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.57 by root, Sat May 17 14:11:13 2008 UTC vs.
Revision 1.64 by root, Mon Sep 29 06:32:09 2008 UTC

… …
39 * op is the spell object. 39 * op is the spell object.
40 */ 40 */
41void 41void
42check_spell_knockback (object *op) 42check_spell_knockback (object *op)
43{ 43{
44 object *tmp, *tmp2; /* object on the map */
45 int weight_move; 44 int weight_move;
46 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 */
47 46
48 if (!op->weight) 47 if (!op->weight)
49 { /*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 */
… …
54 { 53 {
55 weight_move = op->weight + (op->weight * op->level) / 3; 54 weight_move = op->weight + (op->weight * op->level) / 3;
56 /*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); */
57 } 56 }
58 57
59 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)
60 { 59 {
61 int num_sections = 1; 60 int num_sections = 1;
62 61
63 /* don't move DM */ 62 /* don't move DM */
64 if (QUERY_FLAG (tmp, FLAG_WIZ)) 63 if (QUERY_FLAG (tmp, FLAG_WIZ))
… …
71 /* don't move floors or immobile objects */ 70 /* don't move floors or immobile objects */
72 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)))
73 continue; 72 continue;
74 73
75 /* count the object's sections */ 74 /* count the object's sections */
76 for (tmp2 = tmp; tmp2 != NULL; tmp2 = tmp2->more) 75 for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
77 num_sections++; 76 num_sections++;
78 77
79 /* 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
80 * 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
81 * 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.
… …
149 new_bolt->duration++; 148 new_bolt->duration++;
150 new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */ 149 new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
151 new_bolt->stats.dam++; 150 new_bolt->stats.dam++;
152 tmp->stats.dam /= 2; /* reduce father bolt damage */ 151 tmp->stats.dam /= 2; /* reduce father bolt damage */
153 tmp->stats.dam++; 152 tmp->stats.dam++;
153
154 if ((new_bolt = m->insert (new_bolt, sx, sy, op))) 154 if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
155 update_turn_face (new_bolt); 155 update_turn_face (new_bolt);
156} 156}
157 157
158/* move_bolt: moves bolt 'op'. Basically, it just advances a space, 158/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
159 * and checks for various things that may stop it. 159 * and checks for various things that may stop it.
160 */ 160 */
161
162void 161void
163move_bolt (object *op) 162move_bolt (object *op)
164{ 163{
165 int mflags; 164 int mflags;
166 sint16 x, y; 165 sint16 x, y;
… …
249 tmp->duration++; 248 tmp->duration++;
250 249
251 /* New forking code. Possibly create forks of this object 250 /* New forking code. Possibly create forks of this object
252 * going off in other directions. 251 * going off in other directions.
253 */ 252 */
254 if (rndm (0, 99) < tmp->stats.Dex) 253 if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
255 { /* stats.Dex % of forking */ 254 forklightning (op, tmp); /* stats.Dex % of forking */
256 forklightning (op, tmp);
257 }
258 255
259 /* 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
260 * doesn't create any bolts that continue to move onward. 257 * doesn't create any bolts that continue to move onward.
261 */ 258 */
262 op->range = 0; 259 op->range = 0;
… …
286 return 0; 283 return 0;
287 284
288 /* peterm: level dependency for bolts */ 285 /* peterm: level dependency for bolts */
289 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);
290 tmp->attacktype = spob->attacktype; 287 tmp->attacktype = spob->attacktype;
288
291 if (spob->slaying) 289 if (spob->slaying)
292 tmp->slaying = spob->slaying; 290 tmp->slaying = spob->slaying;
291
293 tmp->range = spob->range + SP_level_range_adjust (caster, spob); 292 tmp->range = spob->range + SP_level_range_adjust (caster, spob);
294 tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob); 293 tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
295 tmp->stats.Dex = spob->stats.Dex; 294 tmp->stats.Dex = spob->stats.Dex;
296 tmp->stats.Con = spob->stats.Con; 295 tmp->stats.Con = spob->stats.Con;
297 296
… …
394void 393void
395explode_bullet (object *op) 394explode_bullet (object *op)
396{ 395{
397 object *tmp, *owner; 396 object *tmp, *owner;
398 397
399 if (op->other_arch == NULL) 398 if (!op->other_arch)
400 { 399 {
401 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n"); 400 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
402 op->destroy (); 401 op->destroy ();
403 return; 402 return;
404 } 403 }
… …
433 } 432 }
434 433
435 if (op->attacktype) 434 if (op->attacktype)
436 { 435 {
437 hit_map (op, 0, op->attacktype, 1); 436 hit_map (op, 0, op->attacktype, 1);
437
438 if (op->destroyed ()) 438 if (op->destroyed ())
439 return; 439 return;
440 } 440 }
441 441
442 /* other_arch contains what this explodes into */ 442 /* other_arch contains what this explodes into */
… …
520 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 520 for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
521 { 521 {
522 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 522 if (QUERY_FLAG (tmp, FLAG_ALIVE))
523 { 523 {
524 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 524 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
525
525 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0) 526 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
526 { 527 {
527 if (!QUERY_FLAG (op, FLAG_REMOVED)) 528 if (!QUERY_FLAG (op, FLAG_REMOVED))
528 { 529 {
529 op->destroy (); 530 op->destroy ();
… …
703/* 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 */
704 705
705void 706void
706move_cone (object *op) 707move_cone (object *op)
707{ 708{
708 int i;
709
710 /* 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 */
711 if (!op->map) 710 if (!op->map)
712 { 711 {
713 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");
714 op->set_speed (0); 713 op->set_speed (0);
… …
744 check_spell_knockback (op); 743 check_spell_knockback (op);
745 744
746 if (op->destroyed ()) 745 if (op->destroyed ())
747 return; 746 return;
748 747
749 if ((op->duration--) < 0) 748 if (op->duration-- < 0)
750 { 749 {
751 op->destroy (); 750 op->destroy ();
752 return; 751 return;
753 } 752 }
754 /* Object has hit maximum range, so don't have it move 753 /* Object has hit maximum range, so don't have it move
… …
759 { 758 {
760 op->range = 0; /* just so it doesn't wrap */ 759 op->range = 0; /* just so it doesn't wrap */
761 return; 760 return;
762 } 761 }
763 762
764 for (i = -1; i < 2; i++) 763 for (int i = -1; i <= 1; i++)
765 { 764 {
766 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)];
767 766
768 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))
769 { 768 {
… …
861 860
862 success = 1; 861 success = 1;
863 tmp = arch_to_object (spell->other_arch); 862 tmp = arch_to_object (spell->other_arch);
864 tmp->set_owner (op); 863 tmp->set_owner (op);
865 set_spell_skill (op, caster, spell, tmp); 864 set_spell_skill (op, caster, spell, tmp);
866 tmp->level = caster_level (caster, spell); 865 tmp->level = casting_level (caster, spell);
867 tmp->attacktype = spell->attacktype; 866 tmp->attacktype = spell->attacktype;
868 867
869 /* holy word stuff */ 868 /* holy word stuff */
870 if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER)) 869 if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
871 if (!tailor_god_spell (tmp, op)) 870 if (!tailor_god_spell (tmp, op))
… …
1113 effect = arch_to_object (spell->other_arch); 1112 effect = arch_to_object (spell->other_arch);
1114 else 1113 else
1115 return 0; 1114 return 0;
1116 1115
1117 /* tailor the effect by priest level and worshipped God */ 1116 /* tailor the effect by priest level and worshipped God */
1118 effect->level = caster_level (caster, spell); 1117 effect->level = casting_level (caster, spell);
1119 effect->attacktype = spell->attacktype; 1118 effect->attacktype = spell->attacktype;
1120 if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER)) 1119 if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
1121 { 1120 {
1122 if (tailor_god_spell (effect, op)) 1121 if (tailor_god_spell (effect, op))
1123 new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op)); 1122 new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));
… …
1178 1177
1179/* op is a missile that needs to be moved */ 1178/* op is a missile that needs to be moved */
1180void 1179void
1181move_missile (object *op) 1180move_missile (object *op)
1182{ 1181{
1183 int i, mflags;
1184 object *owner;
1185 sint16 new_x, new_y;
1186 maptile *m;
1187
1188 if (op->range-- <= 0) 1182 if (op->range-- <= 0)
1189 { 1183 {
1190 op->destroy (); 1184 op->destroy ();
1191 return; 1185 return;
1192 } 1186 }
1193 1187
1194 owner = op->owner; 1188 mapxy pos (op);
1195#if 0 1189 pos.move (op->direction);
1196 /* It'd make things nastier if this wasn't here - spells cast by 1190
1197 * monster that are then killed would continue to survive 1191 if (!pos.normalise ())
1198 */
1199 if (owner == NULL)
1200 { 1192 {
1201 op->destroy (); 1193 op->destroy ();
1202 return; 1194 return;
1203 } 1195 }
1204#endif
1205 1196
1206 new_x = op->x + DIRX (op); 1197 mapspace &ms = pos.ms ();
1207 new_y = op->y + DIRY (op);
1208 1198
1209 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))
1210
1211 if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1212 { 1200 {
1213 hit_map (op, op->direction, AT_MAGIC, 1); 1201 hit_map (op, op->direction, AT_MAGIC, 1);
1214 /* Basically, missile only hits one thing then goes away. 1202 /* Basically, missile only hits one thing then goes away.
1215 * 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.
1216 */ 1204 */
1217 if (!op->destroyed ())
1218 op->destroy ();
1219
1220 return;
1221 }
1222
1223 op->remove ();
1224
1225 if (!op->direction || (mflags & P_OUT_OF_MAP))
1226 {
1227 op->destroy (); 1205 op->destroy ();
1228 return; 1206 return;
1229 } 1207 }
1230 1208
1209 if (!op->direction)
1210 {
1211 op->destroy ();
1212 return;
1213 }
1214
1231 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);
1232 if (i > 0 && i != op->direction) 1216 if (i > 0 && i != op->direction)
1233 { 1217 {
1234 op->direction = i; 1218 op->direction = i;
1235 SET_ANIMATION (op, op->direction); 1219 SET_ANIMATION (op, op->direction);
1236 } 1220 }
1237 1221
1238 m->insert (op, new_x, new_y, op); 1222 pos.insert (op, op);
1239} 1223}
1240 1224
1241/**************************************************************************** 1225/****************************************************************************
1242 * Destruction 1226 * Destruction
1243 ****************************************************************************/ 1227 ****************************************************************************/
… …
1300 else 1284 else
1301 op->skill = NULL; 1285 op->skill = NULL;
1302 1286
1303 op->change_skill (find_skill_by_name (op, op->skill)); 1287 op->change_skill (find_skill_by_name (op, op->skill));
1304 1288
1305 for (i = -range; i < range; i++) 1289 for (i = -range; i <= range; i++)
1306 { 1290 {
1307 for (j = -range; j < range; j++) 1291 for (j = -range; j <= range; j++)
1308 { 1292 {
1309 m = op->map; 1293 m = op->map;
1310 sx = op->x + i; 1294 sx = op->x + i;
1311 sy = op->y + j; 1295 sy = op->y + j;
1312 1296
… …
1329 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER))) 1313 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))
1330 { 1314 {
1331 if (spell_ob->subtype == SP_DESTRUCTION) 1315 if (spell_ob->subtype == SP_DESTRUCTION)
1332 { 1316 {
1333 hit_player (tmp, dam, op, spell_ob->attacktype, 0); 1317 hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1318
1334 if (spell_ob->other_arch) 1319 if (spell_ob->other_arch)
1335 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);
1336 } 1321 }
1337 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)
1338 { 1323 {
… …
1466 1451
1467 /* We precompute some values here so that we don't have to keep 1452 /* We precompute some values here so that we don't have to keep
1468 * doing it over and over again. 1453 * doing it over and over again.
1469 */ 1454 */
1470 god = find_god (determine_god (op)); 1455 god = find_god (determine_god (op));
1471 level = caster_level (caster, spell); 1456 level = casting_level (caster, spell);
1472 range = spell->range + SP_level_range_adjust (caster, spell); 1457 range = spell->range + SP_level_range_adjust (caster, spell);
1473 1458
1474 /* On the bright side, no monster should ever have a race of GOD_... 1459 /* On the bright side, no monster should ever have a race of GOD_...
1475 * so even if the player doesn't worship a god, if race=GOD_.., it 1460 * so even if the player doesn't worship a god, if race=GOD_.., it
1476 * won't ever match anything. 1461 * won't ever match anything.
… …
1626 * 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
1627 * lightning spell used it, that seemed misnamed. 1612 * lightning spell used it, that seemed misnamed.
1628 * op is the spell effect. 1613 * op is the spell effect.
1629 * note that duration is handled by process_object() in time.c 1614 * note that duration is handled by process_object() in time.c
1630 */ 1615 */
1631
1632void 1616void
1633move_ball_spell (object *op) 1617move_ball_spell (object *op)
1634{ 1618{
1635 int i, j, dam_save, dir, mflags; 1619 int i, j, dam_save, dir, mflags;
1636 sint16 nx, ny, hx, hy; 1620 sint16 nx, ny, hx, hy;
… …
1702 1686
1703 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)))
1704 { 1688 {
1705 if (j) 1689 if (j)
1706 op->stats.dam = dam_save / 2; 1690 op->stats.dam = dam_save / 2;
1691
1707 hit_map (op, j, op->attacktype, 1); 1692 hit_map (op, j, op->attacktype, 1);
1708
1709 } 1693 }
1710 1694
1711 /* insert the other arch */ 1695 /* insert the other arch */
1712 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))))
1713 m->insert (arch_to_object (op->other_arch), hx, hy, op); 1697 m->insert (arch_to_object (op->other_arch), hx, hy, op);
… …
1746 int adjustdir; 1730 int adjustdir;
1747 maptile *m; 1731 maptile *m;
1748#endif 1732#endif
1749 object *owner = op->env; 1733 object *owner = op->env;
1750 1734
1735 if (!owner) // MUST not happen, remove when true TODO
1736 {
1737 LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1738 op->destroy ();
1739 return;
1740 }
1741
1751 if (!op->duration || !owner->is_on_map ()) 1742 if (!op->duration || !owner->is_on_map ())
1752 { 1743 {
1753 op->destroy (); 1744 op->destroy ();
1754 return; 1745 return;
1755 } 1746 }
1756 1747
1757 op->duration--; 1748 op->duration--;
1758 1749
1759 int basedir = op->direction; 1750 int basedir = op->direction;
1760 if (!basedir) 1751 if (!basedir)
1752 {
1761 /* spray in all directions! 8) */ 1753 /* spray in all directions! 8) */
1762 basedir = (op->facing += op->state) % 8 + 1; 1754 op->facing = (op->facing + op->state) & 7;
1755 basedir = op->facing + 1;
1756 }
1763 1757
1764#if 0 1758#if 0
1765 // this is bogus: it causes wrong places to be checked below 1759 // this is bogus: it causes wrong places to be checked below
1766 // (a wall 2 cells away will block the effect...) and 1760 // (a wall 2 cells away will block the effect...) and
1767 // doesn't work for SP_BULLET anyhow, so again tests the wrong 1761 // doesn't work for SP_BULLET anyhow, so again tests the wrong
… …
1849{ 1843{
1850 if (!spell->other_arch) 1844 if (!spell->other_arch)
1851 return 0; 1845 return 0;
1852 1846
1853 object *tmp = archetype::get (SWARM_SPELL); 1847 object *tmp = archetype::get (SWARM_SPELL);
1848
1854 set_spell_skill (op, caster, spell, tmp); 1849 set_spell_skill (op, caster, spell, tmp);
1855 tmp->level = caster_level (caster, spell); /* needed later, to get level dep. right. */ 1850 tmp->level = casting_level (caster, spell); /* needed later, to get level dep. right. */
1856 tmp->spell = spell->other_arch->instance (); 1851 tmp->spell = spell->other_arch->instance ();
1857 tmp->attacktype = tmp->spell->attacktype; 1852 tmp->attacktype = tmp->spell->attacktype;
1858 1853
1859 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) 1854 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1860 if (!tailor_god_spell (tmp, op)) 1855 if (!tailor_god_spell (tmp, op))
… …
1862 1857
1863 tmp->duration = SP_level_duration_adjust (caster, spell); 1858 tmp->duration = SP_level_duration_adjust (caster, spell);
1864 for (int i = 0; i < spell->duration; i++) 1859 for (int i = 0; i < spell->duration; i++)
1865 tmp->duration += die_roll (1, 3, op, PREFER_HIGH); 1860 tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1866 1861
1862 tmp->invisible = 1;
1863 tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1867 tmp->direction = dir; 1864 tmp->direction = dir;
1868 tmp->invisible = 1;
1869 tmp->facing = rndm (1, 8); // initial firing direction 1865 tmp->facing = rndm (1, 8); // initial firing direction
1870 tmp->state = rndm (4) * 2 + 1; // direction increment 1866 tmp->state = rndm (4) * 2 + 1; // direction increment
1871 1867
1872 op->insert (tmp); 1868 op->insert (tmp);
1873 1869
… …
1911 if (QUERY_FLAG (target, FLAG_MONSTER)) 1907 if (QUERY_FLAG (target, FLAG_MONSTER))
1912 { 1908 {
1913 /* oky doky. got a target monster. Lets make a blinding attack */ 1909 /* oky doky. got a target monster. Lets make a blinding attack */
1914 if (target->head) 1910 if (target->head)
1915 target = target->head; 1911 target = target->head;
1912
1916 (void) hit_player (target, dam, op, spell->attacktype, 1); 1913 hit_player (target, dam, op, spell->attacktype, 1);
1917 return 1; /* one success only! */ 1914 return 1; /* one success only! */
1918 } 1915 }
1919 } 1916 }
1920 1917
1921 /* no live target, perhaps a wall is in the way? */ 1918 /* no live target, perhaps a wall is in the way? */
… …
2001 object *disease = arch_to_object (spell->other_arch); 1998 object *disease = arch_to_object (spell->other_arch);
2002 1999
2003 disease->set_owner (op); 2000 disease->set_owner (op);
2004 set_spell_skill (op, caster, spell, disease); 2001 set_spell_skill (op, caster, spell, disease);
2005 disease->stats.exp = 0; 2002 disease->stats.exp = 0;
2006 disease->level = caster_level (caster, spell); 2003 disease->level = casting_level (caster, spell);
2007 2004
2008 /* do level adjustments */ 2005 /* do level adjustments */
2009 if (disease->stats.wc) 2006 if (disease->stats.wc)
2010 disease->stats.wc += dur_mod / 2; 2007 disease->stats.wc += dur_mod / 2;
2011 2008

Diff Legend

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