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);
}
public void LoadMazeEditor()
{
PersistentGameManager.SceneLoadOrigin = SceneLoadOrigin.Editor;
string mazeName = "default";
PersistentGameManager.SetLastMazeLevelName(mazeName);
PersistentGameManager.SetCurrentSceneName(mazeName);
PhotonNetwork.LoadLevel("Maze");
}
public void LoadOverworldEditor()
{
PersistentGameManager.SceneLoadOrigin = SceneLoadOrigin.Editor;
if (PersistentGameManager.OverworldName == "")
{
PersistentGameManager.SetOverworldName("overworld");
}
PersistentGameManager.SetLastMazeLevelName(PersistentGameManager.CurrentSceneName);
PersistentGameManager.SetCurrentSceneName(PersistentGameManager.OverworldName);
PhotonNetwork.LoadLevel("Overworld");
}
public void LoadOverworld(string overworldName = "default")
{
if (GameRules.GamePlayerType == GamePlayerType.SinglePlayer ||
GameRules.GamePlayerType == GamePlayerType.SplitScreenMultiplayer)
{
PersistentGameManager.SetLastMazeLevelName(PersistentGameManager.CurrentSceneName);
PersistentGameManager.SetCurrentSceneName(overworldName);
IEnumerator loadLevelCoroutine = LoadOverworldCoroutine("Overworld");
StartCoroutine(loadLevelCoroutine);
}
else
{
LoadOverworldEvent loadOverworldEvent = new LoadOverworldEvent();
loadOverworldEvent.SendLoadOverworldEvent(overworldName);
}
}
public void Launch()
{
if (GameRules.GameMode == GameMode.Campaign)
{
PersistentGameManager.SetOverworldName("overworld");
PersistentGameManager.SetCurrentSceneName(PersistentGameManager.OverworldName);
PhotonNetwork.LoadLevel("Overworld");
}
else
{
PersistentGameManager.SetLastMazeLevelName("default");
PersistentGameManager.SetCurrentSceneName("default");
PhotonNetwork.LoadLevel("Maze");
}
}
public void PerformMazeLevelEntryAction(string mazeName)
{
// Player does not meet entry requirements? Return;
if (GameRules.GamePlayerType == GamePlayerType.SinglePlayer)
{
PersistentGameManager.SetCurrentSceneName(mazeName);
OverworldGameplayManager.Instance.LoadMaze();
}
else if (GameRules.GamePlayerType == GamePlayerType.SplitScreenMultiplayer)
{
PersistentGameManager.SetCurrentSceneName(mazeName);
OverworldGameplayManager.Instance.LoadMaze();
}
else
{
PersistentGameManager.SetCurrentSceneName(mazeName);
PlayerSendsMazeLevelInvitationEvent playerSendsMazeLevelInvitationEvent = new PlayerSendsMazeLevelInvitationEvent();
playerSendsMazeLevelInvitationEvent.SendPlayerSendsMazeLevelInvitationEvent(PhotonView.Owner.NickName, mazeName);
string otherPlayerName = "";
if (PlayerNumber == PlayerNumber.Player1)
{
otherPlayerName = GameManager.Instance.CharacterManager.GetPlayerCharacter <PlayerCharacter>(PlayerNumber.Player2).PhotonView.Owner.NickName;
}
else if (PlayerNumber == PlayerNumber.Player2)
{
otherPlayerName = GameManager.Instance.CharacterManager.GetPlayerCharacter <PlayerCharacter>(PlayerNumber.Player1).PhotonView.Owner.NickName;
}
else
{
Logger.Warning($"Unknown player number {PlayerNumber}");
}
OverworldMainScreenOverlayCanvas.Instance.ShowPlayerMessagePanel($"We are waiting for {otherPlayerName} to accept our invitation...");
MazeLevelInvitation.PendingInvitation = true;
}
}
public void OnEvent(EventData photonEvent)
{
byte eventCode = photonEvent.Code;
if (eventCode == LoadNextMazeLevelEvent.LoadNextMazeLevelEventCode)
{
object[] data = (object[])photonEvent.CustomData;
string mazeName = (string)data[0];
PersistentGameManager.SetCurrentSceneName(mazeName);
Logger.Log("received event to load maze");
IEnumerator loadLevelCoroutine = LoadLevelCoroutine("Maze");
StartCoroutine(loadLevelCoroutine);
}
else if (eventCode == PlayerSendsMazeLevelInvitationEvent.PlayerSendsMazeLevelInvitationEventCode)
{
object[] data = (object[])photonEvent.CustomData;
string invitorName = (string)data[0];
string mazeName = (string)data[1];
Logger.Log($"received event for invitation from {invitorName}");
MazeLevelInvitation.PendingInvitation = true;
OverworldMainScreenOverlayCanvas.Instance.ShowMazeInvitation(invitorName, mazeName);
}
else if (eventCode == PlayerRejectsMazeLevelInvitationEvent.PlayerRejectsMazeLevelInvitationEventCode)
{
object[] data = (object[])photonEvent.CustomData;
string rejectorName = (string)data[0];
string mazeName = (string)data[1];
Logger.Log($"received event that {rejectorName} rejected the invitation");
OverworldMainScreenOverlayCanvas.Instance.ShowMazeInvitationRejection(rejectorName, mazeName);
}
}
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);
}
}
