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

Finish entire class refactor. Class swapping needs to be reimplemented. Fixed shadow color from white to black

Browse Source 
Co-authored-by: sigonasr2 <sigonasr2@gmail.com>
This commit is contained in:
sigonasr2, Sig, Sigo 2023-07-14 15:44:17 +00:00
parent d3454727cd
commit c75a01a1ad
24 changed files with 628 additions and 427 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Crawler/Ability.h
View File

@ -8,7 +8,7 @@ struct Ability{
float COOLDOWN_TIME=0;
int manaCost=0;
Pixel barColor1,barColor2;
std::function<bool()>action;
std::function<bool()>action=[&](){return false;};
Ability();
Ability(std::string name,float cooldownTime,int manaCost,Pixel barColor1=VERY_DARK_RED,Pixel barColor2=DARK_RED);
};

6
Crawler/BulletTypes.h
View File

@ -5,7 +5,7 @@ struct EnergyBolt:public Bullet{
float lastParticleSpawn=0;
EnergyBolt(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly=false,Pixel col=WHITE);
void Update(float fElapsedTime)override;
bool PlayerHit(Player&player)override;
bool PlayerHit(Player*player)override;
bool MonsterHit(Monster&monster)override;
};
@ -13,7 +13,7 @@ struct FireBolt:public Bullet{
float lastParticleSpawn=0;
FireBolt(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly=false,Pixel col=WHITE);
void Update(float fElapsedTime)override;
bool PlayerHit(Player&player)override;
bool PlayerHit(Player*player)override;
bool MonsterHit(Monster&monster)override;
};
@ -21,6 +21,6 @@ struct LightningBolt:public Bullet{
float lastParticleSpawn=0;
LightningBolt(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly=false,Pixel col=WHITE);
void Update(float fElapsedTime)override;
bool PlayerHit(Player&player)override;
bool PlayerHit(Player*player)override;
bool MonsterHit(Monster&monster)override;
};

277
Crawler/Class.cpp
View File

@ -1,277 +0,0 @@
#include "DEFINES.h"
#include "Crawler.h"
#include "BulletTypes.h"
INCLUDE_game
INCLUDE_MONSTER_LIST
INCLUDE_BULLET_LIST
std::map<Class,std::unique_ptr<ClassData>>CLASS_DATA;
void ClassData::InitializeClassData(){
CLASS_DATA[WARRIOR]=std::make_unique<Warrior>(Warrior("Warrior",WARRIOR,
,
,
,
,
WARRIOR_WALK_N,WARRIOR_WALK_E,WARRIOR_WALK_S,WARRIOR_WALK_W,
WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W));
CLASS_DATA[RANGER]=std::make_unique<Ranger>(Ranger("Ranger",RANGER,
{"Retreat",7,0,VERY_DARK_BLUE,DARK_BLUE},
{"Rapid Fire",12,35},
{"Charged Shot",15,40},
{"Multishot",25,50},
RANGER_WALK_N,RANGER_WALK_E,RANGER_WALK_S,RANGER_WALK_W,
RANGER_IDLE_N,RANGER_IDLE_E,RANGER_IDLE_S,RANGER_IDLE_W));
CLASS_DATA[TRAPPER]=std::make_unique<Bard>(Bard("Bard",TRAPPER,
{"???",7,0,VERY_DARK_BLUE,DARK_BLUE},
{"???",12,0},
{"???",15,0},
{"???",25,0},
WARRIOR_WALK_N,WARRIOR_WALK_E,WARRIOR_WALK_S,WARRIOR_WALK_W,
WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W));
CLASS_DATA[WIZARD]=std::make_unique<Wizard>(Wizard("Wizard",WIZARD,
{"Teleport",8,5,VERY_DARK_BLUE,DARK_BLUE},
{"Firebolt",6,30},
{"Lightning Bolt",6,25},
{"Meteor",40,75},
WIZARD_WALK_N,WIZARD_WALK_E,WIZARD_WALK_S,WIZARD_WALK_W,
WIZARD_IDLE_N,WIZARD_IDLE_E,WIZARD_IDLE_S,WIZARD_IDLE_W));
CLASS_DATA[WITCH]=std::make_unique<Witch>(Witch("Witch",WITCH,
{"???",8,0,VERY_DARK_BLUE,DARK_BLUE},
{"???",6,0},
{"???",6,0},
{"???",40,0},
WARRIOR_WALK_N,WARRIOR_WALK_E,WARRIOR_WALK_S,WARRIOR_WALK_W,
WARRIOR_IDLE_N,WARRIOR_IDLE_E,WARRIOR_IDLE_S,WARRIOR_IDLE_W));
}
ClassData::ClassData(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
:name(name),cl(cl),rightClickAbility(rightClickAbility),ability1(ability1),ability2(ability2),ability3(ability3),
walk_n(walk_n),walk_e(walk_e),walk_s(walk_s),walk_w(walk_w),idle_n(idle_n),idle_w(idle_w),idle_s(idle_s),idle_e(idle_e)
{}
Warrior::Warrior(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
{}
Thief::Thief(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
{}
void Thief::Update(float fElapsedTime){
}
bool Thief::AutoAttack(){
return true;
}
bool Thief::Ability1(){
return true;
}
bool Thief::Ability2(){
return true;
}
bool Thief::Ability3(){
return true;
}
bool Thief::RightClickAbility(){
return true;
}
Ranger::Ranger(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
{}
void Ranger::Update(float fElapsedTime){
}
bool Ranger::AutoAttack(){
return true;
}
bool Ranger::Ability1(){
return true;
}
bool Ranger::Ability2(){
return true;
}
bool Ranger::Ability3(){
return true;
}
bool Ranger::RightClickAbility(){
return true;
}
Bard::Bard(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
{}
void Bard::Update(float fElapsedTime){
}
bool Bard::AutoAttack(){
return true;
}
bool Bard::Ability1(){
return true;
}
bool Bard::Ability2(){
return true;
}
bool Bard::Ability3(){
return true;
}
bool Bard::RightClickAbility(){
return true;
}
Wizard::Wizard(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
{}
void Wizard::Update(float fElapsedTime){
ACCESS_PLAYER
if(p->attack_cooldown_timer>0){
CLASS_DATA[cl]->idle_n=AnimationState::WIZARD_IDLE_ATTACK_N;
CLASS_DATA[cl]->idle_e=AnimationState::WIZARD_IDLE_ATTACK_E;
CLASS_DATA[cl]->idle_s=AnimationState::WIZARD_IDLE_ATTACK_S;
CLASS_DATA[cl]->idle_w=AnimationState::WIZARD_IDLE_ATTACK_W;
CLASS_DATA[cl]->walk_n=AnimationState::WIZARD_ATTACK_N;
CLASS_DATA[cl]->walk_e=AnimationState::WIZARD_ATTACK_E;
CLASS_DATA[cl]->walk_s=AnimationState::WIZARD_ATTACK_S;
CLASS_DATA[cl]->walk_w=AnimationState::WIZARD_ATTACK_W;
} else {
CLASS_DATA[cl]->idle_n=AnimationState::WIZARD_IDLE_N;
CLASS_DATA[cl]->idle_e=AnimationState::WIZARD_IDLE_E;
CLASS_DATA[cl]->idle_s=AnimationState::WIZARD_IDLE_S;
CLASS_DATA[cl]->idle_w=AnimationState::WIZARD_IDLE_W;
CLASS_DATA[cl]->walk_n=AnimationState::WIZARD_WALK_N;
CLASS_DATA[cl]->walk_e=AnimationState::WIZARD_WALK_E;
CLASS_DATA[cl]->walk_s=AnimationState::WIZARD_WALK_S;
CLASS_DATA[cl]->walk_w=AnimationState::WIZARD_WALK_W;
}
if(p->GetState()==State::CASTING){
switch(p->GetFacingDirection()){
case UP:{
p->UpdateAnimation(AnimationState::WIZARD_CAST_N);
}break;
case DOWN:{
p->UpdateAnimation(AnimationState::WIZARD_CAST_S);
}break;
case LEFT:{
p->UpdateAnimation(AnimationState::WIZARD_CAST_W);
}break;
case RIGHT:{
p->UpdateAnimation(AnimationState::WIZARD_CAST_E);
}break;
}
}
}
bool Wizard::AutoAttack(){
ACCESS_PLAYER
p->attack_cooldown_timer=p->MAGIC_ATTACK_COOLDOWN;
float angleToCursor=atan2(game->GetWorldMousePos().y-p->GetPos().y,game->GetWorldMousePos().x-p->GetPos().x);
BULLET_LIST.push_back(std::make_unique<EnergyBolt>(EnergyBolt(p->GetPos(),{cos(angleToCursor)*200,sin(angleToCursor)*200},12,p->GetAttack(),p->upperLevel,true,WHITE)));
return true;
}
bool Wizard::Ability1(){
ACCESS_PLAYER
float angleToCursor=atan2(game->GetWorldMousePos().y-p->GetPos().y,game->GetWorldMousePos().x-p->GetPos().x);
BULLET_LIST.push_back(std::make_unique<FireBolt>(FireBolt(p->GetPos(),{cos(angleToCursor)*275,sin(angleToCursor)*275},12,p->GetAttack(),p->upperLevel,true,{240,120,60})));
return true;
}
bool Wizard::Ability2(){
ACCESS_PLAYER
float angleToCursor=atan2(game->GetWorldMousePos().y-p->GetPos().y,game->GetWorldMousePos().x-p->GetPos().x);
BULLET_LIST.push_back(std::make_unique<LightningBolt>(LightningBolt(p->GetPos(),{cos(angleToCursor)*230,sin(angleToCursor)*230},12,p->GetAttack()*4,p->upperLevel,true,WHITE)));
return true;
}
bool Wizard::Ability3(){
ACCESS_PLAYER
p->SetState(State::CASTING);
game->AddEffect(std::make_unique<Meteor>(p->GetPos(),3,AnimationState::METEOR,p->OnUpperLevel(),vf2d{1,1},2));
return true;
}
bool Wizard::RightClickAbility(){
ACCESS_PLAYER
float pointMouseDirection=atan2(game->GetWorldMousePos().y-p->GetPos().y,game->GetWorldMousePos().x-p->GetPos().x);
vf2d pointTowardsMouse={cos(pointMouseDirection),sin(pointMouseDirection)};
float dist=std::clamp(geom2d::line<float>{p->GetPos(),game->GetWorldMousePos()}.length(),0.f,6.5f*24);
if(dist<12)return false;
vf2d teleportPoint=p->GetPos()+pointTowardsMouse*dist;
while(dist>0&&game->HasTileCollision(game->GetCurrentLevel(),teleportPoint)&&p->CanPathfindTo(p->GetPos(),teleportPoint)){
dist-=24;
teleportPoint=p->GetPos()+pointTowardsMouse*dist;
}
if(dist>0&&p->CanPathfindTo(p->GetPos(),teleportPoint)){
p->SetState(State::TELEPORT);
p->teleportAnimationTimer=0.35;
p->teleportTarget=teleportPoint;
p->teleportStartPosition=p->GetPos();
p->iframe_time=0.35;
for(int i=0;i<16;i++){
game->AddEffect(std::make_unique<Effect>(p->GetPos()+vf2d{(rand()%160-80)/10.f,(rand()%160-80)/10.f},float(rand()%300)/1000,AnimationState::DOT_PARTICLE,p->upperLevel,0.3,0.2,vf2d{float(rand()%1000-500)/100,float(rand()%1000-500)/100},BLACK));
}
return true;
} else {
p->notificationDisplay={"Cannot Teleport to that location!",0.5};
return false;
}
}
Witch::Witch(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w)
:ClassData(name,cl,rightClickAbility,ability1,ability2,ability3,
walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w)
{}
void Witch::Update(float fElapsedTime){
}
bool Witch::AutoAttack(){
return true;
}
bool Witch::Ability1(){
return true;
}
bool Witch::Ability2(){
return true;
}
bool Witch::Ability3(){
return true;
}
bool Witch::RightClickAbility(){
return true;
}

82
Crawler/Class.h
View File

@ -3,79 +3,13 @@
#include "Animation.h"
#include "olcPixelGameEngine.h"
//Classes have bit-wise operator capabilities.
enum Class{
WARRIOR,THIEF,RANGER,TRAPPER,WIZARD,WITCH
};
struct ClassData{
static void InitializeClassData();
ClassData(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
virtual ~ClassData()=default;
virtual void Update(float fElapsedTime)=0;
virtual bool AutoAttack()=0;
virtual bool Ability1()=0;
virtual bool Ability2()=0;
virtual bool Ability3()=0;
virtual bool RightClickAbility()=0;
};
struct Warrior:public ClassData{
Warrior(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
void Update(float fElapsedTime)override;
bool AutoAttack()override;
bool Ability1()override;
bool Ability2()override;
bool Ability3()override;
bool RightClickAbility()override;
};
struct Thief:public ClassData{
Thief(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
void Update(float fElapsedTime)override;
bool AutoAttack()override;
bool Ability1()override;
bool Ability2()override;
bool Ability3()override;
bool RightClickAbility()override;
};
struct Ranger:public ClassData{
Ranger(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
void Update(float fElapsedTime)override;
bool AutoAttack()override;
bool Ability1()override;
bool Ability2()override;
bool Ability3()override;
bool RightClickAbility()override;
};
struct Bard:public ClassData{
Bard(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
void Update(float fElapsedTime)override;
bool AutoAttack()override;
bool Ability1()override;
bool Ability2()override;
bool Ability3()override;
bool RightClickAbility()override;
};
struct Wizard:public ClassData{
Wizard(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
void Update(float fElapsedTime)override;
bool AutoAttack()override;
bool Ability1()override;
bool Ability2()override;
bool Ability3()override;
bool RightClickAbility()override;
};
struct Witch:public ClassData{
Witch(std::string name,Class cl,Ability rightClickAbility,Ability ability1,Ability ability2,Ability ability3,
AnimationState walk_n,AnimationState walk_e,AnimationState walk_s,AnimationState walk_w,AnimationState idle_n,AnimationState idle_e,AnimationState idle_s,AnimationState idle_w);
void Update(float fElapsedTime)override;
bool AutoAttack()override;
bool Ability1()override;
bool Ability2()override;
bool Ability3()override;
bool RightClickAbility()override;
ANY=0,
WARRIOR=1,
THIEF=2,
RANGER=4,
TRAPPER=8,
WIZARD=16,
WITCH=32
};

BIN
Crawler/Crawler
View File

Binary file not shown.

48
Crawler/Crawler.cpp
View File

@ -15,7 +15,6 @@
#include <queue>
#include "Emitter.h"
INCLUDE_CLASS_DATA
INCLUDE_EMITTER_LIST
//#define DEBUG_COLLISIONS //Shows collision hitboxes.
@ -40,11 +39,9 @@ bool Crawler::OnUserCreate(){
InitializeLevel("assets/Campaigns/1_1.tmx",CAMPAIGN_1_1);
#ifdef OLC_PLATFORM_EMSCRIPTEN
ConsoleCaptureStdOut(true);
#endif
ClassData::InitializeClassData();
std::cout<<"Player loading."<<std::endl;
player=std::make_unique<Warrior>();
std::cout<<"Player loaded."<<std::endl;
//Initialize Camera.
camera=Camera2D{WINDOW_SIZE};
@ -53,6 +50,7 @@ bool Crawler::OnUserCreate(){
camera.SetWorldBoundary({0,0},WORLD_SIZE*24);
camera.EnableWorldBoundary(false);
std::cout<<"Camera loaded."<<std::endl;
//Graphics
GFX_Warrior_Sheet.Load("assets/nico-warrior.png");
GFX_Slime_Sheet.Load("assets/slime.png");
@ -79,6 +77,7 @@ bool Crawler::OnUserCreate(){
GFX_ChainLightning.Load("assets/chain_lightning.png");
GFX_LightningSplash.Load("assets/lightning_splash_effect.png");
GFX_Meteor.Load("assets/meteor.png");
std::cout<<"Images loaded."<<std::endl;
//Animations
sig::Animation::InitializeAnimations();
@ -87,8 +86,9 @@ bool Crawler::OnUserCreate(){
view=TileTransformedView{GetScreenSize(),{1,1}};
LoadLevel(CAMPAIGN_1_1);
player->ChangeClass(WARRIOR);
std::cout<<"Done Loading."<<std::endl;
//ChangePlayerClass(WARRIOR);
std::cout<<"Set player class."<<std::endl;
return true;
}
@ -141,26 +141,26 @@ void Crawler::HandleUserInput(float fElapsedTime){
if(GetMouseWheel()>0){
switch(player->GetClass()){
case WARRIOR:{
player->ChangeClass(RANGER);
ChangePlayerClass(RANGER);
}break;
case RANGER:{
player->ChangeClass(WIZARD);
ChangePlayerClass(WIZARD);
}break;
case WIZARD:{
player->ChangeClass(WARRIOR);
ChangePlayerClass(WARRIOR);
}break;
}
}
if(GetMouseWheel()<0){
switch(player->GetClass()){
case WARRIOR:{
player->ChangeClass(WIZARD);
ChangePlayerClass(WIZARD);
}break;
case RANGER:{
player->ChangeClass(WARRIOR);
ChangePlayerClass(WARRIOR);
}break;
case WIZARD:{
player->ChangeClass(RANGER);
ChangePlayerClass(RANGER);
}break;
}
}
@ -540,7 +540,7 @@ void Crawler::RenderWorld(float fElapsedTime){
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);
view.DrawDecal(player->GetPos()-vf2d{3,3}*shadowScale/2+vf2d{0,6},GFX_Circle.Decal(),shadowScale,BLACK);
}
for(Effect*e:backgroundEffectsLower){
e->Draw();
@ -679,10 +679,11 @@ void Crawler::RenderHud(){
return newName;
};
std::vector<Ability>cooldowns{
player->rightClickAbility,
player->ability1,
player->ability2,
player->ability3
player->GetRightClickAbility(),
player->GetAbility1(),
player->GetAbility2(),
player->GetAbility3(),
player->GetAbility4(),
};
std::vector<Ability>activeCooldowns;
std::copy_if(cooldowns.begin(),cooldowns.end(),std::back_inserter(activeCooldowns),[](Ability a){
@ -752,6 +753,7 @@ void Crawler::SetupWorldShake(float duration){
void Crawler::InitializeLevel(std::string mapFile,MapName map){
TMXParser level(mapFile);
std::cout<<"Done parsing."<<std::endl;
size_t slashMarker = mapFile.find_last_of('/');
std::string baseDir=mapFile.substr(0,slashMarker+1);
MAP_DATA[map]=level.GetData();
@ -760,6 +762,7 @@ void Crawler::InitializeLevel(std::string mapFile,MapName map){
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"]);
std::cout<<"Done parsing tex. "<<std::endl;
Renderable*r=new Renderable();
MAP_TILESETS["assets/maps/"+baseSourceDir].tileset=r;
MAP_TILESETS["assets/maps/"+baseSourceDir].foregroundTiles=tileset.GetData().ForegroundTileData;
@ -767,8 +770,10 @@ void Crawler::InitializeLevel(std::string mapFile,MapName map){
MAP_TILESETS["assets/maps/"+baseSourceDir].collision=tileset.GetData().CollisionData;
MAP_TILESETS["assets/maps/"+baseSourceDir].staircaseTiles=tileset.GetData().StaircaseData;
r->Load("assets/maps/"+tileset.GetData().ImageData.data["source"]);
std::cout<<"Done loading. "<<std::endl;
}
}
std::cout<<"Function done. "<<std::endl;
}
void Crawler::LoadLevel(MapName map){
@ -776,6 +781,7 @@ void Crawler::LoadLevel(MapName map){
foregroundTileGroups.clear();
currentLevel=map;
WORLD_SIZE={MAP_DATA[map].MapData.width,MAP_DATA[map].MapData.height};
std::cout<<"Setup world size."<<std::endl;
for(auto key:MAP_DATA[map].SpawnerData){
SpawnerTag&spawnData=MAP_DATA[map].SpawnerData[key.first];
std::vector<std::pair<MonsterName,vf2d>>monster_list;
@ -789,6 +795,7 @@ void Crawler::LoadLevel(MapName map){
}
SPAWNER_LIST.push_back(MonsterSpawner{{spawnData.ObjectData.GetFloat("x"),spawnData.ObjectData.GetFloat("y")},spawnerRadius*2,monster_list,spawnData.upperLevel});
}
std::cout<<"Spawner lists done."<<std::endl;
std::set<vi2d>foregroundTilesAdded,upperForegroundTilesAdded;
for(int x=0;x<WORLD_SIZE.x;x++){
for(int y=0;y<WORLD_SIZE.y;y++){
@ -870,6 +877,7 @@ void Crawler::LoadLevel(MapName map){
}
}
}
std::cout<<"Done preparing tilesheet reads"<<std::endl;
int counter=0;
bridgeLayerIndex=-1;
for(LayerTag&layer:MAP_DATA[map].LayerData){
@ -878,8 +886,10 @@ void Crawler::LoadLevel(MapName map){
}
counter++;
}
std::cout<<"Bridge Layer indexing done."<<std::endl;
player->upperLevel=false; //Assume player starts on lower level.
player->SetPos(MAP_DATA[map].MapData.playerSpawnLocation);
std::cout<<"Player spawn info set."<<std::endl;
pathfinder.Initialize();
}

12
Crawler/DEFINES.h
View File

@ -6,7 +6,6 @@
#define INCLUDE_game extern Crawler*game;
#define INCLUDE_MONSTER_DATA extern std::map<MonsterName,MonsterData>MONSTER_DATA;
#define INCLUDE_BULLET_LIST extern std::vector<std::unique_ptr<Bullet>>BULLET_LIST;
#define INCLUDE_CLASS_DATA extern std::map<Class,std::unique_ptr<ClassData>>CLASS_DATA;
#define INCLUDE_PARTICLE_LIST extern std::vector<Particle>PARTICLE_LIST;
#define INCLUDE_EMITTER_LIST extern std::vector<std::unique_ptr<Emitter>>EMITTER_LIST;
@ -15,10 +14,19 @@
#define INFINITE 999999
#define SETUP_CLASS(class) \
class::class(){InitializeClassAbilities();} \
Class class::GetClass(){return cl;} \
std::string class::GetClassName(){return name;} \
Ability&class::GetRightClickAbility(){return rightClickAbility;}; \
Ability&class::GetAbility1(){return ability1;}; \
Ability&class::GetAbility2(){return ability2;}; \
Ability&class::GetAbility3(){return ability3;}; \
Ability&class::GetAbility4(){return ability4;};
Ability&class::GetAbility4(){return ability4;}; \
AnimationState&class::GetWalkNAnimation(){return walk_n;}; \
AnimationState&class::GetWalkEAnimation(){return walk_e;}; \
AnimationState&class::GetWalkSAnimation(){return walk_s;}; \
AnimationState&class::GetWalkWAnimation(){return walk_w;}; \
AnimationState&class::GetIdleNAnimation(){return idle_n;}; \
AnimationState&class::GetIdleEAnimation(){return idle_e;}; \
AnimationState&class::GetIdleSAnimation(){return idle_s;}; \
AnimationState&class::GetIdleWAnimation(){return idle_w;};

1
Crawler/Emitter.cpp
View File

@ -15,4 +15,5 @@ bool Emitter::Update(float fElapsedTime){
if(timer<0){
return false;
}
return true;
}

2
Crawler/Emitter.h
View File

@ -1,5 +1,5 @@
#include "olcPixelGameEngine.h"
#pragma once
#include "olcPixelGameEngine.h"
struct Emitter{
float frequency;

4
Crawler/EnergyBolt.cpp
View File

@ -17,11 +17,11 @@ void EnergyBolt::Update(float fElapsedTime){
}
}
bool EnergyBolt::PlayerHit(Player& player)
bool EnergyBolt::PlayerHit(Player*player)
{
deactivated=true;
fadeOutTime=0.2f;
game->AddEffect(std::make_unique<Effect>(player.GetPos(),0,AnimationState::SPLASH_EFFECT,upperLevel,player.GetSizeMult(),0.25));
game->AddEffect(std::make_unique<Effect>(player->GetPos(),0,AnimationState::SPLASH_EFFECT,upperLevel,player->GetSizeMult(),0.25));
return false;
}

4
Crawler/FireBolt.cpp
View File

@ -18,11 +18,11 @@ void FireBolt::Update(float fElapsedTime){
}
}
bool FireBolt::PlayerHit(Player& player)
bool FireBolt::PlayerHit(Player*player)
{
deactivated=true;
fadeOutTime=0.2f;
game->AddEffect(std::make_unique<Effect>(player.GetPos(),0,AnimationState::SPLASH_EFFECT,upperLevel,5,0.25,vf2d{},Pixel{240,120,60}));
game->AddEffect(std::make_unique<Effect>(player->GetPos(),0,AnimationState::SPLASH_EFFECT,upperLevel,5,0.25,vf2d{},Pixel{240,120,60}));
return false;
}

4
Crawler/LightningBolt.cpp
View File

@ -34,11 +34,11 @@ void LightningBolt::Update(float fElapsedTime){
}
}
bool LightningBolt::PlayerHit(Player& player)
bool LightningBolt::PlayerHit(Player*player)
{
deactivated=true;
fadeOutTime=0.2f;
game->AddEffect(std::make_unique<Effect>(player.GetPos(),0.3,AnimationState::LIGHTNING_SPLASH,upperLevel,player.GetSizeMult(),0.25,vf2d{},WHITE,util::random(PI)));
game->AddEffect(std::make_unique<Effect>(player->GetPos(),0.3,AnimationState::LIGHTNING_SPLASH,upperLevel,player->GetSizeMult(),0.25,vf2d{},WHITE,util::random(PI)));
return false;
}

4
Crawler/Monster.cpp
View File

@ -285,10 +285,10 @@ void Monster::Draw(){
game->view.DrawPartialDecal(GetPos()-vf2d{12,12}*GetSizeMult(),GetFrame().GetSourceImage()->Decal(),GetFrame().GetSourceRect().pos,GetFrame().GetSourceRect().size,vf2d(GetSizeMult(),GetSizeMult()),GetBuffs(BuffType::SLOWDOWN).size()>0?Pixel{uint8_t(255*abs(sin(1.4*GetBuffs(BuffType::SLOWDOWN)[0].duration))),uint8_t(255*abs(sin(1.4*GetBuffs(BuffType::SLOWDOWN)[0].duration))),uint8_t(128+127*abs(sin(1.4*GetBuffs(BuffType::SLOWDOWN)[0].duration)))}:WHITE);
}
}
void Monster::Collision(Player&p){
void Monster::Collision(Player*p){
if(MONSTER_DATA[type].GetCollisionDmg()>0&&!hasHitPlayer){
hasHitPlayer=true;
p.Hurt(MONSTER_DATA[type].GetCollisionDmg());
p->Hurt(MONSTER_DATA[type].GetCollisionDmg());
}
Collision();
}

6
Crawler/Monster.h
View File

@ -2,9 +2,11 @@
#include "olcPixelGameEngine.h"
#include "Animation.h"
#include "State.h"
#include "Player.h"
#include "Buff.h"
#include "olcUTIL_Animate2D.h"
struct Player;
enum MonsterStrategy{
RUN_TOWARDS,
SHOOT_AFAR
@ -101,7 +103,7 @@ protected:
vf2d&GetTargetPos();
Key GetFacingDirection();
void Draw();
void Collision(Player&p);
void Collision(Player*p);
void Collision(Monster&p);
void Collision();
void SetVelocity(vf2d vel);

23
Crawler/Player.cpp
View File

@ -12,13 +12,12 @@ INCLUDE_ANIMATION_DATA
INCLUDE_SPAWNER_LIST
INCLUDE_BULLET_LIST
INCLUDE_DAMAGENUMBER_LIST
INCLUDE_CLASS_DATA
INCLUDE_game
const float Player::GROUND_SLAM_SPIN_TIME=0.6f;
Player::Player():
state(State::NORMAL),lastReleasedMovementKey(DOWN),facingDirection(DOWN){}
Player::Player()
:state(State::NORMAL),lastReleasedMovementKey(DOWN),facingDirection(DOWN){}
bool Player::SetX(float x){
vf2d newPos={x,pos.y};
@ -151,10 +150,10 @@ State Player::GetState(){
void Player::Update(float fElapsedTime){
Ability&rightClickAbility=GetRightClickAbility(),
ability1=GetAbility1(),
ability2=GetAbility2(),
ability3=GetAbility3(),
ability4=GetAbility4();
&ability1=GetAbility1(),
&ability2=GetAbility2(),
&ability3=GetAbility3(),
&ability4=GetAbility4();
attack_cooldown_timer=std::max(0.f,attack_cooldown_timer-fElapsedTime);
iframe_time=std::max(0.f,iframe_time-fElapsedTime);
notEnoughManaDisplay.second=std::max(0.f,notEnoughManaDisplay.second-fElapsedTime);
@ -173,7 +172,7 @@ void Player::Update(float fElapsedTime){
}
}
//Class-specific update events.
Update(fElapsedTime);
OnUpdate(fElapsedTime);
switch(state){
case SPIN:{
switch(facingDirection){
@ -258,7 +257,7 @@ void Player::Update(float fElapsedTime){
for(Monster&m:MONSTER_LIST){
if(iframe_time==0&&OnUpperLevel()==m.OnUpperLevel()&&geom2d::overlaps(geom2d::circle(pos,12*size/2),geom2d::circle(m.GetPos(),12*m.GetSizeMult()/2))){
if(m.IsAlive()){
m.Collision(*this);
m.Collision(this);
}
geom2d::line line(pos,m.GetPos());
float dist = line.length();
@ -390,8 +389,10 @@ void Player::AddAnimation(AnimationState state){
animation.AddState(state,ANIMATION_DATA[state]);
}
void Player::UpdateAnimation(AnimationState animState){
animation.ChangeState(internal_animState,animState);
void Player::UpdateAnimation(AnimationState animState,int specificClass){
if(specificClass==ANY||specificClass&GetClass()){
animation.ChangeState(internal_animState,animState);
}
}
Animate2D::Frame Player::GetFrame(){

170
Crawler/Player.h
View File

@ -31,8 +31,8 @@ struct Player{
Animate2D::Animation<AnimationState>animation;
Animate2D::AnimationState internal_animState;
Key lastReleasedMovementKey;
void AddAnimation(AnimationState state);
void Update(float fElapsedTime);
void AddAnimation(AnimationState state);
std::vector<Buff>buffList;
protected:
const float ATTACK_COOLDOWN=0.35f;
@ -90,7 +90,8 @@ public:
std::vector<Buff>GetBuffs(BuffType buff);
bool Hurt(int damage);
void UpdateAnimation(AnimationState animState);
//specificClass is a bitwise-combination of classes from the Class enum. It makes sure certain animations only play if you are a certain class.
void UpdateAnimation(AnimationState animState,int specificClass=ANY);
Animate2D::Frame GetFrame();
Key GetLastReleasedMovementKey();
float GetSwordSwingTimer();
@ -100,6 +101,7 @@ public:
virtual ~Player()=default;
virtual Class GetClass()=0;
virtual bool AutoAttack()=0;
virtual void OnUpdate(float fElapsedTime)=0;
virtual void InitializeClassAbilities()=0;
virtual std::string GetClassName()=0;
virtual Ability&GetRightClickAbility()=0;
@ -107,14 +109,14 @@ public:
virtual Ability&GetAbility2()=0;
virtual Ability&GetAbility3()=0;
virtual Ability&GetAbility4()=0;
virtual AnimationState GetWalkNAnimation()=0;
virtual AnimationState GetWalkEAnimation()=0;
virtual AnimationState GetWalkSAnimation()=0;
virtual AnimationState GetWalkWAnimation()=0;
virtual AnimationState GetIdleNAnimation()=0;
virtual AnimationState GetIdleEAnimation()=0;
virtual AnimationState GetIdleSAnimation()=0;
virtual AnimationState GetIdleWAnimation()=0;
virtual AnimationState&GetWalkNAnimation()=0;
virtual AnimationState&GetWalkEAnimation()=0;
virtual AnimationState&GetWalkSAnimation()=0;
virtual AnimationState&GetWalkWAnimation()=0;
virtual AnimationState&GetIdleNAnimation()=0;
virtual AnimationState&GetIdleEAnimation()=0;
virtual AnimationState&GetIdleSAnimation()=0;
virtual AnimationState&GetIdleWAnimation()=0;
};
struct Warrior:Player{
@ -122,8 +124,10 @@ struct Warrior:Player{
static Class cl;
static Ability rightClickAbility,ability1,ability2,ability3,ability4;
static AnimationState walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
Warrior();
Class GetClass()override;
bool AutoAttack()override;
void OnUpdate(float fElapsedTime)override;
void InitializeClassAbilities()override;
std::string GetClassName()override;
Ability&GetRightClickAbility()override;
@ -131,12 +135,142 @@ struct Warrior:Player{
Ability&GetAbility2()override;
Ability&GetAbility3()override;
Ability&GetAbility4()override;
AnimationState GetWalkNAnimation()override;
AnimationState GetWalkEAnimation()override;
AnimationState GetWalkSAnimation()override;
AnimationState GetWalkWAnimation()override;
AnimationState GetIdleNAnimation()override;
AnimationState GetIdleEAnimation()override;
AnimationState GetIdleSAnimation()override;
AnimationState GetIdleWAnimation()override;
AnimationState&GetWalkNAnimation()override;
AnimationState&GetWalkEAnimation()override;
AnimationState&GetWalkSAnimation()override;
AnimationState&GetWalkWAnimation()override;
AnimationState&GetIdleNAnimation()override;
AnimationState&GetIdleEAnimation()override;
AnimationState&GetIdleSAnimation()override;
AnimationState&GetIdleWAnimation()override;
};
struct Thief:Player{
static std::string name;
static Class cl;
static Ability rightClickAbility,ability1,ability2,ability3,ability4;
static AnimationState walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
Thief();
Class GetClass()override;
bool AutoAttack()override;
void OnUpdate(float fElapsedTime)override;
void InitializeClassAbilities()override;
std::string GetClassName()override;
Ability&GetRightClickAbility()override;
Ability&GetAbility1()override;
Ability&GetAbility2()override;
Ability&GetAbility3()override;
Ability&GetAbility4()override;
AnimationState&GetWalkNAnimation()override;
AnimationState&GetWalkEAnimation()override;
AnimationState&GetWalkSAnimation()override;
AnimationState&GetWalkWAnimation()override;
AnimationState&GetIdleNAnimation()override;
AnimationState&GetIdleEAnimation()override;
AnimationState&GetIdleSAnimation()override;
AnimationState&GetIdleWAnimation()override;
};
struct Ranger:Player{
static std::string name;
static Class cl;
static Ability rightClickAbility,ability1,ability2,ability3,ability4;
static AnimationState walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
Ranger();
Class GetClass()override;
bool AutoAttack()override;
void OnUpdate(float fElapsedTime)override;
void InitializeClassAbilities()override;
std::string GetClassName()override;
Ability&GetRightClickAbility()override;
Ability&GetAbility1()override;
Ability&GetAbility2()override;
Ability&GetAbility3()override;
Ability&GetAbility4()override;
AnimationState&GetWalkNAnimation()override;
AnimationState&GetWalkEAnimation()override;
AnimationState&GetWalkSAnimation()override;
AnimationState&GetWalkWAnimation()override;
AnimationState&GetIdleNAnimation()override;
AnimationState&GetIdleEAnimation()override;
AnimationState&GetIdleSAnimation()override;
AnimationState&GetIdleWAnimation()override;
};
struct Trapper:Player{
static std::string name;
static Class cl;
static Ability rightClickAbility,ability1,ability2,ability3,ability4;
static AnimationState walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
Trapper();
Class GetClass()override;
bool AutoAttack()override;
void OnUpdate(float fElapsedTime)override;
void InitializeClassAbilities()override;
std::string GetClassName()override;
Ability&GetRightClickAbility()override;
Ability&GetAbility1()override;
Ability&GetAbility2()override;
Ability&GetAbility3()override;
Ability&GetAbility4()override;
AnimationState&GetWalkNAnimation()override;
AnimationState&GetWalkEAnimation()override;
AnimationState&GetWalkSAnimation()override;
AnimationState&GetWalkWAnimation()override;
AnimationState&GetIdleNAnimation()override;
AnimationState&GetIdleEAnimation()override;
AnimationState&GetIdleSAnimation()override;
AnimationState&GetIdleWAnimation()override;
};
struct Wizard:Player{
static std::string name;
static Class cl;
static Ability rightClickAbility,ability1,ability2,ability3,ability4;
static AnimationState walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
Wizard();
Class GetClass()override;
bool AutoAttack()override;
void OnUpdate(float fElapsedTime)override;
void InitializeClassAbilities()override;
std::string GetClassName()override;
Ability&GetRightClickAbility()override;
Ability&GetAbility1()override;
Ability&GetAbility2()override;
Ability&GetAbility3()override;
Ability&GetAbility4()override;
AnimationState&GetWalkNAnimation()override;
AnimationState&GetWalkEAnimation()override;
AnimationState&GetWalkSAnimation()override;
AnimationState&GetWalkWAnimation()override;
AnimationState&GetIdleNAnimation()override;
AnimationState&GetIdleEAnimation()override;
AnimationState&GetIdleSAnimation()override;
AnimationState&GetIdleWAnimation()override;
};
struct Witch:Player{
static std::string name;
static Class cl;
static Ability rightClickAbility,ability1,ability2,ability3,ability4;
static AnimationState walk_n,walk_e,walk_s,walk_w,idle_n,idle_e,idle_s,idle_w;
Witch();
Class GetClass()override;
bool AutoAttack()override;
void OnUpdate(float fElapsedTime)override;
void InitializeClassAbilities()override;
std::string GetClassName()override;
Ability&GetRightClickAbility()override;
Ability&GetAbility1()override;
Ability&GetAbility2()override;
Ability&GetAbility3()override;
Ability&GetAbility4()override;
AnimationState&GetWalkNAnimation()override;
AnimationState&GetWalkEAnimation()override;
AnimationState&GetWalkSAnimation()override;
AnimationState&GetWalkWAnimation()override;
AnimationState&GetIdleNAnimation()override;
AnimationState&GetIdleEAnimation()override;
AnimationState&GetIdleSAnimation()override;
AnimationState&GetIdleWAnimation()override;
};

62
Crawler/Ranger.cpp Normal file
View File

@ -0,0 +1,62 @@
#include "Class.h"
#include "olcPixelGameEngine.h"
#include "DEFINES.h"
#include "Player.h"
#include "Effect.h"
#include "Crawler.h"
INCLUDE_MONSTER_LIST
INCLUDE_BULLET_LIST
INCLUDE_game
std::string Ranger::name="Ranger";
Class Ranger::cl=RANGER;
Ability Ranger::rightClickAbility={"Retreat",7,0,VERY_DARK_BLUE,DARK_BLUE};
Ability Ranger::ability1={"Rapid Fire",12,35};
Ability Ranger::ability2={"Charged Shot",15,40};
Ability Ranger::ability3={"Multishot",25,50};
Ability Ranger::ability4={"???",0,0};
AnimationState Ranger::idle_n=RANGER_IDLE_N;
AnimationState Ranger::idle_e=RANGER_IDLE_E;
AnimationState Ranger::idle_s=RANGER_IDLE_S;
AnimationState Ranger::idle_w=RANGER_IDLE_W;
AnimationState Ranger::walk_n=RANGER_WALK_N;
AnimationState Ranger::walk_e=RANGER_WALK_E;
AnimationState Ranger::walk_s=RANGER_WALK_S;
AnimationState Ranger::walk_w=RANGER_WALK_W;
SETUP_CLASS(Ranger)
void Ranger::OnUpdate(float fElapsedTime){
}
bool Ranger::AutoAttack(){
return false;
}
void Ranger::InitializeClassAbilities(){
#pragma region Ranger Right-click Ability (???)
Ranger::rightClickAbility.action=
[&](){
return false;
};
#pragma endregion
#pragma region Ranger Ability 1 (???)
Ranger::ability1.action=
[&](){
return false;
};
#pragma endregion
#pragma region Ranger Ability 2 (???)
Ranger::ability2.action=
[&](){
return false;
};
#pragma endregion
#pragma region Ranger Ability 3 (???)
Ranger::ability3.action=
[&](){
return false;
};
#pragma endregion
}

4
Crawler/TSXParser.h
View File

@ -18,7 +18,7 @@ struct Tileset{
class TSXParser{
public:
Tileset GetData();
Tileset&GetData();
private:
Tileset parsedTilesetInfo;
void ParseTag(std::string tag);
@ -31,7 +31,7 @@ class TSXParser{
#ifdef TSX_PARSER_SETUP
#undef TSX_PARSER_SETUP
Tileset TSXParser::GetData() {
Tileset&TSXParser::GetData() {
return parsedTilesetInfo;
}
std::ostream&operator<<(std::ostream& os, Tileset& rhs){

62
Crawler/Thief.cpp Normal file
View File

@ -0,0 +1,62 @@
#include "Class.h"
#include "olcPixelGameEngine.h"
#include "DEFINES.h"
#include "Player.h"
#include "Effect.h"
#include "Crawler.h"
INCLUDE_MONSTER_LIST
INCLUDE_BULLET_LIST
INCLUDE_game
std::string Thief::name="Thief";
Class Thief::cl=THIEF;
Ability Thief::rightClickAbility={"???",15,0,VERY_DARK_BLUE,DARK_BLUE};
Ability Thief::ability1={"???",12,40};
Ability Thief::ability2={"???",15,50};
Ability Thief::ability3={"???",40,60};
Ability Thief::ability4={"???",0,0};
AnimationState Thief::idle_n=WARRIOR_IDLE_N;
AnimationState Thief::idle_e=WARRIOR_IDLE_E;
AnimationState Thief::idle_s=WARRIOR_IDLE_S;
AnimationState Thief::idle_w=WARRIOR_IDLE_W;
AnimationState Thief::walk_n=WARRIOR_WALK_N;
AnimationState Thief::walk_e=WARRIOR_WALK_E;
AnimationState Thief::walk_s=WARRIOR_WALK_S;
AnimationState Thief::walk_w=WARRIOR_WALK_W;
SETUP_CLASS(Thief)
void Thief::OnUpdate(float fElapsedTime){
}
bool Thief::AutoAttack(){
return false;
}
void Thief::InitializeClassAbilities(){
#pragma region Thief Right-click Ability (???)
Thief::rightClickAbility.action=
[&](){
return false;
};
#pragma endregion
#pragma region Thief Ability 1 (???)
Thief::ability1.action=
[&](){
return false;
};
#pragma endregion
#pragma region Thief Ability 2 (???)
Thief::ability2.action=
[&](){
return false;
};
#pragma endregion
#pragma region Thief Ability 3 (???)
Thief::ability3.action=
[&](){
return false;
};
#pragma endregion
}

62
Crawler/Trapper.cpp Normal file
View File

@ -0,0 +1,62 @@
#include "Class.h"
#include "olcPixelGameEngine.h"
#include "DEFINES.h"
#include "Player.h"
#include "Effect.h"
#include "Crawler.h"
INCLUDE_MONSTER_LIST
INCLUDE_BULLET_LIST
INCLUDE_game
std::string Trapper::name="Trapper";
Class Trapper::cl=TRAPPER;
Ability Trapper::rightClickAbility={"???",15,0,VERY_DARK_BLUE,DARK_BLUE};
Ability Trapper::ability1={"???",12,40};
Ability Trapper::ability2={"???",15,50};
Ability Trapper::ability3={"???",40,60};
Ability Trapper::ability4={"???",0,0};
AnimationState Trapper::idle_n=WARRIOR_IDLE_N;
AnimationState Trapper::idle_e=WARRIOR_IDLE_E;
AnimationState Trapper::idle_s=WARRIOR_IDLE_S;
AnimationState Trapper::idle_w=WARRIOR_IDLE_W;
AnimationState Trapper::walk_n=WARRIOR_WALK_N;
AnimationState Trapper::walk_e=WARRIOR_WALK_E;
AnimationState Trapper::walk_s=WARRIOR_WALK_S;
AnimationState Trapper::walk_w=WARRIOR_WALK_W;
SETUP_CLASS(Trapper)
void Trapper::OnUpdate(float fElapsedTime){
}
bool Trapper::AutoAttack(){
return false;
}
void Trapper::InitializeClassAbilities(){
#pragma region Trapper Right-click Ability (???)
Trapper::rightClickAbility.action=
[&](){
return false;
};
#pragma endregion
#pragma region Trapper Ability 1 (???)
Trapper::ability1.action=
[&](){
return false;
};
#pragma endregion
#pragma region Trapper Ability 2 (???)
Trapper::ability2.action=
[&](){
return false;
};
#pragma endregion
#pragma region Trapper Ability 3 (???)
Trapper::ability3.action=
[&](){
return false;
};
#pragma endregion
}

28
Crawler/Warrior.cpp
View File

@ -16,9 +16,21 @@ Ability Warrior::ability1={"Battlecry",12,40};
Ability Warrior::ability2={"Ground Slam",15,50};
Ability Warrior::ability3={"Sonic Slash",40,60};
Ability Warrior::ability4={"???",0,0};
AnimationState Warrior::idle_n=WARRIOR_IDLE_N;
AnimationState Warrior::idle_e=WARRIOR_IDLE_E;
AnimationState Warrior::idle_s=WARRIOR_IDLE_S;
AnimationState Warrior::idle_w=WARRIOR_IDLE_W;
AnimationState Warrior::walk_n=WARRIOR_WALK_N;
AnimationState Warrior::walk_e=WARRIOR_WALK_E;
AnimationState Warrior::walk_s=WARRIOR_WALK_S;
AnimationState Warrior::walk_w=WARRIOR_WALK_W;
SETUP_CLASS(Warrior)
void Warrior::OnUpdate(float fElapsedTime){
}
bool Warrior::AutoAttack(){
if(GetState()!=State::SPIN){
bool attack=false;
@ -39,16 +51,16 @@ bool Warrior::AutoAttack(){
SetState(State::SWING_SWORD);
switch(facingDirection){
case DOWN:{
UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_S);
UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_S,WARRIOR|THIEF);
}break;
case RIGHT:{
UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_E);
UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_E,WARRIOR|THIEF);
}break;
case LEFT:{
UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_W);
UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_W,WARRIOR|THIEF);
}break;
case UP:{
UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_N);
UpdateAnimation(AnimationState::WARRIOR_SWINGSWORD_N,WARRIOR|THIEF);
}break;
}
}
@ -100,22 +112,22 @@ void Warrior::InitializeClassAbilities(){
case UP:{
vel.y=70;
bulletVel.y=-400;
UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_N);
UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_N,WARRIOR);
}break;
case LEFT:{
vel.x=70;
bulletVel.x=-400;
UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_W);
UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_W,WARRIOR);
}break;
case RIGHT:{
vel.x=-70;
bulletVel.x=400;
UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_E);
UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_E,WARRIOR);
}break;
case DOWN:{
vel.y=-70;
bulletVel.y=400;
UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_S);
UpdateAnimation(AnimationState::WARRIOR_SWINGSONICSWORD_S,WARRIOR);
}break;
}
BULLET_LIST.push_back(std::make_unique<Bullet>(GetPos(),bulletVel,30,GetAttack()*8,AnimationState::SONICSLASH,upperLevel,true,2.25,true,true,WHITE));

62
Crawler/Witch.cpp Normal file
View File

@ -0,0 +1,62 @@
#include "Class.h"
#include "olcPixelGameEngine.h"
#include "DEFINES.h"
#include "Player.h"
#include "Effect.h"
#include "Crawler.h"
INCLUDE_MONSTER_LIST
INCLUDE_BULLET_LIST
INCLUDE_game
std::string Witch::name="Witch";
Class Witch::cl=WITCH;
Ability Witch::rightClickAbility={"???",15,0,VERY_DARK_BLUE,DARK_BLUE};
Ability Witch::ability1={"???",12,40};
Ability Witch::ability2={"???",15,50};
Ability Witch::ability3={"???",40,60};
Ability Witch::ability4={"???",0,0};
AnimationState Witch::idle_n=WARRIOR_IDLE_N;
AnimationState Witch::idle_e=WARRIOR_IDLE_E;
AnimationState Witch::idle_s=WARRIOR_IDLE_S;
AnimationState Witch::idle_w=WARRIOR_IDLE_W;
AnimationState Witch::walk_n=WARRIOR_WALK_N;
AnimationState Witch::walk_e=WARRIOR_WALK_E;
AnimationState Witch::walk_s=WARRIOR_WALK_S;
AnimationState Witch::walk_w=WARRIOR_WALK_W;
SETUP_CLASS(Witch)
void Witch::OnUpdate(float fElapsedTime){
}
bool Witch::AutoAttack(){
return false;
}
void Witch::InitializeClassAbilities(){
#pragma region Witch Right-click Ability (???)
Witch::rightClickAbility.action=
[&](){
return false;
};
#pragma endregion
#pragma region Witch Ability 1 (???)
Witch::ability1.action=
[&](){
return false;
};
#pragma endregion
#pragma region Witch Ability 2 (???)
Witch::ability2.action=
[&](){
return false;
};
#pragma endregion
#pragma region Witch Ability 3 (???)
Witch::ability3.action=
[&](){
return false;
};
#pragma endregion
}

128
Crawler/Wizard.cpp Normal file
View File

@ -0,0 +1,128 @@
#include "Class.h"
#include "olcPixelGameEngine.h"
#include "DEFINES.h"
#include "Player.h"
#include "Effect.h"
#include "Crawler.h"
#include "BulletTypes.h"
INCLUDE_MONSTER_LIST
INCLUDE_BULLET_LIST
INCLUDE_game
std::string Wizard::name="Wizard";
Class Wizard::cl=WIZARD;
Ability Wizard::rightClickAbility={"Teleport",8,5,VERY_DARK_BLUE,DARK_BLUE};
Ability Wizard::ability1={"Firebolt",6,30};
Ability Wizard::ability2={"Lightning Bolt",6,25};
Ability Wizard::ability3={"Meteor",40,75};
Ability Wizard::ability4={"???",0,0};
AnimationState Wizard::idle_n=WIZARD_IDLE_N;
AnimationState Wizard::idle_e=WIZARD_IDLE_E;
AnimationState Wizard::idle_s=WIZARD_IDLE_S;
AnimationState Wizard::idle_w=WIZARD_IDLE_W;
AnimationState Wizard::walk_n=WIZARD_WALK_N;
AnimationState Wizard::walk_e=WIZARD_WALK_E;
AnimationState Wizard::walk_s=WIZARD_WALK_S;
AnimationState Wizard::walk_w=WIZARD_WALK_W;
SETUP_CLASS(Wizard)
void Wizard::OnUpdate(float fElapsedTime){
if(attack_cooldown_timer>0){
idle_n=AnimationState::WIZARD_IDLE_ATTACK_N;
idle_e=AnimationState::WIZARD_IDLE_ATTACK_E;
idle_s=AnimationState::WIZARD_IDLE_ATTACK_S;
idle_w=AnimationState::WIZARD_IDLE_ATTACK_W;
walk_n=AnimationState::WIZARD_ATTACK_N;
walk_e=AnimationState::WIZARD_ATTACK_E;
walk_s=AnimationState::WIZARD_ATTACK_S;
walk_w=AnimationState::WIZARD_ATTACK_W;
} else {
idle_n=AnimationState::WIZARD_IDLE_N;
idle_e=AnimationState::WIZARD_IDLE_E;
idle_s=AnimationState::WIZARD_IDLE_S;
idle_w=AnimationState::WIZARD_IDLE_W;
walk_n=AnimationState::WIZARD_WALK_N;
walk_e=AnimationState::WIZARD_WALK_E;
walk_s=AnimationState::WIZARD_WALK_S;
walk_w=AnimationState::WIZARD_WALK_W;
}
if(GetState()==State::CASTING){
switch(GetFacingDirection()){
case UP:{
UpdateAnimation(AnimationState::WIZARD_CAST_N,WIZARD|WITCH);
}break;
case DOWN:{
UpdateAnimation(AnimationState::WIZARD_CAST_S,WIZARD|WITCH);
}break;
case LEFT:{
UpdateAnimation(AnimationState::WIZARD_CAST_W,WIZARD|WITCH);
}break;
case RIGHT:{
UpdateAnimation(AnimationState::WIZARD_CAST_E,WIZARD|WITCH);
}break;
}
}
}
bool Wizard::AutoAttack(){
attack_cooldown_timer=MAGIC_ATTACK_COOLDOWN;
float angleToCursor=atan2(game->GetWorldMousePos().y-GetPos().y,game->GetWorldMousePos().x-GetPos().x);
BULLET_LIST.push_back(std::make_unique<EnergyBolt>(EnergyBolt(GetPos(),{cos(angleToCursor)*200,sin(angleToCursor)*200},12,GetAttack(),upperLevel,true,WHITE)));
return true;
}
void Wizard::InitializeClassAbilities(){
#pragma region Wizard Right-click Ability (???)
Wizard::rightClickAbility.action=
[&](){
float pointMouseDirection=atan2(game->GetWorldMousePos().y-GetPos().y,game->GetWorldMousePos().x-GetPos().x);
vf2d pointTowardsMouse={cos(pointMouseDirection),sin(pointMouseDirection)};
float dist=std::clamp(geom2d::line<float>{GetPos(),game->GetWorldMousePos()}.length(),0.f,6.5f*24);
if(dist<12)return false;
vf2d teleportPoint=GetPos()+pointTowardsMouse*dist;
while(dist>0&&game->HasTileCollision(game->GetCurrentLevel(),teleportPoint)&&CanPathfindTo(GetPos(),teleportPoint)){
dist-=24;
teleportPoint=GetPos()+pointTowardsMouse*dist;
}
if(dist>0&&CanPathfindTo(GetPos(),teleportPoint)){
SetState(State::TELEPORT);
teleportAnimationTimer=0.35;
teleportTarget=teleportPoint;
teleportStartPosition=GetPos();
iframe_time=0.35;
for(int i=0;i<16;i++){
game->AddEffect(std::make_unique<Effect>(GetPos()+vf2d{(rand()%160-80)/10.f,(rand()%160-80)/10.f},float(rand()%300)/1000,AnimationState::DOT_PARTICLE,upperLevel,0.3,0.2,vf2d{float(rand()%1000-500)/100,float(rand()%1000-500)/100},BLACK));
}
return true;
} else {
notificationDisplay={"Cannot Teleport to that location!",0.5};
return false;
}
};
#pragma endregion
#pragma region Wizard Ability 1 (???)
Wizard::ability1.action=
[&](){
float angleToCursor=atan2(game->GetWorldMousePos().y-GetPos().y,game->GetWorldMousePos().x-GetPos().x);
BULLET_LIST.push_back(std::make_unique<FireBolt>(FireBolt(GetPos(),{cos(angleToCursor)*275,sin(angleToCursor)*275},12,GetAttack(),upperLevel,true,{240,120,60})));
return true;
};
#pragma endregion
#pragma region Wizard Ability 2 (???)
Wizard::ability2.action=
[&](){
float angleToCursor=atan2(game->GetWorldMousePos().y-GetPos().y,game->GetWorldMousePos().x-GetPos().x);
BULLET_LIST.push_back(std::make_unique<LightningBolt>(LightningBolt(GetPos(),{cos(angleToCursor)*230,sin(angleToCursor)*230},12,GetAttack()*4,upperLevel,true,WHITE)));
return true;
};
#pragma endregion
#pragma region Wizard Ability 3 (???)
Wizard::ability3.action=
[&](){
SetState(State::CASTING);
game->AddEffect(std::make_unique<Meteor>(GetPos(),3,AnimationState::METEOR,OnUpperLevel(),vf2d{1,1},2));
return true;
};
#pragma endregion
}

2
Crawler/sig
View File

@ -1,4 +1,4 @@
export AUTO_UPDATE=true
export AUTO_UPDATE=false
source utils/define.sh