private void TurnTowards(float seconds, Vector2 target)
{
float targetAngle = this.GetClosestPointAtAngleInRange(target);
float currentAngle = Vector2Utils.MinimizeMagnitude(this.TurretDirectionRelativeToSelf);
float maxAngleChange = seconds * this.AngularSpeed;
if (this.Range >= Math.PI)
{
this.TurretDirectionRelativeToSelf = PhysicsUtils.AngularMoveTowardBounded(currentAngle, targetAngle, maxAngleChange);
}
else
{
if (Math.Abs(currentAngle - targetAngle) <= maxAngleChange)
{
this.TurretDirectionRelativeToSelf = targetAngle;
}
else if (targetAngle < currentAngle)
{
this.TurretDirectionRelativeToSelf = currentAngle - maxAngleChange;
}
else
{
this.TurretDirectionRelativeToSelf = currentAngle + maxAngleChange;
}
}
}
private void DrawRollingFrictionGizmo(Vector2 locationIn2DSpace, Color gizmoColor)
{
Vector2 correctedRollingFrictionForce = Vector2Utils.GetRotatedVelocityVector(GetRollingFriction(), transform.rotation.eulerAngles.z) * GIZMO_SCALE;
Gizmos.color = gizmoColor;
Gizmos.DrawLine(locationIn2DSpace, locationIn2DSpace + correctedRollingFrictionForce);
}
public void DrawLine(Vector2 point1, Vector2 point2, Color color, double depth)
{
Vector2 scale = new Vector2((float)Math.Sqrt((point2 - point1).LengthSquared()), 1);
float rotation = (float)Vector2Utils.Vector2Angle(point2 - point1);
spriteBatch.Draw(point, point1, null, color, rotation, new Vector2(0), scale, SpriteEffects.None, (float)depth);
}
private void UpdatePosition()
{
if (moveByArc)
{
if (count < 1.0f && movingToPoint)
{
count += moveSpeed * Time.deltaTime;
Vector3 m1 = Vector2.Lerp(startPosition, middlePoint, count);
Vector3 m2 = Vector2.Lerp(middlePoint, targetPosition, count);
transform.position = Vector2.Lerp(m1, m2, count);
var rotation = Vector2Utils.CalculateFacingToTarget(m1, m2).angle;
transform.rotation = rotation;
}
}
else
{
if (transform.position != new Vector3(targetPosition.x, targetPosition.y, 0) && movingToPoint)
{
transform.position = Vector3.Lerp(transform.position, targetPosition, Time.deltaTime * moveSpeed);
}
else
{
movingToPoint = true;
}
}
}
private static Vector2[] GetCorners(Collider2D c)
{
if (c is BoxCollider2D box)
{
Vector2 size = box.size * 0.5f;
return(new Vector2[4] {
box.transform.TransformPoint(new Vector3(size.x, size.y)),
box.transform.TransformPoint(new Vector3(-size.x, size.y)),
box.transform.TransformPoint(new Vector3(size.x, -size.y)),
box.transform.TransformPoint(new Vector3(-size.x, -size.y))
});
}
if (c is CircleCollider2D circle)
{
float radius = circle.radius;
var results = new List <Vector2>();
for (int i = 0; i < 360; i += 10)
{
results.Add(circle.transform.TransformPoint(Vector2Utils.FromAngle(i) * radius));
//Debug.DrawLine(Vector3.zero, Vector2Utils.FromAngle(i) * radius, Color.white, 20f);
}
return(results.ToArray());
}
return(new Vector2[0]);
}
protected override async ValueTask UpdateCore(GameContext game)
{
if (_path is null || (!_path.Any() && _currPathNode is null))
{
return;
}
_currPathNode ??= _path.Next();
var tilePos = _mapRenderer.GetTilePos(_currPathNode);
var newPos = Vector2Utils.MoveTowards(_transform.World.Position, tilePos, Speed);
_transform.Local.Position = newPos;
var dist = Vector2.DistanceSquared(newPos, tilePos);
if (dist < Speed)
{
_currPathNode = null;
_transform.Local.Position = tilePos;
if (!_path.Any())
{
_path = null;
OnArrived?.Invoke(this);
}
}
}
public void explode(float force, Vector3 explosionPosition)
{
//if fragments were not created before runtime then create them now
if (fragments.Count == 0 && allowRuntimeFragmentation)
{
generateFragments();
}
//otherwise unparent and activate them
else
{
foreach (GameObject frag in fragments)
{
frag.transform.parent = null;
frag.SetActive(true);
}
}
//if fragments exist destroy the original
if (fragments.Count > 0)
{
Destroy(gameObject);
if (force > 0)
{
foreach (GameObject gameObject in fragments)
{
Rigidbody2D rigidbody2d = gameObject.GetComponent <Rigidbody2D>();
Vector3 v3Difference = gameObject.transform.position - explosionPosition;
Vector2 difference = new Vector2(v3Difference.x, v3Difference.y);
Vector2 newDirection = Vector2Utils.GetSmallVariation(difference.normalized, 5);
rigidbody2d.AddForce(newDirection.normalized * force, ForceMode2D.Impulse);
}
}
}
}
void Start()
{
startposition = transform.position;
var angle = transform.eulerAngles.z;
body = GetComponent <Rigidbody2D>();
body.velocity = Vector2Utils.CreateVector(Speed, angle * Mathf.Deg2Rad);
}
public Boolean IsPointedAt(Vector2 target, float errorDistance)
{
Vector2 worldPosition = this.WorldPosition();
float angle = Vector2Utils.ShortestAngleDistance(Vector2Utils.Vector2Angle(target - worldPosition), this.WorldDirection());
float distanceToTarget = Vector2.Distance(target, worldPosition);
return(Math.Abs(angle) <= Math.PI / 2 && Math.Abs((float)(Math.Sin(angle) * distanceToTarget)) < errorDistance);
}
public void Shoot()
{
var instance = Instantiate(bullet, transform.position, Quaternion.Inverse(transform.rotation));
var rb = instance.GetComponent <Rigidbody2D>();
rb.velocity = Vector2Utils.Rotate(Vector2.up, rb.rotation) * bulletSpeed;
instance.shooterCollider = shooterCollider;
instance.shooterTag = shooterTag;
}
private void AdjustBone(SkeletonInputs inputs, Bone bone, Vector2 source, Vector2 target, float weight)
{
var transform = bone.GetChainedTransform(inputs);
var center = Matrix3x2.TransformPoint(transform, bone.Center);
float rotationDelta = Vector2Utils.AngleBetween(source - center, target - center);
bone.IncrementRotation(inputs, rotationDelta * weight);
}
private void ShootRay()
{
var instance = Instantiate(ShootingAbility.bullet, transform.position, Quaternion.Inverse(transform.rotation));
var rb = instance.GetComponent <Rigidbody2D>();
rb.velocity = Vector2Utils.Rotate(Vector2.up, rb.rotation) * ShootingAbility.speed;
instance.damage = damage;
instance.shooterCollider = shooterCollider;
instance.shooterTag = shooterTag;
}
public void DrawRectangle(Vector2 position, Vector2 size, Vector2 center, double rotation, Color color, double depth)
{
Vector2 point1 = position + Vector2Utils.RotateVector2(-center, rotation);
Vector2 point2 = point1 + Vector2Utils.RotateVector2(new Vector2(size.X, 0), rotation);
Vector2 point3 = point1 + Vector2Utils.RotateVector2(size, rotation);
Vector2 point4 = point1 + Vector2Utils.RotateVector2(new Vector2(0, size.Y), rotation);
DrawLine(point1, point2, color, depth);
DrawLine(point2, point3, color, depth);
DrawLine(point3, point4, color, depth);
DrawLine(point4, point1, color, depth);
}
private void DrawBrakingFrictionGizmo(Vector2 locationIn2DSpace, Color noGripGizmoColor, Color maxGripGizmoColor)
{
float minFrictionCoefficient = _tyreData.MinFrictionCoefficient() * (IsTyreRolling ? _tyreData.ForwardsFrictionCoefficient : _tyreData.SidewaysFrictionCoefficient);
float maxFrictionCoefficient = _tyreData.MaxFrictionCoefficient() * (IsTyreRolling ? _tyreData.ForwardsFrictionCoefficient : _tyreData.SidewaysFrictionCoefficient);
float currentRelativeCoefficient = ((IsTyreRolling ? _forwardsGripCoefficient : _lockedBrakesGripCoefficient) - minFrictionCoefficient) / (maxFrictionCoefficient - minFrictionCoefficient);
Gizmos.color = Color.Lerp(noGripGizmoColor, maxGripGizmoColor, currentRelativeCoefficient);
Vector2 correctedBrakingFrictionForce = Vector2Utils.GetRotatedVelocityVector(GetBrakingFriction(), transform.rotation.eulerAngles.z) * GIZMO_SCALE;
Gizmos.DrawLine(locationIn2DSpace, locationIn2DSpace + correctedBrakingFrictionForce);
}
private void OnCollisionEnter2D(Collision2D other)
{
if (!other.gameObject.CompareTag("Reflective"))
{
return;
}
Vector2 reflected = Vector3.Reflect(Vector2Utils.CreateVector(1, Angle * Mathf.Deg2Rad),
other.GetContact(0).normal);
Angle = reflected.GetAngle() * Mathf.Rad2Deg;
OnHitShield();
}
public static List <Vector2> GetPointsInArc(float fovAngle, float fovDistance, float offsetAngle, Vector2 origin, int resolution)
{
var results = new List <Vector2>();
float startAngle = offsetAngle + fovAngle * 0.5f;
for (int i = 0; i <= resolution; i++)
{
float angle = startAngle - i * (fovAngle / resolution);
results.Add(Vector2Utils.FromAngle(angle) * fovDistance + origin);
}
return(results);
}
public void DrawCircle(Vector2 center, double radius, Color color, double depth)
{
int maxSegments = 50;
//int segmentSize = 5;
int segments = maxSegments;
for (int i = 0; i < segments; i++)
{
Vector2 point1 = Vector2Utils.ConstructVectorFromPolar(radius, i * (2 * Math.PI / segments)) + center;
Vector2 point2 = Vector2Utils.ConstructVectorFromPolar(radius, ((i + 1) % segments) * (2 * Math.PI / segments)) + center;
DrawLine(point1, point2, color, depth);
}
}
public void TestAngleBetween()
{
Assert.AreEqual(0, Vector2Utils.AngleBetween(+Vector2.UnitX, +Vector2.UnitX), 1e-6f);
Assert.AreEqual(MathUtil.PiOverFour, Vector2Utils.AngleBetween(+Vector2.UnitX, new Vector2(1, 1)), 1e-6f);
Assert.AreEqual(MathUtil.PiOverTwo, Vector2Utils.AngleBetween(+Vector2.UnitX, +Vector2.UnitY), 1e-6f);
Assert.AreEqual(MathUtil.PiOverTwo, Vector2Utils.AngleBetween(+Vector2.UnitY, -Vector2.UnitX), 1e-6f);
Assert.AreEqual(MathUtil.PiOverTwo, Vector2Utils.AngleBetween(-Vector2.UnitX, -Vector2.UnitY), 1e-6f);
Assert.AreEqual(MathUtil.PiOverTwo, Vector2Utils.AngleBetween(-Vector2.UnitY, +Vector2.UnitX), 1e-6f);
Assert.AreEqual(-MathUtil.PiOverTwo, Vector2Utils.AngleBetween(+Vector2.UnitY, +Vector2.UnitX), 1e-6f);
Assert.AreEqual(-MathUtil.PiOverTwo, Vector2Utils.AngleBetween(-Vector2.UnitX, +Vector2.UnitY), 1e-6f);
Assert.AreEqual(-MathUtil.PiOverTwo, Vector2Utils.AngleBetween(-Vector2.UnitY, -Vector2.UnitX), 1e-6f);
Assert.AreEqual(-MathUtil.PiOverTwo, Vector2Utils.AngleBetween(+Vector2.UnitX, -Vector2.UnitY), 1e-6f);
}
public float GetClosestPointAtAngleInRange(Vector2 target)
{
PhysicalObject parent = ((PhysicalObject)(this.Parent));
if (parent != null)
{
float worldDirection = Vector2Utils.Vector2Angle(target - this.WorldPosition());
float targetAngleRelativeToParent = worldDirection - parent.WorldDirection() - this.DirectionRelativeToParent;
return(MathUtils.ClosestInRange(Vector2Utils.MinimizeMagnitude(targetAngleRelativeToParent), this.Range, -this.Range));
}
else
{
return(0);
}
}
private void ShootToTarget(Transform target)
{
var(angle, directionalVector) = Vector2Utils.CalculateFacingToTarget(transform.position, target.position);
var instance = Instantiate(ShootingAbility.bullet, transform.position, angle);
var rb = instance.GetComponent <Rigidbody2D>();
if (gunObject != null)
{
gunObject.transform.right = target.position - gunObject.transform.position;
gunObject.transform.Rotate(new Vector3(0, 0, -90));
}
rb.velocity = directionalVector * ShootingAbility.speed;
instance.damage = damage;
instance.shooterCollider = shooterCollider;
instance.shooterTag = shooterTag;
}
public static List <Vector2> GetFilteredPoints(float fovAngle, float fovDistance, float offsetAngle, Vector2 origin)
{
var results = new List <Vector2>();
var forward = Vector2Utils.FromAngle(offsetAngle);
float distanceSqr = fovDistance * fovDistance;
float halfAngle = fovAngle * 0.5f;
foreach (var p in ObstacleManager.Corners)
{
Vector2 direction = (p - origin);
if (Vector2.Angle(direction, forward) < halfAngle && direction.sqrMagnitude < distanceSqr)
{
results.Add(p);
}
}
return(results);
}
private void OnDrawGizmos()
{
Vector2 intersection = new Vector2();
//Apron.LineIntersection(
//To2D(transform.position), To2D(transform.forward),
//To2D(other.position), To2D(other.forward), ref intersection);
Vector2Utils.RayRayIntersection(To2D(transform.position), To2D(transform.forward),
To2D(other.position), To2D(other.forward), ref intersection);
Gizmos.DrawLine(transform.position - transform.forward * 1000,
transform.position + transform.forward * 1000);
Gizmos.DrawLine(other.position - other.forward * 1000,
other.position + other.forward * 1000);
Gizmos.DrawWireSphere(new Vector3(intersection.x, 0, intersection.y), 1 * 100);
}
public static FabrIkChain Make(SkeletonInputs inputs, Bone sourceBone, Vector2 unposedSource, Vector2 target)
{
Vector2 posedSource = Matrix3x2.TransformPoint(sourceBone.GetChainedTransform(inputs), sourceBone.End);
List <Bone> bones = new List <Bone> {
};
List <Vector2> unposedBoneVectors = new List <Vector2> {
};
List <float> rotations = new List <float>();
List <Vector2> positions = new List <Vector2> {
};
positions.Add(posedSource);
Vector2 previousUnposedPosition = unposedSource;
Vector2 previousPosedPosition = posedSource;
for (var bone = sourceBone; bone != null; bone = bone.Parent)
{
var unposedCenter = bone.Center;
var posedCenter = Matrix3x2.TransformPoint(bone.GetChainedTransform(inputs), unposedCenter);
Vector2 unposedBoneVector = previousUnposedPosition - unposedCenter;
Vector2 posedBoneVector = previousPosedPosition - posedCenter;
float rotation = Vector2Utils.AngleBetween(
unposedBoneVector,
posedBoneVector);
bones.Add(bone);
unposedBoneVectors.Add(unposedBoneVector);
rotations.Add(rotation);
positions.Add(posedCenter);
previousUnposedPosition = unposedCenter;
previousPosedPosition = posedCenter;
}
var startTarget = target;
var endTarget = positions[bones.Count];
return(new FabrIkChain(bones, unposedBoneVectors, rotations, positions, target, endTarget));
}
public override Vector2 WorldPosition()
{
if (this.Parent == null)
{
return(new Vector2(0));
}
else
{
PhysicalObject parentObj = (PhysicalObject)this.Parent;
if (parentObj != null)
{
return(Vector2Utils.RotateVector2(this.PositionRelativeToParent, parentObj.WorldDirection()) + parentObj.WorldPosition());
}
else
{
return(new Vector2(float.NaN));
}
}
}
protected override async ValueTask UpdateCore(GameContext game)
{
var dt = (float)game.GameTime.ElapsedMilliseconds / 1000;
_rotationVelocity += RotationSpeed * dt;
_rotationVelocity *= (1f - dt * RotationDrag);
_transform.Local.Rotation += _rotationVelocity * dt;
var dir = new Vector2(MathF.Sin(_transform.Local.Rotation), -MathF.Cos(_transform.Local.Rotation));
var traction = dir * this.Thrust;
var acceleration = traction / Mass;
_velocity += acceleration * dt;
_velocity *= (1 - dt * Drag);
_velocity = Vector2Utils.ClampMagnitude(ref _velocity, MaxSpeed);
_transform.Local.Position += _velocity * dt;
}
public override void Handle(Microsoft.Xna.Framework.GameTime elapsedTime)
{
base.Handle(elapsedTime);
if (Vector2Utils.ShortestAngleDistance(obj.Direction, Vector2Utils.Vector2Angle(followObj.Position - obj.Position)) < (Math.PI / 20))
{
if (!fire)
{
//((NPCShip)obj).FireCoaxialWeapon();
//fire = true;
}
}
// Switch states if we are too close for engagement.
if ((followObj.Position - obj.Position).Length() < 500)
{
// TODO: Dangerous convert...fix this
this.Context.AddState(new ClearTargetState((NPCBasicAttackStrategy)this.Context, (NPCShip)this.obj, this.followObj));
this.Context.RemoveState(this);
}
}
void FixedUpdate()
{
if (VisibleObject.IsVisible && Player)
{
RotateTowardsPlayer(Time.deltaTime);
transform.position += new Vector3(Random.Range(-5f, 5f), Random.Range(-5f, 5f), 0) * Time.deltaTime;
ShotCooldown -= Time.deltaTime;
if (ShotCooldown <= 0)
{
Instantiate(Burst, LookAhead.transform.position, transform.rotation, transform.parent);
Vector2 direction = Vector2Utils.Vector2FromAngle(Body.rotation + Random.Range(-15f, 15f));
ShotController shot = Instantiate(Shot, LookAhead.transform.position, transform.rotation, transform.parent).GetComponent <ShotController>();
shot.Fire(direction, Body.velocity, ShootPower);
ShotCooldown = MaxShootCooldown + Random.Range(-0.15f, 0.15f);
}
}
}
private Projection projectOnAxis(ConvexShape shape, Vector2 axis)
{
float min = Vector2Utils.DotProduct(axis, shape.Points[0]);
float max = min;
for (int i = 1; i < shape.Points.Count; i++)
{
float p = Vector2Utils.DotProduct(axis, shape.Points[i]);
if (p < min)
{
min = p;
}
else if (p > max)
{
max = p;
}
}
return(new Projection(min, max));
}
//From end-effector to root
public void DoForwardPass()
{
Vector2 targetEnd = firstTargetEnd;
for (int boneIdx = 0; boneIdx < bones.Count; ++boneIdx)
{
Vector2 currentEnd = positions[boneIdx];
Vector2 currentCenter = positions[boneIdx + 1];
float targetRotationDelta = Vector2Utils.AngleBetween(
currentEnd - currentCenter,
targetEnd - currentCenter);
float unconstrainedTargetRotation = rotations[boneIdx] + targetRotationDelta;
float targetRotation = ConstrainRotationAgainstChild(boneIdx, unconstrainedTargetRotation);
Vector2 targetCenter = targetEnd - Vector2Utils.RotateBy(targetRotation, unposedBoneVectors[boneIdx]);
positions[boneIdx] = targetEnd;
rotations[boneIdx] = targetRotation;
targetEnd = targetCenter;
}
positions[bones.Count] = targetEnd;
}
// From root to end-effector
public void DoBackwardPass()
{
Vector2 targetCenter = lastTargetCenter;
for (int boneIdx = bones.Count - 1; boneIdx >= 0; --boneIdx)
{
Vector2 currentEnd = positions[boneIdx];
Vector2 currentCenter = positions[boneIdx + 1];
float targetRotationDelta = Vector2Utils.AngleBetween(
currentEnd - currentCenter,
currentEnd - targetCenter);
float unconstrainedTargetRotation = rotations[boneIdx] + targetRotationDelta;
float targetRotation = ConstraintRotationAgainstParent(boneIdx, unconstrainedTargetRotation);
Vector2 targetEnd = targetCenter + Vector2Utils.RotateBy(targetRotation, unposedBoneVectors[boneIdx]);
positions[boneIdx + 1] = targetCenter;
rotations[boneIdx] = targetRotation;
targetCenter = targetEnd;
}
positions[0] = targetCenter;
}
