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

   262

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

   263

{

   264

	YearMonthDay ymd;

   265

   266

	ConvertDayToYMD(&ymd, number);

   267

	buff += sprintf(buff, " %02i-%02i-%04i", ymd.day, ymd.month + 1, ymd.year + MAX_YEAR_BEGIN_REAL);

   268

   269

	return buff;

   270

}

   271

   272

uint GetCurrentCurrencyRate(void)

   273

{

   274

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

   275

}

   276

   277

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

   278

{

   279

	const char *s;

   280

	char c;

   281

	char buf[40], *p;

   282

	int j;

   283

   284

	// multiply by exchange rate

   285

	number *= spec->rate;

   286

   287

	// convert from negative

   288

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

   289

   290

	// add prefix part

   291

	s = spec->prefix;

   292

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

   293

   294

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

   295

	if (compact) {

   296

		compact = 0;

   297

		if (number >= 1000000000) {

   298

			number = (number + 500000) / 1000000;

   299

			compact = 'M';

   300

		} else if (number >= 1000000) {

   301

			number = (number + 500) / 1000;

   302

			compact = 'k';

   303

		}

   304

	}

   305

   306

	// convert to ascii number and add commas

   307

	p = buf;

   308

	j = 4;

   309

	do {

   310

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

   311

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

   312

	} while (number /= 10);

   313

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

   314

   315

	if (compact) *buff++ = compact;

   316

   317

	// add suffix part

   318

	s = spec->suffix;

   319

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

   320

   321

	return buff;

   322

}

   323

   324

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

   325

{

   326

	byte b;

   327

   328

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

   329

		switch(b) {

   330

		case 0x1: // {SETX}

   331

			*buff++ = b;

   332

			*buff++ = *str++;

   333

			break;

   334

		case 0x2: // {SETXY}

   335

			*buff++ = b;

   336

			*buff++ = *str++;

   337

			*buff++ = *str++;

   338

			break;

   339

		case 0x7B: // {COMMA32}

   340

			buff = FormatCommaNumber(buff, GetParamInt32());

   341

			break;

   342

		case 0x7C: // {COMMA16}

   343

			buff = FormatCommaNumber(buff, GetParamInt16());

   344

			break;

   345

		case 0x7D: // {COMMA8}

   346

			buff = FormatCommaNumber(buff, GetParamInt8());

   347

			break;

   348

		case 0x7E: // {NUMU16}

   349

			buff = FormatNoCommaNumber(buff, GetParamInt16());

   350

			break;

   351

		case 0x7F: // {CURRENCY}

   352

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

   353

			break;

   354

		// 0x80 is reserved for EURO

   355

		case 0x81: // {STRINL}

   356

			str += 2;

   357

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

   358

			break;

   359

		case 0x82: // {DATE_LONG}

   360

			buff = FormatYmdString(buff, GetParamUint16());

   361

			break;

   362

		case 0x83: // {DATE_SHORT}

   363

			buff = FormatMonthAndYear(buff, GetParamUint16());

   364

			break;

   365

		case 0x84: {// {VELOCITY}

   366

			int value = GetParamInt16();

   367

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

   368

			buff = FormatCommaNumber(buff, value);

   369

			if (_opt.kilometers) {

   370

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

   371

				buff += 5;

   372

			} else {

   373

				memcpy(buff, " mph", 4);

   374

				buff += 4;

   375

			}

   376

			break;

   377

		}

   378

   379

		// 0x85 is used as escape character..

   380

		case 0x85:

   381

			switch(*str++) {

   382

			case 0: /* {CURRCOMPACT} */

   383

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

   384

				break;

   385

			case 1: /* {INT32} */

   386

				buff = FormatNoCommaNumber(buff, GetParamInt32());

   387

				break;

   388

			case 2: /* {REV} */

   389

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

   390

				break;

   391

			case 3: { /* {SHORTCARGO} */

   392

				// Short description of cargotypes. Layout:

   393

				// 8-bit = cargo type

   394

				// 16-bit = cargo count

   395

				char *s;

   396

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

   397

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

   398

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

   399

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

   400

				s = GetStringPtr(cargo_str);

   401

   402

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

   403

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

   404

			}	break;

   405

			case 4: /* {CURRCOMPACT64} */

   406

				// 64 bit compact currency-unit

   407

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

   408

				break;

   409

   410

			default:

   411

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

   412

			}

   413

			break;

   414

   415

		case 0x86: // {SKIP}

   416

			GetParamInt16();

   417

			//assert(0);

   418

			break;

   419

		case 0x87: { // {VOLUME}

   420

			char *s;

   421

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

   422

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

   423

			s = GetStringPtr(STR_LITERS);

   424

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

   425

			break;

   426

		}

   427

   428

		case 0x88: // {STRING}

   429

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

   430

			break;

   431

   432

		case 0x99: { // {CARGO}

   433

			// Layout now is:

   434

			//   8bit   - cargo type

   435

			//   16-bit - cargo count

   436

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

   437

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

   438

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

   439

			buff = GetString(buff, cargo_str);

   440

			break;

   441

		}

   442

   443

		case 0x9A: { // {STATION}

   444

			Station *st;

   445

			InjectDparam(1);

   446

			st = GetStation(GetDParam(1));

   447

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

   448

				buff = GetString(buff, STR_UNKNOWN_DESTINATION);

   449

				break;

   450

			}

   451

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

   452

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

   453

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

   454

			break;

   455

		}

   456

		case 0x9B: { // {TOWN}

   457

			Town *t;

   458

			t = GetTown(GetDParam(0));

   459

			assert(t->xy);

   460

			SetDParam(0, t->townnameparts);

   461

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

   462

			break;

   463

		}

   464

   465

		case 0x9C: { // {CURRENCY64}

   466

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

   467

			break;

   468

		}

   469

   470

		case 0x9D: { // {WAYPOINT}

   471

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

   472

			StringID str;

   473

			int idx;

   474

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

   475

				GetParamInt32(); // skip it

   476

				str = cp->town_or_string;

   477

			} else {

   478

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

   479

				if (idx == 0) {

   480

					str = STR_WAYPOINTNAME_CITY;

   481

				} else {

   482

					InjectDparam(1);

   483

					SetDParam(1, idx + 1);

   484

					str = STR_WAYPOINTNAME_CITY_SERIAL;

   485

				}

   486

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

   487

			}

   488

   489

			buff = GetString(buff, str);

   490

		} break;

   491

   492

		case 0x9E: { // {DATE_TINY}

   493

			buff = FormatTinyDate(buff, GetParamUint16());

   494

			break;

   495

		}

   496

   497

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

   498

		// case 0xE: // {TINYFONT}

   499

		// case 0xF: // {BIGFONT}

   500

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

   501

		default:

   502

			*buff++ = b;

   503

		}

   504

	}

   505

	buff[0] = 0;

   506

	return buff;

   507

}

   508

   509

   510

static byte *StationGetSpecialString(byte *buff)

   511

{

   512

	int x = GetParamInt8();

   513

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

   514

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

   515

	if (x & 4) *buff++ = 0xB6;