public override void Update(float deltaTime)
{
miniDashTimer = Mathf.Approach(miniDashTimer, 0, deltaTime);
}
/// <summary>
/// casts a line through the spatial hash and fills the hits array up with any colliders that the line hits.
/// https://github.com/francisengelmann/fast_voxel_traversal/blob/master/main.cpp
/// http://www.cse.yorku.ca/~amana/research/grid.pdf
/// </summary>
/// <returns>the number of Colliders returned</returns>
/// <param name="start">Start.</param>
/// <param name="end">End.</param>
/// <param name="hits">Hits.</param>
/// <param name="layerMask">Layer mask.</param>
public int Linecast(System.Numerics.Vector2 start, System.Numerics.Vector2 end, RaycastHit[] hits, int layerMask)
{
var ray = new Ray2D(start, end);
_raycastParser.Start(ref ray, hits, layerMask);
// get our start/end position in the same space as our grid
var currentCell = CellCoords(start.X, start.Y);
var lastCell = CellCoords(end.X, end.Y);
// what direction are we incrementing the cell checks?
var stepX = Math.Sign(ray.Direction.X);
var stepY = Math.Sign(ray.Direction.Y);
// we make sure that if we're on the same line or row we don't step in the unneeded direction
if (currentCell.X == lastCell.X) stepX = 0;
if (currentCell.Y == lastCell.Y) stepY = 0;
// Calculate cell boundaries. when the step is positive, the next cell is after this one meaning we add 1.
// If negative, cell is before this one in which case dont add to boundary
var xStep = stepX < 0 ? 0f : (float) stepX;
var yStep = stepY < 0 ? 0f : (float) stepY;
var nextBoundaryX = ((float) currentCell.X + xStep) * _cellSize;
var nextBoundaryY = ((float) currentCell.Y + yStep) * _cellSize;
// determine the value of t at which the ray crosses the first vertical voxel boundary. same for y/horizontal.
// The minimum of these two values will indicate how much we can travel along the ray and still remain in the current voxel
// may be infinite for near vertical/horizontal rays
var tMaxX = ray.Direction.X != 0 ? (nextBoundaryX - ray.Start.X) / ray.Direction.X : float.MaxValue;
var tMaxY = ray.Direction.Y != 0 ? (nextBoundaryY - ray.Start.Y) / ray.Direction.Y : float.MaxValue;
// how far do we have to walk before crossing a cell from a cell boundary. may be infinite for near vertical/horizontal rays
var tDeltaX = ray.Direction.X != 0 ? _cellSize / (ray.Direction.X * stepX) : float.MaxValue;
var tDeltaY = ray.Direction.Y != 0 ? _cellSize / (ray.Direction.Y * stepY) : float.MaxValue;
// start walking and returning the intersecting cells.
var cell = CellAtPosition(currentCell.X, currentCell.Y);
// Debug.log( $"cell: {currentCell.X}, {currentCell.Y}" );
// debugDrawCellDetails( intX, intY, cell != null ? cell.Count : 10 );
if (cell != null && _raycastParser.CheckRayIntersection(currentCell.X, currentCell.Y, cell))
{
_raycastParser.Reset();
return _raycastParser.HitCounter;
}
while (currentCell.X != lastCell.X || currentCell.Y != lastCell.Y)
{
if (tMaxX < tMaxY)
{
// HACK: ensures we never overshoot our values
currentCell.X = (int) Mathf.Approach(currentCell.X, lastCell.X, Math.Abs(stepX));
// currentCell.X += stepX;
tMaxX += tDeltaX;
}
else
{
currentCell.Y = (int) Mathf.Approach(currentCell.Y, lastCell.Y, Math.Abs(stepY));
// currentCell.Y += stepY;
tMaxY += tDeltaY;
}
// Debug.log( $"cell: {currentCell.X}, {currentCell.Y}" );
cell = CellAtPosition(currentCell.X, currentCell.Y);
if (cell != null && _raycastParser.CheckRayIntersection(currentCell.X, currentCell.Y, cell))
{
_raycastParser.Reset();
return _raycastParser.HitCounter;
}
}
// make sure we are reset
_raycastParser.Reset();
return _raycastParser.HitCounter;
}
public override void Update(float deltaTime)
{
playerStateMachine.fullDashCooldownTimer = Mathf.Approach(playerStateMachine.fullDashCooldownTimer, 0, deltaTime);
}
