src/newgrf_object.cpp

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