src/type.hh

   1 /*
   2  * This file includes the base class definition for types.
   3  * An entity's conduct is very precisely defined by its assigned type.
   4  *
   5  * Copyright (C) 2008 Hermann Walth
   6  *
   7  * This file is part of OpenStranded
   8  *
   9  * OpenStranded is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation, either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * OpenStranded is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with OpenStranded. If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #ifndef STRANDED_TYPE_HH
  24 #define STRANDED_TYPE_HH
  25
  26 #include <string>
  27
  28 typedef unsigned int ID;
  29
  30
  31 /**
  32  * Types are the prototypes of the single entities.
  33  * There is one type class per kingdom.
  34  * The single type instances include the information about the types
  35  * as read from the definition files.
  36  */
  37 class Type
  38 {
  39         protected:
  40                 std::string name;
  41                 float scaleX, scaleY, scaleZ;
  42                 uint8_t colorR, colorG, colorB;
  43                 std::string model;
  44                 std::string iconPath;
  45                 float fadingDistance;
  46                 float alpha;
  47                 float shine;
  48
  49         public:
  50
  51                 /**
  52                  * The constructor.
  53                  * @param name The name of this type (used only in editor)
  54                  */
  55                 Type (const char *name);
  56
  57                 /**
  58                  * The destructor.
  59                  */
  60                 virtual
  61                 ~Type () {};
  62
  63
  64
  65                 //
  66                 // Name
  67                 //
  68                 /**
  69                  * Set the type name.
  70                  * @param name The new name of the type
  71                  */
  72                 inline void
  73                 setName (const std::string &name) { this->name = name; }
  74
  75                 /**
  76                  * Get the type name.
  77                  * @return The current name of the type
  78                  */
  79                 inline std::string
  80                 getName () { return this->name; }
  81
  82
  83
  84                 //
  85                 // Model path
  86                 //
  87
  88                 /**
  89                  * Set the model.
  90                  * The model is specified by the path to the model file.
  91                  * @param path Path to the new model file
  92                  */
  93                 inline void
  94                 setModel (const std::string &path) { this->model = path; }
  95
  96                 /**
  97                  * Return the path to the current model.
  98                  * @return Path of the current model file
  99                  */
 100                 inline std::string
 101                 getModel () { return this->model; }
 102
 103
 104
 105                 //
 106                 // Icon path
 107                 //
 108
 109                 /**
 110                  * Set the path to the icon used.
 111                  * The icon is the little thumbnail in the editor.
 112                  * @param path Path to the new icon file
 113                  */
 114                 inline void
 115                 setIconPath (const std::string &path) { this->iconPath = path; }
 116
 117                 /**
 118                  * Return the current icon path.
 119                  * @return The path to the current icon file
 120                  */
 121                 inline std::string
 122                 getIconPath () { return this->iconPath; }
 123
 124
 125
 126                 //
 127                 // Scaling values
 128                 //
 129
 130                 /**
 131                  * Set the X scaling value.
 132                  * The scaling values are divided into their coordinate
 133                  * components.
 134                  * @param scaleX The new X scaling value
 135                  */
 136                 inline void
 137                 setScaleX (const float scaleX) { this->scaleX = scaleX; }
 138
 139                 /**
 140                  * Get the X scaling value.
 141                  * @return The current X scaling value
 142                  */
 143                 inline float
 144                 getScaleX () { return this->scaleX; }
 145
 146                 /**
 147                  * Set the Y scaling value.
 148                  * @param scaleY The new Y scaling value
 149                  */
 150                 inline void
 151                 setScaleY (const float scaleY) { this->scaleY = scaleY; }
 152
 153                 /**
 154                  * Get the Y scaling value.
 155                  * @return The current Y scaling value
 156                  */
 157                 inline float
 158                 getScaleY () { return this->scaleY; }
 159
 160                 /**
 161                  * Set the Z scaling value.
 162                  * @param scaleZ The new Z scaling value
 163                  */
 164                 inline void
 165                 setScaleZ (const float scaleZ) { this->scaleZ = scaleZ; }
 166
 167                 /**
 168                  * Get the Z scaling value.
 169                  * @return The current Z scaling value
 170                  */
 171                 inline float
 172                 getScaleZ () { return this->scaleZ; }
 173
 174
 175
 176                 //
 177                 // Color values
 178                 //
 179
 180                 /**
 181                  * Set the red value.
 182                  * @param colorR The new red value ranging from 0 to 255
 183                  */
 184                 inline void
 185                 setColorR (const uint8_t colorR) { this->colorR = colorR; }
 186
 187                 /**
 188                  * Get the red value.
 189                  * @return The current red value ranging from 0 to 255
 190                  */
 191                 inline uint8_t
 192                 getColorR () { return this->colorR; }
 193
 194                 /**
 195                  * Set the green value.
 196                  * @param colorG The new green value ranging from 0 to 255
 197                  */
 198                 inline void
 199                 setColorG (const uint8_t colorG) { this->colorG = colorG; }
 200
 201                 /**
 202                  * Get the green value
 203                  * @return The current green value ranging from 0 to 255
 204                  */
 205                 inline uint8_t
 206                 getColorG () { return this->colorG; }
 207
 208                 /**
 209                  * Set the blue value
 210                  * @param colorB The new blue value ranging from 0 to 255
 211                  */
 212                 inline void
 213                 setColorB (const uint8_t colorB) { this->colorB = colorB; }
 214
 215                 /**
 216                  * Get the blue value
 217                  * @return The current blue value ranging from 0 to 255
 218                  */
 219                 inline uint8_t
 220                 getColorB () { return this->colorB; }
 221
 222
 223
 224                 //
 225                 // Autofading
 226                 //
 227
 228                 /**
 229                  * Set the Autofading distance.
 230                  * This is the distance to the player when an object fades out of sight
 231                  * @param fadingDistance The new Autofading distance
 232                  */
 233                 inline void
 234                 setFadingDistance (const float fadingDistance) { this->fadingDistance = fadingDistance; }
 235
 236                 /**
 237                  * Get the Autofading distance
 238                  * @return The current Autofading distance
 239                  */
 240                 inline float
 241                 getFadingDistance () { return this->fadingDistance; }
 242
 243
 244
 245                 //
 246                 // Alpha
 247                 //
 248
 249                 /**
 250                  * Set the value of transparency (aka alpha channel).
 251                  * @param alpha The new alpha value ranging from 0.0 (invisible) to 1.0 (opaque)
 252                  */
 253                 inline void
 254                 setAlpha (const float alpha) { this->alpha = alpha; }
 255
 256                 /**
 257                  * Returns the transparency value.
 258                  * @return The current alpha value
 259                  */
 260                 inline float
 261                 getAlpha () { return this->alpha; }
 262
 263
 264
 265                 //
 266                 // Shine effect
 267                 //
 268
 269                 /**
 270                  * Set the shine value of the model
 271                  * @param shine The new shine value
 272                  */
 273                 inline void
 274                 setShine (const float shine) { this->shine = shine; }
 275
 276                 /**
 277                  * Get the shine value of the model
 278                  * @return The current shine value
 279                  */
 280                 inline float
 281                 getShine () { return this->shine; }
 282 };
 283
 284 #endif /* STRANDED_TYPE_HH */