src/io/WorldSave.cpp

   1 #include "WorldSave.hpp"
   2
   3 #include "filesystem.hpp"
   4
   5 #include <cctype>
   6 #include <cstring>
   7 #include <fstream>
   8 #include <iostream>
   9 #include <limits>
  10 #include <stdexcept>
  11 #include <zlib.h>
  12
  13 using namespace std;
  14
  15
  16 namespace blank {
  17
  18 WorldSave::WorldSave(const string &path)
  19 : root_path(path)
  20 , world_conf_path(path + "world.conf")
  21 , gen_conf_path(path + "gen.conf")
  22 , chunk_path(path + "chunks/%d/%d/%d.gz")
  23 , chunk_bufsiz(chunk_path.length() + 3 * std::numeric_limits<int>::digits10)
  24 , chunk_buf(new char[chunk_bufsiz]) {
  25
  26 }
  27
  28
  29 bool WorldSave::Exists() const noexcept {
  30         return is_dir(root_path) && is_file(world_conf_path);
  31 }
  32
  33
  34 // TODO: better implementation of config files
  35 void WorldSave::Read(World::Config &conf) const {
  36         ifstream in(world_conf_path);
  37         if (!in) {
  38                 throw runtime_error("failed to open world config");
  39         }
  40
  41         constexpr char spaces[] = "\n\r\t ";
  42
  43         string line;
  44         while (getline(in, line)) {
  45                 if (line.empty() || line[0] == '#') continue;
  46                 auto equals_pos = line.find_first_of('=');
  47
  48                 auto name_begin = line.find_first_not_of(spaces, 0, sizeof(spaces));
  49                 auto name_end = equals_pos - 1;
  50                 while (name_end > name_begin && isspace(line[name_end])) {
  51                         --name_end;
  52                 }
  53
  54                 auto value_begin = line.find_first_not_of(spaces, equals_pos + 1, sizeof(spaces));
  55                 auto value_end = line.length() - 1;
  56                 while (value_end > value_begin && isspace(line[value_end])) {
  57                         --value_end;
  58                 }
  59
  60                 string name(line, name_begin, name_end - name_begin + 1);
  61                 string value(line, value_begin, value_end - value_begin + 1);
  62
  63         //      if (name == "seed") {
  64         //              conf.gen.seed = stoul(value);
  65         //      } else {
  66                         throw runtime_error("unknown world option: " + name);
  67         //      }
  68         }
  69         if (in.bad()) {
  70                 throw runtime_error("IO error reading world config");
  71         }
  72 }
  73
  74 void WorldSave::Write(const World::Config &conf) const {
  75         if (!make_dirs(root_path)) {
  76                 throw runtime_error("failed to create world save directory");
  77         }
  78
  79         ofstream out(world_conf_path);
  80         //out << "seed = " << conf.gen.seed << endl;
  81         out.close();
  82
  83         if (!out) {
  84                 throw runtime_error("failed to write world config");
  85         }
  86 }
  87
  88
  89 void WorldSave::Read(Generator::Config &conf) const {
  90         ifstream in(gen_conf_path);
  91         if (!in) {
  92                 throw runtime_error("failed to open generator config");
  93         }
  94
  95         constexpr char spaces[] = "\n\r\t ";
  96
  97         string line;
  98         while (getline(in, line)) {
  99                 if (line.empty() || line[0] == '#') continue;
 100                 auto equals_pos = line.find_first_of('=');
 101
 102                 auto name_begin = line.find_first_not_of(spaces, 0, sizeof(spaces));
 103                 auto name_end = equals_pos - 1;
 104                 while (name_end > name_begin && isspace(line[name_end])) {
 105                         --name_end;
 106                 }
 107
 108                 auto value_begin = line.find_first_not_of(spaces, equals_pos + 1, sizeof(spaces));
 109                 auto value_end = line.length() - 1;
 110                 while (value_end > value_begin && isspace(line[value_end])) {
 111                         --value_end;
 112                 }
 113
 114                 string name(line, name_begin, name_end - name_begin + 1);
 115                 string value(line, value_begin, value_end - value_begin + 1);
 116
 117                 if (name == "seed") {
 118                         conf.seed = stoul(value);
 119                 } else {
 120                         throw runtime_error("unknown generator option: " + name);
 121                 }
 122         }
 123         if (in.bad()) {
 124                 throw runtime_error("IO error reading world config");
 125         }
 126 }
 127
 128 void WorldSave::Write(const Generator::Config &conf) const {
 129         if (!make_dirs(root_path)) {
 130                 throw runtime_error("failed to create world save directory");
 131         }
 132
 133         ofstream out(gen_conf_path);
 134         out << "seed = " << conf.seed << endl;
 135         out.close();
 136
 137         if (!out) {
 138                 throw runtime_error("failed to write generator config");
 139         }
 140 }
 141
 142
 143 bool WorldSave::Exists(const Chunk::Pos &pos) const noexcept {
 144         return is_file(ChunkPath(pos));
 145 }
 146
 147 void WorldSave::Read(Chunk &chunk) const {
 148         const char *path = ChunkPath(chunk.Position());
 149         gzFile file = gzopen(path, "r");
 150         if (!file) {
 151                 throw runtime_error("failed to open chunk file");
 152         }
 153         if (gzread(file, chunk.BlockData(), Chunk::BlockSize()) != Chunk::BlockSize()) {
 154                 throw runtime_error("failed to read chunk from file");
 155         }
 156         if (gzclose(file) != Z_OK) {
 157                 throw runtime_error("failed to read chunk file");
 158         }
 159         chunk.InvalidateModel();
 160         chunk.ClearSave();
 161 }
 162
 163 void WorldSave::Write(Chunk &chunk) const {
 164         const char *path = ChunkPath(chunk.Position());
 165         gzFile file = gzopen(path, "w");
 166         if (!file) {
 167                 // check if it's because of a missing path component
 168                 if (errno != ENOENT) {
 169                         // nope, fatal
 170                         throw runtime_error(strerror(errno));
 171                 }
 172                 string dir_path(path);
 173                 dir_path.erase(dir_path.find_last_of("\\/"));
 174                 if (!make_dirs(dir_path)) {
 175                         throw runtime_error("failed to create dir for chunk file");
 176                 }
 177                 file = gzopen(path, "w");
 178                 if (!file) {
 179                         throw runtime_error("failed to open chunk file");
 180                 }
 181         }
 182         if (gzwrite(file, chunk.BlockData(), Chunk::BlockSize()) == 0) {
 183                 gzclose(file); // if this fails, it can't be helped
 184                 throw runtime_error("failed to write chunk to file");
 185         }
 186         if (gzclose(file) != Z_OK) {
 187                 throw runtime_error("failed to write chunk file");
 188         }
 189         chunk.ClearSave();
 190 }
 191
 192
 193 const char *WorldSave::ChunkPath(const Chunk::Pos &pos) const {
 194         snprintf(chunk_buf.get(), chunk_bufsiz, chunk_path.c_str(), pos.x, pos.y, pos.z);
 195         return chunk_buf.get();
 196 }
 197
 198 }