sigonasr2/VirusAttack
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Virus Attack finalizing

Browse Source
This commit is contained in:
sigonasr2 2023-09-03 14:16:01 -05:00
parent 0b2b51c70c
commit a4439afc3f
8 changed files with 270 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -11,6 +11,9 @@
*.sln.docstates *.sln.docstates
*.wav *.wav
Windows
Emscripten
# User-specific files (MonoDevelop/Xamarin Studio) # User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs *.userprefs
@ -363,3 +366,5 @@ MigrationBackup/
# Fody - auto-generated XML schema # Fody - auto-generated XML schema
FodyWeavers.xsd FodyWeavers.xsd
*.mp3 *.mp3
*.zip
/olcCodeJam2023Entry/VirusAttack.exe

64
olcCodeJam2023Entry/Scenario.cpp
View File

@ -44,14 +44,22 @@ void Scenario::RunAI(Resources&enemy_resources,std::vector<std::shared_ptr<Colle
if(!setupEasyMode&&flags.difficulty==0){ if(!setupEasyMode&&flags.difficulty==0){
enemy_resources={100,100,100,100,100}; enemy_resources={100,100,100,100,100};
} }
attackTimer=std::max(0.f,attackTimer-game.GetPGE()->GetElapsedTime());
unitBuildTimer=std::max(0.f,unitBuildTimer-game.GetPGE()->GetElapsedTime()); unitBuildTimer=std::max(0.f,unitBuildTimer-game.GetPGE()->GetElapsedTime());
std::weak_ptr<Unit>baseOfOperations; std::weak_ptr<Unit>baseOfOperations;
std::weak_ptr<Unit>enemyBaseOfOperations;
for(auto&u:units){ for(auto&u:units){
if(!u->IsFriendly()&&u->IsRAMBank()){ if(!u->IsFriendly()&&u->IsRAMBank()){
baseOfOperations=u; baseOfOperations=u;
break; break;
} }
} }
for(auto&u:units){
if(u->IsFriendly()&&u->IsRAMBank()){
enemyBaseOfOperations=u;
break;
}
}
if(baseOfOperations.expired()){ if(baseOfOperations.expired()){
for(auto&u:units){ for(auto&u:units){
if(!u->IsFriendly()){ if(!u->IsFriendly()){
@ -93,7 +101,7 @@ void Scenario::RunAI(Resources&enemy_resources,std::vector<std::shared_ptr<Colle
} }
if(memoryAllocatorCount<3){ if(memoryAllocatorCount<3){
for(auto&u:units){ for(auto&u:units){
if(u->IsRAMBank()){ if(!u->IsFriendly()&&u->IsRAMBank()){
AttemptBuild(UnitType::MemoryAllocator,u->GetPos(),MemoryAllocator::resourceCost,enemy_resources,availableMemory,queuedUnits); AttemptBuild(UnitType::MemoryAllocator,u->GetPos(),MemoryAllocator::resourceCost,enemy_resources,availableMemory,queuedUnits);
} }
} }
@ -148,6 +156,35 @@ void Scenario::RunAI(Resources&enemy_resources,std::vector<std::shared_ptr<Colle
} }
} }
} }
if(attackTimer==0){
if(!enemyBaseOfOperations.expired()){
for(auto&u:units){
if(!u->IsFriendly()&&rand()%3==0){
if(u->CanInteractWithEnemies()&&!u->IsAllocator()&&u->CanMove()){
u->SetTargetUnit(enemyBaseOfOperations);
}
}
}
for(auto&u:units){
if(!u->IsFriendly()&&u->GetCurrentTarget().expired()&&u->CanInteractWithAllies()){
if(rand()%5==0){
u->SetTargetLocation(enemyBaseOfOperations.lock()->GetPos());
}
}
}
}
switch(flags.difficulty){
case 0:{
attackTimer=999;
}break;
case 1:{
attackTimer=300;
}break;
case 2:{
attackTimer=120;
}break;
}
}
} }
/* /*
std::shared_ptr<UnitClass>buildUnit=std::make_shared<UnitClass>(this,u->GetPos(),IMAGES,u->IsFriendly()); \ std::shared_ptr<UnitClass>buildUnit=std::make_shared<UnitClass>(this,u->GetPos(),IMAGES,u->IsFriendly()); \
@ -673,9 +710,14 @@ void Stage6::Start(){
}; };
void Stage6::Update(){ void Stage6::Update(){
switch(state){ switch(state){
case 0:{ case 0:{
flags.playerInControl=false;
}break; DisplayBox("...");
if(box.bPressed){
flags.playerInControl=true;
box.SetVisible(false);
}
}break;
} }
}; };
bool Stage6::MissionCompleted(){ bool Stage6::MissionCompleted(){
@ -697,8 +739,20 @@ void Stage7::Start(){
void Stage7::Update(){ void Stage7::Update(){
switch(state){ switch(state){
case 0:{ case 0:{
flags.playerInControl=false;
DisplayBox("I see you have a few new tricks up your sleeve, Hacker.");
if(box.bPressed){
state=1;
}
}break; }break;
case 1:{
DisplayBox("Don't think it'll be that easy to get through this one...");
if(box.bPressed){
state=2;
flags.playerInControl=true;
box.SetVisible(false);
}
}break;
} }
}; };
bool Stage7::MissionCompleted(){ bool Stage7::MissionCompleted(){

1
olcCodeJam2023Entry/Scenario.h
View File

@ -19,6 +19,7 @@ public:
LevelName nextLevel=LevelName::STAGE1; LevelName nextLevel=LevelName::STAGE1;
void RunAI(Resources&enemy_resources,std::vector<std::shared_ptr<CollectionPoint>>&collectionPoints,int availableMemory,std::vector<std::shared_ptr<Unit>>&queuedUnits,std::vector<std::unique_ptr<Audio>>&SOUNDS); void RunAI(Resources&enemy_resources,std::vector<std::shared_ptr<CollectionPoint>>&collectionPoints,int availableMemory,std::vector<std::shared_ptr<Unit>>&queuedUnits,std::vector<std::unique_ptr<Audio>>&SOUNDS);
bool setupEasyMode=false; bool setupEasyMode=false;
float attackTimer=120;
std::map<CollectionPoint*,float>cpCheckTimer; std::map<CollectionPoint*,float>cpCheckTimer;
bool AttemptBuild(UnitType unit,vf2d pos,std::vector<Memory>&resourceCost,Resources&enemy_resources,int availableMemory,std::vector<std::shared_ptr<Unit>>&queuedUnits); bool AttemptBuild(UnitType unit,vf2d pos,std::vector<Memory>&resourceCost,Resources&enemy_resources,int availableMemory,std::vector<std::shared_ptr<Unit>>&queuedUnits);
protected: protected:

251
olcCodeJam2023Entry/VirusAttack.cpp
View File

@ -338,49 +338,184 @@ void VirusAttack::InitializeLevelData(){
positions.erase(positions.begin()+randomIndex); positions.erase(positions.begin()+randomIndex);
types.erase(types.begin()+randomIndex2); types.erase(types.begin()+randomIndex2);
} }
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++){ for(int i=0;i<5;i++){
units.push_back({UnitType::MemoryAllocator,vf2d{44*24,44*24},false}); 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::Refresher,vf2d{2*24,42*24},false});
units.push_back({UnitType::LeftShifter,vf2d{42*24,44*24},false}); units.push_back({UnitType::MemoryGuard,vf2d{7*24,44*24},false});
units.push_back({UnitType::LeftShifter,vf2d{42*24,44*24},false}); units.push_back({UnitType::LeftShifter,vf2d{2*24,44*24},false});
units.push_back({UnitType::Corrupter,vf2d{42*24,44*24},false}); units.push_back({UnitType::LeftShifter,vf2d{2*24,44*24},false});
units.push_back({UnitType::RightShifter,vf2d{42*24,44*24},false}); units.push_back({UnitType::Corrupter,vf2d{2*24,44*24},false});
units.push_back({UnitType::RightShifter,vf2d{45*24,41*24},false}); units.push_back({UnitType::RightShifter,vf2d{2*24,44*24},false});
units.push_back({UnitType::RAMBank,vf2d{44*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 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);
}
units.push_back({UnitType::Refresher,vf2d{52*24,52*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::RAMBank,vf2d{40*24,36*24},false});
units.push_back({UnitType::RAMBank,vf2d{10*24,54*24},false});
}
}
#pragma endregion
} }
bool VirusAttack::OnUserCreate(){ bool VirusAttack::OnUserCreate(){
@ -401,6 +536,8 @@ bool VirusAttack::OnUserCreate(){
memoryAllocatorBox.SetVisible(false); memoryAllocatorBox.SetVisible(false);
platformCreationBox.SetVisible(false); platformCreationBox.SetVisible(false);
restartBox.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); attackingLineModified.Create(IMAGES[ATTACKING_LINE]->Sprite()->width,IMAGES[ATTACKING_LINE]->Sprite()->height,false,false);
@ -411,8 +548,8 @@ bool VirusAttack::OnUserCreate(){
InitializeScenarios(); InitializeScenarios();
InitializeLevelData(); InitializeLevelData();
LoadLevel(STAGE5); LoadLevel(STAGE1);
levelToLoad=STAGE5; levelToLoad=STAGE1;
return true; return true;
} }
@ -505,10 +642,10 @@ void VirusAttack::InitializeGUIs(){
unitCreationList.DisplayAllControls(false); unitCreationList.DisplayAllControls(false);
platformCreationList.DisplayAllControls(false); platformCreationList.DisplayAllControls(false);
campaignStartButton=new QuickGUI::TransparentButton(mainMenu,"Start Campaign",{float(ScreenWidth()/2)-120.f,80+47.5f*0+10},{240,24},CONSTANT::INCREASE_VALUE_COLOR); 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*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*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); //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); exitGameButton=new QuickGUI::TransparentButton(mainMenu,"Exit Game",{float(ScreenWidth()/2)-120.f,80+47.5f*4+10},{240,24},CONSTANT::INCREASE_VALUE_COLOR);
} }
@ -946,9 +1083,11 @@ void VirusAttack::RenderCollectionPoints(CollectionPoint*cp){
bool VirusAttack::OnUserUpdate(float fElapsedTime){ bool VirusAttack::OnUserUpdate(float fElapsedTime){
UpdateMatrixTexture(fElapsedTime); UpdateMatrixTexture(fElapsedTime);
gameplayTime+=fElapsedTime; gameplayTime+=fElapsedTime;
if(gameplayTime>=1){ if(state!=GameState::COMPLETED){
gameplayTime--; if(gameplayTime>=1){
gameSeconds++; gameplayTime--;
gameSeconds++;
}
} }
switch(state){ switch(state){
#pragma region MAIN_MENU #pragma region MAIN_MENU
@ -960,6 +1099,7 @@ bool VirusAttack::OnUserUpdate(float fElapsedTime){
state=GameState::GAMEPLAY; state=GameState::GAMEPLAY;
RestartLevel(); RestartLevel();
gameplayTime=0; gameplayTime=0;
gameSeconds=0;
} }
if(audioToggleButton->bPressed){ if(audioToggleButton->bPressed){
audioMode=(audioMode+1)%3; audioMode=(audioMode+1)%3;
@ -981,6 +1121,20 @@ bool VirusAttack::OnUserUpdate(float fElapsedTime){
}break; }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){ if(exitGameButton->bPressed){
SOUNDS[Sound::BUTTONSELECT]->PlayCentered(); SOUNDS[Sound::BUTTONSELECT]->PlayCentered();
} }
@ -1229,12 +1383,9 @@ bool VirusAttack::OnUserUpdate(float fElapsedTime){
#pragma endregion #pragma endregion
#pragma region COMPLETED #pragma region COMPLETED
case GameState::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); 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);
}break; completedBox.Initialize("Thank you for playing Virus Attack!\n\nCompletion Time:"+std::to_string(gameSeconds)+" seconds\n\nHuge shoutout to the OLC community, javidx9 for the PGE, and all supporters!");
#pragma endregion
#pragma region CREDITS
case GameState::CREDITS:{
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);
}break; }break;
#pragma endregion #pragma endregion
} }

4
olcCodeJam2023Entry/VirusAttack.h
View File

@ -60,7 +60,6 @@ public:
QuickGUI::TransparentButton*campaignStartButton; QuickGUI::TransparentButton*campaignStartButton;
QuickGUI::TransparentButton*audioToggleButton; QuickGUI::TransparentButton*audioToggleButton;
QuickGUI::TransparentButton*difficultyToggleButton; QuickGUI::TransparentButton*difficultyToggleButton;
QuickGUI::TransparentButton*creditsButton;
QuickGUI::TransparentButton*exitGameButton; QuickGUI::TransparentButton*exitGameButton;
QuickGUI::Manager restartManager; QuickGUI::Manager restartManager;
QuickGUI::TransparentImageButton*restartButton; QuickGUI::TransparentImageButton*restartButton;
@ -114,6 +113,9 @@ public:
GameFlags flags; GameFlags flags;
float flashTimer=0; float flashTimer=0;
Textbox completedBox;
Textbox creditsBox;
std::string objective=""; std::string objective="";
vf2d randomBackgroundOffset; vf2d randomBackgroundOffset;

BIN
olcCodeJam2023Entry/pge.data
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 24 MiB

After

Width:  |  Height:  |  Size: 24 MiB

2
olcCodeJam2023Entry/pge.js
View File

File diff suppressed because one or more lines are too long

BIN
olcCodeJam2023Entry/pge.wasm
View File

Binary file not shown.