// When moving the mouse via cursor when targeting update more often.
    // For beams, the beam drawing already handles this, and when not targeting
    // the normal drawing routines handle it.

    // When moving the mouse via cursor when targetting update more often.
    // For beams, the beam drawing already handles this, and when not
    // targetting the normal drawing routines handle it.

                      targeting_type restrict = DIR_NONE,

                      targetting_type restrict = DIR_NONE,

        if (data.flags & SPFLAG_TARGETING_MASK)

        if (data.flags & SPFLAG_TARGETTING_MASK)

    if (flags & SPFLAG_TARGETING_MASK)

    if (flags & SPFLAG_TARGETTING_MASK)

                      targeting_type restrict, targ_mode_type mode,

                      targetting_type restrict, targ_mode_type mode,

    SPFLAG_DIR_OR_TARGET        = 0x00001,      // use DIR_NONE targeting
    SPFLAG_TARGET               = 0x00002,      // use DIR_TARGET targeting
    SPFLAG_GRID                 = 0x00004,      // use DIR_GRID targeting
    SPFLAG_DIR                  = 0x00008,      // use DIR_DIR targeting
    SPFLAG_TARGETING_MASK       = 0x0000f,      // used to test for targeting

    SPFLAG_DIR_OR_TARGET        = 0x00001,      // use DIR_NONE targetting
    SPFLAG_TARGET               = 0x00002,      // use DIR_TARGET targetting
    SPFLAG_GRID                 = 0x00004,      // use DIR_GRID targetting
    SPFLAG_DIR                  = 0x00008,      // use DIR_DIR targetting
    SPFLAG_TARGETTING_MASK      = 0x0000f,      // used to test for targetting

    // XXX: This handles only some of the cases where spells need targeting...

    // XXX: This handles only some of the cases where spells need targetting...

    if ((flags & SPFLAG_TARGETING_MASK) && spell != SPELL_PORTAL_PROJECTILE)

    if ((flags & SPFLAG_TARGETTING_MASK) && spell != SPELL_PORTAL_PROJECTILE)

        targeting_type dir  =

        targetting_type dir  =

    // Note that self-targeting is handled by SPFLAG_NOT_SELF.

    // Note that self-targetting is handled by SPFLAG_NOT_SELF.

        // for targeting

        // for targetting

    ASSERT(!(flags & SPFLAG_TARGETING_MASK) || in_bounds(pbolt.target));

    ASSERT(!(flags & SPFLAG_TARGETTING_MASK) || in_bounds(pbolt.target));

    const bool targeted = (flags & SPFLAG_TARGETING_MASK)

    const bool targeted = (flags & SPFLAG_TARGETTING_MASK)

    // if they're targeting themselves.

    // if they're targetting themselves.

        // not targeting the player in arena mode.

        // not targetting the player in arena mode.

    &Keymaps[KMC_TARGETING],

    &Keymaps[KMC_TARGETTING],

        keymc  = KMC_TARGETING;

        keymc  = KMC_TARGETTING;

         keymap ? (keymc == KMC_DEFAULT   ? "default " :
                   keymc == KMC_LEVELMAP  ? "level-map " :
                   keymc == KMC_TARGETING ? "targeting " :
                   keymc == KMC_CONFIRM   ? "confirm " :
                   keymc == KMC_MENU      ? "menu "
                                          : "buggy") : "",

         keymap ? (keymc == KMC_DEFAULT    ? "default " :
                   keymc == KMC_LEVELMAP   ? "level-map " :
                   keymc == KMC_TARGETTING ? "targetting " :
                   keymc == KMC_CONFIRM    ? "confirm " :
                   keymc == KMC_MENU       ? "menu "
                                           : "buggy") : "",

        return KMC_TARGETING;

        return KMC_TARGETTING;

class fire_target_behaviour : public targeting_behaviour

class fire_target_behaviour : public targetting_behaviour

    // targeting_behaviour API

    // targetting_behaviour API

        show_targeting_help();

        show_targetting_help();

    return targeting_behaviour::get_command(key);

    return targetting_behaviour::get_command(key);

    // Unless the character knows the type of the wand, the targeting

    // Unless the character knows the type of the wand, the targetting

    "wild_magic", "xom", "statue", "rotting", "targeting", "spore",

    "wild_magic", "xom", "statue", "rotting", "targetting", "spore",

        desc += terse? "shot self" : "Killed themselves with bad targeting";

        desc += terse? "shot self" : "Killed themselves with bad targetting";

            desc += "suicidal targeting";

            desc += "suicidal targetting";

    bool        show_beam;       // Show targeting beam by default.

    bool        show_beam;       // Show targetting beam by default.

    bool        default_target;  // start targeting on a real target

    bool        default_target;  // start targetting on a real target

    int         target_range; // for whether targeting is out of range

    int         target_range; // for whether targetting is out of range

    bool        target_zero_exp;    // If true, targeting targets zero-exp

    bool        target_zero_exp;    // If true, targetting targets zero-exp

    // targeting commands

    // targetting commands

    KMC_TARGETING,       // Only during 'x' and other targeting modes

    KMC_TARGETTING,      // Only during 'x' and other targetting modes

enum targeting_type

enum targetting_type

    DIR_TARGET_OBJECT // New as of 27-August-2009, for item-targeting spells

    DIR_TARGET_OBJECT // New as of 27-August-2009, for item-targetting spells

class targeting_behaviour

class targetting_behaviour

    targeting_behaviour(bool just_looking = false);
    virtual ~targeting_behaviour();

    targetting_behaviour(bool just_looking = false);
    virtual ~targetting_behaviour();

void direction( dist &moves, targeting_type restricts = DIR_NONE,

void direction( dist &moves, targetting_type restricts = DIR_NONE,

                const char *prompt = NULL, targeting_behaviour *mod = NULL,

                const char *prompt = NULL, targetting_behaviour *mod = NULL,

static int  _targeting_cmd_to_compass( command_type command );

static int  _targetting_cmd_to_compass( command_type command );

void direction_choose_compass( dist& moves, targeting_behaviour *beh)

void direction_choose_compass( dist& moves, targetting_behaviour *beh)

        const int i = _targeting_cmd_to_compass(key_command);

        const int i = _targetting_cmd_to_compass(key_command);

static int _targeting_cmd_to_compass( command_type command )

static int _targetting_cmd_to_compass( command_type command )

static int _targeting_cmd_to_feature( command_type command )

static int _targetting_cmd_to_feature( command_type command )

// We handle targeting for repeating commands and re-doing the

// We handle targetting for repeating commands and re-doing the

static void _direction_again(dist& moves, targeting_type restricts,

static void _direction_again(dist& moves, targetting_type restricts,

                             const char *prompt, targeting_behaviour *beh)

                             const char *prompt, targetting_behaviour *beh)

void direction(dist& moves, targeting_type restricts,

void direction(dist& moves, targetting_type restricts,

               targeting_behaviour *beh, bool cancel_at_self)

               targetting_behaviour *beh, bool cancel_at_self)

        static targeting_behaviour stock_behaviour;

        static targetting_behaviour stock_behaviour;

            i = _targeting_cmd_to_compass(key_command);

            i = _targetting_cmd_to_compass(key_command);

            i = _targeting_cmd_to_compass(key_command);

            i = _targetting_cmd_to_compass(key_command);

            const int thing_to_find = _targeting_cmd_to_feature(key_command);

            const int thing_to_find = _targetting_cmd_to_feature(key_command);

            mprf("Targeting mode is now: %s",

            mprf("targetting mode is now: %s",

            show_targeting_help();

            show_targetting_help();

// targeting_behaviour

// targetting_behaviour

targeting_behaviour::targeting_behaviour(bool look_around)

targetting_behaviour::targetting_behaviour(bool look_around)

targeting_behaviour::~targeting_behaviour()

targetting_behaviour::~targetting_behaviour()

int targeting_behaviour::get_key()

int targetting_behaviour::get_key()

    return unmangle_direction_keys(getchm(KMC_TARGETING), KMC_TARGETING,

    return unmangle_direction_keys(getchm(KMC_TARGETTING), KMC_TARGETTING,

command_type targeting_behaviour::get_command(int key)

command_type targetting_behaviour::get_command(int key)

    command_type cmd = key_to_command(key, KMC_TARGETING);

    command_type cmd = key_to_command(key, KMC_TARGETTING);

bool targeting_behaviour::should_redraw()

bool targetting_behaviour::should_redraw()

void targeting_behaviour::mark_ammo_nonchosen()

void targetting_behaviour::mark_ammo_nonchosen()

void show_targeting_help();

void show_targetting_help();

static const char *targeting_help_1 =

static const char *targetting_help_1 =

    "<w>Ctrl-F</w> : change monster targeting mode\n"

    "<w>Ctrl-F</w> : change monster targetting mode\n"

    "<w>Ctrl-L</w> : toggle targeting via monster list\n"

    "<w>Ctrl-L</w> : toggle targetting via monster list\n"

    "<h>Targeting (zapping wands, casting spells, etc.):\n"

    "<h>targetting (zapping wands, casting spells, etc.):\n"

    "<h>Wizard targeting commands:</h>\n"

    "<h>Wizard targetting commands:</h>\n"

static const char *targeting_help_2 =

static const char *targetting_help_2 =

            "<w>I</w>.      Targeting\n"

            "<w>I</w>.      targetting\n"

void show_targeting_help()

void show_targetting_help()

    cols.add_formatted(0, targeting_help_1, true, true);
    cols.add_formatted(1, targeting_help_2, true, true);

    cols.add_formatted(0, targetting_help_1, true, true);
    cols.add_formatted(1, targetting_help_2, true, true);

            "form of targeting), <w>Ctrl-G</w> or <w>G</w>, and \n"

            "form of targetting), <w>Ctrl-G</w> or <w>G</w>, and \n"

            "<h>Targeting (for spells and missiles)\n"

            "<h>targetting (for spells and missiles)\n"