| 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 | |
| 42 | bool loading_arch; // ugly flag to object laoder etc. to suppress/request special processing |
41 | archetype *loading_arch; // ugly flag to object laoder etc. to suppress/request special processing |
| 43 | |
42 | |
| 44 | // the hashtable |
43 | // the hashtable |
| 45 | typedef std::tr1::unordered_map |
44 | typedef std::tr1::unordered_map |
| 46 | < |
45 | < |
| 47 | const char *, |
46 | const char *, |
| … | |
… | |
| 300 | |
299 | |
| 301 | void |
300 | void |
| 302 | archetype::unlink () |
301 | archetype::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); |
| … | |
… | |
| 348 | archetype * |
350 | archetype * |
| 349 | archetype::read (object_thawer &f) |
351 | archetype::read (object_thawer &f) |
| 350 | { |
352 | { |
| 351 | assert (f.kw == KW_object); |
353 | assert (f.kw == KW_object); |
| 352 | |
354 | |
| 353 | loading_arch = true; // hack to tell parse_kv et al. to behave |
|
|
| 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 (); |
| 358 | |
358 | |
| 359 | for (;;) |
359 | for (;;) |
| 360 | { |
360 | { |
| 361 | // the archetype might have been referenced earlier |
361 | // the archetype might have been referenced earlier |
| 362 | // so try to find an existing stub archetype first |
362 | // so try to find an existing stub archetype first |
| … | |
… | |
| 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 (); |
| … | |
… | |
| 476 | |
480 | |
| 477 | fail: |
481 | fail: |
| 478 | for (auto (p, parts.begin ()); p != parts.end (); ++p) |
482 | for (auto (p, parts.begin ()); p != parts.end (); ++p) |
| 479 | (*p)->destroy (true); |
483 | (*p)->destroy (true); |
| 480 | |
484 | |
| 481 | loading_arch = false; |
|
|
| 482 | return 0; |
485 | return 0; |
| 483 | } |
486 | } |
| 484 | |
487 | |
| 485 | /* |
488 | /* |
| 486 | * Initialize global archtype pointers: |
489 | * Initialize global archtype pointers: |
| … | |
… | |
| 513 | op->instantiate (); |
516 | op->instantiate (); |
| 514 | |
517 | |
| 515 | return op; |
518 | return op; |
| 516 | } |
519 | } |
| 517 | |
520 | |
|
|
521 | object * |
|
|
522 | archetype::instance () |
|
|
523 | { |
|
|
524 | return arch_to_object (this); |
|
|
525 | } |
|
|
526 | |
| 518 | /* |
527 | /* |
| 519 | * Creates an object. This function is called by get_archetype() |
528 | * Creates an object. This function is called by get_archetype() |
| 520 | * if it fails to find the appropriate archetype. |
529 | * if it fails to find the appropriate archetype. |
| 521 | * Thus get_archetype() will be guaranteed to always return |
530 | * Thus get_archetype() will be guaranteed to always return |
| 522 | * an object, and never NULL. |
531 | * an object, and never NULL. |
