private void ProcessState()
        {
            switch (currentState)
            {
            case GameRoundState.STARTING:
                timeRemaining = waitTime;
                currentState  = GameRoundState.WAITING;
                break;

            case GameRoundState.WAITING:
                timeRemaining = roundLength;

                currentRound++;
                OnRoundChange?.Invoke(currentRound);

                currentState = GameRoundState.RUNNING;
                OnRoundStart?.Invoke(currentRound);
                break;

            case GameRoundState.RUNNING:
                timeRemaining = waitTime;

                currentState = GameRoundState.WAITING;
                OnRoundFinished?.Invoke(currentRound);
                break;
            }
        }
    public void StartRound()
    {
        _startTime      = Time.time;
        _currentTime    = 0;
        _tickCount      = 0;
        _inputTickCount = 0;

        OnRoundStart?.Invoke();
    }
Example #3
0
 public void StartRound()
 {
     foreach (var rock in FindObjectsOfType <Rock>())
     {
         Destroy(rock.gameObject);
     }
     box.transform.DOMove(CurrentRound.boxLocation.position, 1);
     print("invoking OnRoundStart");
     OnRoundStart?.Invoke();
 }
Example #4
0
        private IEnumerator RingCountDown(RoundData[] roundDatas)
        {
            // Initial Settings
            CurrentRingCenter     = initialRingCenter;
            CurrentRingRadius     = initialRingRadius;
            CurrentRingTickDamage = initialTickDamage;
            UpdateRingObject();

            currentRingSpriteRenderer.enabled = true;
            closedRingSpriteRenderer.enabled  = true;

            // Each Round
            for (int i = 0; i < roundDatas.Length; i++)
            {
                OnRoundStart?.Invoke(this, roundDatas[i]);

                closedRingSpriteRenderer.transform.position   = new Vector3(roundDatas[i].Center.x, altitude, roundDatas[i].Center.y);
                closedRingSpriteRenderer.transform.localScale = Vector3.one * roundDatas[i].DiameterAfterClosing;

                // Ring Countdown
                float startTime = Time.time;
                float endTime   = startTime + roundDatas[i].WaitPeriod;
                while (Time.time <= endTime)
                {
                    float progress = (Time.time - startTime) / roundDatas[i].WaitPeriod;

                    yield return(new WaitForSeconds(1f));
                }

                // Ring Closing
                OnRingCloseStart?.Invoke(this, roundDatas[i]);
                CurrentRingTickDamage = roundDatas[i].TickDamage;

                Vector2 startCenter = CurrentRingCenter;
                float   startRadius = CurrentRingRadius;
                startTime = Time.time;
                endTime   = startTime + roundDatas[i].TimeToClose;
                while (Time.time <= endTime)
                {
                    float progress = (Time.time - startTime) / roundDatas[i].TimeToClose;
                    CurrentRingCenter = Vector2.Lerp(startCenter, roundDatas[i].Center, progress);
                    CurrentRingRadius = Mathf.Lerp(startRadius, roundDatas[i].DiameterAfterClosing / 2f, progress);

                    UpdateRingObject();

                    yield return(null);
                    //yield return new WaitForSeconds(0.02f);
                }

                // After Closing
                // Do something
            }
        }
Example #5
0
    /// <summary>
    /// Proceeds to the next thing in the turn order if
    /// there is one.
    /// </summary>
    private void Next()
    {
        turnEndRequested  = false;
        turnEndInProgress = true;

        // Notify that the current actor's turn is ending
        if (turnOrder.Current != null)
        {
            turnOrder.Current.OnTurnEnd();
            OnTurnEnd?.Invoke(turnOrder.Current);
        }

        // If the round hasn't started notify that a new one
        // is starting
        if (!roundStarted)
        {
            RoundCount++;
            OnRoundStart?.Invoke();
            roundStarted = true;
        }

        // Go to next thing in the turn order
        bool anyMore = turnOrder.MoveNext();

        // If there's nothing left in the order then the round has ended
        if (!anyMore)
        {
            roundStarted = false;
            turnOrder.Reset();
            OnRoundEnd?.Invoke();
        }

        // Otherwise, let the new thing know its turn is
        // starting
        else
        {
            // Notify the turn based thing FIRST - then other listeners.
            turnOrder.Current.OnTurnStart();
            OnTurnStart?.Invoke(turnOrder.Current);
        }

        turnEndInProgress = false;

        if (turnEndRequested)
        {
            Next();
        }
    }
Example #6
0
        private void RoundStart()
        {
            RoundCount++;
            GamePlayer player = (CurrentGamePlayerID == 1) ? GamePlayer1 : GamePlayer2;

            player.ManaCrystal++;
            player.RemainedManaCrystal        = player.ManaCrystal;
            player.Hero.AttackCountInThisTurn = 0;
            Field field = (CurrentGamePlayerID == 1) ? Field1 : Field2;

            foreach (var card in field.Cards(GameCardManager))
            {
                (card as ServantCardRecord).AttackCountInThisTurn = 0;
                (card as ServantCardRecord).IsDisplayInThisTurn   = false;
            }
            OnRoundStart?.Invoke(this);
            player.Draw(1);
        }
Example #7
0
    private IEnumerator GameRoundRoutine()
    {
        gameStateText.text = $"Start Round {_roundCounter}";
        yield return(new WaitForSeconds(0.3f));

        gameStateText.text    = "";
        gameStateText.enabled = false;
        blocker.enabled       = false;
        _timeCounter          = roundDuration;
        _gameStartStamp       = Time.time;
        OnRoundStart?.Invoke(_roundCounter);
        for (_timeCounter = roundDuration; _timeCounter >= 0; --_timeCounter)
        {
            timeText.text = _timeCounter.ToString();
            yield return(_waitForTimerTick);
        }
        OnRoundEnd?.Invoke(_roundCounter);
    }
    public static void Restart()
    {
        Eitrum.Engine.Core.Timer.Stop(endGameRestartRoutine);
        Parent.DestroyAllChildren();
        roundTimer = GameSettings.RoundDuration;
        SpawnPlayers();
        OnRestart?.Invoke();
        int counter = 3;

        Eitrum.Engine.Core.Timer.Repeat(1f, counter, () => {
            counter -= 1;
            OnCountDown.Invoke(counter);
            if (counter == 0)
            {
                OnRoundStart?.Invoke();
                for (int iPlayer = 0, nPlayer = players.Count; iPlayer < nPlayer; ++iPlayer)
                {
                    players[iPlayer].canMove        = true;
                    players[iPlayer].rb.isKinematic = false;
                }
            }
        });
    }
Example #9
0
 private void StartRound()
 {
     _currentRound++;
     Spawner.StartRound(_currentRound);
     OnRoundStart?.Invoke();
 }
Example #10
0
 internal void RoundStartEvent()
 {
     OnRoundStart?.Invoke(game);
 }
Example #11
0
        public static void InvokeRoundStart()
        {
            OnRoundStart roundStartEvent = RoundStartEvent;

            roundStartEvent?.Invoke();
        }
Example #12
0
 internal void RoundBegin(RoundLogic logic)
 {
     OnRoundStart?.Invoke(this, new RoundEventArgs(logic));
 }