From d19a44bcb53cebbee0ae51981f66b93b31cb9dcb Mon Sep 17 00:00:00 2001
From: Stanislaw Halik <sthalik@misaki.pl>
Date: Fri, 7 Oct 2022 21:38:42 +0200
Subject: a

---
 compat/assert.hpp     |  5 ++++-
 compat/defs.hpp       |  4 ++--
 src/chunk.hpp         | 22 ++++------------------
 src/tile-iterator.cpp | 31 +++++++++++++++++++++++++++++++
 src/tile-iterator.hpp | 28 +++++++++++-----------------
 src/tile.hpp          |  4 +++-
 6 files changed, 55 insertions(+), 39 deletions(-)

diff --git a/compat/assert.hpp b/compat/assert.hpp
index 6eba9e41..65d7a7fd 100644
--- a/compat/assert.hpp
+++ b/compat/assert.hpp
@@ -24,9 +24,12 @@ template<std::size_t N, typename...Xs>
 [[noreturn]]
 constexpr inline void abort(const char (&fmt)[N], Xs... xs) noexcept
 {
+#if 0
     if (std::is_constant_evaluated())
         throw "aborting";
-    else {
+    else
+#endif
+    {
         emit_debug("fatal: ", fmt, xs...);
         std::abort();
     }
diff --git a/compat/defs.hpp b/compat/defs.hpp
index f4590ca3..36c6a034 100644
--- a/compat/defs.hpp
+++ b/compat/defs.hpp
@@ -8,10 +8,10 @@
 
 #define progn(...) [&]{__VA_ARGS__;}()
 
-#define DECLARE_DEPRECATED_COPY_OPERATOR(type)              \
+#define DECLARE_DEPRECATED_COPY_ASSIGNMENT(type)            \
     [[deprecated]] type(const type&) = default;             \
     [[deprecated]] type& operator=(const type&) = default
 
-#define DECLARE_DELETED_COPY_OPERATOR(type)                 \
+#define DECLARE_DELETED_COPY_ASSIGNMENT(type)               \
     type(const type&) = delete;                             \
     type& operator=(const type&) = delete
diff --git a/src/chunk.hpp b/src/chunk.hpp
index 9d2777e5..8c8059be 100644
--- a/src/chunk.hpp
+++ b/src/chunk.hpp
@@ -15,10 +15,10 @@ template<typename T> class basic_tile_iterator;
 
 struct chunk final
 {
-    constexpr tile& operator[](local_coords xy) { return _tiles[xy.to_index()]; }
-    constexpr const tile& operator[](local_coords xy) const { return _tiles[xy.to_index()]; }
-    constexpr tile& operator[](std::size_t i) { return _tiles[i]; }
-    constexpr const tile& operator[](std::size_t i) const { return _tiles[i]; }
+    tile& operator[](local_coords xy) { return _tiles[xy.to_index()]; }
+    const tile& operator[](local_coords xy) const { return _tiles[xy.to_index()]; }
+    tile& operator[](std::size_t i) { return _tiles[i]; }
+    const tile& operator[](std::size_t i) const { return _tiles[i]; }
     const auto& tiles() const { return _tiles; }
     auto& tiles() { return _tiles; }
 
@@ -33,21 +33,7 @@ struct chunk final
     const_iterator cend() { return const_iterator{_tiles.data(), _tiles.size()}; }
 
 private:
-    template<typename F, typename Self>
-    constexpr void foreach_tile_(F&& fun);
-
     std::array<tile, TILE_COUNT> _tiles = {};
 };
 
-template<typename F, typename Self>
-constexpr void chunk::foreach_tile_(F&& fun)
-{
-    constexpr auto N = TILE_MAX_DIM;
-    std::size_t k = 0;
-    for (std::size_t j = 0; j < N; j++)
-        for (std::size_t i = 0; i < N; i++, k++)
-            fun(const_cast<Self>(*this)._tiles[k], k,
-                local_coords{(std::uint8_t)i, (std::uint8_t)j});
-}
-
 } // namespace Magnum::Examples
diff --git a/src/tile-iterator.cpp b/src/tile-iterator.cpp
index ea98a6ee..d2dbf98d 100644
--- a/src/tile-iterator.cpp
+++ b/src/tile-iterator.cpp
@@ -1,7 +1,38 @@
 #include "tile-iterator.hpp"
+#include "tile.hpp"
 
 namespace Magnum::Examples {
 
+template <typename T>
+void basic_tile_iterator<T>::swap(basic_tile_iterator<T>& other)
+{
+    using std::swap;
+    swap(ptr, other.ptr);
+    swap(pos, other.pos);
+}
+
+template <typename T>
+template <std::size_t N>
+typename std::tuple_element<N, basic_tile_iterator<T>>::type basic_tile_iterator<T>::get()
+{
+    if constexpr(N == 0)
+        return pos == TILE_COUNT ? ptr[0] : ptr[pos];
+    else if constexpr(N == 1)
+        return pos;
+    else if constexpr(N == 2)
+        return local_coords{pos};
+    else
+        return std::void_t<std::integral_constant<int, N>>();
+}
+
+template typename std::tuple_element<0, basic_tile_iterator<tile>>::type basic_tile_iterator<tile>::get<0>();
+template typename std::tuple_element<1, basic_tile_iterator<tile>>::type basic_tile_iterator<tile>::get<1>();
+template typename std::tuple_element<2, basic_tile_iterator<tile>>::type basic_tile_iterator<tile>::get<2>();
+
+template typename std::tuple_element<0, basic_tile_iterator<const tile>>::type basic_tile_iterator<const tile>::get<0>();
+template typename std::tuple_element<1, basic_tile_iterator<const tile>>::type basic_tile_iterator<const tile>::get<1>();
+template typename std::tuple_element<2, basic_tile_iterator<const tile>>::type basic_tile_iterator<const tile>::get<2>();
+
 template class basic_tile_iterator<tile>;
 template class basic_tile_iterator<const tile>;
 
diff --git a/src/tile-iterator.hpp b/src/tile-iterator.hpp
index 99a40412..0cd6d616 100644
--- a/src/tile-iterator.hpp
+++ b/src/tile-iterator.hpp
@@ -40,32 +40,26 @@ public:
 
     basic_tile_iterator<T>& operator=(const basic_tile_iterator<T>&) = default;
     basic_tile_iterator<T>& operator++() { pos++; return *this; }
-    basic_tile_iterator<T> operator++(int) { auto tmp = *this; operator++(); return tmp; }
+    basic_tile_iterator<T>  operator++(int) { auto tmp = *this; operator++(); return tmp; }
     basic_tile_iterator<T>* operator->() { return this; }
     basic_tile_iterator<T>& operator*() { return *this; }
     auto operator<=>(const basic_tile_iterator<T>&) const noexcept = default;
-    void swap(basic_tile_iterator<T>& other) {
-        using std::swap;
-        swap(ptr, other.ptr);
-        swap(pos, other.pos);
-    }
+    void swap(basic_tile_iterator<T>& other);
     template<std::size_t N>
-    typename std::tuple_element<N, basic_tile_iterator<T>>::type get()
-    {
-        if constexpr(N == 0)
-            return pos == TILE_COUNT ? ptr[0] : ptr[pos];
-        else if constexpr(N == 1)
-            return pos;
-        else if constexpr(N == 2)
-            return local_coords{pos};
-        else
-            return std::void_t<std::integral_constant<int, N>>();
-    }
+    typename std::tuple_element<N, basic_tile_iterator<T>>::type get();
 };
 
 extern template class basic_tile_iterator<tile>;
 extern template class basic_tile_iterator<const tile>;
 
+extern template typename std::tuple_element<0, basic_tile_iterator<tile>>::type basic_tile_iterator<tile>::get<0>();
+extern template typename std::tuple_element<1, basic_tile_iterator<tile>>::type basic_tile_iterator<tile>::get<1>();
+extern template typename std::tuple_element<2, basic_tile_iterator<tile>>::type basic_tile_iterator<tile>::get<2>();
+
+extern template typename std::tuple_element<0, basic_tile_iterator<const tile>>::type basic_tile_iterator<const tile>::get<0>();
+extern template typename std::tuple_element<1, basic_tile_iterator<const tile>>::type basic_tile_iterator<const tile>::get<1>();
+extern template typename std::tuple_element<2, basic_tile_iterator<const tile>>::type basic_tile_iterator<const tile>::get<2>();
+
 } // namespace Magnum::Examples
 
 namespace std {
diff --git a/src/tile.hpp b/src/tile.hpp
index d607a2d3..b3b57d08 100644
--- a/src/tile.hpp
+++ b/src/tile.hpp
@@ -28,7 +28,9 @@ struct tile final
     pass_mode passability = pass_shoot_through;
 
     constexpr tile() = default;
-    DECLARE_DEPRECATED_COPY_OPERATOR(tile);
+    tile(tile&&) = default;
+
+    DECLARE_DEPRECATED_COPY_ASSIGNMENT(tile);
 };
 
 } //namespace Magnum::Examples
-- 
cgit v1.2.3