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.67 by root, Mon Sep 29 10:32:50 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;
169 maptile *m; 166 maptile *m;
170 167
171 if (--op->duration < 0) 168 if (--op->duration < 0)
172 { 169 {
173 op->destroy (); 170 op->drop_and_destroy ();
174 return; 171 return;
175 } 172 }
176 173
177 hit_map (op, 0, op->attacktype, 1); 174 hit_map (op, 0, op->attacktype, 1);
178 175
… …
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
… …
310 307
311 maptile *newmap; 308 maptile *newmap;
312 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);
313 if (mflags & P_OUT_OF_MAP) 310 if (mflags & P_OUT_OF_MAP)
314 { 311 {
315 tmp->destroy (); 312 tmp->drop_and_destroy ();
316 return 0; 313 return 0;
317 } 314 }
318 315
319 tmp->map = newmap; 316 tmp->map = newmap;
320 317
321 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)))
322 { 319 {
323 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 320 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
324 { 321 {
325 tmp->destroy (); 322 tmp->drop_and_destroy ();
326 return 0; 323 return 0;
327 } 324 }
328 325
329 tmp->x = op->x; 326 tmp->x = op->x;
330 tmp->y = op->y; 327 tmp->y = op->y;
… …
396void 393void
397explode_bullet (object *op) 394explode_bullet (object *op)
398{ 395{
399 object *tmp, *owner; 396 object *tmp, *owner;
400 397
401 if (op->other_arch == NULL) 398 if (!op->other_arch)
402 { 399 {
403 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n"); 400 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
404 op->destroy (); 401 op->destroy ();
405 return; 402 return;
406 } 403 }
… …
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 */
… …
447 tmp->set_owner (op); 445 tmp->set_owner (op);
448 tmp->skill = op->skill; 446 tmp->skill = op->skill;
449 447
450 owner = op->owner; 448 owner = op->owner;
451 449
452 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))
453 { 454 {
454 op->destroy (); 455 op->destroy ();
455 return; 456 return;
456 } 457 }
457 458
… …
522 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 523 for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
523 { 524 {
524 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 525 if (QUERY_FLAG (tmp, FLAG_ALIVE))
525 { 526 {
526 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 527 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
528
529 // TODO: can't understand the following if's
527 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0) 530 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
528 { 531 {
529 if (!QUERY_FLAG (op, FLAG_REMOVED)) 532 if (!QUERY_FLAG (op, FLAG_REMOVED))
530 { 533 {
531 op->destroy (); 534 op->destroy ();
… …
620 int mflags; 623 int mflags;
621 624
622 if (!spob->other_arch) 625 if (!spob->other_arch)
623 return 0; 626 return 0;
624 627
625 tmp = arch_to_object (spob->other_arch); 628 tmp = spob->other_arch->instance ();
626 if (tmp == NULL) 629 if (!tmp)
627 return 0; 630 return 0;
628 631
629 /* peterm: level dependency for bolts */ 632 /* peterm: level dependency for bolts */
630 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob); 633 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
631 tmp->attacktype = spob->attacktype; 634 tmp->attacktype = spob->attacktype;
632 if (spob->slaying) 635 if (spob->slaying)
633 tmp->slaying = spob->slaying; 636 tmp->slaying = spob->slaying;
634 637
… …
644 SET_ANIMATION (tmp, dir); 647 SET_ANIMATION (tmp, dir);
645 648
646 tmp->set_owner (op); 649 tmp->set_owner (op);
647 set_spell_skill (op, caster, spob, tmp); 650 set_spell_skill (op, caster, spob, tmp);
648 651
649 tmp->x = op->x + freearr_x[dir]; 652 tmp->x = op->x + freearr_x[dir];
650 tmp->y = op->y + freearr_y[dir]; 653 tmp->y = op->y + freearr_y[dir];
651 tmp->map = op->map; 654 tmp->map = op->map;
652 655
653 maptile *newmap; 656 maptile *newmap;
654 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);
655 if (mflags & P_OUT_OF_MAP) 658 if (mflags & P_OUT_OF_MAP)
… …
705/* move_cone: causes cone object 'op' to move a space/hit creatures */ 708/* move_cone: causes cone object 'op' to move a space/hit creatures */
706 709
707void 710void
708move_cone (object *op) 711move_cone (object *op)
709{ 712{
710 int i;
711
712 /* if no map then hit_map will crash so just ignore object */ 713 /* if no map then hit_map will crash so just ignore object */
713 if (!op->map) 714 if (!op->map)
714 { 715 {
715 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown"); 716 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
716 op->set_speed (0); 717 op->set_speed (0);
… …
746 check_spell_knockback (op); 747 check_spell_knockback (op);
747 748
748 if (op->destroyed ()) 749 if (op->destroyed ())
749 return; 750 return;
750 751
751 if ((op->duration--) < 0) 752 if (op->duration-- < 0)
752 { 753 {
753 op->destroy (); 754 op->destroy ();
754 return; 755 return;
755 } 756 }
756 /* Object has hit maximum range, so don't have it move 757 /* Object has hit maximum range, so don't have it move
… …
761 { 762 {
762 op->range = 0; /* just so it doesn't wrap */ 763 op->range = 0; /* just so it doesn't wrap */
763 return; 764 return;
764 } 765 }
765 766
766 for (i = -1; i < 2; i++) 767 for (int i = -1; i <= 1; i++)
767 { 768 {
768 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)]; 769 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
769 770
770 if (ok_to_put_more (op->map, x, y, op, op->attacktype)) 771 if (ok_to_put_more (op->map, x, y, op, op->attacktype))
771 { 772 {
… …
863 864
864 success = 1; 865 success = 1;
865 tmp = arch_to_object (spell->other_arch); 866 tmp = arch_to_object (spell->other_arch);
866 tmp->set_owner (op); 867 tmp->set_owner (op);
867 set_spell_skill (op, caster, spell, tmp); 868 set_spell_skill (op, caster, spell, tmp);
868 tmp->level = caster_level (caster, spell); 869 tmp->level = casting_level (caster, spell);
869 tmp->attacktype = spell->attacktype; 870 tmp->attacktype = spell->attacktype;
870 871
871 /* holy word stuff */ 872 /* holy word stuff */
872 if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER)) 873 if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
873 if (!tailor_god_spell (tmp, op)) 874 if (!tailor_god_spell (tmp, op))
… …
1115 effect = arch_to_object (spell->other_arch); 1116 effect = arch_to_object (spell->other_arch);
1116 else 1117 else
1117 return 0; 1118 return 0;
1118 1119
1119 /* tailor the effect by priest level and worshipped God */ 1120 /* tailor the effect by priest level and worshipped God */
1120 effect->level = caster_level (caster, spell); 1121 effect->level = casting_level (caster, spell);
1121 effect->attacktype = spell->attacktype; 1122 effect->attacktype = spell->attacktype;
1122 if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER)) 1123 if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
1123 { 1124 {
1124 if (tailor_god_spell (effect, op)) 1125 if (tailor_god_spell (effect, op))
1125 new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op)); 1126 new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));
… …
1180 1181
1181/* op is a missile that needs to be moved */ 1182/* op is a missile that needs to be moved */
1182void 1183void
1183move_missile (object *op) 1184move_missile (object *op)
1184{ 1185{
1185 int i, mflags;
1186 object *owner;
1187 sint16 new_x, new_y;
1188 maptile *m;
1189
1190 if (op->range-- <= 0) 1186 if (op->range-- <= 0)
1191 { 1187 {
1188 op->drop_and_destroy ();
1189 return;
1190 }
1191
1192 mapxy pos (op);
1193 pos.move (op->direction);
1194
1195 if (!pos.normalise ())
1196 {
1192 op->destroy (); 1197 op->destroy ();
1193 return; 1198 return;
1194 } 1199 }
1195 1200
1196 owner = op->owner; 1201 mapspace &ms = pos.ms ();
1197#if 0
1198 /* It'd make things nastier if this wasn't here - spells cast by
1199 * monster that are then killed would continue to survive
1200 */
1201 if (owner == NULL)
1202 {
1203 op->destroy ();
1204 return;
1205 }
1206#endif
1207 1202
1208 new_x = op->x + DIRX (op); 1203 if (ms.flags () & P_IS_ALIVE || ms.blocks (op))
1209 new_y = op->y + DIRY (op);
1210
1211 mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
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 { 1204 {
1215 hit_map (op, op->direction, AT_MAGIC, 1); 1205 hit_map (op, op->direction, AT_MAGIC, 1);
1216 /* Basically, missile only hits one thing then goes away. 1206 /* Basically, missile only hits one thing then goes away.
1217 * we need to remove it if someone hasn't already done so. 1207 * we need to remove it if someone hasn't already done so.
1218 */ 1208 */
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 (); 1209 op->destroy ();
1230 return; 1210 return;
1231 } 1211 }
1232 1212
1213 if (!op->direction)
1214 {
1215 op->destroy ();
1216 return;
1217 }
1218
1233 i = spell_find_dir (m, new_x, new_y, op->owner); 1219 int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1234 if (i > 0 && i != op->direction) 1220 if (i > 0 && i != op->direction)
1235 { 1221 {
1236 op->direction = i; 1222 op->direction = i;
1237 SET_ANIMATION (op, op->direction); 1223 SET_ANIMATION (op, op->direction);
1238 } 1224 }
1239 1225
1240 m->insert (op, new_x, new_y, op); 1226 pos.insert (op, op);
1241} 1227}
1242 1228
1243/**************************************************************************** 1229/****************************************************************************
1244 * Destruction 1230 * Destruction
1245 ****************************************************************************/ 1231 ****************************************************************************/
… …
1302 else 1288 else
1303 op->skill = NULL; 1289 op->skill = NULL;
1304 1290
1305 op->change_skill (find_skill_by_name (op, op->skill)); 1291 op->change_skill (find_skill_by_name (op, op->skill));
1306 1292
1307 for (i = -range; i < range; i++) 1293 for (i = -range; i <= range; i++)
1308 { 1294 {
1309 for (j = -range; j < range; j++) 1295 for (j = -range; j <= range; j++)
1310 { 1296 {
1311 m = op->map; 1297 m = op->map;
1312 sx = op->x + i; 1298 sx = op->x + i;
1313 sy = op->y + j; 1299 sy = op->y + j;
1314 1300
… …
1331 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER))) 1317 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))
1332 { 1318 {
1333 if (spell_ob->subtype == SP_DESTRUCTION) 1319 if (spell_ob->subtype == SP_DESTRUCTION)
1334 { 1320 {
1335 hit_player (tmp, dam, op, spell_ob->attacktype, 0); 1321 hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1322
1336 if (spell_ob->other_arch) 1323 if (spell_ob->other_arch)
1337 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op); 1324 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);
1338 } 1325 }
1339 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100) 1326 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)
1340 { 1327 {
… …
1468 1455
1469 /* We precompute some values here so that we don't have to keep 1456 /* We precompute some values here so that we don't have to keep
1470 * doing it over and over again. 1457 * doing it over and over again.
1471 */ 1458 */
1472 god = find_god (determine_god (op)); 1459 god = find_god (determine_god (op));
1473 level = caster_level (caster, spell); 1460 level = casting_level (caster, spell);
1474 range = spell->range + SP_level_range_adjust (caster, spell); 1461 range = spell->range + SP_level_range_adjust (caster, spell);
1475 1462
1476 /* On the bright side, no monster should ever have a race of GOD_... 1463 /* On the bright side, no monster should ever have a race of GOD_...
1477 * so even if the player doesn't worship a god, if race=GOD_.., it 1464 * so even if the player doesn't worship a god, if race=GOD_.., it
1478 * won't ever match anything. 1465 * won't ever match anything.
… …
1628 * about. was called move_ball_lightning, but since more than the ball 1615 * about. was called move_ball_lightning, but since more than the ball
1629 * lightning spell used it, that seemed misnamed. 1616 * lightning spell used it, that seemed misnamed.
1630 * op is the spell effect. 1617 * op is the spell effect.
1631 * note that duration is handled by process_object() in time.c 1618 * note that duration is handled by process_object() in time.c
1632 */ 1619 */
1633
1634void 1620void
1635move_ball_spell (object *op) 1621move_ball_spell (object *op)
1636{ 1622{
1637 int i, j, dam_save, dir, mflags; 1623 int i, j, dam_save, dir, mflags;
1638 sint16 nx, ny, hx, hy; 1624 sint16 nx, ny, hx, hy;
… …
1704 1690
1705 if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op))) 1691 if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))
1706 { 1692 {
1707 if (j) 1693 if (j)
1708 op->stats.dam = dam_save / 2; 1694 op->stats.dam = dam_save / 2;
1695
1709 hit_map (op, j, op->attacktype, 1); 1696 hit_map (op, j, op->attacktype, 1);
1710
1711 } 1697 }
1712 1698
1713 /* insert the other arch */ 1699 /* insert the other arch */
1714 if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))) 1700 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); 1701 m->insert (arch_to_object (op->other_arch), hx, hy, op);
… …
1729 1715
1730 op->direction = i; 1716 op->direction = i;
1731 } 1717 }
1732} 1718}
1733 1719
1734
1735/* move_swarm_spell: peterm 1720/* move_swarm_spell: peterm
1736 * This is an implementation of the swarm spell. It was written for 1721 * 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 1722 * 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 1723 * 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 1724 * 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. 1725 * from a set of squares surrounding the caster, in a given direction.
1741 */ 1726 */
1742
1743void 1727void
1744move_swarm_spell (object *op) 1728move_swarm_spell (object *op)
1745{ 1729{
1746#if 0 1730#if 0
1747 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 }; 1731 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 }; 1732 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; 1733 sint16 target_x, target_y, origin_x, origin_y;
1750 int adjustdir; 1734 int adjustdir;
1751 maptile *m; 1735 maptile *m;
1752#endif 1736#endif
1753 int basedir;
1754 object *owner; 1737 object *owner = op->env;
1755 1738
1756 owner = op->owner; 1739 if (!owner) // MUST not happen, remove when true TODO
1757 if (op->duration == 0 || owner == NULL)
1758 { 1740 {
1741 LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1759 op->destroy (); 1742 op->destroy ();
1760 return; 1743 return;
1761 } 1744 }
1762 1745
1746 if (!op->duration || !owner->is_on_map ())
1747 {
1748 op->drop_and_destroy ();
1749 return;
1750 }
1751
1763 op->duration--; 1752 op->duration--;
1764 1753
1765 basedir = op->direction; 1754 int basedir = op->direction;
1766 if (basedir == 0) 1755 if (!basedir)
1767 { 1756 {
1768 /* spray in all directions! 8) */ 1757 /* spray in all directions! 8) */
1769 basedir = rndm (1, 8); 1758 op->facing = (op->facing + op->state) & 7;
1759 basedir = op->facing + 1;
1770 } 1760 }
1771 1761
1772#if 0 1762#if 0
1773 // this is bogus: it causes wrong places to be checked below 1763 // this is bogus: it causes wrong places to be checked below
1774 // (a wall 2 cells away will block the effect...) and 1764 // (a wall 2 cells away will block the effect...) and
… …
1835 { 1825 {
1836 /* Bullet spells have a bunch more customization that needs to be done */ 1826 /* Bullet spells have a bunch more customization that needs to be done */
1837 if (op->spell->subtype == SP_BULLET) 1827 if (op->spell->subtype == SP_BULLET)
1838 fire_bullet (owner, op, basedir, op->spell); 1828 fire_bullet (owner, op, basedir, op->spell);
1839 else if (op->spell->subtype == SP_MAGIC_MISSILE) 1829 else if (op->spell->subtype == SP_MAGIC_MISSILE)
1840 fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell); 1830 fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
1841 } 1831 }
1842} 1832}
1843
1844
1845
1846 1833
1847/* fire_swarm: 1834/* fire_swarm:
1848 * The following routine creates a swarm of objects. It actually 1835 * The following routine creates a swarm of objects. It actually
1849 * sets up a specific swarm object, which then fires off all 1836 * sets up a specific swarm object, which then fires off all
1850 * the parts of the swarm. 1837 * the parts of the swarm.
… …
1853 * caster: the caster (owner, wand, rod, scroll) 1840 * caster: the caster (owner, wand, rod, scroll)
1854 * dir: the direction everything will be fired in 1841 * dir: the direction everything will be fired in
1855 * spell - the spell that is this spell. 1842 * spell - the spell that is this spell.
1856 * n: the number to be fired. 1843 * n: the number to be fired.
1857 */ 1844 */
1858
1859int 1845int
1860fire_swarm (object *op, object *caster, object *spell, int dir) 1846fire_swarm (object *op, object *caster, object *spell, int dir)
1861{ 1847{
1862 object *tmp;
1863 int i;
1864
1865 if (!spell->other_arch) 1848 if (!spell->other_arch)
1866 return 0; 1849 return 0;
1867 1850
1868 tmp = get_archetype (SWARM_SPELL); 1851 object *tmp = archetype::get (SWARM_SPELL);
1869 tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */ 1852
1870 set_spell_skill (op, caster, spell, tmp); 1853 set_spell_skill (op, caster, spell, tmp);
1871
1872 tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */ 1854 tmp->level = casting_level (caster, spell); /* needed later, to get level dep. right. */
1873 tmp->spell = arch_to_object (spell->other_arch); 1855 tmp->spell = spell->other_arch->instance ();
1874
1875 tmp->attacktype = tmp->spell->attacktype; 1856 tmp->attacktype = tmp->spell->attacktype;
1876 1857
1877 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) 1858 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1878 if (!tailor_god_spell (tmp, op)) 1859 if (!tailor_god_spell (tmp, op))
1879 return 1; 1860 return 1;
1880 1861
1881 tmp->duration = SP_level_duration_adjust (caster, spell); 1862 tmp->duration = SP_level_duration_adjust (caster, spell);
1882 for (i = 0; i < spell->duration; i++) 1863 for (int i = 0; i < spell->duration; i++)
1883 tmp->duration += die_roll (1, 3, op, PREFER_HIGH); 1864 tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1884 1865
1866 tmp->invisible = 1;
1867 tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1885 tmp->direction = dir; 1868 tmp->direction = dir;
1886 tmp->invisible = 1; 1869 tmp->facing = rndm (1, 8); // initial firing direction
1870 tmp->state = rndm (4) * 2 + 1; // direction increment
1887 1871
1888 tmp->insert_at (op, op); 1872 op->insert (tmp);
1873
1889 return 1; 1874 return 1;
1890} 1875}
1891
1892 1876
1893/* See the spells documentation file for why this is its own 1877/* See the spells documentation file for why this is its own
1894 * function. 1878 * function.
1895 */ 1879 */
1896int 1880int
… …
1927 if (QUERY_FLAG (target, FLAG_MONSTER)) 1911 if (QUERY_FLAG (target, FLAG_MONSTER))
1928 { 1912 {
1929 /* oky doky. got a target monster. Lets make a blinding attack */ 1913 /* oky doky. got a target monster. Lets make a blinding attack */
1930 if (target->head) 1914 if (target->head)
1931 target = target->head; 1915 target = target->head;
1916
1932 (void) hit_player (target, dam, op, spell->attacktype, 1); 1917 hit_player (target, dam, op, spell->attacktype, 1);
1933 return 1; /* one success only! */ 1918 return 1; /* one success only! */
1934 } 1919 }
1935 } 1920 }
1936 1921
1937 /* no live target, perhaps a wall is in the way? */ 1922 /* no live target, perhaps a wall is in the way? */
… …
2017 object *disease = arch_to_object (spell->other_arch); 2002 object *disease = arch_to_object (spell->other_arch);
2018 2003
2019 disease->set_owner (op); 2004 disease->set_owner (op);
2020 set_spell_skill (op, caster, spell, disease); 2005 set_spell_skill (op, caster, spell, disease);
2021 disease->stats.exp = 0; 2006 disease->stats.exp = 0;
2022 disease->level = caster_level (caster, spell); 2007 disease->level = casting_level (caster, spell);
2023 2008
2024 /* do level adjustments */ 2009 /* do level adjustments */
2025 if (disease->stats.wc) 2010 if (disease->stats.wc)
2026 disease->stats.wc += dur_mod / 2; 2011 disease->stats.wc += dur_mod / 2;
2027 2012

Diff Legend

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