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.
838 lines
32 KiB
838 lines
32 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 "Version.h"
|
|
#include "TMXParser.h"
|
|
#include "TSXParser.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(){
|
|
InitializeLevel("assets/maps/Level1.tmx",LEVEL1);
|
|
InitializeLevel("assets/maps/Level2.tmx",LEVEL2);
|
|
InitializeLevel("assets/Campaigns/1_1_test.tmx",CAMPAIGN_1_1);
|
|
|
|
//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});
|
|
|
|
LoadLevel(LEVEL2);
|
|
|
|
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>=0&&x<WORLD_SIZE.x&&y>=0&&y<WORLD_SIZE.y){
|
|
for(LayerTag&layer:MAP_DATA[currentLevel].LayerData){
|
|
int tileID=layer.tiles[y][x]-1;
|
|
if(tileID!=-1){
|
|
TilesheetData tileSheet=GetTileSheet(currentLevel,tileID);
|
|
int tileSheetWidth=tileSheet.tileset.Sprite()->width/24;
|
|
int tileSheetHeight=tileSheet.tileset.Sprite()->height/24;
|
|
int tileSheetIndex=tileID-(tileSheet.firstgid-1);
|
|
int tileSheetX=tileSheetIndex%tileSheetWidth;
|
|
int tileSheetY=tileSheetIndex/tileSheetWidth;
|
|
view.DrawPartialDecal(vi2d{x,y}*24,{24,24},tileSheet.tileset.Decal(),vi2d{tileSheetX,tileSheetY}*24,{24,24});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//DrawDecal({0,0},MAP_TILESETS["assets/maps/"+MAP_DATA[LEVEL1].TilesetData[1].data["source"]]->Decal());
|
|
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);
|
|
}
|
|
|
|
|
|
void Crawler::InitializeLevel(std::string mapFile,MapName map){
|
|
TMXParser level(mapFile);
|
|
size_t slashMarker = mapFile.find_last_of('/');
|
|
std::string baseDir=mapFile.substr(0,slashMarker+1);
|
|
MAP_DATA[map]=level.GetData();
|
|
for(XMLTag&tag:MAP_DATA[map].TilesetData){
|
|
size_t slashMarkerSourceDir = tag.data["source"].find_last_of('/');
|
|
std::string baseSourceDir=tag.data["source"].substr(slashMarkerSourceDir+1);
|
|
if(MAP_TILESETS.find("assets/maps/"+baseSourceDir)==MAP_TILESETS.end()){
|
|
TSXParser tileset(baseDir+tag.data["source"]);
|
|
Renderable*r=new Renderable();
|
|
MAP_TILESETS["assets/maps/"+baseSourceDir]=r;
|
|
r->Load("assets/maps/"+tileset.GetData().ImageData.data["source"]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Crawler::LoadLevel(MapName map){
|
|
SPAWNER_LIST.clear();
|
|
currentLevel=map;
|
|
WORLD_SIZE={MAP_DATA[map].MapData.width,MAP_DATA[map].MapData.height};
|
|
for(SpawnerTag&spawner:MAP_DATA[map].SpawnerData){
|
|
std::vector<std::pair<MonsterName,vf2d>>monster_list;
|
|
vf2d spawnerRadius=vf2d{spawner.ObjectData.GetFloat("width"),spawner.ObjectData.GetFloat("height")}/2;
|
|
for(XMLTag&property:spawner.properties){
|
|
int monsterTypeID=property.GetInteger("value")-1;
|
|
if(monsterTypeID>=0&&monsterTypeID<MonsterName::END){
|
|
monster_list.push_back({MonsterName(monsterTypeID),{rand()%int(spawnerRadius.x)-spawnerRadius.x/2,rand()%int(spawnerRadius.y)-spawnerRadius.y/2}});
|
|
}
|
|
}
|
|
SPAWNER_LIST.push_back(MonsterSpawner{{spawner.ObjectData.GetFloat("x")+spawnerRadius.x,spawner.ObjectData.GetFloat("y")+spawnerRadius.y},spawnerRadius,monster_list});
|
|
}
|
|
}
|
|
|
|
vi2d Crawler::GetWorldSize(){
|
|
return WORLD_SIZE;
|
|
}
|
|
|
|
TilesheetData Crawler::GetTileSheet(MapName map,int tileID){
|
|
std::vector<XMLTag>&tileData=MAP_DATA[map].TilesetData;
|
|
if(tileData.size()==1){
|
|
size_t slashMarkerSourceDir = tileData[0].data["source"].find_last_of('/');
|
|
std::string baseSourceDir=tileData[0].data["source"].substr(slashMarkerSourceDir+1);
|
|
return {*MAP_TILESETS["assets/maps/"+baseSourceDir],1};
|
|
} else {
|
|
for (int i=1;i<tileData.size();i++){
|
|
if(tileID<stoi(tileData[i].data["firstgid"])){
|
|
size_t slashMarkerSourceDir = tileData[i-1].data["source"].find_last_of('/');
|
|
std::string baseSourceDir=tileData[i-1].data["source"].substr(slashMarkerSourceDir+1);
|
|
return {*MAP_TILESETS["assets/maps/"+baseSourceDir],stoi(tileData[i-1].data["firstgid"])};
|
|
}
|
|
}
|
|
size_t slashMarkerSourceDir = tileData[tileData.size()-1].data["source"].find_last_of('/');
|
|
std::string baseSourceDir=tileData[tileData.size()-1].data["source"].substr(slashMarkerSourceDir+1);
|
|
return {*MAP_TILESETS["assets/maps/"+baseSourceDir],stoi(tileData[tileData.size()-1].data["firstgid"])};
|
|
}
|
|
}
|
|
|
|
int main()
|
|
{
|
|
Crawler demo;
|
|
if (demo.Construct(WINDOW_SIZE.x, WINDOW_SIZE.y, 4, 4))
|
|
demo.Start();
|
|
|
|
return 0;
|
|
} |