private void Attack(MazeUnit target)
{
projectileShot = Instantiate(projectilePrefab, transform.position, Quaternion.identity);
projectileShot.SetTarget(target.transform);
projectileShot.SetObstacleMask(projectileBlockingLayers);
projectileShot.onHit += OnHit;
}
private void placeNewMazeUnit(MazeUnit newMazeUnit, MazeUnit prevMazeUnit, char dir)
{
Vector3 prevLocation = prevMazeUnit.transform.localPosition;
if (dir == 'N')
{
newMazeUnit.transform.SetParent(transform);
newMazeUnit.transform.localPosition = new Vector3(prevLocation.x, prevLocation.y, prevLocation.z + 1);
newMazeUnit.deleteWall('S');
prevMazeUnit.deleteWall('N');
}
else if (dir == 'E')
{
newMazeUnit.transform.SetParent(transform);
newMazeUnit.transform.localPosition = new Vector3(prevLocation.x + 1, prevLocation.y, prevLocation.z);
newMazeUnit.deleteWall('W');
prevMazeUnit.deleteWall('E');
}
else if (dir == 'S')
{
newMazeUnit.transform.SetParent(transform);
newMazeUnit.transform.localPosition = new Vector3(prevLocation.x, prevLocation.y, prevLocation.z - 1);
newMazeUnit.deleteWall('N');
prevMazeUnit.deleteWall('S');
}
else
{
newMazeUnit.transform.SetParent(transform);
newMazeUnit.transform.localPosition = new Vector3(prevLocation.x - 1, prevLocation.y, prevLocation.z);
newMazeUnit.deleteWall('E');
prevMazeUnit.deleteWall('W');
}
}
public override IEnumerator TakeTurn()
{
DidAction = false;
projectileShot = null;
MazeUnit possibleTarget = VisionUtils.FindVisibleEnemy(transform, visionRange, enemyLayers, visionBlockingLayers);
if (possibleTarget)
{
Attack(possibleTarget);
DidAction = true;
if (ShouldAnimate())
{
animator.SetTrigger("Attack");
yield return(null);
while (!IsAnimationIdle())
{
yield return(null);
}
}
while (projectileShot)
{
yield return(null);
}
}
}
private void SpawnMazeUnit(int i, int j, float currentX, float currentZ)
{
GameObject mazeUnitObject = Instantiate(mazeUnitPrefab, platformsHolder);
mazeUnitObject.transform.position = new Vector3(currentX, 1, currentZ);
GameObject baseUnitObject = Instantiate(baseUnitPrefab, platformsHolder);
baseUnitObject.transform.position = mazeUnitObject.transform.position + Vector3.down;
MazeUnit mazeUnit = mazeUnitObject.GetComponent <MazeUnit>();
mazeUnit.baseUnit = baseUnitObject;
mazeUnit.x = i;
mazeUnit.y = j;
if (AreBorderIndexes(i, j))
{
mazeUnit.isBorder = true;
}
else
{
startingMazeUnitCandidates.Add(mazeUnit);
}
SetNeighbouring(mazeUnit, i, j);
matrix[matrix.Count - 1].Add(mazeUnit);
}
private void Add(MazeUnit newUnit)
{
var newElement = new PathElement(newUnit);
newElement = PathEditorUtils.GetElementType(newElement);
var nr_el = pathToEdit.PathAsLinkedList.Count; // count all elements in the path to get the second last for turning calculation
if (nr_el >= 1)
{
var previousElement = pathToEdit.PathAsLinkedList.Last.Value;
if (nr_el >= 2)
{
var secpreviousElement = pathToEdit.PathAsLinkedList.Last.Previous.Value;
newElement = PathEditorUtils.GetTurnType(newElement, previousElement, secpreviousElement);
}
else
{
newElement.Turn = TurnType.STRAIGHT;
}
}
pathToEdit.PathAsLinkedList.AddLast(newElement);
}
private void MakePath()
{
int startingMazeUnitIndex = Random.Range(0, startingMazeUnitCandidates.Count);
MazeUnit startingMazeUnit = startingMazeUnitCandidates[startingMazeUnitIndex];
MakePathHelper(startingMazeUnit);
}
private MazeUnit GetPossibleTarget()
{
MazeMovement unitMovement = unit.GetMovement();
Maze maze = Maze.Instance;
MazeUnit possibleTarget = maze.GetOccupant(unitMovement.GetMazePos() + Vector2Int.up);
if (IsTargetValid(possibleTarget))
{
return(possibleTarget);
}
possibleTarget = maze.GetOccupant(unitMovement.GetMazePos() + Vector2Int.right);
if (IsTargetValid(possibleTarget))
{
return(possibleTarget);
}
possibleTarget = maze.GetOccupant(unitMovement.GetMazePos() + Vector2Int.down);
if (IsTargetValid(possibleTarget))
{
return(possibleTarget);
}
possibleTarget = maze.GetOccupant(unitMovement.GetMazePos() + Vector2Int.left);
if (IsTargetValid(possibleTarget))
{
return(possibleTarget);
}
return(null);
}
public override IEnumerator TakeTurn()
{
DidAction = false;
MazeUnit possibleTarget = GetPossibleTarget();
if (possibleTarget)
{
Attack(possibleTarget);
DidAction = true;
if (!ShouldAnimate())
{
yield break;
}
animator.SetTrigger("Attack");
yield return(null);
while (!IsAnimationIdle())
{
yield return(null);
}
}
}
private OpenDirections ValidateOpenDirections(MazeUnit u)
{
var children = u.transform.AllChildren().Where(
go => !(go.Equals(MazeUnit.TOP) || go.Equals(MazeUnit.FLOOR)));
OpenDirections waysOpen = OpenDirections.None;
foreach (var item in children)
{
if (item.name.Equals(MazeUnit.NORTH) && !item.activeSelf)
{
waysOpen |= OpenDirections.North;
}
if (item.name.Equals(MazeUnit.SOUTH) && !item.activeSelf)
{
waysOpen |= OpenDirections.South;
}
if (item.name.Equals(MazeUnit.WEST) && !item.activeSelf)
{
waysOpen |= OpenDirections.West;
}
if (item.name.Equals(MazeUnit.EAST) && !item.activeSelf)
{
waysOpen |= OpenDirections.East;
}
}
return(waysOpen);
}
public void TryConnectingCurrentSelection()
{
if (CurrentSelection == null)
{
return;
}
if (!CurrentSelection.Any())
{
return;
}
var iterator = CurrentSelection.GetEnumerator();
MazeUnit last = null;
while (iterator.MoveNext())
{
var current = iterator.Current.GetComponent <MazeUnit>();
if (!last)
{
last = current;
continue;
}
Debug.Log(current.GridID.ToString());
// check if current and last are really neighbors:
if (Math.Abs(current.GridID.x - last.GridID.x) + Math.Abs(current.GridID.y - last.GridID.y) == 1)
{
// check which direction we go, possibilities:
if (current.GridID.x - last.GridID.x == 1) // going east
{
last.Open(OpenDirections.East);
current.Open(OpenDirections.West);
}
else if (current.GridID.x - last.GridID.x == -1) // going west
{
last.Open(OpenDirections.West);
current.Open(OpenDirections.East);
}
if (current.GridID.y - last.GridID.y == 1) // going north
{
last.Open(OpenDirections.North);
current.Open(OpenDirections.South);
}
else if (current.GridID.y - last.GridID.y == -1) // going south
{
last.Open(OpenDirections.South);
current.Open(OpenDirections.North);
}
}
last = current;
}
}
public override bool AttemptSpawn(MazePopulator.PopulationData data)
{
Cell cell = GetRandomFreeUnitCell(data);
MazeUnit enemy = InstantiateInCell(GetUnitPrefab(), cell);
data.mazeData[cell.x, cell.y].occupant = enemy;
return(true);
}
private void Attack(MazeUnit possibleTarget)
{
Health targetHealth = possibleTarget.GetComponent <Health>();
if (!targetHealth)
{
Debug.LogError(gameObject.name + " is trying to attack a target with no Health: " + possibleTarget.name);
return;
}
targetHealth.TakeDamage(attackDamage);
}
static void DrawGizmos(MazeUnit unit, GizmoType gizmoType)
{
Vector3 position = unit.transform.position;
var tempHandleColor = Handles.color;
Handles.color = Color.green;
if (Vector3.Distance(position, Camera.current.transform.position) < 10f)
{
foreach (var item in unit.transform.AllChildren())
{
var customForward = Vector3.zero;
if (item.name == MazeUnit.TOP)
{
customForward = Vector3.down;
}
if (item.name == MazeUnit.FLOOR)
{
customForward = Vector3.up;
}
if (item.name == MazeUnit.WEST)
{
customForward = Vector3.left;
}
if (item.name == MazeUnit.EAST)
{
customForward = Vector3.right;
}
if (item.name == MazeUnit.SOUTH)
{
customForward = Vector3.back;
}
if (item.name == MazeUnit.NORTH)
{
customForward = Vector3.forward;
}
var pos = item.transform.position;
Handles.DrawWireDisc(pos, customForward, 0.1f);
Handles.Label(pos, new GUIContent(item.name));
}
}
Handles.color = tempHandleColor;
}
private MazeUnit createNewUnitInMaze(char dir, int xstart, int zstart)
{
MazeUnit oldUnit = mazeFloor[xstart, zstart];
MazeUnit newUnit = Instantiate(mazeUnitPrefab);
newUnit.setDirection(dir);
mazeFloor[XafterDirection(xstart, dir), ZafterDirection(zstart, dir)] = newUnit;
newUnit.setPos(XafterDirection(xstart, dir), ZafterDirection(zstart, dir));
placeNewMazeUnit(newUnit, oldUnit, dir);
lastMazeUnit = newUnit;
return(newUnit);
}
private void Attack()
{
MazeUnit target = Maze.Instance.GetOccupant(attackPos);
if (target)
{
Health targetHealth = target.GetComponent <Health>();
if (targetHealth)
{
targetHealth.TakeDamage(damage);
Used();
}
}
}
public void ConfigureTopLightBasedOnUnitConfiguration(MazeUnit unit, TopLighting topLight)
{
var unitChildren = unit.transform.AllChildren();
var lightChildren = topLight.transform.AllChildren();
foreach (var lightChild in lightChildren)
{
var corresponding = unitChildren.Where((u) => u.name.Equals(lightChild.name)).FirstOrDefault();
if (corresponding != null)
{
lightChild.SetActive(!corresponding.activeSelf);
}
}
}
public void MoveUnitTo(MazeUnit unit, Vector2Int pos)
{
if (IsPosOutOfBounds(pos))
{
Debug.LogError(unit.name + ": Trying to move out of bounds");
}
CellData cellData = mazeData[pos.x, pos.y];
if (cellData.occupant != null && cellData.occupant != unit)
{
Debug.LogError(unit.name + ": Trying to move unit to occupied space");
return;
}
mazeData[unit.GetMovement().GetMazePos().x, unit.GetMovement().GetMazePos().y].occupant = null;
cellData.occupant = unit;
}
public override IEnumerator TakeTurn()
{
DidAction = false;
if (turnsSinceLastMove != -1)
{
turnsSinceLastMove++;
}
// Still lock on targets even if we can't move right now
if (!target)
{
target = VisionUtils.FindVisibleEnemy(transform, visionRange, enemyLayers, visionBlockingLayers);
}
if (turnsSinceLastMove != -1 && turnsSinceLastMove < turnsPerMove)
{
yield break;
}
if (target)
{
List <Vector2Int> path = AStar.FindPath(
Maze.Instance,
unit.GetMovement().GetMazePos(),
target.GetMovement().GetMazePos(),
Maze.Instance.GetValidNeighbourCoords(target.GetMovement().GetMazePos()));
if (path.Count > pursuitSteps)
{
target = null;
yield break;
}
if (path.Count >= 1 && unit.GetMovement().AttemptMoveToPos(path[1]))
{
turnsSinceLastMove = 0;
DidAction = true;
}
}
yield break;
}
private void SetNeighbouring(MazeUnit mazeUnit, int i, int j)
{
if (i > 0)
{
matrix[i - 1][j].BecomeNeighbours(MazeUnit.Direction.Top, mazeUnit);
if (j > 0)
{
matrix[i - 1][j - 1].BecomeNeighbours(MazeUnit.Direction.TopLeft, mazeUnit);
}
if (j < baseSize.z - 1)
{
matrix[i - 1][j + 1].BecomeNeighbours(MazeUnit.Direction.TopRight, mazeUnit);
}
}
if (j > 0)
{
matrix[i][j - 1].BecomeNeighbours(MazeUnit.Direction.Left, mazeUnit);
}
}
public static MazeUnit InitializeUnit(beMobileMaze maze, Vector2 tilePos, float unitFloorOffset, GameObject unit)
{
var tilePositionInLocalSpace = new Vector3(
(tilePos.x * maze.RoomDimension.x) + (maze.RoomDimension.x / 2f),
unitFloorOffset,
(tilePos.y * maze.RoomDimension.z) + (maze.RoomDimension.z / 2f));
// set the cubes parent to the game object for organizational purposes
unit.transform.parent = maze.transform;
//unit.transform.localPosition = maze.transform.position + maze.transform.TransformPoint(tilePositionInLocalSpace);
unit.transform.localPosition = tilePositionInLocalSpace;
// give the u a assetName that represents it's location within the tile maze
unit.name = string.Format(maze.UnitNamePattern, tilePos.x, tilePos.y);
MazeUnit mazeUnit = unit.GetComponent <MazeUnit>();
mazeUnit.Initialize(tilePos, maze.RoomDimension);
return(mazeUnit);
}
private bool MakePathHelper(MazeUnit current, int length = 1)
{
pathTries++;
current.gameObject.SetActive(false);
path.AddLast(current);
foreach (var dir in current.GetRandomizedAvailableDiggableDirections())
{
var neighbour = current.neighbours[dir];
if (length >= maxPathSize)
{
return(true);
}
if (neighbour.CanBeDugFrom(dir.GetOpposite()))
{
if (MakePathHelper(neighbour, length + 1))
{
return(true);
}
// Sometimes the algorithm can get stuck in a long recursion while trying to find a good lengthy path.
// That is why we have this code here that forces the path to end after a number of tries.
// We still check if the neighbour can be dug, because we don't want to dig for the end of the path from the
// border or make a loop in the path.
else if (pathTries >= pathMaxTries && neighbour.CanBeDugFrom(dir.GetOpposite()))
{
path.AddLast(neighbour);
neighbour.gameObject.SetActive(false);
return(true);
}
}
}
current.gameObject.SetActive(true);
path.RemoveLast();
return(false);
}
/// <summary>
/// Check if there are already unitsFound existing and put them into the new Grid
/// </summary>
/// <param name="maze"></param>
/// <param name="newColumns"></param>
/// <param name="newRows"></param>
/// <returns></returns>
public static MazeUnit[,] ReconfigureGrid(beMobileMaze maze, int newColumns, int newRows)
{
MazeUnit[,] newGrid = new MazeUnit[newColumns, newRows];
for (int col = 0; col < newColumns; col++)
{
for (int row = 0; row < newRows; row++)
{
var hostGameObject = GameObject.Find(string.Format(maze.UnitNamePattern, col, row));
if (hostGameObject != null)
{
newGrid[col, row] = hostGameObject.GetComponent <MazeUnit>();
}
}
}
maze.Grid = newGrid;
var unitsOutsideOfGrid = maze.Units.Select(
(u) =>
{
if (u.GridID.x > newColumns || u.GridID.y > newRows)
{
return(u.gameObject);
}
else
{
return(null);
}
});
unitsOutsideOfGrid.ImmediateDestroyObjects();
return(maze.Grid);
}
private void createEmptyFloor(int level)
{
for (int i = 0; i < sizeX; i++)
{
int j = 0;
int j2 = sizeZ - 1;
MazeUnit edgeUnit = Instantiate(mazeUnitPrefab);
edgeUnit.setPos(i, j);
edgeUnit.transform.SetParent(transform);
edgeUnit.transform.localPosition = new Vector3(i, level, j);
MazeUnit edgeUnit2 = Instantiate(mazeUnitPrefab);
edgeUnit2.setPos(i, j2);
edgeUnit2.transform.SetParent(transform);
edgeUnit2.transform.localPosition = new Vector3(i, level, j2);
MazeUnit edgeUnit3 = Instantiate(mazeUnitPrefab);
edgeUnit3.setPos(j, i);
edgeUnit3.transform.SetParent(transform);
edgeUnit3.transform.localPosition = new Vector3(j, level, i);
MazeUnit edgeUnit4 = Instantiate(mazeUnitPrefab);
edgeUnit4.setPos(j2, i);
edgeUnit4.transform.SetParent(transform);
edgeUnit4.transform.localPosition = new Vector3(j2, level, i);
}
}
public static void ReplaceUnit(beMobileMaze hostMaze, MazeUnit obtainedUnit, MazeUnit unitContainingReplacements, bool resetScaling = true, bool forceRecalculationOfComponentPosition = true)
{
#region prepare children lists
int new_ChildCount = unitContainingReplacements.transform.childCount;
List <GameObject> new_Children = new List <GameObject>();
int old_ChildCount = obtainedUnit.transform.childCount;
List <GameObject> existing_children = new List <GameObject>();
for (int i = 0; i < old_ChildCount; i++)
{
var old_child = obtainedUnit.transform.GetChild(i);
existing_children.Add(old_child.gameObject);
}
for (int i = 0; i < new_ChildCount; i++)
{
var new_child = unitContainingReplacements.transform.GetChild(i);
new_Children.Add(new_child.gameObject);
}
#endregion
if (resetScaling)
{
obtainedUnit.transform.localScale = Vector3.one;
}
var dimension = unitContainingReplacements.Dimension;
var boxCollider = obtainedUnit.GetComponent <BoxCollider>();
boxCollider.size = dimension;
boxCollider.center = new Vector3(0, boxCollider.size.y / 2, 0);
foreach (var replacementPart in new_Children)
{
if (existing_children.Any((go) => go.name.Equals(replacementPart.name)))
{
var old_equivalent = existing_children.Single((go) => go.name.Equals(replacementPart.name));
if (resetScaling)
{
old_equivalent.transform.localScale = Vector3.one;
}
replacementPart.transform.SetParent(old_equivalent.transform.parent, false);
old_equivalent.transform.parent = null;
if (old_equivalent.name.Equals(MazeUnit.TOP))
{
replacementPart.transform.localPosition = new Vector3(0, dimension.y, 0);
}
if (old_equivalent.name.Equals(MazeUnit.NORTH))
{
replacementPart.transform.localPosition = new Vector3(0, dimension.y / 2, dimension.z / 2);
}
if (old_equivalent.name.Equals(MazeUnit.SOUTH))
{
replacementPart.transform.localPosition = new Vector3(0, dimension.y / 2, -dimension.z / 2);
}
if (old_equivalent.name.Equals(MazeUnit.WEST))
{
replacementPart.transform.localPosition = new Vector3(-dimension.x / 2, dimension.y / 2, 0);
}
if (old_equivalent.name.Equals(MazeUnit.EAST))
{
replacementPart.transform.localPosition = new Vector3(dimension.x / 2, dimension.y / 2, 0);
}
if (old_equivalent.name.Equals(MazeUnit.FLOOR))
{
replacementPart.transform.localPosition = new Vector3(0, 0, 0);
}
var meshRenderer = replacementPart.GetComponent <MeshRenderer>();
var oldMeshRenderer = old_equivalent.GetComponent <MeshRenderer>();
if (meshRenderer != null && oldMeshRenderer != null)
{
meshRenderer.sharedMaterials = oldMeshRenderer.sharedMaterials;
}
replacementPart.SetActive(old_equivalent.activeSelf);
}
}
foreach (var item in existing_children)
{
UnityEngine.Object.DestroyImmediate(item.gameObject);
}
}
private void renderUiForSingleMazeSelected()
{
EditorGUILayout.BeginVertical();
GUILayout.Label("Replace Units");
replacementPrefab = (GameObject)EditorGUILayout.ObjectField(replacementPrefab, typeof(UnityEngine.GameObject), false);
MazeUnit mazeUnit = null;
string errorMessage = "No prefab selected!";
if (replacementPrefab != null)
{
mazeUnit = replacementPrefab.GetComponent <MazeUnit>();
}
else
{
EditorGUILayout.HelpBox(errorMessage, MessageType.Error);
}
if (mazeUnit == null)
{
if (replacementPrefab != null)
{
errorMessage = "Selected Asset is no MazeUnit!";
EditorGUILayout.HelpBox(errorMessage, MessageType.Error);
}
}
else
{
if (GUILayout.Button(new GUIContent("Replace Maze Units \n with this prefab.", ToolTip_Replace_Units), GUILayout.Height(50f)))
{
CallReplaceAlgorithm();
}
EditorGUILayout.HelpBox(MsgBox_Replace_Action, MessageType.Warning);
}
EditorGUILayout.EndVertical();
if (replacementPrefab)
{
var previewTexture = AssetPreview.GetAssetPreview(replacementPrefab);
GUILayout.Box(previewTexture);
}
if (GUILayout.Button(new GUIContent("Save as new prefab?", "Creates a new prefab instead of overwriting the old one!")))
{
var targetPath = EditorUtility.SaveFilePanelInProject("Save new maze prefab", "ResizedMaze", EditorEnvironmentConstants.PREFAB_EXTENSION, "sdfsfd");
if (targetPath != null)
{
PrefabUtility.CreatePrefab(targetPath, selectedMaze.gameObject);
}
}
// Resize currently through replacement of Units!
//GUILayout.Label("Change:", EditorStyles.boldLabel);
//selectedMaze.RoomDimension = EditorGUILayout.Vector3Field("Room dimension", selectedMaze.RoomDimension );
//if (GUILayout.Button(new GUIContent("Resize (recommended)", "Resize the geometry"), GUILayout.Height(30)))
//{
// var modificationModel = new UnitMeshModificationModel(selectedMaze.RoomDimension, Vector3.zero ,true);
// ApplyToAllMazeUnits(selectedMaze, (u) => {
// MazeEditorUtil.ResizeUnitByMeshModification(u.gameObject, modificationModel);
// });
//}
//if (GUILayout.Button(new GUIContent("Rescale", "Rescale over the localScale value")))
//{
// MazeEditorUtil.Rescale(selectedMaze, selectedMaze.RoomDimension, unitFloorOffset);
// MazeEditorUtil.RebuildGrid(selectedMaze);
//}
}
private void Remove(MazeUnit unit)
{
var elementToRemove = pathToEdit.PathAsLinkedList.First(e => e.Unit.Equals(unit));
pathToEdit.PathAsLinkedList.Remove(elementToRemove);
}
public void Init(MazeUnit unit)
{
this.unit = unit;
}
public void generateMazeFloor(int xStart, int zStart, char direction, int level, MazeUnit[,] floor, int size)
{
sizeX = size;
sizeZ = size;
mazeFloor = floor;
mazeUnitList = new List <MazeUnit>();
MazeUnit firstUnit = Instantiate(mazeUnitPrefab);
mazeFloor[xStart, zStart] = firstUnit;
mazeFloor[xStart, zStart].setPos(xStart, zStart);
mazeFloor[xStart, zStart].transform.SetParent(transform);
mazeFloor[xStart, zStart].transform.localPosition = new Vector3(xStart, level, zStart);
if (isOnEdge(xStart, zStart))
{
mazeFloor[xStart, zStart].deleteWall('E');
mazeFloor[xStart, zStart].deleteWall('W');
mazeFloor[xStart, zStart].deleteWall('S');
mazeFloor[xStart, zStart].deleteWall('N');
if (level == startingLevel)
{
for (int i = xStart - 2; i < xStart + 3; i++)
{
for (int j = zStart - 2; j < zStart + 3; j++)
{
if (i != xStart || j != zStart)
{
MazeUnit edgeUnit = Instantiate(mazeUnitPrefab);
edgeUnit.setPos(i, j);
edgeUnit.transform.SetParent(transform);
edgeUnit.transform.localPosition = new Vector3(i, level, j);
edgeUnit.onlyLeaveFloor();
}
}
}
}
}
if (level != startingLevel)
{
mazeFloor[xStart, zStart].deleteFloor();
}
int xcurr = XafterDirection(xStart, direction);
int zcurr = ZafterDirection(zStart, direction);
if (!withinBounds(xStart, zStart, direction))
{
mazeFloor[xStart, zStart].deleteWall(direction);
MazeUnit[,] f = new MazeUnit[sizeX, sizeZ];
f[xStart, zStart] = firstUnit;
for (int i = xStart - 1; i < xStart + 2; i++)
{
for (int j = zStart - 1; j < zStart + 2; j++)
{
if (withinBounds(i, j, 'C') && isOnEdge(i, j))
{
generateMazeFloor(i, j, getOppositeDirection(direction), level, f, size);
return;
}
}
}
}
char randDir = generateRandomDirection();
mazeUnitList.Add(createNewUnitInMaze(direction, xStart, zStart));
int superCount = 0;
while (mazeUnitList.Count > 0 && superCount < 200)
{
superCount++;
xcurr = mazeUnitList[0].x;
zcurr = mazeUnitList[0].z;
int count = 0;
while (!isEmptyMazeSpot(xcurr, zcurr, randDir, mazeFloor) && count < 4)
{
count++;
randDir = generateRandomDirection();
}
if (!withinBounds(xcurr, zcurr, randDir))
{
mazeUnitList.Remove(mazeUnitList[0]);
}
else if (!isEmptyMazeSpot(xcurr, zcurr, randDir, mazeFloor))
{
mazeFloor[xcurr, zcurr].deleteWall(randDir);
mazeFloor[XafterDirection(xcurr, randDir), ZafterDirection(zcurr, randDir)].deleteWall(getOppositeDirection(randDir));
mazeUnitList.Remove(mazeUnitList[0]);
}
else
{
mazeUnitList.Add(createNewUnitInMaze(randDir, xcurr, zcurr));
}
}
for (int i = 0; i < sizeX; i++)
{
for (int j = 0; j < sizeZ; j++)
{
if (mazeFloor[i, j] != null)
{
mazeFloor[i, j].deleteAllWallCheck();
}
}
}
//placing stairs!
int xStair = lastMazeUnit.x;
int zStair = lastMazeUnit.z;
char dirStair = lastMazeUnit.dir;
mazeFloor[xStair, zStair].deleteCeiling();
Stairs s = Instantiate(stairsPrefab);
s.transform.SetParent(transform);
s.transform.localPosition = new Vector3(xStair, level, zStair);
s.setDirOfStairs(dirStair);
for (int i = xStair - 1; i < xStair + 2; i++)
{
for (int j = zStair - 1; j < zStair + 2; j++)
{
if (i != xStair || j != zStair)
{
MazeUnit edgeUnit = Instantiate(mazeUnitPrefab);
edgeUnit.setPos(i, j);
edgeUnit.transform.SetParent(transform);
edgeUnit.transform.localPosition = new Vector3(i, level, j);
edgeUnit.onlyLeaveCeiling();
}
}
}
//run traceback
getTraceBackDistance(xStart, zStart, xStair, zStair);
if (level < height)
{
generateMazeFloor(xStair, zStair, dirStair, level + 1, new MazeUnit[sizeX, sizeZ], sizeX);
}
else
{
lastStairX = xStair;
lastStairZ = zStair;
}
}
public void BecomeNeighbours(Direction direction, MazeUnit other)
{
neighbours.Add(direction, other);
other.neighbours.Add(direction.GetOpposite(), this);
}
public void TryDisconnectingCurrentSelection()
{
if (CurrentSelection == null)
{
return;
}
if (!CurrentSelection.Any())
{
return;
}
if (CurrentSelection.Count == 1)
{
var unit = CurrentSelection.First().GetComponent <MazeUnit>();
unit.Close(OpenDirections.North);
unit.Close(OpenDirections.South);
unit.Close(OpenDirections.West);
unit.Close(OpenDirections.East);
}
var iterator = CurrentSelection.GetEnumerator();
MazeUnit last = null;
while (iterator.MoveNext())
{
var current = iterator.Current.GetComponent <MazeUnit>();
if (!last)
{
last = current;
continue;
}
if (current.GridID.x - 1 == last.GridID.x)
{
last.Close(OpenDirections.East);
current.Close(OpenDirections.West);
}
else if (current.GridID.x + 1 == last.GridID.x)
{
last.Close(OpenDirections.West);
current.Close(OpenDirections.East);
}
if (current.GridID.y - 1 == last.GridID.y)
{
last.Close(OpenDirections.North);
current.Close(OpenDirections.South);
}
else if (current.GridID.y + 1 == last.GridID.y)
{
last.Close(OpenDirections.South);
current.Close(OpenDirections.North);
}
last = current;
}
}
