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.3 by root, Sat Aug 26 23:36:28 2006 UTC vs.
Revision 1.24 by root, Sat Sep 16 22:24:12 2006 UTC

1/*
2 * static char *rcsid_arch_c =
3 * "$Id: arch.C,v 1.3 2006/08/26 23:36:28 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)) &&
128 (subtype == -1 || subtype == at->clone.subtype))
129 return at;
130 } 151 {
152 if (((type == -1) || (type == at->clone.type)) && (subtype == -1 || subtype == at->clone.subtype))
153 return at;
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
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 190
184 /* 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
185 * a string seperated lists of things to match, with certain keywords. 192 * a string seperated lists of things to match, with certain keywords.
186 * pl is the player (only needed to set count properly) 193 * pl is the player (only needed to set count properly)
187 * op is the item we are trying to match. Calling function takes care 194 * op is the item we are trying to match. Calling function takes care
… …
196 * player object.) 203 * player object.)
197 * If count is 1, make a quick check on the name. 204 * 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. 205 * IF count is >1, we need to make plural name. Return if match.
199 * Last, make a check on the full name. 206 * Last, make a check on the full name.
200 */ 207 */
208int
201int item_matched_string(object *pl, object *op, const char *name) 209item_matched_string (object *pl, object *op, const char *name)
202{ 210{
203 char *cp, local_name[MAX_BUF]; 211 char *cp, local_name[MAX_BUF];
204 int count,retval=0; 212 int count, retval = 0;
213
205 strcpy(local_name, name); /* strtok is destructive to name */ 214 strcpy (local_name, name); /* strtok is destructive to name */
206 215
207 for (cp=strtok(local_name,","); cp; cp=strtok(NULL,",")) { 216 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
208 while (cp[0]==' ') ++cp; /* get rid of spaces */ 217 {
218 while (cp[0] == ' ')
219 ++cp; /* get rid of spaces */
209 220
210 /* LOG(llevDebug,"Trying to match %s\n", cp);*/ 221 /* LOG(llevDebug,"Trying to match %s\n", cp); */
211 /* All is a very generic match - low match value */ 222 /* All is a very generic match - low match value */
212 if (!strcmp(cp,"all")) return 1; 223 if (!strcmp (cp, "all"))
224 return 1;
213 225
214 /* unpaid is a little more specific */ 226 /* unpaid is a little more specific */
215 if (!strcmp(cp,"unpaid") && QUERY_FLAG(op,FLAG_UNPAID)) return 2; 227 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; 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;
219 231
220 if (!strcmp(cp,"unlocked") && !QUERY_FLAG(op, FLAG_INV_LOCKED)) 232 if (!strcmp (cp, "unlocked") && !QUERY_FLAG (op, FLAG_INV_LOCKED))
221 return 2; 233 return 2;
222 234
223 /* Allow for things like '100 arrows' */ 235 /* Allow for things like '100 arrows' */
224 if ((count=atoi(cp))!=0) { 236 if ((count = atoi (cp)) != 0)
237 {
225 cp=strchr(cp, ' '); 238 cp = strchr (cp, ' ');
226 while (cp && cp[0]==' ') ++cp; /* get rid of spaces */ 239 while (cp && cp[0] == ' ')
227 } 240 ++cp; /* get rid of spaces */
228 else { 241 }
242 else
243 {
229 if (pl->type==PLAYER) 244 if (pl->type == PLAYER)
230 count=pl->contr->count; 245 count = pl->contr->count;
231 else 246 else
232 count = 0; 247 count = 0;
233 } 248 }
234 249
235 if (!cp || cp[0]=='\0' || count<0) return 0; 250 if (!cp || cp[0] == '\0' || count < 0)
251 return 0;
236 252
237 253
238 /* The code here should go from highest retval to lowest. That 254 /* 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 255 * 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 256 * 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 257 * later. So keep it in descending order here, so we try for the best
242 * match first, and work downward. 258 * match first, and work downward.
243 */ 259 */
244 if (!strcasecmp(cp,query_name(op))) retval=20; 260 if (!strcasecmp (cp, query_name (op)))
261 retval = 20;
245 else if (!strcasecmp(cp,query_short_name(op))) retval=18; 262 else if (!strcasecmp (cp, query_short_name (op)))
246 else if (!strcasecmp(cp,query_base_name(op,0))) retval=16; 263 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), 264 else if (!strcasecmp (cp, query_base_name (op, 0)))
250 strlen(cp))) retval=14; 265 retval = 16;
251 else if (!strncasecmp(cp,query_base_name(op,1), 266 else if (!strcasecmp (cp, query_base_name (op, 1)))
252 strlen(cp))) retval=14; 267 retval = 16;
253 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;
254 /* Do substring checks, so things like 'Str+1' will match. 274 /* Do substring checks, so things like 'Str+1' will match.
255 * retval of these should perhaps be lower - they are lower 275 * retval of these should perhaps be lower - they are lower
256 * then the specific strcasecmp aboves, but still higher than 276 * then the specific strcasecmp aboves, but still higher than
257 * some other match criteria. 277 * some other match criteria.
258 */ 278 */
259 else if (strstr(query_base_name(op,1), cp)) retval = 12; 279 else if (strstr (query_base_name (op, 1), cp))
280 retval = 12;
260 else if (strstr(query_base_name(op,0), cp)) retval = 12; 281 else if (strstr (query_base_name (op, 0), cp))
282 retval = 12;
261 else if (strstr(query_short_name(op), cp)) retval = 12; 283 else if (strstr (query_short_name (op), cp))
262 284 retval = 12;
263 /* Check against plural/non plural based on count. */ 285 /* Check against plural/non plural based on count. */
264 else if (count>1 && !strcasecmp(cp,op->name_pl)) { 286 else if (count > 1 && !strcasecmp (cp, op->name_pl))
265 retval=6; 287 retval = 6;
266 }
267 else if (count==1 && !strcasecmp(op->name,cp)) { 288 else if (count == 1 && !strcasecmp (op->name, cp))
268 retval=6; 289 retval = 6;
269 }
270 /* base name matched - not bad */ 290 /* base name matched - not bad */
271 else if (strcasecmp(cp,op->name)==0 && !count) retval=4; 291 else if (strcasecmp (cp, op->name) == 0 && !count)
292 retval = 4;
272 /* Check for partial custom name, but give a real low priority */ 293 /* Check for partial custom name, but give a real low priority */
273 else if (op->custom_name && strstr(op->custom_name, cp)) retval = 3; 294 else if (op->custom_name && strstr (op->custom_name, cp))
295 retval = 3;
274 296
275 if (retval) { 297 if (retval)
298 {
276 if (pl->type == PLAYER) 299 if (pl->type == PLAYER)
277 pl->contr->count=count; 300 pl->contr->count = count;
301
278 return retval; 302 return retval;
279 } 303 }
280 } 304 }
305
281 return 0; 306 return 0;
282} 307}
283 308
284/* 309/*
285 * Initialises the internal linked list of archetypes (read from file). 310 * Initialises the internal linked list of archetypes (read from file).
286 * Then the global "empty_archetype" pointer is initialised. 311 * Then the global "empty_archetype" pointer is initialised.
287 * Then the blocksview[] array is initialised. 312 * Then the blocksview[] array is initialised.
288 */ 313 */
289 314
290void init_archetypes(void) { /* called from add_player() and edit() */ 315void
316init_archetypes (void)
317{ /* called from add_player() and edit() */
291 if(first_archetype!=NULL) /* Only do this once */ 318 if (first_archetype != NULL) /* Only do this once */
292 return; 319 return;
320
293 arch_init = 1; 321 arch_init = 1;
294 load_archetypes(); 322 load_archetypes ();
295 arch_init = 0; 323 arch_init = 0;
296 empty_archetype=find_archetype("empty_archetype"); 324 empty_archetype = archetype::find ("empty_archetype");
325
297/* init_blocksview();*/ 326/* init_blocksview();*/
298} 327}
299 328
300/* 329/*
301 * Stores debug-information about how efficient the hashtable 330 * Stores debug-information about how efficient the hashtable
302 * used for archetypes has been in the static errmsg array. 331 * used for archetypes has been in the static errmsg array.
303 */ 332 */
304 333
334void
305void arch_info(object *op) { 335arch_info (object *op)
336{
306 sprintf(errmsg,"%d searches and %d strcmp()'s",arch_search,arch_cmp); 337 sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
307 new_draw_info(NDI_BLACK, 0, op,errmsg); 338 new_draw_info (NDI_BLACK, 0, op, errmsg);
308} 339}
309 340
310/* 341/*
311 * Initialise the hashtable used by the archetypes. 342 * Initialise the hashtable used by the archetypes.
312 */ 343 */
313 344
345void
314void clear_archetable(void) { 346clear_archetable (void)
347{
315 memset((void *) arch_table,0,ARCHTABLE*sizeof(archetype *)); 348 memset ((void *) arch_table, 0, ARCHTABLE * sizeof (archetype *));
316} 349}
317 350
318/* 351/*
319 * An alternative way to init the hashtable which is slower, but _works_... 352 * An alternative way to init the hashtable which is slower, but _works_...
320 */ 353 */
321 354
355void
322void init_archetable(void) { 356init_archetable (void)
357{
323 archetype *at; 358 archetype *at;
359
324 LOG(llevDebug," Setting up archetable...\n"); 360 LOG (llevDebug, " Setting up archetable...\n");
361
325 for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) 362 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
326 add_arch(at); 363 add_arch (at);
364
327 LOG(llevDebug,"done\n"); 365 LOG (llevDebug, "done\n");
328} 366}
329 367
330/* 368/*
331 * Dumps an archetype to debug-level output. 369 * Dumps an archetype to debug-level output.
332 */ 370 */
333 371
372void
334void dump_arch(archetype *at) { 373dump_arch (archetype *at)
374{
335 dump_object(&at->clone); 375 dump_object (&at->clone);
336} 376}
337 377
338/* 378/*
339 * Dumps _all_ archetypes to debug-level output. 379 * Dumps _all_ archetypes to debug-level output.
340 * If you run crossfire with debug, and enter DM-mode, you can trigger 380 * If you run crossfire with debug, and enter DM-mode, you can trigger
341 * this with the O key. 381 * this with the O key.
342 */ 382 */
343 383
384void
344void dump_all_archetypes(void) { 385dump_all_archetypes (void)
386{
345 archetype *at; 387 archetype *at;
388
346 for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) { 389 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
390 {
347 dump_arch(at); 391 dump_arch (at);
348 fprintf(logfile, "%s\n", errmsg); 392 fprintf (logfile, "%s\n", errmsg);
349 } 393 }
350} 394}
351 395
396void
352void free_all_archs(void) 397free_all_archs (void)
353{ 398{
354 archetype *at, *next; 399 archetype *at, *next;
355 int i=0,f=0; 400 int i = 0, f = 0;
356 401
357 for (at=first_archetype; at!=NULL; at=next) { 402 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 } 403 {
404 if (at->more)
405 next = at->more;
406 else
407 next = at->next;
408
409 delete
410 at;
411
412 i++;
413 }
370 LOG(llevDebug,"Freed %d archetypes, %d faces\n", i, f); 414 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
371} 415}
372 416
373/* 417archetype::archetype ()
374 * Allocates, initialises and returns the pointer to an archetype structure. 418{
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 */ 419 clear_object (&clone); /* to initial state other also */
393 CLEAR_FLAG((&arch->clone),FLAG_FREED); /* This shouldn't matter, since copy_object() */ 420 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */
394 SET_FLAG((&arch->clone), FLAG_REMOVED); /* doesn't copy these flags... */ 421 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
395 arch->head=NULL; 422}
396 arch->more=NULL; 423
397 return arch; 424archetype::~archetype ()
425{
398} 426}
399 427
400/* 428/*
401 * Reads/parses the archetype-file, and copies into a linked list 429 * Reads/parses the archetype-file, and copies into a linked list
402 * of archetype-structures. 430 * of archetype-structures.
403 */ 431 */
404void first_arch_pass(FILE *fp) { 432void
405 object *op; 433first_arch_pass (object_thawer & fp)
434{
406 archetype *at,*head=NULL,*last_more=NULL; 435 archetype *at, *head = NULL, *last_more = NULL;
407 int i,first=2;
408 436
409 op=get_object(); 437 at->clone.arch = first_archetype = at = new archetype;
410 op->arch=first_archetype=at=get_archetype_struct();
411 438
412 while((i=load_object(fp,op,first,0))) { 439 while (int i = load_object (fp, &at->clone, 0))
413 first=0; 440 {
414 copy_object(op,&at->clone);
415 at->clone.speed_left= (float) (-0.1); 441 at->clone.speed_left = (float) (-0.1);
416 /* copy the body_info to the body_used - this is only really 442 /* copy the body_info to the body_used - this is only really
417 * need for monsters, but doesn't hurt to do it for everything. 443 * need for monsters, but doesn't hurt to do it for everything.
418 * by doing so, when a monster is created, it has good starting 444 * by doing so, when a monster is created, it has good starting
419 * values for the body_used info, so when items are created 445 * values for the body_used info, so when items are created
420 * for it, they can be properly equipped. 446 * for it, they can be properly equipped.
421 */ 447 */
422 memcpy(&at->clone.body_used, &op->body_info, sizeof(op->body_info)); 448 memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
423 449
424 switch(i) { 450 switch (i)
451 {
425 case LL_NORMAL: /* A new archetype, just link it with the previous */ 452 case LL_NORMAL: /* A new archetype, just link it with the previous */
426 if(last_more!=NULL) 453 if (last_more != NULL)
427 last_more->next=at; 454 last_more->next = at;
428 if(head!=NULL) 455 if (head != NULL)
429 head->next=at; 456 head->next = at;
430 head=last_more=at; 457 head = last_more = at;
431#if 0 458#if 0
432 if(!op->type) 459 if (!op->type)
433 LOG(llevDebug," WARNING: Archetype %s has no type info!\n", op->arch->name); 460 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
434#endif 461#endif
435 at->tail_x = 0; 462 at->tail_x = 0;
436 at->tail_y = 0; 463 at->tail_y = 0;
437 break; 464 break;
438 465
439 case LL_MORE: /* Another part of the previous archetype, link it correctly */ 466 case LL_MORE: /* Another part of the previous archetype, link it correctly */
440 467
441 at->head=head; 468 at->head = head;
442 at->clone.head = &head->clone; 469 at->clone.head = &head->clone;
443 if(last_more!=NULL) { 470 if (last_more != NULL)
444 last_more->more=at; 471 {
472 last_more->more = at;
445 last_more->clone.more = &at->clone; 473 last_more->clone.more = &at->clone;
446 } 474 }
447 last_more=at; 475 last_more = at;
448 476
449 /* If this multipart image is still composed of individual small 477 /* If this multipart image is still composed of individual small
450 * images, don't set the tail_.. values. We can't use them anyways, 478 * images, don't set the tail_.. values. We can't use them anyways,
451 * and setting these to zero makes the map sending to the client much 479 * and setting these to zero makes the map sending to the client much
452 * easier as just looking at the head, we know what to do. 480 * easier as just looking at the head, we know what to do.
453 */ 481 */
454 if (at->clone.face != head->clone.face) { 482 if (at->clone.face != head->clone.face)
455 head->tail_x = 0; 483 {
456 head->tail_y = 0; 484 head->tail_x = 0;
457 } else { 485 head->tail_y = 0;
458 if (at->clone.x > head->tail_x) head->tail_x = at->clone.x; 486 }
459 if (at->clone.y > head->tail_y) head->tail_y = at->clone.y; 487 else
460 } 488 {
461 break; 489 if (at->clone.x > head->tail_x)
490 head->tail_x = at->clone.x;
491 if (at->clone.y > head->tail_y)
492 head->tail_y = at->clone.y;
493 }
494 break;
462 495
463 } 496 }
464 497
465 at=get_archetype_struct(); 498 at = new archetype;
466 clear_object(op); 499
467 op->arch=at; 500 at->clone.arch = at;
468 } 501 }
469 free(at); 502
470 free_object(op); 503 delete at;
471} 504}
472 505
473/* 506/*
474 * Reads the archetype file once more, and links all pointers between 507 * Reads the archetype file once more, and links all pointers between
475 * archetypes. 508 * archetypes.
476 */ 509 */
477 510
478void second_arch_pass(FILE *fp) { 511void
512second_arch_pass (object_thawer & thawer)
513{
479 char buf[MAX_BUF],*variable=buf,*argument,*cp; 514 char buf[MAX_BUF], *variable = buf, *argument, *cp;
480 archetype *at=NULL,*other; 515 archetype *at = NULL, *other;
481 516
482 while(fgets(buf,MAX_BUF,fp)!=NULL) { 517 while (fgets (buf, MAX_BUF, thawer) != NULL)
518 {
483 if(*buf=='#') 519 if (*buf == '#')
484 continue; 520 continue;
485 if((argument=strchr(buf,' '))!=NULL) { 521 if ((argument = strchr (buf, ' ')) != NULL)
522 {
486 *argument='\0',argument++; 523 *argument = '\0', argument++;
487 cp = argument + strlen(argument)-1; 524 cp = argument + strlen (argument) - 1;
488 while (isspace(*cp)) { 525 while (isspace (*cp))
489 *cp='\0'; 526 {
490 cp--; 527 *cp = '\0';
491 } 528 cp--;
492 } 529 }
530 }
493 if(!strcmp("Object",variable)) { 531 if (!strcmp ("Object", variable))
532 {
494 if((at=find_archetype(argument))==NULL) 533 if ((at = archetype::find (argument)) == NULL)
495 LOG(llevError,"Warning: failed to find arch %s\n",argument); 534 LOG (llevError, "Warning: failed to find arch %s\n", argument);
535 }
496 } else if(!strcmp("other_arch",variable)) { 536 else if (!strcmp ("other_arch", variable))
537 {
497 if(at!=NULL&&at->clone.other_arch==NULL) { 538 if (at != NULL && at->clone.other_arch == NULL)
539 {
498 if((other=find_archetype(argument))==NULL) 540 if ((other = archetype::find (argument)) == NULL)
499 LOG(llevError,"Warning: failed to find other_arch %s\n",argument); 541 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
500 else if(at!=NULL) 542 else if (at != NULL)
501 at->clone.other_arch=other; 543 at->clone.other_arch = other;
544 }
502 } 545 }
503 } else if(!strcmp("randomitems",variable)) { 546 else if (!strcmp ("randomitems", variable))
547 {
504 if(at!=NULL) { 548 if (at != NULL)
549 {
505 treasurelist *tl=find_treasurelist(argument); 550 treasurelist *tl = find_treasurelist (argument);
551
506 if(tl==NULL) 552 if (tl == NULL)
507 LOG(llevError,"Failed to link treasure to arch (%s): %s\n",at->name, argument); 553 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
508 else 554 else
509 at->clone.randomitems=tl; 555 at->clone.randomitems = tl;
556 }
510 } 557 }
511 }
512 } 558 }
513} 559}
514 560
515#ifdef DEBUG 561#ifdef DEBUG
562void
516void check_generators(void) { 563check_generators (void)
564{
517 archetype *at; 565 archetype *at;
566
518 for(at=first_archetype;at!=NULL;at=at->next) 567 for (at = first_archetype; at != NULL; at = at->next)
519 if(QUERY_FLAG(&at->clone,FLAG_GENERATOR)&&at->clone.other_arch==NULL) 568 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
520 LOG(llevError,"Warning: %s is generator but lacks other_arch.\n", 569 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
521 at->name);
522} 570}
523#endif 571#endif
524 572
525/* 573/*
526 * First initialises the archtype hash-table (init_archetable()). 574 * First initialises the archtype hash-table (init_archetable()).
527 * Reads and parses the archetype file (with the first and second-pass 575 * Reads and parses the archetype file (with the first and second-pass
528 * functions). 576 * functions).
529 * Then initialises treasures by calling load_treasures(). 577 * Then initialises treasures by calling load_treasures().
530 */ 578 */
531 579
580void
532void load_archetypes(void) { 581load_archetypes (void)
533 FILE *fp; 582{
534 char filename[MAX_BUF]; 583 char filename[MAX_BUF];
535 int comp; 584
536#if TIME_ARCH_LOAD 585#if TIME_ARCH_LOAD
537 struct timeval tv1,tv2; 586 struct timeval
587 tv1,
588 tv2;
538#endif 589#endif
539 590
540 sprintf(filename,"%s/%s",settings.datadir,settings.archetypes); 591 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
541 LOG(llevDebug,"Reading archetypes from %s...\n",filename); 592 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
542 if((fp=open_and_uncompress(filename,0,&comp))==NULL) { 593
543 LOG(llevError," Can't open archetype file.\n"); 594 {
544 return; 595 object_thawer
545 } 596 thawer (filename);
597
546 clear_archetable(); 598 clear_archetable ();
547 LOG(llevDebug," arch-pass 1...\n"); 599 LOG (llevDebug, " arch-pass 1...\n");
548#if TIME_ARCH_LOAD 600 first_arch_pass (thawer);
549 GETTIMEOFDAY(&tv1); 601 LOG (llevDebug, " done\n");
602 }
603
604 init_archetable ();
605 warn_archetypes = 1;
606
607 {
608 object_thawer
609 thawer (filename);
610
611 LOG (llevDebug, " loading treasure...\n");
612 load_treasures ();
613 LOG (llevDebug, " done\n arch-pass 2...\n");
614 second_arch_pass (thawer);
615 LOG (llevDebug, " done\n");
616#ifdef DEBUG
617 check_generators ();
550#endif 618#endif
551 first_arch_pass(fp); 619 }
552#if TIME_ARCH_LOAD
553 { int sec, usec;
554 GETTIMEOFDAY(&tv2);
555 sec = tv2.tv_sec - tv1.tv_sec;
556 usec = tv2.tv_usec - tv1.tv_usec;
557 if (usec<0) { usec +=1000000; sec--;}
558 LOG(llevDebug,"Load took %d.%06d seconds\n", sec, usec);
559 }
560#endif
561
562 LOG(llevDebug," done\n"); 620 LOG (llevDebug, " done\n");
563 init_archetable();
564 warn_archetypes=1;
565
566 /* do a close and reopen instead of a rewind - necessary in case the
567 * file has been compressed.
568 */
569 close_and_delete(fp, comp);
570 fp=open_and_uncompress(filename,0,&comp);
571
572 LOG(llevDebug," loading treasure...\n");
573 load_treasures();
574 LOG(llevDebug," done\n arch-pass 2...\n");
575 second_arch_pass(fp);
576 LOG(llevDebug," done\n");
577#ifdef DEBUG
578 check_generators();
579#endif
580 close_and_delete(fp, comp);
581 LOG(llevDebug," done\n");
582} 621}
583 622
584/* 623/*
585 * Creates and returns a new object which is a copy of the given archetype. 624 * Creates and returns a new object which is a copy of the given archetype.
586 * This function returns NULL on failure. 625 * This function returns NULL on failure.
587 */ 626 */
588 627
628object *
589object *arch_to_object(archetype *at) { 629arch_to_object (archetype *at)
630{
590 object *op; 631 object *op;
632
591 if(at==NULL) { 633 if (at == NULL)
634 {
592 if(warn_archetypes) 635 if (warn_archetypes)
593 LOG(llevError,"Couldn't find archetype.\n"); 636 LOG (llevError, "Couldn't find archetype.\n");
637
594 return NULL; 638 return NULL;
595 } 639 }
640
596 op=get_object(); 641 op = get_object ();
597 copy_object(&at->clone,op); 642 copy_object (&at->clone, op);
643 op->arch = at;
598 op->instantiate (); 644 op->instantiate ();
599 op->arch=at;
600 return op; 645 return op;
601} 646}
602 647
603/* 648/*
604 * Creates an object. This function is called by get_archetype() 649 * Creates an object. This function is called by get_archetype()
605 * if it fails to find the appropriate archetype. 650 * if it fails to find the appropriate archetype.
606 * Thus get_archetype() will be guaranteed to always return 651 * Thus get_archetype() will be guaranteed to always return
607 * an object, and never NULL. 652 * an object, and never NULL.
608 */ 653 */
609 654
655object *
610object *create_singularity(const char *name) { 656create_singularity (const char *name)
657{
611 object *op; 658 object *op;
612 char buf[MAX_BUF]; 659 char buf[MAX_BUF];
660
613 sprintf(buf,"%s (%s)",ARCH_SINGULARITY,name); 661 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
614 op = get_object(); 662 op = get_object ();
615 op->name = add_string(buf); 663 op->name = op->name_pl = buf;
616 op->name_pl = add_string(buf);
617 SET_FLAG(op,FLAG_NO_PICK); 664 SET_FLAG (op, FLAG_NO_PICK);
618 return op; 665 return op;
619} 666}
620 667
621/* 668/*
622 * Finds which archetype matches the given name, and returns a new 669 * Finds which archetype matches the given name, and returns a new
623 * object containing a copy of the archetype. 670 * object containing a copy of the archetype.
624 */ 671 */
625 672
673object *
626object *get_archetype(const char *name) { 674get_archetype (const char *name)
627 archetype *at; 675{
628 at = find_archetype(name); 676 archetype *at = archetype::find (name);
629 if (at == NULL) 677
678 if (!at)
630 return create_singularity(name); 679 return create_singularity (name);
680
631 return arch_to_object(at); 681 return arch_to_object (at);
632} 682}
633 683
634/* 684/*
635 * Hash-function used by the arch-hashtable. 685 * Hash-function used by the arch-hashtable.
636 */ 686 */
637 687
638unsigned long 688unsigned long
639hasharch(const char *str, int tablesize) { 689hasharch (const char *str, int tablesize)
690{
640 unsigned long hash = 0; 691 unsigned long hash = 0;
641 int i = 0; 692 unsigned int i = 0;
642 const char *p; 693 const char *p;
643 694
644 /* use the one-at-a-time hash function, which supposedly is 695 /* use the one-at-a-time hash function, which supposedly is
645 * better than the djb2-like one used by perl5.005, but 696 * better than the djb2-like one used by perl5.005, but
646 * certainly is better then the bug used here before. 697 * certainly is better then the bug used here before.
647 * see http://burtleburtle.net/bob/hash/doobs.html 698 * see http://burtleburtle.net/bob/hash/doobs.html
648 */ 699 */
649 for (p = str; i < MAXSTRING && *p; p++, i++) { 700 for (p = str; i < MAXSTRING && *p; p++, i++)
701 {
650 hash += *p; 702 hash += *p;
651 hash += hash << 10; 703 hash += hash << 10;
652 hash ^= hash >> 6; 704 hash ^= hash >> 6;
653 } 705 }
706
654 hash += hash << 3; 707 hash += hash << 3;
655 hash ^= hash >> 11; 708 hash ^= hash >> 11;
656 hash += hash << 15; 709 hash += hash << 15;
710
657 return hash % tablesize; 711 return hash % tablesize;
658} 712}
659 713
660/* 714/*
661 * Finds, using the hashtable, which archetype matches the given name. 715 * Finds, using the hashtable, which archetype matches the given name.
662 * returns a pointer to the found archetype, otherwise NULL. 716 * returns a pointer to the found archetype, otherwise NULL.
663 */ 717 */
664 718
719archetype *
665archetype *find_archetype(const char *name) { 720archetype::find (const char *name)
721{
722 if (!name)
723 return 0;
724
725#if USE_UNORDERED_MAP
726 AUTODECL (i, ht.find ((size_t) name));
727
728 if (i == ht.end ())
729 return 0;
730 else
731 return i->second;
732#endif
733
666 archetype *at; 734 archetype *at;
667 unsigned long index; 735 unsigned long index;
668 736
669 if (name == NULL)
670 return (archetype *) NULL;
671
672 index=hasharch(name, ARCHTABLE); 737 index = hasharch (name, ARCHTABLE);
673 arch_search++; 738 arch_search++;
674 for(;;) { 739 for (;;)
740 {
675 at = arch_table[index]; 741 at = arch_table[index];
742
676 if (at==NULL) { 743 if (at == NULL)
744 {
677 if(warn_archetypes) 745 if (warn_archetypes)
678 LOG(llevError,"Couldn't find archetype %s\n",name); 746 LOG (llevError, "Couldn't find archetype %s\n", name);
747
679 return NULL; 748 return NULL;
680 } 749 }
750
681 arch_cmp++; 751 arch_cmp++;
752
682 if (!strcmp(at->name,name)) 753 if (!strcmp ((const char *) at->name, name))
683 return at; 754 return at;
755
684 if(++index>=ARCHTABLE) 756 if (++index >= ARCHTABLE)
685 index=0; 757 index = 0;
686 } 758 }
687} 759}
688 760
689/* 761/*
690 * Adds an archetype to the hashtable. 762 * Adds an archetype to the hashtable.
691 */ 763 */
692 764
765static void
693static void add_arch(archetype *at) { 766add_arch (archetype *at)
767{
768#if USE_UNORDERED_MAP
769 ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
770#endif
771
694 int index=hasharch(at->name, ARCHTABLE),org_index=index; 772 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
773
695 for(;;) { 774 for (;;)
775 {
696 if(arch_table[index]==NULL) { 776 if (arch_table[index] == NULL)
777 {
697 arch_table[index]=at; 778 arch_table[index] = at;
698 return; 779 return;
699 } 780 }
781
700 if(++index==ARCHTABLE) 782 if (++index == ARCHTABLE)
701 index=0; 783 index = 0;
784
702 if(index==org_index) 785 if (index == org_index)
703 fatal(ARCHTABLE_TOO_SMALL); 786 fatal (ARCHTABLE_TOO_SMALL);
704 } 787 }
705} 788}
706 789
707/* 790/*
708 * Returns the first archetype using the given type. 791 * Returns the first archetype using the given type.
709 * Used in treasure-generation. 792 * Used in treasure-generation.
710 */ 793 */
711 794
795archetype *
712archetype *type_to_archetype(int type) { 796type_to_archetype (int type)
797{
713 archetype *at; 798 archetype *at;
714 799
715 for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) 800 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
716 if(at->clone.type==type) 801 if (at->clone.type == type)
717 return at; 802 return at;
803
718 return NULL; 804 return 0;
719} 805}
720 806
721/* 807/*
722 * Returns a new object copied from the first archetype matching 808 * Returns a new object copied from the first archetype matching
723 * the given type. 809 * the given type.
724 * Used in treasure-generation. 810 * Used in treasure-generation.
725 */ 811 */
726 812
813object *
727object *clone_arch(int type) { 814clone_arch (int type)
815{
728 archetype *at; 816 archetype *at;
729 object *op=get_object(); 817 object *op = get_object ();
730 818
731 if((at=type_to_archetype(type))==NULL) { 819 if ((at = type_to_archetype (type)) == NULL)
820 {
732 LOG(llevError,"Can't clone archetype %d\n",type); 821 LOG (llevError, "Can't clone archetype %d\n", type);
733 free_object(op); 822 free_object (op);
734 return NULL; 823 return NULL;
735 } 824 }
825
736 copy_object(&at->clone,op); 826 copy_object (&at->clone, op);
737 op->instantiate (); 827 op->instantiate ();
738 return op; 828 return op;
739} 829}
740 830
741/* 831/*
742 * member: make instance from class 832 * member: make instance from class
743 */ 833 */
744 834
835object *
745object *object_create_arch (archetype * at) 836object_create_arch (archetype *at)
746{ 837{
747 object *op, *prev = NULL, *head = NULL; 838 object *op, *prev = 0, *head = 0;
748 839
749 while (at) { 840 while (at)
841 {
750 op = arch_to_object (at); 842 op = arch_to_object (at);
751 op->x = at->clone.x; 843 op->x = at->clone.x;
752 op->y = at->clone.y; 844 op->y = at->clone.y;
845
753 if (head) 846 if (head)
754 op->head = head, prev->more = op; 847 op->head = head, prev->more = op;
848
755 if (!head) 849 if (!head)
756 head = op; 850 head = op;
851
757 prev = op; 852 prev = op;
758 at = at->more; 853 at = at->more;
759 } 854 }
855
760 return (head); 856 return (head);
761} 857}
762 858
763/*** end of arch.c ***/

Diff Legend

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