Lots of dumb little edits to sort out what I'm aiming at. I'll next clean out most of this in a refactor.

assets/enemies.json

@@ -58,7 +58,7 @@
   },
   "SPIDER_GIANT_HAIRY": {
     "components": [
-      {"_type": "Tile", "display": 2282,
+      {"_type": "Tile", "display": 1218,
         "foreground": [205, 164, 246],
         "background": [30, 20, 75]
       },

camera.cpp

@@ -2,7 +2,7 @@
 #include <numbers>
 #include <cmath>
 
-Point CameraLOL::plan_move(Raycaster &rayview, int dir, bool strafe) {
+Point CameraLOL::plan_move(int dir, bool strafe) {
   t = 0.0;
   if(strafe) {
     target_x = rayview.$pos_x + int(-rayview.$dir_y * 1.5 * dir);
@@ -15,7 +15,7 @@ Point CameraLOL::plan_move(Raycaster &rayview, int dir, bool strafe) {
   return {size_t(target_x), size_t(target_y)};
 }
 
-void CameraLOL::plan_rotate(Raycaster &rayview, int dir) {
+void CameraLOL::plan_rotate(int dir) {
   t = 0.0;
   double angle_dir = std::numbers::pi * 0.25 * dir;
 
@@ -26,24 +26,31 @@ void CameraLOL::plan_rotate(Raycaster &rayview, int dir) {
   target_plane_y = rayview.$plane_x * sin(angle_dir) + rayview.$plane_y * cos(angle_dir);
 }
 
-bool CameraLOL::play_rotate(Raycaster &rayview) {
+bool CameraLOL::play_rotate() {
   t += rot_speed;
   rayview.$dir_x = std::lerp(rayview.$dir_x, target_dir_x, t);
   rayview.$dir_y = std::lerp(rayview.$dir_y, target_dir_y, t);
   rayview.$plane_x = std::lerp(rayview.$plane_x, target_plane_x, t);
   rayview.$plane_y = std::lerp(rayview.$plane_y, target_plane_y, t);
 
-  return t > 1.0;
+  return t >= 1.0;
 }
 
-bool CameraLOL::play_move(Raycaster &rayview) {
+bool CameraLOL::play_move() {
   t += move_speed;
   rayview.$pos_x = std::lerp(rayview.$pos_x, target_x, t);
   rayview.$pos_y = std::lerp(rayview.$pos_y, target_y, t);
   return t >= 1.0;
 }
 
-void CameraLOL::abort_plan(Raycaster& rayview) {
+void CameraLOL::abort_plan() {
   target_x = rayview.$pos_x;
   target_y = rayview.$pos_y;
 }
+
+Point CameraLOL::aimed_at() {
+  return {
+    size_t(rayview.$pos_x + rayview.$dir_x),
+    size_t(rayview.$pos_y + rayview.$dir_y)
+  };
+}

camera.hpp

@@ -2,6 +2,7 @@
 #include "raycaster.hpp"
 
 struct CameraLOL {
+  Raycaster& rayview;
   double t = 0.0;
   double move_speed = 0.1;
   double rot_speed = 0.06;
@@ -12,11 +13,15 @@ struct CameraLOL {
   double target_plane_x = 0.0;
   double target_plane_y = 0.0;
 
-  Point plan_move(Raycaster &rayview, int dir, bool strafe);
+  CameraLOL(Raycaster& rv) :
-  void plan_rotate(Raycaster &rayview, int dir);
+    rayview(rv) {}
 
-  bool play_rotate(Raycaster &rayview);
+  Point plan_move(int dir, bool strafe);
-  bool play_move(Raycaster &rayview);
+  void plan_rotate(int dir);
 
-  void abort_plan(Raycaster& rayview);
+  bool play_rotate();
+  bool play_move();
+
+  void abort_plan();
+  Point aimed_at();
 };

gui_fsm.cpp

@@ -311,10 +311,11 @@ namespace gui {
       $debug_ui.render($window);
       $status_ui.render($window);
       $combat_ui.render($window);
+
       if($map_open) {
-        $map_ui.render($window);
+        $map_ui.render($window, $main_ui.$camera.aimed_at());
       } else {
-        $mini_map.render($window);
+        $mini_map.render($window, $main_ui.$camera.aimed_at());
       }
     }
   }

main_ui.cpp

@@ -8,7 +8,8 @@ namespace gui {
 
   MainUI::MainUI(sf::RenderWindow& window) :
     $window(window),
-    $rayview(RAY_VIEW_WIDTH, RAY_VIEW_HEIGHT)
+    $rayview(RAY_VIEW_WIDTH, RAY_VIEW_HEIGHT),
+    $camera($rayview)
   {
     $window.setVerticalSyncEnabled(VSYNC);
     $window.setFramerateLimit(FRAME_LIMIT);
@@ -42,6 +43,13 @@ namespace gui {
   }
 
   void MainUI::render() {
+    auto aimed_at = $camera.aimed_at();
+    if($level.collision->occupied(aimed_at)) {
+      $rayview.aiming_at = $level.collision->get(aimed_at);
+    } else {
+      $rayview.aiming_at = 0;
+    }
+
     if($show_level) {
       auto time = $clock.getElapsedTime();
       auto st = textures::get("down_the_well");
@@ -64,14 +72,15 @@ namespace gui {
   }
 
   bool MainUI::play_rotate() {
-    bool done = $camera.play_rotate($rayview);
+    bool done = $camera.play_rotate();
     $needs_render = !done;
+
     return done;
   }
 
   // this could be an optional that returs a Point
   std::optional<Point> MainUI::play_move() {
-    if($camera.play_move($rayview)) {
+    if($camera.play_move()) {
       $needs_render = false;
       Point pos{
           size_t($camera.target_x),
@@ -88,15 +97,15 @@ namespace gui {
     // -1 is left, 1 is right
     $compass_dir = ($compass_dir + dir) % $compass.size();
     $overlay_ui.show_text("left", $compass[$compass_dir]);
-    $camera.plan_rotate($rayview, dir);
+    $camera.plan_rotate(dir);
   }
 
   Point MainUI::plan_move(int dir, bool strafe) {
-    return $camera.plan_move($rayview, dir, strafe);
+    return $camera.plan_move(dir, strafe);
   }
 
   void MainUI::abort_plan() {
-    $camera.abort_plan($rayview);
+    $camera.abort_plan();
   }
 
   void MainUI::dead_entity(DinkyECS::Entity entity) {

map_view.cpp

@@ -44,13 +44,13 @@ namespace gui {
     $gui.init();
   }
 
-  void MapViewUI::render(sf::RenderWindow &window) {
+  void MapViewUI::render(sf::RenderWindow &window, Point aim) {
     window.draw(*$paper.sprite);
 
     auto grid = $gui.entity("map_grid");
     auto status = $gui.entity("status");
 
-    std::wstring map_out = System::draw_map($level, 23, 9);
+    std::wstring map_out = System::draw_map($level, 23, 9, aim);
 
     auto& map_text = $gui.get<guecs::Textual>(grid);
     map_text.update(map_out);

map_view.hpp

@@ -13,7 +13,7 @@ namespace gui {
 
       MapViewUI(GameLevel &level);
       void init();
-      void render(sf::RenderWindow &window);
+      void render(sf::RenderWindow &window, Point aim);
       void update_level(GameLevel &level);
   };
 }

mini_map.cpp

@@ -31,8 +31,8 @@ namespace gui {
     $map_grid.init(cell, $font);
   }
 
-  void MiniMapUI::render(sf::RenderWindow &window) {
+  void MiniMapUI::render(sf::RenderWindow &window, Point aim) {
-    std::wstring map_out = System::draw_map($level, 5, 3);
+    std::wstring map_out = System::draw_map($level, 5, 3, aim);
     $map_grid.update(map_out);
     window.draw(*$map_grid.text);
   }

mini_map.hpp

@@ -14,7 +14,7 @@ namespace gui {
 
       MiniMapUI(GameLevel &level);
       void init(guecs::UI& overlay);
-      void render(sf::RenderWindow &window);
+      void render(sf::RenderWindow &window, Point aim);
       void update_level(GameLevel &level);
   };
 }

raycaster.cpp

@@ -165,13 +165,13 @@ void Raycaster::sprite_casting(sf::RenderTarget &target) {
       sf_sprite->setScale(scale);
       sf_sprite->setTextureRect(in_texture);
       sf_sprite->setPosition(position);
-      $brightness.setUniform("offsetFactor", sf::Glsl::Vec2{0.0f, 0.0f});
 
       // the SpatialMap.distance_sorted only calculates the
       // (x1-x2)^2 + (y1-y2)^2 portion of distance, so to get
       // the actual distance we need to sqrt that.
       // float level = sqrt(rec.first);
       float level = lights[sprite_pos.location.y][sprite_pos.location.x] * PERCENT;
+      if(rec.second == aiming_at) level += 0.2;
       $brightness.setUniform("darkness", level);
       target.draw(*sf_sprite, &$brightness);
     }

raycaster.hpp

@@ -27,6 +27,7 @@ struct Raycaster {
   sf::Sprite $view_sprite;
   const uint32_t *$floor_texture = nullptr;
   const uint32_t *$ceiling_texture = nullptr;
+  DinkyECS::Entity aiming_at = 0;
 
   std::unique_ptr<RGBA[]> $pixels = nullptr;
 

systems.cpp

@@ -337,7 +337,7 @@ void System::plan_motion(DinkyECS::World& world, Point move_to) {
  * This one is called inside the MapViewUI very often so
  * just avoid GameMap unlike the others.
  */
-std::wstring System::draw_map(GameLevel level, size_t view_x, size_t view_y) {
+std::wstring System::draw_map(GameLevel level, size_t view_x, size_t view_y, Point aim) {
   DinkyECS::World &world = *level.world;
   Map &map = *level.map;
 
@@ -360,6 +360,14 @@ std::wstring System::draw_map(GameLevel level, size_t view_x, size_t view_y) {
     }
   }
 
+
+  if(aim.x >= cam_orig.x && aim.x <= cam_orig.x + view_x
+      && aim.y >= cam_orig.y && aim.y <= cam_orig.y + view_y)
+  {
+    Point aim_at = map.map_to_camera(aim, cam_orig);
+    grid[aim_at.y][aim_at.x] = '*';
+  }
+
   // then get the enemy/item/device tiles and fill those in
   world.query<Position, Tile>([&](auto, auto &pos, auto &entity_glyph) {
     if(pos.location.x >= cam_orig.x && pos.location.x <= cam_orig.x + view_x

systems.hpp

@@ -17,7 +17,7 @@ namespace System {
   void init_positions(DinkyECS::World &world, SpatialMap &collider);
   void device(DinkyECS::World &world, DinkyECS::Entity actor, DinkyECS::Entity item);
   void plan_motion(DinkyECS::World& world, Point move_to);
-  std::wstring draw_map(GameLevel level, size_t view_x, size_t view_y);
+  std::wstring draw_map(GameLevel level, size_t view_x, size_t view_y, Point aim);
 
   void enemy_ai(GameLevel &level);
   void combat(GameLevel &level);