/// <summary>
/// Gets the topmost tile at the specified cell position , Whilst ignoring the specified tiles in the ExcludedLayers
/// </summary>
/// <param name="cellPosition">cell position within the tilemap to get the tile of. NOT the same
/// as world position.</param>
/// <returns></returns>
public LayerTile GetTile(Vector3Int cellPosition, LayerTypeSelection ExcludedLayers)
{
for (var i = 0; i < LayersValues.Length; i++)
{
LayerTile tile = LayersValues[i].GetTile(cellPosition);
if (tile != null)
{
if (LTSUtil.IsLayerIn(ExcludedLayers, tile.LayerType))
{
continue;
}
return(tile);
}
}
return(null);
}
/// <summary>
/// Gets the topmost tile at the specified cell position , Whilst ignoring the specified tiles in the ExcludedLayers
/// </summary>
/// <param name="cellPosition">cell position within the tilemap to get the tile of. NOT the same
/// as world position.</param>
/// <returns></returns>
public LayerTile GetTile(Vector3Int cellPosition, LayerTypeSelection ExcludedLayers)
{
TileLocation TileLcation = null;
foreach (var layer in LayersValues)
{
if (layer.LayerType == LayerType.Objects)
{
continue;
}
if (LTSUtil.IsLayerIn(ExcludedLayers, layer.LayerType))
{
continue;
}
lock (PresentTiles)
{
PresentTiles[layer].TryGetValue(cellPosition, out TileLcation);
}
if (TileLcation != null)
{
break;
}
}
return(TileLcation?.Tile);
// for (var i = 0; i < LayersValues.Length; i++)
// {
// LayerTile tile = LayersValues[i].GetTile(cellPosition);
// if (tile != null)
// {
// if (LTSUtil.IsLayerIn(ExcludedLayers, tile.LayerType)) continue;
// return tile;
// }
// }
// return null;
}
//Gets the first hit
public MatrixManager.CustomPhysicsHit? Raycast(
Vector2 origin,
Vector2 direction,
float distance,
LayerTypeSelection layerMask, Vector2? To = null)
{
if (To == null)
{
To = direction.normalized * distance;
}
if (direction.x == 0 && direction.y == 0)
{
direction = (To.Value - origin).normalized;
distance = (To.Value - origin).magnitude;
}
// var Beginning = (new Vector3((float) origin.x, (float) origin.y, 0).ToWorld(PresentMatrix));
// Debug.DrawLine(Beginning + (Vector3.right * 0.09f), Beginning + (Vector3.left * 0.09f), Color.yellow, 30);
// Debug.DrawLine(Beginning + (Vector3.up * 0.09f), Beginning + (Vector3.down * 0.09f), Color.yellow, 30);
// var end = (new Vector3((float) To.Value.x, (float) To.Value.y, 0).ToWorld(PresentMatrix));
// Debug.DrawLine(end + (Vector3.right * 0.09f), end + (Vector3.left * 0.09f), Color.red, 30);
// Debug.DrawLine(end + (Vector3.up * 0.09f), end + (Vector3.down * 0.09f), Color.red, 30);
// Debug.DrawLine(Beginning, end, Color.magenta, 30);
Vector2 Relativetarget = To.Value - origin;
//custom code on tile to ask if it aptly got hit, if you want custom geometry
//
//What needs to be returned
//What it hit, game object/tile
//Normal of hit
//Can be done quite easily since we know if me moving left or right
//Static manager
//Calculate if Within bounds of matrix?
//End and start World pos
//
//Calculate offset to then put onto positions, Maybe each position gets its own Calculation
double RelativeX = 0;
double RelativeY = 0;
double gridOffsetx = 0;
double gridOffsety = 0;
int xSteps = 0;
int ySteps = 0;
int stepX = 0;
int stepY = 0;
double Offsetuntouchx = (origin.x - Math.Round(origin.x));
double Offsetuntouchy = (origin.y - Math.Round(origin.y));
if (direction.x < 0)
{
gridOffsetx = -(-0.5d + Offsetuntouchx); //0.5f //this is So when you multiply it gives you 0.5 that some tile borders
stepX = -1; //For detecting which Tile it hits
}
else
{
gridOffsetx = -0.5d - Offsetuntouchx; //-0.5f
stepX = 1;
//sideDistX = (mapX + 1.0 - posX) * deltaDistX;
}
if (direction.y < 0)
{
gridOffsety = -(-0.5d + Offsetuntouchy); // 0.5f
stepY = -1;
//sideDistY = (posY - mapY) * deltaDistY;
}
else
{
gridOffsety = -0.5d - Offsetuntouchy; //-0.5f
stepY = 1;
//sideDistY = (mapY + 1.0 - posY) * deltaDistY;
}
var vec = Vector3Int.zero; //Tile it hit Local Coordinates
var vecHit = Vector3.zero; //Coordinates of Edge tile hit
TileLocation TileLcation = null;
var vexinvX = (1d / (direction.x)); //Editions need to be done here for Working offset
var vexinvY = (1d / (direction.y)); //Needs to be conditional
double calculationFloat = 0;
bool LeftFaceHit = true;
while (Math.Abs((xSteps + gridOffsetx + stepX) * vexinvX) < distance ||
Math.Abs((ySteps + gridOffsety + stepY) * vexinvY) < distance)
//for (int Ai = 0; Ai < 6; Ai++)
{
//if (xBuildUp > yBuildUp)
if ((xSteps + gridOffsetx + stepX) * vexinvX < (ySteps + gridOffsety + stepY) * vexinvY
) // which one has a lesser multiplication factor since that will give a less Magnitude
{
xSteps += stepX;
calculationFloat = ((xSteps + gridOffsetx) * vexinvX);
RelativeX = direction.x * calculationFloat; //Remove offset here maybe?
RelativeY = direction.y * calculationFloat;
LeftFaceHit = true;
}
//else if (xBuildUp < yBuildUp)
else //if (xBuildUp < yBuildUp)
{
ySteps += stepY;
calculationFloat = ((ySteps + gridOffsety) * vexinvY);
RelativeX = direction.x * calculationFloat;
RelativeY = direction.y * calculationFloat;
LeftFaceHit = false;
}
vec.x = (int)Mathf.Round(origin.x) + xSteps;
vec.y = (int)Mathf.Round(origin.y) + ySteps;
vecHit.x = origin.x + (float)RelativeX; //+ offsetX;
vecHit.y = origin.y + (float)RelativeY; // + offsetY;
//Check point here
if (LeftFaceHit)
{
// float TestX = ((vecHit.x - 0.5f) - Mathf.Floor(vecHit.x));
// if (0.05f < Math.Abs(TestX))
// {
// Logger.Log("Offsetuntouchx = " + Offsetuntouchx + "\n" + "directionx = " + direction.x + "\n" +
// "Step = " + xSteps + "\n" + "vexinv = " + vexinvX + "\n" + "offset = " + offsetX +
// "\n" + "\n" + "Test =" + TestX + "\n" + "Relative =" + (RelativeX)
// + "\n" + "\n"
// + " direction.x = " + direction.x + " calculationFloat " + calculationFloat
// + "\n" + " xSteps " + xSteps + " gridOffsetx " + gridOffsetx +" vexinvX " + vexinvX);
// }
}
else
{
// float Testy = ((vecHit.y - 0.5f) - Mathf.Floor(vecHit.y));
// if (0.05f < Math.Abs(Testy))
// {
// Logger.Log("Offsetuntouchx = " + Offsetuntouchy + "\n" + "directionx = " + direction.y + "\n" +
// "Step = " + ySteps + "\n" + "vexinv = " + vexinvY + "\n" + "offset = " + offsetY +
// "\n" + "\n" + "Test =" + Testy + "\n" + "Relative =" + (RelativeY)
// + "\n" + "\n"
// + " direction.y = " + direction.y + " calculationFloat " + calculationFloat
// + "\n" + " ySteps " + ySteps + " gridOffsety " + gridOffsety +" vexinvY " + vexinvY);
// }
}
for (var i = 0; i < LayersValues.Length; i++)
{
if (LayersValues[i].LayerType == LayerType.Objects)
{
continue;
}
if (LTSUtil.IsLayerIn(layerMask, LayersValues[i].LayerType))
{
lock (PresentTiles)
{
PresentTiles[LayersValues[i]].TryGetValue(vec, out TileLcation);
}
// var wold = (vecHit.ToWorld(PresentMatrix));
// Debug.DrawLine(wold + (Vector3.right * 0.09f), wold + (Vector3.left * 0.09f), Color.green, 30);
// Debug.DrawLine(wold + (Vector3.up * 0.09f), wold + (Vector3.down * 0.09f), Color.green, 30);
// if (LeftFaceHit)
// {
// Debug.DrawLine(wold + (Vector3.up * 4f), wold + (Vector3.down * 4), Color.blue, 30);
// }
// else
// {
// Debug.DrawLine(wold + (Vector3.right * 4), wold + (Vector3.left * 4), Color.blue, 30);
// }
// ColorUtility.TryParseHtmlString("#ea9335", out var Orange);
// var map = ((Vector3) vec).ToWorld(PresentMatrix);
// Debug.DrawLine(map + (Vector3.right * 0.09f), map + (Vector3.left * 0.09f), Orange, 30);
// Debug.DrawLine(map + (Vector3.up * 0.09f), map + (Vector3.down * 0.09f), Orange, 30);
if (TileLcation != null)
{
Vector2 normal;
if (LeftFaceHit)
{
normal = Vector2.left * stepX;
}
else
{
normal = Vector2.down * stepY;
}
Vector3 AdjustedNormal = ((Vector3)normal).ToWorld(PresentMatrix);
AdjustedNormal = AdjustedNormal - (Vector3.zero.ToWorld(PresentMatrix));
// Debug.DrawLine(wold, wold + AdjustedNormal, Color.cyan, 30);
return(new MatrixManager.CustomPhysicsHit(((Vector3)vec).ToWorld(PresentMatrix),
(vecHit).ToWorld(PresentMatrix), AdjustedNormal,
new Vector2((float)RelativeX, (float)RelativeY).magnitude, TileLcation));
}
}
}
}
return(null);
}