const double xtarget = (double)((int)(*accx) + 1);
    const double ytarget = (double)((int)(*accy) + 1);

    const double xtarget = (static_cast<int>(*accx) + 1);
    const double ytarget = (static_cast<int>(*accy) + 1);

        curx = (int)(accx);
        cury = (int)(accy);

        curx = static_cast<int>(accx);
        cury = static_cast<int>(accy);

         raynum < (int)raylengths.size();

         raynum < static_cast<int>(raylengths.size());

    const cloud_type ctype = (cloud_type) env.cloud[ cloud ].type;

    const cloud_type ctype = env.cloud[ cloud ].type;

            int envc = (unsigned char) env.map[x][y];

            int envc = env.map[x][y];

        env.cloud[i].type = unmarshallByte(th);

        env.cloud[i].type = static_cast<cloud_type>(unmarshallByte(th));

    unsigned char tmp;

    int tmp;

        tmp = (unsigned char) getch();

        tmp = getch();

    int  getX() const { return (int) x; }
    int  getY() const { return (int) y; }

    int  getX() const { return x; }
    int  getY() const { return y; }

void apply_area_cloud(int (*func) (int, int, int, int, kill_category),
                      int x, int y, int pow, int number, int ctype,

void apply_area_cloud(int (*func) (int, int, int, cloud_type, kill_category),
                      int x, int y, int pow, int number, cloud_type ctype,

static bool cloud_helper( int (*func) (int, int, int, int, kill_category),
                          int x, int y, 
                          int pow, int ctype, kill_category );

static bool cloud_helper(int (*func)(int, int, int, cloud_type, kill_category),
                         int x, int y, 
                         int pow, cloud_type ctype, kill_category );

void apply_area_cloud( int (*func) (int, int, int, int, kill_category),

void apply_area_cloud( int (*func) (int, int, int, cloud_type, kill_category),

                       int pow, int number, int ctype, kill_category whose )

                       int pow, int number, cloud_type ctype,
                       kill_category whose )

static bool cloud_helper( int (*func) (int, int, int, int, kill_category),
                          int x, int y, 
                          int pow, int ctype, kill_category whose )

static bool cloud_helper(int (*func)(int, int, int, cloud_type, kill_category),
                         int x, int y, 
                         int pow, cloud_type ctype, kill_category whose )

            itoa( (int) spell_difficulty( spell ), sval, 10 );

            itoa( spell_difficulty( spell ), sval, 10 );

bool cast_a_spell(void)

bool cast_a_spell()

                big_cloud( CLOUD_GREY_SMOKE + random2(3), KC_YOU,

                big_cloud( random_smoke_type(), KC_YOU,

int make_a_normal_cloud(int x, int y, int pow, int ctype, kill_category);

int make_a_normal_cloud(int x, int y, int pow, cloud_type ctype,
                        kill_category);

static int make_a_rot_cloud(int x, int y, int pow, int ctype);

static int make_a_rot_cloud(int x, int y, int pow, cloud_type ctype);

    return ((int) did_anything);

    return did_anything;

static int make_a_rot_cloud(int x, int y, int pow, int ctype)

static int make_a_rot_cloud(int x, int y, int pow, cloud_type ctype)

int make_a_normal_cloud(int x, int y, int pow, int ctype, kill_category whose)

int make_a_normal_cloud(int x, int y, int pow, cloud_type ctype,
                        kill_category whose)

            keyin = (unsigned char) get_ch();

            keyin = get_ch();

            keyi = (unsigned char) get_ch();

            keyi = get_ch();

            keyi = (unsigned char) get_ch();

            keyi = get_ch();

void big_cloud(int clouds, kill_category whose, int cl_x, int cl_y,

void big_cloud(cloud_type cl_type, kill_category whose, int cl_x, int cl_y,

int cast_big_c(int pow, int cty, kill_category whose, bolt &beam);

int cast_big_c(int pow, cloud_type cty, kill_category whose, bolt &beam);

int cast_big_c(int pow, int cty, kill_category whose, bolt &beam)

int cast_big_c(int pow, cloud_type cty, kill_category whose, bolt &beam)

void big_cloud(int cloud_type, kill_category whose,

void big_cloud(cloud_type cl_type, kill_category whose,

                     cloud_type, whose);

                     cl_type, whose);

    if ((int) you.penance[god] + val > 200)

    if (you.penance[god] + val > 200)

    if ((int) you.gift_timeout + val > 200)

    if (you.gift_timeout + val > 200)

            const char* pmsg = god_gain_power_messages[(int)you.religion][i];

            const char* pmsg = god_gain_power_messages[you.religion][i];

                const char* pmsg=god_lose_power_messages[(int)you.religion][i];

                const char* pmsg = god_lose_power_messages[you.religion][i];

    const unsigned char branch = (unsigned char) ((place >> 8) & 0xFF);

    const unsigned char branch =
        static_cast<unsigned char>((place >> 8) & 0xFF);

    type = (NOTE_TYPES)(readLong( fp ));

    type = static_cast<NOTE_TYPES>(readLong( fp ));

    return (unsigned char) desc;

    return static_cast<unsigned char>(desc);

        && is_range_weapon_type((weapon_type) lnchType)
        && wepType == fires_ammo_type((weapon_type) lnchType))

        && is_range_weapon_type(static_cast<weapon_type>(lnchType))
        && wepType == fires_ammo_type(static_cast<weapon_type>(lnchType)))

            place_cloud( CLOUD_GREY_SMOKE + random2(3),

            place_cloud( random_smoke_type(),

            place_cloud( CLOUD_GREY_SMOKE + random2(3), monster->x,
                         monster->y, 1 + random2(3),

            place_cloud( random_smoke_type(),
                         monster->x, monster->y, 1 + random2(3),

                    place_cloud( CLOUD_GREY_SMOKE + random2(3),

                    place_cloud( random_smoke_type(),

    return (unsigned char) smc->showchar;

    return static_cast<unsigned char>(smc->showchar);

void in_a_cloud(void)

void in_a_cloud()

        break;
    default:

        const cloud_type type = (cloud_type)

        const cloud_type type =

    if (end > (int) items.size()) end = items.size();

    if (end > static_cast<int>(items.size())) end = items.size();

    if ((int) s.length() > map_width)

    if (static_cast<int>(s.length()) > map_width)

        if ((int) s.length() < map_width)

        if (static_cast<int>(s.length()) < map_width)

    int temp_value = 0;            // temporary value storage {dlb}

                    temp_value = (unsigned char) random2(NUM_WEAPONS);

                    const int wpntype = random2(NUM_WEAPONS);

                    if (weapon_rarity(temp_value) >= random2(10) + 1)

                    if (weapon_rarity(wpntype) >= random2(10) + 1)

                        mitm[p].sub_type = temp_value;

                        mitm[p].sub_type = static_cast<unsigned char>(wpntype);

    if ((int) you.burden + imass > carrying_capacity())

    if (you.burden + imass > carrying_capacity())

        int part = (carrying_capacity() - (int)you.burden) / unit_mass;

        int part = (carrying_capacity() - you.burden) / unit_mass;

    const long rot_time = (long) (elapsedTime / 20.0);

    const long rot_time = static_cast<long>(elapsedTime / 20.0);

    int fountain_checks = (int)(elapsedTime / 1000.0);
    if (random2(1000) < (int)(elapsedTime) % 1000)

    int fountain_checks = static_cast<int>(elapsedTime / 1000.0);
    if (random2(1000) < static_cast<int>(elapsedTime) % 1000)

    int turns = (int) (elapsedTime / 10.0);

    const int turns = static_cast<int>(elapsedTime / 10.0);

#include "cloud.h"

        big_cloud( CLOUD_GREY_SMOKE + random2(3), KC_YOU,

        big_cloud( random_smoke_type(), KC_YOU,

    int i;
    unsigned int j;
    char iletter = (char)(oper);

    const char iletter = static_cast<char>(oper);

    for ( i = 0; i < ENDOFPACK; ++i ) {

    for ( int i = 0; i < ENDOFPACK; ++i ) {

            for ( j = 0; j + 2 < r.size(); ++j ) {

            for ( unsigned int j = 0; j + 2 < r.size(); ++j ) {

    char iletter = (char)(oper);
    unsigned int i;

    const char iletter = static_cast<char>(oper);

    for ( i = 0; i + 1 < r.size(); ++i )

    for ( unsigned int i = 0; i + 1 < r.size(); ++i )

        int ci = (int) strtol(s, &es, 10);

        const int ci = static_cast<int>(strtol(s, &es, 10));

            SysEnv.crawl_dir = (char *) calloc(kPathLen, sizeof(char));

            SysEnv.crawl_dir = (char*)calloc(kPathLen, sizeof(char));

    while (*inbuf && *inbuf != ':' && (p - dest) < (int) destsize - 1)

    while (*inbuf && *inbuf != ':' &&
           (p - dest) < static_cast<int>(destsize) - 1)

    uid = (int) getuid();

    uid = static_cast<int>(getuid());

    snprintf( struid, sizeof struid, "-%d", (int)getuid() );

    snprintf( struid, sizeof struid, "-%d", static_cast<int>(getuid()) );

    data[0] = (char)((s >> 8) & 0xFF);
    data[1] = (char)(s & 0xFF);

    data[0] = static_cast<char>((s >> 8) & 0xFF);
    data[1] = static_cast<char>(s & 0xFF);

    int x() const { return (int)(accx); }
    int y() const { return (int)(accy); }

    int x() const { return static_cast<int>(accx); }
    int y() const { return static_cast<int>(accy); }

    int           type;

    cloud_type    type;

        if (place_monster( not_used, montypes[random2((int)montypes.size())],

        if (place_monster( not_used, montypes[random2(montypes.size())],

    if (index < 0 || index >= (int) sitems.size())

    if (index < 0 || index >= static_cast<int>(sitems.size()))

                    << get_ident_type(item.base_type, item.sub_type)

                    << static_cast<int>(get_ident_type(item.base_type,
                                                       item.sub_type))

#include "enum.h"

void deck_of_cards(unsigned char which_deck);

void deck_of_cards(deck_type which_deck);

// array sizes -- see notes below {dlb}
#define DECK_WONDERS_SIZE 27
#define DECK_SUMMONING_SIZE 11
#define DECK_TRICKS_SIZE 11
#define DECK_POWER_SIZE 17
#define DECK_PUNISHMENT_SIZE 23

enum CARDS                      // (unsigned char) deck_of_foo[]

enum card_type

static unsigned char deck_of_wonders[] = 

static card_type deck_of_wonders[] = 

static unsigned char deck_of_summoning[] = 

static card_type deck_of_summoning[] = 

static unsigned char deck_of_tricks[] = 

static card_type deck_of_tricks[] = 

static unsigned char deck_of_power[] = 

static card_type deck_of_power[] = 

static unsigned char deck_of_punishment[] = 

static card_type deck_of_punishment[] = 

static void cards(unsigned char which_card);

// array sizes -- see notes below {dlb}
#define ARRAYSIZE(x) (sizeof(x) / sizeof(x[0]))
#define DECK_WONDERS_SIZE ARRAYSIZE(deck_of_wonders)
#define DECK_SUMMONING_SIZE ARRAYSIZE(deck_of_summoning)
#define DECK_TRICKS_SIZE ARRAYSIZE(deck_of_tricks)
#define DECK_POWER_SIZE ARRAYSIZE(deck_of_power)
#define DECK_PUNISHMENT_SIZE ARRAYSIZE(deck_of_punishment)

void deck_of_cards(unsigned char which_deck)

static void cards(card_type which_card);
void deck_of_cards(deck_type which_deck)

    // I really am not fond of how all of this works, the
    // decks ought to be stored (possibly) in an array of
    // pointers to int or as discrete arrays of int using
    // the sizeof operator to determine upper bounds, and
    // not defines, which is a bit clumsy given that you
    // have to update two things presently (the array and
    // the corresponding define) in order to add things to
    // decks ... someone fix this, or I will {dlb}
    unsigned char *card = deck_of_wonders;
    unsigned char max_card = 0;
    int i = 0;

    card_type *deck = deck_of_wonders;
    int max_card = 0;

        card = deck_of_wonders;

        deck = deck_of_wonders;

        card = deck_of_summoning;

        deck = deck_of_summoning;

        card = deck_of_tricks;

        deck = deck_of_tricks;

        card = deck_of_power;

        deck = deck_of_power;

        card = deck_of_punishment;

        deck = deck_of_punishment;

    i = (int) card[random2(max_card)];

    card_type chosen = deck[random2(max_card)];

        i = random2(NUM_CARDS);

        chosen = static_cast<card_type>(random2(NUM_CARDS));

    if (i == CARD_BLANK && you.skills[SK_EVOCATIONS] > random2(30))
        i = (int) card[random2(max_card)];

    // High Evocations gives you another shot (but not at being punished...)
    if (which_deck != DECK_OF_PUNISHMENT && chosen == CARD_BLANK &&
        you.skills[SK_EVOCATIONS] > random2(30))
        chosen = deck[random2(max_card)];

    cards(i);

    cards(chosen);

static void cards(unsigned char which_card)

static void cards(card_type which_card)

    default:

    case NUM_CARDS:
    case CARD_RANDOM:
        mpr("You have drawn a buggy card!");
        break;

    int avspeed = (int) (time / iterations);

    int avspeed = static_cast<int>(time / iterations);

    int input_1 = (int) keyin;

    int input_1 = keyin;

    int input_2 = (int) keyin;

    int input_2 = keyin;

    int input_1 = (int) keyin;

    int input_1 = keyin;

    int input_2 = (int) keyin;

    int input_2 = keyin;

cloud_type random_smoke_type();

void check_place_cloud( int cl_type, int x, int y, int lifetime,

void check_place_cloud( cloud_type cl_type, int x, int y, int lifetime,

void place_cloud(int cl_type, int ctarget_x, int ctarget_y, int cl_range,
                 kill_category whose);

void place_cloud(cloud_type cl_type, int ctarget_x, int ctarget_y,
                 int cl_range, kill_category whose);

static void new_cloud( int cloud, int type, int x, int y, int decay,

static void new_cloud( int cloud, cloud_type type, int x, int y, int decay,

static void place_new_cloud(int cltype, int x, int y, int decay,

static void place_new_cloud(cloud_type cltype, int x, int y, int decay,

void check_place_cloud( int cl_type, int x, int y, int lifetime,

void check_place_cloud( cloud_type cl_type, int x, int y, int lifetime,

void place_cloud(int cl_type, int ctarget_x,

void place_cloud(cloud_type cl_type, int ctarget_x,

}
cloud_type random_smoke_type()
{
    // excludes black (reproducing existing behaviour)
    switch ( random2(3) )
    {
    case 0: return CLOUD_GREY_SMOKE;
    case 1: return CLOUD_BLUE_SMOKE;
    case 2: return CLOUD_PURP_SMOKE;
    }
    return CLOUD_DEBUGGING;

    const long kIndent = 3;
    long lineLen = kIndent;

    const int kIndent = 3;
    int lineLen = kIndent;

    long i = 0;

    unsigned int i = 0;

    while (i < (long) inStr.length())

    while (i < inStr.length())

        char ch = inStr[i];

        const char ch = inStr[i];

            while (i < (long) inStr.length()
                   && lineLen + (long) word.length() < 79

            while (i < inStr.length()
                   && lineLen + word.length() < 79

                itoa((int) spell_difficulty( spell ), tmp_quant, 10 );

                itoa(spell_difficulty(spell), tmp_quant, 10 );

    int cloud_type;

    cloud_type cl_type;

        cloud_type = beam.flavour == BEAM_MIASMA? CLOUD_MIASMA : CLOUD_STINK;
        big_cloud( cloud_type, whose_kill(beam), x, y, 0, 9 );

        cl_type = beam.flavour == BEAM_MIASMA? CLOUD_MIASMA : CLOUD_STINK;
        big_cloud( cl_type, whose_kill(beam), x, y, 0, 9 );

            env.cloud[ env.cgrid[x][y] ].type = 1 + random2(8);

            env.cloud[ env.cgrid[x][y] ].type =
                static_cast<cloud_type>(1 + random2(8));

    int cloud_type; 

    cloud_type cl_type; 

            cloud_type = CLOUD_STINK;

            cl_type = CLOUD_STINK;

            cloud_type = CLOUD_POISON;

            cl_type = CLOUD_POISON;

            cloud_type = CLOUD_MIASMA;

            cl_type = CLOUD_MIASMA;

            cloud_type = CLOUD_BLACK_SMOKE;

            cl_type = CLOUD_BLACK_SMOKE;

            cloud_type = CLOUD_FIRE;

            cl_type = CLOUD_FIRE;

            cloud_type = CLOUD_COLD;

            cl_type = CLOUD_COLD;

            cloud_type = CLOUD_BLUE_SMOKE;

            cl_type = CLOUD_BLUE_SMOKE;

            cloud_type = CLOUD_PURP_SMOKE;

            cl_type = CLOUD_PURP_SMOKE;

            case 0:  cloud_type = CLOUD_FIRE;           break;
            case 1:  cloud_type = CLOUD_STINK;          break;
            case 2:  cloud_type = CLOUD_COLD;           break;
            case 3:  cloud_type = CLOUD_POISON;         break;
            case 4:  cloud_type = CLOUD_BLACK_SMOKE;    break;
            case 5:  cloud_type = CLOUD_BLUE_SMOKE;     break;
            case 6:  cloud_type = CLOUD_PURP_SMOKE;     break;
            default: cloud_type = CLOUD_STEAM;          break;

            case 0:  cl_type = CLOUD_FIRE;           break;
            case 1:  cl_type = CLOUD_STINK;          break;
            case 2:  cl_type = CLOUD_COLD;           break;
            case 3:  cl_type = CLOUD_POISON;         break;
            case 4:  cl_type = CLOUD_BLACK_SMOKE;    break;
            case 5:  cl_type = CLOUD_BLUE_SMOKE;     break;
            case 6:  cl_type = CLOUD_PURP_SMOKE;     break;
            default: cl_type = CLOUD_STEAM;          break;

            cloud_type = CLOUD_STEAM;

            cl_type = CLOUD_STEAM;

        place_cloud( cloud_type, x, y, duration, whose_kill(beam) );

        place_cloud( cl_type, x, y, duration, whose_kill(beam) );

    unsigned char spc, spc2;

    unsigned char abil_used;

    spc = (int) keyin;

    if (!isalpha( spc ))

    if (!isalpha( keyin ))

    spc2 = letter_to_index(spc);

    const int abil_used = letter_to_index(keyin);

    if (Curr_abil[spc2].which == -1)

    if (Curr_abil[abil_used].which == -1)

    abil_used = spc2;

                ability_type abil = god_abilities[(int)you.religion][i];

                ability_type abil = god_abilities[you.religion][i];

        if ( god_abilities[(int)you.religion][i] != ABIL_NON_ABILITY )

        if ( god_abilities[you.religion][i] != ABIL_NON_ABILITY )

            set_god_ability_helper(god_abilities[(int)you.religion][i],

            set_god_ability_helper(god_abilities[you.religion][i],