1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "station.h"

     4

#include "town.h"

     5

#include "vehicle.h"

     6

#include "news.h"

     7

     8

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

     9

    10

static byte *StationGetSpecialString(byte *buff);

    11

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

    12

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

    13

    14

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

    15

    16

static byte **_langpack_offs;

    17

static byte *_langpack;

    18

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

    19

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

    20

    21

#ifdef WITH_REV_HACK

    22

	#define WITH_REV

    23

	const char _openttd_revision[] = WITH_REV_HACK;

    24

#else

    25

	#ifdef WITH_REV

    26

	extern const char _openttd_revision[];

    27

	#endif

    28

#endif

    29

    30

typedef byte *PlayerNameGeneratorProc(byte *buffr);

    31

    32

typedef struct {

    33

	uint32 ident;

    34

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

    35

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

    36

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

    37

	uint16 offsets[32];	// the offsets

    38

} LanguagePackHeader;

    39

    40

typedef struct {

    41

	uint16 rate;

    42

	char separator;

    43

	byte flags;

    44

	char pre[4];

    45

	char post[4];

    46

} CurrencySpec;

    47

    48

enum {

    49

	CF_TOEURO_2002 = 1,

    50

	CF_ISEURO = 2,

    51

};

    52

    53

static const CurrencySpec _currency_specs[] = {

    54

	{ 1,   ',', 0,              "\xA3", "" },     // british pounds

    55

	{ 2,   ',', 0,              "$",    "" },     // us dollars

    56

	{ 10,  '.', CF_TOEURO_2002, "FF ",  "" },     // french francs

    57

	{ 4,   '.', CF_TOEURO_2002, "DM ",  "" },     // deutsche mark

    58

	{ 200, ',', 0,              "\xA5", "" },     // yen

    59

	{ 200, '.', CF_TOEURO_2002, "Pt",   "" },     // spanish pesetas

    60

	{ 376, ',', CF_TOEURO_2002, "",     " Ft" },

    61

	{ 6,   ' ', 0,              "",     " zl" },

    62

	{ 19,  ',', CF_TOEURO_2002, "ATS ", "" },

    63

	{ 57,  ',', CF_TOEURO_2002, "BEF ", "" },

    64

	{ 10,  '.', 0,              "",     " kr" },

    65

	{ 8,   ',', CF_TOEURO_2002, "FIM ", "" },

    66

	{ 480, ',', CF_TOEURO_2002, "GRD ", "" },

    67

	{ 2,   ',', 0,              "CHF ", "" },

    68

	{ 3,   ',', CF_TOEURO_2002, "NLG ", "" },

    69

	{ 2730,',', CF_TOEURO_2002, "ITL ", "" },

    70

	{ 13,  '.', 0,              "",     " kr" },

    71

	{ 5,   ' ', 0,              "",     " rur" },

    72

	{ 50,  ',', 0,              "",     " Kc" },

    73

	{ 130, '.', 0,              "",     " kr" },

    74

	{ 11,  '.', 0,              "",     " kr" },

    75

	{ 2,   ',', CF_ISEURO,      "€",    "" },

    76

	{ 6,   '.', 0,              "",     " Lei" },

    77

};

    78

    79

const uint16 _currency_string_list[] = {

    80

	STR_CURR_POUNDS,

    81

	STR_CURR_DOLLARS,

    82

	STR_CURR_FF,

    83

	STR_CURR_DM,

    84

	STR_CURR_YEN,

    85

	STR_CURR_PT,

    86

	STR_CURR_FT,

    87

	STR_CURR_ZL,

    88

	STR_CURR_ATS,

    89

	STR_CURR_BEF,

    90

	STR_CURR_DKK,

    91

	STR_CURR_FIM,

    92

	STR_CURR_GRD,

    93

	STR_CURR_CHF,

    94

	STR_CURR_NLG,

    95

	STR_CURR_ITL,

    96

	STR_CURR_SEK,

    97

	STR_CURR_RUR,

    98

	STR_CURR_CZK,

    99

	STR_CURR_ISK,

   100

	STR_CURR_NOK,

   101

	STR_CURR_EUR,

   102

	STR_CURR_ROL,

   103

	INVALID_STRING_ID

   104

};

   105

   106

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

   107

	/* 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},

   108

	/* 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},

   109

	/* 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},

   110

	/* 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}

   111

};

   112

   113

// get a mask of the allowed currencies depending on the year

   114

uint GetMaskOfAllowedCurrencies()

   115

{

   116

	int i;

   117

	uint mask = 0;

   118

	for(i=0; i!=lengthof(_currency_specs); i++) {

   119

		byte flags = _currency_specs[i].flags;

   120

		if (_cur_year >= (2002-1920) && (flags & CF_TOEURO_2002)) continue;

   121

		if (_cur_year < (2000-1920) && (flags & CF_ISEURO)) continue;

   122

		mask |= (1 << i);

   123

	}

   124

	return mask;

   125

}

   126

   127

void CheckSwitchToEuro()

   128

{

   129

	if (_cur_year >= (2002-1920) && _currency_specs[_opt.currency].flags & CF_TOEURO_2002) {

   130

		_opt.currency = 21; // this is the index of euro above.

   131

		AddNewsItem(STR_EURO_INTRODUCE, NEWS_FLAGS(NM_NORMAL,0,NT_ECONOMY,0), 0, 0);

   132

	}

   133

}

   134

   135

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

   136

{

   137

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

   138

	return dst - 1;

   139

}

   140

   141

static byte *GetStringPtr(uint16 string)

   142

{

   143

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

   144

}

   145

   146

byte *GetString(byte *buffr, uint16 string)

   147

{

   148

	uint index = string & 0x7FF;

   149

	uint tab = string >> 11;

   150

   151

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

   152

   153

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

   154

		return GetSpecialTownNameString(buffr, index - 0xC0);

   155

   156

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

   157

		return StationGetSpecialString(buffr);

   158

   159

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

   160

		return GetSpecialPlayerNameString(buffr, index - 0xE4);

   161

   162

	if ( tab == 15)

   163

		return GetName(index, buffr);

   164

   165

	// tab 31 is used for special or dynamic strings

   166

	if ( tab == 31) {

   167

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

   168

	}

   169

   170

	if (index >= _langtab_num[tab])

   171

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

   172

   173

	return DecodeString(buffr, GetStringPtr(string));

   174

}

   175

   176

void InjectDparam(int amount)

   177

{

   178

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

   179

}

   180

   181

   182

int32 GetParamInt32()

   183

{

   184

	int32 result = GET_DPARAM32(0);

   185

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

   186

	return result;

   187

}

   188

   189

static int64 GetParamInt64()

   190

{

   191

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

   192

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

   193

	return result;

   194

}

   195

   196

   197

int GetParamInt16()

   198

{

   199

	int result = (int16)GET_DPARAM16(0);

   200

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

   201

	return result;

   202

}

   203

   204

int GetParamInt8()

   205

{

   206

	int result = (int8)GET_DPARAM8(0);

   207

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

   208

	return result;

   209

}

   210

   211

int GetParamUint16()

   212

{

   213

	int result = GET_DPARAM16(0);

   214

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

   215

	return result;

   216

}

   217

   218

static const uint32 _divisor_table[] = {

   219

	1000000000,

   220

	100000000,

   221

	10000000,

   222

	1000000,

   223

   224

	100000,

   225

	10000,

   226

	1000,

   227

	100,

   228

	10,

   229

	1

   230

};

   231

   232

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

   233

{

   234

	uint32 quot,divisor;

   235

	int i;

   236

	uint32 tot;

   237

	uint32 num;

   238

   239

	if (number < 0) {

   240

		*buff++ = '-';

   241

		number = -number;

   242

	}

   243

   244

	num = number;

   245

   246

	tot = 0;

   247

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

   248

		divisor = _divisor_table[i];

   249

		quot = 0;

   250

		if (num >= divisor) {

   251

			quot = num / _divisor_table[i];

   252

			num = num % _divisor_table[i];

   253

		}

   254

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

   255

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

   256

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

   257

		}

   258

	}

   259

   260

	*buff = 0;

   261

   262

	return buff;

   263

}

   264

   265

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

   266

{

   267

	uint32 quot,divisor;

   268

	int i;

   269

	uint32 tot;

   270

	uint32 num;

   271

   272

	if (number < 0) {

   273

		*buff++ = '-';

   274

		number = -number;

   275

	}

   276

   277

	num = number;

   278

   279

	tot = 0;

   280

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

   281

		divisor = _divisor_table[i];

   282

		quot = 0;

   283

		if (num >= divisor) {

   284

			quot = num / _divisor_table[i];

   285

			num = num % _divisor_table[i];

   286

		}

   287

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

   288

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

   289

		}

   290

	}

   291

   292

	*buff = 0;

   293

   294

	return buff;

   295

}

   296

   297

   298

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

   299

{

   300

	const byte *src;

   301

	YearMonthDay ymd;

   302

   303

	ConvertDayToYMD(&ymd, number);

   304

   305

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

   306

   307

	buff[-1] = ' ';

   308

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

   309

	buff[3] = ' ';

   310

   311

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

   312

}

   313

   314

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

   315

{

   316

	const char *src;

   317

	YearMonthDay ymd;

   318

   319

	ConvertDayToYMD(&ymd, number);

   320

   321

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

   322

	buff[-1] = ' ';

   323

   324

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

   325

}

   326

   327

uint GetCurrentCurrencyRate() {

   328

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

   329

}

   330

   331

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

   332

{

   333

	const char *s;

   334

	char c;

   335

	char buf[40], *p;

   336

	int j;

   337

   338

	// multiply by exchange rate

   339

	number *= spec->rate;

   340

   341

	// convert from negative

   342

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

   343

   344

	// add pre part

   345

	s = spec->pre;

   346

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

   347

   348

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

   349

	if (compact) {

   350

		compact = 0;

   351

		if (number >= 1000000000) {

   352

			number = (number + 500000) / 1000000;

   353

			compact = 'M';

   354

		} else if (number >= 1000000) {

   355

			number = (number + 500) / 1000;

   356

			compact = 'k';

   357

		}

   358

	}

   359

   360

	// convert to ascii number and add commas

   361

	p = buf;

   362

	j = 4;

   363

	do {

   364

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

   365

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

   366

	} while (number /= 10);

   367

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

   368

   369

	if (compact) *buff++ = compact;

   370

   371

	// add post part

   372

	s = spec->post;

   373

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

   374

   375

	return buff;

   376

}

   377

   378

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

   379

{

   380

	byte b;

   381

   382

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

   383

		switch(b) {

   384

		case 0x1: // {SETX}

   385

			*buff++ = b;

   386

			*buff++ = *str++;

   387

			break;

   388

		case 0x2: // {SETXY}

   389

			*buff++ = b;

   390

			*buff++ = *str++;

   391

			*buff++ = *str++;

   392

			break;

   393

		case 0x7B: // {COMMA32}

   394

			buff = FormatCommaNumber(buff, GetParamInt32());

   395

			break;

   396

		case 0x7C: // {COMMA16}

   397

			buff = FormatCommaNumber(buff, GetParamInt16());

   398

			break;

   399

		case 0x7D: // {COMMA8}

   400

			buff = FormatCommaNumber(buff, GetParamInt8());

   401

			break;

   402

		case 0x7E: // {NUMU16}

   403

			buff = FormatNoCommaNumber(buff, GetParamInt16());

   404

			break;

   405

		case 0x7F: // {CURRENCY}

   406

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

   407

			break;

   408

		// 0x80 is reserved for EURO

   409

		case 0x81: // {STRINL}

   410

			str += 2;

   411

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

   412

			break;

   413

		case 0x82: // {DATE_LONG}

   414

			buff = FormatYmdString(buff, GetParamUint16());

   415

			break;

   416

		case 0x83: // {DATE_SHORT}

   417

			buff = FormatMonthAndYear(buff, GetParamUint16());

   418

			break;

   419

		case 0x84: {// {VELOCITY}

   420

			int value = GetParamInt16();

   421

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

   422

			buff = FormatCommaNumber(buff, value);

   423

			if (_opt.kilometers) {

   424

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

   425

				buff += 5;

   426

			} else {

   427

				memcpy(buff, " mph", 4);

   428

				buff += 4;

   429

			}

   430

			break;

   431

		}

   432

   433

		// 0x85 is used as escape character..

   434

		case 0x85:

   435

			switch(*str++) {

   436

			case 0: /* {CURRCOMPACT} */

   437

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

   438

				break;

   439

			case 1: /* {INT32} */

   440

				buff = FormatNoCommaNumber(buff, GetParamInt32());

   441

				break;

   442

			case 2: /* {REV} */

   443

#ifdef WITH_REV

   444

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

   445

#endif

   446

				break;

   447

			case 3: { /* {SHORTCARGO} */

   448

				// Short description of cargotypes. Layout:

   449

				// 8-bit = cargo type

   450

				// 16-bit = cargo count

   451

				char *s;

   452

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

   453

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

   454

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

   455

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

   456

				s = GetStringPtr(cargo_str);

   457

   458

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

   459

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

   460

			}	break;

   461

			case 4: /* {CURRCOMPACT64} */

   462

				// 64 bit compact currency-unit

   463

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

   464

				break;

   465

   466

			default:

   467

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

   468

			}

   469

			break;

   470

   471

		case 0x86: // {SKIP}

   472

			GetParamInt16();

   473

			//assert(0);

   474

			break;

   475

		case 0x87: { // {VOLUME}

   476

			char *s;

   477

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

   478

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

   479

			s = GetStringPtr(STR_LITERS);

   480

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

   481

			break;

   482

		}

   483

   484

		case 0x88: // {STRING}

   485

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

   486

			break;

   487

   488

		case 0x99: { // {CARGO}

   489

			// Layout now is:

   490

			//   8bit   - cargo type

   491

			//   16-bit - cargo count

   492

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

   493

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

   494

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

   495

			buff = GetString(buff, cargo_str);

   496

			break;

   497

		}

   498

   499

		case 0x9A: { // {STATION}

   500

			Station *st;

   501

			InjectDparam(1);

   502

			st = DEREF_STATION(GET_DPARAM16(1));

   503

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

   504

				buff = GetString(buff, STR_UNKNOWN_DESTINATION);

   505

				break;

   506

			}

   507

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

   508

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

   509

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

   510

			break;

   511

		}

   512

		case 0x9B: { // {TOWN}

   513

			Town *t;

   514

			t = DEREF_TOWN(GET_DPARAM16(0));

   515

			assert(t->xy);

   516

			SET_DPARAM32(0, t->townnameparts);

   517

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

   518

			break;

   519

		}

   520

   521

		case 0x9C: { // {CURRENCY64}

   522

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

   523

			break;