List <Node> SmoothPath(List <Node> nodeList)
{
List <Node> newPath = new List <Node>();
if (nodeList == null || nodeList.Count == 0)
{
return(null);
}
Node startingNode = nodeList[0];
newPath.Add(startingNode);
for (int i = 0; i < nodeList.Count; i++)
{
if (i == nodeList.Count - 1)
{
newPath.Add(nodeList[i]);
continue;
}
GridPoints line = new GridPoints(new Vector2(startingNode.gridX, startingNode.gridY), new Vector2(nodeList[i].gridX, nodeList[i].gridY));
foreach (Vector2 point in line)
{
Node currentNodepoint = Pathfinding.instance.grid.grid[(int)point.x, (int)point.y];
if (!currentNodepoint.walkable)
{
newPath.Add(nodeList[i - 1]);
startingNode = nodeList[i - 1];
}
}
}
return(newPath);
}
public void InitializeMap()
{
gridMapSize = GridPoints.UnityToGridCoord(unityMapSize);
tilesInMap = new GameObject[unityMapSize.x, unityMapSize.y];
mapTiles = new GameObject[unityMapSize.x, unityMapSize.y, 16]; //array with all tiles
GetSeed();
}
private void CreateGridPoint(int x, int y, int z)
{
GameObject gridPoint = Instantiate(TemplatePoint);
gridPoint.transform.position = GetGridScaledVector(x, y, z);
gridPoint.transform.localScale = ObjectScale;
GridPoints.Add(gridPoint);
}
public static GridPoints UnityToGridCoord(Vector2 unityCoords)
{
GridPoints gridPoints = new GridPoints
{
x = unityCoords.x * multiplier,
y = unityCoords.y * multiplier
};
return(gridPoints);
}
public static Vector2 GridToUnityCoord(GridPoints gridCoords)
{
Vector2 unityCoords = new Vector2
{
x = gridCoords.x / multiplier,
y = gridCoords.y / multiplier
};
return(unityCoords);
}
public static GridPoints MousePosToGridPoints(Vector2 mousePosition)
{
mousePosition = Camera.main.ScreenToWorldPoint(mousePosition);
GridPoints gridPoints = new GridPoints
{
x = mousePosition.x / multiplier,
y = mousePosition.y / multiplier
};
return(gridPoints);
}
public override void Use()
{
MapController mapBuilder = GameObject.Find("GameManager").GetComponent <MapController>();
GridPoints mousePos = GridPoints.MousePosToGridPoints(Input.mousePosition);
GridPoints holderPos = new GridPoints(holder.xTilePos, holder.yTilePos);
GridPoints distance = GridPoints.GridDistance(mousePos, holderPos);
if (distance.x <= maxDistance && distance.y <= maxDistance)
{
mapBuilder.CreateTile(TileSystem.tiles["Wall"], Mathf.RoundToInt(mousePos.x), Mathf.RoundToInt(mousePos.y));
}
}
public void CombineTilesInMap()
{
for (int x = 1; x < unityMapSize.x; x++)
{
for (int y = 1; y < unityMapSize.y; y++)
{
if (tilesInMap[x, y] != null)
{
CombineTiles(tilesInMap[x, y], GridPoints.UnityToGridCoord(new Vector2(x, y)));
}
}
}
}
public static GridPoints GridDistance(GridPoints coordsToMeasureFrom, GridPoints coordsToMeasureTo)
{
GridPoints gridDistance = new GridPoints
{
x = coordsToMeasureTo.x - coordsToMeasureFrom.x,
y = coordsToMeasureTo.y - coordsToMeasureFrom.y
};
gridDistance.x = Mathf.Abs(gridDistance.x);
gridDistance.y = Mathf.Abs(gridDistance.y);
return(gridDistance);
}
/// <summary>
/// Clears the grid
/// </summary>
public void ClearGrid()
{
for (int y = 0; y < GridPoints.GetLength(1); y++)
{
for (int x = 0; x < GridPoints.GetLength(0); x++)
{
//check if there is an object
if (GridPoints[x, y].IsOccupied)
{
gameObjects.Remove(GridPoints[x, y].CellObject);
GridPoints[x, y].CellObject = null;
}
}
}
}
// check if a tile is there already, if you're adding a ground tile, overwrite old tile
public bool TileAlreadyThere(GridPoints gridCoords, bool newGroundTile = false)
{
Vector2Int unityCoords = Vector2Int.RoundToInt(GridPoints.GridToUnityCoord(gridCoords));
if (IsInsideBoundaries(unityCoords))
{
bool isTileThere = (tilesInMap[unityCoords.x, unityCoords.y] != null && !tilesInMap[unityCoords.x, unityCoords.y].GetComponent <TileObject>().tile.isGroundTile&& !newGroundTile) ? true : false;
if (newGroundTile)
{
RemoveTile(unityCoords.x, unityCoords.y);
}
return(isTileThere);
}
return(false);
}
public void GenerateGrid()
{
if (!gridExist)
{
gridExist = true;
gridPoints = new GridPoints[col * row];
for (int i = 0; i < gridPoints.Length; i++)
{
gridPoints[i] = new GridPoints(this, i, col, row, spriteWidth, spriteHeight);
}
GenerateGridLines();
GenerateGridTMPro();
}
else
{
Debug.Log("Grid already exist, aborting grid generation");
}
}
public static void CreateTile(Tile tile, GridPoints gridPoints)
{
Vector2 unityCoords = GridPoints.GridToUnityCoord(gridPoints);
if (map.IsInsideBoundaries(unityCoords) && !map.TileAlreadyThere(gridPoints, tile.isGroundTile))
{
GameObject tileToAdd = new GameObject("Tile", typeof(SpriteRenderer), typeof(TileObject));
tileToAdd.transform.position = GridPoints.GridToUnityCoord(gridPoints); //TODO gridpoints to vector3 implicit;
// to render the sprites correctly
SpriteRenderer spriteRenderer = tileToAdd.GetComponent <SpriteRenderer>();
spriteRenderer.material = pixelMaterial;
TileObject tileData = tileToAdd.GetComponent <TileObject>();
tileData.tile = tile;
tileToAdd.transform.parent = map.mapHolder.transform;
map.tilesInMap[gridPoints.intX, gridPoints.intY] = tileToAdd;
}
// TODO: MOET FATSOENLIJK GEIMPLEMENTEERD WORDEN
}
public void CreateTile(Tile tile, int xCoord, int yCoord)
{
Vector2 coords = new Vector2(xCoord, yCoord);
GridPoints gridCoords = GridPoints.UnityToGridCoord(coords);
if (IsInsideBoundaries(coords) && !TileAlreadyThere(gridCoords, tile.isGroundTile))
{
GameObject tileToAdd = new GameObject("Tile", typeof(SpriteRenderer), typeof(TileObject));
tileToAdd.transform.position = new Vector3(gridCoords.x, gridCoords.y, 0f);
// to render the sprites correctly
SpriteRenderer spriteRenderer = tileToAdd.GetComponent <SpriteRenderer>();
spriteRenderer.material = pixelMaterial;
TileObject tileData = tileToAdd.GetComponent <TileObject>();
tileData.tile = tile;
tileToAdd.transform.parent = mapHolder.transform;
tilesInMap[xCoord, yCoord] = tileToAdd;
lastCreatedTile = tileToAdd;
}
}
/// <summary>
/// Gets the nearest point in the gird as a Vector3.
/// Returns null if passed position is too far out of the grid.
/// </summary>
/// <param name="position">The position to get the nearest grid cell</param>
/// <returns>The nearest grid cell if not outside the grid</returns>
public CustomGridCell GetGridCellInGrid(Vector3 location)
{
//round the x and y of the position to test
int xPosition = Mathf.RoundToInt(location.x);
int yPosition = Mathf.RoundToInt(location.y);
//int zPosition = Mathf.RoundToInt(location.z / Constants.LEVEL_EDITOR_SPACING);
//bounds check
if (xPosition < 0 || xPosition > GridPoints.GetLength(0) - 1)
{
return(null);
}
//y bounds
else if (yPosition < 0 || yPosition > GridPoints.GetLength(1) - 1)
{
return(null);
}
//in bounds
return(GridPoints[xPosition, yPosition]);
}
/**
* Fill up Grid GridPoints using TriangleList input - Grid information should have been set by SetGridInfo
*
* @param SamplePoints : Sample Point List
* @param TriangleList : List of triangles
*/
public void GenerateGridElements(List <BSPoint> SamplePoints, List <BSTriangle> TriangleList)
{
if (!(NumGridDivisions.X > 0 && NumGridDivisions.Y > 0))
{
return;
}
//if(!(GridDimensions.IsValid))
int TotalNumGridPoints = (int)(NumGridPointsForAxis.X * NumGridPointsForAxis.Y);
GridPoints.Clear();
if (SamplePoints.Count == 0 || TriangleList.Count == 0)
{
return;
}
for (int i = 0; i < TotalNumGridPoints; ++i)
{
GridPoints.Add(new GridElement());
}
Vector3 GridPointPosition;
for (int GridPositionX = 0; GridPositionX < NumGridPointsForAxis.X; ++GridPositionX)
{
for (int GridPositionY = 0; GridPositionY < NumGridPointsForAxis.Y; ++GridPositionY)
{
BSTriangle SelectedTriangle = null;
GridElement GridPoint = GridPoints[GridPositionX * (int)NumGridPointsForAxis.Y + GridPositionY];
GridPointPosition = GetPosFromIndex(GridPositionX, GridPositionY);
Vector3 Weights = Vector3.Zero;
if (FindTriangleThisPointBelongsTo(GridPointPosition, ref Weights, ref SelectedTriangle, TriangleList))
{
// found it
GridPoint.Weights[0] = Weights.X;
GridPoint.Weights[1] = Weights.Y;
GridPoint.Weights[2] = Weights.Z;
// need to find sample point index
// @todo fix this with better solution
// lazy me
GridPoint.Indices[0] = SamplePoints.FindIndex((point) => { return(point == SelectedTriangle.Vertices[0]); });
GridPoint.Indices[1] = SamplePoints.FindIndex((point) => { return(point == SelectedTriangle.Vertices[1]); });
GridPoint.Indices[2] = SamplePoints.FindIndex((point) => { return(point == SelectedTriangle.Vertices[2]); });
//check(GridPoint.Indices[0] != INDEX_NONE);
//check(GridPoint.Indices[1] != INDEX_NONE);
//check(GridPoint.Indices[2] != INDEX_NONE);
}
else
{
List <BSSortByDistance> SortedTriangles = new List <BSSortByDistance>();
for (int TriangleIndex = 0; TriangleIndex < TriangleList.Count; ++TriangleIndex)
{
// Check if points are collinear
BSTriangle Triangle = TriangleList[TriangleIndex];
Vector3 EdgeA = Triangle.Vertices[1].Position - Triangle.Vertices[0].Position;
Vector3 EdgeB = Triangle.Vertices[2].Position - Triangle.Vertices[0].Position;
float Result = EdgeA.X * EdgeB.Y - EdgeA.Y * EdgeB.X;
// Only add valid triangles
if (Result > 0.0f)
{
SortedTriangles.Add(new BSSortByDistance(TriangleIndex, Triangle.GetDistance(GridPointPosition)));
}
}
if (SortedTriangles.Count > 0)
{
// SortedTriangles.Sort([](FSortByDistance A, FSortByDistance B) { return A.Distance < B.Distance; });
BSTriangle ClosestTriangle = TriangleList[SortedTriangles[0].Index];
// For the closest triangle, determine which of its edges is closest to the grid point
List <BSSortByDistance> Edges = new List <BSSortByDistance>();
List <Vector3> PointsOnEdges = new List <Vector3>();
for (int EdgeIndex = 0; EdgeIndex < 3; ++EdgeIndex)
{
Vector3 ClosestPoint = ClosestPointOnLine(ClosestTriangle.Edges[EdgeIndex].Vertices[0].Position, ClosestTriangle.Edges[EdgeIndex].Vertices[1].Position, GridPointPosition);
Edges.Add(new BSSortByDistance(EdgeIndex, (ClosestPoint - GridPointPosition).LengthSquared()));
PointsOnEdges.Add(ClosestPoint);
}
//Edges.Sort([](FSortByDistance A, FSortByDistance B) { return A.Distance < B.Distance; });
// Calculate weighting using the closest edge points and the clamped grid position on the line
Vector3 GridWeights = GetBaryCentric2D(PointsOnEdges[Edges[0].Index], ClosestTriangle.Vertices[0].Position, ClosestTriangle.Vertices[1].Position, ClosestTriangle.Vertices[2].Position);
for (int Index = 0; Index < 3; ++Index)
{
GridPoint.Weights[Index] = GridWeights[Index];
GridPoint.Indices[Index] = SamplePoints.FindIndex((point) => { return(point == ClosestTriangle.Vertices[Index]); });
}
}
else
{
// This means that there is either one point, two points or collinear triangles on the grid
if (SamplePoints.Count == 1)
{
// Just one, fill all grid points to the single sample
GridPoint.Weights[0] = 1.0f;
GridPoint.Indices[0] = 0;
}
else
{
// Two points or co-linear triangles, first find the two closest samples
List <BSSortByDistance> SampleDistances = new List <BSSortByDistance>();
for (int PointIndex = 0; PointIndex < SamplePoints.Count; ++PointIndex)
{
var vec = (SamplePoints[PointIndex].Position - GridPointPosition);
Vector2 vector2 = new Vector2(vec.X, vec.Y);
float DistanceFromSampleToPoint = vector2.LengthSquared();
SampleDistances.Add(new BSSortByDistance(PointIndex, DistanceFromSampleToPoint));
}
SampleDistances.Sort((A, B) =>
{
if (A.Distance == B.Distance)
{
return(0);
}
return(A.Distance > B.Distance ? 1 : -1);
});
// Find closest point on line between the two samples (clamping the grid position to the line, just like clamping to the triangle edges)
BSPoint[] Samples = new BSPoint[2];
Samples[0] = SamplePoints[SampleDistances[0].Index];
Samples[1] = SamplePoints[SampleDistances[1].Index];
Vector3 ClosestPointOnTheLine = ClosestPointOnLine(Samples[0].Position, Samples[1].Position, GridPointPosition);
var temp = (Samples[0].Position - Samples[1].Position);
Vector2 tempVector2 = new Vector2(temp.X, temp.Y);
float LineLength = tempVector2.LengthSquared();
// Weight the samples according to the distance from the grid point on the line to the samples
for (int SampleIndex = 0; SampleIndex < 2; ++SampleIndex)
{
var thelength3D = (Samples[SampleIndex].Position - ClosestPointOnTheLine);
var thelength2D = new Vector2(thelength3D.X, thelength3D.Y);
GridPoint.Weights[SampleIndex] = (LineLength - thelength2D.LengthSquared()) / LineLength;
GridPoint.Indices[SampleIndex] = SamplePoints.FindIndex((point) => { return(point == Samples[SampleIndex]); });
}
}
}
}
}
}
}
public void CombineTiles(GameObject tileToChange, GridPoints gridCoords)
{
Tile tile = tileToChange.GetComponent <TileObject>().tile;
SpriteRenderer SR = tileToChange.GetComponent <SpriteRenderer>();
if (tile.combinable)
{
Vector2 unityCoords = GridPoints.GridToUnityCoord(gridCoords);
Vector2[] coordsToCheck = new Vector2[]
{
new Vector2(unityCoords.x, unityCoords.y + 1),
new Vector2(unityCoords.x + 1, unityCoords.y + 1),
new Vector2(unityCoords.x + 1, unityCoords.y),
new Vector2(unityCoords.x + 1, unityCoords.y - 1),
new Vector2(unityCoords.x, unityCoords.y - 1),
new Vector2(unityCoords.x - 1, unityCoords.y - 1),
new Vector2(unityCoords.x - 1, unityCoords.y),
new Vector2(unityCoords.x - 1, unityCoords.y + 1)
};
List <Direction> td = new List <Direction>();
int i = 0;
foreach (Vector2 coordToCheck in coordsToCheck)
{
if (IsInsideBoundaries(coordToCheck))
{
float unityXCoord = coordToCheck.x;
float unityYCoord = coordToCheck.y;
if (tilesInMap[Mathf.RoundToInt(unityXCoord), Mathf.RoundToInt(unityYCoord)].GetComponent <TileObject>().tile == tile)
{
td.Add((Direction)i);
}
}
i++;
}
SR.sprite = tile.sprites[6];
// top left
if (!td.Contains(Direction.top) && !td.Contains(Direction.left) && td.Contains(Direction.bottom) && td.Contains(Direction.bottomRight) && td.Contains(Direction.right))
{
SR.sprite = tile.sprites[0];
}
// top
if (!td.Contains(Direction.top) && td.Contains(Direction.left) && td.Contains(Direction.bottomLeft) && td.Contains(Direction.bottom) && td.Contains(Direction.bottomRight) && td.Contains(Direction.right))
{
SR.sprite = tile.sprites[1];
}
// top right
if (!td.Contains(Direction.top) && !td.Contains(Direction.right) && td.Contains(Direction.bottom) && td.Contains(Direction.bottomLeft) && td.Contains(Direction.left))
{
SR.sprite = tile.sprites[2];
}
// left
if (!td.Contains(Direction.left) && td.Contains(Direction.top) && td.Contains(Direction.topRight) && td.Contains(Direction.bottom) && td.Contains(Direction.bottomRight) && td.Contains(Direction.right))
{
SR.sprite = tile.sprites[5];
}
// right
if (!td.Contains(Direction.right) && td.Contains(Direction.top) && td.Contains(Direction.topLeft) && td.Contains(Direction.bottom) && td.Contains(Direction.bottomLeft) && td.Contains(Direction.left))
{
SR.sprite = tile.sprites[7];
}
// bottom left
if (!td.Contains(Direction.bottom) && !td.Contains(Direction.left) && td.Contains(Direction.top) && td.Contains(Direction.topRight) && td.Contains(Direction.right))
{
SR.sprite = tile.sprites[10];
}
//bottom
if (!td.Contains(Direction.bottom) && td.Contains(Direction.left) && td.Contains(Direction.topLeft) && td.Contains(Direction.top) && td.Contains(Direction.topRight) && td.Contains(Direction.right))
{
SR.sprite = tile.sprites[11];
}
// bottom right
if (!td.Contains(Direction.bottom) && !td.Contains(Direction.right) && td.Contains(Direction.top) && td.Contains(Direction.topLeft) && td.Contains(Direction.left))
{
SR.sprite = tile.sprites[12];
}
// inner top left
if (td.Count == 7 && !td.Contains(Direction.topLeft))
{
SR.sprite = tile.sprites[17];
}
// inner top
if (td.Count == 6 && !td.Contains(Direction.topRight) && !td.Contains(Direction.topLeft))
{
SR.sprite = tile.sprites[16];
}
// inner top right
if (td.Count == 7 && !td.Contains(Direction.topRight))
{
SR.sprite = tile.sprites[15];
}
// inner left
if (td.Count == 6 && !td.Contains(Direction.bottomLeft) && !td.Contains(Direction.topLeft))
{
SR.sprite = tile.sprites[23];
}
// inner right
if (td.Count == 6 && !td.Contains(Direction.bottomRight) && !td.Contains(Direction.topRight))
{
SR.sprite = tile.sprites[18];
}
// inner bottom left
if (td.Count == 7 && !td.Contains(Direction.bottomLeft))
{
SR.sprite = tile.sprites[20];
}
// inner bottom
if (td.Count == 6 && !td.Contains(Direction.bottomRight) && !td.Contains(Direction.bottomLeft))
{
SR.sprite = tile.sprites[21];
}
// inner bottom right
if (td.Count == 7 && !td.Contains(Direction.bottomRight))
{
SR.sprite = tile.sprites[22];
}
// single top
if (td.Contains(Direction.bottom) && !td.Contains(Direction.left) && !td.Contains(Direction.right) && !td.Contains(Direction.top))
{
SR.sprite = tile.sprites[8];
}
// single left
if (td.Contains(Direction.right) && !td.Contains(Direction.top) && !td.Contains(Direction.bottom) && !td.Contains(Direction.left))
{
SR.sprite = tile.sprites[9];
}
// single right
if (td.Contains(Direction.left) && !td.Contains(Direction.top) && !td.Contains(Direction.bottom) && !td.Contains(Direction.right))
{
SR.sprite = tile.sprites[14];
}
// single bottom
if (td.Contains(Direction.top) && !td.Contains(Direction.left) && !td.Contains(Direction.right) && !td.Contains(Direction.bottom))
{
SR.sprite = tile.sprites[13];
}
// horizontal
if (td.Contains(Direction.left) && td.Contains(Direction.right) && !td.Contains(Direction.top) && !td.Contains(Direction.bottom))
{
SR.sprite = tile.sprites[4];
}
// vertical
if (td.Contains(Direction.top) && td.Contains(Direction.bottom) && !td.Contains(Direction.left) && !td.Contains(Direction.right))
{
SR.sprite = tile.sprites[3];
}
/*
* // left bottom corner straight
* if (td.Contains(Direction.top) && td.Contains(Direction.right) && td.Contains(Direction.topRight) && td.Contains(Direction.bottom) && !td.Contains(Direction.left) && !td.Contains(Direction.bottomRight))
* {
* SR.sprite = tile.sprites[23];
* }
*
* // right bottom corner straight
* if (td.Contains(Direction.top) && td.Contains(Direction.left) && td.Contains(Direction.topLeft) && td.Contains(Direction.bottom) && !td.Contains(Direction.right) && !td.Contains(Direction.bottomLeft))
* {
* SR.sprite = tile.sprites[24];
* }
*
* // left top corner straight
* if (td.Contains(Direction.bottom) && td.Contains(Direction.right) && td.Contains(Direction.bottomRight) && td.Contains(Direction.top) && !td.Contains(Direction.left) && !td.Contains(Direction.topRight))
* {
* SR.sprite = tile.sprites[25];
* }
*
* // right top corner straight
* if (td.Contains(Direction.bottom) && td.Contains(Direction.left) && td.Contains(Direction.bottomLeft) && td.Contains(Direction.top) && !td.Contains(Direction.right) && !td.Contains(Direction.topLeft))
* {
* SR.sprite = tile.sprites[26];
* }*/
// center
if (td.Count == 8)
{
SR.sprite = tile.sprites[6];
}
// single tile
if (!td.Contains(Direction.left) && !td.Contains(Direction.right) && !td.Contains(Direction.top) && !td.Contains(Direction.bottom))
{
SR.sprite = tile.sprites[19];
}
}
}
public void Reset()
{
GridPoints.Clear();
}
