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.120 by root, Fri Mar 26 01:04:45 2010 UTC vs.
Revision 1.148 by root, Sat Nov 17 23:40:04 2018 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 (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
4 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 5 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team 6 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992 Frank Tore Johansen 7 * Copyright (©) 1992 Frank Tore Johansen
7 * 8 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 9 * Deliantra is free software: you can redistribute it and/or modify it under
9 * the terms of the Affero GNU General Public License as published by the 10 * the terms of the Affero GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your 11 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version. 12 * option) any later version.
12 * 13 *
13 * This program is distributed in the hope that it will be useful, 14 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 17 * GNU General Public License for more details.
17 * 18 *
18 * You should have received a copy of the Affero GNU General Public License 19 * You should have received a copy of the Affero GNU General Public License
19 * and the GNU General Public License along with this program. If not, see 20 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>. 21 * <http://www.gnu.org/licenses/>.
21 * 22 *
22 * The authors can be reached via e-mail to <support@deliantra.net> 23 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 24 */
24 25
25#include <global.h> 26#include <global.h>
26#include <object.h> 27#include <object.h>
… …
58} 59}
59 60
60int 61int
61recharge (object *op, object *caster, object *spell_ob) 62recharge (object *op, object *caster, object *spell_ob)
62{ 63{
63 object *wand, *tmp;
64 int ncharges; 64 int ncharges;
65 65
66 wand = find_marked_object (op); 66 object *wand = op->mark ();
67
67 if (!wand || wand->type != WAND) 68 if (!wand || wand->type != WAND)
68 { 69 {
69 new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge."); 70 op->failmsg ("You need to mark the wand you want to recharge.");
70 return 0; 71 return 0;
71 } 72 }
73
72 if (!(random_roll (0, 3, op, PREFER_HIGH))) 74 if (!(random_roll (0, 3, op, PREFER_HIGH)))
73 { 75 {
74 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand)); 76 op->failmsgf ("The %s vibrates violently, then explodes!", query_name (wand));
75 op->play_sound (sound_find ("ob_explode")); 77 op->play_sound (sound_find ("ob_explode"));
76 wand->destroy (); 78 wand->destroy ();
77 tmp = get_archetype (shstr_fireball); 79 object *tmp = archetype::get (shstr_fireball);
78 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 80 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
79 81
80 if (!tmp->stats.dam) 82 if (!tmp->stats.dam)
81 tmp->stats.dam = 1; 83 tmp->stats.dam = 1;
82 84
… …
93 95
94 if (wand->inv && wand->inv->level) 96 if (wand->inv && wand->inv->level)
95 ncharges /= wand->inv->level; 97 ncharges /= wand->inv->level;
96 else 98 else
97 { 99 {
98 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand)); 100 op->failmsgf ("Your %s is broken.", query_name (wand));
99 return 0; 101 return 0;
100 } 102 }
101 103
102 if (!ncharges) 104 if (!ncharges)
103 ncharges = 1; 105 ncharges = 1;
104 106
105 wand->stats.food += ncharges; 107 wand->stats.food += ncharges;
106 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand)); 108 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
107 109
108 if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE)) 110 if (wand->arch && wand->arch->flag [FLAG_ANIMATE])
109 { 111 {
110 SET_FLAG (wand, FLAG_ANIMATE); 112 wand->set_flag (FLAG_ANIMATE);
111 wand->set_speed (wand->arch->speed); 113 wand->set_speed (wand->arch->speed);
112 } 114 }
113 115
114 return 1; 116 return 1;
115} 117}
… …
129{ 131{
130 int bonus_plus = 0; 132 int bonus_plus = 0;
131 const char *missile_name = "arrow"; 133 const char *missile_name = "arrow";
132 134
133 for (object *tmp = op->inv; tmp; tmp = tmp->below) 135 for (object *tmp = op->inv; tmp; tmp = tmp->below)
134 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 136 if (tmp->type == BOW && tmp->flag [FLAG_APPLIED])
135 missile_name = tmp->race; 137 missile_name = tmp->race;
136 138
137 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 139 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
138 140
139 archetype *missile_arch = archetype::find (missile_name); 141 archetype *missile_arch = archetype::find (missile_name);
… …
158 break; 160 break;
159 161
160 if (!al) 162 if (!al)
161 { 163 {
162 missile->destroy (); 164 missile->destroy ();
163 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, spellparam); 165 op->failmsgf ("No such object %ss of %s", missile_name, spellparam);
164 return 0; 166 return 0;
165 } 167 }
166 168
167 if (al->item->slaying) 169 if (al->item->slaying)
168 { 170 {
169 missile->destroy (); 171 missile->destroy ();
170 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, spellparam); 172 op->failmsgf ("You are not allowed to create %ss of %s", missile_name, spellparam);
171 return 0; 173 return 0;
172 } 174 }
173 175
174 give_artifact_abilities (missile, al->item); 176 give_artifact_abilities (missile, al->item);
175 /* These special arrows cost something extra. Don't have them also be magical - 177 /* These special arrows cost something extra. Don't have them also be magical -
… …
193 195
194 missile->magic = missile_plus; 196 missile->magic = missile_plus;
195 /* Can't get any money for these objects */ 197 /* Can't get any money for these objects */
196 missile->value = 0; 198 missile->value = 0;
197 199
198 SET_FLAG (missile, FLAG_IDENTIFIED); 200 missile->set_flag (FLAG_IDENTIFIED);
199 201
200 if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ()) 202 cast_create_obj (op, caster, missile, dir);
203
204 if (!dir
205 && op->type == PLAYER
206 && !missile->destroyed ())
201 pick_up (op, missile); 207 pick_up (op, missile);
202 208
203 return 1; 209 return 1;
204} 210}
205
206 211
207/* allows the choice of what sort of food object to make. 212/* allows the choice of what sort of food object to make.
208 * If spellparam is NULL, it will create food dependent on level --PeterM*/ 213 * If spellparam is NULL, it will create food dependent on level --PeterM*/
209int 214int
210cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam) 215cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
… …
257 /* Pretty unlikely (there are some very low food items), but you never 262 /* Pretty unlikely (there are some very low food items), but you never
258 * know 263 * know
259 */ 264 */
260 if (!at) 265 if (!at)
261 { 266 {
262 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food."); 267 op->failmsgf ("You don't have enough experience to create any food.");
263 return 0; 268 return 0;
264 } 269 }
265 270
266 food_value /= at->stats.food; 271 food_value /= at->stats.food;
267 new_op = at->instance (); 272 new_op = at->instance ();
… …
289 } 294 }
290 295
291 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 296 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
292 for (r = 1; r < maxrange; r++) 297 for (r = 1; r < maxrange; r++)
293 { 298 {
294 sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir]; 299 sint16 x = op->x + r * DIRX (dir), y = op->y + r * DIRY (dir);
295 300
296 m = op->map; 301 m = op->map;
297 mflags = get_map_flags (m, &m, x, y, &x, &y); 302 mflags = get_map_flags (m, &m, x, y, &x, &y);
298 303
299 if (mflags & P_OUT_OF_MAP) 304 if (mflags & P_OUT_OF_MAP)
300 break; 305 break;
301 306
302 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC)) 307 if (!op->flag [FLAG_WIZCAST] && (mflags & P_NO_MAGIC))
303 { 308 {
304 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic."); 309 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
305 return 0; 310 return 0;
306 } 311 }
307 312
308 if (mflags & P_IS_ALIVE) 313 if (mflags & P_IS_ALIVE)
309 { 314 {
310 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above) 315 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
311 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 316 if (tmp->flag [FLAG_ALIVE] && (tmp->type == PLAYER || tmp->flag [FLAG_MONSTER]))
312 { 317 {
313 new_draw_info (NDI_UNIQUE, 0, op, "You detect something."); 318 new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
314 if (tmp->head != NULL) 319 if (tmp->head != NULL)
315 tmp = tmp->head; 320 tmp = tmp->head;
316 examine_monster (op, tmp); 321 examine_monster (op, tmp);
… …
339 if (pl->type == PLAYER) 344 if (pl->type == PLAYER)
340 { 345 {
341 /* If race isn't set, then invisible unless it is undead */ 346 /* If race isn't set, then invisible unless it is undead */
342 if (!pl->contr->invis_race) 347 if (!pl->contr->invis_race)
343 { 348 {
344 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 349 if (mon->flag [FLAG_UNDEAD])
345 return 0; 350 return 0;
346 351
347 return 1; 352 return 1;
348 } 353 }
349 354
… …
380int 385int
381cast_invisible (object *op, object *caster, object *spell_ob) 386cast_invisible (object *op, object *caster, object *spell_ob)
382{ 387{
383 if (op->invisible > 1000) 388 if (op->invisible > 1000)
384 { 389 {
385 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further"); 390 op->failmsg ("You can not extend the duration of your invisibility any further");
386 return 0; 391 return 0;
387 } 392 }
388 393
389 /* Remove the switch with 90% duplicate code - just handle the differences with 394 /* Remove the switch with 90% duplicate code - just handle the differences with
390 * and if statement or two. 395 * and if statement or two.
391 */ 396 */
392 op->invisible += spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 397 op->invisible += spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
398
393 /* max duration */ 399 /* limit duration */
394 if (op->invisible > 1000) 400 min_it (op->invisible, 1000);
395 op->invisible = 1000;
396 401
397 if (op->type == PLAYER) 402 if (op->type == PLAYER)
398 { 403 {
399 op->contr->invis_race = spell_ob->race; 404 op->contr->invis_race = spell_ob->race;
400 405
401 if (QUERY_FLAG (spell_ob, FLAG_MAKE_INVIS)) 406 if (spell_ob->flag [FLAG_MAKE_INVIS])
402 op->contr->tmp_invis = 0; 407 op->contr->tmp_invis = 0;
403 else 408 else
404 op->contr->tmp_invis = 1; 409 op->contr->tmp_invis = 1;
405
406 op->contr->hidden = 0;
407 } 410 }
408 411
409 if (makes_invisible_to (op, op)) 412 if (makes_invisible_to (op, op))
410 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!"); 413 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
411 else 414 else
… …
448 // earth to dust tears down everything that can be torn down 451 // earth to dust tears down everything that can be torn down
449 for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next) 452 for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
450 { 453 {
451 next = tmp->above; 454 next = tmp->above;
452 455
453 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 456 if (tmp->flag [FLAG_TEAR_DOWN])
454 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 457 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
455 } 458 }
456 } 459 }
457 460
458 return 1; 461 return 1;
… …
460 463
461void 464void
462execute_word_of_recall (object *op) 465execute_word_of_recall (object *op)
463{ 466{
464 if (object *pl = op->in_player ()) 467 if (object *pl = op->in_player ())
465 {
466 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST)) 468 if (pl->ms ().flags () & P_NO_CLERIC && !pl->flag [FLAG_WIZCAST])
467 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you."); 469 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
468 else 470 else
469 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp); 471 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
470 }
471 472
472 op->destroy (); 473 op->destroy ();
473} 474}
474 475
475/* Word of recall causes the player to return 'home'. 476/* Word of recall causes the player to return 'home'.
476 * we put a force into the player object, so that there is a 477 * we put a force into the player object, so that there is a
477 * time delay effect. 478 * time delay effect.
478 */ 479 */
479int 480int
480cast_word_of_recall (object *op, object *caster, object *spell_ob) 481cast_word_of_recall (object *op, object *caster, object *spell_ob)
481{ 482{
482 object *dummy; 483 if (!op->is_player ())
483 int time;
484
485 if (op->type != PLAYER)
486 return 0; 484 return 0;
487 485
488 if (find_obj_by_type_subtype (op, SPELL_EFFECT, SP_WORD_OF_RECALL)) 486 if (find_obj_by_type_subtype (op, SPELL_EFFECT, SP_WORD_OF_RECALL))
489 { 487 {
490 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 488 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
491 return 1; 489 return 1;
492 } 490 }
493 491
494 dummy = get_archetype (FORCE_NAME); 492 object *dummy = archetype::get (FORCE_NAME);
495 493
496 if (!dummy)
497 {
498 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
499 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
500 return 0;
501 }
502
503 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob); 494 int time = max (1, spell_ob->duration - SP_level_duration_adjust (caster, spell_ob));
504 if (time < 1)
505 time = 1;
506 495
507 /* value of speed really doesn't make much difference, as long as it is 496 /* value of speed really doesn't make much difference, as long as it is
508 * positive. Lower value may be useful so that the problem doesn't 497 * positive. Lower value may be useful so that the problem doesn't
509 * do anything really odd if it say a -1000 or something. 498 * do anything really odd if it say a -1000 or something.
510 */ 499 */
511 dummy->set_speed (0.002); 500 dummy->set_speed (0.002);
512 dummy->speed_left = -dummy->speed * time; 501 dummy->speed_left = -dummy->speed * time;
513 dummy->type = SPELL_EFFECT; 502 dummy->type = SPELL_EFFECT;
514 dummy->subtype = SP_WORD_OF_RECALL; 503 dummy->subtype = SP_WORD_OF_RECALL;
515 504 dummy->slaying = op->contr->savebed_map;
516 /* If we could take advantage of enter_player_savebed() here, it would be 505 dummy->stats.hp = op->contr->bed_x;
517 * nice, but until the map load fails, we can't. 506 dummy->stats.sp = op->contr->bed_y;
518 */
519 EXIT_PATH (dummy) = op->contr->savebed_map;
520 EXIT_X (dummy) = op->contr->bed_x;
521 EXIT_Y (dummy) = op->contr->bed_y;
522 507
523 op->insert (dummy); 508 op->insert (dummy);
524 509
525 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 510 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
526 511
… …
635 x = op->x; 620 x = op->x;
636 y = op->y; 621 y = op->y;
637 } 622 }
638 else 623 else
639 { 624 {
640 x = op->x + freearr_x[dir]; 625 x = op->x + DIRX (dir);
641 y = op->y + freearr_y[dir]; 626 y = op->y + DIRY (dir);
642 } 627 }
643 628
644 m = op->map; 629 m = op->map;
645 630
646 if ((spell_ob->move_block || x != op->x || y != op->y) && 631 if ((spell_ob->move_block || x != op->x || y != op->y) &&
647 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) || 632 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
648 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block))) 633 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
649 { 634 {
650 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 635 op->failmsg ("Something is in the way.");
651 return 0; 636 return 0;
652 } 637 }
653 638
654 if (spell_ob->other_arch) 639 if (spell_ob->other_arch)
655 tmp = spell_ob->other_arch->instance (); 640 tmp = spell_ob->other_arch->instance ();
… …
679 tmp->attacktype = spell_ob->attacktype; 664 tmp->attacktype = spell_ob->attacktype;
680 tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 665 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); 666 tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
682 tmp->range = 0; 667 tmp->range = 0;
683 } 668 }
684 else if (QUERY_FLAG (tmp, FLAG_ALIVE)) 669 else if (tmp->flag [FLAG_ALIVE])
685 { 670 {
686 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 671 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
687 tmp->stats.maxhp = tmp->stats.hp; 672 tmp->stats.maxhp = tmp->stats.hp;
688 } 673 }
689 674
690 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP)) 675 if (spell_ob->flag [FLAG_IS_USED_UP] || tmp->flag [FLAG_IS_USED_UP])
691 { 676 {
692 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 677 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
693 SET_FLAG (tmp, FLAG_IS_USED_UP); 678 tmp->set_flag (FLAG_IS_USED_UP);
694 } 679 }
695 680
696 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN)) 681 if (spell_ob->flag [FLAG_TEAR_DOWN])
697 { 682 {
698 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 683 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
699 tmp->stats.maxhp = tmp->stats.hp; 684 tmp->stats.maxhp = tmp->stats.hp;
700 SET_FLAG (tmp, FLAG_TEAR_DOWN); 685 tmp->set_flag (FLAG_TEAR_DOWN);
701 SET_FLAG (tmp, FLAG_ALIVE); 686 tmp->set_flag (FLAG_ALIVE);
702 } 687 }
703 688
704 /* This can't really hurt - if the object doesn't kill anything, 689 /* 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 690 * these fields just won't be used. Do not set the owner for
706 * earthwalls, though, so they survive restarts. 691 * earthwalls, though, so they survive restarts.
… …
721 /* If this is a spellcasting wall, need to insert the spell object */ 706 /* If this is a spellcasting wall, need to insert the spell object */
722 if (tmp->other_arch && tmp->other_arch->type == SPELL) 707 if (tmp->other_arch && tmp->other_arch->type == SPELL)
723 insert_ob_in_ob (tmp->other_arch->instance (), tmp); 708 insert_ob_in_ob (tmp->other_arch->instance (), tmp);
724 709
725 /* This code causes the wall to extend some distance in 710 /* This code causes the wall to extend some distance in
726 * each direction, or until an obstruction is encountered. 711 * each direction, or until an obstruction is encountered.
727 * posblocked and negblocked help determine how far the 712 * posblocked and negblocked help determine how far the
728 * created wall can extend, it won't go extend through 713 * created wall can extend, it won't go extend through
729 * blocked spaces. 714 * blocked spaces.
730 */ 715 */
731 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 716 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
… …
736 { 721 {
737 int dir2; 722 int dir2;
738 723
739 dir2 = (dir < 4) ? (dir + 2) : dir - 2; 724 dir2 = (dir < 4) ? (dir + 2) : dir - 2;
740 725
741 x = tmp->x + i * freearr_x[dir2]; 726 x = tmp->x + i * DIRX (dir2);
742 y = tmp->y + i * freearr_y[dir2]; 727 y = tmp->y + i * DIRY (dir2);
743 m = tmp->map; 728 m = tmp->map;
744 729
745 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 730 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
746 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked) 731 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
747 { 732 {
… …
754 739
755 } 740 }
756 else 741 else
757 posblocked = 1; 742 posblocked = 1;
758 743
759 x = tmp->x - i * freearr_x[dir2]; 744 x = tmp->x - i * DIRX (dir2);
760 y = tmp->y - i * freearr_y[dir2]; 745 y = tmp->y - i * DIRY (dir2);
761 m = tmp->map; 746 m = tmp->map;
762 747
763 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 748 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
764 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked) 749 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
765 { 750 {
… …
771 } 756 }
772 else 757 else
773 negblocked = 1; 758 negblocked = 1;
774 } 759 }
775 760
776 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) 761 if (tmp->flag [FLAG_BLOCKSVIEW])
777 update_all_los (op->map, op->x, op->y); 762 update_all_los (op->map, op->x, op->y);
778 763
779 return 1; 764 return 1;
780} 765}
781 766
… …
790 if (op->type != PLAYER) 775 if (op->type != PLAYER)
791 return 0; 776 return 0;
792 777
793 if (!dir) 778 if (!dir)
794 { 779 {
795 new_draw_info (NDI_UNIQUE, 0, op, "In what direction?"); 780 op->failmsg ("In what direction?");
796 return 0; 781 return 0;
797 } 782 }
798 783
799 /* Given the new outdoor maps, can't let players dimension door for 784 /* Given the new outdoor maps, can't let players dimension door for
800 * ever, so put limits in. 785 * ever, so put limits in.
… …
805 { 790 {
806 int count = atoi (spellparam); 791 int count = atoi (spellparam);
807 792
808 if (count > maxdist) 793 if (count > maxdist)
809 { 794 {
810 new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!"); 795 op->failmsg ("You can't dimension door that far!");
811 return 0; 796 return 0;
812 } 797 }
813 798
814 for (dist = 0; dist < count; dist++) 799 for (dist = 0; dist < count; dist++)
815 { 800 {
816 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy); 801 mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * (dist + 1), op->y + DIRY (dir) * (dist + 1), &sx, &sy);
817 802
818 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP)) 803 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
819 break; 804 break;
820 805
821 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 806 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
… …
834 * by such squares). Also, there are probably treasure rooms and 819 * by such squares). Also, there are probably treasure rooms and
835 * lots of other maps that protect areas with no magic, but the 820 * lots of other maps that protect areas with no magic, but the
836 * areas themselves don't contain no magic spaces. 821 * areas themselves don't contain no magic spaces.
837 */ 822 */
838 /* This call here is really just to normalize the coordinates */ 823 /* This call here is really just to normalize the coordinates */
839 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, &sx, &sy); 824 mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist, &sx, &sy);
840 if (mflags & P_IS_ALIVE || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 825 if (mflags & P_IS_ALIVE || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
841 { 826 {
842 new_draw_info (NDI_UNIQUE, 0, op, "You cast your spell, but nothing happens.\n"); 827 new_draw_info (NDI_UNIQUE, 0, op, "You cast your spell, but nothing happens.\n");
843 return 1; /* Maybe the penalty should be more severe... */ 828 return 1; /* Maybe the penalty should be more severe... */
844 } 829 }
… …
850 * spaces that blocked the players view. 835 * spaces that blocked the players view.
851 */ 836 */
852 837
853 for (dist = 0; dist < maxdist; dist++) 838 for (dist = 0; dist < maxdist; dist++)
854 { 839 {
855 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy); 840 mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * (dist + 1), op->y + DIRY (dir) * (dist + 1), &sx, &sy);
856 841
857 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP)) 842 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
858 break; 843 break;
859 844
860 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 845 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
… …
865 /* If the destination is blocked, keep backing up until we 850 /* If the destination is blocked, keep backing up until we
866 * find a place for the player. 851 * find a place for the player.
867 */ 852 */
868 for (; dist > 0; dist--) 853 for (; dist > 0; dist--)
869 { 854 {
870 if (get_map_flags (op->map, &m, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, 855 if (get_map_flags (op->map, &m, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist,
871 &sx, &sy) & (P_OUT_OF_MAP | P_IS_ALIVE)) 856 &sx, &sy) & (P_OUT_OF_MAP | P_IS_ALIVE))
872 continue; 857 continue;
873 858
874 859
875 if (!OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 860 if (!OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
876 break; 861 break;
877 862
878 } 863 }
879 if (!dist) 864 if (!dist)
880 { 865 {
881 new_draw_info (NDI_UNIQUE, 0, op, "Your spell failed!\n"); 866 op->failmsg ("Your spell failed!\n");
882 return 0; 867 return 0;
883 } 868 }
884 } 869 }
885 870
886 /* Actually move the player now */ 871 /* Actually move the player now */
887 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op))) 872 if (!(op = op->map->insert (op, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist, op)))
888 return 1; 873 return 1;
889 874
890 op->speed_left = -5. * op->speed; /* Freeze them for a short while */ 875 op->speed_left = -5. * op->speed; /* Freeze them for a short while */
891 876
892 return 1; 877 return 1;
… …
1002 tmp->stats.grace = tmp->stats.maxgrace; 987 tmp->stats.grace = tmp->stats.maxgrace;
1003 success = 1; 988 success = 1;
1004 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!"); 989 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1005 } 990 }
1006 991
1007 if (spell->stats.food && tmp->stats.food < 999) 992 if (spell->stats.food && tmp->stats.food < MAX_FOOD)
1008 { 993 {
1009 tmp->stats.food += spell->stats.food; 994 tmp->stats.food += spell->stats.food;
1010 995 min_it (tmp->stats.food, MAX_FOOD);
1011 if (tmp->stats.food > 999)
1012 tmp->stats.food = 999;
1013 996
1014 success = 1; 997 success = 1;
1015 /* We could do something a bit better like the messages for healing above */ 998 /* 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"); 999 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1017 } 1000 }
… …
1064 break; 1047 break;
1065 } 1048 }
1066 else if (spell_ob->race && spell_ob->race == tmp2->name) 1049 else if (spell_ob->race && spell_ob->race == tmp2->name)
1067 { 1050 {
1068 if (!silent) 1051 if (!silent)
1069 new_draw_info_format (NDI_UNIQUE, 0, op,
1070 "You can not cast %s while %s is in effect", 1052 op->failmsgf ("You can not cast %s while %s is in effect",
1071 &spell_ob->name, &tmp2->name_pl); 1053 &spell_ob->name, &tmp2->name_pl);
1072 1054
1073 return 0; 1055 return 0;
1074 } 1056 }
1075 } 1057 }
1076 } 1058 }
… …
1092 1074
1093 new_draw_info_format (NDI_UNIQUE, 0, op, 1075 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.>", 1076 "You create an aura of magical force. H<The effect will last for about %.10g seconds.>",
1095 TICK2TIME (duration)); 1077 TICK2TIME (duration));
1096 1078
1097 force = get_archetype (FORCE_NAME); 1079 force = archetype::get (FORCE_NAME);
1098 force->subtype = FORCE_CHANGE_ABILITY; 1080 force->subtype = FORCE_CHANGE_ABILITY;
1099 force->duration = duration; 1081 force->duration = duration;
1100 1082
1101 if (spell_ob->race) 1083 if (spell_ob->race)
1102 force->name = spell_ob->race; 1084 force->name = spell_ob->race;
… …
1105 1087
1106 force->name_pl = spell_ob->name; 1088 force->name_pl = spell_ob->name;
1107 1089
1108 force->speed = 1.0; 1090 force->speed = 1.0;
1109 force->speed_left = -1.0; 1091 force->speed_left = -1.0;
1110 SET_FLAG (force, FLAG_APPLIED); 1092 force->set_flag (FLAG_APPLIED);
1111 1093
1112 /* Now start processing the effects. First, protections */ 1094 /* Now start processing the effects. First, protections */
1113 for (i = 0; i < NROFATTACKS; i++) 1095 for (i = 0; i < NROFATTACKS; i++)
1114 {
1115 if (spell_ob->resist[i]) 1096 if (spell_ob->resist[i])
1116 {
1117 force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob); 1097 force->resist[i] = min (100, spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob));
1118 if (force->resist[i] > 100)
1119 force->resist[i] = 100;
1120 }
1121 }
1122 1098
1123 if (spell_ob->stats.hp) 1099 if (spell_ob->stats.hp)
1124 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob); 1100 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1125 1101
1126 if (tmp->type == PLAYER) 1102 if (tmp->type == PLAYER)
… …
1145 } 1121 }
1146 } 1122 }
1147 1123
1148 force->move_type = spell_ob->move_type; 1124 force->move_type = spell_ob->move_type;
1149 1125
1150 if (QUERY_FLAG (spell_ob, FLAG_SEE_IN_DARK)) 1126 if (spell_ob->flag [FLAG_SEE_IN_DARK])
1151 SET_FLAG (force, FLAG_SEE_IN_DARK); 1127 force->set_flag (FLAG_SEE_IN_DARK);
1152 1128
1153 if (QUERY_FLAG (spell_ob, FLAG_XRAYS)) 1129 if (spell_ob->flag [FLAG_XRAYS])
1154 SET_FLAG (force, FLAG_XRAYS); 1130 force->set_flag (FLAG_XRAYS);
1155 1131
1156 /* Haste/bonus speed */ 1132 /* Haste/bonus speed */
1157 if (spell_ob->stats.exp) 1133 if (spell_ob->stats.exp)
1158 { 1134 {
1159 if (op->speed > 0.5f) 1135 if (op->speed > 0.5f)
… …
1212 } 1188 }
1213 } 1189 }
1214 1190
1215 if (force == NULL) 1191 if (force == NULL)
1216 { 1192 {
1217 force = get_archetype (FORCE_NAME); 1193 force = archetype::get (FORCE_NAME);
1218 force->subtype = FORCE_CHANGE_ABILITY; 1194 force->subtype = FORCE_CHANGE_ABILITY;
1219 if (spell_ob->race) 1195 if (spell_ob->race)
1220 force->name = spell_ob->race; 1196 force->name = spell_ob->race;
1221 else 1197 else
1222 force->name = spell_ob->name; 1198 force->name = spell_ob->name;
… …
1237 { 1213 {
1238 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1214 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1239 } 1215 }
1240 return 0; 1216 return 0;
1241 } 1217 }
1218
1242 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1219 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1243 force->speed = 1.0; 1220 force->speed = 1.0;
1244 force->speed_left = -1.0; 1221 force->speed_left = -1.0;
1245 SET_FLAG (force, FLAG_APPLIED); 1222 force->set_flag (FLAG_APPLIED);
1246 1223
1247 if (!god) 1224 if (!god)
1248 { 1225 {
1249 new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty."); 1226 new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty.");
1250 } 1227 }
… …
1282 1259
1283/* Alchemy code by Mark Wedel 1260/* Alchemy code by Mark Wedel
1284 * 1261 *
1285 * This code adds a new spell, called alchemy. Alchemy will turn 1262 * This code adds a new spell, called alchemy. Alchemy will turn
1286 * objects to pyrite ("false gold"), henceforth called gold nuggets. 1263 * objects to pyrite ("false gold"), henceforth called gold nuggets.
1287 * 1264 *
1288 * The value of the gold nuggets being about 90% of that of the item 1265 * The value of the gold nuggets being about 90% of that of the item
1289 * itself. It uses the value of the object before charisma adjustments, 1266 * itself. It uses the value of the object before charisma adjustments,
1290 * because the nuggets themselves will be will be adjusted by charisma 1267 * because the nuggets themselves will be will be adjusted by charisma
1291 * when sold. 1268 * when sold.
1292 * 1269 *
… …
1304 * the nuggets, alchemy the gold from that, etc. 1281 * the nuggets, alchemy the gold from that, etc.
1305 * Otherwise, give 9 silver on the gold for other objects, 1282 * Otherwise, give 9 silver on the gold for other objects,
1306 * so that it would still be more affordable to haul 1283 * so that it would still be more affordable to haul
1307 * the stuff back to town. 1284 * the stuff back to town.
1308 */ 1285 */
1309 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1286 if (obj->flag [FLAG_UNPAID])
1310 value = 0; 1287 value = 0;
1311 else if (obj->type == MONEY || obj->type == GEM) 1288 else if (obj->type == MONEY || obj->type == GEM)
1312 value /= 3; 1289 value /= 3;
1313 else 1290 else
1314 value = value * 9 / 10; 1291 value = value * 9 / 10;
… …
1368 1345
1369 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next) 1346 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1370 { 1347 {
1371 next = tmp->above; 1348 next = tmp->above;
1372 1349
1373 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1350 if (tmp->weight > 0 && !tmp->flag [FLAG_NO_PICK] &&
1374 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1351 !tmp->flag [FLAG_ALIVE] && !tmp->flag [FLAG_IS_CAULDRON])
1375 { 1352 {
1376 if (tmp->inv) 1353 if (tmp->inv)
1377 { 1354 {
1378 object *next1, *tmp1; 1355 object *next1, *tmp1;
1379 1356
1380 for (tmp1 = tmp->inv; tmp1; tmp1 = next1) 1357 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1381 { 1358 {
1382 next1 = tmp1->below; 1359 next1 = tmp1->below;
1383 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1360 if (tmp1->weight > 0 && !tmp1->flag [FLAG_NO_PICK] &&
1384 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1361 !tmp1->flag [FLAG_ALIVE] && !tmp1->flag [FLAG_IS_CAULDRON])
1385 alchemy_object (tmp1, value, weight); 1362 alchemy_object (tmp1, value, weight);
1386 } 1363 }
1387 } 1364 }
1388 1365
1389 alchemy_object (tmp, value, weight); 1366 alchemy_object (tmp, value, weight);
… …
1394 } 1371 }
1395 1372
1396 value -= rndm (value >> 4); 1373 value -= rndm (value >> 4);
1397 value = min (value, value_max); 1374 value = min (value, value_max);
1398 1375
1399 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i) 1376 for (int i = 0; i < array_length (nugget); ++i)
1400 if (int nrof = value / nugget [i]->value) 1377 if (int nrof = value / nugget [i]->value)
1401 { 1378 {
1402 value -= nrof * nugget[i]->value; 1379 value -= nrof * nugget[i]->value;
1403 1380
1404 object *tmp = nugget[i]->instance (); 1381 object *tmp = nugget[i]->instance ();
… …
1422int 1399int
1423remove_curse (object *op, object *caster, object *spell) 1400remove_curse (object *op, object *caster, object *spell)
1424{ 1401{
1425 int success = 0, was_one = 0; 1402 int success = 0, was_one = 0;
1426 1403
1404 int num_uncurse = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1405
1406 op->splay_marked ();
1407
1408 int typeflag = spell->last_sp ? FLAG_DAMNED : FLAG_CURSED;
1409
1427 for (object *tmp = op->inv; tmp; tmp = tmp->below) 1410 for (object *tmp = op->inv; tmp && num_uncurse; tmp = tmp->below)
1428 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1411 if (!tmp->invisible && tmp->flag [typeflag])
1429 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1430 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1431 { 1412 {
1432 was_one++; 1413 ++was_one;
1433 1414
1434 if (tmp->level <= casting_level (caster, spell)) 1415 if (tmp->level <= casting_level (caster, spell))
1435 { 1416 {
1436 success++; 1417 ++success;
1437 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1418 --num_uncurse;
1438 CLEAR_FLAG (tmp, FLAG_DAMNED);
1439 1419
1440 CLEAR_FLAG (tmp, FLAG_CURSED); 1420 tmp->clr_flag (typeflag);
1441 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED); 1421 tmp->clr_flag (FLAG_CURSED);
1422 tmp->clr_flag (FLAG_KNOWN_CURSED);
1442 tmp->value = 0; /* Still can't sell it */ 1423 tmp->value = 0; /* Still can't sell it */
1443 1424
1444 if (object *pl = tmp->visible_to ()) 1425 if (object *pl = tmp->visible_to ())
1445 esrv_update_item (UPD_FLAGS, pl, tmp); 1426 esrv_update_item (UPD_FLAGS, pl, tmp);
1446 } 1427 }
1447 } 1428 }
1448 1429
1449 if (op->type == PLAYER) 1430 if (op->type == PLAYER)
1450 { 1431 {
1451 if (success) 1432 if (success)
1452 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now."); 1433 new_draw_info (NDI_UNIQUE, 0, op, "You realise that some of your items look shinier now. H<You successfully removed some curses.>");
1453 else 1434 else
1454 { 1435 {
1455 if (was_one) 1436 if (was_one)
1456 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse."); 1437 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove any curse. H<The spell was not strong enough.>");
1457 else 1438 else
1458 new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items."); 1439 new_draw_info (NDI_UNIQUE, 0, op, "You are not having any cursed items. H<Epic fail.>");
1459 } 1440 }
1460 } 1441 }
1461 1442
1462 return success; 1443 return success;
1463} 1444}
1464 1445
1465/* Identifies objects in the players inventory/on the ground */ 1446/* Identifies objects in the players inventory/on the ground */
1466int 1447int
1467cast_identify (object *op, object *caster, object *spell) 1448cast_identify (object *op, object *caster, object *spell)
1468{ 1449{
1469 object *tmp;
1470 dynbuf_text &buf = msg_dynbuf; buf.clear (); 1450 dynbuf_text &buf = msg_dynbuf; buf.clear ();
1471 1451
1472 int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell)); 1452 int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1473 1453
1454 op->splay_marked ();
1455
1474 for (tmp = op->inv; tmp; tmp = tmp->below) 1456 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1475 { 1457 {
1476 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1458 if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
1477 { 1459 {
1478 identify (tmp); 1460 identify (tmp);
1479 1461
1480 if (op->type == PLAYER) 1462 if (op->type == PLAYER)
1481 { 1463 {
… …
1494 * stuff on the floor. Only identify stuff on the floor if the spell 1476 * stuff on the floor. Only identify stuff on the floor if the spell
1495 * was not fully used. 1477 * was not fully used.
1496 */ 1478 */
1497 if (num_ident) 1479 if (num_ident)
1498 { 1480 {
1499 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above) 1481 for (object *tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1500 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1482 if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
1501 { 1483 {
1502 identify (tmp); 1484 identify (tmp);
1503 1485
1504 if (object *pl = tmp->visible_to ()) 1486 if (object *pl = tmp->visible_to ())
1505 { 1487 {
… …
1531 1513
1532int 1514int
1533cast_detection (object *op, object *caster, object *spell, object *skill) 1515cast_detection (object *op, object *caster, object *spell, object *skill)
1534{ 1516{
1535 object *tmp, *last, *god, *detect; 1517 object *tmp, *last, *god, *detect;
1536 int done_one, range, mflags, floor, level; 1518 int done_one, range, floor, level;
1537 sint16 x, y, nx, ny; 1519 sint16 x, y, nx, ny;
1538 maptile *m; 1520 maptile *m;
1539 1521
1540 /* We precompute some values here so that we don't have to keep 1522 /* We precompute some values here so that we don't have to keep
1541 * doing it over and over again. 1523 * doing it over and over again.
… …
1554 * floor. But this is not true for show invisible. 1536 * floor. But this is not true for show invisible.
1555 * Basically, we just go and find the top object and work 1537 * Basically, we just go and find the top object and work
1556 * down - that is easier than working up. 1538 * down - that is easier than working up.
1557 */ 1539 */
1558 1540
1559 for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above) 1541 for (last = 0, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1560 last = tmp; 1542 last = tmp;
1561 1543
1562 /* Shouldn't happen, but if there are no objects on a space, this 1544 /* Shouldn't happen, but if there are no objects on a space, this
1563 * would happen. 1545 * would happen.
1564 */ 1546 */
1565 if (!last) 1547 if (!last)
1566 continue; 1548 continue;
1567 1549
1568 done_one = 0; 1550 done_one = 0;
1569 floor = 0; 1551 floor = 0;
1570 detect = NULL; 1552 detect = 0;
1571 for (tmp = last; tmp; tmp = tmp->below) 1553 for (tmp = last; tmp; tmp = tmp->below)
1572 { 1554 {
1573 /* show invisible */ 1555 /* show invisible */
1574 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1556 if (spell->flag [FLAG_MAKE_INVIS]
1575 /* Might there be other objects that we can make visible? */ 1557 /* Might there be other objects that we can make visible? */
1576 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) 1558 && (tmp->invisible && (tmp->flag [FLAG_MONSTER]
1577 || (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) 1559 || (tmp->type == PLAYER && !tmp->flag [FLAG_WIZ])
1578 || tmp->type == T_HANDLE 1560 || tmp->type == T_HANDLE
1579 || tmp->type == TRAPDOOR 1561 || tmp->type == TRAPDOOR
1580 || tmp->type == EXIT 1562 || tmp->type == EXIT
1581 || tmp->type == HOLE 1563 || tmp->type == HOLE
1582 || tmp->type == BUTTON 1564 || tmp->type == BUTTON
1583 || tmp->type == TELEPORTER 1565 || tmp->type == TELEPORTER
1584 || tmp->type == GATE 1566 || tmp->type == GATE
1585 || tmp->type == LOCKED_DOOR 1567 || tmp->type == LOCKED_DOOR
1586 || tmp->type == WEAPON 1568 || tmp->type == WEAPON
1587 || tmp->type == ALTAR 1569 || tmp->type == ALTAR
1588 || tmp->type == SIGN 1570 || (tmp->type == SIGN && tmp->face != magicmouth_face)
1589 || tmp->type == TRIGGER_PEDESTAL 1571 || tmp->type == TRIGGER_PEDESTAL
1590 || tmp->type == SPECIAL_KEY 1572 || tmp->type == SPECIAL_KEY
1591 || tmp->type == TREASURE 1573 || tmp->type == TREASURE
1592 || tmp->type == BOOK 1574 || tmp->type == BOOK
1593 || tmp->type == HOLY_ALTAR 1575 || tmp->type == HOLY_ALTAR
1594 || tmp->type == CONTAINER))) 1576 || tmp->type == CONTAINER)))
1595 { 1577 {
1578 printf ("show inv %s\n", tmp->debug_desc());//D
1596 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4) 1579 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1597 { 1580 {
1598 tmp->invisible = 0; 1581 tmp->invisible = 0;
1599 done_one = 1; 1582 done_one = 1;
1600 } 1583 }
1601 } 1584 }
1602 1585
1603 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1586 if (tmp->flag [FLAG_IS_FLOOR])
1604 floor = 1; 1587 floor = 1;
1605 1588
1606 /* All detections below this point don't descend beneath the floor, 1589 /* All detections below this point don't descend beneath the floor,
1607 * so just continue on. We could be clever and look at the type of 1590 * so just continue on. We could be clever and look at the type of
1608 * detection to completely break out if we don't care about objects beneath 1591 * detection to completely break out if we don't care about objects beneath
… …
1617 * difficult to see what object is magical/cursed, so the 1600 * difficult to see what object is magical/cursed, so the
1618 * effect wouldn't be as apparent. 1601 * effect wouldn't be as apparent.
1619 */ 1602 */
1620 1603
1621 /* detect magic */ 1604 /* detect magic */
1622 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && 1605 if (spell->flag [FLAG_KNOWN_MAGICAL]
1623 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp)) 1606 && !tmp->flag [FLAG_KNOWN_MAGICAL]
1607 && !tmp->flag [FLAG_IDENTIFIED]
1608 && tmp->need_identify ()
1609 && is_magical (tmp))
1624 { 1610 {
1625 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1611 tmp->set_flag (FLAG_KNOWN_MAGICAL);
1626 /* make runes more visibile */ 1612 /* make runes more visible */
1627 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC) 1613 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1628 tmp->stats.Cha /= 4; 1614 tmp->stats.Cha /= 4;
1629 1615
1630 done_one = 1; 1616 done_one = 1;
1631 } 1617 }
1632 1618
1633 /* detect monster */ 1619 /* detect monster */
1634 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER)) 1620 if (spell->flag [FLAG_MONSTER] && (tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER))
1635 { 1621 {
1636 done_one = 2; 1622 done_one = 2;
1637 1623
1638 if (!detect) 1624 if (!detect)
1639 detect = tmp; 1625 detect = tmp;
… …
1641 1627
1642 /* Basically, if race is set in the spell, then the creatures race must 1628 /* Basically, if race is set in the spell, then the creatures race must
1643 * match that. if the spell race is set to GOD, then the gods opposing 1629 * match that. if the spell race is set to GOD, then the gods opposing
1644 * race must match. 1630 * race must match.
1645 */ 1631 */
1646 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race && 1632 if (spell->race && tmp->flag [FLAG_MONSTER] && tmp->race &&
1647 ((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) || 1633 ((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1648 spell->race.contains (tmp->race))) 1634 spell->race.contains (tmp->race)))
1649 { 1635 {
1650 done_one = 2; 1636 done_one = 2;
1651 1637
1652 if (!detect) 1638 if (!detect)
1653 detect = tmp; 1639 detect = tmp;
1654 } 1640 }
1655 1641
1656 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1642 if (spell->flag [FLAG_KNOWN_CURSED]
1657 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1643 && !tmp->flag [FLAG_KNOWN_CURSED]
1644 && tmp->need_identify ()
1645 && (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1658 { 1646 {
1659 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1647 tmp->set_flag (FLAG_KNOWN_CURSED);
1660 done_one = 1; 1648 done_one = 1;
1649 }
1650
1651 // Do mining detection spell:
1652 if (spell->last_sp == 1) // 1 - detect any vein
1653 {
1654 if (tmp->type == VEIN)
1655 {
1656 if (tmp->other_arch)
1657 {
1658 if (!detect)
1659 detect = tmp->other_arch;
1660 done_one = 2;
1661 }
1662 else
1663 done_one = 1;
1664 }
1661 } 1665 }
1662 } /* for stack of objects on this space */ 1666 } /* for stack of objects on this space */
1663 1667
1664 /* Code here puts an effect of the spell on the space, so you can see 1668 /* Code here puts an effect of the spell on the space, so you can see
1665 * where the magic is. 1669 * where the magic is.
… …
1674 detect_ob->face = detect->face; 1678 detect_ob->face = detect->face;
1675 detect_ob->animation_id = detect->animation_id; 1679 detect_ob->animation_id = detect->animation_id;
1676 detect_ob->anim_speed = detect->anim_speed; 1680 detect_ob->anim_speed = detect->anim_speed;
1677 detect_ob->last_anim = 0; 1681 detect_ob->last_anim = 0;
1678 /* by default, the detect_ob is already animated */ 1682 /* by default, the detect_ob is already animated */
1679 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1683 if (!detect->flag [FLAG_ANIMATE])
1680 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1684 detect_ob->clr_flag (FLAG_ANIMATE);
1681 } 1685 }
1682 1686
1683 m->insert (detect_ob, nx, ny, op); 1687 m->insert (detect_ob, nx, ny, op, INS_ON_TOP);
1684 } 1688 }
1685 } /* for processing the surrounding spaces */ 1689 } /* for processing the surrounding spaces */
1686 1690
1687 1691
1688 /* Now process objects in the players inventory if detect curse or magic */ 1692 /* Now process objects in the players inventory if detect curse or magic */
1689 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL)) 1693 if (spell->flag [FLAG_KNOWN_CURSED] || spell->flag [FLAG_KNOWN_MAGICAL])
1690 { 1694 {
1691 done_one = 0; 1695 done_one = 0;
1692 1696
1693 for (tmp = op->inv; tmp; tmp = tmp->below) 1697 for (tmp = op->inv; tmp; tmp = tmp->below)
1694 { 1698 {
1695 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1699 if (!tmp->invisible && !tmp->flag [FLAG_IDENTIFIED])
1696 { 1700 {
1697 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL)) 1701 if (spell->flag [FLAG_KNOWN_MAGICAL] && is_magical (tmp) && !tmp->flag [FLAG_KNOWN_MAGICAL])
1698 { 1702 {
1699 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1703 tmp->set_flag (FLAG_KNOWN_MAGICAL);
1700 1704
1701 if (object *pl = tmp->visible_to ()) 1705 if (object *pl = tmp->visible_to ())
1702 esrv_update_item (UPD_FLAGS, pl, tmp); 1706 esrv_update_item (UPD_FLAGS, pl, tmp);
1703 } 1707 }
1704 1708
1705 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1709 if (spell->flag [FLAG_KNOWN_CURSED] && !tmp->flag [FLAG_KNOWN_CURSED] &&
1706 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1710 (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1707 { 1711 {
1708 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1712 tmp->set_flag (FLAG_KNOWN_CURSED);
1709 1713
1710 if (object *pl = tmp->visible_to ()) 1714 if (object *pl = tmp->visible_to ())
1711 esrv_update_item (UPD_FLAGS, pl, tmp); 1715 esrv_update_item (UPD_FLAGS, pl, tmp);
1712 } 1716 }
1713 } /* if item is not identified */ 1717 } /* if item is not identified */
… …
1765 sint16 x, y; 1769 sint16 x, y;
1766 maptile *m; 1770 maptile *m;
1767 int mflags; 1771 int mflags;
1768 1772
1769 m = op->map; 1773 m = op->map;
1770 x = op->x + freearr_x[dir]; 1774 x = op->x + DIRX (dir);
1771 y = op->y + freearr_y[dir]; 1775 y = op->y + DIRY (dir);
1772 1776
1773 mflags = get_map_flags (m, &m, x, y, &x, &y); 1777 mflags = get_map_flags (m, &m, x, y, &x, &y);
1774 1778
1775 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 1779 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
1776 { 1780 {
1777 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above) 1781 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
1778 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 1782 if (plyr != op && plyr->flag [FLAG_ALIVE])
1779 break; 1783 break;
1780 } 1784 }
1781 1785
1782 1786
1783 /* If we did not find a player in the specified direction, transfer 1787 /* If we did not find a player in the specified direction, transfer
1784 * to anyone on top of us. This is used for the rune of transference mostly. 1788 * to anyone on top of us. This is used for the rune of transference mostly.
1785 */ 1789 */
1786 if (plyr == NULL) 1790 if (plyr == NULL)
1787 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above) 1791 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
1788 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 1792 if (plyr != op && plyr->flag [FLAG_ALIVE])
1789 break; 1793 break;
1790 1794
1791 if (!plyr) 1795 if (!plyr)
1792 { 1796 {
1793 new_draw_info (NDI_BLACK, 0, op, "There is no one there."); 1797 op->failmsg ("There is no one there.");
1794 return 0; 1798 return 0;
1795 } 1799 }
1796 /* give sp */ 1800 /* give sp */
1797 if (spell->stats.dam > 0) 1801 if (spell->stats.dam > 0)
1798 { 1802 {
… …
1810 if (rate > 95) 1814 if (rate > 95)
1811 rate = 95; 1815 rate = 95;
1812 1816
1813 sucked = (plyr->stats.sp * rate) / 100; 1817 sucked = (plyr->stats.sp * rate) / 100;
1814 plyr->stats.sp -= sucked; 1818 plyr->stats.sp -= sucked;
1815 if (QUERY_FLAG (op, FLAG_ALIVE)) 1819 if (op->flag [FLAG_ALIVE])
1816 { 1820 {
1817 /* Player doesn't get full credit */ 1821 /* Player doesn't get full credit */
1818 sucked = (sucked * rate) / 100; 1822 sucked = (sucked * rate) / 100;
1819 op->stats.sp += sucked; 1823 op->stats.sp += sucked;
1820 if (sucked > 0) 1824 if (sucked > 0)
… …
1840 object *tmp, *head, *next; 1844 object *tmp, *head, *next;
1841 int mflags; 1845 int mflags;
1842 maptile *m; 1846 maptile *m;
1843 sint16 sx, sy; 1847 sint16 sx, sy;
1844 1848
1845 sx = op->x + freearr_x[dir]; 1849 sx = op->x + DIRX (dir);
1846 sy = op->y + freearr_y[dir]; 1850 sy = op->y + DIRY (dir);
1847 m = op->map; 1851 m = op->map;
1848 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 1852 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1849 if (mflags & P_OUT_OF_MAP) 1853 if (mflags & P_OUT_OF_MAP)
1850 return; 1854 return;
1851 1855
… …
1864 1868
1865 /* don't attack our own spells */ 1869 /* don't attack our own spells */
1866 if (tmp->owner && tmp->owner == op->owner) 1870 if (tmp->owner && tmp->owner == op->owner)
1867 continue; 1871 continue;
1868 1872
1869 /* Basically, if the object is magical and not counterspell, 1873 /* Basically, if the object is magical and not counterspell,
1870 * we will more or less remove the object. Don't counterspell 1874 * we will more or less remove the object. Don't counterspell
1871 * monsters either. 1875 * monsters either.
1872 */ 1876 */
1873 1877
1874 if (head->attacktype & AT_MAGIC 1878 if (head->attacktype & AT_MAGIC
1875 && !(head->attacktype & AT_COUNTERSPELL) 1879 && !(head->attacktype & AT_COUNTERSPELL)
1876 && !QUERY_FLAG (head, FLAG_MONSTER) 1880 && !head->flag [FLAG_MONSTER]
1877 && (op->level > head->level)) 1881 && (op->level > head->level))
1878 head->destroy (); 1882 head->destroy ();
1879 else 1883 else
1880 switch (head->type) 1884 switch (head->type)
1881 { 1885 {
1882 case SPELL_EFFECT: 1886 case SPELL_EFFECT:
1883 // XXX: Don't affect floor spelleffects. See also XXX comment 1887 // XXX: Don't affect floor spelleffects. See also XXX comment
1884 // about sanctuary in spell_util.C 1888 // about sanctuary in spell_util.C
1885 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1889 if (tmp->flag [FLAG_IS_FLOOR])
1886 continue; 1890 continue;
1887 1891
1888 if (op->level > head->level) 1892 if (op->level > head->level)
1889 head->destroy (); 1893 head->destroy ();
1890 1894
… …
1913 1917
1914 object *tmp, *god = find_god (determine_god (op)); 1918 object *tmp, *god = find_god (determine_god (op));
1915 1919
1916 if (!god) 1920 if (!god)
1917 { 1921 {
1918 new_draw_info (NDI_UNIQUE, 0, op, "You can't consecrate anything if you don't worship a god!"); 1922 op->failmsg ("You can't consecrate anything if you don't worship a god!");
1919 return 0; 1923 return 0;
1920 } 1924 }
1921 1925
1922 for (tmp = op->below; tmp; tmp = tmp->below) 1926 for (tmp = op->below; tmp; tmp = tmp->below)
1923 { 1927 {
1924 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1928 if (tmp->flag [FLAG_IS_FLOOR])
1925 break; 1929 break;
1926 if (tmp->type == HOLY_ALTAR) 1930 if (tmp->type == HOLY_ALTAR)
1927 { 1931 {
1928 1932
1929 if (tmp->level > casting_level (caster, spell)) 1933 if (tmp->level > casting_level (caster, spell))
1930 { 1934 {
1931 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name); 1935 op->failmsgf ("You are not powerful enough to reconsecrate the %s", &tmp->name);
1932 return 0; 1936 return 0;
1933 } 1937 }
1934 else 1938 else
1935 { 1939 {
1936 /* If we got here, we are consecrating an altar */ 1940 /* If we got here, we are consecrating an altar */
… …
1945 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name); 1949 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1946 return 1; 1950 return 1;
1947 } 1951 }
1948 } 1952 }
1949 } 1953 }
1950 new_draw_info (NDI_UNIQUE, 0, op, "You are not standing over an altar!"); 1954
1955 op->failmsg ("You are not standing over an altar!");
1951 return 0; 1956 return 0;
1952} 1957}
1953 1958
1954/* animate_weapon - 1959/* animate_weapon -
1955 * Generalization of staff_to_snake. Makes a golem out of the caster's weapon. 1960 * Generalization of staff_to_snake. Makes a golem out of the caster's weapon.
1956 * The golem is based on the archetype specified, modified by the caster's level 1961 * The golem is based on the archetype specified, modified by the caster's level
1957 * and the attributes of the weapon. The weapon is inserted in the golem's 1962 * and the attributes of the weapon. The weapon is inserted in the golem's
1958 * inventory so that it falls to the ground when the golem dies. 1963 * inventory so that it falls to the ground when the golem dies.
1959 * This code was very odd - code early on would only let players use the spell, 1964 * This code was very odd - code early on would only let players use the spell,
1960 * yet the code wass full of player checks. I've presumed that the code 1965 * yet the code wass full of player checks. I've presumed that the code
1961 * that only let players use it was correct, and removed all the other 1966 * that only let players use it was correct, and removed all the other
1962 * player checks. MSW 2003-01-06 1967 * player checks. MSW 2003-01-06
1963 */ 1968 */
1964int 1969int
1965animate_weapon (object *op, object *caster, object *spell, int dir) 1970animate_weapon (object *op, object *caster, object *spell, int dir)
1966{ 1971{
1967 object *weapon, *tmp;
1968 char buf[MAX_BUF]; 1972 char buf[MAX_BUF];
1969 int a, i; 1973 int a, i;
1970 sint16 x, y; 1974 sint16 x, y;
1971 maptile *m; 1975 maptile *m;
1972 1976
… …
1990 /* if no direction specified, pick one */ 1994 /* if no direction specified, pick one */
1991 if (!dir) 1995 if (!dir)
1992 dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9); 1996 dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
1993 1997
1994 m = op->map; 1998 m = op->map;
1995 x = op->x + freearr_x[dir]; 1999 x = op->x + DIRX (dir);
1996 y = op->y + freearr_y[dir]; 2000 y = op->y + DIRY (dir);
1997 2001
1998 /* if there's no place to put the golem, abort */ 2002 /* if there's no place to put the golem, abort */
1999 if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) 2003 if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2000 || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type)) 2004 || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2001 { 2005 {
2002 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 2006 op->failmsg ("There is something in the way.");
2003 return 0; 2007 return 0;
2004 } 2008 }
2005 2009
2006 /* Use the weapon marked by the player. */ 2010 /* Use the weapon marked by the player. */
2007 weapon = find_marked_object (op); 2011 object *weapon = op->mark ();
2008 2012
2009 if (!weapon) 2013 if (!weapon)
2010 { 2014 {
2011 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 2015 op->failmsg ("You must mark a weapon to use with this spell!");
2012 return 0; 2016 return 0;
2013 } 2017 }
2014 2018
2015 if (spell->race && weapon->arch->archname != spell->race) 2019 if (spell->race && weapon->arch->archname != spell->race)
2016 { 2020 {
2017 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2021 op->failmsg ("The spell fails to transform your weapon.");
2018 return 0; 2022 return 0;
2019 } 2023 }
2020 2024
2021 if (weapon->type != WEAPON) 2025 if (weapon->type != WEAPON)
2022 { 2026 {
2023 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it."); 2027 op->failmsg ("You need to wield a weapon to animate it.");
2024 return 0; 2028 return 0;
2025 } 2029 }
2026 2030
2027 if (QUERY_FLAG (weapon, FLAG_APPLIED)) 2031 if (weapon->flag [FLAG_APPLIED])
2028 { 2032 {
2029 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon)); 2033 op->failmsgf ("You need to unequip %s before using it in this spell", query_name (weapon));
2030 return 0; 2034 return 0;
2031 } 2035 }
2032 2036
2033 weapon = weapon->split (); 2037 weapon = weapon->split ();
2034 2038
2035 /* create the golem object */ 2039 /* create the golem object */
2036 tmp = spell->other_arch->instance (); 2040 object *tmp = spell->other_arch->instance ();
2037 2041
2038 /* if animated by a player, give the player control of the golem */ 2042 /* if animated by a player, give the player control of the golem */
2039 CLEAR_FLAG (tmp, FLAG_MONSTER); 2043 tmp->clr_flag (FLAG_MONSTER);
2040 tmp->stats.exp = 0; 2044 tmp->stats.exp = 0;
2041 add_friendly_object (tmp); 2045 add_friendly_object (tmp);
2042 tmp->type = GOLEM; 2046 tmp->type = GOLEM;
2043 tmp->set_owner (op); 2047 tmp->set_owner (op);
2044 op->contr->golem = tmp; 2048 op->contr->golem = tmp;
… …
2046 2050
2047 /* Give the weapon to the golem now. A bit of a hack to check the 2051 /* Give the weapon to the golem now. A bit of a hack to check the
2048 * removed flag - it should only be set if weapon->split was 2052 * removed flag - it should only be set if weapon->split was
2049 * used above. 2053 * used above.
2050 */ 2054 */
2051 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2055 if (!weapon->flag [FLAG_REMOVED])
2052 weapon->remove (); 2056 weapon->remove ();
2053 2057
2054 tmp->insert (weapon); 2058 tmp->insert (weapon);
2055 2059
2056 /* To do everything necessary to let a golem use the weapon is a pain, 2060 /* To do everything necessary to let a golem use the weapon is a pain,
2057 * so instead, just set it as equipped (otherwise, we need to update 2061 * so instead, just set it as equipped (otherwise, we need to update
2058 * body_info, skills, etc) 2062 * body_info, skills, etc)
2059 */ 2063 */
2060 SET_FLAG (tmp, FLAG_USE_WEAPON); 2064 tmp->set_flag (FLAG_USE_WEAPON);
2061 SET_FLAG (weapon, FLAG_APPLIED); 2065 weapon->set_flag (FLAG_APPLIED);
2062 tmp->update_stats (); 2066 tmp->update_stats ();
2063 2067
2064 /* There used to be 'odd' code that basically seemed to take the absolute 2068 /* There used to be 'odd' code that basically seemed to take the absolute
2065 * value of the weapon->magic an use that. IMO, that doesn't make sense - 2069 * value of the weapon->magic an use that. IMO, that doesn't make sense -
2066 * if you're using a crappy weapon, it shouldn't be as good. 2070 * if you're using a crappy weapon, it shouldn't be as good.
… …
2107 /* Improve weapon's armour value according to best save vs. physical of its material */ 2111 /* Improve weapon's armour value according to best save vs. physical of its material */
2108 2112
2109 if (a > 14) 2113 if (a > 14)
2110 a = 14; 2114 a = 14;
2111 2115
2112 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2116 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.f - (float) tmp->resist[ATNR_PHYSICAL]) / (30.f - 2.f * a));
2113 2117
2114 /* Determine golem's speed */ 2118 /* Determine golem's speed */
2115 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell))); 2119 tmp->set_speed (min (3.33f, 0.4f + 0.1f * SP_level_range_adjust (caster, spell)));
2116 2120
2117 if (!spell->race) 2121 if (!spell->race)
2118 { 2122 {
2119 sprintf (buf, "animated %s", &weapon->name); 2123 sprintf (buf, "animated %s", &weapon->name);
2120 tmp->name = buf; 2124 tmp->name = buf;
… …
2153 success = op->map->change_map_light (spell->stats.dam); 2157 success = op->map->change_map_light (spell->stats.dam);
2154 2158
2155 if (!success) 2159 if (!success)
2156 { 2160 {
2157 if (spell->stats.dam < 0) 2161 if (spell->stats.dam < 0)
2158 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2162 op->failmsg ("It can be no brighter here.");
2159 else 2163 else
2160 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2164 op->failmsg ("It can be no darker here.");
2161 } 2165 }
2162 2166
2163 return success; 2167 return success;
2164} 2168}
2165 2169
… …
2201 2205
2202/* move aura function. An aura is a part of someone's inventory, 2206/* move aura function. An aura is a part of someone's inventory,
2203 * which he carries with him, but which acts on the map immediately 2207 * which he carries with him, but which acts on the map immediately
2204 * around him. 2208 * around him.
2205 * Aura parameters: 2209 * Aura parameters:
2206 * duration: duration counter. 2210 * duration: duration counter.
2207 * attacktype: aura's attacktype 2211 * attacktype: aura's attacktype
2208 * other_arch: archetype to drop where we attack 2212 * other_arch: archetype to drop where we attack
2209 */ 2213 */
2210void 2214void
2211move_aura (object *aura) 2215move_aura (object *aura)
2212{ 2216{
2213 /* auras belong in inventories */ 2217 /* auras belong in inventories */
2214 object *env = aura->env; 2218 object *env = aura->env;
2215 object *owner = aura->owner; 2219 object *owner = aura->owner;
2216 2220
2217 /* no matter what we've gotta remove the aura... 2221 /* no matter what we've gotta remove the aura...
2218 * we'll put it back if its time isn't up. 2222 * we'll put it back if its time isn't up.
2219 */ 2223 */
2220 aura->remove (); 2224 aura->remove ();
2221 2225
2222 /* exit if we're out of gas */ 2226 /* exit if we're out of gas */
2223 if (aura->duration-- < 0) 2227 if (aura->duration-- < 0)
… …
2232 aura->destroy (); 2236 aura->destroy ();
2233 return; 2237 return;
2234 } 2238 }
2235 2239
2236 /* we need to jump out of the inventory for a bit 2240 /* we need to jump out of the inventory for a bit
2237 * in order to hit the map conveniently. 2241 * in order to hit the map conveniently.
2238 */ 2242 */
2239 aura->insert_at (env, aura); 2243 aura->insert_at (env, aura);
2240 2244
2241 for (int i = 1; i < 9; i++) 2245 for (int i = 1; i < 9; i++)
2242 { 2246 {
… …
2270 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above) 2274 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2271 { 2275 {
2272 int atk_lev, def_lev; 2276 int atk_lev, def_lev;
2273 object *victim = tmp->head_ (); 2277 object *victim = tmp->head_ ();
2274 2278
2275 if (!QUERY_FLAG (victim, FLAG_MONSTER)) 2279 if (!victim->flag [FLAG_MONSTER])
2276 continue; 2280 continue;
2277 2281
2278 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE)) 2282 if (victim->flag [FLAG_UNAGGRESSIVE])
2279 continue; 2283 continue;
2280 2284
2281 if (victim->stats.exp == 0) 2285 if (victim->stats.exp == 0)
2282 continue; 2286 continue;
2283 2287
… …
2299 victim->stats.sp = 0; 2303 victim->stats.sp = 0;
2300 victim->stats.grace = 0; 2304 victim->stats.grace = 0;
2301 victim->stats.Pow = 0; 2305 victim->stats.Pow = 0;
2302#endif 2306#endif
2303 victim->attack_movement = RANDO2; 2307 victim->attack_movement = RANDO2;
2304 SET_FLAG (victim, FLAG_UNAGGRESSIVE); 2308 victim->set_flag (FLAG_UNAGGRESSIVE);
2305 SET_FLAG (victim, FLAG_RUN_AWAY); 2309 victim->set_flag (FLAG_RUN_AWAY);
2306 SET_FLAG (victim, FLAG_RANDOM_MOVE); 2310 victim->set_flag (FLAG_RANDOM_MOVE);
2307 CLEAR_FLAG (victim, FLAG_MONSTER); 2311 victim->clr_flag (FLAG_MONSTER);
2308 2312
2309 if (victim->name) 2313 if (victim->name)
2310 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name); 2314 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2311 } 2315 }
2312 } 2316 }
… …
2318int 2322int
2319write_mark (object *op, object *spell, const char *msg) 2323write_mark (object *op, object *spell, const char *msg)
2320{ 2324{
2321 if (!msg || msg[0] == 0) 2325 if (!msg || msg[0] == 0)
2322 { 2326 {
2323 new_draw_info (NDI_UNIQUE, 0, op, "Write what?"); 2327 op->failmsg ("Write what?");
2324 return 0; 2328 return 0;
2325 } 2329 }
2326 2330
2327 if (!msg_is_safe (msg)) 2331 if (!msg_is_safe (msg))
2328 { 2332 {
2329 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?"); 2333 op->failmsg ("Trying to cheat are we? H<@-signs are not allowed in marking runes.>");
2330 LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg); 2334 LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2331 return 0; 2335 return 0;
2332 } 2336 }
2333 2337
2334 if (!spell->other_arch) 2338 if (!spell->other_arch)

Diff Legend

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