1

/* $Id$ */

     2

     3

/** @file newgrf_townname.cpp

     4

 * Implementation of  Action 0F "universal holder" structure and functions.

     5

 * This file implements a linked-lists of townname generators,

     6

 * holding everything that the newgrf action 0F will send over to OpenTTD.

     7

 */

     8

     9

#include "stdafx.h"

    10

#include "openttd.h"

    11

#include "table/strings.h"

    12

#include "newgrf_townname.h"

    13

#include "string.h"

    14

    15

static GRFTownName *_grf_townnames = NULL;

    16

    17

GRFTownName *GetGRFTownName(uint32 grfid)

    18

{

    19

	GRFTownName *t = _grf_townnames;

    20

	for (; t != NULL; t = t->next) {

    21

		if (t->grfid == grfid) return t;

    22

	}

    23

	return NULL;

    24

}

    25

    26

GRFTownName *AddGRFTownName(uint32 grfid)

    27

{

    28

	GRFTownName *t = GetGRFTownName(grfid);

    29

	if (t == NULL) {

    30

		t = CallocT<GRFTownName>(1);

    31

		t->grfid = grfid;

    32

		t->next = _grf_townnames;

    33

		_grf_townnames = t;

    34

	}

    35

	return t;

    36

}

    37

    38

void DelGRFTownName(uint32 grfid)

    39

{

    40

	GRFTownName *t = _grf_townnames;

    41

	GRFTownName *p = NULL;

    42

	for (;t != NULL; p = t, t = t->next) if (t->grfid == grfid) break;

    43

	if (t != NULL) {

    44

		for (int i = 0; i < 128; i++) {

    45

			for (int j = 0; j < t->nbparts[i]; j++) {

    46

				for (int k = 0; k < t->partlist[i][j].partcount; k++) {

    47

					if (!HasBit(t->partlist[i][j].parts[k].prob, 7)) free(t->partlist[i][j].parts[k].data.text);

    48

				}

    49

				free(t->partlist[i][j].parts);

    50

			}

    51

			free(t->partlist[i]);

    52

		}

    53

		if (p != NULL) {

    54

			p->next = t->next;

    55

		} else {

    56

			_grf_townnames = t->next;

    57

		}

    58

		free(t);

    59

	}

    60

}

    61

    62

static char *RandomPart(char *buf, GRFTownName *t, uint32 seed, byte id, const char *last)

    63

{

    64

	assert(t != NULL);

    65

	for (int i = 0; i < t->nbparts[id]; i++) {

    66

		byte count = t->partlist[id][i].bitcount;

    67

		uint16 maxprob = t->partlist[id][i].maxprob;

    68

		uint32 r = (GB(seed, t->partlist[id][i].bitstart, count) * maxprob) >> count;

    69

		for (int j = 0; j < t->partlist[id][i].partcount; j++) {

    70

			byte prob = t->partlist[id][i].parts[j].prob;

    71

			maxprob -= GB(prob, 0, 7);

    72

			if (maxprob > r) continue;

    73

			if (HasBit(prob, 7)) {

    74

				buf = RandomPart(buf, t, seed, t->partlist[id][i].parts[j].data.id, last);

    75

			} else {

    76

				buf = strecat(buf, t->partlist[id][i].parts[j].data.text, last);

    77

			}

    78

			break;

    79

		}

    80

	}

    81

	return buf;

    82

}

    83

    84

char *GRFTownNameGenerate(char *buf, uint32 grfid, uint16 gen, uint32 seed, const char *last)

    85

{

    86

	strecpy(buf, "", last);

    87

	for (GRFTownName *t = _grf_townnames; t != NULL; t = t->next) {

    88

		if (t->grfid == grfid) {

    89

			assert(gen < t->nb_gen);

    90

			buf = RandomPart(buf, t, seed, t->id[gen], last);

    91

			break;

    92

		}

    93

	}

    94

	return buf;

    95

}

    96

    97

StringID *GetGRFTownNameList()

    98

{

    99

	int nb_names = 0, n = 0;

   100

	for (GRFTownName *t = _grf_townnames; t != NULL; t = t->next) nb_names += t->nb_gen;

   101

	StringID *list = MallocT<StringID>(nb_names + 1);

   102

	for (GRFTownName *t = _grf_townnames; t != NULL; t = t->next) {

   103

		for (int j = 0; j < t->nb_gen; j++) list[n++] = t->name[j];

   104

	}

   105

	list[n] = INVALID_STRING_ID;

   106

	return list;

   107

}

   108

   109

void CleanUpGRFTownNames()

   110

{

   111

	while (_grf_townnames != NULL) DelGRFTownName(_grf_townnames->grfid);

   112

}

   113

   114

uint32 GetGRFTownNameId(int gen)

   115

{

   116

	for (GRFTownName *t = _grf_townnames; t != NULL; t = t->next) {

   117

		if (gen < t->nb_gen) return t->grfid;

   118

		gen -= t->nb_gen;

   119

	}

   120

	/* Fallback to no NewGRF */

   121

	return 0;

   122

}

   123

   124

uint16 GetGRFTownNameType(int gen)

   125

{

   126

	for (GRFTownName *t = _grf_townnames; t != NULL; t = t->next) {

   127

		if (gen < t->nb_gen) return gen;

   128

		gen -= t->nb_gen;

   129

	}

   130

	/* Fallback to english original */

   131

	return SPECSTR_TOWNNAME_ENGLISH;

   132

}