00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "stdafx.h"
00013 #include "company_base.h"
00014 #include "company_func.h"
00015 #include "debug.h"
00016 #include "genworld.h"
00017 #include "newgrf_class_func.h"
00018 #include "newgrf_object.h"
00019 #include "newgrf_sound.h"
00020 #include "object_base.h"
00021 #include "object_map.h"
00022 #include "tile_cmd.h"
00023 #include "town.h"
00024 #include "water.h"
00025 #include "newgrf_animation_base.h"
00026
00028 ObjectOverrideManager _object_mngr(NEW_OBJECT_OFFSET, NUM_OBJECTS, INVALID_OBJECT_TYPE);
00029
00030 extern const ObjectSpec _original_objects[NEW_OBJECT_OFFSET];
00032 ObjectSpec _object_specs[NUM_OBJECTS];
00033
00039 const ObjectSpec *ObjectSpec::Get(ObjectType index)
00040 {
00041 assert(index < NUM_OBJECTS);
00042 return &_object_specs[index];
00043 }
00044
00050 const ObjectSpec *ObjectSpec::GetByTile(TileIndex tile)
00051 {
00052 return ObjectSpec::Get(GetObjectType(tile));
00053 }
00054
00059 bool ObjectSpec::IsEverAvailable() const
00060 {
00061 return this->enabled && HasBit(this->climate, _settings_game.game_creation.landscape) &&
00062 (this->flags & ((_game_mode != GM_EDITOR && !_generating_world) ? OBJECT_FLAG_ONLY_IN_SCENEDIT : OBJECT_FLAG_ONLY_IN_GAME)) == 0;
00063 }
00064
00069 bool ObjectSpec::WasEverAvailable() const
00070 {
00071 return this->IsEverAvailable() && _date > this->introduction_date;
00072 }
00073
00078 bool ObjectSpec::IsAvailable() const
00079 {
00080 return this->WasEverAvailable() &&
00081 (_date < this->end_of_life_date || this->end_of_life_date < this->introduction_date + 365);
00082 }
00083
00088 uint ObjectSpec::Index() const
00089 {
00090 return this - _object_specs;
00091 }
00092
00094 void ResetObjects()
00095 {
00096
00097 MemSetT(_object_specs, 0, lengthof(_object_specs));
00098
00099
00100 MemCpyT(_object_specs, _original_objects, lengthof(_original_objects));
00101
00102 for (uint16 i = 0; i < lengthof(_original_objects); i++) {
00103 _object_specs[i].grf_prop.local_id = i;
00104 }
00105 }
00106
00107 template <typename Tspec, typename Tid, Tid Tmax>
00108 void NewGRFClass<Tspec, Tid, Tmax>::InsertDefaults()
00109 {
00110 ObjectClassID cls = ObjectClass::Allocate('LTHS');
00111 ObjectClass::Get(cls)->name = STR_OBJECT_CLASS_LTHS;
00112 _object_specs[OBJECT_LIGHTHOUSE].cls_id = cls;
00113 ObjectClass::Assign(&_object_specs[OBJECT_LIGHTHOUSE]);
00114
00115 cls = ObjectClass::Allocate('TRNS');
00116 ObjectClass::Get(cls)->name = STR_OBJECT_CLASS_TRNS;
00117 _object_specs[OBJECT_TRANSMITTER].cls_id = cls;
00118 ObjectClass::Assign(&_object_specs[OBJECT_TRANSMITTER]);
00119 }
00120
00121 template <typename Tspec, typename Tid, Tid Tmax>
00122 bool NewGRFClass<Tspec, Tid, Tmax>::IsUIAvailable(uint index) const
00123 {
00124 return this->GetSpec(index)->IsEverAvailable();
00125 }
00126
00127 INSTANTIATE_NEWGRF_CLASS_METHODS(ObjectClass, ObjectSpec, ObjectClassID, OBJECT_CLASS_MAX)
00128
00129
00136 ObjectScopeResolver::ObjectScopeResolver(ResolverObject &ro, Object *obj, TileIndex tile, uint8 view)
00137 : ScopeResolver(ro)
00138 {
00139 this->obj = obj;
00140 this->tile = tile;
00141 this->view = view;
00142 }
00143
00144 uint32 ObjectScopeResolver::GetRandomBits() const
00145 {
00146 return IsValidTile(this->tile) && IsTileType(this->tile, MP_OBJECT) ? GetObjectRandomBits(this->tile) : 0;
00147 }
00148
00155 static uint32 GetObjectIDAtOffset(TileIndex tile, uint32 cur_grfid)
00156 {
00157 if (!IsTileType(tile, MP_OBJECT)) {
00158 return 0xFFFF;
00159 }
00160
00161 const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
00162
00163
00164 if (spec->grf_prop.grffile == NULL) {
00165 return 0xFFFE;
00166 }
00167
00168 if (spec->grf_prop.grffile->grfid == cur_grfid) {
00169 return spec->grf_prop.local_id;
00170 }
00171
00172 return 0xFFFE;
00173 }
00174
00183 static uint32 GetNearbyObjectTileInformation(byte parameter, TileIndex tile, ObjectID index, bool grf_version8)
00184 {
00185 if (parameter != 0) tile = GetNearbyTile(parameter, tile);
00186 bool is_same_object = (IsTileType(tile, MP_OBJECT) && GetObjectIndex(tile) == index);
00187
00188 return GetNearbyTileInformation(tile, grf_version8) | (is_same_object ? 1 : 0) << 8;
00189 }
00190
00198 static uint32 GetClosestObject(TileIndex tile, ObjectType type, const Object *current)
00199 {
00200 uint32 best_dist = UINT32_MAX;
00201 const Object *o;
00202 FOR_ALL_OBJECTS(o) {
00203 if (o->type != type || o == current) continue;
00204
00205 best_dist = min(best_dist, DistanceManhattan(tile, o->location.tile));
00206 }
00207
00208 return best_dist;
00209 }
00210
00219 static uint32 GetCountAndDistanceOfClosestInstance(byte local_id, uint32 grfid, TileIndex tile, const Object *current)
00220 {
00221 uint32 grf_id = GetRegister(0x100);
00222 uint32 idx;
00223
00224
00225 switch (grf_id) {
00226 case 0:
00227 idx = local_id;
00228 break;
00229
00230 case 0xFFFFFFFF:
00231 grf_id = grfid;
00232
00233
00234 default:
00235 idx = _object_mngr.GetID(local_id, grf_id);
00236 break;
00237 }
00238
00239
00240 if (idx >= NUM_OBJECTS) return 0 | 0xFFFF;
00241
00242 return Object::GetTypeCount(idx) << 16 | min(GetClosestObject(tile, idx, current), 0xFFFF);
00243 }
00244
00246 uint32 ObjectScopeResolver::GetVariable(byte variable, uint32 parameter, bool *available) const
00247 {
00248
00249
00250 const Town *t = NULL;
00251
00252 if (this->obj == NULL) {
00253 switch (variable) {
00254
00255 case 0x41:
00256 case 0x60:
00257 case 0x61:
00258 case 0x62:
00259 case 0x64:
00260 break;
00261
00262
00263 case 0x45:
00264 case 0x46:
00265 if (!IsValidTile(this->tile)) goto unhandled;
00266 t = ClosestTownFromTile(this->tile, UINT_MAX);
00267 break;
00268
00269
00270 case 0x42: return _date;
00271
00272
00273 case 0x44: return _current_company;
00274
00275
00276 case 0x48: return this->view;
00277
00278
00279
00280
00281
00282
00283
00284
00285 default:
00286 goto unhandled;
00287 }
00288
00289
00290 if (!IsValidTile(this->tile)) goto unhandled;
00291 } else {
00292 t = this->obj->town;
00293 }
00294
00295 switch (variable) {
00296
00297 case 0x40: {
00298 uint offset = this->tile - this->obj->location.tile;
00299 uint offset_x = TileX(offset);
00300 uint offset_y = TileY(offset);
00301 return offset_y << 20 | offset_x << 16 | offset_y << 8 | offset_x;
00302 }
00303
00304
00305 case 0x41: return GetTileSlope(this->tile) << 8 | GetTerrainType(this->tile);
00306
00307
00308 case 0x42: return this->obj->build_date;
00309
00310
00311 case 0x43: return GetAnimationFrame(this->tile);
00312
00313
00314 case 0x44: return GetTileOwner(this->tile);
00315
00316
00317 case 0x45: return GetTownRadiusGroup(t, this->tile) << 16 | min(DistanceManhattan(this->tile, t->xy), 0xFFFF);
00318
00319
00320 case 0x46: return GetTownRadiusGroup(t, this->tile) << 16 | min(DistanceSquare(this->tile, t->xy), 0xFFFF);
00321
00322
00323 case 0x47: return this->obj->colour;
00324
00325
00326 case 0x48: return this->obj->view;
00327
00328
00329 case 0x60: return GetObjectIDAtOffset(GetNearbyTile(parameter, this->tile), this->ro.grffile->grfid);
00330
00331
00332 case 0x61: {
00333 TileIndex tile = GetNearbyTile(parameter, this->tile);
00334 return (IsTileType(tile, MP_OBJECT) && Object::GetByTile(tile) == this->obj) ? GetObjectRandomBits(tile) : 0;
00335 }
00336
00337
00338 case 0x62: return GetNearbyObjectTileInformation(parameter, this->tile, this->obj == NULL ? INVALID_OBJECT : this->obj->index, this->ro.grffile->grf_version >= 8);
00339
00340
00341 case 0x63: {
00342 TileIndex tile = GetNearbyTile(parameter, this->tile);
00343 return (IsTileType(tile, MP_OBJECT) && Object::GetByTile(tile) == this->obj) ? GetAnimationFrame(tile) : 0;
00344 }
00345
00346
00347 case 0x64: return GetCountAndDistanceOfClosestInstance(parameter, this->ro.grffile->grfid, this->tile, this->obj);
00348 }
00349
00350 unhandled:
00351 DEBUG(grf, 1, "Unhandled object variable 0x%X", variable);
00352
00353 *available = false;
00354 return UINT_MAX;
00355 }
00356
00363 static const SpriteGroup *GetObjectSpriteGroup(const ObjectSpec *spec, const Object *o)
00364 {
00365 const SpriteGroup *group = NULL;
00366
00367 if (o == NULL) group = spec->grf_prop.spritegroup[CT_PURCHASE_OBJECT];
00368 if (group != NULL) return group;
00369
00370
00371 return spec->grf_prop.spritegroup[0];
00372
00373 }
00374
00384 ObjectResolverObject::ObjectResolverObject(const ObjectSpec *spec, Object *obj, TileIndex tile, uint8 view,
00385 CallbackID callback, uint32 param1, uint32 param2)
00386 : ResolverObject(spec->grf_prop.grffile, callback, param1, param2), object_scope(*this, obj, tile, view)
00387 {
00388 this->town_scope = NULL;
00389 }
00390
00391 ObjectResolverObject::~ObjectResolverObject()
00392 {
00393 delete this->town_scope;
00394 }
00395
00401 TownScopeResolver *ObjectResolverObject::GetTown()
00402 {
00403 if (this->town_scope == NULL) {
00404 Town *t;
00405 if (this->object_scope.obj != NULL) {
00406 t = this->object_scope.obj->town;
00407 } else {
00408 t = ClosestTownFromTile(this->object_scope.tile, UINT_MAX);
00409 }
00410 if (t == NULL) return NULL;
00411 this->town_scope = new TownScopeResolver(*this, t, this->object_scope.obj == NULL);
00412 }
00413 return this->town_scope;
00414 }
00415
00427 uint16 GetObjectCallback(CallbackID callback, uint32 param1, uint32 param2, const ObjectSpec *spec, Object *o, TileIndex tile, uint8 view)
00428 {
00429 ObjectResolverObject object(spec, o, tile, view, callback, param1, param2);
00430 const SpriteGroup *group = SpriteGroup::Resolve(GetObjectSpriteGroup(spec, o), object);
00431 if (group == NULL) return CALLBACK_FAILED;
00432
00433 return group->GetCallbackResult();
00434 }
00435
00442 static void DrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, const ObjectSpec *spec)
00443 {
00444 const DrawTileSprites *dts = group->ProcessRegisters(NULL);
00445 PaletteID palette = ((spec->flags & OBJECT_FLAG_2CC_COLOUR) ? SPR_2CCMAP_BASE : PALETTE_RECOLOUR_START) + Object::GetByTile(ti->tile)->colour;
00446
00447 SpriteID image = dts->ground.sprite;
00448 PaletteID pal = dts->ground.pal;
00449
00450 if (GB(image, 0, SPRITE_WIDTH) != 0) {
00451
00452
00453 if ((image == SPR_FLAT_WATER_TILE || spec->flags & OBJECT_FLAG_DRAW_WATER) && IsTileOnWater(ti->tile)) {
00454 DrawWaterClassGround(ti);
00455 } else {
00456 DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, palette));
00457 }
00458 }
00459
00460 DrawNewGRFTileSeq(ti, dts, TO_STRUCTURES, 0, palette);
00461 }
00462
00468 void DrawNewObjectTile(TileInfo *ti, const ObjectSpec *spec)
00469 {
00470 Object *o = Object::GetByTile(ti->tile);
00471 ObjectResolverObject object(spec, o, ti->tile);
00472
00473 const SpriteGroup *group = SpriteGroup::Resolve(GetObjectSpriteGroup(spec, o), object);
00474 if (group == NULL || group->type != SGT_TILELAYOUT) return;
00475
00476 DrawTileLayout(ti, (const TileLayoutSpriteGroup *)group, spec);
00477 }
00478
00486 void DrawNewObjectTileInGUI(int x, int y, const ObjectSpec *spec, uint8 view)
00487 {
00488 ObjectResolverObject object(spec, NULL, INVALID_TILE, view);
00489 const SpriteGroup *group = SpriteGroup::Resolve(GetObjectSpriteGroup(spec, NULL), object);
00490 if (group == NULL || group->type != SGT_TILELAYOUT) return;
00491
00492 const DrawTileSprites *dts = ((const TileLayoutSpriteGroup *)group)->ProcessRegisters(NULL);
00493
00494 PaletteID palette;
00495 if (Company::IsValidID(_local_company)) {
00496
00497 if (spec->flags & OBJECT_FLAG_2CC_COLOUR) {
00498 const Livery *l = Company::Get(_local_company)->livery;
00499 palette = SPR_2CCMAP_BASE + l->colour1 + l->colour2 * 16;
00500 } else {
00501 palette = COMPANY_SPRITE_COLOUR(_local_company);
00502 }
00503 } else {
00504
00505 palette = (spec->flags & OBJECT_FLAG_2CC_COLOUR) ? SPR_2CCMAP_BASE : PALETTE_RECOLOUR_START;
00506 }
00507
00508 SpriteID image = dts->ground.sprite;
00509 PaletteID pal = dts->ground.pal;
00510
00511 if (GB(image, 0, SPRITE_WIDTH) != 0) {
00512 DrawSprite(image, GroundSpritePaletteTransform(image, pal, palette), x, y);
00513 }
00514
00515 DrawNewGRFTileSeqInGUI(x, y, dts, 0, palette);
00516 }
00517
00529 uint16 StubGetObjectCallback(CallbackID callback, uint32 param1, uint32 param2, const ObjectSpec *spec, Object *o, TileIndex tile, int extra_data)
00530 {
00531 return GetObjectCallback(callback, param1, param2, spec, o, tile);
00532 }
00533
00535 struct ObjectAnimationBase : public AnimationBase<ObjectAnimationBase, ObjectSpec, Object, int, StubGetObjectCallback> {
00536 static const CallbackID cb_animation_speed = CBID_OBJECT_ANIMATION_SPEED;
00537 static const CallbackID cb_animation_next_frame = CBID_OBJECT_ANIMATION_NEXT_FRAME;
00538
00539 static const ObjectCallbackMask cbm_animation_speed = CBM_OBJ_ANIMATION_SPEED;
00540 static const ObjectCallbackMask cbm_animation_next_frame = CBM_OBJ_ANIMATION_NEXT_FRAME;
00541 };
00542
00547 void AnimateNewObjectTile(TileIndex tile)
00548 {
00549 const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
00550 if (spec == NULL || !(spec->flags & OBJECT_FLAG_ANIMATION)) return;
00551
00552 ObjectAnimationBase::AnimateTile(spec, Object::GetByTile(tile), tile, (spec->flags & OBJECT_FLAG_ANIM_RANDOM_BITS) != 0);
00553 }
00554
00562 void TriggerObjectTileAnimation(Object *o, TileIndex tile, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
00563 {
00564 if (!HasBit(spec->animation.triggers, trigger)) return;
00565
00566 ObjectAnimationBase::ChangeAnimationFrame(CBID_OBJECT_ANIMATION_START_STOP, spec, o, tile, Random(), trigger);
00567 }
00568
00575 void TriggerObjectAnimation(Object *o, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
00576 {
00577 if (!HasBit(spec->animation.triggers, trigger)) return;
00578
00579 TILE_AREA_LOOP(tile, o->location) {
00580 TriggerObjectTileAnimation(o, tile, trigger, spec);
00581 }
00582 }