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

#include "screenshot.h"

     8

     9

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

    10

    11

static byte *StationGetSpecialString(byte *buff);

    12

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

    13

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

    14

    15

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

    16

    17

static byte **_langpack_offs;

    18

static byte *_langpack;

    19

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

    20

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

    21

    22

#ifdef WITH_REV_HACK

    23

	#define WITH_REV

    24

	const char _openttd_revision[] = WITH_REV_HACK;

    25

#else

    26

	#ifdef WITH_REV

    27

	extern const char _openttd_revision[];

    28

	#endif

    29

#endif

    30

    31

typedef byte *PlayerNameGeneratorProc(byte *buffr);

    32

    33

typedef struct {

    34

	uint32 ident;

    35

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

    36

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

    37

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

    38

	uint16 offsets[32];	// the offsets

    39

} LanguagePackHeader;

    40

    41

typedef struct {

    42

	uint16 rate;

    43

	char separator;

    44

	byte flags;

    45

	char pre[4];

    46

	char post[4];

    47

} CurrencySpec;

    48

    49

enum {

    50

	CF_TOEURO_2002 = 1,

    51

	CF_ISEURO = 2,

    52

};

    53

    54

static const CurrencySpec _currency_specs[] = {

    55

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

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

};

    79

    80

const uint16 _currency_string_list[] = {

    81

	STR_CURR_POUNDS,

    82

	STR_CURR_DOLLARS,

    83

	STR_CURR_FF,

    84

	STR_CURR_DM,

    85

	STR_CURR_YEN,

    86

	STR_CURR_PT,

    87

	STR_CURR_FT,

    88

	STR_CURR_ZL,

    89

	STR_CURR_ATS,

    90

	STR_CURR_BEF,

    91

	STR_CURR_DKK,

    92

	STR_CURR_FIM,

    93

	STR_CURR_GRD,

    94

	STR_CURR_CHF,

    95

	STR_CURR_NLG,

    96

	STR_CURR_ITL,

    97

	STR_CURR_SEK,

    98

	STR_CURR_RUR,

    99

	STR_CURR_CZK,

   100

	STR_CURR_ISK,

   101

	STR_CURR_NOK,

   102

	STR_CURR_EUR,

   103

	STR_CURR_ROL,

   104

	INVALID_STRING_ID

   105

};

   106

   107

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

   108

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

   109

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

   110

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

   111

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

   112

};

   113

   114

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

   115

uint GetMaskOfAllowedCurrencies()

   116

{

   117

	int i;

   118

	uint mask = 0;

   119

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

   120

		byte flags = _currency_specs[i].flags;

   121

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

   122

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

   123

		mask |= (1 << i);

   124

	}

   125

	return mask;

   126

}

   127

   128

void CheckSwitchToEuro()

   129

{

   130

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

   131

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

   132

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

   133

	}

   134

}

   135

   136

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

   137

{

   138

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

   139

	return dst - 1;

   140

}

   141

   142

static byte *GetStringPtr(uint16 string)

   143

{

   144

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

   145

}

   146

   147

byte *GetString(byte *buffr, uint16 string)

   148

{

   149

	uint index = string & 0x7FF;

   150

	uint tab = string >> 11;

   151

   152

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

   153

   154

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

   155

		return GetSpecialTownNameString(buffr, index - 0xC0);

   156

   157

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

   158

		return StationGetSpecialString(buffr);

   159

   160

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

   161

		return GetSpecialPlayerNameString(buffr, index - 0xE4);

   162

   163

	if ( tab == 15)

   164

		return GetName(index, buffr);

   165

   166

	// tab 31 is used for special or dynamic strings

   167

	if ( tab == 31) {

   168

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

   169

	}

   170

   171

	if (index >= _langtab_num[tab])

   172

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

   173

   174

	return DecodeString(buffr, GetStringPtr(string));

   175

}

   176

   177

void InjectDparam(int amount)

   178

{

   179

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

   180

}

   181

   182

   183

int32 GetParamInt32()

   184

{

   185

	int32 result = GET_DPARAM32(0);

   186

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

   187

	return result;

   188

}

   189

   190

static int64 GetParamInt64()

   191

{

   192

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

   193

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

   194

	return result;

   195

}

   196

   197

   198

int GetParamInt16()

   199

{

   200

	int result = (int16)GET_DPARAM16(0);

   201

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

   202

	return result;

   203

}

   204

   205

int GetParamInt8()

   206

{

   207

	int result = (int8)GET_DPARAM8(0);

   208

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

   209

	return result;

   210

}

   211

   212

int GetParamUint16()

   213

{

   214

	int result = GET_DPARAM16(0);

   215

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

   216

	return result;

   217

}

   218

   219

static const uint32 _divisor_table[] = {

   220

	1000000000,

   221

	100000000,

   222

	10000000,

   223

	1000000,

   224

   225

	100000,

   226

	10000,

   227

	1000,

   228

	100,

   229

	10,

   230

	1

   231

};

   232

   233

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

   234

{

   235

	uint32 quot,divisor;

   236

	int i;

   237

	uint32 tot;

   238

	uint32 num;

   239

   240

	if (number < 0) {

   241

		*buff++ = '-';

   242

		number = -number;

   243

	}

   244

   245

	num = number;

   246

   247

	tot = 0;

   248

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

   249

		divisor = _divisor_table[i];

   250

		quot = 0;

   251

		if (num >= divisor) {

   252

			quot = num / _divisor_table[i];

   253

			num = num % _divisor_table[i];

   254

		}

   255

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

   256

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

   257

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

   258

		}

   259

	}

   260

   261

	*buff = 0;

   262

   263

	return buff;

   264

}

   265

   266

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

   267

{

   268

	uint32 quot,divisor;

   269

	int i;

   270

	uint32 tot;

   271

	uint32 num;

   272

   273

	if (number < 0) {

   274

		*buff++ = '-';

   275

		number = -number;

   276

	}

   277

   278

	num = number;

   279

   280

	tot = 0;

   281

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

   282

		divisor = _divisor_table[i];

   283

		quot = 0;

   284

		if (num >= divisor) {

   285

			quot = num / _divisor_table[i];

   286

			num = num % _divisor_table[i];

   287

		}

   288

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

   289

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

   290

		}

   291

	}

   292

   293

	*buff = 0;

   294

   295

	return buff;

   296

}

   297

   298

   299

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

   300

{

   301

	const byte *src;

   302

	YearMonthDay ymd;

   303

   304

	ConvertDayToYMD(&ymd, number);

   305

   306

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

   307

   308

	buff[-1] = ' ';

   309

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

   310

	buff[3] = ' ';

   311

   312

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

   313

}

   314

   315

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

   316

{

   317

	const char *src;

   318

	YearMonthDay ymd;

   319

   320

	ConvertDayToYMD(&ymd, number);

   321

   322

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

   323

	buff[-1] = ' ';

   324

   325

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

   326

}

   327

   328

uint GetCurrentCurrencyRate() {

   329

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

   330

}

   331

   332

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

   333

{

   334

	const char *s;

   335

	char c;

   336

	char buf[40], *p;

   337

	int j;

   338

   339

	// multiply by exchange rate

   340

	number *= spec->rate;

   341

   342

	// convert from negative

   343

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

   344

   345

	// add pre part

   346

	s = spec->pre;

   347

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

   348

   349

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

   350

	if (compact) {

   351

		compact = 0;

   352

		if (number >= 1000000000) {

   353

			number = (number + 500000) / 1000000;

   354

			compact = 'M';

   355

		} else if (number >= 1000000) {

   356

			number = (number + 500) / 1000;

   357

			compact = 'k';

   358

		}

   359

	}

   360

   361

	// convert to ascii number and add commas

   362

	p = buf;

   363

	j = 4;

   364

	do {

   365

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

   366

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

   367

	} while (number /= 10);

   368

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

   369

   370

	if (compact) *buff++ = compact;

   371

   372

	// add post part

   373

	s = spec->post;

   374

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

   375

   376

	return buff;

   377

}

   378

   379

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

   380

{

   381

	byte b;

   382

   383

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

   384

		switch(b) {

   385

		case 0x1: // {SETX}

   386

			*buff++ = b;

   387

			*buff++ = *str++;

   388

			break;

   389

		case 0x2: // {SETXY}

   390

			*buff++ = b;

   391

			*buff++ = *str++;

   392

			*buff++ = *str++;

   393

			break;

   394

		case 0x7B: // {COMMA32}

   395

			buff = FormatCommaNumber(buff, GetParamInt32());

   396

			break;

   397

		case 0x7C: // {COMMA16}

   398

			buff = FormatCommaNumber(buff, GetParamInt16());

   399

			break;

   400

		case 0x7D: // {COMMA8}

   401

			buff = FormatCommaNumber(buff, GetParamInt8());

   402

			break;

   403

		case 0x7E: // {NUMU16}

   404

			buff = FormatNoCommaNumber(buff, GetParamInt16());

   405

			break;

   406

		case 0x7F: // {CURRENCY}

   407

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

   408

			break;

   409

		// 0x80 is reserved for EURO

   410

		case 0x81: // {STRINL}

   411

			str += 2;

   412

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

   413

			break;

   414

		case 0x82: // {DATE_LONG}

   415

			buff = FormatYmdString(buff, GetParamUint16());

   416

			break;

   417

		case 0x83: // {DATE_SHORT}

   418

			buff = FormatMonthAndYear(buff, GetParamUint16());

   419

			break;

   420

		case 0x84: {// {VELOCITY}

   421

			int value = GetParamInt16();

   422

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

   423

			buff = FormatCommaNumber(buff, value);

   424

			if (_opt.kilometers) {

   425

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

   426

				buff += 5;

   427

			} else {

   428

				memcpy(buff, " mph", 4);

   429

				buff += 4;

   430

			}

   431

			break;

   432

		}

   433

   434

		// 0x85 is used as escape character..

   435

		case 0x85:

   436

			switch(*str++) {

   437

			case 0: /* {CURRCOMPACT} */

   438

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

   439

				break;

   440

			case 1: /* {INT32} */

   441

				buff = FormatNoCommaNumber(buff, GetParamInt32());

   442

				break;

   443

			case 2: /* {REV} */

   444

#ifdef WITH_REV

   445

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

   446

#endif

   447

				break;

   448

			case 3: { /* {SHORTCARGO} */

   449

				// Short description of cargotypes. Layout:

   450

				// 8-bit = cargo type

   451

				// 16-bit = cargo count

   452

				char *s;

   453

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

   454

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

   455

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

   456

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

   457

				s = GetStringPtr(cargo_str);

   458

   459

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

   460

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

   461

			}	break;

   462

			case 4: /* {CURRCOMPACT64} */

   463

				// 64 bit compact currency-unit

   464

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

   465

				break;

   466

   467

			default:

   468

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

   469

			}

   470

			break;

   471

   472

		case 0x86: // {SKIP}

   473

			GetParamInt16();

   474

			//assert(0);

   475

			break;

   476

		case 0x87: { // {VOLUME}

   477

			char *s;

   478

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

   479

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

   480

			s = GetStringPtr(STR_LITERS);

   481

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

   482

			break;

   483

		}

   484

   485

		case 0x88: // {STRING}

   486

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

   487

			break;

   488

   489

		case 0x99: { // {CARGO}

   490

			// Layout now is:

   491

			//   8bit   - cargo type

   492

			//   16-bit - cargo count

   493

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

   494

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

   495

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

   496

			buff = GetString(buff, cargo_str);

   497

			break;

   498

		}

   499

   500

		case 0x9A: { // {STATION}

   501

			Station *st;

   502

			InjectDparam(1);

   503

			st = DEREF_STATION(GET_DPARAM16(1));

   504

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

   505

				buff = GetString(buff, STR_UNKNOWN_DESTINATION);

   506

				break;

   507

			}

   508

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

   509

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

   510

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

   511

			break;

   512

		}

   513

		case 0x9B: { // {TOWN}

   514

			Town *t;

   515

			t = DEREF_TOWN(GET_DPARAM16(0));

   516

			assert(t->xy);

   517

			SET_DPARAM32(0, t->townnameparts);

   518

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

   519

			break;

   520

		}

   521

   522

		case 0x9C: { // {CURRENCY64}