rich/ReWalker
1
0
Fork 1
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Added impervious obstacles

Browse Source
This commit is contained in:
rich
2025-02-01 12:54:28 -05:00
parent 166bf96928
commit 9f8224462b
1 changed files with 83 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
main.cpp
View File

@@ -1,8 +1,5 @@
// ReWalker
// A random walker that moves around the screen with a fading trail, mouse interaction, and a status bar.
// Updated to use the latest ReWindow API and JGL rendering.
// Written by Rich
// With help from (and thanks to) from Maxine, Josh, and Bill.
// ReWalker with Obstacles
// A random walker that moves around the screen but avoids four red squares.
#include <ReWindow/types/Window.h>
#include <ReWindow/Logger.h>
@@ -11,68 +8,96 @@
#include <memory>
// Define window size and dot size (dot size should be odd for symmetry)
// 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 fading speed (higher = faster fading, range: 0.001 - 0.2)
#define FADE_SPEED 0.05f
constexpr unsigned int TRAIL_LENGTH = 20; // Number of past steps stored for fading effect
constexpr unsigned int TRAIL_LENGTH = 20;
// Enable debug mode (set to 0 to disable debug output)
#define DEBUG 0
// Enable debug mode
#define DEBUG 1
/**
* @brief Represents the walker that moves randomly on the screen.
* @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; // Current position of the walker
Vector2 position;
Vector2 lastValidPosition;
Walker() : position(WIDTH / 2.0f, (HEIGHT - STATUS_BAR_HEIGHT) / 2.0f),
lastValidPosition(position) {}
/**
* @brief Constructor initializes the walker at the center of the screen.
* @brief Moves the walker in a random direction.
*/
Walker() : position(WIDTH / 2.0f, (HEIGHT - STATUS_BAR_HEIGHT) / 2.0f) {}
/**
* @brief Moves the walker one step in a random direction.
*/
void step() {
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);
// Update position and clamp within screen boundaries (excluding status bar)
// 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));
#if DEBUG
std::cout << "Walker Position: (" << position.x << ", " << position.y << ")\n";
#endif
// 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 a given (mouse) position.
* @param mouseX X coordinate of the mouse.
* @param mouseY Y coordinate of the mouse.
* @param force The force applied to push the walker away.
*/
void pushAway(float mouseX, float mouseY, float force) {
* @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; // No need to invert Y
float deltaY = position.y - mouseY;
float distance = std::sqrt(deltaX * deltaX + deltaY * deltaY);
// Only push if the mouse is close enough
if (distance > 0.0f) {
float unitX = deltaX / distance;
float unitY = deltaY / distance;
// Apply dynamic push force
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;
}
}
}
}
@@ -85,17 +110,21 @@ struct Walker {
};
/**
* @brief Custom ReWindow window class that manages the random walker simulation.
* @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>()),
trailBuffer{},
pushForce(3.0f),
health(100.0f)
{}
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))
@@ -107,23 +136,20 @@ public:
void OnRefresh(float elapsed) override {
handleMouseInput();
handleKeyboardInput();
// Move the walker
walker->step();
// Deplete health over time
health = std::max(health - 0.1f, 0.0f);
// 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::DrawString(Colors::Black, "Framerate: " + std::to_string((int) (1.f / delta_time)), 0, 0, 1, 16);
J2D::End();
SwapBuffers();
@@ -131,30 +157,26 @@ public:
private:
std::unique_ptr<Walker> walker;
std::vector<Obstacle> obstacles;
std::vector<std::pair<Vector2, float>> trailBuffer{};
RenderTarget* render_target = nullptr;
float pushForce;
float health;
void handleMouseInput() {
auto mousePos = GetMouseCoordinates();
if (IsMouseButtonDown(MouseButtons::Left)) {
walker->pushAway(mousePos.x, mousePos.y, pushForce);
walker->pushAway(mousePos.x, mousePos.y, pushForce, obstacles);
}
}
void handleKeyboardInput() {
if (IsKeyDown(Keys::Space)) {
walker->resetPosition();
health = 100.0f;
}
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;
@@ -165,7 +187,6 @@ private:
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());
@@ -173,17 +194,25 @@ private:
void drawTrail() {
for (const auto& trailPoint : trailBuffer)
J2D::DrawPoint({0, 0, 0, (uint8_t) (trailPoint.second * 255.0f)}, trailPoint.first, DOT_SIZE);
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 Status Bar", WIDTH, HEIGHT);
auto window = std::make_unique<RandomWalkerWindow>("Random Walker with Obstacles", WIDTH, HEIGHT);
if (!window->Open())
return -1;