C++ DespawnObject函数代码示例

void PoolGroup<T>::SpawnObject(ActivePoolData& spawns, uint32 limit,
		uint32 triggerFrom) {
	uint32 lastDespawned = 0;
	int count = limit - spawns.GetActiveObjectCount(poolId);

	// If triggered from some object respawn this object is still marked as spawned
	// and also counted into m_SpawnedPoolAmount so we need increase count to be
	// spawned by 1
	if (triggerFrom)
		++count;

	// This will try to spawn the rest of pool, not guaranteed
	for (int i = 0; i < count; ++i) {
		PoolObject* obj = RollOne(spawns, triggerFrom);
		if (!obj)
			continue;
		if (obj->guid == lastDespawned)
			continue;

		if (obj->guid == triggerFrom) {
			ReSpawn1Object(obj);
			triggerFrom = 0;
			continue;
		}
		spawns.ActivateObject<T>(obj->guid, poolId);
		Spawn1Object(obj);

		if (triggerFrom) {
			// One spawn one despawn no count increase
			DespawnObject(spawns, triggerFrom);
			lastDespawned = triggerFrom;
			triggerFrom = 0;
		}
	}
}

void PoolGroup<T>::SpawnObject(MapPersistentState& mapState, uint32 limit, uint32 triggerFrom, bool instantly)
{
    SpawnedPoolData& spawns = mapState.GetSpawnedPoolData();

    uint32 lastDespawned = 0;
    int count = limit - spawns.GetSpawnedObjects(poolId);

    // If triggered from some object respawn this object is still marked as spawned
    // and also counted into m_SpawnedPoolAmount so we need increase count to be
    // spawned by 1
    if (triggerFrom)
    {
        if (spawns.IsSpawnedObject<T>(triggerFrom))
            ++count;
        else
            triggerFrom = 0;
    }

    // This will try to spawn the rest of pool, not guaranteed
    for (int i = 0; i < count; ++i)
    {
        PoolObject* obj = RollOne(spawns, triggerFrom);
        if (!obj)
            continue;
        if (obj->guid == lastDespawned)
            continue;

        if (obj->guid == triggerFrom)
        {
            MANGOS_ASSERT(spawns.IsSpawnedObject<T>(obj->guid));
            MANGOS_ASSERT(spawns.GetSpawnedObjects(poolId) > 0);
            ReSpawn1Object(mapState, obj);
            triggerFrom = 0;
            continue;
        }

        spawns.AddSpawn<T>(obj->guid, poolId);
        Spawn1Object(mapState, obj, instantly);

        if (triggerFrom)
        {
            // One spawn one despawn no count increase
            DespawnObject(mapState, triggerFrom);
            lastDespawned = triggerFrom;
            triggerFrom = 0;
        }
    }
}

void PoolGroup<T>::SpawnObject(uint32 limit, uint32 triggerFrom)
{
    uint32 lastDespawned = 0;
    int count = limit - m_SpawnedPoolAmount;

    // If triggered from some object respawn this object is still marked as spawned
    // and also counted into m_SpawnedPoolAmount so we need increase count to be 
    // spawned by 1
    if (triggerFrom)
        ++count;

    // This will try to spawn the rest of pool, not guaranteed
    for (int i = 0; i < count; ++i)
    {
        int index;
        PoolObjectList* store;

        RollOne(index, &store, triggerFrom);
        if (index == -1)
            continue;
        if ((*store)[index].guid == lastDespawned)
            continue;

        if ((*store)[index].guid == triggerFrom)
        {
            (*store)[index].spawned = ReSpawn1Object(triggerFrom);
            triggerFrom = 0;
            continue;
        }
        else
            (*store)[index].spawned = Spawn1Object((*store)[index].guid);

        if (triggerFrom)
        {
            // One spawn one despawn no count increase
            DespawnObject(triggerFrom);
            lastDespawned = triggerFrom;
            triggerFrom = 0;
        }
        else
            ++m_SpawnedPoolAmount;
    }
}

void PoolGroup<Quest>::SpawnObject(ActivePoolData& spawns, uint32 limit, uint32 triggerFrom)
{
    sLog->outDebug(LOG_FILTER_POOLSYS, "PoolGroup<Quest>: Spawning pool %u", poolId);
    // load state from db
    if (!triggerFrom)
    {
        QueryResult result = CharacterDatabase.PQuery("SELECT quest_id FROM pool_quest_save WHERE pool_id = %u", poolId);
        if (result)
        {
            do
            {
                uint32 questId = result->Fetch()[0].GetUInt32();
                spawns.ActivateObject<Quest>(questId, poolId);
                PoolObject tempObj(questId, 0.0f);
                Spawn1Object(&tempObj);
                --limit;
            } while (result->NextRow() && limit);
            return;
        }
    }

    ActivePoolObjects currentQuests = spawns.GetActiveQuests();
    ActivePoolObjects newQuests;

    // always try to select different quests
    for (PoolObjectList::iterator itr = EqualChanced.begin(); itr != EqualChanced.end(); ++itr)
    {
        if (spawns.IsActiveObject<Quest>(itr->guid))
            continue;
        newQuests.insert(itr->guid);
    }

    // clear the pool
    DespawnObject(spawns);

    // recycle minimal amount of quests if possible count is lower than limit
    if (limit > newQuests.size() && !currentQuests.empty())
    {
        do
        {
            uint32 questId = SelectRandomContainerElement(currentQuests);
            newQuests.insert(questId);
            currentQuests.erase(questId);
        } while (newQuests.size() < limit && !currentQuests.empty()); // failsafe
    }

    if (newQuests.empty())
        return;

    // activate <limit> random quests
    do
    {
        uint32 questId = SelectRandomContainerElement(newQuests);
        spawns.ActivateObject<Quest>(questId, poolId);
        PoolObject tempObj(questId, 0.0f);
        Spawn1Object(&tempObj);
        newQuests.erase(questId);
        --limit;
    } while (limit && !newQuests.empty());

    // if we are here it means the pool is initialized at startup and did not have previous saved state
    if (!triggerFrom)
        sPoolMgr->SaveQuestsToDB();
}