openttd-ottdgrfs: comparison src/newgrf.cpp

equal deleted inserted replaced

-:bd80897189ba
+:84c215fc8eb8
 /* $Id$ */
+/** @file newgrf.cpp */
 #include "stdafx.h"
 #include <stdarg.h>
 #include "newgrf.h"
 #include "variables.h"
 #include "string.h"
 #include "table/strings.h"
 #include "bridge.h"
+#include "town.h"
 #include "economy.h"
 #include "newgrf_engine.h"
 #include "vehicle.h"
 #include "newgrf_text.h"
 #include "table/sprites.h"
 #include "fontcache.h"
 #include "date.h"
 #include "currency.h"
+#include "landscape.h"
 #include "sound.h"
 #include "newgrf_config.h"
+#include "newgrf_house.h"
 #include "newgrf_sound.h"
 #include "newgrf_spritegroup.h"
 #include "helpers.hpp"
+#include "table/town_land.h"
 #include "cargotype.h"
 /* TTDPatch extended GRF format codec
 * (c) Petr Baudis 2004 (GPL'd)
 * Changes by Florian octo Forster are (c) by the OpenTTD development team.
 static byte *_preload_sprite = NULL;
 /* Set if any vehicle is loaded which uses 2cc (two company colours) */
 bool _have_2cc = false;
-/* Default cargo translation table. By default there are 27 possible cargo types */
+/* Set if there are any newhouses loaded. */
-static const uint _default_cargo_max = 27;
+bool _have_newhouses = false;
-static CargoLabel _default_cargo_list[_default_cargo_max];
 enum GrfDataType {
 	GDT_SOUND,
 };
 	}
 	return file;
 }
+/** Used when setting an object's property to map to the GRF's strings
+* while taking in consideration the "drift" between TTDPatch string system and OpenTTD's one
+* @param str StringID that we want to have the equivalent in OoenTTD
+* @return the properly adjusted StringID
+*/
+static StringID MapGRFStringID(uint32 grfid, StringID str)
+{
+	/* 0xD0 and 0xDC stand for all the TextIDs in the range
+	 * of 0xD000 (misc graphics texts) and 0xDC00 (misc persistent texts).
+	 * These strings are unique to each grf file, and thus require to be used with the
+	 * grfid in which they are declared */
+	if (GB(str, 8, 8) == 0xD0 || GB(str, 8, 8) == 0xDC) {
+		return GetGRFStringID(grfid, str);
+	}
+	/* We have some changes in our cargo strings, resulting in some missing. */
+	if (str >= 0x006E && str <= 0x008D) return str - 0x20;
+	if (str >= 0x008E && str <= 0x00AD) return str - 0x20;
+	/* Map building names according to our lang file changes
+	 * 0x200F = Tall Office Block, first house name in the original data, the one that TTDPatch stil uses
+	 * 0x201F = Old houses is the last house name.
+	 * OpenTTD does not have exactly the same order aymore, so, the code below allows
+	 * to compensate for the difference */
+	if (str >= 0x200F && str <= 0x201F) return str + (STR_200F_TALL_OFFICE_BLOCK - 0x200F);
+	return str;
+}
+static uint8 MapDOSColour(uint8 colour)
+{
+	if (_use_dos_palette) return colour;
+	if (colour < 10) {
+		static uint8 dos_to_win_colour_map[] = { 0, 215, 216, 136, 88, 106, 32, 33, 40, 245 };
+		return dos_to_win_colour_map[colour];
+	}
+	if (colour >= 245 && colour < 254) return colour - 28;
+	return colour;
+}
 typedef bool (*VCI_Handler)(uint engine, int numinfo, int prop, byte **buf, int len);
 #define FOR_EACH_OBJECT for (i = 0; i < numinfo; i++)
 static void dewagonize(int condition, int engine)
 	byte *buf = *bufp;
 	int i;
 	bool ret = false;
 	switch (prop) {
-		case 0x05: /* Track type */
+		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;
 						break;
 				}
 			}
 			break;
-		case 0x08: /* AI passenger service */
+		case 0x08: // AI passenger service
-			/* TODO */
+			/* @todo missing feature */
 			FOR_EACH_OBJECT grf_load_byte(&buf);
 			ret = true;
 			break;
-		case 0x09: /* Speed (1 unit is 1 kmh) */
+		case 0x09: // Speed (1 unit is 1 kmh)
 			FOR_EACH_OBJECT {
 				uint16 speed = grf_load_word(&buf);
 				if (speed == 0xFFFF) speed = 0;
 				rvi[i].max_speed = speed;
 			}
 			break;
-		case 0x0B: /* Power */
+		case 0x0B: // Power
 			FOR_EACH_OBJECT {
 				uint16 power = grf_load_word(&buf);
 				if (rvi[i].railveh_type == RAILVEH_MULTIHEAD) power /= 2;
 				rvi[i].power = power;
 				dewagonize(power, engine + i);
 			}
 			break;
-		case 0x0D: /* Running cost factor */
+		case 0x0D: // Running cost factor
 			FOR_EACH_OBJECT {
 				uint8 runcostfact = grf_load_byte(&buf);
 				if (rvi[i].railveh_type == RAILVEH_MULTIHEAD) runcostfact /= 2;
 				rvi[i].running_cost_base = runcostfact;
 			}
 			break;
-		case 0x0E: /* Running cost base */
+		case 0x0E: // Running cost base
 			FOR_EACH_OBJECT {
 				uint32 base = grf_load_dword(&buf);
 				switch (base) {
 					case 0x4C30: rvi[i].running_cost_class = 0; break;
 					case 0x4C36: rvi[i].running_cost_class = 1; break;
 					case 0x4C3C: rvi[i].running_cost_class = 2; break;
-					case 0: break; /* Used by wagons */
+					case 0: break; // Used by wagons
 					default:
 						grfmsg(1, "RailVehicleChangeInfo: Unsupported running cost base 0x%04X, ignoring", base);
 						break;
 				}
 			}
 			break;
-		case 0x12: /* Sprite ID */
+		case 0x12: // Sprite ID
 			FOR_EACH_OBJECT {
 				uint8 spriteid = grf_load_byte(&buf);
 				/* TTD sprite IDs point to a location in a 16bit array, but we use it
 				 * as an array index, so we need it to be half the original value. */
 				rvi[i].image_index = spriteid;
 			}
 			break;
-		case 0x13: /* Dual-headed */
+		case 0x13: // Dual-headed
 			FOR_EACH_OBJECT {
 				uint8 dual = grf_load_byte(&buf);
 				if (dual != 0) {
 					if (rvi[i].railveh_type != RAILVEH_MULTIHEAD) {
 						RAILVEH_WAGON : RAILVEH_SINGLEHEAD;
 				}
 			}
 			break;
-		case 0x14: /* Cargo capacity */
+		case 0x14: // Cargo capacity
 			FOR_EACH_OBJECT rvi[i].capacity = grf_load_byte(&buf);
 			break;
-		case 0x15: /* Cargo type */
+		case 0x15: // Cargo type
 			FOR_EACH_OBJECT {
 				uint8 ctype = grf_load_byte(&buf);
 				if (ctype < NUM_CARGO && HASBIT(_cargo_mask, ctype)) {
 					rvi[i].cargo_type = ctype;
 					grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, using first refittable", ctype);
 				}
 			}
 			break;
-		case 0x16: /* Weight */
+		case 0x16: // Weight
 			FOR_EACH_OBJECT SB(rvi[i].weight, 0, 8, grf_load_byte(&buf));
 			break;
-		case 0x17: /* Cost factor */
+		case 0x17: // Cost factor
 			FOR_EACH_OBJECT rvi[i].base_cost = grf_load_byte(&buf);
 			break;
-		case 0x18: /* AI rank */
+		case 0x18: // AI rank
 			FOR_EACH_OBJECT rvi[i].ai_rank = grf_load_byte(&buf);
 			break;
-		case 0x19: /* Engine traction type */
+		case 0x19: // Engine traction type
 			/* What do the individual numbers mean?
 			 * 0x00 .. 0x07: Steam
 			 * 0x08 .. 0x27: Diesel
 			 * 0x28 .. 0x31: Electric
 			 * 0x32 .. 0x37: Monorail
 				rvi[i].engclass = engclass;
 			}
 			break;
-		case 0x1A: /* Alter purchase list sort order */
+		case 0x1A: // Alter purchase list sort order
 			FOR_EACH_OBJECT {
 				EngineID pos = grf_load_byte(&buf);
 				if (pos < NUM_TRAIN_ENGINES) {
 					AlterRailVehListOrder(engine + i, pos);
 					grfmsg(2, "RailVehicleChangeInfo: Invalid train engine ID %d, ignoring", pos);
 				}
 			}
 			break;
-		case 0x1B: /* Powered wagons power bonus */
+		case 0x1B: // Powered wagons power bonus
 			FOR_EACH_OBJECT rvi[i].pow_wag_power = grf_load_word(&buf);
 			break;
-		case 0x1C: /* Refit cost */
+		case 0x1C: // Refit cost
 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);
 			break;
-		case 0x1D: /* Refit cargo */
+		case 0x1D: // Refit cargo
 			FOR_EACH_OBJECT ei[i].refit_mask = grf_load_dword(&buf);
 			break;
-		case 0x1E: /* Callback */
+		case 0x1E: // Callback
 			FOR_EACH_OBJECT ei[i].callbackmask = grf_load_byte(&buf);
 			break;
-		case 0x1F: /* Tractive effort coefficient */
+		case 0x1F: // Tractive effort coefficient
 			FOR_EACH_OBJECT rvi[i].tractive_effort = grf_load_byte(&buf);
 			break;
-		case 0x21: /* Shorter vehicle */
+		case 0x21: // Shorter vehicle
 			FOR_EACH_OBJECT rvi[i].shorten_factor = grf_load_byte(&buf);
 			break;
-		case 0x22: /* Visual effect */
+		case 0x22: // Visual effect
-			// see note in engine.h about rvi->visual_effect
+			/* see note in engine.h about rvi->visual_effect */
 			FOR_EACH_OBJECT rvi[i].visual_effect = grf_load_byte(&buf);
 			break;
-		case 0x23: /* Powered wagons weight bonus */
+		case 0x23: // Powered wagons weight bonus
 			FOR_EACH_OBJECT rvi[i].pow_wag_weight = grf_load_byte(&buf);
 			break;
-		case 0x24: /* High byte of vehicle weight */
+		case 0x24: // High byte of vehicle weight
 			FOR_EACH_OBJECT {
 				byte weight = grf_load_byte(&buf);
 				if (weight > 4) {
 					grfmsg(2, "RailVehicleChangeInfo: Nonsensical weight of %d tons, ignoring", weight << 8);
 					SB(rvi[i].weight, 8, 8, weight);
 				}
 			}
 			break;
-		case 0x25: /* User-defined bit mask to set when checking veh. var. 42 */
+		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 0x27: /* Miscellaneous flags */
+		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;
-		case 0x28: /* Cargo classes allowed */
+		case 0x28: // Cargo classes allowed
 			FOR_EACH_OBJECT cargo_allowed[engine + i] = grf_load_word(&buf);
 			break;
-		case 0x29: /* Cargo classes disallowed */
+		case 0x29: // Cargo classes disallowed
 			FOR_EACH_OBJECT cargo_disallowed[engine + i] = grf_load_word(&buf);
 			break;
-		case 0x2A: /* Long format introduction date (days since year 0) */
+		case 0x2A: // Long format introduction date (days since year 0)
 			FOR_EACH_OBJECT ei[i].base_intro = grf_load_dword(&buf);
 			break;
-		/* TODO */
+		/* @todo air drag and retire vehicle early
-		/* Fall-through for unimplemented one byte long properties. */
+		 * Fall-through for unimplemented one byte long properties. */
-		case 0x20: /* Air drag */
+		case 0x20: // Air drag
-		case 0x26: /* Retire vehicle early */
+		case 0x26: // Retire vehicle early
-			/* TODO */
 			FOR_EACH_OBJECT grf_load_byte(&buf);
 			ret = true;
 			break;
 		default:
 	byte *buf = *bufp;
 	int i;
 	bool ret = false;
 	switch (prop) {
-		case 0x08: /* Speed (1 unit is 0.5 kmh) */
+		case 0x08: // Speed (1 unit is 0.5 kmh)
 			FOR_EACH_OBJECT rvi[i].max_speed = grf_load_byte(&buf);
 			break;
-		case 0x09: /* Running cost factor */
+		case 0x09: // Running cost factor
 			FOR_EACH_OBJECT rvi[i].running_cost = grf_load_byte(&buf);
 			break;
-		case 0x0A: /* Running cost base */
+		case 0x0A: // Running cost base
-			/* TODO: I have no idea. --pasky */
+			/* @todo : I have no idea. --pasky
+			 * I THINK it is used for overriding the base cost of all road vehicle (_price.roadveh_base) --belugas */
 			FOR_EACH_OBJECT grf_load_dword(&buf);
 			ret = true;
 			break;
-		case 0x0E: /* Sprite ID */
+		case 0x0E: // Sprite ID
 			FOR_EACH_OBJECT {
 				uint8 spriteid = grf_load_byte(&buf);
-				// cars have different custom id in the GRF file
+				/* cars have different custom id in the GRF file */
 				if (spriteid == 0xFF) spriteid = 0xFD;
 				if (spriteid < 0xFD) spriteid >>= 1;
 				rvi[i].image_index = spriteid;
 			}
 			break;
-		case 0x0F: /* Cargo capacity */
+		case 0x0F: // Cargo capacity
 			FOR_EACH_OBJECT rvi[i].capacity = grf_load_byte(&buf);
 			break;
-		case 0x10: /* Cargo type */
+		case 0x10: // Cargo type
 			FOR_EACH_OBJECT {
 				uint8 cargo = grf_load_byte(&buf);
 				if (cargo < NUM_CARGO && HASBIT(_cargo_mask, cargo)) {
 					rvi[i].cargo_type = cargo;
 					grfmsg(2, "RoadVehicleChangeInfo: Invalid cargo type %d, using first refittable", cargo);
 				}
 			}
 			break;
-		case 0x11: /* Cost factor */
+		case 0x11: // Cost factor
 			FOR_EACH_OBJECT rvi[i].base_cost = grf_load_byte(&buf); // ?? is it base_cost?
 			break;
-		case 0x12: /* SFX */
+		case 0x12: // SFX
 			FOR_EACH_OBJECT rvi[i].sfx = (SoundFx)grf_load_byte(&buf);
 			break;
-		case 0x13: /* Power in 10hp */
+		case 0x13: // Power in 10hp
-		case 0x14: /* Weight in 1/4 tons */
+		case 0x14: // Weight in 1/4 tons
-		case 0x15: /* Speed in mph*0.8 */
+		case 0x15: // Speed in mph*0.8
 			/* TODO: Support for road vehicles realistic power
 			 * computations (called rvpower in TTDPatch) is just
 			 * missing in OTTD yet. --pasky */
 			FOR_EACH_OBJECT grf_load_byte(&buf);
 			ret = true;
 			break;
-		case 0x16: /* Cargos available for refitting */
+		case 0x16: // Cargos available for refitting
 			FOR_EACH_OBJECT ei[i].refit_mask = grf_load_dword(&buf);
 			break;
-		case 0x17: /* Callback mask */
+		case 0x17: // Callback mask
 			FOR_EACH_OBJECT ei[i].callbackmask = grf_load_byte(&buf);
 			break;
-		case 0x1A: /* Refit cost */
+		case 0x1A: // Refit cost
 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);
 			break;
-		case 0x1C: /* Miscellaneous flags */
+		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;
 			}
 			break;
-		case 0x1D: /* Cargo classes allowed */
+		case 0x1D: // Cargo classes allowed
 			FOR_EACH_OBJECT cargo_allowed[ROAD_ENGINES_INDEX + engine + i] = grf_load_word(&buf);
 			break;
-		case 0x1E: /* Cargo classes disallowed */
+		case 0x1E: // Cargo classes disallowed
 			FOR_EACH_OBJECT cargo_disallowed[ROAD_ENGINES_INDEX + engine + i] = grf_load_word(&buf);
 			break;
-		case 0x1F: /* Long format introduction date (days since year 0) */
+		case 0x1F: // Long format introduction date (days since year 0)
 			FOR_EACH_OBJECT ei[i].base_intro = grf_load_dword(&buf);
 			break;
-		case 0x18: /* Tractive effort */
+		case 0x18: // Tractive effort
-		case 0x19: /* Air drag */
+		case 0x19: // Air drag
-		case 0x1B: /* Retire vehicle early */
+		case 0x1B: // Retire vehicle early
-			/* TODO */
+			/* @todo */
 			FOR_EACH_OBJECT grf_load_byte(&buf);
 			ret = true;
 			break;
 		default:
 	int i;
 	bool ret = false;
 	//printf("e %x prop %x?\n", engine, prop);
 	switch (prop) {
-		case 0x08: /* Sprite ID */
+		case 0x08: // Sprite ID
 			FOR_EACH_OBJECT {
 				uint8 spriteid = grf_load_byte(&buf);
-				// ships have different custom id in the GRF file
+				/* ships have different custom id in the GRF file */
 				if (spriteid == 0xFF) spriteid = 0xFD;
 				if (spriteid < 0xFD) spriteid >>= 1;
 				svi[i].image_index = spriteid;
 			}
 			break;
-		case 0x09: /* Refittable */
+		case 0x09: // Refittable
 			FOR_EACH_OBJECT svi[i].refittable = (grf_load_byte(&buf) != 0);
 			break;
-		case 0x0A: /* Cost factor */
+		case 0x0A: // Cost factor
 			FOR_EACH_OBJECT svi[i].base_cost = grf_load_byte(&buf); // ?? is it base_cost?
 			break;
-		case 0x0B: /* Speed (1 unit is 0.5 kmh) */
+		case 0x0B: // Speed (1 unit is 0.5 kmh)
 			FOR_EACH_OBJECT svi[i].max_speed = grf_load_byte(&buf);
 			break;
-		case 0x0C: /* Cargo type */
+		case 0x0C: // Cargo type
 			FOR_EACH_OBJECT {
 				uint8 cargo = grf_load_byte(&buf);
 				if (cargo < NUM_CARGO && HASBIT(_cargo_mask, cargo)) {
 					svi[i].cargo_type = cargo;
 					grfmsg(2, "ShipVehicleChangeInfo: Invalid cargo type %d, using first refittable", cargo);
 				}
 			}
 			break;
-		case 0x0D: /* Cargo capacity */
+		case 0x0D: // Cargo capacity
 			FOR_EACH_OBJECT svi[i].capacity = grf_load_word(&buf);
 			break;
-		case 0x0F: /* Running cost factor */
+		case 0x0F: // Running cost factor
 			FOR_EACH_OBJECT svi[i].running_cost = grf_load_byte(&buf);
 			break;
-		case 0x10: /* SFX */
+		case 0x10: // SFX
 			FOR_EACH_OBJECT svi[i].sfx = (SoundFx)grf_load_byte(&buf);
 			break;
-		case 0x11: /* Cargos available for refitting */
+		case 0x11: // Cargos available for refitting
 			FOR_EACH_OBJECT ei[i].refit_mask = grf_load_dword(&buf);
 			break;
-		case 0x12: /* Callback mask */
+		case 0x12: // Callback mask
 			FOR_EACH_OBJECT ei[i].callbackmask = grf_load_byte(&buf);
 			break;
-		case 0x13: /* Refit cost */
+		case 0x13: // Refit cost
 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);
 			break;
-		case 0x17: /* Miscellaneous flags */
+		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;
 			}
 			break;
-		case 0x18: /* Cargo classes allowed */
+		case 0x18: // Cargo classes allowed
 			FOR_EACH_OBJECT cargo_allowed[SHIP_ENGINES_INDEX + engine + i] = grf_load_word(&buf);
 			break;
-		case 0x19: /* Cargo classes disallowed */
+		case 0x19: // Cargo classes disallowed
 			FOR_EACH_OBJECT cargo_disallowed[SHIP_ENGINES_INDEX + engine + i] = grf_load_word(&buf);
 			break;
-		case 0x1A: /* Long format introduction date (days since year 0) */
+		case 0x1A: // Long format introduction date (days since year 0)
 			FOR_EACH_OBJECT ei[i].base_intro = grf_load_dword(&buf);
 			break;
-		case 0x14: /* Ocean speed fraction */
+		case 0x14: // Ocean speed fraction
-		case 0x15: /* Canal speed fraction */
+		case 0x15: // Canal speed fraction
-		case 0x16: /* Retire vehicle early */
+		case 0x16: // Retire vehicle early
-			/* TODO */
+			/* @todo */
 			FOR_EACH_OBJECT grf_load_byte(&buf);
 			ret = true;
 			break;
 		default:
 	int i;
 	bool ret = false;
 	//printf("e %x prop %x?\n", engine, prop);
 	switch (prop) {
-		case 0x08: /* Sprite ID */
+		case 0x08: // Sprite ID
 			FOR_EACH_OBJECT {
 				uint8 spriteid = grf_load_byte(&buf);
-				// aircraft have different custom id in the GRF file
+				/* aircraft have different custom id in the GRF file */
 				if (spriteid == 0xFF) spriteid = 0xFD;
 				if (spriteid < 0xFD) spriteid >>= 1;
 				avi[i].image_index = spriteid;
 			}
 			break;
-		case 0x09: /* Helicopter */
+		case 0x09: // Helicopter
 			FOR_EACH_OBJECT {
 				if (grf_load_byte(&buf) == 0) {
 					avi[i].subtype = AIR_HELI;
 				} else {
 					SB(avi[i].subtype, 0, 1, 1); // AIR_CTOL
 				}
 			}
 			break;
-		case 0x0A: /* Large */
+		case 0x0A: // Large
 			FOR_EACH_OBJECT SB(avi[i].subtype, 1, 1, (grf_load_byte(&buf) != 0 ? 1 : 0)); // AIR_FAST
 			break;
-		case 0x0B: /* Cost factor */
+		case 0x0B: // Cost factor
 			FOR_EACH_OBJECT avi[i].base_cost = grf_load_byte(&buf); // ?? is it base_cost?
 			break;
-		case 0x0C: /* Speed (1 unit is 8 mph, we translate to 1 unit is 1 km/h) */
+		case 0x0C: // Speed (1 unit is 8 mph, we translate to 1 unit is 1 km/h)
 			FOR_EACH_OBJECT avi[i].max_speed = (grf_load_byte(&buf) * 129) / 10;
 			break;
-		case 0x0D: /* Acceleration */
+		case 0x0D: // Acceleration
 			FOR_EACH_OBJECT avi[i].acceleration = (grf_load_byte(&buf) * 129) / 10;
 			break;
-		case 0x0E: /* Running cost factor */
+		case 0x0E: // Running cost factor
 			FOR_EACH_OBJECT avi[i].running_cost = grf_load_byte(&buf);
 			break;
-		case 0x0F: /* Passenger capacity */
+		case 0x0F: // Passenger capacity
 			FOR_EACH_OBJECT avi[i].passenger_capacity = grf_load_word(&buf);
 			break;
-		case 0x11: /* Mail capacity */
+		case 0x11: // Mail capacity
 			FOR_EACH_OBJECT avi[i].mail_capacity = grf_load_byte(&buf);
 			break;
-		case 0x12: /* SFX */
+		case 0x12: // SFX
 			FOR_EACH_OBJECT avi[i].sfx = (SoundFx)grf_load_byte(&buf);
 			break;
-		case 0x13: /* Cargos available for refitting */
+		case 0x13: // Cargos available for refitting
 			FOR_EACH_OBJECT ei[i].refit_mask = grf_load_dword(&buf);
 			break;
-		case 0x14: /* Callback mask */
+		case 0x14: // Callback mask
 			FOR_EACH_OBJECT ei[i].callbackmask = grf_load_byte(&buf);
 			break;
-		case 0x15: /* Refit cost */
+		case 0x15: // Refit cost
 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);
 			break;
-		case 0x17: /* Miscellaneous flags */
+		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;
 			}
 			break;
-		case 0x18: /* Cargo classes allowed */
+		case 0x18: // Cargo classes allowed
 			FOR_EACH_OBJECT cargo_allowed[AIRCRAFT_ENGINES_INDEX + engine + i] = grf_load_word(&buf);
 			break;
-		case 0x19: /* Cargo classes disallowed */
+		case 0x19: // Cargo classes disallowed
 			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) */
+		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 */
+		case 0x16: // Retire vehicle early
-			/* TODO */
+			/* @todo */
 			FOR_EACH_OBJECT grf_load_byte(&buf);
 			ret = true;
 			break;
 		default:
 			}
 		}
 	}
 	switch (prop) {
-		case 0x08: /* Class ID */
+		case 0x08: // Class ID
 			FOR_EACH_OBJECT {
 				/* Property 0x08 is special; it is where the station is allocated */
 				if (statspec[i] == NULL) statspec[i] = CallocT<StationSpec>(1);
 				/* Swap classid because we read it in BE meaning WAYP or DFLT */
 				uint32 classid = grf_load_dword(&buf);
 				statspec[i]->sclass = AllocateStationClass(BSWAP32(classid));
 			}
 			break;
-		case 0x09: /* Define sprite layout */
+		case 0x09: // Define sprite layout
 			FOR_EACH_OBJECT {
 				StationSpec *statspec = _cur_grffile->stations[stid + i];
 				statspec->tiles = grf_load_extended(&buf);
 				statspec->renderdata = CallocT<DrawTileSprites>(statspec->tiles);
 					}
 					while (buf < *bufp + len) {
 						DrawTileSeqStruct *dtss;
-						// no relative bounding box support
+						/* no relative bounding box support */
 						dts->seq = ReallocT((DrawTileSeqStruct*)dts->seq, ++seq_count);
 						dtss = (DrawTileSeqStruct*) &dts->seq[seq_count - 1];
 						dtss->delta_x = grf_load_byte(&buf);
 						if ((byte) dtss->delta_x == 0x80) break;
 					}
 				}
 			}
 			break;
-		case 0x0A: /* Copy sprite layout */
+		case 0x0A: // Copy sprite layout
 			FOR_EACH_OBJECT {
 				StationSpec *statspec = _cur_grffile->stations[stid + i];
 				byte srcid = grf_load_byte(&buf);
 				const StationSpec *srcstatspec = _cur_grffile->stations[srcid];
 				statspec->renderdata = srcstatspec->renderdata;
 				statspec->copied_renderdata = true;
 			}
 			break;
-		case 0x0B: /* Callback mask */
+		case 0x0B: // Callback mask
 			FOR_EACH_OBJECT statspec[i]->callbackmask = grf_load_byte(&buf);
 			break;
-		case 0x0C: /* Disallowed number of platforms */
+		case 0x0C: // Disallowed number of platforms
 			FOR_EACH_OBJECT statspec[i]->disallowed_platforms = grf_load_byte(&buf);
 			break;
-		case 0x0D: /* Disallowed platform lengths */
+		case 0x0D: // Disallowed platform lengths
 			FOR_EACH_OBJECT statspec[i]->disallowed_lengths = grf_load_byte(&buf);
 			break;
-		case 0x0E: /* Define custom layout */
+		case 0x0E: // Define custom layout
 			FOR_EACH_OBJECT {
 				StationSpec *statspec = _cur_grffile->stations[stid + i];
 				statspec->copied_layouts = false;
 					l = length - 1; // index is zero-based
 					//debug("p %d > %d ?", number, stat->platforms[l]);
 					if (number > statspec->platforms[l]) {
 						statspec->layouts[l] = ReallocT(statspec->layouts[l], number);
-						// We expect NULL being 0 here, but C99 guarantees that.
+						/* We expect NULL being 0 here, but C99 guarantees that. */
 						memset(statspec->layouts[l] + statspec->platforms[l], 0,
 						       (number - statspec->platforms[l]) * sizeof(**statspec->layouts));
 						statspec->platforms[l] = number;
 					}
 					statspec->layouts[l][p] = layout;
 				}
 			}
 			break;
-		case 0x0F: /* Copy custom layout */
+		case 0x0F: // Copy custom layout
 			FOR_EACH_OBJECT {
 				StationSpec *statspec = _cur_grffile->stations[stid + i];
 				byte srcid = grf_load_byte(&buf);
 				const StationSpec *srcstatspec = _cur_grffile->stations[srcid];
 				statspec->layouts   = srcstatspec->layouts;
 				statspec->copied_layouts = true;
 			}
 			break;
-		case 0x10: /* Little/lots cargo threshold */
+		case 0x10: // Little/lots cargo threshold
 			FOR_EACH_OBJECT statspec[i]->cargo_threshold = grf_load_word(&buf);
 			break;
-		case 0x11: /* Pylon placement */
+		case 0x11: // Pylon placement
 			FOR_EACH_OBJECT statspec[i]->pylons = grf_load_byte(&buf);
 			break;
-		case 0x12: /* Cargo types for random triggers */
+		case 0x12: // Cargo types for random triggers
 			FOR_EACH_OBJECT statspec[i]->cargo_triggers = grf_load_dword(&buf);
 			break;
-		case 0x13: /* General flags */
+		case 0x13: // General flags
 			FOR_EACH_OBJECT statspec[i]->flags = grf_load_byte(&buf);
 			break;
-		case 0x14: /* Overhead wire placement */
+		case 0x14: // Overhead wire placement
 			FOR_EACH_OBJECT statspec[i]->wires = grf_load_byte(&buf);
 			break;
-		case 0x15: /* Blocked tiles */
+		case 0x15: // Blocked tiles
 			FOR_EACH_OBJECT statspec[i]->blocked = grf_load_byte(&buf);
 			break;
-		case 0x16: /* TODO Animation info */
+		case 0x16: // @todo Animation info
 			FOR_EACH_OBJECT grf_load_word(&buf);
 			ret = true;
 			break;
-		case 0x17: /* TODO Animation speed */
+		case 0x17: // @todo Animation speed
 			FOR_EACH_OBJECT grf_load_byte(&buf);
 			ret = true;
 			break;
-		case 0x18: /* TODO Animation triggers */
+		case 0x18: // @todo Animation triggers
 			FOR_EACH_OBJECT grf_load_word(&buf);
 			ret = true;
 			break;
 		default:
 	byte *buf = *bufp;
 	int i;
 	bool ret = false;
 	switch (prop) {
-		case 0x08: /* Year of availability */
+		case 0x08: // Year of availability
 			FOR_EACH_OBJECT _bridge[brid + i].avail_year = ORIGINAL_BASE_YEAR + grf_load_byte(&buf);
 			break;
-		case 0x09: /* Minimum length */
+		case 0x09: // Minimum length
 			FOR_EACH_OBJECT _bridge[brid + i].min_length = grf_load_byte(&buf);
 			break;
-		case 0x0A: /* Maximum length */
+		case 0x0A: // Maximum length
 			FOR_EACH_OBJECT _bridge[brid + i].max_length = grf_load_byte(&buf);
 			break;
-		case 0x0B: /* Cost factor */
+		case 0x0B: // Cost factor
 			FOR_EACH_OBJECT _bridge[brid + i].price = grf_load_byte(&buf);
 			break;
-		case 0x0C: /* Maximum speed */
+		case 0x0C: // Maximum speed
 			FOR_EACH_OBJECT _bridge[brid + i].speed = grf_load_word(&buf);
 			break;
-		case 0x0D: /* Bridge sprite tables */
+		case 0x0D: // Bridge sprite tables
 			FOR_EACH_OBJECT {
 				Bridge *bridge = &_bridge[brid + i];
 				byte tableid = grf_load_byte(&buf);
 				byte numtables = grf_load_byte(&buf);
 					}
 				}
 			}
 			break;
-		case 0x0E: /* Flags; bit 0 - disable far pillars */
+		case 0x0E: // Flags; bit 0 - disable far pillars
 			FOR_EACH_OBJECT _bridge[brid + i].flags = grf_load_byte(&buf);
 			break;
-		case 0x0F: /* Long format year of availability (year since year 0) */
+		case 0x0F: // Long format year of availability (year since year 0)
 			FOR_EACH_OBJECT _bridge[brid + i].avail_year = clamp(grf_load_dword(&buf), MIN_YEAR, MAX_YEAR);
 			break;
 		default:
 			ret = true;
+	}
+	*bufp = buf;
+	return ret;
+}
+static bool TownHouseChangeInfo(uint hid, int numinfo, int prop, byte **bufp, int len)
+{
+	HouseSpec **housespec;
+	byte *buf = *bufp;
+	int i;
+	bool ret = false;
+	if (hid + numinfo >= HOUSE_MAX) {
+		grfmsg(1, "TownHouseChangeInfo: Too many houses loaded (%u), max (%u). Ignoring.", hid + numinfo, HOUSE_MAX-1);
+		return false;
+	}
+	/* 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();
+	}
+	housespec = &_cur_grffile->housespec[hid];
+	if (prop != 0x08) {
+		/* Check that all the houses being modified have been defined. */
+		FOR_EACH_OBJECT {
+			if (housespec[i] == NULL) {
+				grfmsg(2, "TownHouseChangeInfo: Attempt to modify undefined house %u. Ignoring.", hid + i);
+				return false;
+			}
+		}
+	}
+	switch (prop) {
+		case 0x08: // Substitute building type, and definition of a new house
+			FOR_EACH_OBJECT {
+				byte subs_id = grf_load_byte(&buf);
+				if (subs_id == 0xFF) {
+					/* Instead of defining a new house, a substitute house id
+					 * of 0xFF disables the old house with the current id. */
+					_house_specs[hid + i].enabled = false;
+					continue;
+				} else if (subs_id >= NEW_HOUSE_OFFSET) {
+					/* The substitute id must be one of the original houses. */
+					grfmsg(2, "TownHouseChangeInfo: Attempt to use new house %u as substitute house for %u. Ignoring.", subs_id, hid + i);
+					return false;
+				}
+				/* Allocate space for this house. */
+				if (housespec[i] == NULL) housespec[i] = CallocT<HouseSpec>(1);
+				memcpy(housespec[i], &_house_specs[subs_id], sizeof(_house_specs[subs_id]));
+				housespec[i]->enabled = true;
+				housespec[i]->local_id = hid + i;
+				housespec[i]->substitute_id = subs_id;
+				housespec[i]->grffile = _cur_grffile;
+				housespec[i]->random_colour[0] = 0x04;  // those 4 random colours are the base colour
+				housespec[i]->random_colour[1] = 0x08;  // for all new houses
+				housespec[i]->random_colour[2] = 0x0C;  // they stand for red, blue, orange and green
+				housespec[i]->random_colour[3] = 0x06;
+				/* New houses do not (currently) expect to have a default start
+				 * date before 1930, as this breaks the build date stuff. See
+				 * FinaliseHouseArray() for more details. */
+				if (housespec[i]->min_date < 1930) housespec[i]->min_date = 1930;
+			}
+			_have_newhouses = true;
+			break;
+		case 0x09: // Building flags
+			FOR_EACH_OBJECT {
+				byte state = grf_load_byte(&buf);
+				housespec[i]->building_flags = (BuildingFlags)state;
+			}
+			break;
+		case 0x0A: // Availability years
+			FOR_EACH_OBJECT {
+				uint16 years = grf_load_word(&buf);
+				housespec[i]->min_date = GB(years, 0, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 0, 8);
+				housespec[i]->max_date = GB(years, 8, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 8, 8);
+			}
+			break;
+		case 0x0B: // Population
+			FOR_EACH_OBJECT housespec[i]->population = grf_load_byte(&buf);
+			break;
+		case 0x0C: // Mail generation multiplier
+			FOR_EACH_OBJECT housespec[i]->mail_generation = grf_load_byte(&buf);
+			break;
+		case 0x0D: // Passenger acceptance
+		case 0x0E: // Mail acceptance
+			FOR_EACH_OBJECT housespec[i]->cargo_acceptance[prop - 0x0D] = grf_load_byte(&buf);
+			break;
+		case 0x0F: // Goods/candy, food/fizzy drinks acceptance
+			FOR_EACH_OBJECT {
+				int8 goods = grf_load_byte(&buf);
+				/* If value of goods is negative, it means in fact food or, if in toyland, fizzy_drink acceptance.
+				 * Else, we have "standard" 3rd cargo type, goods or candy, for toyland once more */
+				housespec[i]->accepts_cargo[2] = (goods >= 0) ? ((_opt.landscape == LT_TOYLAND) ? CT_CANDY : CT_GOODS) :
+						((_opt.landscape == LT_TOYLAND) ? CT_FIZZY_DRINKS : CT_FOOD);
+				housespec[i]->cargo_acceptance[2] = abs(goods); // but we do need positive value here
+			}
+			break;
+		case 0x10: // Local authority rating decrease on removal
+			FOR_EACH_OBJECT housespec[i]->remove_rating_decrease = grf_load_word(&buf);
+			break;
+		case 0x11: // Removal cost multiplier
+			FOR_EACH_OBJECT housespec[i]->removal_cost = grf_load_byte(&buf);
+			break;
+		case 0x12: // Building name ID
+			FOR_EACH_OBJECT housespec[i]->building_name = MapGRFStringID(_cur_grffile->grfid, grf_load_word(&buf));
+			break;
+		case 0x13: // Building availability mask
+			FOR_EACH_OBJECT {
+				uint16 avail = grf_load_word(&buf);
+				housespec[i]->building_availability = (HouseZones)avail;
+			}
+			break;
+		case 0x14: // House callback flags
+			FOR_EACH_OBJECT housespec[i]->callback_mask = grf_load_byte(&buf);
+			break;
+		case 0x15: // House override byte
+			FOR_EACH_OBJECT {
+				byte override = grf_load_byte(&buf);
+				/* The house being overridden must be an original house. */
+				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);
+			}
+			break;
+		case 0x16: // Periodic refresh multiplier
+			FOR_EACH_OBJECT housespec[i]->processing_time = grf_load_byte(&buf);
+			break;
+		case 0x17: // Four random colours to use
+			FOR_EACH_OBJECT {
+				uint j;
+				for (j = 0; j < 4; j++)	housespec[i]->random_colour[j] = grf_load_byte(&buf);
+			}
+			break;
+		case 0x18: // Relative probability of appearing
+			FOR_EACH_OBJECT housespec[i]->probability = grf_load_byte(&buf);
+			break;
+		case 0x19: // Extra flags
+			FOR_EACH_OBJECT {
+				byte flags = grf_load_byte(&buf);
+				housespec[i]->extra_flags = (HouseExtraFlags)flags;
+			}
+			break;
+		case 0x1A: // Animation frames
+			FOR_EACH_OBJECT housespec[i]->animation_frames = grf_load_byte(&buf);
+			break;
+		case 0x1B: // Animation speed
+			FOR_EACH_OBJECT housespec[i]->animation_speed = clamp(grf_load_byte(&buf), 2, 16);
+			break;
+		case 0x1C: // Class of the building type
+			FOR_EACH_OBJECT housespec[i]->class_id = AllocateHouseClassID(grf_load_byte(&buf), _cur_grffile->grfid);
+			break;
+		case 0x1D: // Callback flags 2
+			FOR_EACH_OBJECT housespec[i]->callback_mask |= (grf_load_byte(&buf) << 8);
+			break;
+		case 0x1E: // Accepted cargo types
+			FOR_EACH_OBJECT grf_load_dword(&buf);
+			ret = true;
+			break;
+		default:
+			ret = true;
+			break;
 	}
 	*bufp = buf;
 	return ret;
 }
 				}
 			}
 			break;
 		case 0x10: // 12 * 32 * B Snow line height table
+			if (numinfo > 1 || IsSnowLineSet()) {
+				grfmsg(1, "GlobalVarChangeInfo: The snowline can only be set once (%d)", numinfo);
+			} else if (len < SNOW_LINE_MONTHS * SNOW_LINE_DAYS) {
+				grfmsg(1, "GlobalVarChangeInfo: Not enough entries set in the snowline table (%d)", len);
+			} else {
+				byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS];
+				for (uint i = 0; i < SNOW_LINE_MONTHS; i++) {
+					for (uint j = 0; j < SNOW_LINE_DAYS; j++) {
+						table[i][j] = grf_load_byte(&buf);
+					}
+				}
+				SetSnowLine(table);
+			}
+			break;
 		default:
 			ret = true;
 	}
 	*bufp = buf;
 	return ret;
 }
-static bool SoundEffectChangeInfo(uint sid, int numinfo, int prop, byte **bufp, int len)
+static bool CargoChangeInfo(uint cid, int numinfo, int prop, byte **bufp, int len)
 {
+	if (cid + numinfo > NUM_CARGO) {
+		grfmsg(2, "CargoChangeInfo: Cargo type %d out of range (max %d)", cid + numinfo, NUM_CARGO - 1);
+		return false;
+	}
+	CargoSpec *cs = &_cargo[cid];
 	byte *buf = *bufp;
 	int i;
 	bool ret = false;
+	switch (prop) {
+		case 0x08: /* Bit number of cargo */
+			FOR_EACH_OBJECT {
+				cs[i].bitnum = grf_load_byte(&buf);
+				cs[i].grfid = _cur_grffile->grfid;
+				if (cs->IsValid()) {
+					SETBIT(_cargo_mask, cid + i);
+				} else {
+					CLRBIT(_cargo_mask, cid + i);
+				}
+			}
+			break;
+		case 0x09: /* String ID for cargo type name */
+			FOR_EACH_OBJECT cs[i].name = grf_load_word(&buf);
+			break;
+		case 0x0A: /* String for cargo name, plural */
+			FOR_EACH_OBJECT cs[i].name_plural = grf_load_word(&buf);
+			break;
+		case 0x0B:
+			/* String for units of cargo. This is different in OpenTTD to TTDPatch
+			 * (e.g. 10 tonnes of coal) */
+			FOR_EACH_OBJECT cs[i].units_volume = grf_load_word(&buf);
+			break;
+		case 0x0C: /* String for quantity of cargo (e.g. 10 tonnes of coal) */
+			FOR_EACH_OBJECT cs[i].quantifier = grf_load_word(&buf);
+			break;
+		case 0x0D: /* String for two letter cargo abbreviation */
+			FOR_EACH_OBJECT cs[i].abbrev = grf_load_word(&buf);
+			break;
+		case 0x0E: /* Sprite ID for cargo icon */
+			FOR_EACH_OBJECT cs[i].sprite = grf_load_word(&buf);
+			break;
+		case 0x0F: /* Weight of one unit of cargo */
+			FOR_EACH_OBJECT cs[i].weight = grf_load_byte(&buf);
+			break;
+		case 0x10: /* Used for payment calculation */
+			FOR_EACH_OBJECT cs[i].transit_days[0] = grf_load_byte(&buf);
+			break;
+		case 0x11: /* Used for payment calculation */
+			FOR_EACH_OBJECT cs[i].transit_days[1] = grf_load_byte(&buf);
+			break;
+		case 0x12: /* Base cargo price */
+			FOR_EACH_OBJECT cs[i].initial_payment = grf_load_dword(&buf);
+			break;
+		case 0x13: /* Colour for station rating bars */
+			FOR_EACH_OBJECT cs[i].rating_colour = MapDOSColour(grf_load_byte(&buf));
+			break;
+		case 0x14: /* Colour for cargo graph */
+			FOR_EACH_OBJECT cs[i].legend_colour = MapDOSColour(grf_load_byte(&buf));
+			break;
+		case 0x15: /* Freight status */
+			FOR_EACH_OBJECT cs[i].is_freight = grf_load_byte(&buf) != 0;
+			break;
+		case 0x16: /* Cargo classes */
+			FOR_EACH_OBJECT cs[i].classes = grf_load_word(&buf);
+			break;
+		case 0x17: /* Cargo label */
+			FOR_EACH_OBJECT {
+				cs[i].label = grf_load_dword(&buf);
+				cs[i].label = BSWAP32(cs[i].label);
+			}
+			break;
+		case 0x18: /* Town growth substitute type */
+			FOR_EACH_OBJECT {
+				uint8 substitute_type = grf_load_byte(&buf);
+				switch (substitute_type) {
+					case 0x00: cs[i].town_effect = TE_PASSENGERS; break;
+					case 0x02: cs[i].town_effect = TE_MAIL; break;
+					case 0x05: cs[i].town_effect = TE_GOODS; break;
+					case 0x09: cs[i].town_effect = TE_WATER; break;
+					case 0x0B: cs[i].town_effect = TE_FOOD; break;
+					default:
+						grfmsg(1, "CargoChangeInfo: Unknown town growth substitute value %d, setting to none.", substitute_type);
+					case 0xFF: cs[i].town_effect = TE_NONE; break;
+				}
+			}
+			break;
+		case 0x19: /* Town growth coefficient */
+			FOR_EACH_OBJECT cs[i].multipliertowngrowth = grf_load_word(&buf);
+			break;
+		case 0x1A: /* Bitmask of callbacks to use */
+			FOR_EACH_OBJECT cs[i].callback_mask = grf_load_byte(&buf);
+			break;
+		default:
+			ret = true;
+	}
+	*bufp = buf;
+	return ret;
+}
+static bool SoundEffectChangeInfo(uint sid, int numinfo, int prop, byte **bufp, int len)
+{
+	byte *buf = *bufp;
+	int i;
+	bool ret = false;
 	if (_cur_grffile->sound_offset == 0) {
 		grfmsg(1, "SoundEffectChangeInfo: No effects defined, skipping");
 		return false;
 	}
 	switch (prop) {
-		case 0x08: /* Relative volume */
+		case 0x08: // Relative volume
 			FOR_EACH_OBJECT {
 				uint sound = sid + i + _cur_grffile->sound_offset - GetNumOriginalSounds();
 				if (sound >= GetNumSounds()) {
 					grfmsg(1, "SoundEffectChangeInfo: Sound %d not defined (max %d)", sound, GetNumSounds());
 					GetSound(sound)->volume = grf_load_byte(&buf);
 				}
 			}
 			break;
-		case 0x09: /* Priority */
+		case 0x09: // Priority
 			FOR_EACH_OBJECT {
 				uint sound = sid + i + _cur_grffile->sound_offset - GetNumOriginalSounds();
 				if (sound >= GetNumSounds()) {
 					grfmsg(1, "SoundEffectChangeInfo: Sound %d not defined (max %d)", sound, GetNumSounds());
 					GetSound(sound)->priority = grf_load_byte(&buf);
 				}
 			}
 			break;
-		case 0x0A: /* Override old sound */
+		case 0x0A: // Override old sound
 			FOR_EACH_OBJECT {
 				uint sound = sid + i + _cur_grffile->sound_offset - GetNumOriginalSounds();
 				uint orig_sound = grf_load_byte(&buf);
 				if (sound >= GetNumSounds() || orig_sound >= GetNumSounds()) {
 /* Action 0x00 */
 static void FeatureChangeInfo(byte *buf, int len)
 {
 	byte *bufend = buf + len;
-	int i;
+	uint i;
 	/* <00> <feature> <num-props> <num-info> <id> (<property <new-info>)...
 	 *
 	 * B feature       0, 1, 2 or 3 for trains, road vehicles, ships or planes
 	 *                 4 for defining new train station sets
 		/* GSF_SHIP */         ShipVehicleChangeInfo,
 		/* GSF_AIRCRAFT */     AircraftVehicleChangeInfo,
 		/* GSF_STATION */      StationChangeInfo,
 		/* GSF_CANAL */        NULL,
 		/* GSF_BRIDGE */       BridgeChangeInfo,
-		/* GSF_TOWNHOUSE */    NULL,
+		/* GSF_TOWNHOUSE */    TownHouseChangeInfo,
 		/* GSF_GLOBALVAR */    GlobalVarChangeInfo,
 		/* GSF_INDUSTRYTILES */NULL,
 		/* GSF_INDUSTRIES */   NULL,
-		/* GSF_CARGOS */       NULL,
+		/* GSF_CARGOS */       NULL, /* Cargo is handled during reservation */
 		/* GSF_SOUNDFX */      SoundEffectChangeInfo,
 	};
 	EngineInfo *ei = NULL;
 	if (!check_length(len, 6, "FeatureChangeInfo")) return;
 	buf++;
 	uint8 feature  = grf_load_byte(&buf);
 	uint8 numprops = grf_load_byte(&buf);
-	uint8 numinfo  = grf_load_byte(&buf);
+	uint numinfo  = grf_load_byte(&buf);
-	uint8 engine   = grf_load_byte(&buf);
+	uint engine   = grf_load_byte(&buf);
 	grfmsg(6, "FeatureChangeInfo: feature %d, %d properties, to apply to %d+%d",
 	               feature, numprops, engine, numinfo);
 	if (feature >= lengthof(handler) || handler[feature] == NULL) {
 			case GSF_ROAD:
 			case GSF_SHIP:
 			case GSF_AIRCRAFT:
 				/* Common properties for vehicles */
 				switch (prop) {
-					case 0x00: /* Introduction date */
+					case 0x00: // Introduction date
 						FOR_EACH_OBJECT ei[i].base_intro = grf_load_word(&buf) + DAYS_TILL_ORIGINAL_BASE_YEAR;
 						break;
-					case 0x02: /* Decay speed */
+					case 0x02: // Decay speed
 						FOR_EACH_OBJECT SB(ei[i].unk2, 0, 7, grf_load_byte(&buf) & 0x7F);
 						break;
-					case 0x03: /* Vehicle life */
+					case 0x03: // Vehicle life
 						FOR_EACH_OBJECT ei[i].lifelength = grf_load_byte(&buf);
 						break;
-					case 0x04: /* Model life */
+					case 0x04: // Model life
 						FOR_EACH_OBJECT ei[i].base_life = grf_load_byte(&buf);
 						break;
-					case 0x06: /* Climates available */
+					case 0x06: // Climates available
 						FOR_EACH_OBJECT ei[i].climates = grf_load_byte(&buf);
 						break;
-					case 0x07: /* Loading speed */
+					case 0x07: // Loading speed
 						/* Hyronymus explained me what does
 						 * this mean and insists on having a
 						 * credit ;-). --pasky */
 						FOR_EACH_OBJECT ei[i].load_amount = grf_load_byte(&buf);
 						break;
 		uint8 prop = grf_load_byte(&buf);
 		switch (feature) {
 			case GSF_GLOBALVAR:
 				switch (prop) {
-					case 0x09: /* Cargo Translation Table */
+					case 0x09: // Cargo Translation Table
 						if (index != 0) {
 							grfmsg(1, "InitChangeInfo: Cargo translation table must start at zero");
 							return;
 						}
 				break;
 		}
 	}
 }
+/* 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);
+	if (feature != GSF_CARGOS) return;
+	uint8 numprops = grf_load_byte(&buf);
+	uint8 numinfo  = grf_load_byte(&buf);
+	uint8 index    = grf_load_byte(&buf);
+	while (numprops-- && buf < bufend) {
+		uint8 prop = grf_load_byte(&buf);
+		if (CargoChangeInfo(index, numinfo, prop, &buf, bufend - buf)) {
+			grfmsg(2, "FeatureChangeInfo: Ignoring property 0x%02X (not implemented)", prop);
+		}
+	}
+}
 #undef FOR_EACH_OBJECT
 /**
 * Creates a spritegroup representing a callback result
 * @param value The value that was used to represent this callback result
 {
 	SpriteGroup *group = AllocateSpriteGroup();
 	group->type = SGT_CALLBACK;
-	// Old style callback results have the highest byte 0xFF so signify it is a callback result
+	/* Old style callback results have the highest byte 0xFF so signify it is a callback result
-	// New style ones only have the highest bit set (allows 15-bit results, instead of just 8)
+	 * New style ones only have the highest bit set (allows 15-bit results, instead of just 8) */
 	if ((value >> 8) == 0xFF) {
 		value &= ~0xFF00;
 	} else {
 		value &= ~0x8000;
 	}
 	grfmsg(7, "New sprite set at %d of type %d, consisting of %d sets with %d views each (total %d)",
 		_cur_spriteid, feature, num_sets, num_ents, num_sets * num_ents
 	);
-	for (uint i = 0; i < num_sets * num_ents; i++) {
+	for (uint16 i = 0; i < num_sets * num_ents; i++) {
 		LoadNextSprite(_cur_spriteid++, _file_index);
 		_nfo_line++;
 	}
 }
 	uint8 feature = grf_load_byte(&buf);
 	uint8 setid   = grf_load_byte(&buf);
 	uint8 type    = grf_load_byte(&buf);
 	if (setid >= _cur_grffile->spritegroups_count) {
-		// Allocate memory for new sprite group references.
+		/* Allocate memory for new sprite group references. */
 		_cur_grffile->spritegroups = ReallocT(_cur_grffile->spritegroups, setid + 1);
-		// Initialise new space to NULL
+		/* Initialise new space to NULL */
 		for (; _cur_grffile->spritegroups_count < (setid + 1); _cur_grffile->spritegroups_count++)
 			_cur_grffile->spritegroups[_cur_grffile->spritegroups_count] = NULL;
 	}
 	switch (type) {
 				case GSF_TRAIN:
 				case GSF_ROAD:
 				case GSF_SHIP:
 				case GSF_AIRCRAFT:
 				case GSF_STATION:
+				case GSF_CARGOS:
 				{
 					byte sprites     = _cur_grffile->spriteset_numents;
 					byte num_loaded  = type;
 					byte num_loading = grf_load_byte(&buf);
 					}
 					break;
 				}
+				case GSF_TOWNHOUSE: {
+					byte sprites     = _cur_grffile->spriteset_numents;
+					byte num_sprites = max((uint8)1, type);
+					uint i;
+					group = AllocateSpriteGroup();
+					group->type = SGT_TILELAYOUT;
+					group->g.layout.num_sprites = sprites;
+					group->g.layout.dts = CallocT<DrawTileSprites>(1);
+					/* Groundsprite */
+					group->g.layout.dts->ground_sprite = grf_load_word(&buf);
+					group->g.layout.dts->ground_pal    = grf_load_word(&buf);
+					/* Remap transparent/colour modifier bits */
+					if (HASBIT(group->g.layout.dts->ground_sprite, 14)) {
+						CLRBIT(group->g.layout.dts->ground_sprite, 14);
+						SETBIT(group->g.layout.dts->ground_sprite, PALETTE_MODIFIER_TRANSPARENT);
+					}
+					if (HASBIT(group->g.layout.dts->ground_sprite, 15)) {
+						CLRBIT(group->g.layout.dts->ground_sprite, 15);
+						SETBIT(group->g.layout.dts->ground_sprite, PALETTE_MODIFIER_COLOR);
+					}
+					if (HASBIT(group->g.layout.dts->ground_pal, 14)) {
+						CLRBIT(group->g.layout.dts->ground_pal, 14);
+						SETBIT(group->g.layout.dts->ground_sprite, SPRITE_MODIFIER_OPAQUE);
+					}
+					if (HASBIT(group->g.layout.dts->ground_pal, 15)) {
+						/* Bit 31 set means this is a custom sprite, so rewrite it to the
+						 * last spriteset defined. */
+						SpriteID sprite = _cur_grffile->spriteset_start + GB(group->g.layout.dts->ground_sprite, 0, 14) * sprites;
+						SB(group->g.layout.dts->ground_sprite, 0, SPRITE_WIDTH, sprite);
+						CLRBIT(group->g.layout.dts->ground_pal, 15);
+					}
+					group->g.layout.dts->seq = CallocT<DrawTileSeqStruct>(num_sprites + 1);
+					for (i = 0; i < num_sprites; i++) {
+						DrawTileSeqStruct *seq = (DrawTileSeqStruct*)&group->g.layout.dts->seq[i];
+						seq->image = grf_load_word(&buf);
+						seq->pal   = grf_load_word(&buf);
+						seq->delta_x = grf_load_byte(&buf);
+						seq->delta_y = grf_load_byte(&buf);
+						if (HASBIT(seq->image, 14)) {
+							CLRBIT(seq->image, 14);
+							SETBIT(seq->image, PALETTE_MODIFIER_TRANSPARENT);
+						}
+						if (HASBIT(seq->image, 15)) {
+							CLRBIT(seq->image, 15);
+							SETBIT(seq->image, PALETTE_MODIFIER_COLOR);
+						}
+						if (HASBIT(seq->pal, 14)) {
+							CLRBIT(seq->pal, 14);
+							SETBIT(seq->image, SPRITE_MODIFIER_OPAQUE);
+						}
+						if (HASBIT(seq->pal, 15)) {
+							/* Bit 31 set means this is a custom sprite, so rewrite it to the
+							 * last spriteset defined. */
+							SpriteID sprite = _cur_grffile->spriteset_start + GB(seq->image, 0, 14) * sprites;
+							SB(seq->image, 0, SPRITE_WIDTH, sprite);
+							CLRBIT(seq->pal, 15);
+						}
+						if (type > 0) {
+							seq->delta_z = grf_load_byte(&buf);
+							if ((byte)seq->delta_z == 0x80) continue;
+						}
+						seq->size_x = grf_load_byte(&buf);
+						seq->size_y = grf_load_byte(&buf);
+						seq->size_z = grf_load_byte(&buf);
+					}
+					/* Set the terminator value. */
+					((DrawTileSeqStruct*)group->g.layout.dts->seq)[i].delta_x = (byte)0x80;
+					break;
+				}
 				/* Loading of Tile Layout and Production Callback groups would happen here */
 				default: grfmsg(1, "NewSpriteGroup: Unsupported feature %d, skipping", feature);
 			}
 		}
 	}
 {
 	/* Special cargo types for purchase list and stations */
 	if (feature == GSF_STATION && ctype == 0xFE) return CT_DEFAULT_NA;
 	if (ctype == 0xFF) return CT_PURCHASE;
+	if (_cur_grffile->cargo_max == 0) {
+		/* No cargo table, so use bitnum values */
+		if (ctype >= 32) {
+			grfmsg(1, "FeatureMapSpriteGroup: Cargo bitnum %d out of range (max 31), skipping.", ctype);
+			return CT_INVALID;
+		}
+		for (CargoID c = 0; c < NUM_CARGO; c++) {
+			const CargoSpec *cs = GetCargo(c);
+			if (!cs->IsValid()) continue;
+			if (cs->bitnum == ctype) {
+				grfmsg(6, "FeatureMapSpriteGroup: Cargo bitnum %d mapped to cargo type %d.", ctype, c);
+				return c;
+			}
+		}
+		grfmsg(5, "FeatureMapSpriteGroup: Cargo bitnum %d not available in this climate, skipping.", ctype);
+		return CT_INVALID;
+	}
 	/* Check if the cargo type is out of bounds of the cargo translation table */
-	if (ctype >= (_cur_grffile->cargo_max == 0 ? _default_cargo_max : _cur_grffile->cargo_max)) {
+	if (ctype >= _cur_grffile->cargo_max) {
-		grfmsg(1, "FeatureMapSpriteGroup: Cargo type %d out of range (max %d), skipping.", ctype, (_cur_grffile->cargo_max == 0 ? _default_cargo_max : _cur_grffile->cargo_max) - 1);
+		grfmsg(1, "FeatureMapSpriteGroup: Cargo type %d out of range (max %d), skipping.", ctype, _cur_grffile->cargo_max - 1);
 		return CT_INVALID;
 	}
 	/* Look up the cargo label from the translation table */
-	CargoLabel cl = _cur_grffile->cargo_max == 0 ? _default_cargo_list[ctype] : _cur_grffile->cargo_list[ctype];
+	CargoLabel cl = _cur_grffile->cargo_list[ctype];
 	if (cl == 0) {
 		grfmsg(5, "FeatureMapSpriteGroup: Cargo type %d not available in this climate, skipping.", ctype);
 		return CT_INVALID;
 	}
 	}
 	grfmsg(6, "FeatureMapSpriteGroup: 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);
 	return ctype;
 }
+static void VehicleMapSpriteGroup(byte *buf, byte feature, uint8 idcount, uint8 cidcount, bool wagover)
+{
+	static byte *last_engines;
+	static int last_engines_count;
+	if (!wagover) {
+		if (last_engines_count != idcount) {
+			last_engines = ReallocT(last_engines, idcount);
+			last_engines_count = idcount;
+		}
+	} else {
+		if (last_engines_count == 0) {
+			grfmsg(0, "FeatureMapSpriteGroup: WagonOverride: No engine to do override with");
+			return;
+		}
+		grfmsg(6, "FeatureMapSpriteGroup: WagonOverride: %u engines, %u wagons",
+				last_engines_count, idcount);
+	}
+	for (uint i = 0; i < idcount; i++) {
+		uint8 engine_id = buf[3 + i];
+		uint8 engine = engine_id + _vehshifts[feature];
+		byte *bp = &buf[4 + idcount];
+		if (engine_id > _vehcounts[feature]) {
+			grfmsg(0, "Id %u for feature 0x%02X is out of bounds", engine_id, feature);
+			return;
+		}
+		grfmsg(7, "FeatureMapSpriteGroup: [%d] Engine %d...", i, engine);
+		for (uint c = 0; c < cidcount; c++) {
+			uint8 ctype = grf_load_byte(&bp);
+			uint16 groupid = grf_load_word(&bp);
+			grfmsg(8, "FeatureMapSpriteGroup: * [%d] Cargo type 0x%X, group id 0x%02X", c, ctype, groupid);
+			if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
+				grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping", groupid, _cur_grffile->spritegroups_count);
+				continue;
+			}
+			ctype = TranslateCargo(feature, ctype);
+			if (ctype == CT_INVALID) continue;
+			if (wagover) {
+				SetWagonOverrideSprites(engine, ctype, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
+			} else {
+				SetCustomEngineSprites(engine, ctype, _cur_grffile->spritegroups[groupid]);
+				last_engines[i] = engine;
+			}
+		}
+	}
+	{
+		byte *bp = &buf[4 + idcount + cidcount * 3];
+		uint16 groupid = grf_load_word(&bp);
+		grfmsg(8, "-- Default group id 0x%04X", groupid);
+		for (uint i = 0; i < idcount; i++) {
+			uint8 engine = buf[3 + i] + _vehshifts[feature];
+			/* Don't tell me you don't love duplicated code! */
+			if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
+				grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping",
+				       groupid, _cur_grffile->spritegroups_count);
+				continue;
+			}
+			if (wagover) {
+				/* If the ID for this action 3 is the same as the vehicle ID,
+* this indicates we have a helicopter rotor override. */
+				if (feature == GSF_AIRCRAFT && engine == last_engines[i]) {
+					SetRotorOverrideSprites(engine, _cur_grffile->spritegroups[groupid]);
+				} else {
+					/* TODO: No multiple cargo types per vehicle yet. --pasky */
+					SetWagonOverrideSprites(engine, CT_DEFAULT, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
+				}
+			} else {
+				SetCustomEngineSprites(engine, CT_DEFAULT, _cur_grffile->spritegroups[groupid]);
+				SetEngineGRF(engine, _cur_grffile);
+				last_engines[i] = engine;
+			}
+		}
+	}
+}
+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];
+		byte *bp = &buf[4 + idcount];
+		for (uint c = 0; c < cidcount; c++) {
+			uint8 ctype = grf_load_byte(&bp);
+			uint16 groupid = grf_load_word(&bp);
+			if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
+				grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping",
+				       groupid, _cur_grffile->spritegroups_count);
+				continue;
+			}
+			ctype = TranslateCargo(GSF_STATION, ctype);
+			if (ctype == CT_INVALID) continue;
+			statspec->spritegroup[ctype] = _cur_grffile->spritegroups[groupid];
+		}
+	}
+	{
+		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, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping",
+			       groupid, _cur_grffile->spritegroups_count);
+			return;
+		}
+		for (uint i = 0; i < idcount; i++) {
+			uint8 stid = buf[3 + i];
+			StationSpec *statspec = _cur_grffile->stations[stid];
+			statspec->spritegroup[CT_DEFAULT] = _cur_grffile->spritegroups[groupid];
+			statspec->grfid = _cur_grffile->grfid;
+			statspec->localidx = stid;
+			SetCustomStationSpec(statspec);
+		}
+	}
+}
+static void TownHouseMapSpriteGroup(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, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping.",
+		       groupid, _cur_grffile->spritegroups_count);
+		return;
+	}
+	for (uint i = 0; i < idcount; i++) {
+		uint8 hid = buf[3 + i];
+		HouseSpec *hs = _cur_grffile->housespec[hid];
+		if (hs == NULL) {
+			grfmsg(1, "FeatureMapSpriteGroup: Too many houses defined, skipping");
+			return;
+		}
+		hs->spritegroup = _cur_grffile->spritegroups[groupid];
+	}
+}
+static void CargoMapSpriteGroup(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, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping.",
+		       groupid, _cur_grffile->spritegroups_count);
+		return;
+	}
+	for (uint i = 0; i < idcount; i++) {
+		CargoID cid = buf[3 + i];
+		if (cid >= NUM_CARGO) {
+			grfmsg(1, "FeatureMapSpriteGroup: Cargo ID %d out of range, skipping");
+			continue;
+		}
+		CargoSpec *cs = &_cargo[cid];
+		cs->grfid = _cur_grffile->grfid;
+		cs->group = _cur_grffile->spritegroups[groupid];
+	}
+}
 /* Action 0x03 */
 static void FeatureMapSpriteGroup(byte *buf, int len)
 {
 	/* <03> <feature> <n-id> <ids>... <num-cid> [<cargo-type> <cid>]... <def-cid>
 	 * B num-cid       number of cargo IDs (sprite group IDs) in this definition
 	 *                 can be zero, in that case the def-cid is used always
 	 * B cargo-type    type of this cargo type (e.g. mail=2, wood=7, see below)
 	 * W cid           cargo ID (sprite group ID) for this type of cargo
 	 * W def-cid       default cargo ID (sprite group ID) */
-	/* TODO: Bridges, town houses. */
-	/* TODO: Multiple cargo support could be useful even for trains/cars -
-	 * cargo id 0xff is used for showing images in the build train list. */
-	static byte *last_engines;
-	static int last_engines_count;
 	if (!check_length(len, 6, "FeatureMapSpriteGroup")) return;
 	uint8 feature = buf[1];
 	uint8 idcount = buf[2] & 0x7F;
 	if (!check_length(len, 4 + idcount + cidcount * 3, "FeatureMapSpriteGroup")) return;
 	grfmsg(6, "FeatureMapSpriteGroup: Feature %d, %d ids, %d cids, wagon override %d",
 			feature, idcount, cidcount, wagover);
-	if (feature > GSF_STATION) {
-		grfmsg(1, "FeatureMapSpriteGroup: Unsupported feature %d, skipping", feature);
-		return;
-	}
-	if (feature == GSF_STATION) {
-		// We do things differently for stations.
-		for (uint i = 0; i < idcount; i++) {
-			uint8 stid = buf[3 + i];
-			StationSpec *statspec = _cur_grffile->stations[stid];
-			byte *bp = &buf[4 + idcount];
-			for (uint c = 0; c < cidcount; c++) {
-				uint8 ctype = grf_load_byte(&bp);
-				uint16 groupid = grf_load_word(&bp);
-				if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
-					grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping",
-					       groupid, _cur_grffile->spritegroups_count);
-					return;
-				}
-				ctype = TranslateCargo(feature, ctype);
-				if (ctype == CT_INVALID) continue;
-				statspec->spritegroup[ctype] = _cur_grffile->spritegroups[groupid];
-			}
-		}
-		{
-			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, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping",
-				       groupid, _cur_grffile->spritegroups_count);
-				return;
-			}
-			for (uint i = 0; i < idcount; i++) {
-				uint8 stid = buf[3 + i];
-				StationSpec *statspec = _cur_grffile->stations[stid];
-				statspec->spritegroup[CT_DEFAULT] = _cur_grffile->spritegroups[groupid];
-				statspec->grfid = _cur_grffile->grfid;
-				statspec->localidx = stid;
-				SetCustomStationSpec(statspec);
-			}
-		}
-		return;
-	}
-	// FIXME: Tropicset contains things like:
-	// 03 00 01 19 01 00 00 00 00 - this is missing one 00 at the end,
-	// what should we exactly do with that? --pasky
 	if (_cur_grffile->spriteset_start == 0 || _cur_grffile->spritegroups == 0) {
 		grfmsg(1, "FeatureMapSpriteGroup: No sprite set to work on! Skipping");
 		return;
 	}
-	if (!wagover && last_engines_count != idcount) {
+	switch (feature) {
-		last_engines = ReallocT(last_engines, idcount);
+		case GSF_TRAIN:
-		last_engines_count = idcount;
+		case GSF_ROAD:
-	}
+		case GSF_SHIP:
+		case GSF_AIRCRAFT:
-	if (wagover) {
+			VehicleMapSpriteGroup(buf, feature, idcount, cidcount, wagover);
-		if (last_engines_count == 0) {
-			grfmsg(0, "FeatureMapSpriteGroup: WagonOverride: No engine to do override with");
 			return;
-		}
-		grfmsg(6, "FeatureMapSpriteGroup: WagonOverride: %u engines, %u wagons",
+		case GSF_STATION:
-				last_engines_count, idcount);
+			StationMapSpriteGroup(buf, idcount, cidcount);
-	}
-	for (uint i = 0; i < idcount; i++) {
-		uint8 engine_id = buf[3 + i];
-		uint8 engine = engine_id + _vehshifts[feature];
-		byte *bp = &buf[4 + idcount];
-		if (engine_id > _vehcounts[feature]) {
-			grfmsg(0, "Id %u for feature 0x%02X is out of bounds", engine_id, feature);
 			return;
-		}
+		case GSF_TOWNHOUSE:
-		grfmsg(7, "FeatureMapSpriteGroup: [%d] Engine %d...", i, engine);
+			TownHouseMapSpriteGroup(buf, idcount, cidcount);
+			return;
-		for (uint c = 0; c < cidcount; c++) {
-			uint8 ctype = grf_load_byte(&bp);
+		case GSF_CARGOS:
-			uint16 groupid = grf_load_word(&bp);
+			CargoMapSpriteGroup(buf, idcount, cidcount);
+			return;
-			grfmsg(8, "FeatureMapSpriteGroup: * [%d] Cargo type 0x%X, group id 0x%02X", c, ctype, groupid);
+		default:
-			if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
+			grfmsg(1, "FeatureMapSpriteGroup: Unsupported feature %d, skipping", feature);
-				grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping", groupid, _cur_grffile->spritegroups_count);
+			return;
-				return;
-			}
-			ctype = TranslateCargo(feature, ctype);
-			if (ctype == CT_INVALID) continue;
-			if (wagover) {
-				SetWagonOverrideSprites(engine, ctype, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
-			} else {
-				SetCustomEngineSprites(engine, ctype, _cur_grffile->spritegroups[groupid]);
-				last_engines[i] = engine;
-			}
-		}
-	}
-	{
-		byte *bp = buf + 4 + idcount + cidcount * 3;
-		uint16 groupid = grf_load_word(&bp);
-		grfmsg(8, "-- Default group id 0x%04X", groupid);
-		for (uint i = 0; i < idcount; i++) {
-			uint8 engine = buf[3 + i] + _vehshifts[feature];
-			// Don't tell me you don't love duplicated code!
-			if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
-				grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping", groupid, _cur_grffile->spritegroups_count);
-				return;
-			}
-			if (wagover) {
-				/* If the ID for this action 3 is the same as the vehicle ID,
-				 * this indicates we have a helicopter rotor override. */
-				if (feature == GSF_AIRCRAFT && engine == last_engines[i]) {
-					SetRotorOverrideSprites(engine, _cur_grffile->spritegroups[groupid]);
-				} else {
-					// TODO: No multiple cargo types per vehicle yet. --pasky
-					SetWagonOverrideSprites(engine, CT_DEFAULT, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
-				}
-			} else {
-				SetCustomEngineSprites(engine, CT_DEFAULT, _cur_grffile->spritegroups[groupid]);
-				SetEngineGRF(engine, _cur_grffile);
-				last_engines[i] = engine;
-			}
-		}
 	}
 }
 /* Action 0x04 */
 static void FeatureNewName(byte *buf, int len)
 						AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, id);
 					}
 					break;
 				}
+				case GSF_TOWNHOUSE:
 				default:
 					switch (GB(id, 8, 8)) {
-						case 0xC4: /* Station class name */
+						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 */
+						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:
+						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;
 					break;
 #if 0
 				case GSF_CANAL :
 				case GSF_BRIDGE :
-				case GSF_TOWNHOUSE :
 					AddGRFString(_cur_spriteid, id, lang, name);
 					switch (GB(id, 8,8)) {
-						case 0xC9: /* House name */
+						case 0xC9: // House name
 						default:
 							grfmsg(7, "FeatureNewName: Unsupported ID (0x%04X)", id);
 					}
 					break;
 				case GSF_INDUSTRIES :
-				case 0x48 :   /* for generic strings */
+				case 0x48 :   // for generic strings
 					AddGRFString(_cur_spriteid, id, lang, name);
 					break;
 				default :
 					grfmsg(7, "FeatureNewName: Unsupported feature (0x%02X)", feature);
 					break;
 	buf++;
 	uint8 type = grf_load_byte(&buf);
 	uint16 num = grf_load_extended(&buf);
 	switch (type) {
-		case 0x04: /* Signal graphics */
+		case 0x04: // Signal graphics
 			if (num != 112 && num != 240) {
 				grfmsg(1, "GraphicsNews: Signal graphics sprite count must be 112 or 240, skipping");
 				return;
 			}
 			_signal_base = _cur_spriteid;
 			break;
-		case 0x05: /* Catenary graphics */
+		case 0x05: // Catenary graphics
 			if (num != 48) {
 				grfmsg(1, "GraphicsNews: Catenary graphics sprite count must be 48, skipping");
 				return;
 			}
 			replace = SPR_ELRAIL_BASE + 3;
 			break;
-		case 0x06: /* Foundations */
+		case 0x06: // Foundations
 			if (num != 74) {
 				grfmsg(1, "GraphicsNews: Foundation graphics sprite count must be 74, skipping");
 				return;
 			}
 			replace = SPR_SLOPES_BASE;
 			break;
-		case 0x08: /* Canal graphics */
+		case 0x08: // Canal graphics
 			if (num != 65) {
 				grfmsg(1, "GraphicsNews: Canal graphics sprite count must be 65, skipping");
 				return;
 			}
 			replace = SPR_CANALS_BASE + 5;
 			break;
-		case 0x0D: /* Coast graphics */
+		case 0x0D: // Coast graphics
 			if (num != 16) {
 				grfmsg(1, "GraphicsNews: Coast graphics sprite count must be 16, skipping");
 				return;
 			}
 			_coast_base = _cur_spriteid;
 }
 static uint32 GetParamVal(byte param, uint32 *cond_val)
 {
 	switch (param) {
-		case 0x81: /* current year */
+		case 0x81: // current year
 			return clamp(_cur_year, ORIGINAL_BASE_YEAR, ORIGINAL_MAX_YEAR) - ORIGINAL_BASE_YEAR;
-		case 0x83: /* current climate, 0=temp, 1=arctic, 2=trop, 3=toyland */
+		case 0x83: // current climate, 0=temp, 1=arctic, 2=trop, 3=toyland
 			return _opt.landscape;
-		case 0x84: /* GRF loading stage */
+		case 0x84: // GRF loading stage
 			return (_cur_stage > GLS_INIT) | ((_cur_stage == GLS_ACTIVATION) << 9);
-		case 0x85: /* TTDPatch flags, only for bit tests */
+		case 0x85: // TTDPatch flags, only for bit tests
 			if (cond_val == NULL) {
 				/* Supported in Action 0x07 and 0x09, not 0x0D */
 				return 0;
 			} else {
 				uint32 param_val = _ttdpatch_flags[*cond_val / 0x20];
 				*cond_val %= 0x20;
 				return param_val;
 			}
-		case 0x86: /* road traffic side, bit 4 clear=left, set=right */
+		case 0x86: // road traffic side, bit 4 clear=left, set=right
 			return _opt.road_side << 4;
-		case 0x88: /* GRF ID check */
+		case 0x88: // GRF ID check
 			return 0;
-		case 0x8B: { /* TTDPatch version */
+		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;
 			return (major << 24) | (minor << 20) | (revision << 16) | build;
 		}
-		case 0x8D: /* TTD Version, 00=DOS, 01=Windows */
+		case 0x8D: // TTD Version, 00=DOS, 01=Windows
 			return !_use_dos_palette;
-		case 0x8E: /* Y-offset for train sprites */
+		case 0x8E: // Y-offset for train sprites
 			return _traininfo_vehicle_pitch;
-		case 0x92: /* Game mode */
+		case 0x92: // Game mode
 			return _game_mode;
-		case 0x9A: /* Always -1 */
+		case 0x9A: // Always -1
 			return UINT_MAX;
-		case 0x9D: /* TTD Platform, 00=TTDPatch, 01=OpenTTD */
+		case 0x9D: // TTD Platform, 00=TTDPatch, 01=OpenTTD
 			return 1;
-		case 0x9E: /* Miscellaneous GRF features */
+		case 0x9E: // Miscellaneous GRF features
 			return _misc_grf_features;
 		default:
 			/* GRF Parameter */
 			if (param < 0x80) return _cur_grffile->param[param];
 			return;
 		}
 		switch (condtype) {
 			/* Tests 6 to 10 are only for param 0x88, GRFID checks */
-			case 6: /* Is GRFID active? */
+			case 6: // Is GRFID active?
 				result = c->status == GCS_ACTIVATED;
 				break;
-			case 7: /* Is GRFID non-active? */
+			case 7: // Is GRFID non-active?
 				result = c->status != GCS_ACTIVATED;
 				break;
-			case 8: /* GRFID is not but will be active? */
+			case 8: // GRFID is not but will be active?
 				result = c->status == GCS_INITIALISED;
 				break;
-			case 9: /* GRFID is or will be active? */
+			case 9: // GRFID is or will be active?
 				result = c->status == GCS_ACTIVATED || c->status == GCS_INITIALISED;
 				break;
-			case 10: /* GRFID is not nor will be active */
+			case 10: // GRFID is not nor will be active
 				/* This is the only condtype that doesn't get ignored if the GRFID is not found */
 				result = c == NULL || c->flags == GCS_DISABLED || c->status == GCS_NOT_FOUND;
 				break;
 			default: grfmsg(1, "Unsupported GRF test %d. Ignoring", condtype); return;
 		 * we use -1 to indicate that all further
 		 * sprites should be skipped. */
 		_skip_sprites = -1;
 		/* If an action 8 hasn't been encountered yet, disable the grf. */
-		if (_cur_grfconfig->status != GCS_ACTIVATED) _cur_grfconfig->status = GCS_DISABLED;
+		if (_cur_stage != GLS_RESERVE && _cur_grfconfig->status != GCS_ACTIVATED) _cur_grfconfig->status = GCS_DISABLED;
 	}
 }
 /* Action 0x08 (GLS_FILESCAN) */
 	 * B num-sets      How many sets of sprites to replace.
 	 * Each set:
 	 * B num-sprites   How many sprites are in this set
 	 * W first-sprite  First sprite number to replace */
-	buf++; /* skip action byte */
+	buf++; // skip action byte
 	uint8 num_sets = grf_load_byte(&buf);
 	for (uint i = 0; i < num_sets; i++) {
 		uint8 num_sprites = grf_load_byte(&buf);
 		uint16 first_sprite = grf_load_word(&buf);
 	if (!check_length(len, 6, "GRFLoadError")) return;
 	/* For now we can only show one message per newgrf file. */
 	if (_cur_grfconfig->error != NULL) return;
-	buf++; /* Skip the action byte. */
+	buf++; // Skip the action byte.
 	byte severity   = grf_load_byte(&buf);
 	byte lang       = grf_load_byte(&buf);
 	byte message_id = grf_load_byte(&buf);
 	len -= 4;
 					uint8  op      = src1;
 					uint8  feature = GB(data, 8, 8);
 					uint16 count   = GB(data, 16, 16);
 					switch (feature) {
-						case 0x00: /* Trains */
+						case 0x00: // Trains
-						case 0x01: /* Road Vehicles */
+						case 0x01: // Road Vehicles
-						case 0x02: /* Ships */
+						case 0x02: // Ships
-						case 0x03: /* Aircraft */
+						case 0x03: // Aircraft
 						{
 							uint start = 0;
 							uint size  = 0;
 							uint shift = _vehshifts[feature];
 								src1 = UINT_MAX;
 							}
 							break;
 						}
-						case 0x08: /* General sprites */
+						case 0x08: // General sprites
 							switch (op) {
 								case 0:
 									/* Check if the allocated sprites will fit below the original sprite limit */
 									if (_cur_spriteid + count >= 16384) {
 										grfmsg(0, "GRM: Unable to allocate %d sprites; try changing NewGRF order", count);
 			} else {
 				res = (int32)src1 << src2;
 			}
 			break;
-		case 0x07: /* Bitwise AND */
+		case 0x07: // Bitwise AND
 			res = src1 & src2;
 			break;
-		case 0x08: /* Bitwise OR */
+		case 0x08: // Bitwise OR
 			res = src1 | src2;
 			break;
-		case 0x09: /* Unsigned division */
+		case 0x09: // Unsigned division
 			if (src2 == 0) {
 				res = src1;
 			} else {
 				res = src1 / src2;
 			}
 			break;
-		case 0x0A: /* Signed divison */
+		case 0x0A: // Signed divison
 			if (src2 == 0) {
 				res = src1;
 			} else {
 				res = (int32)src1 / (int32)src2;
 			}
 			break;
-		case 0x0B: /* Unsigned modulo */
+		case 0x0B: // Unsigned modulo
 			if (src2 == 0) {
 				res = src1;
 			} else {
 				res = src1 % src2;
 			}
 			break;
-		case 0x0C: /* Signed modulo */
+		case 0x0C: // Signed modulo
 			if (src2 == 0) {
 				res = src1;
 			} else {
 				res = (int32)src1 % (int32)src2;
 			}
 	switch (target) {
 		case 0x8E: // Y-Offset for train sprites
 			_traininfo_vehicle_pitch = res;
 			break;
-		// TODO implement
+		/* @todo implement */
 		case 0x8F: // Rail track type cost factors
 		case 0x93: // Tile refresh offset to left
 		case 0x94: // Tile refresh offset to right
 		case 0x95: // Tile refresh offset upwards
 		case 0x96: // Tile refresh offset downwards
 		case 0x97: // Snow line height
 		case 0x99: // Global ID offset
 			grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
 			break;
-		case 0x9E: /* Miscellaneous GRF features */
+		case 0x9E: // Miscellaneous GRF features
 			_misc_grf_features = res;
 			/* Set train list engine width */
 			_traininfo_vehicle_width = HASBIT(res, 3) ? 32 : 29;
 			break;
 	for (;;) {
 		uint32 tag  = grf_load_dword(&buf);
 		uint32 size = grf_load_dword(&buf);
 		switch (tag) {
-			case ' tmf': /* 'fmt ' */
+			case ' tmf': // 'fmt '
 				/* Audio format, must be 1 (PCM) */
 				if (grf_load_word(&buf) != 1) {
 					grfmsg(1, "LoadGRFSound: Invalid audio format");
 					return;
 				}
 				/* Consume any extra bytes */
 				for (; size > 16; size--) grf_load_byte(&buf);
 				break;
-			case 'atad': /* 'data' */
+			case 'atad': // 'data'
 				se->file_size    = size;
 				se->file_offset  = FioGetPos() - (len - (buf - buf_start)) + 1;
 				se->file_offset |= _file_index << 24;
 				/* Set default volume and priority */
 	                   |                                        (0 << 0x14)  // manualconvert
 	                   |       ((_patches.build_on_slopes ? 1 : 0) << 0x15)  // buildoncoasts
 	                   |                                        (1 << 0x16)  // canals
 	                   |                                        (1 << 0x17)  // newstartyear
 	                   |                                        (0 << 0x18)  // freighttrains
-	                   |                                        (0 << 0x19)  // newhouses
+	                   |                                        (1 << 0x19)  // newhouses
 	                   |                                        (1 << 0x1A)  // newbridges
 	                   |                                        (0 << 0x1B)  // newtownnames
 	                   |                                        (0 << 0x1C)  // moreanimations
 	                   |    ((_patches.wagon_speed_limits ? 1 : 0) << 0x1D)  // wagonspeedlimits
 	                   |                                        (1 << 0x1E)  // newshistory
 		free(file->stations);
 		file->stations = NULL;
 	}
 }
+static void ResetCustomHouses()
+{
+	GRFFile *file;
+	uint i;
+	for (file = _first_grffile; file != NULL; file = file->next) {
+		if (file->housespec == NULL) continue;
+		for (i = 0; i < HOUSE_MAX; i++) free(file->housespec[i]);
+		free(file->housespec);
+		file->housespec = NULL;
+	}
+}
 static void ResetNewGRF()
 {
 	GRFFile *next;
 	for (GRFFile *f = _first_grffile; f != NULL; f = next) {
 */
 static void ResetNewGRFData()
 {
 	CleanUpStrings();
-	// Copy/reset original engine info data
+	/* Copy/reset original engine info data */
 	memcpy(&_engine_info, &orig_engine_info, sizeof(orig_engine_info));
 	memcpy(&_rail_vehicle_info, &orig_rail_vehicle_info, sizeof(orig_rail_vehicle_info));
 	memcpy(&_ship_vehicle_info, &orig_ship_vehicle_info, sizeof(orig_ship_vehicle_info));
 	memcpy(&_aircraft_vehicle_info, &orig_aircraft_vehicle_info, sizeof(orig_aircraft_vehicle_info));
 	memcpy(&_road_vehicle_info, &orig_road_vehicle_info, sizeof(orig_road_vehicle_info));
-	// Copy/reset original bridge info data
+	/* Copy/reset original bridge info data
-	// First, free sprite table data
+	 * First, free sprite table data */
 	for (uint i = 0; i < MAX_BRIDGES; i++) {
 		if (_bridge[i].sprite_table != NULL) {
 			for (uint j = 0; j < 7; j++) free(_bridge[i].sprite_table[j]);
 			free(_bridge[i].sprite_table);
 		}
 	}
 	memcpy(&_bridge, &orig_bridge, sizeof(_bridge));
-	// Reset refit/cargo class data
+	/* Reset refit/cargo class data */
 	memset(&cargo_allowed, 0, sizeof(cargo_allowed));
 	memset(&cargo_disallowed, 0, sizeof(cargo_disallowed));
-	// Reset GRM reservations
+	/* Reset GRM reservations */
 	memset(&_grm_engines, 0, sizeof(_grm_engines));
-	// Unload sprite group data
+	/* Unload sprite group data */
 	UnloadWagonOverrides();
 	UnloadRotorOverrideSprites();
 	UnloadCustomEngineSprites();
 	UnloadCustomEngineNames();
 	ResetEngineListOrder();
-	// Reset price base data
+	/* Reset price base data */
 	ResetPriceBaseMultipliers();
 	/* Reset the curencies array */
 	ResetCurrencies();
-	// Reset station classes
+	/* Reset the house array */
+	ResetCustomHouses();
+	ResetHouses();
+	/* Reset station classes */
 	ResetStationClasses();
 	ResetCustomStations();
+	/* Reset the snowline table. */
+	ClearSnowLine();
 	/* Reset NewGRF files */
 	ResetNewGRF();
-	// Add engine type to engine data. This is needed for the refit precalculation.
+	/* Add engine type to engine data. This is needed for the refit precalculation. */
 	AddTypeToEngines();
 	/* Set up the default cargo types */
 	SetupCargoForClimate(_opt.landscape);
-	/* Generate default cargo translation table */
-	memset(_default_cargo_list, 0, sizeof(_default_cargo_list));
-	for (CargoID c = 0; c != NUM_CARGO; c++) {
-		const CargoSpec *cs = GetCargo(c);
-		if (cs->IsValid()) _default_cargo_list[cs->bitnum] = cs->label;
-	}
 	/* Reset misc GRF features and train list display variables */
 	_misc_grf_features = 0;
 	_traininfo_vehicle_pitch = 0;
 	_traininfo_vehicle_width = 29;
 	_have_2cc = false;
+	_have_newhouses = false;
 	_signal_base = 0;
 	_coast_base = 0;
 	InitializeSoundPool();
 	InitializeSpriteGroupPool();
 		/* Skip engine if not available in this climate */
 		if (!HASBIT(_engine_info[engine].climates, _opt.landscape)) continue;
 		uint32 mask = 0;
 		uint32 not_mask = 0;
-		uint32 xor_mask = _engine_info[engine].refit_mask;
+		uint32 xor_mask = 0;
+		if (_engine_info[engine].refit_mask != 0) {
+			const GRFFile *file = GetEngineGRF(engine);
+			if (file != NULL && file->cargo_max != 0) {
+				/* Apply cargo translation table to the refit mask */
+				uint num_cargo = min(32, file->cargo_max);
+				for (uint i = 0; i < num_cargo; i++) {
+					if (!HASBIT(_engine_info[engine].refit_mask, i)) continue;
+					CargoID c = GetCargoIDByLabel(file->cargo_list[i]);
+					if (c == CT_INVALID) continue;
+					SETBIT(xor_mask, c);
+				}
+			} else {
+				/* No cargo table, so use the cargo bitnum values */
+				for (CargoID c = 0; c < NUM_CARGO; c++) {
+					const CargoSpec *cs = GetCargo(c);
+					if (!cs->IsValid()) continue;
+					if (HASBIT(_engine_info[engine].refit_mask, cs->bitnum)) SETBIT(xor_mask, c);
+				}
+			}
+		}
 		if (cargo_allowed[engine] != 0) {
-			// Build up the list of cargo types from the set cargo classes.
+			/* Build up the list of cargo types from the set cargo classes. */
 			for (CargoID i = 0; i < NUM_CARGO; i++) {
 				const CargoSpec *cs = GetCargo(i);
 				if (cargo_allowed[engine]    & cs->classes) SETBIT(mask,     i);
 				if (cargo_disallowed[engine] & cs->classes) SETBIT(not_mask, i);
 			}
 		} else {
-			// Don't apply default refit mask to wagons or engines with no capacity
+			/* Don't apply default refit mask to wagons or engines with no capacity */
 			if (xor_mask == 0 && (
 						GetEngine(engine)->type != VEH_TRAIN || (
 							RailVehInfo(engine)->capacity != 0 &&
 							RailVehInfo(engine)->railveh_type != RAILVEH_WAGON
 						)
 				}
 			}
 		}
 		_engine_info[engine].refit_mask = ((mask & ~not_mask) ^ xor_mask) & _cargo_mask;
-		if (_engine_info[engine].refit_mask == 0) continue;
 		/* 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) {
 			case VEH_TRAIN: {
 				RailVehicleInfo *rvi = &_rail_vehicle_info[engine];
 				break;
 			}
 		}
 	}
 }
+/** Add all new houses to the house array. House properties can be set at any
+* time in the GRF file, so we can only add a house spec to the house array
+* after the file has finished loading. We also need to check the dates, due to
+* the TTDPatch behaviour described below that we need to emulate. */
+static void FinaliseHouseArray()
+{
+	/* If there are no houses with start dates before 1930, then all houses
+	 * with start dates of 1930 have them reset to 0. This is in order to be
+	 * compatible with TTDPatch, where if no houses have start dates before
+	 * 1930 and the date is before 1930, the game pretends that this is 1930.
+	 * If there have been any houses defined with start dates before 1930 then
+	 * the dates are left alone. */
+	bool reset_dates = true;
+	for (GRFFile *file = _first_grffile; file != NULL; file = file->next) {
+		if (file->housespec == NULL) continue;
+		for (int i = 0; i < HOUSE_MAX; i++) {
+			HouseSpec *hs = file->housespec[i];
+			if (hs != NULL) {
+				SetHouseSpec(hs);
+				if (hs->min_date < 1930) reset_dates = false;
+			}
+		}
+	}
+	if (reset_dates) {
+		for (int i = NEW_HOUSE_OFFSET; i < HOUSE_MAX; i++) {
+			HouseSpec *hs = GetHouseSpecs(i);
+			if (hs->enabled && hs->min_date == 1930) hs->min_date = 0;
+		}
+	}
+}
+/** Each cargo string needs to be mapped from TTDPatch to OpenTTD string IDs.
+* This is done after loading so that strings from Action 4 will be mapped
+* properly. */
+static void MapNewCargoStrings()
+{
+	for (CargoID c = 0; c < NUM_CARGO; c++) {
+		CargoSpec *cs = &_cargo[c];
+		/* Don't map if the cargo is unavailable or not from NewGRF */
+		if (!cs->IsValid() || cs->grfid == 0) continue;
+		cs->name         = MapGRFStringID(cs->grfid, cs->name);
+		cs->name_plural  = MapGRFStringID(cs->grfid, cs->name_plural);
+		cs->units_volume = MapGRFStringID(cs->grfid, cs->units_volume);
+		cs->quantifier   = MapGRFStringID(cs->grfid, cs->quantifier);
+		cs->abbrev       = MapGRFStringID(cs->grfid, cs->abbrev);
+	}
+}
 /* Here we perform initial decoding of some special sprites (as are they
 * described at http://www.ttdpatch.net/src/newgrf.txt, but this is only a very
 * partial implementation yet). */
 /* XXX: We consider GRF files trusted. It would be trivial to exploit OTTD by
 	 * --pasky */
 	/* 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, FeatureChangeInfo, },
+		/* 0x00 */ { NULL,     SafeChangeInfo, NULL,       InitChangeInfo, ReserveChangeInfo, FeatureChangeInfo, },
-		/* 0x01 */ { NULL,     GRFUnsafe, NULL,            NULL,       NewSpriteSet, },
+		/* 0x01 */ { NULL,     GRFUnsafe, NULL,            NULL,           NULL,              NewSpriteSet, },
-		/* 0x02 */ { NULL,     GRFUnsafe, NULL,            NULL,       NewSpriteGroup, },
+		/* 0x02 */ { NULL,     GRFUnsafe, NULL,            NULL,           NULL,              NewSpriteGroup, },
-		/* 0x03 */ { NULL,     GRFUnsafe, NULL,            NULL,       FeatureMapSpriteGroup, },
+		/* 0x03 */ { NULL,     GRFUnsafe, NULL,            NULL,           NULL,              FeatureMapSpriteGroup, },
-		/* 0x04 */ { NULL,     NULL,      NULL,            NULL,       FeatureNewName, },
+		/* 0x04 */ { NULL,     NULL,      NULL,            NULL,           NULL,              FeatureNewName, },
-		/* 0x05 */ { NULL,     NULL,      NULL,            NULL,       GraphicsNew, },
+		/* 0x05 */ { NULL,     NULL,      NULL,            NULL,           NULL,              GraphicsNew, },
-		/* 0x06 */ { NULL,     NULL,      NULL,            CfgApply,   CfgApply, },
+		/* 0x06 */ { NULL,     NULL,      NULL,            CfgApply,       CfgApply,          CfgApply, },
-		/* 0x07 */ { NULL,     NULL,      NULL,            NULL,       SkipIf, },
+		/* 0x07 */ { NULL,     NULL,      NULL,            NULL,           SkipIf,            SkipIf, },
-		/* 0x08 */ { ScanInfo, NULL,      NULL,            GRFInfo,    GRFInfo, },
+		/* 0x08 */ { ScanInfo, NULL,      NULL,            GRFInfo,        NULL,              GRFInfo, },
-		/* 0x09 */ { NULL,     NULL,      NULL,            SkipIf,     SkipIf, },
+		/* 0x09 */ { NULL,     NULL,      NULL,            SkipIf,         SkipIf,            SkipIf, },
-		/* 0x0A */ { NULL,     NULL,      NULL,            NULL,       SpriteReplace, },
+		/* 0x0A */ { NULL,     NULL,      NULL,            NULL,           NULL,              SpriteReplace, },
-		/* 0x0B */ { NULL,     NULL,      NULL,            GRFLoadError, GRFLoadError, },
+		/* 0x0B */ { NULL,     NULL,      NULL,            GRFLoadError,   GRFLoadError,      GRFLoadError, },
-		/* 0x0C */ { NULL,     NULL,      NULL,            GRFComment, GRFComment, },
+		/* 0x0C */ { NULL,     NULL,      NULL,            GRFComment,     NULL,              GRFComment, },
-		/* 0x0D */ { NULL,     SafeParamSet, NULL,         ParamSet,   ParamSet, },
+		/* 0x0D */ { NULL,     SafeParamSet, NULL,         ParamSet,       ParamSet,          ParamSet, },
-		/* 0x0E */ { NULL,     SafeGRFInhibit, NULL,       GRFInhibit, GRFInhibit, },
+		/* 0x0E */ { NULL,     SafeGRFInhibit, NULL,       GRFInhibit,     GRFInhibit,        GRFInhibit, },
-		/* 0x0F */ { NULL,     NULL,      NULL,            NULL,       NULL, },
+		/* 0x0F */ { NULL,     NULL,      NULL,            NULL,           NULL,              NULL, },
-		/* 0x10 */ { NULL,     NULL,      DefineGotoLabel, NULL,       NULL, },
+		/* 0x10 */ { NULL,     NULL,      DefineGotoLabel, NULL,           NULL,              NULL, },
-		/* 0x11 */ { NULL,     GRFUnsafe, NULL,            NULL,       GRFSound, },
+		/* 0x11 */ { NULL,     GRFUnsafe, NULL,            NULL,           NULL,              GRFSound, },
-		/* 0x12 */ { NULL,     NULL,      NULL,            NULL,       LoadFontGlyph, },
+		/* 0x12 */ { NULL,     NULL,      NULL,            NULL,           NULL,              LoadFontGlyph, },
-		/* 0x13 */ { NULL,     NULL,      NULL,            NULL,       TranslateGRFStrings, },
+		/* 0x13 */ { NULL,     NULL,      NULL,            NULL,           NULL,              TranslateGRFStrings, },
 	};
 	byte* buf;
 	if (_preload_sprite == NULL) {
 	}
 }
 void InitDepotWindowBlockSizes();
+static void AfterLoadGRFs()
+{
+	/* Pre-calculate all refit masks after loading GRF files. */
+	CalculateRefitMasks();
+	/* Set the block size in the depot windows based on vehicle sprite sizes */
+	InitDepotWindowBlockSizes();
+	/* Add all new houses to the house array. */
+	FinaliseHouseArray();
+	/* Map cargo strings. This is a separate step because cargos are
+	 * loaded before strings... */
+	MapNewCargoStrings();
+}
 void LoadNewGRF(uint load_index, uint file_index)
 {
 	InitializeGRFSpecial();
 	ResetNewGRFData();
 		_cur_stage = stage;
 		_cur_spriteid = load_index;
 		for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
 			if (c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND) continue;
-			// TODO usererror()
+			/* @todo usererror() */
 			if (!FioCheckFileExists(c->filename)) error("NewGRF file is missing '%s'", c->filename);
 			if (stage == GLS_LABELSCAN) InitNewGRFFile(c, _cur_spriteid);
 			LoadNewGRFFile(c, slot++, stage);
 			if (stage == GLS_ACTIVATION) {
 				DEBUG(sprite, 2, "Currently %i sprites are loaded", _cur_spriteid);
 			}
 		}
 	}
-	// Pre-calculate all refit masks after loading GRF files
+	/* Call any functions that should be run after GRFs have been loaded. */
-	CalculateRefitMasks();
+	AfterLoadGRFs();
+}
-	/* Set the block size in the depot windows based on vehicle sprite sizes */
-	InitDepotWindowBlockSizes();
-}

branch	cpp_gui
changeset 6303	84c215fc8eb8
parent 6298	c30fe89622df
child 6307	f40e88cff863