1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "namegen.h"

     5

#include "table/namegen.h"

     6

     7

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

     8

{

     9

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

    10

}

    11

    12

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

    13

{

    14

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

    15

}

    16

    17

static void ReplaceWords(const char *org, const char *rep, char *buf)

    18

{

    19

	if (strncmp(buf, org, 4) == 0) strncpy(buf, rep, 4);

    20

}

    21

    23

{

    24

	int i;

    25

    26

	//null terminates the string for strcat

    27

	strcpy(buf, "");

    28

    29

	// optional first segment

    30

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

    31

	if (i >= 0)

    32

		strcat(buf,name_original_english_1[i]);

    33

    34

	//mandatory middle segments

    35

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

    36

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

    37

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

    38

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

    39

    40

	//optional last segment

    41

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

    42

	if (i >= 0)

    43

		strcat(buf, name_original_english_6[i]);

    44

    45

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

    46

		buf[0] = 'K';

    47

    48

	ReplaceWords("Cunt", "East", buf);

    49

	ReplaceWords("Slag", "Pits", buf);

    50

	ReplaceWords("Slut", "Edin", buf);

    51

	//ReplaceWords("Fart", "Boot", buf);

    52

	ReplaceWords("Drar", "Quar", buf);

    53

	ReplaceWords("Dreh", "Bash", buf);

    54

	ReplaceWords("Frar", "Shor", buf);

    55

	ReplaceWords("Grar", "Aber", buf);

    56

	ReplaceWords("Brar", "Over", buf);

    57

	ReplaceWords("Wrar", "Inve", buf);

    58

    59

	return 0;

    60

}

    61

    62

    64

{

    65

	int i;

    66

    67

	//null terminates the string for strcat

    68

	strcpy(buf, "");

    69

    70

	// optional first segment

    71

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

    72

	if (i >= 0)

    73

		strcat(buf,name_additional_english_prefix[i]);

    74

    75

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

    76

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

    77

	} else {

    78

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

    79

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

    80

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

    81

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

    82

		} else {

    83

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

    84

		}

    85

	}

    86

    87

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

    88

    89

	//optional last segment

    90

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

    91

	if (i >= 0)

    92

		strcat(buf, name_additional_english_3[i]);

    93

    94

	ReplaceWords("Cunt", "East", buf);

    95

	ReplaceWords("Slag", "Pits", buf);

    96

	ReplaceWords("Slut", "Edin", buf);

    97

	ReplaceWords("Fart", "Boot", buf);

    98

	ReplaceWords("Drar", "Quar", buf);

    99

	ReplaceWords("Dreh", "Bash", buf);

   100

	ReplaceWords("Frar", "Shor", buf);

   101

	ReplaceWords("Grar", "Aber", buf);

   102

	ReplaceWords("Brar", "Over", buf);

   103

	ReplaceWords("Wrar", "Stan", buf);

   104

   105

	return 0;

   106

}

   107

   109

{

   110

	int i, j = 0;

   111

	strcpy(buf, "");

   112

   113

	// Bad, Maria, Gross, ...

   114

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

   115

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

   116

   117

	i = SeedChance(4, 6, seed);

   118

	if (i >= 4) {

   119

		// Kaisers-kirchen

   120

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

   121

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

   122

	} else if (i >= 2) {

   123

		// St. Johann

   124

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

   125

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

   126

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

   127

	} else {

   128

		// Zell

   129

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

   130

	}

   131

   132

	i = SeedChance(1, 6, seed);

   133

	if (i >= 4 - j) {

   134

		// an der Donau (rivers)

   135

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

   136

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

   137

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

   138

		// am Dachstein (mountains)

   139

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

   140

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

   141

	}

   142

   143

	return 0;

   144

}

   145

   147

{

   148

	uint i;

   149

	uint seed_derivative;

   150

   151

	//null terminates the string for strcat

   152

	strcpy(buf, "");

   153

   154

	seed_derivative = SeedChance(7, 28, seed);

   155

   156

	//optional prefix

   157

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

   158

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

   159

		strcat(buf,name_german_pre[i]);

   160

	}

   161

   162

	// mandatory middle segments including option of hardcoded name

   163

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

   164

	if (i < lengthof(name_german_hardcoded)) {

   165

		strcat(buf,name_german_hardcoded[i]);

   166

	} else {

   167

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

   168

   169

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

   170

		strcat(buf, name_german_2[i]);

   171

	}

   172

   173

	// optional suffix

   174

	if (seed_derivative == 24) {

   175

		i = SeedChance(9,

   176

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

   177

		if (i < lengthof(name_german_4_an_der)) {

   178

			strcat(buf, name_german_3_an_der[0]);

   179

			strcat(buf, name_german_4_an_der[i]);

   180

		} else {

   181

			strcat(buf, name_german_3_am[0]);

   182

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

   183

		}

   184

	}

   185

	return 0;

   186

}

   187

   189

{

   190

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

   191

	return 0;

   192

}

   193

   195

{

   196

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

   197

	return 0;

   198

}

   199

   201

{

   202

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

   203

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

   204

	return 0;

   205

}

   206

   208

{

   209

	int i;

   210

   211

	//null terminates the string for strcat

   212

	strcpy(buf, "");

   213

   214

	// optional first segment

   215

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

   216

	if (i >= 0)

   217

		strcat(buf, name_swedish_1[i]);

   218

   219

	// mandatory middle segments including option of hardcoded name

   220

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

   221

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

   222

	} else {

   223

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

   224

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

   225

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

   226

	}

   227

   228

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

   229

   230

	return 0;

   231

}

   232

   234

{

   235

	int i;

   236

   237

	//null terminates the string for strcat

   238

	strcpy(buf, "");

   239

   240

	// optional first segment

   241

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

   242

	if (i >= 0)

   243

		strcat(buf, name_dutch_1[i]);

   244

   245

	// mandatory middle segments including option of hardcoded name

   246

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

   247

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

   248

	} else {

   249

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

   250

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

   251

	}

   252

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

   253

   254

	return 0;

   255

}

   256

   258

{

   259

	//null terminates the string for strcat

   260

	strcpy(buf, "");

   261

   262

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

   263

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

   264

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

   265

	} else {

   266

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

   267

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

   268

	}

   269

   270

	return 0;

   271

}

   272

   274

{

   275

	uint i;

   276

	uint j;

   277

   278

	//null terminates the string for strcat

   279

	strcpy(buf, "");

   280

   281

	// optional first segment

   282

	i = SeedChance(0,

   283

		lengthof(name_polish_2_o) + lengthof(name_polish_2_m) +

   284

		lengthof(name_polish_2_f) + lengthof(name_polish_2_n),

   285

		seed);

   286

	j = SeedChance(2, 20, seed);

   287

   288

   289

	if (i < lengthof(name_polish_2_o)) {

   290

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

   291

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

   292

		if (j < 4)

   293

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

   294

   295

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

   296

   297

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

   298

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

   299

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

   300

		if (j < 4)

   301

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

   302

   303

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

   304

   305

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

   306

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

   307

	} else {

   308

		if (j < 4)

   309

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

   310

   311

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

   312

   313

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

   314

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

   315

	}

   316

	return 0;

   317

}

   318

   320

{

   321

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

   322

	return 0;

   323

}

   324

   326

{

   327

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

   328

	return 0;

   329

}

   330

   332

{

   333

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

   334

	return 0;

   335

}

   336

   338

{

   339

	strcpy(buf, "");

   340

   341

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

   342

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

   343

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

   344

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

   345

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

   346

	} else {

   347

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

   348

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

   349

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

   350

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

   351

	}

   352

   353

	return 0;

   354

}

   355

   357

{

   358

	uint i;

   359

   360

	//null terminates the string for strcat

   361

	strcpy(buf, "");

   362

   363

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

   364

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

   365

	} else {

   366

		// optional first segment

   367

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

   368

		if (i < lengthof(name_hungarian_1))

   369

			strcat(buf, name_hungarian_1[i]);

   370

   371

		// mandatory middle segments

   372

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

   373

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

   374

   375

		// optional last segment

   376

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

   377

		if (i < lengthof(name_hungarian_4)) {

   378

			strcat(buf, name_hungarian_4[i]);

   379

		}

   380

	}

   381

   382

	return 0;

   383

}

   384

   386

{

   387

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

   388

	return 0;

   389

}

   390

   391

TownNameGenerator * const _town_name_generators[] =

   392

{

   393

	MakeEnglishOriginalTownName,

   394

	MakeFrenchTownName,

   395

	MakeGermanTownName,

   396

	MakeEnglishAdditionalTownName,

   397

	MakeSpanishTownName,

   398

	MakeSillyTownName,

   399

	MakeSwedishTownName,

   400

	MakeDutchTownName,

   401

	MakeFinnishTownName,

   402

	MakePolishTownName,

   403

	MakeSlovakTownName,

   404

	MakeNorwegianTownName,

   405

	MakeHungarianTownName,

   406

	MakeAustrianTownName,

   407

	MakeRomanianTownName,

   408

	MakeCzechTownName,

   409

	MakeSwissTownName,

   410

};

   411

   412

// DO WE NEED THIS ANY MORE?

   413

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

   414

   415

uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type)

   416

{

   417

	switch (old_town_name_type) {

   418

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

   419

			/*	Already OK */

   420

			return townnameparts;

   421

   422

		case 1: /* French */

   423

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

   424

			*	0000 0000 0000 0000 0000 0000 1111 1111 */

   425

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

   426

   427

		case 2: /* German */

   428

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

   429

			return townnameparts;

   430

   431

		case 4: /* Latin-American */

   432

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

   433

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

   434

   435

		case 5: /* Silly */

   436

			/*	NUM_SILLY_1	-	lower 16 bits

   437

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

   438

			*	1000 0000 2222 2222 0000 0000 1111 1111 */

   439

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

   440

	}

   441

	return 0;

   442

}