Last active
September 15, 2023 15:34
Memory Allocator game.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#define OLC_PGE_APPLICATION | |
#include "olcPixelGameEngine.h" | |
#include <ctime> | |
bool CheckBounds(int mouseX, int mouseY, int top, int left, int width, int height); | |
struct item { | |
int size; | |
int startingIndex; | |
int id; | |
int lifespan; | |
int removalTime; | |
olc::Pixel color; | |
}; | |
std::string seed = ""; | |
std::string scores = ""; | |
#if defined(OLC_PLATFORM_EMSCRIPTEN) | |
#define OLC_SOUNDWAVE | |
#include "olcSoundWaveEngine.h" | |
#include <emscripten/fetch.h> | |
void downloadSucceeded(emscripten_fetch_t * fetch) { | |
scores = fetch -> data; | |
emscripten_fetch_close(fetch); | |
} | |
void downloadFailed(emscripten_fetch_t * fetch) { | |
emscripten_fetch_close(fetch); // Also free data on failure. | |
} | |
void postScore(std::string name, int score) { | |
emscripten_fetch_attr_t attr; | |
emscripten_fetch_attr_init( & attr); | |
strcpy(attr.requestMethod, "GET"); | |
attr.attributes = EMSCRIPTEN_FETCH_LOAD_TO_MEMORY | EMSCRIPTEN_FETCH_REPLACE; | |
attr.onsuccess = downloadSucceeded; | |
attr.onerror = downloadFailed; | |
emscripten_fetch( & attr, ("redacted"); | |
} | |
#else | |
void postScore(std::string name, int score) { | |
scores = "Your Score:\n " + name + " " + std::to_string(score); | |
} | |
#endif | |
class Example: public olc::PixelGameEngine | |
{ | |
olc::Sprite MainMenuBackgrounds[5]; | |
olc::Sprite MainGameBackgrounds[5]; | |
olc::Sprite DirectionsBackground; | |
olc::Sprite Directions[5]; | |
olc::Sprite GameOver; | |
olc::Sprite PostScore; | |
olc::Sprite StartButton; | |
olc::Sprite StartButtonPressed; | |
olc::Sprite NextButton; | |
olc::Sprite NextButtonPressed; | |
olc::Sprite BackButton; | |
olc::Sprite BackButtonPressed; | |
olc::Sprite PostButton; | |
olc::Sprite PostButtonPressed; | |
olc::Sprite DontPostButton; | |
olc::Sprite DontPostButtonPressed; | |
olc::Sprite PlayAgainButton; | |
olc::Sprite PlayAgainButtonPressed; | |
int dirctionStage = 0; | |
int GameState = 0; | |
std::vector < item > MemoryObjects; | |
item CurrentMemoryObject; | |
int score = 0; | |
int Value = 100; | |
bool valueReady = true; | |
int EndTime = time(0); | |
std::string name = "<BLANK>"; | |
bool MainSoundStarted = false; | |
bool RushSoundStarted = false; | |
int start = time(0); | |
#if defined(OLC_PLATFORM_EMSCRIPTEN) | |
olc::sound::WaveEngine engine; | |
olc::sound::Wave mainWave; | |
olc::sound::Wave rushWave; | |
#endif | |
bool enterSeed = false; | |
int actualSeed = time(0); | |
public: | |
Example() | |
{ | |
sAppName = "Example"; | |
} | |
public: | |
bool OnUserCreate() override | |
{ | |
MainMenuBackgrounds[0] = olc::Sprite("./assets/main_menu_backgrounds/0.png"); | |
MainMenuBackgrounds[1] = olc::Sprite("./assets/main_menu_backgrounds/1.png"); | |
MainMenuBackgrounds[2] = olc::Sprite("./assets/main_menu_backgrounds/2.png"); | |
MainMenuBackgrounds[3] = olc::Sprite("./assets/main_menu_backgrounds/3.png"); | |
MainMenuBackgrounds[4] = olc::Sprite("./assets/main_menu_backgrounds/4.png"); | |
StartButton = olc::Sprite("./assets/buttons/start.png"); | |
StartButtonPressed = olc::Sprite("./assets/buttons/start_pressed.png"); | |
NextButton = olc::Sprite("./assets/buttons/next.png"); | |
NextButtonPressed = olc::Sprite("./assets/buttons/next_pressed.png"); | |
BackButton = olc::Sprite("./assets/buttons/back.png"); | |
BackButtonPressed = olc::Sprite("./assets/buttons/back_pressed.png"); | |
PostButton = olc::Sprite("./assets/buttons/post.png"); | |
PostButtonPressed = olc::Sprite("./assets/buttons/post_pressed.png"); | |
DontPostButton = olc::Sprite("./assets/buttons/dont_post.png"); | |
DontPostButtonPressed = olc::Sprite("./assets/buttons/dont_post_pressed.png"); | |
PlayAgainButton = olc::Sprite("./assets/buttons/play_again.png"); | |
PlayAgainButtonPressed = olc::Sprite("./assets/buttons/play_again_pressed.png"); | |
GameOver = olc::Sprite("./assets/game_over.png"); | |
PostScore = olc::Sprite("./assets/main_menu_backgrounds/0.png"); | |
Directions[0] = olc::Sprite("./assets/directions/0.png"); | |
Directions[1] = olc::Sprite("./assets/directions/1.png"); | |
Directions[2] = olc::Sprite("./assets/directions/2.png"); | |
Directions[3] = olc::Sprite("./assets/directions/3.png"); | |
Directions[4] = olc::Sprite("./assets/directions/4.png"); | |
DirectionsBackground = olc::Sprite("./assets/directions/background.png"); | |
MainGameBackgrounds[0] = olc::Sprite("./assets/main_game_backgrounds/0.png"); | |
MainGameBackgrounds[1] = olc::Sprite("./assets/main_game_backgrounds/1.png"); | |
MainGameBackgrounds[2] = olc::Sprite("./assets/main_game_backgrounds/2.png"); | |
MainGameBackgrounds[3] = olc::Sprite("./assets/main_game_backgrounds/3.png"); | |
MainGameBackgrounds[4] = olc::Sprite("./assets/main_game_backgrounds/4.png"); | |
#if defined(OLC_PLATFORM_EMSCRIPTEN) | |
rushWave.LoadAudioWaveform("./assets/8bitDungeonBoss.wav"); | |
mainWave.LoadAudioWaveform("./assets/8bitDungeonLevel.wav"); | |
engine.InitialiseAudio(44100, 2); | |
engine.SetOutputVolume(0.5); | |
#endif | |
srand(actualSeed); | |
return true; | |
} | |
bool OnUserUpdate(float fElapsedTime) override | |
{ | |
SetPixelMode(olc::Pixel::ALPHA); // Dont draw pixels which have any transparency | |
switch (GameState) { | |
case 0: | |
DrawMainMenu(fElapsedTime); | |
return true; | |
case 1: | |
DrawDirections(fElapsedTime); | |
return true; | |
case 2: | |
DrawGame(fElapsedTime); | |
return true; | |
case 3: | |
DrawPostScore(fElapsedTime); | |
return true; | |
case 4: | |
DrawGameOver(fElapsedTime); | |
return true; | |
} | |
return true; | |
} | |
void DrawMainMenu(float fElapsedTime) { | |
int animationIndex = (time(0) % 4); | |
DrawSprite({ | |
0, | |
0 | |
}, & MainMenuBackgrounds[animationIndex]); | |
if (CheckBounds(GetMouseX(), GetMouseY(), 110, 120, 100, 50)) { | |
DrawSprite({ | |
110, | |
120 | |
}, & StartButtonPressed); | |
if (GetMouse(0).bPressed) | |
{ | |
GameState = 1; | |
if (seed != "") { | |
srand(stoi(seed)); | |
actualSeed = stoi(seed); | |
} | |
} | |
} else { | |
DrawSprite({ | |
110, | |
120 | |
}, & StartButton); | |
} | |
if (GetKey(olc::Key::S).bPressed) { | |
enterSeed = true; | |
} | |
if (enterSeed) { | |
std::string temp = GetNumKey(); | |
printf("%s", temp.c_str()); | |
if (temp == "BACK" && name.length() > 0) { | |
seed = seed.substr(0, seed.length() - 1); | |
} else { | |
if (seed.length() < 10 and temp != "BACK") { | |
seed += temp; | |
} | |
} | |
DrawString({ | |
30, | |
85 | |
}, "Seed: ", olc::BLACK); | |
DrawString({ | |
75, | |
85 | |
}, seed, olc::BLACK); | |
DrawLine({ | |
75, | |
93 | |
}, { | |
160, | |
93 | |
}, olc::BLACK); | |
} | |
} | |
void DrawPostScore(float fElapsedTime) { | |
DrawSprite({ | |
0, | |
0 | |
}, & PostScore); | |
if (seed != "") { | |
DrawString({ | |
200, | |
230 | |
}, "Seed: " + seed); | |
} | |
std::string temp = GetTypedKey(); | |
printf("%s", temp.c_str()); | |
if (temp == "BACK" && name.length() > 0) { | |
name = name.substr(0, name.length() - 1); | |
} else { | |
if (name.length() < 10 and temp != "BACK") { | |
name += temp; | |
} | |
} | |
DrawString({ | |
30, | |
85 | |
}, "Name: ", olc::BLACK); | |
DrawString({ | |
75, | |
85 | |
}, name, olc::BLACK); | |
DrawLine({ | |
75, | |
93 | |
}, { | |
160, | |
93 | |
}, olc::BLACK); | |
DrawString({ | |
20, | |
100 | |
}, "Score: ", olc::BLACK); | |
DrawString({ | |
75, | |
100 | |
}, std::to_string(score), olc::BLACK); | |
if (CheckBounds(GetMouseX(), GetMouseY(), 210, 160, 100, 50) && name.length() > 0) { | |
DrawSprite({ | |
210, | |
160 | |
}, & PostButtonPressed); | |
if (GetMouse(0).bPressed) | |
{ | |
postScore(name, score); | |
GameState = 4; | |
} | |
} else { | |
DrawSprite({ | |
210, | |
160 | |
}, & PostButton); | |
} | |
if (CheckBounds(GetMouseX(), GetMouseY(), 10, 160, 100, 50)) { | |
DrawSprite({ | |
10, | |
160 | |
}, & DontPostButtonPressed); | |
if (GetMouse(0).bPressed) | |
{ | |
scores = "Your Score:\n" + std::to_string(score); | |
GameState = 4; | |
} | |
} else { | |
DrawSprite({ | |
10, | |
160 | |
}, & DontPostButton); | |
} | |
} | |
void DrawGameOver(float fElapsedTime) { | |
int animationIndex = time(0) % 5; | |
DrawSprite({ | |
0, | |
0 | |
}, & GameOver); | |
if (seed != "") { | |
DrawString({ | |
200, | |
230 | |
}, "Seed: " + seed); | |
} | |
DrawString({ | |
65, | |
85 | |
}, scores, olc::BLACK); | |
if (CheckBounds(GetMouseX(), GetMouseY(), 115, 200, 100, 50)) { | |
DrawSprite({ | |
115, | |
200 | |
}, & PlayAgainButtonPressed); | |
if (GetMouse(0).bPressed) | |
{ | |
scores = ""; | |
dirctionStage = 4; | |
GameState = 1; | |
MemoryObjects.clear(); | |
if (seed != "") { | |
srand(actualSeed); | |
} | |
CurrentMemoryObject.startingIndex = 0; | |
score = 0; | |
Value = 100; | |
valueReady = true; | |
EndTime = time(0); | |
name = "<BLANK>"; | |
MainSoundStarted = false; | |
RushSoundStarted = false; | |
start = time(0); | |
} | |
} else { | |
DrawSprite({ | |
115, | |
200 | |
}, & PlayAgainButton); | |
} | |
} | |
void DrawGame(float fElapsedTime) { | |
int remainingTime = EndTime - time(0); | |
#if defined(OLC_PLATFORM_EMSCRIPTEN) | |
if (!MainSoundStarted and(time(0) - start) > 2) { | |
engine.PlayWaveform( & mainWave); | |
MainSoundStarted = true; | |
} | |
if (!RushSoundStarted and remainingTime < 30) { | |
engine.StopAll(); | |
engine.PlayWaveform( & rushWave); | |
RushSoundStarted = true; | |
} | |
#endif | |
bool filled[320]; | |
int animationIndex = (time(0) % 4); | |
DrawSprite({ | |
0, | |
0 | |
}, & MainGameBackgrounds[animationIndex]); | |
if (seed != "") { | |
DrawString({ | |
200, | |
230 | |
}, "Seed: " + seed); | |
} | |
DrawRect({ | |
5, | |
5 | |
}, { | |
180, | |
225 | |
}, olc::BLACK); | |
for (int y = 0; y < 320; y += 1) { | |
DrawMemoryCell(y, olc::GREY); | |
filled[y] = false; | |
} | |
if (time(0) % 2 == 0 && valueReady) { | |
Value -= 10; | |
valueReady = false; | |
} | |
if (time(0) % 2 == 1) { | |
valueReady = true; | |
} | |
if (Value < 0) { | |
Value = 0; | |
} | |
int IndexToRemove = -1; | |
for (unsigned int i = 0; i < MemoryObjects.size(); i++) | |
{ | |
item obj = MemoryObjects[i]; | |
//printf("%d %d %d\n", time(0), obj.removalTime, obj.removalTime < time(0)); | |
if (obj.removalTime < time(0)) { | |
IndexToRemove = i; | |
} | |
if (obj.startingIndex >= 0) { | |
for (int x = 0; x < obj.size; x += 1) { | |
DrawMemoryCell(obj.startingIndex + x, obj.color); | |
filled[obj.startingIndex + x] = true; | |
} | |
} | |
} | |
int mouseIndex = GetMouseCellIndex(); | |
if (mouseIndex >= 0) { | |
bool NotOkay = false; | |
for (int x = 0; x < CurrentMemoryObject.size; x += 1) { | |
NotOkay = NotOkay || filled[mouseIndex + x]; | |
} | |
if (!NotOkay and!(mouseIndex + CurrentMemoryObject.size > 320)) { | |
for (int x = 0; x < CurrentMemoryObject.size; x += 1) { | |
DrawMemoryCell(mouseIndex + x, CurrentMemoryObject.color); | |
} | |
} | |
if (!NotOkay && GetMouse(0).bHeld and!(mouseIndex + CurrentMemoryObject.size > 320)) { | |
CurrentMemoryObject.startingIndex = mouseIndex; | |
CurrentMemoryObject.removalTime = time(0) + CurrentMemoryObject.lifespan; | |
MemoryObjects.push_back(CurrentMemoryObject); | |
score += Value; | |
for (int x = 0; x < CurrentMemoryObject.size; x += 1) { | |
DrawMemoryCell(mouseIndex + x, CurrentMemoryObject.color); | |
} | |
} | |
} | |
if (MemoryObjects.size() > 0 && IndexToRemove != -1) { | |
MemoryObjects.erase(MemoryObjects.begin() + IndexToRemove); | |
} | |
if (CurrentMemoryObject.startingIndex != -1) { | |
CurrentMemoryObject = MakeRandomItem(); | |
Value = 25 * CurrentMemoryObject.size; | |
} | |
if (EndTime - time(0) < 0) { | |
GameState = 3; | |
#if defined(OLC_PLATFORM_EMSCRIPTEN) | |
engine.StopAll(); | |
#endif | |
} | |
if (remainingTime < 30) { | |
DrawString({ | |
205, | |
200 | |
}, "Time Remaining", olc::BLACK); | |
DrawString({ | |
230, | |
210 | |
}, std::to_string(remainingTime) + "s", olc::RED); | |
} else { | |
DrawString({ | |
205, | |
200 | |
}, "Time Remaining", olc::BLACK); | |
DrawString({ | |
230, | |
210 | |
}, std::to_string((int) floor(remainingTime / 60)) + "m" + std::to_string(remainingTime % 60) + "s", olc::BLACK); | |
} | |
DrawString({ | |
205, | |
20 | |
}, "Next Size: " + std::to_string(CurrentMemoryObject.size), olc::BLACK); | |
DrawString({ | |
205, | |
50 | |
}, "Object Value", olc::BLACK); | |
DrawString({ | |
230, | |
60 | |
}, std::to_string(Value), olc::BLACK); | |
DrawString({ | |
205, | |
80 | |
}, "Current Score", olc::BLACK); | |
DrawString({ | |
230, | |
90 | |
}, std::to_string(score), olc::BLACK); | |
} | |
void DrawMemoryCell(int index, olc::Pixel color) { | |
int x = index % 16; | |
int y = floor(index / 16); | |
DrawRect({ | |
8 + (x * 11), | |
8 + (11 * y) | |
}, { | |
9, | |
9 | |
}, olc::BLACK); | |
FillRect({ | |
9 + (x * 11), | |
9 + (11 * y) | |
}, { | |
8, | |
8 | |
}, color); | |
} | |
int GetMouseCellIndex() { | |
for (int index = 0; index < 320; index += 1) { | |
int x = index % 16; | |
int y = floor(index / 16); | |
if (CheckBounds(GetMouseX(), GetMouseY(), 8 + (x * 11), 8 + (11 * y), 9, 9)) { | |
return index; | |
} | |
} | |
return -1; | |
} | |
int lifespans[12] = { | |
5, | |
10, | |
12, | |
14, | |
16, | |
18, | |
20, | |
22, | |
24, | |
26, | |
28, | |
30 | |
}; | |
item MakeRandomItem() { | |
item t; | |
t.color = RandomColor(); | |
t.size = (rand() % 24) + 1; | |
t.startingIndex = -1; | |
t.lifespan = lifespans[rand() % 12]; | |
return t; | |
} | |
olc::Pixel RandomColor() { | |
switch (rand() % 18) { | |
case 0: | |
return olc::RED; | |
case 1: | |
return olc::DARK_RED; | |
case 2: | |
return olc::VERY_DARK_RED; | |
case 3: | |
return olc::YELLOW; | |
case 4: | |
return olc::DARK_YELLOW; | |
case 5: | |
return olc::VERY_DARK_YELLOW; | |
case 6: | |
return olc::GREEN; | |
case 7: | |
return olc::DARK_GREEN; | |
case 8: | |
return olc::VERY_DARK_GREEN; | |
case 9: | |
return olc::CYAN; | |
case 10: | |
return olc::DARK_CYAN; | |
case 11: | |
return olc::VERY_DARK_CYAN; | |
case 12: | |
return olc::BLUE; | |
case 13: | |
return olc::DARK_BLUE; | |
case 14: | |
return olc::VERY_DARK_BLUE; | |
case 15: | |
return olc::MAGENTA; | |
case 16: | |
return olc::DARK_MAGENTA; | |
case 17: | |
return olc::VERY_DARK_MAGENTA; | |
} | |
return olc::BLACK; | |
} | |
void DrawDirections(float fElapsedTime) { | |
DrawSprite({ | |
0, | |
0 | |
}, & DirectionsBackground); | |
DrawString({ | |
280, | |
220 | |
}, std::to_string(dirctionStage) + "/4", olc::BLACK); | |
DrawRect({ | |
5, | |
5 | |
}, { | |
180, | |
225 | |
}, olc::BLACK); | |
for (int y = 0; y < 20; y += 1) { | |
for (int x = 0; x < 16; x += 1) { | |
DrawRect({ | |
8 + (x * 11), | |
8 + (11 * y) | |
}, { | |
9, | |
9 | |
}, olc::BLACK); | |
FillRect({ | |
9 + (x * 11), | |
9 + (11 * y) | |
}, { | |
8, | |
8 | |
}, olc::GREY); | |
} | |
} | |
if (dirctionStage == 0 || dirctionStage == 1) { | |
DrawString({ | |
205, | |
20 | |
}, "Next Size: " + std::to_string(9), olc::BLACK); | |
DrawString({ | |
205, | |
50 | |
}, "Object Value", olc::BLACK); | |
DrawString({ | |
230, | |
60 | |
}, std::to_string(25 * 9), olc::BLACK); | |
DrawString({ | |
205, | |
80 | |
}, "Current Score", olc::BLACK); | |
DrawString({ | |
230, | |
90 | |
}, std::to_string(0), olc::BLACK); | |
} | |
if (dirctionStage == 2) { | |
DrawString({ | |
205, | |
20 | |
}, "Next Size: " + std::to_string(5), olc::BLACK); | |
DrawString({ | |
205, | |
50 | |
}, "Object Value", olc::BLACK); | |
DrawString({ | |
230, | |
60 | |
}, std::to_string(5 * 25), olc::BLACK); | |
DrawString({ | |
205, | |
80 | |
}, "Current Score", olc::BLACK); | |
DrawString({ | |
230, | |
90 | |
}, std::to_string(25 * 9), olc::BLACK); | |
} | |
if (dirctionStage == 3) { | |
DrawString({ | |
205, | |
20 | |
}, "Next Size: " + std::to_string(5), olc::BLACK); | |
DrawString({ | |
205, | |
50 | |
}, "Object Value", olc::BLACK); | |
DrawString({ | |
230, | |
60 | |
}, std::to_string(5 * 25), olc::BLACK); | |
DrawString({ | |
205, | |
80 | |
}, "Current Score", olc::BLACK); | |
DrawString({ | |
230, | |
90 | |
}, std::to_string(25 * 9), olc::BLACK); | |
} | |
if (dirctionStage == 4) { | |
DrawString({ | |
205, | |
20 | |
}, "Next Size: " + std::to_string(3), olc::BLACK); | |
DrawString({ | |
205, | |
50 | |
}, "Object Value", olc::BLACK); | |
DrawString({ | |
230, | |
60 | |
}, std::to_string(3 * 25), olc::BLACK); | |
DrawString({ | |
205, | |
80 | |
}, "Current Score", olc::BLACK); | |
DrawString({ | |
230, | |
90 | |
}, std::to_string(25 * 14), olc::BLACK); | |
} | |
if (dirctionStage == 2 || dirctionStage == 3) { | |
for (int x = 0; x < 9; x += 1) { | |
DrawMemoryCell(0 + x, olc::BLUE); | |
} | |
} | |
if (dirctionStage == 4) { | |
for (int x = 0; x < 9; x += 1) { | |
DrawMemoryCell(0 + x, olc::BLUE); | |
} | |
for (int x = 0; x < 5; x += 1) { | |
DrawMemoryCell(9 + x, olc::RED); | |
} | |
} | |
if (dirctionStage < 4) { | |
if (CheckBounds(GetMouseX(), GetMouseY(), 210, 110, 100, 50)) { | |
DrawSprite({ | |
210, | |
110 | |
}, & NextButtonPressed); | |
if (GetMouse(0).bPressed) | |
{ | |
dirctionStage += 1; | |
} | |
} else { | |
DrawSprite({ | |
210, | |
110 | |
}, & NextButton); | |
} | |
} else { | |
if (CheckBounds(GetMouseX(), GetMouseY(), 210, 110, 100, 50)) { | |
DrawSprite({ | |
210, | |
110 | |
}, & StartButtonPressed); | |
if (GetMouse(0).bPressed) | |
{ | |
dirctionStage += 1; | |
if (dirctionStage > 4) { | |
GameState = 2; | |
EndTime = time(0) + 180; | |
} | |
} | |
} else { | |
DrawSprite({ | |
210, | |
110 | |
}, & StartButton); | |
} | |
} | |
if (dirctionStage > 0) { | |
if (CheckBounds(GetMouseX(), GetMouseY(), 210, 165, 100, 50)) { | |
DrawSprite({ | |
210, | |
165 | |
}, & BackButtonPressed); | |
if (GetMouse(0).bPressed) | |
{ | |
dirctionStage -= 1; | |
} | |
} else { | |
DrawSprite({ | |
210, | |
165 | |
}, & BackButton); | |
} | |
} | |
DrawSprite({ | |
0, | |
0 | |
}, & Directions[dirctionStage]); | |
switch (dirctionStage) { | |
case 0: | |
DrawString({ | |
30, | |
20 | |
}, "Current Object Size\nHow many cells\nthe object takes up\n\nCurrent point value\nof the object.\n\nYour Score.", olc::BLACK); | |
return; | |
case 1: | |
DrawString({ | |
163, | |
17 | |
}, "These are cells\nthey hold objects.\n\nThere are 16\ncells per row.", olc::BLACK); | |
return; | |
case 2: | |
DrawString({ | |
127, | |
44 | |
}, "This is an Object.\nThe goal of the game\nis to place as many\nas you can to get\nthere value added to\nyour score.\nThis Object is\n9 cells in size.", olc::BLACK); | |
return; | |
case 3: | |
DrawString({ | |
125, | |
44 | |
}, "You place Objects by\nclicking cells.\nOver time the value\nof Objects decrease.\nObjects will\nrandomly be 'freed'\nover time giving you\nmore space.", olc::BLACK); | |
return; | |
case 4: | |
DrawString({ | |
45, | |
64 | |
}, "That is all there\nis to the game.\nYou have 3 min to\nget as high of\nscore as possible.", olc::BLACK); | |
return; | |
} | |
} | |
std::string GetNumKey() { | |
if (GetKey(olc::Key::NP0).bPressed || GetKey(olc::Key::K0).bPressed) return "0"; | |
if (GetKey(olc::Key::NP1).bPressed || GetKey(olc::Key::K1).bPressed) return "1"; | |
if (GetKey(olc::Key::NP2).bPressed || GetKey(olc::Key::K2).bPressed) return "2"; | |
if (GetKey(olc::Key::NP3).bPressed || GetKey(olc::Key::K3).bPressed) return "3"; | |
if (GetKey(olc::Key::NP4).bPressed || GetKey(olc::Key::K4).bPressed) return "4"; | |
if (GetKey(olc::Key::NP5).bPressed || GetKey(olc::Key::K5).bPressed) return "5"; | |
if (GetKey(olc::Key::NP6).bPressed || GetKey(olc::Key::K6).bPressed) return "6"; | |
if (GetKey(olc::Key::NP7).bPressed || GetKey(olc::Key::K7).bPressed) return "7"; | |
if (GetKey(olc::Key::NP8).bPressed || GetKey(olc::Key::K8).bPressed) return "8"; | |
if (GetKey(olc::Key::NP9).bPressed || GetKey(olc::Key::K9).bPressed) return "9"; | |
if (GetKey(olc::Key::BACK).bPressed) return "BACK"; | |
return ""; | |
} | |
std::string GetTypedKey() { | |
if (GetKey(olc::Key::A).bPressed) return "A"; | |
if (GetKey(olc::Key::B).bPressed) return "B"; | |
if (GetKey(olc::Key::C).bPressed) return "C"; | |
if (GetKey(olc::Key::D).bPressed) return "D"; | |
if (GetKey(olc::Key::E).bPressed) return "E"; | |
if (GetKey(olc::Key::F).bPressed) return "F"; | |
if (GetKey(olc::Key::G).bPressed) return "G"; | |
if (GetKey(olc::Key::H).bPressed) return "H"; | |
if (GetKey(olc::Key::I).bPressed) return "I"; | |
if (GetKey(olc::Key::J).bPressed) return "J"; | |
if (GetKey(olc::Key::K).bPressed) return "K"; | |
if (GetKey(olc::Key::L).bPressed) return "L"; | |
if (GetKey(olc::Key::M).bPressed) return "M"; | |
if (GetKey(olc::Key::N).bPressed) return "N"; | |
if (GetKey(olc::Key::O).bPressed) return "O"; | |
if (GetKey(olc::Key::P).bPressed) return "P"; | |
if (GetKey(olc::Key::Q).bPressed) return "Q"; | |
if (GetKey(olc::Key::R).bPressed) return "R"; | |
if (GetKey(olc::Key::S).bPressed) return "S"; | |
if (GetKey(olc::Key::T).bPressed) return "T"; | |
if (GetKey(olc::Key::U).bPressed) return "U"; | |
if (GetKey(olc::Key::V).bPressed) return "V"; | |
if (GetKey(olc::Key::W).bPressed) return "W"; | |
if (GetKey(olc::Key::X).bPressed) return "X"; | |
if (GetKey(olc::Key::Y).bPressed) return "Y"; | |
if (GetKey(olc::Key::Z).bPressed) return "Z"; | |
if (GetKey(olc::Key::NP0).bPressed || GetKey(olc::Key::K0).bPressed) return "0"; | |
if (GetKey(olc::Key::NP1).bPressed || GetKey(olc::Key::K1).bPressed) return "1"; | |
if (GetKey(olc::Key::NP2).bPressed || GetKey(olc::Key::K2).bPressed) return "2"; | |
if (GetKey(olc::Key::NP3).bPressed || GetKey(olc::Key::K3).bPressed) return "3"; | |
if (GetKey(olc::Key::NP4).bPressed || GetKey(olc::Key::K4).bPressed) return "4"; | |
if (GetKey(olc::Key::NP5).bPressed || GetKey(olc::Key::K5).bPressed) return "5"; | |
if (GetKey(olc::Key::NP6).bPressed || GetKey(olc::Key::K6).bPressed) return "6"; | |
if (GetKey(olc::Key::NP7).bPressed || GetKey(olc::Key::K7).bPressed) return "7"; | |
if (GetKey(olc::Key::NP8).bPressed || GetKey(olc::Key::K8).bPressed) return "8"; | |
if (GetKey(olc::Key::NP9).bPressed || GetKey(olc::Key::K9).bPressed) return "9"; | |
if (GetKey(olc::Key::BACK).bPressed) return "BACK"; | |
return ""; | |
} | |
}; | |
bool CheckBounds(int mouseX, int mouseY, int left, int top, int width, int height) { | |
return (mouseY > top && mouseY < top + height) && (mouseX > left && mouseX < left + width); | |
} | |
int main() | |
{ | |
Example demo; | |
if (demo.Construct(320, 240, 4, 4)) | |
demo.Start(); | |
return 0; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment