ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/spell_effect.C
(Generate patch)

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.16 by root, Tue Dec 12 20:53:03 2006 UTC vs.
Revision 1.52 by root, Thu May 17 14:14:55 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game
3 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
6 7 *
7 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
8 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
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 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
18 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 23 */
23 24
24#include <global.h> 25#include <global.h>
25#include <object.h> 26#include <object.h>
26#include <living.h> 27#include <living.h>
27#ifndef __CEXTRACT__
28# include <sproto.h> 28#include <sproto.h>
29#endif
30#include <spells.h> 29#include <spells.h>
31#include <sounds.h> 30#include <sounds.h>
32 31
33/* cast_magic_storm: This is really used mostly for spell 32/* cast_magic_storm: This is really used mostly for spell
34 * fumbles at the like. tmp is the object to propogate. 33 * fumbles at the like. tmp is the object to propogate.
… …
37void 36void
38cast_magic_storm (object *op, object *tmp, int lvl) 37cast_magic_storm (object *op, object *tmp, int lvl)
39{ 38{
40 if (!tmp) 39 if (!tmp)
41 return; /* error */ 40 return; /* error */
41
42 tmp->level = op->level; 42 tmp->level = op->level;
43 tmp->x = op->x;
44 tmp->y = op->y;
45 tmp->range += lvl / 5; /* increase the area of destruction */ 43 tmp->range += lvl / 5; /* increase the area of destruction */
46 tmp->duration += lvl / 5; 44 tmp->duration += lvl / 5;
47 45
48 /* Put a cap on duration for this - if the player fails in their 46 /* Put a cap on duration for this - if the player fails in their
49 * apartment, don't want it to go on so long that it kills them 47 * apartment, don't want it to go on so long that it kills them
50 * multiple times. Also, damge already increases with level, 48 * multiple times. Also, damge already increases with level,
51 * so don't really need to increase the duration as much either. 49 * so don't really need to increase the duration as much either.
52 */ 50 */
53 if (tmp->duration >= 40) 51 if (tmp->duration >= 40)
54 tmp->duration = 40; 52 tmp->duration = 40;
53
55 tmp->stats.dam = lvl; /* nasty recoils! */ 54 tmp->stats.dam = lvl; /* nasty recoils! */
56 tmp->stats.maxhp = tmp->count; /* tract single parent */ 55 tmp->stats.maxhp = tmp->count; /* tract single parent */
57 insert_ob_in_map (tmp, op->map, op, 0);
58 56
57 tmp->insert_at (op, op);
59} 58}
60
61 59
62int 60int
63recharge (object *op, object *caster, object *spell_ob) 61recharge (object *op, object *caster, object *spell_ob)
64{ 62{
65 object *wand, *tmp; 63 object *wand, *tmp;
… …
74 if (!(random_roll (0, 3, op, PREFER_HIGH))) 72 if (!(random_roll (0, 3, op, PREFER_HIGH)))
75 { 73 {
76 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand)); 74 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
77 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE); 75 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE);
78 esrv_del_item (op->contr, wand->count); 76 esrv_del_item (op->contr, wand->count);
79 wand->remove ();
80 wand->destroy (0); 77 wand->destroy ();
81 tmp = get_archetype ("fireball"); 78 tmp = get_archetype ("fireball");
82 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 79 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
80
83 if (!tmp->stats.dam) 81 if (!tmp->stats.dam)
84 tmp->stats.dam = 1; 82 tmp->stats.dam = 1;
83
85 tmp->stats.hp = tmp->stats.dam / 2; 84 tmp->stats.hp = tmp->stats.dam / 2;
85
86 if (tmp->stats.hp < 2) 86 if (tmp->stats.hp < 2)
87 tmp->stats.hp = 2; 87 tmp->stats.hp = 2;
88 tmp->x = op->x; 88
89 tmp->y = op->y; 89 tmp->insert_at (op);
90 insert_ob_in_map (tmp, op->map, NULL, 0);
91 return 1; 90 return 1;
92 } 91 }
93 92
94 ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)); 93 ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob));
94
95 if (wand->inv && wand->inv->level) 95 if (wand->inv && wand->inv->level)
96 ncharges /= wand->inv->level; 96 ncharges /= wand->inv->level;
97 else 97 else
98 { 98 {
99 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand)); 99 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));
100 return 0; 100 return 0;
101 } 101 }
102
102 if (!ncharges) 103 if (!ncharges)
103 ncharges = 1; 104 ncharges = 1;
104 105
105 wand->stats.food += ncharges; 106 wand->stats.food += ncharges;
106 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand)); 107 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
108
107 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE)) 109 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE))
108 { 110 {
109 SET_FLAG (wand, FLAG_ANIMATE); 111 SET_FLAG (wand, FLAG_ANIMATE);
110 wand->speed = wand->arch->clone.speed; 112 wand->set_speed (wand->arch->clone.speed);
111 update_ob_speed (wand);
112 } 113 }
114
113 return 1; 115 return 1;
114} 116}
115 117
116/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows 118/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows
117 * based on whether a crossbow or bow is equiped. If neither, it defaults to 119 * based on whether a crossbow or bow is equiped. If neither, it defaults to
… …
152 /* If it starts with a letter, presume it is a description */ 154 /* If it starts with a letter, presume it is a description */
153 if (isalpha (*stringarg)) 155 if (isalpha (*stringarg))
154 { 156 {
155 artifact *al = find_artifactlist (missile->type)->items; 157 artifact *al = find_artifactlist (missile->type)->items;
156 158
157 for (; al != NULL; al = al->next) 159 for (; al; al = al->next)
158 if (!strcasecmp (al->item->name, stringarg)) 160 if (!strcasecmp (al->item->name, stringarg))
159 break; 161 break;
160 162
161 if (!al) 163 if (!al)
162 { 164 {
163 missile->destroy (0); 165 missile->destroy ();
164 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg); 166 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg);
165 return 0; 167 return 0;
166 } 168 }
167 169
168 if (al->item->slaying) 170 if (al->item->slaying)
169 { 171 {
170 missile->destroy (0); 172 missile->destroy ();
171 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg); 173 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);
172 return 0; 174 return 0;
173 } 175 }
174 176
175 give_artifact_abilities (missile, al->item); 177 give_artifact_abilities (missile, al->item);
… …
303 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic."); 305 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
304 return 0; 306 return 0;
305 } 307 }
306 if (mflags & P_IS_ALIVE) 308 if (mflags & P_IS_ALIVE)
307 { 309 {
308 for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = tmp->above) 310 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
309 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 311 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
310 { 312 {
311 new_draw_info (NDI_UNIQUE, 0, op, "You detect something."); 313 new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
312 if (tmp->head != NULL) 314 if (tmp->head != NULL)
313 tmp = tmp->head; 315 tmp = tmp->head;
… …
371 * normal applies. 373 * normal applies.
372 */ 374 */
373int 375int
374cast_invisible (object *op, object *caster, object *spell_ob) 376cast_invisible (object *op, object *caster, object *spell_ob)
375{ 377{
376 object *tmp;
377
378 if (op->invisible > 1000) 378 if (op->invisible > 1000)
379 { 379 {
380 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further"); 380 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");
381 return 0; 381 return 0;
382 } 382 }
… …
398 else 398 else
399 op->contr->tmp_invis = 1; 399 op->contr->tmp_invis = 1;
400 400
401 op->contr->hidden = 0; 401 op->contr->hidden = 0;
402 } 402 }
403
403 if (makes_invisible_to (op, op)) 404 if (makes_invisible_to (op, op))
404 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!"); 405 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
405 else 406 else
406 new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!"); 407 new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");
407 408
408 update_object (op, UP_OBJ_FACE); 409 update_object (op, UP_OBJ_CHANGE);
409 410
410 /* Only search the active objects - only these should actually do 411 /* Only search the active objects - only these should actually do
411 * harm to the player. 412 * harm to the player.
412 */ 413 */
413 for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next) 414 for_all_actives (tmp)
414 if (tmp->enemy == op) 415 if (tmp->enemy == op)
415 tmp->enemy = NULL; 416 tmp->enemy = 0;
417
416 return 1; 418 return 1;
417} 419}
418 420
419/* earth to dust spell. Basically destroys earthwalls in the area. 421/* earth to dust spell. Basically destroys earthwalls in the area.
420 */ 422 */
… …
441 443
442 if (mflags & P_OUT_OF_MAP) 444 if (mflags & P_OUT_OF_MAP)
443 continue; 445 continue;
444 446
445 // earth to dust tears down everything that can be teared down 447 // earth to dust tears down everything that can be teared down
446 for (tmp = get_map_ob (m, sx, sy); tmp != NULL; tmp = next) 448 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
447 { 449 {
448 next = tmp->above; 450 next = tmp->above;
449 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 451 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
450 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 452 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
451 } 453 }
452 } 454 }
455
453 return 1; 456 return 1;
454} 457}
455
456 458
457void 459void
458execute_word_of_recall (object *op) 460execute_word_of_recall (object *op)
459{ 461{
460 object *wor = op; 462 if (object *pl = op->in_player ())
461 463 {
462 while (op != NULL && op->type != PLAYER) 464 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
463 op = op->env;
464
465 if (op != NULL && op->map)
466 if ((get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) && (!QUERY_FLAG (op, FLAG_WIZCAST)))
467 new_draw_info (NDI_UNIQUE, 0, op, "You feel something fizzle inside you."); 465 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
468 else 466 else
467 {
468 // remove first so we do not call update_stats
469 op->remove ();
469 enter_exit (op, wor); 470 pl->enter_exit (op);
471 }
472 }
470 473
471 wor->remove ();
472 wor->destroy (0); 474 op->destroy ();
473} 475}
474 476
475/* Word of recall causes the player to return 'home'. 477/* Word of recall causes the player to return 'home'.
476 * we put a force into the player object, so that there is a 478 * we put a force into the player object, so that there is a
477 * time delay effect. 479 * time delay effect.
… …
496 { 498 {
497 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 499 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
498 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n"); 500 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
499 return 0; 501 return 0;
500 } 502 }
503
501 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob); 504 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
502 if (time < 1) 505 if (time < 1)
503 time = 1; 506 time = 1;
504 507
505 /* value of speed really doesn't make much difference, as long as it is 508 /* value of speed really doesn't make much difference, as long as it is
506 * positive. Lower value may be useful so that the problem doesn't 509 * positive. Lower value may be useful so that the problem doesn't
507 * do anything really odd if it say a -1000 or something. 510 * do anything really odd if it say a -1000 or something.
508 */ 511 */
509 dummy->speed = 0.002; 512 dummy->set_speed (0.002);
510 update_ob_speed (dummy);
511 dummy->speed_left = -dummy->speed * time; 513 dummy->speed_left = -dummy->speed * time;
512 dummy->type = SPELL_EFFECT; 514 dummy->type = SPELL_EFFECT;
513 dummy->subtype = SP_WORD_OF_RECALL; 515 dummy->subtype = SP_WORD_OF_RECALL;
514 516
515 /* If we could take advantage of enter_player_savebed() here, it would be 517 /* If we could take advantage of enter_player_savebed() here, it would be
516 * nice, but until the map load fails, we can't. 518 * nice, but until the map load fails, we can't.
517 */ 519 */
518 EXIT_PATH (dummy) = op->contr->savebed_map; 520 EXIT_PATH (dummy) = op->contr->savebed_map;
519 EXIT_X (dummy) = op->contr->bed_x; 521 EXIT_X (dummy) = op->contr->bed_x;
520 EXIT_Y (dummy) = op->contr->bed_y; 522 EXIT_Y (dummy) = op->contr->bed_y;
521 523
522 (void) insert_ob_in_ob (dummy, op); 524 op->insert (dummy);
525
523 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 526 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
527
524 return 1; 528 return 1;
525} 529}
526 530
527/* cast_wonder 531/* cast_wonder
528 * wonder is really just a spell that will likely cast another 532 * wonder is really just a spell that will likely cast another
… …
558 return cast_spell (op, caster, dir, newspell, NULL); 562 return cast_spell (op, caster, dir, newspell, NULL);
559 } 563 }
560 return 1; 564 return 1;
561} 565}
562 566
563
564int 567int
565perceive_self (object *op) 568perceive_self (object *op)
566{ 569{
570 char buf[MAX_BUF];
567 char *cp = describe_item (op, op), buf[MAX_BUF]; 571 const char *cp = describe_item (op, op);
568 archetype *at = archetype::find (ARCH_DEPLETION); 572 archetype *at = archetype::find (ARCH_DEPLETION);
569 object *tmp; 573 object *tmp;
570 int i; 574 int i;
571 575
572 tmp = find_god (determine_god (op)); 576 tmp = find_god (determine_god (op));
… …
581 new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane"); 585 new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane");
582 else 586 else
583 { 587 {
584 new_draw_info (NDI_UNIQUE, 0, op, "You have:"); 588 new_draw_info (NDI_UNIQUE, 0, op, "You have:");
585 new_draw_info (NDI_UNIQUE, 0, op, cp); 589 new_draw_info (NDI_UNIQUE, 0, op, cp);
590
586 if (tmp != NULL) 591 if (tmp)
587 {
588 for (i = 0; i < NUM_STATS; i++) 592 for (i = 0; i < NUM_STATS; i++)
589 { 593 if (tmp->stats.stat (i) < 0)
590 if (get_attr_value (&tmp->stats, i) < 0)
591 {
592 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -(get_attr_value (&tmp->stats, i))); 594 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -tmp->stats.stat (i));
593 }
594 }
595 }
596 } 595 }
597 596
598 if (is_dragon_pl (op)) 597 if (is_dragon_pl (op))
599 { 598 {
600 /* now grab the 'dragon_ability'-force from the player's inventory */ 599 /* now grab the 'dragon_ability'-force from the player's inventory */
601 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 600 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
602 { 601 {
603 if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force")) 602 if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))
604 { 603 {
605 if (tmp->stats.exp == 0) 604 if (tmp->stats.exp == 0)
606 {
607 sprintf (buf, "Your metabolism isn't focused on anything."); 605 sprintf (buf, "Your metabolism isn't focused on anything.");
608 }
609 else 606 else
610 {
611 sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]); 607 sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]);
612 } 608
613 new_draw_info (NDI_UNIQUE, 0, op, buf); 609 new_draw_info (NDI_UNIQUE, 0, op, buf);
614 break; 610 break;
615 } 611 }
616 } 612 }
617 } 613 }
614
618 return 1; 615 return 1;
619} 616}
620 617
621/* int cast_create_town_portal (object *op, object *caster, int dir) 618/* int cast_create_town_portal (object *op, object *caster, int dir)
622 * 619 *
… …
636 * Code by Tchize (david.delbecq@usa.net) 633 * Code by Tchize (david.delbecq@usa.net)
637 */ 634 */
638int 635int
639cast_create_town_portal (object *op, object *caster, object *spell, int dir) 636cast_create_town_portal (object *op, object *caster, object *spell, int dir)
640{ 637{
641 object *dummy, *force, *old_force, *tmp; 638 object *dummy, *force, *old_force;
642 archetype *perm_portal; 639 archetype *perm_portal;
643 char portal_name[1024], portal_message[1024]; 640 char portal_name[1024], portal_message[1024];
644 sint16 exitx, exity;
645 maptile *exitmap; 641 maptile *exitmap;
646 int op_level; 642 int op_level;
647 643
648
649 /* Check to see if the map the player is currently on is a per player unique
650 * map. This can be determined in that per player unique maps have the
651 * full pathname listed.
652 */
653 if (!strncmp (op->map->path, settings.localdir, strlen (settings.localdir)) && settings.create_home_portals != TRUE)
654 {
655 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You can't cast that here.\n");
656 return 0;
657 }
658
659 /* The first thing to do is to check if we have a marked destination 644 /* The first thing to do is to check if we have a marked destination
660 * dummy is used to make a check inventory for the force 645 * dummy is used to make a check inventory for the force
661 */ 646 */
662 dummy = arch_to_object (spell->other_arch); 647 dummy = arch_to_object (spell->other_arch);
663 if (dummy == NULL) 648 if (dummy == NULL)
664 { 649 {
665 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 650 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
666 LOG (llevError, "get_object failed (force in cast_create_town_portal for %s!\n", &op->name); 651 LOG (llevError, "object::create failed (force in cast_create_town_portal for %s!\n", &op->name);
667 return 0; 652 return 0;
668 } 653 }
654
669 force = check_inv_recursive (op, dummy); 655 force = check_inv_recursive (op, dummy);
670 656
671 if (force == NULL) 657 if (force == NULL)
672 { 658 {
673 /* Here we know there is no destination marked up. 659 /* Here we know there is no destination marked up.
… …
677 */ 663 */
678 dummy->name = op->map->path; 664 dummy->name = op->map->path;
679 EXIT_X (dummy) = op->x; 665 EXIT_X (dummy) = op->x;
680 EXIT_Y (dummy) = op->y; 666 EXIT_Y (dummy) = op->y;
681 insert_ob_in_ob (dummy, op); 667 insert_ob_in_ob (dummy, op);
682 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You fix this place in your mind.\nYou feel you are able to come here from anywhere."); 668 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You fix this place in your mind. You feel you are able to come here from anywhere.");
683 return 1; 669 return 1;
684 } 670 }
671
685 dummy->destroy (0); 672 dummy->destroy ();
686 673
687 /* Here we know where the town portal should go to 674 /* Here we know where the town portal should go to
688 * We should kill any existing portal associated with the player. 675 * We should kill any existing portal associated with the player.
689 * Than we should create the 2 portals. 676 * Than we should create the 2 portals.
690 * For each of them, we need: 677 * For each of them, we need:
… …
703 /* First step: killing existing town portals */ 690 /* First step: killing existing town portals */
704 dummy = get_archetype (spell->race); 691 dummy = get_archetype (spell->race);
705 if (dummy == NULL) 692 if (dummy == NULL)
706 { 693 {
707 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 694 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
708 LOG (llevError, "get_object failed (force) in cast_create_town_portal for %s!\n", &op->name); 695 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
709 return 0; 696 return 0;
710 } 697 }
698
711 perm_portal = archetype::find (spell->slaying); 699 perm_portal = archetype::find (spell->slaying);
712 700
713 /* To kill a town portal, we go trough the player's inventory, 701 /* To kill a town portal, we go trough the player's inventory,
714 * for each marked portal in player's inventory, 702 * for each marked portal in player's inventory,
715 * -We try load the associated map (if impossible, consider the portal destructed) 703 * -We try load the associated map (if impossible, consider the portal destructed)
… …
717 * If it has the good name, we destruct it. 705 * If it has the good name, we destruct it.
718 * -We destruct the force indicating that portal. 706 * -We destruct the force indicating that portal.
719 */ 707 */
720 while ((old_force = check_inv_recursive (op, dummy))) 708 while ((old_force = check_inv_recursive (op, dummy)))
721 { 709 {
722 exitx = EXIT_X (old_force); 710 exitmap = maptile::find_sync (old_force->race, op->map);
723 exity = EXIT_Y (old_force);
724 LOG (llevDebug, "Trying to kill a portal in %s (%d,%d)\n", &old_force->race, exitx, exity);
725
726 if (!strncmp (old_force->race, settings.localdir, strlen (settings.localdir)))
727 exitmap = ready_map_name (old_force->race, MAP_PLAYER_UNIQUE);
728 else
729 exitmap = ready_map_name (old_force->race, 0);
730 711
731 if (exitmap) 712 if (exitmap)
732 { 713 {
714 exitmap->load_sync ();
715
716 int exitx = EXIT_X (old_force);
717 int exity = EXIT_Y (old_force);
718
733 tmp = present_arch (perm_portal, exitmap, exitx, exity); 719 for (object *tmp = present_arch (perm_portal, exitmap, exitx, exity); tmp; tmp = tmp->above)
734 while (tmp)
735 { 720 {
736 if (tmp->name == old_force->name) 721 if (tmp->name == old_force->name)
737 { 722 {
738 tmp->remove ();
739 tmp->destroy (0); 723 tmp->destroy ();
740 break; 724 break;
741 } 725 }
742 else
743 {
744 tmp = tmp->above;
745 }
746 } 726 }
747 } 727 }
748 old_force->remove (); 728
749 old_force->destroy (0); 729 old_force->destroy ();
750 LOG (llevDebug, "\n");
751 } 730 }
731
752 dummy->destroy (0); 732 dummy->destroy ();
753 733
754 /* Creating the portals. 734 /* Creating the portals.
755 * The very first thing to do is to ensure 735 * The very first thing to do is to ensure
756 * access to the destination map. 736 * access to the destination map.
757 * If we can't, don't fizzle. Simply warn player. 737 * If we can't, don't fizzle. Simply warn player.
… …
760 * 'force' is the destination of the town portal, which we got 740 * 'force' is the destination of the town portal, which we got
761 * from the players inventory above. 741 * from the players inventory above.
762 */ 742 */
763 743
764 /* Ensure exit map is loaded */ 744 /* Ensure exit map is loaded */
765 if (!strncmp (force->name, settings.localdir, strlen (settings.localdir))) 745 exitmap = maptile::find_sync (force->name);
766 exitmap = ready_map_name (force->name, MAP_PLAYER_UNIQUE);
767 else
768 exitmap = ready_map_name (force->name, 0);
769 746
770 /* If we were unable to load (ex. random map deleted), warn player */ 747 /* If we were unable to load (ex. random map deleted), warn player */
771 if (exitmap == NULL) 748 if (!exitmap)
772 { 749 {
773 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?"); 750 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens. You can't remember where to go!?");
774 force->remove ();
775 force->destroy (0); 751 force->destroy ();
776 return 1; 752 return 1;
777 } 753 }
754
755 exitmap->load_sync ();
778 756
779 op_level = caster_level (caster, spell); 757 op_level = caster_level (caster, spell);
780 if (op_level < 15) 758 if (op_level < 15)
781 snprintf (portal_message, 1024, 759 snprintf (portal_message, 1024,
782 "\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n", 760 "The air moves around you and a huge smell of ammonia surounds you as you pass through %s's tiny portal. Pouah!\n",
783 &op->name); 761 &op->name);
784 else if (op_level < 30) 762 else if (op_level < 30)
785 snprintf (portal_message, 1024, 763 snprintf (portal_message, 1024,
786 "\n%s's portal smells of ozone.\nYou do a lot of movements and finally pass\nthrough the small hole in the air\n", &op->name); 764 "%s's portal smells of ozone. You do a lot of movements and finally pass through the small hole in the air\n", &op->name);
787 else if (op_level < 60) 765 else if (op_level < 60)
788 snprintf (portal_message, 1024, "\nA shining door opens in the air in front of you,\nshowing you the path to another place.\n"); 766 snprintf (portal_message, 1024, "A shining door opens in the air in front of you, showing you the path to another place.\n");
789 else 767 else
790 snprintf (portal_message, 1024, "\nAs you walk through %s's portal, flowers come out\nfrom the ground around you.\nYou feel awed.\n", 768 snprintf (portal_message, 1024, "As you walk through %s's portal, flowers come out from the ground around you. You feel awed.\n",
791 &op->name); 769 &op->name);
792 770
793 /* Create a portal in front of player 771 /* Create a portal in front of player
794 * dummy contain the portal and 772 * dummy contain the portal and
795 * force contain the track to kill it later 773 * force contain the track to kill it later
796 */ 774 */
797
798 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name); 775 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
799 dummy = get_archetype (spell->slaying); /*The portal */ 776 dummy = get_archetype (spell->slaying); /*The portal */
800 if (dummy == NULL) 777 if (dummy == NULL)
801 { 778 {
802 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 779 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
803 LOG (llevError, "get_object failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name); 780 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
804 return 0; 781 return 0;
805 } 782 }
783
806 EXIT_PATH (dummy) = force->name; 784 EXIT_PATH (dummy) = force->name;
807 EXIT_X (dummy) = EXIT_X (force); 785 EXIT_X (dummy) = EXIT_X (force);
808 EXIT_Y (dummy) = EXIT_Y (force); 786 EXIT_Y (dummy) = EXIT_Y (force);
809 dummy->name = dummy->name_pl = portal_name; 787 dummy->name = dummy->name_pl = portal_name;
810 dummy->msg = portal_message; 788 dummy->msg = portal_message;
… …
813 791
814 /* Now we need to to create a town portal marker inside the player 792 /* Now we need to to create a town portal marker inside the player
815 * object, so on future castings, we can know that he has an active 793 * object, so on future castings, we can know that he has an active
816 * town portal. 794 * town portal.
817 */ 795 */
818 tmp = get_archetype (spell->race); 796 object *tmp = get_archetype (spell->race);
819 if (tmp == NULL) 797
798 if (!tmp)
820 { 799 {
821 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 800 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
822 LOG (llevError, "get_object failed (force) in cast_create_town_portal for %s!\n", &op->name); 801 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
823 return 0; 802 return 0;
824 } 803 }
804
825 tmp->race = op->map->path; 805 tmp->race = op->map->path;
826 tmp->name = portal_name; 806 tmp->name = portal_name;
827 EXIT_X (tmp) = dummy->x; 807 EXIT_X (tmp) = dummy->x;
828 EXIT_Y (tmp) = dummy->y; 808 EXIT_Y (tmp) = dummy->y;
829 insert_ob_in_ob (tmp, op); 809 op->insert (tmp);
830 810
831 /* Create a portal in the destination map 811 /* Create a portal in the destination map
832 * dummy contain the portal and 812 * dummy contain the portal and
833 * force the track to kill it later 813 * force the track to kill it later
834 * the 'force' variable still contains the 'reminder' of 814 * the 'force' variable still contains the 'reminder' of
835 * where this portal goes to. 815 * where this portal goes to.
836 */ 816 */
837 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, op->map->path); 817 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &op->map->path);
838 dummy = get_archetype (spell->slaying); /*The portal */ 818 dummy = get_archetype (spell->slaying); /*The portal */
839 if (dummy == NULL) 819 if (dummy == NULL)
840 { 820 {
841 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 821 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
842 LOG (llevError, "get_object failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name); 822 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
843 return 0; 823 return 0;
844 } 824 }
825
845 EXIT_PATH (dummy) = op->map->path; 826 EXIT_PATH (dummy) = op->map->path;
846 EXIT_X (dummy) = op->x; 827 EXIT_X (dummy) = op->x;
847 EXIT_Y (dummy) = op->y; 828 EXIT_Y (dummy) = op->y;
848 dummy->name = dummy->name_pl = portal_name; 829 dummy->name = dummy->name_pl = portal_name;
849 dummy->msg = portal_message; 830 dummy->msg = portal_message;
850 dummy->x = EXIT_X (force);
851 dummy->y = EXIT_Y (force);
852 dummy->race = op->name; /*Save the owner of the portal */ 831 dummy->race = op->name; /*Save the owner of the portal */
853 insert_ob_in_map (dummy, exitmap, op, 0); 832 exitmap->insert (dummy, EXIT_X (force), EXIT_Y (force), op);
854 833
855 /* Now we create another town portal marker that 834 /* Now we create another town portal marker that
856 * points back to the one we just made 835 * points back to the one we just made
857 */ 836 */
858 tmp = get_archetype (spell->race); 837 tmp = get_archetype (spell->race);
859 if (tmp == NULL) 838 if (tmp == NULL)
860 { 839 {
861 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 840 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
862 LOG (llevError, "get_object failed (force) in cast_create_town_portal for %s!\n", &op->name); 841 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
863 return 0; 842 return 0;
864 } 843 }
844
865 tmp->race = force->name; 845 tmp->race = force->name;
866 tmp->name = portal_name; 846 tmp->name = portal_name;
867 EXIT_X (tmp) = dummy->x; 847 EXIT_X (tmp) = dummy->x;
868 EXIT_Y (tmp) = dummy->y; 848 EXIT_Y (tmp) = dummy->y;
869 insert_ob_in_ob (tmp, op); 849 insert_ob_in_ob (tmp, op);
870 850
871 /* Describe the player what happened 851 /* Describe the player what happened
872 */ 852 */
873 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home."); 853 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
874 force->remove (); /* Delete the force inside the player */
875 force->destroy (0); 854 force->destroy ();
855
876 return 1; 856 return 1;
877} 857}
878
879 858
880/* This creates magic walls. Really, it can create most any object, 859/* This creates magic walls. Really, it can create most any object,
881 * within some reason. 860 * within some reason.
882 */ 861 */
883
884int 862int
885magic_wall (object *op, object *caster, int dir, object *spell_ob) 863magic_wall (object *op, object *caster, int dir, object *spell_ob)
886{ 864{
887 object *tmp, *tmp2; 865 object *tmp;
888 int i, posblocked, negblocked, maxrange; 866 int i, posblocked, negblocked, maxrange;
889 sint16 x, y; 867 sint16 x, y;
890 maptile *m; 868 maptile *m;
891 const char *name; 869 const char *name;
892 archetype *at; 870 archetype *at;
… …
900 else 878 else
901 { 879 {
902 x = op->x + freearr_x[dir]; 880 x = op->x + freearr_x[dir];
903 y = op->y + freearr_y[dir]; 881 y = op->y + freearr_y[dir];
904 } 882 }
883
905 m = op->map; 884 m = op->map;
906 885
907 if ((spell_ob->move_block || x != op->x || y != op->y) && 886 if ((spell_ob->move_block || x != op->x || y != op->y) &&
908 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) || 887 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
909 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block))) 888 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
910 { 889 {
911 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 890 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
912 return 0; 891 return 0;
913 } 892 }
893
914 if (spell_ob->other_arch) 894 if (spell_ob->other_arch)
915 {
916 tmp = arch_to_object (spell_ob->other_arch); 895 tmp = arch_to_object (spell_ob->other_arch);
917 }
918 else if (spell_ob->race) 896 else if (spell_ob->race)
919 { 897 {
920 char buf1[MAX_BUF]; 898 char buf1[MAX_BUF];
921 899
922 sprintf (buf1, spell_ob->race, dir); 900 sprintf (buf1, spell_ob->race, dir);
… …
925 { 903 {
926 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1); 904 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
927 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken."); 905 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
928 return 0; 906 return 0;
929 } 907 }
908
930 tmp = arch_to_object (at); 909 tmp = arch_to_object (at);
931 } 910 }
932 else 911 else
933 { 912 {
934 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name); 913 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
… …
944 } 923 }
945 else if (QUERY_FLAG (tmp, FLAG_ALIVE)) 924 else if (QUERY_FLAG (tmp, FLAG_ALIVE))
946 { 925 {
947 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 926 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
948 tmp->stats.maxhp = tmp->stats.hp; 927 tmp->stats.maxhp = tmp->stats.hp;
949 set_owner (tmp, op);
950 set_spell_skill (op, caster, spell_ob, tmp);
951 } 928 }
929
952 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP)) 930 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP))
953 { 931 {
954 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 932 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
955 SET_FLAG (tmp, FLAG_IS_USED_UP); 933 SET_FLAG (tmp, FLAG_IS_USED_UP);
956 } 934 }
935
957 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN)) 936 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN))
958 { 937 {
959 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 938 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
960 tmp->stats.maxhp = tmp->stats.hp; 939 tmp->stats.maxhp = tmp->stats.hp;
961 SET_FLAG (tmp, FLAG_TEAR_DOWN); 940 SET_FLAG (tmp, FLAG_TEAR_DOWN);
962 SET_FLAG (tmp, FLAG_ALIVE); 941 SET_FLAG (tmp, FLAG_ALIVE);
963 } 942 }
964 943
965 /* This can't really hurt - if the object doesn't kill anything, 944 /* This can't really hurt - if the object doesn't kill anything,
966 * these fields just won't be used. 945 * these fields just won't be used. Do not set the owner for
946 * earthwalls, though, so they survive restarts.
967 */ 947 */
968 set_owner (tmp, op); 948 if (tmp->type != EARTHWALL) //TODO
949 tmp->set_owner (op);
950
969 set_spell_skill (op, caster, spell_ob, tmp); 951 set_spell_skill (op, caster, spell_ob, tmp);
970 tmp->x = x;
971 tmp->y = y;
972 tmp->level = caster_level (caster, spell_ob) / 2; 952 tmp->level = caster_level (caster, spell_ob) / 2;
973 953
974 name = tmp->name; 954 name = tmp->name;
975 if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL) 955 if (!(tmp = m->insert (tmp, x, y, op)))
976 { 956 {
977 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 957 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
978 return 0; 958 return 0;
979 } 959 }
960
980 /* If this is a spellcasting wall, need to insert the spell object */ 961 /* If this is a spellcasting wall, need to insert the spell object */
981 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL) 962 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)
982 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 963 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
983 964
984 /* This code causes the wall to extend some distance in 965 /* This code causes the wall to extend some distance in
… …
1002 m = tmp->map; 983 m = tmp->map;
1003 984
1004 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 985 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1005 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked) 986 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
1006 { 987 {
1007 tmp2 = get_object (); 988 object *tmp2 = tmp->clone ();
1008 copy_object (tmp, tmp2); 989 m->insert (tmp2, x, y, op);
1009 tmp2->x = x; 990
1010 tmp2->y = y;
1011 insert_ob_in_map (tmp2, m, op, 0);
1012 /* If this is a spellcasting wall, need to insert the spell object */ 991 /* If this is a spellcasting wall, need to insert the spell object */
1013 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 992 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)
1014 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 993 tmp2->insert (arch_to_object (tmp2->other_arch));
1015 994
1016 } 995 }
1017 else 996 else
1018 posblocked = 1; 997 posblocked = 1;
1019 998
… …
1022 m = tmp->map; 1001 m = tmp->map;
1023 1002
1024 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 1003 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1025 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked) 1004 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1026 { 1005 {
1027 tmp2 = get_object (); 1006 object *tmp2 = tmp->clone ();
1028 copy_object (tmp, tmp2); 1007 m->insert (tmp2, x, y, op);
1029 tmp2->x = x; 1008
1030 tmp2->y = y;
1031 insert_ob_in_map (tmp2, m, op, 0);
1032 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 1009 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)
1033 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 1010 tmp2->insert (arch_to_object (tmp2->other_arch));
1034 } 1011 }
1035 else 1012 else
1036 negblocked = 1; 1013 negblocked = 1;
1037 } 1014 }
1038 1015
… …
1087 { 1064 {
1088 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n"); 1065 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
1089 op->contr->count = 0; 1066 op->contr->count = 0;
1090 return 0; 1067 return 0;
1091 } 1068 }
1069
1092 op->contr->count = 0; 1070 op->contr->count = 0;
1093 1071
1094 /* Remove code that puts player on random space on maps. IMO, 1072 /* Remove code that puts player on random space on maps. IMO,
1095 * a lot of maps probably have areas the player should not get to, 1073 * a lot of maps probably have areas the player should not get to,
1096 * but may not be marked as NO_MAGIC (as they may be bounded 1074 * but may not be marked as NO_MAGIC (as they may be bounded
… …
1145 return 0; 1123 return 0;
1146 } 1124 }
1147 } 1125 }
1148 1126
1149 /* Actually move the player now */ 1127 /* Actually move the player now */
1150 op->remove (); 1128 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
1151 op->x += freearr_x[dir] * dist;
1152 op->y += freearr_y[dir] * dist;
1153 if ((op = insert_ob_in_map (op, op->map, op, 0)) == NULL)
1154 return 1; 1129 return 1;
1155 1130
1156 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 1131 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1157 return 1; 1132 return 1;
1158} 1133}
… …
1171 object *poison; 1146 object *poison;
1172 int heal = 0, success = 0; 1147 int heal = 0, success = 0;
1173 1148
1174 tmp = find_target_for_friendly_spell (op, dir); 1149 tmp = find_target_for_friendly_spell (op, dir);
1175 1150
1176 if (tmp == NULL) 1151 if (!tmp)
1177 return 0; 1152 return 0;
1178 1153
1179 /* Figure out how many hp this spell might cure. 1154 /* Figure out how many hp this spell might cure.
1180 * could be zero if this spell heals effects, not damage. 1155 * could be zero if this spell heals effects, not damage.
1181 */ 1156 */
… …
1184 heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp; 1159 heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;
1185 1160
1186 if (heal) 1161 if (heal)
1187 { 1162 {
1188 if (tmp->stats.hp >= tmp->stats.maxhp) 1163 if (tmp->stats.hp >= tmp->stats.maxhp)
1189 {
1190 new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed."); 1164 new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");
1191 }
1192 else 1165 else
1193 { 1166 {
1194 /* See how many points we actually heal. Instead of messages 1167 /* See how many points we actually heal. Instead of messages
1195 * based on type of spell, we instead do messages based 1168 * based on type of spell, we instead do messages based
1196 * on amount of damage healed. 1169 * on amount of damage healed.
… …
1198 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 1171 if (heal > (tmp->stats.maxhp - tmp->stats.hp))
1199 heal = tmp->stats.maxhp - tmp->stats.hp; 1172 heal = tmp->stats.maxhp - tmp->stats.hp;
1200 tmp->stats.hp += heal; 1173 tmp->stats.hp += heal;
1201 1174
1202 if (tmp->stats.hp >= tmp->stats.maxhp) 1175 if (tmp->stats.hp >= tmp->stats.maxhp)
1203 {
1204 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 1176 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1205 }
1206 else if (heal > 50) 1177 else if (heal > 50)
1207 {
1208 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!"); 1178 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
1209 }
1210 else if (heal > 25) 1179 else if (heal > 25)
1211 {
1212 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close."); 1180 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
1213 }
1214 else if (heal > 10) 1181 else if (heal > 10)
1215 {
1216 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade."); 1182 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");
1217 }
1218 else 1183 else
1219 {
1220 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close."); 1184 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");
1221 } 1185
1222 success = 1; 1186 success = 1;
1223 } 1187 }
1224 } 1188 }
1189
1225 if (spell->attacktype & AT_DISEASE) 1190 if (spell->attacktype & AT_DISEASE)
1226 if (cure_disease (tmp, op)) 1191 if (cure_disease (tmp, op))
1227 success = 1; 1192 success = 1;
1228 1193
1229 if (spell->attacktype & AT_POISON) 1194 if (spell->attacktype & AT_POISON)
… …
1235 success = 1; 1200 success = 1;
1236 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed"); 1201 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
1237 poison->stats.food = 1; 1202 poison->stats.food = 1;
1238 } 1203 }
1239 } 1204 }
1205
1240 if (spell->attacktype & AT_CONFUSION) 1206 if (spell->attacktype & AT_CONFUSION)
1241 { 1207 {
1242 poison = present_in_ob_by_name (FORCE, "confusion", tmp); 1208 poison = present_in_ob_by_name (FORCE, "confusion", tmp);
1243 if (poison) 1209 if (poison)
1244 { 1210 {
1245 success = 1; 1211 success = 1;
1246 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 1212 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
1247 poison->duration = 1; 1213 poison->duration = 1;
1248 } 1214 }
1249 } 1215 }
1216
1250 if (spell->attacktype & AT_BLIND) 1217 if (spell->attacktype & AT_BLIND)
1251 { 1218 {
1252 at = archetype::find ("blindness"); 1219 at = archetype::find ("blindness");
1253 poison = present_arch_in_ob (at, tmp); 1220 poison = present_arch_in_ob (at, tmp);
1254 if (poison) 1221 if (poison)
… …
1256 success = 1; 1223 success = 1;
1257 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return."); 1224 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
1258 poison->stats.food = 1; 1225 poison->stats.food = 1;
1259 } 1226 }
1260 } 1227 }
1228
1261 if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp) 1229 if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
1262 { 1230 {
1263 tmp->stats.sp += spell->last_sp; 1231 tmp->stats.sp += spell->last_sp;
1264 if (tmp->stats.sp > tmp->stats.maxsp) 1232 if (tmp->stats.sp > tmp->stats.maxsp)
1265 tmp->stats.sp = tmp->stats.maxsp; 1233 tmp->stats.sp = tmp->stats.maxsp;
1266 success = 1; 1234 success = 1;
1267 new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!"); 1235 new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");
1268 } 1236 }
1237
1269 if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace) 1238 if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
1270 { 1239 {
1271 tmp->stats.grace += spell->last_grace; 1240 tmp->stats.grace += spell->last_grace;
1272 if (tmp->stats.grace > tmp->stats.maxgrace) 1241 if (tmp->stats.grace > tmp->stats.maxgrace)
1273 tmp->stats.grace = tmp->stats.maxgrace; 1242 tmp->stats.grace = tmp->stats.maxgrace;
1274 success = 1; 1243 success = 1;
1275 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!"); 1244 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1276 } 1245 }
1246
1277 if (spell->stats.food && tmp->stats.food < 999) 1247 if (spell->stats.food && tmp->stats.food < 999)
1278 { 1248 {
1279 tmp->stats.food += spell->stats.food; 1249 tmp->stats.food += spell->stats.food;
1280 if (tmp->stats.food > 999) 1250 if (tmp->stats.food > 999)
1281 tmp->stats.food = 999; 1251 tmp->stats.food = 999;
1282 success = 1; 1252 success = 1;
1283 /* We could do something a bit better like the messages for healing above */ 1253 /* We could do something a bit better like the messages for healing above */
1284 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1254 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1285 } 1255 }
1256
1286 return success; 1257 return success;
1287} 1258}
1288 1259
1289 1260
1290/* This is used for the spells that gain stats. There are no spells 1261/* This is used for the spells that gain stats. There are no spells
… …
1302}; 1273};
1303 1274
1304int 1275int
1305cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1276cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1306{ 1277{
1307 object *tmp, *tmp2 = NULL;
1308 object *force = NULL; 1278 object *force = NULL;
1309 int i; 1279 int i;
1310 1280
1311 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1281 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1312 if (dir != 0) 1282 object *tmp = dir
1313 {
1314 tmp = find_target_for_friendly_spell (op, dir); 1283 ? find_target_for_friendly_spell (op, dir)
1315 } 1284 : op;
1316 else
1317 {
1318 tmp = op;
1319 }
1320 1285
1321 if (tmp == NULL) 1286 if (!tmp)
1322 return 0; 1287 return 0;
1323 1288
1324 /* If we've already got a force of this type, don't add a new one. */ 1289 /* If we've already got a force of this type, don't add a new one. */
1325 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1290 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1326 { 1291 {
1327 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1292 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1328 { 1293 {
1329 if (tmp2->name == spell_ob->name) 1294 if (tmp2->name == spell_ob->name)
1330 { 1295 {
… …
1388 if (tmp->type == PLAYER) 1353 if (tmp->type == PLAYER)
1389 { 1354 {
1390 /* Stat adjustment spells */ 1355 /* Stat adjustment spells */
1391 for (i = 0; i < NUM_STATS; i++) 1356 for (i = 0; i < NUM_STATS; i++)
1392 { 1357 {
1393 sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm; 1358 if (sint8 stat = spell_ob->stats.stat (i))
1394
1395 if (stat)
1396 { 1359 {
1397 sm = 0; 1360 sint8 sm = 0;
1398 for (k = 0; k < stat; k++) 1361 for (sint8 k = 0; k < stat; k++)
1399 sm += rndm (1, 3); 1362 sm += rndm (1, 3);
1400 1363
1401 if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat)) 1364 if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1402 { 1365 sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1403 sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i); 1366
1404 if (sm < 0) 1367 force->stats.stat (i) = sm;
1405 sm = 0; 1368
1406 }
1407 set_attr_value (&force->stats, i, sm);
1408 if (!sm) 1369 if (!sm)
1409 new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]); 1370 new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1410 } 1371 }
1411 } 1372 }
1412 } 1373 }
… …
1432 force->stats.ac = spell_ob->stats.ac; 1393 force->stats.ac = spell_ob->stats.ac;
1433 force->attacktype = spell_ob->attacktype; 1394 force->attacktype = spell_ob->attacktype;
1434 1395
1435 insert_ob_in_ob (force, tmp); 1396 insert_ob_in_ob (force, tmp);
1436 change_abil (tmp, force); /* Mostly to display any messages */ 1397 change_abil (tmp, force); /* Mostly to display any messages */
1437 fix_player (tmp); 1398 tmp->update_stats ();
1438 return 1; 1399 return 1;
1439} 1400}
1440 1401
1441/* This used to be part of cast_change_ability, but it really didn't make 1402/* This used to be part of cast_change_ability, but it really didn't make
1442 * a lot of sense, since most of the values it derives are from the god 1403 * a lot of sense, since most of the values it derives are from the god
… …
1541 force->stats.wc = spell_ob->stats.wc; 1502 force->stats.wc = spell_ob->stats.wc;
1542 force->stats.ac = spell_ob->stats.ac; 1503 force->stats.ac = spell_ob->stats.ac;
1543 1504
1544 change_abil (tmp, force); /* Mostly to display any messages */ 1505 change_abil (tmp, force); /* Mostly to display any messages */
1545 insert_ob_in_ob (force, tmp); 1506 insert_ob_in_ob (force, tmp);
1546 fix_player (tmp); 1507 tmp->update_stats ();
1547 return 1; 1508 return 1;
1548} 1509}
1549
1550
1551 1510
1552/* Alchemy code by Mark Wedel 1511/* Alchemy code by Mark Wedel
1553 * 1512 *
1554 * This code adds a new spell, called alchemy. Alchemy will turn 1513 * This code adds a new spell, called alchemy. Alchemy will turn
1555 * objects to gold nuggets, the value of the gold nuggets being 1514 * objects to gold nuggets, the value of the gold nuggets being
… …
1565 * For example, if an item is worth 110 gold, you will get 1524 * For example, if an item is worth 110 gold, you will get
1566 * 4 large nuggets, and from 0-10 small nuggets. 1525 * 4 large nuggets, and from 0-10 small nuggets.
1567 * 1526 *
1568 * There is also a chance (1:30) that you will get nothing at all 1527 * There is also a chance (1:30) that you will get nothing at all
1569 * for the object. There is also a maximum weight that will be 1528 * for the object. There is also a maximum weight that will be
1570 * alchemied. 1529 * alchemised.
1571 */ 1530 */
1572
1573/* I didn't feel like passing these as arguements to the
1574 * two functions that need them. Real values are put in them
1575 * when the spell is cast, and these are freed when the spell
1576 * is finished.
1577 */
1578static object *small, *large;
1579
1580static void 1531static void
1581alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight) 1532alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1582{ 1533{
1583 uint64 value = query_cost (obj, NULL, F_TRUE); 1534 uint64 value = query_cost (obj, NULL, F_TRUE);
1584 1535
1585 /* Give third price when we alchemy money (This should hopefully 1536 /* Give third price when we alchemy money (This should hopefully
1586 * make it so that it isn't worth it to alchemy money, sell 1537 * make it so that it isn't worth it to alchemy money, sell
1587 * the nuggets, alchemy the gold from that, etc. 1538 * the nuggets, alchemy the gold from that, etc.
1588 * Otherwise, give 9 silver on the gold for other objects, 1539 * Otherwise, give 9 silver on the gold for other objects,
1589 * so that it would still be more affordable to haul 1540 * so that it would still be more affordable to haul
1590 * the stuff back to town. 1541 * the stuff back to town.
1591 */ 1542 */
1592
1593 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1543 if (QUERY_FLAG (obj, FLAG_UNPAID))
1594 value = 0; 1544 value = 0;
1595 else if (obj->type == MONEY || obj->type == GEM) 1545 else if (obj->type == MONEY || obj->type == GEM)
1596 value /= 3; 1546 value /= 3;
1597 else 1547 else
1598 value = (value * 9) / 10; 1548 value = value * 9 / 10;
1599 1549
1600 value /= 4; // fix by GHJ, don't understand, pcg
1601
1602 if ((obj->value > 0) && rndm (0, 29)) 1550 if (obj->value > 0 && rndm (0, 29))
1603 { 1551 total_value += value;
1604 int count;
1605 1552
1606 count = value / large->value;
1607 *large_nuggets += count;
1608 value -= (uint64) count *(uint64) large->value;
1609
1610 count = value / small->value;
1611 *small_nuggets += count;
1612 }
1613
1614 /* Turn 25 small nuggets into 1 large nugget. If the value
1615 * of large nuggets is not evenly divisable by the small nugget
1616 * value, take off an extra small_nugget (Assuming small_nuggets!=0)
1617 */
1618 if (*small_nuggets * small->value >= large->value)
1619 {
1620 (*large_nuggets)++;
1621 *small_nuggets -= large->value / small->value;
1622 if (*small_nuggets && large->value % small->value)
1623 (*small_nuggets)--;
1624 }
1625 weight += obj->weight; 1553 total_weight += obj->total_weight ();
1626 obj->remove (); 1554
1627 obj->destroy (0); 1555 obj->destroy ();
1628} 1556}
1629 1557
1630static void 1558static void
1631update_map (object *op, maptile *m, int small_nuggets, int large_nuggets, int x, int y) 1559update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1632{ 1560{
1633 object *tmp;
1634 int flag = 0; 1561 int flag = 0;
1635 1562
1636 /* Put any nuggets below the player, but we can only pass this 1563 /* Put any nuggets below the player, but we can only pass this
1637 * flag if we are on the same space as the player 1564 * flag if we are on the same space as the player
1638 */ 1565 */
1639 if (x == op->x && y == op->y && op->map == m) 1566 if (x == op->x && y == op->y && op->map == m)
1640 flag = INS_BELOW_ORIGINATOR; 1567 flag = INS_BELOW_ORIGINATOR;
1641 1568
1642 if (small_nuggets) 1569 if (small_nuggets)
1643 { 1570 {
1644 tmp = get_object (); 1571 object *tmp = small->clone ();
1645 copy_object (small, tmp);
1646 tmp->nrof = small_nuggets; 1572 tmp->nrof = small_nuggets;
1647 tmp->x = x;
1648 tmp->y = y;
1649 insert_ob_in_map (tmp, m, op, flag); 1573 m->insert (tmp, x, y, op, flag);
1650 } 1574 }
1575
1651 if (large_nuggets) 1576 if (large_nuggets)
1652 { 1577 {
1653 tmp = get_object (); 1578 object *tmp = large->clone ();
1654 copy_object (large, tmp);
1655 tmp->nrof = large_nuggets; 1579 tmp->nrof = large_nuggets;
1656 tmp->x = x;
1657 tmp->y = y;
1658 insert_ob_in_map (tmp, m, op, flag); 1580 m->insert (tmp, x, y, op, flag);
1659 } 1581 }
1582
1583 if (object *pl = m->at (x, y).player ())
1584 if (pl->contr->ns)
1585 pl->contr->ns->look_position = 0;
1660} 1586}
1661 1587
1662int 1588int
1663alchemy (object *op, object *caster, object *spell_ob) 1589alchemy (object *op, object *caster, object *spell_ob)
1664{ 1590{
1665 int x, y, weight = 0, weight_max, large_nuggets, small_nuggets, mflags;
1666 sint16 nx, ny;
1667 object *next, *tmp;
1668 maptile *mp;
1669
1670 if (op->type != PLAYER) 1591 if (op->type != PLAYER)
1671 return 0; 1592 return 0;
1672 1593
1594 object *large = get_archetype ("largenugget");
1595 object *small = get_archetype ("smallnugget");
1596
1673 /* Put a maximum weight of items that can be alchemied. Limits the power 1597 /* Put a maximum weight of items that can be alchemised. Limits the power
1674 * some, and also prevents people from alcheming every table/chair/clock 1598 * some, and also prevents people from alchemising every table/chair/clock
1675 * in sight 1599 * in sight
1676 */ 1600 */
1677 weight_max = spell_ob->duration + +SP_level_duration_adjust (caster, spell_ob); 1601 int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1678 weight_max *= 1000; 1602 int weight_max = duration * 1000;
1679 small = get_archetype ("smallnugget"), large = get_archetype ("largenugget"); 1603 uint64 value_max = duration * 1000;
1680 1604
1605 int weight = 0;
1606
1681 for (y = op->y - 1; y <= op->y + 1; y++) 1607 for (int y = op->y - 1; y <= op->y + 1; y++)
1682 { 1608 {
1683 for (x = op->x - 1; x <= op->x + 1; x++) 1609 for (int x = op->x - 1; x <= op->x + 1; x++)
1684 { 1610 {
1611 uint64 value = 0;
1612
1685 nx = x; 1613 sint16 nx = x;
1686 ny = y; 1614 sint16 ny = y;
1687 1615
1688 mp = op->map; 1616 maptile *mp = op->map;
1689 1617
1690 mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny); 1618 int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1691 1619
1692 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC)) 1620 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1693 continue; 1621 continue;
1694 1622
1695 /* Treat alchemy a little differently - most spell effects 1623 /* Treat alchemy a little differently - most spell effects
… …
1697 * ground level effect. 1625 * ground level effect.
1698 */ 1626 */
1699 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK) 1627 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1700 continue; 1628 continue;
1701 1629
1702 small_nuggets = 0; 1630 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1703 large_nuggets = 0;
1704
1705 for (tmp = get_map_ob (mp, nx, ny); tmp != NULL; tmp = next)
1706 { 1631 {
1707 next = tmp->above; 1632 next = tmp->above;
1633
1708 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1634 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1709 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1635 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1710 { 1636 {
1711
1712 if (tmp->inv) 1637 if (tmp->inv)
1713 { 1638 {
1714 object *next1, *tmp1; 1639 object *next1, *tmp1;
1715 1640
1716 for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1) 1641 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1717 { 1642 {
1718 next1 = tmp1->below; 1643 next1 = tmp1->below;
1719 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1644 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1720 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1645 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1721 alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight); 1646 alchemy_object (tmp1, value, weight);
1722 } 1647 }
1723 } 1648 }
1649
1724 alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight); 1650 alchemy_object (tmp, value, weight);
1725 1651
1726 if (weight > weight_max) 1652 if (weight > weight_max)
1727 { 1653 break;
1728 update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1729 large->destroy (0);
1730 small->destroy (0);
1731 return 1;
1732 } 1654 }
1733 } /* is alchemable object */ 1655 }
1734 } /* process all objects on this space */ 1656
1657 value = min (value, value_max);
1658
1659 uint64 count = value / large->value;
1660 int large_nuggets = count;
1661 value -= count * large->value;
1662
1663 count = value / small->value;
1664 int small_nuggets = count;
1735 1665
1736 /* Insert all the nuggets at one time. This probably saves time, but 1666 /* Insert all the nuggets at one time. This probably saves time, but
1737 * it also prevents us from alcheming nuggets that were just created 1667 * it also prevents us from alcheming nuggets that were just created
1738 * with this spell. 1668 * with this spell.
1739 */ 1669 */
1740 update_map (op, mp, small_nuggets, large_nuggets, nx, ny); 1670 update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);
1671
1672 if (weight > weight_max)
1673 goto bailout;
1741 } 1674 }
1742 } 1675 }
1676
1677bailout:
1743 large->destroy (0); 1678 large->destroy ();
1744 small->destroy (0); 1679 small->destroy ();
1745 /* reset this so that if player standing on a big pile of stuff,
1746 * it is redrawn properly.
1747 */
1748 op->contr->socket.look_position = 0;
1749 return 1; 1680 return 1;
1750} 1681}
1751 1682
1752 1683
1753/* This function removes the cursed/damned status on equipped 1684/* This function removes the cursed/damned status on equipped
… …
1762 for (tmp = op->inv; tmp; tmp = tmp->below) 1693 for (tmp = op->inv; tmp; tmp = tmp->below)
1763 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1694 if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1764 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1695 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1765 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1696 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1766 { 1697 {
1767
1768 was_one++; 1698 was_one++;
1769 if (tmp->level <= caster_level (caster, spell)) 1699 if (tmp->level <= caster_level (caster, spell))
1770 { 1700 {
1771 success++; 1701 success++;
1772 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1702 if (QUERY_FLAG (spell, FLAG_DAMNED))
… …
1781 } 1711 }
1782 1712
1783 if (op->type == PLAYER) 1713 if (op->type == PLAYER)
1784 { 1714 {
1785 if (success) 1715 if (success)
1786 {
1787 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now."); 1716 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
1788 }
1789 else 1717 else
1790 { 1718 {
1791 if (was_one) 1719 if (was_one)
1792 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse."); 1720 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
1793 else 1721 else
1794 new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items."); 1722 new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items.");
1795 } 1723 }
1796 } 1724 }
1725
1797 return success; 1726 return success;
1798} 1727}
1799 1728
1800/* Identifies objects in the players inventory/on the ground */ 1729/* Identifies objects in the players inventory/on the ground */
1801 1730
… …
1808 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1737 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1809 1738
1810 if (num_ident < 1) 1739 if (num_ident < 1)
1811 num_ident = 1; 1740 num_ident = 1;
1812 1741
1813
1814 for (tmp = op->inv; tmp; tmp = tmp->below) 1742 for (tmp = op->inv; tmp; tmp = tmp->below)
1815 { 1743 {
1816 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1744 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1817 { 1745 {
1818 identify (tmp); 1746 identify (tmp);
1747
1819 if (op->type == PLAYER) 1748 if (op->type == PLAYER)
1820 { 1749 {
1821 new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op)); 1750 new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op));
1751
1822 if (tmp->msg) 1752 if (tmp->msg)
1823 { 1753 {
1824 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:"); 1754 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1825 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1755 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1826 } 1756 }
1827 } 1757 }
1758
1828 num_ident--; 1759 num_ident--;
1829 success = 1; 1760 success = 1;
1830 if (!num_ident) 1761 if (!num_ident)
1831 break; 1762 break;
1832 } 1763 }
1833 } 1764 }
1765
1834 /* If all the power of the spell has been used up, don't go and identify 1766 /* If all the power of the spell has been used up, don't go and identify
1835 * stuff on the floor. Only identify stuff on the floor if the spell 1767 * stuff on the floor. Only identify stuff on the floor if the spell
1836 * was not fully used. 1768 * was not fully used.
1837 */ 1769 */
1838 if (num_ident) 1770 if (num_ident)
1839 { 1771 {
1840 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1772 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1841 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1773 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1842 { 1774 {
1843
1844 identify (tmp); 1775 identify (tmp);
1776
1845 if (op->type == PLAYER) 1777 if (op->type == PLAYER)
1846 { 1778 {
1847 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op)); 1779 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op));
1780
1848 if (tmp->msg) 1781 if (tmp->msg)
1849 { 1782 {
1850 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:"); 1783 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1851 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1784 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1852 } 1785 }
1786
1853 esrv_send_item (op, tmp); 1787 esrv_send_item (op, tmp);
1854 } 1788 }
1789
1855 num_ident--; 1790 num_ident--;
1856 success = 1; 1791 success = 1;
1857 if (!num_ident) 1792 if (!num_ident)
1858 break; 1793 break;
1859 } 1794 }
1860 } 1795 }
1796
1861 if (!success) 1797 if (!success)
1862 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1798 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified.");
1863 else 1799 else
1864 {
1865 spell_effect (spell, op->x, op->y, op->map, op); 1800 spell_effect (spell, op->x, op->y, op->map, op);
1866 } 1801
1867 return success; 1802 return success;
1868} 1803}
1869
1870 1804
1871int 1805int
1872cast_detection (object *op, object *caster, object *spell, object *skill) 1806cast_detection (object *op, object *caster, object *spell, object *skill)
1873{ 1807{
1874 object *tmp, *last, *god, *detect; 1808 object *tmp, *last, *god, *detect;
… …
1887 skill = caster; 1821 skill = caster;
1888 1822
1889 for (x = op->x - range; x <= op->x + range; x++) 1823 for (x = op->x - range; x <= op->x + range; x++)
1890 for (y = op->y - range; y <= op->y + range; y++) 1824 for (y = op->y - range; y <= op->y + range; y++)
1891 { 1825 {
1892
1893 m = op->map; 1826 m = op->map;
1894 mflags = get_map_flags (m, &m, x, y, &nx, &ny); 1827 mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1895 if (mflags & P_OUT_OF_MAP) 1828 if (mflags & P_OUT_OF_MAP)
1896 continue; 1829 continue;
1897 1830
… …
1899 * floor. But this is not true for show invisible. 1832 * floor. But this is not true for show invisible.
1900 * Basically, we just go and find the top object and work 1833 * Basically, we just go and find the top object and work
1901 * down - that is easier than working up. 1834 * down - that is easier than working up.
1902 */ 1835 */
1903 1836
1904 for (last = NULL, tmp = get_map_ob (m, nx, ny); tmp; tmp = tmp->above) 1837 for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)
1905 last = tmp; 1838 last = tmp;
1839
1906 /* Shouldn't happen, but if there are no objects on a space, this 1840 /* Shouldn't happen, but if there are no objects on a space, this
1907 * would happen. 1841 * would happen.
1908 */ 1842 */
1909 if (!last) 1843 if (!last)
1910 continue; 1844 continue;
… …
1912 done_one = 0; 1846 done_one = 0;
1913 floor = 0; 1847 floor = 0;
1914 detect = NULL; 1848 detect = NULL;
1915 for (tmp = last; tmp; tmp = tmp->below) 1849 for (tmp = last; tmp; tmp = tmp->below)
1916 { 1850 {
1917
1918 /* show invisible */ 1851 /* show invisible */
1919 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1852 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1920 /* Might there be other objects that we can make visibile? */ 1853 /* Might there be other objects that we can make visible? */
1921 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) || 1854 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||
1922 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) || 1855 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) ||
1923 tmp->type == CF_HANDLE || 1856 tmp->type == CF_HANDLE ||
1924 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE || 1857 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE ||
1925 tmp->type == BUTTON || tmp->type == TELEPORTER || 1858 tmp->type == BUTTON || tmp->type == TELEPORTER ||
… …
1932 { 1865 {
1933 tmp->invisible = 0; 1866 tmp->invisible = 0;
1934 done_one = 1; 1867 done_one = 1;
1935 } 1868 }
1936 } 1869 }
1870
1937 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1871 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1938 floor = 1; 1872 floor = 1;
1939 1873
1940 /* All detections below this point don't descend beneath the floor, 1874 /* All detections below this point don't descend beneath the floor,
1941 * so just continue on. We could be clever and look at the type of 1875 * so just continue on. We could be clever and look at the type of
… …
1994 */ 1928 */
1995 if (done_one) 1929 if (done_one)
1996 { 1930 {
1997 object *detect_ob = arch_to_object (spell->other_arch); 1931 object *detect_ob = arch_to_object (spell->other_arch);
1998 1932
1999 detect_ob->x = nx;
2000 detect_ob->y = ny;
2001 /* if this is set, we want to copy the face */ 1933 /* if this is set, we want to copy the face */
2002 if (done_one == 2 && detect) 1934 if (done_one == 2 && detect)
2003 { 1935 {
2004 detect_ob->face = detect->face; 1936 detect_ob->face = detect->face;
2005 detect_ob->animation_id = detect->animation_id; 1937 detect_ob->animation_id = detect->animation_id;
… …
2007 detect_ob->last_anim = 0; 1939 detect_ob->last_anim = 0;
2008 /* by default, the detect_ob is already animated */ 1940 /* by default, the detect_ob is already animated */
2009 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1941 if (!QUERY_FLAG (detect, FLAG_ANIMATE))
2010 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1942 CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
2011 } 1943 }
1944
2012 insert_ob_in_map (detect_ob, m, op, 0); 1945 m->insert (detect_ob, nx, ny, op);
2013 } 1946 }
2014 } /* for processing the surrounding spaces */ 1947 } /* for processing the surrounding spaces */
2015 1948
2016 1949
2017 /* Now process objects in the players inventory if detect curse or magic */ 1950 /* Now process objects in the players inventory if detect curse or magic */
… …
2066 1999
2067 /* Explodes a fireball centered at player */ 2000 /* Explodes a fireball centered at player */
2068 tmp = get_archetype (EXPLODING_FIREBALL); 2001 tmp = get_archetype (EXPLODING_FIREBALL);
2069 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1; 2002 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
2070 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2; 2003 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2071 tmp->x = victim->x; 2004
2072 tmp->y = victim->y; 2005 tmp->insert_at (victim);
2073 insert_ob_in_map (tmp, victim->map, NULL, 0);
2074 victim->stats.sp = 2 * victim->stats.maxsp; 2006 victim->stats.sp = 2 * victim->stats.maxsp;
2075 } 2007 }
2076 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 2008 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2077 {
2078 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 2009 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");
2079 }
2080 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 2010 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2081 {
2082 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 2011 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2083 }
2084 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 2012 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2085 { 2013 {
2086 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 2014 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
2087 confuse_player (victim, victim, 99); 2015 confuse_player (victim, victim, 99);
2088 } 2016 }
2089 else if (victim->stats.sp >= victim->stats.maxsp * 1.25) 2017 else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
2090 {
2091 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices."); 2018 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
2092 }
2093} 2019}
2094 2020
2095/* cast_transfer 2021/* cast_transfer
2096 * This spell transfers sp from the player to another person. 2022 * This spell transfers sp from the player to another person.
2097 * We let the target go above their normal maximum SP. 2023 * We let the target go above their normal maximum SP.
… …
2111 2037
2112 mflags = get_map_flags (m, &m, x, y, &x, &y); 2038 mflags = get_map_flags (m, &m, x, y, &x, &y);
2113 2039
2114 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 2040 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
2115 { 2041 {
2116 for (plyr = get_map_ob (m, x, y); plyr != NULL; plyr = plyr->above) 2042 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
2117 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 2043 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
2118 break; 2044 break;
2119 } 2045 }
2120 2046
2121 2047
2122 /* If we did not find a player in the specified direction, transfer 2048 /* If we did not find a player in the specified direction, transfer
2123 * to anyone on top of us. This is used for the rune of transference mostly. 2049 * to anyone on top of us. This is used for the rune of transference mostly.
2124 */ 2050 */
2125 if (plyr == NULL) 2051 if (plyr == NULL)
2126 for (plyr = get_map_ob (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above) 2052 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
2127 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 2053 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
2128 break; 2054 break;
2129 2055
2130 if (!plyr) 2056 if (!plyr)
2131 { 2057 {
… …
2186 m = op->map; 2112 m = op->map;
2187 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 2113 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
2188 if (mflags & P_OUT_OF_MAP) 2114 if (mflags & P_OUT_OF_MAP)
2189 return; 2115 return;
2190 2116
2191 for (tmp = get_map_ob (m, sx, sy); tmp != NULL; tmp = next) 2117 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
2192 { 2118 {
2193 next = tmp->above; 2119 next = tmp->above;
2194 2120
2195 /* Need to look at the head object - otherwise, if tmp 2121 /* Need to look at the head object - otherwise, if tmp
2196 * points to a monster, we don't have all the necessary 2122 * points to a monster, we don't have all the necessary
… …
2208 /* Basically, if the object is magical and not counterspell, 2134 /* Basically, if the object is magical and not counterspell,
2209 * we will more or less remove the object. Don't counterspell 2135 * we will more or less remove the object. Don't counterspell
2210 * monsters either. 2136 * monsters either.
2211 */ 2137 */
2212 2138
2213 if (head->attacktype & AT_MAGIC && 2139 if (head->attacktype & AT_MAGIC
2214 !(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level)) 2140 && !(head->attacktype & AT_COUNTERSPELL)
2215 { 2141 && !QUERY_FLAG (head, FLAG_MONSTER)
2216 head->remove (); 2142 && (op->level > head->level))
2217 head->destroy (0); 2143 head->destroy ();
2218 }
2219 else 2144 else
2220 switch (head->type) 2145 switch (head->type)
2221 { 2146 {
2222 case SPELL_EFFECT: 2147 case SPELL_EFFECT:
2148 // XXX: Don't affect floor spelleffects. See also XXX comment
2149 // about sanctuary in spell_util.C
2150 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2151 continue;
2152
2223 if (op->level > head->level) 2153 if (op->level > head->level)
2224 {
2225 head->remove ();
2226 head->destroy (0); 2154 head->destroy ();
2227 } 2155
2228 break; 2156 break;
2229 2157
2230 /* I really don't get this rune code that much - that 2158 /* I really don't get this rune code that much - that
2231 * random chance seems really low. 2159 * random chance seems really low.
2232 */ 2160 */
2233 case RUNE: 2161 case RUNE:
2234 if (rndm (0, 149) == 0) 2162 if (rndm (0, 149) == 0)
2235 { 2163 {
2236 head->stats.hp--; /* weaken the rune */ 2164 head->stats.hp--; /* weaken the rune */
2237 if (!head->stats.hp) 2165 if (!head->stats.hp)
2238 {
2239 head->remove ();
2240 head->destroy (0); 2166 head->destroy ();
2241 }
2242 } 2167 }
2243 break; 2168 break;
2244 } 2169 }
2245 } 2170 }
2246} 2171}
… …
2299 * This code was very odd - code early on would only let players use the spell, 2224 * This code was very odd - code early on would only let players use the spell,
2300 * yet the code wass full of player checks. I've presumed that the code 2225 * yet the code wass full of player checks. I've presumed that the code
2301 * that only let players use it was correct, and removed all the other 2226 * that only let players use it was correct, and removed all the other
2302 * player checks. MSW 2003-01-06 2227 * player checks. MSW 2003-01-06
2303 */ 2228 */
2304
2305int 2229int
2306animate_weapon (object *op, object *caster, object *spell, int dir) 2230animate_weapon (object *op, object *caster, object *spell, int dir)
2307{ 2231{
2308 object *weapon, *tmp; 2232 object *weapon, *tmp;
2309 char buf[MAX_BUF]; 2233 char buf[MAX_BUF];
… …
2321 /* exit if it's not a player using this spell. */ 2245 /* exit if it's not a player using this spell. */
2322 if (op->type != PLAYER) 2246 if (op->type != PLAYER)
2323 return 0; 2247 return 0;
2324 2248
2325 /* if player already has a golem, abort */ 2249 /* if player already has a golem, abort */
2326 if (op->contr->ranges[range_golem]) 2250 if (object *golem = op->contr->golem)
2327 { 2251 {
2328 control_golem (op->contr->ranges[range_golem], dir); 2252 control_golem (golem, dir);
2329 return 0; 2253 return 0;
2330 } 2254 }
2331 2255
2332 /* if no direction specified, pick one */ 2256 /* if no direction specified, pick one */
2333 if (!dir) 2257 if (!dir)
… …
2379 /* create the golem object */ 2303 /* create the golem object */
2380 tmp = arch_to_object (spell->other_arch); 2304 tmp = arch_to_object (spell->other_arch);
2381 2305
2382 /* if animated by a player, give the player control of the golem */ 2306 /* if animated by a player, give the player control of the golem */
2383 CLEAR_FLAG (tmp, FLAG_MONSTER); 2307 CLEAR_FLAG (tmp, FLAG_MONSTER);
2384 SET_FLAG (tmp, FLAG_FRIENDLY);
2385 tmp->stats.exp = 0; 2308 tmp->stats.exp = 0;
2386 add_friendly_object (tmp); 2309 add_friendly_object (tmp);
2387 tmp->type = GOLEM; 2310 tmp->type = GOLEM;
2388 set_owner (tmp, op); 2311 tmp->set_owner (op);
2312 op->contr->golem = tmp;
2389 set_spell_skill (op, caster, spell, tmp); 2313 set_spell_skill (op, caster, spell, tmp);
2390 op->contr->ranges[range_golem] = tmp;
2391 op->contr->shoottype = range_golem;
2392 2314
2393 /* Give the weapon to the golem now. A bit of a hack to check the 2315 /* Give the weapon to the golem now. A bit of a hack to check the
2394 * removed flag - it should only be set if get_split_object was 2316 * removed flag - it should only be set if get_split_object was
2395 * used above. 2317 * used above.
2396 */ 2318 */
2397 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2319 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2398 weapon->remove (); 2320 weapon->remove ();
2321
2399 insert_ob_in_ob (weapon, tmp); 2322 insert_ob_in_ob (weapon, tmp);
2400 esrv_send_item (op, weapon); 2323 esrv_send_item (op, weapon);
2401 /* To do everything necessary to let a golem use the weapon is a pain, 2324 /* To do everything necessary to let a golem use the weapon is a pain,
2402 * so instead, just set it as equipped (otherwise, we need to update 2325 * so instead, just set it as equipped (otherwise, we need to update
2403 * body_info, skills, etc) 2326 * body_info, skills, etc)
2404 */ 2327 */
2405 SET_FLAG (tmp, FLAG_USE_WEAPON); 2328 SET_FLAG (tmp, FLAG_USE_WEAPON);
2406 SET_FLAG (weapon, FLAG_APPLIED); 2329 SET_FLAG (weapon, FLAG_APPLIED);
2407 fix_player (tmp); 2330 tmp->update_stats ();
2408 2331
2409 /* There used to be 'odd' code that basically seemed to take the absolute 2332 /* There used to be 'odd' code that basically seemed to take the absolute
2410 * value of the weapon->magic an use that. IMO, that doesn't make sense - 2333 * value of the weapon->magic an use that. IMO, that doesn't make sense -
2411 * if you're using a crappy weapon, it shouldn't be as good. 2334 * if you're using a crappy weapon, it shouldn't be as good.
2412 */ 2335 */
… …
2464 if (a > 14) 2387 if (a > 14)
2465 a = 14; 2388 a = 14;
2466 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2389 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2467 2390
2468 /* Determine golem's speed */ 2391 /* Determine golem's speed */
2469 tmp->speed = 0.4 + 0.1 * SP_level_range_adjust (caster, spell); 2392 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2470
2471 if (tmp->speed > 3.33)
2472 tmp->speed = 3.33;
2473 2393
2474 if (!spell->race) 2394 if (!spell->race)
2475 { 2395 {
2476 sprintf (buf, "animated %s", &weapon->name); 2396 sprintf (buf, "animated %s", &weapon->name);
2477 tmp->name = buf; 2397 tmp->name = buf;
… …
2479 tmp->face = weapon->face; 2399 tmp->face = weapon->face;
2480 tmp->animation_id = weapon->animation_id; 2400 tmp->animation_id = weapon->animation_id;
2481 tmp->anim_speed = weapon->anim_speed; 2401 tmp->anim_speed = weapon->anim_speed;
2482 tmp->last_anim = weapon->last_anim; 2402 tmp->last_anim = weapon->last_anim;
2483 tmp->state = weapon->state; 2403 tmp->state = weapon->state;
2484 if (QUERY_FLAG (weapon, FLAG_ANIMATE)) 2404 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2485 {
2486 SET_FLAG (tmp, FLAG_ANIMATE);
2487 }
2488 else
2489 {
2490 CLEAR_FLAG (tmp, FLAG_ANIMATE);
2491 }
2492 update_ob_speed (tmp);
2493 } 2405 }
2494 2406
2495 /* make experience increase in proportion to the strength of the summoned creature. */ 2407 /* make experience increase in proportion to the strength of the summoned creature. */
2496 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2408 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));
2497 2409
2498 tmp->speed_left = -1; 2410 tmp->speed_left = -1;
2499 tmp->x = x;
2500 tmp->y = y;
2501 tmp->direction = dir; 2411 tmp->direction = dir;
2502 insert_ob_in_map (tmp, m, op, 0); 2412
2413 m->insert (tmp, x, y, op);
2503 return 1; 2414 return 1;
2504} 2415}
2505 2416
2506/* cast_daylight() - changes the map darkness level *lower* */ 2417/* cast_daylight() - changes the map darkness level *lower* */
2507 2418
… …
2515 int success; 2426 int success;
2516 2427
2517 if (!op->map) 2428 if (!op->map)
2518 return 0; /* shouldnt happen */ 2429 return 0; /* shouldnt happen */
2519 2430
2520 success = change_map_light (op->map, spell->stats.dam); 2431 success = op->map->change_map_light (spell->stats.dam);
2432
2521 if (!success) 2433 if (!success)
2522 { 2434 {
2523 if (spell->stats.dam < 0) 2435 if (spell->stats.dam < 0)
2524 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2436 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2525 else 2437 else
… …
2550 2462
2551 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2463 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2552 2464
2553 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2465 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2554 2466
2555 set_owner (new_aura, op); 2467 new_aura->set_owner (op);
2556 set_spell_skill (op, caster, spell, new_aura); 2468 set_spell_skill (op, caster, spell, new_aura);
2557 new_aura->attacktype = spell->attacktype; 2469 new_aura->attacktype = spell->attacktype;
2558 2470
2559 new_aura->level = caster_level (caster, spell); 2471 new_aura->level = caster_level (caster, spell);
2560 if (refresh) 2472 if (refresh)
… …
2591 aura->remove (); 2503 aura->remove ();
2592 2504
2593 /* exit if we're out of gas */ 2505 /* exit if we're out of gas */
2594 if (aura->duration-- < 0) 2506 if (aura->duration-- < 0)
2595 { 2507 {
2596 aura->destroy (0); 2508 aura->destroy ();
2597 return; 2509 return;
2598 } 2510 }
2599 2511
2600 /* auras only exist in inventories */ 2512 /* auras only exist in inventories */
2601 if (env == NULL || env->map == NULL) 2513 if (env == NULL || env->map == NULL)
2602 { 2514 {
2603 aura->destroy (0); 2515 aura->destroy ();
2604 return; 2516 return;
2605 } 2517 }
2606 aura->x = env->x;
2607 aura->y = env->y;
2608 2518
2609 /* we need to jump out of the inventory for a bit 2519 /* we need to jump out of the inventory for a bit
2610 * in order to hit the map conveniently. 2520 * in order to hit the map conveniently.
2611 */ 2521 */
2612 insert_ob_in_map (aura, env->map, aura, 0); 2522 aura->insert_at (env, aura);
2613 2523
2614 for (i = 1; i < 9; i++) 2524 for (i = 1; i < 9; i++)
2615 { 2525 {
2616 sint16 nx, ny; 2526 sint16 nx, ny;
2617 2527
… …
2626 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2536 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))
2627 { 2537 {
2628 hit_map (aura, i, aura->attacktype, 0); 2538 hit_map (aura, i, aura->attacktype, 0);
2629 2539
2630 if (aura->other_arch) 2540 if (aura->other_arch)
2631 { 2541 m->insert (arch_to_object (aura->other_arch), nx, ny, aura);
2632 object *new_ob;
2633
2634 new_ob = arch_to_object (aura->other_arch);
2635 new_ob->x = nx;
2636 new_ob->y = ny;
2637 insert_ob_in_map (new_ob, m, aura, 0);
2638 } 2542 }
2639 }
2640 } 2543 }
2544
2641 /* put the aura back in the player's inventory */ 2545 /* put the aura back in the player's inventory */
2642 aura->remove (); 2546 aura->remove ();
2643 insert_ob_in_ob (aura, env); 2547 insert_ob_in_ob (aura, env);
2644} 2548}
2645 2549
… …
2650void 2554void
2651move_peacemaker (object *op) 2555move_peacemaker (object *op)
2652{ 2556{
2653 object *tmp; 2557 object *tmp;
2654 2558
2655 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 2559 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2656 { 2560 {
2657 int atk_lev, def_lev; 2561 int atk_lev, def_lev;
2658 object *victim = tmp; 2562 object *victim = tmp;
2659 2563
2660 if (tmp->head) 2564 if (tmp->head)
… …
2671 2575
2672 if (rndm (0, atk_lev - 1) > def_lev) 2576 if (rndm (0, atk_lev - 1) > def_lev)
2673 { 2577 {
2674 /* make this sucker peaceful. */ 2578 /* make this sucker peaceful. */
2675 2579
2676 change_exp (get_owner (op), victim->stats.exp, op->skill, 0); 2580 change_exp (op->owner, victim->stats.exp, op->skill, 0);
2677 victim->stats.exp = 0; 2581 victim->stats.exp = 0;
2678#if 0 2582#if 0
2679 /* No idea why these were all set to zero - if something 2583 /* No idea why these were all set to zero - if something
2680 * makes this creature agressive, he should still do damage. 2584 * makes this creature agressive, he should still do damage.
2681 */ 2585 */
… …
2726 2630
2727 snprintf (rune, sizeof (rune), "%s\n", msg); 2631 snprintf (rune, sizeof (rune), "%s\n", msg);
2728 2632
2729 tmp->race = op->name; /*Save the owner of the rune */ 2633 tmp->race = op->name; /*Save the owner of the rune */
2730 tmp->msg = rune; 2634 tmp->msg = rune;
2731 tmp->x = op->x; 2635
2732 tmp->y = op->y; 2636 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2733 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
2734 return 1; 2637 return 1;
2735} 2638}

Diff Legend

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