protected override void OnUpdate(TimeSlice time)
{
base.OnUpdate(time);
var targetPosition = this.targetPosition;
if (null != target)
{
targetPosition.x += target.transform.position.x;
targetPosition.y += target.transform.position.y;
}
var degreeAngle = AngleUtils.Vector2ToDegreeAngle(new Vector2(targetPosition.x - transform.position.x, targetPosition.y - transform.position.y));
rotationObject.transform.eulerAngles = new Vector3(0, 0, -degreeAngle);
switch (layoutType)
{
case LayoutType.None:
break;
}
if (cutoffDistance > 0)
{
if (null == parentObject)
{
Debug.Log("Error. Parent object required for cutoff");
return;
}
var distance = AngleUtils.Distance(parentObject.transform.position, targetPosition);
Cutoff(distance <= cutoffDistance);
}
}
public void OnInputMove(InputAction.CallbackContext context)
{
if (!CanMove())
{
return;
}
if (null == node || null == boardRunner)
{
return;
}
//Debug.Log("Input Move: " + context.ToString());
var axisVector = context.ReadValue <Vector2>();
var distance = AngleUtils.Distance(Vector2.zero, axisVector);
if (distance <= deadZone)
{
return;
}
var angle = AngleUtils.Vector2ToDegreeAngle(axisVector);
var direction = MapUtils.DegreeAngleToMapDirection(angle, axisLimit);
var moveResult = boardRunner.MovePiece(node.piece, direction, moveTime);
OnMoveResult(node, direction, moveResult);
}
protected virtual void Update()
{
switch (stateMachine.State)
{
case StateType.Arrived:
return;
}
var node = GetComponent <Node2D>();
if (null == node)
{
return;
}
var distanceToTarget = AngleUtils.Distance(new Vector2(transform.position.x, transform.position.y), waypoint);
if (distanceToTarget <= arriveDistance)
{
stateMachine.State = StateType.Arrived;
node.Velocity = Vector2.zero;
return;
}
var degreeAngle = AngleUtils.Vector2ToDegreeAngle(new Vector2(waypoint.x - transform.position.x, waypoint.y - transform.position.y));
node.Velocity = AngleUtils.DegreeAngleToVector2(degreeAngle, velocity);
switch (orientType)
{
case OrientType.Rotate:
node.RotationDegreeAngle = degreeAngle;
break;
}
}
public void TestAngleUtils_ClipAngle()
{
Assert.AreEqual(1, AngleUtils.ClipDegreeAngle(361));
Assert.AreEqual(0, AngleUtils.ClipDegreeAngle(-360));
Assert.AreEqual(359, AngleUtils.ClipDegreeAngle(-361));
Assert.AreEqual(0, AngleUtils.ClipDegreeAngle(-720));
}
public void OnInputMove(InputAction.CallbackContext context)
{
if (null == node)
{
return;
}
// Don't use Node2D Velocity (it is constant). Use rigidbody velocity, which decays
// This results in more fluid movement
node.VelocityType = Node2D.MoveType.None;
//Debug.Log("Input Move: " + context.ToString());
var angleAxisLimiter = new AngleAxisLimiter2D(axisLimit);
var rigidbody = node.GetComponent <Rigidbody2D>();
var axisVector = context.ReadValue <Vector2>();
var angle = AngleUtils.Vector2ToDegreeAngle(axisVector);
var distance = AngleUtils.Distance(Vector2.zero, axisVector);
if (distance <= deadZone)
{
rigidbody.velocity = Vector2.zero;
return;
}
var factor = (distance - deadZone) / (1.0f - deadZone);
var interpolatedFactor = interpolate.Transform(factor);
var moveSpeed = minMoveSpeed + ((maxMoveSpeed - minMoveSpeed) * interpolatedFactor);
var limitedAngle = angleAxisLimiter.LimitAngle(angle);
var velocity = AngleUtils.DegreeAngleToVector2(limitedAngle, moveSpeed);
rigidbody.velocity = velocity;
}
protected virtual void OnTriggerStay2D(Collider2D collider)
{
var colliderObject = collider.gameObject;
var colliderWorldCenter = colliderObject.transform.position;
var thisWorldCenter = transform.position;
var distance = AngleUtils.Distance(colliderWorldCenter, thisWorldCenter);
//Debug.Log("Trigger Gravity collider: " + colliderWorldCenter.ToString() + " well: " + thisWorldCenter.ToString() + " Distance: " + distance.ToString());
if (distance > radius)
{
return;
}
// Avoid divide by zero
if (distance == 0 || radius == 0)
{
return;
}
var rigidbody = colliderObject.GetComponent <Rigidbody2D>();
if (null == rigidbody)
{
return;
}
var mass1 = rigidbody.mass;
var mass2 = gravityMass;
// Linear force
var force = minForce + (maxForce - minForce) * (distance / radius);
switch (forceType)
{
case ForceType.InverseSquareMass:
force = (mass1 * mass2) / (distance * distance);
break;
case ForceType.Linear:
break;
}
// Clamp force to prevent strange values near center and weak value at edge
force = Mathf.Max(minForce, MathF.Min(maxForce, force));
var vectorToWell = new Vector2(thisWorldCenter.x - colliderWorldCenter.x, thisWorldCenter.y - colliderWorldCenter.y);
//Debug.Log("Vector to well: " + vectorToWell.ToString() + " Force: " + force.ToString());
vectorToWell.Normalize();
var forceVector = vectorToWell * force;
//Debug.Log("Force Vector: " + forceVector.ToString());
rigidbody.AddForce(forceVector);
}
protected override Vector3 SpawnPositionFor(GameObject gameObject)
{
float distance = RandomUtils.VaryFloat(0, 1.0f) * radius;
float angle = random.Value * 360.0f;
Vector2 offset = AngleUtils.DegreeAngleToVector2(angle, 1.0f) * distance;
var result = new Vector3(offset.x, offset.y, 0);
return(result);
}
public Angle2D(Vector2 vector)
{
float squaredMagnitude = vector.x * vector.x + vector.y * vector.y;
magnitude = Mathf.Sqrt(squaredMagnitude);
Vector2 vp = new Vector2(vector.x, vector.y);
angle = AngleUtils.Vector2ToDegreeAngle(vp) / 360.0f; // Normalize it
}
public override void ApplyLayout()
{
var path = NewPath();
int childCount = transform.childCount;
float normalOffset = childCount > 1 ? 1.0f / (float)(childCount - 1) : 0;
var index = 0;
foreach (Transform childTransform in transform)
{
var childObject = childTransform.gameObject;
var normalPosition = index * normalOffset;
if (index < positions.Count)
{
normalPosition = positions[index];
}
var position = path.PositionAt(normalPosition);
position += offset;
//Debug.Log("Apply layout Position: " + position.ToString() + " Normal: " + normalPosition.ToString());
childObject.transform.localPosition = position;
if (orientToPath)
{
var prevPosition = normalPosition;
var nextPosition = normalPosition;
var orientDelta = .001f;
if (normalPosition == 0)
{
nextPosition += orientDelta;
}
else if (normalPosition == 1.0f)
{
prevPosition -= orientDelta;
}
else
{
nextPosition = Mathf.Min(1.0f, nextPosition + orientDelta);
}
var rotationDegreeAngle = AngleUtils.Vector2ToDegreeAngle(path.PositionAt(nextPosition) - path.PositionAt(prevPosition));
rotationDegreeAngle += orientDegreeAngle;
childObject.transform.localEulerAngles = new Vector3(0, 0, -rotationDegreeAngle);
}
else
{
childObject.transform.localEulerAngles = new Vector3(0, 0, 0);
}
index++;
}
}
/// <summary>
/// Perform a sweep check for occluders, moving from the target's center, outward
/// until the target is no longer hit by the sweep, or until we have reached degreeAngleSweep from center
/// </summary>
protected virtual CheckOccludersResult SweepCheckOccluders(GameObject target, float startDegreeAngle, float degreeAngleSweep, bool exitIfTargetNotIn)
{
if (occluderTypes.Count <= 0 || degreeAngleSweep == 0)
{
return(CheckOccludersResult.CanSeeTarget);
}
if (occluderCheckAngleStep <= 0)
{
return(CheckOccludersResult.CanSeeTarget);
}
var step = degreeAngleSweep < 0 ? -occluderCheckAngleStep : occluderCheckAngleStep;
int numSteps = Mathf.RoundToInt(Mathf.Ceil(Mathf.Abs(degreeAngleSweep) / occluderCheckAngleStep));
var angle = startDegreeAngle;
while (numSteps > 0)
{
var canSeeResult = CanSeeTarget(AngleUtils.DegreeAngleToVector2(angle, MaxOccluderRaycastDistance), target);
switch (canSeeResult)
{
// We have swept past the target, it was not seen
case CanSeeResult.TargetNotIn:
// Some sensors start from the object's center and can exit early if the target is not in the current sweep
// Other sensors check an angle range and need to perform the entire sweep
if (exitIfTargetNotIn)
{
//Debug.Log("Sweep Target Not In: " + angle);
return(CheckOccludersResult.TargetOccluded);
}
break;
case CanSeeResult.CanSeeTarget:
//Debug.Log("Sweep Can See: " + angle);
return(CheckOccludersResult.CanSeeTarget);
}
numSteps -= 1;
angle += step;
// We are using fractional steps, so we might have passed the final angle
if (degreeAngleSweep > 0)
{
angle = Mathf.Min(startDegreeAngle + degreeAngleSweep, angle);
}
else
{
angle = Mathf.Max(startDegreeAngle + degreeAngleSweep, angle);
}
}
return(CheckOccludersResult.TargetOccluded);
}
protected override void OnSense(GameObject target, CollisionState collisionState)
{
if (!this.sensorDelegate.TryGetTarget(out SensorDelegate sensorDelegate))
{
return;
}
if (!sensorDelegate.IsSenseTarget(target))
{
return;
}
var angleToTarget = AngleUtils.Vector2ToDegreeAngle(target.transform.position - transform.position);
if (CheckOccluders(angleToTarget, 45.0f, target, true))
{
return;
}
List <GameObject> objectList = new List <GameObject>();
objectList.Add(target);
ForwardSense(objectList, collisionState);
}
public Vector3 MeshVertexFor(float degreeAngle)
{
var vector = AngleUtils.DegreeAngleToVector2(degreeAngle, 1.0f);
return(new Vector3(vector.x * worldSize.x / 2.0f, vector.y * worldSize.y / 2.0f, 0));
}
public Vector2 ToVector2()
{
return(AngleUtils.DegreeAngleToVector2(this.angle * 360.0f, this.magnitude));
}
public void TestAngleUtils()
{
float sqrt2 = Mathf.Sqrt(2);
float distX = 1;
float distY = 1 * Vector2.down.y;
float hyp = AngleUtils.Hypotenuse(distX, distY);
Assert.AreEqual(hyp, sqrt2, .01);
hyp = AngleUtils.SquaredHypotenuse(distX, distY);
Assert.AreEqual(hyp, 2, .01);
Vector2 adjOpp = AngleUtils.DegreeAngleToVector2(45, sqrt2);
Assert.AreEqual(adjOpp.x, 1, .01);
Assert.AreEqual(adjOpp.y, 1 * Vector2.up.y, .01);
Assert.AreEqual(AngleUtils.DegreeAngleOppToHyp(45, 1), sqrt2, .01);
adjOpp = AngleUtils.DegreeAngleToVector2(135, sqrt2);
Assert.AreEqual(adjOpp.x, 1, .01);
Assert.AreEqual(adjOpp.y, 1 * Vector2.down.y, .01);
adjOpp = AngleUtils.DegreeAngleToVector2(225, sqrt2);
Assert.AreEqual(adjOpp.x, -1, .01);
Assert.AreEqual(adjOpp.y, 1 * Vector2.down.y, .01);
adjOpp = AngleUtils.DegreeAngleToVector2(315, sqrt2);
Assert.AreEqual(adjOpp.x, -1, .01);
Assert.AreEqual(adjOpp.y, 1 * Vector2.up.y, .01);
// IMPORTANT: the angle specified is away from the 0 degree, *not* from the x-coordinate line.
// 60 degrees rotated away from origin 0 is a 30 degree right triangle.
adjOpp = AngleUtils.DegreeAngleToVector2(60, 1);
Assert.AreEqual(adjOpp.x, .866, .01);
Assert.AreEqual(adjOpp.y, .5 * Vector2.up.y, .01);
{
float firstDeg = 180;
float finalDeg = 45;
float turnDeg = AngleUtils.GetClosestDegreeTurn(firstDeg, finalDeg);
Assert.AreEqual(-135, turnDeg, .01);
}
{
float firstDeg = 45;
float finalDeg = 180;
float turnDeg = AngleUtils.GetClosestDegreeTurn(firstDeg, finalDeg);
Assert.AreEqual(135, turnDeg, .01);
}
Vector2 distance;
float angle;
distance.x = 0;
distance.y = 0;
angle = AngleUtils.Vector2ToDegreeAngle(distance);
Assert.AreEqual(0, angle);
distance.x = 0;
distance.y = 10 * Vector2.up.y;
angle = AngleUtils.Vector2ToDegreeAngle(distance);
Assert.AreEqual(0, angle, .001f);
distance.x = 10;
distance.y = 0;
angle = AngleUtils.Vector2ToDegreeAngle(distance);
Assert.AreEqual(90, angle, .001f);
distance.x = 0;
distance.y = 10 * Vector2.down.y;
angle = AngleUtils.Vector2ToDegreeAngle(distance);
Assert.AreEqual(180, angle, .001f);
distance.x = -10;
distance.y = 0;
angle = AngleUtils.Vector2ToDegreeAngle(distance);
Assert.AreEqual(270, angle, .001f);
distance.x = 10;
distance.y = 10 * Vector2.up.y;
angle = AngleUtils.Vector2ToDegreeAngle(distance);
Assert.AreEqual(45, angle, .001f);
distance.x = 10;
distance.y = 10 * Vector2.down.y;
angle = AngleUtils.Vector2ToDegreeAngle(distance);
Assert.AreEqual(135, angle, .001f);
distance.x = -10;
distance.y = 10 * Vector2.down.y;
angle = AngleUtils.Vector2ToDegreeAngle(distance);
Assert.AreEqual(225, angle, .001f);
distance.x = -10;
distance.y = 10 * Vector2.up.y;
angle = AngleUtils.Vector2ToDegreeAngle(distance);
Assert.AreEqual(315, angle, .001f);
}
public Vector2 UVFor(float degreeAngle)
{
var vector = AngleUtils.DegreeAngleToVector2(degreeAngle, 1.0f);
return(new Vector2((vector.x + 1.0f) / 2.0f, (vector.y + 1.0f) / 2.0f));
}
public override Mesh BuildMesh(Mesh mesh)
{
int meshVertexCount = MeshVertexCount;
var vertices = new Vector3[meshVertexCount];
var trianglesSize = SegmentCount * 6;
var triangles = new int[trianglesSize];
var uvSize = meshVertexCount;
var uv = new Vector2[uvSize];
// Outer frame
var meshVertexIndex = 0;
for (int i = 0; i < SegmentCount; i++)
{
var vertex = polygon.vertices[i];
var nextVertex = polygon.vertices[(i + 1) % polygon.vertices.Count];
var angleVector = new Vector2(nextVertex.x - vertex.x, nextVertex.y - vertex.y);
//Debug.Log("Angle Vector: " + angleVector.ToString());
var degreeAngle = AngleUtils.Vector2ToDegreeAngle(angleVector);
//Debug.Log("Degree Angle: " + degreeAngle.ToString());
var outerOffset = AngleUtils.DegreeAngleToVector2(degreeAngle - 90.0f, strokeWidth / 2.0f);
var innerOffset = AngleUtils.DegreeAngleToVector2(degreeAngle + 90.0f, strokeWidth / 2.0f);
//Debug.Log("Outer Offset: " + outerOffset.ToString());
//Debug.Log("Inner Offset: " + innerOffset.ToString());
// Outer frame
// FUTURE: support proper stroke in Z-space (only 2D space stroke width is properly supported)
vertices[meshVertexIndex + 0] = vertex + new Vector3(innerOffset.x, innerOffset.y, 0);
vertices[meshVertexIndex + 1] = nextVertex + new Vector3(innerOffset.x, innerOffset.y, 0);
vertices[meshVertexIndex + 2] = vertex + new Vector3(outerOffset.x, outerOffset.y, 0);
vertices[meshVertexIndex + 3] = nextVertex + new Vector3(outerOffset.x, outerOffset.y, 0);
meshVertexIndex += 4;
}
var center = polygon.Center;
var size = polygon.Size;
if (size.x > 0 && size.y > 0)
{
for (int i = 0; i < uvSize; i++)
{
var vertex = vertices[i];
var distanceFromCenter = vertex - center;
var ratio = new Vector2((distanceFromCenter.x + size.x / 2.0f) / size.x, (distanceFromCenter.y + size.y / 2.0f) / size.y);
uv[i] = ratio;
}
}
else
{
for (int i = 0; i < uvSize; i++)
{
uv[i] = Vector2.zero;
}
}
var t = 0;
meshVertexIndex = 0;
for (int i = 0; i < SegmentCount; i++)
{
triangles[t] = meshVertexIndex;
triangles[t + 1] = meshVertexIndex + 2;
triangles[t + 2] = meshVertexIndex + 1;
triangles[t + 3] = meshVertexIndex + 2;
triangles[t + 4] = meshVertexIndex + 3;
triangles[t + 5] = meshVertexIndex + 1;
meshVertexIndex += 4;
t += 6;
}
UpdateMesh(mesh, vertices, triangles, uv);
return(mesh);
}
public Vector3 PositionAt(float position)
{
var result = AngleUtils.DegreeAngleToVector2(position * 360.0f, radius);
return(result);
}
