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.4 by root, Sun Aug 27 16:15:11 2006 UTC vs.
Revision 1.36 by pippijn, Sat Jan 6 14:42:28 2007 UTC

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

Diff Legend

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