feat: add abnormal effects

L2BotCore/Domain/Entities/AbnormalEffect.h

@@ -0,0 +1,95 @@
+#pragma once
+#include <cstdint>
+#include <string>
+#include <vector>
+#include "EntityInterface.h"
+
+namespace L2Bot::Domain::Entities
+{
+	class AbnormalEffect : public EntityInterface
+	{
+	public:
+		const uint32_t GetId() const override
+		{
+			return m_SkillId;
+		}
+
+		void Update(const EntityInterface* other) override
+		{
+			const AbnormalEffect* casted = static_cast<const AbnormalEffect*>(other);
+			SaveState();
+
+			m_SkillId = casted->m_SkillId;
+			m_Level = casted->m_Level;
+			m_Name = casted->m_Name;
+			m_Description = casted->m_Description;
+			m_IconName = casted->m_IconName;
+		}
+		void SaveState() override
+		{
+			m_IsNewState = false;
+		}
+		const bool IsEqual(const EntityInterface* other) const override
+		{
+			const AbnormalEffect* casted = static_cast<const AbnormalEffect*>(other);
+			return m_SkillId == casted->m_SkillId &&
+				m_Level == casted->m_Level &&
+				m_Name == casted->m_Name &&
+				m_Description == casted->m_Description &&
+				m_IconName == casted->m_IconName;
+		}
+
+		const std::vector<Serializers::Node> BuildSerializationNodes() const override
+		{
+			std::vector<Serializers::Node> result;
+
+			result.push_back({ "skillId", std::to_string(m_SkillId) });
+			result.push_back({ "level", std::to_string(m_Level) });
+
+			if (m_IsNewState)
+			{
+				result.push_back({ "name", m_Name });
+				result.push_back({ "iconName", m_IconName });
+				result.push_back({ "description", m_Description });
+			}
+
+			return result;
+		}
+
+		AbnormalEffect(
+			const uint32_t skillId,
+			const uint8_t level,
+			const std::string& name,
+			const std::string& description,
+			const std::string& iconName
+		) :
+			m_SkillId(skillId),
+			m_Level(level),
+			m_Name(name),
+			m_Description(description),
+			m_IconName(iconName)
+		{
+
+		}
+
+		AbnormalEffect(const AbnormalEffect* other) :
+			m_SkillId(other->m_SkillId),
+			m_Level(other->m_Level),
+			m_Name(other->m_Name),
+			m_Description(other->m_Description),
+			m_IconName(other->m_IconName)
+		{
+		}
+
+		AbnormalEffect() = default;
+		virtual ~AbnormalEffect() = default;
+
+	private:
+		uint32_t m_SkillId = 0;
+		uint8_t m_Level = 0;
+		std::string m_Name = "";
+		std::string m_Description = "";
+		std::string m_IconName = "";
+		bool m_IsNewState = true;
+	};
+}

L2BotCore/L2BotCore.vcxproj

@@ -160,6 +160,7 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="Domain\DTO\EntityState.h" />
+    <ClInclude Include="Domain\Entities\AbnormalEffect.h" />
     <ClInclude Include="Domain\Entities\ArmorItem.h" />
     <ClInclude Include="Domain\Entities\EntityInterface.h" />
     <ClInclude Include="Domain\Entities\BaseItem.h" />

L2BotCore/L2BotCore.vcxproj.filters

@@ -135,6 +135,9 @@
     <ClInclude Include="Domain\Enums\ItemType.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Domain\Entities\AbnormalEffect.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="pch.cpp">

L2BotDll/Application.h

@@ -25,6 +25,7 @@ public:
 			m_AbstractFactory.GetPlayerRepository(),
 			m_AbstractFactory.GetSkillRepository(),
 			m_AbstractFactory.GetItemRepository(),
+			m_AbstractFactory.GetAbnormalEffectRepository(),
 			m_Serializer,
 			m_Transport
 		)

L2BotDll/L2BotDll.vcxproj

@@ -186,6 +186,7 @@
     <ClInclude Include="Versions\GameStructs\FNameInterface.h" />
     <ClInclude Include="Versions\GameStructs\GameEngineInterface.h" />
     <ClInclude Include="Versions\GameStructs\L2GameDataInterface.h" />
+    <ClInclude Include="Versions\Interlude\Factories\AbnormalEffectFactory.h" />
     <ClInclude Include="Versions\Interlude\Factories\HeroFactory.h" />
     <ClInclude Include="Versions\Interlude\Factories\ItemFactory.h" />
     <ClInclude Include="Versions\Interlude\Factories\NPCFactory.h" />
@@ -195,6 +196,7 @@
     <ClInclude Include="Versions\Interlude\GameStructs\L2GameDataWrapper.h" />
     <ClInclude Include="Versions\Interlude\GameStructs\FName.h" />
     <ClInclude Include="Transports\DebugViewTransport.h" />
+    <ClInclude Include="Versions\Interlude\Repositories\AbnormalEffectRepository.h" />
     <ClInclude Include="Versions\Interlude\Repositories\DropRepository.h" />
     <ClInclude Include="framework.h" />
     <ClInclude Include="Versions\GameStructs\FindObjectsTrait.h" />

L2BotDll/L2BotDll.vcxproj.filters

@@ -174,6 +174,12 @@
     <ClInclude Include="Events\ItemAutousedEvent.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Versions\Interlude\Factories\AbnormalEffectFactory.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Versions\Interlude\Repositories\AbnormalEffectRepository.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="dllmain.cpp">

L2BotDll/Services/WorldHandler.h

@@ -22,6 +22,7 @@ public:
 		Repositories::EntityRepositoryInterface& playerRepository,
 		Repositories::EntityRepositoryInterface& skillRepository,
 		Repositories::EntityRepositoryInterface& itemRepository,
+		Repositories::EntityRepositoryInterface& abnormalEffectService,
 		const Serializers::SerializerInterface& serializer,
 		Transports::TransportInterface& transport
 	) :
@@ -31,6 +32,7 @@ public:
 		m_PlayerService(Services::EntityService(playerRepository)),
 		m_SkillService(Services::EntityService(skillRepository)),
 		m_ItemService(Services::EntityService(itemRepository)),
+		m_AbnormalEffectService(Services::EntityService(abnormalEffectService)),
 		m_Serializer(serializer),
 		m_Transport(transport)
 	{
@@ -125,6 +127,7 @@ private:
 			Serializers::SerializableStateContainer{m_PlayerService.GetEntities(), "player"},
 			Serializers::SerializableStateContainer{m_SkillService.GetEntities(), "skill"},
 			Serializers::SerializableStateContainer{m_ItemService.GetEntities(), "item"},
+			Serializers::SerializableStateContainer{m_AbnormalEffectService.GetEntities(), "abnormalEffect"},
 		};
 
 		std::vector<Serializers::Node> result;
@@ -147,6 +150,7 @@ private:
 		m_PlayerService.Invalidate();
 		m_SkillService.Invalidate();
 		m_ItemService.Invalidate();
+		m_AbnormalEffectService.Invalidate();
 	}
 
 private:
@@ -156,6 +160,7 @@ private:
 	Services::EntityService m_PlayerService;
 	Services::EntityService m_SkillService;
 	Services::EntityService m_ItemService;
+	Services::EntityService m_AbnormalEffectService;
 	const Serializers::SerializerInterface& m_Serializer;
 	Transports::TransportInterface& m_Transport;
 	bool m_Stopped = false;

L2BotDll/Versions/Interlude/AbstractFactory.h

@@ -7,12 +7,14 @@
 #include "Factories/PlayerFactory.h"
 #include "Factories/SkillFactory.h"
 #include "Factories/ItemFactory.h"
+#include "Factories/AbnormalEffectFactory.h"
 #include "Repositories/DropRepository.h"
 #include "Repositories/HeroRepository.h"
 #include "Repositories/NPCRepository.h"
 #include "Repositories/PlayerRepository.h"
 #include "Repositories/SkillRepository.h"
 #include "Repositories/ItemRepository.h"
+#include "Repositories/AbnormalEffectRepository.h"
 #include "GameStructs/NetworkHandlerWrapper.h"
 #include "GameStructs/GameEngineWrapper.h"
 #include "GameStructs/L2GameDataWrapper.h"
@@ -101,6 +103,16 @@ namespace Interlude
 			);
 			return result;
 		}
+		AbnormalEffectRepository& GetAbnormalEffectRepository() const override
+		{
+			static auto factory = AbnormalEffectFactory(GetL2GameData(), GetFName());
+			static EntityHandler handler;
+			static auto result = AbnormalEffectRepository(
+				factory,
+				handler
+			);
+			return result;
+		}
 		NetworkHandlerWrapper& GetNetworkHandler() const override
 		{
 			static NetworkHandlerWrapper result;

L2BotDll/Versions/Interlude/Factories/AbnormalEffectFactory.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <memory>
+#include <map>
+#include <chrono>
+#include "../GameStructs/L2GameDataWrapper.h"
+#include "../GameStructs/FName.h"
+#include "../../../Common/Common.h"
+#include "Domain/Entities/AbnormalEffect.h"
+
+using namespace L2Bot::Domain;
+
+namespace Interlude
+{
+	class AbnormalEffectFactory
+	{
+	public:
+		AbnormalEffectFactory(const L2GameDataWrapper& l2GameData, const FName& fName) :
+			m_L2GameData(l2GameData),
+			m_FName(fName)
+		{
+		}
+
+		AbnormalEffectFactory() = delete;
+		virtual ~AbnormalEffectFactory() = default;
+
+		std::unique_ptr<Entities::AbnormalEffect> Create(const uint32_t skillId, const uint32_t level) const
+		{
+			const auto data = m_L2GameData.GetMSData(skillId, level);
+
+			const auto name = data && data->name ? data->name : L"";
+			const auto description = data && data->description ? data->description : L"";
+			const auto iconEntry = data ? m_FName.GetEntry(data->iconNameIndex) : nullptr;
+
+			return std::make_unique<Entities::AbnormalEffect>(
+				skillId,
+				static_cast<uint8_t>(level),
+				ConvertFromWideChar(name),
+				ConvertFromWideChar(description),
+				iconEntry ? ConvertFromWideChar(iconEntry->value) : ""
+			);
+		}
+
+	private:
+		const L2GameDataWrapper& m_L2GameData;
+		const FName& m_FName;
+	};
+}

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;
+	};
+}

L2BotDll/Versions/Interlude/Repositories/SkillRepository.h

@@ -190,9 +190,9 @@ namespace Interlude
 					ids[skillInfo[i]] = skillInfo[i + 2];
 				}
 
-				for (auto it = m_Skills.begin(); it != m_Skills.end();)
+				for (const auto& kvp : m_Skills)
 				{
-					const auto& skill = it->second;
+					const auto& skill = kvp.second;
 
 					const auto needToToggle = ids.find(skill->GetId()) != ids.end();
 					// buff time less than zero means this is a aura
@@ -206,10 +206,6 @@ namespace Interlude
 					{
 						skill->UpdateToggle(true);
 					}
-					else
-					{
-						++it;
-					}
 				}
 			}
 		}

L2BotDll/Versions/VersionAbstractFactory.h

@@ -22,6 +22,7 @@ public:
 	virtual Repositories::EntityRepositoryInterface& GetPlayerRepository() const = 0;
 	virtual Repositories::EntityRepositoryInterface& GetSkillRepository() const = 0;
 	virtual Repositories::EntityRepositoryInterface& GetItemRepository() const = 0;
+	virtual Repositories::EntityRepositoryInterface& GetAbnormalEffectRepository() const = 0;
 	virtual NetworkHandlerInterface& GetNetworkHandler() const = 0;
 	virtual GameEngineInterface& GetGameEngine() const = 0;
 	virtual L2GameDataInterface& GetL2GameData() const = 0;