raycaster/gui.cpp

#include "gui.hpp"
#include <iostream>
#include <chrono>
#include <numeric>
#include <functional>
#include "components.hpp"
#include <numbers>
#include "systems.hpp"

using namespace components;

namespace gui {
  FSM::FSM() :
    $window(sf::VideoMode({SCREEN_WIDTH, SCREEN_HEIGHT}), "Zed's Raycaster Thing"),
    $font{"./assets/text.otf"},
    $text{$font},
    $rayview($textures, RAY_VIEW_WIDTH, RAY_VIEW_HEIGHT)
    {
      $window.setVerticalSyncEnabled(VSYNC);
      $window.setFramerateLimit(FRAME_LIMIT);
      $text.setFillColor({255,255,255});
      $text.setPosition({10,10});
      $textures.load_tiles();
      $textures.load_sprites();
    }

  void FSM::event(Event ev) {
    switch($state) {
      FSM_STATE(State, START, ev);
      FSM_STATE(State, MOVING, ev);
      FSM_STATE(State, ROTATING, ev);
      FSM_STATE(State, IDLE, ev);
      FSM_STATE(State, END, ev);
    }
  }

  void FSM::START(Event ) {
    // ZED: this must die
    generate_map();
    $rayview.set_position(RAY_VIEW_X, RAY_VIEW_Y);
    $rayview.position_camera($player.x + 0.5, $player.y + 0.5);
    state(State::IDLE);
  }

  void FSM::MOVING(Event ) {
    if($camera.play_move($rayview)) {
      // really annoying but we have to figure out the motion factor then run the systems
      auto& player = level.world->get_the<Player>();
      auto& player_position = level.world->get<Position>(player.entity);
      auto& motion = level.world->get<Motion>(player.entity);
      Point move_to{size_t($camera.targetX), size_t($camera.targetY)};
      motion.dx = move_to.x - player_position.location.x;
      motion.dy = move_to.y - player_position.location.y;

      run_systems();

      state(State::IDLE);
    }
  }

  void FSM::ROTATING(Event ) {
    if($camera.play_rotate($rayview)) {
      state(State::IDLE);
    }
  }

  void FSM::IDLE(Event ev) {
    using FU = Event;

    switch(ev) {
      case FU::QUIT:
        $window.close();
        state(State::END);
        return; // done
      case FU::MOVE_FORWARD:
        $camera.plan_run($rayview, 1);
        state(State::MOVING);
        break;
      case FU::MOVE_BACK:
        $camera.plan_run($rayview, -1);
        state(State::MOVING);
        break;
      case FU::MOVE_LEFT:
        $camera.plan_strafe($rayview, 1);
        state(State::MOVING);
        break;
      case FU::MOVE_RIGHT:
        $camera.plan_strafe($rayview, -1);
        state(State::MOVING);
        break;
      case FU::ROTATE_LEFT:
        $camera.plan_rotate($rayview, 1);
        state(State::ROTATING);
        return; // get out early since can always rotate
      case FU::ROTATE_RIGHT:
        $camera.plan_rotate($rayview, -1);
        state(State::ROTATING);
        return; // get out early since can always rotate
      default:
        dbc::sentinel("unhandled event in IDLE");
    }

    // prevent moving into occupied space
    if(!can_move({size_t($camera.targetX), size_t($camera.targetY)})) {
      state(State::IDLE);
      $camera.abort_plan($rayview);
    }
  }

  bool FSM::can_move(Point move_to) {
    return level.map->can_move(move_to) && !level.collision->occupied(move_to);
  }

  void FSM::END(Event ev) {
    fmt::println("END: received event after done: {}", int(ev));
  }

  void FSM::keyboard() {
    while(const auto keyev = $window.pollEvent()) {
      if(keyev->is<sf::Event::Closed>()) {
        event(Event::QUIT);
      }

      if(const auto* key = keyev->getIf<sf::Event::KeyPressed>()) {
        using KEY = sf::Keyboard::Scan;
        switch(key->scancode) {
          case KEY::W:
            event(Event::MOVE_FORWARD);
            break;
          case KEY::S:
            event(Event::MOVE_BACK);
            break;
          case KEY::Q:
            event(Event::ROTATE_LEFT);
            break;
          case KEY::E:
            event(Event::ROTATE_RIGHT);
            break;
          case KEY::D:
            event(Event::MOVE_RIGHT);
            break;
          case KEY::A:
            event(Event::MOVE_LEFT);
            break;
          case KEY::R:
            $stats.reset();
            break;
          default:
            break; // ignored
        }
      }
    }
  }

  void FSM::draw_weapon() {
    auto weapon = $rayview.$textures.sword.sprite;
    weapon->setPosition({SCREEN_WIDTH/2, SCREEN_HEIGHT/2});
    weapon->setRotation(sf::degrees($rotation));
    $window.draw(*weapon);
  }

  void FSM::draw_gui() {
    sf::RectangleShape rect({SCREEN_WIDTH - RAY_VIEW_WIDTH, SCREEN_HEIGHT});

    rect.setPosition({0,0});
    rect.setFillColor({50, 50, 50});
    $window.draw(rect);

    $text.setString(
        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.max, $stats.n, VSYNC,
          FRAME_LIMIT, DEBUG_BUILD, $rayview.$dirX,
          $rayview.$dirY, $rayview.$posX, $rayview.$posY));
    $window.draw($text);
  }

  void FSM::render() {
    auto start = std::chrono::high_resolution_clock::now();
    $rayview.draw($window);
    auto end = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration<double>(end - start);
    $stats.sample(1/elapsed.count());

    draw_gui();
    draw_weapon();
    $window.display();
  }

  void FSM::mouse() {
    if(sf::Mouse::isButtonPressed(sf::Mouse::Button::Left)) {
      $rotation = -30.0f;
    } else {
      $rotation = -10.0f;
    }
  }

  void FSM::generate_map() {
    level = $levels.current();
    auto& player = level.world->get_the<Player>();
    auto& player_position = level.world->get<Position>(player.entity);
    $player = player_position.location;
    $rayview.set_level(level);
  }

  void FSM::run_systems() {
    System::motion(level);
    System::enemy_pathing(level);
    System::collision(level);
    System::death(level);
  }

  bool FSM::active() {
    return !in_state(State::END);
  }
}