src/table/newgrf_debug_data.h

   1 /* $Id: newgrf_debug_data.h 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_debug_data.h Data 'tables' for NewGRF debugging. */
  11
  12 #include "../newgrf_house.h"
  13 #include "../newgrf_engine.h"
  14
  15 /* Helper for filling property tables */
  16 #define NIP(prop, base, variable, type, name) { name, (ptrdiff_t)cpp_offsetof(base, variable), cpp_sizeof(base, variable), prop, type }
  17 #define NIP_END() { nullptr, 0, 0, 0, 0 }
  18
  19 /* Helper for filling callback tables */
  20 #define NIC(cb_id, base, variable, bit) { #cb_id, (ptrdiff_t)cpp_offsetof(base, variable), cpp_sizeof(base, variable), bit, cb_id }
  21 #define NIC_END() { nullptr, 0, 0, 0, 0 }
  22
  23 /* Helper for filling variable tables */
  24 #define NIV(var, name) { name, var }
  25 #define NIV_END() { nullptr, 0 }
  26
  27
  28 /*** NewGRF Vehicles ***/
  29
  30 #define NICV(cb_id, bit) NIC(cb_id, Engine, info.callback_mask, bit)
  31 static const NICallback _nic_vehicles[] = {
  32         NICV(CBID_VEHICLE_VISUAL_EFFECT,         CBM_VEHICLE_VISUAL_EFFECT),
  33         NICV(CBID_VEHICLE_LENGTH,                CBM_VEHICLE_LENGTH),
  34         NICV(CBID_VEHICLE_LOAD_AMOUNT,           CBM_VEHICLE_LOAD_AMOUNT),
  35         NICV(CBID_VEHICLE_REFIT_CAPACITY,        CBM_VEHICLE_REFIT_CAPACITY),
  36         NICV(CBID_VEHICLE_ARTIC_ENGINE,          CBM_VEHICLE_ARTIC_ENGINE),
  37         NICV(CBID_VEHICLE_CARGO_SUFFIX,          CBM_VEHICLE_CARGO_SUFFIX),
  38         NICV(CBID_TRAIN_ALLOW_WAGON_ATTACH,      CBM_NO_BIT),
  39         NICV(CBID_VEHICLE_ADDITIONAL_TEXT,       CBM_NO_BIT),
  40         NICV(CBID_VEHICLE_COLOUR_MAPPING,        CBM_VEHICLE_COLOUR_REMAP),
  41         NICV(CBID_VEHICLE_START_STOP_CHECK,      CBM_NO_BIT),
  42         NICV(CBID_VEHICLE_32DAY_CALLBACK,        CBM_NO_BIT),
  43         NICV(CBID_VEHICLE_SOUND_EFFECT,          CBM_VEHICLE_SOUND_EFFECT),
  44         NICV(CBID_VEHICLE_AUTOREPLACE_SELECTION, CBM_NO_BIT),
  45         NICV(CBID_VEHICLE_MODIFY_PROPERTY,       CBM_NO_BIT),
  46         NIC_END()
  47 };
  48
  49
  50 static const NIVariable _niv_vehicles[] = {
  51         NIV(0x40, "position in consist and length"),
  52         NIV(0x41, "position and length of chain of same vehicles"),
  53         NIV(0x42, "transported cargo types"),
  54         NIV(0x43, "player info"),
  55         NIV(0x44, "aircraft info"),
  56         NIV(0x45, "curvature info"),
  57         NIV(0x46, "motion counter"),
  58         NIV(0x47, "vehicle cargo info"),
  59         NIV(0x48, "vehicle type info"),
  60         NIV(0x49, "year of construction"),
  61         NIV(0x4A, "current rail type info"),
  62         NIV(0x4B, "long date of last service"),
  63         NIV(0x4C, "current max speed"),
  64         NIV(0x4D, "position in articulated vehicle"),
  65         NIV(0x60, "count vehicle id occurrences"),
  66         // 0x61 not useful, since it requires register 0x10F
  67         NIV(0x62, "Curvature/position difference to other vehicle"),
  68         NIV_END()
  69 };
  70
  71 class NIHVehicle : public NIHelper {
  72         bool IsInspectable(uint index) const                 { return Vehicle::Get(index)->GetGRF() != nullptr; }
  73         uint GetParent(uint index) const                     { const Vehicle *first = Vehicle::Get(index)->First(); return GetInspectWindowNumber(GetGrfSpecFeature(first->type), first->index); }
  74         const void *GetInstance(uint index)const             { return Vehicle::Get(index); }
  75         const void *GetSpec(uint index) const                { return Vehicle::Get(index)->GetEngine(); }
  76         void SetStringParameters(uint index) const           { this->SetSimpleStringParameters(STR_VEHICLE_NAME, index); }
  77         uint32 GetGRFID(uint index) const                    { return Vehicle::Get(index)->GetGRFID(); }
  78
  79         /* virtual */ uint Resolve(uint index, uint var, uint param, bool *avail) const
  80         {
  81                 Vehicle *v = Vehicle::Get(index);
  82                 VehicleResolverObject ro(v->engine_type, v, VehicleResolverObject::WO_CACHED);
  83                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
  84         }
  85 };
  86
  87 static const NIFeature _nif_vehicle = {
  88         nullptr,
  89         _nic_vehicles,
  90         _niv_vehicles,
  91         new NIHVehicle(),
  92 };
  93
  94
  95 /*** NewGRF station (tiles) ***/
  96
  97 #define NICS(cb_id, bit) NIC(cb_id, StationSpec, callback_mask, bit)
  98 static const NICallback _nic_stations[] = {
  99         NICS(CBID_STATION_AVAILABILITY,     CBM_STATION_AVAIL),
 100         NICS(CBID_STATION_SPRITE_LAYOUT,    CBM_STATION_SPRITE_LAYOUT),
 101         NICS(CBID_STATION_TILE_LAYOUT,      CBM_NO_BIT),
 102         NICS(CBID_STATION_ANIM_START_STOP,  CBM_NO_BIT),
 103         NICS(CBID_STATION_ANIM_NEXT_FRAME,  CBM_STATION_ANIMATION_NEXT_FRAME),
 104         NICS(CBID_STATION_ANIMATION_SPEED,  CBM_STATION_ANIMATION_SPEED),
 105         NICS(CBID_STATION_LAND_SLOPE_CHECK, CBM_STATION_SLOPE_CHECK),
 106         NIC_END()
 107 };
 108
 109 static const NIVariable _niv_stations[] = {
 110         NIV(0x40, "platform info and relative position"),
 111         NIV(0x41, "platform info and relative position for individually built sections"),
 112         NIV(0x42, "terrain and track type"),
 113         NIV(0x43, "player info"),
 114         NIV(0x44, "path signalling info"),
 115         NIV(0x45, "rail continuation info"),
 116         NIV(0x46, "platform info and relative position from middle"),
 117         NIV(0x47, "platform info and relative position from middle for individually built sections"),
 118         NIV(0x48, "bitmask of accepted cargoes"),
 119         NIV(0x49, "platform info and relative position of same-direction section"),
 120         NIV(0x4A, "current animation frame"),
 121         NIV(0x60, "amount of cargo waiting"),
 122         NIV(0x61, "time since last cargo pickup"),
 123         NIV(0x62, "rating of cargo"),
 124         NIV(0x63, "time spent on route"),
 125         NIV(0x64, "information about last vehicle picking cargo up"),
 126         NIV(0x65, "amount of cargo acceptance"),
 127         NIV(0x66, "animation frame of nearby tile"),
 128         NIV(0x67, "land info of nearby tiles"),
 129         NIV(0x68, "station info of nearby tiles"),
 130         NIV(0x69, "information about cargo accepted in the past"),
 131         NIV_END()
 132 };
 133
 134 class NIHStation : public NIHelper {
 135         bool IsInspectable(uint index) const                 { return GetStationSpec(index) != nullptr; }
 136         uint GetParent(uint index) const                     { return GetInspectWindowNumber(GSF_FAKE_TOWNS, Station::GetByTile(index)->town->index); }
 137         const void *GetInstance(uint index)const             { return nullptr; }
 138         const void *GetSpec(uint index) const                { return GetStationSpec(index); }
 139         void SetStringParameters(uint index) const           { this->SetObjectAtStringParameters(STR_STATION_NAME, GetStationIndex(index), index); }
 140         uint32 GetGRFID(uint index) const                    { return (this->IsInspectable(index)) ? GetStationSpec(index)->grf_prop.grffile->grfid : 0; }
 141
 142         /* virtual */ uint Resolve(uint index, uint var, uint param, bool *avail) const
 143         {
 144                 StationResolverObject ro(GetStationSpec(index), Station::GetByTile(index), index);
 145                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 146         }
 147 };
 148
 149 static const NIFeature _nif_station = {
 150         nullptr,
 151         _nic_stations,
 152         _niv_stations,
 153         new NIHStation(),
 154 };
 155
 156
 157 /*** NewGRF house tiles ***/
 158
 159 #define NICH(cb_id, bit) NIC(cb_id, HouseSpec, callback_mask, bit)
 160 static const NICallback _nic_house[] = {
 161         NICH(CBID_HOUSE_ALLOW_CONSTRUCTION,        CBM_HOUSE_ALLOW_CONSTRUCTION),
 162         NICH(CBID_HOUSE_ANIMATION_NEXT_FRAME,      CBM_HOUSE_ANIMATION_NEXT_FRAME),
 163         NICH(CBID_HOUSE_ANIMATION_START_STOP,      CBM_HOUSE_ANIMATION_START_STOP),
 164         NICH(CBID_HOUSE_CONSTRUCTION_STATE_CHANGE, CBM_HOUSE_CONSTRUCTION_STATE_CHANGE),
 165         NICH(CBID_HOUSE_COLOUR,                    CBM_HOUSE_COLOUR),
 166         NICH(CBID_HOUSE_CARGO_ACCEPTANCE,          CBM_HOUSE_CARGO_ACCEPTANCE),
 167         NICH(CBID_HOUSE_ANIMATION_SPEED,           CBM_HOUSE_ANIMATION_SPEED),
 168         NICH(CBID_HOUSE_DESTRUCTION,               CBM_HOUSE_DESTRUCTION),
 169         NICH(CBID_HOUSE_ACCEPT_CARGO,              CBM_HOUSE_ACCEPT_CARGO),
 170         NICH(CBID_HOUSE_PRODUCE_CARGO,             CBM_HOUSE_PRODUCE_CARGO),
 171         NICH(CBID_HOUSE_DENY_DESTRUCTION,          CBM_HOUSE_DENY_DESTRUCTION),
 172         NICH(CBID_HOUSE_WATCHED_CARGO_ACCEPTED,    CBM_NO_BIT),
 173         NICH(CBID_HOUSE_CUSTOM_NAME,               CBM_NO_BIT),
 174         NICH(CBID_HOUSE_DRAW_FOUNDATIONS,          CBM_HOUSE_DRAW_FOUNDATIONS),
 175         NICH(CBID_HOUSE_AUTOSLOPE,                 CBM_HOUSE_AUTOSLOPE),
 176         NIC_END()
 177 };
 178
 179 static const NIVariable _niv_house[] = {
 180         NIV(0x40, "construction state of tile and pseudo-random value"),
 181         NIV(0x41, "age of building in years"),
 182         NIV(0x42, "town zone"),
 183         NIV(0x43, "terrain type"),
 184         NIV(0x44, "building counts"),
 185         NIV(0x45, "town expansion bits"),
 186         NIV(0x46, "current animation frame"),
 187         NIV(0x47, "xy coordinate of the building"),
 188         NIV(0x60, "other building counts (old house type)"),
 189         NIV(0x61, "other building counts (new house type)"),
 190         NIV(0x62, "land info of nearby tiles"),
 191         NIV(0x63, "current animation frame of nearby house tile"),
 192         NIV(0x64, "cargo acceptance history of nearby stations"),
 193         NIV(0x65, "distance of nearest house matching a given criterion"),
 194         NIV(0x66, "class and ID of nearby house tile"),
 195         NIV(0x67, "GRFID of nearby house tile"),
 196         NIV_END()
 197 };
 198
 199 class NIHHouse : public NIHelper {
 200         bool IsInspectable(uint index) const                 { return HouseSpec::Get(GetHouseType(index))->grf_prop.grffile != nullptr; }
 201         uint GetParent(uint index) const                     { return GetInspectWindowNumber(GSF_FAKE_TOWNS, GetTownIndex(index)); }
 202         const void *GetInstance(uint index)const             { return nullptr; }
 203         const void *GetSpec(uint index) const                { return HouseSpec::Get(GetHouseType(index)); }
 204         void SetStringParameters(uint index) const           { this->SetObjectAtStringParameters(STR_TOWN_NAME, GetTownIndex(index), index); }
 205         uint32 GetGRFID(uint index) const                    { return (this->IsInspectable(index)) ? HouseSpec::Get(GetHouseType(index))->grf_prop.grffile->grfid : 0; }
 206
 207         /* virtual */ uint Resolve(uint index, uint var, uint param, bool *avail) const
 208         {
 209                 HouseResolverObject ro(GetHouseType(index), index, Town::GetByTile(index));
 210                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 211         }
 212 };
 213
 214 static const NIFeature _nif_house = {
 215         nullptr,
 216         _nic_house,
 217         _niv_house,
 218         new NIHHouse(),
 219 };
 220
 221
 222 /*** NewGRF industry tiles ***/
 223
 224 #define NICIT(cb_id, bit) NIC(cb_id, IndustryTileSpec, callback_mask, bit)
 225 static const NICallback _nic_industrytiles[] = {
 226         NICIT(CBID_INDTILE_ANIM_START_STOP,  CBM_NO_BIT),
 227         NICIT(CBID_INDTILE_ANIM_NEXT_FRAME,  CBM_INDT_ANIM_NEXT_FRAME),
 228         NICIT(CBID_INDTILE_ANIMATION_SPEED,  CBM_INDT_ANIM_SPEED),
 229         NICIT(CBID_INDTILE_CARGO_ACCEPTANCE, CBM_INDT_CARGO_ACCEPTANCE),
 230         NICIT(CBID_INDTILE_ACCEPT_CARGO,     CBM_INDT_ACCEPT_CARGO),
 231         NICIT(CBID_INDTILE_SHAPE_CHECK,      CBM_INDT_SHAPE_CHECK),
 232         NICIT(CBID_INDTILE_DRAW_FOUNDATIONS, CBM_INDT_DRAW_FOUNDATIONS),
 233         NICIT(CBID_INDTILE_AUTOSLOPE,        CBM_INDT_AUTOSLOPE),
 234         NIC_END()
 235 };
 236
 237 static const NIVariable _niv_industrytiles[] = {
 238         NIV(0x40, "construction state of tile"),
 239         NIV(0x41, "ground type"),
 240         NIV(0x42, "current town zone in nearest town"),
 241         NIV(0x43, "relative position"),
 242         NIV(0x44, "animation frame"),
 243         NIV(0x60, "land info of nearby tiles"),
 244         NIV(0x61, "animation stage of nearby tiles"),
 245         NIV(0x62, "get industry or airport tile ID at offset"),
 246         NIV_END()
 247 };
 248
 249 class NIHIndustryTile : public NIHelper {
 250         bool IsInspectable(uint index) const                 { return GetIndustryTileSpec(GetIndustryGfx(index))->grf_prop.grffile != nullptr; }
 251         uint GetParent(uint index) const                     { return GetInspectWindowNumber(GSF_INDUSTRIES, GetIndustryIndex(index)); }
 252         const void *GetInstance(uint index)const             { return nullptr; }
 253         const void *GetSpec(uint index) const                { return GetIndustryTileSpec(GetIndustryGfx(index)); }
 254         void SetStringParameters(uint index) const           { this->SetObjectAtStringParameters(STR_INDUSTRY_NAME, GetIndustryIndex(index), index); }
 255         uint32 GetGRFID(uint index) const                    { return (this->IsInspectable(index)) ? GetIndustryTileSpec(GetIndustryGfx(index))->grf_prop.grffile->grfid : 0; }
 256
 257         /* virtual */ uint Resolve(uint index, uint var, uint param, bool *avail) const
 258         {
 259                 IndustryTileResolverObject ro(GetIndustryGfx(index), index, Industry::GetByTile(index));
 260                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 261         }
 262 };
 263
 264 static const NIFeature _nif_industrytile = {
 265         nullptr,
 266         _nic_industrytiles,
 267         _niv_industrytiles,
 268         new NIHIndustryTile(),
 269 };
 270
 271
 272 /*** NewGRF industries ***/
 273
 274 static const NIProperty _nip_industries[] = {
 275         NIP(0x10, Industry, produced_cargo[0], NIT_CARGO, "produced cargo 0"),
 276         NIP(0x10, Industry, produced_cargo[1], NIT_CARGO, "produced cargo 1"),
 277         NIP(0x11, Industry, accepts_cargo[0],  NIT_CARGO, "accepted cargo 0"),
 278         NIP(0x11, Industry, accepts_cargo[1],  NIT_CARGO, "accepted cargo 1"),
 279         NIP(0x11, Industry, accepts_cargo[2],  NIT_CARGO, "accepted cargo 2"),
 280         NIP_END()
 281 };
 282
 283 #define NICI(cb_id, bit) NIC(cb_id, IndustrySpec, callback_mask, bit)
 284 static const NICallback _nic_industries[] = {
 285         NICI(CBID_INDUSTRY_PROBABILITY,          CBM_IND_PROBABILITY),
 286         NICI(CBID_INDUSTRY_LOCATION,             CBM_IND_LOCATION),
 287         NICI(CBID_INDUSTRY_PRODUCTION_CHANGE,    CBM_IND_PRODUCTION_CHANGE),
 288         NICI(CBID_INDUSTRY_MONTHLYPROD_CHANGE,   CBM_IND_MONTHLYPROD_CHANGE),
 289         NICI(CBID_INDUSTRY_CARGO_SUFFIX,         CBM_IND_CARGO_SUFFIX),
 290         NICI(CBID_INDUSTRY_FUND_MORE_TEXT,       CBM_IND_FUND_MORE_TEXT),
 291         NICI(CBID_INDUSTRY_WINDOW_MORE_TEXT,     CBM_IND_WINDOW_MORE_TEXT),
 292         NICI(CBID_INDUSTRY_SPECIAL_EFFECT,       CBM_IND_SPECIAL_EFFECT),
 293         NICI(CBID_INDUSTRY_REFUSE_CARGO,         CBM_IND_REFUSE_CARGO),
 294         NICI(CBID_INDUSTRY_DECIDE_COLOUR,        CBM_IND_DECIDE_COLOUR),
 295         NICI(CBID_INDUSTRY_INPUT_CARGO_TYPES,    CBM_IND_INPUT_CARGO_TYPES),
 296         NICI(CBID_INDUSTRY_OUTPUT_CARGO_TYPES,   CBM_IND_OUTPUT_CARGO_TYPES),
 297         NICI(CBID_INDUSTRY_PROD_CHANGE_BUILD,    CBM_IND_PROD_CHANGE_BUILD),
 298         NIC_END()
 299 };
 300
 301 static const NIVariable _niv_industries[] = {
 302         NIV(0x40, "waiting cargo 0"),
 303         NIV(0x41, "waiting cargo 1"),
 304         NIV(0x42, "waiting cargo 2"),
 305         NIV(0x43, "distance to closest dry/land tile"),
 306         NIV(0x44, "layout number"),
 307         NIV(0x45, "player info"),
 308         NIV(0x46, "industry construction date"),
 309         NIV(0x60, "get industry tile ID at offset"),
 310         NIV(0x61, "get random tile bits at offset"),
 311         NIV(0x62, "land info of nearby tiles"),
 312         NIV(0x63, "animation stage of nearby tiles"),
 313         NIV(0x64, "distance on nearest industry with given type"),
 314         NIV(0x65, "get town zone and Manhattan distance of closest town"),
 315         NIV(0x66, "get square of Euclidean distance of closes town"),
 316         NIV(0x67, "count of industry and distance of closest instance"),
 317         NIV(0x68, "count of industry and distance of closest instance with layout filter"),
 318         NIV_END()
 319 };
 320
 321 class NIHIndustry : public NIHelper {
 322         bool IsInspectable(uint index) const                 { return GetIndustrySpec(Industry::Get(index)->type)->grf_prop.grffile != nullptr; }
 323         uint GetParent(uint index) const                     { return GetInspectWindowNumber(GSF_FAKE_TOWNS, Industry::Get(index)->town->index); }
 324         const void *GetInstance(uint index)const             { return Industry::Get(index); }
 325         const void *GetSpec(uint index) const                { return GetIndustrySpec(Industry::Get(index)->type); }
 326         void SetStringParameters(uint index) const           { this->SetSimpleStringParameters(STR_INDUSTRY_NAME, index); }
 327         uint32 GetGRFID(uint index) const                    { return (this->IsInspectable(index)) ? GetIndustrySpec(Industry::Get(index)->type)->grf_prop.grffile->grfid : 0; }
 328
 329         /* virtual */ uint Resolve(uint index, uint var, uint param, bool *avail) const
 330         {
 331                 Industry *i = Industry::Get(index);
 332                 IndustriesResolverObject ro(i->location.tile, i, i->type);
 333                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 334         }
 335
 336         uint GetPSASize(uint index, uint32 grfid) const      { return cpp_lengthof(PersistentStorage, storage); }
 337
 338         const int32 *GetPSAFirstPosition(uint index, uint32 grfid) const
 339         {
 340                 const Industry *i = (const Industry *)this->GetInstance(index);
 341                 if (i->psa == nullptr) return nullptr;
 342                 return (int32 *)(&i->psa->storage);
 343         }
 344 };
 345
 346 static const NIFeature _nif_industry = {
 347         _nip_industries,
 348         _nic_industries,
 349         _niv_industries,
 350         new NIHIndustry(),
 351 };
 352
 353
 354 /*** NewGRF objects ***/
 355
 356 #define NICO(cb_id, bit) NIC(cb_id, ObjectSpec, callback_mask, bit)
 357 static const NICallback _nic_objects[] = {
 358         NICO(CBID_OBJECT_LAND_SLOPE_CHECK,     CBM_OBJ_SLOPE_CHECK),
 359         NICO(CBID_OBJECT_ANIMATION_NEXT_FRAME, CBM_OBJ_ANIMATION_NEXT_FRAME),
 360         NICO(CBID_OBJECT_ANIMATION_START_STOP, CBM_NO_BIT),
 361         NICO(CBID_OBJECT_ANIMATION_SPEED,      CBM_OBJ_ANIMATION_SPEED),
 362         NICO(CBID_OBJECT_COLOUR,               CBM_OBJ_COLOUR),
 363         NICO(CBID_OBJECT_FUND_MORE_TEXT,       CBM_OBJ_FUND_MORE_TEXT),
 364         NICO(CBID_OBJECT_AUTOSLOPE,            CBM_OBJ_AUTOSLOPE),
 365         NIC_END()
 366 };
 367
 368 static const NIVariable _niv_objects[] = {
 369         NIV(0x40, "relative position"),
 370         NIV(0x41, "tile information"),
 371         NIV(0x42, "construction date"),
 372         NIV(0x43, "animation counter"),
 373         NIV(0x44, "object founder"),
 374         NIV(0x45, "get town zone and Manhattan distance of closest town"),
 375         NIV(0x46, "get square of Euclidean distance of closes town"),
 376         NIV(0x47, "colour"),
 377         NIV(0x48, "view"),
 378         NIV(0x60, "get object ID at offset"),
 379         NIV(0x61, "get random tile bits at offset"),
 380         NIV(0x62, "land info of nearby tiles"),
 381         NIV(0x63, "animation stage of nearby tiles"),
 382         NIV(0x64, "distance on nearest object with given type"),
 383         NIV_END()
 384 };
 385
 386 class NIHObject : public NIHelper {
 387         bool IsInspectable(uint index) const                 { return ObjectSpec::GetByTile(index)->grf_prop.grffile != nullptr; }
 388         uint GetParent(uint index) const                     { return GetInspectWindowNumber(GSF_FAKE_TOWNS, Object::GetByTile(index)->town->index); }
 389         const void *GetInstance(uint index)const             { return Object::GetByTile(index); }
 390         const void *GetSpec(uint index) const                { return ObjectSpec::GetByTile(index); }
 391         void SetStringParameters(uint index) const           { this->SetObjectAtStringParameters(STR_NEWGRF_INSPECT_CAPTION_OBJECT_AT_OBJECT, INVALID_STRING_ID, index); }
 392         uint32 GetGRFID(uint index) const                    { return (this->IsInspectable(index)) ? ObjectSpec::GetByTile(index)->grf_prop.grffile->grfid : 0; }
 393
 394         /* virtual */ uint Resolve(uint index, uint var, uint param, bool *avail) const
 395         {
 396                 ObjectResolverObject ro(ObjectSpec::GetByTile(index), Object::GetByTile(index), index);
 397                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 398         }
 399 };
 400
 401 static const NIFeature _nif_object = {
 402         nullptr,
 403         _nic_objects,
 404         _niv_objects,
 405         new NIHObject(),
 406 };
 407
 408
 409 /*** NewGRF rail types ***/
 410
 411 static const NIVariable _niv_railtypes[] = {
 412         NIV(0x40, "terrain type"),
 413         NIV(0x41, "enhanced tunnels"),
 414         NIV(0x42, "level crossing status"),
 415         NIV(0x43, "construction date"),
 416         NIV(0x44, "town zone"),
 417         NIV_END()
 418 };
 419
 420 class NIHRailType : public NIHelper {
 421         bool IsInspectable(uint index) const                 { return true; }
 422         uint GetParent(uint index) const                     { return UINT32_MAX; }
 423         const void *GetInstance(uint index)const             { return nullptr; }
 424         const void *GetSpec(uint index) const                { return nullptr; }
 425         void SetStringParameters(uint index) const           { this->SetObjectAtStringParameters(STR_NEWGRF_INSPECT_CAPTION_OBJECT_AT_RAIL_TYPE, INVALID_STRING_ID, index); }
 426         uint32 GetGRFID(uint index) const                    { return 0; }
 427
 428         /* virtual */ uint Resolve(uint index, uint var, uint param, bool *avail) const
 429         {
 430                 /* There is no unique GRFFile for the tile. Multiple GRFs can define different parts of the railtype.
 431                  * However, currently the NewGRF Debug GUI does not display variables depending on the GRF (like 0x7F) anyway. */
 432                 RailTypeResolverObject ro(nullptr, index, TCX_NORMAL, RTSG_END);
 433                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 434         }
 435 };
 436
 437 static const NIFeature _nif_railtype = {
 438         nullptr,
 439         nullptr,
 440         _niv_railtypes,
 441         new NIHRailType(),
 442 };
 443
 444
 445 /*** NewGRF airport tiles ***/
 446
 447 #define NICAT(cb_id, bit) NIC(cb_id, AirportTileSpec, callback_mask, bit)
 448 static const NICallback _nic_airporttiles[] = {
 449         NICAT(CBID_AIRPTILE_DRAW_FOUNDATIONS, CBM_AIRT_DRAW_FOUNDATIONS),
 450         NICAT(CBID_AIRPTILE_ANIM_START_STOP,  CBM_NO_BIT),
 451         NICAT(CBID_AIRPTILE_ANIM_NEXT_FRAME,  CBM_AIRT_ANIM_NEXT_FRAME),
 452         NICAT(CBID_AIRPTILE_ANIMATION_SPEED,  CBM_AIRT_ANIM_SPEED),
 453         NIC_END()
 454 };
 455
 456 class NIHAirportTile : public NIHelper {
 457         bool IsInspectable(uint index) const                 { return AirportTileSpec::Get(GetAirportGfx(index))->grf_prop.grffile != nullptr; }
 458         uint GetParent(uint index) const                     { return GetInspectWindowNumber(GSF_FAKE_TOWNS, Station::GetByTile(index)->town->index); }
 459         const void *GetInstance(uint index)const             { return nullptr; }
 460         const void *GetSpec(uint index) const                { return AirportTileSpec::Get(GetAirportGfx(index)); }
 461         void SetStringParameters(uint index) const           { this->SetObjectAtStringParameters(STR_STATION_NAME, GetStationIndex(index), index); }
 462         uint32 GetGRFID(uint index) const                    { return (this->IsInspectable(index)) ? AirportTileSpec::Get(GetAirportGfx(index))->grf_prop.grffile->grfid : 0; }
 463
 464         /* virtual */ uint Resolve(uint index, uint var, uint param, bool *avail) const
 465         {
 466                 AirportTileResolverObject ro(AirportTileSpec::GetByTile(index), index, Station::GetByTile(index));
 467                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 468         }
 469 };
 470
 471 static const NIFeature _nif_airporttile = {
 472         nullptr,
 473         _nic_airporttiles,
 474         _niv_industrytiles, // Yes, they share this (at least now)
 475         new NIHAirportTile(),
 476 };
 477
 478
 479 /*** NewGRF towns ***/
 480
 481 static const NIVariable _niv_towns[] = {
 482         NIV(0x40, "larger town effect on this town"),
 483         NIV(0x41, "town index"),
 484         NIV(0x82, "population"),
 485         NIV(0x94, "zone radius 0"),
 486         NIV(0x96, "zone radius 1"),
 487         NIV(0x98, "zone radius 2"),
 488         NIV(0x9A, "zone radius 3"),
 489         NIV(0x9C, "zone radius 4"),
 490         NIV(0xB6, "number of buildings"),
 491         NIV_END()
 492 };
 493
 494 class NIHTown : public NIHelper {
 495         bool IsInspectable(uint index) const                 { return Town::IsValidID(index); }
 496         uint GetParent(uint index) const                     { return UINT32_MAX; }
 497         const void *GetInstance(uint index)const             { return Town::Get(index); }
 498         const void *GetSpec(uint index) const                { return nullptr; }
 499         void SetStringParameters(uint index) const           { this->SetSimpleStringParameters(STR_TOWN_NAME, index); }
 500         uint32 GetGRFID(uint index) const                    { return 0; }
 501         bool PSAWithParameter() const                        { return true; }
 502         uint GetPSASize(uint index, uint32 grfid) const      { return cpp_lengthof(PersistentStorage, storage); }
 503
 504         /* virtual */ uint Resolve(uint index, uint var, uint param, bool *avail) const
 505         {
 506                 TownResolverObject ro(nullptr, Town::Get(index), true);
 507                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 508         }
 509
 510         const int32 *GetPSAFirstPosition(uint index, uint32 grfid) const
 511         {
 512                 Town *t = Town::Get(index);
 513
 514                 std::list<PersistentStorage *>::iterator iter;
 515                 for (iter = t->psa_list.begin(); iter != t->psa_list.end(); iter++) {
 516                         if ((*iter)->grfid == grfid) return (int32 *)(&(*iter)->storage[0]);
 517                 }
 518
 519                 return nullptr;
 520         }
 521 };
 522
 523 static const NIFeature _nif_town = {
 524         nullptr,
 525         nullptr,
 526         _niv_towns,
 527         new NIHTown(),
 528 };
 529
 530 /** Table with all NIFeatures. */
 531 static const NIFeature * const _nifeatures[] = {
 532         &_nif_vehicle,      // GSF_TRAINS
 533         &_nif_vehicle,      // GSF_ROADVEHICLES
 534         &_nif_vehicle,      // GSF_SHIPS
 535         &_nif_vehicle,      // GSF_AIRCRAFT
 536         &_nif_station,      // GSF_STATIONS
 537         nullptr,               // GSF_CANALS (no callbacks/action2 implemented)
 538         nullptr,               // GSF_BRIDGES (no callbacks/action2)
 539         &_nif_house,        // GSF_HOUSES
 540         nullptr,               // GSF_GLOBALVAR (has no "physical" objects)
 541         &_nif_industrytile, // GSF_INDUSTRYTILES
 542         &_nif_industry,     // GSF_INDUSTRIES
 543         nullptr,               // GSF_CARGOES (has no "physical" objects)
 544         nullptr,               // GSF_SOUNDFX (has no "physical" objects)
 545         nullptr,               // GSF_AIRPORTS (feature not implemented)
 546         nullptr,               // GSF_SIGNALS (feature not implemented)
 547         &_nif_object,       // GSF_OBJECTS
 548         &_nif_railtype,     // GSF_RAILTYPES
 549         &_nif_airporttile,  // GSF_AIRPORTTILES
 550         &_nif_town,         // GSF_FAKE_TOWNS
 551 };
 552 assert_compile(lengthof(_nifeatures) == GSF_FAKE_END);