120 lines
3.0 KiB
C++
120 lines
3.0 KiB
C++
#pragma once
|
|
|
|
#include <map>
|
|
#include <chrono>
|
|
#include <shared_mutex>
|
|
#include "Domain/Repositories/EntityRepositoryInterface.h"
|
|
#include "../Factories/AbnormalEffectFactory.h"
|
|
#include "../../../Events/AbnormalEffectChangedEvent.h"
|
|
#include "../../../Events/HeroDeletedEvent.h"
|
|
#include "../../../Events/EventDispatcher.h"
|
|
#include "../GameStructs/NetworkHandlerWrapper.h"
|
|
#include "../../../Services/EntityHandler.h"
|
|
|
|
using namespace L2Bot::Domain;
|
|
|
|
namespace Interlude
|
|
{
|
|
class AbnormalEffectRepository : public Repositories::EntityRepositoryInterface
|
|
{
|
|
public:
|
|
const std::vector<std::shared_ptr<DTO::EntityState>> GetEntities() override
|
|
{
|
|
std::unique_lock<std::shared_timed_mutex>(m_Mutex);
|
|
|
|
std::map<uint32_t, Entities::AbnormalEffect*> skillPtrs;
|
|
for (const auto& kvp : m_Effects)
|
|
{
|
|
skillPtrs[kvp.first] = kvp.second.get();
|
|
}
|
|
|
|
const auto objects = m_EntityHandler.GetEntities<Entities::AbnormalEffect*>(skillPtrs, [this](Entities::AbnormalEffect* item) {
|
|
return std::make_unique<Entities::AbnormalEffect>(item);
|
|
});
|
|
|
|
auto result = std::vector<std::shared_ptr<DTO::EntityState>>();
|
|
|
|
for (const auto kvp : objects)
|
|
{
|
|
result.push_back(kvp.second);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
AbnormalEffectRepository(const AbnormalEffectFactory& factory, EntityHandler& handler) :
|
|
m_Factory(factory),
|
|
m_EntityHandler(handler)
|
|
{
|
|
EventDispatcher::GetInstance().Subscribe(AbnormalEffectChangedEvent::name, [this](const Event& evt) {
|
|
OnEffectToggled(evt);
|
|
});
|
|
EventDispatcher::GetInstance().Subscribe(HeroDeletedEvent::name, [this](const Event& evt) {
|
|
OnHeroDeleted(evt);
|
|
});
|
|
}
|
|
|
|
AbnormalEffectRepository() = delete;
|
|
virtual ~AbnormalEffectRepository()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void Reset() override
|
|
{
|
|
std::shared_lock<std::shared_timed_mutex>(m_Mutex);
|
|
m_Effects.clear();
|
|
}
|
|
|
|
void OnHeroDeleted(const Event& evt)
|
|
{
|
|
std::shared_lock<std::shared_timed_mutex>(m_Mutex);
|
|
if (evt.GetName() == HeroDeletedEvent::name)
|
|
{
|
|
Reset();
|
|
}
|
|
}
|
|
|
|
void OnEffectToggled(const Event& evt)
|
|
{
|
|
std::shared_lock<std::shared_timed_mutex>(m_Mutex);
|
|
if (evt.GetName() == AbnormalEffectChangedEvent::name)
|
|
{
|
|
const auto casted = static_cast<const AbnormalEffectChangedEvent&>(evt);
|
|
const auto skillInfo = casted.GetSkillInfo();
|
|
|
|
std::map<uint32_t, int32_t> ids;
|
|
for (size_t i = 0; i < skillInfo.size(); i += 3)
|
|
{
|
|
const auto effectId = skillInfo[i];
|
|
const auto level = skillInfo[i + 1];
|
|
|
|
auto effect = m_Factory.Create(effectId, level);
|
|
m_Effects.emplace(effect->GetId(), std::move(effect));
|
|
|
|
ids[effectId] = effectId;
|
|
}
|
|
|
|
for (auto it = m_Effects.begin(); it != m_Effects.end();)
|
|
{
|
|
const auto& effect = it->second;
|
|
|
|
if (ids.find(effect->GetId()) == ids.end())
|
|
{
|
|
it = m_Effects.erase(it);
|
|
}
|
|
else
|
|
{
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
const AbnormalEffectFactory& m_Factory;
|
|
std::map<uint32_t, std::unique_ptr<Entities::AbnormalEffect>> m_Effects;
|
|
std::shared_timed_mutex m_Mutex;
|
|
EntityHandler& m_EntityHandler;
|
|
};
|
|
} |