ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/arch.C
(Generate patch)

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.8 by root, Wed Aug 30 06:06:26 2006 UTC vs.
Revision 1.22 by root, Thu Sep 14 22:35:53 2006 UTC

1/*
2 * static char *rcsid_arch_c =
3 * "$Id: arch.C,v 1.8 2006/08/30 06:06:26 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
21 16
22 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 20
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 22*/
23
24#include <cassert>
25
26#include <tr1/unordered_map>
28 27
29#include <global.h> 28#include <global.h>
30#include <arch.h> 29#include <arch.h>
31#include <funcpoint.h> 30#include <funcpoint.h>
32#include <loader.h> 31#include <loader.h>
33 32
34#include <cassert>
35
36/* IF set, does a little timing on the archetype load. */ 33/* IF set, does a little timing on the archetype load. */
37#define TIME_ARCH_LOAD 0 34#define TIME_ARCH_LOAD 0
38 35
39static void add_arch(archetype *at); 36static void add_arch (archetype *at);
40 37
41static archetype *arch_table[ARCHTABLE]; 38static archetype *arch_table[ARCHTABLE];
42int arch_cmp=0; /* How many strcmp's */ 39int arch_cmp = 0; /* How many strcmp's */
43int arch_search=0; /* How many searches */ 40int arch_search = 0; /* How many searches */
44int arch_init; /* True if doing arch initialization */ 41int arch_init; /* True if doing arch initialization */
45 42
46/* The naming of these functions is really poor - they are all 43/* The naming of these functions is really poor - they are all
47 * pretty much named '.._arch_...', but they may more may not 44 * pretty much named '.._arch_...', but they may more may not
48 * return archetypes. Some make the arch_to_object call, and thus 45 * return archetypes. Some make the arch_to_object call, and thus
49 * return an object. Perhaps those should be called 'archob' functions 46 * return an object. Perhaps those should be called 'archob' functions
50 * to denote they return an object derived from the archetype. 47 * to denote they return an object derived from the archetype.
51 * MSW 2003-04-29 48 * MSW 2003-04-29
52 */ 49 */
50
51#if USE_UNORDERED_MAP
52// the hashtable
53typedef std::tr1::unordered_map
54 <
55 std::size_t,
56 archetype *,
57 std::hash<size_t>,
58 std::equal_to<size_t>,
59 slice_allocator< std::pair<const std::size_t, archetype *> >
60 true,
61 > HT;
62
63static HT ht;
64#endif
53 65
54/** 66/**
55 * GROS - This function retrieves an archetype given the name that appears 67 * GROS - This function retrieves an archetype given the name that appears
56 * during the game (for example, "writing pen" instead of "stylus"). 68 * during the game (for example, "writing pen" instead of "stylus").
57 * It does not use the hashtable system, but browse the whole archlist each time. 69 * It does not use the hashtable system, but browse the whole archlist each time.
… …
60 * Params: 72 * Params:
61 * - name: the name we're searching for (ex: "writing pen"); 73 * - name: the name we're searching for (ex: "writing pen");
62 * Return value: 74 * Return value:
63 * - the archetype found or null if nothing was found. 75 * - the archetype found or null if nothing was found.
64 */ 76 */
77archetype *
65archetype *find_archetype_by_object_name(const char *name) { 78find_archetype_by_object_name (const char *name)
79{
66 archetype *at; 80 archetype *at;
67 81
68 if (name == NULL) 82 if (name == NULL)
69 return (archetype *) NULL; 83 return (archetype *) NULL;
70 84
71 for(at = first_archetype;at!=NULL;at=at->next) { 85 for (at = first_archetype; at != NULL; at = at->next)
86 {
72 if (!strcmp(at->clone.name, name)) 87 if (!strcmp (at->clone.name, name))
73 return at; 88 return at;
74 } 89 }
75 return NULL; 90 return NULL;
76} 91}
77 92
78/** 93/**
79 * This function retrieves an archetype by type and name that appears during 94 * This function retrieves an archetype by type and name that appears during
80 * the game. It is basically the same as find_archetype_by_object_name() 95 * the game. It is basically the same as find_archetype_by_object_name()
81 * except that it considers only items of the given type. 96 * except that it considers only items of the given type.
82 */ 97 */
98archetype *
83archetype *find_archetype_by_object_type_name(int type, const char *name) { 99find_archetype_by_object_type_name (int type, const char *name)
100{
84 archetype *at; 101 archetype *at;
85 102
86 if (name == NULL) 103 if (name == NULL)
87 return NULL;
88
89 for (at = first_archetype; at != NULL; at = at->next) {
90 if (at->clone.type == type && strcmp(at->clone.name, name) == 0)
91 return at;
92 }
93
94 return NULL; 104 return NULL;
105
106 for (at = first_archetype; at != NULL; at = at->next)
107 {
108 if (at->clone.type == type && strcmp (at->clone.name, name) == 0)
109 return at;
110 }
111
112 return NULL;
95} 113}
96 114
97/* This is a lot like the above function. Instead, we are trying to match 115/* This is a lot like the above function. Instead, we are trying to match
98 * the arch->skill values. type is the type of object to match 116 * the arch->skill values. type is the type of object to match
99 * against (eg, to only match against skills or only skill objects for example). 117 * against (eg, to only match against skills or only skill objects for example).
100 * If type is -1, ew don't match on type. 118 * If type is -1, ew don't match on type.
101 */ 119 */
120object *
102object *get_archetype_by_skill_name(const char *skill, int type) { 121get_archetype_by_skill_name (const char *skill, int type)
122{
103 archetype *at; 123 archetype *
124 at;
104 125
105 if (skill == NULL) 126 if (skill == NULL)
106 return NULL;
107
108 for(at = first_archetype;at!=NULL;at=at->next) {
109 if ( ((type == -1) || (type == at->clone.type)) &&
110 (!strcmp(at->clone.skill, skill)))
111 return arch_to_object(at);
112 }
113 return NULL; 127 return NULL;
128
129 for (at = first_archetype; at != NULL; at = at->next)
130 {
131 if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
132 return arch_to_object (at);
133 }
134 return NULL;
114} 135}
115 136
116/* similiar to above - this returns the first archetype 137/* similiar to above - this returns the first archetype
117 * that matches both the type and subtype. type and subtype 138 * that matches both the type and subtype. type and subtype
118 * can be -1 to say ignore, but in this case, the match it does 139 * can be -1 to say ignore, but in this case, the match it does
119 * may not be very useful. This function is most useful when 140 * may not be very useful. This function is most useful when
120 * subtypes are known to be unique for a particular type 141 * subtypes are known to be unique for a particular type
121 * (eg, skills) 142 * (eg, skills)
122 */ 143 */
144archetype *
123archetype *get_archetype_by_type_subtype(int type, int subtype) { 145get_archetype_by_type_subtype (int type, int subtype)
146{
124 archetype *at; 147 archetype *
148 at;
125 149
126 for(at = first_archetype;at!=NULL;at=at->next) { 150 for (at = first_archetype; at != NULL; at = at->next)
127 if ( ((type == -1) || (type == at->clone.type)) && 151 {
128 (subtype == -1 || subtype == at->clone.subtype)) 152 if (((type == -1) || (type == at->clone.type)) && (subtype == -1 || subtype == at->clone.subtype))
129 return at; 153 return at;
130 } 154 }
131 return NULL; 155 return NULL;
132} 156}
133 157
134/** 158/**
135 * GROS - this returns a new object given the name that appears during the game 159 * GROS - this returns a new object given the name that appears during the game
136 * (for example, "writing pen" instead of "stylus"). 160 * (for example, "writing pen" instead of "stylus").
… …
141 * Note by MSW - it appears that it takes the full name and keeps 165 * Note by MSW - it appears that it takes the full name and keeps
142 * shortening it until it finds a match. I re-wrote this so that it 166 * shortening it until it finds a match. I re-wrote this so that it
143 * doesn't malloc it each time - not that this function is used much, 167 * doesn't malloc it each time - not that this function is used much,
144 * but it otherwise had a big memory leak. 168 * but it otherwise had a big memory leak.
145 */ 169 */
170object *
146object *get_archetype_by_object_name(const char *name) { 171get_archetype_by_object_name (const char *name)
172{
147 archetype *at; 173 archetype *at;
148 char tmpname[MAX_BUF]; 174 char tmpname[MAX_BUF];
149 int i; 175 int i;
150 176
151 strncpy(tmpname,name,MAX_BUF-1); 177 assign (tmpname, name);
152 tmpname[MAX_BUF-1] = 0; 178
153 for(i=strlen(tmpname); i>0; i--) { 179 for (i = strlen (tmpname); i > 0; i--)
180 {
154 tmpname[i] = 0; 181 tmpname[i] = 0;
155 at = find_archetype_by_object_name(tmpname); 182 at = find_archetype_by_object_name (tmpname);
183
156 if (at !=NULL) 184 if (at != NULL)
157 {
158 return arch_to_object(at); 185 return arch_to_object (at);
159 }
160 } 186 }
187
161 return create_singularity(name); 188 return create_singularity (name);
162} 189}
163 190
164 /* This is a subset of the parse_id command. Basically, name can be 191 /* This is a subset of the parse_id command. Basically, name can be
165 * a string seperated lists of things to match, with certain keywords. 192 * a string seperated lists of things to match, with certain keywords.
166 * pl is the player (only needed to set count properly) 193 * pl is the player (only needed to set count properly)
… …
176 * player object.) 203 * player object.)
177 * If count is 1, make a quick check on the name. 204 * If count is 1, make a quick check on the name.
178 * IF count is >1, we need to make plural name. Return if match. 205 * IF count is >1, we need to make plural name. Return if match.
179 * Last, make a check on the full name. 206 * Last, make a check on the full name.
180 */ 207 */
208int
181int item_matched_string(object *pl, object *op, const char *name) 209item_matched_string (object *pl, object *op, const char *name)
182{ 210{
183 char *cp, local_name[MAX_BUF]; 211 char *cp, local_name[MAX_BUF];
184 int count,retval=0; 212 int count, retval = 0;
213
185 strcpy(local_name, name); /* strtok is destructive to name */ 214 strcpy (local_name, name); /* strtok is destructive to name */
186 215
187 for (cp=strtok(local_name,","); cp; cp=strtok(NULL,",")) { 216 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
188 while (cp[0]==' ') ++cp; /* get rid of spaces */ 217 {
218 while (cp[0] == ' ')
219 ++cp; /* get rid of spaces */
189 220
190 /* LOG(llevDebug,"Trying to match %s\n", cp);*/ 221 /* LOG(llevDebug,"Trying to match %s\n", cp); */
191 /* All is a very generic match - low match value */ 222 /* All is a very generic match - low match value */
192 if (!strcmp(cp,"all")) return 1; 223 if (!strcmp (cp, "all"))
224 return 1;
193 225
194 /* unpaid is a little more specific */ 226 /* unpaid is a little more specific */
195 if (!strcmp(cp,"unpaid") && QUERY_FLAG(op,FLAG_UNPAID)) return 2; 227 if (!strcmp (cp, "unpaid") && QUERY_FLAG (op, FLAG_UNPAID))
196 if (!strcmp(cp,"cursed") && QUERY_FLAG(op,FLAG_KNOWN_CURSED) &&
197 (QUERY_FLAG(op,FLAG_CURSED) ||QUERY_FLAG(op,FLAG_DAMNED)))
198 return 2; 228 return 2;
229 if (!strcmp (cp, "cursed") && QUERY_FLAG (op, FLAG_KNOWN_CURSED) && (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)))
230 return 2;
199 231
200 if (!strcmp(cp,"unlocked") && !QUERY_FLAG(op, FLAG_INV_LOCKED)) 232 if (!strcmp (cp, "unlocked") && !QUERY_FLAG (op, FLAG_INV_LOCKED))
201 return 2; 233 return 2;
202 234
203 /* Allow for things like '100 arrows' */ 235 /* Allow for things like '100 arrows' */
204 if ((count=atoi(cp))!=0) { 236 if ((count = atoi (cp)) != 0)
237 {
205 cp=strchr(cp, ' '); 238 cp = strchr (cp, ' ');
206 while (cp && cp[0]==' ') ++cp; /* get rid of spaces */ 239 while (cp && cp[0] == ' ')
240 ++cp; /* get rid of spaces */
241 }
242 else
207 } 243 {
208 else {
209 if (pl->type==PLAYER) 244 if (pl->type == PLAYER)
210 count=pl->contr->count; 245 count = pl->contr->count;
211 else 246 else
212 count = 0; 247 count = 0;
213 } 248 }
214 249
215 if (!cp || cp[0]=='\0' || count<0) return 0; 250 if (!cp || cp[0] == '\0' || count < 0)
251 return 0;
216 252
217 253
218 /* The code here should go from highest retval to lowest. That 254 /* The code here should go from highest retval to lowest. That
219 * is because of the 'else' handling - we don't want to match on 255 * is because of the 'else' handling - we don't want to match on
220 * something and set a low retval, even though it may match a higher retcal 256 * something and set a low retval, even though it may match a higher retcal
221 * later. So keep it in descending order here, so we try for the best 257 * later. So keep it in descending order here, so we try for the best
222 * match first, and work downward. 258 * match first, and work downward.
223 */ 259 */
224 if (!strcasecmp(cp,query_name(op))) retval=20; 260 if (!strcasecmp (cp, query_name (op)))
261 retval = 20;
225 else if (!strcasecmp(cp,query_short_name(op))) retval=18; 262 else if (!strcasecmp (cp, query_short_name (op)))
226 else if (!strcasecmp(cp,query_base_name(op,0))) retval=16; 263 retval = 18;
227 else if (!strcasecmp(cp,query_base_name(op,1))) retval=16;
228 else if (op->custom_name && !strcasecmp(cp,op->custom_name)) retval=15;
229 else if (!strncasecmp(cp,query_base_name(op,0), 264 else if (!strcasecmp (cp, query_base_name (op, 0)))
230 strlen(cp))) retval=14; 265 retval = 16;
231 else if (!strncasecmp(cp,query_base_name(op,1), 266 else if (!strcasecmp (cp, query_base_name (op, 1)))
232 strlen(cp))) retval=14; 267 retval = 16;
268 else if (op->custom_name && !strcasecmp (cp, op->custom_name))
269 retval = 15;
270 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
271 retval = 14;
272 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
273 retval = 14;
233 274
234 /* Do substring checks, so things like 'Str+1' will match. 275 /* Do substring checks, so things like 'Str+1' will match.
235 * retval of these should perhaps be lower - they are lower 276 * retval of these should perhaps be lower - they are lower
236 * then the specific strcasecmp aboves, but still higher than 277 * then the specific strcasecmp aboves, but still higher than
237 * some other match criteria. 278 * some other match criteria.
238 */ 279 */
239 else if (strstr(query_base_name(op,1), cp)) retval = 12; 280 else if (strstr (query_base_name (op, 1), cp))
281 retval = 12;
240 else if (strstr(query_base_name(op,0), cp)) retval = 12; 282 else if (strstr (query_base_name (op, 0), cp))
283 retval = 12;
241 else if (strstr(query_short_name(op), cp)) retval = 12; 284 else if (strstr (query_short_name (op), cp))
285 retval = 12;
242 286
243 /* Check against plural/non plural based on count. */ 287 /* Check against plural/non plural based on count. */
244 else if (count>1 && !strcasecmp(cp,op->name_pl)) { 288 else if (count > 1 && !strcasecmp (cp, op->name_pl))
245 retval=6;
246 } 289 {
290 retval = 6;
291 }
247 else if (count==1 && !strcasecmp(op->name,cp)) { 292 else if (count == 1 && !strcasecmp (op->name, cp))
248 retval=6;
249 } 293 {
294 retval = 6;
295 }
250 /* base name matched - not bad */ 296 /* base name matched - not bad */
251 else if (strcasecmp(cp,op->name)==0 && !count) retval=4; 297 else if (strcasecmp (cp, op->name) == 0 && !count)
298 retval = 4;
252 /* Check for partial custom name, but give a real low priority */ 299 /* Check for partial custom name, but give a real low priority */
253 else if (op->custom_name && strstr(op->custom_name, cp)) retval = 3; 300 else if (op->custom_name && strstr (op->custom_name, cp))
301 retval = 3;
254 302
255 if (retval) { 303 if (retval)
304 {
256 if (pl->type == PLAYER) 305 if (pl->type == PLAYER)
257 pl->contr->count=count; 306 pl->contr->count = count;
258 return retval; 307 return retval;
259 } 308 }
260 } 309 }
261 return 0; 310 return 0;
262} 311}
263 312
264/* 313/*
265 * Initialises the internal linked list of archetypes (read from file). 314 * Initialises the internal linked list of archetypes (read from file).
266 * Then the global "empty_archetype" pointer is initialised. 315 * Then the global "empty_archetype" pointer is initialised.
267 * Then the blocksview[] array is initialised. 316 * Then the blocksview[] array is initialised.
268 */ 317 */
269 318
270void init_archetypes(void) { /* called from add_player() and edit() */ 319void
320init_archetypes (void)
321{ /* called from add_player() and edit() */
271 if(first_archetype!=NULL) /* Only do this once */ 322 if (first_archetype != NULL) /* Only do this once */
272 return; 323 return;
324
273 arch_init = 1; 325 arch_init = 1;
274 load_archetypes(); 326 load_archetypes ();
275 arch_init = 0; 327 arch_init = 0;
276 empty_archetype=find_archetype("empty_archetype"); 328 empty_archetype = archetype::find ("empty_archetype");
329
277/* init_blocksview();*/ 330/* init_blocksview();*/
278} 331}
279 332
280/* 333/*
281 * Stores debug-information about how efficient the hashtable 334 * Stores debug-information about how efficient the hashtable
282 * used for archetypes has been in the static errmsg array. 335 * used for archetypes has been in the static errmsg array.
283 */ 336 */
284 337
338void
285void arch_info(object *op) { 339arch_info (object *op)
340{
286 sprintf(errmsg,"%d searches and %d strcmp()'s",arch_search,arch_cmp); 341 sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
287 new_draw_info(NDI_BLACK, 0, op,errmsg); 342 new_draw_info (NDI_BLACK, 0, op, errmsg);
288} 343}
289 344
290/* 345/*
291 * Initialise the hashtable used by the archetypes. 346 * Initialise the hashtable used by the archetypes.
292 */ 347 */
293 348
349void
294void clear_archetable(void) { 350clear_archetable (void)
351{
295 memset((void *) arch_table,0,ARCHTABLE*sizeof(archetype *)); 352 memset ((void *) arch_table, 0, ARCHTABLE * sizeof (archetype *));
296} 353}
297 354
298/* 355/*
299 * An alternative way to init the hashtable which is slower, but _works_... 356 * An alternative way to init the hashtable which is slower, but _works_...
300 */ 357 */
301 358
359void
302void init_archetable(void) { 360init_archetable (void)
361{
303 archetype *at; 362 archetype *at;
363
304 LOG(llevDebug," Setting up archetable...\n"); 364 LOG (llevDebug, " Setting up archetable...\n");
365
305 for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) 366 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
306 add_arch(at); 367 add_arch (at);
368
307 LOG(llevDebug,"done\n"); 369 LOG (llevDebug, "done\n");
308} 370}
309 371
310/* 372/*
311 * Dumps an archetype to debug-level output. 373 * Dumps an archetype to debug-level output.
312 */ 374 */
313 375
376void
314void dump_arch(archetype *at) { 377dump_arch (archetype *at)
378{
315 dump_object(&at->clone); 379 dump_object (&at->clone);
316} 380}
317 381
318/* 382/*
319 * Dumps _all_ archetypes to debug-level output. 383 * Dumps _all_ archetypes to debug-level output.
320 * If you run crossfire with debug, and enter DM-mode, you can trigger 384 * If you run crossfire with debug, and enter DM-mode, you can trigger
321 * this with the O key. 385 * this with the O key.
322 */ 386 */
323 387
388void
324void dump_all_archetypes(void) { 389dump_all_archetypes (void)
390{
325 archetype *at; 391 archetype *at;
392
326 for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) { 393 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
394 {
327 dump_arch(at); 395 dump_arch (at);
328 fprintf(logfile, "%s\n", errmsg); 396 fprintf (logfile, "%s\n", errmsg);
329 } 397 }
330} 398}
331 399
400void
332void free_all_archs(void) 401free_all_archs (void)
333{ 402{
334 archetype *at, *next; 403 archetype *at, *next;
335 int i=0,f=0; 404 int i = 0, f = 0;
336 405
337 for (at=first_archetype; at!=NULL; at=next) { 406 for (at = first_archetype; at != NULL; at = next)
338 if (at->more) next=at->more; 407 {
408 if (at->more)
409 next = at->more;
410 else
339 else next=at->next; 411 next = at->next;
340 if (at->name) free_string(at->name); 412
341 if (at->clone.name) free_string(at->clone.name); 413 delete
342 if (at->clone.name_pl) free_string(at->clone.name_pl);
343 if (at->clone.title) free_string(at->clone.title);
344 if (at->clone.race) free_string(at->clone.race);
345 if (at->clone.slaying) free_string(at->clone.slaying);
346 if (at->clone.msg) free_string(at->clone.msg);
347 free(at); 414 at;
415
348 i++; 416 i++;
349 } 417 }
350 LOG(llevDebug,"Freed %d archetypes, %d faces\n", i, f); 418 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
351} 419}
352 420
353/* 421archetype::archetype ()
354 * Allocates, initialises and returns the pointer to an archetype structure. 422{
355 */
356
357archetype *get_archetype_struct(void) {
358 archetype *arch;
359
360 arch=(archetype *)CALLOC(1,sizeof(archetype));
361 if(arch==NULL)
362 fatal(OUT_OF_MEMORY);
363 arch->next=NULL;
364 arch->name=NULL;
365 arch->clone.other_arch=NULL;
366 arch->clone.name=NULL;
367 arch->clone.name_pl=NULL;
368 arch->clone.title=NULL;
369 arch->clone.race=NULL;
370 arch->clone.slaying=NULL;
371 arch->clone.msg=NULL;
372 clear_object(&arch->clone); /* to initial state other also */ 423 clear_object (&clone); /* to initial state other also */
373 CLEAR_FLAG((&arch->clone),FLAG_FREED); /* This shouldn't matter, since copy_object() */ 424 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */
374 SET_FLAG((&arch->clone), FLAG_REMOVED); /* doesn't copy these flags... */ 425 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
375 arch->head=NULL; 426}
376 arch->more=NULL; 427
377 return arch; 428archetype::~archetype ()
429{
378} 430}
379 431
380/* 432/*
381 * Reads/parses the archetype-file, and copies into a linked list 433 * Reads/parses the archetype-file, and copies into a linked list
382 * of archetype-structures. 434 * of archetype-structures.
383 */ 435 */
436void
384void first_arch_pass(object_thawer &fp) { 437first_arch_pass (object_thawer & fp)
385 object *op; 438{
386 archetype *at,*head=NULL,*last_more=NULL; 439 archetype *at, *head = NULL, *last_more = NULL;
387 int i,first=2;
388 440
389 op=get_object(); 441 at->clone.arch = first_archetype = at = new archetype;
390 op->arch=first_archetype=at=get_archetype_struct();
391 442
392 while((i=load_object(fp,op,first,0))) { 443 while (int i = load_object (fp, &at->clone, 0))
393 first=0; 444 {
394 copy_object(op,&at->clone);
395 at->clone.speed_left= (float) (-0.1); 445 at->clone.speed_left = (float) (-0.1);
396 /* copy the body_info to the body_used - this is only really 446 /* copy the body_info to the body_used - this is only really
397 * need for monsters, but doesn't hurt to do it for everything. 447 * need for monsters, but doesn't hurt to do it for everything.
398 * by doing so, when a monster is created, it has good starting 448 * by doing so, when a monster is created, it has good starting
399 * values for the body_used info, so when items are created 449 * values for the body_used info, so when items are created
400 * for it, they can be properly equipped. 450 * for it, they can be properly equipped.
401 */ 451 */
402 memcpy(&at->clone.body_used, &op->body_info, sizeof(op->body_info)); 452 memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
403 453
404 switch(i) { 454 switch (i)
455 {
405 case LL_NORMAL: /* A new archetype, just link it with the previous */ 456 case LL_NORMAL: /* A new archetype, just link it with the previous */
406 if(last_more!=NULL) 457 if (last_more != NULL)
407 last_more->next=at; 458 last_more->next = at;
408 if(head!=NULL) 459 if (head != NULL)
409 head->next=at; 460 head->next = at;
410 head=last_more=at; 461 head = last_more = at;
411#if 0 462#if 0
412 if(!op->type) 463 if (!op->type)
413 LOG(llevDebug," WARNING: Archetype %s has no type info!\n", op->arch->name); 464 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
414#endif 465#endif
415 at->tail_x = 0; 466 at->tail_x = 0;
416 at->tail_y = 0; 467 at->tail_y = 0;
417 break; 468 break;
418 469
419 case LL_MORE: /* Another part of the previous archetype, link it correctly */ 470 case LL_MORE: /* Another part of the previous archetype, link it correctly */
420 471
421 at->head=head; 472 at->head = head;
422 at->clone.head = &head->clone; 473 at->clone.head = &head->clone;
423 if(last_more!=NULL) { 474 if (last_more != NULL)
475 {
424 last_more->more=at; 476 last_more->more = at;
425 last_more->clone.more = &at->clone; 477 last_more->clone.more = &at->clone;
426 } 478 }
427 last_more=at; 479 last_more = at;
428 480
429 /* If this multipart image is still composed of individual small 481 /* If this multipart image is still composed of individual small
430 * images, don't set the tail_.. values. We can't use them anyways, 482 * images, don't set the tail_.. values. We can't use them anyways,
431 * and setting these to zero makes the map sending to the client much 483 * and setting these to zero makes the map sending to the client much
432 * easier as just looking at the head, we know what to do. 484 * easier as just looking at the head, we know what to do.
433 */ 485 */
434 if (at->clone.face != head->clone.face) { 486 if (at->clone.face != head->clone.face)
487 {
435 head->tail_x = 0; 488 head->tail_x = 0;
436 head->tail_y = 0; 489 head->tail_y = 0;
437 } else {
438 if (at->clone.x > head->tail_x) head->tail_x = at->clone.x;
439 if (at->clone.y > head->tail_y) head->tail_y = at->clone.y;
440 } 490 }
491 else
492 {
493 if (at->clone.x > head->tail_x)
494 head->tail_x = at->clone.x;
495 if (at->clone.y > head->tail_y)
496 head->tail_y = at->clone.y;
497 }
441 break; 498 break;
442 499
443 } 500 }
444 501
445 at=get_archetype_struct(); 502 at = new archetype;
446 clear_object(op); 503
447 op->arch=at; 504 at->clone.arch = at;
448 } 505 }
449 free(at); 506
450 free_object(op); 507 delete at;
451} 508}
452 509
453/* 510/*
454 * Reads the archetype file once more, and links all pointers between 511 * Reads the archetype file once more, and links all pointers between
455 * archetypes. 512 * archetypes.
456 */ 513 */
457 514
458void second_arch_pass(FILE *fp) { 515void
516second_arch_pass (object_thawer & thawer)
517{
459 char buf[MAX_BUF],*variable=buf,*argument,*cp; 518 char buf[MAX_BUF], *variable = buf, *argument, *cp;
460 archetype *at=NULL,*other; 519 archetype *at = NULL, *other;
461 520
462 while(fgets(buf,MAX_BUF,fp)!=NULL) { 521 while (fgets (buf, MAX_BUF, thawer) != NULL)
522 {
463 if(*buf=='#') 523 if (*buf == '#')
464 continue; 524 continue;
465 if((argument=strchr(buf,' '))!=NULL) { 525 if ((argument = strchr (buf, ' ')) != NULL)
526 {
466 *argument='\0',argument++; 527 *argument = '\0', argument++;
467 cp = argument + strlen(argument)-1; 528 cp = argument + strlen (argument) - 1;
468 while (isspace(*cp)) { 529 while (isspace (*cp))
530 {
469 *cp='\0'; 531 *cp = '\0';
470 cp--; 532 cp--;
471 } 533 }
472 } 534 }
473 if(!strcmp("Object",variable)) { 535 if (!strcmp ("Object", variable))
536 {
474 if((at=find_archetype(argument))==NULL) 537 if ((at = archetype::find (argument)) == NULL)
475 LOG(llevError,"Warning: failed to find arch %s\n",argument); 538 LOG (llevError, "Warning: failed to find arch %s\n", argument);
539 }
476 } else if(!strcmp("other_arch",variable)) { 540 else if (!strcmp ("other_arch", variable))
541 {
477 if(at!=NULL&&at->clone.other_arch==NULL) { 542 if (at != NULL && at->clone.other_arch == NULL)
543 {
478 if((other=find_archetype(argument))==NULL) 544 if ((other = archetype::find (argument)) == NULL)
479 LOG(llevError,"Warning: failed to find other_arch %s\n",argument); 545 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
480 else if(at!=NULL) 546 else if (at != NULL)
481 at->clone.other_arch=other; 547 at->clone.other_arch = other;
548 }
482 } 549 }
483 } else if(!strcmp("randomitems",variable)) { 550 else if (!strcmp ("randomitems", variable))
551 {
484 if(at!=NULL) { 552 if (at != NULL)
553 {
554 treasurelist *
485 treasurelist *tl=find_treasurelist(argument); 555 tl = find_treasurelist (argument);
556
486 if(tl==NULL) 557 if (tl == NULL)
487 LOG(llevError,"Failed to link treasure to arch (%s): %s\n",at->name, argument); 558 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
488 else 559 else
489 at->clone.randomitems=tl; 560 at->clone.randomitems = tl;
561 }
490 } 562 }
491 }
492 } 563 }
493} 564}
494 565
495#ifdef DEBUG 566#ifdef DEBUG
567void
496void check_generators(void) { 568check_generators (void)
569{
497 archetype *at; 570 archetype *at;
571
498 for(at=first_archetype;at!=NULL;at=at->next) 572 for (at = first_archetype; at != NULL; at = at->next)
499 if(QUERY_FLAG(&at->clone,FLAG_GENERATOR)&&at->clone.other_arch==NULL) 573 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
500 LOG(llevError,"Warning: %s is generator but lacks other_arch.\n", 574 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
501 at->name);
502} 575}
503#endif 576#endif
504 577
505/* 578/*
506 * First initialises the archtype hash-table (init_archetable()). 579 * First initialises the archtype hash-table (init_archetable()).
… …
511 584
512void 585void
513load_archetypes (void) 586load_archetypes (void)
514{ 587{
515 char filename[MAX_BUF]; 588 char filename[MAX_BUF];
516 int comp; 589
517#if TIME_ARCH_LOAD 590#if TIME_ARCH_LOAD
518 struct timeval tv1, tv2; 591 struct timeval
592 tv1,
593 tv2;
519#endif 594#endif
520 595
521 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes); 596 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
522 LOG (llevDebug, "Reading archetypes from %s:\n", filename); 597 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
523 598
524 { 599 {
600 object_thawer
525 object_thawer thawer (filename); 601 thawer (filename);
526 602
527 clear_archetable (); 603 clear_archetable ();
528 LOG (llevDebug, " arch-pass 1...\n"); 604 LOG (llevDebug, " arch-pass 1...\n");
529 first_arch_pass (thawer); 605 first_arch_pass (thawer);
530 LOG (llevDebug, " done\n"); 606 LOG (llevDebug, " done\n");
531
532 init_archetable ();
533 warn_archetypes = 1;
534 } 607 }
535 608
609 init_archetable ();
610 warn_archetypes = 1;
611
536 { 612 {
613 object_thawer
537 object_thawer thawer (filename); 614 thawer (filename);
538 615
539 LOG (llevDebug, " loading treasure...\n"); 616 LOG (llevDebug, " loading treasure...\n");
540 load_treasures (); 617 load_treasures ();
541 LOG (llevDebug, " done\n arch-pass 2...\n"); 618 LOG (llevDebug, " done\n arch-pass 2...\n");
542 second_arch_pass (thawer); 619 second_arch_pass (thawer);
… …
551/* 628/*
552 * Creates and returns a new object which is a copy of the given archetype. 629 * Creates and returns a new object which is a copy of the given archetype.
553 * This function returns NULL on failure. 630 * This function returns NULL on failure.
554 */ 631 */
555 632
633object *
556object *arch_to_object(archetype *at) { 634arch_to_object (archetype *at)
635{
557 object *op; 636 object *op;
637
558 if(at==NULL) { 638 if (at == NULL)
639 {
559 if(warn_archetypes) 640 if (warn_archetypes)
560 LOG(llevError,"Couldn't find archetype.\n"); 641 LOG (llevError, "Couldn't find archetype.\n");
642
561 return NULL; 643 return NULL;
562 } 644 }
645
563 op=get_object(); 646 op = get_object ();
564 copy_object(&at->clone,op); 647 copy_object (&at->clone, op);
648 op->arch = at;
565 op->instantiate (); 649 op->instantiate ();
566 op->arch=at;
567 return op; 650 return op;
568} 651}
569 652
570/* 653/*
571 * Creates an object. This function is called by get_archetype() 654 * Creates an object. This function is called by get_archetype()
572 * if it fails to find the appropriate archetype. 655 * if it fails to find the appropriate archetype.
573 * Thus get_archetype() will be guaranteed to always return 656 * Thus get_archetype() will be guaranteed to always return
574 * an object, and never NULL. 657 * an object, and never NULL.
575 */ 658 */
576 659
660object *
577object *create_singularity(const char *name) { 661create_singularity (const char *name)
662{
578 object *op; 663 object *op;
579 char buf[MAX_BUF]; 664 char buf[MAX_BUF];
665
580 sprintf(buf,"%s (%s)",ARCH_SINGULARITY,name); 666 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
581 op = get_object(); 667 op = get_object ();
582 op->name = add_string(buf); 668 op->name = op->name_pl = buf;
583 op->name_pl = add_string(buf);
584 SET_FLAG(op,FLAG_NO_PICK); 669 SET_FLAG (op, FLAG_NO_PICK);
585 return op; 670 return op;
586} 671}
587 672
588/* 673/*
589 * Finds which archetype matches the given name, and returns a new 674 * Finds which archetype matches the given name, and returns a new
590 * object containing a copy of the archetype. 675 * object containing a copy of the archetype.
591 */ 676 */
592 677
678object *
593object *get_archetype(const char *name) { 679get_archetype (const char *name)
594 archetype *at; 680{
595 at = find_archetype(name); 681 archetype *at = archetype::find (name);
596 if (at == NULL) 682
683 if (!at)
597 return create_singularity(name); 684 return create_singularity (name);
685
598 return arch_to_object(at); 686 return arch_to_object (at);
599} 687}
600 688
601/* 689/*
602 * Hash-function used by the arch-hashtable. 690 * Hash-function used by the arch-hashtable.
603 */ 691 */
604 692
605unsigned long 693unsigned long
606hasharch(const char *str, int tablesize) { 694hasharch (const char *str, int tablesize)
695{
607 unsigned long hash = 0; 696 unsigned long hash = 0;
608 int i = 0; 697 unsigned int i = 0;
609 const char *p; 698 const char *p;
610 699
611 /* use the one-at-a-time hash function, which supposedly is 700 /* use the one-at-a-time hash function, which supposedly is
612 * better than the djb2-like one used by perl5.005, but 701 * better than the djb2-like one used by perl5.005, but
613 * certainly is better then the bug used here before. 702 * certainly is better then the bug used here before.
614 * see http://burtleburtle.net/bob/hash/doobs.html 703 * see http://burtleburtle.net/bob/hash/doobs.html
615 */ 704 */
616 for (p = str; i < MAXSTRING && *p; p++, i++) { 705 for (p = str; i < MAXSTRING && *p; p++, i++)
706 {
617 hash += *p; 707 hash += *p;
618 hash += hash << 10; 708 hash += hash << 10;
619 hash ^= hash >> 6; 709 hash ^= hash >> 6;
620 } 710 }
711
621 hash += hash << 3; 712 hash += hash << 3;
622 hash ^= hash >> 11; 713 hash ^= hash >> 11;
623 hash += hash << 15; 714 hash += hash << 15;
715
624 return hash % tablesize; 716 return hash % tablesize;
625} 717}
626 718
627/* 719/*
628 * Finds, using the hashtable, which archetype matches the given name. 720 * Finds, using the hashtable, which archetype matches the given name.
629 * returns a pointer to the found archetype, otherwise NULL. 721 * returns a pointer to the found archetype, otherwise NULL.
630 */ 722 */
631 723
724archetype *
632archetype *find_archetype(const char *name) { 725archetype::find (const char *name)
726{
727 if (!name)
728 return 0;
729
730#if USE_UNORDERED_MAP
731 AUTODECL (i, ht.find ((size_t) name));
732
733 if (i == ht.end ())
734 return 0;
735 else
736 return i->second;
737#endif
738
633 archetype *at; 739 archetype *at;
634 unsigned long index; 740 unsigned long index;
635 741
636 if (name == NULL)
637 return (archetype *) NULL;
638
639 index=hasharch(name, ARCHTABLE); 742 index = hasharch (name, ARCHTABLE);
640 arch_search++; 743 arch_search++;
641 for(;;) { 744 for (;;)
745 {
642 at = arch_table[index]; 746 at = arch_table[index];
747
643 if (at==NULL) { 748 if (at == NULL)
749 {
644 if(warn_archetypes) 750 if (warn_archetypes)
645 LOG(llevError,"Couldn't find archetype %s\n",name); 751 LOG (llevError, "Couldn't find archetype %s\n", name);
752
646 return NULL; 753 return NULL;
647 } 754 }
755
648 arch_cmp++; 756 arch_cmp++;
757
649 if (!strcmp(at->name,name)) 758 if (!strcmp ((const char *) at->name, name))
650 return at; 759 return at;
760
651 if(++index>=ARCHTABLE) 761 if (++index >= ARCHTABLE)
652 index=0; 762 index = 0;
653 } 763 }
654} 764}
655 765
656/* 766/*
657 * Adds an archetype to the hashtable. 767 * Adds an archetype to the hashtable.
658 */ 768 */
659 769
770static void
660static void add_arch(archetype *at) { 771add_arch (archetype *at)
772{
773#if USE_UNORDERED_MAP
774 ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
775#endif
776
661 int index=hasharch(at->name, ARCHTABLE),org_index=index; 777 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
778
662 for(;;) { 779 for (;;)
780 {
663 if(arch_table[index]==NULL) { 781 if (arch_table[index] == NULL)
782 {
664 arch_table[index]=at; 783 arch_table[index] = at;
665 return; 784 return;
666 } 785 }
786
667 if(++index==ARCHTABLE) 787 if (++index == ARCHTABLE)
668 index=0; 788 index = 0;
789
669 if(index==org_index) 790 if (index == org_index)
670 fatal(ARCHTABLE_TOO_SMALL); 791 fatal (ARCHTABLE_TOO_SMALL);
671 } 792 }
672} 793}
673 794
674/* 795/*
675 * Returns the first archetype using the given type. 796 * Returns the first archetype using the given type.
676 * Used in treasure-generation. 797 * Used in treasure-generation.
677 */ 798 */
678 799
800archetype *
679archetype *type_to_archetype(int type) { 801type_to_archetype (int type)
802{
680 archetype *at; 803 archetype *at;
681 804
682 for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) 805 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
683 if(at->clone.type==type) 806 if (at->clone.type == type)
684 return at; 807 return at;
808
685 return NULL; 809 return 0;
686} 810}
687 811
688/* 812/*
689 * Returns a new object copied from the first archetype matching 813 * Returns a new object copied from the first archetype matching
690 * the given type. 814 * the given type.
691 * Used in treasure-generation. 815 * Used in treasure-generation.
692 */ 816 */
693 817
818object *
694object *clone_arch(int type) { 819clone_arch (int type)
820{
695 archetype *at; 821 archetype *at;
696 object *op=get_object(); 822 object *op = get_object ();
697 823
698 if((at=type_to_archetype(type))==NULL) { 824 if ((at = type_to_archetype (type)) == NULL)
825 {
699 LOG(llevError,"Can't clone archetype %d\n",type); 826 LOG (llevError, "Can't clone archetype %d\n", type);
700 free_object(op); 827 free_object (op);
701 return NULL; 828 return NULL;
702 } 829 }
830
703 copy_object(&at->clone,op); 831 copy_object (&at->clone, op);
704 op->instantiate (); 832 op->instantiate ();
705 return op; 833 return op;
706} 834}
707 835
708/* 836/*
709 * member: make instance from class 837 * member: make instance from class
710 */ 838 */
711 839
840object *
712object *object_create_arch (archetype * at) 841object_create_arch (archetype *at)
713{ 842{
714 object *op, *prev = NULL, *head = NULL; 843 object *op, *prev = 0, *head = 0;
715 844
716 while (at) { 845 while (at)
846 {
717 op = arch_to_object (at); 847 op = arch_to_object (at);
718 op->x = at->clone.x; 848 op->x = at->clone.x;
719 op->y = at->clone.y; 849 op->y = at->clone.y;
850
720 if (head) 851 if (head)
721 op->head = head, prev->more = op; 852 op->head = head, prev->more = op;
853
722 if (!head) 854 if (!head)
723 head = op; 855 head = op;
856
724 prev = op; 857 prev = op;
725 at = at->more; 858 at = at->more;
726 } 859 }
860
727 return (head); 861 return (head);
728} 862}
729 863
730/*** end of arch.c ***/

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines