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.1 by elmex, Sun Aug 13 17:16:00 2006 UTC vs.
Revision 1.21 by root, Thu Sep 14 22:33:58 2006 UTC

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

Diff Legend

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