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 <numbers>

using namespace components;

void draw_gui(sf::RenderWindow &window, 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\nmean:{:>8.5}\nsdev: {:>8.5}\nmin: {:>8.5}\nmax: {:>8.5}\ncount:{:<10}\n\nVSync? {}\nFR Limit: {}\nDebug? {}\n\nHit R to reset.",
      stats.mean(), stats.stddev(), stats.min, stats.max, stats.n, VSYNC, FRAME_LIMIT, DEBUG_BUILD));
  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 MoveState {
  MOVE,
  ROTATE,
  STRAFE,
  IDLE
};

struct CameraLOL {
  double t = 0.0;
  double moveSpeed = 0.1;
  double rotSpeed = 0.1;
  double targetX = 0.0;
  double targetY = 0.0;
  int targetDir = 0;
  double targetDirX = 0.0;
  double targetDirY = 0.0;
  double targetPlaneX = 0.0;
  double targetPlaneY = 0.0;

  void plan_run(Raycaster &rayview, int dir) {
    t = 0.0;
    targetX = rayview.$posX + int(rayview.$dirX * 1.5 * dir);
    targetY = rayview.$posY + int(rayview.$dirY * 1.5 * dir);
    targetDir = dir;
  }

  bool lerp_run(Raycaster &rayview) {
    t += moveSpeed;
    rayview.$posX = std::lerp(rayview.$posX, targetX, t);
    rayview.$posY = std::lerp(rayview.$posY, targetY, t);
    return t >= 1.0;
  }

  void plan_rotate(Raycaster &rayview, int dir) {
    t = 0.0;
    double angle_dir = std::numbers::pi * 0.5 * dir;

    targetDirX = rayview.$dirX * cos(angle_dir) - rayview.$dirY * sin(angle_dir);
    targetDirY = rayview.$dirX * sin(angle_dir) + rayview.$dirY * cos(angle_dir);

    targetPlaneX = rayview.$planeX * cos(angle_dir) - rayview.$planeY * sin(angle_dir);
    targetPlaneY = rayview.$planeX * sin(angle_dir) + rayview.$planeY * cos(angle_dir);

    targetDir = dir;
  }

  bool lerp_rotate(Raycaster &rayview) {
    t += rotSpeed;
    rayview.$dirX = std::lerp(rayview.$dirX, targetDirX, t);
    rayview.$dirY = std::lerp(rayview.$dirY, targetDirY, t);
    rayview.$planeX = std::lerp(rayview.$planeX, targetPlaneX, t);
    rayview.$planeY = std::lerp(rayview.$planeY, targetPlaneY, t);

    return t > 1.0;
  }
};


inline void handle_window_events(sf::RenderWindow &window, Raycaster &rayview,
    MoveState &state, CameraLOL &camera)
{
  while(const auto event = window.pollEvent()) {
    if(event->is<sf::Event::Closed>()) {
      window.close();
    }

    if(const auto* key = event->getIf<sf::Event::KeyPressed>()) {
      if(key->scancode == sf::Keyboard::Scan::W) {
        camera.plan_run(rayview, 1);
        state = MOVE;
      } else if(key->scancode == sf::Keyboard::Scan::S) {
        camera.plan_run(rayview, -1);
        state = MOVE;
      }

      if(key->scancode == sf::Keyboard::Scan::D) {
        camera.plan_rotate(rayview, -1);
        state = ROTATE;
      } else if(key->scancode == sf::Keyboard::Scan::A) {
        camera.plan_rotate(rayview, 1);
        state = ROTATE;
      }
    }
  }

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

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);

  MoveState state = IDLE;
  CameraLOL camera;

  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, text, stats);
    draw_weapon(window, *weapon_sprite_ptr, rotation);
    window.display();

    if(state == IDLE) {
      handle_window_events(window, rayview, state, camera);
    } else if(state == MOVE) {
      if(camera.lerp_run(rayview)) {
        state = IDLE;
      }
    } else if(state == ROTATE) {
      if(camera.lerp_rotate(rayview)) {
        state = IDLE;
      }
    } else if(state == STRAFE) {
      state = IDLE;
    } else {
      dbc::sentinel("invalid move state.");
    }

    if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::R)) {
      stats.reset();
    }

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

  return 0;
}