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

		buf[0] = e;

    15

		buf[1] = f;

    16

		buf[2] = g;

    17

		buf[3] = h;

    18

	}

    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

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

    30

		strcat(buf,name_original_english_1[i]);

    31

    32

	//mandatory middle segments

    33

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

    34

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

    35

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

    36

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

    37

    38

	//optional last segment

    39

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

    40

		strcat(buf, name_original_english_6[i]);

    41

    42

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

    43

		buf[0] = 'K';

    44

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

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

    54

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

    55

    56

	return 0;

    57

}

    58

    59

    60

static byte MakeEnglishAdditionalTownName(byte *buf, uint32 seed)

    61

{

    62

	int i;

    63

    64

	//null terminates the string for strcat

    65

	strcpy(buf, "");

    66

    67

	// optional first segment

    68

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

    69

		strcat(buf,name_additional_english_prefix[i]);

    70

    71

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

    72

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

    73

	} else {

    74

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

    75

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

    76

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

    77

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

    78

		} else {

    79

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

    80

		}

    81

	}

    82

    83

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

    84

    85

	//optional last segment

    86

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

    87

		strcat(buf, name_additional_english_3[i]);

    88

    89

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

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

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

    97

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

    98

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

    99

   100

	return 0;

   101

}

   102

   103

static byte MakeAustrianTownName(byte *buf, uint32 seed)

   104

{

   105

	int i, j = 0;

   106

	strcpy(buf, "");

   107

   108

	// Bad, Maria, Gross, ...

   109

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

   110

   111

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

   112

   113

	i = GetNumberBasedOnSeed(4, 6, seed);

   114

	if (i >= 4) {

   115

		// Kaisers-kirchen

   116

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

   117

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

   118

	} else if (i >= 2) {

   119

		// St. Johann

   120

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

   121

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

   122

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

   123

	} else {

   124

		// Zell

   125

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

   126

	}

   127

   128

	i = GetNumberBasedOnSeed(1, 6, seed);

   129

	if (i >= 4 - j) {

   130

		// an der Donau (rivers)

   131

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

   132

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

   133

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

   134

		// am Dachstein (mountains)

   135

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

   136

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

   137

	}

   138

   139

	return 0;

   140

}

   141

   142

static byte MakeGermanTownName(byte *buf, uint32 seed)

   143

{

   144

	uint i;

   145

	uint seed_derivative;

   146

   147

	//null terminates the string for strcat

   148

	strcpy(buf, "");

   149

   150

	seed_derivative = GetNumberBasedOnSeed(7, 28, seed);

   151

   152

	//optional prefix

   153

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

   154

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

   155

		strcat(buf,name_german_pre[i]);

   156

	}

   157

   158

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

   159

   160

	// mandatory middle segments including option of hardcoded name

   161

	if (i < lengthof(name_german_hardcoded)) {

   162

		strcat(buf,name_german_hardcoded[i]);

   163

	} else {

   164

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

   165

   166

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

   167

		strcat(buf, name_german_2[i]);

   168

	}

   169

   170

	// optional suffix

   171

	if (seed_derivative == 24) {

   172

		i = GetNumberBasedOnSeed(9,

   173

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

   174

		if (i < lengthof(name_german_4_an_der)) {

   175

			strcat(buf, name_german_3_an_der[0]);

   176

			strcat(buf, name_german_4_an_der[i]);

   177

		} else {

   178

			strcat(buf, name_german_3_am[0]);

   179

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

   180

		}

   181

	}

   182

	return 0;

   183

}

   184

   185

static byte MakeSpanishTownName(byte *buf, uint32 seed)

   186

{

   188

	return 0;

   189

}

   190

   191

static byte MakeFrenchTownName(byte *buf, uint32 seed)

   192

{

   194

	return 0;

   195

}

   196

   197

static byte MakeSillyTownName(byte *buf, uint32 seed)

   198

{

   200

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

   201

	return 0;

   202

}

   203

   204

static byte MakeSwedishTownName(byte *buf, uint32 seed)

   205

{

   206

	int i;

   207

   208

	//null terminates the string for strcat

   209

	strcpy(buf, "");

   210

   211

	// optional first segment

   212

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

   213

		strcat(buf, name_swedish_1[i]);

   214

   215

	// mandatory middle segments including option of hardcoded name

   216

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

   217

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

   218

	} else {

   219

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

   220

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

   221

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

   222

	}

   223

   224

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

   225

   226

	return 0;

   227

}

   228

   229

static byte MakeDutchTownName(byte *buf, uint32 seed)

   230

{

   231

	int i;

   232

   233

	//null terminates the string for strcat

   234

	strcpy(buf, "");

   235

   236

	// optional first segment

   237

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

   238

		strcat(buf, name_dutch_1[i]);

   239

   240

	// mandatory middle segments including option of hardcoded name

   241

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

   242

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

   243

	} else {

   244

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

   245

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

   246

	}

   247

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

   248

   249

	return 0;

   250

}

   251

   252

static byte MakeFinnishTownName(byte *buf, uint32 seed)

   253

{

   254

	//null terminates the string for strcat

   255

	strcpy(buf, "");

   256

   257

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

   258

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

   259

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

   260

	} else {

   261

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

   262

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

   263

	}

   264

   265

	return 0;

   266

}

   267

   268

static byte MakePolishTownName(byte *buf, uint32 seed)

   269

{

   270

	uint i;

   271

	uint j;

   272

   273

	//null terminates the string for strcat

   274

	strcpy(buf, "");

   275

   276

	// optional first segment

   277

	i = GetNumberBasedOnSeed(0,

   278

		lengthof(name_polish_2_o) + lengthof(name_polish_2_m) +

   279

		lengthof(name_polish_2_f) + lengthof(name_polish_2_n),

   280

		seed);

   281

	j = GetNumberBasedOnSeed(2, 20, seed);

   282

   283

   284

	if (i < lengthof(name_polish_2_o)) {

   285

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

   286

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

   287

		if (j < 4)

   288

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

   289

   290

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

   291

   292

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

   293

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

   294

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

   295

		if (j < 4)

   296

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

   297

   298

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

   299

   300

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

   301

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

   302

	} else {

   303

		if (j < 4)

   304

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

   305

   306

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

   307

   308

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

   309

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

   310

	}

   311

	return 0;

   312

}

   313

   314

static byte MakeCzechTownName(byte *buf, uint32 seed)

   315

{

   317

	return 0;

   318

}

   319

   320

static byte MakeRomanianTownName(byte *buf, uint32 seed)

   321

{

   323

	return 0;

   324

}

   325

   326

static byte MakeSlovakTownName(byte *buf, uint32 seed)

   327

{

   329

	return 0;

   330

}

   331

   332

static byte MakeNorwegianTownName(byte *buf, uint32 seed)

   333

{

   334

	strcpy(buf, "");

   335

   336

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

   337

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

   338

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

   339

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

   340

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

   341

	} else {

   342

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

   343

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

   344

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

   345

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

   346

	}

   347

   348

	return 0;

   349

}

   350

   351

static byte MakeHungarianTownName(byte *buf, uint32 seed)

   352

{

   353

	uint i;

   354

   355

	//null terminates the string for strcat

   356

	strcpy(buf, "");

   357

   358

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

   359

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

   360

	} else {

   361

		// optional first segment

   362

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

   363

		if (i < lengthof(name_hungarian_1))

   364

			strcat(buf, name_hungarian_1[i]);

   365

   366

		// mandatory middle segments

   367

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

   368

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

   369

   370

		// optional last segment

   371

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

   372

			strcat(buf, name_hungarian_4[i]);

   373

		}

   374

	}

   375

   376

	return 0;

   377

}

   378

   379

TownNameGenerator * const _town_name_generators[] =

   380

{

   381

	MakeEnglishOriginalTownName,

   382

	MakeFrenchTownName,

   383

	MakeGermanTownName,

   384

	MakeEnglishAdditionalTownName,

   385

	MakeSpanishTownName,

   386

	MakeSillyTownName,

   387

	MakeSwedishTownName,

   388

	MakeDutchTownName,

   389

	MakeFinnishTownName,

   390

	MakePolishTownName,

   391

	MakeSlovakTownName,

   392

	MakeNorwegianTownName,

   393

	MakeHungarianTownName,

   394

	MakeAustrianTownName,

   395

	MakeRomanianTownName,

   396

	MakeCzechTownName,

   397

};

   398

   399

// DO WE NEED THIS ANY MORE?

   400

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

   401

   402

uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type)

   403

{

   404

	switch (old_town_name_type) {

   405

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

   406

			/*	Already OK */

   407

			return townnameparts;

   408

   409

		case 1: /* French */

   410

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

   411

			*	0000 0000 0000 0000 0000 0000 1111 1111 */

   412

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

   413

   414

		case 2: /* German */

   415

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

   416

			return townnameparts;

   417

   418

		case 4: /* Latin-American */

   419

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

   420

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

   421

   422

		case 5: /* Silly */

   423

			/*	NUM_SILLY_1	-	lower 16 bits

   424

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

   425

			*	1000 0000 2222 2222 0000 0000 1111 1111 */

   426

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

   427

	}

   428

	return 0;

   429

}