initial commit, lordsawar source, slightly modified

[lordsawar] / src / action.h

// Copyright (C) 2002, 2003, 2004, 2005, 2006 Ulf Lorenz
// Copyright (C) 2003 Michael Bartl
// Copyright (C) 2007, 2008 Ben Asselstine
// Copyright (C) 2008 Ole Laursen
//
//  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 Library General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 
//  02110-1301, USA.

#ifndef ACTION_H
#define ACTION_H

#include <gtkmm.h>
#include <string>
#include "vector.h"
#include <sigc++/trackable.h>

#include "fight.h"
#include "army.h"
#include "reward.h"
#include "player.h"
#include "Ownable.h"
#include "defs.h"

class Quest;
class Stack;
class City;
class Signpost;
class Ruin;
class Temple;
class XML_Helper;

//! A temporary record of an event during gameplay.
/** 
 * The purpose of the action classes is to keep track of what a player has
 * done. This information can be sent over the network, so that a networked 
 * player then just has to decode and repeat the remote player's actions so
 * that the game state is synchronised.
 * 
 * Each action item is derived from the abstract Action class. It must
 * contain three functions; A loading constructor (which takes an 
 * XML_Helper parameter), a save function which saves the data to the
 * XML file, and a fillData function which takes some parameters and 
 * stores the pertinent data about what happened.
 *
 * Each Player has an Actionlist to which these actions belong.
 */

class Action
{
    public:
        //! The xml tag of this object in a saved-game file.
        static std::string d_tag; 

        //! An Action can be one of the following kinds.
        enum Type {
                /** A stack has moved. */
                STACK_MOVE = 1,
                /** A stack has separated into two parts. */
                STACK_SPLIT = 2,
                /** A stack is fighting a city or another stack. */
                STACK_FIGHT = 3,
                /** A stack has merged with another stack. */
                STACK_JOIN = 4,
                /** A stack containing a hero has examined a ruin. */
                RUIN_SEARCH = 5,
                /** A stack has examined a temple. */
                TEMPLE_SEARCH = 6,
                /** A stack has defeated a city and occupied it. */
                CITY_OCCUPY = 7,
                /** A stack has defeated a city and pillaged it. */
                CITY_PILLAGE = 8,
                /** A stack has defeated a city and razed it. */
                CITY_RAZE = 9,
                /** A player has improved the defenses of a city. (Not used) */
                CITY_UPGRADE = 10,
                /** A player has purchased a new Army unit to be produced 
                 * in a city. */
                CITY_BUY = 11,
                /** A player has changed production in a city to another 
                 * Army unit.*/
                CITY_PROD = 12,
                /** A stack has received a reward. */
                REWARD = 13,
                /** A hero has received a new quest. */
                QUEST = 14,
                /** A hero has picked up or dropped an item. */
                HERO_EQUIP = 15,
                /** An Army unit has advanced to a new level (Only used for 
                 * heroes). */
                UNIT_ADVANCE = 16,
                /** A stack has defeated a city and sacked it. */
                CITY_SACK = 17,
                /** A player has removed a stack. */
                STACK_DISBAND = 18,
                /** A player has changed what a signpost says. */
                MODIFY_SIGNPOST = 19,
                /** A player has changed the name of a city. */
                CITY_RENAME = 20,
                /** A player has vectored Army units from one city to
                 * another. */
                CITY_VECTOR = 21,
                /** A player has changed the order in which Army units do
                 * battle. */
                FIGHT_ORDER = 22,
                /** A player has surrendered. */
                RESIGN = 23,
                /** A hero has planted an item in the ground. */
                ITEM_PLANT = 24,
                /** A newly produced Army unit arrives on the map. */
                PRODUCE_UNIT = 25,
                /** A new vectored Army unit has shown up at a location. */
                PRODUCE_VECTORED_UNIT = 26,
                /** The player's diplomatic relations with respect to another
                 * player has changed. */
                DIPLOMATIC_STATE = 27,
                /** The player's diplomatic proposal with respect to another
                 * player has changed. */
                DIPLOMATIC_PROPOSAL = 28,
                /** The player's diplomatic score with respect to another
                 * player has changed. */
                DIPLOMATIC_SCORE = 29,
                END_TURN = 30,
                CITY_CONQUER = 31,
                RECRUIT_HERO = 32,
                PLAYER_RENAME = 33,
                CITY_DESTITUTE = 34,
                INIT_TURN = 35,
                CITY_LOOT = 36,
        };
        static std::string actionTypeToString(Action::Type type);
        static Action::Type actionTypeFromString(std::string str);

        //! Default constructor.
        Action(Type type);

        //! Copy constructor (shallow).
        Action(const Action &action);

        //! Loading constructor.
        Action(XML_Helper *helper);

        //! Destructor.
        virtual ~Action();

        //! Returns debug information. Needs to be overwritten by derivatives.
        virtual std::string dump() const = 0;

        //! Save function. See XML_Helper for information about saving.
        bool save(XML_Helper* helper) const;
        bool saveContents(XML_Helper* helper) const;
        
        /** 
         * static load function (see XML_Helper)
         * 
         * Whenever an action item is loaded, this function is called. It
         * examines the stored id and calls the constructor of the appropriate
         * action class.
         *
         * @param helper       the XML_Helper instance for the savegame
         */
        //! Load the action from an opened saved-game file.
        static Action* handle_load(XML_Helper* helper);

        //! Make a new action from an existing one.
        static Action* copy(const Action* a);

        //! Returns the Action::Type for this action.
        Type getType() const {return d_type;}

    protected:
        virtual bool doSave(XML_Helper* helper) const = 0;
        
        Type d_type;
};

//-----------------------------------------------------------------------------

//! A temporary record of a Stack moving.
/**
 * The purpose of the Action_Move class is to record when a stack has
 * moved to a new position on the map.
 */
class Action_Move : public Action
{
    public:
        //! Make a new move action.
        Action_Move();
        //! Copy constructor
        Action_Move(const Action_Move &action);
        //! Load a new move action from an opened saved-game file.
        Action_Move(XML_Helper* helper);
        //! Destroy a move action.
        ~Action_Move();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this move action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the move action with the stack and it's new position.
        bool fillData(Stack* s, Vector<int> dest);
    
        guint32 getStackId() const {return d_stack;};
        Vector<int> getEndingPosition() const {return d_dest;};
        Vector<int> getPositionDelta() const {return d_delta;};

        private:
        guint32 d_stack;
        Vector<int> d_dest;
        Vector<int> d_delta;
};

//! A temporary record of a Stack being disbanded.
/**
 * The purpose of the Action_Disband class is to record when a stack has
 * removed from the game.  Disbanding is done to primarily to save the 
 * gold pieces paid out every turn as upkeep for the Army units in the Stack.
 */
class Action_Disband: public Action
{
    public:
        //! Make a new disband action.
        Action_Disband();
        //! Copy constructor
        Action_Disband(const Action_Disband &action);
        //! Load a new disband action from an opened saved-game file.
        Action_Disband(XML_Helper* helper);
        //! Destroy a disband action.
        ~Action_Disband();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this disband action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the Stack being removed.
        bool fillData(Stack* s);
    
        guint32 getStackId() const {return d_stack;};

        private:
        guint32 d_stack;
};

//-----------------------------------------------------------------------------

//! A temporary record of a Stack being split into two.
/**
 * The purpose of the Action_Split class is to record when a Stack has been
 * separated into two parts.  This happens when the Player groups only some
 * of the Army units in the stack (not all), and then moves them to a new 
 * position on the map.  When a split is completed there is the original
 * stack (the remaining Army units in the stack that didn't change position), 
 * and a new stack added to the game (the stack containing the grouped army 
 * units).
 */
class Action_Split : public Action
{
    public:
        //! Make a new stack split action.
        Action_Split();
        //! Copy constructor
        Action_Split(const Action_Split &action);
        //! Load a new stack split action from an opened saved-game file.
        Action_Split(XML_Helper* helper);
        //! Destroy a stack split action.
        ~Action_Split();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this split action to an opened saved-game file.
        bool doSave (XML_Helper* helper) const;

        /** 
         * Populate the Action_Split class with the original Stack, and the 
         * new stack that has been added to the game.  Please note that the 
         * stacks have to be already split before this call.
         */
        //! Populate the action with pertinent data.
        bool fillData(Stack* orig, Stack* added);
    
        guint32 getStackId() const {return d_orig;};
        guint32 getNewStackId() const {return d_added;};
        guint32 getGroupedArmyId(int idx) const {return d_armies_moved[idx];};
        private:
        guint32 d_orig, d_added;
        guint32 d_armies_moved[MAX_STACK_SIZE];
};

//-----------------------------------------------------------------------------

//! A temporary record of a fight between opposing Stack objects.
/**
 * The purpose of the Action_Fight class is to record the results of a
 * fight between two Players.
 */
class Action_Fight : public Action, public sigc::trackable
{
    public:
        //! Make a new fight action.
        Action_Fight();
        //! Copy constructor
        Action_Fight(const Action_Fight &action);
        //! Load a new fight action from an opened saved-game file.
        Action_Fight(XML_Helper* helper);
        //! Destroy a fight action.
        ~Action_Fight();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this fight action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the action with the Fight.  Please note that the
         * Fight must have already been faught.
         */
        //! Fill the action with pertinent data.
        bool fillData(const Fight* f);


        std::list<FightItem> getBattleHistory() const {return d_history;};
        std::list<guint32> getAttackerArmyIds() const {return d_attackers;};
        std::list<guint32> getDefenderArmyIds() const {return d_defenders;};

        private:
        
        std::list<FightItem> d_history;
        std::list<guint32> d_attackers;
        std::list<guint32> d_defenders;

        bool loadItem(std::string tag, XML_Helper* helper);
};

//-----------------------------------------------------------------------------

//! A temporary record of two Stack objects merging into one.
/**
 * The purpose of the Action_Join class is to record a Stack has had 
 * another Stack merged into it.
 */
class Action_Join : public Action
{
    public:
        //! Make a new stack join action.
        Action_Join();
        //! Copy constructor
        Action_Join(const Action_Join &action);
        //! Load a new stack join action from an opened saved-game file.
        Action_Join(XML_Helper* helper);
        //! Destroy a stack join action.
        ~Action_Join();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this stack join action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /** 
         * Populate the Action_Join class with the original Stack, and the 
         * stack that is merging into the original one.  Please note that
         * this method must be called before the merge takes place.
         */
        //! Populate the action with pertinent data.
        bool fillData(Stack* orig, Stack* joining);
    
        guint32 getReceivingStackId() const {return d_orig_id;};
        guint32 getJoiningStackId() const {return d_joining_id;};
        private:
        guint32 d_orig_id, d_joining_id;
};

//-----------------------------------------------------------------------------

//! A temporary record of what happened when a Stack searched a Ruin.
/**
 * The purpose of the Action_Ruin class is to record what happens when a
 * Stack containing a Hero attempts to search a Ruin.
 */
class Action_Ruin : public Action
{
    public:
        //! Make a new ruin search attempted action.
        Action_Ruin();
        //! Copy constructor
        Action_Ruin(const Action_Ruin&action);
        //! Load a new ruin search attempted action from a saved-game file.
        Action_Ruin(XML_Helper* helper);
        //! Destroy a ruin search attempted action.
        ~Action_Ruin();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this ruin search attempted action to a saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_Ruin class with the Stack containing the
         * Hero Army unit, and the Ruin being searched.
         */
        //! Populate the action with pertinent data.
        bool fillData(Ruin* r, Stack* explorers);

        //! Set whether or not the Stack was successful in searching the ruin.
        void setSearched(bool searched) {d_searched = searched;}
    
        guint32 getRuinId() const {return d_ruin;};
        guint32 getStackId() const {return d_stack;};
        bool getSearchSuccessful() const {return d_searched;};

        private:
        guint32 d_ruin;
        guint32 d_stack;
        bool d_searched;
};

//-----------------------------------------------------------------------------

//! A temporary record of what happened when a Stack visited a Temple.
/**
 * The purpose of the Action_Temple class is to record what happens when
 * a Stack visits a Temple.  The Stack may be getting blessed, or instead it
 * might be a Stack containing a Hero who is obtaining a new Quest.
 */
class Action_Temple : public Action
{
    public:
        //! Make a new temple search action.
        Action_Temple();
        //! Copy constructor
        Action_Temple(const Action_Temple &action);
        //! Load a new temple search action from a saved-game file.
        Action_Temple(XML_Helper* helper);
        //! Destroy a temple search action.
        ~Action_Temple();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this temple search attempted action to a saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_Temple class with the Stack and the Temple
         * being searched.
         */
        //! Populate the action with pertinent data.
        bool fillData(Temple* t, Stack* s);
    
        guint32 getTempleId() const {return d_temple;};
        guint32 getStackId() const {return d_stack;};

        private:
        guint32 d_temple;
        guint32 d_stack;
};


//-----------------------------------------------------------------------------

//! A temporary record of what happened when a Player occupied a City.
/**
 * The purpose of the Action_Occupy class is to record when a Player has
 * defeated a City and has occupied it.  Ocuppying differs from sacking
 * and pillaging in that none of the existing Army units in the City are
 * exchanged for gold pieces.
 */
class Action_Occupy : public Action
{
    public:
        //! Make a new city occupy action.
        Action_Occupy();
        //! Copy constructor.
        Action_Occupy(const Action_Occupy &action);
        //! Load a new city occupied action from an opened saved-game file.
        Action_Occupy(XML_Helper* helper);
        //! Destroy a city occupy action.
        ~Action_Occupy();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city occupied action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the City being occupied.
        bool fillData (City* c);
    
        guint32 getCityId() const {return d_city;};

        private:
        guint32 d_city;
};

//-----------------------------------------------------------------------------

//! A temporary record of what happened when a Player pillaged a City.
/**
 * The purpose of the Action_Pillage class is to record when a Player has
 * defeated a City and has pillaged it.  Pillaging a city results in the
 * strongest Army unit being produced in that city being exchanged for an 
 * amount of gold pieces.
 */
class Action_Pillage : public Action
{
    public:
        //! Make a new city pillaged action.
        Action_Pillage();
        //! Copy constructor
        Action_Pillage(const Action_Pillage &action);
        //! Load a new city pillaged action from an opened saved-game file.
        Action_Pillage(XML_Helper* helper);
        //! Destroy a city pillaged action.
        ~Action_Pillage();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city pillaged action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the City that has been pillaged.
        bool fillData(City* c);

        guint32 getCityId() const {return d_city;};

        private:
        guint32 d_city;
};

//-----------------------------------------------------------------------------

//! A temporary record of what happened when a Player sacked a City.
/**
 * The purpose of the Action_Sack class is to record when a Player has
 * defeated a City and has sacked it.  Sacking a city results in all 
 * Army units, except the weakest being exchanged for an amount of gold 
 * pieces.
 */
class Action_Sack : public Action
{
    public:
        //! Make a new city sacked action.
        Action_Sack();
        //! Copy constructor
        Action_Sack(const Action_Sack &action);
        //! Load a new city sacked action from an opened saved-game file.
        Action_Sack(XML_Helper* helper);
        //! Destroy a city sacked action.
        ~Action_Sack();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city sacked action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the City that has been sacked.
        bool fillData(City* c);

        guint32 getCityId() const {return d_city;};

        private:
        guint32 d_city;
};

//-----------------------------------------------------------------------------

//! A temporary record of what happened when a Player razed a City.
/**
 * The purpose of the Action_Raze class is to record when a Player has
 * defeated a City and has razed it.  Razing a city results in that
 * city becoming uninhabitable, and it ceases to produce new Army units.
 */
class Action_Raze : public Action
{
    public:
        //! Make a new city razed action.
        Action_Raze();
        //! Copy constructor
        Action_Raze(const Action_Raze &action);
        //! Load a new city razed action from an opened saved-game file.
        Action_Raze(XML_Helper* helper);
        //! Destroy a city razed action.
        ~Action_Raze();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city razed action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the City that has been razed.
        bool fillData (City* c);
    
        guint32 getCityId() const {return d_city;};

        private:
        guint32 d_city;
};

//-----------------------------------------------------------------------------

//! A temporary record of what happened when a City's defenses were increased.
/**
 * The purpose of the Action_Upgrade class is to record when a Player has
 * improved the City's defenses.  This action is not currently used by 
 * LordsAWar.
 */
class Action_Upgrade : public Action
{
    public:
        //! Make a new city upgraded action.
        Action_Upgrade();
        //! Copy constructor
        Action_Upgrade(const Action_Upgrade &action);
        //! Load a new city upgraded action from an opened saved-game file.
        Action_Upgrade(XML_Helper* helper);
        //! Destroy a city upgraded action.
        ~Action_Upgrade();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city upgraded action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the City that has been upgraded.
        bool fillData(City* c);

        guint32 getCityId() const {return d_city;};

        private:
        guint32 d_city;
};

//-----------------------------------------------------------------------------

//! A temporary record of more production being added to a City.
/**
 * The purpose of the Action_Buy class is to record when a Player purchases
 * a new Army unit for production in a City.  When this happens the player
 * specifies a production slot to hold the new Army unit type.  Any existing
 * Army unit type in that slot before the buy is removed.
 * The idea here is that the city may produce one Army unit type from a set 
 * of available Army units, and this action records what happens when we make 
 * a new kind of Army unit available for production in the City.
 * The army unit is taken from the Player's Armyset.
 */
class Action_Buy : public Action
{
    public:
        //! Make a new city buy production action.
        Action_Buy();
        //! Copy constructor
        Action_Buy(const Action_Buy &action);
        //! Load a new city buy production action from a saved-game file.
        Action_Buy(XML_Helper* helper);
        //! Destroy a city buy production action.
        ~Action_Buy();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city buy production action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_Buy with City where the buy has happened.
         * Also populate it with the City's production slot that is now
         * producing the new Army unit type.  Lastly, populate the Action_Buy 
         * with the new Army unit type being produced.
         */
        //! Populate the action with pertinent data.
        bool fillData(City* c, int slot, const ArmyProto *prod);

        guint32 getCityId() const {return d_city;};
        int getProductionSlot() const {return d_slot;};
        int getBoughtArmyTypeId() const {return d_prod;};
        private:
        guint32 d_city;
        int d_slot, d_prod;
};

//-----------------------------------------------------------------------------

//! A temporary record of a change in production strategy in a City.
/**
 * The purpose of the Action_Production class is to record when the Player
 * changes the production of new Army units within a City.  The idea here
 * is that the City has a set of available Army units that it may produce,
 * and the Player has selected a different Army unit to produce, or has
 * stopped production of new Army units altogether.
 */
class Action_Production : public Action
{
    public:
        //! Make a new city change production action.
        Action_Production();
        //! Copy constructor
        Action_Production (const Action_Production &action);
        //! Load a new city change production action from a saved-game file.
        Action_Production(XML_Helper* helper);
        //! Destroy a city change production action.
        ~Action_Production();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city change production action to a saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_Production with City where the change
         * in production has taken place.  Also populate it with the newly
         * active production slot (-1 means stopped).
         */
        //! Populate the action with pertinent data.
        bool fillData(City* c, int slot);

        guint32 getCityId() const {return d_city;};
        int getSlot() const {return d_prod;};

        private:
        guint32 d_city;
        int d_prod;
};

//-----------------------------------------------------------------------------

//! A temporary record of a Player or Stack getting a Reward.
/**
 * The purpose of the Action_Reward class is to record when the Player
 * has been given a Reward.
 * It could be that the player has been given: Some gold pieces, a map that 
 * makes more of the map visible or information about the location of a new
 * ruin.  It could also be that the player's active stack has been given
 * a number of allies.  It could also be that the Player's active Stack
 * contains a Hero, and the Reward is an Item for the Hero to carry.
 */
class Action_Reward : public Action
{
    public:
        //! Make a new player rewarded action.
        Action_Reward();
        //! Copy constructor
        Action_Reward (const Action_Reward &action);
        //! Load a new player rewarded action from a saved-game file.
        Action_Reward(XML_Helper* helper);
        //! Destroy a player rewarded action.
        ~Action_Reward();
        
        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this player rewarded action to a saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the Action_Reward with a Reward.
        bool fillData (Stack *stack, Reward *r);
    

        Reward *getReward() const {return d_reward;};
        guint32 getStackId() const {return d_stack;};

        private:
        Reward *d_reward;
        guint32 d_stack;

        bool load(std::string tag, XML_Helper *helper);
        
};

//-----------------------------------------------------------------------------

//! A temporary record of a Hero initiating a new Quest.
/**
 * The purpose of the Action_Quest class is to record when a Player's
 * Hero has gone to a Temple and initiated a new Quest.
 */
class Action_Quest : public Action
{
    public:
        //! Make a new hero quest assigned action.
        Action_Quest();
        //! Copy constructor
        Action_Quest (const Action_Quest &action);
        //! Load a new hero quest assigned action from a saved-game file.
        Action_Quest(XML_Helper* helper);
        //! Destroy a hero quest assigned action.
        ~Action_Quest();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this hero quest assigned action to a saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the Action_Quest with a Quest.
        bool fillData(Quest* q);

        guint32 getHeroId() const {return d_hero;};
        guint32 getQuestType() const {return d_questtype;};
        guint32 getData() const {return d_data;};
        guint32 getVictimPlayerId() const {return d_victim_player;};

        private:
        guint32 d_hero;
        guint32 d_questtype;
        guint32 d_data;
        guint32 d_victim_player; //victim player, only KILLARMIES uses this
};

//-----------------------------------------------------------------------------

//! A temporary record of a Hero picking up or dropping an Item.
/**
 * The purpose of the Action_Equip class is to record when a Player's Hero
 * has picked up an Item or dropped it onto the ground.  Heroes pick up
 * and drop Items one at a time.
 */
class Action_Equip : public Action
{
    public:
        enum Slot {
            // The Item is going neither to the ground or the backpack.
            NONE = 0,
            //! The Item has gone into the Hero's Backpack.
            BACKPACK = 1,
            //! The Item has been dropped onto the ground.
            GROUND = 2};
        
        //! Make a new item equipped action.
        Action_Equip();
        //! Copy constructor
        Action_Equip (const Action_Equip &action);
        //! Load a new item equipped action from an opened saved-game file.
        Action_Equip(XML_Helper* helper);
        //! Destroy an item equipped action.
        ~Action_Equip();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this item equipped action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_Equip class with the Id of the Hero,
         * the Id of the Item and the destination of the Item in terms of
         * it's Action_Equip::Slot.
         */
        //! Populate the action with pertinent data.
        bool fillData(Hero *hero, Item *item, Slot slot, Vector<int> pos);

        guint32 getHeroId() const {return d_hero;};
        guint32 getItemId() const {return d_item;};
        guint32 getToBackpackOrToGround() const {return d_slot;};
        Vector<int> getItemPos() const {return d_pos;};

        private:
        guint32 d_hero;
        guint32 d_item;
        guint32 d_slot;
        Vector<int> d_pos;
};

//-----------------------------------------------------------------------------

//! A temporary record of a Hero gaining a new level.
/**
 * The purpose of the Action_Level class is to record when a Player's Hero
 * advances a level and subsequently gains a stat.
 * Stats that may get increased are: Strength, Moves, and Sight (for use on 
 * a hidden map).
 */
class Action_Level : public Action
{
    public:
        //! Make a new level advancement action.
        Action_Level();
        //! Copy constructor
        Action_Level (const Action_Level &action);
        //! Load a new level advancement action from an opened saved-game file.
        Action_Level(XML_Helper* helper);
        //! Destroy a level advancement action.
        ~Action_Level();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this level advancement action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_Level class with the the Id of the Hero
         * Army unit, and also the Hero's stat that has been raised as a
         * result of the level advancement.
         */
        //! Populate the action with pertinent data.
        bool fillData(Army *unit, Army::Stat raised);

        guint32 getArmyId() const {return d_army;};
        guint32 getStatToIncrease() const {return d_stat;};

        private:
        guint32 d_army;
        guint32 d_stat;
};

//-----------------------------------------------------------------------------

//! A temporary record of a Player changing the contents of a Signpost.
/**
 * The purpose of the Action_ModifySignpost is to record when a Signpost
 * has been altered by a player to have a different message on it.  The
 * idea here is that we're playing on a hidden map and a Player wants to
 * thwart an opponent by changing what signs say before he can read them.
 */
class Action_ModifySignpost: public Action
{
    public:
        //! Make a new change signpost action.
        Action_ModifySignpost();
        //! Copy constructor
        Action_ModifySignpost(const Action_ModifySignpost &action);
        //! Load a new change signpost action from an opened saved-game file.
        Action_ModifySignpost(XML_Helper* helper);
        //! Destroy a change signpost action.
        ~Action_ModifySignpost();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this change signpost action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the signpost and the new message.
        bool fillData(Signpost * s, std::string message);
    
        guint32 getSignpostId() const {return d_signpost;};
        std::string getSignContents() const {return d_message;};

        private:
        guint32 d_signpost;
        std::string d_message;
};

//-----------------------------------------------------------------------------

//! A temporary record of a Player changing the name of a City.
/**
 * The purpose of the Action_RenameCity class is to record when a Player has
 * changed the name of a City.  The idea here is that a Player wants
 * to gloat by renaming a newly conquered City.
 */
class Action_RenameCity: public Action
{
    public:
        //! Make a new city rename action.
        Action_RenameCity();
        //! Copy constructor
        Action_RenameCity(const Action_RenameCity &action);
        //! Load a new city rename action from an opened saved-game file.
        Action_RenameCity(XML_Helper* helper);
        //! Destroy a city rename action.
        ~Action_RenameCity();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city rename action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the city being renamed and the new name.
        bool fillData(City *c, std::string name);
    
        guint32 getCityId() const {return d_city;};
        std::string getNewCityName() const {return d_name;};
        private:
        guint32 d_city;
        std::string d_name;
};

//-----------------------------------------------------------------------------

//! A temporary record of a Player changing vectoring strategies for a City.
/**
 * The purpose of the Action_Vector class is to record when a Player has
 * changed the vectoring policy of a City.  The City's Army units can
 * be vectored to another City or to a Hero's planted standard (Item).
 * When units are vectored they take 2 turns to appear at their destination.
 * While the vectored units are en route, they are invisible.
 */
class Action_Vector: public Action
{
    public:
        //! Make a new city vector action.
        Action_Vector();
        //! Copy constructor
        Action_Vector(const Action_Vector &action);
        //! Load a new city vector action from an opened saved-game file.
        Action_Vector(XML_Helper* helper);
        //! Destroy a city vector action.
        ~Action_Vector();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city vector action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_Vector class with the City being vectored
         * from, and the destination position for the vectored units.
         */
        //! Populate the action with pertinent data.
        bool fillData(City* src, Vector <int> dest);
    
        guint32 getCityId() const {return d_city;};
        Vector<int> getVectoringDestination() const {return d_dest;};

        private:
        guint32 d_city;
        Vector<int> d_dest;
};

//-----------------------------------------------------------------------------

//! A temporary record of a Player changing the fight order of an Armyset.
/**
 * The purpose of the Action_FightOrder action is to record when a Player
 * changes the order in which Army units fight in battle.
 */
class Action_FightOrder: public Action
{
    public:
        //! Make a new fight order action.
        Action_FightOrder();
        //! Copy constructor
        Action_FightOrder(const Action_FightOrder &action);
        //! Load a new fight order action from an opened saved-game file.
        Action_FightOrder(XML_Helper* helper);
        //! Destroy a fight order action.
        ~Action_FightOrder();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this fight order action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with a list of ranks, one per Army unit type.
        bool fillData(std::list<guint32> order);
    
        std::list<guint32> getFightOrder() const {return d_order;};

        private:
        std::list<guint32> d_order;
};

//-----------------------------------------------------------------------------

//! A temporary record of a Player surrendering.
/**
 * The purpose of the Action_Resign class is to record when a Player has
 * resigned from the game.  Because these actions are held in a Player's
 * Actionlist, we do not have to store the player's Id.
 */
class Action_Resign: public Action
{
    public:
        //! Make a new player resignation action.
        Action_Resign();
        //! Copy constructor
        Action_Resign(const Action_Resign &action);
        //! Load a new player resignation action from an opened saved-game file.
        Action_Resign(XML_Helper* helper);
        //! Destroy a player resignation action.
        ~Action_Resign();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this player resignation action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! This method doesn't need to be called for Action_Resign actions.
        bool fillData();
};

//-----------------------------------------------------------------------------

//! A temporary record of a Hero planting a standard into the ground.
/**
 * The purpose of the Action_Plant class is to record when a Hero has 
 * planted a standard (e.g. a flag Item) into the ground, so that Army units
 * can be vectored there.
 */
class Action_Plant: public Action
{
    public:
        //! Make a new item planted action.
        Action_Plant();
        //! Copy constructor
        Action_Plant(const Action_Plant &action);
        //! Load a new item planted action from an opened saved-game file.
        Action_Plant(XML_Helper* helper);
        //! Destroy a item planted action.
        ~Action_Plant();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this item planted action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the Id of the Hero and the Id of the Item.
        bool fillData(Hero *hero, Item *item);

        guint32 getHeroId() const {return d_hero;};
        guint32 getItemId() const {return d_item;};

        private:
        guint32 d_hero;
        guint32 d_item;
};

//-----------------------------------------------------------------------------

//! A temporary record of a new Army unit showing up at a city.
/**
 * The purpose of the Action_Produce class is to record when a new Army unit
 * is created.  The idea here is that a City has produced a new Army unit.
 * The City might be vectoring elsewhere, so the unit doesn't show up in the
 * City that produced it.  If vectoring is not enabled the Army unit shows
 * up right away in the host City.
 * This action is used primarily for reporting purposes.  The player's 
 * production report shows which army units were created in what cities.
 * The army unit is taken from the Player's Armyset.
 */
class Action_Produce: public Action
{
    public:
        //! Make a new unit produced action.
        Action_Produce();
        //! Copy constructor
        Action_Produce(const Action_Produce &action);
        //! Load a new unit produced action from an opened saved-game file.
        Action_Produce(XML_Helper* helper);
        //! Destroy a unit produced action.
        ~Action_Produce();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this unit produced action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_Produce action with the army type being
         * produced, the City in which it has arrived, and also whether
         * or not this unit was prevented from showing up here because
         * it is being vectored elsewhere.
         *
         * pos is the vectored location if we're vectoring
         * or it's the position on the map where the newly produced army ended 
         * up.
         */
        //! Populate the action with pertinent data.
        bool fillData(const ArmyProdBase *a, City *city, bool vectored, Vector<int> pos, guint32 army_id);

        //! Get the production details of the army that was produced.
        ArmyProdBase * getArmy() const {return d_army;}

        //! Get the Id of the City that produced the Army unit.
        guint32 getCityId() const {return d_city;}

        //! Get whether or not the Army unit is being vectored elsewhere.
        bool getVectored() const {return d_vectored;}

        //! Get where this army ends up on the map.
        Vector<int> getDestination() const {return d_dest;}

        //! Get the id of the army instance that was created.
        guint32 getArmyId() const {return d_army_id;}
    private:
        ArmyProdBase *d_army;
        guint32 d_city;
        bool d_vectored;
        Vector<int> d_dest;
        guint32 d_army_id;

        bool load(std::string tag, XML_Helper *helper);
};

        
//-----------------------------------------------------------------------------

//! A temporary record of a vectored Army unit showing up at a city.
/**
 * The purpose of the Action_ProduceVectored class is to record when a new
 * vectored Army unit arrives at it's destination.  The idea here is that
 * two turns have passed since a unit was vectored, and now the unit has
 * shown up.
 * This action is used primarily for reporting purposes.  The player's 
 * production report shows which vectored army units arrived in what cities.
 * The army unit is taken from the Player's Armyset.
 */
class Action_ProduceVectored: public Action
{
    public:
        //! Make a new vector arrival action.
        Action_ProduceVectored();
        //! Copy constructor
        Action_ProduceVectored(const Action_ProduceVectored &action);
        //! Load a new vector arrival action from an opened saved-game file.
        Action_ProduceVectored(XML_Helper* helper);
        //! Destroy a vector arrival action.
        ~Action_ProduceVectored();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this vector arrival action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_ProduceVectored with the Id of the army
         * unit type being produced, and the position on the map where
         * it has showing up.
         */
        //! Populate the action with pertinent data.
        bool fillData(ArmyProdBase *army, Vector <int> dest, Vector<int> src);

        //! Get the army type Id that has shown up.
        ArmyProdBase *getArmy() const {return d_army;};

        //! Get the position on the map where the army showed up.
        Vector<int> getDestination() const {return d_dest;}

        //! Get the position on the map where the army is coming from.
        Vector<int> getOrigination() const {return d_src;}
    private:
        ArmyProdBase *d_army;
        Vector<int> d_dest;
        Vector<int> d_src;
        bool load(std::string tag, XML_Helper *helper);
};

//-----------------------------------------------------------------------------

//! A temporary record of the diplomatic state changing.
/**
 * The purpose of the Action_DiplomacyState action is to record our
 * diplomatic state with other players has it changes.  The idea here is 
 * that every player has a diplomatic status with every other player.
 * Although we might propose war on a given turn, we would achieve the
 * state of being at war on a later turn.
 */
class Action_DiplomacyState: public Action
{
    public:
        //! Make a new diplomatic state action.
        Action_DiplomacyState();
        //! Copy constructor
        Action_DiplomacyState(const Action_DiplomacyState &action);
        //! Load a new diplomatic state action from an opened saved-game file.
        Action_DiplomacyState(XML_Helper* helper);
        //! Destroy a diplomatic state action.
        ~Action_DiplomacyState();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this diplomatic state action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_DiplomacyState class with the Player for
         * which we are in a state with.  Also populate the action with
         * the new diplomatic state.
         */
        //! Populate action with pertinent data.
        bool fillData(Player *player, Player::DiplomaticState state);

        //! Get the Id of the Player that we have entered a new state for.
        guint32 getOpponentId() const {return d_opponent_id;}

        //! Get the state that we're in with the other Player.
        Player::DiplomaticState getDiplomaticState() const
          {return d_diplomatic_state;};
    private:
        guint32 d_opponent_id;
        Player::DiplomaticState d_diplomatic_state;
};

//-----------------------------------------------------------------------------

//! A temporary record of a diplomatic proposal.
/**
 * The purpose of the Action_DiplomacyProposal action is to record our
 * diplomatic proposals to other players.  The idea here is that the player
 * wishes to go to war with another Player and so offers/proposes war to a 
 * prospective enemy.
 */
class Action_DiplomacyProposal: public Action
{
    public:
        //! Make a new diplomatic proposal action.
        Action_DiplomacyProposal();
        //! Copy constructor
        Action_DiplomacyProposal(const Action_DiplomacyProposal &action);
        //! Load a new diplomatic proposal action from a saved-game file.
        Action_DiplomacyProposal(XML_Helper* helper);
        //! Destroy a diplomatic proposal action.
        ~Action_DiplomacyProposal();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this diplomatic proposal action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_DiplomacyProposal class with the Player for
         * which we have a new proposal for.  Also populate the action with
         * the new diplomatic proposal.
         */
        //! Populate action with pertinent data.
        bool fillData(Player *player, Player::DiplomaticProposal proposal);

        //! Get the Id of the Player that our proposal is for.
        guint32 getOpponentId() const {return d_opponent_id;}

        //! Get the proposal that we're offering.
        Player::DiplomaticProposal getDiplomaticProposal() const
          {return d_diplomatic_proposal;};
    private:
        guint32 d_opponent_id;
        Player::DiplomaticProposal d_diplomatic_proposal;
};

//-----------------------------------------------------------------------------

//! A temporary record of the diplomatic score.
/**
 * The purpose of the Action_DiplomacyScore is to record when a Player's
 * diplomatic opinion of another Player has changed.  The idea here is that
 * an enemy player has razed a city and now our opinion of that player
 * deteriorates.
 */
class Action_DiplomacyScore: public Action
{
    public:
        //! Make a new diplomatic score action.
        Action_DiplomacyScore();
        //! Copy constructor.
        Action_DiplomacyScore(const Action_DiplomacyScore &action);
        //! Load a new diplomatic score action from an opened saved-game file.
        Action_DiplomacyScore(XML_Helper* helper);
        //! Destroy a diplomatic score action.
        ~Action_DiplomacyScore();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this diplomatic score action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        /**
         * Populate the Action_DiplomacyScore class with the Player for
         * which we have changed our opinion of.  Also populate the action
         * with the amount of change for that Player.  The change can be 
         * negative, and is added to the existing score to get the new 
         * score.
         */
        //! Populate action with pertinent data.
        bool fillData(Player *player, int amount);

        //! Get the Id of the Player that our opinion has changed of.
        guint32 getOpponentId() const {return d_opponent_id;}

        //! Get the amount of the opinion change.
        int getAmountChange() const {return d_amount;};
    private:
        guint32 d_opponent_id;
        int d_amount;
};

//-----------------------------------------------------------------------------

class Action_EndTurn: public Action
{
    public:
        //! Make a new end turn action.
        Action_EndTurn();
        //! Copy constructor
        Action_EndTurn(const Action_EndTurn &action);
        //! Load a new end turn action from an opened saved-game file.
        Action_EndTurn(XML_Helper* helper);
        //! Destroy a end turn action.
        ~Action_EndTurn();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;
};

//-----------------------------------------------------------------------------

class Action_ConquerCity : public Action
{
    public:
        //! Make a new city conquer action.
        Action_ConquerCity();
        //! Copy constructor
        Action_ConquerCity(const Action_ConquerCity &action);
        //! Load a new city conquer action from an opened saved-game file.
        Action_ConquerCity(XML_Helper* helper);
        //! Destroy a city conquer action.
        ~Action_ConquerCity();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city occupied action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the City being conquered.
        bool fillData (City* c, Stack *s);
    
        guint32 getCityId() const {return d_city;};
        guint32 getStackId() const {return d_stack;};
        private:
        guint32 d_city, d_stack;
};

//-----------------------------------------------------------------------------

class Action_RecruitHero : public Action
{
    public:
        //! Make a new recruit hero action.
        Action_RecruitHero();
        //! Copy a new recruit hero action
        Action_RecruitHero(const Action_RecruitHero &action);
        //! Load a new recruit hero action from an opened saved-game file.
        Action_RecruitHero(XML_Helper* helper);
        //! Destroy a recruit hero action.
        ~Action_RecruitHero();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city occupied action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action.
        bool fillData(HeroProto* hero, City *city, int cost, int alliesCount, const ArmyProto *ally);
    
        HeroProto* getHero() const {return d_hero;};
        guint32 getCityId() const {return d_city;};
        guint32 getCost() const {return d_cost;};
        guint32 getNumAllies() const {return d_allies;};
        guint32 getAllyArmyType() const {return d_ally_army_type;};

        private:
        HeroProto *d_hero;
        guint32 d_city, d_cost, d_allies, d_ally_army_type;

        bool load(std::string tag, XML_Helper *helper);
};

//-----------------------------------------------------------------------------

class Action_RenamePlayer: public Action
{
    public:
        //! Make a new rename player action
        Action_RenamePlayer();
        //! Copy constructor
        Action_RenamePlayer(const Action_RenamePlayer &action);
        //! Load a new rename player action from an opened saved-game file.
        Action_RenamePlayer(XML_Helper* helper);
        //! Destroy a rename player action.
        ~Action_RenamePlayer();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city occupied action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action.
        bool fillData(std::string name);
    
        std::string getName() const {return d_name;};

        private:
        std::string d_name;
};

//-----------------------------------------------------------------------------

class Action_CityTooPoorToProduce: public Action
{
    public:
        //! Make a new city-too-poor action
        Action_CityTooPoorToProduce();
        //! Copy constructor
        Action_CityTooPoorToProduce(const Action_CityTooPoorToProduce &action);
        //! Load a new too-poor action from an opened saved-game file.
        Action_CityTooPoorToProduce(XML_Helper* helper);
        //! Destroy a too-poor action.
        ~Action_CityTooPoorToProduce();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city occupied action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action.
        bool fillData(City *city, const ArmyProdBase *army);
    
        guint32 getCityId() const {return d_city;}
        guint32 getArmyType() const {return d_army_type;}

        private:
        guint32 d_city;
        guint32 d_army_type;
};

//-----------------------------------------------------------------------------

class Action_InitTurn: public Action
{
    public:
        //! Make a new initialize turn action.
        Action_InitTurn();
        //! Copy constructor
        Action_InitTurn(const Action_InitTurn &action);
        //! Load a new initialize turn action from an opened saved-game file.
        Action_InitTurn(XML_Helper* helper);
        //! Destroy a initialize turn action.
        ~Action_InitTurn();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;
};

//-----------------------------------------------------------------------------

//! A temporary record of what happened when a Player loots a City.
/**
 * The purpose of the Action_Loot class is to record when a Player has
 * defeated a City and has looted it.  Looting a city results in the
 * looting player's coffers gaining some gold pieces while the looted
 * player's coffers decrease.
 */
class Action_Loot : public Action
{
    public:
        //! Make a new city looting action.
        Action_Loot();
        //! Copy constructor
        Action_Loot(const Action_Loot &action);
        //! Load a new city looting action from an opened saved-game file.
        Action_Loot(XML_Helper* helper);
        //! Destroy a city looting action.
        ~Action_Loot();

        //! Return some debug information about this action.
        std::string dump() const;

        //! Save this city looting action to an opened saved-game file.
        virtual bool doSave(XML_Helper* helper) const;

        //! Populate the action with the players involved and the amounts.
        bool fillData(Player *looter, Player *looted, guint32 amount_to_add,
                      guint32 amount_to_subtract);

        guint32 getAmountToAdd() const { return d_gold_added;};
        guint32 getAmountToSubtract() const { return d_gold_removed;};
        guint32 getLootingPlayerId() const {return d_looting_player_id;};
        guint32 getLootedPlayerId() const {return d_looted_player_id;};

        private:
        guint32 d_looting_player_id;
        guint32 d_looted_player_id;
        guint32 d_gold_added;
        guint32 d_gold_removed;
};

#endif //ACTION_H