diff --git a/src/common/ResourceManager.cpp b/src/common/ResourceManager.cpp index 74dec177..e1b7df5e 100644 --- a/src/common/ResourceManager.cpp +++ b/src/common/ResourceManager.cpp @@ -347,7 +347,7 @@ bool CResourceManager::LoadGameGraphics() { const char * graphicspack = gamegraphicspacklist->current_name(); - g_tilesetmanager->Init(graphicspack); + g_tilesetmanager->init(graphicspack); bool loadok = true; loadok &= game_font_small.init(convertPath("gfx/packs/fonts/font_small.png", graphicspack)); diff --git a/src/common/TilesetManager.cpp b/src/common/TilesetManager.cpp index c185885a..1f59645b 100644 --- a/src/common/TilesetManager.cpp +++ b/src/common/TilesetManager.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #if defined(__APPLE__) #include @@ -114,7 +115,7 @@ void CTileset::Draw(SDL_Surface* dstSurface, short tileSize, SDL_Rect* srcRect, } -void CTileset::SaveTileset() +void CTileset::saveTileset() const { BinaryFile tsf(m_tilesetPath.c_str(), "wb"); if (!tsf.is_open()) { @@ -137,165 +138,151 @@ void CTileset::SaveTileset() * CTilesetManager *********************************/ -CTilesetManager::CTilesetManager() : - SimpleDirectoryList(convertPath("gfx/packs/Classic/tilesets/")) +CTilesetManager::CTilesetManager() + : SimpleDirectoryList(convertPath("gfx/packs/Classic/tilesets/")) {} -CTilesetManager::~CTilesetManager() -{} -void CTilesetManager::Init(const char * szGfxPack) +void CTilesetManager::init(const std::string& gfxPack) { - //Remove all existing tilesets - std::vector::iterator iter = tilesetlist.begin(), lim = tilesetlist.end(); - while (iter != lim) { - delete (*iter); - - iter = tilesetlist.erase(iter); - lim = tilesetlist.end(); - } - - //Add in tilesets from the new gfxpack (if the gfxpack isn't "Classic") - if (strcmp(getFileFromPath(szGfxPack).c_str(), "Classic")) { - std::string s = convertPath("gfx/packs/tilesets", szGfxPack) + '/'; - SimpleDirectoryList dirlist(s); - - short iLength = dirlist.GetCount(); - for (short i = 0; i < iLength; i++) { - CTileset * tileset = new CTileset(dirlist.current_name()); - tilesetlist.push_back(tileset); - - //If the tileset is "classic" then keep it's index for common operations - if (tileset->name() == "Classic") { - tClassicTileset = tileset; - iClassicTilesetIndex = i; - } - - dirlist.next(); - } - } - - //Add in tilesets from the classic tileset to fill the gaps - short iLength = filelist.size(); - char szTilesetName[128]; - for (short i = 0; i < iLength; i++) { - strncpy(szTilesetName, getFileFromPath(filelist[i]).c_str(), 128); - szTilesetName[127] = 0; - - //See if the new tileset already exists and if it does, skip it - short iTilesetSize = tilesetlist.size(); - bool fFound = false; - for (short iTileset = 0; iTileset < iTilesetSize; iTileset++) { - if (tilesetlist[iTileset]->name() == szTilesetName) { - fFound = true; - break; - } - } - - //Add the tileset if another one by the same name isn't already in the tileset - if (!fFound) { - CTileset * tileset = new CTileset(filelist[i].c_str()); - tilesetlist.push_back(tileset); + //Remove all existing tilesets + m_tilesetlist.clear(); + + //Add in tilesets from the new gfxpack (if the gfxpack isn't "Classic") + if (getFileFromPath(gfxPack) != "Classic") { + std::string s = convertPath("gfx/packs/tilesets", gfxPack) + '/'; + SimpleDirectoryList dirlist(s); + + for (short i = 0; i < dirlist.GetCount(); i++) { + std::unique_ptr tileset = std::make_unique(dirlist.current_name()); + + //If the tileset is "classic" then keep it's index for common operations + if (tileset->name() == "Classic") + m_classicTilesetIndex = i; + + m_tilesetlist.emplace_back(std::move(tileset)); + dirlist.next(); + } + } - if (tileset->name() == "Classic") { - tClassicTileset = tileset; - iClassicTilesetIndex = i; - } - } - } + //Add in tilesets from the classic tileset to fill the gaps + for (size_t i = 0; i < filelist.size(); i++) { + const std::string tilesetName = getFileFromPath(filelist[i]); - InitTilesetRects(); + //See if the new tileset already exists and if it does, skip it + bool fFound = false; + for (size_t iTileset = 0; iTileset < m_tilesetlist.size(); iTileset++) { + if (m_tilesetlist[iTileset]->name() == tilesetName) { + fFound = true; + break; + } + } + + //Add the tileset if another one by the same name isn't already in the tileset + if (!fFound) { + std::unique_ptr tileset = std::make_unique(filelist[i]); + if (tileset->name() == "Classic") { + m_classicTilesetIndex = i; + } + m_tilesetlist.emplace_back(std::move(tileset)); + } + } + + initTilesetRects(); } -void CTilesetManager::InitTilesetRects() + +void CTilesetManager::initTilesetRects() { - size_t max_tileset_rows = 0; - for (CTileset* tileset : tilesetlist) { - max_tileset_rows = std::max(max_tileset_rows, tileset->height()); - max_tileset_cols = std::max(max_tileset_cols, tileset->width()); - } - - const size_t tile_count = max_tileset_rows * max_tileset_cols; - rects_ingame.reserve(tile_count); - rects_preview.reserve(tile_count); - rects_thumb.reserve(tile_count); - - short y1 = 0, y2 = 0, y3 = 0; - for (size_t row = 0; row < max_tileset_rows; row++) { - short x1 = 0, x2 = 0, x3 = 0; - for (size_t col = 0; col < max_tileset_cols; col++) { - rects_ingame.emplace_back(SDL_Rect { x1, y1, TILESIZE, TILESIZE }); - rects_preview.emplace_back(SDL_Rect { x2, y2, PREVIEWTILESIZE, PREVIEWTILESIZE }); - rects_thumb.emplace_back(SDL_Rect { x3, y3, THUMBTILESIZE, THUMBTILESIZE }); - - x1 += TILESIZE; - x2 += PREVIEWTILESIZE; - x3 += THUMBTILESIZE; - } - - y1 += TILESIZE; - y2 += PREVIEWTILESIZE; - y3 += THUMBTILESIZE; - } + size_t max_tileset_rows = 0; + for (const std::unique_ptr& tileset : m_tilesetlist) { + max_tileset_rows = std::max(max_tileset_rows, tileset->height()); + m_max_tileset_cols = std::max(m_max_tileset_cols, tileset->width()); + } + + const size_t tile_count = max_tileset_rows * m_max_tileset_cols; + m_rects_ingame.reserve(tile_count); + m_rects_preview.reserve(tile_count); + m_rects_thumb.reserve(tile_count); + + short y1 = 0, y2 = 0, y3 = 0; + for (size_t row = 0; row < max_tileset_rows; row++) { + short x1 = 0, x2 = 0, x3 = 0; + for (size_t col = 0; col < m_max_tileset_cols; col++) { + m_rects_ingame.emplace_back(SDL_Rect { x1, y1, TILESIZE, TILESIZE }); + m_rects_preview.emplace_back(SDL_Rect { x2, y2, PREVIEWTILESIZE, PREVIEWTILESIZE }); + m_rects_thumb.emplace_back(SDL_Rect { x3, y3, THUMBTILESIZE, THUMBTILESIZE }); + + x1 += TILESIZE; + x2 += PREVIEWTILESIZE; + x3 += THUMBTILESIZE; + } + + y1 += TILESIZE; + y2 += PREVIEWTILESIZE; + y3 += THUMBTILESIZE; + } } -short CTilesetManager::GetIndexFromName(const char * szName) + +size_t CTilesetManager::indexFromName(const std::string& name) const { - for (size_t i = 0; i < tilesetlist.size(); i++) { - if (tilesetlist[i]->name() == szName) + for (size_t i = 0; i < m_tilesetlist.size(); i++) { + if (m_tilesetlist[i]->name() == name) return i; } return TILESETUNKNOWN; } + void CTilesetManager::Draw(SDL_Surface * dstSurface, short iTilesetID, short iTileSize, short iSrcTileCol, short iSrcTileRow, short iDstTileCol, short iDstTileRow) { - assert(0 <= iTilesetID && static_cast(iTilesetID) < tilesetlist.size()); - assert(iSrcTileCol >= 0 && iSrcTileRow >= 0); - assert(iDstTileCol >= 0 && iDstTileRow >= 0); + assert(0 <= iTilesetID && static_cast(iTilesetID) < m_tilesetlist.size()); + assert(iSrcTileCol >= 0 && iSrcTileRow >= 0); + assert(iDstTileCol >= 0 && iDstTileRow >= 0); - const size_t src_rect_idx = iSrcTileRow * max_tileset_cols + iSrcTileCol; - const size_t dst_rect_idx = iDstTileRow * max_tileset_cols + iDstTileCol; + const size_t src_rect_idx = iSrcTileRow * m_max_tileset_cols + iSrcTileCol; + const size_t dst_rect_idx = iDstTileRow * m_max_tileset_cols + iDstTileCol; - SDL_Rect* src_rect = GetRect(iTileSize, src_rect_idx); - SDL_Rect* dst_rect = GetRect(iTileSize, dst_rect_idx); + SDL_Rect* src_rect = rect(iTileSize, src_rect_idx); + SDL_Rect* dst_rect = rect(iTileSize, dst_rect_idx); - tilesetlist[iTilesetID]->Draw(dstSurface, iTileSize, src_rect, dst_rect); + m_tilesetlist[iTilesetID]->Draw(dstSurface, iTileSize, src_rect, dst_rect); } -CTileset * CTilesetManager::GetTileset(short iTilesetID) -{ - if (iTilesetID < 0 || iTilesetID >= (short)tilesetlist.size()) - return NULL; - return tilesetlist[iTilesetID]; +CTileset* CTilesetManager::tileset(size_t index) +{ + return index < m_tilesetlist.size() + ? m_tilesetlist[index].get() + : nullptr; } -SDL_Rect* CTilesetManager::GetRect(short size_id, short col, short row) + +SDL_Rect* CTilesetManager::rect(short size_id, short col, short row) { - const size_t rect_idx = row * max_tileset_cols + col; - return GetRect(size_id, rect_idx); + const size_t rect_idx = row * m_max_tileset_cols + col; + return rect(size_id, rect_idx); } -SDL_Rect* CTilesetManager::GetRect(short size_id, size_t idx) + +SDL_Rect* CTilesetManager::rect(short size_id, size_t idx) { - assert(0 <= size_id && size_id < 3); - assert(idx < rects_ingame.size()); - - switch (size_id) { - case 0: return &rects_ingame[idx]; - case 1: return &rects_preview[idx]; - case 2: return &rects_thumb[idx]; - default: return nullptr; - } + assert(0 <= size_id && size_id < 3); + assert(idx < m_rects_ingame.size()); + + switch (size_id) { + case 0: return &m_rects_ingame[idx]; + case 1: return &m_rects_preview[idx]; + case 2: return &m_rects_thumb[idx]; + default: return nullptr; + } } -void CTilesetManager::SaveTilesets() -{ - short iLength = tilesetlist.size(); - for (short i = 0; i < iLength; i++) { - tilesetlist[i]->SaveTileset(); - } +void CTilesetManager::saveTilesets() const +{ + for (const std::unique_ptr& tileset : m_tilesetlist) + tileset->saveTileset(); } diff --git a/src/common/TilesetManager.h b/src/common/TilesetManager.h index 201f24e7..1219c73a 100644 --- a/src/common/TilesetManager.h +++ b/src/common/TilesetManager.h @@ -1,18 +1,18 @@ -#ifndef TILESETMANAGER_H -#define TILESETMANAGER_H +#pragma once #include "FileList.h" -#include "gfx/gfxSprite.h" #include "map.h" #include +#include #include + class CTileset { public: CTileset(const std::string& dir); - void SaveTileset(); + void saveTileset() const; TileType tileType(size_t iTileCol, size_t iTileRow) const; void setTileType(size_t iTileCol, size_t iTileRow, TileType type); @@ -39,41 +39,37 @@ class CTileset { //it was kinda a bad idea to have skinlist and announcer list based on this, because both are accessed in different ways (skinlist like an vector and announcer list like a list). grrrr -class CTilesetManager : public SimpleDirectoryList -{ - public: - CTilesetManager(); - virtual ~CTilesetManager(); - void Init(const char * szGfxPack); +class CTilesetManager : public SimpleDirectoryList { +public: + CTilesetManager(); + + void init(const std::string& gfxPack); - short GetIndexFromName(const char * szName); + size_t indexFromName(const std::string& name) const; - void Draw(SDL_Surface * dstSurface, short iTilesetID, short iTileSize, short iSrcTileCol, short iSrcTileRow, short iDstTileCol, short iDstTileRow); + void Draw(SDL_Surface * dstSurface, short iTilesetID, short iTileSize, short iSrcTileCol, short iSrcTileRow, short iDstTileCol, short iDstTileRow); - void SaveTilesets(); + void saveTilesets() const; - CTileset * GetClassicTileset() { - return tClassicTileset; + size_t classicTilesetIndex() const { + return m_classicTilesetIndex; } - short GetClassicTilesetIndex() { - return iClassicTilesetIndex; + const CTileset& classicTileset() const { + return *m_tilesetlist.at(classicTilesetIndex()); } - CTileset * GetTileset(short iID); - SDL_Rect* GetRect(short size_id, short col, short row); - SDL_Rect* GetRect(short size_id, size_t idx); + CTileset* tileset(size_t index); + SDL_Rect* rect(short size_id, short col, short row); + SDL_Rect* rect(short size_id, size_t idx); - private: - std::vector tilesetlist; - CTileset* tClassicTileset = nullptr; - short iClassicTilesetIndex; +private: + std::vector> m_tilesetlist; // TODO: Store objects + size_t m_classicTilesetIndex = SIZE_MAX; - std::vector rects_ingame; - std::vector rects_preview; - std::vector rects_thumb; - size_t max_tileset_cols = 0; + std::vector m_rects_ingame; + std::vector m_rects_preview; + std::vector m_rects_thumb; + size_t m_max_tileset_cols = 0; - void InitTilesetRects(); + void initTilesetRects(); }; - -#endif // TILESETMANAGER_H diff --git a/src/common/map.cpp b/src/common/map.cpp index d9130cc0..3c7b1207 100644 --- a/src/common/map.cpp +++ b/src/common/map.cpp @@ -264,12 +264,12 @@ void DrawPlatform(short pathtype, TilesetTile ** tiles, short startX, short star SDL_Rect bltrect = {iDstX, iDstY, iTileSize, iTileSize}; if (tile->iID >= 0) { - SDL_BlitSurface(g_tilesetmanager->GetTileset(tile->iID)->surface(iSize), g_tilesetmanager->GetRect(iSize, tile->iCol, tile->iRow), blitdest, &bltrect); + SDL_BlitSurface(g_tilesetmanager->tileset(tile->iID)->surface(iSize), g_tilesetmanager->rect(iSize, tile->iCol, tile->iRow), blitdest, &bltrect); } else if (tile->iID == TILESETANIMATED) { - SDL_BlitSurface(rm->spr_tileanimation[iSize].getSurface(), g_tilesetmanager->GetRect(iSize, tile->iCol * 4, tile->iRow), blitdest, &bltrect); + SDL_BlitSurface(rm->spr_tileanimation[iSize].getSurface(), g_tilesetmanager->rect(iSize, tile->iCol * 4, tile->iRow), blitdest, &bltrect); } else if (tile->iID == TILESETUNKNOWN) { //Draw unknown tile - SDL_BlitSurface(rm->spr_unknowntile[iSize].getSurface(), g_tilesetmanager->GetRect(iSize, 0, 0), blitdest, &bltrect); + SDL_BlitSurface(rm->spr_unknowntile[iSize].getSurface(), g_tilesetmanager->rect(iSize, 0, 0), blitdest, &bltrect); } bool fNeedWrap = false; @@ -288,11 +288,11 @@ void DrawPlatform(short pathtype, TilesetTile ** tiles, short startX, short star bltrect.h = iTileSize; if (tile->iID >= 0) - SDL_BlitSurface(g_tilesetmanager->GetTileset(tile->iID)->surface(iSize), g_tilesetmanager->GetRect(iSize, tile->iCol, tile->iRow), blitdest, &bltrect); + SDL_BlitSurface(g_tilesetmanager->tileset(tile->iID)->surface(iSize), g_tilesetmanager->rect(iSize, tile->iCol, tile->iRow), blitdest, &bltrect); else if (tile->iID == TILESETANIMATED) - SDL_BlitSurface(rm->spr_tileanimation[iSize].getSurface(), g_tilesetmanager->GetRect(iSize, tile->iCol * 4, tile->iRow), blitdest, &bltrect); + SDL_BlitSurface(rm->spr_tileanimation[iSize].getSurface(), g_tilesetmanager->rect(iSize, tile->iCol * 4, tile->iRow), blitdest, &bltrect); else if (tile->iID == TILESETUNKNOWN) - SDL_BlitSurface(rm->spr_unknowntile[iSize].getSurface(), g_tilesetmanager->GetRect(iSize, 0, 0), blitdest, &bltrect); + SDL_BlitSurface(rm->spr_unknowntile[iSize].getSurface(), g_tilesetmanager->rect(iSize, 0, 0), blitdest, &bltrect); } } } @@ -919,7 +919,7 @@ void CMap::saveMap(const std::string& file) mapfile.write_i32(iTileset); //Tileset Name - mapfile.write_string_long(g_tilesetmanager->GetTileset(iTileset)->name().c_str()); + mapfile.write_string_long(g_tilesetmanager->tileset(iTileset)->name().c_str()); } } @@ -936,10 +936,10 @@ void CMap::saveMap(const std::string& file) //Make sure the tile's col and row are within the tileset if (tile->iID >= 0) { - if (tile->iCol < 0 || tile->iCol >= g_tilesetmanager->GetTileset(tile->iID)->width()) + if (tile->iCol < 0 || tile->iCol >= g_tilesetmanager->tileset(tile->iID)->width()) tile->iCol = 0; - if (tile->iRow < 0 || tile->iRow >= g_tilesetmanager->GetTileset(tile->iID)->height()) + if (tile->iRow < 0 || tile->iRow >= g_tilesetmanager->tileset(tile->iID)->height()) tile->iRow = 0; } @@ -974,10 +974,10 @@ void CMap::saveMap(const std::string& file) //Make sure the tile's col and row are within the tileset if (tile->iID >= 0) { - if (tile->iCol < 0 || tile->iCol >= g_tilesetmanager->GetTileset(tile->iID)->width()) + if (tile->iCol < 0 || tile->iCol >= g_tilesetmanager->tileset(tile->iID)->width()) tile->iCol = 0; - if (tile->iRow < 0 || tile->iRow >= g_tilesetmanager->GetTileset(tile->iID)->height()) + if (tile->iRow < 0 || tile->iRow >= g_tilesetmanager->tileset(tile->iID)->height()) tile->iRow = 0; } @@ -1676,7 +1676,7 @@ void CMap::draw(SDL_Surface *targetSurface, int layer) animatedtiles.push_back(animatedtile); } } else if (tile->iID == TILESETUNKNOWN) { //Draw red X where tile should be - SDL_BlitSurface(rm->spr_unknowntile[0].getSurface(), g_tilesetmanager->GetRect(0, 0, 0), targetSurface, &bltrect); + SDL_BlitSurface(rm->spr_unknowntile[0].getSurface(), g_tilesetmanager->rect(0, 0, 0), targetSurface, &bltrect); } } @@ -1910,9 +1910,9 @@ void CMap::drawPreview(SDL_Surface * targetSurface, int layer, bool fThumbnail) g_tilesetmanager->Draw(targetSurface, tile->iID, iTilesetSize, tile->iCol, tile->iRow, i, j); // SDL_BlitSurface(rm->spr_maptiles[iTilesetIndex].getSurface(), &g_tilesetmanager->rRects[iTilesetSize][tile->iCol][tile->iRow], targetSurface, &rectDst); } else if (tile->iID == TILESETANIMATED) { - SDL_BlitSurface(rm->spr_tileanimation[iTilesetSize].getSurface(), g_tilesetmanager->GetRect(iTilesetSize, tile->iCol * 4, tile->iRow), targetSurface, g_tilesetmanager->GetRect(iTilesetSize, i, j)); + SDL_BlitSurface(rm->spr_tileanimation[iTilesetSize].getSurface(), g_tilesetmanager->rect(iTilesetSize, tile->iCol * 4, tile->iRow), targetSurface, g_tilesetmanager->rect(iTilesetSize, i, j)); } else if (tile->iID == TILESETUNKNOWN) { - SDL_BlitSurface(rm->spr_unknowntile[iTilesetSize].getSurface(), g_tilesetmanager->GetRect(iTilesetSize, 0, 0), targetSurface, g_tilesetmanager->GetRect(iTilesetSize, i, j)); + SDL_BlitSurface(rm->spr_unknowntile[iTilesetSize].getSurface(), g_tilesetmanager->rect(iTilesetSize, 0, 0), targetSurface, g_tilesetmanager->rect(iTilesetSize, i, j)); } } } @@ -2076,11 +2076,11 @@ void CMap::SetupAnimatedTiles() for (short iLayer = 0; iLayer < iAnimatedBackgroundLayers; iLayer++) { TilesetTile * tilesetTile = &tile->layers[iLayer]; if (tilesetTile->iID >= 0) { - SDL_BlitSurface(g_tilesetmanager->GetTileset(tilesetTile->iID)->surface(0), &(tile->rSrc[iLayer][0]), animatedTilesSurface, &rDst); + SDL_BlitSurface(g_tilesetmanager->tileset(tilesetTile->iID)->surface(0), &(tile->rSrc[iLayer][0]), animatedTilesSurface, &rDst); } else if (tilesetTile->iID == TILESETANIMATED) { SDL_BlitSurface(animatedTileSrcSurface, &(tile->rSrc[iLayer][sTileAnimationFrame]), animatedTilesSurface, &rDst); } else if (tilesetTile->iID == TILESETUNKNOWN) { - SDL_BlitSurface(rm->spr_unknowntile[0].getSurface(), g_tilesetmanager->GetRect(0, 0, 0), animatedTilesSurface, &rDst); + SDL_BlitSurface(rm->spr_unknowntile[0].getSurface(), g_tilesetmanager->rect(0, 0, 0), animatedTilesSurface, &rDst); } } @@ -2112,11 +2112,11 @@ void CMap::SetupAnimatedTiles() for (short iLayer = 2; iLayer < 4; iLayer++) { TilesetTile * tilesetTile = &tile->layers[iLayer]; if (tilesetTile->iID >= 0) { - SDL_BlitSurface(g_tilesetmanager->GetTileset(tilesetTile->iID)->surface(0), &(tile->rSrc[iLayer][0]), animatedTilesSurface, &rDst); + SDL_BlitSurface(g_tilesetmanager->tileset(tilesetTile->iID)->surface(0), &(tile->rSrc[iLayer][0]), animatedTilesSurface, &rDst); } else if (tilesetTile->iID == TILESETANIMATED) { SDL_BlitSurface(animatedTileSrcSurface, &(tile->rSrc[iLayer][sTileAnimationFrame]), animatedTilesSurface, &rDst); } else if (tilesetTile->iID == TILESETUNKNOWN) { - SDL_BlitSurface(rm->spr_unknowntile[0].getSurface(), g_tilesetmanager->GetRect(0, 0, 0), animatedTilesSurface, &rDst); + SDL_BlitSurface(rm->spr_unknowntile[0].getSurface(), g_tilesetmanager->rect(0, 0, 0), animatedTilesSurface, &rDst); } } @@ -2525,7 +2525,7 @@ void CMap::optimize() for (int i = 0; i < MAPWIDTH; i++) { for (int m = 1; m < MAPLAYERS; m++) { TilesetTile * tile = &mapdata[i][j][m]; - TileType type = g_tilesetmanager->GetTileset(tile->iID)->tileType(tile->iCol, tile->iRow); + TileType type = g_tilesetmanager->tileset(tile->iID)->tileType(tile->iCol, tile->iRow); if (type != tile_nonsolid && type != tile_gap && type != tile_solid_on_top) { for (int k = m - 1; k >= 0; k--) { TilesetTile * compareTile = &mapdata[i][j][k]; diff --git a/src/common/map/MapReader15xx.cpp b/src/common/map/MapReader15xx.cpp index 148fcaf2..e6e3acb8 100644 --- a/src/common/map/MapReader15xx.cpp +++ b/src/common/map/MapReader15xx.cpp @@ -60,11 +60,11 @@ void MapReader1500::read_tiles(CMap& map, BinaryFile& mapfile) short iTileID = (short)mapfile.read_i32(); TilesetTile * tile = &map.mapdata[i][j][1]; - tile->iID = g_tilesetmanager->GetClassicTilesetIndex(); + tile->iID = g_tilesetmanager->classicTilesetIndex(); tile->iCol = iTileID % 32; tile->iRow = iTileID / 32; - TileType iType = g_tilesetmanager->GetClassicTileset()->tileType(tile->iCol, tile->iRow); + TileType iType = g_tilesetmanager->classicTileset().tileType(tile->iCol, tile->iRow); if (iType >= 0 && iType < NUMTILETYPES) { map.mapdatatop[i][j].iType = iType; diff --git a/src/common/map/MapReader16xx.cpp b/src/common/map/MapReader16xx.cpp index 471ca711..eafa828e 100644 --- a/src/common/map/MapReader16xx.cpp +++ b/src/common/map/MapReader16xx.cpp @@ -80,7 +80,7 @@ void MapReader1600::read_tiles(CMap& map, BinaryFile& mapfile) short iTileID = g_iTileConversion[iTile]; TilesetTile * tile = &map.mapdata[i][j][k]; - tile->iID = g_tilesetmanager->GetClassicTilesetIndex(); + tile->iID = g_tilesetmanager->classicTilesetIndex(); tile->iCol = iTileID % 32; tile->iRow = iTileID / 32; } @@ -91,7 +91,7 @@ void MapReader1600::read_tiles(CMap& map, BinaryFile& mapfile) for (short k = MAPLAYERS - 1; k >= 0; k--) { TilesetTile * tile = &map.mapdata[i][j][k]; - TileType type = g_tilesetmanager->GetClassicTileset()->tileType(tile->iCol, tile->iRow); + TileType type = g_tilesetmanager->classicTileset().tileType(tile->iCol, tile->iRow); if (type != tile_nonsolid) { if (type >= 0 && type < NUMTILETYPES) { map.mapdatatop[i][j].iType = type; diff --git a/src/common/map/MapReader17xx.cpp b/src/common/map/MapReader17xx.cpp index 84e66fd2..edfec2ba 100644 --- a/src/common/map/MapReader17xx.cpp +++ b/src/common/map/MapReader17xx.cpp @@ -51,7 +51,7 @@ void MapReader1702::read_autofilters(CMap& map, BinaryFile& mapfile) void MapReader1700::read_tiles(CMap& map, BinaryFile& mapfile) { - short iClassicTilesetID = g_tilesetmanager->GetIndexFromName("Classic"); + short iClassicTilesetID = g_tilesetmanager->indexFromName("Classic"); unsigned short i, j, k; for (j = 0; j < MAPHEIGHT; j++) { @@ -282,11 +282,11 @@ void MapReader1700::read_platform_tiles(CMap& map, BinaryFile& mapfile, type = tile_nonsolid; } else { - tile->iID = g_tilesetmanager->GetClassicTilesetIndex(); + tile->iID = g_tilesetmanager->classicTilesetIndex(); tile->iCol = iTile % TILESETWIDTH; tile->iRow = iTile / TILESETWIDTH; - type = g_tilesetmanager->GetClassicTileset()->tileType(tile->iCol, tile->iRow); + type = g_tilesetmanager->classicTileset().tileType(tile->iCol, tile->iRow); } if (type >= 0 && type < NUMTILETYPES) { diff --git a/src/common/map/MapReader18xx.cpp b/src/common/map/MapReader18xx.cpp index bd9b4921..f0bfdf7d 100644 --- a/src/common/map/MapReader18xx.cpp +++ b/src/common/map/MapReader18xx.cpp @@ -78,14 +78,14 @@ void MapReader1800::read_tileset(BinaryFile& mapfile) for (short iTileset = 0; iTileset < iNumTilesets; iTileset++) { short iID = translation[iTileset].iID; - translationid[iID] = g_tilesetmanager->GetIndexFromName(translation[iTileset].szName); + translationid[iID] = g_tilesetmanager->indexFromName(translation[iTileset].szName); if (translationid[iID] == TILESETUNKNOWN) { tilesetwidths[iID] = 1; tilesetheights[iID] = 1; } else { - tilesetwidths[iID] = g_tilesetmanager->GetTileset(translationid[iID])->width(); - tilesetheights[iID] = g_tilesetmanager->GetTileset(translationid[iID])->height(); + tilesetwidths[iID] = g_tilesetmanager->tileset(translationid[iID])->width(); + tilesetheights[iID] = g_tilesetmanager->tileset(translationid[iID])->height(); } } diff --git a/src/common/movingplatform.cpp b/src/common/movingplatform.cpp index d101eb73..e21b5f5c 100644 --- a/src/common/movingplatform.cpp +++ b/src/common/movingplatform.cpp @@ -383,9 +383,9 @@ MovingPlatform::MovingPlatform(TilesetTile ** tiledata, MapTile ** tiletypes, sh if (tile->iID >= 0) { g_tilesetmanager->Draw(sSurface[iSurface], tile->iID, iTileSizeIndex, tile->iCol, tile->iRow, iCol, iRow); } else if (tile->iID == TILESETANIMATED) { - SDL_BlitSurface(rm->spr_tileanimation[iTileSizeIndex].getSurface(), g_tilesetmanager->GetRect(iTileSizeIndex, tile->iCol * 4, tile->iRow), sSurface[iSurface], g_tilesetmanager->GetRect(iTileSizeIndex, iCol, iRow)); + SDL_BlitSurface(rm->spr_tileanimation[iTileSizeIndex].getSurface(), g_tilesetmanager->rect(iTileSizeIndex, tile->iCol * 4, tile->iRow), sSurface[iSurface], g_tilesetmanager->rect(iTileSizeIndex, iCol, iRow)); } else if (tile->iID == TILESETUNKNOWN) { - SDL_BlitSurface(rm->spr_unknowntile[iTileSizeIndex].getSurface(), g_tilesetmanager->GetRect(iTileSizeIndex, 0, 0), sSurface[iSurface], g_tilesetmanager->GetRect(iTileSizeIndex, iCol, iRow)); + SDL_BlitSurface(rm->spr_unknowntile[iTileSizeIndex].getSurface(), g_tilesetmanager->rect(iTileSizeIndex, 0, 0), sSurface[iSurface], g_tilesetmanager->rect(iTileSizeIndex, iCol, iRow)); } } } diff --git a/src/leveleditor/leveleditor.cpp b/src/leveleditor/leveleditor.cpp index c5701f39..14e8e041 100644 --- a/src/leveleditor/leveleditor.cpp +++ b/src/leveleditor/leveleditor.cpp @@ -245,12 +245,12 @@ class MapPlatform SDL_Rect bltrect = {iPlatformX << 3, iPlatformY << 3, THUMBTILESIZE, THUMBTILESIZE}; if (tile->iID >= 0) { - SDL_BlitSurface(g_tilesetmanager->GetTileset(tile->iID)->surface(2), g_tilesetmanager->GetRect(2, tile->iCol, tile->iRow), preview, &bltrect); + SDL_BlitSurface(g_tilesetmanager->tileset(tile->iID)->surface(2), g_tilesetmanager->rect(2, tile->iCol, tile->iRow), preview, &bltrect); } else if (tile->iID == TILESETANIMATED) { - SDL_BlitSurface(rm->spr_tileanimation[2].getSurface(), g_tilesetmanager->GetRect(2, tile->iCol * 4, tile->iRow), preview, &bltrect); + SDL_BlitSurface(rm->spr_tileanimation[2].getSurface(), g_tilesetmanager->rect(2, tile->iCol * 4, tile->iRow), preview, &bltrect); } else if (tile->iID == TILESETUNKNOWN) { //Draw unknown tile - SDL_BlitSurface(rm->spr_unknowntile[2].getSurface(), g_tilesetmanager->GetRect(2, 0, 0), preview, &bltrect); + SDL_BlitSurface(rm->spr_unknowntile[2].getSurface(), g_tilesetmanager->rect(2, 0, 0), preview, &bltrect); } } } @@ -450,7 +450,7 @@ int main(int argc, char *argv[]) gfx_init(640,480, g_fFullScreen); blitdest = screen; - g_tilesetmanager->Init(convertPath("gfx/Classic/tilesets").c_str()); + g_tilesetmanager->init(convertPath("gfx/Classic/tilesets").c_str()); //Add all of the maps that are world only so we can edit them maplist->addWorldMaps(); @@ -724,7 +724,7 @@ void gameloop_frame() } WriteAnimatedTileTypeFile(convertPath("gfx/packs/Classic/tilesets/tile_animation_tileset.tls").c_str()); - g_tilesetmanager->SaveTilesets(); + g_tilesetmanager->saveTilesets(); printf("\n---------------- shutdown ----------------\n"); return 0; @@ -739,7 +739,7 @@ TileType CalculateTileType(short x, short y) TileType iTileType = tile_nonsolid; if (tile->iID >= 0) - iTileType = g_tilesetmanager->GetTileset(tile->iID)->tileType(tile->iCol, tile->iRow); + iTileType = g_tilesetmanager->tileset(tile->iID)->tileType(tile->iCol, tile->iRow); else if (tile->iID == TILESETANIMATED) iTileType = animatedtiletypes[tile->iRow + (tile->iCol << 5)]; @@ -1719,9 +1719,9 @@ void drawlayer(int layer, bool fUseCopied, short iBlockSize) iSrcRow = 0; } - SDL_BlitSurface(rm->spr_tileanimation[iTilesetIndex].getSurface(), g_tilesetmanager->GetRect(iTilesetIndex, iSrcCol, iSrcRow), screen, g_tilesetmanager->GetRect(iTilesetIndex, i, j)); + SDL_BlitSurface(rm->spr_tileanimation[iTilesetIndex].getSurface(), g_tilesetmanager->rect(iTilesetIndex, iSrcCol, iSrcRow), screen, g_tilesetmanager->rect(iTilesetIndex, i, j)); } else if (tile->iID == TILESETUNKNOWN) { - SDL_BlitSurface(rm->spr_unknowntile[iTilesetIndex].getSurface(), g_tilesetmanager->GetRect(iTilesetIndex, 0, 0), screen, g_tilesetmanager->GetRect(iTilesetIndex, i, j)); + SDL_BlitSurface(rm->spr_unknowntile[iTilesetIndex].getSurface(), g_tilesetmanager->rect(iTilesetIndex, 0, 0), screen, g_tilesetmanager->rect(iTilesetIndex, i, j)); } } } @@ -1809,7 +1809,7 @@ void drawmap(bool fScreenshot, short iBlockSize, bool fWithPlatforms) rSrc.y = iBlockSize << 1; } - SDL_BlitSurface(rm->spr_blocks[iTilesizeIndex].getSurface(), &rSrc, screen, g_tilesetmanager->GetRect(iTilesizeIndex, i, j)); + SDL_BlitSurface(rm->spr_blocks[iTilesizeIndex].getSurface(), &rSrc, screen, g_tilesetmanager->rect(iTilesizeIndex, i, j)); } } } @@ -2624,7 +2624,7 @@ int editor_platforms() if (ix + i >= 0 && ix + i < MAPWIDTH && iy + j >= 0 && iy + j < MAPHEIGHT) { TilesetTile * tile = &g_Platforms[iEditPlatform].tiles[ix + i][iy + j]; SetTilesetTile(tile, set_tile_tileset, set_tile_start_x + i, set_tile_start_y + j); - g_Platforms[iEditPlatform].types[ix + i][iy + j] = g_tilesetmanager->GetTileset(tile->iID)->tileType(tile->iCol, tile->iRow); + g_Platforms[iEditPlatform].types[ix + i][iy + j] = g_tilesetmanager->tileset(tile->iID)->tileType(tile->iCol, tile->iRow); } } } @@ -2702,7 +2702,7 @@ int editor_platforms() if (PLATFORM_EDIT_STATE_EDIT == iPlatformEditState) { SetTilesetTile(tile, set_tile_tileset, set_tile_start_x + i, set_tile_start_y + j); - g_Platforms[iEditPlatform].types[ix + i][iy + j] = g_tilesetmanager->GetTileset(tile->iID)->tileType(tile->iCol, tile->iRow); + g_Platforms[iEditPlatform].types[ix + i][iy + j] = g_tilesetmanager->tileset(tile->iID)->tileType(tile->iCol, tile->iRow); } else { SetTilesetTile(tile, TILESETANIMATED, set_tile_start_y + j, set_tile_start_x + i); g_Platforms[iEditPlatform].types[ix + i][iy + j] = animatedtiletypes[tile->iRow + (tile->iCol << 5)]; @@ -3030,9 +3030,9 @@ void draw_platform(short iPlatform, bool fDrawTileTypes) iSrcRow = 0; } - SDL_BlitSurface(rm->spr_tileanimation[0].getSurface(), g_tilesetmanager->GetRect(0, iSrcCol, iSrcRow), screen, g_tilesetmanager->GetRect(0, iCol, iRow)); + SDL_BlitSurface(rm->spr_tileanimation[0].getSurface(), g_tilesetmanager->rect(0, iSrcCol, iSrcRow), screen, g_tilesetmanager->rect(0, iCol, iRow)); } else if (tile->iID == TILESETUNKNOWN) { - SDL_BlitSurface(rm->spr_unknowntile[0].getSurface(), g_tilesetmanager->GetRect(0, 0, 0), screen, g_tilesetmanager->GetRect(0, iCol, iRow)); + SDL_BlitSurface(rm->spr_unknowntile[0].getSurface(), g_tilesetmanager->rect(0, 0, 0), screen, g_tilesetmanager->rect(0, iCol, iRow)); } if (fDrawTileTypes) { @@ -3557,7 +3557,7 @@ void init_editor_tiles() set_tile_drag = false; view_tileset_repeat_direction = -1; view_tileset_repeat_timer = 0; - tileset = g_tilesetmanager->GetTileset(set_tile_tileset); + tileset = g_tilesetmanager->tileset(set_tile_tileset); editor_tiles_initialized = true; } @@ -3584,20 +3584,20 @@ int editor_tiles() if (!set_tile_drag) { if (event.key.keysym.sym >= SDLK_1 && event.key.keysym.sym <= SDLK_9 && event.key.keysym.sym < SDLK_1 + g_tilesetmanager->GetCount()) { set_tile_tileset = event.key.keysym.sym - SDLK_1; - tileset = g_tilesetmanager->GetTileset(set_tile_tileset); + tileset = g_tilesetmanager->tileset(set_tile_tileset); view_tileset_x = 0; view_tileset_y = 0; } else if (event.key.keysym.sym == SDLK_PAGEUP) { if (set_tile_tileset > 0) { set_tile_tileset--; - tileset = g_tilesetmanager->GetTileset(set_tile_tileset); + tileset = g_tilesetmanager->tileset(set_tile_tileset); view_tileset_x = 0; view_tileset_y = 0; } } else if (event.key.keysym.sym == SDLK_PAGEDOWN) { if (set_tile_tileset < g_tilesetmanager->GetCount() - 1) { set_tile_tileset++; - tileset = g_tilesetmanager->GetTileset(set_tile_tileset); + tileset = g_tilesetmanager->tileset(set_tile_tileset); view_tileset_x = 0; view_tileset_y = 0; } @@ -3608,7 +3608,7 @@ int editor_tiles() view_tileset_repeat_timer = 30; } } else if (event.key.keysym.sym == SDLK_DOWN) { - if (view_tileset_y < g_tilesetmanager->GetTileset(set_tile_tileset)->height() - 15) { + if (view_tileset_y < g_tilesetmanager->tileset(set_tile_tileset)->height() - 15) { view_tileset_y++; view_tileset_repeat_direction = 1; view_tileset_repeat_timer = 30; @@ -3620,7 +3620,7 @@ int editor_tiles() view_tileset_repeat_timer = 30; } } else if (event.key.keysym.sym == SDLK_RIGHT) { - if (view_tileset_x < g_tilesetmanager->GetTileset(set_tile_tileset)->width() - 20) { + if (view_tileset_x < g_tilesetmanager->tileset(set_tile_tileset)->width() - 20) { view_tileset_x++; view_tileset_repeat_direction = 3; view_tileset_repeat_timer = 30; @@ -3651,7 +3651,7 @@ int editor_tiles() short iRow = event.button.y / TILESIZE + view_tileset_y; if (event.button.button == SDL_BUTTON_LEFT) { - CTileset * tileset = g_tilesetmanager->GetTileset(set_tile_tileset); + CTileset * tileset = g_tilesetmanager->tileset(set_tile_tileset); if (iCol < tileset->width() && iRow < tileset->height()) { set_tile_start_x = iCol; @@ -3729,11 +3729,11 @@ int editor_tiles() if (view_tileset_repeat_direction == 0 && view_tileset_y > 0) { view_tileset_y--; - } else if (view_tileset_repeat_direction == 1 && view_tileset_y < g_tilesetmanager->GetTileset(set_tile_tileset)->height() - 15) { + } else if (view_tileset_repeat_direction == 1 && view_tileset_y < g_tilesetmanager->tileset(set_tile_tileset)->height() - 15) { view_tileset_y++; } else if (view_tileset_repeat_direction == 2 && view_tileset_x > 0) { view_tileset_x--; - } else if (view_tileset_repeat_direction == 3 && view_tileset_x < g_tilesetmanager->GetTileset(set_tile_tileset)->width() - 20) { + } else if (view_tileset_repeat_direction == 3 && view_tileset_x < g_tilesetmanager->tileset(set_tile_tileset)->width() - 20) { view_tileset_x++; } } @@ -3754,8 +3754,8 @@ int editor_tiles() r.y = 0; r.w = 640; r.h = 480; - - SDL_BlitSurface(g_tilesetmanager->GetTileset(set_tile_tileset)->surface(0), &rectSrc, screen, &r); + + SDL_BlitSurface(g_tilesetmanager->tileset(set_tile_tileset)->surface(0), &rectSrc, screen, &r); //rm->menu_font_small.drawRightJustified(640, 0, maplist->currentFilename()); rm->menu_font_small.draw(0, 480 - rm->menu_font_small.getHeight(), tileset->name()); diff --git a/src/smw/objects/blocks/DonutBlock.cpp b/src/smw/objects/blocks/DonutBlock.cpp index 59589143..9e87d8cc 100644 --- a/src/smw/objects/blocks/DonutBlock.cpp +++ b/src/smw/objects/blocks/DonutBlock.cpp @@ -64,7 +64,7 @@ void B_DonutBlock::triggerBehavior(short iPlayerId) TilesetTile ** tiledata = new TilesetTile*[1]; tiledata[0] = new TilesetTile[1]; - tiledata[0][0].iID = g_tilesetmanager->GetClassicTilesetIndex(); + tiledata[0][0].iID = g_tilesetmanager->classicTilesetIndex(); tiledata[0][0].iCol = 29; tiledata[0][0].iRow = 15; diff --git a/src/worldeditor/worldeditor.cpp b/src/worldeditor/worldeditor.cpp index 59f7b397..1ee2a025 100644 --- a/src/worldeditor/worldeditor.cpp +++ b/src/worldeditor/worldeditor.cpp @@ -501,7 +501,7 @@ int main(int argc, char *argv[]) gfx_init(640,480, g_fFullScreen); blitdest = screen; - g_tilesetmanager->Init(convertPath("gfx/Classic/tilesets").c_str()); + g_tilesetmanager->init(convertPath("gfx/Classic/tilesets").c_str()); gfx_settitle(MAPTITLESTRING);