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.65 by root, Thu Jun 7 18:55:24 2007 UTC vs.
Revision 1.71 by root, Thu Nov 8 19:43:23 2007 UTC

1/* 1/*
2 * This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Crossfire TRT is free software; you can redistribute it and/or modify it 8 * Deliantra is free software: you can redistribute it and/or modify
9 * under the terms of the GNU General Public License as published by the Free 9 * it under the terms of the GNU General Public License as published by
10 * Software Foundation; either version 2 of the License, or (at your option) 10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, but 13 * This program is distributed in the hope that it will be useful,
14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License along 18 * You should have received a copy of the GNU General Public License
19 * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 * 20 *
22 * The authors can be reached via e-mail to <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 22 */
24 23
25#include <cassert> 24#include <cassert>
26 25
27#include <global.h> 26#include <global.h>
… …
37 * return an object. Perhaps those should be called 'archob' functions 36 * return an object. Perhaps those should be called 'archob' functions
38 * to denote they return an object derived from the archetype. 37 * to denote they return an object derived from the archetype.
39 * MSW 2003-04-29 38 * MSW 2003-04-29
40 */ 39 */
41 40
42bool loading_arch; // ugly flag to object laoder etc. to suppress/request special processing 41archetype *loading_arch; // ugly flag to object laoder etc. to suppress/request special processing
43 42
44// the hashtable 43// the hashtable
45typedef std::tr1::unordered_map 44typedef std::tr1::unordered_map
46 < 45 <
47 const char *, 46 const char *,
… …
69find_archetype_by_object_name (const char *name) 68find_archetype_by_object_name (const char *name)
70{ 69{
71 shstr_cmp name_cmp (name); 70 shstr_cmp name_cmp (name);
72 71
73 for_all_archetypes (at) 72 for_all_archetypes (at)
74 if (at->archname == name_cmp) 73 if (at->name == name_cmp)
75 return at; 74 return at;
76 75
77 return 0; 76 return 0;
78} 77}
79 78
… …
86find_archetype_by_object_type_name (int type, const char *name) 85find_archetype_by_object_type_name (int type, const char *name)
87{ 86{
88 shstr_cmp name_cmp (name); 87 shstr_cmp name_cmp (name);
89 88
90 for_all_archetypes (at) 89 for_all_archetypes (at)
91 if (at->archname == name_cmp && at->type == type) 90 if (at->name == name_cmp && at->type == type)
92 return at; 91 return at;
93 92
94 return 0; 93 return 0;
95} 94}
96 95
… …
300 299
301void 300void
302archetype::unlink () 301archetype::unlink ()
303{ 302{
304 ht.erase (archname); 303 ht.erase (archname);
305 if (!strcmp (&archname, "Gaea")) fprintf (stderr, "oI\n");//D 304
306 if (archetypes.contains (this)) 305 if (archetypes.contains (this))
307 archetypes.erase (this); 306 archetypes.erase (this);
308} 307}
309 308
310/* 309/*
… …
332 { 331 {
333 LOG (llevError, "null archetype requested\n"); 332 LOG (llevError, "null archetype requested\n");
334 name = "(null)"; 333 name = "(null)";
335 } 334 }
336 335
336 if (loading_arch && !strcmp (&loading_arch->archname, name))
337 return loading_arch;
338
337 archetype *at = find (name); 339 archetype *at = find (name);
338 340
339 if (!at) 341 if (!at)
340 { 342 {
341 at = new archetype (name); 343 at = new archetype (name);
… …
347 349
348archetype * 350archetype *
349archetype::read (object_thawer &f) 351archetype::read (object_thawer &f)
350{ 352{
351 assert (f.kw == KW_object); 353 assert (f.kw == KW_object);
352
353 loading_arch = true; // hack to tell parse_kv et al. to behave
354 354
355 std::vector<archetype *> parts; 355 std::vector<archetype *> parts;
356 356
357 coroapi::cede_to_tick_every (10); 357 coroapi::cede_to_tick_every (10);
358 358
… …
382 382
383 f.next (); 383 f.next ();
384 } 384 }
385#endif 385#endif
386 386
387 loading_arch = at; // hack to tell parse_kv et al. to behave
388 bool parse_ok = at->parse_kv (f);
389 loading_arch = 0;
390
387 if (!at->parse_kv (f)) 391 if (!parse_ok)
388 goto fail; 392 goto fail;
389 393
394 loading_arch = at; // hack to tell parse_kv et al. to behave
390 at->post_load_check (); 395 at->post_load_check ();
396 loading_arch = 0;
391 397
392 parts.push_back (at); 398 parts.push_back (at);
393 399
394 if (f.kw != KW_more) 400 if (f.kw != KW_more)
395 break; 401 break;
… …
400 { 406 {
401 f.parse_error ("more object"); 407 f.parse_error ("more object");
402 goto fail; 408 goto fail;
403 } 409 }
404 } 410 }
405
406 loading_arch = false;
407 411
408 { 412 {
409 auto (at, parts.begin ()); 413 auto (at, parts.begin ());
410 414
411 archetype *new_head = parts.front (); 415 archetype *new_head = parts.front ();
… …
443 archetype *less = new_head; 447 archetype *less = new_head;
444 for (auto (p, parts.begin () + 1); p != parts.end (); ++p) 448 for (auto (p, parts.begin () + 1); p != parts.end (); ++p)
445 { 449 {
446 archetype *at = *p; 450 archetype *at = *p;
447 451
452 // some flags get inherited formt he head (probably a lot more)
453 // doing it here doesn't feel too cozy, but it allows code
454 // to ignore head checks for these flags, which saves time
455 at->flag [FLAG_ALIVE] = new_head->flag [FLAG_ALIVE];
456 at->flag [FLAG_NO_PICK] = new_head->flag [FLAG_NO_PICK];
457 at->flag [FLAG_MONSTER] = new_head->flag [FLAG_MONSTER];
458 at->flag [FLAG_IS_FLOOR] = new_head->flag [FLAG_IS_FLOOR];
459
448 if (at->x < new_head->min_x) new_head->min_x = at->x; 460 if (at->x < new_head->min_x) new_head->min_x = at->x;
449 if (at->y < new_head->min_y) new_head->min_y = at->y; 461 if (at->y < new_head->min_y) new_head->min_y = at->y;
450 if (at->x > new_head->max_x) new_head->max_x = at->x; 462 if (at->x > new_head->max_x) new_head->max_x = at->x;
451 if (at->y > new_head->max_y) new_head->max_y = at->y; 463 if (at->y > new_head->max_y) new_head->max_y = at->y;
452 464
… …
468 480
469fail: 481fail:
470 for (auto (p, parts.begin ()); p != parts.end (); ++p) 482 for (auto (p, parts.begin ()); p != parts.end (); ++p)
471 (*p)->destroy (true); 483 (*p)->destroy (true);
472 484
473 loading_arch = false;
474 return 0; 485 return 0;
475} 486}
476 487
477/* 488/*
478 * Initialize global archtype pointers: 489 * Initialize global archtype pointers:
… …
505 op->instantiate (); 516 op->instantiate ();
506 517
507 return op; 518 return op;
508} 519}
509 520
521object *
522archetype::instance ()
523{
524 return arch_to_object (this);
525}
526
510/* 527/*
511 * Creates an object. This function is called by get_archetype() 528 * Creates an object. This function is called by get_archetype()
512 * if it fails to find the appropriate archetype. 529 * if it fails to find the appropriate archetype.
513 * Thus get_archetype() will be guaranteed to always return 530 * Thus get_archetype() will be guaranteed to always return
514 * an object, and never NULL. 531 * an object, and never NULL.
… …
520 537
521 if (!strcmp (name, "bug")) 538 if (!strcmp (name, "bug"))
522 abort (); 539 abort ();
523 540
524 char buf[MAX_BUF]; 541 char buf[MAX_BUF];
525 sprintf (buf, "bug, please report (%s)", ARCH_SINGULARITY, name); 542 sprintf (buf, "bug, please report (%s)", name);
526 543
527 object *op = get_archetype ("bug"); 544 object *op = get_archetype ("bug");
528 op->name = op->name_pl = buf; 545 op->name = op->name_pl = buf;
529 546
530 return op; 547 return op;

Diff Legend

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