bool god_hates_attacking_friend(god_type god, int species);

void religion_turn_end();

typedef void (*delayed_callback)(const mgen_data &mg, int &midx, int placed);
static void _delayed_monster(const mgen_data &mg,
                             delayed_callback callback = NULL);
static void _delayed_monster_done(std::string success, std::string failure,
                                  delayed_callback callback = NULL);
static void _place_delayed_monsters();

    int count = 0;

    mgen_data mg(mon, !force_hostile ? BEH_FRIENDLY : BEH_HOSTILE,
                 0, 0, you.pos(), !force_hostile ? you.pet_target : MHITYOU,
                 0, GOD_YREDELEMNUL);

    for (int i = 0; i < how_many; ++i)

    int created = 0;
    if (force_hostile)

        if (create_monster(
                mgen_data(mon,
                          !force_hostile ? BEH_FRIENDLY : BEH_HOSTILE,
                          0, 0, you.pos(),
                          !force_hostile ? you.pet_target : MHITYOU,
                          0, GOD_YREDELEMNUL)) != -1)

        for (int i = 0; i < how_many; ++i)

            count++;

            if (create_monster(mg) != -1)
                created++;

    }
    else
    {
        for (int i = 0; i < how_many; ++i)
            _delayed_monster(mg);

    return (count);

    return (created);

    bool success = false;
    if (create_monster(
            mgen_data::hostile_at(mon,
                you.pos(), 0, 0, true, GOD_OKAWARU)) != -1)
    {
        success = true;
    }

    return (success);

    return (create_monster(
                    mgen_data::hostile_at(mon,
                        you.pos(), 0, 0, true, GOD_OKAWARU)) != -1);

static void _beogh_reinf_callback(const mgen_data &mg, int &midx, int placed)
{
    ASSERT(mg.god == GOD_BEOGH);
    // Beogh tries a second time to place reinforcements.
    if (midx == -1)
        midx = create_monster(mg);
    if (midx == -1)
        return;
    monsters* mon = &menv[midx];
    mon->flags |= MF_ATT_CHANGE_ATTEMPT;
    bool high_level = (mon->type == MONS_ORC_PRIEST
                       || mon->type == MONS_ORC_WARRIOR
                       || mon->type == MONS_ORC_KNIGHT);
    // For high level orcs, there's a chance of being named.
    if (high_level && one_chance_in(5))
        give_monster_proper_name(mon);
}

static bool _beogh_blessing_reinforcement()

static void _beogh_blessing_reinforcement()

    bool success = false;

        int monster =
            create_monster(
                mgen_data(follower_type, BEH_FRIENDLY, 0, 0,
                          you.pos(), you.pet_target, 0, GOD_BEOGH));
        if (monster != -1)
        {
            monsters *mon = &menv[monster];
            mon->flags |= MF_ATT_CHANGE_ATTEMPT;
            // For high level orcs, there's a chance of being named.
            if (high_level && one_chance_in(5))
                give_monster_proper_name(mon);
            success = true;
        }

        _delayed_monster(
            mgen_data(follower_type, BEH_FRIENDLY, 0, 0,
                      you.pos(), you.pet_target, 0, GOD_BEOGH),
            _beogh_reinf_callback);

    return (success);

                    bool reinforced = _beogh_blessing_reinforcement();

                    _beogh_blessing_reinforcement();

                    if (!reinforced || coinflip())
                    {
                        // Try again, or possibly send more reinforcement.
                        if (_beogh_blessing_reinforcement())
                            reinforced = true;
                    }

                    // Possibly send more reinforcement.
                    if (coinflip())
                        _beogh_blessing_reinforcement();

                    if (!reinforced)
                        return (false);

                    _delayed_monster_done("Beogh blesses you with "
                                         "reinforcements.", "");

                    result = "reinforcement";
                    goto blessing_done;

                    // Return true, even though the reinforcements might
                    // not be placed.
                    return (true);

}
static void _delayed_gift_callback(const mgen_data &mg, int &midx,
                                   int placed)
{
    if (placed <= 0)
        return;
    more();
    _inc_gift_timeout(4 + random2avg(7, 2));
    you.num_gifts[you.religion]++;
    take_note(Note(NOTE_GOD_GIFT, you.religion));

                int how_many = _yred_random_servants(threshold);

                _yred_random_servants(threshold);

                if (how_many > 0)
                {
                    simple_god_message(
                        how_many > 1 ? " grants you several undead servants!"
                                     : " grants you an undead servant!");
                    more();
                    _inc_gift_timeout(4 + random2avg(7, 2));
                    you.num_gifts[you.religion]++;
                    take_note(Note(NOTE_GOD_GIFT, you.religion));
                }

                _delayed_monster_done("grants you @an@ undead servant@s@!",
                                      "", _delayed_gift_callback);

    if (you.turn_is_over)
        religion_turn_end();

void religion_turn_end()
{
    ASSERT(you.turn_is_over);
    _place_delayed_monsters();
}
#define NEW_GIFT_FLAGS (MF_JUST_SUMMONED | MF_GOD_GIFT)

        if(_first_attack_conduct[midx]

        if ((mon->flags & NEW_GIFT_FLAGS) == NEW_GIFT_FLAGS)
        {
            mprf(MSGCH_ERROR, "Newly created friendly god gift '%s' was hurt "
                 "by you, shouldn't be possible; please file a bug report.",
                 mon->name(DESC_PLAIN, true).c_str());
            _first_attack_was_friendly[midx] = true;
        }
        else if(_first_attack_conduct[midx]

    if (you.turn_is_over)
        religion_turn_end();

    if (you.turn_is_over)
        religion_turn_end();

    return god_hates_attacking_friend(god, fr->mons_species());
}
bool god_hates_attacking_friend(god_type god, int species)
{

            return (mons_species(fr->id()) == MONS_ORC);

            return (species == MONS_ORC);

    if (you.turn_is_over)
        religion_turn_end();

    if (you.turn_is_over)
        religion_turn_end();

/////////////////////////////////////////////////////////////////////////////
// Stuff for placing god gift monsters after the player's turn has ended.
/////////////////////////////////////////////////////////////////////////////
static std::vector<mgen_data>       _delayed_data;
static std::deque<delayed_callback> _delayed_callbacks;
static std::deque<unsigned int>     _delayed_done_trigger_pos;
static std::deque<delayed_callback> _delayed_done_callbacks;
static std::deque<std::string>      _delayed_success;
static std::deque<std::string>      _delayed_failure;
static void _delayed_monster(const mgen_data &mg, delayed_callback callback)
{
    _delayed_data.push_back(mg);
    _delayed_callbacks.push_back(callback);
}
static void _delayed_monster_done(std::string success, std::string failure,
                                  delayed_callback callback)
{
    const unsigned int size = _delayed_data.size();
    ASSERT(size > 0);
    _delayed_done_trigger_pos.push_back(size - 1);
    _delayed_success.push_back(success);
    _delayed_failure.push_back(failure);
    _delayed_done_callbacks.push_back(callback);
}
static void _place_delayed_monsters()
{
    int      placed   = 0;
    god_type prev_god = GOD_NO_GOD;
    for (unsigned int i = 0; i < _delayed_data.size(); i++)
    {
        mgen_data &mg          = _delayed_data[i];
        delayed_callback cback = _delayed_callbacks[i];
        if (prev_god != mg.god)
        {
            placed   = 0;
            prev_god = mg.god;
        }
        int midx = create_monster(mg);
        if (cback)
            (*cback)(mg, midx, placed);
        if (midx != -1)
            placed++;
        if (_delayed_done_trigger_pos.size() > 0
            && _delayed_done_trigger_pos[0] == i)
        {
            cback = _delayed_done_callbacks[0];
            std::string msg;
            if (placed > 0)
                msg = _delayed_success[0];
            else
                msg = _delayed_failure[0];
            if (placed == 1)
            {
                msg = replace_all(msg, "@a@", "a");
                msg = replace_all(msg, "@an@", "an");
            }
            else
            {
                msg = replace_all(msg, "@a@", "");
                msg = replace_all(msg, "@an@", "");
            }
            if (placed > 1)
                msg = replace_all(msg, "@s@", "s");
            else
                msg = replace_all(msg, "@s@", "");
            prev_god = GOD_NO_GOD;
            _delayed_done_trigger_pos.pop_front();
            _delayed_success.pop_front();
            _delayed_failure.pop_front();
            _delayed_done_callbacks.pop_front();
            if (msg == "")
            {
                if (cback)
                    (*cback)(mg, midx, placed);
                continue;
            }
            // Fake it coming from simple_god_message().
            if (msg[0] == ' ' || msg[0] == '\'')
                msg = god_name(mg.god) + msg;
            msg = apostrophise_fixup(msg);
            trim_string(msg);
            god_speaks(mg.god, msg.c_str());
            if (cback)
                (*cback)(mg, midx, placed);
        }
    }
    _delayed_data.clear();
    _delayed_callbacks.clear();
    _delayed_done_trigger_pos.clear();
    _delayed_success.clear();
    _delayed_failure.clear();
} // _place_delayed_monsters()

bool mons_avoids_cloud(const monsters *monster, cloud_type cl_type,
                       bool placement = false,
                       bool extra_careful = false);
// Like the above, but prevents monsters from moving into cloud if it
// would anger the player's god, and also allows a monster to move from
// one damaging cloud to another.
bool mons_avoids_cloud(const monsters *monster, int cloud_num,
                       cloud_type *cl_type = NULL, bool placement = false);

static bool _mons_avoids_cloud(const monsters *monster, cloud_type cl_type)

bool mons_avoids_cloud(const monsters *monster, cloud_type cl_type,
                       bool placement, bool extra_careful)

    if (placement)
        extra_careful = true;

        if (extra_careful)
            return (true);

        if (extra_careful)
            return (true);

        if (extra_careful)
            return (true);

        if (extra_careful)
            return (true);

        if (placement)
            return (false);

    if (is_harmless_cloud(cl_type) || mons_intel(monster) == I_PLANT)

    if (is_harmless_cloud(cl_type)
        || mons_intel(monster) == I_PLANT && !extra_careful)
    {

    }

// Like the above, but prevents monsters from moving into cloud if it
// would anger the player's god, and also allows a monster to move from
// one damaging cloud to another, even if they're of different types.
bool mons_avoids_cloud(const monsters *monster, int cloud_num,
                       cloud_type *cl_type, bool placement)
{
    if (cloud_num == EMPTY_CLOUD)
    {
        if (cl_type != NULL)
            *cl_type = CLOUD_NONE;
        return (false);
    }
    const cloud_struct &cloud = env.cloud[cloud_num];
    if (cl_type != NULL)
        *cl_type = cloud.type;
    const bool careful_friendly
        = YOU_KILL(cloud.killer) && mons_friendly(monster)
       && god_hates_attacking_friend(you.religion, monster);
    // Is the target cloud okay?
    if (!mons_avoids_cloud(monster, cloud.type, placement, careful_friendly))
        return (false);
    // If we're already in a cloud that we'd want to avoid then moving
    // from one to the other is okay.
    if (!in_bounds(monster->pos()) || monster->pos() == cloud.pos)
        return (true);
    const int our_cloud_num = env.cgrid(monster->pos());
    if (our_cloud_num == EMPTY_CLOUD)
        return (true);
    const cloud_struct &our_cloud = env.cloud[our_cloud_num];
    // Don't move monster from a cloud that won't anger their god to one
    // that will.
    if (!YOU_KILL(our_cloud.killer) && careful_friendly)
        return (true);
    return (!mons_avoids_cloud(monster, our_cloud.type, true,
                               careful_friendly));
}

        const int        cloud_num = env.cgrid(monster->pos());
        const cloud_type cl_type   = cloud_num == EMPTY_CLOUD ? CLOUD_NONE
                                                    : env.cloud[cloud_num].type;
        if (cloud_num != EMPTY_CLOUD)

        cloud_type cl_type;
        const int  cloud_num   = env.cgrid(monster->pos());
        const bool avoid_cloud = mons_avoids_cloud(monster, cloud_num,
                                                   &cl_type);
        if (cl_type != CLOUD_NONE)

            if (_mons_avoids_cloud(monster, cl_type))

            if (avoid_cloud)

        if (cloud_num != EMPTY_CLOUD && _mons_avoids_cloud(monster, cl_type)
            && monster_can_submerge(monster, grd(monster->pos()))

        if (avoid_cloud && monster_can_submerge(monster, grd(monster->pos()))

                        || _mons_avoids_cloud(monster, cl_type))

                        || avoid_cloud)

    const int        targ_cloud_num  = env.cgrid(targ);
    const cloud_type targ_cloud_type =
        (targ_cloud_num == EMPTY_CLOUD) ? CLOUD_NONE
                                        : env.cloud[targ_cloud_num].type;

    cloud_type targ_cloud_type;
    const int  targ_cloud_num = env.cgrid(targ);

    const int        curr_cloud_num  = env.cgrid(monster->pos());
    const cloud_type curr_cloud_type =
        (curr_cloud_num == EMPTY_CLOUD) ? CLOUD_NONE
                                        : env.cloud[curr_cloud_num].type;

    if (mons_avoids_cloud(monster, targ_cloud_num, &targ_cloud_type))
        return (false);

    if (targ_cloud_num != EMPTY_CLOUD)
    {
        if (curr_cloud_num != EMPTY_CLOUD
            && targ_cloud_type == curr_cloud_type)
        {
            return (true);
        }

        return !_mons_avoids_cloud(monster, targ_cloud_type);
    }

        // Gods other than Xom will try to avoid placing their monsters
        // directly in harm's way.
        if (mg.god != GOD_NO_GOD && mg.god != GOD_XOM)
        {
            monsters dummy;
            dummy.type         = mg.cls;
            dummy.base_monster = mg.base_type;
            dummy.god          = mg.god;
            int tries = 0;
            while (tries++ < 50
                   && mons_avoids_cloud(&dummy, env.cgrid(mg.pos), NULL, true))
            {
                mg.pos = find_newmons_square(montype, mg.pos);
            }
            const int cloud_num = env.cgrid(mg.pos);
            // Don't place friendly god gift in a damaging cloud created by
            // you if that would anger the god.
            if (mons_avoids_cloud(&dummy, cloud_num, NULL, true)
                && mg.behaviour == BEH_FRIENDLY
                && god_hates_attacking_friend(you.religion, &dummy)
                && YOU_KILL(env.cloud[cloud_num].killer))
            {
                return (-1);
            }
        }

    // Force the placement of any delayed monster gifts.
    you.turn_is_over = true;
    religion_turn_end();

    if (!crawl_state.arena)
        religion_turn_end();