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},
    $map_display{$font},
    $rayview($textures, RAY_VIEW_WIDTH, RAY_VIEW_HEIGHT)
    {
      $window.setVerticalSyncEnabled(VSYNC);
      $window.setFramerateLimit(FRAME_LIMIT);
      $text.setPosition({10,10});
      $text.setFillColor({255,255,255});
      $map_display.setPosition({10, SCREEN_HEIGHT-300});
      $map_display.setFillColor({255,255,255});
      $map_display.setLetterSpacing(0.5);
      $map_display.setLineSpacing(0.9);
      $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 ) {
    generate_map();
    $rayview.init_shaders();
    $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)) {
      System::plan_motion(*$level.world, {size_t($camera.targetX), size_t($camera.targetY)});
      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:
        try_move(1, false);
        break;
      case FU::MOVE_BACK:
        try_move(-1, false);
        break;
      case FU::MOVE_LEFT:
        try_move(1, true);
        break;
      case FU::MOVE_RIGHT:
        try_move(-1, true);
        break;
      case FU::ROTATE_LEFT:
        $camera.plan_rotate($rayview, 1);
        state(State::ROTATING);
        break;
      case FU::ROTATE_RIGHT:
        $camera.plan_rotate($rayview, -1);
        state(State::ROTATING);
        break;
      default:
        dbc::sentinel("unhandled event in IDLE");
    }
  }

  void FSM::try_move(int dir, bool strafe) {
    // prevent moving into occupied space
    Point move_to = $camera.plan_move($rayview, dir, strafe);

    if($level.map->can_move(move_to) && !$level.collision->occupied(move_to)) {
      state(State::MOVING);
    } else {
      state(State::IDLE);
      $camera.abort_plan($rayview);
    }
  }

  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});
    sf::RectangleShape map_rect({SCREEN_WIDTH - RAY_VIEW_WIDTH - 10, 300});

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

    map_rect.setPosition({0, SCREEN_HEIGHT-300});
    map_rect.setFillColor({20, 20, 20});
    $window.draw(rect);
    $window.draw(map_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"
          "dir: {:>2.02},{:>2.02}\n"
          "pos: {:>2.02},{:>2.02}\n\n",
          $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);

    std::wstring map = $level.map->tiles().minimap(int($rayview.$posX), int($rayview.$posY));
    $map_display.setString(map);
    $window.draw($map_display);
  }

  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::enemy_pathing($level);
    System::motion($level);
    System::collision($level);
    System::death($level);
  }

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