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; }