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.10 by root, Sun Sep 3 00:18:39 2006 UTC vs.
Revision 1.23 by root, Thu Sep 14 23:13:48 2006 UTC

1/*
2 * static char *rcsid_arch_c =
3 * "$Id: arch.C,v 1.10 2006/09/03 00:18:39 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{
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 add_arch (at);
364
307 LOG(llevDebug,"done\n"); 365 LOG (llevDebug, "done\n");
308} 366}
309 367
310/* 368/*
311 * Dumps an archetype to debug-level output. 369 * Dumps an archetype to debug-level output.
312 */ 370 */
313 371
372void
314void dump_arch(archetype *at) { 373dump_arch (archetype *at)
374{
315 dump_object(&at->clone); 375 dump_object (&at->clone);
316} 376}
317 377
318/* 378/*
319 * Dumps _all_ archetypes to debug-level output. 379 * Dumps _all_ archetypes to debug-level output.
320 * If you run crossfire with debug, and enter DM-mode, you can trigger 380 * If you run crossfire with debug, and enter DM-mode, you can trigger
321 * this with the O key. 381 * this with the O key.
322 */ 382 */
323 383
384void
324void dump_all_archetypes(void) { 385dump_all_archetypes (void)
386{
325 archetype *at; 387 archetype *at;
388
326 for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) { 389 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
390 {
327 dump_arch(at); 391 dump_arch (at);
328 fprintf(logfile, "%s\n", errmsg); 392 fprintf (logfile, "%s\n", errmsg);
329 } 393 }
330} 394}
331 395
396void
332void free_all_archs(void) 397free_all_archs (void)
333{ 398{
334 archetype *at, *next; 399 archetype *at, *next;
335 int i=0,f=0; 400 int i = 0, f = 0;
336 401
337 for (at=first_archetype; at!=NULL; at=next) { 402 for (at = first_archetype; at != NULL; at = next)
338 if (at->more) next=at->more; 403 {
404 if (at->more)
405 next = at->more;
406 else
339 else next=at->next; 407 next = at->next;
340 408
341 delete at; 409 delete
410 at;
411
342 i++; 412 i++;
343 } 413 }
344 LOG(llevDebug,"Freed %d archetypes, %d faces\n", i, f); 414 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
345} 415}
346 416
347/* 417archetype::archetype ()
348 * Allocates, initialises and returns the pointer to an archetype structure. 418{
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 */ 419 clear_object (&clone); /* to initial state other also */
357 CLEAR_FLAG (&arch->clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */ 420 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */
358 SET_FLAG (&arch->clone, FLAG_REMOVED); /* doesn't copy these flags... */ 421 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
422}
359 423
360 return arch; 424archetype::~archetype ()
425{
361} 426}
362 427
363/* 428/*
364 * Reads/parses the archetype-file, and copies into a linked list 429 * Reads/parses the archetype-file, and copies into a linked list
365 * of archetype-structures. 430 * of archetype-structures.
366 */ 431 */
432void
367void first_arch_pass(object_thawer &fp) { 433first_arch_pass (object_thawer & fp)
368 object *op; 434{
369 archetype *at,*head=NULL,*last_more=NULL; 435 archetype *at, *head = NULL, *last_more = NULL;
370 int i,first=2;
371 436
372 op=get_object(); 437 at->clone.arch = first_archetype = at = new archetype;
373 op->arch=first_archetype=at=get_archetype_struct();
374 438
375 while((i=load_object(fp,op,first,0))) { 439 while (int i = load_object (fp, &at->clone, 0))
376 first=0; 440 {
377 copy_object(op,&at->clone);
378 at->clone.speed_left= (float) (-0.1); 441 at->clone.speed_left = (float) (-0.1);
379 /* copy the body_info to the body_used - this is only really 442 /* copy the body_info to the body_used - this is only really
380 * need for monsters, but doesn't hurt to do it for everything. 443 * need for monsters, but doesn't hurt to do it for everything.
381 * by doing so, when a monster is created, it has good starting 444 * by doing so, when a monster is created, it has good starting
382 * values for the body_used info, so when items are created 445 * values for the body_used info, so when items are created
383 * for it, they can be properly equipped. 446 * for it, they can be properly equipped.
384 */ 447 */
385 memcpy(&at->clone.body_used, &op->body_info, sizeof(op->body_info)); 448 memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
386 449
387 switch(i) { 450 switch (i)
451 {
388 case LL_NORMAL: /* A new archetype, just link it with the previous */ 452 case LL_NORMAL: /* A new archetype, just link it with the previous */
389 if(last_more!=NULL) 453 if (last_more != NULL)
390 last_more->next=at; 454 last_more->next = at;
391 if(head!=NULL) 455 if (head != NULL)
392 head->next=at; 456 head->next = at;
393 head=last_more=at; 457 head = last_more = at;
394#if 0 458#if 0
395 if(!op->type) 459 if (!op->type)
396 LOG(llevDebug," WARNING: Archetype %s has no type info!\n", op->arch->name); 460 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
397#endif 461#endif
398 at->tail_x = 0; 462 at->tail_x = 0;
399 at->tail_y = 0; 463 at->tail_y = 0;
400 break; 464 break;
401 465
402 case LL_MORE: /* Another part of the previous archetype, link it correctly */ 466 case LL_MORE: /* Another part of the previous archetype, link it correctly */
403 467
404 at->head=head; 468 at->head = head;
405 at->clone.head = &head->clone; 469 at->clone.head = &head->clone;
406 if(last_more!=NULL) { 470 if (last_more != NULL)
471 {
407 last_more->more=at; 472 last_more->more = at;
408 last_more->clone.more = &at->clone; 473 last_more->clone.more = &at->clone;
409 } 474 }
410 last_more=at; 475 last_more = at;
411 476
412 /* If this multipart image is still composed of individual small 477 /* If this multipart image is still composed of individual small
413 * images, don't set the tail_.. values. We can't use them anyways, 478 * images, don't set the tail_.. values. We can't use them anyways,
414 * and setting these to zero makes the map sending to the client much 479 * and setting these to zero makes the map sending to the client much
415 * easier as just looking at the head, we know what to do. 480 * easier as just looking at the head, we know what to do.
416 */ 481 */
417 if (at->clone.face != head->clone.face) { 482 if (at->clone.face != head->clone.face)
483 {
418 head->tail_x = 0; 484 head->tail_x = 0;
419 head->tail_y = 0; 485 head->tail_y = 0;
420 } else {
421 if (at->clone.x > head->tail_x) head->tail_x = at->clone.x;
422 if (at->clone.y > head->tail_y) head->tail_y = at->clone.y;
423 } 486 }
487 else
488 {
489 if (at->clone.x > head->tail_x)
490 head->tail_x = at->clone.x;
491 if (at->clone.y > head->tail_y)
492 head->tail_y = at->clone.y;
493 }
424 break; 494 break;
425 495
426 } 496 }
427 497
428 at=get_archetype_struct(); 498 at = new archetype;
429 clear_object(op);
430 op->arch=at;
431 }
432 499
500 at->clone.arch = at;
501 }
502
433 delete at; 503 delete at;
434 free_object(op);
435} 504}
436 505
437/* 506/*
438 * Reads the archetype file once more, and links all pointers between 507 * Reads the archetype file once more, and links all pointers between
439 * archetypes. 508 * archetypes.
440 */ 509 */
441 510
511void
442void second_arch_pass(object_thawer &thawer) { 512second_arch_pass (object_thawer & thawer)
513{
443 char buf[MAX_BUF],*variable=buf,*argument,*cp; 514 char buf[MAX_BUF], *variable = buf, *argument, *cp;
444 archetype *at=NULL,*other; 515 archetype *at = NULL, *other;
445 516
446 while(fgets(buf,MAX_BUF,thawer)!=NULL) { 517 while (fgets (buf, MAX_BUF, thawer) != NULL)
518 {
447 if(*buf=='#') 519 if (*buf == '#')
448 continue; 520 continue;
449 if((argument=strchr(buf,' '))!=NULL) { 521 if ((argument = strchr (buf, ' ')) != NULL)
522 {
450 *argument='\0',argument++; 523 *argument = '\0', argument++;
451 cp = argument + strlen(argument)-1; 524 cp = argument + strlen (argument) - 1;
452 while (isspace(*cp)) { 525 while (isspace (*cp))
526 {
453 *cp='\0'; 527 *cp = '\0';
454 cp--; 528 cp--;
455 } 529 }
456 } 530 }
457 if(!strcmp("Object",variable)) { 531 if (!strcmp ("Object", variable))
532 {
458 if((at=find_archetype(argument))==NULL) 533 if ((at = archetype::find (argument)) == NULL)
459 LOG(llevError,"Warning: failed to find arch %s\n",argument); 534 LOG (llevError, "Warning: failed to find arch %s\n", argument);
535 }
460 } else if(!strcmp("other_arch",variable)) { 536 else if (!strcmp ("other_arch", variable))
537 {
461 if(at!=NULL&&at->clone.other_arch==NULL) { 538 if (at != NULL && at->clone.other_arch == NULL)
539 {
462 if((other=find_archetype(argument))==NULL) 540 if ((other = archetype::find (argument)) == NULL)
463 LOG(llevError,"Warning: failed to find other_arch %s\n",argument); 541 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
464 else if(at!=NULL) 542 else if (at != NULL)
465 at->clone.other_arch=other; 543 at->clone.other_arch = other;
544 }
466 } 545 }
467 } else if(!strcmp("randomitems",variable)) { 546 else if (!strcmp ("randomitems", variable))
547 {
468 if(at!=NULL) { 548 if (at != NULL)
549 {
550 treasurelist *
469 treasurelist *tl=find_treasurelist(argument); 551 tl = find_treasurelist (argument);
552
470 if(tl==NULL) 553 if (tl == NULL)
471 LOG(llevError,"Failed to link treasure to arch (%s): %s\n", &at->name, argument); 554 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
472 else 555 else
473 at->clone.randomitems=tl; 556 at->clone.randomitems = tl;
557 }
474 } 558 }
475 }
476 } 559 }
477} 560}
478 561
479#ifdef DEBUG 562#ifdef DEBUG
563void
480void check_generators(void) { 564check_generators (void)
565{
481 archetype *at; 566 archetype *at;
567
482 for(at=first_archetype;at!=NULL;at=at->next) 568 for (at = first_archetype; at != NULL; at = at->next)
483 if(QUERY_FLAG(&at->clone,FLAG_GENERATOR)&&at->clone.other_arch==NULL) 569 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
484 LOG(llevError,"Warning: %s is generator but lacks other_arch.\n", &at->name); 570 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
485} 571}
486#endif 572#endif
487 573
488/* 574/*
489 * First initialises the archtype hash-table (init_archetable()). 575 * First initialises the archtype hash-table (init_archetable()).
… …
494 580
495void 581void
496load_archetypes (void) 582load_archetypes (void)
497{ 583{
498 char filename[MAX_BUF]; 584 char filename[MAX_BUF];
499 int comp; 585
500#if TIME_ARCH_LOAD 586#if TIME_ARCH_LOAD
501 struct timeval tv1, tv2; 587 struct timeval
588 tv1,
589 tv2;
502#endif 590#endif
503 591
504 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes); 592 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
505 LOG (llevDebug, "Reading archetypes from %s:\n", filename); 593 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
506 594
507 { 595 {
596 object_thawer
508 object_thawer thawer (filename); 597 thawer (filename);
509 598
510 clear_archetable (); 599 clear_archetable ();
511 LOG (llevDebug, " arch-pass 1...\n"); 600 LOG (llevDebug, " arch-pass 1...\n");
512 first_arch_pass (thawer); 601 first_arch_pass (thawer);
513 LOG (llevDebug, " done\n"); 602 LOG (llevDebug, " done\n");
514
515 init_archetable ();
516 warn_archetypes = 1;
517 } 603 }
518 604
605 init_archetable ();
606 warn_archetypes = 1;
607
519 { 608 {
609 object_thawer
520 object_thawer thawer (filename); 610 thawer (filename);
521 611
522 LOG (llevDebug, " loading treasure...\n"); 612 LOG (llevDebug, " loading treasure...\n");
523 load_treasures (); 613 load_treasures ();
524 LOG (llevDebug, " done\n arch-pass 2...\n"); 614 LOG (llevDebug, " done\n arch-pass 2...\n");
525 second_arch_pass (thawer); 615 second_arch_pass (thawer);
… …
534/* 624/*
535 * Creates and returns a new object which is a copy of the given archetype. 625 * Creates and returns a new object which is a copy of the given archetype.
536 * This function returns NULL on failure. 626 * This function returns NULL on failure.
537 */ 627 */
538 628
629object *
539object *arch_to_object(archetype *at) { 630arch_to_object (archetype *at)
631{
540 object *op; 632 object *op;
633
541 if(at==NULL) { 634 if (at == NULL)
635 {
542 if(warn_archetypes) 636 if (warn_archetypes)
543 LOG(llevError,"Couldn't find archetype.\n"); 637 LOG (llevError, "Couldn't find archetype.\n");
638
544 return NULL; 639 return NULL;
545 } 640 }
641
546 op=get_object(); 642 op = get_object ();
547 copy_object(&at->clone,op); 643 copy_object (&at->clone, op);
644 op->arch = at;
548 op->instantiate (); 645 op->instantiate ();
549 op->arch=at;
550 return op; 646 return op;
551} 647}
552 648
553/* 649/*
554 * Creates an object. This function is called by get_archetype() 650 * Creates an object. This function is called by get_archetype()
555 * if it fails to find the appropriate archetype. 651 * if it fails to find the appropriate archetype.
556 * Thus get_archetype() will be guaranteed to always return 652 * Thus get_archetype() will be guaranteed to always return
557 * an object, and never NULL. 653 * an object, and never NULL.
558 */ 654 */
559 655
656object *
560object *create_singularity(const char *name) { 657create_singularity (const char *name)
658{
561 object *op; 659 object *op;
562 char buf[MAX_BUF]; 660 char buf[MAX_BUF];
661
563 sprintf(buf,"%s (%s)",ARCH_SINGULARITY,name); 662 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
564 op = get_object(); 663 op = get_object ();
565 op->name = op->name_pl = buf; 664 op->name = op->name_pl = buf;
566 SET_FLAG(op,FLAG_NO_PICK); 665 SET_FLAG (op, FLAG_NO_PICK);
567 return op; 666 return op;
568} 667}
569 668
570/* 669/*
571 * Finds which archetype matches the given name, and returns a new 670 * Finds which archetype matches the given name, and returns a new
572 * object containing a copy of the archetype. 671 * object containing a copy of the archetype.
573 */ 672 */
574 673
674object *
575object *get_archetype(const char *name) { 675get_archetype (const char *name)
576 archetype *at; 676{
577 at = find_archetype(name); 677 archetype *at = archetype::find (name);
578 if (at == NULL) 678
679 if (!at)
579 return create_singularity(name); 680 return create_singularity (name);
681
580 return arch_to_object(at); 682 return arch_to_object (at);
581} 683}
582 684
583/* 685/*
584 * Hash-function used by the arch-hashtable. 686 * Hash-function used by the arch-hashtable.
585 */ 687 */
586 688
587unsigned long 689unsigned long
588hasharch(const char *str, int tablesize) 690hasharch (const char *str, int tablesize)
589{ 691{
590 unsigned long hash = 0; 692 unsigned long hash = 0;
591 unsigned int i = 0; 693 unsigned int i = 0;
592 const char *p; 694 const char *p;
593 695
… …
598 */ 700 */
599 for (p = str; i < MAXSTRING && *p; p++, i++) 701 for (p = str; i < MAXSTRING && *p; p++, i++)
600 { 702 {
601 hash += *p; 703 hash += *p;
602 hash += hash << 10; 704 hash += hash << 10;
603 hash ^= hash >> 6; 705 hash ^= hash >> 6;
604 } 706 }
605 707
606 hash += hash << 3; 708 hash += hash << 3;
607 hash ^= hash >> 11; 709 hash ^= hash >> 11;
608 hash += hash << 15; 710 hash += hash << 15;
609 711
610 return hash % tablesize; 712 return hash % tablesize;
611} 713}
… …
613/* 715/*
614 * Finds, using the hashtable, which archetype matches the given name. 716 * Finds, using the hashtable, which archetype matches the given name.
615 * returns a pointer to the found archetype, otherwise NULL. 717 * returns a pointer to the found archetype, otherwise NULL.
616 */ 718 */
617 719
720archetype *
618archetype *find_archetype(const char *name) { 721archetype::find (const char *name)
722{
723 if (!name)
724 return 0;
725
726#if USE_UNORDERED_MAP
727 AUTODECL (i, ht.find ((size_t) name));
728
729 if (i == ht.end ())
730 return 0;
731 else
732 return i->second;
733#endif
734
619 archetype *at; 735 archetype *at;
620 unsigned long index; 736 unsigned long index;
621 737
622 if (name == NULL)
623 return (archetype *) NULL;
624
625 index=hasharch(name, ARCHTABLE); 738 index = hasharch (name, ARCHTABLE);
626 arch_search++; 739 arch_search++;
627 for(;;) { 740 for (;;)
741 {
628 at = arch_table[index]; 742 at = arch_table[index];
743
629 if (at==NULL) { 744 if (at == NULL)
745 {
630 if(warn_archetypes) 746 if (warn_archetypes)
631 LOG(llevError,"Couldn't find archetype %s\n",name); 747 LOG (llevError, "Couldn't find archetype %s\n", name);
748
632 return NULL; 749 return NULL;
633 } 750 }
751
634 arch_cmp++; 752 arch_cmp++;
753
635 if (!strcmp((const char *)at->name,name)) 754 if (!strcmp ((const char *) at->name, name))
636 return at; 755 return at;
756
637 if(++index>=ARCHTABLE) 757 if (++index >= ARCHTABLE)
638 index=0; 758 index = 0;
639 } 759 }
640} 760}
641 761
642/* 762/*
643 * Adds an archetype to the hashtable. 763 * Adds an archetype to the hashtable.
644 */ 764 */
645 765
766static void
646static void add_arch(archetype *at) { 767add_arch (archetype *at)
768{
769#if USE_UNORDERED_MAP
770 ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
771#endif
772
647 int index=hasharch((const char *)at->name, ARCHTABLE),org_index=index; 773 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
774
648 for(;;) { 775 for (;;)
776 {
649 if(arch_table[index]==NULL) { 777 if (arch_table[index] == NULL)
778 {
650 arch_table[index]=at; 779 arch_table[index] = at;
651 return; 780 return;
652 } 781 }
782
653 if(++index==ARCHTABLE) 783 if (++index == ARCHTABLE)
654 index=0; 784 index = 0;
785
655 if(index==org_index) 786 if (index == org_index)
656 fatal(ARCHTABLE_TOO_SMALL); 787 fatal (ARCHTABLE_TOO_SMALL);
657 } 788 }
658} 789}
659 790
660/* 791/*
661 * Returns the first archetype using the given type. 792 * Returns the first archetype using the given type.
662 * Used in treasure-generation. 793 * Used in treasure-generation.
663 */ 794 */
664 795
796archetype *
665archetype *type_to_archetype(int type) { 797type_to_archetype (int type)
798{
666 archetype *at; 799 archetype *at;
667 800
668 for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) 801 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
669 if(at->clone.type==type) 802 if (at->clone.type == type)
670 return at; 803 return at;
804
671 return NULL; 805 return 0;
672} 806}
673 807
674/* 808/*
675 * Returns a new object copied from the first archetype matching 809 * Returns a new object copied from the first archetype matching
676 * the given type. 810 * the given type.
677 * Used in treasure-generation. 811 * Used in treasure-generation.
678 */ 812 */
679 813
814object *
680object *clone_arch(int type) { 815clone_arch (int type)
816{
681 archetype *at; 817 archetype *at;
682 object *op=get_object(); 818 object *op = get_object ();
683 819
684 if((at=type_to_archetype(type))==NULL) { 820 if ((at = type_to_archetype (type)) == NULL)
821 {
685 LOG(llevError,"Can't clone archetype %d\n",type); 822 LOG (llevError, "Can't clone archetype %d\n", type);
686 free_object(op); 823 free_object (op);
687 return NULL; 824 return NULL;
688 } 825 }
826
689 copy_object(&at->clone,op); 827 copy_object (&at->clone, op);
690 op->instantiate (); 828 op->instantiate ();
691 return op; 829 return op;
692} 830}
693 831
694/* 832/*
695 * member: make instance from class 833 * member: make instance from class
696 */ 834 */
697 835
836object *
698object *object_create_arch (archetype * at) 837object_create_arch (archetype *at)
699{ 838{
700 object *op, *prev = NULL, *head = NULL; 839 object *op, *prev = 0, *head = 0;
701 840
702 while (at) { 841 while (at)
842 {
703 op = arch_to_object (at); 843 op = arch_to_object (at);
704 op->x = at->clone.x; 844 op->x = at->clone.x;
705 op->y = at->clone.y; 845 op->y = at->clone.y;
846
706 if (head) 847 if (head)
707 op->head = head, prev->more = op; 848 op->head = head, prev->more = op;
849
708 if (!head) 850 if (!head)
709 head = op; 851 head = op;
852
710 prev = op; 853 prev = op;
711 at = at->more; 854 at = at->more;
712 } 855 }
856
713 return (head); 857 return (head);
714} 858}
715 859
716/*** end of arch.c ***/

Diff Legend

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