path: root/pokemod/Rules.cpp

/*
 * Copyright 2007-2008 Ben Boeckel <MathStuf@gmail.com>
 * 
 * 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/>.
 */

// Pokemod includes
#include "Pokemod.h"

// Header include
#include "Rules.h"

const QStringList Rules::DVStr = QStringList() << "16" << "32";

Rules::Rules(const Rules& rules) :
        Object("Rules", rules.pokemod(), 0)
{
    *this = rules;
}

Rules::Rules(const Pokemod* pokemod) :
        Object("Rules", pokemod, 0),
        m_genderAllowed(false),
        m_breedingAllowed(false),
        m_holdItems(0),
        m_criticalDomains(false),
        m_abilityAllowed(false),
        m_natureAllowed(false),
        m_numBoxes(0),
        m_boxSize(1),
        m_maxParty(1),
        m_maxFight(1),
        m_maxPlayers(2),
        m_maxMoves(1),
        m_maxLevel(1),
        m_maxMoney(0),
        m_hardCash(false),
        m_specialSplit(false),
        m_specialDVSplit(false),
        m_maxDVValue(0),
        m_happiness(false),
        m_happyFaintLoss(0),
        m_happyLevelGain(0),
        m_happySteps(0),
        m_effortValuesAllowed(false),
        m_maxTotalEV(0),
        m_maxEVPerStat(0),
        m_pokerusChance(1, 1)
{
}

Rules::Rules(const Rules& rules, const Pokemod* pokemod) :
        Object("Rules", pokemod, 0)
{
    *this = rules;
}

Rules::Rules(const QDomElement& xml, const Pokemod* pokemod) :
        Object("Rules", pokemod, 0)
{
    load(xml);
}

bool Rules::validate() const
{
    bool valid = true;
    pokemod()->validationMsg("---Rules", Pokemod::V_Msg);
    if (!m_numBoxes)
        pokemod()->validationMsg("No box storage", Pokemod::V_Warn);
    else if (!m_boxSize)
    {
        pokemod()->validationMsg("Invalid box size");
        valid = false;
    }
    if (!m_maxParty)
    {
        pokemod()->validationMsg("Invalid party size");
        valid = false;
    }
    if (!m_maxParty || (m_maxParty < m_maxFight))
    {
        pokemod()->validationMsg("Larger active than party");
        valid = false;
    }
    if (m_maxPlayers < 2)
    {
        pokemod()->validationMsg("Cannot have battles without at least two players");
        valid = false;
    }
    if (!m_maxMoves)
    {
        pokemod()->validationMsg("No moves can be learned");
        valid = false;
    }
    if (!m_maxMoney)
        pokemod()->validationMsg("Player cannot carry any money", Pokemod::V_Warn);
    if (1 < m_maxDVValue)
    {
        pokemod()->validationMsg("Invalid maximum DV value");
        valid = false;
    }
    if (m_effortValuesAllowed)
    {
        if (m_maxTotalEV < m_maxEVPerStat)
        {
            pokemod()->validationMsg("More EV points are allowed on a stat than allowed overall");
            valid = false;
        }
    }
    if (.005 < m_pokerusChance)
        pokemod()->validationMsg("Pokérus chance is unusually high", Pokemod::V_Warn);
    return valid;
}

void Rules::load(const QDomElement& xml, const int) throw(Exception)
{
    clear();
    LOAD(bool, genderAllowed);
    LOAD(bool, breedingAllowed);
    LOAD(int, holdItems);
    LOAD(bool, criticalDomains);
    LOAD(bool, abilityAllowed);
    LOAD(bool, natureAllowed);
    LOAD(int, numBoxes);
    LOAD(int, boxSize);
    LOAD(int, maxParty);
    LOAD(int, maxFight);
    LOAD(int, maxPlayers);
    LOAD(int, maxMoves);
    LOAD(int, maxLevel);
    LOAD(int, maxMoney);
    LOAD(bool, hardCash);
    LOAD(bool, specialSplit);
    LOAD(bool, specialDVSplit);
    LOAD(int, maxDVValue);
    LOAD(bool, happiness);
    LOAD(int, happyFaintLoss);
    LOAD(int, happyLevelGain);
    LOAD(int, happySteps);
    LOAD(bool, effortValuesAllowed);
    LOAD(int, maxTotalEV);
    LOAD(int, maxEVPerStat);
    LOAD(Fraction, pokerusChance);
}

QDomElement Rules::save() const
{
    QDomElement xml;
    xml.setTagName(className());
    SAVE(bool, genderAllowed);
    SAVE(bool, breedingAllowed);
    SAVE(int, holdItems);
    SAVE(bool, criticalDomains);
    SAVE(bool, abilityAllowed);
    SAVE(bool, natureAllowed);
    SAVE(int, numBoxes);
    SAVE(int, boxSize);
    SAVE(int, maxParty);
    SAVE(int, maxFight);
    SAVE(int, maxPlayers);
    SAVE(int, maxMoves);
    SAVE(int, maxLevel);
    SAVE(int, maxMoney);
    SAVE(bool, hardCash);
    SAVE(bool, specialSplit);
    SAVE(bool, specialDVSplit);
    SAVE(int, maxDVValue);
    SAVE(bool, happiness);
    SAVE(int, happyFaintLoss);
    SAVE(int, happyLevelGain);
    SAVE(int, happySteps);
    SAVE(bool, effortValuesAllowed);
    SAVE(int, maxTotalEV);
    SAVE(int, maxEVPerStat);
    SAVE(Fraction, pokerusChance);
    return xml;
}

void Rules::setGenderAllowed(const bool genderAllowed)
{
    m_genderAllowed = genderAllowed;
}

void Rules::setBreedingAllowed(const bool breedingAllowed)
{
    m_breedingAllowed = breedingAllowed;
}

void Rules::setHoldItems(const int holdItems)
{
    m_holdItems = holdItems;
}

void Rules::setCriticalDomains(const bool criticalDomains)
{
    m_criticalDomains = criticalDomains;
}

void Rules::setAbilityAllowed(const bool abilityAllowed)
{
    m_abilityAllowed = abilityAllowed;
}

void Rules::setNatureAllowed(const bool natureAllowed)
{
    m_natureAllowed = natureAllowed;
}

void Rules::setNumBoxes(const int numBoxes)
{
    m_numBoxes = numBoxes;
}

void Rules::setBoxSize(const int boxSize)
{
    m_boxSize = boxSize;
}

void Rules::setMaxParty(const int maxParty) throw(BoundsException)
{
    if (!maxParty)
        throw(BoundsException(className(), "maxParty"));
    m_maxParty = maxParty;
    if (maxParty < m_maxFight)
        setMaxFight(maxParty);
}

void Rules::setMaxFight(const int maxFight) throw(BoundsException)
{
    if (m_maxParty < maxFight)
        throw(BoundsException(className(), "maxFight"));
    m_maxFight = maxFight;
}

void Rules::setMaxPlayers(const int maxPlayers) throw(BoundsException)
{
    if (!maxPlayers)
        throw(BoundsException(className(), "maxPlayers"));
    m_maxPlayers = maxPlayers;
}

void Rules::setMaxMoves(const int maxMoves) throw(BoundsException)
{
    if (!maxMoves)
        throw(BoundsException(className(), "maxMoves"));
    m_maxMoves = maxMoves;
}

void Rules::setMaxLevel(const int maxLevel) throw(BoundsException)
{
    if (!maxLevel)
        throw(BoundsException(className(), "maxLevel"));
    m_maxLevel = maxLevel;
}

void Rules::setMaxMoney(const int maxMoney)
{
    m_maxMoney = maxMoney;
}

void Rules::setHardCash(const bool hardCash)
{
    m_hardCash = hardCash;
}

void Rules::setSpecialSplit(const bool specialSplit)
{
    m_specialSplit = specialSplit;
    if (!specialSplit)
        setSpecialDVSplit(false);
}

void Rules::setSpecialDVSplit(const bool specialDVSplit)
{
    m_specialDVSplit = specialDVSplit;
}

void Rules::setMaxDVValue(const unsigned char maxDVValue) throw(BoundsException)
{
    if (1 < maxDVValue)
        throw(BoundsException(className(), "maxDVValue"));
    m_maxDVValue = maxDVValue;
}

void Rules::setHappiness(const bool happiness)
{
    m_happiness = happiness;
}

void Rules::setHappyFaintLoss(const int happyFaintLoss)
{
    m_happyFaintLoss = happyFaintLoss;
}

void Rules::setHappyLevelGain(const int happyLevelGain)
{
    m_happyLevelGain = happyLevelGain;
}

void Rules::setHappySteps(const int happySteps)
{
    m_happySteps = happySteps;
}

void Rules::setEffortValuesAllowed(const bool effortValuesAllowed)
{
    m_effortValuesAllowed = effortValuesAllowed;
}

void Rules::setMaxTotalEV(const int maxTotalEV) throw(BoundsException)
{
    if (!maxTotalEV)
        throw(BoundsException(className(), "maxTotalEV"));
    m_maxTotalEV = maxTotalEV;
    if (maxTotalEV < m_maxEVPerStat)
        setMaxEVPerStat(maxTotalEV);
}

void Rules::setMaxEVPerStat(const int maxEVPerStat) throw(BoundsException)
{
    if (!maxEVPerStat || (m_maxTotalEV < maxEVPerStat))
        throw(BoundsException(className(), "maxEVPerStat"));
    m_maxEVPerStat = maxEVPerStat;
}

void Rules::setPokerusChance(const Fraction& pokerusChance) throw(Exception)
{
    m_pokerusChance = pokerusChance;
}

bool Rules::genderAllowed() const
{
    return m_genderAllowed;
}

bool Rules::breedingAllowed() const
{
    return m_breedingAllowed;
}

int Rules::holdItems() const
{
    return m_holdItems;
}

bool Rules::criticalDomains() const
{
    return m_criticalDomains;
}

bool Rules::abilityAllowed() const
{
    return m_abilityAllowed;
}

bool Rules::natureAllowed() const
{
    return m_natureAllowed;
}

int Rules::numBoxes() const
{
    return m_numBoxes;
}

int Rules::boxSize() const
{
    return m_boxSize;
}

int Rules::maxParty() const
{
    return m_maxParty;
}

int Rules::maxFight() const
{
    return m_maxFight;
}

int Rules::maxPlayers() const
{
    return m_maxPlayers;
}

int Rules::maxMoves() const
{
    return m_maxMoves;
}

int Rules::maxLevel() const
{
    return m_maxLevel;
}

int Rules::maxMoney() const
{
    return m_maxMoney;
}

bool Rules::hardCash() const
{
    return m_hardCash;
}

bool Rules::specialSplit() const
{
    return m_specialSplit;
}

bool Rules::specialDVSplit() const
{
    return m_specialDVSplit;
}

unsigned char Rules::maxDVValue() const
{
    return m_maxDVValue;
}

bool Rules::happiness() const
{
    return m_happiness;
}

int Rules::happyFaintLoss() const
{
    return m_happyFaintLoss;
}

int Rules::happyLevelGain() const
{
    return m_happyLevelGain;
}

int Rules::happySteps() const
{
    return m_happySteps;
}

bool Rules::effortValuesAllowed() const
{
    return m_effortValuesAllowed;
}

int Rules::maxTotalEV() const
{
    return m_maxTotalEV;
}

int Rules::maxEVPerStat() const
{
    return m_maxEVPerStat;
}

Fraction Rules::pokerusChance() const
{
    return m_pokerusChance;
}

Rules& Rules::operator=(const Rules& rhs)
{
    if (this == &rhs)
        return *this;
    COPY(genderAllowed);
    COPY(breedingAllowed);
    COPY(holdItems);
    COPY(criticalDomains);
    COPY(abilityAllowed);
    COPY(natureAllowed);
    COPY(numBoxes);
    COPY(boxSize);
    COPY(maxParty);
    COPY(maxFight);
    COPY(maxPlayers);
    COPY(maxMoves);
    COPY(maxLevel);
    COPY(maxMoney);
    COPY(hardCash);
    COPY(specialSplit);
    COPY(specialDVSplit);
    COPY(maxDVValue);
    COPY(happiness);
    COPY(happyFaintLoss);
    COPY(happyLevelGain);
    COPY(happySteps);
    COPY(effortValuesAllowed);
    COPY(maxTotalEV);
    COPY(maxEVPerStat);
    COPY(pokerusChance);
    return *this;
}