00001
00002
00005 #include "stdafx.h"
00006
00007 #include <stdarg.h>
00008
00009 #include "openttd.h"
00010 #include "debug.h"
00011 #include "fileio_func.h"
00012 #include "engine_func.h"
00013 #include "engine_base.h"
00014 #include "spritecache.h"
00015 #include "variables.h"
00016 #include "bridge.h"
00017 #include "town.h"
00018 #include "newgrf_engine.h"
00019 #include "newgrf_text.h"
00020 #include "fontcache.h"
00021 #include "currency.h"
00022 #include "landscape.h"
00023 #include "newgrf_house.h"
00024 #include "newgrf_sound.h"
00025 #include "newgrf_station.h"
00026 #include "industry.h"
00027 #include "newgrf_canal.h"
00028 #include "newgrf_commons.h"
00029 #include "newgrf_townname.h"
00030 #include "newgrf_industries.h"
00031 #include "rev.h"
00032 #include "fios.h"
00033 #include "rail.h"
00034 #include "strings_func.h"
00035 #include "gfx_func.h"
00036 #include "date_func.h"
00037 #include "vehicle_func.h"
00038 #include "sound_func.h"
00039 #include "string_func.h"
00040 #include "network/network.h"
00041 #include "map_func.h"
00042 #include <map>
00043
00044 #include "table/strings.h"
00045 #include "table/build_industry.h"
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057 static int _skip_sprites;
00058 static uint _file_index;
00059
00060 static GRFFile *_cur_grffile;
00061 GRFFile *_first_grffile;
00062 static SpriteID _cur_spriteid;
00063 static GrfLoadingStage _cur_stage;
00064 static uint32 _nfo_line;
00065
00066 static GRFConfig *_cur_grfconfig;
00067
00068
00069 static byte _misc_grf_features = 0;
00070
00071
00072 static uint32 _ttdpatch_flags[8];
00073
00074
00075 GRFLoadedFeatures _loaded_newgrf_features;
00076
00077 enum GrfDataType {
00078 GDT_SOUND,
00079 };
00080
00081 static byte _grf_data_blocks;
00082 static GrfDataType _grf_data_type;
00083
00084
00085 typedef void (*SpecialSpriteHandler)(byte *buf, size_t len);
00086
00087 enum {
00088 MAX_STATIONS = 256,
00089 };
00090
00091
00092 struct GRFTempEngineData {
00093 uint16 cargo_allowed;
00094 uint16 cargo_disallowed;
00095 uint8 rv_max_speed;
00096 };
00097
00098 static GRFTempEngineData *_gted;
00099
00100
00101
00102
00103 static uint32 _grm_engines[256];
00104
00105
00106 static uint32 _grm_cargos[NUM_CARGO * 2];
00107
00108 struct GRFLocation {
00109 uint32 grfid;
00110 uint32 nfoline;
00111
00112 GRFLocation(uint32 grfid, uint32 nfoline) : grfid(grfid), nfoline(nfoline) { }
00113
00114 bool operator<(const GRFLocation &other) const
00115 {
00116 return this->grfid < other.grfid || (this->grfid == other.grfid && this->nfoline < other.nfoline);
00117 }
00118
00119 bool operator==(const GRFLocation &other) const
00120 {
00121 return this->grfid == other.grfid && this->nfoline == other.nfoline;
00122 }
00123 };
00124
00125 static std::map<GRFLocation, SpriteID> _grm_sprites;
00126 typedef std::map<GRFLocation, byte*> GRFLineToSpriteOverride;
00127 GRFLineToSpriteOverride _grf_line_to_action6_sprite_override;
00128
00137 void CDECL grfmsg(int severity, const char *str, ...)
00138 {
00139 char buf[1024];
00140 va_list va;
00141
00142 va_start(va, str);
00143 vsnprintf(buf, sizeof(buf), str, va);
00144 va_end(va);
00145
00146 DEBUG(grf, severity, "[%s:%d] %s", _cur_grfconfig->filename, _nfo_line, buf);
00147 }
00148
00149 static inline bool check_length(size_t real, size_t wanted, const char *str)
00150 {
00151 if (real >= wanted) return true;
00152 grfmsg(0, "%s: Invalid pseudo sprite length %d (expected %d)!", str, real, wanted);
00153 return false;
00154 }
00155
00156 static inline byte grf_load_byte(byte **buf)
00157 {
00158 return *(*buf)++;
00159 }
00160
00161 static uint16 grf_load_word(byte **buf)
00162 {
00163 uint16 val = grf_load_byte(buf);
00164 return val | (grf_load_byte(buf) << 8);
00165 }
00166
00167 static uint16 grf_load_extended(byte** buf)
00168 {
00169 uint16 val;
00170 val = grf_load_byte(buf);
00171 if (val == 0xFF) val = grf_load_word(buf);
00172 return val;
00173 }
00174
00175 static uint32 grf_load_dword(byte **buf)
00176 {
00177 uint32 val = grf_load_word(buf);
00178 return val | (grf_load_word(buf) << 16);
00179 }
00180
00181 static uint32 grf_load_var(byte size, byte **buf)
00182 {
00183 switch (size) {
00184 case 1: return grf_load_byte(buf);
00185 case 2: return grf_load_word(buf);
00186 case 4: return grf_load_dword(buf);
00187 default:
00188 NOT_REACHED();
00189 return 0;
00190 }
00191 }
00192
00193 static const char *grf_load_string(byte **buf, size_t max_len)
00194 {
00195 const char *string = *(const char **)buf;
00196 size_t string_length = ttd_strnlen(string, max_len);
00197
00198 if (string_length == max_len) {
00199
00200 (*buf)[string_length - 1] = '\0';
00201 grfmsg(7, "String was not terminated with a zero byte.");
00202 } else {
00203
00204 string_length++;
00205 }
00206 *buf += string_length;
00207
00208 return string;
00209 }
00210
00211 static GRFFile *GetFileByGRFID(uint32 grfid)
00212 {
00213 GRFFile *file;
00214
00215 for (file = _first_grffile; file != NULL; file = file->next) {
00216 if (file->grfid == grfid) break;
00217 }
00218 return file;
00219 }
00220
00221 static GRFFile *GetFileByFilename(const char *filename)
00222 {
00223 GRFFile *file;
00224
00225 for (file = _first_grffile; file != NULL; file = file->next) {
00226 if (strcmp(file->filename, filename) == 0) break;
00227 }
00228 return file;
00229 }
00230
00232 static void ClearTemporaryNewGRFData(GRFFile *gf)
00233 {
00234
00235 for (GRFLabel *l = gf->label; l != NULL;) {
00236 GRFLabel *l2 = l->next;
00237 free(l);
00238 l = l2;
00239 }
00240 gf->label = NULL;
00241
00242
00243 free(gf->spritegroups);
00244 gf->spritegroups = NULL;
00245 gf->spritegroups_count = 0;
00246 }
00247
00248
00249 typedef std::map<StringID *, uint32> StringIDToGRFIDMapping;
00250 StringIDToGRFIDMapping _string_to_grf_mapping;
00251
00258 StringID MapGRFStringID(uint32 grfid, StringID str)
00259 {
00260
00261 static StringID units_volume[] = {
00262 STR_NOTHING, STR_PASSENGERS, STR_TONS, STR_BAGS,
00263 STR_LITERS, STR_ITEMS, STR_CRATES, STR_TONS,
00264 STR_TONS, STR_TONS, STR_TONS, STR_BAGS,
00265 STR_TONS, STR_TONS, STR_TONS, STR_BAGS,
00266 STR_TONS, STR_TONS, STR_BAGS, STR_LITERS,
00267 STR_TONS, STR_LITERS, STR_TONS, STR_NOTHING,
00268 STR_BAGS, STR_LITERS, STR_TONS, STR_NOTHING,
00269 STR_TONS, STR_NOTHING, STR_LITERS, STR_NOTHING
00270 };
00271
00272
00273
00274
00275
00276 switch (GB(str, 8, 8)) {
00277 case 0xD0: case 0xD1: case 0xD2: case 0xD3:
00278 case 0xDC:
00279 return GetGRFStringID(grfid, str);
00280
00281 case 0xD4: case 0xD5: case 0xD6: case 0xD7:
00282
00283
00284 return GetGRFStringID(grfid, str - 0x400);
00285
00286 default: break;
00287 }
00288
00289 #define TEXID_TO_STRINGID(begin, end, stringid) if (str >= begin && str <= end) return str + (stringid - begin)
00290
00291 TEXID_TO_STRINGID(0x000E, 0x002D, STR_000E);
00292 TEXID_TO_STRINGID(0x002E, 0x004D, STR_002E);
00293 if (str >= 0x004E && str <= 0x006D) str = units_volume[str - 0x004E];
00294 TEXID_TO_STRINGID(0x006E, 0x008D, STR_QUANTITY_NOTHING);
00295 TEXID_TO_STRINGID(0x008E, 0x00AD, STR_ABBREV_NOTHING);
00296
00297
00298
00299
00300 TEXID_TO_STRINGID(0x200F, 0x201F, STR_200F_TALL_OFFICE_BLOCK);
00301 TEXID_TO_STRINGID(0x2036, 0x2041, STR_2036_COTTAGES);
00302 TEXID_TO_STRINGID(0x2059, 0x205C, STR_2059_IGLOO);
00303
00304
00305 TEXID_TO_STRINGID(0x482A, 0x483B, STR_482A_PRODUCTION_LAST_MONTH);
00306 #undef TEXTID_TO_STRINGID
00307
00308 if (str == STR_NULL) return STR_EMPTY;
00309
00310 return str;
00311 }
00312
00313 static inline uint8 MapDOSColour(uint8 colour)
00314 {
00315 extern const byte _palmap_d2w[];
00316 return (_use_palette == PAL_DOS ? colour : _palmap_d2w[colour]);
00317 }
00318
00319 static std::map<uint32, uint32> _grf_id_overrides;
00320
00321 static void SetNewGRFOverride(uint32 source_grfid, uint32 target_grfid)
00322 {
00323 _grf_id_overrides[source_grfid] = target_grfid;
00324 grfmsg(5, "SetNewGRFOverride: Added override of 0x%X to 0x%X", BSWAP32(source_grfid), BSWAP32(target_grfid));
00325 }
00326
00327 static Engine *GetNewEngine(const GRFFile *file, VehicleType type, uint16 internal_id)
00328 {
00329
00330
00331 const GRFFile *grf_match = NULL;
00332 if (_settings_game.vehicle.dynamic_engines) {
00333 uint32 override = _grf_id_overrides[file->grfid];
00334 if (override != 0) {
00335 grf_match = GetFileByGRFID(override);
00336 if (grf_match == NULL) {
00337 grfmsg(5, "Tried mapping from GRFID %x to %x but target is not loaded", BSWAP32(file->grfid), BSWAP32(override));
00338 } else {
00339 grfmsg(5, "Mapping from GRFID %x to %x", BSWAP32(file->grfid), BSWAP32(override));
00340 }
00341 }
00342 }
00343
00344
00345 Engine *e = NULL;
00346 FOR_ALL_ENGINES(e) {
00347 if (_settings_game.vehicle.dynamic_engines && e->grffile != NULL && e->grffile != file && e->grffile != grf_match) continue;
00348 if (e->type != type) continue;
00349 if (e->internal_id != internal_id) continue;
00350
00351 if (e->grffile == NULL) {
00352 e->grffile = file;
00353 grfmsg(5, "Replaced engine at index %d for GRFID %x, type %d, index %d", e->index, BSWAP32(file->grfid), type, internal_id);
00354 }
00355 return e;
00356 }
00357
00358 uint engine_pool_size = GetEnginePoolSize();
00359
00360
00361 e = new Engine(type, internal_id);
00362 e->grffile = file;
00363
00364 if (engine_pool_size != GetEnginePoolSize()) {
00365
00366 _gted = ReallocT(_gted, GetEnginePoolSize());
00367
00368
00369 size_t len = (GetEnginePoolSize() - engine_pool_size) * sizeof(*_gted);
00370 memset(_gted + engine_pool_size, 0, len);
00371 }
00372
00373 grfmsg(5, "Created new engine at index %d for GRFID %x, type %d, index %d", e->index, BSWAP32(file->grfid), type, internal_id);
00374
00375 return e;
00376 }
00377
00378 EngineID GetNewEngineID(const GRFFile *file, VehicleType type, uint16 internal_id)
00379 {
00380 extern uint32 GetNewGRFOverride(uint32 grfid);
00381
00382 const GRFFile *grf_match = NULL;
00383 if (_settings_game.vehicle.dynamic_engines) {
00384 uint32 override = _grf_id_overrides[file->grfid];
00385 if (override != 0) grf_match = GetFileByGRFID(override);
00386 }
00387
00388 const Engine *e = NULL;
00389 FOR_ALL_ENGINES(e) {
00390 if (_settings_game.vehicle.dynamic_engines && e->grffile != file && (grf_match == NULL || e->grffile != grf_match)) continue;
00391 if (e->type != type) continue;
00392 if (e->internal_id != internal_id) continue;
00393
00394 return e->index;
00395 }
00396
00397 return INVALID_ENGINE;
00398 }
00399
00403 static void MapSpriteMappingRecolour(PalSpriteID *grf_sprite)
00404 {
00405 if (HasBit(grf_sprite->pal, 14)) {
00406 ClrBit(grf_sprite->pal, 14);
00407 SetBit(grf_sprite->sprite, SPRITE_MODIFIER_OPAQUE);
00408 }
00409
00410 if (HasBit(grf_sprite->sprite, 14)) {
00411 ClrBit(grf_sprite->sprite, 14);
00412 SetBit(grf_sprite->sprite, PALETTE_MODIFIER_TRANSPARENT);
00413 }
00414
00415 if (HasBit(grf_sprite->sprite, 15)) {
00416 ClrBit(grf_sprite->sprite, 15);
00417 SetBit(grf_sprite->sprite, PALETTE_MODIFIER_COLOUR);
00418 }
00419 }
00420
00421 enum ChangeInfoResult {
00422 CIR_SUCCESS,
00423 CIR_UNHANDLED,
00424 CIR_UNKNOWN,
00425 CIR_INVALID_ID,
00426 };
00427
00428 typedef ChangeInfoResult (*VCI_Handler)(uint engine, int numinfo, int prop, byte **buf, int len);
00429
00430 static ChangeInfoResult CommonVehicleChangeInfo(EngineInfo *ei, int prop, byte **buf)
00431 {
00432 switch (prop) {
00433 case 0x00:
00434 ei->base_intro = grf_load_word(buf) + DAYS_TILL_ORIGINAL_BASE_YEAR;
00435 break;
00436
00437 case 0x02:
00438 ei->decay_speed = grf_load_byte(buf);
00439 break;
00440
00441 case 0x03:
00442 ei->lifelength = grf_load_byte(buf);
00443 break;
00444
00445 case 0x04:
00446 ei->base_life = grf_load_byte(buf);
00447 break;
00448
00449 case 0x06:
00450 ei->climates = grf_load_byte(buf);
00451
00452
00453 if (ei->climates == 0) ei->climates = 0x80;
00454 break;
00455
00456 case 0x07:
00457
00458 ei->load_amount = grf_load_byte(buf);
00459 break;
00460
00461 default:
00462 return CIR_UNKNOWN;
00463 }
00464
00465 return CIR_SUCCESS;
00466 }
00467
00468 static ChangeInfoResult RailVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)
00469 {
00470 byte *buf = *bufp;
00471 ChangeInfoResult ret = CIR_SUCCESS;
00472
00473 for (int i = 0; i < numinfo; i++) {
00474 Engine *e = GetNewEngine(_cur_grffile, VEH_TRAIN, engine + i);
00475 EngineInfo *ei = &e->info;
00476 RailVehicleInfo *rvi = &e->u.rail;
00477
00478 switch (prop) {
00479 case 0x05: {
00480 uint8 tracktype = grf_load_byte(&buf);
00481
00482 if (tracktype < _cur_grffile->railtype_max) {
00483 RailType railtype = GetRailTypeByLabel(_cur_grffile->railtype_list[tracktype]);
00484 if (railtype == INVALID_RAILTYPE) {
00485
00486 ei[i].climates = 0x80;
00487 } else {
00488 rvi[i].railtype = railtype;
00489 }
00490 break;
00491 }
00492
00493 switch (tracktype) {
00494 case 0: rvi->railtype = rvi->engclass >= 2 ? RAILTYPE_ELECTRIC : RAILTYPE_RAIL; break;
00495 case 1: rvi->railtype = RAILTYPE_MONO; break;
00496 case 2: rvi->railtype = RAILTYPE_MAGLEV; break;
00497 default:
00498 grfmsg(1, "RailVehicleChangeInfo: Invalid track type %d specified, ignoring", tracktype);
00499 break;
00500 }
00501 } break;
00502
00503 case 0x08:
00504
00505
00506 rvi->ai_passenger_only = grf_load_byte(&buf);
00507 break;
00508
00509 case 0x09: {
00510 uint16 speed = grf_load_word(&buf);
00511 if (speed == 0xFFFF) speed = 0;
00512
00513 rvi->max_speed = speed;
00514 } break;
00515
00516 case 0x0B:
00517 rvi->power = grf_load_word(&buf);
00518
00519
00520 if (rvi->power != 0) {
00521 if (rvi->railveh_type == RAILVEH_WAGON) {
00522 rvi->railveh_type = RAILVEH_SINGLEHEAD;
00523 }
00524 } else {
00525 rvi->railveh_type = RAILVEH_WAGON;
00526 }
00527 break;
00528
00529 case 0x0D:
00530 rvi->running_cost = grf_load_byte(&buf);
00531 break;
00532
00533 case 0x0E: {
00534 uint32 base = grf_load_dword(&buf);
00535
00536
00537
00538
00539 if (base == 0) {
00540 rvi->running_cost_class = 0xFF;
00541 } else if (base < 0x4B34 || base > 0x4C54 || (base - 0x4B34) % 6 != 0) {
00542 grfmsg(1, "RailVehicleChangeInfo: Unsupported running cost base 0x%04X, ignoring", base);
00543 } else {
00544
00545 rvi->running_cost_class = (base - 0x4B34) / 6;
00546 }
00547 } break;
00548
00549 case 0x12: {
00550 uint8 spriteid = grf_load_byte(&buf);
00551
00552
00553
00554 if (spriteid < 0xFD) spriteid >>= 1;
00555
00556 rvi->image_index = spriteid;
00557 } break;
00558
00559 case 0x13: {
00560 uint8 dual = grf_load_byte(&buf);
00561
00562 if (dual != 0) {
00563 rvi->railveh_type = RAILVEH_MULTIHEAD;
00564 } else {
00565 rvi->railveh_type = rvi->power == 0 ?
00566 RAILVEH_WAGON : RAILVEH_SINGLEHEAD;
00567 }
00568 } break;
00569
00570 case 0x14:
00571 rvi->capacity = grf_load_byte(&buf);
00572 break;
00573
00574 case 0x15: {
00575 uint8 ctype = grf_load_byte(&buf);
00576
00577 if (ctype < NUM_CARGO && HasBit(_cargo_mask, ctype)) {
00578 rvi->cargo_type = ctype;
00579 } else if (ctype == 0xFF) {
00580
00581 rvi->cargo_type = CT_INVALID;
00582 } else {
00583 rvi->cargo_type = CT_INVALID;
00584 grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, using first refittable", ctype);
00585 }
00586 } break;
00587
00588 case 0x16:
00589 SB(rvi->weight, 0, 8, grf_load_byte(&buf));
00590 break;
00591
00592 case 0x17:
00593 rvi->cost_factor = grf_load_byte(&buf);
00594 break;
00595
00596 case 0x18:
00597 rvi->ai_rank = grf_load_byte(&buf);
00598 break;
00599
00600 case 0x19: {
00601
00602
00603
00604
00605
00606
00607
00608 uint8 traction = grf_load_byte(&buf);
00609 EngineClass engclass;
00610
00611 if (traction <= 0x07) {
00612 engclass = EC_STEAM;
00613 } else if (traction <= 0x27) {
00614 engclass = EC_DIESEL;
00615 } else if (traction <= 0x31) {
00616 engclass = EC_ELECTRIC;
00617 } else if (traction <= 0x37) {
00618 engclass = EC_MONORAIL;
00619 } else if (traction <= 0x41) {
00620 engclass = EC_MAGLEV;
00621 } else {
00622 break;
00623 }
00624
00625 if (_cur_grffile->railtype_max == 0) {
00626
00627
00628 if (rvi->railtype == RAILTYPE_RAIL && engclass >= EC_ELECTRIC) rvi->railtype = RAILTYPE_ELECTRIC;
00629 if (rvi->railtype == RAILTYPE_ELECTRIC && engclass < EC_ELECTRIC) rvi->railtype = RAILTYPE_RAIL;
00630 }
00631
00632 rvi->engclass = engclass;
00633 } break;
00634
00635 case 0x1A:
00636 AlterVehicleListOrder(e->index, grf_load_extended(&buf));
00637 break;
00638
00639 case 0x1B:
00640 rvi->pow_wag_power = grf_load_word(&buf);
00641 break;
00642
00643 case 0x1C:
00644 ei->refit_cost = grf_load_byte(&buf);
00645 break;
00646
00647 case 0x1D:
00648 ei->refit_mask = grf_load_dword(&buf);
00649 break;
00650
00651 case 0x1E:
00652 ei->callbackmask = grf_load_byte(&buf);
00653 break;
00654
00655 case 0x1F:
00656 rvi->tractive_effort = grf_load_byte(&buf);
00657 break;
00658
00659 case 0x20:
00661 grf_load_byte(&buf);
00662 ret = CIR_UNHANDLED;
00663 break;
00664
00665 case 0x21:
00666 rvi->shorten_factor = grf_load_byte(&buf);
00667 break;
00668
00669 case 0x22:
00671 rvi->visual_effect = grf_load_byte(&buf);
00672 break;
00673
00674 case 0x23:
00675 rvi->pow_wag_weight = grf_load_byte(&buf);
00676 break;
00677
00678 case 0x24: {
00679 byte weight = grf_load_byte(&buf);
00680
00681 if (weight > 4) {
00682 grfmsg(2, "RailVehicleChangeInfo: Nonsensical weight of %d tons, ignoring", weight << 8);
00683 } else {
00684 SB(rvi->weight, 8, 8, weight);
00685 }
00686 } break;
00687
00688 case 0x25:
00689 rvi->user_def_data = grf_load_byte(&buf);
00690 break;
00691
00692 case 0x26:
00693 ei->retire_early = grf_load_byte(&buf);
00694 break;
00695
00696 case 0x27:
00697 ei->misc_flags = grf_load_byte(&buf);
00698 _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
00699 break;
00700
00701 case 0x28:
00702 _gted[e->index].cargo_allowed = grf_load_word(&buf);
00703 break;
00704
00705 case 0x29:
00706 _gted[e->index].cargo_disallowed = grf_load_word(&buf);
00707 break;
00708
00709 case 0x2A:
00710 ei->base_intro = grf_load_dword(&buf);
00711 break;
00712
00713 default:
00714 ret = CommonVehicleChangeInfo(ei, prop, &buf);
00715 break;
00716 }
00717 }
00718
00719 *bufp = buf;
00720 return ret;
00721 }
00722
00723 static ChangeInfoResult RoadVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)
00724 {
00725 byte *buf = *bufp;
00726 ChangeInfoResult ret = CIR_SUCCESS;
00727
00728 for (int i = 0; i < numinfo; i++) {
00729 Engine *e = GetNewEngine(_cur_grffile, VEH_ROAD, engine + i);
00730 EngineInfo *ei = &e->info;
00731 RoadVehicleInfo *rvi = &e->u.road;
00732
00733 switch (prop) {
00734 case 0x08:
00735 rvi->max_speed = grf_load_byte(&buf);
00736 break;
00737
00738 case 0x09:
00739 rvi->running_cost = grf_load_byte(&buf);
00740 break;
00741
00742 case 0x0A: {
00743 uint32 base = grf_load_dword(&buf);
00744
00745
00746
00747
00748 if (base == 0) {
00749 rvi->running_cost_class = 0xFF;
00750 } else if (base < 0x4B34 || base > 0x4C54 || (base - 0x4B34) % 6 != 0) {
00751 grfmsg(1, "RailVehicleChangeInfo: Unsupported running cost base 0x%04X, ignoring", base);
00752 } else {
00753
00754 rvi->running_cost_class = (base - 0x4B34) / 6;
00755 }
00756
00757 break;
00758 }
00759
00760 case 0x0E: {
00761 uint8 spriteid = grf_load_byte(&buf);
00762
00763
00764 if (spriteid == 0xFF) spriteid = 0xFD;
00765
00766 if (spriteid < 0xFD) spriteid >>= 1;
00767
00768 rvi->image_index = spriteid;
00769 } break;
00770
00771 case 0x0F:
00772 rvi->capacity = grf_load_byte(&buf);
00773 break;
00774
00775 case 0x10: {
00776 uint8 cargo = grf_load_byte(&buf);
00777
00778 if (cargo < NUM_CARGO && HasBit(_cargo_mask, cargo)) {
00779 rvi->cargo_type = cargo;
00780 } else if (cargo == 0xFF) {
00781 rvi->cargo_type = CT_INVALID;
00782 } else {
00783 rvi->cargo_type = CT_INVALID;
00784 grfmsg(2, "RoadVehicleChangeInfo: Invalid cargo type %d, using first refittable", cargo);
00785 }
00786 } break;
00787
00788 case 0x11:
00789 rvi->cost_factor = grf_load_byte(&buf);
00790 break;
00791
00792 case 0x12:
00793 rvi->sfx = (SoundFx)grf_load_byte(&buf);
00794 break;
00795
00796 case 0x13:
00797 rvi->power = grf_load_byte(&buf);
00798 break;
00799
00800 case 0x14:
00801 rvi->weight = grf_load_byte(&buf);
00802 break;
00803
00804 case 0x15:
00805 _gted[e->index].rv_max_speed = grf_load_byte(&buf);
00806 break;
00807
00808 case 0x16:
00809 ei->refit_mask = grf_load_dword(&buf);
00810 break;
00811
00812 case 0x17:
00813 ei->callbackmask = grf_load_byte(&buf);
00814 break;
00815
00816 case 0x18:
00817 rvi->tractive_effort = grf_load_byte(&buf);
00818 break;
00819
00820 case 0x19:
00821 rvi->air_drag = grf_load_byte(&buf);
00822 break;
00823
00824 case 0x1A:
00825 ei->refit_cost = grf_load_byte(&buf);
00826 break;
00827
00828 case 0x1B:
00829 ei->retire_early = grf_load_byte(&buf);
00830 break;
00831
00832 case 0x1C:
00833 ei->misc_flags = grf_load_byte(&buf);
00834 _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
00835 break;
00836
00837 case 0x1D:
00838 _gted[e->index].cargo_allowed = grf_load_word(&buf);
00839 break;
00840
00841 case 0x1E:
00842 _gted[e->index].cargo_disallowed = grf_load_word(&buf);
00843 break;
00844
00845 case 0x1F:
00846 ei->base_intro = grf_load_dword(&buf);
00847 break;
00848
00849 case 0x20:
00850 AlterVehicleListOrder(e->index, grf_load_extended(&buf));
00851 break;
00852
00853 default:
00854 ret = CommonVehicleChangeInfo(ei, prop, &buf);
00855 break;
00856 }
00857 }
00858
00859 *bufp = buf;
00860 return ret;
00861 }
00862
00863 static ChangeInfoResult ShipVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)
00864 {
00865 byte *buf = *bufp;
00866 ChangeInfoResult ret = CIR_SUCCESS;
00867
00868 for (int i = 0; i < numinfo; i++) {
00869 Engine *e = GetNewEngine(_cur_grffile, VEH_SHIP, engine + i);
00870 EngineInfo *ei = &e->info;
00871 ShipVehicleInfo *svi = &e->u.ship;
00872
00873 switch (prop) {
00874 case 0x08: {
00875 uint8 spriteid = grf_load_byte(&buf);
00876
00877
00878 if (spriteid == 0xFF) spriteid = 0xFD;
00879
00880 if (spriteid < 0xFD) spriteid >>= 1;
00881
00882 svi->image_index = spriteid;
00883 } break;
00884
00885 case 0x09:
00886 svi->refittable = (grf_load_byte(&buf) != 0);
00887 break;
00888
00889 case 0x0A:
00890 svi->cost_factor = grf_load_byte(&buf);
00891 break;
00892
00893 case 0x0B:
00894 svi->max_speed = grf_load_byte(&buf);
00895 break;
00896
00897 case 0x0C: {
00898 uint8 cargo = grf_load_byte(&buf);
00899
00900 if (cargo < NUM_CARGO && HasBit(_cargo_mask, cargo)) {
00901 svi->cargo_type = cargo;
00902 } else if (cargo == 0xFF) {
00903 svi->cargo_type = CT_INVALID;
00904 } else {
00905 svi->cargo_type = CT_INVALID;
00906 grfmsg(2, "ShipVehicleChangeInfo: Invalid cargo type %d, using first refittable", cargo);
00907 }
00908 } break;
00909
00910 case 0x0D:
00911 svi->capacity = grf_load_word(&buf);
00912 break;
00913
00914 case 0x0F:
00915 svi->running_cost = grf_load_byte(&buf);
00916 break;
00917
00918 case 0x10:
00919 svi->sfx = (SoundFx)grf_load_byte(&buf);
00920 break;
00921
00922 case 0x11:
00923 ei->refit_mask = grf_load_dword(&buf);
00924 break;
00925
00926 case 0x12:
00927 ei->callbackmask = grf_load_byte(&buf);
00928 break;
00929
00930 case 0x13:
00931 ei->refit_cost = grf_load_byte(&buf);
00932 break;
00933
00934 case 0x14:
00935 case 0x15:
00937 grf_load_byte(&buf);
00938 ret = CIR_UNHANDLED;
00939 break;
00940
00941 case 0x16:
00942 ei->retire_early = grf_load_byte(&buf);
00943 break;
00944
00945 case 0x17:
00946 ei->misc_flags = grf_load_byte(&buf);
00947 _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
00948 break;
00949
00950 case 0x18:
00951 _gted[e->index].cargo_allowed = grf_load_word(&buf);
00952 break;
00953
00954 case 0x19:
00955 _gted[e->index].cargo_disallowed = grf_load_word(&buf);
00956 break;
00957
00958 case 0x1A:
00959 ei->base_intro = grf_load_dword(&buf);
00960 break;
00961
00962 case 0x1B:
00963 AlterVehicleListOrder(e->index, grf_load_extended(&buf));
00964 break;
00965
00966 default:
00967 ret = CommonVehicleChangeInfo(ei, prop, &buf);
00968 break;
00969 }
00970 }
00971
00972 *bufp = buf;
00973 return ret;
00974 }
00975
00976 static ChangeInfoResult AircraftVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)
00977 {
00978 byte *buf = *bufp;
00979 ChangeInfoResult ret = CIR_SUCCESS;
00980
00981 for (int i = 0; i < numinfo; i++) {
00982 Engine *e = GetNewEngine(_cur_grffile, VEH_AIRCRAFT, engine + i);
00983 EngineInfo *ei = &e->info;
00984 AircraftVehicleInfo *avi = &e->u.air;
00985
00986 switch (prop) {
00987 case 0x08: {
00988 uint8 spriteid = grf_load_byte(&buf);
00989
00990
00991 if (spriteid == 0xFF) spriteid = 0xFD;
00992
00993 if (spriteid < 0xFD) spriteid >>= 1;
00994
00995 avi->image_index = spriteid;
00996 } break;
00997
00998 case 0x09:
00999 if (grf_load_byte(&buf) == 0) {
01000 avi->subtype = AIR_HELI;
01001 } else {
01002 SB(avi->subtype, 0, 1, 1);
01003 }
01004 break;
01005
01006 case 0x0A:
01007 SB(avi->subtype, 1, 1, (grf_load_byte(&buf) != 0 ? 1 : 0));
01008 break;
01009
01010 case 0x0B:
01011 avi->cost_factor = grf_load_byte(&buf);
01012 break;
01013
01014 case 0x0C:
01015 avi->max_speed = (grf_load_byte(&buf) * 129) / 10;
01016 break;
01017
01018 case 0x0D:
01019 avi->acceleration = (grf_load_byte(&buf) * 129) / 10;
01020 break;
01021
01022 case 0x0E:
01023 avi->running_cost = grf_load_byte(&buf);
01024 break;
01025
01026 case 0x0F:
01027 avi->passenger_capacity = grf_load_word(&buf);
01028 break;
01029
01030 case 0x11:
01031 avi->mail_capacity = grf_load_byte(&buf);
01032 break;
01033
01034 case 0x12:
01035 avi->sfx = (SoundFx)grf_load_byte(&buf);
01036 break;
01037
01038 case 0x13:
01039 ei->refit_mask = grf_load_dword(&buf);
01040 break;
01041
01042 case 0x14:
01043 ei->callbackmask = grf_load_byte(&buf);
01044 break;
01045
01046 case 0x15:
01047 ei->refit_cost = grf_load_byte(&buf);
01048 break;
01049
01050 case 0x16:
01051 ei->retire_early = grf_load_byte(&buf);
01052 break;
01053
01054 case 0x17:
01055 ei->misc_flags = grf_load_byte(&buf);
01056 _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
01057 break;
01058
01059 case 0x18:
01060 _gted[e->index].cargo_allowed = grf_load_word(&buf);
01061 break;
01062
01063 case 0x19:
01064 _gted[e->index].cargo_disallowed = grf_load_word(&buf);
01065 break;
01066
01067 case 0x1A:
01068 ei->base_intro = grf_load_dword(&buf);
01069 break;
01070
01071 case 0x1B:
01072 AlterVehicleListOrder(e->index, grf_load_extended(&buf));
01073 break;
01074
01075 default:
01076 ret = CommonVehicleChangeInfo(ei, prop, &buf);
01077 break;
01078 }
01079 }
01080
01081 *bufp = buf;
01082 return ret;
01083 }
01084
01085 static ChangeInfoResult StationChangeInfo(uint stid, int numinfo, int prop, byte **bufp, int len)
01086 {
01087 byte *buf = *bufp;
01088 ChangeInfoResult ret = CIR_SUCCESS;
01089
01090 if (stid + numinfo > MAX_STATIONS) {
01091 grfmsg(1, "StationChangeInfo: Station %u is invalid, max %u, ignoring", stid + numinfo, MAX_STATIONS);
01092 return CIR_INVALID_ID;
01093 }
01094
01095
01096 if (_cur_grffile->stations == NULL) _cur_grffile->stations = CallocT<StationSpec*>(MAX_STATIONS);
01097
01098 for (int i = 0; i < numinfo; i++) {
01099 StationSpec *statspec = _cur_grffile->stations[stid + i];
01100
01101
01102 if (statspec == NULL && prop != 0x08) {
01103 grfmsg(2, "StationChangeInfo: Attempt to modify undefined station %u, ignoring", stid + i);
01104 return CIR_INVALID_ID;
01105 }
01106
01107 switch (prop) {
01108 case 0x08: {
01109 StationSpec **spec = &_cur_grffile->stations[stid + i];
01110
01111
01112 if (*spec == NULL) *spec = CallocT<StationSpec>(1);
01113
01114
01115 uint32 classid = grf_load_dword(&buf);
01116 (*spec)->sclass = AllocateStationClass(BSWAP32(classid));
01117 } break;
01118
01119 case 0x09:
01120 statspec->tiles = grf_load_extended(&buf);
01121 statspec->renderdata = CallocT<DrawTileSprites>(statspec->tiles);
01122 statspec->copied_renderdata = false;
01123
01124 for (uint t = 0; t < statspec->tiles; t++) {
01125 DrawTileSprites *dts = &statspec->renderdata[t];
01126 uint seq_count = 0;
01127
01128 dts->seq = NULL;
01129 dts->ground.sprite = grf_load_word(&buf);
01130 dts->ground.pal = grf_load_word(&buf);
01131 if (dts->ground.sprite == 0) continue;
01132 if (HasBit(dts->ground.pal, 15)) {
01133 ClrBit(dts->ground.pal, 15);
01134 SetBit(dts->ground.sprite, SPRITE_MODIFIER_USE_OFFSET);
01135 }
01136
01137 MapSpriteMappingRecolour(&dts->ground);
01138
01139 while (buf < *bufp + len) {
01140 DrawTileSeqStruct *dtss;
01141
01142
01143 dts->seq = ReallocT((DrawTileSeqStruct*)dts->seq, ++seq_count);
01144 dtss = (DrawTileSeqStruct*) &dts->seq[seq_count - 1];
01145
01146 dtss->delta_x = grf_load_byte(&buf);
01147 if ((byte) dtss->delta_x == 0x80) break;
01148 dtss->delta_y = grf_load_byte(&buf);
01149 dtss->delta_z = grf_load_byte(&buf);
01150 dtss->size_x = grf_load_byte(&buf);
01151 dtss->size_y = grf_load_byte(&buf);
01152 dtss->size_z = grf_load_byte(&buf);
01153 dtss->image.sprite = grf_load_word(&buf);
01154 dtss->image.pal = grf_load_word(&buf);
01155
01156
01157 if (HasBit(dtss->image.pal, 15)) {
01158 ClrBit(dtss->image.pal, 15);
01159 SetBit(dtss->image.sprite, SPRITE_MODIFIER_USE_OFFSET);
01160 }
01161
01162 MapSpriteMappingRecolour(&dtss->image);
01163 }
01164 }
01165 break;
01166
01167 case 0x0A: {
01168 byte srcid = grf_load_byte(&buf);
01169 const StationSpec *srcstatspec = _cur_grffile->stations[srcid];
01170
01171 statspec->tiles = srcstatspec->tiles;
01172 statspec->renderdata = srcstatspec->renderdata;
01173 statspec->copied_renderdata = true;
01174 } break;
01175
01176 case 0x0B:
01177 statspec->callbackmask = grf_load_byte(&buf);
01178 break;
01179
01180 case 0x0C:
01181 statspec->disallowed_platforms = grf_load_byte(&buf);
01182 break;
01183
01184 case 0x0D:
01185 statspec->disallowed_lengths = grf_load_byte(&buf);
01186 break;
01187
01188 case 0x0E:
01189 statspec->copied_layouts = false;
01190
01191 while (buf < *bufp + len) {
01192 byte length = grf_load_byte(&buf);
01193 byte number = grf_load_byte(&buf);
01194 StationLayout layout;
01195 uint l, p;
01196
01197 if (length == 0 || number == 0) break;
01198
01199
01200 if (length > statspec->lengths) {
01201 statspec->platforms = ReallocT(statspec->platforms, length);
01202 memset(statspec->platforms + statspec->lengths, 0, length - statspec->lengths);
01203
01204 statspec->layouts = ReallocT(statspec->layouts, length);
01205 memset(statspec->layouts + statspec->lengths, 0,
01206 (length - statspec->lengths) * sizeof(*statspec->layouts));
01207
01208 statspec->lengths = length;
01209 }
01210 l = length - 1;
01211
01212
01213 if (number > statspec->platforms[l]) {
01214 statspec->layouts[l] = ReallocT(statspec->layouts[l], number);
01215
01216 memset(statspec->layouts[l] + statspec->platforms[l], 0,
01217 (number - statspec->platforms[l]) * sizeof(**statspec->layouts));
01218
01219 statspec->platforms[l] = number;
01220 }
01221
01222 p = 0;
01223 layout = MallocT<byte>(length * number);
01224 for (l = 0; l < length; l++) {
01225 for (p = 0; p < number; p++) {
01226 layout[l * number + p] = grf_load_byte(&buf);
01227 }
01228 }
01229
01230 l--;
01231 p--;
01232 free(statspec->layouts[l][p]);
01233 statspec->layouts[l][p] = layout;
01234 }
01235 break;
01236
01237 case 0x0F: {
01238 byte srcid = grf_load_byte(&buf);
01239 const StationSpec *srcstatspec = _cur_grffile->stations[srcid];
01240
01241 statspec->lengths = srcstatspec->lengths;
01242 statspec->platforms = srcstatspec->platforms;
01243 statspec->layouts = srcstatspec->layouts;
01244 statspec->copied_layouts = true;
01245 } break;
01246
01247 case 0x10:
01248 statspec->cargo_threshold = grf_load_word(&buf);
01249 break;
01250
01251 case 0x11:
01252 statspec->pylons = grf_load_byte(&buf);
01253 break;
01254
01255 case 0x12:
01256 statspec->cargo_triggers = grf_load_dword(&buf);
01257 break;
01258
01259 case 0x13:
01260 statspec->flags = grf_load_byte(&buf);
01261 break;
01262
01263 case 0x14:
01264 statspec->wires = grf_load_byte(&buf);
01265 break;
01266
01267 case 0x15:
01268 statspec->blocked = grf_load_byte(&buf);
01269 break;
01270
01271 case 0x16:
01272 statspec->anim_frames = grf_load_byte(&buf);
01273 statspec->anim_status = grf_load_byte(&buf);
01274 break;
01275
01276 case 0x17:
01277 statspec->anim_speed = grf_load_byte(&buf);
01278 break;
01279
01280 case 0x18:
01281 statspec->anim_triggers = grf_load_word(&buf);
01282 break;
01283
01284 default:
01285 ret = CIR_UNKNOWN;
01286 break;
01287 }
01288 }
01289
01290 *bufp = buf;
01291 return ret;
01292 }
01293
01294 static ChangeInfoResult CanalChangeInfo(uint id, int numinfo, int prop, byte **bufp, int len)
01295 {
01296 byte *buf = *bufp;
01297 ChangeInfoResult ret = CIR_SUCCESS;
01298
01299 if (id + numinfo > CF_END) {
01300 grfmsg(1, "CanalChangeInfo: Canal feature %u is invalid, max %u, ignoreing", id + numinfo, CF_END);
01301 return CIR_INVALID_ID;
01302 }
01303
01304 for (int i = 0; i < numinfo; i++) {
01305 WaterFeature *wf = &_water_feature[id + i];
01306
01307 switch (prop) {
01308 case 0x08:
01309 wf->callbackmask = grf_load_byte(&buf);
01310 break;
01311
01312 case 0x09:
01313 wf->flags = grf_load_byte(&buf);
01314 break;
01315
01316 default:
01317 ret = CIR_UNKNOWN;
01318 break;
01319 }
01320 }
01321
01322 *bufp = buf;
01323 return ret;
01324 }
01325
01326 static ChangeInfoResult BridgeChangeInfo(uint brid, int numinfo, int prop, byte **bufp, int len)
01327 {
01328 byte *buf = *bufp;
01329 ChangeInfoResult ret = CIR_SUCCESS;
01330
01331 if (brid + numinfo > MAX_BRIDGES) {
01332 grfmsg(1, "BridgeChangeInfo: Bridge %u is invalid, max %u, ignoring", brid + numinfo, MAX_BRIDGES);
01333 return CIR_INVALID_ID;
01334 }
01335
01336 for (int i = 0; i < numinfo; i++) {
01337 BridgeSpec *bridge = &_bridge[brid + i];
01338
01339 switch (prop) {
01340 case 0x08:
01341 bridge->avail_year = ORIGINAL_BASE_YEAR + grf_load_byte(&buf);
01342 break;
01343
01344 case 0x09:
01345 bridge->min_length = grf_load_byte(&buf);
01346 break;
01347
01348 case 0x0A:
01349 bridge->max_length = grf_load_byte(&buf);
01350 break;
01351
01352 case 0x0B:
01353 bridge->price = grf_load_byte(&buf);
01354 break;
01355
01356 case 0x0C:
01357 bridge->speed = grf_load_word(&buf);
01358 break;
01359
01360 case 0x0D: {
01361 byte tableid = grf_load_byte(&buf);
01362 byte numtables = grf_load_byte(&buf);
01363
01364 if (bridge->sprite_table == NULL) {
01365
01366 bridge->sprite_table = CallocT<PalSpriteID*>(7);
01367 }
01368
01369 for (; numtables-- != 0; tableid++) {
01370 if (tableid >= 7) {
01371 grfmsg(1, "BridgeChangeInfo: Table %d >= 7, skipping", tableid);
01372 for (byte sprite = 0; sprite < 32; sprite++) grf_load_dword(&buf);
01373 continue;
01374 }
01375
01376 if (bridge->sprite_table[tableid] == NULL) {
01377 bridge->sprite_table[tableid] = MallocT<PalSpriteID>(32);
01378 }
01379
01380 for (byte sprite = 0; sprite < 32; sprite++) {
01381 SpriteID image = grf_load_word(&buf);
01382 SpriteID pal = grf_load_word(&buf);
01383
01384 bridge->sprite_table[tableid][sprite].sprite = image;
01385 bridge->sprite_table[tableid][sprite].pal = pal;
01386
01387 MapSpriteMappingRecolour(&bridge->sprite_table[tableid][sprite]);
01388 }
01389 }
01390 } break;
01391
01392 case 0x0E:
01393 bridge->flags = grf_load_byte(&buf);
01394 break;
01395
01396 case 0x0F:
01397 bridge->avail_year = Clamp(grf_load_dword(&buf), MIN_YEAR, MAX_YEAR);
01398 break;
01399
01400 case 0x10: {
01401 StringID newone = GetGRFStringID(_cur_grffile->grfid, grf_load_word(&buf));
01402 if (newone != STR_UNDEFINED) bridge->material = newone;
01403 } break;
01404
01405 case 0x11:
01406 case 0x12: {
01407 StringID newone = GetGRFStringID(_cur_grffile->grfid, grf_load_word(&buf));
01408 if (newone != STR_UNDEFINED) bridge->transport_name[prop - 0x11] = newone;
01409 } break;
01410
01411 case 0x13:
01412 bridge->price = grf_load_word(&buf);
01413 break;
01414
01415 default:
01416 ret = CIR_UNKNOWN;
01417 break;
01418 }
01419 }
01420
01421 *bufp = buf;
01422 return ret;
01423 }
01424
01425 static ChangeInfoResult TownHouseChangeInfo(uint hid, int numinfo, int prop, byte **bufp, int len)
01426 {
01427 byte *buf = *bufp;
01428 ChangeInfoResult ret = CIR_SUCCESS;
01429
01430 if (hid + numinfo > HOUSE_MAX) {
01431 grfmsg(1, "TownHouseChangeInfo: Too many houses loaded (%u), max (%u). Ignoring.", hid + numinfo, HOUSE_MAX);
01432 return CIR_INVALID_ID;
01433 }
01434
01435
01436 if (_cur_grffile->housespec == NULL) {
01437 _cur_grffile->housespec = CallocT<HouseSpec*>(HOUSE_MAX);
01438 }
01439
01440 for (int i = 0; i < numinfo; i++) {
01441 HouseSpec *housespec = _cur_grffile->housespec[hid + i];
01442
01443 if (prop != 0x08 && housespec == NULL) {
01444 grfmsg(2, "TownHouseChangeInfo: Attempt to modify undefined house %u. Ignoring.", hid + i);
01445 return CIR_INVALID_ID;
01446 }
01447
01448 switch (prop) {
01449 case 0x08: {
01450 HouseSpec **house = &_cur_grffile->housespec[hid + i];
01451 byte subs_id = grf_load_byte(&buf);
01452
01453 if (subs_id == 0xFF) {
01454
01455
01456 _house_specs[hid + i].enabled = false;
01457 continue;
01458 } else if (subs_id >= NEW_HOUSE_OFFSET) {
01459
01460 grfmsg(2, "TownHouseChangeInfo: Attempt to use new house %u as substitute house for %u. Ignoring.", subs_id, hid + i);
01461 continue;
01462 }
01463
01464
01465 if (*house == NULL) *house = CallocT<HouseSpec>(1);
01466
01467 housespec = *house;
01468
01469 memcpy(housespec, &_house_specs[subs_id], sizeof(_house_specs[subs_id]));
01470
01471 housespec->enabled = true;
01472 housespec->local_id = hid + i;
01473 housespec->substitute_id = subs_id;
01474 housespec->grffile = _cur_grffile;
01475 housespec->random_colour[0] = 0x04;
01476 housespec->random_colour[1] = 0x08;
01477 housespec->random_colour[2] = 0x0C;
01478 housespec->random_colour[3] = 0x06;
01479
01480
01481
01482
01483
01484 if (!GetCargo(housespec->accepts_cargo[2])->IsValid()) {
01485 housespec->cargo_acceptance[2] = 0;
01486 }
01487
01493 if (housespec->min_year < 1930) housespec->min_year = 1930;
01494
01495 _loaded_newgrf_features.has_newhouses = true;
01496 } break;
01497
01498 case 0x09:
01499 housespec->building_flags = (BuildingFlags)grf_load_byte(&buf);
01500 break;
01501
01502 case 0x0A: {
01503 uint16 years = grf_load_word(&buf);
01504 housespec->min_year = GB(years, 0, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 0, 8);
01505 housespec->max_year = GB(years, 8, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 8, 8);
01506 } break;
01507
01508 case 0x0B:
01509 housespec->population = grf_load_byte(&buf);
01510 break;
01511
01512 case 0x0C:
01513 housespec->mail_generation = grf_load_byte(&buf);
01514 break;
01515
01516 case 0x0D:
01517 case 0x0E:
01518 housespec->cargo_acceptance[prop - 0x0D] = grf_load_byte(&buf);
01519 break;
01520
01521 case 0x0F: {
01522 int8 goods = grf_load_byte(&buf);
01523
01524
01525
01526 CargoID cid = (goods >= 0) ? ((_settings_game.game_creation.landscape == LT_TOYLAND) ? CT_CANDY : CT_GOODS) :
01527 ((_settings_game.game_creation.landscape == LT_TOYLAND) ? CT_FIZZY_DRINKS : CT_FOOD);
01528
01529
01530 if (!GetCargo(cid)->IsValid()) goods = 0;
01531
01532 housespec->accepts_cargo[2] = cid;
01533 housespec->cargo_acceptance[2] = abs(goods);
01534 } break;
01535
01536 case 0x10:
01537 housespec->remove_rating_decrease = grf_load_word(&buf);
01538 break;
01539
01540 case 0x11:
01541 housespec->removal_cost = grf_load_byte(&buf);
01542 break;
01543
01544 case 0x12:
01545 housespec->building_name = grf_load_word(&buf);
01546 _string_to_grf_mapping[&housespec->building_name] = _cur_grffile->grfid;
01547 break;
01548
01549 case 0x13:
01550 housespec->building_availability = (HouseZones)grf_load_word(&buf);
01551 break;
01552
01553 case 0x14:
01554 housespec->callback_mask = grf_load_byte(&buf);
01555 break;
01556
01557 case 0x15: {
01558 byte override = grf_load_byte(&buf);
01559
01560
01561 if (override >= NEW_HOUSE_OFFSET) {
01562 grfmsg(2, "TownHouseChangeInfo: Attempt to override new house %u with house id %u. Ignoring.", override, hid + i);
01563 continue;
01564 }
01565
01566 _house_mngr.Add(hid + i, _cur_grffile->grfid, override);
01567 } break;
01568
01569 case 0x16:
01570 housespec->processing_time = grf_load_byte(&buf);
01571 break;
01572
01573 case 0x17:
01574 for (uint j = 0; j < 4; j++) housespec->random_colour[j] = grf_load_byte(&buf);
01575 break;
01576
01577 case 0x18:
01578 housespec->probability = grf_load_byte(&buf);
01579 break;
01580
01581 case 0x19:
01582 housespec->extra_flags = (HouseExtraFlags)grf_load_byte(&buf);
01583 break;
01584
01585 case 0x1A:
01586 housespec->animation_frames = grf_load_byte(&buf);
01587 break;
01588
01589 case 0x1B:
01590 housespec->animation_speed = Clamp(grf_load_byte(&buf), 2, 16);
01591 break;
01592
01593 case 0x1C:
01594 housespec->class_id = AllocateHouseClassID(grf_load_byte(&buf), _cur_grffile->grfid);
01595 break;
01596
01597 case 0x1D:
01598 housespec->callback_mask |= (grf_load_byte(&buf) << 8);
01599 break;
01600
01601 case 0x1E: {
01602 uint32 cargotypes = grf_load_dword(&buf);
01603
01604
01605 if (cargotypes == 0xFFFFFFFF) break;
01606
01607 for (uint j = 0; j < 3; j++) {
01608
01609 uint8 cargo_part = GB(cargotypes, 8 * j, 8);
01610 CargoID cargo = GetCargoTranslation(cargo_part, _cur_grffile);
01611
01612 if (cargo == CT_INVALID) {
01613
01614 housespec->cargo_acceptance[j] = 0;
01615 } else {
01616 housespec->accepts_cargo[j] = cargo;
01617 }
01618 }
01619 } break;
01620
01621 case 0x1F:
01622 housespec->minimum_life = grf_load_byte(&buf);
01623 break;
01624
01625 case 0x20: {
01626 byte count = grf_load_byte(&buf);
01627 for (byte j = 0; j < count; j++) grf_load_byte(&buf);
01628 ret = CIR_UNHANDLED;
01629 } break;
01630
01631 case 0x21:
01632 housespec->min_year = grf_load_word(&buf);
01633 break;
01634
01635 case 0x22:
01636 housespec->max_year = grf_load_word(&buf);
01637 break;
01638
01639 default:
01640 ret = CIR_UNKNOWN;
01641 break;
01642 }
01643 }
01644
01645 *bufp = buf;
01646 return ret;
01647 }
01648
01649 static ChangeInfoResult GlobalVarChangeInfo(uint gvid, int numinfo, int prop, byte **bufp, int len)
01650 {
01651 byte *buf = *bufp;
01652 ChangeInfoResult ret = CIR_SUCCESS;
01653
01654 for (int i = 0; i < numinfo; i++) {
01655 switch (prop) {
01656 case 0x08: {
01657 byte factor = grf_load_byte(&buf);
01658 uint price = gvid + i;
01659
01660 if (price < NUM_PRICES) {
01661 SetPriceBaseMultiplier(price, factor);
01662 } else {
01663 grfmsg(1, "GlobalVarChangeInfo: Price %d out of range, ignoring", price);
01664 }
01665 } break;
01666
01667 case 0x09:
01668
01669
01670 buf += 4;
01671 break;
01672
01673 case 0x0A: {
01674 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
01675 StringID newone = GetGRFStringID(_cur_grffile->grfid, grf_load_word(&buf));
01676
01677 if ((newone != STR_UNDEFINED) && (curidx < NUM_CURRENCY)) {
01678 _currency_specs[curidx].name = newone;
01679 }
01680 } break;
01681
01682 case 0x0B: {
01683 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
01684 uint32 rate = grf_load_dword(&buf);
01685
01686 if (curidx < NUM_CURRENCY) {
01687
01688
01689
01690 _currency_specs[curidx].rate = rate / 1000;
01691 } else {
01692 grfmsg(1, "GlobalVarChangeInfo: Currency multipliers %d out of range, ignoring", curidx);
01693 }
01694 } break;
01695
01696 case 0x0C: {
01697 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
01698 uint16 options = grf_load_word(&buf);
01699
01700 if (curidx < NUM_CURRENCY) {
01701 _currency_specs[curidx].separator = GB(options, 0, 8);
01702
01703
01704 _currency_specs[curidx].symbol_pos = GB(options, 8, 1);
01705 } else {
01706 grfmsg(1, "GlobalVarChangeInfo: Currency option %d out of range, ignoring", curidx);
01707 }
01708 } break;
01709
01710 case 0x0D: {
01711 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
01712 uint32 tempfix = grf_load_dword(&buf);
01713
01714 if (curidx < NUM_CURRENCY) {
01715 memcpy(_currency_specs[curidx].prefix, &tempfix, 4);
01716 _currency_specs[curidx].prefix[4] = 0;
01717 } else {
01718 grfmsg(1, "GlobalVarChangeInfo: Currency symbol %d out of range, ignoring", curidx);
01719 }
01720 } break;
01721
01722 case 0x0E: {
01723 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
01724 uint32 tempfix = grf_load_dword(&buf);
01725
01726 if (curidx < NUM_CURRENCY) {
01727 memcpy(&_currency_specs[curidx].suffix, &tempfix, 4);
01728 _currency_specs[curidx].suffix[4] = 0;
01729 } else {
01730 grfmsg(1, "GlobalVarChangeInfo: Currency symbol %d out of range, ignoring", curidx);
01731 }
01732 } break;
01733
01734 case 0x0F: {
01735 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
01736 Year year_euro = grf_load_word(&buf);
01737
01738 if (curidx < NUM_CURRENCY) {
01739 _currency_specs[curidx].to_euro = year_euro;
01740 } else {
01741 grfmsg(1, "GlobalVarChangeInfo: Euro intro date %d out of range, ignoring", curidx);
01742 }
01743 } break;
01744
01745 case 0x10:
01746 if (numinfo > 1 || IsSnowLineSet()) {
01747 grfmsg(1, "GlobalVarChangeInfo: The snowline can only be set once (%d)", numinfo);
01748 } else if (len < SNOW_LINE_MONTHS * SNOW_LINE_DAYS) {
01749 grfmsg(1, "GlobalVarChangeInfo: Not enough entries set in the snowline table (%d)", len);
01750 } else {
01751 byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS];
01752
01753 for (uint i = 0; i < SNOW_LINE_MONTHS; i++) {
01754 for (uint j = 0; j < SNOW_LINE_DAYS; j++) {
01755 table[i][j] = grf_load_byte(&buf);
01756 }
01757 }
01758 SetSnowLine(table);
01759 }
01760 break;
01761
01762 case 0x11:
01763
01764
01765 buf += 8;
01766 break;
01767
01768 case 0x12:
01769
01770
01771 buf += 4;
01772 break;
01773
01774 default:
01775 ret = CIR_UNKNOWN;
01776 break;
01777 }
01778 }
01779
01780 *bufp = buf;
01781 return ret;
01782 }
01783
01784 static ChangeInfoResult GlobalVarReserveInfo(uint gvid, int numinfo, int prop, byte **bufp, int len)
01785 {
01786 byte *buf = *bufp;
01787 ChangeInfoResult ret = CIR_SUCCESS;
01788
01789 for (int i = 0; i < numinfo; i++) {
01790 switch (prop) {
01791 case 0x08:
01792 grf_load_byte(&buf);
01793 break;
01794
01795 case 0x09: {
01796 if (i == 0) {
01797 if (gvid != 0) {
01798 grfmsg(1, "ReserveChangeInfo: Cargo translation table must start at zero");
01799 return CIR_INVALID_ID;
01800 }
01801
01802 free(_cur_grffile->cargo_list);
01803 _cur_grffile->cargo_max = numinfo;
01804 _cur_grffile->cargo_list = MallocT<CargoLabel>(numinfo);
01805 }
01806
01807 CargoLabel cl = grf_load_dword(&buf);
01808 _cur_grffile->cargo_list[i] = BSWAP32(cl);
01809 break;
01810 }
01811
01812 case 0x0A:
01813 case 0x0C:
01814 case 0x0F:
01815 grf_load_word(&buf);
01816 break;
01817
01818 case 0x0B:
01819 case 0x0D:
01820 case 0x0E:
01821 grf_load_dword(&buf);
01822 break;
01823
01824 case 0x10:
01825 buf += SNOW_LINE_MONTHS * SNOW_LINE_DAYS;
01826 break;
01827
01828 case 0x11: {
01829 uint32 s = grf_load_dword(&buf);
01830 uint32 t = grf_load_dword(&buf);
01831 SetNewGRFOverride(s, t);
01832 break;
01833 }
01834
01835 case 0x12: {
01836 if (i == 0) {
01837 if (gvid != 0) {
01838 grfmsg(1, "ReserveChangeInfo: Rail type translation table must start at zero");
01839 return CIR_INVALID_ID;
01840 }
01841
01842 free(_cur_grffile->railtype_list);
01843 _cur_grffile->railtype_max = numinfo;
01844 _cur_grffile->railtype_list = MallocT<RailTypeLabel>(numinfo);
01845 }
01846
01847 RailTypeLabel rtl = grf_load_dword(&buf);
01848 _cur_grffile->railtype_list[i] = BSWAP32(rtl);
01849 break;
01850 }
01851
01852 default:
01853 ret = CIR_UNKNOWN;
01854 break;
01855 }
01856 }
01857
01858 *bufp = buf;
01859 return ret;
01860 }
01861
01862
01863 static ChangeInfoResult CargoChangeInfo(uint cid, int numinfo, int prop, byte **bufp, int len)
01864 {
01865 byte *buf = *bufp;
01866 ChangeInfoResult ret = CIR_SUCCESS;
01867
01868 if (cid + numinfo > NUM_CARGO) {
01869 grfmsg(2, "CargoChangeInfo: Cargo type %d out of range (max %d)", cid + numinfo, NUM_CARGO - 1);
01870 return CIR_INVALID_ID;
01871 }
01872
01873 for (int i = 0; i < numinfo; i++) {
01874 CargoSpec *cs = &_cargo[cid + i];
01875
01876 switch (prop) {
01877 case 0x08:
01878 cs->bitnum = grf_load_byte(&buf);
01879 if (cs->IsValid()) {
01880 cs->grffile = _cur_grffile;
01881 SetBit(_cargo_mask, cid + i);
01882 } else {
01883 ClrBit(_cargo_mask, cid + i);
01884 }
01885 break;
01886
01887 case 0x09:
01888 cs->name = grf_load_word(&buf);
01889 _string_to_grf_mapping[&cs->name] = _cur_grffile->grfid;
01890 break;
01891
01892 case 0x0A:
01893 cs->name_single = grf_load_word(&buf);
01894 _string_to_grf_mapping[&cs->name_single] = _cur_grffile->grfid;
01895 break;
01896
01897 case 0x0B:
01898
01899
01900 cs->units_volume = grf_load_word(&buf);
01901 _string_to_grf_mapping[&cs->units_volume] = _cur_grffile->grfid;
01902 break;
01903
01904 case 0x0C:
01905 cs->quantifier = grf_load_word(&buf);
01906 _string_to_grf_mapping[&cs->quantifier] = _cur_grffile->grfid;
01907 break;
01908
01909 case 0x0D:
01910 cs->abbrev = grf_load_word(&buf);
01911 _string_to_grf_mapping[&cs->abbrev] = _cur_grffile->grfid;
01912 break;
01913
01914 case 0x0E:
01915 cs->sprite = grf_load_word(&buf);
01916 break;
01917
01918 case 0x0F:
01919 cs->weight = grf_load_byte(&buf);
01920 break;
01921
01922 case 0x10:
01923 cs->transit_days[0] = grf_load_byte(&buf);
01924 break;
01925
01926 case 0x11:
01927 cs->transit_days[1] = grf_load_byte(&buf);
01928 break;
01929
01930 case 0x12:
01931 cs->initial_payment = grf_load_dword(&buf);
01932 break;
01933
01934 case 0x13:
01935 cs->rating_colour = MapDOSColour(grf_load_byte(&buf));
01936 break;
01937
01938 case 0x14:
01939 cs->legend_colour = MapDOSColour(grf_load_byte(&buf));
01940 break;
01941
01942 case 0x15:
01943 cs->is_freight = (grf_load_byte(&buf) != 0);
01944 break;
01945
01946 case 0x16:
01947 cs->classes = grf_load_word(&buf);
01948 break;
01949
01950 case 0x17:
01951 cs->label = grf_load_dword(&buf);
01952 cs->label = BSWAP32(cs->label);
01953 break;
01954
01955 case 0x18: {
01956 uint8 substitute_type = grf_load_byte(&buf);
01957
01958 switch (substitute_type) {
01959 case 0x00: cs->town_effect = TE_PASSENGERS; break;
01960 case 0x02: cs->town_effect = TE_MAIL; break;
01961 case 0x05: cs->town_effect = TE_GOODS; break;
01962 case 0x09: cs->town_effect = TE_WATER; break;
01963 case 0x0B: cs->town_effect = TE_FOOD; break;
01964 default:
01965 grfmsg(1, "CargoChangeInfo: Unknown town growth substitute value %d, setting to none.", substitute_type);
01966 case 0xFF: cs->town_effect = TE_NONE; break;
01967 }
01968 } break;
01969
01970 case 0x19:
01971 cs->multipliertowngrowth = grf_load_word(&buf);
01972 break;
01973
01974 case 0x1A:
01975 cs->callback_mask = grf_load_byte(&buf);
01976 break;
01977
01978 default:
01979 ret = CIR_UNKNOWN;
01980 break;
01981 }
01982 }
01983
01984 *bufp = buf;
01985 return ret;
01986 }
01987
01988
01989 static ChangeInfoResult SoundEffectChangeInfo(uint sid, int numinfo, int prop, byte **bufp, int len)
01990 {
01991 byte *buf = *bufp;
01992 ChangeInfoResult ret = CIR_SUCCESS;
01993
01994 if (_cur_grffile->sound_offset == 0) {
01995 grfmsg(1, "SoundEffectChangeInfo: No effects defined, skipping");
01996 return CIR_INVALID_ID;
01997 }
01998
01999 for (int i = 0; i < numinfo; i++) {
02000 uint sound = sid + i + _cur_grffile->sound_offset - GetNumOriginalSounds();
02001
02002 if (sound >= GetNumSounds()) {
02003 grfmsg(1, "SoundEffectChangeInfo: Sound %d not defined (max %d)", sound, GetNumSounds());
02004 return CIR_INVALID_ID;
02005 }
02006
02007 switch (prop) {
02008 case 0x08:
02009 GetSound(sound)->volume = grf_load_byte(&buf);
02010 break;
02011
02012 case 0x09:
02013 GetSound(sound)->priority = grf_load_byte(&buf);
02014 break;
02015
02016 case 0x0A: {
02017 uint orig_sound = grf_load_byte(&buf);
02018
02019 if (orig_sound >= GetNumSounds()) {
02020 grfmsg(1, "SoundEffectChangeInfo: Original sound %d not defined (max %d)", orig_sound, GetNumSounds());
02021 } else {
02022 FileEntry *newfe = GetSound(sound);
02023 FileEntry *oldfe = GetSound(orig_sound);
02024
02025
02026 *oldfe = *newfe;
02027 }
02028 } break;
02029
02030 default:
02031 ret = CIR_UNKNOWN;
02032 break;
02033 }
02034 }
02035
02036 *bufp = buf;
02037 return ret;
02038 }
02039
02040 static ChangeInfoResult IndustrytilesChangeInfo(uint indtid, int numinfo, int prop, byte **bufp, int len)
02041 {
02042 byte *buf = *bufp;
02043 ChangeInfoResult ret = CIR_SUCCESS;
02044
02045 if (indtid + numinfo > NUM_INDUSTRYTILES) {
02046 grfmsg(1, "IndustryTilesChangeInfo: Too many industry tiles loaded (%u), max (%u). Ignoring.", indtid + numinfo, NUM_INDUSTRYTILES);
02047 return CIR_INVALID_ID;
02048 }
02049
02050
02051 if (_cur_grffile->indtspec == NULL) {
02052 _cur_grffile->indtspec = CallocT<IndustryTileSpec*>(NUM_INDUSTRYTILES);
02053 }
02054
02055 for (int i = 0; i < numinfo; i++) {
02056 IndustryTileSpec *tsp = _cur_grffile->indtspec[indtid + i];
02057
02058 if (prop != 0x08 && tsp == NULL) {
02059 grfmsg(2, "IndustryTilesChangeInfo: Attempt to modify undefined industry tile %u. Ignoring.", indtid + i);
02060 return CIR_INVALID_ID;
02061 }
02062
02063 switch (prop) {
02064 case 0x08: {
02065 IndustryTileSpec **tilespec = &_cur_grffile->indtspec[indtid + i];
02066 byte subs_id = grf_load_byte(&buf);
02067
02068 if (subs_id >= NEW_INDUSTRYTILEOFFSET) {
02069
02070 grfmsg(2, "IndustryTilesChangeInfo: Attempt to use new industry tile %u as substitute industry tile for %u. Ignoring.", subs_id, indtid + i);
02071 continue;
02072 }
02073
02074
02075 if (*tilespec == NULL) {
02076 int tempid;
02077 *tilespec = CallocT<IndustryTileSpec>(1);
02078 tsp = *tilespec;
02079
02080 memcpy(tsp, &_industry_tile_specs[subs_id], sizeof(_industry_tile_specs[subs_id]));
02081 tsp->enabled = true;
02082
02083
02084
02085
02086 tsp->anim_production = INDUSTRYTILE_NOANIM;
02087 tsp->anim_next = INDUSTRYTILE_NOANIM;
02088
02089 tsp->grf_prop.local_id = indtid + i;
02090 tsp->grf_prop.subst_id = subs_id;
02091 tsp->grf_prop.grffile = _cur_grffile;
02092 tempid = _industile_mngr.AddEntityID(indtid + i, _cur_grffile->grfid, subs_id);
02093 }
02094 } break;
02095
02096 case 0x09: {
02097 byte ovrid = grf_load_byte(&buf);
02098
02099
02100 if (ovrid >= NEW_INDUSTRYTILEOFFSET) {
02101 grfmsg(2, "IndustryTilesChangeInfo: Attempt to override new industry tile %u with industry tile id %u. Ignoring.", ovrid, indtid + i);
02102 continue;
02103 }
02104
02105 _industile_mngr.Add(indtid + i, _cur_grffile->grfid, ovrid);
02106 } break;
02107
02108 case 0x0A:
02109 case 0x0B:
02110 case 0x0C: {
02111 uint16 acctp = grf_load_word(&buf);
02112 tsp->accepts_cargo[prop - 0x0A] = GetCargoTranslation(GB(acctp, 0, 8), _cur_grffile);
02113 tsp->acceptance[prop - 0x0A] = GB(acctp, 8, 8);
02114 } break;
02115
02116 case 0x0D:
02117 tsp->slopes_refused = (Slope)grf_load_byte(&buf);
02118 break;
02119
02120 case 0x0E:
02121 tsp->callback_flags = grf_load_byte(&buf);
02122 break;
02123
02124 case 0x0F:
02125 tsp->animation_info = grf_load_word(&buf);
02126 break;
02127
02128 case 0x10:
02129 tsp->animation_speed = grf_load_byte(&buf);
02130 break;
02131
02132 case 0x11:
02133 tsp->animation_triggers = grf_load_byte(&buf);
02134 break;
02135
02136 case 0x12:
02137 tsp->animation_special_flags = grf_load_byte(&buf);
02138 break;
02139
02140 default:
02141 ret = CIR_UNKNOWN;
02142 break;
02143 }
02144 }
02145
02146 *bufp = buf;
02147 return ret;
02148 }
02149
02150 static ChangeInfoResult IndustriesChangeInfo(uint indid, int numinfo, int prop, byte **bufp, int len)
02151 {
02152 byte *buf = *bufp;
02153 ChangeInfoResult ret = CIR_SUCCESS;
02154
02155 if (indid + numinfo > NUM_INDUSTRYTYPES) {
02156 grfmsg(1, "IndustriesChangeInfo: Too many industries loaded (%u), max (%u). Ignoring.", indid + numinfo, NUM_INDUSTRYTYPES);
02157 return CIR_INVALID_ID;
02158 }
02159
02160 grfmsg(1, "IndustriesChangeInfo: newid %u", indid);
02161
02162
02163 if (_cur_grffile->industryspec == NULL) {
02164 _cur_grffile->industryspec = CallocT<IndustrySpec*>(NUM_INDUSTRYTYPES);
02165 }
02166
02167 for (int i = 0; i < numinfo; i++) {
02168 IndustrySpec *indsp = _cur_grffile->industryspec[indid + i];
02169
02170 if (prop != 0x08 && indsp == NULL) {
02171 grfmsg(2, "IndustriesChangeInfo: Attempt to modify undefined industry %u. Ignoring.", indid + i);
02172 return CIR_INVALID_ID;
02173 }
02174
02175 switch (prop) {
02176 case 0x08: {
02177 IndustrySpec **indspec = &_cur_grffile->industryspec[indid + i];
02178 byte subs_id = grf_load_byte(&buf);
02179
02180 if (subs_id == 0xFF) {
02181
02182
02183 _industry_specs[indid + i].enabled = false;
02184 continue;
02185 } else if (subs_id >= NEW_INDUSTRYOFFSET) {
02186
02187 grfmsg(2, "_industry_specs: Attempt to use new industry %u as substitute industry for %u. Ignoring.", subs_id, indid + i);
02188 continue;
02189 }
02190
02191
02192
02193
02194 if (*indspec == NULL) {
02195 *indspec = CallocT<IndustrySpec>(1);
02196 indsp = *indspec;
02197
02198 memcpy(indsp, &_origin_industry_specs[subs_id], sizeof(_industry_specs[subs_id]));
02199 indsp->enabled = true;
02200 indsp->grf_prop.local_id = indid + i;
02201 indsp->grf_prop.subst_id = subs_id;
02202 indsp->grf_prop.grffile = _cur_grffile;
02203
02204
02205 indsp->check_proc = CHECK_NOTHING;
02206 }
02207 } break;
02208
02209 case 0x09: {
02210 byte ovrid = grf_load_byte(&buf);
02211
02212
02213 if (ovrid >= NEW_INDUSTRYOFFSET) {
02214 grfmsg(2, "IndustriesChangeInfo: Attempt to override new industry %u with industry id %u. Ignoring.", ovrid, indid + i);
02215 continue;
02216 }
02217 indsp->grf_prop.override = ovrid;
02218 _industry_mngr.Add(indid + i, _cur_grffile->grfid, ovrid);
02219 } break;
02220
02221 case 0x0A: {
02222 indsp->num_table = grf_load_byte(&buf);
02223 uint32 defsize = grf_load_dword(&buf);
02224 IndustryTileTable **tile_table = CallocT<IndustryTileTable*>(indsp->num_table);
02225 IndustryTileTable *itt = CallocT<IndustryTileTable>(defsize);
02226 int size;
02227 IndustryTileTable *copy_from;
02228
02229 for (byte j = 0; j < indsp->num_table; j++) {
02230 for (int k = 0;; k++) {
02231 itt[k].ti.x = grf_load_byte(&buf);
02232
02233 if (itt[k].ti.x == 0xFE && k == 0) {
02234
02235 IndustryType type = grf_load_byte(&buf);
02236 byte laynbr = grf_load_byte(&buf);
02237
02238 copy_from = (IndustryTileTable*)_origin_industry_specs[type].table[laynbr];
02239 for (size = 1;; size++) {
02240 if (copy_from[size - 1].ti.x == -0x80 && copy_from[size - 1].ti.y == 0) break;
02241 }
02242 break;
02243 }
02244
02245 itt[k].ti.y = grf_load_byte(&buf);
02246
02247 if (itt[k].ti.x == 0 && itt[k].ti.y == 0x80) {
02248
02249
02250 itt[k].ti.x = -0x80;
02251 itt[k].ti.y = 0;
02252 itt[k].gfx = 0;
02253
02254 size = k + 1;
02255 copy_from = itt;
02256 break;
02257 }
02258
02259 itt[k].gfx = grf_load_byte(&buf);
02260
02261 if (itt[k].gfx == 0xFE) {
02262
02263 int local_tile_id = grf_load_word(&buf);
02264
02265
02266 int tempid = _industile_mngr.GetID(local_tile_id, _cur_grffile->grfid);
02267
02268 if (tempid == INVALID_INDUSTRYTILE) {
02269 grfmsg(2, "IndustriesChangeInfo: Attempt to use industry tile %u with industry id %u, not yet defined. Ignoring.", local_tile_id, indid);
02270 } else {
02271
02272 itt[k].gfx = tempid;
02273 size = k + 1;
02274 copy_from = itt;
02275 }
02276 } else if (itt[k].gfx == 0xFF) {
02277 itt[k].ti.x = (int8)GB(itt[k].ti.x, 0, 8);
02278 itt[k].ti.y = (int8)GB(itt[k].ti.y, 0, 8);
02279 }
02280 }
02281 tile_table[j] = CallocT<IndustryTileTable>(size);
02282 memcpy(tile_table[j], copy_from, sizeof(*copy_from) * size);
02283 }
02284
02285 indsp->table = tile_table;
02286 SetBit(indsp->cleanup_flag, 1);
02287 free(itt);
02288 } break;
02289
02290 case 0x0B:
02291 indsp->life_type = (IndustryLifeType)grf_load_byte(&buf);
02292 break;
02293
02294 case 0x0C:
02295 indsp->closure_text = grf_load_word(&buf);
02296 _string_to_grf_mapping[&indsp->closure_text] = _cur_grffile->grfid;
02297 break;
02298
02299 case 0x0D:
02300 indsp->production_up_text = grf_load_word(&buf);
02301 _string_to_grf_mapping[&indsp->production_up_text] = _cur_grffile->grfid;
02302 break;
02303
02304 case 0x0E:
02305 indsp->production_down_text = grf_load_word(&buf);
02306 _string_to_grf_mapping[&indsp->production_down_text] = _cur_grffile->grfid;
02307 break;
02308
02309 case 0x0F:
02310 indsp->cost_multiplier = grf_load_byte(&buf);
02311 break;
02312
02313 case 0x10:
02314 for (byte j = 0; j < 2; j++) {
02315 indsp->produced_cargo[j] = GetCargoTranslation(grf_load_byte(&buf), _cur_grffile);
02316 }
02317 break;
02318
02319 case 0x11:
02320 for (byte j = 0; j < 3; j++) {
02321 indsp->accepts_cargo[j] = GetCargoTranslation(grf_load_byte(&buf), _cur_grffile);
02322 }
02323 grf_load_byte(&buf);
02324 break;
02325
02326 case 0x12:
02327 case 0x13:
02328 indsp->production_rate[prop - 0x12] = grf_load_byte(&buf);
02329 break;
02330
02331 case 0x14:
02332 indsp->minimal_cargo = grf_load_byte(&buf);
02333 break;
02334
02335 case 0x15: {
02336 indsp->number_of_sounds = grf_load_byte(&buf);
02337 uint8 *sounds = MallocT<uint8>(indsp->number_of_sounds);
02338
02339 for (uint8 j = 0; j < indsp->number_of_sounds; j++) sounds[j] = grf_load_byte(&buf);
02340 indsp->random_sounds = sounds;
02341 SetBit(indsp->cleanup_flag, 0);
02342 } break;
02343
02344 case 0x16:
02345 for (byte j = 0; j < 3; j++) indsp->conflicting[j] = grf_load_byte(&buf);
02346 break;
02347
02348 case 0x17:
02349 indsp->appear_creation[_settings_game.game_creation.landscape] = grf_load_byte(&buf);
02350 break;
02351
02352 case 0x18:
02353 indsp->appear_ingame[_settings_game.game_creation.landscape] = grf_load_byte(&buf);
02354 break;
02355
02356 case 0x19:
02357 indsp->map_colour = MapDOSColour(grf_load_byte(&buf));
02358 break;
02359
02360 case 0x1A:
02361 indsp->behaviour = (IndustryBehaviour)grf_load_dword(&buf);
02362 break;
02363
02364 case 0x1B:
02365 indsp->new_industry_text = grf_load_word(&buf);
02366 _string_to_grf_mapping[&indsp->new_industry_text] = _cur_grffile->grfid;
02367 break;
02368
02369 case 0x1C:
02370 case 0x1D:
02371 case 0x1E: {
02372 uint32 multiples = grf_load_dword(&buf);
02373 indsp->input_cargo_multiplier[prop - 0x1C][0] = GB(multiples, 0, 16);
02374 indsp->input_cargo_multiplier[prop - 0x1C][1] = GB(multiples, 16, 16);
02375 } break;
02376
02377 case 0x1F:
02378 indsp->name = grf_load_word(&buf);
02379 _string_to_grf_mapping[&indsp->name] = _cur_grffile->grfid;
02380 break;
02381
02382 case 0x20:
02383 indsp->prospecting_chance = grf_load_dword(&buf);
02384 break;
02385
02386 case 0x21:
02387 case 0x22: {
02388 byte aflag = grf_load_byte(&buf);
02389 SB(indsp->callback_flags, (prop - 0x21) * 8, 8, aflag);
02390 } break;
02391
02392 case 0x23:
02393 indsp->removal_cost_multiplier = grf_load_dword(&buf);
02394 break;
02395
02396 case 0x24:
02397 indsp->station_name = grf_load_word(&buf);
02398 _string_to_grf_mapping[&indsp->station_name] = _cur_grffile->grfid;
02399 break;
02400
02401 default:
02402 ret = CIR_UNKNOWN;
02403 break;
02404 }
02405 }
02406
02407 *bufp = buf;
02408 return ret;
02409 }
02410
02411 static bool HandleChangeInfoResult(const char *caller, ChangeInfoResult cir, uint8 feature, uint8 property)
02412 {
02413 switch (cir) {
02414 default: NOT_REACHED();
02415
02416 case CIR_SUCCESS:
02417 return false;
02418
02419 case CIR_UNHANDLED:
02420 grfmsg(1, "%s: Ignoring property 0x%02X of feature 0x%02X (not implemented)", caller, property, feature);
02421 return false;
02422
02423 case CIR_UNKNOWN:
02424 grfmsg(0, "%s: Unknown property 0x%02X of feature 0x%02X, disabling", caller, property, feature);
02425
02426
02427 case CIR_INVALID_ID:
02428
02429 _skip_sprites = -1;
02430 _cur_grfconfig->status = GCS_DISABLED;
02431 _cur_grfconfig->error = CallocT<GRFError>(1);
02432 _cur_grfconfig->error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
02433 _cur_grfconfig->error->message = (cir == CIR_INVALID_ID) ? STR_NEWGRF_ERROR_INVALID_ID : STR_NEWGRF_ERROR_UNKNOWN_PROPERTY;
02434 return true;
02435 }
02436 }
02437
02438
02439 static void FeatureChangeInfo(byte *buf, size_t len)
02440 {
02441 byte *bufend = buf + len;
02442
02443
02444
02445
02446
02447
02448
02449
02450
02451
02452
02453
02454
02455
02456 static const VCI_Handler handler[] = {
02457 RailVehicleChangeInfo,
02458 RoadVehicleChangeInfo,
02459 ShipVehicleChangeInfo,
02460 AircraftVehicleChangeInfo,
02461 StationChangeInfo,
02462 CanalChangeInfo,
02463 BridgeChangeInfo,
02464 TownHouseChangeInfo,
02465 GlobalVarChangeInfo,
02466 IndustrytilesChangeInfo,
02467 IndustriesChangeInfo,
02468 NULL,
02469 SoundEffectChangeInfo,
02470 };
02471
02472 if (!check_length(len, 6, "FeatureChangeInfo")) return;
02473 buf++;
02474 uint8 feature = grf_load_byte(&buf);
02475 uint8 numprops = grf_load_byte(&buf);
02476 uint numinfo = grf_load_byte(&buf);
02477 uint engine = grf_load_extended(&buf);
02478
02479 grfmsg(6, "FeatureChangeInfo: feature %d, %d properties, to apply to %d+%d",
02480 feature, numprops, engine, numinfo);
02481
02482 if (feature >= lengthof(handler) || handler[feature] == NULL) {
02483 grfmsg(1, "FeatureChangeInfo: Unsupported feature %d, skipping", feature);
02484 return;
02485 }
02486
02487 while (numprops-- && buf < bufend) {
02488 uint8 prop = grf_load_byte(&buf);
02489
02490 ChangeInfoResult cir = handler[feature](engine, numinfo, prop, &buf, bufend - buf);
02491 if (HandleChangeInfoResult("FeatureChangeInfo", cir, feature, prop)) return;
02492 }
02493 }
02494
02495
02496 static void SafeChangeInfo(byte *buf, size_t len)
02497 {
02498 if (!check_length(len, 6, "SafeChangeInfo")) return;
02499 buf++;
02500 uint8 feature = grf_load_byte(&buf);
02501 uint8 numprops = grf_load_byte(&buf);
02502 grf_load_byte(&buf);
02503 grf_load_extended(&buf);
02504
02505 if (feature == GSF_BRIDGE && numprops == 1) {
02506 uint8 prop = grf_load_byte(&buf);
02507
02508
02509 if (prop == 0x0D) return;
02510 }
02511
02512 SetBit(_cur_grfconfig->flags, GCF_UNSAFE);
02513
02514
02515 _skip_sprites = -1;
02516 }
02517
02518
02519 static void ReserveChangeInfo(byte *buf, size_t len)
02520 {
02521 byte *bufend = buf + len;
02522
02523 if (!check_length(len, 6, "ReserveChangeInfo")) return;
02524 buf++;
02525 uint8 feature = grf_load_byte(&buf);
02526
02527 if (feature != GSF_CARGOS && feature != GSF_GLOBALVAR) return;
02528
02529 uint8 numprops = grf_load_byte(&buf);
02530 uint8 numinfo = grf_load_byte(&buf);
02531 uint8 index = grf_load_extended(&buf);
02532
02533 while (numprops-- && buf < bufend) {
02534 uint8 prop = grf_load_byte(&buf);
02535 ChangeInfoResult cir = CIR_SUCCESS;
02536
02537 switch (feature) {
02538 default: NOT_REACHED();
02539 case GSF_CARGOS:
02540 cir = CargoChangeInfo(index, numinfo, prop, &buf, bufend - buf);
02541 break;
02542
02543 case GSF_GLOBALVAR:
02544 cir = GlobalVarReserveInfo(index, numinfo, prop, &buf, bufend - buf);
02545 break;
02546 }
02547
02548 if (HandleChangeInfoResult("ReserveChangeInfo", cir, feature, prop)) return;
02549 }
02550 }
02551
02557 static const SpriteGroup *NewCallBackResultSpriteGroup(uint16 value)
02558 {
02559 SpriteGroup *group = AllocateSpriteGroup();
02560
02561 group->type = SGT_CALLBACK;
02562
02563
02564
02565 if ((value >> 8) == 0xFF) {
02566 value &= ~0xFF00;
02567 } else {
02568 value &= ~0x8000;
02569 }
02570
02571 group->g.callback.result = value;
02572
02573 return group;
02574 }
02575
02582 static const SpriteGroup *NewResultSpriteGroup(SpriteID sprite, byte num_sprites)
02583 {
02584 SpriteGroup *group = AllocateSpriteGroup();
02585 group->type = SGT_RESULT;
02586 group->g.result.sprite = sprite;
02587 group->g.result.num_sprites = num_sprites;
02588 return group;
02589 }
02590
02591
02592 static void NewSpriteSet(byte *buf, size_t len)
02593 {
02594
02595
02596
02597
02598
02599
02600
02601
02602
02603
02604
02605
02606 if (!check_length(len, 4, "NewSpriteSet")) return;
02607 buf++;
02608 uint8 feature = grf_load_byte(&buf);
02609 uint8 num_sets = grf_load_byte(&buf);
02610 uint16 num_ents = grf_load_extended(&buf);
02611
02612 _cur_grffile->spriteset_start = _cur_spriteid;
02613 _cur_grffile->spriteset_feature = feature;
02614 _cur_grffile->spriteset_numsets = num_sets;
02615 _cur_grffile->spriteset_numents = num_ents;
02616
02617 grfmsg(7, "New sprite set at %d of type %d, consisting of %d sets with %d views each (total %d)",
02618 _cur_spriteid, feature, num_sets, num_ents, num_sets * num_ents
02619 );
02620
02621 for (int i = 0; i < num_sets * num_ents; i++) {
02622 _nfo_line++;
02623 LoadNextSprite(_cur_spriteid++, _file_index, _nfo_line);
02624 }
02625 }
02626
02627
02628 static void SkipAct1(byte *buf, size_t len)
02629 {
02630 if (!check_length(len, 4, "SkipAct1")) return;
02631 buf++;
02632 grf_load_byte(&buf);
02633 uint8 num_sets = grf_load_byte(&buf);
02634 uint16 num_ents = grf_load_extended(&buf);
02635
02636 _skip_sprites = num_sets * num_ents;
02637
02638 grfmsg(3, "SkipAct1: Skipping %d sprites", _skip_sprites);
02639 }
02640
02641
02642
02643 static const SpriteGroup *GetGroupFromGroupID(byte setid, byte type, uint16 groupid)
02644 {
02645 if (HasBit(groupid, 15)) return NewCallBackResultSpriteGroup(groupid);
02646
02647 if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
02648 grfmsg(1, "GetGroupFromGroupID(0x%02X:0x%02X): Groupid 0x%04X does not exist, leaving empty", setid, type, groupid);
02649 return NULL;
02650 }
02651
02652 return _cur_grffile->spritegroups[groupid];
02653 }
02654
02655
02656 static const SpriteGroup *CreateGroupFromGroupID(byte feature, byte setid, byte type, uint16 spriteid, uint16 num_sprites)
02657 {
02658 if (HasBit(spriteid, 15)) return NewCallBackResultSpriteGroup(spriteid);
02659
02660 if (spriteid >= _cur_grffile->spriteset_numsets) {
02661 grfmsg(1, "CreateGroupFromGroupID(0x%02X:0x%02X): Sprite set %u invalid, max %u", setid, type, spriteid, _cur_grffile->spriteset_numsets);
02662 return NULL;
02663 }
02664
02665
02666
02667
02668 if (_cur_grffile->spriteset_start + spriteid * num_sprites + num_sprites > _cur_spriteid) {
02669 grfmsg(1, "CreateGroupFromGroupID(0x%02X:0x%02X): Real Sprite IDs 0x%04X - 0x%04X do not (all) exist (max 0x%04X), leaving empty",
02670 setid, type,
02671 _cur_grffile->spriteset_start + spriteid * num_sprites,
02672 _cur_grffile->spriteset_start + spriteid * num_sprites + num_sprites - 1, _cur_spriteid - 1);
02673 return NULL;
02674 }
02675
02676 if (feature != _cur_grffile->spriteset_feature) {
02677 grfmsg(1, "CreateGroupFromGroupID(0x%02X:0x%02X): Sprite set feature 0x%02X does not match action feature 0x%02X, skipping",
02678 setid, type,
02679 _cur_grffile->spriteset_feature, feature);
02680 return NULL;
02681 }
02682
02683 return NewResultSpriteGroup(_cur_grffile->spriteset_start + spriteid * num_sprites, num_sprites);
02684 }
02685
02686
02687 static void NewSpriteGroup(byte *buf, size_t len)
02688 {
02689
02690
02691
02692
02693
02694
02695
02696
02697
02698
02699 SpriteGroup *group = NULL;
02700 byte *bufend = buf + len;
02701
02702 if (!check_length(len, 5, "NewSpriteGroup")) return;
02703 buf++;
02704
02705 uint8 feature = grf_load_byte(&buf);
02706 uint8 setid = grf_load_byte(&buf);
02707 uint8 type = grf_load_byte(&buf);
02708
02709 if (setid >= _cur_grffile->spritegroups_count) {
02710
02711 _cur_grffile->spritegroups = ReallocT(_cur_grffile->spritegroups, setid + 1);
02712
02713 for (; _cur_grffile->spritegroups_count < (setid + 1); _cur_grffile->spritegroups_count++)
02714 _cur_grffile->spritegroups[_cur_grffile->spritegroups_count] = NULL;
02715 }
02716
02717 switch (type) {
02718
02719 case 0x81:
02720 case 0x82:
02721 case 0x85:
02722 case 0x86:
02723 case 0x89:
02724 case 0x8A:
02725 {
02726 byte varadjust;
02727 byte varsize;
02728
02729
02730 if (!check_length(bufend - buf, 1, "NewSpriteGroup (Deterministic) (1)")) return;
02731
02732 group = AllocateSpriteGroup();
02733 group->type = SGT_DETERMINISTIC;
02734 group->g.determ.var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
02735
02736 switch (GB(type, 2, 2)) {
02737 default: NOT_REACHED();
02738 case 0: group->g.determ.size = DSG_SIZE_BYTE; varsize = 1; break;
02739 case 1: group->g.determ.size = DSG_SIZE_WORD; varsize = 2; break;
02740 case 2: group->g.determ.size = DSG_SIZE_DWORD; varsize = 4; break;
02741 }
02742
02743 if (!check_length(bufend - buf, 5 + varsize, "NewSpriteGroup (Deterministic) (2)")) return;
02744
02745
02746
02747 do {
02748 DeterministicSpriteGroupAdjust *adjust;
02749
02750 if (group->g.determ.num_adjusts > 0) {
02751 if (!check_length(bufend - buf, 2 + varsize + 3, "NewSpriteGroup (Deterministic) (3)")) return;
02752 }
02753
02754 group->g.determ.num_adjusts++;
02755 group->g.determ.adjusts = ReallocT(group->g.determ.adjusts, group->g.determ.num_adjusts);
02756
02757 adjust = &group->g.determ.adjusts[group->g.determ.num_adjusts - 1];
02758
02759
02760 adjust->operation = group->g.determ.num_adjusts == 1 ? DSGA_OP_ADD : (DeterministicSpriteGroupAdjustOperation)grf_load_byte(&buf);
02761 adjust->variable = grf_load_byte(&buf);
02762 if (adjust->variable == 0x7E) {
02763
02764 adjust->subroutine = GetGroupFromGroupID(setid, type, grf_load_byte(&buf));
02765 } else {
02766 adjust->parameter = IsInsideMM(adjust->variable, 0x60, 0x80) ? grf_load_byte(&buf) : 0;
02767 }
02768
02769 varadjust = grf_load_byte(&buf);
02770 adjust->shift_num = GB(varadjust, 0, 5);
02771 adjust->type = (DeterministicSpriteGroupAdjustType)GB(varadjust, 6, 2);
02772 adjust->and_mask = grf_load_var(varsize, &buf);
02773
02774 if (adjust->type != DSGA_TYPE_NONE) {
02775 adjust->add_val = grf_load_var(varsize, &buf);
02776 adjust->divmod_val = grf_load_var(varsize, &buf);
02777 } else {
02778 adjust->add_val = 0;
02779 adjust->divmod_val = 0;
02780 }
02781
02782
02783 } while (HasBit(varadjust, 5));
02784
02785 group->g.determ.num_ranges = grf_load_byte(&buf);
02786 if (group->g.determ.num_ranges > 0) group->g.determ.ranges = CallocT<DeterministicSpriteGroupRange>(group->g.determ.num_ranges);
02787
02788 if (!check_length(bufend - buf, 2 + (2 + 2 * varsize) * group->g.determ.num_ranges, "NewSpriteGroup (Deterministic)")) return;
02789
02790 for (uint i = 0; i < group->g.determ.num_ranges; i++) {
02791 group->g.determ.ranges[i].group = GetGroupFromGroupID(setid, type, grf_load_word(&buf));
02792 group->g.determ.ranges[i].low = grf_load_var(varsize, &buf);
02793 group->g.determ.ranges[i].high = grf_load_var(varsize, &buf);
02794 }
02795
02796 group->g.determ.default_group = GetGroupFromGroupID(setid, type, grf_load_word(&buf));
02797 break;
02798 }
02799
02800
02801 case 0x80:
02802 case 0x83:
02803 case 0x84:
02804 {
02805 if (!check_length(bufend - buf, HasBit(type, 2) ? 8 : 7, "NewSpriteGroup (Randomized) (1)")) return;
02806
02807 group = AllocateSpriteGroup();
02808 group->type = SGT_RANDOMIZED;
02809 group->g.random.var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
02810
02811 if (HasBit(type, 2)) {
02812 if (feature <= GSF_AIRCRAFT) group->g.random.var_scope = VSG_SCOPE_RELATIVE;
02813 group->g.random.count = grf_load_byte(&buf);
02814 }
02815
02816 uint8 triggers = grf_load_byte(&buf);
02817 group->g.random.triggers = GB(triggers, 0, 7);
02818 group->g.random.cmp_mode = HasBit(triggers, 7) ? RSG_CMP_ALL : RSG_CMP_ANY;
02819 group->g.random.lowest_randbit = grf_load_byte(&buf);
02820 group->g.random.num_groups = grf_load_byte(&buf);
02821 group->g.random.groups = CallocT<const SpriteGroup*>(group->g.random.num_groups);
02822
02823 if (!check_length(bufend - buf, 2 * group->g.random.num_groups, "NewSpriteGroup (Randomized) (2)")) return;
02824
02825 for (uint i = 0; i < group->g.random.num_groups; i++) {
02826 group->g.random.groups[i] = GetGroupFromGroupID(setid, type, grf_load_word(&buf));
02827 }
02828
02829 break;
02830 }
02831
02832
02833 default:
02834 {
02835
02836
02837 switch (feature) {
02838 case GSF_TRAIN:
02839 case GSF_ROAD:
02840 case GSF_SHIP:
02841 case GSF_AIRCRAFT:
02842 case GSF_STATION:
02843 case GSF_CANAL:
02844 case GSF_CARGOS:
02845 {
02846 byte sprites = _cur_grffile->spriteset_numents;
02847 byte num_loaded = type;
02848 byte num_loading = grf_load_byte(&buf);
02849
02850 if (_cur_grffile->spriteset_start == 0) {
02851 grfmsg(0, "NewSpriteGroup: No sprite set to work on! Skipping");
02852 return;
02853 }
02854
02855 if (!check_length(bufend - buf, 2 * num_loaded + 2 * num_loading, "NewSpriteGroup (Real) (1)")) return;
02856
02857 group = AllocateSpriteGroup();
02858 group->type = SGT_REAL;
02859
02860 group->g.real.num_loaded = num_loaded;
02861 group->g.real.num_loading = num_loading;
02862 if (num_loaded > 0) group->g.real.loaded = CallocT<const SpriteGroup*>(num_loaded);
02863 if (num_loading > 0) group->g.real.loading = CallocT<const SpriteGroup*>(num_loading);
02864
02865 grfmsg(6, "NewSpriteGroup: New SpriteGroup 0x%02X, %u views, %u loaded, %u loading",
02866 setid, sprites, num_loaded, num_loading);
02867
02868 for (uint i = 0; i < num_loaded; i++) {
02869 uint16 spriteid = grf_load_word(&buf);
02870 group->g.real.loaded[i] = CreateGroupFromGroupID(feature, setid, type, spriteid, sprites);
02871 grfmsg(8, "NewSpriteGroup: + rg->loaded[%i] = subset %u", i, spriteid);
02872 }
02873
02874 for (uint i = 0; i < num_loading; i++) {
02875 uint16 spriteid = grf_load_word(&buf);
02876 group->g.real.loading[i] = CreateGroupFromGroupID(feature, setid, type, spriteid, sprites);
02877 grfmsg(8, "NewSpriteGroup: + rg->loading[%i] = subset %u", i, spriteid);
02878 }
02879
02880 break;
02881 }
02882
02883 case GSF_TOWNHOUSE:
02884 case GSF_INDUSTRYTILES: {
02885 byte sprites = _cur_grffile->spriteset_numents;
02886 byte num_sprites = max((uint8)1, type);
02887 uint i;
02888
02889 group = AllocateSpriteGroup();
02890 group->type = SGT_TILELAYOUT;
02891 group->g.layout.num_sprites = sprites;
02892 group->g.layout.dts = CallocT<DrawTileSprites>(1);
02893
02894
02895 group->g.layout.dts->ground.sprite = grf_load_word(&buf);
02896 group->g.layout.dts->ground.pal = grf_load_word(&buf);
02897
02898
02899 MapSpriteMappingRecolour(&group->g.layout.dts->ground);
02900
02901 if (HasBit(group->g.layout.dts->ground.pal, 15)) {
02902
02903
02904 SpriteID sprite = _cur_grffile->spriteset_start + GB(group->g.layout.dts->ground.sprite, 0, 14) * sprites;
02905 SB(group->g.layout.dts->ground.sprite, 0, SPRITE_WIDTH, sprite);
02906 ClrBit(group->g.layout.dts->ground.pal, 15);
02907 }
02908
02909 group->g.layout.dts->seq = CallocT<DrawTileSeqStruct>(num_sprites + 1);
02910
02911 for (i = 0; i < num_sprites; i++) {
02912 DrawTileSeqStruct *seq = (DrawTileSeqStruct*)&group->g.layout.dts->seq[i];
02913
02914 seq->image.sprite = grf_load_word(&buf);
02915 seq->image.pal = grf_load_word(&buf);
02916 seq->delta_x = grf_load_byte(&buf);
02917 seq->delta_y = grf_load_byte(&buf);
02918
02919 MapSpriteMappingRecolour(&seq->image);
02920
02921 if (HasBit(seq->image.pal, 15)) {
02922
02923
02924 SpriteID sprite = _cur_grffile->spriteset_start + GB(seq->image.sprite, 0, 14) * sprites;
02925 SB(seq->image.sprite, 0, SPRITE_WIDTH, sprite);
02926 ClrBit(seq->image.pal, 15);
02927 }
02928
02929 if (type > 0) {
02930 seq->delta_z = grf_load_byte(&buf);
02931 if ((byte)seq->delta_z == 0x80) continue;
02932 }
02933
02934 seq->size_x = grf_load_byte(&buf);
02935 seq->size_y = grf_load_byte(&buf);
02936 seq->size_z = grf_load_byte(&buf);
02937 }
02938
02939
02940 ((DrawTileSeqStruct*)group->g.layout.dts->seq)[i].delta_x = (byte)0x80;
02941
02942 break;
02943 }
02944
02945 case GSF_INDUSTRIES: {
02946 if (type > 1) {
02947 grfmsg(1, "NewSpriteGroup: Unsupported industry production version %d, skipping", type);
02948 break;
02949 }
02950
02951 group = AllocateSpriteGroup();
02952 group->type = SGT_INDUSTRY_PRODUCTION;
02953 group->g.indprod.version = type;
02954 if (type == 0) {
02955 for (uint i = 0; i < 3; i++) {
02956 group->g.indprod.substract_input[i] = grf_load_word(&buf);
02957 }
02958 for (uint i = 0; i < 2; i++) {
02959 group->g.indprod.add_output[i] = grf_load_word(&buf);
02960 }
02961 group->g.indprod.again = grf_load_byte(&buf);
02962 } else {
02963 for (uint i = 0; i < 3; i++) {
02964 group->g.indprod.substract_input[i] = grf_load_byte(&buf);
02965 }
02966 for (uint i = 0; i < 2; i++) {
02967 group->g.indprod.add_output[i] = grf_load_byte(&buf);
02968 }
02969 group->g.indprod.again = grf_load_byte(&buf);
02970 }
02971 break;
02972 }
02973
02974
02975 default: grfmsg(1, "NewSpriteGroup: Unsupported feature %d, skipping", feature);
02976 }
02977 }
02978 }
02979
02980 _cur_grffile->spritegroups[setid] = group;
02981 }
02982
02983 static CargoID TranslateCargo(uint8 feature, uint8 ctype)
02984 {
02985
02986 if (feature == GSF_STATION && ctype == 0xFE) return CT_DEFAULT_NA;
02987 if (ctype == 0xFF) return CT_PURCHASE;
02988
02989 if (_cur_grffile->cargo_max == 0) {
02990
02991 if (ctype >= 32) {
02992 grfmsg(1, "TranslateCargo: Cargo bitnum %d out of range (max 31), skipping.", ctype);
02993 return CT_INVALID;
02994 }
02995
02996 for (CargoID c = 0; c < NUM_CARGO; c++) {
02997 const CargoSpec *cs = GetCargo(c);
02998 if (!cs->IsValid()) continue;
02999
03000 if (cs->bitnum == ctype) {
03001 grfmsg(6, "TranslateCargo: Cargo bitnum %d mapped to cargo type %d.", ctype, c);
03002 return c;
03003 }
03004 }
03005
03006 grfmsg(5, "TranslateCargo: Cargo bitnum %d not available in this climate, skipping.", ctype);
03007 return CT_INVALID;
03008 }
03009
03010
03011 if (ctype >= _cur_grffile->cargo_max) {
03012 grfmsg(1, "TranslateCargo: Cargo type %d out of range (max %d), skipping.", ctype, _cur_grffile->cargo_max - 1);
03013 return CT_INVALID;
03014 }
03015
03016
03017 CargoLabel cl = _cur_grffile->cargo_list[ctype];
03018 if (cl == 0) {
03019 grfmsg(5, "TranslateCargo: Cargo type %d not available in this climate, skipping.", ctype);
03020 return CT_INVALID;
03021 }
03022
03023 ctype = GetCargoIDByLabel(cl);
03024 if (ctype == CT_INVALID) {
03025 grfmsg(5, "TranslateCargo: Cargo '%c%c%c%c' unsupported, skipping.", GB(cl, 24, 8), GB(cl, 16, 8), GB(cl, 8, 8), GB(cl, 0, 8));
03026 return CT_INVALID;
03027 }
03028
03029 grfmsg(6, "TranslateCargo: Cargo '%c%c%c%c' mapped to cargo type %d.", GB(cl, 24, 8), GB(cl, 16, 8), GB(cl, 8, 8), GB(cl, 0, 8), ctype);
03030 return ctype;
03031 }
03032
03033
03034 static bool IsValidGroupID(uint16 groupid, const char *function)
03035 {
03036 if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
03037 grfmsg(1, "%s: Spriteset 0x%04X out of range (maximum 0x%02X) or empty, skipping.", function, groupid, _cur_grffile->spritegroups_count - 1);
03038 return false;
03039 }
03040
03041 return true;
03042 }
03043
03044 static void VehicleMapSpriteGroup(byte *buf, byte feature, uint8 idcount)
03045 {
03046 static EngineID *last_engines;
03047 static uint last_engines_count;
03048 bool wagover = false;
03049
03050
03051 if (HasBit(idcount, 7)) {
03052 wagover = true;
03053
03054 idcount = GB(idcount, 0, 7);
03055
03056 if (last_engines_count == 0) {
03057 grfmsg(0, "VehicleMapSpriteGroup: WagonOverride: No engine to do override with");
03058 return;
03059 }
03060
03061 grfmsg(6, "VehicleMapSpriteGroup: WagonOverride: %u engines, %u wagons",
03062 last_engines_count, idcount);
03063 } else {
03064 if (last_engines_count != idcount) {
03065 last_engines = ReallocT(last_engines, idcount);
03066 last_engines_count = idcount;
03067 }
03068 }
03069
03070 EngineID *engines = AllocaM(EngineID, idcount);
03071 for (uint i = 0; i < idcount; i++) {
03072 engines[i] = GetNewEngine(_cur_grffile, (VehicleType)feature, grf_load_extended(&buf))->index;
03073 if (!wagover) last_engines[i] = engines[i];
03074 }
03075
03076 uint8 cidcount = grf_load_byte(&buf);
03077 for (uint c = 0; c < cidcount; c++) {
03078 uint8 ctype = grf_load_byte(&buf);
03079 uint16 groupid = grf_load_word(&buf);
03080 if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) continue;
03081
03082 grfmsg(8, "VehicleMapSpriteGroup: * [%d] Cargo type 0x%X, group id 0x%02X", c, ctype, groupid);
03083
03084 ctype = TranslateCargo(feature, ctype);
03085 if (ctype == CT_INVALID) continue;
03086
03087 for (uint i = 0; i < idcount; i++) {
03088 EngineID engine = engines[i];
03089
03090 grfmsg(7, "VehicleMapSpriteGroup: [%d] Engine %d...", i, engine);
03091
03092 if (wagover) {
03093 SetWagonOverrideSprites(engine, ctype, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
03094 } else {
03095 SetCustomEngineSprites(engine, ctype, _cur_grffile->spritegroups[groupid]);
03096 }
03097 }
03098 }
03099
03100 uint16 groupid = grf_load_word(&buf);
03101 if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) return;
03102
03103 grfmsg(8, "-- Default group id 0x%04X", groupid);
03104
03105 for (uint i = 0; i < idcount; i++) {
03106 EngineID engine = engines[i];
03107
03108 if (wagover) {
03109 SetWagonOverrideSprites(engine, CT_DEFAULT, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
03110 } else {
03111 SetCustomEngineSprites(engine, CT_DEFAULT, _cur_grffile->spritegroups[groupid]);
03112 SetEngineGRF(engine, _cur_grffile);
03113 }
03114 }
03115 }
03116
03117
03118 static void CanalMapSpriteGroup(byte *buf, uint8 idcount)
03119 {
03120 CanalFeature *cfs = AllocaM(CanalFeature, idcount);
03121 for (uint i = 0; i < idcount; i++) {
03122 cfs[i] = (CanalFeature)grf_load_byte(&buf);
03123 }
03124
03125 uint8 cidcount = grf_load_byte(&buf);
03126 buf += cidcount * 3;
03127
03128 uint16 groupid = grf_load_word(&buf);
03129 if (!IsValidGroupID(groupid, "CanalMapSpriteGroup")) return;
03130
03131 for (uint i = 0; i < idcount; i++) {
03132 CanalFeature cf = cfs[i];
03133
03134 if (cf >= CF_END) {
03135 grfmsg(1, "CanalMapSpriteGroup: Canal subset %d out of range, skipping", cf);
03136 continue;
03137 }
03138
03139 _water_feature[cf].grffile = _cur_grffile;
03140 _water_feature[cf].group = _cur_grffile->spritegroups[groupid];
03141 }
03142 }
03143
03144
03145 static void StationMapSpriteGroup(byte *buf, uint8 idcount)
03146 {
03147 uint8 *stations = AllocaM(uint8, idcount);
03148 for (uint i = 0; i < idcount; i++) {
03149 stations[i] = grf_load_byte(&buf);
03150 }
03151
03152 uint8 cidcount = grf_load_byte(&buf);
03153 for (uint c = 0; c < cidcount; c++) {
03154 uint8 ctype = grf_load_byte(&buf);
03155 uint16 groupid = grf_load_word(&buf);
03156 if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) continue;
03157
03158 ctype = TranslateCargo(GSF_STATION, ctype);
03159 if (ctype == CT_INVALID) continue;
03160
03161 for (uint i = 0; i < idcount; i++) {
03162 StationSpec *statspec = _cur_grffile->stations[stations[i]];
03163
03164 if (statspec == NULL) {
03165 grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X does not exist, skipping", stations[i]);
03166 continue;
03167 }
03168
03169 statspec->spritegroup[ctype] = _cur_grffile->spritegroups[groupid];
03170 }
03171 }
03172
03173 uint16 groupid = grf_load_word(&buf);
03174 if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) return;
03175
03176 for (uint i = 0; i < idcount; i++) {
03177 StationSpec *statspec = _cur_grffile->stations[stations[i]];
03178
03179 if (statspec == NULL) {
03180 grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X does not exist, skipping", stations[i]);
03181 continue;
03182 }
03183
03184 statspec->spritegroup[CT_DEFAULT] = _cur_grffile->spritegroups[groupid];
03185 statspec->grffile = _cur_grffile;
03186 statspec->localidx = stations[i];
03187 SetCustomStationSpec(statspec);
03188 }
03189 }
03190
03191
03192 static void TownHouseMapSpriteGroup(byte *buf, uint8 idcount)
03193 {
03194 uint8 *houses = AllocaM(uint8, idcount);
03195 for (uint i = 0; i < idcount; i++) {
03196 houses[i] = grf_load_byte(&buf);
03197 }
03198
03199
03200 uint8 cidcount = grf_load_byte(&buf);
03201 buf += cidcount * 3;
03202
03203 uint16 groupid = grf_load_word(&buf);
03204 if (!IsValidGroupID(groupid, "TownHouseMapSpriteGroup")) return;
03205
03206 for (uint i = 0; i < idcount; i++) {
03207 HouseSpec *hs = _cur_grffile->housespec[houses[i]];
03208
03209 if (hs == NULL) {
03210 grfmsg(1, "TownHouseMapSpriteGroup: House %d undefined, skipping.", houses[i]);
03211 continue;
03212 }
03213
03214 hs->spritegroup = _cur_grffile->spritegroups[groupid];
03215 }
03216 }
03217
03218 static void IndustryMapSpriteGroup(byte *buf, uint8 idcount)
03219 {
03220 uint8 *industries = AllocaM(uint8, idcount);
03221 for (uint i = 0; i < idcount; i++) {
03222 industries[i] = grf_load_byte(&buf);
03223 }
03224
03225
03226 uint8 cidcount = grf_load_byte(&buf);
03227 buf += cidcount * 3;
03228
03229 uint16 groupid = grf_load_word(&buf);
03230 if (!IsValidGroupID(groupid, "IndustryMapSpriteGroup")) return;
03231
03232 for (uint i = 0; i < idcount; i++) {
03233 IndustrySpec *indsp = _cur_grffile->industryspec[industries[i]];
03234
03235 if (indsp == NULL) {
03236 grfmsg(1, "IndustryMapSpriteGroup: Industry %d undefined, skipping", industries[i]);
03237 continue;
03238 }
03239
03240 indsp->grf_prop.spritegroup = _cur_grffile->spritegroups[groupid];
03241 }
03242 }
03243
03244 static void IndustrytileMapSpriteGroup(byte *buf, uint8 idcount)
03245 {
03246 uint8 *indtiles = AllocaM(uint8, idcount);
03247 for (uint i = 0; i < idcount; i++) {
03248 indtiles[i] = grf_load_byte(&buf);
03249 }
03250
03251
03252 uint8 cidcount = grf_load_byte(&buf);
03253 buf += cidcount * 3;
03254
03255 uint16 groupid = grf_load_word(&buf);
03256 if (!IsValidGroupID(groupid, "IndustrytileMapSpriteGroup")) return;
03257
03258 for (uint i = 0; i < idcount; i++) {
03259 IndustryTileSpec *indtsp = _cur_grffile->indtspec[indtiles[i]];
03260
03261 if (indtsp == NULL) {
03262 grfmsg(1, "IndustrytileMapSpriteGroup: Industry tile %d undefined, skipping", indtiles[i]);
03263 continue;
03264 }
03265
03266 indtsp->grf_prop.spritegroup = _cur_grffile->spritegroups[groupid];
03267 }
03268 }
03269
03270 static void CargoMapSpriteGroup(byte *buf, uint8 idcount)
03271 {
03272 CargoID *cargos = AllocaM(CargoID, idcount);
03273 for (uint i = 0; i < idcount; i++) {
03274 cargos[i] = grf_load_byte(&buf);
03275 }
03276
03277
03278 uint8 cidcount = grf_load_byte(&buf);
03279 buf += cidcount * 3;
03280
03281 uint16 groupid = grf_load_word(&buf);
03282 if (!IsValidGroupID(groupid, "CargoMapSpriteGroup")) return;
03283
03284 for (uint i = 0; i < idcount; i++) {
03285 CargoID cid = cargos[i];
03286
03287 if (cid >= NUM_CARGO) {
03288 grfmsg(1, "CargoMapSpriteGroup: Cargo ID %d out of range, skipping", cid);
03289 continue;
03290 }
03291
03292 CargoSpec *cs = &_cargo[cid];
03293 cs->grffile = _cur_grffile;
03294 cs->group = _cur_grffile->spritegroups[groupid];
03295 }
03296 }
03297
03298
03299
03300 static void FeatureMapSpriteGroup(byte *buf, size_t len)
03301 {
03302
03303
03304
03305
03306
03307
03308
03309
03310
03311
03312
03313
03314
03315
03316 if (_cur_grffile->spritegroups == 0) {
03317 grfmsg(1, "FeatureMapSpriteGroup: No sprite groups to work on! Skipping");
03318 return;
03319 }
03320
03321 if (!check_length(len, 6, "FeatureMapSpriteGroup")) return;
03322
03323 buf++;
03324 uint8 feature = grf_load_byte(&buf);
03325 uint8 idcount = grf_load_byte(&buf);
03326
03327
03328 if (idcount == 0) {
03329
03330 grf_load_byte(&buf);
03331 uint16 groupid = grf_load_word(&buf);
03332
03333 grfmsg(6, "FeatureMapSpriteGroup: Adding generic feature callback for feature %d", feature);
03334
03335 AddGenericCallback(feature, _cur_grffile, _cur_grffile->spritegroups[groupid]);
03336 return;
03337 }
03338
03339 grfmsg(6, "FeatureMapSpriteGroup: Feature %d, %d ids", feature, idcount);
03340
03341 switch (feature) {
03342 case GSF_TRAIN:
03343 case GSF_ROAD:
03344 case GSF_SHIP:
03345 case GSF_AIRCRAFT:
03346 VehicleMapSpriteGroup(buf, feature, idcount);
03347 return;
03348
03349 case GSF_CANAL:
03350 CanalMapSpriteGroup(buf, idcount);
03351 return;
03352
03353 case GSF_STATION:
03354 StationMapSpriteGroup(buf, idcount);
03355 return;
03356
03357 case GSF_TOWNHOUSE:
03358 TownHouseMapSpriteGroup(buf, idcount);
03359 return;
03360
03361 case GSF_INDUSTRIES:
03362 IndustryMapSpriteGroup(buf, idcount);
03363 return;
03364
03365 case GSF_INDUSTRYTILES:
03366 IndustrytileMapSpriteGroup(buf, idcount);
03367 return;
03368
03369 case GSF_CARGOS:
03370 CargoMapSpriteGroup(buf, idcount);
03371 return;
03372
03373 default:
03374 grfmsg(1, "FeatureMapSpriteGroup: Unsupported feature %d, skipping", feature);
03375 return;
03376 }
03377 }
03378
03379
03380 static void FeatureNewName(byte *buf, size_t len)
03381 {
03382
03383
03384
03385
03386
03387
03388
03389
03390
03391
03392
03393
03394
03395
03396
03397
03398 bool new_scheme = _cur_grffile->grf_version >= 7;
03399
03400 if (!check_length(len, 6, "FeatureNewName")) return;
03401 buf++;
03402 uint8 feature = grf_load_byte(&buf);
03403 uint8 lang = grf_load_byte(&buf);
03404 uint8 num = grf_load_byte(&buf);
03405 bool generic = HasBit(lang, 7);
03406 uint16 id;
03407 if (generic) {
03408 id = grf_load_word(&buf);
03409 } else if (feature <= GSF_AIRCRAFT) {
03410 id = grf_load_extended(&buf);
03411 } else {
03412 id = grf_load_byte(&buf);
03413 }
03414
03415 ClrBit(lang, 7);
03416
03417 uint16 endid = id + num;
03418
03419 grfmsg(6, "FeatureNewName: About to rename engines %d..%d (feature %d) in language 0x%02X",
03420 id, endid, feature, lang);
03421
03422 len -= generic ? 6 : 5;
03423
03424 for (; id < endid && len > 0; id++) {
03425 const char *name = grf_load_string(&buf, len);
03426 size_t name_length = strlen(name) + 1;
03427
03428 len -= (int)name_length;
03429
03430 grfmsg(8, "FeatureNewName: 0x%04X <- %s", id, name);
03431
03432 switch (feature) {
03433 case GSF_TRAIN:
03434 case GSF_ROAD:
03435 case GSF_SHIP:
03436 case GSF_AIRCRAFT:
03437 if (!generic) {
03438 Engine *e = GetNewEngine(_cur_grffile, (VehicleType)feature, id);
03439 StringID string = AddGRFString(_cur_grffile->grfid, e->index, lang, new_scheme, name, e->info.string_id);
03440 e->info.string_id = string;
03441 } else {
03442 AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, id);
03443 }
03444 break;
03445
03446 case GSF_INDUSTRIES: {
03447 AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
03448 break;
03449 }
03450
03451 case GSF_TOWNHOUSE:
03452 default:
03453 switch (GB(id, 8, 8)) {
03454 case 0xC4:
03455 if (_cur_grffile->stations == NULL || _cur_grffile->stations[GB(id, 0, 8)] == NULL) {
03456 grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
03457 } else {
03458 StationClassID sclass = _cur_grffile->stations[GB(id, 0, 8)]->sclass;
03459 SetStationClassName(sclass, AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED));
03460 }
03461 break;
03462
03463 case 0xC5:
03464 if (_cur_grffile->stations == NULL || _cur_grffile->stations[GB(id, 0, 8)] == NULL) {
03465 grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
03466 } else {
03467 _cur_grffile->stations[GB(id, 0, 8)]->name = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
03468 }
03469 break;
03470
03471 case 0xC9:
03472 if (_cur_grffile->housespec == NULL || _cur_grffile->housespec[GB(id, 0, 8)] == NULL) {
03473 grfmsg(1, "FeatureNewName: Attempt to name undefined house 0x%X, ignoring.", GB(id, 0, 8));
03474 } else {
03475 _cur_grffile->housespec[GB(id, 0, 8)]->building_name = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
03476 }
03477 break;
03478
03479 case 0xD0:
03480 case 0xD1:
03481 case 0xD2:
03482 case 0xD3:
03483 case 0xDC:
03484 AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
03485 break;
03486
03487 default:
03488 grfmsg(7, "FeatureNewName: Unsupported ID (0x%04X)", id);
03489 break;
03490 }
03491 break;
03492
03493 #if 0
03494 case GSF_CANAL :
03495 case GSF_BRIDGE :
03496 AddGRFString(_cur_spriteid, id, lang, name);
03497 switch (GB(id, 8, 8)) {
03498 case 0xC9:
03499 default:
03500 grfmsg(7, "FeatureNewName: Unsupported ID (0x%04X)", id);
03501 }
03502 break;
03503
03504 default :
03505 grfmsg(7, "FeatureNewName: Unsupported feature (0x%02X)", feature);
03506 break;
03507 #endif
03508 }
03509 }
03510 }
03511
03520 static uint16 SanitizeSpriteOffset(uint16& num, uint16 offset, int max_sprites, const char *name)
03521 {
03522
03523 if (offset >= max_sprites) {
03524 grfmsg(1, "GraphicsNew: %s sprite offset must be less than %i, skipping", name, max_sprites);
03525 uint orig_num = num;
03526 num = 0;
03527 return orig_num;
03528 }
03529
03530 if (offset + num > max_sprites) {
03531 grfmsg(4, "GraphicsNew: %s sprite overflow, truncating...", name);
03532 uint orig_num = num;
03533 num = max(max_sprites - offset, 0);
03534 return orig_num - num;
03535 }
03536
03537 return 0;
03538 }
03539
03540
03541 static void GraphicsNew(byte *buf, size_t len)
03542 {
03543
03544
03545
03546
03547
03548
03549
03550 enum Action5BlockType {
03551 A5BLOCK_FIXED,
03552 A5BLOCK_ALLOW_OFFSET,
03553 A5BLOCK_INVALID,
03554 };
03555 struct Action5Type {
03556 Action5BlockType block_type;
03557 SpriteID sprite_base;
03558 uint16 min_sprites;
03559 uint16 max_sprites;
03560 const char *name;
03561 };
03562
03563 static const Action5Type action5_types[] = {
03564
03565 { A5BLOCK_INVALID, 0, 0, 0, "Type 0x00" },
03566 { A5BLOCK_INVALID, 0, 0, 0, "Type 0x01" },
03567 { A5BLOCK_INVALID, 0, 0, 0, "Type 0x02" },
03568 { A5BLOCK_INVALID, 0, 0, 0, "Type 0x03" },
03569 { A5BLOCK_FIXED, SPR_SIGNALS_BASE, 48, PRESIGNAL_SEMAPHORE_AND_PBS_SPRITE_COUNT, "Signal graphics" },
03570 { A5BLOCK_FIXED, SPR_ELRAIL_BASE, 48, ELRAIL_SPRITE_COUNT, "Catenary graphics" },
03571 { A5BLOCK_FIXED, SPR_SLOPES_BASE, 74, NORMAL_AND_HALFTILE_FOUNDATION_SPRITE_COUNT, "Foundation graphics" },
03572 { A5BLOCK_INVALID, 0, 75, 0, "TTDP GUI graphics" },
03573 { A5BLOCK_FIXED, SPR_CANALS_BASE, 65, CANALS_SPRITE_COUNT, "Canal graphics" },
03574 { A5BLOCK_FIXED, SPR_ONEWAY_BASE, 6, ONEWAY_SPRITE_COUNT, "One way road graphics" },
03575 { A5BLOCK_FIXED, SPR_2CCMAP_BASE, 256, TWOCCMAP_SPRITE_COUNT, "2CC colour maps" },
03576 { A5BLOCK_FIXED, SPR_TRAMWAY_BASE, 113, TRAMWAY_SPRITE_COUNT, "Tramway graphics" },
03577 { A5BLOCK_INVALID, 0, 133, 0, "Snowy temperate tree" },
03578 { A5BLOCK_FIXED, SPR_SHORE_BASE, 16, SPR_SHORE_SPRITE_COUNT, "Shore graphics" },
03579 { A5BLOCK_INVALID, 0, 0, 0, "New Signals graphics" },
03580 { A5BLOCK_FIXED, SPR_TRACKS_FOR_SLOPES_BASE, 12, TRACKS_FOR_SLOPES_SPRITE_COUNT, "Sloped rail track" },
03581 { A5BLOCK_FIXED, SPR_AIRPORTX_BASE, 15, AIRPORTX_SPRITE_COUNT, "Airport graphics" },
03582 { A5BLOCK_FIXED, SPR_ROADSTOP_BASE, 8, ROADSTOP_SPRITE_COUNT, "Road stop graphics" },
03583 { A5BLOCK_FIXED, SPR_AQUEDUCT_BASE, 8, AQUEDUCT_SPRITE_COUNT, "Aqueduct graphics" },
03584 { A5BLOCK_FIXED, SPR_AUTORAIL_BASE, 55, AUTORAIL_SPRITE_COUNT, "Autorail graphics" },
03585 { A5BLOCK_ALLOW_OFFSET, SPR_FLAGS_BASE, 1, FLAGS_SPRITE_COUNT, "Flag graphics" },
03586 { A5BLOCK_ALLOW_OFFSET, SPR_OPENTTD_BASE, 1, OPENTTD_SPRITE_COUNT, "OpenTTD GUI graphics" },
03587 };
03588
03589 if (!check_length(len, 2, "GraphicsNew")) return;
03590 buf++;
03591 uint8 type = grf_load_byte(&buf);
03592 uint16 num = grf_load_extended(&buf);
03593 uint16 offset = HasBit(type, 7) ? grf_load_extended(&buf) : 0;
03594 ClrBit(type, 7);
03595
03596 if ((type == 0x0D) && (num == 10) && _cur_grffile->is_ottdfile) {
03597
03598
03599 grfmsg(2, "GraphicsNew: Loading 10 missing shore sprites from openttd(d/w).grf.");
03600 LoadNextSprite(SPR_SHORE_BASE + 0, _file_index, _nfo_line++);
03601 LoadNextSprite(SPR_SHORE_BASE + 5, _file_index, _nfo_line++);
03602 LoadNextSprite(SPR_SHORE_BASE + 7, _file_index, _nfo_line++);
03603 LoadNextSprite(SPR_SHORE_BASE + 10, _file_index, _nfo_line++);
03604 LoadNextSprite(SPR_SHORE_BASE + 11, _file_index, _nfo_line++);
03605 LoadNextSprite(SPR_SHORE_BASE + 13, _file_index, _nfo_line++);
03606 LoadNextSprite(SPR_SHORE_BASE + 14, _file_index, _nfo_line++);
03607 LoadNextSprite(SPR_SHORE_BASE + 15, _file_index, _nfo_line++);
03608 LoadNextSprite(SPR_SHORE_BASE + 16, _file_index, _nfo_line++);
03609 LoadNextSprite(SPR_SHORE_BASE + 17, _file_index, _nfo_line++);
03610 if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ONLY_NEW;
03611 return;
03612 }
03613
03614
03615 if ((type >= lengthof(action5_types)) || (action5_types[type].block_type == A5BLOCK_INVALID)) {
03616 grfmsg(2, "GraphicsNew: Custom graphics (type 0x%02X) sprite block of length %u (unimplemented, ignoring)", type, num);
03617 _skip_sprites = num;
03618 return;
03619 }
03620
03621 const Action5Type *action5_type = &action5_types[type];
03622
03623
03624 if ((action5_type->block_type != A5BLOCK_ALLOW_OFFSET) && (offset != 0)) {
03625 grfmsg(1, "GraphicsNew: %s (type 0x%02X) do not allow an <offset> field. Ignoring offset.", action5_type->name, type);
03626 offset = 0;
03627 }
03628
03629
03630
03631 if ((action5_type->block_type == A5BLOCK_FIXED) && (num < action5_type->min_sprites)) {
03632 grfmsg(1, "GraphicsNew: %s (type 0x%02X) count must be at least %d. Only %d were specified. Skipping.", action5_type->name, type, action5_type->min_sprites, num);
03633 _skip_sprites = num;
03634 return;
03635 }
03636
03637
03638 uint16 skip_num = SanitizeSpriteOffset(num, offset, action5_type->max_sprites, action5_type->name);
03639 SpriteID replace = action5_type->sprite_base + offset;
03640
03641
03642 grfmsg(2, "GraphicsNew: Replacing sprites %d to %d of %s (type 0x%02X) at SpriteID 0x%04X", offset, offset + num - 1, action5_type->name, type, replace);
03643
03644 for (; num > 0; num--) {
03645 _nfo_line++;
03646 LoadNextSprite(replace == 0 ? _cur_spriteid++ : replace++, _file_index, _nfo_line);
03647 }
03648
03649 if (type == 0x0D) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_5;
03650
03651 _skip_sprites = skip_num;
03652 }
03653
03654
03655 static void SkipAct5(byte *buf, size_t len)
03656 {
03657 if (!check_length(len, 2, "SkipAct5")) return;
03658 buf++;
03659
03660
03661 grf_load_byte(&buf);
03662
03663
03664 _skip_sprites = grf_load_extended(&buf);
03665
03666 grfmsg(3, "SkipAct5: Skipping %d sprites", _skip_sprites);
03667 }
03668
03679 bool GetGlobalVariable(byte param, uint32 *value)
03680 {
03681 switch (param) {
03682 case 0x00:
03683 *value = max(_date - DAYS_TILL_ORIGINAL_BASE_YEAR, 0);
03684 return true;
03685
03686 case 0x01:
03687 *value = Clamp(_cur_year, ORIGINAL_BASE_YEAR, ORIGINAL_MAX_YEAR) - ORIGINAL_BASE_YEAR;
03688 return true;
03689
03690 case 0x02: {
03691 YearMonthDay ymd;
03692 ConvertDateToYMD(_date, &ymd);
03693 Date start_of_year = ConvertYMDToDate(ymd.year, 0, 1);
03694 *value = ymd.month | (ymd.day - 1) << 8 | (IsLeapYear(ymd.year) ? 1 << 15 : 0) | (_date - start_of_year) << 16;
03695 return true;
03696 }
03697
03698 case 0x03:
03699 *value = _settings_game.game_creation.landscape;
03700 return true;
03701
03702 case 0x06:
03703 *value = _settings_game.vehicle.road_side << 4;
03704 return true;
03705
03706 case 0x09:
03707 *value = _date_fract;
03708 return true;
03709
03710 case 0x0A:
03711 *value = _tick_counter;
03712 return true;
03713
03714 case 0x0B: {
03715 uint major = 2;
03716 uint minor = 6;
03717 uint revision = 1;
03718 uint build = 1382;
03719 *value = (major << 24) | (minor << 20) | (revision << 16) | build;
03720 return true;
03721 }
03722
03723 case 0x0D:
03724 *value = _cur_grfconfig->windows_paletted;
03725 return true;
03726
03727 case 0x0E:
03728 *value = _traininfo_vehicle_pitch;
03729 return true;
03730
03731 case 0x0F:
03732 *value = 0;
03733 SB(*value, 0, 8, GetRailTypeInfo(RAILTYPE_RAIL)->cost_multiplier);
03734 if (_settings_game.vehicle.disable_elrails) {
03735
03736 SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_MONO)->cost_multiplier);
03737 } else {
03738 SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_ELECTRIC)->cost_multiplier);
03739
03740 }
03741 SB(*value, 16, 8, GetRailTypeInfo(RAILTYPE_MAGLEV)->cost_multiplier);
03742 return true;
03743
03744 case 0x11:
03745 *value = 0;
03746 return true;
03747
03748 case 0x12:
03749 *value = _game_mode;
03750 return true;
03751
03752
03753
03754
03755
03756
03757
03758 case 0x1A:
03759 *value = UINT_MAX;
03760 return true;
03761
03762 case 0x1B:
03763 *value = GB(_display_opt, 0, 6);
03764 return true;
03765
03766 case 0x1D:
03767 *value = 1;
03768 return true;
03769
03770 case 0x1E:
03771 *value = _misc_grf_features;
03772 return true;
03773
03774
03775
03776 case 0x20:
03777 *value = _settings_game.game_creation.landscape == LT_ARCTIC ? GetSnowLine() : 0xFF;
03778 return true;
03779
03780 case 0x21:
03781 *value = _openttd_newgrf_version;
03782 return true;
03783
03784 case 0x22:
03785 *value = _settings_game.difficulty.diff_level;
03786 return true;
03787
03788 case 0x23:
03789 *value = _date;
03790 return true;
03791
03792 case 0x24:
03793 *value = _cur_year;
03794 return true;
03795
03796 default: return false;
03797 }
03798 }
03799
03800 static uint32 GetParamVal(byte param, uint32 *cond_val)
03801 {
03802
03803 uint32 value;
03804 if (GetGlobalVariable(param - 0x80, &value)) return value;
03805
03806
03807 switch (param) {
03808 case 0x84: {
03809 uint32 res = 0;
03810
03811 if (_cur_stage > GLS_INIT) SetBit(res, 0);
03812 if (_cur_stage == GLS_RESERVE) SetBit(res, 8);
03813 if (_cur_stage == GLS_ACTIVATION) SetBit(res, 9);
03814 return res;
03815 }
03816
03817 case 0x85:
03818 if (cond_val == NULL) {
03819
03820 return 0;
03821 } else {
03822 uint32 param_val = _ttdpatch_flags[*cond_val / 0x20];
03823 *cond_val %= 0x20;
03824 return param_val;
03825 }
03826
03827 case 0x88:
03828 return 0;
03829
03830
03831
03832 default:
03833
03834 if (param < 0x80) return _cur_grffile->param[param];
03835
03836
03837 grfmsg(1, "Unsupported in-game variable 0x%02X", param);
03838 return UINT_MAX;
03839 }
03840 }
03841
03842
03843 static void CfgApply(byte *buf, size_t len)
03844 {
03845
03846
03847
03848
03849
03850
03851
03852
03853
03854
03855
03856
03857 size_t pos = FioGetPos();
03858 uint16 num = FioReadWord();
03859 uint8 type = FioReadByte();
03860 byte *preload_sprite = NULL;
03861
03862
03863 if (type == 0xFF) {
03864 preload_sprite = MallocT<byte>(num);
03865 FioReadBlock(preload_sprite, num);
03866 }
03867
03868
03869 FioSeekTo(pos, SEEK_SET);
03870
03871 if (type != 0xFF) {
03872 grfmsg(2, "CfgApply: Ignoring (next sprite is real, unsupported)");
03873 free(preload_sprite);
03874 return;
03875 }
03876
03877 GRFLocation location(_cur_grfconfig->grfid, _nfo_line + 1);
03878 GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
03879 if (it != _grf_line_to_action6_sprite_override.end()) {
03880 free(preload_sprite);
03881 preload_sprite = _grf_line_to_action6_sprite_override[location];
03882 } else {
03883 _grf_line_to_action6_sprite_override[location] = preload_sprite;
03884 }
03885
03886
03887 buf++;
03888
03889 for (;;) {
03890 uint i;
03891 uint param_num;
03892 uint param_size;
03893 uint offset;
03894 bool add_value;
03895
03896
03897 param_num = grf_load_byte(&buf);
03898 if (param_num == 0xFF) break;
03899
03900
03901
03902 param_size = grf_load_byte(&buf);
03903
03904
03905
03906 add_value = HasBit(param_size, 7);
03907 param_size = GB(param_size, 0, 7);
03908
03909
03910 offset = grf_load_extended(&buf);
03911
03912
03913
03914 if (param_num < 0x80 && (param_num + (param_size - 1) / 4) >= _cur_grffile->param_end) {
03915 grfmsg(2, "CfgApply: Ignoring (param %d not set)", (param_num + (param_size - 1) / 4));
03916 break;
03917 }
03918
03919 grfmsg(8, "CfgApply: Applying %u bytes from parameter 0x%02X at offset 0x%04X", param_size, param_num, offset);
03920
03921 bool carry = false;
03922 for (i = 0; i < param_size && offset + i < num; i++) {
03923 uint32 value = GetParamVal(param_num + i / 4, NULL);
03924
03925
03926 if (i == 0) carry = false;
03927
03928 if (add_value) {
03929 uint new_value = preload_sprite[offset + i] + GB(value, (i % 4) * 8, 8) + (carry ? 1 : 0);
03930 preload_sprite[offset + i] = GB(new_value, 0, 8);
03931
03932 carry = new_value >= 256;
03933 } else {
03934 preload_sprite[offset + i] = GB(value, (i % 4) * 8, 8);
03935 }
03936 }
03937 }
03938 }
03939
03949 static void DisableStaticNewGRFInfluencingNonStaticNewGRFs(GRFConfig *c)
03950 {
03951 if (c->error != NULL) {
03952 free(c->error->custom_message);
03953 free(c->error->data);
03954 free(c->error);
03955 }
03956 c->status = GCS_DISABLED;
03957 c->error = CallocT<GRFError>(1);
03958 c->error->data = strdup(_cur_grfconfig->name);
03959 c->error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
03960 c->error->message = STR_NEWGRF_ERROR_STATIC_GRF_CAUSES_DESYNC;
03961
03962 ClearTemporaryNewGRFData(GetFileByGRFID(c->grfid));
03963 }
03964
03965
03966
03967 static void SkipIf(byte *buf, size_t len)
03968 {
03969
03970
03971
03972
03973
03974
03975
03976
03977 uint32 cond_val = 0;
03978 uint32 mask = 0;
03979 bool result;
03980
03981 if (!check_length(len, 6, "SkipIf")) return;
03982 buf++;
03983 uint8 param = grf_load_byte(&buf);
03984 uint8 paramsize = grf_load_byte(&buf);
03985 uint8 condtype = grf_load_byte(&buf);
03986
03987 if (condtype < 2) {
03988
03989 paramsize = 1;
03990 }
03991
03992 switch (paramsize) {
03993 case 8: cond_val = grf_load_dword(&buf); mask = grf_load_dword(&buf); break;
03994 case 4: cond_val = grf_load_dword(&buf); mask = 0xFFFFFFFF; break;
03995 case 2: cond_val = grf_load_word(&buf); mask = 0x0000FFFF; break;
03996 case 1: cond_val = grf_load_byte(&buf); mask = 0x000000FF; break;
03997 default: break;
03998 }
03999
04000 if (param < 0x80 && _cur_grffile->param_end <= param) {
04001 grfmsg(7, "SkipIf: Param %d undefined, skipping test", param);
04002 return;
04003 }
04004
04005 uint32 param_val = GetParamVal(param, &cond_val);
04006
04007 grfmsg(7, "SkipIf: Test condtype %d, param 0x%08X, condval 0x%08X", condtype, param_val, cond_val);
04008
04009
04010
04011
04012
04013
04014
04015
04016 if (param == 0x88 && condtype != 0x0B && condtype != 0x0C) {
04017
04018
04019 GRFConfig *c = GetGRFConfig(cond_val, mask);
04020
04021 if (c != NULL && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur_grfconfig->flags, GCF_STATIC) && c->status != GCS_DISABLED && _networking) {
04022 DisableStaticNewGRFInfluencingNonStaticNewGRFs(c);
04023 c = NULL;
04024 }
04025
04026 if (condtype != 10 && c == NULL) {
04027 grfmsg(7, "SkipIf: GRFID 0x%08X unknown, skipping test", BSWAP32(cond_val));
04028 return;
04029 }
04030
04031 switch (condtype) {
04032
04033 case 0x06:
04034 result = c->status == GCS_ACTIVATED;
04035 break;
04036
04037 case 0x07:
04038 result = c->status != GCS_ACTIVATED;
04039 break;
04040
04041 case 0x08:
04042 result = c->status == GCS_INITIALISED;
04043 break;
04044
04045 case 0x09:
04046 result = c->status == GCS_ACTIVATED || c->status == GCS_INITIALISED;
04047 break;
04048
04049 case 0x0A:
04050
04051 result = c == NULL || c->flags == GCS_DISABLED || c->status == GCS_NOT_FOUND;
04052 break;
04053
04054 default: grfmsg(1, "SkipIf: Unsupported GRF condition type %02X. Ignoring", condtype); return;
04055 }
04056 } else {
04057
04058 switch (condtype) {
04059 case 0x00: result = !!(param_val & (1 << cond_val));
04060 break;
04061 case 0x01: result = !(param_val & (1 << cond_val));
04062 break;
04063 case 0x02: result = (param_val & mask) == cond_val;
04064 break;
04065 case 0x03: result = (param_val & mask) != cond_val;
04066 break;
04067 case 0x04: result = (param_val & mask) < cond_val;
04068 break;
04069 case 0x05: result = (param_val & mask) > cond_val;
04070 break;
04071 case 0x0B: result = GetCargoIDByLabel(BSWAP32(cond_val)) == CT_INVALID;
04072 break;
04073 case 0x0C: result = GetCargoIDByLabel(BSWAP32(cond_val)) != CT_INVALID;
04074 break;
04075 case 0x0D: result = GetRailTypeByLabel(BSWAP32(cond_val)) == INVALID_RAILTYPE;
04076 break;
04077 case 0x0E: result = GetRailTypeByLabel(BSWAP32(cond_val)) != INVALID_RAILTYPE;
04078 break;
04079
04080 default: grfmsg(1, "SkipIf: Unsupported condition type %02X. Ignoring", condtype); return;
04081 }
04082 }
04083
04084 if (!result) {
04085 grfmsg(2, "SkipIf: Not skipping sprites, test was false");
04086 return;
04087 }
04088
04089 uint8 numsprites = grf_load_byte(&buf);
04090
04091
04092
04093
04094
04095 GRFLabel *choice = NULL;
04096 for (GRFLabel *label = _cur_grffile->label; label != NULL; label = label->next) {
04097 if (label->label != numsprites) continue;
04098
04099
04100 if (choice == NULL) choice = label;
04101
04102 if (label->nfo_line > _nfo_line) {
04103 choice = label;
04104 break;
04105 }
04106 }
04107
04108 if (choice != NULL) {
04109 grfmsg(2, "SkipIf: Jumping to label 0x%0X at line %d, test was true", choice->label, choice->nfo_line);
04110 FioSeekTo(choice->pos, SEEK_SET);
04111 _nfo_line = choice->nfo_line;
04112 return;
04113 }
04114
04115 grfmsg(2, "SkipIf: Skipping %d sprites, test was true", numsprites);
04116 _skip_sprites = numsprites;
04117 if (_skip_sprites == 0) {
04118
04119
04120
04121 _skip_sprites = -1;
04122
04123
04124 if (_cur_grfconfig->status != GCS_ACTIVATED) {
04125 _cur_grfconfig->status = GCS_DISABLED;
04126 ClearTemporaryNewGRFData(_cur_grffile);
04127 }
04128 }
04129 }
04130
04131
04132
04133 static void ScanInfo(byte *buf, size_t len)
04134 {
04135 if (!check_length(len, 8, "Info")) return;
04136 buf++;
04137 grf_load_byte(&buf);
04138 uint32 grfid = grf_load_dword(&buf);
04139
04140 _cur_grfconfig->grfid = grfid;
04141
04142
04143 if (GB(grfid, 24, 8) == 0xFF) SetBit(_cur_grfconfig->flags, GCF_SYSTEM);
04144
04145 len -= 6;
04146 const char *name = grf_load_string(&buf, len);
04147 _cur_grfconfig->name = TranslateTTDPatchCodes(grfid, name);
04148
04149 len -= strlen(name) + 1;
04150 if (len > 0) {
04151 const char *info = grf_load_string(&buf, len);
04152 _cur_grfconfig->info = TranslateTTDPatchCodes(grfid, info);
04153 }
04154
04155
04156 _skip_sprites = -1;
04157 }
04158
04159
04160 static void GRFInfo(byte *buf, size_t len)
04161 {
04162
04163
04164
04165
04166
04167
04168
04169 if (!check_length(len, 8, "GRFInfo")) return;
04170 buf++;
04171 uint8 version = grf_load_byte(&buf);
04172 uint32 grfid = grf_load_dword(&buf);
04173 const char *name = grf_load_string(&buf, len - 6);
04174
04175 if (_cur_stage < GLS_RESERVE && _cur_grfconfig->status != GCS_UNKNOWN) {
04176 _cur_grfconfig->status = GCS_DISABLED;
04177 _cur_grfconfig->error = CallocT<GRFError>(1);
04178 _cur_grfconfig->error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
04179 _cur_grfconfig->error->message = STR_NEWGRF_ERROR_MULTIPLE_ACTION_8;
04180
04181 _skip_sprites = -1;
04182 return;
04183 }
04184
04185 _cur_grffile->grfid = grfid;
04186 _cur_grffile->grf_version = version;
04187 _cur_grfconfig->status = _cur_stage < GLS_RESERVE ? GCS_INITIALISED : GCS_ACTIVATED;
04188
04189
04190 DEBUG(grf, 1, "GRFInfo: Loaded GRFv%d set %08lX - %s (palette: %s)", version, BSWAP32(grfid), name, _cur_grfconfig->windows_paletted ? "Windows" : "DOS");
04191 }
04192
04193
04194 static void SpriteReplace(byte *buf, size_t len)
04195 {
04196
04197
04198
04199
04200
04201
04202
04203
04204 buf++;
04205 uint8 num_sets = grf_load_byte(&buf);
04206
04207 for (uint i = 0; i < num_sets; i++) {
04208 uint8 num_sprites = grf_load_byte(&buf);
04209 uint16 first_sprite = grf_load_word(&buf);
04210
04211 grfmsg(2, "SpriteReplace: [Set %d] Changing %d sprites, beginning with %d",
04212 i, num_sprites, first_sprite
04213 );
04214
04215 for (uint j = 0; j < num_sprites; j++) {
04216 int load_index = first_sprite + j;
04217 _nfo_line++;
04218 LoadNextSprite(load_index, _file_index, _nfo_line);
04219
04220
04221
04222 if (IsInsideMM(load_index, SPR_ORIGINALSHORE_START, SPR_ORIGINALSHORE_END + 1)) {
04223 if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
04224 }
04225 }
04226 }
04227 }
04228
04229
04230 static void SkipActA(byte *buf, size_t len)
04231 {
04232 buf++;
04233 uint8 num_sets = grf_load_byte(&buf);
04234
04235 for (uint i = 0; i < num_sets; i++) {
04236
04237 _skip_sprites += grf_load_byte(&buf);
04238
04239 grf_load_word(&buf);
04240 }
04241
04242 grfmsg(3, "SkipActA: Skipping %d sprites", _skip_sprites);
04243 }
04244
04245
04246 static void GRFLoadError(byte *buf, size_t len)
04247 {
04248
04249
04250
04251
04252
04253
04254
04255
04256
04257
04258
04259
04260
04261
04262
04263 static const StringID msgstr[] = {
04264 STR_NEWGRF_ERROR_VERSION_NUMBER,
04265 STR_NEWGRF_ERROR_DOS_OR_WINDOWS,
04266 STR_NEWGRF_ERROR_UNSET_SWITCH,
04267 STR_NEWGRF_ERROR_INVALID_PARAMETER,
04268 STR_NEWGRF_ERROR_LOAD_BEFORE,
04269 STR_NEWGRF_ERROR_LOAD_AFTER,
04270 STR_NEWGRF_ERROR_OTTD_VERSION_NUMBER,
04271 };
04272
04273 static const StringID sevstr[] = {
04274 STR_NEWGRF_ERROR_MSG_INFO,
04275 STR_NEWGRF_ERROR_MSG_WARNING,
04276 STR_NEWGRF_ERROR_MSG_ERROR,
04277 STR_NEWGRF_ERROR_MSG_FATAL
04278 };
04279
04280 if (!check_length(len, 6, "GRFLoadError")) return;
04281
04282
04283 if (_cur_grfconfig->error != NULL) return;
04284
04285 buf++;
04286 byte severity = grf_load_byte(&buf);
04287 byte lang = grf_load_byte(&buf);
04288 byte message_id = grf_load_byte(&buf);
04289 len -= 4;
04290
04291
04292 if (!CheckGrfLangID(lang, _cur_grffile->grf_version)) return;
04293
04294
04295
04296 if (!HasBit(severity, 7) && _cur_stage == GLS_INIT) {
04297 grfmsg(7, "GRFLoadError: Skipping non-fatal GRFLoadError in stage %d", _cur_stage);
04298 return;
04299 }
04300 ClrBit(severity, 7);
04301
04302 if (severity >= lengthof(sevstr)) {
04303 grfmsg(7, "GRFLoadError: Invalid severity id %d. Setting to 2 (non-fatal error).", severity);
04304 severity = 2;
04305 } else if (severity == 3) {
04306
04307
04308 _cur_grfconfig->status = GCS_DISABLED;
04309 ClearTemporaryNewGRFData(_cur_grffile);
04310 _skip_sprites = -1;
04311 }
04312
04313 if (message_id >= lengthof(msgstr) && message_id != 0xFF) {
04314 grfmsg(7, "GRFLoadError: Invalid message id.");
04315 return;
04316 }
04317
04318 if (len <= 1) {
04319 grfmsg(7, "GRFLoadError: No message data supplied.");
04320 return;
04321 }
04322
04323 GRFError *error = CallocT<GRFError>(1);
04324
04325 error->severity = sevstr[severity];
04326
04327 if (message_id == 0xFF) {
04328
04329 const char *message = grf_load_string(&buf, len);
04330 len -= (strlen(message) + 1);
04331
04332 error->custom_message = TranslateTTDPatchCodes(_cur_grffile->grfid, message);
04333 } else {
04334 error->message = msgstr[message_id];
04335 }
04336
04337 if (len > 0) {
04338 const char *data = grf_load_string(&buf, len);
04339 len -= (strlen(data) + 1);
04340
04341 error->data = TranslateTTDPatchCodes(_cur_grffile->grfid, data);
04342 }
04343
04344
04345 uint i = 0;
04346 for (; i < 2 && len > 0; i++) {
04347 error->param_number[i] = grf_load_byte(&buf);
04348 len--;
04349 }
04350 error->num_params = i;
04351
04352 _cur_grfconfig->error = error;
04353 }
04354
04355
04356 static void GRFComment(byte *buf, size_t len)
04357 {
04358
04359
04360
04361
04362 if (len == 1) return;
04363
04364 size_t text_len = len - 1;
04365 const char *text = (const char*)(buf + 1);
04366 grfmsg(2, "GRFComment: %.*s", text_len, text);
04367 }
04368
04369
04370 static void SafeParamSet(byte *buf, size_t len)
04371 {
04372 if (!check_length(len, 5, "SafeParamSet")) return;
04373 buf++;
04374 uint8 target = grf_load_byte(&buf);
04375
04376
04377 if (target < 0x80) return;
04378
04379
04380
04381
04382
04383
04384 SetBit(_cur_grfconfig->flags, GCF_UNSAFE);
04385
04386
04387 _skip_sprites = -1;
04388 }
04389
04390
04391 static uint32 GetPatchVariable(uint8 param)
04392 {
04393 switch (param) {
04394
04395 case 0x0B: return max(_settings_game.game_creation.starting_year, ORIGINAL_BASE_YEAR) - ORIGINAL_BASE_YEAR;
04396
04397
04398 case 0x0E: return _settings_game.vehicle.freight_trains;
04399
04400
04401 case 0x0F: return 0;
04402
04403
04404
04405
04406 case 0x10:
04407 switch (_settings_game.vehicle.plane_speed) {
04408 default:
04409 case 4: return 1;
04410 case 3: return 2;
04411 case 2: return 2;
04412 case 1: return 4;
04413 }
04414
04415
04416
04417 case 0x11: return SPR_2CCMAP_BASE;
04418
04419
04420
04421
04422
04423
04424
04425
04426
04427
04428
04429
04430 case 0x13: {
04431 byte map_bits = 0;
04432 byte log_X = MapLogX() - 6;
04433 byte log_Y = MapLogY() - 6;
04434 byte max_edge = max(log_X, log_Y);
04435
04436 if (log_X == log_Y) {
04437 SetBit(map_bits ,0);
04438 } else {
04439 if (max_edge == log_Y) SetBit(map_bits, 1);
04440 }
04441
04442 return (map_bits << 24) | (min(log_X, log_Y) << 20) | (max_edge << 16) |
04443 (log_X << 12) | (log_Y << 8) | (log_X + log_Y);
04444 }
04445
04446 default:
04447 grfmsg(2, "ParamSet: Unknown Patch variable 0x%02X.", param);
04448 return 0;
04449 }
04450 }
04451
04452
04453 static uint32 PerformGRM(uint32 *grm, uint16 num_ids, uint16 count, uint8 op, uint8 target, const char *type)
04454 {
04455 uint start = 0;
04456 uint size = 0;
04457
04458 if (op == 6) {
04459
04460 return grm[_cur_grffile->param[target]];
04461 }
04462
04463
04464 if (op == 2 || op == 3) start = _cur_grffile->param[target];
04465
04466 for (uint i = start; i < num_ids; i++) {
04467 if (grm[i] == 0) {
04468 size++;
04469 } else {
04470 if (op == 2 || op == 3) break;
04471 start = i + 1;
04472 size = 0;
04473 }
04474
04475 if (size == count) break;
04476 }
04477
04478 if (size == count) {
04479
04480 if (op == 0 || op == 3) {
04481 grfmsg(2, "ParamSet: GRM: Reserving %d %s at %d", count, type, start);
04482 for (uint i = 0; i < count; i++) grm[start + i] = _cur_grffile->grfid;
04483 }
04484 return start;
04485 }
04486
04487
04488 if (op != 4 && op != 5) {
04489
04490 grfmsg(0, "ParamSet: GRM: Unable to allocate %d %s, deactivating", count, type);
04491 _cur_grfconfig->status = GCS_DISABLED;
04492 ClearTemporaryNewGRFData(_cur_grffile);
04493 _skip_sprites = -1;
04494 return UINT_MAX;
04495 }
04496
04497 grfmsg(1, "ParamSet: GRM: Unable to allocate %d %s", count, type);
04498 return UINT_MAX;
04499 }
04500
04501
04502
04503 static void ParamSet(byte *buf, size_t len)
04504 {
04505
04506
04507
04508
04509
04510
04511
04512
04513
04514
04515
04516
04517
04518
04519
04520
04521
04522
04523
04524
04525
04526
04527 if (!check_length(len, 5, "ParamSet")) return;
04528 buf++;
04529 uint8 target = grf_load_byte(&buf);
04530 uint8 oper = grf_load_byte(&buf);
04531 uint32 src1 = grf_load_byte(&buf);
04532 uint32 src2 = grf_load_byte(&buf);
04533
04534 uint32 data = 0;
04535 if (len >= 8) data = grf_load_dword(&buf);
04536
04537
04538
04539
04540
04541
04542
04543 if (HasBit(oper, 7)) {
04544 if (target < 0x80 && target < _cur_grffile->param_end) {
04545 grfmsg(7, "ParamSet: Param %u already defined, skipping", target);
04546 return;
04547 }
04548
04549 oper = GB(oper, 0, 7);
04550 }
04551
04552 if (src2 == 0xFE) {
04553 if (GB(data, 0, 8) == 0xFF) {
04554 if (data == 0x0000FFFF) {
04555
04556 src1 = GetPatchVariable(src1);
04557 } else {
04558
04559 uint8 op = src1;
04560 uint8 feature = GB(data, 8, 8);
04561 uint16 count = GB(data, 16, 16);
04562
04563 if (_cur_stage == GLS_RESERVE) {
04564 if (feature == 0x08) {
04565
04566 if (op == 0) {
04567
04568 if (_cur_spriteid + count >= 16384) {
04569 grfmsg(0, "ParamSet: GRM: Unable to allocate %d sprites; try changing NewGRF order", count);
04570 _cur_grfconfig->status = GCS_DISABLED;
04571 ClearTemporaryNewGRFData(_cur_grffile);
04572 _skip_sprites = -1;
04573 return;
04574 }
04575
04576
04577 grfmsg(4, "ParamSet: GRM: Allocated %d sprites at %d", count, _cur_spriteid);
04578 _grm_sprites[GRFLocation(_cur_grffile->grfid, _nfo_line)] = _cur_spriteid;
04579 _cur_spriteid += count;
04580 }
04581 }
04582
04583 src1 = 0;
04584 } else if (_cur_stage == GLS_ACTIVATION) {
04585 switch (feature) {
04586 case 0x00:
04587 case 0x01:
04588 case 0x02:
04589 case 0x03:
04590 if (!_settings_game.vehicle.dynamic_engines) {
04591 src1 = PerformGRM(&_grm_engines[_engine_offsets[feature]], _engine_counts[feature], count, op, target, "vehicles");
04592 if (_skip_sprites == -1) return;
04593 } else {
04594
04595 switch (op) {
04596 case 2:
04597 case 3:
04598 src1 = _cur_grffile->param[target];
04599 break;
04600
04601 default:
04602 src1 = 0;
04603 break;
04604 }
04605 }
04606 break;
04607
04608 case 0x08:
04609 switch (op) {
04610 case 0:
04611
04612 src1 = _grm_sprites[GRFLocation(_cur_grffile->grfid, _nfo_line)];
04613 grfmsg(4, "ParamSet: GRM: Using pre-allocated sprites at %d", src1);
04614 break;
04615
04616 case 1:
04617 src1 = _cur_spriteid;
04618 break;
04619
04620 default:
04621 grfmsg(1, "ParamSet: GRM: Unsupported operation %d for general sprites", op);
04622 return;
04623 }
04624 break;
04625
04626 case 0x0B:
04627
04628 src1 = PerformGRM(_grm_cargos, NUM_CARGO * 2, count, op, target, "cargos");
04629 if (_skip_sprites == -1) return;
04630 break;
04631
04632 default: grfmsg(1, "ParamSet: GRM: Unsupported feature 0x%X", feature); return;
04633 }
04634 } else {
04635
04636 src1 = 0;
04637 }
04638 }
04639 } else {
04640
04641 const GRFFile *file = GetFileByGRFID(data);
04642 GRFConfig *c = GetGRFConfig(data);
04643 if (c != NULL && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur_grfconfig->flags, GCF_STATIC) && _networking) {
04644
04645 DisableStaticNewGRFInfluencingNonStaticNewGRFs(c);
04646 src1 = 0;
04647 } else if (file == NULL || src1 >= file->param_end || (c != NULL && c->status == GCS_DISABLED)) {
04648 src1 = 0;
04649 } else {
04650 src1 = file->param[src1];
04651 }
04652 }
04653 } else {
04654
04655
04656
04657
04658
04659 src1 = (src1 == 0xFF) ? data : GetParamVal(src1, NULL);
04660 src2 = (src2 == 0xFF) ? data : GetParamVal(src2, NULL);
04661 }
04662
04663
04664
04665
04666
04667
04668
04669 uint32 res;
04670 switch (oper) {
04671 case 0x00:
04672 res = src1;
04673 break;
04674
04675 case 0x01:
04676 res = src1 + src2;
04677 break;
04678
04679 case 0x02:
04680 res = src1 - src2;
04681 break;
04682
04683 case 0x03:
04684 res = src1 * src2;
04685 break;
04686
04687 case 0x04:
04688 res = (int32)src1 * (int32)src2;
04689 break;
04690
04691 case 0x05:
04692 if ((int32)src2 < 0) {
04693 res = src1 >> -(int32)src2;
04694 } else {
04695 res = src1 << src2;
04696 }
04697 break;
04698
04699 case 0x06:
04700 if ((int32)src2 < 0) {
04701 res = (int32)src1 >> -(int32)src2;
04702 } else {
04703 res = (int32)src1 << src2;
04704 }
04705 break;
04706
04707 case 0x07:
04708 res = src1 & src2;
04709 break;
04710
04711 case 0x08:
04712 res = src1 | src2;
04713 break;
04714
04715 case 0x09:
04716 if (src2 == 0) {
04717 res = src1;
04718 } else {
04719 res = src1 / src2;
04720 }
04721 break;
04722
04723 case 0x0A:
04724 if (src2 == 0) {
04725 res = src1;
04726 } else {
04727 res = (int32)src1 / (int32)src2;
04728 }
04729 break;
04730
04731 case 0x0B:
04732 if (src2 == 0) {
04733 res = src1;
04734 } else {
04735 res = src1 % src2;
04736 }
04737 break;
04738
04739 case 0x0C:
04740 if (src2 == 0) {
04741 res = src1;
04742 } else {
04743 res = (int32)src1 % (int32)src2;
04744 }
04745 break;
04746
04747 default: grfmsg(0, "ParamSet: Unknown operation %d, skipping", oper); return;
04748 }
04749
04750 switch (target) {
04751 case 0x8E:
04752 _traininfo_vehicle_pitch = res;
04753 break;
04754
04755 case 0x8F: {
04756 extern RailtypeInfo _railtypes[RAILTYPE_END];
04757 _railtypes[RAILTYPE_RAIL].cost_multiplier = GB(res, 0, 8);
04758 if (_settings_game.vehicle.disable_elrails) {
04759 _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 0, 8);
04760 _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 8, 8);
04761 } else {
04762 _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 8, 8);
04763 _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 16, 8);
04764 }
04765 _railtypes[RAILTYPE_MAGLEV].cost_multiplier = GB(res, 16, 8);
04766 break;
04767 }
04768
04769
04770 case 0x93:
04771 case 0x94:
04772 case 0x95:
04773 case 0x96:
04774 case 0x97:
04775 case 0x99:
04776 grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
04777 break;
04778
04779 case 0x9E:
04780 _misc_grf_features = res;
04781
04782 _traininfo_vehicle_width = HasGrfMiscBit(GMB_TRAIN_WIDTH_32_PIXELS) ? 32 : 29;
04783 break;
04784
04785 case 0x9F:
04786 grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
04787 break;
04788
04789 default:
04790 if (target < 0x80) {
04791 _cur_grffile->param[target] = res;
04792 if (target + 1U > _cur_grffile->param_end) _cur_grffile->param_end = target + 1;
04793 } else {
04794 grfmsg(7, "ParamSet: Skipping unknown target 0x%02X", target);
04795 }
04796 break;
04797 }
04798 }
04799
04800
04801 static void SafeGRFInhibit(byte *buf, size_t len)
04802 {
04803
04804
04805
04806
04807
04808 if (!check_length(len, 2, "GRFInhibit")) return;
04809 buf++;
04810 uint8 num = grf_load_byte(&buf);
04811 if (!check_length(len, 2 + 4 * num, "GRFInhibit")) return;
04812
04813 for (uint i = 0; i < num; i++) {
04814 uint32 grfid = grf_load_dword(&buf);
04815
04816
04817 if (grfid != _cur_grfconfig->grfid) {
04818 SetBit(_cur_grfconfig->flags, GCF_UNSAFE);
04819
04820
04821 _skip_sprites = -1;
04822
04823 return;
04824 }
04825 }
04826 }
04827
04828
04829 static void GRFInhibit(byte *buf, size_t len)
04830 {
04831
04832
04833
04834
04835
04836 if (!check_length(len, 2, "GRFInhibit")) return;
04837 buf++;
04838 uint8 num = grf_load_byte(&buf);
04839 if (!check_length(len, 2 + 4 * num, "GRFInhibit")) return;
04840
04841 for (uint i = 0; i < num; i++) {
04842 uint32 grfid = grf_load_dword(&buf);
04843 GRFConfig *file = GetGRFConfig(grfid);
04844
04845
04846 if (file != NULL && file != _cur_grfconfig) {
04847 grfmsg(2, "GRFInhibit: Deactivating file '%s'", file->filename);
04848 file->status = GCS_DISABLED;
04849 }
04850 }
04851 }
04852
04853
04854 static void FeatureTownName(byte *buf, size_t len)
04855 {
04856
04857
04858
04859
04860
04861
04862
04863 if (!check_length(len, 1, "FeatureTownName: definition ID")) return;
04864 buf++; len--;
04865
04866 uint32 grfid = _cur_grffile->grfid;
04867
04868 GRFTownName *townname = AddGRFTownName(grfid);
04869
04870 byte id = grf_load_byte(&buf);
04871 len--;
04872 grfmsg(6, "FeatureTownName: definition 0x%02X", id & 0x7F);
04873
04874 if (HasBit(id, 7)) {
04875
04876 ClrBit(id, 7);
04877 bool new_scheme = _cur_grffile->grf_version >= 7;
04878
04879 if (!check_length(len, 1, "FeatureTownName: lang_id")) return;
04880 byte lang = grf_load_byte(&buf);
04881 len--;
04882
04883 byte nb_gen = townname->nb_gen;
04884 do {
04885 ClrBit(lang, 7);
04886
04887 if (!check_length(len, 1, "FeatureTownName: style name")) return;
04888 const char *name = grf_load_string(&buf, len);
04889 len -= strlen(name) + 1;
04890
04891 char *lang_name = TranslateTTDPatchCodes(grfid, name);
04892 grfmsg(6, "FeatureTownName: lang 0x%X -> '%s'", lang, lang_name);
04893 free(lang_name);
04894
04895 townname->name[nb_gen] = AddGRFString(grfid, id, lang, new_scheme, name, STR_UNDEFINED);
04896
04897 if (!check_length(len, 1, "FeatureTownName: lang_id")) return;
04898 lang = grf_load_byte(&buf);
04899 len--;
04900 } while (lang != 0);
04901 townname->id[nb_gen] = id;
04902 townname->nb_gen++;
04903 }
04904
04905 if (!check_length(len, 1, "FeatureTownName: number of parts")) return;
04906 byte nb = grf_load_byte(&buf);
04907 len--;
04908 grfmsg(6, "FeatureTownName: %d parts", nb, nb);
04909
04910 townname->nbparts[id] = nb;
04911 townname->partlist[id] = CallocT<NamePartList>(nb);
04912
04913 for (int i = 0; i < nb; i++) {
04914 if (!check_length(len, 3, "FeatureTownName: parts header")) return;
04915 byte nbtext = grf_load_byte(&buf);
04916 townname->partlist[id][i].bitstart = grf_load_byte(&buf);
04917 townname->partlist[id][i].bitcount = grf_load_byte(&buf);
04918 townname->partlist[id][i].maxprob = 0;
04919 townname->partlist[id][i].partcount = nbtext;
04920 townname->partlist[id][i].parts = CallocT<NamePart>(nbtext);
04921 len -= 3;
04922 grfmsg(6, "FeatureTownName: part %d contains %d texts and will use GB(seed, %d, %d)", i, nbtext, townname->partlist[id][i].bitstart, townname->partlist[id][i].bitcount);
04923
04924 for (int j = 0; j < nbtext; j++) {
04925 if (!check_length(len, 2, "FeatureTownName: part")) return;
04926 byte prob = grf_load_byte(&buf);
04927 len--;
04928
04929 if (HasBit(prob, 7)) {
04930 byte ref_id = grf_load_byte(&buf);
04931 len--;
04932
04933 if (townname->nbparts[ref_id] == 0) {
04934 grfmsg(0, "FeatureTownName: definition 0x%02X doesn't exist, deactivating", ref_id);
04935 DelGRFTownName(grfid);
04936 _cur_grfconfig->status = GCS_DISABLED;
04937 ClearTemporaryNewGRFData(_cur_grffile);
04938 _skip_sprites = -1;
04939 return;
04940 }
04941
04942 grfmsg(6, "FeatureTownName: part %d, text %d, uses intermediate definition 0x%02X (with probability %d)", i, j, ref_id, prob & 0x7F);
04943 townname->partlist[id][i].parts[j].data.id = ref_id;
04944 } else {
04945 const char *text = grf_load_string(&buf, len);
04946 len -= strlen(text) + 1;
04947 townname->partlist[id][i].parts[j].data.text = TranslateTTDPatchCodes(grfid, text);
04948 grfmsg(6, "FeatureTownName: part %d, text %d, '%s' (with probability %d)", i, j, townname->partlist[id][i].parts[j].data.text, prob);
04949 }
04950 townname->partlist[id][i].parts[j].prob = prob;
04951 townname->partlist[id][i].maxprob += GB(prob, 0, 7);
04952 }
04953 grfmsg(6, "FeatureTownName: part %d, total probability %d", i, townname->partlist[id][i].maxprob);
04954 }
04955 }
04956
04957
04958 static void DefineGotoLabel(byte *buf, size_t len)
04959 {
04960
04961
04962
04963
04964
04965 if (!check_length(len, 1, "DefineGotoLabel")) return;
04966 buf++; len--;
04967
04968 GRFLabel *label = MallocT<GRFLabel>(1);
04969 label->label = grf_load_byte(&buf);
04970 label->nfo_line = _nfo_line;
04971 label->pos = FioGetPos();
04972 label->next = NULL;
04973
04974
04975 if (_cur_grffile->label == NULL) {
04976 _cur_grffile->label = label;
04977 } else {
04978
04979 GRFLabel *l;
04980 for (l = _cur_grffile->label; l->next != NULL; l = l->next) {}
04981 l->next = label;
04982 }
04983
04984 grfmsg(2, "DefineGotoLabel: GOTO target with label 0x%02X", label->label);
04985 }
04986
04987
04988 static void GRFSound(byte *buf, size_t len)
04989 {
04990
04991
04992
04993
04994 if (!check_length(len, 1, "GRFSound")) return;
04995 buf++;
04996 uint16 num = grf_load_word(&buf);
04997
04998 _grf_data_blocks = num;
04999 _grf_data_type = GDT_SOUND;
05000
05001 if (_cur_grffile->sound_offset == 0) _cur_grffile->sound_offset = GetNumSounds();
05002 }
05003
05004
05005 static void SkipAct11(byte *buf, size_t len)
05006 {
05007
05008
05009
05010
05011 if (!check_length(len, 1, "SkipAct11")) return;
05012 buf++;
05013 _skip_sprites = grf_load_word(&buf);
05014
05015 grfmsg(3, "SkipAct11: Skipping %d sprites", _skip_sprites);
05016 }
05017
05018 static void ImportGRFSound(byte *buf, int len)
05019 {
05020 const GRFFile *file;
05021 FileEntry *se = AllocateFileEntry();
05022 uint32 grfid = grf_load_dword(&buf);
05023 uint16 sound = grf_load_word(&buf);
05024
05025 file = GetFileByGRFID(grfid);
05026 if (file == NULL || file->sound_offset == 0) {
05027 grfmsg(1, "ImportGRFSound: Source file not available");
05028 return;
05029 }
05030
05031 if (file->sound_offset + sound >= GetNumSounds()) {
05032 grfmsg(1, "ImportGRFSound: Sound effect %d is invalid", sound);
05033 return;
05034 }
05035
05036 grfmsg(2, "ImportGRFSound: Copying sound %d (%d) from file %X", sound, file->sound_offset + sound, grfid);
05037
05038 *se = *GetSound(file->sound_offset + sound);
05039
05040
05041 se->volume = 128;
05042 se->priority = 0;
05043 }
05044
05045
05046 static void GRFImportBlock(byte *buf, int len)
05047 {
05048 if (_grf_data_blocks == 0) {
05049 grfmsg(2, "GRFImportBlock: Unexpected import block, skipping");
05050 return;
05051 }
05052
05053 buf++;
05054
05055 _grf_data_blocks--;
05056
05057
05058
05059 if (grf_load_byte(&buf) != _grf_data_type) {
05060 grfmsg(1, "GRFImportBlock: Import type mismatch");
05061 }
05062
05063 switch (_grf_data_type) {
05064 case GDT_SOUND: ImportGRFSound(buf, len - 1); break;
05065 default: NOT_REACHED(); break;
05066 }
05067 }
05068
05069 static void LoadGRFSound(byte *buf, int len)
05070 {
05071 byte *buf_start = buf;
05072
05073
05074
05075 FileEntry *se = AllocateFileEntry();
05076
05077 if (grf_load_dword(&buf) != BSWAP32('RIFF')) {
05078 grfmsg(1, "LoadGRFSound: Missing RIFF header");
05079 return;
05080 }
05081
05082
05083 grf_load_dword(&buf);
05084
05085 if (grf_load_dword(&buf) != BSWAP32('WAVE')) {
05086 grfmsg(1, "LoadGRFSound: Invalid RIFF type");
05087 return;
05088 }
05089
05090 for (;;) {
05091 uint32 tag = grf_load_dword(&buf);
05092 uint32 size = grf_load_dword(&buf);
05093
05094 switch (tag) {
05095 case ' tmf':
05096
05097 if (grf_load_word(&buf) != 1) {
05098 grfmsg(1, "LoadGRFSound: Invalid audio format");
05099 return;
05100 }
05101 se->channels = grf_load_word(&buf);
05102 se->rate = grf_load_dword(&buf);
05103 grf_load_dword(&buf);
05104 grf_load_word(&buf);
05105 se->bits_per_sample = grf_load_word(&buf);
05106
05107
05108 for (; size > 16; size--) grf_load_byte(&buf);
05109 break;
05110
05111 case 'atad':
05112 se->file_size = size;
05113 se->file_offset = FioGetPos() - (len - (buf - buf_start)) + 1;
05114 se->file_slot = _file_index;
05115
05116
05117 se->volume = 0x80;
05118 se->priority = 0;
05119
05120 grfmsg(2, "LoadGRFSound: channels %u, sample rate %u, bits per sample %u, length %u", se->channels, se->rate, se->bits_per_sample, size);
05121 return;
05122
05123 default:
05124 se->file_size = 0;
05125 return;
05126 }
05127 }
05128 }
05129
05130
05131 static void LoadFontGlyph(byte *buf, size_t len)
05132 {
05133
05134
05135
05136
05137
05138
05139
05140 buf++; len--;
05141 if (!check_length(len, 1, "LoadFontGlyph")) return;
05142
05143 uint8 num_def = grf_load_byte(&buf);
05144
05145 if (!check_length(len, 1 + num_def * 4, "LoadFontGlyph")) return;
05146
05147 for (uint i = 0; i < num_def; i++) {
05148 FontSize size = (FontSize)grf_load_byte(&buf);
05149 uint8 num_char = grf_load_byte(&buf);
05150 uint16 base_char = grf_load_word(&buf);
05151
05152 grfmsg(7, "LoadFontGlyph: Loading %u glyph(s) at 0x%04X for size %u", num_char, base_char, size);
05153
05154 for (uint c = 0; c < num_char; c++) {
05155 SetUnicodeGlyph(size, base_char + c, _cur_spriteid);
05156 _nfo_line++;
05157 LoadNextSprite(_cur_spriteid++, _file_index, _nfo_line);
05158 }
05159 }
05160 }
05161
05162
05163 static void SkipAct12(byte *buf, size_t len)
05164 {
05165
05166
05167
05168
05169
05170
05171
05172 buf++; len--;
05173 if (!check_length(len, 1, "SkipAct12")) return;
05174 uint8 num_def = grf_load_byte(&buf);
05175
05176 if (!check_length(len, 1 + num_def * 4, "SkipAct12")) return;
05177
05178 for (uint i = 0; i < num_def; i++) {
05179
05180 grf_load_byte(&buf);
05181
05182
05183 _skip_sprites += grf_load_byte(&buf);
05184
05185
05186 grf_load_word(&buf);
05187 }
05188
05189 grfmsg(3, "SkipAct12: Skipping %d sprites", _skip_sprites);
05190 }
05191
05192
05193 static void TranslateGRFStrings(byte *buf, size_t len)
05194 {
05195
05196
05197
05198
05199
05200
05201
05202 buf++; len--;
05203 if (!check_length(len, 7, "TranslateGRFString")) return;
05204
05205 uint32 grfid = grf_load_dword(&buf);
05206 const GRFConfig *c = GetGRFConfig(grfid);
05207 if (c == NULL || (c->status != GCS_INITIALISED && c->status != GCS_ACTIVATED)) {
05208 grfmsg(7, "TranslateGRFStrings: GRFID 0x%08x unknown, skipping action 13", BSWAP32(grfid));
05209 return;
05210 }
05211
05212 if (c->status == GCS_INITIALISED) {
05213
05214
05215 GRFError *error = CallocT<GRFError>(1);
05216
05217 char tmp[256];
05218 GetString(tmp, STR_NEWGRF_ERROR_AFTER_TRANSLATED_FILE, lastof(tmp));
05219 error->data = strdup(tmp);
05220
05221 error->message = STR_NEWGRF_ERROR_LOAD_AFTER;
05222 error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
05223
05224 if (_cur_grfconfig->error != NULL) free(_cur_grfconfig->error);
05225 _cur_grfconfig->error = error;
05226
05227 _cur_grfconfig->status = GCS_DISABLED;
05228 ClearTemporaryNewGRFData(_cur_grffile);
05229 _skip_sprites = -1;
05230 return;
05231 }
05232
05233 byte num_strings = grf_load_byte(&buf);
05234 uint16 first_id = grf_load_word(&buf);
05235
05236 if (!((first_id >= 0xD000 && first_id + num_strings <= 0xD3FF) || (first_id >= 0xDC00 && first_id + num_strings <= 0xDCFF))) {
05237 grfmsg(7, "TranslateGRFStrings: Attempting to set out-of-range string IDs in action 13 (first: 0x%4X, number: 0x%2X)", first_id, num_strings);
05238 return;
05239 }
05240
05241 len -= 7;
05242
05243 for (uint i = 0; i < num_strings && len > 0; i++) {
05244 const char *string = grf_load_string(&buf, len);
05245 size_t string_length = strlen(string) + 1;
05246
05247 len -= (int)string_length;
05248
05249 if (string_length == 1) {
05250 grfmsg(7, "TranslateGRFString: Ignoring empty string.");
05251 continue;
05252 }
05253
05254
05255
05256
05257
05258
05259 AddGRFString(grfid, first_id + i, 0x7F, true, string, STR_UNDEFINED);
05260 }
05261 }
05262
05263
05264 static void GRFDataBlock(byte *buf, int len)
05265 {
05266 if (_grf_data_blocks == 0) {
05267 grfmsg(2, "GRFDataBlock: unexpected data block, skipping");
05268 return;
05269 }
05270
05271 buf++;
05272 uint8 name_len = grf_load_byte(&buf);
05273 const char *name = (const char *)buf;
05274 buf += name_len + 1;
05275
05276 grfmsg(2, "GRFDataBlock: block name '%s'...", name);
05277
05278 _grf_data_blocks--;
05279
05280 switch (_grf_data_type) {
05281 case GDT_SOUND: LoadGRFSound(buf, len - name_len - 2); break;
05282 default: NOT_REACHED(); break;
05283 }
05284 }
05285
05286
05287
05288 static void GRFUnsafe(byte *buf, size_t len)
05289 {
05290 SetBit(_cur_grfconfig->flags, GCF_UNSAFE);
05291
05292
05293 _skip_sprites = -1;
05294 }
05295
05296
05297 static void InitializeGRFSpecial()
05298 {
05299 _ttdpatch_flags[0] = ((_settings_game.station.always_small_airport ? 1 : 0) << 0x0C)
05300 | (1 << 0x0D)
05301 | (1 << 0x0E)
05302 | ((_settings_game.construction.longbridges ? 1 : 0) << 0x0F)
05303 | (0 << 0x10)
05304 | (1 << 0x12)
05305 | (1 << 0x13)
05306 | ((_settings_game.vehicle.never_expire_vehicles ? 1 : 0) << 0x16)
05307 | (1 << 0x1B)
05308 | (1 << 0x1D)
05309 | (1 << 0x1E);
05310
05311 _ttdpatch_flags[1] = ((_settings_game.economy.station_noise_level ? 1 : 0) << 0x07)
05312 | ((_settings_game.vehicle.mammoth_trains ? 1 : 0) << 0x08)
05313 | (1 << 0x09)
05314 | (0 << 0x0B)
05315 | ((_settings_game.order.gradual_loading ? 1 : 0) << 0x0C)
05316 | (1 << 0x12)
05317 | (1 << 0x13)
05318 | (1 << 0x14)
05319 | (1 << 0x16)
05320 | (1 << 0x17)
05321 | (1 << 0x18)
05322 | (1 << 0x19)
05323 | (1 << 0x1A)
05324 | ((_settings_game.construction.signal_side ? 1 : 0) << 0x1B)
05325 | ((_settings_game.vehicle.disable_elrails ? 0 : 1) << 0x1C);
05326
05327 _ttdpatch_flags[2] = (1 << 0x01)
05328 | (1 << 0x03)
05329 | (0 << 0x0B)
05330 | (0 << 0x0C)
05331 | ((_settings_game.construction.build_on_slopes ? 1 : 0) << 0x0D)
05332 | (1 << 0x0E)
05333 | (1 << 0x0F)
05334 | (0 << 0x10)
05335 | (0 << 0x11)
05336 | (1 << 0x12)
05337 | (1 << 0x13)
05338 | (1 << 0x14)
05339 | ((_settings_game.construction.build_on_slopes ? 1 : 0) << 0x15)
05340 | (1 << 0x16)
05341 | (1 << 0x17)
05342 | ((_settings_game.vehicle.freight_trains > 1 ? 1 : 0) << 0x18)
05343 | (1 << 0x19)
05344 | (1 << 0x1A)
05345 | (1 << 0x1B)
05346 | (1 << 0x1C)
05347 | ((_settings_game.vehicle.wagon_speed_limits ? 1 : 0) << 0x1D)
05348 | (1 << 0x1E)
05349 | (0 << 0x1F);
05350
05351 _ttdpatch_flags[3] = (0 << 0x00)
05352 | (1 << 0x01)
05353 | ((_settings_game.economy.allow_town_roads || _generating_world ? 0 : 1) << 0x02)
05354 | (1 << 0x03)
05355 | (0 << 0x04)
05356 | (1 << 0x05)
05357 | (1 << 0x06)
05358 | (1 << 0x07)
05359 | ((_settings_game.order.improved_load ? 1 : 0) << 0x08)
05360 | (0 << 0x09)
05361 | (0 << 0x0A)
05362 | (1 << 0x0B)
05363 | (1 << 0x0C)
05364 | (1 << 0x0D)
05365 | ((_settings_game.station.nonuniform_stations ? 1 : 0) << 0x0E)
05366 | (1 << 0x0F)
05367 | (1 << 0x10)
05368 | (1 << 0x11)
05369 | (1 << 0x12)
05370 | (0 << 0x13)
05371 | (1 << 0x14)
05372 | (0 << 0x15)
05373 | (1 << 0x16)
05374 | (1 << 0x17)
05375 | ((_settings_game.vehicle.dynamic_engines ? 1 : 0) << 0x18)
05376 | (1 << 0x1E)
05377 | (1 << 0x1F);
05378 }
05379
05380 static void ResetCustomStations()
05381 {
05382 for (GRFFile *file = _first_grffile; file != NULL; file = file->next) {
05383 if (file->stations == NULL) continue;
05384 for (uint i = 0; i < MAX_STATIONS; i++) {
05385 if (file->stations[i] == NULL) continue;
05386 StationSpec *statspec = file->stations[i];
05387
05388
05389 if (!statspec->copied_renderdata) {
05390 for (uint t = 0; t < statspec->tiles; t++) {
05391 free((void*)statspec->renderdata[t].seq);
05392 }
05393 free(statspec->renderdata);
05394 }
05395
05396
05397 if (!statspec->copied_layouts) {
05398 for (uint l = 0; l < statspec->lengths; l++) {
05399 for (uint p = 0; p < statspec->platforms[l]; p++) {
05400 free(statspec->layouts[l][p]);
05401 }
05402 free(statspec->layouts[l]);
05403 }
05404 free(statspec->layouts);
05405 free(statspec->platforms);
05406 }
05407
05408
05409 free(statspec);
05410 }
05411
05412
05413 free(file->stations);
05414 file->stations = NULL;
05415 }
05416 }
05417
05418 static void ResetCustomHouses()
05419 {
05420 GRFFile *file;
05421 uint i;
05422
05423 for (file = _first_grffile; file != NULL; file = file->next) {
05424 if (file->housespec == NULL) continue;
05425 for (i = 0; i < HOUSE_MAX; i++) {
05426 free(file->housespec[i]);
05427 }
05428
05429 free(file->housespec);
05430 file->housespec = NULL;
05431 }
05432 }
05433
05434 static void ResetCustomIndustries()
05435 {
05436 GRFFile *file;
05437
05438 for (file = _first_grffile; file != NULL; file = file->next) {
05439 uint i;
05440
05441
05442 if (file->industryspec != NULL) {
05443
05444 for (i = 0; i < NUM_INDUSTRYTYPES; i++) {
05445 IndustrySpec *ind = file->industryspec[i];
05446
05447 if (ind != NULL) {
05448
05449 if (HasBit(ind->cleanup_flag, CLEAN_RANDOMSOUNDS)) {
05450 free((void*)ind->random_sounds);
05451 }
05452
05453
05454 if (HasBit(ind->cleanup_flag, CLEAN_TILELSAYOUT) && ind->table != NULL) {
05455 for (int j = 0; j < ind->num_table; j++) {
05456
05457 if (ind->table[j] != NULL) {
05458 free((IndustryTileTable*)ind->table[j]);
05459 }
05460 }
05461
05462 free((IndustryTileTable**)ind->table);
05463 ind->table = NULL;
05464 }
05465
05466 free(ind);
05467 ind = NULL;
05468 }
05469 }
05470
05471 free(file->industryspec);
05472 file->industryspec = NULL;
05473 }
05474
05475 if (file->indtspec != NULL) {
05476 for (i = 0; i < NUM_INDUSTRYTILES; i++) {
05477 if (file->indtspec[i] != NULL) {
05478 free(file->indtspec[i]);
05479 file->indtspec[i] = NULL;
05480 }
05481 }
05482
05483 free(file->indtspec);
05484 file->indtspec = NULL;
05485 }
05486 }
05487 }
05488
05489 static void ResetNewGRF()
05490 {
05491 GRFFile *next;
05492
05493 for (GRFFile *f = _first_grffile; f != NULL; f = next) {
05494 next = f->next;
05495
05496 free(f->filename);
05497 free(f->cargo_list);
05498 free(f->railtype_list);
05499 free(f);
05500 }
05501
05502 _first_grffile = NULL;
05503 _cur_grffile = NULL;
05504 }
05505
05506 static void ResetNewGRFErrors()
05507 {
05508 for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
05509 if (!HasBit(c->flags, GCF_COPY) && c->error != NULL) {
05510 free(c->error->custom_message);
05511 free(c->error->data);
05512 free(c->error);
05513 c->error = NULL;
05514 }
05515 }
05516 }
05517
05522 static void ResetNewGRFData()
05523 {
05524 CleanUpStrings();
05525 CleanUpGRFTownNames();
05526
05527
05528 SetupEngines();
05529
05530
05531 ResetBridges();
05532
05533
05534 ResetRailTypes();
05535
05536
05537 _gted = CallocT<GRFTempEngineData>(GetEnginePoolSize());
05538
05539
05540 memset(&_grm_engines, 0, sizeof(_grm_engines));
05541 memset(&_grm_cargos, 0, sizeof(_grm_cargos));
05542
05543
05544 ResetGenericCallbacks();
05545
05546
05547 ResetPriceBaseMultipliers();
05548
05549
05550 ResetCurrencies();
05551
05552
05553 ResetCustomHouses();
05554 ResetHouses();
05555
05556
05557 ResetCustomIndustries();
05558 ResetIndustries();
05559
05560
05561 ResetStationClasses();
05562 ResetCustomStations();
05563
05564
05565 memset(_water_feature, 0, sizeof(_water_feature));
05566
05567
05568 ClearSnowLine();
05569
05570
05571 ResetNewGRF();
05572
05573
05574 ResetNewGRFErrors();
05575
05576
05577 SetupCargoForClimate(_settings_game.game_creation.landscape);
05578
05579
05580 _misc_grf_features = 0;
05581 _traininfo_vehicle_pitch = 0;
05582 _traininfo_vehicle_width = 29;
05583
05584 _loaded_newgrf_features.has_2CC = false;
05585 _loaded_newgrf_features.has_newhouses = false;
05586 _loaded_newgrf_features.has_newindustries = false;
05587 _loaded_newgrf_features.shore = SHORE_REPLACE_NONE;
05588
05589
05590 _grf_id_overrides.clear();
05591
05592 InitializeSoundPool();
05593 InitializeSpriteGroupPool();
05594 }
05595
05596 static void BuildCargoTranslationMap()
05597 {
05598 memset(_cur_grffile->cargo_map, 0xFF, sizeof(_cur_grffile->cargo_map));
05599
05600 for (CargoID c = 0; c < NUM_CARGO; c++) {
05601 const CargoSpec *cs = GetCargo(c);
05602 if (!cs->IsValid()) continue;
05603
05604 if (_cur_grffile->cargo_max == 0) {
05605
05606 _cur_grffile->cargo_map[c] = cs->bitnum;
05607 } else {
05608
05609 for (uint i = 0; i < _cur_grffile->cargo_max; i++) {
05610 if (cs->label == _cur_grffile->cargo_list[i]) {
05611 _cur_grffile->cargo_map[c] = i;
05612 break;
05613 }
05614 }
05615 }
05616 }
05617 }
05618
05619 static void InitNewGRFFile(const GRFConfig *config, int sprite_offset)
05620 {
05621 GRFFile *newfile = GetFileByFilename(config->filename);
05622 if (newfile != NULL) {
05623
05624 newfile->sprite_offset = sprite_offset;
05625 _cur_grffile = newfile;
05626 return;
05627 }
05628
05629 newfile = CallocT<GRFFile>(1);
05630
05631 if (newfile == NULL) error ("Out of memory");
05632
05633 newfile->filename = strdup(config->filename);
05634 newfile->sprite_offset = sprite_offset;
05635
05636
05637 assert(lengthof(newfile->param) == lengthof(config->param) && lengthof(config->param) == 0x80);
05638 newfile->param_end = config->num_params;
05639 memcpy(newfile->param, config->param, sizeof(newfile->param));
05640
05641 if (_first_grffile == NULL) {
05642 _cur_grffile = newfile;
05643 _first_grffile = newfile;
05644 } else {
05645 _cur_grffile->next = newfile;
05646 _cur_grffile = newfile;
05647 }
05648 }
05649
05650
05653 static const CargoLabel _default_refitmasks_rail[] = {
05654 'PASS', 'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD',
05655 'IORE', 'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE',
05656 'WATR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
05657 'PLST', 'FZDR',
05658 0 };
05659
05660 static const CargoLabel _default_refitmasks_road[] = {
05661 0 };
05662
05663 static const CargoLabel _default_refitmasks_ships[] = {
05664 'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD', 'IORE',
05665 'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE', 'WATR',
05666 'RUBR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
05667 'PLST', 'FZDR',
05668 0 };
05669
05670 static const CargoLabel _default_refitmasks_aircraft[] = {
05671 'PASS', 'MAIL', 'GOOD', 'VALU', 'GOLD', 'DIAM', 'FOOD', 'FRUT', 'SUGR',
05672 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL', 'PLST', 'FZDR',
05673 0 };
05674
05675 static const CargoLabel *_default_refitmasks[] = {
05676 _default_refitmasks_rail,
05677 _default_refitmasks_road,
05678 _default_refitmasks_ships,
05679 _default_refitmasks_aircraft,
05680 };
05681
05682
05686 static void CalculateRefitMasks()
05687 {
05688 Engine *e;
05689
05690 FOR_ALL_ENGINES(e) {
05691 EngineID engine = e->index;
05692 EngineInfo *ei = &e->info;
05693 uint32 mask = 0;
05694 uint32 not_mask = 0;
05695 uint32 xor_mask = 0;
05696
05697 if (ei->refit_mask != 0) {
05698 const GRFFile *file = e->grffile;
05699 if (file != NULL && file->cargo_max != 0) {
05700
05701 uint num_cargo = min(32, file->cargo_max);
05702 for (uint i = 0; i < num_cargo; i++) {
05703 if (!HasBit(ei->refit_mask, i)) continue;
05704
05705 CargoID c = GetCargoIDByLabel(file->cargo_list[i]);
05706 if (c == CT_INVALID) continue;
05707
05708 SetBit(xor_mask, c);
05709 }
05710 } else {
05711
05712 for (CargoID c = 0; c < NUM_CARGO; c++) {
05713 const CargoSpec *cs = GetCargo(c);
05714 if (!cs->IsValid()) continue;
05715
05716 if (HasBit(ei->refit_mask, cs->bitnum)) SetBit(xor_mask, c);
05717 }
05718 }
05719 }
05720
05721 if (_gted[engine].cargo_allowed != 0) {
05722
05723 for (CargoID i = 0; i < NUM_CARGO; i++) {
05724 const CargoSpec *cs = GetCargo(i);
05725 if (_gted[engine].cargo_allowed & cs->classes) SetBit(mask, i);
05726 if (_gted[engine].cargo_disallowed & cs->classes) SetBit(not_mask, i);
05727 }
05728 } else if (xor_mask == 0) {
05729
05730 if (e->type != VEH_TRAIN || (e->u.rail.capacity != 0 && e->u.rail.railveh_type != RAILVEH_WAGON)) {
05731 const CargoLabel *cl = _default_refitmasks[e->type];
05732 for (uint i = 0;; i++) {
05733 if (cl[i] == 0) break;
05734
05735 CargoID cargo = GetCargoIDByLabel(cl[i]);
05736 if (cargo == CT_INVALID) continue;
05737
05738 SetBit(xor_mask, cargo);
05739 }
05740 }
05741 }
05742
05743 ei->refit_mask = ((mask & ~not_mask) ^ xor_mask) & _cargo_mask;
05744
05745
05746
05747 switch (e->type) {
05748 default: NOT_REACHED();
05749 case VEH_AIRCRAFT: break;
05750 case VEH_TRAIN: {
05751 RailVehicleInfo *rvi = &e->u.rail;
05752 if (rvi->cargo_type == CT_INVALID) rvi->cargo_type = FindFirstRefittableCargo(engine);
05753 if (rvi->cargo_type == CT_INVALID) ei->climates = 0x80;
05754 break;
05755 }
05756 case VEH_ROAD: {
05757 RoadVehicleInfo *rvi = &e->u.road;
05758 if (rvi->cargo_type == CT_INVALID) rvi->cargo_type = FindFirstRefittableCargo(engine);
05759 if (rvi->cargo_type == CT_INVALID) ei->climates = 0x80;
05760 break;
05761 }
05762 case VEH_SHIP: {
05763 ShipVehicleInfo *svi = &e->u.ship;
05764 if (svi->cargo_type == CT_INVALID) svi->cargo_type = FindFirstRefittableCargo(engine);
05765 if (svi->cargo_type == CT_INVALID) ei->climates = 0x80;
05766 break;
05767 }
05768 }
05769 }
05770 }
05771
05776 static void FinaliseHouseArray()
05777 {
05778
05779
05780
05781
05782
05783
05784
05785
05786
05787 Year min_year = MAX_YEAR;
05788
05789 for (GRFFile *file = _first_grffile; file != NULL; file = file->next) {
05790 if (file->housespec == NULL) continue;
05791
05792 for (int i = 0; i < HOUSE_MAX; i++) {
05793 HouseSpec *hs = file->housespec[i];
05794 if (hs != NULL) {
05795 _house_mngr.SetEntitySpec(hs);
05796 if (hs->min_year < min_year) min_year = hs->min_year;
05797 }
05798 }
05799 }
05800
05801 if (min_year != 0) {
05802 for (int i = 0; i < HOUSE_MAX; i++) {
05803 HouseSpec *hs = GetHouseSpecs(i);
05804
05805 if (hs->enabled && hs->min_year == min_year) hs->min_year = 0;
05806 }
05807 }
05808 }
05809
05813 static void FinaliseIndustriesArray()
05814 {
05815 for (GRFFile *file = _first_grffile; file != NULL; file = file->next) {
05816 if (file->industryspec != NULL) {
05817 for (int i = 0; i < NUM_INDUSTRYTYPES; i++) {
05818 IndustrySpec *indsp = file->industryspec[i];
05819
05820 if (indsp != NULL && indsp->enabled) {
05821 StringID strid;
05822
05823
05824
05825 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->name);
05826 if (strid != STR_UNDEFINED) indsp->name = strid;
05827
05828 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->closure_text);
05829 if (strid != STR_UNDEFINED) indsp->closure_text = strid;
05830
05831 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_up_text);
05832 if (strid != STR_UNDEFINED) indsp->production_up_text = strid;
05833
05834 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_down_text);
05835 if (strid != STR_UNDEFINED) indsp->production_down_text = strid;
05836
05837 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->new_industry_text);
05838 if (strid != STR_UNDEFINED) indsp->new_industry_text = strid;
05839
05840 if (indsp->station_name != STR_NULL) {
05841
05842
05843 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->station_name);
05844 if (strid != STR_UNDEFINED) indsp->station_name = strid;
05845 }
05846
05847 _industry_mngr.SetEntitySpec(indsp);
05848 _loaded_newgrf_features.has_newindustries = true;
05849 }
05850 }
05851 }
05852
05853 if (file->indtspec != NULL) {
05854 for (int i = 0; i < NUM_INDUSTRYTILES; i++) {
05855 IndustryTileSpec *indtsp = file->indtspec[i];
05856 if (indtsp != NULL) {
05857 _industile_mngr.SetEntitySpec(indtsp);
05858 }
05859 }
05860 }
05861 }
05862
05863 for (uint j = 0; j < NUM_INDUSTRYTYPES; j++) {
05864 IndustrySpec *indsp = &_industry_specs[j];
05865 if (indsp->enabled && indsp->grf_prop.grffile != NULL) {
05866 for (uint i = 0; i < 3; i++) {
05867 indsp->conflicting[i] = MapNewGRFIndustryType(indsp->conflicting[i], indsp->grf_prop.grffile->grfid);
05868 }
05869 }
05870 }
05871 }
05872
05873
05874
05875
05876
05877
05878
05879 static void DecodeSpecialSprite(uint num, GrfLoadingStage stage)
05880 {
05881
05882
05883
05884
05885
05886
05887
05888
05889
05890
05891
05892
05893 static const SpecialSpriteHandler handlers[][GLS_END] = {
05894 { NULL, SafeChangeInfo, NULL, NULL, ReserveChangeInfo, FeatureChangeInfo, },
05895 { SkipAct1, SkipAct1, SkipAct1, SkipAct1, SkipAct1, NewSpriteSet, },
05896 { NULL, NULL, NULL, NULL, NULL, NewSpriteGroup, },
05897 { NULL, GRFUnsafe, NULL, NULL, NULL, FeatureMapSpriteGroup, },
05898 { NULL, NULL, NULL, NULL, NULL, FeatureNewName, },
05899 { SkipAct5, SkipAct5, SkipAct5, SkipAct5, SkipAct5, GraphicsNew, },
05900 { NULL, NULL, NULL, CfgApply, CfgApply, CfgApply, },
05901 { NULL, NULL, NULL, NULL, SkipIf, SkipIf, },
05902 { ScanInfo, NULL, NULL, GRFInfo, GRFInfo, GRFInfo, },
05903 { NULL, NULL, NULL, SkipIf, SkipIf, SkipIf, },
05904 { SkipActA, SkipActA, SkipActA, SkipActA, SkipActA, SpriteReplace, },
05905 { NULL, NULL, NULL, GRFLoadError, GRFLoadError, GRFLoadError, },
05906 { NULL, NULL, NULL, GRFComment, NULL, GRFComment, },
05907 { NULL, SafeParamSet, NULL, ParamSet, ParamSet, ParamSet, },
05908 { NULL, SafeGRFInhibit, NULL, GRFInhibit, GRFInhibit, GRFInhibit, },
05909 { NULL, GRFUnsafe, NULL, FeatureTownName, NULL, NULL, },
05910 { NULL, NULL, DefineGotoLabel, NULL, NULL, NULL, },
05911 { SkipAct11,GRFUnsafe, SkipAct11, SkipAct11, SkipAct11, GRFSound, },
05912 { SkipAct12, SkipAct12, SkipAct12, SkipAct12, SkipAct12, LoadFontGlyph, },
05913 { NULL, NULL, NULL, NULL, NULL, TranslateGRFStrings, },
05914 };
05915
05916 bool preloaded_sprite = true;
05917 GRFLocation location(_cur_grfconfig->grfid, _nfo_line);
05918 byte *buf;
05919
05920 GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
05921 if (it == _grf_line_to_action6_sprite_override.end()) {
05922
05923
05924 buf = MallocT<byte>(num);
05925 FioReadBlock(buf, num);
05926 preloaded_sprite = false;
05927 } else {
05928
05929 buf = _grf_line_to_action6_sprite_override[location];
05930 grfmsg(7, "DecodeSpecialSprite: Using preloaded pseudo sprite data");
05931
05932
05933 FioSeekTo(num, SEEK_CUR);
05934 }
05935
05936 byte action = buf[0];
05937
05938 if (action == 0xFF) {
05939 grfmsg(7, "DecodeSpecialSprite: Handling data block in stage %d", stage);
05940 GRFDataBlock(buf, num);
05941 } else if (action == 0xFE) {
05942 grfmsg(7, "DecodeSpecialSprite: Handling import block in stage %d", stage);
05943 GRFImportBlock(buf, num);
05944 } else if (action >= lengthof(handlers)) {
05945 grfmsg(7, "DecodeSpecialSprite: Skipping unknown action 0x%02X", action);
05946 } else if (handlers[action][stage] == NULL) {
05947 grfmsg(7, "DecodeSpecialSprite: Skipping action 0x%02X in stage %d", action, stage);
05948 } else {
05949 grfmsg(7, "DecodeSpecialSprite: Handling action 0x%02X in stage %d", action, stage);
05950 handlers[action][stage](buf, num);
05951 }
05952 if (!preloaded_sprite) free(buf);
05953 }
05954
05955
05956 void LoadNewGRFFile(GRFConfig *config, uint file_index, GrfLoadingStage stage)
05957 {
05958 const char *filename = config->filename;
05959 uint16 num;
05960
05961
05962
05963
05964
05965
05966
05967
05968
05969
05970 if (stage != GLS_FILESCAN && stage != GLS_SAFETYSCAN && stage != GLS_LABELSCAN) {
05971 _cur_grffile = GetFileByFilename(filename);
05972 if (_cur_grffile == NULL) usererror("File '%s' lost in cache.\n", filename);
05973 if (stage == GLS_RESERVE && config->status != GCS_INITIALISED) return;
05974 if (stage == GLS_ACTIVATION && !HasBit(config->flags, GCF_RESERVED)) return;
05975 _cur_grffile->is_ottdfile = config->IsOpenTTDBaseGRF();
05976 }
05977
05978 if (file_index > LAST_GRF_SLOT) {
05979 DEBUG(grf, 0, "'%s' is not loaded as the maximum number of GRFs has been reached", filename);
05980 config->status = GCS_DISABLED;
05981 config->error = CallocT<GRFError>(1);
05982 config->error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
05983 config->error->message = STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED;
05984 return;
05985 }
05986
05987 FioOpenFile(file_index, filename);
05988 _file_index = file_index;
05989 _palette_remap_grf[_file_index] = (config->windows_paletted != (_use_palette == PAL_WINDOWS));
05990
05991 _cur_grfconfig = config;
05992
05993 DEBUG(grf, 2, "LoadNewGRFFile: Reading NewGRF-file '%s'", filename);
05994
05995
05996
05997
05998 if (FioReadWord() == 4 && FioReadByte() == 0xFF) {
05999 FioReadDword();
06000 } else {
06001 DEBUG(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
06002 return;
06003 }
06004
06005 _skip_sprites = 0;
06006 _nfo_line = 0;
06007
06008 while ((num = FioReadWord()) != 0) {
06009 byte type = FioReadByte();
06010 _nfo_line++;
06011
06012 if (type == 0xFF) {
06013 if (_skip_sprites == 0) {
06014 DecodeSpecialSprite(num, stage);
06015
06016
06017 if (_skip_sprites == -1) break;
06018
06019 continue;
06020 } else {
06021 FioSkipBytes(num);
06022 }
06023 } else {
06024 if (_skip_sprites == 0) {
06025 grfmsg(0, "LoadNewGRFFile: Unexpected sprite, disabling");
06026 config->status = GCS_DISABLED;
06027 config->error = CallocT<GRFError>(1);
06028 config->error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
06029 config->error->message = STR_NEWGRF_ERROR_UNEXPECTED_SPRITE;
06030 break;
06031 }
06032
06033 FioSkipBytes(7);
06034 SkipSpriteData(type, num - 8);
06035 }
06036
06037 if (_skip_sprites > 0) _skip_sprites--;
06038 }
06039 }
06040
06048 static void ActivateOldShore()
06049 {
06050
06051
06052 if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
06053
06054 if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) {
06055 DupSprite(SPR_ORIGINALSHORE_START + 1, SPR_SHORE_BASE + 1);
06056 DupSprite(SPR_ORIGINALSHORE_START + 2, SPR_SHORE_BASE + 2);
06057 DupSprite(SPR_ORIGINALSHORE_START + 6, SPR_SHORE_BASE + 3);
06058 DupSprite(SPR_ORIGINALSHORE_START , SPR_SHORE_BASE + 4);
06059 DupSprite(SPR_ORIGINALSHORE_START + 4, SPR_SHORE_BASE + 6);
06060 DupSprite(SPR_ORIGINALSHORE_START + 3, SPR_SHORE_BASE + 8);
06061 DupSprite(SPR_ORIGINALSHORE_START + 7, SPR_SHORE_BASE + 9);
06062 DupSprite(SPR_ORIGINALSHORE_START + 5, SPR_SHORE_BASE + 12);
06063 }
06064
06065 if (_loaded_newgrf_features.shore == SHORE_REPLACE_ACTION_A) {
06066 DupSprite(SPR_FLAT_GRASS_TILE + 16, SPR_SHORE_BASE + 0);
06067 DupSprite(SPR_FLAT_GRASS_TILE + 17, SPR_SHORE_BASE + 5);
06068 DupSprite(SPR_FLAT_GRASS_TILE + 7, SPR_SHORE_BASE + 7);
06069 DupSprite(SPR_FLAT_GRASS_TILE + 15, SPR_SHORE_BASE + 10);
06070 DupSprite(SPR_FLAT_GRASS_TILE + 11, SPR_SHORE_BASE + 11);
06071 DupSprite(SPR_FLAT_GRASS_TILE + 13, SPR_SHORE_BASE + 13);
06072 DupSprite(SPR_FLAT_GRASS_TILE + 14, SPR_SHORE_BASE + 14);
06073 DupSprite(SPR_FLAT_GRASS_TILE + 18, SPR_SHORE_BASE + 15);
06074
06075
06076
06077 DupSprite(SPR_FLAT_GRASS_TILE + 5, SPR_SHORE_BASE + 16);
06078 DupSprite(SPR_FLAT_GRASS_TILE + 10, SPR_SHORE_BASE + 17);
06079 }
06080 }
06081
06082 void InitDepotWindowBlockSizes();
06083
06084 extern void InitGRFTownGeneratorNames();
06085
06086 static void AfterLoadGRFs()
06087 {
06088 for (StringIDToGRFIDMapping::iterator it = _string_to_grf_mapping.begin(); it != _string_to_grf_mapping.end(); it++) {
06089 *((*it).first) = MapGRFStringID((*it).second, *((*it).first));
06090 }
06091 _string_to_grf_mapping.clear();
06092
06093
06094 for (GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.begin(); it != _grf_line_to_action6_sprite_override.end(); it++) {
06095 free((*it).second);
06096 }
06097 _grf_line_to_action6_sprite_override.clear();
06098
06099
06100 CalculateRefitMasks();
06101
06102
06103 InitDepotWindowBlockSizes();
06104
06105
06106 FinaliseHouseArray();
06107
06108
06109 FinaliseIndustriesArray();
06110
06111
06112 BuildIndustriesLegend();
06113
06114
06115 InitGRFTownGeneratorNames();
06116
06117
06118 CommitVehicleListOrderChanges();
06119
06120
06121 ActivateOldShore();
06122
06123 Engine *e;
06124 FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {
06125 if (_gted[e->index].rv_max_speed != 0) {
06126
06127 e->u.road.max_speed = _gted[e->index].rv_max_speed * 4;
06128 }
06129 }
06130
06131 SetYearEngineAgingStops();
06132
06133
06134 free(_gted);
06135 _grm_sprites.clear();
06136 }
06137
06138 void LoadNewGRF(uint load_index, uint file_index)
06139 {
06140
06141
06142
06143
06144 Date date = _date;
06145 Year year = _cur_year;
06146 DateFract date_fract = _date_fract;
06147 uint16 tick_counter = _tick_counter;
06148 byte display_opt = _display_opt;
06149
06150 if (_networking) {
06151 _cur_year = _settings_game.game_creation.starting_year;
06152 _date = ConvertYMDToDate(_cur_year, 0, 1);
06153 _date_fract = 0;
06154 _tick_counter = 0;
06155 _display_opt = 0;
06156 }
06157
06158 InitializeGRFSpecial();
06159
06160 ResetNewGRFData();
06161
06162
06163
06164
06165
06166
06167
06168
06169 for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
06170 if (c->status != GCS_NOT_FOUND) c->status = GCS_UNKNOWN;
06171 }
06172
06173 _cur_spriteid = load_index;
06174
06175
06176
06177
06178 for (GrfLoadingStage stage = GLS_LABELSCAN; stage <= GLS_ACTIVATION; stage++) {
06179
06180
06181 for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
06182 if (c->status == GCS_ACTIVATED) c->status = GCS_INITIALISED;
06183 }
06184
06185 uint slot = file_index;
06186
06187 _cur_stage = stage;
06188 for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
06189 if (c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND) continue;
06190 if (stage > GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) continue;
06191
06192
06193 if (!FioCheckFileExists(c->filename)) usererror("NewGRF file is missing '%s'", c->filename);
06194
06195 if (stage == GLS_LABELSCAN) InitNewGRFFile(c, _cur_spriteid);
06196 LoadNewGRFFile(c, slot++, stage);
06197 if (stage == GLS_RESERVE) {
06198 SetBit(c->flags, GCF_RESERVED);
06199 } else if (stage == GLS_ACTIVATION) {
06200 ClrBit(c->flags, GCF_RESERVED);
06201 assert(GetFileByGRFID(c->grfid) == _cur_grffile);
06202 ClearTemporaryNewGRFData(_cur_grffile);
06203 BuildCargoTranslationMap();
06204 DEBUG(sprite, 2, "LoadNewGRF: Currently %i sprites are loaded", _cur_spriteid);
06205 } else if (stage == GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) {
06206
06207 ClearTemporaryNewGRFData(_cur_grffile);
06208 }
06209 }
06210 }
06211
06212
06213 AfterLoadGRFs();
06214
06215
06216 _cur_year = year;
06217 _date = date;
06218 _date_fract = date_fract;
06219 _tick_counter = tick_counter;
06220 _display_opt = display_opt;
06221 }
06222
06223 bool HasGrfMiscBit(GrfMiscBit bit)
06224 {
06225 return HasBit(_misc_grf_features, bit);
06226 }