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

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.11 by root, Sun Sep 10 15:59:58 2006 UTC vs.
Revision 1.42 by root, Mon Apr 30 04:25:30 2007 UTC

1
2/* 1/*
3 * static char *rcsid_spell_util_c =
4 * "$Id: spell_util.C,v 1.11 2006/09/10 15:59:58 root Exp $";
5 */
6
7
8/*
9 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game
10 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
11 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
12 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
13 7 *
14 This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version. 11 * (at your option) any later version.
18 12 *
19 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,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details. 16 * GNU General Public License for more details.
23 17 *
24 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
26 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 21 *
28 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
29*/ 23 */
30
31 24
32#include <global.h> 25#include <global.h>
33#include <spells.h> 26#include <spells.h>
34#include <object.h> 27#include <object.h>
35#include <errno.h> 28#include <errno.h>
36#ifndef __CEXTRACT__
37# include <sproto.h> 29#include <sproto.h>
38#endif
39#include <sounds.h> 30#include <sounds.h>
40 31
41extern char *spell_mapping[]; 32extern char *spell_mapping[];
42 33
43/* This returns a random spell from 'ob'. If skill is set, then 34/* This returns a random spell from 'ob'. If skill is set, then
… …
126 } 117 }
127 118
128 i = 0; 119 i = 0;
129 while (spell_mapping[i]) 120 while (spell_mapping[i])
130 { 121 {
131 if (!find_archetype (spell_mapping[i])) 122 if (!archetype::find (spell_mapping[i]))
132 { 123 {
133 LOG (llevError, "Unable to find spell mapping %s (%i)\n", spell_mapping[i], i); 124 LOG (llevError, "Unable to find spell mapping %s (%i)\n", spell_mapping[i], i);
134 } 125 }
135 i++; 126 i++;
136 } 127 }
… …
158} 149}
159 150
160/* pretty basic function - basically just takes 151/* pretty basic function - basically just takes
161 * an object, sets the x,y, and calls insert_ob_in_map 152 * an object, sets the x,y, and calls insert_ob_in_map
162 */ 153 */
163
164void 154void
165spell_effect (object *spob, int x, int y, mapstruct *map, object *originator) 155spell_effect (object *spob, int x, int y, maptile *map, object *originator)
166{ 156{
167
168 if (spob->other_arch != NULL) 157 if (spob->other_arch)
169 { 158 map->insert (arch_to_object (spob->other_arch), x, y, originator);
170 object *effect = arch_to_object (spob->other_arch);
171
172 effect->x = x;
173 effect->y = y;
174
175 insert_ob_in_map (effect, map, originator, 0);
176 }
177} 159}
178 160
179/* 161/*
180 * This function takes a caster and spell and presents the 162 * This function takes a caster and spell and presents the
181 * effective level the caster needs to be to cast the spell. 163 * effective level the caster needs to be to cast the spell.
182 * basically, it just adjusts the spell->level with attuned/repelled 164 * basically, it just adjusts the spell->level with attuned/repelled
183 * spellpaths. Was called path_level_mod 165 * spellpaths. Was called path_level_mod.
184 * 166 *
185 * caster is person casting hte spell. 167 * caster is person casting the spell.
186 * spell is the spell object. 168 * spell is the spell object.
187 * Returns modified level. 169 * Returns modified level.
188 */ 170 */
189int 171int
190min_casting_level (object *caster, object *spell) 172min_casting_level (object *caster, object *spell)
191{ 173{
192 int new_level; 174 int new_level;
193 175
194 if (caster->path_denied & spell->path_attuned) 176 if (caster->path_denied & spell->path_attuned)
195 {
196 /* This case is not a bug, just the fact that this function is
197 * usually called BEFORE checking for path_deny. -AV
198 */
199#if 0
200 LOG (llevError, "BUG: path_level_mod (arch %s, name %s): casting denied " "spell\n", caster->arch->name, caster->name);
201#endif
202 return 1; 177 return 1;
203 } 178
204 new_level = spell->level 179 new_level = spell->level
205 + ((caster->path_repelled & spell->path_attuned) ? +2 : 0) + ((caster->path_attuned & spell->path_attuned) ? -2 : 0); 180 + (caster->path_repelled & spell->path_attuned ? +2 : 0)
206 return (new_level < 1) ? 1 : new_level; 181 + (caster->path_attuned & spell->path_attuned ? -2 : 0);
207}
208 182
183 return max (1, new_level);
184}
209 185
210/* This function returns the effective level the spell 186/* This function returns the effective level the spell
211 * is being cast at. 187 * is being cast at.
212 * Note that I changed the repelled/attuned bonus to 2 from 5. 188 * Note that I changed the repelled/attuned bonus to 2 from 5.
213 * This is because the new code compares casting_level against 189 * This is because the new code compares casting_level against
214 * min_caster_level, so the difference is effectively 4 190 * min_caster_level, so the difference is effectively 4
215 */ 191 */
216
217int 192int
218caster_level (object *caster, object *spell) 193caster_level (object *caster, object *spell)
219{ 194{
220 int level = caster->level; 195 int level = caster->level;
221 196
222 /* If this is a player, try to find the matching skill */ 197 /* If this is a player, try to find the matching skill */
223 if (caster->type == PLAYER && spell->skill) 198 if (caster->type == PLAYER && spell->skill)
224 {
225 int i;
226
227 for (i = 0; i < NUM_SKILLS; i++) 199 for (int i = 0; i < NUM_SKILLS; i++)
228 if (caster->contr->last_skill_ob[i] && caster->contr->last_skill_ob[i]->skill == spell->skill) 200 if (caster->contr->last_skill_ob[i] && caster->contr->last_skill_ob[i]->skill == spell->skill)
229 { 201 {
230 level = caster->contr->last_skill_ob[i]->level; 202 level = caster->contr->last_skill_ob[i]->level;
231 break; 203 break;
232 } 204 }
233 }
234 205
235 /* if a rod is fired by a player, take the use_magic_item skill in consideration. */ 206 /* if a rod is fired by a player, take the use_magic_item skill in consideration. */
236 if (caster->type == ROD && caster->env && caster->env->type == PLAYER) 207 if (caster->type == ROD && caster->env && caster->env->type == PLAYER)
237 { 208 {
238 object *skill = find_skill_by_number (caster->env, SK_USE_MAGIC_ITEM); 209 object *skill = find_skill_by_number (caster->env, SK_USE_MAGIC_ITEM);
… …
240 211
241 level = MIN (level, sk_level + level / 10 + 1); 212 level = MIN (level, sk_level + level / 10 + 1);
242 } 213 }
243 214
244 /* Got valid caster level. Now adjust for attunement */ 215 /* Got valid caster level. Now adjust for attunement */
245 level += ((caster->path_repelled & spell->path_attuned) ? -2 : 0) + ((caster->path_attuned & spell->path_attuned) ? 2 : 0); 216 level += caster->path_repelled & spell->path_attuned ? -2 : 0;
217 level += caster->path_attuned & spell->path_attuned ? +2 : 0;
246 218
247 /* Always make this at least 1. If this is zero, we get divide by zero 219 /* Always make this at least 1. If this is zero, we get divide by zero
248 * errors in various places. 220 * errors in various places.
249 */ 221 */
250 if (level < 1)
251 level = 1;
252 return level; 222 return max (level, 1);
253} 223}
254 224
255/* The following function scales the spellpoint cost of 225/* The following function scales the spellpoint cost of
256 * a spell by it's increased effectiveness. Some of the 226 * a spell by it's increased effectiveness. Some of the
257 * lower level spells become incredibly vicious at high 227 * lower level spells become incredibly vicious at high
… …
451 * reflect_spell fails.) 421 * reflect_spell fails.)
452 * Caller should be sure it passes us valid map coordinates 422 * Caller should be sure it passes us valid map coordinates
453 * eg, updated for tiled maps. 423 * eg, updated for tiled maps.
454 */ 424 */
455int 425int
456reflwall (mapstruct *m, int x, int y, object *sp_op) 426reflwall (maptile *m, int x, int y, object *sp_op)
457{ 427{
458 object *op; 428 object *op;
459 429
460 if (OUT_OF_REAL_MAP (m, x, y)) 430 if (OUT_OF_REAL_MAP (m, x, y))
461 return 0; 431 return 0;
462 for (op = get_map_ob (m, x, y); op != NULL; op = op->above) 432 for (op = GET_MAP_OB (m, x, y); op != NULL; op = op->above)
463 if (QUERY_FLAG (op, FLAG_REFL_SPELL) && (!QUERY_FLAG (op, FLAG_ALIVE) || 433 if (QUERY_FLAG (op, FLAG_REFL_SPELL)
464 sp_op->type == LIGHTNING || (rndm (0, 99)) < 90 - (sp_op->level / 10))) 434 && (!QUERY_FLAG (op, FLAG_ALIVE)
435 || (rndm (0, 99)) < 90 - (sp_op->level / 10)))
465 return 1; 436 return 1;
466 437
467 return 0; 438 return 0;
468} 439}
469 440
… …
475 * in. 446 * in.
476 */ 447 */
477int 448int
478cast_create_obj (object *op, object *caster, object *new_op, int dir) 449cast_create_obj (object *op, object *caster, object *new_op, int dir)
479{ 450{
480 mapstruct *m; 451 maptile *m;
481 sint16 sx, sy; 452 sint16 sx, sy;
482 453
483 if (dir && 454 if (dir &&
484 ((get_map_flags (op->map, &m, op->x + freearr_x[dir], op->y + freearr_y[dir], &sx, &sy) & P_OUT_OF_MAP) || 455 ((get_map_flags (op->map, &m, op->x + freearr_x[dir], op->y + freearr_y[dir], &sx, &sy) & P_OUT_OF_MAP) ||
485 OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))) 456 OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))))
486 { 457 {
487 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 458 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
488 new_draw_info (NDI_UNIQUE, 0, op, "You cast it at your feet."); 459 new_draw_info (NDI_UNIQUE, 0, op, "You cast it at your feet.");
489 dir = 0; 460 dir = 0;
490 } 461 }
491 new_op->x = op->x + freearr_x[dir]; 462
492 new_op->y = op->y + freearr_y[dir]; 463 op->map->insert (new_op,
493 if (dir == 0) 464 op->x + freearr_x[dir], op->y + freearr_y[dir],
494 insert_ob_in_map (new_op, op->map, op, INS_BELOW_ORIGINATOR); 465 op,
495 else 466 dir ? 0 : INS_BELOW_ORIGINATOR);
496 insert_ob_in_map (new_op, op->map, op, 0); 467
497 return dir; 468 return dir;
498} 469}
499 470
500/* Returns true if it is ok to put spell *op on the space/may provided. 471/* Returns true if it is ok to put spell *op on the space/may provided.
501 * immune_stop is basically the attacktype of the spell (why 472 * immune_stop is basically the attacktype of the spell (why
… …
503 * has the AT_MAGIC bit set, and there is a counterwall 474 * has the AT_MAGIC bit set, and there is a counterwall
504 * on the space, the object doesn't get placed. if immune stop 475 * on the space, the object doesn't get placed. if immune stop
505 * does not have AT_MAGIC, then counterwalls do not effect the spell. 476 * does not have AT_MAGIC, then counterwalls do not effect the spell.
506 * 477 *
507 */ 478 */
508
509int 479int
510ok_to_put_more (mapstruct *m, sint16 x, sint16 y, object *op, int immune_stop) 480ok_to_put_more (maptile *m, sint16 x, sint16 y, object *op, int immune_stop)
511{ 481{
512 object *tmp; 482 if (!xy_normalise (m, x, y))
513 int mflags;
514 mapstruct *mp;
515
516 mp = m;
517 mflags = get_map_flags (m, &mp, x, y, &x, &y);
518
519 if (mflags & P_OUT_OF_MAP)
520 return 0; 483 return 0;
521 484
522 if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (mp, x, y))) 485 mapspace &ms = m->at (x, y);
486
487 if (OB_TYPE_MOVE_BLOCK (op, ms.move_block))
523 return 0; 488 return 0;
524 489
525 for (tmp = get_map_ob (mp, x, y); tmp != NULL; tmp = tmp->above) 490 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
526 { 491 {
527 /* If there is a counterspell on the space, and this 492 /* If there is a counterspell on the space, and this
528 * object is using magic, don't progress. I believe we could 493 * object is using magic, don't progress. I believe we could
529 * leave this out and let in progress, and other areas of the code 494 * leave this out and let in progress, and other areas of the code
530 * will then remove it, but that would seem to to use more 495 * will then remove it, but that would seem to to use more
531 * resources, and may not work as well if a player is standing 496 * resources, and may not work as well if a player is standing
532 * on top of a counterwall spell (may hit the player before being 497 * on top of a counterwall spell (may hit the player before being
533 * removed.) On the other hand, it may be more dramatic for the 498 * removed.) On the other hand, it may be more dramatic for the
534 * spell to actually hit the counterwall and be sucked up. 499 * spell to actually hit the counterwall and be sucked up.
535 */ 500 */
536 if ((tmp->attacktype & AT_COUNTERSPELL) && 501 if ((tmp->attacktype & AT_COUNTERSPELL)
537 (tmp->type != PLAYER) && !QUERY_FLAG (tmp, FLAG_MONSTER) && 502 && !QUERY_FLAG (tmp, FLAG_MONSTER)
538 (tmp->type != WEAPON) && (tmp->type != BOW) && (tmp->type != ARROW) && (tmp->type != GOLEM) && (immune_stop & AT_MAGIC)) 503 && (tmp->type != PLAYER)
504 && (tmp->type != WEAPON)
505 && (tmp->type != BOW)
506 && (tmp->type != ARROW)
507 && (tmp->type != GOLEM)
508 && !QUERY_FLAG (tmp, FLAG_IS_FLOOR) // XXX:
509 // we special case floor here because there
510 // are sometimes spell effect floors
511 // which are used to inflict damage
512 // (and those shouldn't go away from
513 // sanctuary) see also: permanent lava
514 && (immune_stop & AT_MAGIC))
539 return 0; 515 return 0;
540 516
541 /* This is to prevent 'out of control' spells. Basically, this 517 /* This is to prevent 'out of control' spells. Basically, this
542 * limits one spell effect per space per spell. This is definately 518 * limits one spell effect per space per spell. This is definately
543 * needed for performance reasons, and just for playability I believe. 519 * needed for performance reasons, and just for playability I believe.
… …
553 * playability reasons. 529 * playability reasons.
554 */ 530 */
555 if (tmp->arch == op->arch 531 if (tmp->arch == op->arch
556 && tmp->type == op->type 532 && tmp->type == op->type
557 && tmp->subtype == op->subtype 533 && tmp->subtype == op->subtype
534 && tmp->owner == op->owner
558 && tmp->owner == op->owner && ((tmp->subtype == SP_EXPLOSION) || (tmp->subtype == SP_CONE && tmp->stats.sp == op->stats.sp))) 535 && ((tmp->subtype == SP_EXPLOSION) || (tmp->subtype == SP_CONE && tmp->stats.sp == op->stats.sp)))
559 { 536 {
560 tmp->stats.dam = MAX (tmp->stats.dam, op->stats.dam); 537 tmp->stats.dam = MAX (tmp->stats.dam, op->stats.dam);
561 tmp->range = MAX (tmp->range, op->range); 538 tmp->range = MAX (tmp->range, op->range);
562 tmp->duration = MAX (tmp->duration, op->duration); 539 tmp->duration = MAX (tmp->duration, op->duration);
563 return 0; 540 return 0;
… …
565 542
566 /* Perhaps we should also put checks in for no magic and unholy 543 /* Perhaps we should also put checks in for no magic and unholy
567 * ground to prevent it from moving along? 544 * ground to prevent it from moving along?
568 */ 545 */
569 } 546 }
547
570 /* If it passes the above tests, it must be OK */ 548 /* If it passes the above tests, it must be OK */
571 return 1; 549 return 1;
572} 550}
573 551
574/* fire_arch_from_position: fires an archetype. 552/* fire_arch_from_position: fires an archetype.
… …
585int 563int
586fire_arch_from_position (object *op, object *caster, sint16 x, sint16 y, int dir, object *spell) 564fire_arch_from_position (object *op, object *caster, sint16 x, sint16 y, int dir, object *spell)
587{ 565{
588 object *tmp; 566 object *tmp;
589 int mflags; 567 int mflags;
590 mapstruct *m; 568 maptile *m;
591 569
592 if (spell->other_arch == NULL) 570 if (spell->other_arch == NULL)
593 return 0; 571 return 0;
594 572
595 m = op->map; 573 m = op->map;
… …
605 return 0; 583 return 0;
606 584
607 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, x, y))) 585 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, x, y)))
608 { 586 {
609 new_draw_info (NDI_UNIQUE, 0, op, "You can't cast the spell on top of a wall!\n"); 587 new_draw_info (NDI_UNIQUE, 0, op, "You can't cast the spell on top of a wall!\n");
610 free_object (tmp); 588 tmp->destroy ();
611 return 0; 589 return 0;
612 } 590 }
613
614
615 591
616 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 592 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
617 tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell); 593 tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
618 /* code in time.c uses food for some things, duration for others */ 594 /* code in time.c uses food for some things, duration for others */
619 tmp->stats.food = tmp->duration; 595 tmp->stats.food = tmp->duration;
620 tmp->range = spell->range + SP_level_range_adjust (caster, spell); 596 tmp->range = spell->range + SP_level_range_adjust (caster, spell);
621 tmp->attacktype = spell->attacktype; 597 tmp->attacktype = spell->attacktype;
622 tmp->x = x; 598 tmp->x = x;
623 tmp->y = y; 599 tmp->y = y;
624 tmp->direction = dir; 600 tmp->direction = dir;
625 if (get_owner (op) != NULL) 601 if (op->owner != NULL)
626 copy_owner (tmp, op); 602 tmp->set_owner (op);
627 else 603 else
628 set_owner (tmp, op); 604 tmp->set_owner (op);
629 tmp->level = caster_level (caster, spell); 605 tmp->level = caster_level (caster, spell);
630 set_spell_skill (op, caster, spell, tmp); 606 set_spell_skill (op, caster, spell, tmp);
631 607
632 /* needed for AT_HOLYWORD,AT_GODPOWER stuff */ 608 /* needed for AT_HOLYWORD,AT_GODPOWER stuff */
633 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) 609 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
… …
636 return 0; 612 return 0;
637 } 613 }
638 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE)) 614 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
639 SET_ANIMATION (tmp, dir); 615 SET_ANIMATION (tmp, dir);
640 616
641 if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL) 617 if ((tmp = insert_ob_in_map (tmp, m, op, 0)))
642 return 1;
643
644 move_spell_effect (tmp); 618 move_spell_effect (tmp);
645 619
646 return 1; 620 return 1;
647} 621}
648
649
650 622
651/***************************************************************************** 623/*****************************************************************************
652 * 624 *
653 * Code related to rods - perhaps better located in another file? 625 * Code related to rods - perhaps better located in another file?
654 * 626 *
655 ****************************************************************************/ 627 ****************************************************************************/
656
657void 628void
658regenerate_rod (object *rod) 629regenerate_rod (object *rod)
659{ 630{
660 if (rod->stats.hp < rod->stats.maxhp) 631 if (rod->stats.hp < rod->stats.maxhp)
661 { 632 {
… …
670void 641void
671drain_rod_charge (object *rod) 642drain_rod_charge (object *rod)
672{ 643{
673 rod->stats.hp -= SP_level_spellpoint_cost (rod, rod->inv, SPELL_HIGHEST); 644 rod->stats.hp -= SP_level_spellpoint_cost (rod, rod->inv, SPELL_HIGHEST);
674} 645}
675
676
677
678 646
679/* this function is commonly used to find a friendly target for 647/* this function is commonly used to find a friendly target for
680 * spells such as heal or protection or armour 648 * spells such as heal or protection or armour
681 * op is what is looking for the target (which can be a player), 649 * op is what is looking for the target (which can be a player),
682 * dir is the direction we are looking in. Return object found, or 650 * dir is the direction we are looking in. Return object found, or
683 * NULL if no good object. 651 * NULL if no good object.
684 */ 652 */
685
686object * 653object *
687find_target_for_friendly_spell (object *op, int dir) 654find_target_for_friendly_spell (object *op, int dir)
688{ 655{
689 object *tmp; 656 object *tmp;
690 mapstruct *m;
691 sint16 x, y;
692 int mflags;
693 657
694 /* I don't really get this block - if op isn't a player or rune, 658 /* I don't really get this block - if op isn't a player or rune,
695 * we then make the owner of this object the target. 659 * we then make the owner of this object the target.
696 * The owner could very well be no where near op. 660 * The owner could very well be no where near op.
697 */ 661 */
698 if (op->type != PLAYER && op->type != RUNE) 662 if (op->type != PLAYER && op->type != RUNE)
699 { 663 {
700 tmp = get_owner (op); 664 tmp = op->owner;
701 /* If the owner does not exist, or is not a monster, than apply the spell 665 /* If the owner does not exist, or is not a monster, than apply the spell
702 * to the caster. 666 * to the caster.
703 */ 667 */
704 if (!tmp || !QUERY_FLAG (tmp, FLAG_MONSTER)) 668 if (!tmp || !QUERY_FLAG (tmp, FLAG_MONSTER))
705 tmp = op; 669 tmp = op;
706 } 670 }
707 else 671 else
708 { 672 {
709 m = op->map; 673 maptile *m = op->map;
710 x = op->x + freearr_x[dir]; 674 sint16 x = op->x + freearr_x[dir];
711 y = op->y + freearr_y[dir]; 675 sint16 y = op->y + freearr_y[dir];
712
713 mflags = get_map_flags (m, &m, x, y, &x, &y);
714
715 if (mflags & P_OUT_OF_MAP)
716 tmp = NULL;
717 else
718 { 676
719 for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = tmp->above) 677 tmp = xy_normalise (m, x, y)
720 if (tmp->type == PLAYER) 678 ? m->at (x, y).player ()
721 break; 679 : 0;
722 }
723 } 680 }
681
724 /* didn't find a player there, look in current square for a player */ 682 /* didn't find a player there, look in current square for a player */
725 if (tmp == NULL) 683 if (!tmp)
726 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 684 tmp = op->ms ().player ();
727 {
728 if (tmp->type == PLAYER)
729 break;
730 }
731 685
732 return tmp; 686 return tmp;
733} 687}
734 688
735 689
… …
745 * any, otherwise -1. 699 * any, otherwise -1.
746 * note that exclude can be NULL, in which case all bets are off. 700 * note that exclude can be NULL, in which case all bets are off.
747 */ 701 */
748 702
749int 703int
750spell_find_dir (mapstruct *m, int x, int y, object *exclude) 704spell_find_dir (maptile *m, int x, int y, object *exclude)
751{ 705{
752 int i, max = SIZEOFFREE; 706 int i, max = SIZEOFFREE;
753 sint16 nx, ny; 707 sint16 nx, ny;
754 int owner_type = 0, mflags; 708 int owner_type = 0, mflags;
755 object *tmp; 709 object *tmp;
756 mapstruct *mp; 710 maptile *mp;
757 711
758 if (exclude && exclude->head) 712 if (exclude && exclude->head)
759 exclude = exclude->head; 713 exclude = exclude->head;
760 if (exclude && exclude->type) 714 if (exclude && exclude->type)
761 owner_type = exclude->type; 715 owner_type = exclude->type;
… …
767 mp = m; 721 mp = m;
768 mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny); 722 mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);
769 if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW)) 723 if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW))
770 continue; 724 continue;
771 725
772 tmp = get_map_ob (mp, nx, ny); 726 tmp = GET_MAP_OB (mp, nx, ny);
773 727
774 while (tmp != NULL && (((owner_type == PLAYER && 728 while (tmp != NULL && (((owner_type == PLAYER &&
775 !QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_GENERATOR)) || 729 !QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_GENERATOR)) ||
776 (owner_type != PLAYER && tmp->type != PLAYER)) || (tmp == exclude || (tmp->head && tmp->head == exclude)))) 730 (owner_type != PLAYER && tmp->type != PLAYER)) || (tmp == exclude || (tmp->head && tmp->head == exclude))))
777 tmp = tmp->above; 731 tmp = tmp->above;
… …
780 return freedir[i]; 734 return freedir[i];
781 } 735 }
782 return -1; /* flag for "keep going the way you were" */ 736 return -1; /* flag for "keep going the way you were" */
783} 737}
784 738
785
786
787/* put_a_monster: puts a monster named monstername near by 739/* put_a_monster: puts a monster named monstername near by
788 * op. This creates the treasures for the monsters, and 740 * op. This creates the treasures for the monsters, and
789 * also deals with multipart monsters properly. 741 * also deals with multipart monsters properly.
790 */ 742 */
791
792void 743void
793put_a_monster (object *op, const char *monstername) 744put_a_monster (object *op, const char *monstername)
794{ 745{
795 object *tmp, *head = NULL, *prev = NULL; 746 object *tmp, *head = NULL, *prev = NULL;
796 archetype *at; 747 archetype *at;
797 int dir; 748 int dir;
798 749
799 /* Handle cases where we are passed a bogus mosntername */ 750 /* Handle cases where we are passed a bogus mosntername */
800 751
801 if ((at = find_archetype (monstername)) == NULL) 752 if ((at = archetype::find (monstername)) == NULL)
802 return; 753 return;
803 754
804 /* find a free square nearby 755 /* find a free square nearby
805 * first we check the closest square for free squares 756 * first we check the closest square for free squares
806 */ 757 */
… …
832 create_treasure (head->randomitems, head, GT_INVISIBLE, op->map->difficulty, 0); 783 create_treasure (head->randomitems, head, GT_INVISIBLE, op->map->difficulty, 0);
833 784
834 insert_ob_in_map (head, op->map, op, 0); 785 insert_ob_in_map (head, op->map, op, 0);
835 786
836 /* thought it'd be cool to insert a burnout, too. */ 787 /* thought it'd be cool to insert a burnout, too. */
837 tmp = get_archetype ("burnout"); 788 op->map->insert (get_archetype ("burnout"), op->x + freearr_x[dir], op->y + freearr_y[dir], op);
838 tmp->map = op->map;
839 tmp->x = op->x + freearr_x[dir];
840 tmp->y = op->y + freearr_y[dir];
841 insert_ob_in_map (tmp, op->map, op, 0);
842 } 789 }
843} 790}
844 791
845/* peterm: function which summons hostile monsters and 792/* peterm: function which summons hostile monsters and
846 * places them in nearby squares. 793 * places them in nearby squares.
… …
873{ 820{
874 int attacktype; 821 int attacktype;
875 int face; 822 int face;
876} ATTACKS[22] = 823} ATTACKS[22] =
877{ 824{
878 {
879 AT_PHYSICAL, 0}, 825 { AT_PHYSICAL, 0},
880 {
881 AT_PHYSICAL, 0}, /*face = explosion */ 826 { AT_PHYSICAL, 0}, /*face = explosion */
882 {
883 AT_PHYSICAL, 0}, 827 { AT_PHYSICAL, 0},
884 {
885 AT_MAGIC, 1}, 828 { AT_MAGIC, 1},
886 {
887 AT_MAGIC, 1}, /* face = last-burnout */ 829 { AT_MAGIC, 1}, /* face = last-burnout */
888 {
889 AT_MAGIC, 1}, 830 { AT_MAGIC, 1},
890 {
891 AT_FIRE, 2}, 831 { AT_FIRE, 2},
892 {
893 AT_FIRE, 2}, /* face = fire.... */ 832 { AT_FIRE, 2}, /* face = fire.... */
894 {
895 AT_FIRE, 2}, 833 { AT_FIRE, 2},
896 {
897 AT_ELECTRICITY, 3}, 834 { AT_ELECTRICITY, 3},
898 {
899 AT_ELECTRICITY, 3}, /* ball_lightning */ 835 { AT_ELECTRICITY, 3}, /* ball_lightning */
900 {
901 AT_ELECTRICITY, 3}, 836 { AT_ELECTRICITY, 3},
902 {
903 AT_COLD, 4}, 837 { AT_COLD, 4},
904 {
905 AT_COLD, 4}, /* face=icestorm */ 838 { AT_COLD, 4}, /* face=icestorm */
906 {
907 AT_COLD, 4}, 839 { AT_COLD, 4},
908 {
909 AT_CONFUSION, 5}, 840 { AT_CONFUSION, 5},
910 {
911 AT_POISON, 7}, 841 { AT_POISON, 7},
912 {
913 AT_POISON, 7}, /* face = acid sphere. generator */ 842 { AT_POISON, 7}, /* face = acid sphere. generator */
914 {
915 AT_POISON, 7}, /* poisoncloud face */ 843 { AT_POISON, 7}, /* poisoncloud face */
916 {
917 AT_SLOW, 8}, 844 { AT_SLOW, 8},
918 {
919 AT_PARALYZE, 9}, 845 { AT_PARALYZE, 9},
920 {
921AT_FEAR, 10}}; 846 { AT_FEAR, 10},
922 847};
923
924 848
925/* shuffle_attack: peterm 849/* shuffle_attack: peterm
926 * This routine shuffles the attack of op to one of the 850 * This routine shuffles the attack of op to one of the
927 * ones in the list. It does this at random. It also 851 * ones in the list. It does this at random. It also
928 * chooses a face appropriate to the attack that is 852 * chooses a face appropriate to the attack that is
… …
973 if (failure <= -20 && failure > -40) /* wonder */ 897 if (failure <= -20 && failure > -40) /* wonder */
974 { 898 {
975 new_draw_info_format (NDI_UNIQUE, 0, op, "%s gives a sign to renew your faith.", godname); 899 new_draw_info_format (NDI_UNIQUE, 0, op, "%s gives a sign to renew your faith.", godname);
976 tmp = get_archetype (SPELL_WONDER); 900 tmp = get_archetype (SPELL_WONDER);
977 cast_cone (op, op, 0, tmp); 901 cast_cone (op, op, 0, tmp);
978 free_object (tmp); 902 tmp->destroy ();
979 } 903 }
980 904
981 else if (failure <= -40 && failure > -60) /* confusion */ 905 else if (failure <= -40 && failure > -60) /* confusion */
982 { 906 {
983 new_draw_info (NDI_UNIQUE, 0, op, "Your diety touches your mind!"); 907 new_draw_info (NDI_UNIQUE, 0, op, "Your diety touches your mind!");
… …
1017 if (failure <= -20 && failure > -40) /* wonder */ 941 if (failure <= -20 && failure > -40) /* wonder */
1018 { 942 {
1019 new_draw_info (NDI_UNIQUE, 0, op, "Your spell causes an unexpected effect."); 943 new_draw_info (NDI_UNIQUE, 0, op, "Your spell causes an unexpected effect.");
1020 tmp = get_archetype (SPELL_WONDER); 944 tmp = get_archetype (SPELL_WONDER);
1021 cast_cone (op, op, 0, tmp); 945 cast_cone (op, op, 0, tmp);
1022 free_object (tmp); 946 tmp->destroy ();
1023 } 947 }
1024 948
1025 else if (failure <= -40 && failure > -60) /* confusion */ 949 else if (failure <= -40 && failure > -60) /* confusion */
1026 { 950 {
1027 new_draw_info (NDI_UNIQUE, 0, op, "Your magic recoils on you, making you confused!"); 951 new_draw_info (NDI_UNIQUE, 0, op, "Your magic recoils on you, making you confused!");
… …
1046 else 970 else
1047 { 971 {
1048 new_draw_info (NDI_UNIQUE, 0, op, "You lose control of the mana! The uncontrolled magic blasts you!"); 972 new_draw_info (NDI_UNIQUE, 0, op, "You lose control of the mana! The uncontrolled magic blasts you!");
1049 tmp = get_archetype (LOOSE_MANA); 973 tmp = get_archetype (LOOSE_MANA);
1050 tmp->level = skill->level; 974 tmp->level = skill->level;
1051 tmp->x = op->x;
1052 tmp->y = op->y;
1053 975
1054 /* increase the area of destruction a little for more powerful spells */ 976 /* increase the area of destruction a little for more powerful spells */
1055 tmp->range += isqrt (power); 977 tmp->range += isqrt (power);
1056 978
1057 if (power > 25) 979 if (power > 25)
1058 tmp->stats.dam = 25 + isqrt (power); 980 tmp->stats.dam = 25 + isqrt (power);
1059 else 981 else
1060 tmp->stats.dam = power; /* nasty recoils! */ 982 tmp->stats.dam = power; /* nasty recoils! */
1061 983
1062 tmp->stats.maxhp = tmp->count; 984 tmp->stats.maxhp = tmp->count;
1063 insert_ob_in_map (tmp, op->map, NULL, 0); 985
986 tmp->insert_at (op);
1064 } 987 }
1065 } 988 }
1066} 989}
1067 990
1068int 991int
1069cast_party_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg) 992cast_party_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
1070{ 993{
1071 int success; 994 int success;
1072 player *pl;
1073 object *spell; 995 object *spell;
1074 996
1075 if (!spell_ob->other_arch) 997 if (!spell_ob->other_arch)
1076 { 998 {
1077 LOG (llevError, "cast_party_spell: empty other arch\n"); 999 LOG (llevError, "cast_party_spell: empty other arch\n");
… …
1082 /* Always cast spell on caster */ 1004 /* Always cast spell on caster */
1083 success = cast_spell (op, caster, dir, spell, stringarg); 1005 success = cast_spell (op, caster, dir, spell, stringarg);
1084 1006
1085 if (caster->contr->party == NULL) 1007 if (caster->contr->party == NULL)
1086 { 1008 {
1087 remove_ob (spell); 1009 spell->remove ();
1088 return success; 1010 return success;
1089 } 1011 }
1090 for (pl = first_player; pl != NULL; pl = pl->next) 1012 for_all_players (pl)
1091 if ((pl->ob->contr->party == caster->contr->party) && (on_same_map (pl->ob, caster))) 1013 if ((pl->ob->contr->party == caster->contr->party) && (on_same_map (pl->ob, caster)))
1092 { 1014 {
1093 cast_spell (pl->ob, caster, pl->ob->facing, spell, stringarg); 1015 cast_spell (pl->ob, caster, pl->ob->facing, spell, stringarg);
1094 } 1016 }
1095 remove_ob (spell); 1017 spell->remove ();
1096 return success; 1018 return success;
1097} 1019}
1098 1020
1099/* This is where the main dispatch when someone casts a spell. 1021/* This is where the main dispatch when someone casts a spell.
1100 * 1022 *
… …
1121 * 1043 *
1122 * if it is a player casting the spell (op->type == PLAYER, op == caster), 1044 * if it is a player casting the spell (op->type == PLAYER, op == caster),
1123 * this function will decrease the mana/grace appropriately. For other 1045 * this function will decrease the mana/grace appropriately. For other
1124 * objects, the caller should do what it considers appropriate. 1046 * objects, the caller should do what it considers appropriate.
1125 */ 1047 */
1126
1127int 1048int
1128cast_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg) 1049cast_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
1129{ 1050{
1130
1131 const char *godname; 1051 const char *godname;
1132 int success = 0, mflags, cast_level = 0, old_shoottype; 1052 int success = 0, mflags, cast_level = 0;
1133 object *skill = NULL; 1053 object *skill = NULL;
1134
1135 old_shoottype = op->contr ? op->contr->shoottype : 0;
1136 1054
1137 if (!spell_ob) 1055 if (!spell_ob)
1138 { 1056 {
1139 LOG (llevError, "cast_spell: null spell object passed\n"); 1057 LOG (llevError, "cast_spell: null spell object passed\n");
1140 return 0; 1058 return 0;
1141 } 1059 }
1060
1142 if (!strcmp ((godname = determine_god (op)), "none")) 1061 if (!strcmp ((godname = determine_god (op)), "none"))
1143 godname = "A random spirit"; 1062 godname = "A random spirit";
1144 1063
1145 /* the caller should set caster to op if appropriate */ 1064 /* the caller should set caster to op if appropriate */
1146 if (!caster) 1065 if (!caster)
… …
1150 } 1069 }
1151 1070
1152 /* if caster is a spell casting object, this normally shouldn't be 1071 /* if caster is a spell casting object, this normally shouldn't be
1153 * an issue, because they don't have any spellpaths set up. 1072 * an issue, because they don't have any spellpaths set up.
1154 */ 1073 */
1155 if (caster->path_denied & spell_ob->path_attuned) 1074 if (caster->path_denied & spell_ob->path_attuned && !QUERY_FLAG (caster, FLAG_WIZCAST))
1156 { 1075 {
1157 new_draw_info (NDI_UNIQUE, 0, op, "That spell path is denied to you."); 1076 new_draw_info (NDI_UNIQUE, 0, op, "That spell path is denied to you.");
1158 return 0; 1077 return 0;
1159 } 1078 }
1160 1079
… …
1193 SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) > op->stats.sp) 1112 SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) > op->stats.sp)
1194 { 1113 {
1195 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough mana."); 1114 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough mana.");
1196 return 0; 1115 return 0;
1197 } 1116 }
1117
1198 if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) && 1118 if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) &&
1199 SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) > op->stats.grace) 1119 SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) > op->stats.grace)
1200 { 1120 {
1201 if (random_roll (0, op->stats.Wis - 1, op, PREFER_HIGH) + op->stats.grace - 1121 if (random_roll (0, op->stats.Wis - 1, op, PREFER_HIGH) + op->stats.grace -
1202 10 * SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) / op->stats.maxgrace > 0) 1122 10 * SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) / op->stats.maxgrace > 0)
… …
1215 if (spell_ob->stats.grace && random_roll (0, 99, op, PREFER_HIGH) < 1135 if (spell_ob->stats.grace && random_roll (0, 99, op, PREFER_HIGH) <
1216 (spell_ob->level / (float) MAX (1, op->level) * cleric_chance[op->stats.Wis])) 1136 (spell_ob->level / (float) MAX (1, op->level) * cleric_chance[op->stats.Wis]))
1217 { 1137 {
1218 play_sound_player_only (op->contr, SOUND_FUMBLE_SPELL, 0, 0); 1138 play_sound_player_only (op->contr, SOUND_FUMBLE_SPELL, 0, 0);
1219 new_draw_info (NDI_UNIQUE, 0, op, "You fumble the spell."); 1139 new_draw_info (NDI_UNIQUE, 0, op, "You fumble the spell.");
1140
1220 if (settings.casting_time == TRUE) 1141 if (settings.casting_time == TRUE)
1221 {
1222 op->casting_time = -1; 1142 op->casting_time = -1;
1223 } 1143
1224 op->stats.grace -= random_roll (1, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE), op, PREFER_LOW); 1144 op->stats.grace -= random_roll (1, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE), op, PREFER_LOW);
1225 return 0; 1145 return 0;
1226 } 1146 }
1227 else if (spell_ob->stats.sp) 1147 else if (spell_ob->stats.sp)
1228 { 1148 {
… …
1231 if (failure < 0) 1151 if (failure < 0)
1232 { 1152 {
1233 new_draw_info (NDI_UNIQUE, 0, op, "You bungle the spell because you have too much heavy equipment in use."); 1153 new_draw_info (NDI_UNIQUE, 0, op, "You bungle the spell because you have too much heavy equipment in use.");
1234 if (settings.spell_failure_effects == TRUE) 1154 if (settings.spell_failure_effects == TRUE)
1235 spell_failure (op, failure, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), skill); 1155 spell_failure (op, failure, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), skill);
1236 op->contr->shoottype = (rangetype) old_shoottype; 1156
1237 op->stats.sp -= random_roll (0, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), op, PREFER_LOW); 1157 op->stats.sp -= random_roll (0, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), op, PREFER_LOW);
1238 return 0; 1158 return 0;
1239 } 1159 }
1240 } 1160 }
1241 } 1161 }
… …
1264 { 1184 {
1265 if (op->type != PLAYER) 1185 if (op->type != PLAYER)
1266 return 0; 1186 return 0;
1267 1187
1268 if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace) 1188 if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)
1269 new_draw_info_format (NDI_UNIQUE, 0, op, "This ground is unholy! %s ignores you.", godname); 1189 new_draw_info_format (NDI_UNIQUE, 0, op, "This ground is unholy! %s ignores you.", godname);
1270 else 1190 else
1271 switch (op->contr->shoottype)
1272 {
1273 case range_magic:
1274 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your spellcasting."); 1191 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the spell!");
1275 break; 1192
1276 case range_misc:
1277 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of your item.");
1278 break;
1279 case range_golem:
1280 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of your scroll.");
1281 break;
1282 default:
1283 break;
1284 }
1285 return 0; 1193 return 0;
1286 } 1194 }
1287 1195
1288 if (caster == op && settings.casting_time == TRUE && spell_ob->type == SPELL) 1196 if (caster == op && settings.casting_time == TRUE && spell_ob->type == SPELL)
1289 { 1197 {
… …
1295 * spell is actually cast, it knows about the stringarg. 1203 * spell is actually cast, it knows about the stringarg.
1296 * necessary for the invoke command spells. 1204 * necessary for the invoke command spells.
1297 */ 1205 */
1298 if (stringarg) 1206 if (stringarg)
1299 { 1207 {
1300 op->spellarg = strdup_local (stringarg); 1208 op->spellarg = strdup (stringarg);
1301 } 1209 }
1302 else 1210 else
1303 op->spellarg = NULL; 1211 op->spellarg = NULL;
1304 return 0; 1212 return 0;
1305 } 1213 }
… …
1362 change_skill (op, skill, 0); /* needed for proper exp credit */ 1270 change_skill (op, skill, 0); /* needed for proper exp credit */
1363 } 1271 }
1364 1272
1365 switch (spell_ob->subtype) 1273 switch (spell_ob->subtype)
1366 { 1274 {
1367 /* The order of case statements is same as the order they show up 1275 /* The order of case statements is same as the order they show up
1368 * in in spells.h. 1276 * in in spells.h.
1369 */ 1277 */
1370 case SP_RAISE_DEAD: 1278 case SP_RAISE_DEAD:
1371 success = cast_raise_dead_spell (op, caster, spell_ob, dir, stringarg); 1279 success = cast_raise_dead_spell (op, caster, spell_ob, dir, stringarg);
1372 break; 1280 break;
1373 1281
1374 case SP_RUNE: 1282 case SP_RUNE:
1375 success = write_rune (op, caster, spell_ob, dir, stringarg); 1283 success = write_rune (op, caster, spell_ob, dir, stringarg);
1376 break; 1284 break;
1377 1285
1378 case SP_MAKE_MARK: 1286 case SP_MAKE_MARK:
1379 success = write_mark (op, spell_ob, stringarg); 1287 success = write_mark (op, spell_ob, stringarg);
1380 break; 1288 break;
1381 1289
1382 case SP_BOLT: 1290 case SP_BOLT:
1383 success = fire_bolt (op, caster, dir, spell_ob, skill); 1291 success = fire_bolt (op, caster, dir, spell_ob, skill);
1384 break; 1292 break;
1385 1293
1386 case SP_BULLET: 1294 case SP_BULLET:
1387 success = fire_bullet (op, caster, dir, spell_ob); 1295 success = fire_bullet (op, caster, dir, spell_ob);
1388 break; 1296 break;
1389 1297
1390 case SP_CONE: 1298 case SP_CONE:
1391 success = cast_cone (op, caster, dir, spell_ob); 1299 success = cast_cone (op, caster, dir, spell_ob);
1392 break; 1300 break;
1393 1301
1394 case SP_BOMB: 1302 case SP_BOMB:
1395 success = create_bomb (op, caster, dir, spell_ob); 1303 success = create_bomb (op, caster, dir, spell_ob);
1396 break; 1304 break;
1397 1305
1398 case SP_WONDER: 1306 case SP_WONDER:
1399 success = cast_wonder (op, caster, dir, spell_ob); 1307 success = cast_wonder (op, caster, dir, spell_ob);
1400 break; 1308 break;
1401 1309
1402 case SP_SMITE: 1310 case SP_SMITE:
1403 success = cast_smite_spell (op, caster, dir, spell_ob); 1311 success = cast_smite_spell (op, caster, dir, spell_ob);
1404 break; 1312 break;
1405 1313
1406 case SP_MAGIC_MISSILE: 1314 case SP_MAGIC_MISSILE:
1315 success = fire_arch_from_position (op, caster, op->x + freearr_x[dir], op->y + freearr_y[dir], dir, spell_ob);
1316 break;
1317
1318 case SP_SUMMON_GOLEM:
1319 success = summon_golem (op, caster, dir, spell_ob);
1320 break;
1321
1322 case SP_DIMENSION_DOOR:
1323 /* dimension door needs the actual caster, because that is what is
1324 * moved.
1325 */
1326 success = dimension_door (op, caster, spell_ob, dir);
1327 break;
1328
1329 case SP_MAGIC_MAPPING:
1330 if (op->type == PLAYER)
1331 {
1332 spell_effect (spell_ob, op->x, op->y, op->map, op);
1333 draw_magic_map (op);
1334 success = 1;
1335 }
1336 else
1337 success = 0;
1338 break;
1339
1340 case SP_MAGIC_WALL:
1341 success = magic_wall (op, caster, dir, spell_ob);
1342 break;
1343
1344 case SP_DESTRUCTION:
1345 success = cast_destruction (op, caster, spell_ob);
1346 break;
1347
1348 case SP_PERCEIVE_SELF:
1349 success = perceive_self (op);
1350 break;
1351
1352 case SP_WORD_OF_RECALL:
1353 success = cast_word_of_recall (op, caster, spell_ob);
1354 break;
1355
1356 case SP_INVISIBLE:
1357 success = cast_invisible (op, caster, spell_ob);
1358 break;
1359
1360 case SP_PROBE:
1361 success = probe (op, caster, spell_ob, dir);
1362 break;
1363
1364 case SP_HEALING:
1365 success = cast_heal (op, caster, spell_ob, dir);
1366 break;
1367
1368 case SP_CREATE_FOOD:
1369 success = cast_create_food (op, caster, spell_ob, dir, stringarg);
1370 break;
1371
1372 case SP_EARTH_TO_DUST:
1373 success = cast_earth_to_dust (op, caster, spell_ob);
1374 break;
1375
1376 case SP_CHANGE_ABILITY:
1377 success = cast_change_ability (op, caster, spell_ob, dir, 0);
1378 break;
1379
1380 case SP_BLESS:
1381 success = cast_bless (op, caster, spell_ob, dir);
1382 break;
1383
1384 case SP_CURSE:
1385 success = cast_curse (op, caster, spell_ob, dir);
1386 break;
1387
1388 case SP_SUMMON_MONSTER:
1389 success = summon_object (op, caster, spell_ob, dir, stringarg);
1390 break;
1391
1392 case SP_CHARGING:
1393 success = recharge (op, caster, spell_ob);
1394 break;
1395
1396 case SP_POLYMORPH:
1397#ifdef NO_POLYMORPH
1398 /* Not great, but at least provide feedback so if players do have
1399 * polymorph (ie, find it as a preset item or left over from before
1400 * it was disabled), they get some feedback.
1401 */
1402 new_draw_info (NDI_UNIQUE, 0, op, "The spell fizzles");
1403 success = 0;
1404#else
1405 success = cast_polymorph (op, caster, spell_ob, dir);
1406#endif
1407 break;
1408
1409 case SP_ALCHEMY:
1410 success = alchemy (op, caster, spell_ob);
1411 break;
1412
1413 case SP_REMOVE_CURSE:
1414 success = remove_curse (op, caster, spell_ob);
1415 break;
1416
1417 case SP_IDENTIFY:
1418 success = cast_identify (op, caster, spell_ob);
1419 break;
1420
1421 case SP_DETECTION:
1422 success = cast_detection (op, caster, spell_ob, skill);
1423 break;
1424
1425 case SP_MOOD_CHANGE:
1426 success = mood_change (op, caster, spell_ob);
1427 break;
1428
1429 case SP_MOVING_BALL:
1430 if (spell_ob->path_repelled && (spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled)
1431 {
1432 new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the proper attunement to cast %s", &spell_ob->name);
1433 success = 0;
1434 }
1435 else
1407 success = fire_arch_from_position (op, caster, op->x + freearr_x[dir], op->y + freearr_y[dir], dir, spell_ob); 1436 success = fire_arch_from_position (op, caster, op->x + freearr_x[dir], op->y + freearr_y[dir], dir, spell_ob);
1408 break; 1437 break;
1409 1438
1410 case SP_SUMMON_GOLEM:
1411 success = summon_golem (op, caster, dir, spell_ob);
1412 old_shoottype = range_golem;
1413 break;
1414
1415 case SP_DIMENSION_DOOR:
1416 /* dimension door needs the actual caster, because that is what is
1417 * moved.
1418 */
1419 success = dimension_door (op, caster, spell_ob, dir);
1420 break;
1421
1422 case SP_MAGIC_MAPPING:
1423 if (op->type == PLAYER)
1424 {
1425 spell_effect (spell_ob, op->x, op->y, op->map, op);
1426 draw_magic_map (op);
1427 success = 1;
1428 }
1429 else
1430 success = 0;
1431 break;
1432
1433 case SP_MAGIC_WALL:
1434 success = magic_wall (op, caster, dir, spell_ob);
1435 break;
1436
1437 case SP_DESTRUCTION:
1438 success = cast_destruction (op, caster, spell_ob);
1439 break;
1440
1441 case SP_PERCEIVE_SELF:
1442 success = perceive_self (op);
1443 break;
1444
1445 case SP_WORD_OF_RECALL:
1446 success = cast_word_of_recall (op, caster, spell_ob);
1447 break;
1448
1449 case SP_INVISIBLE:
1450 success = cast_invisible (op, caster, spell_ob);
1451 break;
1452
1453 case SP_PROBE:
1454 success = probe (op, caster, spell_ob, dir);
1455 break;
1456
1457 case SP_HEALING:
1458 success = cast_heal (op, caster, spell_ob, dir);
1459 break;
1460
1461 case SP_CREATE_FOOD:
1462 success = cast_create_food (op, caster, spell_ob, dir, stringarg);
1463 break;
1464
1465 case SP_EARTH_TO_DUST:
1466 success = cast_earth_to_dust (op, caster, spell_ob);
1467 break;
1468
1469 case SP_CHANGE_ABILITY:
1470 success = cast_change_ability (op, caster, spell_ob, dir, 0);
1471 break;
1472
1473 case SP_BLESS:
1474 success = cast_bless (op, caster, spell_ob, dir);
1475 break;
1476
1477 case SP_CURSE:
1478 success = cast_curse (op, caster, spell_ob, dir);
1479 break;
1480
1481 case SP_SUMMON_MONSTER:
1482 success = summon_object (op, caster, spell_ob, dir, stringarg);
1483 break;
1484
1485 case SP_CHARGING:
1486 success = recharge (op, caster, spell_ob);
1487 break;
1488
1489 case SP_POLYMORPH:
1490#ifdef NO_POLYMORPH
1491 /* Not great, but at least provide feedback so if players do have
1492 * polymorph (ie, find it as a preset item or left over from before
1493 * it was disabled), they get some feedback.
1494 */
1495 new_draw_info (NDI_UNIQUE, 0, op, "The spell fizzles");
1496 success = 0;
1497#else
1498 success = cast_polymorph (op, caster, spell_ob, dir);
1499#endif
1500 break;
1501
1502 case SP_ALCHEMY:
1503 success = alchemy (op, caster, spell_ob);
1504 break;
1505
1506 case SP_REMOVE_CURSE:
1507 success = remove_curse (op, caster, spell_ob);
1508 break;
1509
1510 case SP_IDENTIFY:
1511 success = cast_identify (op, caster, spell_ob);
1512 break;
1513
1514 case SP_DETECTION:
1515 success = cast_detection (op, caster, spell_ob, skill);
1516 break;
1517
1518 case SP_MOOD_CHANGE:
1519 success = mood_change (op, caster, spell_ob);
1520 break;
1521
1522 case SP_MOVING_BALL:
1523 if (spell_ob->path_repelled && (spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled)
1524 {
1525 new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the proper attunement to cast %s", &spell_ob->name);
1526 success = 0;
1527 }
1528 else
1529 success = fire_arch_from_position (op, caster, op->x + freearr_x[dir], op->y + freearr_y[dir], dir, spell_ob);
1530 break;
1531
1532 case SP_SWARM: 1439 case SP_SWARM:
1533 success = fire_swarm (op, caster, spell_ob, dir); 1440 success = fire_swarm (op, caster, spell_ob, dir);
1534 break; 1441 break;
1535 1442
1536 case SP_CHANGE_MANA: 1443 case SP_CHANGE_MANA:
1537 success = cast_transfer (op, caster, spell_ob, dir); 1444 success = cast_transfer (op, caster, spell_ob, dir);
1538 break; 1445 break;
1539 1446
1540 case SP_DISPEL_RUNE: 1447 case SP_DISPEL_RUNE:
1541 /* in rune.c */ 1448 /* in rune.c */
1542 success = dispel_rune (op, caster, spell_ob, skill, dir); 1449 success = dispel_rune (op, caster, spell_ob, skill, dir);
1543 break; 1450 break;
1544 1451
1545 case SP_CREATE_MISSILE: 1452 case SP_CREATE_MISSILE:
1546 success = cast_create_missile (op, caster, spell_ob, dir, stringarg); 1453 success = cast_create_missile (op, caster, spell_ob, dir, stringarg);
1547 break; 1454 break;
1548 1455
1549 case SP_CONSECRATE: 1456 case SP_CONSECRATE:
1550 success = cast_consecrate (op, caster, spell_ob); 1457 success = cast_consecrate (op, caster, spell_ob);
1551 break; 1458 break;
1552 1459
1553 case SP_ANIMATE_WEAPON: 1460 case SP_ANIMATE_WEAPON:
1554 success = animate_weapon (op, caster, spell_ob, dir); 1461 success = animate_weapon (op, caster, spell_ob, dir);
1555 old_shoottype = range_golem;
1556 break; 1462 break;
1557 1463
1558 case SP_LIGHT: 1464 case SP_LIGHT:
1559 success = cast_light (op, caster, spell_ob, dir); 1465 success = cast_light (op, caster, spell_ob, dir);
1560 break; 1466 break;
1561 1467
1562 case SP_CHANGE_MAP_LIGHT: 1468 case SP_CHANGE_MAP_LIGHT:
1563 success = cast_change_map_lightlevel (op, caster, spell_ob); 1469 success = cast_change_map_lightlevel (op, caster, spell_ob);
1564 break; 1470 break;
1565 1471
1566 case SP_FAERY_FIRE: 1472 case SP_FAERY_FIRE:
1567 success = cast_destruction (op, caster, spell_ob); 1473 success = cast_destruction (op, caster, spell_ob);
1568 break; 1474 break;
1569 1475
1570 case SP_CAUSE_DISEASE: 1476 case SP_CAUSE_DISEASE:
1571 success = cast_cause_disease (op, caster, spell_ob, dir); 1477 success = cast_cause_disease (op, caster, spell_ob, dir);
1572 break; 1478 break;
1573 1479
1574 case SP_AURA: 1480 case SP_AURA:
1575 success = create_aura (op, caster, spell_ob); 1481 success = create_aura (op, caster, spell_ob);
1576 break; 1482 break;
1577 1483
1578 case SP_TOWN_PORTAL: 1484 case SP_TOWN_PORTAL:
1579 success = cast_create_town_portal (op, caster, spell_ob, dir); 1485 success = cast_create_town_portal (op, caster, spell_ob, dir);
1580 break; 1486 break;
1581 1487
1582 case SP_PARTY_SPELL: 1488 case SP_PARTY_SPELL:
1583 success = cast_party_spell (op, caster, dir, spell_ob, stringarg); 1489 success = cast_party_spell (op, caster, dir, spell_ob, stringarg);
1584 break; 1490 break;
1585 1491
1586 default: 1492 default:
1587 if (!INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (stringarg))) 1493 if (!INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (stringarg)))
1588 LOG (llevError, "cast_spell: Unhandled spell subtype %d\n", spell_ob->subtype); 1494 LOG (llevError, "cast_spell: Unhandled spell subtype %d\n", spell_ob->subtype);
1589
1590
1591 } 1495 }
1592 1496
1593 /* FIXME - we need some better sound suppport */ 1497 /* FIXME - we need some better sound suppport */
1594 // yes, for example, augment map info with the spell effect 1498 // yes, for example, augment map info with the spell effect
1595 // so clients can calculate the sounds themselves 1499 // so clients can calculate the sounds themselves
… …
1597 1501
1598 /* free the spell arg */ 1502 /* free the spell arg */
1599 if (settings.casting_time == TRUE && stringarg) 1503 if (settings.casting_time == TRUE && stringarg)
1600 { 1504 {
1601 free (stringarg); 1505 free (stringarg);
1602 stringarg = NULL; 1506 stringarg = 0;
1603 } 1507 }
1604 /* perhaps a bit of a hack, but if using a wand, it has to change the skill
1605 * to something like use_magic_item, but you really want to be able to fire
1606 * it again.
1607 */
1608 if (op->contr)
1609 op->contr->shoottype = (rangetype) old_shoottype;
1610 1508
1611 return success; 1509 return success;
1612} 1510}
1613 1511
1614 1512
… …
1617 * then dispatches them to the appropriate specific routines. 1515 * then dispatches them to the appropriate specific routines.
1618 */ 1516 */
1619void 1517void
1620move_spell_effect (object *op) 1518move_spell_effect (object *op)
1621{ 1519{
1622
1623 switch (op->subtype) 1520 switch (op->subtype)
1624 { 1521 {
1625 case SP_BOLT: 1522 case SP_BOLT:
1626 move_bolt (op); 1523 move_bolt (op);
1627 break; 1524 break;
1628 1525
1629 case SP_BULLET: 1526 case SP_BULLET:
1630 move_bullet (op); 1527 move_bullet (op);
1631 break; 1528 break;
1632 1529
1633 case SP_EXPLOSION: 1530 case SP_EXPLOSION:
1634 explosion (op); 1531 explosion (op);
1635 break; 1532 break;
1636 1533
1637 case SP_CONE: 1534 case SP_CONE:
1638 move_cone (op); 1535 move_cone (op);
1639 break; 1536 break;
1640 1537
1641 case SP_BOMB: 1538 case SP_BOMB:
1642 animate_bomb (op); 1539 animate_bomb (op);
1643 break; 1540 break;
1644 1541
1645 case SP_MAGIC_MISSILE: 1542 case SP_MAGIC_MISSILE:
1646 move_missile (op); 1543 move_missile (op);
1647 break; 1544 break;
1648 1545
1649 case SP_WORD_OF_RECALL: 1546 case SP_WORD_OF_RECALL:
1650 execute_word_of_recall (op); 1547 execute_word_of_recall (op);
1651 break; 1548 break;
1652 1549
1653 case SP_MOVING_BALL: 1550 case SP_MOVING_BALL:
1654 move_ball_spell (op); 1551 move_ball_spell (op);
1655 break; 1552 break;
1656 1553
1657 case SP_SWARM: 1554 case SP_SWARM:
1658 move_swarm_spell (op); 1555 move_swarm_spell (op);
1659 break; 1556 break;
1660 1557
1661 case SP_AURA: 1558 case SP_AURA:
1662 move_aura (op); 1559 move_aura (op);
1663 break; 1560 break;
1664
1665 } 1561 }
1666} 1562}
1667 1563
1668/* this checks to see if something special should happen if 1564/* this checks to see if something special should happen if
1669 * something runs into the object. 1565 * something runs into the object.
1670 */ 1566 */
1671void 1567void
1672check_spell_effect (object *op) 1568check_spell_effect (object *op)
1673{ 1569{
1674
1675 switch (op->subtype) 1570 switch (op->subtype)
1676 { 1571 {
1677 case SP_BOLT: 1572 case SP_BOLT:
1678 move_bolt (op); 1573 move_bolt (op);
1679 return; 1574 return;
1680 1575
1681 case SP_BULLET: 1576 case SP_BULLET:
1682 check_bullet (op); 1577 check_bullet (op);
1683 return; 1578 return;
1684 } 1579 }
1685
1686} 1580}
1687 1581
1688/* This is called by move_apply. Basically, if someone 1582/* This is called by move_apply. Basically, if someone
1689 * moves onto a spell effect and the walk_on or fly_on flags 1583 * moves onto a spell effect and the walk_on or fly_on flags
1690 * are set, this is called. This should only be called for 1584 * are set, this is called. This should only be called for
… …
1693void 1587void
1694apply_spell_effect (object *spell, object *victim) 1588apply_spell_effect (object *spell, object *victim)
1695{ 1589{
1696 switch (spell->subtype) 1590 switch (spell->subtype)
1697 { 1591 {
1698 case SP_CONE: 1592 case SP_CONE:
1699 if (QUERY_FLAG (victim, FLAG_ALIVE) && spell->speed && spell->attacktype) 1593 if (QUERY_FLAG (victim, FLAG_ALIVE) && spell->speed && spell->attacktype)
1700 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 0); 1594 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 0);
1701 break; 1595 break;
1702 1596
1703 case SP_MAGIC_MISSILE: 1597 case SP_MAGIC_MISSILE:
1704 if (QUERY_FLAG (victim, FLAG_ALIVE)) 1598 if (QUERY_FLAG (victim, FLAG_ALIVE))
1705 { 1599 {
1706 tag_t spell_tag = spell->count;
1707
1708 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1709 if (!was_destroyed (spell, spell_tag))
1710 {
1711 remove_ob (spell);
1712 free_object (spell);
1713 }
1714 }
1715 break;
1716
1717 case SP_MOVING_BALL:
1718 if (QUERY_FLAG (victim, FLAG_ALIVE))
1719 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1); 1600 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1601
1602 if (!spell->destroyed ())
1603 spell->destroy ();
1604 }
1605 break;
1606
1607 case SP_MOVING_BALL:
1608 if (QUERY_FLAG (victim, FLAG_ALIVE))
1609 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1720 else if (victim->material || victim->materialname) 1610 else if (victim->materialname)
1721 save_throw_object (victim, spell->attacktype, spell); 1611 save_throw_object (victim, spell->attacktype, spell);
1722 break; 1612 break;
1723 } 1613 }
1724} 1614}

Diff Legend

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