1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "string.h"

     4

#include "strings.h"

     5

#include "table/strings.h"

     6

#include "namegen.h"

     7

#include "station.h"

     8

#include "town.h"

     9

#include "vehicle.h"

    10

#include "news.h"

    11

#include "screenshot.h"

    12

#include "waypoint.h"

    13

    14

static char *StationGetSpecialString(char *buff);

    15

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

    16

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

    17

    18

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

    19

    20

extern const char _openttd_revision[];

    21

    22

typedef struct LanguagePack {

    23

	uint32 ident;

    24

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

    25

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

    26

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

    27

	char isocode[16];	// the ISO code for the language (not country code)

    28

	uint16 offsets[32];	// the offsets

    29

	char data[VARARRAY_SIZE];

    30

} LanguagePack;

    31

    32

static char **_langpack_offs;

    33

static LanguagePack *_langpack;

    34

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

    35

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

    36

    37

const StringID _currency_string_list[] = {

    38

	STR_CURR_GBP,

    39

	STR_CURR_USD,

    40

	STR_CURR_EUR,

    41

	STR_CURR_YEN,

    42

	STR_CURR_ATS,

    43

	STR_CURR_BEF,

    44

	STR_CURR_CHF,

    45

	STR_CURR_CZK,

    46

	STR_CURR_DEM,

    47

	STR_CURR_DKK,

    48

	STR_CURR_ESP,

    49

	STR_CURR_FIM,

    50

	STR_CURR_FRF,

    51

	STR_CURR_GRD,

    52

	STR_CURR_HUF,

    53

	STR_CURR_ISK,

    54

	STR_CURR_ITL,

    55

	STR_CURR_NLG,

    56

	STR_CURR_NOK,

    57

	STR_CURR_PLN,

    58

	STR_CURR_ROL,

    59

	STR_CURR_RUR,

    60

	STR_CURR_SEK,

    61

	STR_CURR_CUSTOM,

    62

	INVALID_STRING_ID

    63

};

    64

    65

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

    66

	{ /* LT_NORMAL */

    67

		STR_PASSENGERS,

    68

		STR_TONS,

    69

		STR_BAGS,

    70

		STR_LITERS,

    71

		STR_ITEMS,

    72

		STR_CRATES,

    73

		STR_TONS,

    74

		STR_TONS,

    75

		STR_TONS,

    76

		STR_TONS,

    77

		STR_BAGS,

    78

		STR_RES_OTHER

    79

	},

    80

    81

	{ /* LT_HILLY */

    82

		STR_PASSENGERS,

    83

		STR_TONS,

    84

		STR_BAGS,

    85

		STR_LITERS,

    86

		STR_ITEMS,

    87

		STR_CRATES,

    88

		STR_TONS,

    89

		STR_TONS,

    90

		STR_RES_OTHER,

    91

		STR_TONS,

    92

		STR_BAGS,

    93

		STR_TONS

    94

	},

    95

    96

	{ /* LT_DESERT */

    97

		STR_PASSENGERS,

    98

		STR_LITERS,

    99

		STR_BAGS,

   100

		STR_LITERS,

   101

		STR_TONS,

   102

		STR_CRATES,

   103

		STR_TONS,

   104

		STR_TONS,

   105

		STR_TONS,

   106

		STR_LITERS,

   107

		STR_BAGS,

   108

		STR_TONS

   109

	},

   110

   111

	{ /* LT_CANDY */

   112

		STR_PASSENGERS,

   113

		STR_TONS,

   114

		STR_BAGS,

   115

		STR_NOTHING,

   116

		STR_NOTHING,

   117

		STR_TONS,

   118

		STR_TONS,

   119

		STR_LITERS,

   120

		STR_TONS,

   121

		STR_NOTHING,

   122

		STR_LITERS,

   123

		STR_NOTHING

   124

	}

   125

};

   126

   127

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

   128

{

   129

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

   130

	return dst - 1;

   131

}

   132

   133

static const char *GetStringPtr(StringID string)

   134

{

   135

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

   136

}

   137

   138

char *GetString(char *buffr, StringID string)

   139

{

   140

	uint index = string & 0x7FF;

   141

	uint tab = string >> 11;

   142

   143

	switch (string) {

   144

		case 0:

   145

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

   146

			break;

   147

   148

		case 0x30D1:

   149

			return StationGetSpecialString(buffr);

   150

   151

		case STR_SPEC_SCREENSHOT_NAME:

   152

			return DecodeString(buffr, _screenshot_name);

   153

	}

   154

   155

	switch (tab) {

   156

		case 4:

   157

			if (index >= 0xC0) return GetSpecialTownNameString(buffr, index - 0xC0);

   158

			break;

   159

   160

		case 14:

   161

			if (index >= 0xE4) return GetSpecialPlayerNameString(buffr, index - 0xE4);

   162

			break;

   163

   164

		case 15:

   165

			return GetName(index, buffr);

   166

   167

		case 31: // special or dynamic strings

   168

			return DecodeString(buffr, _userstring);

   169

   170

		default:

   171

			break;

   172

	}

   173

   174

	if (index >= _langtab_num[tab])

   175

		error(

   176

			"!String 0x%X is invalid. "

   177

			"Probably because an old version of the .lng file.\n", string

   178

		);

   179

   180

	return DecodeString(buffr, GetStringPtr(string));

   181

}

   182

   183

void InjectDParam(int amount)

   184

{

   185

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

   186

}

   187

   188

   189

int32 GetParamInt32(void)

   190

{

   191

	int32 result = GetDParam(0);

   192

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

   193

	return result;

   194

}

   195

   196

static int64 GetParamInt64(void)

   197

{

   198

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

   199

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

   200

	return result;

   201

}

   202

   203

   204

int GetParamInt16(void)

   205

{

   206

	int result = (int16)GetDParam(0);

   207

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

   208

	return result;

   209

}

   210

   211

int GetParamInt8(void)

   212

{

   213

	int result = (int8)GetDParam(0);

   214

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

   215

	return result;

   216

}

   217

   218

int GetParamUint16(void)

   219

{

   220

	int result = GetDParam(0);

   221

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

   222

	return result;

   223

}

   224

   225

static const uint32 _divisor_table[] = {

   226

	1000000000,

   227

	100000000,

   228

	10000000,

   229

	1000000,

   230

   231

	100000,

   232

	10000,

   233

	1000,

   234

	100,

   235

	10,

   236

	1

   237

};

   238

   239

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

   240

{

   241

	uint32 quot,divisor;

   242

	int i;

   243

	uint32 tot;

   244

	uint32 num;

   245

   246

	if (number < 0) {

   247

		*buff++ = '-';

   248

		number = -number;

   249

	}

   250

   251

	num = number;

   252

   253

	tot = 0;

   254

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

   255

		divisor = _divisor_table[i];

   256

		quot = 0;

   257

		if (num >= divisor) {

   258

			quot = num / _divisor_table[i];

   259

			num = num % _divisor_table[i];

   260

		}

   261

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

   262

			*buff++ = '0' + quot;

   263

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

   264

		}

   265

	}

   266

   267

	*buff = '\0';

   268

   269

	return buff;

   270

}

   271

   272

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

   273

{

   274

	uint32 quot,divisor;

   275

	int i;

   276

	uint32 tot;

   277

	uint32 num;

   278

   279

	if (number < 0) {

   280

		*buff++ = '-';

   281

		number = -number;

   282

	}

   283

   284

	num = number;

   285

   286

	tot = 0;

   287

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

   288

		divisor = _divisor_table[i];

   289

		quot = 0;

   290

		if (num >= divisor) {

   291

			quot = num / _divisor_table[i];

   292

			num = num % _divisor_table[i];

   293

		}

   294

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

   295

			*buff++ = '0' + quot;

   296

		}

   297

	}

   298

   299

	*buff = '\0';

   300

   301

	return buff;

   302

}

   303

   304

   305

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

   306

{

   307

	const char *src;

   308

	YearMonthDay ymd;

   309

   310

	ConvertDayToYMD(&ymd, number);

   311

   312

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

   313

   314

	buff[-1] = ' ';

   315

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

   316

	buff[3] = ' ';

   317

   318

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

   319

}

   320

   321

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

   322

{

   323

	const char *src;

   324

	YearMonthDay ymd;

   325

   326

	ConvertDayToYMD(&ymd, number);

   327

   328

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

   329

	buff[-1] = ' ';

   330

   331

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

   332

}

   333

   334

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

   335

{

   336

	YearMonthDay ymd;

   337

   338

	ConvertDayToYMD(&ymd, number);

   339

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

   340

   341

	return buff;

   342

}

   343

   344

uint GetCurrentCurrencyRate(void)

   345

{

   346

	return _currency_specs[_opt.currency].rate;

   347

}

   348

   349

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

   350

{

   351

	const char *s;

   352

	char c;

   353

	char buf[40], *p;

   354

	int j;

   355

   356

	// multiply by exchange rate

   357

	number *= spec->rate;

   358

   359

	// convert from negative

   360

	if (number < 0) {

   361

		*buff++ = '-';

   362

		number = -number;

   363

	}

   364

   365

	// add prefix part

   366

	s = spec->prefix;

   367

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

   368

   369

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

   370

	if (compact) {

   371

		compact = 0;

   372

		if (number >= 1000000000) {

   373

			number = (number + 500000) / 1000000;

   374

			compact = 'M';

   375

		} else if (number >= 1000000) {

   376

			number = (number + 500) / 1000;

   377

			compact = 'k';

   378

		}

   379

	}

   380

   381

	// convert to ascii number and add commas

   382

	p = buf;

   383

	j = 4;

   384

	do {

   385

		if (--j == 0) {

   386

			*p++ = spec->separator;

   387

			j = 3;

   388

		}

   389

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

   390

	} while (number /= 10);

   391

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

   392

   393

	if (compact) *buff++ = compact;

   394

   395

	// add suffix part

   396

	s = spec->suffix;

   397

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

   398

   399

	return buff;

   400

}

   401

   402

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

   403

{

   404

	byte b;

   405

   406

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

   407

		switch (b) {

   408

		case 0x1: // {SETX}

   409

			*buff++ = b;

   410

			*buff++ = *str++;

   411

			break;

   412

		case 0x2: // {SETXY}

   413

			*buff++ = b;

   414

			*buff++ = *str++;

   415

			*buff++ = *str++;

   416

			break;

   417

		case 0x7B: // {COMMA32}

   418

			buff = FormatCommaNumber(buff, GetParamInt32());

   419

			break;

   420

		case 0x7C: // {COMMA16}

   421

			buff = FormatCommaNumber(buff, GetParamInt16());

   422

			break;

   423

		case 0x7D: // {COMMA8}

   424

			buff = FormatCommaNumber(buff, GetParamInt8());

   425

			break;

   426

		case 0x7E: // {NUMU16}

   427

			buff = FormatNoCommaNumber(buff, GetParamInt16());

   428

			break;

   429

		case 0x7F: // {CURRENCY}

   430

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

   431

			break;

   432

		// 0x80 is reserved for EURO

   433

		case 0x81: // {STRINL}

   434

			str += 2;

   435

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

   436

			break;

   437

		case 0x82: // {DATE_LONG}

   438

			buff = FormatYmdString(buff, GetParamUint16());

   439

			break;

   440

		case 0x83: // {DATE_SHORT}

   441

			buff = FormatMonthAndYear(buff, GetParamUint16());

   442

			break;

   443

		case 0x84: {// {VELOCITY}

   444

			int value = GetParamInt16();

   445

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

   446

			buff = FormatCommaNumber(buff, value);

   447

			if (_opt.kilometers) {

   448

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

   449

				buff += 5;

   450

			} else {

   451

				memcpy(buff, " mph", 4);

   452

				buff += 4;

   453

			}

   454

			break;

   455

		}

   456

   457

		// 0x85 is used as escape character..

   458

		case 0x85:

   459

			switch (*str++) {

   460

			case 0: /* {CURRCOMPACT} */

   461

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

   462

				break;

   463

			case 1: /* {INT32} */

   464

				buff = FormatNoCommaNumber(buff, GetParamInt32());

   465

				break;

   466

			case 2: /* {REV} */

   467

				buff = str_cat(buff, _openttd_revision);

   468

				break;

   469

			case 3: { /* {SHORTCARGO} */

   470

				// Short description of cargotypes. Layout:

   471

				// 8-bit = cargo type

   472

				// 16-bit = cargo count

   473

				const char *s;

   474

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

   475

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

   476

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

   477

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

   478

				s = GetStringPtr(cargo_str);

   479

   480

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

   481

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

   482

			} break;

   483

			case 4: /* {CURRCOMPACT64} */

   484

				// 64 bit compact currency-unit

   485

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

   486

				break;

   487

   488

			default:

   489

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

   490

			}

   491

			break;

   492

   493

		case 0x86: // {SKIP}

   494

			GetParamInt16();

   495

			//assert(0);

   496

			break;

   497

		case 0x87: { // {VOLUME}

   498

			const char *s;

   499

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

   500

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

   501

			s = GetStringPtr(STR_LITERS);

   502

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

   503

			break;