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.12 by root, Mon Sep 4 17:16:19 2006 UTC vs.
Revision 1.36 by pippijn, Sat Jan 6 14:42:28 2007 UTC

1/*
2 * static char *rcsid_arch_c =
3 * "$Id: arch.C,v 1.12 2006/09/04 17:16:19 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
11 7
12 This program is free software; you can redistribute it and/or modify 8 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by 9 it under the terms of the GNU General Public License as published by
… …
21 17
22 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 21
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 23*/
28 24
29#include <cassert> 25#include <cassert>
30 26
31#include <tr1/unordered_map>
32
33#include <global.h> 27#include <global.h>
34#include <arch.h>
35#include <funcpoint.h> 28#include <funcpoint.h>
36#include <loader.h> 29#include <loader.h>
37 30
38/* IF set, does a little timing on the archetype load. */ 31#define USE_UNORDERED_MAP 0
39#define TIME_ARCH_LOAD 0
40 32
41static void add_arch (archetype * at); 33#if USE_UNORDERED_MAP
34# include <tr1/functional>
35# include <tr1/unordered_map>
36#endif
42 37
43static archetype *arch_table[ARCHTABLE];
44int arch_cmp = 0; /* How many strcmp's */ 38int arch_cmp = 0; /* How many strcmp's */
45int arch_search = 0; /* How many searches */ 39int arch_search = 0; /* How many searches */
46int arch_init; /* True if doing arch initialization */ 40int arch_init; /* True if doing arch initialization */
47 41
48/* The naming of these functions is really poor - they are all 42/* The naming of these functions is really poor - they are all
… …
53 * MSW 2003-04-29 47 * MSW 2003-04-29
54 */ 48 */
55 49
56#if USE_UNORDERED_MAP 50#if USE_UNORDERED_MAP
57// the hashtable 51// the hashtable
58typedef std::tr1::unordered_map<size_t, archetype *> HT; 52typedef std::tr1::unordered_map
53 <
54 std::size_t,
55 arch_ptr,
56 std::tr1::hash<size_t>,
57 std::equal_to<size_t>,
58 slice_allocator< std::pair<const std::size_t, archetype *> >
59 true,
60 > HT;
59 61
60static HT ht; 62static HT ht;
63#else
64static arch_ptr arch_table[ARCHTABLE];
61#endif 65#endif
62 66
63/** 67/**
64 * GROS - This function retrieves an archetype given the name that appears 68 * GROS - This function retrieves an archetype given the name that appears
65 * during the game (for example, "writing pen" instead of "stylus"). 69 * during the game (for example, "writing pen" instead of "stylus").
… …
115 * If type is -1, ew don't match on type. 119 * If type is -1, ew don't match on type.
116 */ 120 */
117object * 121object *
118get_archetype_by_skill_name (const char *skill, int type) 122get_archetype_by_skill_name (const char *skill, int type)
119{ 123{
120 archetype * 124 archetype *at;
121 at;
122 125
123 if (skill == NULL) 126 if (skill)
124 return NULL;
125
126 for (at = first_archetype; at != NULL; at = at->next) 127 for (at = first_archetype; at; at = at->next)
127 {
128 if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill))) 128 if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
129 return arch_to_object (at); 129 return arch_to_object (at);
130 } 130
131 return NULL; 131 return 0;
132} 132}
133 133
134/* similiar to above - this returns the first archetype 134/* similiar to above - this returns the first archetype
135 * that matches both the type and subtype. type and subtype 135 * that matches both the type and subtype. type and subtype
136 * can be -1 to say ignore, but in this case, the match it does 136 * can be -1 to say ignore, but in this case, the match it does
… …
165 * but it otherwise had a big memory leak. 165 * but it otherwise had a big memory leak.
166 */ 166 */
167object * 167object *
168get_archetype_by_object_name (const char *name) 168get_archetype_by_object_name (const char *name)
169{ 169{
170 archetype * 170 archetype *at;
171 at;
172 char
173 tmpname[MAX_BUF]; 171 char tmpname[MAX_BUF];
174 int 172 int i;
175 i;
176 173
177 strncpy (tmpname, name, MAX_BUF - 1); 174 assign (tmpname, name);
178 tmpname[MAX_BUF - 1] = 0; 175
179 for (i = strlen (tmpname); i > 0; i--) 176 for (i = strlen (tmpname); i > 0; i--)
180 { 177 {
181 tmpname[i] = 0; 178 tmpname[i] = 0;
182 at = find_archetype_by_object_name (tmpname); 179 at = find_archetype_by_object_name (tmpname);
180
183 if (at != NULL) 181 if (at)
184 {
185 return arch_to_object (at); 182 return arch_to_object (at);
186 }
187 } 183 }
184
188 return create_singularity (name); 185 return create_singularity (name);
189} 186}
190 187
191 /* This is a subset of the parse_id command. Basically, name can be 188 /* This is a subset of the parse_id command. Basically, name can be
192 * a string seperated lists of things to match, with certain keywords. 189 * a string seperated lists of things to match, with certain keywords.
… …
204 * If count is 1, make a quick check on the name. 201 * If count is 1, make a quick check on the name.
205 * IF count is >1, we need to make plural name. Return if match. 202 * IF count is >1, we need to make plural name. Return if match.
206 * Last, make a check on the full name. 203 * Last, make a check on the full name.
207 */ 204 */
208int 205int
209item_matched_string (object * pl, object * op, const char *name) 206item_matched_string (object *pl, object *op, const char *name)
210{ 207{
211 char *
212 cp,
213 local_name[MAX_BUF]; 208 char *cp, local_name[MAX_BUF];
214 int 209 int count, retval = 0;
215 count, 210
216 retval = 0;
217 strcpy (local_name, name); /* strtok is destructive to name */ 211 strcpy (local_name, name); /* strtok is destructive to name */
218 212
219 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ",")) 213 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
220 { 214 {
221 while (cp[0] == ' ') 215 while (cp[0] == ' ')
… …
272 retval = 15; 266 retval = 15;
273 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp))) 267 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
274 retval = 14; 268 retval = 14;
275 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp))) 269 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
276 retval = 14; 270 retval = 14;
277
278 /* Do substring checks, so things like 'Str+1' will match. 271 /* Do substring checks, so things like 'Str+1' will match.
279 * retval of these should perhaps be lower - they are lower 272 * retval of these should perhaps be lower - they are lower
280 * then the specific strcasecmp aboves, but still higher than 273 * then the specific strcasecmp aboves, but still higher than
281 * some other match criteria. 274 * some other match criteria.
282 */ 275 */
… …
284 retval = 12; 277 retval = 12;
285 else if (strstr (query_base_name (op, 0), cp)) 278 else if (strstr (query_base_name (op, 0), cp))
286 retval = 12; 279 retval = 12;
287 else if (strstr (query_short_name (op), cp)) 280 else if (strstr (query_short_name (op), cp))
288 retval = 12; 281 retval = 12;
289
290 /* Check against plural/non plural based on count. */ 282 /* Check against plural/non plural based on count. */
291 else if (count > 1 && !strcasecmp (cp, op->name_pl)) 283 else if (count > 1 && !strcasecmp (cp, op->name_pl))
292 {
293 retval = 6; 284 retval = 6;
294 }
295 else if (count == 1 && !strcasecmp (op->name, cp)) 285 else if (count == 1 && !strcasecmp (op->name, cp))
296 {
297 retval = 6; 286 retval = 6;
298 }
299 /* base name matched - not bad */ 287 /* base name matched - not bad */
300 else if (strcasecmp (cp, op->name) == 0 && !count) 288 else if (strcasecmp (cp, op->name) == 0 && !count)
301 retval = 4; 289 retval = 4;
302 /* Check for partial custom name, but give a real low priority */ 290 /* Check for partial custom name, but give a real low priority */
303 else if (op->custom_name && strstr (op->custom_name, cp)) 291 else if (op->custom_name && strstr (op->custom_name, cp))
… …
305 293
306 if (retval) 294 if (retval)
307 { 295 {
308 if (pl->type == PLAYER) 296 if (pl->type == PLAYER)
309 pl->contr->count = count; 297 pl->contr->count = count;
298
310 return retval; 299 return retval;
311 } 300 }
312 } 301 }
302
313 return 0; 303 return 0;
314} 304}
315 305
316/* 306/*
317 * Initialises the internal linked list of archetypes (read from file). 307 * Initialises the internal linked list of archetypes (read from file).
… …
322void 312void
323init_archetypes (void) 313init_archetypes (void)
324{ /* called from add_player() and edit() */ 314{ /* called from add_player() and edit() */
325 if (first_archetype != NULL) /* Only do this once */ 315 if (first_archetype != NULL) /* Only do this once */
326 return; 316 return;
317
327 arch_init = 1; 318 arch_init = 1;
328 load_archetypes (); 319 load_archetypes ();
329 arch_init = 0; 320 arch_init = 0;
330 empty_archetype = find_archetype ("empty_archetype"); 321 empty_archetype = archetype::find ("empty_archetype");
322
331/* init_blocksview();*/ 323/* init_blocksview();*/
332} 324}
333 325
334/* 326/*
335 * Stores debug-information about how efficient the hashtable 327 * Stores debug-information about how efficient the hashtable
336 * used for archetypes has been in the static errmsg array. 328 * used for archetypes has been in the static errmsg array.
337 */ 329 */
338 330
339void 331void
340arch_info (object * op) 332arch_info (object *op)
341{ 333{
342 sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp); 334 sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
343 new_draw_info (NDI_BLACK, 0, op, errmsg); 335 new_draw_info (NDI_BLACK, 0, op, errmsg);
344} 336}
345 337
… …
363 archetype *at; 355 archetype *at;
364 356
365 LOG (llevDebug, " Setting up archetable...\n"); 357 LOG (llevDebug, " Setting up archetable...\n");
366 358
367 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 359 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
368 add_arch (at); 360 at->hash_add ();
369 361
370 LOG (llevDebug, "done\n"); 362 LOG (llevDebug, "done\n");
371} 363}
372 364
373/*
374 * Dumps an archetype to debug-level output.
375 */
376
377void
378dump_arch (archetype * at)
379{
380 dump_object (&at->clone);
381}
382
383/*
384 * Dumps _all_ archetypes to debug-level output.
385 * If you run crossfire with debug, and enter DM-mode, you can trigger
386 * this with the O key.
387 */
388
389void
390dump_all_archetypes (void)
391{
392 archetype *
393 at;
394 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
395 {
396 dump_arch (at);
397 fprintf (logfile, "%s\n", errmsg);
398 }
399}
400
401void 365void
402free_all_archs (void) 366free_all_archs (void)
403{ 367{
404 archetype * 368 archetype *at, *next;
405 at, *
406 next;
407 int
408 i = 0, f = 0; 369 int i = 0, f = 0;
409 370
410 for (at = first_archetype; at != NULL; at = next) 371 for (at = first_archetype; at != NULL; at = next)
411 { 372 {
412 if (at->more) 373 if (at->more)
413 next = at->more; 374 next = at->more;
414 else 375 else
415 next = at->next; 376 next = at->next;
416 377
417 delete 378 delete
418 at; 379 at;
380
419 i++; 381 i++;
420 } 382 }
383
421 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f); 384 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
422} 385}
423 386
424/* 387archetype::archetype ()
425 * Allocates, initialises and returns the pointer to an archetype structure.
426 */
427// TODO: should become constructor
428archetype *
429get_archetype_struct (void)
430{ 388{
431 archetype *
432 arch;
433
434 arch = new archetype;
435
436 clear_object (&arch->clone); /* to initial state other also */
437 CLEAR_FLAG (&arch->clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */ 389 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
438 SET_FLAG (&arch->clone, FLAG_REMOVED); /* doesn't copy these flags... */ 390 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
391}
439 392
440 return arch; 393archetype::~archetype ()
394{
441} 395}
442 396
443/* 397/*
444 * Reads/parses the archetype-file, and copies into a linked list 398 * Reads/parses the archetype-file, and copies into a linked list
445 * of archetype-structures. 399 * of archetype-structures.
446 */ 400 */
447void 401void
448first_arch_pass (object_thawer & fp) 402first_arch_pass (object_thawer & fp)
449{ 403{
450 object * 404 archetype *head = 0, *last_more = 0;
451 op;
452 archetype *
453 at, *
454 head = NULL, *last_more = NULL;
455 int
456 i;
457 405
458 op = get_object (); 406 archetype *at = new archetype;
459 op->arch = first_archetype = at = get_archetype_struct (); 407 at->clone.arch = first_archetype = at;
460 408
461 while ((i = load_object (fp, op, 0))) 409 while (int i = load_object (fp, &at->clone, 0))
462 { 410 {
463 copy_object (op, &at->clone);
464 at->clone.speed_left = (float) (-0.1); 411 at->clone.speed_left = (float) (-0.1);
465 /* copy the body_info to the body_used - this is only really 412 /* copy the body_info to the body_used - this is only really
466 * need for monsters, but doesn't hurt to do it for everything. 413 * need for monsters, but doesn't hurt to do it for everything.
467 * by doing so, when a monster is created, it has good starting 414 * by doing so, when a monster is created, it has good starting
468 * values for the body_used info, so when items are created 415 * values for the body_used info, so when items are created
469 * for it, they can be properly equipped. 416 * for it, they can be properly equipped.
470 */ 417 */
471 memcpy (&at->clone.body_used, &op->body_info, sizeof (op->body_info)); 418 memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
472 419
473 switch (i) 420 switch (i)
474 { 421 {
475 case LL_NORMAL: /* A new archetype, just link it with the previous */ 422 case LL_NORMAL: /* A new archetype, just link it with the previous */
476 if (last_more != NULL) 423 if (last_more != NULL)
477 last_more->next = at; 424 last_more->next = at;
478 if (head != NULL) 425 if (head != NULL)
479 head->next = at; 426 head->next = at;
480 head = last_more = at; 427 head = last_more = at;
481#if 0 428#if 0
482 if (!op->type) 429 if (!op->type)
483 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name); 430 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
484#endif 431#endif
485 at->tail_x = 0; 432 at->tail_x = 0;
486 at->tail_y = 0; 433 at->tail_y = 0;
487 break; 434 break;
488 435
489 case LL_MORE: /* Another part of the previous archetype, link it correctly */ 436 case LL_MORE: /* Another part of the previous archetype, link it correctly */
490 437
491 at->head = head; 438 at->head = head;
492 at->clone.head = &head->clone; 439 at->clone.head = &head->clone;
493 if (last_more != NULL) 440 if (last_more != NULL)
494 { 441 {
495 last_more->more = at; 442 last_more->more = at;
496 last_more->clone.more = &at->clone; 443 last_more->clone.more = &at->clone;
497 } 444 }
498 last_more = at; 445 last_more = at;
499 446
500 /* If this multipart image is still composed of individual small 447 /* If this multipart image is still composed of individual small
501 * images, don't set the tail_.. values. We can't use them anyways, 448 * images, don't set the tail_.. values. We can't use them anyways,
502 * and setting these to zero makes the map sending to the client much 449 * and setting these to zero makes the map sending to the client much
503 * easier as just looking at the head, we know what to do. 450 * easier as just looking at the head, we know what to do.
504 */ 451 */
505 if (at->clone.face != head->clone.face) 452 if (at->clone.face != head->clone.face)
506 { 453 {
507 head->tail_x = 0; 454 head->tail_x = 0;
508 head->tail_y = 0; 455 head->tail_y = 0;
509 } 456 }
510 else 457 else
511 { 458 {
512 if (at->clone.x > head->tail_x) 459 if (at->clone.x > head->tail_x)
513 head->tail_x = at->clone.x; 460 head->tail_x = at->clone.x;
514 if (at->clone.y > head->tail_y) 461 if (at->clone.y > head->tail_y)
515 head->tail_y = at->clone.y; 462 head->tail_y = at->clone.y;
516 } 463 }
517 break; 464 break;
518 465
519 } 466 }
520 467
521 at = get_archetype_struct (); 468 at = new archetype;
522 clear_object (op); 469
523 op->arch = at; 470 at->clone.arch = at;
524 } 471 }
525 472
526 delete 473 delete at;
527 at;
528 free_object (op);
529} 474}
530 475
531/* 476/*
532 * Reads the archetype file once more, and links all pointers between 477 * Reads the archetype file once more, and links all pointers between
533 * archetypes. 478 * archetypes.
534 */ 479 */
535 480
536void 481void
537second_arch_pass (object_thawer & thawer) 482second_arch_pass (object_thawer & thawer)
538{ 483{
539 char
540 buf[MAX_BUF], *
541 variable = buf, *argument, *cp; 484 char buf[MAX_BUF], *variable = buf, *argument, *cp;
542 archetype *
543 at = NULL, *other; 485 archetype *at = NULL, *other;
544 486
545 while (fgets (buf, MAX_BUF, thawer) != NULL) 487 while (fgets (buf, MAX_BUF, thawer) != NULL)
546 { 488 {
547 if (*buf == '#') 489 if (*buf == '#')
548 continue; 490 continue;
… …
556 cp--; 498 cp--;
557 } 499 }
558 } 500 }
559 if (!strcmp ("Object", variable)) 501 if (!strcmp ("Object", variable))
560 { 502 {
561 if ((at = find_archetype (argument)) == NULL) 503 if ((at = archetype::find (argument)) == NULL)
562 LOG (llevError, "Warning: failed to find arch %s\n", argument); 504 LOG (llevError, "Warning: failed to find arch %s\n", argument);
563 } 505 }
564 else if (!strcmp ("other_arch", variable)) 506 else if (!strcmp ("other_arch", variable))
565 { 507 {
566 if (at != NULL && at->clone.other_arch == NULL) 508 if (at != NULL && at->clone.other_arch == NULL)
567 { 509 {
568 if ((other = find_archetype (argument)) == NULL) 510 if ((other = archetype::find (argument)) == NULL)
569 LOG (llevError, "Warning: failed to find other_arch %s\n", argument); 511 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
570 else if (at != NULL) 512 else if (at != NULL)
571 at->clone.other_arch = other; 513 at->clone.other_arch = other;
572 } 514 }
573 } 515 }
574 else if (!strcmp ("randomitems", variable)) 516 else if (!strcmp ("randomitems", variable))
575 { 517 {
576 if (at != NULL) 518 if (at != NULL)
577 { 519 {
578 treasurelist *
579 tl = find_treasurelist (argument); 520 treasurelist *tl = find_treasurelist (argument);
521
580 if (tl == NULL) 522 if (tl == NULL)
581 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument); 523 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
582 else 524 else
583 at->clone.randomitems = tl; 525 at->clone.randomitems = tl;
584 } 526 }
… …
588 530
589#ifdef DEBUG 531#ifdef DEBUG
590void 532void
591check_generators (void) 533check_generators (void)
592{ 534{
593 archetype * 535 archetype *at;
594 at; 536
595 for (at = first_archetype; at != NULL; at = at->next) 537 for (at = first_archetype; at != NULL; at = at->next)
596 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL) 538 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
597 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name); 539 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
598} 540}
599#endif 541#endif
… …
606 */ 548 */
607 549
608void 550void
609load_archetypes (void) 551load_archetypes (void)
610{ 552{
611 char
612 filename[MAX_BUF]; 553 char filename[MAX_BUF];
613 int
614 comp;
615#if TIME_ARCH_LOAD
616 struct timeval
617 tv1,
618 tv2;
619#endif
620 554
621 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes); 555 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
622 LOG (llevDebug, "Reading archetypes from %s:\n", filename); 556 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
623 557
624 { 558 {
… …
638 object_thawer 572 object_thawer
639 thawer (filename); 573 thawer (filename);
640 574
641 LOG (llevDebug, " loading treasure...\n"); 575 LOG (llevDebug, " loading treasure...\n");
642 load_treasures (); 576 load_treasures ();
577 LOG (llevDebug, " done\n");
643 LOG (llevDebug, " done\n arch-pass 2...\n"); 578 LOG (llevDebug, " arch-pass 2...\n");
644 second_arch_pass (thawer); 579 second_arch_pass (thawer);
645 LOG (llevDebug, " done\n"); 580 LOG (llevDebug, " done\n");
646#ifdef DEBUG 581#ifdef DEBUG
647 check_generators (); 582 check_generators ();
648#endif 583#endif
… …
652 587
653/* 588/*
654 * Creates and returns a new object which is a copy of the given archetype. 589 * Creates and returns a new object which is a copy of the given archetype.
655 * This function returns NULL on failure. 590 * This function returns NULL on failure.
656 */ 591 */
657
658object * 592object *
659arch_to_object (archetype * at) 593arch_to_object (archetype *at)
660{ 594{
661 object * 595 object *op;
662 op; 596
663 if (at == NULL) 597 if (at == NULL)
664 { 598 {
665 if (warn_archetypes) 599 if (warn_archetypes)
666 LOG (llevError, "Couldn't find archetype.\n"); 600 LOG (llevError, "Couldn't find archetype.\n");
601
667 return NULL; 602 return NULL;
668 } 603 }
669 op = get_object (); 604
670 copy_object (&at->clone, op); 605 op = at->clone.clone ();
606 op->arch = at;
671 op->instantiate (); 607 op->instantiate ();
672 op->arch = at;
673 return op; 608 return op;
674} 609}
675 610
676/* 611/*
677 * Creates an object. This function is called by get_archetype() 612 * Creates an object. This function is called by get_archetype()
678 * if it fails to find the appropriate archetype. 613 * if it fails to find the appropriate archetype.
679 * Thus get_archetype() will be guaranteed to always return 614 * Thus get_archetype() will be guaranteed to always return
680 * an object, and never NULL. 615 * an object, and never NULL.
681 */ 616 */
682
683object * 617object *
684create_singularity (const char *name) 618create_singularity (const char *name)
685{ 619{
686 object * 620 object *op;
687 op;
688 char
689 buf[MAX_BUF]; 621 char buf[MAX_BUF];
622
690 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 623 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
691 op = get_object (); 624 op = object::create ();
692 op->name = op->name_pl = buf; 625 op->name = op->name_pl = buf;
693 SET_FLAG (op, FLAG_NO_PICK); 626 SET_FLAG (op, FLAG_NO_PICK);
694 return op; 627 return op;
695} 628}
696 629
697/* 630/*
698 * Finds which archetype matches the given name, and returns a new 631 * Finds which archetype matches the given name, and returns a new
699 * object containing a copy of the archetype. 632 * object containing a copy of the archetype.
700 */ 633 */
701
702object * 634object *
703get_archetype (const char *name) 635get_archetype (const char *name)
704{ 636{
705 archetype * 637 archetype *at = archetype::find (name);
706 at; 638
707 at = find_archetype (name); 639 if (!at)
708 if (at == NULL)
709 return create_singularity (name); 640 return create_singularity (name);
641
710 return arch_to_object (at); 642 return arch_to_object (at);
711} 643}
712 644
713/* 645/*
714 * Hash-function used by the arch-hashtable. 646 * Hash-function used by the arch-hashtable.
715 */ 647 */
716 648
717unsigned long 649unsigned long
718hasharch (const char *str, int tablesize) 650hasharch (const char *str, int tablesize)
719{ 651{
720 unsigned long 652 unsigned long hash = 0;
721 hash = 0;
722 unsigned int 653 unsigned int i = 0;
723 i = 0;
724 const char * 654 const char *p;
725 p;
726 655
727 /* use the one-at-a-time hash function, which supposedly is 656 /* use the one-at-a-time hash function, which supposedly is
728 * better than the djb2-like one used by perl5.005, but 657 * better than the djb2-like one used by perl5.005, but
729 * certainly is better then the bug used here before. 658 * certainly is better then the bug used here before.
730 * see http://burtleburtle.net/bob/hash/doobs.html 659 * see http://burtleburtle.net/bob/hash/doobs.html
… …
747 * Finds, using the hashtable, which archetype matches the given name. 676 * Finds, using the hashtable, which archetype matches the given name.
748 * returns a pointer to the found archetype, otherwise NULL. 677 * returns a pointer to the found archetype, otherwise NULL.
749 */ 678 */
750 679
751archetype * 680archetype *
752find_archetype (const char *name) 681archetype::find (const char *name)
753{ 682{
754#if USE_UNORDERED_MAP
755 name = shstr::find (name);
756
757 if (!name) 683 if (!name)
758 return 0; 684 return 0;
759 685
760 HT::const_iterator i = ht.find ((size_t)name); 686#if USE_UNORDERED_MAP
687 AUTODECL (i, ht.find ((size_t) name));
761 688
762 if (i == ht.end ()) 689 if (i == ht.end ())
763 return 0; 690 return 0;
764 else 691 else
765 return i->second; 692 return i->second;
766#endif 693#endif
767 694
768 archetype *at; 695 archetype *at;
769 unsigned long index; 696 unsigned long index;
770 697
771 if (name == NULL)
772 return (archetype *) NULL;
773
774 index = hasharch (name, ARCHTABLE); 698 index = hasharch (name, ARCHTABLE);
775 arch_search++; 699 arch_search++;
776 for (;;) 700 for (;;)
777 { 701 {
778 at = arch_table[index]; 702 at = arch_table[index];
703
779 if (at == NULL) 704 if (at == NULL)
780 { 705 {
781 if (warn_archetypes) 706 if (warn_archetypes)
782 LOG (llevError, "Couldn't find archetype %s\n", name); 707 LOG (llevError, "Couldn't find archetype %s\n", name);
708
783 return NULL; 709 return NULL;
784 } 710 }
711
785 arch_cmp++; 712 arch_cmp++;
713
786 if (!strcmp ((const char *) at->name, name)) 714 if (!strcmp ((const char *) at->name, name))
787 return at; 715 return at;
716
788 if (++index >= ARCHTABLE) 717 if (++index >= ARCHTABLE)
789 index = 0; 718 index = 0;
790 } 719 }
791} 720}
792 721
793/* 722/*
794 * Adds an archetype to the hashtable. 723 * Adds an archetype to the hashtable.
795 */ 724 */
796 725void
797static void 726archetype::hash_add ()
798add_arch (archetype *at)
799{ 727{
800#if USE_UNORDERED_MAP 728#if USE_UNORDERED_MAP
801 ht.insert (std::make_pair ((size_t)(const char *)at->name, at)); 729 ht.insert (std::make_pair ((size_t) (const char *) name, this));
802#endif 730#else
803 731
804 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 732 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
805 733
806 for (;;) 734 for (;;)
807 { 735 {
808 if (arch_table[index] == NULL) 736 if (!arch_table[index])
809 { 737 {
810 arch_table[index] = at; 738 arch_table[index] = this;
811 return; 739 break;
812 } 740 }
813 741
814 if (++index == ARCHTABLE) 742 if (++index == ARCHTABLE)
815 index = 0; 743 index = 0;
816 744
817 if (index == org_index) 745 if (index == org_index)
818 fatal (ARCHTABLE_TOO_SMALL); 746 fatal (ARCHTABLE_TOO_SMALL);
819 } 747 }
748#endif
749}
750
751void
752archetype::hash_del ()
753{
754#if USE_UNORDERED_MAP
755# error remove this from HT
756#else
757
758 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
759
760 for (;;)
761 {
762 if (arch_table[index] == this)
763 {
764 arch_table[index] = 0;
765 break;
766 }
767
768 if (++index == ARCHTABLE)
769 index = 0;
770
771 if (index == org_index)
772 break;
773 }
774#endif
820} 775}
821 776
822/* 777/*
823 * Returns the first archetype using the given type. 778 * Returns the first archetype using the given type.
824 * Used in treasure-generation. 779 * Used in treasure-generation.
825 */ 780 */
826 781
827archetype * 782archetype *
828type_to_archetype (int type) 783type_to_archetype (int type)
829{ 784{
830 archetype * 785 archetype *at;
831 at;
832 786
833 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 787 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
834 if (at->clone.type == type) 788 if (at->clone.type == type)
835 return at; 789 return at;
790
836 return NULL; 791 return 0;
837} 792}
838 793
839/* 794/*
840 * Returns a new object copied from the first archetype matching 795 * Returns a new object copied from the first archetype matching
841 * the given type. 796 * the given type.
… …
843 */ 798 */
844 799
845object * 800object *
846clone_arch (int type) 801clone_arch (int type)
847{ 802{
848 archetype * 803 archetype *at;
849 at;
850 object *
851 op = get_object ();
852 804
853 if ((at = type_to_archetype (type)) == NULL) 805 if ((at = type_to_archetype (type)) == NULL)
854 { 806 {
855 LOG (llevError, "Can't clone archetype %d\n", type); 807 LOG (llevError, "Can't clone archetype %d\n", type);
856 free_object (op);
857 return NULL; 808 return 0;
858 } 809 }
859 copy_object (&at->clone, op); 810
811 object *op = at->clone.clone ();
860 op->instantiate (); 812 op->instantiate ();
861 return op; 813 return op;
862} 814}
863 815
864/* 816/*
865 * member: make instance from class 817 * member: make instance from class
866 */ 818 */
867 819
868object * 820object *
869object_create_arch (archetype * at) 821object_create_arch (archetype *at)
870{ 822{
871 object * 823 object *op, *prev = 0, *head = 0;
872 op, *
873 prev = NULL, *head = NULL;
874 824
875 while (at) 825 while (at)
876 { 826 {
877 op = arch_to_object (at); 827 op = arch_to_object (at);
878 op->x = at->clone.x; 828 op->x = at->clone.x;
879 op->y = at->clone.y; 829 op->y = at->clone.y;
830
880 if (head) 831 if (head)
881 op->head = head, prev->more = op; 832 op->head = head, prev->more = op;
833
882 if (!head) 834 if (!head)
883 head = op; 835 head = op;
836
884 prev = op; 837 prev = op;
885 at = at->more; 838 at = at->more;
886 } 839 }
840
887 return (head); 841 return (head);
888} 842}
889 843
890/*** end of arch.c ***/

Diff Legend

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