crawl-ref/source/mon-project.cc

   1 /**
   2  * @file
   3  * @brief Slow projectiles, done as monsters.
   4 **/
   5
   6 #include "AppHdr.h"
   7
   8 #include "mon-project.h"
   9
  10 #include <cmath>
  11 #include <cstdio>
  12 #include <cstdlib>
  13 #include <cstring>
  14
  15 #include "act-iter.h"
  16 #include "areas.h"
  17 #include "cloud.h"
  18 #include "directn.h"
  19 #include "env.h"
  20 #include "itemprop.h"
  21 #include "message.h"
  22 #include "mgen_data.h"
  23 #include "mon-death.h"
  24 #include "mon-place.h"
  25 #include "ouch.h"
  26 #include "shout.h"
  27 #include "stepdown.h"
  28 #include "terrain.h"
  29 #include "viewchar.h"
  30
  31 static void _fuzz_direction(const actor *caster, monster& mon, int pow);
  32
  33 spret_type cast_iood(actor *caster, int pow, bolt *beam, float vx, float vy,
  34                      int foe, bool fail)
  35 {
  36     const bool is_player = caster->is_player();
  37     if (beam && is_player && !player_tracer(ZAP_IOOD, pow, *beam))
  38         return SPRET_ABORT;
  39
  40     fail_check();
  41
  42     int mtarg = !beam ? MHITNOT :
  43                 beam->target == you.pos() ? MHITYOU : mgrd(beam->target);
  44
  45     monster *mon = place_monster(mgen_data(MONS_ORB_OF_DESTRUCTION,
  46                 (is_player) ? BEH_FRIENDLY :
  47                     ((monster*)caster)->friendly() ? BEH_FRIENDLY : BEH_HOSTILE,
  48                 caster,
  49                 0,
  50                 SPELL_IOOD,
  51                 coord_def(),
  52                 mtarg,
  53                 0,
  54                 GOD_NO_GOD), true, true);
  55     if (!mon)
  56     {
  57         mprf(MSGCH_ERROR, "Failed to spawn projectile.");
  58         return SPRET_ABORT;
  59     }
  60
  61     if (beam)
  62     {
  63         beam->choose_ray();
  64 #ifdef DEBUG_DIAGNOSTICS
  65         const coord_def pos = caster->pos();
  66         dprf("beam (%d,%d)+t*(%d,%d)  ray (%f,%f)+t*(%f,%f)",
  67             pos.x, pos.y, beam->target.x - pos.x, beam->target.y - pos.y,
  68             beam->ray.r.start.x - 0.5, beam->ray.r.start.y - 0.5,
  69             beam->ray.r.dir.x, beam->ray.r.dir.y);
  70 #endif
  71         mon->props[IOOD_X].get_float() = beam->ray.r.start.x - 0.5;
  72         mon->props[IOOD_Y].get_float() = beam->ray.r.start.y - 0.5;
  73         mon->props[IOOD_VX].get_float() = beam->ray.r.dir.x;
  74         mon->props[IOOD_VY].get_float() = beam->ray.r.dir.y;
  75         _fuzz_direction(caster, *mon, pow);
  76     }
  77     else
  78     {
  79         // Multi-orb: spread the orbs a bit, otherwise diagonal ones might
  80         // fail to leave the cardinal direction: orb A moves -0.4,+0.9 and
  81         // orb B +0.4,+0.9, both rounded to 0,1.
  82         mon->props[IOOD_X].get_float() = caster->pos().x + 0.4 * vx;
  83         mon->props[IOOD_Y].get_float() = caster->pos().y + 0.4 * vy;
  84         mon->props[IOOD_VX].get_float() = vx;
  85         mon->props[IOOD_VY].get_float() = vy;
  86     }
  87
  88     mon->props[IOOD_KC].get_byte() = (is_player) ? KC_YOU :
  89         ((monster*)caster)->friendly() ? KC_FRIENDLY : KC_OTHER;
  90     mon->props[IOOD_POW].get_short() = pow;
  91     mon->flags &= ~MF_JUST_SUMMONED;
  92     mon->props[IOOD_CASTER].get_string() = caster->as_monster()
  93         ? caster->name(DESC_A, true)
  94         : (caster->is_player()) ? "you" : "";
  95     mon->summoner = caster->mid;
  96
  97     if (caster->is_player() || caster->type == MONS_PLAYER_GHOST
  98         || caster->type == MONS_PLAYER_ILLUSION)
  99     {
 100         mon->props[IOOD_FLAWED].get_byte() = true;
 101     }
 102
 103     // Move away from the caster's square.
 104     iood_act(*mon, true);
 105
 106     // If the foe was adjacent to the caster, that might have destroyed it.
 107     if (mon->alive())
 108     {
 109         // We need to take at least one full move (for the above), but let's
 110         // randomize it and take more so players won't get guaranteed instant
 111         // damage.
 112         mon->lose_energy(EUT_MOVE, 2, random2(3)+2);
 113
 114         // Multi-orbs don't home during the first move, they'd likely
 115         // immediately explode otherwise.
 116         if (foe != MHITNOT)
 117             mon->foe = foe;
 118     }
 119
 120     return SPRET_SUCCESS;
 121 }
 122
 123 /**
 124  * Find a target for a bursty (non-player-targeted) IOOD.
 125  *
 126  * Try to find an enemy that's at a reasonable angle from the angle the IOOD
 127  * is fired at, preferring the given foe (if a non-MHITNOT foe is given) if
 128  * they're valid, and otherwise preferring the closest valid foe.
 129  *
 130  * @param angle             The angle that the IOOD will be fired at, relative
 131  *                          to the player's position.
 132  * @param preferred_foe     The mindex of a target to choose if possible; may
 133  *                          be MHITNOT (no preferred target)
 134  * @return                  The mindex of a valid target for the IOOD.
 135  */
 136 static int _burst_iood_target(double iood_angle, int preferred_foe)
 137 {
 138     int closest_foe = MHITNOT;
 139     int closest_dist = INT_MAX;
 140
 141     for (monster_near_iterator mi(you.pos(), LOS_SOLID); mi; ++mi)
 142     {
 143         const monster* m = *mi;
 144         ASSERT(m);
 145
 146         if (!you.can_see(m) || mons_is_projectile(m))
 147             continue;
 148
 149         // is this position at a valid angle?
 150         const coord_def delta = mi->pos() - you.pos();
 151         const double angle = atan2(delta.x, delta.y);
 152         const double abs_angle_diff = abs(angle - fmod(iood_angle, PI * 2));
 153         const double angle_diff = (abs_angle_diff > PI) ?
 154                                         2 * PI - abs_angle_diff :
 155                                         abs_angle_diff;
 156         if (angle_diff >= PI / 3)
 157         {
 158             dprf("can't target %s; angle diff %f",
 159                  m->name(DESC_PLAIN).c_str(), angle_diff);
 160             continue;
 161         }
 162
 163         // if preferred foe is valid, choose it.
 164         if (m->mindex() == preferred_foe)
 165         {
 166             dprf("preferred target %s is valid burst target (delta %f)",
 167                  m->name(DESC_PLAIN).c_str(), angle_diff);
 168             return preferred_foe;
 169         }
 170
 171         if (mons_aligned(m, &you) || mons_is_firewood(m))
 172         {
 173             dprf("skipping invalid burst target %s (%s)",
 174                  m->name(DESC_PLAIN).c_str(),
 175                  mons_aligned(m, &you) ? "aligned" : "firewood");
 176             continue;
 177         }
 178
 179         const int dist = grid_distance(m->pos(), you.pos());
 180         // on distance ties, bias by iterator order (mindex)
 181         if (dist >= closest_dist)
 182         {
 183             dprf("%s not closer to target than closest (%d vs %d)",
 184                  m->name(DESC_PLAIN).c_str(), dist, closest_dist);
 185             continue;
 186         }
 187
 188         dprf("%s is valid burst target (delta %f, dist %d)",
 189              m->name(DESC_PLAIN).c_str(), angle_diff, dist);
 190         closest_dist = dist;
 191         closest_foe = m->mindex();
 192     }
 193
 194     const int foe = closest_foe != MHITNOT ? closest_foe : preferred_foe;
 195     dprf("targeting %d", foe);
 196     return foe;
 197 }
 198
 199 void cast_iood_burst(int pow, coord_def target)
 200 {
 201     const monster* mons = monster_at(target);
 202     const int preferred_foe = mons && you.can_see(mons) ?
 203                                                             mons->mindex() :
 204                                                             MHITNOT;
 205
 206     const int n_orbs = random_range(3, 7);
 207     dprf("Bursting %d orbs.", n_orbs);
 208     const double angle0 = random2(2097152) * PI * 2 / 2097152;
 209
 210     for (int i = 0; i < n_orbs; i++)
 211     {
 212         const double angle = angle0 + i * PI * 2 / n_orbs;
 213         const int foe = _burst_iood_target(angle, preferred_foe);
 214         cast_iood(&you, pow, 0, sin(angle), cos(angle), foe);
 215     }
 216 }
 217
 218 static void _normalize(float &x, float &y)
 219 {
 220     const float d = sqrt(x*x + y*y);
 221     if (d <= 0.000001)
 222         return;
 223     x/=d;
 224     y/=d;
 225 }
 226
 227 // angle measured in chord length
 228 static bool _in_front(float vx, float vy, float dx, float dy, float angle)
 229 {
 230     return (dx-vx)*(dx-vx) + (dy-vy)*(dy-vy) <= (angle*angle);
 231 }
 232
 233 static void _iood_stop(monster& mon, bool msg = true)
 234 {
 235     if (!mon.alive())
 236         return;
 237
 238     if (mons_is_boulder(&mon))
 239     {
 240         // Deduct the energy first - the move they made that just stopped
 241         // them was a speed 14 move.
 242         mon.lose_energy(EUT_MOVE);
 243         mon.del_ench(ENCH_ROLLING,!msg);
 244         return;
 245     }
 246
 247     if (msg)
 248         simple_monster_message(&mon, " dissipates.");
 249     dprf("iood: dissipating");
 250     monster_die(&mon, KILL_DISMISSED, NON_MONSTER);
 251 }
 252
 253 static void _fuzz_direction(const actor *caster, monster& mon, int pow)
 254 {
 255     const float x = mon.props[IOOD_X];
 256     const float y = mon.props[IOOD_Y];
 257     float vx = mon.props[IOOD_VX];
 258     float vy = mon.props[IOOD_VY];
 259
 260     _normalize(vx, vy);
 261
 262     if (pow < 10)
 263         pow = 10;
 264     const float off = (coinflip() ? -1 : 1) * 0.25;
 265     float tan = (random2(31) - 15) * 0.019; // approx from degrees
 266     tan *= 75.0 / pow;
 267     if (caster && caster->inaccuracy())
 268         tan *= 2;
 269
 270     // Cast either from left or right hand.
 271     mon.props[IOOD_X] = x + vy*off;
 272     mon.props[IOOD_Y] = y - vx*off;
 273     // And off the direction a bit.
 274     mon.props[IOOD_VX] = vx + vy*tan;
 275     mon.props[IOOD_VY] = vy - vx*tan;
 276 }
 277
 278 // Alas, too much differs to reuse beam shield blocks :(
 279 static bool _iood_shielded(monster& mon, actor &victim)
 280 {
 281     if (!victim.shielded() || victim.incapacitated())
 282         return false;
 283
 284     const int to_hit = 15 + (mons_is_projectile(mon.type) ?
 285         mon.props[IOOD_POW].get_short()/12 : mon.get_hit_dice()/2);
 286     const int con_block = random2(to_hit + victim.shield_block_penalty());
 287     const int pro_block = victim.shield_bonus();
 288     dprf("iood shield: pro %d, con %d", pro_block, con_block);
 289     return pro_block >= con_block;
 290 }
 291
 292 static bool _boulder_hit(monster& mon, const coord_def &pos)
 293 {
 294     actor *victim = actor_at(pos);
 295     if (victim)
 296     {
 297         simple_monster_message(&mon, (string(" smashes into ")
 298                                + victim->name(DESC_THE) + "!").c_str());
 299
 300         int dam = victim->apply_ac(roll_dice(3, 20));
 301         victim->hurt(&mon, dam, BEAM_MISSILE, KILLED_BY_ROLLING);
 302     }
 303
 304     noisy(5, pos);
 305     return victim && victim->alive() || !mon.alive();
 306 }
 307
 308 static bool _iood_hit(monster& mon, const coord_def &pos, bool big_boom = false)
 309 {
 310     if (mons_is_boulder(&mon))
 311         return _boulder_hit(mon, pos);
 312
 313     bolt beam;
 314     beam.name = "orb of destruction";
 315     beam.flavour = BEAM_DEVASTATION;
 316     beam.attitude = mon.attitude;
 317
 318     actor *caster = actor_by_mid(mon.summoner);
 319     if (!caster)        // caster is dead/gone, blame the orb itself (as its
 320         caster = &mon;  // friendliness is correct)
 321     beam.set_agent(caster);
 322     if (mon.props.exists(IOOD_REFLECTOR))
 323     {
 324         beam.reflections = 1;
 325
 326         const mid_t refl_mid = mon.props[IOOD_REFLECTOR].get_int64();
 327
 328         if (refl_mid == MID_PLAYER)
 329             beam.reflector = MID_PLAYER;
 330         else
 331         {
 332             // If the reflecting monster has died, credit the original caster.
 333             const monster * const rmon = monster_by_mid(refl_mid);
 334             beam.reflector = rmon ? refl_mid : caster->mid;
 335         }
 336     }
 337     beam.colour = WHITE;
 338     beam.glyph = dchar_glyph(DCHAR_FIRED_BURST);
 339     beam.range = 1;
 340     beam.source = pos;
 341     beam.target = pos;
 342     beam.hit = AUTOMATIC_HIT;
 343     beam.source_name = mon.props[IOOD_CASTER].get_string();
 344
 345     int pow = mon.props[IOOD_POW].get_short();
 346     pow = stepdown_value(pow, 30, 30, 200, -1);
 347     const int dist = mon.props[IOOD_DIST].get_int();
 348     ASSERT(dist >= 0);
 349     if (dist < 4)
 350         pow = pow * (dist*2+3) / 10;
 351     beam.damage = dice_def(9, pow / 4);
 352
 353     if (dist < 3)
 354         beam.name = "wavering " + beam.name;
 355     if (dist < 2)
 356         beam.hit_verb = "weakly hits";
 357     beam.ex_size = 1;
 358     beam.loudness = 7;
 359
 360     monster_die(&mon, KILL_DISMISSED, NON_MONSTER);
 361
 362     if (big_boom)
 363         beam.explode(true, false);
 364     else
 365         beam.fire();
 366
 367     return true;
 368 }
 369
 370 // returns true if the orb is gone
 371 bool iood_act(monster& mon, bool no_trail)
 372 {
 373     bool iood = mons_is_projectile(mon.type);
 374     ASSERT(iood || mons_is_boulder(&mon));
 375
 376     float x = mon.props[IOOD_X];
 377     float y = mon.props[IOOD_Y];
 378     float vx = mon.props[IOOD_VX];
 379     float vy = mon.props[IOOD_VY];
 380
 381     dprf("iood_act: pos=(%d,%d) rpos=(%f,%f) v=(%f,%f) foe=%d",
 382          mon.pos().x, mon.pos().y,
 383          x, y, vx, vy, mon.foe);
 384
 385     if (!vx && !vy) // not initialized
 386     {
 387         _iood_stop(mon);
 388         return true;
 389     }
 390
 391     _normalize(vx, vy);
 392
 393     const actor *foe = mon.get_foe();
 394     // If the target is gone, the orb continues on a ballistic course since
 395     // picking a new one would require intelligence.
 396
 397     // Boulders don't home onto their targets. IOODs can't home in on a
 398     // submerged creature.
 399     if (iood && foe && !foe->submerged())
 400     {
 401         const coord_def target = foe->pos();
 402         float dx = target.x - x;
 403         float dy = target.y - y;
 404         _normalize(dx, dy);
 405
 406         // Special case:
 407         // Moving diagonally when the orb is just about to hit you
 408         //      2
 409         //    ->*1
 410         // (from 1 to 2) would be a guaranteed escape. This may be
 411         // realistic (strafing!), but since the game has no non-cheesy
 412         // means of waiting a small fraction of a turn, we don't want it.
 413         const int old_t_pos = mon.props[IOOD_TPOS].get_short();
 414         const coord_def rpos(static_cast<int>(round(x)), static_cast<int>(round(y)));
 415         if (old_t_pos && old_t_pos != (256 * target.x + target.y)
 416             && (rpos - target).rdist() <= 1
 417             // ... but following an orb is ok.
 418             && _in_front(vx, vy, dx, dy, 1.5)) // ~97 degrees
 419         {
 420             vx = dx;
 421             vy = dy;
 422         }
 423         mon.props[IOOD_TPOS].get_short() = 256 * target.x + target.y;
 424
 425         if (!_in_front(vx, vy, dx, dy, 0.3)) // ~17 degrees
 426         {
 427             float ax, ay;
 428             if (dy*vx < dx*vy)
 429                 ax = vy, ay = -vx, dprf("iood: veering left");
 430             else
 431                 ax = -vy, ay = vx, dprf("iood: veering right");
 432             vx += ax * 0.3;
 433             vy += ay * 0.3;
 434         }
 435         else
 436             dprf("iood: keeping course");
 437
 438         _normalize(vx, vy);
 439         mon.props[IOOD_VX] = vx;
 440         mon.props[IOOD_VY] = vy;
 441     }
 442
 443 move_again:
 444
 445     x += vx;
 446     y += vy;
 447
 448     mon.props[IOOD_X] = x;
 449     mon.props[IOOD_Y] = y;
 450     mon.props[IOOD_DIST].get_int()++;
 451
 452     const coord_def pos(static_cast<int>(round(x)), static_cast<int>(round(y)));
 453     if (!in_bounds(pos))
 454     {
 455         _iood_stop(mon);
 456         return true;
 457     }
 458
 459     if (iood && mon.props.exists(IOOD_FLAWED))
 460     {
 461         const actor *caster = actor_by_mid(mon.summoner);
 462         if (!caster || caster->pos().origin() ||
 463             (caster->pos() - pos).rdist() > LOS_RADIUS)
 464         {   // not actual vision, because of the smoke trail
 465             _iood_stop(mon);
 466             return true;
 467         }
 468     }
 469
 470     if (pos == mon.pos())
 471         return false;
 472
 473     if (!no_trail)
 474     {
 475         place_cloud(iood ? CLOUD_MAGIC_TRAIL : CLOUD_DUST_TRAIL, mon.pos(),
 476                     2 + random2(3), &mon);
 477     }
 478
 479     actor *victim = actor_at(pos);
 480     if (cell_is_solid(pos) || victim)
 481     {
 482         if (cell_is_solid(pos))
 483         {
 484             const int boulder_noisiness = 5; // don't want this to be big
 485             if (you.see_cell(pos) && you.see_cell(mon.pos()))
 486             {
 487                 mprf("%s hits %s", mon.name(DESC_THE, true).c_str(),
 488                      feature_description_at(pos, false, DESC_A).c_str());
 489                 if (!iood)
 490                     noisy(boulder_noisiness, pos);
 491             }
 492             else if (!iood && !silenced(you.pos()))
 493                 noisy(boulder_noisiness, pos, "You hear a crash.");
 494
 495             if (!iood) // boulders need to stop now
 496             {
 497                 _iood_stop(mon);
 498                 return true;
 499             }
 500         }
 501
 502         monster* mons = (victim && victim->is_monster()) ?
 503             (monster*) victim : 0;
 504
 505         if (mons && iood && mons_is_projectile(victim->type))
 506         {
 507             // Weak orbs just fizzle instead of exploding.
 508             if (mons->props[IOOD_DIST].get_int() < 2
 509                 || mon.props[IOOD_DIST].get_int() < 2)
 510             {
 511                 if (mons->props[IOOD_DIST].get_int() < 2)
 512                 {
 513                     if (you.see_cell(pos))
 514                         mpr("The orb fizzles.");
 515                     monster_die(mons, KILL_DISMISSED, NON_MONSTER);
 516                 }
 517
 518                 // Return, if the acting orb fizzled.
 519                 if (mon.props[IOOD_DIST].get_int() < 2)
 520                 {
 521                     if (you.see_cell(pos))
 522                         mpr("The orb fizzles.");
 523                     monster_die(&mon, KILL_DISMISSED, NON_MONSTER);
 524                     return true;
 525                 }
 526             }
 527             else
 528             {
 529                 if (mon.observable())
 530                     mpr("The orbs collide in a blinding explosion!");
 531                 else
 532                     mpr("You hear a loud magical explosion!");
 533                 noisy(40, pos);
 534                 monster_die(mons, KILL_DISMISSED, NON_MONSTER);
 535                 _iood_hit(mon, pos, true);
 536                 return true;
 537             }
 538         }
 539
 540         if (mons && mons_is_boulder(&mon) && mons_is_boulder(mons))
 541         {
 542             if (mon.observable())
 543             {
 544                 mpr("The boulders collide with a stupendous crash!");
 545                 noisy(20, pos);
 546             }
 547             else
 548                 noisy(20, pos, "You hear a loud crashing sound!");
 549
 550             // Remove ROLLING and add DAZED
 551             _iood_stop(mon);
 552             _iood_stop(*mons);
 553             if (!mon.check_clarity(false))
 554                 mon.add_ench(ENCH_CONFUSION);
 555             if (!mons->check_clarity(false))
 556                 mons->add_ench(ENCH_CONFUSION);
 557             return true;
 558         }
 559
 560         if (mons && (mons->submerged() || mons->type == MONS_BATTLESPHERE))
 561         {
 562             // Try to swap with the submerged creature.
 563             if (mon.swap_with(mons))
 564             {
 565                 dprf("iood: Swapping with a submerged monster.");
 566                 return false;
 567             }
 568             else // if swap fails, move ahead
 569             {
 570                 dprf("iood: Boosting above a submerged monster (can't swap).");
 571                 mon.lose_energy(EUT_MOVE);
 572                 goto move_again;
 573             }
 574         }
 575
 576         if (victim && _iood_shielded(mon, *victim))
 577         {
 578             item_def *shield = victim->shield();
 579             if (!shield || !shield_reflects(*shield))
 580             {
 581                 if (victim->is_player())
 582                     mprf("You block %s.", mon.name(DESC_THE, true).c_str());
 583                 else
 584                 {
 585                     simple_monster_message(mons, (" blocks "
 586                         + mon.name(DESC_THE, true) + ".").c_str());
 587                 }
 588                 victim->shield_block_succeeded(&mon);
 589                 _iood_stop(mon);
 590                 return true;
 591             }
 592
 593             if (victim->is_player())
 594             {
 595                 mprf("Your %s reflects %s!",
 596                     shield->name(DESC_PLAIN).c_str(),
 597                     mon.name(DESC_THE, true).c_str());
 598                 ident_reflector(shield);
 599             }
 600             else if (you.see_cell(pos))
 601             {
 602                 if (victim->observable())
 603                 {
 604                     mprf("%s reflects %s with %s %s!",
 605                         victim->name(DESC_THE, true).c_str(),
 606                         mon.name(DESC_THE, true).c_str(),
 607                         mon.pronoun(PRONOUN_POSSESSIVE).c_str(),
 608                         shield->name(DESC_PLAIN).c_str());
 609                     ident_reflector(shield);
 610                 }
 611                 else
 612                 {
 613                     mprf("%s bounces off thin air!",
 614                         mon.name(DESC_THE, true).c_str());
 615                 }
 616             }
 617             victim->shield_block_succeeded(&mon);
 618
 619             // mid_t is unsigned so won't fit in a plain int
 620             mon.props[IOOD_REFLECTOR] = (int64_t) victim->mid;
 621             mon.props[IOOD_VX] = vx = -vx;
 622             mon.props[IOOD_VY] = vy = -vy;
 623
 624             // Need to get out of the victim's square.
 625
 626             // If you're next to the caster and both of you wear shields of
 627             // reflection, this can lead to a brief game of ping-pong, but
 628             // rapidly increasing shield penalties will make it short.
 629             mon.lose_energy(EUT_MOVE);
 630             goto move_again;
 631         }
 632
 633         if (_iood_hit(mon, pos))
 634         {
 635             if (!iood)
 636                 _iood_stop(mon);
 637             return true;
 638         }
 639     }
 640
 641     // Boulders stop at lava/water to prevent unusual behaviour;
 642     // skimming across the water like a pebble could be justifiable, but
 643     // it raises too many questions.
 644     if (!iood && (!feat_has_solid_floor(grd(pos)) || feat_is_water(grd(pos))))
 645     {
 646         mprf("%s screeches to a halt.", mon.name(DESC_THE, true).c_str());
 647         _iood_stop(mon,false);
 648         return true;
 649     }
 650
 651     if (!mon.move_to_pos(pos))
 652     {
 653         _iood_stop(mon);
 654         return true;
 655     }
 656
 657     // move_to_pos() just trashed the coords, set them again
 658     mon.props[IOOD_X] = x;
 659     mon.props[IOOD_Y] = y;
 660
 661     return false;
 662 }
 663
 664 // Reduced copy of iood_act to move the orb while the player
 665 // is off-level. Just goes straight and dissipates instead of
 666 // hitting anything.
 667 static bool _iood_catchup_move(monster& mon)
 668 {
 669     float x = mon.props[IOOD_X];
 670     float y = mon.props[IOOD_Y];
 671     float vx = mon.props[IOOD_VX];
 672     float vy = mon.props[IOOD_VY];
 673
 674     if (!vx && !vy) // not initialized
 675     {
 676         _iood_stop(mon, false);
 677         return true;
 678     }
 679
 680     _normalize(vx, vy);
 681
 682     x += vx;
 683     y += vy;
 684
 685     mon.props[IOOD_X] = x;
 686     mon.props[IOOD_Y] = y;
 687     mon.props[IOOD_DIST].get_int()++;
 688
 689     const coord_def pos(static_cast<int>(round(x)), static_cast<int>(round(y)));
 690     if (!in_bounds(pos))
 691     {
 692         _iood_stop(mon, true);
 693         return true;
 694     }
 695
 696     if (pos == mon.pos())
 697         return false;
 698
 699     actor *victim = actor_at(pos);
 700     if (cell_is_solid(pos) || victim)
 701     {
 702         // Just dissipate instead of hitting something.
 703         _iood_stop(mon, true);
 704         return true;
 705     }
 706     // Boulder doesn't travel over water/lava.
 707     if (mons_is_boulder(&mon)
 708         && (!feat_has_solid_floor(grd(pos)) || feat_is_water(grd(pos))))
 709     {
 710         _iood_stop(mon, false);
 711         return true;
 712     }
 713
 714     if (!mon.move_to_pos(pos))
 715     {
 716         _iood_stop(mon);
 717         return true;
 718     }
 719
 720     // move_to_pos() just trashed the coords, set them again
 721     mon.props[IOOD_X] = x;
 722     mon.props[IOOD_Y] = y;
 723
 724     return false;
 725 }
 726
 727 void iood_catchup(monster* mons, int pturns)
 728 {
 729     monster& mon = *mons;
 730     ASSERT(mon.is_projectile());
 731
 732     const int moves = pturns * mon.speed / BASELINE_DELAY;
 733
 734     // Handle some cases for IOOD only
 735     if (mons_is_projectile(mons))
 736     {
 737         if (moves > 50)
 738         {
 739             _iood_stop(mon, false);
 740             return;
 741         }
 742
 743         if (mon.props[IOOD_KC].get_byte() == KC_YOU)
 744         {
 745             // Left player's vision.
 746             _iood_stop(mon, false);
 747             return;
 748         }
 749     }
 750
 751     for (int i = 0; i < moves; ++i)
 752         if (_iood_catchup_move(mon))
 753             return;
 754 }
 755
 756 void boulder_start(monster *mon, bolt *beam)
 757 {
 758     mon->add_ench(ENCH_ROLLING);
 759     // Work out x/y/vx/vy from beam
 760     beam->choose_ray();
 761     mon->props[IOOD_X].get_float() = beam->ray.r.start.x - 0.5;
 762     mon->props[IOOD_Y].get_float() = beam->ray.r.start.y - 0.5;
 763     mon->props[IOOD_VX].get_float() = mons_is_fleeing(mon) ?
 764         -beam->ray.r.dir.x : beam->ray.r.dir.x;
 765     mon->props[IOOD_VY].get_float() = mons_is_fleeing(mon) ?
 766         -beam->ray.r.dir.y : beam->ray.r.dir.y;
 767     iood_act(*mon);
 768 }