openttd-ottdgrfs: comparison src/newgrf.cpp

equal deleted inserted replaced

-:7c8ec33959b1
+:4b5241e5dd10
 #include "sound.h"
 #include "newgrf_config.h"
 #include "newgrf_sound.h"
 #include "newgrf_spritegroup.h"
 #include "helpers.hpp"
+#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.
 *
 /* Used by Action 0x06 to preload a pseudo sprite and modify its content */
 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 */
+static const uint _default_cargo_max = 27;
+static CargoLabel _default_cargo_list[_default_cargo_max];
 typedef enum GrfDataType {
 	GDT_SOUND,
 } GrfDataType;
 		case 4: return grf_load_dword(buf);
 		default:
 			NOT_REACHED();
 			return 0;
 	}
+}
+static const char *grf_load_string(byte **buf, size_t max_len)
+{
+	const char *string   = *(const char **)buf;
+	size_t string_length = ttd_strnlen(string, max_len);
+	if (string_length == max_len) {
+		/* String was not NUL terminated, so make sure it is now. */
+		(*buf)[string_length - 1] = '\0';
+		grfmsg(7, "String was not terminated with a zero byte.");
+	} else {
+		/* Increase the string length to include the NUL byte. */
+		string_length++;
+	}
+	*buf += string_length;
+	return string;
 }
 static GRFFile *GetFileByGRFID(uint32 grfid)
 {
 	GRFFile *file;
 				uint8 ctype = grf_load_byte(&buf);
 				if (ctype < NUM_CARGO) {
 					rvi[i].cargo_type = ctype;
 				} else {
-					grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, ignoring", ctype);
+					rvi[i].cargo_type = CT_INVALID;
+					grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, using first refittable", ctype);
 				}
 			}
 			break;
 		case 0x16: /* Weight */
 				uint8 cargo = grf_load_byte(&buf);
 				if (cargo < NUM_CARGO) {
 					rvi[i].cargo_type = cargo;
 				} else {
-					grfmsg(2, "RoadVehicleChangeInfo: Invalid cargo type %d, ignoring", cargo);
+					rvi[i].cargo_type = CT_INVALID;
+					grfmsg(2, "RoadVehicleChangeInfo: Invalid cargo type %d, using first refittable", cargo);
 				}
 			}
 			break;
 		case 0x11: /* Cost factor */
 		case 0x0C: /* Cargo type */
 			FOR_EACH_OBJECT {
 				uint8 cargo = grf_load_byte(&buf);
-				// XXX: Need to consult this with patchman yet.
-#if 0
-				// Documentation claims this is already the
-				// per-landscape cargo type id, but newships.grf
-				// assume otherwise.
-				cargo = local_cargo_id_ctype[cargo];
-#endif
 				if (cargo < NUM_CARGO) {
 					svi[i].cargo_type = cargo;
 				} else {
-					grfmsg(2, "ShipVehicleChangeInfo: Invalid cargo type %d, ignoring", cargo);
+					svi[i].cargo_type = CT_INVALID;
+					grfmsg(2, "ShipVehicleChangeInfo: Invalid cargo type %d, using first refittable", cargo);
 				}
 			}
 			break;
 		case 0x0D: /* Cargo capacity */
 					grfmsg(1, "GlobalVarChangeInfo: Price %d out of range, ignoring", price);
 				}
 			}
 			break;
+		case 0x09: /* Cargo translation table */
+			/* This is loaded during the initialisation stage, so just skip it here. */
+			/* Each entry is 4 bytes. */
+			buf += numinfo * 4;
+			break;
 		case 0x0A: // Currency display names
 			FOR_EACH_OBJECT {
 				uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
 				StringID newone = GetGRFStringID(_cur_grffile->grfid, grf_load_word(&buf));
 					grfmsg(1, "GlobalVarChangeInfo: Euro intro date %d out of range, ignoring", curidx);
 				}
 			}
 			break;
-		case 0x09: // Cargo translation table
 		case 0x10: // 12 * 32 * B Snow line height table
 		default:
 			ret = true;
 	}
 	uint8 feature;
 	uint8 numprops;
 	uint8 numinfo;
 	uint8 index;
+	if (len == 1) {
+		grfmsg(8, "Silently ignoring one-byte special sprite 0x00");
+		return;
+	}
 	if (!check_length(len, 6, "SafeChangeInfo")) return;
 	buf++;
 	feature  = grf_load_byte(&buf);
 	numprops = grf_load_byte(&buf);
 	numinfo  = grf_load_byte(&buf);
 	SETBIT(_cur_grfconfig->flags, GCF_UNSAFE);
 	/* Skip remainder of GRF */
 	_skip_sprites = -1;
+}
+/* Action 0x00 (GLS_INIT) */
+static void InitChangeInfo(byte *buf, int len)
+{
+	byte *bufend = buf + len;
+	uint8 feature;
+	uint8 numprops;
+	uint8 numinfo;
+	uint8 index;
+	if (len == 1) {
+		grfmsg(8, "Silently ignoring one-byte special sprite 0x00");
+		return;
+	}
+	if (!check_length(len, 6, "InitChangeInfo")) return;
+	buf++;
+	feature  = grf_load_byte(&buf);
+	numprops = grf_load_byte(&buf);
+	numinfo  = grf_load_byte(&buf);
+	index    = grf_load_byte(&buf);
+	while (numprops-- && buf < bufend) {
+		uint8 prop = grf_load_byte(&buf);
+		switch (feature) {
+			case GSF_GLOBALVAR:
+				switch (prop) {
+					case 0x09: /* Cargo Translation Table */
+						if (index != 0) {
+							grfmsg(1, "InitChangeInfo: Cargo translation table must start at zero");
+							return;
+						}
+						free(_cur_grffile->cargo_list);
+						_cur_grffile->cargo_max = numinfo;
+						_cur_grffile->cargo_list = MallocT<CargoLabel>(numinfo);
+						int i;
+						FOR_EACH_OBJECT {
+							CargoLabel cl = grf_load_dword(&buf);
+							_cur_grffile->cargo_list[i] = BSWAP32(cl);
+						}
+						break;
+				}
+				break;
+		}
+	}
 }
 #undef FOR_EACH_OBJECT
 /**
 	}
 	_cur_grffile->spritegroups[setid] = group;
 }
+static CargoID TranslateCargo(uint8 feature, uint8 ctype)
+{
+	/* Special cargo types for purchase list and stations */
+	if (feature == GSF_STATION && ctype == 0xFE) return CT_DEFAULT_NA;
+	if (ctype == 0xFF) return CT_PURCHASE;
+	/* 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)) {
+		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);
+		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];
+	if (cl == 0) {
+		grfmsg(5, "FeatureMapSpriteGroup: Cargo type %d not available in this climate, skipping.", ctype);
+		return CT_INVALID;
+	}
+	ctype = GetCargoIDByLabel(cl);
+	if (ctype == CT_INVALID) {
+		grfmsg(5, "FeatureMapSpriteGroup: Cargo '%c%c%c%c' unsupported, skipping.", GB(cl, 24, 8), GB(cl, 16, 8), GB(cl, 8, 8), GB(cl, 0, 8));
+		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;
+}
 /* Action 0x03 */
 static void FeatureMapSpriteGroup(byte *buf, int len)
 {
 	/* <03> <feature> <n-id> <ids>... <num-cid> [<cargo-type> <cid>]... <def-cid>
 	 * id-list    := [<id>] [id-list]
 					grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping",
 					       groupid, _cur_grffile->spritegroups_count);
 					return;
 				}
-				if (ctype == 0xFE) ctype = GC_DEFAULT_NA;
+				ctype = TranslateCargo(feature, ctype);
-				if (ctype == 0xFF) ctype = GC_PURCHASE;
+				if (ctype == CT_INVALID) continue;
-				if (ctype >= NUM_GLOBAL_CID) {
-					grfmsg(1, "FeatureMapSpriteGroup: Cargo type %d out of range, skipping.", ctype);
-					continue;
-				}
 				statspec->spritegroup[ctype] = _cur_grffile->spritegroups[groupid];
 			}
 		}
 			for (i = 0; i < idcount; i++) {
 				uint8 stid = buf[3 + i];
 				StationSpec *statspec = _cur_grffile->stations[stid];
-				statspec->spritegroup[GC_DEFAULT] = _cur_grffile->spritegroups[groupid];
+				statspec->spritegroup[CT_DEFAULT] = _cur_grffile->spritegroups[groupid];
 				statspec->grfid = _cur_grffile->grfid;
 				statspec->localidx = stid;
 				SetCustomStationSpec(statspec);
 			}
 		}
 			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 (ctype == GC_INVALID) ctype = GC_PURCHASE;
+			ctype = TranslateCargo(feature, ctype);
+			if (ctype == CT_INVALID) continue;
-			if (ctype >= NUM_GLOBAL_CID) {
-				grfmsg(1, "FeatureMapSpriteGroup: Cargo type %d out of range, skipping.", ctype);
-				continue;
-			}
 			if (wagover) {
 				SetWagonOverrideSprites(engine, ctype, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
 			} else {
 				SetCustomEngineSprites(engine, ctype, _cur_grffile->spritegroups[groupid]);
 				 * 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, GC_DEFAULT, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
+					SetWagonOverrideSprites(engine, CT_DEFAULT, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
 				}
 			} else {
-				SetCustomEngineSprites(engine, GC_DEFAULT, _cur_grffile->spritegroups[groupid]);
+				SetCustomEngineSprites(engine, CT_DEFAULT, _cur_grffile->spritegroups[groupid]);
 				SetEngineGRF(engine, _cur_grffile);
 				last_engines[i] = engine;
 			}
 		}
 	}
 	uint8 feature;
 	uint8 lang;
 	uint8 num;
 	uint16 id;
 	uint16 endid;
-	const char* name;
 	bool new_scheme = _cur_grffile->grf_version >= 7;
 	bool generic;
 	if (!check_length(len, 6, "FeatureNewName")) return;
 	buf++;
 	endid    = id + num;
 	grfmsg(6, "FeatureNewName: About to rename engines %d..%d (feature %d) in language 0x%02X",
 	               id, endid, feature, lang);
-	name = (const char*)buf; /*transfer read value*/
 	len -= generic ? 6 : 5;
 	for (; id < endid && len > 0; id++) {
-		size_t ofs = strlen(name) + 1;
+		const char *name   = grf_load_string(&buf, len);
+		size_t name_length = strlen(name) + 1;
-		if (ofs < 128) {
+		len -= (int)name_length;
+		if (name_length == 1) {
+			grfmsg(7, "FeatureNewName: Can't add empty name");
+		} else if (name_length > 127) {
+			grfmsg(7, "FeatureNewName: Too long a name (%d)", name_length);
+		} else {
 			grfmsg(8, "FeatureNewName: %d <- %s", id, name);
 			switch (feature) {
 				case GSF_TRAIN:
 				case GSF_ROAD:
 				default :
 					grfmsg(7, "FeatureNewName: Unsupported feature (0x%02X)", feature);
 					break;
 #endif
 			}
-		} else {
-			/* ofs is the string length + 1, so if the string is empty, ofs
-			 * is 1 */
-			if (ofs == 1) {
-				grfmsg(7, "FeatureNewName: Can't add empty name");
-			} else {
-				grfmsg(7, "FeatureNewName: Too long a name (%d)", ofs);
-			}
 		}
-		name += ofs;
-		len -= (int)ofs;
 	}
 }
 /* Action 0x05 */
 static void GraphicsNew(byte *buf, int len)
 	if (_skip_sprites == 0) {
 		/* Zero means there are no sprites to skip, so
 		 * 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 (!HASBIT(_cur_grfconfig->flags, GCF_ACTIVATED)) SETBIT(_cur_grfconfig->flags, GCF_DISABLED);
 	}
 }
 /* Action 0x08 (GLS_FILESCAN) */
 	const char *name;
 	if (!check_length(len, 8, "GRFInfo")) return; buf++;
 	version = grf_load_byte(&buf);
 	grfid = grf_load_dword(&buf);
-	name = (const char*)buf;
+	name = grf_load_string(&buf, len - 6);
 	_cur_grffile->grfid = grfid;
 	_cur_grffile->grf_version = version;
 	SETBIT(_cur_grfconfig->flags, GCF_ACTIVATED);
 		}
 	}
 }
 /* Action 0x0B */
-static void GRFError(byte *buf, int len)
+static void GRFLoadError(byte *buf, int len)
 {
 	/* <0B> <severity> <language-id> <message-id> [<message...> 00] [<data...>] 00 [<parnum>]
 	 *
 	 * B severity      00: notice, contine loading grf file
 	 *                 01: warning, continue loading grf file
 	 * B language-id   see action 4, use 1F for built-in error messages
 	 * B message-id    message to show, see below
 	 * S message       for custom messages (message-id FF), text of the message
 	 *                 not present for built-in messages.
 	 * V data          additional data for built-in (or custom) messages
-	 * B parnum        see action 6, only used with built-in message 03 */
+	 * B parnum        parameter numbers to be shown in the message (maximum of 2) */
-	/* TODO: For now we just show the message, sometimes incomplete and never translated. */
+	static const StringID msgstr[] = {
-	static const char *const msgstr[] = {
+		STR_NEWGRF_ERROR_VERSION_NUMBER,
-		"%sRequires at least pseudo-TTDPatch version %s",
+		STR_NEWGRF_ERROR_DOS_OR_WINDOWS,
-		"%sThis file is for %s version of TTD",
+		STR_NEWGRF_ERROR_UNSET_SWITCH,
-		"%sDesigned to be used with %s",
+		STR_NEWGRF_ERROR_INVALID_PARAMETER,
-		"%sInvalid parameter %s",
+		STR_NEWGRF_ERROR_LOAD_BEFORE,
-		"%sMust be loaded before %s",
+		STR_NEWGRF_ERROR_LOAD_AFTER
-		"%sMust be loaded after %s",
-		"%s%s"
 	};
-	static const char *const sevstr[] = {
+	static const StringID sevstr[] = {
-		"",
+		STR_NEWGRF_ERROR_MSG_INFO,
-		"Warning: ",
+		STR_NEWGRF_ERROR_MSG_WARNING,
-		"Error: ",
+		STR_NEWGRF_ERROR_MSG_ERROR,
-		"Fatal: ",
+		STR_NEWGRF_ERROR_MSG_FATAL
 	};
-	uint8 sevid;
-	uint8 msgid;
+	/* AddGRFString expects the string to be referred to by an id in the newgrf
+	 * file. Errors messages are never referred to however, so invent ids that
-	if (!check_length(len, 6, "GRFError")) return;
+	 * are unlikely to be reached in a newgrf file so they don't overwrite
-	sevid = buf[1];
+	 * anything else. */
-	msgid = buf[3];
+	enum {
+		MESSAGE_STRING_ID = MAX_UVALUE(StringID) - 1,
-	// Undocumented TTDPatch feature.
+		MESSAGE_DATA_ID   = MAX_UVALUE(StringID)
-	if (!HASBIT(sevid, 7) && _cur_stage < GLS_ACTIVATION) {
+	};
-		grfmsg(7, "Skipping non-fatal GRFError in stage 1");
+	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. */
+	byte severity   = grf_load_byte(&buf);
+	byte lang       = grf_load_byte(&buf);
+	byte message_id = grf_load_byte(&buf);
+	len -= 4;
+	/* Skip the error until the activation stage unless bit 7 of the severity
+	 * is set. */
+	if (!HASBIT(severity, 7) && _cur_stage < GLS_ACTIVATION) {
+		grfmsg(7, "Skipping non-fatal GRFLoadError in stage 1");
 		return;
 	}
+	CLRBIT(severity, 7);
-	sevid = GB(sevid, 0, 2);
-	grfmsg(0,  msgstr[(msgid == 0xFF) ? lengthof(msgstr) - 1 : msgid], sevstr[sevid], &buf[4]);
+	if (severity >= lengthof(sevstr)) {
+		grfmsg(7, "GRFLoadError: Invalid severity id %d. Setting to 2 (non-fatal error).", severity);
+		severity = 2;
+	} else if (severity == 3) {
+		/* This is a fatal error, so make sure the GRF is deactivated and no
+		 * more of it gets loaded. */
+		SETBIT(_cur_grfconfig->flags, GCF_DISABLED);
+		CLRBIT(_cur_grfconfig->flags, GCF_ACTIVATED);
+		_skip_sprites = -1;
+	}
+	if (message_id >= lengthof(msgstr) && message_id != 0xFF) {
+		grfmsg(7, "GRFLoadError: Invalid message id.");
+		return;
+	}
+	if (len <= 1) {
+		grfmsg(7, "GRFLoadError: No message data supplied.");
+		return;
+	}
+	bool new_scheme = _cur_grffile->grf_version >= 7;
+	GRFError *error = CallocT<GRFError>(1);
+	error->severity = sevstr[severity];
+	if (message_id == 0xFF) {
+		/* This is a custom error message. */
+		const char *message = grf_load_string(&buf, len);
+		len -= (strlen(message) + 1);
+		error->message = AddGRFString(_cur_grffile->grfid, MESSAGE_STRING_ID, lang, new_scheme, message, STR_UNDEFINED);
+	} else {
+		error->message = msgstr[message_id];
+	}
+	if (len > 0) {
+		const char *data = grf_load_string(&buf, len);
+		len -= (strlen(data) + 1);
+		error->data = AddGRFString(_cur_grffile->grfid, MESSAGE_DATA_ID, lang, new_scheme, data, STR_UNDEFINED);
+	}
+	/* Only two parameter numbers can be used in the string. */
+	uint i = 0;
+	for (; i < 2 && len > 0; i++) {
+		error->param_number[i] = grf_load_byte(&buf);
+		len--;
+	}
+	error->num_params = i;
+	_cur_grfconfig->error = error;
 }
 /* Action 0x0C */
 static void GRFComment(byte *buf, int len)
 {
 	/* <0C> [<ignored...>]
 	 *
 	 * V ignored       Anything following the 0C is ignored */
-	static char comment[256];
 	if (len == 1) return;
-	ttd_strlcpy(comment, (char*)(buf + 1), minu(sizeof(comment), len));
+	int text_len = len - 1;
-	grfmsg(2, "GRFComment: %s", comment);
+	const char *text = (const char*)(buf + 1);
+	grfmsg(2, "GRFComment: %.*s", text_len, text);
 }
 /* Action 0x0D (GLS_SAFETYSCAN) */
 static void SafeParamSet(byte *buf, int len)
 {
 	ResetNewGRF();
 	// 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;
 	free(_cur_grffile->spritegroups);
 	_cur_grffile->spritegroups = NULL;
 	_cur_grffile->spritegroups_count = 0;
 }
+static void BuildCargoTranslationMap()
+{
+	memset(_cur_grffile->cargo_map, 0xFF, sizeof(_cur_grffile->cargo_map));
+	for (CargoID c = 0; c < NUM_CARGO; c++) {
+		const CargoSpec *cs = GetCargo(c);
+		if (!cs->IsValid()) continue;
+		if (_cur_grffile->cargo_max == 0) {
+			/* Default translation table, so just a straight mapping to bitnum */
+			_cur_grffile->cargo_map[c] = cs->bitnum;
+		} else {
+			/* Check the translation table for this cargo's label */
+			for (uint i = 0; i < _cur_grffile->cargo_max; i++) {
+				if (cs->label == _cur_grffile->cargo_list[i]) {
+					_cur_grffile->cargo_map[c] = i;
+					break;
+				}
+			}
+		}
+	}
+}
 static void InitNewGRFFile(const GRFConfig *config, int sprite_offset)
 {
 	GRFFile *newfile;
 	newfile = GetFileByFilename(config->filename);
 		_cur_grffile = newfile;
 	}
 }
-/** Bitmasked values of what type of cargo is refittable for the given vehicle-type.
+/** List of what cargo labels are refittable for the given the vehicle-type.
-* This coupled with the landscape information (_landscape_global_cargo_mask) gives
+* Only currently active labels are applied. */
-* us exactly what is refittable and what is not */
+static const CargoLabel _default_refitmasks_rail[] = {
-#define MC(cargo) (1 << cargo)
+	'PASS', 'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD',
-static const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {
+	'IORE', 'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE',
-	/* Trains */
+	'WATR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
-	MC(GC_PASSENGERS) | MC(GC_COAL)      | MC(GC_MAIL)   | MC(GC_LIVESTOCK) | MC(GC_GOODS)        | MC(GC_GRAIN)      | MC(GC_WOOD)    | MC(GC_IRON_ORE)    |
+	'PLST', 'FZDR',
-	MC(GC_STEEL)      | MC(GC_VALUABLES) | MC(GC_PAPER)  | MC(GC_FOOD)      | MC(GC_FRUIT)        | MC(GC_COPPER_ORE) | MC(GC_WATER)   | MC(GC_SUGAR)       |
+	0 };
-	MC(GC_TOYS)       | MC(GC_CANDY)     | MC(GC_TOFFEE) | MC(GC_COLA)      | MC(GC_COTTON_CANDY) | MC(GC_BUBBLES)    | MC(GC_PLASTIC) | MC(GC_FIZZY_DRINKS),
-	/* Road vehicles (not refittable by default) */
+static const CargoLabel _default_refitmasks_road[] = {
-	0,
+	0 };
-	/* Ships */
-	MC(GC_COAL)  | MC(GC_MAIL)   | MC(GC_LIVESTOCK) | MC(GC_GOODS)        | MC(GC_GRAIN)   | MC(GC_WOOD)    | MC(GC_IRON_ORE) | MC(GC_STEEL) | MC(GC_VALUABLES) |
+static const CargoLabel _default_refitmasks_ships[] = {
-	MC(GC_PAPER) | MC(GC_FOOD)   | MC(GC_FRUIT)     | MC(GC_COPPER_ORE)   | MC(GC_WATER)   | MC(GC_RUBBER)  | MC(GC_SUGAR)    | MC(GC_TOYS)  | MC(GC_BATTERIES) |
+	'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD', 'IORE',
-	MC(GC_CANDY) | MC(GC_TOFFEE) | MC(GC_COLA)      | MC(GC_COTTON_CANDY) | MC(GC_BUBBLES) | MC(GC_PLASTIC) | MC(GC_FIZZY_DRINKS),
+	'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE', 'WATR',
-	/* Aircraft */
+	'RUBR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
-	MC(GC_PASSENGERS) | MC(GC_MAIL)  | MC(GC_GOODS)  | MC(GC_VALUABLES) | MC(GC_FOOD)         | MC(GC_FRUIT)   | MC(GC_SUGAR)   | MC(GC_TOYS) |
+	'PLST', 'FZDR',
-	MC(GC_BATTERIES)  | MC(GC_CANDY) | MC(GC_TOFFEE) | MC(GC_COLA)      | MC(GC_COTTON_CANDY) | MC(GC_BUBBLES) | MC(GC_PLASTIC) | MC(GC_FIZZY_DRINKS),
+	0 };
-	/* Special/Disaster */
-	0,0
+static const CargoLabel _default_refitmasks_aircraft[] = {
+	'PASS', 'MAIL', 'GOOD', 'VALU', 'GOLD', 'DIAM', 'FOOD', 'FRUT', 'SUGR',
+	'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL', 'PLST', 'FZDR',
+	0 };
+static const CargoLabel *_default_refitmasks[] = {
+	_default_refitmasks_rail,
+	_default_refitmasks_road,
+	_default_refitmasks_ships,
+	_default_refitmasks_aircraft,
 };
-#undef MC
 /**
 * Precalculate refit masks from cargo classes for all vehicles.
 */
 		uint32 xor_mask = _engine_info[engine].refit_mask;
 		byte i;
 		if (cargo_allowed[engine] != 0) {
 			// Build up the list of cargo types from the set cargo classes.
-			for (i = 0; i < lengthof(cargo_classes); i++) {
+			for (i = 0; i < NUM_CARGO; i++) {
-				if (HASBIT(cargo_allowed[engine], i)) mask |= cargo_classes[i];
+				const CargoSpec *cs = GetCargo(i);
-				if (HASBIT(cargo_disallowed[engine], i)) not_mask |= cargo_classes[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
 			if (xor_mask == 0 && (
 						GetEngine(engine)->type != VEH_Train || (
 							RailVehInfo(engine)->capacity != 0 &&
 							RailVehInfo(engine)->railveh_type != RAILVEH_WAGON
 						)
 					)) {
-				xor_mask = _default_refitmasks[GetEngine(engine)->type];
+				const CargoLabel *cl = _default_refitmasks[GetEngine(engine)->type];
+				for (uint i = 0;; i++) {
+					if (cl[i] == 0) break;
+					CargoID cargo = GetCargoIDByLabel(cl[i]);
+					if (cargo == CT_INVALID) continue;
+					SETBIT(xor_mask, cargo);
+				}
 			}
 		}
-		_engine_info[engine].refit_mask = ((mask & ~not_mask) ^ xor_mask) & _landscape_global_cargo_mask[_opt.landscape];
+		_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];
+				if (rvi->cargo_type == CT_INVALID) rvi->cargo_type = FindFirstRefittableCargo(engine);
+				break;
+			}
+			case VEH_Road: {
+				RoadVehicleInfo *rvi = &_road_vehicle_info[engine - ROAD_ENGINES_INDEX];
+				if (rvi->cargo_type == CT_INVALID) rvi->cargo_type = FindFirstRefittableCargo(engine);
+				break;
+			}
+			case VEH_Ship: {
+				ShipVehicleInfo *svi = &_ship_vehicle_info[engine - SHIP_ENGINES_INDEX];
+				if (svi->cargo_type == CT_INVALID) svi->cargo_type = FindFirstRefittableCargo(engine);
+				break;
+			}
+		}
 	}
 }
 /* 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
 	 * --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,       NULL,       FeatureChangeInfo, },
+		/* 0x00 */ { NULL,     SafeChangeInfo, NULL,       InitChangeInfo, FeatureChangeInfo, },
 		/* 0x01 */ { NULL,     GRFUnsafe, NULL,            NULL,       NewSpriteSet, },
 		/* 0x02 */ { NULL,     GRFUnsafe, NULL,            NULL,       NewSpriteGroup, },
 		/* 0x03 */ { NULL,     GRFUnsafe, NULL,            NULL,       FeatureMapSpriteGroup, },
 		/* 0x04 */ { NULL,     NULL,      NULL,            NULL,       FeatureNewName, },
 		/* 0x05 */ { NULL,     NULL,      NULL,            NULL,       GraphicsNew, },
 		/* 0x06 */ { NULL,     NULL,      NULL,            CfgApply,   CfgApply, },
 		/* 0x07 */ { NULL,     NULL,      NULL,            NULL,       SkipIf, },
 		/* 0x08 */ { ScanInfo, NULL,      NULL,            GRFInfo,    GRFInfo, },
 		/* 0x09 */ { NULL,     NULL,      NULL,            SkipIf,     SkipIf, },
 		/* 0x0A */ { NULL,     NULL,      NULL,            NULL,       SpriteReplace, },
-		/* 0x0B */ { NULL,     NULL,      NULL,            GRFError,   GRFError, },
+		/* 0x0B */ { NULL,     NULL,      NULL,            GRFLoadError, GRFLoadError, },
 		/* 0x0C */ { NULL,     NULL,      NULL,            GRFComment, GRFComment, },
 		/* 0x0D */ { NULL,     SafeParamSet, NULL,         ParamSet,   ParamSet, },
 		/* 0x0E */ { NULL,     SafeGRFInhibit, NULL,       GRFInhibit, GRFInhibit, },
 		/* 0x0F */ { NULL,     NULL,      NULL,            NULL,       NULL, },
 		/* 0x10 */ { NULL,     NULL,      DefineGotoLabel, NULL,       NULL, },
 	if (stage != GLS_FILESCAN && stage != GLS_SAFETYSCAN && stage != GLS_LABELSCAN) {
 		_cur_grffile = GetFileByFilename(filename);
 		if (_cur_grffile == NULL) error("File '%s' lost in cache.\n", filename);
 		if (stage == GLS_ACTIVATION && !HASBIT(config->flags, GCF_ACTIVATED)) return;
 	}
+	if (stage == GLS_ACTIVATION) CLRBIT(config->flags, GCF_ACTIVATED);
 	FioOpenFile(file_index, filename);
 	_file_index = file_index; // XXX
 	_cur_grfconfig = config;
 			if (stage == GLS_LABELSCAN) InitNewGRFFile(c, _cur_spriteid);
 			LoadNewGRFFile(c, slot++, stage);
 			if (stage == GLS_ACTIVATION) {
 				ClearTemporaryNewGRFData();
+				BuildCargoTranslationMap();
 				DEBUG(sprite, 2, "Currently %i sprites are loaded", _cur_spriteid);
 			}
 		}
 	}

branch	cpp_gui
changeset 6268	4b5241e5dd10
parent 6254	abc6ad7c035c
child 6285	187e3ef04cc9