roguish/systems.cpp

#include "systems.hpp"
#include <fmt/core.h>
#include <string>
#include <cmath>
#include "rand.hpp"
#include "collider.hpp"
#include "events.hpp"
#include "ftxui/screen/color.hpp"
#include "ftxui/screen/terminal.hpp"  // for SetColorSupport, Color, TrueColor
#include "dbc.hpp"
#include "lights.hpp"

using std::string;
using namespace fmt;
using namespace components;
using ftxui::Color;
using lighting::LightSource;

void System::lighting(DinkyECS::World &world, Map &game_map, LightRender &light, Player &player) {
  light.reset_light();

  world.query<Position, LightSource>([&](const auto &ent, auto &position, auto &lightsource) {
    light.set_light_target(position.location);
  });

  // BUG: some light doesn't move, can I not path those?
  light.path_light(game_map.walls());

  world.query<Position, LightSource>([&](const auto &ent, auto &position, auto &lightsource) {
    light.render_light(lightsource, position.location);
  });
}

void System::enemy_pathing(DinkyECS::World &world, Map &game_map, Player &player) {
  // TODO: this will be on each enemy not a global thing
  const auto &config = world.get_the<EnemyConfig>();
  const auto &player_position = world.get<Position>(player.entity);
  game_map.set_target(player_position.location);
  game_map.make_paths();

  world.query<Position, Motion>([&](const auto &ent, auto &position, auto &motion) {
    if(ent != player.entity) {
      Point out = position.location; // copy
      if(game_map.distance(out) < config.HEARING_DISTANCE) {
        // BUG: is neighbors really the best name for this?
        game_map.neighbors(out);
        motion = { int(out.x - position.location.x), int(out.y - position.location.y)};
      }
    }
  });
  game_map.clear_target(player_position.location);
}

void System::init_positions(DinkyECS::World &world) {
  auto &collider = world.get_the<spatial_map>();

  // BUG: instead of separate things maybe just one
  // BUG: Collision component that references what is collide
  world.query<Position, Combat>([&](const auto &ent, auto &pos, auto &combat) {
      if(!combat.dead) {
        collider.insert(pos.location, ent);
      }
  });

  world.query<Position, Loot>([&](const auto &ent, auto &pos, auto &loot) {
      collider.insert(pos.location, ent);
  });
}

inline void move_entity(spatial_map &collider, Map &game_map, Position &position, Motion &motion, DinkyECS::Entity ent) {
  Point move_to = {
    position.location.x + motion.dx,
    position.location.y + motion.dy
  };
  motion = {0,0}; // clear it after getting it

  // it's a wall, skip
  if(!game_map.can_move(move_to)) return;
  // there's collision skip
  if(collider.occupied(move_to)) return;

  // all good, do the move
  collider.move(position.location, move_to, ent);
  position.location = move_to;
}

void System::motion(DinkyECS::World &world, Map &game_map) {
  auto &collider = world.get_the<spatial_map>();

  world.query<Position, Motion>([&](const auto &ent, auto &position, auto &motion) {
    // don't process entities that don't move
    if(motion.dx != 0 || motion.dy != 0) {
      move_entity(collider, game_map, position, motion, ent);
    }
  });
}

void System::death(DinkyECS::World &world) {
  // BUG: this is where entities can die on top of
  // BUG: eachother and overlap their corpse
  // BUG: maybe that can be allowed and looting just shows
  // BUG: all dead things there?
  auto &collider = world.get_the<spatial_map>();

  world.query<Position, Combat>([&](const auto &ent, auto &position, auto &combat) {
    // bring out yer dead
    if(combat.hp <= 0 && !combat.dead) {
      combat.dead = true;
      // take them out of collision map
      collider.remove(position.location);

      // remove their motion so they're dead
      world.remove<Motion>(ent);
    }
  });
}

void System::collision(DinkyECS::World &world, Player &player) {
  auto& collider = world.get_the<spatial_map>();
  const auto& player_position = world.get<Position>(player.entity);
  auto& player_combat = world.get<Combat>(player.entity);

  // this is guaranteed to not return the given position
  auto [found, nearby] = collider.neighbors(player_position.location);

  if(found) {
    for(auto entity : nearby) {
      if(world.has<Combat>(entity)) {
        auto& enemy_combat = world.get<Combat>(entity);

        Events::Combat result {
          player_combat.attack(enemy_combat),
          enemy_combat.attack(player_combat)
        };

        world.send<Events::GUI>(Events::GUI::COMBAT, entity, result);
      } else if(world.has<Loot>(entity)) {
        auto loot = world.get<Loot>(entity);
        auto &loot_pos = world.get<Position>(entity);
        auto &inventory = world.get<Inventory>(player.entity);
        // BUG: this should go away and be a part of inventory
        auto &light = world.get<LightSource>(player.entity);

        world.send<Events::GUI>(Events::GUI::LOOT, entity, loot);
        inventory.gold += loot.amount;
        light.strength = 5;
        light.radius = 2;
        collider.remove(loot_pos.location);
      } else {
        println("UNKNOWN COLLISION TYPE {}", entity);
      }
    }
  }
}

// BUG: this is kind of massive, need to maybe rethink how systems are designed.  I mean...can each system be a callable class instead?
void System::draw_entities(DinkyECS::World &world, Map &game_map, const Matrix &lighting, ftxui::Canvas &canvas, const Point &cam_orig, size_t view_x, size_t view_y) {
  auto &tiles = game_map.tiles();

  world.query<Position, Tile>([&](const auto &ent, auto &pos, auto &tile) {
    if(pos.location.x >= cam_orig.x && pos.location.x <= cam_orig.x + view_x
        && pos.location.y >= cam_orig.y && pos.location.y <= cam_orig.y + view_y) {
      Point loc = game_map.map_to_camera(pos.location, cam_orig);

      int light_value = lighting[pos.location.y][pos.location.x];
      const TileCell& cell = tiles.at(pos.location.x, pos.location.y);

      // the 2 and 4 are from ftxui::Canvas since it does a kind of "subpixel" drawing
      canvas.DrawText(loc.x*2, loc.y*4, tile.chr, [light_value, cell](auto &pixel) {
          pixel.foreground_color = Color::HSV(255, 200, light_value + 20);
          pixel.background_color = Color::HSV(cell.bg_h, cell.bg_s, light_value / cell.bg_v);
      });
    }
  });
}

void System::draw_map(DinkyECS::World &world, Map &game_map, const Matrix &lighting, ftxui::Canvas &canvas, size_t view_x, size_t view_y) {
  const auto& debug = world.get_the<Debug>();
  const auto& player = world.get_the<Player>();
  const auto& player_position = world.get<Position>(player.entity);
  Point start = game_map.center_camera(player_position.location, view_x, view_y);
  auto &tiles = game_map.tiles();
  auto &paths = game_map.paths();

  size_t end_x = std::min(view_x, game_map.width() - start.x);
  size_t end_y = std::min(view_y, game_map.height() - start.y);

  for(size_t y = 0; y < end_y; ++y) {
    for(size_t x = 0; x < end_x; ++x) {
      const TileCell& tile = tiles.at(start.x+x, start.y+y);
      int light_value = debug.LIGHT ? 160 : lighting[start.y+y][start.x+x];
      int dnum = debug.PATHS ? paths[start.y+y][start.x+x] : WALL_PATH_LIMIT;

      if(debug.PATHS && dnum != WALL_PATH_LIMIT) {
        string num = dnum > 15 ? "*" : format("{:x}", dnum);

        canvas.DrawText(x * 2, y * 4, num, [dnum, light_value](auto &pixel) {
           pixel.foreground_color = Color::HSV(dnum * 20, 150, 200);
           pixel.background_color = Color::HSV(30, 20, light_value / 2);
        });
      } else {
        canvas.DrawText(x * 2, y * 4, tile.display, [tile, light_value](auto &pixel) {
          pixel.foreground_color = Color::HSV(tile.fg_h, tile.fg_s, light_value - tile.fg_v);
          pixel.background_color = Color::HSV(tile.bg_h, tile.bg_s, light_value / tile.bg_v);
        });
      }
    }
  }

  System::draw_entities(world, game_map, lighting, canvas, start, view_x, view_y);
}