sigonasr2
/
VirusAttack
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
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.
94 Commits
2 Branches
0 Tags
196 MiB
 
 
 
Tag: Branch: Tree: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
VirusAttack/olcCodeJam2023Entry/VirusAttack.cpp

1786 lines
70 KiB
Raw Permalink Blame History

#define OLC_PGE_APPLICATION
#define OLC_SOUNDWAVE
#define OLC_PGEX_TRANSFORMEDVIEW
#define AUDIO_LISTENER_IMPLEMENTATION
#define AUDIO_SOURCE_IMPLEMENTATION
#define OLC_PGEX_QUICKGUI
#define SPLASH_ENABLED
#ifdef SPLASH_ENABLED
#define OLC_PGEX_SPLASHSCREEN
#endif
#include "Scenario.h"
#include "TileManager.h"
#include "olcUTIL_Geometry2D.h"
#include "util.h"
#include "Level.h"
#include "Scenario.h"
#include "VirusAttack.h"
VirusAttack*game;
std::vector<std::unique_ptr<Renderable>>IMAGES;
std::vector<std::unique_ptr<Audio>>SOUNDS;
std::vector<std::unique_ptr<Scenario>>SCENARIOS;
VirusAttack::VirusAttack()
{
// Name your application
sAppName = "Virus Attack";
game=this;
}
void VirusAttack::InitializeImages(){
auto LoadImage=[&](Image img,std::string filepath,bool filter=false,bool clamp=true){
IMAGES.emplace_back(std::make_unique<Renderable>());
IMAGES[img]->Load(filepath,nullptr,filter,clamp);
};
LoadImage(TILE,"assets/tile.png",false,false);
LoadImage(MINIMAP_HUD,"assets/minimap_hud.png");
LoadImage(OUTLINE,"assets/outline.png");
IMAGES.emplace_back(std::make_unique<Renderable>());
IMAGES[MINIMAP_OUTLINE]->Create(64,64);
LoadImage(VIRUS_IMG1,"assets/unit.png");
LoadImage(SELECTION_CIRCLE,"assets/selection_circle.png");
IMAGES.emplace_back(std::make_unique<Renderable>());
IMAGES[MATRIX]->Create(64,64,false,false);
IMAGES[MATRIX]->Sprite()->SetSampleMode(Sprite::PERIODIC);
LoadImage(MEMORY_COLLECTION_POINT,"assets/memory_collection_point.png");
LoadImage(LEFT_SHIFTER,"assets/left_shifter.png");
LoadImage(RIGHT_SHIFTER,"assets/right_shifter.png");
LoadImage(BIT_RESTORER,"assets/bit_restorer.png");
LoadImage(MEMORY_SWAPPER,"assets/memory_swapper.png");
LoadImage(CORRUPTER,"assets/corrupter.png");
LoadImage(UNIT_ALLOCATOR,"assets/shell.png");
LoadImage(RAM_BANK,"assets/ram_bank.png");
LoadImage(RANGE_INDICATOR,"assets/range_indicator.png");
LoadImage(DOWN_ARROW,"assets/down_arrow.png");
LoadImage(RED_X,"assets/red_x.png");
LoadImage(RLD,"assets/rld.png");
LoadImage(PRC,"assets/prc.png");
LoadImage(RNG,"assets/rng.png");
LoadImage(SPD,"assets/spd.png");
LoadImage(TARGETING_LINE,"assets/targetLine.png");
LoadImage(ATTACKING_LINE,"assets/attackLine.png",false,false);
LoadImage(RLD_ICON,"assets/rld_icon.png");
LoadImage(PRC_ICON,"assets/prc_icon.png");
LoadImage(RNG_ICON,"assets/rng_icon.png");
LoadImage(SPD_ICON,"assets/spd_icon.png");
LoadImage(RESOURCE,"assets/material.png");
LoadImage(MEMORY_COLLECTION_POINT_HIGHLIGHT,"assets/memory_collection_point_highlight.png");
LoadImage(MEMORY_GUARD,"assets/memoryguard.png");
LoadImage(REFRESHER,"assets/refresher.png");
LoadImage(TURRET,"assets/turret.png");
LoadImage(PLATFORM,"assets/platform.png");
LoadImage(GUARD_ICON,"assets/shieldIcon.png");
LoadImage(GUIDE,"assets/guide.png");
LoadImage(ROUND_BAR,"assets/round_bar.png");
LoadImage(SEGMENT_BAR,"assets/segmentBar.png",false,false);
LoadImage(HOODED_FIGURE,"assets/hooded_figure.png");
LoadImage(SPOOK_HOODED_FIGURE,"assets/spook_hooded_figure.png");
LoadImage(RESTART,"assets/restart.png");
LoadImage(RESTART_HOVER,"assets/restartHover.png");
LoadImage(SHIELD_BUBBLE,"assets/shieldbubble.png");
titleScreenText.Create(426,100,false,true);
SetDrawTarget(titleScreenText.Sprite());
Clear(BLANK);
float textScale=3;
vf2d textSize=GetTextSizeProp("Virus Attack")*textScale;
DrawShadowStringProp(titleScreenText.Sprite()->Size()/2-textSize/2,"Virus Attack",WHITE,BLACK,{textScale,textScale},textScale);
SetDrawTarget(nullptr);
titleScreenText.Decal()->Update();
textOrientationX=titleScreenText.Sprite()->width/2;
textOrientationY=titleScreenText.Sprite()->height-12;
}
void VirusAttack::InitializeLevelData(){
#pragma region Stage 1
{
//Stage 1 data.
LevelName stage=STAGE1;
levelData[stage].name=stage;
levelData[stage].cameraStart={96,96};
levelData[stage].worldZoom={1,1};
levelData[stage].levelColor=DARK_GREEN;
levelData[stage].size={24,24};
levelData[stage].bgm=Sound::GRAVITY;
levelData[stage].scenarioIndex=int(stage);
levelData[stage].availableMemory=240;
levelData[stage].player_starting_resources={5,5,5,5,5};
levelData[stage].enemy_starting_resources={0,0,0,0,0};
{
std::vector<UnitData>&units=levelData[stage].unitPlacement;
std::vector<CPData>&collectionPoints=levelData[stage].cpPlacement;
units.push_back({UnitType::LeftShifter,vf2d{128,128},true});
units.push_back({UnitType::LeftShifter,vf2d{128,128},true});
units.push_back({UnitType::RAMBank,vf2d{320,320},false});
}
}
#pragma endregion
#pragma region Stage 2
{
//Stage 2 data.
LevelName stage=STAGE2;
levelData[stage].name=stage;
levelData[stage].cameraStart={96,96};
levelData[stage].worldZoom={1,1};
levelData[stage].size={30,30};
levelData[stage].levelColor=DARK_GREEN;
levelData[stage].bgm=Sound::GRAVITY;
levelData[stage].scenarioIndex=int(stage);
levelData[stage].availableMemory=240;
levelData[stage].player_starting_resources={50,30,40,30,55};
levelData[stage].enemy_starting_resources={0,0,0,0,0};
{
std::vector<UnitData>&units=levelData[stage].unitPlacement;
std::vector<CPData>&collectionPoints=levelData[stage].cpPlacement;
units.push_back({UnitType::_Platform,vf2d{7*24,10*24},true});
units.push_back({UnitType::RightShifter,vf2d{20*24,21*24},false});
units.push_back({UnitType::LeftShifter,vf2d{20*24,22*24},false});
units.push_back({UnitType::MemoryAllocator,vf2d{22*24,24*24},false});
units.push_back({UnitType::RAMBank,vf2d{22*24,23*24},false});
}
}
#pragma endregion
#pragma region Stage 3
{
//Stage 3 data.
LevelName stage=STAGE3;
levelData[stage].name=stage;
levelData[stage].cameraStart={96,96};
levelData[stage].worldZoom={1,1};
levelData[stage].size={30,30};
levelData[stage].levelColor=DARK_GREEN;
levelData[stage].bgm=Sound::GRAVITY;
levelData[stage].scenarioIndex=int(stage);
levelData[stage].availableMemory=240;
levelData[stage].player_starting_resources={100,40,60,40,100};
levelData[stage].enemy_starting_resources={0,0,0,0,0};
{
std::vector<UnitData>&units=levelData[stage].unitPlacement;
std::vector<CPData>&collectionPoints=levelData[stage].cpPlacement;
units.push_back({UnitType::RAMBank,vf2d{3*24,6*24},true});
for(int i=0;i<4;i++){
units.push_back({UnitType::RightShifter,vf2d{3*24,8*24},true});
}
units.push_back({UnitType::LeftShifter,vf2d{3*24,7*24},true});
units.push_back({UnitType::RightShifter,vf2d{18*24,19*24},false});
units.push_back({UnitType::LeftShifter,vf2d{20*24,22*24},false});
units.push_back({UnitType::LeftShifter,vf2d{21*24,22*24},false});
for(int i=0;i<8;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{20*24,17*24},false});
}
units.push_back({UnitType::_Platform,vf2d{22*24,23*24},false});
}
}
#pragma endregion
#pragma region Stage 4
{
//Stage 4 data.
LevelName stage=STAGE4;
levelData[stage].name=stage;
levelData[stage].cameraStart={96,96};
levelData[stage].worldZoom={1,1};
levelData[stage].size={36,36};
levelData[stage].levelColor=DARK_GREEN;
levelData[stage].bgm=Sound::COSMOS;
levelData[stage].scenarioIndex=int(stage);
levelData[stage].availableMemory=300;
levelData[stage].player_starting_resources={3,0,0,0,0};
levelData[stage].enemy_starting_resources={3,0,0,0,0};
{
std::vector<UnitData>&units=levelData[stage].unitPlacement;
std::vector<CPData>&collectionPoints=levelData[stage].cpPlacement;
units.push_back({UnitType::RAMBank,vf2d{4*24,4*24},true});
for(int i=0;i<5;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{4*24,6*24},true});
}
collectionPoints.push_back(CPData{{8*24,1*24},0,MemoryType::HEALTH});
collectionPoints.push_back(CPData{{9*24,1*24},0,MemoryType::HEALTH});
collectionPoints.push_back(CPData{{12*24,1*24},0,MemoryType::PROCEDURE});
collectionPoints.push_back(CPData{{15*24,1*24},0,MemoryType::PROCEDURE});
collectionPoints.push_back(CPData{{1*24,12*24},-PI/2,MemoryType::RANGE});
collectionPoints.push_back(CPData{{1*24,13*24},-PI/2,MemoryType::ATKSPD});
collectionPoints.push_back(CPData{{1*24,17*24},-PI/2,MemoryType::MOVESPD});
collectionPoints.push_back(CPData{{1*24,20*24},-PI/2,MemoryType::RANGE});
}
}
#pragma endregion
#pragma region Stage 5
{
//Stage 5 data.
LevelName stage=STAGE5;
levelData[stage].name=stage;
levelData[stage].cameraStart={96,96};
levelData[stage].worldZoom={1,1};
levelData[stage].size={48,48};
levelData[stage].levelColor=DARK_GREY;
levelData[stage].bgm=Sound::BOSS1;
levelData[stage].scenarioIndex=int(stage);
levelData[stage].availableMemory=640;
levelData[stage].player_starting_resources={5,5,5,5,5};
levelData[stage].enemy_starting_resources={5,5,5,5,5};
{
std::vector<UnitData>&units=levelData[stage].unitPlacement;
std::vector<CPData>&collectionPoints=levelData[stage].cpPlacement;
units.push_back({UnitType::RAMBank,vf2d{4*24,4*24},true});
for(int i=0;i<5;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{4*24,6*24},true});
}
collectionPoints.push_back(CPData{{8*24,1*24},0,MemoryType::HEALTH});
collectionPoints.push_back(CPData{{10*24,1*24},0,MemoryType::HEALTH});
collectionPoints.push_back(CPData{{32*24,12*24},0,MemoryType::HEALTH});
collectionPoints.push_back(CPData{{20*24,32*24},0,MemoryType::HEALTH});
collectionPoints.push_back(CPData{{9*24,1*24},0,MemoryType::PROCEDURE});
collectionPoints.push_back(CPData{{1*24,7*24},-PI/2,MemoryType::PROCEDURE});
collectionPoints.push_back(CPData{{16*24,16*24},0,MemoryType::PROCEDURE});
collectionPoints.push_back(CPData{{36*24,1*24},-PI/2,MemoryType::PROCEDURE});
collectionPoints.push_back(CPData{{1*24,3*24},-PI/2,MemoryType::RANGE});
collectionPoints.push_back(CPData{{1*24,6*24},-PI/2,MemoryType::ATKSPD});
collectionPoints.push_back(CPData{{1*24,11*24},-PI/2,MemoryType::MOVESPD});
collectionPoints.push_back(CPData{{1*24,22*24},-PI/2,MemoryType::RANGE});
collectionPoints.push_back(CPData{{6*24,16*24},-PI/2,MemoryType::ATKSPD});
collectionPoints.push_back(CPData{{1*24,32*24},-PI/2,MemoryType::MOVESPD});
collectionPoints.push_back(CPData{{(48-1)*24,(48-4)*24},PI/2,MemoryType::RANGE});
collectionPoints.push_back(CPData{{(48-1)*24,(48-7)*24},PI/2,MemoryType::ATKSPD});
collectionPoints.push_back(CPData{{(48-1)*24,(48-12)*24},PI/2,MemoryType::MOVESPD});
collectionPoints.push_back(CPData{{(48-1)*24,(48-23)*24},PI/2,MemoryType::RANGE});
collectionPoints.push_back(CPData{{(48-6)*24,(48-17)*24},PI/2,MemoryType::ATKSPD});
collectionPoints.push_back(CPData{{(48-1)*24,(48-33)*24},PI/2,MemoryType::MOVESPD});
collectionPoints.push_back(CPData{{(48-8)*24,(48-2)*24},PI,MemoryType::HEALTH});
collectionPoints.push_back(CPData{{(48-10)*24,(48-2)*24},PI,MemoryType::HEALTH});
collectionPoints.push_back(CPData{{(48-32)*24,(48-13)*24},PI,MemoryType::HEALTH});
collectionPoints.push_back(CPData{{(48-20)*24,(48-33)*24},PI,MemoryType::HEALTH});
collectionPoints.push_back(CPData{{(48-9)*24,(48-2)*24},PI,MemoryType::PROCEDURE});
collectionPoints.push_back(CPData{{(48-1)*24,(48-8)*24},PI/2,MemoryType::PROCEDURE});
collectionPoints.push_back(CPData{{(48-16)*24,(48-17)*24},PI,MemoryType::PROCEDURE});
collectionPoints.push_back(CPData{{(48-36)*24,(48-2)*24},PI/2,MemoryType::PROCEDURE});
for(int i=0;i<5;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{44*24,44*24},false});
}
units.push_back({UnitType::Turret,vf2d{42*24,42*24},false});
units.push_back({UnitType::LeftShifter,vf2d{42*24,44*24},false});
units.push_back({UnitType::LeftShifter,vf2d{42*24,44*24},false});
units.push_back({UnitType::Corrupter,vf2d{42*24,44*24},false});
units.push_back({UnitType::RightShifter,vf2d{42*24,44*24},false});
units.push_back({UnitType::RightShifter,vf2d{45*24,41*24},false});
units.push_back({UnitType::RAMBank,vf2d{44*24,44*24},false});
}
}
#pragma endregion
#pragma region Stage 6
{
//Stage 6 data.
LevelName stage=STAGE6;
levelData[stage].name=stage;
levelData[stage].cameraStart={96,96};
levelData[stage].worldZoom={1,1};
levelData[stage].size={48,48};
levelData[stage].levelColor=DARK_GREY;
levelData[stage].bgm=Sound::BOSS1;
levelData[stage].scenarioIndex=int(stage);
levelData[stage].availableMemory=640;
levelData[stage].player_starting_resources={5,5,5,5,5};
levelData[stage].enemy_starting_resources={5,5,5,5,5};
{
std::vector<UnitData>&units=levelData[stage].unitPlacement;
std::vector<CPData>&collectionPoints=levelData[stage].cpPlacement;
units.push_back({UnitType::RAMBank,vf2d{4*24,4*24},true});
for(int i=0;i<5;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{4*24,6*24},true});
}
std::vector<vf2d>positions={
{{8,1},{10,1},{32,12},{20,32},{9,1},{1,7},{16,16}
,{36,1},{1,3},{1,6},{1,11},{1,22},{6,16},{1,32}}
};
std::vector<MemoryType>types={
{MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::PROCEDURE,
MemoryType::PROCEDURE,MemoryType::PROCEDURE,MemoryType::PROCEDURE,MemoryType::RANGE,
MemoryType::ATKSPD,MemoryType::MOVESPD,MemoryType::RANGE,MemoryType::ATKSPD,MemoryType::MOVESPD,}
};
if(positions.size()!=types.size()){
throw;
}
while(positions.size()>0){
int randomIndex=rand()%positions.size();
int randomIndex2=rand()%types.size();
float finalDir=0;
if(positions[randomIndex].x<levelData[stage].size.x/2){
if(positions[randomIndex].y<positions[randomIndex].x){
finalDir=0;
}else{
finalDir=-PI/2;
}
} else{
if(positions[randomIndex].y>positions[randomIndex].x){
finalDir=PI;
}else{
finalDir=PI/2;
}
}
collectionPoints.push_back(CPData{positions[randomIndex]*24,finalDir,types[randomIndex2]});
collectionPoints.push_back(CPData{(levelData[stage].size-positions[randomIndex]-vf2d{1,1})*24,float(finalDir+PI),types[randomIndex2]});
positions.erase(positions.begin()+randomIndex);
types.erase(types.begin()+randomIndex2);
}
for(int i=0;i<5;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{44*24,44*24},false});
}
units.push_back({UnitType::Refresher,vf2d{2*24,42*24},false});
units.push_back({UnitType::MemoryGuard,vf2d{7*24,44*24},false});
units.push_back({UnitType::LeftShifter,vf2d{2*24,44*24},false});
units.push_back({UnitType::LeftShifter,vf2d{2*24,44*24},false});
units.push_back({UnitType::Corrupter,vf2d{2*24,44*24},false});
units.push_back({UnitType::RightShifter,vf2d{2*24,44*24},false});
units.push_back({UnitType::RightShifter,vf2d{5*24,41*24},false});
units.push_back({UnitType::RAMBank,vf2d{4*24,44*24},false});
}
}
#pragma endregion
#pragma region Stage 7
{
//Stage 7 data.
LevelName stage=STAGE7;
levelData[stage].name=stage;
levelData[stage].cameraStart={96,96};
levelData[stage].worldZoom={1,1};
levelData[stage].size={64,64};
levelData[stage].levelColor=DARK_RED;
levelData[stage].bgm=Sound::BOSS2;
levelData[stage].scenarioIndex=int(stage);
levelData[stage].availableMemory=960;
levelData[stage].player_starting_resources={5,5,5,5,5};
levelData[stage].enemy_starting_resources={5,5,5,5,5};
{
std::vector<UnitData>&units=levelData[stage].unitPlacement;
std::vector<CPData>&collectionPoints=levelData[stage].cpPlacement;
units.push_back({UnitType::RAMBank,vf2d{4*24,4*24},true});
for(int i=0;i<5;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{4*24,6*24},true});
}
std::vector<vf2d>positions={
{{8,1},{10,1},{32,12},{20,32},{9,1},{1,7},{16,16}
,{36,1},{1,3},{1,6},{1,11},{1,22},{6,16},{1,32}
,{14,16},{27,29},{14,12},{7,36},{16,30},{22,19},{39,40}}
};
std::vector<MemoryType>types={
{MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::PROCEDURE,
MemoryType::PROCEDURE,MemoryType::PROCEDURE,MemoryType::PROCEDURE,MemoryType::RANGE,
MemoryType::ATKSPD,MemoryType::MOVESPD,MemoryType::RANGE,MemoryType::ATKSPD,MemoryType::MOVESPD,
MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::PROCEDURE,
MemoryType::PROCEDURE,MemoryType::ATKSPD,MemoryType::MOVESPD,MemoryType::RANGE,}
};
if(positions.size()!=types.size()){
throw;
}
while(positions.size()>0){
int randomIndex=rand()%positions.size();
int randomIndex2=rand()%types.size();
float finalDir=0;
if(positions[randomIndex].x<levelData[stage].size.x/2){
if(positions[randomIndex].y<positions[randomIndex].x){
finalDir=0;
}else{
finalDir=-PI/2;
}
} else{
if(positions[randomIndex].y>positions[randomIndex].x){
finalDir=PI;
}else{
finalDir=PI/2;
}
}
collectionPoints.push_back(CPData{positions[randomIndex]*24,finalDir,types[randomIndex2]});
collectionPoints.push_back(CPData{(levelData[stage].size-positions[randomIndex]-vf2d{1,1})*24,float(finalDir+PI),types[randomIndex2]});
positions.erase(positions.begin()+randomIndex);
types.erase(types.begin()+randomIndex2);
}
units.push_back({UnitType::Turret,vf2d{52*24,52*24},false});
units.push_back({UnitType::LeftShifter,vf2d{52*24,54*24},false});
units.push_back({UnitType::LeftShifter,vf2d{52*24,54*24},false});
units.push_back({UnitType::Corrupter,vf2d{52*24,54*24},false});
units.push_back({UnitType::RightShifter,vf2d{52*24,54*24},false});
units.push_back({UnitType::RightShifter,vf2d{55*24,51*24},false});
units.push_back({UnitType::RAMBank,vf2d{54*24,54*24},false});
units.push_back({UnitType::RAMBank,vf2d{54*24,54*24},false});
for(int i=0;i<5;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{54*24,54*24},false});
}
units.push_back({UnitType::Turret,vf2d{53*24,22*24},false});
units.push_back({UnitType::RAMBank,vf2d{54*24,24*24},false});
for(int i=0;i<2;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{54*24,25*24},false});
}
units.push_back({UnitType::RightShifter,vf2d{53*24,24*24},false});
units.push_back({UnitType::BitRestorer,vf2d{54*24,25*24},false});
units.push_back({UnitType::RightShifter,vf2d{54*24,26*24},false});
}
}
#pragma endregion
#pragma region Stage 8
{
//Stage 8 data.
LevelName stage=STAGE8;
levelData[stage].name=stage;
levelData[stage].cameraStart={96,96};
levelData[stage].worldZoom={1,1};
levelData[stage].size={64,64};
levelData[stage].levelColor=DARK_RED;
levelData[stage].bgm=Sound::BOSS2;
levelData[stage].scenarioIndex=int(stage);
levelData[stage].availableMemory=1280;
levelData[stage].player_starting_resources={5,5,5,5,5};
levelData[stage].enemy_starting_resources={5,5,5,5,5};
{
std::vector<UnitData>&units=levelData[stage].unitPlacement;
std::vector<CPData>&collectionPoints=levelData[stage].cpPlacement;
units.push_back({UnitType::RAMBank,vf2d{4*24,4*24},true});
for(int i=0;i<5;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{4*24,6*24},true});
}
std::vector<vf2d>positions={
{{8,1},{10,1},{32,12},{20,32},{9,1},{1,7},{16,16}
,{36,1},{1,3},{1,6},{1,11},{1,22},{6,16},{1,32}
,{14,16},{27,29},{14,12},{7,36},{16,30},{22,19},{39,40}}
};
std::vector<MemoryType>types={
{MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::PROCEDURE,
MemoryType::PROCEDURE,MemoryType::PROCEDURE,MemoryType::PROCEDURE,MemoryType::RANGE,
MemoryType::ATKSPD,MemoryType::MOVESPD,MemoryType::RANGE,MemoryType::ATKSPD,MemoryType::MOVESPD,
MemoryType::HEALTH,MemoryType::HEALTH,MemoryType::PROCEDURE,
MemoryType::PROCEDURE,MemoryType::ATKSPD,MemoryType::MOVESPD,MemoryType::RANGE,}
};
if(positions.size()!=types.size()){
throw;
}
while(positions.size()>0){
int randomIndex=rand()%positions.size();
int randomIndex2=rand()%types.size();
float finalDir=0;
if(positions[randomIndex].x<levelData[stage].size.x/2){
if(positions[randomIndex].y<positions[randomIndex].x){
finalDir=0;
}else{
finalDir=-PI/2;
}
} else{
if(positions[randomIndex].y>positions[randomIndex].x){
finalDir=PI;
}else{
finalDir=PI/2;
}
}
collectionPoints.push_back(CPData{positions[randomIndex]*24,finalDir,types[randomIndex2]});
collectionPoints.push_back(CPData{(levelData[stage].size-positions[randomIndex]-vf2d{1,1})*24,float(finalDir+PI),types[randomIndex2]});
positions.erase(positions.begin()+randomIndex);
types.erase(types.begin()+randomIndex2);
}
for(int i=0;i<2;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{53*24,53*24},false});
}
units.push_back({UnitType::Refresher,vf2d{56*24,56*24},false});
units.push_back({UnitType::RAMBank,vf2d{54*24,54*24},false});
for(int i=0;i<5;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{39*24,35*24},false});
}
units.push_back({UnitType::Refresher,vf2d{43*24,52*24},false});
units.push_back({UnitType::Turret,vf2d{44*24,52*24},false});
units.push_back({UnitType::MemoryGuard,vf2d{40*24,35*24},false});
units.push_back({UnitType::RAMBank,vf2d{40*24,36*24},false});
units.push_back({UnitType::Turret,vf2d{37*24,57*24},false});
units.push_back({UnitType::Turret,vf2d{42*24,57*24},false});
for(int i=0;i<2;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{10*24,53*24},false});
}
units.push_back({UnitType::RAMBank,vf2d{10*24,54*24},false});
units.push_back({UnitType::Turret,vf2d{11*24,52*24},false});
}
}
#pragma endregion
}
bool VirusAttack::OnUserCreate(){
srand(time(NULL));
currentBackCol=newCol=colorChangeOptions[rand()%colorChangeOptions.size()];
SetPixelMode(Pixel::MASK);
gametv.Initialise(GetScreenSize());
InitializeImages();
unitCreationBox.Initialize("Hello world, this is a test of the textbox system.\nMaybe even with some newline characters snuck in there.",
{});
unitCreationBox.SetVisible(false);
testBox.Initialize("Hello world, this is a test of the textbox system.\nMaybe even with some newline characters snuck in there.",{});
testBox.SetVisible(false);
memoryAllocatorBox.Initialize(CONSTANT::MEMORY_ALLOCATOR_BOX_DISPLAY_STRING,{},CONSTANT::MEMORY_ALLOCATOR_BOX_HEADER_STRING);
memoryAllocatorBox.SetVisible(false);
platformCreationBox.SetVisible(false);
restartBox.SetVisible(false);
completedBox.SetVisible(false);
creditsBox.SetVisible(false);
attackingLineModified.Create(IMAGES[ATTACKING_LINE]->Sprite()->width,IMAGES[ATTACKING_LINE]->Sprite()->height,false,false);
AL.AudioSystemInit();
InitializeSounds();
InitializeGUIs();
InitializeScenarios();
InitializeLevelData();
LoadLevel(STAGE1);
levelToLoad=STAGE1;
return true;
}
void VirusAttack::LoadLevel(LevelName level){
Level&selectedLevel=levelData[level];
currentLevel=&selectedLevel;
currentScenario=currentLevel->scenarioIndex;
WORLD_SIZE=selectedLevel.size;
gametv.SetWorldScale(selectedLevel.worldZoom);
gametv.SetWorldOffset(selectedLevel.cameraStart-vf2d(GetScreenSize())/2.f/gametv.GetWorldScale());
if(bgm==nullptr){
bgm=SOUNDS[int(selectedLevel.bgm)].get();
bgm_handle=bgm->PlayCentered(1,1,true);
} else
if(bgm!=SOUNDS[int(selectedLevel.bgm)].get()){
bgm->Stop();
bgm=SOUNDS[int(selectedLevel.bgm)].get();
bgm_handle=bgm->PlayCentered(1,1,true);
}
player_resources=selectedLevel.player_starting_resources;
enemy_resources=selectedLevel.enemy_starting_resources;
TileManager::visibleTiles.clear();
std::for_each(units.begin(),units.end(),[&](auto&u){
u->OnDeath(SOUNDS);
});
units.clear();
collectionPoints.clear();
for(auto&u:selectedLevel.unitPlacement){
#define TranslateUnit(type) \
case UnitType::type:{ \
units.push_back(std::make_shared<type>(this,u.pos,IMAGES,u.friendly)); \
}break;
switch(u.type){
TranslateUnit(LeftShifter)
TranslateUnit(RightShifter)
TranslateUnit(BitRestorer)
TranslateUnit(MemorySwapper)
TranslateUnit(Corrupter)
TranslateUnit(MemoryAllocator)
TranslateUnit(RAMBank)
TranslateUnit(_Platform)
TranslateUnit(MemoryGuard)
TranslateUnit(Refresher)
TranslateUnit(Turret)
default:{
std::cout<<"Could not load unit type "<<int(u.type)<<"!"<<std::endl;
throw;
}
}
}
for(auto&cp:selectedLevel.cpPlacement){
collectionPoints.push_back(std::make_shared<CollectionPoint>(this,cp.pos,cp.rot,*IMAGES[MEMORY_COLLECTION_POINT],cp.type));
}
randomBackgroundOffset={util::random(128),util::random(128)};
objective="";
SCENARIOS[currentScenario]->_Start();
}
void VirusAttack::InitializeGUIs(){
restartButton=new QuickGUI::TransparentImageButton(restartManager,*IMAGES[RESTART],*IMAGES[RESTART_HOVER],{1,1},{float(ScreenWidth()-32),12.f},{28,28});
unitCreationList.colNormal = olc::DARK_GREEN;
unitCreationList.colHover = olc::GREEN;
unitCreationList.colClick = olc::YELLOW;
unitCreationList.colDisable = olc::DARK_GREY;
unitCreationList.colBorder = olc::YELLOW;
unitCreationList.colText = olc::WHITE;
platformCreationList.CopyThemeFrom(unitCreationList);
leftShifterButton=new QuickGUI::ImageButton(unitCreationList,*IMAGES[LEFT_SHIFTER],{0.5,0.5},{16.f+32*0,float(ScreenHeight()-48)},{20,20});
rightShifterButton=new QuickGUI::ImageButton(unitCreationList,*IMAGES[RIGHT_SHIFTER],{0.5,0.5},{16.f+32*1,float(ScreenHeight()-48)},{20,20});
bitRestorerButton=new QuickGUI::ImageButton(unitCreationList,*IMAGES[BIT_RESTORER],{0.5,0.5},{16.f+32*2,float(ScreenHeight()-48)},{20,20});
memorySwapperButton=new QuickGUI::ImageButton(unitCreationList,*IMAGES[MEMORY_SWAPPER],{0.5,0.5},{16.f+32*3,float(ScreenHeight()-48)},{20,20});
corrupterButton=new QuickGUI::ImageButton(unitCreationList,*IMAGES[CORRUPTER],{0.5,0.5},{16.f+32*4,float(ScreenHeight()-48)},{20,20});
platformButton=new QuickGUI::ImageButton(unitCreationList,*IMAGES[PLATFORM],{0.25,0.25},{16.f+32*5,float(ScreenHeight()-48)},{20,20});
ramBankButton=new QuickGUI::ImageButton(platformCreationList,*IMAGES[RAM_BANK],{0.125,0.125},{float(ScreenWidth()-48),48.f+32*0},{20,20});
refresherButton=new QuickGUI::ImageButton(platformCreationList,*IMAGES[REFRESHER],{0.25,0.25},{float(ScreenWidth()-48),48.f+32*1},{20,20});
turretButton=new QuickGUI::ImageButton(platformCreationList,*IMAGES[TURRET],{0.25,0.25},{float(ScreenWidth()-48),48.f+32*2},{20,20});
memoryGuardButton=new QuickGUI::ImageButton(platformCreationList,*IMAGES[MEMORY_GUARD],{0.25,0.25},{float(ScreenWidth()-48),48.f+32*3},{20,20});
unitCreationList.DisplayAllControls(false);
platformCreationList.DisplayAllControls(false);
campaignStartButton=new QuickGUI::TransparentButton(mainMenu,"Start Campaign",{float(ScreenWidth()/2)-120.f,80+47.5f*1+10},{240,24},CONSTANT::INCREASE_VALUE_COLOR);
audioToggleButton=new QuickGUI::TransparentButton(mainMenu,"Audio: On",{float(ScreenWidth()/2)-120.f,80+47.5f*2+10},{240,24},CONSTANT::INCREASE_VALUE_COLOR);
difficultyToggleButton=new QuickGUI::TransparentButton(mainMenu,"Difficulty: Normal",{float(ScreenWidth()/2)-120.f,80+47.5f*3+10},{240,24},CONSTANT::INCREASE_VALUE_COLOR);
//creditsButton=new QuickGUI::TransparentButton(mainMenu,"Credits",{float(ScreenWidth()/2)-120.f,80+47.5f*3+10},{240,24},CONSTANT::INCREASE_VALUE_COLOR);
exitGameButton=new QuickGUI::TransparentButton(mainMenu,"Exit Game",{float(ScreenWidth()/2)-120.f,80+47.5f*4+10},{240,24},CONSTANT::INCREASE_VALUE_COLOR);
}
void VirusAttack::InitializeScenarios(){
SCENARIOS.emplace_back(std::make_unique<Stage1>(units,IMAGES,SOUNDS,objective,gametv,flags));
SCENARIOS.emplace_back(std::make_unique<Stage2>(units,IMAGES,SOUNDS,objective,gametv,flags));
SCENARIOS.emplace_back(std::make_unique<Stage3>(units,IMAGES,SOUNDS,objective,gametv,flags));
SCENARIOS.emplace_back(std::make_unique<Stage4>(units,IMAGES,SOUNDS,objective,gametv,flags));
SCENARIOS.emplace_back(std::make_unique<Stage5>(units,IMAGES,SOUNDS,objective,gametv,flags));
SCENARIOS.emplace_back(std::make_unique<Stage6>(units,IMAGES,SOUNDS,objective,gametv,flags));
SCENARIOS.emplace_back(std::make_unique<Stage7>(units,IMAGES,SOUNDS,objective,gametv,flags));
SCENARIOS.emplace_back(std::make_unique<Stage8>(units,IMAGES,SOUNDS,objective,gametv,flags));
}
void VirusAttack::InitializeSounds(){
int soundIndex=0;
auto LoadSound=[&](Sound::Sound sound,std::string soundFilename){
SOUNDS.emplace_back(std::make_unique<Audio>());
SOUNDS[int(sound)]->AL=&AL;
SOUNDS[int(sound)]->LoadAudioSample(soundIndex,std::string("./assets/"+soundFilename).c_str());
soundIndex++;
};
LoadSound(Sound::HUM,"machine2.wav");
LoadSound(Sound::GRAVITY,"gravity.mp3");
LoadSound(Sound::COSMOS,"cosmos.mp3");
LoadSound(Sound::BOSS1,"boss1.mp3");
LoadSound(Sound::BOSS2,"boss2.mp3");
LoadSound(Sound::VOICEOVER,"voice.mp3");
LoadSound(Sound::PING,"ping.mp3");
LoadSound(Sound::ALARM,"alarm.mp3");
LoadSound(Sound::SWITCH,"switch.mp3");
LoadSound(Sound::HIT1,"hit1.mp3");
LoadSound(Sound::HIT2,"hit2.mp3");
LoadSound(Sound::HIT3,"hit3.mp3");
LoadSound(Sound::BUTTONSELECT,"buttonselect.mp3");
LoadSound(Sound::SMALLBUILD,"smallbuild.mp3");
LoadSound(Sound::BIGBUILD,"bigbuild.mp3");
LoadSound(Sound::HEAL,"heal.mp3");
LoadSound(Sound::REFRESHER,"refresher.mp3");
LoadSound(Sound::TURRET,"turret.mp3");
LoadSound(Sound::MEMORY_GUARD,"memoryguard.mp3");
LoadSound(Sound::SPAWN,"spawn.mp3");
LoadSound(Sound::DEAD1,"dead1.mp3");
LoadSound(Sound::DEAD2,"dead2.mp3");
LoadSound(Sound::DEAD3,"dead3.mp3");
LoadSound(Sound::WIND,"wind.mp3");
}
bool VirusAttack::UnitCreationClickHandled(){
#define CheckClick(UnitClass,Button,Validator) \
if(Button->bPressed){ \
for(auto&u:units){ \
if(u->IsSelected()&&u->Validator()&&CanAfford(player_resources,UnitClass::resourceCost)) { \
std::shared_ptr<UnitClass>buildUnit=std::make_shared<UnitClass>(this,u->GetPos(),IMAGES,u->IsFriendly()); \
u->SetBuildUnit(CONSTANT::UNIT_BUILD_TIME,std::move(buildUnit),SOUNDS); \
ExpendResources(player_resources,UnitClass::resourceCost); \
CalculateUsedMemory(); \
} \
} \
SOUNDS[Sound::BUTTONSELECT]->PlayCentered(); \
return true; \
}
CheckClick(LeftShifter,leftShifterButton,IsAllocator)
CheckClick(RightShifter,rightShifterButton,IsAllocator)
CheckClick(BitRestorer,bitRestorerButton,IsAllocator)
CheckClick(MemorySwapper,memorySwapperButton,IsAllocator)
CheckClick(BitRestorer,bitRestorerButton,IsAllocator)
CheckClick(Corrupter,corrupterButton,IsAllocator)
CheckClick(_Platform,platformButton,IsAllocator)
CheckClick(RAMBank,ramBankButton,IsPlatform)
CheckClick(Refresher,refresherButton,IsPlatform)
CheckClick(Turret,turretButton,IsPlatform)
CheckClick(MemoryGuard,memoryGuardButton,IsPlatform)
return false;
}
#define EnableAndHoverCheck(UnitClass,Button,box,allowed) \
Button->Enable(CanAfford(player_resources,UnitClass::resourceCost)&&allowed); \
if(!allowed){Button->bVisible=false;} \
if(Button->bHover){ \
box.Initialize(UnitClass::unitDescription, GetMousePos(), UnitClass::unitName,nullptr,{120,36},nullptr,UnitClass::resourceCost); \
hovering=true; \
if(CanAfford(player_resources,UnitClass::resourceCost)){ \
box.SetBackgroundColor(CONSTANT::MESSAGE_BOX_DEFAULT_BACKCOL); \
} else { \
box.SetBackgroundColor(VERY_DARK_GREY/2); \
} \
}
void VirusAttack::UpdateUnitCreationListGUI(bool allocatorSelected){
unitCreationList.DisplayAllControls(allocatorSelected);
bool hovering=false;
EnableAndHoverCheck(LeftShifter,leftShifterButton,unitCreationBox,true)
EnableAndHoverCheck(RightShifter,rightShifterButton,unitCreationBox,true)
EnableAndHoverCheck(BitRestorer,bitRestorerButton,unitCreationBox,!flags.limitedBuildOptions)
EnableAndHoverCheck(MemorySwapper,memorySwapperButton,unitCreationBox,!flags.limitedBuildOptions)
EnableAndHoverCheck(BitRestorer,bitRestorerButton,unitCreationBox,!flags.limitedBuildOptions)
EnableAndHoverCheck(Corrupter,corrupterButton,unitCreationBox,!flags.limitedBuildOptions)
EnableAndHoverCheck(_Platform,platformButton,unitCreationBox,!flags.limitedBuildOptions)
if(!hovering){
unitCreationBox.SetVisible(false);
}
unitCreationList.Update(this);
}
void VirusAttack::UpdatePlatformCreationListGUI(bool platformSelected){
platformCreationList.DisplayAllControls(platformSelected);
bool hovering=false;
EnableAndHoverCheck(RAMBank,ramBankButton,platformCreationBox,true)
EnableAndHoverCheck(Refresher,refresherButton,platformCreationBox,!flags.limitedBuildOptions)
EnableAndHoverCheck(Turret,turretButton,platformCreationBox,!flags.limitedBuildOptions)
EnableAndHoverCheck(MemoryGuard,memoryGuardButton,platformCreationBox,!flags.limitedBuildOptions)
if(!hovering){
platformCreationBox.SetVisible(false);
}
platformCreationList.Update(this);
}
void VirusAttack::HandleDraggingSelection(){
auto NotClickingOnMinimap=[&](){return !(GetMouseX()>=ScreenWidth()-64&&GetMouseY()>=ScreenHeight()-64);};
if(GetMouse(0).bPressed){
if(NotClickingOnMinimap()){
for(auto&u:units){
if(u->ClickHandled(gametv,player_resources,units,IMAGES)){
goto skipLeftClick; //Break out early because this instance reported it handled a click for us.
}
}
if(UnitCreationClickHandled()){
goto skipLeftClick;
}
for(auto&u:units){
u->Deselect();
}
if(startingDragPos==CONSTANT::UNSELECTED){
startingDragPos=GetWorldMousePos();
}
}
}
skipLeftClick:
if(GetMouse(0).bReleased&&startingDragPos!=CONSTANT::UNSELECTED){
vf2d endDragPos=GetWorldMousePos();
if(endDragPos.x<startingDragPos.x){std::swap(startingDragPos.x,endDragPos.x);}
if(endDragPos.y<startingDragPos.y){std::swap(startingDragPos.y,endDragPos.y);}
geom2d::rect<float> selectionRegion(startingDragPos,endDragPos-startingDragPos);
for(auto&u:units){
if(u->IsFriendly()){
if(geom2d::overlaps(selectionRegion,geom2d::circle<float>(u->GetPos(),u->GetUnitSize().x/2))){
u->Select();
}
}
}
startingDragPos=CONSTANT::UNSELECTED;
}
}
vf2d VirusAttack::GetWorldMousePos(){
return gametv.ScreenToWorld(GetMousePos());
}
void VirusAttack::DrawSelectionRectangle(){
if(startingDragPos!=CONSTANT::UNSELECTED){
gametv.FillRectDecal(startingDragPos,GetWorldMousePos()-startingDragPos,{255,255,0,128});
}
}
void VirusAttack::HandleRightClickMove(){
if (GetMouse(1).bHeld){
bool selectedTarget=false;
if(GetMouseX()>=ScreenWidth()-64&&GetMouseY()>=ScreenHeight()-64){//Clicked on Minimap.
for(auto&u:units){
if(u->IsFriendly()&&u->IsSelected()&&u->CanMove()){
vf2d minimapTL=GetScreenSize()-vf2d{64,64};
vf2d minimapCenterClick=vf2d(GetMousePos()-minimapTL)/64*WORLD_SIZE*CONSTANT::TILE_SIZE-vf2d(GetScreenSize())/gametv.GetWorldScale()/2.f+vf2d(GetScreenSize()/2.f)/gametv.GetWorldScale();
u->SetTargetLocation(minimapCenterClick);
}
}
goto targetFound;
}
for(auto&u:units){
if(geom2d::overlaps(geom2d::circle<float>(u->GetPos(),u->GetUnitSize().x/2),GetWorldMousePos())){
for(auto&u2:units){
if(&u!=&u2){
if(!u->IsFriendly()&&u2->IsFriendly()&&u2->IsSelected()&&u2->CanInteractWithEnemies()){
u2->SetTargetUnit(u);
} else
if(u->IsFriendly()&&u2->IsFriendly()&&u2->IsSelected()&&u2->CanInteractWithAllies()){
u2->SetTargetUnit(u);
}
}
}
selectedTarget=true;
break;
}
}
if(!selectedTarget){
for(auto&u:units){
if(u->IsFriendly()&&u->IsSelected()&&u->CanMove()){
//First see if we can attach to a collection point.
for(auto&cp:collectionPoints){
geom2d::rect<float>cpRect=geom2d::rect<float>({cp->pos-cp->img.Sprite()->Size()/2,cp->img.Sprite()->Size()});
if(geom2d::overlaps(cpRect,GetWorldMousePos())){
if(cp->attachedUnit.expired()){
u->SetTargetCollectionPoint(cp,u);
goto targetFound; //We found a target, so now we can just leave.
}
}
}
//Okay, nothing to do here. Simply move to the selected position.
u->SetTargetLocation(GetWorldMousePos());
}
}
}
targetFound:
int a;
}
}
void VirusAttack::CollisionChecking(std::shared_ptr<Unit>u,std::shared_ptr<Unit>u2){
if(u->GetPos().x<0){
u->SetPos({0,u->GetPos().y});
}
if(u->GetPos().x>WORLD_SIZE.x*CONSTANT::TILE_SIZE.x){
u->SetPos({float(WORLD_SIZE.x*CONSTANT::TILE_SIZE.x),u->GetPos().y});
}
if(u->GetPos().y<0){
u->SetPos({u->GetPos().x,0});
}
if(u->GetPos().y>WORLD_SIZE.y*CONSTANT::TILE_SIZE.y){
u->SetPos({u->GetPos().x,float(WORLD_SIZE.y*CONSTANT::TILE_SIZE.y)});
}
bool bothAreEnemies=!u->IsFriendly()&&!u2->IsFriendly();
float u1Radius=u->GetUnitSize().x/2;
float u2Radius=u2->GetUnitSize().x/2;
if(bothAreEnemies){
if(u->IsPlatformStructure()^u2->IsPlatformStructure()){
u1Radius=u->IsPlatformStructure()?u->GetUnitSize().x/4:u1Radius;
u2Radius=u2->IsPlatformStructure()?u2->GetUnitSize().x/4:u2Radius;
}
}
if(u!=u2&&geom2d::overlaps(geom2d::circle<float>(u->GetPos(),u1Radius),geom2d::circle<float>(u2->GetPos(),u2Radius))){
geom2d::line<float>collisionLine(u->GetPos(),u2->GetPos()+vf2d{0.001,0.001});
float maxDist=u1Radius+u1Radius;
float dist=maxDist-collisionLine.length();
vf2d dir=collisionLine.vector().norm();
if(u->IsMoveable()||(!u->IsMoveable()&&!u2->IsMoveable())){
u->SetPos(u->GetPos()-dir*dist/2);
}
if(u2->IsMoveable()||(!u->IsMoveable()&&!u2->IsMoveable())){
u2->SetPos(u2->GetPos()+dir*(dist)/2);
}
}
}
void VirusAttack::IdentifyClosestTarget(std::weak_ptr<Unit>&closestUnit,float&closestDist,std::shared_ptr<Unit>u,std::shared_ptr<Unit>u2){
if(u==u2)return;
bool canInteract;
canInteract=
(u->IsFriendly()&&u->CanInteractWithEnemies()&&!u2->IsFriendly())||
(u->IsFriendly()&&u->CanInteractWithAllies()&&u2->IsFriendly()&&u->AutoAcquiresFriendlyTargets())||
(!u->IsFriendly()&&u->CanInteractWithEnemies()&&u2->IsFriendly())||
(!u->IsFriendly()&&u->CanInteractWithAllies()&&!u2->IsFriendly()&&u->AutoAcquiresFriendlyTargets());
if(canInteract){
geom2d::line<float>unitLine(u->GetPos(),u2->GetPos());
if(unitLine.length()<closestDist){
closestUnit=u2;
closestDist=unitLine.length();
}
}
}
void VirusAttack::DrawMinimap(){
DrawDecal(GetScreenSize()-IMAGES[MINIMAP_HUD]->Sprite()->Size(),IMAGES[MINIMAP_HUD]->Decal(),{1,1});
vf2d minimapTL=GetScreenSize()-vf2d{64,64};
vi2d worldPixelSize=WORLD_SIZE*CONSTANT::TILE_SIZE;
vf2d viewingTilesPct=vf2d{float(ScreenWidth()),float(ScreenHeight())}/CONSTANT::TILE_SIZE/WORLD_SIZE;
SetDrawTarget(IMAGES[MINIMAP_OUTLINE]->Sprite());
Clear(BLANK);
DrawRect((gametv.GetWorldOffset()/worldPixelSize*64),viewingTilesPct*64/gametv.GetWorldScale());
for(auto&cp:collectionPoints){
Pixel col;
switch(cp->type){
case HEALTH:{
col=CONSTANT::HEALTH_COLOR;
}break;
case ATKSPD:{
col=CONSTANT::ATKSPD_COLOR;
}break;
case MOVESPD:{
col=CONSTANT::MOVESPD_COLOR;
}break;
case RANGE:{
col=CONSTANT::RANGE_COLOR;
}break;
case PROCEDURE:{
col=CONSTANT::PROCEDURE_COLOR;
}break;
}
FillCircle(cp->pos/worldPixelSize*64-vf2d{1,0},1,col);
DrawCircle(cp->pos/worldPixelSize*64-vf2d{1,0},1,BLACK);
}
for(auto&u:units){
vf2d squareSize=u->GetUnitSize()/vf2d(WORLD_SIZE);
squareSize.x=std::round(std::max(1.f,squareSize.x));
squareSize.y=std::round(std::max(1.f,squareSize.y));
float colorMult=1;
if(u->IsAttached()){colorMult=0.5;}
FillRect(u->GetGhostPos()/worldPixelSize*64-squareSize,squareSize*2,(u->IsFriendly()?GREEN:RED)*colorMult);
}
IMAGES[MINIMAP_OUTLINE]->Decal()->Update();
SetDrawTarget(nullptr);
DrawDecal(minimapTL,IMAGES[MINIMAP_OUTLINE]->Decal());
}
void VirusAttack::HandlePanAndZoom(float fElapsedTime){
float speedScale=std::min(1.f,gametv.GetWorldScale().x);
bool canMouseScroll=!memoryAllocatorBox.IsVisible()&&!unitCreationBox.IsVisible()&&
(GetMouseY()<=ScreenHeight()-64||GetMouseX()<=ScreenWidth()-64
||GetMouseScreenX()>=GetWindowPos().x+GetWindowSize().x||GetMouseScreenY()>=GetWindowPos().y+GetWindowSize().y)&&!restartBox.IsVisible();
if(GetKey(A).bHeld||canMouseScroll&&GetMouseScreenX()<=GetWindowPos().x+CONSTANT::SCROLL_BOUNDARY){
vf2d amt=vf2d{-300*fElapsedTime,0}/speedScale;
gametv.MoveWorldOffset(amt);
}
if(GetKey(W).bHeld||canMouseScroll&&GetMouseScreenY()<=GetWindowPos().y+CONSTANT::SCROLL_BOUNDARY+24){
gametv.MoveWorldOffset(vf2d{0,-300*fElapsedTime}/speedScale);
}
if(GetKey(S).bHeld||canMouseScroll&&GetMouseScreenY()>=GetWindowPos().y+GetWindowSize().y-CONSTANT::SCROLL_BOUNDARY){
gametv.MoveWorldOffset(vf2d{0,300*fElapsedTime}/speedScale);
}
if(GetKey(D).bHeld||canMouseScroll&&GetMouseScreenX()>=GetWindowPos().x+GetWindowSize().x-CONSTANT::SCROLL_BOUNDARY){
vf2d amt=vf2d{300*fElapsedTime,0}/speedScale;
gametv.MoveWorldOffset(amt);
}
if(GetMouseWheel()>0){
if(gametv.GetWorldScale().x<2){
gametv.ZoomAtScreenPos(1.25,GetMousePos());
}
} else
if(GetMouseWheel()<0){
if(gametv.GetWorldScale().x>0.5){
gametv.ZoomAtScreenPos(0.75,GetMousePos());
}
}
}
void VirusAttack::HandleMinimapClick(){
if(startingDragPos==CONSTANT::UNSELECTED&&GetMouse(0).bHeld&&GetMouseX()>=ScreenWidth()-64&&GetMouseY()>=ScreenHeight()-64){
vf2d minimapTL=GetScreenSize()-vf2d{64,64};
gametv.SetWorldOffset(vf2d(GetMousePos()-minimapTL)/64*WORLD_SIZE*CONSTANT::TILE_SIZE-vf2d(GetScreenSize())/gametv.GetWorldScale()/2.f);
}
vf2d offset=gametv.GetWorldOffset();
offset.x=std::clamp(float(offset.x),-ScreenWidth()/2/gametv.GetWorldScale().x,WORLD_SIZE.x*24-(ScreenWidth()/2/gametv.GetWorldScale().x));
offset.y=std::clamp(float(offset.y),-ScreenHeight()/2/gametv.GetWorldScale().y,WORLD_SIZE.y*24-(ScreenHeight()/2/gametv.GetWorldScale().y));
gametv.SetWorldOffset(offset);
}
void VirusAttack::UpdateMatrixTexture(float fElapsedTime){
if(matrixTimer==0){
activeLetters.emplace_back(vf2d{float(rand()%64),float(64)},util::random(-40)-20,matrixLetters[rand()%matrixLetters.size()]);
matrixTimer=util::random(0.125);
}
if(updatePixelsTimer==0){
SetDrawTarget(IMAGES[MATRIX]->Sprite());
Sprite*img=IMAGES[MATRIX]->Sprite();
for(int y=63;y>=0;y--){
for(int x=63;x>=0;x--){
Pixel col=img->GetPixel(x,y);
if(col.r>0){
if(x>0){
Pixel leftCol=img->GetPixel(x-1,y);
if(leftCol.r<col.r){
leftCol=PixelLerp(col,leftCol,0.125);
}
Draw(x-1,y,leftCol);
}
if(x<img->width-1){
Pixel rightCol=img->GetPixel(x+1,y);
if(rightCol.r<col.r){
rightCol=PixelLerp(col,rightCol,0.125);
}
Draw(x+1,y,rightCol);
}
col/=8;
Draw(x,y,col);
}
}
}
for(int y=0;y<64;y++){
Draw({0,y},img->GetPixel(1,y));
}
SetDrawTarget(nullptr);
updatePixelsTimer=0.1;
}
if(activeLetters.size()>0){
SetDrawTarget(IMAGES[MATRIX]->Sprite());
for(Letter&letter:activeLetters){
letter.pos.y+=letter.spd*fElapsedTime;
DrawString(letter.pos,std::string(1,letter.c));
}
SetDrawTarget(nullptr);
IMAGES[MATRIX]->Decal()->Update();
}
matrixTimer=std::max(0.f,matrixTimer-fElapsedTime);
updatePixelsTimer=std::max(0.f,updatePixelsTimer-fElapsedTime);
std::erase_if(activeLetters,[](Letter&letter){return letter.pos.y<-32;});
}
void VirusAttack::RenderCollectionPoints(CollectionPoint*cp){
geom2d::rect<float>cpRect=geom2d::rect<float>({cp->pos-cp->img.Sprite()->Size()/2,cp->img.Sprite()->Size()});
geom2d::rect<float>viewRegion=geom2d::rect<float>({gametv.GetWorldTL(),gametv.GetWorldVisibleArea()});
if(geom2d::overlaps(cpRect,viewRegion)){
Pixel col;
switch(cp->type){
case HEALTH:{
col=CONSTANT::HEALTH_COLOR;
}break;
case RANGE:{
col=CONSTANT::RANGE_COLOR;
}break;
case ATKSPD:{
col=CONSTANT::ATKSPD_COLOR;
}break;
case MOVESPD:{
col=CONSTANT::MOVESPD_COLOR;
}break;
case PROCEDURE:{
col=CONSTANT::PROCEDURE_COLOR;
}break;
}
gametv.DrawRotatedDecal(cp->pos,cp->img.Decal(),cp->rot,cp->img.Sprite()->Size()/2,{1,1},col);
if(geom2d::overlaps(cpRect,GetWorldMousePos())){
gametv.DrawRotatedDecal(cp->pos,IMAGES[MEMORY_COLLECTION_POINT_HIGHLIGHT]->Decal(),cp->rot,cp->img.Sprite()->Size()/2,{1,1},col);
}
}
}
bool VirusAttack::OnUserUpdate(float fElapsedTime){
UpdateMatrixTexture(fElapsedTime);
gameplayTime+=fElapsedTime;
if(state!=GameState::COMPLETED){
if(gameplayTime>=1){
gameplayTime--;
gameSeconds++;
}
}
switch(state){
#pragma region MAIN_MENU
case GameState::MAIN_MENU:{
mainMenu.Update(this);
if(campaignStartButton->bPressed){
SOUNDS[Sound::BUTTONSELECT]->PlayCentered();
state=GameState::GAMEPLAY;
RestartLevel();
gameplayTime=0;
gameSeconds=0;
}
if(audioToggleButton->bPressed){
audioMode=(audioMode+1)%3;
switch(audioMode){
case 0:{
AL.bMusicOn=AL.bSoundOn=true;
bgm_handle=bgm->PlayCentered();
audioToggleButton->sText="Audio: On";
}break;
case 1:{
AL.bSoundOn=true;
AL.bMusicOn=false;
bgm->Stop(bgm_handle);
audioToggleButton->sText="Audio: SE Only";
}break;
case 2:{
AL.bMusicOn=AL.bSoundOn=false;
audioToggleButton->sText="Audio: Off";
}break;
}
}
if(difficultyToggleButton->bPressed){
flags.difficulty=(flags.difficulty+1)%3;
switch(flags.difficulty){
case 0:{
difficultyToggleButton->sText="Difficulty: Easy";
}break;
case 1:{
difficultyToggleButton->sText="Difficulty: Normal";
}break;
case 2:{
difficultyToggleButton->sText="Difficulty: Hard";
}break;
}
}
if(exitGameButton->bPressed){
SOUNDS[Sound::BUTTONSELECT]->PlayCentered();
return false;
}
titleScreenY=std::min(0.f,titleScreenY+fElapsedTime*120);
nextColorChange=std::max(0.f,nextColorChange-fElapsedTime);
transition=std::min(1.f,transition+fElapsedTime);
if(nextColorChange==0){
currentBackCol=newCol;
newCol=colorChangeOptions[rand()%colorChangeOptions.size()];
randomBackgroundOffset={util::random(128),util::random(128)};
nextColorChange=10;
transition=0;
}
if(titleScreenY==0){
textOrientationX=std::max(0.f,textOrientationX-fElapsedTime*50);
textOrientationY=std::max(0.f,textOrientationY-fElapsedTime*25);
}
DrawPartialDecal({0,0},GetScreenSize(),IMAGES[MATRIX]->Decal(),randomBackgroundOffset+gametv.GetWorldOffset()*(vf2d{32,32}/vf2d(GetScreenSize()))*gametv.GetWorldScale(),{32,32},PixelLerp(Pixel{currentBackCol.r,currentBackCol.g,currentBackCol.b,255},Pixel{newCol.r,newCol.g,newCol.b,255},transition));
vf2d setPieceOffset={48,titleScreenY};
{
vf2d offset=vf2d{0,0}+setPieceOffset;
DrawWarpedDecal(IMAGES[RAM_BANK]->Decal(),{vf2d{24,24}+offset,vf2d{24,104}+offset,vf2d{72,88}+offset,vf2d{72,40}+offset},Pixel{192,192,255});
}
{
vf2d offset=vf2d{100,-52}+setPieceOffset;
DrawWarpedDecal(IMAGES[MEMORY_GUARD]->Decal(),{vf2d{20,48}+offset,vf2d{20,108}+offset,vf2d{96,104}+offset,vf2d{96,52}+offset},Pixel{192,192,255});
}
{
vf2d offset=vf2d{76,-20}+setPieceOffset;
DrawWarpedDecal(IMAGES[BIT_RESTORER]->Decal(),{vf2d{12,52}+offset,vf2d{12,104}+offset,vf2d{64,92}+offset,vf2d{64,64}+offset},Pixel{192,192,255});
}
DrawCurvedTexture(vf2d{170-48,70}+setPieceOffset,{-30,-20},attackingLineModified.Decal(),{arrowScroll/2,0},CONSTANT::HEALER_ATTACK_COL,1.5);
{
vf2d offset=vf2d{48,0}+setPieceOffset;
DrawWarpedDecal(IMAGES[LEFT_SHIFTER]->Decal(),{vf2d{20,48}+offset,vf2d{20,108}+offset,vf2d{68,96}+offset,vf2d{68,60}+offset},Pixel{192,192,255});
}
if(flickerAmt>0.6){
flickerAmt-=util::random(0.4);
} else {
flickerAmt=1;
}
DrawDecal(vf2d{12,-28}+setPieceOffset,IMAGES[SHIELD_BUBBLE]->Decal(),{2.4,2.8},{255,255,255,uint8_t(flickerAmt*255)});
{
vf2d offset=vf2d{250,-18}+setPieceOffset;
DrawWarpedDecal(IMAGES[RAM_BANK]->Decal(),{vf2d{8,38}+offset,vf2d{8,90}+offset,vf2d{68,102}+offset,vf2d{68,26}+offset},Pixel{255,192,192});
}
{
vf2d offset=vf2d{220,0}+setPieceOffset;
DrawWarpedDecal(IMAGES[MEMORY_SWAPPER]->Decal(),{vf2d{20,60}+offset,vf2d{20,96}+offset,vf2d{68,108}+offset,vf2d{68,48}+offset},Pixel{255,192,192});
}
arrowScroll-=fElapsedTime*2;
SetDrawTarget(attackingLineModified.Sprite());
Clear(BLANK);
for(int y=0;y<IMAGES[ATTACKING_LINE]->Sprite()->height;y++){
for(int x=0;x<IMAGES[ATTACKING_LINE]->Sprite()->width;x++){
Pixel col=IMAGES[ATTACKING_LINE]->Sprite()->GetPixel(x,y);
if(col.a>0){
if(col==WHITE){
Draw(x,y,IMAGES[MATRIX]->Sprite()->GetPixel(x,y));
}else{
Draw(x,y,IMAGES[ATTACKING_LINE]->Sprite()->GetPixel(x,y));
}
}
}
}
SetDrawTarget(nullptr);
attackingLineModified.Decal()->Update();
//DrawPartialWarpedDecal()
DrawCurvedTexture(vf2d{150-48,80}+setPieceOffset,{160,-30},attackingLineModified.Decal(),{arrowScroll,0},CONSTANT::ATTACKER_ATTACK_COL,0.8);
{
vf2d offset={0,20};
DrawWarpedDecal(titleScreenText.Decal(),{vf2d{float(textOrientationX),float(textOrientationY)}+offset,vf2d{0,float(titleScreenText.Sprite()->height)}+offset,vf2d{float(titleScreenText.Sprite()->width),float(titleScreenText.Sprite()->height)}+offset,vf2d{float(titleScreenText.Sprite()->width-textOrientationX),float(textOrientationY)}+offset});
}
mainMenu.DrawDecal(this);
}break;
#pragma endregion
#pragma region GAMEPLAY
case GameState::GAMEPLAY:{
HandleGUIDisplay();
if(flags.playerInControl){
HandleDraggingSelection();
HandleRightClickMove();
HandlePanAndZoom(fElapsedTime);
HandleMinimapClick();
}
flashTimer+=fElapsedTime*2;
if(flashTimer>1){
flashTimer--;
}
SCENARIOS[currentScenario]->_Update(enemy_resources,collectionPoints,currentLevel->availableMemory-GetTotalUsedMemory(),queuedUnits,SOUNDS);
if(SCENARIOS[currentScenario]->transitionToNextLevel){
if(SCENARIOS[currentScenario]->nextLevel!=FINISH){
levelToLoad=SCENARIOS[currentScenario]->nextLevel;
}else{
state=GameState::COMPLETED;
}
}
restartManager.Update(this);
HandleRestartButton(fElapsedTime);
PerformLevelTransition(fElapsedTime);
AL.vecPos=gametv.ScreenToWorld(GetScreenSize()/2);
AL.fSoundFXVolume=std::min(1.f,gametv.GetWorldScale().x);
AL.OnUserUpdate(fElapsedTime);
for(auto&tile:TileManager::visibleTiles){
tile.second-=fElapsedTime;
}
std::erase_if(TileManager::visibleTiles,[](std::pair<vf2d,float> key){return key.second<=0;});
CalculateUsedMemory();
for(auto&u:units){
if(isnan(u->GetPos().x)||isnan(u->GetPos().y)){
for(int i=0;i<u->memory.size();i++){
u->memory[i]=false;
}
continue;//Unit does because it's out of bounds.
};
u->SaveMemory();
std::weak_ptr<Unit>closestUnit;
float closestDist=999999;
for(auto&u2:units){
IdentifyClosestTarget(closestUnit,closestDist,u,u2);
CollisionChecking(u,u2);
}
if(u->IsFriendly()){
for(int y=-2;y<3;y++){
for(int x=-2;x<3;x++){
if(abs(x)+abs(y)<=2){
TileManager::visibleTiles[u->GetPos()/24/4+vi2d(x,y)]=5;
}
}
}
}
u->AttemptAttack(u,closestUnit,units,debuffIcons,IMAGES,SOUNDS);
u->_Update(this,SOUNDS,player_resources,enemy_resources,queuedUnits,resourceGainTimer,resourceGainIcons,IMAGES,flags);
}
std::erase_if(units,[&](std::shared_ptr<Unit>u){
if(u->GetHealth()==0){
u->_OnDeath(SOUNDS);
deathAnimations.emplace_back(std::make_unique<DeathAnimation>(this,u->GetPos(),u->GetImage(),*IMAGES[MATRIX],u->IsFriendly()));
return true;
} else {
return false;
}
});
for(auto&queuedUnit:queuedUnits){
units.push_back(std::move(queuedUnit));
}
queuedUnits.clear();
DrawPartialDecal({0,0},GetScreenSize(),IMAGES[MATRIX]->Decal(),randomBackgroundOffset+gametv.GetWorldOffset()*(vf2d{32,32}/vf2d(GetScreenSize()))*gametv.GetWorldScale(),{32,32},Pixel{currentLevel->levelColor.r,currentLevel->levelColor.g,currentLevel->levelColor.b,164}/2);
gametv.DrawPartialDecal({0,0},WORLD_SIZE*CONSTANT::TILE_SIZE,IMAGES[TILE]->Decal(),{0,0},WORLD_SIZE*CONSTANT::TILE_SIZE,currentLevel->levelColor);
for(auto&u:units){
u->DrawRangeIndicator(this,gametv,IMAGES);
}
for(auto&u:units){
u->Draw(gametv,IMAGES);
if(u->IsGuarded()&&!u->InFogOfWar()){
gametv.DrawDecal(u->GetPos()+vf2d{float(u->GetUnitSize().x/2),-float(u->GetUnitSize().y/2)}-vf2d{float(IMAGES[GUARD_ICON]->Sprite()->width),0.f}*0.375,IMAGES[GUARD_ICON]->Decal(),{0.375,0.375});
}
}
for(auto&deadUnit:deathAnimations){
deadUnit->Update(fElapsedTime);
deadUnit->Draw(gametv,this);
}
std::erase_if(deathAnimations,[](auto&u){return u->IsDone();});
for(auto&collectionPoint:collectionPoints){
collectionPoint->Update(this,*IMAGES[MATRIX]);
RenderCollectionPoints(collectionPoint.get());
}
for(auto&u:units){
u->DrawUnitDamageStats(this,gametv,IMAGES);
}
for(DebuffIcon&icon:debuffIcons){
icon.Update(fElapsedTime);
icon.Draw(gametv);
}
for(ResourceGainIcon&icon:resourceGainIcons){
icon.Update(fElapsedTime);
icon.Draw(gametv);
}
std::erase_if(debuffIcons,[](DebuffIcon&icon){return icon.lifetime<=0;});
std::erase_if(resourceGainIcons,[](ResourceGainIcon&icon){return icon.lifetime<=0;});
for(auto&u:units){
u->_DrawHud(gametv,IMAGES,flags.unitMetersGreyedOut);
}
DrawSelectionRectangle();
RenderFogOfWar();
unitCreationList.DrawDecal(this);
platformCreationList.DrawDecal(this);
restartManager.DrawDecal(this);
DrawSystemMemoryBar(fElapsedTime);
DrawResourceBar(fElapsedTime);
if(flags.guideEnabled){
DrawDecal({float(ScreenWidth()-74-IMAGES[GUIDE]->Sprite()->width*0.75),float(ScreenHeight()+6-IMAGES[GUIDE]->Sprite()->height*0.75)},IMAGES[GUIDE]->Decal(),{0.75,0.75});
}
DrawMinimap();
unitCreationBox.UpdateAndDraw(GetMousePos()+vi2d{8,-28},this,player_resources,IMAGES,GetTotalUsedMemory(),currentLevel->availableMemory);
testBox.UpdateAndDraw(GetMousePos()-testBox.GetSize()/2,this,player_resources,IMAGES,GetTotalUsedMemory(),currentLevel->availableMemory);
memoryAllocatorBox.UpdateAndDraw(GetMousePos()+vi2d{8,-28},this,player_resources,IMAGES,GetTotalUsedMemory(),currentLevel->availableMemory);
platformCreationBox.UpdateAndDraw(GetMousePos()+vi2d{8,-28},this,player_resources,IMAGES,GetTotalUsedMemory(),currentLevel->availableMemory);
restartBox.UpdateAndDraw(GetMousePos()+vf2d{0,10},this,player_resources,IMAGES,GetTotalUsedMemory(),currentLevel->availableMemory);
if(restartButtonHoldTime>0){
FillRectDecal(restartButton->vPos+vf2d{3,(1-(restartButtonHoldTime/2.5f))*restartButton->vSize.y},{restartButton->vSize.x,((restartButtonHoldTime/2.5f))*restartButton->vSize.y},{255,255,255,128});
}
std::sort(units.begin(),units.end(),[&](auto&u1,auto&u2){
float dist1=geom2d::line<float>(u1->GetGhostPos(),GetWorldMousePos()).length();
float dist2=geom2d::line<float>(u2->GetGhostPos(),GetWorldMousePos()).length();
return dist1>dist2;});
SCENARIOS[currentScenario]->Draw();
for(auto&u:units){
if(u->IsGuarded()){
bool changeOccured=false;
int changedBit=-1;
for(int i=0;i<u->memory.size();i++){
if(u->memory[i]!=u->savedMemory[i]){
changeOccured=true;
changedBit=i;
break;
}
}
if(changeOccured&&util::random(1)<=0.3){
u->memory[changedBit]=u->savedMemory[changedBit];
}
}
}
DrawPartialDecal({0,0},GetScreenSize(),IMAGES[MATRIX]->Decal(),randomBackgroundOffset+gametv.GetWorldOffset()*(vf2d{32,32}/vf2d(GetScreenSize()))*gametv.GetWorldScale(),{32,32},Pixel{currentLevel->levelColor.r,currentLevel->levelColor.g,currentLevel->levelColor.b,uint8_t(levelForegroundFade*255)}/2);
}break;
#pragma endregion
#pragma region COMPLETED
case GameState::COMPLETED:{
DrawPartialDecal({0,0},GetScreenSize(),IMAGES[MATRIX]->Decal(),randomBackgroundOffset+gametv.GetWorldOffset()*(vf2d{32,32}/vf2d(GetScreenSize()))*gametv.GetWorldScale(),{32,32},Pixel{currentLevel->levelColor.r,currentLevel->levelColor.g,currentLevel->levelColor.b,164}/2);
completedBox.Initialize("Thank you for playing Virus Attack!\n\nCompletion Time:"+DisplayTime(gameSeconds)+" seconds\nDifficulty Completed:\n+"+(flags.difficulty==0?"Easy":flags.difficulty==1?"Normal":"Hard")+"+\n\nHuge shoutout to the OLC community, javidx9 for the PGE existing, and all supporters!\n\n\nPress [Escape] to return to the main menu.",{0,0},"Congratulations!",nullptr,{float(ScreenWidth()-2),1.f});
completedBox.UpdateAndDraw({0,0},this,player_resources,IMAGES,GetTotalUsedMemory(),currentLevel->availableMemory);
if(GetKey(ESCAPE).bPressed){
state=GameState::MAIN_MENU;
float titleScreenY=-200;
float textOrientationY=0;
float textOrientationX=0;
LoadLevel(STAGE1);
levelToLoad=LevelName::STAGE1;
}
}break;
#pragma endregion
}
return true;
}
std::string VirusAttack::DisplayTime(int gameSeconds){
int totalMinutes=gameSeconds/60;
int totalHours=totalMinutes/60;
std::string secondsDisplay=std::to_string(gameSeconds%60);
std::string minutesDisplay=std::to_string(totalMinutes%60);
std::string hoursDisplay=std::to_string(totalHours);
return hoursDisplay+":"+((minutesDisplay.length()==1)?"0":"")+minutesDisplay+":"+((secondsDisplay.length()==1)?"0":"")+secondsDisplay;
}
void VirusAttack::DrawSystemMemoryBar(float fElapsedTime){
memoryChangeTimer=std::max(0.f,memoryChangeTimer-fElapsedTime);
memoryDisplayDelay-=fElapsedTime;
if(memoryDisplayDelay<=0){
if(memoryDisplayAmt>lastTotalMemory){
memoryDisplayAmt-=1;
} else
if(memoryDisplayAmt<lastTotalMemory){
memoryDisplayAmt+=1;
}
memoryDisplayDelay=0.01;
}
lastDisplayMemoryUpdateTimer-=fElapsedTime;
if(lastDisplayMemoryUpdateTimer<=0){
for(int i=0;i<playerUsedMemory.size();i++){
if(playerUsedMemory[i]<playerUsedDisplayMemory[i]){
playerUsedDisplayMemory[i]--;
} else
if(playerUsedMemory[i]>playerUsedDisplayMemory[i]){
playerUsedDisplayMemory[i]++;
}
}
for(int i=0;i<enemyUsedMemory.size();i++){
if(enemyUsedMemory[i]<enemyUsedDisplayMemory[i]){
enemyUsedDisplayMemory[i]--;
} else
if(enemyUsedMemory[i]>enemyUsedDisplayMemory[i]){
enemyUsedDisplayMemory[i]++;
}
}
lastDisplayMemoryUpdateTimer=0.01;
}
vf2d barPos={2,float(ScreenHeight()-7)};
float barOffset=0;
float barWidth=240;
float actualBarWidth=barWidth+2;
for(int i=0;i<playerUsedDisplayMemory.size();i++){
float barSegmentWidth=(float(playerUsedDisplayMemory[i])/currentLevel->availableMemory)*actualBarWidth;
Pixel col;
switch(i){
case 0:{
col=CONSTANT::HEALTH_COLOR;
}break;
case 1:{
col=flags.unitMetersGreyedOut?DARK_GREY:CONSTANT::RANGE_COLOR;
}break;
case 2:{
col=flags.unitMetersGreyedOut?DARK_GREY:CONSTANT::ATKSPD_COLOR;
}break;
case 3:{
col=flags.unitMetersGreyedOut?DARK_GREY:CONSTANT::MOVESPD_COLOR;
}break;
case 4:{
col=flags.unitMetersGreyedOut?DARK_GREY:CONSTANT::PROCEDURE_COLOR;
}break;
}
DrawPartialDecal(barPos+vf2d{barOffset+1,1.f},{barSegmentWidth,3},IMAGES[SEGMENT_BAR]->Decal(),{0,0},{float(playerUsedDisplayMemory[i]),3.f},col);
barOffset+=barSegmentWidth;
}
FillRectDecal(barPos+vf2d{barOffset+1,1.f},{2,3},GREEN);
barOffset=0;
for(int i=0;i<enemyUsedDisplayMemory.size();i++){
float barSegmentWidth=(float(enemyUsedDisplayMemory[i])/currentLevel->availableMemory)*actualBarWidth;
Pixel col;
switch(i){
case 0:{
col=CONSTANT::HEALTH_COLOR;
}break;
case 1:{
col=flags.unitMetersGreyedOut?DARK_GREY:CONSTANT::RANGE_COLOR;
}break;
case 2:{
col=flags.unitMetersGreyedOut?DARK_GREY:CONSTANT::ATKSPD_COLOR;
}break;
case 3:{
col=flags.unitMetersGreyedOut?DARK_GREY:CONSTANT::MOVESPD_COLOR;
}break;
case 4:{
col=flags.unitMetersGreyedOut?DARK_GREY:CONSTANT::PROCEDURE_COLOR;
}break;
}
DrawPartialDecal(barPos+vf2d{barOffset+actualBarWidth+3-barSegmentWidth,1.f},{barSegmentWidth,3},IMAGES[SEGMENT_BAR]->Decal(),{0,0},{float(enemyUsedDisplayMemory[i]),3.f},col);
barOffset-=barSegmentWidth;
}
FillRectDecal(barPos+vf2d{barOffset+actualBarWidth+3-2,1.f},{2,3},RED);
DrawPartialDecal(barPos,{3,5},IMAGES[ROUND_BAR]->Decal(),{0,0},{3,5},flags.flashMemoryBar?PixelLerp(BLACK,CONSTANT::INCREASE_VALUE_COLOR,flashTimer):BLACK);
for(int i=barPos.x+3;i<barWidth;i++){
DrawPartialDecal(barPos+vf2d{3,0},{barWidth,5},IMAGES[ROUND_BAR]->Decal(),{2,0},{1,5},flags.flashMemoryBar?PixelLerp(BLACK,CONSTANT::INCREASE_VALUE_COLOR,flashTimer):BLACK);
}
DrawPartialDecal(barPos+vf2d{3+barWidth,0},{3,5},IMAGES[ROUND_BAR]->Decal(),{2,0},{3,5},flags.flashMemoryBar?PixelLerp(BLACK,CONSTANT::INCREASE_VALUE_COLOR,flashTimer):BLACK);
vf2d textPos=barPos+vf2d{barWidth+6+4,0};
if(GetTotalUsedMemory()>lastTotalMemory){
memoryIncreased=true;
memoryChangeTimer=2;
} else
if(GetTotalUsedMemory()<lastTotalMemory){
memoryIncreased=false;
memoryChangeTimer=2;
}
lastTotalMemory=GetTotalUsedMemory();
DrawShadowStringPropDecal(textPos,std::to_string(memoryDisplayAmt)+"/"+std::to_string(currentLevel->availableMemory)+"b",WHITE,PixelLerp(BLACK,memoryIncreased?CONSTANT::INCREASE_VALUE_COLOR:CONSTANT::DECREASE_VALUE_COLOR,memoryChangeTimer/2.0f),{0.6,0.6},0.6);
}
void VirusAttack::DrawResourceBar(float fElapsedTime){
for(int i=0;i<resourceGainTimer.size();i++){
resourceGainTimer[i]=std::max(0.f,resourceGainTimer[i]-fElapsedTime);
}
GradientFillRectDecal({0,0},{float(ScreenWidth()),12.f},BLACK,{VERY_DARK_BLUE.r,VERY_DARK_BLUE.g,VERY_DARK_BLUE.b,128},{VERY_DARK_BLUE.r,VERY_DARK_BLUE.g,VERY_DARK_BLUE.b,128},BLACK);
DrawRectDecal({0,0},{float(ScreenWidth()),12.f},{3, 194, 252});
auto DrawResourceDisplay=[&](int index,int resourceValue,int&previousResourceValue,int&displayResourceValue,Pixel col){
resourceDisplayValueUpdateTimer[index]-=fElapsedTime;
if(previousResourceValue<resourceValue){
resourceIncreased[index]=true;
resourceGainTimer[index]=2;
previousResourceValue=resourceValue;
} else
if(previousResourceValue>resourceValue){
resourceIncreased[index]=false;
resourceGainTimer[index]=2;
previousResourceValue=resourceValue;
}
if(resourceDisplayValueUpdateTimer[index]<=0){
if(displayResourceValue<resourceValue){
displayResourceValue++;
} else
if(displayResourceValue>resourceValue){
displayResourceValue--;
}
resourceDisplayValueUpdateTimer[index]=0.01;
}
DrawDecal({6.f+index*42,1.f},IMAGES[RESOURCE]->Decal(),{1,1},col);
DrawShadowStringDecal({6.f+index*42+20,2.f},std::to_string(displayResourceValue),col,PixelLerp(BLACK,resourceIncreased[index]?CONSTANT::INCREASE_VALUE_COLOR:CONSTANT::DECREASE_VALUE_COLOR,resourceGainTimer[index]/2.0f));
};
DrawResourceDisplay(0,player_resources.health,player_prev_resources.health,player_display_resources.health,CONSTANT::HEALTH_COLOR);
DrawResourceDisplay(1,player_resources.atkSpd,player_prev_resources.atkSpd,player_display_resources.atkSpd,CONSTANT::ATKSPD_COLOR);
DrawResourceDisplay(2,player_resources.moveSpd,player_prev_resources.moveSpd,player_display_resources.moveSpd,CONSTANT::MOVESPD_COLOR);
DrawResourceDisplay(3,player_resources.range,player_prev_resources.range,player_display_resources.range,CONSTANT::RANGE_COLOR);
DrawResourceDisplay(4,player_resources.procedure,player_prev_resources.procedure,player_display_resources.procedure,CONSTANT::PROCEDURE_COLOR);
}
void VirusAttack::RenderFogOfWar(){
for(int y=gametv.GetTopLeftTile().y/96-1;y<=gametv.GetBottomRightTile().y/96+1;y++){
for(int x=gametv.GetTopLeftTile().x/96-1;x<=gametv.GetBottomRightTile().x/96+1;x++){
if(TileManager::visibleTiles.count(vi2d{x,y})==0){
if(x>=0&&y>=0&&x<WORLD_SIZE.x/4&&y<WORLD_SIZE.y/4){
gametv.FillRectDecal(vf2d{float(x),float(y)}*96,{96,96},{0,0,0,128});
}
}
}
}
}
bool VirusAttack::CanAfford(Resources&resources,std::vector<Memory>&unitCosts){
int totalMemoryCost=0;
for(Memory&mem:unitCosts){
switch(mem.type){
case HEALTH:{
if(resources.health<mem.size)return false;
}break;
case ATKSPD:{
if(resources.atkSpd<mem.size)return false;
}break;
case MOVESPD:{
if(resources.moveSpd<mem.size)return false;
}break;
case RANGE:{
if(resources.range<mem.size)return false;
}break;
case PROCEDURE:{
if(resources.procedure<mem.size)return false;
}break;
}
totalMemoryCost+=mem.size;
}
return totalMemoryCost+GetTotalUsedMemory()<=currentLevel->availableMemory;
}
void VirusAttack::ExpendResources(Resources&resources,std::vector<Memory>&unitCosts){
for(Memory&mem:unitCosts){
switch(mem.type){
case HEALTH:{
resources.health-=mem.size;
}break;
case ATKSPD:{
resources.atkSpd-=mem.size;
}break;
case MOVESPD:{
resources.moveSpd-=mem.size;
}break;
case RANGE:{
resources.range-=mem.size;
}break;
case PROCEDURE:{
resources.procedure-=mem.size;
}break;
}
}
}
int VirusAttack::GetTotalUsedMemory(){
return GetPlayerUsedMemory()+GetEnemyUsedMemory();
}
int VirusAttack::GetPlayerUsedMemory(){
int sum=0;
for(int i=0;i<5;i++){
sum+=playerUsedMemory[i];
}
return sum;
}
int VirusAttack::GetEnemyUsedMemory(){
int sum=0;
for(int i=0;i<5;i++){
sum+=enemyUsedMemory[i];
}
return sum;
}
void VirusAttack::CalculateUsedMemory(){
playerUsedMemory=enemyUsedMemory={0};
for(auto&u:units){
std::array<size_t,5>costs={u->health.size,u->range.size,u->atkSpd.size,u->moveSpd.size,u->procedure.size};
if(u->IsBuilding()){
costs={u->GetBuildUnit()->health.size,u->GetBuildUnit()->range.size,u->GetBuildUnit()->atkSpd.size,u->GetBuildUnit()->moveSpd.size,u->GetBuildUnit()->procedure.size};
}
std::array<int,5>&targetArr=u->IsFriendly()?playerUsedMemory:enemyUsedMemory;
for(int i=0;i<targetArr.size();i++){
targetArr[i]+=costs[i];
}
}
}
bool VirusAttack::OnUserDestroy(){
return true;
}
void VirusAttack::PerformLevelTransition(float fElapsedTime){
if(levelToLoad!=currentLevel->name||reloadLevel){
levelForegroundFade=std::min(1.f,levelForegroundFade+fElapsedTime);
if(levelForegroundFade>=1){
LoadLevel(levelToLoad);
reloadLevel=false;
}
}else
if(levelForegroundFade>0){
levelForegroundFade=std::max(0.f,levelForegroundFade-fElapsedTime);
}
}
void VirusAttack::RestartLevel(){
reloadLevel=true;
}
void VirusAttack::HandleRestartButton(float fElapsedTime){
if(restartButton->bHover){
restartBox.Initialize("Click and hold to restart the level.",GetMousePos()+vf2d{0,10},"Restart Level",nullptr,{72,1});
restartBox.SetVisible(true);
if(restartButton->bPressed){
restartButtonHeldDown=true;
}
if(restartButton->bReleased){
restartBox.SetVisible(false);
restartButtonHeldDown=false;
restartButtonHoldTime=0;
}
if(restartButtonHeldDown){
restartButtonHoldTime+=fElapsedTime;
if(restartButtonHoldTime>=CONSTANT::RESTART_BUTTON_HOLD_TIME){
RestartLevel();
restartButtonHeldDown=false;
restartButtonHoldTime=0;
}
}
}else{
restartBox.SetVisible(false);
restartButtonHeldDown=false;
restartButtonHoldTime=0;
}
}
void VirusAttack::DrawCurvedTexture(vf2d offset,vf2d size,Decal*decal,vf2d texOffset,Pixel col,float curveThickness){
vf2d curveMultiplier=size;
vf2d curveDisplacement=offset;
std::vector<vf2d>curvePoints={{0.f,abs(sin((0)*float(PI)))},{0.1,abs(sin((0.1f)*float(PI)))},{0.2,abs(sin((0.2f)*float(PI)))},{0.3,abs(sin((0.3f)*float(PI)))},{0.4,abs(sin((0.4f)*float(PI)))},{0.5,abs(sin((0.5f)*float(PI)))},{0.6,abs(sin((0.6f)*float(PI)))},{0.7,abs(sin((0.7f)*float(PI)))},{0.8,abs(sin((0.8f)*float(PI)))},{0.9,abs(sin((0.9f)*float(PI)))},{1.f,abs(sin((1.f)*float(PI)))}};
vf2d curve2offset={0.f,curveThickness};
std::vector<vf2d>curvePoints2={vf2d{0.f,abs(sin((0)*float(PI)))}+curve2offset,vf2d{0.1,abs(sin((0.1f)*float(PI)))}+curve2offset,vf2d{0.2,abs(sin((0.2f)*float(PI)))}+curve2offset,vf2d{0.3,abs(sin((0.3f)*float(PI)))}+curve2offset,vf2d{0.4,abs(sin((0.4f)*float(PI)))}+curve2offset,vf2d{0.5,abs(sin((0.5f)*float(PI)))}+curve2offset,vf2d{0.6f,abs(sin((0.6f)*float(PI)))}+curve2offset,vf2d{0.7,abs(sin((0.7f)*float(PI)))}+curve2offset,vf2d{0.8,abs(sin((0.8f)*float(PI)))}+curve2offset,vf2d{0.9,abs(sin((0.9f)*float(PI)))}+curve2offset,vf2d{1.f,abs(sin((1.f)*float(PI)))}+curve2offset};
std::vector<vf2d>combinedCurvePoints={
curvePoints2[0]*curveMultiplier+curveDisplacement,curvePoints[0]*curveMultiplier+curveDisplacement,
curvePoints2[1]*curveMultiplier+curveDisplacement,curvePoints[1]*curveMultiplier+curveDisplacement,
curvePoints2[2]*curveMultiplier+curveDisplacement,curvePoints[2]*curveMultiplier+curveDisplacement,
curvePoints2[3]*curveMultiplier+curveDisplacement,curvePoints[3]*curveMultiplier+curveDisplacement,
curvePoints2[4]*curveMultiplier+curveDisplacement,curvePoints[4]*curveMultiplier+curveDisplacement,
curvePoints2[5]*curveMultiplier+curveDisplacement,curvePoints[5]*curveMultiplier+curveDisplacement,
curvePoints2[6]*curveMultiplier+curveDisplacement,curvePoints[6]*curveMultiplier+curveDisplacement,
curvePoints2[7]*curveMultiplier+curveDisplacement,curvePoints[7]*curveMultiplier+curveDisplacement,
curvePoints2[8]*curveMultiplier+curveDisplacement,curvePoints[8]*curveMultiplier+curveDisplacement,
curvePoints2[9]*curveMultiplier+curveDisplacement,curvePoints[9]*curveMultiplier+curveDisplacement,
curvePoints2[10]*curveMultiplier+curveDisplacement,curvePoints[10]*curveMultiplier+curveDisplacement,
};
std::vector<vf2d>combinedUVPoints={
{curvePoints[0].y+texOffset.x,1},{curvePoints[0].y+texOffset.x,0},
{curvePoints[1].y+texOffset.x,1},{curvePoints[1].y+texOffset.x,0},
{curvePoints[2].y+texOffset.x,1},{curvePoints[2].y+texOffset.x,0},
{curvePoints[3].y+texOffset.x,1},{curvePoints[3].y+texOffset.x,0},
{curvePoints[4].y+texOffset.x,1},{curvePoints[4].y+texOffset.x,0},
{1-curvePoints[5].y+texOffset.x+1,1},{1-curvePoints[5].y+texOffset.x+1,0},
{1-curvePoints[6].y+texOffset.x+1,1},{1-curvePoints[6].y+texOffset.x+1,0},
{1-curvePoints[7].y+texOffset.x+1,1},{1-curvePoints[7].y+texOffset.x+1,0},
{1-curvePoints[8].y+texOffset.x+1,1},{1-curvePoints[8].y+texOffset.x+1,0},
{1-curvePoints[9].y+texOffset.x+1,1},{1-curvePoints[9].y+texOffset.x+1,0},
{1-curvePoints[10].y+texOffset.x+1,1},{1-curvePoints[10].y+texOffset.x+1,0},
};
SetDecalStructure(DecalStructure::STRIP);
DrawPolygonDecal(decal,combinedCurvePoints,combinedUVPoints,col);
SetDecalStructure(DecalStructure::FAN);
}
void VirusAttack::HandleGUIDisplay(){
bool allocatorSelected=false;
bool platformSelected=false;
bool memoryAllocatorBoxHovered=false;
for(auto&u:units){
u->UpdateGUIState(gametv,player_resources,memoryAllocatorBox,memoryAllocatorBoxHovered,GetTotalUsedMemory(),currentLevel->availableMemory);
if(u->IsSelected()){
if(u->IsAllocator()){
allocatorSelected=true;
} else
if(u->IsPlatform()){
platformSelected=true;
}
}
}
if(!memoryAllocatorBoxHovered)memoryAllocatorBox.SetVisible(false);
UpdateUnitCreationListGUI(allocatorSelected);
UpdatePlatformCreationListGUI(platformSelected);
}
int main()
{
VirusAttack app;
if (app.Construct(426, 320, 4, 4))
app.Start();
return 0;
}