public IEnumerator <YieldInstruction> ProcessHitLoc(Loc loc)
{
BattleContext actionContext = new BattleContext(this, false);
Character charTarget = ZoneManager.Instance.CurrentMap.GetCharAtLoc(loc);
actionContext.TargetTile = loc;
if (charTarget != null && DungeonScene.Instance.IsTargeted(actionContext.User, charTarget, actionContext.Explosion.TargetAlignments))
{
actionContext.Target = charTarget;
yield return(CoroutineManager.Instance.StartCoroutine(DungeonScene.Instance.HitTarget(actionContext, charTarget)));//hit the character
}
//do thing to tile
yield return(CoroutineManager.Instance.StartCoroutine(actionContext.User.HitTile(actionContext)));
}
public IEnumerator <YieldInstruction> InitActionData(BattleContext context)
{
EventEnqueueFunction <BattleEvent> function = (StablePriorityQueue <GameEventPriority, Tuple <GameEventOwner, Character, BattleEvent> > queue, Priority maxPriority, ref Priority nextPriority) =>
{
DataManager.Instance.UniversalEvent.AddEventsToQueue(queue, maxPriority, ref nextPriority, DataManager.Instance.UniversalEvent.InitActionData);
};
foreach (Tuple <GameEventOwner, Character, BattleEvent> effect in IterateEvents(function))
{
yield return(CoroutineManager.Instance.StartCoroutine(effect.Item3.Apply(effect.Item1, effect.Item2, context)));
if (context.CancelState.Cancel)
{
yield break;
}
}
}
public IEnumerator <YieldInstruction> ExecuteAction(BattleContext baseContext)
{
BattleContext context = new BattleContext(baseContext, true);
yield return(CoroutineManager.Instance.StartCoroutine(context.User.OnAction(context)));
if (context.CancelState.Cancel)
{
yield break;
}
yield return(CoroutineManager.Instance.StartCoroutine(PerformAction(context)));
if (context.CancelState.Cancel)
{
yield break;
}
yield return(CoroutineManager.Instance.StartCoroutine(context.User.AfterActionTaken(context)));
}
public IEnumerator <YieldInstruction> PreProcessAction(BattleContext context)
{
context.StrikeStartTile = context.User.CharLoc;
context.StrikeEndTile = context.User.CharLoc;
List <Dir8> trialDirs = new List <Dir8>();
trialDirs.Add(context.User.CharDir);
if (context.UsageSlot != BattleContext.FORCED_SLOT && context.User.MovesScrambled)
{
trialDirs.Add(DirExt.AddAngles(context.User.CharDir, Dir8.DownRight));
trialDirs.Add(DirExt.AddAngles(context.User.CharDir, Dir8.DownLeft));
}
ProcessDir(trialDirs[DataManager.Instance.Save.Rand.Next(trialDirs.Count)], context.User);
yield break;
}
public IEnumerator <YieldInstruction> ProcessUseItem(Character character, int invSlot, int teamSlot, ActionResult result)
{
if (character.AttackOnly)
{
LogMsg(Text.FormatKey("MSG_CANT_USE_ITEM", character.Name), false, true);
yield break;
}
Character target = teamSlot == -1 ? character : character.MemberTeam.Players[teamSlot];
if (target.AttackOnly)
{
LogMsg(Text.FormatKey("MSG_CANT_USE_ITEM", target.Name), false, true);
yield break;
}
BattleContext context = new BattleContext(BattleActionType.Item);
context.User = target;
context.UsageSlot = invSlot;
yield return(CoroutineManager.Instance.StartCoroutine(InitActionData(context)));
yield return(CoroutineManager.Instance.StartCoroutine(context.User.BeforeTryAction(context)));
if (context.CancelState.Cancel)
{
yield return(CoroutineManager.Instance.StartCoroutine(CancelWait(context.User.CharLoc))); yield break;
}
context.TurnCancel.Cancel = false;
//move has been made; end-turn must be done from this point onwards
yield return(CoroutineManager.Instance.StartCoroutine(CheckExecuteAction(context, PreExecuteItem)));
if (!context.CancelState.Cancel)
{
yield return(new WaitForFrames(GameManager.Instance.ModifyBattleSpeed(20, context.User.CharLoc)));
}
yield return(CoroutineManager.Instance.StartCoroutine(FinishTurn(context.User, !context.TurnCancel.Cancel)));
result.Success = context.TurnCancel.Cancel ? ActionResult.ResultType.Success : ActionResult.ResultType.TurnTaken;
}
public IEnumerator <YieldInstruction> RepeatActions(BattleContext context)
{
//increment for multistrike
context.StrikesMade++;
while (context.StrikesMade < context.Strikes && !context.User.Dead)
{
yield return(CoroutineManager.Instance.StartCoroutine(PreProcessAction(context)));
yield return(CoroutineManager.Instance.StartCoroutine(context.User.BeforeAction(context)));
if (context.CancelState.Cancel)
{
yield break;
}
yield return(CoroutineManager.Instance.StartCoroutine(ExecuteAction(context)));
context.StrikesMade++;
}
}
public IEnumerator <YieldInstruction> CheckExecuteAction(BattleContext context, ContextMethod preExecute)
{
yield return(CoroutineManager.Instance.StartCoroutine(PreProcessAction(context)));
yield return(CoroutineManager.Instance.StartCoroutine(context.User.BeforeAction(context)));
if (context.CancelState.Cancel)
{
yield break;
}
yield return(CoroutineManager.Instance.StartCoroutine(preExecute(context)));
yield return(CoroutineManager.Instance.StartCoroutine(ExecuteAction(context)));
if (context.CancelState.Cancel)
{
yield break;
}
yield return(CoroutineManager.Instance.StartCoroutine(RepeatActions(context)));
}
public IEnumerator <YieldInstruction> PreExecuteSkill(BattleContext context)
{
if (context.UsageSlot > BattleContext.DEFAULT_ATTACK_SLOT && context.UsageSlot < CharData.MAX_SKILL_SLOTS)
{
yield return(CoroutineManager.Instance.StartCoroutine(context.User.DeductCharges(context.UsageSlot, 1, false, false)));
if (context.User.Skills[context.UsageSlot].Element.Charges == 0)
{
context.SkillUsedUp = context.User.Skills[context.UsageSlot].Element.SkillNum;
}
}
yield return(new WaitUntil(AnimationsOver));
if (!String.IsNullOrEmpty(context.actionMsg))
{
LogMsg(context.actionMsg);
}
yield break;
}
public IEnumerator <YieldInstruction> BeforeExplosion(BattleContext context)
{
EventEnqueueFunction <BattleEvent> function = (StablePriorityQueue <GameEventPriority, Tuple <GameEventOwner, Character, BattleEvent> > queue, Priority maxPriority, ref Priority nextPriority) =>
{
DataManager.Instance.UniversalEvent.AddEventsToQueue(queue, maxPriority, ref nextPriority, DataManager.Instance.UniversalEvent.BeforeExplosions);
context.Data.AddEventsToQueue <BattleEvent>(queue, maxPriority, ref nextPriority, context.Data.BeforeExplosions);
StablePriorityQueue <int, Character> charQueue = new StablePriorityQueue <int, Character>();
foreach (Character character in ZoneManager.Instance.CurrentMap.IterateCharacters())
{
if (!character.Dead)
{
charQueue.Enqueue(-character.Speed, character);
}
}
int portPriority = 0;
while (charQueue.Count > 0)
{
Character character = charQueue.Dequeue();
foreach (PassiveContext effectContext in character.IterateProximityPassives(context.User, context.ExplosionTile, portPriority))
{
effectContext.AddEventsToQueue(queue, maxPriority, ref nextPriority, ((ProximityData)effectContext.EventData).BeforeExplosions);
}
portPriority++;
}
};
foreach (Tuple <GameEventOwner, Character, BattleEvent> effect in IterateEvents <BattleEvent>(function))
{
yield return(CoroutineManager.Instance.StartCoroutine(effect.Item3.Apply(effect.Item1, effect.Item2, context)));
if (context.CancelState.Cancel)
{
yield break;
}
}
}
public BattleContext(BattleContext other, bool copyGlobal) : base(other)
{
TurnCancel = other.TurnCancel;
if (copyGlobal)
{
GlobalContextStates = other.GlobalContextStates.Clone();
}
else
{
GlobalContextStates = other.GlobalContextStates;
}
StrikeStartTile = other.StrikeStartTile;
StrikeEndTile = other.StrikeEndTile;
StartDir = other.StartDir;
ExplosionTile = other.ExplosionTile;
TargetTile = other.TargetTile;
if (copyGlobal)
{
StrikeLandTiles = new List <Loc>();
StrikeLandTiles.AddRange(other.StrikeLandTiles);
}
else
{
StrikeLandTiles = other.StrikeLandTiles;
}
ActionType = other.ActionType;
UsageSlot = other.UsageSlot;
StrikesMade = other.StrikesMade;
Strikes = other.Strikes;
HitboxAction = other.HitboxAction.Clone();
Explosion = new ExplosionData(other.Explosion);
Data = new BattleData(other.Data);
Item = new InvItem(other.Item);
SkillUsedUp = other.SkillUsedUp;
actionMsg = other.actionMsg;
actionSilent = other.actionSilent;
Hit = other.Hit;
RangeMod = other.RangeMod;
}
public IEnumerator <YieldInstruction> ProcessUseSkill(Character character, int skillSlot, ActionResult result)
{
BattleContext context = new BattleContext(BattleActionType.Skill);
context.User = character;
context.UsageSlot = skillSlot;
yield return(CoroutineManager.Instance.StartCoroutine(InitActionData(context)));
yield return(CoroutineManager.Instance.StartCoroutine(context.User.BeforeTryAction(context)));
if (context.CancelState.Cancel)
{
yield return(CoroutineManager.Instance.StartCoroutine(CancelWait(context.User.CharLoc))); yield break;
}
context.TurnCancel.Cancel = false;
//move has been made; end-turn must be done from this point onwards
yield return(CoroutineManager.Instance.StartCoroutine(CheckExecuteAction(context, PreExecuteSkill)));
if (context.SkillUsedUp > -1 && !context.User.Dead)
{
SkillData entry = DataManager.Instance.GetSkill(context.SkillUsedUp);
LogMsg(Text.FormatKey("MSG_OUT_OF_CHARGES", context.User.Name, entry.Name.ToLocal()));
yield return(CoroutineManager.Instance.StartCoroutine(DungeonScene.Instance.ProcessBattleFX(context.User, context.User, DataManager.Instance.NoChargeFX)));
}
if (!context.CancelState.Cancel)
{
yield return(new WaitForFrames(GameManager.Instance.ModifyBattleSpeed(20, context.User.CharLoc)));
}
yield return(CoroutineManager.Instance.StartCoroutine(FinishTurn(context.User, !context.TurnCancel.Cancel)));
result.Success = context.TurnCancel.Cancel ? ActionResult.ResultType.Success : ActionResult.ResultType.TurnTaken;
}
public override IEnumerator <YieldInstruction> Apply(GameEventOwner owner, Character ownerChar, BattleContext context)
{
object[] parameters = new object[] { owner, ownerChar, context };
LuaFunction func_iter = LuaEngine.Instance.CreateCoroutineIterator(Script, parameters);
return(ScriptEvent.ApplyFunc(func_iter));
}
public abstract IEnumerator <YieldInstruction> Apply(GameEventOwner owner, Character ownerChar, BattleContext context);
