src/table/newgrf_debug_data.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file newgrf_debug_data.h Data 'tables' for NewGRF debugging. */
   9
  10 #include "../newgrf_house.h"
  11 #include "../newgrf_engine.h"
  12 #include "../newgrf_roadtype.h"
  13
  14 /* Helper for filling property tables */
  15 #define NIP(prop, base, variable, type, name) { name, (ptrdiff_t)cpp_offsetof(base, variable), cpp_sizeof(base, variable), prop, type }
  16 #define NIP_END() { nullptr, 0, 0, 0, 0 }
  17
  18 /* Helper for filling callback tables */
  19 #define NIC(cb_id, base, variable, bit) { #cb_id, (ptrdiff_t)cpp_offsetof(base, variable), cpp_sizeof(base, variable), bit, cb_id }
  20 #define NIC_END() { nullptr, 0, 0, 0, 0 }
  21
  22 /* Helper for filling variable tables */
  23 #define NIV(var, name) { name, var }
  24 #define NIV_END() { nullptr, 0 }
  25
  26
  27 /*** NewGRF Vehicles ***/
  28
  29 #define NICV(cb_id, bit) NIC(cb_id, Engine, info.callback_mask, bit)
  30 static const NICallback _nic_vehicles[] = {
  31         NICV(CBID_VEHICLE_VISUAL_EFFECT,         CBM_VEHICLE_VISUAL_EFFECT),
  32         NICV(CBID_VEHICLE_LENGTH,                CBM_VEHICLE_LENGTH),
  33         NICV(CBID_VEHICLE_LOAD_AMOUNT,           CBM_VEHICLE_LOAD_AMOUNT),
  34         NICV(CBID_VEHICLE_REFIT_CAPACITY,        CBM_VEHICLE_REFIT_CAPACITY),
  35         NICV(CBID_VEHICLE_ARTIC_ENGINE,          CBM_VEHICLE_ARTIC_ENGINE),
  36         NICV(CBID_VEHICLE_CARGO_SUFFIX,          CBM_VEHICLE_CARGO_SUFFIX),
  37         NICV(CBID_TRAIN_ALLOW_WAGON_ATTACH,      CBM_NO_BIT),
  38         NICV(CBID_VEHICLE_ADDITIONAL_TEXT,       CBM_NO_BIT),
  39         NICV(CBID_VEHICLE_COLOUR_MAPPING,        CBM_VEHICLE_COLOUR_REMAP),
  40         NICV(CBID_VEHICLE_START_STOP_CHECK,      CBM_NO_BIT),
  41         NICV(CBID_VEHICLE_32DAY_CALLBACK,        CBM_NO_BIT),
  42         NICV(CBID_VEHICLE_SOUND_EFFECT,          CBM_VEHICLE_SOUND_EFFECT),
  43         NICV(CBID_VEHICLE_AUTOREPLACE_SELECTION, CBM_NO_BIT),
  44         NICV(CBID_VEHICLE_MODIFY_PROPERTY,       CBM_NO_BIT),
  45         NIC_END()
  46 };
  47
  48
  49 static const NIVariable _niv_vehicles[] = {
  50         NIV(0x40, "position in consist and length"),
  51         NIV(0x41, "position and length of chain of same vehicles"),
  52         NIV(0x42, "transported cargo types"),
  53         NIV(0x43, "player info"),
  54         NIV(0x44, "aircraft info"),
  55         NIV(0x45, "curvature info"),
  56         NIV(0x46, "motion counter"),
  57         NIV(0x47, "vehicle cargo info"),
  58         NIV(0x48, "vehicle type info"),
  59         NIV(0x49, "year of construction"),
  60         NIV(0x4A, "current rail/road type info"),
  61         NIV(0x4B, "long date of last service"),
  62         NIV(0x4C, "current max speed"),
  63         NIV(0x4D, "position in articulated vehicle"),
  64         NIV(0x60, "count vehicle id occurrences"),
  65         // 0x61 not useful, since it requires register 0x10F
  66         NIV(0x62, "Curvature/position difference to other vehicle"),
  67         NIV_END()
  68 };
  69
  70 class NIHVehicle : public NIHelper {
  71         bool IsInspectable(uint index) const override        { return Vehicle::Get(index)->GetGRF() != nullptr; }
  72         uint GetParent(uint index) const override            { const Vehicle *first = Vehicle::Get(index)->First(); return GetInspectWindowNumber(GetGrfSpecFeature(first->type), first->index); }
  73         const void *GetInstance(uint index)const override    { return Vehicle::Get(index); }
  74         const void *GetSpec(uint index) const override       { return Vehicle::Get(index)->GetEngine(); }
  75         void SetStringParameters(uint index) const override  { this->SetSimpleStringParameters(STR_VEHICLE_NAME, index); }
  76         uint32 GetGRFID(uint index) const override                   { return Vehicle::Get(index)->GetGRFID(); }
  77
  78         uint Resolve(uint index, uint var, uint param, bool *avail) const override
  79         {
  80                 Vehicle *v = Vehicle::Get(index);
  81                 VehicleResolverObject ro(v->engine_type, v, VehicleResolverObject::WO_CACHED);
  82                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
  83         }
  84 };
  85
  86 static const NIFeature _nif_vehicle = {
  87         nullptr,
  88         _nic_vehicles,
  89         _niv_vehicles,
  90         new NIHVehicle(),
  91 };
  92
  93
  94 /*** NewGRF station (tiles) ***/
  95
  96 #define NICS(cb_id, bit) NIC(cb_id, StationSpec, callback_mask, bit)
  97 static const NICallback _nic_stations[] = {
  98         NICS(CBID_STATION_AVAILABILITY,     CBM_STATION_AVAIL),
  99         NICS(CBID_STATION_SPRITE_LAYOUT,    CBM_STATION_SPRITE_LAYOUT),
 100         NICS(CBID_STATION_TILE_LAYOUT,      CBM_NO_BIT),
 101         NICS(CBID_STATION_ANIM_START_STOP,  CBM_NO_BIT),
 102         NICS(CBID_STATION_ANIM_NEXT_FRAME,  CBM_STATION_ANIMATION_NEXT_FRAME),
 103         NICS(CBID_STATION_ANIMATION_SPEED,  CBM_STATION_ANIMATION_SPEED),
 104         NICS(CBID_STATION_LAND_SLOPE_CHECK, CBM_STATION_SLOPE_CHECK),
 105         NIC_END()
 106 };
 107
 108 static const NIVariable _niv_stations[] = {
 109         NIV(0x40, "platform info and relative position"),
 110         NIV(0x41, "platform info and relative position for individually built sections"),
 111         NIV(0x42, "terrain and track type"),
 112         NIV(0x43, "player info"),
 113         NIV(0x44, "path signalling info"),
 114         NIV(0x45, "rail continuation info"),
 115         NIV(0x46, "platform info and relative position from middle"),
 116         NIV(0x47, "platform info and relative position from middle for individually built sections"),
 117         NIV(0x48, "bitmask of accepted cargoes"),
 118         NIV(0x49, "platform info and relative position of same-direction section"),
 119         NIV(0x4A, "current animation frame"),
 120         NIV(0x60, "amount of cargo waiting"),
 121         NIV(0x61, "time since last cargo pickup"),
 122         NIV(0x62, "rating of cargo"),
 123         NIV(0x63, "time spent on route"),
 124         NIV(0x64, "information about last vehicle picking cargo up"),
 125         NIV(0x65, "amount of cargo acceptance"),
 126         NIV(0x66, "animation frame of nearby tile"),
 127         NIV(0x67, "land info of nearby tiles"),
 128         NIV(0x68, "station info of nearby tiles"),
 129         NIV(0x69, "information about cargo accepted in the past"),
 130         NIV(0x6A, "GRFID of nearby station tiles"),
 131         NIV_END()
 132 };
 133
 134 class NIHStation : public NIHelper {
 135         bool IsInspectable(uint index) const override        { return GetStationSpec(index) != nullptr; }
 136         uint GetParent(uint index) const override            { return GetInspectWindowNumber(GSF_FAKE_TOWNS, Station::GetByTile(index)->town->index); }
 137         const void *GetInstance(uint index)const override    { return nullptr; }
 138         const void *GetSpec(uint index) const override       { return GetStationSpec(index); }
 139         void SetStringParameters(uint index) const override  { this->SetObjectAtStringParameters(STR_STATION_NAME, GetStationIndex(index), index); }
 140         uint32 GetGRFID(uint index) const override           { return (this->IsInspectable(index)) ? GetStationSpec(index)->grf_prop.grffile->grfid : 0; }
 141
 142         uint Resolve(uint index, uint var, uint param, bool *avail) const override
 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 override        { return HouseSpec::Get(GetHouseType(index))->grf_prop.grffile != nullptr; }
 201         uint GetParent(uint index) const override            { return GetInspectWindowNumber(GSF_FAKE_TOWNS, GetTownIndex(index)); }
 202         const void *GetInstance(uint index)const override    { return nullptr; }
 203         const void *GetSpec(uint index) const override       { return HouseSpec::Get(GetHouseType(index)); }
 204         void SetStringParameters(uint index) const override  { this->SetObjectAtStringParameters(STR_TOWN_NAME, GetTownIndex(index), index); }
 205         uint32 GetGRFID(uint index) const override           { return (this->IsInspectable(index)) ? HouseSpec::Get(GetHouseType(index))->grf_prop.grffile->grfid : 0; }
 206
 207         uint Resolve(uint index, uint var, uint param, bool *avail) const override
 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 override        { return GetIndustryTileSpec(GetIndustryGfx(index))->grf_prop.grffile != nullptr; }
 251         uint GetParent(uint index) const override            { return GetInspectWindowNumber(GSF_INDUSTRIES, GetIndustryIndex(index)); }
 252         const void *GetInstance(uint index)const override    { return nullptr; }
 253         const void *GetSpec(uint index) const override       { return GetIndustryTileSpec(GetIndustryGfx(index)); }
 254         void SetStringParameters(uint index) const override  { this->SetObjectAtStringParameters(STR_INDUSTRY_NAME, GetIndustryIndex(index), index); }
 255         uint32 GetGRFID(uint index) const override           { return (this->IsInspectable(index)) ? GetIndustryTileSpec(GetIndustryGfx(index))->grf_prop.grffile->grfid : 0; }
 256
 257         uint Resolve(uint index, uint var, uint param, bool *avail) const override
 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(0x25, Industry, produced_cargo[ 0], NIT_CARGO, "produced cargo 0"),
 276         NIP(0x25, Industry, produced_cargo[ 1], NIT_CARGO, "produced cargo 1"),
 277         NIP(0x25, Industry, produced_cargo[ 2], NIT_CARGO, "produced cargo 2"),
 278         NIP(0x25, Industry, produced_cargo[ 3], NIT_CARGO, "produced cargo 3"),
 279         NIP(0x25, Industry, produced_cargo[ 4], NIT_CARGO, "produced cargo 4"),
 280         NIP(0x25, Industry, produced_cargo[ 5], NIT_CARGO, "produced cargo 5"),
 281         NIP(0x25, Industry, produced_cargo[ 6], NIT_CARGO, "produced cargo 6"),
 282         NIP(0x25, Industry, produced_cargo[ 7], NIT_CARGO, "produced cargo 7"),
 283         NIP(0x25, Industry, produced_cargo[ 8], NIT_CARGO, "produced cargo 8"),
 284         NIP(0x25, Industry, produced_cargo[ 9], NIT_CARGO, "produced cargo 9"),
 285         NIP(0x25, Industry, produced_cargo[10], NIT_CARGO, "produced cargo 10"),
 286         NIP(0x25, Industry, produced_cargo[11], NIT_CARGO, "produced cargo 11"),
 287         NIP(0x25, Industry, produced_cargo[12], NIT_CARGO, "produced cargo 12"),
 288         NIP(0x25, Industry, produced_cargo[13], NIT_CARGO, "produced cargo 13"),
 289         NIP(0x25, Industry, produced_cargo[14], NIT_CARGO, "produced cargo 14"),
 290         NIP(0x25, Industry, produced_cargo[15], NIT_CARGO, "produced cargo 15"),
 291         NIP(0x26, Industry, accepts_cargo[ 0],  NIT_CARGO, "accepted cargo 0"),
 292         NIP(0x26, Industry, accepts_cargo[ 1],  NIT_CARGO, "accepted cargo 1"),
 293         NIP(0x26, Industry, accepts_cargo[ 2],  NIT_CARGO, "accepted cargo 2"),
 294         NIP(0x26, Industry, accepts_cargo[ 3],  NIT_CARGO, "accepted cargo 3"),
 295         NIP(0x26, Industry, accepts_cargo[ 4],  NIT_CARGO, "accepted cargo 4"),
 296         NIP(0x26, Industry, accepts_cargo[ 5],  NIT_CARGO, "accepted cargo 5"),
 297         NIP(0x26, Industry, accepts_cargo[ 6],  NIT_CARGO, "accepted cargo 6"),
 298         NIP(0x26, Industry, accepts_cargo[ 7],  NIT_CARGO, "accepted cargo 7"),
 299         NIP(0x26, Industry, accepts_cargo[ 8],  NIT_CARGO, "accepted cargo 8"),
 300         NIP(0x26, Industry, accepts_cargo[ 9],  NIT_CARGO, "accepted cargo 9"),
 301         NIP(0x26, Industry, accepts_cargo[10],  NIT_CARGO, "accepted cargo 10"),
 302         NIP(0x26, Industry, accepts_cargo[11],  NIT_CARGO, "accepted cargo 11"),
 303         NIP(0x26, Industry, accepts_cargo[12],  NIT_CARGO, "accepted cargo 12"),
 304         NIP(0x26, Industry, accepts_cargo[13],  NIT_CARGO, "accepted cargo 13"),
 305         NIP(0x26, Industry, accepts_cargo[14],  NIT_CARGO, "accepted cargo 14"),
 306         NIP(0x26, Industry, accepts_cargo[15],  NIT_CARGO, "accepted cargo 15"),
 307         NIP_END()
 308 };
 309
 310 #define NICI(cb_id, bit) NIC(cb_id, IndustrySpec, callback_mask, bit)
 311 static const NICallback _nic_industries[] = {
 312         NICI(CBID_INDUSTRY_PROBABILITY,          CBM_IND_PROBABILITY),
 313         NICI(CBID_INDUSTRY_LOCATION,             CBM_IND_LOCATION),
 314         NICI(CBID_INDUSTRY_PRODUCTION_CHANGE,    CBM_IND_PRODUCTION_CHANGE),
 315         NICI(CBID_INDUSTRY_MONTHLYPROD_CHANGE,   CBM_IND_MONTHLYPROD_CHANGE),
 316         NICI(CBID_INDUSTRY_CARGO_SUFFIX,         CBM_IND_CARGO_SUFFIX),
 317         NICI(CBID_INDUSTRY_FUND_MORE_TEXT,       CBM_IND_FUND_MORE_TEXT),
 318         NICI(CBID_INDUSTRY_WINDOW_MORE_TEXT,     CBM_IND_WINDOW_MORE_TEXT),
 319         NICI(CBID_INDUSTRY_SPECIAL_EFFECT,       CBM_IND_SPECIAL_EFFECT),
 320         NICI(CBID_INDUSTRY_REFUSE_CARGO,         CBM_IND_REFUSE_CARGO),
 321         NICI(CBID_INDUSTRY_DECIDE_COLOUR,        CBM_IND_DECIDE_COLOUR),
 322         NICI(CBID_INDUSTRY_INPUT_CARGO_TYPES,    CBM_IND_INPUT_CARGO_TYPES),
 323         NICI(CBID_INDUSTRY_OUTPUT_CARGO_TYPES,   CBM_IND_OUTPUT_CARGO_TYPES),
 324         NICI(CBID_INDUSTRY_PROD_CHANGE_BUILD,    CBM_IND_PROD_CHANGE_BUILD),
 325         NIC_END()
 326 };
 327
 328 static const NIVariable _niv_industries[] = {
 329         NIV(0x40, "waiting cargo 0"),
 330         NIV(0x41, "waiting cargo 1"),
 331         NIV(0x42, "waiting cargo 2"),
 332         NIV(0x43, "distance to closest dry/land tile"),
 333         NIV(0x44, "layout number"),
 334         NIV(0x45, "player info"),
 335         NIV(0x46, "industry construction date"),
 336         NIV(0x60, "get industry tile ID at offset"),
 337         NIV(0x61, "get random tile bits at offset"),
 338         NIV(0x62, "land info of nearby tiles"),
 339         NIV(0x63, "animation stage of nearby tiles"),
 340         NIV(0x64, "distance on nearest industry with given type"),
 341         NIV(0x65, "get town zone and Manhattan distance of closest town"),
 342         NIV(0x66, "get square of Euclidean distance of closes town"),
 343         NIV(0x67, "count of industry and distance of closest instance"),
 344         NIV(0x68, "count of industry and distance of closest instance with layout filter"),
 345         NIV_END()
 346 };
 347
 348 class NIHIndustry : public NIHelper {
 349         bool IsInspectable(uint index) const override        { return GetIndustrySpec(Industry::Get(index)->type)->grf_prop.grffile != nullptr; }
 350         uint GetParent(uint index) const override            { return GetInspectWindowNumber(GSF_FAKE_TOWNS, Industry::Get(index)->town->index); }
 351         const void *GetInstance(uint index)const override    { return Industry::Get(index); }
 352         const void *GetSpec(uint index) const override       { return GetIndustrySpec(Industry::Get(index)->type); }
 353         void SetStringParameters(uint index) const override  { this->SetSimpleStringParameters(STR_INDUSTRY_NAME, index); }
 354         uint32 GetGRFID(uint index) const override           { return (this->IsInspectable(index)) ? GetIndustrySpec(Industry::Get(index)->type)->grf_prop.grffile->grfid : 0; }
 355
 356         uint Resolve(uint index, uint var, uint param, bool *avail) const override
 357         {
 358                 Industry *i = Industry::Get(index);
 359                 IndustriesResolverObject ro(i->location.tile, i, i->type);
 360                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 361         }
 362
 363         uint GetPSASize(uint index, uint32 grfid) const override { return cpp_lengthof(PersistentStorage, storage); }
 364
 365         const int32 *GetPSAFirstPosition(uint index, uint32 grfid) const override
 366         {
 367                 const Industry *i = (const Industry *)this->GetInstance(index);
 368                 if (i->psa == nullptr) return nullptr;
 369                 return (int32 *)(&i->psa->storage);
 370         }
 371 };
 372
 373 static const NIFeature _nif_industry = {
 374         _nip_industries,
 375         _nic_industries,
 376         _niv_industries,
 377         new NIHIndustry(),
 378 };
 379
 380
 381 /*** NewGRF objects ***/
 382
 383 #define NICO(cb_id, bit) NIC(cb_id, ObjectSpec, callback_mask, bit)
 384 static const NICallback _nic_objects[] = {
 385         NICO(CBID_OBJECT_LAND_SLOPE_CHECK,     CBM_OBJ_SLOPE_CHECK),
 386         NICO(CBID_OBJECT_ANIMATION_NEXT_FRAME, CBM_OBJ_ANIMATION_NEXT_FRAME),
 387         NICO(CBID_OBJECT_ANIMATION_START_STOP, CBM_NO_BIT),
 388         NICO(CBID_OBJECT_ANIMATION_SPEED,      CBM_OBJ_ANIMATION_SPEED),
 389         NICO(CBID_OBJECT_COLOUR,               CBM_OBJ_COLOUR),
 390         NICO(CBID_OBJECT_FUND_MORE_TEXT,       CBM_OBJ_FUND_MORE_TEXT),
 391         NICO(CBID_OBJECT_AUTOSLOPE,            CBM_OBJ_AUTOSLOPE),
 392         NIC_END()
 393 };
 394
 395 static const NIVariable _niv_objects[] = {
 396         NIV(0x40, "relative position"),
 397         NIV(0x41, "tile information"),
 398         NIV(0x42, "construction date"),
 399         NIV(0x43, "animation counter"),
 400         NIV(0x44, "object founder"),
 401         NIV(0x45, "get town zone and Manhattan distance of closest town"),
 402         NIV(0x46, "get square of Euclidean distance of closes town"),
 403         NIV(0x47, "colour"),
 404         NIV(0x48, "view"),
 405         NIV(0x60, "get object ID at offset"),
 406         NIV(0x61, "get random tile bits at offset"),
 407         NIV(0x62, "land info of nearby tiles"),
 408         NIV(0x63, "animation stage of nearby tiles"),
 409         NIV(0x64, "distance on nearest object with given type"),
 410         NIV_END()
 411 };
 412
 413 class NIHObject : public NIHelper {
 414         bool IsInspectable(uint index) const override        { return ObjectSpec::GetByTile(index)->grf_prop.grffile != nullptr; }
 415         uint GetParent(uint index) const override            { return GetInspectWindowNumber(GSF_FAKE_TOWNS, Object::GetByTile(index)->town->index); }
 416         const void *GetInstance(uint index)const override    { return Object::GetByTile(index); }
 417         const void *GetSpec(uint index) const override       { return ObjectSpec::GetByTile(index); }
 418         void SetStringParameters(uint index) const override  { this->SetObjectAtStringParameters(STR_NEWGRF_INSPECT_CAPTION_OBJECT_AT_OBJECT, INVALID_STRING_ID, index); }
 419         uint32 GetGRFID(uint index) const override           { return (this->IsInspectable(index)) ? ObjectSpec::GetByTile(index)->grf_prop.grffile->grfid : 0; }
 420
 421         uint Resolve(uint index, uint var, uint param, bool *avail) const override
 422         {
 423                 ObjectResolverObject ro(ObjectSpec::GetByTile(index), Object::GetByTile(index), index);
 424                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 425         }
 426 };
 427
 428 static const NIFeature _nif_object = {
 429         nullptr,
 430         _nic_objects,
 431         _niv_objects,
 432         new NIHObject(),
 433 };
 434
 435
 436 /*** NewGRF rail types ***/
 437
 438 static const NIVariable _niv_railtypes[] = {
 439         NIV(0x40, "terrain type"),
 440         NIV(0x41, "enhanced tunnels"),
 441         NIV(0x42, "level crossing status"),
 442         NIV(0x43, "construction date"),
 443         NIV(0x44, "town zone"),
 444         NIV_END()
 445 };
 446
 447 class NIHRailType : public NIHelper {
 448         bool IsInspectable(uint index) const override        { return true; }
 449         uint GetParent(uint index) const override            { return UINT32_MAX; }
 450         const void *GetInstance(uint index)const override    { return nullptr; }
 451         const void *GetSpec(uint index) const override       { return nullptr; }
 452         void SetStringParameters(uint index) const override  { this->SetObjectAtStringParameters(STR_NEWGRF_INSPECT_CAPTION_OBJECT_AT_RAIL_TYPE, INVALID_STRING_ID, index); }
 453         uint32 GetGRFID(uint index) const override           { return 0; }
 454
 455         uint Resolve(uint index, uint var, uint param, bool *avail) const override
 456         {
 457                 /* There is no unique GRFFile for the tile. Multiple GRFs can define different parts of the railtype.
 458                  * However, currently the NewGRF Debug GUI does not display variables depending on the GRF (like 0x7F) anyway. */
 459                 RailTypeResolverObject ro(nullptr, index, TCX_NORMAL, RTSG_END);
 460                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 461         }
 462 };
 463
 464 static const NIFeature _nif_railtype = {
 465         nullptr,
 466         nullptr,
 467         _niv_railtypes,
 468         new NIHRailType(),
 469 };
 470
 471
 472 /*** NewGRF airport tiles ***/
 473
 474 #define NICAT(cb_id, bit) NIC(cb_id, AirportTileSpec, callback_mask, bit)
 475 static const NICallback _nic_airporttiles[] = {
 476         NICAT(CBID_AIRPTILE_DRAW_FOUNDATIONS, CBM_AIRT_DRAW_FOUNDATIONS),
 477         NICAT(CBID_AIRPTILE_ANIM_START_STOP,  CBM_NO_BIT),
 478         NICAT(CBID_AIRPTILE_ANIM_NEXT_FRAME,  CBM_AIRT_ANIM_NEXT_FRAME),
 479         NICAT(CBID_AIRPTILE_ANIMATION_SPEED,  CBM_AIRT_ANIM_SPEED),
 480         NIC_END()
 481 };
 482
 483 class NIHAirportTile : public NIHelper {
 484         bool IsInspectable(uint index) const override        { return AirportTileSpec::Get(GetAirportGfx(index))->grf_prop.grffile != nullptr; }
 485         uint GetParent(uint index) const override            { return GetInspectWindowNumber(GSF_FAKE_TOWNS, Station::GetByTile(index)->town->index); }
 486         const void *GetInstance(uint index)const override    { return nullptr; }
 487         const void *GetSpec(uint index) const override       { return AirportTileSpec::Get(GetAirportGfx(index)); }
 488         void SetStringParameters(uint index) const override  { this->SetObjectAtStringParameters(STR_STATION_NAME, GetStationIndex(index), index); }
 489         uint32 GetGRFID(uint index) const override           { return (this->IsInspectable(index)) ? AirportTileSpec::Get(GetAirportGfx(index))->grf_prop.grffile->grfid : 0; }
 490
 491         uint Resolve(uint index, uint var, uint param, bool *avail) const override
 492         {
 493                 AirportTileResolverObject ro(AirportTileSpec::GetByTile(index), index, Station::GetByTile(index));
 494                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 495         }
 496 };
 497
 498 static const NIFeature _nif_airporttile = {
 499         nullptr,
 500         _nic_airporttiles,
 501         _niv_industrytiles, // Yes, they share this (at least now)
 502         new NIHAirportTile(),
 503 };
 504
 505
 506 /*** NewGRF towns ***/
 507
 508 static const NIVariable _niv_towns[] = {
 509         NIV(0x40, "larger town effect on this town"),
 510         NIV(0x41, "town index"),
 511         NIV(0x82, "population"),
 512         NIV(0x94, "zone radius 0"),
 513         NIV(0x96, "zone radius 1"),
 514         NIV(0x98, "zone radius 2"),
 515         NIV(0x9A, "zone radius 3"),
 516         NIV(0x9C, "zone radius 4"),
 517         NIV(0xB6, "number of buildings"),
 518         NIV_END()
 519 };
 520
 521 class NIHTown : public NIHelper {
 522         bool IsInspectable(uint index) const override        { return Town::IsValidID(index); }
 523         uint GetParent(uint index) const override            { return UINT32_MAX; }
 524         const void *GetInstance(uint index)const override    { return Town::Get(index); }
 525         const void *GetSpec(uint index) const override       { return nullptr; }
 526         void SetStringParameters(uint index) const override  { this->SetSimpleStringParameters(STR_TOWN_NAME, index); }
 527         uint32 GetGRFID(uint index) const override           { return 0; }
 528         bool PSAWithParameter() const override               { return true; }
 529         uint GetPSASize(uint index, uint32 grfid) const override { return cpp_lengthof(PersistentStorage, storage); }
 530
 531         uint Resolve(uint index, uint var, uint param, bool *avail) const override
 532         {
 533                 TownResolverObject ro(nullptr, Town::Get(index), true);
 534                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 535         }
 536
 537         const int32 *GetPSAFirstPosition(uint index, uint32 grfid) const override
 538         {
 539                 Town *t = Town::Get(index);
 540
 541                 std::list<PersistentStorage *>::iterator iter;
 542                 for (iter = t->psa_list.begin(); iter != t->psa_list.end(); iter++) {
 543                         if ((*iter)->grfid == grfid) return (int32 *)(&(*iter)->storage[0]);
 544                 }
 545
 546                 return nullptr;
 547         }
 548 };
 549
 550 static const NIFeature _nif_town = {
 551         nullptr,
 552         nullptr,
 553         _niv_towns,
 554         new NIHTown(),
 555 };
 556
 557 /*** NewGRF road types ***/
 558
 559 static const NIVariable _niv_roadtypes[] = {
 560         NIV(0x40, "terrain type"),
 561         NIV(0x41, "enhanced tunnels"),
 562         NIV(0x42, "level crossing status"),
 563         NIV(0x43, "construction date"),
 564         NIV(0x44, "town zone"),
 565         NIV_END()
 566 };
 567
 568 class NIHRoadType : public NIHelper {
 569         bool IsInspectable(uint index) const override        { return true; }
 570         uint GetParent(uint index) const override            { return UINT32_MAX; }
 571         const void *GetInstance(uint index) const override   { return nullptr; }
 572         const void *GetSpec(uint index) const override       { return nullptr; }
 573         void SetStringParameters(uint index) const override  { this->SetObjectAtStringParameters(STR_NEWGRF_INSPECT_CAPTION_OBJECT_AT_RAIL_TYPE, INVALID_STRING_ID, index); }
 574         uint32 GetGRFID(uint index) const override           { return 0; }
 575
 576         uint Resolve(uint index, uint var, uint param, bool *avail) const override
 577         {
 578                 /* There is no unique GRFFile for the tile. Multiple GRFs can define different parts of the railtype.
 579                  * However, currently the NewGRF Debug GUI does not display variables depending on the GRF (like 0x7F) anyway. */
 580                 RoadTypeResolverObject ro(nullptr, index, TCX_NORMAL, ROTSG_END);
 581                 return ro.GetScope(VSG_SCOPE_SELF)->GetVariable(var, param, avail);
 582         }
 583 };
 584
 585 static const NIFeature _nif_roadtype = {
 586         nullptr,
 587         nullptr,
 588         _niv_roadtypes,
 589         new NIHRoadType(),
 590 };
 591
 592 static const NIFeature _nif_tramtype = {
 593         nullptr,
 594         nullptr,
 595         _niv_roadtypes,
 596         new NIHRoadType(),
 597 };
 598
 599 /** Table with all NIFeatures. */
 600 static const NIFeature * const _nifeatures[] = {
 601         &_nif_vehicle,      // GSF_TRAINS
 602         &_nif_vehicle,      // GSF_ROADVEHICLES
 603         &_nif_vehicle,      // GSF_SHIPS
 604         &_nif_vehicle,      // GSF_AIRCRAFT
 605         &_nif_station,      // GSF_STATIONS
 606         nullptr,               // GSF_CANALS (no callbacks/action2 implemented)
 607         nullptr,               // GSF_BRIDGES (no callbacks/action2)
 608         &_nif_house,        // GSF_HOUSES
 609         nullptr,               // GSF_GLOBALVAR (has no "physical" objects)
 610         &_nif_industrytile, // GSF_INDUSTRYTILES
 611         &_nif_industry,     // GSF_INDUSTRIES
 612         nullptr,               // GSF_CARGOES (has no "physical" objects)
 613         nullptr,               // GSF_SOUNDFX (has no "physical" objects)
 614         nullptr,               // GSF_AIRPORTS (feature not implemented)
 615         nullptr,               // GSF_SIGNALS (feature not implemented)
 616         &_nif_object,       // GSF_OBJECTS
 617         &_nif_railtype,     // GSF_RAILTYPES
 618         &_nif_airporttile,  // GSF_AIRPORTTILES
 619         &_nif_roadtype,     // GSF_ROADTYPES
 620         &_nif_tramtype,     // GSF_TRAMTYPES
 621         &_nif_town,         // GSF_FAKE_TOWNS
 622 };
 623 assert_compile(lengthof(_nifeatures) == GSF_FAKE_END);