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); } }