openttd-ottdgrfs: comparison src/newgrf.cpp

equal deleted inserted replaced

-:0b2aebc8283e
+:0b8b245a2391
 #include "newgrf_sound.h"
 #include "newgrf_spritegroup.h"
 #include "helpers.hpp"
 #include "table/town_land.h"
 #include "cargotype.h"
+#include "industry.h"
+#include "newgrf_canal.h"
+#include "newgrf_commons.h"
 /* TTDPatch extended GRF format codec
 * (c) Petr Baudis 2004 (GPL'd)
 * Changes by Florian octo Forster are (c) by the OpenTTD development team.
 *
 		case 0x05: // Track type
 			FOR_EACH_OBJECT {
 				uint8 tracktype = grf_load_byte(&buf);
 				switch (tracktype) {
-					case 0: rvi[i].railtype = rvi[i].engclass == 2 ? RAILTYPE_ELECTRIC : RAILTYPE_RAIL; break;
+					case 0: rvi[i].railtype = rvi[i].engclass >= 2 ? RAILTYPE_ELECTRIC : RAILTYPE_RAIL; break;
 					case 1: rvi[i].railtype = RAILTYPE_MONO; break;
 					case 2: rvi[i].railtype = RAILTYPE_MAGLEV; break;
 					default:
 						grfmsg(1, "RailVehicleChangeInfo: Invalid track type %d specified, ignoring", tracktype);
 						break;
 			 * 0x32 .. 0x37: Monorail
 			 * 0x38 .. 0x41: Maglev
 			 */
 			FOR_EACH_OBJECT {
 				uint8 traction = grf_load_byte(&buf);
-				int engclass;
+				EngineClass engclass;
 				if (traction <= 0x07) {
-					engclass = 0;
+					engclass = EC_STEAM;
 				} else if (traction <= 0x27) {
-					engclass = 1;
+					engclass = EC_DIESEL;
 				} else if (traction <= 0x31) {
-					engclass = 2;
+					engclass = EC_ELECTRIC;
+				} else if (traction <= 0x37) {
+					engclass = EC_MONORAIL;
 				} else if (traction <= 0x41) {
-					engclass = 2;
+					engclass = EC_MAGLEV;
 				} else {
 					break;
 				}
-				if (rvi[i].railtype == RAILTYPE_RAIL     && engclass == 2) rvi[i].railtype = RAILTYPE_ELECTRIC;
+				if (rvi[i].railtype == RAILTYPE_RAIL     && engclass >= EC_ELECTRIC) rvi[i].railtype = RAILTYPE_ELECTRIC;
-				if (rvi[i].railtype == RAILTYPE_ELECTRIC && engclass != 2) rvi[i].railtype = RAILTYPE_RAIL;
+				if (rvi[i].railtype == RAILTYPE_ELECTRIC && engclass  < EC_ELECTRIC) rvi[i].railtype = RAILTYPE_RAIL;
 				rvi[i].engclass = engclass;
 			}
 			break;
 		case 0x25: // User-defined bit mask to set when checking veh. var. 42
 			FOR_EACH_OBJECT rvi[i].user_def_data = grf_load_byte(&buf);
 			break;
+		case 0x26: // Retire vehicle early
+			FOR_EACH_OBJECT ei[i].retire_early = grf_load_byte(&buf);
+			break;
 		case 0x27: // Miscellaneous flags
 			FOR_EACH_OBJECT {
 				ei[i].misc_flags = grf_load_byte(&buf);
 				if (HASBIT(ei[i].misc_flags, EF_USES_2CC)) _have_2cc = true;
 			}
 			break;
 		/* @todo air drag and retire vehicle early
 		 * Fall-through for unimplemented one byte long properties. */
 		case 0x20: // Air drag
-		case 0x26: // Retire vehicle early
 			FOR_EACH_OBJECT grf_load_byte(&buf);
 			ret = true;
 			break;
 		default:
 		case 0x1A: // Refit cost
 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);
 			break;
+		case 0x1B: // Retire vehicle early
+			FOR_EACH_OBJECT ei[i].retire_early = grf_load_byte(&buf);
+			break;
 		case 0x1C: // Miscellaneous flags
 			FOR_EACH_OBJECT {
 				ei[i].misc_flags = grf_load_byte(&buf);
 				if (HASBIT(ei[i].misc_flags, EF_USES_2CC)) _have_2cc = true;
 			}
 			FOR_EACH_OBJECT ei[i].base_intro = grf_load_dword(&buf);
 			break;
 		case 0x18: // Tractive effort
 		case 0x19: // Air drag
-		case 0x1B: // Retire vehicle early
 			/* @todo */
 			FOR_EACH_OBJECT grf_load_byte(&buf);
 			ret = true;
 			break;
 		case 0x13: // Refit cost
 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);
 			break;
+		case 0x16: // Retire vehicle early
+			FOR_EACH_OBJECT ei[i].retire_early = grf_load_byte(&buf);
+			break;
 		case 0x17: // Miscellaneous flags
 			FOR_EACH_OBJECT {
 				ei[i].misc_flags = grf_load_byte(&buf);
 				if (HASBIT(ei[i].misc_flags, EF_USES_2CC)) _have_2cc = true;
 			}
 			FOR_EACH_OBJECT ei[i].base_intro = grf_load_dword(&buf);
 			break;
 		case 0x14: // Ocean speed fraction
 		case 0x15: // Canal speed fraction
-		case 0x16: // Retire vehicle early
 			/* @todo */
 			FOR_EACH_OBJECT grf_load_byte(&buf);
 			ret = true;
 			break;
 		case 0x15: // Refit cost
 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);
 			break;
+		case 0x16: // Retire vehicle early
+			FOR_EACH_OBJECT ei[i].retire_early = grf_load_byte(&buf);
+			break;
 		case 0x17: // Miscellaneous flags
 			FOR_EACH_OBJECT {
 				ei[i].misc_flags = grf_load_byte(&buf);
 				if (HASBIT(ei[i].misc_flags, EF_USES_2CC)) _have_2cc = true;
 			}
 			FOR_EACH_OBJECT cargo_disallowed[AIRCRAFT_ENGINES_INDEX + engine + i] = grf_load_word(&buf);
 			break;
 		case 0x1A: // Long format introduction date (days since year 0)
 			FOR_EACH_OBJECT ei[i].base_intro = grf_load_dword(&buf);
-			break;
-		case 0x16: // Retire vehicle early
-			/* @todo */
-			FOR_EACH_OBJECT grf_load_byte(&buf);
-			ret = true;
 			break;
 		default:
 			ret = true;
 			break;
 	/* Allocate house specs if they haven't been allocated already. */
 	if (_cur_grffile->housespec == NULL) {
 		_cur_grffile->housespec = CallocT<HouseSpec*>(HOUSE_MAX);
 		/* Reset any overrides that have been set. */
-		ResetHouseOverrides();
+		_house_mngr.ResetOverride();
 	}
 	housespec = &_cur_grffile->housespec[hid];
 	if (prop != 0x08) {
 				if (override >= NEW_HOUSE_OFFSET) {
 					grfmsg(2, "TownHouseChangeInfo: Attempt to override new house %u with house id %u. Ignoring.", override, hid);
 					return false;
 				}
-				AddHouseOverride(hid, override);
+				_house_mngr.Add(hid, override);
 			}
 			break;
 		case 0x16: // Periodic refresh multiplier
 			FOR_EACH_OBJECT housespec[i]->processing_time = grf_load_byte(&buf);
 					} else {
 						housespec[i]->accepts_cargo[j] = cargo;
 					}
 				}
 			}
+			break;
+		case 0x1F: // Minimum life span
+			FOR_EACH_OBJECT housespec[i]->minimum_life = grf_load_byte(&buf);
 			break;
 		default:
 			ret = true;
 			break;
 		/* GSF_SOUNDFX */      SoundEffectChangeInfo,
 	};
 	EngineInfo *ei = NULL;
-	if (len == 1) {
-		grfmsg(8, "Silently ignoring one-byte special sprite 0x00");
-		return;
-	}
 	if (!check_length(len, 6, "FeatureChangeInfo")) return;
 	buf++;
 	uint8 feature  = grf_load_byte(&buf);
 	uint8 numprops = grf_load_byte(&buf);
 	uint numinfo  = grf_load_byte(&buf);
 }
 /* Action 0x00 (GLS_SAFETYSCAN) */
 static void SafeChangeInfo(byte *buf, int len)
 {
-	if (len == 1) {
-		grfmsg(8, "Silently ignoring one-byte special sprite 0x00");
-		return;
-	}
 	if (!check_length(len, 6, "SafeChangeInfo")) return;
 	buf++;
 	uint8 feature  = grf_load_byte(&buf);
 	uint8 numprops = grf_load_byte(&buf);
 	grf_load_byte(&buf);
 /* Action 0x00 (GLS_INIT) */
 static void InitChangeInfo(byte *buf, int len)
 {
 	byte *bufend = buf + len;
-	if (len == 1) {
-		grfmsg(8, "Silently ignoring one-byte special sprite 0x00");
-		return;
-	}
 	if (!check_length(len, 6, "InitChangeInfo")) return;
 	buf++;
 	uint8 feature  = grf_load_byte(&buf);
 	uint8 numprops = grf_load_byte(&buf);
 /* Action 0x00 (GLS_RESERVE) */
 static void ReserveChangeInfo(byte *buf, int len)
 {
 	byte *bufend = buf + len;
-	if (len == 1) {
-		grfmsg(8, "Silently ignoring one-byte special sprite 0x00");
-		return;
-	}
 	if (!check_length(len, 6, "InitChangeInfo")) return;
 	buf++;
 	uint8 feature  = grf_load_byte(&buf);
 	for (uint16 i = 0; i < num_sets * num_ents; i++) {
 		LoadNextSprite(_cur_spriteid++, _file_index);
 		_nfo_line++;
 	}
+}
+/* Action 0x01 (SKIP) */
+static void SkipAct1(byte *buf, int len)
+{
+	if (!check_length(len, 4, "SkipAct1")) return;
+	buf++;
+	grf_load_byte(&buf);
+	uint8 num_sets  = grf_load_byte(&buf);
+	uint16 num_ents = grf_load_extended(&buf);
+	_skip_sprites = num_sets * num_ents;
+	grfmsg(3, "SkipAct1: Skipping %d sprites", _skip_sprites);
 }
 /* Helper function to either create a callback or link to a previously
 * defined spritegroup. */
 static const SpriteGroup* GetGroupFromGroupID(byte setid, byte type, uint16 groupid)
 				/* Continue reading var adjusts while bit 5 is set. */
 			} while (HASBIT(varadjust, 5));
 			group->g.determ.num_ranges = grf_load_byte(&buf);
-			group->g.determ.ranges = CallocT<DeterministicSpriteGroupRange>(group->g.determ.num_ranges);
+			if (group->g.determ.num_ranges > 0) group->g.determ.ranges = CallocT<DeterministicSpriteGroupRange>(group->g.determ.num_ranges);
 			if (!check_length(bufend - buf, 2 + (2 + 2 * varsize) * group->g.determ.num_ranges, "NewSpriteGroup (Deterministic)")) return;
 			for (uint i = 0; i < group->g.determ.num_ranges; i++) {
 				group->g.determ.ranges[i].group = GetGroupFromGroupID(setid, type, grf_load_word(&buf));
 				case GSF_TRAIN:
 				case GSF_ROAD:
 				case GSF_SHIP:
 				case GSF_AIRCRAFT:
 				case GSF_STATION:
+				case GSF_CANAL:
 				case GSF_CARGOS:
 				{
 					byte sprites     = _cur_grffile->spriteset_numents;
 					byte num_loaded  = type;
 					byte num_loading = grf_load_byte(&buf);
 		}
 	}
 }
+static void CanalMapSpriteGroup(byte *buf, uint8 idcount, uint8 cidcount)
+{
+	byte *bp = &buf[4 + idcount + cidcount * 3];
+	uint16 groupid = grf_load_word(&bp);
+	if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
+		grfmsg(1, "CanalMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping.",
+		       groupid, _cur_grffile->spritegroups_count);
+		return;
+	}
+	for (uint i = 0; i < idcount; i++) {
+		CanalFeature cf = (CanalFeature)buf[3 + i];
+		if (cf >= CF_END) {
+			grfmsg(1, "CanalMapSpriteGroup: Canal subset %d out of range, skipping", cf);
+			continue;
+		}
+		_canal_sg[cf] = _cur_grffile->spritegroups[groupid];
+	}
+}
 static void StationMapSpriteGroup(byte *buf, uint8 idcount, uint8 cidcount)
 {
 	for (uint i = 0; i < idcount; i++) {
 		uint8 stid = buf[3 + i];
 		StationSpec *statspec = _cur_grffile->stations[stid];
 		case GSF_TRAIN:
 		case GSF_ROAD:
 		case GSF_SHIP:
 		case GSF_AIRCRAFT:
 			VehicleMapSpriteGroup(buf, feature, idcount, cidcount, wagover);
+			return;
+		case GSF_CANAL:
+			CanalMapSpriteGroup(buf, idcount, cidcount);
 			return;
 		case GSF_STATION:
 			StationMapSpriteGroup(buf, idcount, cidcount);
 			return;
 		const char *name   = grf_load_string(&buf, len);
 		size_t name_length = strlen(name) + 1;
 		len -= (int)name_length;
-		if (name_length == 1) {
+		grfmsg(8, "FeatureNewName: 0x%04X <- %s", id, name);
-			grfmsg(7, "FeatureNewName: Can't add empty name");
-		} else if (name_length > 127) {
+		switch (feature) {
-			grfmsg(7, "FeatureNewName: Too long a name (%d)", name_length);
+			case GSF_TRAIN:
-		} else {
+			case GSF_ROAD:
-			grfmsg(8, "FeatureNewName: %d <- %s", id, name);
+			case GSF_SHIP:
+			case GSF_AIRCRAFT:
-			switch (feature) {
+				if (id < TOTAL_NUM_ENGINES) {
-				case GSF_TRAIN:
+					StringID string = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_8000_KIRBY_PAUL_TANK_STEAM + id);
-				case GSF_ROAD:
+					SetCustomEngineName(id, string);
-				case GSF_SHIP:
+				} else {
-				case GSF_AIRCRAFT: {
+					AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, id);
-					if (id < TOTAL_NUM_ENGINES) {
+				}
-						StringID string = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_8000_KIRBY_PAUL_TANK_STEAM + id);
+				break;
-						SetCustomEngineName(id, string);
-					} else {
+			case GSF_TOWNHOUSE:
-						AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, id);
+			default:
-					}
+				switch (GB(id, 8, 8)) {
-					break;
+					case 0xC4: // Station class name
-				}
+						if (_cur_grffile->stations == NULL || _cur_grffile->stations[GB(id, 0, 8)] == NULL) {
+							grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
-				case GSF_TOWNHOUSE:
+						} else {
-				default:
+							StationClassID sclass = _cur_grffile->stations[GB(id, 0, 8)]->sclass;
-					switch (GB(id, 8, 8)) {
+							SetStationClassName(sclass, AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED));
-						case 0xC4: // Station class name
-							if (_cur_grffile->stations == NULL || _cur_grffile->stations[GB(id, 0, 8)] == NULL) {
-								grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
-							} else {
-								StationClassID sclass = _cur_grffile->stations[GB(id, 0, 8)]->sclass;
-								SetStationClassName(sclass, AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED));
-							}
-							break;
-						case 0xC5: // Station name
-							if (_cur_grffile->stations == NULL || _cur_grffile->stations[GB(id, 0, 8)] == NULL) {
-								grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
-							} else {
-								_cur_grffile->stations[GB(id, 0, 8)]->name = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
-							}
-							break;
-						case 0xC9: { // House name
-							if (_cur_grffile->housespec == NULL || _cur_grffile->housespec[GB(id, 0, 8)] == NULL) {
-								grfmsg(1, "FeatureNewName: Attempt to name undefined house 0x%X, ignoring.", GB(id, 0, 8));
-							} else {
-								_cur_grffile->housespec[GB(id, 0, 8)]->building_name = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
-							}
-							break;
 						}
+						break;
-						case 0xD0:
-						case 0xDC:
+					case 0xC5: // Station name
-							AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
+						if (_cur_grffile->stations == NULL || _cur_grffile->stations[GB(id, 0, 8)] == NULL) {
-							break;
+							grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
+						} else {
-						default:
+							_cur_grffile->stations[GB(id, 0, 8)]->name = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
-							grfmsg(7, "FeatureNewName: Unsupported ID (0x%04X)", id);
+						}
-							break;
+						break;
-					}
-					break;
+					case 0xC9: // House name
+						if (_cur_grffile->housespec == NULL || _cur_grffile->housespec[GB(id, 0, 8)] == NULL) {
+							grfmsg(1, "FeatureNewName: Attempt to name undefined house 0x%X, ignoring.", GB(id, 0, 8));
+						} else {
+							_cur_grffile->housespec[GB(id, 0, 8)]->building_name = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
+						}
+						break;
+					case 0xD0:
+					case 0xDC:
+						AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
+						break;
+					default:
+						grfmsg(7, "FeatureNewName: Unsupported ID (0x%04X)", id);
+						break;
+				}
+				break;
 #if 0
 				case GSF_CANAL :
 				case GSF_BRIDGE :
 					AddGRFString(_cur_spriteid, id, lang, name);
 					break;
 				default :
 					grfmsg(7, "FeatureNewName: Unsupported feature (0x%02X)", feature);
 					break;
 #endif
-			}
 		}
 	}
 }
 /* Action 0x05 */
 	for (; num > 0; num--) {
 		LoadNextSprite(replace == 0 ? _cur_spriteid++ : replace++, _file_index);
 		_nfo_line++;
 	}
+}
+/* Action 0x05 (SKIP) */
+static void SkipAct5(byte *buf, int len)
+{
+	if (!check_length(len, 2, "SkipAct5")) return;
+	buf++;
+	/* Ignore type byte */
+	grf_load_byte(&buf);
+	/* Skip the sprites of this action */
+	_skip_sprites = grf_load_extended(&buf);
+	grfmsg(3, "SkipAct5: Skipping %d sprites", _skip_sprites);
 }
 static uint32 GetParamVal(byte param, uint32 *cond_val)
 {
 	switch (param) {
 		case 0x8B: { // TTDPatch version
 			uint major    = 2;
 			uint minor    = 6;
 			uint revision = 0; // special case: 2.0.1 is 2.0.10
-			uint build    = 1168;
+			uint build    = 1210;
 			return (major << 24) | (minor << 20) | (revision << 16) | build;
 		}
 		case 0x8D: // TTD Version, 00=DOS, 01=Windows
 			return !_use_dos_palette;
 			break;
 		}
 		grfmsg(8, "CfgApply: Applying %u bytes from parameter 0x%02X at offset 0x%04X", param_size, param_num, offset);
+		bool carry = false;
 		for (i = 0; i < param_size; i++) {
 			uint32 value = GetParamVal(param_num + i / 4, NULL);
+			/* Reset carry flag for each iteration of the variable (only really
+			 * matters if param_size is greater than 4) */
+			if (i == 0) carry = false;
 			if (add_value) {
-				_preload_sprite[offset + i] += GB(value, (i % 4) * 8, 8);
+				uint new_value = _preload_sprite[offset + i] + GB(value, (i % 4) * 8, 8) + (carry ? 1 : 0);
+				_preload_sprite[offset + i] = GB(new_value, 0, 8);
+				/* Check if the addition overflowed */
+				carry = new_value >= 256;
 			} else {
 				_preload_sprite[offset + i] = GB(value, (i % 4) * 8, 8);
 			}
 		}
 	}
 				break;
 			case 4: result = (param_val & mask) < cond_val;
 				break;
 			case 5: result = (param_val & mask) > cond_val;
 				break;
+			case 11: result = GetCargoIDByLabel(BSWAP32(cond_val)) == CT_INVALID;
+				break;
+			case 12: result = GetCargoIDByLabel(BSWAP32(cond_val)) != CT_INVALID;
+				break;
 			default: grfmsg(1, "SkipIf: Unsupported test %d. Ignoring", condtype); return;
 		}
 	}
 		for (uint j = 0; j < num_sprites; j++) {
 			LoadNextSprite(first_sprite + j, _file_index); // XXX
 			_nfo_line++;
 		}
 	}
+}
+/* Action 0x0A (SKIP) */
+static void SkipActA(byte *buf, int len)
+{
+	buf++;
+	uint8 num_sets = grf_load_byte(&buf);
+	for (uint i = 0; i < num_sets; i++) {
+		/* Skip the sprites this replaces */
+		_skip_sprites += grf_load_byte(&buf);
+		/* But ignore where they go */
+		grf_load_word(&buf);
+	}
+	grfmsg(3, "SkipActA: Skipping %d sprites", _skip_sprites);
 }
 /* Action 0x0B */
 static void GRFLoadError(byte *buf, int len)
 {
 	SETBIT(_cur_grfconfig->flags, GCF_UNSAFE);
 	/* Skip remainder of GRF */
 	_skip_sprites = -1;
 }
+static uint32 GetPatchVariable(uint8 param)
+{
+	switch (param) {
+		/* start year - 1920 */
+		case 0x0B: return max(_patches.starting_year, ORIGINAL_BASE_YEAR) - ORIGINAL_BASE_YEAR;
+		/* freight trains weight factor */
+		case 0x0E: return _patches.freight_trains;
+		/* empty wagon speed increase */
+		case 0x0F: return 0;
+		/* plane speed factor */
+		case 0x10: return 4;
+		/* 2CC colormap base sprite */
+		case 0x11: return SPR_2CCMAP_BASE;
+		default:
+			grfmsg(2, "ParamSet: Unknown Patch variable 0x%02X.", param);
+			return 0;
+	}
+}
 /* Action 0x0D */
 static void ParamSet(byte *buf, int len)
 {
 	/* <0D> <target> <operation> <source1> <source2> [<data>]
 	if (src2 == 0xFE) {
 		if (GB(data, 0, 8) == 0xFF) {
 			if (data == 0x0000FFFF) {
 				/* Patch variables */
-				grfmsg(2, "ParamSet: Reading Patch variables unsupported");
+				src1 = GetPatchVariable(src1);
-				return;
 			} else {
 				/* GRF Resource Management */
 				if (_cur_stage != GLS_ACTIVATION) {
 					/* Ignore GRM during initialization */
 					src1 = 0;
 			break;
 		case 0x9E: // Miscellaneous GRF features
 			_misc_grf_features = res;
 			/* Set train list engine width */
-			_traininfo_vehicle_width = HASBIT(res, 3) ? 32 : 29;
+			_traininfo_vehicle_width = HasGrfMiscBit(GMB_TRAIN_WIDTH_32_PIXELS) ? 32 : 29;
 			break;
 		default:
 			if (target < 0x80) {
 				_cur_grffile->param[target] = res;
 	                   |                                        (0 << 0x03)  // pathbasedsignalling. To enable if ever pbs is back
 	                   |                                        (0 << 0x04)  // aichoosechance
 	                   |                                        (1 << 0x05)  // resolutionwidth
 	                   |                                        (1 << 0x06)  // resolutionheight
 	                   |                                        (0 << 0x07)  // newindustries
-	                   |                                        (0 << 0x08)  // fifoloading
+	                   |         ((_patches.improved_load ? 1 : 0) << 0x08)  // fifoloading
 	                   |                                        (0 << 0x09)  // townroadbranchprob
 	                   |                                        (0 << 0x0A)  // tempsnowline
 	                   |                                        (1 << 0x0B)  // newcargo
 	                   |                                        (1 << 0x0C)  // enhancemultiplayer
 	                   |                                        (1 << 0x0D)  // onewayroads
 	/* Reset station classes */
 	ResetStationClasses();
 	ResetCustomStations();
+	/* Reset canal sprite groups */
+	memset(_canal_sg, 0, sizeof(_canal_sg));
 	/* Reset the snowline table. */
 	ClearSnowLine();
 	/* Reset NewGRF files */
 	ResetNewGRF();
 		_engine_info[engine].refit_mask = ((mask & ~not_mask) ^ xor_mask) & _cargo_mask;
 		/* Check if this engine's cargo type is valid. If not, set to the first refittable
 		 * cargo type. Apparently cargo_type isn't a common property... */
 		switch (GetEngine(engine)->type) {
+			default: NOT_REACHED();
+			case VEH_AIRCRAFT: break;
 			case VEH_TRAIN: {
 				RailVehicleInfo *rvi = &_rail_vehicle_info[engine];
 				if (rvi->cargo_type == CT_INVALID) rvi->cargo_type = FindFirstRefittableCargo(engine);
 				if (rvi->cargo_type == CT_INVALID) _engine_info[engine].climates = 0;
 				break;
 		if (file->housespec == NULL) continue;
 		for (int i = 0; i < HOUSE_MAX; i++) {
 			HouseSpec *hs = file->housespec[i];
 			if (hs != NULL) {
-				SetHouseSpec(hs);
+				_house_mngr.SetEntitySpec(hs);
 				if (hs->min_date < 1930) reset_dates = false;
 			}
 		}
 	}
 	/* We need a pre-stage to set up GOTO labels of Action 0x10 because the grf
 	 * is not in memory and scanning the file every time would be too expensive.
 	 * In other stages we skip action 0x10 since it's already dealt with. */
 	static const SpecialSpriteHandler handlers[][GLS_END] = {
 		/* 0x00 */ { NULL,     SafeChangeInfo, NULL,       InitChangeInfo, ReserveChangeInfo, FeatureChangeInfo, },
-		/* 0x01 */ { NULL,     GRFUnsafe, NULL,            NULL,           NULL,              NewSpriteSet, },
+		/* 0x01 */ { SkipAct1, SkipAct1,  SkipAct1,        SkipAct1,       SkipAct1,          NewSpriteSet, },
-		/* 0x02 */ { NULL,     GRFUnsafe, NULL,            NULL,           NULL,              NewSpriteGroup, },
+		/* 0x02 */ { NULL,     NULL,      NULL,            NULL,           NULL,              NewSpriteGroup, },
 		/* 0x03 */ { NULL,     GRFUnsafe, NULL,            NULL,           NULL,              FeatureMapSpriteGroup, },
 		/* 0x04 */ { NULL,     NULL,      NULL,            NULL,           NULL,              FeatureNewName, },
-		/* 0x05 */ { NULL,     NULL,      NULL,            NULL,           NULL,              GraphicsNew, },
+		/* 0x05 */ { SkipAct5, SkipAct5,  SkipAct5,        SkipAct5,       SkipAct5,          GraphicsNew, },
 		/* 0x06 */ { NULL,     NULL,      NULL,            CfgApply,       CfgApply,          CfgApply, },
 		/* 0x07 */ { NULL,     NULL,      NULL,            NULL,           SkipIf,            SkipIf, },
 		/* 0x08 */ { ScanInfo, NULL,      NULL,            GRFInfo,        NULL,              GRFInfo, },
 		/* 0x09 */ { NULL,     NULL,      NULL,            SkipIf,         SkipIf,            SkipIf, },
-		/* 0x0A */ { NULL,     NULL,      NULL,            NULL,           NULL,              SpriteReplace, },
+		/* 0x0A */ { SkipActA, SkipActA,  SkipActA,        SkipActA,       SkipActA,          SpriteReplace, },
 		/* 0x0B */ { NULL,     NULL,      NULL,            GRFLoadError,   GRFLoadError,      GRFLoadError, },
 		/* 0x0C */ { NULL,     NULL,      NULL,            GRFComment,     NULL,              GRFComment, },
 		/* 0x0D */ { NULL,     SafeParamSet, NULL,         ParamSet,       ParamSet,          ParamSet, },
 		/* 0x0E */ { NULL,     SafeGRFInhibit, NULL,       GRFInhibit,     GRFInhibit,        GRFInhibit, },
 		/* 0x0F */ { NULL,     NULL,      NULL,            NULL,           NULL,              NULL, },
 	InitDepotWindowBlockSizes();
 	/* Add all new houses to the house array. */
 	FinaliseHouseArray();
+	/* Create dynamic list of industry legends for smallmap_gui.cpp */
+	BuildIndustriesLegend();
 	/* Map cargo strings. This is a separate step because cargos are
 	 * loaded before strings... */
 	MapNewCargoStrings();
 }
 	}
 	/* Call any functions that should be run after GRFs have been loaded. */
 	AfterLoadGRFs();
 }
+bool HasGrfMiscBit(GrfMiscBit bit)
+{
+	return HASBIT(_misc_grf_features, bit);
+}

branch	gamebalance
changeset 9911	0b8b245a2391
parent 9910	0b2aebc8283e
child 9912	1ac8aac92385