OpenTTD
newgrf_townname.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of OpenTTD.
3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6  */
7 
15 #include "stdafx.h"
16 #include "newgrf_townname.h"
17 #include "core/alloc_func.hpp"
18 #include "string_func.h"
19 
20 #include "safeguards.h"
21 
22 static GRFTownName *_grf_townnames = nullptr;
23 
24 GRFTownName *GetGRFTownName(uint32 grfid)
25 {
26  GRFTownName *t = _grf_townnames;
27  for (; t != nullptr; t = t->next) {
28  if (t->grfid == grfid) return t;
29  }
30  return nullptr;
31 }
32 
33 GRFTownName *AddGRFTownName(uint32 grfid)
34 {
35  GRFTownName *t = GetGRFTownName(grfid);
36  if (t == nullptr) {
37  t = CallocT<GRFTownName>(1);
38  t->grfid = grfid;
39  t->next = _grf_townnames;
40  _grf_townnames = t;
41  }
42  return t;
43 }
44 
45 void DelGRFTownName(uint32 grfid)
46 {
47  GRFTownName *t = _grf_townnames;
48  GRFTownName *p = nullptr;
49  for (;t != nullptr; p = t, t = t->next) if (t->grfid == grfid) break;
50  if (t != nullptr) {
51  for (int i = 0; i < 128; i++) {
52  for (int j = 0; j < t->nbparts[i]; j++) {
53  for (int k = 0; k < t->partlist[i][j].partcount; k++) {
54  if (!HasBit(t->partlist[i][j].parts[k].prob, 7)) free(t->partlist[i][j].parts[k].data.text);
55  }
56  free(t->partlist[i][j].parts);
57  }
58  free(t->partlist[i]);
59  }
60  if (p != nullptr) {
61  p->next = t->next;
62  } else {
63  _grf_townnames = t->next;
64  }
65  free(t);
66  }
67 }
68 
69 static char *RandomPart(char *buf, GRFTownName *t, uint32 seed, byte id, const char *last)
70 {
71  assert(t != nullptr);
72  for (int i = 0; i < t->nbparts[id]; i++) {
73  byte count = t->partlist[id][i].bitcount;
74  uint16 maxprob = t->partlist[id][i].maxprob;
75  uint32 r = (GB(seed, t->partlist[id][i].bitstart, count) * maxprob) >> count;
76  for (int j = 0; j < t->partlist[id][i].partcount; j++) {
77  byte prob = t->partlist[id][i].parts[j].prob;
78  maxprob -= GB(prob, 0, 7);
79  if (maxprob > r) continue;
80  if (HasBit(prob, 7)) {
81  buf = RandomPart(buf, t, seed, t->partlist[id][i].parts[j].data.id, last);
82  } else {
83  buf = strecat(buf, t->partlist[id][i].parts[j].data.text, last);
84  }
85  break;
86  }
87  }
88  return buf;
89 }
90 
91 char *GRFTownNameGenerate(char *buf, uint32 grfid, uint16 gen, uint32 seed, const char *last)
92 {
93  strecpy(buf, "", last);
94  for (GRFTownName *t = _grf_townnames; t != nullptr; t = t->next) {
95  if (t->grfid == grfid) {
96  assert(gen < t->nb_gen);
97  buf = RandomPart(buf, t, seed, t->id[gen], last);
98  break;
99  }
100  }
101  return buf;
102 }
103 
104 StringID *GetGRFTownNameList()
105 {
106  int nb_names = 0, n = 0;
107  for (GRFTownName *t = _grf_townnames; t != nullptr; t = t->next) nb_names += t->nb_gen;
108  StringID *list = MallocT<StringID>(nb_names + 1);
109  for (GRFTownName *t = _grf_townnames; t != nullptr; t = t->next) {
110  for (int j = 0; j < t->nb_gen; j++) list[n++] = t->name[j];
111  }
112  list[n] = INVALID_STRING_ID;
113  return list;
114 }
115 
116 void CleanUpGRFTownNames()
117 {
118  while (_grf_townnames != nullptr) DelGRFTownName(_grf_townnames->grfid);
119 }
120 
121 uint32 GetGRFTownNameId(int gen)
122 {
123  for (GRFTownName *t = _grf_townnames; t != nullptr; t = t->next) {
124  if (gen < t->nb_gen) return t->grfid;
125  gen -= t->nb_gen;
126  }
127  /* Fallback to no NewGRF */
128  return 0;
129 }
130 
131 uint16 GetGRFTownNameType(int gen)
132 {
133  for (GRFTownName *t = _grf_townnames; t != nullptr; t = t->next) {
134  if (gen < t->nb_gen) return gen;
135  gen -= t->nb_gen;
136  }
137  /* Fallback to english original */
138  return SPECSTR_TOWNNAME_ENGLISH;
139 }
static char * strecat(char *dst, const char *src, const char *last)
Appends characters from one string to another.
Definition: depend.cpp:97
char * text
If probability bit 7 is clear.
Header of Action 0F "universal holder" structure and functions.
Functions related to low-level strings.
Functions related to the allocation of memory.
Definition of base types and functions in a cross-platform compatible way.
A number of safeguards to prevent using unsafe methods.
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
byte prob
The relative probability of the following name to appear in the bottom 7 bits.
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
char * strecpy(char *dst, const char *src, const char *last)
Copies characters from one buffer to another.
Definition: depend.cpp:66
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: depend.cpp:129
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
byte id
If probability bit 7 is set.