Fixed sigencore to use namespaces in sources

10 files changed, 289 insertions, 256 deletions

diff --git a/sigencore/Arena.cpp b/sigencore/Arena.cpp
index 01577dfb..d2a5611f 100644
--- a/sigencore/Arena.cpp
+++ b/sigencore/Arena.cpp
@@ -44,23 +44,27 @@
 #include <QtCore/QtConcurrentRun>
 #include <QtCore/QUuid>
 
-const int Sigencore::Arena::Spectator = -1;
-const int Sigencore::Arena::Fighters = -2;
-const int Sigencore::Arena::AllTeams = -3;
-const int Sigencore::Arena::NoTeam = -4;
+using namespace Sigcore;
+using namespace Sigscript;
+using namespace Sigencore;
 
-Sigencore::TeamMember::RequestedAction Sigencore::requestDecision(Player* player, TeamMember* teamMember)
+const int Arena::Spectator = -1;
+const int Arena::Fighters = -2;
+const int Arena::AllTeams = -3;
+const int Arena::NoTeam = -4;
+
+TeamMember::RequestedAction Sigencore::requestDecision(Player* player, TeamMember* teamMember)
 {
     return TeamMember::RequestedAction(teamMember, QtConcurrent::run(decision, player, teamMember));
 }
 
-Sigencore::TeamMember::Action Sigencore::decision(Player* player, TeamMember* teamMember)
+TeamMember::Action Sigencore::decision(Player* player, TeamMember* teamMember)
 {
     return player->requestAction(teamMember);
 }
 
-Sigencore::Arena::Arena(Sigscript::GameWrapper* game, const bool isWild, Sigscript::Config* parent) :
-        Sigscript::Config(parent),
+Arena::Arena(GameWrapper* game, const bool isWild, Config* parent) :
+        Config(parent),
         m_game(game),
         m_isWild(isWild),
         m_state(Setup),
@@ -70,14 +74,14 @@ Sigencore::Arena::Arena(Sigscript::GameWrapper* game, const bool isWild, Sigscri
     m_actions = new Kross::ActionCollection(QString("arena-%1").arg(m_id.toString()), Kross::Manager::self().actionCollection());
 }
 
-Sigencore::Arena::~Arena()
+Arena::~Arena()
 {
     delete m_actions;
 }
 
-QList<Sigencore::TeamMember*> Sigencore::Arena::active(const int team) const
+QList<TeamMember*> Arena::active(const int team) const
 {
-    QList<Sigencore::TeamMember*> active;
+    QList<TeamMember*> active;
     QList<Client*> clients;
     if ((team == Fighters) || (team == AllTeams))
         clients = m_teams.keys();
@@ -92,16 +96,16 @@ QList<Sigencore::TeamMember*> Sigencore::Arena::active(const int team) const
     return active;
 }
 
-QList<Sigencore::TeamMember*> Sigencore::Arena::active(Client* client) const
+QList<TeamMember*> Arena::active(Client* client) const
 {
-    QList<Sigencore::TeamMember*> active;
+    QList<TeamMember*> active;
     Player* player = qobject_cast<Player*>(client);
     if (player)
         active += player->active();
     return active;
 }
 
-QList<Sigencore::Client*> Sigencore::Arena::teamPlayers(const int team) const
+QList<Client*> Arena::teamPlayers(const int team) const
 {
     switch (team)
     {
@@ -122,7 +126,7 @@ QList<Sigencore::Client*> Sigencore::Arena::teamPlayers(const int team) const
     }
 }
 
-Sigencore::Player* Sigencore::Arena::player(TeamMember* teamMember) const
+Player* Arena::player(TeamMember* teamMember) const
 {
     Team* team = qobject_cast<Team*>(teamMember->containment());
     if (team)
@@ -130,26 +134,26 @@ Sigencore::Player* Sigencore::Arena::player(TeamMember* teamMember) const
     return NULL;
 }
 
-int Sigencore::Arena::team(TeamMember* teamMember) const
+int Arena::team(TeamMember* teamMember) const
 {
     return team(player(teamMember));
 }
 
-int Sigencore::Arena::team(Client* client) const
+int Arena::team(Client* client) const
 {
     if (m_teams.contains(client))
         return m_teams[client];
     return NoTeam;
 }
 
-int Sigencore::Arena::numTeams() const
+int Arena::numTeams() const
 {
     QSet<int> teams = m_teams.values().toSet();
     teams.remove(Spectator);
     return teams.size();
 }
 
-int Sigencore::Arena::numPlayers() const
+int Arena::numPlayers() const
 {
     QList<Client*> clients = m_teams.keys();
     int players = 0;
@@ -158,7 +162,7 @@ int Sigencore::Arena::numPlayers() const
     return players;
 }
 
-int Sigencore::Arena::numTeamMembers() const
+int Arena::numTeamMembers() const
 {
     QList<Client*> clients = m_teams.keys();
     int teamMembers = 0;
@@ -171,17 +175,17 @@ int Sigencore::Arena::numTeamMembers() const
     return teamMembers;
 }
 
-Sigencore::Arena::State Sigencore::Arena::state() const
+Arena::State Arena::state() const
 {
     return m_state;
 }
 
-QList<Sigscript::WeatherWrapper*> Sigencore::Arena::weathers() const
+QList<WeatherWrapper*> Arena::weathers() const
 {
     return m_weathers.keys();
 }
 
-void Sigencore::Arena::setWeather(TeamMember* teamMember, Sigscript::WeatherWrapper* weather)
+void Arena::setWeather(TeamMember* teamMember, WeatherWrapper* weather)
 {
     // FIXME: Loses memory if a weather is started again
     ObjectMap objects;
@@ -196,7 +200,7 @@ void Sigencore::Arena::setWeather(TeamMember* teamMember, Sigscript::WeatherWrap
     emit(weatherStarted(teamMember, weather));
 }
 
-bool Sigencore::Arena::unsetWeather(Sigscript::WeatherWrapper* weather)
+bool Arena::unsetWeather(WeatherWrapper* weather)
 {
     if (m_weathers.contains(weather))
     {
@@ -208,12 +212,12 @@ bool Sigencore::Arena::unsetWeather(Sigscript::WeatherWrapper* weather)
     return false;
 }
 
-Sigscript::GameWrapper* Sigencore::Arena::game() const
+GameWrapper* Arena::game() const
 {
     return m_game;
 }
 
-bool Sigencore::Arena::addClient(Client* client, const int team)
+bool Arena::addClient(Client* client, const int team)
 {
     if (0 <= team)
     {
@@ -228,7 +232,7 @@ bool Sigencore::Arena::addClient(Client* client, const int team)
     return true;
 }
 
-void Sigencore::Arena::removeClient(Client* client)
+void Arena::removeClient(Client* client)
 {
     Player* player = qobject_cast<Player*>(client);
     if (player && m_spoils.contains(player))
@@ -245,7 +249,7 @@ void Sigencore::Arena::removeClient(Client* client)
     emit(clientRemoved(client, team));
 }
 
-void Sigencore::Arena::registerScript(const Sigcore::Script& script)
+void Arena::registerScript(const Script& script)
 {
     if (!script.script().isEmpty())
     {
@@ -257,7 +261,7 @@ void Sigencore::Arena::registerScript(const Sigcore::Script& script)
     }
 }
 
-void Sigencore::Arena::cleanUp()
+void Arena::cleanUp()
 {
     emit(battleAboutToEnd());
     emit(aboutToClearActions());
@@ -271,7 +275,7 @@ void Sigencore::Arena::cleanUp()
         client->exitArena();
 }
 
-void Sigencore::Arena::handleAction(TeamMember* teamMember, TeamMember::Action action)
+void Arena::handleAction(TeamMember* teamMember, TeamMember::Action action)
 {
     TeamMember::ActionData data = action.second;
     switch (action.first)
@@ -283,10 +287,10 @@ void Sigencore::Arena::handleAction(TeamMember* teamMember, TeamMember::Action a
             break;
         case TeamMember::Attack:
         {
-            Sigscript::MoveWrapper* move = game()->move(data.first.toInt());
+            MoveWrapper* move = game()->move(data.first.toInt());
             if (move)
             {
-                const Sigcore::Script script = move->battleScript();
+                const Script script = move->battleScript();
                 if (!script.script().isEmpty())
                 {
                     ObjectMap objects;
@@ -303,10 +307,10 @@ void Sigencore::Arena::handleAction(TeamMember* teamMember, TeamMember::Action a
         }
         case TeamMember::Item:
         {
-            Sigscript::ItemWrapper* item = m_game->item(data.first.toInt());
+            ItemWrapper* item = m_game->item(data.first.toInt());
             if (item)
             {
-                const Sigcore::Script script = item->script();
+                const Script script = item->script();
                 if (!script.script().isEmpty())
                 {
                     ObjectMap objects;
@@ -333,7 +337,7 @@ void Sigencore::Arena::handleAction(TeamMember* teamMember, TeamMember::Action a
                 break;
             Player* self = player(teamMember);
             const int numFlee = self->active().size();
-            Sigcore::Fraction selfRunChance;
+            Fraction selfRunChance;
             self->valueOfType("runchance", &selfRunChance);
             bool canRun = true;
             self->valueOfType("canflee", &canRun);
@@ -345,7 +349,7 @@ void Sigencore::Arena::handleAction(TeamMember* teamMember, TeamMember::Action a
                 Player* player = qobject_cast<Player*>(client);
                 if (!player || (self == player) || (m_teams[self] == m_teams[player]))
                     continue;
-                Sigcore::Fraction playerRunChance;
+                Fraction playerRunChance;
                 player->valueOfType("fleechance", &playerRunChance);
                 if (!playerRunChance.poll())
                     canRun = false;
@@ -377,7 +381,7 @@ void Sigencore::Arena::handleAction(TeamMember* teamMember, TeamMember::Action a
     }
 }
 
-void Sigencore::Arena::setupBattle()
+void Arena::setupBattle()
 {
     emit(battleAboutToStart());
     QList<Client*> clients = m_teams.keys();
@@ -391,7 +395,7 @@ void Sigencore::Arena::setupBattle()
     emit(battleStarted());
 }
 
-void Sigencore::Arena::distributeWinnings()
+void Arena::distributeWinnings()
 {
     QList<Client*> clients = m_teams.keys();
     foreach (Client* client, clients)
@@ -405,7 +409,7 @@ void Sigencore::Arena::distributeWinnings()
     }
 }
 
-void Sigencore::Arena::checkForLosers()
+void Arena::checkForLosers()
 {
     QList<Client*> clients = m_teams.keys();
     QList<Player*> roundLosers;
@@ -425,7 +429,7 @@ void Sigencore::Arena::checkForLosers()
     foreach (Player* loser, roundLosers)
     {
         const int money = loser->money();
-        Sigcore::Fraction lossFactor(1, 2);
+        Fraction lossFactor(1, 2);
         m_game->valueOfType("lossFactor", &lossFactor);
         pot[m_teams[loser]] += money * lossFactor;
         m_spoils[loser].second = money * lossFactor;
@@ -455,7 +459,7 @@ void Sigencore::Arena::checkForLosers()
         cleanUp();
 }
 
-Sigencore::TeamMember* Sigencore::Arena::findMember(const QUuid& id)
+TeamMember* Arena::findMember(const QUuid& id)
 {
     QList<Client*> clients = m_teams.keys();
     foreach (Client* client, clients)
diff --git a/sigencore/CMakeLists.txt b/sigencore/CMakeLists.txt
index b9c7d27b..b0ab1d46 100644
--- a/sigencore/CMakeLists.txt
+++ b/sigencore/CMakeLists.txt
@@ -50,6 +50,8 @@ target_link_libraries(sigencore LINK_INTERFACE_LIBRARIES
     sigscript
 )
 
+add_subdirectory(plugins)
+
 install(
     TARGETS
         sigencore
diff --git a/sigencore/Client.cpp b/sigencore/Client.cpp
index f877db11..a176a335 100644
--- a/sigencore/Client.cpp
+++ b/sigencore/Client.cpp
@@ -18,23 +18,26 @@
 // Header include
 #include "Client.h"
 
-Sigencore::Client::Client(Sigscript::GameWrapper* game, Sigscript::Config* parent) :
-        Sigscript::Config(parent),
+using namespace Sigscript;
+using namespace Sigencore;
+
+Client::Client(GameWrapper* game, Config* parent) :
+        Config(parent),
         m_game(game)
 {
 }
 
-Sigencore::Client::~Client()
+Client::~Client()
 {
 }
 
-bool Sigencore::Client::enterArena(Arena* arena)
+bool Client::enterArena(Arena* arena)
 {
     m_arena = arena;
     return true;
 }
 
-void Sigencore::Client::exitArena()
+void Client::exitArena()
 {
     m_arena = NULL;
 }
diff --git a/sigencore/Containment.cpp b/sigencore/Containment.cpp
index 116f73f0..f84bbfed 100644
--- a/sigencore/Containment.cpp
+++ b/sigencore/Containment.cpp
@@ -25,27 +25,30 @@
 #include <sigscript/GameWrapper.h>
 #include <sigscript/RulesWrapper.h>
 
-Sigencore::Containment::Containment(Sigscript::GameWrapper* game, Sigscript::Config* parent) :
-        Sigscript::Config(parent),
+using namespace Sigscript;
+using namespace Sigencore;
+
+Containment::Containment(GameWrapper* game, Config* parent) :
+        Config(parent),
         m_game(game)
 {
 }
 
-Sigencore::Containment::~Containment()
+Containment::~Containment()
 {
 }
 
-QList<Sigencore::Creature*> Sigencore::Containment::members() const
+QList<Creature*> Containment::members() const
 {
     return m_members;
 }
 
-int Sigencore::Containment::numMembers() const
+int Containment::numMembers() const
 {
     return m_members.size();
 }
 
-bool Sigencore::Containment::addMember(Creature* member)
+bool Containment::addMember(Creature* member)
 {
     member->setContainment(this);
     m_members.append(member);
@@ -53,13 +56,13 @@ bool Sigencore::Containment::addMember(Creature* member)
     return true;
 }
 
-bool Sigencore::Containment::removeMember(Creature* member)
+bool Containment::removeMember(Creature* member)
 {
     // TODO
     return false;
 }
 
-Sigencore::Creature* Sigencore::Containment::findMember(const QUuid& id) const
+Creature* Containment::findMember(const QUuid& id) const
 {
     foreach (Creature* member, m_members)
     {
@@ -69,7 +72,7 @@ Sigencore::Creature* Sigencore::Containment::findMember(const QUuid& id) const
     return NULL;
 }
 
-bool Sigencore::Containment::reorder(const int from, const int to)
+bool Containment::reorder(const int from, const int to)
 {
     if ((from < m_members.size()) && (to < m_members.size()))
     {
@@ -81,7 +84,7 @@ bool Sigencore::Containment::reorder(const int from, const int to)
     return false;
 }
 
-Sigscript::GameWrapper* Sigencore::Containment::game() const
+GameWrapper* Containment::game() const
 {
     return m_game;
 }
diff --git a/sigencore/Creature.cpp b/sigencore/Creature.cpp
index d276f797..9e9ef34d 100644
--- a/sigencore/Creature.cpp
+++ b/sigencore/Creature.cpp
@@ -39,10 +39,15 @@
 // C includes
 #include <cmath>
 
-QMap<Sigencore::Creature::StyleLevel, long long> Sigencore::Creature::m_expCache;
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigscript;
+using namespace Sigencore;
 
-Sigencore::Creature::Creature(Sigscript::SpeciesWrapper* species, const int level, Containment* containment, const bool suppressInitialization) :
-        Sigscript::Config(containment),
+QMap<Creature::StyleLevel, long long> Creature::m_expCache;
+
+Creature::Creature(SpeciesWrapper* species, const int level, Containment* containment, const bool suppressInitialization) :
+        Config(containment),
         m_game(containment->game()),
         m_containment(containment),
         m_species(species),
@@ -51,33 +56,33 @@ Sigencore::Creature::Creature(Sigscript::SpeciesWrapper* species, const int leve
         m_levelExp(calcLevelExperience(species->growth(), level)),
         m_id(QUuid::createUuid())
 {
-    for (int i = 0; i < (Sigmod::ST_SpecialDefense - Sigmod::ST_HP + 1); ++i)
+    for (int i = 0; i < (ST_SpecialDefense - ST_HP + 1); ++i)
     {
         m_dv[i] = -1;
         m_statExp[i] = -1;
     }
-    for (int i = 0; i < (Sigmod::ST_SpecialDefense - Sigmod::ST_Attack + 1); ++i)
+    for (int i = 0; i < (ST_SpecialDefense - ST_Attack + 1); ++i)
         m_stages[i] = 0;
     if (!suppressInitialization)
         completeData();
 }
 
-Sigencore::Creature::~Creature()
+Creature::~Creature()
 {
     // TODO
 }
 
-QUuid Sigencore::Creature::id() const
+QUuid Creature::id() const
 {
     return m_id;
 }
 
-Sigscript::GameWrapper* Sigencore::Creature::game() const
+GameWrapper* Creature::game() const
 {
     return m_game;
 }
 
-bool Sigencore::Creature::setContainment(Containment* containment)
+bool Creature::setContainment(Containment* containment)
 {
     if (m_containment && m_containment->removeMember(this))
     {
@@ -87,32 +92,32 @@ bool Sigencore::Creature::setContainment(Containment* containment)
     return false;
 }
 
-Sigencore::Containment* Sigencore::Creature::containment() const
+Containment* Creature::containment() const
 {
     return m_containment;
 }
 
-Sigscript::SpeciesWrapper* Sigencore::Creature::species() const
+SpeciesWrapper* Creature::species() const
 {
     return m_species;
 }
 
-void Sigencore::Creature::setName(const QString& name)
+void Creature::setName(const QString& name)
 {
     m_name = name;
     emit(nameChanged(m_name));
 }
 
-QString Sigencore::Creature::name() const
+QString Creature::name() const
 {
     return m_name;
 }
 
-bool Sigencore::Creature::setGender(const Gender gender)
+bool Creature::setGender(const Gender gender)
 {
     if (!m_game->rules()->genderAllowed())
         return false;
-    const Sigcore::Fraction genderFactor = m_species->genderFactor();
+    const Fraction genderFactor = m_species->genderFactor();
     switch (gender)
     {
         case Male:
@@ -135,12 +140,12 @@ bool Sigencore::Creature::setGender(const Gender gender)
     return true;
 }
 
-Sigencore::Creature::Gender Sigencore::Creature::gender() const
+Creature::Gender Creature::gender() const
 {
     return m_gender;
 }
 
-bool Sigencore::Creature::setLevel(const int level)
+bool Creature::setLevel(const int level)
 {
     if ((level <= 0) || (m_game->rules()->maxLevel() < level))
         return false;
@@ -151,17 +156,17 @@ bool Sigencore::Creature::setLevel(const int level)
     return true;
 }
 
-bool Sigencore::Creature::giveLevels(const int levels)
+bool Creature::giveLevels(const int levels)
 {
     return setLevel(m_level + levels);
 }
 
-int Sigencore::Creature::level() const
+int Creature::level() const
 {
     return m_level;
 }
 
-int Sigencore::Creature::calcLevel(const Sigmod::Species::Style growth, const long long levelExp)
+int Creature::calcLevel(const Species::Style growth, const long long levelExp)
 {
     int level = -1;
     while (calcLevelExperience(growth, level + 1) < levelExp)
@@ -169,7 +174,7 @@ int Sigencore::Creature::calcLevel(const Sigmod::Species::Style growth, const lo
     return level;
 }
 
-bool Sigencore::Creature::setLevelExperience(const long long levelExp)
+bool Creature::setLevelExperience(const long long levelExp)
 {
     if (levelExp < 0)
         return false;
@@ -186,17 +191,17 @@ bool Sigencore::Creature::setLevelExperience(const long long levelExp)
     return true;
 }
 
-bool Sigencore::Creature::giveLevelExperience(const long long levelExp)
+bool Creature::giveLevelExperience(const long long levelExp)
 {
     return setLevelExperience(m_levelExp + levelExp);
 }
 
-long long Sigencore::Creature::levelExperience() const
+long long Creature::levelExperience() const
 {
     return m_levelExp;
 }
 
-long long Sigencore::Creature::calcLevelExperience(const Sigmod::Species::Style growth, const int level)
+long long Creature::calcLevelExperience(const Species::Style growth, const int level)
 {
     if (m_expCache.contains(StyleLevel(growth, level)))
         return m_expCache[StyleLevel(growth, level)];
@@ -205,7 +210,7 @@ long long Sigencore::Creature::calcLevelExperience(const Sigmod::Species::Style
     long long exp = -1;
     switch (growth)
     {
-        case Sigmod::Species::Fluctuating:
+        case Species::Fluctuating:
             if (level <= 15)
                 exp = cube * ((24 + (level + 1) / 3) / 50.);
             else if (level <= 35)
@@ -218,19 +223,19 @@ long long Sigencore::Creature::calcLevelExperience(const Sigmod::Species::Style
             else
                 exp = 5 * cube / 3;
             break;
-        case Sigmod::Species::Fading:
+        case Species::Fading:
             exp = 6 * cube / 5 - 15 * square + 100 * level - 140;
             break;
-        case Sigmod::Species::Slow:
+        case Species::Slow:
             exp = 5 * cube / 4;
             break;
-        case Sigmod::Species::Normal:
+        case Species::Normal:
             exp = cube;
             break;
-        case Sigmod::Species::Fast:
+        case Species::Fast:
             exp = 4 * cube / 5;
             break;
-        case Sigmod::Species::Erratic:
+        case Species::Erratic:
         {
             const double p[] = {0.000, 0.008, 0.014};
             if (level <= 50)
@@ -254,9 +259,9 @@ long long Sigencore::Creature::calcLevelExperience(const Sigmod::Species::Style
     return exp;
 }
 
-bool Sigencore::Creature::setCurrentHp(const int hp)
+bool Creature::setCurrentHp(const int hp)
 {
-    if ((hp < 0) || (statValue(Sigmod::ST_HP) < hp))
+    if ((hp < 0) || (statValue(ST_HP) < hp))
         return false;
     m_currentHp = hp;
     emit(currentHpChanged(m_currentHp));
@@ -265,51 +270,51 @@ bool Sigencore::Creature::setCurrentHp(const int hp)
     return true;
 }
 
-bool Sigencore::Creature::changeCurrentHp(const int hp)
+bool Creature::changeCurrentHp(const int hp)
 {
     return setCurrentHp(m_currentHp + hp);
 }
 
-int Sigencore::Creature::currentHp() const
+int Creature::currentHp() const
 {
     return m_currentHp;
 }
 
-bool Sigencore::Creature::setDv(const Sigmod::Stat stat, const int dv)
+bool Creature::setDv(const Stat stat, const int dv)
 {
-    if ((stat == Sigmod::ST_SpecialDefense) && !(m_game->rules()->specialSplit() && m_game->rules()->specialDVSplit()))
+    if ((stat == ST_SpecialDefense) && !(m_game->rules()->specialSplit() && m_game->rules()->specialDVSplit()))
         return false;
     m_dv[stat] = dv;
     emit(dvChanged(stat, dv));
     return true;
 }
 
-int Sigencore::Creature::dv(const Sigmod::Stat stat) const
+int Creature::dv(const Stat stat) const
 {
-    if ((stat == Sigmod::ST_Accuracy) || (stat == Sigmod::ST_Evasion))
+    if ((stat == ST_Accuracy) || (stat == ST_Evasion))
         return false;
-    Sigmod::Stat actualStat = stat;
-    if (stat == Sigmod::ST_SpecialDefense)
+    Stat actualStat = stat;
+    if (stat == ST_SpecialDefense)
     {
         if (m_game->rules()->specialSplit() && m_game->rules()->specialDVSplit())
-            actualStat = Sigmod::ST_Special;
+            actualStat = ST_Special;
         else
             return false;
     }
     int dv;
-    if (valueOfType(QString("stat-dv-%1").arg((m_game->rules()->specialSplit() ? Sigmod::StatGSCStr : Sigmod::StatRBYStr)[actualStat]), &dv) && (dv < (m_game->rules()->specialDVSplit() ? 32 : 16)))
+    if (valueOfType(QString("stat-dv-%1").arg((m_game->rules()->specialSplit() ? StatGSCStr : StatRBYStr)[actualStat]), &dv) && (dv < (m_game->rules()->specialDVSplit() ? 32 : 16)))
         return dv;
     return m_dv[actualStat];
 }
 
-bool Sigencore::Creature::setStatExperience(const Sigmod::Stat stat, const long long statExp)
+bool Creature::setStatExperience(const Stat stat, const long long statExp)
 {
-    if ((stat == Sigmod::ST_Accuracy) || (stat == Sigmod::ST_Evasion) || ((stat == Sigmod::ST_SpecialDefense) && !m_game->rules()->specialSplit()))
+    if ((stat == ST_Accuracy) || (stat == ST_Evasion) || ((stat == ST_SpecialDefense) && !m_game->rules()->specialSplit()))
         return false;
     if (m_game->rules()->effortValuesAllowed())
     {
         int evSum = statExp;
-        for (int i = Sigmod::ST_HP; i <= (m_game->rules()->specialSplit() ? Sigmod::ST_Special : Sigmod::ST_SpecialDefense); ++i)
+        for (int i = ST_HP; i <= (m_game->rules()->specialSplit() ? ST_Special : ST_SpecialDefense); ++i)
         {
             if (i != stat)
                 evSum += m_statExp[i];
@@ -322,30 +327,30 @@ bool Sigencore::Creature::setStatExperience(const Sigmod::Stat stat, const long
     return true;
 }
 
-bool Sigencore::Creature::giveStatExperience(const Sigmod::Stat stat, const long long statExp)
+bool Creature::giveStatExperience(const Stat stat, const long long statExp)
 {
     return setStatExperience(stat, m_statExp[stat] + statExp);
 }
 
-long long Sigencore::Creature::statExperience(const Sigmod::Stat stat) const
+long long Creature::statExperience(const Stat stat) const
 {
     long long exp = m_statExp[stat];
-    valueOfType(QString("stat-experience-%1").arg((m_game->rules()->specialSplit() ? Sigmod::StatGSCStr : Sigmod::StatRBYStr)[stat]), &exp);
+    valueOfType(QString("stat-experience-%1").arg((m_game->rules()->specialSplit() ? StatGSCStr : StatRBYStr)[stat]), &exp);
     return exp;
 }
 
-int Sigencore::Creature::statValue(const Sigmod::Stat stat) const
+int Creature::statValue(const Stat stat) const
 {
-    Sigcore::Fraction multiplier;
-    if (stat != Sigmod::ST_HP)
+    Fraction multiplier;
+    if (stat != ST_HP)
     {
-        foreach (Sigscript::NatureWrapper* nature, m_natures)
+        foreach (NatureWrapper* nature, m_natures)
             multiplier *= nature->stat(stat);
     }
     return calcStat(m_game, stat, m_level, m_species->baseStat(stat), dv(stat), statExperience(stat), multiplier);
 }
 
-int Sigencore::Creature::calcStat(Sigscript::GameWrapper* game, const Sigmod::Stat stat, const int level, const int baseStat, const int dv, const int statExp, const Sigcore::Fraction& multiplier)
+int Creature::calcStat(GameWrapper* game, const Stat stat, const int level, const int baseStat, const int dv, const int statExp, const Fraction& multiplier)
 {
     int statValue = statExp;
     if (!game->rules()->effortValuesAllowed() && statValue)
@@ -357,36 +362,36 @@ int Sigencore::Creature::calcStat(Sigscript::GameWrapper* game, const Sigmod::St
     else
         statValue += dv;
     statValue *= double(level) / game->rules()->maxLevel();
-    if (stat == Sigmod::ST_HP)
+    if (stat == ST_HP)
         statValue += 10 + level;
     else
         statValue += 5;
     return statValue * multiplier;
 }
 
-void Sigencore::Creature::recalcStats()
+void Creature::recalcStats()
 {
     // FIXME?
-    recalcStat(Sigmod::ST_HP);
-    recalcStat(Sigmod::ST_Attack);
-    recalcStat(Sigmod::ST_Defense);
-    recalcStat(Sigmod::ST_Speed);
+    recalcStat(ST_HP);
+    recalcStat(ST_Attack);
+    recalcStat(ST_Defense);
+    recalcStat(ST_Speed);
     if (m_game->rules()->specialSplit())
     {
-        recalcStat(Sigmod::ST_SpecialAttack);
-        recalcStat(Sigmod::ST_SpecialDefense);
+        recalcStat(ST_SpecialAttack);
+        recalcStat(ST_SpecialDefense);
     }
     else
-        recalcStat(Sigmod::ST_Special);
+        recalcStat(ST_Special);
 }
 
-void Sigencore::Creature::recalcStat(const Sigmod::Stat stat)
+void Creature::recalcStat(const Stat stat)
 {
     // FIXME?
     emit(statValueChanged(stat, statValue(stat)));
 }
 
-bool Sigencore::Creature::addAbility(Sigscript::AbilityWrapper* ability)
+bool Creature::addAbility(AbilityWrapper* ability)
 {
     if ((m_abilities.size() < m_game->rules()->maxAbilities()) && !m_abilities.contains(ability))
     {
@@ -397,7 +402,7 @@ bool Sigencore::Creature::addAbility(Sigscript::AbilityWrapper* ability)
     return false;
 }
 
-bool Sigencore::Creature::removeAbility(Sigscript::AbilityWrapper* ability)
+bool Creature::removeAbility(AbilityWrapper* ability)
 {
     if (m_abilities.contains(ability))
     {
@@ -408,17 +413,17 @@ bool Sigencore::Creature::removeAbility(Sigscript::AbilityWrapper* ability)
     return false;
 }
 
-QList<Sigscript::AbilityWrapper*> Sigencore::Creature::abilities() const
+QList<AbilityWrapper*> Creature::abilities() const
 {
     return m_abilities;
 }
 
-bool Sigencore::Creature::hasAbility(Sigscript::AbilityWrapper* ability) const
+bool Creature::hasAbility(AbilityWrapper* ability) const
 {
     return m_abilities.contains(ability);
 }
 
-bool Sigencore::Creature::addItems(Sigscript::ItemWrapper* item, const int count, const bool allOrNothing)
+bool Creature::addItems(ItemWrapper* item, const int count, const bool allOrNothing)
 {
     const int addWeight = count * item->weight();
     int end = 0;
@@ -459,35 +464,35 @@ bool Sigencore::Creature::addItems(Sigscript::ItemWrapper* item, const int count
     return count - end;
 }
 
-QList<Sigscript::ItemWrapper*> Sigencore::Creature::items() const
+QList<ItemWrapper*> Creature::items() const
 {
     return m_items.keys();
 }
 
-int Sigencore::Creature::itemWeight() const
+int Creature::itemWeight() const
 {
     int weight = 0;
-    QList<Sigscript::ItemWrapper*> items = m_items.keys();
-    foreach (Sigscript::ItemWrapper* curItem, items)
+    QList<ItemWrapper*> items = m_items.keys();
+    foreach (ItemWrapper* curItem, items)
         weight += curItem->weight() * m_items[curItem];
     return weight;
 }
 
-int Sigencore::Creature::itemCount() const
+int Creature::itemCount() const
 {
     int count = 0;
-    QList<Sigscript::ItemWrapper*> items = m_items.keys();
-    foreach (Sigscript::ItemWrapper* curItem, items)
+    QList<ItemWrapper*> items = m_items.keys();
+    foreach (ItemWrapper* curItem, items)
         count += m_items[curItem];
     return count;
 }
 
-int Sigencore::Creature::hasItem(Sigscript::ItemWrapper* item) const
+int Creature::hasItem(ItemWrapper* item) const
 {
     return m_items.count(item);
 }
 
-bool Sigencore::Creature::addMove(Sigscript::MoveWrapper* move)
+bool Creature::addMove(MoveWrapper* move)
 {
     bool canLearn = false;
     for (int i = 0; !canLearn && (i < m_species->moveCount()); ++i)
@@ -504,7 +509,7 @@ bool Sigencore::Creature::addMove(Sigscript::MoveWrapper* move)
     return false;
 }
 
-bool Sigencore::Creature::removeMove(Sigscript::MoveWrapper* move)
+bool Creature::removeMove(MoveWrapper* move)
 {
     if (m_moves.contains(move) && (1 < m_moves.size()))
     {
@@ -515,17 +520,17 @@ bool Sigencore::Creature::removeMove(Sigscript::MoveWrapper* move)
     return false;
 }
 
-QList<Sigscript::MoveWrapper*> Sigencore::Creature::moves() const
+QList<MoveWrapper*> Creature::moves() const
 {
     return m_moves;
 }
 
-bool Sigencore::Creature::hasMove(Sigscript::MoveWrapper* move) const
+bool Creature::hasMove(MoveWrapper* move) const
 {
     return m_moves.contains(move);
 }
 
-bool Sigencore::Creature::addNature(Sigscript::NatureWrapper* nature)
+bool Creature::addNature(NatureWrapper* nature)
 {
     if ((m_natures.size() < m_game->rules()->maxNatures()) && !m_natures.contains(nature))
     {
@@ -536,7 +541,7 @@ bool Sigencore::Creature::addNature(Sigscript::NatureWrapper* nature)
     return false;
 }
 
-bool Sigencore::Creature::removeNature(Sigscript::NatureWrapper* nature)
+bool Creature::removeNature(NatureWrapper* nature)
 {
     if (m_natures.contains(nature))
     {
@@ -547,17 +552,17 @@ bool Sigencore::Creature::removeNature(Sigscript::NatureWrapper* nature)
     return false;
 }
 
-QList<Sigscript::NatureWrapper*> Sigencore::Creature::natures() const
+QList<NatureWrapper*> Creature::natures() const
 {
     return m_natures;
 }
 
-bool Sigencore::Creature::hasNature(Sigscript::NatureWrapper* nature) const
+bool Creature::hasNature(NatureWrapper* nature) const
 {
     return m_natures.contains(nature);
 }
 
-bool Sigencore::Creature::addStatus(Sigscript::StatusWrapper* status)
+bool Creature::addStatus(StatusWrapper* status)
 {
     if (!m_status.contains(status))
     {
@@ -568,7 +573,7 @@ bool Sigencore::Creature::addStatus(Sigscript::StatusWrapper* status)
     return false;
 }
 
-bool Sigencore::Creature::removeStatus(Sigscript::StatusWrapper* status)
+bool Creature::removeStatus(StatusWrapper* status)
 {
     if (m_status.contains(status))
     {
@@ -579,17 +584,17 @@ bool Sigencore::Creature::removeStatus(Sigscript::StatusWrapper* status)
     return false;
 }
 
-QList<Sigscript::StatusWrapper*> Sigencore::Creature::status() const
+QList<StatusWrapper*> Creature::status() const
 {
     return m_status;
 }
 
-bool Sigencore::Creature::hasStatus(Sigscript::StatusWrapper* status) const
+bool Creature::hasStatus(StatusWrapper* status) const
 {
     return m_status.contains(status);
 }
 
-void Sigencore::Creature::completeData()
+void Creature::completeData()
 {
     // TODO
     if (!m_name.isEmpty())
@@ -610,37 +615,37 @@ void Sigencore::Creature::completeData()
     emit(initialized());
 }
 
-void Sigencore::Creature::completeStats()
+void Creature::completeStats()
 {
     if (m_game->rules()->specialSplit() && m_game->rules()->specialDVSplit())
     {
-        for (int i = Sigmod::ST_HP; i <= Sigmod::ST_SpecialDefense; ++i)
+        for (int i = ST_HP; i <= ST_SpecialDefense; ++i)
             m_dv[i] = qrand() & 31;
     }
     else
     {
-        for (int i = Sigmod::ST_Attack; i <= Sigmod::ST_Special; ++i)
+        for (int i = ST_Attack; i <= ST_Special; ++i)
             m_dv[i] = qrand() & 15;
-        m_dv[Sigmod::ST_HP] = ((m_dv[Sigmod::ST_Attack] & 1) << 3) + ((m_dv[Sigmod::ST_Defense] & 1) << 2) + ((m_dv[Sigmod::ST_Speed] & 1) << 1) + (m_dv[Sigmod::ST_Special] & 1);
+        m_dv[ST_HP] = ((m_dv[ST_Attack] & 1) << 3) + ((m_dv[ST_Defense] & 1) << 2) + ((m_dv[ST_Speed] & 1) << 1) + (m_dv[ST_Special] & 1);
     }
 }
 
-void Sigencore::Creature::completeAbilities()
+void Creature::completeAbilities()
 {
-    Sigcore::Hat<Sigscript::AbilityWrapper*> abilityHat = m_species->abilityHat();
+    Hat<AbilityWrapper*> abilityHat = m_species->abilityHat();
     while ((m_abilities.size() < game()->rules()->maxAbilities()) && abilityHat.count())
         addAbility(abilityHat.takeAndClear());
 }
 
-void Sigencore::Creature::completeItems()
+void Creature::completeItems()
 {
-    Sigcore::Hat<Sigscript::ItemWrapper*> itemHat = m_species->itemHat();
+    Hat<ItemWrapper*> itemHat = m_species->itemHat();
     int i = 0;
     while ((i < m_game->rules()->maxHeldItems()) && itemHat.count())
     {
         if (m_species->itemChance().poll())
         {
-            Sigscript::ItemWrapper* item = itemHat.pick();
+            ItemWrapper* item = itemHat.pick();
             if (addItems(item, 1))
                 ++i;
             else
@@ -651,12 +656,12 @@ void Sigencore::Creature::completeItems()
     }
 }
 
-void Sigencore::Creature::completeMoves()
+void Creature::completeMoves()
 {
-    QMap<int, Sigscript::MoveWrapper*> moves;
+    QMap<int, MoveWrapper*> moves;
     for (int i = 0; i < m_species->moveCount(); ++i)
     {
-        Sigscript::SpeciesMoveWrapper* move = m_species->move(i);
+        SpeciesMoveWrapper* move = m_species->move(i);
         const int level = move->level();
         if ((0 <= level) && (level <= m_level))
             moves[level] = move->move();
@@ -664,18 +669,18 @@ void Sigencore::Creature::completeMoves()
     // TODO: give the moves to the creature
 }
 
-void Sigencore::Creature::completeNatures()
+void Creature::completeNatures()
 {
-    Sigcore::Hat<Sigscript::NatureWrapper*> natureHat = game()->natureHat();
+    Hat<NatureWrapper*> natureHat = game()->natureHat();
     while ((m_natures.size() < m_game->rules()->maxNatures()) && natureHat.count())
         addNature(natureHat.takeAndClear());
 }
 
-void Sigencore::Creature::makeConnections()
+void Creature::makeConnections()
 {
     connect(this, SIGNAL(levelChanged(int)), SLOT(recalcStats()));
-    connect(this, SIGNAL(natureAdded(Sigscript::NatureWrapper*)), SLOT(recalcStats()));
-    connect(this, SIGNAL(natureRemoved(Sigscript::NatureWrapper*)), SLOT(recalcStats()));
-    connect(this, SIGNAL(dvChanged(Sigmod::Stat, int)), SLOT(recalcStat(Sigmod::Stat)));
-    connect(this, SIGNAL(statExperienceChanged(Sigmod::Stat, long long)), SLOT(recalcStat(Sigmod::Stat)));
+    connect(this, SIGNAL(natureAdded(NatureWrapper*)), SLOT(recalcStats()));
+    connect(this, SIGNAL(natureRemoved(NatureWrapper*)), SLOT(recalcStats()));
+    connect(this, SIGNAL(dvChanged(Stat, int)), SLOT(recalcStat(Stat)));
+    connect(this, SIGNAL(statExperienceChanged(Stat, long long)), SLOT(recalcStat(Stat)));
 }
diff --git a/sigencore/Overworld.cpp b/sigencore/Overworld.cpp
index b5b090ad..51f00c81 100644
--- a/sigencore/Overworld.cpp
+++ b/sigencore/Overworld.cpp
@@ -17,3 +17,4 @@
 
 #include "Overworld.h"
 
+using namespace Sigencore;
diff --git a/sigencore/Player.cpp b/sigencore/Player.cpp
index 2b72657f..85787936 100644
--- a/sigencore/Player.cpp
+++ b/sigencore/Player.cpp
@@ -27,7 +27,10 @@
 #include <sigscript/ItemTypeWrapper.h>
 #include <sigscript/RulesWrapper.h>
 
-Sigencore::Player::Player(Sigscript::GameWrapper* game, Sigscript::Config* parent) :
+using namespace Sigscript;
+using namespace Sigencore;
+
+Player::Player(GameWrapper* game, Config* parent) :
         Client(game, parent),
         m_world(NULL),
         m_arena(NULL),
@@ -36,31 +39,31 @@ Sigencore::Player::Player(Sigscript::GameWrapper* game, Sigscript::Config* paren
 {
 }
 
-Sigencore::Player::~Player()
+Player::~Player()
 {
 }
 
-Sigencore::Overworld* Sigencore::Player::world() const
+Overworld* Player::world() const
 {
     return m_world;
 }
 
-bool Sigencore::Player::enterWorld(Overworld* world)
+bool Player::enterWorld(Overworld* world)
 {
     // TODO
 }
 
-void Sigencore::Player::exitWorld()
+void Player::exitWorld()
 {
     // TODO
 }
 
-Sigencore::Arena* Sigencore::Player::arena() const
+Arena* Player::arena() const
 {
     return m_arena;
 }
 
-bool Sigencore::Player::enterArena(Arena* arena)
+bool Player::enterArena(Arena* arena)
 {
     m_active.clear();
     for (int i = 0; (m_active.size() < m_game->rules()->maxFight()) && (i < m_team->numMembers()); ++i)
@@ -75,7 +78,7 @@ bool Sigencore::Player::enterArena(Arena* arena)
     return (m_active.size() && Client::enterArena(arena));
 }
 
-void Sigencore::Player::exitArena()
+void Player::exitArena()
 {
     foreach (TeamMember* teamMember, m_active)
         teamMember->exitArena();
@@ -83,22 +86,22 @@ void Sigencore::Player::exitArena()
     Client::exitArena();
 }
 
-int Sigencore::Player::itemWeightTotal(const bool distinct) const
+int Player::itemWeightTotal(const bool distinct) const
 {
-    QList<Sigscript::ItemWrapper*> items = m_items.keys();
+    QList<ItemWrapper*> items = m_items.keys();
     int weight = 0;
-    foreach (Sigscript::ItemWrapper* item, items)
+    foreach (ItemWrapper* item, items)
         weight += item->weight() * (distinct ? m_items[item] : 1);
     return weight;
 }
 
-int Sigencore::Player::itemWeightType(const int type, const bool distinct) const
+int Player::itemWeightType(const int type, const bool distinct) const
 {
     if (type < 0)
         return itemWeightTotal(distinct);
-    QList<Sigscript::ItemWrapper*> items = m_items.keys();
+    QList<ItemWrapper*> items = m_items.keys();
     int weight = 0;
-    foreach (Sigscript::ItemWrapper* item, items)
+    foreach (ItemWrapper* item, items)
     {
         if (item->type()->id() == type)
             weight += item->weight() * (distinct ? m_items[item] : 1);
@@ -106,33 +109,33 @@ int Sigencore::Player::itemWeightType(const int type, const bool distinct) const
     return weight;
 }
 
-int Sigencore::Player::itemWeight(const int item, const bool distinct) const
+int Player::itemWeight(const int item, const bool distinct) const
 {
     if (item < 0)
         return itemWeightTotal(distinct);
-    Sigscript::ItemWrapper* itemd = m_game->item(item);
+    ItemWrapper* itemd = m_game->item(item);
     int weight = 0;
     if (itemd && m_items.contains(itemd))
         weight += itemd->weight() * (distinct ? m_items[itemd] : 1);
     return weight;
 }
 
-int Sigencore::Player::itemCountTotal(const bool distinct) const
+int Player::itemCountTotal(const bool distinct) const
 {
-    QList<Sigscript::ItemWrapper*> items = m_items.keys();
+    QList<ItemWrapper*> items = m_items.keys();
     int count = 0;
-    foreach (Sigscript::ItemWrapper* item, items)
+    foreach (ItemWrapper* item, items)
         count += (distinct ? m_items[item] : 1);
     return count;
 }
 
-int Sigencore::Player::itemCountType(const int type, const bool distinct) const
+int Player::itemCountType(const int type, const bool distinct) const
 {
     if (type < 0)
         return itemCountTotal(distinct);
-    QList<Sigscript::ItemWrapper*> items = m_items.keys();
+    QList<ItemWrapper*> items = m_items.keys();
     int count = 0;
-    foreach (Sigscript::ItemWrapper* item, items)
+    foreach (ItemWrapper* item, items)
     {
         if (item->type()->id() == type)
             count += (distinct ? m_items[item] : 1);
@@ -140,24 +143,24 @@ int Sigencore::Player::itemCountType(const int type, const bool distinct) const
     return count;
 }
 
-int Sigencore::Player::itemCount(const int item, const bool distinct) const
+int Player::itemCount(const int item, const bool distinct) const
 {
     if (item < 0)
         return itemCountTotal(distinct);
-    Sigscript::ItemWrapper* itemd = m_game->item(item);
+    ItemWrapper* itemd = m_game->item(item);
     int count = 0;
     if (itemd && m_items.contains(itemd))
         count += (distinct ? m_items[itemd] : 1);
     return count;
 }
 
-QMap<Sigscript::ItemWrapper*, int> Sigencore::Player::items(const int type) const
+QMap<ItemWrapper*, int> Player::items(const int type) const
 {
     if (type < 0)
         return m_items;
-    QMap<Sigscript::ItemWrapper*, int> itemMap = m_items;
-    QList<Sigscript::ItemWrapper*> items = itemMap.keys();
-    foreach (Sigscript::ItemWrapper* item, items)
+    QMap<ItemWrapper*, int> itemMap = m_items;
+    QList<ItemWrapper*> items = itemMap.keys();
+    foreach (ItemWrapper* item, items)
     {
         if (item->id() != type)
             itemMap.remove(item);
@@ -165,7 +168,7 @@ QMap<Sigscript::ItemWrapper*, int> Sigencore::Player::items(const int type) cons
     return itemMap;
 }
 
-int Sigencore::Player::giveItems(Sigscript::ItemWrapper* item, const int count, const bool allOrNothing)
+int Player::giveItems(ItemWrapper* item, const int count, const bool allOrNothing)
 {
     const int id = item->id();
     const QString name = item->name();
@@ -243,7 +246,7 @@ int Sigencore::Player::giveItems(Sigscript::ItemWrapper* item, const int count,
     return count - end;
 }
 
-bool Sigencore::Player::giveMoney(const int amount, const bool allOrNothing)
+bool Player::giveMoney(const int amount, const bool allOrNothing)
 {
     int playerMin = 0;
     int playerMax = m_game->rules()->maxMoney();
@@ -259,22 +262,22 @@ bool Sigencore::Player::giveMoney(const int amount, const bool allOrNothing)
     return qAbs(newUnbounded - newAmount);
 }
 
-Sigencore::Team* Sigencore::Player::team() const
+Team* Player::team() const
 {
     return m_team;
 }
 
-Sigencore::TeamMember* Sigencore::Player::findMember(const QUuid& id) const
+TeamMember* Player::findMember(const QUuid& id) const
 {
     return m_team->findTeamMember(id);
 }
 
-QList<Sigencore::TeamMember*> Sigencore::Player::active() const
+QList<TeamMember*> Player::active() const
 {
     return m_active;
 }
 
-void Sigencore::Player::switchOut(TeamMember* oldActive, TeamMember* newActive)
+void Player::switchOut(TeamMember* oldActive, TeamMember* newActive)
 {
     oldActive->exitArena();
     newActive->makeActive(m_arena);
@@ -282,12 +285,12 @@ void Sigencore::Player::switchOut(TeamMember* oldActive, TeamMember* newActive)
     m_active.append(newActive);
 }
 
-bool Sigencore::Player::isKnockedOut() const
+bool Player::isKnockedOut() const
 {
     return m_team->isKnockedOut();
 }
 
-int Sigencore::Player::money() const
+int Player::money() const
 {
     return m_money;
 }
diff --git a/sigencore/RunScript.cpp b/sigencore/RunScript.cpp
index 13ba699d..a6c11bca 100644
--- a/sigencore/RunScript.cpp
+++ b/sigencore/RunScript.cpp
@@ -29,7 +29,11 @@
 #include <kross/core/action.h>
 #include <kross/core/actioncollection.h>
 
-Kross::Action* Sigencore::runScript(const QString& name, const Sigcore::Script& script, const ObjectMap& objects, Kross::ActionCollection* collection)
+using namespace Sigcore;
+using namespace Sigscript;
+using namespace Sigencore;
+
+Kross::Action* Sigencore::runScript(const QString& name, const Script& script, const ObjectMap& objects, Kross::ActionCollection* collection)
 {
     Kross::Action* action = new Kross::Action(collection, name);
     action->setInterpreter(script.interpreter());
@@ -40,9 +44,9 @@ Kross::Action* Sigencore::runScript(const QString& name, const Sigcore::Script&
     return action;
 }
 
-Kross::Action* Sigencore::globalScript(Sigscript::GameWrapper* game, const QString& name, const QString& scriptName, const ObjectMap& objects, Kross::ActionCollection* collection)
+Kross::Action* Sigencore::globalScript(GameWrapper* game, const QString& name, const QString& scriptName, const ObjectMap& objects, Kross::ActionCollection* collection)
 {
-    Sigscript::GlobalScriptWrapper* script = game->globalScript(name);
+    GlobalScriptWrapper* script = game->globalScript(name);
     if (script)
         return runScript(scriptName, script->script(), objects, collection);
     return NULL;
diff --git a/sigencore/Team.cpp b/sigencore/Team.cpp
index 313539da..75f400f1 100644
--- a/sigencore/Team.cpp
+++ b/sigencore/Team.cpp
@@ -26,28 +26,31 @@
 #include <sigscript/GameWrapper.h>
 #include <sigscript/RulesWrapper.h>
 
-Sigencore::Team::Team(Sigscript::GameWrapper* game, Player* player) :
+using namespace Sigscript;
+using namespace Sigencore;
+
+Team::Team(GameWrapper* game, Player* player) :
         Containment(game, player),
         m_arena(NULL),
         m_player(player)
 {
 }
 
-Sigencore::Team::~Team()
+Team::~Team()
 {
 }
 
-QList<Sigencore::TeamMember*> Sigencore::Team::teamMembers() const
+QList<TeamMember*> Team::teamMembers() const
 {
     return m_teamMembers;
 }
 
-int Sigencore::Team::numTeamMembers() const
+int Team::numTeamMembers() const
 {
     return m_teamMembers.size();
 }
 
-bool Sigencore::Team::addTeamMember(TeamMember* teamMember)
+bool Team::addTeamMember(TeamMember* teamMember)
 {
     if (m_teamMembers.size() < m_game->rules()->maxParty())
     {
@@ -60,18 +63,18 @@ bool Sigencore::Team::addTeamMember(TeamMember* teamMember)
     return false;
 }
 
-bool Sigencore::Team::removeTeamMember(TeamMember* teamMember)
+bool Team::removeTeamMember(TeamMember* teamMember)
 {
     // TODO
     return false;
 }
 
-Sigencore::TeamMember* Sigencore::Team::findTeamMember(const QUuid& id) const
+TeamMember* Team::findTeamMember(const QUuid& id) const
 {
     return qobject_cast<TeamMember*>(Containment::findMember(id));
 }
 
-bool Sigencore::Team::reorder(const int from, const int to)
+bool Team::reorder(const int from, const int to)
 {
     if ((from < m_teamMembers.size()) && (to < m_teamMembers.size()))
     {
@@ -84,7 +87,7 @@ bool Sigencore::Team::reorder(const int from, const int to)
     return false;
 }
 
-bool Sigencore::Team::isKnockedOut() const
+bool Team::isKnockedOut() const
 {
     foreach (TeamMember* teamMember, m_teamMembers)
     {
@@ -94,13 +97,13 @@ bool Sigencore::Team::isKnockedOut() const
     return true;
 }
 
-void Sigencore::Team::setPlayer(Player* player)
+void Team::setPlayer(Player* player)
 {
     // TODO: Unlink m_player with this
     m_player = player;
 }
 
-Sigencore::Player* Sigencore::Team::player() const
+Player* Team::player() const
 {
     return m_player;
 }
diff --git a/sigencore/TeamMember.cpp b/sigencore/TeamMember.cpp
index ba0c9cce..663645ba 100644
--- a/sigencore/TeamMember.cpp
+++ b/sigencore/TeamMember.cpp
@@ -51,6 +51,11 @@
 // C includes
 #include <cmath>
 
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigscript;
+using namespace Sigencore;
+
 int Sigencore::actionPriority(TeamMember* teamMember, const TeamMember::Action& action)
 {
     int priority = INT_MAX;
@@ -93,24 +98,24 @@ int Sigencore::actionPriority(TeamMember* teamMember, const TeamMember::Action&
     return priority;
 }
 
-Sigencore::TeamMember::TeamMember(Sigscript::SpeciesWrapper* species, const int level, Team* team, const bool isWild, const bool suppressInitialization) :
+TeamMember::TeamMember(SpeciesWrapper* species, const int level, Team* team, const bool isWild, const bool suppressInitialization) :
         Creature(species, level, team, suppressInitialization),
         m_team(team),
         m_arena(NULL),
         m_isWild(isWild)
 {
-    for (int i = 0; i < (Sigmod::ST_SpecialDefense - Sigmod::ST_Attack + 1); ++i)
+    for (int i = 0; i < (ST_SpecialDefense - ST_Attack + 1); ++i)
         m_stages[i] = 0;
 }
 
-Sigencore::TeamMember::~TeamMember()
+TeamMember::~TeamMember()
 {
     if (m_arena)
         exitArena();
     // TODO: Clean up scripts
 }
 
-bool Sigencore::TeamMember::setContainment(Containment* containment)
+bool TeamMember::setContainment(Containment* containment)
 {
     Team* team = qobject_cast<Team*>(containment);
     if (team)
@@ -119,7 +124,7 @@ bool Sigencore::TeamMember::setContainment(Containment* containment)
     m_containment = containment;
 }
 
-bool Sigencore::TeamMember::setTeam(Team* team)
+bool TeamMember::setTeam(Team* team)
 {
     if (m_team && m_team->removeTeamMember(this))
     {
@@ -130,51 +135,51 @@ bool Sigencore::TeamMember::setTeam(Team* team)
     return false;
 }
 
-Sigencore::Team* Sigencore::TeamMember::team() const
+Team* TeamMember::team() const
 {
     return m_team;
 }
 
-bool Sigencore::TeamMember::setStatStage(const Sigmod::Stat stat, const int stage)
+bool TeamMember::setStatStage(const Stat stat, const int stage)
 {
-    if (stat == Sigmod::ST_HP)
+    if (stat == ST_HP)
         return false;
     if (m_game->rules()->maxStages() < qAbs(stage))
         return false;
-    m_stages[stat - Sigmod::ST_Attack] = stage;
+    m_stages[stat - ST_Attack] = stage;
     emit(statStageChanged(stat, stage));
     return true;
 }
 
-bool Sigencore::TeamMember::giveStatStages(const Sigmod::Stat stat, const int stages)
+bool TeamMember::giveStatStages(const Stat stat, const int stages)
 {
-    if (stat == Sigmod::ST_HP)
+    if (stat == ST_HP)
         return false;
-    return setStatStage(stat, m_stages[stat - Sigmod::ST_Attack] + stages);
+    return setStatStage(stat, m_stages[stat - ST_Attack] + stages);
 }
 
-int Sigencore::TeamMember::statStage(const Sigmod::Stat stat) const
+int TeamMember::statStage(const Stat stat) const
 {
     int stages;
-    if (stat == Sigmod::ST_HP)
+    if (stat == ST_HP)
         return 0;
-    if (valueOfType(QString("stat-stages-%1").arg((m_game->rules()->specialSplit() ? Sigmod::StatGSCStr : Sigmod::StatRBYStr)[stat]), &stages) &&  (qAbs(stages) <= m_game->rules()->maxStages()))
+    if (valueOfType(QString("stat-stages-%1").arg((m_game->rules()->specialSplit() ? StatGSCStr : StatRBYStr)[stat]), &stages) &&  (qAbs(stages) <= m_game->rules()->maxStages()))
         return stages;
-    return m_stages[stat - Sigmod::ST_Attack];
+    return m_stages[stat - ST_Attack];
 }
 
-int Sigencore::TeamMember::statValue(const Sigmod::Stat stat) const
+int TeamMember::statValue(const Stat stat) const
 {
-    Sigcore::Fraction multiplier;
+    Fraction multiplier;
     const int stage = statStage(stat);
     if (0 < stage)
-        multiplier *= Sigcore::Fraction(stage + 2, 2);
+        multiplier *= Fraction(stage + 2, 2);
     else if (stage < 0)
-        multiplier *= Sigcore::Fraction(2, stage + 2);
+        multiplier *= Fraction(2, stage + 2);
     return multiplier * Creature::statValue(stat);
 }
 
-bool Sigencore::TeamMember::addAbility(Sigscript::AbilityWrapper* ability)
+bool TeamMember::addAbility(AbilityWrapper* ability)
 {
     if ((m_abilities.size() < m_game->rules()->maxAbilities()) && !m_abilities.contains(ability))
     {
@@ -210,7 +215,7 @@ bool Sigencore::TeamMember::addAbility(Sigscript::AbilityWrapper* ability)
     return false;
 }
 
-bool Sigencore::TeamMember::removeAbility(Sigscript::AbilityWrapper* ability)
+bool TeamMember::removeAbility(AbilityWrapper* ability)
 {
     if (m_abilities.contains(ability))
     {
@@ -225,12 +230,12 @@ bool Sigencore::TeamMember::removeAbility(Sigscript::AbilityWrapper* ability)
     return false;
 }
 
-bool Sigencore::TeamMember::addItems(Sigscript::ItemWrapper* item, const int count, const bool allOrNothing)
+bool TeamMember::addItems(ItemWrapper* item, const int count, const bool allOrNothing)
 {
     // TODO: Handle scripts
 }
 
-bool Sigencore::TeamMember::addMove(Sigscript::MoveWrapper* move)
+bool TeamMember::addMove(MoveWrapper* move)
 {
     bool canLearn = false;
     for (int i = 0; !canLearn && (i < m_species->moveCount()); ++i)
@@ -260,7 +265,7 @@ bool Sigencore::TeamMember::addMove(Sigscript::MoveWrapper* move)
     return false;
 }
 
-bool Sigencore::TeamMember::removeMove(Sigscript::MoveWrapper* move)
+bool TeamMember::removeMove(MoveWrapper* move)
 {
     if (m_moves.contains(move) && (1 < m_moves.size()))
     {
@@ -275,7 +280,7 @@ bool Sigencore::TeamMember::removeMove(Sigscript::MoveWrapper* move)
     return false;
 }
 
-bool Sigencore::TeamMember::addNature(Sigscript::NatureWrapper* nature)
+bool TeamMember::addNature(NatureWrapper* nature)
 {
     if ((m_natures.size() < m_game->rules()->maxNatures()) && !m_natures.contains(nature))
     {
@@ -286,7 +291,7 @@ bool Sigencore::TeamMember::addNature(Sigscript::NatureWrapper* nature)
     return false;
 }
 
-bool Sigencore::TeamMember::removeNature(Sigscript::NatureWrapper* nature)
+bool TeamMember::removeNature(NatureWrapper* nature)
 {
     if (m_natures.contains(nature))
     {
@@ -297,7 +302,7 @@ bool Sigencore::TeamMember::removeNature(Sigscript::NatureWrapper* nature)
     return false;
 }
 
-bool Sigencore::TeamMember::addStatus(Sigscript::StatusWrapper* status)
+bool TeamMember::addStatus(StatusWrapper* status)
 {
     if (!m_status.contains(status))
     {
@@ -333,7 +338,7 @@ bool Sigencore::TeamMember::addStatus(Sigscript::StatusWrapper* status)
     return false;
 }
 
-bool Sigencore::TeamMember::removeStatus(Sigscript::StatusWrapper* status)
+bool TeamMember::removeStatus(StatusWrapper* status)
 {
     if (m_status.contains(status))
     {
@@ -348,13 +353,13 @@ bool Sigencore::TeamMember::removeStatus(Sigscript::StatusWrapper* status)
     return false;
 }
 
-void Sigencore::TeamMember::makeActive(Arena* arena)
+void TeamMember::makeActive(Arena* arena)
 {
     // TODO
     Team* team = qobject_cast<Team*>(this->containment());
-    foreach (Sigscript::StatusWrapper* status, m_status)
+    foreach (StatusWrapper* status, m_status)
     {
-        const Sigcore::Script script = status->battleScript();
+        const Script script = status->battleScript();
         if (!script.script().isEmpty())
         {
             ObjectMap objects;
@@ -368,9 +373,9 @@ void Sigencore::TeamMember::makeActive(Arena* arena)
             action->trigger();
         }
     }
-    foreach (Sigscript::AbilityWrapper* ability, m_abilities)
+    foreach (AbilityWrapper* ability, m_abilities)
     {
-        const Sigcore::Script script = ability->battleScript();
+        const Script script = ability->battleScript();
         if (!script.script().isEmpty())
         {
             ObjectMap objects;
@@ -387,27 +392,27 @@ void Sigencore::TeamMember::makeActive(Arena* arena)
     m_arena = arena;
 }
 
-void Sigencore::TeamMember::exitArena()
+void TeamMember::exitArena()
 {
     qDeleteAll(m_statusBattleScriptsMap.values());
     m_statusBattleScriptsMap.clear();
     qDeleteAll(m_abilityBattleScriptsMap.values());
     m_abilityBattleScriptsMap.clear();
-    for (int i = Sigmod::ST_Attack; i <= Sigmod::ST_Evasion; ++i)
+    for (int i = ST_Attack; i <= ST_Evasion; ++i)
     {
-        const QString entry = QString("stat-stages-%1").arg((m_game->rules()->specialSplit() ? Sigmod::StatGSCStr : Sigmod::StatRBYStr)[i]);
+        const QString entry = QString("stat-stages-%1").arg((m_game->rules()->specialSplit() ? StatGSCStr : StatRBYStr)[i]);
         if (options(entry) & Temporary)
             removeValue(entry, false);
     }
     m_arena = NULL;
 }
 
-void Sigencore::TeamMember::completeMoves()
+void TeamMember::completeMoves()
 {
-    QMap<int, Sigscript::MoveWrapper*> moves;
+    QMap<int, MoveWrapper*> moves;
     for (int i = 0; i < m_species->moveCount(); ++i)
     {
-        Sigscript::SpeciesMoveWrapper* move = m_species->move(i);
+        SpeciesMoveWrapper* move = m_species->move(i);
         const int level = m_isWild ? move->wild() : move->level();
         if ((0 <= level) && (level <= m_level))
             moves[level] = move->move();
@@ -415,8 +420,8 @@ void Sigencore::TeamMember::completeMoves()
     // TODO: give the moves to the creature
 }
 
-void Sigencore::TeamMember::makeConnections()
+void TeamMember::makeConnections()
 {
-    connect(this, SIGNAL(statStageChanged(Sigmod::Stat, int)), SLOT(recalcStat(Sigmod::Stat)));
+    connect(this, SIGNAL(statStageChanged(Stat, int)), SLOT(recalcStat(Stat)));
     Creature::makeConnections();
 }