src/newgrf_spritegroup.h

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