AdventuresInLestoria/Adventures in Lestoria/Player.h

#pragma region License
/*
License (OLC-3)
~~~~~~~~~~~~~~~

Copyright 2024 Joshua Sigona <sigonasr2@gmail.com>

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

1. Redistributions or derivations of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.

2. Redistributions or derivative works in binary form must reproduce the above
copyright notice. This list of conditions and the following	disclaimer must be
reproduced in the documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its contributors may
be used to endorse or promote products derived from this software without specific
prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS	"AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL,	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

Portions of this software are copyright © 2024 The FreeType
Project (www.freetype.org). Please see LICENSE_FT.txt for more information.
All rights reserved.
*/
#pragma endregion
#pragma once
#include "olcUTIL_Animate2D.h"
#include "Animation.h"
#include "Monster.h"
#include "State.h"
#include "Ability.h"
#include "Buff.h"
#include "Pathfinding.h"
#include "config.h"
#include "Key.h"
#include "Class.h"
#include "Item.h"
#include "AttributableStat.h"


#undef GetClassName
struct DamageNumber;
class MenuComponent;
struct Ability;

struct CastInfo{
	std::string name="???";
	float castTimer=0.f;
	float castTotalTime=0.f;
	vf2d castPos{};
};

namespace MoveFlag{
	enum MoveFlag{
		NONE					=	0b0,
		PREVENT_CAST_CANCELLING	=	0b1,
	};
};

namespace PlayerTest{
	class PlayerTests;
}

class EntityStats{
	friend class Inventory;
	ItemAttributable equipStats; //The stats after gear calculations are applied.
	ItemAttributable baseStats;
public:
	void RecalculateEquipStats(); //Called when equipment is updated.
	const ItemAttributable&GetStats()const;
	const ItemAttributable&GetBaseStats()const;
	//Get stats with equipment applied.
	const float&GetEquipStat(ItemAttribute stat)const;
	 //Get stats with equipment applied.
	const float&GetEquipStat(std::string_view stat)const;
	const float&GetBaseStat(ItemAttribute stat)const;
	const float&GetBaseStat(std::string_view stat)const;
	void SetBaseStat(ItemAttribute a,float val);
	void SetBaseStat(std::string_view a,float val);
	void Reset();
};

class Player{
	friend class AiL;
	friend class sig::Animation;
	friend struct Warrior;
	friend struct Thief;
	friend struct Ranger;
	friend struct Trapper;
	friend struct Wizard;
	friend struct Witch;
	friend class State_GameRun;
	friend class Inventory;
	friend void ItemOverlay::Draw();
	friend class PlayerTests::PlayerTest;
	friend class ItemTests::ItemTest;
public:
	Player();
	//So this is rather fascinating and only exists because we have the ability to change classes which means we need to initialize a class
	//using a new object type... Because of that we'll take the pointer reference to the old object and copy some of its properties to this new
	//one. It's hackish but it means we can reduce the amount of extra boilerplate when class changing...I don't know how to feel about this.
	Player(Player*player);
	static float GROUND_SLAM_SPIN_TIME;
	vf2d&GetPos()const;
	float GetX();
	float GetY();
	float GetZ();
	const float&GetEquipStat(ItemAttribute a)const;
	const float&GetEquipStat(std::string_view a)const;
	const float&GetBaseStat(ItemAttribute a)const;
	const float&GetBaseStat(std::string_view a)const;
	void SetBaseStat(std::string_view a,float val);
	void SetBaseStat(ItemAttribute a,float val);
	const int GetMaxHealth()const;
	const int GetHealth()const;
	const int GetMana()const;
	const int GetMaxMana()const;
	const int GetAttack()const;
	const int GetDefense()const;
	const float GetDamageReductionFromBuffs()const;
	const float GetDamageReductionFromArmor()const;
	float GetMoveSpdMult();
	float GetSizeMult()const;
	const float GetCooldownReductionPct()const;
	const float GetCritRatePct()const;
	const float GetCritDmgPct()const;
	const float GetHPRecoveryPct()const;
	const float GetHP6RecoveryPct()const;
	const float GetHP4RecoveryPct()const;
	const float GetDamageReductionPct()const;
	const float GetAttackRecoveryRateReduction()const;
	void SetSizeMult(float size);
	float GetAttackRangeMult();
	float GetSpinAngle();
	State::State GetState();
	Key GetFacingDirection();
	vf2d GetVelocity();
	bool HasIframes();
	void Update(float fElapsedTime);
	void UpdateWalkingAnimation(Key direction, const float frameMult=1.f);
	void UpdateIdleAnimation(Key direction);
	//The range is the search range in tiles.
	bool CanPathfindTo(vf2d pos,vf2d targetPos,float range=8);
	bool CanMove();
	bool CanAct();
	const bool CanAct(const Ability&ability);
	void Knockback(vf2d vel);
	void ProximityKnockback(const vf2d centerPoint,const float knockbackFactor);
	void ApplyIframes(float duration);
	//NOTE: Will directly override the iframe timer for the player, as opposed to _ApplyIframes which actually keeps the longest current iframe time.
	void _SetIframes(float duration);
	void RestoreMana(int amt,bool suppressDamageNumber=false);
	void ConsumeMana(int amt);
	//Returns true if the move was valid and successful.
	bool SetX(float x,MoveFlag::MoveFlag flags=MoveFlag::NONE);
	//Returns true if the move was valid and successful.
	bool SetY(float y,MoveFlag::MoveFlag flags=MoveFlag::NONE);
	void SetZ(float z);
	//Returns true if the move was valid and successful.
	bool SetPos(vf2d pos,MoveFlag::MoveFlag flags=MoveFlag::NONE);
	//Ignores collision checking and sets the player at the given position.
	void ForceSetPos(vf2d pos);
	void SetState(State::State newState);
	
	void AddBuff(BuffType type,float duration,float intensity);
	//NOTE: If adding a % increase stat, please use the percentage version! 100% = 1!!
	void AddBuff(BuffType type,float duration,float intensity,std::set<ItemAttribute>attr);
	//NOTE: If adding a % increase stat, please use the percentage version! 100% = 1!!
	void AddBuff(BuffType type,float duration,float intensity,std::set<std::string>attr);
	void AddBuff(BuffType type,float duration,float intensity,float timeBetweenTicks,std::function<void(AiL*,int)>repeatAction);

	const std::vector<Buff>GetBuffs(BuffType buff)const;
	const std::vector<Buff>GetStatBuffs(const std::vector<std::string>&attr)const;
	//Removes the first buff found.
	void RemoveBuff(BuffType type);
	//Removes all buffs of a certain type.
	void RemoveAllBuffs(BuffType type);
	//Remove every buff.
	void RemoveAllBuffs();

	void UpdateHealthAndMana();

	void RecalculateEquipStats();

	bool Hurt(int damage,bool onUpperLevel,float z);
	//Return false if healing was not possible.
	bool Heal(int damage,bool suppressDamageNumber=false);
	//specificClass is a bitwise-combination of classes from the Class enum. It makes sure certain animations only play if you are a certain class.=
	void UpdateAnimation(std::string animState,int specificClass=ANY,const float frameMult=1.f);
	Animate2D::Frame GetFrame();
	float GetSwordSwingTimer();
	bool OnUpperLevel();
	void ResetLastCombatTime();
	bool IsOutOfCombat();
	float GetEndZoneStandTime();
	//Triggers when the player has moved.
	void Moved(MoveFlag::MoveFlag flags=MoveFlag::NONE);
	virtual ~Player()=default;
	virtual Class GetClass()=0;
	virtual bool AutoAttack()=0;
	virtual void OnUpdate(float fElapsedTime)=0;
	virtual const std::string&GetClassName()=0;
	virtual Ability&GetRightClickAbility()=0;
	virtual Ability&GetAbility1()=0;
	virtual Ability&GetAbility2()=0;
	virtual Ability&GetAbility3()=0;
	virtual Ability&GetAbility4()=0;
	virtual std::string&GetWalkNAnimation()=0;
	virtual std::string&GetWalkEAnimation()=0;
	virtual std::string&GetWalkSAnimation()=0;
	virtual std::string&GetWalkWAnimation()=0;
	virtual std::string&GetIdleNAnimation()=0;
	virtual std::string&GetIdleEAnimation()=0;
	virtual std::string&GetIdleSAnimation()=0;
	virtual std::string&GetIdleWAnimation()=0;

	geom2d::circle<float>Hitbox();

	void CheckEndZoneCollision();

	CastInfo&GetCastInfo();
	//Provide the base animation name and this function does the rest. Ex. If you want WARRIOR_SWINGSWORD_S, use SWINGSWORD
	void SetAnimationBasedOnTargetingDirection(const std::string_view animation_name,float targetDirection);
	void SetAnimationBasedOnTarget(const std::string_view animation_name,const vf2d&target);

	void SetItem1UseFunc(Ability a);
	void SetItem2UseFunc(Ability a);
	void SetItem3UseFunc(Ability a);
	void PerformHPRecovery();

	static InputGroup KEY_ABILITY1, KEY_ABILITY2, KEY_ABILITY3, KEY_ABILITY4, KEY_DEFENSIVE, KEY_ITEM1, KEY_ITEM2, KEY_ITEM3;
	static std::vector<std::weak_ptr<MenuComponent>>moneyListeners;
	
    static void AddMoneyListener(std::weak_ptr<MenuComponent>component);
	uint32_t GetMoney()const;
	void SetMoney(uint32_t newMoney);
	void AddXP(const uint32_t xpGain);
	void OnLevelUp();
	const uint8_t LevelCap()const;
	const uint8_t Level()const;
	const uint32_t CurrentXP()const;
	const uint32_t TotalXP()const;
	const uint32_t NextLevelXPRequired()const;

	void CancelCast();
	const ItemAttributable&GetStats()const;
	const ItemAttributable&GetBaseStats()const;
	void ResetAccumulatedXP();
	const uint32_t GetAccumulatedXP()const;
	void AddAccumulatedXP(const uint32_t xpGain);
	//Knockup the player for duration amount of seconds, and Zamt pixels.
	void Knockup(float duration);
	static const bool INVERTED,USE_WALK_DIR;
	const vf2d GetAimingLocation(bool useWalkDir=false,bool invert=false);
	const vf2d GetWorldAimingLocation(bool useWalkDir=false,bool invert=false);
	void SetXP(const uint32_t xp);
	void SetTotalXPEarned(const uint32_t totalXP);
	void SetLevel(uint8_t newLevel);
	void SetInvisible(const bool invisibleState);
	const bool IsInvisible()const;
	void ResetVelocity();
	const float GetHealthGrowthRate()const;
	const float GetAtkGrowthRate()const;
	const float GetIframeTime()const;
	const Renderable&GetMinimapImage()const;
	void AddVelocity(vf2d vel);
	const float GetHealthRatio()const;
	const bool IsAlive()const;
	//An all-in-one function that applies a stat plus any % modifiers the stat may have as well.
	const float GetModdedStatBonuses(std::string_view stat)const;
	//An all-in-one function that applies a stat plus any % modifiers the stat may have as well.
	const float GetModdedStatBonuses(ItemAttribute stat)const;
	//Flag to make the player character render using additive blending / normal blending.
	void SetAdditiveBlending(const bool additiveBlending);
	const bool IsUsingAdditiveBlending()const;
	vf2d MoveUsingPathfinding(vf2d targetPos);
	const std::unordered_set<std::string>&GetMyClass()const;
private:
	int hp="Warrior.BaseHealth"_I;
	int mana="Player.BaseMana"_I;
	float hpGrowthRate="Warrior.HealthGrowthRate"_F;
	float atkGrowthRate="Warrior.AtkGrowthRate"_F;
	vf2d pos;
	uint8_t level=1;
	uint8_t levelCap=1;
	uint32_t totalXPEarned=0;
	uint32_t currentLevelXP=0;
	uint32_t accumulatedXP=0;
	float z=0;
	float size=1.0f;
	float spin_attack_timer=0;
	float rolling_timer{};
	float spin_spd=0;
	float spin_angle=0;
	float lastAnimationFlip=0;
	float manaTickTimer=0;
	float hpRecoveryTimer=0;
	float hp6RecoveryTimer=0;
	float hp4RecoveryTimer=0;
	float knockUpTimer=0.f;
	float totalKnockupTime=0.f;
	float knockUpZAmt=0.f;
	//angle in polar coords.
	vf2d aimingAngle{};
	std::pair<std::string,float> notEnoughManaDisplay={"",0.f};
	float teleportAttemptWaitTime=0; //If a teleport fails, we wait awhile before trying again, it's expensive.
	State::State state=State::NORMAL;
	Animate2D::Animation<std::string>animation;
	Animate2D::AnimationState internal_animState;
	void AddAnimation(std::string state);
	std::vector<Buff>buffList;
	CastInfo castInfo={"",0};
	vf2d movementVelocity={};//This tells us if the player is moving (mostly controlled by user input) since their velocity is not used for regular movement.
	float lastHitTimer=0; //When this is greater than zero, if we get hit again it adds to our displayed combo number.
	std::shared_ptr<DamageNumber>damageNumberPtr;
	void Initialize();
	float iframe_time=0;
	float lastCombatTime=0;
	float hurtRumbleTime=0.0f;
	Ability useItem1;
	Ability useItem2;
	Ability useItem3;
	uint32_t money="Player.Starting Money"_I;
	EntityStats stats;
	//So this is kind of a stupid one...
	//If the attr provided is a % modifier, it will take the lhs in a += operation and multiply it by the % modifier from player's actual stats.
	//If the attr provided is not a % modifier, it will add in a +=/+ operation...
	const ItemAttribute&GetBonusStat(std::string_view attr)const;
	bool rendered=false;
	bool invisibility=false;
	//Returns true if the move was valid and successful.
	//If playerInvoked is true, this means the player was the one that instantiated this input, and it's not an extra movement done via collision.
	//Set playerInvoked to false when you don't want a movement loop due to collisions.
	//Typical usage is playerInvoked is true on first call, and playerInvoked is false on all subsequent chained calls.
	bool _SetX(float x,MoveFlag::MoveFlag flags=MoveFlag::NONE,const bool playerInvoked=true);
	//Returns true if the move was valid and successful.
	//If playerInvoked is true, this means the player was the one that instantiated this input, and it's not an extra movement done via collision.
	//Set playerInvoked to false when you don't want a movement loop due to collisions.
	//Typical usage is playerInvoked is true on first call, and playerInvoked is false on all subsequent chained calls.
	bool _SetY(float y,MoveFlag::MoveFlag flags=MoveFlag::NONE,const bool playerInvoked=true);
	const bool UsingAutoAim()const;
	void InitializeMinimapImage();
	bool lowHealthSoundPlayed=false;
	float lowHealthSoundPlayedTimer=0.f;
	float rangerShootAnimationTimer=0.f;
	Renderable minimapImg; //An image of the character represented on a minimap. Should be 12x12 and generally be a circle.
	void CheckAndPerformAbility(Ability&ability,InputGroup key);
	float deadlyDashWaitTimer{};
	float deadlyDashAfterDashTimer{};
	vf2d deadlyDashEndingPos{};
	bool renderedSpriteUsesAdditiveBlending{false};
	float deadlyDashAdditiveBlendingToggleTimer{};
	std::unordered_set<std::string>myClass{};
protected:
	const float ATTACK_COOLDOWN="Warrior.Auto Attack.Cooldown"_F;
	const float MAGIC_ATTACK_COOLDOWN="Wizard.Auto Attack.Cooldown"_F;
	float ARROW_ATTACK_COOLDOWN="Ranger.Auto Attack.Cooldown"_F;
	void SetSwordSwingTimer(float val);
	void SetFacingDirection(Key direction);
	void Spin(float duration,float spinSpd);
	float friction="Player.Friction"_F;
	float attack_cooldown_timer=0;
	float teleportAnimationTimer=0;
	vf2d teleportTarget={};
	vf2d teleportStartPosition={};
	std::pair<std::string,float> notificationDisplay={"",0.f};
	bool upperLevel=false;
	vf2d vel={0,0};
	float attack_range="Warrior.Auto Attack.Range"_F/100.f;
	Key facingDirection=DOWN;
	float swordSwingTimer=0;
	void CastSpell(Ability&ability);
	Ability*castPrepAbility;
	void PrepareCast(Ability&ability);
	vf2d precastLocation={};
	void SetVelocity(vf2d vel);
	const float RETREAT_DISTANCE=24*"Ranger.Right Click Ability.RetreatDistance"_F/100;
	float RETREAT_TIME="Ranger.Right Click Ability.RetreatTime"_F; //How long the Retreat ability takes.
	const int RETREAT_GHOST_FRAMES=8;
	const float RETREAT_GHOST_FRAME_DELAY=0.025f;
	float ghostFrameTimer=0;
	float ghostRemoveTimer=0;
	float blockTimer=0;
	float retreatTimer=0;
	std::vector<vf2d>ghostPositions;
	float rapidFireTimer=0;
	int remainingRapidFireShots=0;
	float endZoneStandTime=0;
	float lastPathfindingCooldown=0.f;
	const float RAPID_FIRE_SHOOT_DELAY="Ranger.Ability 1.ArrowDelay"_F;
	const int RAPID_FIRE_SHOOT_AMOUNT="Ranger.Ability 1.ArrowCount"_I;
	float footstepTimer=0.f;
	float ySquishFactor{1.f};
	size_t cooldownSoundInstance=std::numeric_limits<size_t>::max();
};

#pragma region Warrior
struct Warrior:Player{
	static std::string name;
	static Class cl;
	static Ability rightClickAbility,ability1,ability2,ability3,ability4;
	static std::string walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
	static void Initialize();
	Warrior();
	Warrior(Player*player);
	Class GetClass()override;
	bool AutoAttack()override;
	//Include only WARRIOR-specific implementations!
	void OnUpdate(float fElapsedTime)override;
	static void InitializeClassAbilities();
	const std::string&GetClassName()override;
	Ability&GetRightClickAbility()override;
	Ability&GetAbility1()override;
	Ability&GetAbility2()override;
	Ability&GetAbility3()override;
	Ability&GetAbility4()override;
	std::string&GetWalkNAnimation()override;
	std::string&GetWalkEAnimation()override;
	std::string&GetWalkSAnimation()override;
	std::string&GetWalkWAnimation()override;
	std::string&GetIdleNAnimation()override;
	std::string&GetIdleEAnimation()override;
	std::string&GetIdleSAnimation()override;
	std::string&GetIdleWAnimation()override;
};
#pragma endregion

#pragma region Thief
struct Thief:Player{
	static std::string name;
	static Class cl;
	static Ability rightClickAbility,ability1,ability2,ability3,ability4;
	static std::string walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
	static void Initialize();
	Thief();
	Thief(Player*player);
	Class GetClass()override;
	bool AutoAttack()override;
	//Include only THIEF-specific implementations!
	void OnUpdate(float fElapsedTime)override;
	static void InitializeClassAbilities();
	const std::string&GetClassName()override;
	Ability&GetRightClickAbility()override;
	Ability&GetAbility1()override;
	Ability&GetAbility2()override;
	Ability&GetAbility3()override;
	Ability&GetAbility4()override;
	std::string&GetWalkNAnimation()override;
	std::string&GetWalkEAnimation()override;
	std::string&GetWalkSAnimation()override;
	std::string&GetWalkWAnimation()override;
	std::string&GetIdleNAnimation()override;
	std::string&GetIdleEAnimation()override;
	std::string&GetIdleSAnimation()override;
	std::string&GetIdleWAnimation()override;
};
#pragma endregion

#pragma region Ranger
struct Ranger:Player{
	static std::string name;
	static Class cl;
	static Ability rightClickAbility,ability1,ability2,ability3,ability4;
	static std::string walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
	static void Initialize();
	Ranger();
	Ranger(Player*player);
	Class GetClass()override;
	bool AutoAttack()override;
	//Include only RANGER-specific implementations!
	void OnUpdate(float fElapsedTime)override;
	static void InitializeClassAbilities();
	const std::string&GetClassName()override;
	Ability&GetRightClickAbility()override;
	Ability&GetAbility1()override;
	Ability&GetAbility2()override;
	Ability&GetAbility3()override;
	Ability&GetAbility4()override;
	std::string&GetWalkNAnimation()override;
	std::string&GetWalkEAnimation()override;
	std::string&GetWalkSAnimation()override;
	std::string&GetWalkWAnimation()override;
	std::string&GetIdleNAnimation()override;
	std::string&GetIdleEAnimation()override;
	std::string&GetIdleSAnimation()override;
	std::string&GetIdleWAnimation()override;
};
#pragma endregion

#pragma region Trapper
struct Trapper:Player{
	static std::string name;
	static Class cl;
	static Ability rightClickAbility,ability1,ability2,ability3,ability4;
	static std::string walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
	static void Initialize();
	Trapper();
	Trapper(Player*player);
	Class GetClass()override;
	bool AutoAttack()override;
	//Include only TRAPPER-specific implementations!
	void OnUpdate(float fElapsedTime)override;
	static void InitializeClassAbilities();
	const std::string&GetClassName()override;
	Ability&GetRightClickAbility()override;
	Ability&GetAbility1()override;
	Ability&GetAbility2()override;
	Ability&GetAbility3()override;
	Ability&GetAbility4()override;
	std::string&GetWalkNAnimation()override;
	std::string&GetWalkEAnimation()override;
	std::string&GetWalkSAnimation()override;
	std::string&GetWalkWAnimation()override;
	std::string&GetIdleNAnimation()override;
	std::string&GetIdleEAnimation()override;
	std::string&GetIdleSAnimation()override;
	std::string&GetIdleWAnimation()override;
};
#pragma endregion

#pragma region Wizard
struct Wizard:Player{
	static std::string name;
	static Class cl;
	static Ability rightClickAbility,ability1,ability2,ability3,ability4;
	static std::string walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
	static void Initialize();
	Wizard();
	Wizard(Player*player);
	Class GetClass()override;
	bool AutoAttack()override;
	//Include only WIZARD-specific implementations!
	void OnUpdate(float fElapsedTime)override;
	static void InitializeClassAbilities();
	const std::string&GetClassName()override;
	Ability&GetRightClickAbility()override;
	Ability&GetAbility1()override;
	Ability&GetAbility2()override;
	Ability&GetAbility3()override;
	Ability&GetAbility4()override;
	std::string&GetWalkNAnimation()override;
	std::string&GetWalkEAnimation()override;
	std::string&GetWalkSAnimation()override;
	std::string&GetWalkWAnimation()override;
	std::string&GetIdleNAnimation()override;
	std::string&GetIdleEAnimation()override;
	std::string&GetIdleSAnimation()override;
	std::string&GetIdleWAnimation()override;
};
#pragma endregion

#pragma region Witch
struct Witch:Player{
	static std::string name;
	static Class cl;
	static Ability rightClickAbility,ability1,ability2,ability3,ability4;
	static std::string walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
	static void Initialize();
	Witch();
	Witch(Player*player);
	Class GetClass()override;
	bool AutoAttack()override;
	//Include only WITCHs-specific implementations!
	void OnUpdate(float fElapsedTime)override;
	static void InitializeClassAbilities();
	const std::string&GetClassName()override;
	Ability&GetRightClickAbility()override;
	Ability&GetAbility1()override;
	Ability&GetAbility2()override;
	Ability&GetAbility3()override;
	Ability&GetAbility4()override;
	std::string&GetWalkNAnimation()override;
	std::string&GetWalkEAnimation()override;
	std::string&GetWalkSAnimation()override;
	std::string&GetWalkWAnimation()override;
	std::string&GetIdleNAnimation()override;
	std::string&GetIdleEAnimation()override;
	std::string&GetIdleSAnimation()override;
	std::string&GetIdleWAnimation()override;
};
#pragma endregion

#define READFROMCONFIG(class,enum) \
	class::name=#class".ClassName"_S; \
	class::cl=enum; \
	class::rightClickAbility={ \
		#class".Right Click Ability.Name"_S, \
		#class".Right Click Ability.Short Name"_S, \
		#class".Right Click Ability.Description"_s.concat(), \
		#class".Right Click Ability.Cooldown"_F, \
		#class".Right Click Ability.Mana Cost"_I, \
		&KEY_DEFENSIVE, \
		"Ability Icons/"+#class".Right Click Ability.Icon"_S, \
		{uint8_t(#class".Right Click Ability.Cooldown Bar Color 1"_f[0]),uint8_t(#class".Right Click Ability.Cooldown Bar Color 1"_f[1]),uint8_t(#class".Right Click Ability.Cooldown Bar Color 1"_f[2]),uint8_t(#class".Right Click Ability.Cooldown Bar Color 1"_f[3]==0?255:#class".Right Click Ability.Cooldown Bar Color 1"_f[3])}, \
		{uint8_t(#class".Right Click Ability.Cooldown Bar Color 2"_f[0]),uint8_t(#class".Right Click Ability.Cooldown Bar Color 2"_f[1]),uint8_t(#class".Right Click Ability.Cooldown Bar Color 2"_f[2]),uint8_t(#class".Right Click Ability.Cooldown Bar Color 2"_f[3]==0?255:#class".Right Click Ability.Cooldown Bar Color 2"_f[3])}, \
		{#class".Right Click Ability.Precast Time"_F,#class".Right Click Ability.Casting Range"_I/100.f*24,#class".Right Click Ability.Casting Size"_I/100.f*24}, \
		bool( #class".Right Click Ability.CancelCast"_I ) \
	}; \
	class::ability1={ \
		#class".Ability 1.Name"_S, \
		#class".Ability 1.Short Name"_S, \
		#class".Ability 1.Description"_s.concat(), \
		#class".Ability 1.Cooldown"_F, \
		#class".Ability 1.Mana Cost"_I, \
		&KEY_ABILITY1, \
		"Ability Icons/"+#class".Ability 1.Icon"_S, \
		{uint8_t(#class".Ability 1.Cooldown Bar Color 1"_f[0]),uint8_t(#class".Ability 1.Cooldown Bar Color 1"_f[1]),uint8_t(#class".Ability 1.Cooldown Bar Color 1"_f[2]),uint8_t(#class".Ability 1.Cooldown Bar Color 1"_f[3]==0?255:#class".Ability 1.Cooldown Bar Color 1"_f[3])}, \
		{uint8_t(#class".Ability 1.Cooldown Bar Color 2"_f[0]),uint8_t(#class".Ability 1.Cooldown Bar Color 2"_f[1]),uint8_t(#class".Ability 1.Cooldown Bar Color 2"_f[2]),uint8_t(#class".Ability 1.Cooldown Bar Color 2"_f[3]==0?255:#class".Ability 1.Cooldown Bar Color 2"_f[3])}, \
		{#class".Ability 1.Precast Time"_F,#class".Ability 1.Casting Range"_I/100.f*24,#class".Ability 1.Casting Size"_I/100.f*24}, \
		bool(#class".Ability 1.CancelCast"_I) \
	}; \
	class::ability2={ \
		#class".Ability 2.Name"_S, \
		#class".Ability 2.Short Name"_S, \
		#class".Ability 2.Description"_s.concat(), \
		#class".Ability 2.Cooldown"_F, \
		#class".Ability 2.Mana Cost"_I, \
		&KEY_ABILITY2, \
		"Ability Icons/"+#class".Ability 2.Icon"_S, \
		{uint8_t(#class".Ability 2.Cooldown Bar Color 1"_f[0]),uint8_t(#class".Ability 2.Cooldown Bar Color 1"_f[1]),uint8_t(#class".Ability 2.Cooldown Bar Color 1"_f[2]),uint8_t(#class".Ability 2.Cooldown Bar Color 1"_f[3]==0?255:#class".Ability 2.Cooldown Bar Color 1"_f[3])}, \
		{uint8_t(#class".Ability 2.Cooldown Bar Color 2"_f[0]),uint8_t(#class".Ability 2.Cooldown Bar Color 2"_f[1]),uint8_t(#class".Ability 2.Cooldown Bar Color 2"_f[2]),uint8_t(#class".Ability 2.Cooldown Bar Color 2"_f[3]==0?255:#class".Ability 2.Cooldown Bar Color 2"_f[3])}, \
		{#class".Ability 2.Precast Time"_F,#class".Ability 2.Casting Range"_I/100.f*24,#class".Ability 2.Casting Size"_I/100.f*24}, \
		bool(#class".Ability 2.CancelCast"_I) \
	}; \
	class::ability3={ \
		#class".Ability 3.Name"_S, \
		#class".Ability 3.Short Name"_S, \
		#class".Ability 3.Description"_s.concat(), \
		#class".Ability 3.Cooldown"_F, \
		#class".Ability 3.Mana Cost"_I, \
		&KEY_ABILITY3, \
		"Ability Icons/"+#class".Ability 3.Icon"_S, \
		{uint8_t(#class".Ability 3.Cooldown Bar Color 1"_f[0]),uint8_t(#class".Ability 3.Cooldown Bar Color 1"_f[1]),uint8_t(#class".Ability 3.Cooldown Bar Color 1"_f[2]),uint8_t(#class".Ability 3.Cooldown Bar Color 1"_f[3]==0?255:#class".Ability 3.Cooldown Bar Color 1"_f[3])}, \
		{uint8_t(#class".Ability 3.Cooldown Bar Color 2"_f[0]),uint8_t(#class".Ability 3.Cooldown Bar Color 2"_f[1]),uint8_t(#class".Ability 3.Cooldown Bar Color 2"_f[2]),uint8_t(#class".Ability 3.Cooldown Bar Color 2"_f[3]==0?255:#class".Ability 3.Cooldown Bar Color 2"_f[3])}, \
		{#class".Ability 3.Precast Time"_F,#class".Ability 3.Casting Range"_I/100.f*24,#class".Ability 3.Casting Size"_I/100.f*24}, \
		bool(#class".Ability 3.CancelCast"_I) \
	}; \
	class::ability4;