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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.110 by root, Fri Jan 27 22:00:40 2012 UTC vs.
Revision 1.116 by root, Sat Sep 16 22:17:42 2017 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002-2003 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002-2003 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 8 * 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 9 * 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 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version. 11 * option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the Affero GNU General Public License 18 * 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 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>. 20 * <http://www.gnu.org/licenses/>.
21 * 21 *
22 * The authors can be reached via e-mail to <support@deliantra.net> 22 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 23 */
24 24
25/* This file contains all the spell attack code. Grouping this code 25/* This file contains all the spell attack code. Grouping this code
26 * together should hopefully make it easier to find the relevent bits 26 * together should hopefully make it easier to find the relevent bits
… …
86 if (tmp->move_type & MOVE_FLYING) 86 if (tmp->move_type & MOVE_FLYING)
87 frictionmod = 1; /* flying objects loose the friction modifier */ 87 frictionmod = 1; /* flying objects loose the friction modifier */
88 88
89 if (rndm (0, weight_move - 1) > ((tmp->weight / num_sections) * frictionmod)) 89 if (rndm (0, weight_move - 1) > ((tmp->weight / num_sections) * frictionmod))
90 { /* move it. */ 90 { /* move it. */
91 /* move_object is really for monsters, but looking at 91 /* move_object is really for monsters, but looking at
92 * the move_object function, it appears that it should 92 * the move_object function, it appears that it should
93 * also be safe for objects. 93 * also be safe for objects.
94 * This does return if successful or not, but 94 * This does return if successful or not, but
95 * I don't see us doing anything useful with that information 95 * I don't see us doing anything useful with that information
96 * right now. 96 * right now.
… …
129 new_dir = -1; 129 new_dir = -1;
130 130
131 /* check the new dir for a wall and in the map */ 131 /* check the new dir for a wall and in the map */
132 t_dir = absdir (tmp->direction + new_dir); 132 t_dir = absdir (tmp->direction + new_dir);
133 133
134 if (get_map_flags (tmp->map, &m, tmp->x + freearr_x[t_dir], tmp->y + freearr_y[t_dir], &sx, &sy) & P_OUT_OF_MAP) 134 if (get_map_flags (tmp->map, &m, tmp->x + DIRX (t_dir), tmp->y + DIRY (t_dir), &sx, &sy) & P_OUT_OF_MAP)
135 return; 135 return;
136 136
137 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, sx, sy))) 137 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, sx, sy)))
138 return; 138 return;
139 139
… …
179 179
180 if (--op->range < 0) 180 if (--op->range < 0)
181 op->range = 0; 181 op->range = 0;
182 else 182 else
183 { 183 {
184 x = op->x + DIRX (op); 184 x = op->x + DIRX (op->direction);
185 y = op->y + DIRY (op); 185 y = op->y + DIRY (op->direction);
186 m = op->map; 186 m = op->map;
187 mflags = get_map_flags (m, &m, x, y, &x, &y); 187 mflags = get_map_flags (m, &m, x, y, &x, &y);
188 188
189 if (mflags & P_OUT_OF_MAP) 189 if (mflags & P_OUT_OF_MAP)
190 return; 190 return;
… …
217 /* Need to check for P_OUT_OF_MAP: if the bolt is tavelling 217 /* Need to check for P_OUT_OF_MAP: if the bolt is tavelling
218 * over a corner in a tiled map, it is possible that 218 * over a corner in a tiled map, it is possible that
219 * op->direction is within an adjacent map but either 219 * op->direction is within an adjacent map but either
220 * op->direction-1 or op->direction+1 does not exist. 220 * op->direction-1 or op->direction+1 does not exist.
221 */ 221 */
222 mflags = get_map_flags (op->map, &m, op->x + freearr_x[absdir (op->direction - 1)], 222 mflags = get_map_flags (op->map, &m, op->x + DIRX (absdir (op->direction - 1)),
223 op->y + freearr_y[absdir (op->direction - 1)], &x, &y); 223 op->y + DIRY (absdir (op->direction - 1)), &x, &y);
224 224
225 left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)); 225 left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y));
226 226
227 mflags = get_map_flags (op->map, &m, op->x + freearr_x[absdir (op->direction + 1)], 227 mflags = get_map_flags (op->map, &m, op->x + DIRX (absdir (op->direction + 1)),
228 op->y + freearr_y[absdir (op->direction + 1)], &x, &y); 228 op->y + DIRY (absdir (op->direction + 1)), &x, &y);
229 right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)); 229 right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y));
230 230
231 if (left == right) 231 if (left == right)
232 op->direction = absdir (op->direction + 4); 232 op->direction = absdir (op->direction + 4);
233 else if (left) 233 else if (left)
… …
247 tmp->speed_left = -0.1f; 247 tmp->speed_left = -0.1f;
248 /* To make up for the decrease at the top of the function */ 248 /* To make up for the decrease at the top of the function */
249 tmp->duration++; 249 tmp->duration++;
250 250
251 /* New forking code. Possibly create forks of this object 251 /* New forking code. Possibly create forks of this object
252 * going off in other directions. 252 * going off in other directions.
253 */ 253 */
254 if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex) 254 if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
255 forklightning (op, tmp); /* stats.Dex % of forking */ 255 forklightning (op, tmp); /* stats.Dex % of forking */
256 256
257 /* In this way, the object left behind sticks on the space, but 257 /* In this way, the object left behind sticks on the space, but
… …
300 SET_ANIMATION (tmp, dir); 300 SET_ANIMATION (tmp, dir);
301 301
302 tmp->set_owner (op); 302 tmp->set_owner (op);
303 set_spell_skill (op, caster, spob, tmp); 303 set_spell_skill (op, caster, spob, tmp);
304 304
305 tmp->x = op->x + DIRX (tmp); 305 tmp->x = op->x + DIRX (tmp->direction);
306 tmp->y = op->y + DIRY (tmp); 306 tmp->y = op->y + DIRY (tmp->direction);
307 tmp->map = op->map; 307 tmp->map = op->map;
308 308
309 maptile *newmap; 309 maptile *newmap;
310 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y); 310 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
311 if (mflags & P_OUT_OF_MAP) 311 if (mflags & P_OUT_OF_MAP)
… …
364 { 364 {
365 for (i = 1; i < 9; i++) 365 for (i = 1; i < 9; i++)
366 { 366 {
367 sint16 dx, dy; 367 sint16 dx, dy;
368 368
369 dx = op->x + freearr_x[i]; 369 dx = op->x + DIRX (i);
370 dy = op->y + freearr_y[i]; 370 dy = op->y + DIRY (i);
371 371
372 /* ok_to_put_more already does things like checks for walls, 372 /* ok_to_put_more already does things like checks for walls,
373 * out of map, etc. 373 * out of map, etc.
374 */ 374 */
375 if (ok_to_put_more (op->map, dx, dy, op, op->attacktype)) 375 if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))
376 { 376 {
377 object *tmp = op->clone (); 377 object *tmp = op->clone ();
… …
549move_bullet (object *op) 549move_bullet (object *op)
550{ 550{
551#if 0 551#if 0
552 /* We need a better general purpose way to do this */ 552 /* We need a better general purpose way to do this */
553 553
554 /* peterm: added to make comet leave a trail of burnouts 554 /* peterm: added to make comet leave a trail of burnouts
555 it's an unadulterated hack, but the effect is cool. */ 555 it's an unadulterated hack, but the effect is cool. */
556 if (op->stats.sp == SP_METEOR) 556 if (op->stats.sp == SP_METEOR)
557 { 557 {
558 replace_insert_ob_in_map ("fire_trail", op); 558 replace_insert_ob_in_map ("fire_trail", op);
559 if (op->destroyed ()) 559 if (op->destroyed ())
… …
646 SET_ANIMATION (tmp, dir); 646 SET_ANIMATION (tmp, dir);
647 647
648 tmp->set_owner (op); 648 tmp->set_owner (op);
649 set_spell_skill (op, caster, spob, tmp); 649 set_spell_skill (op, caster, spob, tmp);
650 650
651 tmp->x = op->x + freearr_x[dir]; 651 tmp->x = op->x + DIRX (dir);
652 tmp->y = op->y + freearr_y[dir]; 652 tmp->y = op->y + DIRY (dir);
653 tmp->map = op->map; 653 tmp->map = op->map;
654 654
655 maptile *newmap; 655 maptile *newmap;
656 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y); 656 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
657 if (mflags & P_OUT_OF_MAP) 657 if (mflags & P_OUT_OF_MAP)
… …
754 if (!op->is_on_map ()) 754 if (!op->is_on_map ())
755 return; 755 return;
756 756
757 /* Check to see if we should push anything. 757 /* Check to see if we should push anything.
758 * Spell objects with weight push whatever they encounter to some 758 * Spell objects with weight push whatever they encounter to some
759 * degree. 759 * degree.
760 */ 760 */
761 if (op->weight) 761 if (op->weight)
762 { 762 {
763 check_spell_knockback (op); 763 check_spell_knockback (op);
764 764
… …
781 return; 781 return;
782 } 782 }
783 783
784 for (int i = -1; i <= 1; i++) 784 for (int i = -1; i <= 1; i++)
785 { 785 {
786 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)]; 786 sint16 x = op->x + DIRX (absdir (op->stats.sp + i)), y = op->y + DIRY (absdir (op->stats.sp + i));
787 787
788 if (ok_to_put_more (op->map, x, y, op, op->attacktype)) 788 if (ok_to_put_more (op->map, x, y, op, op->attacktype))
789 { 789 {
790 object *tmp = op->clone (); 790 object *tmp = op->clone ();
791 791
… …
864 d = 8; 864 d = 8;
865 else 865 else
866 continue; 866 continue;
867 } 867 }
868 868
869 x = op->x + freearr_x[d]; 869 x = op->x + DIRX (d);
870 y = op->y + freearr_y[d]; 870 y = op->y + DIRY (d);
871 871
872 if (get_map_flags (op->map, &m, x, y, &sx, &sy) & P_OUT_OF_MAP) 872 if (get_map_flags (op->map, &m, x, y, &sx, &sy) & P_OUT_OF_MAP)
873 continue; 873 continue;
874 874
875 if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype) 875 if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
… …
983 */ 983 */
984 if (archetype *at = archetype::find (SPLINT)) 984 if (archetype *at = archetype::find (SPLINT))
985 { 985 {
986 for (int i = 1; i < 9; i++) 986 for (int i = 1; i < 9; i++)
987 { 987 {
988 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i])) 988 if (out_of_map (op->map, op->x + DIRX (i), op->y + DIRX (i)))
989 continue; 989 continue;
990 990
991 object *tmp = at->instance (); 991 object *tmp = at->instance ();
992 tmp->direction = i; 992 tmp->direction = i;
993 tmp->range = op->range; 993 tmp->range = op->range;
… …
999 tmp->skill = op->skill; 999 tmp->skill = op->skill;
1000 1000
1001 if (tmp->flag [FLAG_IS_TURNABLE]) 1001 if (tmp->flag [FLAG_IS_TURNABLE])
1002 SET_ANIMATION (tmp, i); 1002 SET_ANIMATION (tmp, i);
1003 1003
1004 op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op); 1004 op->map->insert (tmp, op->x + DIRX (i), op->y + DIRX (i), op);
1005 move_bullet (tmp); 1005 move_bullet (tmp);
1006 } 1006 }
1007 } 1007 }
1008 1008
1009 explode_bullet (op); 1009 explode_bullet (op);
… …
1012int 1012int
1013create_bomb (object *op, object *caster, int dir, object *spell) 1013create_bomb (object *op, object *caster, int dir, object *spell)
1014{ 1014{
1015 object *tmp; 1015 object *tmp;
1016 int mflags; 1016 int mflags;
1017 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir]; 1017 sint16 dx = op->x + DIRX (dir), dy = op->y + DIRY (dir);
1018 maptile *m; 1018 maptile *m;
1019 1019
1020 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy); 1020 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
1021 1021
1022 // when creating a bomb below ourself it should always work, even 1022 // when creating a bomb below ourself it should always work, even
… …
1073 if (dir == 0) 1073 if (dir == 0)
1074 return NULL; 1074 return NULL;
1075 1075
1076 for (dist = 1; dist < range; dist++) 1076 for (dist = 1; dist < range; dist++)
1077 { 1077 {
1078 x = op->x + freearr_x[dir] * dist; 1078 x = op->x + DIRX (dir) * dist;
1079 y = op->y + freearr_y[dir] * dist; 1079 y = op->y + DIRY (dir) * dist;
1080 mp = op->map; 1080 mp = op->map;
1081 mflags = get_map_flags (op->map, &mp, x, y, &x, &y); 1081 mflags = get_map_flags (op->map, &mp, x, y, &x, &y);
1082 1082
1083 if (mflags & P_OUT_OF_MAP) 1083 if (mflags & P_OUT_OF_MAP)
1084 return NULL; 1084 return NULL;
… …
1096 } 1096 }
1097 1097
1098 return NULL; 1098 return NULL;
1099} 1099}
1100 1100
1101/* cast_smite_arch() - the priest points to a creature and causes 1101/* cast_smite_spell() - the priest points to a creature and causes
1102 * a 'godly curse' to decend. 1102 * a 'godly curse' to decend.
1103 * usual params - 1103 * usual params -
1104 * op = player 1104 * op = player
1105 * caster = object casting the spell. 1105 * caster = object casting the spell.
1106 * dir = direction being cast 1106 * dir = direction being cast
1107 * spell = spell object 1107 * spell = spell object
… …
1112 object *effect, *target; 1112 object *effect, *target;
1113 object *god = find_god (determine_god (op)); 1113 object *god = find_god (determine_god (op));
1114 1114
1115 target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA); 1115 target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA);
1116 1116
1117 /* Bunch of conditions for casting this spell. Note that only 1117 /* Bunch of conditions for casting this spell. Note that only
1118 * require a god if this is a cleric spell (requires grace). 1118 * require a god if this is a cleric spell (requires grace).
1119 * This makes this spell much more general purpose - it can be used 1119 * This makes this spell much more general purpose - it can be used
1120 * by wizards also, which is good, because I think this is a very 1120 * by wizards also, which is good, because I think this is a very
1121 * interesting spell. 1121 * interesting spell.
1122 * if it is a cleric spell, you need a god, and the creature 1122 * if it is a cleric spell, you need a god, and the creature
… …
1250/**************************************************************************** 1250/****************************************************************************
1251 * Destruction 1251 * Destruction
1252 ****************************************************************************/ 1252 ****************************************************************************/
1253 1253
1254/* make_object_glow() - currently only makes living objects glow. 1254/* make_object_glow() - currently only makes living objects glow.
1255 * we do this by creating a force and inserting it in the 1255 * we do this by creating a force and inserting it in the
1256 * object. if time is 0, the object glows permanently. To truely 1256 * object. if time is 0, the object glows permanently. To truely
1257 * make this work for non-living objects, we would have to 1257 * make this work for non-living objects, we would have to
1258 * give them the capability to have an inventory. b.t. 1258 * give them the capability to have an inventory. b.t.
1259 */ 1259 */
1260static int 1260static int
1261make_object_glow (object *op, int radius, int time) 1261make_object_glow (object *op, int radius, int time)
1262{ 1262{
… …
1621 * other bits (i / 2): absolute value of offset 1621 * other bits (i / 2): absolute value of offset
1622 */ 1622 */
1623 int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2); 1623 int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1624 int tmpdir = absdir (op->direction + offset); 1624 int tmpdir = absdir (op->direction + offset);
1625 1625
1626 nx = op->x + freearr_x[tmpdir]; 1626 nx = op->x + DIRX (tmpdir);
1627 ny = op->y + freearr_y[tmpdir]; 1627 ny = op->y + DIRY (tmpdir);
1628 if (!(get_map_flags (op->map, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 1628 if (!(get_map_flags (op->map, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, nx, ny))))
1629 { 1629 {
1630 dir = tmpdir; 1630 dir = tmpdir;
1631 break; 1631 break;
1632 } 1632 }
… …
1639 m = op->map; 1639 m = op->map;
1640 } 1640 }
1641 1641
1642 m->insert (op, nx, ny, op); 1642 m->insert (op, nx, ny, op);
1643 1643
1644 dam_save = op->stats.dam; /* save the original dam: we do halfdam on 1644 dam_save = op->stats.dam; /* save the original dam: we do halfdam on
1645 surrounding squares */ 1645 surrounding squares */
1646 1646
1647 /* loop over current square and neighbors to hit. 1647 /* loop over current square and neighbors to hit.
1648 * if this has an other_arch field, we insert that in 1648 * if this has an other_arch field, we insert that in
1649 * the surround spaces. 1649 * the surround spaces.
1650 */ 1650 */
1651 for (j = 0; j < 9; j++) 1651 for (j = 0; j < 9; j++)
1652 { 1652 {
1653 hx = nx + freearr_x[j]; 1653 hx = nx + DIRX (j);
1654 hy = ny + freearr_y[j]; 1654 hy = ny + DIRY (j);
1655 1655
1656 m = op->map; 1656 m = op->map;
1657 mflags = get_map_flags (m, &m, hx, hy, &hx, &hy); 1657 mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
1658 1658
1659 if (mflags & P_OUT_OF_MAP) 1659 if (mflags & P_OUT_OF_MAP)
… …
1682 i = spell_find_dir (op->map, op->x, op->y, op->owner); 1682 i = spell_find_dir (op->map, op->x, op->y, op->owner);
1683 1683
1684 if (i >= 0) 1684 if (i >= 0)
1685 { /* we have a preferred direction! */ 1685 { /* we have a preferred direction! */
1686 /* pick another direction if the preferred dir is blocked. */ 1686 /* pick another direction if the preferred dir is blocked. */
1687 if (get_map_flags (op->map, &m, nx + freearr_x[i], ny + freearr_y[i], &hx, &hy) & P_OUT_OF_MAP || 1687 if (get_map_flags (op->map, &m, nx + DIRX (i), ny + DIRY (i), &hx, &hy) & P_OUT_OF_MAP ||
1688 OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))) 1688 OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))
1689 i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */ 1689 i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */
1690 1690
1691 op->direction = i; 1691 op->direction = i;
1692 } 1692 }
1693} 1693}
1694 1694
1695/* move_swarm_spell: peterm 1695/* move_swarm_spell: peterm
1696 * This is an implementation of the swarm spell. It was written for 1696 * This is an implementation of the swarm spell. It was written for
1697 * meteor swarm, but it could be used for any swarm. A swarm spell 1697 * meteor swarm, but it could be used for any swarm. A swarm spell
1698 * is a special type of object that casts swarms of other types 1698 * is a special type of object that casts swarms of other types
1699 * of spells. Which spell it casts is flexible. It fires the spells 1699 * of spells. Which spell it casts is flexible. It fires the spells
1700 * from a set of squares surrounding the caster, in a given direction. 1700 * from a set of squares surrounding the caster, in a given direction.
1701 */ 1701 */
1702void 1702void
1703move_swarm_spell (object *op) 1703move_swarm_spell (object *op)
1704{ 1704{
1705#if 0 1705#if 0
… …
1741 // space. 1741 // space.
1742 // should be fixed later, but correctness before features... 1742 // should be fixed later, but correctness before features...
1743 // (schmorp) 1743 // (schmorp)
1744 1744
1745 /* new offset calculation to make swarm element distribution 1745 /* new offset calculation to make swarm element distribution
1746 * more uniform 1746 * more uniform
1747 */ 1747 */
1748 if (op->duration) 1748 if (op->duration)
1749 { 1749 {
1750 if (basedir & 1) 1750 if (basedir & 1)
1751 { 1751 {
… …
1759 else 1759 else
1760 { 1760 {
1761 adjustdir = 0; /* fire the last one from forward. */ 1761 adjustdir = 0; /* fire the last one from forward. */
1762 } 1762 }
1763 1763
1764 target_x = op->x + freearr_x[absdir (basedir + adjustdir)]; 1764 target_x = op->x + DIRX (absdir (basedir + adjustdir));
1765 target_y = op->y + freearr_y[absdir (basedir + adjustdir)]; 1765 target_y = op->y + DIRY (absdir (basedir + adjustdir));
1766 1766
1767 /* back up one space so we can hit point-blank targets, but this 1767 /* back up one space so we can hit point-blank targets, but this
1768 * necessitates extra out_of_map check below 1768 * necessitates extra out_of_map check below
1769 */ 1769 */
1770 origin_x = target_x - freearr_x[basedir]; 1770 origin_x = target_x - DIRX (basedir);
1771 origin_y = target_y - freearr_y[basedir]; 1771 origin_y = target_y - DIRY (basedir);
1772 1772
1773 1773
1774 /* spell pointer is set up for the spell this casts. Since this 1774 /* spell pointer is set up for the spell this casts. Since this
1775 * should just be a pointer to the spell in some inventory, 1775 * should just be a pointer to the spell in some inventory,
1776 * it is unlikely to disappear by the time we need it. However, 1776 * it is unlikely to disappear by the time we need it. However,
… …
1807} 1807}
1808 1808
1809/* fire_swarm: 1809/* fire_swarm:
1810 * The following routine creates a swarm of objects. It actually 1810 * The following routine creates a swarm of objects. It actually
1811 * sets up a specific swarm object, which then fires off all 1811 * sets up a specific swarm object, which then fires off all
1812 * the parts of the swarm. 1812 * the parts of the swarm.
1813 * 1813 *
1814 * op: the owner 1814 * op: the owner
1815 * caster: the caster (owner, wand, rod, scroll) 1815 * caster: the caster (owner, wand, rod, scroll)
1816 * dir: the direction everything will be fired in 1816 * dir: the direction everything will be fired in
1817 * spell - the spell that is this spell. 1817 * spell - the spell that is this spell.
… …
1862 1862
1863 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1863 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1864 1864
1865 if (dir) 1865 if (dir)
1866 { 1866 {
1867 x = op->x + freearr_x[dir]; 1867 x = op->x + DIRX (dir);
1868 y = op->y + freearr_y[dir]; 1868 y = op->y + DIRY (dir);
1869 m = op->map; 1869 m = op->map;
1870 1870
1871 mflags = get_map_flags (m, &m, x, y, &x, &y); 1871 mflags = get_map_flags (m, &m, x, y, &x, &y);
1872 1872
1873 if (mflags & P_OUT_OF_MAP) 1873 if (mflags & P_OUT_OF_MAP)
… …
1920 1920
1921 return 1; 1921 return 1;
1922} 1922}
1923 1923
1924/* cast_cause_disease: this spell looks along <dir> from the 1924/* cast_cause_disease: this spell looks along <dir> from the
1925 * player and infects someone. 1925 * player and infects someone.
1926 * op is the player/monster, caster is the object, dir is the direction 1926 * op is the player/monster, caster is the object, dir is the direction
1927 * to cast, disease_arch is the specific disease, and type is the spell number 1927 * to cast, disease_arch is the specific disease, and type is the spell number
1928 * perhaps this should actually be in disease.c? 1928 * perhaps this should actually be in disease.c?
1929 */ 1929 */
1930int 1930int
… …
1936 maptile *m; 1936 maptile *m;
1937 1937
1938 x = op->x; 1938 x = op->x;
1939 y = op->y; 1939 y = op->y;
1940 1940
1941 /* If casting from a scroll, no direction will be available, so refer to the 1941 /* If casting from a scroll, no direction will be available, so refer to the
1942 * direction the player is pointing. 1942 * direction the player is pointing.
1943 */ 1943 */
1944 if (!dir) 1944 if (!dir)
1945 dir = op->facing; 1945 dir = op->facing;
1946 1946
… …
1953 dur_mod = SP_level_duration_adjust (caster, spell); 1953 dur_mod = SP_level_duration_adjust (caster, spell);
1954 1954
1955 /* search in a line for a victim */ 1955 /* search in a line for a victim */
1956 for (i = 1; i < range; i++) 1956 for (i = 1; i < range; i++)
1957 { 1957 {
1958 x = op->x + i * freearr_x[dir]; 1958 x = op->x + i * DIRX (dir);
1959 y = op->y + i * freearr_y[dir]; 1959 y = op->y + i * DIRY (dir);
1960 m = op->map; 1960 m = op->map;
1961 1961
1962 mflags = get_map_flags (m, &m, x, y, &x, &y); 1962 mflags = get_map_flags (m, &m, x, y, &x, &y);
1963 1963
1964 if (mflags & P_OUT_OF_MAP) 1964 if (mflags & P_OUT_OF_MAP)
… …
1994 1994
1995 if (disease->last_sp < 1) 1995 if (disease->last_sp < 1)
1996 disease->last_sp = 1; 1996 disease->last_sp = 1;
1997 } 1997 }
1998 1998
1999 if (disease->stats.dam ) disease->stats.dam += copysign (disease->stats.dam , dam_mod); 1999 if (disease->stats.dam ) disease->stats.dam += copysignl (disease->stats.dam , dam_mod);
2000 if (disease->stats.maxsp) disease->stats.maxsp += copysign (disease->stats.maxsp, dam_mod); 2000 if (disease->stats.maxsp) disease->stats.maxsp += copysignl (disease->stats.maxsp, dam_mod);
2001 if (disease->stats.ac ) disease->stats.ac += dam_mod; 2001 if (disease->stats.ac ) disease->stats.ac += dam_mod;
2002 if (disease->last_eat ) disease->last_eat -= dam_mod; 2002 if (disease->last_eat ) disease->last_eat -= dam_mod;
2003 if (disease->stats.hp ) disease->stats.hp -= dam_mod; 2003 if (disease->stats.hp ) disease->stats.hp -= dam_mod;
2004 if (disease->stats.sp ) disease->stats.sp -= dam_mod; 2004 if (disease->stats.sp ) disease->stats.sp -= dam_mod;
2005 2005

Diff Legend

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