raycaster/main.cpp

#include "raycaster.hpp"
#include <iostream>
#include <chrono>
#include <numeric>
#include <functional>
#include "constants.hpp"
#include "stats.hpp"
#include "levelmanager.hpp"
#include "components.hpp"
#include "camera.hpp"
#include <numbers>
#define FSM_DEBUG 1
#include "fsm.hpp"

using namespace components;

void draw_gui(sf::RenderWindow &window, Raycaster &rayview, sf::Text &text, Stats &stats) {
  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);
}

Matrix generate_map(TexturePack &textures, GameLevel &level, Point &player_out) {
  auto &tiles = level.map->tiles();
  auto &player = level.world->get_the<Player>();
  auto &player_position = level.world->get<Position>(player.entity);
  player_out = player_position.location;

  return textures.convert_char_to_texture(tiles.$tile_ids);
}

void draw_weapon(sf::RenderWindow &window, sf::Sprite &weapon, float rotation) {
  weapon.setPosition({SCREEN_WIDTH/2,SCREEN_HEIGHT/2});
  weapon.setRotation(sf::degrees(rotation));
  window.draw(weapon);
}

enum class MainState {
  START,
  MOVING,
  ROTATING,
  IDLE
};

enum class MainEvent {
  STARTED,
  TICK,
  MOVE_FORWARD,
  MOVE_BACK,
  MOVE_LEFT,
  MOVE_RIGHT,
  ROTATE_LEFT,
  ROTATE_RIGHT,
  QUIT
};

class MainFSM : public DeadSimpleFSM<MainState, MainEvent> {
  public:
    sf::RenderWindow& $window;
    Raycaster& $rayview;
    CameraLOL $camera;

    MainFSM(sf::RenderWindow &window, Raycaster &rayview) :
      $window(window),
      $rayview(rayview) { }

    void event(MainEvent ev) {
      switch($state) {
        FSM_STATE(MainState, START, ev);
        FSM_STATE(MainState, MOVING, ev);
        FSM_STATE(MainState, ROTATING, ev);
        FSM_STATE(MainState, IDLE, ev);
      }
    }

    void START(MainEvent ) {
      state(MainState::IDLE);
    }

    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() {
  sf::RenderWindow window(sf::VideoMode({SCREEN_WIDTH, SCREEN_HEIGHT}), "Zed's Ray Caster Game Thing");

  sf::Font font{"./assets/text.otf"};
  sf::Text text{font};
  text.setFillColor({255,255,255});
  text.setPosition({10,10});

  Point player{0, 0};
  LevelManager levels;
  GameLevel &cur_level = levels.current();

  TexturePack textures;
  textures.load_tiles();
  textures.load_sprites();

  auto map = generate_map(textures, cur_level, player);

  Point evil_eye_1, evil_eye_2;
  dbc::check(cur_level.map->place_entity(1, evil_eye_1), "failed to place enemy 1");
  dbc::check(cur_level.map->place_entity(2, evil_eye_2), "failed to place enemy 2");

  Raycaster rayview(window, textures, map, RAY_VIEW_WIDTH, RAY_VIEW_HEIGHT);
  rayview.init_shaders();

  rayview.set_position(RAY_VIEW_X, RAY_VIEW_Y);
  rayview.position_camera(player.x + 0.5, player.y + 0.5);

  rayview.position_sprite(evil_eye_1, "evil_eye");
  rayview.position_sprite(evil_eye_2, "evil_eye");

  float rotation = -30.0f;
  Stats stats;

  window.setVerticalSyncEnabled(VSYNC);
  window.setFramerateLimit(FRAME_LIMIT);

  MainFSM fsm(window, rayview);
  fsm.event(MainEvent::STARTED);

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

    auto weapon_sprite_ptr = rayview.$textures.sword.sprite;
    draw_gui(window, rayview, text, stats);
    draw_weapon(window, *weapon_sprite_ptr, rotation);
    window.display();

    if(fsm.in_state(MainState::IDLE)) {
      fsm.keyboard();
    } else{
      fsm.event(MainEvent::TICK);
    }

    if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::P)) {
      if(rayview.$active_shader == nullptr) {
        rayview.$active_shader = &rayview.$paused;
      } else {
        rayview.$active_shader = nullptr;
      }
    }

    if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::R)) {
      rayview.position_camera(player.x + 0.5, player.y + 0.5);
      stats.reset();
    }

    if(sf::Mouse::isButtonPressed(sf::Mouse::Button::Left)) {
      rayview.$anim.play(false);
      rotation = -30.0f;
    } else {
      rotation = -10.0f;
    }
  }

  return 0;
}