void Start()
{
if (mapData != null && grid != null)
{
int[,] mapDesign = mapData.MakeMap();
grid.CreateGrid(mapDesign);
gridVisualisation = grid.gameObject.GetComponent <GridVisualisation>();
if (gridVisualisation != null)
{
gridVisualisation.CreateGridVisualisation(grid);
}
//if our goal is not in the map range it will throw.
if (grid.IsWithinBounds(xGoal, yGoal) && grid.IsWithinBounds(xStart, yStart))
{
startNode = gridVisualisation.nodesVisualisationData[xStart, yStart];
goalNode = gridVisualisation.nodesVisualisationData[xGoal, yGoal];
xGoalInput.text = xGoal.ToString();
yGoalInput.text = yGoal.ToString();
xUnitInput.text = xStart.ToString();
yUnitInput.text = yStart.ToString();
InstantiateUnit(startNode);
}
}
}
void ChangeTileTerrain(NodeVisualisation node, NodeType nodeType, bool wallStatus)
{
node.gridNode.nodeType = nodeType;
node.EnableObject(node.wall, wallStatus);
node.EnableObject(node.arrow, PathfindingVisualisationAid);
gridVisualisation.ResetGridVisualisation();
}
void Start()
{
if (mapData != null && grid != null)
{
int[,] mapinstance = mapData.MakeMap();
grid.CreateGrid(mapinstance);
gridVisualisation = grid.gameObject.GetComponent <GridVisualisation>();
if (gridVisualisation != null)
{
gridVisualisation.CreateGridVisualisation(grid);
}
//if our goal is not in the map range it will throw.
if (grid.IsWithinBounds(xGoal, yGoal) && grid.IsWithinBounds(xStart, yStart))
{
startNode = gridVisualisation.nodesVisualisationData[xStart, yStart];
goalNode = gridVisualisation.nodesVisualisationData[xGoal, yGoal];
xGoalInput.text = xGoal.ToString();
yGoalInput.text = yGoal.ToString();
xUnitInput.text = xStart.ToString();
yUnitInput.text = yStart.ToString();
ChangeTileToGoalNode(goalNode);
InstantiateUnit(startNode);
}
flowfieldPathfinding.CreatePathfinding(grid, gridVisualisation);
flowfieldPathfinding.FlowfieldPath(goalNode.transform.position, PathfindingVisualisationAid, heuristicIndex);
}
}
public void ChangeGoalPositionOnButtonClick()
{
//If the text box is not blank then crack on otherwise throw debug message.
if (xGoalInput.text != "" && yGoalInput.text != "")
{
xGoalInputValue = int.Parse(xGoalInput.text);
yGoalInputValue = int.Parse(yGoalInput.text);
if (grid.IsWithinBounds(xGoalInputValue, yGoalInputValue))
{
NodeVisualisation node = gridVisualisation.nodesVisualisationData[xGoalInputValue, yGoalInputValue];
if (node.gridNode.nodeType != NodeType.Blocked)
{
ChangeTileToGoalNode(node);
RecalculateUnitPath();
}
else
{
Debug.Log("Can't place goal on a blocked node please input a valid walkable node");
}
}
else
{
Debug.Log("Number Inputted is out of bounds. Please put a number that corresponds to the size of the map");
}
}
else
{
Debug.Log("A value must be given");
}
}
public void ChangeUnitPositionOnButtonClick()
{
if (xUnitInput.text != "" && yUnitInput.text != "")
{
xUnitInputValue = int.Parse(xUnitInput.text);
yUnitInputValue = int.Parse(yUnitInput.text);
if (grid.IsWithinBounds(xUnitInputValue, yUnitInputValue))
{
NodeVisualisation node = gridVisualisation.nodesVisualisationData[xUnitInputValue, yUnitInputValue];
if (node.gridNode.nodeType != NodeType.Blocked)
{
unitData[0].ChangeUnitPositionWithoutUsingSpawnPosition(node.gridNode.xIndexPosition, node.gridNode.yIndexPosition);
unitData[0].ClearList();
gridVisualisation.ResetGridVisualisation();
gridVisualisation.ChangeToGoalNodeColourOnly(goalNode);
}
else
{
Debug.Log("Can't place unit on a blocked node please input a valid walkable node");
}
}
else
{
Debug.Log("Number Inputted is out of bounds. Please put a number that corresponds to the size of the map");
}
}
else
{
Debug.Log("A value must be given for the unit");
}
}
void ChangeTileToGoalNode(NodeVisualisation node)
{
gridVisualisation.ResetGridVisualisation();
gridVisualisation.ChangeToFloorNode(goalNode);
gridVisualisation.ChangeToGoalNode(node);
goalNode = node;
}
void InstantiateUnit(NodeVisualisation node)
{
FlowfieldUnit unit = Instantiate(unitPrefab, node.transform.position + unitPrefab.transform.position, Quaternion.identity);
unit.InstaniateUnit(node.gridNode.xIndexPosition, node.gridNode.yIndexPosition, grid, unitData.Count);
unitData.Add(unit);
}
//When you left click the mouse button, it will
void LeftMouseClickToAlterNodeTerrain()
{
if (Input.GetMouseButtonDown(0))
{
if (Physics.Raycast(ray, out hit))
{
Debug.Log(hit.collider.gameObject.tag);
if (hit.collider.gameObject.tag == "Node")
{
NodeVisualisation nodeVisualisation = hit.collider.gameObject.GetComponentInParent <NodeVisualisation>();
if (nodeVisualisation != goalNode)
{
switch (terrainIndex)
{
case 0:
if (nodeVisualisation.gridNode.nodeType != NodeType.Open)
{
ChangeTileTerrain(nodeVisualisation, NodeType.Open, false);
UpdateMap();
}
break;
case 1:
if (nodeVisualisation.gridNode.nodeType != NodeType.Blocked)
{
ChangeTileTerrain(nodeVisualisation, NodeType.Blocked, true);
UpdateMap();
}
break;
case 2:
if (nodeVisualisation.gridNode.nodeType != NodeType.Grass)
{
ChangeTileTerrain(nodeVisualisation, NodeType.Grass, false);
UpdateMap();
}
break;
case 3:
if (nodeVisualisation.gridNode.nodeType != NodeType.Water)
{
ChangeTileTerrain(nodeVisualisation, NodeType.Water, false);
UpdateMap();
}
break;
}
}
}
}
}
}
public void ColorNodes(List <Node> nodelist, Color color)
{
foreach (Node node in nodelist)
{
if (node != null)
{
NodeVisualisation nodeVisualisation = nodesVisualisationData[node.xIndexPosition, node.yIndexPosition];
if (nodeVisualisation != null)
{
nodeVisualisation.ColorNode(color);
}
}
}
}
void MiddleMouseClickToSpawnUnit()
{
if (Input.GetMouseButtonDown(2))
{
if (Physics.Raycast(ray, out hit))
{
Debug.Log(hit.collider.gameObject.tag);
//added mesh chollider to tile to make sure we are able to hit the tile plane.
if (hit.collider.gameObject.tag == "Node")
{
NodeVisualisation nodeVisualisation = hit.collider.gameObject.GetComponentInParent <NodeVisualisation>();
if (nodeVisualisation.gridNode.nodeType != NodeType.Blocked && nodeVisualisation.gridNode.nodeType != NodeType.GoalNode)
{
InstantiateUnit(nodeVisualisation);
}
}
}
}
}
public void CreateGridVisualisation(GridManager grid)
{
if (grid == null)
{
Debug.LogWarning("GridManager has returned as null");
return;
}
nodesVisualisationData = new NodeVisualisation[grid.GetGridWidth, grid.GetGridHeight];
foreach (Node node in grid.gridNodes)
{
GameObject instance = Instantiate(nodeVisualisationPrefab, Vector3.zero, Quaternion.identity);
NodeVisualisation nodeVisualisation = instance.GetComponent <NodeVisualisation>();
if (nodeVisualisation != null)
{
nodeVisualisation.CreateNodeVisualisation(node);
nodesVisualisationData[node.xIndexPosition, node.yIndexPosition] = nodeVisualisation;
if (nodeVisualisation.gridNode.nodeType == NodeType.Blocked)
{
nodeVisualisation.ColorNode(wallColor);
}
else if (nodeVisualisation.gridNode.nodeType == NodeType.Open)
{
nodeVisualisation.ColorNode(baseColor);
}
else if (nodeVisualisation.gridNode.nodeType == NodeType.GoalNode)
{
nodeVisualisation.ColorNode(goalColor);
}
else if (nodeVisualisation.gridNode.nodeType == NodeType.Grass)
{
nodeVisualisation.ColorNode(grassColor);
}
else if (nodeVisualisation.gridNode.nodeType == NodeType.Water)
{
nodeVisualisation.ColorNode(waterColor);
}
}
}
}
//When you left click the mouse button, it will
void LeftMouseClickToAlterNodeTerrain()
{
if (Input.GetMouseButtonDown(0))
{
if (Physics.Raycast(ray, out hit))
{
Debug.Log(hit.collider.gameObject.tag);
if (hit.collider.gameObject.tag == "Node")
{
NodeVisualisation nodeVisualisation = hit.collider.gameObject.GetComponentInParent <NodeVisualisation>();
if (nodeVisualisation != goalNode)
{
switch (terrainIndex)
{
case 0:
ChangeTileTerrain(nodeVisualisation, NodeType.Open, false);
RecalculateUnitPath();
break;
case 1:
ChangeTileTerrain(nodeVisualisation, NodeType.Blocked, true);
SearchUnitPathRecalculate(nodeVisualisation);
break;
case 2:
ChangeTileTerrain(nodeVisualisation, NodeType.Grass, false);
RecalculateUnitPath();
break;
case 3:
ChangeTileTerrain(nodeVisualisation, NodeType.Water, false);
RecalculateUnitPath();
break;
default:
break;
}
}
}
}
}
}
void InstantiateUnit(NodeVisualisation node)
{
Unit unit = Instantiate(unitPrefab, node.transform.position + unitPrefab.transform.position, Quaternion.identity);
unit.SetUnitPositionInGrid(node.gridNode.xIndexPosition, node.gridNode.yIndexPosition);
unit.InitiatePathfinding(grid, gridVisualisation);
unitData.Add(unit);
unit.UnitFindPath(goalNode.transform, algorithmIndex, heuristicIndex);
AddMessageToTextBox(unit.ReturnUnitMessage(), unitData.Count - 1);
UpdateScrollBarToBottom();
if (PathfindingVisualisationAid)
{
if (!(unitData.Count > 1))
{
unit.UnitSearchVisualisation();
}
unit.UnitPathVisualisation();
gridVisualisation.ChangeToGoalNodeColourOnly(goalNode);
}
}
void RightMouseClickToChangeGoalNodePositon()
{
//Right click
if (Input.GetMouseButtonDown(1))
{
if (Physics.Raycast(ray, out hit))
{
Debug.Log(hit.collider.gameObject.tag);
//added mesh chollider to tile to make sure we are able to hit the tile plane.
if (hit.collider.gameObject.tag == "Node")
{
NodeVisualisation nodeVisualisation = hit.collider.gameObject.GetComponentInParent <NodeVisualisation>();
if (nodeVisualisation.gridNode.nodeType != NodeType.Blocked)
{
ChangeTileToGoalNode(nodeVisualisation);
RecalculateUnitPath();
}
}
}
}
}
void SearchUnitPathRecalculate(NodeVisualisation node)
{
ClearTextFromDisplay();
for (int i = 0; i < unitData.Count; i++)
{
if (unitData[i].SearchPathChangedNode(node.gridNode))
{
unitData[i].UnitFindPath(goalNode.transform, algorithmIndex, heuristicIndex);
}
AddMessageToTextBox(unitData[i].ReturnUnitMessage(), i);
if (PathfindingVisualisationAid)
{
if (!(unitData.Count > 1))
{
unitData[i].UnitSearchVisualisation();
}
unitData[i].UnitPathVisualisation();
gridVisualisation.ChangeToGoalNodeColourOnly(goalNode);
}
}
UpdateScrollBarToBottom();
}
public void ChangeToFloorNode(NodeVisualisation nodevisualisation)
{
nodevisualisation.gridNode.nodeType = NodeType.Open;
nodevisualisation.ColorNode(baseColor);
}
public void ChangeToGrassNode(NodeVisualisation nodevisualisation)
{
nodevisualisation.gridNode.nodeType = NodeType.Grass;
nodevisualisation.ColorNode(grassColor);
}
public void ChangeToWaterNode(NodeVisualisation nodevisualisation)
{
nodevisualisation.gridNode.nodeType = NodeType.Water;
nodevisualisation.ColorNode(waterColor);
}
public void ChangeToGoalNode(NodeVisualisation nodevisualisation)
{
nodevisualisation.gridNode.nodeType = NodeType.GoalNode;
nodevisualisation.ColorNode(goalColor);
}
public void ChangeToGoalNodeColourOnly(NodeVisualisation nodevisualisation)
{
nodevisualisation.ColorNode(goalColor);
}
public void ChangeToGoalNodeColourOnly(Node node)
{
NodeVisualisation visualNode = nodesVisualisationData[node.xIndexPosition, node.yIndexPosition];
visualNode.ColorNode(goalColor);
}
