/////////////////////////////////////////////////////////////////////////////
// Name:        AbilityEffect.cpp
// Purpose:     Define an effect of an ability
// Author:      Ben Boeckel
// Modified by: Ben Boeckel
// Created:     Thu Mar 22 19:06:58 2007
// Copyright:   ©2007 Ben Boeckel and Nerdy Productions
// Licence:
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License along
//    with this program; if not, write to the Free Software Foundation, Inc.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
/////////////////////////////////////////////////////////////////////////////

#include "AbilityEffect.h"

extern PokeGen::PokeMod::Pokemod curPokeMod;

PokeGen::PokeMod::AbilityEffect::AbilityEffect(unsigned _id)
{
   LogCtor("AbilityEffect", _id);
   chance.Set(1, 1);
   effect = -1;
   val1 = -1;
   val2 = -1;
   val3 = -1;
   trigger = -1;
   tval1 = -1;
   tval2.Set(1, 1);
   id = _id;
}

PokeGen::PokeMod::AbilityEffect::AbilityEffect(Ini &ini, unsigned _id)
{
   LogCtorIni("AbilityEffect", _id);
   chance.Set(1, 1);
   effect = -1;
   val1 = -1;
   val2 = -1;
   val3 = -1;
   trigger = -1;
   tval1 = -1;
   tval2.Set(1, 1);
   ImportIni(ini, _id);
   // Big problems
   if (id == UINT_MAX)
      LogIdError("AbilityEffect");
}

PokeGen::PokeMod::AbilityEffect::~AbilityEffect()
{
   LogDtor("AbilityEffect", id);
}

#ifdef POKEMODR
void PokeGen::PokeMod::AbilityEffect::Validate(const wxListBox &output)
#else
void PokeGen::PokeMod::AbilityEffect::Validate()
#endif
{
   isValid = true;
   LogValidateStart("AbilityEffect", id);
   // TODO (Validation#1#): AbilityEffect Validation
   LogValidateOver("AbilityEffect", id, isValid);
}

void PokeGen::PokeMod::AbilityEffect::ImportIni(Ini &ini, unsigned _id)
{
   LogImportStart("AbilityEffect");
   if (_id == UINT_MAX)
   {
      ini.GetValue("id", id, UINT_MAX);
      // Was there an id associated with the element?
      if (id == UINT_MAX)
         LogIdNotFound("AbilityEffect");
   }
   else
      id = _id;
   unsigned i;
   unsigned j;
   ini.GetValue("chance-n", i, 1);
   ini.GetValue("chance-d", j, 1);
   chance.Set(i, j);
   ini.GetValue("effect", effect, -1);
   ini.GetValue("val1", val1, -1);
   ini.GetValue("val2", val2, -1);
   ini.GetValue("val3", val3, -1);
   ini.GetValue("trigger", trigger, -1);
   ini.GetValue("tval1", tval1, -1);
   ini.GetValue("tval2-n", i, 1);
   ini.GetValue("tval2-d", j, 1);
   tval2.Set(i, j);
   LogImportOver("AbilityEffect", id);
}

void PokeGen::PokeMod::AbilityEffect::ExportIni(std::ofstream &fout, const String &ability) const
{
   LogExportStart("AbilityEffect", id);
   // Make elements
   Ini exAbilityEffect(ability + " abilityEffect");
   exAbilityEffect.AddField("id", id);
   exAbilityEffect.AddField("chance-n", chance.GetNum());
   exAbilityEffect.AddField("chance-d", chance.GetDenom());
   exAbilityEffect.AddField("effect", effect);
   exAbilityEffect.AddField("val1", val1);
   exAbilityEffect.AddField("val2", val2);
   exAbilityEffect.AddField("val3", val3);
   exAbilityEffect.AddField("trigger", trigger);
   exAbilityEffect.AddField("tval1", tval1);
   exAbilityEffect.AddField("tval2-n", tval2.GetNum());
   exAbilityEffect.AddField("tval2-d", tval2.GetDenom());
   exAbilityEffect.Export(fout);
   LogExportOver("AbilityEffect", id);
}

void PokeGen::PokeMod::AbilityEffect::SetChance(const Frac &c)
{
   LogSetVar("AbilityEffect", id, "chance", c.GetNum(), c.GetDenom());
   chance = c;
}

void PokeGen::PokeMod::AbilityEffect::SetChance(unsigned n, unsigned d)
{
   LogSetVar("AbilityEffect", id, "chance", n, d);
   chance.Set(n, d);
}

void PokeGen::PokeMod::AbilityEffect::SetChanceNum(unsigned n)
{
   LogSetVar("AbilityEffect", id, "chance", n, true);
   chance.SetNum(n);
}

void PokeGen::PokeMod::AbilityEffect::SetChanceDenom(unsigned d)
{
   LogSetVar("AbilityEffect", id, "chance", d, false);
   chance.SetDenom(d);
}

void PokeGen::PokeMod::AbilityEffect::SetEffect(int e)
{
   if ((e <= AE_NONE) || (AE_END <= e))
      LogOutOfRange("AbilityEffect", id, "effect", e, "");
   else
   {
      LogSetVar("AbilityEffect", id, "effect", e);
      effect = e;
      val1 = -1;
      val2 = -1;
      val3 = -1;
   }
}

void PokeGen::PokeMod::AbilityEffect::SetEffect(const String &e)
{
   LogSetVar("AbilityEffect", id, "effect", e);
   SetEffect(FindIn(AE_END, e, AbilityEffectStr));
}

void PokeGen::PokeMod::AbilityEffect::SetVal1(int v1)
{
   switch (effect)
   {
      case AE_NONE:
      case AE_DMG_TO_HP:
      case AE_PRV_DMG:
      case AE_AUTO_HEAL:
      case AE_DEAL_DMG:
      case AE_WILDS:
      case AE_BULLSEYE:
      case AE_FAST_HATCH:
         LogNoUse("AbilityEffect", id, "val1", v1, "effect", AbilityEffectStr[effect]);
         break;
      case AE_STATS:
         if ((v1 <= BST_NONE) || (BST_END <= v1) || (curPokeMod.IsSpecialSplit() && (v1 == BST_SPECIAL_DEFENSE)))
            LogOutOfRange("AbilityEffect", id, "val1", v1, "effect", "Stat");
         else
         {
            LogSetVar("AbilityEffect", id, "val1", v1, (curPokeMod.IsSpecialSplit() ? BattleStatRBYStr : BattleStatGSCStr)[v1]);
            val1 = v1;
         }
         break;
      case AE_STATUS:
         if (curPokeMod.GetStatus(v1))
         {
            LogSetVar("AbilityEffect", id, "val1", v1, curPokeMod.GetStatus(v1)->GetName());
            val1 = v1;
         }
         else
            LogOutOfRange("AbilityEffect", id, "val1", v1, "effect", "Status");
         break;
      case AE_ABILITY:
         if (curPokeMod.GetAbility(v1))
         {
            LogSetVar("AbilityEffect", id, "val1", v1, curPokeMod.GetAbility(v1)->GetName());
            val1 = v1;
         }
         else
            LogOutOfRange("AbilityEffect", id, "val1", v1, "effect", "Ability");
         break;
      case AE_ACC_POWER:
         if ((v1 <= PA_NONE) || (PA_END <= v1))
            LogOutOfRange("AbilityEffect", id, "val1", v1, "effect", "AccPower");
         else
         {
            LogSetVar("AbilityEffect", id, "val1", v1, PowerAccStr[v1]);
            val1 = v1;
         }
         break;
      case AE_ITEM_EFFECT:
         if ((v1 <= ABIT_NONE) || (ABIT_END <= v1))
            LogOutOfRange("AbilityEffect", id, "val1", v1, "effect", "ItemEffect");
         else
         {
            LogSetVar("AbilityEffect", id, "val1", v1, AbilityItemStr[v1]);
            val1 = v1;
         }
         break;
      case AE_TYPE:
         if (curPokeMod.GetType(v1))
         {
            LogSetVar("AbilityEffect", id, "val1", v1, curPokeMod.GetType(v1)->GetName());
            val1 = v1;
         }
         else
            LogOutOfRange("AbilityEffect", id, "val1", v1, "effect", "Type");
         break;
      case AE_WEATHER:
         if ((v1 <= W_NONE) || (W_END_ALL <= v1))
            LogOutOfRange("AbilityEffect", id, "val1", v1, "effect", "Weather");
         else
         {
            LogSetVar("AbilityEffect", id, "val1", v1, StatusShowStr[v1]);
            val1 = v1;
         }
         break;
      default:
         LogNotSet("AbilityEffect", id, "val1", v1, "effect");
   }
}

void PokeGen::PokeMod::AbilityEffect::SetVal1(const String &v1)
{
   void *temp;
   switch (effect)
   {
      case AE_NONE:
      case AE_DMG_TO_HP:
      case AE_PRV_DMG:
      case AE_AUTO_HEAL:
      case AE_DEAL_DMG:
      case AE_WILDS:
      case AE_BULLSEYE:
      case AE_FAST_HATCH:
         LogNoUse("AbilityEffect", id, "val1", v1, "effect", AbilityEffectStr[effect]);
         break;
      case AE_STATS:
         SetVal1(FindIn(BST_END, v1, curPokeMod.IsSpecialSplit() ? BattleStatRBYStr : BattleStatGSCStr));
         break;
      case AE_STATUS:
         if (temp = curPokeMod.GetStatus(v1))
            SetVal1((Status *)temp->GetId());
         break;
      case AE_ABILITY:
         if (temp = curPokeMod.GetAbility(v1))
            SetVal1((Ability *)temp->GetId());
         break;
      case AE_ACC_POWER:
         SetVal1(FindIn(PA_END, v1, PowerAccStr));
         break;
      case AE_ITEM_EFFECT:
         SetVal1(FindIn(ABIT_END, v1, AbilityItemStr));
         break;
      case AE_TYPE:
         if (temp = curPokeMod.GetType(v1))
            SetVal1((Type *)temp->GetId());
         break;
      case AE_WEATHER:
         SetVal1(FindIn(W_END_ALL, v1, WeatherStr));
         break;
      default:
         LogNotSet("AbilityEffect", id, "val1", v1, "effect");
   }
}

void PokeGen::PokeMod::AbilityEffect::SetVal2(int v2)
{
   switch (effect)
   {
      case AE_DMG_TO_HP:
      case AE_PRV_DMG:
      case AE_AUTO_HEAL:
      case AE_DEAL_DMG:
      case AE_WILDS:
      case AE_ACC_POWER:
      case AE_BULLSEYE:
      case AE_ITEM_EFFECT:
      case AE_FAST_HATCH:
         LogNoUse("AbilityEffect", id, "val2", v2, "effect", AbilityEffectStr[effect]);
         break;
      case AE_STATS:
         if ((v2 <= BM_NONE) || (BM_END <= v2))
            LogOutOfRange("AbilityEffect", id, "val2", v2, "effect", "Stat");
         else
         {
            LogSetVar("AbilityEffect", id, "val2", v2, BattleMemberStr[v2]);
            val2 = v2;
         }
         break;
      case AE_STATUS:
      case AE_WEATHER:
         if ((v2 <= CA_NONE) || (CA_END <= v2))
            LogOutOfRange("AbilityEffect", id, "val2", v2, "effect", AbilityEffectStr[effect]);
         else
         {
            LogSetVar("AbilityEffect", id, "val2", v2, CauseStr[v2]);
            val2 = v2;
         }
         break;
      case AE_ABILITY:
         if ((v2 <= ABI_NONE) || (ABI_END <= v2))
            LogOutOfRange("AbilityEffect", id, "val2", v2, "effect", "Ability");
         else
         {
            LogSetVar("AbilityEffect", id, "val2", v2, AbilityInteractStr[v2]);
            val2 = v2;
         }
         break;
      case AE_TYPE:
         if ((v2 <= BO_NONE) || (BO_END <= v2))
            LogOutOfRange("AbilityEffect", id, "val2", v2, "effect", "Type");
         else
         {
            LogSetVar("AbilityEffect", id, "val2", v2, BoostStr[v2]);
            val2 = v2;
         }
         break;
      default:
         LogNotSet("AbilityEffect", id, "val2", v2, "effect");
   }
}

void PokeGen::PokeMod::AbilityEffect::SetVal2(const String &v2)
{
   switch (effect)
   {
      case AE_DMG_TO_HP:
      case AE_PRV_DMG:
      case AE_AUTO_HEAL:
      case AE_DEAL_DMG:
      case AE_WILDS:
      case AE_ACC_POWER:
      case AE_BULLSEYE:
      case AE_ITEM_EFFECT:
      case AE_FAST_HATCH:
         LogNoUse("AbilityEffect", id, "val2", v2, "effect", AbilityEffectStr[effect]);
         break;
      case AE_STATS:
         SetVal2(FindIn(BM_END, v2, BattleMemberStr));
         break;
      case AE_STATUS:
      case AE_WEATHER:
         SetVal2(FindIn(CA_END, v2, CauseStr));
         break;
      case AE_ABILITY:
         SetVal2(FindIn(ABI_END, v2, AbilityInteractStr));
         break;
      case AE_TYPE:
         SetVal2(FindIn(BO_END, v2, BoostStr));
         break;
      default:
         LogNotSet("AbilityEffect", id, "val2", v2, "effect");
   }
}

void PokeGen::PokeMod::AbilityEffect::SetVal3(int v3)
{
   switch (effect)
   {
      case AE_DMG_TO_HP:
      case AE_PRV_DMG:
      case AE_AUTO_HEAL:
      case AE_DEAL_DMG:
      case AE_WILDS:
      case AE_ACC_POWER:
      case AE_TYPE:
      case AE_FAST_HATCH:
         if ((v3 < 0) || (100 < v3))
            LogOutOfRange("AbilityEffect", id, "val3", v3, "effect", AbilityEffectStr[effect]);
         else
         {
            LogSetVar("AbilityEffect", id, "val3", v3);
            val3 = v3;
         }
         break;
      case AE_STATS:
         if ((v3 < -6) || (6 < v3))
            LogOutOfRange("AbilityEffect", id, "val3", v3, "effect", "Stat");
         else
         {
            LogSetVar("AbilityEffect", id, "val3", v3);
            val3 = v3;
         }
         break;
      case AE_STATUS:
      case AE_ABILITY:
      case AE_BULLSEYE:
      case AE_ITEM_EFFECT:
      case AE_WEATHER:
         LogNoUse("AbilityEffect", id, "val3", v3, "effect", AbilityEffectStr[effect]);
         break;
      default:
         LogNotSet("AbilityEffect", id, "val3", v3, "effect");
   }
}

void PokeGen::PokeMod::AbilityEffect::SetTrigger(int t)
{
   if ((t <= AT_NONE) || (AT_END <= t))
      LogOutOfRange("AbilityEffect", id, "trigger", t, "");
   else
   {
      LogSetVar("AbilityEffect", id, "trigger", t);
      trigger = t;
      tval1 = -1;
      tval2.Set(1, 1);
   }
}

void PokeGen::PokeMod::AbilityEffect::SetTrigger(const String &t)
{
   SetTrigger(FindIn(AT_END, t, AbilityTriggerStr));
}

void PokeGen::PokeMod::AbilityEffect::SetTval1(int tv1)
{
   switch (trigger)
   {
      case AT_ANYTHING:
      case AT_CONTACT:
      case AT_DMG:
         LogNoUse("AbilityEffect", id, "tVal1", tv1, "trigger", AbilityTriggerStr[effect]);
         break;
      case AT_WEATHER:
         if ((tv1 <= W_NONE) || (W_END_ALL <= tv1))
            LogOutOfRange("AbilityEffect", id, "tVal1", tv1, "trigger", "Weather");
         else
         {
            LogSetVar("AbilityEffect", id, "tVal1", tv1, WeatherStr[tv1]);
            tval1 = tv1;
         }
         break;
      case AT_TYPE:
         if (curPokeMod.GetType(tv1))
         {
            LogSetVar("AbilityEffect", id, "tVal1", tv1, curPokeMod.GetType(tv1)->GetName());
            tval1 = tv1;
         }
         else
            LogOutOfRange("AbilityEffect", id, "tVal1", tv1, "trigger", "Type");
         break;
      case AT_HP_BOUND:
         if ((tv1 <= SI_NONE) || (SI_END <= tv1))
            LogOutOfRange("AbilityEffect", id, "tVal1", tv1, "trigger", "HPBound");
         else
         {
            LogSetVar("AbilityEffect", id, "tVal1", tv1, SideStr[tv1]);
            tval1 = tv1;
         }
         break;
      case AT_STAT_CHANGE:
         if ((tv1 <= BST_NONE) || (BST_END <= tv1) || (curPokeMod.IsSpecialSplit() && (tv1 == BST_SPECIAL_DEFENSE)))
            LogOutOfRange("AbilityEffect", id, "tVal1", tv1, "trigger", "Stat");
         else
         {
            LogSetVar("AbilityEffect", id, "tVal1", tv1, (curPokeMod.IsSpecialSplit() ? BattleStatRBYStr : BattleStatGSCStr)[tv1]);
            tval1 = tv1;
         }
         break;
      case AT_STATUS:
         if (curPokeMod.GetStatus(tv1))
         {
            LogSetVar("AbilityEffect", id, "tVal1", tv1, curPokeMod.GetStatus(tv1)->GetName());
            tval1 = tv1;
         }
         else
            LogOutOfRange("AbilityEffect", id, "tVal1", tv1, "trigger", "Status");
         break;
      default:
         LogNotSet("AbilityEffect", id, "tVal1", tv1, "trigger");
   }
}

void PokeGen::PokeMod::AbilityEffect::SetTval1(const String &tv1)
{
   void *temp;
   switch (trigger)
   {
      case AT_ANYTHING:
      case AT_CONTACT:
      case AT_DMG:
         LogNoUse("AbilityEffect", id, "tVal1", tv1, "trigger", AbilityTriggerStr[effect]);
         break;
      case AT_WEATHER:
         SetTval1(FindIn(W_END_ALL, tv1, WeatherStr));
         break;
      case AT_TYPE:
         if (temp = curPokeMod.GetType(tv1))
            SetTval1((Type *)temp->GetId());
         break;
      case AT_HP_BOUND:
         SetTval1(FindIn(SI_END, tv1, SideStr));
         break;
      case AT_STAT_CHANGE:
         SetTval1(FindIn(BST_END, tv1, curPokeMod.IsSpecialSplit() ? BattleStatRBYStr : BattleStatGSCStr));
         break;
      case AT_STATUS:
         if (temp = curPokeMod.GetStatus(tv1))
            SetTval1((Status *)temp->GetId());
         break;
      default:
         LogNotSet("AbilityEffect", id, "tVal1", tv1, "trigger");
   }
}

void PokeGen::PokeMod::AbilityEffect::SetTval2(const Frac &tv2)
{
   switch (trigger)
   {
      case AT_ANYTHING:
      case AT_CONTACT:
      case AT_WEATHER:
      case AT_DMG:
      case AT_TYPE:
      case AT_STAT_CHANGE:
      case AT_STATUS:
         LogNoUse("AbilityEffect", id, "tVal2", LONG_MAX, "trigger", AbilityTriggerStr[effect]);
         break;
      case AT_HP_BOUND:
         tval2 = tv2;
         break;
      default:
         LogNotSet("AbilityEffect", id, "tVal2", LONG_MAX, "trigger");
   }
}

void PokeGen::PokeMod::AbilityEffect::SetTval2(unsigned n, unsigned d)
{
   switch (trigger)
   {
      case AT_ANYTHING:
      case AT_CONTACT:
      case AT_WEATHER:
      case AT_DMG:
      case AT_TYPE:
      case AT_STAT_CHANGE:
      case AT_STATUS:
         LogNoUse("AbilityEffect", id, "tVal2", LONG_MAX, "trigger", AbilityTriggerStr[effect]);
         break;
      case AT_HP_BOUND:
         tval2.Set(n, d);
         break;
      default:
         LogNotSet("AbilityEffect", id, "tVal2", LONG_MAX, "trigger");
   }
}

void PokeGen::PokeMod::AbilityEffect::SetTval2Num(unsigned n)
{
   switch (trigger)
   {
      case AT_ANYTHING:
      case AT_CONTACT:
      case AT_WEATHER:
      case AT_DMG:
      case AT_TYPE:
      case AT_STAT_CHANGE:
      case AT_STATUS:
         LogNoUse("AbilityEffect", id, "tVal2 numerator", n, "trigger", AbilityTriggerStr[effect]);
         break;
      case AT_HP_BOUND:
         tval2.SetNum(n);
         break;
      default:
         LogNotSet("AbilityEffect", id, "tVal2 numerator", n, "trigger");
   }
}

void PokeGen::PokeMod::AbilityEffect::SetTval2Denom(unsigned d)
{
   switch (trigger)
   {
      case AT_ANYTHING:
      case AT_CONTACT:
      case AT_WEATHER:
      case AT_DMG:
      case AT_TYPE:
      case AT_STAT_CHANGE:
      case AT_STATUS:
         LogNoUse("AbilityEffect", id, "tVal2 denominator", d, "trigger", AbilityTriggerStr[effect]);
         break;
      case AT_HP_BOUND:
         tval2.SetDenom(d);
         break;
      default:
         LogNotSet("AbilityEffect", id, "tVal2 denominator", d, "trigger");
   }
}

PokeGen::PokeMod::PMFrac PokeGen::PokeMod::AbilityEffect::GetChance() const
{
   LogFetchVar("AbilityEffect", id, "chance");
   return chance;
}

unsigned PokeGen::PokeMod::AbilityEffect::GetChanceNum() const
{
   LogFetchVar("AbilityEffect", id, "chance numerator", chance.GetNum());
   return chance.GetNum();
}

unsigned PokeGen::PokeMod::AbilityEffect::GetChanceDenom() const
{
   LogFetchVar("AbilityEffect", id, "chance denominator", chance.GetDenom());
   return chance.GetDenom();
}

int PokeGen::PokeMod::AbilityEffect::GetEffect() const
{
   LogFetchVar("AbilityEffect", id, "effect", effect);
   return effect;
}

PokeGen::PokeMod::String PokeGen::PokeMod::AbilityEffect::GetEffectString() const
{
   LogFetchVar("AbilityEffect", id, "effect string", effect);
   if ((effect <= AE_NONE) || (AE_END <= effect))
      return "";
   else
      return AbilityEffectStr[effect];
}

int PokeGen::PokeMod::AbilityEffect::GetVal1() const
{
   LogFetchVar("AbilityEffect", id, "val1", val1);
   return val1;
}

PokeGen::PokeMod::String PokeGen::PokeMod::AbilityEffect::GetVal1String() const
{
   LogFetchVar("AbilityEffect", id, "val1 string", val1);
   String ret = "";
   switch (effect)
   {
      case AE_STATS:
         if ((BST_NONE < val1) && (val1 < BST_END))
            ret = (curPokeMod.IsSpecialSplit() ? BattleStatRBYStr : BattleStatGSCStr)[val1];
         break;
      case AE_STATUS:
         if (curPokeMod.GetStatus(val1))
            ret = curPokeMod.GetStatus(val1)->GetName();
         break;
      case AE_ABILITY:
         if (curPokeMod.GetAbility(val1))
            ret = curPokeMod.GetAbility(val1)->GetName();
         break;
      case AE_ACC_POWER:
         if ((PA_NONE < val1) || (val1 < PA_END))
            ret = PowerAccStr[val1];
         break;
      case AE_ITEM_EFFECT:
         if ((ABIT_NONE < val1) || (val1 < ABIT_END))
            ret = AbilityItemStr[val1];
         break;
      case AE_TYPE:
         if (curPokeMod.GetType(val1))
            ret = curPokeMod.GetType(val1)->GetName();
         break;
      case AE_WEATHER:
         if ((W_NONE < val1) || (val1 < W_END_ALL))
            ret = StatusShowStr[val1];
   }
   return ret;
}

int PokeGen::PokeMod::AbilityEffect::GetVal2() const
{
   LogFetchVar("AbilityEffect", id, "val2", val2);
   return val2;
}

PokeGen::PokeMod::String PokeGen::PokeMod::AbilityEffect::GetVal2String() const
{
   LogFetchVar("AbilityEffect", id, "val2 string", val2);
   String ret = "";
   switch (effect)
   {
      case AE_STATS:
         if ((BM_NONE < val2) && (val2 < BM_END))
            ret = BattleMemberStr[val2];
         break;
      case AE_STATUS:
      case AE_WEATHER:
         if ((CA_NONE < val2) && (val2 < CA_END))
            ret = CauseStr[val2];
         break;
      case AE_ABILITY:
         if ((ABI_NONE < val2) && (val2 < ABI_END))
            ret = AbilityInteractStr[val2];
         break;
      case AE_TYPE:
         if ((BO_NONE < val2) && (val2 < BO_END))
            ret = BoostStr[val2];
   }
   return ret;
}

int PokeGen::PokeMod::AbilityEffect::GetVal3() const
{
   LogFetchVar("AbilityEffect", id, "val3", val3);
   return val3;
}

int PokeGen::PokeMod::AbilityEffect::GetTrigger() const
{
   LogFetchVar("AbilityEffect", id, "trigger", trigger);
   return trigger;
}

PokeGen::PokeMod::String PokeGen::PokeMod::AbilityEffect::GetTriggerString() const
{
   LogFetchVar("AbilityEffect", id, "trigger string", trigger);
   if ((trigger <= AT_NONE) || (AT_END <= trigger))
      return "";
   else
      return AbilityTriggerStr[trigger];
}

int PokeGen::PokeMod::AbilityEffect::GetTval1() const
{
   LogFetchVar("AbilityEffect", id, "tVal1", tval1);
   return tval1;
}

PokeGen::PokeMod::String PokeGen::PokeMod::AbilityEffect::GetTval1String() const
{
   LogFetchVar("AbilityEffect", id, "tVal1 string", tval1);
   String ret = "";
   switch (trigger)
   {
      case AT_WEATHER:
         if ((W_NONE < tval1) && (tval1 < W_END_ALL))
            ret = WeatherStr[tval1];
         break;
      case AT_TYPE:
         if (curPokeMod.GetType(tval1))
            ret = curPokeMod.GetType(tval1)->GetName();
         break;
      case AT_HP_BOUND:
         if ((SI_NONE < tval1) && (tval1 < SI_END))
            ret = SideStr[tval1];
         break;
      case AT_STAT_CHANGE:
         if ((BST_NONE < tval1) && (tval1 < BST_END))
            ret = (curPokeMod.IsSpecialSplit() ? BattleStatRBYStr : BattleStatGSCStr)[tval1];
         break;
      case AT_STATUS:
         if (curPokeMod.GetStatus(tval1))
            ret = curPokeMod.GetStatus(tval1)->GetName();
   }
   return ret;
}

PokeGen::PokeMod::Frac PokeGen::PokeMod::AbilityEffect::GetTval2() const
{
   switch (trigger)
   {
      case AT_ANYTHING:
      case AT_CONTACT:
      case AT_WEATHER:
      case AT_DMG:
      case AT_TYPE:
      case AT_STAT_CHANGE:
      case AT_STATUS:
         LogNoUse("AbilityEffect", id, "tVal2", LONG_MAX, "trigger", AbilityTriggerStr[trigger]);
         break;
      case AT_HP_BOUND:
         LogFetchVar("AbilityEffect", id, "tVal2");
         break;
      default:
         LogNotSet("AbilityEffect", id, "tVal2", LONG_MAX, "trigger");
   }
   return tval2;
}

unsigned PokeGen::PokeMod::AbilityEffect::GetTval2Num() const
{
   switch (trigger)
   {
      case AT_ANYTHING:
      case AT_CONTACT:
      case AT_WEATHER:
      case AT_DMG:
      case AT_TYPE:
      case AT_STAT_CHANGE:
      case AT_STATUS:
         LogNoUse("AbilityEffect", id, "tVal2 numerator", LONG_MAX, "trigger", AbilityTriggerStr[trigger]);
         break;
      case AT_HP_BOUND:
         LogFetchVar("AbilityEffect", id, "tVal2", tval2.GetNum());
         return tval2.GetNum();
      default:
         LogNotSet("AbilityEffect", id, "tVal2 numerator", LONG_MAX, "trigger");
   }
   return 0;
}

unsigned PokeGen::PokeMod::AbilityEffect::GetTval2Denom() const
{
   switch (trigger)
   {
      case AT_ANYTHING:
      case AT_CONTACT:
      case AT_WEATHER:
      case AT_DMG:
      case AT_TYPE:
      case AT_STAT_CHANGE:
      case AT_STATUS:
         LogNoUse("AbilityEffect", id, "tVal2 denominator", LONG_MAX, "trigger", AbilityTriggerStr[trigger]);
         break;
      case AT_HP_BOUND:
         LogFetchVar("AbilityEffect", id, "tVal2", tval2.GetDenom());
         return tval2.GetDenom();
      default:
         LogNotSet("AbilityEffect", id, "tVal2 denominator", LONG_MAX, "trigger");
   }
   return 0;
}