diff --git a/game/main.cpp b/game/main.cpp index b7e765d..0626a58 100644 --- a/game/main.cpp +++ b/game/main.cpp @@ -15,7 +15,7 @@ * along with DoorKeeper. If not, see . */ -#include "doorkeeper/doorkeeper2d.hpp" +#include "doorkeeper/doorkeeper.hpp" #include "doorkeeper/helpers/maploader.hpp" #include "doorkeeper/helpers/asciimapsource.hpp" #include "doorkeeper/helpers/typename_native.hpp" @@ -23,17 +23,18 @@ #include int main() { - using dk::Tyler2d; - using dk::coords2; - using dk::Viewport2d; - using dk::Layer2d; - typedef dkh::MapLoaderPool2d> IntPoolType; + using PixelConvType = dk::PixelConvSquare<2>; + using Tyler2d = dk::Tyler; + using coords2 = Tyler2d::coords; + //using Viewport2d = dk::Viewport; + //using Layer2d = dk::Layer; + typedef dkh::MapLoaderPool*(const std::string&)>> IntPoolType; std::cout << "Welcome to " GAME_NAME " v" << GAME_VER_MAJOR << '.' << GAME_VER_MINOR << '.' << GAME_VER_PATCH << '\n'; IntPoolType pool; pool.opener = [](const std::string& parName) { std::cout << "Opening " << parName << std::endl; return new dkh::AsciiMapSource(parName, coords2(10, 8), dk::MapType_IsometricStaggered, coords2(64, 64)); }; - dkh::PushLayerMapType<2> pushers; + dkh::PushLayerMapType pushers; pushers.insert(std::make_pair(dk::type_name_hash(), &Tyler2d::push_layer_void)); Tyler2d tiler(dkh::call_map_load(pool, std::string("test_level.dk"), pushers)); diff --git a/include/doorkeeper/components/layer.hpp b/include/doorkeeper/components/layer.hpp index c271ac6..2f44669 100644 --- a/include/doorkeeper/components/layer.hpp +++ b/include/doorkeeper/components/layer.hpp @@ -31,7 +31,7 @@ #endif namespace dk { - template + template class Viewport; template @@ -58,18 +58,22 @@ namespace dk { coords m_haveTo; }; - template - class Layer : public LayerBase { - friend class Viewport; + template + class Layer : public LayerBase { + friend class Viewport; public: - typedef typename LayerBase::coords coords; - typedef TileIterator iterator; - typedef TileIterator const_iterator; + enum { + dimensions = PixConv::dimensions + }; + + typedef typename LayerBase::coords coords; + typedef TileIterator iterator; + typedef TileIterator const_iterator; Layer ( const Layer& ) = delete; Layer ( Layer&& ) = default; - Layer ( const coords& parTileSize, const coords& parMasterTileSize, BaseMapSource* parTilemap ); + Layer ( const coords& parTileSize, const coords& parMasterTileSize, BaseMapSource* parTilemap ); virtual ~Layer ( void ) noexcept = default; Layer& operator= ( const Layer& ) = delete; @@ -81,7 +85,7 @@ namespace dk { virtual void onPreload ( const coords& parFrom, const coords& parTo ); std::vector m_tiles; - BaseMapSource* m_tilemap; + BaseMapSource* m_tilemap; }; } //namespace dk diff --git a/include/doorkeeper/components/pixelconv.hpp b/include/doorkeeper/components/pixelconv.hpp index 53d3811..917293e 100644 --- a/include/doorkeeper/components/pixelconv.hpp +++ b/include/doorkeeper/components/pixelconv.hpp @@ -27,6 +27,10 @@ namespace dk { template class PixelConv { public: + enum { + dimensions = D + }; + typedef Vector coords; PixelConv ( MapTypes parType, const coords& parTileSize ); @@ -55,20 +59,19 @@ namespace dk { virtual coords pick_tile ( const coords& parPixelPoint ) const; }; + template class PixelConvDiamond : public PixelConv<2> { public: using base_class = PixelConv<2>; using base_class::coords; PixelConvDiamond ( const coords& parTileSize, bool parStaggered, bool parFirstReentrant ); - PixelConvDiamond ( const coords& parTileSize, bool parStaggered, bool parFirstReentrant, const coords& parRatio ); virtual ~PixelConvDiamond ( void ) noexcept = default; virtual coords to_pixel ( const coords& parFrom ) const; virtual coords pick_tile ( const coords& parPixelPoint ) const; protected: - const coords m_ratio; const CoordinateScalarType m_first_reentr; const bool m_staggered; }; diff --git a/include/doorkeeper/components/tyler.hpp b/include/doorkeeper/components/tyler.hpp index 23b4fa1..a6070f4 100644 --- a/include/doorkeeper/components/tyler.hpp +++ b/include/doorkeeper/components/tyler.hpp @@ -29,12 +29,16 @@ namespace dk { template class BaseMapSource; - template + template class Tyler { - typedef std::unique_ptr> LayerPtr; + typedef std::unique_ptr> LayerPtr; typedef std::vector LayerList; public: - typedef typename LayerBase::coords coords; + enum { + dimensions = PixConv::dimensions + }; + + typedef typename LayerBase::coords coords; Tyler ( void ) = delete; Tyler ( Tyler&& ) = default; @@ -45,11 +49,11 @@ namespace dk { const coords& map_size ( void ) const { return m_size; } template - Layer& push_layer ( BaseMapSource* parTilemap, int parIndex ); + Layer& push_layer ( BaseMapSource* parTilemap, int parIndex ); template - Layer& push_layer ( BaseMapSource* parTilemap, const coords& parSubdiv, int parIndex ); + Layer& push_layer ( BaseMapSource* parTilemap, const coords& parSubdiv, int parIndex ); template - void push_layer_void ( BaseMapSource* parTilemap, int parIndex ); + void push_layer_void ( BaseMapSource* parTilemap, int parIndex ); void preload ( const coords& parFrom, const coords& parTo ); diff --git a/include/doorkeeper/components/viewport.hpp b/include/doorkeeper/components/viewport.hpp index 70e3760..702077a 100644 --- a/include/doorkeeper/components/viewport.hpp +++ b/include/doorkeeper/components/viewport.hpp @@ -24,20 +24,24 @@ #include namespace dk { - template + template class Tyler; - template + template class Layer; - template + template class Viewport { public: - typedef Vector coords; + enum { + dimensions = PixConv::dimensions + }; + + typedef Vector coords; Viewport ( const Viewport& parOther ) = default; - explicit Viewport ( Tyler& parTyler ); - Viewport ( Tyler& parTyler, const coords& parSize, const coords& parPos ); + explicit Viewport ( Tyler& parTyler ); + Viewport ( Tyler& parTyler, const coords& parSize, const coords& parPos ); ~Viewport ( void ) noexcept = default; Viewport& operator= ( const Viewport& ) = default; @@ -48,22 +52,22 @@ namespace dk { const coords& count ( void ) const { return m_size; } template - typename Layer::iterator begin ( Layer& parLayer ) const; + typename Layer::iterator begin ( Layer& parLayer ) const; template - typename Layer::iterator end ( Layer& parLayer ) const; + typename Layer::iterator end ( Layer& parLayer ) const; template inline - typename Layer::const_iterator begin ( const Layer& parLayer ) const a_always_inline; + typename Layer::const_iterator begin ( const Layer& parLayer ) const a_always_inline; template inline - typename Layer::const_iterator end ( const Layer& parLayer ) const a_always_inline; + typename Layer::const_iterator end ( const Layer& parLayer ) const a_always_inline; template - typename Layer::const_iterator cbegin ( const Layer& parLayer ) const; + typename Layer::const_iterator cbegin ( const Layer& parLayer ) const; template - typename Layer::const_iterator cend ( const Layer& parLayer ) const; + typename Layer::const_iterator cend ( const Layer& parLayer ) const; private: coords m_size; coords m_position; - Tyler& m_tyler; + Tyler& m_tyler; }; } //namespace dk diff --git a/include/doorkeeper/doorkeeper.hpp b/include/doorkeeper/doorkeeper.hpp index 057e8fb..2b9e737 100644 --- a/include/doorkeeper/doorkeeper.hpp +++ b/include/doorkeeper/doorkeeper.hpp @@ -22,5 +22,6 @@ #include "components/tyler.hpp" #include "components/viewport.hpp" #include "components/layer.hpp" +#include "components/pixelconv.hpp" #endif diff --git a/include/doorkeeper/doorkeeper2d.hpp b/include/doorkeeper/doorkeeper2d.hpp deleted file mode 100644 index 5b61a24..0000000 --- a/include/doorkeeper/doorkeeper2d.hpp +++ /dev/null @@ -1,40 +0,0 @@ -/* Copyright 2015, Michele Santullo - * This file is part of DoorKeeper. - * - * DoorKeeper is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * DoorKeeper is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with DoorKeeper. If not, see . - */ - -#ifndef id6327FA76CFB44F65A459C69096EC65D5 -#define id6327FA76CFB44F65A459C69096EC65D5 - -#include "doorkeeper.hpp" -#include - -namespace dk { - typedef Tyler<2>::coords coords2; - typedef Tyler<2> Tyler2d; - template using Layer2d = Layer; - typedef Viewport<2> Viewport2d; - typedef BaseMapSource<2> BaseMapSource2d; -} //namespace dk - -namespace dkh { - template - struct MapLoaderPool; - - template - using MapLoaderPool2d = MapLoaderPool<2, C>; -} //namespace dkh - -#endif diff --git a/include/doorkeeper/helpers/maploader.hpp b/include/doorkeeper/helpers/maploader.hpp index f1c5b67..7c029f3 100644 --- a/include/doorkeeper/helpers/maploader.hpp +++ b/include/doorkeeper/helpers/maploader.hpp @@ -22,7 +22,6 @@ #include "doorkeeper/components/basemapsource.hpp" #include "doorkeeper/helpers/typename.hpp" #include "doorkeeper/components/exception.hpp" -#include #include #include #include @@ -31,41 +30,42 @@ #include namespace dkh { - template - using PushLayerMapType = std::map::*)(dk::BaseMapSource*,int)>; + template + using PushLayerMapType = std::map::*)(dk::BaseMapSource*,int)>; - template + template struct MapLoaderPool { - typedef std::unique_ptr> BaseMapSourceUPtr; + enum { dimensions = PixConv::dimensions }; + typedef std::unique_ptr> BaseMapSourceUPtr; typedef std::map PoolMapType; + typedef PixConv PixelConvType; - enum { dimensions = D }; typedef C opener_type; PoolMapType pool; C opener; - dk::BaseMapSource* operator() ( const std::string& parName ); + dk::BaseMapSource* operator() ( const std::string& parName ); }; class UnknownLayerTemplateException : public dk::DoorKeeperException { }; template - dk::Tyler call_map_load ( M& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher ); + dk::Tyler call_map_load ( M& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher ); template - dk::Tyler call_map_load ( dk::Tyler& parTyler, M& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher ); + dk::Tyler call_map_load ( dk::Tyler& parTyler, M& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher ); - template - dk::Tyler map_load ( C& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher ); + template + dk::Tyler map_load ( C& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher ); - template - dk::Tyler& map_load ( dk::Tyler& parTyler, C& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher ); + template + dk::Tyler& map_load ( dk::Tyler& parTyler, C& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher ); namespace implem { - template - void call_push_layer ( dk::Tyler& parTyler, const PushLayerMapType& parPusher, dk::BaseMapSource* parReader, int parIndex ); + template + void call_push_layer ( dk::Tyler& parTyler, const PushLayerMapType& parPusher, dk::BaseMapSource* parReader, int parIndex ); } //namespace implem } //namespace dkh diff --git a/include/doorkeeper/implem/layer.inl b/include/doorkeeper/implem/layer.inl index a590382..98093f2 100644 --- a/include/doorkeeper/implem/layer.inl +++ b/include/doorkeeper/implem/layer.inl @@ -42,9 +42,9 @@ namespace dk { ///-------------------------------------------------------------------------- ///-------------------------------------------------------------------------- - template - Layer::Layer (const coords& parTileSize, const coords& parMasterTileSize, BaseMapSource* parTilemap) : - LayerBase(parTilemap->mapSize(), parTileSize, parMasterTileSize), + template + Layer::Layer (const coords& parTileSize, const coords& parMasterTileSize, BaseMapSource* parTilemap) : + LayerBase(parTilemap->mapSize(), parTileSize, parMasterTileSize), m_tilemap(parTilemap) { DK_ASSERT(m_tilemap); @@ -52,22 +52,22 @@ namespace dk { ///-------------------------------------------------------------------------- ///-------------------------------------------------------------------------- - template - typename Layer::iterator Layer::begin() { + template + typename Layer::iterator Layer::begin() { return iterator(&m_tiles, m_tilemap->pixel_conv(), coords(0), this->m_count); } ///-------------------------------------------------------------------------- ///-------------------------------------------------------------------------- - template - typename Layer::iterator Layer::end() { - return iterator(&m_tiles, m_tilemap->pixel_conv(), make_past_end_coords(this->m_count - 1), make_past_end_coords(this->m_count - 1)); + template + typename Layer::iterator Layer::end() { + return iterator(&m_tiles, m_tilemap->pixel_conv(), make_past_end_coords(this->m_count - 1), make_past_end_coords(this->m_count - 1)); } ///-------------------------------------------------------------------------- ///-------------------------------------------------------------------------- - template - void Layer::onPreload (const coords& parFrom, const coords& parTo) { + template + void Layer::onPreload (const coords& parFrom, const coords& parTo) { m_tiles.clear(); m_tilemap->fetch(m_tiles, parFrom, parTo); #if !defined(NDEBUG) diff --git a/include/doorkeeper/implem/maploader.inl b/include/doorkeeper/implem/maploader.inl index c17979c..15635c6 100644 --- a/include/doorkeeper/implem/maploader.inl +++ b/include/doorkeeper/implem/maploader.inl @@ -16,29 +16,31 @@ */ namespace dkh { - template - dk::Tyler map_load (C& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher) { - dk::BaseMapSource* reader = parFileOpener(parOpen); - dk::Tyler tyler(reader->tileSize()); + template + dk::Tyler map_load (C& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher) { + constexpr uint32_t dimensions = PixConv::dimensions; + dk::BaseMapSource* reader = parFileOpener(parOpen); + dk::Tyler tyler(reader->tileSize()); for (int z = 0; z < reader->layersCount(); ++z) { - implem::call_push_layer(tyler, parPusher, reader, z); + implem::call_push_layer(tyler, parPusher, reader, z); } std::vector submaps; reader->chainedMaps(submaps); for (const auto& name : submaps) { - map_load(tyler, parFileOpener, name, parPusher); + map_load(tyler, parFileOpener, name, parPusher); } return std::move(tyler); } - template - dk::Tyler& map_load (dk::Tyler& parTyler, C& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher) { + template + dk::Tyler& map_load (dk::Tyler& parTyler, C& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher) { + constexpr uint32_t dimensions = PixConv::dimensions; std::stack> name_stack; std::vector submaps; name_stack.push(parOpen); do { - dk::BaseMapSource* reader = parFileOpener(name_stack.top()); + dk::BaseMapSource* reader = parFileOpener(name_stack.top()); name_stack.pop(); submaps.clear(); @@ -48,14 +50,14 @@ namespace dkh { } for (int z = 0; z < reader->layersCount(); ++z) { - implem::call_push_layer(parTyler, parPusher, reader, z); + implem::call_push_layer(parTyler, parPusher, reader, z); } } while (not name_stack.empty()); return parTyler; } - template - dk::BaseMapSource* MapLoaderPool::operator() (const std::string& parName) { + template + auto MapLoaderPool::operator() (const std::string& parName) -> dk::BaseMapSource* { auto it_found = pool.find(parName); if (pool.end() != it_found) { return it_found->second.get(); @@ -69,18 +71,18 @@ namespace dkh { } template - dk::Tyler call_map_load (M& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher) { - return map_load(parFileOpener, parOpen, parPusher); + dk::Tyler call_map_load (M& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher) { + return map_load(parFileOpener, parOpen, parPusher); } template - dk::Tyler call_map_load (dk::Tyler& parTyler, M& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher) { - return map_load(parTyler, parFileOpener, parOpen, parPusher); + dk::Tyler call_map_load (dk::Tyler& parTyler, M& parFileOpener, const std::string& parOpen, const PushLayerMapType& parPusher) { + return map_load(parTyler, parFileOpener, parOpen, parPusher); } namespace implem { - template - void call_push_layer (dk::Tyler& parTyler, const PushLayerMapType& parPusher, dk::BaseMapSource* parReader, int parLayerIndex) { + template + void call_push_layer (dk::Tyler& parTyler, const PushLayerMapType& parPusher, dk::BaseMapSource* parReader, int parLayerIndex) { auto it_found = parPusher.find(parReader->layerTypeHash(parLayerIndex)); if (parPusher.end() == it_found) throw UnknownLayerTemplateException(); diff --git a/include/doorkeeper/implem/pixelconv.inl b/include/doorkeeper/implem/pixelconv.inl index 1fa06ea..98678aa 100644 --- a/include/doorkeeper/implem/pixelconv.inl +++ b/include/doorkeeper/implem/pixelconv.inl @@ -16,6 +16,36 @@ */ namespace dk { + template + PixelConvDiamond::PixelConvDiamond (const coords& parTileSize, bool parStaggered, bool parFirstReentrant) : + base_class(parStaggered ? MapType_IsometricStaggered : MapType_Isometric, parTileSize), + m_first_reentr(parFirstReentrant ? 1 : 0), + m_staggered(parStaggered) + { + } + + template + auto PixelConvDiamond::to_pixel (const coords& parFrom) const -> coords { + if (m_staggered) { + const auto from(parFrom); + const CoordinateScalarType xoffs = m_first_reentr xor (from.y() bitand 1); + const auto& tile_size = this->tile_size(); + + const auto retval(from * tile_size + coords(xoffs * tile_size.x() / 2, 0)); + return coords(retval.x() / DivX, retval.y() / DivY); + } + else { + DK_ASSERT(false); //not implemented + return coords(0); + } + } + + template + auto PixelConvDiamond::pick_tile (const coords& parPixelPoint) const -> coords { + DK_ASSERT(false); //not implemented + return coords(0); + } + template PixelConv::PixelConv (MapTypes parType, const coords& parTileSize) : m_tile_size(parTileSize), diff --git a/include/doorkeeper/implem/tyler.inl b/include/doorkeeper/implem/tyler.inl index 7d7ff84..73031ce 100644 --- a/include/doorkeeper/implem/tyler.inl +++ b/include/doorkeeper/implem/tyler.inl @@ -18,8 +18,8 @@ namespace dk { ///-------------------------------------------------------------------------- ///-------------------------------------------------------------------------- - template - Tyler::Tyler (const coords& parTileSize) : + template + Tyler::Tyler (const coords& parTileSize) : m_size(0), m_tilesize(parTileSize) { @@ -27,10 +27,10 @@ namespace dk { ///-------------------------------------------------------------------------- ///-------------------------------------------------------------------------- - template - typename Tyler::coords::scalar_type Tyler::tiles_count() const { + template + typename Tyler::coords::scalar_type Tyler::tiles_count() const { typename coords::scalar_type retval = 1; - for (uint32_t d = 0; d < D; ++d) { + for (uint32_t d = 0; d < dimensions; ++d) { retval *= m_size[d]; } return retval; @@ -38,21 +38,21 @@ namespace dk { ///-------------------------------------------------------------------------- ///-------------------------------------------------------------------------- - template + template template - Layer& Tyler::push_layer (BaseMapSource* parTilemap, int parIndex) { + Layer& Tyler::push_layer (BaseMapSource* parTilemap, int parIndex) { return push_layer(parTilemap, coords(static_cast(1)), parIndex); } ///-------------------------------------------------------------------------- ///-------------------------------------------------------------------------- - template + template template - Layer& Tyler::push_layer (BaseMapSource* parTilemap, const coords& parSubdiv, int parIndex) { + Layer& Tyler::push_layer (BaseMapSource* parTilemap, const coords& parSubdiv, int parIndex) { //TODO: store the index (void)parIndex; - auto newLayer = new Layer(m_tilesize / parSubdiv, m_tilesize, parTilemap); + auto newLayer = new Layer(m_tilesize / parSubdiv, m_tilesize, parTilemap); if (m_size == coords(0)) { m_size = newLayer->mapSize(); } @@ -69,16 +69,16 @@ namespace dk { ///-------------------------------------------------------------------------- ///-------------------------------------------------------------------------- - template + template template - void Tyler::push_layer_void (BaseMapSource* parTilemap, int parIndex) { + void Tyler::push_layer_void (BaseMapSource* parTilemap, int parIndex) { push_layer(parTilemap, parIndex); } ///-------------------------------------------------------------------------- ///-------------------------------------------------------------------------- - template - void Tyler::preload (const coords& parFrom, const coords& parTo) { + template + void Tyler::preload (const coords& parFrom, const coords& parTo) { for (auto& layer : m_layers) { layer->preload(parFrom, parTo); } diff --git a/include/doorkeeper/implem/viewport.inl b/include/doorkeeper/implem/viewport.inl index 9b21dbd..46cc0b5 100644 --- a/include/doorkeeper/implem/viewport.inl +++ b/include/doorkeeper/implem/viewport.inl @@ -16,14 +16,14 @@ */ namespace dk { - template - Viewport::Viewport (Tyler& parTyler) : + template + Viewport::Viewport (Tyler& parTyler) : m_tyler(parTyler) { } - template - Viewport::Viewport (Tyler& parTyler, const coords& parSize, const coords& parPos) : + template + Viewport::Viewport (Tyler& parTyler, const coords& parSize, const coords& parPos) : m_size(parSize), m_position(parPos), m_tyler(parTyler) @@ -33,64 +33,64 @@ namespace dk { m_tyler.preload(m_position, m_position + m_size); } - template + template template - typename Layer::iterator Viewport::begin (Layer& parLayer) const { - typedef typename Layer::iterator IterType; + typename Layer::iterator Viewport::begin (Layer& parLayer) const { + typedef typename Layer::iterator IterType; return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), m_position, m_tyler.map_size() - 1); } - template + template template - typename Layer::iterator Viewport::end (Layer& parLayer) const { - typedef typename Layer::iterator IterType; - return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), make_past_end_coords(m_tyler.map_size() - 1), make_past_end_coords(m_tyler.map_size() - 1)); + typename Layer::iterator Viewport::end (Layer& parLayer) const { + typedef typename Layer::iterator IterType; + return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), make_past_end_coords(m_tyler.map_size() - 1), make_past_end_coords(m_tyler.map_size() - 1)); } - template + template template - typename Layer::const_iterator Viewport::begin (const Layer& parLayer) const { + typename Layer::const_iterator Viewport::begin (const Layer& parLayer) const { return this->cbegin(parLayer); } - template + template template - typename Layer::const_iterator Viewport::end (const Layer& parLayer) const { + typename Layer::const_iterator Viewport::end (const Layer& parLayer) const { return this->cend(parLayer); } - template + template template - typename Layer::const_iterator Viewport::cbegin (const Layer& parLayer) const { - typedef typename Layer::const_iterator IterType; + typename Layer::const_iterator Viewport::cbegin (const Layer& parLayer) const { + typedef typename Layer::const_iterator IterType; return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), m_position, m_tyler.map_size() - 1); } - template + template template - typename Layer::const_iterator Viewport::cend (const Layer& parLayer) const { - typedef typename Layer::const_iterator IterType; - return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), make_past_end_coords(m_tyler.map_size() - 1), make_past_end_coords(m_tyler.map_size() - 1)); + typename Layer::const_iterator Viewport::cend (const Layer& parLayer) const { + typedef typename Layer::const_iterator IterType; + return IterType(&parLayer.m_tiles, parLayer.m_tilemap->pixel_conv(), make_past_end_coords(m_tyler.map_size() - 1), make_past_end_coords(m_tyler.map_size() - 1)); } - template - void Viewport::setSize (const coords& parSize) { + template + void Viewport::setSize (const coords& parSize) { DK_ASSERT(m_position <= m_position + parSize); DK_ASSERT(parSize + m_position <= m_tyler.map_size()); m_size = parSize; m_tyler.preload(m_position, m_position + m_size); } - template - void Viewport::setFrom (const coords& parFrom) { + template + void Viewport::setFrom (const coords& parFrom) { DK_ASSERT(parFrom <= parFrom + m_size); DK_ASSERT(m_size + parFrom <= m_tyler.map_size()); m_position = parFrom; m_tyler.preload(m_position, m_position + m_size); } - template - void Viewport::setFromSize (const coords& parFrom, const coords& parSize) { + template + void Viewport::setFromSize (const coords& parFrom, const coords& parSize) { DK_ASSERT(parFrom <= parFrom + parSize); DK_ASSERT(parSize + parFrom <= m_tyler.map_size()); m_position = parFrom; diff --git a/src/pixelconv.cpp b/src/pixelconv.cpp index 80fbe5d..ff5ce47 100644 --- a/src/pixelconv.cpp +++ b/src/pixelconv.cpp @@ -18,42 +18,6 @@ #include "doorkeeper/components/pixelconv.hpp" namespace dk { - PixelConvDiamond::PixelConvDiamond (const coords& parTileSize, bool parStaggered, bool parFirstReentrant) : - base_class(parStaggered ? MapType_IsometricStaggered : MapType_Isometric, parTileSize), - m_ratio(1), - m_first_reentr(parFirstReentrant ? 1 : 0), - m_staggered(parStaggered) - { - } - - PixelConvDiamond::PixelConvDiamond (const coords& parTileSize, bool parStaggered, bool parFirstReentrant, const coords& parRatio) : - base_class(MapType_IsometricStaggered, parTileSize), - m_ratio(parRatio), - m_first_reentr(parFirstReentrant ? 1 : 0), - m_staggered(parStaggered) - { - DK_ASSERT(parRatio > 0); - } - - auto PixelConvDiamond::to_pixel (const coords& parFrom) const -> coords { - if (m_staggered) { - const auto from(parFrom); - const CoordinateScalarType xoffs = m_first_reentr xor (from.y() bitand 1); - const auto& tile_size = this->tile_size(); - - return (from * tile_size + coords(xoffs * tile_size.x() / 2, 0)) / m_ratio; - } - else { - DK_ASSERT(false); //not implemented - return coords(0); - } - } - - auto PixelConvDiamond::pick_tile (const coords& parPixelPoint) const -> coords { - DK_ASSERT(false); //not implemented - return coords(0); - } - PixelConvHex::PixelConvHex (const coords& parTileSize, bool parFirstReentrant) : base_class(MapType_Hex, parTileSize), m_first_reentr(parFirstReentrant ? 1 : 0) diff --git a/test/main.cpp b/test/main.cpp index 436a531..81e2b0e 100644 --- a/test/main.cpp +++ b/test/main.cpp @@ -34,10 +34,11 @@ #include namespace { + typedef dk::Tyler> TylerSquare2; template inline dk::Vector<2> get_diamond_coordinates (const dk::TileIterator& parIterator, const dk::Vector<2>& parSize) { - dk::PixelConvDiamond pconv(parSize, true, false); + dk::PixelConvDiamond<1, 1> pconv(parSize, true, false); return pconv.to_pixel(parIterator->block_position()); } } //unnamed namespace @@ -45,7 +46,7 @@ namespace { template struct LayerWithData { std::unique_ptr device; - dk::Layer* layer; + dk::Layer>* layer; std::string path; }; @@ -54,6 +55,10 @@ namespace { typedef std::unique_ptr SDLWindowUPtr; typedef std::unique_ptr SDLTextureUPtr; + typedef dk::Tyler> TylerDiamond2; + typedef dk::Viewport> ViewportDiamond2; + typedef dk::Layer> LayerDiamond2; + struct SDLSimple { SDLSimple ( void ); ~SDLSimple ( void ) noexcept; @@ -61,14 +66,14 @@ namespace { }; void printWelcome ( void ); - void addLayer ( dk::Tyler<2>& parTiler, LayerWithData& parLayerInfo, const char* parPath ); - void printViewport ( const dk::Viewport<2>& parView, const dk::Layer& parLayer ); + void addLayer ( TylerSquare2& parTiler, LayerWithData& parLayerInfo, const char* parPath ); + void printViewport ( const ViewportDiamond2& parView, const LayerDiamond2& parLayer ); std::pair GetRenderingDriver ( void ); - void draw_tiles ( SDL_Renderer* parRenderer, SDL_Texture* parTile0, SDL_Texture* parTile1, const dk::Viewport<2>& parView, const dk::Layer& parLayer, int parYOffs ); + void draw_tiles ( SDL_Renderer* parRenderer, SDL_Texture* parTile0, SDL_Texture* parTile1, const ViewportDiamond2& parView, const LayerDiamond2& parLayer, int parYOffs ); } //unnamed namespace int main() { - typedef dk::Tyler<2>::coords coords2; + typedef TylerSquare2::coords coords2; using dkh::AsciiMapSource; SDLSimple sdl_init; @@ -87,7 +92,7 @@ int main() { &SDL_DestroyRenderer ); - dk::Tyler<2> tiler(coords2(64)); + TylerSquare2 tiler(coords2(64)); LayerWithData bottomLayer; addLayer(tiler, bottomLayer, DATA_PATH"/test.map"); @@ -95,8 +100,8 @@ int main() { LayerWithData topLayer; addLayer(tiler, topLayer, DATA_PATH"/test_2.map"); - printViewport(dk::Viewport<2>(tiler, coords2(10, 6), coords2(0)), *bottomLayer.layer); - printViewport(dk::Viewport<2>(tiler, coords2(4, 4), coords2(0)), *bottomLayer.layer); + printViewport(ViewportDiamond2(tiler, coords2(10, 6), coords2(0)), *bottomLayer.layer); + printViewport(ViewportDiamond2(tiler, coords2(4, 4), coords2(0)), *bottomLayer.layer); #if !defined(NDEBUG) std::cout << "Map size: " << tiler.map_size() << '\n'; @@ -113,7 +118,7 @@ int main() { //Main loop bool running = true; int y = 0; - dk::Viewport<2> viewport(tiler, coords2(10, 8), coords2(0)); + ViewportDiamond2 viewport(tiler, coords2(10, 8), coords2(0)); coords2 tile_size; SDL_QueryTexture(tile_0.get(), nullptr, nullptr, &tile_size.x(), &tile_size.y()); do { @@ -164,7 +169,7 @@ namespace { std::cout << '\n'; } - void addLayer (dk::Tyler<2>& parTiler, LayerWithData& parLayerInfo, const char* parPath) { + void addLayer (TylerSquare2& parTiler, LayerWithData& parLayerInfo, const char* parPath) { typedef dkh::AsciiMapSource::coords coords; parLayerInfo.path = parPath; @@ -172,7 +177,7 @@ namespace { parLayerInfo.layer = &parTiler.push_layer(parLayerInfo.device.get(), 0); } - void printViewport (const dk::Viewport<2>& parView, const dk::Layer& parLayer) { + void printViewport (const ViewportDiamond2& parView, const LayerDiamond2& parLayer) { int col = 0; const auto tilecount = parView.count(); for (auto itTile = parView.begin(parLayer), itTileEND = parView.end(parLayer); itTile != itTileEND; ++itTile) { @@ -231,8 +236,8 @@ namespace { return RetPairType(-1, "default"); } - void draw_tiles (SDL_Renderer* parRenderer, SDL_Texture* parTile0, SDL_Texture* parTile1, const dk::Viewport<2>& parView, const dk::Layer& parLayer, int parYOffs) { - typedef dk::Tyler<2>::coords coords2; + void draw_tiles (SDL_Renderer* parRenderer, SDL_Texture* parTile0, SDL_Texture* parTile1, const ViewportDiamond2& parView, const LayerDiamond2& parLayer, int parYOffs) { + typedef TylerSquare2::coords coords2; SDL_Rect rect_src; rect_src.x = rect_src.y = 0; coords2 original_size; diff --git a/test/unit/asciimapsource.cpp b/test/unit/asciimapsource.cpp index 4ce533a..b5caac6 100644 --- a/test/unit/asciimapsource.cpp +++ b/test/unit/asciimapsource.cpp @@ -44,7 +44,7 @@ void asciimapsource::SetUp() { } TEST_F(asciimapsource, load) { - dk::Viewport<2> full_view(tiler, coords2(map_width, map_height), coords2(0)); + dk::Viewport full_view(tiler, coords2(map_width, map_height), coords2(0)); EXPECT_EQ(coords2(map_width, map_height), tiler.map_size()); @@ -68,10 +68,10 @@ TEST_F(asciimapsource, load) { TEST_F(asciimapsource, coordinates) { const coords2 tsize(tile_size); - dk::Viewport<2> full_view(tiler, coords2(map_width, map_height), coords2(0)); - dk::PixelConvSquare<2> iso_conv((tsize)); - dk::PixelConvDiamond diamond_conv(tsize, true, false); - dk::PixelConvDiamond diamond_conv2(tsize, true, true); + dk::Viewport full_view(tiler, coords2(map_width, map_height), coords2(0)); + PixelConvType iso_conv((tsize)); + dk::PixelConvDiamond<1, 1> diamond_conv(tsize, true, false); + dk::PixelConvDiamond<1, 1> diamond_conv2(tsize, true, true); full_view.setFrom(coords2(0)); for (auto itTile = full_view.begin(*layer), itTileEND = full_view.end(*layer); itTile != itTileEND; ++itTile) { diff --git a/test/unit/asciimapsource.hpp b/test/unit/asciimapsource.hpp index d90bebb..5d14874 100644 --- a/test/unit/asciimapsource.hpp +++ b/test/unit/asciimapsource.hpp @@ -23,8 +23,9 @@ class asciimapsource : public ::testing::Test { protected: - typedef dk::Tyler<2>::coords coords2; + typedef dk::Tyler>::coords coords2; typedef std::unique_ptr AsciiMapSourceUPtr; + typedef dk::PixelConvSquare<2> PixelConvType; asciimapsource ( void ); virtual ~asciimapsource ( void ) noexcept = default; @@ -35,8 +36,8 @@ protected: static const dk::CoordinateScalarType map_width; static const dk::CoordinateScalarType map_height; - dk::Tyler<2> tiler; - dk::Layer* layer; + dk::Tyler> tiler; + dk::Layer* layer; AsciiMapSourceUPtr loader; }; diff --git a/tools/mapconv/main.cpp b/tools/mapconv/main.cpp index ca60786..933347c 100644 --- a/tools/mapconv/main.cpp +++ b/tools/mapconv/main.cpp @@ -16,6 +16,7 @@ */ #include "doorkeeper/doorkeeper.hpp" +#include "doorkeeper/helpers/maploader.hpp" #include "doorkeeper/helpers/tylermapsource.hpp" #include #include