public List<Vector2> GetPoints() { //构造OBB //body的方向 Vector2 bodyDir = direction; if (bodyDir != Vector2.Zero) bodyDir.Normalize(); //body的方向 的垂直方向 Vector2 bodyDirC = new Vector2(bodyDir.Y, -bodyDir.X); if (bodyDirC != Vector2.Zero) bodyDirC.Normalize(); Vector2 point1 = bodyDir * height + bodyDirC * width + center; Vector2 point2 = bodyDir * height + -bodyDirC * width + center; Vector2 point3 = -bodyDir * height + -bodyDirC * width + center; Vector2 point4 = -bodyDir * height + bodyDirC * width + center; List<Vector2> points = new List<Vector2>(); points.Add(point1); points.Add(point2); points.Add(point3); points.Add(point4); return points; }
protected override void TickCore(Entity host, RealmTime time, ref object state) { int cooldown; if (state == null) cooldown = 1000; else cooldown = (int)state; Status = CycleStatus.NotStarted; if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return; var player = (Player)host.GetNearestEntity(distance, null); if (player != null) { Vector2 vect; vect = new Vector2(player.X - host.X, player.Y - host.Y); vect.Normalize(); float dist = host.GetSpeed(speed) * (time.thisTickTimes / 1000f); host.ValidateAndMove(host.X + (-vect.X) * dist, host.Y + (-vect.Y) * dist); host.UpdateCount++; if (cooldown <= 0) { Status = CycleStatus.Completed; cooldown = 1000; } else { Status = CycleStatus.InProgress; cooldown -= time.thisTickTimes; } } state = cooldown; }
protected override bool TickCore(RealmTime time) { if (Host.Self.HasConditionEffect(ConditionEffects.Paralyzed)) return true; var speed = this.speed*GetSpeedMultiplier(Host.Self); var dist = radius; var entity = GetNearestEntity(ref dist, objType); if (entity != null && dist > targetRadius) { var tx = entity.X + rand.Next(-2, 2)/2f; var ty = entity.Y + rand.Next(-2, 2)/2f; if (tx != Host.Self.X || ty != Host.Self.Y) { var x = Host.Self.X; var y = Host.Self.Y; var vect = new Vector2(tx, ty) - new Vector2(Host.Self.X, Host.Self.Y); vect.Normalize(); vect *= (speed/1.5f)*(time.thisTickTimes/1000f); ValidateAndMove(Host.Self.X + vect.X, Host.Self.Y + vect.Y); Host.Self.UpdateCount++; } return true; } return false; }
protected override void TickCore(Entity host, RealmTime time, ref object state) { if (!returned) { if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed)) return; var spd = host.GetSpeed(speed) * (time.thisTickTimes / 1000f); Position pos = (host as Enemy).SpawnPoint; var tx = pos.X; var ty = pos.Y; if (Math.Abs(tx - host.X) > 1 || Math.Abs(ty - host.Y) > 1) { var x = host.X; var y = host.Y; Vector2 vect = new Vector2(tx, ty) - new Vector2(host.X, host.Y); vect.Normalize(); vect *= spd; host.Move(host.X + vect.X, host.Y + vect.Y); host.UpdateCount++; } if (host.X == pos.X && host.Y == pos.Y && once) { once = true; returned = true; } } }
protected override bool TickCore(RealmTime time) { if (Host.Self.HasConditionEffect(ConditionEffects.Paralyzed)) return true; var speed = this.speed * GetSpeedMultiplier(Host.Self); float dist = radius; Entity entity = GetNearestEntity(ref dist, objType); Character chr = Host as Character; if (entity != null && chr.HP < threshold) { var x = Host.Self.X; var y = Host.Self.Y; Vector2 vect = new Vector2(entity.X, entity.Y) - new Vector2(Host.Self.X, Host.Self.Y); vect.Normalize(); vect *= -1 * (speed / 1.5f) * (time.thisTickTimes / 1000f); ValidateAndMove(Host.Self.X + vect.X, Host.Self.Y + vect.Y); Host.Self.UpdateCount++; if (!Host.StateStorage.ContainsKey(Key)) { chr.Owner.BroadcastPacket(new ShowEffectPacket() { EffectType = EffectType.Flashing, PosA = new Position() { X = 1, Y = 1000000 }, TargetId = chr.Id, Color = new ARGB(0xff303030) }, null); Host.StateStorage[Key] = true; } return true; } else return false; }
/// <summary> /// 标准化 /// </summary> public static void Normalize(ref Vector2 v2) { if(v2 != Vector2.Zero) { v2 = v2.Normalize(); } }
private void UpdatePoints() { // compute line points Vector2 lineVector = point2 - point1; // get the right vector of the line Vector2 right = new Vector2(-lineVector.Y, lineVector.X); right.Normalize(); Vector2 leftStart = point1 + right * -lineWidth/2f; Vector2 rightStart = point1 + right * lineWidth/2f; Vector2 leftEnd = point2 + right * -lineWidth/2f; Vector2 rightEnd = point2 + right * lineWidth/2f; this.v = new float[] { leftStart.X, leftStart.Y, rightStart.X, rightStart.Y, leftEnd.X, leftEnd.Y, rightStart.X, rightStart.Y, rightEnd.X,rightEnd.Y, leftEnd.X, leftEnd.Y }; this.UpdateVertex(); }
// TODO: Figure out light stuffs public SeaLink(float x, float y, float babies, Vector2 offset) : base(x - offset.X, y - offset.Y, 4, 1.0f) { // Initialize sprite sprite.CenterOrigin(); Graphic = sprite; this.babies = babies; dirStepAmount = 1.3f; // Set up colliders SetHitbox(28, 28, (int)Tags.ENEMY); personalSpace = new CircleCollider((int)(spaceAmount * 0.5), (int)Tags.SEALINK, (int)Tags.ENEMYATTACK); AddCollider(personalSpace); if (offset == Vector2.Zero) { velocity = new Vector2(0, speed); velocity = Util.Rotate(velocity, Rand.Angle); } else { velocity = offset; velocity.Normalize(); velocity = Util.Rotate(velocity, 4); } sprite.Scale = 0.1f; }
/// <summary> /// Cargar valores iniciales del interpolador /// </summary> public void reset() { dir = end - init; distanceToTravel = dir.Length(); dir.Normalize(); current = init; }
public static float Vector2ToRadians(Vector2 velocity) { velocity.Normalize(); // float t1 = (float)Math.Acos(velocity.X / Math.Sqrt(velocity.X * velocity.X + velocity.Y * velocity.Y)); float t1 = (float)Math.Atan2(velocity.Y, velocity.X); return t1; }
protected override void TickCore(Entity host, RealmTime time, ref object state) { var s = (OrbitState) state; Status = CycleStatus.NotStarted; if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return; Entity entity = host.GetNearestEntity(acquireRange, target); if (entity != null) { double angle; if (host.Y == entity.Y && host.X == entity.X) //small offset angle = Math.Atan2(host.Y - entity.Y + (Random.NextDouble()*2 - 1), host.X - entity.X + (Random.NextDouble()*2 - 1)); else angle = Math.Atan2(host.Y - entity.Y, host.X - entity.X); float angularSpd = host.GetSpeed(s.Speed)/s.Radius; angle += angularSpd*(time.thisTickTimes/1000f); double x = entity.X + Math.Cos(angle)*radius; double y = entity.Y + Math.Sin(angle)*radius; Vector2 vect = new Vector2((float) x, (float) y) - new Vector2(host.X, host.Y); vect.Normalize(); vect *= host.GetSpeed(s.Speed)*(time.thisTickTimes/1000f); host.ValidateAndMove(host.X + vect.X, host.Y + vect.Y); host.UpdateCount++; Status = CycleStatus.InProgress; } state = s; }
public void GetLengthAndNormalize() { Vector2 Point3 = new Vector2(3, -4); Assert.IsTrue(Point3.Length > 4.999f && Point3.Length < 5.001f); Point3.Normalize(); Assert.IsTrue(Point3.Length > 0.99f && Point3.Length < 1.01f); }
public void HandleImpostorInput() { Vector2 impostorMove = new Vector2(X, Y); impostorMove -= new Vector2(Global.theGhost.X + (float)Math.Sin(Y * X) * 50, Global.theGhost.Y + (float)Math.Sin(Y * X*X) * 50); impostorMove.Normalize(); MoveInDirection(-impostorMove); ShootInDirection(impostorMove); }
public Projectile(float x, float y, Vector2 direction, float speed, int radius, float lifespan, int damage, params int[] tags) : base(x, y) { direction.Normalize(); this.velocity = direction * speed; this.lifespan = lifespan; Collider = new CircleCollider(radius, tags); Collider.CenterOrigin(); this.damage = damage; }
public override Vector2 Tangent(float t) { var tx = Curve2d.TangentQuadraticBezier(t, v0.x, v1.x, v2.x); var ty = Curve2d.TangentQuadraticBezier(t, v0.y, v1.y, v2.y); // returns unit vector var tangent = new Vector2(tx, ty); tangent.Normalize(); return tangent; }
protected override void Update(TimeSpan gameTime) { var impulse = new Vector2(); impulse = Behaviors.Aggregate(impulse, (current, behavior) => behavior.Apply(current)); if (impulse.Length() > MaxImpulseLength) { impulse.Normalize(); impulse = impulse*MaxImpulseLength; } RigidBody.ApplyLinearImpulse(new Vector3(impulse.X, 0, impulse.Y)); }
public Vector4 CalcTangentVector(Vector3[] position, Vector2[] texCoord, Vector3 normal) { Vector4 tangent; Vector3 edge1 = new Vector3(position[1].X - position[0].X, position[1].Y - position[0].Y, position[1].Z - position[0].Z); Vector3 edge2 = new Vector3(position[2].X - position[1].X, position[2].Y - position[1].Y, position[2].Z - position[1].Z); edge1.Normalize(); edge2.Normalize(); Vector2 texEdge1 = new Vector2(texCoord[1].X - texCoord[0].X, texCoord[1].Y - texCoord[0].Y); Vector2 texEdge2 = new Vector2(texCoord[2].X - texCoord[1].X, texCoord[2].Y - texCoord[1].Y); texEdge1.Normalize(); texEdge2.Normalize(); Vector3 bitangent; float det = (texEdge1.X * texEdge2.Y) - (texEdge1.Y * texEdge2.X); if (Math.Abs(det) < 1e-6f) { tangent.X = 1.0f; tangent.Y = 0.0f; tangent.Z = 0.0f; bitangent = new Vector3(0.0f, 1.0f, 0.0f); } else { det = 1.0f / det; tangent.X = (texEdge2.Y * edge1.X - texEdge1.Y * edge2.X) * det; tangent.Y = (texEdge2.Y * edge1.Y - texEdge1.Y * edge2.Y) * det; tangent.Z = (texEdge2.Y * edge1.Z - texEdge1.Y * edge2.Z) * det; tangent.W = 0.0f; bitangent = new Vector3((-texEdge2.X * edge1.X + texEdge1.X * edge2.X) * det, (-texEdge2.X * edge1.Y + texEdge1.X * edge2.Y) * det, (-texEdge2.X * edge1.Z + texEdge1.X * edge2.Z) * det); tangent.Normalize(); bitangent.Normalize(); } Vector3 n = normal; Vector3 t = new Vector3(tangent.X, tangent.Y, tangent.Z); Vector3 b = Vector3.Cross(n, t); tangent.W = (Vector3.Dot(b, bitangent) < 0.0f) ? -1.0f : 1.0f; return tangent; }
protected override bool TickCore(RealmTime time) { if (Host.Self.HasConditionEffect(ConditionEffects.Paralyzed)) return true; var speed = this.speed * GetSpeedMultiplier(Host.Self); CirclingState state; object o; if (!Host.StateStorage.TryGetValue(Key, out o)) { float dist = sight; Host.StateStorage[Key] = state = new CirclingState() { target = WeakReference<Entity>.Create(GetNearestEntity(ref dist, objType)), angle = (float)(2 * Math.PI * rand.NextDouble()) }; } else { state = (CirclingState)o; state.angle += angularSpeed * (time.thisTickTimes / 1000f); if (!state.target.IsAlive) { Host.StateStorage.Remove(Key); return false; } var target = state.target.Target; if (target == null || target.Owner == null) { Host.StateStorage.Remove(Key); return false; } double x = target.X + Math.Cos(state.angle) * radius; double y = target.Y + Math.Sin(state.angle) * radius; if (x != Host.Self.X || y != Host.Self.Y) { Vector2 vect = new Vector2((float)x, (float)y) - new Vector2(Host.Self.X, Host.Self.Y); vect.Normalize(); vect *= (speed / 1.5f) * (time.thisTickTimes / 1000f); ValidateAndMove(Host.Self.X + vect.X, Host.Self.Y + vect.Y); Host.Self.UpdateCount++; } } if (state.angle >= Math.PI * 2) state.angle -= (float)(Math.PI * 2); return true; }
protected override bool TickCore(RealmTime time) { if (Host.Self.HasConditionEffect(ConditionEffects.Paralyzed)) return true; var speed = this.speed*GetSpeedMultiplier(Host.Self); var pos = (Host as Enemy).SpawnPoint; var tx = pos.X; var ty = pos.Y; if (Math.Abs(tx - Host.Self.X) > 1 || Math.Abs(ty - Host.Self.Y) > 1) { var x = Host.Self.X; var y = Host.Self.Y; var vect = new Vector2(tx, ty) - new Vector2(Host.Self.X, Host.Self.Y); vect.Normalize(); vect *= (speed/1.5f)*(time.thisTickTimes/1000f); ValidateAndMove(Host.Self.X + vect.X, Host.Self.Y + vect.Y); Host.Self.UpdateCount++; return true; } return false; }
protected override bool TickCore(RealmTime time) { if (Host.Self.HasConditionEffect(ConditionEffects.Paralyzed)) return true; var speed = this.speed * GetSpeedMultiplier(Host.Self); float dist = radius; Entity entity = GetNearestEntity(ref dist, objType); object obj; int t; if (Host.StateStorage.TryGetValue(Key, out obj)) t = (int)obj; else t = this.time; if (entity != null && dist > targetRadius && t > 0) { var tx = entity.X + rand.Next(-2, 2) / 2f; var ty = entity.Y + rand.Next(-2, 2) / 2f; if (tx != Host.Self.X || ty != Host.Self.Y) { var x = Host.Self.X; var y = Host.Self.Y; Vector2 vect = new Vector2(tx, ty) - new Vector2(Host.Self.X, Host.Self.Y); vect.Normalize(); vect *= (speed / 1.5f) * (time.thisTickTimes / 1000f); ValidateAndMove(Host.Self.X + vect.X, Host.Self.Y + vect.Y); Host.Self.UpdateCount++; } t -= time.thisTickTimes; Host.StateStorage[Key] = t; return false; } else { t = this.time; Host.StateStorage[Key] = t; return true; } }
protected override bool TickCore(RealmTime time) { if (Host.Self.HasConditionEffect(ConditionEffects.Paralyzed)) return true; var speed = this.speed * GetSpeedMultiplier(Host.Self); float dist = radius; Entity entity = GetNearestEntity(ref dist, objType); Character chr = Host as Character; if (entity != null && (entity.X != Host.Self.X || entity.Y != Host.Self.Y)) { var x = Host.Self.X; var y = Host.Self.Y; Vector2 vect = new Vector2(entity.X, entity.Y) - new Vector2(Host.Self.X, Host.Self.Y); vect.Normalize(); vect *= -1 * (speed / 1.5f) * (time.thisTickTimes / 1000f); ValidateAndMove(Host.Self.X + vect.X, Host.Self.Y + vect.Y); Host.Self.UpdateCount++; return true; } else return false; }
protected override void TickCore(Entity host, RealmTime time, ref object state) { Status = CycleStatus.NotStarted; if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return; var map = host.Owner.Map; var tile = map[(int)host.X, (int)host.Y]; if (tile.Elevation != 0 && tile.Elevation < altitude) { Vector2 vect; vect = new Vector2(map.Width / 2 - host.X, map.Height / 2 - host.Y); vect.Normalize(); float dist = host.GetSpeed(speed) * (time.thisTickTimes / 1000f); host.ValidateAndMove(host.X + vect.X * dist, host.Y + vect.Y * dist); host.UpdateCount++; Status = CycleStatus.InProgress; } else Status = CycleStatus.Completed; }
protected override bool TickCore(RealmTime time) { if (Host.Self.HasConditionEffect(ConditionEffects.Paralyzed)) return true; var speed = this.speed * GetSpeedMultiplier(Host.Self); Position target; object o; if (!Host.StateStorage.TryGetValue(Key, out o)) { float dist = radius; var entity = GetNearestEntity(ref dist, objType); if (entity == null) return true; Host.StateStorage[Key] = target = new Position() { X = entity.X, Y = entity.Y }; } else target = (Position)o; if (target.X != Host.Self.X || target.Y != Host.Self.Y) { Vector2 vect = new Vector2((float)target.X, (float)target.Y) - new Vector2(Host.Self.X, Host.Self.Y); vect.Normalize(); vect *= (speed / 1.5f) * (time.thisTickTimes / 1000f); ValidateAndMove(Host.Self.X + vect.X, Host.Self.Y + vect.Y); Host.Self.UpdateCount++; } if (Dist(Host.Self.X, Host.Self.Y, target.X, target.Y) < 1) { Host.StateStorage.Remove(Key); return true; } else return false; }
public override void Update() { base.Update(); // Fly towards player Vector2 VectorToPlayer = new Vector2(Global.theGhost.X - X, Global.theGhost.Y - Y - 10); if(VectorToPlayer.Length < 2) { Global.Score++; Sound bip = new Sound(Assets.SFX_GET); bip.Volume = 0.6f; bip.Pitch = Rand.Float(0.8f, 1.2f); bip.Play(); RemoveSelf(); //Global.theMusic.Pitch += 0.01f; } VectorToPlayer.Normalize(); X += VectorToPlayer.X * 3; Y += VectorToPlayer.Y * 3; }
public Ink(float x, float y, float angle) : base(x, y) { // Init sprite sprite.Add(AnimType.Go, new Anim(new int[] { 0, 1, 2 }, new float[] { 8.0f })); sprite.Play(AnimType.Go); sprite.CenterOrigin(); sprite.Angle = angle; offset = Util.Rotate(offset, sprite.Angle); sprite.OriginX += offset.X; sprite.OriginY += offset.Y; offset.Normalize(); offset *= 2.7f; Graphic = sprite; // Set up collider Collider = new CircleCollider(250, (int)Tags.INK); Collider.CenterOrigin(); // Get that sound snd.Volume = 0.01f; snd.Play(); }
protected override bool TickCore(RealmTime time) { if (Host.Self.HasConditionEffect(ConditionEffects.Paralyzed)) return true; var speed = this.speed * GetSpeedMultiplier(Host.Self); CirclingState state; object o; if (!Host.StateStorage.TryGetValue(Key, out o)) { var dist = radius; Host.StateStorage[Key] = state = new CirclingState { center = new Position { X = Host.Self.X, Y = Host.Self.Y }, angle = (float)(2 * Math.PI * rand.NextDouble()) }; } else { state = (CirclingState)o; state.angle += angularSpeed * (time.thisTickTimes / 1000f); var x = state.center.X + Math.Cos(state.angle) * radius; var y = state.center.Y + Math.Sin(state.angle) * radius; if (x != Host.Self.X && y != Host.Self.Y) { var vect = new Vector2((float)x, (float)y) - new Vector2(Host.Self.X, Host.Self.Y); vect.Normalize(); vect *= speed / 1.5f * (time.thisTickTimes / 1000f); ValidateAndMove(Host.Self.X + vect.X, Host.Self.Y + vect.Y); Host.Self.UpdateCount++; } } if (state.angle >= Math.PI * 2) state.angle -= (float)(Math.PI * 2); return true; }
public static Vector3[] CreateCurve(Vector3[] roadLine, int Segments, float Offset, bool Invert) { Vector2[] roadCurve = Misc.GetBezierApproximation(roadLine.Select(p=>p.Xz).ToArray(), Segments); Vector2[] heightLine = new Vector2[roadLine.Length]; Vector2 prevPoint = roadLine[0].Xz; for (int i = 0; i < heightLine.Length; i++) { heightLine[i] = new Vector2((roadLine[i].Xz - prevPoint).Length, roadLine[i].Y); prevPoint = roadLine[i].Xz; } Vector2[] heightCurve = Misc.GetBezierApproximation(heightLine, Segments); Vector3[] PathNodes = new Vector3[Segments + 1]; for (int i = 0; i < Segments + 1; i++) { Vector2 dir = new Vector2(); if (i== 0) dir = (roadCurve[i] - roadCurve[i+1]); else if (i == Segments) dir = (roadCurve[i - 1] - roadCurve[i]); else dir = (roadCurve[i - 1] - roadCurve[i]) + (roadCurve[i] - roadCurve[i + 1]); dir.Normalize(); dir *= Offset; PathNodes[(Invert) ? Segments - i : i] = new Vector3(roadCurve[i].X + dir.Y, heightCurve[i].Y, roadCurve[i].Y - dir.X); } return PathNodes; }
protected override void TickCore(Entity host, RealmTime time, ref object state) { if (instant) return; if (!returned) { if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed)) return; var spd = host.GetSpeed(speed) * (time.thisTickTimes / 1000f); if (Math.Abs(X - host.X) > 0.5 || Math.Abs(Y - host.Y) > 0.5) { Vector2 vect = new Vector2(X, Y) - new Vector2(host.X, host.Y); vect.Normalize(); vect *= spd; host.Move(host.X + vect.X, host.Y + vect.Y); host.UpdateCount++; if (host.X == X && host.Y == Y && once) { once = true; returned = true; } } } }
public void Build(Map currentMap) { List<Vector3> BezierCurve = new List<Vector3>(); List<Node> PointsForPath = new List<Node>(); Vector3[] BezierControlPoints = new Vector3[4]; Vector2 dir = new Vector2(); Node first = FirstEndpoint.getPosition(currentMap.ObjectCollection); if (first != null) { dir = Misc.getCartesian(first.Rotation.Y); first.Rotation = new Vector3(dir.X, 0, dir.Y); PointsForPath.Add(first); // First endpoint exists, so add it to the list } PointsForPath.AddRange(Points); Node last = LastEndpoint.getPosition(currentMap.ObjectCollection); if (last != null) { // Set rotation for the last endpoint dir = Misc.getCartesian(last.Rotation.Y); last.Rotation = new Vector3(-dir.X, 0, -dir.Y); PointsForPath.Add(last); // Last endpoint exists, so add it to the list } for (int i = 0; i < PointsForPath.Count; i++) { if((i > 0 || first == null)&&(i < PointsForPath.Count-1 || last == null)) { if (i == 0) dir = PointsForPath[i + 1].Location.Xz - PointsForPath[i].Location.Xz; else if(i == PointsForPath.Count - 1) dir = PointsForPath[i].Location.Xz - PointsForPath[i - 1].Location.Xz; else { dir = (PointsForPath[i].Location.Xz - PointsForPath[i - 1].Location.Xz); dir += (PointsForPath[i + 1].Location.Xz - PointsForPath[i].Location.Xz); } dir.Normalize(); PointsForPath[i].Rotation = new Vector3(dir.X, 0, dir.Y); } } for (int i = 0; i < PointsForPath.Count - 1; i++) { float segments = (PointsForPath[i + 1].Location.Xz - PointsForPath[i].Location.Xz).Length * 0.25f; BezierControlPoints[0] = PointsForPath[i].Location; BezierControlPoints[1] = PointsForPath[i].Location + (PointsForPath[i].Rotation*segments); BezierControlPoints[2] = PointsForPath[i + 1].Location - (PointsForPath[i + 1].Rotation*segments); BezierControlPoints[3] = PointsForPath[i + 1].Location; Vector3[] roadEdgeRight = CreateCurve(BezierControlPoints, (int)segments, RoadWidth/2, false); Vector3[] roadEdgeLeft = CreateCurve(BezierControlPoints, (int)segments, -RoadWidth/2, false); for (int j = 0; j < roadEdgeLeft.Length; j++) { BezierCurve.Add(roadEdgeLeft[j]); BezierCurve.Add(roadEdgeRight[j]); } } Vector3[] Vertices = new Vector3[BezierCurve.Count * 2]; int[] Indices = new int[(BezierCurve.Count) * 3]; Vector2[] TextureCoordinates = new Vector2[BezierCurve.Count * 2]; for (int i = 0; i < (BezierCurve.Count/2)-1; i++) { Indices[(i * 6) + 0] = (i * 2) + 0; Indices[(i * 6) + 1] = (i * 2) + 1; Indices[(i * 6) + 2] = (i * 2) + 2; Indices[(i * 6) + 3] = (i * 2) + 2; Indices[(i * 6) + 4] = (i * 2) + 1; Indices[(i * 6) + 5] = (i * 2) + 3; Vertices[(i * 2) + 0] = BezierCurve[(i * 2) + 0]; Vertices[(i * 2) + 1] = BezierCurve[(i * 2) + 1]; Vertices[(i * 2) + 2] = BezierCurve[(i * 2) + 2]; Vertices[(i * 2) + 3] = BezierCurve[(i * 2) + 3]; TextureCoordinates[(i * 4) + 0] = new Vector2(1, 0); TextureCoordinates[(i * 4) + 1] = new Vector2(0, 0); TextureCoordinates[(i * 4) + 2] = new Vector2(1, 0.2f); TextureCoordinates[(i * 4) + 3] = new Vector2(0, 0.2f); } RoadMesh.GenerateCollisionShape = !Graphics.StaticView; RoadMesh.Load(BezierCurve.ToArray(), Indices, TextureName, TextureCoordinates); if (!Graphics.StaticView) { RoadSurface = World.CreateRigidBody(0, Matrix4.Identity, RoadMesh.GetCollisionShape()); if (!Tools.PhysicsDebugDrawer.DrawRoads) RoadSurface.CollisionFlags |= CollisionFlags.DisableVisualizeObject; } }
public static Vector2 MinLength(Vector2 value, float minLength) => value.Length() < minLength?Vector2.Normalize(value) * minLength : value;
public static Vector2 MaxLength(Vector2 value, float maxLength) => value.Length() > maxLength?Vector2.Normalize(value) * maxLength : value;
/// <summary> /// Moves towards the order target /// </summary> private void UpdateMoveToOrder() { if (Vector2.Distance(this.MapPosition, this.OrderPosition) < OrderRange) { State = GameObjectState.DoOrder; return; } Vector2 direction = this.OrderPosition - this.MapPosition; Vector2 ort = new Vector2(-direction.Y, direction.X); if (Math.Abs(direction.X) > Math.Abs(direction.Y) && Math.Sign(direction.X) != Math.Sign(ort.X) || Math.Abs(direction.X) < Math.Abs(direction.Y) && Math.Sign(direction.Y) != Math.Sign(ort.Y)) ort *= -1; direction.Normalize(); ort.Normalize(); Vector2[] moveAttempts = new Vector2[3]; moveAttempts[0] = direction * 0.5f * entry.Speed; moveAttempts[1] = ort * 0.5f * entry.Speed; moveAttempts[2] = ort * -0.5f * entry.Speed; Vector2 moveAttempt = direction * 0.5f * entry.Speed; bool success = false; for (int i = 0; i < 3; i++) { Tile newTile = game.Map.GetTileFlat(this.MapPosition + moveAttempts[i] * 3); if (newTile == null) continue; if (NearestTile == null) { Debug.Assert(RecalculatePosition); return; } if ((Math.Abs(newTile.Elevation - NearestTile.Elevation) > MapBoard.CLIFF_THRESHOLD)) continue; if ((newTile.Elevation < MapBoard.SEA_LEVEL)) continue; else { moveAttempt = moveAttempts[i]; success = true; break; } } if (success) { this.MapPosition = this.MapPosition + moveAttempt; this.RecalculatePosition = true; } else { CancelOrders(true); } }