From fd874f8a1e413b769245aa61a866bd536a551c3c Mon Sep 17 00:00:00 2001
From: Ben Boeckel <MathStuf@gmail.com>
Date: Tue, 24 Feb 2009 16:33:13 -0500
Subject: Fixed up sigscript namespacing in sources

---
 sigscript/RulesWrapper.cpp | 53 ++++++++++++++++++++++++----------------------
 1 file changed, 28 insertions(+), 25 deletions(-)

(limited to 'sigscript/RulesWrapper.cpp')

diff --git a/sigscript/RulesWrapper.cpp b/sigscript/RulesWrapper.cpp
index 26f95bb2..2278e6ec 100644
--- a/sigscript/RulesWrapper.cpp
+++ b/sigscript/RulesWrapper.cpp
@@ -24,7 +24,10 @@
 // Sigmod includes
 #include <sigmod/Rules.h>
 
-Sigscript::RulesWrapper* Sigscript::RulesWrapper::create(const Sigmod::Rules* rules, GameWrapper* parent)
+using namespace Sigmod;
+using namespace Sigscript;
+
+RulesWrapper* RulesWrapper::create(const Rules* rules, GameWrapper* parent)
 {
     Signature sig = Signature(parent, Subsignature(rules->className(), rules->id()));
     if (!m_instances.contains(sig))
@@ -32,136 +35,136 @@ Sigscript::RulesWrapper* Sigscript::RulesWrapper::create(const Sigmod::Rules* ru
     return qobject_cast<RulesWrapper*>(m_instances[sig]);
 }
 
-Sigscript::RulesWrapper::RulesWrapper(const Sigmod::Rules* rules, GameWrapper* parent) :
+RulesWrapper::RulesWrapper(const Rules* rules, GameWrapper* parent) :
         ObjectWrapper(rules, parent),
         m_rules(rules)
 {
 }
 
-bool Sigscript::RulesWrapper::genderAllowed() const
+bool RulesWrapper::genderAllowed() const
 {
     return m_rules->genderAllowed();
 }
 
-bool Sigscript::RulesWrapper::breedingAllowed() const
+bool RulesWrapper::breedingAllowed() const
 {
     return m_rules->breedingAllowed();
 }
 
-bool Sigscript::RulesWrapper::criticalDomains() const
+bool RulesWrapper::criticalDomains() const
 {
     return m_rules->criticalDomains();
 }
 
-bool Sigscript::RulesWrapper::useATB() const
+bool RulesWrapper::useATB() const
 {
     return m_rules->useATB();
 }
 
-int Sigscript::RulesWrapper::numBoxes() const
+int RulesWrapper::numBoxes() const
 {
     ALLOW_OVERRIDE_SO(rules, int, numBoxes);
     return m_rules->numBoxes();
 }
 
-int Sigscript::RulesWrapper::boxSize() const
+int RulesWrapper::boxSize() const
 {
     ALLOW_OVERRIDE_SO(rules, int, boxSize);
     return m_rules->boxSize();
 }
 
-int Sigscript::RulesWrapper::maxParty() const
+int RulesWrapper::maxParty() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxParty);
     return m_rules->maxParty();
 }
 
-int Sigscript::RulesWrapper::maxFight() const
+int RulesWrapper::maxFight() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxFight);
     return m_rules->maxFight();
 }
 
-int Sigscript::RulesWrapper::maxPlayers() const
+int RulesWrapper::maxPlayers() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxFight);
     return m_rules->maxPlayers();
 }
 
-int Sigscript::RulesWrapper::maxHeldItems() const
+int RulesWrapper::maxHeldItems() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxHeldItems);
     return m_rules->maxHeldItems();
 }
 
-int Sigscript::RulesWrapper::maxAbilities() const
+int RulesWrapper::maxAbilities() const
 {
     return m_rules->maxAbilities();
 }
 
-int Sigscript::RulesWrapper::maxNatures() const
+int RulesWrapper::maxNatures() const
 {
     return m_rules->maxNatures();
 }
 
-int Sigscript::RulesWrapper::maxMoves() const
+int RulesWrapper::maxMoves() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxMoves);
     return m_rules->maxMoves();
 }
 
-int Sigscript::RulesWrapper::maxLevel() const
+int RulesWrapper::maxLevel() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxLevel);
     return m_rules->maxLevel();
 }
 
-int Sigscript::RulesWrapper::maxStages() const
+int RulesWrapper::maxStages() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxStages);
     return m_rules->maxStages();
 }
 
-int Sigscript::RulesWrapper::maxMoney() const
+int RulesWrapper::maxMoney() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxMoney);
     return m_rules->maxMoney();
 }
 
-int Sigscript::RulesWrapper::maxTotalWeight() const
+int RulesWrapper::maxTotalWeight() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxTotalWeight);
     return m_rules->maxTotalWeight();
 }
 
-bool Sigscript::RulesWrapper::allowSwitchStyle() const
+bool RulesWrapper::allowSwitchStyle() const
 {
     ALLOW_OVERRIDE_SO(rules, bool, allowSwitchStyle);
     return m_rules->allowSwitchStyle();
 }
 
-bool Sigscript::RulesWrapper::specialSplit() const
+bool RulesWrapper::specialSplit() const
 {
     return m_rules->specialSplit();
 }
 
-bool Sigscript::RulesWrapper::specialDVSplit() const
+bool RulesWrapper::specialDVSplit() const
 {
     return m_rules->specialDVSplit();
 }
 
-bool Sigscript::RulesWrapper::effortValuesAllowed() const
+bool RulesWrapper::effortValuesAllowed() const
 {
     return m_rules->effortValuesAllowed();
 }
 
-int Sigscript::RulesWrapper::maxTotalEV() const
+int RulesWrapper::maxTotalEV() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxTotalEV);
     return m_rules->maxTotalEV();
 }
 
-int Sigscript::RulesWrapper::maxEVPerStat() const
+int RulesWrapper::maxEVPerStat() const
 {
     ALLOW_OVERRIDE_SO(rules, int, maxEVPerStat);
     return m_rules->maxEVPerStat();
-- 
cgit