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.58 by root, Sat May 17 14:57:23 2008 UTC vs.
Revision 1.74 by root, Sun Dec 28 07:48:44 2008 UTC

… …
148 new_bolt->duration++; 148 new_bolt->duration++;
149 new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */ 149 new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
150 new_bolt->stats.dam++; 150 new_bolt->stats.dam++;
151 tmp->stats.dam /= 2; /* reduce father bolt damage */ 151 tmp->stats.dam /= 2; /* reduce father bolt damage */
152 tmp->stats.dam++; 152 tmp->stats.dam++;
153
153 if ((new_bolt = m->insert (new_bolt, sx, sy, op))) 154 if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
154 update_turn_face (new_bolt); 155 update_turn_face (new_bolt);
155} 156}
156 157
157/* move_bolt: moves bolt 'op'. Basically, it just advances a space, 158/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
… …
164 sint16 x, y; 165 sint16 x, y;
165 maptile *m; 166 maptile *m;
166 167
167 if (--op->duration < 0) 168 if (--op->duration < 0)
168 { 169 {
169 op->destroy (); 170 op->drop_and_destroy ();
170 return; 171 return;
171 } 172 }
172 173
173 hit_map (op, 0, op->attacktype, 1); 174 hit_map (op, 0, op->attacktype, 1);
174 175
… …
306 307
307 maptile *newmap; 308 maptile *newmap;
308 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y); 309 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
309 if (mflags & P_OUT_OF_MAP) 310 if (mflags & P_OUT_OF_MAP)
310 { 311 {
311 tmp->destroy (); 312 tmp->drop_and_destroy ();
312 return 0; 313 return 0;
313 } 314 }
314 315
315 tmp->map = newmap; 316 tmp->map = newmap;
316 317
317 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y))) 318 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
318 { 319 {
319 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 320 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
320 { 321 {
321 tmp->destroy (); 322 tmp->drop_and_destroy ();
322 return 0; 323 return 0;
323 } 324 }
324 325
325 tmp->x = op->x; 326 tmp->x = op->x;
326 tmp->y = op->y; 327 tmp->y = op->y;
… …
392void 393void
393explode_bullet (object *op) 394explode_bullet (object *op)
394{ 395{
395 object *tmp, *owner; 396 object *tmp, *owner;
396 397
397 if (op->other_arch == NULL) 398 if (!op->other_arch)
398 { 399 {
399 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n"); 400 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
400 op->destroy (); 401 op->destroy ();
401 return; 402 return;
402 } 403 }
… …
444 tmp->set_owner (op); 445 tmp->set_owner (op);
445 tmp->skill = op->skill; 446 tmp->skill = op->skill;
446 447
447 owner = op->owner; 448 owner = op->owner;
448 449
449 if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner)) 450 if ((tmp->attacktype & AT_HOLYWORD
451 || tmp->attacktype & AT_GODPOWER)
452 && owner
453 && !tailor_god_spell (tmp, owner))
450 { 454 {
451 op->destroy (); 455 op->destroy ();
452 return; 456 return;
453 } 457 }
454 458
… …
520 { 524 {
521 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 525 if (QUERY_FLAG (tmp, FLAG_ALIVE))
522 { 526 {
523 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 527 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
524 528
529 // TODO: can't understand the following if's
525 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0) 530 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
526 { 531 {
527 if (!QUERY_FLAG (op, FLAG_REMOVED)) 532 if (!QUERY_FLAG (op, FLAG_REMOVED))
528 { 533 {
529 op->destroy (); 534 op->destroy ();
… …
732 } 737 }
733#endif 738#endif
734 739
735 hit_map (op, 0, op->attacktype, 0); 740 hit_map (op, 0, op->attacktype, 0);
736 741
742 if (!op->is_on_map ())
743 return;
744
737 /* Check to see if we should push anything. 745 /* Check to see if we should push anything.
738 * Spell objects with weight push whatever they encounter to some 746 * Spell objects with weight push whatever they encounter to some
739 * degree. 747 * degree.
740 */ 748 */
741 if (op->weight) 749 if (op->weight)
750 {
742 check_spell_knockback (op); 751 check_spell_knockback (op);
743 752
744 if (op->destroyed ()) 753 if (!op->is_on_map ())
745 return; 754 return;
755 }
746 756
747 if ((op->duration--) < 0) 757 if (op->duration-- < 0)
748 { 758 {
749 op->destroy (); 759 op->destroy ();
750 return; 760 return;
751 } 761 }
752 /* Object has hit maximum range, so don't have it move 762 /* Object has hit maximum range, so don't have it move
… …
859 869
860 success = 1; 870 success = 1;
861 tmp = arch_to_object (spell->other_arch); 871 tmp = arch_to_object (spell->other_arch);
862 tmp->set_owner (op); 872 tmp->set_owner (op);
863 set_spell_skill (op, caster, spell, tmp); 873 set_spell_skill (op, caster, spell, tmp);
864 tmp->level = caster_level (caster, spell); 874 tmp->level = casting_level (caster, spell);
865 tmp->attacktype = spell->attacktype; 875 tmp->attacktype = spell->attacktype;
866 876
867 /* holy word stuff */ 877 /* holy word stuff */
868 if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER)) 878 if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
869 if (!tailor_god_spell (tmp, op)) 879 if (!tailor_god_spell (tmp, op))
… …
998 int mflags; 1008 int mflags;
999 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir]; 1009 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1000 maptile *m; 1010 maptile *m;
1001 1011
1002 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy); 1012 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
1013
1014 // when creating a bomb below ourself it should always work, even
1015 // when movement is blocked (somehow we got here, somehow we are here,
1016 // so we should also be able to make a bomb here). (originally added
1017 // to fix create bomb traps in doors, which cast with dir=0).
1018 if (dir)
1019 {
1003 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK)) 1020 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1004 { 1021 {
1005 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1022 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1006 return 0; 1023 return 0;
1024 }
1007 } 1025 }
1008 1026
1009 tmp = arch_to_object (spell->other_arch); 1027 tmp = arch_to_object (spell->other_arch);
1010 1028
1011 /* level dependencies for bomb */ 1029 /* level dependencies for bomb */
… …
1111 effect = arch_to_object (spell->other_arch); 1129 effect = arch_to_object (spell->other_arch);
1112 else 1130 else
1113 return 0; 1131 return 0;
1114 1132
1115 /* tailor the effect by priest level and worshipped God */ 1133 /* tailor the effect by priest level and worshipped God */
1116 effect->level = caster_level (caster, spell); 1134 effect->level = casting_level (caster, spell);
1117 effect->attacktype = spell->attacktype; 1135 effect->attacktype = spell->attacktype;
1118 if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER)) 1136 if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
1119 { 1137 {
1120 if (tailor_god_spell (effect, op)) 1138 if (tailor_god_spell (effect, op))
1121 new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op)); 1139 new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));
… …
1178void 1196void
1179move_missile (object *op) 1197move_missile (object *op)
1180{ 1198{
1181 if (op->range-- <= 0) 1199 if (op->range-- <= 0)
1182 { 1200 {
1183 op->destroy (); 1201 op->drop_and_destroy ();
1184 return; 1202 return;
1185 } 1203 }
1186 1204
1187 mapxy pos (op); 1205 mapxy pos (op);
1188 pos.move (op->direction); 1206 pos.move (op->direction);
… …
1240 1258
1241 object *tmp = get_archetype (FORCE_NAME); 1259 object *tmp = get_archetype (FORCE_NAME);
1242 tmp->speed = 0.01; 1260 tmp->speed = 0.01;
1243 tmp->stats.food = time; 1261 tmp->stats.food = time;
1244 SET_FLAG (tmp, FLAG_IS_USED_UP); 1262 SET_FLAG (tmp, FLAG_IS_USED_UP);
1245 tmp->glow_radius = radius;
1246 if (tmp->glow_radius > MAX_LIGHT_RADII)
1247 tmp->glow_radius = MAX_LIGHT_RADII; 1263 tmp->glow_radius = min (MAX_LIGHT_RADIUS, radius);
1248
1249 tmp = insert_ob_in_ob (tmp, op); 1264 tmp = insert_ob_in_ob (tmp, op);
1250 1265
1251 if (tmp->glow_radius > op->glow_radius) 1266 if (tmp->glow_radius > op->glow_radius)
1252 op->glow_radius = tmp->glow_radius; 1267 op->glow_radius = tmp->glow_radius;
1253 1268
… …
1255} 1270}
1256 1271
1257int 1272int
1258cast_destruction (object *op, object *caster, object *spell_ob) 1273cast_destruction (object *op, object *caster, object *spell_ob)
1259{ 1274{
1260 int i, j, range, mflags, friendly = 0, dam, dur;
1261 sint16 sx, sy;
1262 maptile *m;
1263 object *tmp;
1264 const char *skill;
1265
1266 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 1275 int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1267 dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 1276 int dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
1268 dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 1277 int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1269 if (QUERY_FLAG (op, FLAG_FRIENDLY) || op->type == PLAYER) 1278
1270 friendly = 1; 1279 bool friendly = op->flag [FLAG_FRIENDLY] || op->is_player ();
1271 1280
1272 /* destruction doesn't use another spell object, so we need 1281 /* destruction doesn't use another spell object, so we need
1273 * update op's skill pointer so that exp is properly awarded. 1282 * update op's skill pointer so that exp is properly awarded.
1274 * We do some shortcuts here - since this is just temporary
1275 * and we'll reset the values back, we don't need to go through
1276 * the full share string/free_string route.
1277 */ 1283 */
1278 skill = op->skill; 1284 const shstr skill = op->skill;
1285
1279 if (caster == op) 1286 if (caster == op)
1280 op->skill = spell_ob->skill; 1287 op->skill = spell_ob->skill;
1281 else if (caster->skill) 1288 else if (caster->skill)
1282 op->skill = caster->skill; 1289 op->skill = caster->skill;
1283 else 1290 else
1284 op->skill = NULL; 1291 op->skill = 0;
1285 1292
1286 op->change_skill (find_skill_by_name (op, op->skill)); 1293 op->change_skill (find_skill_by_name (op, op->skill));
1287 1294
1288 for (i = -range; i <= range; i++) 1295 unordered_mapwalk (op, -range, -range, range, range)
1289 { 1296 {
1290 for (j = -range; j <= range; j++) 1297 mapspace &ms = m->at (nx, ny);
1291 {
1292 m = op->map;
1293 sx = op->x + i;
1294 sy = op->y + j;
1295 1298
1296 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1297 if (mflags & P_OUT_OF_MAP)
1298 continue;
1299
1300 if (mflags & P_IS_ALIVE) 1299 if (ms.flags () & P_IS_ALIVE)
1300 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1301 if (tmp->flag [FLAG_ALIVE] || tmp->is_player ())
1301 { 1302 {
1302 for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above) 1303 tmp = tmp->head_ ();
1303 if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
1304 break;
1305 1304
1306 if (tmp) 1305 if ((friendly && !tmp->flag [FLAG_FRIENDLY] && !tmp->is_player ())
1306 || (!friendly && (tmp->flag [FLAG_FRIENDLY] || tmp->is_player ())))
1307 { 1307 {
1308 if (tmp->head) 1308 if (spell_ob->subtype == SP_DESTRUCTION)
1309 tmp = tmp->head;
1310
1311 if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) ||
1312 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))
1313 { 1309 {
1314 if (spell_ob->subtype == SP_DESTRUCTION)
1315 {
1316 hit_player (tmp, dam, op, spell_ob->attacktype, 0); 1310 hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1317 1311
1318 if (spell_ob->other_arch) 1312 if (spell_ob->other_arch)
1319 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op); 1313 m->insert (arch_to_object (spell_ob->other_arch), nx, ny, op);
1320 } 1314 }
1321 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100) 1315 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist [ATNR_MAGIC] != 100)
1322 { 1316 {
1323 if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch) 1317 if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1324 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op); 1318 m->insert (arch_to_object (spell_ob->other_arch), nx, ny, op);
1325 }
1326 } 1319 }
1327 } 1320 }
1328 } 1321 }
1329 }
1330 } 1322 }
1331 1323
1332 op->skill = skill; 1324 op->skill = skill;
1333 return 1; 1325 return 1;
1334} 1326}
… …
1450 1442
1451 /* We precompute some values here so that we don't have to keep 1443 /* We precompute some values here so that we don't have to keep
1452 * doing it over and over again. 1444 * doing it over and over again.
1453 */ 1445 */
1454 god = find_god (determine_god (op)); 1446 god = find_god (determine_god (op));
1455 level = caster_level (caster, spell); 1447 level = casting_level (caster, spell);
1456 range = spell->range + SP_level_range_adjust (caster, spell); 1448 range = spell->range + SP_level_range_adjust (caster, spell);
1457 1449
1458 /* On the bright side, no monster should ever have a race of GOD_... 1450 /* On the bright side, no monster should ever have a race of GOD_...
1459 * so even if the player doesn't worship a god, if race=GOD_.., it 1451 * so even if the player doesn't worship a god, if race=GOD_.., it
1460 * won't ever match anything. 1452 * won't ever match anything.
… …
1482 /* If there is nothing living on this space, no need to go further */ 1474 /* If there is nothing living on this space, no need to go further */
1483 if (!(mflags & P_IS_ALIVE)) 1475 if (!(mflags & P_IS_ALIVE))
1484 continue; 1476 continue;
1485 1477
1486 // players can only affect spaces that they can actually see 1478 // players can only affect spaces that they can actually see
1479 if (caster
1487 if (caster && caster->contr 1480 && caster->contr
1488 && caster->contr->visibility_at (m, nx, ny) < 70) 1481 && caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
1489 continue; 1482 continue;
1490 1483
1491 for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below) 1484 for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)
1492 if (QUERY_FLAG (tmp, FLAG_MONSTER)) 1485 if (QUERY_FLAG (tmp, FLAG_MONSTER))
1493 break; 1486 break;
… …
1603 } /* for y */ 1596 } /* for y */
1604 1597
1605 return 1; 1598 return 1;
1606} 1599}
1607 1600
1608
1609/* Move_ball_spell: This handles ball type spells that just sort of wander 1601/* Move_ball_spell: This handles ball type spells that just sort of wander
1610 * about. was called move_ball_lightning, but since more than the ball 1602 * about. was called move_ball_lightning, but since more than the ball
1611 * lightning spell used it, that seemed misnamed. 1603 * lightning spell used it, that seemed misnamed.
1612 * op is the spell effect. 1604 * op is the spell effect.
1613 * note that duration is handled by process_object() in time.c 1605 * note that duration is handled by process_object() in time.c
1614 */ 1606 */
1615
1616void 1607void
1617move_ball_spell (object *op) 1608move_ball_spell (object *op)
1618{ 1609{
1619 int i, j, dam_save, dir, mflags; 1610 int i, j, dam_save, dir, mflags;
1620 sint16 nx, ny, hx, hy; 1611 sint16 nx, ny, hx, hy;
… …
1639 for (i = 1; i < 9; i++) 1630 for (i = 1; i < 9; i++)
1640 { 1631 {
1641 /* i bit 0: alters sign of offset 1632 /* i bit 0: alters sign of offset
1642 * other bits (i / 2): absolute value of offset 1633 * other bits (i / 2): absolute value of offset
1643 */ 1634 */
1644
1645 int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2); 1635 int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1646 int tmpdir = absdir (op->direction + offset); 1636 int tmpdir = absdir (op->direction + offset);
1647 1637
1648 nx = op->x + freearr_x[tmpdir]; 1638 nx = op->x + freearr_x[tmpdir];
1649 ny = op->y + freearr_y[tmpdir]; 1639 ny = op->y + freearr_y[tmpdir];
… …
1651 { 1641 {
1652 dir = tmpdir; 1642 dir = tmpdir;
1653 break; 1643 break;
1654 } 1644 }
1655 } 1645 }
1646
1656 if (dir == 0) 1647 if (dir == 0)
1657 { 1648 {
1658 nx = op->x; 1649 nx = op->x;
1659 ny = op->y; 1650 ny = op->y;
1660 m = op->map; 1651 m = op->map;
… …
1730 int adjustdir; 1721 int adjustdir;
1731 maptile *m; 1722 maptile *m;
1732#endif 1723#endif
1733 object *owner = op->env; 1724 object *owner = op->env;
1734 1725
1726 if (!owner) // MUST not happen, remove when true TODO
1727 {
1728 LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1729 op->destroy ();
1730 return;
1731 }
1732
1735 if (!op->duration || !owner->is_on_map ()) 1733 if (!op->duration || !owner->is_on_map ())
1736 { 1734 {
1737 op->destroy (); 1735 op->drop_and_destroy ();
1738 return; 1736 return;
1739 } 1737 }
1740 1738
1741 op->duration--; 1739 op->duration--;
1742 1740
1743 int basedir = op->direction; 1741 int basedir = op->direction;
1744 if (!basedir) 1742 if (!basedir)
1743 {
1745 /* spray in all directions! 8) */ 1744 /* spray in all directions! 8) */
1746 basedir = (op->facing += op->state) % 8 + 1; 1745 op->facing = (op->facing + op->state) & 7;
1746 basedir = op->facing + 1;
1747 }
1747 1748
1748#if 0 1749#if 0
1749 // this is bogus: it causes wrong places to be checked below 1750 // this is bogus: it causes wrong places to be checked below
1750 // (a wall 2 cells away will block the effect...) and 1751 // (a wall 2 cells away will block the effect...) and
1751 // doesn't work for SP_BULLET anyhow, so again tests the wrong 1752 // doesn't work for SP_BULLET anyhow, so again tests the wrong
… …
1833{ 1834{
1834 if (!spell->other_arch) 1835 if (!spell->other_arch)
1835 return 0; 1836 return 0;
1836 1837
1837 object *tmp = archetype::get (SWARM_SPELL); 1838 object *tmp = archetype::get (SWARM_SPELL);
1839
1838 set_spell_skill (op, caster, spell, tmp); 1840 set_spell_skill (op, caster, spell, tmp);
1839 tmp->level = caster_level (caster, spell); /* needed later, to get level dep. right. */ 1841 tmp->level = casting_level (caster, spell); /* needed later, to get level dep. right. */
1840 tmp->spell = spell->other_arch->instance (); 1842 tmp->spell = spell->other_arch->instance ();
1841 tmp->attacktype = tmp->spell->attacktype; 1843 tmp->attacktype = tmp->spell->attacktype;
1842 1844
1843 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) 1845 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1844 if (!tailor_god_spell (tmp, op)) 1846 if (!tailor_god_spell (tmp, op))
… …
1846 1848
1847 tmp->duration = SP_level_duration_adjust (caster, spell); 1849 tmp->duration = SP_level_duration_adjust (caster, spell);
1848 for (int i = 0; i < spell->duration; i++) 1850 for (int i = 0; i < spell->duration; i++)
1849 tmp->duration += die_roll (1, 3, op, PREFER_HIGH); 1851 tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1850 1852
1853 tmp->invisible = 1;
1854 tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1851 tmp->direction = dir; 1855 tmp->direction = dir;
1852 tmp->invisible = 1;
1853 tmp->facing = rndm (1, 8); // initial firing direction 1856 tmp->facing = rndm (1, 8); // initial firing direction
1854 tmp->state = rndm (4) * 2 + 1; // direction increment 1857 tmp->state = rndm (4) * 2 + 1; // direction increment
1855 1858
1856 op->insert (tmp); 1859 op->insert (tmp);
1857 1860
… …
1869 int dam, mflags; 1872 int dam, mflags;
1870 maptile *m; 1873 maptile *m;
1871 1874
1872 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1875 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1873 1876
1874 if (!dir) 1877 if (dir)
1875 {
1876 new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1877 return 0;
1878 } 1878 {
1879
1880 x = op->x + freearr_x[dir]; 1879 x = op->x + freearr_x[dir];
1881 y = op->y + freearr_y[dir]; 1880 y = op->y + freearr_y[dir];
1882 m = op->map; 1881 m = op->map;
1883 1882
1884 mflags = get_map_flags (m, &m, x, y, &x, &y); 1883 mflags = get_map_flags (m, &m, x, y, &x, &y);
1885 1884
1886 if (mflags & P_OUT_OF_MAP) 1885 if (mflags & P_OUT_OF_MAP)
1887 { 1886 {
1888 new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there."); 1887 new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");
1889 return 0; 1888 return 0;
1890 } 1889 }
1891 1890
1892 if (mflags & P_IS_ALIVE && spell->attacktype) 1891 if (mflags & P_IS_ALIVE && spell->attacktype)
1893 { 1892 {
1894 for (target = GET_MAP_OB (m, x, y); target; target = target->above) 1893 for (target = GET_MAP_OB (m, x, y); target; target = target->above)
1895 if (QUERY_FLAG (target, FLAG_MONSTER)) 1894 if (QUERY_FLAG (target, FLAG_MONSTER))
1896 { 1895 {
1897 /* oky doky. got a target monster. Lets make a blinding attack */ 1896 /* oky doky. got a target monster. Lets make a blinding attack */
1898 if (target->head) 1897 if (target->head)
1899 target = target->head; 1898 target = target->head;
1900 1899
1901 hit_player (target, dam, op, spell->attacktype, 1); 1900 hit_player (target, dam, op, spell->attacktype, 1);
1902 return 1; /* one success only! */ 1901 return 1; /* one success only! */
1902 }
1903 } 1903 }
1904 }
1905 1904
1906 /* no live target, perhaps a wall is in the way? */ 1905 /* no live target, perhaps a wall is in the way? */
1907 if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y))) 1906 if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
1908 { 1907 {
1909 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 1908 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1910 return 0; 1909 return 0;
1910 }
1911 } 1911 }
1912 1912
1913 /* ok, looks groovy to just insert a new light on the map */ 1913 /* ok, looks groovy to just insert a new light on the map */
1914 tmp = arch_to_object (spell->other_arch); 1914 tmp = arch_to_object (spell->other_arch);
1915 if (!tmp) 1915 if (!tmp)
1916 { 1916 {
1917 LOG (llevError, "Error: spell arch for cast_light() missing.\n"); 1917 LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1918 return 0; 1918 return 0;
1919 } 1919 }
1920
1920 tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell); 1921 tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
1922
1921 if (tmp->glow_radius) 1923 if (tmp->glow_radius)
1922 {
1923 tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell); 1924 tmp->glow_radius = min (MAX_LIGHT_RADIUS, spell->range + SP_level_range_adjust (caster, spell));
1924 if (tmp->glow_radius > MAX_LIGHT_RADII)
1925 tmp->glow_radius = MAX_LIGHT_RADII;
1926 }
1927 1925
1926 if (dir)
1928 m->insert (tmp, x, y, op); 1927 m->insert (tmp, x, y, op);
1928 else
1929 caster->outer_env ()->insert (tmp);
1930
1929 return 1; 1931 return 1;
1930} 1932}
1931 1933
1932/* cast_cause_disease: this spell looks along <dir> from the 1934/* cast_cause_disease: this spell looks along <dir> from the
1933 * player and infects someone. 1935 * player and infects someone.
… …
1986 object *disease = arch_to_object (spell->other_arch); 1988 object *disease = arch_to_object (spell->other_arch);
1987 1989
1988 disease->set_owner (op); 1990 disease->set_owner (op);
1989 set_spell_skill (op, caster, spell, disease); 1991 set_spell_skill (op, caster, spell, disease);
1990 disease->stats.exp = 0; 1992 disease->stats.exp = 0;
1991 disease->level = caster_level (caster, spell); 1993 disease->level = casting_level (caster, spell);
1992 1994
1993 /* do level adjustments */ 1995 /* do level adjustments */
1994 if (disease->stats.wc) 1996 if (disease->stats.wc)
1995 disease->stats.wc += dur_mod / 2; 1997 disease->stats.wc += dur_mod / 2;
1996 1998

Diff Legend

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