[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

1 files changed, 26 insertions, 26 deletions

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();
 }