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();
    }
示例#2
0
    public void LoadMazeLevel(List <string> arguments)
    {
        if (MazeLevelGameplayManager.Instance == null)
        {
            if (PersistentGameManager.CurrentSceneType == SceneType.Overworld)
            {
                Logger.Warning("We are currently in the overworld scene. Switching scenes.");
                PersistentGameManager.SetLastMazeLevelName("default");
                PersistentGameManager.SetCurrentSceneName("default");

                PhotonNetwork.LoadLevel("Maze"); // TODO this loads the default maze, should load specific maze
            }
            else
            {
                Logger.Error("Cannot find MazeLevelManager. Returning.");
            }
            return;
        }

        MazeLevelData mazeLevelData;

        if (arguments.Count < 2)
        {
            PersistentGameManager.SetLastMazeLevelName("default");
            PersistentGameManager.SetCurrentSceneName("default");

            mazeLevelData = MazeLevelLoader.LoadMazeLevelData(PersistentGameManager.CurrentSceneName);
            MazeLevelLoader.LoadMazeLevel(mazeLevelData);
            return;
            //string message = "The command '<color=" + ConsoleConfiguration.HighlightColour + ">load maze</color>' needs an additional argument with the name of the maze level";
            //Logger.Warning(message);

            //message += "\nThe Currently available levels are: \n";
            //message = MazeLevelLoader.GetAllMazeLevelNamesForPrint(message);
            //throw new NotEnoughArgumentsConsoleException(message);
        }

        string mazeName = arguments[1];

        mazeLevelData = MazeLevelLoader.LoadMazeLevelData(mazeName);

        if (mazeLevelData == null && Console.Instance.ConsoleState != ConsoleState.Closed)
        {
            string printLine = "<color=" + ConsoleConfiguration.HighlightColour + ">" + arguments[1] + "</color> is not a known maze level and cannot be loaded.\n\n";
            printLine += "The Currently available levels are: \n";
            printLine  = MazeLevelLoader.GetAllMazeLevelNamesForPrint(printLine);
            Console.Instance.PrintToReportText(printLine);
        }

        PersistentGameManager.SetLastMazeLevelName(mazeName);
        PersistentGameManager.SetCurrentSceneName(mazeName);

        mazeLevelData = MazeLevelLoader.LoadMazeLevelData(PersistentGameManager.CurrentSceneName);
        MazeLevelLoader.LoadMazeLevel(mazeLevelData);
    }
示例#3
0
    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);
    }
示例#4
0
    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);
        }
    }