scraps

importer_base.cpp (12488B)

---

 #include "scraps/format/rags_common/importer_base.hpp"
 
 #include "scraps/format/archive.hpp"
 #include "scraps/format/rags_common/description.hpp"
 #include "scraps/game/character_state.hpp" // IWYU pragma: keep
 #include "scraps/game/object_state.hpp" // IWYU pragma: keep
 #include "scraps/game/game_state.hpp"
 
 #include <libshit/assert.hpp>
 #include <libshit/char_utils.hpp>
 #include <libshit/doctest_std.hpp>
 #include <libshit/memory_utils.hpp>
 #include <libshit/utils.hpp>
 
 #include <capnp/common.h>
 #include <capnp/layout.h>
 #include <capnp/list.h>
 #include <capnp/orphan.h>
 
 #include <boost/endian/buffers.hpp>
 
 #include <algorithm>
 #include <cstring>
 #include <tuple>
 #include <vector>
 
 #define LIBSHIT_LOG_NAME "import"
 #include <libshit/logger_helper.hpp>
 
 namespace Scraps::Format::RagsCommon
 {
   TEST_SUITE_BEGIN("Scraps::Format::RagsCommon");
 
   ImporterBase::ImporterBase()
     : bld{1024*1024 / sizeof(capnp::word)},
       game{bld.initRoot<Proto::Game>()}
   {
     game.SetPlayerId(GetId());
     LIBSHIT_ASSERT(game.GetPlayerId() == 1);
   }
 
   std::uint64_t ImporterBase::FindId(
     const IdMap& map, Libshit::StringView key, Libshit::StringView what,
     std::optional<Libshit::StringView> missing_key)
   {
     if (key == missing_key) return 0;
     if (auto it = map.find(key); it != map.end()) return it->second;
 
     WARN << "Missing " << what << " " << Libshit::Quoted(key)
          << ", ignored" << std::endl;
     return 0;
   }
 
   std::uint64_t ImporterBase::FindId(
     const IdMap& name_map, const UuidMap& uuid_map, Libshit::StringView key,
     Libshit::StringView what, std::optional<Libshit::StringView> missing_key)
   {
     if (key == missing_key) return 0;
     if (auto uuid = Uuid::TryParse(key))
     {
       if (auto it = uuid_map.find(*uuid); it != uuid_map.end())
         return it->second;
     }
     else if (auto it = name_map.find(key); it != name_map.end())
       return it->second;
 
     WARN << "Missing " << what << " UUID or name " << Libshit::Quoted(key)
          << ", ignored" << std::endl;
     return 0;
   }
 
   // Game
   static std::pair<ImporterBase::IdMap, std::vector<std::string>>
   GenListIds(ImporterBase& imp, std::vector<std::string>&& list,
              Libshit::StringView what)
   {
     ImporterBase::IdMap res;
     std::vector<std::string> vect;
     for (auto&& x : list)
     {
       auto [it, inserted] = res.try_emplace(x, imp.GetId());
       if (inserted)
         vect.push_back(Libshit::Move(x));
       else
         WARN << "Duplicate " << what << " " << Libshit::Quoted(x) << ", ignored"
              << std::endl;
     }
     return {Libshit::Move(res), Libshit::Move(vect)};
   }
 
   TEST_CASE("GenListIds")
   {
     ImporterBase imp;
     SUBCASE("empty")
     {
       auto [m, v] = GenListIds(imp, {}, "");
       CHECK(m.empty());
       CHECK(v.empty());
     }
 
     SUBCASE("one item")
     {
       auto [m, v] = GenListIds(imp, {"abc"}, "");
       CHECK(m.size() == 1);
       CHECK(m.at("abc") == 2);
       CHECK(v == std::vector<std::string>{"abc"});
     }
 
     SUBCASE("three item, good order")
     {
       auto [m, v] = GenListIds(imp, {"aa","bc","xxx"}, "");
       CHECK(m.size() == 3);
       CHECK(m.at("aa") == 2);
       CHECK(m.at("bc") == 3);
       CHECK(m.at("xxx") == 4);
       CHECK(v == std::vector<std::string>{"aa", "bc", "xxx"});
     }
 
     SUBCASE("three item, bad order")
     {
       auto [m, v] = GenListIds(imp, {"xxx","aa","bc"}, "");
       CHECK(m.size() == 3);
       CHECK(m.at("xxx") == 2);
       CHECK(m.at("aa") == 3);
       CHECK(m.at("bc") == 4);
       CHECK(v == std::vector<std::string>{"xxx", "aa", "bc"});
     }
 
     SUBCASE("dup")
     {
       auto [m, v] = GenListIds(imp, {"abc","abc"}, "test normal");
       CHECK(m.size() == 1);
       CHECK(m.at("abc") == 2);
       CHECK(v == std::vector<std::string>{"abc"});
     }
   }
 
   template <auto Func>
   static void CommaSepCommon(
     ImporterBase& imp, ImporterBase::IdMap& groups,
     Proto::Game::Builder game,
     std::vector<std::string>&& list,
     Libshit::StringView what)
   {
     std::vector<std::string> order;
     std::tie(groups, order) = GenListIds(imp, Libshit::Move(list), what);
     auto capnp_list = (game.*Func)(order.size());
     std::uint32_t i = 0;
     for (auto&& name : order)
     {
       capnp_list[i].SetId(groups.at(name));
       capnp_list[i].SetName(imp.sp.InternString(Libshit::Move(name)));
       ++i;
     }
   }
 
   ImporterBase::IdMap::iterator ImporterBase::InsertUniqueName(
     IdMap& ids, std::string&& name, Libshit::StringView what, std::uint64_t id)
   {
     if (!id) id = GetId();
     if (auto [it, inserted] = ids.try_emplace(Libshit::Move(name), id); inserted)
       return it;
 
     if (!what.empty())
       WARN << "Duplicate " << what << " name " << Libshit::Quoted(name)
            << ", renamed" << std::endl;
 
     name += "_conflict";
     auto orig_len = name.size();
 
     for (std::uint32_t i = 0; ; ++i)
     {
       name.resize(orig_len);
       name += std::to_string(i);
       if (auto [it, inserted] = ids.try_emplace(Libshit::Move(name), id);
           inserted)
         return it;
     }
   }
 
   TEST_CASE("InsertUniqueName")
   {
     ImporterBase imp;
     auto it = imp.InsertUniqueName(imp.file_ids, "foo", "");
     CHECK(it->first == "foo");
     CHECK(it->second == 2);
 
     it = imp.InsertUniqueName(imp.file_ids, "bar", "", 69);
     CHECK(it->first == "bar");
     CHECK(it->second == 69);
 
     it = imp.InsertUniqueName(imp.file_ids, "foo", "");
     CHECK(it->first == "foo_conflict0");
     CHECK(it->second == 3);
 
     it = imp.InsertUniqueName(imp.file_ids, "foo", "", 1337);
     CHECK(it->first == "foo_conflict1");
     CHECK(it->second == 1337);
   }
 
   std::string ImporterBase::GetUniqueName(NameSet& set, std::string&& name)
   {
     if (auto [it, inserted] = set.insert(name); inserted)
       return Libshit::Move(name);
 
     name += "_conflict";
     auto orig_len = name.size();
 
     for (std::uint32_t i = 0; ; ++i)
     {
       name.resize(orig_len);
       name += std::to_string(i);
       if (auto [it, inserted] = set.insert(name); inserted)
         return Libshit::Move(name);
     }
   }
 
   TEST_CASE("GetUniqueName")
   {
     ImporterBase::NameSet set;
     CHECK(ImporterBase::GetUniqueName(set, "foo") == "foo");
     CHECK(ImporterBase::GetUniqueName(set, "foo") == "foo_conflict0");
     CHECK(ImporterBase::GetUniqueName(set, "bar") == "bar");
     CHECK(ImporterBase::GetUniqueName(set, "foo") == "foo_conflict1");
   }
 
   void ImporterBase::SetRoomGroups(
     Proto::Game::Builder game, std::vector<std::string>&& list)
   {
     CommaSepCommon<&Proto::Game::Builder::InitRoomGroups>(
       *this, room_group_ids, game, Libshit::Move(list), "room group");
   }
 
   void ImporterBase::SetClothingZones(
     Proto::Game::Builder game, std::vector<std::string>&& list)
   {
     CommaSepCommon<&Proto::Game::Builder::InitClothingZones>(
       *this, clothing_zone_ids, game, Libshit::Move(list), "clothing zone");
   }
 
   template <typename Proxy>
   static std::vector<std::uint32_t> CalcOrder(Proxy coll, std::uint32_t offs)
   {
     if (coll.Size() <= offs) return {};
 
     std::vector<std::uint32_t> res;
     std::vector<std::string> names;
     res.reserve(coll.Size());
     names.reserve(coll.Size());
     for (std::uint32_t i = 0, n = coll.Size(); i < n; ++i)
     {
       res.push_back(i);
       coll.At(i).CalculateToString(names.emplace_back());
     }
     std::sort(res.begin() + offs, res.end(), [&](std::uint32_t a, std::uint32_t b)
     { return names[a] < names[b]; });
     return res;
   }
 
   template <typename List>
   static ImporterBase::IdRemap GenRemap(
     List lst, const std::vector<std::uint32_t>& order)
   {
     ImporterBase::IdRemap res;
     LIBSHIT_ASSERT(lst.size() == order.size());
     for (std::uint32_t i = 0, n = lst.size(); i < n; ++i)
     {
       auto ins = res.try_emplace(lst[order[i]].GetId(), lst[i].GetId()).second;
       LIBSHIT_ASSERT(ins);
     }
     return res;
   }
 
   static void SortCapnp(
     const std::vector<std::uint32_t>& order, capnp::_::ListBuilder lst,
     capnp::_::StructSize struct_size)
   {
     LIBSHIT_ASSERT(order.size() == lst.size());
     const auto n = lst.size();
     auto elem_siz = struct_size.total() * sizeof(capnp::word);
     auto siz = n * elem_siz;
     auto buf = Libshit::MakeUnique<char[]>(siz, Libshit::uninitialized);
     auto cap_dat = reinterpret_cast<char*>(lst.getLocation() + 1);
     std::memcpy(buf.get(), cap_dat, siz);
     std::memset(cap_dat, 0, siz);
 
     for (std::size_t i = 0; i < n; ++i)
     {
       std::memcpy(cap_dat + elem_siz * i, buf.get() + elem_siz * order[i],
                   elem_siz);
 
       // Unfortunately pointers contains offsets relative to the pointer itself,
       // not the segment start, so we have to recalculate those. I have no
       // freakin idea how could you achive this using the "public" capnp api
       // (if it is possible at all), so just bit-bang it.
       std::int32_t diff = std::int32_t(elem_siz / sizeof(capnp::word)) *
         (std::int32_t(order[i]) - std::int32_t(i));
 
       auto p = reinterpret_cast<boost::endian::little_uint32_buf_t*>(
         cap_dat + elem_siz * i + struct_size.data * sizeof(capnp::word));
       for (std::size_t j = 0; j < struct_size.pointers; ++j)
       {
         auto pv = p[j*2].value();
         // but far pointers contain offset relative to the segment start for the
         // sake of consistency, I think
         if ((pv & 3) == 2) continue;
 
         // leave null pointers alone
         if (std::int32_t off = std::int32_t(pv) >> 2)
           p[j*2] = (std::uint32_t(off + diff) << 2) | (pv & 3);
       }
     }
   }
 
   void ImporterBase::FinishGame(
     std::int32_t object_so, std::int32_t chara_so, std::int32_t inventory_so)
   {
     if (game.GetShowMainImage()) game.SetInlineImages(false);
     game.AdoptStringPool(sp.ToCapnp(bld.getOrphanage()));
 
     // yes, NATURAL and LILO means unordered, and if any of [object, inventory]
     // sort order is alpha, both of them will be sorted. seriously, what did you
     // expect?
     bool sort_chara = chara_so == SortOrder::ALPHA;
     bool sort_obj = object_so == SortOrder::ALPHA || inventory_so == SortOrder::ALPHA;
     if (!sort_chara && !sort_obj) return;
 
     std::vector<std::uint32_t> chara_order, obj_order;
     {
       Game::GameState gs{Libshit::MakeUnique<Format::DummyArchiveReader>(game)};
 
       if (sort_chara) chara_order = CalcOrder(gs.GetCharacterColl(), 1);
       if (sort_obj) obj_order = CalcOrder(gs.GetObjectColl(), 0);
     }
 
     if (!chara_order.empty())
     {
       RemapCharacter(GenRemap(game.GetCharacters(), chara_order));
       SortCapnp(chara_order, PrivateGetter::GetBuilder(game.GetCharacters()),
                 capnp::_::structSize<Proto::Character>());
     }
     if (!obj_order.empty())
     {
       RemapObject(GenRemap(game.GetObjects(), obj_order));
       SortCapnp(obj_order, PrivateGetter::GetBuilder(game.GetObjects()),
                 capnp::_::structSize<Proto::Object>());
     }
   }
 
   // Character
   void ImporterBase::RemapCharacter(const IdRemap& remap)
   {
     for (auto c : game.GetCharacters())
       c.SetId(remap.at(c.GetId()));
     for (auto o : game.GetObjects())
       if (auto l = o.GetLocation(); l.IsCharacterId())
         l.SetCharacterId(remap.at(l.GetCharacterId()));
   }
 
   // Player
   void ImporterBase::FinishPlayer(Proto::Character::Builder player)
   {
     LIBSHIT_ASSERT(game.GetPlayerId() == 1);
 
     player.SetId(game.GetPlayerId());
     // don't warn when we already have a "player" character, it's fine
     auto name = InsertUniqueName(character_ids, "player", "", 1);
     player.SetName(sp.InternCopy(name->first));
   }
 
   // Room
   Proto::Room::Exit::Direction ImporterBase::ConvertDirection(std::int32_t dir)
   {
     if (dir <= Direction::EMPTY || dir > Direction::OUT)
       LIBSHIT_THROW(Libshit::DecodeError, "Invalid exit direction",
                     "Direction", dir);
     return static_cast<Proto::Room::Exit::Direction>(dir);
   }
 
   // Timer
   void ImporterBase::FinishTimer(Proto::Timer::Builder timer, TimerType type)
   {
     timer.SetId(timer_ids.at(sp.Get(timer.GetName())));
 
     switch (type)
     {
     case TimerType::RUN_ALWAYS: timer.SetWithLength(false); break;
     case TimerType::LENGTH:     timer.SetWithLength(true);  break;
     default:
       LIBSHIT_THROW(ImportError, "Unknown timer type", "Type", type);
     }
   }
 
   // StatusBarItem
   void ImporterBase::FinishStatusBarItem(Proto::StatusBarItem::Builder it)
   { it.SetId(statusbar_ids.at(sp.Get(it.GetName()))); }
 
   TEST_SUITE_END();
 }