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

Diff Legend

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