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