ReWalker/main.cpp

// ReWalker
// A random walker that moves around the screen with a fading trail, mouse interaction, and a status bar.
// There are now obsticalse you cant walk through
// Updated to use the latest ReWindow API and JGL rendering.
// Written by Rich
// With help from (and thanks to) from Maxine, Josh, and Bill.

#include <ReWindow/types/Window.h>
#include <ReWindow/Logger.h>
#include <JGL/JGL.h>
#include <Color4.hpp>
#include <memory>


// Define window size and dot size
#define WIDTH 800
#define HEIGHT 600
#define DOT_SIZE 5
#define OBSTACLE_SIZE 50

#define STATUS_BAR_HEIGHT 30  // Height of the status bar at the bottom

#define FADE_SPEED 0.05f
constexpr unsigned int TRAIL_LENGTH = 20;

// Enable debug mode
#define DEBUG 1

/**
 * @brief Represents an obstacle that the walker cannot pass through.
 */
struct Obstacle {
    Vector2 position;  // Top-left corner of the obstacle

    Obstacle(float x, float y) : position(x, y) {}

    /**
     * @brief Checks if a given position is inside the obstacle.
     */
    bool isColliding(const Vector2& pos) const {
        return pos.x >= position.x && pos.x <= position.x + OBSTACLE_SIZE &&
               pos.y >= position.y && pos.y <= position.y + OBSTACLE_SIZE;
    }
};

/**
 * @brief Represents the walker that moves randomly.
 */
struct Walker {
    Vector2 position;
    Vector2 lastValidPosition;

    Walker() : position(WIDTH / 2.0f, (HEIGHT - STATUS_BAR_HEIGHT) / 2.0f), 
               lastValidPosition(position) {}

    /**
     * @brief Moves the walker in a random direction.
     */
    void step(const std::vector<Obstacle>& obstacles) {
        float angle = static_cast<float>(rand()) / RAND_MAX * 360.0f;
        angle = Math::Radians(angle);
        float dx = std::cos(angle);
        float dy = std::sin(angle);

        // Store last valid position
        lastValidPosition = position;

        // Update position
        position.x = std::clamp(position.x + dx, 0.0f, static_cast<float>(WIDTH - 1));
        position.y = std::clamp(position.y + dy, 0.0f, static_cast<float>(HEIGHT - STATUS_BAR_HEIGHT - 1));

        // Check for collisions
        for (const auto& obstacle : obstacles) {
            if (obstacle.isColliding(position)) {
                position = lastValidPosition;  // Revert movement if collision occurs
                break;
            }
        }
    }

    /**
     * @brief Pushes the walker away from the mouse pointer.
     */
    void pushAway(float mouseX, float mouseY, float force, const std::vector<Obstacle>& obstacles) {
        float deltaX = position.x - mouseX;
        float deltaY = position.y - mouseY;

        float distance = std::sqrt(deltaX * deltaX + deltaY * deltaY);
        if (distance > 0.0f) {
            float unitX = deltaX / distance;
            float unitY = deltaY / distance;

            lastValidPosition = position;

            position.x = std::clamp(position.x + unitX * force, 0.0f, static_cast<float>(WIDTH - 1));
            position.y = std::clamp(position.y + unitY * force, 0.0f, static_cast<float>(HEIGHT - STATUS_BAR_HEIGHT - 1));

            // Prevent moving into obstacles
            for (const auto& obstacle : obstacles) {
                if (obstacle.isColliding(position)) {
                    position = lastValidPosition;
                    break;
                }
            }
        }
    }

    /**
     * @brief Resets the walker to the center of the screen.
     */
    void resetPosition() {
        position = Vector2(WIDTH / 2.0f, (HEIGHT - STATUS_BAR_HEIGHT) / 2.0f);
    }
};

/**
 * @brief Custom ReWindow window class that manages the walker simulation.
 */
class RandomWalkerWindow : public ReWindow::OpenGLWindow {
public:
    RandomWalkerWindow(const std::string& title, int width, int height)
        : ReWindow::OpenGLWindow(title, width, height, 2, 1),
          walker(std::make_unique<Walker>()),
          pushForce(3.0f) 
    {
        // Define four obstacles
        obstacles.emplace_back(200, 150);
        obstacles.emplace_back(500, 150);
        obstacles.emplace_back(200, 400);
        obstacles.emplace_back(500, 400);
    }

    void OnOpen() override {
        if (!JGL::Init({WIDTH, HEIGHT}, 0, 0))
            exit(0);

        this->render_target = new RenderTarget({WIDTH, HEIGHT}, Colors::White);
    }

    void OnRefresh(float elapsed) override {
        handleMouseInput();
        handleKeyboardInput();

        // Move walker
        walker->step(obstacles);

        JGL::Update({WIDTH, HEIGHT});
        J2D::Begin(render_target, true);
            fadeTrail();
            drawTrail();
            drawObstacles();
            plotWalker();
        J2D::End();

        J2D::Begin(nullptr, true);
            J2D::DrawRenderTarget(render_target, {0, 0});
        J2D::End();

        SwapBuffers();
    }

private:
    std::unique_ptr<Walker> walker;
    std::vector<Obstacle> obstacles;
    std::vector<std::pair<Vector2, float>> trailBuffer{};
    RenderTarget* render_target = nullptr;

    float pushForce;

    void handleMouseInput() {
        auto mousePos = GetMouseCoordinates();
        if (IsMouseButtonDown(MouseButtons::Left)) {
            walker->pushAway(mousePos.x, mousePos.y, pushForce, obstacles);
        }
    }

    void handleKeyboardInput() {
        if (IsKeyDown(Keys::Space)) {
            walker->resetPosition();
        }
        if (IsKeyDown(Keys::Escape)) {
            Close();
        }
        if (IsKeyDown(Keys::One)) pushForce = 1.0f;
        if (IsKeyDown(Keys::Two)) pushForce = 2.0f;
        if (IsKeyDown(Keys::Three)) pushForce = 3.0f;
        if (IsKeyDown(Keys::Four)) pushForce = 4.0f;
        if (IsKeyDown(Keys::Five)) pushForce = 5.0f;
    }

    void fadeTrail() {
        for (auto& trailPoint : trailBuffer)
            trailPoint.second = std::max(trailPoint.second - FADE_SPEED, 0.0f);
        trailBuffer.emplace_back(walker->position, 1.0f);
        if (trailBuffer.size() > TRAIL_LENGTH)
            trailBuffer.erase(trailBuffer.begin());
    }

    void drawTrail() {
        for (const auto& trailPoint : trailBuffer)
            J2D::DrawPoint({0, 0, 0, (uint8_t)(trailPoint.second * 255.0f)}, trailPoint.first, DOT_SIZE);
    }

    void plotWalker() {
        J2D::DrawPoint(Colors::Black, walker->position, DOT_SIZE);
    }

    /**
     * @brief Draws the four red obstacles.
     */
    void drawObstacles() {
        for (const auto& obstacle : obstacles) {
            J2D::FillRect(Colors::Red, obstacle.position, {OBSTACLE_SIZE, OBSTACLE_SIZE});
        }
    }
};

int main() {
    auto window = std::make_unique<RandomWalkerWindow>("Random Walker with Obstacles", WIDTH, HEIGHT);
    if (!window->Open())
        return -1;

    while (!window->IsClosing()) {
        window->ManagedRefresh();
    }

    return 0;
}