// Constructor public MoveEffect( MoveEffectType effectType, MoveEffectTiming effectTiming = MoveEffectTiming.Unique, MoveEffectTargetType effectTargetType = MoveEffectTargetType.Unique, IEnumerable <MoveEffectFilter> effectFilters = null, float effectChance = -1, bool forceEffectDisplay = false, bool[] boolParams = null, float[] floatParams = null, string[] stringParams = null, bool sheerForceEffect = false ) : base(boolParams, floatParams, stringParams) { this.effectType = effectType; this.effectTiming = effectTiming; this.effectTargetType = effectTargetType; this.effectFilters = new HashSet <MoveEffectFilter>(); if (effectFilters != null) { this.effectFilters.UnionWith(effectFilters); } this.effectChance = effectChance; this.forceEffectDisplay = forceEffectDisplay; this.sheerForceEffect = sheerForceEffect; }
public MultiEffect(MoveEffectType type, XmlNode node) : base(type, node) { Min = node.Attributes.Contains("min") ? int.Parse(node.Attributes["min"].Value) : int.MaxValue - 1; Max = node.Attributes.Contains("max") ? int.Parse(node.Attributes["max"].Value) : int.MaxValue - 1; When = node.Attributes.Contains("when") ? (When)Enum.Parse(typeof(When), node.Attributes["when"].Value, true) : Enums.When.NA; }
public CustomDamageEffect(MoveEffectType type, XmlNode node) : base(type, node) { Calculation = node.Attributes["calculation"].Value; Value = node.Attributes.Contains("value") ? int.Parse(node.Attributes["value"].Value) : 0; Multiplier = node.Attributes.Contains("multiplier") ? decimal.Parse(node.Attributes["multiplier"].Value) : 1m; }
public EffectDatabase.MoveEff.MoveEffect GetEffectNew(MoveEffectType effectType, bool forceUnique = false) { List <EffectDatabase.MoveEff.MoveEffect> effectList = GetEffectsNew(effectType, forceUnique); if (effectList.Count > 0) { return(effectList[0]); } return(null); }
public HealthEffect(MoveEffectType type, XmlNode node) : base(type, node) { Percent = decimal.Parse(node.Attributes["percent"].Value, CultureInfo.InvariantCulture); Of = node.Attributes["of"].Value; if (node.Attributes.Contains("who")) { Who = (Who)Enum.Parse(typeof(Who), node.Attributes["who"].Value, true); } RestoreOnly = type == MoveEffectType.RestoreHealth; }
public MoveEffect GetEffect(MoveEffectType effectType) { for (int i = 0; i < moveEffects.Count; i++) { if (moveEffects[i].effectType == effectType) { return(moveEffects[i]); } } return(null); }
public StatusEffect(MoveEffectType type, XmlNode node) : base(type, node) { Status = (StatusCondition)Enum.Parse(typeof(StatusCondition), node.Attributes["status"].Value.Replace("-", ""), true); Who = (Who)Enum.Parse(typeof(Who), node.Attributes["who"].Value, true); Chance = node.Attributes.Contains("chance") ? int.Parse(node.Attributes["chance"].Value) : 256; TurnLimit = node.Attributes.Contains("turn-limit") ? int.Parse(node.Attributes["turn-limit"].Value) : 0; Reset = type == MoveEffectType.ResetStatus; ForceMessage = node.Attributes.Contains("force-message") ? node.Attributes["force-message"].Value : null; Force = node.Attributes.Contains("force") ? bool.Parse(node.Attributes["force"].Value) : false; Condition = node.Attributes.Contains("condition") ? node.Attributes["condition"].Value : null; }
public MoveEffect(MoveEffectType type, XmlNode node) { Type = type; if (node.Attributes.Contains("message")) { Message = node.Attributes["message"].Value; } else { Message = null; } Validate(node); }
public List <MoveEffect> GetEffects(MoveEffectType effectType) { List <MoveEffect> effects = new List <MoveEffect>(); for (int i = 0; i < moveEffects.Count; i++) { if (moveEffects[i].effectType == effectType) { effects.Add(moveEffects[i]); } } return(effects); }
public LockInEffect(MoveEffectType type, XmlNode node) : base(type, node) { ConstantDamage = node.Attributes.Contains("constant-damage") ? bool.Parse(node.Attributes["constant-damage"].Value) : false; if (node.Attributes.Contains("ignore-cancel")) { IgnoreCancel = node.Attributes["ignore-cancel"].Value.Split(',').Select(s => (CancelMoveReason)Enum.Parse(typeof(CancelMoveReason), s, true)).ToArray(); } else { IgnoreCancel = null; } IgnoreMissOnLock = node.Attributes.Contains("ignore-miss-on-lock") ? bool.Parse(node.Attributes["ignore-miss-on-lock"].Value) : false; }
public StatEffect(MoveEffectType type, XmlNode node) : base(type, node) { Stat = (StatType)Enum.Parse(typeof(StatType), node.Attributes["stat"].Value.Replace("-", ""), true); Who = (Who)Enum.Parse(typeof(Who), node.Attributes["who"].Value, true); Change = node.Attributes.Contains("change") ? int.Parse(node.Attributes["change"].Value) : 0; Multiplier = node.Attributes.Contains("multiplier") ? decimal.Parse(node.Attributes["multiplier"].Value) : 1m; Chance = node.Attributes.Contains("chance") ? int.Parse(node.Attributes["chance"].Value) : 256; Temporary = node.Attributes.Contains("temporary") ? bool.Parse(node.Attributes["temporary"].Value) : false; Condition = node.Attributes.Contains("condition") ? node.Attributes["condition"].Value : null; Limit = node.Attributes.Contains("limit") ? int.Parse(node.Attributes["limit"].Value) : int.MaxValue; Constant = node.Attributes.Contains("constant") ? int.Parse(node.Attributes["constant"].Value) : 0; }
public List <EffectDatabase.MoveEff.MoveEffect> GetEffectsNew(MoveEffectType effectType, bool forceUnique = false) { List <EffectDatabase.MoveEff.MoveEffect> effects = new List <EffectDatabase.MoveEff.MoveEffect>(); for (int i = 0; i < effectsNew.Count; i++) { if (effectsNew[i].effectType == effectType) { if (!forceUnique || effectsNew[i].timing == MoveEffectTiming.Unique) { effects.Add(effectsNew[i]); } } } return(effects); }
public ExtraDamageEffect(MoveEffectType type, XmlNode node) : base(type, node) { Value = node.Attributes.Contains("value") ? int.Parse(node.Attributes["value"].Value) : 0; Percent = node.Attributes.Contains("percent") ? decimal.Parse(node.Attributes["percent"].Value) : 0m; }
public StatusRequirementEffect(MoveEffectType type, XmlNode node) : base(type, node) { Status = (StatusCondition)Enum.Parse(typeof(StatusCondition), node.Attributes["status"].Value, true); Who = (Who)Enum.Parse(typeof(Who), node.Attributes["who"].Value, true); }
protected Move(XmlNode node) { Name = node.Attributes["name"].Value; Type = Element.Elements[node.Attributes["type"].Value]; PP = int.Parse(node.Attributes["pp"].Value); if (node.Attributes.Contains("power")) { Power = int.Parse(node.Attributes["power"].Value); } else { Power = 0; } Accuracy = int.Parse(node.Attributes["accuracy"].Value); if (node.Attributes.Contains("category")) { Category = (ElementCategory)Enum.Parse(typeof(ElementCategory), node.Attributes["category"].Value, true); } else { Category = Type.Category; } if (node.Attributes.Contains("priority")) { Priority = int.Parse(node.Attributes["priority"].Value); } else { Priority = 0; } if (node.Attributes.Contains("crit-ratio")) { CritRatio = int.Parse(node.Attributes["crit-ratio"].Value); } else { CritRatio = 1; } Effects = new List <MoveEffect>(); foreach (XmlNode effect in node.ChildNodes.Cast <XmlNode>().Where(n => n.Name == "effect")) { MoveEffectType effectType = (MoveEffectType)Enum.Parse(typeof(MoveEffectType), effect.Attributes["type"].Value.Replace("-", ""), true); switch (effectType) { case MoveEffectType.Status: case MoveEffectType.ResetStatus: Effects.Add(new StatusEffect(effectType, effect)); break; case MoveEffectType.Stat: Effects.Add(new StatEffect(effectType, effect)); break; case MoveEffectType.MultiHit: case MoveEffectType.Disable: case MoveEffectType.Charge: Effects.Add(new MultiEffect(effectType, effect)); break; case MoveEffectType.LockInMove: Effects.Add(new LockInEffect(effectType, effect)); break; case MoveEffectType.CustomDamage: Effects.Add(new CustomDamageEffect(effectType, effect)); break; case MoveEffectType.Copy: Effects.Add(new CopyEffect(effectType, effect)); break; case MoveEffectType.TransferHealth: case MoveEffectType.RestoreHealth: Effects.Add(new HealthEffect(effectType, effect)); break; case MoveEffectType.ResetStatStages: case MoveEffectType.ProtectStatStages: Effects.Add(new StatStageEffect(effectType, effect)); break; case MoveEffectType.RecoilDamage: case MoveEffectType.MissDamage: Effects.Add(new ExtraDamageEffect(effectType, effect)); break; case MoveEffectType.StatusRequirement: Effects.Add(new StatusRequirementEffect(effectType, effect)); break; case MoveEffectType.PayDay: Effects.Add(new PayDayEffect(effectType, effect)); break; case MoveEffectType.NoEffect: Effects.Add(new NoEffectEffect(effectType, effect)); break; default: Effects.Add(new MoveEffect(effectType, effect)); break; } } if (Power > 0 || Effects.Any(e => e.Type == MoveEffectType.CustomDamage) || Effects.Any(e => e.Type == MoveEffectType.OneHitKO)) { if (Effects.Count == 0) { AttackType = AttackType.Damaging; } else { AttackType = AttackType.DamagingWithEffectChance; } } else if (Power <= 0) { if (Effects.Count(e => e.Type == MoveEffectType.Status && ((StatusEffect)e).Who == Who.Foe && ((StatusEffect)e).Status != StatusCondition.Paralysis) == Effects.Count) { AttackType = AttackType.NonDamaging; } else if (Effects.Count(e => e.Type == MoveEffectType.Stat && ((StatEffect)e).Who == Who.Foe) == Effects.Count) { AttackType = AttackType.NonDamaging; } else { AttackType = AttackType.None; } } }
public CopyEffect(MoveEffectType type, XmlNode node) : base(type, node) { What = node.Attributes["what"].Value; PP = node.Attributes.Contains("pp") ? int.Parse(node.Attributes["pp"].Value) : 0; }
public NoEffectEffect(MoveEffectType type, XmlNode node) : base(type, node) { Condition = Element.Elements[node.Attributes["condition"].Value]; }
public StatStageEffect(MoveEffectType type, XmlNode node) : base(type, node) { Who = (Who)Enum.Parse(typeof(Who), node.Attributes["who"].Value, true); Protect = type == MoveEffectType.ProtectStatStages; }
public PayDayEffect(MoveEffectType type, XmlNode node) : base(type, node) { Multiplier = decimal.Parse(node.Attributes["multiplier"].Value, CultureInfo.InvariantCulture); }