From cb83f5255b360d64c32c7e45d11d242e104e62f5 Mon Sep 17 00:00:00 2001
From: Ben Boeckel <MathStuf@gmail.com>
Date: Mon, 29 Dec 2008 12:06:26 -0500
Subject: Added macos for overriding values in sigscript

---
 sigscript/RulesWrapper.cpp | 45 +++++++++++++++------------------------------
 1 file changed, 15 insertions(+), 30 deletions(-)

(limited to 'sigscript/RulesWrapper.cpp')

diff --git a/sigscript/RulesWrapper.cpp b/sigscript/RulesWrapper.cpp
index 39efd685..a5f78592 100644
--- a/sigscript/RulesWrapper.cpp
+++ b/sigscript/RulesWrapper.cpp
@@ -57,50 +57,43 @@ bool Sigscript::RulesWrapper::useTurns() const
 
 bool Sigscript::RulesWrapper::pausedATB() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<bool>("pausedATB"))
-        return valueOfType<bool>("pausedATB");
+    ALLOW_OVERRIDE_SO(rules, bool, pausedATB);
     return m_rules->pausedATB();
 }
 
 int Sigscript::RulesWrapper::numBoxes() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("numBoxes"))
-        return valueOfType<int>("numBoxes");
+    ALLOW_OVERRIDE_SO(rules, int, numBoxes);
     return m_rules->numBoxes();
 }
 
 int Sigscript::RulesWrapper::boxSize() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("boxSize"))
-        return valueOfType<int>("boxSize");
+    ALLOW_OVERRIDE_SO(rules, int, boxSize);
     return m_rules->boxSize();
 }
 
 int Sigscript::RulesWrapper::maxParty() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxParty"))
-        return valueOfType<int>("maxParty");
+    ALLOW_OVERRIDE_SO(rules, int, maxParty);
     return m_rules->maxParty();
 }
 
 int Sigscript::RulesWrapper::maxFight() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxFight"))
-        return valueOfType<int>("maxFight");
+    ALLOW_OVERRIDE_SO(rules, int, maxFight);
     return m_rules->maxFight();
 }
 
 int Sigscript::RulesWrapper::maxPlayers() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxFight"))
-        return valueOfType<int>("maxFight");
+    ALLOW_OVERRIDE_SO(rules, int, maxFight);
     return m_rules->maxPlayers();
 }
 
 int Sigscript::RulesWrapper::maxHeldItems() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxHeldItems"))
-        return valueOfType<int>("maxHeldItems");
+    ALLOW_OVERRIDE_SO(rules, int, maxHeldItems);
     return m_rules->maxHeldItems();
 }
 
@@ -116,43 +109,37 @@ int Sigscript::RulesWrapper::maxNatures() const
 
 int Sigscript::RulesWrapper::maxMoves() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxMoves"))
-        return valueOfType<int>("maxMoves");
+    ALLOW_OVERRIDE_SO(rules, int, maxMoves);
     return m_rules->maxMoves();
 }
 
 int Sigscript::RulesWrapper::maxLevel() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxLevel"))
-        return valueOfType<int>("maxLevel");
+    ALLOW_OVERRIDE_SO(rules, int, maxLevel);
     return m_rules->maxLevel();
 }
 
 int Sigscript::RulesWrapper::maxStages() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxStages"))
-        return valueOfType<int>("maxStages");
+    ALLOW_OVERRIDE_SO(rules, int, maxStages);
     return m_rules->maxStages();
 }
 
 int Sigscript::RulesWrapper::maxMoney() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxMoney"))
-        return valueOfType<int>("maxMoney");
+    ALLOW_OVERRIDE_SO(rules, int, maxMoney);
     return m_rules->maxMoney();
 }
 
 int Sigscript::RulesWrapper::maxTotalWeight() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxTotalWeight"))
-        return valueOfType<int>("maxTotalWeight");
+    ALLOW_OVERRIDE_SO(rules, int, maxTotalWeight);
     return m_rules->maxTotalWeight();
 }
 
 bool Sigscript::RulesWrapper::allowSwitchStyle() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<bool>("allowSwitchStyle"))
-        return valueOfType<bool>("allowSwitchStyle");
+    ALLOW_OVERRIDE_SO(rules, bool, allowSwitchStyle);
     return m_rules->allowSwitchStyle();
 }
 
@@ -173,14 +160,12 @@ bool Sigscript::RulesWrapper::effortValuesAllowed() const
 
 int Sigscript::RulesWrapper::maxTotalEV() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxTotalEV"))
-        return valueOfType<int>("maxTotalEV");
+    ALLOW_OVERRIDE_SO(rules, int, maxTotalEV);
     return m_rules->maxTotalEV();
 }
 
 int Sigscript::RulesWrapper::maxEVPerStat() const
 {
-    if (sigmod()->singlePlayer() && hasValueOfType<int>("maxEVPerStat"))
-        return valueOfType<int>("maxEVPerStat");
+    ALLOW_OVERRIDE_SO(rules, int, maxEVPerStat);
     return m_rules->maxEVPerStat();
 }
-- 
cgit