1

#include "stdafx.h"

     2

#include "ttd.h"

     3

     4

#include "table/namegen.h"

     5

     6

static inline uint32 SeedChance(int shift_by, int max, uint32 seed)

     7

{

     8

	return ((uint16)(seed >> shift_by) * max) >> 16;

     9

}

    10

    11

static inline int32 SeedChanceBias(int shift_by, int max, uint32 seed, int bias)

    12

{

    13

	return SeedChance(shift_by, max + bias, seed) - bias;

    14

}

    15

    16

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

    17

{

    18

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

    19

		buf[0] = e;

    20

		buf[1] = f;

    21

		buf[2] = g;

    22

		buf[3] = h;

    23

	}

    24

}

    25

    26

static byte MakeEnglishOriginalTownName(byte *buf, uint32 seed)

    27

{

    28

	int i;

    29

    30

	//null terminates the string for strcat

    31

	strcpy(buf, "");

    32

    33

	// optional first segment

    34

	i = SeedChanceBias(0, lengthof(name_original_english_1), seed, 50);

    35

	if (i >= 0)

    36

		strcat(buf,name_original_english_1[i]);

    37

    38

	//mandatory middle segments

    39

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

    40

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

    41

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

    42

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

    43

    44

	//optional last segment

    45

	i = SeedChanceBias(15, lengthof(name_original_english_6), seed, 60);

    46

	if (i >= 0)

    47

		strcat(buf, name_original_english_6[i]);

    48

    49

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

    50

		buf[0] = 'K';

    51

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

    63

	return 0;

    64

}

    65

    66

    67

static byte MakeEnglishAdditionalTownName(byte *buf, uint32 seed)

    68

{

    69

	int i;

    70

    71

	//null terminates the string for strcat

    72

	strcpy(buf, "");

    73

    74

	// optional first segment

    75

	i = SeedChanceBias(0, lengthof(name_additional_english_prefix), seed, 50);

    76

	if (i >= 0)

    77

		strcat(buf,name_additional_english_prefix[i]);

    78

    79

	if (SeedChance(3, 20, seed) >= 14) {

    80

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

    81

	} else {

    82

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

    83

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

    84

		if (SeedChance(11, 20, seed) >= 4) {

    85

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

    86

		} else {

    87

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

    88

		}

    89

	}

    90

    91

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

    92

    93

	//optional last segment

    94

	i = SeedChanceBias(15, lengthof(name_additional_english_3), seed, 60);

    95

	if (i >= 0)

    96

		strcat(buf, name_additional_english_3[i]);

    97

    98

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

    99

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

   100

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

   101

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

   102

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

   103

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

   104

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

   105

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

   106

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

   107

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

   108

   109

	return 0;

   110

}

   111

   112

static byte MakeAustrianTownName(byte *buf, uint32 seed)

   113

{

   114

	int i, j = 0;

   115

	strcpy(buf, "");

   116

   117

	// Bad, Maria, Gross, ...

   118

	i = SeedChanceBias(0, lengthof(name_austrian_a1), seed, 15);

   119

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

   120

   121

	i = SeedChance(4, 6, seed);

   122

	if (i >= 4) {

   123

		// Kaisers-kirchen

   124

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

   125

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

   126

	} else if (i >= 2) {

   127

		// St. Johann

   128

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

   129

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

   130

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

   131

	} else {

   132

		// Zell

   133

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

   134

	}

   135

   136

	i = SeedChance(1, 6, seed);

   137

	if (i >= 4 - j) {

   138

		// an der Donau (rivers)

   139

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

   140

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

   141

	} else if (i >= 2 - j) {

   142

		// am Dachstein (mountains)

   143

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

   144

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

   145

	}

   146

   147

	return 0;

   148

}

   149

   150

static byte MakeGermanTownName(byte *buf, uint32 seed)

   151

{

   152

	uint i;

   153

	uint seed_derivative;

   154

   155

	//null terminates the string for strcat

   156

	strcpy(buf, "");

   157

   158

	seed_derivative = SeedChance(7, 28, seed);

   159

   160

	//optional prefix

   161

	if (seed_derivative == 12 || seed_derivative == 19) {

   162

		i = SeedChance(2, lengthof(name_german_pre), seed);

   163

		strcat(buf,name_german_pre[i]);

   164

	}

   165

   166

	// mandatory middle segments including option of hardcoded name

   167

	i = SeedChance(3, lengthof(name_german_hardcoded) + lengthof(name_german_1), seed);

   168

	if (i < lengthof(name_german_hardcoded)) {

   169

		strcat(buf,name_german_hardcoded[i]);

   170

	} else {

   171

		strcat(buf, name_german_1[i - lengthof(name_german_hardcoded)]);

   172

   173

		i = SeedChance(5, lengthof(name_german_2), seed);

   174

		strcat(buf, name_german_2[i]);

   175

	}

   176

   177

	// optional suffix

   178

	if (seed_derivative == 24) {

   179

		i = SeedChance(9,

   180

			lengthof(name_german_4_an_der) + lengthof(name_german_4_am), seed);

   181

		if (i < lengthof(name_german_4_an_der)) {

   182

			strcat(buf, name_german_3_an_der[0]);

   183

			strcat(buf, name_german_4_an_der[i]);

   184

		} else {

   185

			strcat(buf, name_german_3_am[0]);

   186

			strcat(buf, name_german_4_am[i - lengthof(name_german_4_an_der)]);

   187

		}

   188

	}

   189

	return 0;

   190

}

   191

   192

static byte MakeSpanishTownName(byte *buf, uint32 seed)

   193

{

   194

	strcpy(buf, name_spanish_1[SeedChance(0, lengthof(name_spanish_1), seed)]);

   195

	return 0;

   196

}

   197

   198

static byte MakeFrenchTownName(byte *buf, uint32 seed)

   199

{

   200

	strcpy(buf, name_french_1[SeedChance(0, lengthof(name_french_1), seed)]);

   201

	return 0;

   202

}

   203

   204

static byte MakeSillyTownName(byte *buf, uint32 seed)

   205

{

   206

	strcpy(buf, name_silly_1[SeedChance( 0, lengthof(name_silly_1), seed)]);

   207

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

   208

	return 0;

   209

}

   210

   211

static byte MakeSwedishTownName(byte *buf, uint32 seed)

   212

{

   213

	int i;

   214

   215

	//null terminates the string for strcat

   216

	strcpy(buf, "");

   217

   218

	// optional first segment

   219

	i = SeedChanceBias(0, lengthof(name_swedish_1), seed, 50);

   220

	if (i >= 0)

   221

		strcat(buf, name_swedish_1[i]);

   222

   223

	// mandatory middle segments including option of hardcoded name

   224

	if (SeedChance(4, 5, seed) >= 3) {

   225

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

   226

	} else {

   227

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

   228

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

   229

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

   230

	}

   231

   232

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

   233

   234

	return 0;

   235

}

   236

   237

static byte MakeDutchTownName(byte *buf, uint32 seed)

   238

{

   239

	int i;

   240

   241

	//null terminates the string for strcat

   242

	strcpy(buf, "");

   243

   244

	// optional first segment

   245

	i = SeedChanceBias(0, lengthof(name_dutch_1), seed, 50);

   246

	if (i >= 0)

   247

		strcat(buf, name_dutch_1[i]);

   248

   249

	// mandatory middle segments including option of hardcoded name

   250

	if (SeedChance(6, 9, seed) > 4) {

   251

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

   252

	} else {

   253

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

   254

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

   255

	}

   256

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

   257

   258

	return 0;

   259

}

   260

   261

static byte MakeFinnishTownName(byte *buf, uint32 seed)

   262

{

   263

	//null terminates the string for strcat

   264

	strcpy(buf, "");

   265

   266

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

   267

	if (SeedChance(0, 15, seed) >= 10) {

   268

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

   269

	} else {

   270

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

   271

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

   272

	}

   273

   274

	return 0;

   275

}

   276

   277

static byte MakePolishTownName(byte *buf, uint32 seed)

   278

{

   279

	uint i;

   280

	uint j;

   281

   282

	//null terminates the string for strcat

   283

	strcpy(buf, "");

   284

   285

	// optional first segment

   286

	i = SeedChance(0,

   287

		lengthof(name_polish_2_o) + lengthof(name_polish_2_m) +

   288

		lengthof(name_polish_2_f) + lengthof(name_polish_2_n),

   289

		seed);

   290

	j = SeedChance(2, 20, seed);

   291

   292

   293

	if (i < lengthof(name_polish_2_o)) {

   294

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

   295

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

   296

		if (j < 4)

   297

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

   298

   299

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

   300

   301

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

   302

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

   303

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

   304

		if (j < 4)

   305

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

   306

   307

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

   308

   309

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

   310

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

   311

	} else {

   312

		if (j < 4)

   313

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

   314

   315

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

   316

   317

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

   318

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

   319

	}

   320

	return 0;

   321

}

   322

   323

static byte MakeCzechTownName(byte *buf, uint32 seed)

   324

{

   325

	strcpy(buf, name_czech_1[SeedChance(0, lengthof(name_czech_1), seed)]);

   326

	return 0;

   327

}

   328

   329

static byte MakeRomanianTownName(byte *buf, uint32 seed)

   330

{

   331

	strcpy(buf, name_romanian_1[SeedChance(0, lengthof(name_romanian_1), seed)]);

   332

	return 0;

   333

}

   334

   335

static byte MakeSlovakTownName(byte *buf, uint32 seed)

   336

{

   337

	strcpy(buf, name_slovakish_1[SeedChance(0, lengthof(name_slovakish_1), seed)]);

   338

	return 0;

   339

}

   340

   341

static byte MakeNorwegianTownName(byte *buf, uint32 seed)

   342

{

   343

	strcpy(buf, "");

   344

   345

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

   346

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

   347

	if (SeedChance(0, 15, seed) < 3) {

   348

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

   349

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

   350

	} else {

   351

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

   352

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

   353

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

   354

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

   355

	}

   356

   357

	return 0;

   358

}

   359

   360

static byte MakeHungarianTownName(byte *buf, uint32 seed)

   361

{

   362

	uint i;

   363

   364

	//null terminates the string for strcat

   365

	strcpy(buf, "");

   366

   367

	if (SeedChance(12, 15, seed) < 3) {

   368

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

   369

	} else {

   370

		// optional first segment

   371

		i = SeedChance(3, lengthof(name_hungarian_1) * 3, seed);

   372

		if (i < lengthof(name_hungarian_1))

   373

			strcat(buf, name_hungarian_1[i]);

   374

   375

		// mandatory middle segments

   376

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

   377

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

   378

   379

		// optional last segment

   380

		i = SeedChance(10, lengthof(name_hungarian_4) * 3, seed);

   381

		if (i < lengthof(name_hungarian_4)) {

   382

			strcat(buf, name_hungarian_4[i]);

   383

		}

   384

	}

   385

   386

	return 0;

   387

}

   388

   395

TownNameGenerator * const _town_name_generators[] =

   396

{

   397

	MakeEnglishOriginalTownName,

   398

	MakeFrenchTownName,

   399

	MakeGermanTownName,

   400

	MakeEnglishAdditionalTownName,

   401

	MakeSpanishTownName,

   402

	MakeSillyTownName,

   403

	MakeSwedishTownName,

   404

	MakeDutchTownName,

   405

	MakeFinnishTownName,

   406

	MakePolishTownName,

   407

	MakeSlovakTownName,

   408

	MakeNorwegianTownName,

   409

	MakeHungarianTownName,

   410

	MakeAustrianTownName,

   411

	MakeRomanianTownName,

   412

	MakeCzechTownName,

   414

};

   415

   416

// DO WE NEED THIS ANY MORE?

   417

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

   418

   419

uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type)

   420

{

   421

	switch (old_town_name_type) {

   422

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

   423

			/*	Already OK */

   424

			return townnameparts;

   425

   426

		case 1: /* French */

   427

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

   428

			*	0000 0000 0000 0000 0000 0000 1111 1111 */

   429

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

   430

   431

		case 2: /* German */

   432

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

   433

			return townnameparts;

   434

   435

		case 4: /* Latin-American */

   436

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

   437

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

   438

   439

		case 5: /* Silly */

   440

			/*	NUM_SILLY_1	-	lower 16 bits

   441

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

   442

			*	1000 0000 2222 2222 0000 0000 1111 1111 */

   443

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

   444

	}

   445

	return 0;

   446

}