Refactored all the game classes into derived classes.

Crawler/Class.cpp

@@ -1,58 +1,333 @@
 #include "Class.h"
+#include "DEFINES.h"
+#include "Crawler.h"
+#include "BulletTypes.h"
 
-std::map<Class,ClassData>CLASS_DATA={
+INCLUDE_game
-	{WARRIOR,{
+INCLUDE_MONSTER_LIST
-		"Warrior",WARRIOR,
+INCLUDE_PLAYER_BULLET_LIST
+
+
+std::map<Class,std::unique_ptr<ClassData>>CLASS_DATA;
+
+void ClassData::InitializeClassData(){
+	CLASS_DATA[WARRIOR]=std::make_unique<Warrior>(Warrior("Warrior",WARRIOR,
 		{"Block",15,0,VERY_DARK_BLUE,DARK_BLUE},
 		{"Battlecry",12,40},
 		{"Ground Slam",15,50},
 		{"Sonic Slash",40,60},
 		WARRIOR_WALK_N,WARRIOR_WALK_E,WARRIOR_WALK_S,WARRIOR_WALK_W,
-		WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W,
+		WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W));
-	}},
+	CLASS_DATA[RANGER]=std::make_unique<Ranger>(Ranger("Ranger",RANGER,
-	{THIEF,{
-		"Thief",THIEF,
-		{"???",15,0,VERY_DARK_BLUE,DARK_BLUE},
-		{"???",12,0},
-		{"???",15,0},
-		{"???",40,0},
-		WARRIOR_WALK_N,WARRIOR_WALK_E,WARRIOR_WALK_S,WARRIOR_WALK_W,
-		WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W,
-	}},
-	{RANGER,{
-		"Ranger",RANGER,
 		{"Retreat",7,0,VERY_DARK_BLUE,DARK_BLUE},
 		{"Rapid Fire",12,35},
 		{"Charged Shot",15,40},
 		{"Multishot",25,50},
 		RANGER_WALK_N,RANGER_WALK_E,RANGER_WALK_S,RANGER_WALK_W,
-		RANGER_IDLE_N,RANGER_IDLE_E,RANGER_IDLE_S,RANGER_IDLE_W,
+		RANGER_IDLE_N,RANGER_IDLE_E,RANGER_IDLE_S,RANGER_IDLE_W));
-	}},
+	CLASS_DATA[BARD]=std::make_unique<Bard>(Bard("Bard",BARD,
-	{BARD,{
-		"Bard",BARD,
 		{"???",7,0,VERY_DARK_BLUE,DARK_BLUE},
 		{"???",12,0},
 		{"???",15,0},
 		{"???",25,0},
 		WARRIOR_WALK_N,WARRIOR_WALK_E,WARRIOR_WALK_S,WARRIOR_WALK_W,
-		WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W,
+		WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W));
-	}},
+	CLASS_DATA[WIZARD]=std::make_unique<Wizard>(Wizard("Wizard",WIZARD,
-	{WIZARD,{
-		"Wizard",WIZARD,
 		{"Teleport",8,5,VERY_DARK_BLUE,DARK_BLUE},
 		{"Firebolt",6,30},
 		{"Lightning Bolt",6,25},
 		{"Meteor",40,75},
 		WIZARD_WALK_N,WIZARD_WALK_E,WIZARD_WALK_S,WIZARD_WALK_W,
-		WIZARD_IDLE_N,WIZARD_IDLE_E,WIZARD_IDLE_S,WIZARD_IDLE_W,
+		WIZARD_IDLE_N,WIZARD_IDLE_E,WIZARD_IDLE_S,WIZARD_IDLE_W));
-	}},
+	CLASS_DATA[WITCH]=std::make_unique<Witch>(Witch("Witch",WITCH,
-	{WITCH,{
-		"Witch",WITCH,
 		{"???",8,0,VERY_DARK_BLUE,DARK_BLUE},
 		{"???",6,0},
 		{"???",6,0},
 		{"???",40,0},
 		WARRIOR_WALK_N,WARRIOR_WALK_E,WARRIOR_WALK_S,WARRIOR_WALK_W,
-		WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W,
+		WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W));
-	}},
+}
-};
+
+ClassData::ClassData(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+	AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
+	:name(name),cl(cl),rightClickAbility(rightClickAbility),ability1(ability1),ability2(ability2),ability3(ability3),
+	walk_n(walk_n),walk_e(walk_e),walk_s(walk_s),walk_w(walk_w),idle_n(idle_n),idle_w(idle_w),idle_s(idle_s),idle_e(idle_e)
+{}
+
+Warrior::Warrior(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+	AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
+	:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
+		walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
+{}
+
+void Warrior::Update(float fElapsedTime){
+}
+
+bool Warrior::AutoAttack(){
+	ACCESS_PLAYER
+	if(p.state!=State::SPIN){
+		bool attack=false;
+		Monster*closest=nullptr;
+		float closest_dist=999999;
+		for(Monster&m:MONSTER_LIST){
+			if(m.IsAlive()
+				&&geom2d::overlaps(geom2d::circle<float>(p.pos-vf2d{p.GetSizeMult()*12,p.GetSizeMult()*12},p.attack_range*p.GetSizeMult()*12),geom2d::circle<float>(m.GetPos()-vf2d{m.GetSizeMult()*12,m.GetSizeMult()*12},m.GetSizeMult()*12))
+				&&geom2d::line<float>(game->GetWorldMousePos(),m.GetPos()).length()<closest_dist){
+				closest_dist=geom2d::line<float>(game->GetWorldMousePos(),m.GetPos()).length();
+				closest=&m;
+			}
+		}
+		if(closest!=nullptr&&closest->Hurt(p.GetAttack())){
+			p.attack_cooldown_timer=p.ATTACK_COOLDOWN;
+			p.swordSwingTimer=0.2;
+			p.SetState(State::SWING_SWORD);
+			switch(p.facingDirection){
+				case DOWN:{
+					p.UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_S);
+				}break;
+				case RIGHT:{
+					p.UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_E);
+				}break;
+				case LEFT:{
+					p.UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_W);
+				}break;
+				case UP:{
+					p.UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_N);
+				}break;
+			}
+		}
+	}
+	return true;
+}
+
+bool Warrior::Ability1(){
+	ACCESS_PLAYER
+	game->AddEffect(Effect(p.pos,0.1,AnimationState::BATTLECRY_EFFECT,1,0.3));
+	p.AddBuff(BuffType::ATTACK_UP,10,0.1);
+	p.AddBuff(BuffType::DAMAGE_REDUCTION,10,0.1);
+	for(Monster&m:MONSTER_LIST){
+		if(m.GetSizeMult()<=1&&geom2d::overlaps(geom2d::circle<float>(p.pos,12*3.5),geom2d::circle<float>(m.GetPos(),m.GetSizeMult()*12))){
+			m.AddBuff(BuffType::SLOWDOWN,5,0.3);
+		}
+	}
+	return true;
+}
+
+bool Warrior::Ability2(){
+	ACCESS_PLAYER
+	p.Spin(p.GROUND_SLAM_SPIN_TIME,14*PI);
+	p.iframe_time=p.GROUND_SLAM_SPIN_TIME+0.1;
+	return true;
+}
+
+bool Warrior::Ability3(){
+	ACCESS_PLAYER
+	p.SetState(State::SWING_SONIC_SWORD);
+	p.AddBuff(BuffType::SLOWDOWN,0.5,1);
+	vf2d bulletVel={};
+	switch(p.GetFacingDirection()){
+		case UP:{
+			p.vel.y=70;
+			bulletVel.y=-400;
+			p.UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_N);
+		}break;
+		case LEFT:{
+			p.vel.x=70;
+			bulletVel.x=-400;
+			p.UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_W);
+		}break;
+		case RIGHT:{
+			p.vel.x=-70;
+			bulletVel.x=400;
+			p.UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_E);
+		}break;
+		case DOWN:{
+			p.vel.y=-70;
+			bulletVel.y=400;
+			p.UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_S);
+		}break;
+	}
+	PLAYER_BULLET_LIST.push_back(std::make_unique<Bullet>(p.pos,bulletVel,30,p.GetAttack()*8,AnimationState::SONICSLASH,true,2.25,true));
+	game->SetupWorldShake(0.5);
+	return true;
+}
+
+bool Warrior::RightClickAbility(){
+	ACCESS_PLAYER
+	if(p.GetState()==State::NORMAL){
+		rightClickAbility.cooldown=rightClickAbility.COOLDOWN_TIME;
+		p.SetState(State::BLOCK);
+		p.AddBuff(BuffType::SLOWDOWN,3,0.3);
+		return true;
+	}
+	return false;
+}
+
+Thief::Thief(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+	AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
+	:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
+		walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
+{}
+
+void Thief::Update(float fElapsedTime){
+}
+
+bool Thief::AutoAttack(){
+	return true;
+}
+
+bool Thief::Ability1(){
+	return true;
+}
+
+bool Thief::Ability2(){
+	return true;
+}
+
+bool Thief::Ability3(){
+	return true;
+}
+
+bool Thief::RightClickAbility(){
+	return true;
+}
+
+Ranger::Ranger(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+	AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
+	:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
+		walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
+{}
+
+void Ranger::Update(float fElapsedTime){
+}
+
+bool Ranger::AutoAttack(){
+	return true;
+}
+
+bool Ranger::Ability1(){
+	return true;
+}
+
+bool Ranger::Ability2(){
+	return true;
+}
+
+bool Ranger::Ability3(){
+	return true;
+}
+
+bool Ranger::RightClickAbility(){
+	return true;
+}
+
+Bard::Bard(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+	AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
+	:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
+		walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
+{}
+
+void Bard::Update(float fElapsedTime){
+}
+
+bool Bard::AutoAttack(){
+	return true;
+}
+
+bool Bard::Ability1(){
+	return true;
+}
+
+bool Bard::Ability2(){
+	return true;
+}
+
+bool Bard::Ability3(){
+	return true;
+}
+
+bool Bard::RightClickAbility(){
+	return true;
+}
+
+Wizard::Wizard(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+	AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
+	:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
+		walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
+{}
+
+void Wizard::Update(float fElapsedTime){
+	ACCESS_PLAYER
+	if(p.attack_cooldown_timer>0){
+		CLASS_DATA[cl]->idle_n=AnimationState::WIZARD_IDLE_ATTACK_N;
+		CLASS_DATA[cl]->idle_e=AnimationState::WIZARD_IDLE_ATTACK_E;
+		CLASS_DATA[cl]->idle_s=AnimationState::WIZARD_IDLE_ATTACK_S;
+		CLASS_DATA[cl]->idle_w=AnimationState::WIZARD_IDLE_ATTACK_W;
+		CLASS_DATA[cl]->walk_n=AnimationState::WIZARD_ATTACK_N;
+		CLASS_DATA[cl]->walk_e=AnimationState::WIZARD_ATTACK_E;
+		CLASS_DATA[cl]->walk_s=AnimationState::WIZARD_ATTACK_S;
+		CLASS_DATA[cl]->walk_w=AnimationState::WIZARD_ATTACK_W;
+	} else {
+		CLASS_DATA[cl]->idle_n=AnimationState::WIZARD_IDLE_N;
+		CLASS_DATA[cl]->idle_e=AnimationState::WIZARD_IDLE_E;
+		CLASS_DATA[cl]->idle_s=AnimationState::WIZARD_IDLE_S;
+		CLASS_DATA[cl]->idle_w=AnimationState::WIZARD_IDLE_W;
+		CLASS_DATA[cl]->walk_n=AnimationState::WIZARD_WALK_N;
+		CLASS_DATA[cl]->walk_e=AnimationState::WIZARD_WALK_E;
+		CLASS_DATA[cl]->walk_s=AnimationState::WIZARD_WALK_S;
+		CLASS_DATA[cl]->walk_w=AnimationState::WIZARD_WALK_W;
+	}
+}
+
+bool Wizard::AutoAttack(){
+	ACCESS_PLAYER
+	p.attack_cooldown_timer=p.MAGIC_ATTACK_COOLDOWN;
+	float angleToCursor=atan2(game->GetWorldMousePos().y-p.pos.y,game->GetWorldMousePos().x-p.pos.x);
+	PLAYER_BULLET_LIST.push_back(std::make_unique<EnergyBolt>(EnergyBolt(p.pos,{cos(angleToCursor)*200,sin(angleToCursor)*200},12,p.GetAttack())));
+	return true;
+}
+
+bool Wizard::Ability1(){
+	return true;
+}
+
+bool Wizard::Ability2(){
+	return true;
+}
+
+bool Wizard::Ability3(){
+	return true;
+}
+
+bool Wizard::RightClickAbility(){
+	return true;
+}
+
+Witch::Witch(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+	AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
+	:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
+		walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
+{}
+
+void Witch::Update(float fElapsedTime){
+}
+
+bool Witch::AutoAttack(){
+	return true;
+}
+
+bool Witch::Ability1(){
+	return true;
+}
+
+bool Witch::Ability2(){
+	return true;
+}
+
+bool Witch::Ability3(){
+	return true;
+}
+
+bool Witch::RightClickAbility(){
+	return true;
+}

Crawler/Class.h

@@ -11,4 +11,74 @@ struct ClassData{
 	Class cl;
 	Ability rightClickAbility,ability1,ability2,ability3;
 	AnimationState walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
+	static void InitializeClassData();
+	ClassData(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+		AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
+	virtual void Update(float fElapsedTime)=0;
+	virtual bool AutoAttack()=0;
+	virtual bool Ability1()=0;
+	virtual bool Ability2()=0;
+	virtual bool Ability3()=0;
+	virtual bool RightClickAbility()=0;
+};
+
+struct Warrior:public ClassData{
+	Warrior(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+		AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
+	void Update(float fElapsedTime)override;
+	bool AutoAttack()override;
+	bool Ability1()override;
+	bool Ability2()override;
+	bool Ability3()override;
+	bool RightClickAbility()override;
+};
+struct Thief:public ClassData{
+	Thief(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+		AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
+	void Update(float fElapsedTime)override;
+	bool AutoAttack()override;
+	bool Ability1()override;
+	bool Ability2()override;
+	bool Ability3()override;
+	bool RightClickAbility()override;
+};
+struct Ranger:public ClassData{
+	Ranger(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+		AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
+	void Update(float fElapsedTime)override;
+	bool AutoAttack()override;
+	bool Ability1()override;
+	bool Ability2()override;
+	bool Ability3()override;
+	bool RightClickAbility()override;
+};
+struct Bard:public ClassData{
+	Bard(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+		AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
+	void Update(float fElapsedTime)override;
+	bool AutoAttack()override;
+	bool Ability1()override;
+	bool Ability2()override;
+	bool Ability3()override;
+	bool RightClickAbility()override;
+};
+struct Wizard:public ClassData{
+	Wizard(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+		AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
+	void Update(float fElapsedTime)override;
+	bool AutoAttack()override;
+	bool Ability1()override;
+	bool Ability2()override;
+	bool Ability3()override;
+	bool RightClickAbility()override;
+};
+struct Witch:public ClassData{
+	Witch(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
+		AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
+	void Update(float fElapsedTime)override;
+	bool AutoAttack()override;
+	bool Ability1()override;
+	bool Ability2()override;
+	bool Ability3()override;
+	bool RightClickAbility()override;
 };

Crawler/Crawler.cpp

@@ -11,6 +11,8 @@
 #include "Map.h"
 #include "DEFINES.h"
 
+INCLUDE_CLASS_DATA
+
 //192x192
 const vi2d WINDOW_SIZE={24*15,24*10};
 std::map<AnimationState,Animate2D::FrameSequence>ANIMATION_DATA;
@@ -32,6 +34,8 @@ bool Crawler::OnUserCreate(){
 	InitializeLevel("assets/maps/Level2.tmx",LEVEL2);
 	InitializeLevel("assets/Campaigns/1_1_test.tmx",CAMPAIGN_1_1);
 
+	ClassData::InitializeClassData();
+
 	//Initialize Camera.
 	camera=Camera2D{WINDOW_SIZE};
 	camera.SetMode(olc::utils::Camera2D::Mode::LazyFollow);

Crawler/DEFINES.h

@@ -6,6 +6,8 @@
 #define INCLUDE_game extern Crawler*game;
 #define INCLUDE_MONSTER_DATA extern std::map<MonsterName,MonsterData>MONSTER_DATA;
 #define INCLUDE_BULLET_LIST extern std::vector<std::unique_ptr<Bullet>>BULLET_LIST;
-#define INCLUDE_CLASS_DATA extern std::map<Class,ClassData>CLASS_DATA;
+#define INCLUDE_CLASS_DATA extern std::map<Class,std::unique_ptr<ClassData>>CLASS_DATA;
 #define INCLUDE_PLAYER_BULLET_LIST extern std::vector<std::unique_ptr<Bullet>>PLAYER_BULLET_LIST;
 #define INCLUDE_PARTICLE_LIST extern std::vector<Particle>PARTICLE_LIST;
+
+#define ACCESS_PLAYER Player&p=game->GetPlayer();

Crawler/Player.cpp

@@ -21,11 +21,11 @@ Player::Player():
 	state(State::NORMAL),lastReleasedMovementKey(DOWN),facingDirection(DOWN){}
 
 void Player::SetClass(Class cl){
-	this->cl=CLASS_DATA[cl].cl;
+	this->cl=CLASS_DATA[cl]->cl;
-	rightClickAbility=CLASS_DATA[cl].rightClickAbility;
+	rightClickAbility=CLASS_DATA[cl]->rightClickAbility;
-	ability1=CLASS_DATA[cl].ability1;
+	ability1=CLASS_DATA[cl]->ability1;
-	ability2=CLASS_DATA[cl].ability2;
+	ability2=CLASS_DATA[cl]->ability2;
-	ability3=CLASS_DATA[cl].ability3;
+	ability3=CLASS_DATA[cl]->ability3;
 	UpdateIdleAnimation(DOWN);
 }
 
@@ -149,39 +149,7 @@ void Player::Update(float fElapsedTime){
 		}
 	}
 	//Class-specific update events.
-	switch (cl) {
+	CLASS_DATA[cl]->Update(fElapsedTime);
-		case WARRIOR: {
-		}break;
-		case THIEF: {
-		}break;
-		case RANGER: {
-		}break;
-		case BARD: {
-		}break;
-		case WIZARD: {
-			if(attack_cooldown_timer>0){
-				CLASS_DATA[cl].idle_n=AnimationState::WIZARD_IDLE_ATTACK_N;
-				CLASS_DATA[cl].idle_e=AnimationState::WIZARD_IDLE_ATTACK_E;
-				CLASS_DATA[cl].idle_s=AnimationState::WIZARD_IDLE_ATTACK_S;
-				CLASS_DATA[cl].idle_w=AnimationState::WIZARD_IDLE_ATTACK_W;
-				CLASS_DATA[cl].walk_n=AnimationState::WIZARD_ATTACK_N;
-				CLASS_DATA[cl].walk_e=AnimationState::WIZARD_ATTACK_E;
-				CLASS_DATA[cl].walk_s=AnimationState::WIZARD_ATTACK_S;
-				CLASS_DATA[cl].walk_w=AnimationState::WIZARD_ATTACK_W;
-			} else {
-				CLASS_DATA[cl].idle_n=AnimationState::WIZARD_IDLE_N;
-				CLASS_DATA[cl].idle_e=AnimationState::WIZARD_IDLE_E;
-				CLASS_DATA[cl].idle_s=AnimationState::WIZARD_IDLE_S;
-				CLASS_DATA[cl].idle_w=AnimationState::WIZARD_IDLE_W;
-				CLASS_DATA[cl].walk_n=AnimationState::WIZARD_WALK_N;
-				CLASS_DATA[cl].walk_e=AnimationState::WIZARD_WALK_E;
-				CLASS_DATA[cl].walk_s=AnimationState::WIZARD_WALK_S;
-				CLASS_DATA[cl].walk_w=AnimationState::WIZARD_WALK_W;
-			}
-		}break;
-		case WITCH: {
-		}break;
-	}
 	switch(state){
 		case SPIN:{
 			switch(facingDirection){
@@ -284,176 +252,42 @@ void Player::Update(float fElapsedTime){
 		SetY(newY);
 	}
 	if(attack_cooldown_timer==0&&game->GetMouse(0).bHeld){
-		switch (cl) {
+		CLASS_DATA[cl]->AutoAttack();
-			case WARRIOR:{
-				if(state!=State::SPIN){
-					bool attack=false;
-					Monster*closest=nullptr;
-					float closest_dist=999999;
-					for(Monster&m:MONSTER_LIST){
-						if(m.IsAlive()
-							&&geom2d::overlaps(geom2d::circle<float>(pos-vf2d{size*12,size*12},attack_range*size*12),geom2d::circle<float>(m.GetPos()-vf2d{m.GetSizeMult()*12,m.GetSizeMult()*12},m.GetSizeMult()*12))
-							&&geom2d::line<float>(game->GetWorldMousePos(),m.GetPos()).length()<closest_dist){
-							closest_dist=geom2d::line<float>(game->GetWorldMousePos(),m.GetPos()).length();
-							closest=&m;
-						}
-					}
-					if(closest!=nullptr&&closest->Hurt(GetAttack())){
-						attack_cooldown_timer=ATTACK_COOLDOWN;
-						swordSwingTimer=0.2;
-						SetState(State::SWING_SWORD);
-						switch(facingDirection){
-							case DOWN:{
-								UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_S);
-							}break;
-							case RIGHT:{
-								UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_E);
-							}break;
-							case LEFT:{
-								UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_W);
-							}break;
-							case UP:{
-								UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_N);
-							}break;
-						}
-					}
-				}
-			}break;
-			case THIEF: {
-			}break;
-			case RANGER: {
-			}break;
-			case BARD: {
-			}break;
-			case WIZARD: {
-				attack_cooldown_timer=MAGIC_ATTACK_COOLDOWN;
-				float angleToCursor=atan2(game->GetWorldMousePos().y-pos.y,game->GetWorldMousePos().x-pos.x);
-				PLAYER_BULLET_LIST.push_back(std::make_unique<EnergyBolt>(EnergyBolt(pos,{cos(angleToCursor)*200,sin(angleToCursor)*200},12,GetAttack())));
-			}break;
-			case WITCH: {
-			}break;
-		}
 	}
 	if(ability1.cooldown==0&&GetMana()>=ability1.manaCost&&game->GetKey(SHIFT).bHeld){
-		switch (cl) {
+		
-			case WARRIOR: {
+		if(CLASS_DATA[cl]->Ability1()){
-				game->AddEffect(Effect(pos,0.1,AnimationState::BATTLECRY_EFFECT,1,0.3));
+			ability1.cooldown=ability1.COOLDOWN_TIME;
-				ability1.cooldown=ability1.COOLDOWN_TIME;
+			mana-=ability1.manaCost;
-				AddBuff(BuffType::ATTACK_UP,10,0.1);
-				AddBuff(BuffType::DAMAGE_REDUCTION,10,0.1);
-				for(Monster&m:MONSTER_LIST){
-					if(m.GetSizeMult()<=1&&geom2d::overlaps(geom2d::circle<float>(pos,12*3.5),geom2d::circle<float>(m.GetPos(),m.GetSizeMult()*12))){
-						m.AddBuff(BuffType::SLOWDOWN,5,0.3);
-					}
-				}
-			}break;
-			case THIEF: {
-			}break;
-			case RANGER: {
-			}break;
-			case BARD: {
-			}break;
-			case WIZARD: {
-			}break;
-			case WITCH: {
-			}break;
 		}
-		mana-=ability1.manaCost;
+		
 	} else 
 	if(ability1.cooldown==0&&GetMana()<ability1.manaCost&&game->GetKey(SHIFT).bPressed){
 		notEnoughManaDisplay={ability1.name,1};
 	}
 	if(ability2.cooldown==0&&GetMana()>=ability2.manaCost&&game->GetKey(SPACE).bPressed){
-		switch(cl){
+		if(CLASS_DATA[cl]->Ability2()){
-			case WARRIOR:{
+			ability2.cooldown=ability2.COOLDOWN_TIME;
-				Spin(GROUND_SLAM_SPIN_TIME,14*PI);
+			mana-=ability2.manaCost;
-				iframe_time=GROUND_SLAM_SPIN_TIME+0.1;
-			}break;
-			case THIEF:{
-			}break;
-			case RANGER:{
-			}break;
-			case BARD:{
-			}break;
-			case WIZARD:{
-			}break;
-			case WITCH:{
-			}break;
 		}
-		mana-=ability2.manaCost;
 	} else 
 	if(ability2.cooldown==0&&GetMana()<ability2.manaCost&&game->GetKey(SPACE).bPressed){
 		notEnoughManaDisplay={ability2.name,1};
 	}
 	if(ability3.cooldown==0&&GetMana()>=ability3.manaCost&&game->GetKey(CTRL).bPressed){
-		switch(cl){
+		if(CLASS_DATA[cl]->Ability3()){
-			case WARRIOR:{
+			ability3.cooldown=ability3.COOLDOWN_TIME;
-				ability3.cooldown=ability3.COOLDOWN_TIME;
+			mana-=ability3.manaCost;
-				SetState(State::SWING_SONIC_SWORD);
-				AddBuff(BuffType::SLOWDOWN,0.5,1);
-				vf2d bulletVel={};
-				switch(GetFacingDirection()){
-					case UP:{
-						vel.y=70;
-						bulletVel.y=-400;
-						UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_N);
-					}break;
-					case LEFT:{
-						vel.x=70;
-						bulletVel.x=-400;
-						UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_W);
-					}break;
-					case RIGHT:{
-						vel.x=-70;
-						bulletVel.x=400;
-						UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_E);
-					}break;
-					case DOWN:{
-						vel.y=-70;
-						bulletVel.y=400;
-						UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_S);
-					}break;
-				}
-				PLAYER_BULLET_LIST.push_back(std::make_unique<Bullet>(pos,bulletVel,30,GetAttack()*8,AnimationState::SONICSLASH,true,2.25,true));
-				game->SetupWorldShake(0.5);
-			}break;
-			case THIEF:{
-			}break;
-			case RANGER:{
-			}break;
-			case BARD:{
-			}break;
-			case WIZARD:{
-			}break;
-			case WITCH:{
-			}break;
 		}
-		mana-=ability3.manaCost;
 	} else 
 	if(ability3.cooldown==0&&GetMana()<ability3.manaCost&&game->GetKey(CTRL).bPressed){
 		notEnoughManaDisplay={ability3.name,1};
 	}
 	if(rightClickAbility.cooldown==0&&GetMana()>=rightClickAbility.manaCost&&game->GetMouse(1).bHeld){
-		switch (cl) {
+		if(CLASS_DATA[cl]->RightClickAbility()){
-			case WARRIOR: {
+			rightClickAbility.cooldown=rightClickAbility.COOLDOWN_TIME;
-				if(GetState()==State::NORMAL){
+			mana-=rightClickAbility.manaCost;
-					rightClickAbility.cooldown=rightClickAbility.COOLDOWN_TIME;
-					SetState(State::BLOCK);
-					AddBuff(BuffType::SLOWDOWN,3,0.3);
-				}
-			}break;
-			case THIEF: {
-			}break;
-			case RANGER: {
-			}break;
-			case BARD: {
-			}break;
-			case WIZARD: {
-			}break;
-			case WITCH: {
-			}break;
 		}
-		mana-=rightClickAbility.manaCost;
 	} else 
 	if(rightClickAbility.cooldown==0&&GetMana()<rightClickAbility.manaCost&&game->GetMouse(1).bPressed){
 		notEnoughManaDisplay={rightClickAbility.name,1};
@@ -540,16 +374,15 @@ void Player::Spin(float duration,float spinSpd){
 	spin_attack_timer=duration;
 	spin_spd=spinSpd;
 	spin_angle=0;
-	ability2.cooldown=ability2.COOLDOWN_TIME;
 }
 
 void Player::UpdateWalkingAnimation(Key direction){
 	AnimationState anim;
 	switch(direction){
-		case UP:anim=CLASS_DATA[cl].walk_n;break;
+		case UP:anim=CLASS_DATA[cl]->walk_n;break;
-		case RIGHT:anim=CLASS_DATA[cl].walk_e;break;
+		case RIGHT:anim=CLASS_DATA[cl]->walk_e;break;
-		case DOWN:anim=CLASS_DATA[cl].walk_s;break;
+		case DOWN:anim=CLASS_DATA[cl]->walk_s;break;
-		case LEFT:anim=CLASS_DATA[cl].walk_w;break;
+		case LEFT:anim=CLASS_DATA[cl]->walk_w;break;
 	}
 	UpdateAnimation(anim);
 }
@@ -557,10 +390,10 @@ void Player::UpdateWalkingAnimation(Key direction){
 void Player::UpdateIdleAnimation(Key direction){
 	AnimationState anim;
 	switch(direction){
-		case UP:anim=CLASS_DATA[cl].idle_n;break;
+		case UP:anim=CLASS_DATA[cl]->idle_n;break;
-		case RIGHT:anim=CLASS_DATA[cl].idle_e;break;
+		case RIGHT:anim=CLASS_DATA[cl]->idle_e;break;
-		case DOWN:anim=CLASS_DATA[cl].idle_s;break;
+		case DOWN:anim=CLASS_DATA[cl]->idle_s;break;
-		case LEFT:anim=CLASS_DATA[cl].idle_w;break;
+		case LEFT:anim=CLASS_DATA[cl]->idle_w;break;
 	}
 	UpdateAnimation(anim);
 }

Crawler/Player.h

@@ -9,6 +9,12 @@
 
 struct Player{
 	friend class Crawler;
+	friend class Warrior;
+	friend class Thief;
+	friend class Ranger;
+	friend class Bard;
+	friend class Wizard;
+	friend class Witch;
 	private:
 	Class cl=WARRIOR;
 	int hp=100,maxhp=hp;

Crawler/Version.h

@@ -2,7 +2,7 @@
 #define VERSION_MAJOR 0
 #define VERSION_MINOR 2
 #define VERSION_PATCH 0
-#define VERSION_BUILD 352
+#define VERSION_BUILD 369
 
 #define stringify(a) stringify_(a)
 #define stringify_(a) #a