[FIX] classes more usable

[FIX] Matrix class
[ADD] pokemod/Rules.{h, cpp}
[FIX] coding style cleaned up

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

1 files changed, 577 insertions, 0 deletions

diff --git a/pokemod/Rules.cpp b/pokemod/Rules.cpp
new file mode 100644
index 00000000..0daede2a
--- /dev/null
+++ b/pokemod/Rules.cpp
@@ -0,0 +1,577 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        pokemod/Rules.h
+// Purpose:     Rules for a PokéMod
+// Author:      Ben Boeckel
+// Modified by: Ben Boeckel
+// Created:     Mon Nov 19 14:54:12 2007
+// Copyright:   ©2007 Ben Boeckel and Nerdy Productions
+// Licence:
+//    This program is free software: you can redistribute it and/or modify
+//    it under the terms of the GNU General Public License as published by
+//    the Free Software Foundation, either version 3 of the License, or
+//    (at your option) any later version.
+//
+//    This program is distributed in the hope that it will be useful,
+//    but WITHOUT ANY WARRANTY; without even the implied warranty of
+//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//    GNU General Public License for more details.
+//
+//    You should have received a copy of the GNU General Public License along
+//    with this program.  If not, see <http://www.gnu.org/licenses/>.
+/////////////////////////////////////////////////////////////////////////////
+
+#include "Rules.h"
+
+PokeGen::PokeMod::Rules::Rules(const Pokemod& par) :
+        Object(par, 0),
+        genderAllowed(false),
+        breedingAllowed(false),
+        eggSpecies(UINT_MAX),
+        holdItems(0),
+        criticalDomains(false),
+        abilityAllowed(false),
+        natureAllowed(false),
+        numPokemonBoxes(0),
+        numPokemonPerBox(1),
+        maxParty(1),
+        maxFight(1),
+        maxMoves(1),
+        maxLevel(1),
+        maxMoney(0),
+        hardCash(false),
+        specialSplit(false),
+        specialDVSplit(false),
+        maxDVValue(16),
+        happiness(false),
+        happyFaintLoss(0),
+        happyLevelGain(0),
+        happySteps(0),
+        effortValuesAllowed(false),
+        maxTotalEV(0),
+        maxEVPerStat(0),
+        pokerusChance(1, 1),
+        typeChart(1, 1, Frac(1, 1, Frac::Improper))
+{
+}
+
+PokeGen::PokeMod::Rules::Rules(const Pokemod& par, const QString& fname) :
+        Object(par, 0)
+{
+    load(fname);
+}
+
+bool PokeGen::PokeMod::Rules::validate() const
+{
+    bool valid = true;
+    pokemod.validationMsg("---Rules", Pokemod::V_Msg);
+    if (genderAllowed && breedingAllowed || (pokemod.getSpeciesByID(eggSpecies) == UINT_MAX))
+    {
+        pokemod.validationMsg("Invalid egg species");
+        valid = false;
+    }
+    if (!numPokemonBoxes)
+        pokemod.validationMsg("Invalid number of Pokémon boxes", Pokemod::V_Warn);
+    else if (!numPokemonPerBox)
+    {
+        pokemod.validationMsg("Invalid number of Pokémon per box");
+        valid = false;
+    }
+    if (!maxParty)
+    {
+        pokemod.validationMsg("Invalid number of Pokémon for max party");
+        valid = false;
+    }
+    if (!maxParty || (maxParty < maxFight))
+    {
+        pokemod.validationMsg("More Pokémon can fight than are allowed in the party");
+        valid = false;
+    }
+    if (!maxMoves)
+    {
+        pokemod.validationMsg("Pokémon cannot learn any moves");
+        valid = false;
+    }
+    if (!maxMoney)
+        pokemod.validationMsg("Player cannot carry any money", Pokemod::V_Warn);
+    if ((maxDVValue != 16) && (maxDVValue != 32))
+    {
+        pokemod.validationMsg("Invalid maximum DV value");
+        valid = false;
+    }
+    if (effortValuesAllowed)
+    {
+        if (maxTotalEV < maxEVPerStat)
+        {
+            pokemod.validationMsg("More EV points are allowed on a stat than allowed overall");
+            valid = false;
+        }
+    }
+    if (.05 < pokerusChance)
+        pokemod.validationMsg("Pokérus chance is unusually high", Pokemod::V_Warn);
+    return valid;
+}
+
+void PokeGen::PokeMod::Rules::load(const QString& fname)
+{
+    Ini ini(fname);
+    unsigned i;
+    unsigned j;
+    ini.getValue("genderAllowed", genderAllowed, false);
+    ini.getValue("breedingAllowed", breedingAllowed, false);
+    ini.getValue("eggSpecies", eggSpecies);
+    ini.getValue("holdItems", holdItems, 0);
+    ini.getValue("criticalDomains", criticalDomains, false);
+    ini.getValue("abilityAllowed", abilityAllowed, false);
+    ini.getValue("natureAllowed", natureAllowed, false);
+    ini.getValue("numPokemonBoxes", numPokemonBoxes, 0);
+    ini.getValue("numPokemonPerBox", numPokemonPerBox, 1);
+    ini.getValue("maxParty", maxParty, 1);
+    ini.getValue("maxFight", maxFight, 1);
+    ini.getValue("maxMoves", maxMoves, 1);
+    ini.getValue("maxLevel", maxLevel, 0);
+    ini.getValue("maxMoney", maxMoney, 0);
+    ini.getValue("hardCash", hardCash, false);
+    ini.getValue("specialSplit", specialSplit, false);
+    ini.getValue("specialDVSplit", specialDVSplit, false);
+    ini.getValue("maxDVValue", maxDVValue, 16);
+    ini.getValue("happiness", happiness, false);
+    ini.getValue("happyFaintLoss", happyFaintLoss, 0);
+    ini.getValue("happyLevelGain", happyLevelGain, 0);
+    ini.getValue("happySteps", happySteps, 0);
+    ini.getValue("effortValuesAllowed", effortValuesAllowed, false);
+    ini.getValue("maxTotalEV", maxTotalEV, 0);
+    ini.getValue("maxEVPerStat", maxEVPerStat, 0);
+    ini.getValue("pokerusChance-n", i, 1);
+    ini.getValue("pokerusChance-d", j, 1);
+    pokerusChance.set(i, j);
+    for (unsigned i = 0; i < pokemod.getTypeCount(); ++i)
+    {
+        for (unsigned j = 0; j < pokemod.getTypeCount(); ++j)
+        {
+            unsigned k;
+            unsigned l;
+            ini.getValue(QString("typeChart-%1-%2-n").arg(i).arg(j), k, 1);
+            ini.getValue(QString("typeChart-%1-%2-d").arg(i).arg(j), l, 1);
+            setTypeChart(i, j, k, l);
+        }
+    }
+}
+
+void PokeGen::PokeMod::Rules::save() const
+{
+    Ini ini;
+    ini.addField("genderAllowed", genderAllowed);
+    ini.addField("breedingAllowed", breedingAllowed);
+    ini.addField("eggSpecies", eggSpecies);
+    ini.addField("holdItems", holdItems);
+    ini.addField("criticalDomains", criticalDomains);
+    ini.addField("abilityAllowed", abilityAllowed);
+    ini.addField("natureAllowed", natureAllowed);
+    ini.addField("numPokemonBoxes", numPokemonBoxes);
+    ini.addField("numPokemonPerBox", numPokemonPerBox);
+    ini.addField("maxParty", maxParty);
+    ini.addField("maxFight", maxFight);
+    ini.addField("maxMoves", maxMoves);
+    ini.addField("maxLevel", maxLevel);
+    ini.addField("maxMoney", maxMoney);
+    ini.addField("hardCash", hardCash);
+    ini.addField("specialSplit", specialSplit);
+    ini.addField("specialDVSplit", specialDVSplit);
+    ini.addField("maxDVValue", maxDVValue);
+    ini.addField("happiness", happiness);
+    ini.addField("happyFaintLoss", happyFaintLoss);
+    ini.addField("happyLevelGain", happyLevelGain);
+    ini.addField("happySteps", happySteps);
+    ini.addField("effortValuesAllowed", effortValuesAllowed);
+    ini.addField("maxTotalEV", maxTotalEV);
+    ini.addField("maxEVPerStat", maxEVPerStat);
+    ini.addField("pokerusChance-n", pokerusChance.getNum());
+    ini.addField("pokerusChance-d", pokerusChance.getDenom());
+    for (unsigned i = 1; i < typeChart.getWidth(); ++i)
+    {
+        for (unsigned j = 1; j < typeChart.getHeight(); ++j)
+        {
+            ini.addField(QString("typeChart-%1-%2-n").arg(typeChart(i, 0).getNum()).arg(typeChart(0, j).getNum()), typeChart(i, j).getNum());
+            ini.addField(QString("typeChart-%1-%2-d").arg(typeChart(i, 0).getNum()).arg(typeChart(0, j).getNum()), typeChart(i, j).getDenom());
+        }
+    }
+    ini.save(QString("%1/rules.pini").arg(pokemod.getPath()));
+}
+
+void PokeGen::PokeMod::Rules::setGenderAllowed(const bool g)
+{
+    genderAllowed = g;
+    if (!genderAllowed)
+        breedingAllowed = false;
+}
+
+void PokeGen::PokeMod::Rules::setBreedingAllowed(const bool b)
+{
+    if (!genderAllowed)
+        throw("Rules: cannot breed without genders");
+    breedingAllowed = b;
+}
+
+void PokeGen::PokeMod::Rules::setEggSpecies(const unsigned e)
+{
+    if (!breedingAllowed)
+        throw("Rules: ne eggs without breeding");
+    if (pokemod.getSpeciesByID(e) == UINT_MAX)
+        throw("Rules: eggSpecies out-of-bounds");
+    eggSpecies = e;
+}
+
+void PokeGen::PokeMod::Rules::setHoldItems(const unsigned h)
+{
+    holdItems = h;
+}
+
+void PokeGen::PokeMod::Rules::setCriticalDomains(const bool c)
+{
+    criticalDomains = c;
+}
+
+void PokeGen::PokeMod::Rules::setAbilityAllowed(const bool a)
+{
+    abilityAllowed = a;
+}
+
+void PokeGen::PokeMod::Rules::setNatureAllowed(const bool n)
+{
+    natureAllowed = n;
+}
+
+void PokeGen::PokeMod::Rules::setNumPokemonBoxes(const unsigned n)
+{
+    numPokemonBoxes = n;
+}
+
+void PokeGen::PokeMod::Rules::setNumPokemonPerBox(const unsigned n)
+{
+    numPokemonPerBox = n;
+}
+
+void PokeGen::PokeMod::Rules::setMaxParty(const unsigned m)
+{
+    if (!m)
+        throw("Rules: maxParty out-of-bounds");
+    maxParty = m;
+}
+
+void PokeGen::PokeMod::Rules::setMaxFight(const unsigned m)
+{
+    if (maxParty < m)
+        throw("Rules: maxFight out-of-bounds");
+    maxFight = m;
+}
+
+void PokeGen::PokeMod::Rules::setMaxMoves(const unsigned m)
+{
+    if (!m)
+        throw("Rules: maxMoves out-of-bounds");
+    maxMoves = m;
+}
+
+void PokeGen::PokeMod::Rules::setMaxLevel(const unsigned m)
+{
+    if (!m)
+        throw("Rules: maxLevel out-of-bounds");
+    maxLevel = m;
+}
+
+void PokeGen::PokeMod::Rules::setMaxMoney(const unsigned m)
+{
+    maxMoney = m;
+}
+
+void PokeGen::PokeMod::Rules::setHardCash(const bool h)
+{
+    hardCash = h;
+}
+
+void PokeGen::PokeMod::Rules::setSpecialSplit(const bool s)
+{
+    specialSplit = s;
+}
+
+void PokeGen::PokeMod::Rules::setSpecialDVSplit(const bool s)
+{
+    specialDVSplit = s;
+}
+
+void PokeGen::PokeMod::Rules::setMaxDVValue(const unsigned char m)
+{
+    if ((m != 16) && (m != 32))
+        throw("Rules: maxDVValue out-of-bounds");
+    maxDVValue = m;
+}
+
+void PokeGen::PokeMod::Rules::setHappiness(const bool h)
+{
+    happiness = h;
+}
+
+void PokeGen::PokeMod::Rules::setHappyFaintLoss(const unsigned h)
+{
+    happyFaintLoss = h;
+}
+
+void PokeGen::PokeMod::Rules::setHappyLevelGain(const unsigned h)
+{
+    happyLevelGain = h;
+}
+
+void PokeGen::PokeMod::Rules::setHappySteps(const unsigned h)
+{
+    happySteps = h;
+}
+
+void PokeGen::PokeMod::Rules::setEffortValuesAllowed(const bool e)
+{
+    effortValuesAllowed = e;
+}
+
+void PokeGen::PokeMod::Rules::setMaxTotalEV(const unsigned m)
+{
+    if (!effortValuesAllowed)
+        throw("Rules: no effort values");
+    maxTotalEV = m;
+}
+
+void PokeGen::PokeMod::Rules::setMaxEVPerStat(const unsigned m)
+{
+    if (!effortValuesAllowed)
+        throw("Rules: no effort values");
+    if (maxTotalEV < m)
+        throw("Rules: maxEVPerStat out-of-bounds");
+    maxEVPerStat = m;
+}
+
+void PokeGen::PokeMod::Rules::setPokerusChance(const unsigned n, const unsigned d)
+{
+    pokerusChance.set(n, d);
+}
+
+void PokeGen::PokeMod::Rules::setPokerusChanceNum(const unsigned n)
+{
+    pokerusChance.setNum(n);
+}
+
+void PokeGen::PokeMod::Rules::setPokerusChanceDenom(const unsigned d)
+{
+    pokerusChance.setDenom(d);
+}
+
+bool PokeGen::PokeMod::Rules::getGenderAllowed() const
+{
+    return genderAllowed;
+}
+
+bool PokeGen::PokeMod::Rules::getBreedingAllowed() const
+{
+    return breedingAllowed;
+}
+
+unsigned PokeGen::PokeMod::Rules::getEggSpecies() const
+{
+    return eggSpecies;
+}
+
+unsigned PokeGen::PokeMod::Rules::getHoldItems() const
+{
+    return holdItems;
+}
+
+bool PokeGen::PokeMod::Rules::getCriticalDomains() const
+{
+    return criticalDomains;
+}
+
+bool PokeGen::PokeMod::Rules::getAbilityAllowed() const
+{
+    return abilityAllowed;
+}
+
+bool PokeGen::PokeMod::Rules::getNatureAllowed() const
+{
+    return natureAllowed;
+}
+
+unsigned PokeGen::PokeMod::Rules::getNumPokemonBoxes() const
+{
+    return numPokemonBoxes;
+}
+
+unsigned PokeGen::PokeMod::Rules::getNumPokemonPerBox() const
+{
+    return numPokemonPerBox;
+}
+
+unsigned PokeGen::PokeMod::Rules::getMaxParty() const
+{
+    return maxParty;
+}
+
+unsigned PokeGen::PokeMod::Rules::getMaxFight() const
+{
+    return maxFight;
+}
+
+unsigned PokeGen::PokeMod::Rules::getMaxMoves() const
+{
+    return maxMoves;
+}
+
+unsigned PokeGen::PokeMod::Rules::getMaxLevel() const
+{
+    return maxLevel;
+}
+
+unsigned PokeGen::PokeMod::Rules::getMaxMoney() const
+{
+    return maxMoney;
+}
+
+bool PokeGen::PokeMod::Rules::getHardCash() const
+{
+    return hardCash;
+}
+
+bool PokeGen::PokeMod::Rules::getSpecialSplit() const
+{
+    return specialSplit;
+}
+
+bool PokeGen::PokeMod::Rules::getSpecialDVSplit() const
+{
+    return specialDVSplit;
+}
+
+unsigned char PokeGen::PokeMod::Rules::getMaxDVValue() const
+{
+    return maxDVValue;
+}
+
+bool PokeGen::PokeMod::Rules::getHappiness() const
+{
+    return happiness;
+}
+
+unsigned PokeGen::PokeMod::Rules::getHappyFaintLoss() const
+{
+    return happyFaintLoss;
+}
+
+unsigned PokeGen::PokeMod::Rules::getHappyLevelGain() const
+{
+    return happyLevelGain;
+}
+
+unsigned PokeGen::PokeMod::Rules::getHappySteps() const
+{
+    return happySteps;
+}
+
+bool PokeGen::PokeMod::Rules::getEffortValuesAllowed() const
+{
+    return effortValuesAllowed;
+}
+
+unsigned PokeGen::PokeMod::Rules::getMaxTotalEV() const
+{
+    return maxTotalEV;
+}
+
+unsigned PokeGen::PokeMod::Rules::getMaxEVPerStat() const
+{
+    return maxEVPerStat;
+}
+
+PokeGen::Frac PokeGen::PokeMod::Rules::getPokerusChance() const
+{
+    return pokerusChance;
+}
+
+unsigned PokeGen::PokeMod::Rules::getPokerusChanceNum() const
+{
+    return pokerusChance.getNum();
+}
+
+unsigned PokeGen::PokeMod::Rules::getPokerusChanceDenom() const
+{
+    return pokerusChance.getDenom();
+}
+
+void PokeGen::PokeMod::Rules::setTypeChart(const unsigned att, const unsigned def, const unsigned n, const unsigned d)
+{
+    typeChart(att, def).set(n, d);
+}
+
+void PokeGen::PokeMod::Rules::setTypeChartNum(const unsigned att, const unsigned def, const unsigned n)
+{
+    typeChart(att, def).setNum(n);
+}
+
+void PokeGen::PokeMod::Rules::setTypeChartDenom(const unsigned att, const unsigned def, const unsigned d)
+{
+    typeChart(att, def).setDenom(d);
+}
+
+const PokeGen::FracMatrix& PokeGen::PokeMod::Rules::getTypeChart() const
+{
+    return typeChart;
+}
+
+PokeGen::FracMatrix& PokeGen::PokeMod::Rules::getTypeChart()
+{
+    return typeChart;
+}
+
+PokeGen::Frac PokeGen::PokeMod::Rules::getTypeChart(const unsigned att, const unsigned def) const
+{
+    return typeChart(att, def);
+}
+
+unsigned PokeGen::PokeMod::Rules::getTypeChartNum(const unsigned att, const unsigned def) const
+{
+    return getTypeChart(att, def).getNum();
+}
+
+unsigned PokeGen::PokeMod::Rules::getTypeChartDenom(const unsigned att, const unsigned def) const
+{
+    return getTypeChart(att, def).getDenom();
+}
+
+PokeGen::PokeMod::Rules& PokeGen::PokeMod::Rules::operator=(const Rules& rhs)
+{
+    if (this == &rhs)
+        return *this;
+    genderAllowed = rhs.genderAllowed;
+    breedingAllowed = rhs.breedingAllowed;
+    eggSpecies = rhs.eggSpecies;
+    holdItems = rhs.holdItems;
+    criticalDomains = rhs.criticalDomains;
+    abilityAllowed = rhs.abilityAllowed;
+    natureAllowed = rhs.natureAllowed;
+    numPokemonBoxes = rhs.numPokemonBoxes;
+    numPokemonPerBox = rhs.numPokemonPerBox;
+    maxParty = rhs.maxParty;
+    maxFight = rhs.maxFight;
+    maxMoves = rhs.maxMoves;
+    maxLevel = rhs.maxLevel;
+    maxMoney = rhs.maxMoney;
+    hardCash = rhs.hardCash;
+    specialSplit = rhs.specialSplit;
+    specialDVSplit = rhs.specialDVSplit;
+    maxDVValue = rhs.maxDVValue;
+    happiness = rhs.happiness;
+    happyFaintLoss = rhs.happyFaintLoss;
+    happyLevelGain = rhs.happyLevelGain;
+    happySteps = rhs.happySteps;
+    effortValuesAllowed = rhs.effortValuesAllowed;
+    maxTotalEV = rhs.maxTotalEV;
+    maxEVPerStat = rhs.maxEVPerStat;
+    pokerusChance = rhs.pokerusChance;
+    typeChart = rhs.typeChart;
+    return *this;
+}