public static void PhysicalAttack(int power, AbilityState state, int targetIndex)
{
ICombatant er = state.Performer;
ICombatant ee = state.Target[targetIndex];
bool restorative = false;
if (!PhysicalHit(state, targetIndex))
{
return;
}
int bd = PhysicalBase(er);
int dam = PhysicalDamage(bd, power, ee);
dam = Critical(dam, state, targetIndex);
dam = Berserk(dam, state);
dam = RowCheck(dam, state, targetIndex);
dam = Frog(dam, state);
dam = Sadness(dam, ee);
dam = Split(dam, state);
dam = Barrier(dam, state, targetIndex);
dam = MPTurbo(dam, state);
dam = Mini(dam, state);
dam = RandomVariation(dam);
dam = LowerSanityCkeck(dam);
dam = RunElementalChecks(dam, ref restorative, state, targetIndex);
dam = UpperSanityCheck(dam);
ee.AcceptDamage(er, dam);
}
public static int Critical(int dam, AbilityState state, int targetIndex)
{
ICombatant ee = state.Target[targetIndex];
Ally er = state.Performer as Ally;
if (er == null)
{
return(dam);
}
int critp;
if (er.LuckyGirl)
{
critp = 255;
}
else
{
critp = (er.Luck + er.Level - ee.Level) / 4;
critp = critp + er.Weapon.CriticalPercent;
}
int r = (Game.Random.Next(65536) * 99 / 65536) + 1;
if (r <= critp)
{
dam = dam * 2;
}
return(dam);
}
public static bool PhysicalHit(AbilityState state, int targetIndex)
{
ICombatant er = state.Performer;
ICombatant ee = state.Target[targetIndex];
int hitp;
if (ee.Absorbs(state.Elements) ||
ee.Voids(state.Elements) ||
ee.Death || ee.Sleep ||
ee.Confusion || ee.Stop ||
ee.Petrify || ee.Manipulate ||
ee.Paralysed || ee.Peerless)
{
hitp = 255;
}
else
{
hitp = ((er.Dexterity / 4) + state.HitP)
+ er.Defp
- ee.Defp;
if (er.Fury)
{
hitp = hitp - hitp * 3 / 10;
}
}
// Sanity
if (hitp < 1)
{
hitp = 1;
}
int lucky = Game.Random.Next(0, 100);
// Lucky Hit
if (lucky < Math.Floor(state.Performer.Luck / 4.0d))
{
hitp = 255;
}
// Lucky Evade
else if (lucky < Math.Floor(ee.Luck / 4.0d))
{
if (er is Ally && ee is Enemy)
{
hitp = 0;
}
}
int r = Game.Random.Next(65536) * 99 / 65536 + 1;
if (r < hitp)
{
return(true);
}
else
{
return(false);
}
}
public void ActOnSelection()
{
int o = _option; // allocate to stack (option is on heap)
Item i = (Item)Inventory.GetItem(_option);
AbilityState state = Game.Battle.Commanding.Ability;
switch (i.TargetType)
{
case TargetType.AllTar:
case TargetType.AllTarNS:
case TargetType.NTar:
state.Target = GroupSelector.Instance.Selected;
break;
case TargetType.Field:
state.Target = FieldSelector.Instance.Selected;
break;
case TargetType.OneTar:
state.Target = TargetSelector.Instance.Selected;
break;
default: break;
}
state.Performer = Game.Battle.Commanding;
state.Action += delegate() { Inventory.UseItem(o); };
}
private void CheckAbilityQueue()
{
_abilityMutex.WaitOne();
// If the current ability is done, clear it
if (_abilityThread != null && !_abilityThread.IsAlive)
{
#if DEBUG
Console.WriteLine("Killing action:");
Console.WriteLine(_activeAbility.ToString());
#endif
if (_activeAbility.Performer is Ally)
{
_lastPartyAction = (AbilityState)_activeAbility.Clone();
}
_activeAbility.Performer.Ability.Reset();
_activeAbility = null;
_abilityThread = null;
}
// Dequeue next ability if none is in progress
if (_abilityThread == null && _abilityQueue.Count > 0)
{
_activeAbility = _abilityQueue.Dequeue();
_abilityThread = new Thread(new ThreadStart(_activeAbility.DoAction));
_abilityThread.Start();
}
_abilityMutex.ReleaseMutex();
}
public static int Berserk(int dam, AbilityState state)
{
if (state.Performer.Berserk)
{
dam = dam * 15 / 10;
}
return(dam);
}
public static int Mini(int dam, AbilityState state)
{
if (state.Performer.Small)
{
dam = 0;
}
return(dam);
}
public static int Frog(int dam, AbilityState state)
{
if (state.Performer.Frog)
{
dam = dam / 4;
}
return(dam);
}
/// <summary>Creates a deep clone of this AbilityState.</summary>
/// <returns>A new deep clone</returns>
public object Clone()
{
// Shallow objects
AbilityState state = (AbilityState)this.MemberwiseClone();
// Deep objects
state._actionTimer = new Timer(2000, 0, false);
return(state);
}
public static int Split(int dam, AbilityState state)
{
if (state.QuadraMagic)
{
dam = dam / 2;
}
else if (state.Target.Length > 1 && !state.NoSplit)
{
dam = dam * 2 / 3;
}
return(dam);
}
public void EnqueueAction(AbilityState a)
{
_abilityMutex.WaitOne();
_abilityQueue.Enqueue(a);
#if DEBUG
Console.WriteLine("Added ability to Queue. Current queue state:");
foreach (AbilityState s in _abilityQueue)
{
Console.WriteLine(s.ToString());
}
#endif
_abilityMutex.ReleaseMutex();
}
public static int RunMagicModifiers(int dam, ref bool restorative, AbilityState state, int targetIndex)
{
dam = Sadness(dam, state.Target[targetIndex]);
dam = Split(dam, state);
dam = Barrier(dam, state, targetIndex);
dam = MPTurbo(dam, state);
dam = RandomVariation(dam);
dam = LowerSanityCkeck(dam);
dam = RunElementalChecks(dam, ref restorative, state, targetIndex);
dam = UpperSanityCheck(dam);
return(dam);
}
public static int RowCheck(int dam, AbilityState state, int targetIndex)
{
if (state.LongRange)
{
return(dam);
}
if (state.Performer.BackRow || state.Target[targetIndex].BackRow)
{
dam = dam / 2;
}
return(dam);
}
public static bool MagicHit(AbilityState state, int targetIndex)
{
if (state.HitP == 255)
{
return(true);
}
if (state.Target[targetIndex].Absorbs(state.Elements))
{
return(true);
}
if (state.Target[targetIndex].Voids(state.Elements))
{
return(true);
}
if (state.Target[targetIndex].Death ||
state.Target[targetIndex].Sleep ||
state.Target[targetIndex].Confusion ||
state.Target[targetIndex].Stop ||
state.Target[targetIndex].Petrify ||
state.Target[targetIndex].Paralysed ||
state.Target[targetIndex].Peerless ||
state.Target[targetIndex].Reflect)
{
return(true);
}
int matp = state.HitP;
if (state.Performer.Fury)
{
matp = matp - matp * 3 / 10;
}
if (Game.Random.Next(1, 101) > state.Target[targetIndex].MDefp)
{
return(false);
}
int hitp = matp + state.Performer.Level - state.Target[targetIndex].Level / 2 - 1;
if (Game.Random.Next(100) < hitp)
{
return(true);
}
else
{
return(false);
}
}
public static int Barrier(int dam, AbilityState state, int targetIndex)
{
ICombatant ee = state.Target[targetIndex];
switch (state.Type)
{
case AttackType.Magical:
if (ee.MBarrier) dam = dam / 2;
break;
case AttackType.Physical:
if (ee.Barrier) dam = dam / 2;
break;
default: break;
}
return dam;
}
public static int RunElementalChecks(int dam, ref bool restorative, AbilityState state, int targetIndex)
{
bool checksDone = false;
foreach (Element e in state.Elements)
{
if (state.Target[targetIndex].Voids(e))
{
dam = 0;
checksDone = true;
break;
}
}
if (!checksDone)
{
foreach (Element e in state.Elements)
{
if (state.Target[targetIndex].Absorbs(e))
{
restorative = !restorative;
checksDone = true;
break;
}
}
}
if (!checksDone)
{
foreach (Element e in state.Elements)
{
if (state.Target[targetIndex].Halves(e) && state.Target[targetIndex].Weak(e))
{
continue;
}
else if (state.Target[targetIndex].Halves(e))
{
dam = dam / 2;
break;
}
else if (state.Target[targetIndex].Weak(e))
{
dam = dam * 2;
break;
}
}
}
return(dam);
}
public Ally(Character c, int x, int y, int e)
{
_c = c;
_abilityState = new AbilityState();
int vStep = Globals.BattleSpeed;
_c_timer = new ScaledClock(10000);
_v_timer = new ScaledClock(vStep);
_turnTimer = new ScaledTimer(6000, e, Globals.TurnTimerSpeed(this, vStep));
_x = x;
_y = y;
GetMagicSpells();
GetSummons();
_battleMenu = new BattleMenu(this);
_magicMenu = new MagicMenu(MagicSpells, _battleMenu.WMagic);
if (!_magicMenu.IsValid)
{
_magicMenu = null;
}
_summonMenu = new SummonMenu(Summons, _battleMenu.WSummon);
if (!_summonMenu.IsValid)
{
_summonMenu = null;
}
EnemySkillMateria m = new EnemySkillMateria(GetEnemySkillMask());
if (m.AP > 0)
{
_enemySkillMenu = new EnemySkillMenu(m);
}
if (HP == 0)
{
InflictDeath();
}
}
public static void MagicSpell(int power, AbilityState state, int targetIndex)
{
ICombatant er = state.Performer;
ICombatant ee = state.Target[targetIndex];
if (!MagicHit(state, targetIndex))
{
return;
}
bool restorative = false;
int bd = MagicalBase(er);
int dam = MagicalDamage(bd, 4, ee);
RunMagicModifiers(dam, ref restorative, state, targetIndex);
if (restorative)
{
dam = -dam;
}
ee.AcceptDamage(er, dam);
}
public static int Barrier(int dam, AbilityState state, int targetIndex)
{
ICombatant ee = state.Target[targetIndex];
switch (state.Type)
{
case AttackType.Magical:
if (ee.MBarrier)
{
dam = dam / 2;
}
break;
case AttackType.Physical:
if (ee.Barrier)
{
dam = dam / 2;
}
break;
default: break;
}
return(dam);
}
public static int Critical(int dam, AbilityState state, int targetIndex)
{
ICombatant ee = state.Target[targetIndex];
Ally er = state.Performer as Ally;
if (er == null)
return dam;
int critp;
if (er.LuckyGirl)
critp = 255;
else
{
critp = (er.Luck + er.Level - ee.Level) / 4;
critp = critp + er.Weapon.CriticalPercent;
}
int r = (Game.Random.Next(65536) * 99 / 65536) + 1;
if (r <= critp)
dam = dam * 2;
return dam;
}
public static int Split(int dam, AbilityState state)
{
if (state.QuadraMagic)
dam = dam / 2;
else if (state.Target.Length > 1 && !state.NoSplit)
dam = dam * 2 / 3;
return dam;
}
public static int RunMagicModifiers(int dam, ref bool restorative, AbilityState state, int targetIndex)
{
dam = Sadness(dam, state.Target[targetIndex]);
dam = Split(dam, state);
dam = Barrier(dam, state, targetIndex);
dam = MPTurbo(dam, state);
dam = RandomVariation(dam);
dam = LowerSanityCkeck(dam);
dam = RunElementalChecks(dam, ref restorative, state, targetIndex);
dam = UpperSanityCheck(dam);
return dam;
}
public static int Berserk(int dam, AbilityState state)
{
if (state.Performer.Berserk)
dam = dam * 15 / 10;
return dam;
}
public static int RunElementalChecks(int dam, ref bool restorative, AbilityState state, int targetIndex)
{
bool checksDone = false;
foreach (Element e in state.Elements)
if (state.Target[targetIndex].Voids(e))
{
dam = 0;
checksDone = true;
break;
}
if (!checksDone)
foreach (Element e in state.Elements)
if (state.Target[targetIndex].Absorbs(e))
{
restorative = !restorative;
checksDone = true;
break;
}
if (!checksDone)
foreach (Element e in state.Elements)
{
if (state.Target[targetIndex].Halves(e) && state.Target[targetIndex].Weak(e))
continue;
else if (state.Target[targetIndex].Halves(e))
{
dam = dam / 2;
break;
}
else if (state.Target[targetIndex].Weak(e))
{
dam = dam * 2;
break;
}
}
return dam;
}
public static int RowCheck(int dam, AbilityState state, int targetIndex)
{
if (state.LongRange)
return dam;
if (state.Performer.BackRow || state.Target[targetIndex].BackRow)
dam = dam / 2;
return dam;
}
public static bool PhysicalHit(AbilityState state, int targetIndex)
{
ICombatant er = state.Performer;
ICombatant ee = state.Target[targetIndex];
int hitp;
if (ee.Absorbs(state.Elements) ||
ee.Voids(state.Elements) ||
ee.Death || ee.Sleep ||
ee.Confusion || ee.Stop ||
ee.Petrify || ee.Manipulate ||
ee.Paralysed || ee.Peerless)
hitp = 255;
else
{
hitp = ((er.Dexterity / 4) + state.HitP)
+ er.Defp
- ee.Defp;
if (er.Fury)
hitp = hitp - hitp * 3 / 10;
}
// Sanity
if (hitp < 1)
hitp = 1;
int lucky = Game.Random.Next(0, 100);
// Lucky Hit
if (lucky < Math.Floor(state.Performer.Luck / 4.0d))
hitp = 255;
// Lucky Evade
else if (lucky < Math.Floor(ee.Luck / 4.0d))
if (er is Ally && ee is Enemy)
hitp = 0;
int r = Game.Random.Next(65536) * 99 / 65536 + 1;
if (r < hitp)
return true;
else return false;
}
public static void PhysicalAttack(int power, AbilityState state, int targetIndex)
{
ICombatant er = state.Performer;
ICombatant ee = state.Target[targetIndex];
bool restorative = false;
if (!PhysicalHit(state, targetIndex))
return;
int bd = PhysicalBase(er);
int dam = PhysicalDamage(bd, power, ee);
dam = Critical(dam, state, targetIndex);
dam = Berserk(dam, state);
dam = RowCheck(dam, state, targetIndex);
dam = Frog(dam, state);
dam = Sadness(dam, ee);
dam = Split(dam, state);
dam = Barrier(dam, state, targetIndex);
dam = MPTurbo(dam, state);
dam = Mini(dam, state);
dam = RandomVariation(dam);
dam = LowerSanityCkeck(dam);
dam = RunElementalChecks(dam, ref restorative, state, targetIndex);
dam = UpperSanityCheck(dam);
ee.AcceptDamage(er, dam);
}
public Enemy(string xmlstring, int x, int y)
{
_xml = xmlstring;
_weak = new List<Element>();
_halve = new List<Element>();
_void = new List<Element>();
_absorb = new List<Element>();
_immune = new List<Status>();
_win = new List<EnemyItem>();
_steal = new List<EnemyItem>();
_abilityState = new AbilityState();
XmlDocument xml = new XmlDocument();
xml.Load(new MemoryStream(Encoding.UTF8.GetBytes(xmlstring)));
_name = xml.SelectSingleNode("//name").InnerText;
_attack = Int32.Parse(xml.SelectSingleNode("//atk").InnerText);
_defense = Int32.Parse(xml.SelectSingleNode("//def").InnerText);
_defensePercent = Int32.Parse(xml.SelectSingleNode("//defp").InnerText);
_dexterity = Int32.Parse(xml.SelectSingleNode("//dex").InnerText);
_magicAttack = Int32.Parse(xml.SelectSingleNode("//mat").InnerText);
_magicDefense = Int32.Parse(xml.SelectSingleNode("//mdf").InnerText);
_luck = Int32.Parse(xml.SelectSingleNode("//lck").InnerText);
_level = Int32.Parse(xml.SelectSingleNode("//lvl").InnerText);
_maxhp = _hp = Int32.Parse(xml.SelectSingleNode("//hp").InnerText);
_maxmp = _mp = Int32.Parse(xml.SelectSingleNode("//mp").InnerText);
_exp = Int32.Parse(xml.SelectSingleNode("//exp").InnerText);
_ap = Int32.Parse(xml.SelectSingleNode("//ap").InnerText);
_gil = Int32.Parse(xml.SelectSingleNode("//gil").InnerText);
foreach (XmlNode weak in xml.SelectSingleNode("//weaks").ChildNodes)
_weak.Add((Element)Enum.Parse(typeof(Element), weak.InnerText));
foreach (XmlNode halve in xml.SelectSingleNode("//halves").ChildNodes)
_halve.Add((Element)Enum.Parse(typeof(Element), halve.InnerText));
foreach (XmlNode v in xml.SelectSingleNode("//voids").ChildNodes)
_void.Add((Element)Enum.Parse(typeof(Element), v.InnerText));
foreach (XmlNode absorb in xml.SelectSingleNode("//absorbs").ChildNodes)
_absorb.Add((Element)Enum.Parse(typeof(Element), absorb.InnerText));
foreach (XmlNode immunity in xml.SelectSingleNode("//immunities").ChildNodes)
_immune.Add((Status)Enum.Parse(typeof(Status), immunity.InnerText));
foreach (XmlNode win in xml.SelectSingleNode("//win").ChildNodes)
_win.Add(new EnemyItem(win.OuterXml));
foreach (XmlNode steal in xml.SelectSingleNode("//steal").ChildNodes)
_steal.Add(new EnemyItem(steal.OuterXml));
foreach (XmlNode morph in xml.SelectSingleNode("//morph").ChildNodes)
if (morph.Attributes["id"] != null)
{
string id = morph.Attributes["id"].Value;
string type = morph.Attributes["type"].Value;
_morph = Atmosphere.BattleSimulator.Item.GetItem(id, type);
}
int vStep = Globals.BattleSpeed;
_c_timer = new ScaledClock(vStep);
_v_timer = new ScaledClock(vStep);
_turnTimer = new ScaledTimer(6000, _dexterity * vStep / Globals.NormalSpeed());
_ai = new Thread(new ThreadStart(AI));
_x = x;
_y = y;
}
private void CheckAbilityQueue()
{
_abilityMutex.WaitOne();
// If the current ability is done, clear it
if (_abilityThread != null && !_abilityThread.IsAlive)
{
#if DEBUG
Console.WriteLine("Killing action:");
Console.WriteLine(_activeAbility.ToString());
#endif
if (_activeAbility.Performer is Ally)
_lastPartyAction = (AbilityState)_activeAbility.Clone();
_activeAbility.Performer.Ability.Reset();
_activeAbility = null;
_abilityThread = null;
}
// Dequeue next ability if none is in progress
if (_abilityThread == null && _abilityQueue.Count > 0)
{
_activeAbility = _abilityQueue.Dequeue();
_abilityThread = new Thread(new ThreadStart(_activeAbility.DoAction));
_abilityThread.Start();
}
_abilityMutex.ReleaseMutex();
}
public static bool MagicHit(AbilityState state, int targetIndex)
{
if (state.HitP == 255)
return true;
if (state.Target[targetIndex].Absorbs(state.Elements))
return true;
if (state.Target[targetIndex].Voids(state.Elements))
return true;
if (state.Target[targetIndex].Death ||
state.Target[targetIndex].Sleep ||
state.Target[targetIndex].Confusion ||
state.Target[targetIndex].Stop ||
state.Target[targetIndex].Petrify ||
state.Target[targetIndex].Paralysed ||
state.Target[targetIndex].Peerless ||
state.Target[targetIndex].Reflect)
return true;
int matp = state.HitP;
if (state.Performer.Fury)
matp = matp - matp * 3 / 10;
if (Game.Random.Next(1, 101) > state.Target[targetIndex].MDefp)
return false;
int hitp = matp + state.Performer.Level - state.Target[targetIndex].Level / 2 - 1;
if (Game.Random.Next(100) < hitp)
return true;
else return false;
}
public void ActOnSelection()
{
ICombatant target;
Ally performer = Game.Battle.Commanding;
#region Attack
if (_option == _attackOption)
{
target = TargetSelector.Instance.Selected[0];
int bd = Formula.PhysicalBase(Game.Battle.Commanding);
int dam = Formula.PhysicalDamage(bd, 16, target);
AbilityState state = Game.Battle.Commanding.Ability;
state.LongRange = performer.LongRange;
state.QuadraMagic = false;
state.Type = AttackType.Physical;
state.Performer = performer;
state.Target = TargetSelector.Instance.Selected;
state.Action += delegate() { target.AcceptDamage(Game.Battle.ActiveAbility.Performer, dam); };
}
#endregion Attack
#region 2x-Cut
else if (_option == _doubleCutOption2)
{
target = TargetSelector.Instance.Selected[0];
int bd = Formula.PhysicalBase(Game.Battle.Commanding);
int dam = Formula.PhysicalDamage(bd, 16, target);
AbilityState state = Game.Battle.Commanding.Ability;
state.LongRange = performer.LongRange;
state.QuadraMagic = false;
state.Type = AttackType.Physical;
state.Performer = performer;
state.Target = TargetSelector.Instance.Selected;
state.Action += delegate() { target.AcceptDamage(Game.Battle.ActiveAbility.Performer, dam); };
Game.Battle.EnqueueAction((AbilityState)state.Clone());
Game.Battle.EnqueueAction((AbilityState)state.Clone());
// Here we must disable the action hook, because we do not the second state
// to be attached to Ally.Ability. If it were, when the first one is disposed of
// it will reset the second one. See BattleState.CheckAbilityQueue()
Selector.DisableActionHook(true);
}
#endregion 2x-Cut
#region 4x-Cut
else if (_option == _doubleCutOption4)
{
target = TargetSelector.Instance.Selected[0];
int bd = Formula.PhysicalBase(Game.Battle.Commanding);
int dam = Formula.PhysicalDamage(bd, 16, target);
AbilityState state = Game.Battle.Commanding.Ability;
state.LongRange = performer.LongRange;
state.QuadraMagic = false;
state.Type = AttackType.Physical;
state.Performer = performer;
state.Target = TargetSelector.Instance.Selected;
state.Action += delegate() { target.AcceptDamage(Game.Battle.ActiveAbility.Performer, dam); };
Game.Battle.EnqueueAction((AbilityState)state.Clone());
Game.Battle.EnqueueAction((AbilityState)state.Clone());
Game.Battle.EnqueueAction((AbilityState)state.Clone());
Game.Battle.EnqueueAction((AbilityState)state.Clone());
// Here we must disable the action hook, because we do not the first three states
// to be attached to Ally.Ability. If it were, when the first one is disposed of
// it will reset the others. See BattleState.CheckAbilityQueue()
Selector.DisableActionHook(true);
}
#endregion 4x-Cut
#region Sense
else if (_option == _senseOption)
{
target = TargetSelector.Instance.Selected[0];
AbilityState state = Game.Battle.Commanding.Ability;
state.Performer = performer;
state.Target = new ICombatant[1];
state.Target[0] = target;
state.Action += delegate() { target.Sense(); };
}
#endregion Sense
#region Mime
else if (_option == _mimeOption)
{
if (Game.Battle.LastPartyAbility == null)
{
Selector.DisableActionHook(true);
Game.Battle.Commanding.TurnTimer.Reset();
}
else
{
Game.Battle.Commanding.Ability = Game.Battle.LastPartyAbility;
try
{
Game.Battle.Commanding.Ability.Performer = performer;
}
catch (Exception e)
{
}
}
}
#endregion Mime
#region Deathblow
else if (_option == _deathblowOption)
{
target = TargetSelector.Instance.Selected[0];
int bd = Formula.PhysicalBase(Game.Battle.Commanding);
int dam = Formula.PhysicalDamage(bd, 16, target) * 2;
AbilityState state = Game.Battle.Commanding.Ability;
state.LongRange = performer.LongRange;
state.QuadraMagic = false;
state.Type = AttackType.Physical;
state.Performer = performer;
state.Target = TargetSelector.Instance.Selected;
state.Action += delegate() { target.AcceptDamage(Game.Battle.ActiveAbility.Performer, dam); };
}
#endregion Deathblow
#region Steal
else if (_option == _stealOption)
{
target = TargetSelector.Instance.Selected[0];
AbilityState state = Game.Battle.Commanding.Ability;
state.Type = AttackType.Physical;
state.Performer = performer;
state.Target = TargetSelector.Instance.Selected;
state.Action += delegate() { ((Enemy)target).StealItem(performer); };
}
#endregion Steal
#region Mug
else if (_option == _mugOption)
{
target = TargetSelector.Instance.Selected[0];
int bd = Formula.PhysicalBase(Game.Battle.Commanding);
int dam = Formula.PhysicalDamage(bd, 16, target);
AbilityState state = Game.Battle.Commanding.Ability;
state.Type = AttackType.Physical;
state.Performer = performer;
state.Target = TargetSelector.Instance.Selected;
state.Action += delegate()
{
target.AcceptDamage(Game.Battle.ActiveAbility.Performer, dam);
((Enemy)target).StealItem(performer);
};
}
#endregion Mug
}
public Enemy(string xmlstring, int x, int y)
{
_xml = xmlstring;
_weak = new List <Element>();
_halve = new List <Element>();
_void = new List <Element>();
_absorb = new List <Element>();
_immune = new List <Status>();
_win = new List <EnemyItem>();
_steal = new List <EnemyItem>();
_abilityState = new AbilityState();
XmlDocument xml = new XmlDocument();
xml.Load(new MemoryStream(Encoding.UTF8.GetBytes(xmlstring)));
_name = xml.SelectSingleNode("//name").InnerText;
_attack = Int32.Parse(xml.SelectSingleNode("//atk").InnerText);
_defense = Int32.Parse(xml.SelectSingleNode("//def").InnerText);
_defensePercent = Int32.Parse(xml.SelectSingleNode("//defp").InnerText);
_dexterity = Int32.Parse(xml.SelectSingleNode("//dex").InnerText);
_magicAttack = Int32.Parse(xml.SelectSingleNode("//mat").InnerText);
_magicDefense = Int32.Parse(xml.SelectSingleNode("//mdf").InnerText);
_luck = Int32.Parse(xml.SelectSingleNode("//lck").InnerText);
_level = Int32.Parse(xml.SelectSingleNode("//lvl").InnerText);
_maxhp = _hp = Int32.Parse(xml.SelectSingleNode("//hp").InnerText);
_maxmp = _mp = Int32.Parse(xml.SelectSingleNode("//mp").InnerText);
_exp = Int32.Parse(xml.SelectSingleNode("//exp").InnerText);
_ap = Int32.Parse(xml.SelectSingleNode("//ap").InnerText);
_gil = Int32.Parse(xml.SelectSingleNode("//gil").InnerText);
foreach (XmlNode weak in xml.SelectSingleNode("//weaks").ChildNodes)
{
_weak.Add((Element)Enum.Parse(typeof(Element), weak.InnerText));
}
foreach (XmlNode halve in xml.SelectSingleNode("//halves").ChildNodes)
{
_halve.Add((Element)Enum.Parse(typeof(Element), halve.InnerText));
}
foreach (XmlNode v in xml.SelectSingleNode("//voids").ChildNodes)
{
_void.Add((Element)Enum.Parse(typeof(Element), v.InnerText));
}
foreach (XmlNode absorb in xml.SelectSingleNode("//absorbs").ChildNodes)
{
_absorb.Add((Element)Enum.Parse(typeof(Element), absorb.InnerText));
}
foreach (XmlNode immunity in xml.SelectSingleNode("//immunities").ChildNodes)
{
_immune.Add((Status)Enum.Parse(typeof(Status), immunity.InnerText));
}
foreach (XmlNode win in xml.SelectSingleNode("//win").ChildNodes)
{
_win.Add(new EnemyItem(win.OuterXml));
}
foreach (XmlNode steal in xml.SelectSingleNode("//steal").ChildNodes)
{
_steal.Add(new EnemyItem(steal.OuterXml));
}
foreach (XmlNode morph in xml.SelectSingleNode("//morph").ChildNodes)
{
if (morph.Attributes["id"] != null)
{
string id = morph.Attributes["id"].Value;
string type = morph.Attributes["type"].Value;
_morph = Atmosphere.BattleSimulator.Item.GetItem(id, type);
}
}
int vStep = Globals.BattleSpeed;
_c_timer = new ScaledClock(vStep);
_v_timer = new ScaledClock(vStep);
_turnTimer = new ScaledTimer(6000, _dexterity * vStep / Globals.NormalSpeed());
_ai = new Thread(new ThreadStart(AI));
_x = x;
_y = y;
}
public static int MPTurbo(int dam, AbilityState state)
{
dam = dam + (dam * 10 * state.MPTurboFactor) / 10;
return(dam);
}
public static int Frog(int dam, AbilityState state)
{
if (state.Performer.Frog)
dam = dam / 4;
return dam;
}
public static int MPTurbo(int dam, AbilityState state)
{
dam = dam + (dam * 10 * state.MPTurboFactor) / 10;
return dam;
}
public void EnqueueAction(AbilityState a)
{
_abilityMutex.WaitOne();
_abilityQueue.Enqueue(a);
#if DEBUG
Console.WriteLine("Added ability to Queue. Current queue state:");
foreach (AbilityState s in _abilityQueue)
Console.WriteLine(s.ToString());
#endif
_abilityMutex.ReleaseMutex();
}
public static void MagicSpell(int power, AbilityState state, int targetIndex)
{
ICombatant er = state.Performer;
ICombatant ee = state.Target[targetIndex];
if (!MagicHit(state, targetIndex))
return;
bool restorative = false;
int bd = MagicalBase(er);
int dam = MagicalDamage(bd, 4, ee);
RunMagicModifiers(dam, ref restorative, state, targetIndex);
if (restorative)
dam = -dam;
ee.AcceptDamage(er, dam);
}
public void ActOnSelection()
{
if (_first != -1)
{
// allocate to stack (option is on heap)
int first = _first;
int second = _option;
#region First
Item i = (Item)Inventory.GetItem(first);
AbilityState state = (AbilityState)Game.Battle.Commanding.Ability.Clone();
switch (i.TargetType)
{
case TargetType.AllTar:
case TargetType.AllTarNS:
case TargetType.NTar:
state.Target = GroupSelector.Instance.Selected;
break;
case TargetType.Field:
state.Target = FieldSelector.Instance.Selected;
break;
case TargetType.OneTar:
state.Target = TargetSelector.Instance.Selected;
break;
default: break;
}
state.Performer = Game.Battle.Commanding;
state.Action += delegate() { Inventory.UseItem(first); };
Game.Battle.EnqueueAction(state);
#endregion First
#region Second
i = (Item)Inventory.GetItem(second);
state = Game.Battle.Commanding.Ability;
switch (i.TargetType)
{
case TargetType.AllTar:
case TargetType.AllTarNS:
case TargetType.NTar:
state.Target = GroupSelector.Instance.Selected;
break;
case TargetType.Field:
state.Target = FieldSelector.Instance.Selected;
break;
case TargetType.OneTar:
state.Target = TargetSelector.Instance.Selected;
break;
default: break;
}
state.Performer = Game.Battle.Commanding;
state.Action += delegate() { Inventory.UseItem(second); };
// don't enqueue, will be picked up by Battle.ActionHook()
#endregion Second
}
else
{
_first = _option;
}
}
public static int Mini(int dam, AbilityState state)
{
if (state.Performer.Small)
dam = 0;
return dam;
}
