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

    13

static char *StationGetSpecialString(char *buff);

    14

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

    15

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

    16

    17

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

    18

    19

extern const char _openttd_revision[];

    20

    21

typedef struct LanguagePack {

    22

	uint32 ident;

    23

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

    24

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

    25

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

    26

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

    27

	uint16 offsets[32];	// the offsets

    28

	char data[VARARRAY_SIZE];

    29

} LanguagePack;

    30

    31

static char **_langpack_offs;

    32

static LanguagePack *_langpack;

    33

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

    34

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

    35

    36

const StringID _currency_string_list[] = {

    37

	STR_CURR_GBP,

    38

	STR_CURR_USD,

    39

	STR_CURR_EUR,

    40

	STR_CURR_YEN,

    41

	STR_CURR_ATS,

    42

	STR_CURR_BEF,

    43

	STR_CURR_CHF,

    44

	STR_CURR_CZK,

    45

	STR_CURR_DEM,

    46

	STR_CURR_DKK,

    47

	STR_CURR_ESP,

    48

	STR_CURR_FIM,

    49

	STR_CURR_FRF,

    50

	STR_CURR_GRD,

    51

	STR_CURR_HUF,

    52

	STR_CURR_ISK,

    53

	STR_CURR_ITL,

    54

	STR_CURR_NLG,

    55

	STR_CURR_NOK,

    56

	STR_CURR_PLN,

    57

	STR_CURR_ROL,

    58

	STR_CURR_RUR,

    59

	STR_CURR_SEK,

    60

	STR_CURR_CUSTOM,

    61

	INVALID_STRING_ID

    62

};

    63

    64

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

    65

	{ /* LT_NORMAL */

    66

		STR_PASSENGERS,

    67

		STR_TONS,

    68

		STR_BAGS,

    69

		STR_LITERS,

    70

		STR_ITEMS,

    71

		STR_CRATES,

    72

		STR_TONS,

    73

		STR_TONS,

    74

		STR_TONS,

    75

		STR_TONS,

    76

		STR_BAGS,

    77

		STR_RES_OTHER

    78

	},

    79

    80

	{ /* LT_HILLY */

    81

		STR_PASSENGERS,

    82

		STR_TONS,

    83

		STR_BAGS,

    84

		STR_LITERS,

    85

		STR_ITEMS,

    86

		STR_CRATES,

    87

		STR_TONS,

    88

		STR_TONS,

    89

		STR_RES_OTHER,

    90

		STR_TONS,

    91

		STR_BAGS,

    92

		STR_TONS

    93

	},

    94

    95

	{ /* LT_DESERT */

    96

		STR_PASSENGERS,

    97

		STR_LITERS,

    98

		STR_BAGS,

    99

		STR_LITERS,

   100

		STR_TONS,

   101

		STR_CRATES,

   102

		STR_TONS,

   103

		STR_TONS,

   104

		STR_TONS,

   105

		STR_LITERS,

   106

		STR_BAGS,

   107

		STR_TONS

   108

	},

   109

   110

	{ /* LT_CANDY */

   111

		STR_PASSENGERS,

   112

		STR_TONS,

   113

		STR_BAGS,

   114

		STR_NOTHING,

   115

		STR_NOTHING,

   116

		STR_TONS,

   117

		STR_TONS,

   118

		STR_LITERS,

   119

		STR_TONS,

   120

		STR_NOTHING,

   121

		STR_LITERS,

   122

		STR_NOTHING

   123

	}

   124

};

   125

   126

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

   127

{

   128

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

   129

	return dst - 1;

   130

}

   131

   132

static const char *GetStringPtr(StringID string)

   133

{

   134

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

   135

}

   136

   137

char *GetString(char *buffr, StringID string)

   138

{

   139

	uint index = string & 0x7FF;

   140

	uint tab = string >> 11;

   141

   142

	switch (string) {

   143

		case 0:

   144

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

   145

			break;

   146

   147

		case 0x30D1:

   148

			return StationGetSpecialString(buffr);

   149

   150

		case STR_SPEC_SCREENSHOT_NAME:

   151

			return DecodeString(buffr, _screenshot_name);

   152

	}

   153

   154

	switch (tab) {

   155

		case 4:

   156

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

   157

			break;

   158

   159

		case 14:

   160

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

   161

			break;

   162

   163

		case 15:

   164

			return GetName(index, buffr);

   165

   166

		case 31: // special or dynamic strings

   167

			return DecodeString(buffr, _userstring);

   168

   169

		default:

   170

			break;

   171

	}

   172

   173

	if (index >= _langtab_num[tab])

   174

		error(

   175

			"!String 0x%X is invalid. "

   176

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

   177

		);

   178

   179

	return DecodeString(buffr, GetStringPtr(string));

   180

}

   181

   182

void InjectDParam(int amount)

   183

{

   184

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

   185

}

   186

   187

   188

int32 GetParamInt32(void)

   189

{

   190

	int32 result = GetDParam(0);

   191

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

   192

	return result;

   193

}

   194

   195

static int64 GetParamInt64(void)

   196

{

   197

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

   198

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

   199

	return result;

   200

}

   201

   202

   203

int GetParamInt16(void)

   204

{

   205

	int result = (int16)GetDParam(0);

   206

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

   207

	return result;

   208

}

   209

   210

int GetParamInt8(void)

   211

{

   212

	int result = (int8)GetDParam(0);

   213

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

   214

	return result;

   215

}

   216

   217

int GetParamUint16(void)

   218

{

   219

	int result = GetDParam(0);

   220

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

   221

	return result;

   222

}

   223

   224

static const uint32 _divisor_table[] = {

   225

	1000000000,

   226

	100000000,

   227

	10000000,

   228

	1000000,

   229

   230

	100000,

   231

	10000,

   232

	1000,

   233

	100,

   234

	10,

   235

	1

   236

};

   237

   238

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

   239

{

   240

	uint32 quot,divisor;

   241

	int i;

   242

	uint32 tot;

   243

	uint32 num;

   244

   245

	if (number < 0) {

   246

		*buff++ = '-';

   247

		number = -number;

   248

	}

   249

   250

	num = number;

   251

   252

	tot = 0;

   253

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

   254

		divisor = _divisor_table[i];

   255

		quot = 0;

   256

		if (num >= divisor) {

   257

			quot = num / _divisor_table[i];

   258

			num = num % _divisor_table[i];

   259

		}

   260

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

   261

			*buff++ = '0' + quot;

   262

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

   263

		}

   264

	}

   265

   266

	*buff = '\0';

   267

   268

	return buff;

   269

}

   270

   271

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

   272

{

   273

	uint32 quot,divisor;

   274

	int i;

   275

	uint32 tot;

   276

	uint32 num;

   277

   278

	if (number < 0) {

   279

		*buff++ = '-';

   280

		number = -number;

   281

	}

   282

   283

	num = number;

   284

   285

	tot = 0;

   286

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

   287

		divisor = _divisor_table[i];

   288

		quot = 0;

   289

		if (num >= divisor) {

   290

			quot = num / _divisor_table[i];

   291

			num = num % _divisor_table[i];

   292

		}

   293

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

   294

			*buff++ = '0' + quot;

   295

		}

   296

	}

   297

   298

	*buff = '\0';

   299

   300

	return buff;

   301

}

   302

   303

   304

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

   305

{

   306

	const char *src;

   307

	YearMonthDay ymd;

   308

   309

	ConvertDayToYMD(&ymd, number);

   310

   311

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

   312

   313

	buff[-1] = ' ';

   314

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

   315

	buff[3] = ' ';

   316

   317

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

   318

}

   319

   320

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

   321

{

   322

	const char *src;

   323

	YearMonthDay ymd;

   324

   325

	ConvertDayToYMD(&ymd, number);

   326

   327

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

   328

	buff[-1] = ' ';

   329

   330

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

   331

}

   332

   333

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

   334

{

   335

	YearMonthDay ymd;

   336

   337

	ConvertDayToYMD(&ymd, number);

   338

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

   339

   340

	return buff;

   341

}

   342

   343

uint GetCurrentCurrencyRate(void)

   344

{

   345

	return _currency_specs[_opt.currency].rate;

   346

}

   347

   348

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

   349

{

   350

	const char *s;

   351

	char c;

   352

	char buf[40], *p;

   353

	int j;

   354

   355

	// multiply by exchange rate

   356

	number *= spec->rate;

   357

   358

	// convert from negative

   359

	if (number < 0) {

   360

		*buff++ = '-';

   361

		number = -number;

   362

	}

   363

   364

	// add prefix part

   365

	s = spec->prefix;

   366

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

   367

   368

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

   369

	if (compact) {

   370

		compact = 0;

   371

		if (number >= 1000000000) {

   372

			number = (number + 500000) / 1000000;

   373

			compact = 'M';

   374

		} else if (number >= 1000000) {

   375

			number = (number + 500) / 1000;

   376

			compact = 'k';

   377

		}

   378

	}

   379

   380

	// convert to ascii number and add commas

   381

	p = buf;

   382

	j = 4;

   383

	do {

   384

		if (--j == 0) {

   385

			*p++ = spec->separator;

   386

			j = 3;

   387

		}

   388

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

   389

	} while (number /= 10);

   390

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

   391

   392

	if (compact) *buff++ = compact;

   393

   394

	// add suffix part

   395

	s = spec->suffix;

   396

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

   397

   398

	return buff;

   399

}

   400

   401

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

   402

{

   403

	byte b;

   404

   405

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

   406

		switch (b) {

   407

		case 0x1: // {SETX}

   408

			*buff++ = b;

   409

			*buff++ = *str++;

   410

			break;

   411

		case 0x2: // {SETXY}

   412

			*buff++ = b;

   413

			*buff++ = *str++;

   414

			*buff++ = *str++;

   415

			break;

   416

		case 0x7B: // {COMMA32}

   417

			buff = FormatCommaNumber(buff, GetParamInt32());

   418

			break;

   419

		case 0x7C: // {COMMA16}

   420

			buff = FormatCommaNumber(buff, GetParamInt16());

   421

			break;

   422

		case 0x7D: // {COMMA8}

   423

			buff = FormatCommaNumber(buff, GetParamInt8());

   424

			break;

   425

		case 0x7E: // {NUMU16}

   426

			buff = FormatNoCommaNumber(buff, GetParamInt16());

   427

			break;

   428

		case 0x7F: // {CURRENCY}

   429

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

   430

			break;

   431

		// 0x80 is reserved for EURO

   432

		case 0x81: // {STRINL}

   433

			str += 2;

   434

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

   435

			break;

   436

		case 0x82: // {DATE_LONG}

   437

			buff = FormatYmdString(buff, GetParamUint16());

   438

			break;

   439

		case 0x83: // {DATE_SHORT}

   440

			buff = FormatMonthAndYear(buff, GetParamUint16());

   441

			break;

   442

		case 0x84: {// {VELOCITY}

   443

			int value = GetParamInt16();

   444

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

   445

			buff = FormatCommaNumber(buff, value);

   446

			if (_opt.kilometers) {

   447

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

   448

				buff += 5;

   449

			} else {

   450

				memcpy(buff, " mph", 4);

   451

				buff += 4;

   452

			}

   453

			break;

   454

		}

   455

   456

		// 0x85 is used as escape character..

   457

		case 0x85:

   458

			switch (*str++) {

   459

			case 0: /* {CURRCOMPACT} */

   460

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

   461

				break;

   462

			case 1: /* {INT32} */

   463

				buff = FormatNoCommaNumber(buff, GetParamInt32());

   464

				break;

   465

			case 2: /* {REV} */

   466

				buff = str_cat(buff, _openttd_revision);

   467

				break;

   468

			case 3: { /* {SHORTCARGO} */

   469

				// Short description of cargotypes. Layout:

   470

				// 8-bit = cargo type

   471

				// 16-bit = cargo count

   472

				const char *s;

   473

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

   474

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

   475

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

   476

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

   477

				s = GetStringPtr(cargo_str);

   478

   479

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

   480

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

   481

			} break;

   482

			case 4: /* {CURRCOMPACT64} */

   483

				// 64 bit compact currency-unit

   484

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

   485

				break;

   486

   487

			default:

   488

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

   489

			}

   490

			break;

   491

   492

		case 0x86: // {SKIP}

   493

			GetParamInt16();

   494

			//assert(0);

   495

			break;

   496

		case 0x87: { // {VOLUME}

   497

			const char *s;

   498

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

   499

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

   500

			s = GetStringPtr(STR_LITERS);

   501

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

   502

			break;

   503

		}