src/newgrf_spritegroup.h

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD 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, version 2.
   6  * OpenTTD 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.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /** @file newgrf_spritegroup.h Action 2 handling. */
  11
  12 #ifndef NEWGRF_SPRITEGROUP_H
  13 #define NEWGRF_SPRITEGROUP_H
  14
  15 #include "town_type.h"
  16 #include "engine_type.h"
  17 #include "house_type.h"
  18
  19 #include "newgrf_callbacks.h"
  20 #include "newgrf_generic.h"
  21 #include "newgrf_storage.h"
  22 #include "newgrf_commons.h"
  23
  24 /**
  25  * Gets the value of a so-called newgrf "register".
  26  * @param i index of the register
  27  * @pre i < 0x110
  28  * @return the value of the register
  29  */
  30 static inline uint32 GetRegister(uint i)
  31 {
  32         extern TemporaryStorageArray<int32, 0x110> _temp_store;
  33         return _temp_store.GetValue(i);
  34 }
  35
  36 /**
  37  * Clears the value of a so-called newgrf "register".
  38  * @param i index of the register
  39  * @pre i < 0x110
  40  */
  41 static inline void ClearRegister(uint i)
  42 {
  43         extern TemporaryStorageArray<int32, 0x110> _temp_store;
  44         _temp_store.StoreValue(i, 0);
  45 }
  46
  47 /* List of different sprite group types */
  48 enum SpriteGroupType {
  49         SGT_REAL,
  50         SGT_DETERMINISTIC,
  51         SGT_RANDOMIZED,
  52         SGT_CALLBACK,
  53         SGT_RESULT,
  54         SGT_TILELAYOUT,
  55         SGT_INDUSTRY_PRODUCTION,
  56 };
  57
  58 struct SpriteGroup;
  59 typedef uint32 SpriteGroupID;
  60
  61 /* SPRITE_WIDTH is 24. ECS has roughly 30 sprite groups per real sprite.
  62  * Adding an 'extra' margin would be assuming 64 sprite groups per real
  63  * sprite. 64 = 2^6, so 2^30 should be enough (for now) */
  64 typedef Pool<SpriteGroup, SpriteGroupID, 1024, 1 << 30, PT_DATA> SpriteGroupPool;
  65 extern SpriteGroupPool _spritegroup_pool;
  66
  67 /* Common wrapper for all the different sprite group types */
  68 struct SpriteGroup : SpriteGroupPool::PoolItem<&_spritegroup_pool> {
  69 protected:
  70         SpriteGroup(SpriteGroupType type) : type(type) {}
  71         /** Base sprite group resolver */
  72         virtual const SpriteGroup *Resolve(struct ResolverObject *object) const { return this; };
  73
  74 public:
  75         virtual ~SpriteGroup() {}
  76
  77         SpriteGroupType type;
  78
  79         virtual SpriteID GetResult() const { return 0; }
  80         virtual byte GetNumResults() const { return 0; }
  81         virtual uint16 GetCallbackResult() const { return CALLBACK_FAILED; }
  82
  83         /**
  84          * ResolverObject (re)entry point.
  85          * This cannot be made a call to a virtual function because virtual functions
  86          * do not like NULL and checking for NULL *everywhere* is more cumbersome than
  87          * this little helper function.
  88          * @param group the group to resolve for
  89          * @param object information needed to resolve the group
  90          * @return the resolved group
  91          */
  92         static const SpriteGroup *Resolve(const SpriteGroup *group, ResolverObject *object)
  93         {
  94                 return group == NULL ? NULL : group->Resolve(object);
  95         }
  96 };
  97
  98
  99 /* 'Real' sprite groups contain a list of other result or callback sprite
 100  * groups. */
 101 struct RealSpriteGroup : SpriteGroup {
 102         RealSpriteGroup() : SpriteGroup(SGT_REAL) {}
 103         ~RealSpriteGroup();
 104
 105         /* Loaded = in motion, loading = not moving
 106          * Each group contains several spritesets, for various loading stages */
 107
 108         /* XXX: For stations the meaning is different - loaded is for stations
 109          * with small amount of cargo whilst loading is for stations with a lot
 110          * of da stuff. */
 111
 112         byte num_loaded;       ///< Number of loaded groups
 113         byte num_loading;      ///< Number of loading groups
 114         const SpriteGroup **loaded;  ///< List of loaded groups (can be SpriteIDs or Callback results)
 115         const SpriteGroup **loading; ///< List of loading groups (can be SpriteIDs or Callback results)
 116
 117 protected:
 118         const SpriteGroup *Resolve(ResolverObject *object) const;
 119 };
 120
 121 /* Shared by deterministic and random groups. */
 122 enum VarSpriteGroupScope {
 123         VSG_BEGIN,
 124
 125         VSG_SCOPE_SELF = VSG_BEGIN, ///< Resolved object itself
 126         VSG_SCOPE_PARENT,           ///< Related object of the resolved one
 127         VSG_SCOPE_RELATIVE,         ///< Relative position (vehicles only)
 128
 129         VSG_END
 130 };
 131 DECLARE_POSTFIX_INCREMENT(VarSpriteGroupScope)
 132
 133 enum DeterministicSpriteGroupSize {
 134         DSG_SIZE_BYTE,
 135         DSG_SIZE_WORD,
 136         DSG_SIZE_DWORD,
 137 };
 138
 139 enum DeterministicSpriteGroupAdjustType {
 140         DSGA_TYPE_NONE,
 141         DSGA_TYPE_DIV,
 142         DSGA_TYPE_MOD,
 143 };
 144
 145 enum DeterministicSpriteGroupAdjustOperation {
 146         DSGA_OP_ADD,  ///< a + b
 147         DSGA_OP_SUB,  ///< a - b
 148         DSGA_OP_SMIN, ///< (signed) min(a, b)
 149         DSGA_OP_SMAX, ///< (signed) max(a, b)
 150         DSGA_OP_UMIN, ///< (unsigned) min(a, b)
 151         DSGA_OP_UMAX, ///< (unsigned) max(a, b)
 152         DSGA_OP_SDIV, ///< (signed) a / b
 153         DSGA_OP_SMOD, ///< (signed) a % b
 154         DSGA_OP_UDIV, ///< (unsigned) a / b
 155         DSGA_OP_UMOD, ///< (unsigned) a & b
 156         DSGA_OP_MUL,  ///< a * b
 157         DSGA_OP_AND,  ///< a & b
 158         DSGA_OP_OR,   ///< a | b
 159         DSGA_OP_XOR,  ///< a ^ b
 160         DSGA_OP_STO,  ///< store a into temporary storage, indexed by b. return a
 161         DSGA_OP_RST,  ///< return b
 162         DSGA_OP_STOP, ///< store a into persistent storage, indexed by b, return a
 163         DSGA_OP_ROR,  ///< rotate a b positions to the right
 164         DSGA_OP_SCMP, ///< (signed) comparison (a < b -> 0, a == b = 1, a > b = 2)
 165         DSGA_OP_UCMP, ///< (unsigned) comparison (a < b -> 0, a == b = 1, a > b = 2)
 166         DSGA_OP_SHL,  ///< a << b
 167         DSGA_OP_SHR,  ///< (unsigned) a >> b
 168         DSGA_OP_SAR,  ///< (signed) a >> b
 169 };
 170
 171
 172 struct DeterministicSpriteGroupAdjust {
 173         DeterministicSpriteGroupAdjustOperation operation;
 174         DeterministicSpriteGroupAdjustType type;
 175         byte variable;
 176         byte parameter; ///< Used for variables between 0x60 and 0x7F inclusive.
 177         byte shift_num;
 178         uint32 and_mask;
 179         uint32 add_val;
 180         uint32 divmod_val;
 181         const SpriteGroup *subroutine;
 182 };
 183
 184
 185 struct DeterministicSpriteGroupRange {
 186         const SpriteGroup *group;
 187         uint32 low;
 188         uint32 high;
 189 };
 190
 191
 192 struct DeterministicSpriteGroup : SpriteGroup {
 193         DeterministicSpriteGroup() : SpriteGroup(SGT_DETERMINISTIC) {}
 194         ~DeterministicSpriteGroup();
 195
 196         VarSpriteGroupScope var_scope;
 197         DeterministicSpriteGroupSize size;
 198         uint num_adjusts;
 199         byte num_ranges;
 200         DeterministicSpriteGroupAdjust *adjusts;
 201         DeterministicSpriteGroupRange *ranges; // Dynamically allocated
 202
 203         /* Dynamically allocated, this is the sole owner */
 204         const SpriteGroup *default_group;
 205
 206 protected:
 207         const SpriteGroup *Resolve(ResolverObject *object) const;
 208 };
 209
 210 enum RandomizedSpriteGroupCompareMode {
 211         RSG_CMP_ANY,
 212         RSG_CMP_ALL,
 213 };
 214
 215 struct RandomizedSpriteGroup : SpriteGroup {
 216         RandomizedSpriteGroup() : SpriteGroup(SGT_RANDOMIZED) {}
 217         ~RandomizedSpriteGroup();
 218
 219         VarSpriteGroupScope var_scope;  ///< Take this object:
 220
 221         RandomizedSpriteGroupCompareMode cmp_mode; ///< Check for these triggers:
 222         byte triggers;
 223         byte count;
 224
 225         byte lowest_randbit; ///< Look for this in the per-object randomized bitmask:
 226         byte num_groups; ///< must be power of 2
 227
 228         const SpriteGroup **groups; ///< Take the group with appropriate index:
 229
 230 protected:
 231         const SpriteGroup *Resolve(ResolverObject *object) const;
 232 };
 233
 234
 235 /* This contains a callback result. A failed callback has a value of
 236  * CALLBACK_FAILED */
 237 struct CallbackResultSpriteGroup : SpriteGroup {
 238         /**
 239          * Creates a spritegroup representing a callback result
 240          * @param value The value that was used to represent this callback result
 241          * @param grf_version8 True, if we are dealing with a new NewGRF which uses GRF version >= 8.
 242          */
 243         CallbackResultSpriteGroup(uint16 value, bool grf_version8) :
 244                 SpriteGroup(SGT_CALLBACK),
 245                 result(value)
 246         {
 247                 /* Old style callback results (only valid for version < 8) have the highest byte 0xFF so signify it is a callback result.
 248                  * New style ones only have the highest bit set (allows 15-bit results, instead of just 8) */
 249                 if (!grf_version8 && (this->result >> 8) == 0xFF) {
 250                         this->result &= ~0xFF00;
 251                 } else {
 252                         this->result &= ~0x8000;
 253                 }
 254         }
 255
 256         uint16 result;
 257         uint16 GetCallbackResult() const { return this->result; }
 258 };
 259
 260
 261 /* A result sprite group returns the first SpriteID and the number of
 262  * sprites in the set */
 263 struct ResultSpriteGroup : SpriteGroup {
 264         /**
 265          * Creates a spritegroup representing a sprite number result.
 266          * @param sprite The sprite number.
 267          * @param num_sprites The number of sprites per set.
 268          * @return A spritegroup representing the sprite number result.
 269          */
 270         ResultSpriteGroup(SpriteID sprite, byte num_sprites) :
 271                 SpriteGroup(SGT_RESULT),
 272                 sprite(sprite),
 273                 num_sprites(num_sprites)
 274         {
 275         }
 276
 277         SpriteID sprite;
 278         byte num_sprites;
 279         SpriteID GetResult() const { return this->sprite; }
 280         byte GetNumResults() const { return this->num_sprites; }
 281 };
 282
 283 /**
 284  * Action 2 sprite layout for houses, industry tiles, objects and airport tiles.
 285  */
 286 struct TileLayoutSpriteGroup : SpriteGroup {
 287         TileLayoutSpriteGroup() : SpriteGroup(SGT_TILELAYOUT) {}
 288         ~TileLayoutSpriteGroup() {}
 289
 290         NewGRFSpriteLayout dts;
 291
 292         const DrawTileSprites *ProcessRegisters(uint8 *stage) const;
 293 };
 294
 295 struct IndustryProductionSpriteGroup : SpriteGroup {
 296         IndustryProductionSpriteGroup() : SpriteGroup(SGT_INDUSTRY_PRODUCTION) {}
 297
 298         uint8 version;
 299         int16 subtract_input[3];  // signed
 300         uint16 add_output[2];     // unsigned
 301         uint8 again;
 302 };
 303
 304 struct ResolverObject;
 305
 306 /**
 307  * Interface to query and set values specific to a single #VarSpriteGroupScope (action 2 scope).
 308  *
 309  * Multiple of these interfaces are combined into a #ResolverObject to allow access
 310  * to different game entities from a #SpriteGroup-chain (action 1-2-3 chain).
 311  */
 312 struct ScopeResolver {
 313         ResolverObject *ro; ///< Surrounding resolver object.
 314
 315         ScopeResolver(ResolverObject *ro);
 316         virtual ~ScopeResolver();
 317
 318         virtual uint32 GetRandomBits() const;
 319         virtual uint32 GetTriggers() const;
 320         virtual void SetTriggers(int triggers) const;
 321
 322         virtual uint32 GetVariable(byte variable, uint32 parameter, bool *available) const;
 323         virtual void StorePSA(uint reg, int32 value);
 324 };
 325
 326 /**
 327  * Interface for #SpriteGroup-s to access the gamestate.
 328  *
 329  * Using this interface #SpriteGroup-chains (action 1-2-3 chains) can be resolved,
 330  * to get the results of callbacks, rerandomisations or normal sprite lookups.
 331  */
 332 struct ResolverObject {
 333         ResolverObject(const GRFFile *grffile, CallbackID callback = CBID_NO_CALLBACK, uint32 callback_param1 = 0, uint32 callback_param2 = 0);
 334         virtual ~ResolverObject();
 335
 336         ScopeResolver default_scope; ///< Default implementation of the grf scope.
 337
 338         CallbackID callback;        ///< Callback being resolved.
 339         uint32 callback_param1;     ///< First parameter (var 10) of the callback.
 340         uint32 callback_param2;     ///< Second parameter (var 18) of the callback.
 341
 342         byte trigger;
 343
 344         uint32 last_value;          ///< Result of most recent DeterministicSpriteGroup (including procedure calls)
 345         uint32 reseed[VSG_END];     ///< Collects bits to rerandomise while triggering triggers.
 346
 347         const GRFFile *grffile;     ///< GRFFile the resolved SpriteGroup belongs to
 348
 349         virtual const SpriteGroup *ResolveReal(const RealSpriteGroup *group) const;
 350
 351         virtual ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, byte relative = 0);
 352
 353         /**
 354          * Returns the OR-sum of all bits that need reseeding
 355          * independent of the scope they were accessed with.
 356          * @return OR-sum of the bits.
 357          */
 358         uint32 GetReseedSum() const
 359         {
 360                 uint32 sum = 0;
 361                 for (VarSpriteGroupScope vsg = VSG_BEGIN; vsg < VSG_END; vsg++) {
 362                         sum |= this->reseed[vsg];
 363                 }
 364                 return sum;
 365         }
 366
 367         /**
 368          * Resets the dynamic state of the resolver object.
 369          * To be called before resolving an Action-1-2-3 chain.
 370          */
 371         void ResetState()
 372         {
 373                 this->last_value = 0;
 374                 this->trigger    = 0;
 375                 memset(this->reseed, 0, sizeof(this->reseed));
 376         }
 377 };
 378
 379 #endif /* NEWGRF_SPRITEGROUP_H */