cursor_control con(true);

    cursor_control ccon(!Options.use_fake_cursor);

        gotoxy(curs_x, curs_y + top - 1);

        cursorxy(curs_x, curs_y + top - 1);

            gotoxy( 2, 1 );

            gotoxy( 1, 1 );

                gotoxy( 2, count_y + 2 );

                gotoxy( 1, count_y + 2 );

void cursorxy(int x, int y);

        // This function is const because compiled_pattern is not really part of
        // the state of the object.
        
        void *&cp = const_cast<text_pattern*>( this )->compiled_pattern;

            !!(cp = compile_pattern(pattern.c_str(), ignore_case))

            !!(compiled_pattern = compile_pattern(pattern.c_str(), ignore_case))

            (compiled_pattern ||
                (const_cast<text_pattern*>( this )->isvalid = compile()));

            (compiled_pattern || (isvalid = compile()));

    void *compiled_pattern;
    bool isvalid;

    mutable void *compiled_pattern;
    mutable bool isvalid;

    int match = strcspn(file, "`$*?|><&\n");

    int match = strcspn(file, "\\`$*?|><&\n!");

#endif
}
// Wrapper around gotoxy that can draw a fake cursor for Unix terms where
// cursoring over darkgray or black causes problems.
void cursorxy(int x, int y)
{
#ifdef UNIX
    if (Options.use_fake_cursor)
        fakecursorxy(x, y);
    else
        gotoxy(x, y);
#else
    gotoxy(x, y);

void fakecursorxy(int x, int y);

static unsigned oldch, oldmangledch;
static int faked_x = -1, faked_y;
void fakecursorxy(int x, int y)
{
    if (oldch && faked_x != -1
        && mvinch(faked_y, faked_x) == oldmangledch)
    {
        if (faked_x != x - 1 || faked_y != y - 1)
            mvaddch(faked_y, faked_x, oldch);
        else
            return;
    }
    
    const unsigned c      = mvinch(y - 1, x - 1);
    const int ch          = c & A_CHARTEXT;
    const unsigned colour = c & A_COLOR;
    const int pair        = PAIR_NUMBER(colour);

    faked_x = x - 1;
    faked_y = y - 1;
    oldch   = c;
    int fg     = pair & 7;
    int bg     = (pair >> 3) & 7;

    if (pair == 63)
    {
        fg    = COLOR_WHITE;
        bg    = COLOR_BLACK;
    }
    const int newpair = (fg * 8 + bg);
    
    mvaddch( y - 1, x - 1,  oldmangledch = ((ch & 127) | COLOR_PAIR(newpair)) );
    move(y - 1, x - 1);
}

    use_fake_cursor        = false;

    else if (key == "use_fake_cursor")
    {
        use_fake_cursor = read_bool(field, use_fake_cursor);
    }

        if (def->mons_species() == MONS_ORC)

        if (defender->mons_species() == MONS_ORC)

    
    bool        use_fake_cursor;    // Draw a fake cursor instead of relying
                                    // on the term's own cursor.

    cursor_control con(!Options.use_fake_cursor);
    

        // I'm sure there's a perfectly good reason for the +1.
        gotoxy( grid2viewX(moves.tx) + 1, grid2viewY(moves.ty) );

        cursorxy( grid2viewX(moves.tx), grid2viewY(moves.ty) );

        if ( !in_bounds(moves.tx, moves.ty) )

        if ( !in_viewport_bounds(grid2viewX(moves.tx), grid2viewY(moves.ty)) )

    mpr("You can't see that place.");
    

    gotoxy(18,9);

    gotoxy(VIEW_CX, VIEW_CY);

# target_zero_exp = false

# target_zero_exp = true

# target_unshifted_dirs = true

##### 6-c   Unix ##################################
#
# use_fake_cursor = true

                confirm_self_target, default_target

                confirm_self_target, default_target,
                target_unshifted_dirs

                background

                background, use_fake_cursor

target_unshifted_dirs = false
        If set to true, targeting will use the old Stone Soup 0.1 / Crawl 4.0
        targeting keymap where unshifted direction keys fire in that direction
        immediately. The default is to use the new targeting keymap where
        unshifted direction keys move the targeting cursor (and shifted
        directions fire in the given direction immediately).

use_fake_cursor = false
        If true, Crawl draws the cursor explicitly on the level-map and
        targeting screens instead of relying on the term to draw the cursor.
        Use this if your term cannot show a cursor over darkgrey/black
        squares.