openttd-ottdgrfs: comparison src/strings.cpp

equal deleted inserted replaced

-:b5c2449616b5
+:66dde6412125
 #include "fileio.h"
 #include "helpers.hpp"
 #include "cargotype.h"
 #include "group.h"
 #include "debug.h"
+#include "newgrf_townname.h"
+#include "signs.h"
+#include "vehicle.h"
+#include "newgrf_engine.h"
 /* for opendir/readdir/closedir */
 # include "fios.h"
 DynamicLanguages _dynlang;
 char _userstring[128];
 static char *StationGetSpecialString(char *buff, int x, const char* last);
 static char *GetSpecialTownNameString(char *buff, int ind, uint32 seed, const char* last);
-static char *GetSpecialPlayerNameString(char *buff, int ind, const int32 *argv, const char* last);
+static char *GetSpecialPlayerNameString(char *buff, int ind, const int64 *argv, const char* last);
-static char *FormatString(char *buff, const char *str, const int32 *argv, uint casei, const char* last);
+static char *FormatString(char *buff, const char *str, const int64 *argv, uint casei, const char* last);
 struct LanguagePack {
 	uint32 ident;       // 32-bits identifier
 	uint32 version;     // 32-bits of auto generated version info which is basically a hash of strings.h
 	char name[32];      // the international name of this language
 static uint _langtab_num[32];   // Offset into langpack offs
 static uint _langtab_start[32]; // Offset into langpack offs
 /** Read an int64 from the argv array. */
-static inline int64 GetInt64(const int32 **argv)
+static inline int64 GetInt64(const int64 **argv)
-{
-	int64 result;
-	assert(argv);
-	result = (uint32)(*argv)[0] + ((uint64)(uint32)(*argv)[1] << 32);
-	(*argv) += 2;
-	return result;
-}
-/** Read an int32 from the argv array. */
-static inline int32 GetInt32(const int32 **argv)
 {
 	assert(argv);
 	return *(*argv)++;
 }
+/** Read an int32 from the argv array. */
+static inline int32 GetInt32(const int64 **argv)
+{
+	return (int32)GetInt64(argv);
+}
 /** Read an array from the argv array. */
-static inline const int32 *GetArgvPtr(const int32 **argv, int n)
+static inline const int64 *GetArgvPtr(const int64 **argv, int n)
 {
-	const int32 *result;
+	const int64 *result;
 	assert(*argv);
 	result = *argv;
 	(*argv) += n;
 	return result;
 }
 * @param string
 * @param argv
 * @param last
 * @return a formatted string of char
 */
-static char *GetStringWithArgs(char *buffr, uint string, const int32 *argv, const char* last)
+static char *GetStringWithArgs(char *buffr, uint string, const int64 *argv, const char* last)
 {
 	uint index = GB(string,  0, 11);
 	uint tab   = GB(string, 11,  5);
 	char buff[512];
 	return FormatString(buffr, GetStringPtr(GB(string, 0, 16)), argv, GB(string, 24, 8), last);
 }
 char *GetString(char *buffr, StringID string, const char* last)
 {
-	return GetStringWithArgs(buffr, string, (int32*)_decode_parameters, last);
+	return GetStringWithArgs(buffr, string, (int64*)_decode_parameters, last);
 }
 char *InlineString(char *buf, StringID string)
 {
 	SetDParam(n, BindCString(str));
 }
 void InjectDParam(int amount)
 {
-	memmove(_decode_parameters + amount, _decode_parameters, sizeof(_decode_parameters) - amount * sizeof(uint32));
+	memmove(_decode_parameters + amount, _decode_parameters, sizeof(_decode_parameters) - amount * sizeof(uint64));
 }
 static const uint32 _divisor_table[] = {
 	1000000000,
 	100000000,
 static char *FormatYmdString(char *buff, Date date, const char* last)
 {
 	YearMonthDay ymd;
 	ConvertDateToYMD(date, &ymd);
-	int32 args[3] = { ymd.day + STR_01AC_1ST - 1, STR_0162_JAN + ymd.month, ymd.year };
+	int64 args[3] = { ymd.day + STR_01AC_1ST - 1, STR_0162_JAN + ymd.month, ymd.year };
 	return FormatString(buff, GetStringPtr(STR_DATE_LONG), args, 0, last);
 }
 static char *FormatMonthAndYear(char *buff, Date date, const char* last)
 {
 	YearMonthDay ymd;
 	ConvertDateToYMD(date, &ymd);
-	int32 args[2] = { STR_MONTH_JAN + ymd.month, ymd.year };
+	int64 args[2] = { STR_MONTH_JAN + ymd.month, ymd.year };
 	return FormatString(buff, GetStringPtr(STR_DATE_SHORT), args, 0, last);
 }
 static char *FormatTinyDate(char *buff, Date date, const char* last)
 {
 	char month[3];
 	/* We want to zero-pad the days and months */
 	snprintf(day,   lengthof(day),   "%02i", ymd.day);
 	snprintf(month, lengthof(month), "%02i", ymd.month + 1);
-	int32 args[3] = { BindCString(day), BindCString(month), ymd.year };
+	int64 args[3] = { BindCString(day), BindCString(month), ymd.year };
 	return FormatString(buff, GetStringPtr(STR_DATE_TINY), args, 0, last);
 }
-static char *FormatGenericCurrency(char *buff, const CurrencySpec *spec, int64 number, bool compact, const char* last)
+static char *FormatGenericCurrency(char *buff, const CurrencySpec *spec, Money number, bool compact, const char* last)
 {
 	const char* multiplier = "";
 	char buf[40];
 	char* p;
 	int j;
-	/* multiply by exchange rate */
+	/* Multiply by exchange rate, but do it safely. */
-	number *= spec->rate;
+	CommandCost cs(number);
+	cs.MultiplyCost(spec->rate);
+	number = cs.GetCost();
 	/* convert from negative */
 	if (number < 0) {
 		buff = strecpy(buff, "-", last);
 		number = -number;
 		   1,  0, STR_UNITS_VOLUME_SHORT_SI, STR_UNITS_VOLUME_LONG_SI,
 		   1,  0, STR_UNITS_FORCE_SI,
 	},
 };
-static char* FormatString(char* buff, const char* str, const int32* argv, uint casei, const char* last)
+static char* FormatString(char* buff, const char* str, const int64* argv, uint casei, const char* last)
 {
 	extern const char _openttd_revision[];
 	WChar b;
-	const int32 *argv_orig = argv;
+	const int64 *argv_orig = argv;
 	uint modifier = 0;
 	while ((b = Utf8Consume(&str)) != '\0') {
 		switch (b) {
 			case SCC_SETX: // {SETX}
 			case SCC_DATE_SHORT: // {DATE_SHORT}
 				buff = FormatMonthAndYear(buff, GetInt32(&argv), last);
 				break;
 			case SCC_VELOCITY: {// {VELOCITY}
-				int32 args[1];
+				int64 args[1];
 				assert(_opt_ptr->units < lengthof(units));
 				args[0] = GetInt32(&argv) * units[_opt_ptr->units].s_m >> units[_opt_ptr->units].s_s;
 				buff = FormatString(buff, GetStringPtr(units[_opt_ptr->units].velocity), args, modifier >> 24, last);
 				modifier = 0;
 				break;
 			}
 			case SCC_CURRENCY_COMPACT: /* {CURRCOMPACT} */
-				buff = FormatGenericCurrency(buff, _currency, GetInt32(&argv), true, last);
+				buff = FormatGenericCurrency(buff, _currency, GetInt64(&argv), true, last);
 				break;
 			case SCC_REVISION: /* {REV} */
 				buff = strecpy(buff, _openttd_revision, last);
 				break;
 				 * 8-bit = cargo type
 				 * 16-bit = cargo count */
 				StringID cargo_str = GetCargo(GetInt32(&argv))->units_volume;
 				switch (cargo_str) {
 					case STR_TONS: {
-						int32 args[1];
+						int64 args[1];
 						assert(_opt_ptr->units < lengthof(units));
 						args[0] = GetInt32(&argv) * units[_opt_ptr->units].w_m >> units[_opt_ptr->units].w_s;
 						buff = FormatString(buff, GetStringPtr(units[_opt_ptr->units].l_weight), args, modifier >> 24, last);
 						modifier = 0;
 						break;
 					}
 					case STR_LITERS: {
-						int32 args[1];
+						int64 args[1];
 						assert(_opt_ptr->units < lengthof(units));
 						args[0] = GetInt32(&argv) * units[_opt_ptr->units].v_m >> units[_opt_ptr->units].v_s;
 						buff = FormatString(buff, GetStringPtr(units[_opt_ptr->units].l_volume), args, modifier >> 24, last);
 						modifier = 0;
 						break;
 						}
 						break;
 				}
 			} break;
-			case SCC_CURRENCY_COMPACT_64: { /* {CURRCOMPACT64} */
-				/* 64 bit compact currency-unit */
-				buff = FormatGenericCurrency(buff, _currency, GetInt64(&argv), true, last);
-				break;
-			}
 			case SCC_STRING1: { /* {STRING1} */
 				/* String that consumes ONE argument */
 				uint str = modifier + GetInt32(&argv);
 				buff = GetStringWithArgs(buff, str, GetArgvPtr(&argv, 1), last);
 				modifier = 0;
 				break;
 			}
 			case SCC_INDUSTRY_NAME: { /* {INDUSTRY} */
 				const Industry* i = GetIndustry(GetInt32(&argv));
-				int32 args[2];
+				int64 args[2];
 				/* industry not valid anymore? */
 				if (!IsValidIndustry(i)) break;
 				/* First print the town name and the industry type name
 				modifier = 0;
 				break;
 			}
 			case SCC_VOLUME: { // {VOLUME}
-				int32 args[1];
+				int64 args[1];
 				assert(_opt_ptr->units < lengthof(units));
 				args[0] = GetInt32(&argv) * units[_opt_ptr->units].v_m >> units[_opt_ptr->units].v_s;
 				buff = FormatString(buff, GetStringPtr(units[_opt_ptr->units].l_volume), args, modifier >> 24, last);
 				modifier = 0;
 				break;
 				buff = GetStringWithArgs(buff, cargo_str, argv++, last);
 				break;
 			}
 			case SCC_POWER: { // {POWER}
-				int32 args[1];
+				int64 args[1];
 				assert(_opt_ptr->units < lengthof(units));
 				args[0] = GetInt32(&argv) * units[_opt_ptr->units].p_m >> units[_opt_ptr->units].p_s;
 				buff = FormatString(buff, GetStringPtr(units[_opt_ptr->units].power), args, modifier >> 24, last);
 				modifier = 0;
 				break;
 			}
 			case SCC_VOLUME_SHORT: { // {VOLUME_S}
-				int32 args[1];
+				int64 args[1];
 				assert(_opt_ptr->units < lengthof(units));
 				args[0] = GetInt32(&argv) * units[_opt_ptr->units].v_m >> units[_opt_ptr->units].v_s;
 				buff = FormatString(buff, GetStringPtr(units[_opt_ptr->units].s_volume), args, modifier >> 24, last);
 				modifier = 0;
 				break;
 			}
 			case SCC_WEIGHT: { // {WEIGHT}
-				int32 args[1];
+				int64 args[1];
 				assert(_opt_ptr->units < lengthof(units));
 				args[0] = GetInt32(&argv) * units[_opt_ptr->units].w_m >> units[_opt_ptr->units].w_s;
 				buff = FormatString(buff, GetStringPtr(units[_opt_ptr->units].l_weight), args, modifier >> 24, last);
 				modifier = 0;
 				break;
 			}
 			case SCC_WEIGHT_SHORT: { // {WEIGHT_S}
-				int32 args[1];
+				int64 args[1];
 				assert(_opt_ptr->units < lengthof(units));
 				args[0] = GetInt32(&argv) * units[_opt_ptr->units].w_m >> units[_opt_ptr->units].w_s;
 				buff = FormatString(buff, GetStringPtr(units[_opt_ptr->units].s_weight), args, modifier >> 24, last);
 				modifier = 0;
 				break;
 			}
 			case SCC_FORCE: { // {FORCE}
-				int32 args[1];
+				int64 args[1];
 				assert(_opt_ptr->units < lengthof(units));
 				args[0] = GetInt32(&argv) * units[_opt_ptr->units].f_m >> units[_opt_ptr->units].f_s;
 				buff = FormatString(buff, GetStringPtr(units[_opt_ptr->units].force), args, modifier >> 24, last);
 				modifier = 0;
 				break;
 			case SCC_NUM: // {NUM}
 				buff = FormatNoCommaNumber(buff, GetInt32(&argv), last);
 				break;
 			case SCC_CURRENCY: // {CURRENCY}
-				buff = FormatGenericCurrency(buff, _currency, GetInt32(&argv), false, last);
+				buff = FormatGenericCurrency(buff, _currency, GetInt64(&argv), false, last);
 				break;
 			case SCC_WAYPOINT_NAME: { // {WAYPOINT}
-				int32 temp[2];
+				int64 temp[2];
 				Waypoint *wp = GetWaypoint(GetInt32(&argv));
 				StringID str;
 				if (wp->string != STR_NULL) {
 					str = wp->string;
 				} else {
 				const Station* st = GetStation(GetInt32(&argv));
 				if (!st->IsValid()) { // station doesn't exist anymore
 					buff = GetStringWithArgs(buff, STR_UNKNOWN_DESTINATION, NULL, last);
 				} else {
-					int32 temp[2];
+					int64 temp[3];
-					temp[0] = st->town->townnametype;
+					temp[0] = STR_TOWN;
-					temp[1] = st->town->townnameparts;
+					temp[1] = st->town->index;
+					temp[2] = st->index;
 					buff = GetStringWithArgs(buff, st->string_id, temp, last);
 				}
 				break;
 			}
 			case SCC_TOWN_NAME: { // {TOWN}
 				const Town* t = GetTown(GetInt32(&argv));
-				int32 temp[1];
+				int64 temp[1];
 				assert(IsValidTown(t));
 				temp[0] = t->townnameparts;
-				buff = GetStringWithArgs(buff, t->townnametype, temp, last);
+				uint32 grfid = t->townnamegrfid;
+				if (grfid == 0) {
+					/* Original town name */
+					buff = GetStringWithArgs(buff, t->townnametype, temp, last);
+				} else {
+					/* Newgrf town name */
+					if (GetGRFTownName(grfid) != NULL) {
+						/* The grf is loaded */
+						buff = GRFTownNameGenerate(buff, t->townnamegrfid, t->townnametype, t->townnameparts, last);
+					} else {
+						/* Fallback to english original */
+						buff = GetStringWithArgs(buff, SPECSTR_TOWNNAME_ENGLISH, temp, last);
+					}
+				}
 				break;
 			}
 			case SCC_GROUP_NAME: { // {GROUP}
 				const Group *g = GetGroup(GetInt32(&argv));
-				int32 args[1];
+				int64 args[1];
 				assert(IsValidGroup(g));
 				args[0] = g->index;
-				buff = GetStringWithArgs(buff, (g->string_id == STR_SV_GROUP_NAME) ? (StringID)STR_GROUP_NAME_FORMAT : g->string_id, args, last);
+				buff = GetStringWithArgs(buff, IsCustomName(g->string_id) ? g->string_id : (StringID)STR_GROUP_NAME_FORMAT, args, last);
 				break;
 			}
-			case SCC_CURRENCY_64: { // {CURRENCY64}
+			case SCC_ENGINE_NAME: { // {ENGINE}
-				buff = FormatGenericCurrency(buff, _currency, GetInt64(&argv), false, last);
+				EngineID engine = (EngineID)GetInt32(&argv);
+				buff = GetString(buff, GetCustomEngineName(engine), last);
+				break;
+			}
+			case SCC_VEHICLE_NAME: { // {VEHICLE}
+				const Vehicle *v = GetVehicle(GetInt32(&argv));
+				int64 args[1];
+				args[0] = v->unitnumber;
+				buff = GetStringWithArgs(buff, v->string_id, args, last);
+				break;
+			}
+			case SCC_SIGN_NAME: { // {SIGN}
+				const Sign *si = GetSign(GetInt32(&argv));
+				buff = GetString(buff, si->str, last);
+				break;
+			}
+			case SCC_COMPANY_NAME: { // {COMPANY}
+				const Player *p = GetPlayer((PlayerID)GetInt32(&argv));
+				int64 args[1];
+				args[0] = p->name_2;
+				buff = GetStringWithArgs(buff, p->name_1, args, last);
+				break;
+			}
+			case SCC_COMPANY_NUM: { // {COMPANYNUM}
+				PlayerID player = (PlayerID)GetInt32(&argv);
+				/* Nothing is added for AI or inactive players */
+				if (IsHumanPlayer(player) && IsValidPlayer(player)) {
+					int64 args[1];
+					args[0] = player + 1;
+					buff = GetStringWithArgs(buff, STR_7002_PLAYER, args, last);
+				}
+				break;
+			}
+			case SCC_PLAYER_NAME: { // {PLAYERNAME}
+				const Player *p = GetPlayer((PlayerID)GetInt32(&argv));
+				int64 args[1];
+				args[0] = p->president_name_2;
+				buff = GetStringWithArgs(buff, p->president_name_1, args, last);
 				break;
 			}
 			case SCC_SETCASE: { // {SETCASE}
 				/* This is a pseudo command, it's outputted when someone does {STRING.ack}
 	buff = strecpy(buff, base[num * GB(x, 16, 8) >> 8], last);
 	return buff;
 }
-static char *GetSpecialPlayerNameString(char *buff, int ind, const int32 *argv, const char* last)
+static char *GetSpecialPlayerNameString(char *buff, int ind, const int64 *argv, const char* last)
 {
 	switch (ind) {
 		case 1: // not used
 			return strecpy(buff, _silly_company_names[GetInt32(&argv) & 0xFFFF], last);

branch	noai
changeset 9629	66dde6412125
parent 9628	b5c2449616b5
child 9686	d3c195c226f9