void FlagLevelLoad()
{
if (Time.time > this.startTime + player.winTime)
{
PlayerWon.Invoke();
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.TryGetComponent(out Player player))
{
PlayerWon?.Invoke(_timer.Minute, (int)_timer.Second);
_statsData.CountingWins();
_statsData.СomparePlayingTime(_timer.Minute, (int)_timer.Second);
}
}
//TODO: in RPSNController, update game state
void Start()
{
gamesToChooseFrom = settings.GetShuffledMinigames().ToList();
// If we overestimated the number of games to choose from
if (numberOfMinigamesToChooseFrom > gamesToChooseFrom.Count)
{
numberOfMinigamesToChooseFrom = gamesToChooseFrom.Count;
//TODO: won't need this if dynamic thumbnail display, get all minigame options, spawn thumbnail screens based on how many choices we can select
// Reset minigame thumbnail array
if (populatableObjects.Count > numberOfMinigamesToChooseFrom)
{
for (int i = numberOfMinigamesToChooseFrom; i < populatableObjects.Count; i++)
{
populatableObjects[i].SetActive(false);
}
populatableObjects.RemoveRange(numberOfMinigamesToChooseFrom, populatableObjects.Count - numberOfMinigamesToChooseFrom);
}
// minigameSelectionLocation.transform.localPosition = new Vector3(0, minigameSelectionLocation.transform.localPosition.y, minigameSelectionLocation.transform.localPosition.z);
}
//gamesToChooseFrom = GameState.Instance.SelectedMinigames;
//TODO: change UI anchors on screen
switch (GameState.Instance.LastMetagameFinishState)
{
case LastMetagameFinish.P1WIN:
currentWinner = PlayerWon.P1;
playerSelecting.text = "P1";
break;
case LastMetagameFinish.P2WIN:
currentWinner = PlayerWon.P2;
playerSelecting.text = "P2";
break;
default: // TIE or NONE, pick random player to select
switch (Random.Range(0, 1))
{
case 0:
currentWinner = PlayerWon.P1;
playerSelecting.text = "P1";
break;
case 1:
currentWinner = PlayerWon.P2;
playerSelecting.text = "P2";
break;
}
break;
}
PopulateUI();
StartCoroutine(ChooseMinigame());
}
protected override void EndGame(Player winner = null)
{
base.EndGame(winner);
if (winner == null)
{
MatchDrawn?.Invoke();
}
else
{
PlayerWon?.Invoke(winner);
}
}
void SubscribeToGameSceneEvents()
{
// Make sure the game over and player won events don't have any
// listeners before adding any
GameOver.RemoveAllListeners();
PlayerWon.RemoveAllListeners();
GameOver.AddListener(resetGameState);
PlayerWon.AddListener(victorySequence);
player.statusEvents.Died.AddListener(deathSequence);
}
internal static GameState CalculateScore(GameState state, PlayerWon playerWon)
{
if (playerWon == PlayerWon.A)
{
return(state.IncreaseA());
}
else
{
return(state.IncreaseB());
}
}
private void AddToEtherealKillCount(String element)
{
etherealKillCount++;
if (etherealKillCount == 4)
{
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
animator.SetBool("isAttacking", false);
animator.SetBool("isDying", false);
animator.SetBool("isRunning", false);
animator.SetBool("isIdle", true);
PlayerWon?.Invoke();
enabled = false;
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("GameId: " + Id.ToString());
sb.AppendLine("Channel: " + ChannelName);
sb.AppendLine("Player count: " + PlayerCount);
sb.AppendLine("Start time: " + StartTime.ToShortTimeString());
sb.AppendLine("End time: " + EndTime.ToShortTimeString());
sb.AppendLine("Status: " + GameStatus);
sb.AppendLine("Kon time: " + KonTime);
sb.AppendLine("Fuse time: " + FuseTime);
sb.AppendLine("Holder: " + Holder?.ToString());
sb.AppendLine("Player won: " + PlayerWon?.ToString());
return(sb.ToString());
}
void VictorySequence()
{
// Play music, fade into a victory screen, and then give the player the
// option to either exit the game or start a new one.
Debug.Log("You win!");
PlayerWon.RemoveListener(victorySequence);
//resultText.text = "You win! You are now promoted to Admiral!";
// Fade out of the current song into the next one
musicFader.FadeIntoClip(victoryMusic, 1, 0.5f, 0.5f);
screenFader.Fade(1, fadeOutDuration);
// Make sure the victory scene is loaded when the fade out is done.
//UnityAction undisplayResultText = () => resultText.text = "";
//screenFader.FadeEnd.AddListener(undisplayResultText);
screenFader.FadeEnd.AddListener(LoadVictoryScene);
//screenFader.FadeEnd.AddListener(ResetGameState);
}
public void InvokePlayerWon()
{
if (!playerWonInvoked)
{
Debug.Log("PLayerWon has been invoked");
PlayerWon?.Invoke();
if (PlayerWon == null)
{
Debug.Log("PlayerWon is null");
}
playerWonInvoked = true;
}
if (!gameOverInkvoked)
{
InvokeGameOver();
}
}
private void Update()
{
if (canStartLevel && Input.GetKeyDown(KeyCode.G))
{
canStartLevel = false;
StopAllCoroutines();
StartCoroutine(PlayLevel());
}
if (isResetRequired && UIManager.Instance.IsReadyToReceiveUpdates)
{
isResetRequired = false;
ResetLevel();
}
if (isLevelOngoing && haveAllWavesSpawned && IsWaveFinished())
{
isLevelOngoing = false;
PlayerWon?.Invoke();
}
}
/// <summary>
/// Start is called before the first frame update
/// </summary>
void Start()
{
// Start level timer
levelTime = ConfigurationUtils.InitialLevelTimer;
levelTimer = gameObject.AddComponent <Timer>();
levelTimer.Duration = ConfigurationUtils.InitialLevelTimer + 1;
levelTimer.AddTimerFinishedListener(HandleLevelTimerFinished);
levelTimer.Run();
// Set level
level = 1;
// Initialize text
timeLeftText = GameObject.FindGameObjectWithTag("TimeLeftText").GetComponent <Text>();
levelText = GameObject.FindGameObjectWithTag("LevelText").GetComponent <Text>();
timeLeftText.text = timeLeftPrefix + levelTime;
levelText.text = levelPrefix + level;
// Initialize events and add class as invoker
levelUp = new LevelUp();
playerWon = new PlayerWon();
EventManager.AddLevelUpInvoker(this);
EventManager.AddPlayerWonInvoker(this);
}
public void Redeal()
{
for (int i = 0; i < currentPlayer.RedealFlags.Length; i++)
{
if (currentPlayer.RedealFlags[i])
{
currentDeck.DiscardCard(currentPlayer.Hand[i]);
currentPlayer.Hand[i] = currentDeck.GetTopCard();
}
currentPlayer.RedealFlags[i] = false;
}
CardsRedealt?.Invoke(currentPlayer.Hand);
if (Rules.TestHand(currentPlayer.Hand, currentBet, out string winningHandName, out int reward))
{
currentPlayer.Credits += reward;
PlayerWon?.Invoke(winningHandName, reward, currentPlayer);
}
currentBet = Mathf.Min(kDefaultBet, currentPlayer.Credits);
BetChanged?.Invoke(currentBet);
}
public static void UnsubscribeAllSubscriber()
{
if (NextPhase != null)
{
System.Delegate[] delegates = NextPhase.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
NextPhase -= delegates [i] as NextPhaseEvent;
}
}
if (AllowCurrentPlayerToMove != null)
{
System.Delegate[] delegates = AllowCurrentPlayerToMove.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
AllowCurrentPlayerToMove -= delegates [i] as AllowCurrentPlayerToMoveEvent;
}
}
if (DisallowCurrentPlayerToMove != null)
{
System.Delegate[] delegates = DisallowCurrentPlayerToMove.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
DisallowCurrentPlayerToMove -= delegates [i] as DisallowCurrentPlayerToMoveEvent;
}
}
if (AllowCurrentPlayerToFire != null)
{
System.Delegate[] delegates = AllowCurrentPlayerToFire.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
AllowCurrentPlayerToFire -= delegates [i] as AllowCurrentPlayerToFireEvent;
}
}
if (DisallowCurrentPlayerToFire != null)
{
System.Delegate[] delegates = DisallowCurrentPlayerToFire.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
DisallowCurrentPlayerToFire -= delegates [i] as DisallowCurrentPlayerToFireEvent;
}
}
if (NextPlayer != null)
{
System.Delegate[] delegates = NextPlayer.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
NextPlayer -= delegates [i] as NextPlayerEvent;
}
}
if (PlayerDead != null)
{
System.Delegate[] delegates = PlayerDead.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
PlayerDead -= delegates [i] as PlayerDeadEvent;
}
}
if (PlayerWon != null)
{
System.Delegate[] delegates = PlayerWon.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
PlayerWon -= delegates [i] as PlayerWonEvent;
}
}
if (TimerEnd != null)
{
System.Delegate[] delegates = TimerEnd.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
TimerEnd -= delegates [i] as TimerEndEvent;
}
}
if (PlayerCast != null)
{
System.Delegate[] delegates = PlayerCast.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
PlayerCast -= delegates [i] as PlayerCastEvent;
}
}
if (SpellEnd != null)
{
System.Delegate[] delegates = SpellEnd.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
SpellEnd -= delegates [i] as SpellEndEvent;
}
}
if (NextPlayerButtonClick != null)
{
System.Delegate[] delegates = NextPlayerButtonClick.GetInvocationList();
for (int i = 0; i < delegates.Length; i++)
{
NextPlayerButtonClick -= delegates [i] as NextPlayerButtonClickEvent;
}
}
}
public void CallAWinner(Player player)
{
PlayerWon?.Invoke(player, EventArgs.Empty);
}
public void NewState_Is_Correct_After_Game(GameState currentState, PlayerWon playerWon, GameState expectedNewState)
{
var newState = Scorer.CalculateScore(currentState, playerWon);
Assert.Equal(expectedNewState, newState);
}
private void Minesweeper_MouseClick(object sender, MouseEventArgs e)
{
if (!GameOver)
{
int x = e.X; int y = e.Y;
bool FitsByX = (x <= Starting.X + this.Size && x >= Starting.X);
bool FitsByY = (y <= Starting.Y + this.Size && y >= Starting.Y);
if (FitsByX && FitsByY)
{
bool isLeft = e.Button.Equals(MouseButtons.Left);
bool isRight = e.Button.Equals(MouseButtons.Right);
bool isMiddle = e.Button.Equals(MouseButtons.Middle);
int CellSize = this.Size / this.Settings.Width;
int i = (x - Starting.X) / CellSize;
int j = (y - Starting.Y) / CellSize;
if (isMiddle)
{
if (board[i, j].State.Equals(Enums.CellState.Uncovered))
{
List <Cell> cells = board[i, j].Neighbours;
List <Cell> mines = board[i, j].Neighbours.Where(x => x.IsMine == true).ToList();
List <Cell> nonMine = board[i, j].Neighbours.Where(x => x.IsMine == false).ToList();
bool AllMarked = true;
foreach (Cell mine in mines)
{
if (!mine.State.Equals(Enums.CellState.Flag))
{
AllMarked = false;
break;
}
}
if (AllMarked)
{
foreach (Cell cell in nonMine)
{
cell.Uncover(g);
}
}
}
}
else
{
if (isLeft)
{
if (!board[i, j].State.Equals(Enums.CellState.Flag))
{
if (board[i, j].IsMine)
{
GameOver = true;
for (int n = 0; n < this.Settings.Width; n++)
{
for (int m = 0; m < this.Settings.Height; m++)
{
if (board[n, m].IsMine)
{
board[n, m].State = Enums.CellState.Mine;
board[n, m].Draw(g);
}
}
}
PlayerLost?.Invoke(this, EventArgs.Empty);
return;
}
else
{
board[i, j].Uncover(g);
}
}
}
else
{
if (isRight)
{
board[i, j].TryPlaceFlag(g);
}
}
}
}
int CoveredCount = 0;
for (int i = 0; i < this.Settings.Width; i++)
{
for (int j = 0; j < this.Settings.Height; j++)
{
if (!board[i, j].IsMine && board[i, j].State.Equals(Enums.CellState.Covered))
{
CoveredCount++;
}
}
}
if (CoveredCount == 0)
{
PlayerWon?.Invoke(this, EventArgs.Empty);
GameOver = true;
return;
}
}
}
