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.26 by root, Fri Nov 17 19:40:53 2006 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
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*/
28 23
24#include <cassert>
25
29#include <global.h> 26#include <global.h>
30#include <arch.h>
31#include <funcpoint.h> 27#include <funcpoint.h>
32#include <loader.h> 28#include <loader.h>
33 29
34#include <cassert> 30#define USE_UNORDERED_MAP 0
35 31
36/* IF set, does a little timing on the archetype load. */ 32#if USE_UNORDERED_MAP
37#define TIME_ARCH_LOAD 0 33# include <tr1/functional>
34# include <tr1/unordered_map>
35#endif
38 36
39static void add_arch(archetype *at);
40
41static archetype *arch_table[ARCHTABLE];
42int arch_cmp=0; /* How many strcmp's */ 37int arch_cmp = 0; /* How many strcmp's */
43int arch_search=0; /* How many searches */ 38int arch_search = 0; /* How many searches */
44int arch_init; /* True if doing arch initialization */ 39int arch_init; /* True if doing arch initialization */
45 40
46/* The naming of these functions is really poor - they are all 41/* The naming of these functions is really poor - they are all
47 * pretty much named '.._arch_...', but they may more may not 42 * pretty much named '.._arch_...', but they may more may not
48 * return archetypes. Some make the arch_to_object call, and thus 43 * return archetypes. Some make the arch_to_object call, and thus
49 * return an object. Perhaps those should be called 'archob' functions 44 * return an object. Perhaps those should be called 'archob' functions
50 * to denote they return an object derived from the archetype. 45 * to denote they return an object derived from the archetype.
51 * MSW 2003-04-29 46 * MSW 2003-04-29
52 */ 47 */
48
49#if USE_UNORDERED_MAP
50// the hashtable
51typedef std::tr1::unordered_map
52 <
53 std::size_t,
54 arch_ptr,
55 std::tr1::hash<size_t>,
56 std::equal_to<size_t>,
57 slice_allocator< std::pair<const std::size_t, archetype *> >
58 true,
59 > HT;
60
61static HT ht;
62#else
63static arch_ptr arch_table[ARCHTABLE];
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 at->hash_add ();
364
327 LOG(llevDebug,"done\n"); 365 LOG (llevDebug, "done\n");
328} 366}
329 367
330/* 368void
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) 369free_all_archs (void)
353{ 370{
354 archetype *at, *next; 371 archetype *at, *next;
355 int i=0,f=0; 372 int i = 0, f = 0;
356 373
357 for (at=first_archetype; at!=NULL; at=next) { 374 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 } 375 {
376 if (at->more)
377 next = at->more;
378 else
379 next = at->next;
380
381 delete
382 at;
383
384 i++;
385 }
386
370 LOG(llevDebug,"Freed %d archetypes, %d faces\n", i, f); 387 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
371} 388}
372 389
373/* 390archetype::archetype ()
374 * Allocates, initialises and returns the pointer to an archetype structure. 391{
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 */ 392 clear_object (&clone); /* to initial state other also */
393 CLEAR_FLAG((&arch->clone),FLAG_FREED); /* This shouldn't matter, since copy_object() */ 393 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */
394 SET_FLAG((&arch->clone), FLAG_REMOVED); /* doesn't copy these flags... */ 394 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
395 arch->head=NULL; 395}
396 arch->more=NULL; 396
397 return arch; 397archetype::~archetype ()
398{
398} 399}
399 400
400/* 401/*
401 * Reads/parses the archetype-file, and copies into a linked list 402 * Reads/parses the archetype-file, and copies into a linked list
402 * of archetype-structures. 403 * of archetype-structures.
403 */ 404 */
404void first_arch_pass(FILE *fp) { 405void
405 object *op; 406first_arch_pass (object_thawer & fp)
407{
406 archetype *at,*head=NULL,*last_more=NULL; 408 archetype *at, *head = NULL, *last_more = NULL;
407 int i,first=2;
408 409
409 object_thawer thawer; 410 at->clone.arch = first_archetype = at = new archetype;
410 411
411 op=get_object(); 412 while (int i = load_object (fp, &at->clone, 0))
412 op->arch=first_archetype=at=get_archetype_struct(); 413 {
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); 414 at->clone.speed_left = (float) (-0.1);
418 /* copy the body_info to the body_used - this is only really 415 /* 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. 416 * 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 417 * by doing so, when a monster is created, it has good starting
421 * values for the body_used info, so when items are created 418 * values for the body_used info, so when items are created
422 * for it, they can be properly equipped. 419 * for it, they can be properly equipped.
423 */ 420 */
424 memcpy(&at->clone.body_used, &op->body_info, sizeof(op->body_info)); 421 memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
425 422
426 switch(i) { 423 switch (i)
424 {
427 case LL_NORMAL: /* A new archetype, just link it with the previous */ 425 case LL_NORMAL: /* A new archetype, just link it with the previous */
428 if(last_more!=NULL) 426 if (last_more != NULL)
429 last_more->next=at; 427 last_more->next = at;
430 if(head!=NULL) 428 if (head != NULL)
431 head->next=at; 429 head->next = at;
432 head=last_more=at; 430 head = last_more = at;
433#if 0 431#if 0
434 if(!op->type) 432 if (!op->type)
435 LOG(llevDebug," WARNING: Archetype %s has no type info!\n", op->arch->name); 433 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
436#endif 434#endif
437 at->tail_x = 0; 435 at->tail_x = 0;
438 at->tail_y = 0; 436 at->tail_y = 0;
439 break; 437 break;
440 438
441 case LL_MORE: /* Another part of the previous archetype, link it correctly */ 439 case LL_MORE: /* Another part of the previous archetype, link it correctly */
442 440
443 at->head=head; 441 at->head = head;
444 at->clone.head = &head->clone; 442 at->clone.head = &head->clone;
445 if(last_more!=NULL) { 443 if (last_more != NULL)
446 last_more->more=at; 444 {
445 last_more->more = at;
447 last_more->clone.more = &at->clone; 446 last_more->clone.more = &at->clone;
448 } 447 }
449 last_more=at; 448 last_more = at;
450 449
451 /* If this multipart image is still composed of individual small 450 /* If this multipart image is still composed of individual small
452 * images, don't set the tail_.. values. We can't use them anyways, 451 * 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 452 * 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. 453 * easier as just looking at the head, we know what to do.
455 */ 454 */
456 if (at->clone.face != head->clone.face) { 455 if (at->clone.face != head->clone.face)
457 head->tail_x = 0; 456 {
458 head->tail_y = 0; 457 head->tail_x = 0;
459 } else { 458 head->tail_y = 0;
460 if (at->clone.x > head->tail_x) head->tail_x = at->clone.x; 459 }
461 if (at->clone.y > head->tail_y) head->tail_y = at->clone.y; 460 else
462 } 461 {
463 break; 462 if (at->clone.x > head->tail_x)
463 head->tail_x = at->clone.x;
464 if (at->clone.y > head->tail_y)
465 head->tail_y = at->clone.y;
466 }
467 break;
464 468
465 } 469 }
466 470
467 at=get_archetype_struct(); 471 at = new archetype;
468 clear_object(op); 472
469 op->arch=at; 473 at->clone.arch = at;
470 } 474 }
471 free(at); 475
472 free_object(op); 476 delete at;
473} 477}
474 478
475/* 479/*
476 * Reads the archetype file once more, and links all pointers between 480 * Reads the archetype file once more, and links all pointers between
477 * archetypes. 481 * archetypes.
478 */ 482 */
479 483
480void second_arch_pass(FILE *fp) { 484void
485second_arch_pass (object_thawer & thawer)
486{
481 char buf[MAX_BUF],*variable=buf,*argument,*cp; 487 char buf[MAX_BUF], *variable = buf, *argument, *cp;
482 archetype *at=NULL,*other; 488 archetype *at = NULL, *other;
483 489
484 while(fgets(buf,MAX_BUF,fp)!=NULL) { 490 while (fgets (buf, MAX_BUF, thawer) != NULL)
491 {
485 if(*buf=='#') 492 if (*buf == '#')
486 continue; 493 continue;
487 if((argument=strchr(buf,' '))!=NULL) { 494 if ((argument = strchr (buf, ' ')) != NULL)
495 {
488 *argument='\0',argument++; 496 *argument = '\0', argument++;
489 cp = argument + strlen(argument)-1; 497 cp = argument + strlen (argument) - 1;
490 while (isspace(*cp)) { 498 while (isspace (*cp))
491 *cp='\0'; 499 {
492 cp--; 500 *cp = '\0';
493 } 501 cp--;
494 } 502 }
503 }
495 if(!strcmp("Object",variable)) { 504 if (!strcmp ("Object", variable))
505 {
496 if((at=find_archetype(argument))==NULL) 506 if ((at = archetype::find (argument)) == NULL)
497 LOG(llevError,"Warning: failed to find arch %s\n",argument); 507 LOG (llevError, "Warning: failed to find arch %s\n", argument);
508 }
498 } else if(!strcmp("other_arch",variable)) { 509 else if (!strcmp ("other_arch", variable))
510 {
499 if(at!=NULL&&at->clone.other_arch==NULL) { 511 if (at != NULL && at->clone.other_arch == NULL)
512 {
500 if((other=find_archetype(argument))==NULL) 513 if ((other = archetype::find (argument)) == NULL)
501 LOG(llevError,"Warning: failed to find other_arch %s\n",argument); 514 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
502 else if(at!=NULL) 515 else if (at != NULL)
503 at->clone.other_arch=other; 516 at->clone.other_arch = other;
517 }
504 } 518 }
505 } else if(!strcmp("randomitems",variable)) { 519 else if (!strcmp ("randomitems", variable))
520 {
506 if(at!=NULL) { 521 if (at != NULL)
522 {
507 treasurelist *tl=find_treasurelist(argument); 523 treasurelist *tl = find_treasurelist (argument);
524
508 if(tl==NULL) 525 if (tl == NULL)
509 LOG(llevError,"Failed to link treasure to arch (%s): %s\n",at->name, argument); 526 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
510 else 527 else
511 at->clone.randomitems=tl; 528 at->clone.randomitems = tl;
529 }
512 } 530 }
513 }
514 } 531 }
515} 532}
516 533
517#ifdef DEBUG 534#ifdef DEBUG
535void
518void check_generators(void) { 536check_generators (void)
537{
519 archetype *at; 538 archetype *at;
539
520 for(at=first_archetype;at!=NULL;at=at->next) 540 for (at = first_archetype; at != NULL; at = at->next)
521 if(QUERY_FLAG(&at->clone,FLAG_GENERATOR)&&at->clone.other_arch==NULL) 541 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
522 LOG(llevError,"Warning: %s is generator but lacks other_arch.\n", 542 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
523 at->name);
524} 543}
525#endif 544#endif
526 545
527/* 546/*
528 * First initialises the archtype hash-table (init_archetable()). 547 * First initialises the archtype hash-table (init_archetable()).
529 * Reads and parses the archetype file (with the first and second-pass 548 * Reads and parses the archetype file (with the first and second-pass
530 * functions). 549 * functions).
531 * Then initialises treasures by calling load_treasures(). 550 * Then initialises treasures by calling load_treasures().
532 */ 551 */
533 552
553void
534void load_archetypes(void) { 554load_archetypes (void)
535 FILE *fp; 555{
536 char filename[MAX_BUF]; 556 char filename[MAX_BUF];
537 int comp; 557
538#if TIME_ARCH_LOAD 558 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
539 struct timeval tv1,tv2; 559 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
560
561 {
562 object_thawer
563 thawer (filename);
564
565 clear_archetable ();
566 LOG (llevDebug, " arch-pass 1...\n");
567 first_arch_pass (thawer);
568 LOG (llevDebug, " done\n");
569 }
570
571 init_archetable ();
572 warn_archetypes = 1;
573
574 {
575 object_thawer
576 thawer (filename);
577
578 LOG (llevDebug, " loading treasure...\n");
579 load_treasures ();
580 LOG (llevDebug, " done\n arch-pass 2...\n");
581 second_arch_pass (thawer);
582 LOG (llevDebug, " done\n");
583#ifdef DEBUG
584 check_generators ();
540#endif 585#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 } 586 }
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"); 587 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} 588}
585 589
586/* 590/*
587 * Creates and returns a new object which is a copy of the given archetype. 591 * Creates and returns a new object which is a copy of the given archetype.
588 * This function returns NULL on failure. 592 * This function returns NULL on failure.
589 */ 593 */
590 594
595object *
591object *arch_to_object(archetype *at) { 596arch_to_object (archetype *at)
597{
592 object *op; 598 object *op;
599
593 if(at==NULL) { 600 if (at == NULL)
601 {
594 if(warn_archetypes) 602 if (warn_archetypes)
595 LOG(llevError,"Couldn't find archetype.\n"); 603 LOG (llevError, "Couldn't find archetype.\n");
604
596 return NULL; 605 return NULL;
597 } 606 }
607
598 op=get_object(); 608 op = get_object ();
599 copy_object(&at->clone,op); 609 copy_object (&at->clone, op);
610 op->arch = at;
600 op->instantiate (); 611 op->instantiate ();
601 op->arch=at;
602 return op; 612 return op;
603} 613}
604 614
605/* 615/*
606 * Creates an object. This function is called by get_archetype() 616 * Creates an object. This function is called by get_archetype()
607 * if it fails to find the appropriate archetype. 617 * if it fails to find the appropriate archetype.
608 * Thus get_archetype() will be guaranteed to always return 618 * Thus get_archetype() will be guaranteed to always return
609 * an object, and never NULL. 619 * an object, and never NULL.
610 */ 620 */
611 621
622object *
612object *create_singularity(const char *name) { 623create_singularity (const char *name)
624{
613 object *op; 625 object *op;
614 char buf[MAX_BUF]; 626 char buf[MAX_BUF];
627
615 sprintf(buf,"%s (%s)",ARCH_SINGULARITY,name); 628 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
616 op = get_object(); 629 op = get_object ();
617 op->name = add_string(buf); 630 op->name = op->name_pl = buf;
618 op->name_pl = add_string(buf);
619 SET_FLAG(op,FLAG_NO_PICK); 631 SET_FLAG (op, FLAG_NO_PICK);
620 return op; 632 return op;
621} 633}
622 634
623/* 635/*
624 * Finds which archetype matches the given name, and returns a new 636 * Finds which archetype matches the given name, and returns a new
625 * object containing a copy of the archetype. 637 * object containing a copy of the archetype.
626 */ 638 */
627 639
640object *
628object *get_archetype(const char *name) { 641get_archetype (const char *name)
629 archetype *at; 642{
630 at = find_archetype(name); 643 archetype *at = archetype::find (name);
631 if (at == NULL) 644
645 if (!at)
632 return create_singularity(name); 646 return create_singularity (name);
647
633 return arch_to_object(at); 648 return arch_to_object (at);
634} 649}
635 650
636/* 651/*
637 * Hash-function used by the arch-hashtable. 652 * Hash-function used by the arch-hashtable.
638 */ 653 */
639 654
640unsigned long 655unsigned long
641hasharch(const char *str, int tablesize) { 656hasharch (const char *str, int tablesize)
657{
642 unsigned long hash = 0; 658 unsigned long hash = 0;
643 int i = 0; 659 unsigned int i = 0;
644 const char *p; 660 const char *p;
645 661
646 /* use the one-at-a-time hash function, which supposedly is 662 /* use the one-at-a-time hash function, which supposedly is
647 * better than the djb2-like one used by perl5.005, but 663 * better than the djb2-like one used by perl5.005, but
648 * certainly is better then the bug used here before. 664 * certainly is better then the bug used here before.
649 * see http://burtleburtle.net/bob/hash/doobs.html 665 * see http://burtleburtle.net/bob/hash/doobs.html
650 */ 666 */
651 for (p = str; i < MAXSTRING && *p; p++, i++) { 667 for (p = str; i < MAXSTRING && *p; p++, i++)
668 {
652 hash += *p; 669 hash += *p;
653 hash += hash << 10; 670 hash += hash << 10;
654 hash ^= hash >> 6; 671 hash ^= hash >> 6;
655 } 672 }
673
656 hash += hash << 3; 674 hash += hash << 3;
657 hash ^= hash >> 11; 675 hash ^= hash >> 11;
658 hash += hash << 15; 676 hash += hash << 15;
677
659 return hash % tablesize; 678 return hash % tablesize;
660} 679}
661 680
662/* 681/*
663 * Finds, using the hashtable, which archetype matches the given name. 682 * Finds, using the hashtable, which archetype matches the given name.
664 * returns a pointer to the found archetype, otherwise NULL. 683 * returns a pointer to the found archetype, otherwise NULL.
665 */ 684 */
666 685
686archetype *
667archetype *find_archetype(const char *name) { 687archetype::find (const char *name)
688{
689 if (!name)
690 return 0;
691
692#if USE_UNORDERED_MAP
693 AUTODECL (i, ht.find ((size_t) name));
694
695 if (i == ht.end ())
696 return 0;
697 else
698 return i->second;
699#endif
700
668 archetype *at; 701 archetype *at;
669 unsigned long index; 702 unsigned long index;
670 703
671 if (name == NULL)
672 return (archetype *) NULL;
673
674 index=hasharch(name, ARCHTABLE); 704 index = hasharch (name, ARCHTABLE);
675 arch_search++; 705 arch_search++;
676 for(;;) { 706 for (;;)
707 {
677 at = arch_table[index]; 708 at = arch_table[index];
709
678 if (at==NULL) { 710 if (at == NULL)
711 {
679 if(warn_archetypes) 712 if (warn_archetypes)
680 LOG(llevError,"Couldn't find archetype %s\n",name); 713 LOG (llevError, "Couldn't find archetype %s\n", name);
714
681 return NULL; 715 return NULL;
682 } 716 }
717
683 arch_cmp++; 718 arch_cmp++;
719
684 if (!strcmp(at->name,name)) 720 if (!strcmp ((const char *) at->name, name))
685 return at; 721 return at;
722
686 if(++index>=ARCHTABLE) 723 if (++index >= ARCHTABLE)
687 index=0; 724 index = 0;
688 } 725 }
689} 726}
690 727
691/* 728/*
692 * Adds an archetype to the hashtable. 729 * Adds an archetype to the hashtable.
693 */ 730 */
731void
732archetype::hash_add ()
733{
734#if USE_UNORDERED_MAP
735 ht.insert (std::make_pair ((size_t) (const char *) name, this));
736#else
694 737
695static void add_arch(archetype *at) {
696 int index=hasharch(at->name, ARCHTABLE),org_index=index; 738 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
739
697 for(;;) { 740 for (;;)
741 {
698 if(arch_table[index]==NULL) { 742 if (!arch_table[index])
743 {
699 arch_table[index]=at; 744 arch_table[index] = this;
700 return; 745 break;
701 } 746 }
747
702 if(++index==ARCHTABLE) 748 if (++index == ARCHTABLE)
703 index=0; 749 index = 0;
750
704 if(index==org_index) 751 if (index == org_index)
705 fatal(ARCHTABLE_TOO_SMALL); 752 fatal (ARCHTABLE_TOO_SMALL);
706 } 753 }
754#endif
755}
756
757void
758archetype::hash_del ()
759{
760#if USE_UNORDERED_MAP
761# error remove this from HT
762#else
763
764 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
765
766 for (;;)
767 {
768 if (arch_table[index] == this)
769 {
770 arch_table[index] = 0;
771 break;
772 }
773
774 if (++index == ARCHTABLE)
775 index = 0;
776
777 if (index == org_index)
778 break;
779 }
780#endif
707} 781}
708 782
709/* 783/*
710 * Returns the first archetype using the given type. 784 * Returns the first archetype using the given type.
711 * Used in treasure-generation. 785 * Used in treasure-generation.
712 */ 786 */
713 787
788archetype *
714archetype *type_to_archetype(int type) { 789type_to_archetype (int type)
790{
715 archetype *at; 791 archetype *at;
716 792
717 for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) 793 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
718 if(at->clone.type==type) 794 if (at->clone.type == type)
719 return at; 795 return at;
796
720 return NULL; 797 return 0;
721} 798}
722 799
723/* 800/*
724 * Returns a new object copied from the first archetype matching 801 * Returns a new object copied from the first archetype matching
725 * the given type. 802 * the given type.
726 * Used in treasure-generation. 803 * Used in treasure-generation.
727 */ 804 */
728 805
806object *
729object *clone_arch(int type) { 807clone_arch (int type)
808{
730 archetype *at; 809 archetype *at;
731 object *op=get_object(); 810 object *op = get_object ();
732 811
733 if((at=type_to_archetype(type))==NULL) { 812 if ((at = type_to_archetype (type)) == NULL)
813 {
734 LOG(llevError,"Can't clone archetype %d\n",type); 814 LOG (llevError, "Can't clone archetype %d\n", type);
735 free_object(op); 815 free_object (op);
736 return NULL; 816 return NULL;
737 } 817 }
818
738 copy_object(&at->clone,op); 819 copy_object (&at->clone, op);
739 op->instantiate (); 820 op->instantiate ();
740 return op; 821 return op;
741} 822}
742 823
743/* 824/*
744 * member: make instance from class 825 * member: make instance from class
745 */ 826 */
746 827
828object *
747object *object_create_arch (archetype * at) 829object_create_arch (archetype *at)
748{ 830{
749 object *op, *prev = NULL, *head = NULL; 831 object *op, *prev = 0, *head = 0;
750 832
751 while (at) { 833 while (at)
834 {
752 op = arch_to_object (at); 835 op = arch_to_object (at);
753 op->x = at->clone.x; 836 op->x = at->clone.x;
754 op->y = at->clone.y; 837 op->y = at->clone.y;
838
755 if (head) 839 if (head)
756 op->head = head, prev->more = op; 840 op->head = head, prev->more = op;
841
757 if (!head) 842 if (!head)
758 head = op; 843 head = op;
844
759 prev = op; 845 prev = op;
760 at = at->more; 846 at = at->more;
761 } 847 }
848
762 return (head); 849 return (head);
763} 850}
764 851
765/*** end of arch.c ***/

Diff Legend

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