1

#include "stdafx.h"

     2

#include "ttd.h"

     3

     4

#include "table/namegen.h"

     5

     6

inline static uint32 GetNumberBasedOnSeed(int x, int y, uint32 seed)

     7

{

     8

	return (((uint16)(seed >> x) * (y))>>16);

     9

}

    10

    11

static void ReplaceWords(byte a, byte b, byte c, byte d, byte e, byte f, byte g, byte h, byte *buf)

    12

{

    13

	if (buf[0] == a && buf[1] == b && buf[2] == c && buf[3] == d)

    14

	{

    15

		buf[0] = e;

    16

		buf[1] = f;

    17

		buf[2] = g;

    18

		buf[3] = h;

    19

	}

    20

}

    21

    22

static byte MakeEnglishOriginalTownName(byte *buf, uint32 seed)

    23

{

    24

	int i;

    25

    26

	//null terminates the string for strcat

    27

	strcpy(buf, "");

    28

    29

	// optional first segment

    30

	if ((i = GetNumberBasedOnSeed(0, lengthof(name_original_english_1) + 50, seed) - 50) >= 0)

    31

	{

    32

		strcat(buf,name_original_english_1[i]);

    33

	}

    34

    35

	//mandatory middle segments

    36

	strcat(buf, name_original_english_2[GetNumberBasedOnSeed(4,  lengthof(name_original_english_2), seed)]);

    37

	strcat(buf, name_original_english_3[GetNumberBasedOnSeed(7,  lengthof(name_original_english_3), seed)]);

    38

	strcat(buf, name_original_english_4[GetNumberBasedOnSeed(10, lengthof(name_original_english_4), seed)]);

    39

	strcat(buf, name_original_english_5[GetNumberBasedOnSeed(13, lengthof(name_original_english_5), seed)]);

    40

    41

	//optional last segment

    42

	if ((i = GetNumberBasedOnSeed(15, lengthof(name_original_english_6) + 60, seed) - 60) >= 0)

    43

	{

    44

		strcat(buf, name_original_english_6[i]);

    45

	}

    46

    47

	if (buf[0] == 'C' && (buf[1] == 'e' || buf[1] == 'i'))

    48

		buf[0] = 'K';

    49

    50

	ReplaceWords('C','u','n','t',  'E','a','s','t', buf);

    51

	ReplaceWords('S','l','a','g',  'P','i','t','s', buf);

    52

	ReplaceWords('S','l','u','t',  'E','d','i','n', buf);

    53

//	ReplaceWords('F','a','r','t',  'B','o','o','t', buf);

    54

	ReplaceWords('D','r','a','r',  'Q','u','a','r', buf);

    55

	ReplaceWords('D','r','e','h',  'B','a','s','h', buf);

    56

	ReplaceWords('F','r','a','r',  'S','h','o','r', buf);

    57

	ReplaceWords('G','r','a','r',  'A','b','e','r', buf);

    58

	ReplaceWords('B','r','a','r',  'O','v','e','r', buf);

    59

	ReplaceWords('W','r','a','r',  'I','n','v','e', buf);

    60

    61

	return 0;

    62

}

    63

    64

    65

static byte MakeEnglishAdditionalTownName(byte *buf, uint32 seed)

    66

{

    67

	int i;

    68

    69

	//null terminates the string for strcat

    70

	strcpy(buf, "");

    71

    72

	// optional first segment

    73

	if ((i = GetNumberBasedOnSeed(0, lengthof(name_additional_english_prefix) + 50, seed) - 50) >= 0)

    74

	{

    75

		strcat(buf,name_additional_english_prefix[i]);

    76

	}

    77

    78

	if (GetNumberBasedOnSeed(3, 20, seed) >= 14)

    79

	{

    80

		strcat(buf, name_additional_english_1a[GetNumberBasedOnSeed(6, lengthof(name_additional_english_1a), seed)]);

    81

	}

    82

	else

    83

	{

    84

		strcat(buf, name_additional_english_1b1[GetNumberBasedOnSeed(6, lengthof(name_additional_english_1b1), seed)]);

    85

		strcat(buf, name_additional_english_1b2[GetNumberBasedOnSeed(9, lengthof(name_additional_english_1b2), seed)]);

    86

		if (GetNumberBasedOnSeed(11, 20, seed) >= 4)

    87

		{

    88

			strcat(buf, name_additional_english_1b3a[GetNumberBasedOnSeed(12, lengthof(name_additional_english_1b3a), seed)]);

    89

		}

    90

		else

    91

		{

    92

			strcat(buf, name_additional_english_1b3b[GetNumberBasedOnSeed(12, lengthof(name_additional_english_1b3b), seed)]);

    93

		}

    94

	}

    95

    96

	strcat(buf, name_additional_english_2[GetNumberBasedOnSeed(14, lengthof(name_additional_english_2), seed)]);

    97

    98

	//optional last segment

    99

	if ((i = GetNumberBasedOnSeed(15, lengthof(name_additional_english_3) + 60, seed) - 60) >= 0)

   100

	{

   101

		strcat(buf, name_additional_english_3[i]);

   102

	}

   103

   104

	ReplaceWords('C','u','n','t',  'E','a','s','t', buf);

   105

	ReplaceWords('S','l','a','g',  'P','i','t','s', buf);

   106

	ReplaceWords('S','l','u','t',  'E','d','i','n', buf);

   107

	ReplaceWords('F','a','r','t',  'B','o','o','t', buf);

   108

	ReplaceWords('D','r','a','r',  'Q','u','a','r', buf);

   109

	ReplaceWords('D','r','e','h',  'B','a','s','h', buf);

   110

	ReplaceWords('F','r','a','r',  'S','h','o','r', buf);

   111

	ReplaceWords('G','r','a','r',  'A','b','e','r', buf);

   112

	ReplaceWords('B','r','a','r',  'O','v','e','r', buf);

   113

	ReplaceWords('W','r','a','r',  'S','t','a','n', buf);

   114

   115

	return 0;

   116

   117

   118

}

   119

   120

static byte MakeAustrianTownName(byte *buf, uint32 seed)

   121

{

   122

	int i, j = 0;

   123

	strcpy(buf, "");

   124

   125

	// Bad, Maria, Gross, ...

   126

	i = GetNumberBasedOnSeed(0, lengthof(name_austrian_a1) + 15,seed) - 15;

   127

   128

	if (i >= 0) strcat(buf, name_austrian_a1[i]);

   129

   130

	i = GetNumberBasedOnSeed(4, 6, seed);

   131

	if (i >= 4)

   132

	{

   133

		// Kaisers-kirchen

   134

		strcat(buf, name_austrian_a2[GetNumberBasedOnSeed( 7, lengthof(name_austrian_a2), seed)]);

   135

		strcat(buf, name_austrian_a3[GetNumberBasedOnSeed(13, lengthof(name_austrian_a3), seed)]);

   136

	}

   137

	else if (i >= 2)

   138

	{

   139

		// St. Johann

   140

		strcat(buf, name_austrian_a5[GetNumberBasedOnSeed( 7, lengthof(name_austrian_a5), seed)]);

   141

		strcat(buf, name_austrian_a6[GetNumberBasedOnSeed( 9, lengthof(name_austrian_a6), seed)]);

   142

		j = 1; // More likely to have a " an der " or " am "

   143

	}

   144

	else

   145

	{

   146

		// Zell

   147

		strcat(buf, name_austrian_a4[GetNumberBasedOnSeed( 7, lengthof(name_austrian_a4), seed)]);

   148

	}

   149

   150

	i = GetNumberBasedOnSeed(1, 6, seed);

   151

	if (i >= 4 - j)

   152

	{

   153

		// an der Donau (rivers)

   154

		strcat(buf, name_austrian_f1[GetNumberBasedOnSeed(4, lengthof(name_austrian_f1), seed)]);

   155

		strcat(buf, name_austrian_f2[GetNumberBasedOnSeed(5, lengthof(name_austrian_f2), seed)]);

   156

	}

   157

	else if (i >= 2 - j)

   158

	{

   159

		// am Dachstein (mountains)

   160

		strcat(buf, name_austrian_b1[GetNumberBasedOnSeed(4, lengthof(name_austrian_b1), seed)]);

   161

		strcat(buf, name_austrian_b2[GetNumberBasedOnSeed(5, lengthof(name_austrian_b2), seed)]);

   162

	}

   163

   164

	return 0;

   165

}

   166

   167

static byte MakeGermanTownName(byte *buf, uint32 seed)

   168

{

   169

	int i;

   170

   171

	//null terminates the string for strcat

   172

	strcpy(buf, "");

   173

   174

	// optional first segment

   175

	if ((i = GetNumberBasedOnSeed(0, lengthof(name_german_pre) + 50, seed) - 50) >= 0)

   176

	{

   177

		strcat(buf,name_german_pre[i]);

   178

	}

   179

   180

	// mandatory middle segments including option of hardcoded name

   181

	if ((i = GetNumberBasedOnSeed(4, lengthof(name_german_hardcoded) + 50, seed) - 50) >= 0)

   182

	{

   183

		strcat(buf,name_german_hardcoded[i]);

   184

	}

   185

	else

   186

	{

   187

		strcat(buf, name_german_1[GetNumberBasedOnSeed( 7, lengthof(name_german_1), seed)]);

   188

		strcat(buf, name_german_2[GetNumberBasedOnSeed(10, lengthof(name_german_2), seed)]);

   189

	}

   190

   191

	//optional last segment

   192

	if ((i = GetNumberBasedOnSeed(12, 50 + 10, seed) - 50) >= 0)

   193

	{

   194

		if (i > 2)

   195

		{

   196

			strcat(buf, name_german_3_an_der[GetNumberBasedOnSeed(14, lengthof(name_german_3_an_der), seed)]);

   197

			strcat(buf, name_german_4_an_der[GetNumberBasedOnSeed(15, lengthof(name_german_4_an_der), seed)]);

   198

		} else {

   199

			strcat(buf, name_german_3_am[GetNumberBasedOnSeed(14, lengthof(name_german_3_am), seed)]);

   200

			strcat(buf, name_german_4_am[GetNumberBasedOnSeed(15, lengthof(name_german_4_am), seed)]);

   201

		}

   202

   203

   204

	}

   205

	return 0;

   206

}

   207

   208

static byte MakeSpanishTownName(byte *buf, uint32 seed)

   209

{

   210

	strcpy(buf, "");

   211

	strcat(buf, name_spanish_1[GetNumberBasedOnSeed(0, lengthof(name_spanish_1), seed)]);

   212

	return 0;

   213

}

   214

   215

static byte MakeFrenchTownName(byte *buf, uint32 seed)

   216

{

   217

	strcpy(buf, "");

   218

	strcat(buf, name_french_1[GetNumberBasedOnSeed(0, lengthof(name_french_1), seed)]);

   219

	return 0;

   220

}

   221

   222

static byte MakeSillyTownName(byte *buf, uint32 seed)

   223

{

   224

	strcpy(buf, "");

   225

	strcat(buf, name_silly_1[GetNumberBasedOnSeed( 0, lengthof(name_silly_1), seed)]);

   226

	strcat(buf, name_silly_2[GetNumberBasedOnSeed(16, lengthof(name_silly_2), seed)]);

   227

	return 0;

   228

}

   229

   230

static byte MakeSwedishTownName(byte *buf, uint32 seed)

   231

{

   232

	int i;

   233

   234

	//null terminates the string for strcat

   235

	strcpy(buf, "");

   236

   237

	// optional first segment

   238

	if ((i = GetNumberBasedOnSeed(0, lengthof(name_swedish_1) + 50, seed) - 50) >= 0)

   239

	{

   240

		strcat(buf, name_swedish_1[i]);

   241

	}

   242

   243

	// mandatory middle segments including option of hardcoded name

   244

	if (GetNumberBasedOnSeed(4, 5, seed) >= 3)

   245

	{

   246

		strcat(buf, name_swedish_2[GetNumberBasedOnSeed( 7, lengthof(name_swedish_2), seed)]);

   247

	}

   248

	else

   249

	{

   250

		strcat(buf, name_swedish_2a[GetNumberBasedOnSeed( 7, lengthof(name_swedish_2a), seed)]);

   251

		strcat(buf, name_swedish_2b[GetNumberBasedOnSeed(10, lengthof(name_swedish_2b), seed)]);

   252

		strcat(buf, name_swedish_2c[GetNumberBasedOnSeed(13, lengthof(name_swedish_2c), seed)]);

   253

	}

   254

   255

	strcat(buf, name_swedish_3[GetNumberBasedOnSeed(16, lengthof(name_swedish_3), seed)]);

   256

   257

	return 0;

   258

}

   259

   260

static byte MakeDutchTownName(byte *buf, uint32 seed)

   261

{

   262

	int i;

   263

   264

	//null terminates the string for strcat

   265

	strcpy(buf, "");

   266

   267

	// optional first segment

   268

	if ((i = GetNumberBasedOnSeed(0, lengthof(name_dutch_1) + 50, seed) - 50) >= 0)

   269

	{

   270

		strcat(buf, name_dutch_1[i]);

   271

	}

   272

   273

	// mandatory middle segments including option of hardcoded name

   274

	if (GetNumberBasedOnSeed(6, 9, seed) > 4)

   275

	{

   276

		strcat(buf, name_dutch_2[GetNumberBasedOnSeed( 9, lengthof(name_dutch_2), seed)]);

   277

	}

   278

	else

   279

	{

   280

		strcat(buf, name_dutch_3[GetNumberBasedOnSeed( 9, lengthof(name_dutch_3), seed)]);

   281

		strcat(buf, name_dutch_4[GetNumberBasedOnSeed(12, lengthof(name_dutch_4), seed)]);

   282

	}

   283

	strcat(buf, name_dutch_5[GetNumberBasedOnSeed(15, lengthof(name_dutch_5), seed)]);

   284

   285

	return 0;

   286

}

   287

   288

static byte MakeFinnishTownName(byte *buf, uint32 seed)

   289

{

   290

	//null terminates the string for strcat

   291

	strcpy(buf, "");

   292

   293

	// Select randomly if town name should consists of one or two parts.

   294

	if (GetNumberBasedOnSeed(0, 15, seed) >= 10)

   295

	{

   296

		strcat(buf, name_finnish_1[GetNumberBasedOnSeed( 2, lengthof(name_finnish_1), seed)]);

   297

	}

   298

	else

   299

	{

   300

		strcat(buf, name_finnish_2a[GetNumberBasedOnSeed( 2, lengthof(name_finnish_2a), seed)]);

   301

		strcat(buf, name_finnish_2b[GetNumberBasedOnSeed(10, lengthof(name_finnish_2b), seed)]);

   302

	}

   303

   304

	return 0;

   305

}

   306

   307

static byte MakePolishTownName(byte *buf, uint32 seed)

   308

{

   311

   312

	//null terminates the string for strcat

   313

	strcpy(buf, "");

   314

   315

	// optional first segment

   316

	i = GetNumberBasedOnSeed(0,

   317

					lengthof(name_polish_2_o) +

   318

					lengthof(name_polish_2_m) +

   319

					lengthof(name_polish_2_f) +

   320

					lengthof(name_polish_2_n), seed);

   321

	j = GetNumberBasedOnSeed(2, 20, seed);

   322

   323

   324

	if (i < lengthof(name_polish_2_o))

   325

	{

   326

		strcat(buf, name_polish_2_o[GetNumberBasedOnSeed(3, lengthof(name_polish_2_o), seed)]);

   327

	}

   328

	else if (i < lengthof(name_polish_2_m) + lengthof(name_polish_2_o))

   329

	{

   330

		if (j < 4)

   331

			strcat(buf, name_polish_1_m[GetNumberBasedOnSeed(5, lengthof(name_polish_1_m), seed)]);

   332

   333

		strcat(buf, name_polish_2_m[GetNumberBasedOnSeed(7, lengthof(name_polish_2_m), seed)]);

   334

   335

		if (j >= 4 && j < 16)

   336

			strcat(buf, name_polish_3_m[GetNumberBasedOnSeed(10, lengthof(name_polish_3_m), seed)]);

   337

	}

   338

	else if (i < lengthof(name_polish_2_f) + lengthof(name_polish_2_m) + lengthof(name_polish_2_o))

   339

	{

   340

		if (j < 4)

   341

			strcat(buf, name_polish_1_f[GetNumberBasedOnSeed(5, lengthof(name_polish_1_f), seed)]);

   342

   343

		strcat(buf, name_polish_2_f[GetNumberBasedOnSeed(7, lengthof(name_polish_2_f), seed)]);

   344

   345

		if (j >= 4 && j < 16)

   346

			strcat(buf, name_polish_3_f[GetNumberBasedOnSeed(10, lengthof(name_polish_3_f), seed)]);

   347

	}

   348

	else

   349

	{

   350

		if (j < 4)

   351

			strcat(buf, name_polish_1_n[GetNumberBasedOnSeed(5, lengthof(name_polish_1_n), seed)]);

   352

   353

		strcat(buf, name_polish_2_n[GetNumberBasedOnSeed(7, lengthof(name_polish_2_n), seed)]);

   354

   355

		if (j >= 4 && j < 16)

   356

			strcat(buf, name_polish_3_n[GetNumberBasedOnSeed(10, lengthof(name_polish_3_n), seed)]);

   357

	}

   358

	return 0;

   359

}

   360

   361

static byte MakeCzechTownName(byte *buf, uint32 seed)

   362

{

   363

	strcpy(buf, "");

   364

	strcat(buf, name_czech_1[GetNumberBasedOnSeed(0, lengthof(name_czech_1), seed)]);

   365

	return 0;

   366

}

   367

   368

static byte MakeRomanianTownName(byte *buf, uint32 seed)

   369

{

   370

	strcpy(buf, "");

   371

	strcat(buf, name_romanian_1[GetNumberBasedOnSeed(0, lengthof(name_romanian_1), seed)]);

   372

	return 0;

   373

}

   374

   375

static byte MakeSlovakTownName(byte *buf, uint32 seed)

   376

{

   377

	strcpy(buf, "");

   378

	strcat(buf, name_slovakish_1[GetNumberBasedOnSeed(0, lengthof(name_slovakish_1), seed)]);

   379

	return 0;

   380

}

   381

   382

static byte MakeNorwegianTownName(byte *buf, uint32 seed)

   383

{

   384

	strcpy(buf, "");

   385

   386

	// Use first 4 bit from seed to decide whether or not this town should

   387

	// have a real name 3/16 chance.  Bit 0-3

   388

	if (GetNumberBasedOnSeed(0, 15, seed) < 3)

   389

	{

   390

		// Use 7bit for the realname table index.  Bit 4-10

   391

		strcat(buf, name_norwegian_real[GetNumberBasedOnSeed(4, lengthof(name_norwegian_real), seed)]);

   392

	}

   393

	else

   394

	{

   395

		// Use 7bit for the first fake part.  Bit 4-10

   396

		strcat(buf, name_norwegian_1[GetNumberBasedOnSeed(4, lengthof(name_norwegian_1), seed)]);

   397

		// Use 7bit for the last fake part.  Bit 11-17

   398

		strcat(buf, name_norwegian_2[GetNumberBasedOnSeed(11, lengthof(name_norwegian_2), seed)]);

   399

	}

   400

   401

	return 0;

   402

}

   403

   404

static byte MakeHungarianTownName(byte *buf, uint32 seed)

   405

{

   407

   408

	//null terminates the string for strcat

   409

	strcpy(buf, "");

   410

   411

	if (GetNumberBasedOnSeed(12, 15, seed) < 3)

   412

	{

   413

		strcat(buf, name_hungarian_real[GetNumberBasedOnSeed(0, lengthof(name_hungarian_real), seed)]);

   414

	}

   415

	else

   416

	{

   417

		// optional first segment

   418

		if ((i = GetNumberBasedOnSeed(0, lengthof(name_hungarian_1) * 3, seed)) < lengthof(name_hungarian_1))

   419

		{

   420

			strcat(buf, name_hungarian_1[i]);

   421

		}

   422

   423

		// mandatory middle segments

   424

		strcat(buf, name_hungarian_2[GetNumberBasedOnSeed(3, lengthof(name_hungarian_2), seed)]);

   425

		strcat(buf, name_hungarian_3[GetNumberBasedOnSeed(6, lengthof(name_hungarian_3), seed)]);

   426

   427

		// optional last segment

   428

		if ((i = GetNumberBasedOnSeed(10, lengthof(name_hungarian_4) * 3, seed)) < lengthof(name_hungarian_4)) {

   429

			strcat(buf, name_hungarian_4[i]);

   430

		}

   431

	}

   432

   433

	return 0;

   434

}

   435

   436

TownNameGenerator * const _town_name_generators[] = {

   437

	MakeEnglishOriginalTownName,

   438

	MakeFrenchTownName,

   439

	MakeGermanTownName,

   440

	MakeEnglishAdditionalTownName,

   441

	MakeSpanishTownName,

   442

	MakeSillyTownName,

   443

	MakeSwedishTownName,

   444

	MakeDutchTownName,

   445

	MakeFinnishTownName,

   446

	MakePolishTownName,

   447

	MakeSlovakTownName,

   448

	MakeNorwegianTownName,

   449

	MakeHungarianTownName,

   450

	MakeAustrianTownName,

   451

	MakeRomanianTownName,

   452

	MakeCzechTownName,

   453

};

   454

   455

// DO WE NEED THIS ANY MORE?

   456

#define FIXNUM(x, y, z) (((((x) << 16) / (y)) + 1) << z)

   457

   458

uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type)

   459

{

   460

	switch (old_town_name_type) {

   461

		case 0: case 3: /* English, American */

   462

			/*	Already OK */

   463

			return townnameparts;

   464

		case 1: /* French */

   465

			/*	For some reason 86 needs to be subtracted from townnameparts

   466

			*	0000 0000 0000 0000 0000 0000 1111 1111 */

   467

			return FIXNUM(townnameparts - 86, lengthof(name_french_1), 0);

   468

		case 2: /* German */

   469

			DEBUG(misc, 0) ("German Townnames are buggy... (%d)", townnameparts);

   470

			return townnameparts;

   471

		case 4: /* Latin-American */

   472

			/*	0000 0000 0000 0000 0000 0000 1111 1111 */

   473

			return FIXNUM(townnameparts, lengthof(name_spanish_1), 0);

   474

		case 5: /* Silly */

   475

			/*	NUM_SILLY_1	-	lower 16 bits

   476

			*	NUM_SILLY_2	-	upper 16 bits without leading 1 (first 8 bytes)

   477

			*	1000 0000 2222 2222 0000 0000 1111 1111 */

   478

			return FIXNUM(townnameparts, lengthof(name_silly_1), 0) | FIXNUM(((townnameparts >> 16)&0xFF), lengthof(name_silly_2), 16);

   479

	}

   480

	return 0;

   481

}