item_def *player_slot_item(equipment_type eq);

    return you.slot_item(eq);

    return (you.slot_item(eq));

    return you.weapon();

    return (you.weapon());

    if (grd(mon->pos()) != DNGN_SHALLOW_WATER)
        return (false);

    if (grd(mon->pos()) == DNGN_SHALLOW_WATER)
    {
        const item_def *weapon = you.weapon();
        return (weapon && weapon_skill(*weapon) == SK_POLEARMS);
    }

    const item_def *weapon = you.weapon();
    return (weapon && weapon_skill(*weapon) == SK_POLEARMS);

    return (false);

    return (item == -1? NULL : &inv[item]);

    return (item == -1 ? NULL : &inv[item]);

    return slot_item(EQ_WEAPON);

    return (slot_item(EQ_WEAPON));

    return slot_item(EQ_SHIELD);

    return (slot_item(EQ_SHIELD));

bool monster_can_hit_monster(monsters *monster, const monsters *targ);

}
// Given an adjacent monster, returns true if the monster can hit it
// (the monster should not be submerged, be submerged in shallow water
// if the monster has a polearm, or be submerged in anything if the
// monster has tentacles).
bool monster_can_hit_monster(monsters *monster, const monsters *targ)
{
    if (!mons_is_submerged(targ))
        return (true);
    if (grd(targ->pos()) == DNGN_SHALLOW_WATER)
    {
        item_def *weapon = monster->weapon();
        return (weapon && weapon_skill(*weapon) == SK_POLEARMS);
    }
    return (monster->has_damage_type(DVORP_TENTACLE));

            // FIXME: looks like the lack of a check on 'submerged' here
            // is the reason monsters can attack submerged monsters they
            // happen to walk into. -cao

                && !mons_aligned(monster->mindex(), targ->mindex()))

                && !mons_aligned(monster->mindex(), targ->mindex())
                && monster_can_hit_monster(monster, targ))

    // Even/odd attacks use main/offhand weapon

    // Even/odd attacks use main/offhand weapon.

    return mslot_item(equip_slot_to_mslot(eq));

    return (mslot_item(equip_slot_to_mslot(eq)));

bool monsters::has_damage_type(int dam_type)
{
    for (int i = 0; i < 4; ++i)
    {
        const int dmg_type = damage_type(i);
        if (dmg_type == dam_type)
            return (true);
    }
    return (false);
}

    int       damage_brand(int attk = -1);
    int       damage_type(int attk = -1);

    int       damage_brand(int which_attack = -1);
    int       damage_type(int which_attack = -1);

    int       damage_brand(int attk = -1);
    int       damage_type(int attk = -1);

    int       damage_brand(int which_attack = -1);
    int       damage_type(int which_attack = -1);

    bool has_damage_type(int dam_type);