public void LoadMaze()
{
Logger.Log("Load maze (in editor)");
if (string.IsNullOrWhiteSpace(_mazeName))
{
Logger.Warning(Logger.Datawriting, "In order to save the maze level, please fill in a maze name");
return;
}
bool mazeLevelNameExists = MazeLevelLoader.MazeLevelExists(_mazeName);
if (mazeLevelNameExists)
{
MazeLevelGameplayManager.Instance.UnloadLevel();
MazeLevelData mazeLevelData = MazeLevelLoader.LoadMazeLevelData(_mazeName);
MazeLevelLoader.LoadMazeLevelForEditor(mazeLevelData);
}
EditorSelectedMazeTileModifierContainer selectedTileModifierContainer = EditorCanvasUI.Instance.SelectedTileModifierContainer as EditorSelectedMazeTileModifierContainer;
selectedTileModifierContainer?.SetInitialModifierValues();
EditorMazeTileModificationPanel.Instance?.Reset();
EditorMazeTileModificationPanel.Instance?.DestroyModifierActions();
}
private void SaveMazeLevelData()
{
MazeLevelData mazeLevelData = new MazeLevelData(MazeLevelGameplayManager.Instance.EditorLevel).WithName(_mazeName);
JsonMazeLevelFileWriter fileWriter = new JsonMazeLevelFileWriter();
fileWriter.SerialiseData(mazeLevelData);
}
protected override void InitialiseEditorTileAreas(MazeLevelData mazeLevelData)
{
for (int i = 0; i < mazeLevelData.TileAreas.Count; i++)
{
SerialisableTileArea serialisableTileArea = mazeLevelData.TileAreas[i];
TileArea newTileArea = new TileArea(serialisableTileArea);
TileAreas.Add(newTileArea.Id, newTileArea);
}
}
public void SetupLevel(MazeLevelData mazeLevelData)
{
Level = InGameMazeLevel.Create(mazeLevelData);
InitialiseTileAttributes();
Logger.Log("Start scan...");
IEnumerator coroutine = ScanCoroutine();
StartCoroutine(coroutine);
}
public void SerialiseData <T>(T levelData)
{
Directory.CreateDirectory(Path.Combine(Application.dataPath, "StreamingAssets", "maze"));
_levelData = levelData as MazeLevelData;
_path = Path.Combine(Application.dataPath, "StreamingAssets", "maze", _levelData.Name + ".json");
string jsonDataString = JsonUtility.ToJson(_levelData, true).ToString();
File.WriteAllText(_path, jsonDataString);
}
public void SetupLevelForEditor(MazeLevelData mazeLevelData)
{
EditorLevel = EditorMazeLevel.Create(mazeLevelData);
InitialiseEditorTileBackgrounds();
InitialiseEditorTileAttributes();
MainScreenOverlayCanvas.Instance.ResetBlackOutSquares();
CameraManager.Instance.ResetCameras();
CameraManager.Instance.SetPanLimits(EditorLevel.LevelBounds);
}
private MazeLevelData GetMazeLevelData(string sanatisedLevelName)
{
bool levelExists = MazeLevelLoader.MazeLevelExists(sanatisedLevelName);
if (!levelExists)
{
string message = $"Could not find a maze level with the name '<color={sanatisedLevelName}>info maze</color>'.\n";
throw new MazeLevelNameNotFoundConsoleException(message);
}
MazeLevelData mazeLevelData = MazeLevelLoader.LoadMazeLevelData(sanatisedLevelName);
return(mazeLevelData);
}
private IEnumerator LoadLevelCoroutine(string levelName, MazeLevelData levelData)
{
MainScreenOverlayCanvas.Instance.BlackOutSquaresToBlack();
while (MainScreenOverlayCanvas.Instance.BlackOutSquares[0].BlackStatus != BlackStatus.Black)
{
yield return(null);
}
UnloadLevel();
MazeScoreScreenContainer.Instance.CloseScoreScreenPanel();
SetupLevel(levelData);
MainScreenOverlayCanvas.Instance.BlackOutSquaresToClear();
}
public static void LoadMazeLevel(MazeLevelData mazeLevelData)
{
//If we are in the editor, first close the editor mode before loading a maze through the consule
if (EditorManager.InEditor)
{
EditorManager.CloseEditor();
}
if (PersistentGameManager.CurrentSceneType == SceneType.Overworld)
{
Logger.Warning("We are currently in the overworld scene. Do not load maze but return.");
return;
}
// Make checks such as if there are starting locations for the players
MazeLevelGameplayManager.Instance.UnloadLevel();
MazeLevelGameplayManager.Instance.SetupLevel(mazeLevelData); // sets new Level in MazeLevelManager
}
private GridLocation GetMazeLevelBounds(MazeLevelData mazeLevelData)
{
GridLocation furthestBounds = new GridLocation(0, 0);
for (int i = 0; i < mazeLevelData.Tiles.Count; i++)
{
SerialisableTile tile = mazeLevelData.Tiles[i];
if (tile.GridLocation.X > furthestBounds.X)
{
furthestBounds.X = tile.GridLocation.X;
}
if (tile.GridLocation.Y > furthestBounds.Y)
{
furthestBounds.Y = tile.GridLocation.Y;
}
}
return(furthestBounds);
}
public InGameMazeLevel(MazeLevelData mazeLevelData)
{
Name = mazeLevelData.Name;
GameManager.Instance.CurrentGameLevel = this;
if (TilesContainer.Instance != null)
{
GameObject.Destroy(TilesContainer.Instance.gameObject);
TilesContainer.Instance = null;
}
_mazeContainer = new GameObject(Name);
_mazeContainer.transform.SetParent(GameManager.Instance.GridGO.transform);
_mazeContainer.transform.position = new Vector3(0, 0, 0);
_mazeContainer.AddComponent <TilesContainer>();
_mazeContainer.SetActive(true);
InitialiseEditorTileAreas(mazeLevelData);
BuildTiles(mazeLevelData);
}
public string GetInfo(List <string> arguments)
{
try
{
if (arguments.Count < 1)
{
string message = "The command '<color=" + ConsoleConfiguration.HighlightColour + ">info maze</color>' needs an additional argument with the name of the maze level you want info on.";
Logger.Warning(message);
throw new NotEnoughArgumentsConsoleException(message);
}
string sanatisedLevelName = arguments[0].ToLower().Replace(" ", "-");
MazeLevelData mazeLevelData = GetMazeLevelData(sanatisedLevelName);
MazeLevelNameData mazeLevelName = GetMazeLevelNameData(sanatisedLevelName);
bool isPlayable = GetIsPlayable(mazeLevelName);
GridLocation mazeLevelBounds = GetMazeLevelBounds(mazeLevelData);
string infoMessage = "--\n";
infoMessage += $"Information for maze level {arguments[0]}\n";
infoMessage += "--\n\n";
infoMessage += $"Name: {sanatisedLevelName}\n";
infoMessage += $"Playable: {isPlayable}\n";
infoMessage += $"Rows: {mazeLevelBounds.X + 1}\n";
infoMessage += $"Columns: {mazeLevelBounds.Y + 1}\n";
infoMessage += "\n\n";
return(infoMessage);
}
catch (System.Exception)
{
return(null);
}
}
public static void LoadMazeLevelForEditor(MazeLevelData mazeLevelData)
{
MazeLevelGameplayManager.Instance.SetupLevelForEditor(mazeLevelData); // sets up the level without instantiating characters etc.
}
public override void BuildTiles(MazeLevelData mazeLevelData)
{
Dictionary <InGameMazeTile, List <SerialisableGridLocation> > TileTransformationGridLocationByTile = new Dictionary <InGameMazeTile, List <SerialisableGridLocation> >();
for (int i = 0; i < mazeLevelData.Tiles.Count; i++)
{
SerialisableTile serialisableTile = mazeLevelData.Tiles[i];
GameObject tileGO = GameObject.Instantiate(MazeLevelGameplayManager.Instance.InGameTilePrefab, _mazeContainer.transform);
InGameMazeTile tile = tileGO.GetComponent <InGameMazeTile>();
tile.SetGridLocation(serialisableTile.GridLocation.X, serialisableTile.GridLocation.Y);
tile.SetId(serialisableTile.Id);
tileGO.name = "Tile" + tile.GridLocation.X + ", " + tile.GridLocation.Y;
tileGO.transform.position = GridLocation.GridToVector(tile.GridLocation);
Tiles.Add(tile);
AddBackgroundSprites(serialisableTile, tile);
AddTileAttributes(serialisableTile, tile);
AddCornerFillers(serialisableTile, tile);
AddTileAreas(serialisableTile, tile);
TilesByLocation.Add(tile.GridLocation, tile);
GridLocation furthestBounds = LevelBounds;
if (tile.GridLocation.X > furthestBounds.X)
{
_levelBounds.X = tile.GridLocation.X;
}
if (tile.GridLocation.Y > furthestBounds.Y)
{
_levelBounds.Y = tile.GridLocation.Y;
}
TileTransformationGridLocationByTile.Add(tile, serialisableTile.TilesToTransform);
}
foreach (KeyValuePair <InGameMazeTile, List <SerialisableGridLocation> > item in TileTransformationGridLocationByTile)
{
List <InGameMazeTile> tilesToTransform = new List <InGameMazeTile>();
for (int i = 0; i < item.Value.Count; i++)
{
for (int j = 0; j < Tiles.Count; j++)
{
InGameMazeTile tile = Tiles[j] as InGameMazeTile;
if (item.Value[i].X == tile.GridLocation.X && item.Value[i].Y == tile.GridLocation.Y)
{
tilesToTransform.Add(tile);
break;
}
}
}
item.Key.AddTilesToTransform(tilesToTransform);
}
for (int k = 0; k < Tiles.Count; k++)
{
InGameMazeTile tile = Tiles[k] as InGameMazeTile;
tile.AddNeighbours(this);
}
ConnectBridgeEdgesToTheirBridgePieces();
}
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);
}
public static InGameMazeLevel Create(MazeLevelData mazeLevelData)
{
Logger.Log(Logger.Initialisation, $"Set up new Maze Level '<color={ConsoleConfiguration.HighlightColour}>{mazeLevelData.Name}</color>'");
return(new InGameMazeLevel(mazeLevelData));
}
public override void BuildTiles(MazeLevelData mazeLevelData)
{
Dictionary <SerialisableGridLocation, List <EditorMazeTile> > TileTransformationTriggererByGridLocation = new Dictionary <SerialisableGridLocation, List <EditorMazeTile> >();
for (int i = 0; i < mazeLevelData.Tiles.Count; i++)
{
SerialisableTile serialisableTile = mazeLevelData.Tiles[i];
GameObject tileGO = GameObject.Instantiate(MazeLevelGameplayManager.Instance.EditorTilePrefab, _mazeContainer.transform);
EditorMazeTile tile = tileGO.GetComponent <EditorMazeTile>();
tile.SetGridLocation(serialisableTile.GridLocation.X, serialisableTile.GridLocation.Y);
tile.SetId(serialisableTile.Id);
tileGO.name = "Tile" + tile.GridLocation.X + ", " + tile.GridLocation.Y;
tileGO.transform.position = GridLocation.GridToVector(tile.GridLocation);
Tiles.Add(tile);
AddTileAttributes(serialisableTile, tile);
AddBackgroundSprites(serialisableTile, tile);
AddCornerFillers(serialisableTile, tile);
AddTileAreas(serialisableTile, tile);
TilesByLocation.Add(tile.GridLocation, tile);
ITileMainMaterial mainMaterial = AddMainMaterial(serialisableTile);
tile.SetMainMaterial(mainMaterial);
GridLocation furthestBounds = LevelBounds;
if (tile.GridLocation.X > furthestBounds.X)
{
_levelBounds.X = tile.GridLocation.X;
}
if (tile.GridLocation.Y > furthestBounds.Y)
{
_levelBounds.Y = tile.GridLocation.Y;
}
if (serialisableTile.TilesToTransform != null)
{
for (int j = 0; j < serialisableTile.TilesToTransform.Count; j++)
{
if (TileTransformationTriggererByGridLocation.ContainsKey(serialisableTile.TilesToTransform[j]))
{
List <EditorMazeTile> transformationTriggerers = TileTransformationTriggererByGridLocation[serialisableTile.TilesToTransform[j]];
transformationTriggerers.Add(tile);
}
else
{
List <EditorMazeTile> transformationTriggerers = new List <EditorMazeTile>();
transformationTriggerers.Add(tile);
TileTransformationTriggererByGridLocation.Add(serialisableTile.TilesToTransform[j], transformationTriggerers);
}
}
}
}
foreach (KeyValuePair <SerialisableGridLocation, List <EditorMazeTile> > item in TileTransformationTriggererByGridLocation)
{
for (int i = 0; i < Tiles.Count; i++)
{
EditorMazeTile tile = Tiles[i] as EditorMazeTile;
if (item.Key.X == tile.GridLocation.X && item.Key.Y == tile.GridLocation.Y)
{
tile.BeautificationTriggerers = item.Value;
}
}
}
for (int k = 0; k < Tiles.Count; k++)
{
EditorMazeTile tile = Tiles[k] as EditorMazeTile;
tile.AddNeighbours(this);
}
ConnectBridgeEdgesToTheirBridgePieces();
}
public void Start()
{
switch (PersistentGameManager.CurrentSceneType)
{
case SceneType.Overworld:
Logger.Log("instantiate overworld sprites, tiles and characters");
if (PersistentGameManager.SceneLoadOrigin == SceneLoadOrigin.Gameplay)
{
if (PersistentGameManager.OverworldName == "")
{
PersistentGameManager.SetOverworldName("overworld");
}
string overworldName = PersistentGameManager.OverworldName;
Logger.Log($"We will load the maze '{overworldName}'");
OverworldData startUpOverworldData = OverworldLoader.LoadOverworldData(overworldName);
if (startUpOverworldData == null)
{
Logger.Error("Could not find the default overworld for startup");
}
OverworldLoader.LoadOverworld(startUpOverworldData);
if (OverworldGameplayManager.Instance.Overworld == null)
{
Logger.Log(Logger.Initialisation, "No overworld loaded on startup. Returning");
return;
}
} // We loaded a overworld scene through the editor. Set up an empty grid for in the editor
else
{
Logger.Log("create empty grid");
EditorCanvasUI.Instance.OverworldModificationPanel.GenerateTiles();
}
break;
case SceneType.Maze:
// We loaded a maze scene through the game. Set up the maze level
if (PersistentGameManager.SceneLoadOrigin == SceneLoadOrigin.Gameplay)
{
if (PersistentGameManager.CurrentSceneName == "")
{
PersistentGameManager.SetCurrentSceneName("default");
}
string mazeName = PersistentGameManager.CurrentSceneName;
PersistentGameManager.SetLastMazeLevelName(mazeName);
Logger.Log($"We will load the maze '{mazeName}'");
MazeLevelData startUpMazeLevelData = MazeLevelLoader.LoadMazeLevelData(mazeName);
if (startUpMazeLevelData == null)
{
Logger.Error($"Could not find the level {mazeName} for startup. Will load defult level instead.");
mazeName = "default";
startUpMazeLevelData = MazeLevelLoader.LoadMazeLevelData(mazeName);
}
MazeLevelLoader.LoadMazeLevel(startUpMazeLevelData);
if (CurrentGameLevel == null)
{
Logger.Log(Logger.Initialisation, "No level loaded on startup. Returning");
return;
}
if (CurrentGameLevel.PlayerCharacterSpawnpoints.Count == 0)
{
return;
}
PlayableLevelNames = MazeLevelLoader.GetAllPlayableLevelNames();
} // We loaded a maze scene through the editor. Set up an empty grid for in the editor
else
{
Logger.Log("create empty grid");
EditorCanvasUI.Instance.MazeModificationPanel.GenerateTiles();
}
break;
default:
Logger.Error($"Scenetype {PersistentGameManager.CurrentSceneType} is not implemented yet");
break;
}
}
public void OnEvent(EventData photonEvent)
{
byte eventCode = photonEvent.Code;
if (eventCode == PlayerMarksTileEvent.PlayerMarksTileEventCode)
{
object[] data = (object[])photonEvent.CustomData;
GridLocation tileLocation = new GridLocation((int)data[0], (int)data[1]);
PlayerNumber playerNumber = (PlayerNumber)data[2];
InGameMazeTile tile = Level.TilesByLocation[tileLocation] as InGameMazeTile;
MazeTilePath mazeTilePath = (MazeTilePath)tile.GetBackgrounds().FirstOrDefault(background => background is MazeTilePath);
if (mazeTilePath == null)
{
return;
}
PlayerMark playerMark = new PlayerMark(mazeTilePath.ConnectionScore);
HandlePlayerMarkerSprite(tile, playerNumber, playerMark);
HandlePlayerTileMarkerEnds(tile);
HandleNumberOfUnmarkedTiles();
tile.ResetPlayerMarkEndsRenderer();
tile.TriggerTransformations();
}
else if (eventCode == LoadNextMazeLevelEvent.LoadNextMazeLevelEventCode)
{
object[] data = (object[])photonEvent.CustomData;
string pickedLevel = (string)data[0];
MazeLevelData mazeLevelData = MazeLevelLoader.LoadMazeLevelData(pickedLevel);
if (mazeLevelData == null)
{
Logger.Error($"Could not load maze level data for the randomly picked maze level {pickedLevel}");
}
PersistentGameManager.SetCurrentSceneName(pickedLevel);
IEnumerator loadLevelCoroutine = LoadOverworldCoroutine("Overworld");
StartCoroutine(loadLevelCoroutine);
}
else if (eventCode == LoadOverworldEvent.LoadOverworldEventCode)
{
object[] data = (object[])photonEvent.CustomData;
string overworldName = (string)data[0];
PersistentGameManager.SetLastMazeLevelName(PersistentGameManager.CurrentSceneName);
PersistentGameManager.SetCurrentSceneName(PersistentGameManager.OverworldName);
IEnumerator loadLevelCoroutine = LoadOverworldCoroutine("Overworld");
StartCoroutine(loadLevelCoroutine);
}
else if (eventCode == PlayerCollidesWithMusicInstrumentCaseEvent.PlayerCollidesWithMusicInstrumentCaseEventCode)
{
object[] data = (object[])photonEvent.CustomData;
GridLocation tileLocation = new GridLocation((int)data[0], (int)data[1]);
PlayerNumber playerNumber = (PlayerNumber)data[2];
InGameMazeTile tile = Level.TilesByLocation[tileLocation] as InGameMazeTile;
MusicInstrumentCase musicInstrumentCase = (MusicInstrumentCase)tile.GetAttributes().FirstOrDefault(attribute => attribute is MusicInstrumentCase);
if (musicInstrumentCase == null)
{
Logger.Error("Could not find musicInstrumentCase");
}
MazePlayerCharacter player = GameManager.Instance.CharacterManager.GetPlayers <MazePlayerCharacter>()[playerNumber];
musicInstrumentCase.PlayerCollisionOnTile(player);
}
else if (eventCode == EnemyCollidesWithMusicInstrumentCaseEvent.EnemyCollidesWithMusicInstrumentCaseEventCode)
{
object[] data = (object[])photonEvent.CustomData;
GridLocation tileLocation = new GridLocation((int)data[0], (int)data[1]);
int enemyId = (int)data[2];
InGameMazeTile tile = Level.TilesByLocation[tileLocation] as InGameMazeTile;
MusicInstrumentCase musicInstrumentCase = (MusicInstrumentCase)tile.GetAttributes().FirstOrDefault(attribute => attribute is MusicInstrumentCase);
if (musicInstrumentCase == null)
{
Logger.Error("Could not find musicInstrumentCase");
}
MazeCharacterManager characterManager = GameManager.Instance.CharacterManager as MazeCharacterManager;
EnemyCharacter enemyCharacter = characterManager.Enemies.FirstOrDefault(enemy => enemy.PhotonView.ViewID == enemyId);
if (enemyCharacter == null)
{
Logger.Error("Could not find enemy character");
}
musicInstrumentCase.EnemyCollisinOnTile(enemyCharacter);
}
}
