public static void ForDebug(Vector3 r1, Vector3 r2, Vector3 r3, Vector3 r4, Color color, float duration = 0)
{
Debug.DrawLine(r1, r2, color, duration);
Debug.DrawLine(r2, r3, color, duration);
Debug.DrawLine(r3, r4, color, duration);
Debug.DrawLine(r4, r1, color, duration);
}
private void DrawPatchBounds(Patch p)
{
var bounds = new Bounds();
bounds.SetMinMax((Vector3)(p.SolidHullMin + p.Offset) * 0.5f, (Vector3)(p.SolidHullMax + p.Offset) * 0.5f);
var extents = bounds.extents;
var center = bounds.center;
var c0 = center - extents;
var c1 = center + new Vector3(extents.x, -extents.y, -extents.z);
var c2 = center + new Vector3(extents.x, extents.y, -extents.z);
var c3 = center + new Vector3(-extents.x, extents.y, -extents.z);
var c4 = center + new Vector3(-extents.x, extents.y, extents.z);
var c5 = center + extents;
var c6 = center + new Vector3(extents.x, -extents.y, extents.z);
var c7 = center + new Vector3(-extents.x, -extents.y, extents.z);
Debug.DrawLine(c0, c1, Color.magenta);
Debug.DrawLine(c0, c3, Color.magenta);
Debug.DrawLine(c0, c7, Color.magenta);
Debug.DrawLine(c1, c2, Color.magenta);
Debug.DrawLine(c1, c6, Color.magenta);
Debug.DrawLine(c2, c3, Color.magenta);
Debug.DrawLine(c2, c5, Color.magenta);
Debug.DrawLine(c3, c4, Color.magenta);
Debug.DrawLine(c4, c5, Color.magenta);
Debug.DrawLine(c4, c7, Color.magenta);
Debug.DrawLine(c5, c6, Color.magenta);
Debug.DrawLine(c6, c7, Color.magenta);
}
private void Update()
{
if (tTarget == null || onCollision)
{
return;
}
var point = CenterPoint();
var raycastHit = new RaycastHit();
var distance = Vector3.Distance(point, targetPos); Debug.DrawLine(point, targetPos);
var distanceNextFrame = effectSettings.MoveSpeed * Time.deltaTime;
if (distanceNextFrame > distance)
{
distanceNextFrame = distance;
}
if (distance <= effectSettings.ColliderRadius)
{
DeactivateAttachedPoints(raycastHit);
}
var direction = (targetPos - point).normalized;
if (Physics.Raycast(point, direction, out raycastHit, distanceNextFrame + effectSettings.ColliderRadius))
{
targetPos = raycastHit.point - direction * effectSettings.ColliderRadius;
DeactivateAttachedPoints(raycastHit);
}
}
// Update is called once per frame
private void Update()
{
float stepLength = 1.0f / Segments;
float step;
_animCounter += Time.deltaTime;
// Animate the tangents to move around in cycles
TangentOne.Translate(Mathf.Cos(_animCounter) * 0.1f, 0, 0, Space.Self);
TangentTwo.Translate(Mathf.Sin(_animCounter) * 0.1f, 0, 0, Space.Self);
// Turn GameObject positions into Vector2 objects
_startPosition = new Vector2(StartPosition.position.x, StartPosition.position.y);
_endPosition = new Vector2(EndPosition.position.x, EndPosition.position.y);
_tangentOne = new Vector2(TangentOne.position.x, TangentOne.position.y);
_tangentTwo = new Vector2(TangentTwo.position.x, TangentTwo.position.y);
// Build the line segments of the curve
for (var i = 0; i < Segments; i++)
{
step = i * stepLength;
var prevPosition = Hermite.GetVector2AtStep(_startPosition, _endPosition,
(_tangentOne - _startPosition) * TangentOneWeight,
-(_tangentTwo - _endPosition) * TangentTwoWeight,
step);
var nextPosition = Hermite.GetVector2AtStep(_startPosition, _endPosition,
(_tangentOne - _startPosition) * TangentTwoWeight,
-(_tangentTwo - _endPosition) * TangentTwoWeight,
step + stepLength);
_lines[i].transform.position = new Vector3(prevPosition.x, prevPosition.y, 0);
_lines[i].transform.LookAt(new Vector3(nextPosition.x, nextPosition.y, 0), Vector3.up);
_lines[i].transform.localScale = new Vector3(0.2f, 0.2f, (prevPosition - nextPosition).magnitude);
}
// Debug Draw methods only show up when Editor is playing and paused
Hermite.DrawVector2(_startPosition, _endPosition, (_tangentOne - _startPosition), -(_tangentTwo - _endPosition), Segments);
Debug.DrawLine(_startPosition, _tangentOne, Color.cyan);
Debug.DrawLine(_endPosition, _tangentTwo, Color.magenta);
}
/// <summary>
/// Draws a cube made with lines
/// </summary>
/// <param name="center">center of the code in world space</param>
/// <param name="size">size of the cube (extents*2 or max-min)</param>
/// <param name="color">the color of the cube lines</param>
public static void DrawWireCube(Vector3 center, Vector3 size, Color color = default)
{
Vector3 lbb = center + ((-size) * 0.5f);
Vector3 rbb = center + (new Vector3(size.x, -size.y, -size.z) * 0.5f);
Vector3 lbf = center + (new Vector3(size.x, -size.y, size.z) * 0.5f);
Vector3 rbf = center + (new Vector3(-size.x, -size.y, size.z) * 0.5f);
Vector3 lub = center + (new Vector3(-size.x, size.y, -size.z) * 0.5f);
Vector3 rub = center + (new Vector3(size.x, size.y, -size.z) * 0.5f);
Vector3 luf = center + ((size) * 0.5f);
Vector3 ruf = center + (new Vector3(-size.x, size.y, size.z) * 0.5f);
color = color == default ? Color.white : color;
Debug.DrawLine(lbb, rbb, color);
Debug.DrawLine(rbb, lbf, color);
Debug.DrawLine(lbf, rbf, color);
Debug.DrawLine(rbf, lbb, color);
Debug.DrawLine(lub, rub, color);
Debug.DrawLine(rub, luf, color);
Debug.DrawLine(luf, ruf, color);
Debug.DrawLine(ruf, lub, color);
Debug.DrawLine(lbb, lub, color);
Debug.DrawLine(rbb, rub, color);
Debug.DrawLine(lbf, luf, color);
Debug.DrawLine(rbf, ruf, color);
}
/// <summary>
/// Draws a cube at the specified position, and of the specified color and size
/// </summary>
/// <param name="position">Position.</param>
/// <param name="color">Color.</param>
/// <param name="size">Size.</param>
public static void DrawCube(Vector3 position, Color color, Vector3 size)
{
if (!DebugDrawEnabled)
{
return;
}
Vector3 halfSize = size / 2f;
Vector3[] points = new Vector3 []
{
position + new Vector3(halfSize.x, halfSize.y, halfSize.z),
position + new Vector3(-halfSize.x, halfSize.y, halfSize.z),
position + new Vector3(-halfSize.x, -halfSize.y, halfSize.z),
position + new Vector3(halfSize.x, -halfSize.y, halfSize.z),
position + new Vector3(halfSize.x, halfSize.y, -halfSize.z),
position + new Vector3(-halfSize.x, halfSize.y, -halfSize.z),
position + new Vector3(-halfSize.x, -halfSize.y, -halfSize.z),
position + new Vector3(halfSize.x, -halfSize.y, -halfSize.z),
};
Debug.DrawLine(points[0], points[1], color);
Debug.DrawLine(points[1], points[2], color);
Debug.DrawLine(points[2], points[3], color);
Debug.DrawLine(points[3], points[0], color);
}
void DebugSceneView(PresentationState animState)
{
if (m_template.footIK.debugIdlePos)
{
var rotation = Quaternion.Euler(0f, animState.rotation, 0f);
var leftIdlePos = rotation * m_template.footIK.leftToeStandPos + animState.position;
var rightIdlePos = rotation * m_template.footIK.rightToeStandPos + animState.position;
DebugDraw.Sphere(leftIdlePos, 0.01f, Color.green);
DebugDraw.Sphere(leftIdlePos, 0.04f, Color.green);
DebugDraw.Sphere(rightIdlePos, 0.01f, Color.red);
DebugDraw.Sphere(rightIdlePos, 0.04f, Color.red);
}
if (m_template.footIK.debugRayCast)
{
DebugDraw.Sphere(m_LeftFootPos, 0.025f, Color.yellow);
DebugDraw.Sphere(m_RightFootPos, 0.025f, Color.yellow);
DebugDraw.Sphere(m_LeftHit.point, 0.015f);
DebugDraw.Sphere(m_RightHit.point, 0.015f);
Debug.DrawLine(m_LeftHit.point, m_LeftHit.point + m_LeftHit.normal, Color.green);
Debug.DrawLine(m_RightHit.point, m_RightHit.point + m_RightHit.normal, Color.red);
}
}
/// <summary>
/// Draws a point of the specified color and size at the specified position
/// </summary>
/// <param name="pos">Position.</param>
/// <param name="col">Col.</param>
/// <param name="scale">Scale.</param>
public static void DrawPoint(Vector3 position, Color color, float size)
{
if (!DebugDrawEnabled)
{
return;
}
Vector3[] points = new Vector3[]
{
position + (Vector3.up * size),
position - (Vector3.up * size),
position + (Vector3.right * size),
position - (Vector3.right * size),
position + (Vector3.forward * size),
position - (Vector3.forward * size)
};
Debug.DrawLine(points[0], points[1], color);
Debug.DrawLine(points[2], points[3], color);
Debug.DrawLine(points[4], points[5], color);
Debug.DrawLine(points[0], points[2], color);
Debug.DrawLine(points[0], points[3], color);
Debug.DrawLine(points[0], points[4], color);
Debug.DrawLine(points[0], points[5], color);
Debug.DrawLine(points[1], points[2], color);
Debug.DrawLine(points[1], points[3], color);
Debug.DrawLine(points[1], points[4], color);
Debug.DrawLine(points[1], points[5], color);
Debug.DrawLine(points[4], points[2], color);
Debug.DrawLine(points[4], points[3], color);
Debug.DrawLine(points[5], points[2], color);
Debug.DrawLine(points[5], points[3], color);
}
internal void DrawEdges()
{
Debug.DrawLine(EdgeA.Start, EdgeA.End, Color.green, 180);
Debug.DrawLine(EdgeB.Start, EdgeB.End, Color.green, 180);
Debug.DrawLine(EdgeC.Start, EdgeC.End, Color.green, 180);
Debug.DrawLine(EdgeD.Start, EdgeD.End, Color.green, 180);
}
private void TraceDisplacement(Vector3 delta, Color color)
{
if (_traceAdjustments)
{
Debug.DrawLine(Transform.position, Transform.position + delta, color);
}
}
public static void DebugPath(Vector3[] path)
{
for (int i = 0; i < path.Length - 1; i++)
{
Debug.DrawLine(path[i], path[i + 1], Color.yellow, 10.0f);
}
}
public Vector3 GetReEntryPosition(Vector3 position, Bounds bounds)
{
var pointOnBounds = _paddedBounds.ClosestPoint(position);
var colliderOverlapPadding = 0.5f;
var size = (_collider.bounds.extents * 2) + bounds.extents * colliderOverlapPadding;
var result = new Vector3(pointOnBounds.x, position.y, pointOnBounds.z);
if (position.z <= _collider.bounds.min.z)
{
result.z += size.z;
}
if (position.z > _collider.bounds.max.z)
{
result.z -= size.z;
}
if (position.x <= _collider.bounds.min.x)
{
result.x += size.x;
}
if (position.x > _collider.bounds.max.x)
{
result.x -= size.x;
}
Debug.DrawLine(pointOnBounds, result + Vector3.zero * 0.1f, Color.yellow);
return(result);
}
// Update is called once per frame
private void Update()
{
float stepLength = 1.0f / Segments;
float step;
_animCounter += Time.deltaTime;
// Animate the tangents to move around in cycles
TangentOne.Translate(Mathf.Cos(_animCounter) * 0.1f, Mathf.Sin(_animCounter) * 0.05f, -Mathf.Sin(_animCounter) * 0.1f, Space.Self);
TangentTwo.Translate(Mathf.Sin(_animCounter) * 0.1f, Mathf.Cos(_animCounter) * 0.03f, Mathf.Cos(_animCounter) * 0.1f, Space.Self);
// Build the line segments of the curve
for (var i = 0; i < Segments; i++)
{
step = i * stepLength;
// Use the Hermite class to get the start and end points of the current segment
var prevPosition = Hermite.GetVector3AtStep(StartPosition.position, EndPosition.position,
(TangentOne.position - StartPosition.position) * TangentOneWeight,
-(TangentTwo.position - EndPosition.position) * TangentTwoWeight,
step);
var nextPosition = Hermite.GetVector3AtStep(StartPosition.position, EndPosition.position,
(TangentOne.position - StartPosition.position) * TangentTwoWeight,
-(TangentTwo.position - EndPosition.position) * TangentTwoWeight,
step + stepLength);
// Move the segment to the starting point
_lines[i].transform.position = prevPosition;
// Rotate towards the endpoint
_lines[i].transform.LookAt(nextPosition, Vector3.up);
// Scale the cube to match length
_lines[i].transform.localScale = new Vector3(0.2f, 0.2f, (prevPosition - nextPosition).magnitude);
}
// Debug Draw methods only show up when Editor is playing and paused
Hermite.DrawVector3(StartPosition.position, EndPosition.position, TangentOne.position,
-TangentTwo.position, Segments);
Debug.DrawLine(StartPosition.position, TangentOne.position, Color.cyan);
Debug.DrawLine(EndPosition.position, TangentTwo.position, Color.magenta);
}
//private void DrawCells(KdTree<FloatWithSizeMath.FloatWithSize, Cell> cellTree)
private void DrawCells(IEnumerable <Cell> cellTree)
{
foreach (var currentCell in cellTree)
{
try
{
#if UNITY_EDITOR
Gizmos.color = currentCell.Color;
Gizmos.DrawCube(currentCell.Position, currentCell.Size);
if (!ShowReferences)
{
continue;
}
Gizmos.color = Color.blue;
foreach (var neighbour in currentCell.Neighbours)
{
//Gizmos.DrawLine(currentCell.Position, neighbour.Key.Position);
//Gizmos.DrawCube(currentCell.Position, Vector3.one * 0.075f);
Debug.DrawLine(currentCell.Position, neighbour.Key.Position, Color.blue);
}
#endif
}
catch (Exception e)
{
Debug.Log(e);
}
}
}
void OnDrawGizmos()
{
if (_path != null && _path.Count > 0)
{
int index = 1;
foreach (Node node in _path)
{
if (index < _path.Count)
{
SNode nextNode = _path[index];
Debug.DrawLine(node.position, nextNode.position, Color.green);
index++;
}
}
;
int vecIndex = 1;
if (actualPath.Count > 0)
{
foreach (Vector3 vec in actualPath)
{
if (vecIndex < actualPath.Count)
{
Vector3 nextVec = actualPath[vecIndex];
Debug.DrawLine(vec, nextVec, Color.red);
vecIndex++;
}
}
}
}
}
private Vector3 GetGroundPoint(Vector3 predictedPosition, bool right)
{
RaycastHit hit;
var groundPoint = Vector3.zero;
var skyPosition = predictedPosition + Vector3.up * 1.2f;
Debug.DrawLine(skyPosition, skyPosition + Vector3.down * 2f, Color.magenta);
//test OMG
var currentDirection = StateManager.currentDirection;
var rot = Quaternion.LookRotation(currentDirection);
var a1 = predictedPosition + rot * new Vector3(0.05f, 0, 0.05f);
var a2 = predictedPosition + rot * new Vector3(-0.05f, 0, 0.05f);
var a3 = predictedPosition + rot * new Vector3(-0.05f, 0, -0.05f);
var a4 = predictedPosition + rot * new Vector3(0.05f, 0, -0.05f);
var sky1 = _predictor.GetSkyPosition(1.2f, a1);
var sky2 = _predictor.GetSkyPosition(1.2f, a2);
var sky3 = _predictor.GetSkyPosition(1.2f, a3);
var sky4 = _predictor.GetSkyPosition(1.2f, a4);
var hit1 = Physics.Raycast(sky1, Vector3.down, out var h1, 4f, environmentLayer);
var hit2 = Physics.Raycast(sky2, Vector3.down, out var h2, 4f, environmentLayer);
var hit3 = Physics.Raycast(sky3, Vector3.down, out var h3, 4f, environmentLayer);
var hit4 = Physics.Raycast(sky4, Vector3.down, out var h4, 4f, environmentLayer);
Debug.DrawLine(sky1, sky1 + Vector3.down * 1.2f, Color.yellow);
Debug.DrawLine(sky2, sky2 + Vector3.down * 1.2f, Color.yellow);
Debug.DrawLine(sky3, sky3 + Vector3.down * 1.2f, Color.yellow);
Debug.DrawLine(sky4, sky4 + Vector3.down * 1.2f, Color.yellow);
var test = new float[4];
test[0] = h1.point.y;
test[1] = h2.point.y;
test[2] = h3.point.y;
test[3] = h4.point.y;
var res = _predictor.GetPopularElement(test);
if (Physics.Raycast(skyPosition, Vector3.down, out hit, 2f, environmentLayer))
{
groundPoint = hit.point;
groundPoint.y += feetHeight;
//test rotation all the time like old system
var rotAxis = Vector3.Cross(Vector3.up, hit.normal);
var angle = Vector3.Angle(Vector3.up, hit.normal);
var rotation = Quaternion.AngleAxis(angle, rotAxis);
if (right)
{
rightRotationIK = rotation;
}
else
{
leftRotationIK = rotation;
}
}
return(new Vector3(predictedPosition.x, res, predictedPosition.z));
return(groundPoint);
}
public static void DrawLine(Vector3 from, Vector3 to, Color c, float duration = 0f)
{
if (!showDebugging)
{
return;
}
Debug.DrawLine(from, to, c, duration);
}
void Update()
{
if (Input.GetMouseButtonDown(0) && AssignedTeam == Team.Red)
{
Vector3 pos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
moveTarget = new Vector2(pos.x, pos.y);
isMoving = true;
}
if (isMoving)
{
if (Manager.Debugging)
{
Debug.DrawLine(transform.position, moveTarget, Color.green);
}
}
////////////////////////////////////////////
/// AI Update
calculateNearestEnemies();
calculateNearestFriendlies();
SelectState();
switch (aiState)
{
case (AIState.Flee):
RunAway();
break;
case (AIState.Fight):
Fight();
break;
case (AIState.Find):
Debug.LogException(new NotImplementedException());
break;
case (AIState.HealFriend):
HealFriendly();
Debug.LogException(new NotImplementedException());
break;
case (AIState.Patrol):
Patrol();
Debug.LogException(new NotImplementedException());
break;
case (AIState.None):
break;
default:
Debug.LogException(new ArgumentException());
break;
}
}
private RaycastHit[] CalculateBothRayCastHits(Transform transform)
{
var point = PositionWithinArea(transform);
var startingCast = CreateRandomRay(point);
var hits = Physics.RaycastAll(startingCast.origin, startingCast.direction);
Debug.DrawLine(startingCast.origin, startingCast.direction, Color.cyan, 1000f);
return(hits);
}
private void OnDrawGizmosSelected()
{
if (corners == null)
{
return;
}
foreach (var p in corners.Buffer(2, 1).Where(p => p.Count == 2))
{
Debug.DrawLine(p.First(), p.Last(), Color.green);
}
}
public static void bounds2D(Bounds bounds, Color color, float duration = 0)
{
var c = bounds.center;
var e = bounds.extents;
var e2 = new Vector3(e.x, -e.y, e.z);
Debug.DrawLine(c + e, c + e2, color, duration);
Debug.DrawLine(c - e, c + e2, color, duration);
Debug.DrawLine(c - e, c - e2, color, duration);
Debug.DrawLine(c + e, c - e2, color, duration);
}
public static void ForDebug(Bounds2i rectangle, Color color, float duration = 0)
{
var corner1 = new Vector3(rectangle.Min.X, 0, rectangle.Min.Z);
var corner2 = new Vector3(rectangle.Min.X, 0, rectangle.Max.Z + 1);
var corner3 = new Vector3(rectangle.Max.X + 1, 0, rectangle.Max.Z + 1);
var corner4 = new Vector3(rectangle.Max.X + 1, 0, rectangle.Min.Z);
Debug.DrawLine(corner1, corner2, color, duration);
Debug.DrawLine(corner2, corner3, color, duration);
Debug.DrawLine(corner3, corner4, color, duration);
Debug.DrawLine(corner4, corner1, color, duration);
}
public static void circle(Vector3 pos, float radius, Color color, float duration, int segments = 20)
{
var current = pos + new Vector3(radius, 0);
var segmentAngle = 2 * Mathf.PI / segments;
for (var i = 1; i <= segments; i++)
{
var next = pos + radius * new Vector3(Mathf.Cos(segmentAngle * i), Mathf.Sin(segmentAngle * i));
Debug.DrawLine(current, next, color, duration);
current = next;
}
}
private void VisualizerTest()
{
float[] spectrum = new float[256];
source.GetSpectrumData(spectrum, 0, FFTWindow.Rectangular);
for (int i = 1; i < spectrum.Length - 1; i++)
{
Debug.DrawLine(new Vector3(i - 1, spectrum[i] + 10, 0), new Vector3(i, spectrum[i + 1] + 10, 0), Color.red);
Debug.DrawLine(new Vector3(i - 1, Mathf.Log(spectrum[i - 1]) + 10, 2), new Vector3(i, Mathf.Log(spectrum[i]) + 10, 2), Color.cyan);
Debug.DrawLine(new Vector3(Mathf.Log(i - 1), spectrum[i - 1] - 10, 1), new Vector3(Mathf.Log(i), spectrum[i] - 10, 1), Color.green);
Debug.DrawLine(new Vector3(Mathf.Log(i - 1), Mathf.Log(spectrum[i - 1]), 3), new Vector3(Mathf.Log(i), Mathf.Log(spectrum[i]), 3), Color.blue);
}
}
void DrawEdges(float duration)
{
var tri = NavMesh.CalculateTriangulation();
var edge_list = CreateEdges(tri);
foreach (var edge in edge_list)
{
edge.ComputeDerivedData();
Debug.DrawLine(edge.m_StartPos, edge.m_EndPos, Color.magenta, duration);
var mid = edge.GetMidpoint();
Debug.DrawLine(mid, mid + edge.m_Normal, Color.blue, duration);
}
}
public static void DebugDrawQuadrant(float3 pos)
{
Color color = Color.black;
Vector3 lowerLeft = new Vector3((math.floor(pos.x / quadrantCellSize)) * quadrantCellSize, 0,
math.floor(pos.z / quadrantCellSize) * quadrantCellSize);
Debug.DrawLine(lowerLeft, lowerLeft + new Vector3(1, 0, 0) * quadrantCellSize, color);
Debug.DrawLine(lowerLeft, lowerLeft + new Vector3(0, 0, 1) * quadrantCellSize, color);
Debug.DrawLine(lowerLeft + new Vector3(1, 0, 0) * quadrantCellSize,
lowerLeft + new Vector3(1, 0, 1) * quadrantCellSize, color);
Debug.DrawLine(lowerLeft + new Vector3(0, 0, 1) * quadrantCellSize,
lowerLeft + new Vector3(1, 0, 1) * quadrantCellSize, color);
}
public bool checkVisible(Vector3 point)
{
var campos = _Player.camera.transform.position;
var wp = _Player.camera.WorldToViewportPoint(point);
var vis = new Rect(0, 0, 1, 1).Contains(wp) && wp.z > 0 && !Physics.Linecast(campos, point, Layer.levelMask) || Vector3.Distance(campos, point) < 50;
if (vis)
{
Debug.DrawLine(campos, point);
}
return(vis);
}
void Draw(ref BlobArray <int> parentIndexes, ref DynamicBuffer <float4x4> localToWorldBuffer, Color color)
{
for (int i = 1; i != parentIndexes.Length; ++i)
{
var localToWorld = localToWorldBuffer[i];
var pIdx = parentIndexes[i];
var parentLocalToWorld = localToWorldBuffer[pIdx];
Vector3 p1 = localToWorld.c3.xyz;
Vector3 p2 = parentLocalToWorld.c3.xyz;
// DebugOverlay.DrawLine3D(p1, p2, color);
Debug.DrawLine(p1, p2, color);
}
}
private void _DrawAll()
{
for (int i = 0; i < Left.Length - 1; i++)
{
var pos1 = transform.position + new Vector3(Left[i].x, 0, Left[i].y);
var pos2 = transform.position + new Vector3(Left[i + 1].x, 0, Left[i + 1].y);
Debug.DrawLine(pos1, pos2, AllLineColor);
}
for (int i = 0; i < Right.Length - 1; i++)
{
var pos1 = transform.position + new Vector3(Right[i].x, 0, Right[i].y);
var pos2 = transform.position + new Vector3(Right[i + 1].x, 0, Right[i + 1].y);
Debug.DrawLine(pos1, pos2, AllLineColor);
}
}
public static bool PositionIsInFan(Vector3d basePosi, long radius, int angle, FixedQuaternion baseQuaternion, Vector3d posi)
{
#if UNITY_EDITOR
var p1_sin = FixedMath.Trig.Sin(FixedMath.One.Div(180).Mul(FixedMath.Pi).Mul(angle / 2));
var p1_cos = FixedMath.Trig.Cos(FixedMath.One.Div(180).Mul(FixedMath.Pi).Mul(angle / 2));
var p1 = new Vector3d(p1_sin.Mul(radius), 0, p1_cos.Mul(radius));
var worldP1 = baseQuaternion * p1 + basePosi;
var p2_sin = FixedMath.Trig.Sin(FixedMath.One.Div(180).Mul(FixedMath.Pi).Mul(-angle / 2));
var p2_cos = FixedMath.Trig.Cos(FixedMath.One.Div(180).Mul(FixedMath.Pi).Mul(-angle / 2));
var p2 = new Vector3d(p2_sin.Mul(radius), 0, p2_cos.Mul(radius));
var worldP2 = baseQuaternion * p2 + basePosi;
Debug.DrawLine(basePosi.ToVector3(), worldP1.ToVector3(), Color.red, 3);
Debug.DrawLine(basePosi.ToVector3(), worldP2.ToVector3(), Color.red, 3);
#endif
var radiusSqr = radius.Mul(radius);
var relativeP = posi - basePosi;
if (radiusSqr > relativeP.sqrMagnitude)
{
var rotateRelativeP = FixedQuaternion.Inverse(baseQuaternion) * relativeP;
var cos = Vector3d.Dot(rotateRelativeP.Normalize(), new Vector3d(0, 0, FixedMath.One));
var realCos = FixedMath.Trig.Cos(FixedMath.One.Div(180).Mul(FixedMath.Pi).Mul(angle / 2));
if (relativeP.z > 0)
{
if (angle > 180)
{
return(true);
}
return(realCos < cos);
}
else
{
if (angle < 180)
{
return(false);
}
else
{
return(realCos > cos);
}
}
}
else
{
return(false);
}
}
