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.7 by root, Tue Aug 29 08:01:35 2006 UTC vs.
Revision 1.21 by root, Thu Sep 14 22:33:58 2006 UTC

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

Diff Legend

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