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

    17

{

    18

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

    19

}

    20

    21

static byte MakeEnglishOriginalTownName(byte *buf, uint32 seed)

    22

{

    23

	int i;

    24

    25

	//null terminates the string for strcat

    26

	strcpy(buf, "");

    27

    28

	// optional first segment

    29

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

    30

	if (i >= 0)

    31

		strcat(buf,name_original_english_1[i]);

    32

    33

	//mandatory middle segments

    34

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

    35

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

    36

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

    37

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

    38

    39

	//optional last segment

    40

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

    41

	if (i >= 0)

    42

		strcat(buf, name_original_english_6[i]);

    43

    44

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

    45

		buf[0] = 'K';

    46

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

    58

	return 0;

    59

}

    60

    61

    62

static byte MakeEnglishAdditionalTownName(byte *buf, uint32 seed)

    63

{

    64

	int i;

    65

    66

	//null terminates the string for strcat

    67

	strcpy(buf, "");

    68

    69

	// optional first segment

    70

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

    71

	if (i >= 0)

    72

		strcat(buf,name_additional_english_prefix[i]);

    73

    74

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

    75

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

    76

	} else {

    77

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

    78

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

    79

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

    80

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

    81

		} else {

    82

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

    83

		}

    84

	}

    85

    86

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

    87

    88

	//optional last segment

    89

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

    90

	if (i >= 0)

    91

		strcat(buf, name_additional_english_3[i]);

    92

    93

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

    94

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

    95

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

    96

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

    97

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

    98

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

    99

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

   100

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

   101

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

   102

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

   103

   104

	return 0;

   105

}

   106

   107

static byte MakeAustrianTownName(byte *buf, uint32 seed)

   108

{

   109

	int i, j = 0;

   110

	strcpy(buf, "");

   111

   112

	// Bad, Maria, Gross, ...

   113

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

   114

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

   115

   116

	i = SeedChance(4, 6, seed);

   117

	if (i >= 4) {

   118

		// Kaisers-kirchen

   119

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

   120

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

   121

	} else if (i >= 2) {

   122

		// St. Johann

   123

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

   124

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

   125

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

   126

	} else {

   127

		// Zell

   128

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

   129

	}

   130

   131

	i = SeedChance(1, 6, seed);

   132

	if (i >= 4 - j) {

   133

		// an der Donau (rivers)

   134

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

   135

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

   136

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

   137

		// am Dachstein (mountains)

   138

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

   139

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

   140

	}

   141

   142

	return 0;

   143

}

   144

   145

static byte MakeGermanTownName(byte *buf, uint32 seed)

   146

{

   147

	uint i;

   148

	uint seed_derivative;

   149

   150

	//null terminates the string for strcat

   151

	strcpy(buf, "");

   152

   153

	seed_derivative = SeedChance(7, 28, seed);

   154

   155

	//optional prefix

   156

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

   157

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

   158

		strcat(buf,name_german_pre[i]);

   159

	}

   160

   161

	// mandatory middle segments including option of hardcoded name

   162

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

   163

	if (i < lengthof(name_german_hardcoded)) {

   164

		strcat(buf,name_german_hardcoded[i]);

   165

	} else {

   166

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

   167

   168

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

   169

		strcat(buf, name_german_2[i]);

   170

	}

   171

   172

	// optional suffix

   173

	if (seed_derivative == 24) {

   174

		i = SeedChance(9,

   175

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

   176

		if (i < lengthof(name_german_4_an_der)) {

   177

			strcat(buf, name_german_3_an_der[0]);

   178

			strcat(buf, name_german_4_an_der[i]);

   179

		} else {

   180

			strcat(buf, name_german_3_am[0]);

   181

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

   182

		}

   183

	}

   184

	return 0;

   185

}

   186

   187

static byte MakeSpanishTownName(byte *buf, uint32 seed)

   188

{

   189

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

   190

	return 0;

   191

}

   192

   193

static byte MakeFrenchTownName(byte *buf, uint32 seed)

   194

{

   195

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

   196

	return 0;

   197

}

   198

   199

static byte MakeSillyTownName(byte *buf, uint32 seed)

   200

{

   201

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

   202

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

   203

	return 0;

   204

}

   205

   206

static byte MakeSwedishTownName(byte *buf, uint32 seed)

   207

{

   208

	int i;

   209

   210

	//null terminates the string for strcat

   211

	strcpy(buf, "");

   212

   213

	// optional first segment

   214

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

   215

	if (i >= 0)

   216

		strcat(buf, name_swedish_1[i]);

   217

   218

	// mandatory middle segments including option of hardcoded name

   219

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

   220

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

   221

	} else {

   222

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

   223

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

   224

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

   225

	}

   226

   227

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

   228

   229

	return 0;

   230

}

   231

   232

static byte MakeDutchTownName(byte *buf, uint32 seed)

   233

{

   234

	int i;

   235

   236

	//null terminates the string for strcat

   237

	strcpy(buf, "");

   238

   239

	// optional first segment

   240

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

   241

	if (i >= 0)

   242

		strcat(buf, name_dutch_1[i]);

   243

   244

	// mandatory middle segments including option of hardcoded name

   245

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

   246

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

   247

	} else {

   248

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

   249

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

   250

	}

   251

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

   252

   253

	return 0;

   254

}

   255

   256

static byte MakeFinnishTownName(byte *buf, uint32 seed)

   257

{

   258

	//null terminates the string for strcat

   259

	strcpy(buf, "");

   260

   261

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

   262

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

   263

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

   264

	} else {

   265

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

   266

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

   267

	}

   268

   269

	return 0;

   270

}

   271

   272

static byte MakePolishTownName(byte *buf, uint32 seed)

   273

{

   274

	uint i;

   275

	uint j;

   276

   277

	//null terminates the string for strcat

   278

	strcpy(buf, "");

   279

   280

	// optional first segment

   281

	i = SeedChance(0,

   282

		lengthof(name_polish_2_o) + lengthof(name_polish_2_m) +

   283

		lengthof(name_polish_2_f) + lengthof(name_polish_2_n),

   284

		seed);

   285

	j = SeedChance(2, 20, seed);

   286

   287

   288

	if (i < lengthof(name_polish_2_o)) {

   289

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

   290

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

   291

		if (j < 4)

   292

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

   293

   294

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

   295

   296

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

   297

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

   298

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

   299

		if (j < 4)

   300

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

   301

   302

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

   303

   304

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

   305

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

   306

	} else {

   307

		if (j < 4)

   308

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

   309

   310

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

   311

   312

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

   313

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

   314

	}

   315

	return 0;

   316

}

   317

   318

static byte MakeCzechTownName(byte *buf, uint32 seed)

   319

{

   320

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

   321

	return 0;

   322

}

   323

   324

static byte MakeRomanianTownName(byte *buf, uint32 seed)

   325

{

   326

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

   327

	return 0;

   328

}

   329

   330

static byte MakeSlovakTownName(byte *buf, uint32 seed)

   331

{

   332

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

   333

	return 0;

   334

}

   335

   336

static byte MakeNorwegianTownName(byte *buf, uint32 seed)

   337

{

   338

	strcpy(buf, "");

   339

   340

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

   341

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

   342

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

   343

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

   344

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

   345

	} else {

   346

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

   347

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

   348

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

   349

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

   350

	}

   351

   352

	return 0;

   353

}

   354

   355

static byte MakeHungarianTownName(byte *buf, uint32 seed)

   356

{

   357

	uint i;

   358

   359

	//null terminates the string for strcat

   360

	strcpy(buf, "");

   361

   362

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

   363

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

   364

	} else {

   365

		// optional first segment

   366

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

   367

		if (i < lengthof(name_hungarian_1))

   368

			strcat(buf, name_hungarian_1[i]);

   369

   370

		// mandatory middle segments

   371

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

   372

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

   373

   374

		// optional last segment

   375

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

   376

		if (i < lengthof(name_hungarian_4)) {

   377

			strcat(buf, name_hungarian_4[i]);

   378

		}

   379

	}

   380

   381

	return 0;

   382

}

   383

   384

static byte MakeSwissTownName(byte *buf, uint32 seed)

   385

{

   386

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

   387

	return 0;

   388

}

   389

   390

TownNameGenerator * const _town_name_generators[] =

   391

{

   392

	MakeEnglishOriginalTownName,

   393

	MakeFrenchTownName,

   394

	MakeGermanTownName,

   395

	MakeEnglishAdditionalTownName,

   396

	MakeSpanishTownName,

   397

	MakeSillyTownName,

   398

	MakeSwedishTownName,

   399

	MakeDutchTownName,

   400

	MakeFinnishTownName,

   401

	MakePolishTownName,

   402

	MakeSlovakTownName,

   403

	MakeNorwegianTownName,

   404

	MakeHungarianTownName,

   405

	MakeAustrianTownName,

   406

	MakeRomanianTownName,

   407

	MakeCzechTownName,

   408

	MakeSwissTownName,

   409

};

   410

   411

// DO WE NEED THIS ANY MORE?

   412

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

   413

   414

uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type)

   415

{

   416

	switch (old_town_name_type) {

   417

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

   418

			/*	Already OK */

   419

			return townnameparts;

   420

   421

		case 1: /* French */

   422

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

   423

			*	0000 0000 0000 0000 0000 0000 1111 1111 */

   424

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

   425

   426

		case 2: /* German */

   427

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

   428

			return townnameparts;

   429

   430

		case 4: /* Latin-American */

   431

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

   432

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

   433

   434

		case 5: /* Silly */

   435

			/*	NUM_SILLY_1	-	lower 16 bits

   436

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

   437

			*	1000 0000 2222 2222 0000 0000 1111 1111 */

   438

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

   439

	}

   440

	return 0;

   441

}