public void Win()
{
if(gameState == GameStates.Playing) {
gameState = GameStates.Won;
winScreen.SetActive(true);
}
}
private void destroyGameState(GameStates pState)
{
switch (pState)
{
case GameStates.menu:
{
if (_menu != null) { _menu.Destroy(); }
break;
}
case GameStates.level:
{
//if (_level != null) { _level.Destroy(); }
break;
}
case GameStates.bossarena:
{
if (_bossArena != null) { _bossArena.Destroy(); }
break;
}
case GameStates.nameinput:
{
if (_nameinput != null) { _nameinput.Destroy(); }
break;
}
case GameStates.endscreen:
{
if (_endscreen != null) { _endscreen.Destroy(); }
break;
}
}
}
public static void ChangeToState(GameStates state)
{
switch (state)
{
case GameStates.MainMenuState:
CurrentState = new MainMenuState(currentScreenSize);
break;
case GameStates.LevelOneState:
CurrentState = new LevelOneState(content, currentScreenSize);
break;
case GameStates.LevelTwoState:
CurrentState = new LevelTwoState(content, currentScreenSize);
break;
case GameStates.LevelThreeState:
CurrentState = new LevelThreeState(content, currentScreenSize);
break;
case GameStates.FinalLevel:
CurrentState = new FinalLevel(content, currentScreenSize);
break;
case GameStates.Quit:
CurrentState = new QuitState(currentScreenSize);
break;
case GameStates.PickName:
CurrentState = new PickNameState(currentScreenSize);
break;
case GameStates.HighScore:
CurrentState = new HighScoreState(currentScreenSize);
break;
}
if (UnSeriousEngine.isInitialized)
{
CurrentState.LoadContent(Content);
}
}
public void StartGame()
{
currentGameState = GameStates.Play;
gamesFirstTouch = false;
//turns off all button menus
menuManager.SwitchMenu (MenuManager.MenuTypes.None);
}
// Event
public void FirstEvent()
{
eventManager.firstEvent -= FirstEvent;
state = GameStates.Stop;
Vector3 cameraPos = Camera.main.gameObject.transform.position;
Instantiate (bossList[0], new Vector3(cameraPos.x, cameraPos.y + 12f, 0f), Quaternion.identity);
}
private void inputHandler()
{
if (Input.GetKeyDown("p")) {
state = state == GameStates.Run ? GameStates.Pause : GameStates.Run;
Time.timeScale = Time.timeScale == 0f ? 1f : 0f;
}
}
// The GameClass constructor. Here we create, but not show, the GameSettings form.
// The
public GameClass(MainClass mainClass, Control owner)
{
gameState = GameStates.Loading;
this.owner = owner;
this.mainClass = mainClass;
splash = new SplashScreen(this);
splash.ShowDialog();
gameSettings = new SpaceWar.GameSettings(this);
gameSettings.Location = new Point(owner.Bounds.Right,owner.Bounds.Top);
gravity = gameSettings.Gravity;
gameSpeed = gameSettings.GameSpeed;
bounceBack = gameSettings.Bounce;
inverseGravity = gameSettings.InverseGravity;
blackHole = gameSettings.BlackHole;
localDevice = new Microsoft.DirectX.DirectDraw.Device();
localDevice.SetCooperativeLevel(owner, Microsoft.DirectX.DirectDraw.CooperativeLevelFlags.Normal);
DXUtil.Timer(DirectXTimer.Start);
SpaceWar.RotatableShape.CreateShapes();
input = new InputClass(this.owner);
soundHandler = new SoundHandler(this.owner);
try {
netPeer = new PlayClass(this);
}
catch(DirectXException e) {
MessageBox.Show(owner,e.ToString());
}
}
public void Update(GameTime gameTime, ref GameStates gameState)
{
if (_mControls.IsBackPressed(false))
gameState = GameStates.Exit;
if (_mControls.IsStartPressed(false) || _mControls.IsAPressed(false))
gameState = GameStates.MainMenu;
}
public ReflexGameWindow(string userName, int initialGameTime)
{
InitializeComponent();
SetMouseForm(gameWindow, CHART_WIDTH, CHART_HEIGHT, timeLabel);
setTimeOutMethod(timedOut);
setQuestionTime((double)initialGameTime);
CoordsList = new List<TimePoint>();
greenBrush = new SolidBrush(Color.Green);
blueBrush = new SolidBrush(Color.Blue);
redBrush = new SolidBrush(Color.Red);
this.maxGameTime = INITIAL_GAME_TIME = initialGameTime;
graphics = gameWindow.CreateGraphics();
gameState = GameStates.OutOfGame;
this.userName = userName;
rnd = new Random();
scoreLabel.Text = "";
timeLabel.Text = "";
stopRButton.Enabled = false;
stopLButton.Enabled = false;
}
public void setGameState(GameStates pState)
{
if (pState == _state) return;
destroyGameState(_state);
_state = pState;
newGameState(pState);
}
public void EnterMenu(GameStates stateWhenEntering, GameStates menuTypeToEnter)
{
previousGameState = stateWhenEntering;
currentSelectionIndex = 0;
prevSelectionIndex = 0;
menuType = menuTypeToEnter;
if (menuType == GameStates.MainMenu)
{
Game.SoundManager.PlaySong("LOD", true);
foreach (MenuEntry entry in MainMenuEntries.Keys)
{
entry.SetUnselected();
}
MainMenuEntries.ElementAt(currentSelectionIndex).Key.SetSelected();
}
else if (menuType == GameStates.PAUSE)
{
foreach (MenuEntry entry in PauseMenuEntries.Keys)
{
entry.SetUnselected();
}
PauseMenuEntries.ElementAt(currentSelectionIndex).Key.SetSelected();
}
}
public void Restart()
{
theGameState = GameStates.GS_USER_INPUT;
//reset the target's height
if (theTarget != null && theHill != null)
{
Vector3 targetNewPosistion = new Vector3(theHill.transform.position.x, theHill.transform.position.y, theHill.transform.position.z);
float hillXRotRadians = -Mathf.Deg2Rad * theHill.transform.rotation.eulerAngles.x;
float distUpHill = UnityEngine.Random.Range(-1.0f, 1.0f) * HILL_UNSCALED_HALF_WIDTH * theHill.transform.localScale.z;
//use polar coordinates & the hill's angle to randomly select a distance up the hill for the target
targetNewPosistion.x += UnityEngine.Random.Range(-HILL_HALF_WIDTH, HILL_HALF_WIDTH) / 2.0f;
targetNewPosistion.y += distUpHill * Mathf.Sin(hillXRotRadians);
targetNewPosistion.z += distUpHill * Mathf.Cos(hillXRotRadians);
/*print("targetNewPosition = " + targetNewPosistion + ", distUpHill = " + distUpHill + " hillXRotRadians = " + hillXRotRadians +
"euler.x = " + theHill.transform.rotation.eulerAngles.x);*/
theTarget.transform.Translate(targetNewPosistion - theTarget.transform.position);
}
//reset the ball
if (theBall != null)
{
theBall.Restart();
}
//reset the ballista
if (theBallista != null)
{
theBallista.Restart();
}
}
public void SwitchState(GameStates newState)
{
if (_currentState == newState)
return;
//run code
}
public void SetGameState(GameStates newState)
{
Debug.Log("Setting GameState :" + newState.ToString());
if (newState == GameStates.GameOverLoss) {
RestartGame();
}
}
public static void ChangeState(GameStates newState)
{
if (instance.state == newState)
return;
// Before change
switch (instance.state) {
case GameStates.Login:
break;
case GameStates.Playing:
instance.highscoreCanvas.gameObject.SetActive(false);
break;
case GameStates.Paused:
instance.pauseCanvas.gameObject.SetActive(false);
break;
}
instance.state = newState;
// After change
switch (instance.state) {
case GameStates.Login:
break;
case GameStates.Playing:
instance.highscoreCanvas.gameObject.SetActive(true);
break;
case GameStates.Paused:
instance.pauseCanvas.gameObject.SetActive(true);
break;
}
}
public void startGame()
{
currentState = GameStates.INGAME; //Change state to INGAME
pregameCanvas.gameObject.SetActive (false); //Hide pregameCanvas
ingameCanvas.gameObject.SetActive (true); //Show ingameCanvas
PlayerPrefs.SetInt("gamesPlayed", PlayerPrefs.GetInt ("gamesPlayed", 0) + 1 );
}
public void GameOver()
{
difficulty = 1;
OnGameOver ();
curState = GameStates.Menu;
playButton.SetActive (true);
}
//-----------------------------------------
// INPUT
//-----------------------------------------
public void ButtonControls(int state)
{
// map int to enum values for readability
gameState = (GameStates)state;
// change the game state
changeState = true;
}
public Position(PositionCore core, int fiftyMovesClock, int moveNumber, GameStates properties, LegalMove move)
{
Core = core;
FiftyMovesClock = fiftyMovesClock;
MoveNumber = moveNumber;
Properties = properties;
Move = move;
}
public void SetState (GameStates nextState)
{
if (nextState != currentState)
{
currentState = nextState;
Debug.Log ("Switching to " + nextState);
}
}
public Game1()
{
graphics = new GraphicsDeviceManager( this );
Content.RootDirectory = "Content";
#if Section5 // Game State
CurerntState = GameStates.Loading;
#endif
}
public void RecordVictory(float kgOfFuelLeft)
{
score = (int)Mathf.Max(1.0f, 250000.0f - kgOfFuelLeft);
if (score > highScore)
{
highScore = score;
}
theGameState = GameStates.GS_ENDGAME_VICTORY;
}
public static void ChangeGameState(GameStates state)
{
if (currentState == null)
{
currentState = new GameState();
}
currentState.Enter(state);
}
public void Update(GameTime gameTime, ref GameStates gameState)
{
mouseCurrState = Mouse.GetState();
countDown -= (float)gameTime.ElapsedGameTime.TotalSeconds;
if (countDown <= 1)
gameState = GameStates.GAME;
mousePrevState = mouseCurrState;
}
public void GameOver()
{
currentState = GameStates.GAMEOVER; //Change state to GAMEOVER
CheckHighScore (); //Call CheckHighScore function
gamesPlayedText.text += PlayerPrefs.GetInt ("gamesPlayed", 0); //Set gamesPlayed
gameoverScoreText.text = score.ToString(); //Set gameover scoreText
gameoverBestScoreText.text += PlayerPrefs.GetInt ("bestscore", 0); //Set best score text
StartCoroutine (ShowGameoverCanvas ()); //Show Gameover Canvas
}
public Game1()
{
graphics = new GraphicsDeviceManager(this);
graphics.PreferredBackBufferWidth = level.Width * 32;
graphics.PreferredBackBufferHeight = (level.Height + 1) * 32;
gameStates = GameStates.Menu;
IsMouseVisible = true;
Content.RootDirectory = "Content";
}
public static IGameState GetState(GameStates gameStates)
{
IStateFactory stateFactory;
if (!GetInstance().factories.TryGetValue(gameStates, out stateFactory)) {
Console.WriteLine("Matching factory not found for {0}", gameStates);
throw new NotImplementedException();
}
return stateFactory.GetState();
}
void Awake()
{
if (instance != null)
Debug.LogError("Instance Has Already Been Created Somewhere");
instance = this;
Debug.Log (Screen.width);
Debug.Log (Screen.height);
}
public void PlayerWantsToFinishCooking() {
if (status == GameStates.cooking)
{
status = GameStates.resultTab;
UI.SetForResults();
Grill.GoToRestaurant();
}
}
public void gameOver()
{
currentState = GameStates.GAMEOVER;
checkHighScore ();
gamesPlayedText.text += PlayerPrefs.GetInt ("gamesPlayed", 0);
gameoverScoreText.text = score.ToString();
gameoverBestScoreText.text += PlayerPrefs.GetInt ("bestscore", 0);
StartCoroutine (ShowGameoverCanvas ());
}
static public void endGame()
{
currentState = GameStates.GameOver;
}
private void InitStates()
{
GameStates.Init();
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
{
Exit();
}
// TODO: Add your update logic here
KeyboardState kbState = Keyboard.GetState();
KeyboardState previousKbState = kbState;
switch (activeState)
{
//Main Menu
case GameStates.Menu:
if (SingleKeyPress(Keys.Enter, kbState) == true) //Once the player presses the enter key....
{
activeState = GameStates.Game; //the screen transitions to the main game
ResetGame(); //Resets all data to restart the game
}
break;
//Game
case GameStates.Game:
previousKbState = kbState; //The previous keyboard state will become the current keyboard state
kbState = Keyboard.GetState(); //Retrieves the currently pressed keys
timer -= gameTime.ElapsedGameTime.TotalSeconds; //The timer decreases in real time
if (kbState.IsKeyDown(Keys.Left) == true) //Moves the player left
{
newPlayer.X -= 2;
}
if (kbState.IsKeyDown(Keys.Right) == true) //Moves the player right
{
newPlayer.X += 2;
}
if (kbState.IsKeyDown(Keys.Up) == true) //Moves the player up
{
newPlayer.Y -= 2;
}
if (kbState.IsKeyDown(Keys.Down) == true) //Moves the player down
{
newPlayer.Y += 2;
}
ScreenWrap(); //Constantly calls the ScreenWrap method if the player strays too far off screen
for (int i = 0; i < collectibleList.Count; i++) //Check every collectible inside the list
{
if (collectibleList[i].CheckCollision(newPlayer) == true && collectibleList[i].Active == true) //Once the player collides with the object....
{
collectibleList[i].Active = false; //that collectible alone will become inactive
newPlayer.LevelScore += 1; //Increments the player's level score
newPlayer.TotalScore += 1; //Increments the player's total score
}
}
if (timer <= 0) //Once the timer hits 0....
{
activeState = GameStates.GameOver; //the game will transition to the game over screen
}
if (newPlayer.LevelScore == collectibleList.Count)
{
NextLevel();
}
break;
//Game Over
case GameStates.GameOver:
if (SingleKeyPress(Keys.Enter, kbState) == true) //Once the player presses the enter key here....
{
activeState = GameStates.Menu; //the game will restart
}
break;
}
base.Update(gameTime);
}
void OnClientConnect()
{
Debug.Log("*** CONNECTED TO SERVER ***");
_state = GameStates.SelectingFaction;
}
public static void EnterMenuState()
{
TogglePauseState();
CurrentGameState = GameStates.InMenu;
}
public void UpdateGameLogic()
{
// i guess fading holds a higher priority than spinning because you technically want to fade to spin
if (_fader.Fading)
{
_fader.ContinueFade(ref _queuedUpState);
return;
}
if (_spinner.Spinning)
{
_spinner.ContinueSpin(ref _queuedUpState);
return;
}
_gameState = _queuedUpState;
if (_fader.QueuedFadeIn)
{
_fader.FadeIn();
// clear the inputs, i know this is kind of ghetto
_inputHandler.ClearInputs();
}
if (_gameState == GameStates.StartMenu)
{
_player.Region = RegionNames.Test1;
_camera.Region = RegionNames.Test1;
_player.Position = new Vector2(100, 1800);
_camera.Position = new Vector2(650, 1660);
_player.UpdateWeaponAnchorPositions();
_player.EquipStartingWeapon(0);
_resourceManager.LoadAssets(new RegionLoadMessage()
{
RegionsToLoad = new List <RegionNames>()
{
RegionNames.Test1, RegionNames.Test2
},
RegionsToUnload = new List <RegionNames>()
});
_fader.FadeOut();
_spinner.BeginSpin(GameStates.Roam, RegionNames.Test1);
}
else if (_gameState == GameStates.ExitMenu)
{
_menuLogicHandler.UpdateExitMenuLogic(ref _queuedUpState, ref _paused);
}
else if (_gameState == GameStates.Menu)
{
_menuLogicHandler.UpdatePauseMenuLogic(ref _queuedUpState, ref _paused);
}
else if (_gameState == GameStates.Roam)
{
lock (_resourceManager.Loading.Sync)
{
_roamLogicHandler.UpdateRoamLogic(ref _queuedUpState, ref _paused);
if (_paused)
{
_menuLogicHandler.EnterMenu();
}
}
}
}
public void ChangeState(GameStates newState)
{
m_gameStates[(int)m_activeState].SetActive(false);
m_activeState = newState;
m_gameStates[(int)m_activeState].SetActive(true);
}
public void onDrawSelect()
{
GameState = GameStates.draw;
hideTurnCanvas();
//handle unlocking
}
public GameState(GameController creator)
{
m_GameState = GameStates.Pre;
creator.GameState_Changed += OnGameState_Changed;
}
//Broadcast to system
private void OnStateChanged(GameStates newState)
{
Debug.Log("**** State changed to " + newState);
currentState = newState;
stateChanged.Dispatch(newState);
}
static public void changeToCustomizationScreen()
{
currentState = GameStates.CustomizationOpen;
}
static public void changeToGameScreen()
{
currentState = GameStates.GamePrepare;
}
static public void startGame()
{
currentState = GameStates.GameActive;
}
public void SetGameState(GameStates gameState)
{
m_currentGameState = gameState;
}
public void SetGameState(GameStates state)
{
gameState = state;
}
private void SetUiForGameState(GameStates state)
{
GameState = state;
switch (GameState)
{
case GameStates.Idle:
GameLoadMenuItem.Enabled = true;
GameNewMenuItem.Enabled = true;
GameRunMenuItem.Enabled = true;
GameStepMenuItem.Enabled = true;
GamePauseMenuItem.Enabled = false;
btnRun.Enabled = true;
btnStep.Enabled = true;
btnPause.Enabled = false;
btnNew.Enabled = true;
SpeedSlider.Enabled = true;
CheckboxLockRowAndCols.Enabled = true;
TrackRows.Enabled = true;
TrackCols.Enabled = true;
UpDownRows.Enabled = true;
UpDownCols.Enabled = true;
break;
case GameStates.Run:
GameLoadMenuItem.Enabled = true;
GameNewMenuItem.Enabled = true;
GameRunMenuItem.Enabled = false;
GameStepMenuItem.Enabled = true;
GamePauseMenuItem.Enabled = true;
btnRun.Enabled = false;
btnStep.Enabled = true;
btnPause.Enabled = true;
btnNew.Enabled = true;
SpeedSlider.Enabled = true;
CheckboxLockRowAndCols.Enabled = false;
TrackRows.Enabled = false;
TrackCols.Enabled = false;
UpDownRows.Enabled = false;
UpDownCols.Enabled = false;
break;
case GameStates.Step:
GameLoadMenuItem.Enabled = true;
GameNewMenuItem.Enabled = true;
GameRunMenuItem.Enabled = true;
GameStepMenuItem.Enabled = true;
GamePauseMenuItem.Enabled = false;
btnRun.Enabled = true;
btnStep.Enabled = true;
btnPause.Enabled = false;
btnNew.Enabled = true;
SpeedSlider.Enabled = true;
CheckboxLockRowAndCols.Enabled = false;
TrackRows.Enabled = false;
TrackCols.Enabled = false;
UpDownRows.Enabled = false;
UpDownCols.Enabled = false;
break;
case GameStates.Pause:
GameLoadMenuItem.Enabled = true;
GameNewMenuItem.Enabled = true;
GameRunMenuItem.Enabled = true;
GameStepMenuItem.Enabled = true;
GamePauseMenuItem.Enabled = false;
btnRun.Enabled = true;
btnStep.Enabled = true;
btnPause.Enabled = false;
btnNew.Enabled = true;
SpeedSlider.Enabled = true;
CheckboxLockRowAndCols.Enabled = false;
TrackRows.Enabled = false;
TrackCols.Enabled = false;
UpDownRows.Enabled = false;
UpDownCols.Enabled = false;
break;
}
}
// Update is called once per frame
void Update()
{
//check what state the game is currently in
switch (m_GameState)
{
//initialising
case GameStates.Initialisation:
InitGame();
m_GameState = GameStates.Playing;
break;
//Playing
case GameStates.Playing:
//process the player's input.
ProcessInput();
//check if the player is dead
if (!m_Player.GetComponent <DudeController>().IsPlayerAlive)
{
//set the player as dead
m_Player.GetComponent <DudeController>().DudeDeath();
//play the death sound
m_DeathSound.Play();
//set the gamestate to game over
m_GameState = GameStates.GameOver;
//send the score to the high score system and set the game over text on the game over menu
SubmitHighScore(m_PlayerScore);
}
break;
//game over
case GameStates.GameOver:
//display game over panel
m_Menu.SetActive(true);
break;
default:
break;
}
/* Game Losing Condition Checks*/
//check if they have moved too far backwards and kill player if so
if (m_CurrentNode.GridLocation.y < (m_PlayerScore - 2))
{
m_Player.GetComponent <DudeController>().IsPlayerAlive = false;
}
m_InactiveTime -= Time.deltaTime;
//check if they havent moved to a new row forward for long enough.
if (m_PlayerScore > m_FurthestScoreProgress)
{
m_FurthestScoreProgress = m_PlayerScore;
m_InactiveTime = 5.5f;
}
else
{
if (m_InactiveTime < 0.0f)
{
m_Player.GetComponent <DudeController>().IsPlayerAlive = false;
}
}
}
public void showMenu()
{
menuCanvas.enabled = true;
gameState = GameStates.menu;
resetGame();
}
public static void ExitMenuState()
{
TogglePauseState();
CurrentGameState = GameStates.InPlay;
}
IEnumerator movePlayer(int playerIndex)
{
print(currentState + " - Player" + (playerIndex + 1) + " Moving: " + numberedRolled);
//int netPlayerIndex = 0;///TODO: GET RID OF AND MAKE JUST FLAT OUT playerIndex
//if (playerIndex == 1 || playerIndex == 3)///
// netPlayerIndex = 1;///
//NetworkedPlayerController currentPlayerController = networkedPlayers[netPlayerIndex].GetComponent<NetworkedPlayerController>();
NetworkedPlayerController currentPlayerController = networkedPlayers[playerIndex].GetComponent <NetworkedPlayerController>();
coroutineStarted = true;
for (int i = 0; i < numberedRolled; i++)
{
BoardTileNetworked currentTile = playersCurrentTile[playerIndex].GetComponent <BoardTileNetworked>();
print(currentTile);
//currentPlayerController.responded = false;
//currentPlayerController.left = false;
//currentPlayerController.fightAccepted = false;
//currentPlayerController.tileEffectPassed = false;
if (currentTile.NextBoardTiles.Length > 1)
{
print("Dealing w/ a Switch Tile");
if (!currentPlayerController.isLocalPlayer)
{
while (!currentPlayerController.responded)
{
yield return(null);
}
//break;
}
if (currentPlayerController.isLocalPlayer)
{
currentTile.tileEffect(currentPlayerController);
}
while (!currentPlayerController.responded)
{
yield return(null);
}
if (currentPlayerController.left)
{
playersCurrentTile[playerIndex] = currentTile.NextBoardTiles[0];
}
else
{
playersCurrentTile[playerIndex] = currentTile.NextBoardTiles[1];
}
currentPlayerController.responded = false;
print("Reponded Reset to: " + currentPlayerController.responded);
currentPlayerController.luPromptPanel.SetActive(false);
currentPlayerController.lrPromptPanel.SetActive(false);
}
else
{
playersCurrentTile[playerIndex] = currentTile.NextBoardTiles[0];
}
print("1");
players[playerIndex].transform.position = playersCurrentTile[playerIndex].transform.position;
foreach (GameObject player in players)
{
if (players[playerIndex].transform.position == player.transform.position && players[playerIndex] != player)
{
if (currentPlayerController.isLocalPlayer)
{
currentPlayerController.combatPromptPanel.SetActive(true);
currentPlayerController.combatPromptText.text = "fight " + player.name + "?";
}
while (!currentPlayerController.responded)
{
yield return(null);
}
currentPlayerController.responded = false;
currentPlayerController.combatPromptPanel.SetActive(false);
if (currentPlayerController.fightAccepted)
{
NetworkedPlayerStats defenderStats = player.GetComponent <NetworkedPlayerController>().playersStats;
defenderStats.takeDamage(calculateDamage(currentPlayerController.playersStats, defenderStats));
if (defenderStats.hp >= 0)
{
currentPlayerController.playersStats.takeDamage(calculateDamage(defenderStats, currentPlayerController.playersStats));
}
}
}
}
print("2");
if (currentPlayerController.fightAccepted)
{
print("fightAccepted");
coroutineStarted = false;
break;
}
print("3");
BoardTileNetworked newCurrentTile = playersCurrentTile[playerIndex].GetComponent <BoardTileNetworked>();
print("4");
if (!(newCurrentTile is LUTileNetworked) && !(newCurrentTile is LRTileNetworked) && !(newCurrentTile is BlankTileNetworked))
{
print("Current Player isLocal: " + currentPlayerController.isLocalPlayer);
if (!currentPlayerController.isLocalPlayer)
{
while (!currentPlayerController.responded)
{
yield return(null);
}
}
if (currentPlayerController.isLocalPlayer)
{
newCurrentTile.tileEffect(currentPlayerController);
}
while (!currentPlayerController.responded)
{
yield return(null);
}
currentPlayerController.adPromptPanel.SetActive(false);
currentPlayerController.msPromptPanel.SetActive(false);
print("tile effect passed: " + currentPlayerController.tileEffectPassed);
if (!currentPlayerController.tileEffectPassed)
{
print("Breaking...");
coroutineStarted = false;
break;
}
}
print("5");
yield return(new WaitForSeconds(0.2f));
}
coroutineStarted = false;
currentPlayerController.responded = false;
if (currentState == GameStates.Player1Move)
{
coroutineStarted = false;
currentPlayerController.responded = false;
currentState = GameStates.Player2Turn;
}
else if (currentState == GameStates.Player2Move)
{
print("ok....");
coroutineStarted = false;
currentPlayerController.responded = false;
currentState = GameStates.Player3Turn;
}
else if (currentState == GameStates.Player3Move)
{
coroutineStarted = false;
currentPlayerController.responded = false;
currentState = GameStates.Player4Turn;
}
else if (currentState == GameStates.Player4Move)
{
coroutineStarted = false;
currentPlayerController.responded = false;
currentState = GameStates.Player1Turn;
}
}
void OnFatalError(string message)
{
LastErrorMessage = message;
_state = GameStates.Error;
}
// Update is called once per frame
void Update()
{
//Getting all networked players
if (networkedPlayers.Length != 4)
{
networkedPlayers = GameObject.FindGameObjectsWithTag("NetworkedPlayer");
print("Num of networked players: " + networkedPlayers.Length);
for (int i = 0; i < networkedPlayers.Length; i++)
{
print("Setting up Player " + i);
networkedPlayers[i].GetComponent <NetworkedPlayerController>().setPlayer(i);
print("Player " + i + " set");
}
print("All players set!");
}
//Updating Stat text
//print("Updating Stats...");
//print("statsLines.length: " + statLines.Length);
for (int playerIndex = 0; playerIndex < statLines.Length; playerIndex++)
{
//print("playerIndex: " + playerIndex);
//int netPlayerIndex = 0;///TODO: GET RID OF AND MAKE JUST FLAT OUT playerIndex
//if (playerIndex == 1 || playerIndex == 3)///
// netPlayerIndex = 1;///
//NetworkedPlayerStats stats = networkedPlayers[netPlayerIndex].GetComponent<NetworkedPlayerController>().playersStats;
NetworkedPlayerStats stats = networkedPlayers[playerIndex].GetComponent <NetworkedPlayerController>().playersStats;
statLines[playerIndex].text = "HP: " + stats.hp + "\nAtk: " + stats.atk + "\nDef: " + stats.def + "\nMove: " + stats.movement;
}
print("currentState: " + currentState);
//Setting up the current gameState
switch (currentState)
{
case (GameStates.PregameSetting):
currentState = GameStates.Player1Turn;
currentTurn.text = "Player 1 turn";
break;
case (GameStates.Player1Turn):
rollDiceButton.enabled = true;
break;
case (GameStates.Player1Move):
numberRolledText.text = "Rolled: " + numberedRolled;
if (!coroutineStarted)
{
rollDiceButton.enabled = false;
StartCoroutine(movePlayer(0));
}
break;
case (GameStates.Player2Turn):
rollDiceButton.enabled = true;
currentTurn.text = "Player 2 turn";
break;
case (GameStates.Player2Move):
numberRolledText.text = "Rolled: " + numberedRolled;
if (!coroutineStarted)
{
rollDiceButton.enabled = false;
StartCoroutine(movePlayer(1));
}
break;
case (GameStates.Player3Turn):
rollDiceButton.enabled = true;
currentTurn.text = "Player 3 turn";
break;
case (GameStates.Player3Move):
numberRolledText.text = "Rolled: " + numberedRolled;
if (!coroutineStarted)
{
rollDiceButton.enabled = false;
StartCoroutine(movePlayer(2));
}
break;
case (GameStates.Player4Turn):
rollDiceButton.enabled = true;
currentTurn.text = "Player 4 turn";
break;
case (GameStates.Player4Move):
numberRolledText.text = "Rolled: " + numberedRolled;
if (!coroutineStarted)
{
rollDiceButton.enabled = false;
StartCoroutine(movePlayer(3));
}
break;
case (GameStates.Combat):
break;
case (GameStates.GameOver):
break;
}
}
// Use this for initialization
void Start()
{
currentState = GameStates.START;
coolDownList = new List <List <int> >();
}
private void Start()
{
GameState = GameStates.Play;
}
private void ToggleUIViews(GameStates gamestate)
{
ingameUI.SetActive(gamestate == GameStates.Game);
summaryView.gameObject.SetActive(gamestate == GameStates.Summary);
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
{
this.Exit();
}
// TODO: Add your update logic here
switch (gameState)
{
case GameStates.TitleScreen:
titleScreenTimer +=
(float)gameTime.ElapsedGameTime.TotalSeconds;
if (titleScreenTimer >= titleScreenDelayTime)
{
if ((Keyboard.GetState().IsKeyDown(Keys.Space)) ||
(GamePad.GetState(PlayerIndex.One).Buttons.A ==
ButtonState.Pressed))
{
playerManager.LivesRemaining = playerStartingLives;
playerManager.healthRemaining = playerStartingHealth;
playerManager.PlayerScore = 0;
resetGame();
gameState = GameStates.Playing;
}
}
break;
case GameStates.Playing:
starField.Update(gameTime);
planetManager.Update(gameTime);
asteroidManager.Update(gameTime);
playerManager.Update(gameTime);
enemyManager.Update(gameTime);
explosionManager.Update(gameTime);
collisionManager.CheckCollisions();
if (playerManager.Destroyed)
{
playerDeathTimer = 0f;
enemyManager.Active = false;
playerManager.LivesRemaining--;
if (playerManager.LivesRemaining < 0)
{
gameState = GameStates.GameOver;
}
else
{
gameState = GameStates.PlayerDead;
}
}
if ((playerManager.PlayerScore / pointsPerLevel) + 1 != playerManager.CurrentLevel)
{
playerManager.CurrentLevel = 1 + playerManager.PlayerScore / pointsPerLevel;
gameState = GameStates.LevelUp;
}
if (playerManager.CurrentLevel == 6)
{
gameState = GameStates.Win;
}
break;
case GameStates.PlayerDead:
playerDeathTimer +=
(float)gameTime.ElapsedGameTime.TotalSeconds;
starField.Update(gameTime);
asteroidManager.Update(gameTime);
enemyManager.Update(gameTime);
playerManager.PlayerShotManager.Update(gameTime);
explosionManager.Update(gameTime);
if (playerDeathTimer >= playerDeathDelayTime)
{
resetGame();
gameState = GameStates.Playing;
}
break;
case GameStates.GameOver:
playerDeathTimer +=
(float)gameTime.ElapsedGameTime.TotalSeconds;
starField.Update(gameTime);
asteroidManager.Update(gameTime);
enemyManager.Update(gameTime);
playerManager.PlayerShotManager.Update(gameTime);
explosionManager.Update(gameTime);
if (playerDeathTimer >= playerDeathDelayTime)
{
gameState = GameStates.TitleScreen;
}
break;
case GameStates.LevelUp:
playerDeathTimer +=
(float)gameTime.ElapsedGameTime.TotalSeconds;
starField.Update(gameTime);
asteroidManager.Update(gameTime);
enemyManager.Update(gameTime);
playerManager.PlayerShotManager.Update(gameTime);
explosionManager.Update(gameTime);
if (playerDeathTimer >= playerDeathDelayTime)
{
if (playerManager.CurrentLevel == 2)
{
playerManager.minShotTimer = 0.15f;
enemyManager.MinShipsPerWave = 6;
enemyManager.MaxShipsPerWave = 9;
}
resetGame();
gameState = GameStates.Playing;
}
break;
case GameStates.Win:
playerDeathTimer +=
(float)gameTime.ElapsedGameTime.TotalSeconds;
starField.Update(gameTime);
asteroidManager.Update(gameTime);
enemyManager.Update(gameTime);
playerManager.PlayerShotManager.Update(gameTime);
explosionManager.Update(gameTime);
if (playerDeathTimer >= playerDeathDelayTime)
{
gameState = GameStates.TitleScreen;
}
break;
}
base.Update(gameTime);
}
void HandleOnLoadLevel()
{
GameState = GameStates.Loading;
}
static public void pauseGame()
{
currentState = GameStates.GamePaused;
}
/// <summary>
/// Evento che avviene all'avvio del gioco gestendo il flusso che deve seguire.Ad esempio cambiare lo stato del gioco
/// </summary>
void HandleOnGameStart()
{
GameState = GameStates.MainMenu;
//fai partire la scena del MainMenu.
}
public void RaiseEvent(GameStates newGameState)
{
response.Invoke(newGameState);
}
