223 lines
7.6 KiB
C++
223 lines
7.6 KiB
C++
/*
|
|
*
|
|
* TileMapComponent.h
|
|
*
|
|
* Created on: Mar 21, 2020
|
|
* Author: ayoungblood
|
|
*/
|
|
|
|
#ifndef SRC_ECS_TILEMAPCOMPONENT_H_
|
|
#define SRC_ECS_TILEMAPCOMPONENT_H_
|
|
|
|
#include "ECS.h"
|
|
#include <SDL2/SDL.h>
|
|
#include "../assetmgr/AssetManager.h"
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include "../tileson/tileson.hpp"
|
|
|
|
class TileMapComponent : public Component
|
|
{
|
|
public:
|
|
SDL_Texture* texture;
|
|
SDL_Rect srcRect, destRect;
|
|
//tmxparser::TmxMap map;
|
|
tson::Tileson t;
|
|
std::unique_ptr<tson::Map> map;
|
|
int globalScale;
|
|
std::vector<SDL_Rect> tileSet;
|
|
std::vector<SDL_Rect> destRects;
|
|
std::vector<std::tuple<int,int>> initialPositions;
|
|
int tileSetTotal;
|
|
std::vector<std::vector<int>> colliders;
|
|
int tilesWide;
|
|
int tilesHigh;
|
|
int tileWidth;
|
|
|
|
TileMapComponent() = default;
|
|
|
|
~TileMapComponent()
|
|
{
|
|
SDL_DestroyTexture(texture);
|
|
}
|
|
|
|
TileMapComponent(std::string mapPath, int gScale, int offsetX, int offsetY)
|
|
{
|
|
// ***********************************************************************************
|
|
// TILESON ~~~~~~~~~~~
|
|
|
|
//tson::Tileson t;
|
|
const std::filesystem::path jsonPath = std::filesystem::u8path(mapPath);
|
|
map = t.parse(jsonPath);
|
|
|
|
std::cout << jsonPath << std::endl;
|
|
if(map->getStatus() == tson::ParseStatus::OK)
|
|
{
|
|
printf("Tileson successfully parsed the tilemap\n");
|
|
std::cout << map->getStatusMessage() << std::endl;
|
|
|
|
//map = loadedMap;
|
|
tson::Tileset *tileset = map->getTileset("br-tiles");
|
|
//tson::Tileset *collisionTS = map->getTileset("Collision");
|
|
//std::cout << "Image Path: " << tileset->getImage() << std::endl;
|
|
std::string fullPath = tileset->getImage();
|
|
|
|
size_t charPos = fullPath.find("assets");
|
|
fullPath.erase(0,charPos);
|
|
|
|
//std::cout << "Updated path: " << fullPath << std::endl;
|
|
tson::Layer *tileLayer = map->getLayer("Tile Layer 1"); //This is a Layer
|
|
std::string texName = tileLayer->getName();
|
|
std::cout << "texName: " << texName << std::endl;
|
|
std::cout << "fullPath: " << fullPath << std::endl;
|
|
//std::string texturePath = fullPath;
|
|
Game::assets->AddTexture(texName, fullPath.c_str());
|
|
setTex(texName);
|
|
globalScale = gScale;
|
|
|
|
tson::Layer *collisionLayer = map->getLayer("Collision");
|
|
// std::cout << "Collider 0,2: " << collisionLayer->getTileData(0,2)->getId() << std::endl;
|
|
// std::cout << "Collider 1,2: " << collisionLayer->getTileData(1,2)->getId() << std::endl;
|
|
// std::cout << "Collider 2,2: " << collisionLayer->getTileData(2,2)->getId() << std::endl;
|
|
// if (collisionLayer->getTileData(3,2)){
|
|
// std::cout << "Collider 3,2: " << collisionLayer->getTileData(3,2)->getId() << std::endl;
|
|
// } else {
|
|
// printf("null found instead of collider \n");
|
|
// }
|
|
//colliders.resize(map.height, std::vector<int>(map.width, 0));
|
|
tilesWide = map->getSize().x;
|
|
// printf("tilesWide: %d\n",tilesWide);
|
|
tilesHigh = map->getSize().y;
|
|
// printf("tilesHigh: %d\n",tilesHigh);
|
|
tileWidth = map->getTileSize().x;
|
|
// printf("tileSizeWidth: %d\n",tileWidth);
|
|
Game::levelMap.w = tilesWide*tileWidth*globalScale;
|
|
Game::levelMap.h = tilesHigh*tileWidth*globalScale;
|
|
|
|
|
|
// =========== Setup Tile Set ===========
|
|
|
|
tileSetTotal = tileset->getTileCount();
|
|
tileSet.resize(tileSetTotal);
|
|
int tileSetCols = tileset->getColumns();
|
|
// std::cout << "tileSet Cols: " << tileSetCols << std::endl;
|
|
int tileSetRows = tileSetTotal/tileSetCols;
|
|
// std::cout << "tileSet Rows: " << tileSetRows << std::endl;
|
|
// std::cout << "TileSetTotal: " << tileSetTotal << std::endl;
|
|
|
|
for (int r=0;r<tileSetRows;r++){
|
|
for (int c=0;c<tileSetCols;c++){
|
|
srcRect.x = c*tileWidth;
|
|
srcRect.y = r*tileWidth;
|
|
srcRect.w = srcRect.h = tileWidth;
|
|
int element = r*tileSetCols+c;
|
|
tileSet[element] = srcRect;
|
|
//std::cout << "Element: " << element << " X: " << srcRect.x << " Y: " << srcRect.y << std::endl;
|
|
}
|
|
}
|
|
|
|
if(tileLayer->getType() == tson::LayerType::TileLayer)
|
|
{
|
|
destRects.resize(tilesWide*tilesHigh);
|
|
initialPositions.resize(tilesWide*tilesHigh);
|
|
for (int r=0;r<tilesHigh;r++){
|
|
for (int c=0;c<tilesWide;c++){
|
|
int elem = c+r*tilesWide;
|
|
SDL_Rect thisRect = SDL_Rect();
|
|
thisRect.x = c*tileWidth*globalScale;
|
|
thisRect.y = r*tileWidth*globalScale;
|
|
thisRect.w = thisRect.h = tileWidth*globalScale;
|
|
std::tuple<int,int> ogPos = std::make_tuple(thisRect.x,thisRect.y);
|
|
initialPositions[elem] = ogPos;
|
|
thisRect.x = thisRect.x-offsetX*globalScale;
|
|
thisRect.y = thisRect.y=offsetY*globalScale;
|
|
destRects[elem] = thisRect;
|
|
}
|
|
}
|
|
destRect.w = destRect.h = tileWidth * gScale;
|
|
|
|
|
|
// std::cout << "destRect[0] .x: " << destRects[0].x << " .y " << destRects[0].y << " .w " << destRects[0].w << " .h " << destRects[0].h << std::endl;
|
|
// std::cout << "destRect[1] .x: " << destRects[1].x << " .y " << destRects[1].y << " .w " << destRects[1].w << " .h " << destRects[1].h << std::endl;
|
|
//
|
|
// std::cout << "tileSet[0] .x: " << tileSet[0].x << " .y " << tileSet[0].y << " .w " << tileSet[0].w << " .h " << tileSet[0].h << std::endl;
|
|
// std::cout << "tileSet[1] .x: " << tileSet[1].x << " .y " << tileSet[1].y << " .w " << tileSet[1].w << " .h " << tileSet[0].h << std::endl;
|
|
|
|
//std::cout << "Tile id: " << tileObject.getTile()->getId() << std::endl;
|
|
|
|
//std::cout << "Tile column: " << col << std::endl;
|
|
//std::cout << "Tile row: " << row << std::endl;
|
|
//std::cout << "X: " << drawingRect.x << std::endl;
|
|
//std::cout << "Y: " << drawingRect.y << std::endl;
|
|
//std::cout << "Width: " << drawingRect.width << std::endl;
|
|
//std::cout << "height: " << drawingRect.height << std::endl;
|
|
//std::cout << "col % tilesWide: " << col%tilesWide << std::endl;
|
|
|
|
|
|
// tson::Layer *myLayer = map->getLayer("Tile Layer 1");
|
|
// tson::Tile *myTile1 = myLayer->getTileData(0,0);
|
|
// int tid1 = myTile1->getId()-1;
|
|
// tson::Tile *myTile2 = myLayer->getTileData(1,0);
|
|
// int tid2 = myTile2->getId()-1;
|
|
// tson::Tile *myTile3 = myLayer->getTileData(2,0);
|
|
// int tid3 = myTile3->getId()-1;
|
|
// tson::Tile *myTile4 = myLayer->getTileData(3,0);
|
|
// int tid4 = myTile4->getId()-1;
|
|
// std::cout << "First tile row's Ids: " << tid1 << ", " << tid2 << ", " << tid3 << ", " << tid4 << ", " << std::endl;
|
|
}
|
|
|
|
} else {
|
|
printf("Failed to load Tileson map\n");
|
|
std::cout << map->getStatusMessage();
|
|
}
|
|
//std::cout << "texture var: " << texture << std::endl;
|
|
}
|
|
|
|
void update() override
|
|
{
|
|
// if (Game::gsm->currentState == GameStateManager::ST_COREGAME){
|
|
|
|
for (int i=0;i<destRects.size();i++){
|
|
destRects[i].x = std::get<0>(initialPositions[i]) - Game::camera.x;
|
|
destRects[i].y = std::get<1>(initialPositions[i]) - Game::camera.y;
|
|
}
|
|
// }
|
|
}
|
|
|
|
void draw() override
|
|
{
|
|
//iterate through rows and columns of the map to draw the tiles
|
|
// First cycle through rows
|
|
tson::Layer *myLayer = map->getLayer("Tile Layer 1");
|
|
tson::Layer *collisionLayer = map->getLayer("Collision");
|
|
for (int r = 0;r<map->getSize().y;r++){
|
|
// Next cycle through each column or tile in that row:
|
|
for (int c = 0;c<map->getSize().x;c++){
|
|
int i = r*map->getSize().x+c;
|
|
int elem = c+r*map->getSize().x;
|
|
tson::Tile *myTile = myLayer->getTileData(c,r);
|
|
int tid = myTile->getId()-1;
|
|
int tileToDraw = tid;
|
|
TextureManager::Draw(texture, tileSet[tileToDraw], destRects[elem], SDL_FLIP_NONE);
|
|
if (Game::debugMenu){
|
|
if (collisionLayer->getTileData(c,r)) {
|
|
SDL_SetRenderDrawColor(Game::renderer,255,0,255,134);
|
|
SDL_RenderDrawRect(Game::renderer, &destRects[elem]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void setTex(std::string id)
|
|
{
|
|
texture = Game::assets->GetTexture(id);
|
|
}
|
|
};
|
|
|
|
#endif /* SRC_ECS_TILEMAPCOMPONENT_H_ */
|
|
|