const char *icon_name =
#ifdef DATA_DIR_PATH
            DATA_DIR_PATH
#endif

    const char *icon_name = "dat/tiles/stone_soup_icon-win32.png";

            "dat/tiles/stone_soup_icon-win32.png";

    const char *icon_name = "dat/tiles/stone_soup_icon-32x32.png";

            "dat/tiles/stone_soup_icon-32x32.png";

        } // switch

        }

    } // while

    }

static bool _raise_remains(const coord_def &a, int corps, beh_type beha,

static bool _raise_remains(const coord_def &pos, int corps, beh_type beha,

    {
        if (see_grid(pos))
        {
            mpr("The zero-headed hydra corpse sways and immediately "
                "collapses!");
        }

    }

        mon = (mons_zombie_size(item.plus) == Z_SMALL) ?
                MONS_ZOMBIE_SMALL : MONS_ZOMBIE_LARGE;

        mon = (mons_zombie_size(item.plus) == Z_SMALL) ? MONS_ZOMBIE_SMALL
                                                       : MONS_ZOMBIE_LARGE;

        mon = (mons_zombie_size(item.plus) == Z_SMALL) ?
                MONS_SKELETON_SMALL : MONS_SKELETON_LARGE;

        mon = (mons_zombie_size(item.plus) == Z_SMALL) ? MONS_SKELETON_SMALL
                                                       : MONS_SKELETON_LARGE;

    const int monster = create_monster(

    int monster = create_monster(

                                      0, 0, a, hitting,

                                      0, 0, pos, hitting,

    if (monster != -1)
    {
        const int monnum = item.orig_monnum - 1;

    if (monster == -1)
        return (false);

        if (is_named_corpse(item))
            name_zombie(&menv[monster], monnum, get_corpse_name(item));

    const int monnum = item.orig_monnum - 1;

        equip_undead(a, corps, monster, monnum);

    if (is_named_corpse(item))
        name_zombie(&menv[monster], monnum, get_corpse_name(item));

        destroy_item(corps);

    equip_undead(pos, corps, monster, monnum);

        return (true);
    }

    destroy_item(corps);

    return (false);

    return (true);

        monsters *monster_vic = monster_at(target);

        monsters *mons = monster_at(target);

        // Pop submerged status (this may be a little too nice
        // because it will affect trapdoor spiders, not just fish).
        if (monster_vic)
            monster_vic->del_ench(ENCH_SUBMERGED);

        // Pop submerged status.
        if (mons && mons_habitat(mons) == HT_WATER)
        {
            mons->del_ench(ENCH_SUBMERGED);
            if (ftype == DNGN_FLOOR)
                mons->add_ench(mon_enchant(ENCH_AQUATIC_LAND, 0, KC_YOU));
        }

            if (!monster_vic)

            if (!mons)

                backlight_monsters(target,1,0);

                backlight_monsters(target, 1, 0);

    radius_iterator rad(target, LOS_RADIUS, true, true, true);

    for (; rad; ++rad)

    for (radius_iterator rad(target, LOS_RADIUS, true, true, true); rad; ++rad)

            monsters *mon = monster_at(*rad);
            if (mon && mon->has_ench(ENCH_AQUATIC_LAND))
                mon->del_ench(ENCH_AQUATIC_LAND);

        // XXX: Why do we destroy the old and create a new plant
        //      rather than simply upgrade the old plant?

        monster_type new_species;

        monster_type new_species = MONS_PLANT;

dc-dngn/dngn_entrance UNSEEN_ENTRANCE

dc-dngn/gateways/dngn_entrance UNSEEN_ENTRANCE

// New player movement speed system... allows for a bit more that

// New player movement speed system... allows for a bit more than

            can_move = (mons_amphibious(mon))
                ? DNGN_DEEP_WATER : DNGN_SHALLOW_WATER;

            can_move = (mons_amphibious(mon) ? DNGN_DEEP_WATER
                                             : DNGN_SHALLOW_WATER);

           return (false);

            return (false);

    }
    // If a water monster is currently flopping around on land, it cannot
    // really control where it wants to move, though there's a 50% chance
    // of flopping into an adjacent water grid.
    if (monster->has_ench(ENCH_AQUATIC_LAND))
    {
        std::vector<coord_def> adj_water;
        std::vector<coord_def> adj_move;
        for (adjacent_iterator ai(monster->pos()); ai; ++ai)
        {
            if (!grid_is_solid(*ai))
            {
                adj_move.push_back(*ai);
                if (grid_is_watery(grd(*ai)))
                    adj_water.push_back(*ai);
            }
        }
        if (adj_move.empty())
        {
            simple_monster_message(monster, " flops around on dry land!");
            return (false);
        }
        std::vector<coord_def> moves = adj_water;
        if (adj_water.empty() || coinflip())
            moves = adj_move;
        coord_def newpos = monster->pos();
        int count = 0;
        for (unsigned int i = 0; i < moves.size(); ++i)
            if (one_chance_in(++count))
                newpos = moves[i];
        const monsters *mon2 = monster_at(newpos);
        if (newpos == you.pos() && mons_wont_attack(monster)
            || (mon2 && mons_wont_attack(monster) == mons_wont_attack(mon2)))
        {
            simple_monster_message(monster, " flops around on dry land!");
            return (false);
        }
        return _do_move_monster(monster, newpos - monster->pos());

        break;
    case ENCH_AQUATIC_LAND:
        // Aquatic monsters lose hit points every turn they spend on dry land.
        ASSERT(mons_habitat(this) == HT_WATER
               && !grid_is_watery( grd(pos()) ));
        // Zombies don't take damage from flopping about on land.
        if (mons_is_zombified(this))
            break;
        // We don't have a reasonable agent to give.
        // Don't clean up the monster in order to credit properly.
        hurt(NULL, 1 + random2(5), BEAM_NONE, false);
        // Credit the kill.
        if (hit_points < 1)
        {
            monster_die(this, me.killer(), me.kill_agent());
            break;
        }

    // monsters stepping on traps:

    if (alive() && has_ench(ENCH_AQUATIC_LAND))
    {
        if (!grid_is_watery( grd(pos()) ))
            simple_monster_message(this, " flops around on dry land!");
        else if (!grid_is_watery( grd(oldpos) ))
        {
            simple_monster_message(this, " dives back into the water!");
            del_ench(ENCH_AQUATIC_LAND);
        }
    }
    // Monsters stepping on traps:

            if (mons_class_amphibious(type))

            if (mons_amphibious(this))

    "soul-ripe", "decay", "hungry", "bug"

    "soul-ripe", "decay", "hungry", "flopping", "bug"

static int runes_in_pack()

static int runes_in_pack(std::vector<int> &runes)

            for (int q = 1; runes.size() < 3 && q < you.inv[i].quantity; ++q)
                runes.push_back(you.inv[i].plus);

        const int num_runes = runes_in_pack();

        std::vector<int> runes;
        const int num_runes = runes_in_pack(runes);

    {

    }

        mpr("You're wielding some staff I've never heard of! (fight.cc)");

        mpr("You're wielding some staff I've never heard of! (fight.cc)",
            MSGCH_ERROR);

    } // end switch

    }

    ENCH_BATTLE_FRENZY,  // 25 -- Monster is in a battle frenzy

    ENCH_BATTLE_FRENZY,                //   25 -- Monster is in a battle frenzy

    ENCH_SOUL_RIPE,

    ENCH_SOUL_RIPE,                    //   30

    ENCH_AQUATIC_LAND,   // Water monsters lose hp while on land.

    NUM_ENCHANTMENTS

    NUM_ENCHANTMENTS                   //    34

    // Lastly try to dump the Lua persistant data and the contents of the Lua

    // Lastly try to dump the Lua persistent data and the contents of the Lua

    fprintf(file, "Lua persistant data:" EOL);

    fprintf(file, "Lua persistent data:" EOL);

            error_inout += type;
            error_inout += "s.";

            error_inout += pluralise(type);
            error_inout += ".";

    #ifndef REGEX_PCRE

    #endif

crawl - play the roguelike game of crawl

crawl \- play the roguelike game of crawl

Use the "-help" option to get a list of command line options and their descriptions.

Use the "\-help" option to get a list of command line options and their descriptions.