private void CheckGameState(Enums.GameStates state)
{
if (state == Enums.GameStates.LevelFinish)
{
_rb.velocity = Vector3.zero;
}
}
public void InvokeGameModeChanged(Enums.GameStates state)
{
if (DoGameModeChanged != null)
{
DoGameModeChanged(state);
}
}
void Awake()
{
if (instance == null)
{
DontDestroyOnLoad(this.gameObject);
instance = this;
state = Enums.GameStates.Running;
prevState = Enums.GameStates.Running;
musicVol = .3f;
sfxVol = .3f;
if (FileExists())
Load();
else
{
//weapons = new Enums.BulletTypes[] { Enums.BulletTypes.Pistol, Enums.BulletTypes.Destroyer, Enums.BulletTypes.Malloc, Enums.BulletTypes.Free, Enums.BulletTypes.Launcher };
weapons = new Enums.BulletTypes[] { Enums.BulletTypes.Pistol };
Store();
}
}
else if (this != instance)
{
Destroy(this.gameObject);
}
}
/// <summary>
/// Adds a disc to the game board.
/// </summary>
/// <param name="disc"></param>
/// <param name="RowIndex"></param>
public void AddDisc(Disc disc, int RowIndex)
{
if (this._CurrentState != Enums.GameStates.RedsTurn && this._CurrentState != Enums.GameStates.YellowsTurn)
{
throw new Exception("The game has already ended! " + this.GetGameStateString());
}
if (this._CurrentState == Enums.GameStates.YellowsTurn && disc.Side == Enums.Sides.Red)
{
throw new WrongPlayerMoveException("It is currently yellow's turn. Play a yellow disc.");
}
else if (this._CurrentState == Enums.GameStates.RedsTurn && disc.Side == Enums.Sides.Yellow)
{
throw new WrongPlayerMoveException("It is currently red's turn. Play a red disc.");
}
this._Board.AddDisc(disc, RowIndex);
if (!CheckForWinOrDraw()) // Need to switch the sides that are currently playing around
{
if (this._CurrentState == Enums.GameStates.RedsTurn)
{
this._CurrentState = Enums.GameStates.YellowsTurn;
}
else
{
this._CurrentState = Enums.GameStates.RedsTurn;
}
}
// Either way, the game state has changed
FireGameStateChangedEvent();
}
private void PlayLevelFinishAnimation(Enums.GameStates state)
{
if (state == Enums.GameStates.LevelFinish)
{
Vector3 pos = transform.position;
LeanTween.move(gameObject, _finishFlag.position, 1f).setEase(LeanTweenType.easeInCubic);
}
}
/// <summary>
/// Resets the board and re-initializes the game. WARNING: All existing game state will be lost!
/// </summary>
public void Reset()
{
_Board.Dispose();
_Board = null;
_Board = new Board(this._Height, this._Width, this);
this._CurrentState = Enums.GameStates.YellowsTurn;
FireGameStateChangedEvent();
}
private void RenderLoop()
{
while (true)
{
if (state == Enums.GameStates.ResetGame)
{
DrawResetGame();
}
if (state == Enums.GameStates.RestartGame)
{
resultLabel.Invoke(new Action(delegate() { resultLabel.Text = "Game is over, reset to restart!"; }));
}
if (state == Enums.GameStates.StartGame)
{
RenderCard(null, pictureBoxDealerHand1);
RenderCard(dealer.cardList[dealer.cardList.Count - 1], pictureBoxDealerHand2);
RenderCard(player1.cardList[player1.cardList.Count - 2], pictureBoxPlayer1Hand1);
RenderCard(player1.cardList[player1.cardList.Count - 1], pictureBoxPlayer1Hand2);
RenderCard(player2.cardList[player2.cardList.Count - 2], pictureBoxPlayer2Hand1);
RenderCard(player2.cardList[player2.cardList.Count - 1], pictureBoxPlayer2Hand2);
state = Enums.GameStates.Wait;
}
//if(state == Enums.GameStates.Start)
//{
// // check dealer cards for dead or Blackjack
// if (dealer.sumCards() > 21)
// {
// resultLabel.Text = String.Format("The sum of the dealers cards is: {0}, Dealer dead! You win! Click Reset", dealer.sumCards());
// }
// else if (dealer.sumCards() == 21)
// {
// resultLabel.Text = String.Format("Blackjack!, Dealer wins!");
// }
// else
// {
// // dealer no blackjack or dead so continue
// // check player cards for dead or blackjack
// if (player1.sumCards() > 21)
// {
// resultLabel.Text = String.Format("The sum of {0} cards is: {1}, you lose! Click Reset", player1.Name, player1.sumCards());
// }
// else if (player1.sumCards() == 21)
// {
// resultLabel.Text = String.Format("Blackjack!, {0} wins!", player1.Name);
// }
// else
// {
// resultLabel.Text = String.Format("The sum of {0} cards is: {1}", player1.Name, player1.sumCards());
// }
// }
//}
}
}
private void OpenLevelFinishPanel(Enums.GameStates state)
{
if (state == Enums.GameStates.LevelFinish)
{
_levelFinishPanel.gameObject.SetActive(true);
}
else
{
_levelFinishPanel.gameObject.SetActive(false);
}
}
private void ChangeCamera(Enums.GameStates state)
{
if (state == Enums.GameStates.LevelFinish)
{
_finishCam.m_Priority = 15;
}
else if (state == Enums.GameStates.Gameplay)
{
_finishCam.m_Priority = 5;
}
}
private void SetBlockCondition(Enums.GameStates state)
{
if (state == Enums.GameStates.LevelFinish)
{
_isBlocked = true;
}
else
{
_isBlocked = false;
}
}
public void Load()
{
State = Enums.GameStates.ResetGame;
// Create a thread object, passing in the Update method
var gameThread = new Thread(GameLoop);
// make it a background thread so it is ternimated at app close.
gameThread.IsBackground = true;
// Start the game thread
gameThread.Start();
}
public void SetGameState(Enums.GameStates newGameState, Guid selectedObjectId)
{
switch (newGameState)
{
case Enums.GameStates.ManPressed: SetSelectedMan(selectedObjectId); break;
case Enums.GameStates.ManSelected: SetSelectedMan(selectedObjectId); break;
case Enums.GameStates.RoomSelected: SetSelectedRoom(selectedObjectId); break;
}
SetGameState(newGameState);
}
public void SetGameState(Enums.GameStates newGameState)
{
switch (newGameState)
{
case Enums.GameStates.Normal:
ResetSelectedRoom();
ResetSelectedMan();
GuiManager.Ref.SetNormalCursor();
BuildManager.Ref.HideRoomPositionSelectors();
RoomManager.Ref.HighlightNoRoom();
GuiManager.Ref.ShowBuildRoomDlg(false);
GuiManager.Ref.ShowMainMenuDlg(false);
GuiManager.Ref.ShowHireDlg(false);
break;
case Enums.GameStates.GuiBlocking:
GuiManager.Ref.SetGuiBlockingCursor();
ResetSelectedRoom();
ResetSelectedMan();
break;
case Enums.GameStates.BuildRoom:
ResetSelectedRoom();
ResetSelectedMan();
GuiManager.Ref.ShowBuildRoomDlg(false);
break;
case Enums.GameStates.RoomSelected:
ResetSelectedMan();
GuiManager.Ref.Show_RoomInfoWindow(_SelectedRoom);
break;
case Enums.GameStates.ManPressed:
ResetSelectedRoom();
break;
case Enums.GameStates.ManSelected:
ResetSelectedRoom();
GuiManager.Ref.Show_ManInfoWindow(_SelectedMan);
break;
case Enums.GameStates.ManDragging:
ResetSelectedRoom();
GuiManager.Ref.SetManDragCursor();
break;
}
_GameState = newGameState;
}
void Awake()
{
if (instance == null)
{
DontDestroyOnLoad(this.gameObject);
instance = this;
state = Enums.GameStates.Running;
prevState = Enums.GameStates.Running;
musicVol = .5f;
sfxVol = .5f;
weapons = new Enums.BulletTypes[] { Enums.BulletTypes.Player };
}
else if (this != instance)
{
Destroy(this.gameObject);
}
}
// handles hit button click for player 1
private void hitButton_Click(object sender, EventArgs e)
{
if (player1.SumCards() == 0)
{
resultLabel.Text = "You need to deal first!";
RenderCard(null, pictureBoxPlayer1Hit);
}
// player sumcards is not 0, so continue
else
{
if (player1.SumCards() >= 21 || dealer.SumCards() >= 21)
{
state = Enums.GameStates.RestartGame;
}
else
{
int randomCard = selectRandomCard();
Card card = deck[randomCard];
usedCards.Add(randomCard);
if (usedCards.Contains(randomCard))
{
randomCard = selectRandomCard();
}
else
{
randomCard = 1 * randomCard;
}
pictureBoxPlayer1Hit.ImageLocation = card.Image;
player1.cardList.Add(card);
if (player1.SumCards() > 21)
{
resultLabel.Text = String.Format("The sum of {0} cards is: {1}, you lose! Click Reset", player1.Name, player1.SumCards());
}
else if (player1.SumCards() == 21)
{
resultLabel.Text = String.Format("BlackJack!, you win!");
}
else
{
resultLabel.Text = String.Format("The sum of {0} cards is: {1}", player1.Name, player1.SumCards());
}
}
}
}
void Awake()
{
if (instance == null)
{
DontDestroyOnLoad(this.gameObject);
instance = this;
state = Enums.GameStates.Running;
prevState = Enums.GameStates.Running;
musicVol = .5f;
sfxVol = .5f;
weapons = new Enums.BulletTypes[] { Enums.BulletTypes.Pistol };
}
else if (this != instance)
{
Destroy(this.gameObject);
}
}
void Awake()
{
if (instance == null)
{
DontDestroyOnLoad(this.gameObject);
instance = this;
state = Enums.GameStates.CardSelection;
prevState = Enums.GameStates.CardSelection;
musicVol = .5f;
sfxVol = .5f;
player1Win = false;
player1Lose = false;
}
else if (this != instance)
{
Destroy(this.gameObject);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="Height">The height of the board to be played. Must be greater than 0.</param>
/// <param name="Width">The width of the board to be played. Must be greater than 0.</param>
public Game(int Height, int Width)
{
if (Height <= 0 || Width <= 0)
{
throw new InvalidBoardDimensionsException("The height and width of the board must be greater than 0.");
}
if (Height < cConnectionsRequired || Width < cConnectionsRequired)
{
throw new InvalidBoardDimensionsException("The board is too small, players will not be able to win.");
}
this.winningCheckAlgorithms = new List <IWinCheckAlgorithm>();
this.winningCheckAlgorithms.Add(new DiagonalWinCheckAlgorithm());
this.winningCheckAlgorithms.Add(new HorizontalWinCheckAlgorithm());
this.winningCheckAlgorithms.Add(new VerticalWinCheckAlgorithm());
this._Height = Height;
this._Width = Width;
this._CurrentState = Enums.GameStates.YellowsTurn;
_Board = new Board(Height, Width, this);
}
private void GameLoop()
{
while (true)
{
// NEW GAME
if (state == Enums.GameStates.ResetGame)
{
// reset game
ResetGame();
// generate deck
deck = Deck.GenerateDeck();
dealer.Shuffle(deck);
dealer.Deal(deck, dealer);
dealer.Deal(deck, dealer);
dealer.Deal(deck, player1);
dealer.Deal(deck, player1);
dealer.Deal(deck, player2);
dealer.Deal(deck, player2);
// when done, chage state to start
state = Enums.GameStates.StartGame;
}
// START GAME
if (turn == Enums.Turn.Dealer)
{
//// Deal dealer
//DealDealer();
//// Deal player
//DealPlayers();
state = Enums.GameStates.Wait;
}
}
}
/// <summary>
/// Checks the board for a winner or a draw, and updates the game state accordingly.
/// </summary>
/// <returns>True if there was a win or draw, false otherwise.</returns>
private bool CheckForWinOrDraw()
{
if (this.Board != null)
{
for (int X = 0; X <= this._Board.Discs.GetUpperBound(0); X++)
{
for (int Y = 0; Y <= this._Board.Discs.GetUpperBound(1); Y++)
{
var discCurrentlyChecking = this._Board.Discs[X, Y];
if (discCurrentlyChecking != null)
{
if (this.winningCheckAlgorithms != null &&
this.winningCheckAlgorithms.Any(algo => algo.CheckForWinningCondition(this._Board, discCurrentlyChecking)))
{
if (discCurrentlyChecking.Side == Enums.Sides.Red)
{
this._CurrentState = Enums.GameStates.RedWins;
}
else
{
this._CurrentState = Enums.GameStates.YellowWins;
}
return(true);
}
}
}
}
// Check for a draw
if (this._Board.IsFull)
{
this._CurrentState = Enums.GameStates.Draw;
return(true);
}
}
return(false);
}
private void Start()
{
_state = Enums.GameStates.Gameplay;
LevelManager.onLevelChanged += SetGameState;
}
private void CardSelectorStateDisable()
{
state = Enums.GameStates.Battle;
}
private void CardSelectorStateEnable()
{
state = Enums.GameStates.CardSelection;
}
/// <summary> Change to Run state. </summary>
public static void Run()
{
prevState = state;
state = Enums.GameStates.Running;
}
/// <summary> Change to Intro state. </summary>
public static void Intro()
{
prevState = state;
state = Enums.GameStates.Intro;
}
/// <summary> Change to Intro state. </summary>
public static void Menu()
{
prevState = state;
state = Enums.GameStates.Menu;
}
private void CardSelectorStateEnable()
{
state = Enums.GameStates.CardSelection;
}
public void ChangeGameState(Enums.GameStates state)
{
onGameStateChange?.Invoke(state);
}
void Awake()
{
if (instance == null)
{
DontDestroyOnLoad(this.gameObject);
instance = this;
state = Enums.GameStates.CardSelection;
prevState = Enums.GameStates.CardSelection;
musicVol = .5f;
sfxVol = .5f;
player1Win = false;
player1Lose = false;
}
else if (this != instance)
{
Destroy(this.gameObject);
}
}
/// <summary> Change to Intro state. </summary>
public static void CutScene()
{
prevState = state;
state = Enums.GameStates.CutScene;
}
public GameStateChangedEventArgs(Enums.GameStates newState) : base()
{
this.NewState = newState;
}
// handles reset button
private void resetButton_Click(object sender, EventArgs e)
{
state = Enums.GameStates.ResetGame;
}
private void SetGameState()
{
State = Enums.GameStates.Gameplay;
}
/// <summary> Change to Intro state. </summary>
public static void CutScene()
{
prevState = state;
state = Enums.GameStates.CutScene;
}
private void CardSelectorStateDisable()
{
state = Enums.GameStates.Battle;
}
/// <summary> Change to Intro state. </summary>
public static void Intro()
{
prevState = state;
state = Enums.GameStates.Intro;
}
/// <summary> Change to Run state. </summary>
public static void Run()
{
prevState = state;
state = Enums.GameStates.Running;
}
public void Render()
{
// NEW GAME
if (State == Enums.GameStates.ResetGame)
{
gui.DrawResetGame();
State = Enums.GameStates.Wait;
}
// RESTART GAME
if (State == Enums.GameStates.RestartGame)
{
gui.Result();
}
// START GAME
if (State == Enums.GameStates.StartGame)
{
gui.DrawStartGame();
// Draw dealer cards on start game, first card faced down
gui.InvokeRenderCard(dealer.CardX, dealer.CardY, dealer.Cardback);
gui.InvokeRenderCard(dealer.CardX + 30, dealer.CardY, dealer.cardList[1].Image);
// Draw player 1 cards
gui.InvokeRenderCard(players[0].CardX, players[0].CardY, players[0].cardList[0].Image);
gui.InvokeRenderCard(players[0].CardX + 30, players[0].CardY, players[0].cardList[1].Image);
// Draw player 2 cards
gui.InvokeRenderCard(players[1].CardX, players[1].CardY, players[1].cardList[0].Image);
gui.InvokeRenderCard(players[1].CardX + 30, players[1].CardY, players[1].cardList[1].Image);
State = Enums.GameStates.Wait;
}
// UPDATE GAME
if (State == Enums.GameStates.UpdateGame)
{
// draw hit cards if any for players
foreach (Participents player in players)
{
if (player.cardList.Count > 2)
{
for (int x = 2; x < player.cardList.Count; x++)
{
gui.InvokeRenderCard(player.CardX + 30 * x, player.CardY, player.cardList[x].Image);
}
}
}
if (players[1].SumCards() > 21)
{
State = Enums.GameStates.EndGame;
}
// wait
State = Enums.GameStates.Wait;
}
// END GAME
if (State == Enums.GameStates.EndGame)
{
// Dealer 1st card is shown
gui.InvokeRenderCard(dealer.CardX, dealer.CardY, dealer.cardList[0].Image);
gui.InvokeRenderCard(dealer.CardX + 30, dealer.CardY, dealer.cardList[1].Image);
// Dealer draws
DealerDraws();
// draw hit cards if any for dealer
if (dealer.cardList.Count > 2)
{
for (int x = 2; x < dealer.cardList.Count; x++)
{
gui.InvokeRenderCard(dealer.CardX + 30 * x, dealer.CardY, dealer.cardList[x].Image);
}
}
// Determine winner
DetermineWinner();
// wait
State = Enums.GameStates.Wait;
}
}
