Support multiple map layers, fix transparent tiles

5 files changed, 53 insertions, 35 deletions

diff --git a/resources/sprite/entity/square.png b/resources/sprite/entity/square.png
index a386db7..cdc6981 100644
--- a/resources/sprite/entity/square.png
+++ b/resources/sprite/entity/square.png
diff --git a/resources/sprite/tile/horizontal_bar.png b/resources/sprite/tile/horizontal_bar.png
new file mode 100644
index 0000000..08f99de
--- /dev/null
+++ b/resources/sprite/tile/horizontal_bar.png
diff --git a/src/model/Map.cpp b/src/model/Map.cpp
index db18baf..a770ee4 100644
--- a/src/model/Map.cpp
+++ b/src/model/Map.cpp
@@ -35,13 +35,22 @@ std::shared_ptr<Map> Map::load(__attribute__((unused)) const std::string &name)
 	std::shared_ptr<Map> map(new Map(16, 16));
 
 	map->tileset.push_back("dirt");
+	map->tileset.push_back("horizontal_bar");
+
+	for (int i = 0; i < 2; i++)
+		map->tiles.emplace_back(new uint32_t[16*16]);
 
 	for (int i = 0; i < 16; i++) {
 		for (int j = 0; j < 16; j++) {
 			if (4 <= i && i < 12 && 4 <= j && j < 12)
-				map->setTileAt(i, j, 1);
+				map->setTileAt(0, i, j, 1);
+			else
+				map->setTileAt(0, i, j, 0);
+
+			if (4 <= i && i < 12 && j == 8)
+				map->setTileAt(1, i, j, 2);
 			else
-				map->setTileAt(i, j, 0);
+				map->setTileAt(1, i, j, 0);
 		}
 	}
 
diff --git a/src/model/Map.hpp b/src/model/Map.hpp
index 9d4eded..423c91d 100644
--- a/src/model/Map.hpp
+++ b/src/model/Map.hpp
@@ -44,14 +44,14 @@ private:
 	std::vector<std::string> tileset;
 
 	size_t width, height;
-	std::unique_ptr<uint32_t[]> tiles;
+	std::vector<std::unique_ptr<uint32_t[]>> tiles;
 
 	std::shared_ptr<Entity> playerEntity;
 	mutable std::deque<std::shared_ptr<Entity>> entities;
 
 
 	Map(size_t width0, size_t height0)
-		: width(width0), height(height0), tiles(new uint32_t[width*height]) {
+		: width(width0), height(height0) {
 	}
 
 public:
@@ -79,18 +79,22 @@ public:
 		return height;
 	}
 
-	void setTileAt(size_t x, size_t y, uint32_t value) {
-		if (x >= width || y >= height)
+	size_t getLayerCount() const {
+		return tiles.size();
+	}
+
+	void setTileAt(size_t layer, size_t x, size_t y, uint32_t value) {
+		if (layer >= tiles.size() || x >= width || y >= height)
 			throw std::range_error("Map::setTileAt: bad coordinates");
 
-		tiles[y*width + x] = value;
+		tiles[layer][y*width + x] = value;
 	}
 
-	uint32_t getTileAt(ssize_t x, ssize_t y) const {
-		if (x < 0 || (size_t)x >= width || y < 0 || (size_t)y >= height)
+	uint32_t getTileAt(size_t layer, ssize_t x, ssize_t y) const {
+		if (layer >= tiles.size() || x < 0 || (size_t)x >= width || y < 0 || (size_t)y >= height)
 			return 0;
 
-		return tiles[y*width + x];
+		return tiles[layer][y*width + x];
 	}
 
 	static std::shared_ptr<Map> load(const std::string &name);
diff --git a/src/view/MapView.cpp b/src/view/MapView.cpp
index 4938c5d..d511c31 100644
--- a/src/view/MapView.cpp
+++ b/src/view/MapView.cpp
@@ -48,12 +48,11 @@ MapView::MapView(const std::shared_ptr<Window> &window0,
 	amask = 0xff000000;
 #endif
 
+	SpriteCache *spriteCache = window->getSpriteCache();
+
 	const std::vector<std::string> &tileset = map->getTileset();
 
 	SDL_Surface *surface = SDL_CreateRGBSurface(0, getTileSize()*tileset.size(), getTileSize(), 32, rmask, gmask, bmask, amask);
-	SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_NONE);
-
-	SpriteCache *spriteCache = window->getSpriteCache();
 
 	for (size_t i = 0; i < tileset.size(); i++) {
 		SDL_Rect rect = {
@@ -63,7 +62,11 @@ MapView::MapView(const std::shared_ptr<Window> &window0,
 			.h = 0,
 		};
 
-		SDL_BlitSurface(spriteCache->get("tile", tileset[i]), nullptr, surface, &rect);
+		SDL_Surface *sprite = spriteCache->get("tile", tileset[i]);
+
+		SDL_SetSurfaceBlendMode(sprite, SDL_BLENDMODE_NONE);
+		SDL_BlitSurface(sprite, nullptr, surface, &rect);
+		SDL_SetSurfaceBlendMode(sprite, SDL_BLENDMODE_BLEND);
 	}
 
 	tiles = SDL_CreateTextureFromSurface(window->getRenderer(), surface);
@@ -98,27 +101,29 @@ void MapView::render(float centerX, float centerY, uint64_t time) {
 
 	int baseX = viewport.first/2 - int(centerX * tilePixels) - tilePixels/2, baseY = viewport.second/2 - int(centerY * tilePixels) - tilePixels/2;
 
-	for (int x = minX; x <= maxX; x++) {
-		for (int y = minY; y <= maxY; y++) {
-			uint32_t tile = map->getTileAt(x, y);
-			if (!tile)
-				continue;
-
-			SDL_Rect src = {
-				.x = int(getTileSize()*(tile-1)),
-				.y = 0,
-				.w = getTileSize(),
-				.h = getTileSize(),
-			};
-
-			SDL_Rect dst = {
-				.x = baseX + x*tilePixels,
-				.y = baseY + y*tilePixels,
-				.w = tilePixels,
-				.h = tilePixels,
-			};
-
-			SDL_RenderCopy(window->getRenderer(), tiles, &src, &dst);
+	for (size_t layer = 0; layer < map->getLayerCount(); layer++) {
+		for (int x = minX; x <= maxX; x++) {
+			for (int y = minY; y <= maxY; y++) {
+				uint32_t tile = map->getTileAt(layer, x, y);
+				if (!tile)
+					continue;
+
+				SDL_Rect src = {
+					.x = int(getTileSize()*(tile-1)),
+					.y = 0,
+					.w = getTileSize(),
+					.h = getTileSize(),
+				};
+
+				SDL_Rect dst = {
+					.x = baseX + x*tilePixels,
+					.y = baseY + y*tilePixels,
+					.w = tilePixels,
+					.h = tilePixels,
+				};
+
+				SDL_RenderCopy(window->getRenderer(), tiles, &src, &dst);
+			}
 		}
 	}