// randomized.

    // randomised.

        // randomized.

        // randomised.

// Static class members must be initialized outside of the class declaration,
// or gcc won't define them in view.o and we'll get a linking error.

// Static class members must be initialised outside of the class
// declaration, or gcc won't define them in view.o and we'll get a
// linking error.

    // If we want to minimize the number of moves on the ray, look one

    // If we want to minimise the number of moves on the ray, look one

// Realize that this is simply a repackaged version of

// Realise that this is simply a repackaged version of

// Initialize is only called for resting/shift-running. We should eventually

// Initialise is only called for resting/shift-running. We should eventually

    // Initialize with additional losses, if any.

    // Initialise with additional losses, if any.

// Initialize per-cell types of walls and floors using defaults.

// Initialise per-cell types of walls and floors using defaults.

        m_font_buf.add("Change doll mode   m                       Randomize doll      Ctrl-R", VColour::white, 0.0f, start_y + height * 3);

        m_font_buf.add("Change doll mode   m                       Randomise doll      Ctrl-R", VColour::white, 0.0f, start_y + height * 3);

    // Initialize equipment setting.

    // Initialise equipment setting.

    // Initialize job default.

    // Initialise job default.

static inline void _finalize_tile(unsigned int *tile,

static inline void _finalise_tile(unsigned int *tile,

                // We know this value is already initialized and

                // We know this value is already initialised and

                // We know this value is already initialized and

                // We know this value is already initialised and

            _finalize_tile(&tileb[count+1], wall_flv, floor_flv, special_flv,

            _finalise_tile(&tileb[count+1], wall_flv, floor_flv, special_flv,

        fprintf(stderr, "Failed to initialize freetype library.\n");

        fprintf(stderr, "Failed to initialise freetype library.\n");

// initialized if it wasn't part of the savefile.
// For now, none are supported.

// initialised if it wasn't part of the savefile.  For now, none are
// supported.

// are read, so everything that can be initialized should have been by now.

// are read, so everything that can be initialised should have been by
// now.

// originally designed to randomize evasion -

// originally designed to randomise evasion -

// it is a bit more extensible and optimizes the logical structure, as well

// it is a bit more extensible and optimises the logical structure, as well

            bool               pluralized = true;
            std::string        feet       = you.foot_name(true, &pluralized);

            bool               pluralised = true;
            std::string        feet       = you.foot_name(true, &pluralised);

            str << "Your " << feet << (pluralized ? " feel" : " feels")

            str << "Your " << feet << (pluralised ? " feel" : " feels")

            bool pluralized = true;

            bool pluralised = true;

                pluralized = can_plural_hand;

                pluralised = can_plural_hand;

                target->hand_name(true, &pluralized);

                target->hand_name(true, &pluralised);

            if (pluralized)

            if (pluralised)

    // initialize beam structure

    // initialise beam structure

        // (Range - 1) is used because the distance is randomized and

        // (Range - 1) is used because the distance is randomised and

            // randomize distance (arcs don't care about a couple of feet)

            // randomise distance (arcs don't care about a couple of feet)

            // distance randomized (as above)

            // distance randomised (as above)

                _shop_print("You don't recognize anything yet!", 1);

                _shop_print("You don't recognise anything yet!", 1);

// Feawn neutralizes most plants and fungi but skips toadstools to prevent

// Feawn neutralises most plants and fungi but skips toadstools to prevent

            // decapitalize 'the'

            // decapitalise 'the'

        // m_old_disp < 0 means it's invalid and needs to be initialized.

        // m_old_disp < 0 means it's invalid and needs to be initialised.

    // This function depends on stats and mutations being finalized.

    // This function depends on stats and mutations being finalised.

    // finalized by now. (GDL)

    // finalised by now. (GDL)

        // If it's changed form, you won't recognize it.

        // If it's changed form, you won't recognise it.

    // Initialize to some bogus values so we can catch problems.

    // Initialise to some bogus values so we can catch problems.

    // However, they don't realize that secret doors make good eating.

    // However, they don't realise that secret doors make good eating.

       // confused, since then they're too confused to realize they

       // confused, since then they're too confused to realise they

static bool initialized_randmons = false;

static bool initialised_randmons = false;

static void _initialize_randmons()

static void _initialise_randmons()

    initialized_randmons = true;

    initialised_randmons = true;

    if (!initialized_randmons)
        _initialize_randmons();

    if (!initialised_randmons)
        _initialise_randmons();

// monsters recognizing traps and patrolling branch entrances.

// monsters recognising traps and patrolling branch entrances.

        // the actual value and then randomizing it.

        // the actual value and then randomising it.

            // now randomize (normal intels less accurate than high):

            // now randomise (normal intels less accurate than high):

// Initialize blood potions with a vector of timers.

// Initialise blood potions with a vector of timers.

    // Initialize timer depending on corpse age:

    // Initialise timer depending on corpse age:

    // startprob is used to initialize the chance for neighbours being

    // startprob is used to initialise the chance for neighbours being

    // Players might not realize the implications of teleport
    // mutations in the labyrinth.

    // Players might not realise the implications of teleport mutations
    // in the labyrinth.

// is able to recognize as being monsters (i.e. no unknown mimics or

// is able to recognise as being monsters (i.e. no unknown mimics or

    // Initializes a Menu from a formatted_string as follows:

    // Initialises a Menu from a formatted_string as follows:

 * Serializes a key sequence into a string of the format described

 * Serialises a key sequence into a string of the format described

    // "ab" and "de" are recognized as macros.

    // "ab" and "de" are recognised as macros.

 * Initializes the macros.

 * Initialises the macros.

    // keypad 0-9 (only if the "application mode" was successfully initialized)

    // keypad 0-9 (only if the "application mode" was successfully initialised)

        // Initialize thrown potion with oldest potion in stack.

        // Initialise thrown potion with oldest potion in stack.

    // FINALIZE tohit and damage

    // FINALISE tohit and damage

        // wiz_mode is recognized as a legal key in all compiles -- bwr

        // wiz_mode is recognised as a legal key in all compiles -- bwr

    // initialize

    // initialise

    // Completely uninitialized, caveat user.

    // Completely uninitialised, caveat user.

        // Values greater than the allowed maximum or less then the allowed
        // minimum signalize bugginess.

        // Values greater than the allowed maximum or less then the
        // allowed minimum signalise bugginess.

    bool statLowered = false;   // must initialize to false {dlb}

    bool statLowered = false;   // must initialise to false {dlb}

            // Reinitialize zap counts.

            // Reinitialise zap counts.

    // (Haste and invisibility already penalized earlier.)

    // (Haste and invisibility already penalised earlier.)

    // Initialize all items.

    // Initialise all items.

// Places a randomized ellipse with centre (x,y) and half axes a and b.

// Places a randomised ellipse with centre (x, y) and half axes a and b.

        case CMD_TARGET_SELECT: // finalize current choice

        case CMD_TARGET_SELECT: // finalise current choice

                // Finalize whatever is inside the loop

                // Finalise whatever is inside the loop

    {"Walking Fertilizer", "Green %s",              "Tree Hugger",              "Conservationist",

    {"Walking Fertiliser", "Green %s",              "Tree Hugger",              "Conservationist",

        mpr("Lua not initialized", MSGCH_DIAGNOSTICS);

        mpr("Lua not initialised", MSGCH_DIAGNOSTICS);

    // We have to canonicalize the key (in case the user typed it

    // We have to canonicalise the key (in case the user typed it

        // We have to canonicalize the key (in case the user typed it

        // We have to canonicalise the key (in case the user typed it

    // Initialize colour to quiet some Valgrind warnings

    // Initialise colour to quiet some Valgrind warnings.

        error = "<LUA not initialized>";

        error = "<LUA not initialised>";

    void initialize_fire();

    void initialise_fire();

    // NOTE: Whenever zapping() is called with a randomized value for power

    // NOTE: Whenever zapping() is called with a randomised value for power

void bolt::initialize_fire()

void bolt::initialise_fire()

    initialize_fire();

    initialise_fire();

    // isn't going to realize it).

    // isn't going to realise it).

    // not to penalize players that fling fireballs into a melee with

    // not to penalise players that fling fireballs into a melee with

// put it, and it doesn't do anything other than initialize its members.

// put it, and it doesn't do anything other than initialise its members.

        // Now that we found something, initialize the props array.

        // Now that we found something, initialise the props array.

 * _UNRAND_ENUM_func_name() in order to be recognized.

 * _UNRAND_ENUM_func_name() in order to be recognised.

        struct dist lmove;   // Will be initialized by direction().

        struct dist lmove;   // Will be initialised by direction().

// print midmsg and decrease duration by midloss (a randomized amount so as

// print midmsg and decrease duration by midloss (a randomised amount so as

    // Must re-run as the feature table wasn't initialized yet.

    // Must re-run as the feature table wasn't initialised yet.

        ret << "Food";   // randomized and amount hidden from player

        ret << "Food";   // randomised and amount hidden from player

        ret << "Piety";  // randomized and amount hidden from player

        ret << "Piety";  // randomised and amount hidden from player

        // This object just says to the world that it's uninitialized

        // This object just says to the world that it's uninitialised