everything everywhere

all at once

1 files changed, 828 insertions, 0 deletions

diff --git a/source/game/StarCelestialDatabase.cpp b/source/game/StarCelestialDatabase.cpp
new file mode 100644
index 0000000..718bfde
--- /dev/null
+++ b/source/game/StarCelestialDatabase.cpp
@@ -0,0 +1,828 @@
+#include "StarCelestialDatabase.hpp"
+#include "StarLexicalCast.hpp"
+#include "StarCasting.hpp"
+#include "StarRandom.hpp"
+#include "StarCompression.hpp"
+#include "StarFile.hpp"
+#include "StarJsonExtra.hpp"
+#include "StarDataStreamExtra.hpp"
+#include "StarRoot.hpp"
+#include "StarAssets.hpp"
+#include "StarVersioningDatabase.hpp"
+#include "StarIterator.hpp"
+
+namespace Star {
+
+CelestialDatabase::~CelestialDatabase() {}
+
+RectI CelestialDatabase::xyRange() const {
+  auto range = m_baseInformation.xyCoordRange;
+  return RectI(range[0], range[0], range[1], range[1]);
+}
+
+int CelestialDatabase::planetOrbitalLevels() const {
+  return m_baseInformation.planetOrbitalLevels;
+}
+
+int CelestialDatabase::satelliteOrbitalLevels() const {
+  return m_baseInformation.satelliteOrbitalLevels;
+}
+
+Vec2I CelestialDatabase::chunkIndexFor(CelestialCoordinate const& coordinate) const {
+  return chunkIndexFor(coordinate.location().vec2());
+}
+
+Vec2I CelestialDatabase::chunkIndexFor(Vec2I const& systemXY) const {
+  return {(systemXY[0] - pmod(systemXY[0], m_baseInformation.chunkSize)) / m_baseInformation.chunkSize,
+      (systemXY[1] - pmod(systemXY[1], m_baseInformation.chunkSize)) / m_baseInformation.chunkSize};
+}
+
+List<Vec2I> CelestialDatabase::chunkIndexesFor(RectI const& region) const {
+  if (region.isEmpty())
+    return {};
+
+  List<Vec2I> chunkLocations;
+  RectI chunkRegion(chunkIndexFor(region.min()), chunkIndexFor(region.max() - Vec2I(1, 1)));
+  for (int x = chunkRegion.xMin(); x <= chunkRegion.xMax(); ++x) {
+    for (int y = chunkRegion.yMin(); y <= chunkRegion.yMax(); ++y)
+      chunkLocations.append({x, y});
+  }
+  return chunkLocations;
+}
+
+RectI CelestialDatabase::chunkRegion(Vec2I const& chunkIndex) const {
+  return RectI(chunkIndex * m_baseInformation.chunkSize, (chunkIndex + Vec2I(1, 1)) * m_baseInformation.chunkSize);
+}
+
+CelestialMasterDatabase::CelestialMasterDatabase(Maybe<String> databaseFile) {
+  auto assets = Root::singleton().assets();
+
+  auto config = assets->json("/celestial.config");
+
+  m_baseInformation.planetOrbitalLevels = config.getInt("planetOrbitalLevels");
+  m_baseInformation.satelliteOrbitalLevels = config.getInt("satelliteOrbitalLevels");
+  m_baseInformation.chunkSize = config.getInt("chunkSize");
+  m_baseInformation.xyCoordRange = jsonToVec2I(config.get("xyCoordRange"));
+  m_baseInformation.zCoordRange = jsonToVec2I(config.get("zCoordRange"));
+
+  m_generationInformation.systemProbability = config.getFloat("systemProbability");
+  m_generationInformation.constellationProbability = config.getFloat("constellationProbability");
+  m_generationInformation.constellationLineCountRange = jsonToVec2U(config.get("constellationLineCountRange"));
+  m_generationInformation.constellationMaxTries = config.getUInt("constellationMaxTries");
+  m_generationInformation.maximumConstellationLineLength = config.getFloat("maximumConstellationLineLength");
+  m_generationInformation.minimumConstellationLineLength = config.getFloat("minimumConstellationLineLength");
+  m_generationInformation.minimumConstellationMagnitude = config.getFloat("minimumConstellationMagnitude");
+  m_generationInformation.minimumConstellationLineCloseness = config.getFloat("minimumConstellationLineCloseness");
+
+  // Copy construct into a Map<String, Json> in the parsing of the weighted
+  // pools to make sure that each WeightedPool is predictably populated based
+  // on key order.
+
+  for (auto const& systemPair : Map<String, Json>::from(config.getObject("systemTypes"))) {
+    SystemType systemType;
+    systemType.typeName = systemPair.first;
+    systemType.baseParameters = systemPair.second.get("baseParameters");
+    systemType.variationParameters = systemPair.second.getArray("variationParameters", JsonArray());
+    for (auto const& orbitRegion : systemPair.second.getArray("orbitRegions", JsonArray())) {
+      String regionName = orbitRegion.getString("regionName");
+      Vec2I orbitRange = jsonToVec2I(orbitRegion.get("orbitRange"));
+      float bodyProbability = orbitRegion.getFloat("bodyProbability");
+      WeightedPool<String> regionPlanetaryTypes = jsonToWeightedPool<String>(orbitRegion.get("planetaryTypes"));
+      WeightedPool<String> regionSatelliteTypes = jsonToWeightedPool<String>(orbitRegion.get("satelliteTypes"));
+      systemType.orbitRegions.append({regionName, orbitRange, bodyProbability, regionPlanetaryTypes, regionSatelliteTypes});
+    }
+    m_generationInformation.systemTypes.add(systemPair.first, systemType);
+  }
+
+  m_generationInformation.systemTypePerlin = PerlinD(config.getObject("systemTypePerlin"), staticRandomU64("SystemTypePerlin"));
+  m_generationInformation.systemTypeBins = config.get("systemTypeBins");
+
+  for (auto const& planetaryPair : Map<String, Json>::from(config.getObject("planetaryTypes"))) {
+    PlanetaryType planetaryType;
+    planetaryType.typeName = planetaryPair.first;
+    planetaryType.satelliteProbability = planetaryPair.second.getFloat("satelliteProbability");
+    planetaryType.maxSatelliteCount =
+        planetaryPair.second.getUInt("maxSatelliteCount", m_baseInformation.satelliteOrbitalLevels);
+    planetaryType.baseParameters = planetaryPair.second.get("baseParameters");
+    planetaryType.variationParameters = planetaryPair.second.getArray("variationParameters", JsonArray());
+    planetaryType.orbitParameters = planetaryPair.second.getObject("orbitParameters", JsonObject());
+    m_generationInformation.planetaryTypes[planetaryType.typeName] = planetaryType;
+  }
+
+  for (auto const& satellitePair : Map<String, Json>::from(config.getObject("satelliteTypes"))) {
+    SatelliteType satelliteType;
+    satelliteType.typeName = satellitePair.first;
+    satelliteType.baseParameters = satellitePair.second.get("baseParameters");
+    satelliteType.variationParameters = satellitePair.second.getArray("variationParameters", JsonArray());
+    satelliteType.orbitParameters = satellitePair.second.getObject("orbitParameters", JsonObject());
+    m_generationInformation.satelliteTypes[satelliteType.typeName] = satelliteType;
+  }
+
+  auto namesConfig = assets->json("/celestial/names.config");
+  m_generationInformation.planetarySuffixes = jsonToStringList(namesConfig.get("planetarySuffixes"));
+  m_generationInformation.satelliteSuffixes = jsonToStringList(namesConfig.get("satelliteSuffixes"));
+
+  for (auto const& list : namesConfig.get("systemPrefixNames").iterateArray())
+    m_generationInformation.systemPrefixNames.add(list.getFloat(0), list.getString(1));
+
+  for (auto const& list : namesConfig.get("systemNames").iterateArray())
+    m_generationInformation.systemNames.add(list.getFloat(0), list.getString(1));
+
+  for (auto const& list : namesConfig.get("systemSuffixNames").iterateArray())
+    m_generationInformation.systemSuffixNames.add(list.getFloat(0), list.getString(1));
+
+  if (databaseFile) {
+    m_database.setContentIdentifier("Celestial2");
+    m_database.setIODevice(File::open(*databaseFile, IOMode::ReadWrite));
+    m_database.open();
+    if (m_database.contentIdentifier() != "Celestial2") {
+      Logger::error("CelestialMasterDatabase database content identifier is not 'Celestial2', moving out of the way and recreating");
+      m_database.close();
+      File::rename(*databaseFile, strf("%s.%s.fail", *databaseFile, Time::millisecondsSinceEpoch()));
+      m_database.setIODevice(File::open(*databaseFile, IOMode::ReadWrite));
+      m_database.open();
+    }
+    m_database.setAutoCommit(false);
+  }
+
+  m_commitInterval = config.getFloat("commitInterval");
+  m_commitTimer.restart(m_commitInterval);
+}
+
+CelestialBaseInformation CelestialMasterDatabase::baseInformation() const {
+  return m_baseInformation;
+}
+
+CelestialResponse CelestialMasterDatabase::respondToRequest(CelestialRequest const& request) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  if (auto chunkLocation = request.maybeLeft()) {
+    auto chunk = getChunk(*chunkLocation);
+    // System objects are sent by separate system requests.
+    chunk.systemObjects.clear();
+    return makeLeft(move(chunk));
+  } else if (auto systemLocation = request.maybeRight()) {
+    auto const& chunk = getChunk(chunkIndexFor(*systemLocation));
+    CelestialSystemObjects systemObjects = {*systemLocation, chunk.systemObjects.get(*systemLocation)};
+    return makeRight(move(systemObjects));
+  } else {
+    return CelestialResponse();
+  }
+}
+
+void CelestialMasterDatabase::cleanupAndCommit() {
+  RecursiveMutexLocker locker(m_mutex);
+  m_chunkCache.cleanup();
+  if (m_database.isOpen() && m_commitTimer.timeUp()) {
+    m_database.commit();
+    m_commitTimer.restart(m_commitInterval);
+  }
+}
+
+bool CelestialMasterDatabase::coordinateValid(CelestialCoordinate const& coordinate) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  if (!coordinate)
+    return false;
+
+  auto const& chunk = getChunk(chunkIndexFor(coordinate));
+
+  auto systemObjects = chunk.systemObjects.ptr(coordinate.location());
+  if (!systemObjects)
+    return false;
+
+  if (coordinate.isSystem())
+    return true;
+
+  auto planet = systemObjects->ptr(coordinate.planet().orbitNumber());
+  if (!planet)
+    return false;
+
+  if (coordinate.isPlanetaryBody())
+    return true;
+
+  return planet->satelliteParameters.contains(coordinate.orbitNumber());
+}
+
+Maybe<CelestialCoordinate> CelestialMasterDatabase::findRandomWorld(unsigned tries, unsigned trySpatialRange,
+    function<bool(CelestialCoordinate)> filter, Maybe<uint64_t> seed) {
+  RecursiveMutexLocker locker(m_mutex);
+  RandomSource randSource;
+  if (seed)
+    randSource.init(*seed);
+  for (unsigned i = 0; i < tries; ++i) {
+    RectI range = xyRange();
+    Vec2I randomLocation = Vec2I(randSource.randInt(range.xMin(), range.xMax()), randSource.randInt(range.yMin(), range.yMax()));
+    for (auto system : scanSystems(RectI::withCenter(randomLocation, Vec2I::filled(trySpatialRange)))) {
+      if (!hasChildren(system).value(false))
+        continue;
+
+      auto world = randSource.randFrom(children(system));
+      // This sucks, 50% of the time will try and return satellite, not really
+      // balanced probability wise
+      if (hasChildren(world).value(false) && randSource.randb())
+        world = randSource.randFrom(children(world));
+
+      if (!filter || filter(world))
+        return world;
+    }
+  }
+
+  return {};
+}
+
+Maybe<CelestialParameters> CelestialMasterDatabase::parameters(CelestialCoordinate const& coordinate) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  if (!coordinateValid(coordinate))
+    throw CelestialException("CelestialMasterDatabase::parameters called on invalid coordinate");
+
+  auto const& chunk = getChunk(chunkIndexFor(coordinate));
+
+  if (coordinate.isSatelliteBody())
+    return chunk.systemObjects.get(coordinate.location())
+        .get(coordinate.parent().orbitNumber())
+        .satelliteParameters.get(coordinate.orbitNumber());
+
+  if (coordinate.isPlanetaryBody())
+    return chunk.systemObjects.get(coordinate.location()).get(coordinate.orbitNumber()).planetParameters;
+
+  return chunk.systemParameters.get(coordinate.location());
+}
+
+Maybe<String> CelestialMasterDatabase::name(CelestialCoordinate const& coordinate) {
+  return parameters(coordinate)->name();
+}
+
+Maybe<bool> CelestialMasterDatabase::hasChildren(CelestialCoordinate const& coordinate) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  if (!coordinateValid(coordinate))
+    throw CelestialException("CelestialMasterDatabase::hasChildren called on invalid coordinate");
+
+  auto const& systemObjects = getChunk(chunkIndexFor(coordinate)).systemObjects.get(coordinate.location());
+
+  if (coordinate.isSystem())
+    return !systemObjects.empty();
+
+  if (coordinate.isPlanetaryBody())
+    return !systemObjects.get(coordinate.orbitNumber()).satelliteParameters.empty();
+
+  return false;
+}
+
+List<CelestialCoordinate> CelestialMasterDatabase::children(CelestialCoordinate const& coordinate) {
+  return childOrbits(coordinate).transformed(bind(&CelestialCoordinate::child, coordinate, _1));
+}
+
+List<int> CelestialMasterDatabase::childOrbits(CelestialCoordinate const& coordinate) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  if (!coordinateValid(coordinate))
+    throw CelestialException("CelestialMasterDatabase::childOrbits called on invalid coordinate");
+
+  auto const& systemObjects = getChunk(chunkIndexFor(coordinate)).systemObjects.get(coordinate.location());
+
+  if (coordinate.isSystem())
+    return systemObjects.keys();
+
+  if (coordinate.isPlanetaryBody())
+    return systemObjects.get(coordinate.orbitNumber()).satelliteParameters.keys();
+
+  throw CelestialException("CelestialMasterDatabase::childOrbits called on improper type!");
+}
+
+List<CelestialCoordinate> CelestialMasterDatabase::scanSystems(RectI const& region, Maybe<StringSet> const& includedTypes) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  List<CelestialCoordinate> systems;
+  for (auto const& chunkLocation : chunkIndexesFor(region)) {
+    auto const& chunkData = getChunk(chunkLocation);
+    for (auto const& pair : chunkData.systemParameters) {
+      Vec3I systemLocation = pair.first;
+      if (region.contains(systemLocation.vec2())) {
+        if (includedTypes) {
+          String thisType = pair.second.getParameter("typeName", "").toString();
+          if (!includedTypes->contains(thisType))
+            continue;
+        }
+        systems.append(CelestialCoordinate(systemLocation));
+      }
+    }
+  }
+  return systems;
+}
+
+List<pair<Vec2I, Vec2I>> CelestialMasterDatabase::scanConstellationLines(RectI const& region) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  List<pair<Vec2I, Vec2I>> lines;
+  for (auto const& chunkLocation : chunkIndexesFor(region)) {
+    auto const& chunkData = getChunk(chunkLocation);
+    for (auto const& constellation : chunkData.constellations) {
+      for (auto const& line : constellation) {
+        if (region.intersects(Line2I(line.first, line.second)))
+          lines.append(line);
+      }
+    }
+  }
+  return lines;
+}
+
+bool CelestialMasterDatabase::scanRegionFullyLoaded(RectI const&) {
+  return true;
+}
+
+void CelestialMasterDatabase::updateParameters(CelestialCoordinate const& coordinate, CelestialParameters const& parameters) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  if (!coordinateValid(coordinate))
+    throw CelestialException("CelestialMasterDatabase::updateParameters called on invalid coordinate");
+
+  auto chunkIndex = chunkIndexFor(coordinate);
+  auto chunk = getChunk(chunkIndex);
+
+  bool updated = false;
+  if (coordinate.isSatelliteBody()) {
+    chunk.systemObjects.get(coordinate.location())
+        .get(coordinate.parent().orbitNumber())
+        .satelliteParameters.set(coordinate.orbitNumber(), parameters);
+    updated = true;
+  } else if (coordinate.isPlanetaryBody()) {
+    chunk.systemObjects.get(coordinate.location()).get(coordinate.orbitNumber()).planetParameters = parameters;
+    updated = true;
+  }
+
+  if (updated && m_database.isOpen()) {
+    auto versioningDatabase = Root::singleton().versioningDatabase();
+    auto versionedChunk = versioningDatabase->makeCurrentVersionedJson("CelestialChunk", chunk.toJson());
+    m_database.insert(DataStreamBuffer::serialize(chunkIndex), compressData(DataStreamBuffer::serialize<VersionedJson>(versionedChunk)));
+
+    m_chunkCache.remove(chunkIndex);
+  } else {
+    updated = false;
+  }
+
+  if (!updated)
+    throw CelestialException("CelestialMasterDatabase::updateParameters failed; coordinate is not a valid planet or satellite, or celestial database was not open for writing");
+}
+
+Maybe<CelestialOrbitRegion> CelestialMasterDatabase::orbitRegion(
+    List<CelestialOrbitRegion> const& orbitRegions, int planetaryOrbitNumber) {
+  for (auto const& region : orbitRegions) {
+    if (planetaryOrbitNumber >= region.orbitRange[0] && planetaryOrbitNumber <= region.orbitRange[1])
+      return region;
+  }
+  return {};
+}
+
+CelestialChunk const& CelestialMasterDatabase::getChunk(Vec2I const& chunkIndex) {
+  return m_chunkCache.get(chunkIndex, [this](Vec2I const& chunkIndex) -> CelestialChunk {
+      auto versioningDatabase = Root::singleton().versioningDatabase();
+
+      if (m_database.isOpen()) {
+        if (auto chunkData = m_database.find(DataStreamBuffer::serialize(chunkIndex))) {
+          auto versionedChunk = DataStreamBuffer::deserialize<VersionedJson>(uncompressData(chunkData.take()));
+          if (!versioningDatabase->versionedJsonCurrent(versionedChunk)) {
+            versionedChunk = versioningDatabase->updateVersionedJson(versionedChunk);
+            m_database.insert(DataStreamBuffer::serialize(chunkIndex),
+                compressData(DataStreamBuffer::serialize<VersionedJson>(versionedChunk)));
+          }
+          return CelestialChunk(versionedChunk.content);
+        }
+      }
+
+      auto newChunk = produceChunk(chunkIndex);
+      if (m_database.isOpen()) {
+        auto versionedChunk = versioningDatabase->makeCurrentVersionedJson("CelestialChunk", newChunk.toJson());
+        m_database.insert(DataStreamBuffer::serialize(chunkIndex),
+            compressData(DataStreamBuffer::serialize<VersionedJson>(versionedChunk)));
+      }
+
+      return newChunk;
+    });
+}
+
+CelestialChunk CelestialMasterDatabase::produceChunk(Vec2I const& chunkIndex) const {
+  CelestialChunk chunkData;
+  chunkData.chunkIndex = chunkIndex;
+
+  RandomSource random(staticRandomU64(chunkIndex[0], chunkIndex[1], "ChunkIndexMix"));
+
+  RectI region = chunkRegion(chunkIndex);
+  List<Vec3I> systemLocations;
+  for (int x = region.xMin(); x < region.xMax(); ++x) {
+    for (int y = region.yMin(); y < region.yMax(); ++y) {
+      if (random.randf() < m_generationInformation.systemProbability) {
+        auto z = random.randi32() % (m_baseInformation.zCoordRange[1] - m_baseInformation.zCoordRange[0])
+            + m_baseInformation.zCoordRange[0];
+        systemLocations.append(Vec3I(x, y, z));
+      }
+    }
+  }
+
+  List<Vec2I> constellationCandidates;
+  for (auto const& systemLocation : systemLocations) {
+    if (auto systemInformation = produceSystem(random, systemLocation)) {
+      chunkData.systemParameters[systemLocation] = systemInformation.get().first;
+      chunkData.systemObjects[systemLocation] = move(systemInformation.get().second);
+
+      if (systemInformation.get().first.getParameter("magnitude").toFloat()
+          >= m_generationInformation.minimumConstellationMagnitude)
+        constellationCandidates.append(systemLocation.vec2());
+    }
+  }
+
+  chunkData.constellations = produceConstellations(random, constellationCandidates);
+
+  return chunkData;
+}
+
+Maybe<pair<CelestialParameters, HashMap<int, CelestialPlanet>>> CelestialMasterDatabase::produceSystem(
+    RandomSource& random, Vec3I const& location) const {
+  float typeSelector = m_generationInformation.systemTypePerlin.get(location[0], location[1]);
+  String systemTypeName = binnedChoiceFromJson(m_generationInformation.systemTypeBins, typeSelector, "").toString();
+  if (systemTypeName.empty())
+    return {};
+  auto systemType = m_generationInformation.systemTypes.get(systemTypeName);
+
+  CelestialCoordinate systemCoordinate(location);
+  uint64_t systemSeed = random.randu64();
+
+  String prefix = m_generationInformation.systemPrefixNames.select(random);
+  String mid = m_generationInformation.systemNames.select(random);
+  String suffix = m_generationInformation.systemSuffixNames.select(random);
+
+  String systemName = String(strf("%s %s %s", prefix, mid, suffix)).trim();
+
+  systemName = systemName.replace("<onedigit>", strf("%01d", random.randu32() % 10));
+  systemName = systemName.replace("<twodigit>", strf("%02d", random.randu32() % 100));
+  systemName = systemName.replace("<threedigit>", strf("%03d", random.randu32() % 1000));
+  systemName = systemName.replace("<fourdigit>", strf("%04d", random.randu32() % 10000));
+
+  CelestialParameters systemParameters = CelestialParameters(systemCoordinate,
+      systemSeed,
+      systemName,
+      jsonMerge(systemType.baseParameters, random.randValueFrom(systemType.variationParameters)));
+
+  List<int> planetaryOrbits;
+  for (int i = 1; i <= m_baseInformation.planetOrbitalLevels; ++i) {
+    if (auto systemOrbitRegion = orbitRegion(systemType.orbitRegions, i)) {
+      if (random.randf() <= systemOrbitRegion->bodyProbability)
+        planetaryOrbits.append(i);
+    }
+  }
+
+  HashMap<int, CelestialPlanet> systemObjects;
+  for (auto planetPair : enumerateIterator(planetaryOrbits)) {
+    auto systemOrbitRegion = orbitRegion(systemType.orbitRegions, planetPair.first);
+
+    auto planetaryTypeName = systemOrbitRegion->planetaryTypes.select(random);
+    if (m_generationInformation.planetaryTypes.contains(planetaryTypeName)) {
+      auto planetaryType = m_generationInformation.planetaryTypes.get(planetaryTypeName);
+      auto planetaryParameters =
+          jsonMerge(planetaryType.baseParameters, random.randValueFrom(planetaryType.variationParameters));
+
+      CelestialCoordinate planetCoordinate(location, planetPair.first);
+      uint64_t planetarySeed = random.randu64();
+      String planetaryName = strf("%s %s", systemName, m_generationInformation.planetarySuffixes.at(planetPair.second));
+
+      CelestialPlanet planet;
+      planet.planetParameters =
+          CelestialParameters(planetCoordinate, planetarySeed, planetaryName, planetaryParameters);
+
+      List<int> satelliteOrbits;
+      for (int i = 1; i <= m_baseInformation.satelliteOrbitalLevels; ++i) {
+        if (satelliteOrbits.size() < planetaryType.maxSatelliteCount
+            && random.randf() < planetaryType.satelliteProbability)
+          satelliteOrbits.append(i);
+      }
+
+      for (auto satellitePair : enumerateIterator(satelliteOrbits)) {
+        auto satelliteTypeName = systemOrbitRegion->satelliteTypes.select(random);
+        if (m_generationInformation.satelliteTypes.contains(satelliteTypeName)) {
+          auto satelliteType = m_generationInformation.satelliteTypes.get(satelliteTypeName);
+          auto satelliteParameters = jsonMerge(satelliteType.baseParameters,
+              random.randValueFrom(satelliteType.variationParameters),
+              random.randValueFrom(
+                  satelliteType.orbitParameters.value(systemOrbitRegion->regionName, JsonArray()).toArray()));
+
+          CelestialCoordinate satelliteCoordinate(location, planetPair.first, satellitePair.first);
+          uint64_t satelliteSeed = random.randu64();
+          String satelliteName =
+              strf("%s %s", planetaryName, m_generationInformation.satelliteSuffixes.at(satellitePair.second));
+
+          planet.satelliteParameters[satellitePair.first] =
+              CelestialParameters(satelliteCoordinate, satelliteSeed, satelliteName, satelliteParameters);
+        }
+      }
+
+      systemObjects[planetPair.first] = move(planet);
+    }
+  }
+
+  return pair<CelestialParameters, HashMap<int, CelestialPlanet>>{move(systemParameters), move(systemObjects)};
+}
+
+List<CelestialConstellation> CelestialMasterDatabase::produceConstellations(
+    RandomSource& random, List<Vec2I> const& constellationCandidates) const {
+  List<CelestialConstellation> constellations;
+
+  if (random.randf() < m_generationInformation.constellationProbability && constellationCandidates.size() > 2) {
+    unsigned targetConstellationLineCount = random.randUInt(
+        m_generationInformation.constellationLineCountRange[0], m_generationInformation.constellationLineCountRange[1]);
+    Set<Vec2I> constellationPoints;
+    Set<Line2I> constellationLines;
+
+    unsigned tries = 0;
+
+    while (constellationLines.size() < targetConstellationLineCount) {
+      if (++tries > m_generationInformation.constellationMaxTries)
+        break;
+
+      Vec2I start;
+      if (constellationPoints.empty())
+        start = random.randValueFrom(constellationCandidates);
+      else
+        start = random.randValueFrom(constellationPoints);
+
+      Vec2I end = random.randValueFrom(constellationCandidates);
+
+      Line2I proposedLine(start, end);
+      Line2D proposedLineD(proposedLine);
+
+      if (start == end)
+        continue;
+
+      if (constellationLines.contains(proposedLine) || constellationLines.contains(proposedLine.reversed()))
+        continue;
+
+      if (proposedLineD.diff().magnitude() > m_generationInformation.maximumConstellationLineLength)
+        continue;
+
+      if (proposedLineD.diff().magnitude() < m_generationInformation.minimumConstellationLineLength)
+        continue;
+
+      bool valid = true;
+      for (auto const& constellationLine : constellationLines) {
+        Line2D constellationLineD(constellationLine);
+        auto intersection = proposedLineD.intersection(constellationLineD);
+        if (intersection.intersects && Vec2I::round(intersection.point) != proposedLine.min()
+            && Vec2I::round(intersection.point) != proposedLine.max()) {
+          valid = false;
+          break;
+        }
+
+        if (proposedLine.min() != constellationLine.min() && proposedLine.min() != constellationLine.max()
+            && constellationLineD.distanceTo(proposedLineD.min())
+                < m_generationInformation.minimumConstellationLineCloseness) {
+          valid = false;
+          break;
+        }
+
+        if (proposedLine.max() != constellationLine.min() && proposedLine.max() != constellationLine.max()
+            && constellationLineD.distanceTo(proposedLineD.max())
+                < m_generationInformation.minimumConstellationLineCloseness) {
+          valid = false;
+          break;
+        }
+      }
+
+      if (valid) {
+        constellationLines.add(proposedLine);
+        constellationPoints.add(proposedLine.min());
+        constellationPoints.add(proposedLine.max());
+      }
+    }
+
+    if (constellationLines.size() > 1) {
+      CelestialConstellation constellation;
+      for (auto const& line : constellationLines)
+        constellation.append({line.min(), line.max()});
+      constellations.append(constellation);
+    }
+  }
+
+  return constellations;
+}
+
+CelestialSlaveDatabase::CelestialSlaveDatabase(CelestialBaseInformation baseInformation) {
+  auto config = Root::singleton().assets()->json("/celestial.config");
+
+  m_baseInformation = move(baseInformation);
+  m_requestTimeout = config.getFloat("requestTimeout");
+}
+
+void CelestialSlaveDatabase::signalRegion(RectI const& region) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  for (auto location : chunkIndexesFor(region)) {
+    if (!m_chunkCache.ptr(location) && !m_pendingChunkRequests.contains(location))
+      m_pendingChunkRequests[location] = Timer();
+  }
+}
+
+void CelestialSlaveDatabase::signalSystem(CelestialCoordinate const& system) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  if (auto chunk = m_chunkCache.ptr(chunkIndexFor(system))) {
+    if (!chunk->systemObjects.contains(system.location()))
+      m_pendingSystemRequests[system.location()] = Timer();
+  } else {
+    signalRegion(RectI::withSize(system.location().vec2(), {1, 1}));
+  }
+}
+
+List<CelestialRequest> CelestialSlaveDatabase::pullRequests() {
+  RecursiveMutexLocker locker(m_mutex);
+
+  List<CelestialRequest> requests;
+
+  auto chunkIt = makeSMutableMapIterator(m_pendingChunkRequests);
+  while (chunkIt.hasNext()) {
+    auto& pair = chunkIt.next();
+    if (!pair.second.running()) {
+      requests.append(makeLeft(pair.first));
+      pair.second.restart(m_requestTimeout);
+    } else if (pair.second.timeUp()) {
+      chunkIt.remove();
+    }
+  }
+
+  auto systemIt = makeSMutableMapIterator(m_pendingSystemRequests);
+  while (systemIt.hasNext()) {
+    auto& pair = systemIt.next();
+    if (!pair.second.running()) {
+      requests.append(makeRight(pair.first));
+      pair.second.restart(m_requestTimeout);
+    } else if (pair.second.timeUp()) {
+      systemIt.remove();
+    }
+  }
+
+  return requests;
+}
+
+void CelestialSlaveDatabase::pushResponses(List<CelestialResponse> responses) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  for (auto& response : responses) {
+    if (auto celestialChunk = response.leftPtr()) {
+      m_pendingChunkRequests.remove(celestialChunk->chunkIndex);
+      m_chunkCache.set(celestialChunk->chunkIndex, move(*celestialChunk));
+    } else if (auto celestialSystemObjects = response.rightPtr()) {
+      m_pendingSystemRequests.remove(celestialSystemObjects->systemLocation);
+      auto chunkLocation = chunkIndexFor(celestialSystemObjects->systemLocation);
+      if (auto chunk = m_chunkCache.ptr(chunkLocation))
+        chunk->systemObjects[celestialSystemObjects->systemLocation] = move(celestialSystemObjects->planets);
+    }
+  }
+}
+
+void CelestialSlaveDatabase::cleanup() {
+  RecursiveMutexLocker locker(m_mutex);
+  m_chunkCache.cleanup();
+}
+
+Maybe<CelestialParameters> CelestialSlaveDatabase::parameters(CelestialCoordinate const& coordinate) {
+  if (!coordinate)
+    throw CelestialException("CelestialSlaveDatabase::parameters called on null coordinate");
+
+  RecursiveMutexLocker locker(m_mutex);
+
+  if (coordinate.isSystem())
+    signalRegion(RectI::withSize(coordinate.location().vec2(), {1, 1}));
+  else
+    signalSystem(coordinate);
+
+  if (auto chunk = m_chunkCache.ptr(chunkIndexFor(coordinate))) {
+    if (coordinate.isSystem())
+      return chunk->systemParameters.maybe(coordinate.location());
+
+    if (auto systemObjects = chunk->systemObjects.ptr(coordinate.location())) {
+      auto const& planet = systemObjects->get(coordinate.planet().orbitNumber());
+      if (coordinate.isPlanetaryBody())
+        return planet.planetParameters;
+      else if (coordinate.isSatelliteBody())
+        return planet.satelliteParameters.get(coordinate.orbitNumber());
+    }
+  }
+
+  return {};
+}
+
+Maybe<String> CelestialSlaveDatabase::name(CelestialCoordinate const& coordinate) {
+  if (auto p = parameters(coordinate))
+    return p->name();
+  return {};
+}
+
+Maybe<bool> CelestialSlaveDatabase::hasChildren(CelestialCoordinate const& coordinate) {
+  if (!coordinate)
+    throw CelestialException("CelestialSlaveDatabase::hasChildren called on null coordinate");
+
+  RecursiveMutexLocker locker(m_mutex);
+
+  signalSystem(coordinate);
+
+  if (auto chunk = m_chunkCache.ptr(chunkIndexFor(coordinate))) {
+    if (auto systemObjects = chunk->systemObjects.ptr(coordinate.location())) {
+      if (coordinate.isSystem())
+        return !systemObjects->empty();
+      else if (coordinate.isPlanetaryBody())
+        return !systemObjects->get(coordinate.orbitNumber()).satelliteParameters.empty();
+    }
+  }
+
+  return {};
+}
+
+List<CelestialCoordinate> CelestialSlaveDatabase::children(CelestialCoordinate const& coordinate) {
+  return childOrbits(coordinate).transformed(bind(&CelestialCoordinate::child, coordinate, _1));
+}
+
+List<int> CelestialSlaveDatabase::childOrbits(CelestialCoordinate const& coordinate) {
+  if (!coordinate)
+    throw CelestialException("CelestialSlaveDatabase::childOrbits called on null coordinate");
+
+  if (coordinate.isSatelliteBody())
+    throw CelestialException("CelestialSlaveDatabase::childOrbits called on improper type!");
+
+  RecursiveMutexLocker locker(m_mutex);
+
+  signalSystem(coordinate);
+
+  if (auto chunk = m_chunkCache.ptr(chunkIndexFor(coordinate))) {
+    if (auto systemObjects = chunk->systemObjects.ptr(coordinate.location())) {
+      if (coordinate.isSystem())
+        return systemObjects->keys();
+      else if (coordinate.isPlanetaryBody())
+        return systemObjects->get(coordinate.orbitNumber()).satelliteParameters.keys();
+    }
+  }
+
+  return {};
+}
+
+List<CelestialCoordinate> CelestialSlaveDatabase::scanSystems(RectI const& region, Maybe<StringSet> const& includedTypes) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  signalRegion(region);
+
+  List<CelestialCoordinate> systems;
+  for (auto const& chunkLocation : chunkIndexesFor(region)) {
+    if (auto chunkData = m_chunkCache.ptr(chunkLocation)) {
+      for (auto const& pair : chunkData->systemParameters) {
+        Vec3I systemLocation = pair.first;
+        if (region.contains(systemLocation.vec2())) {
+          if (includedTypes) {
+            String thisType = pair.second.getParameter("typeName", "").toString();
+            if (!includedTypes->contains(thisType))
+              continue;
+          }
+          systems.append(CelestialCoordinate(systemLocation));
+        }
+      }
+    }
+  }
+  return systems;
+}
+
+List<pair<Vec2I, Vec2I>> CelestialSlaveDatabase::scanConstellationLines(RectI const& region) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  signalRegion(region);
+
+  List<pair<Vec2I, Vec2I>> lines;
+  for (auto const& chunkLocation : chunkIndexesFor(region)) {
+    if (auto chunkData = m_chunkCache.ptr(chunkLocation)) {
+      for (auto const& constellation : chunkData->constellations) {
+        for (auto const& line : constellation) {
+          if (region.intersects(Line2I(line.first, line.second)))
+            lines.append(line);
+        }
+      }
+    }
+  }
+  return lines;
+}
+
+bool CelestialSlaveDatabase::scanRegionFullyLoaded(RectI const& region) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  signalRegion(region);
+
+  for (auto const& chunkLocation : chunkIndexesFor(region)) {
+    if (!m_chunkCache.ptr(chunkLocation))
+      return false;
+  }
+  return true;
+}
+
+void CelestialSlaveDatabase::invalidateCacheFor(CelestialCoordinate const& coordinate) {
+  RecursiveMutexLocker locker(m_mutex);
+
+  m_chunkCache.remove(chunkIndexFor(coordinate));
+}
+
+}