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

#endif

    25

    26

#ifdef WITH_REV

    27

extern const char _openttd_revision[];

    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

};

    77

    78

const uint16 _currency_string_list[] = {

    79

	STR_CURR_POUNDS,

    80

	STR_CURR_DOLLARS,

    81

	STR_CURR_FF,

    82

	STR_CURR_DM,

    83

	STR_CURR_YEN,

    84

	STR_CURR_PT,

    85

	STR_CURR_FT,

    86

	STR_CURR_ZL,

    87

	STR_CURR_ATS,

    88

	STR_CURR_BEF,

    89

	STR_CURR_DKK,

    90

	STR_CURR_FIM,

    91

	STR_CURR_GRD,

    92

	STR_CURR_CHF,

    93

	STR_CURR_NLG,

    94

	STR_CURR_ITL,

    95

	STR_CURR_SEK,

    96

	STR_CURR_RUR,

    97

	STR_CURR_CZK,

    98

	STR_CURR_ISK,

    99

	STR_CURR_NOK,

   100

	STR_CURR_EUR,

   101

	INVALID_STRING_ID

   102

};

   103

   104

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

   105

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

   106

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

   107

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

   108

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

   109

};

   110

   111

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

   112

uint GetMaskOfAllowedCurrencies()

   113

{

   114

	int i;

   115

	uint mask = 0;

   116

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

   117

		byte flags = _currency_specs[i].flags;

   118

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

   119

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

   120

		mask |= (1 << i);

   121

	}

   122

	return mask;

   123

}

   124

   125

void CheckSwitchToEuro()

   126

{

   127

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

   128

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

   129

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

   130

	}

   131

}

   132

   133

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

   134

{

   135

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

   136

	return dst - 1;

   137

}

   138

   139

static byte *GetStringPtr(uint16 string)

   140

{

   141

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

   142

}

   143

   144

byte *GetString(byte *buffr, uint16 string)

   145

{

   146

	uint index = string & 0x7FF;

   147

	uint tab = string >> 11;

   148

   149

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

   150

   151

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

   152

		return GetSpecialTownNameString(buffr, index - 0xC0);

   153

   154

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

   155

		return StationGetSpecialString(buffr);

   156

   157

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

   158

		return GetSpecialPlayerNameString(buffr, index - 0xE4);

   159

   160

	if ( tab == 15)

   161

		return GetName(index, buffr);

   162

   163

	// tab 31 is used for special or dynamic strings

   164

	if ( tab == 31) {

   165

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

   166

	}

   167

   168

	if (index >= _langtab_num[tab])

   169

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

   170

   171

	return DecodeString(buffr, GetStringPtr(string));

   172

}

   173

   174

void InjectDparam(int amount) 

   175

{

   176

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

   177

}

   178

   179

   180

int32 GetParamInt32()

   181

{

   182

	int32 result = GET_DPARAM32(0);

   183

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

   184

	return result;

   185

}

   186

   187

int64 GetParamInt64()

   188

{

   189

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

   190

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

   191

	return result;

   192

}

   193

   194

   195

int GetParamInt16()

   196

{

   197

	int result = (int16)GET_DPARAM16(0);

   198

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

   199

	return result;

   200

}

   201

   202

int GetParamInt8()

   203

{

   204

	int result = (int8)GET_DPARAM8(0);

   205

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

   206

	return result;

   207

}

   208

   209

int GetParamUint16()

   210

{

   211

	int result = GET_DPARAM16(0);

   212

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

   213

	return result;

   214

}

   215

   216

static const uint32 _divisor_table[] = {

   217

	1000000000,

   218

	100000000,

   219

	10000000,

   220

	1000000,

   221

   222

	100000,

   223

	10000,

   224

	1000,

   225

	100,

   226

	10,

   227

	1

   228

};

   229

   230

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

   231

{

   232

	uint32 quot,divisor;

   233

	int i;

   234

	uint32 tot;

   235

	uint32 num;

   236

   237

	if (number < 0) {

   238

		*buff++ = '-';

   239

		number = -number;

   240

	}

   241

   242

	num = number;

   243

   244

	tot = 0;

   245

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

   246

		divisor = _divisor_table[i];

   247

		quot = 0;

   248

		if (num >= divisor) {

   249

			quot = num / _divisor_table[i];

   250

			num = num % _divisor_table[i];

   251

		}

   252

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

   253

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

   254

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

   255

		}

   256

	}

   257

   258

	*buff = 0;

   259

   260

	return buff;

   261

}

   262

   263

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

   264

{

   265

	uint32 quot,divisor;

   266

	int i;

   267

	uint32 tot;

   268

	uint32 num;

   269

   270

	if (number < 0) {

   271

		*buff++ = '-';

   272

		number = -number;

   273

	}

   274

   275

	num = number;

   276

   277

	tot = 0;

   278

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

   279

		divisor = _divisor_table[i];

   280

		quot = 0;

   281

		if (num >= divisor) {

   282

			quot = num / _divisor_table[i];

   283

			num = num % _divisor_table[i];

   284

		}

   285

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

   286

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

   287

		}

   288

	}

   289

   290

	*buff = 0;

   291

   292

	return buff;

   293

}

   294

   295

   296

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

   297

{

   298

	const byte *src;

   299

	YearMonthDay ymd;

   300

   301

	ConvertDayToYMD(&ymd, number);

   302

   303

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

   304

   305

	buff[-1] = ' ';

   306

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

   307

	buff[3] = ' ';

   308

   309

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

   310

}

   311

   312

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

   313

{

   314

	const char *src;

   315

	YearMonthDay ymd;

   316

   317

	ConvertDayToYMD(&ymd, number);

   318

   319

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

   320

	buff[-1] = ' ';

   321

   322

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

   323

}

   324

   325

uint GetCurrentCurrencyRate() {

   326

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

   327

}

   328

   329

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

   330

{

   331

	const char *s;

   332

	char c;

   333

	char buf[40], *p;

   334

	int j;

   335

   336

	// multiply by exchange rate

   337

	number *= spec->rate;

   338

   339

	// convert from negative

   340

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

   341

   342

	// add pre part

   343

	s = spec->pre;

   344

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

   345

   346

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

   347

	if (compact) {

   348

		compact = 0;

   349

		if (number >= 1000000000) {

   350

			number = (number + 500000) / 1000000;

   351

			compact = 'M';

   352

		} else if (number >= 1000000) {

   353

			number = (number + 500) / 1000;

   354

			compact = 'k';

   355

		}	

   356

	}

   357

   358

	// convert to ascii number and add commas

   359

	p = buf;

   360

	j = 4;

   361

	do { 

   362

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

   363

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

   364

	} while (number /= 10);

   365

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

   366

   367

	if (compact) *buff++ = compact;

   368

   369

	// add post part

   370

	s = spec->post;

   371

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

   372

   373

	return buff;

   374

}

   375

   376

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

   377

{

   378

	byte b;

   379

   380

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

   381

		switch(b) {

   382

		case 0x1: // {SETX}

   383

			*buff++ = b;

   384

			*buff++ = *str++;

   385

			break;

   386

		case 0x2: // {SETXY}

   387

			*buff++ = b;

   388

			*buff++ = *str++;

   389

			*buff++ = *str++;

   390

			break;

   391

		case 0x7B: // {COMMA32}

   392

			buff = FormatCommaNumber(buff, GetParamInt32());

   393

			break;

   394

		case 0x7C: // {COMMA16}

   395

			buff = FormatCommaNumber(buff, GetParamInt16());

   396

			break;

   397

		case 0x7D: // {COMMA8}

   398

			buff = FormatCommaNumber(buff, GetParamInt8());

   399

			break;

   400

		case 0x7E: // {NUMU16}

   401

			buff = FormatNoCommaNumber(buff, GetParamInt16());

   402

			break;

   403

		case 0x7F: // {CURRENCY}

   404

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

   405

			break;

   406

		// 0x80 is reserved for EURO

   407

		case 0x81: // {STRINL}

   408

			str += 2;

   409

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

   410

			break;

   411

		case 0x82: // {DATE_LONG}

   412

			buff = FormatYmdString(buff, GetParamUint16());

   413

			break;

   414

		case 0x83: // {DATE_SHORT}

   415

			buff = FormatMonthAndYear(buff, GetParamUint16());

   416

			break;

   417

		case 0x84: {// {VELOCITY}

   418

			int value = GetParamInt16();

   419

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

   420

			buff = FormatCommaNumber(buff, value);

   421

			if (_opt.kilometers) {

   422

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

   423

				buff += 5;

   424

			} else {

   425

				memcpy(buff, " mph", 4);

   426

				buff += 4;

   427

			}

   428

			break;

   429

		}

   430

   431

		// 0x85 is used as escape character.. 

   432

		case 0x85:

   433

			switch(*str++) {

   434

			case 0:

   435

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

   436

				break;

   437

			case 1: // {INT32}

   438

				buff = FormatNoCommaNumber(buff, GetParamInt32());

   439

				break;

   440

   441

			case 2: // {REV}

   442

#ifdef WITH_REV

   443

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

   444

#endif

   445

				break;

   446

			case 3: { // {SHORTCARGO}

   447

				// Layout:

   448

				// 8-bit = cargo type

   449

				// 16-bit = cargo count

   450

				char *s;

   451

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

   452

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

   453

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

   454

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

   455

				s = GetStringPtr(cargo_str);

   456

   457

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

   458

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

   459

				break;

   460

			}

   461

   462

			default:

   463

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

   464

			}

   465

			break;

   466

   467

		case 0x86: // {SKIP}

   468

			GetParamInt16();

   469

			//assert(0);

   470

			break;

   471

		case 0x87: { // {VOLUME}

   472

			char *s;

   473

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

   474

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

   475

			s = GetStringPtr(STR_LITERS);

   476

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

   477

			break;

   478

		}

   479

   480

		case 0x88: // {STRING}

   481

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

   482

			break;

   483

   484

		case 0x99: { // {CARGO}

   485

			// Layout now is:

   486

			//   8bit   - cargo type

   487

			//   16-bit - cargo count

   488

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

   489

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

   490

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

   491

			buff = GetString(buff, cargo_str);

   492

			break;

   493

		}

   494

   495

		case 0x9A: { // {STATION}

   496

			Station *st;

   497

			InjectDparam(1);

   498

			st = DEREF_STATION(GET_DPARAM16(1));

   503

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

   504

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

   505

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

   506

			break;

   507

		}

   508

		case 0x9B: { // {TOWN}

   509

			Town *t;

   510

			t = DEREF_TOWN(GET_DPARAM16(0));

   511

			assert(t->xy);

   512

			SET_DPARAM32(0, t->townnameparts);

   513

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

   514

			break;

   515

		}

   516

   517

		case 0x9C: { // {CURRENCY64}

   518

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

   519

			break;

   520

		}

   521

   522

		case 0x9D: { // {CHECKPOINT}

   523

			Checkpoint *cp = &_checkpoints[GET_DPARAM16(0)];

   524

			StringID str;

   525

			int idx;

   526

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

   527

				GetParamInt32(); // skip it

   528

				str = cp->town_or_string;