InstanceScenario.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "InstanceScenario.h"
#include "DB2Stores.h"
#include "GameTime.h"
#include "InstanceScript.h"
#include "Map.h"
#include "MapUtils.h"
#include "ObjectMgr.h"
#include "Player.h"
#include "ScenarioMgr.h"
#include "StringFormat.h"
 
InstanceScenario::InstanceScenario(InstanceMap* map, ScenarioData const* scenarioData) : Scenario(map, scenarioData)
{
}
 
void InstanceScenario::LoadInstanceData()
{
    InstanceScript const* instanceScript = _map->ToInstanceMap()->GetInstanceScript();
    if (!instanceScript)
        return;
 
    std::vector<CriteriaTree const*> criteriaTrees;
 
    CriteriaList const& killCreatureCriteria = sCriteriaMgr->GetScenarioCriteriaByTypeAndScenario(CriteriaType::KillCreature, _data->Entry->ID);
    if (!killCreatureCriteria.empty())
    {
        if (std::vector<InstanceSpawnGroupInfo> const* spawnGroups = sObjectMgr->GetInstanceSpawnGroupsForMap(_map->GetId()))
        {
            std::unordered_map<uint32, uint64> despawnedCreatureCountsById;
            for (InstanceSpawnGroupInfo const& spawnGroup : *spawnGroups)
            {
                if (instanceScript->GetBossState(spawnGroup.BossStateId) != DONE)
                    continue;
 
                bool isDespawned = !((1 << DONE) & spawnGroup.BossStates) || (spawnGroup.Flags & InstanceSpawnGroupInfo::FLAG_BLOCK_SPAWN);
                if (isDespawned)
                    for (auto const& [spawnGroupId, spawn] : sObjectMgr->GetSpawnMetadataForGroup(spawnGroup.SpawnGroupId))
                        if (SpawnData const* spawnData = spawn->ToSpawnData())
                            ++despawnedCreatureCountsById[spawnData->id];
            }
 
            for (Criteria const* criteria : killCreatureCriteria)
            {
                // count creatures in despawned spawn groups
                if (uint64* progress = Trinity::Containers::MapGetValuePtr(despawnedCreatureCountsById, criteria->Entry->Asset.CreatureID))
                {
                    SetCriteriaProgress(criteria, *progress, nullptr, PROGRESS_SET);
 
                    if (CriteriaTreeList const* trees = sCriteriaMgr->GetCriteriaTreesByCriteria(criteria->ID))
                        for (CriteriaTree const* tree : *trees)
                            criteriaTrees.push_back(tree);
                }
            }
        }
    }
 
    for (Criteria const* criteria : sCriteriaMgr->GetScenarioCriteriaByTypeAndScenario(CriteriaType::DefeatDungeonEncounter, _data->Entry->ID))
    {
        if (!instanceScript->IsEncounterCompleted(criteria->Entry->Asset.DungeonEncounterID))
            continue;
 
        SetCriteriaProgress(criteria, 1, nullptr, PROGRESS_SET);
 
        if (CriteriaTreeList const* trees = sCriteriaMgr->GetCriteriaTreesByCriteria(criteria->ID))
            for (CriteriaTree const* tree : *trees)
                criteriaTrees.push_back(tree);
    }
 
    for (CriteriaTree const* tree : criteriaTrees)
    {
        ScenarioStepEntry const* step = tree->ScenarioStep;
        if (!step)
            continue;
 
        if (IsCompletedCriteriaTree(tree))
            SetStepState(step, SCENARIO_STEP_DONE);
    }
}
 
std::string InstanceScenario::GetOwnerInfo() const
{
    return Trinity::StringFormat("Instance ID {}", _map->GetInstanceId());
}
 
void InstanceScenario::SendPacket(WorldPacket const* data) const
{
    _map->SendToPlayers(data);
}