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); }