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.54 by root, Wed Apr 30 10:31:04 2008 UTC vs.
Revision 1.58 by root, Sat May 17 14:57:23 2008 UTC

… …
36/* this function checks to see if a spell pushes objects as well 36/* this function checks to see if a spell pushes objects as well
37 * as flies over and damages them (only used for cones for now) 37 * as flies over and damages them (only used for cones for now)
38 * but moved here so it could be applied to bolts too 38 * but moved here so it could be applied to bolts too
39 * op is the spell object. 39 * op is the spell object.
40 */ 40 */
41
42void 41void
43check_spell_knockback (object *op) 42check_spell_knockback (object *op)
44{ 43{
45 object *tmp, *tmp2; /* object on the map */
46 int weight_move; 44 int weight_move;
47 int frictionmod = 2; /*poor man's physics - multipy targets weight by this amount */ 45 int frictionmod = 2; /*poor man's physics - multipy targets weight by this amount */
48 46
49 if (!op->weight) 47 if (!op->weight)
50 { /*shouldn't happen but if cone object has no weight drop out */ 48 { /*shouldn't happen but if cone object has no weight drop out */
… …
55 { 53 {
56 weight_move = op->weight + (op->weight * op->level) / 3; 54 weight_move = op->weight + (op->weight * op->level) / 3;
57 /*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */ 55 /*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */
58 } 56 }
59 57
60 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 58 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
61 { 59 {
62 int num_sections = 1; 60 int num_sections = 1;
63 61
64 /* don't move DM */ 62 /* don't move DM */
65 if (QUERY_FLAG (tmp, FLAG_WIZ)) 63 if (QUERY_FLAG (tmp, FLAG_WIZ))
… …
72 /* don't move floors or immobile objects */ 70 /* don't move floors or immobile objects */
73 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK))) 71 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))
74 continue; 72 continue;
75 73
76 /* count the object's sections */ 74 /* count the object's sections */
77 for (tmp2 = tmp; tmp2 != NULL; tmp2 = tmp2->more) 75 for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
78 num_sections++; 76 num_sections++;
79 77
80 /* I'm not sure if it makes sense to divide by num_sections - bigger 78 /* I'm not sure if it makes sense to divide by num_sections - bigger
81 * objects should be harder to move, and we are moving the entire 79 * objects should be harder to move, and we are moving the entire
82 * object, not just the head, so the total weight should be relevant. 80 * object, not just the head, so the total weight should be relevant.
… …
106 * 104 *
107 * BOLT CODE 105 * BOLT CODE
108 * 106 *
109 ***************************************************************************/ 107 ***************************************************************************/
110 108
111/* Causes op to fork. op is the original bolt, tmp 109/* Causes op to fork. op is the original bolt, tmp
112 * is the first piece of the fork. 110 * is the first piece of the fork.
113 */ 111 */
114
115void 112void
116forklightning (object *op, object *tmp) 113forklightning (object *op, object *tmp)
117{ 114{
118 int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */ 115 int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */
119 int t_dir; /* stores temporary dir calculation */ 116 int t_dir; /* stores temporary dir calculation */
… …
158} 155}
159 156
160/* move_bolt: moves bolt 'op'. Basically, it just advances a space, 157/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
161 * and checks for various things that may stop it. 158 * and checks for various things that may stop it.
162 */ 159 */
163
164void 160void
165move_bolt (object *op) 161move_bolt (object *op)
166{ 162{
167 int mflags; 163 int mflags;
168 sint16 x, y; 164 sint16 x, y;
… …
251 tmp->duration++; 247 tmp->duration++;
252 248
253 /* New forking code. Possibly create forks of this object 249 /* New forking code. Possibly create forks of this object
254 * going off in other directions. 250 * going off in other directions.
255 */ 251 */
256 if (rndm (0, 99) < tmp->stats.Dex) 252 if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
257 { /* stats.Dex % of forking */ 253 forklightning (op, tmp); /* stats.Dex % of forking */
258 forklightning (op, tmp);
259 }
260 254
261 /* In this way, the object left behind sticks on the space, but 255 /* In this way, the object left behind sticks on the space, but
262 * doesn't create any bolts that continue to move onward. 256 * doesn't create any bolts that continue to move onward.
263 */ 257 */
264 op->range = 0; 258 op->range = 0;
… …
288 return 0; 282 return 0;
289 283
290 /* peterm: level dependency for bolts */ 284 /* peterm: level dependency for bolts */
291 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob); 285 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
292 tmp->attacktype = spob->attacktype; 286 tmp->attacktype = spob->attacktype;
287
293 if (spob->slaying) 288 if (spob->slaying)
294 tmp->slaying = spob->slaying; 289 tmp->slaying = spob->slaying;
290
295 tmp->range = spob->range + SP_level_range_adjust (caster, spob); 291 tmp->range = spob->range + SP_level_range_adjust (caster, spob);
296 tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob); 292 tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
297 tmp->stats.Dex = spob->stats.Dex; 293 tmp->stats.Dex = spob->stats.Dex;
298 tmp->stats.Con = spob->stats.Con; 294 tmp->stats.Con = spob->stats.Con;
299 295
… …
435 } 431 }
436 432
437 if (op->attacktype) 433 if (op->attacktype)
438 { 434 {
439 hit_map (op, 0, op->attacktype, 1); 435 hit_map (op, 0, op->attacktype, 1);
436
440 if (op->destroyed ()) 437 if (op->destroyed ())
441 return; 438 return;
442 } 439 }
443 440
444 /* other_arch contains what this explodes into */ 441 /* other_arch contains what this explodes into */
… …
522 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 519 for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
523 { 520 {
524 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 521 if (QUERY_FLAG (tmp, FLAG_ALIVE))
525 { 522 {
526 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 523 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
524
527 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0) 525 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
528 { 526 {
529 if (!QUERY_FLAG (op, FLAG_REMOVED)) 527 if (!QUERY_FLAG (op, FLAG_REMOVED))
530 { 528 {
531 op->destroy (); 529 op->destroy ();
… …
620 int mflags; 618 int mflags;
621 619
622 if (!spob->other_arch) 620 if (!spob->other_arch)
623 return 0; 621 return 0;
624 622
625 tmp = arch_to_object (spob->other_arch); 623 tmp = spob->other_arch->instance ();
626 if (tmp == NULL) 624 if (!tmp)
627 return 0; 625 return 0;
628 626
629 /* peterm: level dependency for bolts */ 627 /* peterm: level dependency for bolts */
630 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob); 628 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
631 tmp->attacktype = spob->attacktype; 629 tmp->attacktype = spob->attacktype;
632 if (spob->slaying) 630 if (spob->slaying)
633 tmp->slaying = spob->slaying; 631 tmp->slaying = spob->slaying;
634 632
… …
644 SET_ANIMATION (tmp, dir); 642 SET_ANIMATION (tmp, dir);
645 643
646 tmp->set_owner (op); 644 tmp->set_owner (op);
647 set_spell_skill (op, caster, spob, tmp); 645 set_spell_skill (op, caster, spob, tmp);
648 646
649 tmp->x = op->x + freearr_x[dir]; 647 tmp->x = op->x + freearr_x[dir];
650 tmp->y = op->y + freearr_y[dir]; 648 tmp->y = op->y + freearr_y[dir];
651 tmp->map = op->map; 649 tmp->map = op->map;
652 650
653 maptile *newmap; 651 maptile *newmap;
654 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y); 652 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
655 if (mflags & P_OUT_OF_MAP) 653 if (mflags & P_OUT_OF_MAP)
… …
705/* move_cone: causes cone object 'op' to move a space/hit creatures */ 703/* move_cone: causes cone object 'op' to move a space/hit creatures */
706 704
707void 705void
708move_cone (object *op) 706move_cone (object *op)
709{ 707{
710 int i;
711
712 /* if no map then hit_map will crash so just ignore object */ 708 /* if no map then hit_map will crash so just ignore object */
713 if (!op->map) 709 if (!op->map)
714 { 710 {
715 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown"); 711 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
716 op->set_speed (0); 712 op->set_speed (0);
… …
761 { 757 {
762 op->range = 0; /* just so it doesn't wrap */ 758 op->range = 0; /* just so it doesn't wrap */
763 return; 759 return;
764 } 760 }
765 761
766 for (i = -1; i < 2; i++) 762 for (int i = -1; i <= 1; i++)
767 { 763 {
768 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)]; 764 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
769 765
770 if (ok_to_put_more (op->map, x, y, op, op->attacktype)) 766 if (ok_to_put_more (op->map, x, y, op, op->attacktype))
771 { 767 {
… …
1180 1176
1181/* op is a missile that needs to be moved */ 1177/* op is a missile that needs to be moved */
1182void 1178void
1183move_missile (object *op) 1179move_missile (object *op)
1184{ 1180{
1185 int i, mflags;
1186 object *owner;
1187 sint16 new_x, new_y;
1188 maptile *m;
1189
1190 if (op->range-- <= 0) 1181 if (op->range-- <= 0)
1191 { 1182 {
1192 op->destroy (); 1183 op->destroy ();
1193 return; 1184 return;
1194 } 1185 }
1195 1186
1196 owner = op->owner; 1187 mapxy pos (op);
1197#if 0 1188 pos.move (op->direction);
1198 /* It'd make things nastier if this wasn't here - spells cast by 1189
1199 * monster that are then killed would continue to survive 1190 if (!pos.normalise ())
1200 */
1201 if (owner == NULL)
1202 { 1191 {
1203 op->destroy (); 1192 op->destroy ();
1204 return; 1193 return;
1205 } 1194 }
1206#endif
1207 1195
1208 new_x = op->x + DIRX (op); 1196 mapspace &ms = pos.ms ();
1209 new_y = op->y + DIRY (op);
1210 1197
1211 mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y); 1198 if (ms.flags () & P_IS_ALIVE || ms.blocks (op))
1212
1213 if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1214 { 1199 {
1215 hit_map (op, op->direction, AT_MAGIC, 1); 1200 hit_map (op, op->direction, AT_MAGIC, 1);
1216 /* Basically, missile only hits one thing then goes away. 1201 /* Basically, missile only hits one thing then goes away.
1217 * we need to remove it if someone hasn't already done so. 1202 * we need to remove it if someone hasn't already done so.
1218 */ 1203 */
1219 if (!op->destroyed ())
1220 op->destroy ();
1221
1222 return;
1223 }
1224
1225 op->remove ();
1226
1227 if (!op->direction || (mflags & P_OUT_OF_MAP))
1228 {
1229 op->destroy (); 1204 op->destroy ();
1230 return; 1205 return;
1231 } 1206 }
1232 1207
1208 if (!op->direction)
1209 {
1210 op->destroy ();
1211 return;
1212 }
1213
1233 i = spell_find_dir (m, new_x, new_y, op->owner); 1214 int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1234 if (i > 0 && i != op->direction) 1215 if (i > 0 && i != op->direction)
1235 { 1216 {
1236 op->direction = i; 1217 op->direction = i;
1237 SET_ANIMATION (op, op->direction); 1218 SET_ANIMATION (op, op->direction);
1238 } 1219 }
1239 1220
1240 m->insert (op, new_x, new_y, op); 1221 pos.insert (op, op);
1241} 1222}
1242 1223
1243/**************************************************************************** 1224/****************************************************************************
1244 * Destruction 1225 * Destruction
1245 ****************************************************************************/ 1226 ****************************************************************************/
… …
1302 else 1283 else
1303 op->skill = NULL; 1284 op->skill = NULL;
1304 1285
1305 op->change_skill (find_skill_by_name (op, op->skill)); 1286 op->change_skill (find_skill_by_name (op, op->skill));
1306 1287
1307 for (i = -range; i < range; i++) 1288 for (i = -range; i <= range; i++)
1308 { 1289 {
1309 for (j = -range; j < range; j++) 1290 for (j = -range; j <= range; j++)
1310 { 1291 {
1311 m = op->map; 1292 m = op->map;
1312 sx = op->x + i; 1293 sx = op->x + i;
1313 sy = op->y + j; 1294 sy = op->y + j;
1314 1295
… …
1331 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER))) 1312 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))
1332 { 1313 {
1333 if (spell_ob->subtype == SP_DESTRUCTION) 1314 if (spell_ob->subtype == SP_DESTRUCTION)
1334 { 1315 {
1335 hit_player (tmp, dam, op, spell_ob->attacktype, 0); 1316 hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1317
1336 if (spell_ob->other_arch) 1318 if (spell_ob->other_arch)
1337 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op); 1319 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);
1338 } 1320 }
1339 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100) 1321 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)
1340 { 1322 {
… …
1704 1686
1705 if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op))) 1687 if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))
1706 { 1688 {
1707 if (j) 1689 if (j)
1708 op->stats.dam = dam_save / 2; 1690 op->stats.dam = dam_save / 2;
1691
1709 hit_map (op, j, op->attacktype, 1); 1692 hit_map (op, j, op->attacktype, 1);
1710
1711 } 1693 }
1712 1694
1713 /* insert the other arch */ 1695 /* insert the other arch */
1714 if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))) 1696 if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1715 m->insert (arch_to_object (op->other_arch), hx, hy, op); 1697 m->insert (arch_to_object (op->other_arch), hx, hy, op);
… …
1729 1711
1730 op->direction = i; 1712 op->direction = i;
1731 } 1713 }
1732} 1714}
1733 1715
1734
1735/* move_swarm_spell: peterm 1716/* move_swarm_spell: peterm
1736 * This is an implementation of the swarm spell. It was written for 1717 * This is an implementation of the swarm spell. It was written for
1737 * meteor swarm, but it could be used for any swarm. A swarm spell 1718 * meteor swarm, but it could be used for any swarm. A swarm spell
1738 * is a special type of object that casts swarms of other types 1719 * is a special type of object that casts swarms of other types
1739 * of spells. Which spell it casts is flexible. It fires the spells 1720 * of spells. Which spell it casts is flexible. It fires the spells
1740 * from a set of squares surrounding the caster, in a given direction. 1721 * from a set of squares surrounding the caster, in a given direction.
1741 */ 1722 */
1742
1743void 1723void
1744move_swarm_spell (object *op) 1724move_swarm_spell (object *op)
1745{ 1725{
1746#if 0 1726#if 0
1747 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 }; 1727 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1748 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 }; 1728 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1749 sint16 target_x, target_y, origin_x, origin_y; 1729 sint16 target_x, target_y, origin_x, origin_y;
1750 int adjustdir; 1730 int adjustdir;
1751 maptile *m; 1731 maptile *m;
1752#endif 1732#endif
1753 int basedir;
1754 object *owner; 1733 object *owner = op->env;
1755 1734
1756 owner = op->owner; 1735 if (!op->duration || !owner->is_on_map ())
1757 if (op->duration == 0 || owner == NULL)
1758 { 1736 {
1759 op->destroy (); 1737 op->destroy ();
1760 return; 1738 return;
1761 } 1739 }
1762 1740
1763 op->duration--; 1741 op->duration--;
1764 1742
1765 basedir = op->direction; 1743 int basedir = op->direction;
1766 if (basedir == 0) 1744 if (!basedir)
1767 {
1768 /* spray in all directions! 8) */ 1745 /* spray in all directions! 8) */
1769 basedir = rndm (1, 8); 1746 basedir = (op->facing += op->state) % 8 + 1;
1770 }
1771 1747
1772#if 0 1748#if 0
1773 // this is bogus: it causes wrong places to be checked below 1749 // this is bogus: it causes wrong places to be checked below
1774 // (a wall 2 cells away will block the effect...) and 1750 // (a wall 2 cells away will block the effect...) and
1775 // doesn't work for SP_BULLET anyhow, so again tests the wrong 1751 // doesn't work for SP_BULLET anyhow, so again tests the wrong
… …
1835 { 1811 {
1836 /* Bullet spells have a bunch more customization that needs to be done */ 1812 /* Bullet spells have a bunch more customization that needs to be done */
1837 if (op->spell->subtype == SP_BULLET) 1813 if (op->spell->subtype == SP_BULLET)
1838 fire_bullet (owner, op, basedir, op->spell); 1814 fire_bullet (owner, op, basedir, op->spell);
1839 else if (op->spell->subtype == SP_MAGIC_MISSILE) 1815 else if (op->spell->subtype == SP_MAGIC_MISSILE)
1840 fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell); 1816 fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
1841 } 1817 }
1842} 1818}
1843
1844
1845
1846 1819
1847/* fire_swarm: 1820/* fire_swarm:
1848 * The following routine creates a swarm of objects. It actually 1821 * The following routine creates a swarm of objects. It actually
1849 * sets up a specific swarm object, which then fires off all 1822 * sets up a specific swarm object, which then fires off all
1850 * the parts of the swarm. 1823 * the parts of the swarm.
… …
1853 * caster: the caster (owner, wand, rod, scroll) 1826 * caster: the caster (owner, wand, rod, scroll)
1854 * dir: the direction everything will be fired in 1827 * dir: the direction everything will be fired in
1855 * spell - the spell that is this spell. 1828 * spell - the spell that is this spell.
1856 * n: the number to be fired. 1829 * n: the number to be fired.
1857 */ 1830 */
1858
1859int 1831int
1860fire_swarm (object *op, object *caster, object *spell, int dir) 1832fire_swarm (object *op, object *caster, object *spell, int dir)
1861{ 1833{
1862 object *tmp;
1863 int i;
1864
1865 if (!spell->other_arch) 1834 if (!spell->other_arch)
1866 return 0; 1835 return 0;
1867 1836
1868 tmp = get_archetype (SWARM_SPELL); 1837 object *tmp = archetype::get (SWARM_SPELL);
1869 tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */
1870 set_spell_skill (op, caster, spell, tmp); 1838 set_spell_skill (op, caster, spell, tmp);
1871
1872 tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */ 1839 tmp->level = caster_level (caster, spell); /* needed later, to get level dep. right. */
1873 tmp->spell = arch_to_object (spell->other_arch); 1840 tmp->spell = spell->other_arch->instance ();
1874
1875 tmp->attacktype = tmp->spell->attacktype; 1841 tmp->attacktype = tmp->spell->attacktype;
1876 1842
1877 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) 1843 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1878 if (!tailor_god_spell (tmp, op)) 1844 if (!tailor_god_spell (tmp, op))
1879 return 1; 1845 return 1;
1880 1846
1881 tmp->duration = SP_level_duration_adjust (caster, spell); 1847 tmp->duration = SP_level_duration_adjust (caster, spell);
1882 for (i = 0; i < spell->duration; i++) 1848 for (int i = 0; i < spell->duration; i++)
1883 tmp->duration += die_roll (1, 3, op, PREFER_HIGH); 1849 tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1884 1850
1885 tmp->direction = dir; 1851 tmp->direction = dir;
1886 tmp->invisible = 1; 1852 tmp->invisible = 1;
1853 tmp->facing = rndm (1, 8); // initial firing direction
1854 tmp->state = rndm (4) * 2 + 1; // direction increment
1887 1855
1888 tmp->insert_at (op, op); 1856 op->insert (tmp);
1857
1889 return 1; 1858 return 1;
1890} 1859}
1891
1892 1860
1893/* See the spells documentation file for why this is its own 1861/* See the spells documentation file for why this is its own
1894 * function. 1862 * function.
1895 */ 1863 */
1896int 1864int
… …
1927 if (QUERY_FLAG (target, FLAG_MONSTER)) 1895 if (QUERY_FLAG (target, FLAG_MONSTER))
1928 { 1896 {
1929 /* oky doky. got a target monster. Lets make a blinding attack */ 1897 /* oky doky. got a target monster. Lets make a blinding attack */
1930 if (target->head) 1898 if (target->head)
1931 target = target->head; 1899 target = target->head;
1900
1932 (void) hit_player (target, dam, op, spell->attacktype, 1); 1901 hit_player (target, dam, op, spell->attacktype, 1);
1933 return 1; /* one success only! */ 1902 return 1; /* one success only! */
1934 } 1903 }
1935 } 1904 }
1936 1905
1937 /* no live target, perhaps a wall is in the way? */ 1906 /* no live target, perhaps a wall is in the way? */

Diff Legend

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