private ExecuteableAction RecalculateTargets(ExecuteableAction executableAction)
{
List <Character> newTargets = new List <Character>();
foreach (var target in executableAction.Targets)
{
if (target.IsAlive)
{
newTargets.Add(target);
}
else
{
switch (executableAction.ActionToApply.TargetType)
{
case TargetType.EnemySingle:
newTargets.Add(CharacterManager.Instance.GetRandomAliveEnemy());
break;
case TargetType.PlayersSingle:
newTargets.Add(CharacterManager.Instance.GetRandomAlivePlayer());
break;
}
}
}
if (newTargets.Count == 0)
{
StopAllCoroutines();
PhaseManager.Instance.EndGame();
}
executableAction.Targets = newTargets;
return(executableAction);
}
private IEnumerator HandleSubmittedAction(SubmittedAction submittedAction, float actionTime)
{
int actionSegements = submittedAction.ExecuteableActions.Count;
float segmentTime = actionTime / actionSegements;
foreach (var executableAction in submittedAction.ExecuteableActions)
{
ExecuteableAction recalculatedAction = RecalculateTargets(executableAction);
ExecuteAction(recalculatedAction);
yield return(new WaitForSeconds(segmentTime));
}
}
private SubmittedAction CreateSubmittedActionForEnemy(EnemyAction enemyAction, Character enemyCharacter)
{
List <ExecuteableAction> executeableActions = new List <ExecuteableAction>();
foreach (var tAction in enemyAction.TargetedActions)
{
ExecuteableAction executeableAction = new ExecuteableAction(enemyCharacter, tAction);
var potentialTargets = FindPotentialActionTargets(tAction, enemyCharacter);
var finalTargets = SelectFinalTargets(tAction, potentialTargets, enemyCharacter);
executeableAction.Targets = finalTargets;
executeableActions.Add(executeableAction);
}
return(new SubmittedAction(enemyCharacter, executeableActions));
}
private void ExecuteAction(ExecuteableAction executeableAction)
{
int targetNumber = executeableAction.Targets.Count;
bool usedAttack = false;
foreach (var target in executeableAction.Targets)
{
foreach (var actionComponent in executeableAction.ActionToApply.ActionComponents)
{
if (actionComponent is DamageComponent)
{
usedAttack = true;
}
actionComponent.ExecuteAction(target, executeableAction.Targeter, 1.0f / targetNumber);
}
}
if (usedAttack)
{
executeableAction.Targeter.ResetAttackBuffModifier();
}
}
private void LockInAction()
{
if (_currentTargetedActionIndex < _actionsToTarget.Count)
{
ExecuteableAction actionToLock = new ExecuteableAction(_attatchedPlayer, CurrentTargetedAction);
switch (_currentTargetSelectionMode)
{
case TargetSelectionMode.Choice:
actionToLock.Targets.Add(_potentialTargets[_currentSingleTargetIndex]);
break;
case TargetSelectionMode.NoChoice:
actionToLock.Targets = _potentialTargets.ToList();
break;
}
_confirmedActions.Add(actionToLock);
//Process next targeted action or end.
++_currentTargetedActionIndex;
ProcessTargetedAction();
}
}
public void EndPlayersTurns()
{
RemovePlayerShields();
List <Character> alivePlayers = CharacterManager.Instance.GetAlivePlayers();
foreach (var player in alivePlayers)
{
if (_submittedPlayerActions.FirstOrDefault(x => x.TargetingCharacter == player) == null)
{
ExecuteableAction executeableAction = new ExecuteableAction(player, _defaultAction.TargetedActions[0]);
executeableAction.Targets.Add(CharacterManager.Instance.GetRandomAliveEnemy());
List <ExecuteableAction> defaultActions = new List <ExecuteableAction> {
executeableAction
};
SubmittedAction submittedAction = new SubmittedAction(player, defaultActions);
_submittedPlayerActions.Add(submittedAction);
}
}
_actionSequence = StartCoroutine(ProcessSubmittedTurns(_submittedPlayerActions, false));
}
