games/raycaster
1
0
Fork 0
Code Issues 30 Pull requests Projects Releases 2 Packages Wiki Activity Actions

Trying out an FSM for controlling the main loop.

Browse source
This commit is contained in:
Zed A. Shaw 2025-02-04 00:52:54 -05:00
parent 740e30cb2b
commit 7228bdf210
6 changed files with 247 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

21
camera.cpp
View file

@ -6,14 +6,12 @@ void CameraLOL::plan_run(Raycaster &rayview, int dir) {
t = 0.0; t = 0.0;
targetX = rayview.$posX + int(rayview.$dirX * 1.5 * dir); targetX = rayview.$posX + int(rayview.$dirX * 1.5 * dir);
targetY = rayview.$posY + int(rayview.$dirY * 1.5 * dir); targetY = rayview.$posY + int(rayview.$dirY * 1.5 * dir);
targetDir = dir;
} }
bool CameraLOL::play_run(Raycaster &rayview) { void CameraLOL::plan_strafe(Raycaster &rayview, int dir) {
t += moveSpeed; t = 0.0;
rayview.$posX = std::lerp(rayview.$posX, targetX, t); targetX = rayview.$posX + int(-rayview.$dirY * 1.5 * dir);
rayview.$posY = std::lerp(rayview.$posY, targetY, t); targetY = rayview.$posY + int(rayview.$dirX * 1.5 * dir);
return t >= 1.0;
} }
void CameraLOL::plan_rotate(Raycaster &rayview, int dir) { void CameraLOL::plan_rotate(Raycaster &rayview, int dir) {
@ -25,8 +23,6 @@ void CameraLOL::plan_rotate(Raycaster &rayview, int dir) {
targetPlaneX = rayview.$planeX * cos(angle_dir) - rayview.$planeY * sin(angle_dir); targetPlaneX = rayview.$planeX * cos(angle_dir) - rayview.$planeY * sin(angle_dir);
targetPlaneY = rayview.$planeX * sin(angle_dir) + rayview.$planeY * cos(angle_dir); targetPlaneY = rayview.$planeX * sin(angle_dir) + rayview.$planeY * cos(angle_dir);
targetDir = dir;
} }
bool CameraLOL::play_rotate(Raycaster &rayview) { bool CameraLOL::play_rotate(Raycaster &rayview) {
@ -39,14 +35,7 @@ bool CameraLOL::play_rotate(Raycaster &rayview) {
return t > 1.0; return t > 1.0;
} }
void CameraLOL::plan_strafe(Raycaster &rayview, int dir) { bool CameraLOL::play_move(Raycaster &rayview) {
t = 0.0;
targetX = rayview.$posX + int(-rayview.$dirY * 1.5 * dir);
targetY = rayview.$posY + int(rayview.$dirX * 1.5 * dir);
}
bool CameraLOL::play_strafe(Raycaster &rayview) {
t += moveSpeed; t += moveSpeed;
rayview.$posX = std::lerp(rayview.$posX, targetX, t); rayview.$posX = std::lerp(rayview.$posX, targetX, t);
rayview.$posY = std::lerp(rayview.$posY, targetY, t); rayview.$posY = std::lerp(rayview.$posY, targetY, t);

10
camera.hpp
View file

@ -7,17 +7,15 @@ struct CameraLOL {
double rotSpeed = 0.1; double rotSpeed = 0.1;
double targetX = 0.0; double targetX = 0.0;
double targetY = 0.0; double targetY = 0.0;
int targetDir = 0;
double targetDirX = 0.0; double targetDirX = 0.0;
double targetDirY = 0.0; double targetDirY = 0.0;
double targetPlaneX = 0.0; double targetPlaneX = 0.0;
double targetPlaneY = 0.0; double targetPlaneY = 0.0;
void plan_run(Raycaster &rayview, int dir); void plan_run(Raycaster &rayview, int dir);
bool play_run(Raycaster &rayview);
void plan_rotate(Raycaster &rayview, int dir);
bool play_rotate(Raycaster &rayview);
void plan_strafe(Raycaster &rayview, int dir); void plan_strafe(Raycaster &rayview, int dir);
bool play_strafe(Raycaster &rayview); void plan_rotate(Raycaster &rayview, int dir);
bool play_rotate(Raycaster &rayview);
bool play_move(Raycaster &rayview);
}; };

28
fsm.hpp Normal file
View file

@ -0,0 +1,28 @@
#pragma once
#include <fmt/core.h>
#ifndef FSM_DEBUG
#define FSM_STATE(C, S, E, ...) case C::S: S(E, ##__VA_ARGS__); break
#else
#define FSM_STATE(C, S, E, ...) case C::S: fmt::println(">> " #C " " #S " event={}, state={}", int(E), int($state)); S(E, ##__VA_ARGS__); fmt::println("<< " #C " state={}", int($state)); break
#endif
template<typename S, typename E>
class DeadSimpleFSM {
protected:
// BUG: don't put this in your class because state() won't work
S $state = S::START;
public:
template<typename... Types>
void event(E event, Types... args);
void state(S next_state) {
$state = next_state;
}
bool in_state(S state) {
return $state == state;
}
};

196
main.cpp
View file

@ -9,6 +9,8 @@
#include "components.hpp" #include "components.hpp"
#include "camera.hpp" #include "camera.hpp"
#include <numbers> #include <numbers>
#define FSM_DEBUG 1
#include "fsm.hpp"
using namespace components; using namespace components;
@ -20,7 +22,18 @@ void draw_gui(sf::RenderWindow &window, Raycaster &rayview, sf::Text &text, Stat
window.draw(rect); window.draw(rect);
text.setString( text.setString(
fmt::format("FPS\nmean:{:>8.5}\nsdev: {:>8.5}\nmin: {:>8.5}\nmax: {:>8.5}\ncount:{:<10}\n\nVSync? {}\nFR Limit: {}\nDebug? {}\n\nHit R to reset.\n\ndir: {:>2.2},{:>2.2}\npos: {:>2.2},{:>2.2}", fmt::format("FPS\n"
"mean:{:>8.5}\n"
"sdev: {:>8.5}\n"
"min: {:>8.5}\n"
"max: {:>8.5}\n"
"count:{:<10}\n\n"
"VSync? {}\n"
"FR Limit: {}\n"
"Debug? {}\n\n"
"Hit R to reset.\n\n"
"dir: {:>2.02},{:>2.02}\n"
"pos: {:>2.02},{:>2.02}",
stats.mean(), stats.stddev(), stats.min, stats.mean(), stats.stddev(), stats.min,
stats.max, stats.n, VSYNC, stats.max, stats.n, VSYNC,
FRAME_LIMIT, DEBUG_BUILD, rayview.$dirX, FRAME_LIMIT, DEBUG_BUILD, rayview.$dirX,
@ -43,56 +56,131 @@ void draw_weapon(sf::RenderWindow &window, sf::Sprite &weapon, float rotation) {
window.draw(weapon); window.draw(weapon);
} }
enum MoveState { enum class MainState {
MOVE, START,
ROTATE, MOVING,
STRAFE, ROTATING,
IDLE IDLE
}; };
inline void handle_window_events(sf::RenderWindow &window, Raycaster &rayview, enum class MainEvent {
MoveState &state, CameraLOL &camera) STARTED,
{ TICK,
while(const auto event = window.pollEvent()) { MOVE_FORWARD,
if(event->is<sf::Event::Closed>()) { MOVE_BACK,
window.close(); MOVE_LEFT,
} MOVE_RIGHT,
ROTATE_LEFT,
ROTATE_RIGHT,
QUIT
};
if(const auto* key = event->getIf<sf::Event::KeyPressed>()) { class MainFSM : public DeadSimpleFSM<MainState, MainEvent> {
if(key->scancode == sf::Keyboard::Scan::W) { public:
camera.plan_run(rayview, 1); sf::RenderWindow& $window;
state = MOVE; Raycaster& $rayview;
} else if(key->scancode == sf::Keyboard::Scan::S) { CameraLOL $camera;
camera.plan_run(rayview, -1);
state = MOVE;
}
if(key->scancode == sf::Keyboard::Scan::Q) { MainFSM(sf::RenderWindow &window, Raycaster &rayview) :
camera.plan_rotate(rayview, 1); $window(window),
state = ROTATE; $rayview(rayview) { }
} else if(key->scancode == sf::Keyboard::Scan::E) {
camera.plan_rotate(rayview, -1);
state = ROTATE;
}
if(key->scancode == sf::Keyboard::Scan::D) { void event(MainEvent ev) {
camera.plan_strafe(rayview, -1); switch($state) {
state = STRAFE; FSM_STATE(MainState, START, ev);
} else if(key->scancode == sf::Keyboard::Scan::A) { FSM_STATE(MainState, MOVING, ev);
camera.plan_strafe(rayview, 1); FSM_STATE(MainState, ROTATING, ev);
state = STRAFE; FSM_STATE(MainState, IDLE, ev);
}
} }
} }
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::P)) { void START(MainEvent ) {
if(rayview.$active_shader == nullptr) { state(MainState::IDLE);
rayview.$active_shader = &rayview.$paused; }
} else {
rayview.$active_shader = nullptr; void MOVING(MainEvent ) {
if($camera.play_move($rayview)) {
state(MainState::IDLE);
} }
} }
}
void ROTATING(MainEvent ) {
if($camera.play_rotate($rayview)) {
state(MainState::IDLE);
}
}
void IDLE(MainEvent ev) {
using FU = MainEvent;
switch(ev) {
case FU::QUIT:
$window.close();
break;
case FU::MOVE_FORWARD:
$camera.plan_run($rayview, 1);
state(MainState::MOVING);
break;
case FU::MOVE_BACK:
$camera.plan_run($rayview, -1);
state(MainState::MOVING);
break;
case FU::MOVE_LEFT:
$camera.plan_strafe($rayview, 1);
state(MainState::MOVING);
break;
case FU::MOVE_RIGHT:
$camera.plan_strafe($rayview, -1);
state(MainState::MOVING);
break;
case FU::ROTATE_LEFT:
$camera.plan_rotate($rayview, 1);
state(MainState::ROTATING);
break;
case FU::ROTATE_RIGHT:
$camera.plan_rotate($rayview, -1);
state(MainState::ROTATING);
break;
default:
dbc::sentinel("unhandled event in IDLE");
}
}
void keyboard() {
while(const auto keyev = $window.pollEvent()) {
if(keyev->is<sf::Event::Closed>()) {
event(MainEvent::QUIT);
}
if(const auto* key = keyev->getIf<sf::Event::KeyPressed>()) {
using KEY = sf::Keyboard::Scan;
switch(key->scancode) {
case KEY::W:
event(MainEvent::MOVE_FORWARD);
break;
case KEY::S:
event(MainEvent::MOVE_BACK);
break;
case KEY::Q:
event(MainEvent::ROTATE_LEFT);
break;
case KEY::E:
event(MainEvent::ROTATE_RIGHT);
break;
case KEY::D:
event(MainEvent::MOVE_RIGHT);
break;
case KEY::A:
event(MainEvent::MOVE_LEFT);
break;
default:
break; // ignored
}
}
}
}
};
int main() { int main() {
sf::RenderWindow window(sf::VideoMode({SCREEN_WIDTH, SCREEN_HEIGHT}), "Zed's Ray Caster Game Thing"); sf::RenderWindow window(sf::VideoMode({SCREEN_WIDTH, SCREEN_HEIGHT}), "Zed's Ray Caster Game Thing");
@ -131,8 +219,8 @@ int main() {
window.setVerticalSyncEnabled(VSYNC); window.setVerticalSyncEnabled(VSYNC);
window.setFramerateLimit(FRAME_LIMIT); window.setFramerateLimit(FRAME_LIMIT);
MoveState state = IDLE; MainFSM fsm(window, rayview);
CameraLOL camera; fsm.event(MainEvent::STARTED);
while(window.isOpen()) { while(window.isOpen()) {
auto start = std::chrono::high_resolution_clock::now(); auto start = std::chrono::high_resolution_clock::now();
@ -146,22 +234,18 @@ int main() {
draw_weapon(window, *weapon_sprite_ptr, rotation); draw_weapon(window, *weapon_sprite_ptr, rotation);
window.display(); window.display();
if(state == IDLE) { if(fsm.in_state(MainState::IDLE)) {
handle_window_events(window, rayview, state, camera); fsm.keyboard();
} else if(state == MOVE) { } else{
if(camera.play_run(rayview)) { fsm.event(MainEvent::TICK);
state = IDLE;
}
} else if(state == ROTATE) {
if(camera.play_rotate(rayview)) {
state = IDLE;
}
} else if(state == STRAFE) {
if(camera.play_strafe(rayview)) {
state = IDLE;
} }
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::P)) {
if(rayview.$active_shader == nullptr) {
rayview.$active_shader = &rayview.$paused;
} else { } else {
dbc::sentinel("invalid move state."); rayview.$active_shader = nullptr;
}
} }
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::R)) { if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::R)) {

1
meson.build
View file

@ -77,6 +77,7 @@ executable('runtests', sources + [
'tests/pathing.cpp', 'tests/pathing.cpp',
'tests/spatialmap.cpp', 'tests/spatialmap.cpp',
'tests/tilemap.cpp', 'tests/tilemap.cpp',
'tests/fsm.cpp',
'tests/worldbuilder.cpp', 'tests/worldbuilder.cpp',
], override_options: exe_defaults, ], override_options: exe_defaults,
dependencies: dependencies + [catch2]) dependencies: dependencies + [catch2])

67
tests/fsm.cpp Normal file
View file

@ -0,0 +1,67 @@
#include <catch2/catch_test_macros.hpp>
#include <fmt/core.h>
#include <string>
#include "../fsm.hpp"
using namespace fmt;
using std::string;
enum class MyState {
START, RUNNING, END
};
enum class MyEvent {
STARTED, PUSH, QUIT
};
class MyFSM : public DeadSimpleFSM<MyState, MyEvent> {
public:
void event(MyEvent ev, string data="") {
switch($state) {
FSM_STATE(MyState, START, ev);
FSM_STATE(MyState, RUNNING, ev, data);
FSM_STATE(MyState, END, ev);
}
}
void START(MyEvent ev) {
println("<<< START {}", (int)ev);
state(MyState::RUNNING);
}
void RUNNING(MyEvent ev, string &data) {
if(ev == MyEvent::QUIT) {
println("<<< QUITTING {}", data);
state(MyState::END);
} else {
println("<<< RUN: {}", data);
state(MyState::RUNNING);
}
}
void END(MyEvent ev) {
println("<<< STOP {}", (int)ev);
state(MyState::END);
}
};
TEST_CASE("confirm fsm works with optional data", "[utils]") {
MyFSM fsm;
REQUIRE(fsm.in_state(MyState::START));
fsm.event(MyEvent::STARTED);
REQUIRE(fsm.in_state(MyState::RUNNING));
fsm.event(MyEvent::PUSH);
REQUIRE(fsm.in_state(MyState::RUNNING));
fsm.event(MyEvent::PUSH);
REQUIRE(fsm.in_state(MyState::RUNNING));
fsm.event(MyEvent::PUSH);
REQUIRE(fsm.in_state(MyState::RUNNING));
fsm.event(MyEvent::QUIT, "DONE!");
REQUIRE(fsm.in_state(MyState::END));
}