One step closer to map rendering from tile sprites.

matrix.cpp

@@ -1,8 +1,5 @@
 #include "matrix.hpp"
-#include "dbc.hpp"
 #include <fmt/core.h>
-#include <cmath>
-#include <cstdlib>
 #include "constants.hpp"
 
 using namespace fmt;

matrix.hpp

@@ -1,24 +1,12 @@
 #pragma once
-#include <vector>
-#include <queue>
-#include <string>
-#include <array>
-#include <numeric>
-#include <algorithm>
-#include <fmt/core.h>
-#include "point.hpp"
-#include "rand.hpp"
-#include "dbc.hpp"
 #include "shiterator.hpp"
 
-
 namespace matrix {
   using Row = shiterator::BaseRow<int>;
   using Matrix = shiterator::Base<int>;
 
   using viewport = shiterator::viewport_t<Matrix>;
 
-
   using each_cell = shiterator::each_cell_t<Matrix>;
 
   using each_row = shiterator::each_row_t<Matrix>;

systems.cpp

@@ -408,16 +408,20 @@ void System::plan_motion(World& world, Position move_to) {
 }
 
 void System::draw_map(GameLevel& level, Matrix& grid, int compass_dir) {
+  (void)compass_dir;
   World &world = *level.world;
   Map &map = *level.map;
-  size_t view_x = matrix::width(grid);
+  size_t view_x = matrix::width(grid) - 1;
-  size_t view_y = matrix::height(grid);
+  size_t view_y = matrix::height(grid) - 1;
 
   auto player_pos = world.get<Position>(level.player).location;
   Point cam_orig = map.center_camera(player_pos, view_x, view_y);
   auto &tiles = map.tiles();
   auto &tile_set = textures::get_map_tile_set();
 
+  /* I'm doing double tid->wchar_t conversion here, maybe just
+   * render the tids into the grid then let someone else do this. */
+
   // first fill it with the map cells
   for(shiterator::each_cell_t it{grid}; it.next();) {
     size_t tile_y = size_t(it.y) + cam_orig.y;
@@ -438,7 +442,8 @@ void System::draw_map(GameLevel& level, Matrix& grid, int compass_dir) {
       Point view_pos = map.map_to_camera(pos.location, cam_orig);
 
       if(ent == level.player) {
-        grid[view_pos.y][view_pos.x] = COMPASS[compass_dir][0];
+        // grid[view_pos.y][view_pos.x] = COMPASS[compass_dir][0];
+        grid[view_pos.y][view_pos.x] = 41981;
       } else {
         grid[view_pos.y][view_pos.x] = entity_glyph.display;
       }

tests/map.cpp

@@ -4,6 +4,7 @@
 #include <fstream>
 #include "map.hpp"
 #include "levelmanager.hpp"
+#include "systems.hpp"
 
 using namespace fmt;
 using namespace nlohmann;
@@ -80,26 +81,21 @@ TEST_CASE("dijkstra algo test", "[map]") {
   }
 }
 
-sf::Sprite render_map(GameLevel& level, sf::RenderTexture& render) {
+sf::Sprite render_map(Matrix& tiles, sf::RenderTexture& render) {
-  auto &walls = level.map->tiles();
-
-  auto &tile_set = textures::get_map_tile_set();
-
   sf::Vector2i size{MAP_TILE_DIM,MAP_TILE_DIM};
 
   sf::Vector2u dim{
-    (unsigned int)matrix::width(walls) * size.x,
+    (unsigned int)matrix::width(tiles) * size.x,
-    (unsigned int)matrix::height(walls) * size.y};
+    (unsigned int)matrix::height(tiles) * size.y};
 
   bool worked = render.resize(dim);
   dbc::check(worked, "Failed to resize map render target.");
 
   render.clear({0,0,0,0});
 
-  for(matrix::each_row it{walls}; it.next();) {
+  for(matrix::each_row it{tiles}; it.next();) {
-    size_t tid = walls[it.y][it.x];
+    wchar_t display = tiles[it.y][it.x];
-    wchar_t display = tile_set[tid];
+    if(display == L' ') continue; // skip for now
-
     auto& sprite = textures::get_map_sprite(display);
     sprite.setPosition({float(it.x * size.x), float(it.y * size.y)});
     render.draw(sprite);
@@ -109,42 +105,21 @@ sf::Sprite render_map(GameLevel& level, sf::RenderTexture& render) {
   return sf::Sprite{render.getTexture()};
 }
 
-sf::Sprite render_entities(GameLevel& level, sf::Sprite& map_sprite, sf::RenderTexture& render) {
-  render.clear({0,0,0,0});
-  render.draw(map_sprite);
-
-  level.world->query<components::Position, components::Tile>([&](auto, auto &pos, auto &entity_glyph) {
-    auto sprite = textures::get_map_sprite(entity_glyph.display);
-    sprite.setPosition({float(pos.location.x * MAP_TILE_DIM), float(pos.location.y * MAP_TILE_DIM)});
-    render.draw(sprite);
-  });
-
-  render.display();
-  return sf::Sprite{render.getTexture()};
-}
-
 TEST_CASE("map image test", "[map-sprite]") {
   components::init();
   textures::init();
 
   LevelManager levels;
   GameLevel level = levels.current();
+  Matrix map_tiles = matrix::make(7,7);
+  System::draw_map(level, map_tiles, 2);
+
   // on level start make one render texture with the base map
   auto render = std::make_shared<sf::RenderTexture>();
-  auto map_sprite = render_map(level, *render);
+  auto map_sprite = render_map(map_tiles, *render);
-
-  // every turn render the map to the entities texture, then render
-  // entities on this image, that way I just have to render them
-  auto entities = std::make_shared<sf::RenderTexture>(render->getSize());
-  render_entities(level, map_sprite, *entities);
 
   // confirm we get two different maps
   auto out_img = render->getTexture().copyToImage();
   bool worked = out_img.saveToFile("map_render.png");
   REQUIRE(worked);
-
-  // this has entities on it
-  out_img = entities->getTexture().copyToImage();
-  worked = out_img.saveToFile("map_entities.png");
-  REQUIRE(worked);
 }