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.62 by root, Mon Jul 14 00:04:57 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 */
… …
151 new_bolt->duration++; 148 new_bolt->duration++;
152 new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */ 149 new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
153 new_bolt->stats.dam++; 150 new_bolt->stats.dam++;
154 tmp->stats.dam /= 2; /* reduce father bolt damage */ 151 tmp->stats.dam /= 2; /* reduce father bolt damage */
155 tmp->stats.dam++; 152 tmp->stats.dam++;
153
156 if ((new_bolt = m->insert (new_bolt, sx, sy, op))) 154 if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
157 update_turn_face (new_bolt); 155 update_turn_face (new_bolt);
158} 156}
159 157
160/* move_bolt: moves bolt 'op'. Basically, it just advances a space, 158/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
161 * and checks for various things that may stop it. 159 * and checks for various things that may stop it.
162 */ 160 */
163
164void 161void
165move_bolt (object *op) 162move_bolt (object *op)
166{ 163{
167 int mflags; 164 int mflags;
168 sint16 x, y; 165 sint16 x, y;
… …
251 tmp->duration++; 248 tmp->duration++;
252 249
253 /* New forking code. Possibly create forks of this object 250 /* New forking code. Possibly create forks of this object
254 * going off in other directions. 251 * going off in other directions.
255 */ 252 */
256 if (rndm (0, 99) < tmp->stats.Dex) 253 if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
257 { /* stats.Dex % of forking */ 254 forklightning (op, tmp); /* stats.Dex % of forking */
258 forklightning (op, tmp);
259 }
260 255
261 /* In this way, the object left behind sticks on the space, but 256 /* In this way, the object left behind sticks on the space, but
262 * doesn't create any bolts that continue to move onward. 257 * doesn't create any bolts that continue to move onward.
263 */ 258 */
264 op->range = 0; 259 op->range = 0;
… …
288 return 0; 283 return 0;
289 284
290 /* peterm: level dependency for bolts */ 285 /* peterm: level dependency for bolts */
291 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob); 286 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
292 tmp->attacktype = spob->attacktype; 287 tmp->attacktype = spob->attacktype;
288
293 if (spob->slaying) 289 if (spob->slaying)
294 tmp->slaying = spob->slaying; 290 tmp->slaying = spob->slaying;
291
295 tmp->range = spob->range + SP_level_range_adjust (caster, spob); 292 tmp->range = spob->range + SP_level_range_adjust (caster, spob);
296 tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob); 293 tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
297 tmp->stats.Dex = spob->stats.Dex; 294 tmp->stats.Dex = spob->stats.Dex;
298 tmp->stats.Con = spob->stats.Con; 295 tmp->stats.Con = spob->stats.Con;
299 296
… …
435 } 432 }
436 433
437 if (op->attacktype) 434 if (op->attacktype)
438 { 435 {
439 hit_map (op, 0, op->attacktype, 1); 436 hit_map (op, 0, op->attacktype, 1);
437
440 if (op->destroyed ()) 438 if (op->destroyed ())
441 return; 439 return;
442 } 440 }
443 441
444 /* other_arch contains what this explodes into */ 442 /* other_arch contains what this explodes into */
… …
522 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 520 for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
523 { 521 {
524 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 522 if (QUERY_FLAG (tmp, FLAG_ALIVE))
525 { 523 {
526 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 524 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
525
527 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0) 526 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
528 { 527 {
529 if (!QUERY_FLAG (op, FLAG_REMOVED)) 528 if (!QUERY_FLAG (op, FLAG_REMOVED))
530 { 529 {
531 op->destroy (); 530 op->destroy ();
… …
620 int mflags; 619 int mflags;
621 620
622 if (!spob->other_arch) 621 if (!spob->other_arch)
623 return 0; 622 return 0;
624 623
625 tmp = arch_to_object (spob->other_arch); 624 tmp = spob->other_arch->instance ();
626 if (tmp == NULL) 625 if (!tmp)
627 return 0; 626 return 0;
628 627
629 /* peterm: level dependency for bolts */ 628 /* peterm: level dependency for bolts */
630 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob); 629 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
631 tmp->attacktype = spob->attacktype; 630 tmp->attacktype = spob->attacktype;
632 if (spob->slaying) 631 if (spob->slaying)
633 tmp->slaying = spob->slaying; 632 tmp->slaying = spob->slaying;
634 633
… …
644 SET_ANIMATION (tmp, dir); 643 SET_ANIMATION (tmp, dir);
645 644
646 tmp->set_owner (op); 645 tmp->set_owner (op);
647 set_spell_skill (op, caster, spob, tmp); 646 set_spell_skill (op, caster, spob, tmp);
648 647
649 tmp->x = op->x + freearr_x[dir]; 648 tmp->x = op->x + freearr_x[dir];
650 tmp->y = op->y + freearr_y[dir]; 649 tmp->y = op->y + freearr_y[dir];
651 tmp->map = op->map; 650 tmp->map = op->map;
652 651
653 maptile *newmap; 652 maptile *newmap;
654 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y); 653 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
655 if (mflags & P_OUT_OF_MAP) 654 if (mflags & P_OUT_OF_MAP)
… …
705/* move_cone: causes cone object 'op' to move a space/hit creatures */ 704/* move_cone: causes cone object 'op' to move a space/hit creatures */
706 705
707void 706void
708move_cone (object *op) 707move_cone (object *op)
709{ 708{
710 int i;
711
712 /* if no map then hit_map will crash so just ignore object */ 709 /* if no map then hit_map will crash so just ignore object */
713 if (!op->map) 710 if (!op->map)
714 { 711 {
715 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown"); 712 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
716 op->set_speed (0); 713 op->set_speed (0);
… …
746 check_spell_knockback (op); 743 check_spell_knockback (op);
747 744
748 if (op->destroyed ()) 745 if (op->destroyed ())
749 return; 746 return;
750 747
751 if ((op->duration--) < 0) 748 if (op->duration-- < 0)
752 { 749 {
753 op->destroy (); 750 op->destroy ();
754 return; 751 return;
755 } 752 }
756 /* Object has hit maximum range, so don't have it move 753 /* Object has hit maximum range, so don't have it move
… …
761 { 758 {
762 op->range = 0; /* just so it doesn't wrap */ 759 op->range = 0; /* just so it doesn't wrap */
763 return; 760 return;
764 } 761 }
765 762
766 for (i = -1; i < 2; i++) 763 for (int i = -1; i <= 1; i++)
767 { 764 {
768 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)]; 765 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
769 766
770 if (ok_to_put_more (op->map, x, y, op, op->attacktype)) 767 if (ok_to_put_more (op->map, x, y, op, op->attacktype))
771 { 768 {
… …
1180 1177
1181/* op is a missile that needs to be moved */ 1178/* op is a missile that needs to be moved */
1182void 1179void
1183move_missile (object *op) 1180move_missile (object *op)
1184{ 1181{
1185 int i, mflags;
1186 object *owner;
1187 sint16 new_x, new_y;
1188 maptile *m;
1189
1190 if (op->range-- <= 0) 1182 if (op->range-- <= 0)
1191 { 1183 {
1192 op->destroy (); 1184 op->destroy ();
1193 return; 1185 return;
1194 } 1186 }
1195 1187
1196 owner = op->owner; 1188 mapxy pos (op);
1197#if 0 1189 pos.move (op->direction);
1198 /* It'd make things nastier if this wasn't here - spells cast by 1190
1199 * monster that are then killed would continue to survive 1191 if (!pos.normalise ())
1200 */
1201 if (owner == NULL)
1202 { 1192 {
1203 op->destroy (); 1193 op->destroy ();
1204 return; 1194 return;
1205 } 1195 }
1206#endif
1207 1196
1208 new_x = op->x + DIRX (op); 1197 mapspace &ms = pos.ms ();
1209 new_y = op->y + DIRY (op);
1210 1198
1211 mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y); 1199 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 { 1200 {
1215 hit_map (op, op->direction, AT_MAGIC, 1); 1201 hit_map (op, op->direction, AT_MAGIC, 1);
1216 /* Basically, missile only hits one thing then goes away. 1202 /* Basically, missile only hits one thing then goes away.
1217 * we need to remove it if someone hasn't already done so. 1203 * we need to remove it if someone hasn't already done so.
1218 */ 1204 */
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 (); 1205 op->destroy ();
1230 return; 1206 return;
1231 } 1207 }
1232 1208
1209 if (!op->direction)
1210 {
1211 op->destroy ();
1212 return;
1213 }
1214
1233 i = spell_find_dir (m, new_x, new_y, op->owner); 1215 int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1234 if (i > 0 && i != op->direction) 1216 if (i > 0 && i != op->direction)
1235 { 1217 {
1236 op->direction = i; 1218 op->direction = i;
1237 SET_ANIMATION (op, op->direction); 1219 SET_ANIMATION (op, op->direction);
1238 } 1220 }
1239 1221
1240 m->insert (op, new_x, new_y, op); 1222 pos.insert (op, op);
1241} 1223}
1242 1224
1243/**************************************************************************** 1225/****************************************************************************
1244 * Destruction 1226 * Destruction
1245 ****************************************************************************/ 1227 ****************************************************************************/
… …
1302 else 1284 else
1303 op->skill = NULL; 1285 op->skill = NULL;
1304 1286
1305 op->change_skill (find_skill_by_name (op, op->skill)); 1287 op->change_skill (find_skill_by_name (op, op->skill));
1306 1288
1307 for (i = -range; i < range; i++) 1289 for (i = -range; i <= range; i++)
1308 { 1290 {
1309 for (j = -range; j < range; j++) 1291 for (j = -range; j <= range; j++)
1310 { 1292 {
1311 m = op->map; 1293 m = op->map;
1312 sx = op->x + i; 1294 sx = op->x + i;
1313 sy = op->y + j; 1295 sy = op->y + j;
1314 1296
… …
1331 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER))) 1313 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))
1332 { 1314 {
1333 if (spell_ob->subtype == SP_DESTRUCTION) 1315 if (spell_ob->subtype == SP_DESTRUCTION)
1334 { 1316 {
1335 hit_player (tmp, dam, op, spell_ob->attacktype, 0); 1317 hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1318
1336 if (spell_ob->other_arch) 1319 if (spell_ob->other_arch)
1337 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op); 1320 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);
1338 } 1321 }
1339 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100) 1322 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)
1340 { 1323 {
… …
1628 * about. was called move_ball_lightning, but since more than the ball 1611 * about. was called move_ball_lightning, but since more than the ball
1629 * lightning spell used it, that seemed misnamed. 1612 * lightning spell used it, that seemed misnamed.
1630 * op is the spell effect. 1613 * op is the spell effect.
1631 * note that duration is handled by process_object() in time.c 1614 * note that duration is handled by process_object() in time.c
1632 */ 1615 */
1633
1634void 1616void
1635move_ball_spell (object *op) 1617move_ball_spell (object *op)
1636{ 1618{
1637 int i, j, dam_save, dir, mflags; 1619 int i, j, dam_save, dir, mflags;
1638 sint16 nx, ny, hx, hy; 1620 sint16 nx, ny, hx, hy;
… …
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 (!owner) // MUST not happen, remove when true TODO
1757 if (op->duration == 0 || owner == NULL)
1758 { 1736 {
1737 LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1759 op->destroy (); 1738 op->destroy ();
1760 return; 1739 return;
1761 } 1740 }
1762 1741
1742 if (!op->duration || !owner->is_on_map ())
1743 {
1744 op->destroy ();
1745 return;
1746 }
1747
1763 op->duration--; 1748 op->duration--;
1764 1749
1765 basedir = op->direction; 1750 int basedir = op->direction;
1766 if (basedir == 0) 1751 if (!basedir)
1767 { 1752 {
1768 /* spray in all directions! 8) */ 1753 /* spray in all directions! 8) */
1769 basedir = rndm (1, 8); 1754 op->facing = (op->facing + op->state) & 7;
1755 basedir = op->facing + 1;
1770 } 1756 }
1771 1757
1772#if 0 1758#if 0
1773 // this is bogus: it causes wrong places to be checked below 1759 // this is bogus: it causes wrong places to be checked below
1774 // (a wall 2 cells away will block the effect...) and 1760 // (a wall 2 cells away will block the effect...) and
… …
1835 { 1821 {
1836 /* Bullet spells have a bunch more customization that needs to be done */ 1822 /* Bullet spells have a bunch more customization that needs to be done */
1837 if (op->spell->subtype == SP_BULLET) 1823 if (op->spell->subtype == SP_BULLET)
1838 fire_bullet (owner, op, basedir, op->spell); 1824 fire_bullet (owner, op, basedir, op->spell);
1839 else if (op->spell->subtype == SP_MAGIC_MISSILE) 1825 else if (op->spell->subtype == SP_MAGIC_MISSILE)
1840 fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell); 1826 fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
1841 } 1827 }
1842} 1828}
1843
1844
1845
1846 1829
1847/* fire_swarm: 1830/* fire_swarm:
1848 * The following routine creates a swarm of objects. It actually 1831 * The following routine creates a swarm of objects. It actually
1849 * sets up a specific swarm object, which then fires off all 1832 * sets up a specific swarm object, which then fires off all
1850 * the parts of the swarm. 1833 * the parts of the swarm.
… …
1853 * caster: the caster (owner, wand, rod, scroll) 1836 * caster: the caster (owner, wand, rod, scroll)
1854 * dir: the direction everything will be fired in 1837 * dir: the direction everything will be fired in
1855 * spell - the spell that is this spell. 1838 * spell - the spell that is this spell.
1856 * n: the number to be fired. 1839 * n: the number to be fired.
1857 */ 1840 */
1858
1859int 1841int
1860fire_swarm (object *op, object *caster, object *spell, int dir) 1842fire_swarm (object *op, object *caster, object *spell, int dir)
1861{ 1843{
1862 object *tmp;
1863 int i;
1864
1865 if (!spell->other_arch) 1844 if (!spell->other_arch)
1866 return 0; 1845 return 0;
1867 1846
1868 tmp = get_archetype (SWARM_SPELL); 1847 object *tmp = archetype::get (SWARM_SPELL);
1869 tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */ 1848
1870 set_spell_skill (op, caster, spell, tmp); 1849 set_spell_skill (op, caster, spell, tmp);
1871
1872 tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */ 1850 tmp->level = caster_level (caster, spell); /* needed later, to get level dep. right. */
1873 tmp->spell = arch_to_object (spell->other_arch); 1851 tmp->spell = spell->other_arch->instance ();
1874
1875 tmp->attacktype = tmp->spell->attacktype; 1852 tmp->attacktype = tmp->spell->attacktype;
1876 1853
1877 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) 1854 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1878 if (!tailor_god_spell (tmp, op)) 1855 if (!tailor_god_spell (tmp, op))
1879 return 1; 1856 return 1;
1880 1857
1881 tmp->duration = SP_level_duration_adjust (caster, spell); 1858 tmp->duration = SP_level_duration_adjust (caster, spell);
1882 for (i = 0; i < spell->duration; i++) 1859 for (int i = 0; i < spell->duration; i++)
1883 tmp->duration += die_roll (1, 3, op, PREFER_HIGH); 1860 tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1884 1861
1862 tmp->invisible = 1;
1863 tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1885 tmp->direction = dir; 1864 tmp->direction = dir;
1886 tmp->invisible = 1; 1865 tmp->facing = rndm (1, 8); // initial firing direction
1866 tmp->state = rndm (4) * 2 + 1; // direction increment
1887 1867
1888 tmp->insert_at (op, op); 1868 op->insert (tmp);
1869
1889 return 1; 1870 return 1;
1890} 1871}
1891
1892 1872
1893/* See the spells documentation file for why this is its own 1873/* See the spells documentation file for why this is its own
1894 * function. 1874 * function.
1895 */ 1875 */
1896int 1876int
… …
1927 if (QUERY_FLAG (target, FLAG_MONSTER)) 1907 if (QUERY_FLAG (target, FLAG_MONSTER))
1928 { 1908 {
1929 /* oky doky. got a target monster. Lets make a blinding attack */ 1909 /* oky doky. got a target monster. Lets make a blinding attack */
1930 if (target->head) 1910 if (target->head)
1931 target = target->head; 1911 target = target->head;
1912
1932 (void) hit_player (target, dam, op, spell->attacktype, 1); 1913 hit_player (target, dam, op, spell->attacktype, 1);
1933 return 1; /* one success only! */ 1914 return 1; /* one success only! */
1934 } 1915 }
1935 } 1916 }
1936 1917
1937 /* no live target, perhaps a wall is in the way? */ 1918 /* no live target, perhaps a wall is in the way? */

Diff Legend

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