fiddlerwoaroof/crawl - Change AVCMVFA3MKCXHO6H44UK5KJNIHTGQV7UA7GYXM26VI6TXXU5ZN6QC

Shaft traps (trap doors) [1792195] and level annotation [1769009]

added, with the shaft traps changed as per comments on SF; shafts aren't randomly generated yet, so this doesn't change gameplay. Changed DNGN_TRAP_III to DNGN_TRAP_NATURAL, of which trap type the shaft traps are the only current member.

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

Created by zelgadis on October 5, 2007

AVCMVFA3MKCXHO6H44UK5KJNIHTGQV7UA7GYXM26VI6TXXU5ZN6QC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/view.cc at line 2527 [10.16817]
B:BD[9.17457] → [9.17457:17485]
```
        case DNGN_TRAP_III:
```
[9.17457]
[9.17485]
```
        case DNGN_TRAP_NATURAL:
```

Replacement in crawl-ref/source/view.cc at line 3633 [10.16817]

B:BD[10.93767] → [11.50216:50287]

        case DNGN_TRAP_III:
            Feature[i].colour = LIGHTGREY;

[10.93767]

[11.50287]

        case DNGN_TRAP_NATURAL:
            Feature[i].colour = BROWN;

Replacement in crawl-ref/source/view.cc at line 3636 [10.16817]
B:BD[11.50353] → [11.50353:50400]
```
            Feature[i].map_colour = LIGHTGREY;
```
[11.50353]
[11.50400]
```
            Feature[i].map_colour = BROWN;
```

Insertion in crawl-ref/source/traps.cc at line 386 [12.5308]

[12.15375]


    // If we don't trigger the shaft, and the player doesn't
    // already know about it, don't let him/her notice it.
    case TRAP_SHAFT:
    {
        // Paranoia
        if (!is_valid_shaft_level())
        {
            if (trap_known);
                mpr("The shaft disappears in a puff of logic!");
            grd[env.trap[i].x][env.trap[i].y] = DNGN_FLOOR;
            env.trap[i].type = TRAP_UNASSIGNED;
            return;
        }
        if (!you.will_trigger_shaft())
        {
            if (trap_known && !you.airborne())
                mpr("You fail to trigger the shaft.");
            if (!trap_known)
                grd[you.x_pos][you.y_pos] = DNGN_UNDISCOVERED_TRAP;
            return;
        }
        if (!you.do_shaft())
            if (!trap_known)
            {
                grd[you.x_pos][you.y_pos] = DNGN_UNDISCOVERED_TRAP;
                return;
            }
        break;
    }

Insertion in crawl-ref/source/traps.cc at line 809 [12.5308]
[12.23317]
[12.23317]
```
    case TRAP_SHAFT:
        return (DNGN_TRAP_NATURAL);
```
Replacement in crawl-ref/source/terrain.cc at line 180 [12.26938]
B:BD[12.31434] → [12.31434:31475]
```
              || grid == DNGN_TRAP_III);
```
[12.31434]
[12.31475]
```
              || grid == DNGN_TRAP_NATURAL);
```
Insertion in crawl-ref/source/tags.cc at line 99 [10.164589]
[13.1821]
[10.167976]
```
extern std::map<level_id, std::string> level_annotations;
```

Insertion in crawl-ref/source/tags.cc at line 427 [10.164589]

[10.171969]

// To pass to marsahllMap
static void marshall_string(struct tagHeader &th, const std::string &data)
{
    marshallString(th, data);
}

Insertion in crawl-ref/source/tags.cc at line 466 [10.164589]

[14.530]

[10.172380]

// To pass to unmarshallMap
static std::string unmarshall_string(struct tagHeader &th)
{
    return unmarshallString(th);
}

Insertion in crawl-ref/source/tags.cc at line 1055 [10.164589]

[13.4187]

[15.1266]

    marshallMap(th, level_annotations,
                marshall_level_id, marshall_string);

Insertion in crawl-ref/source/tags.cc at line 1453 [10.164589]

[13.6165]

[15.2957]

    unmarshallMap(th, level_annotations,
                  unmarshall_level_id, unmarshall_string);

Insertion in crawl-ref/source/state.h at line 70 [12.42804]
[7.1136]
[7.1136]
```
    bool level_annotation_shown;
```

Replacement in crawl-ref/source/state.cc at line 36 [7.1546]

B:BD[7.2574] → [7.2574:2633]

      cmd_repeat_started_unsafe(false), input_line_curr(0)

[7.2574]

[7.2633]

      cmd_repeat_started_unsafe(false), input_line_curr(0),
      level_annotation_shown(false)

Deletion in crawl-ref/source/spells4.cc at line 2670 [10.436250]
B:BD[10.511012] → [10.511012:511083]
```
    case DNGN_TRAP_III: // What are these? Should they explode? -- bwr
```

Replacement in crawl-ref/source/spells3.cc at line 676 [10.531613]

B:BD[6.364] → [6.364:428]

        DNGN_TRAP_MECHANICAL, DNGN_TRAP_MAGICAL, DNGN_TRAP_III,

[6.364]

[6.428]

        DNGN_TRAP_MECHANICAL, DNGN_TRAP_MAGICAL, DNGN_TRAP_NATURAL,

Insertion in crawl-ref/source/player.cc at line 57 [10.962854]
[10.963796]
[10.963796]
```
#include "place.h"
```

Insertion in crawl-ref/source/player.cc at line 5017 [10.962854]

[16.1875]

{
}
bool actor::will_trigger_shaft() const
{
    return (!airborne() && total_weight() >= 300
            && is_valid_shaft_level());
}
level_id actor::shaft_dest() const
{
    if (you.level_type != LEVEL_DUNGEON)
        return level_id::current();
    level_id lev        = level_id::current();
    int      curr_depth = subdungeon_depth(you.where_are_you, you.your_level);
    lev.depth += ((pos().x + pos().y) % 3) + 1;
    if (lev.depth > your_branch().depth)
        lev.depth = your_branch().depth;
    if (lev.depth == curr_depth)
        return lev;
    // Only shafts on the level immediately above a dangeorus branch
    // bottom will take you to that dangerous bottom, and shafts can't
    // be created during level generation time.
    if (your_branch().dangerous_bottom_level
        && lev.depth == your_branch().depth
        && (your_branch().depth - curr_depth) > 1)
    {
        lev.depth--;
    }
    return lev;
}
bool actor::airborne() const

Insertion in crawl-ref/source/player.cc at line 5057 [10.962854]
[16.1877]
[9.200948]
```
    return (is_levitating() || (flies() == FL_FLY && !paralysed()));
```

Replacement in crawl-ref/source/player.cc at line 5297 [10.962854]

B:BD[17.2664] → [18.7696:7757]

B:BD[18.7757] → [19.7214:7272]

∅:D[19.7272] → [18.7757:7796]

B:BD[18.7757] → [18.7757:7796]

    return (attribute[ATTR_TRANSFORMATION] == TRAN_DRAGON ||
            attribute[ATTR_TRANSFORMATION] == TRAN_BAT ||
            duration[DUR_LEVITATION]);

[17.2664]

[9.204709]

    return (duration[DUR_LEVITATION]);

Replacement in crawl-ref/source/player.cc at line 5302 [10.962854]

B:BD[17.2772] → [4.201:260]

    return (!player_is_levitating() && !beogh_water_walk()

[17.2772]

[4.260]

    return (!airborne() && !beogh_water_walk()

Insertion in crawl-ref/source/player.cc at line 5381 [10.962854]

[17.4310]

[20.172]

}
int player::body_weight() const
{
    if (attribute[ATTR_TRANSFORMATION] == TRAN_AIR)
        return 0;
    int weight;
    switch(body_size(PSIZE_BODY))
    {
    case SIZE_TINY:
        weight = 150;
        break;
    case SIZE_LITTLE:
        weight = 300;
        break;
    case SIZE_SMALL:
        weight = 425;
        break;
    case SIZE_MEDIUM:
        weight = 550;
        break;
    case SIZE_LARGE:
        weight = 1300;
        break;
    case SIZE_BIG:
        weight = 1500;
        break;
    case SIZE_GIANT:
        weight = 1800;
        break;
    case SIZE_HUGE:
        weight = 2200;
        break;
    default:
        mpr("ERROR: invalid player body weight");
        perror("player::body_weight(): invalid player body weight");
        end(0);
    }
    switch(attribute[ATTR_TRANSFORMATION])
    {
    case TRAN_STATUE:
        weight *= 2;
        break;
    case TRAN_LICH:
        weight /= 2;
        break;
    default:
        break;
    }
    return (weight);
}
int player::total_weight() const
{
    return (body_weight() + burden);

Insertion in crawl-ref/source/player.cc at line 5821 [10.962854]

[16.4947]

}
bool player::confusable() const
{
    return (player_mental_clarity() == 0);

Insertion in crawl-ref/source/player.cc at line 5828 [10.962854]

[16.4950]

[21.1279]

bool player::slowable() const
{
    return (!wearing_amulet(AMU_RESIST_SLOW));
}

Replacement in crawl-ref/source/player.cc at line 5835 [10.962854]

B:BD[16.4983] → [22.905:933]

B:BD[22.933] → [21.1314:1340]

∅:D[21.1340] → [23.139:148]

B:BD[23.139] → [23.139:148]

    if ( !is_levitating() )
        return (FL_NONE);
    else

[16.4983]

[2.798]

    if (attribute[ATTR_TRANSFORMATION] == TRAN_DRAGON ||
        attribute[ATTR_TRANSFORMATION] == TRAN_BAT)
    {
        return FL_FLY;
    }
    else if (is_levitating())

Insertion in crawl-ref/source/player.cc at line 5844 [10.962854]
[2.948]
[21.1418]
```
    else
        return (FL_NONE);
```

Insertion in crawl-ref/source/player.cc at line 6287 [10.962854]

[15.10906]

[7.9317]


bool player::do_shaft()
{
    dungeon_feature_type force_stair = DNGN_UNSEEN;

Insertion in crawl-ref/source/player.cc at line 6292 [10.962854]

[7.9318]

    if (!is_valid_shaft_level())
        return (false);
    // Handle instances of do_shaft() being invoked magically when
    // the player isn't standing over a shaft.
    if (trap_type_at_xy(x_pos, y_pos) != TRAP_SHAFT)
    {
        switch(grd[x_pos][y_pos])
        {
        case DNGN_FLOOR:
        case DNGN_OPEN_DOOR:
        case DNGN_TRAP_MECHANICAL:
        case DNGN_TRAP_MAGICAL:
        case DNGN_TRAP_NATURAL:
        case DNGN_UNDISCOVERED_TRAP:
        case DNGN_ENTER_SHOP:
            break;
        default:
            return (false);
        }
        if (airborne() || total_weight() == 0)
        {
            mpr("A shaft briefly opens up underneath you!");
            return (true);
        }
        force_stair = DNGN_TRAP_NATURAL;
    }
    down_stairs(your_level, force_stair);
    return (true);
}

Insertion in crawl-ref/source/overmap.h at line 23 [10.1068481]

[24.97]

[10.1069220]


///////////////////////////////////////////////////////////
void set_level_annotation(std::string str,
                          level_id li = level_id::current());
void clear_level_annotation(level_id li = level_id::current());
std::string get_level_annotation(level_id li = level_id::current());
bool level_annotation_has(std::string str,
                          level_id li = level_id::current());

Insertion in crawl-ref/source/overmap.h at line 34 [10.1068481]
[10.1069221]
[10.1069974]
```
void annotate_level();
```
Insertion in crawl-ref/source/overmap.cc at line 29 [10.1070017]
[25.2902]
[26.2126]
```
#include "cio.h"
```
Insertion in crawl-ref/source/overmap.cc at line 47 [10.1070017]
[27.1676]
[27.1676]
```
typedef std::map<level_id, std::string> annotation_map_type;
```
Insertion in crawl-ref/source/overmap.cc at line 53 [10.1070017]
[27.1798]
[10.1071122]
```
annotation_map_type level_annotations;
```

Insertion in crawl-ref/source/overmap.cc at line 372 [10.1070017]

[28.1170]

    }
    bool notes_exist = false;
    bool has_notes[NUM_BRANCHES];
    for (int i = 0; i < NUM_BRANCHES; ++i)
    {
        Branch branch = branches[i];
        has_notes[i] = false;
        for (int depth = 1; depth <= branch.depth; depth++)
        {
            const level_id li(branch.id, depth);
            if (get_level_annotation(li).length() > 0)
            {
                notes_exist  = true;
                has_notes[i] = true;
                break;
            }
        }

Insertion in crawl-ref/source/overmap.cc at line 395 [10.1070017]

[24.164]

    if (notes_exist)
    {
        disp += "\n\n                    <white>Level Annotations</white>\n" ;
        for (int i = 0; i < NUM_BRANCHES; ++i)
        {
            if (!has_notes[i])
                continue;
            Branch branch = branches[i];
            disp += "\n<yellow>";
            disp += branch.shortname;
            disp += "</yellow>\n";
            for (int depth = 1; depth <= branch.depth; depth++)
            {
                const level_id li(branch.id, depth);
                if (get_level_annotation(li).length() > 0)
                {
                    char depth_str[3];
                    sprintf(depth_str, "%2d", depth);
                    disp += "<white>";
                    disp += depth_str;
                    disp += ":</white> ";
                    disp += get_level_annotation(li);
                    disp += + "\n";
                }
            }
        }
    }

Insertion in crawl-ref/source/overmap.cc at line 571 [10.1070017]

[13.15692]


////////////////////////////////////////////////////////////////////////
void set_level_annotation(std::string str,
                          level_id li)
{
    if (str == "")
    {
        clear_level_annotation(li);
        return;
    }
    level_annotations[li] = str;
}
void clear_level_annotation(level_id li)
{
    level_annotations.erase(li);
}
std::string get_level_annotation(level_id li)
{
    annotation_map_type::const_iterator i = level_annotations.find(li);
    if (i == level_annotations.end())
        return "";
    return (i->second);
}
bool level_annotation_has(std::string find,
                          level_id li)
{
    std::string str = get_level_annotation(li);
    return (str.find(find) != std::string::npos);
}
void annotate_level()
{
    level_id li  = level_id::current();
    level_id li2 = level_id::current();
    if (is_stair(grd[you.x_pos][you.y_pos]))
    {
        li2 = level_id::get_next_level_id(you.pos());
        if (li2.level_type != LEVEL_DUNGEON || li2.depth <= 0)
            li2 = level_id::current();
    }
    if (you.level_type != LEVEL_DUNGEON && li2.level_type != LEVEL_DUNGEON)
    {
        mpr("You can't annotate this level.");
        return;
    }
    if (you.level_type != LEVEL_DUNGEON)
        li = li2;
    else if (li2 != level_id::current())
    {
        if (yesno("Annotate level on other end of current stairs?"))
            li = li2;
    }
    if (get_level_annotation(li).length() > 0)
    {
        mpr("Current level annotation is:", MSGCH_PROMPT);
        mpr(get_level_annotation(li).c_str() );
    }
    mpr( "Set level annotation to what? ", MSGCH_PROMPT );
    char buf[77];
    get_input_line( buf, sizeof(buf) );
    if (strlen(buf) == 0)
    {
        if (get_level_annotation(li).length() > 0)
        {
            if (!yesno("Really clear the annotation?"))
                return;
        }
        else
        {
            canned_msg(MSG_OK);
            return;
        }
    }
    set_level_annotation(buf, li);
}

Insertion in crawl-ref/source/mstuff2.cc at line 300 [10.1340842]

[10.1349108]

        break;
    case TRAP_SHAFT:
    {
        // Paranoia
        if (!is_valid_shaft_level())
        {
            if (trapKnown && monsterNearby)
                mpr("The shaft disappears in a puff of logic!");
            grd[env.trap[which_trap].x][env.trap[which_trap].y] = DNGN_FLOOR;
            env.trap[which_trap].type = TRAP_UNASSIGNED;
            return;
        }
        if (!monster->will_trigger_shaft())
        {
            if (trapKnown && !monster->airborne())
                simple_monster_message(monster,
                                        " fails to trigger the shaft.");
            return;
        }
        revealTrap = monster->do_shaft();

Insertion in crawl-ref/source/mstuff2.cc at line 326 [10.1340842]
[10.1349123]
[29.4995]
```
    }
```

Replacement in crawl-ref/source/monstuff.cc at line 4517 [10.1396662]

B:BD[30.4246] → [21.1919:2031]

    const flight_type lev = mons->flies();
    if (lev == FL_LEVITATE || (lev == FL_FLY && !mons->paralysed()))

[30.4246]

[30.4334]

    if (mons->airborne())

Insertion in crawl-ref/source/monstuff.cc at line 4573 [10.1396662]

[31.1988]

    if (trap.type == TRAP_SHAFT && monster->will_trigger_shaft())
        return (false);

Insertion in crawl-ref/source/monplace.cc at line 326 [10.1641732]

[32.7444]

[11.454461]

}
static bool can_place_on_trap(int mon_type, trap_type trap)
{
    if (trap == TRAP_TELEPORT)
        return (false);
    if (trap == TRAP_SHAFT)
    {
        if (mon_type == RANDOM_MONSTER)
            return (false);
        return (mons_class_flag(mon_type, M_FLIES)
                || mons_class_flag(mon_type, M_LEVITATE)
                || get_monster_data(mon_type)->size == SIZE_TINY);
    }
    return (true);

Replacement in crawl-ref/source/monplace.cc at line 393 [10.1641732]

B:BD[3.2450] → [3.2450:2512]

                    if (env.trap[trap].type == TRAP_TELEPORT)

[3.2450]

[3.2512]

                    if (!can_place_on_trap(mon_type, env.trap[trap].type))

Replacement in crawl-ref/source/monplace.cc at line 530 [10.1641732]

B:BD[10.1648084] → [10.1648084:1648142]

                if (env.trap[trap].type == TRAP_TELEPORT)

[10.1648084]

[10.1648142]

                if (!can_place_on_trap(mon_type, env.trap[trap].type))

Replacement in crawl-ref/source/monplace.cc at line 707 [10.1641732]

B:BD[10.1653956] → [10.1653956:1654014]

                if (env.trap[trap].type == TRAP_TELEPORT)

[10.1653956]

[10.1654014]

                if (!can_place_on_trap(mon_type, env.trap[trap].type))

Insertion in crawl-ref/source/mon-util.h at line 581 [10.1682293]

[11.465035]

bool mons_class_is_confusable(int monsclass);
bool mons_class_is_slowable(int monsclass);

Insertion in crawl-ref/source/mon-util.cc at line 370 [10.1699344]

[11.470173]

[33.2341]

}
bool mons_class_is_confusable(int mc)
{
    return (smc->resist_magic < MAG_IMMUNE
            && mons_intel(mc) > I_PLANT);
}
bool mons_class_is_slowable(int mc)
{
    return (smc->resist_magic < MAG_IMMUNE);

Insertion in crawl-ref/source/mon-util.cc at line 2400 [10.1699344]

[17.8652]


int monsters::body_weight() const
{
    int mclass = type;
    switch(mclass)
    {
    case MONS_SPECTRAL_THING:
    case MONS_SPECTRAL_WARRIOR:
    case MONS_ELECTRIC_GOLEM:
    case MONS_RAKSHASA_FAKE:
        return 0;
    case MONS_ZOMBIE_SMALL:
    case MONS_ZOMBIE_LARGE:
    case MONS_SKELETON_SMALL:
    case MONS_SKELETON_LARGE:
    case MONS_SIMULACRUM_SMALL:
    case MONS_SIMULACRUM_LARGE:
        mclass = number;
        break;
    default:
        break;
    }
    int weight = mons_weight(mclass);
    // Water elementals are "insubstantial", but still have weight.
    if (weight == 0 && type == MONS_WATER_ELEMENTAL)
        weight = 1500;
    // weight == 0 in the monster entry indicates "no corpse".  Can't
    // use CE_NOCORPSE, because the corpse-effect field is used for
    // corpseless monsters to indicate what happens if their blood
    // is sucked.  Grrrr.
    if (weight == 0 && !mons_is_insubstantial(type))
    {
        const monsterentry *entry = get_monster_data(mclass);
        switch(entry->size)
        {
        case SIZE_TINY:
            weight = 150;
            break;
        case SIZE_LITTLE:
            weight = 300;
            break;
        case SIZE_SMALL:
            weight = 425;
            break;
        case SIZE_MEDIUM:
            weight = 550;
            break;
        case SIZE_LARGE:
            weight = 1300;
            break;
        case SIZE_BIG:
            weight = 1500;
            break;
        case SIZE_GIANT:
            weight = 1800;
            break;
        case SIZE_HUGE:
            weight = 2200;
            break;
        default:
            mpr("ERROR: invalid monster body weight");
            perror("monsters::body_weight(): invalid monster body weight");
            end(0);
        }

Insertion in crawl-ref/source/mon-util.cc at line 2470 [10.1699344]

[17.8653]

        switch(mclass)
        {
        case MONS_IRON_DEVIL:
            weight += 550;
            break;
        case MONS_STONE_GOLEM:
        case MONS_EARTH_ELEMENTAL:
        case MONS_CRYSTAL_GOLEM:
            weight *= 2;
            break;
        case MONS_IRON_DRAGON:
        case MONS_IRON_GOLEM:
            weight *= 3;
            break;
        case MONS_QUICKSILVER_DRAGON:
        case MONS_SILVER_STATUE:
            weight *= 4;
            break;
        case MONS_WOOD_GOLEM:
            weight *= 2;
            weight /= 3;
            break;
        case MONS_FLYING_SKULL:
        case MONS_CURSE_SKULL:
        case MONS_SKELETAL_DRAGON:
        case MONS_SKELETAL_WARRIOR:
            weight /= 2;
            break;
        case MONS_SHADOW_FIEND:
        case MONS_SHADOW_IMP:
        case MONS_SHADOW_DEMON:
            weight /= 3;
            break;
        }
        switch(monster_symbols[mclass].glyph)
        {
        case 'L':
            weight /= 2;
            break;
        case 'p':
            weight = 0;
            break;
        }
    }
    if (type == MONS_SKELETON_SMALL || type == MONS_SKELETON_LARGE)
        weight /= 2;
    return (weight);
}
int monsters::total_weight() const
{
    int burden = 0;
    for (int i = 0; i < NUM_MONSTER_SLOTS; i++)
        if (inv[i] != NON_ITEM)
            burden += item_mass(mitm[inv[i]]) * mitm[inv[i]].quantity;
    return (body_weight() + burden);
}

Insertion in crawl-ref/source/mon-util.cc at line 3460 [10.1699344]

[16.14699]

bool monsters::is_levitating() const
{
    return (mons_class_flag(type, M_LEVITATE));
}

Insertion in crawl-ref/source/mon-util.cc at line 4816 [10.1699344]

[26.4466]


bool monsters::do_shaft()
{
    if (!is_valid_shaft_level())
        return (false);
    bool nearby  = mons_near(this);
    bool vis     = player_monster_visible(this);
    // Handle instances of do_shaft() being invoked magically when
    // the monster isn't standing over a shaft.
    if (trap_type_at_xy(x, y) != TRAP_SHAFT)
    {
        switch(grd[x][y])
        {
        case DNGN_FLOOR:
        case DNGN_OPEN_DOOR:
        case DNGN_TRAP_MECHANICAL:
        case DNGN_TRAP_MAGICAL:
        case DNGN_TRAP_NATURAL:
        case DNGN_UNDISCOVERED_TRAP:
        case DNGN_ENTER_SHOP:
            break;
        default:
            return (false);
        }
        if (airborne() || total_weight() == 0)
        {
            if (nearby)
            {
                if (vis)
                    mprf("A shaft briefly opens up underneath %s!",
                         name(DESC_NOCAP_THE).c_str());
                else
                    mpr("A shaft briefly opens up in the floor!");
            }
            return (true);
        }
    }
    level_id lev = shaft_dest();
    if (lev == level_id::current())
        return (false);
    set_transit(lev);
    if (nearby)
    {
        if (vis)
            mprf("%s falls through a shaft!",
                 name(DESC_CAP_THE).c_str());
        else
            mpr("A shaft briefly opens up in the floor!");
    }
    // Monster is no longer on this level
    destroy_inventory();
    monster_cleanup(this);
    return true;
}

Insertion in crawl-ref/source/misc.h at line 126 [10.1928926]

[7.10010]

[10.1933556]

//////////////////////////////////////////////////////////////////////
bool is_valid_shaft_level();

Insertion in crawl-ref/source/misc.cc at line 63 [10.1933596]
[10.1934443]
[12.72278]
```
#include "overmap.h"
```

Insertion in crawl-ref/source/misc.cc at line 543 [10.1933596]

[10.1944243]

    }
    level_id  old_level_id    = level_id::current();
    LevelInfo &old_level_info = travel_cache.get_level_info(old_level_id);
    // Does the next level have a warning annotation?
    coord_def pos(you.x_pos, you.y_pos);
    level_id  next_level_id = level_id::get_next_level_id(pos);
    crawl_state.level_annotation_shown = false;
    if (level_annotation_has("WARN", next_level_id)
        && next_level_id != level_id::current()
        && next_level_id.level_type == LEVEL_DUNGEON && !force_stair)
    {
        mpr("Warning: level annotation for next level is:", MSGCH_PROMPT);
        mpr(get_level_annotation(next_level_id).c_str(), MSGCH_PROMPT);
        if (!yesno("Enter next level anyways?", true, 0, true, false))
        {
            interrupt_activity( AI_FORCE_INTERRUPT );
            return;
        }
        crawl_state.level_annotation_shown = true;

Deletion in crawl-ref/source/misc.cc at line 610 [10.1933596]

B:BD[9.248887] → [34.6268:6321]

∅:D[34.6321] → [9.248953:249078]

B:BD[9.248953] → [9.248953:249078]

    level_id  old_level_id    = level_id::current();
    LevelInfo &old_level_info = travel_cache.get_level_info(old_level_id);
    int stair_x = you.x_pos, stair_y = you.y_pos;

Insertion in crawl-ref/source/misc.cc at line 738 [10.1933596]
[9.249761]
[9.249761]
```
            int stair_x = you.x_pos, stair_y = you.y_pos;
```

Replacement in crawl-ref/source/misc.cc at line 765 [10.1933596]

B:BD[9.250885] → [9.250885:250955]

            old_level_info.update_stair(stair_x, stair_y, lp, guess);

[9.250885]

[9.250955]

            old_level_info.update_stair(you.x_pos, you.y_pos, lp, guess);

Insertion in crawl-ref/source/misc.cc at line 794 [10.1933596]

[35.2130]

[10.1948512]


    bool shaft = ((!force_stair
                   && trap_type_at_xy(you.x_pos, you.y_pos) == TRAP_SHAFT)
                  || force_stair == DNGN_TRAP_NATURAL);
    level_id shaft_dest;
    int      shaft_level = -1;

Replacement in crawl-ref/source/misc.cc at line 811 [10.1933596]

B:BD[10.1948798] → [36.9123:9186]

    if (grid_stair_direction(stair_find) != CMD_GO_DOWNSTAIRS)

[10.1948798]

[10.1949189]

    if (grid_stair_direction(stair_find) != CMD_GO_DOWNSTAIRS && !shaft)

Insertion in crawl-ref/source/misc.cc at line 838 [10.1933596]

[10.1949845]

    }
    if (shaft)
    {
        bool known_trap = (grd[you.x_pos][you.y_pos] != DNGN_UNDISCOVERED_TRAP
                           && !force_stair);
        if (you.airborne() && !known_trap && !force_stair)
        {
            mpr("You can't go down here!");
            return;
        }
        if (you.airborne() && you.flies() != FL_FLY && !force_stair)
        {
            if (known_trap)
                mpr("You must have controlled flight to dive through "
                    "a shaft.");
            return;
        }
        if (!is_valid_shaft_level())
        {
            if (known_trap)
                mpr("Strange, the shaft doesn't seem to lead anywhere.");
            return;
        }
        shaft_dest = you.shaft_dest();
        if (shaft_dest == level_id::current())
        {
            if (known_trap)
                mpr("Strange, the shaft doesn't seem to lead anywhere.");
            return;
        }
        shaft_level = absdungeon_depth(shaft_dest.branch,
                                          shaft_dest.depth);
        if (you.flies() != FL_FLY || force_stair)
            mpr("You fall through a shaft!");

Replacement in crawl-ref/source/misc.cc at line 913 [10.1933596]

B:BD[10.1950361] → [10.1950361:1950422]

                mpr("You need a Rune to enter this place.");

[10.1950361]

[10.1950422]

                mpr("You need one more Rune to enter this place.");

Insertion in crawl-ref/source/misc.cc at line 920 [10.1933596]

[10.1950682]

            return;
        }
    }
    // Does the next level have a warning annotation?
    coord_def pos = you.pos();
    level_id  next_level_id = level_id::get_next_level_id(pos);
    crawl_state.level_annotation_shown = false;
    if (level_annotation_has("WARN", next_level_id)
        && next_level_id != level_id::current()
        && next_level_id.level_type == LEVEL_DUNGEON && !force_stair)
    {
        mpr("Warning: level annotation for next level is:", MSGCH_PROMPT);
        mpr(get_level_annotation(next_level_id).c_str(), MSGCH_PROMPT);
        if (!yesno("Enter next level anyways?", true, 0, true, false))
        {
            interrupt_activity( AI_FORCE_INTERRUPT );

Insertion in crawl-ref/source/misc.cc at line 942 [10.1933596]
[10.1950712]
[10.1950712]
```
        crawl_state.level_annotation_shown = true;
```

Replacement in crawl-ref/source/misc.cc at line 1050 [10.1933596]

B:BD[10.1956594] → [10.1956594:1956635]

    if (you.level_type == LEVEL_DUNGEON)

[10.1956594]

[10.1956635]

    if (shaft)
    {
        you.your_level    = shaft_level;
        you.where_are_you = shaft_dest.branch;
    }
    else if (you.level_type == LEVEL_DUNGEON)

Insertion in crawl-ref/source/misc.cc at line 1065 [10.1933596]
[10.1956948]
[10.1956948]
```
    if (shaft)
        stair_taken = DNGN_ROCK_STAIRS_DOWN;
```

Replacement in crawl-ref/source/misc.cc at line 1092 [10.1933596]

B:BD[10.1957623] → [5.1322:1380]

        climb_message(stair_find, false, old_level_type);

[10.1957623]

[10.1957660]

        if (shaft)
        {
            if (you.flies() == FL_FLY && !force_stair)
                mpr("You dive down through the shaft.");
        }
        else
            climb_message(stair_find, false, old_level_type);

Replacement in crawl-ref/source/misc.cc at line 1102 [10.1933596]

B:BD[5.1388] → [5.1388:1431]

    exit_stair_message(stair_find, false);

[5.1388]

[5.1431]

    if (!shaft)
        exit_stair_message(stair_find, false);

Replacement in crawl-ref/source/misc.cc at line 1188 [10.1933596]

B:BD[10.1957832] → [36.10025:10070]

    if (level_type_exits_up(you.level_type))

[10.1957832]

[36.10070]

    if (shaft)
    {
        you.your_level    = shaft_level;
        you.where_are_you = shaft_dest.branch;
    }
    else if (level_type_exits_up(you.level_type))

Insertion in crawl-ref/source/misc.cc at line 1482 [10.1933596]

[10.1982357]


bool is_valid_shaft_level()
{
    if (you.level_type != LEVEL_DUNGEON)
        return (false);
    // Don't generate shafts in branches where teleport control
    // is prevented.  Prevents player from going down levels without
    // reaching stairs, and also keeps player from getting stuck
    // on lower levels with the innability to use teleport control to
    // get back up.
    if (testbits(get_branch_flags(), LFLAG_NO_TELE_CONTROL))
    {
        return (false);
    }
    int depth = subdungeon_depth(you.where_are_you, you.your_level);
    // When generating levels, don't place a shaft on the level
    // immediately above the bottom of a branch if that branch is
    // significantly more dangerous than normal.
    int min_delta = 1;
    if (env.turns_on_level == -1 && your_branch().dangerous_bottom_level)
        min_delta = 2;

Insertion in crawl-ref/source/misc.cc at line 1507 [10.1933596]
[10.1982358]
[37.274]
```
    return ((your_branch().depth - depth) >= min_delta);
}
```

Replacement in crawl-ref/source/luadgn.cc at line 1073 [38.1232]

B:BD[8.1984] → [8.1984:2056]

    "open_door", "", "", "trap_mechanical", "trap_magical", "trap_iii",

[8.1984]

[39.12436]

    "open_door", "", "", "trap_mechanical", "trap_magical", "trap_natural",

Insertion in crawl-ref/source/files.cc at line 81 [10.3084589]
[12.93383]
[12.93383]
```
#include "overmap.h"
```
Insertion in crawl-ref/source/files.cc at line 906 [10.3084589]
[14.27834]
[10.3097083]
```
        env.turns_on_level = -1;
```

Insertion in crawl-ref/source/files.cc at line 1033 [10.3084589]

[40.2917]

[41.52680]


    // Inform user of level's annotation.
    if (get_level_annotation().length() > 0
        && !crawl_state.level_annotation_shown)
    {
        char buf[200];

Insertion in crawl-ref/source/files.cc at line 1040 [10.3084589]

[41.52681]

[15.13670]

        sprintf(buf, "Level annotation: %s\n",
                get_level_annotation().c_str() );
        mpr(buf, MSGCH_PLAIN, YELLOW);
    }
    crawl_state.level_annotation_shown = false;

Insertion in crawl-ref/source/externs.h at line 66 [10.3270163]
[17.81211]
[17.81211]
```
class level_id;
```

Insertion in crawl-ref/source/externs.h at line 88 [10.3270163]

[17.81595]

    virtual int       body_weight() const = 0;
    virtual int       total_weight() const = 0;

Insertion in crawl-ref/source/externs.h at line 162 [10.3270163]

[21.3501]

[16.85869]

    virtual bool is_levitating() const = 0;
    virtual bool airborne() const;

Insertion in crawl-ref/source/externs.h at line 192 [10.3270163]

[16.86361]

[9.440112]


    virtual bool     will_trigger_shaft() const;
    virtual level_id shaft_dest() const;
    virtual bool     do_shaft() = 0;

Insertion in crawl-ref/source/externs.h at line 741 [10.3270163]
[17.82989]
[17.82989]
```
    int       body_weight() const;
    int       total_weight() const;
```
Insertion in crawl-ref/source/externs.h at line 792 [10.3270163]
[16.87431]
[16.87431]
```
    bool confusable() const;
    bool slowable() const;
```
Insertion in crawl-ref/source/externs.h at line 829 [10.3270163]
[15.16013]
[10.3280317]
```
    bool do_shaft();
```
Deletion in crawl-ref/source/externs.h at line 858 [10.3270163]
B:BD[14.31657] → [42.15501:15517]
```
class level_id;
```
Insertion in crawl-ref/source/externs.h at line 997 [10.3270163]
[17.83800]
[17.83800]
```
    int       body_weight() const;
    int       total_weight() const;
```
Insertion in crawl-ref/source/externs.h at line 1060 [10.3270163]
[21.3690]
[43.3210]
```
    bool is_levitating() const;
```
Insertion in crawl-ref/source/externs.h at line 1105 [10.3270163]
[44.2237]
[14.31992]
```
    bool do_shaft();
```
Insertion in crawl-ref/source/enum.h at line 551 [10.3287960]
[45.9360]
[11.906435]
```
    CMD_ANNOTATE_LEVEL,
```
Replacement in crawl-ref/source/enum.h at line 894 [10.3287960]
B:BD[10.3308652] → [10.3308652:3308671]
```
    DNGN_TRAP_III,
```
[10.3308652]
[10.3308671]
```
    DNGN_TRAP_NATURAL,
```
Insertion in crawl-ref/source/enum.h at line 2553 [10.3287960]
[10.3373518]
[10.3373518]
```
    TRAP_SHAFT,
```

Replacement in crawl-ref/source/dungeon.cc at line 6676 [10.3429798]

B:BD[10.3686371] → [10.3686371:3686405]

B:BD[10.3686405] → [29.14702:14768]

    if (spec_type == TRAP_RANDOM)
        spec_type = static_cast<trap_type>( random2(NUM_TRAPS) );

[10.3686371]

[10.3686445]

    if (spec_type == TRAP_RANDOM || spec_type == TRAP_NONTELEPORT)
    {
        trap_type forbidden1 = NUM_TRAPS;
        trap_type forbidden2 = NUM_TRAPS;
        if (spec_type == TRAP_NONTELEPORT)
        {
            forbidden1 = TRAP_SHAFT;
            forbidden2 = TRAP_TELEPORT;
        }
        else if (!is_valid_shaft_level())
            forbidden1 = TRAP_SHAFT;
        do
        {
            spec_type = static_cast<trap_type>( random2(NUM_TRAPS) );
        } while (spec_type == forbidden1 || spec_type == forbidden2);
    }

Insertion in crawl-ref/source/direct.cc at line 1494 [10.3697945]
[36.36792]
[29.15957]
```
        case TRAP_SHAFT:
            return ("shaft trap");
```
Replacement in crawl-ref/source/direct.cc at line 1566 [10.3697945]
∅:D[36.37827] → [9.468446:468470]
∅:D[11.980670] → [9.468446:468470]
B:BD[9.468446] → [9.468446:468470]
B:BD[9.468470] → [36.37828:37853]
```
    case DNGN_TRAP_III:
        return ("trap");
```
[36.37827]
[9.469686]
```
    case DNGN_TRAP_NATURAL:
        return ("natural trap");
```
Replacement in crawl-ref/source/direct.cc at line 1719 [10.3697945]
B:BD[11.981039] → [11.981039:981063]
```
    case DNGN_TRAP_III:
```
[11.981039]
[46.8834]
```
    case DNGN_TRAP_NATURAL:
```
Insertion in crawl-ref/source/describe.cc at line 341 [10.3736416]
[47.25699]
[11.983180]
```
    "shaft"
```

Insertion in crawl-ref/source/describe.cc at line 361 [10.3736416]

[48.13361]

    else if (s == "nonteleport" || s == "noteleport" || s == "nontele"
             || s == "notele")
        return (TRAP_NONTELEPORT);

Insertion in crawl-ref/source/dat/descript/features.txt at line 88 [49.62794]
[49.64308]
[49.64308]
```
A natural trap
%%%%
```
Insertion in crawl-ref/source/command.cc at line 1466 [10.4082507]
[11.1195268]
[11.1195268]
```
            "<w>Ctrl-I</w> : annotate the dungeon level\n"
```

Insertion in crawl-ref/source/branch.h at line 49 [25.13240]

[50.5608]

[25.14282]

    bool dangerous_bottom_level; // bottom level is more dangerous than normal

Replacement in crawl-ref/source/branch.cc at line 118 [25.14355]
B:BD[51.1560] → [50.5610:5633]
```
      8, 'D', false },
```
[51.1560]
[25.14817]
```
      8, 'D', false, false },
```
Replacement in crawl-ref/source/branch.cc at line 126 [25.14355]
B:BD[51.1609] → [50.5634:5657]
```
      0, 'T', false },
```
[51.1609]
[25.15082]
```
      0, 'T', false, false },
```
Replacement in crawl-ref/source/branch.cc at line 134 [25.14355]
B:BD[51.1655] → [50.5658:5682]
```
      20, 'O', false },
```
[51.1655]
[25.15348]
```
      20, 'O', false, false },
```
Replacement in crawl-ref/source/branch.cc at line 142 [25.14355]
B:BD[51.1701] → [50.5683:5706]
```
      8, 'E', false },
```
[51.1701]
[25.15609]
```
      8, 'E', false, true },
```
Replacement in crawl-ref/source/branch.cc at line 150 [25.14355]
B:BD[51.1741] → [50.5707:5730]
```
      5, 'L', false },
```
[51.1741]
[25.15834]
```
      5, 'L', false, false },
```
Replacement in crawl-ref/source/branch.cc at line 158 [25.14355]
B:BD[51.1784] → [50.5731:5754]
```
      0, 'S', false },
```
[51.1784]
[52.10227]
```
      0, 'S', false, true },
```
Replacement in crawl-ref/source/branch.cc at line 166 [25.14355]
B:BD[53.1884] → [50.5755:5778]
```
      0, 'A', false },
```
[53.1884]
[25.16049]
```
      0, 'A', false, true },
```
Replacement in crawl-ref/source/branch.cc at line 174 [25.14355]
B:BD[51.1832] → [50.5779:5802]
```
      5, 'M', false },
```
[51.1832]
[25.16302]
```
      5, 'M', false, true },
```
Replacement in crawl-ref/source/branch.cc at line 182 [25.14355]
B:BD[51.1880] → [50.5803:5827]
```
      10, 'P', false },
```
[51.1880]
[25.16549]
```
      10, 'P', false, true },
```
Replacement in crawl-ref/source/branch.cc at line 190 [25.14355]
B:BD[51.1921] → [50.5828:5851]
```
      0, 'H', false },
```
[51.1921]
[25.16816]
```
      0, 'H', false, true },
```
Replacement in crawl-ref/source/branch.cc at line 198 [25.14355]
B:BD[51.1969] → [50.5852:5875]
```
      5, 'V', false },
```
[51.1969]
[25.17054]
```
      5, 'V', false, true },
```
Replacement in crawl-ref/source/branch.cc at line 207 [25.14355]
B:BD[51.2020] → [50.5876:5899]
```
      0, 'B', false },
```
[51.2020]
[25.17333]
```
      0, 'B', false, false },
```
Replacement in crawl-ref/source/branch.cc at line 215 [25.14355]
B:BD[51.2062] → [50.5900:5923]
```
      5, 'C', false },
```
[51.2062]
[25.17557]
```
      5, 'C', false, false },
```
Replacement in crawl-ref/source/branch.cc at line 223 [25.14355]
B:BD[51.2103] → [50.5924:5947]
```
      0, 'G', false },
```
[51.2103]
[25.17786]
```
      0, 'G', false, true },
```
Replacement in crawl-ref/source/branch.cc at line 231 [25.14355]
B:BD[51.2151] → [50.5948:5971]
```
      0, 'U', false },
```
[51.2151]
[25.18056]
```
      0, 'U', false, false },
```
Replacement in crawl-ref/source/branch.cc at line 239 [25.14355]
B:BD[51.2189] → [50.5972:5994]
```
      0, 'I', true },
```
[51.2189]
[25.18293]
```
      0, 'I', true, true },
```
Replacement in crawl-ref/source/branch.cc at line 247 [25.14355]
B:BD[51.2235] → [50.5995:6017]
```
      0, 'N', true },
```
[51.2235]
[25.18540]
```
      0, 'N', true, true },
```
Replacement in crawl-ref/source/branch.cc at line 255 [25.14355]
B:BD[51.2281] → [50.6018:6040]
```
      0, 'X', true },
```
[51.2281]
[25.18794]
```
      0, 'X', true, true },
```
Replacement in crawl-ref/source/branch.cc at line 263 [25.14355]
B:BD[51.2329] → [50.6041:6063]
```
      0, 'Y', true },
```
[51.2329]
[25.19052]
```
      0, 'Y', true, true },
```
Replacement in crawl-ref/source/branch.cc at line 271 [25.14355]
B:BD[51.2348] → [50.6064:6087]
```
      0, 'R', false },
```
[51.2348]
[25.19238]
```
      0, 'R', false, false },
```
Replacement in crawl-ref/source/branch.cc at line 279 [25.14355]
B:BD[51.2367] → [50.6088:6111]
```
      0, '0', false },
```
[51.2367]
[25.19424]
```
      0, '0', false, false },
```
Replacement in crawl-ref/source/branch.cc at line 287 [25.14355]
B:BD[51.2413] → [50.6112:6135]
```
      1, 'Z', false },
```
[51.2413]
[25.19656]
```
      1, 'Z', false, true },
```
Replacement in crawl-ref/source/branch.cc at line 295 [25.14355]
B:BD[51.2432] → [50.6136:6156]
```
      0, 0, false }
```
[51.2432]
[25.19839]
```
      0, 0, false, false }
```

Insertion in crawl-ref/source/acr.cc at line 1449 [10.4397395]

[11.1260205]

}
static bool can_go_down_shaft()
{
    // Not a shaft
    if (trap_type_at_xy(you.x_pos, you.y_pos) != TRAP_SHAFT)
        return (false);
    // Undiscovered shaft
    if (grd[you.x_pos][you.y_pos] == DNGN_UNDISCOVERED_TRAP)
        return (false);
    // Have to fly to dive through it.
    if (you.flies() != FL_FLY)
        return (false);
    return (true);

Insertion in crawl-ref/source/acr.cc at line 1511 [10.4397395]

[54.90382]

[36.50355]

    if (trap_at_xy(you.x_pos, you.y_pos) == TRAP_SHAFT
        && grd[you.x_pos][you.y_pos] != DNGN_UNDISCOVERED_TRAP
        && !can_go_down_shaft())
    {
        mpr("You must have controlled flight to dive through a shaft.");
        return;
    }

Insertion in crawl-ref/source/acr.cc at line 1981 [10.4397395]

[9.551934]

[9.551957]

    case CMD_ANNOTATE_LEVEL:
        annotate_level();
        break;

Replacement in crawl-ref/source/acr.cc at line 3126 [10.4397395]
B:BD[11.1276816] → [55.1509:1551]
```
    case CONTROL('I'): return CMD_NO_CMD;
```
[11.1276816]
[11.1276858]
```
    case CONTROL('I'): return CMD_ANNOTATE_LEVEL;
```

Replacement in crawl-ref/source/acr.cc at line 3218 [10.4397395]

B:BD[10.4465172] → [10.4465172:4465253]

        if (grd[dx][dy] >= DNGN_TRAP_MECHANICAL && grd[dx][dy] <= DNGN_TRAP_III)

[10.4465172]

[10.4465253]

        if (grd[dx][dy] >= DNGN_TRAP_MECHANICAL
            && grd[dx][dy] <= DNGN_TRAP_NATURAL)