igra

src/game/agame/background.cpp

@@ -1,19 +1,37 @@
 #include <game/agame/background.hpp>
+#include <game/agame/player.hpp>
 #include <window/window.hpp>
 #include <object/camera.hpp>
 #include <algorithm>
+#include <utils.hpp>
 
 namespace Game::AGame {
     void Background::start() {
+        mSeaTex = std::make_shared<Game::Renderer::Texture>("../resources/l3sea.png", SDL_GetRenderer(Window::Window::getSDLWindowBackend()), "seaTex");
         mEnemyTex = std::make_shared<Game::Renderer::Texture>("../resources/l3enemy.png", SDL_GetRenderer(Window::Window::getSDLWindowBackend()), "enemyTex");
         mTrashTex = std::make_shared<Game::Renderer::Texture>("../resources/l3trash.png", SDL_GetRenderer(Window::Window::getSDLWindowBackend()), "trashTex");
+        mFriendlyTex = std::make_shared<Game::Renderer::Texture>("../resources/l3friendly.png", SDL_GetRenderer(Window::Window::getSDLWindowBackend()), "friendlyTex");
         GameManager::setSharedData("enemyActiveCount", 0);
+        GameManager::setSharedData("trashActiveCount", 0);
+        GameManager::setSharedData("friendlyActiveCount", 0);
+        GameManager::setSharedData("gameStage", 1);
+        GameManager::setSharedData("gameWon", false);
+        GameManager::setSharedData("gameLost", false);
 
         mZIndex = -1; // Ensure background renders behind other entities
         mTex->setTiled(true); // Set the background texture to be tiled
+        if (mSeaTex) {
+            mSeaTex->setTiled(true);
+        }
         mTiledScale = 0.5f;
         SDL_GetWindowSizeInPixels(Window::Window::getSDLWindowBackend(), &mW, &mH);
 
+        // Land boundary: left 1/3 of map in centered coordinates
+        // For 1280px window: -640 (left) + 426.67 (1/3) = -213.33
+        mLandBoundaryX = -static_cast<float>(mW) / 2.f + static_cast<float>(mW) / 3.f;
+        GameManager::setSharedData("terrainLandBoundaryX", mLandBoundaryX);
+        GameManager::setSharedData("enemyRevealRadius", 260.f);
+
         mTransform.scaleX *= 10.f;
         mTransform.scaleY *= 10.f;
 
@@ -21,72 +39,147 @@ namespace Game::AGame {
         mTransform.y -= mTex->getHeight() * mTransform.adjustedScaleY() / 2.f;
 
         LOG("W: " << mW << " H: " << mH);
+        spawnLevel(1);
+    }
 
-        mTransform.x = mW / 2.f - (mW / 3.f);
-        mTransform.y = -mH;
+    void Background::render(Game::Renderer::Renderer* renderer, Game::Renderer::RendererConfig config) {
+        if (!renderer || !mTex || !mSeaTex) {
+            return;
+        }
+
+        const float worldLeft = -static_cast<float>(mW) / 2.f;
+        const float worldRight = static_cast<float>(mW) / 2.f;
+        const float worldTop = -static_cast<float>(mH) / 2.f;
+        const float worldBottom = static_cast<float>(mH) / 2.f;
+
+        const float landLeft = worldLeft;
+        const float landRight = mLandBoundaryX;
+        const float seaLeft = mLandBoundaryX;
+        const float seaRight = worldRight;
+
+        auto drawSection = [&](const std::shared_ptr<Game::Renderer::Texture>& tex, float startX, float endX) {
+            if (!tex) {
+                return;
+            }
+
+            float tileW = 0.f;
+            float tileH = 0.f;
+            SDL_GetTextureSize(tex->getSDLTexture(), &tileW, &tileH);
+            tileW *= mTiledScale;
+            tileH *= mTiledScale;
+            if (tileW <= 0.f || tileH <= 0.f) {
+                return;
+            }
+
+            const float screenStartX = startX - config.camX + config.screenW / 2.f;
+            const float screenEndX = endX - config.camX + config.screenW / 2.f;
+            const float screenStartY = worldTop - config.camY + config.screenH / 2.f;
+            const float screenEndY = worldBottom - config.camY + config.screenH / 2.f;
+
+            for (float x = screenStartX; x < screenEndX; x += tileW) {
+                for (float y = screenStartY; y < screenEndY; y += tileH) {
+                    SDL_FRect dst{ x, y, tileW, tileH };
+                    SDL_RenderTexture(renderer->getSDLRenderer(), tex->getSDLTexture(), nullptr, &dst);
+                }
+            }
+        };
+
+        drawSection(mTex, landLeft, landRight);
+        drawSection(mSeaTex, seaLeft, seaRight);
+    }
+
+    void Background::spawnFriendly(int stage, int count) {
+        const float viewLeft = -mW / 2.f;
+        const float viewTop = -mH / 2.f;
+        const float viewBottom = mH / 2.f;
+
+        Object::Transform tS;
+        tS.rotation = 0.f;
+        tS.scaleX = 6.f;
+        tS.scaleY = 6.f;
+
+        const float halfFriendlyW = mFriendlyTex->getWidth() * tS.adjustedScaleX() / 2.f;
+        const float halfFriendlyH = mFriendlyTex->getHeight() * tS.adjustedScaleY() / 2.f;
+        for (int i = 0; i < count; ++i) {
+            tS.x = static_cast<float>(Utils::getUtils().rirng32(static_cast<int>(viewLeft + halfFriendlyW + 25.f), static_cast<int>(mLandBoundaryX - halfFriendlyW - 25.f)));
+            tS.y = static_cast<float>(Utils::getUtils().rirng32(static_cast<int>(viewTop + halfFriendlyH + 100.f), static_cast<int>(viewBottom - halfFriendlyH - 100.f)));
+            GameManager::instantiateEntity(std::make_unique<AGame::Friendly>("Friendly" + std::to_string(stage) + "_" + std::to_string(i + 1), mFriendlyTex, tS));
+        }
+    }
+
+    void Background::spawnLevel(int stage) {
+        const float viewLeft = -mW / 2.f;
+        const float viewRight = mW / 2.f;
+        const float viewTop = -mH / 2.f;
+        const float viewBottom = mH / 2.f;
+
+        const int enemyCount = 2 + stage * 2;
+        const int trashCount = 4 + stage * 3;
+        const int friendlyCount = 1 + (stage - 1);
+
+        GameManager::setSharedData("gameStage", stage);
+        GameManager::setSharedData("enemyActiveCount", enemyCount);
+        GameManager::setSharedData("trashActiveCount", trashCount);
+        GameManager::setSharedData("friendlyActiveCount", friendlyCount);
+
+        if (stage > 1) {
+            auto* player = GameManager::getEntityByName<Player>("Player");
+            if (player) {
+                player->respawnRandomSea(mLandBoundaryX);
+            }
+        }
+
+        Object::Transform tS;
+        tS.rotation = 0.f;
+
+        tS.scaleX = 7.f;
+        tS.scaleY = 7.f;
+        const float halfEnemyW = mEnemyTex->getWidth() * tS.adjustedScaleX() / 2.f;
+        const float halfEnemyH = mEnemyTex->getHeight() * tS.adjustedScaleY() / 2.f;
+        for (int i = 0; i < enemyCount; ++i) {
+            tS.x = static_cast<float>(Utils::getUtils().rirng32(static_cast<int>(viewLeft + halfEnemyW + 25.f), static_cast<int>(mLandBoundaryX - halfEnemyW - 25.f)));
+            tS.y = static_cast<float>(Utils::getUtils().rirng32(static_cast<int>(viewTop + halfEnemyH + 100.f), static_cast<int>(viewBottom - halfEnemyH - 100.f)));
+            GameManager::instantiateEntity(std::make_unique<AGame::Enemy>("Enemy" + std::to_string(stage) + "_" + std::to_string(i + 1), mEnemyTex, tS));
+        }
+
+        tS.scaleX = 5.5f;
+        tS.scaleY = 5.5f;
+        const float halfTrashW = mTrashTex->getWidth() * tS.adjustedScaleX() / 2.f;
+        const float halfTrashH = mTrashTex->getHeight() * tS.adjustedScaleY() / 2.f;
+        for (int i = 0; i < trashCount; ++i) {
+            tS.x = static_cast<float>(Utils::getUtils().rirng32(static_cast<int>(mLandBoundaryX + halfTrashW + 25.f), static_cast<int>(viewRight - halfTrashW - 25.f)));
+            tS.y = static_cast<float>(Utils::getUtils().rirng32(static_cast<int>(viewTop + halfTrashH + 100.f), static_cast<int>(viewBottom - halfTrashH - 100.f)));
+            GameManager::instantiateEntity(std::make_unique<AGame::Trash>("Trash" + std::to_string(stage) + "_" + std::to_string(i + 1), mTrashTex, tS));
+        }
+
+        spawnFriendly(stage, friendlyCount);
     }
 
     void Background::update(float deltaTime) {
-        mEnemySpawnTimer += deltaTime;
+        (void)deltaTime;
 
-        int cnt = GameManager::getSharedData<int>("enemyActiveCount");
-        if (mEnemySpawnTimer >= mTimeToSpawn && cnt < 5) {
-            mEnemySpawnTimer = 0.f; // RESET
-            GameManager::setSharedData("enemyActiveCount", cnt + 1);
-            // Spawn Enemy on grass
-            Object::Transform tS;
-            tS.scaleY = 7.f;
-            tS.scaleX = 7.f;
-            tS.rotation = 0.f;
+        const int enemyCount = GameManager::getSharedData<int>("enemyActiveCount");
+        const int trashCount = GameManager::getSharedData<int>("trashActiveCount");
+        const int stage = GameManager::getSharedData<int>("gameStage");
 
-            float camX, camY;
-            Object::Camera::getInstance().getPosition(camX, camY);
-
-            const float halfEnemyW = mEnemyTex->getWidth() * tS.adjustedScaleX() / 2.f;
-            const float halfEnemyH = mEnemyTex->getHeight() * tS.adjustedScaleY() / 2.f;
-
-            const float viewLeft = camX - (mW / 2.f);
-            const float viewRight = camX + (mW / 2.f);
-            const float viewTop = camY - (mH / 2.f);
-            const float viewBottom = camY + (mH / 2.f);
-
-            // Right 1/3 of the currently visible screen, in world coordinates.
-            int spawnMinX = static_cast<int>(viewLeft + (2.f * mW / 3.f) + halfEnemyW);
-            int spawnMaxX = static_cast<int>(viewRight - halfEnemyW - 25.f);
-            int spawnMinY = static_cast<int>(viewTop + halfEnemyH + 100.f);
-            int spawnMaxY = static_cast<int>(viewBottom - halfEnemyH - 100.f);
-
-            // Safety for tiny windows / huge sprites.
-            if (spawnMinX > spawnMaxX) spawnMinX = spawnMaxX = static_cast<int>(camX);
-            if (spawnMinY > spawnMaxY) spawnMinY = spawnMaxY = static_cast<int>(camY);
-
-            tS.x = static_cast<float>(Utils::getUtils().rirng32(spawnMinX, spawnMaxX));
-            tS.y = static_cast<float>(Utils::getUtils().rirng32(spawnMinY, spawnMaxY));
-            GameManager::instantiateEntity(std::make_unique<AGame::Enemy>("Enemy" + std::to_string(cnt + 1), mEnemyTex, tS));
-
-            // Spawn Trash at shoreline
-            tS.scaleX = 5.5f;
-            tS.scaleY = 5.5f;
-            tS.rotation = 0.f;
-            tS.x = mTransform.x - 75.f;
-            tS.y = static_cast<float>(Utils::getUtils().rirng32(spawnMinY, spawnMaxY));
-            GameManager::instantiateEntity(std::make_unique<AGame::Trash>("Trash" + std::to_string(cnt + 1), mTrashTex, tS));
+        if (mPendingLevelSpawn) {
+            if (enemyCount <= 0 && trashCount <= 0) {
+                GameManager::processPendingEntityRemovals();
+                mPendingLevelSpawn = false;
+                spawnLevel(mPendingLevelStage);
+            }
+            return;
         }
 
-        /*const bool* state = SDL_GetKeyboardState(nullptr);
-        if (state[SDL_SCANCODE_P]) {
-            mTransform.scaleX *= 2.f;
-            mTransform.scaleY *= 2.f;
+        if (enemyCount <= 0 && trashCount <= 0) {
+            if (stage < mMaxLevels) {
+                mPendingLevelSpawn = true;
+                mPendingLevelStage = stage + 1;
+            } else if (!GameManager::getSharedData<bool>("gameWon")) {
+                GameManager::setSharedData("gameWon", true);
+                LOG("All levels cleared");
+            }
         }
-        if (state[SDL_SCANCODE_L]) {
-            mTransform.scaleX *= 0.5f;
-            mTransform.scaleY *= 0.5f;
-        }*/
-        //mTransform.rotation += 1.f; // Rotate clockwise for testing
-        //mTransform.scaleX = 1.f + 1.f * std::sin(RUNNING_TIME() / 0.5f); // Pulsate scale for testing
-        //mTransform.scaleY = 1.f + 0.5f * std::cos(RUNNING_TIME() / 0.5f); // Pulsate scale for testing
-
-        //Object::Camera::getInstance().move(1.f, 0.f);
     }
 
     void Background::onWindowResized(int newWidth, int newHeight) {

src/game/agame/enemy.cpp

@@ -1,22 +1,129 @@
 #include <game/agame/enemy.hpp>
 #include <object/components/boxcollider.hpp>
+#include <game/agame/player.hpp>
+#include <state/gamestate.hpp>
+#include <algorithm>
+#include <cmath>
+#include <utils.hpp>
+#include <game/gamemanager.hpp>
+#include <window/window.hpp>
 
 namespace Game::AGame {
     void Enemy::start() {
         mZIndex = 20;
         addComponent<Object::Components::BoxCollider>();
         LOG("Enemy started: " << getName());
+        
+        // Initialize random movement
+        const float angle = static_cast<float>(Utils::getUtils().rirng32(0, 360)) * 3.14159f / 180.f;
+        const float speed = 20.f + static_cast<float>(Utils::getUtils().rirng32(0, 30));
+        mMoveSpeedX = std::cos(angle) * speed;
+        mMoveSpeedY = std::sin(angle) * speed;
+        mDirectionChangeTimer = 0.f;
     }
 
     void Enemy::update(float deltaTime) {
-        return;
+        (void)deltaTime;
+
+        auto* player = GameManager::getEntityByName<Player>("Player");
+        if (!player) {
+            mIsVisible = false;
+            return;
+        }
+
+        // Enemies are always visible
+        mIsVisible = true;
+        
+        // Semi-random movement with periodic direction changes
+        mDirectionChangeTimer += deltaTime;
+        if (mDirectionChangeTimer > 2.0f) {
+            const float angle = static_cast<float>(Utils::getUtils().rirng32(0, 360)) * 3.14159f / 180.f;
+            const float speed = 20.f + static_cast<float>(Utils::getUtils().rirng32(0, 30));
+            mMoveSpeedX = std::cos(angle) * speed;
+            mMoveSpeedY = std::sin(angle) * speed;
+            mDirectionChangeTimer = 0.f;
+        }
+        
+        // Move enemy
+        mTransform.x += mMoveSpeedX * deltaTime;
+        mTransform.y += mMoveSpeedY * deltaTime;
+        
+        // Clamp to land section
+        const float landBoundaryX = GameManager::getSharedData<float>("terrainLandBoundaryX");
+        const float entityWidth = getTexture() ? getTexture()->getWidth() * mTransform.adjustedScaleX() : 0.f;
+        const float entityHeight = getTexture() ? getTexture()->getHeight() * mTransform.adjustedScaleY() : 0.f;
+        const float halfWidth = entityWidth / 2.f;
+        const float halfHeight = entityHeight / 2.f;
+        
+        // Get window dimensions for boundary calculations
+        int w = 0, h = 0;
+        SDL_GetWindowSizeInPixels(Window::Window::getSDLWindowBackend(), &w, &h);
+        const float leftEdge = -w / 2.f + 25.f;
+        
+        if (mTransform.x - halfWidth < leftEdge) {
+            mTransform.x = leftEdge + halfWidth;
+            mMoveSpeedX = std::abs(mMoveSpeedX);
+        }
+        if (mTransform.x + halfWidth > landBoundaryX - 25.f) {
+            mTransform.x = landBoundaryX - 25.f - halfWidth;
+            mMoveSpeedX = -std::abs(mMoveSpeedX);
+        }
+        if (mTransform.y - halfHeight < -h / 2.f + 25.f) {
+            mTransform.y = -h / 2.f + 25.f + halfHeight;
+            mMoveSpeedY = std::abs(mMoveSpeedY);
+        }
+        if (mTransform.y + halfHeight > h / 2.f - 25.f) {
+            mTransform.y = h / 2.f - 25.f - halfHeight;
+            mMoveSpeedY = -std::abs(mMoveSpeedY);
+        }
+    }
+
+    bool Enemy::hasAdjacentEnemy() {
+        if (!getTexture()) return false;
+
+        const float detectionRadius = 40.f;
+        const float enemyWidth = getTexture()->getWidth() * mTransform.adjustedScaleX();
+        const float enemyHeight = getTexture()->getHeight() * mTransform.adjustedScaleY();
+        const float centerX = mTransform.x + enemyWidth / 2.f;
+        const float centerY = mTransform.y + enemyHeight / 2.f;
+
+        auto entities = GameManager::getEntityByName<Object::Entity>("Dummy");
+        if (!entities) {
+            auto snapshot = State::GameState::getInstance().getEntitiesSnapshot();
+            for (auto* other : snapshot) {
+                if (!other || other == this || !dynamic_cast<Enemy*>(other)) continue;
+                auto* otherEnemy = dynamic_cast<Enemy*>(other);
+                if (!otherEnemy || !otherEnemy->getTexture()) continue;
+                const float otherWidth = otherEnemy->getTexture()->getWidth() * otherEnemy->getTransform()->adjustedScaleX();
+                const float otherHeight = otherEnemy->getTexture()->getHeight() * otherEnemy->getTransform()->adjustedScaleY();
+                const float otherCenterX = otherEnemy->getTransform()->x + otherWidth / 2.f;
+                const float otherCenterY = otherEnemy->getTransform()->y + otherHeight / 2.f;
+                const float dx = centerX - otherCenterX;
+                const float dy = centerY - otherCenterY;
+                if (dx * dx + dy * dy <= detectionRadius * detectionRadius) {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
 
     void Enemy::onCollisionEnter(Object::Entity* other) {
-        LOG("Enemy '" << getName() << "' collided with '" << other->getName() << "' (onCollisionEnter); Killing myself now!");
-        GameManager::setSharedData("enemyActiveCount", GameManager::getSharedData<int>("enemyActiveCount") - 1);
-        
-        // Find in state
+        auto* player = dynamic_cast<Player*>(other);
+        if (!player || !mIsVisible) {
+            return;
+        }
+
+        if (hasAdjacentEnemy()) {
+            LOG("Player collided with a strong group of polluters; game over!");
+            GameManager::setSharedData("gameLost", true);
+            GameManager::destroyEntity(player);
+            return;
+        }
+
+        LOG("Enemy '" << getName() << "' collided with player; removing polluter and awarding points");
+        GameManager::setSharedData("enemyActiveCount", std::max(0, GameManager::getSharedData<int>("enemyActiveCount") - 1));
+        GameManager::setSharedData("gameScore", GameManager::getSharedData<int>("gameScore") + 100);
         GameManager::destroyEntity(this);
     }
 }

src/game/agame/friendly.cpp

@@ -0,0 +1,81 @@
+#include <game/agame/friendly.hpp>
+#include <game/gamemanager.hpp>
+#include <game/agame/player.hpp>
+#include <object/components/boxcollider.hpp>
+#include <algorithm>
+#include <cmath>
+#include <utils.hpp>
+#include <window/window.hpp>
+
+namespace Game::AGame {
+    void Friendly::start() {
+        mZIndex = 20;
+        addComponent<Object::Components::BoxCollider>();
+        LOG("Friendly started: " << getName());
+        
+        // Initialize random movement
+        const float angle = static_cast<float>(Utils::getUtils().rirng32(0, 360)) * 3.14159f / 180.f;
+        const float speed = 20.f + static_cast<float>(Utils::getUtils().rirng32(0, 30));
+        mMoveSpeedX = std::cos(angle) * speed;
+        mMoveSpeedY = std::sin(angle) * speed;
+        mDirectionChangeTimer = 0.f;
+    }
+
+    void Friendly::update(float deltaTime) {
+        (void)deltaTime;
+        
+        // Semi-random movement with periodic direction changes
+        mDirectionChangeTimer += deltaTime;
+        if (mDirectionChangeTimer > 2.0f) {
+            const float angle = static_cast<float>(Utils::getUtils().rirng32(0, 360)) * 3.14159f / 180.f;
+            const float speed = 20.f + static_cast<float>(Utils::getUtils().rirng32(0, 30));
+            mMoveSpeedX = std::cos(angle) * speed;
+            mMoveSpeedY = std::sin(angle) * speed;
+            mDirectionChangeTimer = 0.f;
+        }
+        
+        // Move friendly
+        mTransform.x += mMoveSpeedX * deltaTime;
+        mTransform.y += mMoveSpeedY * deltaTime;
+        
+        // Clamp to land section
+        const float landBoundaryX = GameManager::getSharedData<float>("terrainLandBoundaryX");
+        const float entityWidth = getTexture() ? getTexture()->getWidth() * mTransform.adjustedScaleX() : 0.f;
+        const float entityHeight = getTexture() ? getTexture()->getHeight() * mTransform.adjustedScaleY() : 0.f;
+        const float halfWidth = entityWidth / 2.f;
+        const float halfHeight = entityHeight / 2.f;
+        
+        // Get window dimensions for boundary calculations
+        int w = 0, h = 0;
+        SDL_GetWindowSizeInPixels(Window::Window::getSDLWindowBackend(), &w, &h);
+        const float leftEdge = -w / 2.f + 25.f;
+        
+        if (mTransform.x - halfWidth < leftEdge) {
+            mTransform.x = leftEdge + halfWidth;
+            mMoveSpeedX = std::abs(mMoveSpeedX);
+        }
+        if (mTransform.x + halfWidth > landBoundaryX - 25.f) {
+            mTransform.x = landBoundaryX - 25.f - halfWidth;
+            mMoveSpeedX = -std::abs(mMoveSpeedX);
+        }
+        if (mTransform.y - halfHeight < -h / 2.f + 25.f) {
+            mTransform.y = -h / 2.f + 25.f + halfHeight;
+            mMoveSpeedY = std::abs(mMoveSpeedY);
+        }
+        if (mTransform.y + halfHeight > h / 2.f - 25.f) {
+            mTransform.y = h / 2.f - 25.f - halfHeight;
+            mMoveSpeedY = -std::abs(mMoveSpeedY);
+        }
+    }
+
+    void Friendly::onCollisionEnter(Object::Entity* other) {
+        auto* player = dynamic_cast<Player*>(other);
+        if (!player) {
+            return;
+        }
+
+        GameManager::setSharedData("friendlyActiveCount", std::max(0, GameManager::getSharedData<int>("friendlyActiveCount") - 1));
+        GameManager::setSharedData("gameScore", GameManager::getSharedData<int>("gameScore") - 50);
+        GameManager::destroyEntity(this);
+    }
+}

src/game/agame/hudtext.cpp

@@ -0,0 +1,56 @@
+#include <game/agame/hudtext.hpp>
+#include <game/gamemanager.hpp>
+#include <window/window.hpp>
+#include <sstream>
+
+namespace Game::AGame {
+    void HUDText::start() {
+        mZIndex = 1000;
+        Object::UIText::start();
+        setText("Level 1 | Score 0 | Trash 0 | Polluters 0");
+    }
+
+    void HUDText::update(float deltaTime) {
+        (void)deltaTime;
+
+        int windowW = 0;
+        int windowH = 0;
+        SDL_GetWindowSizeInPixels(Window::Window::getSDLWindowBackend(), &windowW, &windowH);
+        float camX = 0.f;
+        float camY = 0.f;
+        Object::Camera::getInstance().getPosition(camX, camY);
+
+        auto anchorTopRight = [&]() {
+            if (!mTex) {
+                return;
+            }
+
+            const float marginX = 24.f;
+            const float marginY = 24.f;
+            const float textWidth = mTex->getWidth() * mTransform.adjustedScaleX();
+            mTransform.x = camX + windowW / 2.f - marginX - textWidth;
+            mTransform.y = camY - windowH / 2.f + marginY;
+        };
+
+        if (GameManager::getSharedData<bool>("gameLost")) {
+            setText("You Died!");
+            anchorTopRight();
+            return;
+        }
+
+        if (GameManager::getSharedData<bool>("gameWon")) {
+            setText("You Won!");
+            anchorTopRight();
+            return;
+        }
+
+        std::stringstream stream;
+        stream << "Level " << GameManager::getSharedData<int>("gameStage")
+               << " | Točke " << GameManager::getSharedData<int>("gameScore")
+               << " | Smeti " << GameManager::getSharedData<int>("trashActiveCount")
+               << " | Sovražniki " << GameManager::getSharedData<int>("enemyActiveCount");
+        
+        setText(stream.str());
+        anchorTopRight();
+    }
+}

src/game/agame/player.cpp

@@ -3,8 +3,60 @@
 #include <cmath>
 #include <game/input.hpp>
 #include <game/gamemanager.hpp>
+#include <utils.hpp>
 
 namespace Game::AGame {
+    void Player::setShipTexture(std::shared_ptr<Game::Renderer::Texture> tex) {
+        mShipTex = std::move(tex);
+        if (mIsShipMode && mShipTex) {
+            setTexture(mShipTex);
+        }
+    }
+
+    void Player::setGroundTexture(std::shared_ptr<Game::Renderer::Texture> tex) {
+        mGroundTex = std::move(tex);
+        if (!mIsShipMode && mGroundTex) {
+            setTexture(mGroundTex);
+        }
+    }
+
+    void Player::respawnRandomSea(float landBoundaryX) {
+        auto spawnTex = mShipTex ? mShipTex : mTex;
+        if (!spawnTex) {
+            return;
+        }
+
+        int w = 0;
+        int h = 0;
+        SDL_GetWindowSizeInPixels(Window::Window::getSDLWindowBackend(), &w, &h);
+
+        const float halfWidth = spawnTex->getWidth() * mTransform.adjustedScaleX() / 2.f;
+        const float halfHeight = spawnTex->getHeight() * mTransform.adjustedScaleY() / 2.f;
+
+        const float minCenterX = landBoundaryX + mShoreMargin + halfWidth;
+        const float maxCenterX = w / 2.f - halfWidth - 10.f;
+        const float minCenterY = -h / 2.f + halfHeight;
+        const float maxCenterY = h / 2.f - halfHeight;
+
+        float centerX = minCenterX;
+        if (maxCenterX > minCenterX) {
+            centerX = static_cast<float>(Utils::getUtils().rirng32(static_cast<int>(minCenterX), static_cast<int>(maxCenterX)));
+        }
+
+        float centerY = 0.f;
+        if (maxCenterY > minCenterY) {
+            centerY = static_cast<float>(Utils::getUtils().rirng32(static_cast<int>(minCenterY), static_cast<int>(maxCenterY)));
+        }
+
+        mTransform.x = centerX - halfWidth;
+        mTransform.y = centerY - halfHeight;
+
+        mIsShipMode = true;
+        if (mShipTex) {
+            setTexture(mShipTex);
+        }
+    }
+
     void Player::start() {
         //mSound = Object::Sound("../resources/example.wav", Object::Format::WAV);
         //mSound.play();
@@ -12,15 +64,41 @@ namespace Game::AGame {
         Game::GameManager::setSharedData("gameStage", 1);
         Game::GameManager::setSharedData("gameScore", 0);
 
-        int w, h;
-        SDL_GetWindowSizeInPixels(Window::Window::getSDLWindowBackend(), &w, &h);
-
         mTransform.scaleX = 8.f;
         mTransform.scaleY = 8.f;
 
+        if (!mShipTex) {
+            mShipTex = mTex;
+        }
+        if (!mGroundTex) {
+            mGroundTex = mTex;
+        }
+
+        int w = 0;
+        int h = 0;
+        SDL_GetWindowSizeInPixels(Window::Window::getSDLWindowBackend(), &w, &h);
+
+        const float halfWidth = mTex->getWidth() * mTransform.adjustedScaleX() / 2.f;
+        const float halfHeight = mTex->getHeight() * mTransform.adjustedScaleY() / 2.f;
+        const float minX = -w / 2.f + halfWidth;
+        const float maxX = w / 2.f - halfWidth;
+        const float minY = -h / 2.f + halfHeight;
+        const float maxY = h / 2.f - halfHeight;
+
+        const float landBoundaryX = Game::GameManager::getSharedData<float>("terrainLandBoundaryX");
+        mTransform.x = static_cast<float>(Utils::getUtils().rirng32(static_cast<int>(minX), static_cast<int>(maxX)));
+        mTransform.y = static_cast<float>(Utils::getUtils().rirng32(static_cast<int>(minY), static_cast<int>(maxY)));
+        mIsShipMode = (mTransform.x + halfWidth) >= landBoundaryX;
+
         mTransform.x -= mTex->getWidth() * mTransform.adjustedScaleX() / 2.f;
         mTransform.y -= mTex->getHeight() * mTransform.adjustedScaleY() / 2.f;
 
+        if (mIsShipMode && mShipTex) {
+            setTexture(mShipTex);
+        } else if (!mIsShipMode && mGroundTex) {
+            setTexture(mGroundTex);
+        }
+
         LOG("W: " << w << " H: " << h);
         //mSound.~Sound();
     }
@@ -31,11 +109,41 @@ namespace Game::AGame {
         //mTransform.scaleY = 1.f + 0.5f * std::cos(RUNNING_TIME() / 0.5f); // Pulsate scale for testing
         //Object::Camera::getInstance().move(1.f, 0.f);
 
+        const float landBoundaryX = Game::GameManager::getSharedData<float>("terrainLandBoundaryX");
+        const float halfWidth = mTex->getWidth() * mTransform.adjustedScaleX() / 2.f;
+
+        if (Input::isKeyPressed(SDL_SCANCODE_E)) {
+            const bool nearShore = std::abs((mTransform.x + halfWidth) - landBoundaryX) <= mShoreMargin;
+            if (nearShore) {
+                mIsShipMode = !mIsShipMode;
+            }
+        }
+
         // Simple movement
         if (Input::isKeyPressed(SDL_SCANCODE_W)) { mTransform.y -= mSpeed * deltaTime; }
         if (Input::isKeyPressed(SDL_SCANCODE_S)) { mTransform.y += mSpeed * deltaTime; }
         if (Input::isKeyPressed(SDL_SCANCODE_A)) { mTransform.x -= mSpeed * deltaTime; mIsFlipped = false; }
         if (Input::isKeyPressed(SDL_SCANCODE_D)) { mTransform.x += mSpeed * deltaTime; mIsFlipped = true; }
         mSpeed = Input::isKeyPressed(SDL_SCANCODE_LSHIFT) ? 400.f : 200.f;
+
+        if (mIsShipMode && (mTransform.x + halfWidth) < landBoundaryX + mShoreMargin) {
+            mTransform.x = landBoundaryX + mShoreMargin - halfWidth;
+        }
+        if (!mIsShipMode && (mTransform.x + halfWidth) > landBoundaryX - mShoreMargin) {
+            mTransform.x = landBoundaryX - mShoreMargin - halfWidth;
+        }
+
+        if (mIsShipMode && mShipTex) {
+            setTexture(mShipTex);
+        } else if (!mIsShipMode && mGroundTex) {
+            setTexture(mGroundTex);
+        }
+    }
+
+    void Player::onCollisionEnter(Object::Entity* other) {
+        (void)other;
+        if (GameManager::getSharedData<bool>("gameLost")) {
+            GameManager::destroyEntity(this);
+        }
     }
 }

src/game/agame/trash.cpp

@@ -1,11 +1,27 @@
 #include <game/agame/trash.hpp>
+#include <game/agame/player.hpp>
+#include <object/components/boxcollider.hpp>
+#include <algorithm>
 
 namespace Game::AGame {
     void Trash::start() {
         mZIndex = 20;
+        addComponent<Object::Components::BoxCollider>();
     }
 
     void Trash::update(float deltaTime) {
+        (void)deltaTime;
         return;
     }
+
+    void Trash::onCollisionEnter(Object::Entity* other) {
+        auto* player = dynamic_cast<Player*>(other);
+        if (!player || !player->isShipMode()) {
+            return;
+        }
+
+        GameManager::setSharedData("trashActiveCount", std::max(0, GameManager::getSharedData<int>("trashActiveCount") - 1));
+        GameManager::setSharedData("gameScore", GameManager::getSharedData<int>("gameScore") + 25);
+        GameManager::destroyEntity(this);
+    }
 }