// Starts a push chain
public override bool InitiatePush(TileElement[,,] board, Facet direction, Monocoord newOccupant)
{
LinkedList <TileElement> evaluatedTiles = new LinkedList <TileElement>();
if (Push(board, direction, evaluatedTiles))
{
// Sets the newOccupant to its position if push is successful
if (newOccupant != null)
{
board[newOccupant.GetPos().x, newOccupant.GetPos().y, newOccupant.GetPos().z] = newOccupant;
}
// All pushed elements are dropped and their physics helper properties are reset
foreach (TileElement te in evaluatedTiles)
{
te.Fall(board);
te.Checked = false;
te.Moving = false;
}
evaluatedTiles.Clear();
// Executes movement animation
LevelManager.current.StartCoroutine(LevelManager.current.AnimateTileStateChange());
return(true);
}
return(false);
}
public override void Revert(TileElement[,,] board)
{
tileElement.model = GameObject.Instantiate(Resources.Load("Models/" + tileElement.TileName())) as GameObject;
tileElement.BindDataToModel();
tileElement.WarpToPos();
tileElement.AdjustRender();
if (tileElement is Monocoord)
{
Monocoord monoTile = (Monocoord)tileElement;
board[monoTile.GetPos().x, monoTile.GetPos().y, monoTile.GetPos().z] = tileElement;
if (tileElement is Vine)
{
LevelManager.current.AdjustAvailableVinesUI(((Vine)tileElement).GetColor(), -1);
}
}
else
{
Dicoord diTile = (Dicoord)tileElement;
for (int x = diTile.GetPos1().x; x <= diTile.GetPos2().x; x++)
{
for (int y = diTile.GetPos1().y; y <= diTile.GetPos2().y; y++)
{
for (int z = diTile.GetPos1().z; z <= diTile.GetPos2().z; z++)
{
board[x, y, z] = tileElement;
}
}
}
}
}
// PHYSICS public abstract bool InitiatePush(TileElement[,,] board, Facet direction, Monocoord newOccupant);
public override void Revert(TileElement[,,] board)
{
if (tileElement is Monocoord)
{
Monocoord monocoord = (Monocoord)tileElement;
if (board[monocoord.GetPos().x, monocoord.GetPos().y, monocoord.GetPos().z] is IMonoSpacious)
{
((IMonoSpacious)board[monocoord.GetPos().x, monocoord.GetPos().y, monocoord.GetPos().z]).Expecting = true;
}
else
{
board[monocoord.GetPos().x, monocoord.GetPos().y, monocoord.GetPos().z] = null;
}
monocoord.SetCoords(new int[]
{
oldPos.x,
oldPos.y,
oldPos.z
});
if (board[monocoord.GetPos().x, monocoord.GetPos().y, monocoord.GetPos().z] != null && board[monocoord.GetPos().x, monocoord.GetPos().y, monocoord.GetPos().z] is IMonoSpacious)
{
((IMonoSpacious)board[monocoord.GetPos().x, monocoord.GetPos().y, monocoord.GetPos().z]).Helper.Inhabitant = monocoord;
((IMonoSpacious)board[monocoord.GetPos().x, monocoord.GetPos().y, monocoord.GetPos().z]).TileEnters(monocoord);
}
else
{
board[monocoord.GetPos().x, monocoord.GetPos().y, monocoord.GetPos().z] = monocoord;
}
}
else
{
Dicoord dicoord = ((Dicoord)tileElement);
for (int x = dicoord.GetPos1().x; x <= dicoord.GetPos2().x; x++)
{
for (int y = dicoord.GetPos1().y; y <= dicoord.GetPos2().y; y++)
{
for (int z = dicoord.GetPos1().z; z <= dicoord.GetPos2().z; z++)
{
if (board[x, y, z] is IMonoSpacious)
{
((IMonoSpacious)board[x, y, z]).Expecting = true;
}
else
{
board[x, y, z] = null;
}
}
}
}
dicoord.SetCoords(new int[]
{
oldPos.x,
oldPos.y,
oldPos.z
},
new int[] {
oldPos.x + (dicoord.GetPos2().x - dicoord.GetPos1().x),
oldPos.y + (dicoord.GetPos2().y - dicoord.GetPos1().y),
oldPos.z + (dicoord.GetPos2().z - dicoord.GetPos1().z)
});
for (int x = dicoord.GetPos1().x; x <= dicoord.GetPos2().x; x++)
{
for (int y = dicoord.GetPos1().y; y <= dicoord.GetPos2().y; y++)
{
for (int z = dicoord.GetPos1().z; z <= dicoord.GetPos2().z; z++)
{
if (board[x, y, z] != null && board[x, y, z] is IMonoSpacious)
{
((IMonoSpacious)board[x, y, z]).Helper.Inhabitant = dicoord;
((IMonoSpacious)board[x, y, z]).TileEnters(dicoord);
}
else
{
board[x, y, z] = dicoord;
}
}
}
}
}
tileElement.WarpToPos();
}
public void LoadLevel(string levelPath, bool playing)
{
// Load LevelData and initialize the lists
levelData = (LevelData)SerializationManager.LoadData(levelPath);
TileElement tileModel = Constants.TILE_MODELS[(int)TileElementNames.Ground];
availableVines = levelData.availableVines;
// Create the Grounds
board = new TileElement[levelData.grounds.GetLength(0), levelData.grounds.GetLength(1), levelData.grounds.GetLength(2)];
for (int x = 0; x < board.GetLength(0); x++)
{
for (int y = 0; y < board.GetLength(1); y++)
{
for (int z = 0; z < board.GetLength(2); z++)
{
if (levelData.grounds[x, y, z] != null)
{
board[x, y, z] = tileModel.LoadTileElement(new object[] {
new Vector3Int(x, y, z),
levelData.grounds[x, y, z]
});
board[x, y, z].model = Instantiate(Resources.Load("Models/Ground")) as GameObject;
board[x, y, z].BindDataToModel();
board[x, y, z].WarpToPos();
((Ground)board[x, y, z]).ColorFacets(litBases);
}
}
}
}
// Create Bramble and save his position
bramble = (Bramble)Constants.TILE_MODELS[(int)TileElementNames.Bramble].LoadTileElement(new object[]
{
new Vector3Int(levelData.brambleCoords[0], levelData.brambleCoords[1], levelData.brambleCoords[2]),
levelData.brambleDirection
});
bramble.model = Instantiate(Resources.Load("Models/Bramble")) as GameObject;
bramble.BindDataToModel();
bramble.WarpToPos();
board[bramble.GetPos().x, bramble.GetPos().y, bramble.GetPos().z] = bramble;
// Create the Sigil
board[levelData.sigilCoords[0], levelData.sigilCoords[1], levelData.sigilCoords[2]] = (Sigil)Constants.TILE_MODELS[(int)TileElementNames.Sigil].LoadTileElement(new object[]
{
new Vector3Int(levelData.sigilCoords[0], levelData.sigilCoords[1], levelData.sigilCoords[2]),
});
board[levelData.sigilCoords[0], levelData.sigilCoords[1], levelData.sigilCoords[2]].model = Instantiate(Resources.Load("Models/Sigil")) as GameObject;
board[levelData.sigilCoords[0], levelData.sigilCoords[1], levelData.sigilCoords[2]].BindDataToModel();
board[levelData.sigilCoords[0], levelData.sigilCoords[1], levelData.sigilCoords[2]].WarpToPos();
// Convert the data arrays to Queues
Queue <int> intQueue = new Queue <int>();
for (int i = 0; i < levelData.dataInts.Length; i++)
{
intQueue.Enqueue(levelData.dataInts[i]);
}
Queue <Shade> shadeQueue = new Queue <Shade>();
for (int i = 0; i < levelData.dataShades.Length; i++)
{
shadeQueue.Enqueue(levelData.dataShades[i]);
}
// Decompile all of the non-essential elements
for (int i = 0; i < levelData.tileTypes.Length; i++)
{
TileElement tileBase = Constants.TILE_MODELS[(int)levelData.tileTypes[i]];
TileElement decompiledTile = tileBase.DecompileTileElement(ref intQueue, ref shadeQueue);
decompiledTile.model = Instantiate(Resources.Load("Models/" + tileBase.TileName())) as GameObject;
decompiledTile.BindDataToModel();
decompiledTile.WarpToPos();
decompiledTile.AdjustRender();
if (tileBase is Monocoord)
{
Monocoord monoTile = (Monocoord)decompiledTile;
board[monoTile.GetPos().x, monoTile.GetPos().y, monoTile.GetPos().z] = decompiledTile;
}
else
{
Dicoord diTile = (Dicoord)decompiledTile;
for (int x = diTile.GetPos1().x; x <= diTile.GetPos2().x; x++)
{
for (int y = diTile.GetPos1().y; y <= diTile.GetPos2().y; y++)
{
for (int z = diTile.GetPos1().z; z <= diTile.GetPos2().z; z++)
{
board[x, y, z] = decompiledTile;
}
}
}
}
}
CameraManager.current.CalibrateCamera(board);
}
