src/newgrf_object.cpp

   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_object.cpp Handling of object NewGRFs. */
  11
  12 #include "stdafx.h"
  13 #include "company_base.h"
  14 #include "company_func.h"
  15 #include "debug.h"
  16 #include "genworld.h"
  17 #include "newgrf_class_func.h"
  18 #include "newgrf_object.h"
  19 #include "newgrf_sound.h"
  20 #include "object_base.h"
  21 #include "object.h"
  22 #include "map/object.h"
  23 #include "map/slope.h"
  24 #include "tile_cmd.h"
  25 #include "town.h"
  26 #include "water.h"
  27 #include "newgrf_animation_base.h"
  28
  29 /** The override manager for our objects. */
  30 ObjectOverrideManager _object_mngr(NEW_OBJECT_OFFSET, NUM_OBJECTS, INVALID_OBJECT_TYPE);
  31
  32 extern const ObjectSpec _original_objects[NEW_OBJECT_OFFSET];
  33 /** All the object specifications. */
  34 ObjectSpec _object_specs[NUM_OBJECTS];
  35
  36 /**
  37  * Get the specification associated with a specific ObjectType.
  38  * @param index The object type to fetch.
  39  * @return The specification.
  40  */
  41 /* static */ const ObjectSpec *ObjectSpec::Get(ObjectType index)
  42 {
  43         assert(index < NUM_OBJECTS);
  44         return &_object_specs[index];
  45 }
  46
  47 /**
  48  * Get the specification associated with a tile.
  49  * @param tile The tile to fetch the data for.
  50  * @return The specification.
  51  */
  52 /* static */ const ObjectSpec *ObjectSpec::GetByTile(TileIndex tile)
  53 {
  54         return ObjectSpec::Get(GetObjectType(tile));
  55 }
  56
  57 /**
  58  * Check whether the object might be available at some point in this game with the current game mode.
  59  * @return true if it might be available.
  60  */
  61 bool ObjectSpec::IsEverAvailable() const
  62 {
  63         return this->enabled && HasBit(this->climate, _settings_game.game_creation.landscape) &&
  64                         (this->flags & ((_game_mode != GM_EDITOR && !_generating_world) ? OBJECT_FLAG_ONLY_IN_SCENEDIT : OBJECT_FLAG_ONLY_IN_GAME)) == 0;
  65 }
  66
  67 /**
  68  * Check whether the object was available at some point in the past or present in this game with the current game mode.
  69  * @return true if it was ever or is available.
  70  */
  71 bool ObjectSpec::WasEverAvailable() const
  72 {
  73         return this->IsEverAvailable() && _date > this->introduction_date;
  74 }
  75
  76 /**
  77  * Check whether the object is available at this time.
  78  * @return true if it is available.
  79  */
  80 bool ObjectSpec::IsAvailable() const
  81 {
  82         return this->WasEverAvailable() &&
  83                         (_date < this->end_of_life_date || this->end_of_life_date < this->introduction_date + 365);
  84 }
  85
  86 /**
  87  * Gets the index of this spec.
  88  * @return The index.
  89  */
  90 uint ObjectSpec::Index() const
  91 {
  92         return this - _object_specs;
  93 }
  94
  95 /** This function initialize the spec arrays of objects. */
  96 void ResetObjects()
  97 {
  98         /* Clean the pool. */
  99         MemSetT(_object_specs, 0, lengthof(_object_specs));
 100
 101         /* And add our originals. */
 102         MemCpyT(_object_specs, _original_objects, lengthof(_original_objects));
 103
 104         for (uint16 i = 0; i < lengthof(_original_objects); i++) {
 105                 _object_specs[i].grf_prop.local_id = i;
 106         }
 107 }
 108
 109 template <typename Tspec, typename Tid, Tid Tmax>
 110 /* static */ void NewGRFClass<Tspec, Tid, Tmax>::InsertDefaults()
 111 {
 112         ObjectClassID cls = ObjectClass::Allocate('LTHS');
 113         ObjectClass::Get(cls)->name = STR_OBJECT_CLASS_LTHS;
 114         _object_specs[OBJECT_LIGHTHOUSE].cls_id = cls;
 115         ObjectClass::Assign(&_object_specs[OBJECT_LIGHTHOUSE]);
 116
 117         cls = ObjectClass::Allocate('TRNS');
 118         ObjectClass::Get(cls)->name = STR_OBJECT_CLASS_TRNS;
 119         _object_specs[OBJECT_TRANSMITTER].cls_id = cls;
 120         ObjectClass::Assign(&_object_specs[OBJECT_TRANSMITTER]);
 121 }
 122
 123 template <typename Tspec, typename Tid, Tid Tmax>
 124 bool NewGRFClass<Tspec, Tid, Tmax>::IsUIAvailable(uint index) const
 125 {
 126         return this->GetSpec(index)->IsEverAvailable();
 127 }
 128
 129 INSTANTIATE_NEWGRF_CLASS_METHODS(ObjectClass, ObjectSpec, ObjectClassID, OBJECT_CLASS_MAX)
 130
 131 /**
 132  * Constructor of an object scope resolver.
 133  * @param ro Surrounding resolver.
 134  * @param obj Object being resolved.
 135  * @param tile %Tile of the object.
 136  * @param view View of the object.
 137  */
 138 ObjectScopeResolver::ObjectScopeResolver(ResolverObject &ro, Object *obj, TileIndex tile, uint8 view)
 139                 : ScopeResolver(ro)
 140 {
 141         this->obj = obj;
 142         this->tile = tile;
 143         this->view = view;
 144 }
 145
 146 /* virtual */ uint32 ObjectScopeResolver::GetRandomBits() const
 147 {
 148         return IsValidTile(this->tile) && IsObjectTile(this->tile) ? GetObjectRandomBits(this->tile) : 0;
 149 }
 150
 151 /**
 152  * Make an analysis of a tile and get the object type.
 153  * @param tile TileIndex of the tile to query
 154  * @param cur_grfid GRFID of the current callback chain
 155  * @return value encoded as per NFO specs
 156  */
 157 static uint32 GetObjectIDAtOffset(TileIndex tile, uint32 cur_grfid)
 158 {
 159         if (!IsObjectTile(tile)) {
 160                 return 0xFFFF;
 161         }
 162
 163         const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
 164
 165         /* Default objects have no associated NewGRF file */
 166         if (spec->grf_prop.grffile == NULL) {
 167                 return 0xFFFE; // Defined in another grf file
 168         }
 169
 170         if (spec->grf_prop.grffile->grfid == cur_grfid) { // same object, same grf ?
 171                 return spec->grf_prop.local_id;
 172         }
 173
 174         return 0xFFFE; // Defined in another grf file
 175 }
 176
 177 /**
 178  * Based on newhouses equivalent, but adapted for newobjects
 179  * @param parameter from callback.  It's in fact a pair of coordinates
 180  * @param tile TileIndex from which the callback was initiated
 181  * @param index of the object been queried for
 182  * @param grf_version8 True, if we are dealing with a new NewGRF which uses GRF version >= 8.
 183  * @return a construction of bits obeying the newgrf format
 184  */
 185 static uint32 GetNearbyObjectTileInformation(byte parameter, TileIndex tile, ObjectID index, bool grf_version8)
 186 {
 187         if (parameter != 0) tile = GetNearbyTile(parameter, tile); // only perform if it is required
 188         bool is_same_object = (IsObjectTile(tile) && GetObjectIndex(tile) == index);
 189
 190         return GetNearbyTileInformation(tile, grf_version8) | (is_same_object ? 1 : 0) << 8;
 191 }
 192
 193 /**
 194  * Get the closest object of a given type.
 195  * @param tile    The tile to start searching from.
 196  * @param type    The type of the object to search for.
 197  * @param current The current object (to ignore).
 198  * @return The distance to the closest object.
 199  */
 200 static uint32 GetClosestObject(TileIndex tile, ObjectType type, const Object *current)
 201 {
 202         uint32 best_dist = UINT32_MAX;
 203         const Object *o;
 204         FOR_ALL_OBJECTS(o) {
 205                 if (o->type != type || o == current) continue;
 206
 207                 best_dist = min(best_dist, DistanceManhattan(tile, o->location.tile));
 208         }
 209
 210         return best_dist;
 211 }
 212
 213 /**
 214  * Implementation of var 65
 215  * @param local_id Parameter given to the callback, which is the set id, or the local id, in our terminology.
 216  * @param grfid    The object's GRFID.
 217  * @param tile     The tile to look from.
 218  * @param current  Object for which the inquiry is made
 219  * @return The formatted answer to the callback : rr(reserved) cc(count) dddd(manhattan distance of closest sister)
 220  */
 221 static uint32 GetCountAndDistanceOfClosestInstance(byte local_id, uint32 grfid, TileIndex tile, const Object *current)
 222 {
 223         uint32 grf_id = GetRegister(0x100);  // Get the GRFID of the definition to look for in register 100h
 224         uint32 idx;
 225
 226         /* Determine what will be the object type to look for */
 227         switch (grf_id) {
 228                 case 0:  // this is a default object type
 229                         idx = local_id;
 230                         break;
 231
 232                 case 0xFFFFFFFF: // current grf
 233                         grf_id = grfid;
 234                         /* FALL THROUGH */
 235
 236                 default: // use the grfid specified in register 100h
 237                         idx = _object_mngr.GetID(local_id, grf_id);
 238                         break;
 239         }
 240
 241         /* If the object type is invalid, there is none and the closest is far away. */
 242         if (idx >= NUM_OBJECTS) return 0 | 0xFFFF;
 243
 244         return Object::GetTypeCount(idx) << 16 | min(GetClosestObject(tile, idx, current), 0xFFFF);
 245 }
 246
 247 /** Used by the resolver to get values for feature 0F deterministic spritegroups. */
 248 /* virtual */ uint32 ObjectScopeResolver::GetVariable(byte variable, uint32 parameter, bool *available) const
 249 {
 250         /* We get the town from the object, or we calculate the closest
 251          * town if we need to when there's no object. */
 252         const Town *t = NULL;
 253
 254         if (this->obj == NULL) {
 255                 switch (variable) {
 256                         /* Allow these when there's no object. */
 257                         case 0x41:
 258                         case 0x60:
 259                         case 0x61:
 260                         case 0x62:
 261                         case 0x64:
 262                                 break;
 263
 264                         /* Allow these, but find the closest town. */
 265                         case 0x45:
 266                         case 0x46:
 267                                 if (!IsValidTile(this->tile)) goto unhandled;
 268                                 t = ClosestTownFromTile(this->tile, UINT_MAX);
 269                                 break;
 270
 271                         /* Construction date */
 272                         case 0x42: return _date;
 273
 274                         /* Object founder information */
 275                         case 0x44: return _current_company;
 276
 277                         /* Object view */
 278                         case 0x48: return this->view;
 279
 280                         /*
 281                          * Disallow the rest:
 282                          * 0x40: Relative position is passed as parameter during construction.
 283                          * 0x43: Animation counter is only for actual tiles.
 284                          * 0x47: Object colour is only valid when its built.
 285                          * 0x63: Animation counter of nearby tile, see above.
 286                          */
 287                         default:
 288                                 goto unhandled;
 289                 }
 290
 291                 /* If there's an invalid tile, then we don't have enough information at all. */
 292                 if (!IsValidTile(this->tile)) goto unhandled;
 293         } else {
 294                 t = this->obj->town;
 295         }
 296
 297         switch (variable) {
 298                 /* Relative position. */
 299                 case 0x40: {
 300                         uint offset = this->tile - this->obj->location.tile;
 301                         uint offset_x = TileX(offset);
 302                         uint offset_y = TileY(offset);
 303                         return offset_y << 20 | offset_x << 16 | offset_y << 8 | offset_x;
 304                 }
 305
 306                 /* Tile information. */
 307                 case 0x41: return GetTileSlope(this->tile) << 8 | GetTerrainType(this->tile);
 308
 309                 /* Construction date */
 310                 case 0x42: return this->obj->build_date;
 311
 312                 /* Animation counter */
 313                 case 0x43: return GetAnimationFrame(this->tile);
 314
 315                 /* Object founder information */
 316                 case 0x44: return GetTileOwner(this->tile);
 317
 318                 /* Get town zone and Manhattan distance of closest town */
 319                 case 0x45: return GetTownRadiusGroup(t, this->tile) << 16 | min(DistanceManhattan(this->tile, t->xy), 0xFFFF);
 320
 321                 /* Get square of Euclidian distance of closes town */
 322                 case 0x46: return GetTownRadiusGroup(t, this->tile) << 16 | min(DistanceSquare(this->tile, t->xy), 0xFFFF);
 323
 324                 /* Object colour */
 325                 case 0x47: return this->obj->colour;
 326
 327                 /* Object view */
 328                 case 0x48: return this->obj->view;
 329
 330                 /* Get object ID at offset param */
 331                 case 0x60: return GetObjectIDAtOffset(GetNearbyTile(parameter, this->tile), this->ro.grffile->grfid);
 332
 333                 /* Get random tile bits at offset param */
 334                 case 0x61: {
 335                         TileIndex tile = GetNearbyTile(parameter, this->tile);
 336                         return (IsObjectTile(tile) && Object::GetByTile(tile) == this->obj) ? GetObjectRandomBits(tile) : 0;
 337                 }
 338
 339                 /* Land info of nearby tiles */
 340                 case 0x62: return GetNearbyObjectTileInformation(parameter, this->tile, this->obj == NULL ? INVALID_OBJECT : this->obj->index, this->ro.grffile->grf_version >= 8);
 341
 342                 /* Animation counter of nearby tile */
 343                 case 0x63: {
 344                         TileIndex tile = GetNearbyTile(parameter, this->tile);
 345                         return (IsObjectTile(tile) && Object::GetByTile(tile) == this->obj) ? GetAnimationFrame(tile) : 0;
 346                 }
 347
 348                 /* Count of object, distance of closest instance */
 349                 case 0x64: return GetCountAndDistanceOfClosestInstance(parameter, this->ro.grffile->grfid, this->tile, this->obj);
 350         }
 351
 352 unhandled:
 353         DEBUG(grf, 1, "Unhandled object variable 0x%X", variable);
 354
 355         *available = false;
 356         return UINT_MAX;
 357 }
 358
 359 /**
 360  * Get the object's sprite group.
 361  * @param spec The specification to get the sprite group from.
 362  * @param o    The object to get he sprite group for.
 363  * @return The resolved sprite group.
 364  */
 365 static const SpriteGroup *GetObjectSpriteGroup(const ObjectSpec *spec, const Object *o)
 366 {
 367         const SpriteGroup *group = NULL;
 368
 369         if (o == NULL) group = spec->grf_prop.spritegroup[CT_PURCHASE_OBJECT];
 370         if (group != NULL) return group;
 371
 372         /* Fall back to the default set if the selected cargo type is not defined */
 373         return spec->grf_prop.spritegroup[0];
 374
 375 }
 376
 377 /**
 378  * Constructor of the object resolver.
 379  * @param obj Object being resolved.
 380  * @param tile %Tile of the object.
 381  * @param view View of the object.
 382  * @param callback Callback ID.
 383  * @param callback_param1 First parameter (var 10) of the callback.
 384  * @param callback_param2 Second parameter (var 18) of the callback.
 385  */
 386 ObjectResolverObject::ObjectResolverObject(const ObjectSpec *spec, Object *obj, TileIndex tile, uint8 view,
 387                 CallbackID callback, uint32 param1, uint32 param2)
 388         : ResolverObject(spec->grf_prop.grffile, callback, param1, param2), object_scope(*this, obj, tile, view)
 389 {
 390         this->town_scope = NULL;
 391 }
 392
 393 ObjectResolverObject::~ObjectResolverObject()
 394 {
 395         delete this->town_scope;
 396 }
 397
 398 /**
 399  * Get the town resolver scope that belongs to this object resolver.
 400  * On the first call, the town scope is created (if possible).
 401  * @return Town scope, if available.
 402  */
 403 TownScopeResolver *ObjectResolverObject::GetTown()
 404 {
 405         if (this->town_scope == NULL) {
 406                 Town *t;
 407                 if (this->object_scope.obj != NULL) {
 408                         t = this->object_scope.obj->town;
 409                 } else {
 410                         t = ClosestTownFromTile(this->object_scope.tile, UINT_MAX);
 411                 }
 412                 if (t == NULL) return NULL;
 413                 this->town_scope = new TownScopeResolver(*this, t, this->object_scope.obj == NULL);
 414         }
 415         return this->town_scope;
 416 }
 417
 418 /**
 419  * Perform a callback for an object.
 420  * @param callback The callback to perform.
 421  * @param param1   The first parameter to pass to the NewGRF.
 422  * @param param2   The second parameter to pass to the NewGRF.
 423  * @param spec     The specification of the object / the entry point.
 424  * @param o        The object to call the callback for.
 425  * @param tile     The tile the callback is called for.
 426  * @param view     The view of the object (only used when o == NULL).
 427  * @return The result of the callback.
 428  */
 429 uint16 GetObjectCallback(CallbackID callback, uint32 param1, uint32 param2, const ObjectSpec *spec, Object *o, TileIndex tile, uint8 view)
 430 {
 431         ObjectResolverObject object(spec, o, tile, view, callback, param1, param2);
 432         const SpriteGroup *group = SpriteGroup::Resolve(GetObjectSpriteGroup(spec, o), object);
 433         if (group == NULL) return CALLBACK_FAILED;
 434
 435         return group->GetCallbackResult();
 436 }
 437
 438 /**
 439  * Draw an group of sprites on the map.
 440  * @param ti    Information about the tile to draw on.
 441  * @param group The group of sprites to draw.
 442  * @param spec  Object spec to draw.
 443  */
 444 static void DrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, const ObjectSpec *spec)
 445 {
 446         const DrawTileSprites *dts = group->ProcessRegisters(NULL);
 447         PaletteID palette = ((spec->flags & OBJECT_FLAG_2CC_COLOUR) ? SPR_2CCMAP_BASE : PALETTE_RECOLOUR_START) + Object::GetByTile(ti->tile)->colour;
 448
 449         SpriteID image = dts->ground.sprite;
 450         PaletteID pal  = dts->ground.pal;
 451
 452         if (GB(image, 0, SPRITE_WIDTH) != 0) {
 453                 /* If the ground sprite is the default flat water sprite, draw also canal/river borders
 454                  * Do not do this if the tile's WaterClass is 'land'. */
 455                 if ((image == SPR_FLAT_WATER_TILE || spec->flags & OBJECT_FLAG_DRAW_WATER) && IsTileOnWater(ti->tile)) {
 456                         DrawWaterClassGround(ti);
 457                 } else {
 458                         DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, palette));
 459                 }
 460         }
 461
 462         DrawNewGRFTileSeq(ti, dts, TO_STRUCTURES, 0, palette);
 463 }
 464
 465 /**
 466  * Draw an object on the map.
 467  * @param ti   Information about the tile to draw on.
 468  * @param spec Object spec to draw.
 469  */
 470 void DrawNewObjectTile(TileInfo *ti, const ObjectSpec *spec)
 471 {
 472         Object *o = Object::GetByTile(ti->tile);
 473         ObjectResolverObject object(spec, o, ti->tile);
 474
 475         const SpriteGroup *group = SpriteGroup::Resolve(GetObjectSpriteGroup(spec, o), object);
 476         if (group == NULL || group->type != SGT_TILELAYOUT) return;
 477
 478         DrawTileLayout(ti, (const TileLayoutSpriteGroup *)group, spec);
 479 }
 480
 481 /**
 482  * Draw representation of an object (tile) for GUI purposes.
 483  * @param x    Position x of image.
 484  * @param y    Position y of image.
 485  * @param spec Object spec to draw.
 486  * @param view The object's view.
 487  */
 488 void DrawNewObjectTileInGUI(int x, int y, const ObjectSpec *spec, uint8 view)
 489 {
 490         ObjectResolverObject object(spec, NULL, INVALID_TILE, view);
 491         const SpriteGroup *group = SpriteGroup::Resolve(GetObjectSpriteGroup(spec, NULL), object);
 492         if (group == NULL || group->type != SGT_TILELAYOUT) return;
 493
 494         const DrawTileSprites *dts = ((const TileLayoutSpriteGroup *)group)->ProcessRegisters(NULL);
 495
 496         PaletteID palette;
 497         if (Company::IsValidID(_local_company)) {
 498                 /* Get the colours of our company! */
 499                 if (spec->flags & OBJECT_FLAG_2CC_COLOUR) {
 500                         const Livery *l = Company::Get(_local_company)->livery;
 501                         palette = SPR_2CCMAP_BASE + l->colour1 + l->colour2 * 16;
 502                 } else {
 503                         palette = COMPANY_SPRITE_COLOUR(_local_company);
 504                 }
 505         } else {
 506                 /* There's no company, so just take the base palette. */
 507                 palette = (spec->flags & OBJECT_FLAG_2CC_COLOUR) ? SPR_2CCMAP_BASE : PALETTE_RECOLOUR_START;
 508         }
 509
 510         SpriteID image = dts->ground.sprite;
 511         PaletteID pal  = dts->ground.pal;
 512
 513         if (GB(image, 0, SPRITE_WIDTH) != 0) {
 514                 DrawSprite(image, GroundSpritePaletteTransform(image, pal, palette), x, y);
 515         }
 516
 517         DrawNewGRFTileSeqInGUI(x, y, dts, 0, palette);
 518 }
 519
 520 /**
 521  * Perform a callback for an object.
 522  * @param callback The callback to perform.
 523  * @param param1   The first parameter to pass to the NewGRF.
 524  * @param param2   The second parameter to pass to the NewGRF.
 525  * @param spec     The specification of the object / the entry point.
 526  * @param o        The object to call the callback for.
 527  * @param tile     The tile the callback is called for.
 528  * @param extra_data Ignored.
 529  * @return The result of the callback.
 530  */
 531 uint16 StubGetObjectCallback(CallbackID callback, uint32 param1, uint32 param2, const ObjectSpec *spec, Object *o, TileIndex tile, int extra_data)
 532 {
 533         return GetObjectCallback(callback, param1, param2, spec, o, tile);
 534 }
 535
 536 /** Helper class for animation control. */
 537 struct ObjectAnimationBase : public AnimationBase<ObjectAnimationBase, ObjectSpec, Object, int, StubGetObjectCallback> {
 538         static const CallbackID cb_animation_speed      = CBID_OBJECT_ANIMATION_SPEED;
 539         static const CallbackID cb_animation_next_frame = CBID_OBJECT_ANIMATION_NEXT_FRAME;
 540
 541         static const ObjectCallbackMask cbm_animation_speed      = CBM_OBJ_ANIMATION_SPEED;
 542         static const ObjectCallbackMask cbm_animation_next_frame = CBM_OBJ_ANIMATION_NEXT_FRAME;
 543 };
 544
 545 /**
 546  * Handle the animation of the object tile.
 547  * @param tile The tile to animate.
 548  */
 549 void AnimateNewObjectTile(TileIndex tile)
 550 {
 551         const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
 552         if (spec == NULL || !(spec->flags & OBJECT_FLAG_ANIMATION)) return;
 553
 554         ObjectAnimationBase::AnimateTile(spec, Object::GetByTile(tile), tile, (spec->flags & OBJECT_FLAG_ANIM_RANDOM_BITS) != 0);
 555 }
 556
 557 /**
 558  * Trigger the update of animation on a single tile.
 559  * @param o       The object that got triggered.
 560  * @param tile    The location of the triggered tile.
 561  * @param trigger The trigger that is triggered.
 562  * @param spec    The spec associated with the object.
 563  */
 564 void TriggerObjectTileAnimation(Object *o, TileIndex tile, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
 565 {
 566         if (!HasBit(spec->animation.triggers, trigger)) return;
 567
 568         ObjectAnimationBase::ChangeAnimationFrame(CBID_OBJECT_ANIMATION_START_STOP, spec, o, tile, Random(), trigger);
 569 }
 570
 571 /**
 572  * Trigger the update of animation on a whole object.
 573  * @param o       The object that got triggered.
 574  * @param trigger The trigger that is triggered.
 575  * @param spec    The spec associated with the object.
 576  */
 577 void TriggerObjectAnimation(Object *o, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
 578 {
 579         if (!HasBit(spec->animation.triggers, trigger)) return;
 580
 581         TILE_AREA_LOOP(tile, o->location) {
 582                 TriggerObjectTileAnimation(o, tile, trigger, spec);
 583         }
 584 }