[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, 85 insertions, 85 deletions

diff --git a/sigmod/Map.cpp b/sigmod/Map.cpp
index 6cb92154..07509021 100644
--- a/sigmod/Map.cpp
+++ b/sigmod/Map.cpp
@@ -18,26 +18,26 @@
 // Header include
 #include "Map.h"
 
-// Pokemod includes
+// Sigmod includes
 #include "Macros.h"
 #include "MapEffect.h"
 #include "MapTrainer.h"
 #include "MapWarp.h"
 #include "MapWildList.h"
-#include "Pokemod.h"
+#include "Sigmod.h"
 
 // Qt includes
 #include <QtCore/QSet>
 
-const QStringList Pokemod::Map::TypeStr = QStringList() << "Outdoor" << "Dungeon" << "Building";
+const QStringList Sigmod::Map::TypeStr = QStringList() << "Outdoor" << "Dungeon" << "Building";
 
-Pokemod::Map::Map(const Map& map) :
+Sigmod::Map::Map(const Map& map) :
         Object(map.parent(), map.id())
 {
     *this = map;
 }
 
-Pokemod::Map::Map(const Pokemod* parent, const int id) :
+Sigmod::Map::Map(const Sigmod* parent, const int id) :
         Object(parent, id),
         m_name(""),
         m_flyWarp(-1),
@@ -45,25 +45,25 @@ Pokemod::Map::Map(const Pokemod* parent, const int id) :
 {
 }
 
-Pokemod::Map::Map(const Map& map, const Pokemod* parent, const int id) :
+Sigmod::Map::Map(const Map& map, const Sigmod* parent, const int id) :
         Object(parent, id)
 {
     *this = map;
 }
 
-Pokemod::Map::Map(const QDomElement& xml, const Pokemod* parent, const int id) :
+Sigmod::Map::Map(const QDomElement& xml, const Sigmod* parent, const int id) :
         Object(parent, id)
 {
     LOAD_ID();
     load(xml);
 }
 
-Pokemod::Map::~Map()
+Sigmod::Map::~Map()
 {
     clear();
 }
 
-void Pokemod::Map::validate()
+void Sigmod::Map::validate()
 {
     TEST_BEGIN();
     if (m_name.isEmpty())
@@ -104,7 +104,7 @@ void Pokemod::Map::validate()
     TEST_END();
 }
 
-void Pokemod::Map::load(const QDomElement& xml)
+void Sigmod::Map::load(const QDomElement& xml)
 {
     LOAD_BEGIN();
     LOAD(name);
@@ -117,7 +117,7 @@ void Pokemod::Map::load(const QDomElement& xml)
     LOAD_SUB(newWildList, MapWildList);
 }
 
-QDomElement Pokemod::Map::save() const
+QDomElement Sigmod::Map::save() const
 {
     SAVE_CREATE();
     SAVE(name);
@@ -131,12 +131,12 @@ QDomElement Pokemod::Map::save() const
     return xml;
 }
 
-void Pokemod::Map::setName(const QString& name)
+void Sigmod::Map::setName(const QString& name)
 {
     CHECK(name);
 }
 
-void Pokemod::Map::setFlyWarp(const int flyWarp)
+void Sigmod::Map::setFlyWarp(const int flyWarp)
 {
     if ((flyWarp != -1) && (warpIndex(flyWarp) == INT_MAX))
         emit(error(bounds("flyWarp")));
@@ -144,117 +144,117 @@ void Pokemod::Map::setFlyWarp(const int flyWarp)
         CHECK(flyWarp);
 }
 
-void Pokemod::Map::setType(const Type type)
+void Sigmod::Map::setType(const Type type)
 {
     CHECK(type);
 }
 
-QString Pokemod::Map::name() const
+QString Sigmod::Map::name() const
 {
     return m_name;
 }
 
-int Pokemod::Map::flyWarp() const
+int Sigmod::Map::flyWarp() const
 {
     return m_flyWarp;
 }
 
-Pokemod::Map::Type Pokemod::Map::type() const
+Sigmod::Map::Type Sigmod::Map::type() const
 {
     return m_type;
 }
 
-void Pokemod::Map::setTile(const int row, const int column, const int tile)
+void Sigmod::Map::setTile(const int row, const int column, const int tile)
 {
-    if (qobject_cast<const Pokemod*>(pokemod())->tileIndex(tile) == INT_MAX)
+    if (qobject_cast<const Sigmod*>(sigmod())->tileIndex(tile) == INT_MAX)
         emit(error(bounds("tile")));
     else
         m_map.set(row, column, tile);
 }
 
-void Pokemod::Map::insertColumn(const int column)
+void Sigmod::Map::insertColumn(const int column)
 {
     m_map.insertColumn(column, 0);
 }
 
-void Pokemod::Map::insertRow(const int row)
+void Sigmod::Map::insertRow(const int row)
 {
     m_map.insertRow(row, 0);
 }
 
-void Pokemod::Map::addColumn()
+void Sigmod::Map::addColumn()
 {
     m_map.addColumn(0);
 }
 
-void Pokemod::Map::addRow()
+void Sigmod::Map::addRow()
 {
     m_map.addRow(0);
 }
 
-void Pokemod::Map::deleteColumn(const int column)
+void Sigmod::Map::deleteColumn(const int column)
 {
     m_map.deleteColumn(column);
 }
 
-void Pokemod::Map::deleteRow(const int row)
+void Sigmod::Map::deleteRow(const int row)
 {
     m_map.deleteRow(row);
 }
 
-const Pokemod::Matrix<int>* Pokemod::Map::map() const
+const Sigmod::Matrix<int>* Sigmod::Map::map() const
 {
     return &m_map;
 }
 
-Pokemod::Matrix<int>* Pokemod::Map::map()
+Sigmod::Matrix<int>* Sigmod::Map::map()
 {
     return &m_map;
 }
 
-int Pokemod::Map::tile(const int row, const int column) const
+int Sigmod::Map::tile(const int row, const int column) const
 {
     return m_map.at(row, column);
 }
 
-int Pokemod::Map::width() const
+int Sigmod::Map::width() const
 {
     return m_map.width();
 }
 
-int Pokemod::Map::height() const
+int Sigmod::Map::height() const
 {
     return m_map.height();
 }
 
-QPoint Pokemod::Map::size() const
+QPoint Sigmod::Map::size() const
 {
     return m_map.size();
 }
 
-const Pokemod::MapEffect* Pokemod::Map::effect(const int index) const
+const Sigmod::MapEffect* Sigmod::Map::effect(const int index) const
 {
     Q_ASSERT(index < effectCount());
     return m_effects.at(index);
 }
 
-Pokemod::MapEffect* Pokemod::Map::effect(const int index)
+Sigmod::MapEffect* Sigmod::Map::effect(const int index)
 {
     Q_ASSERT(index < effectCount());
     return m_effects[index];
 }
 
-const Pokemod::MapEffect* Pokemod::Map::effectById(const int index) const
+const Sigmod::MapEffect* Sigmod::Map::effectById(const int index) const
 {
     return effect(effectIndex(index));
 }
 
-Pokemod::MapEffect* Pokemod::Map::effectById(const int index)
+Sigmod::MapEffect* Sigmod::Map::effectById(const int index)
 {
     return effect(effectIndex(index));
 }
 
-int Pokemod::Map::effectIndex(const int id) const
+int Sigmod::Map::effectIndex(const int id) const
 {
     for (int i = 0; i < effectCount(); ++i)
     {
@@ -264,45 +264,45 @@ int Pokemod::Map::effectIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::Map::effectCount() const
+int Sigmod::Map::effectCount() const
 {
     return m_effects.size();
 }
 
-Pokemod::MapEffect* Pokemod::Map::newEffect()
+Sigmod::MapEffect* Sigmod::Map::newEffect()
 {
     return newEffect(new MapEffect(this, newEffectId()));
 }
 
-Pokemod::MapEffect* Pokemod::Map::newEffect(const QDomElement& xml)
+Sigmod::MapEffect* Sigmod::Map::newEffect(const QDomElement& xml)
 {
     return newEffect(new MapEffect(xml, this, newEffectId()));
 }
 
-Pokemod::MapEffect* Pokemod::Map::newEffect(const MapEffect& effect)
+Sigmod::MapEffect* Sigmod::Map::newEffect(const MapEffect& effect)
 {
     return newEffect(new MapEffect(effect, this, newEffectId()));
 }
 
-Pokemod::MapEffect* Pokemod::Map::newEffect(MapEffect* effect)
+Sigmod::MapEffect* Sigmod::Map::newEffect(MapEffect* effect)
 {
     m_effects.append(effect);
     return effect;
 }
 
-void Pokemod::Map::deleteEffect(const int index)
+void Sigmod::Map::deleteEffect(const int index)
 {
     Q_ASSERT(index < effectCount());
     delete m_effects[index];
     m_effects.removeAt(index);
 }
 
-void Pokemod::Map::deleteEffectById(const int id)
+void Sigmod::Map::deleteEffectById(const int id)
 {
     deleteEffect(effectIndex(id));
 }
 
-int Pokemod::Map::newEffectId() const
+int Sigmod::Map::newEffectId() const
 {
     int i = 0;
     while ((i < effectCount()) && (effectIndex(i) != INT_MAX))
@@ -310,29 +310,29 @@ int Pokemod::Map::newEffectId() const
     return i;
 }
 
-const Pokemod::MapTrainer* Pokemod::Map::trainer(const int index) const
+const Sigmod::MapTrainer* Sigmod::Map::trainer(const int index) const
 {
     Q_ASSERT(index < trainerCount());
     return m_trainers.at(index);
 }
 
-Pokemod::MapTrainer* Pokemod::Map::trainer(const int index)
+Sigmod::MapTrainer* Sigmod::Map::trainer(const int index)
 {
     Q_ASSERT(index < trainerCount());
     return m_trainers[index];
 }
 
-const Pokemod::MapTrainer* Pokemod::Map::trainerById(const int id) const
+const Sigmod::MapTrainer* Sigmod::Map::trainerById(const int id) const
 {
     return trainer(trainerIndex(id));
 }
 
-Pokemod::MapTrainer* Pokemod::Map::trainerById(const int id)
+Sigmod::MapTrainer* Sigmod::Map::trainerById(const int id)
 {
     return trainer(trainerIndex(id));
 }
 
-int Pokemod::Map::trainerIndex(const int id) const
+int Sigmod::Map::trainerIndex(const int id) const
 {
     for (int i = 0; i < trainerCount(); ++i)
     {
@@ -342,45 +342,45 @@ int Pokemod::Map::trainerIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::Map::trainerCount() const
+int Sigmod::Map::trainerCount() const
 {
     return m_trainers.size();
 }
 
-Pokemod::MapTrainer* Pokemod::Map::newTrainer()
+Sigmod::MapTrainer* Sigmod::Map::newTrainer()
 {
     return newTrainer(new MapTrainer(this, newTrainerId()));
 }
 
-Pokemod::MapTrainer* Pokemod::Map::newTrainer(const QDomElement& xml)
+Sigmod::MapTrainer* Sigmod::Map::newTrainer(const QDomElement& xml)
 {
     return newTrainer(new MapTrainer(xml, this, newTrainerId()));
 }
 
-Pokemod::MapTrainer* Pokemod::Map::newTrainer(const MapTrainer& trainer)
+Sigmod::MapTrainer* Sigmod::Map::newTrainer(const MapTrainer& trainer)
 {
     return newTrainer(new MapTrainer(trainer, this, newTrainerId()));
 }
 
-Pokemod::MapTrainer* Pokemod::Map::newTrainer(MapTrainer* trainer)
+Sigmod::MapTrainer* Sigmod::Map::newTrainer(MapTrainer* trainer)
 {
     m_trainers.append(trainer);
     return trainer;
 }
 
-void Pokemod::Map::deleteTrainer(const int index)
+void Sigmod::Map::deleteTrainer(const int index)
 {
     Q_ASSERT(index < trainerCount());
     delete m_trainers[index];
     m_trainers.removeAt(index);
 }
 
-void Pokemod::Map::deleteTrainerById(const int id)
+void Sigmod::Map::deleteTrainerById(const int id)
 {
     deleteTrainer(trainerIndex(id));
 }
 
-int Pokemod::Map::newTrainerId() const
+int Sigmod::Map::newTrainerId() const
 {
     int i = 0;
     while ((i < trainerCount()) && (trainerIndex(i) != INT_MAX))
@@ -388,29 +388,29 @@ int Pokemod::Map::newTrainerId() const
     return i;
 }
 
-const Pokemod::MapWarp* Pokemod::Map::warp(const int index) const
+const Sigmod::MapWarp* Sigmod::Map::warp(const int index) const
 {
     Q_ASSERT(index < warpCount());
     return m_warps.at(index);
 }
 
-Pokemod::MapWarp* Pokemod::Map::warp(const int index)
+Sigmod::MapWarp* Sigmod::Map::warp(const int index)
 {
     Q_ASSERT(index < warpCount());
     return m_warps[index];
 }
 
-const Pokemod::MapWarp* Pokemod::Map::warpById(const int id) const
+const Sigmod::MapWarp* Sigmod::Map::warpById(const int id) const
 {
     return warp(warpIndex(id));
 }
 
-Pokemod::MapWarp* Pokemod::Map::warpById(const int id)
+Sigmod::MapWarp* Sigmod::Map::warpById(const int id)
 {
     return warp(warpIndex(id));
 }
 
-int Pokemod::Map::warpIndex(const int id) const
+int Sigmod::Map::warpIndex(const int id) const
 {
     for (int i = 0; i < warpCount(); ++i)
     {
@@ -420,45 +420,45 @@ int Pokemod::Map::warpIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::Map::warpCount() const
+int Sigmod::Map::warpCount() const
 {
     return m_warps.size();
 }
 
-Pokemod::MapWarp* Pokemod::Map::newWarp()
+Sigmod::MapWarp* Sigmod::Map::newWarp()
 {
     return newWarp(new MapWarp(this, newWarpId()));
 }
 
-Pokemod::MapWarp* Pokemod::Map::newWarp(const QDomElement& xml)
+Sigmod::MapWarp* Sigmod::Map::newWarp(const QDomElement& xml)
 {
     return newWarp(new MapWarp(xml, this, newWarpId()));
 }
 
-Pokemod::MapWarp* Pokemod::Map::newWarp(const MapWarp& warp)
+Sigmod::MapWarp* Sigmod::Map::newWarp(const MapWarp& warp)
 {
     return newWarp(new MapWarp(warp, this, newWarpId()));
 }
 
-Pokemod::MapWarp* Pokemod::Map::newWarp(MapWarp* warp)
+Sigmod::MapWarp* Sigmod::Map::newWarp(MapWarp* warp)
 {
     m_warps.append(warp);
     return warp;
 }
 
-void Pokemod::Map::deleteWarp(const int index)
+void Sigmod::Map::deleteWarp(const int index)
 {
     Q_ASSERT(index < warpCount());
     delete m_warps[index];
     m_warps.removeAt(index);
 }
 
-void Pokemod::Map::deleteWarpById(const int id)
+void Sigmod::Map::deleteWarpById(const int id)
 {
     deleteWarp(warpIndex(id));
 }
 
-int Pokemod::Map::newWarpId() const
+int Sigmod::Map::newWarpId() const
 {
     int i = 0;
     while ((i < warpCount()) && (warpIndex(i) != INT_MAX))
@@ -466,29 +466,29 @@ int Pokemod::Map::newWarpId() const
     return i;
 }
 
-const Pokemod::MapWildList* Pokemod::Map::wildList(const int index) const
+const Sigmod::MapWildList* Sigmod::Map::wildList(const int index) const
 {
     Q_ASSERT(index < wildListCount());
     return m_wildLists.at(index);
 }
 
-Pokemod::MapWildList* Pokemod::Map::wildList(const int index)
+Sigmod::MapWildList* Sigmod::Map::wildList(const int index)
 {
     Q_ASSERT(index < wildListCount());
     return m_wildLists[index];
 }
 
-const Pokemod::MapWildList* Pokemod::Map::wildListById(const int id) const
+const Sigmod::MapWildList* Sigmod::Map::wildListById(const int id) const
 {
     return wildList(wildListIndex(id));
 }
 
-Pokemod::MapWildList* Pokemod::Map::wildListById(const int id)
+Sigmod::MapWildList* Sigmod::Map::wildListById(const int id)
 {
     return wildList(wildListIndex(id));
 }
 
-int Pokemod::Map::wildListIndex(const int id) const
+int Sigmod::Map::wildListIndex(const int id) const
 {
     for (int i = 0; i < wildListCount(); ++i)
     {
@@ -498,45 +498,45 @@ int Pokemod::Map::wildListIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::Map::wildListCount() const
+int Sigmod::Map::wildListCount() const
 {
     return m_wildLists.size();
 }
 
-Pokemod::MapWildList* Pokemod::Map::newWildList()
+Sigmod::MapWildList* Sigmod::Map::newWildList()
 {
     return newWildList(new MapWildList(this, newWildListId()));
 }
 
-Pokemod::MapWildList* Pokemod::Map::newWildList(const QDomElement& xml)
+Sigmod::MapWildList* Sigmod::Map::newWildList(const QDomElement& xml)
 {
     return newWildList(new MapWildList(xml, this, newWildListId()));
 }
 
-Pokemod::MapWildList* Pokemod::Map::newWildList(const MapWildList& wildList)
+Sigmod::MapWildList* Sigmod::Map::newWildList(const MapWildList& wildList)
 {
     return newWildList(new MapWildList(wildList, this, newWildListId()));
 }
 
-Pokemod::MapWildList* Pokemod::Map::newWildList(MapWildList* wildList)
+Sigmod::MapWildList* Sigmod::Map::newWildList(MapWildList* wildList)
 {
     m_wildLists.append(wildList);
     return wildList;
 }
 
-void Pokemod::Map::deleteWildList(const int index)
+void Sigmod::Map::deleteWildList(const int index)
 {
     Q_ASSERT(index < wildListCount());
     delete m_wildLists[index];
     m_wildLists.removeAt(index);
 }
 
-void Pokemod::Map::deleteWildListById(const int id)
+void Sigmod::Map::deleteWildListById(const int id)
 {
     deleteWildList(wildListIndex(id));
 }
 
-int Pokemod::Map::newWildListId() const
+int Sigmod::Map::newWildListId() const
 {
     int i = 0;
     while ((i < warpCount()) && (warpIndex(i) != INT_MAX))
@@ -544,7 +544,7 @@ int Pokemod::Map::newWildListId() const
     return i;
 }
 
-Pokemod::Map& Pokemod::Map::operator=(const Map& rhs)
+Sigmod::Map& Sigmod::Map::operator=(const Map& rhs)
 {
     if (this == &rhs)
         return *this;
@@ -560,7 +560,7 @@ Pokemod::Map& Pokemod::Map::operator=(const Map& rhs)
     return *this;
 }
 
-void Pokemod::Map::clear()
+void Sigmod::Map::clear()
 {
     while (effectCount())
         deleteEffect(0);