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.11 by root, Sun Sep 3 22:45:55 2006 UTC vs.
Revision 1.32 by root, Mon Dec 25 11:25:49 2006 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines