Method instanceWorldPromise

source/game/StarUniverseServer.cpp:2200–2319

}

Maybe<WorkerPoolPromise<WorldServerThreadPtr>> UniverseServer::instanceWorldPromise(InstanceWorldId const& instanceWorldId) {
  auto storageDirectory = m_storageDirectory;
  auto universeClock = m_universeClock;
  return m_workerPool.addProducer<WorldServerThreadPtr>([this, storageDirectory, instanceWorldId, universeClock]() {
      Json worldConfig = Root::singleton().assets()->json("/instance_worlds.config").get(instanceWorldId.instance);
      uint64_t worldSeed;
      if (worldConfig.contains("seed"))
        worldSeed = worldConfig.getUInt("seed");
      else
        worldSeed = Random::randu64();

      String worldType = worldConfig.getString("type");

      VisitableWorldParametersPtr worldParameters;
      if (worldType.equalsIgnoreCase("Terrestrial"))
        worldParameters = generateTerrestrialWorldParameters(worldConfig.getString("planetType"), worldConfig.getString("planetSize"), worldSeed);
      else if (worldType.equalsIgnoreCase("Asteroids"))
        worldParameters = generateAsteroidsWorldParameters(worldSeed);
      else if (worldType.equalsIgnoreCase("FloatingDungeon"))
        worldParameters = generateFloatingDungeonWorldParameters(worldConfig.getString("dungeonWorld"));
      else
        throw UniverseServerException(strf("Unknown world type: '{}'\n", worldType));

      if (instanceWorldId.level)
        worldParameters->threatLevel = *instanceWorldId.level;

      if (worldConfig.contains("beamUpRule"))
        worldParameters->beamUpRule = BeamUpRuleNames.getLeft(worldConfig.getString("beamUpRule"));
      worldParameters->disableDeathDrops = worldConfig.getBool("disableDeathDrops", false);

      SkyParameters skyParameters = SkyParameters(worldConfig.get("skyParameters", Json()));
      auto worldTemplate = make_shared<WorldTemplate>(worldParameters, skyParameters, worldSeed);
      Json worldProperties = worldConfig.get("worldProperties", JsonObject{});
      bool spawningEnabled = worldConfig.getBool("spawningEnabled", true);
      bool persistent = worldConfig.getBool("persistent", false);
      bool useUniverseClock = worldConfig.getBool("useUniverseClock", false);

      WorldServerPtr worldServer;

      bool worldExisted = false;

      if (persistent) {
        String identifier = instanceWorldId.instance;
        if (instanceWorldId.uuid)
          identifier = strf("{}-{}", identifier, instanceWorldId.uuid->hex());
        if (instanceWorldId.level)
          identifier = strf("{}-{}", identifier, instanceWorldId.level.value());
        String storageFile = File::relativeTo(storageDirectory, strf("unique-{}.world", identifier));
        if (File::isFile(storageFile)) {
          try {
            Logger::info("UniverseServer: Loading persistent unique instance world {}", instanceWorldId.instance);
            worldServer = make_shared<WorldServer>(File::open(storageFile, IOMode::ReadWrite));
            worldExisted = true;
          } catch (std::exception const& e) {
            Logger::error("UniverseServer: Could not load persistent unique instance world {}, removing! Cause: {}",
                instanceWorldId.instance, outputException(e, false));
            File::rename(storageFile, strf("{}.{}.fail", storageFile, Time::millisecondsSinceEpoch()));
          }