sigonasr2
/
AdventuresInLestoria
1
1
Fork 0
Code Issues 9 Pull Requests Projects 1 Releases Wiki Activity
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.
54 Commits
4 Branches
0 Tags
3.4 GiB
 
 
 
 
 
 
Tag: Branch: Tree: f5bc7ee824
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f5bc7ee824'
${ noResults }
AdventuresInLestoria/Crawler/Crawler.cpp

800 lines
30 KiB
Raw Blame History

#include "olcPGEX_TransformedView.h"
#include "Crawler.h"
#include "olcUTIL_Camera2D.h"
#include "DamageNumber.h"
#include "Bullet.h"
#include "Ability.h"
#include "Class.h"
#include "Version.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;
std::vector<Bullet>PLAYER_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");
GFX_Battlecry_Effect.Load("assets/battlecry_effect.png");
GFX_Mana.Load("assets/mana.png");
GFX_SonicSlash.Load("assets/sonicslash.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::WARRIOR_SWINGSWORD_E);
player.AddAnimation(AnimationState::WARRIOR_SWINGSWORD_S);
player.AddAnimation(AnimationState::WARRIOR_SWINGSWORD_N);
player.AddAnimation(AnimationState::WARRIOR_SWINGSWORD_W);
player.AddAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_E);
player.AddAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_S);
player.AddAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_N);
player.AddAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_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);
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);
Animate2D::FrameSequence pl_warrior_sonic_swing_s(0.1,Animate2D::Style::OneShot),pl_warrior_sonic_swing_n(0.1,Animate2D::Style::OneShot),pl_warrior_sonic_swing_e(0.1,Animate2D::Style::OneShot),pl_warrior_sonic_swing_w(0.1,Animate2D::Style::OneShot);
for (int i=0;i<4;i++){
pl_warrior_swing_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,0}*24,{24,24}}});
pl_warrior_sonic_swing_s.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,4}*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}}});
pl_warrior_sonic_swing_n.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,5}*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}}});
pl_warrior_sonic_swing_w.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,6}*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}}});
pl_warrior_sonic_swing_e.AddFrame({&GFX_Warrior_Sheet,{vi2d{4+i,7}*24,{24,24}}});
}
ANIMATION_DATA[AnimationState::WARRIOR_SWINGSWORD_N]=pl_warrior_swing_n;
ANIMATION_DATA[AnimationState::WARRIOR_SWINGSWORD_E]=pl_warrior_swing_e;
ANIMATION_DATA[AnimationState::WARRIOR_SWINGSWORD_S]=pl_warrior_swing_s;
ANIMATION_DATA[AnimationState::WARRIOR_SWINGSWORD_W]=pl_warrior_swing_w;
ANIMATION_DATA[AnimationState::WARRIOR_SWINGSONICSWORD_N]=pl_warrior_sonic_swing_n;
ANIMATION_DATA[AnimationState::WARRIOR_SWINGSONICSWORD_E]=pl_warrior_sonic_swing_e;
ANIMATION_DATA[AnimationState::WARRIOR_SWINGSONICSWORD_S]=pl_warrior_sonic_swing_s;
ANIMATION_DATA[AnimationState::WARRIOR_SWINGSONICSWORD_W]=pl_warrior_sonic_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;
Animate2D::FrameSequence battlecry_effect(0.02f,Animate2D::Style::OneShot);
for(int i=0;i<5;i++){
battlecry_effect.AddFrame({&GFX_Battlecry_Effect,{{i*84,0},{84,84}}});
}
ANIMATION_DATA[AnimationState::BATTLECRY_EFFECT]=battlecry_effect;
Animate2D::FrameSequence sonicslash_effect(0.04f,Animate2D::Style::OneShot);
for(int i=0;i<4;i++){
sonicslash_effect.AddFrame({&GFX_SonicSlash,{{i*60,0},{60,60}}});
}
ANIMATION_DATA[AnimationState::SONICSLASH]=sonicslash_effect;
}
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.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::WARRIOR_SWINGSWORD_N);
}break;
case DOWN:{
player.UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_S);
}break;
case LEFT:{
player.UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_W);
}break;
case RIGHT:{
player.UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_E);
}break;
}
player.SetSwordSwingTimer(player.GetSwordSwingTimer()-fElapsedTime);
if(player.GetSwordSwingTimer()<=0){
player.SetSwordSwingTimer(0);
player.SetState(State::NORMAL);
}
}
if(player.GetState()!=State::NORMAL){
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){
lastWorldShakeAdjust=std::max(0.f,lastWorldShakeAdjust-fElapsedTime);
if(worldShakeTime-fElapsedTime>0){
if(lastWorldShakeAdjust==0){
lastWorldShakeAdjust=float(rand()%int(WORLD_SHAKE_ADJUST_MAX_TIME*1000))/1000+0.05;
worldShakeVel={float(rand()%1000)/1000*100-50,float(rand()%1000)/1000*100-50};
}
worldShake+=worldShakeVel*fElapsedTime;
} else {
camera.SetTarget(player.GetPos());
}
worldShakeTime=std::max(0.f,worldShakeTime-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;
}
}
b.lifetime-=fElapsedTime;
if(b.lifetime<=0){
it=BULLET_LIST.erase(it);
if(it==BULLET_LIST.end()){
break;
}
}
b.animation.UpdateState(b.internal_animState,fElapsedTime);
}
for(std::vector<Bullet>::iterator it=PLAYER_BULLET_LIST.begin();it!=PLAYER_BULLET_LIST.end();++it){
Bullet&b=*it;
b.pos+=b.vel*fElapsedTime;
for(Monster&m:MONSTER_LIST){
if(geom2d::overlaps(geom2d::circle(m.GetPos(),12*m.GetSizeMult()),geom2d::circle(b.pos,b.radius))){
if(b.hitList.find(&m)==b.hitList.end()&&m.Hurt(b.damage)){
if(!b.hitsMultiple){
it=PLAYER_BULLET_LIST.erase(it);
if(it==PLAYER_BULLET_LIST.end()){
break;
}
}
b.hitList[&m]=true;
}
}
}
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=PLAYER_BULLET_LIST.erase(it);
if(it==PLAYER_BULLET_LIST.end()){
break;
}
}
b.lifetime-=fElapsedTime;
if(b.lifetime<=0){
it=PLAYER_BULLET_LIST.erase(it);
if(it==PLAYER_BULLET_LIST.end()){
break;
}
}
b.animation.UpdateState(b.internal_animState,fElapsedTime);
}
}
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()),player.GetBuffs(BuffType::ATTACK_UP).size()>0?Pixel{255,uint8_t(255*abs(sin(1.4*player.GetBuffs(BuffType::ATTACK_UP)[0].duration))),uint8_t(255*abs(sin(1.4*player.GetBuffs(BuffType::ATTACK_UP)[0].duration)))}:WHITE);
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){
b.Draw();
}
for(Bullet&b:PLAYER_BULLET_LIST){
b.Draw();
}
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());
DrawDecal({2,20},GFX_Mana.Decal());
std::string text=player.GetHealth()>0?std::to_string(player.GetHealth()):"X";
std::string text_mana=std::to_string(player.GetMana());
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});
}
}
}
for(int y=-1;y<=1;y++){
for(int x=-1;x<=1;x++){
if(x!=0||y!=0){
DrawStringPropDecal(vf2d{24,23}+vf2d{float(x),float(y)},text_mana,BLACK,{1.5,1.5});
}
}
}
DrawStringPropDecal({20,3},text,WHITE,{2,2});
DrawStringPropDecal({24,23},text_mana,{192,192,255},{1.5,1.5});
if(player.notEnoughManaDisplay.second>0){
std::string displayText="Not enough mana for "+player.notEnoughManaDisplay.first+"!";
DrawStringPropDecal(vf2d{float(ScreenWidth()/2),float(ScreenHeight()/4)}-GetTextSizeProp(displayText)/2+vf2d{1,1},displayText,VERY_DARK_RED);
DrawStringPropDecal(vf2d{float(ScreenWidth()/2),float(ScreenHeight()/4)}-GetTextSizeProp(displayText)/2,displayText,DARK_RED);
}
std::string versionStr("v" + std::to_string(VERSION_MAJOR) + "." + std::to_string(VERSION_MINOR) + "." + std::to_string(VERSION_PATCH) + "." + std::to_string(VERSION_BUILD));
DrawStringDecal(vf2d{ GetScreenSize() } - vf2d{ GetTextSize(versionStr) }*0.4 - vf2d{ 0.4,0 }, versionStr, WHITE, { 0.4,0.4 });
DrawStringDecal(vf2d{ GetScreenSize() } - vf2d{ GetTextSize(versionStr) }*0.4 - vf2d{ 0,0.4 }, versionStr, WHITE, { 0.4,0.4 });
DrawStringDecal(vf2d{ GetScreenSize() } - vf2d{ GetTextSize(versionStr) }*0.4, versionStr, BLACK,{0.4,0.4});
}
void Crawler::AddEffect(Effect foreground,Effect background){
foregroundEffects.push_back(foreground);
backgroundEffects.push_back(background);
}
void Crawler::AddEffect(Effect foreground,bool back){
if(back){
backgroundEffects.push_back(foreground);
} else {
foregroundEffects.push_back(foreground);
}
}
vf2d Crawler::GetWorldMousePos(){
return GetMousePos()+view.GetWorldOffset();
}
void Crawler::SetupWorldShake(float duration){
worldShakeTime=duration;
worldShake=player.GetPos();
camera.SetTarget(worldShake);
}
int main()
{
Crawler demo;
if (demo.Construct(WINDOW_SIZE.x, WINDOW_SIZE.y, 4, 4))
demo.Start();
return 0;
}