.

1 files changed, 78 insertions, 54 deletions

diff --git a/crop-tool/serialize.cpp b/crop-tool/serialize.cpp
index 8d3a5cf7..34d70faa 100644
--- a/crop-tool/serialize.cpp
+++ b/crop-tool/serialize.cpp
@@ -12,72 +12,87 @@ using Corrade::Utility::Error;
 
 static constexpr
 std::pair<anim_direction, const char*> anim_direction_map[] = {
-    { anim_direction::Invalid,  "x"     },
-    { anim_direction::N,        "N"     },
-    { anim_direction::NE,       "NE"    },
-    { anim_direction::E,        "E"     },
-    { anim_direction::SE,       "SE"    },
-    { anim_direction::S,        "S"     },
-    { anim_direction::SW,       "SW"    },
-    { anim_direction::W,        "W"     },
-    { anim_direction::NW,       "NW"    },
+    { anim_direction::N,        "n"     },
+    { anim_direction::NE,       "ne"    },
+    { anim_direction::E,        "e"     },
+    { anim_direction::SE,       "se"    },
+    { anim_direction::S,        "s"     },
+    { anim_direction::SW,       "sw"    },
+    { anim_direction::W,        "w"     },
+    { anim_direction::NW,       "nw"    },
 };
 
+const char* anim_group::direction_to_string(anim_direction group)
+{
+    auto it = std::find_if(std::cbegin(anim_direction_map), std::cend(anim_direction_map),
+                           [=](const auto& pair) { return group == pair.first; });
+    if (it != std::cend(anim_direction_map))
+        return it->second;
+    else
+        return "(unknown)";
+}
+
+anim_direction anim_group::string_to_direction(const std::string& str)
+{
+    auto it = std::find_if(std::cbegin(anim_direction_map), std::cend(anim_direction_map),
+                           [&](const auto& pair) { return str == pair.second; });
+    if (it != std::cend(anim_direction_map))
+        return it->first;
+    else
+        return (anim_direction)0;
+}
+
 namespace nlohmann {
 
 template<>
-struct adl_serializer<Magnum::Vector2i> final {
-    static void to_json(json& j, const Magnum::Vector2i& x)
-    {
-        j["x"] = x[0];
-        j["y"] = x[1];
-    }
-
-    static void from_json(const json& j, Magnum::Vector2i& x)
-    {
-        j.at("x").get_to(x[0]);
-        j.at("y").get_to(x[1]);
-    }
+struct adl_serializer<anim_direction> final {
+    static void to_json(json& j, anim_direction x);
+    static void from_json(const json& j, anim_direction& x);
 };
 
 template<>
-struct adl_serializer<anim_direction> final {
-    static void to_json(json& j, anim_direction x)
-    {
-        auto it = std::find_if(std::cbegin(anim_direction_map), std::cend(anim_direction_map),
-                               [=](const auto& pair) { return x == pair.first; });
-        if (it != std::cend(anim_direction_map))
-            j = it->second;
-        else
-            j = anim_direction_map[0].second;
-    }
-    static void from_json(const json& j, anim_direction& x)
-    {
-        std::string str = j;
-        auto it = std::find_if(std::cbegin(anim_direction_map), std::cend(anim_direction_map),
-                               [&](const auto& pair) { return str == pair.second; });
-        if (it != std::cend(anim_direction_map))
-            x = it->first;
-        else
-            x = anim_direction::Invalid;
-    }
+struct adl_serializer<Magnum::Vector2i> final {
+    static void to_json(json& j, const Magnum::Vector2i& x);
+    static void from_json(const json& j, Magnum::Vector2i& x);
 };
 
+void adl_serializer<Magnum::Vector2i>::to_json(json& j, const Magnum::Vector2i& x)
+{
+    j["x"] = x[0];
+    j["y"] = x[1];
+}
+
+void adl_serializer<Magnum::Vector2i>::from_json(const json& j, Magnum::Vector2i& x)
+{
+    j.at("x").get_to(x[0]);
+    j.at("y").get_to(x[1]);
+}
+
+void adl_serializer<anim_direction>::to_json(json& j, anim_direction x)
+{
+    j = anim_group::direction_to_string(x);
+}
+
+void adl_serializer<anim_direction>::from_json(const json& j, anim_direction& x)
+{
+    x = anim_group::string_to_direction(j);
+}
+
 } // namespace nlohmann
 
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(anim_frame, ground);
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(anim_direction_group, group, frames);
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(anim, name, nframes, actionframe, fps, directions);
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(anim_group, direction, frames, ground);
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(anim, name, nframes, actionframe, fps, groups);
 
 std::optional<anim> anim::from_json(const std::filesystem::path& pathname)
 {
     using namespace nlohmann;
     std::ifstream s;
-    s.exceptions(s.exceptions() | std::ios::failbit);
+    s.exceptions(s.exceptions() | std::ios::failbit | std::ios::badbit);
     try {
         s.open(pathname, std::ios_base::in);
-    } catch (const std::ios_base::failure& e) {
-        Error{} << "failed to open" << pathname << ":" << e.what();
+    } catch (const std::ios::failure& e) {
+        Error{} << "failed to open" << pathname << ':' << e.what();
         return std::nullopt;
     }
     anim ret;
@@ -87,17 +102,26 @@ std::optional<anim> anim::from_json(const std::filesystem::path& pathname)
         using nlohmann::from_json;
         from_json(j, ret);
     } catch (const std::exception& e) {
-        Error{} << "failed to parse" << pathname.string() << ":" << e.what();
+        Error{} << "failed to parse" << pathname << ':' << e.what();
+        return std::nullopt;
     }
     return std::make_optional(std::move(ret));
 }
 
-const char* anim_direction_group::anim_direction_string(anim_direction group)
+bool anim::to_json(const std::filesystem::path& pathname)
 {
-    auto it = std::find_if(std::cbegin(anim_direction_map), std::cend(anim_direction_map),
-                           [=](const auto& pair) { return group == pair.first; });
-    if (it != std::cend(anim_direction_map))
-        return it->second;
-    else
-        return "(unknown)";
+    nlohmann::json j = *this;
+
+    std::ofstream s;
+    s.exceptions(s.exceptions() | std::ios::failbit | std::ios::badbit);
+    try {
+        s.open(pathname, std::ios_base::out | std::ios_base::trunc);
+    } catch (const std::ios::failure& e) {
+        Error{} << "failed to open" << pathname << "for writing:" << e.what();
+        return false;
+    }
+    s << j.dump(4);
+    s.flush();
+
+    return true;
 }