[FIX] Added a static poll method to Fraction

[FIX] More Arena stuff fleshed out
[FIX] Added priority scripts to Ability and Move
[FIX] A SigmodWrapper pointer is now passed around the containments
[FIX] Config now has templated methods for retrieving values

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

16 files changed, 111 insertions, 70 deletions

diff --git a/sigscript/AbilityWrapper.cpp b/sigscript/AbilityWrapper.cpp
index e5b22529..35e8dd82 100644
--- a/sigscript/AbilityWrapper.cpp
+++ b/sigscript/AbilityWrapper.cpp
@@ -41,8 +41,8 @@ QString Sigscript::AbilityWrapper::name() const
 
 int Sigscript::AbilityWrapper::priority() const
 {
-    if (value("priority").canConvert<int>())
-        return value("priority").toInt();
+    if (hasValueOfType<int>("priority"))
+        return valueOfType<int>("priority");
     return m_ability->priority();
 }
 
@@ -60,3 +60,8 @@ Sigmod::Script Sigscript::AbilityWrapper::worldScript() const
 {
     return m_ability->worldScript();
 }
+
+Sigmod::Script Sigscript::AbilityWrapper::priorityScript() const
+{
+    return m_ability->priorityScript();
+}
diff --git a/sigscript/AbilityWrapper.h b/sigscript/AbilityWrapper.h
index bb677555..7b0faa0f 100644
--- a/sigscript/AbilityWrapper.h
+++ b/sigscript/AbilityWrapper.h
@@ -38,6 +38,7 @@ class SIGSCRIPT_EXPORT AbilityWrapper : public ObjectWrapper
         Q_SCRIPTABLE QString description() const;
         Q_SCRIPTABLE Sigmod::Script battleScript() const;
         Q_SCRIPTABLE Sigmod::Script worldScript() const;
+        Q_SCRIPTABLE Sigmod::Script priorityScript() const;
     private:
         AbilityWrapper(const Sigmod::Ability* ability, SigmodWrapper* parent);
         AbilityWrapper& operator=(const AbilityWrapper& rhs);
diff --git a/sigscript/CoinListObjectWrapper.cpp b/sigscript/CoinListObjectWrapper.cpp
index b0b0f0c6..b0b540a5 100644
--- a/sigscript/CoinListObjectWrapper.cpp
+++ b/sigscript/CoinListObjectWrapper.cpp
@@ -65,14 +65,14 @@ Sigscript::SpeciesWrapper* Sigscript::CoinListObjectWrapper::speciesObject()
 
 int Sigscript::CoinListObjectWrapper::amount() const
 {
-    if (value("amount").canConvert<int>())
-        return value("amount").toInt();
+    if (hasValueOfType<int>("amount"))
+        return valueOfType<int>("amount");
     return m_object->amount();
 }
 
 int Sigscript::CoinListObjectWrapper::cost() const
 {
-    if (value("cost").canConvert<int>())
-        return value("cost").toInt();
+    if (hasValueOfType<int>("cost"))
+        return valueOfType<int>("cost");
     return m_object->cost();
 }
diff --git a/sigscript/Config.h b/sigscript/Config.h
index 6cfe95b9..d35c487b 100644
--- a/sigscript/Config.h
+++ b/sigscript/Config.h
@@ -44,7 +44,9 @@ class SIGSCRIPT_EXPORT Config : public QObject
         Config(QObject* parent);
         
         Q_SCRIPTABLE QVariant value(const QString& name, const bool recursive = true) const;
+        template<typename T> T valueOfType(const QString& name, const bool recursive = false) const;
         Q_SCRIPTABLE bool hasValue(const QString& name, const bool recursive = false) const;
+        template<typename T> bool hasValueOfType(const QString& name, const bool recursive = false) const;
     signals:
         void valueAdded(const QString& name, const QVariant& value);
         void valueChanged(const QString& name, const QVariant& oldValue, const QVariant& newValue);
@@ -61,6 +63,33 @@ class SIGSCRIPT_EXPORT Config : public QObject
         QMap<QString, QVariant> m_values;
         QList<QString> m_temporaries;
 };
+
+template<typename T> T Config::valueOfType(const QString& name, const bool recursive) const
+{
+    if (hasValueOfType<T>(name))
+        return m_values[name].value<T>();
+    if (recursive)
+    {
+        QObject* par = parent();
+        while (par)
+        {
+            if (qobject_cast<Config*>(par) && qobject_cast<Config*>(par)->hasValue(name))
+                return qobject_cast<Config*>(par)->valueOfType<T>(name);
+            par = par->parent();
+        }
+    }
+    return T();
+}
+
+template<typename T> bool Config::hasValueOfType(const QString& name, const bool recursive) const
+{
+    if (m_values.contains(name) && m_values[name].canConvert<T>())
+        return true;
+    if (recursive && qobject_cast<Config*>(parent()))
+        return qobject_cast<Config*>(parent())->hasValueOfType<T>(name, true);
+    return false;
+}
+
 }
 Q_DECLARE_METATYPE(Sigscript::Config*)
 
diff --git a/sigscript/ItemWrapper.cpp b/sigscript/ItemWrapper.cpp
index 1fb400db..71e36149 100644
--- a/sigscript/ItemWrapper.cpp
+++ b/sigscript/ItemWrapper.cpp
@@ -51,8 +51,8 @@ Sigscript::ItemTypeWrapper* Sigscript::ItemWrapper::type()
 
 int Sigscript::ItemWrapper::price() const
 {
-    if (value("price").canConvert<int>())
-        return value("price").toInt();
+    if (hasValueOfType<int>("price"))
+        return valueOfType<int>("price");
     return m_item->price();
 }
 
diff --git a/sigscript/MapEffectWrapper.cpp b/sigscript/MapEffectWrapper.cpp
index 03ebb30f..52bd4de9 100644
--- a/sigscript/MapEffectWrapper.cpp
+++ b/sigscript/MapEffectWrapper.cpp
@@ -42,8 +42,8 @@ QString Sigscript::MapEffectWrapper::name() const
 
 QPoint Sigscript::MapEffectWrapper::coordinate() const
 {
-    if (value("coordinate").canConvert<QPoint>())
-        return value("coordinate").toPoint();
+    if (hasValueOfType<QPoint>("coordinate"))
+        return valueOfType<QPoint>("coordinate");
     return m_effect->coordinate();
 }
 
@@ -54,8 +54,8 @@ Sigscript::SkinWrapper* Sigscript::MapEffectWrapper::skin()
 
 bool Sigscript::MapEffectWrapper::isGhost() const
 {
-    if (value("ghost").canConvert<bool>())
-        return value("ghost").toBool();
+    if (hasValueOfType<bool>("ghost"))
+        return valueOfType<bool>("ghost");
     return m_effect->isGhost();
 }
 
diff --git a/sigscript/MapTrainerTeamMemberWrapper.cpp b/sigscript/MapTrainerTeamMemberWrapper.cpp
index 6d0ea036..e875008a 100644
--- a/sigscript/MapTrainerTeamMemberWrapper.cpp
+++ b/sigscript/MapTrainerTeamMemberWrapper.cpp
@@ -42,8 +42,8 @@ Sigscript::SpeciesWrapper* Sigscript::MapTrainerTeamMemberWrapper::species()
 
 int Sigscript::MapTrainerTeamMemberWrapper::level() const
 {
-    if (value("level").canConvert<int>())
-        return value("level").toInt();
+    if (hasValueOfType<int>("level"))
+        return valueOfType<int>("level");
     return m_teamMember->level();
 }
 
diff --git a/sigscript/MapWarpWrapper.cpp b/sigscript/MapWarpWrapper.cpp
index 32e1c14d..bacba9b0 100644
--- a/sigscript/MapWarpWrapper.cpp
+++ b/sigscript/MapWarpWrapper.cpp
@@ -55,8 +55,8 @@ QString Sigscript::MapWarpWrapper::name() const
 
 QPoint Sigscript::MapWarpWrapper::coordinate() const
 {
-    if (value("coordinate").canConvert<QPoint>())
-        return value("coordinate").toPoint();
+    if (hasValueOfType<QPoint>("coordinate"))
+        return valueOfType<QPoint>("coordinate");
     return m_warp->coordinate();
 }
 
diff --git a/sigscript/MapWildListEncounterWrapper.cpp b/sigscript/MapWildListEncounterWrapper.cpp
index 3945f8bc..1eea2ce8 100644
--- a/sigscript/MapWildListEncounterWrapper.cpp
+++ b/sigscript/MapWildListEncounterWrapper.cpp
@@ -42,14 +42,14 @@ Sigscript::SpeciesWrapper* Sigscript::MapWildListEncounterWrapper::species()
 
 int Sigscript::MapWildListEncounterWrapper::level() const
 {
-    if (value("level").canConvert<int>())
-        return value("level").toInt();
+    if (hasValueOfType<int>("level"))
+        return valueOfType<int>("level");
     return m_encounter->level();
 }
 
 int Sigscript::MapWildListEncounterWrapper::weight() const
 {
-    if (value("weight").canConvert<int>())
-        return value("weight").toInt();
+    if (hasValueOfType<int>("weight"))
+        return valueOfType<int>("weight");
     return m_encounter->weight();
 }
diff --git a/sigscript/MoveWrapper.cpp b/sigscript/MoveWrapper.cpp
index 98f13702..6c21cc38 100644
--- a/sigscript/MoveWrapper.cpp
+++ b/sigscript/MoveWrapper.cpp
@@ -41,15 +41,15 @@ QString Sigscript::MoveWrapper::name() const
 
 Sigmod::Fraction Sigscript::MoveWrapper::accuracy() const
 {
-    if (value("accuracy").canConvert<Sigmod::Fraction>())
-        return value("accuracy").value<Sigmod::Fraction>();
+    if (hasValueOfType<Sigmod::Fraction>("accuracy"))
+        return valueOfType<Sigmod::Fraction>("accuracy");
     return m_move->accuracy();
 }
 
 int Sigscript::MoveWrapper::power() const
 {
-    if (value("power").canConvert<int>())
-        return value("power").toInt();
+    if (hasValueOfType<int>("power"))
+        return valueOfType<int>("power");
     return m_move->power();
 }
 
@@ -70,8 +70,8 @@ int Sigscript::MoveWrapper::powerPoints() const
 
 int Sigscript::MoveWrapper::priority() const
 {
-    if (value("priority").canConvert<int>())
-        return value("priority").toInt();
+    if (hasValueOfType<int>("priority"))
+        return valueOfType<int>("priority");
     return m_move->priority();
 }
 
@@ -89,3 +89,8 @@ Sigmod::Script Sigscript::MoveWrapper::worldScript() const
 {
     return m_move->worldScript();
 }
+
+Sigmod::Script Sigscript::MoveWrapper::priorityScript() const
+{
+    return m_move->priorityScript();
+}
diff --git a/sigscript/MoveWrapper.h b/sigscript/MoveWrapper.h
index 0ae57288..8b6d1842 100644
--- a/sigscript/MoveWrapper.h
+++ b/sigscript/MoveWrapper.h
@@ -46,6 +46,7 @@ class SIGSCRIPT_EXPORT MoveWrapper : public ObjectWrapper
         Q_SCRIPTABLE QString description() const;
         Q_SCRIPTABLE Sigmod::Script battleScript() const;
         Q_SCRIPTABLE Sigmod::Script worldScript() const;
+        Q_SCRIPTABLE Sigmod::Script priorityScript() const;
     private:
         MoveWrapper(const Sigmod::Move* move, SigmodWrapper* parent);
         MoveWrapper& operator=(const MoveWrapper& rhs);
diff --git a/sigscript/RulesWrapper.cpp b/sigscript/RulesWrapper.cpp
index d549c395..f1493208 100644
--- a/sigscript/RulesWrapper.cpp
+++ b/sigscript/RulesWrapper.cpp
@@ -56,43 +56,43 @@ bool Sigscript::RulesWrapper::useTurns() const
 
 int Sigscript::RulesWrapper::numBoxes() const
 {
-    if (value("numBoxes").canConvert<int>())
-        return value("numBoxes").toInt();
+    if (hasValueOfType<int>("numBoxes"))
+        return valueOfType<int>("numBoxes");
     return m_rules->numBoxes();
 }
 
 int Sigscript::RulesWrapper::boxSize() const
 {
-    if (value("boxSize").canConvert<int>())
-        return value("boxSize").toInt();
+    if (hasValueOfType<int>("boxSize"))
+        return valueOfType<int>("boxSize");
     return m_rules->boxSize();
 }
 
 int Sigscript::RulesWrapper::maxParty() const
 {
-    if (value("maxParty").canConvert<int>())
-        return value("maxParty").toInt();
+    if (hasValueOfType<int>("maxParty"))
+        return valueOfType<int>("maxParty");
     return m_rules->maxParty();
 }
 
 int Sigscript::RulesWrapper::maxFight() const
 {
-    if (value("maxFight").canConvert<int>())
-        return value("maxFight").toInt();
+    if (hasValueOfType<int>("maxFight"))
+        return valueOfType<int>("maxFight");
     return m_rules->maxFight();
 }
 
 int Sigscript::RulesWrapper::maxPlayers() const
 {
-    if (value("maxFight").canConvert<int>())
-        return value("maxFight").toInt();
+    if (hasValueOfType<int>("maxFight"))
+        return valueOfType<int>("maxFight");
     return m_rules->maxPlayers();
 }
 
 int Sigscript::RulesWrapper::maxHeldItems() const
 {
-    if (value("maxHeldItems").canConvert<int>())
-        return value("maxHeldItems").toInt();
+    if (hasValueOfType<int>("maxHeldItems"))
+        return valueOfType<int>("maxHeldItems");
     return m_rules->maxHeldItems();
 }
 
@@ -108,29 +108,29 @@ int Sigscript::RulesWrapper::maxNatures() const
 
 int Sigscript::RulesWrapper::maxMoves() const
 {
-    if (value("maxMoves").canConvert<int>())
-        return value("maxMoves").toInt();
+    if (hasValueOfType<int>("maxMoves"))
+        return valueOfType<int>("maxMoves");
     return m_rules->maxMoves();
 }
 
 int Sigscript::RulesWrapper::maxLevel() const
 {
-    if (value("maxLevel").canConvert<int>())
-        return value("maxLevel").toInt();
+    if (hasValueOfType<int>("maxLevel"))
+        return valueOfType<int>("maxLevel");
     return m_rules->maxLevel();
 }
 
 int Sigscript::RulesWrapper::maxStages() const
 {
-    if (value("maxStages").canConvert<int>())
-        return value("maxStages").toInt();
+    if (hasValueOfType<int>("maxStages"))
+        return valueOfType<int>("maxStages");
     return m_rules->maxStages();
 }
 
 int Sigscript::RulesWrapper::maxMoney() const
 {
-    if (value("maxMoney").canConvert<int>())
-        return value("maxMoney").toInt();
+    if (hasValueOfType<int>("maxMoney"))
+        return valueOfType<int>("maxMoney");
     return m_rules->maxMoney();
 }
 
@@ -141,8 +141,8 @@ bool Sigscript::RulesWrapper::hardCash() const
 
 bool Sigscript::RulesWrapper::allowSwitchStyle() const
 {
-    if (value("allowSwitchStyle").canConvert<bool>())
-        return value("allowSwitchStyle").toBool();
+    if (hasValueOfType<bool>("allowSwitchStyle"))
+        return valueOfType<bool>("allowSwitchStyle");
     return m_rules->allowSwitchStyle();
 }
 
@@ -163,14 +163,14 @@ bool Sigscript::RulesWrapper::effortValuesAllowed() const
 
 int Sigscript::RulesWrapper::maxTotalEV() const
 {
-    if (value("maxTotalEV").canConvert<int>())
-        return value("maxTotalEV").toInt();
+    if (hasValueOfType<int>("maxTotalEV"))
+        return valueOfType<int>("maxTotalEV");
     return m_rules->maxTotalEV();
 }
 
 int Sigscript::RulesWrapper::maxEVPerStat() const
 {
-    if (value("maxEVPerStat").canConvert<int>())
-        return value("maxEVPerStat").toInt();
+    if (hasValueOfType<int>("maxEVPerStat"))
+        return valueOfType<int>("maxEVPerStat");
     return m_rules->maxEVPerStat();
 }
diff --git a/sigscript/SpeciesItemWrapper.cpp b/sigscript/SpeciesItemWrapper.cpp
index 707c0b57..8bc86ef3 100644
--- a/sigscript/SpeciesItemWrapper.cpp
+++ b/sigscript/SpeciesItemWrapper.cpp
@@ -42,7 +42,7 @@ Sigscript::ItemWrapper* Sigscript::SpeciesItemWrapper::item()
 
 int Sigscript::SpeciesItemWrapper::weight() const
 {
-    if (value("weight").canConvert<int>())
-        return value("weight").toInt();
+    if (hasValueOfType<int>("weight"))
+        return valueOfType<int>("weight");
     return m_item->weight();
 }
diff --git a/sigscript/SpeciesWrapper.cpp b/sigscript/SpeciesWrapper.cpp
index 7eef05e8..5f1b1a72 100644
--- a/sigscript/SpeciesWrapper.cpp
+++ b/sigscript/SpeciesWrapper.cpp
@@ -102,22 +102,22 @@ int Sigscript::SpeciesWrapper::catchValue() const
 
 Sigmod::Fraction Sigscript::SpeciesWrapper::runChance() const
 {
-    if (value("runChance").canConvert<Sigmod::Fraction>())
-        return value("runChance").value<Sigmod::Fraction>();
+    if (hasValueOfType<Sigmod::Fraction>("runChance"))
+        return valueOfType<Sigmod::Fraction>("runChance");
     return m_species->runChance();
 }
 
 Sigmod::Fraction Sigscript::SpeciesWrapper::fleeChance() const
 {
-    if (value("fleeChance").canConvert<Sigmod::Fraction>())
-        return value("fleeChance").value<Sigmod::Fraction>();
+    if (hasValueOfType<Sigmod::Fraction>("fleeChance"))
+        return valueOfType<Sigmod::Fraction>("fleeChance");
     return m_species->fleeChance();
 }
 
 Sigmod::Fraction Sigscript::SpeciesWrapper::itemChance() const
 {
-    if (value("itemChance").canConvert<Sigmod::Fraction>())
-        return value("itemChance").value<Sigmod::Fraction>();
+    if (hasValueOfType<Sigmod::Fraction>("itemChance"))
+        return valueOfType<Sigmod::Fraction>("itemChance");
     return m_species->itemChance();
 }
 
@@ -173,8 +173,8 @@ Sigmod::Fraction Sigscript::SpeciesWrapper::genderFactor() const
 
 int Sigscript::SpeciesWrapper::eggSpecies() const
 {
-    if (value("eggSpecies").canConvert<int>())
-        return value("eggSpecies").toInt();
+    if (hasValueOfType<int>("eggSpecies"))
+        return valueOfType<int>("eggSpecies");
     return m_species->eggSpecies();
 }
 
diff --git a/sigscript/TileWrapper.cpp b/sigscript/TileWrapper.cpp
index 575fc0ac..3ef2525d 100644
--- a/sigscript/TileWrapper.cpp
+++ b/sigscript/TileWrapper.cpp
@@ -42,9 +42,9 @@ QString Sigscript::TileWrapper::name() const
 
 Sigscript::SpriteWrapper* Sigscript::TileWrapper::sprite()
 {
-    if (value("sprite").canConvert<QString>())
+    if (hasValueOfType<QString>("sprite"))
     {
-        SpriteWrapper* sprite = sigmod()->sprite(value("sprite").toString());
+        SpriteWrapper* sprite = sigmod()->sprite(valueOfType<QString>("sprite"));
         if (sprite && sprite->sprite().size() == QSize(64, 64))
             return sprite;
     }
@@ -53,8 +53,8 @@ Sigscript::SpriteWrapper* Sigscript::TileWrapper::sprite()
 
 bool Sigscript::TileWrapper::from(const Sigmod::Direction direction) const
 {
-    if (value(QString("direction-%1").arg(direction)).canConvert<bool>())
-        return value(QString("direction-%1").arg(direction)).toBool();
+    if (hasValueOfType<bool>(QString("direction-%1").arg(direction)))
+        return valueOfType<bool>(QString("direction-%1").arg(direction));
     return m_tile->from(direction);
 }
 
diff --git a/sigscript/TrainerWrapper.cpp b/sigscript/TrainerWrapper.cpp
index 7d60be1e..bc937058 100644
--- a/sigscript/TrainerWrapper.cpp
+++ b/sigscript/TrainerWrapper.cpp
@@ -54,8 +54,8 @@ QString Sigscript::TrainerWrapper::TrainerWrapper::name() const
 
 int Sigscript::TrainerWrapper::TrainerWrapper::moneyFactor() const
 {
-    if (value("moneyFactor").canConvert<int>())
-        return value("moneyFactor").toInt();
+    if (hasValueOfType<int>("moneyFactor"))
+        return valueOfType<int>("moneyFactor");
     return m_trainer->moneyFactor();
 }
 
@@ -66,8 +66,8 @@ Sigscript::SkinWrapper* Sigscript::TrainerWrapper::TrainerWrapper::skin()
 
 int Sigscript::TrainerWrapper::TrainerWrapper::depth() const
 {
-    if (value("depth").canConvert<int>())
-        return value("depth").toInt();
+    if (hasValueOfType<int>("depth"))
+        return valueOfType<int>("depth");
     return m_trainer->depth();
 }