git.maemo.org Git - lordsawar/blob - src/QuestsManager.h

   1 // Copyright (C) 2003, 2005 Ulf Lorenz
   2 // Copyright (C) 2004 Andrea Paternesi
   3 // Copyright (C) 2007, 2008, 2009 Ben Asselstine
   4 // Copyright (C) 2007, 2008 Ole Laursen
   5 //
   6 //  This program is free software; you can redistribute it and/or modify
   7 //  it under the terms of the GNU General Public License as published by
   8 //  the Free Software Foundation; either version 3 of the License, or
   9 //  (at your option) any later version.
  10 //
  11 //  This program is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //  GNU Library General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU General Public License
  17 //  along with this program; if not, write to the Free Software
  18 //  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 //  02110-1301, USA.
  20
  21 #ifndef QUEST_MANAGER_H
  22 #define QUEST_MANAGER_H
  23
  24 #include <queue>
  25 #include <map>
  26 #include <vector>
  27 #include <sigc++/trackable.h>
  28 #include <sigc++/signal.h>
  29 #include "callback-enums.h"
  30
  31 #include "player.h"
  32 #include "hero.h"
  33
  34 class Quest;
  35 class XML_Helper;
  36 class Army;
  37 class Reward;
  38
  39
  40 //! Manages Quest objects.
  41 /**
  42  * This class creates new quests and assigns them to heroes.  It also keeps
  43  * track of pending quests and invalidates quests due to Hero death.  It
  44  * acts as a central place to catch army death events, and city conquered
  45  * events, and it passes these events on to the Quest objects it manages.
  46  *
  47  * This object equates to the lordsawar.questlist XML entity in the saved-game
  48  * file.
  49  *
  50  * This class is implemented as a singleton.
  51  *
  52  */
  53 class QuestsManager : public sigc::trackable
  54 {
  55     public:
  56
  57         //! The xml tag of this object in a saved-game file.
  58         static std::string d_tag;
  59
  60         // Methods that operate on the class data and modify it.
  61
  62         //! Create a new quest for the given hero.
  63         /**
  64          * Check and see which quests are possible and give the specified hero
  65          * a random quest.
  66          *
  67          * @param heroId  The Id of the Hero object to be responsible for the
  68          *                new Quest.
  69          * @param razing_possible  Whether or not razing cities is allowed in
  70          *                         the scenario.  If this is set to true, the
  71          *                         quests that involve razing will be
  72          *                         considered.  Otherwise a razing quest will
  73          *                         not be considered at all, and not returned.
  74          *
  75          * @return A pointer to the new Quest object.
  76          */
  77         Quest* createNewQuest(guint32 heroId, bool razing_possible);
  78
  79         //! Create new kill hero quest from remote action.
  80         Quest* createNewKillHeroQuest(guint32 heroId, guint32 targetHeroId);
  81
  82         //! Create new enemy armies quest from remote action.
  83         Quest* createNewEnemyArmiesQuest(guint32 heroId, guint32 num_armies,
  84                                          guint32 victim_player_id);
  85
  86         //! Create new city sacking quest from remote action.
  87         Quest* createNewCitySackQuest(guint32 heroId, guint32 cityId);
  88
  89         //! Create new city razing quest from remote action.
  90         Quest* createNewCityRazeQuest(guint32 heroId, guint32 cityId);
  91
  92         //! Create new city occupation quest from remote action.
  93         Quest* createNewCityOccupyQuest(guint32 heroId, guint32 cityId);
  94
  95         //! Create new kill enemy army type quest from remote action.
  96         Quest* createNewEnemyArmytypeQuest(guint32 heroId, guint32 armyTypeId);
  97
  98         //! Create new pillage gold quest from remote action.
  99         Quest* createNewPillageGoldQuest(guint32 heroId, guint32 amount);
 100
 101         //! Mark the Quest that the given Hero object is on to be completed.
 102         /**
 103          *  This method deactivates the quest and saves the completion
 104          *  notification message which will be presented to the player.
 105          *
 106          *  @param heroId  The id of the Hero object who has a Quest that we
 107          *                 want to mark as complete.
 108          */
 109         void questCompleted(guint32 heroId);
 110
 111         //! Mark the Quest that the given Hero object is on to be expired.
 112         /**
 113          *  This method deactivates the quest and saves the expiry notification
 114          *  message which will be presented to the player.
 115          *
 116          *  @param heroId  The id of the Hero object who has a Quest that we
 117          *                 want to mark as expired.
 118          */
 119         void questExpired(guint32 heroId);
 120
 121         //! Callback when an Army object is killed.
 122         /**
 123          *  Here we account for a dead army.   maybe it's our hero,
 124          *  maybe it's a target hero, maybe we're somebody else's target hero
 125          *  or maybe we're some other army we're supposed to kill.
 126          *
 127          *  @param army      The army who was killed.
 128          *  @param culprits  The list of Army object Ids that were involved in
 129          *                   killing the given army.
 130          */
 131         void armyDied(Army *army, std::vector<guint32>& culprits);
 132
 133         //! Callback when a city is razed.
 134         /**
 135          * Other classes call this to trigger this razing event.  Derived
 136          * classes of Quest catch this event via the Quest::cityAction
 137          * callback.
 138          *
 139          * @param city   A pointer to the City object being razed.
 140          * @param stack  A pointer to the stack that conquered and is razing
 141          *               the given city.
 142          */
 143         void cityRazed(City *city, Stack *stack);
 144
 145         //! Callback when a city is sacked.
 146         /**
 147          * Other classes call this to trigger this sacking event.  Derived
 148          * classes of Quest catch this event via the Quest::cityAction
 149          * callback.
 150          *
 151          * @param city   A pointer to the City object being sacked.
 152          * @param stack  A pointer to the stack that conquered and is sacking
 153          *               the given city.
 154          * @param gold   The number of gold pieces that the sacking resulted in.
 155          */
 156         void citySacked(City *city, Stack *stack, int gold);
 157
 158         //! Callback when a city is pillaged.
 159         /**
 160          * Other classes call this to trigger this pillaging event.  Derived
 161          * classes of Quest catch this event via the Quest::cityAction
 162          * callback.
 163          *
 164          * @param city   A pointer to the City object being pillaged.
 165          * @param stack  A pointer to the stack that conquered and is pillaging
 166          *               the given city.
 167          * @param gold   The number of gold pieces that the pillaging resulted
 168          *               in.
 169          */
 170         void cityPillaged(City *city, Stack *stack, int gold);
 171
 172         //! Callback when a city is occupied.
 173         /**
 174          * Other classes call this to trigger this occupying event.  Derived
 175          * classes of Quest catch this event via the Quest::cityAction
 176          * callback.
 177          *
 178          * @param city   A pointer to the City object being occupied.
 179          * @param stack  A pointer to the stack that conquered and is occupying
 180          *               the given city.
 181          */
 182         void cityOccupied(City *city, Stack *stack);
 183
 184         //! Process the Quests at the start of every turn for the given player.
 185         /**
 186          * @param player  The player to process Quest objects for.  The Hero
 187          *                object must be owned by this player to be processed.
 188          */
 189         void nextTurn(Player *player);
 190
 191
 192         // Methods that operate on the class data and do not modify it.
 193
 194         //! Return a list of active Quest objects that belong to the player.
 195         /**
 196          * @param player  The player to get active Quest objects for.
 197          */
 198         std::vector<Quest*> getPlayerQuests(const Player *player) const;
 199
 200         Quest* getHeroQuest(guint32 hero_id) const;
 201
 202         //! Save the quests to an opened saved-game file.
 203         /**
 204          * Saves the lordsawar.questlist XML entity to the saved-game file.
 205          *
 206          * @param helper  The opened saved-game file to save the Quest objects
 207          *                to.
 208          */
 209         bool save(XML_Helper* helper) const;
 210
 211
 212         // Signals
 213
 214         //! Emitted when a Hero object completes a Quest.
 215         /**
 216          * @param quest   A pointer to the Quest object that was successfully
 217          *                completed.
 218          * @param reward  A pointer to the reward that the Hero is receiving.
 219          */
 220         sigc::signal<void, Quest *, Reward *> quest_completed;
 221
 222         //! Emitted when a Hero object fails to complete a Quest.
 223         /**
 224          * @param quest  A pointer to the Ques tobject that was expired.
 225          */
 226         sigc::signal<void, Quest *> quest_expired;
 227
 228
 229         // Static Methods
 230
 231         //! Gets the singleton instance or creates a new one.
 232         static QuestsManager* getInstance();
 233
 234         /**
 235          * Make a new QuestsManager object by loading all Quest objects from
 236          * an opened saved-game file.
 237          *
 238          * @param helper     The opened saved-game file to read from.
 239          *
 240          * @return A pointer to the new QuestsManager object.
 241          */
 242         //! Loads the questlist from a saved-game file.
 243         static QuestsManager* getInstance(XML_Helper* helper);
 244
 245         //! Explicitly deletes the singleton instance.
 246         static void deleteInstance();
 247
 248     protected:
 249
 250         //! Default constructor.
 251         QuestsManager();
 252
 253         //! Loading constructor.
 254         /**
 255          * Loads the lordsawar.questlist XML entity from the saved-game file.
 256          *
 257          * @param helper  The opened saved-game file to load the questlist from.
 258          */
 259         QuestsManager(XML_Helper* helper);
 260
 261         //! Destructor.
 262         ~QuestsManager();
 263
 264     private:
 265
 266         //! Definition of a function pointer for the Quest::isFeasible methods.
 267         typedef bool (*QFeasibilityType)(guint32);
 268
 269         //! Callback for loading Quest objects into the QuestsManager.
 270         bool load(std::string tag, XML_Helper* helper);
 271
 272         //! Does some setup that has to be done on loading as well as creation.
 273         void sharedInit();
 274
 275         //! Deactivates a given quest, i.e. marks it as 'to-delete'.
 276         /**
 277          * @note A Hero can only have one quest, so giving the heroId is as
 278          *       good as specifying a particular quest.
 279          */
 280         void deactivateQuest(guint32 heroId);
 281
 282         //! This method performs cleanup of the marked quests
 283         /**
 284          * Remove the quests marked as deactivated, and have heroes that belong
 285          * to players of the given type.
 286          */
 287         void cleanup(Player::Type type = Player::HUMAN);
 288
 289         //! Callback when a city is conquered.
 290         /**
 291          * This method calls the other simlarly named methods in the derived
 292          * Quest classes.
 293          *
 294          * @param city   A pointer to the city that was defeated.
 295          * @param stack  A pointer to the stack doing the conquering.
 296          * @param action What action was taken: pillaging, sacking, razing, or
 297          *               occupying.
 298          * @param gold   The number of gold pieces achieved in the sacking or
 299          *               pillaging.
 300          */
 301         void cityAction(City *c, Stack *s, CityDefeatedAction action, int gold);
 302
 303         // DATA
 304
 305         //! A hash of all Quests in this QuestsManager.  Lookup by HeroId.
 306         std::map<guint32,Quest*> d_quests;
 307
 308         //! A list of quests that have been marked as 'to-delete'.
 309         std::list<Quest*> d_inactive_quests;
 310
 311         //! A vector of isFeasible function pointers.
 312         /**
 313          * This list of function pointers is used to see if it makes sense to
 314          * give out a quest of a particular kind (Quest::Type).
 315          */
 316         std::vector<QFeasibilityType> d_questsFeasible;
 317
 318         //! A static pointer for the singleton instance.
 319         static QuestsManager * s_instance;
 320 };
 321
 322 #endif