src/kingdom.hh

   1 /*
   2  * This file includes the base class definition for entity kingdoms.
   3  * Kingdoms group entities roughly by their most basic similiarities.
   4  * The name 'Kingdom' is derived from the biological term.
   5  *
   6  * Copyright (C) 2008 Hermann Walth
   7  *
   8  * This file is part of OpenStranded
   9  *
  10  * OpenStranded is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation, either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * OpenStranded is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with OpenStranded. If not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 #ifndef STRANDED_KINGDOM_HH
  25 #define STRANDED_KINGDOM_HH
  26
  27 #include <string>
  28 #include <map>
  29 #include "entity.hh"
  30 #include "type.hh"
  31
  32 class Kingdom;
  33
  34 typedef unsigned int ID;
  35
  36
  37 /**
  38  * This is a base class for all kingdoms.
  39  * Originally implemented kingdoms were, roughly summarized, the following:
  40  *      Units as the only mobile and intelligent (or controllable) entities,
  41  *      Items as storable tools or resources,
  42  *      Objects as immobile structures, flora, rocks or similiar, and
  43  *      Infos as meta-information for technical purposes
  44  * The OpenStranded Kingdom system is, however, designed to make it possible
  45  * to implement new kingdoms at will.
  46  */
  47 class Kingdom
  48 {
  49         private:
  50                 std::string name;
  51
  52                 /*
  53                  * Kingdoms manage all their entities and types
  54                  * with pointers in local lists (STL Maps)
  55                  * where they are mapped to certain IDs.
  56                  * Using pointers may not be optimal OOP,
  57                  * but other methods aren't as efficient here.
  58                  */
  59                 std::map <ID, Entity*> entityList;
  60                 std::map <ID, Type*> typeList;
  61
  62                 ID highestEntityID;
  63
  64         public:
  65                 /**
  66                  * The constructor.
  67                  * @param name The name of the kingdom
  68                  */
  69                 Kingdom (const char *name);
  70
  71                 /**
  72                  * The destructor.
  73                  * Entities and Types are most likely to be allocated on the heap,
  74                  * so this destructor is used to free them again
  75                  */
  76                 virtual
  77                 ~Kingdom ();
  78
  79                 /**
  80                  * Looks up a certain entity from the kingdom's list by its ID.
  81                  * @param index The ID of the desired entity
  82                  * @return A pointer to the entity, NULL if none is found
  83                  */
  84                 Entity*
  85                 getEntity (ID index);
  86
  87                 /**
  88                  * Looks up a certain type from the kingdom's list by its ID
  89                  * @param index The ID of the desired type
  90                  * @return A pointer to the type, NULL if none is found
  91                  */
  92                 Type*
  93                 getType (ID index);
  94
  95                 /**
  96                  * Checks whether an entity with a certain ID exists
  97                  * @param entity ID of the entity
  98                  * @return true if the entity exists, false if not
  99                  */
 100                 bool
 101                 entityExists (ID entity);
 102
 103                 /**
 104                  * Checks whether a type with a certain ID exists
 105                  * @param type ID of the type
 106                  * @return true if the type exists, false if not
 107                  */
 108                 bool
 109                 typeExists (ID type);
 110
 111                 /**
 112                  * Append an entity to the list.
 113                  * This method automatically assigns an ID which is by
 114                  * one higher than the currently highest entity ID
 115                  * @param type The ID of the type of the entity
 116                  * @return A pointer to the appended entity
 117                  */
 118                 Entity*
 119                 appendEntity (ID type);
 120
 121                 /**
 122                  * Insert an entity into a specific position of the list.
 123                  * This method assigns the specified ID to the entity.
 124                  * @param type The ID of the type of the entity
 125                  * @param entity The desired ID of the entity in the kingdom
 126                  * @return A pointer to the inserted entity
 127                  */
 128                 Entity*
 129                 insertEntity (ID type, ID entity);
 130
 131                 /**
 132                  * Insert a type.
 133                  * TypeIDs need to be certain and definite towards the outside,
 134                  * so there is only an insertType method defining a certain ID.
 135                  * @param name The name of the type
 136                  * @param type The desired ID of the type
 137                  * @return A pointer to the inserted type
 138                  */
 139                 Type*
 140                 insertType (const char* name, ID type);
 141
 142                 /**
 143                  * Insert a type without a name.
 144                  * @param type The desired ID of the type
 145                  * @return A pointer to the inserted type
 146                  */
 147                 Type*
 148                 insertType (ID type);
 149
 150                 /*
 151                  * These are some virtual functions used by other methods.
 152                  * They differ from kingdom to kingdom.
 153                  * Basically, they should just implement the
 154                  * entity's and type's constructors/destructors for this kingdom
 155                  */
 156
 157                 virtual Entity*
 158                 createEntity (ID type);
 159
 160                 virtual void
 161                 destroyEntity (Entity *entity);
 162
 163                 virtual Type*
 164                 createType (const char* name);
 165
 166                 virtual void
 167                 destroyType (Type *type);
 168
 169
 170
 171                 //
 172                 // Static class members
 173                 //
 174
 175                 static std::map <ID, Kingdom*> kingdomList;
 176
 177                 static void
 178                 initKingdomList (std::string mod = "Stranded II");
 179
 180                 static void
 181                 uninitKingdomList ();
 182
 183                 static void
 184                 parseEntityTypes(std::string mod, std::string name);
 185 };
 186
 187 #endif /* STRANDED_KINGDOM_HH */