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

#include "core/alloc_func.hpp"

    15

    16

static GRFTownName *_grf_townnames = NULL;

    17

    18

GRFTownName *GetGRFTownName(uint32 grfid)

    19

{

    20

	GRFTownName *t = _grf_townnames;

    21

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

    22

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

    23

	}

    24

	return NULL;

    25

}

    26

    27

GRFTownName *AddGRFTownName(uint32 grfid)

    28

{

    29

	GRFTownName *t = GetGRFTownName(grfid);

    30

	if (t == NULL) {

    31

		t = CallocT<GRFTownName>(1);

    32

		t->grfid = grfid;

    33

		t->next = _grf_townnames;

    34

		_grf_townnames = t;

    35

	}

    36

	return t;

    37

}

    38

    39

void DelGRFTownName(uint32 grfid)

    40

{

    41

	GRFTownName *t = _grf_townnames;

    42

	GRFTownName *p = NULL;

    43

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

    44

	if (t != NULL) {

    45

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

    46

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

    47

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

    48

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

    49

				}

    50

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

    51

			}

    52

			free(t->partlist[i]);

    53

		}

    54

		if (p != NULL) {

    55

			p->next = t->next;

    56

		} else {

    57

			_grf_townnames = t->next;

    58

		}

    59

		free(t);

    60

	}

    61

}

    62

    63

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

    64

{

    65

	assert(t != NULL);

    66

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

    67

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

    68

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

    69

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

    70

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

    71

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

    72

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

    73

			if (maxprob > r) continue;

    74

			if (HasBit(prob, 7)) {

    75

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

    76

			} else {

    77

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

    78

			}

    79

			break;

    80

		}

    81

	}

    82

	return buf;

    83

}

    84

    85

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

    86

{

    87

	strecpy(buf, "", last);

    88

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

    89

		if (t->grfid == grfid) {

    90

			assert(gen < t->nb_gen);

    91

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

    92

			break;

    93

		}

    94

	}

    95

	return buf;

    96

}

    97

    98

StringID *GetGRFTownNameList()

    99

{

   100

	int nb_names = 0, n = 0;

   101

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

   102

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

   103

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

   104

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

   105

	}

   106

	list[n] = INVALID_STRING_ID;

   107

	return list;

   108

}

   109

   110

void CleanUpGRFTownNames()

   111

{

   112

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

   113

}

   114

   115

uint32 GetGRFTownNameId(int gen)

   116

{

   117

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

   118

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

   119

		gen -= t->nb_gen;

   120

	}

   121

	/* Fallback to no NewGRF */

   122

	return 0;

   123

}

   124

   125

uint16 GetGRFTownNameType(int gen)

   126

{

   127

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

   128

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

   129

		gen -= t->nb_gen;

   130

	}

   131

	/* Fallback to english original */

   132

	return SPECSTR_TOWNNAME_ENGLISH;

   133

}