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_map.h"
  22 #include "tile_cmd.h"
  23 #include "town.h"
  24 #include "water.h"
  25 #include "newgrf_animation_base.h"
  26
  27 #include "safeguards.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) && IsTileType(this->tile, MP_OBJECT) ? 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 (!IsTileType(tile, MP_OBJECT)) {
 160                 return 0xFFFF;
 161         }
 162
 163         const Object *o = Object::GetByTile(tile);
 164         const ObjectSpec *spec = ObjectSpec::Get(o->type);
 165
 166         /* Default objects have no associated NewGRF file */
 167         if (spec->grf_prop.grffile == NULL) {
 168                 return 0xFFFE; // Defined in another grf file
 169         }
 170
 171         if (spec->grf_prop.grffile->grfid == cur_grfid) { // same object, same grf ?
 172                 return spec->grf_prop.local_id | o->view << 16;
 173         }
 174
 175         return 0xFFFE; // Defined in another grf file
 176 }
 177
 178 /**
 179  * Based on newhouses equivalent, but adapted for newobjects
 180  * @param parameter from callback.  It's in fact a pair of coordinates
 181  * @param tile TileIndex from which the callback was initiated
 182  * @param index of the object been queried for
 183  * @param grf_version8 True, if we are dealing with a new NewGRF which uses GRF version >= 8.
 184  * @return a construction of bits obeying the newgrf format
 185  */
 186 static uint32 GetNearbyObjectTileInformation(byte parameter, TileIndex tile, ObjectID index, bool grf_version8)
 187 {
 188         if (parameter != 0) tile = GetNearbyTile(parameter, tile); // only perform if it is required
 189         bool is_same_object = (IsTileType(tile, MP_OBJECT) && GetObjectIndex(tile) == index);
 190
 191         return GetNearbyTileInformation(tile, grf_version8) | (is_same_object ? 1 : 0) << 8;
 192 }
 193
 194 /**
 195  * Get the closest object of a given type.
 196  * @param tile    The tile to start searching from.
 197  * @param type    The type of the object to search for.
 198  * @param current The current object (to ignore).
 199  * @return The distance to the closest object.
 200  */
 201 static uint32 GetClosestObject(TileIndex tile, ObjectType type, const Object *current)
 202 {
 203         uint32 best_dist = UINT32_MAX;
 204         const Object *o;
 205         FOR_ALL_OBJECTS(o) {
 206                 if (o->type != type || o == current) continue;
 207
 208                 best_dist = min(best_dist, DistanceManhattan(tile, o->location.tile));
 209         }
 210
 211         return best_dist;
 212 }
 213
 214 /**
 215  * Implementation of var 65
 216  * @param local_id Parameter given to the callback, which is the set id, or the local id, in our terminology.
 217  * @param grfid    The object's GRFID.
 218  * @param tile     The tile to look from.
 219  * @param current  Object for which the inquiry is made
 220  * @return The formatted answer to the callback : rr(reserved) cc(count) dddd(manhattan distance of closest sister)
 221  */
 222 static uint32 GetCountAndDistanceOfClosestInstance(byte local_id, uint32 grfid, TileIndex tile, const Object *current)
 223 {
 224         uint32 grf_id = GetRegister(0x100);  // Get the GRFID of the definition to look for in register 100h
 225         uint32 idx;
 226
 227         /* Determine what will be the object type to look for */
 228         switch (grf_id) {
 229                 case 0:  // this is a default object type
 230                         idx = local_id;
 231                         break;
 232
 233                 case 0xFFFFFFFF: // current grf
 234                         grf_id = grfid;
 235                         /* FALL THROUGH */
 236
 237                 default: // use the grfid specified in register 100h
 238                         idx = _object_mngr.GetID(local_id, grf_id);
 239                         break;
 240         }
 241
 242         /* If the object type is invalid, there is none and the closest is far away. */
 243         if (idx >= NUM_OBJECTS) return 0 | 0xFFFF;
 244
 245         return Object::GetTypeCount(idx) << 16 | min(GetClosestObject(tile, idx, current), 0xFFFF);
 246 }
 247
 248 /** Used by the resolver to get values for feature 0F deterministic spritegroups. */
 249 /* virtual */ uint32 ObjectScopeResolver::GetVariable(byte variable, uint32 parameter, bool *available) const
 250 {
 251         /* We get the town from the object, or we calculate the closest
 252          * town if we need to when there's no object. */
 253         const Town *t = NULL;
 254
 255         if (this->obj == NULL) {
 256                 switch (variable) {
 257                         /* Allow these when there's no object. */
 258                         case 0x41:
 259                         case 0x60:
 260                         case 0x61:
 261                         case 0x62:
 262                         case 0x64:
 263                                 break;
 264
 265                         /* Allow these, but find the closest town. */
 266                         case 0x45:
 267                         case 0x46:
 268                                 if (!IsValidTile(this->tile)) goto unhandled;
 269                                 t = ClosestTownFromTile(this->tile, UINT_MAX);
 270                                 break;
 271
 272                         /* Construction date */
 273                         case 0x42: return _date;
 274
 275                         /* Object founder information */
 276                         case 0x44: return _current_company;
 277
 278                         /* Object view */
 279                         case 0x48: return this->view;
 280
 281                         /*
 282                          * Disallow the rest:
 283                          * 0x40: Relative position is passed as parameter during construction.
 284                          * 0x43: Animation counter is only for actual tiles.
 285                          * 0x47: Object colour is only valid when its built.
 286                          * 0x63: Animation counter of nearby tile, see above.
 287                          */
 288                         default:
 289                                 goto unhandled;
 290                 }
 291
 292                 /* If there's an invalid tile, then we don't have enough information at all. */
 293                 if (!IsValidTile(this->tile)) goto unhandled;
 294         } else {
 295                 t = this->obj->town;
 296         }
 297
 298         switch (variable) {
 299                 /* Relative position. */
 300                 case 0x40: {
 301                         uint offset = this->tile - this->obj->location.tile;
 302                         uint offset_x = TileX(offset);
 303                         uint offset_y = TileY(offset);
 304                         return offset_y << 20 | offset_x << 16 | offset_y << 8 | offset_x;
 305                 }
 306
 307                 /* Tile information. */
 308                 case 0x41: return GetTileSlope(this->tile) << 8 | GetTerrainType(this->tile);
 309
 310                 /* Construction date */
 311                 case 0x42: return this->obj->build_date;
 312
 313                 /* Animation counter */
 314                 case 0x43: return GetAnimationFrame(this->tile);
 315
 316                 /* Object founder information */
 317                 case 0x44: return GetTileOwner(this->tile);
 318
 319                 /* Get town zone and Manhattan distance of closest town */
 320                 case 0x45: return GetTownRadiusGroup(t, this->tile) << 16 | min(DistanceManhattan(this->tile, t->xy), 0xFFFF);
 321
 322                 /* Get square of Euclidian distance of closes town */
 323                 case 0x46: return GetTownRadiusGroup(t, this->tile) << 16 | min(DistanceSquare(this->tile, t->xy), 0xFFFF);
 324
 325                 /* Object colour */
 326                 case 0x47: return this->obj->colour;
 327
 328                 /* Object view */
 329                 case 0x48: return this->obj->view;
 330
 331                 /* Get object ID at offset param */
 332                 case 0x60: return GetObjectIDAtOffset(GetNearbyTile(parameter, this->tile), this->ro.grffile->grfid);
 333
 334                 /* Get random tile bits at offset param */
 335                 case 0x61: {
 336                         TileIndex tile = GetNearbyTile(parameter, this->tile);
 337                         return (IsTileType(tile, MP_OBJECT) && Object::GetByTile(tile) == this->obj) ? GetObjectRandomBits(tile) : 0;
 338                 }
 339
 340                 /* Land info of nearby tiles */
 341                 case 0x62: return GetNearbyObjectTileInformation(parameter, this->tile, this->obj == NULL ? INVALID_OBJECT : this->obj->index, this->ro.grffile->grf_version >= 8);
 342
 343                 /* Animation counter of nearby tile */
 344                 case 0x63: {
 345                         TileIndex tile = GetNearbyTile(parameter, this->tile);
 346                         return (IsTileType(tile, MP_OBJECT) && Object::GetByTile(tile) == this->obj) ? GetAnimationFrame(tile) : 0;
 347                 }
 348
 349                 /* Count of object, distance of closest instance */
 350                 case 0x64: return GetCountAndDistanceOfClosestInstance(parameter, this->ro.grffile->grfid, this->tile, this->obj);
 351         }
 352
 353 unhandled:
 354         DEBUG(grf, 1, "Unhandled object variable 0x%X", variable);
 355
 356         *available = false;
 357         return UINT_MAX;
 358 }
 359
 360 /**
 361  * Constructor of the object resolver.
 362  * @param obj Object being resolved.
 363  * @param tile %Tile of the object.
 364  * @param view View of the object.
 365  * @param callback Callback ID.
 366  * @param callback_param1 First parameter (var 10) of the callback.
 367  * @param callback_param2 Second parameter (var 18) of the callback.
 368  */
 369 ObjectResolverObject::ObjectResolverObject(const ObjectSpec *spec, Object *obj, TileIndex tile, uint8 view,
 370                 CallbackID callback, uint32 param1, uint32 param2)
 371         : ResolverObject(spec->grf_prop.grffile, callback, param1, param2), object_scope(*this, obj, tile, view)
 372 {
 373         this->town_scope = NULL;
 374         this->root_spritegroup = (obj == NULL && spec->grf_prop.spritegroup[CT_PURCHASE_OBJECT] != NULL) ?
 375                         spec->grf_prop.spritegroup[CT_PURCHASE_OBJECT] : spec->grf_prop.spritegroup[0];
 376 }
 377
 378 ObjectResolverObject::~ObjectResolverObject()
 379 {
 380         delete this->town_scope;
 381 }
 382
 383 /**
 384  * Get the town resolver scope that belongs to this object resolver.
 385  * On the first call, the town scope is created (if possible).
 386  * @return Town scope, if available.
 387  */
 388 TownScopeResolver *ObjectResolverObject::GetTown()
 389 {
 390         if (this->town_scope == NULL) {
 391                 Town *t;
 392                 if (this->object_scope.obj != NULL) {
 393                         t = this->object_scope.obj->town;
 394                 } else {
 395                         t = ClosestTownFromTile(this->object_scope.tile, UINT_MAX);
 396                 }
 397                 if (t == NULL) return NULL;
 398                 this->town_scope = new TownScopeResolver(*this, t, this->object_scope.obj == NULL);
 399         }
 400         return this->town_scope;
 401 }
 402
 403 /**
 404  * Perform a callback for an object.
 405  * @param callback The callback to perform.
 406  * @param param1   The first parameter to pass to the NewGRF.
 407  * @param param2   The second parameter to pass to the NewGRF.
 408  * @param spec     The specification of the object / the entry point.
 409  * @param o        The object to call the callback for.
 410  * @param tile     The tile the callback is called for.
 411  * @param view     The view of the object (only used when o == NULL).
 412  * @return The result of the callback.
 413  */
 414 uint16 GetObjectCallback(CallbackID callback, uint32 param1, uint32 param2, const ObjectSpec *spec, Object *o, TileIndex tile, uint8 view)
 415 {
 416         ObjectResolverObject object(spec, o, tile, view, callback, param1, param2);
 417         return object.ResolveCallback();
 418 }
 419
 420 /**
 421  * Draw an group of sprites on the map.
 422  * @param ti    Information about the tile to draw on.
 423  * @param group The group of sprites to draw.
 424  * @param spec  Object spec to draw.
 425  */
 426 static void DrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, const ObjectSpec *spec)
 427 {
 428         const DrawTileSprites *dts = group->ProcessRegisters(NULL);
 429         PaletteID palette = ((spec->flags & OBJECT_FLAG_2CC_COLOUR) ? SPR_2CCMAP_BASE : PALETTE_RECOLOUR_START) + Object::GetByTile(ti->tile)->colour;
 430
 431         SpriteID image = dts->ground.sprite;
 432         PaletteID pal  = dts->ground.pal;
 433
 434         if (GB(image, 0, SPRITE_WIDTH) != 0) {
 435                 /* If the ground sprite is the default flat water sprite, draw also canal/river borders
 436                  * Do not do this if the tile's WaterClass is 'land'. */
 437                 if ((image == SPR_FLAT_WATER_TILE || spec->flags & OBJECT_FLAG_DRAW_WATER) && IsTileOnWater(ti->tile)) {
 438                         DrawWaterClassGround(ti);
 439                 } else {
 440                         DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, palette));
 441                 }
 442         }
 443
 444         DrawNewGRFTileSeq(ti, dts, TO_STRUCTURES, 0, palette);
 445 }
 446
 447 /**
 448  * Draw an object on the map.
 449  * @param ti   Information about the tile to draw on.
 450  * @param spec Object spec to draw.
 451  */
 452 void DrawNewObjectTile(TileInfo *ti, const ObjectSpec *spec)
 453 {
 454         Object *o = Object::GetByTile(ti->tile);
 455         ObjectResolverObject object(spec, o, ti->tile);
 456
 457         const SpriteGroup *group = object.Resolve();
 458         if (group == NULL || group->type != SGT_TILELAYOUT) return;
 459
 460         DrawTileLayout(ti, (const TileLayoutSpriteGroup *)group, spec);
 461 }
 462
 463 /**
 464  * Draw representation of an object (tile) for GUI purposes.
 465  * @param x    Position x of image.
 466  * @param y    Position y of image.
 467  * @param spec Object spec to draw.
 468  * @param view The object's view.
 469  */
 470 void DrawNewObjectTileInGUI(int x, int y, const ObjectSpec *spec, uint8 view)
 471 {
 472         ObjectResolverObject object(spec, NULL, INVALID_TILE, view);
 473         const SpriteGroup *group = object.Resolve();
 474         if (group == NULL || group->type != SGT_TILELAYOUT) return;
 475
 476         const DrawTileSprites *dts = ((const TileLayoutSpriteGroup *)group)->ProcessRegisters(NULL);
 477
 478         PaletteID palette;
 479         if (Company::IsValidID(_local_company)) {
 480                 /* Get the colours of our company! */
 481                 if (spec->flags & OBJECT_FLAG_2CC_COLOUR) {
 482                         const Livery *l = Company::Get(_local_company)->livery;
 483                         palette = SPR_2CCMAP_BASE + l->colour1 + l->colour2 * 16;
 484                 } else {
 485                         palette = COMPANY_SPRITE_COLOUR(_local_company);
 486                 }
 487         } else {
 488                 /* There's no company, so just take the base palette. */
 489                 palette = (spec->flags & OBJECT_FLAG_2CC_COLOUR) ? SPR_2CCMAP_BASE : PALETTE_RECOLOUR_START;
 490         }
 491
 492         SpriteID image = dts->ground.sprite;
 493         PaletteID pal  = dts->ground.pal;
 494
 495         if (GB(image, 0, SPRITE_WIDTH) != 0) {
 496                 DrawSprite(image, GroundSpritePaletteTransform(image, pal, palette), x, y);
 497         }
 498
 499         DrawNewGRFTileSeqInGUI(x, y, dts, 0, palette);
 500 }
 501
 502 /**
 503  * Perform a callback for an object.
 504  * @param callback The callback to perform.
 505  * @param param1   The first parameter to pass to the NewGRF.
 506  * @param param2   The second parameter to pass to the NewGRF.
 507  * @param spec     The specification of the object / the entry point.
 508  * @param o        The object to call the callback for.
 509  * @param tile     The tile the callback is called for.
 510  * @param extra_data Ignored.
 511  * @return The result of the callback.
 512  */
 513 uint16 StubGetObjectCallback(CallbackID callback, uint32 param1, uint32 param2, const ObjectSpec *spec, Object *o, TileIndex tile, int extra_data)
 514 {
 515         return GetObjectCallback(callback, param1, param2, spec, o, tile);
 516 }
 517
 518 /** Helper class for animation control. */
 519 struct ObjectAnimationBase : public AnimationBase<ObjectAnimationBase, ObjectSpec, Object, int, StubGetObjectCallback> {
 520         static const CallbackID cb_animation_speed      = CBID_OBJECT_ANIMATION_SPEED;
 521         static const CallbackID cb_animation_next_frame = CBID_OBJECT_ANIMATION_NEXT_FRAME;
 522
 523         static const ObjectCallbackMask cbm_animation_speed      = CBM_OBJ_ANIMATION_SPEED;
 524         static const ObjectCallbackMask cbm_animation_next_frame = CBM_OBJ_ANIMATION_NEXT_FRAME;
 525 };
 526
 527 /**
 528  * Handle the animation of the object tile.
 529  * @param tile The tile to animate.
 530  */
 531 void AnimateNewObjectTile(TileIndex tile)
 532 {
 533         const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
 534         if (spec == NULL || !(spec->flags & OBJECT_FLAG_ANIMATION)) return;
 535
 536         ObjectAnimationBase::AnimateTile(spec, Object::GetByTile(tile), tile, (spec->flags & OBJECT_FLAG_ANIM_RANDOM_BITS) != 0);
 537 }
 538
 539 /**
 540  * Trigger the update of animation on a single tile.
 541  * @param o       The object that got triggered.
 542  * @param tile    The location of the triggered tile.
 543  * @param trigger The trigger that is triggered.
 544  * @param spec    The spec associated with the object.
 545  */
 546 void TriggerObjectTileAnimation(Object *o, TileIndex tile, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
 547 {
 548         if (!HasBit(spec->animation.triggers, trigger)) return;
 549
 550         ObjectAnimationBase::ChangeAnimationFrame(CBID_OBJECT_ANIMATION_START_STOP, spec, o, tile, Random(), trigger);
 551 }
 552
 553 /**
 554  * Trigger the update of animation on a whole object.
 555  * @param o       The object that got triggered.
 556  * @param trigger The trigger that is triggered.
 557  * @param spec    The spec associated with the object.
 558  */
 559 void TriggerObjectAnimation(Object *o, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
 560 {
 561         if (!HasBit(spec->animation.triggers, trigger)) return;
 562
 563         TILE_AREA_LOOP(tile, o->location) {
 564                 TriggerObjectTileAnimation(o, tile, trigger, spec);
 565         }
 566 }