[FIX] Renamed everything (in use) away from Poké- prefixes

git-svn-id: https://pokegen.svn.sourceforge.net/svnroot/pokegen/trunk@250 6ecfd1a5-f3ed-3746-8530-beee90d26b22

1 files changed, 57 insertions, 57 deletions

diff --git a/sigmod/Rules.cpp b/sigmod/Rules.cpp
index b4a1836a..22402a03 100644
--- a/sigmod/Rules.cpp
+++ b/sigmod/Rules.cpp
@@ -18,19 +18,19 @@
 // Header include
 #include "Rules.h"
 
-// Pokemod includes
+// Sigmod includes
 #include "Macros.h"
-#include "Pokemod.h"
+#include "Sigmod.h"
 
-const QStringList Pokemod::Rules::DVStr = QStringList() << "16" << "32";
+const QStringList Sigmod::Rules::DVStr = QStringList() << "16" << "32";
 
-Pokemod::Rules::Rules(const Rules& rules) :
+Sigmod::Rules::Rules(const Rules& rules) :
         Object(rules.parent(), 0)
 {
     *this = rules;
 }
 
-Pokemod::Rules::Rules(const Pokemod* parent) :
+Sigmod::Rules::Rules(const Sigmod* parent) :
         Object(parent, 0),
         m_genderAllowed(false),
         m_breedingAllowed(false),
@@ -58,19 +58,19 @@ Pokemod::Rules::Rules(const Pokemod* parent) :
 {
 }
 
-Pokemod::Rules::Rules(const Rules& rules, const Pokemod* parent) :
+Sigmod::Rules::Rules(const Rules& rules, const Sigmod* parent) :
         Object(parent, 0)
 {
     *this = rules;
 }
 
-Pokemod::Rules::Rules(const QDomElement& xml, const Pokemod* parent) :
+Sigmod::Rules::Rules(const QDomElement& xml, const Sigmod* parent) :
         Object(parent, 0)
 {
     load(xml);
 }
 
-void Pokemod::Rules::validate()
+void Sigmod::Rules::validate()
 {
     TEST_BEGIN();
     TEST(setBreedingAllowed, breedingAllowed);
@@ -90,7 +90,7 @@ void Pokemod::Rules::validate()
     TEST_END();
 }
 
-void Pokemod::Rules::load(const QDomElement& xml)
+void Sigmod::Rules::load(const QDomElement& xml)
 {
     LOAD_BEGIN();
     LOAD(genderAllowed);
@@ -118,7 +118,7 @@ void Pokemod::Rules::load(const QDomElement& xml)
     LOAD(maxEVPerStat);
 }
 
-QDomElement Pokemod::Rules::save() const
+QDomElement Sigmod::Rules::save() const
 {
     QDomElement xml = QDomDocument().createElement(className());
     SAVE(genderAllowed);
@@ -147,12 +147,12 @@ QDomElement Pokemod::Rules::save() const
     return xml;
 }
 
-void Pokemod::Rules::setGenderAllowed(const bool genderAllowed)
+void Sigmod::Rules::setGenderAllowed(const bool genderAllowed)
 {
     CHECK(genderAllowed);
 }
 
-void Pokemod::Rules::setBreedingAllowed(const bool breedingAllowed)
+void Sigmod::Rules::setBreedingAllowed(const bool breedingAllowed)
 {
     if (!m_genderAllowed && breedingAllowed)
         emit(error(bounds("breedingAllowed")));
@@ -160,22 +160,22 @@ void Pokemod::Rules::setBreedingAllowed(const bool breedingAllowed)
         CHECK(breedingAllowed);
 }
 
-void Pokemod::Rules::setCriticalDomains(const bool criticalDomains)
+void Sigmod::Rules::setCriticalDomains(const bool criticalDomains)
 {
     CHECK(criticalDomains);
 }
 
-void Pokemod::Rules::setUseTurns(const bool useTurns)
+void Sigmod::Rules::setUseTurns(const bool useTurns)
 {
     CHECK(useTurns);
 }
 
-void Pokemod::Rules::setNumBoxes(const int numBoxes)
+void Sigmod::Rules::setNumBoxes(const int numBoxes)
 {
     CHECK(numBoxes);
 }
 
-void Pokemod::Rules::setBoxSize(const int boxSize)
+void Sigmod::Rules::setBoxSize(const int boxSize)
 {
     if (m_numBoxes && !boxSize)
         emit(error(bounds("boxSize")));
@@ -183,7 +183,7 @@ void Pokemod::Rules::setBoxSize(const int boxSize)
         CHECK(boxSize);
 }
 
-void Pokemod::Rules::setMaxParty(const int maxParty)
+void Sigmod::Rules::setMaxParty(const int maxParty)
 {
     if (!maxParty)
         emit(error(bounds("maxParty")));
@@ -191,7 +191,7 @@ void Pokemod::Rules::setMaxParty(const int maxParty)
         CHECK(maxParty);
 }
 
-void Pokemod::Rules::setMaxFight(const int maxFight)
+void Sigmod::Rules::setMaxFight(const int maxFight)
 {
     if (m_maxParty < maxFight)
         emit(error(bounds("maxFight")));
@@ -199,7 +199,7 @@ void Pokemod::Rules::setMaxFight(const int maxFight)
         CHECK(maxFight);
 }
 
-void Pokemod::Rules::setMaxPlayers(const int maxPlayers)
+void Sigmod::Rules::setMaxPlayers(const int maxPlayers)
 {
     if (maxPlayers < 2)
         emit(error(bounds("maxPlayers")));
@@ -207,22 +207,22 @@ void Pokemod::Rules::setMaxPlayers(const int maxPlayers)
         CHECK(maxPlayers);
 }
 
-void Pokemod::Rules::setMaxHeldItems(const int maxHeldItems)
+void Sigmod::Rules::setMaxHeldItems(const int maxHeldItems)
 {
     CHECK(maxHeldItems);
 }
 
-void Pokemod::Rules::setMaxAbilities(const int maxAbilities)
+void Sigmod::Rules::setMaxAbilities(const int maxAbilities)
 {
     CHECK(maxAbilities);
 }
 
-void Pokemod::Rules::setMaxNatures(const int maxNatures)
+void Sigmod::Rules::setMaxNatures(const int maxNatures)
 {
     CHECK(maxNatures);
 }
 
-void Pokemod::Rules::setMaxMoves(const int maxMoves)
+void Sigmod::Rules::setMaxMoves(const int maxMoves)
 {
     if (!maxMoves)
         emit(error(bounds("maxMoves")));
@@ -230,7 +230,7 @@ void Pokemod::Rules::setMaxMoves(const int maxMoves)
         CHECK(maxMoves);
 }
 
-void Pokemod::Rules::setMaxLevel(const int maxLevel)
+void Sigmod::Rules::setMaxLevel(const int maxLevel)
 {
     if (!maxLevel)
         emit(error(bounds("maxLevel")));
@@ -238,32 +238,32 @@ void Pokemod::Rules::setMaxLevel(const int maxLevel)
         CHECK(maxLevel);
 }
 
-void Pokemod::Rules::setMaxStages(const int maxStages)
+void Sigmod::Rules::setMaxStages(const int maxStages)
 {
     CHECK(maxStages);
 }
 
-void Pokemod::Rules::setMaxMoney(const int maxMoney)
+void Sigmod::Rules::setMaxMoney(const int maxMoney)
 {
     CHECK(maxMoney);
 }
 
-void Pokemod::Rules::setHardCash(const bool hardCash)
+void Sigmod::Rules::setHardCash(const bool hardCash)
 {
     CHECK(hardCash);
 }
 
-void Pokemod::Rules::setAllowSwitchStyle(const bool allowSwitchStyle)
+void Sigmod::Rules::setAllowSwitchStyle(const bool allowSwitchStyle)
 {
     CHECK(allowSwitchStyle);
 }
 
-void Pokemod::Rules::setSpecialSplit(const bool specialSplit)
+void Sigmod::Rules::setSpecialSplit(const bool specialSplit)
 {
     CHECK(specialSplit);
 }
 
-void Pokemod::Rules::setSpecialDVSplit(const bool specialDVSplit)
+void Sigmod::Rules::setSpecialDVSplit(const bool specialDVSplit)
 {
     if (!specialDVSplit && m_specialSplit)
         emit(error(bounds("specialDVSplit")));
@@ -271,12 +271,12 @@ void Pokemod::Rules::setSpecialDVSplit(const bool specialDVSplit)
         CHECK(specialDVSplit);
 }
 
-void Pokemod::Rules::setEffortValuesAllowed(const bool effortValuesAllowed)
+void Sigmod::Rules::setEffortValuesAllowed(const bool effortValuesAllowed)
 {
     CHECK(effortValuesAllowed);
 }
 
-void Pokemod::Rules::setMaxTotalEV(const int maxTotalEV)
+void Sigmod::Rules::setMaxTotalEV(const int maxTotalEV)
 {
     if (!maxTotalEV)
         emit(error(bounds("maxTotalEV")));
@@ -284,7 +284,7 @@ void Pokemod::Rules::setMaxTotalEV(const int maxTotalEV)
         CHECK(maxTotalEV);
 }
 
-void Pokemod::Rules::setMaxEVPerStat(const int maxEVPerStat)
+void Sigmod::Rules::setMaxEVPerStat(const int maxEVPerStat)
 {
     if ((!maxEVPerStat && m_maxTotalEV) || (m_maxTotalEV < maxEVPerStat))
         emit(error(bounds("maxEVPerStat")));
@@ -292,122 +292,122 @@ void Pokemod::Rules::setMaxEVPerStat(const int maxEVPerStat)
         CHECK(maxEVPerStat);
 }
 
-bool Pokemod::Rules::genderAllowed() const
+bool Sigmod::Rules::genderAllowed() const
 {
     return m_genderAllowed;
 }
 
-bool Pokemod::Rules::breedingAllowed() const
+bool Sigmod::Rules::breedingAllowed() const
 {
     return m_breedingAllowed;
 }
 
-bool Pokemod::Rules::criticalDomains() const
+bool Sigmod::Rules::criticalDomains() const
 {
     return m_criticalDomains;
 }
 
-bool Pokemod::Rules::useTurns() const
+bool Sigmod::Rules::useTurns() const
 {
     return m_useTurns;
 }
 
-int Pokemod::Rules::numBoxes() const
+int Sigmod::Rules::numBoxes() const
 {
     return m_numBoxes;
 }
 
-int Pokemod::Rules::boxSize() const
+int Sigmod::Rules::boxSize() const
 {
     return m_boxSize;
 }
 
-int Pokemod::Rules::maxParty() const
+int Sigmod::Rules::maxParty() const
 {
     return m_maxParty;
 }
 
-int Pokemod::Rules::maxFight() const
+int Sigmod::Rules::maxFight() const
 {
     return m_maxFight;
 }
 
-int Pokemod::Rules::maxPlayers() const
+int Sigmod::Rules::maxPlayers() const
 {
     return m_maxPlayers;
 }
 
-int Pokemod::Rules::maxHeldItems() const
+int Sigmod::Rules::maxHeldItems() const
 {
     return m_maxHeldItems;
 }
 
-int Pokemod::Rules::maxAbilities() const
+int Sigmod::Rules::maxAbilities() const
 {
     return m_maxAbilities;
 }
 
-int Pokemod::Rules::maxNatures() const
+int Sigmod::Rules::maxNatures() const
 {
     return m_maxNatures;
 }
 
-int Pokemod::Rules::maxMoves() const
+int Sigmod::Rules::maxMoves() const
 {
     return m_maxMoves;
 }
 
-int Pokemod::Rules::maxLevel() const
+int Sigmod::Rules::maxLevel() const
 {
     return m_maxLevel;
 }
 
-int Pokemod::Rules::maxStages() const
+int Sigmod::Rules::maxStages() const
 {
     return m_maxStages;
 }
 
-int Pokemod::Rules::maxMoney() const
+int Sigmod::Rules::maxMoney() const
 {
     return m_maxMoney;
 }
 
-bool Pokemod::Rules::hardCash() const
+bool Sigmod::Rules::hardCash() const
 {
     return m_hardCash;
 }
 
-bool Pokemod::Rules::allowSwitchStyle() const
+bool Sigmod::Rules::allowSwitchStyle() const
 {
     return m_allowSwitchStyle;
 }
 
-bool Pokemod::Rules::specialSplit() const
+bool Sigmod::Rules::specialSplit() const
 {
     return m_specialSplit;
 }
 
-bool Pokemod::Rules::specialDVSplit() const
+bool Sigmod::Rules::specialDVSplit() const
 {
     return m_specialDVSplit;
 }
 
-bool Pokemod::Rules::effortValuesAllowed() const
+bool Sigmod::Rules::effortValuesAllowed() const
 {
     return m_effortValuesAllowed;
 }
 
-int Pokemod::Rules::maxTotalEV() const
+int Sigmod::Rules::maxTotalEV() const
 {
     return m_maxTotalEV;
 }
 
-int Pokemod::Rules::maxEVPerStat() const
+int Sigmod::Rules::maxEVPerStat() const
 {
     return m_maxEVPerStat;
 }
 
-Pokemod::Rules& Pokemod::Rules::operator=(const Rules& rhs)
+Sigmod::Rules& Sigmod::Rules::operator=(const Rules& rhs)
 {
     if (this == &rhs)
         return *this;