public bool BuildObjectsLine(NodeGridPosition StartNodeGridPos, NodeGridPosition EndNodeGridPos)
{
bool success = true;
if (GridObjectToBuild.CanBeBuiltInLines)
{
foreach (NodeGridPosition GridPos in grid.GetNodeLineFromNodes(StartNodeGridPos, EndNodeGridPos))
{
if (!BuildObject(GridPos))
{
success = false;
}
}
}
else
{
success = BuildObject(StartNodeGridPos);
}
if (success && OnMapChanged != null)
{
OnMapChanged();
}
return(success);
}
public List <Node> GetNeighbours(NodeGridPosition GridPos)
{
List <Node> Neighbours = new List <Node>();
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
if (x == 0 && y == 0)
{
continue;
}
int checkX = GridPos.x + x;
int checkY = GridPos.y + y;
if (!CheckIfOutOfBounds(checkX, checkY))
{
Neighbours.Add(grid[checkX, checkY]);
}
}
}
return(Neighbours);
}
public void BuildObjectsFromSave(Save save)
{
if (save == null)
{
Debug.LogError("Save is null!");
return;
}
GridObjectSaveData[] ObjectsToBuildDATA = save.GridObjects;
if (ObjectsToBuildDATA.Length <= 0)
{
Debug.Log("No GridObjects to build!");
return;
}
foreach (GridObjectSaveData objectToBuild in ObjectsToBuildDATA)
{
GridObjectID ID = (GridObjectID)objectToBuild.ID;
NodeGridPosition GridPos = new NodeGridPosition(objectToBuild.x, objectToBuild.y);
int Rot = objectToBuild.Rot;
if (!BuildObject(ID, GridPos, Rot))
{
Debug.LogWarning("SomeThing Went Wrong!");
}
}
Debug.Log("Done!");
}
/// <summary>
/// Constructor, It checks automatically if it is walkable or not
/// </summary>
/// <param name="_WorldPosition"></param>
/// <param name="_GridPos"></param>
public Node(Vector3 _WorldPosition, NodeGridPosition _GridPos)
{
WorldPosition = _WorldPosition;
GridPos = new NodeGridPosition(_GridPos);
//This makes it a bit more secure
Walkable = CheckIfWalkable();
}
/// <summary>
/// Constructor, It checks automatically if it is walkable or not
/// </summary>
/// <param name="_WorldPosition"></param>
/// <param name="_gridX"></param>
/// <param name="_gridY"></param>
public Node(Vector3 _WorldPosition, int _gridX, int _gridY)
{
WorldPosition = _WorldPosition;
GridPos = new NodeGridPosition(_gridX, _gridY);
//This makes it a bit more secure
Walkable = CheckIfWalkable();
}
public static Vector3 GetWorldPointFromNodeGridPosition(NodeGridPosition GridPos)
{
if (!Instance.CheckIfOutOfBounds(GridPos))
{
Node node = Instance.grid[GridPos.x, GridPos.y];
return(node.WorldPosition);
}
return(Vector3.zero);
}
public List <NodeGridPosition> GetNodeAreaFromNodes(NodeGridPosition StartNodeGridPos, NodeGridPosition EndNodeGridPos)
{
if (StartNodeGridPos == EndNodeGridPos)
{
return new List <NodeGridPosition> {
StartNodeGridPos
}
}
;
List <NodeGridPosition> Area = new List <NodeGridPosition>();
int DifferenceX = Mathf.Abs(EndNodeGridPos.x - StartNodeGridPos.x);
int DifferenceY = Mathf.Abs(EndNodeGridPos.y - StartNodeGridPos.y);
NodeGridPosition CurrentNode = StartNodeGridPos;
int x = StartNodeGridPos.x, y = StartNodeGridPos.y;
while (CurrentNode != EndNodeGridPos)
{
while (CurrentNode.x != EndNodeGridPos.x)
{
if (!CheckIfOutOfBounds(x, y))
{
CurrentNode = new NodeGridPosition(x, y);
if (CurrentNode != null)
{
Area.Add(CurrentNode);
}
}
if (StartNodeGridPos.x < EndNodeGridPos.x)
{
x++;
}
else
{
x--;
}
}
x = StartNodeGridPos.x;
if (StartNodeGridPos.y < EndNodeGridPos.y)
{
y++;
}
else
{
y--;
}
}
return(Area);
}
public List <NodeGridPosition> GetOccupiedNodes(NodeGridPosition GridPos)
{
List <NodeGridPosition> OccupiedNodes = new List <NodeGridPosition>();
if (ObjectToBuildSize.x == 1 && ObjectToBuildSize.x == 1)
{
OccupiedNodes.Add(GridPos);
return(OccupiedNodes);
}
for (int _x = 0; _x < ObjectToBuildSize.x; _x++)
{
for (int _y = 0; _y < ObjectToBuildSize.y; _y++)
{
//I used x for where the occupied node actually is and _x for storing the loop
int x = 0;
int y = 0;
switch (ObjectToBuildRotation)//rot is an int used this way 0 = 0°, 1 = 90°, 2 = 180°, 3 = 270°
{
case 0:
x = _x;
y = _y;
break;
case 1:
x = _y;
y = -_x;
break;
case 2:
x = -_x;
y = -_y;
break;
case 3:
x = -_y;
y = _x;
break;
default:
x = _x;
y = _y;
break;
}
x += GridPos.x;
y += GridPos.y;
OccupiedNodes.Add(new NodeGridPosition(x, y));
}
}
return(OccupiedNodes);
}
public static Vector3 GetWorldPointFromNodeGridPosition(NodeGridPosition GridPos, out bool Success)
{
if (!Instance.CheckIfOutOfBounds(GridPos))
{
Node node = Instance.grid[GridPos.x, GridPos.y];
Success = true;
return(node.WorldPosition);
}
Success = false;
return(Vector3.zero);
}
public bool DestroySingleGridObject(NodeGridPosition GridPos)
{
bool success = DestroyGridObject(GridPos);
if (success && OnMapChanged != null)
{
OnMapChanged();
}
return(success);
}
public bool BuildSingleObject(NodeGridPosition GridPos)
{
bool success = BuildObject(GridPos);
if (success && OnMapChanged != null)
{
OnMapChanged();
}
return(success);
}
private void OnMouse1()
{
if (Recording && BuildMode)
{
NodeGridPosition tmp_GridPos = Grid.NodeGridPositionFromRayCast();
if (tmp_GridPos != NodeGridPosition.Null)
{
EndNodeGridPos = tmp_GridPos;
SelectedNodesGridPos = Grid.Instance.GetNodeLineFromNodes(StartNodeGridPos, EndNodeGridPos);
}
}
}
public void ShowSelectedNodesInGrid(NodeGridPosition GridPos)
{
if (Grid.Instance.CheckIfOutOfBounds(GridPos) || !BuildMode)
{
return;
}
SelectedOverlay.showMain = true;
float radius = Grid.Instance.nodeRadius;
Vector3 center = Grid.GetWorldPointFromNodeGridPosition(GridPos) - Vector3.one * radius;
SetSelectedOverlayTransform(Vector3.one * radius * 2, center, 0.01f);
}
public void ShowSelectedNodesInGrid(List <NodeGridPosition> GridPos)
{
if (GridPos == null || GridPos.Count <= 0 || !BuildMode)
{
return;
}
else if (GridPos.Count == 1)
{
ShowSelectedNodesInGrid(GridPos[0]);
return;
}
SelectedOverlay.showMain = true;
float Lenght = GridPos.Count * Grid.Instance.nodeRadius * 2f;
float width = Grid.Instance.nodeRadius * 2f;
Vector3 size;
Vector3 center;
NodeGridPosition n1GridPos = GridPos[0];
NodeGridPosition n2GridPos = GridPos[GridPos.Count - 1];
float differenceX = Mathf.Abs(n2GridPos.x - n1GridPos.x);
float differenceY = Mathf.Abs(n2GridPos.y - n1GridPos.y);
if (differenceX > differenceY)
{
size = new Vector3(Lenght, 0f, width);
}
else
{
size = new Vector3(width, 0f, Lenght);
}
Vector3 n1WorldPos = Grid.GetWorldPointFromNodeGridPosition(n1GridPos);
Vector3 n2WorldPos = Grid.GetWorldPointFromNodeGridPosition(n2GridPos);
center = new Vector3((n1WorldPos.x + n2WorldPos.x - size.x) / 2f, 0f, (n1WorldPos.z + n2WorldPos.z - size.z) / 2f);
SetSelectedOverlayTransform(size, center, 0.01f);
}
public bool DestroyLineOfGridObject(NodeGridPosition StartNodeGridPos, NodeGridPosition EndNodeGridPos)
{
bool success = false;
foreach (NodeGridPosition GridPos in grid.GetNodeLineFromNodes(StartNodeGridPos, EndNodeGridPos))
{
if (DestroyGridObject(GridPos))
{
success = true;
}
}
if (success && OnMapChanged != null)
{
OnMapChanged();
}
return(success);
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
else if (Instance != this)
{
Debug.LogError(gameObject + " was a second Instance! and was destroyed for it!");
Destroy(gameObject);
}
grid = Grid.Instance;
CreateGrid();
OnGridObjectToBuildChanged += delegate { ObjectToBuildSize = GridObjectToBuild.Size; };
}
private bool DestroyGridObject(NodeGridPosition GridPos)
{
if (grid.CheckIfOutOfBounds(GridPos) || !BullDozerMode || !BuildMode)
{
return(false);
}
GridObject GridObj = ObjectGrid[GridPos.x, GridPos.y];
if (GridObj == null)
{
return(false);
}
GridObjects.Remove(GridObj);
List <NodeGridPosition> NodesOccupied = GridObj.GetOccupiedNodes();
if (GridObj.ID == GridObjectID.wall)
{
Walls.Remove(GridObj.GetComponent <Wall>());
}
Destroy(GridObj.gameObject);
foreach (NodeGridPosition OccupiedGridPos in NodesOccupied)
{
if (GridObj.ID == GridObjectID.Floor)//Floors get stored in Floors and not ObjectGrid
{
FloorGrid[OccupiedGridPos.x, OccupiedGridPos.y] = null;
}
else //Everything Else gets stored in ObjectGrid
{
ObjectGrid[OccupiedGridPos.x, OccupiedGridPos.y] = null;
grid.grid[OccupiedGridPos.x, OccupiedGridPos.y].Occupied = false;
//no need to check this if the GridObject is a floor. Floors Don't Block People, You should try them.
grid.grid[OccupiedGridPos.x, OccupiedGridPos.y].UpdateWalkable();
}
}
return(true);
}
private void OnMouse1Down()
{
if (BuildMode)
{
NodeGridPosition tmp_GridPos = Grid.NodeGridPositionFromRayCast();
if (tmp_GridPos != NodeGridPosition.Null)
{
StartNodeGridPos = tmp_GridPos;
Recording = true;
SelectedNodesGridPos = new List <NodeGridPosition> {
StartNodeGridPos
};
}
}
else
{
//do a raycast with the Controllable Entity layer, if then we hit somebody make them currentEntity in (EnityManager)s
//Utility.DoRayCast()
}
}
private void OnMouse1Up()
{
if (Recording && StartNodeGridPos != NodeGridPosition.Null && BuildMode)
{
Utility <NodeGridPosition> .CleanUpList(SelectedNodesGridPos);
EndNodeGridPos = Grid.NodeGridPositionFromRayCast();
//If we don't find a EndNodeGridPosition we set the EndNodeGridPosition to the last GridPosition in the SelectedNodes List
if (EndNodeGridPos == NodeGridPosition.Null && SelectedNodesGridPos.Count > 0)
{
EndNodeGridPos = SelectedNodesGridPos[SelectedNodesGridPos.Count - 1];
}
if (StartNodeGridPos == EndNodeGridPos)
{
if (!BullDozerMode)
{
BuildManager.Instance.BuildSingleObject(StartNodeGridPos);
}
else
{
BuildManager.Instance.DestroySingleGridObject(StartNodeGridPos);
}
}
else if (StartNodeGridPos != EndNodeGridPos)
{
if (!BullDozerMode)
{
BuildManager.Instance.BuildObjectsLine(StartNodeGridPos, EndNodeGridPos);
}
else
{
BuildManager.Instance.DestroyLineOfGridObject(StartNodeGridPos, EndNodeGridPos);
}
}
Recording = false;
SelectedNodesGridPos = null;
}
}
public bool CheckIfOccupied(NodeGridPosition NodeGridPositionTocheck)
{
if (grid.CheckIfOutOfBounds(NodeGridPositionTocheck))
{
return(true);
}
else if (ObjectGrid[NodeGridPositionTocheck.x, NodeGridPositionTocheck.y] != null)
{
return(true);
}
else if (grid.grid[NodeGridPositionTocheck.x, NodeGridPositionTocheck.y].Occupied)
{
return(true);
}
else
{
return(false);
}
}
public void UpdateGrid(NodeGridPosition from, NodeGridPosition to)
{
if (CheckIfOutOfBounds(from) || CheckIfOutOfBounds(to))
{
return;
}
int x = from.x;
while (x != to.x)
{
int y = from.y;
while (y != to.y)
{
grid[x, y].UpdateWalkable();
if (from.y < to.y)
{
y++;
}
else
{
y--;
}
}
if (from.x < to.x)
{
x++;
}
else
{
x--;
}
}
}
public NodeGridPosition(NodeGridPosition _GridPos)
{
x = _GridPos.x;
y = _GridPos.y;
}
public bool CheckIfOutOfBounds(NodeGridPosition GridPos)
{
return(GridPos.x < 0 || GridPos.x >= GridSize.x || GridPos.y < 0 || GridPos.y >= GridSize.y);
}
private bool BuildObject(NodeGridPosition GridPos)
{
if (!BuildMode || GridPos == NodeGridPosition.Null)
{
return(false);
}
if (GridObjectToBuild == null)
{
Debug.LogError("GridObjectToBuild is null!");
return(false);
}
if (GridObjectToBuild.ID != GridObjectID.Floor && CheckIfOccupied(GetOccupiedNodes(GridPos)))
{
return(false);
}
Vector3 WorldPos = Grid.GetWorldPointFromNodeGridPosition(GridPos);
while (ObjectToBuildRotation < 0)
{
ObjectToBuildRotation += 4;
}
ObjectToBuildRotation %= 4;
Quaternion Rot = Quaternion.Euler(0f, ObjectToBuildRotation * 90f, 0f);
GridObject GridObj = Instantiate(GridObjectToBuild.Prefab, WorldPos, Rot);
GridObj.GridPos = new NodeGridPosition(GridPos.x, GridPos.y);
Debug.Log("After: " + GridObj.GridPos.x + ", " + GridObj.GridPos.y);
GridObj.Rot = ObjectToBuildRotation;
GridObjects.Add(GridObj);
if (GridObjectToBuild.ID == GridObjectID.wall)
{
Wall wall = GridObj.GetComponent <Wall>();
if (wall != null)
{
wall.transform.SetParent(WallParent);
wall.ShowUpWall(AllWallsShowing);
AddWall(wall);
}
}
//If the size of the object is more that 1 in any axis
if (GridObj.Size.x > 1 && GridObj.Size.y > 1)
{
//We go through all the occupied nodes to tell them they have been occupied
foreach (NodeGridPosition OccupiedGridPosition in GridObj.GetOccupiedNodes())
{
ObjectGrid[OccupiedGridPosition.x, OccupiedGridPosition.y] = GridObj;
Node occupiedNode = grid.grid[OccupiedGridPosition.x, OccupiedGridPosition.y];
occupiedNode.Occupied = true;
occupiedNode.UpdateWalkable();
}
}
else
{
ObjectGrid[GridPos.x, GridPos.y] = GridObj;
Node node = grid.grid[GridPos.x, GridPos.y];
node.Occupied = true;
node.UpdateWalkable();
}
return(true);
}
public List <NodeGridPosition> GetNodeLineFromNodes(NodeGridPosition StartNodeGridPos, NodeGridPosition EndNodeGridPos)
{
if (CheckIfOutOfBounds(StartNodeGridPos))
{
return(null);
}
List <NodeGridPosition> Line = new List <NodeGridPosition>();
int DifferenceX = Mathf.Abs(EndNodeGridPos.x - StartNodeGridPos.x);
int DifferenceY = Mathf.Abs(EndNodeGridPos.y - StartNodeGridPos.y);
NodeGridPosition CurrentNodeGridPos = StartNodeGridPos;
//If true we will get a line of nodes along the X axis of the lenght of DifferenceX
if (DifferenceX > DifferenceY)
{
int X = StartNodeGridPos.x;
EndNodeGridPos = new NodeGridPosition(EndNodeGridPos.x, StartNodeGridPos.y);
while (CurrentNodeGridPos != EndNodeGridPos)
{
CurrentNodeGridPos = new NodeGridPosition(X, StartNodeGridPos.y);
if (!CheckIfOutOfBounds(CurrentNodeGridPos))
{
Line.Add(CurrentNodeGridPos);
}
if (StartNodeGridPos.x < EndNodeGridPos.x)
{
X++;
}
else
{
X--;
}
}
}
//else we will get a line of nodes along the Y axis of the lenght of DifferenceY
else
{
int Y = StartNodeGridPos.y;
EndNodeGridPos = new NodeGridPosition(StartNodeGridPos.x, EndNodeGridPos.y);
while (CurrentNodeGridPos != EndNodeGridPos)
{
CurrentNodeGridPos = new NodeGridPosition(StartNodeGridPos.x, Y);
if (!CheckIfOutOfBounds(CurrentNodeGridPos))
{
Line.Add(CurrentNodeGridPos);
}
if (StartNodeGridPos.y < EndNodeGridPos.y)
{
Y++;
}
else
{
Y--;
}
}
}
return(Line);
}
//WARNING! NO BUILDMODE CHECK
private bool BuildObject(GridObjectSaveData GridObjectSavedData)
{
if (GridObjectSavedData == null)
{
return(false);
}
GridObjectID ID = (GridObjectID)GridObjectSavedData.ID;
NodeGridPosition GridPos = new NodeGridPosition(GridObjectSavedData.x, GridObjectSavedData.y);
int Rot = GridObjectSavedData.Rot;
GridObjectData ObjectData = IDManager.Instance.GetData(GridObjectSavedData.ID);
if (ObjectData == null)
{
Debug.LogError("ObjectData is null!");
return(false);
}
if (CheckIfOccupied(GetOccupiedNodes(GridPos)) || GridPos == NodeGridPosition.Null)
{
return(false);
}
Vector3 WorldPos = Grid.GetWorldPointFromNodeGridPosition(GridPos);
while (Rot < 0)
{
Rot += 4;
}
Rot %= 4;
Quaternion Rotation = Quaternion.Euler(0f, Rot * 90f, 0f);
GridObject GridObj = Instantiate(ObjectData.Prefab, WorldPos, Rotation);
GridObj.GridPos = GridPos;
GridObj.Rot = Rot;
GridObjects.Add(GridObj);
if (ID == GridObjectID.wall)
{
Wall wall = GridObj.GetComponent <Wall>();
if (wall != null)
{
wall.transform.SetParent(WallParent);
wall.ShowUpWall(AllWallsShowing);
AddWall(wall);
}
}
//If the size of the object is more that 1 in any axis
if (GridObj.Size.x > 1 && GridObj.Size.y > 1)
{
//We go through all the occupied nodes to tell them they have been occupied
foreach (NodeGridPosition OccupiedGridPosition in GridObj.GetOccupiedNodes())
{
ObjectGrid[OccupiedGridPosition.x, OccupiedGridPosition.y] = GridObj;
Node occupiedNode = grid.grid[OccupiedGridPosition.x, OccupiedGridPosition.y];
occupiedNode.Occupied = true;
occupiedNode.UpdateWalkable();
}
}
else
{
ObjectGrid[GridPos.x, GridPos.y] = GridObj;
Node node = grid.grid[GridPos.x, GridPos.y];
node.Occupied = true;
node.UpdateWalkable();
}
return(true);
}
