Junior programmers bots

Makefile

@@ -19,7 +19,7 @@ else
 	CPP=g++
 endif
 ifeq ($(DEBUG),1)
-	CPPFLAGS+=-g -Og -D_DEBUG
+	CPPFLAGS+=-g -O0 -D_DEBUG
 else
 	CPPFLAGS+=-flto -O3
 endif

include/debuggers.h

@@ -4,6 +4,7 @@
 #include "bug.h"
 #include "olcPGEX_Sound.h"
 #include "olcPixelGameEngine.h"
+#include "programmer.h"
 #include "player.h"
 #include <vector>
 #include <string>
@@ -11,8 +12,7 @@
 namespace pabloader {
 class Debuggers : public olc::PixelGameEngine {
 private:
-    Player* player;
-    std::vector<Bug*> bugs;
+    std::vector<Programmer*> programmers;
     uint32_t bugsCatched = 0;
     uint32_t bugsMissed = 0;
 
@@ -33,11 +33,14 @@ public:
     int GameScreenHeight() { return ScreenHeight() - linesOfCode * 10; };
 
 private:
+    void SpawnProgrammer();
     void SpawnBug();
     Bug* CreateBug();
     bool GameOver();
 
 public:
+    std::vector<Bug*> bugs;
+
     olc::ResourcePack pack;
     olc::Sprite playerSprite;
     olc::Sprite enemiesSprite;

include/entity.h

@@ -3,8 +3,9 @@
 
 #include "olcPGEX_Graphics2D.h"
 #include "olcPixelGameEngine.h"
+#include <cmath>
 
-namespace pabloader {    
+namespace pabloader {
 class Debuggers;
 
 class Entity {
@@ -18,10 +19,15 @@ protected:
 public:
     Entity(Debuggers* game_);
     virtual ~Entity(){};
-    
+
     virtual void Update(float dt) = 0;
     virtual void Draw() = 0;
+
+    float GetX() { return x; }
+    float GetY() { return y; }
+
     bool Collides(Entity* entity);
+    float Dist(Entity* entity) { return std::hypot(x - entity->x, y - entity->y); }
 };
 }
 

include/player.h

@@ -1,25 +1,15 @@
 #ifndef PLAYER_H
 #define PLAYER_H
 
-#include "entity.h"
 #include "olcPGE_Common.h"
+#include "programmer.h"
 
 namespace pabloader {
 
-class Player : public Entity {
-private:
-    uint8_t tile = 0;
-    uint8_t skin = 0;
-    uint32_t tileCounter = 0;
-    bool onGround = false;
-
+class Player : public Programmer {
 public:
     Player(Debuggers* game);
-    void Update(float dt) override;
-    void Draw() override;
-    bool IsOnGround() { return onGround; }
-    uint8_t GetSkin() { return skin; }
-    void UpgradeLevel() { skin = std::min(skin + 1, 3); }
+    void Think() override;
 };
 }
 

include/programmer.h

@@ -0,0 +1,31 @@
+#ifndef PROGRAMMER_H
+#define PROGRAMMER_H
+
+#include "entity.h"
+#include "olcPGE_Common.h"
+
+namespace pabloader {
+
+class Programmer : public Entity {
+protected:
+    uint8_t tile = 0;
+    uint32_t tileCounter = 0;
+    uint8_t skin = 0;
+    bool onGround = false;
+    bool doJump = false;
+    bool walkLeft = false;
+    bool walkRight = false;
+    bool moveDown = false;
+
+public:
+    Programmer(Debuggers* game);
+    virtual void Think();
+    virtual void Update(float dt) override;
+    virtual void Draw() override;
+    bool IsOnGround() { return onGround; }
+    uint8_t GetSkin() { return skin; }
+    void UpgradeLevel() { skin = std::min(skin + 1, 2); }
+};
+}
+
+#endif

src/debuggers.cpp

@@ -1,6 +1,8 @@
 #include "debuggers.h"
 #include <cmath>
 #include <iostream>
+#include <random>
+#include <ctime>
 
 namespace pabloader {
 std::string& rtrim(std::string& str, const std::string& chars = "\t\n\v\f\r ")
@@ -12,6 +14,7 @@ std::string& rtrim(std::string& str, const std::string& chars = "\t\n\v\f\r ")
 bool Debuggers::OnUserCreate()
 {
     SetPixelMode(olc::Pixel::MASK);
+    std::srand(std::time(0));
 
     if (!olc::SOUND::InitialiseAudio()) {
         std::cerr << "Cannot init audio" << std::endl;
@@ -88,7 +91,9 @@ bool Debuggers::OnUserCreate()
 
     // Creating entities
 
-    player = new Player(this);
+    auto player = new Player(this);
+    programmers.push_back(player);
+
     return true;
 }
 
@@ -103,32 +108,19 @@ bool Debuggers::OnUserUpdate(float fElapsedTime)
 
     DrawSprite(0, 0, &backgroundSprite);
 
-    DrawString(1, 1, "A,S,D - move; SPACE - jump", olc::CYAN);
-    DrawString(1, 10, "Don't let the bugs destroy your code!", olc::YELLOW);
-
-    player->Update(fElapsedTime);
-    player->Draw();
-
     uint32_t bugsSize = bugs.size();
 
-    if (bugsSize == 0 && player->IsOnGround()) {
-        SpawnBug();
-    }
-
-    if (bugsCatched >= bugsSize * 25 && player->GetSkin() < bugsSize) {
-        player->UpgradeLevel();
-        SpawnBug();
-    }
-
     for (auto bug : bugs) {
         if (bug->IsActive()) {
             bug->Update(fElapsedTime);
             bug->Draw();
-            if (player->Collides(bug)) {
-                bugsCatched++;
-                bug->Kill();
-                olc::SOUND::PlaySample(bugCatchSample);
-                SpawnBug();
+            for (auto& programmer : programmers) {
+                if (programmer->Collides(bug)) {
+                    bugsCatched++;
+                    bug->Kill();
+                    olc::SOUND::PlaySample(bugCatchSample);
+                    SpawnBug();
+                }
             }
         } else {
             bugsMissed++;
@@ -139,21 +131,45 @@ bool Debuggers::OnUserUpdate(float fElapsedTime)
         }
     }
 
-    linesOfCode = (sourceCode.size() * 4 / totalLines)  +1;
+    linesOfCode = (sourceCode.size() * 4 / totalLines) + 1;
+
+    for (auto it = programmers.rbegin(); it != programmers.rend(); it++) {
+        auto& programmer = *it;
+        programmer->Think();
+        programmer->Update(fElapsedTime);
+        programmer->Draw();
+    }
+
+    Player* player = dynamic_cast<Player*>(programmers.at(0));
+
+    if (bugsSize == 0 && player->IsOnGround()) {
+        SpawnBug();
+    }
+
+    if (bugsCatched >= bugsSize * (15 * programmers.size()) && player->GetSkin() < bugsSize) {
+        player->UpgradeLevel();
+        SpawnBug();
+        SpawnProgrammer();
+    }
 
 #ifdef _DEBUG
     DrawString(1, 37, "Bugs: " + std::to_string(bugs.size()));
     if (GetKey(olc::B).bPressed) {
         SpawnBug();
     }
+    if (GetKey(olc::P).bPressed) {
+        SpawnProgrammer();
+    }
 #endif
+    DrawString(1, 1, "A,S,D - move; SPACE - jump", olc::CYAN);
+    DrawString(1, 10, "Don't let the bugs destroy your code!", olc::YELLOW);
     DrawString(1, 19, "Bugs catched: " + std::to_string(bugsCatched));
     DrawString(1, 28, "Bugs missed: " + std::to_string(bugsMissed));
 
     int y = GameScreenHeight();
     FillRect(0, y - 1, ScreenWidth(), ScreenHeight() - y + 1, olc::VERY_DARK_GREY);
 
-    for (auto line : sourceCode) {
+    for (auto& line : sourceCode) {
         DrawString(1, y, line);
         y += 10;
         if (y >= ScreenHeight())
@@ -174,18 +190,18 @@ bool Debuggers::GameOver()
     return true;
 }
 
-bool Debuggers::OnUserDestroy()
-{
-    olc::SOUND::DestroyAudio();
-    return true;
-}
-
 void Debuggers::SpawnBug()
 {
     auto bug = CreateBug();
     bug->ResetPosition();
 }
 
+void Debuggers::SpawnProgrammer()
+{
+    auto programmer = new Programmer(this);
+    programmers.push_back(programmer);
+}
+
 Bug* Debuggers::CreateBug()
 {
     for (auto bug : bugs) {
@@ -196,4 +212,10 @@ Bug* Debuggers::CreateBug()
     bugs.push_back(bug);
     return bug;
 }
+
+bool Debuggers::OnUserDestroy()
+{
+    olc::SOUND::DestroyAudio();
+    return true;
+}
 }

src/entity.cpp

@@ -14,4 +14,5 @@ bool Entity::Collides(Entity* entity)
     bool collidesY = (y - h / 2 < entity->y + entity->h / 2) && (entity->y - entity->h / 2 < y + h / 2);
     return collidesX && collidesY;
 }
+
 }

src/player.cpp

@@ -4,31 +4,17 @@
 #include <iostream>
 
 namespace pabloader {
-Player::Player(Debuggers* game_)
-    : Entity(game_)
+Player::Player(Debuggers* game)
+    : Programmer(game)
 {
-    w = game->playerSprite.width / 4;
-    h = game->playerSprite.height / 4;
-    x = (game->ScreenWidth() - w) / 2;
-    y = game->GameScreenHeight() / 2;
 }
 
-void Player::Update(float dt)
+void Player::Think()
 {
-    x += xv * dt;
-    y += yv * dt;
-
-    xv *= 1 - 0.2 * dt;
-
-    if (!onGround) {
-        yv += (70 + skin * 20) * dt;
-        yv *= 1 - 0.05 * dt;
-    } else {
-        xv *= 1 - 0.5 * dt;
-    }
-
-    transform.Reset();
-
+    doJump = game->GetKey(olc::SPACE).bHeld;
+    walkLeft = game->GetKey(olc::A).bHeld;
+    walkRight = game->GetKey(olc::D).bHeld;
+    moveDown = game->GetKey(olc::S).bHeld;
 #ifdef _DEBUG
     // game->DrawString(1, 19, std::to_string(x) + " " + std::to_string(y));
     // game->DrawString(1, 28, std::to_string(xv) + " " + std::to_string(yv));
@@ -36,88 +22,6 @@ void Player::Update(float dt)
     if (game->GetKey(olc::J).bPressed) {
         skin = (skin + 1) % 4;
     }
-#endif
-    bool userInput = false;
-
-    if (game->GetKey(olc::SPACE).bHeld && onGround) {
-        yv = -100;
-        userInput = true;
-    }
-
-    if (game->GetKey(olc::A).bHeld) {
-        xv -= (100 + skin * 50) * dt;
-        userInput = true;
-    }
-
-    if (game->GetKey(olc::D).bHeld) {
-        xv += (100 + skin * 50) * dt;
-        userInput = true;
-    }
-
-    if (game->GetKey(olc::S).bHeld) {
-        if (!onGround) {
-            yv += (100 + skin * 50) * dt;
-        }
-        userInput = true;
-    }
-
-    if (x > game->ScreenWidth() - w / 2) {
-        xv *= -0.3;
-        x = game->ScreenWidth() - w / 2;
-        olc::SOUND::PlaySample(game->playerFallSample);
-    }
-
-    if (x < w / 2) {
-        xv *= -0.3;
-        x = w / 2;
-        olc::SOUND::PlaySample(game->playerFallSample);
-    }
-
-    if (y > game->GameScreenHeight() - h / 2) {
-        yv *= -0.3;
-
-        if (std::abs(yv) < 2) {
-            yv = 0;
-        }
-        y = game->GameScreenHeight() - h / 2;
-    }
-
-    bool newOnGround = y >= game->GameScreenHeight() - h / 2;
-    if (newOnGround && !onGround) {
-        olc::SOUND::PlaySample(game->playerFallSample);
-    }
-    onGround = newOnGround;
-
-    if (onGround) {
-        tile = 2;
-        tileCounter = static_cast<uint32_t>(0.1 / dt);
-    } else if (tileCounter <= 0) {
-        tile = 0;
-    } else {
-        tileCounter--;
-    }
-
-    if (!userInput && std::abs(xv) < 2) {
-        xv = 0;
-    }
-    if (xv < 0) {
-        transform.Scale(-1, 1);
-    }
-    transform.Translate(x, y);
-}
-
-void Player::Draw()
-{
-    int xOff = xv < 0 ? -1 : 0;
-    if (std::abs(xv) < 1) {
-        olc::GFX2D::DrawPartialSprite(&game->playerSprite, skin * w + xOff, h + tile * h, w, h, transform, true);
-    } else {
-        olc::GFX2D::DrawPartialSprite(&game->playerSprite, skin * w + xOff, 0 + tile * h, w, h, transform, true);
-    }
-#ifdef _DEBUG
-    float x, y;
-    transform.Forward(0, 0, x, y);
-    game->DrawRect((int)x - w / 2, (int)y - h / 2, w, h, olc::RED);
 #endif
 }
 }

src/programmer.cpp

@@ -0,0 +1,138 @@
+#include "programmer.h"
+#include "debuggers.h"
+#include "olcPGEX_Sound.h"
+#include <iostream>
+
+namespace pabloader {
+Programmer::Programmer(Debuggers* game)
+    : Entity(game)
+{
+    w = game->playerSprite.width / 4;
+    h = game->playerSprite.height / 4;
+    x = (game->ScreenWidth() - w) / 2;
+    y = game->GameScreenHeight() / 2;
+}
+
+void Programmer::Think()
+{
+    Bug* closest = nullptr;
+    float dist = 1e100;
+    for (auto bug : game->bugs) {
+        float d = bug->Dist(this);
+        if (d < dist && bug->GetY() > 0) {
+            dist = d;
+            closest = bug;
+        }
+    }
+
+    if (closest != nullptr) {
+        doJump = closest->GetY() < y;
+        moveDown = closest->GetY() > y;
+        walkLeft = closest->GetX() < x;
+        walkRight = closest->GetX() > x;
+    } else {
+        doJump = false;
+        walkLeft = false;
+        walkRight = false;
+        moveDown = false;
+    }
+}
+
+void Programmer::Update(float dt)
+{
+    x += xv * dt;
+    y += yv * dt;
+
+    xv *= 1 - 0.2 * dt;
+
+    if (!onGround) {
+        yv += (70 + skin * 30) * dt;
+        yv *= 1 - 0.05 * dt;
+    } else {
+        xv *= 1 - 0.5 * dt;
+    }
+
+    transform.Reset();
+
+    bool userInput = false;
+
+    if (doJump && onGround) {
+        yv = -100 - 50 * skin;
+        userInput = true;
+    }
+
+    if (walkLeft) {
+        xv -= (150 + skin * 50) * dt;
+        userInput = true;
+    }
+
+    if (walkRight) {
+        xv += (150 + skin * 50) * dt;
+        userInput = true;
+    }
+
+    if (moveDown) {
+        if (!onGround) {
+            yv += (150 + skin * 50) * dt;
+        }
+        userInput = true;
+    }
+
+    if (x > game->ScreenWidth() - w / 2) {
+        xv *= -0.3;
+        x = game->ScreenWidth() - w / 2;
+        olc::SOUND::PlaySample(game->playerFallSample);
+    }
+
+    if (x < w / 2) {
+        xv *= -0.3;
+        x = w / 2;
+        olc::SOUND::PlaySample(game->playerFallSample);
+    }
+
+    if (y > game->GameScreenHeight() - h / 2) {
+        yv *= -0.3;
+
+        if (std::abs(yv) < 2) {
+            yv = 0;
+        }
+        y = game->GameScreenHeight() - h / 2;
+    }
+
+    bool newOnGround = y >= game->GameScreenHeight() - h / 2;
+    if (newOnGround && !onGround) {
+        olc::SOUND::PlaySample(game->playerFallSample);
+    }
+    onGround = newOnGround;
+
+    if (onGround) {
+        tile = 2;
+        tileCounter = static_cast<uint32_t>(0.1 / dt);
+    } else if (tileCounter <= 0) {
+        tile = 0;
+    } else {
+        tileCounter--;
+    }
+
+    if (!userInput && std::abs(xv) < 2) {
+        xv = 0;
+    }
+    if (xv < 0) {
+        transform.Scale(-1, 1);
+    }
+    transform.Translate(x, y);
+}
+
+void Programmer::Draw()
+{
+    int xOff = xv < 0 ? -1 : 0;
+    if (std::abs(xv) < 1) {
+        olc::GFX2D::DrawPartialSprite(&game->playerSprite, skin * w + xOff, h + tile * h, w, h, transform, true);
+    } else {
+        olc::GFX2D::DrawPartialSprite(&game->playerSprite, skin * w + xOff, 0 + tile * h, w, h, transform, true);
+    }
+#ifdef _DEBUG
+    game->DrawRect(x - w / 2, y - h / 2, w, h, olc::GREEN);
+#endif
+}
+}