public override void GizmoDrawings(beMobileMaze maze, GizmoType type)
{
var pathController = backend.selectedMaze.GetComponent <PathController>();
if (!pathController.Paths.Any())
{
return;
}
if (!pathController.Paths.Any(p => p.ID == selected))
{
return;
}
var pathToRender = pathController.Paths.First(p => p.ID == selected);
var hoveringDistance = new Vector3(0, maze.RoomDimension.y * 0.9f, 0);
var temp = Gizmos.color;
Gizmos.color = tilePositionIsValid ? Color.green : Color.red;
Gizmos.DrawCube(
backend.visual.MarkerPosition + new Vector3(0, maze.RoomDimension.y * 0.5f, 0),
maze.RoomDimension * 0.4f);
Gizmos.color = temp;
PathEditorUtils.RenderPathElements(maze, pathToRender, hoveringDistance, GetPrimaryColor());
}
public static void ApplyToAllMazeUnits(this beMobileMaze maze, Action <MazeUnit> action)
{
foreach (var item in maze.Units)
{
action(item);
}
}
private void InitializeWithMaze(beMobileMaze currentSelection)
{
selectedMaze = currentSelection;
prefabOfSelectedMaze = PrefabUtility.GetPrefabParent(currentSelection);
pathToPrefab = AssetDatabase.GetAssetPath(prefabOfSelectedMaze);
}
public void RenderPaths(beMobileMaze maze, Vector3 drawingOffset)
{
var pathController = maze.GetComponent <PathController>();
if (pathController == null)
{
return;
}
foreach (var path in pathController.Paths)
{
float localDrawingOffset = path.ID * 0.1f;
if (localDrawingOffset > 1)
{
localDrawingOffset = 1 - localDrawingOffset;
}
Color drawingColor;
if (path.ID % 2 == 0)
{
drawingColor = new Color(localDrawingOffset, (localDrawingOffset * 0.5f) + 0.5f, 1 - localDrawingOffset);
}
else
{
drawingColor = new Color(localDrawingOffset, 1 - localDrawingOffset, (localDrawingOffset * 0.5f) + 0.5f);
}
var offset = drawingOffset + new Vector3(localDrawingOffset, 0, localDrawingOffset);
PathEditorUtils.RenderPathElements(maze, path, offset, drawingColor);
}
}
string RenderMazeGrid(beMobileMaze maze)
{
if (maze.Grid == null)
{
return("No Grid available!");
}
StringBuilder gridCode = new StringBuilder();
StringBuilder line = new StringBuilder();
int cols = maze.Grid.GetLength(0);
int rows = maze.Grid.GetLength(1);
for (int r = 0; r < rows; r++)
{
for (int c = 0; c < cols; c++)
{
if (maze.Grid[c, r] != null)
{
line.AppendFormat(" {0}", 1);
}
else
{
line.AppendFormat(" {0}", 0);
}
}
gridCode.AppendLine(line.ToString());
line.Remove(0, line.Length);
}
;
return(gridCode.ToString());
}
public static void DrawFloorGrid(beMobileMaze maze)
{
// store map width, height and position
var mapWidth = maze.MazeWidthInMeter + maze.RoomDimension.x;
var mapHeight = maze.MazeLengthInMeter + maze.RoomDimension.z;
//var position = maze.transform.position;
var position = new Vector3(0, 0, 0);
var ro_x1 = new Vector3(-0.01f, 0, -0.01f);
var ro_x2 = new Vector3(0.01f, 0, -0.01f);
var ro_x3 = new Vector3(-0.01f, 0, 0.01f);
var ro_x4 = new Vector3(0.01f, 0, 0.01f);
// draw layer border
Gizmos.color = Color.black;
Gizmos.DrawLine(position + ro_x1, position + new Vector3(mapWidth, 0, 0) + ro_x2);
Gizmos.DrawLine(position + ro_x1, position + new Vector3(0, 0, mapHeight) + ro_x3);
Gizmos.DrawLine(position + new Vector3(mapWidth, 0, 0) + ro_x2, position + new Vector3(mapWidth, 0, mapHeight) + ro_x4);
Gizmos.DrawLine(position + new Vector3(0, 0, mapHeight) + ro_x3, position + new Vector3(mapWidth, 0, mapHeight) + ro_x4);
Vector3 lineStart;
Vector3 lineEnde;
// draw tile cells
Gizmos.color = Color.white * new Color(1, 1, 1, 0.5f);
for (float i = 0; i <= maze.Columns; i++)
{
float xOffset = i * maze.RoomDimension.x;
lineStart = position + new Vector3(xOffset, 0, 0);
lineEnde = position + new Vector3(xOffset, 0, mapHeight);
var labelPos = position + new Vector3(xOffset, 0, 0);
Handles.Label(labelPos, i.ToString());
Gizmos.DrawLine(lineStart, lineEnde);
}
for (float i = 0; i <= maze.Rows; i++)
{
float yoffset = i * maze.RoomDimension.z;
lineStart = position + new Vector3(0, 0, yoffset);
lineEnde = position + new Vector3(mapWidth, 0, yoffset);
var labelPos = position + new Vector3(0, 0, yoffset);
Handles.Label(labelPos, i.ToString());
Gizmos.DrawLine(lineStart, lineEnde);
}
var zeroField = new Vector3(position.x + (maze.RoomDimension.x / 2), 0, position.x + (maze.RoomDimension.x / 2));
Gizmos.color = new Color(Color.green.r, Color.green.g, Color.green.b, 0.1f);
Gizmos.DrawCube(zeroField, new Vector3(maze.RoomDimension.x - 0.1f, 0, maze.RoomDimension.z - 0.1f));
}
public static void Rescale(beMobileMaze maze, Vector3 newUnitScale, float floorOffset)
{
foreach (var item in maze.Units)
{
item.transform.localScale = newUnitScale;
InitializeUnit(maze, item.GridID, floorOffset, item.gameObject);
}
}
internal static void CacheUnitsIn(beMobileMaze maze)
{
var unitsFound = maze.gameObject.GetComponentsInChildren <MazeUnit>(true);
maze.Units.Clear();
maze.Units.AddRange(unitsFound);
}
public static void RebuildGrid(beMobileMaze maze)
{
CacheUnitsIn(maze);
var GridDim = beMobileMaze.CalcGridSize(maze);
maze.Grid = beMobileMaze.FillGridWith(maze.Units, Mathf.FloorToInt(GridDim.x), Mathf.FloorToInt(GridDim.y));
}
private void AddANewUnit(beMobileMaze maze, Vector2 pos, MazeCreationWorkflowBackEnd backend)
{
var unitHost = PrefabUtility.InstantiatePrefab(unitPrefab) as GameObject;
PrefabUtility.DisconnectPrefabInstance(unitHost);
var unit = MazeEditorUtil.InitializeUnit(maze, pos, unitFloorOffset, unitHost);
maze.Grid[(int)pos.x, (int)pos.y] = unit;
maze.Units.Add(unit);
}
/// <summary>
/// Export as a textfield which could be read as a matlab expression and evals to an matrix containing zeros and ones on unit positions
/// </summary>
/// <param name="maze"></param>
/// <param name="targetFile"></param>
public void Export(beMobileMaze maze, FileInfo targetFile)
{
using (var fs = new FileStream(targetFile.FullName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
var builders = new List <StringBuilder>();
if (maze.Rows == 0 || maze.Columns == 0)
{
OnUnexpectedValuesFound("Maze has no Grid to use during Export process");
if (abortExport)
{
return;
}
}
builders.Add(AppendMazeMatrix(maze));
var pathController = maze.GetComponent <PathController>();
if (pathController.Paths.Count == 0)
{
OnUnexpectedValuesFound("No Paths found during Export process");
if (abortExport)
{
return;
}
}
foreach (var path in pathController.Paths)
{
builders.Add(AppendPathWithMatrix(maze, path));
}
StringBuilder finalBuilder = new StringBuilder();
int appedingIndex = 0;
do
{
finalBuilder.Append(builders[appedingIndex]).AppendLine();
appedingIndex++;
} while (appedingIndex < builders.Count);
byte[] info = new UTF8Encoding(true).GetBytes(finalBuilder.ToString());
fs.Write(info, 0, info.Length);
}
}
public static void ReplaceUnits(beMobileMaze targetMaze, GameObject replacementPrefab)
{
foreach (var existingUnit in targetMaze.Units)
{
var newUnitFromPrefab = PrefabUtility.InstantiatePrefab(replacementPrefab) as GameObject;
PrefabUtility.DisconnectPrefabInstance(newUnitFromPrefab);
var newUnit = newUnitFromPrefab.GetComponent <MazeUnit>();
ReplaceUnit(targetMaze, existingUnit, newUnit);
UnityEngine.Object.DestroyImmediate(newUnitFromPrefab);
}
}
public static void CheckAndUpdateMazeDefinitionOn(beMobileMaze maze, Vector3 dimension)
{
var newBoundarySize_X = maze.Grid.GetLength(0) + ((dimension.x * maze.Grid.GetLength(0)) - maze.Grid.GetLength(0));
if (newBoundarySize_X > maze.MazeWidthInMeter)
{
maze.MazeWidthInMeter = (float)Math.Ceiling(newBoundarySize_X);
}
var newBoundarySize_Y = maze.Grid.GetLength(1) + (dimension.z * maze.Grid.GetLength(1) - maze.Grid.GetLength(1)); // z is the lenght! y is up!
if (newBoundarySize_Y > maze.MazeLengthInMeter)
{
maze.MazeLengthInMeter = (float)Math.Ceiling(newBoundarySize_Y);
}
}
public override void GizmoDrawings(beMobileMaze maze, GizmoType type)
{
base.GizmoDrawings(maze, type);
var temp = Gizmos.color;
Gizmos.color = GetPrimaryColor() * new Color(1, 1, 1, 0.4f);
foreach (var item in CurrentSelection)
{
var pos = item.transform.localPosition + new Vector3(0, maze.RoomDimension.y / 2, 0);
Gizmos.DrawCube(pos, new Vector3(maze.RoomDimension.x, maze.RoomDimension.y, maze.RoomDimension.z));
}
Gizmos.color = temp;
}
internal static Vector2 Shrink(beMobileMaze selectedMaze)
{
var gridIds = selectedMaze.Units.Select(u => u.GridID);
var xMax = gridIds.Max((v) => v.x);
var yMax = gridIds.Max((v) => v.y);
var newMazeSize = new Vector2(
xMax * selectedMaze.RoomDimension.x,
yMax * selectedMaze.RoomDimension.z);
selectedMaze.MazeLengthInMeter = newMazeSize.y;
selectedMaze.MazeWidthInMeter = newMazeSize.x;
return(newMazeSize);
}
public void Render(beMobileMaze maze, Vector3 drawingOffset)
{
var schemaWallWidth = 0.1f;
var schemaWallLength = maze.RoomDimension.x;
var temp = Gizmos.color;
var schematicUnitSize = new Vector3(maze.RoomDimension.x, 0, maze.RoomDimension.z);
foreach (var unit in maze.Units)
{
Gizmos.color = Color.white;
Gizmos.DrawCube(unit.transform.localPosition, schematicUnitSize);
Gizmos.color = Color.black;
foreach (var child in unit.transform.AllChildren())
{
if (!child.activeSelf)
{
continue;
}
if (child.name == "Top")
{
continue;
}
var position = child.transform.localPosition;
if (child.name == "West" || child.name == "East")
{
var wallDimensions = new Vector3(schemaWallWidth, 0, schemaWallLength);
Gizmos.DrawCube(position + drawingOffset, wallDimensions);
}
if (child.name == "North" || child.name == "South")
{
var wallDimensions = new Vector3(schemaWallLength, 0, schemaWallWidth);
Gizmos.DrawCube(position + drawingOffset, wallDimensions);
}
}
}
Gizmos.color = temp;
}
public static bool DoesNotContainPaths(this beMobileMaze maze)
{
var controller = maze.GetComponent <PathController>();
if (controller == null)
{
return(false);
}
if (!controller.Paths.Any() || controller.Paths.Any((p) => p == null))
{
controller.ForcePathLookup();
}
var hasPaths = controller.Paths.Any(p => p.PathAsLinkedList.Any());
return(!hasPaths);
}
public static void LookUpAllUnits(beMobileMaze maze)
{
var unitsExceptMissingReference = maze.Units.Where(u => u != null);
maze.Units.Clear();
foreach (var item in unitsExceptMissingReference)
{
maze.Units.Add(item);
}
for (int i = 0; i < maze.transform.childCount; i++)
{
var existing = maze.transform.GetChild(i).GetComponent <MazeUnit>();
if (existing != null && !maze.Units.Contains(existing))
{
maze.Units.Add(existing);
}
}
}
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);
}
static void DrawGizmosFor(beMobileMaze maze, GizmoType type)
{
var editorBackend = Instance;
if (editorBackend == null)
{
return;
}
editorBackend.visual.pushHandleMatrix(maze.transform.localToWorldMatrix);
editorBackend.visual.pushGizmoMatrix(maze.transform.localToWorldMatrix);
editorBackend.visual.RenderTileHighlighting(maze.transform, maze.RoomDimension * 1.1f);
var cam = Camera.current;
if (GridEditingVisualUtils.CameraIsATopDownView(cam, maze.transform) && cam.orthographic)
{
schemaRenderer = new SchematicMazeRenderer();
var offset = new Vector3(0, maze.RoomDimension.y + 1, 0);
schemaRenderer.Render(maze, offset);
schemaRenderer.RenderPaths(maze, offset);
}
if (editorBackend.CurrentSelectedMode != null)
{
editorBackend.CurrentSelectedMode.GizmoDrawings(maze, type);
}
editorBackend.visual.popGizmoMatrix();
editorBackend.visual.popHandleMatrix();
}
/// <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);
}
/// <summary>
/// Erases a block at the pre-calculated mouse hit position
/// </summary>
private void RemoveAUnit(beMobileMaze maze, Vector2 pos, MazeCreationWorkflowBackEnd backend)
{
Debug.Log("Remove call...");
var allÚnits = maze.GetComponentsInChildren <MazeUnit>();
var selected = allÚnits.Where(u => u.GridID == pos);
var unitHost = selected.First();
if (!unitHost)
{
Debug.Log("Nothing to erase!");
return;
}
// if a game object was found with the same assetName and it is a child we just destroy it immediately
if (unitHost != null && unitHost.transform.parent == maze.transform)
{
maze.Units.Remove(unitHost);
maze.Grid[(int)pos.x, (int)pos.y] = null;
Editor.DestroyImmediate(unitHost.gameObject);
}
}
public void Initialize(beMobileMaze maze)
{
selectedMaze = maze;
}
public static MazeUnit[,] ReconfigureGrid(beMobileMaze maze, float columns, float rows)
{
return(ReconfigureGrid(maze, Mathf.FloorToInt(columns), Mathf.FloorToInt(rows)));
}
public string CreateTargetFileName(beMobileMaze mazeToExport)
{
return(string.Format(FILE_NAME_PATTERN, mazeToExport.name, FILE_EXTENSION));
}
private StringBuilder AppendPathWithMatrix(beMobileMaze maze, PathInMaze path)
{
StringBuilder pathAsTextMatrix = new StringBuilder();
var pathID = string.Format("Path: {0} matlab path matrix:\t", path.ID);
var pathElements = path.PathAsLinkedList.ToList();
pathAsTextMatrix.Append(pathID);
pathAsTextMatrix.Append(" [ ");
var grid = new MazeGridTraversal(maze);
grid.travers(
s => {
string content = "0";
pathAsTextMatrix.Append(content);
if (s.ColumnsLeft > 0)
{
pathAsTextMatrix.Append(", ");
}
if (s.ColumnsLeft == 0)
{
pathAsTextMatrix.Append("; ");
}
},
(u, s) => {
var currentUnitIsPathElement = pathElements.Any(
e => e.Unit.GridID == new Vector2(s.Column, s.Row));
if (currentUnitIsPathElement)
{
pathAsTextMatrix.Append("2");
}
else
{
pathAsTextMatrix.Append("1");
}
if (s.ColumnsLeft > 0)
{
pathAsTextMatrix.Append(", ");
}
if (s.ColumnsLeft == 0)
{
pathAsTextMatrix.Append("; ");
}
}
);
#region
//for (int y_i = 0; y_i < maze.Rows; y_i++)
//{
// StringBuilder rowAsLine = new StringBuilder();
// for (int x_i = 0; x_i < maze.Columns; x_i++)
// {
// var currentUnitIsPathElement = pathElements.Any(e => e.Unit.GridID == new UnityEngine.Vector2(x_i, y_i));
// if (maze[x_i, y_i] == null)
// {
// rowAsLine.Append("0");
// }
// else if (currentUnitIsPathElement)
// {
// rowAsLine.Append("2");
// }
// else
// {
// rowAsLine.Append("1");
// }
// if (x_i != maze.Columns - 1)
// rowAsLine.Append(", ");
// }
// if (y_i != maze.Rows - 1)
// {
// rowAsLine.Append("; ");
// }
// pathAsTextMatrix.Append(rowAsLine.ToString());
//}
#endregion original
pathAsTextMatrix.Append(" ] ");
return(pathAsTextMatrix);
}
private StringBuilder AppendMazeMatrix(beMobileMaze maze)
{
var traversal = new MazeGridTraversal(maze);
StringBuilder mazeAsTextMatrix = new StringBuilder();
var mazeID = string.Format("Maze: {0} matlab matrix:\t", maze.name);
mazeAsTextMatrix.Append(mazeID);
mazeAsTextMatrix.Append(" [ ");
traversal.travers(
s => {
string content = "0";
mazeAsTextMatrix.Append(content);
if (s.ColumnsLeft > 0)
{
mazeAsTextMatrix.Append(", ");
}
if (s.ColumnsLeft == 0)
{
mazeAsTextMatrix.Append("; ");
}
},
(u, s) => {
OpenDirections openDirectionsCode = u.WaysOpen;
OpenDirections directions = ValidateOpenDirections(u);
if (openDirectionsCode != directions)
{
Debug.Log(u.GridID + "Has wrong directions code - Correct during export!");
}
string content = ((int)openDirectionsCode).ToString();
mazeAsTextMatrix.Append(content);
if (s.ColumnsLeft > 0)
{
mazeAsTextMatrix.Append(", ");
}
if (s.ColumnsLeft == 0)
{
mazeAsTextMatrix.Append("; ");
}
});
#region original
//for (int y_i = maze.Rows - 1; y_i >= 0; y_i--)
//{
// StringBuilder rowAsLine = new StringBuilder();
// for (int x_i = 0; x_i < maze.Columns; x_i++)
// {
// if (maze[x_i, y_i] == null)
// {
// rowAsLine.Append("0");
// }
// else
// {
// rowAsLine.Append("1");
// }
// if (x_i < maze.Columns - 1)
// rowAsLine.Append(", ");
// }
// if (y_i != 0)
// {
// rowAsLine.Append("; ");
// }
// mazeAsTextMatrix.Append(rowAsLine.ToString());
//}
#endregion
mazeAsTextMatrix.Append(" ]");
return(mazeAsTextMatrix);
}
public beMobileMaze Bake(beMobileMaze originalMaze)
{
beMobileMaze mazeToUse = null;
if (!replaceOriginalMaze)
{
mazeToUse = GameObject.Instantiate(originalMaze);
originalMaze.gameObject.SetActive(false);
}
Debug.Assert(mazeToUse.GetComponent <MeshFilter>() == null, "Component has already a MeshFilter");
var meshFilter = mazeToUse.gameObject.AddComponent <MeshFilter>();
Debug.Assert(mazeToUse.GetComponent <MeshRenderer>() == null, "Component has already a MeshRenderer");
meshFilter.mesh = new Mesh();
meshFilter.sharedMesh.name = mazeToUse.name;
var meshRenderer = mazeToUse.gameObject.AddComponent <MeshRenderer>();
var plane = GameObject.CreatePrimitive(PrimitiveType.Plane);
meshRenderer.material = plane.GetComponent <MeshRenderer>().sharedMaterial;
GameObject.DestroyImmediate(plane);
var combineInstances = new List <CombineInstance>();
var allMeshFilter = new List <MeshFilter>();
var allRenderer = new List <MeshRenderer>();
traverseAndCollectAll(new Stack <MazeUnit>(mazeToUse.Units), allMeshFilter, allRenderer);
List <MeshFilter> selectedMeshFilter = allMeshFilter;
selectedMeshFilter.RemoveAll(filter => !filter.gameObject.activeInHierarchy);
if (ignoreFloor)
{
selectedMeshFilter.RemoveAll(filter => filter.name.Equals("Floor") || filter.transform.parent.name.Equals("Floor"));
}
foreach (var filter in selectedMeshFilter)
{
var combined = new CombineInstance();
combined.mesh = filter.sharedMesh;
combined.transform = filter.transform.localToWorldMatrix;
combineInstances.Add(combined);
Component.DestroyImmediate(filter);
}
foreach (var renderer in allRenderer)
{
Component.DestroyImmediate(renderer);
}
meshFilter.sharedMesh.CombineMeshes(combineInstances.ToArray(), MERGE_SUBMESHES, USE_MATRICES);
;
meshFilter.sharedMesh.RecalculateNormals();
AssetDatabase.CreateAsset(meshFilter.sharedMesh, EditorEnvironmentConstants.Get_PACKAGE_MODEL_SUBFOLDER() + "/" + mazeToUse.name + "_combinedMesh.asset");
return(mazeToUse);
}
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);
}
}
public MazeGridTraversal(beMobileMaze maze)
{
this.maze = maze;
}
