const unsigned int ticks_per_redraw = 100;

    // 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.
    const unsigned int ticks_per_redraw
        = (mouse_control::current_mode() == MOUSE_MODE_TARGET ? 50 : 100);

    TILEP_GENDER_MALE   = 0,
    TILEP_GENDER_FEMALE = 1,

    TILEP_GENDER_FEMALE = 0,
    TILEP_GENDER_MALE   = 1,

#define NUM_MAX_DOLLS   10

static void _load_doll_data(const char *fn, dolls_data *doll)

static void _load_doll_data(const char *fn, dolls_data *dolls, int max)

        // Don't take gender too seriously.  -- Enne
        tilep_race_default(you.species, coinflip(),
                           you.experience_level, doll->parts);

        // Sanity, in case this hasn't been done before.
        for (unsigned int i = 0; i < TILEP_PART_MAX; ++i)
            dolls[0].parts[i] = TILEP_SHOW_EQUIP;

#if 0
        // For some reason I can't reset this although it's used identically
        // elsewhere. (jpeg)
        for (unsigned int j = 0; j < TILEP_PART_MAX; ++j)
            doll->parts[j] = TILEP_SHOW_EQUIP;
#endif

        // Don't take gender too seriously.  -- Enne
        tilep_race_default(you.species, gender,
                           you.experience_level, dolls[0].parts);

            if (strcmp(fbuf, "MODE=DEFAULT") == 0)

            if (max == 1 && strcmp(fbuf, "MODE=DEFAULT") == 0)

                tilep_job_default(you.char_class, gender, doll->parts);

                tilep_job_default(you.char_class, gender, dolls[0].parts);

            if (strncmp(fbuf, "NUM=", 4) == 0)

            if (max == 1 && strncmp(fbuf, "NUM=", 4) == 0)

                if (cur < 0 || cur > 10)

                if (cur < 0 || cur >= NUM_MAX_DOLLS)

        int count = 0;
        while (fscanf(fp, "%s", fbuf) != EOF)

        if (max == 1) // Load only one doll, namely no. cur.

            if (cur == count++)

            int count = 0;
            while (fscanf(fp, "%s", fbuf) != EOF)
            {
                if (cur == count++)
                {
                    tilep_scan_parts(fbuf, dolls[0].parts);
                    gender = dolls[0].parts[TILEP_PART_BASE] % 2;
                    break;
                }
            }
            if (cur >= count)

                tilep_scan_parts(fbuf, doll->parts);
                gender = doll->parts[TILEP_PART_BASE] % 2;
                break;

                mprf(MSGCH_WARN, "Doll %d could not be found in '%s'.",
                                 cur, dollsTxt);

        if (cur >= count)

        else // Load up to max dolls from file.

            mprf(MSGCH_WARN, "Doll %d could not be found in '%s'.",
                             cur, dollsTxt);

            for (int count = 0; count < max && fscanf(fp, "%s", fbuf) != EOF;
                 ++count)
            {
                tilep_scan_parts(fbuf, dolls[count].parts);
            }

    dolls_data default_doll;

    dolls_data default_doll[1];

        default_doll.parts[i] = TILEP_SHOW_EQUIP;
    mpr("loaded equipment");
    _load_doll_data("dolls.txt", &default_doll);

        default_doll[0].parts[i] = TILEP_SHOW_EQUIP;

    _load_doll_data("dolls.txt", default_doll, 1);

                       default_doll.parts);

                       default_doll[0].parts);
    player_doll = default_doll[0];
}
static int _get_random_doll_part(int p)
{
    ASSERT(p >= 0 && p <= TILEP_PART_MAX);
    return (tile_player_part_start[p]
            + random2(tile_player_part_count[p]));
}
static void _fill_doll_part(dolls_data &doll, int p)
{
    ASSERT(p >= 0 && p <= TILEP_PART_MAX);
    doll.parts[p] = _get_random_doll_part(p);
}
static void _create_random_doll(dolls_data &rdoll)
{
    // All dolls roll for these.
    _fill_doll_part(rdoll, TILEP_PART_BODY);
    _fill_doll_part(rdoll, TILEP_PART_HAND1);
    _fill_doll_part(rdoll, TILEP_PART_LEG);
    _fill_doll_part(rdoll, TILEP_PART_BOOTS);
    _fill_doll_part(rdoll, TILEP_PART_HAIR);
    // The following only are rolled with 50% chance.
    if (coinflip())
        _fill_doll_part(rdoll, TILEP_PART_CLOAK);
    if (coinflip())
        _fill_doll_part(rdoll, TILEP_PART_ARM);
    if (coinflip())
        _fill_doll_part(rdoll, TILEP_PART_HAND2);
    if (coinflip())
        _fill_doll_part(rdoll, TILEP_PART_HELM);

    player_doll = default_doll;

    // Only male dolls get a chance at a beard.
    if (rdoll.parts[TILEP_PART_BASE] % 2 == 1 && one_chance_in(4))
        _fill_doll_part(rdoll, TILEP_PART_BEARD);

    mpr("Pick (d)efault doll for job, use (e)quipment settings, or (l)oad "
        "from file?");
    char ch = (char) getchm(KMC_DEFAULT);
         ch = tolower(ch);

    dolls_data equip_doll;

    dolls_data dolls[NUM_MAX_DOLLS];

         default_doll.parts[i] = TILEP_SHOW_EQUIP;

         equip_doll.parts[i] = TILEP_SHOW_EQUIP;

                       you.experience_level, default_doll.parts);

                       you.experience_level, equip_doll.parts);

    mpr("loaded equipment");
    if (ch == 'd')

    bool done_default = false;
    bool loaded       = false;
    char old_ch       = 'x'; // for saving current doll (d/e) into file
    while (true)

        tilep_job_default(you.char_class, gender, default_doll.parts);
    }
    else if (ch == 'e')
    {
        // nothing to be done
    }
    else if (ch == 'l')
    {
        _load_doll_data("dolls.txt", &default_doll);
    }
    else
        return;

        mpr("Pick (d)efault doll for job, use (e)quipment settings, roll a "
            "(r)andom doll, or load doll (0-9) from file?", MSGCH_PROMPT);
        char ch = (char) getchm(KMC_DEFAULT);
             ch = tolower(ch);
        bool finish = false;
        if (ch == 'd')
        {
            if (!done_default)
            {
                default_doll = equip_doll;
                tilep_job_default(you.char_class, gender, default_doll.parts);
                done_default = true;
            }
            player_doll = default_doll;
        }
        else if (ch == 'e')
        {
            player_doll = equip_doll;
            // nothing else to be done
        }
        else if (ch == 'r')
        {
            dolls_data random_doll = equip_doll;
            _create_random_doll(random_doll);
            player_doll = random_doll;
        }
        else if (ch == 's')
        {
            mpr("I'm sorry, you can't save your settings yet.");
            continue;
        }
        else if (ch >= '0' && ch <= '9')
        {
            // HACK until I can find the proper function.
            int num = ch - '0';
            ASSERT(num >= 0 && num <= 9);
            if (num < 0 || num >= NUM_MAX_DOLLS)
                finish = true;
            else
            {
                if (!loaded)
                {
                    for (unsigned int i = 0; i < NUM_MAX_DOLLS; ++i)
                        dolls[i] = equip_doll;
                    // This'll have to be replaced by "load doll 0..9".
                    _load_doll_data("dolls.txt", dolls, NUM_MAX_DOLLS);
                    loaded = true;
                }
                player_doll = dolls[num];
            }
        }
        else
            finish = true;
        mesclr();

    player_doll = default_doll;

        if (finish)
            break;

        old_ch = ch;
        viewwindow(true, false);
    }

void DungeonRegion::pack_player(int x, int y)

void _fill_doll_equipment(dolls_data &result)

    dolls_data result = player_doll;
    const bool halo = inside_halo(you.pos());
    result.parts[TILEP_PART_HALO] = halo ? TILEP_HALO_TSO : 0;
    result.parts[TILEP_PART_ENCH] =
        (you.duration[DUR_LIQUID_FLAMES] ? TILEP_ENCH_STICKY_FLAME : 0);

    // Main hand.

        int item = you.equip[EQ_WEAPON];

        const int item = you.equip[EQ_WEAPON];

    // Off hand.

        int item = you.equip[EQ_SHIELD];

        const int item = you.equip[EQ_SHIELD];

    // Body armour.

        int item = you.equip[EQ_BODY_ARMOUR];

        const int item = you.equip[EQ_BODY_ARMOUR];

    // Cloak.

        int item = you.equip[EQ_CLOAK];

        const int item = you.equip[EQ_CLOAK];

    // Helmet.

        int item = you.equip[EQ_HELMET];

        const int item = you.equip[EQ_HELMET];

    // Boots.

        int item = you.equip[EQ_BOOTS];

        const int item = you.equip[EQ_BOOTS];

    // Gloves.

        int item = you.equip[EQ_GLOVES];

        const int item = you.equip[EQ_GLOVES];

    // Various other slots.

}

void DungeonRegion::pack_player(int x, int y)
{
    dolls_data result = player_doll;
    const bool halo = inside_halo(you.pos());
    result.parts[TILEP_PART_HALO] = halo ? TILEP_HALO_TSO : 0;
    result.parts[TILEP_PART_ENCH] =
        (you.duration[DUR_LIQUID_FLAMES] ? TILEP_ENCH_STICKY_FLAME : 0);
    _fill_doll_equipment(result);

    if (parts[TILEP_PART_BASE] == TILEP_BASE_CENTAUR
        || parts[TILEP_PART_BASE] == TILEP_BASE_CENTAUR + 1)

    else if (parts[TILEP_PART_BASE] == TILEP_BASE_CENTAUR
             || parts[TILEP_PART_BASE] == TILEP_BASE_CENTAUR + 1)

    if (parts[TILEP_PART_BASE] == TILEP_BASE_MERFOLK_WATER
        || parts[TILEP_PART_BASE] == TILEP_BASE_MERFOLK_WATER + 1)

    else if (parts[TILEP_PART_BASE] == TILEP_BASE_MERFOLK_WATER
             || parts[TILEP_PART_BASE] == TILEP_BASE_MERFOLK_WATER + 1)

    else if (parts[TILEP_PART_BASE] >= TILEP_BASE_DRACONIAN
             && parts[TILEP_PART_BASE] <= TILEP_BASE_DRACONIAN_WHITE + 1)
    {
        flag[TILEP_PART_HAIR] = flag[TILEP_PART_HELM] = TILEP_FLAG_HIDE;
    }

#ifdef USE_TILE
    &Keymaps[KMC_TILE],
#endif

#if 0
#ifdef USE_TILE
    if (context != KMC_TILE && it == key_map.end())
    {
        context = KMC_TILE;
        key_map = _keys_to_cmds[KMC_TILE];
        it      = key_map.find(key);
    }
#endif
#endif

#if 0
#ifdef USE_TILE
    if (cmd >= CMD_MIN_TILE && cmd <= CMD_MAX_TILE)
        return KMC_TILE;
#endif
#endif

#ifdef USE_TILE
    KMC_TILE,            // For context_for_command()
#endif

static void draw_ray_glyph(const coord_def &pos, int colour,
                           int glych, int mcol, bool in_range)

#ifndef USE_TILE
static void _draw_ray_glyph(const coord_def &pos, int colour,
                            int glych, int mcol, bool in_range)

#ifdef USE_TILE
    tile_place_ray(pos, in_range);
#else

#endif

#endif

            show_beam = show_beam && find_ray(you.pos(), moves.target,
                                              true, ray, 0, true);

            show_beam  = show_beam && find_ray(you.pos(), moves.target,
                                               true, ray, 0, true);

        bool _draw_beam = find_ray(you.pos(), moves.target, true, ray, 0, true)
                          && show_beam && !_blocked_ray(moves.target);
        if (need_beam_redraw || _draw_beam)

        if (!need_beam_redraw)

#else

            need_beam_redraw = show_beam
                               && find_ray(you.pos(), moves.target, true, ray,
                                           0, true)
                               && !_blocked_ray(moves.target);
        }
#endif

#ifndef USE_TILE

#ifdef USE_TILE
                        tile_place_ray(raycopy.pos(), in_range);
#else

                        draw_ray_glyph(raycopy.pos(), bcol, '*',
                                       bcol | COLFLAG_REVERSE, in_range);

                        _draw_ray_glyph(raycopy.pos(), bcol, '*',
                                        bcol | COLFLAG_REVERSE, in_range);
#endif

                const bool in_range = (range < 0)
                    || grid_distance(raycopy.pos(), you.pos()) <= range;
                draw_ray_glyph(moves.target, MAGENTA, '*',
                               MAGENTA | COLFLAG_REVERSE, in_range);

                const bool in_range
                        = (range < 0
                           || grid_distance(raycopy.pos(), you.pos()) <= range);
                tile_place_ray(moves.target, in_range);
#endif

#ifdef USE_TILE

#else
            }

    if ( moves.delta.origin() )

    if (moves.delta.origin())

    return unmangle_direction_keys( getchm(KMC_TARGETING), KMC_TARGETING,
                                    false, false);

    return unmangle_direction_keys(getchm(KMC_TARGETING), KMC_TARGETING,
                                   false, false);

    {

    }

        {

        }

        {

        }

        {

        }

#ifndef USE_TILE

 #ifndef USE_TILE

#endif

 #endif

MODE=LOADING
NUM=0
001:001:***:011:034:092:***:023:034:017:000:063
001:001:***:009:002:040:016:077:***:023:009:040
001:000:***:014:017:046:020:048:***:010:000:041
001:001:001:018:000:017:***:190:066:000:009:043
001:001:005:003:016:137:***:117:005:000:000:***
001:000:001:021:000:033:***:136:058:007:000:012
001:001:003:014:000:005:***:194:041:017:000:028
001:000:***:017:027:068:***:197:050:011:000:068
001:000:008:011:033:091:007:055:027:008:000:054
001:001:007:***:026:015:020:170:057:011:000:032