Migrated more classes to using the check structure

6 files changed, 103 insertions, 252 deletions

diff --git a/sigmod/MapEffect.cpp b/sigmod/MapEffect.cpp
index 4a16bc06..241a7ce3 100644
--- a/sigmod/MapEffect.cpp
+++ b/sigmod/MapEffect.cpp
@@ -83,62 +83,27 @@ QDomElement Sigmod::MapEffect::save() const
     return xml;
 }
 
-void Sigmod::MapEffect::setName(const QString& name)
-{
-    CHECK(name);
-}
-
-void Sigmod::MapEffect::setCoordinate(const QPoint& coordinate)
-{
+SETTER(MapEffect, QString&, Name, name)
+SETTER(MapEffect, QPoint&, Coordinate, coordinate)
+SETTER(MapEffect, int, Skin, skin)
+SETTER(MapEffect, bool, IsGhost, isGhost)
+SETTER(MapEffect, Sigcore::Script&, Script, script)
+
+GETTER(MapEffect, QString, name)
+GETTER(MapEffect, QPoint, coordinate)
+GETTER(MapEffect, int, skin)
+GETTER(MapEffect, bool, isGhost)
+GETTER(MapEffect, Sigcore::Script, script)
+
+CHECK(MapEffect, QString&, name)
+CHECK_BEGIN(MapEffect, QPoint&, coordinate)
     const Map* map = qobject_cast<const Map*>(parent());
-    if ((coordinate.x() < 0) || (coordinate.y() < 0) || (map->width() <= coordinate.x()) || (map->height() <= coordinate.y()))
-        emit(error(bounds("coordinate", QPoint(0, 0), QPoint(map->width(), map->height()), coordinate)));
-    else
-        CHECK(coordinate);
-}
-
-void Sigmod::MapEffect::setSkin(const int skin)
-{
-    if (!sigmod()->skinById(skin))
-        emit(error(bounds("skin", skin)));
-    else
-        CHECK(skin);
-}
-
-void Sigmod::MapEffect::setIsGhost(const bool isGhost)
-{
-    CHECK(isGhost);
-}
-
-void Sigmod::MapEffect::setScript(const Sigcore::Script& script)
-{
-    CHECK(script);
-}
-
-QString Sigmod::MapEffect::name() const
-{
-    return m_name;
-}
-
-QPoint Sigmod::MapEffect::coordinate() const
-{
-    return m_coordinate;
-}
-
-int Sigmod::MapEffect::skin() const
-{
-    return m_skin;
-}
-
-bool Sigmod::MapEffect::isGhost() const
-{
-    return m_isGhost;
-}
-
-Sigcore::Script Sigmod::MapEffect::script() const
-{
-    return m_script;
-}
+    TBOUNDS_MOD(coordinate_x, 0, map->width() - 1, coordinate.x())
+    TBOUNDS_MOD(coordinate_y, 0, map->height() - 1, coordinate.y())
+CHECK_END()
+CHECK_INDEX(MapEffect, int, skin, sigmod(), skin)
+CHECK(MapEffect, bool, isGhost)
+CHECK(MapEffect, Sigcore::Script&, script)
 
 Sigmod::MapEffect& Sigmod::MapEffect::operator=(const MapEffect& rhs)
 {
diff --git a/sigmod/MapEffect.h b/sigmod/MapEffect.h
index f8f064bc..4ae0f376 100644
--- a/sigmod/MapEffect.h
+++ b/sigmod/MapEffect.h
@@ -59,6 +59,12 @@ class SIGMOD_EXPORT MapEffect : public Object
         bool isGhost() const;
         Sigcore::Script script() const;
         
+        bool nameCheck(const QString& name) const;
+        bool coordinateCheck(const QPoint& coordinate) const;
+        bool skinCheck(const int skin) const;
+        bool isGhostCheck(const bool isGhost) const;
+        bool scriptCheck(const Sigcore::Script& script) const;
+        
         MapEffect& operator=(const MapEffect& rhs);
     private:
         QString m_name;
diff --git a/sigmod/MapTrainer.cpp b/sigmod/MapTrainer.cpp
index b4b5fa33..65439946 100644
--- a/sigmod/MapTrainer.cpp
+++ b/sigmod/MapTrainer.cpp
@@ -68,10 +68,10 @@ void Sigmod::MapTrainer::validate()
     TEST_BEGIN();
     if (m_name.isEmpty())
         emit(error("Name is empty"));
-    TEST(setTrainerClass, trainerClass);
-    TEST(setCoordinate, coordinate);
-    TEST(setNumberFight, numberFight);
-    TEST(setLeadTeamMember, leadTeamMember);
+    TEST(trainerClass);
+    TEST(coordinate);
+    TEST(numberFight);
+    TEST(leadTeamMember);
     if (!teamMemberCount())
         emit(error("There are no team members"));
     QSet<int> idChecker;
@@ -89,6 +89,7 @@ void Sigmod::MapTrainer::load(const QDomElement& xml)
     LOAD(coordinate);
     LOAD(numberFight);
     LOAD(script);
+    LOAD(leadTeamMember);
     LOAD_SUB(newTeamMember, MapTrainerTeamMember);
     LOAD(leadTeamMember);
 }
@@ -101,82 +102,40 @@ QDomElement Sigmod::MapTrainer::save() const
     SAVE(coordinate);
     SAVE(numberFight);
     SAVE(script);
+    SAVE(leadTeamMember);
     SAVE_SUB(MapTrainerTeamMember, teamMembers);
     return xml;
 }
 
-void Sigmod::MapTrainer::setName(const QString& name)
-{
-    CHECK(name);
-}
+SETTER(MapTrainer, QString&, Name, name)
+SETTER(MapTrainer, int, TrainerClass, trainerClass)
+SETTER(MapTrainer, QPoint&, Coordinate, coordinate)
+SETTER(MapTrainer, int, NumberFight, numberFight)
+SETTER(MapTrainer, Sigcore::Script&, Script, script)
+SETTER(MapTrainer, int, LeadTeamMember, leadTeamMember)
 
-void Sigmod::MapTrainer::setTrainerClass(const int trainerClass)
-{
-    if (!sigmod()->trainerById(trainerClass))
-        emit(error(bounds("trainerClass", trainerClass)));
-    else
-        CHECK(trainerClass);
-}
+GETTER(MapTrainer, QString, name)
+GETTER(MapTrainer, int, trainerClass)
+GETTER(MapTrainer, QPoint, coordinate)
+GETTER(MapTrainer, int, numberFight)
+GETTER(MapTrainer, Sigcore::Script, script)
+GETTER(MapTrainer, int, leadTeamMember)
 
-void Sigmod::MapTrainer::setCoordinate(const QPoint& coordinate)
-{
+CHECK(MapTrainer, QString&, name)
+CHECK_INDEX(MapTrainer, int, trainerClass, sigmod(), trainer)
+CHECK_BEGIN(MapTrainer, QPoint&, coordinate)
     const Map* map = qobject_cast<const Map*>(parent());
-    if ((coordinate.x() < 0) || (coordinate.y() < 0) || (map->width() <= coordinate.x()) || (map->height() <= coordinate.y()))
-        emit(error(bounds("coordinate", QPoint(0, 0), QPoint(map->width(), map->height()), coordinate)));
-    else
-        CHECK(coordinate);
-}
-
-void Sigmod::MapTrainer::setNumberFight(const int numberFight)
-{
-    if ((numberFight <= 0) || (sigmod()->rules()->maxFight() < numberFight))
-        emit(error(bounds("numberFight", 1, sigmod()->rules()->maxFight(), numberFight)));
-    else
-        CHECK(numberFight);
-}
-
-void Sigmod::MapTrainer::setScript(const Sigcore::Script& script)
-{
-    CHECK(script);
-}
-
-void Sigmod::MapTrainer::setLeadTeamMember(const int leadTeamMember)
-{
+    TBOUNDS_MOD(coordinate_x, 0, map->width() - 1, coordinate.x())
+    TBOUNDS_MOD(coordinate_y, 0, map->height() - 1, coordinate.y())
+CHECK_END()
+CHECK_BOUNDS(MapTrainer, int, numberFight, 1, sigmod()->rules()->maxFight())
+CHECK_BEGIN(MapTrainer, int, leadTeamMember)
     if (!teamMemberById(leadTeamMember))
-        emit(error(bounds("leadTeamMember", leadTeamMember)));
-    else
-        CHECK(leadTeamMember);
-}
-
-QString Sigmod::MapTrainer::name() const
-{
-    return m_name;
-}
-
-int Sigmod::MapTrainer::trainerClass() const
-{
-    return m_trainerClass;
-}
-
-QPoint Sigmod::MapTrainer::coordinate() const
-{
-    return m_coordinate;
-}
-
-int Sigmod::MapTrainer::numberFight() const
-{
-    return m_numberFight;
-}
-
-Sigcore::Script Sigmod::MapTrainer::script() const
-{
-    return m_script;
-}
-
-int Sigmod::MapTrainer::leadTeamMember() const
-{
-    return m_leadTeamMember;
-}
+    {
+        EBOUNDS_IDX(leadTeamMember);
+        return false;
+    }
+CHECK_END()
 
 const Sigmod::MapTrainerTeamMember* Sigmod::MapTrainer::teamMember(const int index) const
 {
diff --git a/sigmod/MapTrainer.h b/sigmod/MapTrainer.h
index f01afdbe..27ba9c88 100644
--- a/sigmod/MapTrainer.h
+++ b/sigmod/MapTrainer.h
@@ -64,6 +64,13 @@ class SIGMOD_EXPORT MapTrainer : public Object
         Sigcore::Script script() const;
         int leadTeamMember() const;
         
+        bool nameCheck(const QString& name) const;
+        bool trainerClassCheck(const int trainerClass) const;
+        bool coordinateCheck(const QPoint& coordinate) const;
+        bool numberFightCheck(const int numberFight) const;
+        bool scriptCheck(const Sigcore::Script& script) const;
+        bool leadTeamMemberCheck(const int leadTeamMember) const;
+        
         const MapTrainerTeamMember* teamMember(const int index) const;
         MapTrainerTeamMember* teamMember(const int index);
         const MapTrainerTeamMember* teamMemberById(const int id) const;
diff --git a/sigmod/MapTrainerTeamMember.cpp b/sigmod/MapTrainerTeamMember.cpp
index dfeb84f8..d34ca2f5 100644
--- a/sigmod/MapTrainerTeamMember.cpp
+++ b/sigmod/MapTrainerTeamMember.cpp
@@ -59,20 +59,20 @@ Sigmod::MapTrainerTeamMember::MapTrainerTeamMember(const QDomElement& xml, const
 void Sigmod::MapTrainerTeamMember::validate()
 {
     TEST_BEGIN();
-    TEST(setSpecies, species);
-    TEST(setLevel, level);
+    TEST(species);
+    TEST(level);
     if (sigmod()->rules()->maxAbilities() < m_ability.size())
         emit(error("Too many abilities"));
-    TEST_LIST(setAbility, ability);
+    TEST_LIST(ability);
     if (sigmod()->rules()->maxHeldItems() < m_item.size())
         emit(error("Too many held items"));
-    TEST_LIST(setItem, item);
+    TEST_LIST(item);
     if (sigmod()->rules()->maxMoves() < m_move.size())
         emit(error("Too many moves"));
-    TEST_LIST(setMove, move);
+    TEST_LIST(move);
     if (sigmod()->rules()->maxNatures() < m_nature.size())
         emit(error("Too many natures"));
-    TEST_LIST(setNature, nature);
+    TEST_LIST(nature);
     TEST_END();
 }
 
@@ -99,48 +99,13 @@ QDomElement Sigmod::MapTrainerTeamMember::save() const
     return xml;
 }
 
-void Sigmod::MapTrainerTeamMember::setSpecies(const int species)
-{
-    if (!sigmod()->speciesById(species))
-        emit(error(bounds("species", species)));
-    else
-        CHECK(species);
-}
-
-void Sigmod::MapTrainerTeamMember::setLevel(const int level)
-{
-    if ((level <= 0) || (sigmod()->rules()->maxLevel() < level))
-        emit(error(bounds("level", 0, sigmod()->rules()->maxLevel(), level)));
-    else
-        CHECK(level);
-}
-
-void Sigmod::MapTrainerTeamMember::setAbility(const int ability, const bool state)
-{
-    if (!sigmod()->abilityById(ability))
-        emit(error(bounds("ability", ability)));
-    else if (state && !m_ability.contains(ability))
-    {
-        if (m_ability.size() < sigmod()->rules()->maxAbilities())
-        {
-            m_ability.append(ability);
-            emit(changed());
-        }
-        else
-            emit(error("Cannot have any more abilities"));
-    }
-    else if (m_ability.contains(ability))
-    {
-        m_ability.removeAll(ability);
-        emit(changed());
-    }
-}
+SETTER(MapTrainerTeamMember, int, Species, species)
+SETTER(MapTrainerTeamMember, int, Level, level)
+SETTER_LIST(MapTrainerTeamMember, Ability, ability, sigmod()->rules()->maxAbilities(), "Cannot have anymore abilities")
 
 void Sigmod::MapTrainerTeamMember::setItem(const int item, const bool state)
 {
-    if (!sigmod()->itemById(item))
-        emit(error(bounds("item", item)));
-    else if (state && !m_item.contains(item))
+    if (itemCheck(item) && state && !m_item.contains(item))
     {
         if (m_item.size() < sigmod()->rules()->maxHeldItems())
         {
@@ -150,10 +115,10 @@ void Sigmod::MapTrainerTeamMember::setItem(const int item, const bool state)
                 emit(changed());
             }
             else
-                emit(error("Cannot carry that much weight"));
+                ERROR("Cannot carry that much weight");
         }
         else
-            emit(error("Cannot hold any more items"));
+            ERROR("Cannot hold any more items");
     }
     else if (m_item.contains(item))
     {
@@ -164,9 +129,7 @@ void Sigmod::MapTrainerTeamMember::setItem(const int item, const bool state)
 
 void Sigmod::MapTrainerTeamMember::setMove(const int move, const bool state)
 {
-    if (!sigmod()->moveById(move))
-        emit(error(bounds("move", move)));
-    else if (state && !m_move.contains(move))
+    if (moveCheck(move) && state && !m_move.contains(move))
     {
         const Species* species = sigmod()->speciesById(move);
         for (int i = 0; i < species->moveCount(); ++i)
@@ -178,13 +141,12 @@ void Sigmod::MapTrainerTeamMember::setMove(const int move, const bool state)
                 {
                     m_move.append(move);
                     emit(changed());
-                    return;
                 }
                 else
-                    emit(error("Cannot know any more moves"));
+                    ERROR("Cannot know any more moves");
             }
         }
-        emit(error("Cannot learn the move"));
+        ERROR("Cannot learn the move");
     }
     else if (m_move.contains(move))
     {
@@ -193,76 +155,21 @@ void Sigmod::MapTrainerTeamMember::setMove(const int move, const bool state)
     }
 }
 
-void Sigmod::MapTrainerTeamMember::setNature(const int nature, const bool state)
-{
-    if (!sigmod()->natureById(nature))
-        emit(error(bounds("nature", nature)));
-    else if (state && !m_nature.contains(nature))
-    {
-        if (m_nature.size() < sigmod()->rules()->maxNatures())
-        {
-            m_nature.append(nature);
-            emit(changed());
-        }
-        else
-            emit(error("Cannot have any more natures"));
-    }
-    else if (m_nature.contains(nature))
-    {
-        m_nature.removeAll(nature);
-        emit(changed());
-    }
-}
-
-int Sigmod::MapTrainerTeamMember::species() const
-{
-    return m_species;
-}
-
-int Sigmod::MapTrainerTeamMember::level() const
-{
-    return m_level;
-}
-
-bool Sigmod::MapTrainerTeamMember::ability(const int ability) const
-{
-    return m_ability.contains(ability);
-}
+SETTER_LIST(MapTrainerTeamMember, Nature, nature, sigmod()->rules()->maxNatures(), "Cannot have anymore natures")
 
-QList<int> Sigmod::MapTrainerTeamMember::abilities() const
-{
-    return m_ability;
-}
+GETTER(MapTrainerTeamMember, int, species)
+GETTER(MapTrainerTeamMember, int, level)
+GETTER_LIST(MapTrainerTeamMember, ability)
+GETTER_LIST(MapTrainerTeamMember, item)
+GETTER_LIST(MapTrainerTeamMember, move)
+GETTER_LIST(MapTrainerTeamMember, nature)
 
-bool Sigmod::MapTrainerTeamMember::item(const int item) const
-{
-    return m_item.contains(item);
-}
-
-QList<int> Sigmod::MapTrainerTeamMember::items() const
-{
-    return m_item;
-}
-
-bool Sigmod::MapTrainerTeamMember::move(const int move) const
-{
-    return m_move.contains(move);
-}
-
-QList<int> Sigmod::MapTrainerTeamMember::moves() const
-{
-    return m_move;
-}
-
-bool Sigmod::MapTrainerTeamMember::nature(const int nature) const
-{
-    return m_nature.contains(nature);
-}
-
-QList<int> Sigmod::MapTrainerTeamMember::natures() const
-{
-    return m_nature;
-}
+CHECK_INDEX(MapTrainerTeamMember, int, species, sigmod(), species)
+CHECK_BOUNDS(MapTrainerTeamMember, int, level, 1, sigmod()->rules()->maxLevel())
+CHECK_INDEX(MapTrainerTeamMember, int, ability, sigmod(), ability)
+CHECK_INDEX(MapTrainerTeamMember, int, item, sigmod(), item)
+CHECK_INDEX(MapTrainerTeamMember, int, move, sigmod(), move)
+CHECK_INDEX(MapTrainerTeamMember, int, nature, sigmod(), nature)
 
 Sigmod::MapTrainerTeamMember& Sigmod::MapTrainerTeamMember::operator=(const MapTrainerTeamMember& rhs)
 {
diff --git a/sigmod/MapTrainerTeamMember.h b/sigmod/MapTrainerTeamMember.h
index 2b5de59c..9aa7acc8 100644
--- a/sigmod/MapTrainerTeamMember.h
+++ b/sigmod/MapTrainerTeamMember.h
@@ -54,13 +54,20 @@ class SIGMOD_EXPORT MapTrainerTeamMember : public Object
         int species() const;
         int level() const;
         bool ability(const int ability) const;
-        QList<int> abilities() const;
+        QList<int> ability() const;
         bool item(const int item) const;
-        QList<int> items() const;
+        QList<int> item() const;
         bool move(const int move) const;
-        QList<int> moves() const;
+        QList<int> move() const;
         bool nature(const int nature) const;
-        QList<int> natures() const;
+        QList<int> nature() const;
+        
+        bool speciesCheck(const int species) const;
+        bool levelCheck(const int level) const;
+        bool abilityCheck(const int ability) const;
+        bool itemCheck(const int item) const;
+        bool moveCheck(const int move) const;
+        bool natureCheck(const int nature) const;
 
         MapTrainerTeamMember& operator=(const MapTrainerTeamMember& p);
     protected: