From 3595239f08f2bc1df32ef22ed6de9bde10ca3384 Mon Sep 17 00:00:00 2001
From: Ben Boeckel <MathStuf@gmail.com>
Date: Mon, 4 Jun 2007 01:35:20 +0000
Subject: Style cleanup, minor Matrix fixes, duplication validations, Pokemod
 methods

git-svn-id: https://pokegen.svn.sourceforge.net/svnroot/pokegen/trunk@19 6ecfd1a5-f3ed-3746-8530-beee90d26b22
---
 pokemod/Pokemod.cpp | 2611 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 2607 insertions(+), 4 deletions(-)

(limited to 'pokemod/Pokemod.cpp')

diff --git a/pokemod/Pokemod.cpp b/pokemod/Pokemod.cpp
index 4799fd89..615fb565 100644
--- a/pokemod/Pokemod.cpp
+++ b/pokemod/Pokemod.cpp
@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        pokemod/Pokemod.cpp
-// Purpose:
+// Purpose:     Define a custom PokéMod for PokéGen
 // Author:      Ben Boeckel
 // Modified by: Ben Boeckel
 // Created:     Sat Feb 24 21:41:19 2007
@@ -23,7 +23,54 @@
 
 #include "Pokemod.h"
 
-PokeGen::PokeMod::Pokemod::Pokemod()
+PokeGen::PokeMod::Pokemod::Pokemod() :
+      title(""),
+      version(""),
+      description(""),
+      genderAllowed(false),
+      breedingAllowed(false),
+      eggSpecies(UINT_MAX),
+      holdItems(false),
+      criticalDomains(false),
+      contestAllowed(false),
+      abilityAllowed(false),
+      natureAllowed(false),
+      numDaycares(0),
+      numPokemonBoxes(0),
+      numPokemonPerBox(1),
+      maxParty(1),
+      maxFight(1),
+      maxMoves(1),
+      maxLevel(1),
+      maxMoney(0),
+      hardCash(false),
+      specialSplit(false),
+      specialDVSplit(false),
+      maxDVValue(16),
+      happiness(false),
+      happyFaintLoss(0),
+      happyLevelGain(0),
+      happySteps(0),
+      effortValuesAllowed(false),
+      maxTotalEV(0),
+      maxEVPerStat(0),
+      pokerusChance(1, 1),
+      startMap(UINT_MAX),
+      startMoney(0),
+      startCoordinate(0, 0),
+      startDirection(UINT_MAX),
+      startDialog(UINT_MAX),
+      walkSkin(""),
+      bikeSkin(""),
+      surfSkin(""),
+      flySkin(""),
+      fishSkin(""),
+      surfFishSkin(""),
+      superPCUname(""),
+      superPCPasswd(""),
+      struggleMove(UINT_MAX),
+      confuseMove(UINT_MAX),
+      typeChart(1, 1, Frac(1, 1, true))
 {
    LogCtor("Pokemod", 0);
 }
@@ -43,6 +90,7 @@ void PokeGen::PokeMod::Pokemod::Validate()
 {
    LogValidateStart("Pokemod", 0);
    // TODO (Validation#1#): Pokemod Validation
+#  warning "Pokemod Validation"
    LogValidateOver("Pokemod", 0, isValid);
 }
 
@@ -55,10 +103,2565 @@ void PokeGen::PokeMod::Pokemod::Validate(const wxListBox &output)
 
 void PokeGen::PokeMod::Pokemod::ImportIni(std::ifstream &fin)
 {
-   // TODO (Ini#1#): Import Pokemod
+   LogImportStart("Pokemod");
+   std::vector<Ini> sections;
+   Ini meta("unset");
+   while (fin.peek() != '\n')
+   {
+      Ini curSection(fin);
+      if (curSection.GetName() == "pokemod")
+      {
+         if (meta.GetName() == "unset")
+         {
+            Log(String("Pokemod: Multiple meta data sections in PokéMod file"), PM_DEBUG_ERROR);
+            return;
+         }
+         meta = curSection;
+         unsigned i;
+         unsigned j;
+         curSection.GetValue("title", title);
+         curSection.GetValue("version", version);
+         curSection.GetValue("description", description);
+         curSection.GetValue("genderAllowed", genderAllowed, false);
+         curSection.GetValue("breedingAllowed", breedingAllowed, false);
+         curSection.GetValue("eggSpecies", eggSpecies);
+         curSection.GetValue("holdItems", holdItems, false);
+         curSection.GetValue("criticalDomains", criticalDomains, false);
+         curSection.GetValue("contestAllowed", contestAllowed, false);
+         curSection.GetValue("abilityAllowed", abilityAllowed, false);
+         curSection.GetValue("natureAllowed", natureAllowed, false);
+         curSection.GetValue("numDaycares", numDaycares, 0);
+         curSection.GetValue("numPokemonBoxes", numPokemonBoxes, 0);
+         curSection.GetValue("numPokemonPerBox", numPokemonPerBox, 1);
+         curSection.GetValue("maxParty", maxParty, 1);
+         curSection.GetValue("maxFight", maxFight, 1);
+         curSection.GetValue("maxMoves", maxMoves, 1);
+         curSection.GetValue("maxLevel", maxLevel, 0);
+         curSection.GetValue("maxMoney", maxMoney, 0);
+         curSection.GetValue("hardCash", hardCash, false);
+         curSection.GetValue("specialSplit", specialSplit, false);
+         curSection.GetValue("specialDVSplit", specialDVSplit, false);
+         curSection.GetValue("maxDVValue", maxDVValue, 16);
+         curSection.GetValue("happiness", happiness, false);
+         curSection.GetValue("happyFaintLoss", happyFaintLoss, 0);
+         curSection.GetValue("happyLevelGain", happyLevelGain, 0);
+         curSection.GetValue("happySteps", happySteps, 0);
+         curSection.GetValue("effortValuesAllowed", effortValuesAllowed, false);
+         curSection.GetValue("maxTotalEV", maxTotalEV, 0);
+         curSection.GetValue("maxEVPerStat", maxEVPerStat, 0);
+         curSection.GetValue("pokerusChance-n", i, 1);
+         curSection.GetValue("pokerusChance-d", j, 1);
+         pokerusChance.Set(i, j);
+         curSection.GetValue("startMap", startMap);
+         curSection.GetValue("startMoney", startMoney, 0);
+         curSection.GetValue("startCoordinate-x", i, 0);
+         curSection.GetValue("startCoordinate-y", j, 0);
+         startCoordinate.Set(i, j);
+         curSection.GetValue("startDirection", startDirection);
+         curSection.GetValue("startDialog", startDialog);
+         curSection.GetValue("walkSkin", walkSkin);
+         curSection.GetValue("bikeSkin", bikeSkin);
+         curSection.GetValue("surfSkin", surfSkin);
+         curSection.GetValue("flySkin", flySkin);
+         curSection.GetValue("fishSkin", fishSkin);
+         curSection.GetValue("surfFishSkin", surfFishSkin);
+         curSection.GetValue("superPCUname", superPCUname);
+         curSection.GetValue("superPCPasswd", superPCPasswd);
+         curSection.GetValue("struggleMove", struggleMove);
+         curSection.GetValue("confuseMove", confuseMove);
+      }
+      else if (curSection.GetName() == "ability")
+         NewAbility(&curSection);
+      else if (curSection.GetName() == "author")
+         NewAuthor(&curSection);
+      else if (curSection.GetName() == "badge")
+         NewBadge(&curSection);
+      else if (curSection.GetName() == "coinList")
+         NewCoinList(&curSection);
+      else if (curSection.GetName() == "dialog")
+         NewDialog(&curSection);
+      else if (curSection.GetName() == "eggGroup")
+         NewEggGroup(&curSection);
+      else if (curSection.GetName() == "item")
+         NewItem(&curSection);
+      else if (curSection.GetName() == "itemStorage")
+         NewItemStorage(&curSection);
+      else if (curSection.GetName() == "map")
+         NewMap(&curSection);
+      else if (curSection.GetName() == "move")
+         NewMove(&curSection);
+      else if (curSection.GetName() == "nature")
+         NewNature(&curSection);
+      else if (curSection.GetName() == "pokemon")
+         NewPokemon(&curSection);
+      else if (curSection.GetName() == "status")
+         NewStatus(&curSection);
+      else if (curSection.GetName() == "store")
+         NewStore(&curSection);
+      else if (curSection.GetName() == "tile")
+         NewTile(&curSection);
+      else if (curSection.GetName() == "time")
+         NewTime(&curSection);
+      else if (curSection.GetName() == "type")
+         NewType(&curSection);
+      else
+         sections.push_back(curSection);
+   }
+   if (meta.GetName() == "unset")
+   {
+      Log(String("Pokemod: No meta data found in PokéMod file"), PM_DEBUG_ERROR);
+      return;
+   }
+   for (std::vector<Type>::iterator i = types.begin(); i != types.end(); ++i)
+   {
+      for (std::vector<Type>::iterator j = types.begin(); j != types.end(); ++j)
+      {
+         unsigned k;
+         unsigned l;
+         meta.GetValue(String("typeChart-%u-%u-n", i->GetId(), j->GetId()), k, 1);
+         meta.GetValue(String("typeChart-%u-%u-d", i->GetId(), j->GetId()), l, 1);
+         SetTypeChart(i->GetId(), j->GetId(), k, l);
+      }
+   }
+   std::stringstream ss;
+   std::string s;
+   std::string s1;
+   unsigned u;
+   for (std::vector<Ini>::iterator i = sections.begin(); i != sections.end(); ++i)
+   {
+      ss.write(i->GetName().c_str(), i->GetName().length());
+      ss >> s;
+      ss >> s1;
+      if (s == "abilityEffect")
+      {
+         if (Ability *a = (Ability *)GetAbility(s1))
+            a->NewAbilityEffect(&*i);
+         sections.erase(i);
+      }
+      else if (s == "coinItem")
+      {
+         if (CoinList *c = (CoinList *)GetCoinList(s1))
+            c->NewCoinItem(&*i);
+         sections.erase(i);
+      }
+      else if (s == "itemEffect")
+      {
+         if (Item *it = (Item *)GetItem(s1))
+            it->NewItemEffect(&*i);
+         sections.erase(i);
+      }
+      else if (s == "mapEffect")
+      {
+         if (Map *m = (Map *)GetMap(s1))
+            m->NewMapEffect(&*i);
+         sections.erase(i);
+      }
+      else if (s == "mapTrainer")
+      {
+         if (Map *m = (Map *)GetMap(s1))
+            m->NewMapTrainer(&*i);
+         sections.erase(i);
+      }
+      else if (s == "mapWarp")
+      {
+         if (Map *m = (Map *)GetMap(s1))
+            m->NewMapWarp(&*i);
+         sections.erase(i);
+      }
+      else if (s == "mapWildList")
+      {
+         if (Map *m = (Map *)GetMap(s1))
+            m->NewMapWildList(&*i);
+         sections.erase(i);
+      }
+      else if (s == "moveEffect")
+      {
+         if (Move *m = (Move *)GetMove(s1))
+            m->NewMoveEffect(&*i);
+         sections.erase(i);
+      }
+      else if (s == "natureEffect")
+      {
+         if (Nature *n = (Nature *)GetNature(s1))
+            n->NewNatureEffect(&*i);
+         sections.erase(i);
+      }
+      else if (s == "pokemonAbility")
+      {
+         if (Pokemon *p = (Pokemon *)GetPokemon(s1))
+            p->NewPokemonAbility(&*i);
+         sections.erase(i);
+      }
+      else if (s == "pokemonEvolution")
+      {
+         if (Pokemon *p = (Pokemon *)GetPokemon(s1))
+            p->NewPokemonEvolution(&*i);
+         sections.erase(i);
+      }
+      else if (s == "pokemonItem")
+      {
+         if (Pokemon *p = (Pokemon *)GetPokemon(s1))
+            p->NewPokemonItem(&*i);
+         sections.erase(i);
+      }
+      else if (s == "pokemonMove")
+      {
+         if (Pokemon *p = (Pokemon *)GetPokemon(s1))
+            p->NewPokemonMove(&*i);
+         sections.erase(i);
+      }
+      else if (s == "pokemonNature")
+      {
+         if (Pokemon *p = (Pokemon *)GetPokemon(s1))
+            p->NewPokemonNature(&*i);
+         sections.erase(i);
+      }
+      else if (s == "statusEffect")
+      {
+         if (Status *st = (Status *)GetStatus(s1))
+            st->NewStatusEffect(&*i);
+         sections.erase(i);
+      }
+      ss.clear();
+   }
+   for (std::vector<Ini>::iterator i = sections.begin(); i != sections.end(); ++i)
+   {
+      if (s == "mapTrainerTeam")
+      {
+         ss >> u;
+         if (const Map *m = GetMap(s1))
+         {
+            if (MapTrainer *t = (MapTrainer *)m->GetMapTrainer(u))
+               t->NewMapTrainerTeam(&*i);
+         }
+         sections.erase(i);
+      }
+      else if (s == "mapWildPokemon")
+      {
+         ss >> u;
+         if (const Map *m = GetMap(s1))
+         {
+            if (MapWildList *t = (MapWildList *)m->GetMapWildList(u))
+               t->NewMapWildPokemon(&*i);
+         }
+         sections.erase(i);
+      }
+   }
+   for (std::vector<Ini>::iterator i = sections.begin(); i != sections.end(); ++i)
+      Log(String("Pokemod: Unused INI section named \"%s\"", i->GetName().c_str()), PM_DEBUG_INFO);
+   LogImportOver("Pokemod", 0, title);
 }
 
 void PokeGen::PokeMod::Pokemod::ExportIni(std::ofstream &fout) const
 {
-   // TODO (Ini#1#): Export Pokemod
+   LogExportStart("Pokemod", 0, title);
+   Ini exPokemod("pokemod");
+   exPokemod.AddField("title", title);
+   exPokemod.AddField("version", version);
+   exPokemod.AddField("description", description);
+   exPokemod.AddField("genderAllowed", genderAllowed);
+   exPokemod.AddField("breedingAllowed", breedingAllowed);
+   exPokemod.AddField("eggSpecies", eggSpecies);
+   exPokemod.AddField("holdItems", holdItems);
+   exPokemod.AddField("criticalDomains", criticalDomains);
+   exPokemod.AddField("contestAllowed", contestAllowed);
+   exPokemod.AddField("abilityAllowed", abilityAllowed);
+   exPokemod.AddField("natureAllowed", natureAllowed);
+   exPokemod.AddField("numDaycares", numDaycares);
+   exPokemod.AddField("numPokemonBoxes", numPokemonBoxes);
+   exPokemod.AddField("numPokemonPerBox", numPokemonPerBox);
+   exPokemod.AddField("maxParty", maxParty);
+   exPokemod.AddField("maxFight", maxFight);
+   exPokemod.AddField("maxMoves", maxMoves);
+   exPokemod.AddField("maxLevel", maxLevel);
+   exPokemod.AddField("maxMoney", maxMoney);
+   exPokemod.AddField("hardCash", hardCash);
+   exPokemod.AddField("specialSplit", specialSplit);
+   exPokemod.AddField("specialDVSplit", specialDVSplit);
+   exPokemod.AddField("maxDVValue", maxDVValue);
+   exPokemod.AddField("happiness", happiness);
+   exPokemod.AddField("happyFaintLoss", happyFaintLoss);
+   exPokemod.AddField("happyLevelGain", happyLevelGain);
+   exPokemod.AddField("happySteps", happySteps);
+   exPokemod.AddField("effortValuesAllowed", effortValuesAllowed);
+   exPokemod.AddField("maxTotalEV", maxTotalEV);
+   exPokemod.AddField("maxEVPerStat", maxEVPerStat);
+   exPokemod.AddField("pokerusChance-n", pokerusChance.GetNum());
+   exPokemod.AddField("pokerusChance-d", pokerusChance.GetDenom());
+   exPokemod.AddField("startMap", startMap);
+   exPokemod.AddField("startMoney", startMoney);
+   exPokemod.AddField("startCoordinate-x", startCoordinate.GetX());
+   exPokemod.AddField("startCoordinate-y", startCoordinate.GetY());
+   exPokemod.AddField("startDirection", startDirection);
+   exPokemod.AddField("startDialog", startDialog);
+   exPokemod.AddField("walkSkin", walkSkin);
+   exPokemod.AddField("bikeSkin", bikeSkin);
+   exPokemod.AddField("surfSkin", surfSkin);
+   exPokemod.AddField("flySkin", flySkin);
+   exPokemod.AddField("fishSkin", fishSkin);
+   exPokemod.AddField("surfFishSkin", surfFishSkin);
+   exPokemod.AddField("superPCUname", superPCUname);
+   exPokemod.AddField("superPCPasswd", superPCPasswd);
+   exPokemod.AddField("struggleMove", struggleMove);
+   exPokemod.AddField("confuseMove", confuseMove);
+   for (unsigned i = 1; i < typeChart.GetWidth(); ++i)
+   {
+      for (unsigned j = 1; j < typeChart.GetHeight(); ++j)
+      {
+         exPokemod.AddField(String("typeChart-%u-%u-n", typeChart[i][0].GetNum(), typeChart[0][j].GetNum()), typeChart[i][j].GetNum());
+         exPokemod.AddField(String("typeChart-%u-%u-d", typeChart[i][0].GetNum(), typeChart[0][j].GetNum()), typeChart[i][j].GetDenom());
+      }
+   }
+   exPokemod.Export(fout);
+   for (std::vector<Ability>::const_iterator i = abilities.begin(); i != abilities.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Author>::const_iterator i = authors.begin(); i != authors.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Badge>::const_iterator i = badges.begin(); i != badges.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<CoinList>::const_iterator i = coinLists.begin(); i != coinLists.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Dialog>::const_iterator i = dialogs.begin(); i != dialogs.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<EggGroup>::const_iterator i = eggGroups.begin(); i != eggGroups.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Item>::const_iterator i = items.begin(); i != items.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<ItemStorage>::const_iterator i = itemStorages.begin(); i != itemStorages.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Map>::const_iterator i = maps.begin(); i != maps.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Move>::const_iterator i = moves.begin(); i != moves.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Nature>::const_iterator i = natures.begin(); i != natures.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Pokemon>::const_iterator i = pokemon.begin(); i != pokemon.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Status>::const_iterator i = statuses.begin(); i != statuses.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Store>::const_iterator i = stores.begin(); i != stores.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Tile>::const_iterator i = tiles.begin(); i != tiles.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Time>::const_iterator i = times.begin(); i != times.end(); ++i)
+      i->ExportIni(fout);
+   for (std::vector<Type>::const_iterator i = types.begin(); i != types.end(); ++i)
+      i->ExportIni(fout);
+   LogExportOver("Pokemod", 0, title);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTitle(const String &t)
+{
+   LogSetVar("Pokemod", 0, "title", t);
+   title = t;
+}
+
+void PokeGen::PokeMod::Pokemod::SetVersion(const String &v)
+{
+   LogSetVar("Pokemod", 0, "version", v);
+   version = v;
+}
+
+void PokeGen::PokeMod::Pokemod::SetDescription(const String &d)
+{
+   LogSetVar("Pokemod", 0, "description", d);
+   description = d;
+}
+
+void PokeGen::PokeMod::Pokemod::SetIsGenderAllowed(const bool g)
+{
+   LogSetVar("Pokemod", 0, "genderAllowed", g);
+   genderAllowed = g;
+}
+
+void PokeGen::PokeMod::Pokemod::SetIsBreedingAllowed(const bool b)
+{
+   LogSetVar("Pokemod", 0, "breedingAllowed", b);
+   breedingAllowed = b;
+}
+
+void PokeGen::PokeMod::Pokemod::SetEggSpecies(const unsigned e)
+{
+   LogSetVar("Pokemod", 0, "eggSpecies", e);
+   if (GetPokemon(e))
+      eggSpecies = e;
+}
+
+void PokeGen::PokeMod::Pokemod::SetEggSpecies(const String &e)
+{
+   LogSetVar("Pokemod", 0, "eggSpecies string", e);
+   if (const Pokemon *p = GetPokemon(e))
+      eggSpecies = p->GetId();
+}
+
+void PokeGen::PokeMod::Pokemod::SetCanHoldItems(const bool h)
+{
+   LogSetVar("Pokemod", 0, "holdItems", h);
+   holdItems = h;
+}
+
+void PokeGen::PokeMod::Pokemod::SetHasCriticalDomains(const bool c)
+{
+   LogSetVar("Pokemod", 0, "criticalDomains", c);
+   criticalDomains = c;
+}
+
+void PokeGen::PokeMod::Pokemod::SetIsContestAllowed(const bool c)
+{
+   LogSetVar("Pokemod", 0, "contestAllowed", c);
+   contestAllowed = c;
+}
+
+void PokeGen::PokeMod::Pokemod::SetIsAbilityAllowed(const bool a)
+{
+   LogSetVar("Pokemod", 0, "abilityAllowed", a);
+   abilityAllowed = a;
+}
+
+void PokeGen::PokeMod::Pokemod::SetIsNatureAllowed(const bool n)
+{
+   LogSetVar("Pokemod", 0, "natureAllowed", n);
+   natureAllowed = n;
+}
+
+void PokeGen::PokeMod::Pokemod::SetNumDaycares(const unsigned n)
+{
+   LogSetVar("Pokemod", 0, "numDaycares", n);
+   numDaycares = n;
+}
+
+void PokeGen::PokeMod::Pokemod::SetNumPokemonBoxes(const unsigned n)
+{
+   LogSetVar("Pokemod", 0, "numPokemonBoxes", n);
+   numPokemonBoxes = n;
+}
+
+void PokeGen::PokeMod::Pokemod::SetNumPokemonPerBox(const unsigned n)
+{
+   LogSetVar("Pokemod", 0, "numPokemonPerBox", n);
+   numPokemonPerBox = n;
+}
+
+void PokeGen::PokeMod::Pokemod::SetMaxParty(const unsigned m)
+{
+   LogSetVar("Pokemod", 0, "maxParty", m);
+   maxParty = m;
+}
+
+void PokeGen::PokeMod::Pokemod::SetMaxFight(const unsigned m)
+{
+   LogSetVar("Pokemod", 0, "maxFight", m);
+   if (m <= maxParty)
+      maxFight = m;
+}
+
+void PokeGen::PokeMod::Pokemod::SetMaxMoves(const unsigned m)
+{
+   LogSetVar("Pokemod", 0, "maxMoves", m);
+   maxMoves = m;
+}
+
+void PokeGen::PokeMod::Pokemod::SetMaxLevel(const unsigned m)
+{
+   LogSetVar("Pokemod", 0, "maxLevel", m);
+   maxLevel = m;
+}
+
+void PokeGen::PokeMod::Pokemod::SetMaxMoney(const unsigned m)
+{
+   LogSetVar("Pokemod", 0, "maxMoney", m);
+   maxMoney = m;
+}
+
+void PokeGen::PokeMod::Pokemod::SetIsHardCash(const bool h)
+{
+   LogSetVar("Pokemod", 0, "hardCash", h);
+   hardCash = h;
+}
+
+void PokeGen::PokeMod::Pokemod::SetIsSpecialSplit(const bool s)
+{
+   LogSetVar("Pokemod", 0, "specialSplit", s);
+   specialSplit = s;
+}
+
+void PokeGen::PokeMod::Pokemod::SetIsSpecialDVSplit(const bool s)
+{
+   LogSetVar("Pokemod", 0, "specialDVSplit", s);
+   specialDVSplit = s;
+}
+
+void PokeGen::PokeMod::Pokemod::SetMaxDVValue(const unsigned char m)
+{
+   LogSetVar("Pokemod", 0, "maxDVValue", m);
+   if ((m == 16) || (m == 32))
+      maxDVValue = m;
+}
+
+void PokeGen::PokeMod::Pokemod::SetIsHappiness(const bool h)
+{
+   LogSetVar("Pokemod", 0, "happiness", h);
+   happiness = h;
+}
+
+void PokeGen::PokeMod::Pokemod::SetHappyFaintLoss(const unsigned h)
+{
+   LogSetVar("Pokemod", 0, "happyFaintLoss", h);
+   happyFaintLoss = h;
+}
+
+void PokeGen::PokeMod::Pokemod::SetHappyLevelGain(const unsigned h)
+{
+   LogSetVar("Pokemod", 0, "happyLevelGain", h);
+   happyLevelGain = h;
+}
+
+void PokeGen::PokeMod::Pokemod::SetHappySteps(const unsigned h)
+{
+   LogSetVar("Pokemod", 0, "happySteps", h);
+   happySteps = h;
+}
+
+void PokeGen::PokeMod::Pokemod::SetIsEffortValuesAllowed(const bool e)
+{
+   LogSetVar("Pokemod", 0, "effortValuesAllowed", e);
+   effortValuesAllowed = e;
+}
+
+void PokeGen::PokeMod::Pokemod::SetMaxTotalEV(const unsigned m)
+{
+   LogSetVar("Pokemod", 0, "maxTotalEV", m);
+   maxTotalEV = m;
+}
+
+void PokeGen::PokeMod::Pokemod::SetMaxEVPerStat(const unsigned m)
+{
+   LogSetVar("Pokemod", 0, "maxEVPerStat", m);
+   maxEVPerStat = m;
+}
+
+void PokeGen::PokeMod::Pokemod::SetPokerusChance(const Frac &p)
+{
+   LogSetVar("Pokemod", 0, "pokerusChance", p.GetNum(), p.GetDenom());
+   pokerusChance = p;
+}
+
+void PokeGen::PokeMod::Pokemod::SetPokerusChance(const unsigned n, const unsigned d)
+{
+   LogSetVar("Pokemod", 0, "pokerusChance", n, d);
+   pokerusChance.Set(n, d);
+}
+
+void PokeGen::PokeMod::Pokemod::SetPokerusChanceNum(const unsigned n)
+{
+   LogSetVar("Pokemod", 0, "pokerusChance numerator", n);
+   pokerusChance.SetNum(n);
+}
+
+void PokeGen::PokeMod::Pokemod::SetPokerusChanceDenom(const unsigned d)
+{
+   LogSetVar("Pokemod", 0, "pokerusChance denominator", d);
+   pokerusChance.SetDenom(d);
+}
+
+void PokeGen::PokeMod::Pokemod::SetStartMap(const unsigned s)
+{
+   LogSetVar("Pokemod", 0, "startMap", s);
+   if (GetMap(s))
+      startMap = s;
+}
+
+void PokeGen::PokeMod::Pokemod::SetStartMap(const String &s)
+{
+   LogSetVar("Pokemod", 0, "startMap string", s);
+   if (const Map *m = GetMap(s))
+      startMap = m->GetId();
+}
+
+void PokeGen::PokeMod::Pokemod::SetStartMoney(const unsigned s)
+{
+   LogSetVar("Pokemod", 0, "startMoney", s);
+   startMoney = s;
+}
+
+void PokeGen::PokeMod::Pokemod::SetStartCoordinate(const Point &s)
+{
+   LogSetVar("Pokemod", 0, "startCoordinate", s.GetX(), s.GetY());
+   if (const Map *m = GetMap(startMap))
+   {
+      if ((s.GetX() < m->GetWidth()) && (s.GetY() < m->GetHeight()))
+         startCoordinate = s;
+   }
+}
+
+void PokeGen::PokeMod::Pokemod::SetStartCoordinate(const unsigned x, const unsigned y)
+{
+   LogSetVar("Pokemod", 0, "startCoordinate", x, y);
+   if (const Map *m = GetMap(startMap))
+   {
+      if ((x < m->GetWidth()) && (y < m->GetHeight()))
+         startCoordinate.Set(x, y);
+   }
+}
+
+void PokeGen::PokeMod::Pokemod::SetStartCoordinateX(const unsigned x)
+{
+   LogSetVar("Pokemod", 0, "startCoordinate x", x);
+   if (const Map *m = GetMap(startMap))
+   {
+      if (x < m->GetWidth())
+         startCoordinate.SetX(x);
+   }
+}
+
+void PokeGen::PokeMod::Pokemod::SetStartCoordinateY(const unsigned y)
+{
+   LogSetVar("Pokemod", 0, "startCoordinate y", y);
+   if (const Map *m = GetMap(startMap))
+   {
+      if (y < m->GetHeight())
+         startCoordinate.SetY(y);
+   }
+}
+
+void PokeGen::PokeMod::Pokemod::SetStartDirection(const unsigned s)
+{
+   LogSetVar("Pokemod", 0, "startDirection", s);
+   if (s < DIR_END)
+      startDirection = s;
+}
+
+void PokeGen::PokeMod::Pokemod::SetStartDirection(const String &s)
+{
+   SetStartDirection(FindIn(DIR_END, s, DirectionStr));
+}
+
+void PokeGen::PokeMod::Pokemod::SetStartDialog(const unsigned s)
+{
+   LogSetVar("Pokemod", 0, "startDialog", s);
+   if (GetDialog(s))
+      startDialog = s;
+}
+
+void PokeGen::PokeMod::Pokemod::SetWalkSkin(const Path &w)
+{
+   LogSetVar("Pokemod", 0, "walkSkin", w);
+   walkSkin = w;
+}
+
+void PokeGen::PokeMod::Pokemod::SetBikeSkin(const Path &b)
+{
+   LogSetVar("Pokemod", 0, "bikeSkin", b);
+   bikeSkin = b;
+}
+
+void PokeGen::PokeMod::Pokemod::SetSurfSkin(const Path &s)
+{
+   LogSetVar("Pokemod", 0, "surfSkin", s);
+   surfSkin = s;
+}
+
+void PokeGen::PokeMod::Pokemod::SetFlySkin(const Path &f)
+{
+   LogSetVar("Pokemod", 0, "flySkin", f);
+   flySkin = f;
+}
+
+void PokeGen::PokeMod::Pokemod::SetFishSkin(const Path &f)
+{
+   LogSetVar("Pokemod", 0, "fishSkin", f);
+   fishSkin = f;
+}
+
+void PokeGen::PokeMod::Pokemod::SetSurfFishSkin(const Path &s)
+{
+   LogSetVar("Pokemod", 0, "surfFishSkin", s);
+   surfFishSkin = s;
+}
+
+void PokeGen::PokeMod::Pokemod::SetSuperPCUname(const String &u)
+{
+   LogSetVar("Pokemod", 0, "superPCUname", u);
+   superPCUname = u;
+}
+
+void PokeGen::PokeMod::Pokemod::SetSuperPCPasswd(const String &p)
+{
+   LogSetVar("Pokemod", 0, "superPCPasswd", p);
+   superPCPasswd = p;
+}
+
+void PokeGen::PokeMod::Pokemod::SetStruggleMove(const unsigned s)
+{
+   LogSetVar("Pokemod", 0, "struggleMove", s);
+   if (GetMove(s))
+      struggleMove = s;
+}
+
+void PokeGen::PokeMod::Pokemod::SetStruggleMove(const String &s)
+{
+   LogSetVar("Pokemod", 0, "struggleMove string", s);
+   if (const Move *m = GetMove(s))
+      struggleMove = m->GetId();
+}
+
+void PokeGen::PokeMod::Pokemod::SetConfuseMove(const unsigned c)
+{
+   LogSetVar("Pokemod", 0, "confuseMove", c);
+   if (GetMove(c))
+      confuseMove = c;
+}
+
+void PokeGen::PokeMod::Pokemod::SetConfuseMove(const String &c)
+{
+   LogSetVar("Pokemod", 0, "confuseMove string", c);
+   if (const Move *m = GetMove(c))
+      confuseMove = m->GetId();
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetTitle() const
+{
+   LogFetchVar("Pokemod", 0, "title", title);
+   return title;
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetVersion() const
+{
+   LogFetchVar("Pokemod", 0, "version", version);
+   return version;
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetDescription() const
+{
+   LogFetchVar("Pokemod", 0, "description", description);
+   return description;
+}
+
+bool PokeGen::PokeMod::Pokemod::IsGenderAllowed() const
+{
+   LogFetchVar("Pokemod", 0, "genderAllowed", genderAllowed);
+   return genderAllowed;
+}
+
+bool PokeGen::PokeMod::Pokemod::IsBreedingAllowed() const
+{
+   LogFetchVar("Pokemod", 0, "breedingAllowed", breedingAllowed);
+   return breedingAllowed;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetEggSpecies() const
+{
+   LogFetchVar("Pokemod", 0, "eggSpecies", eggSpecies);
+   return eggSpecies;
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetEggSpeciesString() const
+{
+   LogFetchVar("Pokemod", 0, "eggSpecies", eggSpecies);
+   if (const Pokemon *p = GetPokemon(eggSpecies))
+      return p->GetName();
+   return "";
+}
+
+bool PokeGen::PokeMod::Pokemod::CanHoldItems() const
+{
+   LogFetchVar("Pokemod", 0, "holdItems", holdItems);
+   return holdItems;
+}
+
+bool PokeGen::PokeMod::Pokemod::HasCriticalDomains() const
+{
+   LogFetchVar("Pokemod", 0, "criticalDomains", criticalDomains);
+   return criticalDomains;
+}
+
+bool PokeGen::PokeMod::Pokemod::IsContestAllowed() const
+{
+   LogFetchVar("Pokemod", 0, "contestAllowed", contestAllowed);
+   return contestAllowed;
+}
+
+bool PokeGen::PokeMod::Pokemod::IsAbilityAllowed() const
+{
+   LogFetchVar("Pokemod", 0, "abilityAllowed", abilityAllowed);
+   return abilityAllowed;
+}
+
+bool PokeGen::PokeMod::Pokemod::IsNatureAllowed() const
+{
+   LogFetchVar("Pokemod", 0, "natureAllowed", natureAllowed);
+   return natureAllowed;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetNumDaycares() const
+{
+   LogFetchVar("Pokemod", 0, "numDaycares", numDaycares);
+   return numDaycares;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetNumPokemonBoxes() const
+{
+   LogFetchVar("Pokemod", 0, "numPokemonBoxes", numPokemonBoxes);
+   return numPokemonBoxes;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetNumPokemonPerBox() const
+{
+   LogFetchVar("Pokemod", 0, "numPokemonPerBox", numPokemonPerBox);
+   return numPokemonPerBox;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetMaxParty() const
+{
+   LogFetchVar("Pokemod", 0, "maxParty", maxParty);
+   return maxParty;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetMaxFight() const
+{
+   LogFetchVar("Pokemod", 0, "maxFight", maxFight);
+   return maxFight;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetMaxMoves() const
+{
+   LogFetchVar("Pokemod", 0, "maxMoves", maxMoves);
+   return maxMoves;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetMaxLevel() const
+{
+   LogFetchVar("Pokemod", 0, "maxLevel", maxLevel);
+   return maxLevel;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetMaxMoney() const
+{
+   LogFetchVar("Pokemod", 0, "maxMoney", maxMoney);
+   return maxMoney;
+}
+
+bool PokeGen::PokeMod::Pokemod::IsHardCash() const
+{
+   LogFetchVar("Pokemod", 0, "hardCash", hardCash);
+   return hardCash;
+}
+
+bool PokeGen::PokeMod::Pokemod::IsSpecialSplit() const
+{
+   LogFetchVar("Pokemod", 0, "specialSplit", specialSplit);
+   return specialSplit;
+}
+
+bool PokeGen::PokeMod::Pokemod::IsSpecialDVSplit() const
+{
+   LogFetchVar("Pokemod", 0, "specialDVSplit", specialDVSplit);
+   return specialDVSplit;
+}
+
+unsigned char PokeGen::PokeMod::Pokemod::GetMaxDVValue() const
+{
+   LogFetchVar("Pokemod", 0, "maxDVValue", maxDVValue);
+   return maxDVValue;
+}
+
+bool PokeGen::PokeMod::Pokemod::IsHappiness() const
+{
+   LogFetchVar("Pokemod", 0, "happiness", happiness);
+   return happiness;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetHappyFaintLoss() const
+{
+   LogFetchVar("Pokemod", 0, "happyFaintLoss", happyFaintLoss);
+   return happyFaintLoss;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetHappyLevelGain() const
+{
+   LogFetchVar("Pokemod", 0, "happyLevelGain", happyLevelGain);
+   return happyLevelGain;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetHappySteps() const
+{
+   LogFetchVar("Pokemod", 0, "happySteps", happySteps);
+   return happySteps;
+}
+
+bool PokeGen::PokeMod::Pokemod::IsEffortValuesAllowed() const
+{
+   LogFetchVar("Pokemod", 0, "effortValuesAllowed", effortValuesAllowed);
+   return effortValuesAllowed;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetMaxTotalEV() const
+{
+   LogFetchVar("Pokemod", 0, "maxTotalEV", maxTotalEV);
+   return maxTotalEV;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetMaxEVPerStat() const
+{
+   LogFetchVar("Pokemod", 0, "maxEVPerStat", maxEVPerStat);
+   return maxEVPerStat;
+}
+
+PokeGen::PokeMod::Frac PokeGen::PokeMod::Pokemod::GetPokerusChance() const
+{
+   LogFetchVar("Pokemod", 0, "pokerusChance", pokerusChance.GetNum(), pokerusChance.GetDenom());
+   return pokerusChance;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetPokerusChanceNum() const
+{
+   LogFetchVar("Pokemod", 0, "pokerusChance numerator", pokerusChance.GetNum());
+   return pokerusChance.GetNum();
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetPokerusChanceDenom() const
+{
+   LogFetchVar("Pokemod", 0, "pokerusChance denominator", pokerusChance.GetDenom());
+   return pokerusChance.GetDenom();
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetStartMap() const
+{
+   LogFetchVar("Pokemod", 0, "startMap", startMap);
+   return startMap;
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetStartMapString() const
+{
+   LogFetchVar("Pokemod", 0, "startMap string", startMap);
+   if (const Map *m = GetMap(startMap))
+      return m->GetName();
+   return "";
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetStartMoney() const
+{
+   LogFetchVar("Pokemod", 0, "startMoney", startMoney);
+   return startMoney;
+}
+
+PokeGen::PokeMod::Point PokeGen::PokeMod::Pokemod::GetStartCoordinate() const
+{
+   LogFetchVar("Pokemod", 0, "startCoordinate", startCoordinate.GetX(), startCoordinate.GetY());
+   return startCoordinate;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetStartCoordinateX() const
+{
+   LogFetchVar("Pokemod", 0, "startCoordinate x", startCoordinate.GetX());
+   return startCoordinate.GetX();
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetStartCoordinateY() const
+{
+   LogFetchVar("Pokemod", 0, "startCoordinate y", startCoordinate.GetY());
+   return startCoordinate.GetY();
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetStartDirection() const
+{
+   LogFetchVar("Pokemod", 0, "startDirection", startDirection);
+   return startDirection;
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetStartDirectionString() const
+{
+   LogFetchVar("Pokemod", 0, "startDirection string", startDirection);
+   if (startDirection < DIR_END)
+      return DirectionStr[startDirection];
+   return "";
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetStartDialog() const
+{
+   LogFetchVar("Pokemod", 0, "startDialog", startDialog);
+   return startDialog;
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetStartDialogString() const
+{
+   LogFetchVar("Pokemod", 0, "startDialog string", startDialog);
+   if (const Dialog *d = GetDialog(startDialog))
+      return d->GetDialog();
+   return "";
+}
+
+PokeGen::PokeMod::Path PokeGen::PokeMod::Pokemod::GetWalkSkin() const
+{
+   LogFetchVar("Pokemod", 0, "walkSkin", walkSkin);
+   return walkSkin;
+}
+
+PokeGen::PokeMod::Path PokeGen::PokeMod::Pokemod::GetBikeSkin() const
+{
+   LogFetchVar("Pokemod", 0, "bikeSkin", bikeSkin);
+   return bikeSkin;
+}
+
+PokeGen::PokeMod::Path PokeGen::PokeMod::Pokemod::GetSurfSkin() const
+{
+   LogFetchVar("Pokemod", 0, "surfSkin", surfSkin);
+   return surfSkin;
+}
+
+PokeGen::PokeMod::Path PokeGen::PokeMod::Pokemod::GetFlySkin() const
+{
+   LogFetchVar("Pokemod", 0, "flySkin", flySkin);
+   return flySkin;
+}
+
+PokeGen::PokeMod::Path PokeGen::PokeMod::Pokemod::GetFishSkin() const
+{
+   LogFetchVar("Pokemod", 0, "fishSkin", fishSkin);
+   return fishSkin;
+}
+
+PokeGen::PokeMod::Path PokeGen::PokeMod::Pokemod::GetSurfFishSkin() const
+{
+   LogFetchVar("Pokemod", 0, "surfFishSkin", surfFishSkin);
+   return surfFishSkin;
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetSuperPCUname() const
+{
+   LogFetchVar("Pokemod", 0, "superPCUname", superPCUname);
+   return superPCUname;
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetSuperPCPasswd() const
+{
+   LogFetchVar("Pokemod", 0, "superPCPasswd", superPCPasswd);
+   return superPCPasswd;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetStruggleMove() const
+{
+   LogFetchVar("Pokemod", 0, "struggleMove", struggleMove);
+   return struggleMove;
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetStruggleMoveString() const
+{
+   LogFetchVar("Pokemod", 0, "struggleMove string", struggleMove);
+   if (const Move *m = GetMove(struggleMove))
+      return m->GetName();
+   return "";
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetConfuseMove() const
+{
+   LogFetchVar("Pokemod", 0, "confuseMove", confuseMove);
+   return confuseMove;
+}
+
+PokeGen::PokeMod::String PokeGen::PokeMod::Pokemod::GetConfuseMoveString() const
+{
+   LogFetchVar("Pokemod", 0, "confuseMove string", confuseMove);
+   if (const Move *m = GetMove(confuseMove))
+      return m->GetName();
+   return "";
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChart(const unsigned att, const unsigned def, const Frac &m) const
+{
+   unsigned col = UINT_MAX;
+   unsigned row = UINT_MAX;
+   for (unsigned i = 1; (i < typeChart.GetWidth()) && ((col == UINT_MAX) || (row != UINT_MAX)); ++i)
+   {
+      if (typeChart[i][0].GetNum() == att)
+         row = i;
+      if (typeChart[i][0].GetNum() == def)
+         col = i;
+   }
+   if ((col != UINT_MAX) && (row != UINT_MAX))
+      typeChart[col][row] = m;
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChart(const unsigned att, const unsigned def, const unsigned n, const unsigned d) const
+{
+   unsigned col = UINT_MAX;
+   unsigned row = UINT_MAX;
+   for (unsigned i = 1; (i < typeChart.GetWidth()) && ((col == UINT_MAX) || (row != UINT_MAX)); ++i)
+   {
+      if (typeChart[i][0].GetNum() == att)
+         row = i;
+      if (typeChart[i][0].GetNum() == def)
+         col = i;
+   }
+   if ((col != UINT_MAX) && (row != UINT_MAX))
+      typeChart[col][row].Set(n, d);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChartNum(const unsigned att, const unsigned def, const unsigned n) const
+{
+   unsigned col = UINT_MAX;
+   unsigned row = UINT_MAX;
+   for (unsigned i = 1; (i < typeChart.GetWidth()) && ((col == UINT_MAX) || (row != UINT_MAX)); ++i)
+   {
+      if (typeChart[i][0].GetNum() == att)
+         row = i;
+      if (typeChart[i][0].GetNum() == def)
+         col = i;
+   }
+   if ((col != UINT_MAX) && (row != UINT_MAX))
+      typeChart[col][row].SetNum(n);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChartDenom(const unsigned att, const unsigned def, const unsigned d) const
+{
+   unsigned col = UINT_MAX;
+   unsigned row = UINT_MAX;
+   for (unsigned i = 1; (i < typeChart.GetWidth()) && ((col == UINT_MAX) || (row != UINT_MAX)); ++i)
+   {
+      if (typeChart[i][0].GetNum() == att)
+         row = i;
+      if (typeChart[i][0].GetNum() == def)
+         col = i;
+   }
+   if ((col != UINT_MAX) && (row != UINT_MAX))
+      typeChart[col][row].SetDenom(d);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChart(const String &att, const unsigned def, const Frac &m) const
+{
+   if (const Type *t = GetType(att))
+      SetTypeChart(t->GetId(), def, m);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChart(const String &att, const unsigned def, const unsigned n, const unsigned d) const
+{
+   if (const Type *t = GetType(att))
+      SetTypeChart(t->GetId(), def, n, d);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChartNum(const String &att, const unsigned def, const unsigned n) const
+{
+   if (const Type *t = GetType(att))
+      SetTypeChartNum(t->GetId(), def, n);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChartDenom(const String &att, const unsigned def, const unsigned d) const
+{
+   if (const Type *t = GetType(att))
+      SetTypeChartDenom(t->GetId(), def, d);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChart(const unsigned att, const String &def, const Frac &m) const
+{
+   if (const Type *t = GetType(def))
+      SetTypeChart(att, t->GetId(), m);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChart(const unsigned att, const String &def, const unsigned n, const unsigned d) const
+{
+   if (const Type *t = GetType(def))
+      SetTypeChart(att, t->GetId(), n, d);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChartNum(const unsigned att, const String &def, const unsigned n) const
+{
+   if (const Type *t = GetType(def))
+      SetTypeChartNum(att, t->GetId(), n);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChartDenom(const unsigned att, const String &def, const unsigned d) const
+{
+   if (const Type *t = GetType(def))
+      SetTypeChartDenom(att, t->GetId(), d);
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChart(const String &att, const String &def, const Frac &m) const
+{
+   if (const Type *t = GetType(att))
+   {
+      if (const Type *t2 = GetType(def))
+         SetTypeChart(t->GetId(), t2->GetId(), m);
+   }
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChart(const String &att, const String &def, const unsigned n, const unsigned d) const
+{
+   if (const Type *t = GetType(att))
+   {
+      if (const Type *t2 = GetType(def))
+         SetTypeChart(t->GetId(), t2->GetId(), n, d);
+   }
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChartNum(const String &att, const String &def, const unsigned n) const
+{
+   if (const Type *t = GetType(att))
+   {
+      if (const Type *t2 = GetType(def))
+         SetTypeChartNum(t->GetId(), t2->GetId(), n);
+   }
+}
+
+void PokeGen::PokeMod::Pokemod::SetTypeChartDenom(const String &att, const String &def, const unsigned d) const
+{
+   if (const Type *t = GetType(att))
+   {
+      if (const Type *t2 = GetType(def))
+         SetTypeChartDenom(t->GetId(), t2->GetId(), d);
+   }
+}
+
+PokeGen::PokeMod::Frac PokeGen::PokeMod::Pokemod::GetTypeChart(const unsigned att, const unsigned def) const
+{
+   unsigned col = UINT_MAX;
+   unsigned row = UINT_MAX;
+   for (unsigned i = 1; (i < typeChart.GetWidth()) && ((col == UINT_MAX) || (row != UINT_MAX)); ++i)
+   {
+      if (typeChart[i][0].GetNum() == att)
+         row = i;
+      if (typeChart[i][0].GetNum() == def)
+         col = i;
+   }
+   if ((col != UINT_MAX) && (row != UINT_MAX))
+      return typeChart[col][row];
+   return Frac(1, 1);
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTypeChartNum(const unsigned att, const unsigned def) const
+{
+   unsigned col = UINT_MAX;
+   unsigned row = UINT_MAX;
+   for (unsigned i = 1; (i < typeChart.GetWidth()) && ((col == UINT_MAX) || (row != UINT_MAX)); ++i)
+   {
+      if (typeChart[i][0].GetNum() == att)
+         row = i;
+      if (typeChart[i][0].GetNum() == def)
+         col = i;
+   }
+   if ((col != UINT_MAX) && (row != UINT_MAX))
+      return typeChart[col][row].GetNum();
+   return UINT_MAX;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTypeChartDenom(const unsigned att, const unsigned def) const
+{
+   unsigned col = UINT_MAX;
+   unsigned row = UINT_MAX;
+   for (unsigned i = 1; (i < typeChart.GetWidth()) && ((col == UINT_MAX) || (row != UINT_MAX)); ++i)
+   {
+      if (typeChart[i][0].GetNum() == att)
+         row = i;
+      if (typeChart[i][0].GetNum() == def)
+         col = i;
+   }
+   if ((col != UINT_MAX) && (row != UINT_MAX))
+      return typeChart[col][row].GetDenom();
+   return UINT_MAX;
+}
+
+PokeGen::PokeMod::Frac PokeGen::PokeMod::Pokemod::GetTypeChart(const String &att, const unsigned def) const
+{
+   if (const Type *t = GetType(att))
+      return GetTypeChart(t->GetId(), def);
+   return Frac(1, 1);
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTypeChartNum(const String &att, const unsigned def) const
+{
+   if (const Type *t = GetType(att))
+      return GetTypeChartNum(t->GetId(), def);
+   return UINT_MAX;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTypeChartDenom(const String &att, const unsigned def) const
+{
+   if (const Type *t = GetType(att))
+      return GetTypeChartDenom(t->GetId(), def);
+   return UINT_MAX;
+}
+
+PokeGen::PokeMod::Frac PokeGen::PokeMod::Pokemod::GetTypeChart(const unsigned att, const String &def) const
+{
+   if (const Type *t = GetType(def))
+      return GetTypeChart(att, t->GetId());
+   return Frac(1, 1);
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTypeChartNum(const unsigned att, const String &def) const
+{
+   if (const Type *t = GetType(def))
+      return GetTypeChartNum(att, t->GetId());
+   return UINT_MAX;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTypeChartDenom(const unsigned att, const String &def) const
+{
+   if (const Type *t = GetType(def))
+      return GetTypeChartDenom(def, t->GetId());
+   return UINT_MAX;
+}
+
+PokeGen::PokeMod::Frac PokeGen::PokeMod::Pokemod::GetTypeChart(const String &att, const String &def) const
+{
+   if (const Type *t = GetType(att))
+   {
+      if (const Type *t2 = GetType(def))
+         return GetTypeChart(t->GetId(), t2->GetId());
+   }
+   return Frac(1, 1);
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTypeChartNum(const String &att, const String &def) const
+{
+   if (const Type *t = GetType(att))
+   {
+      if (const Type *t2 = GetType(def))
+         return GetTypeChartNum(t->GetId(), t2->GetId());
+   }
+   return UINT_MAX;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTypeChartDenom(const String &att, const String &def) const
+{
+   if (const Type *t = GetType(att))
+   {
+      if (const Type *t2 = GetType(def))
+         return GetTypeChartDenom(t->GetId(), t2->GetId());
+   }
+   return UINT_MAX;
+}
+
+const PokeGen::PokeMod::Ability *PokeGen::PokeMod::Pokemod::GetAbility(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "ability", _id);
+   for (unsigned i = 0; i < GetAbilityCount(); ++i)
+   {
+      if (abilities[i].GetId() == _id)
+         return &abilities[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "ability", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Ability *PokeGen::PokeMod::Pokemod::GetAbility(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "ability", n);
+   for (unsigned i = 0; i < GetAbilityCount(); ++i)
+   {
+      if (abilities[i].GetName() == n)
+         return &abilities[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "ability", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetAbilityCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "ability");
+   return abilities.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewAbility(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetAbilityCount(); ++i)
+   {
+      if (!GetAbility(i))
+         break;
+   }
+   Ability newAbility(i);
+   if (ini)
+      newAbility.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "ability", i);
+   abilities.push_back(newAbility);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteAbility(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "ability", _id);
+   for (std::vector<Ability>::iterator i = abilities.begin(); i != abilities.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "ability", _id);
+         abilities.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "ability", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteAbility(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "ability", n);
+   for (std::vector<Ability>::iterator i = abilities.begin(); i != abilities.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "ability", n);
+         abilities.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "ability", n);
+}
+
+const PokeGen::PokeMod::Author *PokeGen::PokeMod::Pokemod::GetAuthor(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "author", _id);
+   for (unsigned i = 0; i < GetAuthorCount(); ++i)
+   {
+      if (authors[i].GetId() == _id)
+         return &authors[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "author", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Author *PokeGen::PokeMod::Pokemod::GetAuthor(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "author", n);
+   for (unsigned i = 0; i < GetAuthorCount(); ++i)
+   {
+      if (authors[i].GetName() == n)
+         return &authors[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "author", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetAuthorCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "author");
+   return authors.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewAuthor(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetAuthorCount(); ++i)
+   {
+      if (!GetAuthor(i))
+         break;
+   }
+   Author newAuthor(i);
+   if (ini)
+      newAuthor.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "author", i);
+   authors.push_back(newAuthor);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteAuthor(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "author", _id);
+   for (std::vector<Author>::iterator i = authors.begin(); i != authors.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "author", _id);
+         authors.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "author", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteAuthor(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "author", n);
+   for (std::vector<Author>::iterator i = authors.begin(); i != authors.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "author", n);
+         authors.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "author", n);
+}
+
+const PokeGen::PokeMod::Badge *PokeGen::PokeMod::Pokemod::GetBadge(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "badge", _id);
+   for (unsigned i = 0; i < GetBadgeCount(); ++i)
+   {
+      if (badges[i].GetId() == _id)
+         return &badges[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "badge", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Badge *PokeGen::PokeMod::Pokemod::GetBadge(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "badge", n);
+   for (unsigned i = 0; i < GetBadgeCount(); ++i)
+   {
+      if (badges[i].GetName() == n)
+         return &badges[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "badge", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetBadgeCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "badge");
+   return badges.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewBadge(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetBadgeCount(); ++i)
+   {
+      if (!GetBadge(i))
+         break;
+   }
+   Badge newBadge(i);
+   if (ini)
+      newBadge.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "badge", i);
+   badges.push_back(newBadge);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteBadge(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "badge", _id);
+   for (std::vector<Badge>::iterator i = badges.begin(); i != badges.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "badge", _id);
+         badges.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "badge", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteBadge(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "badge", n);
+   for (std::vector<Badge>::iterator i = badges.begin(); i != badges.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "badge", n);
+         badges.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "badge", n);
+}
+
+const PokeGen::PokeMod::CoinList *PokeGen::PokeMod::Pokemod::GetCoinList(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "coin list", _id);
+   for (unsigned i = 0; i < GetCoinListCount(); ++i)
+   {
+      if (coinLists[i].GetId() == _id)
+         return &coinLists[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "coin list", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::CoinList *PokeGen::PokeMod::Pokemod::GetCoinList(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "coin list", n);
+   for (unsigned i = 0; i < GetCoinListCount(); ++i)
+   {
+      if (coinLists[i].GetName() == n)
+         return &coinLists[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "coin list", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetCoinListCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "coin list");
+   return coinLists.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewCoinList(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetCoinListCount(); ++i)
+   {
+      if (!GetCoinList(i))
+         break;
+   }
+   CoinList newCoinList(i);
+   if (ini)
+      newCoinList.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "coin list", i);
+   coinLists.push_back(newCoinList);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteCoinList(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "coin list", _id);
+   for (std::vector<CoinList>::iterator i = coinLists.begin(); i != coinLists.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "coin list", _id);
+         coinLists.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "coin list", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteCoinList(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "coin list", n);
+   for (std::vector<CoinList>::iterator i = coinLists.begin(); i != coinLists.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "coin list", n);
+         coinLists.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "coin list", n);
+}
+
+const PokeGen::PokeMod::Dialog *PokeGen::PokeMod::Pokemod::GetDialog(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "dialog", _id);
+   for (unsigned i = 0; i < GetDialogCount(); ++i)
+   {
+      if (dialogs[i].GetId() == _id)
+         return &dialogs[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "dialog", _id);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetDialogCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "dialog");
+   return dialogs.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewDialog(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetDialogCount(); ++i)
+   {
+      if (!GetDialog(i))
+         break;
+   }
+   Dialog newDialog(i);
+   if (ini)
+      newDialog.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "dialog", i);
+   dialogs.push_back(newDialog);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteDialog(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "dialog", _id);
+   for (std::vector<Dialog>::iterator i = dialogs.begin(); i != dialogs.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "dialog", _id);
+         dialogs.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "dialog", _id);
+}
+
+const PokeGen::PokeMod::EggGroup *PokeGen::PokeMod::Pokemod::GetEggGroup(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "egg group", _id);
+   for (unsigned i = 0; i < GetEggGroupCount(); ++i)
+   {
+      if (eggGroups[i].GetId() == _id)
+         return &eggGroups[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "egg group", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::EggGroup *PokeGen::PokeMod::Pokemod::GetEggGroup(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "egg group", n);
+   for (unsigned i = 0; i < GetEggGroupCount(); ++i)
+   {
+      if (eggGroups[i].GetName() == n)
+         return &eggGroups[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "egg group", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetEggGroupCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "egg group");
+   return eggGroups.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewEggGroup(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetEggGroupCount(); ++i)
+   {
+      if (!GetEggGroup(i))
+         break;
+   }
+   EggGroup newEggGroup(i);
+   if (ini)
+      newEggGroup.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "egg group", i);
+   eggGroups.push_back(newEggGroup);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteEggGroup(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "egg group", _id);
+   for (std::vector<EggGroup>::iterator i = eggGroups.begin(); i != eggGroups.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "egg group", _id);
+         eggGroups.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "egg group", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteEggGroup(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "egg group", n);
+   for (std::vector<EggGroup>::iterator i = eggGroups.begin(); i != eggGroups.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "egg group", n);
+         eggGroups.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "egg group", n);
+}
+
+const PokeGen::PokeMod::Item *PokeGen::PokeMod::Pokemod::GetItem(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "item", _id);
+   for (unsigned i = 0; i < GetItemCount(); ++i)
+   {
+      if (items[i].GetId() == _id)
+         return &items[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "item", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Item *PokeGen::PokeMod::Pokemod::GetItem(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "item", n);
+   for (unsigned i = 0; i < GetItemCount(); ++i)
+   {
+      if (items[i].GetName() == n)
+         return &items[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "item", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetItemCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "item");
+   return items.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewItem(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetItemCount(); ++i)
+   {
+      if (!GetItem(i))
+         break;
+   }
+   Item newItem(i);
+   if (ini)
+      newItem.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "item", i);
+   items.push_back(newItem);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteItem(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "item", _id);
+   for (std::vector<Item>::iterator i = items.begin(); i != items.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "item", _id);
+         items.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "item", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteItem(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "item", n);
+   for (std::vector<Item>::iterator i = items.begin(); i != items.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "item", n);
+         items.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "item", n);
+}
+
+const PokeGen::PokeMod::ItemStorage *PokeGen::PokeMod::Pokemod::GetItemStorage(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "item storage", _id);
+   for (unsigned i = 0; i < GetItemStorageCount(); ++i)
+   {
+      if (itemStorages[i].GetId() == _id)
+         return &itemStorages[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "item storage", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::ItemStorage *PokeGen::PokeMod::Pokemod::GetItemStorage(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "item storage", n);
+   for (unsigned i = 0; i < GetItemStorageCount(); ++i)
+   {
+      if (itemStorages[i].GetName() == n)
+         return &itemStorages[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "item storage", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetItemStorageCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "item storage");
+   return itemStorages.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewItemStorage(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetItemStorageCount(); ++i)
+   {
+      if (!GetItemStorage(i))
+         break;
+   }
+   ItemStorage newItemStorage(i);
+   if (ini)
+      newItemStorage.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "item storage", i);
+   itemStorages.push_back(newItemStorage);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteItemStorage(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "item storage", _id);
+   for (std::vector<ItemStorage>::iterator i = itemStorages.begin(); i != itemStorages.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "item storage", _id);
+         itemStorages.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "item storage", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteItemStorage(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "item storage", n);
+   for (std::vector<ItemStorage>::iterator i = itemStorages.begin(); i != itemStorages.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "item storage", n);
+         itemStorages.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "item storage", n);
+}
+
+const PokeGen::PokeMod::Map *PokeGen::PokeMod::Pokemod::GetMap(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "map", _id);
+   for (unsigned i = 0; i < GetMapCount(); ++i)
+   {
+      if (maps[i].GetId() == _id)
+         return &maps[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "map", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Map *PokeGen::PokeMod::Pokemod::GetMap(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "map", n);
+   for (unsigned i = 0; i < GetMapCount(); ++i)
+   {
+      if (maps[i].GetName() == n)
+         return &maps[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "map", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetMapCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "map");
+   return maps.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewMap(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetMapCount(); ++i)
+   {
+      if (!GetMap(i))
+         break;
+   }
+   Map newMap(i);
+   if (ini)
+      newMap.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "map", i);
+   maps.push_back(newMap);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteMap(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "map", _id);
+   for (std::vector<Map>::iterator i = maps.begin(); i != maps.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "map", _id);
+         maps.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "map", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteMap(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "map", n);
+   for (std::vector<Map>::iterator i = maps.begin(); i != maps.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "map", n);
+         maps.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "map", n);
+}
+
+const PokeGen::PokeMod::Move *PokeGen::PokeMod::Pokemod::GetMove(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "move", _id);
+   for (unsigned i = 0; i < GetMoveCount(); ++i)
+   {
+      if (moves[i].GetId() == _id)
+         return &moves[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "move", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Move *PokeGen::PokeMod::Pokemod::GetMove(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "move", n);
+   for (unsigned i = 0; i < GetMoveCount(); ++i)
+   {
+      if (moves[i].GetName() == n)
+         return &moves[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "move", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetMoveCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "move");
+   return moves.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewMove(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetMoveCount(); ++i)
+   {
+      if (!GetMove(i))
+         break;
+   }
+   Move newMove(i);
+   if (ini)
+      newMove.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "move", i);
+   moves.push_back(newMove);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteMove(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "move", _id);
+   for (std::vector<Move>::iterator i = moves.begin(); i != moves.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "move", _id);
+         moves.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "move", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteMove(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "move", n);
+   for (std::vector<Move>::iterator i = moves.begin(); i != moves.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "move", n);
+         moves.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "move", n);
+}
+
+const PokeGen::PokeMod::Nature *PokeGen::PokeMod::Pokemod::GetNature(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "nature", _id);
+   for (unsigned i = 0; i < GetNatureCount(); ++i)
+   {
+      if (natures[i].GetId() == _id)
+         return &natures[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "nature", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Nature *PokeGen::PokeMod::Pokemod::GetNature(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "nature", n);
+   for (unsigned i = 0; i < GetNatureCount(); ++i)
+   {
+      if (natures[i].GetName() == n)
+         return &natures[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "nature", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetNatureCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "nature");
+   return natures.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewNature(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetNatureCount(); ++i)
+   {
+      if (!GetNature(i))
+         break;
+   }
+   Nature newNature(i);
+   if (ini)
+      newNature.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "nature", i);
+   natures.push_back(newNature);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteNature(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "nature", _id);
+   for (std::vector<Nature>::iterator i = natures.begin(); i != natures.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "nature", _id);
+         natures.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "nature", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteNature(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "nature", n);
+   for (std::vector<Nature>::iterator i = natures.begin(); i != natures.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "nature", n);
+         natures.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "nature", n);
+}
+
+const PokeGen::PokeMod::Pokemon *PokeGen::PokeMod::Pokemod::GetPokemon(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "Pokémon", _id);
+   for (unsigned i = 0; i < GetPokemonCount(); ++i)
+   {
+      if (pokemon[i].GetId() == _id)
+         return &pokemon[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "Pokémon", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Pokemon *PokeGen::PokeMod::Pokemod::GetPokemon(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "Pokémon", n);
+   for (unsigned i = 0; i < GetPokemonCount(); ++i)
+   {
+      if (pokemon[i].GetName() == n)
+         return &pokemon[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "Pokémon", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetPokemonCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "Pokémon");
+   return pokemon.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewPokemon(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetPokemonCount(); ++i)
+   {
+      if (!GetPokemon(i))
+         break;
+   }
+   Pokemon newPokemon(i);
+   if (ini)
+      newPokemon.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "Pokémon", i);
+   pokemon.push_back(newPokemon);
+}
+
+void PokeGen::PokeMod::Pokemod::DeletePokemon(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "Pokémon", _id);
+   for (std::vector<Pokemon>::iterator i = pokemon.begin(); i != pokemon.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "Pokémon", _id);
+         pokemon.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "Pokémon", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeletePokemon(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "Pokémon", n);
+   for (std::vector<Pokemon>::iterator i = pokemon.begin(); i != pokemon.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "Pokémon", n);
+         pokemon.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "Pokémon", n);
+}
+
+const PokeGen::PokeMod::Status *PokeGen::PokeMod::Pokemod::GetStatus(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "status", _id);
+   for (unsigned i = 0; i < GetStatusCount(); ++i)
+   {
+      if (statuses[i].GetId() == _id)
+         return &statuses[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "status", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Status *PokeGen::PokeMod::Pokemod::GetStatus(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "status", n);
+   for (unsigned i = 0; i < GetStatusCount(); ++i)
+   {
+      if (statuses[i].GetName() == n)
+         return &statuses[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "status", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetStatusCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "status");
+   return statuses.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewStatus(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetStatusCount(); ++i)
+   {
+      if (!GetStatus(i))
+         break;
+   }
+   Status newStatus(i);
+   if (ini)
+      newStatus.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "status", i);
+   statuses.push_back(newStatus);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteStatus(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "status", _id);
+   for (std::vector<Status>::iterator i = statuses.begin(); i != statuses.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "status", _id);
+         statuses.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "status", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteStatus(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "status", n);
+   for (std::vector<Status>::iterator i = statuses.begin(); i != statuses.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "status", n);
+         statuses.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "status", n);
+}
+
+const PokeGen::PokeMod::Store *PokeGen::PokeMod::Pokemod::GetStore(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "store", _id);
+   for (unsigned i = 0; i < GetStoreCount(); ++i)
+   {
+      if (stores[i].GetId() == _id)
+         return &stores[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "store", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Store *PokeGen::PokeMod::Pokemod::GetStore(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "store", n);
+   for (unsigned i = 0; i < GetStoreCount(); ++i)
+   {
+      if (stores[i].GetName() == n)
+         return &stores[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "store", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetStoreCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "store");
+   return stores.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewStore(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetStoreCount(); ++i)
+   {
+      if (!GetStore(i))
+         break;
+   }
+   Store newStore(i);
+   if (ini)
+      newStore.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "store", i);
+   stores.push_back(newStore);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteStore(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "store", _id);
+   for (std::vector<Store>::iterator i = stores.begin(); i != stores.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "store", _id);
+         stores.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "store", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteStore(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "store", n);
+   for (std::vector<Store>::iterator i = stores.begin(); i != stores.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "store", n);
+         stores.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "store", n);
+}
+
+const PokeGen::PokeMod::Tile *PokeGen::PokeMod::Pokemod::GetTile(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "tile", _id);
+   for (unsigned i = 0; i < GetTileCount(); ++i)
+   {
+      if (tiles[i].GetId() == _id)
+         return &tiles[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "tile", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Tile *PokeGen::PokeMod::Pokemod::GetTile(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "tile", n);
+   for (unsigned i = 0; i < GetTileCount(); ++i)
+   {
+      if (tiles[i].GetName() == n)
+         return &tiles[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "tile", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTileCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "tile");
+   return tiles.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewTile(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetTileCount(); ++i)
+   {
+      if (!GetTile(i))
+         break;
+   }
+   Tile newTile(i);
+   if (ini)
+      newTile.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "tile", i);
+   tiles.push_back(newTile);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteTile(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "tile", _id);
+   for (std::vector<Tile>::iterator i = tiles.begin(); i != tiles.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "tile", _id);
+         tiles.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "tile", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteTile(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "tile", n);
+   for (std::vector<Tile>::iterator i = tiles.begin(); i != tiles.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "tile", n);
+         tiles.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "tile", n);
+}
+
+const PokeGen::PokeMod::Time *PokeGen::PokeMod::Pokemod::GetTime(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "time", _id);
+   for (unsigned i = 0; i < GetTimeCount(); ++i)
+   {
+      if (times[i].GetId() == _id)
+         return &times[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "time", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Time *PokeGen::PokeMod::Pokemod::GetTime(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "time", n);
+   for (unsigned i = 0; i < GetTimeCount(); ++i)
+   {
+      if (times[i].GetName() == n)
+         return &times[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "time", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTimeCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "time");
+   return times.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewTime(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetTimeCount(); ++i)
+   {
+      if (!GetTime(i))
+         break;
+   }
+   Time newTime(i);
+   if (ini)
+      newTime.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "time", i);
+   times.push_back(newTime);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteTime(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "time", _id);
+   for (std::vector<Time>::iterator i = times.begin(); i != times.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "time", _id);
+         times.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "time", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteTime(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "time", n);
+   for (std::vector<Time>::iterator i = times.begin(); i != times.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "time", n);
+         times.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "time", n);
+}
+
+const PokeGen::PokeMod::Type *PokeGen::PokeMod::Pokemod::GetType(const unsigned _id) const
+{
+   LogSubmoduleFetch("Pokemod", id, "type", _id);
+   for (unsigned i = 0; i < GetTypeCount(); ++i)
+   {
+      if (types[i].GetId() == _id)
+         return &types[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "type", _id);
+   return NULL;
+}
+
+const PokeGen::PokeMod::Type *PokeGen::PokeMod::Pokemod::GetType(const String &n) const
+{
+   LogSubmoduleFetch("Pokemod", id, "type", n);
+   for (unsigned i = 0; i < GetTypeCount(); ++i)
+   {
+      if (types[i].GetName() == n)
+         return &types[i];
+   }
+   LogSubmoduleFetchFail("Pokemod", id, "type", n);
+   return NULL;
+}
+
+unsigned PokeGen::PokeMod::Pokemod::GetTypeCount() const
+{
+   LogSubmoduleCount("Pokemod", id, "type");
+   return types.size();
+}
+
+void PokeGen::PokeMod::Pokemod::NewType(Ini *const ini)
+{
+   unsigned i = 0;
+   for (; i < GetTypeCount(); ++i)
+   {
+      if (!GetType(i))
+         break;
+   }
+   Type newType(i);
+   if (ini)
+      newType.ImportIni(*ini);
+   LogSubmoduleNew("Pokemod", id, "type", i);
+   types.push_back(newType);
+   typeChart.AddCol(Frac(1, 1));
+   typeChart.AddRow(Frac(1, 1));
+   typeChart[0][typeChart.GetHeight() - 1] = Frac(i, 1, true);
+   typeChart[typeChart.GetHeight() - 1][0] = Frac(i, 1, true);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteType(const unsigned _id)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "type", _id);
+   for (std::vector<Type>::iterator i = types.begin(); i != types.end(); ++i)
+   {
+      if (i->GetId() == _id)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "type", _id);
+         for (unsigned j = 0; j < typeChart.GetWidth(); ++j)
+         {
+            if (typeChart[j][0].GetNum() == _id)
+            {
+               typeChart.DeleteCol(j);
+               typeChart.DeleteRow(j);
+            }
+         }
+         types.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "type", _id);
+}
+
+void PokeGen::PokeMod::Pokemod::DeleteType(const String &n)
+{
+   LogSubmoduleRemoveStart("Pokemod", id, "type", n);
+   for (std::vector<Type>::iterator i = types.begin(); i != types.end(); ++i)
+   {
+      if (i->GetName() == n)
+      {
+         LogSubmoduleRemoved("Pokemod", id, "type", n);
+         for (unsigned j = 0; j < typeChart.GetWidth(); ++j)
+         {
+            if (typeChart[j][0].GetNum() == i->GetId())
+            {
+               typeChart.DeleteCol(j);
+               typeChart.DeleteRow(j);
+            }
+         }
+         types.erase(i);
+      }
+   }
+   LogSubmoduleRemoveFail("Pokemod", id, "type", n);
 }
-- 
cgit