}                               // end player_genus()

}

        // unique monsters

        // Unique monsters.

        // compare with monster *species*

        // Compare with monster *species*.

        // compare with monster *genus*

        // Compare with monster *genus*.

            return (mons_genus(mon) == MONS_DRAGON); // includes all drakes

            return (mons_genus(mon) == MONS_DRAGON); // Includes all drakes.

            break; // check real (non-transformed) form

            break; // Check real (non-transformed) form.

        case SP_GHOUL: // genus would include necrophage and rotting hulk

        case SP_GHOUL: // Genus would include necrophage and rotting hulk.

   // not a transformation, but also temporary -> check first
   if (check_mutation)
   {
       if (eq == EQ_GLOVES && you.has_claws(false) >= 3)
           return false;

    // Not a transformation, but also temporary -> check first.
    if (check_mutation)
    {
        if (eq == EQ_GLOVES && you.has_claws(false) >= 3)
            return (false);

       if (eq == EQ_BOOTS
           && ( player_is_swimming() && you.species == SP_MERFOLK

        if (eq == EQ_BOOTS
            && (player_is_swimming() && you.species == SP_MERFOLK

                || player_mutation_level(MUT_TALONS) ))
       {
           return false;
       }
   }

                || player_mutation_level(MUT_TALONS)))
        {
            return (false);
        }
    }

   int transform = you.attribute[ATTR_TRANSFORMATION];

    int transform = you.attribute[ATTR_TRANSFORMATION];

   // no further restrictions
   if (transform == TRAN_NONE || transform == TRAN_LICH)
       return true;

    // No further restrictions.
    if (transform == TRAN_NONE || transform == TRAN_LICH)
        return (true);

   // bats cannot use anything, clouds obviously so
   if (transform == TRAN_BAT || transform == TRAN_AIR)
       return false;

    // Bats cannot use anything, clouds obviously so.
    if (transform == TRAN_BAT || transform == TRAN_AIR)
        return (false);

   // everyone else can wear jewellery, at least
   if (eq == EQ_LEFT_RING || eq == EQ_RIGHT_RING || eq == EQ_AMULET)
       return true;

    // Everyone else can wear jewellery, at least.
    if (eq == EQ_LEFT_RING || eq == EQ_RIGHT_RING || eq == EQ_AMULET)
        return (true);

   // these cannot use anything but jewellery
   if (transform == TRAN_SPIDER || transform == TRAN_DRAGON
       || transform == TRAN_SERPENT_OF_HELL)
   {
       return false;
   }

    // These cannot use anything but jewellery.
    if (transform == TRAN_SPIDER || transform == TRAN_DRAGON
        || transform == TRAN_SERPENT_OF_HELL)
    {
        return (false);
    }

   if (transform == TRAN_BLADE_HANDS)
   {
       if (eq == EQ_WEAPON || eq == EQ_GLOVES || eq == EQ_SHIELD)
           return false;
       return true;
   }

    if (transform == TRAN_BLADE_HANDS)
    {
        if (eq == EQ_WEAPON || eq == EQ_GLOVES || eq == EQ_SHIELD)
            return (false);
        return (true);
    }

   if (transform == TRAN_ICE_BEAST)
   {
       if (eq != EQ_CLOAK)
       {
           return false;
       }
       return true;
   }

    if (transform == TRAN_ICE_BEAST)
    {
        if (eq != EQ_CLOAK)
            return (false);
        return (true);
    }

   if (transform == TRAN_STATUE)
   {
       if (eq == EQ_BODY_ARMOUR || eq == EQ_GLOVES || eq == EQ_SHIELD)
           return false;
       return true;
   }

    if (transform == TRAN_STATUE)
    {
        if (eq == EQ_BODY_ARMOUR || eq == EQ_GLOVES || eq == EQ_SHIELD)
            return (false);
        return (true);
    }

   return true;

    return (true);

    /* rings */

    // rings

    /* mutations */

    // mutations

    /* randart weapons only */

    // randart weapons only

}                               // end player_teleport()

}

    // ghouls heal slowly
    // dematerialised people heal slowly
    // dematerialised ghouls shouldn't heal any more slowly -- bwr

    // Ghouls heal slowly.
    // Dematerialised people heal slowly.
    // Dematerialised ghouls shouldn't heal any more slowly. -- bwr

    // healing depending on satiation

    // Healing depending on satiation.

                return (0); // no regeneration for starving vampires!

                return (0); // No regeneration for starving vampires!

    // moved here from acr.cc... maintaining the >= 40 behaviour

    // Moved here from acr.cc... maintaining the >= 40 behaviour.

        // berserk has its own food penalty -- excluding berserk haste

        // Berserk has its own food penalty -- excluding berserk haste.

        /* transformations */

        // transformations

        /* armour */

        // armour

        // in the air, can fly fast (should be lightly burdened).

        // In the air, can fly fast (should be lightly burdened).

        return true;

        return (true);

        return true;

        return (true);

        // this is hackish {dlb}

        // XXX: this is hackish {dlb}

            return true;

            return (true);

        return false;

        return (false);

        return true;

        return (true);

    return false;
}                               // end wearing_amulet()

    return (false);
}

            if (you.species == SP_VAMPIRE && one_chance_in(5))

            if (you.species == SP_VAMPIRE && one_chance_in(8))

    if (attribute[ATTR_TRANSFORMATION] == TRAN_DRAGON ||
        attribute[ATTR_TRANSFORMATION] == TRAN_BAT)

    if (attribute[ATTR_TRANSFORMATION] == TRAN_DRAGON
        || attribute[ATTR_TRANSFORMATION] == TRAN_BAT)

// really important extern -- screen redraws suck w/o it {dlb}

// Really important extern -- screen redraws suck w/o it! {dlb}

// macro that saves some typing, nothing more

// Macro that saves some typing, nothing more.

                // keep previous entry

                // Leep previous entry.

        // we prefer prefixes over partial matches

        // We prefer prefixes over partial matches.

    //unsigned int x = 0;    // must be unsigned to match size_t {dlb}
    // first, fill static array with dummy values {dlb};

    // First, fill static array with dummy values. {dlb}

    // next, fill static array with location of entry in mondata[] {dlb}:

    // Next, fill static array with location of entry in mondata[]. {dlb}:

    // finally, monsters yet with dummy entries point to TTTSNB(tm) {dlb}:

    // Finally, monsters yet with dummy entries point to TTTSNB(tm). {dlb}:

}                               // end mons_init()

}

// Returns true if a given monster is an abomination
// created by Twisted Resurrection

// Returns true if a given monster is an abomination created by
// Twisted Resurrection.

        return (mons_species(monster->type) == MONS_DRACONIAN);

        return (mons_species(monster->type) == MONS_DRACONIAN
                || monster->type == MONS_ORB_GUARDIAN);

    // Not every demonic monster is a demon (hell hog, hell hound, etc.).

    // Not every demonic monster is a demon (hell hog, hell hound, etc.)

    // these are cumulative, of course: {dlb}

    // These are cumulative, of course: {dlb}

}                               // end mons_damage()

}

}                               // end mon_resist_magic()

}

}                               // end check_mons_resist_magic()

}

        // no ego armour, but storm dragon.

        // No ego armour, but storm dragon.

}                               // end mons_res_elec()

}

}                               // end mons_res_poison()

}

}                               // end mons_res_fire()

}

}                               // end mons_res_cold()

}

             // && !mon->has_ench(ENCH_PETRIFY));

    // these three are the original arguments:

    // These three are the original arguments.

    // these are some values we care about:

    // These are some values we care about.

    // XXX: shapeshifters can qualify here, even though they can't cast:

    // XXX: Shapeshifters can qualify here, even though they can't cast.

    // early out for no XP monsters

    // Early out for no XP monsters.

    // Let's calculate a simple difficulty modifier -- bwr

    // Let's calculate a simple difficulty modifier. -- bwr

    // Let's look for big spells:

    // Let's look for big spells.

    // let's look at regeneration

    // Let's look at regeneration.

    // Monsters at normal or fast speed with big melee damage

    // Monsters at normal or fast speed with big melee damage.

    // Currently 70% - 200% -- bwr

    // Currently 70% - 200%. -- bwr

    // Apply difficulty

    // Apply difficulty.

    // Basic speed modification

    // Basic speed modification.

    // Apply the modifier in the monster's definition

    // Apply the modifier in the monster's definition.

    // guarantee the value is within limits

    // Guarantee the value is within limits.

// generate a shiny new and unscarred monster

// Generate a shiny new and unscarred monster.

    int mcls = mons.type;

    int mcls                  = mons.type;

    int monnumber = mons.number;
    monster_type monbase = mons.base_monster;
    const monsterentry *m = get_monster_data(mcls);
    int col = mons_class_colour(mons.type);

    int monnumber             = mons.number;
    monster_type monbase      = mons.base_monster;
    const monsterentry *m     = get_monster_data(mcls);
    int col                   = mons_class_colour(mons.type);

        if (col != BLACK) // maybe overwritten by the mon_glyph option

        if (col != BLACK) // May be overwritten by the mon_glyph option.

        if (col != BLACK) // maybe overwritten by the mon_glyph option

        if (col != BLACK) // May be overwritten by the mon_glyph option.

        // these are supposed to only be created by polymorph

        // These are supposed to only be created by polymorph.

        {

        }

        // these are supposed to only be created by polymorph

        // These are supposed to only be created by polymorph.

    // some calculations

    // Some calculations.

    // so let it be written, so let it be done
    mons.hit_dice = hd;
    mons.hit_points = hp;
    mons.max_hit_points = hp_max;
    mons.ac = ac;
    mons.ev = ev;
    mons.speed = speed;

    // So let it be written, so let it be done.
    mons.hit_dice        = hd;
    mons.hit_points      = hp;
    mons.max_hit_points  = hp_max;
    mons.ac              = ac;
    mons.ev              = ev;
    mons.speed           = speed;

    // reset monster enchantments

    // Reset monster enchantments.

    // Handle non-visible case first

    // Handle non-visible case first.

    // Vowel fix: Change 'a orc' to 'an orc'

    // Vowel fix: Change 'a orc' to 'an orc'.

// Fills the number parameter (if not otherwise needed) with a seed for
// random name choice from randname.txt.

// Names a previously unnamed monster.

    // already has a unique name

    // Already has a unique name.

// see mons_init for initialization of mon_entry array.

// See mons_init for initialization of mon_entry array.

    // for now, just return monster hit dice.

    // For now, just return monster hit dice.

    // use of foeRatio:
    // The higher this number, the more monsters will _avoid_
    // collateral damage to their friends.
    // Setting this to zero will in fact have all monsters ignore
    // their friends when considering collateral damage.

    // Use of foeRatio:
    // The higher this number, the more monsters will _avoid_ collateral
    // damage to their friends.
    // Setting this to zero will in fact have all monsters ignore their
    // friends when considering collateral damage.

    // only fire if they do acceptably low collateral damage

    // Only fire if they do acceptably low collateral damage.

// you had a friendly target..  only returns a meaningful value for

// you had a friendly target...  only returns a meaningful value for

// spells for a quick get-away
// currently only used to get out of a net

// Spells for a quick get-away.
// Currently only used to get out of a net.

// use of variant:

// Use of variant:

        case PRONOUN_REFLEXIVE:  // awkward at start of sentence, always lower

        case PRONOUN_REFLEXIVE:  // Awkward at start of sentence, always lower.

            || m->type == MONS_ROTTING_DEVIL
            || m->type == MONS_CURSE_TOE)

        || m->type == MONS_ROTTING_DEVIL
        || m->type == MONS_CURSE_TOE)
    {

    }

            && (m2->type == MONS_KILLER_BEE
                    || m2->type == MONS_KILLER_BEE_LARVA))

        && (m2->type == MONS_KILLER_BEE
            || m2->type == MONS_KILLER_BEE_LARVA))
    {

    }

    // Special-case gnolls so they can't get past (hob)goblins

    // Special-case gnolls, so they can't get past (hob)goblins.

    // no fitting launcher in inventory

    // No fitting launcher in inventory.

        return false;

        return (false);

        // monster may not pick up trapping net

        // Monster may not pick up trapping net.

    // limited growth factor here -- should 77 really be the cap? {dlb}:

    // Limited growth factor here -- should 77 really be the cap? {dlb}:

            return false;

            return (false);

                return false;

                return (false);

                return false;

                return (false);

                return false;

                return (false);

                return false;

                return (false);

                    return false;

                    return (false);

                    return false;

                    return (false);

        // Item was cursed

        // Item was cursed.

        del_ench(ENCH_SLOW, true); // give no additional message

        del_ench(ENCH_SLOW, true); // Give no additional message.

    del_ench(ENCH_FATIGUE, true); // give no additional message

    del_ench(ENCH_FATIGUE, true); // Give no additional message.

    // Don't make greased-lightning Pandemonium demons in the dungeon (max
    // speed = 17). Demons in Pandemonium can be up to speed 24.

    // Don't make greased-lightning Pandemonium demons in the dungeon
    // max speed = 17). Demons in Pandemonium can be up to speed 24.

                || you.level_type == LEVEL_DUNGEON && hit_dice > 8 + random2(25))

                || you.level_type == LEVEL_DUNGEON
                   && hit_dice > 8 + random2(25))

    // check for slow/haste

    // Check for slow/haste.

        // reevaluate behaviour

        // Reevaluate behaviour.

        // just for flavour

        // Just for flavour.

// used to adjust time durations in calc_duration() for monster speed

// Used to adjust time durations in calc_duration() for monster speed.

        // handled in handle_pickup

        // Handled in handle_pickup.

            // confused monsters more likely to struggle without result

            // Confused monsters more likely to struggle without result.

            // nets get destroyed more quickly for larger monsters
            // and if already strongly frayed

            // Nets get destroyed more quickly for larger monsters
            // and if already strongly frayed.

            // handled specially to make up for its small size

            // Handled specially to make up for its small size.

            // extra damage for large (50%) and big (always)

            // Extra damage for large (50%) and big (always).

            // berserking doubles damage dealt

            // Berserking doubles damage dealt.

    case ENCH_GLOWING_SHAPESHIFTER:     // this ench never runs out
        // number of actions is fine for shapeshifters

    case ENCH_GLOWING_SHAPESHIFTER:     // This ench never runs out!
        // Number of actions is fine for shapeshifters.

    case ENCH_SHAPESHIFTER:     // this ench never runs out

    case ENCH_SHAPESHIFTER:     // This ench never runs out!

    // clear old cell pointer

    // Clear old cell pointer.

    // set monster x,y to new value

    // Set monster x,y to new value.

// replaces @player_god@ and @god_is@ with player's god name
// special handling for atheists: use "you"/"You" instead

// Replaces @player_god@ and @god_is@ with player's god name
// special handling for atheists: use "you"/"You" instead.

    // get species genus

    // Get species genus.

    if (insult.empty()) // species too specific?

    if (insult.empty()) // Species too specific?

    // no verb needed

    // No verb needed,

    // this conditional can later be merged into food::can_ingest() when

    // This conditional can later be merged into food::can_ingest() when

// [ds] Returns true if something was eaten

// [ds] Returns true if something was eaten.

        // Decrease healing when done in bat form.
        if (you.attribute[ATTR_TRANSFORMATION] == TRAN_BAT)
            heal /= 2;

        inc_hp(heal, false);
        mprf("You feel %sbetter.", (you.hp == you.hp_max) ? "much " : "");

        if (heal > 0)
        {
            inc_hp(heal, false);
            mprf("You feel %sbetter.", (you.hp == you.hp_max) ? "much " : "");
        }

        // Bats get a little less nutrition out of it

        // Bats get a rather less nutrition out of it.

            food_value -= 5 + random2(16);

            food_value /= 2;

        // thirsty stabbing vampires get to draw blood

        // Thirsty stabbing vampires get to draw blood.

            // call function of orcs first noticing you but with
            // beaten-up conversion messages (if applicable)

            // Call function of orcs first noticing you, but with
            // beaten-up conversion messages (if applicable).

        // normal vampiric biting attack, not if already got stabbing special

        // Normal vampiric biting attack, not if already got stabbing special.

            // more than if not killed

            // More than if not killed.

            damage = (you.species == SP_VAMPIRE ? 2 : 1);

            damage = (you.species == SP_VAMPIRE ? 1 : coinflip());