fiddlerwoaroof/crawl - Change NVAQAP5YCPRQHJN4UL3ZYNKZLVUUXCPR57VC7SGVPSB3NPM6ORFAC

Move the monster dumping code from state.cc to debug.cc, and dump to stderr to

reduce the need to pass a file pointer all over the place.

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

Created by zelgadis on January 28, 2009

NVAQAP5YCPRQHJN4UL3ZYNKZLVUUXCPR57VC7SGVPSB3NPM6ORFAC

Dependencies

In channels

main

Change contents

Deletion in crawl-ref/source/state.h at line 14 [6.42804]
B:BD[4.326] → [5.257:276]
```
#include <stdio.h>
```
Replacement in crawl-ref/source/state.h at line 135 [6.42804]
B:BD[5.407] → [5.407:434]
```
    void dump(FILE* file);
```
[5.407]
[7.1044]
```
    void dump();
```
Deletion in crawl-ref/source/state.cc at line 16 [9.1546]
B:BD[8.596] → [3.258:277]
```
#include "items.h"
```
Deletion in crawl-ref/source/state.cc at line 19 [9.1546]
B:BD[10.216] → [3.278:300]
```
#include "monstuff.h"
```
Deletion in crawl-ref/source/state.cc at line 23 [9.1546]
B:BD[5.458] → [3.301:323]
```
#include "spl-util.h"
```
Deletion in crawl-ref/source/state.cc at line 24 [9.1546]
B:BD[9.2007] → [3.324:343]
```
#include "stuff.h"
```

Deletion in crawl-ref/source/state.cc at line 432 [9.1546]

B:BD[7.2399] → [3.344:909]

∅:D[3.909] → [7.2399:2401]

B:BD[7.2399] → [7.2399:2401]

B:BD[7.2401] → [3.910:3277]

∅:D[3.3277] → [7.2401:2402]

B:BD[7.2401] → [7.2401:2402]

B:BD[7.2402] → [3.3278:6471]

}
static std::string _coord_str(const coord_def &pos)
{
    return make_stringf("(%d, %d)%s", pos.x, pos.y,
                        !in_bounds(pos) ? " <OoB>" : "");
}
static std::string _dump_mon_short(monsters* mon)
{
    const int midx = monster_index(mon);
    if (invalid_monster_index(midx))
        return make_stringf("Invalid monster index %d", midx);
    std::string out = "Monster '" + mon->full_name(DESC_PLAIN, true) + "' ";
    out += make_stringf("%s [midx = %d]", _coord_str(mon->pos()).c_str(),
                        midx);
    return (out);
}
static void _dump_mon_full(FILE* file, monsters* mon, bool recurse)
{
    const int midx = monster_index(mon);
    if (invalid_monster_index(midx) || invalid_monster_class(mon->type))
        return;
    fprintf(file, "<<<<<<<<<" EOL);
    fprintf(file, "Name: %s" EOL, mon->name(DESC_PLAIN, true).c_str());
    fprintf(file, "Base name: %s" EOL,
            mon->base_name(DESC_PLAIN, true).c_str());
    fprintf(file, "Full name: %s" EOL EOL,
            mon->full_name(DESC_PLAIN, true).c_str());
    if (in_bounds(mon->pos()))
    {
        std::string feat = 
            raw_feature_description(grd(mon->pos()), NUM_TRAPS, true);
        fprintf(file, "On/in/over feature: %s" EOL EOL, feat.c_str());
    }
    fprintf(file, "Foe: ");
    if (mon->foe == MHITNOT)
        fprintf(file, "none");
    else if (mon->foe == MHITYOU)
        fprintf(file, "player");
    else if (invalid_monster_index(mon->foe))
        fprintf(file, "invalid monster index %d", mon->foe);
    else if (mon->foe == midx)
        fprintf(file, "self");
    else
        fprintf(file, "%s", _dump_mon_short(&menv[mon->foe]).c_str());
    fprintf(file, EOL);
    fprintf(file, "Target: ");
    if (mon->target.origin())
        fprintf(file, "none" EOL);
    else
        fprintf(file, "%s" EOL, _coord_str(mon->target).c_str());
    int target = MHITNOT;
    fprintf(file, "At target: ");
    if (mon->target.origin())
        fprintf(file, "N/A");
    else if (mon->target == you.pos())
    {
        fprintf(file, "player");
        target = MHITYOU;
    }
    else if (mon->target == mon->pos())
    {
        fprintf(file, "self");
        target = midx;
    }
    else if (in_bounds(mon->target))
    {
       target = mgrd(mon->target);
       if (target == NON_MONSTER)
           fprintf(file, "nothing");
       else if (target == midx)
           fprintf(file, "improperly linked self");
       else if (target == mon->foe)
           fprintf(file, "same as foe");
       else if (invalid_monster_index(target))
           fprintf(file, "invalid monster index %d", target);
       else
           fprintf(file, "%s", _dump_mon_short(&menv[target]).c_str());
    }
    else
        fprintf(file, "<OoB>");
    fprintf(file, EOL);
    if (mon->is_patrolling())
        fprintf(file, "Patrolling: %s" EOL EOL,
                _coord_str(mon->patrol_point).c_str());
    if (mon->travel_target != MTRAV_NONE)
    {
        fprintf(file, EOL "Travelling:" EOL);
        fprintf(file, "    travel_target      = %d" EOL, mon->travel_target);
        fprintf(file, "    travel_path.size() = %lu" EOL,
                (long unsigned int) mon->travel_path.size());
        if (mon->travel_path.size() > 0)
        {
            fprintf(file, "    next travel step: %s" EOL,
                    _coord_str(mon->travel_path.back()).c_str());
            fprintf(file, "    last travel step: %s" EOL,
                    _coord_str(mon->travel_path.front()).c_str());
        }
    }
    fprintf(file, EOL);
    fprintf(file, "Inventory:" EOL);
    for (int i = 0; i < NUM_MONSTER_SLOTS; i++)
    {
        const int idx = mon->inv[i];
        if (idx == NON_ITEM)
            continue;
        fprintf(file, "    slot #%d: ", i);
        if (idx < 0 || idx > MAX_ITEMS)
        {
            fprintf(file, "invalid item index %d" EOL, idx);
            continue;
        }
        const item_def &item(mitm[idx]);
        if (!is_valid_item(item))
        {
            fprintf(file, "invalid item" EOL);
            continue;
        }
        fprintf(file, "%s", item.name(DESC_PLAIN, false, true).c_str());
        if (!held_by_monster(item))
            fprintf(file, " [not held by monster, pos = %s]",
                    _coord_str(item.pos).c_str());
        else if (holding_monster(item) != mon)
            fprintf(file, " [held by other monster: %s]",
                    _dump_mon_short(holding_monster(item)).c_str());
        fprintf(file, EOL);
    }
    fprintf(file, EOL);
    if (mons_class_flag(mon->type, M_SPELLCASTER))
    {
        fprintf(file, "Spells:" EOL);
        for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; i++)
        {
            spell_type spell = mon->spells[i];
            if (spell == SPELL_NO_SPELL)
                continue;
            fprintf(file, "    slot #%d: ", i);
            if (!is_valid_spell(spell))
                fprintf(file, "Invalid spell #%d" EOL, (int) spell);
            else
                fprintf(file, "%s" EOL, spell_title(spell));
        }
        fprintf(file, EOL);
    }
    fprintf(file, "attitude: %d, behaviour: %d, number: %d, flags: 0x%lx" EOL,
            mon->attitude, mon->behaviour, mon->number, mon->flags);
    fprintf(file, "colour: %d, foe_memory: %d, shield_blocks:%d, "
                  "experience: %lu" EOL,
            mon->colour, mon->foe_memory, mon->shield_blocks,
            mon->experience);
    fprintf(file, "god: %s, seen_context: %s" EOL,
            god_name(mon->god).c_str(), mon->seen_context.c_str());
    fprintf(file, ">>>>>>>>>" EOL EOL);
    if (!recurse)
        return;
    if (!invalid_monster_index(mon->foe) && mon->foe != midx
        && !invalid_monster_class(menv[mon->foe].type))
    {
        fprintf(file, "Foe:" EOL);
        _dump_mon_full(file, &menv[mon->foe], false);
    }
    if (!invalid_monster_index(target) && target != midx
        && target != mon->foe
        && !invalid_monster_class(menv[target].type))
    {
        fprintf(file, "Target:" EOL);
        _dump_mon_full(file, &menv[target], false);
    }

Replacement in crawl-ref/source/state.cc at line 434 [9.1546]
∅:D[7.2402] → [5.540:574]
∅:D[3.6474] → [5.540:574]
B:BD[5.540] → [5.540:574]
```
void game_state::dump(FILE* file)
```
[3.6474]
[5.574]
```
void game_state::dump()
```
Replacement in crawl-ref/source/state.cc at line 436 [9.1546]
B:BD[5.576] → [11.258:304]
```
    fprintf(file, EOL "Game state:" EOL EOL);
```
[5.576]
[5.622]
```
    fprintf(stderr, EOL "Game state:" EOL EOL);
```

Replacement in crawl-ref/source/state.cc at line 438 [9.1546]

B:BD[5.623] → [3.6475:6540]

    fprintf(file, "mouse_enabled: %d, waiting_for_command: %d, "

[5.623]

[11.305]

    fprintf(stderr, "mouse_enabled: %d, waiting_for_command: %d, "

Replacement in crawl-ref/source/state.cc at line 441 [9.1546]

B:BD[5.800] → [5.800:868]

    fprintf(file, "io_inited: %d, need_save: %d, saving_game: %d, "

[5.800]

[11.352]

    fprintf(stderr, "io_inited: %d, need_save: %d, saving_game: %d, "

Replacement in crawl-ref/source/state.cc at line 444 [9.1546]

B:BD[5.979] → [5.979:1044]

    fprintf(file, "seen_hups: %d, map_stat_gen: %d, arena: %d, "

[5.979]

[11.399]

    fprintf(stderr, "seen_hups: %d, map_stat_gen: %d, arena: %d, "

Replacement in crawl-ref/source/state.cc at line 448 [9.1546]
B:BD[5.1180] → [11.461:485]
```
    fprintf(file, EOL);
```
[5.1180]
[5.1207]
```
    fprintf(stderr, EOL);
```

Replacement in crawl-ref/source/state.cc at line 452 [9.1546]

B:BD[5.1247] → [11.486:532]

        fprintf(file, "Startup errors:" EOL);

[5.1247]

[5.1293]

        fprintf(stderr, "Startup errors:" EOL);

Replacement in crawl-ref/source/state.cc at line 454 [9.1546]

B:BD[5.1358] → [11.533:625]

            fprintf(file, "%s" EOL, startup_errors[i].c_str());
        fprintf(file, EOL);

[5.1358]

[5.1451]

            fprintf(stderr, "%s" EOL, startup_errors[i].c_str());
        fprintf(stderr, EOL);

Replacement in crawl-ref/source/state.cc at line 458 [9.1546]

B:BD[5.1458] → [11.626:701]

    fprintf(file, "prev_cmd = %s" EOL, command_to_name(prev_cmd).c_str());

[5.1458]

[5.1533]

    fprintf(stderr, "prev_cmd = %s" EOL, command_to_name(prev_cmd).c_str());

Replacement in crawl-ref/source/state.cc at line 462 [9.1546]

B:BD[5.1570] → [5.1570:1629]

        fprintf(file, "Doing prev_cmd again with keys: ");

[5.1570]

[5.1629]

        fprintf(stderr, "Doing prev_cmd again with keys: ");

Replacement in crawl-ref/source/state.cc at line 464 [9.1546]

B:BD[5.1693] → [5.1693:1746]

B:BD[5.1746] → [11.702:730]

∅:D[11.730] → [5.1777:1819]

B:BD[5.1777] → [5.1777:1819]

            fprintf(file, "%d, ", prev_cmd_keys[i]);
        fprintf(file, EOL);
        fprintf(file, "As ASCII keys: ");

[5.1693]

[5.1819]

            fprintf(stderr, "%d, ", prev_cmd_keys[i]);
        fprintf(stderr, EOL);
        fprintf(stderr, "As ASCII keys: ");

Replacement in crawl-ref/source/state.cc at line 468 [9.1546]

B:BD[5.1883] → [5.1883:1941]

B:BD[5.1941] → [11.731:763]

            fprintf(file, "%c", (char) prev_cmd_keys[i]);
        fprintf(file, EOL EOL);

[5.1883]

[5.1976]

            fprintf(stderr, "%c", (char) prev_cmd_keys[i]);
        fprintf(stderr, EOL EOL);

Replacement in crawl-ref/source/state.cc at line 471 [9.1546]

B:BD[5.1982] → [11.764:843]

    fprintf(file, "repeat_cmd = %s" EOL, command_to_name(repeat_cmd).c_str());

[5.1982]

[5.2061]

    fprintf(stderr, "repeat_cmd = %s" EOL, command_to_name(repeat_cmd).c_str());

Replacement in crawl-ref/source/state.cc at line 475 [9.1546]

B:BD[5.2121] → [2.331:387]

∅:D[2.387] → [5.2178:2246]

∅:D[11.900] → [5.2178:2246]

B:BD[5.2178] → [5.2178:2246]

        fprintf(file, "Doing command repetition:" EOL);
        fprintf(file, "cmd_repeat_start:%d, cmd_repeat_count: %d, "

[5.2121]

[11.901]

        fprintf(stderr, "Doing command repetition:" EOL);
        fprintf(stderr, "cmd_repeat_start:%d, cmd_repeat_count: %d, "

Replacement in crawl-ref/source/state.cc at line 481 [9.1546]

B:BD[5.2431] → [5.2431:2479]

        fprintf(file, "Keys being repeated: ");

[5.2431]

[5.2479]

        fprintf(stderr, "Keys being repeated: ");

Replacement in crawl-ref/source/state.cc at line 483 [9.1546]

B:BD[5.2545] → [5.2545:2600]

B:BD[5.2600] → [11.1003:1031]

∅:D[11.1031] → [5.2631:2673]

B:BD[5.2631] → [5.2631:2673]

            fprintf(file, "%d, ", repeat_cmd_keys[i]);
        fprintf(file, EOL);
        fprintf(file, "As ASCII keys: ");

[5.2545]

[5.2673]

            fprintf(stderr, "%d, ", repeat_cmd_keys[i]);
        fprintf(stderr, EOL);
        fprintf(stderr, "As ASCII keys: ");

Replacement in crawl-ref/source/state.cc at line 487 [9.1546]

B:BD[5.2739] → [5.2739:2799]

B:BD[5.2799] → [3.6541:6569]

            fprintf(file, "%c", (char) repeat_cmd_keys[i]);
        fprintf(file, EOL);

[5.2739]

[5.2834]

            fprintf(stderr, "%c", (char) repeat_cmd_keys[i]);
        fprintf(stderr, EOL);

Replacement in crawl-ref/source/state.cc at line 491 [9.1546]
B:BD[5.2841] → [3.6570:6594]
```
    fprintf(file, EOL);
```
[5.2841]
[3.6594]
```
    fprintf(stderr, EOL);
```

Replacement in crawl-ref/source/state.cc at line 495 [9.1546]

B:BD[5.2910] → [11.1065:1136]

        fprintf(file, "God %s currently acting with depth %d" EOL EOL,

[5.2910]

[5.2981]

        fprintf(stderr, "God %s currently acting with depth %d" EOL EOL,

Replacement in crawl-ref/source/state.cc at line 501 [9.1546]

B:BD[5.3098] → [11.1137:1186]

        fprintf(file, "Other gods acting:" EOL);

[5.3098]

[5.3148]

        fprintf(stderr, "Other gods acting:" EOL);

Replacement in crawl-ref/source/state.cc at line 503 [9.1546]

B:BD[5.3212] → [11.1187:1241]

            fprintf(file, "God %s with depth %d" EOL,

[5.3212]

[5.3266]

            fprintf(stderr, "God %s with depth %d" EOL,

Replacement in crawl-ref/source/state.cc at line 506 [9.1546]
B:BD[5.3377] → [3.6596:6628]
```
        fprintf(file, EOL EOL);
```
[5.3377]
[12.279]
```
        fprintf(stderr, EOL EOL);
```

Replacement in crawl-ref/source/state.cc at line 511 [9.1546]

B:BD[12.317] → [3.6629:6779]

        fprintf(file, "%s currently acting:" EOL EOL,
                _dump_mon_short(mon_act).c_str());
        _dump_mon_full(file, mon_act, true);

[12.317]

[5.3408]

        fprintf(stderr, "%s currently acting:" EOL EOL,
                debug_mon_str(mon_act).c_str());
        debug_dump_mon(mon_act, true);

Replacement in crawl-ref/source/state.cc at line 518 [9.1546]

B:BD[12.481] → [12.481:535]

        fprintf(file, "Others monsters acting:" EOL);

[12.481]

[12.535]

        fprintf(stderr, "Others monsters acting:" EOL);

Replacement in crawl-ref/source/state.cc at line 520 [9.1546]

B:BD[12.599] → [3.6780:6884]

            fprintf(file, "    %s" EOL,
                    _dump_mon_short(mon_act_stack[i]).c_str());

[12.599]

[12.716]

            fprintf(stderr, "    %s" EOL,
                    debug_mon_str(mon_act_stack[i]).c_str());

Insertion in crawl-ref/source/debug.h at line 148 [13.4011741]

[5.10327]

[13.4016395]


std::string debug_coord_str(const coord_def &pos);
std::string debug_mon_str(const monsters* mon);
void        debug_dump_mon(const monsters* mon, bool recurse);

Replacement in crawl-ref/source/debug.cc at line 5657 [13.4016436]
B:BD[5.12437] → [5.12437:12465]
```
    crawl_state.dump(file);
```
[5.12437]
[5.12465]
```
    crawl_state.dump();
```

Insertion in crawl-ref/source/debug.cc at line 5682 [13.4016436]

[5.12765]

}
std::string debug_coord_str(const coord_def &pos)
{
    return make_stringf("(%d, %d)%s", pos.x, pos.y,
                        !in_bounds(pos) ? " <OoB>" : "");
}
std::string debug_mon_str(const monsters* mon)
{
    const int midx = monster_index(mon);
    if (invalid_monster_index(midx))
        return make_stringf("Invalid monster index %d", midx);
    std::string out = "Monster '" + mon->full_name(DESC_PLAIN, true) + "' ";
    out += make_stringf("%s [midx = %d]", debug_coord_str(mon->pos()).c_str(),
                        midx);
    return (out);

Insertion in crawl-ref/source/debug.cc at line 5702 [13.4016436]

[5.12767]


void debug_dump_mon(const monsters* mon, bool recurse)
{
    const int midx = monster_index(mon);
    if (invalid_monster_index(midx) || invalid_monster_class(mon->type))
        return;
    fprintf(stderr, "<<<<<<<<<" EOL);
    fprintf(stderr, "Name: %s" EOL, mon->name(DESC_PLAIN, true).c_str());
    fprintf(stderr, "Base name: %s" EOL,
            mon->base_name(DESC_PLAIN, true).c_str());
    fprintf(stderr, "Full name: %s" EOL EOL,
            mon->full_name(DESC_PLAIN, true).c_str());
    if (in_bounds(mon->pos()))
    {
        std::string feat = 
            raw_feature_description(grd(mon->pos()), NUM_TRAPS, true);
        fprintf(stderr, "On/in/over feature: %s" EOL EOL, feat.c_str());
    }

Insertion in crawl-ref/source/debug.cc at line 5724 [13.4016436]

[5.12768]

[14.2380]

    fprintf(stderr, "Foe: ");
    if (mon->foe == MHITNOT)
        fprintf(stderr, "none");
    else if (mon->foe == MHITYOU)
        fprintf(stderr, "player");
    else if (invalid_monster_index(mon->foe))
        fprintf(stderr, "invalid monster index %d", mon->foe);
    else if (mon->foe == midx)
        fprintf(stderr, "self");
    else
        fprintf(stderr, "%s", debug_mon_str(&menv[mon->foe]).c_str());
    fprintf(stderr, EOL);
    fprintf(stderr, "Target: ");
    if (mon->target.origin())
        fprintf(stderr, "none" EOL);
    else
        fprintf(stderr, "%s" EOL, debug_coord_str(mon->target).c_str());
    int target = MHITNOT;
    fprintf(stderr, "At target: ");
    if (mon->target.origin())
        fprintf(stderr, "N/A");
    else if (mon->target == you.pos())
    {
        fprintf(stderr, "player");
        target = MHITYOU;
    }
    else if (mon->target == mon->pos())
    {
        fprintf(stderr, "self");
        target = midx;
    }
    else if (in_bounds(mon->target))
    {
       target = mgrd(mon->target);
       if (target == NON_MONSTER)
           fprintf(stderr, "nothing");
       else if (target == midx)
           fprintf(stderr, "improperly linked self");
       else if (target == mon->foe)
           fprintf(stderr, "same as foe");
       else if (invalid_monster_index(target))
           fprintf(stderr, "invalid monster index %d", target);
       else
           fprintf(stderr, "%s", debug_mon_str(&menv[target]).c_str());
    }
    else
        fprintf(stderr, "<OoB>");
    fprintf(stderr, EOL);
    if (mon->is_patrolling())
        fprintf(stderr, "Patrolling: %s" EOL EOL,
                debug_coord_str(mon->patrol_point).c_str());
    if (mon->travel_target != MTRAV_NONE)
    {
        fprintf(stderr, EOL "Travelling:" EOL);
        fprintf(stderr, "    travel_target      = %d" EOL, mon->travel_target);
        fprintf(stderr, "    travel_path.size() = %lu" EOL,
                (long unsigned int) mon->travel_path.size());
        if (mon->travel_path.size() > 0)
        {
            fprintf(stderr, "    next travel step: %s" EOL,
                    debug_coord_str(mon->travel_path.back()).c_str());
            fprintf(stderr, "    last travel step: %s" EOL,
                    debug_coord_str(mon->travel_path.front()).c_str());
        }
    }
    fprintf(stderr, EOL);
    fprintf(stderr, "Inventory:" EOL);
    for (int i = 0; i < NUM_MONSTER_SLOTS; i++)
    {
        const int idx = mon->inv[i];
        if (idx == NON_ITEM)
            continue;
        fprintf(stderr, "    slot #%d: ", i);
        if (idx < 0 || idx > MAX_ITEMS)
        {
            fprintf(stderr, "invalid item index %d" EOL, idx);
            continue;
        }
        const item_def &item(mitm[idx]);
        if (!is_valid_item(item))
        {
            fprintf(stderr, "invalid item" EOL);
            continue;
        }
        fprintf(stderr, "%s", item.name(DESC_PLAIN, false, true).c_str());
        if (!held_by_monster(item))
            fprintf(stderr, " [not held by monster, pos = %s]",
                    debug_coord_str(item.pos).c_str());
        else if (holding_monster(item) != mon)
            fprintf(stderr, " [held by other monster: %s]",
                    debug_mon_str(holding_monster(item)).c_str());
        fprintf(stderr, EOL);
    }
    fprintf(stderr, EOL);
    if (mons_class_flag(mon->type, M_SPELLCASTER))
    {
        fprintf(stderr, "Spells:" EOL);
        for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; i++)
        {
            spell_type spell = mon->spells[i];
            if (spell == SPELL_NO_SPELL)
                continue;
            fprintf(stderr, "    slot #%d: ", i);
            if (!is_valid_spell(spell))
                fprintf(stderr, "Invalid spell #%d" EOL, (int) spell);
            else
                fprintf(stderr, "%s" EOL, spell_title(spell));
        }
        fprintf(stderr, EOL);
    }
    fprintf(stderr, "attitude: %d, behaviour: %d, number: %d, flags: 0x%lx" EOL,
            mon->attitude, mon->behaviour, mon->number, mon->flags);
    fprintf(stderr, "colour: %d, foe_memory: %d, shield_blocks:%d, "
                  "experience: %lu" EOL,
            mon->colour, mon->foe_memory, mon->shield_blocks,
            mon->experience);
    fprintf(stderr, "god: %s, seen_context: %s" EOL,
            god_name(mon->god).c_str(), mon->seen_context.c_str());
    fprintf(stderr, ">>>>>>>>>" EOL EOL);
    if (!recurse)
        return;
    if (!invalid_monster_index(mon->foe) && mon->foe != midx
        && !invalid_monster_class(menv[mon->foe].type))
    {
        fprintf(stderr, "Foe:" EOL);
        debug_dump_mon(&menv[mon->foe], false);
    }
    if (!invalid_monster_index(target) && target != midx
        && target != mon->foe
        && !invalid_monster_class(menv[target].type))
    {
        fprintf(stderr, "Target:" EOL);
        debug_dump_mon(&menv[target], false);
    }
}