OpenTTD
newgrf_object.cpp
Go to the documentation of this file.
1 /* $Id: newgrf_object.cpp 27984 2018-03-11 13:19:41Z 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 
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 
31 
32 extern const ObjectSpec _original_objects[NEW_OBJECT_OFFSET];
35 
41 /* static */ const ObjectSpec *ObjectSpec::Get(ObjectType index)
42 {
43  assert(index < NUM_OBJECTS);
44  return &_object_specs[index];
45 }
46 
52 /* static */ const ObjectSpec *ObjectSpec::GetByTile(TileIndex tile)
53 {
54  return ObjectSpec::Get(GetObjectType(tile));
55 }
56 
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 
72 {
73  return this->IsEverAvailable() && _date > this->introduction_date;
74 }
75 
81 {
82  return this->WasEverAvailable() &&
83  (_date < this->end_of_life_date || this->end_of_life_date < this->introduction_date + 365);
84 }
85 
90 uint ObjectSpec::Index() const
91 {
92  return this - _object_specs;
93 }
94 
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>
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>
125 {
126  return this->GetSpec(index)->IsEverAvailable();
127 }
128 
130 
131 /* virtual */ uint32 ObjectScopeResolver::GetRandomBits() const
132 {
133  return IsValidTile(this->tile) && IsTileType(this->tile, MP_OBJECT) ? GetObjectRandomBits(this->tile) : 0;
134 }
135 
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 
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 
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 
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 
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 
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) ?
361 }
362 
363 ObjectResolverObject::~ObjectResolverObject()
364 {
365  delete this->town_scope;
366 }
367 
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 
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 
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 
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 
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;
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 
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 
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 
517 {
518  const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
519  if (spec == NULL || !(spec->flags & OBJECT_FLAG_ANIMATION)) return;
520 
522 }
523 
532 {
533  if (!HasBit(spec->animation.triggers, trigger)) return;
534 
536 }
537 
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 }