fiddlerwoaroof/crawl - Change LG7XJWUXOV4ZBMOTZX7R5NUC5IONVNCF5O42M4QVYLHNZ62AV25AC

Improve AI handling of clouds, so that clouds will only cause sumbergable

monsters to submerge if it's a cloud tpye the monster wants to avoid, rather than always for all cloud types, and prevent lurking monsters from unsubmerging if it would expose them to a cloud type they want to avoid.

Monsters submerging now consume some energy, except for air elementals and vapours submerging into the air.

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

Created by zelgadis on November 22, 2008

LG7XJWUXOV4ZBMOTZX7R5NUC5IONVNCF5O42M4QVYLHNZ62AV25AC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/monstuff.cc at line 90 [4.1396662]
[4.1398587]
[4.1398587]
```
#define ENERGY_SUBMERGE(entry) (std::max(entry->energy_usage.swim / 2, 1))
```

Insertion in crawl-ref/source/monstuff.cc at line 3897 [4.1396662]

[5.27274]

[6.2922]

}
static bool _mons_avoids_cloud(const monsters *monster, cloud_type cl_type)
{
    switch (cl_type)
    {
    case CLOUD_MIASMA:
        // Even the dumbest monsters will avoid miasma if they can.
        return (mons_res_miasma(monster) <= 0);
    case CLOUD_FIRE:
        if (mons_res_fire(monster) > 1)
            return (false);
        if (monster->hit_points >= 15 + random2avg(46, 5))
            return (false);
        break;
    case CLOUD_STINK:
        if (mons_res_poison(monster) > 0)
            return (false);
        if (x_chance_in_y(monster->hit_dice - 1, 5))
            return (false);
        if (monster->hit_points >= random2avg(19, 2))
            return (false);
        break;
    case CLOUD_COLD:
        if (mons_res_cold(monster) > 1)
            return (false);
        if (monster->hit_points >= 15 + random2avg(46, 5))
            return (false);
        break;
    case CLOUD_POISON:
        if (mons_res_poison(monster) > 0)
            return (false);
        if (monster->hit_points >= random2avg(37, 4))
            return (false);
        break;
    case CLOUD_GREY_SMOKE:
        // This isn't harmful, but dumb critters might think so.
        if (mons_intel(monster) > I_ANIMAL || coinflip())
            return (false);
        if (mons_res_fire(monster) > 0)
            return (false);
        if (monster->hit_points >= random2avg(19, 2))
            return (false);
        break;
    default:
        break;
    }
    // Exceedingly dumb creatures will wander into harmful clouds.
    if (is_harmless_cloud(cl_type) || mons_intel(monster) == I_PLANT)
        return (false);
    // If we get here, the cloud is potentially harmful.
    return (true);

Insertion in crawl-ref/source/monstuff.cc at line 4017 [4.1396662]
[7.1270]
[7.1270]
```
        monsterentry* entry = get_monster_data(monster->type);
```
Insertion in crawl-ref/source/monstuff.cc at line 4020 [4.1396662]
[7.1313]
[7.1313]
```
        monster->speed_increment -= ENERGY_SUBMERGE(entry);
```

Replacement in crawl-ref/source/monstuff.cc at line 5933 [4.1396662]

B:BD[4.1507806] → [8.50539:50593]

        if (env.cgrid(monster->pos()) != EMPTY_CLOUD)

[4.1507806]

[9.430804]

        const int        cloud_num = env.cgrid(monster->pos());
        const cloud_type cl_type   =
            cloud_num == EMPTY_CLOUD ? CLOUD_NONE : env.cloud[cloud_num].type;
        if (cloud_num != EMPTY_CLOUD)

Replacement in crawl-ref/source/monstuff.cc at line 5938 [4.1396662]

B:BD[9.430814] → [2.4064:4108]

            if (mons_is_submerged(monster))

[9.430814]

[10.4569]

            if (_mons_avoids_cloud(monster, cl_type))

Replacement in crawl-ref/source/monstuff.cc at line 5940 [4.1396662]

B:BD[10.4583] → [10.4583:4653]

∅:D[10.4653] → [9.430872:430895]

∅:D[11.10384] → [9.430872:430895]

B:BD[9.430872] → [9.430872:430895]

B:BD[9.430895] → [10.4654:4668]

                monster->speed_increment -= entry->energy_usage.swim;
                break;
            }

[10.4583]

[4.1508012]

                if (mons_is_submerged(monster))
                {
                    monster->speed_increment -= entry->energy_usage.swim;
                    break;
                }

Replacement in crawl-ref/source/monstuff.cc at line 5946 [4.1396662]

B:BD[4.1508013] → [12.2879:2916]

∅:D[13.2756] → [10.4669:4753]

∅:D[12.2916] → [10.4669:4753]

B:BD[9.430933] → [10.4669:4753]

∅:D[10.4753] → [9.430933:430982]

B:BD[9.430933] → [9.430933:430982]

            if (monster->type == -1)
            {
                monster->speed_increment -= entry->energy_usage.move;
                break;  // problem with vortices

[4.1508013]

[10.4754]

                if (monster->type == -1)
                {
                    monster->speed_increment -= entry->energy_usage.move;
                    break;  // problem with vortices
                }

Replacement in crawl-ref/source/monstuff.cc at line 5980 [4.1396662]

B:BD[14.7551] → [8.50594:50714]

        if (monster_can_submerge(monster, grd(monster->pos()))
            && env.cgrid(monster->pos()) != EMPTY_CLOUD)

[14.7551]

[9.431434]

        if (cloud_num != EMPTY_CLOUD && _mons_avoids_cloud(monster, cl_type)
            && monster_can_submerge(monster, grd(monster->pos()))
            && !monster->submerged())

Insertion in crawl-ref/source/monstuff.cc at line 5985 [4.1396662]

[11.10432]

[9.431498]

            monster->speed_increment -= ENERGY_SUBMERGE(entry);
            continue;

Replacement in crawl-ref/source/monstuff.cc at line 6029 [4.1396662]

B:BD[15.3415] → [15.3415:3464]

                    // if the monster is afraid.

[15.3415]

[15.3464]

                    // if the monster is afraid, or if it's avoiding the
                    // cloud on top of the water.

Replacement in crawl-ref/source/monstuff.cc at line 6032 [4.1396662]

∅:D[15.3539] → [16.4116:4173]

B:BD[16.4116] → [16.4116:4173]

                        || monster->has_ench(ENCH_FEAR))

[15.3539]

[16.4173]

                        || monster->has_ench(ENCH_FEAR)
                        || _mons_avoids_cloud(monster, cl_type))

Replacement in crawl-ref/source/monstuff.cc at line 6961 [4.1396662]

B:BD[17.3518] → [5.31711:31760]

∅:D[5.31760] → [17.3581:3613]

B:BD[17.3581] → [17.3581:3613]

    const int targ_cloud_num  = env.cgrid(targ);
    const int targ_cloud_type =

[17.3518]

[3.3243]

    const int        targ_cloud_num  = env.cgrid(targ);
    const cloud_type targ_cloud_type =

Replacement in crawl-ref/source/monstuff.cc at line 6966 [4.1396662]

B:BD[17.3735] → [5.31761:31819]

∅:D[5.31819] → [17.3805:3837]

B:BD[17.3805] → [17.3805:3837]

    const int curr_cloud_num = env.cgrid(monster->pos());
    const int curr_cloud_type =

[17.3735]

[3.3371]

    const int        curr_cloud_num  = env.cgrid(monster->pos());
    const cloud_type curr_cloud_type =

Deletion in crawl-ref/source/monstuff.cc at line 7088 [4.1396662]

B:BD[17.7311] → [17.7311:7355]

B:BD[17.7355] → [18.204:354]

B:BD[18.354] → [19.9816:9817]

∅:D[19.9817] → [18.367:392]

B:BD[18.367] → [18.367:392]

B:BD[18.392] → [20.8402:8446]

B:BD[20.8446] → [21.6769:6800]


        switch (targ_cloud_type)
        {
        case CLOUD_MIASMA:
            // Even the dumbest monsters will avoid miasma if they can.
            return (mons_res_miasma(monster) > 0);
        case CLOUD_FIRE:
            if (mons_res_fire(monster) > 1)
                return (true);

Replacement in crawl-ref/source/monstuff.cc at line 7089 [4.1396662]
B:BD[17.7466] → [18.466:529]
B:BD[18.529] → [21.6801:6832]
∅:D[21.6832] → [18.558:577]
B:BD[18.558] → [18.558:577]
∅:D[18.577] → [17.7589:7590]
B:BD[17.7589] → [17.7589:7590]
B:BD[17.7590] → [18.578:650]
B:BD[18.650] → [21.6833:6864]
B:BD[21.6864] → [22.6760:6817]
∅:D[22.6817] → [21.6865:6896]
B:BD[18.731] → [21.6865:6896]
∅:D[21.6896] → [18.760:818]
B:BD[18.760] → [18.760:818]
B:BD[18.818] → [21.6897:6928]
∅:D[21.6928] → [18.847:866]
B:BD[18.847] → [18.847:866]
∅:D[18.866] → [17.7910:7911]
B:BD[17.7910] → [17.7910:7911]
B:BD[17.7911] → [18.867:892]
B:BD[18.892] → [20.8447:8491]
B:BD[20.8491] → [21.6929:6960]
∅:D[18.965] → [17.8021:8022]
∅:D[21.6960] → [17.8021:8022]
B:BD[17.8021] → [17.8021:8022]
B:BD[17.8022] → [18.966:1029]
B:BD[18.1029] → [21.6961:6992]
∅:D[21.6992] → [18.1058:1077]
B:BD[18.1058] → [18.1058:1077]
∅:D[18.1077] → [17.8145:8146]
B:BD[17.8145] → [17.8145:8146]
B:BD[17.8146] → [18.1078:1151]
B:BD[18.1151] → [21.6993:7024]
∅:D[18.1180] → [17.8260:8261]
∅:D[21.7024] → [17.8260:8261]
B:BD[17.8260] → [17.8260:8261]
B:BD[17.8261] → [18.1181:1239]
B:BD[18.1239] → [21.7025:7056]
∅:D[21.7056] → [18.1268:1287]
B:BD[18.1268] → [18.1268:1287]
∅:D[18.1287] → [17.8379:8380]
B:BD[17.8379] → [17.8379:8380]
B:BD[17.8449] → [18.1288:1319]
B:BD[18.1319] → [23.6488:6557]
B:BD[23.6557] → [24.3707:3769]
∅:D[24.3769] → [21.7057:7088]
B:BD[18.1387] → [21.7057:7088]
∅:D[18.1416] → [17.8589:8590]
∅:D[21.7088] → [17.8589:8590]
B:BD[17.8589] → [17.8589:8590]
B:BD[17.8590] → [18.1417:1461]
B:BD[18.1461] → [21.7089:7120]
∅:D[18.1490] → [17.8671:8672]
∅:D[21.7120] → [17.8671:8672]
B:BD[17.8671] → [17.8671:8672]
B:BD[17.8672] → [18.1491:1549]
B:BD[18.1549] → [21.7121:7152]
∅:D[21.7152] → [18.1578:1597]
B:BD[18.1578] → [18.1578:1597]
B:BD[18.1597] → [19.9818:9819]
∅:D[19.9819] → [18.1598:1615]
B:BD[17.8807] → [18.1598:1615]
B:BD[18.1615] → [21.7153:7201]
∅:D[18.1661] → [17.8878:8889]
∅:D[21.7201] → [17.8878:8889]
B:BD[17.8878] → [17.8878:8889]
B:BD[17.8889] → [23.6558:6679]
B:BD[23.6679] → [24.3770:3814]
∅:D[24.3814] → [21.7202:7230]
B:BD[17.9060] → [21.7202:7230]
```
            if (monster->hit_points >= 15 + random2avg(46, 5))
                return (true);
            break;
        case CLOUD_STINK:
            if (mons_res_poison(monster) > 0)
                return (true);
            if (x_chance_in_y(monster->hit_dice - 1, 5))
                return (true);
            if (monster->hit_points >= random2avg(19, 2))
                return (true);
            break;
        case CLOUD_COLD:
            if (mons_res_cold(monster) > 1)
                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;
        case CLOUD_GREY_SMOKE:
            // This isn't harmful, but dumb critters might think so.
            if (mons_intel(monster) > 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) != I_PLANT)
            return (false);
```
[17.7466]
[17.9086]
```
        return !_mons_avoids_cloud(monster, targ_cloud_type);
```