private void LeftArrowPB_Click(object sender, EventArgs e) { if (AllEnumValuesLB.SelectedIndex != -1) { string selectedValue = AllEnumValuesLB.SelectedItem.ToString(); CurrentValueLB.Items.Add(AllEnumValuesLB.SelectedItem); AllEnumValuesLB.Items.Remove(AllEnumValuesLB.SelectedItem); // recalcule SpellTargetType stt2 = SpellTargetType.NONE; foreach (SpellTargetType stt in Enum.GetValues(typeof(SpellTargetType))) { if (CurrentValueLB.Items.Contains(stt.ToString())) { stt2 |= stt; } } CurrentValueTB.Text = ((uint)stt2).ToString(); effectData.targets = stt2; AllEnumValuesLB.SelectedIndex = AllEnumValuesLB.Items.Count - 1; } else { MessageBox.Show("Veuillez selectionner un élement dans la liste 'Avalaible Flags'"); } }
public ISpell FindSpell(ElementType element, SpellTargetType type) { if (!spellCache.ContainsKey(element) || !spellCache[element].ContainsKey(type)) { return(null); } return(spellCache[element][type]); }
private void OnSpellSelectedByCurrentChar(Character character, int spellIndex) { for (int i = 0; i < _parties.Length; i++) { _parties[i].Event_TargetSelected -= OnCharacterSelectAsTarget; _parties[i].ChangePartyTargetMode(false); } _currentSelectedSpellIndex = spellIndex; SpellTargetType tarType = AppearanceConfigData.instance. GetMagicWithIndex(character.moniker, spellIndex)._targetType; bool isSplash = AppearanceConfigData.instance. GetMagicWithIndex(character.moniker, spellIndex)._isSplash; bool ignoreTaunt = (tarType == SpellTargetType.Ally) || isSplash; switch (tarType) { case SpellTargetType.Ally: _parties[0].Event_TargetSelected += OnCharacterSelectAsTarget; _parties[0].ChangePartyTargetMode(true, ignoreTaunt); break; case SpellTargetType.Enemy: _parties[1].Event_TargetSelected += OnCharacterSelectAsTarget; _parties[1].ChangePartyTargetMode(true, ignoreTaunt); break; case SpellTargetType.All: _parties[0].Event_TargetSelected += OnCharacterSelectAsTarget; _parties[0].ChangePartyTargetMode(true, true); _parties[1].Event_TargetSelected += OnCharacterSelectAsTarget; _parties[1].ChangePartyTargetMode(true, ignoreTaunt); break; case SpellTargetType.Self: _parties[0].Event_TargetSelected += OnCharacterSelectAsTarget; _parties[0].ChangePartyTargetMode(true, ignoreTaunt, new List <Character> { character }); break; default: break; } DivineDebug.Log("OnSpellSelectedByCurrentChar, targetType: " + tarType.ToString()); DivineDebug.Log("OnSpellSelectedByCurrentChar, char: " + character.moniker); if (characterVisitor != null) { characterVisitor.OnCharacterSpellSelected(character, spellIndex); } }
private void CastSpell(SpellTargetType type, ISpellParams parameters) { ElementType element = GetSelectedElement(); ISpell spell = FindSpell(element, type); if (spell != null && GetElementCharge(element) >= spell.GetCost()) { if (spell.Cast(parameters)) { elementCharge[element] = GetElementCharge(element) - spell.GetCost(); ClearElements(); } } }
public EffectBase(EffectInstance effect) { this.m_id = (short)effect.effectId; this.m_template = Singleton <EffectManager> .Instance.GetTemplate(this.Id); this.m_targets = (SpellTargetType)effect.targetId; this.m_targetMask = effect.targetMask; this.m_delay = effect.delay; this.m_duration = effect.duration; this.m_group = effect.group; this.m_random = effect.random; this.m_modificator = effect.modificator; this.m_trigger = effect.trigger; this.m_hidden = effect.visibleInTooltip; this.ParseRawZone(effect.rawZone); }
public EffectBase(short id, EffectBase effect) { this.m_id = id; this.m_template = Singleton <EffectManager> .Instance.GetTemplate(id); this.m_targets = effect.Targets; this.m_targetMask = effect.TargetMask; this.m_delay = effect.Delay; this.m_duration = effect.Duration; this.m_group = effect.Group; this.m_random = effect.Random; this.m_modificator = effect.Modificator; this.m_trigger = effect.Trigger; this.m_hidden = effect.Hidden; this.m_zoneSize = effect.m_zoneSize; this.m_zoneMinSize = effect.m_zoneMinSize; this.m_zoneShape = effect.ZoneShape; }
private void EditBtn_Click(object sender, EventArgs e) { SpellTargetType stt2 = SpellTargetType.NONE; foreach (SpellTargetType stt in Enum.GetValues(typeof(SpellTargetType))) { if (CurrentValueLB.Items.Contains(stt.ToString())) { stt2 |= stt; } } if ((Int32)stt2 == 230) { MessageBox.Show("Cette valeur/Flags n'est pas valide pour Stump World"); return; } effectData.targets = stt2; this.Close(); }
private void OnSecretSelected(int secretIndex) { _currentSelectedSecretIndex = secretIndex; for (int i = 0; i < _parties.Length; i++) { _parties[i].Event_TargetSelected -= OnCharacterSelectAsSecretTarget; _parties[i].ChangePartyTargetMode(false); } int partyIndex = _currentSelectedCharacter.side == PartySide.Player ? 0 : 1; SpellTargetType tarType = AppearanceConfigData.instance.GetSecretWithIndex(_parties[partyIndex].secrets[secretIndex])._targetType; if (tarType == SpellTargetType.Hero) { _parties[0].Event_TargetSelected += OnCharacterSelectAsSecretTarget; _parties[0].ChangePartyTargetMode(true, true, new List <Character> { _parties[0].hero, _parties[0].chakra }); } }
protected virtual void InternalDeserialize(ref System.IO.BinaryReader reader) { if (reader.PeekChar() == 67) { reader.ReadChar(); this.m_id = reader.ReadInt16(); } else { this.m_targets = (SpellTargetType)reader.ReadInt32(); this.m_targetMask = reader.ReadString(); this.m_id = reader.ReadInt16(); this.m_duration = reader.ReadInt32(); this.m_delay = reader.ReadInt32(); this.m_random = reader.ReadInt32(); this.m_group = reader.ReadInt32(); this.m_modificator = reader.ReadInt32(); this.m_trigger = reader.ReadBoolean(); this.m_hidden = reader.ReadBoolean(); this.ParseRawZone(reader.ReadString()); } }
public SpellEffect(SpellEffectType type, SpellTargetType target, int value) { this.type = type; this.target = target; this.value = value; }
// Precise compute efficiency of a spell for a given category (beware to remove pc from friend and friendcells lists before calling this !) // Returns -1 if it would hit friends (todo : optimize if needed) public int GetFullAreaEffect(PlayedFighter pc, Cell source, Cell dest, IEnumerable <Fighter> actors, Spell.SpellCategory category, ref string comment) { SpellImpact spellImpact = new SpellImpact(); foreach (EffectInstanceDice effect in LevelTemplate.effects) { if ((Spell.GetEffectCategories((uint)effect.effectId, LevelTemplate.id) & category) > 0) { comment += " Effect " + (EffectsEnum)(effect.effectId) + " : "; EffectDice effectCl = new EffectDice(effect); IEnumerable <Cell> cells = effectCl.GetArea(source, dest); SpellTargetType targetType = (SpellTargetType)effect.targetId; int nbAffectedTargets = 0; if (EffectBase.canAffectTarget(effectCl, this, pc, pc) && cells.Contains(source)) { // Caster would be affected DamageType efficiency = Spell.CumulEffects(effect, ref spellImpact, pc, pc /*, category*/, this); if (efficiency != 0) { comment += string.Format("{0} on {1} => {2}, ", (decimal)efficiency, pc, (decimal)spellImpact.Damage); } nbAffectedTargets++; if (efficiency < 0) { return(0); // The caster would be affected by a bad spell => give up } } foreach (var actor in actors.Where(act => cells.Contains(act.Cell))) // All actors within the area covered by the spell { if (!EffectBase.canAffectTarget(effectCl, this, pc, actor)) { continue; // This actor is not affected by the spell } DamageType damage = Spell.CumulEffects(effect, ref spellImpact, pc, actor /*, category*/, this); if (damage != 0) { comment += string.Format(" - {0} on {1} => {2}", (decimal)damage, actor, (decimal)spellImpact.Damage); } nbAffectedTargets++; //if (damage > 0 && actor.Team == pc.Team) return 0; // Harmful on a friend => give up } //if (nbAffectedTargets > 1) //{ // pc.Character.SendWarning("Spell {0} : {1} targets affected for {2} damage - {3}", this, nbAffectedTargets, spellImpact.Damage, comment); //} } } if (Template.id == 139) // Mot d'altruisme : only use near end of fight or if lot of spellImpact to heal { int hpLeftOnFoes = actors.Where(actor => actor.Team.Id != pc.Team.Id).Sum(actor => actor.Stats.Health); comment += string.Format(" - special \"Mot d'altruisme\" processing : hpLeftOnFoes = {0}, efficiency = {1}", hpLeftOnFoes, (int)spellImpact.Damage); if (hpLeftOnFoes > 500) // Not the end of the fight { if (spellImpact.Damage < 300) { return(0); // Do not cast it if less than 300 hp of healing } else { return((int)spellImpact.Damage / 3); // Otherwise, far from the end of the fight, divide efficiency by 3 } } // if close to the end of the fight, then returns full result. } return((int)spellImpact.Damage); }
/// <summary> /// Add spellImpact for a given effect, taking into account caster bonus and target resistance. /// </summary> /// <param name="effect"></param> /// <param name="spellImpact"></param> /// <param name="caster"></param> /// <param name="target"></param> /// <returns></returns> public static DamageType CumulEffects(EffectInstanceDice effect, ref SpellImpact spellImpact, PlayedFighter caster, Fighter target /*, Spell.SpellCategory Categories*/, Spell spell) { bool isFriend = caster.Team.Id == target.Team.Id; SpellImpact result = new SpellImpact(); SpellTargetType targetType = (SpellTargetType)effect.targetId; //if ((targetType & SpellTargetType.ENEMIES) == 0) return spellImpact; // No enemy can be targeted SpellCategory category = GetEffectCategories(effect.effectId, spell.LevelTemplate.id) /* & Categories*/; if (category == 0) { return(0); // No category selected in this spell } if (spell.Template.id == 0) // Weapon => ignore non heal or damage effects { if ((category & (SpellCategory.Damages | SpellCategory.Healing)) == 0) { return(0); } } double chanceToHappen = 1.0; // // When chances to happen is under 100%, then we reduce spellImpact accordingly, for simplicity, but after having apply damage bonus & reduction. // So average damage should remain exact even if Min and Max are not. if (effect.random > 0) { chanceToHappen = effect.random / 100.0; } if (target.Summoned && (caster.Breed.Id != (int)BreedEnum.Osamodas || target.Team.Id != caster.Team.Id)) { chanceToHappen /= 2; // It's much better to hit non-summoned foes => effect on summons (except allies summon for Osa) is divided by 2. } SpellException spellException = null; if (spellExceptions.ContainsKey(spell.LevelTemplate.id)) { spellException = spellExceptions[spell.LevelTemplate.id]; } if ((category & SpellCategory.DamagesNeutral) > 0) { AdjustDamage(result, spellException != null ? spellException.MinNeutral : effect.diceNum, spellException != null ? spellException.MaxNeutral : effect.diceSide, SpellCategory.DamagesNeutral, chanceToHappen, GetSafetotal(caster, Stats.PlayerField.NeutralDamageBonus) + GetSafetotal(caster, Stats.PlayerField.DamageBonus) + GetSafetotal(caster, Stats.PlayerField.PhysicalDamage), GetSafetotal(caster, Stats.PlayerField.DamageBonusPercent) + GetSafetotal(caster, Stats.PlayerField.Strength), target == null ? 0 : target.Stats.NeutralElementReduction, target == null ? 0 : target.Stats.NeutralResistPercent, isFriend); } if ((category & SpellCategory.DamagesFire) > 0) { AdjustDamage(result, spellException != null ? spellException.MinFire : effect.diceNum, spellException != null ? spellException.MaxFire : effect.diceSide, SpellCategory.DamagesFire, chanceToHappen, GetSafetotal(caster, Stats.PlayerField.FireDamageBonus) + GetSafetotal(caster, Stats.PlayerField.DamageBonus) + GetSafetotal(caster, Stats.PlayerField.MagicDamage), GetSafetotal(caster, Stats.PlayerField.DamageBonusPercent) + GetSafetotal(caster, Stats.PlayerField.Intelligence), target == null ? 0 : target.Stats.FireElementReduction, target == null ? 0 : target.Stats.FireResistPercent, isFriend); } if ((category & SpellCategory.DamagesAir) > 0) { AdjustDamage(result, spellException != null ? spellException.MinAir : effect.diceNum, spellException != null ? spellException.MaxAir : effect.diceSide, SpellCategory.DamagesAir, chanceToHappen, GetSafetotal(caster, Stats.PlayerField.AirDamageBonus) + GetSafetotal(caster, Stats.PlayerField.DamageBonus) + GetSafetotal(caster, Stats.PlayerField.MagicDamage), GetSafetotal(caster, Stats.PlayerField.DamageBonusPercent) + GetSafetotal(caster, Stats.PlayerField.Agility), target == null ? 0 : target.Stats.AirElementReduction, target == null ? 0 : target.Stats.AirResistPercent, isFriend); } if ((category & SpellCategory.DamagesWater) > 0) { AdjustDamage(result, spellException != null ? spellException.MinWater : effect.diceNum, spellException != null ? spellException.MaxWater : effect.diceSide, SpellCategory.DamagesWater, chanceToHappen, GetSafetotal(caster, Stats.PlayerField.WaterDamageBonus) + GetSafetotal(caster, Stats.PlayerField.DamageBonus) + GetSafetotal(caster, Stats.PlayerField.MagicDamage), GetSafetotal(caster, Stats.PlayerField.DamageBonusPercent) + GetSafetotal(caster, Stats.PlayerField.Chance), target == null ? 0 : target.Stats.WaterElementReduction, target == null ? 0 : target.Stats.WaterResistPercent, isFriend); } if ((category & SpellCategory.DamagesEarth) > 0) { AdjustDamage(result, spellException != null ? spellException.MinEarth : effect.diceNum, spellException != null ? spellException.MaxEarth : effect.diceSide, SpellCategory.DamagesEarth, chanceToHappen, GetSafetotal(caster, Stats.PlayerField.EarthDamageBonus) + GetSafetotal(caster, Stats.PlayerField.DamageBonus) + GetSafetotal(caster, Stats.PlayerField.MagicDamage), GetSafetotal(caster, Stats.PlayerField.DamageBonusPercent) + GetSafetotal(caster, Stats.PlayerField.Strength), target == null ? 0 : target.Stats.EarthElementReduction, target == null ? 0 : target.Stats.EarthResistPercent, isFriend); } if ((category & SpellCategory.Healing) > 0) { bool steal = (category & SpellCategory.Damages) > 0; if (steal) { target = caster; // Probably hp steal } uint hptoHeal = (uint)(Math.Max(0, target.Stats.MaxHealth - target.Stats.Health)); // Can't heal over max if (steal) { result.MinHeal = -Math.Min(hptoHeal, Math.Abs(result.MinDamage)); result.MaxHeal = -Math.Min(hptoHeal, Math.Abs(result.MaxDamage)); } else { bool skip = false; if (spell.Template.id == 140) // Mot de reconstruction => do only use it on purpose { if (hptoHeal < target.Stats.Health || hptoHeal < 400) { skip = true; // Only heal targets with under 50% of health and at least 400 hp to heal } } if (!skip && hptoHeal > 0) { AdjustDamage(result, Math.Min(effect.diceNum, hptoHeal), Math.Min(effect.diceSide, hptoHeal), SpellCategory.Healing, chanceToHappen, GetSafetotal(caster, Stats.PlayerField.HealBonus), GetSafetotal(caster, Stats.PlayerField.Intelligence), 0, 0, isFriend); if (result.Heal > hptoHeal) { if (isFriend) { result.MinHeal = result.MaxHeal = -hptoHeal; } else { result.MinHeal = result.MaxHeal = hptoHeal; } } } } } if ((category & SpellCategory.Buff) > 0) { if (isFriend) { result.Boost -= spell.Level * chanceToHappen; } else { result.Boost += spell.Level * chanceToHappen; } } if ((category & SpellCategory.Curse) > 0) { DamageType ratio = spell.Level * chanceToHappen; if (effect.effectId == (int)EffectsEnum.Effect_SkipTurn) // Let say this effect counts as 2 damage per level of the target { ratio = target.Level * 2 * chanceToHappen; } if (isFriend) { result.Curse -= 2 * ratio; } else { result.Curse += ratio; } } if (isFriend) { result.Add(result); // amplify (double) effects on friends. } if (!isFriend && ((category & SpellCategory.Damages) > 0) && result.MinDamage > target.Stats.Health) // Enough damage to kill the target => affect an arbitrary 50% of max heal (with at least current health), so strong spells are not favored anymore. { double ratio = Math.Max(target.Stats.MaxHealth / 2, target.Stats.Health) / result.MinDamage; result.Multiply(ratio); } if (spell.Template.id == 114) // Rekop { if (target.Stats.Health < 1000) { result.Multiply(0.1); } else if (target.Stats.Health < 2000) { result.Multiply(0.5); } } // Damage reflection if (((category & SpellCategory.Damages) > 0) && result.Damage > 0 && !isFriend) { DamageType reflected = spell.GetDamageReflection(target); if (reflected > 0) { if (reflected >= spellImpact.Damage) { return(0); // Reflect all damages } result.MinHeal += reflected * 2; result.MaxHeal += reflected * 2; } } if (spell.Template.id == 0 && (category & SpellCategory.Damages) > 0) // Weapon => consider effect of "maîtrise" { Weapon weapon = caster.Character.Inventory.GetEquippedWeapon(); if (weapon != null) { foreach (var boost in caster.GetBoostWeaponDamagesEffects()) { if (boost.weaponTypeId == weapon.typeId) { result.Multiply(1.0 + boost.delta / 100.0); } } } } if (spellImpact != null) { spellImpact.Add(result); } else { spellImpact = result; } return(result.Damage); }
private void CumulEffects(EffectDice effect, ref SpellTarget spellImpact, FightActor target, Spell spell) { bool flag = this.Fighter.Team.Id == target.Team.Id; SpellTarget spellTarget = new SpellTarget(); SpellTargetType arg_2A_0 = effect.Targets; SpellCategory effectCategories = SpellIdentifier.GetEffectCategories(effect.EffectId); if (effectCategories != SpellCategory.None) { double num = 1.0; if (effect.Random > 0) { num = (double)effect.Random / 100.0; } if (target is SummonedFighter) { num /= 2.0; } uint damage = (uint)System.Math.Min(effect.DiceNum, effect.DiceFace); uint damage2 = (uint)System.Math.Max(effect.DiceNum, effect.DiceFace); if ((effectCategories & SpellCategory.DamagesNeutral) > SpellCategory.None) { SpellSelector.AdjustDamage(spellTarget, damage, damage2, SpellCategory.DamagesNeutral, num, this.Fighter.Stats.GetTotal(PlayerFields.NeutralDamageBonus) + this.Fighter.Stats.GetTotal(PlayerFields.DamageBonus) + this.Fighter.Stats.GetTotal(PlayerFields.PhysicalDamage), this.Fighter.Stats.GetTotal(PlayerFields.DamageBonusPercent) + this.Fighter.Stats.GetTotal(PlayerFields.Strength), target.Stats.GetTotal(PlayerFields.NeutralElementReduction), target.Stats.GetTotal(PlayerFields.NeutralResistPercent), flag); } if ((effectCategories & SpellCategory.DamagesFire) > SpellCategory.None) { SpellSelector.AdjustDamage(spellTarget, damage, damage2, SpellCategory.DamagesNeutral, num, this.Fighter.Stats.GetTotal(PlayerFields.FireDamageBonus) + this.Fighter.Stats.GetTotal(PlayerFields.DamageBonus) + this.Fighter.Stats.GetTotal(PlayerFields.MagicDamage), this.Fighter.Stats.GetTotal(PlayerFields.DamageBonusPercent) + this.Fighter.Stats.GetTotal(PlayerFields.Intelligence), target.Stats.GetTotal(PlayerFields.FireElementReduction), target.Stats.GetTotal(PlayerFields.FireResistPercent), flag); } if ((effectCategories & SpellCategory.DamagesAir) > SpellCategory.None) { SpellSelector.AdjustDamage(spellTarget, damage, damage2, SpellCategory.DamagesNeutral, num, this.Fighter.Stats.GetTotal(PlayerFields.AirDamageBonus) + this.Fighter.Stats.GetTotal(PlayerFields.DamageBonus) + this.Fighter.Stats.GetTotal(PlayerFields.MagicDamage), this.Fighter.Stats.GetTotal(PlayerFields.DamageBonusPercent) + this.Fighter.Stats.GetTotal(PlayerFields.Agility), target.Stats.GetTotal(PlayerFields.AirElementReduction), target.Stats.GetTotal(PlayerFields.AirResistPercent), flag); } if ((effectCategories & SpellCategory.DamagesWater) > SpellCategory.None) { SpellSelector.AdjustDamage(spellTarget, damage, damage2, SpellCategory.DamagesNeutral, num, this.Fighter.Stats.GetTotal(PlayerFields.WaterDamageBonus) + this.Fighter.Stats.GetTotal(PlayerFields.DamageBonus) + this.Fighter.Stats.GetTotal(PlayerFields.MagicDamage), this.Fighter.Stats.GetTotal(PlayerFields.DamageBonusPercent) + this.Fighter.Stats.GetTotal(PlayerFields.Chance), target.Stats.GetTotal(PlayerFields.WaterElementReduction), target.Stats.GetTotal(PlayerFields.WaterResistPercent), flag); } if ((effectCategories & SpellCategory.DamagesEarth) > SpellCategory.None) { SpellSelector.AdjustDamage(spellTarget, damage, damage2, SpellCategory.DamagesNeutral, num, this.Fighter.Stats.GetTotal(PlayerFields.EarthDamageBonus) + this.Fighter.Stats.GetTotal(PlayerFields.DamageBonus) + this.Fighter.Stats.GetTotal(PlayerFields.PhysicalDamage), this.Fighter.Stats.GetTotal(PlayerFields.DamageBonusPercent) + this.Fighter.Stats.GetTotal(PlayerFields.Strength), target.Stats.GetTotal(PlayerFields.EarthElementReduction), target.Stats.GetTotal(PlayerFields.EarthResistPercent), flag); } if ((effectCategories & SpellCategory.Healing) > SpellCategory.None) { bool flag2; if (flag2 = ((effectCategories & SpellCategory.Damages) > SpellCategory.None)) { target = this.Fighter; } uint num2 = (uint)System.Math.Max(0, target.MaxLifePoints - target.LifePoints); if (flag2) { spellTarget.MinHeal = System.Math.Min(num2, System.Math.Abs(spellTarget.MinDamage)); spellTarget.MaxHeal = System.Math.Min(num2, System.Math.Abs(spellTarget.MaxDamage)); } else { if (num2 > 0u) { SpellSelector.AdjustDamage(spellTarget, (uint)System.Math.Min((long)effect.DiceNum, (long)((ulong)num2)), (uint)System.Math.Min((long)effect.DiceFace, (long)((ulong)num2)), SpellCategory.Healing, num, this.Fighter.Stats.GetTotal(PlayerFields.HealBonus), this.Fighter.Stats.GetTotal(PlayerFields.Intelligence), 0, 0, !flag); if (spellTarget.Heal > num2) { if (flag) { spellTarget.MinHeal = (spellTarget.MaxHeal = num2); } else { spellTarget.MinHeal = (spellTarget.MaxHeal = (double)(-(double)((ulong)num2))); } } } } } if ((effectCategories & SpellCategory.Buff) > SpellCategory.None) { if (flag) { spellTarget.Boost += (double)spell.CurrentLevel * num; } else { spellTarget.Boost -= (double)spell.CurrentLevel * num; } } if ((effectCategories & SpellCategory.Curse) > SpellCategory.None) { double num3 = (double)spell.CurrentLevel * num; if (effect.EffectId == EffectsEnum.Effect_SkipTurn) { num3 = (double)(target.Level * 2) * num; } if (flag) { spellTarget.Curse -= 2.0 * num3; } else { spellTarget.Curse += num3; } } if (flag) { spellTarget.Add(spellTarget); } if (!flag && (effectCategories & SpellCategory.Damages) > SpellCategory.None && spellTarget.MinDamage > (double)target.LifePoints) { double num3 = System.Math.Max((double)target.MaxLifePoints / 2.0, (double)target.LifePoints) / spellTarget.MinDamage; spellTarget.Multiply(num3); } if (spellImpact != null) { spellImpact.Add(spellTarget); } else { spellImpact = spellTarget; } } }
public TargetTypeCriterion(SpellTargetType type, bool caster) { TargetType = type; Caster = caster; }