private void ResolveExecuteEvent(CombatSkillExecuter executer)
{
Skill userSkill = executer.ExecutedSkill;
// Execute effects on all targets.
if (userSkill != null && userSkill.SkillDefinition.Effect != null)
{
CombatEventDispatcher dispatcher = new CombatEventDispatcher(this);
CombatUnit userUnit = executer.Owner;
foreach (CombatUnit target in executer.Targets)
{
CombatEventLog log = new CombatEventLog(userSkill);
log.LogValues.Add("user", userUnit.Unit.Profile.Name);
log.LogValues.Add("target", target.Unit.Profile.Name);
log.LogValues.Add("skillname", userSkill.SkillDefinition.DisplayedName);
userSkill.SkillDefinition.Effect.Apply(dispatcher, userUnit, target, log);
_CombatEventLog.Add(log);
}
// Trigger execute event after skill usage.
CombatEvent executeEvent = new CombatEvent(executer, CombatEventType.Apply, userUnit);
HandleCombatEvent(executeEvent);
}
}
private void ResolveDeclareEvent(CombatSkillExecuter executer)
{
Skill userSkill = executer.ExecutedSkill;
CombatUnit user = executer.Owner;
// Check if the skill can be used (user is alive, skill is not used up, etc.)
if (user == null || user.CombatStatus.SkillUsed)
{
executer.Interrupt();
}
else if (user.Unit == null || user.Unit.IsDead)
{
executer.Interrupt();
}
else if (userSkill == null || userSkill.SkillCurrentUsage == 0)
{
executer.Interrupt();
}
if (!executer.IsInterrupted)
{
executer.GenerateSkillTargets();
// If we don't have valid targets, then this skill will not be triggered.
if (executer.Targets.Count == 0)
{
executer.Interrupt();
}
}
if (!executer.IsInterrupted)
{
// The skill is now triggered. Decrement skill usage times right now.
// If another reaction skill cancels this skill, the skill will still be consumed.
--userSkill.SkillCurrentUsage;
user.CombatStatus.SkillUsed = true;
// Check if any reactions are triggered.
// Reactions may modify declareEvent, causing the attempt to use this skill to fail.
// If this happens, the IsValid field on the event shall also be set to false.
// React to declare event first.
CombatEvent declareEvent = new CombatEvent(executer, CombatEventType.Declare, user);
HandleCombatEvent(declareEvent);
// Then react to targeting event for each target, if the skill execution is still valid.
if (!executer.IsInterrupted)
{
foreach (CombatUnit targetUnit in executer.Targets)
{
CombatEvent targetingEvent = new CombatEvent(executer, CombatEventType.Target, targetUnit);
HandleCombatEvent(targetingEvent);
}
}
}
}
private void ResolveSkill(CombatUnit skillOwner)
{
CombatSkillExecuter executer = new CombatSkillExecuter(this, skillOwner);
ResolveDeclareEvent(executer);
// If the combat event is still valid, execute the event.
if (!executer.IsInterrupted)
{
ResolveExecuteEvent(executer);
}
}
public CombatEvent(CombatSkillExecuter triggeringSkillExecutor, CombatEventType eventType, CombatUnit eventTarget)
{
CombatResolver resolver = triggeringSkillExecutor.Resolver;
Executer = triggeringSkillExecutor;
Skill = triggeringSkillExecutor.ExecutedSkill;
User = triggeringSkillExecutor.Owner;
Party = User.CombatParty;
Phase = Skill.SkillDefinition.PerformedPhase;
Event = eventType;
Target = eventTarget;
}
