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.108 by root, Fri Sep 18 03:38:29 2009 UTC vs.
Revision 1.127 by root, Wed Apr 14 02:31:24 2010 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation, either version 3 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * option) any later version.
12 * 12 *
13 * 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,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License 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 18 * You should have received a copy of the Affero GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
20 * 21 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 23 */
23 24
24#include <global.h> 25#include <global.h>
… …
63 int ncharges; 64 int ncharges;
64 65
65 wand = find_marked_object (op); 66 wand = find_marked_object (op);
66 if (!wand || wand->type != WAND) 67 if (!wand || wand->type != WAND)
67 { 68 {
68 new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge."); 69 op->failmsg ("You need to mark the wand you want to recharge.");
69 return 0; 70 return 0;
70 } 71 }
72
71 if (!(random_roll (0, 3, op, PREFER_HIGH))) 73 if (!(random_roll (0, 3, op, PREFER_HIGH)))
72 { 74 {
73 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand)); 75 op->failmsgf ("The %s vibrates violently, then explodes!", query_name (wand));
74 op->play_sound (sound_find ("ob_explode")); 76 op->play_sound (sound_find ("ob_explode"));
75 wand->destroy (); 77 wand->destroy ();
76 tmp = get_archetype ("fireball"); 78 tmp = get_archetype (shstr_fireball);
77 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;
78 80
79 if (!tmp->stats.dam) 81 if (!tmp->stats.dam)
80 tmp->stats.dam = 1; 82 tmp->stats.dam = 1;
81 83
… …
92 94
93 if (wand->inv && wand->inv->level) 95 if (wand->inv && wand->inv->level)
94 ncharges /= wand->inv->level; 96 ncharges /= wand->inv->level;
95 else 97 else
96 { 98 {
97 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand)); 99 op->failmsgf ("Your %s is broken.", query_name (wand));
98 return 0; 100 return 0;
99 } 101 }
100 102
101 if (!ncharges) 103 if (!ncharges)
102 ncharges = 1; 104 ncharges = 1;
103 105
104 wand->stats.food += ncharges; 106 wand->stats.food += ncharges;
105 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));
106 108
107 if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE)) 109 if (wand->arch && wand->arch->flag [FLAG_ANIMATE])
108 { 110 {
109 SET_FLAG (wand, FLAG_ANIMATE); 111 wand->set_flag (FLAG_ANIMATE);
110 wand->set_speed (wand->arch->speed); 112 wand->set_speed (wand->arch->speed);
111 } 113 }
112 114
113 return 1; 115 return 1;
114} 116}
… …
128{ 130{
129 int bonus_plus = 0; 131 int bonus_plus = 0;
130 const char *missile_name = "arrow"; 132 const char *missile_name = "arrow";
131 133
132 for (object *tmp = op->inv; tmp; tmp = tmp->below) 134 for (object *tmp = op->inv; tmp; tmp = tmp->below)
133 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 135 if (tmp->type == BOW && tmp->flag [FLAG_APPLIED])
134 missile_name = tmp->race; 136 missile_name = tmp->race;
135 137
136 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 138 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
137 139
138 archetype *missile_arch = archetype::find (missile_name); 140 archetype *missile_arch = archetype::find (missile_name);
… …
157 break; 159 break;
158 160
159 if (!al) 161 if (!al)
160 { 162 {
161 missile->destroy (); 163 missile->destroy ();
162 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, spellparam); 164 op->failmsgf ("No such object %ss of %s", missile_name, spellparam);
163 return 0; 165 return 0;
164 } 166 }
165 167
166 if (al->item->slaying) 168 if (al->item->slaying)
167 { 169 {
168 missile->destroy (); 170 missile->destroy ();
169 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, spellparam); 171 op->failmsgf ("You are not allowed to create %ss of %s", missile_name, spellparam);
170 return 0; 172 return 0;
171 } 173 }
172 174
173 give_artifact_abilities (missile, al->item); 175 give_artifact_abilities (missile, al->item);
174 /* These special arrows cost something extra. Don't have them also be magical - 176 /* These special arrows cost something extra. Don't have them also be magical -
… …
192 194
193 missile->magic = missile_plus; 195 missile->magic = missile_plus;
194 /* Can't get any money for these objects */ 196 /* Can't get any money for these objects */
195 missile->value = 0; 197 missile->value = 0;
196 198
197 SET_FLAG (missile, FLAG_IDENTIFIED); 199 missile->set_flag (FLAG_IDENTIFIED);
198 200
199 if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ()) 201 if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ())
200 pick_up (op, missile); 202 pick_up (op, missile);
201 203
202 return 1; 204 return 1;
… …
256 /* Pretty unlikely (there are some very low food items), but you never 258 /* Pretty unlikely (there are some very low food items), but you never
257 * know 259 * know
258 */ 260 */
259 if (!at) 261 if (!at)
260 { 262 {
261 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food."); 263 op->failmsgf ("You don't have enough experience to create any food.");
262 return 0; 264 return 0;
263 } 265 }
264 266
265 food_value /= at->stats.food; 267 food_value /= at->stats.food;
266 new_op = arch_to_object (at); 268 new_op = at->instance ();
267 new_op->nrof = food_value; 269 new_op->nrof = food_value;
268 270
269 new_op->value = 0; 271 new_op->value = 0;
270 if (new_op->nrof < 1) 272 if (new_op->nrof < 1)
271 new_op->nrof = 1; 273 new_op->nrof = 1;
… …
296 mflags = get_map_flags (m, &m, x, y, &x, &y); 298 mflags = get_map_flags (m, &m, x, y, &x, &y);
297 299
298 if (mflags & P_OUT_OF_MAP) 300 if (mflags & P_OUT_OF_MAP)
299 break; 301 break;
300 302
301 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC)) 303 if (!op->flag [FLAG_WIZCAST] && (mflags & P_NO_MAGIC))
302 { 304 {
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 308
307 if (mflags & P_IS_ALIVE) 309 if (mflags & P_IS_ALIVE)
308 { 310 {
309 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above) 311 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
310 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 312 if (tmp->flag [FLAG_ALIVE] && (tmp->type == PLAYER || tmp->flag [FLAG_MONSTER]))
311 { 313 {
312 new_draw_info (NDI_UNIQUE, 0, op, "You detect something."); 314 new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
313 if (tmp->head != NULL) 315 if (tmp->head != NULL)
314 tmp = tmp->head; 316 tmp = tmp->head;
315 examine_monster (op, tmp); 317 examine_monster (op, tmp);
… …
338 if (pl->type == PLAYER) 340 if (pl->type == PLAYER)
339 { 341 {
340 /* If race isn't set, then invisible unless it is undead */ 342 /* If race isn't set, then invisible unless it is undead */
341 if (!pl->contr->invis_race) 343 if (!pl->contr->invis_race)
342 { 344 {
343 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 345 if (mon->flag [FLAG_UNDEAD])
344 return 0; 346 return 0;
345 347
346 return 1; 348 return 1;
347 } 349 }
348 350
… …
379int 381int
380cast_invisible (object *op, object *caster, object *spell_ob) 382cast_invisible (object *op, object *caster, object *spell_ob)
381{ 383{
382 if (op->invisible > 1000) 384 if (op->invisible > 1000)
383 { 385 {
384 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further"); 386 op->failmsg ("You can not extend the duration of your invisibility any further");
385 return 0; 387 return 0;
386 } 388 }
387 389
388 /* Remove the switch with 90% duplicate code - just handle the differences with 390 /* Remove the switch with 90% duplicate code - just handle the differences with
389 * and if statement or two. 391 * and if statement or two.
… …
395 397
396 if (op->type == PLAYER) 398 if (op->type == PLAYER)
397 { 399 {
398 op->contr->invis_race = spell_ob->race; 400 op->contr->invis_race = spell_ob->race;
399 401
400 if (QUERY_FLAG (spell_ob, FLAG_MAKE_INVIS)) 402 if (spell_ob->flag [FLAG_MAKE_INVIS])
401 op->contr->tmp_invis = 0; 403 op->contr->tmp_invis = 0;
402 else 404 else
403 op->contr->tmp_invis = 1; 405 op->contr->tmp_invis = 1;
404 406
405 op->contr->hidden = 0; 407 op->contr->hidden = 0;
… …
447 // earth to dust tears down everything that can be torn down 449 // earth to dust tears down everything that can be torn down
448 for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next) 450 for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
449 { 451 {
450 next = tmp->above; 452 next = tmp->above;
451 453
452 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 454 if (tmp->flag [FLAG_TEAR_DOWN])
453 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 455 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
454 } 456 }
455 } 457 }
456 458
457 return 1; 459 return 1;
… …
460void 462void
461execute_word_of_recall (object *op) 463execute_word_of_recall (object *op)
462{ 464{
463 if (object *pl = op->in_player ()) 465 if (object *pl = op->in_player ())
464 { 466 {
465 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST)) 467 if (pl->ms ().flags () & P_NO_CLERIC && !pl->flag [FLAG_WIZCAST])
466 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you."); 468 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
467 else 469 else
468 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp); 470 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
469 } 471 }
470 472
… …
564 566
565int 567int
566perceive_self (object *op) 568perceive_self (object *op)
567{ 569{
568 const char *cp = describe_item (op, op); 570 const char *cp = describe_item (op, op);
569 archetype *at = archetype::find (ARCH_DEPLETION); 571 archetype *at = archetype::find (shstr_depletion);
570 572
571 dynbuf_text &buf = msg_dynbuf; buf.clear (); 573 dynbuf_text &buf = msg_dynbuf; buf.clear ();
572 574
573 if (!op->is_player ()) 575 if (!op->is_player ())
574 return 0; 576 return 0;
… …
593 for (int i = 0; i < NUM_STATS; i++) 595 for (int i = 0; i < NUM_STATS; i++)
594 if (tmp->stats.stat (i) < 0) 596 if (tmp->stats.stat (i) < 0)
595 buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i)); 597 buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
596 } 598 }
597 599
598 if (is_dragon_pl (op)) 600 if (op->is_dragon ())
599 /* now grab the 'dragon_ability'-force from the player's inventory */ 601 /* now grab the 'dragon_ability'-force from the player's inventory */
600 for (tmp = op->inv; tmp; tmp = tmp->below) 602 for (tmp = op->inv; tmp; tmp = tmp->below)
601 { 603 {
602 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force) 604 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
603 { 605 {
… …
644 646
645 if ((spell_ob->move_block || x != op->x || y != op->y) && 647 if ((spell_ob->move_block || x != op->x || y != op->y) &&
646 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) || 648 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
647 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block))) 649 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
648 { 650 {
649 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 651 op->failmsg ("Something is in the way.");
650 return 0; 652 return 0;
651 } 653 }
652 654
653 if (spell_ob->other_arch) 655 if (spell_ob->other_arch)
654 tmp = arch_to_object (spell_ob->other_arch); 656 tmp = spell_ob->other_arch->instance ();
655 else if (spell_ob->race) 657 else if (spell_ob->race)
656 { 658 {
657 char buf1[MAX_BUF]; 659 char buf1[MAX_BUF];
658 660
659 sprintf (buf1, spell_ob->race, dir); 661 sprintf (buf1, spell_ob->race, dir);
… …
663 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1); 665 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
664 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken."); 666 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
665 return 0; 667 return 0;
666 } 668 }
667 669
668 tmp = arch_to_object (at); 670 tmp = at->instance ();
669 } 671 }
670 else 672 else
671 { 673 {
672 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name); 674 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
673 return 0; 675 return 0;
… …
678 tmp->attacktype = spell_ob->attacktype; 680 tmp->attacktype = spell_ob->attacktype;
679 tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 681 tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
680 tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 682 tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
681 tmp->range = 0; 683 tmp->range = 0;
682 } 684 }
683 else if (QUERY_FLAG (tmp, FLAG_ALIVE)) 685 else if (tmp->flag [FLAG_ALIVE])
684 { 686 {
685 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 687 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
686 tmp->stats.maxhp = tmp->stats.hp; 688 tmp->stats.maxhp = tmp->stats.hp;
687 } 689 }
688 690
689 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP)) 691 if (spell_ob->flag [FLAG_IS_USED_UP] || tmp->flag [FLAG_IS_USED_UP])
690 { 692 {
691 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 693 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
692 SET_FLAG (tmp, FLAG_IS_USED_UP); 694 tmp->set_flag (FLAG_IS_USED_UP);
693 } 695 }
694 696
695 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN)) 697 if (spell_ob->flag [FLAG_TEAR_DOWN])
696 { 698 {
697 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 699 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
698 tmp->stats.maxhp = tmp->stats.hp; 700 tmp->stats.maxhp = tmp->stats.hp;
699 SET_FLAG (tmp, FLAG_TEAR_DOWN); 701 tmp->set_flag (FLAG_TEAR_DOWN);
700 SET_FLAG (tmp, FLAG_ALIVE); 702 tmp->set_flag (FLAG_ALIVE);
701 } 703 }
702 704
703 /* This can't really hurt - if the object doesn't kill anything, 705 /* This can't really hurt - if the object doesn't kill anything,
704 * these fields just won't be used. Do not set the owner for 706 * these fields just won't be used. Do not set the owner for
705 * earthwalls, though, so they survive restarts. 707 * earthwalls, though, so they survive restarts.
… …
717 return 0; 719 return 0;
718 } 720 }
719 721
720 /* If this is a spellcasting wall, need to insert the spell object */ 722 /* If this is a spellcasting wall, need to insert the spell object */
721 if (tmp->other_arch && tmp->other_arch->type == SPELL) 723 if (tmp->other_arch && tmp->other_arch->type == SPELL)
722 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 724 insert_ob_in_ob (tmp->other_arch->instance (), tmp);
723 725
724 /* This code causes the wall to extend some distance in 726 /* This code causes the wall to extend some distance in
725 * each direction, or until an obstruction is encountered. 727 * each direction, or until an obstruction is encountered.
726 * posblocked and negblocked help determine how far the 728 * posblocked and negblocked help determine how far the
727 * created wall can extend, it won't go extend through 729 * created wall can extend, it won't go extend through
… …
747 object *tmp2 = tmp->clone (); 749 object *tmp2 = tmp->clone ();
748 m->insert (tmp2, x, y, op); 750 m->insert (tmp2, x, y, op);
749 751
750 /* If this is a spellcasting wall, need to insert the spell object */ 752 /* If this is a spellcasting wall, need to insert the spell object */
751 if (tmp2->other_arch && tmp2->other_arch->type == SPELL) 753 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
752 tmp2->insert (arch_to_object (tmp2->other_arch)); 754 tmp2->insert (tmp2->other_arch->instance ());
753 755
754 } 756 }
755 else 757 else
756 posblocked = 1; 758 posblocked = 1;
757 759
… …
764 { 766 {
765 object *tmp2 = tmp->clone (); 767 object *tmp2 = tmp->clone ();
766 m->insert (tmp2, x, y, op); 768 m->insert (tmp2, x, y, op);
767 769
768 if (tmp2->other_arch && tmp2->other_arch->type == SPELL) 770 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
769 tmp2->insert (arch_to_object (tmp2->other_arch)); 771 tmp2->insert (tmp2->other_arch->instance ());
770 } 772 }
771 else 773 else
772 negblocked = 1; 774 negblocked = 1;
773 } 775 }
774 776
775 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) 777 if (tmp->flag [FLAG_BLOCKSVIEW])
776 update_all_los (op->map, op->x, op->y); 778 update_all_los (op->map, op->x, op->y);
777 779
778 return 1; 780 return 1;
779} 781}
780 782
… …
789 if (op->type != PLAYER) 791 if (op->type != PLAYER)
790 return 0; 792 return 0;
791 793
792 if (!dir) 794 if (!dir)
793 { 795 {
794 new_draw_info (NDI_UNIQUE, 0, op, "In what direction?"); 796 op->failmsg ("In what direction?");
795 return 0; 797 return 0;
796 } 798 }
797 799
798 /* Given the new outdoor maps, can't let players dimension door for 800 /* Given the new outdoor maps, can't let players dimension door for
799 * ever, so put limits in. 801 * ever, so put limits in.
… …
804 { 806 {
805 int count = atoi (spellparam); 807 int count = atoi (spellparam);
806 808
807 if (count > maxdist) 809 if (count > maxdist)
808 { 810 {
809 new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!"); 811 op->failmsg ("You can't dimension door that far!");
810 return 0; 812 return 0;
811 } 813 }
812 814
813 for (dist = 0; dist < count; dist++) 815 for (dist = 0; dist < count; dist++)
814 { 816 {
… …
875 break; 877 break;
876 878
877 } 879 }
878 if (!dist) 880 if (!dist)
879 { 881 {
880 new_draw_info (NDI_UNIQUE, 0, op, "Your spell failed!\n"); 882 op->failmsg ("Your spell failed!\n");
881 return 0; 883 return 0;
882 } 884 }
883 } 885 }
884 886
885 /* Actually move the player now */ 887 /* Actually move the player now */
886 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op))) 888 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
887 return 1; 889 return 1;
888 890
889 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 891 op->speed_left = -5. * op->speed; /* Freeze them for a short while */
892
890 return 1; 893 return 1;
891} 894}
892 895
893/* cast_heal: Heals something. 896/* cast_heal: Heals something.
894 * op is the caster. 897 * op is the caster.
… …
949 if (cure_disease (tmp, op, spell)) 952 if (cure_disease (tmp, op, spell))
950 success = 1; 953 success = 1;
951 954
952 if (spell->attacktype & AT_POISON) 955 if (spell->attacktype & AT_POISON)
953 { 956 {
954 at = archetype::find ("poisoning"); 957 at = archetype::find (shstr_poisoning);
955 poison = present_arch_in_ob (at, tmp); 958 poison = present_arch_in_ob (at, tmp);
956 if (poison) 959 if (poison)
957 { 960 {
958 success = 1; 961 success = 1;
959 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed"); 962 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
… …
961 } 964 }
962 } 965 }
963 966
964 if (spell->attacktype & AT_CONFUSION) 967 if (spell->attacktype & AT_CONFUSION)
965 { 968 {
966 poison = present_in_ob_by_name (FORCE, "confusion", tmp); 969 poison = present_in_ob_by_name (FORCE, shstr_confusion, tmp);
967 if (poison) 970 if (poison)
968 { 971 {
969 success = 1; 972 success = 1;
970 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 973 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
971 poison->duration = 1; 974 poison->duration = 1;
972 } 975 }
973 } 976 }
974 977
975 if (spell->attacktype & AT_BLIND) 978 if (spell->attacktype & AT_BLIND)
976 { 979 {
977 at = archetype::find ("blindness"); 980 at = archetype::find (shstr_blindness);
978 poison = present_arch_in_ob (at, tmp); 981 poison = present_arch_in_ob (at, tmp);
979 if (poison) 982 if (poison)
980 { 983 {
981 success = 1; 984 success = 1;
982 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return."); 985 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
… …
1000 tmp->stats.grace = tmp->stats.maxgrace; 1003 tmp->stats.grace = tmp->stats.maxgrace;
1001 success = 1; 1004 success = 1;
1002 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!"); 1005 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1003 } 1006 }
1004 1007
1005 if (spell->stats.food && tmp->stats.food < 999) 1008 if (spell->stats.food && tmp->stats.food < MAX_FOOD)
1006 { 1009 {
1007 tmp->stats.food += spell->stats.food; 1010 tmp->stats.food += spell->stats.food;
1008 1011 min_it (tmp->stats.food, MAX_FOOD);
1009 if (tmp->stats.food > 999)
1010 tmp->stats.food = 999;
1011 1012
1012 success = 1; 1013 success = 1;
1013 /* We could do something a bit better like the messages for healing above */ 1014 /* We could do something a bit better like the messages for healing above */
1014 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1015 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1015 } 1016 }
… …
1062 break; 1063 break;
1063 } 1064 }
1064 else if (spell_ob->race && spell_ob->race == tmp2->name) 1065 else if (spell_ob->race && spell_ob->race == tmp2->name)
1065 { 1066 {
1066 if (!silent) 1067 if (!silent)
1067 new_draw_info_format (NDI_UNIQUE, 0, op,
1068 "You can not cast %s while %s is in effect", 1068 op->failmsgf ("You can not cast %s while %s is in effect",
1069 &spell_ob->name, &tmp2->name_pl); 1069 &spell_ob->name, &tmp2->name_pl);
1070 1070
1071 return 0; 1071 return 0;
1072 } 1072 }
1073 } 1073 }
1074 } 1074 }
… …
1103 1103
1104 force->name_pl = spell_ob->name; 1104 force->name_pl = spell_ob->name;
1105 1105
1106 force->speed = 1.0; 1106 force->speed = 1.0;
1107 force->speed_left = -1.0; 1107 force->speed_left = -1.0;
1108 SET_FLAG (force, FLAG_APPLIED); 1108 force->set_flag (FLAG_APPLIED);
1109 1109
1110 /* Now start processing the effects. First, protections */ 1110 /* Now start processing the effects. First, protections */
1111 for (i = 0; i < NROFATTACKS; i++) 1111 for (i = 0; i < NROFATTACKS; i++)
1112 { 1112 {
1113 if (spell_ob->resist[i]) 1113 if (spell_ob->resist[i])
… …
1143 } 1143 }
1144 } 1144 }
1145 1145
1146 force->move_type = spell_ob->move_type; 1146 force->move_type = spell_ob->move_type;
1147 1147
1148 if (QUERY_FLAG (spell_ob, FLAG_SEE_IN_DARK)) 1148 if (spell_ob->flag [FLAG_SEE_IN_DARK])
1149 SET_FLAG (force, FLAG_SEE_IN_DARK); 1149 force->set_flag (FLAG_SEE_IN_DARK);
1150 1150
1151 if (QUERY_FLAG (spell_ob, FLAG_XRAYS)) 1151 if (spell_ob->flag [FLAG_XRAYS])
1152 SET_FLAG (force, FLAG_XRAYS); 1152 force->set_flag (FLAG_XRAYS);
1153 1153
1154 /* Haste/bonus speed */ 1154 /* Haste/bonus speed */
1155 if (spell_ob->stats.exp) 1155 if (spell_ob->stats.exp)
1156 { 1156 {
1157 if (op->speed > 0.5f) 1157 if (op->speed > 0.5f)
… …
1238 return 0; 1238 return 0;
1239 } 1239 }
1240 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1240 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1241 force->speed = 1.0; 1241 force->speed = 1.0;
1242 force->speed_left = -1.0; 1242 force->speed_left = -1.0;
1243 SET_FLAG (force, FLAG_APPLIED); 1243 force->set_flag (FLAG_APPLIED);
1244 1244
1245 if (!god) 1245 if (!god)
1246 { 1246 {
1247 new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty."); 1247 new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty.");
1248 } 1248 }
1249 else 1249 else
1250 { 1250 {
1251 /* Only give out good benefits, and put a max on it */ 1251 /* Only give out good benefits, and put a max on it */
1252 for (i = 0; i < NROFATTACKS; i++) 1252 for (i = 0; i < NROFATTACKS; i++)
1253 {
1254 if (god->resist[i] > 0) 1253 if (god->resist[i] > 0)
1255 {
1256 force->resist[i] = MIN (god->resist[i], spell_ob->resist[ATNR_GODPOWER]); 1254 force->resist[i] = min (god->resist[i], spell_ob->resist[ATNR_GODPOWER]);
1257 } 1255
1258 }
1259 force->path_attuned |= god->path_attuned; 1256 force->path_attuned |= god->path_attuned;
1260 1257
1261 if (spell_ob->attacktype) 1258 if (spell_ob->attacktype)
1262 force->slaying = god->slaying; 1259 force->slaying = god->slaying;
1263 1260
… …
1305 * the nuggets, alchemy the gold from that, etc. 1302 * the nuggets, alchemy the gold from that, etc.
1306 * Otherwise, give 9 silver on the gold for other objects, 1303 * Otherwise, give 9 silver on the gold for other objects,
1307 * so that it would still be more affordable to haul 1304 * so that it would still be more affordable to haul
1308 * the stuff back to town. 1305 * the stuff back to town.
1309 */ 1306 */
1310 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1307 if (obj->flag [FLAG_UNPAID])
1311 value = 0; 1308 value = 0;
1312 else if (obj->type == MONEY || obj->type == GEM) 1309 else if (obj->type == MONEY || obj->type == GEM)
1313 value /= 3; 1310 value /= 3;
1314 else 1311 else
1315 value = value * 9 / 10; 1312 value = value * 9 / 10;
… …
1328 if (op->type != PLAYER) 1325 if (op->type != PLAYER)
1329 return 0; 1326 return 0;
1330 1327
1331 archetype *nugget[3]; 1328 archetype *nugget[3];
1332 1329
1333 nugget[0] = archetype::find ("pyrite3"); 1330 nugget[0] = archetype::find (shstr_pyrite3);
1334 nugget[1] = archetype::find ("pyrite2"); 1331 nugget[1] = archetype::find (shstr_pyrite2);
1335 nugget[2] = archetype::find ("pyrite"); 1332 nugget[2] = archetype::find (shstr_pyrite);
1336 1333
1337 /* Put a maximum weight of items that can be alchemised. Limits the power 1334 /* Put a maximum weight of items that can be alchemised. Limits the power
1338 * some, and also prevents people from alchemising every table/chair/clock 1335 * some, and also prevents people from alchemising every table/chair/clock
1339 * in sight 1336 * in sight
1340 */ 1337 */
… …
1369 1366
1370 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next) 1367 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1371 { 1368 {
1372 next = tmp->above; 1369 next = tmp->above;
1373 1370
1374 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1371 if (tmp->weight > 0 && !tmp->flag [FLAG_NO_PICK] &&
1375 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1372 !tmp->flag [FLAG_ALIVE] && !tmp->flag [FLAG_IS_CAULDRON])
1376 { 1373 {
1377 if (tmp->inv) 1374 if (tmp->inv)
1378 { 1375 {
1379 object *next1, *tmp1; 1376 object *next1, *tmp1;
1380 1377
1381 for (tmp1 = tmp->inv; tmp1; tmp1 = next1) 1378 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1382 { 1379 {
1383 next1 = tmp1->below; 1380 next1 = tmp1->below;
1384 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1381 if (tmp1->weight > 0 && !tmp1->flag [FLAG_NO_PICK] &&
1385 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1382 !tmp1->flag [FLAG_ALIVE] && !tmp1->flag [FLAG_IS_CAULDRON])
1386 alchemy_object (tmp1, value, weight); 1383 alchemy_object (tmp1, value, weight);
1387 } 1384 }
1388 } 1385 }
1389 1386
1390 alchemy_object (tmp, value, weight); 1387 alchemy_object (tmp, value, weight);
… …
1400 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i) 1397 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1401 if (int nrof = value / nugget [i]->value) 1398 if (int nrof = value / nugget [i]->value)
1402 { 1399 {
1403 value -= nrof * nugget[i]->value; 1400 value -= nrof * nugget[i]->value;
1404 1401
1405 object *tmp = arch_to_object (nugget[i]); 1402 object *tmp = nugget[i]->instance ();
1406 tmp->nrof = nrof; 1403 tmp->nrof = nrof;
1407 tmp->flag [FLAG_IDENTIFIED] = true; 1404 tmp->flag [FLAG_IDENTIFIED] = true;
1408 op->map->insert (tmp, x, y, op, 0); 1405 op->map->insert (tmp, x, y, op, 0);
1409 } 1406 }
1410 1407
… …
1424remove_curse (object *op, object *caster, object *spell) 1421remove_curse (object *op, object *caster, object *spell)
1425{ 1422{
1426 int success = 0, was_one = 0; 1423 int success = 0, was_one = 0;
1427 1424
1428 for (object *tmp = op->inv; tmp; tmp = tmp->below) 1425 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1429 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1426 if (tmp->flag [FLAG_APPLIED] &&
1430 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1427 ((tmp->flag [FLAG_CURSED] && spell->flag [FLAG_CURSED]) ||
1431 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1428 (tmp->flag [FLAG_DAMNED] && spell->flag [FLAG_DAMNED])))
1432 { 1429 {
1433 was_one++; 1430 was_one++;
1434 1431
1435 if (tmp->level <= casting_level (caster, spell)) 1432 if (tmp->level <= casting_level (caster, spell))
1436 { 1433 {
1437 success++; 1434 success++;
1438 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1435 if (spell->flag [FLAG_DAMNED])
1439 CLEAR_FLAG (tmp, FLAG_DAMNED); 1436 tmp->clr_flag (FLAG_DAMNED);
1440 1437
1441 CLEAR_FLAG (tmp, FLAG_CURSED); 1438 tmp->clr_flag (FLAG_CURSED);
1442 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED); 1439 tmp->clr_flag (FLAG_KNOWN_CURSED);
1443 tmp->value = 0; /* Still can't sell it */ 1440 tmp->value = 0; /* Still can't sell it */
1444 1441
1445 if (object *pl = tmp->visible_to ()) 1442 if (object *pl = tmp->visible_to ())
1446 esrv_update_item (UPD_FLAGS, pl, tmp); 1443 esrv_update_item (UPD_FLAGS, pl, tmp);
1447 } 1444 }
… …
1472 1469
1473 int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell)); 1470 int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1474 1471
1475 for (tmp = op->inv; tmp; tmp = tmp->below) 1472 for (tmp = op->inv; tmp; tmp = tmp->below)
1476 { 1473 {
1477 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1474 if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && need_identify (tmp))
1478 { 1475 {
1479 identify (tmp); 1476 identify (tmp);
1480 1477
1481 if (op->type == PLAYER) 1478 if (op->type == PLAYER)
1482 { 1479 {
… …
1496 * was not fully used. 1493 * was not fully used.
1497 */ 1494 */
1498 if (num_ident) 1495 if (num_ident)
1499 { 1496 {
1500 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above) 1497 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1501 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1498 if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && need_identify (tmp))
1502 { 1499 {
1503 identify (tmp); 1500 identify (tmp);
1504 1501
1505 if (object *pl = tmp->visible_to ()) 1502 if (object *pl = tmp->visible_to ())
1506 { 1503 {
… …
1546 range = spell->range + SP_level_range_adjust (caster, spell); 1543 range = spell->range + SP_level_range_adjust (caster, spell);
1547 1544
1548 if (!skill) 1545 if (!skill)
1549 skill = caster; 1546 skill = caster;
1550 1547
1548 dynbuf buf;
1551 unordered_mapwalk (op, -range, -range, range, range) 1549 unordered_mapwalk (buf, op, -range, -range, range, range)
1552 { 1550 {
1553 /* For most of the detections, we only detect objects above the 1551 /* For most of the detections, we only detect objects above the
1554 * floor. But this is not true for show invisible. 1552 * floor. But this is not true for show invisible.
1555 * Basically, we just go and find the top object and work 1553 * Basically, we just go and find the top object and work
1556 * down - that is easier than working up. 1554 * down - that is easier than working up.
1557 */ 1555 */
1558 1556
1559 for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above) 1557 for (last = 0, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1560 last = tmp; 1558 last = tmp;
1561 1559
1562 /* Shouldn't happen, but if there are no objects on a space, this 1560 /* Shouldn't happen, but if there are no objects on a space, this
1563 * would happen. 1561 * would happen.
1564 */ 1562 */
1565 if (!last) 1563 if (!last)
1566 continue; 1564 continue;
1567 1565
1568 done_one = 0; 1566 done_one = 0;
1569 floor = 0; 1567 floor = 0;
1570 detect = NULL; 1568 detect = 0;
1571 for (tmp = last; tmp; tmp = tmp->below) 1569 for (tmp = last; tmp; tmp = tmp->below)
1572 { 1570 {
1573 /* show invisible */ 1571 /* show invisible */
1574 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1572 if (spell->flag [FLAG_MAKE_INVIS]
1575 /* Might there be other objects that we can make visible? */ 1573 /* Might there be other objects that we can make visible? */
1576 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) 1574 && (tmp->invisible && (tmp->flag [FLAG_MONSTER]
1577 || (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) 1575 || (tmp->type == PLAYER && !tmp->flag [FLAG_WIZ])
1578 || tmp->type == CF_HANDLE 1576 || tmp->type == T_HANDLE
1579 || tmp->type == TRAPDOOR 1577 || tmp->type == TRAPDOOR
1580 || tmp->type == EXIT 1578 || tmp->type == EXIT
1581 || tmp->type == HOLE 1579 || tmp->type == HOLE
1582 || tmp->type == BUTTON 1580 || tmp->type == BUTTON
1583 || tmp->type == TELEPORTER 1581 || tmp->type == TELEPORTER
1584 || tmp->type == GATE 1582 || tmp->type == GATE
1585 || tmp->type == LOCKED_DOOR 1583 || tmp->type == LOCKED_DOOR
1586 || tmp->type == WEAPON 1584 || tmp->type == WEAPON
1587 || tmp->type == ALTAR 1585 || tmp->type == ALTAR
1588 || tmp->type == SIGN 1586 || (tmp->type == SIGN && tmp->face != magicmouth_face)
1589 || tmp->type == TRIGGER_PEDESTAL 1587 || tmp->type == TRIGGER_PEDESTAL
1590 || tmp->type == SPECIAL_KEY 1588 || tmp->type == SPECIAL_KEY
1591 || tmp->type == TREASURE 1589 || tmp->type == TREASURE
1592 || tmp->type == BOOK 1590 || tmp->type == BOOK
1593 || tmp->type == HOLY_ALTAR 1591 || tmp->type == HOLY_ALTAR
1594 || tmp->type == CONTAINER))) 1592 || tmp->type == CONTAINER)))
1595 { 1593 {
1594 printf ("show inv %s\n", tmp->debug_desc());//D
1596 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4) 1595 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1597 { 1596 {
1598 tmp->invisible = 0; 1597 tmp->invisible = 0;
1599 done_one = 1; 1598 done_one = 1;
1600 } 1599 }
1601 } 1600 }
1602 1601
1603 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1602 if (tmp->flag [FLAG_IS_FLOOR])
1604 floor = 1; 1603 floor = 1;
1605 1604
1606 /* All detections below this point don't descend beneath the floor, 1605 /* All detections below this point don't descend beneath the floor,
1607 * so just continue on. We could be clever and look at the type of 1606 * so just continue on. We could be clever and look at the type of
1608 * detection to completely break out if we don't care about objects beneath 1607 * detection to completely break out if we don't care about objects beneath
… …
1617 * difficult to see what object is magical/cursed, so the 1616 * difficult to see what object is magical/cursed, so the
1618 * effect wouldn't be as apparent. 1617 * effect wouldn't be as apparent.
1619 */ 1618 */
1620 1619
1621 /* detect magic */ 1620 /* detect magic */
1622 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && 1621 if (spell->flag [FLAG_KNOWN_MAGICAL] &&
1623 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp)) 1622 !tmp->flag [FLAG_KNOWN_MAGICAL] && !tmp->flag [FLAG_IDENTIFIED] && is_magical (tmp))
1624 { 1623 {
1625 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1624 tmp->set_flag (FLAG_KNOWN_MAGICAL);
1626 /* make runes more visibile */ 1625 /* make runes more visible */
1627 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC) 1626 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1628 tmp->stats.Cha /= 4; 1627 tmp->stats.Cha /= 4;
1629 1628
1630 done_one = 1; 1629 done_one = 1;
1631 } 1630 }
1632 1631
1633 /* detect monster */ 1632 /* detect monster */
1634 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER)) 1633 if (spell->flag [FLAG_MONSTER] && (tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER))
1635 { 1634 {
1636 done_one = 2; 1635 done_one = 2;
1637 1636
1638 if (!detect) 1637 if (!detect)
1639 detect = tmp; 1638 detect = tmp;
… …
1641 1640
1642 /* Basically, if race is set in the spell, then the creatures race must 1641 /* Basically, if race is set in the spell, then the creatures race must
1643 * match that. if the spell race is set to GOD, then the gods opposing 1642 * match that. if the spell race is set to GOD, then the gods opposing
1644 * race must match. 1643 * race must match.
1645 */ 1644 */
1646 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race && 1645 if (spell->race && tmp->flag [FLAG_MONSTER] && tmp->race &&
1647 ((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) || 1646 ((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1648 spell->race.contains (tmp->race))) 1647 spell->race.contains (tmp->race)))
1649 { 1648 {
1650 done_one = 2; 1649 done_one = 2;
1651 1650
1652 if (!detect) 1651 if (!detect)
1653 detect = tmp; 1652 detect = tmp;
1654 } 1653 }
1655 1654
1656 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1655 if (spell->flag [FLAG_KNOWN_CURSED] && !tmp->flag [FLAG_KNOWN_CURSED] &&
1657 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1656 (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1658 { 1657 {
1659 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1658 tmp->set_flag (FLAG_KNOWN_CURSED);
1660 done_one = 1; 1659 done_one = 1;
1660 }
1661
1662 // Do mining detection spell:
1663 if (spell->last_sp == 1) // 1 - detect any vein
1664 {
1665 if (tmp->type == VEIN)
1666 {
1667 if (tmp->other_arch)
1668 {
1669 if (!detect)
1670 detect = tmp->other_arch;
1671 done_one = 2;
1672 }
1673 else
1674 done_one = 1;
1675 }
1661 } 1676 }
1662 } /* for stack of objects on this space */ 1677 } /* for stack of objects on this space */
1663 1678
1664 /* Code here puts an effect of the spell on the space, so you can see 1679 /* Code here puts an effect of the spell on the space, so you can see
1665 * where the magic is. 1680 * where the magic is.
1666 */ 1681 */
1667 if (done_one) 1682 if (done_one)
1668 { 1683 {
1669 object *detect_ob = arch_to_object (spell->other_arch); 1684 object *detect_ob = spell->other_arch->instance ();
1670 1685
1671 /* if this is set, we want to copy the face */ 1686 /* if this is set, we want to copy the face */
1672 if (done_one == 2 && detect) 1687 if (done_one == 2 && detect)
1673 { 1688 {
1674 detect_ob->face = detect->face; 1689 detect_ob->face = detect->face;
1675 detect_ob->animation_id = detect->animation_id; 1690 detect_ob->animation_id = detect->animation_id;
1676 detect_ob->anim_speed = detect->anim_speed; 1691 detect_ob->anim_speed = detect->anim_speed;
1677 detect_ob->last_anim = 0; 1692 detect_ob->last_anim = 0;
1678 /* by default, the detect_ob is already animated */ 1693 /* by default, the detect_ob is already animated */
1679 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1694 if (!detect->flag [FLAG_ANIMATE])
1680 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1695 detect_ob->clr_flag (FLAG_ANIMATE);
1681 } 1696 }
1682 1697
1683 m->insert (detect_ob, nx, ny, op); 1698 m->insert (detect_ob, nx, ny, op, INS_ON_TOP);
1684 } 1699 }
1685 } /* for processing the surrounding spaces */ 1700 } /* for processing the surrounding spaces */
1686 1701
1687 1702
1688 /* Now process objects in the players inventory if detect curse or magic */ 1703 /* Now process objects in the players inventory if detect curse or magic */
1689 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL)) 1704 if (spell->flag [FLAG_KNOWN_CURSED] || spell->flag [FLAG_KNOWN_MAGICAL])
1690 { 1705 {
1691 done_one = 0; 1706 done_one = 0;
1692 1707
1693 for (tmp = op->inv; tmp; tmp = tmp->below) 1708 for (tmp = op->inv; tmp; tmp = tmp->below)
1694 { 1709 {
1695 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1710 if (!tmp->invisible && !tmp->flag [FLAG_IDENTIFIED])
1696 { 1711 {
1697 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL)) 1712 if (spell->flag [FLAG_KNOWN_MAGICAL] && is_magical (tmp) && !tmp->flag [FLAG_KNOWN_MAGICAL])
1698 { 1713 {
1699 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1714 tmp->set_flag (FLAG_KNOWN_MAGICAL);
1700 1715
1701 if (object *pl = tmp->visible_to ()) 1716 if (object *pl = tmp->visible_to ())
1702 esrv_update_item (UPD_FLAGS, pl, tmp); 1717 esrv_update_item (UPD_FLAGS, pl, tmp);
1703 } 1718 }
1704 1719
1705 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1720 if (spell->flag [FLAG_KNOWN_CURSED] && !tmp->flag [FLAG_KNOWN_CURSED] &&
1706 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1721 (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1707 { 1722 {
1708 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1723 tmp->set_flag (FLAG_KNOWN_CURSED);
1709 1724
1710 if (object *pl = tmp->visible_to ()) 1725 if (object *pl = tmp->visible_to ())
1711 esrv_update_item (UPD_FLAGS, pl, tmp); 1726 esrv_update_item (UPD_FLAGS, pl, tmp);
1712 } 1727 }
1713 } /* if item is not identified */ 1728 } /* if item is not identified */
… …
1773 mflags = get_map_flags (m, &m, x, y, &x, &y); 1788 mflags = get_map_flags (m, &m, x, y, &x, &y);
1774 1789
1775 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 1790 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
1776 { 1791 {
1777 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above) 1792 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
1778 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 1793 if (plyr != op && plyr->flag [FLAG_ALIVE])
1779 break; 1794 break;
1780 } 1795 }
1781 1796
1782 1797
1783 /* If we did not find a player in the specified direction, transfer 1798 /* If we did not find a player in the specified direction, transfer
1784 * to anyone on top of us. This is used for the rune of transference mostly. 1799 * to anyone on top of us. This is used for the rune of transference mostly.
1785 */ 1800 */
1786 if (plyr == NULL) 1801 if (plyr == NULL)
1787 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above) 1802 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
1788 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 1803 if (plyr != op && plyr->flag [FLAG_ALIVE])
1789 break; 1804 break;
1790 1805
1791 if (!plyr) 1806 if (!plyr)
1792 { 1807 {
1793 new_draw_info (NDI_BLACK, 0, op, "There is no one there."); 1808 op->failmsg ("There is no one there.");
1794 return 0; 1809 return 0;
1795 } 1810 }
1796 /* give sp */ 1811 /* give sp */
1797 if (spell->stats.dam > 0) 1812 if (spell->stats.dam > 0)
1798 { 1813 {
… …
1810 if (rate > 95) 1825 if (rate > 95)
1811 rate = 95; 1826 rate = 95;
1812 1827
1813 sucked = (plyr->stats.sp * rate) / 100; 1828 sucked = (plyr->stats.sp * rate) / 100;
1814 plyr->stats.sp -= sucked; 1829 plyr->stats.sp -= sucked;
1815 if (QUERY_FLAG (op, FLAG_ALIVE)) 1830 if (op->flag [FLAG_ALIVE])
1816 { 1831 {
1817 /* Player doesn't get full credit */ 1832 /* Player doesn't get full credit */
1818 sucked = (sucked * rate) / 100; 1833 sucked = (sucked * rate) / 100;
1819 op->stats.sp += sucked; 1834 op->stats.sp += sucked;
1820 if (sucked > 0) 1835 if (sucked > 0)
… …
1871 * monsters either. 1886 * monsters either.
1872 */ 1887 */
1873 1888
1874 if (head->attacktype & AT_MAGIC 1889 if (head->attacktype & AT_MAGIC
1875 && !(head->attacktype & AT_COUNTERSPELL) 1890 && !(head->attacktype & AT_COUNTERSPELL)
1876 && !QUERY_FLAG (head, FLAG_MONSTER) 1891 && !head->flag [FLAG_MONSTER]
1877 && (op->level > head->level)) 1892 && (op->level > head->level))
1878 head->destroy (); 1893 head->destroy ();
1879 else 1894 else
1880 switch (head->type) 1895 switch (head->type)
1881 { 1896 {
1882 case SPELL_EFFECT: 1897 case SPELL_EFFECT:
1883 // XXX: Don't affect floor spelleffects. See also XXX comment 1898 // XXX: Don't affect floor spelleffects. See also XXX comment
1884 // about sanctuary in spell_util.C 1899 // about sanctuary in spell_util.C
1885 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1900 if (tmp->flag [FLAG_IS_FLOOR])
1886 continue; 1901 continue;
1887 1902
1888 if (op->level > head->level) 1903 if (op->level > head->level)
1889 head->destroy (); 1904 head->destroy ();
1890 1905
… …
1913 1928
1914 object *tmp, *god = find_god (determine_god (op)); 1929 object *tmp, *god = find_god (determine_god (op));
1915 1930
1916 if (!god) 1931 if (!god)
1917 { 1932 {
1918 new_draw_info (NDI_UNIQUE, 0, op, "You can't consecrate anything if you don't worship a god!"); 1933 op->failmsg ("You can't consecrate anything if you don't worship a god!");
1919 return 0; 1934 return 0;
1920 } 1935 }
1921 1936
1922 for (tmp = op->below; tmp; tmp = tmp->below) 1937 for (tmp = op->below; tmp; tmp = tmp->below)
1923 { 1938 {
1924 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1939 if (tmp->flag [FLAG_IS_FLOOR])
1925 break; 1940 break;
1926 if (tmp->type == HOLY_ALTAR) 1941 if (tmp->type == HOLY_ALTAR)
1927 { 1942 {
1928 1943
1929 if (tmp->level > casting_level (caster, spell)) 1944 if (tmp->level > casting_level (caster, spell))
1930 { 1945 {
1931 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name); 1946 op->failmsgf ("You are not powerful enough to reconsecrate the %s", &tmp->name);
1932 return 0; 1947 return 0;
1933 } 1948 }
1934 else 1949 else
1935 { 1950 {
1936 /* If we got here, we are consecrating an altar */ 1951 /* If we got here, we are consecrating an altar */
… …
1945 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name); 1960 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1946 return 1; 1961 return 1;
1947 } 1962 }
1948 } 1963 }
1949 } 1964 }
1950 new_draw_info (NDI_UNIQUE, 0, op, "You are not standing over an altar!"); 1965
1966 op->failmsg ("You are not standing over an altar!");
1951 return 0; 1967 return 0;
1952} 1968}
1953 1969
1954/* animate_weapon - 1970/* animate_weapon -
1955 * Generalization of staff_to_snake. Makes a golem out of the caster's weapon. 1971 * Generalization of staff_to_snake. Makes a golem out of the caster's weapon.
… …
1997 2013
1998 /* if there's no place to put the golem, abort */ 2014 /* if there's no place to put the golem, abort */
1999 if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) 2015 if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2000 || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type)) 2016 || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2001 { 2017 {
2002 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 2018 op->failmsg ("There is something in the way.");
2003 return 0; 2019 return 0;
2004 } 2020 }
2005 2021
2006 /* Use the weapon marked by the player. */ 2022 /* Use the weapon marked by the player. */
2007 weapon = find_marked_object (op); 2023 weapon = find_marked_object (op);
2008 2024
2009 if (!weapon) 2025 if (!weapon)
2010 { 2026 {
2011 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 2027 op->failmsg ("You must mark a weapon to use with this spell!");
2012 return 0; 2028 return 0;
2013 } 2029 }
2014 2030
2015 if (spell->race && weapon->arch->archname != spell->race) 2031 if (spell->race && weapon->arch->archname != spell->race)
2016 { 2032 {
2017 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2033 op->failmsg ("The spell fails to transform your weapon.");
2018 return 0; 2034 return 0;
2019 } 2035 }
2020 2036
2021 if (weapon->type != WEAPON) 2037 if (weapon->type != WEAPON)
2022 { 2038 {
2023 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it."); 2039 op->failmsg ("You need to wield a weapon to animate it.");
2024 return 0; 2040 return 0;
2025 } 2041 }
2026 2042
2027 if (QUERY_FLAG (weapon, FLAG_APPLIED)) 2043 if (weapon->flag [FLAG_APPLIED])
2028 { 2044 {
2029 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon)); 2045 op->failmsgf ("You need to unequip %s before using it in this spell", query_name (weapon));
2030 return 0; 2046 return 0;
2031 } 2047 }
2032 2048
2033 weapon = weapon->split (); 2049 weapon = weapon->split ();
2034 2050
2035 /* create the golem object */ 2051 /* create the golem object */
2036 tmp = arch_to_object (spell->other_arch); 2052 tmp = spell->other_arch->instance ();
2037 2053
2038 /* if animated by a player, give the player control of the golem */ 2054 /* if animated by a player, give the player control of the golem */
2039 CLEAR_FLAG (tmp, FLAG_MONSTER); 2055 tmp->clr_flag (FLAG_MONSTER);
2040 tmp->stats.exp = 0; 2056 tmp->stats.exp = 0;
2041 add_friendly_object (tmp); 2057 add_friendly_object (tmp);
2042 tmp->type = GOLEM; 2058 tmp->type = GOLEM;
2043 tmp->set_owner (op); 2059 tmp->set_owner (op);
2044 op->contr->golem = tmp; 2060 op->contr->golem = tmp;
… …
2046 2062
2047 /* Give the weapon to the golem now. A bit of a hack to check the 2063 /* Give the weapon to the golem now. A bit of a hack to check the
2048 * removed flag - it should only be set if weapon->split was 2064 * removed flag - it should only be set if weapon->split was
2049 * used above. 2065 * used above.
2050 */ 2066 */
2051 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2067 if (!weapon->flag [FLAG_REMOVED])
2052 weapon->remove (); 2068 weapon->remove ();
2053 2069
2054 tmp->insert (weapon); 2070 tmp->insert (weapon);
2055 2071
2056 /* To do everything necessary to let a golem use the weapon is a pain, 2072 /* To do everything necessary to let a golem use the weapon is a pain,
2057 * so instead, just set it as equipped (otherwise, we need to update 2073 * so instead, just set it as equipped (otherwise, we need to update
2058 * body_info, skills, etc) 2074 * body_info, skills, etc)
2059 */ 2075 */
2060 SET_FLAG (tmp, FLAG_USE_WEAPON); 2076 tmp->set_flag (FLAG_USE_WEAPON);
2061 SET_FLAG (weapon, FLAG_APPLIED); 2077 weapon->set_flag (FLAG_APPLIED);
2062 tmp->update_stats (); 2078 tmp->update_stats ();
2063 2079
2064 /* There used to be 'odd' code that basically seemed to take the absolute 2080 /* There used to be 'odd' code that basically seemed to take the absolute
2065 * value of the weapon->magic an use that. IMO, that doesn't make sense - 2081 * value of the weapon->magic an use that. IMO, that doesn't make sense -
2066 * if you're using a crappy weapon, it shouldn't be as good. 2082 * if you're using a crappy weapon, it shouldn't be as good.
… …
2086 2102
2087 /* attacktype */ 2103 /* attacktype */
2088 if (!tmp->attacktype) 2104 if (!tmp->attacktype)
2089 tmp->attacktype = AT_PHYSICAL; 2105 tmp->attacktype = AT_PHYSICAL;
2090 2106
2091 if (materialtype_t *mt = name_to_material (op->materialname))
2092 {
2093 for (i = 0; i < NROFATTACKS; i++) 2107 for (i = 0; i < NROFATTACKS; i++)
2094 tmp->resist[i] = 50 - (mt->save[i] * 5); 2108 tmp->resist[i] = 50 - (op->material->save[i] * 5);
2095 a = mt->save[0]; 2109
2096 } 2110 a = op->material->save[0];
2097 else
2098 {
2099 for (i = 0; i < NROFATTACKS; i++)
2100 tmp->resist[i] = 5;
2101 a = 10;
2102 }
2103 2111
2104 /* Set weapon's immunity */ 2112 /* Set weapon's immunity */
2105 tmp->resist[ATNR_CONFUSION] = 100; 2113 tmp->resist[ATNR_CONFUSION] = 100;
2106 tmp->resist[ATNR_POISON] = 100; 2114 tmp->resist[ATNR_POISON] = 100;
2107 tmp->resist[ATNR_SLOW] = 100; 2115 tmp->resist[ATNR_SLOW] = 100;
… …
2134 tmp->state = weapon->state; 2142 tmp->state = weapon->state;
2135 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE]; 2143 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2136 } 2144 }
2137 2145
2138 /* make experience increase in proportion to the strength of the summoned creature. */ 2146 /* make experience increase in proportion to the strength of the summoned creature. */
2139 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell)); 2147 tmp->stats.exp *= 1 + (max (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2140 2148
2141 tmp->speed_left = -1; 2149 tmp->speed_left = -1;
2142 tmp->direction = dir; 2150 tmp->direction = dir;
2143 2151
2144 m->insert (tmp, x, y, op); 2152 m->insert (tmp, x, y, op);
… …
2161 success = op->map->change_map_light (spell->stats.dam); 2169 success = op->map->change_map_light (spell->stats.dam);
2162 2170
2163 if (!success) 2171 if (!success)
2164 { 2172 {
2165 if (spell->stats.dam < 0) 2173 if (spell->stats.dam < 0)
2166 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2174 op->failmsg ("It can be no brighter here.");
2167 else 2175 else
2168 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2176 op->failmsg ("It can be no darker here.");
2169 } 2177 }
2170 2178
2171 return success; 2179 return success;
2172} 2180}
2173 2181
… …
2183 2191
2184 new_aura = present_arch_in_ob (spell->other_arch, op); 2192 new_aura = present_arch_in_ob (spell->other_arch, op);
2185 if (new_aura) 2193 if (new_aura)
2186 refresh = 1; 2194 refresh = 1;
2187 else 2195 else
2188 new_aura = arch_to_object (spell->other_arch); 2196 new_aura = spell->other_arch->instance ();
2189 2197
2190 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2198 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2191 2199
2192 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2200 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2193 2201
… …
2258 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block))) 2266 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2259 { 2267 {
2260 hit_map (aura, i, aura->attacktype, 0); 2268 hit_map (aura, i, aura->attacktype, 0);
2261 2269
2262 if (aura->other_arch) 2270 if (aura->other_arch)
2263 pos.insert (arch_to_object (aura->other_arch), aura); 2271 pos.insert (aura->other_arch->instance (), aura);
2264 } 2272 }
2265 } 2273 }
2266 2274
2267 /* put the aura back in the player's inventory */ 2275 /* put the aura back in the player's inventory */
2268 env->insert (aura); 2276 env->insert (aura);
… …
2278 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above) 2286 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2279 { 2287 {
2280 int atk_lev, def_lev; 2288 int atk_lev, def_lev;
2281 object *victim = tmp->head_ (); 2289 object *victim = tmp->head_ ();
2282 2290
2283 if (!QUERY_FLAG (victim, FLAG_MONSTER)) 2291 if (!victim->flag [FLAG_MONSTER])
2284 continue; 2292 continue;
2285 2293
2286 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE)) 2294 if (victim->flag [FLAG_UNAGGRESSIVE])
2287 continue; 2295 continue;
2288 2296
2289 if (victim->stats.exp == 0) 2297 if (victim->stats.exp == 0)
2290 continue; 2298 continue;
2291 2299
2292 def_lev = MAX (1, victim->level); 2300 def_lev = max (1, victim->level);
2293 atk_lev = MAX (1, op->level); 2301 atk_lev = max (1, op->level);
2294 2302
2295 if (rndm (0, atk_lev - 1) > def_lev) 2303 if (rndm (0, atk_lev - 1) > def_lev)
2296 { 2304 {
2297 /* make this sucker peaceful. */ 2305 /* make this sucker peaceful. */
2298 2306
… …
2307 victim->stats.sp = 0; 2315 victim->stats.sp = 0;
2308 victim->stats.grace = 0; 2316 victim->stats.grace = 0;
2309 victim->stats.Pow = 0; 2317 victim->stats.Pow = 0;
2310#endif 2318#endif
2311 victim->attack_movement = RANDO2; 2319 victim->attack_movement = RANDO2;
2312 SET_FLAG (victim, FLAG_UNAGGRESSIVE); 2320 victim->set_flag (FLAG_UNAGGRESSIVE);
2313 SET_FLAG (victim, FLAG_RUN_AWAY); 2321 victim->set_flag (FLAG_RUN_AWAY);
2314 SET_FLAG (victim, FLAG_RANDOM_MOVE); 2322 victim->set_flag (FLAG_RANDOM_MOVE);
2315 CLEAR_FLAG (victim, FLAG_MONSTER); 2323 victim->clr_flag (FLAG_MONSTER);
2316 2324
2317 if (victim->name) 2325 if (victim->name)
2318 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name); 2326 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2319 } 2327 }
2320 } 2328 }
… …
2326int 2334int
2327write_mark (object *op, object *spell, const char *msg) 2335write_mark (object *op, object *spell, const char *msg)
2328{ 2336{
2329 if (!msg || msg[0] == 0) 2337 if (!msg || msg[0] == 0)
2330 { 2338 {
2331 new_draw_info (NDI_UNIQUE, 0, op, "Write what?"); 2339 op->failmsg ("Write what?");
2332 return 0; 2340 return 0;
2333 } 2341 }
2334 2342
2335 if (strcasestr_local (msg, "endmsg")) 2343 if (!msg_is_safe (msg))
2336 { 2344 {
2337 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?"); 2345 op->failmsg ("Trying to cheat are we? H<@-signs are not allowed in marking runes.>");
2338 LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg); 2346 LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2339 return 0; 2347 return 0;
2340 } 2348 }
2341 2349
2342 if (!spell->other_arch) 2350 if (!spell->other_arch)
2343 return 0; 2351 return 0;
2344 2352
2345 object *tmp = arch_to_object (spell->other_arch); 2353 object *tmp = spell->other_arch->instance ();
2346 2354
2347 tmp->race = op->name; /*Save the owner of the rune */ 2355 tmp->race = op->name; /*Save the owner of the rune */
2348 tmp->msg = msg; 2356 tmp->msg = msg;
2349 2357
2350 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR); 2358 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);

Diff Legend

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