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

Diff Legend

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