// 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;
}
}
}
}
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;
}
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);
}
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);
}
private void PreparePlayerForNewLevel()
{
mapManager.AddActor(player, mapManager.Map.SpawnPoint);
TurnComponent playerTurn = player.GetComponent <TurnComponent>();
if (playerTurn != null)
{
turnManager.AddActor(playerTurn);
}
}
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);
}
}
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);
}
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();
}
}
/// <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());
}
}
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>();
}
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);
}
public override bool MatchesTurnComponent(TurnComponent TurnComponent)
{
return(TurnComponent == TurnComponent.CLOSE_ASSAULT);
}
public TurnInfo(Army Army, TurnComponent TurnComponent)
{
this.Army = Army;
this.TurnComponent = TurnComponent;
}
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);
}
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);
}
//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);
}
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);
}
public NextPhaseOrder(Army Army, TurnComponent TurnComponent)
{
this.Army = Army;
this.TurnComponent = TurnComponent;
}
public abstract bool MatchesTurnComponent(TurnComponent TurnComponent);
