public void GoToNextState()
{
switch (CurrentState)
{
case GameState.Loading:
CurrentState = GameState.Starting;
OnGameStateChanged?.Invoke(CurrentState);
break;
case GameState.Starting:
CurrentState = GameState.Playing;
OnGameStateChanged?.Invoke(CurrentState);
break;
case GameState.Playing:
CurrentState = GameState.Finished;
OnGameStateChanged?.Invoke(CurrentState);
break;
case GameState.Finished:
CurrentState = GameState.Starting;
OnGameStateChanged?.Invoke(CurrentState);
break;
}
}
private void Start()
{
DontDestroyOnLoad(gameObject);
_StateMachine.OnStateChanged += state => OnGameStateChanged?.Invoke(state);
_StateMachine.SetState(_StartState);
}
private void Awake()
{
if (_instance != null)
{
Destroy(gameObject);
return;
}
_instance = this;
DontDestroyOnLoad(gameObject);
_stateMachine = new StateMachine();
_stateMachine.OnStateChanged += state => OnGameStateChanged?.Invoke(state);
var menu = new Menu();
var loading = new Loadlevel();
var play = new Play();
var paused = new Paused();
_stateMachine.SetState(menu);
_stateMachine.AddTransition(loading, play, loading.OperationsFinished);
_stateMachine.AddTransition(paused, menu, () => RestartButton.Pressed);
_stateMachine.AddTransition(paused, play, () => PlayerInput.Instance.PausePressed);
_stateMachine.AddTransition(play, paused, () => PlayerInput.Instance.PausePressed);
_stateMachine.AddTransition(menu, loading, () => PlayButton.LevelToLoad != null);
}
public void UpdateGameState(GameState _newGameState_)
{
gameState = _newGameState_;
switch (_newGameState_)
{
case GameState.MainMenu_State:
break;
case GameState.LevelGeneration:
SceneManager.LoadScene("LvlGen_Test");
break;
case GameState.Gameplay_State:
Transform start = GameObject.FindGameObjectWithTag("Start").transform;
GameObject player = GameObject.Instantiate(playerObj, start.position, start.rotation);
break;
case GameState.Fail_State:
break;
case GameState.Success_State:
break;
default:
throw new ArgumentOutOfRangeException(nameof(_newGameState_), _newGameState_, null);
}
OnGameStateChanged?.Invoke(_newGameState_);
}
private void GamePlayBlueCard()
{
if (GameState.state == ETriadGameState.InProgressBlue)
{
if ((Session.specialRules & ETriadGameSpecialMod.BlueCardSelection) != ETriadGameSpecialMod.None)
{
UndoStateBlue = new TriadGameData(GameState);
}
bool bHasMove = Session.SolverFindBestMove(GameState, out int bestNextPos, out TriadCard bestNextCard, out TriadGameResultChance bestChance);
if (bHasMove)
{
Logger.WriteLine("Blue> [{0}]: {1} => {2}: {3:P0}",
bestNextPos, bestNextCard.Name.GetCodeName(),
bestChance.expectedResult == ETriadGameState.BlueDraw ? "draw" : "win",
bestChance.expectedResult == ETriadGameState.BlueDraw ? bestChance.drawChance : bestChance.winChance);
GameState.bDebugRules = true;
Session.PlaceCard(GameState, bestNextCard, ETriadCardOwner.Blue, bestNextPos);
GameState.bDebugRules = false;
OnGameStateChanged?.Invoke(GameState, new Move()
{
Card = bestNextCard, BoardIdx = bestNextPos, WinChance = bestChance
});
}
else
{
OnGameStateChanged?.Invoke(GameState, null);
}
}
}
void GameStateChanged(NinjaGameManagerModel model, uint value)
{
Debug.Log("Current GameState: " + (GameState)value);
OnGameStateChanged?.Invoke((GameState)value);
switch (value)
{
case ((uint)NinjaGameManager.GameState.Intro):
break;
case ((uint)NinjaGameManager.GameState.RoundSetUp):
DoRoundSetUp();
break;
case ((uint)NinjaGameManager.GameState.P1AttackRound):
StartCoroutine(DoP1AttackRound());
break;
case ((uint)NinjaGameManager.GameState.Break):
break;
case ((uint)NinjaGameManager.GameState.P2AttackRound):
StartCoroutine(DoP2AttackRound());
break;
case ((uint)NinjaGameManager.GameState.GameResults):
DoGameResults();
break;
}
}
public void StartGameState(eGameState newGameState)
{
if (newGameState != CurrentGameState)
{
//End current gamestate
switch (CurrentGameState)
{
case eGameState.Waiting:
case eGameState.Playing:
break;
}
//Start new gamestate
switch (newGameState)
{
case eGameState.Waiting:
case eGameState.Playing:
break;
}
//reset time
m_WaitTime = 0;
m_MatchTime = 0;
if (OnGameStateChanged != null)
{
OnGameStateChanged.Invoke(newGameState);
}
}
}
private void UpdateState(GameState newState)
{
GameState previousGameState = State;
State = newState;
switch (State)
{
case GameState.BOOT:
{
Time.timeScale = 1.0f;
break;
}
case GameState.RUNNING:
{
Time.timeScale = 1.0f;
break;
}
case GameState.PAUSED:
{
Time.timeScale = 0.0f;
break;
}
}
OnGameStateChanged?.Invoke(previousGameState, State);
}
void UpdateState(GameState state)
{
GameState previousGameState = _currentGameState; // Save to previous game state
_currentGameState = state; // Change to the new game state
switch (_currentGameState)
{
case GameState.PREGAME: // Initialize any systems that need to be reset
Time.timeScale = 0.0f;
break;
case GameState.RUNNING: // Unlock player, enemies and input in other systems, update tick if you are managing time
Time.timeScale = 1.0f;
break;
case GameState.PAUSED: // Pause player, enemies etc, Lock other input in other systems
Time.timeScale = 0.0f;
break;
default:
break;
}
OnGameStateChanged.Invoke(_currentGameState, previousGameState);
}
private void Awake()
{
// Make sure there's only ever one instance of GameStateMachine
if (_instance != null)
{
Destroy(this.gameObject);
return;
}
_instance = this;
DontDestroyOnLoad(this.gameObject);
// Create a base StateMachine and hook into it's OnStateChanged
_stateMachine = new StateMachine();
_stateMachine.OnStateChanged += state => OnGameStateChanged?.Invoke(state);
// Create our states and default to the Menu state
var menu = new Menu();
var loading = new LoadLevel();
var play = new Play();
var pause = new Pause();
_stateMachine.SetState(menu);
// Create all of our game state transitions
_stateMachine.AddTransition(menu, loading, () => PlayButton.LevelToLoad != null);
_stateMachine.AddTransition(loading, play, loading.Finished);
_stateMachine.AddTransition(play, pause, () => PlayerInput.Instance.PausePressed);
_stateMachine.AddTransition(pause, play, () => PlayerInput.Instance.PausePressed);
_stateMachine.AddTransition(pause, menu, () => RestartButton.Pressed);
}
private void GoalPlayerTwo_OnScoreChanged(int newScore)
{
if (newScore >= scoreToWin)
{
playing = false;
OnGameStateChanged?.Invoke(playing, 2);
}
}
/// <summary>
/// Поставить игру на паузу
/// </summary>
public void PauseGame()
{
m_GameState = GameState.PAUSE;
OnGameStateChanged?.Invoke(GameState.PAUSE);
m_InstantiateManager.StopInstantiate = true;
GameTimer.IsRunning = false;
Time.timeScale = 0;
}
/// <summary>
/// Возобновить игровой процесс после паузы
/// </summary>
public void ContinueGame()
{
m_GameState = GameState.PLAY;
OnGameStateChanged?.Invoke(GameState.PLAY);
m_InstantiateManager.StopInstantiate = false;
GameTimer.IsRunning = true;
Time.timeScale = 1;
}
private void ParseGameState(Message e)
{
string gameState = e.MessageString.Remove(0, "GAME_STATE ".Length);
CurrentGameState = gameState;
OnGameStateChanged?.Invoke(gameState);
}
private void Ball_OnLifeChanged(int newLife)
{
if (newLife <= loseCondition)
{
playing = false;
OnGameStateChanged?.Invoke(playing);
}
}
public void ChangeGameState(GameManagerState state)
{
if (state == GameManagerState.ActivePlay)
{
m_loGameState = m_lightsOutDefinition.gameBuilder.Create(m_lightsOutDefinition.gameBoard, m_gameInitData);
}
OnGameManagerStateChanged?.Invoke(state);
OnGameStateChanged?.Invoke(m_loGameState);
}
private void ChangeGameState(GameState state)
{
if (_gameState == state)
{
return;
}
_gameState = state;
OnGameStateChanged?.Invoke(state);
}
public void GameUndoRed()
{
if (UndoStateRed.Count > 0)
{
GameState = UndoStateRed[UndoStateRed.Count - 1];
UndoStateRed.RemoveAt(UndoStateRed.Count - 1);
OnGameStateChanged?.Invoke(GameState, null);
}
}
public void HandleUserInteraction(int selected)
{
m_loGameState = m_lightsOutDefinition.gameBoard.MakeMove(m_loGameState, selected);
m_movesMade.value += 1;
OnGameStateChanged?.Invoke(m_loGameState);
if (m_loGameState.isWon)
{
ChangeGameState(GameManagerState.ResultsDisplay);
}
}
/// <summary>
/// Начать игру заново
/// </summary>
public void RestartGame()
{
m_GameState = GameState.PLAY;
OnGameStateChanged?.Invoke(GameState.RESTART);
GameTimer.RestartTimer();
GameTimer.IsRunning = true;
m_InstantiateManager.StopInstantiate = false;
m_InstantiateManager.DestroyAllPopups();
GameTimer.IsRunning = true;
Time.timeScale = 1;
}
//Конец игры (завершается таймером)
private void EndGame()
{
m_GameState = GameState.END;
OnGameStateChanged?.Invoke(GameState.END);
GameTimer.RestartTimer();
GameTimer.IsRunning = false;
m_InstantiateManager.StopInstantiate = true;
m_InstantiateManager.DestroyAllPopups();
GameTimer.IsRunning = false;
Time.timeScale = 0;
}
private void Update()
{
if (!playing)
{
if (Input.GetKeyDown(KeyCode.Return))
{
playing = true;
OnGameStateChanged?.Invoke(playing, 0);
}
}
}
public void ChangeGameState(GameState gameState)
{
OnGameStateChanged?.Invoke(gameState);
// Send the event for resumed but then set the actual state back to playing to make it less confusing
if (gameState == GameState.Resumed)
{
gameState = GameState.Playing;
}
GameState = gameState;
}
// -------------------------------------------------------------------------------
public void ChangeGameplayState(GameplayStates newGameplayState)
{
if (CurrentGameplayState != newGameplayState)
{
if (OnGameStateChanged != null)
{
OnGameStateChanged.Invoke(CurrentGameplayState, newGameplayState);
}
CurrentGameplayState = newGameplayState;
}
}
public void GameReset()
{
Logger.WriteLine("Game.Reset");
foreach (var rule in Session.modifiers)
{
rule.OnMatchInit();
}
GameState = Session.StartGame(PlayerDeck, Npc.Deck, ETriadGameState.InProgressRed);
UndoStateBlue = null;
UndoStateRed.Clear();
OnGameStateChanged?.Invoke(GameState, null);
}
protected void Init()
{
if (_instance != null)
{
Destroy(gameObject);
return;
}
_instance = this;
DontDestroyOnLoad(gameObject);
_stateMachine = new StateMachine();
//Subscribe to OnGameStateChanged elsewhere if you want to see when a state changes as well as get access to information in the state
_stateMachine.OnStateChanged += state => OnGameStateChanged?.Invoke(state);
_stateMachine.OnStateChanged += state => StateChanged(state);
}
public void UpdateGameState(GameState newState)
{
gameState = newState;
switch (newState)
{
case GameState.Wait:
break;
case GameState.Move:
break;
default:
break;
}
OnGameStateChanged?.Invoke(newState);
}
public void SetGameRedCard(TriadCard card, int boardIdx)
{
if (GameState != null)
{
GameState.forcedCardIdx = -1;
TriadGameData newUndoState = new TriadGameData(GameState);
Logger.WriteLine("Red> [{0}]: {1}", boardIdx, card.Name.GetCodeName());
GameState.bDebugRules = true;
bool bPlaced = Session.PlaceCard(GameState, card, ETriadCardOwner.Red, boardIdx);
GameState.bDebugRules = false;
// additional debug logs
int numBoardPlaced = 0;
{
int availBoardMask = 0;
for (int Idx = 0; Idx < GameState.board.Length; Idx++)
{
if (GameState.board[Idx] != null)
{
numBoardPlaced++;
}
else
{
availBoardMask |= (1 << Idx);
}
}
Logger.WriteLine(" Board cards:{0} ({1:x}), placed:{2}", numBoardPlaced, availBoardMask, bPlaced);
}
if (bPlaced)
{
if (numBoardPlaced == GameState.board.Length)
{
OnGameStateChanged?.Invoke(GameState, null);
}
else
{
GamePlayBlueCard();
}
UndoStateRed.Add(newUndoState);
}
}
}
void DisplayScreen(OnGameStateChanged e)
{
switch (GameManager.instance.state)
{
case Enums.GAME_STATE.SELECTION:
ChangeScreen(selectionScreen);
return;
case Enums.GAME_STATE.GAME:
ChangeScreen(levelScreen);
return;
case Enums.GAME_STATE.END:
ChangeScreen(endScreen);
return;
case Enums.GAME_STATE.MENU:
ChangeScreen(menuScreen);
return;
}
}
void ChangeMusic(OnGameStateChanged e)
{
switch (GameManager.instance.state)
{
case Enums.GAME_STATE.MENU:
_audioMusicSource.clip = _menuClip;
break;
case Enums.GAME_STATE.SELECTION:
return;
case Enums.GAME_STATE.GAME:
_audioMusicSource.clip = _gameClip;
break;
case Enums.GAME_STATE.END:
_audioMusicSource.clip = _endClip;
break;
}
_audioMusicSource.Play();
}
