raycaster/components.hpp

#pragma once
#include "components.hpp"
#include "config.hpp"
#include "constants.hpp"
#include "dinkyecs.hpp"
#include "point.hpp"
#include <SFML/Graphics/Rect.hpp>
#include <SFML/System/Vector2.hpp>
#include <functional>
#include <nlohmann/json.hpp>
#include <nlohmann/json_fwd.hpp>

#define ENROLL_COMPONENT(COMPONENT, ...)                         \
    NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(COMPONENT, __VA_ARGS__);  \
    template <> struct NameOf<COMPONENT> {                       \
      static constexpr const char *name = #COMPONENT;            \
    };

namespace components {
  using namespace nlohmann;

  struct Position {
    Point location;
  };

  struct Motion {
    int dx;
    int dy;
    bool random=false;
  };

  struct Loot {
    int amount;
  };

  struct Tile {
    std::string display;
    std::array<uint8_t, 3> foreground;
    std::array<uint8_t, 3> background;
  };

  struct GameConfig {
    Config game;
    Config enemies;
    Config items;
    Config tiles;
    Config devices;
  };

  struct EnemyConfig {
    int hearing_distance = 10;
  };

  struct Debug {
    bool PATHS=false;
    bool LIGHT=false;
    bool FPS=false;
  };

  struct Weapon {
    int damage = 0;
  };

  struct Curative {
    int hp = 10;
  };

  struct Combat {
    int hp;
    int max_hp;
    int damage;

    /* NOTE: This is used to _mark_ entities as dead, to detect ones that have just died. Don't make attack automatically set it.*/
    bool dead = false;

    int attack(Combat &target);
  };

  struct LightSource {
    int strength = 0;
    float radius = 1.0f;
  };

  struct Device {
    json config;
    std::vector<std::string> events;

    void configure_events(std::vector<std::string> &event_names);
  };

  struct Sprite {
    string name;
  };

  struct Sound {
    std::string attack;
    std::string death;
  };

  struct Animation {
    float scale = 0.0f;
    bool simple = true;
    int frames = 10;
    float speed = 0.3f;
    int current = 0;
    bool playing = false;
    float subframe = 0;

    void play();
    void step(sf::Vector2f& scale_out, sf::IntRect& rect_out);
  };

  template <typename T> struct NameOf;

  // these need to be here if you're using components::convert outside of components.cpp
  ENROLL_COMPONENT(Tile, display, foreground, background);
  ENROLL_COMPONENT(Sprite, name);
  ENROLL_COMPONENT(Curative, hp);
  ENROLL_COMPONENT(LightSource, strength, radius);
  ENROLL_COMPONENT(Weapon, damage);
  ENROLL_COMPONENT(Loot, amount);


  using ReflFuncSignature = std::function<void(DinkyECS::World& world, DinkyECS::Entity ent, nlohmann::json &j)>;
  using ComponentMap = std::unordered_map<std::string, ReflFuncSignature>;
  struct Player {
    DinkyECS::Entity entity;
  };

  template<typename COMPONENT> COMPONENT convert(nlohmann::json &data) {
    COMPONENT result;
    from_json(data, result);
    return result;
  }

  template<typename COMPONENT> COMPONENT get(nlohmann::json &data) {
    for (auto &i : data["components"]) {
      if(i["_type"] == NameOf<COMPONENT>::name) {
        COMPONENT result;
        from_json(i, result);
        return result;
      }
    }

    return {};
  }

  template <typename COMPONENT> void enroll(ComponentMap &m) {
    m[NameOf<COMPONENT>::name] = [](DinkyECS::World& world, DinkyECS::Entity ent, nlohmann::json &j) {
      COMPONENT c;
      from_json(j, c);
      world.set<COMPONENT>(ent, c);
    };
  }

  void configure(ComponentMap& component_map);

  void configure_entity(const ComponentMap& component_map, DinkyECS::World& world, DinkyECS::Entity ent, json& data);

}