sigonasr2/AdventuresInLestoria
1
1
Fork 0
Code Issues 19 Pull Requests Actions Projects 1 Releases Wiki Activity

All underlying class differences now applied to code. Preparation for other class implementations. Implemented class swapping via mouse wheel.

Browse Source
This commit is contained in:
sigonasr2 2023-06-17 23:07:26 -05:00
parent 21368f6f95
commit 9e6573729e
13 changed files with 369 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Crawler/Animation.h
View File

@ -1,12 +1,16 @@
#pragma once #pragma once
enum AnimationState{ enum AnimationState{
WALK_S,WALK_E,WALK_N,WALK_W, WARRIOR_WALK_S,WARRIOR_WALK_E,WARRIOR_WALK_N,WARRIOR_WALK_W,
IDLE_S,IDLE_E,IDLE_N,IDLE_W, WARRIOR_IDLE_S,WARRIOR_IDLE_E,WARRIOR_IDLE_N,WARRIOR_IDLE_W,
GREEN_SLIME_IDLE,GREEN_SLIME_ROLL,GREEN_SLIME_JUMP,GREEN_SLIME_SPIT,GREEN_SLIME_DIE, GREEN_SLIME_IDLE,GREEN_SLIME_ROLL,GREEN_SLIME_JUMP,GREEN_SLIME_SPIT,GREEN_SLIME_DIE,
BLUE_SLIME_IDLE,BLUE_SLIME_ROLL,BLUE_SLIME_JUMP,BLUE_SLIME_SPIT,BLUE_SLIME_DIE, BLUE_SLIME_IDLE,BLUE_SLIME_ROLL,BLUE_SLIME_JUMP,BLUE_SLIME_SPIT,BLUE_SLIME_DIE,
RED_SLIME_IDLE,RED_SLIME_ROLL,RED_SLIME_JUMP,RED_SLIME_SPIT,RED_SLIME_DIE, RED_SLIME_IDLE,RED_SLIME_ROLL,RED_SLIME_JUMP,RED_SLIME_SPIT,RED_SLIME_DIE,
YELLOW_SLIME_IDLE,YELLOW_SLIME_ROLL,YELLOW_SLIME_JUMP,YELLOW_SLIME_SPIT,YELLOW_SLIME_DIE, YELLOW_SLIME_IDLE,YELLOW_SLIME_ROLL,YELLOW_SLIME_JUMP,YELLOW_SLIME_SPIT,YELLOW_SLIME_DIE,
GROUND_SLAM_ATTACK_BACK,GROUND_SLAM_ATTACK_FRONT, GROUND_SLAM_ATTACK_BACK,GROUND_SLAM_ATTACK_FRONT,
SWINGSWORD_S,SWINGSWORD_E,SWINGSWORD_N,SWINGSWORD_W, SWINGSWORD_S,SWINGSWORD_E,SWINGSWORD_N,SWINGSWORD_W,
RANGER_WALK_S,RANGER_WALK_E,RANGER_WALK_N,RANGER_WALK_W,
RANGER_IDLE_S,RANGER_IDLE_E,RANGER_IDLE_N,RANGER_IDLE_W,
WIZARD_WALK_S,WIZARD_WALK_E,WIZARD_WALK_N,WIZARD_WALK_W,
WIZARD_IDLE_S,WIZARD_IDLE_E,WIZARD_IDLE_N,WIZARD_IDLE_W,
}; };

24
Crawler/Class.cpp
View File

@ -6,41 +6,53 @@ std::map<Class,ClassData>CLASS_DATA={
{"Block",15,VERY_DARK_BLUE,DARK_BLUE}, {"Block",15,VERY_DARK_BLUE,DARK_BLUE},
{"Battlecry",12}, {"Battlecry",12},
{"Ground Slam",15}, {"Ground Slam",15},
{"Sonic Slash",40} {"Sonic Slash",40},
WARRIOR_WALK_N,WARRIOR_WALK_E,WARRIOR_WALK_S,WARRIOR_WALK_W,
WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W,
}}, }},
{THIEF,{ {THIEF,{
"Thief",THIEF, "Thief",THIEF,
{"???",15,VERY_DARK_BLUE,DARK_BLUE}, {"???",15,VERY_DARK_BLUE,DARK_BLUE},
{"???",12}, {"???",12},
{"???",15}, {"???",15},
{"???",40} {"???",40},
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",RANGER, "Ranger",RANGER,
{"Retreat",7,VERY_DARK_BLUE,DARK_BLUE}, {"Retreat",7,VERY_DARK_BLUE,DARK_BLUE},
{"Rapid Fire",12}, {"Rapid Fire",12},
{"Charged Shot",15}, {"Charged Shot",15},
{"Multishot",25} {"Multishot",25},
RANGER_WALK_N,RANGER_WALK_E,RANGER_WALK_S,RANGER_WALK_W,
RANGER_IDLE_N,RANGER_IDLE_E,RANGER_IDLE_S,RANGER_IDLE_W,
}}, }},
{BARD,{ {BARD,{
"Bard",BARD, "Bard",BARD,
{"???",7,VERY_DARK_BLUE,DARK_BLUE}, {"???",7,VERY_DARK_BLUE,DARK_BLUE},
{"???",12}, {"???",12},
{"???",15}, {"???",15},
{"???",25} {"???",25},
WARRIOR_WALK_N,WARRIOR_WALK_E,WARRIOR_WALK_S,WARRIOR_WALK_W,
WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W,
}}, }},
{WIZARD,{ {WIZARD,{
"Wizard",WIZARD, "Wizard",WIZARD,
{"Teleport",8,VERY_DARK_BLUE,DARK_BLUE}, {"Teleport",8,VERY_DARK_BLUE,DARK_BLUE},
{"Firebolt",6}, {"Firebolt",6},
{"Lightning Bolt",6}, {"Lightning Bolt",6},
{"Meteor",40} {"Meteor",40},
WIZARD_WALK_N,WIZARD_WALK_E,WIZARD_WALK_S,WIZARD_WALK_W,
WIZARD_IDLE_N,WIZARD_IDLE_E,WIZARD_IDLE_S,WIZARD_IDLE_W,
}}, }},
{WITCH,{ {WITCH,{
"Witch",WITCH, "Witch",WITCH,
{"???",8,VERY_DARK_BLUE,DARK_BLUE}, {"???",8,VERY_DARK_BLUE,DARK_BLUE},
{"???",6}, {"???",6},
{"???",6}, {"???",6},
{"???",40} {"???",40},
WARRIOR_WALK_N,WARRIOR_WALK_E,WARRIOR_WALK_S,WARRIOR_WALK_W,
WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W,
}}, }},
}; };

2
Crawler/Class.h
View File

@ -1,5 +1,6 @@
#pragma once #pragma once
#include "Ability.h" #include "Ability.h"
#include "Animation.h"
#include "olcPixelGameEngine.h" #include "olcPixelGameEngine.h"
enum Class{ enum Class{
@ -9,4 +10,5 @@ struct ClassData{
std::string name; std::string name;
Class cl; Class cl;
Ability rightClickAbility,ability1,ability2,ability3; Ability rightClickAbility,ability1,ability2,ability3;
AnimationState walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
}; };

294
Crawler/Crawler.cpp
View File

@ -31,25 +31,43 @@ bool Crawler::OnUserCreate(){
camera.EnableWorldBoundary(false); camera.EnableWorldBoundary(false);
//Graphics //Graphics
GFX_Pl_Sheet.Load("assets/nico-warrior.png"); GFX_Warrior_Sheet.Load("assets/nico-warrior.png");
GFX_Slime_Sheet.Load("assets/slime.png"); GFX_Slime_Sheet.Load("assets/slime.png");
GFX_Circle.Load("assets/circle.png"); GFX_Circle.Load("assets/circle.png");
GFX_Effect_GroundSlam_Back.Load("assets/ground-slam-attack-back.png"); GFX_Effect_GroundSlam_Back.Load("assets/ground-slam-attack-back.png");
GFX_Effect_GroundSlam_Front.Load("assets/ground-slam-attack-front.png"); GFX_Effect_GroundSlam_Front.Load("assets/ground-slam-attack-front.png");
GFX_Heart.Load("assets/heart.png"); GFX_Heart.Load("assets/heart.png");
GFX_BLOCK_BUBBLE.Load("assets/block.png"); GFX_BLOCK_BUBBLE.Load("assets/block.png");
GFX_Ranger_Sheet.Load("assets/nico-ranger.png");
GFX_Wizard_Sheet.Load("assets/nico-wizard.png");
//Animations //Animations
InitializeAnimations(); InitializeAnimations();
player.AddAnimation(AnimationState::WALK_N); player.AddAnimation(AnimationState::WARRIOR_WALK_N);
player.AddAnimation(AnimationState::WALK_E); player.AddAnimation(AnimationState::WARRIOR_WALK_E);
player.AddAnimation(AnimationState::WALK_S); player.AddAnimation(AnimationState::WARRIOR_WALK_S);
player.AddAnimation(AnimationState::WALK_W); player.AddAnimation(AnimationState::WARRIOR_WALK_W);
player.AddAnimation(AnimationState::IDLE_N); player.AddAnimation(AnimationState::WARRIOR_IDLE_N);
player.AddAnimation(AnimationState::IDLE_E); player.AddAnimation(AnimationState::WARRIOR_IDLE_E);
player.AddAnimation(AnimationState::IDLE_S); player.AddAnimation(AnimationState::WARRIOR_IDLE_S);
player.AddAnimation(AnimationState::IDLE_W); player.AddAnimation(AnimationState::WARRIOR_IDLE_W);
player.AddAnimation(AnimationState::RANGER_WALK_N);
player.AddAnimation(AnimationState::RANGER_WALK_E);
player.AddAnimation(AnimationState::RANGER_WALK_S);
player.AddAnimation(AnimationState::RANGER_WALK_W);
player.AddAnimation(AnimationState::RANGER_IDLE_N);
player.AddAnimation(AnimationState::RANGER_IDLE_E);
player.AddAnimation(AnimationState::RANGER_IDLE_S);
player.AddAnimation(AnimationState::RANGER_IDLE_W);
player.AddAnimation(AnimationState::WIZARD_WALK_N);
player.AddAnimation(AnimationState::WIZARD_WALK_E);
player.AddAnimation(AnimationState::WIZARD_WALK_S);
player.AddAnimation(AnimationState::WIZARD_WALK_W);
player.AddAnimation(AnimationState::WIZARD_IDLE_N);
player.AddAnimation(AnimationState::WIZARD_IDLE_E);
player.AddAnimation(AnimationState::WIZARD_IDLE_S);
player.AddAnimation(AnimationState::WIZARD_IDLE_W);
player.AddAnimation(AnimationState::SWINGSWORD_E); player.AddAnimation(AnimationState::SWINGSWORD_E);
player.AddAnimation(AnimationState::SWINGSWORD_S); player.AddAnimation(AnimationState::SWINGSWORD_S);
player.AddAnimation(AnimationState::SWINGSWORD_N); player.AddAnimation(AnimationState::SWINGSWORD_N);
@ -58,8 +76,6 @@ bool Crawler::OnUserCreate(){
player.SetClass(WARRIOR); player.SetClass(WARRIOR);
player.SetPos({4*24,4*24}); player.SetPos({4*24,4*24});
player.UpdateAnimation(AnimationState::IDLE_S);
SPAWNER_LIST.push_back(MonsterSpawner({360*1,96},4*24,{{ SPAWNER_LIST.push_back(MonsterSpawner({360*1,96},4*24,{{
{MonsterName::SLIME_GREEN,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}} {MonsterName::SLIME_GREEN,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
@ -120,59 +136,137 @@ bool Crawler::OnUserUpdate(float fElapsedTime){
} }
void Crawler::InitializeAnimations(){ void Crawler::InitializeAnimations(){
Animate2D::FrameSequence pl_walk_s{0.2}; //Warrior animations.
pl_walk_s.AddFrame({&GFX_Pl_Sheet,{vi2d{0,0}*24,{24,24}}}); Animate2D::FrameSequence pl_warrior_walk_s{0.2};
pl_walk_s.AddFrame({&GFX_Pl_Sheet,{vi2d{1,0}*24,{24,24}}}); pl_warrior_walk_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,0}*24,{24,24}}});
pl_walk_s.AddFrame({&GFX_Pl_Sheet,{vi2d{0,0}*24,{24,24}}}); pl_warrior_walk_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{1,0}*24,{24,24}}});
pl_walk_s.AddFrame({&GFX_Pl_Sheet,{vi2d{2,0}*24,{24,24}}}); pl_warrior_walk_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,0}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WALK_S]=pl_walk_s; pl_warrior_walk_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{2,0}*24,{24,24}}});
Animate2D::FrameSequence pl_walk_e{0.2}; ANIMATION_DATA[AnimationState::WARRIOR_WALK_S]=pl_warrior_walk_s;
pl_walk_e.AddFrame({&GFX_Pl_Sheet,{vi2d{0,3}*24,{24,24}}}); Animate2D::FrameSequence pl_warrior_walk_e{0.2};
pl_walk_e.AddFrame({&GFX_Pl_Sheet,{vi2d{1,3}*24,{24,24}}}); pl_warrior_walk_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,3}*24,{24,24}}});
pl_walk_e.AddFrame({&GFX_Pl_Sheet,{vi2d{0,3}*24,{24,24}}}); pl_warrior_walk_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{1,3}*24,{24,24}}});
pl_walk_e.AddFrame({&GFX_Pl_Sheet,{vi2d{2,3}*24,{24,24}}}); pl_warrior_walk_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,3}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WALK_E]=pl_walk_e; pl_warrior_walk_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{2,3}*24,{24,24}}});
Animate2D::FrameSequence pl_walk_w{0.2}; ANIMATION_DATA[AnimationState::WARRIOR_WALK_E]=pl_warrior_walk_e;
pl_walk_w.AddFrame({&GFX_Pl_Sheet,{vi2d{0,2}*24,{24,24}}}); Animate2D::FrameSequence pl_warrior_walk_w{0.2};
pl_walk_w.AddFrame({&GFX_Pl_Sheet,{vi2d{1,2}*24,{24,24}}}); pl_warrior_walk_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,2}*24,{24,24}}});
pl_walk_w.AddFrame({&GFX_Pl_Sheet,{vi2d{0,2}*24,{24,24}}}); pl_warrior_walk_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{1,2}*24,{24,24}}});
pl_walk_w.AddFrame({&GFX_Pl_Sheet,{vi2d{2,2}*24,{24,24}}}); pl_warrior_walk_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,2}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WALK_W]=pl_walk_w; pl_warrior_walk_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{2,2}*24,{24,24}}});
Animate2D::FrameSequence pl_walk_n{0.2}; ANIMATION_DATA[AnimationState::WARRIOR_WALK_W]=pl_warrior_walk_w;
pl_walk_n.AddFrame({&GFX_Pl_Sheet,{vi2d{0,1}*24,{24,24}}}); Animate2D::FrameSequence pl_warrior_walk_n{0.2};
pl_walk_n.AddFrame({&GFX_Pl_Sheet,{vi2d{1,1}*24,{24,24}}}); pl_warrior_walk_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,1}*24,{24,24}}});
pl_walk_n.AddFrame({&GFX_Pl_Sheet,{vi2d{0,1}*24,{24,24}}}); pl_warrior_walk_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{1,1}*24,{24,24}}});
pl_walk_n.AddFrame({&GFX_Pl_Sheet,{vi2d{2,1}*24,{24,24}}}); pl_warrior_walk_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,1}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WALK_N]=pl_walk_n; pl_warrior_walk_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{2,1}*24,{24,24}}});
Animate2D::FrameSequence pl_idle_s; ANIMATION_DATA[AnimationState::WARRIOR_WALK_N]=pl_warrior_walk_n;
pl_idle_s.AddFrame({&GFX_Pl_Sheet,{vi2d{0,0}*24,{24,24}}}); Animate2D::FrameSequence pl_warrior_idle_s;
ANIMATION_DATA[AnimationState::IDLE_S]=pl_idle_s; pl_warrior_idle_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,0}*24,{24,24}}});
Animate2D::FrameSequence pl_idle_e; ANIMATION_DATA[AnimationState::WARRIOR_IDLE_S]=pl_warrior_idle_s;
pl_idle_e.AddFrame({&GFX_Pl_Sheet,{vi2d{0,3}*24,{24,24}}}); Animate2D::FrameSequence pl_warrior_idle_e;
ANIMATION_DATA[AnimationState::IDLE_E]=pl_idle_e; pl_warrior_idle_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,3}*24,{24,24}}});
Animate2D::FrameSequence pl_idle_w; ANIMATION_DATA[AnimationState::WARRIOR_IDLE_E]=pl_warrior_idle_e;
pl_idle_w.AddFrame({&GFX_Pl_Sheet,{vi2d{0,2}*24,{24,24}}}); Animate2D::FrameSequence pl_warrior_idle_w;
ANIMATION_DATA[AnimationState::IDLE_W]=pl_idle_w; pl_warrior_idle_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,2}*24,{24,24}}});
Animate2D::FrameSequence pl_idle_n; ANIMATION_DATA[AnimationState::WARRIOR_IDLE_W]=pl_warrior_idle_w;
pl_idle_n.AddFrame({&GFX_Pl_Sheet,{vi2d{0,1}*24,{24,24}}}); Animate2D::FrameSequence pl_warrior_idle_n;
ANIMATION_DATA[AnimationState::IDLE_N]=pl_idle_n; pl_warrior_idle_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,1}*24,{24,24}}});
Animate2D::FrameSequence pl_swing_s(0.05),pl_swing_n(0.05),pl_swing_e(0.05),pl_swing_w(0.05); ANIMATION_DATA[AnimationState::WARRIOR_IDLE_N]=pl_warrior_idle_n;
Animate2D::FrameSequence pl_warrior_swing_s(0.05),pl_warrior_swing_n(0.05),pl_warrior_swing_e(0.05),pl_warrior_swing_w(0.05);
for (int i=0;i<4;i++){ for (int i=0;i<4;i++){
pl_swing_s.AddFrame({&GFX_Pl_Sheet,{vi2d{4+i,0}*24,{24,24}}}); pl_warrior_swing_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,0}*24,{24,24}}});
} }
for (int i=0;i<4;i++){ for (int i=0;i<4;i++){
pl_swing_n.AddFrame({&GFX_Pl_Sheet,{vi2d{4+i,1}*24,{24,24}}}); pl_warrior_swing_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,1}*24,{24,24}}});
} }
for (int i=0;i<4;i++){ for (int i=0;i<4;i++){
pl_swing_w.AddFrame({&GFX_Pl_Sheet,{vi2d{4+i,2}*24,{24,24}}}); pl_warrior_swing_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,2}*24,{24,24}}});
} }
for (int i=0;i<4;i++){ for (int i=0;i<4;i++){
pl_swing_e.AddFrame({&GFX_Pl_Sheet,{vi2d{4+i,3}*24,{24,24}}}); pl_warrior_swing_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,3}*24,{24,24}}});
} }
ANIMATION_DATA[AnimationState::SWINGSWORD_N]=pl_swing_n; ANIMATION_DATA[AnimationState::SWINGSWORD_N]=pl_warrior_swing_n;
ANIMATION_DATA[AnimationState::SWINGSWORD_E]=pl_swing_e; ANIMATION_DATA[AnimationState::SWINGSWORD_E]=pl_warrior_swing_e;
ANIMATION_DATA[AnimationState::SWINGSWORD_S]=pl_swing_s; ANIMATION_DATA[AnimationState::SWINGSWORD_S]=pl_warrior_swing_s;
ANIMATION_DATA[AnimationState::SWINGSWORD_W]=pl_swing_w; ANIMATION_DATA[AnimationState::SWINGSWORD_W]=pl_warrior_swing_w;
//Ranger animations
Animate2D::FrameSequence pl_ranger_walk_s{0.2};
pl_ranger_walk_s.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,0}*24,{24,24}}});
pl_ranger_walk_s.AddFrame({&GFX_Ranger_Sheet,{vi2d{1,0}*24,{24,24}}});
pl_ranger_walk_s.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,0}*24,{24,24}}});
pl_ranger_walk_s.AddFrame({&GFX_Ranger_Sheet,{vi2d{2,0}*24,{24,24}}});
ANIMATION_DATA[AnimationState::RANGER_WALK_S]=pl_ranger_walk_s;
Animate2D::FrameSequence pl_ranger_walk_e{0.2};
pl_ranger_walk_e.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,3}*24,{24,24}}});
pl_ranger_walk_e.AddFrame({&GFX_Ranger_Sheet,{vi2d{1,3}*24,{24,24}}});
pl_ranger_walk_e.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,3}*24,{24,24}}});
pl_ranger_walk_e.AddFrame({&GFX_Ranger_Sheet,{vi2d{2,3}*24,{24,24}}});
ANIMATION_DATA[AnimationState::RANGER_WALK_E]=pl_ranger_walk_e;
Animate2D::FrameSequence pl_ranger_walk_w{0.2};
pl_ranger_walk_w.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,2}*24,{24,24}}});
pl_ranger_walk_w.AddFrame({&GFX_Ranger_Sheet,{vi2d{1,2}*24,{24,24}}});
pl_ranger_walk_w.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,2}*24,{24,24}}});
pl_ranger_walk_w.AddFrame({&GFX_Ranger_Sheet,{vi2d{2,2}*24,{24,24}}});
ANIMATION_DATA[AnimationState::RANGER_WALK_W]=pl_ranger_walk_w;
Animate2D::FrameSequence pl_ranger_walk_n{0.2};
pl_ranger_walk_n.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,1}*24,{24,24}}});
pl_ranger_walk_n.AddFrame({&GFX_Ranger_Sheet,{vi2d{1,1}*24,{24,24}}});
pl_ranger_walk_n.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,1}*24,{24,24}}});
pl_ranger_walk_n.AddFrame({&GFX_Ranger_Sheet,{vi2d{2,1}*24,{24,24}}});
ANIMATION_DATA[AnimationState::RANGER_WALK_N]=pl_ranger_walk_n;
Animate2D::FrameSequence pl_ranger_idle_s;
pl_ranger_idle_s.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,0}*24,{24,24}}});
ANIMATION_DATA[AnimationState::RANGER_IDLE_S]=pl_ranger_idle_s;
Animate2D::FrameSequence pl_ranger_idle_e;
pl_ranger_idle_e.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,3}*24,{24,24}}});
ANIMATION_DATA[AnimationState::RANGER_IDLE_E]=pl_ranger_idle_e;
Animate2D::FrameSequence pl_ranger_idle_w;
pl_ranger_idle_w.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,2}*24,{24,24}}});
ANIMATION_DATA[AnimationState::RANGER_IDLE_W]=pl_ranger_idle_w;
Animate2D::FrameSequence pl_ranger_idle_n;
pl_ranger_idle_n.AddFrame({&GFX_Ranger_Sheet,{vi2d{0,1}*24,{24,24}}});
ANIMATION_DATA[AnimationState::RANGER_IDLE_N]=pl_ranger_idle_n;
//Wizard animations
Animate2D::FrameSequence pl_wizard_walk_s{0.2};
pl_wizard_walk_s.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,0}*24,{24,24}}});
pl_wizard_walk_s.AddFrame({&GFX_Wizard_Sheet,{vi2d{1,0}*24,{24,24}}});
pl_wizard_walk_s.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,0}*24,{24,24}}});
pl_wizard_walk_s.AddFrame({&GFX_Wizard_Sheet,{vi2d{2,0}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WIZARD_WALK_S]=pl_wizard_walk_s;
Animate2D::FrameSequence pl_wizard_walk_e{0.2};
pl_wizard_walk_e.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,3}*24,{24,24}}});
pl_wizard_walk_e.AddFrame({&GFX_Wizard_Sheet,{vi2d{1,3}*24,{24,24}}});
pl_wizard_walk_e.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,3}*24,{24,24}}});
pl_wizard_walk_e.AddFrame({&GFX_Wizard_Sheet,{vi2d{2,3}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WIZARD_WALK_E]=pl_wizard_walk_e;
Animate2D::FrameSequence pl_wizard_walk_w{0.2};
pl_wizard_walk_w.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,2}*24,{24,24}}});
pl_wizard_walk_w.AddFrame({&GFX_Wizard_Sheet,{vi2d{1,2}*24,{24,24}}});
pl_wizard_walk_w.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,2}*24,{24,24}}});
pl_wizard_walk_w.AddFrame({&GFX_Wizard_Sheet,{vi2d{2,2}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WIZARD_WALK_W]=pl_wizard_walk_w;
Animate2D::FrameSequence pl_wizard_walk_n{0.2};
pl_wizard_walk_n.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,1}*24,{24,24}}});
pl_wizard_walk_n.AddFrame({&GFX_Wizard_Sheet,{vi2d{1,1}*24,{24,24}}});
pl_wizard_walk_n.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,1}*24,{24,24}}});
pl_wizard_walk_n.AddFrame({&GFX_Wizard_Sheet,{vi2d{2,1}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WIZARD_WALK_N]=pl_wizard_walk_n;
Animate2D::FrameSequence pl_wizard_idle_s;
pl_wizard_idle_s.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,0}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WIZARD_IDLE_S]=pl_wizard_idle_s;
Animate2D::FrameSequence pl_wizard_idle_e;
pl_wizard_idle_e.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,3}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WIZARD_IDLE_E]=pl_wizard_idle_e;
Animate2D::FrameSequence pl_wizard_idle_w;
pl_wizard_idle_w.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,2}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WIZARD_IDLE_W]=pl_wizard_idle_w;
Animate2D::FrameSequence pl_wizard_idle_n;
pl_wizard_idle_n.AddFrame({&GFX_Wizard_Sheet,{vi2d{0,1}*24,{24,24}}});
ANIMATION_DATA[AnimationState::WIZARD_IDLE_N]=pl_wizard_idle_n;
//Load slime animations. //Load slime animations.
for(int slime=0;slime<4;slime++){ for(int slime=0;slime<4;slime++){
for(int state=0;state<5;state++){ for(int state=0;state<5;state++){
@ -225,9 +319,49 @@ bool Crawler::DownReleased(){
void Crawler::HandleUserInput(float fElapsedTime){ void Crawler::HandleUserInput(float fElapsedTime){
bool setIdleAnimation=true; bool setIdleAnimation=true;
if(GetKey(SPACE).bPressed&&player.GetAbility2Cooldown()==0){ if(GetMouseWheel()>0){
player.Spin(Player::GROUND_SLAM_SPIN_TIME,14*PI); switch(player.cl){
player.iframe_time=Player::GROUND_SLAM_SPIN_TIME+0.1; case WARRIOR:{
player.SetClass(RANGER);
}break;
case RANGER:{
player.SetClass(WIZARD);
}break;
case WIZARD:{
player.SetClass(WARRIOR);
}break;
}
}
if(GetMouseWheel()<0){
switch(player.cl){
case WARRIOR:{
player.SetClass(WIZARD);
}break;
case RANGER:{
player.SetClass(WARRIOR);
}break;
case WIZARD:{
player.SetClass(RANGER);
}break;
}
}
if(player.ability2.cooldown==0&&GetKey(SPACE).bPressed){
switch(player.cl){
case WARRIOR:{
player.Spin(Player::GROUND_SLAM_SPIN_TIME,14*PI);
player.iframe_time=Player::GROUND_SLAM_SPIN_TIME+0.1;
}break;
case THIEF:{
}break;
case RANGER:{
}break;
case BARD:{
}break;
case WIZARD:{
}break;
case WITCH:{
}break;
}
} }
if(player.GetVelocity()==vf2d{0,0}){ if(player.GetVelocity()==vf2d{0,0}){
if(RightHeld()){ if(RightHeld()){
@ -238,7 +372,7 @@ void Crawler::HandleUserInput(float fElapsedTime){
} }
player.SetFacingDirection(RIGHT); player.SetFacingDirection(RIGHT);
if(player.GetState()==State::NORMAL){ if(player.GetState()==State::NORMAL){
player.UpdateAnimation(AnimationState::WALK_E); player.UpdateWalkingAnimation(RIGHT);
} }
setIdleAnimation=false; setIdleAnimation=false;
} }
@ -251,7 +385,7 @@ void Crawler::HandleUserInput(float fElapsedTime){
if(setIdleAnimation){ if(setIdleAnimation){
player.SetFacingDirection(LEFT); player.SetFacingDirection(LEFT);
if(player.GetState()==State::NORMAL){ if(player.GetState()==State::NORMAL){
player.UpdateAnimation(AnimationState::WALK_W); player.UpdateWalkingAnimation(LEFT);
} }
} }
setIdleAnimation=false; setIdleAnimation=false;
@ -265,7 +399,7 @@ void Crawler::HandleUserInput(float fElapsedTime){
if(setIdleAnimation){ if(setIdleAnimation){
player.SetFacingDirection(UP); player.SetFacingDirection(UP);
if(player.GetState()==State::NORMAL){ if(player.GetState()==State::NORMAL){
player.UpdateAnimation(AnimationState::WALK_N); player.UpdateWalkingAnimation(UP);
} }
} }
setIdleAnimation=false; setIdleAnimation=false;
@ -279,7 +413,7 @@ void Crawler::HandleUserInput(float fElapsedTime){
if(setIdleAnimation){ if(setIdleAnimation){
player.SetFacingDirection(DOWN); player.SetFacingDirection(DOWN);
if(player.GetState()==State::NORMAL){ if(player.GetState()==State::NORMAL){
player.UpdateAnimation(AnimationState::WALK_S); player.UpdateWalkingAnimation(DOWN);
} }
} }
setIdleAnimation=false; setIdleAnimation=false;
@ -289,13 +423,13 @@ void Crawler::HandleUserInput(float fElapsedTime){
player.SetLastReleasedMovementKey(UP); player.SetLastReleasedMovementKey(UP);
if(player.GetState()==State::NORMAL){ if(player.GetState()==State::NORMAL){
if(RightHeld()){ if(RightHeld()){
player.UpdateAnimation(AnimationState::WALK_E); player.UpdateWalkingAnimation(RIGHT);
} else } else
if(DownHeld()){ if(DownHeld()){
player.UpdateAnimation(AnimationState::WALK_S); player.UpdateWalkingAnimation(DOWN);
} else } else
if(LeftHeld()){ if(LeftHeld()){
player.UpdateAnimation(AnimationState::WALK_W); player.UpdateWalkingAnimation(LEFT);
} }
} }
} }
@ -303,13 +437,13 @@ void Crawler::HandleUserInput(float fElapsedTime){
player.SetLastReleasedMovementKey(RIGHT); player.SetLastReleasedMovementKey(RIGHT);
if(player.GetState()==State::NORMAL){ if(player.GetState()==State::NORMAL){
if(UpHeld()){ if(UpHeld()){
player.UpdateAnimation(AnimationState::WALK_N); player.UpdateWalkingAnimation(UP);
} else } else
if(DownHeld()){ if(DownHeld()){
player.UpdateAnimation(AnimationState::WALK_S); player.UpdateWalkingAnimation(DOWN);
} else } else
if(LeftHeld()){ if(LeftHeld()){
player.UpdateAnimation(AnimationState::WALK_W); player.UpdateWalkingAnimation(LEFT);
} }
} }
} }
@ -317,13 +451,13 @@ void Crawler::HandleUserInput(float fElapsedTime){
player.SetLastReleasedMovementKey(LEFT); player.SetLastReleasedMovementKey(LEFT);
if(player.GetState()==State::NORMAL){ if(player.GetState()==State::NORMAL){
if(RightHeld()){ if(RightHeld()){
player.UpdateAnimation(AnimationState::WALK_E); player.UpdateWalkingAnimation(RIGHT);
} else } else
if(DownHeld()){ if(DownHeld()){
player.UpdateAnimation(AnimationState::WALK_S); player.UpdateWalkingAnimation(DOWN);
} else } else
if(UpHeld()){ if(UpHeld()){
player.UpdateAnimation(AnimationState::WALK_N); player.UpdateWalkingAnimation(UP);
} }
} }
} }
@ -331,13 +465,13 @@ void Crawler::HandleUserInput(float fElapsedTime){
player.SetLastReleasedMovementKey(DOWN); player.SetLastReleasedMovementKey(DOWN);
if(player.GetState()==State::NORMAL){ if(player.GetState()==State::NORMAL){
if(RightHeld()){ if(RightHeld()){
player.UpdateAnimation(AnimationState::WALK_E); player.UpdateWalkingAnimation(RIGHT);
} else } else
if(UpHeld()){ if(UpHeld()){
player.UpdateAnimation(AnimationState::WALK_N); player.UpdateWalkingAnimation(UP);
} else } else
if(LeftHeld()){ if(LeftHeld()){
player.UpdateAnimation(AnimationState::WALK_W); player.UpdateWalkingAnimation(LEFT);
} }
} }
} }
@ -372,19 +506,19 @@ void Crawler::HandleUserInput(float fElapsedTime){
if(setIdleAnimation){ if(setIdleAnimation){
switch(player.GetLastReleasedMovementKey()){ switch(player.GetLastReleasedMovementKey()){
case UP:{ case UP:{
player.UpdateAnimation(AnimationState::IDLE_N); player.UpdateIdleAnimation(UP);
}break; }break;
case DOWN:{ case DOWN:{
player.UpdateAnimation(AnimationState::IDLE_S); player.UpdateIdleAnimation(DOWN);
}break; }break;
case LEFT:{ case LEFT:{
player.UpdateAnimation(AnimationState::IDLE_W); player.UpdateIdleAnimation(LEFT);
}break; }break;
case RIGHT:{ case RIGHT:{
player.UpdateAnimation(AnimationState::IDLE_E); player.UpdateIdleAnimation(RIGHT);
}break; }break;
default:{ default:{
player.UpdateAnimation(AnimationState::IDLE_S); player.UpdateIdleAnimation(DOWN);
} }
} }
} else { } else {

4
Crawler/Crawler.h
View File

@ -12,9 +12,9 @@ class Crawler : public olc::PixelGameEngine
{ {
Camera2D camera; Camera2D camera;
Player player; Player player;
Renderable GFX_Pl_Sheet,GFX_Slime_Sheet,GFX_Circle, Renderable GFX_Warrior_Sheet,GFX_Slime_Sheet,GFX_Circle,
GFX_Effect_GroundSlam_Back,GFX_Effect_GroundSlam_Front, GFX_Effect_GroundSlam_Back,GFX_Effect_GroundSlam_Front,
GFX_Heart,GFX_BLOCK_BUBBLE; GFX_Heart,GFX_BLOCK_BUBBLE,GFX_Ranger_Sheet,GFX_Wizard_Sheet;
std::vector<Effect>foregroundEffects,backgroundEffects; std::vector<Effect>foregroundEffects,backgroundEffects;
public: public:

2
Crawler/Monster.cpp
View File

@ -305,7 +305,7 @@ AnimationState Monster::GetDeathAnimationName(){
return AnimationState::RED_SLIME_DIE; return AnimationState::RED_SLIME_DIE;
} }
default:{ default:{
return AnimationState::IDLE_S; return AnimationState::WARRIOR_IDLE_S;
} }
} }
} }

123
Crawler/Player.cpp
View File

@ -23,6 +23,7 @@ void Player::SetClass(Class cl){
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);
} }
void Player::SetX(float x){ void Player::SetX(float x){
@ -99,14 +100,14 @@ void Player::Update(float fElapsedTime){
if(lastAnimationFlip==0){ if(lastAnimationFlip==0){
lastAnimationFlip=0.03; lastAnimationFlip=0.03;
facingDirection=DOWN; facingDirection=DOWN;
animation.ChangeState(internal_animState,AnimationState::WALK_S); animation.ChangeState(internal_animState,AnimationState::WARRIOR_WALK_S);
} }
}break; }break;
case DOWN:{ case DOWN:{
if(lastAnimationFlip==0){ if(lastAnimationFlip==0){
lastAnimationFlip=0.03; lastAnimationFlip=0.03;
facingDirection=UP; facingDirection=UP;
animation.ChangeState(internal_animState,AnimationState::WALK_N); animation.ChangeState(internal_animState,AnimationState::WARRIOR_WALK_N);
} }
}break; }break;
} }
@ -177,41 +178,71 @@ void Player::Update(float fElapsedTime){
pos.y=newY; pos.y=newY;
} }
if(attack_cooldown_timer==0&&game->GetMouse(0).bHeld){ if(attack_cooldown_timer==0&&game->GetMouse(0).bHeld){
bool attack=false; switch (cl) {
Monster*closest=nullptr; case WARRIOR: {
float closest_dist=999999; bool attack=false;
for(Monster&m:MONSTER_LIST){ Monster*closest=nullptr;
if(m.IsAlive() float closest_dist=999999;
&&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)) for(Monster&m:MONSTER_LIST){
&&geom2d::line<float>(game->GetWorldMousePos(),m.GetPos()).length()<closest_dist){ if(m.IsAlive()
closest_dist=geom2d::line<float>(game->GetWorldMousePos(),m.GetPos()).length(); &&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))
closest=&m; &&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(atk)){ }
attack_cooldown_timer=ATTACK_COOLDOWN; }
swordSwingTimer=0.2; if(closest!=nullptr&&closest->Hurt(atk)){
SetState(State::SWING_SWORD); attack_cooldown_timer=ATTACK_COOLDOWN;
switch(facingDirection){ swordSwingTimer=0.2;
case DOWN:{ SetState(State::SWING_SWORD);
UpdateAnimation(AnimationState::SWINGSWORD_S); switch(facingDirection){
}break; case DOWN:{
case RIGHT:{ UpdateAnimation(AnimationState::SWINGSWORD_S);
UpdateAnimation(AnimationState::SWINGSWORD_E); }break;
}break; case RIGHT:{
case LEFT:{ UpdateAnimation(AnimationState::SWINGSWORD_E);
UpdateAnimation(AnimationState::SWINGSWORD_W); }break;
}break; case LEFT:{
case UP:{ UpdateAnimation(AnimationState::SWINGSWORD_W);
UpdateAnimation(AnimationState::SWINGSWORD_N); }break;
}break; case UP:{
} UpdateAnimation(AnimationState::SWINGSWORD_N);
}break;
}
}
}break;
case THIEF: {
}break;
case RANGER: {
}break;
case BARD: {
}break;
case WIZARD: {
}break;
case WITCH: {
}break;
} }
} }
if(rightClickAbility.cooldown==0&&GetState()==State::NORMAL&&game->GetMouse(1).bHeld){ if(rightClickAbility.cooldown==0&&game->GetMouse(1).bHeld){
rightClickAbility.cooldown=rightClickAbility.COOLDOWN_TIME; switch (cl) {
SetState(State::BLOCK); case WARRIOR: {
moveSpd=0.7; if(GetState()==State::NORMAL){
rightClickAbility.cooldown=rightClickAbility.COOLDOWN_TIME;
SetState(State::BLOCK);
moveSpd=0.7;
}
}break;
case THIEF: {
}break;
case RANGER: {
}break;
case BARD: {
}break;
case WIZARD: {
}break;
case WITCH: {
}break;
}
} }
} }
@ -291,4 +322,26 @@ void Player::Spin(float duration,float spinSpd){
spin_spd=spinSpd; spin_spd=spinSpd;
spin_angle=0; spin_angle=0;
ability2.cooldown=ability2.COOLDOWN_TIME; ability2.cooldown=ability2.COOLDOWN_TIME;
}
void Player::UpdateWalkingAnimation(Key direction){
AnimationState anim;
switch(direction){
case UP:anim=CLASS_DATA[cl].walk_n;break;
case RIGHT:anim=CLASS_DATA[cl].walk_e;break;
case DOWN:anim=CLASS_DATA[cl].walk_s;break;
case LEFT:anim=CLASS_DATA[cl].walk_w;break;
}
UpdateAnimation(anim);
}
void Player::UpdateIdleAnimation(Key direction){
AnimationState anim;
switch(direction){
case UP:anim=CLASS_DATA[cl].idle_n;break;
case RIGHT:anim=CLASS_DATA[cl].idle_e;break;
case DOWN:anim=CLASS_DATA[cl].idle_s;break;
case LEFT:anim=CLASS_DATA[cl].idle_w;break;
}
UpdateAnimation(anim);
} }

2
Crawler/Player.h
View File

@ -64,6 +64,8 @@ public:
Key GetFacingDirection(); Key GetFacingDirection();
vf2d GetVelocity(); vf2d GetVelocity();
bool HasIframes(); bool HasIframes();
void UpdateWalkingAnimation(Key direction);
void UpdateIdleAnimation(Key direction);
bool Hurt(int damage); bool Hurt(int damage);
void UpdateAnimation(AnimationState animState); void UpdateAnimation(AnimationState animState);

BIN
Crawler/assets/nico-ranger.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 15 KiB

After

Width:  |  Height:  |  Size: 19 KiB

BIN
Crawler/assets/nico-ranger2.xcf
View File

Binary file not shown.

BIN
Crawler/assets/nico-wizard.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 11 KiB

After

Width:  |  Height:  |  Size: 12 KiB

BIN
Crawler/assets/nico-wizard.xcf
View File

Binary file not shown.

36
Crawler/switch-class.snippet Normal file
View File

@ -0,0 +1,36 @@
<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
<CodeSnippet Format="1.0.0">
<Header>
<Title>Class Switch</Title>
<Author>Sig</Author>
<Description>A switch statement of all classes.</Description>
<Shortcut>switchcl</Shortcut>
</Header>
<Snippet>
<Code Language="CPP">
<![CDATA[switch ($clVar$){
case WARRIOR:{
}break;
case THIEF:{
}break;
case RANGER:{
}break;
case BARD:{
}break;
case WIZARD:{
}break;
case WITCH:{
}break;
}]]>
</Code>
<Declarations>
<Literal>
<ID>clVar</ID>
<ToolTip>Name of the class variable.</ToolTip>
<Default>cl</Default>
</Literal>
</Declarations>
</Snippet>
</CodeSnippet>
</CodeSnippets>