path: root/pokemod/Pokemod.h

/*
 * 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/>.
 */

#ifndef __POKEMOD_POKEMOD__
#define __POKEMOD_POKEMOD__

// Qt includes
#include <QList>
#include <QPixmap>
#include <QString>
#include <QStringList>

// General includes
#include <Exception.h>
#include <Frac.h>
#include <Matrix.h>
#include <Point.h>

// Pokemod includes
#include "Object.h"
#include "Rules.h"

// Forward declarations
class Ability;
class Author;
class Badge;
class CoinList;
class Dialog;
class EggGroup;
class Item;
class ItemType;
class Map;
class Move;
class Nature;
class Species;
class Store;
class Tile;
class Time;
class Trainer;
class Type;

class Pokemod : public Object
{
    public:
        enum Validation
        {
            V_Msg = 0,
            V_Warn = 1,
            V_Error = 2,
            V_End = 3
        };
        static const QStringList ValidationStr;
        
        enum Stat
        {
            ST_HP = 0,
            ST_Attack = 1,
            ST_Defense = 2,
            ST_Speed = 3,
            ST_Special = 4,
            ST_End_RBY = 5,
            ST_SpecialAttack = 4,
            ST_SpecialDefense = 5,
            ST_End_GSC = 6,
            ST_Accuracy = 6,
            ST_Evasion = 7,
            ST_End_Battle = 8,
        };
        static const QStringList StatRBYStr;
        static const QStringList StatGSCStr;

        enum BattleMember
        {
            BM_Player = 0,
            BM_Enemy = 1,
            BM_End = 2
        };
        static const QStringList BattleMemberStr;

        enum Weather
        {
            W_Ice = 0,
            W_Rain = 1,
            W_Sun = 2,
            W_Sand = 3,
            W_End_Real = 4,
            W_All = 4,
            W_End_All = 5
        };
        static const QStringList WeatherStr;

        enum Direction
        {
            D_Up = 0,
            D_Down = 1,
            D_Left = 2,
            D_Right = 3,
            D_End = 4,
            D_None = 4,
            D_End_None = 5
        };
        static const QStringList DirectionStr;

        enum Relative
        {
            REL_Less = 0,
            REL_LessOrEqual = 1,
            REL_GreaterOrEqual = 2,
            REL_Greater = 3,
            REL_Equal = 4,
            REL_NotEqual = 5,
            REL_End = 6
        };
        static const QStringList RelativeStr;

        enum Status
        {
            STS_Freeze = 0,
            STS_Paralyze = 1,
            STS_Sleep = 2,
            STS_Poison = 3,
            STS_ToxicPoison = 4,
            STS_Burn = 5,
            STS_Any = 6,
            STS_End = 7
        };
        static const QStringList StatusStr;

        enum HMMove
        {
            HM_Cut = 0,
            HM_Fly = 1,
            HM_Surf = 2,
            HM_Strength = 3,
            HM_Whirlpool = 4,
            HM_Waterfall = 5,
            HM_Dive = 6,
            HM_Headbutt = 7,
            HM_RockSmash = 8,
            HM_RockClimb = 9,
            HM_End = 10,
            HM_Defog = 10,
            HM_Flash = 11,
            HM_Heal = 12,
            HM_Escape = 13,
            HM_End_All = 14
        };
        static const QStringList HMStr;
        
        Pokemod();
        Pokemod(const Pokemod& pokemod);
        Pokemod(const QDomElement& xml);
        ~Pokemod();
        
        void load(const QDomElement& xml, const int = 0) throw(Exception);
        QDomElement save() const;
        
        int maxCompatability(const Pokemod& rhs) const;
        
        void validationMsg(const QString& msg, Validation val = V_Error) const throw(Exception);
        void setValOutput(QStringList& s);
        void unsetValOutput();
        
        void setTitle(const QString& title);
        void setVersion(const QString& version);
        void setDescription(const QString& description);
        void setStartMap(const int startMap) throw(BoundsException);
        void setStartWarp(const int startWarp) throw(BoundsException);
        void setWalkSkin(const QPixmap& walkSkin) throw(Exception);
        void setBikeSkin(const QPixmap& bikeSkin) throw(Exception);
        void setSurfSkin(const QPixmap& surfSkin) throw(Exception);
        void setFlySkin(const QPixmap& slySkin) throw(Exception);
        void setFishSkin(const QPixmap& fishSkin) throw(Exception);
        void setSurfFishSkin(const QPixmap& surfFishSkin) throw(Exception);
        void setSuperPCUname(const QString& username);
        void setSuperPCPasswd(const QString& password);
        void setTypeChart(const int attack, const int defense, const Frac& multiplier) throw(Exception);
        void setRules(const Rules& rules);
        void setRules(const QDomElement& xml);
        
        QString title() const;
        QString version() const;
        QString description() const;
        int startMap() const;
        int startWarp() const;
        QPixmap walkSkin() const;
        QPixmap bikeSkin() const;
        QPixmap surfSkin() const;
        QPixmap flySkin() const;
        QPixmap fishSkin() const;
        QPixmap surfFishSkin() const;
        QString superPCUname() const;
        QString superPCPasswd() const;
        const Matrix<Frac>* typeChart() const;
        Matrix<Frac>* typeChart();
        Frac typeChart(const int attack, const int defense) const;
        const Rules* rules() const;
        Rules* rules();
        
        const Ability* ability(const int index) const throw(IndexException);
        Ability* ability(const int index) throw(IndexException);
        const Ability* abilityById(const int id) const throw(IndexException);
        Ability* abilityById(const int id) throw(IndexException);
        int abilityIndex(const int id) const;
        int abilityCount() const;
        Ability* newAbility();
        Ability* newAbility(const QDomElement& xml);
        Ability* newAbility(const Ability& ability);
        void deleteAbility(const int index) throw(IndexException);
        void deleteAbilityById(const int id) throw(IndexException);
        
        const Author* author(const int index) const throw(IndexException);
        Author* author(const int index) throw(IndexException);
        const Author* authorById(const int id) const throw(IndexException);
        Author* authorById(const int id) throw(IndexException);
        int authorIndex(const int id) const;
        int authorCount() const;
        Author* newAuthor();
        Author* newAuthor(const QDomElement& xml);
        Author* newAuthor(const Author& author);
        void deleteAuthor(const int index) throw(IndexException);
        void deleteAuthorById(const int id) throw(IndexException);
        
        const Badge* badge(const int index) const throw(IndexException);
        Badge* badge(const int index) throw(IndexException);
        const Badge* badgeById(const int id) const throw(IndexException);
        Badge* badgeById(const int id) throw(IndexException);
        int badgeIndex(const int id) const;
        int badgeCount() const;
        Badge* newBadge();
        Badge* newBadge(const QDomElement& xml);
        Badge* newBadge(const Badge& badge);
        void deleteBadge(const int index) throw(IndexException);
        void deleteBadgeById(const int id) throw(IndexException);
        
        const CoinList* coinList(const int index) const throw(IndexException);
        CoinList* coinList(const int index) throw(IndexException);
        const CoinList* coinListById(const int id) const throw(IndexException);
        CoinList* coinListById(const int id) throw(IndexException);
        int coinListIndex(const int id) const;
        int coinListCount() const;
        CoinList* newCoinList();
        CoinList* newCoinList(const QDomElement& xml);
        CoinList* newCoinList(const CoinList& coinList);
        void deleteCoinList(const int index) throw(IndexException);
        void deleteCoinListById(const int id) throw(IndexException);
        
        const Dialog* dialog(const int index) const throw(IndexException);
        Dialog* dialog(const int index) throw(IndexException);
        const Dialog* dialogById(const int id) const throw(IndexException);
        Dialog* dialogById(const int id) throw(IndexException);
        int dialogIndex(const int id) const;
        int dialogCount() const;
        Dialog* newDialog();
        Dialog* newDialog(const QDomElement& xml);
        Dialog* newDialog(const Dialog& dialog);
        void deleteDialog(const int index) throw(IndexException);
        void deleteDialogById(const int id) throw(IndexException);
        
        const EggGroup* eggGroup(const int index) const throw(IndexException);
        EggGroup* eggGroup(const int index) throw(IndexException);
        const EggGroup* eggGroupById(const int id) const throw(IndexException);
        EggGroup* eggGroupById(const int id) throw(IndexException);
        int eggGroupIndex(const int id) const;
        int eggGroupCount() const;
        EggGroup* newEggGroup();
        EggGroup* newEggGroup(const QDomElement& xml);
        EggGroup* newEggGroup(const EggGroup& eggGroup);
        void deleteEggGroup(const int index) throw(IndexException);
        void deleteEggGroupById(const int id) throw(IndexException);
        
        const Item* item(const int index) const throw(IndexException);
        Item* item(const int index) throw(IndexException);
        const Item* itemById(const int id) const throw(IndexException);
        Item* itemById(const int id) throw(IndexException);
        int itemIndex(const int id) const;
        int itemCount() const;
        Item* newItem();
        Item* newItem(const QDomElement& xml);
        Item* newItem(const Item& item);
        void deleteItem(const int index) throw(IndexException);
        void deleteItemById(const int id) throw(IndexException);
        
        const ItemType* itemType(const int index) const throw(IndexException);
        ItemType* itemType(const int index) throw(IndexException);
        const ItemType* itemTypeById(const int id) const throw(IndexException);
        ItemType* itemTypeById(const int id) throw(IndexException);
        int itemTypeIndex(const int id) const;
        int itemTypeCount() const;
        ItemType* newItemType();
        ItemType* newItemType(const QDomElement& xml);
        ItemType* newItemType(const ItemType& itemType);
        void deleteItemType(const int index) throw(IndexException);
        void deleteItemTypeById(const int id) throw(IndexException);
        
        const Map* map(const int index) const throw(IndexException);
        Map* map(const int index) throw(IndexException);
        const Map* mapById(const int id) const throw(IndexException);
        Map* mapById(const int id) throw(IndexException);
        int mapIndex(const int id) const;
        int mapCount() const;
        Map* newMap();
        Map* newMap(const QDomElement& xml);
        Map* newMap(const Map& map);
        void deleteMap(const int index) throw(IndexException);
        void deleteMapById(const int id) throw(IndexException);
        
        const Move* move(const int index) const throw(IndexException);
        Move* move(const int index) throw(IndexException);
        const Move* moveById(const int id) const throw(IndexException);
        Move* moveById(const int id) throw(IndexException);
        int moveIndex(const int id) const;
        int moveCount() const;
        Move* newMove();
        Move* newMove(const QDomElement& xml);
        Move* newMove(const Move& move);
        void deleteMove(const int index) throw(IndexException);
        void deleteMoveById(const int id) throw(IndexException);
        
        const Nature* nature(const int index) const throw(IndexException);
        Nature* nature(const int index) throw(IndexException);
        const Nature* natureById(const int id) const throw(IndexException);
        Nature* natureById(const int id) throw(IndexException);
        int natureIndex(const int id) const;
        int natureCount() const;
        Nature* newNature();
        Nature* newNature(const QDomElement& xml);
        Nature* newNature(const Nature& nature);
        void deleteNature(const int index) throw(IndexException);
        void deleteNatureById(const int id) throw(IndexException);
        
        const Species* species(const int index) const throw(IndexException);
        Species* species(const int index) throw(IndexException);
        const Species* speciesById(const int id) const throw(IndexException);
        Species* speciesById(const int id) throw(IndexException);
        int speciesIndex(const int id) const;
        int speciesCount() const;
        Species* newSpecies();
        Species* newSpecies(const QDomElement& xml);
        Species* newSpecies(const Species& species);
        void deleteSpecies(const int index) throw(IndexException);
        void deleteSpeciesById(const int id) throw(IndexException);
        
        const Store* store(const int index) const throw(IndexException);
        Store* store(const int index) throw(IndexException);
        const Store* storeById(const int id) const throw(IndexException);
        Store* storeById(const int id) throw(IndexException);
        int storeIndex(const int id) const;
        int storeCount() const;
        Store* newStore();
        Store* newStore(const QDomElement& xml);
        Store* newStore(const Store& store);
        void deleteStore(const int index) throw(IndexException);
        void deleteStoreById(const int id) throw(IndexException);
        
        const Tile* tile(const int index) const throw(IndexException);
        Tile* tile(const int index) throw(IndexException);
        const Tile* tileById(const int id) const throw(IndexException);
        Tile* tileById(const int id) throw(IndexException);
        int tileIndex(const int id) const;
        int tileCount() const;
        Tile* newTile();
        Tile* newTile(const QDomElement& xml);
        Tile* newTile(const Tile& tile);
        void deleteTile(const int index) throw(IndexException);
        void deleteTileById(const int id) throw(IndexException);
        
        const Time* time(const int index) const throw(IndexException);
        Time* time(const int index) throw(IndexException);
        const Time* timeById(const int id) const throw(IndexException);
        Time* timeById(const int id) throw(IndexException);
        int timeIndex(const int id) const;
        int timeCount() const;
        Time* newTime();
        Time* newTime(const QDomElement& xml);
        Time* newTime(const Time& time);
        void deleteTime(const int index) throw(IndexException);
        void deleteTimeById(const int id) throw(IndexException);
        
        const Trainer* trainer(const int index) const throw(IndexException);
        Trainer* trainer(const int index) throw(IndexException);
        const Trainer* trainerById(const int id) const throw(IndexException);
        Trainer* trainerById(const int id) throw(IndexException);
        int trainerIndex(const int id) const;
        int trainerCount() const;
        Trainer* newTrainer();
        Trainer* newTrainer(const QDomElement& xml);
        Trainer* newTrainer(const Trainer& trainer);
        void deleteTrainer(const int index) throw(IndexException);
        void deleteTrainerById(const int id) throw(IndexException);
        
        const Type* type(const int index) const throw(IndexException);
        Type* type(const int index) throw(IndexException);
        const Type* typeById(const int id) const throw(IndexException);
        Type* typeById(const int id) throw(IndexException);
        int typeIndex(const int id) const;
        int typeCount() const;
        Type* newType();
        Type* newType(const QDomElement& xml);
        Type* newType(const Type& type);
        void deleteType(const int index) throw(IndexException);
        void deleteTypeById(const int id) throw(IndexException);
        
        Pokemod& operator=(const Pokemod& rhs);
    private:
        QStringList* valOutput;
        
        bool validate() const;
        int newAbilityId() const;
        int newAuthorId() const;
        int newBadgeId() const;
        int newCoinListId() const;
        int newDialogId() const;
        int newEggGroupId() const;
        int newItemId() const;
        int newItemTypeId() const;
        int newMapId() const;
        int newMoveId() const;
        int newNatureId() const;
        int newSpeciesId() const;
        int newStoreId() const;
        int newTileId() const;
        int newTimeId() const;
        int newTrainerId() const;
        int newTypeId() const;
        void clear()
        {
            while (abilityCount())
                deleteAbility(0);
            while (authorCount())
                deleteAuthor(0);
            while (badgeCount())
                deleteBadge(0);
            while (coinListCount())
                deleteCoinList(0);
            while (dialogCount())
                deleteDialog(0);
            while (eggGroupCount())
                deleteEggGroup(0);
            while (itemCount())
                deleteItem(0);
            while (itemTypeCount())
                deleteItemType(0);
            while (mapCount())
                deleteMap(0);
            while (moveCount())
                deleteMove(0);
            while (natureCount())
                deleteNature(0);
            while (speciesCount())
                deleteSpecies(0);
            while (storeCount())
                deleteStore(0);
            while (tileCount())
                deleteTile(0);
            while (timeCount())
                deleteTime(0);
            while (trainerCount())
                deleteTrainer(0);
            while (typeCount())
                deleteType(0);
        }
        
        void copyDir(const QString& src, const QString& dest) const;
        
        QString m_title;
        QString m_version;
        QString m_description;
        int m_startMap;
        int m_startWarp;
        QPixmap m_walkSkin;
        QPixmap m_bikeSkin;
        QPixmap m_surfSkin;
        QPixmap m_flySkin;
        QPixmap m_fishSkin;
        QPixmap m_surfFishSkin;
        QString m_superPCUname;
        QString m_superPCPasswd;
        Matrix<Frac> m_typeChart;
        Rules m_rules;
        QList<Ability*> m_abilities;
        QList<Author*> m_authors;
        QList<Badge*> m_badges;
        QList<CoinList*> m_coinLists;
        QList<Dialog*> m_dialogs;
        QList<EggGroup*> m_eggGroups;
        QList<Item*> m_items;
        QList<ItemType*> m_itemTypes;
        QList<Map*> m_maps;
        QList<Move*> m_moves;
        QList<Nature*> m_natures;
        QList<Species*> m_species;
        QList<Store*> m_stores;
        QList<Tile*> m_tiles;
        QList<Time*> m_times;
        QList<Trainer*> m_trainers;
        QList<Type*> m_types;
        
        QString m_path;
};

#endif