roguish/save.cpp

#include "save.hpp"
#include <fstream>
#include "dbc.hpp"
#include <fmt/core.h>

using namespace components;


template<typename CompT>
inline void extract(DinkyECS::World &world, std::map<DinkyECS::Entity, CompT> &into) {
  auto from_world = world.entity_map_for<CompT>();
  for(auto [entity, value] : from_world) {
    into[entity] = std::any_cast<CompT>(value);
  }
}

void save::to_file(std::string path, DinkyECS::World &world) {
  SaveData save_data;
  tser::BinaryArchive archive;

  save_data.facts.player = world.get_the<Player>();

  extract<Position>(world, save_data.position);
  extract<Combat>(world, save_data.combat);
  extract<Motion>(world, save_data.motion);

  archive.save(save_data);
  std::string_view archive_view = archive.get_buffer();

  std::ofstream out(path, std::ios::binary);
  out << archive_view;
  out.flush();
}

template<typename CompT>
inline void inject(DinkyECS::World &world, std::map<DinkyECS::Entity, CompT> &outof) {
  for(auto [entity, value] : outof) {
    world.set<CompT>(entity, value);
  }
}

void save::from_file(std::string path, DinkyECS::World &world_out) {
  tser::BinaryArchive archive(0);

  if(std::ifstream in_file{path, std::ios::binary | std::ios::ate}) {
    auto size = in_file.tellg();
    std::string in_data(size, '\0');
    in_file.seekg(0);

    if(in_file.read(&in_data[0], size)) {
      std::string_view in_view(in_data);
      archive.initialize(in_view);
    } else {
      dbc::sentinel(fmt::format("wrong size or error reading {}", path));
    }
  } else {
    dbc::sentinel(fmt::format("failed to load file {}", path));
  }

  auto save_data = archive.load<SaveData>();
  world_out.set_the<Player>(save_data.facts.player);
  inject<Position>(world_out, save_data.position);
  inject<Combat>(world_out, save_data.combat);
  inject<Motion>(world_out, save_data.motion);
}