private SerialisableTileBaseGround TryAddBaseBackgroundForNewOverworld(List <SerialisableTileBackground> tileBackgrounds, List <SerialisableTileAttribute> tileAttributes)
{
for (int i = 0; i < tileBackgrounds.Count; i++)
{
Type type = Type.GetType(tileBackgrounds[i].BackgroundType);
if (type.Equals(typeof(SerialisableTilePathBackground)))
{
SerialisableTilePathBackground serialisableTilePathBackground = (SerialisableTilePathBackground)JsonUtility.FromJson(tileBackgrounds[i].SerialisedData, type);
if (serialisableTilePathBackground.TileConnectionScore == 16)
{
return(null);
}
}
}
SerialisableTileObstacleAttribute obstacleAttribute = tileAttributes.OfType <SerialisableTileObstacleAttribute>().FirstOrDefault();
if (obstacleAttribute == null)
{
return(new SerialisableTileBaseGround(16));
}
if (obstacleAttribute.ConnectionScore == 16)
{
return(null);
}
return(new SerialisableTileBaseGround(16));
}
private void AddTileAttributes(SerialisableTile serialisableTile, InGameMazeTile tile)
{
InGameMazeTileAttributePlacer tileAttributePlacer = new InGameMazeTileAttributePlacer(tile);
foreach (SerialisableTileAttribute serialisableTileAttribute in serialisableTile.TileAttributes)
{
Type type = Type.GetType(serialisableTileAttribute.AttributeType);
if (type.Equals(typeof(SerialisableTileObstacleAttribute)))
{
SerialisableTileObstacleAttribute serialisableTileObstacleAttribute = (SerialisableTileObstacleAttribute)JsonUtility.FromJson(serialisableTileAttribute.SerialisedData, type);
tileAttributePlacer.PlaceTileObstacle(ObstacleType.Bush, new TileConnectionScoreInfo(serialisableTileObstacleAttribute.ConnectionScore, serialisableTileObstacleAttribute.SpriteNumber));
}
else if (type.Equals(typeof(SerialisablePlayerExitAttribute)))
{
SerialisablePlayerExitAttribute serialisablePlayerExitAttribute = (SerialisablePlayerExitAttribute)JsonUtility.FromJson(serialisableTileAttribute.SerialisedData, type);
tileAttributePlacer.PlacePlayerExit(ObstacleType.Bush, new TileConnectionScoreInfo(serialisablePlayerExitAttribute.ConnectionScore, serialisablePlayerExitAttribute.SpriteNumber));
}
else if (type.Equals(typeof(SerialisablePlayerSpawnpointAttribute)))
{
tileAttributePlacer.PlacePlayerSpawnpoint();
}
else if (type.Equals(typeof(SerialisablePlayerOnlyAttribute)))
{
tileAttributePlacer.PlacePlayerOnlyAttribute(PlayerOnlyType.Bush);
}
else if (type.Equals(typeof(SerialisableEnemySpawnpointAttribute)))
{
SerialisableEnemySpawnpointAttribute serialisableEnemySpawnpointAttribute = (SerialisableEnemySpawnpointAttribute)JsonUtility.FromJson(serialisableTileAttribute.SerialisedData, type);
tileAttributePlacer.PlaceEnemySpawnpoint(serialisableEnemySpawnpointAttribute.TileAreaIds, TileAreas);
}
else if (type.Equals(typeof(SerialisableBridgePieceAttribute)))
{
SerialisableBridgePieceAttribute serialisableBridgePieceAttribute = (SerialisableBridgePieceAttribute)JsonUtility.FromJson(serialisableTileAttribute.SerialisedData, type);
if (Enum.TryParse(serialisableBridgePieceAttribute.BridgePieceDirection, out BridgePieceDirection bridgePieceDirection))
{
tileAttributePlacer.PlaceBridgePiece(BridgeType.Wooden, bridgePieceDirection);
}
else
{
Logger.Error($"Could not parse the BridgePieceDirection value{serialisableBridgePieceAttribute.BridgePieceDirection}");
}
}
else if (type.Equals(typeof(SerialisableBridgeEdgeAttribute)))
{
SerialisableBridgeEdgeAttribute serialisableBridgeEdgeAttribute = (SerialisableBridgeEdgeAttribute)JsonUtility.FromJson(serialisableTileAttribute.SerialisedData, type);
if (Enum.TryParse(serialisableBridgeEdgeAttribute.BridgeEdgeSide, out Direction bridgeEdgeSide))
{
tileAttributePlacer.PlaceBridgeEdge(BridgeType.Wooden, bridgeEdgeSide);
}
else
{
Logger.Error($"Could not parse the BridgeEdgeSide value{serialisableBridgeEdgeAttribute.BridgeEdgeSide}");
}
}
else if (type.Equals(typeof(SerialisableMusicInstrumentCaseAttribute)))
{
tileAttributePlacer.PlaceMusicInstrumentCase();
}
else
{
Logger.Error($"Unknown tile attribute of type {type}");
}
}
}
private ISerialisableTileAttribute CreateSerialisableTileAttribute(Tile tile, ITileAttribute tileAttribute)
{
if (tileAttribute.GetType() == typeof(TileObstacle))
{
TileObstacle tileObstacle = tileAttribute as TileObstacle;
SerialisableTileObstacleAttribute serialisableTileObstacleAttribute =
new SerialisableTileObstacleAttribute(
new TileConnectionScoreInfo(tileObstacle.ConnectionScore, tileObstacle.SpriteNumber));
return(serialisableTileObstacleAttribute);
}
else if (tileAttribute.GetType() == typeof(PlayerExit))
{
PlayerExit playerExit = tileAttribute as PlayerExit;
SerialisablePlayerExitAttribute serialisablePlayerExitAttribute = new SerialisablePlayerExitAttribute(
new TileConnectionScoreInfo(playerExit.ConnectionScore, playerExit.SpriteNumber));
return(serialisablePlayerExitAttribute);
}
else if (tileAttribute.GetType() == typeof(PlayerOnly))
{
SerialisablePlayerOnlyAttribute serialisablePlayerOnlyAttribute = new SerialisablePlayerOnlyAttribute();
return(serialisablePlayerOnlyAttribute);
}
else if (tileAttribute.GetType() == typeof(PlayerSpawnpoint))
{
SerialisablePlayerSpawnpointAttribute serialisablePlayerSpawnpointAttribute = new SerialisablePlayerSpawnpointAttribute();
return(serialisablePlayerSpawnpointAttribute);
}
else if (tileAttribute.GetType() == typeof(EnemySpawnpoint))
{
EnemySpawnpoint enemySpawnpoint = tileAttribute as EnemySpawnpoint;
SerialisableEnemySpawnpointAttribute serialisableEnemySpawnpointAttribute = new SerialisableEnemySpawnpointAttribute(enemySpawnpoint.TileAreas);
return(serialisableEnemySpawnpointAttribute);
}
else if (tileAttribute.GetType() == typeof(MazeLevelEntry))
{
MazeLevelEntry mazeLevelEntry = tileAttribute as MazeLevelEntry;
SerialisableMazeLevelEntryAttribute serialisableMazeLevelEntryAttribute = new SerialisableMazeLevelEntryAttribute(mazeLevelEntry.MazeLevelName);
return(serialisableMazeLevelEntryAttribute);
}
else if (tileAttribute.GetType() == typeof(BridgePiece))
{
BridgePiece bridgePiece = tileAttribute as BridgePiece;
BridgePieceDirection bridgePieceDirection = bridgePiece.BridgePieceDirection;
SerialisableBridgePieceAttribute serialisableBridgePieceAttribute = new SerialisableBridgePieceAttribute(bridgePieceDirection);
return(serialisableBridgePieceAttribute);
}
else if (tileAttribute.GetType() == typeof(BridgeEdge))
{
BridgeEdge bridgeEdge = tileAttribute as BridgeEdge;
SerialisableBridgeEdgeAttribute serialisableBridgeEdgeAttribute = new SerialisableBridgeEdgeAttribute(bridgeEdge.EdgeSide);
return(serialisableBridgeEdgeAttribute);
}
else if (tileAttribute.GetType() == typeof(MusicInstrumentCase))
{
SerialisableMusicInstrumentCaseAttribute serialisableMusicInstrumentCaseAttribute = new SerialisableMusicInstrumentCaseAttribute();
return(serialisableMusicInstrumentCaseAttribute);
}
else
{
Logger.Error($"Could not serialise the tile attribute {tileAttribute.GetType()}");
return(null);
}
}
public void GenerateTiles()
{
if (_gridWidth < 3)
{
Logger.Warning(Logger.Level, "Cannot generate a tile grid with a width of {0}. The minimum generatable grid width is 3", _gridWidth);
return;
}
if (_gridWidth > 25)
{
Logger.Warning(Logger.Level, "Cannot generate a tile grid with a width of {0}. The maximum generatable grid width is 20", _gridWidth);
return;
}
if (_gridHeight < 3)
{
Logger.Warning(Logger.Level, "Cannot generate a tile grid with a height of {0}. The minimum generatable grid height is 3", _gridHeight);
return;
}
if (_gridHeight > 25)
{
Logger.Warning(Logger.Level, "Cannot generate a tile grid with a height of {0}. The maximum generatable grid height is 20", _gridHeight);
return;
}
Logger.Log("Generate tile grid with a width of {0} and a height of {1}", _gridWidth, _gridHeight);
// remove everything from the currently loaded level
MazeLevelGameplayManager.Instance.UnloadLevel();
// Create a new level from scratch with a obstacle ring at the edges
List <SerialisableTile> tiles = new List <SerialisableTile>();
for (int i = 0; i < _gridWidth; i++)
{
for (int j = 0; j < _gridHeight; j++)
{
string tileId = Guid.NewGuid().ToString();
GridLocation gridLocation = new GridLocation(i, j);
List <SerialisableTileAttribute> tileAttributes = new List <SerialisableTileAttribute>();
List <SerialisableTileBackground> tileBackgrounds = new List <SerialisableTileBackground>();
List <SerialisableTileCornerFiller> tileCornerFillers = new List <SerialisableTileCornerFiller>();
SerialisableTileMainMaterial mainMaterial = new SerialisableTileMainMaterial("GroundMainMaterial", new SerialisableLandMaterial());
SerialisableTileObstacleAttribute edgeObstacle = TryAddEdgeObstacle(gridLocation);
if (edgeObstacle != null)
{
tileAttributes.Add(new SerialisableTileAttribute(edgeObstacle.GetType().ToString(), edgeObstacle));
}
SerialisableTilePathBackground mazeTilePath = TryAddPathsForNewMaze(gridLocation, tileAttributes);
if (mazeTilePath != null)
{
tileBackgrounds.Add(new SerialisableTileBackground(mazeTilePath.GetType().ToString(), mazeTilePath));
}
SerialisableTileBaseGround baseBackground = TryAddBaseBackgroundForNewMaze(tileBackgrounds, tileAttributes);
if (baseBackground != null)
{
tileBackgrounds.Add(new SerialisableTileBackground(baseBackground.GetType().ToString(), baseBackground));
}
SerialisableTile tile = new SerialisableTile(tileId, mainMaterial, tileAttributes, tileBackgrounds, tileCornerFillers, gridLocation.X, gridLocation.Y);
tiles.Add(tile);
}
}
MazeLevelData newMazeLevelData = new MazeLevelData();
newMazeLevelData.Tiles = tiles;
MazeLevelLoader.LoadMazeLevelForEditor(newMazeLevelData);
}
