private List <IBattleActionListener> getListeners(BattleAction action, BattleActionContext battleActionContext, MoveContext moveContext)
{
List <IBattleActionListener> listeners = new List <IBattleActionListener>();
//TODO fix watcher to be more flexible
List <IBattleActionListener> relevantList = null;
if (action is DamageBattleAction)
{
relevantList = damageListeners;
}
if (action is StatusBattleAction)
{
relevantList = statusListeners;
}
if (relevantList != null)
{
foreach (IBattleActionListener listener in relevantList)
{
if (listener.isListeningFor(action))
{
listeners.Add(listener);
}
}
}
return(listeners);
}
public List <BattleActionContext> buildActionsToResolve(BattleActionContext battleActionContext, MoveContext moveContext)
{
//TODO flesh out action watcher
List <BattleActionContext> actions = new List <BattleActionContext>();
actions.Add(battleActionContext);
return(actions);
}
public override bool canExecute(BattleActionContext battleActionContext)
{
bool canExecute = true;
foreach (BattleAction ba in battleActions)
{
canExecute = canExecute && ba.canExecute(battleActionContext);
}
return(canExecute);
}
public BattleActionResult resolveAction(BattleActionContext battleActionContext, MoveContext moveContext)
{
BattleActionContext alteredAction = watcher.getAlteredBattleAction(battleActionContext, moveContext);
BattleActionResult result = BattleActionResult.NO_CHANGES;
if (alteredAction.canExecute())
{
result = battleActionContext.execute();
}
return(result);
}
public BattleActionResult resolveAction(BattleActionContext battleActionContext)
{
BattleActionContext alteredAction = watcher.getAlteredBattleAction(battleActionContext);
BattleActionResult result = null;
if (alteredAction.canExecute())
{
result = battleActionContext.execute();
}
uiManager.updateAllUI();
return(result);
}
public BattleAction.State GetBattleActionState(BattleAction battleAction)
{
if (this.pendingAction.Any((BattleActionContext context) => context.BattleAction == battleAction))
{
return(BattleAction.State.Selected);
}
Diagnostics.Assert(this.activeBattleActions != null);
BattleActionContext battleActionContext = this.activeBattleActions.Find((BattleActionContext context) => context.BattleAction == battleAction);
if (battleActionContext != null)
{
return(battleActionContext.State);
}
return(BattleAction.State.Available);
}
public ActivePeriod[] GetTargetActivePeriods(BattleSimulationTarget target)
{
List <ActivePeriod> list = new List <ActivePeriod>();
Diagnostics.Assert(this.activeBattleActions != null);
for (int i = 0; i < this.activeBattleActions.Count; i++)
{
BattleActionContext battleActionContext = this.activeBattleActions[i];
Diagnostics.Assert(battleActionContext != null && battleActionContext.Targets != null);
if (battleActionContext.Targets.Contains(target))
{
Diagnostics.Assert(battleActionContext.ActivePeriods != null);
list.AddRange(battleActionContext.ActivePeriods);
}
}
return(list.ToArray());
}
private void ExecuteBattleAction(BattleActionContext battleActionContext, bool immediate)
{
if (battleActionContext == null)
{
throw new ArgumentNullException("battleActionContext");
}
if (immediate)
{
Diagnostics.Assert(this.activeBattleActions != null);
this.activeBattleActions.Add(battleActionContext);
battleActionContext.OnRoundStart(this);
}
else
{
Diagnostics.Assert(this.pendingAction != null);
this.pendingAction.Enqueue(battleActionContext);
}
}
public void OnRoundStart()
{
Diagnostics.Assert(this.activeBattleActions != null);
Diagnostics.Assert(this.battleEffectsContexts != null);
foreach (BattleEffectController battleEffectController in this.battleEffectsContexts.Values)
{
Diagnostics.Assert(battleEffectController != null);
battleEffectController.OnRoundStart(this);
}
for (int i = 0; i < this.activeBattleActions.Count; i++)
{
Diagnostics.Assert(this.activeBattleActions[i] != null);
this.activeBattleActions[i].OnRoundStart(this);
}
Diagnostics.Assert(this.pendingAction != null);
while (this.pendingAction.Count > 0)
{
BattleActionContext battleActionContext = this.pendingAction.Dequeue();
this.ExecuteBattleAction(battleActionContext, true);
}
}
private bool ExecuteBattleAction(float battleActionContextRandomNumber, BattleAction battleAction, BattleEffects battleEffects, BattleSimulationUnit initiator, BattleSimulationUnit activator, BattleSimulationTarget[] currentTargets, bool immediate)
{
if (battleAction == null)
{
throw new ArgumentNullException("battleAction");
}
if (battleEffects == null)
{
throw new ArgumentNullException("battleEffects");
}
if (!battleAction.CanBeAppliedByDeadUnit && activator.GetPropertyValue(SimulationProperties.Health) <= 0f)
{
return(false);
}
Diagnostics.Assert(this.Simulation != null && this.Simulation.BattleSimulationRandom != null);
double num = this.Simulation.BattleSimulationRandom.NextDouble();
double num2 = (double)battleEffects.GetProbability(initiator);
if (num >= num2)
{
return(false);
}
BattleSimulationTarget[] array = this.Simulation.FilterTargets(battleEffects.TargetsFilter, initiator, currentTargets);
BattleEffectsArea battleEffectsArea = battleEffects as BattleEffectsArea;
if (battleEffectsArea == null)
{
BattleActionContext battleActionContext = new BattleActionContext(this, battleAction, battleEffects, initiator, activator, array, battleActionContextRandomNumber);
this.ExecuteBattleAction(battleActionContext, immediate);
}
else
{
this.ExecuteAOEBattleAction(battleActionContextRandomNumber, battleAction, battleEffectsArea, initiator, activator, array, immediate);
}
return(true);
}
public BattleActionContext getAlteredBattleAction(BattleActionContext battleActionContext)
{
return(battleActionContext);
}
public void ExecuteBattleEffect(BattleSimulationUnit initiator, BattleSimulationUnit activator, BattleSimulationTarget target, BattleEffect battleEffect, BattleActionContext actionContext)
{
Diagnostics.Assert(this.battleEffectsContexts != null, "this.battleEffectsContexts != null");
BattleEffectController battleEffectController;
if (this.battleEffectsContexts.ContainsKey(target))
{
battleEffectController = this.battleEffectsContexts[target];
}
else
{
battleEffectController = new BattleEffectController(target, this.Simulation);
this.battleEffectsContexts.Add(target, battleEffectController);
}
Diagnostics.Assert(battleEffectController != null);
battleEffectController.Execute(battleEffect, initiator, activator, this, actionContext);
}
public virtual bool canExecute(BattleActionContext actionContext)
{
return(actionContext.source != null && !actionContext.source.isKnockedOut());
}
