Fixed internals of GameWrapper

2 files changed, 164 insertions, 164 deletions

diff --git a/sigscript/GameWrapper.cpp b/sigscript/GameWrapper.cpp
index 39e51f17..695212bf 100644
--- a/sigscript/GameWrapper.cpp
+++ b/sigscript/GameWrapper.cpp
@@ -16,7 +16,7 @@
  */
 
 // Header include
-#include "SigmodWrapper.h"
+#include "GameWrapper.h"
 
 // Sigscript includes
 #include "AbilityWrapper.h"
@@ -50,11 +50,11 @@
 #include <sigmod/Badge.h>
 #include <sigmod/CoinList.h>
 #include <sigmod/EggGroup.h>
+#include <sigmod/Game.h>
 #include <sigmod/GlobalScript.h>
 #include <sigmod/Item.h>
 #include <sigmod/Move.h>
 #include <sigmod/Nature.h>
-#include <sigmod/Sigmod.h>
 #include <sigmod/Store.h>
 #include <sigmod/Skin.h>
 #include <sigmod/Sprite.h>
@@ -64,134 +64,134 @@
 #include <sigmod/Type.h>
 #include <sigmod/Weather.h>
 
-Sigscript::SigmodWrapper::SigmodWrapper(const Sigmod::Sigmod* sigmod) :
-        ObjectWrapper(sigmod, NULL),
-        m_sigmod(sigmod)
+Sigscript::GameWrapper::GameWrapper(const Sigmod::Game* game) :
+        ObjectWrapper(game, NULL),
+        m_game(game)
 {
 }
 
-Sigcore::Hat<Sigscript::NatureWrapper*> Sigscript::SigmodWrapper::natureHat()
+Sigcore::Hat<Sigscript::NatureWrapper*> Sigscript::GameWrapper::natureHat()
 {
     Sigcore::Hat<NatureWrapper*> hat;
-    for (int i = 0; i < m_sigmod->natureCount(); ++i)
+    for (int i = 0; i < m_game->natureCount(); ++i)
     {
-        NatureWrapper* nature = NatureWrapper::create(m_sigmod->nature(i), this);
+        NatureWrapper* nature = NatureWrapper::create(m_game->nature(i), this);
         hat.add(nature, nature->weight());
     }
     return hat;
 }
 
-Sigscript::AbilityWrapper* Sigscript::SigmodWrapper::ability(const int id)
+Sigscript::AbilityWrapper* Sigscript::GameWrapper::ability(const int id)
 {
-    return AbilityWrapper::create(m_sigmod->abilityById(id), this);
+    return AbilityWrapper::create(m_game->abilityById(id), this);
 }
 
-Sigscript::AuthorWrapper* Sigscript::SigmodWrapper::author(const int id)
+Sigscript::AuthorWrapper* Sigscript::GameWrapper::author(const int id)
 {
-    return AuthorWrapper::create(m_sigmod->authorById(id), this);
+    return AuthorWrapper::create(m_game->authorById(id), this);
 }
 
-Sigscript::BadgeWrapper* Sigscript::SigmodWrapper::badge(const int id)
+Sigscript::BadgeWrapper* Sigscript::GameWrapper::badge(const int id)
 {
-    return BadgeWrapper::create(m_sigmod->badgeById(id), this);
+    return BadgeWrapper::create(m_game->badgeById(id), this);
 }
 
-Sigscript::CoinListWrapper* Sigscript::SigmodWrapper::coinList(const int id)
+Sigscript::CoinListWrapper* Sigscript::GameWrapper::coinList(const int id)
 {
-    return CoinListWrapper::create(m_sigmod->coinListById(id), this);
+    return CoinListWrapper::create(m_game->coinListById(id), this);
 }
 
-Sigscript::EggGroupWrapper* Sigscript::SigmodWrapper::eggGroup(const int id)
+Sigscript::EggGroupWrapper* Sigscript::GameWrapper::eggGroup(const int id)
 {
-    return EggGroupWrapper::create(m_sigmod->eggGroupById(id), this);
+    return EggGroupWrapper::create(m_game->eggGroupById(id), this);
 }
 
-Sigscript::GlobalScriptWrapper* Sigscript::SigmodWrapper::globalScript(const int id)
+Sigscript::GlobalScriptWrapper* Sigscript::GameWrapper::globalScript(const int id)
 {
-    return GlobalScriptWrapper::create(m_sigmod->globalScriptById(id), this);
+    return GlobalScriptWrapper::create(m_game->globalScriptById(id), this);
 }
 
-Sigscript::ItemWrapper* Sigscript::SigmodWrapper::item(const int id)
+Sigscript::ItemWrapper* Sigscript::GameWrapper::item(const int id)
 {
-    return ItemWrapper::create(m_sigmod->itemById(id), this);
+    return ItemWrapper::create(m_game->itemById(id), this);
 }
 
-Sigscript::ItemTypeWrapper* Sigscript::SigmodWrapper::itemType(const int id)
+Sigscript::ItemTypeWrapper* Sigscript::GameWrapper::itemType(const int id)
 {
-    return ItemTypeWrapper::create(m_sigmod->itemTypeById(id), this);
+    return ItemTypeWrapper::create(m_game->itemTypeById(id), this);
 }
 
-Sigscript::MapWrapper* Sigscript::SigmodWrapper::map(const int id)
+Sigscript::MapWrapper* Sigscript::GameWrapper::map(const int id)
 {
-    return MapWrapper::create(m_sigmod->mapById(id), this);
+    return MapWrapper::create(m_game->mapById(id), this);
 }
 
-Sigscript::MoveWrapper* Sigscript::SigmodWrapper::move(const int id)
+Sigscript::MoveWrapper* Sigscript::GameWrapper::move(const int id)
 {
-    return MoveWrapper::create(m_sigmod->moveById(id), this);
+    return MoveWrapper::create(m_game->moveById(id), this);
 }
 
-Sigscript::NatureWrapper* Sigscript::SigmodWrapper::nature(const int id)
+Sigscript::NatureWrapper* Sigscript::GameWrapper::nature(const int id)
 {
-    return NatureWrapper::create(m_sigmod->natureById(id), this);
+    return NatureWrapper::create(m_game->natureById(id), this);
 }
 
-Sigscript::SkinWrapper* Sigscript::SigmodWrapper::skin(const int id)
+Sigscript::SkinWrapper* Sigscript::GameWrapper::skin(const int id)
 {
-    return SkinWrapper::create(m_sigmod->skinById(id), this);
+    return SkinWrapper::create(m_game->skinById(id), this);
 }
 
-Sigscript::SoundWrapper* Sigscript::SigmodWrapper::sound(const int id)
+Sigscript::SoundWrapper* Sigscript::GameWrapper::sound(const int id)
 {
-    return SoundWrapper::create(m_sigmod->soundById(id), this);
+    return SoundWrapper::create(m_game->soundById(id), this);
 }
 
-Sigscript::SpeciesWrapper* Sigscript::SigmodWrapper::species(const int id)
+Sigscript::SpeciesWrapper* Sigscript::GameWrapper::species(const int id)
 {
-    return SpeciesWrapper::create(m_sigmod->speciesById(id), this);
+    return SpeciesWrapper::create(m_game->speciesById(id), this);
 }
 
-Sigscript::SpriteWrapper* Sigscript::SigmodWrapper::sprite(const int id)
+Sigscript::SpriteWrapper* Sigscript::GameWrapper::sprite(const int id)
 {
-    return SpriteWrapper::create(m_sigmod->spriteById(id), this);
+    return SpriteWrapper::create(m_game->spriteById(id), this);
 }
 
-Sigscript::StatusWrapper* Sigscript::SigmodWrapper::status(const int id)
+Sigscript::StatusWrapper* Sigscript::GameWrapper::status(const int id)
 {
-    return StatusWrapper::create(m_sigmod->statusById(id), this);
+    return StatusWrapper::create(m_game->statusById(id), this);
 }
 
-Sigscript::StoreWrapper* Sigscript::SigmodWrapper::store(const int id)
+Sigscript::StoreWrapper* Sigscript::GameWrapper::store(const int id)
 {
-    return StoreWrapper::create(m_sigmod->storeById(id), this);
+    return StoreWrapper::create(m_game->storeById(id), this);
 }
 
-Sigscript::TileWrapper* Sigscript::SigmodWrapper::tile(const int id)
+Sigscript::TileWrapper* Sigscript::GameWrapper::tile(const int id)
 {
-    return TileWrapper::create(m_sigmod->tileById(id), this);
+    return TileWrapper::create(m_game->tileById(id), this);
 }
 
-Sigscript::TimeWrapper* Sigscript::SigmodWrapper::time(const int id)
+Sigscript::TimeWrapper* Sigscript::GameWrapper::time(const int id)
 {
-    return TimeWrapper::create(m_sigmod->timeById(id), this);
+    return TimeWrapper::create(m_game->timeById(id), this);
 }
 
-Sigscript::TrainerWrapper* Sigscript::SigmodWrapper::trainer(const int id)
+Sigscript::TrainerWrapper* Sigscript::GameWrapper::trainer(const int id)
 {
-    return TrainerWrapper::create(m_sigmod->trainerById(id), this);
+    return TrainerWrapper::create(m_game->trainerById(id), this);
 }
 
-Sigscript::TypeWrapper* Sigscript::SigmodWrapper::type(const int id)
+Sigscript::TypeWrapper* Sigscript::GameWrapper::type(const int id)
 {
-    return TypeWrapper::create(m_sigmod->typeById(id), this);
+    return TypeWrapper::create(m_game->typeById(id), this);
 }
 
-Sigscript::WeatherWrapper* Sigscript::SigmodWrapper::weather(const int id)
+Sigscript::WeatherWrapper* Sigscript::GameWrapper::weather(const int id)
 {
-    return WeatherWrapper::create(m_sigmod->weatherById(id), this);
+    return WeatherWrapper::create(m_game->weatherById(id), this);
 }
 
-Sigmod::Stat Sigscript::SigmodWrapper::stat(const QString& name) const
+Sigmod::Stat Sigscript::GameWrapper::stat(const QString& name) const
 {
     if (name == "HP")
         return Sigmod::ST_HP;
@@ -214,7 +214,7 @@ Sigmod::Stat Sigscript::SigmodWrapper::stat(const QString& name) const
     return QVariant(-1).value<Sigmod::Stat>();
 }
 
-Sigmod::Direction Sigscript::SigmodWrapper::direction(const QString& name) const
+Sigmod::Direction Sigscript::GameWrapper::direction(const QString& name) const
 {
     if (name == "Up")
         return Sigmod::D_Up;
@@ -229,257 +229,257 @@ Sigmod::Direction Sigscript::SigmodWrapper::direction(const QString& name) const
     return QVariant(-1).value<Sigmod::Direction>();
 }
 
-QString Sigscript::SigmodWrapper::title() const
+QString Sigscript::GameWrapper::title() const
 {
-    return m_sigmod->title();
+    return m_game->title();
 }
 
-QString Sigscript::SigmodWrapper::version() const
+QString Sigscript::GameWrapper::version() const
 {
-    return m_sigmod->version();
+    return m_game->version();
 }
 
-QString Sigscript::SigmodWrapper::description() const
+QString Sigscript::GameWrapper::description() const
 {
-    return m_sigmod->description();
+    return m_game->description();
 }
 
-bool Sigscript::SigmodWrapper::singlePlayer() const
+bool Sigscript::GameWrapper::singlePlayer() const
 {
-    return m_sigmod->singlePlayer();
+    return m_game->singlePlayer();
 }
 
-Sigcore::Script Sigscript::SigmodWrapper::startScript()
+Sigcore::Script Sigscript::GameWrapper::startScript()
 {
-    return m_sigmod->startScript();
+    return m_game->startScript();
 }
 
-Sigcore::Fraction Sigscript::SigmodWrapper::effectiveness(const TypeWrapper* attacker, const TypeWrapper* defender) const
+Sigcore::Fraction Sigscript::GameWrapper::effectiveness(const TypeWrapper* attacker, const TypeWrapper* defender) const
 {
-    return m_sigmod->typechart(m_sigmod->typeIndex(attacker->id()), m_sigmod->typeIndex(defender->id()));
+    return m_game->typechart(m_game->typeIndex(attacker->id()), m_game->typeIndex(defender->id()));
 }
 
-Sigscript::RulesWrapper* Sigscript::SigmodWrapper::rules()
+Sigscript::RulesWrapper* Sigscript::GameWrapper::rules()
 {
-    return RulesWrapper::create(m_sigmod->rules(), this);
+    return RulesWrapper::create(m_game->rules(), this);
 }
 
-Sigscript::AbilityWrapper* Sigscript::SigmodWrapper::ability(const QString& name)
+Sigscript::AbilityWrapper* Sigscript::GameWrapper::ability(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->abilityCount(); ++i)
+    for (int i = 0; i < m_game->abilityCount(); ++i)
     {
-        if (m_sigmod->ability(i)->name() == name)
-            return AbilityWrapper::create(m_sigmod->ability(i), this);
+        if (m_game->ability(i)->name() == name)
+            return AbilityWrapper::create(m_game->ability(i), this);
     }
     return NULL;
 }
 
-Sigscript::AuthorWrapper* Sigscript::SigmodWrapper::author(const QString& name)
+Sigscript::AuthorWrapper* Sigscript::GameWrapper::author(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->authorCount(); ++i)
+    for (int i = 0; i < m_game->authorCount(); ++i)
     {
-        if (m_sigmod->author(i)->name() == name)
-            return AuthorWrapper::create(m_sigmod->author(i), this);
+        if (m_game->author(i)->name() == name)
+            return AuthorWrapper::create(m_game->author(i), this);
     }
     return NULL;
 }
 
-Sigscript::BadgeWrapper* Sigscript::SigmodWrapper::badge(const QString& name)
+Sigscript::BadgeWrapper* Sigscript::GameWrapper::badge(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->badgeCount(); ++i)
+    for (int i = 0; i < m_game->badgeCount(); ++i)
     {
-        if (m_sigmod->badge(i)->name() == name)
-            return BadgeWrapper::create(m_sigmod->badge(i), this);
+        if (m_game->badge(i)->name() == name)
+            return BadgeWrapper::create(m_game->badge(i), this);
     }
     return NULL;
 }
 
-Sigscript::CoinListWrapper* Sigscript::SigmodWrapper::coinList(const QString& name)
+Sigscript::CoinListWrapper* Sigscript::GameWrapper::coinList(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->coinListCount(); ++i)
+    for (int i = 0; i < m_game->coinListCount(); ++i)
     {
-        if (m_sigmod->coinList(i)->name() == name)
-            return CoinListWrapper::create(m_sigmod->coinList(i), this);
+        if (m_game->coinList(i)->name() == name)
+            return CoinListWrapper::create(m_game->coinList(i), this);
     }
     return NULL;
 }
 
-Sigscript::EggGroupWrapper* Sigscript::SigmodWrapper::eggGroup(const QString& name)
+Sigscript::EggGroupWrapper* Sigscript::GameWrapper::eggGroup(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->eggGroupCount(); ++i)
+    for (int i = 0; i < m_game->eggGroupCount(); ++i)
     {
-        if (m_sigmod->eggGroup(i)->name() == name)
-            return EggGroupWrapper::create(m_sigmod->eggGroup(i), this);
+        if (m_game->eggGroup(i)->name() == name)
+            return EggGroupWrapper::create(m_game->eggGroup(i), this);
     }
     return NULL;
 }
 
-Sigscript::GlobalScriptWrapper* Sigscript::SigmodWrapper::globalScript(const QString& name)
+Sigscript::GlobalScriptWrapper* Sigscript::GameWrapper::globalScript(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->globalScriptCount(); ++i)
+    for (int i = 0; i < m_game->globalScriptCount(); ++i)
     {
-        if (m_sigmod->globalScript(i)->name() == name)
-            return GlobalScriptWrapper::create(m_sigmod->globalScript(i), this);
+        if (m_game->globalScript(i)->name() == name)
+            return GlobalScriptWrapper::create(m_game->globalScript(i), this);
     }
     return NULL;
 }
 
-Sigscript::ItemWrapper* Sigscript::SigmodWrapper::item(const QString& name)
+Sigscript::ItemWrapper* Sigscript::GameWrapper::item(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->itemCount(); ++i)
+    for (int i = 0; i < m_game->itemCount(); ++i)
     {
-        if (m_sigmod->item(i)->name() == name)
-            return ItemWrapper::create(m_sigmod->item(i), this);
+        if (m_game->item(i)->name() == name)
+            return ItemWrapper::create(m_game->item(i), this);
     }
     return NULL;
 }
 
-Sigscript::ItemTypeWrapper* Sigscript::SigmodWrapper::itemType(const QString& name)
+Sigscript::ItemTypeWrapper* Sigscript::GameWrapper::itemType(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->itemTypeCount(); ++i)
+    for (int i = 0; i < m_game->itemTypeCount(); ++i)
     {
-        if (m_sigmod->itemType(i)->name() == name)
-            return ItemTypeWrapper::create(m_sigmod->itemType(i), this);
+        if (m_game->itemType(i)->name() == name)
+            return ItemTypeWrapper::create(m_game->itemType(i), this);
     }
     return NULL;
 }
 
-Sigscript::MapWrapper* Sigscript::SigmodWrapper::map(const QString& name)
+Sigscript::MapWrapper* Sigscript::GameWrapper::map(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->mapCount(); ++i)
+    for (int i = 0; i < m_game->mapCount(); ++i)
     {
-        if (m_sigmod->map(i)->name() == name)
-            return MapWrapper::create(m_sigmod->map(i), this);
+        if (m_game->map(i)->name() == name)
+            return MapWrapper::create(m_game->map(i), this);
     }
     return NULL;
 }
 
-Sigscript::MoveWrapper* Sigscript::SigmodWrapper::move(const QString& name)
+Sigscript::MoveWrapper* Sigscript::GameWrapper::move(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->moveCount(); ++i)
+    for (int i = 0; i < m_game->moveCount(); ++i)
     {
-        if (m_sigmod->move(i)->name() == name)
-            return MoveWrapper::create(m_sigmod->move(i), this);
+        if (m_game->move(i)->name() == name)
+            return MoveWrapper::create(m_game->move(i), this);
     }
     return NULL;
 }
 
-Sigscript::NatureWrapper* Sigscript::SigmodWrapper::nature(const QString& name)
+Sigscript::NatureWrapper* Sigscript::GameWrapper::nature(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->natureCount(); ++i)
+    for (int i = 0; i < m_game->natureCount(); ++i)
     {
-        if (m_sigmod->nature(i)->name() == name)
-            return NatureWrapper::create(m_sigmod->nature(i), this);
+        if (m_game->nature(i)->name() == name)
+            return NatureWrapper::create(m_game->nature(i), this);
     }
     return NULL;
 }
 
-Sigscript::SkinWrapper* Sigscript::SigmodWrapper::skin(const QString& name)
+Sigscript::SkinWrapper* Sigscript::GameWrapper::skin(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->skinCount(); ++i)
+    for (int i = 0; i < m_game->skinCount(); ++i)
     {
-        if (m_sigmod->skin(i)->name() == name)
-            return SkinWrapper::create(m_sigmod->skin(i), this);
+        if (m_game->skin(i)->name() == name)
+            return SkinWrapper::create(m_game->skin(i), this);
     }
     return NULL;
 }
 
-Sigscript::SoundWrapper* Sigscript::SigmodWrapper::sound(const QString& name)
+Sigscript::SoundWrapper* Sigscript::GameWrapper::sound(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->soundCount(); ++i)
+    for (int i = 0; i < m_game->soundCount(); ++i)
     {
-        if (m_sigmod->sound(i)->name() == name)
-            return SoundWrapper::create(m_sigmod->sound(i), this);
+        if (m_game->sound(i)->name() == name)
+            return SoundWrapper::create(m_game->sound(i), this);
     }
     return NULL;
 }
 
-Sigscript::SpeciesWrapper* Sigscript::SigmodWrapper::species(const QString& name)
+Sigscript::SpeciesWrapper* Sigscript::GameWrapper::species(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->speciesCount(); ++i)
+    for (int i = 0; i < m_game->speciesCount(); ++i)
     {
-        if (m_sigmod->species(i)->name() == name)
-            return SpeciesWrapper::create(m_sigmod->species(i), this);
+        if (m_game->species(i)->name() == name)
+            return SpeciesWrapper::create(m_game->species(i), this);
     }
     return NULL;
 }
 
-Sigscript::SpriteWrapper* Sigscript::SigmodWrapper::sprite(const QString& name)
+Sigscript::SpriteWrapper* Sigscript::GameWrapper::sprite(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->spriteCount(); ++i)
+    for (int i = 0; i < m_game->spriteCount(); ++i)
     {
-        if (m_sigmod->sprite(i)->name() == name)
-            return SpriteWrapper::create(m_sigmod->sprite(i), this);
+        if (m_game->sprite(i)->name() == name)
+            return SpriteWrapper::create(m_game->sprite(i), this);
     }
     return NULL;
 }
 
-Sigscript::StatusWrapper* Sigscript::SigmodWrapper::status(const QString& name)
+Sigscript::StatusWrapper* Sigscript::GameWrapper::status(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->statusCount(); ++i)
+    for (int i = 0; i < m_game->statusCount(); ++i)
     {
-        if (m_sigmod->status(i)->name() == name)
-            return StatusWrapper::create(m_sigmod->status(i), this);
+        if (m_game->status(i)->name() == name)
+            return StatusWrapper::create(m_game->status(i), this);
     }
     return NULL;
 }
 
-Sigscript::StoreWrapper* Sigscript::SigmodWrapper::store(const QString& name)
+Sigscript::StoreWrapper* Sigscript::GameWrapper::store(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->storeCount(); ++i)
+    for (int i = 0; i < m_game->storeCount(); ++i)
     {
-        if (m_sigmod->store(i)->name() == name)
-            return StoreWrapper::create(m_sigmod->store(i), this);
+        if (m_game->store(i)->name() == name)
+            return StoreWrapper::create(m_game->store(i), this);
     }
     return NULL;
 }
 
-Sigscript::TileWrapper* Sigscript::SigmodWrapper::tile(const QString& name)
+Sigscript::TileWrapper* Sigscript::GameWrapper::tile(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->tileCount(); ++i)
+    for (int i = 0; i < m_game->tileCount(); ++i)
     {
-        if (m_sigmod->tile(i)->name() == name)
-            return TileWrapper::create(m_sigmod->tile(i), this);
+        if (m_game->tile(i)->name() == name)
+            return TileWrapper::create(m_game->tile(i), this);
     }
     return NULL;
 }
 
-Sigscript::TimeWrapper* Sigscript::SigmodWrapper::time(const QString& name)
+Sigscript::TimeWrapper* Sigscript::GameWrapper::time(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->timeCount(); ++i)
+    for (int i = 0; i < m_game->timeCount(); ++i)
     {
-        if (m_sigmod->time(i)->name() == name)
-            return TimeWrapper::create(m_sigmod->time(i), this);
+        if (m_game->time(i)->name() == name)
+            return TimeWrapper::create(m_game->time(i), this);
     }
     return NULL;
 }
 
-Sigscript::TrainerWrapper* Sigscript::SigmodWrapper::trainer(const QString& name)
+Sigscript::TrainerWrapper* Sigscript::GameWrapper::trainer(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->trainerCount(); ++i)
+    for (int i = 0; i < m_game->trainerCount(); ++i)
     {
-        if (m_sigmod->trainer(i)->name() == name)
-            return TrainerWrapper::create(m_sigmod->trainer(i), this);
+        if (m_game->trainer(i)->name() == name)
+            return TrainerWrapper::create(m_game->trainer(i), this);
     }
     return NULL;
 }
 
-Sigscript::TypeWrapper* Sigscript::SigmodWrapper::type(const QString& name)
+Sigscript::TypeWrapper* Sigscript::GameWrapper::type(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->typeCount(); ++i)
+    for (int i = 0; i < m_game->typeCount(); ++i)
     {
-        if (m_sigmod->type(i)->name() == name)
-            return TypeWrapper::create(m_sigmod->type(i), this);
+        if (m_game->type(i)->name() == name)
+            return TypeWrapper::create(m_game->type(i), this);
     }
     return NULL;
 }
 
-Sigscript::WeatherWrapper* Sigscript::SigmodWrapper::weather(const QString& name)
+Sigscript::WeatherWrapper* Sigscript::GameWrapper::weather(const QString& name)
 {
-    for (int i = 0; i < m_sigmod->weatherCount(); ++i)
+    for (int i = 0; i < m_game->weatherCount(); ++i)
     {
-        if (m_sigmod->weather(i)->name() == name)
-            return WeatherWrapper::create(m_sigmod->weather(i), this);
+        if (m_game->weather(i)->name() == name)
+            return WeatherWrapper::create(m_game->weather(i), this);
     }
     return NULL;
 }
diff --git a/sigscript/GameWrapper.h b/sigscript/GameWrapper.h
index 48515286..179d77f8 100644
--- a/sigscript/GameWrapper.h
+++ b/sigscript/GameWrapper.h
@@ -15,8 +15,8 @@
  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SIGSCRIPT_SIGMODWRAPPER
-#define SIGSCRIPT_SIGMODWRAPPER
+#ifndef SIGSCRIPT_GAMEWRAPPER
+#define SIGSCRIPT_GAMEWRAPPER
 
 // Sigscript includes
 #include "ObjectWrapper.h"
@@ -32,7 +32,7 @@
 // Forward declarations
 namespace Sigmod
 {
-class Sigmod;
+class Game;
 }
 
 namespace Sigscript
@@ -62,12 +62,12 @@ class TrainerWrapper;
 class TypeWrapper;
 class WeatherWrapper;
 
-class SIGSCRIPT_EXPORT SigmodWrapper : public ObjectWrapper
+class SIGSCRIPT_EXPORT GameWrapper : public ObjectWrapper
 {
     Q_OBJECT
     
     public:
-        SigmodWrapper(const Sigmod::Sigmod* sigmod);
+        GameWrapper(const Sigmod::Game* game);
         
         Sigcore::Hat<NatureWrapper*> natureHat();
         
@@ -128,11 +128,11 @@ class SIGSCRIPT_EXPORT SigmodWrapper : public ObjectWrapper
         Q_SCRIPTABLE TypeWrapper* type(const QString& name);
         Q_SCRIPTABLE WeatherWrapper* weather(const QString& name);
     private:
-        SigmodWrapper& operator=(const SigmodWrapper& rhs);
+        GameWrapper& operator=(const GameWrapper& rhs);
         
-        const Sigmod::Sigmod* m_sigmod;
+        const Sigmod::Game* m_game;
 };
 }
-Q_DECLARE_METATYPE(Sigscript::SigmodWrapper*)
+Q_DECLARE_METATYPE(Sigscript::GameWrapper*)
 
 #endif