feat: add abnormal effects

L2BotDll/Versions/Interlude/Repositories/AbnormalEffectRepository.h

@@ -0,0 +1,120 @@
+#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;
+	};
+}