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.124 by root, Sun Apr 11 00:34:06 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>
… …
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
… …
102 ncharges = 1; 103 ncharges = 1;
103 104
104 wand->stats.food += ncharges; 105 wand->stats.food += ncharges;
105 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand)); 106 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
106 107
107 if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE)) 108 if (wand->arch && wand->arch->flag [FLAG_ANIMATE])
108 { 109 {
109 SET_FLAG (wand, FLAG_ANIMATE); 110 wand->set_flag (FLAG_ANIMATE);
110 wand->set_speed (wand->arch->speed); 111 wand->set_speed (wand->arch->speed);
111 } 112 }
112 113
113 return 1; 114 return 1;
114} 115}
… …
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)
133 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 134 if (tmp->type == BOW && tmp->flag [FLAG_APPLIED])
134 missile_name = tmp->race; 135 missile_name = tmp->race;
135 136
136 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 137 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
137 138
138 archetype *missile_arch = archetype::find (missile_name); 139 archetype *missile_arch = archetype::find (missile_name);
… …
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);
… …
192 193
193 missile->magic = missile_plus; 194 missile->magic = missile_plus;
194 /* Can't get any money for these objects */ 195 /* Can't get any money for these objects */
195 missile->value = 0; 196 missile->value = 0;
196 197
197 SET_FLAG (missile, FLAG_IDENTIFIED); 198 missile->set_flag (FLAG_IDENTIFIED);
198 199
199 if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ()) 200 if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ())
200 pick_up (op, missile); 201 pick_up (op, missile);
201 202
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;
… …
296 mflags = get_map_flags (m, &m, x, y, &x, &y); 297 mflags = get_map_flags (m, &m, x, y, &x, &y);
297 298
298 if (mflags & P_OUT_OF_MAP) 299 if (mflags & P_OUT_OF_MAP)
299 break; 300 break;
300 301
301 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC)) 302 if (!op->flag [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 (tmp->flag [FLAG_ALIVE] && (tmp->type == PLAYER || tmp->flag [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;
314 examine_monster (op, tmp); 316 examine_monster (op, tmp);
… …
337 if (pl->type == PLAYER) 339 if (pl->type == PLAYER)
338 { 340 {
339 /* If race isn't set, then invisible unless it is undead */ 341 /* If race isn't set, then invisible unless it is undead */
340 if (!pl->contr->invis_race) 342 if (!pl->contr->invis_race)
341 { 343 {
342 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 344 if (mon->flag [FLAG_UNDEAD])
343 return 0; 345 return 0;
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 }
… …
394 396
395 if (op->type == PLAYER) 397 if (op->type == PLAYER)
396 { 398 {
397 op->contr->invis_race = spell_ob->race; 399 op->contr->invis_race = spell_ob->race;
398 400
399 if (QUERY_FLAG (spell_ob, FLAG_MAKE_INVIS)) 401 if (spell_ob->flag [FLAG_MAKE_INVIS])
400 op->contr->tmp_invis = 0; 402 op->contr->tmp_invis = 0;
401 else 403 else
402 op->contr->tmp_invis = 1; 404 op->contr->tmp_invis = 1;
403 405
404 op->contr->hidden = 0; 406 op->contr->hidden = 0;
… …
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;
454 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 452
453 if (tmp->flag [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
459 return 1; 458 return 1;
… …
462void 461void
463execute_word_of_recall (object *op) 462execute_word_of_recall (object *op)
464{ 463{
465 if (object *pl = op->in_player ()) 464 if (object *pl = op->in_player ())
466 { 465 {
467 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST)) 466 if (pl->ms ().flags () & P_NO_CLERIC && !pl->flag [FLAG_WIZCAST])
468 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you."); 467 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
469 else 468 else
470 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp); 469 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
471 } 470 }
472 471
… …
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;
… …
679 tmp->attacktype = spell_ob->attacktype; 679 tmp->attacktype = spell_ob->attacktype;
680 tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 680 tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
681 tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 681 tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
682 tmp->range = 0; 682 tmp->range = 0;
683 } 683 }
684 else if (QUERY_FLAG (tmp, FLAG_ALIVE)) 684 else if (tmp->flag [FLAG_ALIVE])
685 { 685 {
686 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 686 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
687 tmp->stats.maxhp = tmp->stats.hp; 687 tmp->stats.maxhp = tmp->stats.hp;
688 } 688 }
689 689
690 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP)) 690 if (spell_ob->flag [FLAG_IS_USED_UP] || tmp->flag [FLAG_IS_USED_UP])
691 { 691 {
692 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 692 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
693 SET_FLAG (tmp, FLAG_IS_USED_UP); 693 tmp->set_flag (FLAG_IS_USED_UP);
694 } 694 }
695 695
696 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN)) 696 if (spell_ob->flag [FLAG_TEAR_DOWN])
697 { 697 {
698 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 698 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
699 tmp->stats.maxhp = tmp->stats.hp; 699 tmp->stats.maxhp = tmp->stats.hp;
700 SET_FLAG (tmp, FLAG_TEAR_DOWN); 700 tmp->set_flag (FLAG_TEAR_DOWN);
701 SET_FLAG (tmp, FLAG_ALIVE); 701 tmp->set_flag (FLAG_ALIVE);
702 } 702 }
703 703
704 /* This can't really hurt - if the object doesn't kill anything, 704 /* This can't really hurt - if the object doesn't kill anything,
705 * these fields just won't be used. Do not set the owner for 705 * these fields just won't be used. Do not set the owner for
706 * earthwalls, though, so they survive restarts. 706 * earthwalls, though, so they survive restarts.
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
776 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) 776 if (tmp->flag [FLAG_BLOCKSVIEW])
777 update_all_los (op->map, op->x, op->y); 777 update_all_los (op->map, op->x, op->y);
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;
… …
790 if (op->type != PLAYER) 790 if (op->type != PLAYER)
791 return 0; 791 return 0;
792 792
793 if (!dir) 793 if (!dir)
794 { 794 {
795 new_draw_info (NDI_UNIQUE, 0, op, "In what direction?"); 795 op->failmsg ("In what direction?");
796 return 0; 796 return 0;
797 } 797 }
798 798
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.");
… …
1002 tmp->stats.grace = tmp->stats.maxgrace; 1002 tmp->stats.grace = tmp->stats.maxgrace;
1003 success = 1; 1003 success = 1;
1004 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!"); 1004 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1005 } 1005 }
1006 1006
1007 if (spell->stats.food && tmp->stats.food < 999) 1007 if (spell->stats.food && tmp->stats.food < MAX_FOOD)
1008 { 1008 {
1009 tmp->stats.food += spell->stats.food; 1009 tmp->stats.food += spell->stats.food;
1010 1010 min_it (tmp->stats.food, MAX_FOOD);
1011 if (tmp->stats.food > 999)
1012 tmp->stats.food = 999;
1013 1011
1014 success = 1; 1012 success = 1;
1015 /* We could do something a bit better like the messages for healing above */ 1013 /* We could do something a bit better like the messages for healing above */
1016 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1014 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1017 } 1015 }
… …
1032 "You don't feel any more powerful." 1030 "You don't feel any more powerful."
1033 "You are no easier to look at.", 1031 "You are no easier to look at.",
1034}; 1032};
1035 1033
1036int 1034int
1035change_ability_duration (object *spell, object *caster)
1036{
1037 return spell->duration + SP_level_duration_adjust (caster, spell) * 50;
1038}
1039
1040int
1037cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1041cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1038{ 1042{
1039 object *force = NULL; 1043 object *force = 0;
1040 int i; 1044 int i;
1041 1045
1042 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1046 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1043 object *tmp = dir 1047 object *tmp = dir
1044 ? find_target_for_friendly_spell (op, dir) 1048 ? find_target_for_friendly_spell (op, dir)
1045 : op; 1049 : op;
1046 1050
1047 if (!tmp) 1051 if (!tmp)
1048 return 0; 1052 return 0;
1049 1053
1050 /* If we've already got a force of this type, don't add a new one. */ 1054 /* If we've already got a force of this type, don't add a new one. */
… …
1058 break; 1062 break;
1059 } 1063 }
1060 else if (spell_ob->race && spell_ob->race == tmp2->name) 1064 else if (spell_ob->race && spell_ob->race == tmp2->name)
1061 { 1065 {
1062 if (!silent) 1066 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); 1067 new_draw_info_format (NDI_UNIQUE, 0, op,
1068 "You can not cast %s while %s is in effect",
1069 &spell_ob->name, &tmp2->name_pl);
1070
1064 return 0; 1071 return 0;
1065 } 1072 }
1066 } 1073 }
1067 } 1074 }
1075
1076 int duration = change_ability_duration (spell_ob, caster);
1077
1068 if (force == NULL) 1078 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 } 1079 {
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) 1080 if (duration > force->duration)
1086 { 1081 {
1087 force->duration = duration; 1082 force->duration = duration;
1088 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 1083 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1089 } 1084 }
1090 else 1085 else
1091 {
1092 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1086 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1093 }
1094 1087
1095 return 1; 1088 return 1;
1096 } 1089 }
1097 1090
1098 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1091 new_draw_info_format (NDI_UNIQUE, 0, op,
1092 "You create an aura of magical force. H<The effect will last for about %.10g seconds.>",
1093 TICK2TIME (duration));
1094
1095 force = get_archetype (FORCE_NAME);
1096 force->subtype = FORCE_CHANGE_ABILITY;
1097 force->duration = duration;
1098
1099 if (spell_ob->race)
1100 force->name = spell_ob->race;
1101 else
1102 force->name = spell_ob->name;
1103
1104 force->name_pl = spell_ob->name;
1105
1099 force->speed = 1.0; 1106 force->speed = 1.0;
1100 force->speed_left = -1.0; 1107 force->speed_left = -1.0;
1101 SET_FLAG (force, FLAG_APPLIED); 1108 force->set_flag (FLAG_APPLIED);
1102 1109
1103 /* Now start processing the effects. First, protections */ 1110 /* Now start processing the effects. First, protections */
1104 for (i = 0; i < NROFATTACKS; i++) 1111 for (i = 0; i < NROFATTACKS; i++)
1105 { 1112 {
1106 if (spell_ob->resist[i]) 1113 if (spell_ob->resist[i])
… …
1136 } 1143 }
1137 } 1144 }
1138 1145
1139 force->move_type = spell_ob->move_type; 1146 force->move_type = spell_ob->move_type;
1140 1147
1141 if (QUERY_FLAG (spell_ob, FLAG_SEE_IN_DARK)) 1148 if (spell_ob->flag [FLAG_SEE_IN_DARK])
1142 SET_FLAG (force, FLAG_SEE_IN_DARK); 1149 force->set_flag (FLAG_SEE_IN_DARK);
1143 1150
1144 if (QUERY_FLAG (spell_ob, FLAG_XRAYS)) 1151 if (spell_ob->flag [FLAG_XRAYS])
1145 SET_FLAG (force, FLAG_XRAYS); 1152 force->set_flag (FLAG_XRAYS);
1146 1153
1147 /* Haste/bonus speed */ 1154 /* Haste/bonus speed */
1148 if (spell_ob->stats.exp) 1155 if (spell_ob->stats.exp)
1149 { 1156 {
1150 if (op->speed > 0.5f) 1157 if (op->speed > 0.5f)
… …
1170 */ 1177 */
1171int 1178int
1172cast_bless (object *op, object *caster, object *spell_ob, int dir) 1179cast_bless (object *op, object *caster, object *spell_ob, int dir)
1173{ 1180{
1174 int i; 1181 int i;
1175 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp; 1182 object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1176 1183
1177 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1184 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1178 if (dir != 0) 1185 if (dir != 0)
1179 { 1186 {
1180 tmp = find_target_for_friendly_spell (op, dir); 1187 tmp = find_target_for_friendly_spell (op, dir);
1188
1189 if (!tmp)
1190 return 0;
1181 } 1191 }
1182 else 1192 else
1183 {
1184 tmp = op; 1193 tmp = op;
1185 }
1186 1194
1187 /* If we've already got a force of this type, don't add a new one. */ 1195 /* 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) 1196 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1189 { 1197 {
1190 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1198 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1191 { 1199 {
1192 if (tmp2->name == spell_ob->name) 1200 if (tmp2->name == spell_ob->name)
1193 { 1201 {
… …
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); 1207 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; 1208 return 0;
1201 } 1209 }
1202 } 1210 }
1203 } 1211 }
1212
1204 if (force == NULL) 1213 if (force == NULL)
1205 { 1214 {
1206 force = get_archetype (FORCE_NAME); 1215 force = get_archetype (FORCE_NAME);
1207 force->subtype = FORCE_CHANGE_ABILITY; 1216 force->subtype = FORCE_CHANGE_ABILITY;
1208 if (spell_ob->race) 1217 if (spell_ob->race)
… …
1229 return 0; 1238 return 0;
1230 } 1239 }
1231 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;
1232 force->speed = 1.0; 1241 force->speed = 1.0;
1233 force->speed_left = -1.0; 1242 force->speed_left = -1.0;
1234 SET_FLAG (force, FLAG_APPLIED); 1243 force->set_flag (FLAG_APPLIED);
1235 1244
1236 if (!god) 1245 if (!god)
1237 { 1246 {
1238 new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty."); 1247 new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty.");
1239 } 1248 }
1240 else 1249 else
1241 { 1250 {
1242 /* Only give out good benefits, and put a max on it */ 1251 /* Only give out good benefits, and put a max on it */
1243 for (i = 0; i < NROFATTACKS; i++) 1252 for (i = 0; i < NROFATTACKS; i++)
1244 {
1245 if (god->resist[i] > 0) 1253 if (god->resist[i] > 0)
1246 {
1247 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]);
1248 } 1255
1249 }
1250 force->path_attuned |= god->path_attuned; 1256 force->path_attuned |= god->path_attuned;
1251 1257
1252 if (spell_ob->attacktype) 1258 if (spell_ob->attacktype)
1253 force->slaying = god->slaying; 1259 force->slaying = god->slaying;
1254 1260
… …
1296 * the nuggets, alchemy the gold from that, etc. 1302 * the nuggets, alchemy the gold from that, etc.
1297 * Otherwise, give 9 silver on the gold for other objects, 1303 * Otherwise, give 9 silver on the gold for other objects,
1298 * so that it would still be more affordable to haul 1304 * so that it would still be more affordable to haul
1299 * the stuff back to town. 1305 * the stuff back to town.
1300 */ 1306 */
1301 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1307 if (obj->flag [FLAG_UNPAID])
1302 value = 0; 1308 value = 0;
1303 else if (obj->type == MONEY || obj->type == GEM) 1309 else if (obj->type == MONEY || obj->type == GEM)
1304 value /= 3; 1310 value /= 3;
1305 else 1311 else
1306 value = value * 9 / 10; 1312 value = value * 9 / 10;
… …
1319 if (op->type != PLAYER) 1325 if (op->type != PLAYER)
1320 return 0; 1326 return 0;
1321 1327
1322 archetype *nugget[3]; 1328 archetype *nugget[3];
1323 1329
1324 nugget[0] = archetype::find ("pyrite3"); 1330 nugget[0] = archetype::find (shstr_pyrite3);
1325 nugget[1] = archetype::find ("pyrite2"); 1331 nugget[1] = archetype::find (shstr_pyrite2);
1326 nugget[2] = archetype::find ("pyrite"); 1332 nugget[2] = archetype::find (shstr_pyrite);
1327 1333
1328 /* 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
1329 * some, and also prevents people from alchemising every table/chair/clock 1335 * some, and also prevents people from alchemising every table/chair/clock
1330 * in sight 1336 * in sight
1331 */ 1337 */
… …
1360 1366
1361 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)
1362 { 1368 {
1363 next = tmp->above; 1369 next = tmp->above;
1364 1370
1365 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1371 if (tmp->weight > 0 && !tmp->flag [FLAG_NO_PICK] &&
1366 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1372 !tmp->flag [FLAG_ALIVE] && !tmp->flag [FLAG_IS_CAULDRON])
1367 { 1373 {
1368 if (tmp->inv) 1374 if (tmp->inv)
1369 { 1375 {
1370 object *next1, *tmp1; 1376 object *next1, *tmp1;
1371 1377
1372 for (tmp1 = tmp->inv; tmp1; tmp1 = next1) 1378 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1373 { 1379 {
1374 next1 = tmp1->below; 1380 next1 = tmp1->below;
1375 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1381 if (tmp1->weight > 0 && !tmp1->flag [FLAG_NO_PICK] &&
1376 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1382 !tmp1->flag [FLAG_ALIVE] && !tmp1->flag [FLAG_IS_CAULDRON])
1377 alchemy_object (tmp1, value, weight); 1383 alchemy_object (tmp1, value, weight);
1378 } 1384 }
1379 } 1385 }
1380 1386
1381 alchemy_object (tmp, value, weight); 1387 alchemy_object (tmp, value, weight);
… …
1391 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i) 1397 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1392 if (int nrof = value / nugget [i]->value) 1398 if (int nrof = value / nugget [i]->value)
1393 { 1399 {
1394 value -= nrof * nugget[i]->value; 1400 value -= nrof * nugget[i]->value;
1395 1401
1396 object *tmp = arch_to_object (nugget[i]); 1402 object *tmp = nugget[i]->instance ();
1397 tmp->nrof = nrof; 1403 tmp->nrof = nrof;
1398 tmp->flag [FLAG_IDENTIFIED] = true; 1404 tmp->flag [FLAG_IDENTIFIED] = true;
1399 op->map->insert (tmp, x, y, op, 0); 1405 op->map->insert (tmp, x, y, op, 0);
1400 } 1406 }
1401 1407
… …
1412 * items. 1418 * items.
1413 */ 1419 */
1414int 1420int
1415remove_curse (object *op, object *caster, object *spell) 1421remove_curse (object *op, object *caster, object *spell)
1416{ 1422{
1417 object *tmp;
1418 int success = 0, was_one = 0; 1423 int success = 0, was_one = 0;
1419 1424
1420 for (tmp = op->inv; tmp; tmp = tmp->below) 1425 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1421 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1426 if (tmp->flag [FLAG_APPLIED] &&
1422 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1427 ((tmp->flag [FLAG_CURSED] && spell->flag [FLAG_CURSED]) ||
1423 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1428 (tmp->flag [FLAG_DAMNED] && spell->flag [FLAG_DAMNED])))
1424 { 1429 {
1425 was_one++; 1430 was_one++;
1426 1431
1427 if (tmp->level <= caster_level (caster, spell)) 1432 if (tmp->level <= casting_level (caster, spell))
1428 { 1433 {
1429 success++; 1434 success++;
1430 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1435 if (spell->flag [FLAG_DAMNED])
1431 CLEAR_FLAG (tmp, FLAG_DAMNED); 1436 tmp->clr_flag (FLAG_DAMNED);
1432 1437
1433 CLEAR_FLAG (tmp, FLAG_CURSED); 1438 tmp->clr_flag (FLAG_CURSED);
1434 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED); 1439 tmp->clr_flag (FLAG_KNOWN_CURSED);
1435 tmp->value = 0; /* Still can't sell it */ 1440 tmp->value = 0; /* Still can't sell it */
1436 1441
1437 if (object *pl = tmp->visible_to ()) 1442 if (object *pl = tmp->visible_to ())
1438 esrv_update_item (UPD_FLAGS, pl, tmp); 1443 esrv_update_item (UPD_FLAGS, pl, tmp);
1439 } 1444 }
… …
1457 1462
1458/* Identifies objects in the players inventory/on the ground */ 1463/* Identifies objects in the players inventory/on the ground */
1459int 1464int
1460cast_identify (object *op, object *caster, object *spell) 1465cast_identify (object *op, object *caster, object *spell)
1461{ 1466{
1462 dynbuf_text buf;
1463 object *tmp; 1467 object *tmp;
1468 dynbuf_text &buf = msg_dynbuf; buf.clear ();
1464 1469
1465 int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1470 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 1471
1470 for (tmp = op->inv; tmp; tmp = tmp->below) 1472 for (tmp = op->inv; tmp; tmp = tmp->below)
1471 { 1473 {
1472 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1474 if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && need_identify (tmp))
1473 { 1475 {
1474 identify (tmp); 1476 identify (tmp);
1475 1477
1476 if (op->type == PLAYER) 1478 if (op->type == PLAYER)
1477 { 1479 {
1478 buf.printf ("You identified: %s.\n\n", long_desc (tmp, op)); 1480 buf.printf ("You identified: %s.\r", long_desc (tmp, op));
1479 1481
1480 if (tmp->msg) 1482 if (tmp->msg)
1481 buf << "The item has a story:\n\n" << tmp->msg << "\n\n"; 1483 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1482 } 1484 }
1483 1485
1484 num_ident--;
1485 if (!num_ident) 1486 if (!--num_ident)
1486 break; 1487 break;
1487 } 1488 }
1488 } 1489 }
1489 1490
1490 /* If all the power of the spell has been used up, don't go and identify 1491 /* If all the power of the spell has been used up, don't go and identify
… …
1492 * was not fully used. 1493 * was not fully used.
1493 */ 1494 */
1494 if (num_ident) 1495 if (num_ident)
1495 { 1496 {
1496 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)
1497 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1498 if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && need_identify (tmp))
1498 { 1499 {
1499 identify (tmp); 1500 identify (tmp);
1500 1501
1501 if (object *pl = tmp->visible_to ()) 1502 if (object *pl = tmp->visible_to ())
1502 { 1503 {
1503 buf.printf ("On the ground you identified: %s.\n\n", long_desc (tmp, op)); 1504 buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1504 1505
1505 if (tmp->msg) 1506 if (tmp->msg)
1506 buf << "The item has a story:\n\n" << tmp->msg << "\n\n"; 1507 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1507 } 1508 }
1508 1509
1509 num_ident--;
1510 if (!num_ident) 1510 if (!--num_ident)
1511 break; 1511 break;
1512 } 1512 }
1513 } 1513 }
1514 1514
1515 if (buf.empty ()) 1515 if (buf.empty ())
… …
1537 1537
1538 /* We precompute some values here so that we don't have to keep 1538 /* We precompute some values here so that we don't have to keep
1539 * doing it over and over again. 1539 * doing it over and over again.
1540 */ 1540 */
1541 god = find_god (determine_god (op)); 1541 god = find_god (determine_god (op));
1542 level = caster_level (caster, spell); 1542 level = casting_level (caster, spell);
1543 range = spell->range + SP_level_range_adjust (caster, spell); 1543 range = spell->range + SP_level_range_adjust (caster, spell);
1544 1544
1545 if (!skill) 1545 if (!skill)
1546 skill = caster; 1546 skill = caster;
1547 1547
1548 for (x = op->x - range; x <= op->x + range; x++) 1548 dynbuf buf;
1549 for (y = op->y - range; y <= op->y + range; y++) 1549 unordered_mapwalk (buf, op, -range, -range, range, range)
1550 { 1550 {
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 1551 /* For most of the detections, we only detect objects above the
1557 * floor. But this is not true for show invisible. 1552 * floor. But this is not true for show invisible.
1558 * Basically, we just go and find the top object and work 1553 * Basically, we just go and find the top object and work
1559 * down - that is easier than working up. 1554 * down - that is easier than working up.
1560 */ 1555 */
1561 1556
1562 for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above) 1557 for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1563 last = tmp; 1558 last = tmp;
1564 1559
1565 /* 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
1566 * would happen. 1561 * would happen.
1567 */ 1562 */
1568 if (!last) 1563 if (!last)
1569 continue; 1564 continue;
1570 1565
1571 done_one = 0; 1566 done_one = 0;
1572 floor = 0; 1567 floor = 0;
1573 detect = NULL; 1568 detect = NULL;
1574 for (tmp = last; tmp; tmp = tmp->below) 1569 for (tmp = last; tmp; tmp = tmp->below)
1575 { 1570 {
1576 /* show invisible */ 1571 /* show invisible */
1577 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1572 if (spell->flag [FLAG_MAKE_INVIS]
1578 /* Might there be other objects that we can make visible? */ 1573 /* Might there be other objects that we can make visible? */
1579 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) || 1574 && (tmp->invisible && (tmp->flag [FLAG_MONSTER]
1580 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) || 1575 || (tmp->type == PLAYER && !tmp->flag [FLAG_WIZ])
1581 tmp->type == CF_HANDLE || 1576 || tmp->type == T_HANDLE
1582 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE || 1577 || tmp->type == TRAPDOOR
1578 || tmp->type == EXIT
1579 || tmp->type == HOLE
1580 || tmp->type == BUTTON
1583 tmp->type == BUTTON || tmp->type == TELEPORTER || 1581 || tmp->type == TELEPORTER
1582 || tmp->type == GATE
1584 tmp->type == GATE || tmp->type == LOCKED_DOOR || 1583 || tmp->type == LOCKED_DOOR
1585 tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN || 1584 || tmp->type == WEAPON
1585 || tmp->type == ALTAR
1586 || tmp->type == SIGN
1586 tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY || 1587 || tmp->type == TRIGGER_PEDESTAL
1587 tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR))) 1588 || tmp->type == SPECIAL_KEY
1589 || tmp->type == TREASURE
1590 || tmp->type == BOOK
1591 || tmp->type == HOLY_ALTAR
1592 || tmp->type == CONTAINER)))
1588 { 1593 {
1589 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4) 1594 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1590 { 1595 {
1591 tmp->invisible = 0; 1596 tmp->invisible = 0;
1597 done_one = 1;
1598 }
1599 }
1600
1601 if (tmp->flag [FLAG_IS_FLOOR])
1602 floor = 1;
1603
1604 /* All detections below this point don't descend beneath the floor,
1605 * so just continue on. We could be clever and look at the type of
1606 * detection to completely break out if we don't care about objects beneath
1607 * the floor, but once we get to the floor, not likely a very big issue anyways.
1608 */
1609 if (floor)
1610 continue;
1611
1612 /* I had thought about making detect magic and detect curse
1613 * show the flash the magic item like it does for detect monster.
1614 * however, if the object is within sight, this would then make it
1615 * difficult to see what object is magical/cursed, so the
1616 * effect wouldn't be as apparent.
1617 */
1618
1619 /* detect magic */
1620 if (spell->flag [FLAG_KNOWN_MAGICAL] &&
1621 !tmp->flag [FLAG_KNOWN_MAGICAL] && !tmp->flag [FLAG_IDENTIFIED] && is_magical (tmp))
1622 {
1623 tmp->set_flag (FLAG_KNOWN_MAGICAL);
1624 /* make runes more visible */
1625 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1626 tmp->stats.Cha /= 4;
1627
1628 done_one = 1;
1629 }
1630
1631 /* detect monster */
1632 if (spell->flag [FLAG_MONSTER] && (tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER))
1633 {
1634 done_one = 2;
1635
1636 if (!detect)
1637 detect = tmp;
1638 }
1639
1640 /* Basically, if race is set in the spell, then the creatures race must
1641 * match that. if the spell race is set to GOD, then the gods opposing
1642 * race must match.
1643 */
1644 if (spell->race && tmp->flag [FLAG_MONSTER] && tmp->race &&
1645 ((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1646 spell->race.contains (tmp->race)))
1647 {
1648 done_one = 2;
1649
1650 if (!detect)
1651 detect = tmp;
1652 }
1653
1654 if (spell->flag [FLAG_KNOWN_CURSED] && !tmp->flag [FLAG_KNOWN_CURSED] &&
1655 (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1656 {
1657 tmp->set_flag (FLAG_KNOWN_CURSED);
1658 done_one = 1;
1659 }
1660
1661 // Do mining detection spell:
1662 if (spell->last_sp == 1) // 1 - detect any vein
1663 {
1664 if (tmp->type == VEIN)
1665 {
1666 if (tmp->other_arch)
1667 {
1668 if (!detect)
1669 detect = tmp->other_arch;
1670 done_one = 2;
1671 }
1672 else
1592 done_one = 1; 1673 done_one = 1;
1593 } 1674 }
1594 } 1675 }
1595
1596 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1597 floor = 1;
1598
1599 /* 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
1601 * 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.
1603 */
1604 if (floor)
1605 continue;
1606
1607 /* I had thought about making detect magic and detect curse
1608 * 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
1610 * difficult to see what object is magical/cursed, so the
1611 * effect wouldn't be as apparant.
1612 */
1613
1614 /* detect magic */
1615 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1616 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1617 {
1618 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1619 /* make runes more visibile */
1620 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1621 tmp->stats.Cha /= 4;
1622 done_one = 1;
1623 }
1624 /* detect monster */
1625 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1626 {
1627 done_one = 2;
1628 if (!detect)
1629 detect = tmp;
1630 }
1631 /* 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
1633 * race must match.
1634 */
1635 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1636 ((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) ||
1637 (strstr (spell->race, tmp->race))))
1638 {
1639 done_one = 2;
1640 if (!detect)
1641 detect = tmp;
1642 }
1643 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1644 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1645 {
1646 SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1647 done_one = 1;
1648 }
1649 } /* for stack of objects on this space */ 1676 } /* for stack of objects on this space */
1650 1677
1651 /* Code here puts an effect of the spell on the space, so you can see 1678 /* Code here puts an effect of the spell on the space, so you can see
1652 * where the magic is. 1679 * where the magic is.
1653 */ 1680 */
1654 if (done_one) 1681 if (done_one)
1655 { 1682 {
1656 object *detect_ob = arch_to_object (spell->other_arch); 1683 object *detect_ob = spell->other_arch->instance ();
1657 1684
1658 /* if this is set, we want to copy the face */ 1685 /* if this is set, we want to copy the face */
1659 if (done_one == 2 && detect) 1686 if (done_one == 2 && detect)
1660 { 1687 {
1661 detect_ob->face = detect->face; 1688 detect_ob->face = detect->face;
1662 detect_ob->animation_id = detect->animation_id; 1689 detect_ob->animation_id = detect->animation_id;
1663 detect_ob->anim_speed = detect->anim_speed; 1690 detect_ob->anim_speed = detect->anim_speed;
1664 detect_ob->last_anim = 0; 1691 detect_ob->last_anim = 0;
1665 /* by default, the detect_ob is already animated */ 1692 /* by default, the detect_ob is already animated */
1666 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1693 if (!detect->flag [FLAG_ANIMATE])
1667 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1694 detect_ob->clr_flag (FLAG_ANIMATE);
1668 } 1695 }
1669 1696
1670 m->insert (detect_ob, nx, ny, op); 1697 m->insert (detect_ob, nx, ny, op, INS_ON_TOP);
1671 } 1698 }
1672 } /* for processing the surrounding spaces */ 1699 } /* for processing the surrounding spaces */
1673 1700
1674 1701
1675 /* Now process objects in the players inventory if detect curse or magic */ 1702 /* 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)) 1703 if (spell->flag [FLAG_KNOWN_CURSED] || spell->flag [FLAG_KNOWN_MAGICAL])
1677 { 1704 {
1678 done_one = 0; 1705 done_one = 0;
1679 1706
1680 for (tmp = op->inv; tmp; tmp = tmp->below) 1707 for (tmp = op->inv; tmp; tmp = tmp->below)
1681 { 1708 {
1682 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1709 if (!tmp->invisible && !tmp->flag [FLAG_IDENTIFIED])
1683 { 1710 {
1684 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL)) 1711 if (spell->flag [FLAG_KNOWN_MAGICAL] && is_magical (tmp) && !tmp->flag [FLAG_KNOWN_MAGICAL])
1685 { 1712 {
1686 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1713 tmp->set_flag (FLAG_KNOWN_MAGICAL);
1687 1714
1688 if (object *pl = tmp->visible_to ()) 1715 if (object *pl = tmp->visible_to ())
1689 esrv_update_item (UPD_FLAGS, pl, tmp); 1716 esrv_update_item (UPD_FLAGS, pl, tmp);
1690 } 1717 }
1691 1718
1692 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1719 if (spell->flag [FLAG_KNOWN_CURSED] && !tmp->flag [FLAG_KNOWN_CURSED] &&
1693 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1720 (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1694 { 1721 {
1695 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1722 tmp->set_flag (FLAG_KNOWN_CURSED);
1696 1723
1697 if (object *pl = tmp->visible_to ()) 1724 if (object *pl = tmp->visible_to ())
1698 esrv_update_item (UPD_FLAGS, pl, tmp); 1725 esrv_update_item (UPD_FLAGS, pl, tmp);
1699 } 1726 }
1700 } /* if item is not identified */ 1727 } /* if item is not identified */
… …
1721 1748
1722 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you."); 1749 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
1723 1750
1724 if (victim->stats.sp >= victim->stats.maxsp * 2) 1751 if (victim->stats.sp >= victim->stats.maxsp * 2)
1725 { 1752 {
1726 object *tmp;
1727
1728 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!"); 1753 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; 1754 victim->stats.sp = 2 * victim->stats.maxsp;
1755 create_exploding_ball_at (victim, caster_level);
1737 } 1756 }
1738 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 1757 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."); 1758 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) 1759 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
1741 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 1760 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
1742 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 1761 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
1743 { 1762 {
1744 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 1763 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
… …
1768 mflags = get_map_flags (m, &m, x, y, &x, &y); 1787 mflags = get_map_flags (m, &m, x, y, &x, &y);
1769 1788
1770 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 1789 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
1771 { 1790 {
1772 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above) 1791 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
1773 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 1792 if (plyr != op && plyr->flag [FLAG_ALIVE])
1774 break; 1793 break;
1775 } 1794 }
1776 1795
1777 1796
1778 /* If we did not find a player in the specified direction, transfer 1797 /* If we did not find a player in the specified direction, transfer
1779 * to anyone on top of us. This is used for the rune of transference mostly. 1798 * to anyone on top of us. This is used for the rune of transference mostly.
1780 */ 1799 */
1781 if (plyr == NULL) 1800 if (plyr == NULL)
1782 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above) 1801 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
1783 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 1802 if (plyr != op && plyr->flag [FLAG_ALIVE])
1784 break; 1803 break;
1785 1804
1786 if (!plyr) 1805 if (!plyr)
1787 { 1806 {
1788 new_draw_info (NDI_BLACK, 0, op, "There is no one there."); 1807 new_draw_info (NDI_BLACK, 0, op, "There is no one there.");
… …
1790 } 1809 }
1791 /* give sp */ 1810 /* give sp */
1792 if (spell->stats.dam > 0) 1811 if (spell->stats.dam > 0)
1793 { 1812 {
1794 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell); 1813 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
1795 charge_mana_effect (plyr, caster_level (caster, spell)); 1814 charge_mana_effect (plyr, casting_level (caster, spell));
1796 return 1; 1815 return 1;
1797 } 1816 }
1798 /* suck sp away. Can't suck sp from yourself */ 1817 /* suck sp away. Can't suck sp from yourself */
1799 else if (op != plyr) 1818 else if (op != plyr)
1800 { 1819 {
… …
1805 if (rate > 95) 1824 if (rate > 95)
1806 rate = 95; 1825 rate = 95;
1807 1826
1808 sucked = (plyr->stats.sp * rate) / 100; 1827 sucked = (plyr->stats.sp * rate) / 100;
1809 plyr->stats.sp -= sucked; 1828 plyr->stats.sp -= sucked;
1810 if (QUERY_FLAG (op, FLAG_ALIVE)) 1829 if (op->flag [FLAG_ALIVE])
1811 { 1830 {
1812 /* Player doesn't get full credit */ 1831 /* Player doesn't get full credit */
1813 sucked = (sucked * rate) / 100; 1832 sucked = (sucked * rate) / 100;
1814 op->stats.sp += sucked; 1833 op->stats.sp += sucked;
1815 if (sucked > 0) 1834 if (sucked > 0)
1816 { 1835 {
1817 charge_mana_effect (op, caster_level (caster, spell)); 1836 charge_mana_effect (op, casting_level (caster, spell));
1818 } 1837 }
1819 } 1838 }
1820 return 1; 1839 return 1;
1821 } 1840 }
1822 return 0; 1841 return 0;
… …
1866 * monsters either. 1885 * monsters either.
1867 */ 1886 */
1868 1887
1869 if (head->attacktype & AT_MAGIC 1888 if (head->attacktype & AT_MAGIC
1870 && !(head->attacktype & AT_COUNTERSPELL) 1889 && !(head->attacktype & AT_COUNTERSPELL)
1871 && !QUERY_FLAG (head, FLAG_MONSTER) 1890 && !head->flag [FLAG_MONSTER]
1872 && (op->level > head->level)) 1891 && (op->level > head->level))
1873 head->destroy (); 1892 head->destroy ();
1874 else 1893 else
1875 switch (head->type) 1894 switch (head->type)
1876 { 1895 {
1877 case SPELL_EFFECT: 1896 case SPELL_EFFECT:
1878 // XXX: Don't affect floor spelleffects. See also XXX comment 1897 // XXX: Don't affect floor spelleffects. See also XXX comment
1879 // about sanctuary in spell_util.C 1898 // about sanctuary in spell_util.C
1880 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1899 if (tmp->flag [FLAG_IS_FLOOR])
1881 continue; 1900 continue;
1882 1901
1883 if (op->level > head->level) 1902 if (op->level > head->level)
1884 head->destroy (); 1903 head->destroy ();
1885 1904
… …
1914 return 0; 1933 return 0;
1915 } 1934 }
1916 1935
1917 for (tmp = op->below; tmp; tmp = tmp->below) 1936 for (tmp = op->below; tmp; tmp = tmp->below)
1918 { 1937 {
1919 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1938 if (tmp->flag [FLAG_IS_FLOOR])
1920 break; 1939 break;
1921 if (tmp->type == HOLY_ALTAR) 1940 if (tmp->type == HOLY_ALTAR)
1922 { 1941 {
1923 1942
1924 if (tmp->level > caster_level (caster, spell)) 1943 if (tmp->level > casting_level (caster, spell))
1925 { 1944 {
1926 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name); 1945 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);
1927 return 0; 1946 return 0;
1928 } 1947 }
1929 else 1948 else
1930 { 1949 {
1931 /* If we got here, we are consecrating an altar */ 1950 /* If we got here, we are consecrating an altar */
1932 sprintf (buf, "Altar of %s", &god->name); 1951 sprintf (buf, "Altar of %s", &god->name);
1933 tmp->name = buf; 1952 tmp->name = buf;
1934 tmp->level = caster_level (caster, spell); 1953 tmp->level = casting_level (caster, spell);
1935 tmp->other_arch = god->arch; 1954 tmp->other_arch = god->arch;
1936 1955
1937 if (op->type == PLAYER) 1956 if (op->type == PLAYER)
1938 esrv_update_item (UPD_NAME, op, tmp); 1957 esrv_update_item (UPD_NAME, op, tmp);
1939 1958
… …
1982 return 0; 2001 return 0;
1983 } 2002 }
1984 2003
1985 /* if no direction specified, pick one */ 2004 /* if no direction specified, pick one */
1986 if (!dir) 2005 if (!dir)
1987 dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9); 2006 dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
1988 2007
1989 m = op->map; 2008 m = op->map;
1990 x = op->x + freearr_x[dir]; 2009 x = op->x + freearr_x[dir];
1991 y = op->y + freearr_y[dir]; 2010 y = op->y + freearr_y[dir];
1992 2011
1993 /* if there's no place to put the golem, abort */ 2012 /* 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) || 2013 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)) 2014 || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
1996 { 2015 {
1997 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 2016 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1998 return 0; 2017 return 0;
1999 } 2018 }
2000 2019
… …
2004 if (!weapon) 2023 if (!weapon)
2005 { 2024 {
2006 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 2025 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2007 return 0; 2026 return 0;
2008 } 2027 }
2028
2009 if (spell->race && strcmp (weapon->arch->archname, spell->race)) 2029 if (spell->race && weapon->arch->archname != spell->race)
2010 { 2030 {
2011 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2031 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2012 return 0; 2032 return 0;
2013 } 2033 }
2034
2014 if (weapon->type != WEAPON) 2035 if (weapon->type != WEAPON)
2015 { 2036 {
2016 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it."); 2037 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");
2017 return 0; 2038 return 0;
2018 } 2039 }
2019 if (QUERY_FLAG (weapon, FLAG_APPLIED)) 2040
2041 if (weapon->flag [FLAG_APPLIED])
2020 { 2042 {
2021 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon)); 2043 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; 2044 return 0;
2023 } 2045 }
2024 2046
2025 weapon = weapon->split (); 2047 weapon = weapon->split ();
2026 2048
2027 /* create the golem object */ 2049 /* create the golem object */
2028 tmp = arch_to_object (spell->other_arch); 2050 tmp = spell->other_arch->instance ();
2029 2051
2030 /* if animated by a player, give the player control of the golem */ 2052 /* if animated by a player, give the player control of the golem */
2031 CLEAR_FLAG (tmp, FLAG_MONSTER); 2053 tmp->clr_flag (FLAG_MONSTER);
2032 tmp->stats.exp = 0; 2054 tmp->stats.exp = 0;
2033 add_friendly_object (tmp); 2055 add_friendly_object (tmp);
2034 tmp->type = GOLEM; 2056 tmp->type = GOLEM;
2035 tmp->set_owner (op); 2057 tmp->set_owner (op);
2036 op->contr->golem = tmp; 2058 op->contr->golem = tmp;
… …
2038 2060
2039 /* Give the weapon to the golem now. A bit of a hack to check the 2061 /* Give the weapon to the golem now. A bit of a hack to check the
2040 * removed flag - it should only be set if weapon->split was 2062 * removed flag - it should only be set if weapon->split was
2041 * used above. 2063 * used above.
2042 */ 2064 */
2043 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2065 if (!weapon->flag [FLAG_REMOVED])
2044 weapon->remove (); 2066 weapon->remove ();
2045 2067
2046 tmp->insert (weapon); 2068 tmp->insert (weapon);
2047 2069
2048 /* To do everything necessary to let a golem use the weapon is a pain, 2070 /* To do everything necessary to let a golem use the weapon is a pain,
2049 * so instead, just set it as equipped (otherwise, we need to update 2071 * so instead, just set it as equipped (otherwise, we need to update
2050 * body_info, skills, etc) 2072 * body_info, skills, etc)
2051 */ 2073 */
2052 SET_FLAG (tmp, FLAG_USE_WEAPON); 2074 tmp->set_flag (FLAG_USE_WEAPON);
2053 SET_FLAG (weapon, FLAG_APPLIED); 2075 weapon->set_flag (FLAG_APPLIED);
2054 tmp->update_stats (); 2076 tmp->update_stats ();
2055 2077
2056 /* There used to be 'odd' code that basically seemed to take the absolute 2078 /* There used to be 'odd' code that basically seemed to take the absolute
2057 * value of the weapon->magic an use that. IMO, that doesn't make sense - 2079 * value of the weapon->magic an use that. IMO, that doesn't make sense -
2058 * if you're using a crappy weapon, it shouldn't be as good. 2080 * if you're using a crappy weapon, it shouldn't be as good.
… …
2078 2100
2079 /* attacktype */ 2101 /* attacktype */
2080 if (!tmp->attacktype) 2102 if (!tmp->attacktype)
2081 tmp->attacktype = AT_PHYSICAL; 2103 tmp->attacktype = AT_PHYSICAL;
2082 2104
2083 if (materialtype_t *mt = name_to_material (op->materialname))
2084 {
2085 for (i = 0; i < NROFATTACKS; i++) 2105 for (i = 0; i < NROFATTACKS; i++)
2086 tmp->resist[i] = 50 - (mt->save[i] * 5); 2106 tmp->resist[i] = 50 - (op->material->save[i] * 5);
2087 a = mt->save[0]; 2107
2088 } 2108 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 2109
2096 /* Set weapon's immunity */ 2110 /* Set weapon's immunity */
2097 tmp->resist[ATNR_CONFUSION] = 100; 2111 tmp->resist[ATNR_CONFUSION] = 100;
2098 tmp->resist[ATNR_POISON] = 100; 2112 tmp->resist[ATNR_POISON] = 100;
2099 tmp->resist[ATNR_SLOW] = 100; 2113 tmp->resist[ATNR_SLOW] = 100;
… …
2126 tmp->state = weapon->state; 2140 tmp->state = weapon->state;
2127 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE]; 2141 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2128 } 2142 }
2129 2143
2130 /* make experience increase in proportion to the strength of the summoned creature. */ 2144 /* 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)); 2145 tmp->stats.exp *= 1 + (max (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2132 2146
2133 tmp->speed_left = -1; 2147 tmp->speed_left = -1;
2134 tmp->direction = dir; 2148 tmp->direction = dir;
2135 2149
2136 m->insert (tmp, x, y, op); 2150 m->insert (tmp, x, y, op);
… …
2140/* cast_daylight() - changes the map darkness level *lower* */ 2154/* cast_daylight() - changes the map darkness level *lower* */
2141 2155
2142/* cast_change_map_lightlevel: Was cast_daylight/nightfall. 2156/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2143 * This changes the light level for the entire map. 2157 * This changes the light level for the entire map.
2144 */ 2158 */
2145
2146int 2159int
2147cast_change_map_lightlevel (object *op, object *caster, object *spell) 2160cast_change_map_lightlevel (object *op, object *caster, object *spell)
2148{ 2161{
2149 int success; 2162 int success;
2150 2163
… …
2158 if (spell->stats.dam < 0) 2171 if (spell->stats.dam < 0)
2159 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2172 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2160 else 2173 else
2161 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2174 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2162 } 2175 }
2176
2163 return success; 2177 return success;
2164} 2178}
2165 2179
2166/* create an aura spell object and put it in the player's inventory. 2180/* 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, 2181 * as usual, op is player, caster is the object casting the spell,
… …
2175 2189
2176 new_aura = present_arch_in_ob (spell->other_arch, op); 2190 new_aura = present_arch_in_ob (spell->other_arch, op);
2177 if (new_aura) 2191 if (new_aura)
2178 refresh = 1; 2192 refresh = 1;
2179 else 2193 else
2180 new_aura = arch_to_object (spell->other_arch); 2194 new_aura = spell->other_arch->instance ();
2181 2195
2182 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2196 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2183 2197
2184 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2198 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2185 2199
2186 set_spell_skill (op, caster, spell, new_aura); 2200 set_spell_skill (op, caster, spell, new_aura);
2187 new_aura->attacktype = spell->attacktype; 2201 new_aura->attacktype = spell->attacktype;
2188 2202
2189 new_aura->level = caster_level (caster, spell); 2203 new_aura->level = casting_level (caster, spell);
2190 2204
2191 if (refresh) 2205 if (refresh)
2192 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2206 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2193 else 2207 else
2194 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2208 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))) 2264 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2251 { 2265 {
2252 hit_map (aura, i, aura->attacktype, 0); 2266 hit_map (aura, i, aura->attacktype, 0);
2253 2267
2254 if (aura->other_arch) 2268 if (aura->other_arch)
2255 pos.insert (arch_to_object (aura->other_arch), aura); 2269 pos.insert (aura->other_arch->instance (), aura);
2256 } 2270 }
2257 } 2271 }
2258 2272
2259 /* put the aura back in the player's inventory */ 2273 /* put the aura back in the player's inventory */
2260 env->insert (aura); 2274 env->insert (aura);
… …
2265 * op is the piece object. 2279 * op is the piece object.
2266 */ 2280 */
2267void 2281void
2268move_peacemaker (object *op) 2282move_peacemaker (object *op)
2269{ 2283{
2270 object *tmp; 2284 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 { 2285 {
2274 int atk_lev, def_lev; 2286 int atk_lev, def_lev;
2275 object *victim = tmp->head_ (); 2287 object *victim = tmp->head_ ();
2276 2288
2277 if (!QUERY_FLAG (victim, FLAG_MONSTER)) 2289 if (!victim->flag [FLAG_MONSTER])
2278 continue; 2290 continue;
2279 2291
2280 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE)) 2292 if (victim->flag [FLAG_UNAGGRESSIVE])
2281 continue; 2293 continue;
2282 2294
2283 if (victim->stats.exp == 0) 2295 if (victim->stats.exp == 0)
2284 continue; 2296 continue;
2285 2297
2286 def_lev = MAX (1, victim->level); 2298 def_lev = max (1, victim->level);
2287 atk_lev = MAX (1, op->level); 2299 atk_lev = max (1, op->level);
2288 2300
2289 if (rndm (0, atk_lev - 1) > def_lev) 2301 if (rndm (0, atk_lev - 1) > def_lev)
2290 { 2302 {
2291 /* make this sucker peaceful. */ 2303 /* make this sucker peaceful. */
2292 2304
… …
2301 victim->stats.sp = 0; 2313 victim->stats.sp = 0;
2302 victim->stats.grace = 0; 2314 victim->stats.grace = 0;
2303 victim->stats.Pow = 0; 2315 victim->stats.Pow = 0;
2304#endif 2316#endif
2305 victim->attack_movement = RANDO2; 2317 victim->attack_movement = RANDO2;
2306 SET_FLAG (victim, FLAG_UNAGGRESSIVE); 2318 victim->set_flag (FLAG_UNAGGRESSIVE);
2307 SET_FLAG (victim, FLAG_RUN_AWAY); 2319 victim->set_flag (FLAG_RUN_AWAY);
2308 SET_FLAG (victim, FLAG_RANDOM_MOVE); 2320 victim->set_flag (FLAG_RANDOM_MOVE);
2309 CLEAR_FLAG (victim, FLAG_MONSTER); 2321 victim->clr_flag (FLAG_MONSTER);
2310 2322
2311 if (victim->name) 2323 if (victim->name)
2312 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name); 2324 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2313 } 2325 }
2314 } 2326 }
2315} 2327}
2316
2317 2328
2318/* This writes a rune that contains the appropriate message. 2329/* This writes a rune that contains the appropriate message.
2319 * There really isn't any adjustments we make. 2330 * There really isn't any adjustments we make.
2320 */ 2331 */
2321
2322int 2332int
2323write_mark (object *op, object *spell, const char *msg) 2333write_mark (object *op, object *spell, const char *msg)
2324{ 2334{
2325 char rune[HUGE_BUF];
2326 object *tmp;
2327
2328 if (!msg || msg[0] == 0) 2335 if (!msg || msg[0] == 0)
2329 { 2336 {
2330 new_draw_info (NDI_UNIQUE, 0, op, "Write what?"); 2337 new_draw_info (NDI_UNIQUE, 0, op, "Write what?");
2331 return 0; 2338 return 0;
2332 } 2339 }
2333 2340
2334 if (strcasestr_local (msg, "endmsg")) 2341 if (!msg_is_safe (msg))
2335 { 2342 {
2336 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?"); 2343 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); 2344 LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2338 return 0; 2345 return 0;
2339 } 2346 }
2347
2340 if (!spell->other_arch) 2348 if (!spell->other_arch)
2341 return 0; 2349 return 0;
2342 tmp = arch_to_object (spell->other_arch);
2343 2350
2344 snprintf (rune, sizeof (rune), "%s\n", msg); 2351 object *tmp = spell->other_arch->instance ();
2345 2352
2346 tmp->race = op->name; /*Save the owner of the rune */ 2353 tmp->race = op->name; /*Save the owner of the rune */
2347 tmp->msg = rune; 2354 tmp->msg = msg;
2348 2355
2349 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR); 2356 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2357
2350 return 1; 2358 return 1;
2351} 2359}
2360

Diff Legend

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