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

Diff Legend

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