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.83 by root, Tue May 6 16:55:26 2008 UTC vs.
Revision 1.118 by root, Sun Feb 7 04:22:33 2010 UTC

… …
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * 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>
… …
61{ 62{
62 object *wand, *tmp; 63 object *wand, *tmp;
63 int ncharges; 64 int ncharges;
64 65
65 wand = find_marked_object (op); 66 wand = find_marked_object (op);
66 if (wand == NULL || 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 new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");
69 return 0; 70 return 0;
70 } 71 }
71 if (!(random_roll (0, 3, op, PREFER_HIGH))) 72 if (!(random_roll (0, 3, op, PREFER_HIGH)))
72 { 73 {
73 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));
74 op->play_sound (sound_find ("ob_explode")); 75 op->play_sound (sound_find ("ob_explode"));
75 wand->destroy (); 76 wand->destroy ();
76 tmp = get_archetype ("fireball"); 77 tmp = get_archetype (shstr_fireball);
77 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 78 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
78 79
79 if (!tmp->stats.dam) 80 if (!tmp->stats.dam)
80 tmp->stats.dam = 1; 81 tmp->stats.dam = 1;
81 82
… …
122 * The # of arrows created also goes up with level, so if a 30th level mage 123 * The # of arrows created also goes up with level, so if a 30th level mage
123 * wants LOTS of arrows, and doesn't care what the plus is he could 124 * wants LOTS of arrows, and doesn't care what the plus is he could
124 * create nonnmagic arrows, or even -1, etc... 125 * create nonnmagic arrows, or even -1, etc...
125 */ 126 */
126int 127int
127cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg) 128cast_create_missile (object *op, object *caster, object *spell, int dir, const char *spellparam)
128{ 129{
129 int bonus_plus = 0; 130 int bonus_plus = 0;
130 const char *missile_name = "arrow"; 131 const char *missile_name = "arrow";
131 132
132 for (object *tmp = op->inv; tmp; tmp = tmp->below) 133 for (object *tmp = op->inv; tmp; tmp = tmp->below)
… …
143 return 0; 144 return 0;
144 } 145 }
145 146
146 object *missile = missile_arch->instance (); 147 object *missile = missile_arch->instance ();
147 148
148 if (stringarg) 149 if (spellparam)
149 { 150 {
150 /* If it starts with a letter, presume it is a description */ 151 /* If it starts with a letter, presume it is a description */
151 if (isalpha (*stringarg)) 152 if (isalpha (*spellparam))
152 { 153 {
153 artifact *al = find_artifactlist (missile->type)->items; 154 artifact *al = find_artifactlist (missile->type)->items;
154 155
155 for (; al; al = al->next) 156 for (; al; al = al->next)
156 if (!strcasecmp (al->item->name, stringarg)) 157 if (!strcasecmp (al->item->name, spellparam))
157 break; 158 break;
158 159
159 if (!al) 160 if (!al)
160 { 161 {
161 missile->destroy (); 162 missile->destroy ();
162 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg); 163 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, spellparam);
163 return 0; 164 return 0;
164 } 165 }
165 166
166 if (al->item->slaying) 167 if (al->item->slaying)
167 { 168 {
168 missile->destroy (); 169 missile->destroy ();
169 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg); 170 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, spellparam);
170 return 0; 171 return 0;
171 } 172 }
172 173
173 give_artifact_abilities (missile, al->item); 174 give_artifact_abilities (missile, al->item);
174 /* These special arrows cost something extra. Don't have them also be magical - 175 /* These special arrows cost something extra. Don't have them also be magical -
… …
176 * the parsing of having to do both plus and type. 177 * the parsing of having to do both plus and type.
177 */ 178 */
178 bonus_plus = 1 + (al->item->value / 5); 179 bonus_plus = 1 + (al->item->value / 5);
179 missile_plus = 0; 180 missile_plus = 0;
180 } 181 }
181 else if (atoi (stringarg) < missile_plus) 182 else if (atoi (spellparam) < missile_plus)
182 missile_plus = atoi (stringarg); 183 missile_plus = atoi (spellparam);
183 } 184 }
184 185
185 missile_plus = clamp (missile_plus, -4, 4); 186 missile_plus = clamp (missile_plus, -4, 4);
186 187
187 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 188 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
… …
202 return 1; 203 return 1;
203} 204}
204 205
205 206
206/* allows the choice of what sort of food object to make. 207/* allows the choice of what sort of food object to make.
207 * If stringarg is NULL, it will create food dependent on level --PeterM*/ 208 * If spellparam is NULL, it will create food dependent on level --PeterM*/
208int 209int
209cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *stringarg) 210cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
210{ 211{
211 int food_value; 212 int food_value;
212 archetype *at = NULL; 213 archetype *at = NULL;
213 object *new_op; 214 object *new_op;
214 215
215 food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob); 216 food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
216 217
217 if (stringarg) 218 if (spellparam)
218 { 219 {
219 at = find_archetype_by_object_type_name (FOOD, stringarg); 220 at = find_archetype_by_object_type_name (FOOD, spellparam);
220 if (at == NULL) 221 if (at == NULL)
221 at = find_archetype_by_object_type_name (DRINK, stringarg); 222 at = find_archetype_by_object_type_name (DRINK, spellparam);
222 if (at == NULL || at->stats.food > food_value) 223 if (at == NULL || at->stats.food > food_value)
223 stringarg = NULL; 224 spellparam = NULL;
224 } 225 }
225 226
226 if (!stringarg) 227 if (!spellparam)
227 { 228 {
228 archetype *at_tmp; 229 archetype *at_tmp;
229 230
230 /* We try to find the archetype with the maximum food value. 231 /* We try to find the archetype with the maximum food value.
231 * This removes the dependancy of hard coded food values in this 232 * This removes the dependancy of hard coded food values in this
… …
261 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food."); 262 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
262 return 0; 263 return 0;
263 } 264 }
264 265
265 food_value /= at->stats.food; 266 food_value /= at->stats.food;
266 new_op = arch_to_object (at); 267 new_op = at->instance ();
267 new_op->nrof = food_value; 268 new_op->nrof = food_value;
268 269
269 new_op->value = 0; 270 new_op->value = 0;
270 if (new_op->nrof < 1) 271 if (new_op->nrof < 1)
271 new_op->nrof = 1; 272 new_op->nrof = 1;
… …
301 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC)) 302 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))
302 { 303 {
303 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic."); 304 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
304 return 0; 305 return 0;
305 } 306 }
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; 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;
… …
344 346
345 return 1; 347 return 1;
346 } 348 }
347 349
348 /* invis_race is set if we get here */ 350 /* invis_race is set if we get here */
349 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 351 if (pl->contr->invis_race == shstr_undead && is_true_undead (mon))
350 return 1; 352 return 1;
351 353
352 /* No race, can't be invisible to it */ 354 /* No race, can't be invisible to it */
353 if (!mon->race) 355 if (!mon->race)
354 return 0; 356 return 0;
355 357
356 if (strstr (mon->race, pl->contr->invis_race)) 358 if (mon->race.contains (pl->contr->invis_race))
357 return 1; 359 return 1;
358 360
359 /* Nothing matched above, return 0 */ 361 /* Nothing matched above, return 0 */
360 return 0; 362 return 0;
361 } 363 }
… …
424/* earth to dust spell. Basically destroys earthwalls in the area. 426/* earth to dust spell. Basically destroys earthwalls in the area.
425 */ 427 */
426int 428int
427cast_earth_to_dust (object *op, object *caster, object *spell_ob) 429cast_earth_to_dust (object *op, object *caster, object *spell_ob)
428{ 430{
429 object *tmp, *next;
430 int range, i, j, mflags; 431 int range, i, j, mflags;
431 sint16 sx, sy; 432 sint16 sx, sy;
432 maptile *m; 433 maptile *m;
433
434 if (op->type != PLAYER)
435 return 0;
436 434
437 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 435 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
438 436
439 for (i = -range; i <= range; i++) 437 for (i = -range; i <= range; i++)
440 for (j = -range; j <= range; j++) 438 for (j = -range; j <= range; j++)
… …
445 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 443 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
446 444
447 if (mflags & P_OUT_OF_MAP) 445 if (mflags & P_OUT_OF_MAP)
448 continue; 446 continue;
449 447
450 // earth to dust tears down everything that can be teared down 448 // earth to dust tears down everything that can be torn down
451 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next) 449 for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
452 { 450 {
453 next = tmp->above; 451 next = tmp->above;
452
454 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 453 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
455 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 454 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
456 } 455 }
457 } 456 }
458 457
… …
491 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 490 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
492 return 1; 491 return 1;
493 } 492 }
494 493
495 dummy = get_archetype (FORCE_NAME); 494 dummy = get_archetype (FORCE_NAME);
496 if (dummy == NULL) 495
496 if (!dummy)
497 { 497 {
498 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 498 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
499 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n"); 499 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
500 return 0; 500 return 0;
501 } 501 }
… …
565 565
566int 566int
567perceive_self (object *op) 567perceive_self (object *op)
568{ 568{
569 const char *cp = describe_item (op, op); 569 const char *cp = describe_item (op, op);
570 archetype *at = archetype::find (ARCH_DEPLETION); 570 archetype *at = archetype::find (shstr_depletion);
571 571
572 dynbuf_text buf; 572 dynbuf_text &buf = msg_dynbuf; buf.clear ();
573 573
574 if (player *pl = op->contr) 574 if (!op->is_player ())
575 return 0;
576
575 if (object *race = archetype::find (op->race)) 577 if (object *race = archetype::find (op->race))
576 buf << "You are a " << (pl->gender ? "female" : "male") << " " << &race->name << ".\n"; 578 buf << " - You are a G<male|female> " << &race->name << ".\n";
577 579
578 if (object *god = find_god (determine_god (op))) 580 if (object *god = find_god (determine_god (op)))
579 buf << "You worship " << &god->name << ".\n"; 581 buf << " - You worship " << &god->name << ".\n";
580 else 582 else
581 buf << "You worship no god.\n"; 583 buf << " - You worship no god.\n";
582 584
583 object *tmp = present_arch_in_ob (at, op); 585 object *tmp = present_arch_in_ob (at, op);
584 586
585 if (*cp == '\0' && tmp == NULL) 587 if (*cp == '\0' && !tmp)
586 buf << "You feel very mundane. "; 588 buf << " - You feel very mundane. ";
587 else 589 else
588 { 590 {
589 buf << "You have: " << cp << ".\n"; 591 buf << " - You have: " << cp << ".\n";
590 592
591 if (tmp) 593 if (tmp)
592 for (int i = 0; i < NUM_STATS; i++) 594 for (int i = 0; i < NUM_STATS; i++)
593 if (tmp->stats.stat (i) < 0) 595 if (tmp->stats.stat (i) < 0)
594 buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i)); 596 buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
595 } 597 }
596 598
597 if (is_dragon_pl (op)) 599 if (op->is_dragon ())
598 /* now grab the 'dragon_ability'-force from the player's inventory */ 600 /* now grab the 'dragon_ability'-force from the player's inventory */
599 for (tmp = op->inv; tmp; tmp = tmp->below) 601 for (tmp = op->inv; tmp; tmp = tmp->below)
600 { 602 {
601 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force) 603 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
602 { 604 {
603 if (tmp->stats.exp == 0) 605 if (tmp->stats.exp == 0)
604 buf << "Your metabolism isn't focused on anything.\n"; 606 buf << " - Your metabolism isn't focused on anything.\n";
605 else 607 else
606 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n"; 608 buf << " - Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
607 609
608 break; 610 break;
609 } 611 }
610 } 612 }
611 613
612 buf << '\0'; // zero-terminate 614 op->contr->infobox (MSG_CHANNEL ("perceiveself"), buf);
613
614 new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
615 615
616 return 1; 616 return 1;
617} 617}
618 618
619/* This creates magic walls. Really, it can create most any object, 619/* This creates magic walls. Really, it can create most any object,
… …
650 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 650 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
651 return 0; 651 return 0;
652 } 652 }
653 653
654 if (spell_ob->other_arch) 654 if (spell_ob->other_arch)
655 tmp = arch_to_object (spell_ob->other_arch); 655 tmp = spell_ob->other_arch->instance ();
656 else if (spell_ob->race) 656 else if (spell_ob->race)
657 { 657 {
658 char buf1[MAX_BUF]; 658 char buf1[MAX_BUF];
659 659
660 sprintf (buf1, spell_ob->race, dir); 660 sprintf (buf1, spell_ob->race, dir);
… …
664 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1); 664 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
665 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken."); 665 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
666 return 0; 666 return 0;
667 } 667 }
668 668
669 tmp = arch_to_object (at); 669 tmp = at->instance ();
670 } 670 }
671 else 671 else
672 { 672 {
673 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name); 673 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
674 return 0; 674 return 0;
… …
707 */ 707 */
708 if (tmp->type != EARTHWALL) //TODO 708 if (tmp->type != EARTHWALL) //TODO
709 tmp->set_owner (op); 709 tmp->set_owner (op);
710 710
711 set_spell_skill (op, caster, spell_ob, tmp); 711 set_spell_skill (op, caster, spell_ob, tmp);
712 tmp->level = caster_level (caster, spell_ob) / 2; 712 tmp->level = casting_level (caster, spell_ob) / 2;
713 713
714 name = tmp->name; 714 name = tmp->name;
715 if (!(tmp = m->insert (tmp, x, y, op))) 715 if (!(tmp = m->insert (tmp, x, y, op)))
716 { 716 {
717 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 717 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
718 return 0; 718 return 0;
719 } 719 }
720 720
721 /* If this is a spellcasting wall, need to insert the spell object */ 721 /* If this is a spellcasting wall, need to insert the spell object */
722 if (tmp->other_arch && tmp->other_arch->type == SPELL) 722 if (tmp->other_arch && tmp->other_arch->type == SPELL)
723 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 723 insert_ob_in_ob (tmp->other_arch->instance (), tmp);
724 724
725 /* This code causes the wall to extend some distance in 725 /* This code causes the wall to extend some distance in
726 * each direction, or until an obstruction is encountered. 726 * each direction, or until an obstruction is encountered.
727 * posblocked and negblocked help determine how far the 727 * posblocked and negblocked help determine how far the
728 * created wall can extend, it won't go extend through 728 * created wall can extend, it won't go extend through
… …
748 object *tmp2 = tmp->clone (); 748 object *tmp2 = tmp->clone ();
749 m->insert (tmp2, x, y, op); 749 m->insert (tmp2, x, y, op);
750 750
751 /* If this is a spellcasting wall, need to insert the spell object */ 751 /* If this is a spellcasting wall, need to insert the spell object */
752 if (tmp2->other_arch && tmp2->other_arch->type == SPELL) 752 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
753 tmp2->insert (arch_to_object (tmp2->other_arch)); 753 tmp2->insert (tmp2->other_arch->instance ());
754 754
755 } 755 }
756 else 756 else
757 posblocked = 1; 757 posblocked = 1;
758 758
… …
765 { 765 {
766 object *tmp2 = tmp->clone (); 766 object *tmp2 = tmp->clone ();
767 m->insert (tmp2, x, y, op); 767 m->insert (tmp2, x, y, op);
768 768
769 if (tmp2->other_arch && tmp2->other_arch->type == SPELL) 769 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
770 tmp2->insert (arch_to_object (tmp2->other_arch)); 770 tmp2->insert (tmp2->other_arch->instance ());
771 } 771 }
772 else 772 else
773 negblocked = 1; 773 negblocked = 1;
774 } 774 }
775 775
… …
778 778
779 return 1; 779 return 1;
780} 780}
781 781
782int 782int
783dimension_door (object *op, object *caster, object *spob, int dir) 783dimension_door (object *op, object *caster, object *spob, int dir, const char *spellparam)
784{ 784{
785 uint32 dist, maxdist; 785 uint32 dist, maxdist;
786 int mflags; 786 int mflags;
787 maptile *m; 787 maptile *m;
788 sint16 sx, sy; 788 sint16 sx, sy;
… …
799 /* Given the new outdoor maps, can't let players dimension door for 799 /* Given the new outdoor maps, can't let players dimension door for
800 * ever, so put limits in. 800 * ever, so put limits in.
801 */ 801 */
802 maxdist = spob->range + SP_level_range_adjust (caster, spob); 802 maxdist = spob->range + SP_level_range_adjust (caster, spob);
803 803
804 if (op->contr->count) 804 if (spellparam)
805 { 805 {
806 int count = atoi (spellparam);
807
806 if (op->contr->count > maxdist) 808 if (count > maxdist)
807 { 809 {
808 new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!"); 810 new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");
809 return 0; 811 return 0;
810 } 812 }
811 813
812 for (dist = 0; dist < op->contr->count; dist++) 814 for (dist = 0; dist < count; dist++)
813 { 815 {
814 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy); 816 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);
815 817
816 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP)) 818 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
817 break; 819 break;
818 820
819 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 821 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
820 break; 822 break;
821 } 823 }
822 824
823 if (dist < op->contr->count) 825 if (dist < count)
824 { 826 {
825 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n"); 827 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
826 op->contr->count = 0;
827 return 0; 828 return 0;
828 } 829 }
829
830 op->contr->count = 0;
831 830
832 /* Remove code that puts player on random space on maps. IMO, 831 /* Remove code that puts player on random space on maps. IMO,
833 * a lot of maps probably have areas the player should not get to, 832 * a lot of maps probably have areas the player should not get to,
834 * but may not be marked as NO_MAGIC (as they may be bounded 833 * but may not be marked as NO_MAGIC (as they may be bounded
835 * by such squares). Also, there are probably treasure rooms and 834 * by such squares). Also, there are probably treasure rooms and
… …
886 885
887 /* Actually move the player now */ 886 /* Actually move the player now */
888 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op))) 887 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
889 return 1; 888 return 1;
890 889
891 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 890 op->speed_left = -5. * op->speed; /* Freeze them for a short while */
891
892 return 1; 892 return 1;
893} 893}
894 894
895/* cast_heal: Heals something. 895/* cast_heal: Heals something.
896 * op is the caster. 896 * op is the caster.
… …
951 if (cure_disease (tmp, op, spell)) 951 if (cure_disease (tmp, op, spell))
952 success = 1; 952 success = 1;
953 953
954 if (spell->attacktype & AT_POISON) 954 if (spell->attacktype & AT_POISON)
955 { 955 {
956 at = archetype::find ("poisoning"); 956 at = archetype::find (shstr_poisoning);
957 poison = present_arch_in_ob (at, tmp); 957 poison = present_arch_in_ob (at, tmp);
958 if (poison) 958 if (poison)
959 { 959 {
960 success = 1; 960 success = 1;
961 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed"); 961 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
… …
963 } 963 }
964 } 964 }
965 965
966 if (spell->attacktype & AT_CONFUSION) 966 if (spell->attacktype & AT_CONFUSION)
967 { 967 {
968 poison = present_in_ob_by_name (FORCE, "confusion", tmp); 968 poison = present_in_ob_by_name (FORCE, shstr_confusion, tmp);
969 if (poison) 969 if (poison)
970 { 970 {
971 success = 1; 971 success = 1;
972 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 972 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
973 poison->duration = 1; 973 poison->duration = 1;
974 } 974 }
975 } 975 }
976 976
977 if (spell->attacktype & AT_BLIND) 977 if (spell->attacktype & AT_BLIND)
978 { 978 {
979 at = archetype::find ("blindness"); 979 at = archetype::find (shstr_blindness);
980 poison = present_arch_in_ob (at, tmp); 980 poison = present_arch_in_ob (at, tmp);
981 if (poison) 981 if (poison)
982 { 982 {
983 success = 1; 983 success = 1;
984 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return."); 984 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
… …
1032 "You don't feel any more powerful." 1032 "You don't feel any more powerful."
1033 "You are no easier to look at.", 1033 "You are no easier to look at.",
1034}; 1034};
1035 1035
1036int 1036int
1037change_ability_duration (object *spell, object *caster)
1038{
1039 return spell->duration + SP_level_duration_adjust (caster, spell) * 50;
1040}
1041
1042int
1037cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1043cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1038{ 1044{
1039 object *force = NULL; 1045 object *force = 0;
1040 int i; 1046 int i;
1041 1047
1042 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1048 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1043 object *tmp = dir 1049 object *tmp = dir
1044 ? find_target_for_friendly_spell (op, dir) 1050 ? find_target_for_friendly_spell (op, dir)
1045 : op; 1051 : op;
1046 1052
1047 if (!tmp) 1053 if (!tmp)
1048 return 0; 1054 return 0;
1049 1055
1050 /* If we've already got a force of this type, don't add a new one. */ 1056 /* If we've already got a force of this type, don't add a new one. */
… …
1058 break; 1064 break;
1059 } 1065 }
1060 else if (spell_ob->race && spell_ob->race == tmp2->name) 1066 else if (spell_ob->race && spell_ob->race == tmp2->name)
1061 { 1067 {
1062 if (!silent) 1068 if (!silent)
1063 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl); 1069 new_draw_info_format (NDI_UNIQUE, 0, op,
1070 "You can not cast %s while %s is in effect",
1071 &spell_ob->name, &tmp2->name_pl);
1072
1064 return 0; 1073 return 0;
1065 } 1074 }
1066 } 1075 }
1067 } 1076 }
1077
1078 int duration = change_ability_duration (spell_ob, caster);
1079
1068 if (force == NULL) 1080 if (force)
1069 {
1070 force = get_archetype (FORCE_NAME);
1071 force->subtype = FORCE_CHANGE_ABILITY;
1072 if (spell_ob->race)
1073 force->name = spell_ob->race;
1074 else
1075 force->name = spell_ob->name;
1076 force->name_pl = spell_ob->name;
1077 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1078
1079 } 1081 {
1080 else
1081 {
1082 int duration;
1083
1084 duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1085 if (duration > force->duration) 1082 if (duration > force->duration)
1086 { 1083 {
1087 force->duration = duration; 1084 force->duration = duration;
1088 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 1085 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1089 } 1086 }
1090 else 1087 else
1091 {
1092 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1088 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1093 }
1094 1089
1095 return 1; 1090 return 1;
1096 } 1091 }
1097 1092
1098 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1093 new_draw_info_format (NDI_UNIQUE, 0, op,
1094 "You create an aura of magical force. H<The effect will last for about %.10g seconds.>",
1095 TICK2TIME (duration));
1096
1097 force = get_archetype (FORCE_NAME);
1098 force->subtype = FORCE_CHANGE_ABILITY;
1099 force->duration = duration;
1100
1101 if (spell_ob->race)
1102 force->name = spell_ob->race;
1103 else
1104 force->name = spell_ob->name;
1105
1106 force->name_pl = spell_ob->name;
1107
1099 force->speed = 1.0; 1108 force->speed = 1.0;
1100 force->speed_left = -1.0; 1109 force->speed_left = -1.0;
1101 SET_FLAG (force, FLAG_APPLIED); 1110 SET_FLAG (force, FLAG_APPLIED);
1102 1111
1103 /* Now start processing the effects. First, protections */ 1112 /* Now start processing the effects. First, protections */
… …
1170 */ 1179 */
1171int 1180int
1172cast_bless (object *op, object *caster, object *spell_ob, int dir) 1181cast_bless (object *op, object *caster, object *spell_ob, int dir)
1173{ 1182{
1174 int i; 1183 int i;
1175 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp; 1184 object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1176 1185
1177 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1186 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1178 if (dir != 0) 1187 if (dir != 0)
1179 { 1188 {
1180 tmp = find_target_for_friendly_spell (op, dir); 1189 tmp = find_target_for_friendly_spell (op, dir);
1190
1191 if (!tmp)
1192 return 0;
1181 } 1193 }
1182 else 1194 else
1183 {
1184 tmp = op; 1195 tmp = op;
1185 }
1186 1196
1187 /* If we've already got a force of this type, don't add a new one. */ 1197 /* If we've already got a force of this type, don't add a new one. */
1188 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1198 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1189 { 1199 {
1190 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1200 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1191 { 1201 {
1192 if (tmp2->name == spell_ob->name) 1202 if (tmp2->name == spell_ob->name)
1193 { 1203 {
… …
1199 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl); 1209 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1200 return 0; 1210 return 0;
1201 } 1211 }
1202 } 1212 }
1203 } 1213 }
1214
1204 if (force == NULL) 1215 if (force == NULL)
1205 { 1216 {
1206 force = get_archetype (FORCE_NAME); 1217 force = get_archetype (FORCE_NAME);
1207 force->subtype = FORCE_CHANGE_ABILITY; 1218 force->subtype = FORCE_CHANGE_ABILITY;
1208 if (spell_ob->race) 1219 if (spell_ob->race)
… …
1239 } 1250 }
1240 else 1251 else
1241 { 1252 {
1242 /* Only give out good benefits, and put a max on it */ 1253 /* Only give out good benefits, and put a max on it */
1243 for (i = 0; i < NROFATTACKS; i++) 1254 for (i = 0; i < NROFATTACKS; i++)
1244 {
1245 if (god->resist[i] > 0) 1255 if (god->resist[i] > 0)
1246 {
1247 force->resist[i] = MIN (god->resist[i], spell_ob->resist[ATNR_GODPOWER]); 1256 force->resist[i] = min (god->resist[i], spell_ob->resist[ATNR_GODPOWER]);
1248 } 1257
1249 }
1250 force->path_attuned |= god->path_attuned; 1258 force->path_attuned |= god->path_attuned;
1251 1259
1252 if (spell_ob->attacktype) 1260 if (spell_ob->attacktype)
1253 force->slaying = god->slaying; 1261 force->slaying = god->slaying;
1254 1262
… …
1319 if (op->type != PLAYER) 1327 if (op->type != PLAYER)
1320 return 0; 1328 return 0;
1321 1329
1322 archetype *nugget[3]; 1330 archetype *nugget[3];
1323 1331
1324 nugget[0] = archetype::find ("pyrite3"); 1332 nugget[0] = archetype::find (shstr_pyrite3);
1325 nugget[1] = archetype::find ("pyrite2"); 1333 nugget[1] = archetype::find (shstr_pyrite2);
1326 nugget[2] = archetype::find ("pyrite"); 1334 nugget[2] = archetype::find (shstr_pyrite);
1327 1335
1328 /* Put a maximum weight of items that can be alchemised. Limits the power 1336 /* Put a maximum weight of items that can be alchemised. Limits the power
1329 * some, and also prevents people from alchemising every table/chair/clock 1337 * some, and also prevents people from alchemising every table/chair/clock
1330 * in sight 1338 * in sight
1331 */ 1339 */
… …
1391 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i) 1399 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1392 if (int nrof = value / nugget [i]->value) 1400 if (int nrof = value / nugget [i]->value)
1393 { 1401 {
1394 value -= nrof * nugget[i]->value; 1402 value -= nrof * nugget[i]->value;
1395 1403
1396 object *tmp = arch_to_object (nugget[i]); 1404 object *tmp = nugget[i]->instance ();
1397 tmp->nrof = nrof; 1405 tmp->nrof = nrof;
1398 tmp->flag [FLAG_IDENTIFIED] = true; 1406 tmp->flag [FLAG_IDENTIFIED] = true;
1399 op->map->insert (tmp, x, y, op, 0); 1407 op->map->insert (tmp, x, y, op, 0);
1400 } 1408 }
1401 1409
… …
1412 * items. 1420 * items.
1413 */ 1421 */
1414int 1422int
1415remove_curse (object *op, object *caster, object *spell) 1423remove_curse (object *op, object *caster, object *spell)
1416{ 1424{
1417 object *tmp;
1418 int success = 0, was_one = 0; 1425 int success = 0, was_one = 0;
1419 1426
1420 for (tmp = op->inv; tmp; tmp = tmp->below) 1427 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1421 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1428 if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1422 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1429 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1423 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1430 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1424 { 1431 {
1425 was_one++; 1432 was_one++;
1426 1433
1427 if (tmp->level <= caster_level (caster, spell)) 1434 if (tmp->level <= casting_level (caster, spell))
1428 { 1435 {
1429 success++; 1436 success++;
1430 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1437 if (QUERY_FLAG (spell, FLAG_DAMNED))
1431 CLEAR_FLAG (tmp, FLAG_DAMNED); 1438 CLEAR_FLAG (tmp, FLAG_DAMNED);
1432 1439
… …
1457 1464
1458/* Identifies objects in the players inventory/on the ground */ 1465/* Identifies objects in the players inventory/on the ground */
1459int 1466int
1460cast_identify (object *op, object *caster, object *spell) 1467cast_identify (object *op, object *caster, object *spell)
1461{ 1468{
1462 dynbuf_text buf;
1463 object *tmp; 1469 object *tmp;
1470 dynbuf_text &buf = msg_dynbuf; buf.clear ();
1464 1471
1465 int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1472 int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1466
1467 if (num_ident < 1)
1468 num_ident = 1;
1469 1473
1470 for (tmp = op->inv; tmp; tmp = tmp->below) 1474 for (tmp = op->inv; tmp; tmp = tmp->below)
1471 { 1475 {
1472 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1476 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1473 { 1477 {
1474 identify (tmp); 1478 identify (tmp);
1475 1479
1476 if (op->type == PLAYER) 1480 if (op->type == PLAYER)
1477 { 1481 {
1478 buf.printf ("You identified: %s.\n\n", long_desc (tmp, op)); 1482 buf.printf ("You identified: %s.\r", long_desc (tmp, op));
1479 1483
1480 if (tmp->msg) 1484 if (tmp->msg)
1481 buf << "The item has a story:\n\n" << tmp->msg << "\n\n"; 1485 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1482 } 1486 }
1483 1487
1484 num_ident--;
1485 if (!num_ident) 1488 if (!--num_ident)
1486 break; 1489 break;
1487 } 1490 }
1488 } 1491 }
1489 1492
1490 /* If all the power of the spell has been used up, don't go and identify 1493 /* If all the power of the spell has been used up, don't go and identify
… …
1498 { 1501 {
1499 identify (tmp); 1502 identify (tmp);
1500 1503
1501 if (object *pl = tmp->visible_to ()) 1504 if (object *pl = tmp->visible_to ())
1502 { 1505 {
1503 buf.printf ("On the ground you identified: %s.\n\n", long_desc (tmp, op)); 1506 buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1504 1507
1505 if (tmp->msg) 1508 if (tmp->msg)
1506 buf << "The item has a story:\n\n" << tmp->msg << "\n\n"; 1509 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1507 } 1510 }
1508 1511
1509 num_ident--;
1510 if (!num_ident) 1512 if (!--num_ident)
1511 break; 1513 break;
1512 } 1514 }
1513 } 1515 }
1514 1516
1515 if (buf.empty ()) 1517 if (buf.empty ())
… …
1537 1539
1538 /* We precompute some values here so that we don't have to keep 1540 /* We precompute some values here so that we don't have to keep
1539 * doing it over and over again. 1541 * doing it over and over again.
1540 */ 1542 */
1541 god = find_god (determine_god (op)); 1543 god = find_god (determine_god (op));
1542 level = caster_level (caster, spell); 1544 level = casting_level (caster, spell);
1543 range = spell->range + SP_level_range_adjust (caster, spell); 1545 range = spell->range + SP_level_range_adjust (caster, spell);
1544 1546
1545 if (!skill) 1547 if (!skill)
1546 skill = caster; 1548 skill = caster;
1547 1549
1548 for (x = op->x - range; x <= op->x + range; x++) 1550 dynbuf buf;
1549 for (y = op->y - range; y <= op->y + range; y++) 1551 unordered_mapwalk (buf, op, -range, -range, range, range)
1550 { 1552 {
1551 m = op->map;
1552 mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1553 if (mflags & P_OUT_OF_MAP)
1554 continue;
1555
1556 /* For most of the detections, we only detect objects above the 1553 /* For most of the detections, we only detect objects above the
1557 * floor. But this is not true for show invisible. 1554 * floor. But this is not true for show invisible.
1558 * Basically, we just go and find the top object and work 1555 * Basically, we just go and find the top object and work
1559 * down - that is easier than working up. 1556 * down - that is easier than working up.
1560 */ 1557 */
1561 1558
1562 for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above) 1559 for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1563 last = tmp; 1560 last = tmp;
1564 1561
1565 /* Shouldn't happen, but if there are no objects on a space, this 1562 /* Shouldn't happen, but if there are no objects on a space, this
1566 * would happen. 1563 * would happen.
1567 */ 1564 */
1568 if (!last) 1565 if (!last)
1569 continue; 1566 continue;
1570 1567
1571 done_one = 0; 1568 done_one = 0;
1572 floor = 0; 1569 floor = 0;
1573 detect = NULL; 1570 detect = NULL;
1574 for (tmp = last; tmp; tmp = tmp->below) 1571 for (tmp = last; tmp; tmp = tmp->below)
1575 { 1572 {
1576 /* show invisible */ 1573 /* show invisible */
1577 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1574 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1578 /* Might there be other objects that we can make visible? */ 1575 /* Might there be other objects that we can make visible? */
1579 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) || 1576 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER)
1580 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) || 1577 || (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ))
1581 tmp->type == CF_HANDLE || 1578 || tmp->type == T_HANDLE
1582 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE || 1579 || tmp->type == TRAPDOOR
1580 || tmp->type == EXIT
1581 || tmp->type == HOLE
1582 || tmp->type == BUTTON
1583 tmp->type == BUTTON || tmp->type == TELEPORTER || 1583 || tmp->type == TELEPORTER
1584 || tmp->type == GATE
1584 tmp->type == GATE || tmp->type == LOCKED_DOOR || 1585 || tmp->type == LOCKED_DOOR
1585 tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN || 1586 || tmp->type == WEAPON
1587 || tmp->type == ALTAR
1588 || tmp->type == SIGN
1586 tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY || 1589 || tmp->type == TRIGGER_PEDESTAL
1587 tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR))) 1590 || tmp->type == SPECIAL_KEY
1591 || tmp->type == TREASURE
1592 || tmp->type == BOOK
1593 || tmp->type == HOLY_ALTAR
1594 || tmp->type == CONTAINER)))
1588 { 1595 {
1589 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4) 1596 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1590 { 1597 {
1591 tmp->invisible = 0; 1598 tmp->invisible = 0;
1592 done_one = 1; 1599 done_one = 1;
1593 } 1600 }
1594 } 1601 }
1595 1602
1596 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1603 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1597 floor = 1; 1604 floor = 1;
1598 1605
1599 /* All detections below this point don't descend beneath the floor, 1606 /* All detections below this point don't descend beneath the floor,
1600 * so just continue on. We could be clever and look at the type of 1607 * so just continue on. We could be clever and look at the type of
1601 * detection to completely break out if we don't care about objects beneath 1608 * detection to completely break out if we don't care about objects beneath
1602 * the floor, but once we get to the floor, not likely a very big issue anyways. 1609 * the floor, but once we get to the floor, not likely a very big issue anyways.
1603 */ 1610 */
1604 if (floor) 1611 if (floor)
1605 continue; 1612 continue;
1606 1613
1607 /* I had thought about making detect magic and detect curse 1614 /* I had thought about making detect magic and detect curse
1608 * show the flash the magic item like it does for detect monster. 1615 * show the flash the magic item like it does for detect monster.
1609 * however, if the object is within sight, this would then make it 1616 * however, if the object is within sight, this would then make it
1610 * difficult to see what object is magical/cursed, so the 1617 * difficult to see what object is magical/cursed, so the
1611 * effect wouldn't be as apparant. 1618 * effect wouldn't be as apparent.
1612 */ 1619 */
1613 1620
1614 /* detect magic */ 1621 /* detect magic */
1615 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && 1622 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1616 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp)) 1623 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1617 { 1624 {
1618 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1625 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1619 /* make runes more visibile */ 1626 /* make runes more visibile */
1620 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC) 1627 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1621 tmp->stats.Cha /= 4; 1628 tmp->stats.Cha /= 4;
1629
1622 done_one = 1; 1630 done_one = 1;
1623 } 1631 }
1632
1624 /* detect monster */ 1633 /* detect monster */
1625 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER)) 1634 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1626 { 1635 {
1627 done_one = 2; 1636 done_one = 2;
1637
1628 if (!detect) 1638 if (!detect)
1629 detect = tmp; 1639 detect = tmp;
1630 } 1640 }
1641
1631 /* Basically, if race is set in the spell, then the creatures race must 1642 /* Basically, if race is set in the spell, then the creatures race must
1632 * match that. if the spell race is set to GOD, then the gods opposing 1643 * match that. if the spell race is set to GOD, then the gods opposing
1633 * race must match. 1644 * race must match.
1634 */ 1645 */
1635 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race && 1646 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1636 ((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) || 1647 ((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1637 (strstr (spell->race, tmp->race)))) 1648 spell->race.contains (tmp->race)))
1638 { 1649 {
1639 done_one = 2; 1650 done_one = 2;
1651
1640 if (!detect) 1652 if (!detect)
1641 detect = tmp; 1653 detect = tmp;
1642 } 1654 }
1655
1643 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1656 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1644 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1657 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1645 { 1658 {
1646 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1659 SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1647 done_one = 1; 1660 done_one = 1;
1648 } 1661 }
1649 } /* for stack of objects on this space */ 1662 } /* for stack of objects on this space */
1650 1663
1651 /* Code here puts an effect of the spell on the space, so you can see 1664 /* Code here puts an effect of the spell on the space, so you can see
1652 * where the magic is. 1665 * where the magic is.
1653 */ 1666 */
1654 if (done_one) 1667 if (done_one)
1655 { 1668 {
1656 object *detect_ob = arch_to_object (spell->other_arch); 1669 object *detect_ob = spell->other_arch->instance ();
1657 1670
1658 /* if this is set, we want to copy the face */ 1671 /* if this is set, we want to copy the face */
1659 if (done_one == 2 && detect) 1672 if (done_one == 2 && detect)
1660 { 1673 {
1661 detect_ob->face = detect->face; 1674 detect_ob->face = detect->face;
1662 detect_ob->animation_id = detect->animation_id; 1675 detect_ob->animation_id = detect->animation_id;
1663 detect_ob->anim_speed = detect->anim_speed; 1676 detect_ob->anim_speed = detect->anim_speed;
1664 detect_ob->last_anim = 0; 1677 detect_ob->last_anim = 0;
1665 /* by default, the detect_ob is already animated */ 1678 /* by default, the detect_ob is already animated */
1666 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1679 if (!QUERY_FLAG (detect, FLAG_ANIMATE))
1667 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1680 CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
1668 } 1681 }
1669 1682
1670 m->insert (detect_ob, nx, ny, op); 1683 m->insert (detect_ob, nx, ny, op);
1671 } 1684 }
1672 } /* for processing the surrounding spaces */ 1685 } /* for processing the surrounding spaces */
1673 1686
1674 1687
1675 /* Now process objects in the players inventory if detect curse or magic */ 1688 /* Now process objects in the players inventory if detect curse or magic */
1676 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL)) 1689 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
1677 { 1690 {
… …
1721 1734
1722 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you."); 1735 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
1723 1736
1724 if (victim->stats.sp >= victim->stats.maxsp * 2) 1737 if (victim->stats.sp >= victim->stats.maxsp * 2)
1725 { 1738 {
1726 object *tmp;
1727
1728 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!"); 1739 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");
1729
1730 /* Explodes a fireball centered at player */
1731 tmp = get_archetype (EXPLODING_FIREBALL);
1732 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
1733 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
1734
1735 tmp->insert_at (victim);
1736 victim->stats.sp = 2 * victim->stats.maxsp; 1740 victim->stats.sp = 2 * victim->stats.maxsp;
1741 create_exploding_ball_at (victim, caster_level);
1737 } 1742 }
1738 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 1743 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
1739 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 1744 new_draw_info (NDI_UNIQUE | NDI_ORANGE, 0, victim, "You feel like your head is going to explode.");
1740 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 1745 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
1741 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 1746 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
1742 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 1747 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
1743 { 1748 {
1744 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 1749 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
… …
1790 } 1795 }
1791 /* give sp */ 1796 /* give sp */
1792 if (spell->stats.dam > 0) 1797 if (spell->stats.dam > 0)
1793 { 1798 {
1794 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell); 1799 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
1795 charge_mana_effect (plyr, caster_level (caster, spell)); 1800 charge_mana_effect (plyr, casting_level (caster, spell));
1796 return 1; 1801 return 1;
1797 } 1802 }
1798 /* suck sp away. Can't suck sp from yourself */ 1803 /* suck sp away. Can't suck sp from yourself */
1799 else if (op != plyr) 1804 else if (op != plyr)
1800 { 1805 {
… …
1812 /* Player doesn't get full credit */ 1817 /* Player doesn't get full credit */
1813 sucked = (sucked * rate) / 100; 1818 sucked = (sucked * rate) / 100;
1814 op->stats.sp += sucked; 1819 op->stats.sp += sucked;
1815 if (sucked > 0) 1820 if (sucked > 0)
1816 { 1821 {
1817 charge_mana_effect (op, caster_level (caster, spell)); 1822 charge_mana_effect (op, casting_level (caster, spell));
1818 } 1823 }
1819 } 1824 }
1820 return 1; 1825 return 1;
1821 } 1826 }
1822 return 0; 1827 return 0;
… …
1919 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1924 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1920 break; 1925 break;
1921 if (tmp->type == HOLY_ALTAR) 1926 if (tmp->type == HOLY_ALTAR)
1922 { 1927 {
1923 1928
1924 if (tmp->level > caster_level (caster, spell)) 1929 if (tmp->level > casting_level (caster, spell))
1925 { 1930 {
1926 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name); 1931 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);
1927 return 0; 1932 return 0;
1928 } 1933 }
1929 else 1934 else
1930 { 1935 {
1931 /* If we got here, we are consecrating an altar */ 1936 /* If we got here, we are consecrating an altar */
1932 sprintf (buf, "Altar of %s", &god->name); 1937 sprintf (buf, "Altar of %s", &god->name);
1933 tmp->name = buf; 1938 tmp->name = buf;
1934 tmp->level = caster_level (caster, spell); 1939 tmp->level = casting_level (caster, spell);
1935 tmp->other_arch = god->arch; 1940 tmp->other_arch = god->arch;
1936 1941
1937 if (op->type == PLAYER) 1942 if (op->type == PLAYER)
1938 esrv_update_item (UPD_NAME, op, tmp); 1943 esrv_update_item (UPD_NAME, op, tmp);
1939 1944
… …
1982 return 0; 1987 return 0;
1983 } 1988 }
1984 1989
1985 /* if no direction specified, pick one */ 1990 /* if no direction specified, pick one */
1986 if (!dir) 1991 if (!dir)
1987 dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9); 1992 dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
1988 1993
1989 m = op->map; 1994 m = op->map;
1990 x = op->x + freearr_x[dir]; 1995 x = op->x + freearr_x[dir];
1991 y = op->y + freearr_y[dir]; 1996 y = op->y + freearr_y[dir];
1992 1997
1993 /* if there's no place to put the golem, abort */ 1998 /* if there's no place to put the golem, abort */
1994 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) || 1999 if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
1995 ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type)) 2000 || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
1996 { 2001 {
1997 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 2002 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1998 return 0; 2003 return 0;
1999 } 2004 }
2000 2005
… …
2004 if (!weapon) 2009 if (!weapon)
2005 { 2010 {
2006 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 2011 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2007 return 0; 2012 return 0;
2008 } 2013 }
2014
2009 if (spell->race && strcmp (weapon->arch->archname, spell->race)) 2015 if (spell->race && weapon->arch->archname != spell->race)
2010 { 2016 {
2011 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2017 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2012 return 0; 2018 return 0;
2013 } 2019 }
2020
2014 if (weapon->type != WEAPON) 2021 if (weapon->type != WEAPON)
2015 { 2022 {
2016 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it."); 2023 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");
2017 return 0; 2024 return 0;
2018 } 2025 }
2026
2019 if (QUERY_FLAG (weapon, FLAG_APPLIED)) 2027 if (QUERY_FLAG (weapon, FLAG_APPLIED))
2020 { 2028 {
2021 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon)); 2029 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
2022 return 0; 2030 return 0;
2023 } 2031 }
2024 2032
2025 weapon = weapon->split (); 2033 weapon = weapon->split ();
2026 2034
2027 /* create the golem object */ 2035 /* create the golem object */
2028 tmp = arch_to_object (spell->other_arch); 2036 tmp = spell->other_arch->instance ();
2029 2037
2030 /* if animated by a player, give the player control of the golem */ 2038 /* if animated by a player, give the player control of the golem */
2031 CLEAR_FLAG (tmp, FLAG_MONSTER); 2039 CLEAR_FLAG (tmp, FLAG_MONSTER);
2032 tmp->stats.exp = 0; 2040 tmp->stats.exp = 0;
2033 add_friendly_object (tmp); 2041 add_friendly_object (tmp);
… …
2078 2086
2079 /* attacktype */ 2087 /* attacktype */
2080 if (!tmp->attacktype) 2088 if (!tmp->attacktype)
2081 tmp->attacktype = AT_PHYSICAL; 2089 tmp->attacktype = AT_PHYSICAL;
2082 2090
2083 if (materialtype_t *mt = name_to_material (op->materialname))
2084 {
2085 for (i = 0; i < NROFATTACKS; i++) 2091 for (i = 0; i < NROFATTACKS; i++)
2086 tmp->resist[i] = 50 - (mt->save[i] * 5); 2092 tmp->resist[i] = 50 - (op->material->save[i] * 5);
2087 a = mt->save[0]; 2093
2088 } 2094 a = op->material->save[0];
2089 else
2090 {
2091 for (i = 0; i < NROFATTACKS; i++)
2092 tmp->resist[i] = 5;
2093 a = 10;
2094 }
2095 2095
2096 /* Set weapon's immunity */ 2096 /* Set weapon's immunity */
2097 tmp->resist[ATNR_CONFUSION] = 100; 2097 tmp->resist[ATNR_CONFUSION] = 100;
2098 tmp->resist[ATNR_POISON] = 100; 2098 tmp->resist[ATNR_POISON] = 100;
2099 tmp->resist[ATNR_SLOW] = 100; 2099 tmp->resist[ATNR_SLOW] = 100;
… …
2126 tmp->state = weapon->state; 2126 tmp->state = weapon->state;
2127 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE]; 2127 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2128 } 2128 }
2129 2129
2130 /* make experience increase in proportion to the strength of the summoned creature. */ 2130 /* make experience increase in proportion to the strength of the summoned creature. */
2131 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2131 tmp->stats.exp *= 1 + (max (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2132 2132
2133 tmp->speed_left = -1; 2133 tmp->speed_left = -1;
2134 tmp->direction = dir; 2134 tmp->direction = dir;
2135 2135
2136 m->insert (tmp, x, y, op); 2136 m->insert (tmp, x, y, op);
… …
2140/* cast_daylight() - changes the map darkness level *lower* */ 2140/* cast_daylight() - changes the map darkness level *lower* */
2141 2141
2142/* cast_change_map_lightlevel: Was cast_daylight/nightfall. 2142/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2143 * This changes the light level for the entire map. 2143 * This changes the light level for the entire map.
2144 */ 2144 */
2145
2146int 2145int
2147cast_change_map_lightlevel (object *op, object *caster, object *spell) 2146cast_change_map_lightlevel (object *op, object *caster, object *spell)
2148{ 2147{
2149 int success; 2148 int success;
2150 2149
… …
2158 if (spell->stats.dam < 0) 2157 if (spell->stats.dam < 0)
2159 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2158 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2160 else 2159 else
2161 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2160 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2162 } 2161 }
2162
2163 return success; 2163 return success;
2164} 2164}
2165 2165
2166/* create an aura spell object and put it in the player's inventory. 2166/* create an aura spell object and put it in the player's inventory.
2167 * as usual, op is player, caster is the object casting the spell, 2167 * as usual, op is player, caster is the object casting the spell,
… …
2175 2175
2176 new_aura = present_arch_in_ob (spell->other_arch, op); 2176 new_aura = present_arch_in_ob (spell->other_arch, op);
2177 if (new_aura) 2177 if (new_aura)
2178 refresh = 1; 2178 refresh = 1;
2179 else 2179 else
2180 new_aura = arch_to_object (spell->other_arch); 2180 new_aura = spell->other_arch->instance ();
2181 2181
2182 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2182 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2183 2183
2184 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2184 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2185 2185
2186 set_spell_skill (op, caster, spell, new_aura); 2186 set_spell_skill (op, caster, spell, new_aura);
2187 new_aura->attacktype = spell->attacktype; 2187 new_aura->attacktype = spell->attacktype;
2188 2188
2189 new_aura->level = caster_level (caster, spell); 2189 new_aura->level = casting_level (caster, spell);
2190 2190
2191 if (refresh) 2191 if (refresh)
2192 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2192 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2193 else 2193 else
2194 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2194 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
… …
2250 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block))) 2250 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2251 { 2251 {
2252 hit_map (aura, i, aura->attacktype, 0); 2252 hit_map (aura, i, aura->attacktype, 0);
2253 2253
2254 if (aura->other_arch) 2254 if (aura->other_arch)
2255 pos.insert (arch_to_object (aura->other_arch), aura); 2255 pos.insert (aura->other_arch->instance (), aura);
2256 } 2256 }
2257 } 2257 }
2258 2258
2259 /* put the aura back in the player's inventory */ 2259 /* put the aura back in the player's inventory */
2260 env->insert (aura); 2260 env->insert (aura);
… …
2265 * op is the piece object. 2265 * op is the piece object.
2266 */ 2266 */
2267void 2267void
2268move_peacemaker (object *op) 2268move_peacemaker (object *op)
2269{ 2269{
2270 object *tmp; 2270 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2271
2272 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2273 { 2271 {
2274 int atk_lev, def_lev; 2272 int atk_lev, def_lev;
2275 object *victim = tmp->head_ (); 2273 object *victim = tmp->head_ ();
2276 2274
2277 if (!QUERY_FLAG (victim, FLAG_MONSTER)) 2275 if (!QUERY_FLAG (victim, FLAG_MONSTER))
… …
2281 continue; 2279 continue;
2282 2280
2283 if (victim->stats.exp == 0) 2281 if (victim->stats.exp == 0)
2284 continue; 2282 continue;
2285 2283
2286 def_lev = MAX (1, victim->level); 2284 def_lev = max (1, victim->level);
2287 atk_lev = MAX (1, op->level); 2285 atk_lev = max (1, op->level);
2288 2286
2289 if (rndm (0, atk_lev - 1) > def_lev) 2287 if (rndm (0, atk_lev - 1) > def_lev)
2290 { 2288 {
2291 /* make this sucker peaceful. */ 2289 /* make this sucker peaceful. */
2292 2290
… …
2312 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name); 2310 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2313 } 2311 }
2314 } 2312 }
2315} 2313}
2316 2314
2317
2318/* This writes a rune that contains the appropriate message. 2315/* This writes a rune that contains the appropriate message.
2319 * There really isn't any adjustments we make. 2316 * There really isn't any adjustments we make.
2320 */ 2317 */
2321
2322int 2318int
2323write_mark (object *op, object *spell, const char *msg) 2319write_mark (object *op, object *spell, const char *msg)
2324{ 2320{
2325 char rune[HUGE_BUF];
2326 object *tmp;
2327
2328 if (!msg || msg[0] == 0) 2321 if (!msg || msg[0] == 0)
2329 { 2322 {
2330 new_draw_info (NDI_UNIQUE, 0, op, "Write what?"); 2323 new_draw_info (NDI_UNIQUE, 0, op, "Write what?");
2331 return 0; 2324 return 0;
2332 } 2325 }
2333 2326
2334 if (strcasestr_local (msg, "endmsg")) 2327 if (!msg_is_safe (msg))
2335 { 2328 {
2336 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?"); 2329 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");
2337 LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg); 2330 LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2338 return 0; 2331 return 0;
2339 } 2332 }
2333
2340 if (!spell->other_arch) 2334 if (!spell->other_arch)
2341 return 0; 2335 return 0;
2342 tmp = arch_to_object (spell->other_arch);
2343 2336
2344 snprintf (rune, sizeof (rune), "%s\n", msg); 2337 object *tmp = spell->other_arch->instance ();
2345 2338
2346 tmp->race = op->name; /*Save the owner of the rune */ 2339 tmp->race = op->name; /*Save the owner of the rune */
2347 tmp->msg = rune; 2340 tmp->msg = msg;
2348 2341
2349 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR); 2342 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2343
2350 return 1; 2344 return 1;
2351} 2345}
2346

Diff Legend

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