// TODO: Add action points restrictions.
        public override void Update(GameTime gameTime)
        {
            if (_entity == null)
            {
                foreach (var entity in ActiveEntities)
                {
                    _turn = _turnMapper.Get(entity);

                    if (_turn != null)
                    {
                        initTurn(entity); return;
                    }
                }
            }
            else
            {
                foreach (var entity in ActiveEntities)
                {
                    var turnEnd = _turnEndMapper.Get(entity);
                    if (turnEnd != null)
                    {
                        _turnEndMapper.Delete(entity);
                        toggleTurn();
                        return;
                    }
                }
            }
        }
Beispiel #2
0
 public void AddActor(TurnComponent actor)
 {
     if (!actors.Contains(actor) && !pendingActors.Contains(actor))
     {
         pendingActors.Add(actor);
     }
 }
 private void toUnknownState()
 {
     _l.Info("Back to unknown state");
     _turn.State = Turn.Unknown;
     _turn       = null;
     _entity     = null;
 }
Beispiel #4
0
 public override void Remove(TurnComponent member)
 {
     if (_turnComponents != null && _turnComponents.Contains(member))
     {
         _turnComponents.Remove(member);
     }
 }
        void EndTurn(object sender, EventArgs e)
        {
            TurnComponent t = Match.GetTurn().TurnInfo.TurnComponent;

            if (_Controllers.ContainsKey(t) && _Controllers[t].Finish())
            {
                ExecuteOrderAndAlert(new NextPhaseOrder(Match.GetTurn().TurnInfo));
            }
        }
 public bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     if (UseMovement)
     {
         return(Carrier.Configuration.IsVehicle
                                    ? TurnComponent == TurnComponent.VEHICLE_MOVEMENT
                                                 : TurnComponent == TurnComponent.NON_VEHICLE_MOVEMENT);
     }
     return(TurnComponent == TurnComponent.DEPLOYMENT);
 }
Beispiel #7
0
        public void AddActor(GameObject actor)
        {
            TurnComponent actorsTurn = actor.GetComponent <TurnComponent>();

            if (actorsTurn != null)
            {
                AddActor(actorsTurn);
                SubscribeEvents(actorsTurn);
            }
        }
 public bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     if (TurnComponent == TurnComponent.DEPLOYMENT)
     {
         return(true);
     }
     return(Unit.Configuration.IsVehicle
                                    ? TurnComponent == TurnComponent.VEHICLE_MOVEMENT
                                            : TurnComponent == TurnComponent.NON_VEHICLE_MOVEMENT);
 }
Beispiel #9
0
        private void PreparePlayerForNewLevel()
        {
            mapManager.AddActor(player, mapManager.Map.SpawnPoint);

            TurnComponent playerTurn = player.GetComponent <TurnComponent>();

            if (playerTurn != null)
            {
                turnManager.AddActor(playerTurn);
            }
        }
Beispiel #10
0
        private void GrantTurn(TurnComponent actor)
        {
            token.Target = actor;
            actor.Entity.Events.AddListener(OnActorTurnDone, EntityTurnDoneEvent.EVENT_TYPE);
            actor.GrantTurn(token);

            if (OnTurnStarted != null)
            {
                OnTurnStarted.Invoke(token);
            }
        }
Beispiel #11
0
 public bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     if (Unit.Configuration.IsAircraft())
     {
         return(TurnComponent == TurnComponent.AIRCRAFT);
     }
     if (Combat)
     {
         return(Unit.Configuration.IsVehicle
                                            ? TurnComponent == TurnComponent.VEHICLE_COMBAT_MOVEMENT
                                                    : TurnComponent == TurnComponent.CLOSE_ASSAULT);
     }
     return(Unit.Configuration.IsVehicle
                                    ? TurnComponent == TurnComponent.VEHICLE_MOVEMENT
                                            : TurnComponent == TurnComponent.NON_VEHICLE_MOVEMENT);
 }
Beispiel #12
0
    IEnumerator IterateTeamMembers(IEnumerable <TurnComponent> turnComponent)
    {
        IEnumerator <TurnComponent> enumerator = turnComponent.GetEnumerator();

        while (enumerator.MoveNext())
        {
            yield return(new WaitForSeconds(_delay));

            TurnComponent component = enumerator.Current;
            component.NextTurn();

            yield return(null);
        }

        Debug.Log("---" + GetName() + "'s turn has ended---");
    }
        int WaitMillis(TurnComponent TurnComponent)
        {
            switch (TurnComponent)
            {
            case TurnComponent.WAIT:
            case TurnComponent.RESET:
            case TurnComponent.MINEFIELD_ATTACK: return(0);

            case TurnComponent.ARTILLERY:
            case TurnComponent.ATTACK:
            case TurnComponent.AIRCRAFT:
            case TurnComponent.ANTI_AIRCRAFT: return(1000);

            case TurnComponent.DEPLOYMENT: return(2500);

            default: return(5000);
            }
        }
        public void DoTurn(Turn Turn)
        {
            TurnComponent t = AllowedArmies.Contains(Turn.TurnInfo.Army)
                                                                                   ? Turn.TurnInfo.TurnComponent : TurnComponent.SPECTATE;

            _MatchScreen.SetEnabled(AllowedArmies.Contains(Turn.TurnInfo.Army));
            if (_CurrentTurn.Army != null && _Controllers.ContainsKey(_CurrentTurn.TurnComponent))
            {
                _Controllers[_CurrentTurn.TurnComponent].End();
                Clear();
                UnHighlight();
                SelectUnit(null);
                _MatchScreen.PaneLayer.Clear();
            }
            _CurrentTurn = Turn.TurnInfo;

            if (_Controllers.ContainsKey(t))
            {
                _Controllers[t].Begin();
            }
        }
Beispiel #15
0
        /// <summary>
        /// Cycles through the entities so they can take turns
        /// </summary>
        public void ProcessTurns()
        {
            const int MIN_INITIATIVE = 2000;

            // always start with the player, b/c last turn cycle ended with the player
            player.FireEvent(new ENewTurn());

            var turnQueue = new Utilities.MinHeap <TurnComponent>();

            foreach (Entity e in currentMap.levelEntities)
            {
                if (e == player)
                {
                    continue;
                }

                // check if this turn taker can be added to the queue yet, or if it needs to wait longer
                TurnComponent turnTaker = e.Get <TurnComponent>();
                if (turnTaker != null)
                {
                    turnTaker.initiative += turnTaker.speed;

                    if (turnTaker.initiative >= MIN_INITIATIVE)
                    {
                        turnQueue.Add(turnTaker);
                        turnTaker.initiative = 0;
                    }
                }
            }

            // now actually perform the turn cycle in order of most initiative
            while (turnQueue.Count > 0)
            {
                Entity e = turnQueue.ExtractDominating().owner;
                e.FireEvent(new ENewTurn());
            }
        }
Beispiel #16
0
    private void Awake()
    {
        #region Singleton
        if (Instance == null)
        {
            Instance = this;
        }
        else if (Instance == this)
        {
            Destroy(gameObject);
        }
        DontDestroyOnLoad(gameObject);
        #endregion

        for (int index = 0; index < HeroIDs.Count; index++)
        {
            elementDict.Add(HeroIDs[index], CharPrefabs[index]);
        }

        PlayerList = new List <Hero>();
        AIList     = new List <Hero>();

        gameOverText = gameOverTextGO.GetComponent <TextMeshProUGUI>();
    }
Beispiel #17
0
        public void RemoveActor(TurnComponent actor)
        {
            if (token.Target == actor)
            {
                CurrentTurnDone(actor);
            }

            int actorIndex = actors.IndexOf(actor);

            if
            (
                actorIndex != -1 &&
                actorIndex <= token.Turn &&
                actorIndex < actors.Count - 1
            )
            {
                token.Turn--;
            }

            actors.Remove(actor);
            pendingActors.Remove(actor);

            UnsubscribeEvents(actor);
        }
Beispiel #18
0
 public override bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     return(TurnComponent == TurnComponent.CLOSE_ASSAULT);
 }
Beispiel #19
0
 public TurnInfo(Army Army, TurnComponent TurnComponent)
 {
     this.Army          = Army;
     this.TurnComponent = TurnComponent;
 }
Beispiel #20
0
 public bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     return(TurnComponent == TurnComponent.ARTILLERY);
 }
 public override bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     return(Unit.Configuration.IsVehicle
                                    ? TurnComponent == TurnComponent.VEHICLE_MOVEMENT
                                            : TurnComponent == TurnComponent.NON_VEHICLE_MOVEMENT);
 }
Beispiel #22
0
 public bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     return(this.TurnComponent == TurnComponent);
 }
 public bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     return(Engineer.Configuration.IsVehicle
                                            ? TurnComponent == TurnComponent.VEHICLE_MOVEMENT
                                                    : TurnComponent == TurnComponent.NON_VEHICLE_MOVEMENT);
 }
Beispiel #24
0
    //private void IterateTeamMembers(IEnumerable<TurnComponent> turnComponent)
    //{
    //    IEnumerator<TurnComponent> enumerator = turnComponent.GetEnumerator();
    //    _readyForNext = true;

    //    while(enumerator.MoveNext() )
    //    {
    //        TurnComponent component = enumerator.Current;
    //        component.NextTurn();

    //        _readyForNext = false;
    //        StartCoroutine(TurnDelay());
    //    }
    //}

    public override void Add(TurnComponent member)
    {
        _turnComponents.Add(member);
    }
 public override bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     return(true);
 }
Beispiel #26
0
 public override bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     return(TurnComponent == TurnComponent.DEPLOYMENT);
 }
 public override bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     return(TurnComponent == TurnComponent.AIRCRAFT);
 }
 public override bool MatchesTurnComponent(TurnComponent TurnComponent)
 {
     return(TurnComponent == TurnComponent.ATTACK);
 }
Beispiel #29
0
 public NextPhaseOrder(Army Army, TurnComponent TurnComponent)
 {
     this.Army          = Army;
     this.TurnComponent = TurnComponent;
 }
Beispiel #30
0
 public abstract bool MatchesTurnComponent(TurnComponent TurnComponent);