initial commit, lordsawar source, slightly modified

[lordsawar] / src / player.h

// Copyright (C) 2000, 2001, 2002, 2003 Michael Bartl
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 Ulf Lorenz
// Copyright (C) 2003 Marek Publicewicz
// Copyright (C) 2004 John Farrell
// Copyright (C) 2005 Bryan Duff
// Copyright (C) 2006, 2007, 2008, 2009 Ben Asselstine
// Copyright (C) 2007, 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 PLAYER_H
#define PLAYER_H

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

#include "vector.h"
#include "fight.h"
#include "army.h"
#include "defs.h"
#include "callback-enums.h"

class Stacklist;
class XML_Helper;
class Hero;
class HeroProto;
class Action;
class Action_Produce;
class NetworkAction;
class History;
class NetworkHistory;
class City;
class Quest;
class Army;
class Ruin;
class Temple;
class MoveResult;
class FogMap;
class Fight;
class Reward;
class Signpost;
class VectoredUnit;
class ArmyProto;
class Item;
class Triumphs;
class Sage;

//! The abstract player class.
/** 
 * This class does not yet implement an actual player type. Its purpose is to
 * provide an abstract class design which every player implementation has to
 * fulfill. Of each player class we demand the following functionality:
 *
 * 1. functions for _every_ action a player can do
 * 2. some kind of callback functions if the player has a choice (e.g. if he has
 *    conquered a city, he may choose between razing, pillaging and occupying)
 * 3. signals which are raised whenever something important happens
 * 4. an actionlist which keeps track of _everything_ a player has done
 *
 * The fourth point allows us an easy network playing scheme. After a player
 * has finished, all he has to do is sending his actionlist to the over network
 * players. Since every item which the player can touch/kill etc. (cities,
 * armies, ruins,...) has a unique id, the remote game instances can then
 * simply apply these action lists to their own situation.
 *
 * The third point allows us to dock other classes to every possible event. One
 * example are ruin searching quests which must be informed whenever any
 * player searches a ruin. Or the bigmap can be informed when a stack moves,
 * so that it may update its contents.
 *
 * The second item allows an easy coexistence of AI and human players.
 * Basically, an AI player just follows some kind of routine while a human
 * player uses gui interaction. However, this becomes a bit problematic
 * whenever the player may decide something. One solution is providing
 * callbacks for these cases. The human player then opens a dialog somehow
 * while the AI player overwrites the default behaviour.
 *
 * The first point makes a nice derivation scheme possible. It is possible to
 * divide the player types into a local player, who implements all these
 * functions and a networked player. The latter one simply overwrites these
 * functions so that the game status is updated for each item of the actionlist
 * he has been sent. Furthermore, with a local player having been implemented,
 * it is extremely easy to write an AI player. All you have to do is overwrite
 * the startTurn function with your own code. For every action you already know
 * there is an implementation in a superior class which takes off the burden
 * for the actual work.
 *
 *
 * Finally, the current derivation scheme is as follows:
 * RealPlayer derives from Player.
 * NetworkPlayer derives from Player.
 * AI_Fast, AI_Dummy, and AI_Smart derive from RealPlayer.
 *
 * The Ids of players are very specific.  The first player (the White player)
 * must have the Id of 0, the next player (Green) must have the Id of 1, and 
 * so on.  The Neutral player must have the final player Id.
 * If the White player is not in the scenario, then the Id 0 must be skipped.
 * There can only be MAX_PLAYERS players in total.
 */

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

        //! The available player types.
        enum Type {
          //! Local human player.  See the RealPlayer class.
          HUMAN = 0, 
          //! Local computer player (Easy).  See the AI_Fast class.
          AI_FAST = 1, 
          //! Local computer player (Neutral).  See the AI_Dummy class.
          AI_DUMMY = 2, 
          //! Local computer player (Hard).  See the AI_Smart class.
          AI_SMART = 4,
          //! Remote player.  See the NetworkPlayer class.
          NETWORKED = 8
        };

        //! Every player has a diplomatic state with every other player.
        enum DiplomaticState {
          //! Can't attack opponent's stacks anywhere.
          AT_PEACE = 1, 
          //! Can't attack opponent's stacks in cities.
          AT_WAR_IN_FIELD = 2, 
          //! Can attack opponent's stack everywhere.
          AT_WAR = 3
        };

        //! Every player has a diplomatic proposal to every other player.
        enum DiplomaticProposal {
          //! Offer to keep the status-quo with the opponent.
          NO_PROPOSAL = 0, 
          //! Offer peace to an opponent.
          PROPOSE_PEACE = 1, 
          //! Offer limited war to an opponent (only kill stacks in the field).
          PROPOSE_WAR_IN_FIELD = 2, 
          //! Offer all-out war to an opponent.
          PROPOSE_WAR = 3 
        };

        /** 
         * Make a new player.  
         * @note AI_Fast, AI_Dummy, AI_Smart and RealPlayer use this 
         * constructor to make new Players.
         *
         * @param name         The name of the player.
         * @param armyset      The Id of the player's Armyset.
         * @param color        The player's colour.
         * @param width        The width of the player's FogMap.
         * @param height       The height of the player's FogMap.
         * @param type         The kind of player (Player::Type).
         * @param player_no    The Id of the player.  If this value is -1,
         *                     the next free Id it used.
         */
        //! Default constructor.
        Player (std::string name, guint32 armyset, Gdk::Color color, int width,
                int height, Type type, int player_no = -1);

        //! Copy constructor.
        Player(const Player&);

        //! Constructor for loading. See XML_Helper for documentation.
        Player(XML_Helper* helper);

        //! Destructor.
        virtual ~Player();


        // Set Methods

        //! Change the player's name.
        void setName(std::string name){d_name = name;}
        
        //! Change the player's Armyset.
        void setArmyset(guint32 armyset){d_armyset = armyset;}

        //! Set the type of the player (to be used by derived classes only.)
        void setType(Type type) {d_type = type;}

        //! Change the player's colour.
        void setColor(Gdk::Color c);

        //! Makes a player unable to die, even when having no units or cities.
        void setMortality(bool ismortal) {d_immortal = !ismortal;}
        
        //! Change the number of gold pieces of the player has.
        void setGold(int gold){d_gold = gold;}

        //! Set this player's rank in diplomatic matters.  Starts at 1.
        void setDiplomaticRank (guint32 rank) {d_diplomatic_rank = rank;};

        //! Set the rank as a name.
        void setDiplomaticTitle (std::string title) {d_diplomatic_title = title;};
        //! Set if this player will be seen as it moves through visible terrain.
        void setObservable(bool observable) {d_observable = observable;};

        //! Revive the player, this does not provide any cities.
        void revive() {d_dead = false;}

        //! Set whether or not this player has surrendered.
        /*
         * computer players may surrender to a lone human player who has most
         * of the cities on the board.
         * this method merely sets the surrendered member so that we can
         * quit properly. e.g. it triggers the aborted_Turn signal to be fired
         * at a different time in fast, smart and dummy players.
         */
        void setSurrendered(bool surr);

        //! Set the fight order of the player.
        void setFightOrder(std::list<guint32> order);



        // Get Methods

        //! Returns whether or not this is a computer player.
        virtual bool isComputer() const = 0;

        //! Returns the unique ID of the player.
        guint32 getId() const {return d_id;}

        //! Returns the list of player's events. 
        std::list<History*>* getHistorylist() {return &d_history;}

        //! Return the Id of the player's Armyset.
        guint32 getArmyset() const {return d_armyset;}

        //! Return whether or not the player has been killed.
        bool isDead() const {return d_dead;}

        //! Returns whether a player is immortal or not.
        bool isImmortal() const {return d_immortal;}

        //! Return the type of the player (Player::Type).
        guint32 getType() const {return d_type;}

        /**
         * Return the amount of upkeep in gold pieces that the player spent 
         * in the previous turn.  
         */
        //! Return the upkeep.
        guint32 getUpkeep() const {return d_upkeep;}

        //! Return the income from all of the player's cities.
        guint32 getIncome () const {return d_income;}

        //! What diplomatic rank does this player have?  Starts at 1.
        guint32 getDiplomaticRank () const {return d_diplomatic_rank;};

        //! What rank do we have?  As a name.
        std::string getDiplomaticTitle() const {return d_diplomatic_title;};

        //! Returns the colour of the player.
        Gdk::Color getColor() const {return d_color;}

        //! Returns the amount of gold pieces the player has in the treasury.
        int getGold() const {return d_gold;}

        //! Returns the name of the player.
        std::string getName(bool translate = true) const;

        //! Returns the player's current score.
        guint32 getScore() const;

        //! Returns the list of stacks owned by the player.
        Stacklist* getStacklist() const {return d_stacklist;}

        //! Get the FogMap of the player.
        FogMap* getFogMap() const {return d_fogmap;}

        //! Get the Triumphs of the player.
        Triumphs* getTriumphs() const {return d_triumphs;}

        //! Get the fight order of the player.
        std::list<guint32> getFightOrder() const {return d_fight_order;}

        bool isObservable() const {return d_observable;};

        bool abortRequested() const {return abort_requested;};

        // Methods that operate on the player's action list.

        //! Returns a list of the players unit production actions for this turn.
        std::list<Action_Produce *> getUnitsProducedThisTurn() const;

        //! Return the amount of gold pieces for the newly produced armies.
        guint32 getCostOfUnitsProducedThisTurn() const;

        //! Returns a list of the player's actions to show in a report.
        std::list<Action *> getReportableActions() const;

        //! Returns the number of times we fought so far this turn.
        int countFightsThisTurn() const;
        //! Returns the number of times we moved a stack this turn.
        int countMovesThisTurn() const;
        //! Returns number of cities that were too poor to produce this turn.
        int countDestituteCitiesThisTurn() const;

        //! Returns the battle actions for this turn.
        std::list<Action *> getFightsThisTurn() const;
        //! Returns the movement actions for this turn.
        std::list<Action *> getMovesThisTurn() const;

        //! Remove every Action from the list of the player's actions.
        void clearActionlist();

        //! Show debugging information for the player's Action list.
        void dumpActionlist() const;

        //! Wrap the player's actions for transport over the network.
        void saveNetworkActions(XML_Helper *helper) const;

        //! Check to see if it's our turn.
        bool hasAlreadyInitializedTurn() const;

        //! Check to see if we've ended our turn this round.
        bool hasAlreadyEndedTurn() const;

        //! Return the movement history of a given stack for this turn.
        std::list<Vector<int> > getStackTrack(Stack *s) const;


        // Methods that operate on the player's history list.

        //! Remove every History element from the list of the player's events.
        void clearHistorylist();

        //! Show debugging information for the player's History list.
        void dumpHistorylist() const;

        //! Check the player's history to see if we've conquered the given city.
        bool conqueredCity(City *c) const;

        //! Check the player's history to see if we've explored the given ruin.
        bool searchedRuin(Ruin *r) const;
        
        //! Return a list of history events for the given hero.
        std::list<History *> getHistoryForHeroId(guint32 id) const;

        //! Return a list of history events for the given city.
        std::list<History *> getHistoryForCityId(guint32 id) const;

        //! Count the turns we've completed.
        guint32 countEndTurnHistoryEntries() const;

        //! Add a new history item to the player's history list.
        void addHistory(History *history);


        // Methods that operate on the player's stacklist

        //! Return a list of the player's heroes.
        std::list<Hero*> getHeroes() const;

        //! Return the grand total of the player's armies.
        guint32 countArmies() const;

        //! Return the number of the player's armies that are awardable.
        guint32 countAllies() const;

        //! Return the player's currently selected stack.
        Stack * getActivestack() const;

        //! Select this stack.
        void setActivestack(Stack *);

        //! Return the position on the map for the given army unit.
        Vector<int> getPositionOfArmyById(guint32 id) const;

        //! Remove movement points from all of the player's army units.
        void immobilize();

        //! Remove all stacks from the player's list.
        void clearStacklist();

        //! Add a Stack to the player's Stacklist.
        void addStack(Stack* stack);

        //! Remove a Stack from the player's Stacklist.
        bool deleteStack(Stack* stack);


        // Methods that operate on the player's diplomatic data members.

        //! Query the diplomatic state this player has with an opponent.
        DiplomaticState getDiplomaticState (Player *player) const;

        //! Query the diplomatic proposal we're making to an opponent.
        DiplomaticProposal getDiplomaticProposal (Player *player) const;

        //! Get the diplomatic score with respect to an opponent.
        guint32 getDiplomaticScore (Player *p) const;


        void adjustDiplomacyFromConqueringCity(City *city);



        //! Add some gold pieces to the player's treasury.
        void addGold(int gold);

        //! Subtract gold pieces from the player's treasury.
        void withdrawGold(int gold);

        /**
         * Perform a summation of the upkeep value for every Army in the 
         * player's Stacklist.  This method sets d_upkeep.
         * The upkeep value is in gold pieces.
         */
        //! Calculates the upkeep.
        void calculateUpkeep();

        /**
         * Perform a summation of the income value for every City in the 
         * player's Citylist.  This method sets d_income.
         * The income value is in gold pieces.
         */
        //! Calculates the upkeep.
        void calculateIncome();


        //! Remove all fog from the player's map.
        void clearFogMap();


        /** 
         * Saves the player data to a file.
         *
         * @param helper     The opened saved-game file to write to.
         *
         * @note This function only saves basic data, it doesn't open/close the
         * player tags, this has to be done by the derived methods in 
         * RealPlayer, AI_Fast, AI_Smart and AI_Dummy.
         */
        //! Save the player to a saved-game file.
        virtual bool save(XML_Helper* helper) const;



        /** 
         * Called to merge two stacks into one.
         *
         * This callback must result in an Action_Join element being 
         * given to the addAction method.
         *
         * @param receiver     The receiving stack.
         * @param joining      The joining stack, destroyed after the join.
         *
         * @return False if an error occured, else true.
         */
        //! Callback to merge two stacks into one.
        bool stackJoin(Stack* receiver, Stack* joining);

        /**
         * Called to change the position of a Stack on the map.
         * The new position is dictated by the last point of the Path of the 
         * Stack.  This method can trigger many other actions.
         *
         * This callback must result in an Action_Move element being 
         * given to the addAction method.
         *
         * @param s             The stack to be moved.
         *
         * @return False if an error occured, else true.
         */
        //! Callback to move a stack on the map.
        bool stackMove(Stack* s);
        MoveResult* stackMove(Stack* s, Vector<int> dest);

        //! Callback to take the armies from the stack that have at least
        //! enough moves to reach the end of the stack's path.
        bool stackSplitAndMove(Stack* s, Stack *& new_stack);
        bool stackSplitAndMoveToAttack(Stack* s, Stack *& new_stack);
        bool stackSplitAndMoveToJoin(Stack* s, Stack *join, Stack *& new_stack);

        /** 
         * Called to adjudicate a fight between two lists of stacks.
         * 
         * Note that all stacks next to the defending stack also take part in
         * the fight, if they belong either to the attacker's side or to the
         * defender.  If the attacker or the defender die in the course of 
         * events, the pointers are set to 0.
         *
         * This callback must result in an Action_Fight element being 
         * given to the addAction method.
         *
         * @param attacker         The list of attacking stacks.
         * @param defender         The list of defending stacks.
         *
         * @return One of Fight::ATTACKER_WON, Fight::DEFENDER_WON, or
         *         Fight::DRAW (Fight::Result).
         */
        //! Callback to adjudicate fights.
        Fight::Result stackFight(Stack** attacker, Stack** defender);
        
        /** 
         * Called to adjudicate a fight between two lists of stacks in a ruin.
         *
         * @param attacker         The list of attacking stacks.  This list
         *                         consists of a single Stack containing at
         *                         least one Hero unit.
         * @param defender         The list of defending stacks.  This list
         *                         consists of a single Army unit in a 
         *                         single Stack.
         *
         *  If the defender dies in the fight, the defender pointer is set 
         *  to 0.
         *  If the Hero loses the battle, only the Hero unit is removed
         *  from the attacker's stack.
         *
         * @return One of Fight::ATTACKER_WON, Fight::DEFENDER_WON, or
         *         Fight::DRAW (Fight::Result).
         */
        //! Callback to adjudicate fights in ruins.
        Fight::Result stackRuinFight(Stack** attacker, Stack** defender);
        /** 
         * A stack searches a ruin.  The stack must contain a hero.
         *
         * This callback must result in an Action_Ruin element being 
         * given to the addAction method.
         *
         * @param stack            The stack which searches the ruin.
         * @param ruin             The ruin to be searched.
         *
         * @return reward          A pointer to the received Reward.  Return 
         *                         NULL if the keeper could not be defeated.
         */
        //! Callback to have a stack visit a ruin.
        Reward* stackSearchRuin(Stack* stack, Ruin* ruin);

        /** 
         * A stack visits a temple and becomes blessed. By blessing, the 
         * strength of all armies rises by 1.
         *
         * This callback must result in an Action_Temple element being 
         * given to the addAction method.
         *
         * @param stack            The stack visiting the temple.
         * @param temple           The visited temple.
         *
         * @return The number of blessed armies.
         */
        //! Callback to have a stack visit a temple.
        int stackVisitTemple(Stack* stack, Temple* temple);
        
        /** 
         * Called to ask the military advisor about what would happen 
         * if the stack attacked the tile.
         *
         * @param stack    The stack to attack with.
         * @param tile     The tile to attack (could be a city, or a stack).
         * @param intense_combat  If the intense combat game option is on or 
         *                        not.
         *
         * @return The percent chance to win the fight.  The maximum value
         *         is 100.0, and the minimum value is 0.0.
         */
        //! Callback to calculate the odds of winning a fight.
        float stackFightAdvise(Stack* stack, Vector<int> tile,
                               bool intense_combat);

        /**
         * Disbanding a player's stack removes it from the game.  Disbanding
         * stacks saves upkeep for unwanted Army units.
         *
         * This callback must result in an Action_Disband element being 
         * given to the addAction method.
         *
         * @param stack            The stack to disband.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to disband a player's stack.
        bool stackDisband(Stack* stack);

        /**
         * Modifying a signpost entails changing the message on the sign.
         * When playing in a hidden map, the hope is that we change the
         * message on the sign before an opponent can read it.
         *
         * For this callback to make sense, you should only change
         * Signposts for which we have a Stack co-located.
         *
         * This callback must result in a Action_ModifySignpost element being
         * given to the addAction method.
         *
         * @param signpost         The signpost to modify.
         * @param message          The new text to inscribe onto the sign.
         *
         * @return False on error, true otherwise.
         */
        //! Change the text on a signpost.
        bool signpostChange(Signpost *signpost, std::string message);




        // Hero related actions the player can take.

        /** 
         * Callback to plant the Player's flag Item on the ground.
         * Planting a standard entails taking the Item out of the Hero's
         * backpack and putting it on the ground so that Army units can
         * be vectored to that location.
         *
         * Computer players don't currently consider vectoring units, so
         * only human players use this method.
         *
         * This callback must result in an Action_Plant element being added
         * to the player's Action list (Player::d_actions).
         *
         * @param  stack  The Stack that contains the Hero who is holding
         *                the plantable Item.  Every player has exactly one 
         *                plantable Item.  The item is planted at the
         *                position of the Stack on the map.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to plant a player's standard.
        bool heroPlantStandard(Stack *stack);

        /**
         * Callback to drop an item at a particular position on the game map.
         * The item is removed from the Hero's backback and placed in a bag
         * at place on the map.
         * 
         * For this method to make sense, the Hero should be in a Stack
         * that is co-located with the drop position.  E.g. Heroes should
         * drop items here.
         *
         * This callback must result in an Action_Equip element being 
         * given to the addAction method.
         *
         * @param hero             The Hero that holds the item.
         * @param item             The Item to drop onto the ground.
         * @param pos              The position of the tile on the game map to 
         *                         drop the item onto.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to have a Hero drop an Item.
        bool heroDropItem(Hero *hero, Item *item, Vector<int> pos);

        /**
         * Callback to drop a all items at a particular position on the 
         * game map.  All items in the Hero's backback are removed and placed 
         * into a bag at place on the map.
         *
         * For this method to make sense, the Hero should be in a Stack
         * that is co-located with the drop position.  E.g. Heroes should
         * drop items here.
         *
         * This callback must result in one or more Action_Equip elements 
         * being given to the addAction method.
         *
         * @param hero             The Hero that holds the items.
         * @param pos              The position of the tile on the game map to 
         *                         drop the item onto.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to have a Hero drop all items.
        bool heroDropAllItems(Hero *hero, Vector<int> pos);

        /**
         * Callback to pickup an Item at a particular position on the game 
         * map.  The item is removed from a tile on the game map, and placed
         * into the Hero's backback.
         *
         * For this method to make sense, the Hero should be in a Stack
         * that is co-located with the pickup position.  E.g. Heroes should
         * pickup items from the tile they are on.
         *
         * This callback must result in an Action_Equip element being 
         * given to the addAction method.
         *
         * @param hero             The Hero that holds the item.
         * @param item             The Item to pickup off of the ground.
         * @param pos              The position of the tile on the game map to 
         *                         pickup the item from.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to have a Hero pick up an Item.
        bool heroPickupItem(Hero *hero, Item *item, Vector<int> pos);

        //! Pick up all of the items at the given location on the game map.
        bool heroPickupAllItems(Hero *h, Vector<int> pos);

        /**
         * Completing a Quest entails that the Hero is going to receive a
         * reward, but that happens in Player::giveReward.
         * The QuestsManager class handles removal of expired or completed 
         * quests.
         * This callback doesn't do much except record the event for
         * posterity (see HistoryReportDialog).
         *
         * This callback must result in a History_QuestCompleted element being
         * added to the player's History list (Player::d_history).
         *
         * @param hero             The Hero completing the Quest.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to have a Hero complete a quest.
        bool heroCompletesQuest(Hero *hero);

        /** 
         * A hero visits a temple and receives a Quest from the temple's 
         * priests.  If there is more than one hero in the stack, the quest is 
         * assigned to the first hero without a quest.
         *
         * This callback must result in an Action_Quest element being 
         * given to the addAction method.
         * This callback must result in a History_QuestStarted element being
         * added to the player's History list (Player::d_history).
         *
         * @param hero              The visiting hero.
         * @param temple            The visited temple.
         * @param except_raze       Don't give out a raze quest because it's
         *                          impossible to raze a city in this 
         *                          scenario.
         *
         * @return The newly assigned Quest or 0 on error.
         */
        //! Callback to have a Hero get a new Quest from a temple.
        Quest* heroGetQuest(Hero *hero, Temple* temple, bool except_raze);

        /** 
         * Called whenever a hero emerges in a city
         *
         * @param  hero    The hero who has offered his or her service.
         * @param  city    The city where the hero is emerging.
         * @param  cost    The amount of gold pieces neccessary to recruit 
         *                 the hero.
         * 
         * @note Only change the name and gender attributes of the Hero.
         */
        void recruitHero(HeroProto* hero, City *city, int cost, int alliesCount, const ArmyProto *ally);

        /** 
         * Called whenever a hero advances a level.
         * For human players this method presents a dialog that allows the
         * user to select an Army::STAT to improve (HP, MOVES, or SIGHT if
         * a hidden map is in use).  For computer players this method is 
         * used to decide which stat should be improved.
         * 
         * This callback must result in an Action_Level element being 
         * given to the addAction method.
         *
         * @param army     The army to raise (is always a Hero.)
         */
        //! Callback to advance an Army's level.
        virtual void heroGainsLevel(Hero * a) = 0;







        // City related actions the player can take.

        /**
         * Callback to have a Player rename a City.
         *
         * Only human players currently rename cities; computer players
         * do not consider doing so.
         *
         * This callback must result in a Action_RenameCity element being
         * given to the addAction method.
         *
         * @param city             The city to change the name of.
         * @param name             The new name of the city.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to rename a city.
        bool cityRename(City *city, std::string name);

        /** 
         * Callback to initiate vectoring new units from a player's City to 
         * a destination point on the game map.
         *
         * Computer players don't currently consider vectoring units, so
         * only human players use this method.
         *
         * This callback must result in a Action_Vector element being
         * given to the addAction method.
         *
         * @param  city   The city to vector from.
         * @param  dest   The place on the map to vector the produced Army
         *                units to.  If the  destination is -1,-1 it means 
         *                to stop vectoring altogether.  The destination 
         *                point should be co-located with a City or a 
         *                planted standard Item.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to vector produced units from a city.
        bool vectorFromCity(City* city, Vector<int> dest);

        /** 
         * Callback to change the vectoring destination for all of the
         * player's cities that are vectoring to a particular city.
         *
         * SRC and DEST can both be the player's planted standard.
         *
         * @param  src    The place that we want to take all the vectoring from.
         * @param  dest   The place on the map to vector to.  The destination 
         *                point should be co-located with a City or a 
         *                planted standard Item.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to make a mass change to vectoring.
        bool changeVectorDestination(Vector<int> src, Vector<int> dest);

        /** 
         * Callback to have the active player occupy a given city.
         * The player has defeated a City and now it has been decided
         * that the player wishes to occupy this city.  The decision 
         * happens in Player::invadeCity. Occupying means that the city 
         * becomes owned by the ocuppying player.
         *
         * This callback must result in an Action_Occupy element being 
         * given to the addAction method.
         *
         * @param city             The occupied city.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to occupy a city.
        void cityOccupy(City* city);

        /** 
         * Pillage a city (trade in the best army type and get some gold.)
         * The player has defeated a City and now it has been decided
         * that the player wishes to pillage this city.  The decision to
         * pillage happened in Player::invadeCity. Pillaging means that the 
         * city becomes owned by the pillaging player, and that the strongest 
         * Army unit type that the city can produce is traded-in for an 
         * amount of gold pieces.
         *
         * This callback must result in an Action_Pillage element being 
         * given to the addAction method.
         *
         * @param city             The city to be pillaged.
         * @param gold             Returns the amount of gold pillaged.
         * @param pillaged_army_type The army type that is cashed in for gold.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to pillage a city.
        void cityPillage(City* city, int& gold, int *pillaged_army_type);

        /**
         * Sack a city (trade in all army types except one and get some gold.)
         * The player has defeated a City and now it has been decided
         * that the player wishes to sack this city.  The decision to sack
         * was made in Player::invadeCity.  Sacking entails that the city 
         * becomes owned by the sacking player, and that all of the Army 
         * units that the city produces are traded-in for gold pieces except 
         * for the weakest Army unit.
         *
         * The AI_Fast, AI_Dummy and AI_Smart classes use this method
         * as defined in RealPlayer to sack cities.
         *
         * This callback must result in an Action_Sack element being 
         * given to the addAction method.
         *
         * @param city             The city to be sacked .
         * @param gold             Returns the amount of gold sacked.
         * @param sacked_types     Returns the Army types that were cashed-in 
         *                         for gold pieces.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to sack a city.
        void citySack(City* city, int& gold, std::list<guint32> *sacked_types);

        /** 
         * Raze (permanently destroy) a city.
         * The player has defeated a City and now it has been decided
         * that the player wishes to raze this city.  The decision to raze
         * was made in Player::invadeCity.  Razing entails that the city 
         * becomes burned, and is owned by nobody.  The city cannot produce
         * Army units.  Other players find razing to be diplomatically 
         * treacherous.
         *
         * The AI_Fast, AI_Dummy and AI_Smart classes use this method
         * as defined in RealPlayer to raze cities.
         *
         * This callback must result in an Action_Raze element being 
         * given to the addAction method.
         *
         * @param city             The city to be razed.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to raze a city.
        void cityRaze(City* city);

        /** 
         * Add another production to a city.  
         * The city has a set of Army units available to produce, but the
         * Player deems this insufficent.  A new Army unit is purchased
         * for an amount of gold pieces, so that the City can produce that
         * Army unit.  Each Army unit type that can be produced is
         * associated with one of 4 slots.  If the player purchases a new
         * Army unit in a slot that already has an Army unit, it is 
         * removed permanently.
         *
         * This callback must result in an Action_Buy element being 
         * given to the addAction method.
         *
         * @param city             The lucky city.
         * @param slot             The production slot of the city.  The 
         *                         minimum value is 0 and the maximum value
         *                         is 3.
         * @param armytype         The index of the army type to add.  This
         *                         type relates to the Player's Armyset.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to purchase a new Army unit for production within a City.
        bool cityBuyProduction(City* city, int slot, int armytype);

        /** 
         * Change the production of a city.
         * The City has a set of Army units that it may produce.  There are
         * up to 4 army units available for production in the City, and each
         * sits in a slot.  The change of production is indicated by slot 
         * number.  If the production is to stop altogether the slot number
         * is -1.
         * After a slot is selected and enough time passes, a new Army unit
         * will arrive in the city that produced it.
         *
         * This callback must result in an Action_Production element being 
         * given to the addAction method.
         *
         * @param city             The affected city.
         * @param slot             The index of the selected production slot.
         *                         The minimum value is -1 which means to 
         *                         stop production in the City.  The other
         *                         legal values are 0 through 3; one for
         *                         each slot in the city.  If a slot does
         *                         not contain an Army unit, then that slot
         *                         number is an illegal value to this method.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to change the Army unit being produced within a City.
        bool cityChangeProduction(City* city, int slot);

        //! A player's city produces an army unit.
        /**
         * @param city  The city that has produced an army unit.
         * @return False on error, true otherwise.
         */
        bool cityProducesArmy(City *city);

        //! A player has a vectored army unit arrive somewhere.
        bool vectoredUnitArrives(VectoredUnit *unit);

        //! Shut down a city's production due to insufficent funds.
        void cityTooPoorToProduce(City *city, int slot);

        /** 
         * Called so that the player can decide what to do with a newly
         * conquered city.  For human players this method presents the dialog
         * that asks the user what should be done (Razing, Pillaging, etc).
         * For the computer players this method is for deciding what to do.
         * The decision is made by emitting one of the following signals:
         * srazingCity, spillagingCity, ssackingCity, soccupyingCity.
         *
         * @param  city   The newly conquered city.
         *
         * @return True if everything went well.
         */
        //! Decision callback for what to do if a city is invaded.
        virtual void invadeCity(City* city) = 0;

        //! Decision callback for what to do when a hero shows up.
        virtual bool chooseHero(HeroProto *hero, City *city, int gold) = 0;
        
        //! Decision callback for what reward to pick when at a sage.
        virtual Reward *chooseReward(Ruin *ruin, Sage *sage, Stack *stack) = 0;

        //! Decision callback for if to commit treachery or not.
        virtual bool chooseTreachery (Stack *stack, Player *player, Vector <int> pos) = 0;

        //! Decision callback for when a hero gains a level.
        virtual Army::Stat chooseStat(Hero *hero) = 0;

        //! Decision callback for when a hero visits a temple.
        virtual bool chooseQuest(Hero *hero) = 0;

        // Player related actions the player can take.

        /** 
         * This function is called when a player's turn starts. 
         * For AI players this function should start the algorithm.
         * Results in a History_StartTurn event going into the player's 
         * Historylist.
         *
         * @return True if everything went well.
         */
        //! Callback to start a Player's turn.
        virtual bool startTurn() = 0;

        virtual void abortTurn() = 0;

        /** 
         * This function is called before a player's turn starts.
         * The idea here is that it happens before heroes are recruited,
         * and before new army units show up in cities.
         */
        //! Initialise a Player's turn.
        void initTurn();

        virtual void endTurn() = 0;
        

        /** 
         * This method gives the player the specified Reward.  There are 
         * various possibilities when they player is being 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 a stack has been 
         * given a number of powerful allies.  It could also be that a stack 
         * contains a Hero, and the Reward is an Item for the Hero to carry.
         *
         * This callback must result in an Action_Reward element being 
         * given to the addAction method.
         *
         * @param stack            The stack which has caused the reward.
         * @param reward           A pointer for storing the Reward being 
         *                         given to the player.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to give a Reward to the Player or the player's Stack.
        bool giveReward (Stack *stack, Reward *reward);

        //! Give the player a new name.
        void rename (std::string name);

        //! have a hero show up, or not.
        bool maybeRecruitHero ();

        //! Mark the player as dead. Kills all Army units in the Stacklist.
        void kill();

        //! Go to a temple if we're near enough.
        /**
         * Helper method to take a stack on a mission to get blessed.
         * If the method returns false initially, it means that the nearest 
         * temple is unsuitable.
         * @note The idea is that this method is called over subsequent turns, 
         * until the blessed parameter gets filled with a value of true.
         *
         * @param s            The stack to visit a temple.
         * @param dist         The maximum number of tiles that a temple
         *                     can be away from the stack, and be considered
         *                     for visiting.
         * @param mp           The maximum number of movement points that a
         *                     stack needs to have to reach the temple.
         * @param percent_can_be_blessed  If the stack has this many army 
         *                                units that have not been blessed
         *                                at the temple (expressed as a
         *                                percent), then the temple will be
         *                                considered for visiting.
         * @param blessed      Gets filled with false if the stack didn't get 
         *                     blessed.  Gets filled with true if the stack 
         *                     got blessed at the temple.
         * @param stack_died   Gets filled with true if the stack got killed
         *                     by an enemy stack on the same square as the
         *                     temple.
         *
         * Returns true if the stack moved, false if it stayed still.
         */
        bool AI_maybeVisitTempleForBlessing(Stack *s, int dist, int mp, 
                                            double percent_can_be_blessed, 
                                            bool &blessed, bool &stack_died);

        bool AI_maybeVisitTempleForQuest(Stack *s, int dist, int max_mp, 
                                         bool &stack_died);

        bool AI_maybeVisitRuin(Stack *s, int dist, int max_mp, 
                               bool &stack_died);

        Vector<int> AI_getQuestDestination(Quest *quest, Stack *stack) const;
        bool AI_invadeCityQuestPreference(City *c, CityDefeatedAction &action) const;
        /** 
         * Callback to decide if we perform treachery on a friendly player.
         *
         * For human players this method presents a dialog for the user
         * to confirm if treachery should happen or not.  For computer
         * players this method implements the decision to perform treachery
         * or not.
         *
         * @param stack             My stack considering the treachery.
         * @param player            The friendly player.
         * @param pos               The place on the map being targetted.
         * @param state             The state we end up in if we decide yes.
         *
         * @return True if we decided to be treacherous.  False otherwise.
         */
        //! Decision callback for if we should perform trechery or not.
        bool treachery (Stack *stack, Player *player, Vector <int> pos);

        /**
         * Callback to have the Player resign.  This entails disbanding
         * all of the player's stacks and then razing all of the player's 
         * remaining cities.  It also removes all of the gold pieces from 
         * the player's treasury.
         *
         * This callback is called when a human player wants to surrender
         * ungracefully.  Computer players do not currently consider
         * calling this method to surrender, and they use a different
         * mechanism to collectively surrender to a final human player.
         *
         * This callback must result in a Action_Resign element being
         * given to the addAction method.
         *
         */
        //! Callback to disband all the player's stacks and raze all cities.
        void resign();

        //! Declare a new diplomatic state with respect to an opponent.
        void declareDiplomacy(DiplomaticState state, Player *player);

        //! Negotiate diplomatic talks with an opponent, and return a new state.
        DiplomaticState negotiateDiplomacy (Player *player);

        /**
         * Change the player's opinion of an opponent for the better.
         *
         * @param player    The player to improve our opinion by.
         * @param amount    The amount to improve by.  The minimum value 
         *                  is 1 and the maximum value is 15.
         *
         */
        //! Make your diplomatic view of another player increase.
        void improveDiplomaticRelationship (Player *p, guint32 amount);

        /**
         * Change all players opinion of you for the better, except for 
         * possibly a single player.
         *
         * @param amount    The amount to improve.  The minimum value is 1
         *                  and the maximum value is 15.
         * @param except    Don't improve this player's view of the player.
         *
         * @note Pass except as NULL to not except a player.
         */
        //! Make all other players diplomatic view of you increase.
        void improveDiplomaticRelationship (guint32 amount, Player *except);

        /**
         * Change the player's view of an opponent for the worse.
         *
         * @param player    The player to deteriorate our view of.
         * @param amount    The amount to deteriorate by.  The minimum value 
         *                  is 1 and the maximum value is 15.
         *
         */
        //! Make your diplomatic view of another player decrease.
        void deteriorateDiplomaticRelationship (Player *player, guint32 amount);

        /**
         * Change all players opinion of you for the worse.
         *
         * @param amount    The amount to deterioriate by.  The minimum value 
         *                  is 1 and the maximum value is 15.
         */
        //! Make all other players diplomatic view of you worsen
        void deteriorateDiplomaticRelationship (guint32 amount);

        /**
         * Change all players opinion of another player for the worse, 
         * who happen to have a diplomatic state of state with you.
         *
         * @param player    The target player.
         * @param amount    The amount to deterioriate by.  The minimum value 
         *                  is 1 and the maximum value is 15.
         * @param state     The state that an opponent has to be in with you,
         *                  to make the deterioration happen.
         */
        //! Make players you are at state with you think less of player.
        void deteriorateAlliesRelationship(Player *player, guint32 amount, 
                                           Player::DiplomaticState state);

        /**
         * Change all players opinion of another player for the better, 
         * who happen to have a diplomatic state of state with you.
         *
         * @param player    The target player.
         * @param amount    The amount to improve by.  The minimum value 
         *                  is 1 and the maximum value is 15.
         * @param state     The state that an opponent has to be in with you,
         *                  to make the improvement happen.
         */
        //! Make players who are at STATE with PLAYER think better of you.
        void improveAlliesRelationship(Player *player, guint32 amount, 
                                       Player::DiplomaticState state);

        //! Propose a new diplomatic state wrt another player
        void proposeDiplomacy (DiplomaticProposal proposal, Player *player);




        // Signals

        /**
         * @param city   The city being invaded.
         * @param loot   The gold looted.
         */
        //! Emitted when the player defeats a City.
        sigc::signal<void, City*, int> sinvadingCity;

        /**
         * @param hero   The new hero that is emerging.
         * @param city   The city in which the hero is emerging.
         * @param gold   The amount of gold pieces the hero costs.
         *
         * @return True if we're accepting a hero, false if not.
         */
        //! Emitted whenever a hero is recruited.
        sigc::signal<bool, HeroProto*, City *, int> srecruitingHero;

        /**
         * @param army   The army that has gained a level.
         *
         * @return One of Army::Stat::STRENGTH, Army::Stat::MOVES, or 
         *         Army::Stat::SIGHT.
         */
        //! Emitted when an Army advances a level; returns stat to raise.
        sigc::signal<Army::Stat, Hero*> sheroGainsLevel;

        /**
         * @param army   The army that has gotten a medal.
         */
        //! Emitted whever a player's army gets a new medal.
        sigc::signal<void, Army*, int> snewMedalArmy;

        /**
         * @param army         The army that has died.
         * @param culprit_ids  A std::vector of enemy Army Ids to have 
         *                     participated in the death of this player's Army.
         */
        //! Emitted when a player's Army dies.
        sigc::signal<void, Army*, std::vector<guint32> > sdyingArmy;

        /**
         * @param ruin    The ruin being searched.
         * @param stack   The stack doing the searching (must contain Hero).
         * @param reward  The reward received.
         */
        //! Emitted whenever the player successfully searched a ruin.
        sigc::signal<void, Ruin*, Stack*> ssearchingRuin;

        /**
         * @param temple  The temple being visited.
         * @param stack   The stack that has gotten blessed.
         */
        //! Emitted whenever the player visits a temple.
        sigc::signal<void, Temple*, Stack*> svisitingTemple;

        /**
         * @param city   The city being occupied.
         * @param stack  The stack doing the occupying.
         */
        //! Emitted when the player occupies a City.
        sigc::signal<void, City*, Stack*> soccupyingCity;

        /**
         * @param city        The city that has been pillaged.
         * @param stack       The stack doing the pillaging.
         * @param gold        The amount of gold pieces pillaged.
         * @param army_types  The list of Army types traded-in for gold pieces.
         */
        //! Emitted whenever the player pillages a city.
        sigc::signal<void, City*, Stack*, int, guint32> spillagingCity;

        /**
         * @param city        The city that has been sacked.
         * @param stack       The stack doing the sacked.
         * @param gold        The amount of gold pieces sacked.
         * @param army_types  The list of Army types traded-in for gold pieces.
         */
        //! Emitted whenever the player sacks a city.
        sigc::signal<void, City*, Stack*, int, std::list<guint32> > ssackingCity;

        /**
         * @param city        The city that has been razed.
         * @param stack       The razing stack.
         */
        //! Emitted whenever the player razes a city.
        sigc::signal<void, City*, Stack*> srazingCity;

        /**
         * Emitted when the player's treasury has been changed.
         */
        //! Emitted whenever a player's stats changes.
        sigc::signal<void> schangingStats;

        //! Emitted whenever a computer player does something of note.
        sigc::signal<void, std::string> schangingStatus;

        //! Emitted whenever any player does anything at all.
        sigc::signal<void> sbusy;

        /**
         * Emitted when the player's stack moves, is disbanded, gets blessed,
         * searches a ruin, or is otherwise altered.
         *
         * @param stack    The stack that has been altered.
         */
        //! Emitted whenever the stack's status has changed.
        sigc::signal<void, Stack*> supdatingStack;

        //! Emitted whenever the active stack comes to a stop.
        sigc::signal<void, Stack*> shaltedStack;

        /**
         * Emitted whenever a city is conquered or razed.
         *
         * @param city     The city that has been altered.
         */
        //! Emitted whenever the status of a city has changed.
        sigc::signal<void, City*> supdatingCity;

        /**
         * @param fight  The details of the upcoming fight.
         */
        //! Emitted when a fight has started against a city or stack.
        sigc::signal<void, Fight &> fight_started;

        /**
         * @param city     The city we attacked.
         * @param result   If we won or not.
         */
        //! Emitted after we attack a city.
        sigc::signal<void, City *, Fight::Result> cityfight_finished;
        
        /**
         * @param attacker The player's attacking stack.
         * @param keeper   The keeper of the ruin.
         */
        //! Emitted when a fight in a ruin is started.
        sigc::signal<void, Stack *, Stack *> ruinfight_started;

        /**
         * @param result   If we defeated the ruin's keeper or not.
         */
        //! Emitted when a fight in a ruin has finished.
        sigc::signal<void, Fight::Result> ruinfight_finished;

        /**
         * @param chance   The percent chance that we will prevail in battle.
         */
        //! Emitted when a player asks for help from a military advisor.
        sigc::signal<void, float> advice_asked;

        //! Signal raised when a stack is considering an act of treachery.
        sigc::signal<bool, Stack *, Player *, Vector<int> > streacheryStack;

        //! Signal raised when a human player is deciding.
        sigc::signal<bool, Stack *, Player *, Vector<int> > streachery;

        //! Player would like to end the turn.
        sigc::signal<void> ending_turn;

        //! Player has confirmed to abort the turn.
        sigc::signal<void> aborted_turn;

        sigc::signal<void, int> hero_arrives_with_allies;

        sigc::signal<void, NetworkAction *> acting;
        sigc::signal<void, NetworkHistory *> history_written;
        
        void loadPbmGame();
        //! Check the history to see if we ever conquered the given city.


        Stack *stackSplitArmy(Stack *stack, Army *a);
        Stack *stackSplitArmies(Stack *stack, std::list<guint32> armies);
        Stack *stackSplitArmies(Stack *stack, std::list<Army*> armies);
        
        // Static Methods

        static std::string playerTypeToString(const Player::Type type);
        static Player::Type playerTypeFromString(const std::string str);
        //! is it safe to vector from the given city?
        static bool safeFromAttack(City *c, guint32 safe_mp, guint32 min_defenders);
        /** 
         * Make a new player with the given parameters.
         * 
         * @note The neutral player must still be inserted as neutral player
         * manually!
         *
         * @param name     The name of the player.
         * @param armyset  The Id of the player's Armyset.
         * @param color    The player's colour.
         * @param width    The width of the player's FogMap.
         * @param height   The height of the player's FogMap.
         * @param type     The player's type (Player::Type).
         */
        //! Create a player.
        static Player* create(std::string name, guint32 armyset, 
                              Gdk::Color color, int width, int height, 
                              Type type);
        
        /** 
         * Copies a player to a different type.
         * 
         * @note This method does not change ownerships! (e.g. of cities)
         *
         * @param player   The original player.
         * @param type     The type we want to get out (Player::Type).
         * @return A new player with the old player's data and the given type.
         */
        //! Create a new player from another player.
        static Player* create(Player* orig, Type type);

        /** 
         * Loads a player from a file.
         *
         * This is a bit inconsistent with other classes, but with players you
         * have the problem that there are different types with different
         * classes. So we need a static member function which looks which
         * player type to load and calls the constructor of the appropriate
         * class.
         *
         * @param helper       the opened saved-game file to read from.
         *
         * @return The loaded Player instance.
         */
        static Player* loadPlayer(XML_Helper* helper);

    

    protected:
        // do some fight cleaning up, setting
        void cleanupAfterFight(std::list<Stack*> &attackers,
                               std::list<Stack*> &defenders);
        
        //! Move stack s one step forward on it's Path.
        bool stackMoveOneStep(Stack* s);

        //! Move stack s one step forward on it's Path, over another stack.
        bool stackMoveOneStepOverTooLargeFriendlyStacks(Stack *s);

        void addAction(Action *action);

        // DATA
        //! The player's colour.
        /**
         * Mask portions of images are shaded in this colour.
         */
        Gdk::Color d_color;

        //! The name of the Player.
        std::string d_name;

        //! The ArmySet of the Player.
        guint32 d_armyset;

        //! The number of gold pieces the Player has in the treasury.
        int d_gold;

        //! Whether or not this player is dead.
        bool d_dead;

        //! Whether or not this player can be killed.
        bool d_immortal;

        //! The kind of Player (see Player::Type).
        guint32 d_type;

        //! A unique numeric identifier identifying this Player.
        guint32 d_id;

        //! A list of actions that this Player made this turn.
        std::list<Action*> d_actions;

        //! A list of "headlines" for this Player for the whole game.
        std::list<History*> d_history;

        //! A list of the Player's Stack objects.
        Stacklist* d_stacklist;

        //! What the player can see on the hidden map.
        FogMap* d_fogmap;

        //! A tally of the kills that this player has made
        Triumphs* d_triumphs;

        //! The order in which this Player's army types fight in battle.
        /**
         * @note This value is related to the Player's ArmySet.
         */
        std::list<guint32> d_fight_order; 

        //! How many gold pieces the Player paid out in the last turn.
        guint32 d_upkeep;

        //! How many gold pieces the Player made from taxes in the last turn.
        guint32 d_income;

        //! The diplomatic view that this Player has of each other Player.
        DiplomaticState d_diplomatic_state[MAX_PLAYERS];

        //! The diplomatic rank this Player has among all other Players.
        guint32 d_diplomatic_rank;

        //! The title that goes along with the diplomatic rank.
        std::string d_diplomatic_title;

        //! The proposals that this Player is making this turn.
        DiplomaticProposal d_diplomatic_proposal[MAX_PLAYERS];

        //! A quantification of how much this Player likes every other Player.
        guint32 d_diplomatic_score[MAX_PLAYERS];

        //! Whether or not this player is observable by the user.
        bool d_observable;

        //! Whether or not this player has surrendered.
        bool surrendered;

        //! Whether or not someone has closed the main game window.
        bool abort_requested;

        //! assists in scorekeeping for diplomacy
        void alterDiplomaticRelationshipScore (Player *player, int amount);

        void conquerCity(City *city, Stack *stack);

        // return the new stack if split succeeded
        Stack *doStackSplit(Stack *s);
        bool doStackSplitArmy(Stack *s, Army *a, Stack *& new_stack);
        void doStackJoin(Stack* receiver, Stack* joining);
        int doStackVisitTemple(Stack *s, Temple *t);
        void doCityOccupy(City *c);
        void doCityPillage(City *c, int& gold, int* pillaged_army_type);
        void doCitySack(City *c, int& gold, std::list<guint32> *sacked_types);
        void doCityRaze(City *c);
        void doCityBuyProduction(City *c, int slot, int type);
        void doCityChangeProduction(City *c, int slot);
        void doGiveReward(Stack *s, Reward *reward);
        void doHeroDropItem(Hero *hero, Item *item, Vector<int> pos);
        bool doHeroDropAllItems(Hero *h, Vector<int> pos);
        void doHeroPickupItem(Hero *hero, Item *item, Vector<int> pos);
        void doHeroGainsLevel(Hero *hero, Army::Stat stat);
        bool doStackDisband(Stack *stack);
        void doSignpostChange(Signpost *signpost, std::string message);
        void doCityRename(City *c, std::string name);
        void doVectorFromCity(City * c, Vector<int> dest);
        void doSetFightOrder(std::list<guint32> order);
        void doResign();
        void doHeroPlantStandard(Hero *hero, Item *item, Vector<int> pos);
        void doDeclareDiplomacy (DiplomaticState state, Player *player);
        void doProposeDiplomacy (DiplomaticProposal proposal, Player *player);
        void doConquerCity(City *city, Stack *stack);
        void doLootCity(Player *looted, guint32 added, guint32 subtracted);
        Hero* doRecruitHero(HeroProto* hero, City *city, int cost, int alliesCount, const ArmyProto *ally);
        void doRename(std::string name);
        void doKill();
        const Army *doCityProducesArmy(City *city, Vector<int> &pos);
        Army *doVectoredUnitArrives(VectoredUnit *unit);
        bool doChangeVectorDestination(Vector<int> src, Vector<int> dest,
                                       std::list<City*> &vectored);

        bool doStackSplitArmies(Stack *stack, std::list<guint32> armies,
                                Stack *&new_stack);

        Quest* doHeroGetQuest(Hero *hero, Temple* t, bool except_raze);

        void AI_maybeBuyScout(City *c);


        bool AI_maybePickUpItems (Stack *s, int dist, int mp, bool &picked_up,
                                  bool &stack_died);



        bool AI_maybeVector(City *c, guint32 safe_mp, guint32 min_defenders,
                            City *target, City **vector_city = NULL);


        void AI_setupVectoring(guint32 safe_mp, guint32 min_defenders,
                               guint32 mp_to_front);

        bool AI_maybeDisband(Stack *s, City *city, guint32 min_defenders, 
                             int safe_mp, bool &stack_killed);
        bool AI_maybeDisband(Stack *s, int safe_mp, bool &stack_killed);

        void pruneActionlist();
        static void pruneActionlist(std::list<Action*> actions);
        std::list<History*> getHistoryForThisTurn() const;
            
    private:
        //! Loads the subdata of a player (actions and stacklist)
        bool load(std::string tag, XML_Helper* helper);

        /**
         * Returns all heroes in the given list of stacks.
         *
         * @param stacks           the list of stacks which is searched.
         * @param heroes           Return a list of id's of the heroes found.
         */
        //! Get heroes.
        void getHeroes(const std::list<Stack*> stacks, 
                       std::vector<guint32>& heroes);

        /** 
         * Goes through a list of stacks and removes all armies with less
         * than 1 hitpoint.  It also removes empty stacks. 
         * This function also heals regenerating units at the end of combat. 
         *
         * @param stacks           The list searched for dead armies.
         * @param culprits         The list of heroes responsible for killing
         *                         the armies.  This is needed for tracking
         *                         the progress of a Quest.
         * @return The sum of the XP of the killed armies.
         */
        //! Remove dead Armies from a list of stacks after a fight.
        double removeDeadArmies(std::list<Stack*>& stacks,
                                std::vector<guint32>& culprits);
        
        /** 
         * Increases the number of experience points of a stack
         * the number of battles and checks if an army can get a medal
         *
         * This functions takes a number of experience points and distributes
         * them equally over all armies in the stack list. Therefore, the less
         * armies fight, the more experience the single armies get. It emits a
         * signal when a unit gains a level.
         *
         * @param stacks           A list of all stacks gaining experience.
         * @param xp_sum           The number of XP to distribute.
         */
        //! update Army state after a Fight.
        void updateArmyValues(std::list<Stack*>& stacks, double xp_sum);


        /** 
         * Called to move a Stack to a specified position.
         *
         * The Path is calculated on the fly unless follow is set to true. 
         * In this case, an existing path is checked and iterated over.  
         * This is useful if a stack didn't reach its target within one 
         * round and should continue the movement.
         *
         * This callback must result in an Action_Move element being 
         * given to the addAction method.
         *
         * @param s                The stack to be moved.
         * @param dest             The destination of the move.
         * @param follow           If set to false, calculate the path.
         *
         * @return False on error, true otherwise.
         */
        //! Callback to move a stack on the map.
        MoveResult *stackMove(Stack* s, Vector<int> dest, bool follow);

        bool nextStepOnEnemyStackOrCity(Stack *s) const;

        void lootCity(City *city, Player *looted);
        void calculateLoot(Player *looted, guint32 &added, guint32 &subtracted);
        void takeCityInPossession(City* c);
        static void pruneCityVectorings(std::list<Action*> actions);
        static void pruneCityProductions(std::list<Action*> actions);

        std::list<Action *> getActionsThisTurn(int type) const;
};

#endif // PLAYER_H

// End of file