//renders the path in orange
public void OnDebugRender()
{
if (m_WayPoints.Count <= 0)
{
return;
}
int idx = 0;
Vector3 wp = m_WayPoints[idx];
Gizmos.color = Color.red;
while (idx < m_WayPoints.Count - 1)
{
idx += 1;
Vector3 n = m_WayPoints[idx];
DebugExtension.DrawLineArrow2(wp, n, Color.black);
wp = n;
}
if (m_bLooped)
{
DebugExtension.DrawLineArrow2(wp, m_WayPoints[0], Color.black);
}
Gizmos.DrawSphere(wp, 0.1f);
Gizmos.color = Color.blue;
Gizmos.DrawSphere(m_WayPoints[currentIdx], 0.1f);
}
private void OnDrawGizmosSelected()
{
Gizmos.color = Color.yellow;
Gizmos.DrawSphere(posPuntero, 0.25f);
if (m_pointList != null && m_pointList.Count > 1)
{
DebugExtension.DebugLine(m_pointList, Colors.LightBlue, Colors.DarkBlue);
}
//if (optimacedPointList != null && optimacedPointList.Count > 0)
// DebugExtension.DebugLine(optimacedPointList, Colors.Red, Colors.IndianRed);
//if (normalizedPointList != null && normalizedPointList.Count > 0)
// DebugExtension.DebugLine(normalizedPointList, Colors.LightGreen, Colors.Green);
//if (simplifyPointList != null && simplifyPointList.Count > 0)
//{
// Vector2 vP = new Vector2(0, 0);
// for (int i = 0; i < simplifyPointList.Count; i++)
// {
// Debug.DrawLine(vP, simplifyPointList[i] + vP, Colors.Blue);
// vP = vP + simplifyPointList[i];
// }
//}
}
void OnDrawGizmos()
{
if (grid == null)
{
DebugExtension.DebugLocalCube(transform, new Vector3(1, 1, 1));
}
else if (drawGrid)
{
Vector3 cellExtent = grid.GetCellExtent();
Vector3 gridExtent = grid.GetExtent();
Vector3 numCells = new Vector3(grid.GetNumCells(0), grid.GetNumCells(1), grid.GetNumCells(2));
Vector3 gridOrigin = grid.GetMinCorner();
for (int i = 0; i < numCells.x; ++i)
{
for (int j = 0; j < numCells.y; ++j)
{
for (int k = 0; k < numCells.z; ++k)
{
Gizmos.color = new Vector4(0.7f, 0.7f, 1, 0.2f);
Gizmos.DrawWireCube(gridOrigin + new Vector3(cellExtent.x * i + cellExtent.x / 2, cellExtent.y * j + cellExtent.y / 2, cellExtent.z * k + cellExtent.z / 2), cellExtent);
}
}
}
}
}
private void OnDrawGizmosSelected()
{
// gravity opposite direction
if (_enemyRigidbody != null)
{
Gizmos.color = Color.cyan;
DrawArrow.ForGizmo(transform.position, _enemyRigidbody.velocity);
}
var targetNormal = (transform.position - Planet.position).normalized;
var capsuleB = Quaternion.FromToRotation(Vector3.up, targetNormal) *
CapsuleBegin;
var capsuleE = Quaternion.FromToRotation(Vector3.up, targetNormal) *
CapsuleEnd;
// bomb player detection range
DebugExtension.DrawCapsule(transform.position + capsuleB,
transform.position + capsuleE,
_isPlayerInRange ? Color.red : Color.gray, CapsuleRadius);
if (!_isPlayerInRange)
{
return;
}
Gizmos.color = Color.red;
Gizmos.DrawLine(transform.position,
transform.position +
(Player.position - transform.position).normalized *
_distanceToPlayer);
}
/// <summary>
/// - Debugs a cone.
/// </summary>
/// <param name='position'>
/// - The position for the tip of the cone.
/// </param>
/// <param name='direction'>
/// - The direction for the cone gets wider in.
/// </param>
/// <param name='angle'>
/// - The angle of the cone.
/// </param>
/// <param name='color'>
/// - The color of the cone.
/// </param>
/// <param name='duration'>
/// - How long to draw the cone.
/// </param>
/// <param name='depthTest'>
/// - Whether or not the cone should be faded when behind other objects.
/// </param>
public static void DebugCone(Vector3 position, Vector3 direction, Color color, float angle = 45, float duration = 0, bool depthTest = true)
{
float length = direction.magnitude;
Vector3 _forward = direction;
Vector3 _up = Vector3.Slerp(_forward, -_forward, 0.5f);
Vector3 _right = Vector3.Cross(_forward, _up).normalized *length;
direction = direction.normalized;
Vector3 slerpedVector = Vector3.Slerp(_forward, _up, angle / 90.0f);
float dist;
var farPlane = new Plane(-direction, position + _forward);
var distRay = new Ray(position, slerpedVector);
farPlane.Raycast(distRay, out dist);
Debug.DrawRay(position, slerpedVector.normalized * dist, color);
Debug.DrawRay(position, Vector3.Slerp(_forward, -_up, angle / 90.0f).normalized *dist, color, duration, depthTest);
Debug.DrawRay(position, Vector3.Slerp(_forward, _right, angle / 90.0f).normalized *dist, color, duration, depthTest);
Debug.DrawRay(position, Vector3.Slerp(_forward, -_right, angle / 90.0f).normalized *dist, color, duration, depthTest);
DebugExtension.DebugCircle(position + _forward, direction, color, (_forward - (slerpedVector.normalized * dist)).magnitude, duration, depthTest);
DebugExtension.DebugCircle(position + (_forward * 0.5f), direction, color, ((_forward * 0.5f) - (slerpedVector.normalized * (dist * 0.5f))).magnitude, duration, depthTest);
}
void OnDrawGizmos()
{
frontTransform = transform.FindChild("front");
backTransform = transform.FindChild("back");
Gizmos.color = new Vector4(0, 0, 1, 1);
Gizmos.DrawWireSphere(transform.position, gizmoSize);
Gizmos.color = new Vector4(0.7f, 0.7f, 1, 1);
//Gizmos.DrawLine(transform.position, transform.position + transform.forward * frontWeight);
//Gizmos.DrawLine(transform.position, transform.position - transform.forward * backWeight);
Gizmos.DrawLine(transform.position, frontTransform.position);
Gizmos.DrawLine(transform.position, backTransform.position);
//Gizmos.DrawWireSphere(transform.position + transform.forward * frontWeight, gizmoSize / 2);
//Gizmos.DrawWireSphere(transform.position - transform.forward * backWeight, gizmoSize / 2);
DebugExtension.DrawArrow(transform.position, transform.forward / 2, Color.cyan);
// up and right indicators
Gizmos.color = new Vector4(1, 0, 0, 1);
Gizmos.DrawLine(transform.position, transform.position + transform.right * 3);
Gizmos.color = new Vector4(0, 1, 0, 1);
Gizmos.DrawLine(transform.position, transform.position + transform.up * 3);
}
void DetectCollisions()
{
RaycastHit hit;
Vector3 p1 = transform.position + Vector3.up * bottomOfCharacter;
Vector3 p2 = p1 + Vector3.up * playerMovement.charController.height;
for (int i = 0; i < 360; i += 18)
{
if (Physics.CapsuleCast(p1, p2, 0, new Vector3(Mathf.Cos(i), 0, Mathf.Sin(i)), out hit, playerMovement.charController.radius + collisionDetectionDistance))
{
PlayerModel tempPlay = null;
tempPlay = hit.collider.gameObject.GetComponentInParent <PlayerModel>();
if (tempPlay == null)
{
Vector3 temp = (hit.point - transform.position).normalized;
temp.y = 0;
playerMovement.charController.Move((temp) * (collisionDetectionDistance - hit.distance));
if (hit.collider.gameObject.tag == "Hazard" && isHolding)
{
if (!playerPowerups.strengthPower)
{
Fail();
}
}
}
}
DebugExtension.DebugCapsule(p1 + new Vector3(Mathf.Cos(i), 0, Mathf.Sin(i)), p2 + new Vector3(Mathf.Cos(i), 0, Mathf.Sin(i)), 0);
}
}
protected override void Draw()
{
Gizmos.color = Color;
if (Collider.edgeRadius == 0)
{
for (int i = 0; i < PointsLenght - 1; i++)
{
Gizmos.DrawLine(MultipliedPoints[i], MultipliedPoints[i + 1]);
}
}
else
{
float radius = Collider.edgeRadius;
for (int i = 0; i < PointsLenght - 1; i++)
{
Vector2 HelperVector = MultipliedPoints[i + 1] - MultipliedPoints[i];
HelperVector.Normalize();
HelperVector *= radius;
Gizmos.DrawLine(new Vector3(MultipliedPoints[i].x - HelperVector.y, MultipliedPoints[i].y + HelperVector.x), new Vector3(MultipliedPoints[i + 1].x - HelperVector.y, MultipliedPoints[i + 1].y + HelperVector.x));
Gizmos.DrawLine(new Vector3(MultipliedPoints[i].x + HelperVector.y, MultipliedPoints[i].y - HelperVector.x), new Vector3(MultipliedPoints[i + 1].x + HelperVector.y, MultipliedPoints[i + 1].y - HelperVector.x));
DebugExtension.DrawCircle(MultipliedPoints[i], Vector3.forward, Color, radius);
}
DebugExtension.DrawCircle(MultipliedPoints[PointsLenght - 1], Vector3.forward, Color, Collider.edgeRadius);
}
}
public void Explode(float radius = 1.0f)
{
DebugExtension.DebugCircle(_piece.transform.position, Vector3.forward, Color.red, radius, 5);
// Instancia o Sistema da Partículas
Object.Instantiate(_explosion, _piece.transform.position, Quaternion.identity);
// Checa se houve colisão em um raio ao redor da explosão
var hits = Physics2D.CircleCastAll(_piece.transform.position, radius, Vector2.zero);
foreach (var hit in hits)
{
var obj = hit.collider.GetComponent <IKillable>();
if (obj != null && hit.collider.gameObject != _piece.gameObject)
{
var dir = (hit.collider.transform.position - _piece.transform.position).normalized;
obj.TakeDamage(dir, 10);
}
var atk = hit.collider.GetComponent <IAttack>();
if (atk != null)
{
Object.Destroy(hit.collider.gameObject);
}
}
// ScreenShake
Camera.main.GetComponent <CameraController>().Shake();
}
private void OnDrawGizmos()
{
if (groundCheck != null)
{
DebugExtension.DrawCircle(groundCheck.transform.position, Vector3.forward, Color.magenta, 0.2f);
}
}
private void Update()
{
if (Grid == null)
{
BuildGrid();
}
if (DrawGridPoints)
{
foreach (var node in Grid.InnerGrid)
{
if (node.HasFlag(NodeFlags.Avoidance))
{
DebugExtension.DebugWireSphere(Grid.ToWorldPosition(node.NavigableCenter), UnityColors.OrangeRed, 0.1f);
}
else if (node.HasFlag(NodeFlags.NearEdge))
{
DebugExtension.DebugPoint(Grid.ToWorldPosition(node.NavigableCenter), UnityColors.Gray, 0.2f);
}
else if (node.HasFlag(NodeFlags.Navigation))
{
DebugExtension.DebugPoint(Grid.ToWorldPosition(node.NavigableCenter), UnityColors.Blue, 0.2f);
}
}
}
}
private void CheckIsGrounded()
{
Vector3 checkPosition =
Vector3.down * boxCollider2D.size.y / 2 + transform.position;
DebugExtension
.DebugWireSphere(checkPosition,
Color.red,
fGroundSphereRadius,
Time.deltaTime);
Collider2D[] colliders =
Physics2D
.OverlapCircleAll((Vector2)checkPosition,
fGroundSphereRadius,
groundMask);
if (rb.velocity.y <= 0.0f)
{
if (colliders.Length > 0)
{
isGrounded = true;
}
else
{
isGrounded = false;
}
}
else
{
isGrounded = false;
}
animator.SetBool("isJump", !isGrounded);
}
void OnDrawGizmos()
{
DebugExtension.DrawCircle(transform.position, transform.forward, Color.white, mRadius);
DebugExtension.DrawCircle(transform.position + transform.right * mRadius, transform.up, Color.white, mThickness / 2);
DebugExtension.DrawCircle(transform.position - transform.right * mRadius, transform.up, Color.white, mThickness / 2);
DebugExtension.DrawCircle(transform.position + transform.up * mRadius, transform.right, Color.white, mThickness / 2);
DebugExtension.DrawCircle(transform.position - transform.up * mRadius, transform.right, Color.white, mThickness / 2);
Vector3 pos = transform.position + (transform.up * mRadius + transform.right * mRadius) / Mathf.Sqrt(2);
DebugExtension.DrawCircle(pos, transform.up - transform.right, Color.white, mThickness / 2);
pos = transform.position - (transform.up * mRadius + transform.right * mRadius) / Mathf.Sqrt(2);
DebugExtension.DrawCircle(pos, transform.up - transform.right, Color.white, mThickness / 2);
pos = transform.position + (transform.up * mRadius - transform.right * mRadius) / Mathf.Sqrt(2);
DebugExtension.DrawCircle(pos, transform.up + transform.right, Color.white, mThickness / 2);
pos = transform.position - (transform.up * mRadius - transform.right * mRadius) / Mathf.Sqrt(2);
DebugExtension.DrawCircle(pos, transform.up + transform.right, Color.white, mThickness / 2);
DebugExtension.DrawArrow(transform.position, transform.forward, Color.white);
}
/**
* Check if Character is grounded by spherecasting the ground.
*/
private bool CheckGrounding(out RaycastHit hitInfo)
{
float gravSpeed = raycastOffset + (gravitySpeed + fallSpeedIncrementer) * Time.deltaTime;
Vector3 position = rb.position + new Vector3(0, raycastOffset, 0);
DebugExtension.DebugArrow(position, -transform.up * gravSpeed);
Boolean hitGround = Physics.Raycast(position, -transform.up,
out hitInfo, gravSpeed, 1 | (1 << 10));
if (hitGround)
{
if (hitInfo.collider.isTrigger)
{
return(false);
}
if (Vector3.Dot(hitInfo.normal, Vector3.up) > groundingAngle)
{
gravitySpeed = GRAVITY * fallSpeed;
currentJumpNumber = 0;
IsJumping = false;
return(true);
}
}
return(false);
}
private void Update()
{
foreach (Vector3 point in _points)
{
DebugExtension.DebugPoint(point);
}
ResetInput();
if (Vector3.Distance(transform.position, target.position) > .5f)
{
Vector2 targetDir = target.position - transform.position;
float bestAngle = float.MaxValue; //TODO make smarter
RegisteredMove bestMove = null;
foreach (var move in registeredMoves)
{
if (!move.checkCondition())
{
continue;
}
float angle = Vector2.Angle(targetDir, move.direction);
if (angle < bestAngle)
{
bestAngle = angle;
bestMove = move;
}
}
bestMove?.doMove(bestMove.distanceToDuration(targetDir.magnitude));
//print(bestMove?.name);
}
}
public void DebugDrawVelocityGrid()
{
if (mVelGrid != null)
{
Vector3 cellExtent = mVelGrid.GetCellExtent();
Vector3 gridExtent = mVelGrid.GetExtent();
Vector3 numCells = new Vector3(mVelGrid.GetNumCells(0), mVelGrid.GetNumCells(1), mVelGrid.GetNumCells(2));
Vector3 gridOrigin = mVelGrid.GetMinCorner();
for (int i = 0; i < numCells.x; ++i)
{
for (int j = 0; j < numCells.y; ++j)
{
for (int k = 0; k < numCells.z; ++k)
{
uint[] indices = { (uint)i, (uint)j, (uint)k };
uint offset = mVelGrid.OffsetFromIndices(indices);
Vector3 center = mVelGrid.PositionFromIndices(indices) + cellExtent / 2;
if (mVelGrid[offset].v.magnitude == 0)
{
break;
}
Color color = new Vector4(0.8f, 0.8f, 1, 1);
DebugExtension.DrawArrow(center, mVelGrid[offset].v / 8, color);
}
}
}
}
}
public void OnSceneGUI()
{
if (sim != null)
{
//debug particle index
if (temp.debugParticleIndex)
{
for (int i = 0; i < sim.numberOfParticles(); i++)
{
Vector2 pos = temp.transform.localToWorldMatrix.MultiplyPoint3x4(sim.getParticle(i).Position);
Handles.Label(pos, new GUIContent(i.ToString()));
DebugExtension.DebugPoint(pos, Color.blue, 2f);
}
}
//debug spring index
if (temp.debugSpringIndex)
{
for (int i = 0; i < sim.numberOfSprings(); i++)
{
Vector2 midpt = (sim.getSpring(i).ParticleA.Position + sim.getSpring(i).ParticleB.Position) / 2f;
midpt = temp.transform.localToWorldMatrix.MultiplyPoint3x4(midpt);
GUIStyle st = new GUIStyle();
st.normal.textColor = Color.cyan - new Color(0f, 0f, 0f, 0.5f);
Handles.Label(midpt, new GUIContent(i.ToString()), st);
}
}
}
}
void OnDrawGizmos()
{
var halfPlaneSizeX = transform.right * planeSize.x * 0.5f;
var halfPlaneSizeY = transform.forward * planeSize.y * 0.5f;
Debug.DrawLine(transform.position - halfPlaneSizeX - halfPlaneSizeY, transform.position + halfPlaneSizeX - halfPlaneSizeY, Color.green);
Debug.DrawLine(transform.position + halfPlaneSizeX - halfPlaneSizeY, transform.position + halfPlaneSizeX + halfPlaneSizeY, Color.green);
Debug.DrawLine(transform.position + halfPlaneSizeX + halfPlaneSizeY, transform.position - halfPlaneSizeX + halfPlaneSizeY, Color.green);
Debug.DrawLine(transform.position - halfPlaneSizeX + halfPlaneSizeY, transform.position - halfPlaneSizeX - halfPlaneSizeY, Color.green);
foreach (var particle in debugParticles)
{
if (particle.flags != 0)
{
DebugExtension.DebugCircle(new Vector3(particle.x, 0, particle.y), Color.magenta, particleRadius);
DebugExtension.DrawArrow(new Vector3(particle.x, 0, particle.y), new Vector3(particle.dx, 0, particle.dy), Color.magenta);
var currentPosition = particle.GetPosition(currentTime);
DebugExtension.DebugCircle(new Vector3(currentPosition.x, 0, currentPosition.y), Color.blue, particleRadius);
var proj = Project(new Vector3(currentPosition.x, 0, currentPosition.y));
Debug.LogFormat("{0} {1}", proj.x * textureSize, proj.y * textureSize);
break;
}
}
}
public void OFF()
{
isPose = false;
DebugExtension.DrawCircle(transform.position, radius, Color.red, 3f);
PauseScreen(false);
SwitchBehaviour(false);
}
/// <summary>
/// 爆破時の処理
/// 周囲のコライダーを取得して四散させ、ダメージを与える
/// 取得するコライダーはActorBaseがアタッチされたもの
/// </summary>
protected void AddExprForce()
{
DebugExtension.DrawCircle(transform.position, exprRadius, Color.green, 1f);
//周囲のコライダー取得
var targets = Physics2D.OverlapCircleAll(transform.position, exprRadius)
.Where(c =>
{
var component = c.GetComponent <ActorBase>();
if (component == null)
{
return(false);
}
return(component.HP > 0);
})
.Select(c =>
{
Vector2 dir = c.transform.position - transform.position;
return(new { col = c, direction = dir });
});
//吹き飛ばしとダメージを与える処理
foreach (var target in targets)
{
AddForce(target.col, target.direction, exprPower);
target.col.SendMessage("ExprDamaged");
}
}
/// <summary>
/// renvoi vrai ou faux si on a le droit de sauter (selon le hold)
/// </summary>
/// <returns></returns>
public bool CanGrip(bool setupPoint = true)
{
//faux si le cooldown n'est pas fini, ou qu'on est pas grounded
if (!coolDownGrip.IsReady() || !worldCollision.IsGroundedSafe())
{
return(false);
}
Collider coll;
if (worldCollision.PlatformManager.IsGrippable(out coll))
{
if (!setupPoint)
{
return(true);
}
// The distance from the explosion position to the surface of the collider.
//Collider coll = objectToAggrip.GetComponent<Collider>();
pointAttract = coll.ClosestPointOnBounds(transform.position);
DebugExtension.DebugWireSphere(pointAttract, 1, 1);
return(true);
}
return(false);
}
private void OnDrawGizmosSelected()
{
if (_spawn != null)
{
DebugExtension.DrawArrow(_spawn.position, _spawn.forward * 0.2f, Color.red);
}
}
/// <summary>
/// - Debugs a cylinder.
/// </summary>
/// <param name='start'>
/// - The position of one end of the cylinder.
/// </param>
/// <param name='end'>
/// - The position of the other end of the cylinder.
/// </param>
/// <param name='color'>
/// - The color of the cylinder.
/// </param>
/// <param name='radius'>
/// - The radius of the cylinder.
/// </param>
/// <param name='duration'>
/// - How long to draw the cylinder.
/// </param>
/// <param name='depthTest'>
/// - Whether or not the cylinder should be faded when behind other objects.
/// </param>
public static void DebugCylinder(Vector3 start, Vector3 end, Color color, float radius = 1, float duration = 0, bool depthTest = true)
{
Vector3 up = (end - start).normalized * radius;
Vector3 forward = Vector3.Slerp(up, -up, 0.5f);
Vector3 right = Vector3.Cross(up, forward).normalized *radius;
//Radial circles
DebugExtension.DebugCircle(start, up, color, radius, duration, depthTest);
DebugExtension.DebugCircle(end, -up, color, radius, duration, depthTest);
DebugExtension.DebugCircle((start + end) * 0.5f, up, color, radius, duration, depthTest);
//Side lines
Debug.DrawLine(start + right, end + right, color, duration, depthTest);
Debug.DrawLine(start - right, end - right, color, duration, depthTest);
Debug.DrawLine(start + forward, end + forward, color, duration, depthTest);
Debug.DrawLine(start - forward, end - forward, color, duration, depthTest);
//Start endcap
Debug.DrawLine(start - right, start + right, color, duration, depthTest);
Debug.DrawLine(start - forward, start + forward, color, duration, depthTest);
//End endcap
Debug.DrawLine(end - right, end + right, color, duration, depthTest);
Debug.DrawLine(end - forward, end + forward, color, duration, depthTest);
}
public void Move(Vector2 velocityBias, bool isDash = false)
{
// DebugExtension.DebugArrow( BodyPosition, velocityBias, Color.blue );
// DebugExtension.DebugArrow( BodyPosition, CurrentVelocity, Color.red );
if (Time.deltaTime <= 0)
{
return;
}
var amount = (CurrentVelocity + velocityBias) * Time.deltaTime;
var length = amount.magnitude;
var direction = amount.normalized;
var hit = Physics2D.CapsuleCast(BodyPosition, 0.6f * BodySize, CapsuleDirection2D.Vertical, 0, direction,
length,
_moveBlockingLayerMask | (isDash ? 0 : _dashableObstacleLayerMask));
if (hit.collider != null && !transform.IsAncestorOf(hit.collider.transform))
{
DebugExtension.DebugPoint(hit.point, Color.yellow, 0.1f, 1);
BodyPosition = hit.centroid;
CancelHorizontalMovement();
}
else
{
transform.Translate(direction * length);
}
CheckWallCollisions(isDash);
}
//Wiresphere already exists
/// <summary>
/// - Draws a cylinder.
/// </summary>
/// <param name='start'>
/// - The position of one end of the cylinder.
/// </param>
/// <param name='end'>
/// - The position of the other end of the cylinder.
/// </param>
/// <param name='radius'>
/// - The radius of the cylinder.
/// </param>
public static void DrawCylinder(Vector3 start, Vector3 end, float radius = 1.0f)
{
Vector3 up = (end - start).normalized * radius;
Vector3 forward = Vector3.Slerp(up, -up, 0.5f);
Vector3 right = Vector3.Cross(up, forward).normalized *radius;
//Radial circles
DebugExtension.DrawCircle(start, up, radius);
DebugExtension.DrawCircle(end, -up, radius);
DebugExtension.DrawCircle((start + end) * 0.5f, up, radius);
//Side lines
Gizmos.DrawLine(start + right, end + right);
Gizmos.DrawLine(start - right, end - right);
Gizmos.DrawLine(start + forward, end + forward);
Gizmos.DrawLine(start - forward, end - forward);
//Start endcap
Gizmos.DrawLine(start - right, start + right);
Gizmos.DrawLine(start - forward, start + forward);
//End endcap
Gizmos.DrawLine(end - right, end + right);
Gizmos.DrawLine(end - forward, end + forward);
}
private void CheckWallCollisions(bool isDash = false)
{
var filter = _wallCollisionContactFilter2D;
if (!isDash)
{
filter.layerMask |= _dashableObstacleLayerMask;
}
if (_collisionCheckCollider.OverlapCollider(filter, _wallColliders) > 0)
{
if (transform.IsAncestorOf(_wallColliders[0].transform))
{
return;
}
var distance2D = _collisionCheckCollider.Distance(_wallColliders[0]);
DebugExtension.DebugPoint(distance2D.pointA, Color.red, 0.1f, 1);
if (distance2D.distance > 0)
{
// Debug.LogError( "Should not be > 0" );
// Debug.Log( string.Format( "{0} - {1}", distance2D.normal, distance2D.distance ) );
}
else
{
transform.Translate(distance2D.normal * distance2D.distance);
CancelHorizontalMovement();
}
}
}
void OnTriggerEnter(Collider other)
{
if (!enabled || !_canGenerateCollisions || _checkedColliders.Contains(other))
{
return;
}
_checkedColliders.Add(other);
var hitEntity = EntityController.GetEntity(UnityToEntityBridge.GetEntityId(other));
var entity = EntityController.GetEntity(EntityID);
if (hitEntity == null || hitEntity.Id == EntityID)
{
return;
}
if (!CollisionCheckSystem.IsValidCollision(entity, _limitToEnemy, hitEntity, other, out var sourceNode, out var targetNode))
{
return;
}
var position = transform.position;
var hitPnt = other.ClosestPointOnBounds(position);
var hitNormal = (hitPnt - position).normalized;
#if DEBUG
DebugExtension.DrawPoint(hitPnt, Color.yellow, 1.5f, 4f);
#endif
hitEntity.Post(new CollisionEvent(entity, sourceNode, targetNode, hitPnt, hitNormal));
entity.Post(new PerformedCollisionEvent(sourceNode, targetNode, hitPnt, hitNormal));
}
void OnDrawGizmosSelected()
{
Vector3 directionA = Vector3.zero;
Vector3 directionB = Vector3.zero;
//Calculer les deux vecteurs représentants l'angle de tir
if (Application.isPlaying)
{
directionA = GeneralFunction.rotateVector(targetDirection.normalized, shootingAngle * Mathf.Deg2Rad);
directionB = GeneralFunction.rotateVector(targetDirection.normalized, -shootingAngle * Mathf.Deg2Rad);
}
else
{
directionA = GeneralFunction.rotateVector(transform.forward, shootingAngle * Mathf.Deg2Rad);
directionB = GeneralFunction.rotateVector(transform.forward, -shootingAngle * Mathf.Deg2Rad);
}
//Dessiner la portée de tir
Gizmos.color = Color.yellow;
DebugExtension.DrawCircle(transform.position, Vector3.up, Gizmos.color, shootingRange);
//Dessiner l'angle de tir
Gizmos.color = Color.gray;
Gizmos.DrawRay(transform.position, directionA * detectionRange);
Gizmos.DrawRay(transform.position, directionB * detectionRange);
//Tracer un trait vers la cible
if (targetPosition != Vector3.zero)
{
Gizmos.DrawLine(transform.position, targetPosition);
}
}
public IEnumerator RequestNewPathTo(Vector2 pos)
{
DebugExtension.DebugCircle(pos, Vector3.forward, Color.blue, 0.2f);
Vector2 cam = Camera.main.transform.position;
if (pos.x == -1000)
{
bool found = false;
while (!found)
{
Target = Camera.main.ViewportToWorldPoint(new Vector3(Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f), 0));
if (!PathRequestManager.VerifyLocation(Target))
{
Debug.Log("Não é possivel chegar à posição de destino");
}
else
{
found = true;
}
}
}
else
{
Target = pos;
}
PathRequestManager.RequestPath(new PathRequest(transform.position, Target, OnPathFound));
yield return(new WaitForEndOfFrame());
}
public static SteeringOutput GetSteering(KinematicState ownKS,
ref float targetOrientation,
float wanderRate = 30f,
float wanderRadius = 10f, float wanderOffset = 20f)
{
// change target orientation (change location of surrogate target on unit circle)
targetOrientation += wanderRate * Utils.binomial();
// place surrogate target on circle of wanderRadius
SURROGATE_TARGET.transform.position = Utils.OrientationToVector(targetOrientation) * wanderRadius;
// place circle "in front"
SURROGATE_TARGET.transform.position += ownKS.position + Utils.OrientationToVector(ownKS.orientation) * wanderOffset;
// show some gizmos before returning
Debug.DrawLine(ownKS.position,
ownKS.position + Utils.OrientationToVector(ownKS.orientation) * wanderOffset,
Color.black);
DebugExtension.DebugCircle(ownKS.position + Utils.OrientationToVector(ownKS.orientation) * wanderOffset,
new Vector3(0, 0, 1),
Color.red,
wanderRadius);
DebugExtension.DebugPoint(SURROGATE_TARGET.transform.position,
Color.black,
5f);
// Seek the surrogate target
return(Seek.GetSteering(ownKS, SURROGATE_TARGET));
}
