The open source repository for the action RPG game in development by Sig Productions titled 'Adventures in Lestoria'!
https://forums.lestoria.net
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
705 lines
26 KiB
705 lines
26 KiB
#include "olcPGEX_TransformedView.h"
|
|
#include "Crawler.h"
|
|
#include "olcUTIL_Camera2D.h"
|
|
#include "DamageNumber.h"
|
|
#include "Bullet.h"
|
|
#include "Ability.h"
|
|
#include "Class.h"
|
|
#include "DEFINES.h"
|
|
|
|
//192x192
|
|
const vi2d WINDOW_SIZE={24*15,24*10};
|
|
std::map<AnimationState,Animate2D::FrameSequence>ANIMATION_DATA;
|
|
std::vector<Monster>MONSTER_LIST;
|
|
std::vector<MonsterSpawner>SPAWNER_LIST;
|
|
std::vector<DamageNumber>DAMAGENUMBER_LIST;
|
|
std::vector<Bullet>BULLET_LIST;
|
|
Crawler*game;
|
|
|
|
Crawler::Crawler()
|
|
{
|
|
sAppName = "Crawler Concept";
|
|
game=this;
|
|
}
|
|
|
|
bool Crawler::OnUserCreate(){
|
|
//Initialize Camera.
|
|
camera=Camera2D{WINDOW_SIZE};
|
|
camera.SetMode(olc::utils::Camera2D::Mode::LazyFollow);
|
|
camera.SetTarget(player.GetPos());
|
|
camera.SetWorldBoundary({0,0},WORLD_SIZE*24);
|
|
camera.EnableWorldBoundary(false);
|
|
|
|
//Graphics
|
|
GFX_Warrior_Sheet.Load("assets/nico-warrior.png");
|
|
GFX_Slime_Sheet.Load("assets/slime.png");
|
|
GFX_Circle.Load("assets/circle.png");
|
|
GFX_Effect_GroundSlam_Back.Load("assets/ground-slam-attack-back.png");
|
|
GFX_Effect_GroundSlam_Front.Load("assets/ground-slam-attack-front.png");
|
|
GFX_Heart.Load("assets/heart.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
|
|
InitializeAnimations();
|
|
|
|
player.AddAnimation(AnimationState::WARRIOR_WALK_N);
|
|
player.AddAnimation(AnimationState::WARRIOR_WALK_E);
|
|
player.AddAnimation(AnimationState::WARRIOR_WALK_S);
|
|
player.AddAnimation(AnimationState::WARRIOR_WALK_W);
|
|
player.AddAnimation(AnimationState::WARRIOR_IDLE_N);
|
|
player.AddAnimation(AnimationState::WARRIOR_IDLE_E);
|
|
player.AddAnimation(AnimationState::WARRIOR_IDLE_S);
|
|
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_S);
|
|
player.AddAnimation(AnimationState::SWINGSWORD_N);
|
|
player.AddAnimation(AnimationState::SWINGSWORD_W);
|
|
view=TileTransformedView{GetScreenSize(),{1,1}};
|
|
|
|
player.SetClass(WARRIOR);
|
|
player.SetPos({4*24,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}}
|
|
}}));
|
|
SPAWNER_LIST.push_back(MonsterSpawner({360*2,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}}
|
|
,{MonsterName::SLIME_RED,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
}}));
|
|
SPAWNER_LIST.push_back(MonsterSpawner({360*3,96},4*24,{{
|
|
{MonsterName::SLIME_BLUE,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_BLUE,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
}}));
|
|
SPAWNER_LIST.push_back(MonsterSpawner({360*4,96},4*24,{{
|
|
{MonsterName::SLIME_BLUE,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_BLUE,{(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}}
|
|
,{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}}
|
|
}}));
|
|
SPAWNER_LIST.push_back(MonsterSpawner({360*5,96},4*24,{{
|
|
{MonsterName::SLIME_BLUE,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_BLUE,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_RED,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_RED,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
}}));
|
|
SPAWNER_LIST.push_back(MonsterSpawner({360*6,96},4*24,{{
|
|
{MonsterName::SLIME_RED,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_RED,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_RED,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_RED,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_RED,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
}}));
|
|
SPAWNER_LIST.push_back(MonsterSpawner({360*7,96},4*24,{{
|
|
{MonsterName::SLIME_BLUE,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_BLUE,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_BLUE,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_BLUE,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
,{MonsterName::SLIME_BLUE,{(rand()%20/2.f-5)*24,(rand()%20/2.f-5)*24}}
|
|
}}));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Crawler::OnUserUpdate(float fElapsedTime){
|
|
HandleUserInput(fElapsedTime);
|
|
UpdateEffects(fElapsedTime);
|
|
player.Update(fElapsedTime);
|
|
for(Monster&m:MONSTER_LIST){
|
|
m.Update(fElapsedTime);
|
|
}
|
|
UpdateBullets(fElapsedTime);
|
|
UpdateCamera(fElapsedTime);
|
|
RenderWorld(fElapsedTime);
|
|
RenderHud();
|
|
return true;
|
|
}
|
|
|
|
void Crawler::InitializeAnimations(){
|
|
//Warrior animations.
|
|
Animate2D::FrameSequence pl_warrior_walk_s{0.2};
|
|
pl_warrior_walk_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,0}*24,{24,24}}});
|
|
pl_warrior_walk_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{1,0}*24,{24,24}}});
|
|
pl_warrior_walk_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,0}*24,{24,24}}});
|
|
pl_warrior_walk_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{2,0}*24,{24,24}}});
|
|
ANIMATION_DATA[AnimationState::WARRIOR_WALK_S]=pl_warrior_walk_s;
|
|
Animate2D::FrameSequence pl_warrior_walk_e{0.2};
|
|
pl_warrior_walk_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,3}*24,{24,24}}});
|
|
pl_warrior_walk_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{1,3}*24,{24,24}}});
|
|
pl_warrior_walk_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,3}*24,{24,24}}});
|
|
pl_warrior_walk_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{2,3}*24,{24,24}}});
|
|
ANIMATION_DATA[AnimationState::WARRIOR_WALK_E]=pl_warrior_walk_e;
|
|
Animate2D::FrameSequence pl_warrior_walk_w{0.2};
|
|
pl_warrior_walk_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,2}*24,{24,24}}});
|
|
pl_warrior_walk_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{1,2}*24,{24,24}}});
|
|
pl_warrior_walk_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,2}*24,{24,24}}});
|
|
pl_warrior_walk_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{2,2}*24,{24,24}}});
|
|
ANIMATION_DATA[AnimationState::WARRIOR_WALK_W]=pl_warrior_walk_w;
|
|
Animate2D::FrameSequence pl_warrior_walk_n{0.2};
|
|
pl_warrior_walk_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,1}*24,{24,24}}});
|
|
pl_warrior_walk_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{1,1}*24,{24,24}}});
|
|
pl_warrior_walk_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,1}*24,{24,24}}});
|
|
pl_warrior_walk_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{2,1}*24,{24,24}}});
|
|
ANIMATION_DATA[AnimationState::WARRIOR_WALK_N]=pl_warrior_walk_n;
|
|
Animate2D::FrameSequence pl_warrior_idle_s;
|
|
pl_warrior_idle_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,0}*24,{24,24}}});
|
|
ANIMATION_DATA[AnimationState::WARRIOR_IDLE_S]=pl_warrior_idle_s;
|
|
Animate2D::FrameSequence pl_warrior_idle_e;
|
|
pl_warrior_idle_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,3}*24,{24,24}}});
|
|
ANIMATION_DATA[AnimationState::WARRIOR_IDLE_E]=pl_warrior_idle_e;
|
|
Animate2D::FrameSequence pl_warrior_idle_w;
|
|
pl_warrior_idle_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,2}*24,{24,24}}});
|
|
ANIMATION_DATA[AnimationState::WARRIOR_IDLE_W]=pl_warrior_idle_w;
|
|
Animate2D::FrameSequence pl_warrior_idle_n;
|
|
pl_warrior_idle_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{0,1}*24,{24,24}}});
|
|
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++){
|
|
pl_warrior_swing_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,0}*24,{24,24}}});
|
|
}
|
|
for (int i=0;i<4;i++){
|
|
pl_warrior_swing_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,1}*24,{24,24}}});
|
|
}
|
|
for (int i=0;i<4;i++){
|
|
pl_warrior_swing_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,2}*24,{24,24}}});
|
|
}
|
|
for (int i=0;i<4;i++){
|
|
pl_warrior_swing_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,3}*24,{24,24}}});
|
|
}
|
|
ANIMATION_DATA[AnimationState::SWINGSWORD_N]=pl_warrior_swing_n;
|
|
ANIMATION_DATA[AnimationState::SWINGSWORD_E]=pl_warrior_swing_e;
|
|
ANIMATION_DATA[AnimationState::SWINGSWORD_S]=pl_warrior_swing_s;
|
|
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.
|
|
for(int slime=0;slime<4;slime++){
|
|
for(int state=0;state<5;state++){
|
|
Animate2D::FrameSequence anim;
|
|
if(state==4){//These are death animations.
|
|
anim=Animate2D::FrameSequence(0.1f,Animate2D::Style::OneShot);
|
|
}
|
|
if(state==2){//These are death animations.
|
|
anim=Animate2D::FrameSequence(0.06f);
|
|
}
|
|
for (int frame=0;frame<10;frame++){
|
|
anim.AddFrame({&GFX_Slime_Sheet,{vi2d{frame,state+5*slime}*24,{24,24}}});
|
|
}
|
|
ANIMATION_DATA[AnimationState(AnimationState::GREEN_SLIME_IDLE+state+slime*5)]=anim;
|
|
}
|
|
}
|
|
Animate2D::FrameSequence effect_groundslam_back(0.02f,Animate2D::Style::OneShot),effect_groundslam_front(0.02f,Animate2D::Style::OneShot);
|
|
for(int i=0;i<5;i++){
|
|
effect_groundslam_back.AddFrame({&GFX_Effect_GroundSlam_Back,{{i*64,0},{64,64}}});
|
|
effect_groundslam_front.AddFrame({&GFX_Effect_GroundSlam_Front,{{i*64,0},{64,64}}});
|
|
}
|
|
ANIMATION_DATA[AnimationState::GROUND_SLAM_ATTACK_BACK]=effect_groundslam_back;
|
|
ANIMATION_DATA[AnimationState::GROUND_SLAM_ATTACK_FRONT]=effect_groundslam_front;
|
|
}
|
|
|
|
bool Crawler::LeftHeld(){
|
|
return GetKey(LEFT).bHeld|GetKey(A).bHeld;
|
|
}
|
|
bool Crawler::RightHeld(){
|
|
return GetKey(RIGHT).bHeld|GetKey(D).bHeld;
|
|
}
|
|
bool Crawler::UpHeld(){
|
|
return GetKey(UP).bHeld|GetKey(W).bHeld;
|
|
}
|
|
bool Crawler::DownHeld(){
|
|
return GetKey(DOWN).bHeld|GetKey(S).bHeld;
|
|
}
|
|
bool Crawler::LeftReleased(){
|
|
return GetKey(LEFT).bReleased|GetKey(A).bReleased;
|
|
}
|
|
bool Crawler::RightReleased(){
|
|
return GetKey(RIGHT).bReleased|GetKey(D).bReleased;
|
|
}
|
|
bool Crawler::UpReleased(){
|
|
return GetKey(UP).bReleased|GetKey(W).bReleased;
|
|
}
|
|
bool Crawler::DownReleased(){
|
|
return GetKey(DOWN).bReleased|GetKey(S).bReleased;
|
|
}
|
|
|
|
void Crawler::HandleUserInput(float fElapsedTime){
|
|
bool setIdleAnimation=true;
|
|
if(GetMouseWheel()>0){
|
|
switch(player.cl){
|
|
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(RightHeld()){
|
|
if(player.GetPos().x+12*player.GetSizeMult()+fElapsedTime*100*player.GetMoveSpdMult()<WORLD_SIZE.x*24){
|
|
player.SetX(player.GetX()+fElapsedTime*100*player.GetMoveSpdMult());
|
|
} else {
|
|
player.SetX(WORLD_SIZE.x*24-12);
|
|
}
|
|
player.SetFacingDirection(RIGHT);
|
|
if(player.GetState()==State::NORMAL){
|
|
player.UpdateWalkingAnimation(RIGHT);
|
|
}
|
|
setIdleAnimation=false;
|
|
}
|
|
if(LeftHeld()){
|
|
if(player.GetPos().x-12*player.GetSizeMult()+fElapsedTime*100*player.GetMoveSpdMult()>0){
|
|
player.SetX(player.GetX()-fElapsedTime*100*player.GetMoveSpdMult());
|
|
} else {
|
|
player.SetX(12);
|
|
}
|
|
if(setIdleAnimation){
|
|
player.SetFacingDirection(LEFT);
|
|
if(player.GetState()==State::NORMAL){
|
|
player.UpdateWalkingAnimation(LEFT);
|
|
}
|
|
}
|
|
setIdleAnimation=false;
|
|
}
|
|
if(UpHeld()){
|
|
if(player.GetPos().y-12*player.GetSizeMult()+fElapsedTime*100*player.GetMoveSpdMult()>0){
|
|
player.SetY(player.GetY()-fElapsedTime*100*player.GetMoveSpdMult());
|
|
} else {
|
|
player.SetY(12);
|
|
}
|
|
if(setIdleAnimation){
|
|
player.SetFacingDirection(UP);
|
|
if(player.GetState()==State::NORMAL){
|
|
player.UpdateWalkingAnimation(UP);
|
|
}
|
|
}
|
|
setIdleAnimation=false;
|
|
}
|
|
if(DownHeld()){
|
|
if(player.GetPos().y+12*player.GetSizeMult()+fElapsedTime*100*player.GetMoveSpdMult()<WORLD_SIZE.y*24){
|
|
player.SetY(player.GetY()+fElapsedTime*100*player.GetMoveSpdMult());
|
|
} else {
|
|
player.SetY(WORLD_SIZE.y*24-12);
|
|
}
|
|
if(setIdleAnimation){
|
|
player.SetFacingDirection(DOWN);
|
|
if(player.GetState()==State::NORMAL){
|
|
player.UpdateWalkingAnimation(DOWN);
|
|
}
|
|
}
|
|
setIdleAnimation=false;
|
|
}
|
|
}
|
|
if(UpReleased()){
|
|
player.SetLastReleasedMovementKey(UP);
|
|
if(player.GetState()==State::NORMAL){
|
|
if(RightHeld()){
|
|
player.UpdateWalkingAnimation(RIGHT);
|
|
} else
|
|
if(DownHeld()){
|
|
player.UpdateWalkingAnimation(DOWN);
|
|
} else
|
|
if(LeftHeld()){
|
|
player.UpdateWalkingAnimation(LEFT);
|
|
}
|
|
}
|
|
}
|
|
if(RightReleased()){
|
|
player.SetLastReleasedMovementKey(RIGHT);
|
|
if(player.GetState()==State::NORMAL){
|
|
if(UpHeld()){
|
|
player.UpdateWalkingAnimation(UP);
|
|
} else
|
|
if(DownHeld()){
|
|
player.UpdateWalkingAnimation(DOWN);
|
|
} else
|
|
if(LeftHeld()){
|
|
player.UpdateWalkingAnimation(LEFT);
|
|
}
|
|
}
|
|
}
|
|
if(LeftReleased()){
|
|
player.SetLastReleasedMovementKey(LEFT);
|
|
if(player.GetState()==State::NORMAL){
|
|
if(RightHeld()){
|
|
player.UpdateWalkingAnimation(RIGHT);
|
|
} else
|
|
if(DownHeld()){
|
|
player.UpdateWalkingAnimation(DOWN);
|
|
} else
|
|
if(UpHeld()){
|
|
player.UpdateWalkingAnimation(UP);
|
|
}
|
|
}
|
|
}
|
|
if(DownReleased()){
|
|
player.SetLastReleasedMovementKey(DOWN);
|
|
if(player.GetState()==State::NORMAL){
|
|
if(RightHeld()){
|
|
player.UpdateWalkingAnimation(RIGHT);
|
|
} else
|
|
if(UpHeld()){
|
|
player.UpdateWalkingAnimation(UP);
|
|
} else
|
|
if(LeftHeld()){
|
|
player.UpdateWalkingAnimation(LEFT);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(player.GetState()==State::SWING_SWORD){
|
|
setIdleAnimation=false;
|
|
switch(player.GetFacingDirection()){
|
|
case UP:{
|
|
player.UpdateAnimation(AnimationState::SWINGSWORD_N);
|
|
}break;
|
|
case DOWN:{
|
|
player.UpdateAnimation(AnimationState::SWINGSWORD_S);
|
|
}break;
|
|
case LEFT:{
|
|
player.UpdateAnimation(AnimationState::SWINGSWORD_W);
|
|
}break;
|
|
case RIGHT:{
|
|
player.UpdateAnimation(AnimationState::SWINGSWORD_E);
|
|
}break;
|
|
}
|
|
player.SetSwordSwingTimer(player.GetSwordSwingTimer()-fElapsedTime);
|
|
if(player.GetSwordSwingTimer()<=0){
|
|
player.SetSwordSwingTimer(0);
|
|
player.SetState(State::NORMAL);
|
|
}
|
|
}
|
|
|
|
if(player.GetState()==State::BLOCK){
|
|
setIdleAnimation=false;
|
|
}
|
|
|
|
if(setIdleAnimation){
|
|
switch(player.GetLastReleasedMovementKey()){
|
|
case UP:{
|
|
player.UpdateIdleAnimation(UP);
|
|
}break;
|
|
case DOWN:{
|
|
player.UpdateIdleAnimation(DOWN);
|
|
}break;
|
|
case LEFT:{
|
|
player.UpdateIdleAnimation(LEFT);
|
|
}break;
|
|
case RIGHT:{
|
|
player.UpdateIdleAnimation(RIGHT);
|
|
}break;
|
|
default:{
|
|
player.UpdateIdleAnimation(DOWN);
|
|
}
|
|
}
|
|
} else {
|
|
//We have moved.
|
|
player.Moved();
|
|
}
|
|
}
|
|
|
|
void Crawler::UpdateCamera(float fElapsedTime){
|
|
camera.Update(fElapsedTime);
|
|
view.SetWorldOffset(vi2d(camera.GetViewPosition()));
|
|
}
|
|
|
|
void Crawler::UpdateEffects(float fElapsedTime){
|
|
for(std::vector<Effect>::iterator it=backgroundEffects.begin();it!=backgroundEffects.end();++it){
|
|
Effect&e=*it;
|
|
if(!e.Update(fElapsedTime)){
|
|
it=backgroundEffects.erase(it);
|
|
if(it==backgroundEffects.end()){
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for(std::vector<Effect>::iterator it=foregroundEffects.begin();it!=foregroundEffects.end();++it){
|
|
Effect&e=*it;
|
|
if(!e.Update(fElapsedTime)){
|
|
it=foregroundEffects.erase(it);
|
|
if(it==foregroundEffects.end()){
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void Crawler::UpdateBullets(float fElapsedTime){
|
|
for(std::vector<Bullet>::iterator it=BULLET_LIST.begin();it!=BULLET_LIST.end();++it){
|
|
Bullet&b=*it;
|
|
b.pos+=b.vel*fElapsedTime;
|
|
if(geom2d::overlaps(geom2d::circle(player.GetPos(),12*player.GetSizeMult()/2),geom2d::circle(b.pos,b.radius))){
|
|
if(player.Hurt(b.damage)){
|
|
it=BULLET_LIST.erase(it);
|
|
if(it==BULLET_LIST.end()){
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(b.pos.x<view.GetWorldTL().x||b.pos.x>view.GetWorldBR().x||b.pos.y<view.GetWorldTL().y||b.pos.y>view.GetWorldBR().y){
|
|
it=BULLET_LIST.erase(it);
|
|
if(it==BULLET_LIST.end()){
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void Crawler::HurtEnemies(vf2d pos,float radius,int damage){
|
|
for(Monster&m:MONSTER_LIST){
|
|
if(geom2d::overlaps(geom2d::circle(pos,radius),geom2d::circle(m.GetPos(),12*m.GetSizeMult()))){
|
|
m.Hurt(damage);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Crawler::RenderWorld(float fElapsedTime){
|
|
Clear({100,180,100});
|
|
for (int x = view.GetTopLeftTile().x/24-1; x <= view.GetBottomRightTile().x/24; x++){
|
|
for (int y = view.GetTopLeftTile().y/24-1; y <= view.GetBottomRightTile().y/24; y++){
|
|
if(x>=00&&x<WORLD_SIZE.x&&y>=0&&y<WORLD_SIZE.y){
|
|
view.DrawRect(vi2d{x,y}*24,{24,24},VERY_DARK_GREY);
|
|
}
|
|
}
|
|
}
|
|
std::vector<Monster>monstersBefore,monstersAfter;
|
|
Player&pl=player;
|
|
std::copy_if(MONSTER_LIST.begin(),MONSTER_LIST.end(),std::back_inserter(monstersBefore),[&pl](Monster&m){return m.GetPos().y<pl.GetPos().y;});
|
|
std::copy_if(MONSTER_LIST.begin(),MONSTER_LIST.end(),std::back_inserter(monstersAfter),[&pl](Monster&m){return m.GetPos().y>=pl.GetPos().y;});
|
|
std::sort(monstersBefore.begin(),monstersBefore.end(),[](Monster&m1,Monster&m2){return m1.GetPos().y<m2.GetPos().y;});
|
|
std::sort(monstersAfter.begin(),monstersAfter.end(),[](Monster&m1,Monster&m2){return m1.GetPos().y<m2.GetPos().y;});
|
|
if(player.GetZ()>0){
|
|
vf2d shadowScale=vf2d{8/3.f,1}/std::max(1.f,player.GetZ()/4);
|
|
view.DrawDecal(player.GetPos()-vf2d{3,3}*shadowScale/2+vf2d{0,6},GFX_Circle.Decal(),shadowScale);
|
|
}
|
|
for(Effect&e:backgroundEffects){
|
|
e.Draw();
|
|
}
|
|
for(Monster&m:monstersBefore){
|
|
m.Draw();
|
|
}
|
|
view.DrawPartialRotatedDecal(player.GetPos()+vf2d{0,-player.GetZ()},player.GetFrame().GetSourceImage()->Decal(),player.GetSpinAngle(),{12,12},player.GetFrame().GetSourceRect().pos,player.GetFrame().GetSourceRect().size,vf2d(player.GetSizeMult(),player.GetSizeMult()));
|
|
if(player.GetState()==State::BLOCK){
|
|
view.DrawDecal(player.GetPos()-vf2d{12,12},GFX_BLOCK_BUBBLE.Decal());
|
|
}
|
|
for(Monster&m:monstersAfter){
|
|
m.Draw();
|
|
}
|
|
for(Effect&e:foregroundEffects){
|
|
e.Draw();
|
|
}
|
|
for(Bullet&b:BULLET_LIST){
|
|
view.FillCircle(b.pos,b.radius,b.col);
|
|
view.DrawCircle(b.pos,b.radius,WHITE,0xAA);
|
|
}
|
|
for(std::vector<DamageNumber>::iterator it=DAMAGENUMBER_LIST.begin();it!=DAMAGENUMBER_LIST.end();++it){
|
|
DamageNumber&dn=*it;
|
|
dn.lifeTime+=fElapsedTime;
|
|
if(dn.lifeTime>1){
|
|
it=DAMAGENUMBER_LIST.erase(it);
|
|
if(it==DAMAGENUMBER_LIST.end()){
|
|
break;
|
|
}
|
|
} else {
|
|
if(dn.lifeTime<DamageNumber::MOVE_UP_TIME){
|
|
dn.pos.y-=20*fElapsedTime;
|
|
}
|
|
std::string text=std::to_string(dn.damage);
|
|
view.DrawStringPropDecal(dn.pos-GetTextSizeProp(text)/2,text,DARK_RED);
|
|
}
|
|
}
|
|
}
|
|
|
|
Player&Crawler::GetPlayer(){
|
|
return player;
|
|
}
|
|
|
|
void Crawler::RenderHud(){
|
|
const std::function<std::string(std::string)>capitalize=[](std::string name)->std::string{
|
|
std::string newName="";
|
|
for(int i=0;i<name.length();i++){
|
|
newName.append(1,name[i]>='a'?name[i]-32:name[i]);
|
|
newName.append(1,' ');
|
|
}
|
|
return newName;
|
|
};
|
|
std::vector<Ability>cooldowns{
|
|
player.rightClickAbility,
|
|
player.ability1,
|
|
player.ability2,
|
|
player.ability3
|
|
};
|
|
std::vector<Ability>activeCooldowns;
|
|
std::copy_if(cooldowns.begin(),cooldowns.end(),std::back_inserter(activeCooldowns),[](Ability a){
|
|
return a.cooldown>0;
|
|
});
|
|
std::sort(activeCooldowns.begin(),activeCooldowns.end(),[](Ability&a1,Ability&a2){
|
|
return a1.cooldown<a2.cooldown;
|
|
});
|
|
int offset=6*activeCooldowns.size();
|
|
for(Ability&a:activeCooldowns){
|
|
if(a.cooldown>0){
|
|
FillRectDecal(vf2d{10,ScreenHeight()-22.f}-vf2d{0,float(offset)},{64,6},BLACK);
|
|
FillRectDecal(vf2d{11,ScreenHeight()-21.f}-vf2d{0,float(offset)},{62,4},DARK_GREY);
|
|
GradientFillRectDecal(vf2d{10,ScreenHeight()-22.f}-vf2d{0,float(offset)},{(a.cooldown/a.COOLDOWN_TIME)*64,6},a.barColor1,a.barColor1,a.barColor2,a.barColor2);
|
|
DrawRotatedStringPropDecal(vf2d{8,ScreenHeight()-20.f}+vf2d{1,1}-vf2d{0,float(offset)},capitalize(a.name),-PI/64,{0,0},BLACK,{0.4,0.4});
|
|
DrawRotatedStringPropDecal(vf2d{8,ScreenHeight()-20.f}-vf2d{0,float(offset)},capitalize(a.name),-PI/64,{0,0},WHITE,{0.4,0.4});
|
|
}
|
|
offset-=6;
|
|
}
|
|
DrawDecal({2,2},GFX_Heart.Decal());
|
|
std::string text=player.GetHealth()>0?std::to_string(player.GetHealth()):"X";
|
|
for(int y=-1;y<=1;y++){
|
|
for(int x=-1;x<=1;x++){
|
|
if(x!=0||y!=0){
|
|
DrawStringPropDecal(vf2d{20,3}+vf2d{float(x),float(y)},text,BLACK,{2,2});
|
|
}
|
|
}
|
|
}
|
|
DrawStringPropDecal({20,3},text,WHITE,{2,2});
|
|
}
|
|
|
|
void Crawler::AddEffect(Effect foreground,Effect background){
|
|
foregroundEffects.push_back(foreground);
|
|
backgroundEffects.push_back(background);
|
|
}
|
|
|
|
vf2d Crawler::GetWorldMousePos(){
|
|
return GetMousePos()+view.GetWorldOffset();
|
|
}
|
|
|
|
int main()
|
|
{
|
|
Crawler demo;
|
|
if (demo.Construct(WINDOW_SIZE.x, WINDOW_SIZE.y, 4, 4))
|
|
demo.Start();
|
|
|
|
return 0;
|
|
} |