1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "station.h"

     5

#include "town.h"

     6

#include "vehicle.h"

     7

#include "news.h"

     8

#include "screenshot.h"

     9

    10

#define USE_TABLE(x)  { assert(index < lengthof(x)); str = x[index]; break; }

    11

    12

static byte *StationGetSpecialString(byte *buff);

    13

static byte *GetSpecialTownNameString(byte *buff, int ind);

    14

static byte *GetSpecialPlayerNameString(byte *buff, int ind);

    15

    16

static byte *DecodeString(byte *buff, const byte *str);

    17

    18

static byte **_langpack_offs;

    19

static byte *_langpack;

    20

static uint _langtab_num[32]; // Offset into langpack offs

    21

static uint _langtab_start[32]; // Offset into langpack offs

    22

    23

extern const char _openttd_revision[];

    24

    25

typedef byte *PlayerNameGeneratorProc(byte *buffr);

    26

    27

typedef struct {

    28

	uint32 ident;

    29

	uint32 version;			// 32-bits of auto generated version info which is basically a hash of strings.h

    30

	char name[32];			// the international name of this language

    31

	char own_name[32];	// the localized name of this language

    32

	uint16 offsets[32];	// the offsets

    33

} LanguagePackHeader;

    34

    35

const uint16 _currency_string_list[] = {

    36

	STR_CURR_GBP,

    37

	STR_CURR_USD,

    38

	STR_CURR_EUR,

    39

	STR_CURR_YEN,

    40

	STR_CURR_ATS,

    41

	STR_CURR_BEF,

    42

	STR_CURR_CHF,

    43

	STR_CURR_CZK,

    44

	STR_CURR_DEM,

    45

	STR_CURR_DKK,

    46

	STR_CURR_ESP,

    47

	STR_CURR_FIM,

    48

	STR_CURR_FRF,

    49

	STR_CURR_GRD,

    50

	STR_CURR_HUF,

    51

	STR_CURR_ISK,

    52

	STR_CURR_ITL,

    53

	STR_CURR_NLG,

    54

	STR_CURR_NOK,

    55

	STR_CURR_PLN,

    56

	STR_CURR_ROL,

    57

	STR_CURR_RUR,

    58

	STR_CURR_SEK,

    59

	STR_CURR_CUSTOM,

    60

	INVALID_STRING_ID

    61

};

    62

    63

static const uint16 _cargo_string_list[NUM_LANDSCAPE][NUM_CARGO] = {

    64

	/* LT_NORMAL */ {STR_PASSENGERS, STR_TONS, STR_BAGS, STR_LITERS, STR_ITEMS, STR_CRATES, STR_TONS, STR_TONS, STR_TONS, STR_TONS, STR_BAGS, STR_RES_OTHER},

    65

	/* LT_HILLY */  {STR_PASSENGERS, STR_TONS, STR_BAGS, STR_LITERS, STR_ITEMS, STR_CRATES, STR_TONS, STR_TONS, STR_RES_OTHER, STR_TONS, STR_BAGS, STR_TONS},

    66

	/* LT_DESERT */ {STR_PASSENGERS, STR_LITERS, STR_BAGS, STR_LITERS, STR_TONS, STR_CRATES, STR_TONS, STR_TONS, STR_TONS, STR_LITERS, STR_BAGS, STR_TONS},

    67

	/* LT_CANDY */  {STR_PASSENGERS, STR_TONS, STR_BAGS, STR_NOTHING, STR_NOTHING, STR_TONS, STR_TONS, STR_LITERS, STR_TONS, STR_NOTHING, STR_LITERS, STR_NOTHING}

    68

};

    69

    70

static byte *str_cat(byte *dst, const byte *src)

    71

{

    72

	while ( (*dst++ = *src++) != 0) {}

    73

	return dst - 1;

    74

}

    75

    76

static byte *GetStringPtr(uint16 string)

    77

{

    78

	return _langpack_offs[_langtab_start[string >> 11] + (string & 0x7FF)];

    79

}

    80

    81

byte *GetString(byte *buffr, uint16 string)

    82

{

    83

	uint index = string & 0x7FF;

    84

	uint tab = string >> 11;

    85

    86

	if (string == 0) error("!invalid string id 0 in GetString");

    87

    88

	if ( tab == 4 && index >= 0xC0)

    89

		return GetSpecialTownNameString(buffr, index - 0xC0);

    90

    91

	if ( tab == 6 && index == 0xD1)

    92

		return StationGetSpecialString(buffr);

    93

    94

	if ( tab == 14 && index >= 0xE4)

    95

		return GetSpecialPlayerNameString(buffr, index - 0xE4);

    96

    97

	if ( tab == 15)

    98

		return GetName(index, buffr);

    99

   100

	// tab 31 is used for special or dynamic strings

   101

	if ( tab == 31) {

   102

		return DecodeString(buffr, index == (STR_SPEC_SCREENSHOT_NAME & 0x7FF) ? _screenshot_name : _userstring);

   103

	}

   104

   105

	if (index >= _langtab_num[tab])

   106

		error("!String 0x%X is invalid. Probably because an old version of the .lng file.\n", string);

   107

   108

	return DecodeString(buffr, GetStringPtr(string));

   109

}

   110

   111

void InjectDparam(int amount)

   112

{

   113

	memmove(_decode_parameters + amount, _decode_parameters, sizeof(_decode_parameters) - amount * sizeof(uint32));

   114

}

   115

   116

   117

int32 GetParamInt32(void)

   118

{

   119

	int32 result = GetDParam(0);

   120

	memmove(&_decode_parameters[0], &_decode_parameters[1], sizeof(uint32) * (lengthof(_decode_parameters)-1));

   121

	return result;

   122

}

   123

   124

static int64 GetParamInt64(void)

   125

{

   126

	int64 result = GetDParam(0) + ((uint64)GetDParam(1) << 32);

   127

	memmove(&_decode_parameters[0], &_decode_parameters[2], sizeof(uint32) * (lengthof(_decode_parameters)-2));

   128

	return result;

   129

}

   130

   131

   132

int GetParamInt16(void)

   133

{

   134

	int result = (int16)GetDParam(0);

   135

	memmove(&_decode_parameters[0], &_decode_parameters[1], sizeof(uint32) * (lengthof(_decode_parameters)-1));

   136

	return result;

   137

}

   138

   139

int GetParamInt8(void)

   140

{

   141

	int result = (int8)GetDParam(0);

   142

	memmove(&_decode_parameters[0], &_decode_parameters[1], sizeof(uint32) * (lengthof(_decode_parameters)-1));

   143

	return result;

   144

}

   145

   146

int GetParamUint16(void)

   147

{

   148

	int result = GetDParam(0);

   149

	memmove(&_decode_parameters[0], &_decode_parameters[1], sizeof(uint32) * (lengthof(_decode_parameters)-1));

   150

	return result;

   151

}

   152

   153

static const uint32 _divisor_table[] = {

   154

	1000000000,

   155

	100000000,

   156

	10000000,

   157

	1000000,

   158

   159

	100000,

   160

	10000,

   161

	1000,

   162

	100,

   163

	10,

   164

	1

   165

};

   166

   167

static byte *FormatCommaNumber(byte *buff, int32 number)

   168

{

   169

	uint32 quot,divisor;

   170

	int i;

   171

	uint32 tot;

   172

	uint32 num;

   173

   174

	if (number < 0) {

   175

		*buff++ = '-';

   176

		number = -number;

   177

	}

   178

   179

	num = number;

   180

   181

	tot = 0;

   182

	for(i=0; i!=10; i++) {

   183

		divisor = _divisor_table[i];

   184

		quot = 0;

   185

		if (num >= divisor) {

   186

			quot = num / _divisor_table[i];

   187

			num = num % _divisor_table[i];

   188

		}

   189

		if (tot|=quot || i==9) {

   190

			*buff++ = (byte)('0' + quot);

   191

			if (i==0 || i==3 || i==6) *buff++ = ',';

   192

		}

   193

	}

   194

   195

	*buff = 0;

   196

   197

	return buff;

   198

}

   199

   200

static byte *FormatNoCommaNumber(byte *buff, int32 number)

   201

{

   202

	uint32 quot,divisor;

   203

	int i;

   204

	uint32 tot;

   205

	uint32 num;

   206

   207

	if (number < 0) {

   208

		*buff++ = '-';

   209

		number = -number;

   210

	}

   211

   212

	num = number;

   213

   214

	tot = 0;

   215

	for(i=0; i!=10; i++) {

   216

		divisor = _divisor_table[i];

   217

		quot = 0;

   218

		if (num >= divisor) {

   219

			quot = num / _divisor_table[i];

   220

			num = num % _divisor_table[i];

   221

		}

   222

		if (tot|=quot || i==9) {

   223

			*buff++ = (byte)('0' + quot);

   224

		}

   225

	}

   226

   227

	*buff = 0;

   228

   229

	return buff;

   230

}

   231

   232

   233

static byte *FormatYmdString(byte *buff, uint16 number)

   234

{

   235

	const byte *src;

   236

	YearMonthDay ymd;

   237

   238

	ConvertDayToYMD(&ymd, number);

   239

   240

	for(src = GetStringPtr(ymd.day+STR_01AC_1ST-1); (*buff++=*src++) != 0;) {}

   241

   242

	buff[-1] = ' ';

   243

	memcpy(buff, GetStringPtr(STR_0162_JAN + ymd.month), 4);

   244

	buff[3] = ' ';

   245

   246

	return FormatNoCommaNumber(buff+4, ymd.year + MAX_YEAR_BEGIN_REAL);

   247

}

   248

   249

static byte *FormatMonthAndYear(byte *buff, uint16 number)

   250

{

   251

	const char *src;

   252

	YearMonthDay ymd;

   253

   254

	ConvertDayToYMD(&ymd, number);

   255

   256

	for(src = GetStringPtr(STR_MONTH_JAN + ymd.month); (*buff++=*src++) != 0;) {}

   257

	buff[-1] = ' ';

   258

   259

	return FormatNoCommaNumber(buff, ymd.year + MAX_YEAR_BEGIN_REAL);

   260

}

   261

   273

uint GetCurrentCurrencyRate(void)

   274

{

   275

    return (&_currency_specs[_opt.currency])->rate;

   276

}

   277

   278

static byte *FormatGenericCurrency(byte *buff, const CurrencySpec *spec, int64 number, bool compact)

   279

{

   280

	const char *s;

   281

	char c;

   282

	char buf[40], *p;

   283

	int j;

   284

   285

	// multiply by exchange rate

   286

	number *= spec->rate;

   287

   288

	// convert from negative

   289

	if (number < 0) { *buff++ = '-'; number = -number; }

   290

   291

	// add prefix part

   292

	s = spec->prefix;

   293

	while (s != spec->prefix + lengthof(spec->prefix) && (c=*s++)) *buff++ = c;

   294

   295

	// for huge numbers, compact the number into k or M

   296

	if (compact) {

   297

		compact = 0;

   298

		if (number >= 1000000000) {

   299

			number = (number + 500000) / 1000000;

   300

			compact = 'M';

   301

		} else if (number >= 1000000) {

   302

			number = (number + 500) / 1000;

   303

			compact = 'k';

   304

		}

   305

	}

   306

   307

	// convert to ascii number and add commas

   308

	p = buf;

   309

	j = 4;

   310

	do {

   311

		if (--j == 0) { *p++ = spec->separator; j = 3; }

   312

		*p++ = '0' + number % 10;

   313

	} while (number /= 10);

   314

	do *buff++ = *--p; while (p != buf);

   315

   316

	if (compact) *buff++ = compact;

   317

   318

	// add suffix part

   319

	s = spec->suffix;

   320

	while (s != spec->suffix + lengthof(spec->suffix) && (c=*s++)) *buff++ = c;

   321

   322

	return buff;

   323

}

   324

   325

static byte *DecodeString(byte *buff, const byte *str)

   326

{

   327

	byte b;

   328

   329

	while((b = *str++) != 0) {

   330

		switch(b) {

   331

		case 0x1: // {SETX}

   332

			*buff++ = b;

   333

			*buff++ = *str++;

   334

			break;

   335

		case 0x2: // {SETXY}

   336

			*buff++ = b;

   337

			*buff++ = *str++;

   338

			*buff++ = *str++;

   339

			break;

   340

		case 0x7B: // {COMMA32}

   341

			buff = FormatCommaNumber(buff, GetParamInt32());

   342

			break;

   343

		case 0x7C: // {COMMA16}

   344

			buff = FormatCommaNumber(buff, GetParamInt16());

   345

			break;

   346

		case 0x7D: // {COMMA8}

   347

			buff = FormatCommaNumber(buff, GetParamInt8());

   348

			break;

   349

		case 0x7E: // {NUMU16}

   350

			buff = FormatNoCommaNumber(buff, GetParamInt16());

   351

			break;

   352

		case 0x7F: // {CURRENCY}

   353

			buff = FormatGenericCurrency(buff, &_currency_specs[_opt.currency], GetParamInt32(), false);

   354

			break;

   355

		// 0x80 is reserved for EURO

   356

		case 0x81: // {STRINL}

   357

			str += 2;

   358

			buff = GetString(buff, READ_LE_UINT16(str-2));

   359

			break;

   360

		case 0x82: // {DATE_LONG}

   361

			buff = FormatYmdString(buff, GetParamUint16());

   362

			break;

   363

		case 0x83: // {DATE_SHORT}

   364

			buff = FormatMonthAndYear(buff, GetParamUint16());

   365

			break;

   366

		case 0x84: {// {VELOCITY}

   367

			int value = GetParamInt16();

   368

			if (_opt.kilometers) value = value * 1648 >> 10;

   369

			buff = FormatCommaNumber(buff, value);

   370

			if (_opt.kilometers) {

   371

				memcpy(buff, " km/h", 5);

   372

				buff += 5;

   373

			} else {

   374

				memcpy(buff, " mph", 4);

   375

				buff += 4;

   376

			}

   377

			break;

   378

		}

   379

   380

		// 0x85 is used as escape character..

   381

		case 0x85:

   382

			switch(*str++) {

   383

			case 0: /* {CURRCOMPACT} */

   384

				buff = FormatGenericCurrency(buff, &_currency_specs[_opt.currency], GetParamInt32(), true);

   385

				break;

   386

			case 1: /* {INT32} */

   387

				buff = FormatNoCommaNumber(buff, GetParamInt32());

   388

				break;

   389

			case 2: /* {REV} */

   390

				buff = str_cat(buff, (const byte*)_openttd_revision);

   391

				break;

   392

			case 3: { /* {SHORTCARGO} */

   393

				// Short description of cargotypes. Layout:

   394

				// 8-bit = cargo type

   395

				// 16-bit = cargo count

   396

				char *s;

   397

				uint16 cargo_str = _cargo_string_list[_opt.landscape][(byte)GetParamInt8()];

   398

				uint16 multiplier = (cargo_str == STR_LITERS) ? 1000 : 1;

   399

				// liquid type of cargo is multiplied by 100 to get correct amount

   400

				buff = FormatCommaNumber(buff, GetParamInt16() * multiplier );

   401

				s = GetStringPtr(cargo_str);

   402

   403

				memcpy(buff++, " ", 1);

   404

				while (*s) *buff++ = *s++;

   405

			}	break;

   406

			case 4: /* {CURRCOMPACT64} */

   407

				// 64 bit compact currency-unit

   408

				buff = FormatGenericCurrency(buff, &_currency_specs[_opt.currency], GetParamInt64(), true);

   409

				break;

   410

   411

			default:

   412

				error("!invalid escape sequence in string");

   413

			}

   414

			break;

   415

   416

		case 0x86: // {SKIP}

   417

			GetParamInt16();

   418

			//assert(0);

   419

			break;

   420

		case 0x87: { // {VOLUME}

   421

			char *s;

   422

			buff = FormatCommaNumber(buff, GetParamInt16() * 1000);

   423

			memcpy(buff++, " ", 1);

   424

			s = GetStringPtr(STR_LITERS);

   425

			while (*s) *buff++ = *s++;

   426

			break;

   427

		}

   428

   429

		case 0x88: // {STRING}

   430

			buff = GetString(buff, (uint16)GetParamUint16());

   431

			break;

   432

   433

		case 0x99: { // {CARGO}

   434

			// Layout now is:

   435

			//   8bit   - cargo type

   436

			//   16-bit - cargo count

   437

			int cargo_str = _cargoc.names_long_s[GetParamInt8()];

   438

			// Now check if the cargo count is 1, if it is, increase string by 32.

   439

			if (GetDParam(0) != 1) cargo_str += 32;

   440

			buff = GetString(buff, cargo_str);

   441

			break;

   442

		}

   443

   444

		case 0x9A: { // {STATION}

   445

			Station *st;

   446

			InjectDparam(1);

   447

			st = GetStation(GetDParam(1));

   448

			if (!st->xy) { // station doesn't exist anymore

   449

				buff = GetString(buff, STR_UNKNOWN_DESTINATION);

   450

				break;

   451

			}

   452

			SetDParam(0, st->town->townnametype);

   453

			SetDParam(1, st->town->townnameparts);

   454

			buff = GetString(buff, st->string_id);

   455

			break;

   456

		}

   457

		case 0x9B: { // {TOWN}

   458

			Town *t;

   459

			t = GetTown(GetDParam(0));

   460

			assert(t->xy);

   461

			SetDParam(0, t->townnameparts);

   462

			buff = GetString(buff, t->townnametype);

   463

			break;

   464

		}

   465

   466

		case 0x9C: { // {CURRENCY64}

   467

			buff = FormatGenericCurrency(buff, &_currency_specs[_opt.currency], GetParamInt64(), false);

   468

			break;

   469

		}

   470

   471

		case 0x9D: { // {WAYPOINT}

   472

			Waypoint *cp = &_waypoints[GetDParam(0)];

   473

			StringID str;

   474

			int idx;

   475

			if (~cp->town_or_string & 0xC000) {

   476

				GetParamInt32(); // skip it

   477

				str = cp->town_or_string;

   478

			} else {

   479

				idx = (cp->town_or_string >> 8) & 0x3F;

   480

				if (idx == 0) {

   481

					str = STR_WAYPOINTNAME_CITY;

   482

				} else {

   483

					InjectDparam(1);

   484

					SetDParam(1, idx + 1);

   485

					str = STR_WAYPOINTNAME_CITY_SERIAL;

   486

				}

   487

				SetDParam(0, cp->town_or_string & 0xFF);

   488

			}

   489

   490

			buff = GetString(buff, str);

   491

		} break;

   498

		// case 0x88..0x98: // {COLORS}

   499

		// case 0xE: // {TINYFONT}

   500

		// case 0xF: // {BIGFONT}

   501

		// 0x9E is the highest number that is available.

   502

		default:

   503

			*buff++ = b;

   504

		}

   505

	}

   506

	buff[0] = 0;

   507

	return buff;

   508

}

   509

   510

   511

static byte *StationGetSpecialString(byte *buff)

   512

{

   513

	int x = GetParamInt8();

   514

	if (x & 1) *buff++ = 0xB4;

   515

	if (x & 2) *buff++ = 0xB5;