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

Diff Legend

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