fiddlerwoaroof/crawl - Change PM65H4V4GNPVIJFUQW57DC3VDB7TRUUNXKVZONQKEFZSK3AXX5GQC

Fix to intelligent friendlies avoiding traps. It actually works now. :)

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@2811 c06c8d41-db1a-0410-9941-cceddc491573

Created by j-p-e-g on November 8, 2007

PM65H4V4GNPVIJFUQW57DC3VDB7TRUUNXKVZONQKEFZSK3AXX5GQC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/monstuff.cc at line 4855 [5.1396662]

[4.5233]


static bool mon_can_move_to_pos(const monsters *monster, const int count_x,
                                const int count_y, bool just_check = false);

Replacement in crawl-ref/source/monstuff.cc at line 4859 [5.1396662]

B:BD[4.5234] → [6.1801:1876]

static bool is_trap_safe(const monsters *monster, const trap_struct &trap)

[4.5234]

[6.1876]

// Check whether a given trap (described by trap position) can be
// regarded as safe. Takes in account monster intelligence and allegiance.
// (just_check is used for intelligent friendlies trying to avoid traps.)
static bool is_trap_safe(const monsters *monster, const int trap_x,
                         const int trap_y, bool just_check = false)

Insertion in crawl-ref/source/monstuff.cc at line 4865 [5.1396662]
[6.1878]
[6.1878]
```
    const trap_struct &trap = env.trap[trap_at_xy(trap_x,trap_y)];
    
```

Replacement in crawl-ref/source/monstuff.cc at line 4875 [5.1396662]

B:BD[3.1791] → [3.1791:1922]

    // the player knows about (this could be annoying in a corridor)
    if (grd[monster->x][monster->y] != DNGN_UNDISCOVERED_TRAP

[3.1791]

[3.1922]

    // the player knows about (we're assuming s/he warned them about them)
    if (grd[trap_x][trap_y] != DNGN_UNDISCOVERED_TRAP

Replacement in crawl-ref/source/monstuff.cc at line 4880 [5.1396662]

B:BD[3.2047] → [3.2047:2322]

        const int x = monster->x;
        const int y = monster->y;
        // test for corridor-like environment (simple hack)
        if (!(grd[x-1][y] < DNGN_MINMOVE && grd[x+1][y] < DNGN_MINMOVE
              || grd[x][y-1] < DNGN_MINMOVE && grd[x][y+1] < DNGN_MINMOVE))

[3.2047]

[3.2322]

        if (just_check)
            return false; // square is blocked
        else

Replacement in crawl-ref/source/monstuff.cc at line 4884 [5.1396662]

B:BD[3.2332] → [3.2332:2401]

            return (monster->hit_points == monster->max_hit_points);

[3.2332]

[3.2401]

            // test for corridor-like environment
            const int x = trap_x - monster->x;
            const int y = trap_y - monster->y;
            
            // The question is whether the monster (m) can easily reach its
            // presumable destination (x) without stepping on the trap. Traps
            // in corridors do not allow this. See e.g
            //  #x#        ##
            //  #^#   or  m^x
            //   m         ##
            //
            // The same problem occurs if paths are blocked by monsters,
            // hostile terrain or other traps rather than walls.
            // What we do is check whether the squares with the relative
            // positions (-1,0)/(+1,0) or (0,-1)/(0,+1) form a "corridor"
            // (relative to the _current_ monster position rather than the
            // trap one) form a corridor-like environment. If they don't
            // the trap square is marked as "unsafe", otherwise the decision
            // will be made according to later tests (monster hp, trap type, ...)
            // If a monster still gets stuck in a corridor it will usually be
            // because it has less than half its maximum hp
            
            if ((mon_can_move_to_pos(monster, x-1, y, true)
                   || mon_can_move_to_pos(monster, x+1,y, true))
                && (mon_can_move_to_pos(monster, x,y-1, true)
                    || mon_can_move_to_pos(monster, x,y+1, true)))
            {
                return (false);
            }

Insertion in crawl-ref/source/monstuff.cc at line 4965 [5.1396662]

[7.7740]

[8.771]

}
// Check whether a monster can move to given square (described by its relative
// coordinates to the current monster position). just_check is true only for
// calls from is_trap_safe when checking the surrounding squares of a trap.
bool mon_can_move_to_pos(const monsters *monster, const int count_x,
                         const int count_y, bool just_check)
{
    const int targ_x = monster->x + count_x;
    const int targ_y = monster->y + count_y;
    
    // bounds check - don't consider moving out of grid!
    if (targ_x < 0 || targ_x >= GXM || targ_y < 0 || targ_y >= GYM)
        return false;
    dungeon_feature_type target_grid = grd[targ_x][targ_y];
    const int habitat = monster_habitat( monster->type );
    // effectively slows down monster movement across water.
    // Fire elementals can't cross at all.
    bool no_water = false;
    if (monster->type == MONS_FIRE_ELEMENTAL || one_chance_in(5))
        //okmove = DNGN_WATER_STUCK;
        no_water = true;
    const int targ_cloud_num  = env.cgrid[ targ_x ][ targ_y ];
    const int targ_cloud_type =
        targ_cloud_num == EMPTY_CLOUD? CLOUD_NONE
                                     : env.cloud[targ_cloud_num].type;
    const int curr_cloud_num = env.cgrid[ monster->x ][ monster->y ];
    const int curr_cloud_type =
        curr_cloud_num == EMPTY_CLOUD? CLOUD_NONE
                                     : env.cloud[curr_cloud_num].type;
    if (monster->type == MONS_BORING_BEETLE
        && (target_grid == DNGN_ROCK_WALL
            || target_grid == DNGN_CLEAR_ROCK_WALL))
    {
        // don't burrow out of bounds
        if (targ_x <= 7 || targ_x >= (GXM - 8)
            || targ_y <= 7 || targ_y >= (GYM - 8))
        {
            return false;
        }
        // don't burrow at an angle (legacy behaviour)
        if (count_x != 0 && count_y != 0)
        {
            return false;
        }
    }
    else if (!monster->can_pass_through(target_grid)
             || (no_water && target_grid >= DNGN_DEEP_WATER
                 && target_grid <= DNGN_WATER_STUCK))
    {
        return false;
    }
    else if (!habitat_okay( monster, target_grid ))
    {
        return false;
    }
    if (monster->type == MONS_WANDERING_MUSHROOM
        && see_grid(targ_x, targ_y))
    {
        return false;
    }
    // Water elementals avoid fire and heat
    if (monster->type == MONS_WATER_ELEMENTAL
        && (target_grid == DNGN_LAVA
            || targ_cloud_type == CLOUD_FIRE
            || targ_cloud_type == CLOUD_STEAM))
    {
        return false;
    }
    // Fire elementals avoid water and cold
    if (monster->type == MONS_FIRE_ELEMENTAL
        && (target_grid == DNGN_DEEP_WATER
            || target_grid == DNGN_SHALLOW_WATER
            || target_grid == DNGN_BLUE_FOUNTAIN
            || targ_cloud_type == CLOUD_COLD))
    {
        return false;
    }
    // Submerged water creatures avoid the shallows where
    // they would be forced to surface. -- bwr
    // [dshaligram] Monsters now prefer to head for deep water only if
    // they're low on hitpoints. No point in hiding if they want a
    // fight.
    if (habitat == DNGN_DEEP_WATER
        && (targ_x != you.x_pos || targ_y != you.y_pos)
        && target_grid != DNGN_DEEP_WATER
        && grd[monster->x][monster->y] == DNGN_DEEP_WATER
        && monster->hit_points < (monster->max_hit_points * 3) / 4)
    {
        return false;
    }
    
    // smacking the player is always a good move if we're
    // hostile (even if we're heading somewhere else)
    // also friendlies want to keep close to the player
    // so it's okay as well
    // smacking another monster is good, if the monsters
    // are aligned differently
    if (mgrd[targ_x][targ_y] != NON_MONSTER)
    {
        if (just_check)
        {
            if (targ_x == monster->x && targ_y == monster->y)
                return true;
                
            return false; // blocks square
        }
        const int thismonster = monster_index(monster),
                  targmonster = mgrd[targ_x][targ_y];
        if (mons_aligned(thismonster, targmonster)
            && targmonster != MHITNOT
            && targmonster != MHITYOU
            && !mons_can_displace(monster, &menv[targmonster]))
        {
            return false;
        }
    }
    // wandering through a trap is OK if we're pretty healthy,
    // really stupid, or immune to the trap
    const int which_trap = trap_at_xy(targ_x,targ_y);
    if (which_trap >= 0 && !is_trap_safe(monster, targ_x, targ_y, just_check))
    {
        return false;
    }
    if (targ_cloud_num != EMPTY_CLOUD)
    {
        if (curr_cloud_num != EMPTY_CLOUD
            && targ_cloud_type == curr_cloud_type)
        {
            return true;
        }
        switch (targ_cloud_type)
        {
            case CLOUD_FIRE:
                if (mons_res_fire(monster) > 0)
                    return true;
                if (monster->hit_points >= 15 + random2avg(46, 5))
                    return true;
                break;
            case CLOUD_STINK:
                if (mons_res_poison(monster) > 0)
                    return true;
                if (1 + random2(5) < monster->hit_dice)
                    return true;
                if (monster->hit_points >= random2avg(19, 2))
                    return true;
                break;
            case CLOUD_COLD:
                if (mons_res_cold(monster) > 0)
                    return true;
                if (monster->hit_points >= 15 + random2avg(46, 5))
                    return true;
                break;
            case CLOUD_POISON:
                if (mons_res_poison(monster) > 0)
                    return true;
                if (monster->hit_points >= random2avg(37, 4))
                    return true;
                break;
            // this isn't harmful, but dumb critters might think so.
            case CLOUD_GREY_SMOKE:
                if (mons_intel(monster->type) > I_ANIMAL || coinflip())
                    return true;
                if (mons_res_fire(monster) > 0)
                    return true;
                if (monster->hit_points >= random2avg(19, 2))
                    return true;
                break;
                
            default:
                return true;   // harmless clouds
        }
        // if we get here, the cloud is potentially harmful.
        // exceedingly dumb creatures will still wander in.
        if (mons_intel(monster->type) != I_PLANT)
            return false;
    }
    
    // if we end up here the monster can safely move
    return true;

Replacement in crawl-ref/source/monstuff.cc at line 5177 [5.1396662]
B:BD[5.1529766] → [5.1529766:1529803]
```
    int okmove = DNGN_SHALLOW_WATER;
```
[5.1529766]
[5.1529803]
```
    int okmove = DNGN_SHALLOW_WATER; // what does this actually do?
```

Replacement in crawl-ref/source/monstuff.cc at line 5212 [5.1396662]

B:BD[9.194] → [9.194:259]

                && (monster_habitat(monster->type) == DNGN_FLOOR

[9.194]

[9.259]

                && (habitat == DNGN_FLOOR

Deletion in crawl-ref/source/monstuff.cc at line 5224 [5.1396662]

∅:D[7.7897] → [5.1530025:1530130]

B:BD[5.1530025] → [5.1530025:1530130]

B:BD[5.1530130] → [2.955:982]

∅:D[2.982] → [5.1530130:1530196]

B:BD[5.1530130] → [5.1530130:1530196]

B:BD[5.1530196] → [2.983:1045]


    // effectively slows down monster movement across water.
    // Fire elementals can't cross at all.
    bool no_water = false;
    if (monster->type == MONS_FIRE_ELEMENTAL || one_chance_in(5))
        //okmove = DNGN_WATER_STUCK;
        no_water = true;

Replacement in crawl-ref/source/monstuff.cc at line 5236 [5.1396662]

B:BD[5.1530502] → [5.1530502:1530550]

B:BD[5.1530550] → [10.443644:443657]

∅:D[10.443657] → [5.1530550:1530664]

B:BD[5.1530550] → [5.1530550:1530664]

B:BD[5.1530664] → [10.443658:443780]

∅:D[10.443780] → [5.1530856:1531105]

B:BD[5.1530856] → [5.1530856:1531105]

B:BD[5.1531105] → [10.443781:443782]

B:BD[10.443782] → [2.1046:1114]

∅:D[2.1114] → [10.443833:444339]

B:BD[10.443833] → [10.443833:444339]

∅:D[10.444339] → [5.1531105:1531252]

B:BD[5.1531105] → [5.1531105:1531252]

B:BD[5.1531252] → [11.11253:11364]

∅:D[11.11364] → [5.1531302:1531851]

B:BD[5.1531302] → [5.1531302:1531851]

B:BD[5.1531851] → [2.1115:1306]

∅:D[2.1306] → [5.1531906:1532542]

B:BD[5.1531906] → [5.1531906:1532542]

B:BD[5.1532542] → [10.444340:444394]

B:BD[10.444394] → [12.6152:6208]

∅:D[12.6208] → [5.1532748:1533127]

∅:D[10.444566] → [5.1532748:1533127]

B:BD[5.1532748] → [5.1532748:1533127]

B:BD[5.1533127] → [12.6209:6264]

∅:D[12.6264] → [5.1533229:1533458]

∅:D[10.444679] → [5.1533229:1533458]

B:BD[5.1533229] → [5.1533229:1533458]

B:BD[5.1533458] → [10.444680:444856]

∅:D[10.444856] → [5.1533458:1533681]

B:BD[5.1533458] → [5.1533458:1533681]

B:BD[5.1533681] → [10.444857:444933]

∅:D[10.444933] → [5.1533823:1534075]

B:BD[5.1533823] → [5.1533823:1534075]

B:BD[5.1534075] → [10.444934:444999]

∅:D[10.444999] → [5.1534141:1534247]

B:BD[5.1534141] → [5.1534141:1534247]

B:BD[5.1534247] → [10.445000:445361]

∅:D[10.445361] → [5.1534327:1534465]

B:BD[5.1534327] → [5.1534327:1534465]

B:BD[5.1534465] → [13.71:256]

B:BD[13.256] → [6.2751:2849]

∅:D[14.157] → [5.1534673:1534687]

∅:D[13.547] → [5.1534673:1534687]

∅:D[6.2849] → [5.1534673:1534687]

B:BD[5.1534673] → [5.1534673:1534687]

B:BD[5.1534687] → [13.548:627]

∅:D[13.627] → [5.1534881:1534896]

B:BD[5.1534881] → [5.1534881:1534896]

B:BD[5.1534896] → [10.445362:445409]

∅:D[10.445409] → [5.1534939:1534953]

B:BD[5.1534939] → [5.1534939:1534953]

B:BD[5.1534953] → [10.445410:445519]

∅:D[10.445519] → [5.1535080:1535147]

B:BD[5.1535080] → [5.1535080:1535147]

B:BD[5.1535147] → [10.445520:445561]

∅:D[10.445561] → [5.1535201:1535252]

B:BD[5.1535201] → [5.1535201:1535252]

B:BD[5.1535289] → [5.1535289:1535543]

B:BD[5.1535581] → [5.1535581:1535924]

B:BD[5.1535961] → [5.1535961:1536216]

B:BD[5.1536255] → [5.1536255:1536472]

B:BD[5.1536472] → [10.445562:445635]

∅:D[10.445635] → [5.1536546:1536585]

B:BD[5.1536546] → [5.1536546:1536585]

B:BD[5.1536628] → [5.1536628:1536738]

            good_move[count_x][count_y] = true;
            
            const int targ_x = monster->x + count_x - 1;
            const int targ_y = monster->y + count_y - 1;
            // [ds] Bounds check was after grd[targ_x][targ_y] which would
            // trigger an ASSERT. Moved it up.
            // bounds check - don't consider moving out of grid!
            if (targ_x < 0 || targ_x >= GXM || targ_y < 0 || targ_y >= GYM)
            {
                good_move[count_x][count_y] = false;
                continue;
            }
            dungeon_feature_type target_grid = grd[targ_x][targ_y];
            const int targ_cloud_num  = env.cgrid[ targ_x ][ targ_y ];
            const int targ_cloud_type = 
                targ_cloud_num == EMPTY_CLOUD? CLOUD_NONE
                                             : env.cloud[targ_cloud_num].type;
            const int curr_cloud_num = env.cgrid[ monster->x ][ monster->y ];
            const int curr_cloud_type =
                curr_cloud_num == EMPTY_CLOUD? CLOUD_NONE
                                             : env.cloud[curr_cloud_num].type;
            if (target_grid == DNGN_DEEP_WATER)
                deep_water_available = true;
            if (monster->type == MONS_BORING_BEETLE
                && (target_grid == DNGN_ROCK_WALL
                    || target_grid == DNGN_CLEAR_ROCK_WALL))
            {
                // don't burrow out of bounds
                if (targ_x <= 7 || targ_x >= (GXM - 8)
                    || targ_y <= 7 || targ_y >= (GYM - 8))
                {
                    good_move[count_x][count_y] = false;
                    continue;
                }
                // don't burrow at an angle (legacy behaviour)
                if (count_x != 1 && count_y != 1)
                {
                    good_move[count_x][count_y] = false;
                    continue;
                }
            } 
            else if (!monster->can_pass_through(target_grid)
                     || (no_water && target_grid >= DNGN_DEEP_WATER
                         && target_grid <= DNGN_WATER_STUCK))
            {
                good_move[count_x][count_y] = false;
                continue;
            }
            else if (!habitat_okay( monster, target_grid ))
            {
                good_move[count_x][count_y] = false;
                continue;
            }
            if (monster->type == MONS_WANDERING_MUSHROOM
                && see_grid(targ_x, targ_y))
            {
                good_move[count_x][count_y] = false;
                continue;
            }
            // Water elementals avoid fire and heat
            if (monster->type == MONS_WATER_ELEMENTAL
                && (target_grid == DNGN_LAVA
                    || targ_cloud_type == CLOUD_FIRE 
                    || targ_cloud_type == CLOUD_STEAM))
            {
                good_move[count_x][count_y] = false;
                continue;
            }
            // Fire elementals avoid water and cold 
            if (monster->type == MONS_FIRE_ELEMENTAL
                && (target_grid == DNGN_DEEP_WATER
                    || target_grid == DNGN_SHALLOW_WATER
                    || target_grid == DNGN_BLUE_FOUNTAIN
                    || targ_cloud_type == CLOUD_COLD))
            {
                good_move[count_x][count_y] = false;
                continue;
            }
            // Submerged water creatures avoid the shallows where
            // they would be forced to surface. -- bwr
            // [dshaligram] Monsters now prefer to head for deep water only if
            // they're low on hitpoints. No point in hiding if they want a
            // fight.
            if (habitat == DNGN_DEEP_WATER
                && (targ_x != you.x_pos || targ_y != you.y_pos)
                && target_grid != DNGN_DEEP_WATER
                && grd[monster->x][monster->y] == DNGN_DEEP_WATER
                && monster->hit_points < (monster->max_hit_points * 3) / 4)
            {
                good_move[count_x][count_y] = false;
                continue;
            }
            // smacking the player is always a good move if
            // we're hostile (even if we're heading somewhere
            // else)
            // smacking another monster is good, if the monsters
            // are aligned differently
            if (mgrd[targ_x][targ_y] != NON_MONSTER)
            {
                const int thismonster = monster_index(monster),
                          targmonster = mgrd[targ_x][targ_y];
                if (mons_aligned(thismonster, targmonster)
                        && targmonster != MHITNOT
                        && targmonster != MHITYOU
                        && !mons_can_displace(monster, &menv[targmonster]))
                {
                    good_move[count_x][count_y] = false;
                    continue;
                }
            }
            // wandering through a trap is OK if we're pretty healthy,
            // really stupid, or immune to the trap
            const int which_trap = trap_at_xy(targ_x,targ_y);
            if (which_trap >= 0 &&
                 !is_trap_safe(monster, env.trap[which_trap]))
            {
                good_move[count_x][count_y] = false;
                continue;
            }
            if (targ_cloud_num != EMPTY_CLOUD)
            {
                if (curr_cloud_num != EMPTY_CLOUD
                    && targ_cloud_type == curr_cloud_type)
                {
                    continue;
                }
                switch (targ_cloud_type)
                {
                case CLOUD_FIRE:
                    if (mons_res_fire(monster) > 0)
                        continue;
                    if (monster->hit_points >= 15 + random2avg(46, 5))
                        continue;
                    break;
                case CLOUD_STINK:
                    if (mons_res_poison(monster) > 0)
                        continue;
                    if (1 + random2(5) < monster->hit_dice)
                        continue;
                    if (monster->hit_points >= random2avg(19, 2))
                        continue;
                    break;
                case CLOUD_COLD:
                    if (mons_res_cold(monster) > 0)
                        continue;
                    if (monster->hit_points >= 15 + random2avg(46, 5))
                        continue;
                    break;
                case CLOUD_POISON:
                    if (mons_res_poison(monster) > 0)
                        continue;
                    if (monster->hit_points >= random2avg(37, 4))
                        continue;
                    break;
                // this isn't harmful, but dumb critters might think so.
                case CLOUD_GREY_SMOKE:
                    if (mons_intel(monster->type) > I_ANIMAL || coinflip())
                        continue;

[5.1530502]

[5.1536738]

             const int targ_x = monster->x + count_x - 1;
             const int targ_y = monster->y + count_y - 1;

Replacement in crawl-ref/source/monstuff.cc at line 5239 [5.1396662]

B:BD[5.1536739] → [5.1536739:1536825]

                    if (mons_res_fire(monster) > 0)
                        continue;

[5.1536739]

[5.1536825]

             // [ds] Bounds check was after grd[targ_x][targ_y] which would
             // trigger an ASSERT. Moved it up.

Replacement in crawl-ref/source/monstuff.cc at line 5242 [5.1396662]

B:BD[5.1536826] → [5.1536826:1536953]

                    if (monster->hit_points >= random2avg(19, 2))
                        continue;
                    break;

[5.1536826]

[5.1536953]

             // bounds check - don't consider moving out of grid!
             if (targ_x < 0 || targ_x >= GXM || targ_y < 0 || targ_y >= GYM)
             {
                 good_move[count_x][count_y] = false;
                 continue;
             }
             dungeon_feature_type target_grid = grd[targ_x][targ_y];

Replacement in crawl-ref/source/monstuff.cc at line 5250 [5.1396662]

B:BD[5.1536954] → [5.1536954:1537048]

                default:
                    continue;   // harmless clouds
                }

[5.1536954]

[5.1537048]

             if (target_grid == DNGN_DEEP_WATER)
                 deep_water_available = true;

Replacement in crawl-ref/source/monstuff.cc at line 5253 [5.1396662]

B:BD[5.1537049] → [5.1537049:1537315]

                // if we get here, the cloud is potentially harmful.
                // exceedingly dumb creatures will still wander in.
                if (mons_intel(monster->type) != I_PLANT)
                    good_move[count_x][count_y] = false;
            }

[5.1537049]

[5.1537315]

             const monsters* mons = dynamic_cast<const monsters*>(monster);
             good_move[count_x][count_y] =
                 mon_can_move_to_pos(mons, count_x-1, count_y-1);