osb/source/game/StarWorldGeneration.cpp

#include "StarWorldGeneration.hpp"
#include "StarWorldServer.hpp"
#include "StarMaterialItem.hpp"
#include "StarMaterialDatabase.hpp"
#include "StarNpcDatabase.hpp"
#include "StarMonsterDatabase.hpp"
#include "StarNpc.hpp"
#include "StarBiome.hpp"
#include "StarSky.hpp"
#include "StarWorldTemplate.hpp"
#include "StarBiomePlacement.hpp"
#include "StarWireEntity.hpp"
#include "StarItemDrop.hpp"
#include "StarLogging.hpp"
#include "StarRoot.hpp"
#include "StarItemDatabase.hpp"
#include "StarProjectileDatabase.hpp"
#include "StarProjectile.hpp"
#include "StarObjectDatabase.hpp"
#include "StarObject.hpp"
#include "StarContainerObject.hpp"
#include "StarMonster.hpp"
#include "StarEntityMap.hpp"
#include "StarPlant.hpp"
#include "StarLiquidsDatabase.hpp"
#include "StarStagehand.hpp"
#include "StarVehicleDatabase.hpp"

namespace Star {

static int const PlantAdjustmentLimit = 2;

LiquidWorld::LiquidWorld(WorldServer* world) {
  m_worldServer = world;
  auto& root = Root::singleton();
  m_liquidsDatabase = root.liquidsDatabase();
  m_materialDatabase = root.materialDatabase();
}

Vec2I LiquidWorld::uniqueLocation(Vec2I const& location) const {
  return m_worldServer->geometry().xwrap(location);
}

float LiquidWorld::drainLevel(Vec2I const& location) const {
  if (location[1] > m_worldServer->worldTemplate()->undergroundLevel()) {
    auto const& tile = m_worldServer->getServerTile(location);
    if (!m_materialDatabase->blocksLiquidFlow(tile.background)) {
      auto const& belowTile = m_worldServer->getServerTile(location + Vec2I(0, -1));
      if (m_materialDatabase->blocksLiquidFlow(belowTile.background) || m_materialDatabase->blocksLiquidFlow(belowTile.foreground) || belowTile.liquid.source)
        return m_liquidsDatabase->backgroundDrain();
    }
  }
  return 0.0f;
}

CellularLiquidCell<LiquidId> LiquidWorld::cell(Vec2I const& location) const {
  auto const& tile = m_worldServer->getServerTile(location);
  if (m_materialDatabase->blocksLiquidFlow(tile.foreground)) {
    return CellularLiquidCollisionCell();
  } else {
    if (tile.liquid.source)
      return CellularLiquidSourceCell<LiquidId>{tile.liquid.liquid, tile.liquid.pressure};
    else if (tile.liquid.liquid != EmptyLiquidId)
      return CellularLiquidFlowCell<LiquidId>{tile.liquid.liquid, tile.liquid.level, tile.liquid.pressure};
    else
      return CellularLiquidFlowCell<LiquidId>{{}, 0.0f, 0.0f};
  }
}

void LiquidWorld::setFlow(Vec2I const& location, CellularLiquidFlowCell<LiquidId> const& flow) {
  if (flow.liquid) {
    m_worldServer->setLiquid(location, *flow.liquid, flow.level, flow.pressure);

    auto const& tile = m_worldServer->getServerTile(location);
    if (auto materialInteraction = m_materialDatabase->liquidMaterialInteraction(*flow.liquid, tile.background)) {
      if (!materialInteraction->topOnly && tile.liquid.level >= materialInteraction->consumeLiquid) {
        if (auto modifyTile = m_worldServer->modifyServerTile(location)) {
          modifyTile->liquid.take(materialInteraction->consumeLiquid);
          modifyTile->background = materialInteraction->transformTo;
          m_worldServer->activateLiquidLocation(location);
        }
      }
    }
    if (auto modInteraction = m_materialDatabase->liquidModInteraction(*flow.liquid, tile.backgroundMod)) {
      if (!modInteraction->topOnly && tile.liquid.level >= modInteraction->consumeLiquid) {
        if (auto modifyTile = m_worldServer->modifyServerTile(location)) {
          modifyTile->liquid.take(modInteraction->consumeLiquid);
          modifyTile->backgroundMod = modInteraction->transformTo;
          m_worldServer->activateLiquidLocation(location);
        }
      }
    }
  } else {
    m_worldServer->setLiquid(location, EmptyLiquidId, 0.0f, 0.0f);
  }
}

void LiquidWorld::liquidInteraction(Vec2I const& a, LiquidId aLiquid, Vec2I const& b, LiquidId bLiquid) {
  auto handleInteraction = [this](Vec2I const& target, Maybe<LiquidInteractionResult> interaction) {
    if (interaction) {
      if (interaction->isLeft()) {
        m_worldServer->modifyTile(target, PlaceMaterial{TileLayer::Foreground, interaction->left(), 0}, false);
      } else {
        auto liquidLevel = m_worldServer->liquidLevel(target);
        m_worldServer->setLiquid(target, interaction->right(), liquidLevel.level, liquidLevel.level);
      }
    }
  };

  handleInteraction(a, m_liquidsDatabase->interact(aLiquid, bLiquid));
  handleInteraction(b, m_liquidsDatabase->interact(bLiquid, aLiquid));
}

void LiquidWorld::liquidCollision(Vec2I const& liquidPos, LiquidId liquidId, Vec2I const& blockPos) {
  auto const& blockTile = m_worldServer->getServerTile(blockPos);

  if (auto materialInteraction = m_materialDatabase->liquidMaterialInteraction(liquidId, blockTile.foreground)) {
    if ((!materialInteraction->topOnly || liquidPos[1] > blockPos[1]) && m_worldServer->liquidLevel(liquidPos).level >= materialInteraction->consumeLiquid) {
      auto modifyLiquidTile = m_worldServer->modifyServerTile(liquidPos);
      auto modifyBlockTile = m_worldServer->modifyServerTile(blockPos);
      if (modifyLiquidTile && modifyBlockTile) {
        modifyLiquidTile->liquid.take(materialInteraction->consumeLiquid);
        modifyBlockTile->foreground = materialInteraction->transformTo;
        if (!m_materialDatabase->isMultiColor(materialInteraction->transformTo))
          modifyBlockTile->foregroundColorVariant = DefaultMaterialColorVariant;
        m_worldServer->activateLiquidLocation(liquidPos);
      }
    }
  }
  if (auto modInteraction = m_materialDatabase->liquidModInteraction(liquidId, blockTile.foregroundMod)) {
    if ((!modInteraction->topOnly || liquidPos[1] > blockPos[1]) && m_worldServer->liquidLevel(liquidPos).level >= modInteraction->consumeLiquid) {
      auto modifyLiquidTile = m_worldServer->modifyServerTile(liquidPos);
      auto modifyBlockTile = m_worldServer->modifyServerTile(blockPos);
      if (modifyLiquidTile && modifyBlockTile) {
        modifyLiquidTile->liquid.take(modInteraction->consumeLiquid);
        modifyBlockTile->foregroundMod = modInteraction->transformTo;
        m_worldServer->activateLiquidLocation(liquidPos);
      }
    }
  }
}

FallingBlocksWorld::FallingBlocksWorld(WorldServer* w)
  : m_worldServer(w), m_materialDatabase(Root::singleton().materialDatabase()) {}

FallingBlockType FallingBlocksWorld::blockType(Vec2I const& pos) {
  auto const& tile =  m_worldServer->getServerTile(pos, true);
  if (tile.rootSource) {
    return FallingBlockType::Immovable;
  } if (tile.foreground == EmptyMaterialId) {
    if (m_worldServer->tileIsOccupied(pos, TileLayer::Foreground))
      return FallingBlockType::Immovable;
    else
      return FallingBlockType::Open;
  } else if (m_materialDatabase->isCascadingFallingMaterial(tile.foreground)) {
    return FallingBlockType::Cascading;
  } else if (m_materialDatabase->isFallingMaterial(tile.foreground)) {
    return FallingBlockType::Falling;
  } else {
    return FallingBlockType::Immovable;
  }
}

void FallingBlocksWorld::moveBlock(Vec2I const& from, Vec2I const& to) {
  auto fromTile = m_worldServer->modifyServerTile(from, true);
  auto toTile = m_worldServer->modifyServerTile(to, true);
  if (!fromTile || !toTile)
    return;

  if (m_worldServer->isTileProtected(to)) {
    for (auto drop : m_worldServer->destroyBlock(TileLayer::Foreground, from, true, true))
      m_worldServer->addEntity(ItemDrop::createRandomizedDrop(drop, Vec2F(to)));
  } else {
    toTile->foreground = fromTile->foreground;
    toTile->foregroundMod = NoModId;
    toTile->foregroundHueShift = fromTile->foregroundHueShift;
    toTile->foregroundColorVariant = fromTile->foregroundColorVariant;
    toTile->updateCollision(m_materialDatabase->materialCollisionKind(toTile->foreground));

    fromTile->foreground = EmptyMaterialId;
    fromTile->foregroundMod = NoModId;
    fromTile->updateCollision(CollisionKind::None);

    m_worldServer->requestGlobalBreakCheck();
  }
}

DungeonGeneratorWorld::DungeonGeneratorWorld(WorldServer* worldServer, bool markForActivation)
  : m_worldServer(worldServer), m_markForActivation(markForActivation) {}

WorldGeometry DungeonGeneratorWorld::getWorldGeometry() const {
  return m_worldServer->geometry();
}

void DungeonGeneratorWorld::markRegion(RectI const& region) {
  if (!m_markForActivation)
    return;

  Logger::debug("Marking {} as dungeon region", region);

  m_worldServer->signalRegion(region);
  m_worldServer->activateLiquidRegion(region);
}

void DungeonGeneratorWorld::markTerrain(PolyF const& region) {
  if (!m_markForActivation)
    return;

  Logger::debug("Marking poly as dungeon terrain region: {}", region);
  m_worldServer->worldTemplate()->addCustomTerrainRegion(region);
}

void DungeonGeneratorWorld::markSpace(PolyF const& region) {
  if (!m_markForActivation)
    return;

  Logger::debug("Marking poly as dungeon space region: {}", region);
  m_worldServer->worldTemplate()->addCustomSpaceRegion(region);
}

void DungeonGeneratorWorld::setForegroundMaterial(Vec2I const& position, MaterialId material, MaterialHue hueshift, MaterialColorVariant colorVariant) {
  if (ServerTile* tile = m_worldServer->modifyServerTile(position)) {
    m_worldServer->modifyLiquid(position, EmptyLiquidId, 0);
    tile->foreground = material;
    tile->foregroundHueShift = hueshift;
    tile->foregroundColorVariant = colorVariant;
    tile->foregroundMod = NoModId;
    tile->foregroundModHueShift = MaterialHue();
    tile->collision = Root::singleton().materialDatabase()->materialCollisionKind(tile->foreground);
    tile->collisionCacheDirty = true;
  }
}

void DungeonGeneratorWorld::setBackgroundMaterial(Vec2I const& position, MaterialId material, MaterialHue hueshift, MaterialColorVariant colorVariant) {
  if (ServerTile* tile = m_worldServer->modifyServerTile(position)) {
    m_worldServer->modifyLiquid(position, EmptyLiquidId, 0);
    tile->background = material;
    tile->backgroundHueShift = hueshift;
    tile->backgroundColorVariant = colorVariant;
    tile->backgroundMod = NoModId;
    tile->backgroundModHueShift = MaterialHue();
  }
}

void DungeonGeneratorWorld::placeObject(Vec2I const& pos, String const& objectName, Star::Direction direction, Json const& parameters) {
  m_worldServer->signalRegion(RectI::withSize(pos, {1, 1}));

  auto objectDatabase = Root::singleton().objectDatabase();
  if (auto object = objectDatabase->createForPlacement(m_worldServer, objectName, pos, direction, parameters))
    m_worldServer->addEntity(object);
  else
    Logger::warn("Failed to place dungeon object: {} direction: {} position: {}", objectName, (int)direction, pos);
}

void DungeonGeneratorWorld::placeVehicle(Vec2F const& pos, String const& vehicleName, Json const& parameters) {
  m_worldServer->signalRegion(RectI::withSize(Vec2I(pos), {1, 1}));

  auto vehicleDatabase = Root::singleton().vehicleDatabase();
  auto vehicle = vehicleDatabase->create(vehicleName, parameters.opt().value(JsonObject{}).set("persistent", true));
  vehicle->setPosition(pos);
  m_worldServer->addEntity(vehicle);
}

void DungeonGeneratorWorld::placeSurfaceBiomeItems(Vec2I const& pos) {
  List<BiomeItemPlacement> surfaceItems = m_worldServer->worldTemplate()->potentialBiomeItemsAt(pos[0], pos[1]).surfaceBiomeItems;
  placeBiomeItems(pos, surfaceItems);
}

void DungeonGeneratorWorld::placeBiomeTree(Vec2I const& pos) {
  if (auto biome = m_worldServer->worldTemplate()->blockBiome(pos[0], pos[1])) {
    m_worldServer->signalRegion(RectI::withSize(pos, {1, 1}));
    auto seed = m_worldServer->worldTemplate()->seedFor(pos[0], pos[1]);
    if (auto treeVariant = biome->surfacePlaceables.firstTreeType())
      placePlant(Root::singleton().plantDatabase()->createPlant(*treeVariant, seed), pos);
  }
}

// yay, copy paste coding, kyren WILL kill me
void DungeonGeneratorWorld::placePlant(PlantPtr const& plant, Vec2I const& position) {
  if (!plant)
    return;

  auto spaces = plant->spaces();
  auto roots = plant->roots();
  auto const& primaryRoot = plant->primaryRoot();

  auto background = m_worldServer->getServerTile(position).background;
  bool adjustBackground = background == EmptyMaterialId || background == NullMaterialId;

  auto withinAdjustment = [=](Vec2I const& pos) {
    return PlantAdjustmentLimit - std::abs(pos[0]) > 0 && PlantAdjustmentLimit - std::abs(pos[1]) > 0;
  };

  // Bail out if we don't have at least one free space, and root in the primary
  // root position, or if we're in a dungeon region.
  auto primaryTile = m_worldServer->getServerTile(position);
  auto rootTile = m_worldServer->getServerTile(position + primaryRoot);
  if (isConnectableMaterial(primaryTile.foreground) || !isConnectableMaterial(rootTile.foreground))
    return;

  // First bail out if we can't fit anything we're not adjusting
  for (auto space : spaces) {
    Vec2I pspace = space + position;

    if (withinAdjustment(space) && !m_worldServer->atTile<Plant>(pspace).empty())
      return;

    // Bail out if we hit a different plant's root tile, or if we're not in the
    // adjustment space and we hit a non-empty tile.
    auto tile = m_worldServer->getServerTile(pspace);
    if (tile.rootSource || (!withinAdjustment(space) && !(tile.foreground == EmptyMaterialId || tile.foreground == NullMaterialId)))
      return;
  }

  // Check all the roots outside of the adjustment limit
  for (auto root : roots) {
    root += position;
    if (!withinAdjustment(root) && !isConnectableMaterial(m_worldServer->getServerTile(root).foreground))
      return;
  }

  // Clear all the necessary blocks within the adjustment limit
  for (auto space : spaces) {
    if (!withinAdjustment(space))
      continue;

    space += position;
    if (auto tile = m_worldServer->modifyServerTile(space)) {
      if (isConnectableMaterial(tile->foreground))
        *tile = primaryTile;
      if (adjustBackground)
        tile->background = EmptyMaterialId;
      tile->collision = CollisionKind::None;
      tile->collision = Root::singleton().materialDatabase()->materialCollisionKind(tile->foreground);
      tile->collisionCacheDirty = true;
    } else {
      return;
    }
  }

  // Make all the root blocks a real material based on the primary root.
  for (auto root : roots) {
    root += position;
    if (auto tile = m_worldServer->modifyServerTile(root)) {
      if (!isRealMaterial(tile->foreground)) {
        *tile = rootTile;
        tile->collision = Root::singleton().materialDatabase()->materialCollisionKind(tile->foreground);
        tile->collisionCacheDirty = true;
      }
    } else {
      return;
    }
  }

  plant->setTilePosition(position);
  m_worldServer->addEntity(plant);
  return;
}

void DungeonGeneratorWorld::placeBiomeItems(Vec2I const& pos, List<BiomeItemPlacement>& potentialItems) {
  m_worldServer->signalRegion(RectI::withSize(pos, {1, 1}));
  sort(potentialItems);
  for (auto const& placement : potentialItems) {
    auto seed = m_worldServer->worldTemplate()->seedFor(placement.position[0], placement.position[1]);
    if (placement.item.is<GrassVariant>()) {
      auto& grass = placement.item.get<GrassVariant>();
      placePlant(Root::singleton().plantDatabase()->createPlant(grass, seed), placement.position);
    } else if (placement.item.is<BushVariant>()) {
      auto& bush = placement.item.get<BushVariant>();
      placePlant(Root::singleton().plantDatabase()->createPlant(bush, seed), placement.position);
    } else if (placement.item.is<TreePair>()) {
      auto& treePair = placement.item.get<TreePair>();
      TreeVariant treeVariant;
      if (seed % 2 == 0)
        treeVariant = treePair.first;
      else
        treeVariant = treePair.second;

      placePlant(Root::singleton().plantDatabase()->createPlant(treeVariant, seed), placement.position);
    } else if (placement.item.is<ObjectPool>()) {
      auto& objectPool = placement.item.get<ObjectPool>();
      auto direction = seed % 2 ? Direction::Left : Direction::Right;
      auto objectPair = objectPool.select(seed);
      if (auto object = Root::singleton().objectDatabase()->createForPlacement(
              m_worldServer, objectPair.first, placement.position, direction, objectPair.second))
        m_worldServer->addEntity(object);
    } else if (placement.item.is<TreasureBoxSet>()) {
      auto& treasureBoxSet = placement.item.get<TreasureBoxSet>();
      auto direction = seed % 2 ? Direction::Left : Direction::Right;
      if (auto treasureContainer = Root::singleton().treasureDatabase()->createTreasureChest(m_worldServer, treasureBoxSet, placement.position, direction, seed))
        m_worldServer->addEntity(treasureContainer);
    }
  }
}

void DungeonGeneratorWorld::addDrop(Vec2F const& position, ItemDescriptor const& item) {
  m_worldServer->addEntity(ItemDrop::createRandomizedDrop(item, position));
}

void DungeonGeneratorWorld::spawnNpc(Vec2F const& position, Json const& parameters) {
  auto kind = parameters.getString("kind");
  if (kind.equals("npc", String::CaseInsensitive)) {
    auto npcDatabase = Root::singleton().npcDatabase();
    uint64_t seed = parameters.getUInt("seed", Random::randu64());
    String species = parameters.getString("species");
    String typeName = parameters.getString("typeName", "default");
    JsonObject uniqueParameters = parameters.getObject("parameters", {});
    if (!uniqueParameters.contains("persistent"))
      uniqueParameters["persistent"] = true;
    auto npc = npcDatabase->createNpc(npcDatabase->generateNpcVariant(species, typeName, m_worldServer->threatLevel(), seed, uniqueParameters));
    npc->setPosition(position - npc->feetOffset());
    m_worldServer->addEntity(npc);
  } else if (kind.equals("monster", String::CaseInsensitive)) {
    auto monsterDatabase = Root::singleton().monsterDatabase();
    uint64_t seed = parameters.getUInt("seed", Random::randu64());
    String typeName = parameters.getString("typeName");
    JsonObject uniqueParameters = parameters.getObject("parameters", {});
    if (!uniqueParameters.contains("persistent"))
      uniqueParameters["persistent"] = true;
    auto monster = monsterDatabase->createMonster(monsterDatabase->monsterVariant(typeName, seed, uniqueParameters));
    monster->setPosition(position);
    m_worldServer->addEntity(monster);
  } else
    throw StarException(strf("Unknown spawnable kind '{}'", kind));
}

void DungeonGeneratorWorld::spawnStagehand(Vec2F const& position, Json const& definition) {
  auto stagehand = Root::singleton().stagehandDatabase()->createStagehand(definition.getString("type"), definition.get("parameters", Json()));
  stagehand->setPosition(position);
  m_worldServer->addEntity(stagehand);
}

void DungeonGeneratorWorld::setLiquid(Vec2I const& pos, LiquidStore const& liquid) {
  ServerTile* tile = m_worldServer->modifyServerTile(pos);
  starAssert(tile);
  if (tile)
    tile->liquid = liquid;
}

void DungeonGeneratorWorld::setPlayerStart(Vec2F const& startPosition) {
  m_worldServer->setPlayerStart(startPosition);
}

void DungeonGeneratorWorld::connectWireGroup(List<Vec2I> const& wireGroup) {
  List<WireConnection> outbounds;
  List<WireConnection> inbounds;

  for (auto entry : wireGroup) {
    bool found = false;
    Vec2F posf = centerOfTile(entry);
    RectF bounds = {posf - Vec2F(16, 16), posf + Vec2F(16, 16)};
    for (auto entity : m_worldServer->query<WireEntity>(bounds)) {
      for (size_t i = 0; i < entity->nodeCount(WireDirection::Input); ++i) {
        if (entity->tilePosition() + entity->nodePosition({WireDirection::Input, i}) == entry) {
          inbounds.append(WireConnection{entity->tilePosition(), i});
          found = true;
        }
      }
      for (size_t i = 0; i < entity->nodeCount(WireDirection::Output); ++i) {
        if (entity->tilePosition() + entity->nodePosition({WireDirection::Output, i}) == entry) {
          outbounds.append(WireConnection{entity->tilePosition(), i});
          found = true;
        }
      }
    }
    if (!found)
      Logger::warn("Dungeon wire endpoint not found. {}", entry);
  }

  if (!outbounds.size() || !inbounds.size()) {
    Logger::warn("Dungeon wires did not make a circuit.");
    return;
  }

  for (auto outbound : outbounds) {
    auto out = m_worldServer->atTile<WireEntity>(outbound.entityLocation).first();
    for (auto inbound : inbounds) {
      auto in = m_worldServer->atTile<WireEntity>(inbound.entityLocation).first();
      in->addNodeConnection({WireDirection::Input, inbound.nodeIndex}, outbound);
      out->addNodeConnection({WireDirection::Output, outbound.nodeIndex}, inbound);
    }
  }
}

void DungeonGeneratorWorld::setForegroundMod(Vec2I const& position, ModId mod, MaterialHue hueshift) {
  ServerTile* tile = m_worldServer->modifyServerTile(position);
  if (tile) {
    tile->foregroundMod = mod;
    tile->foregroundModHueShift = hueshift;
  }
}

void DungeonGeneratorWorld::setBackgroundMod(Vec2I const& position, ModId mod, MaterialHue hueshift) {
  ServerTile* tile = m_worldServer->modifyServerTile(position);
  if (tile) {
    tile->backgroundMod = mod;
    tile->foregroundModHueShift = hueshift;
  }
}

void DungeonGeneratorWorld::setTileProtection(DungeonId dungeonId, bool isProtected) {
  m_worldServer->setTileProtection(dungeonId, isProtected);
}

bool DungeonGeneratorWorld::checkSolid(Vec2I const& position, TileLayer layer) {
  auto const& tile = m_worldServer->getServerTile(position);
  return tile.material(layer) != EmptyMaterialId && tile.material(layer) != NullMaterialId;
}

bool DungeonGeneratorWorld::checkOpen(Vec2I const& position, TileLayer layer) {
  auto const& tile = m_worldServer->getServerTile(position);
  return tile.material(layer) == EmptyMaterialId || tile.material(layer) == NullMaterialId;
}

bool DungeonGeneratorWorld::checkOceanLiquid(Vec2I const& position) {
  auto const& block = m_worldServer->worldTemplate()->blockInfo(position[0], position[1]);
  return block.oceanLiquid != EmptyLiquidId && position[1] < block.oceanLiquidLevel;
}

DungeonId DungeonGeneratorWorld::getDungeonIdAt(Vec2I const& position) {
  return m_worldServer->getServerTile(position).dungeonId;
}

void DungeonGeneratorWorld::setDungeonIdAt(Vec2I const& position, DungeonId dungeonId) {
  if (auto tile = m_worldServer->modifyServerTile(position))
    tile->dungeonId = dungeonId;
}

void DungeonGeneratorWorld::clearTileEntities(RectI const& bounds, Set<Vec2I> const& positions, bool clearAnchoredObjects) {
  auto entities = m_worldServer->entityQuery(RectF(bounds).padded(1), entityTypeFilter<TileEntity>());
  auto geometry = m_worldServer->geometry();
  entities.filter([positions, geometry, clearAnchoredObjects](EntityPtr entity) {
      auto tileEntity = as<TileEntity>(entity);
      for (auto pos : tileEntity->spaces()) {
        if (positions.contains(geometry.xwrap(pos + tileEntity->tilePosition())))
          return true;
      }
      if (clearAnchoredObjects) {
        for (auto pos : tileEntity->roots()) {
          if (positions.contains(geometry.xwrap(pos + tileEntity->tilePosition())))
            return true;
        }
        if (auto object = as<Object>(entity)) {
          for (auto pos : object->anchorPositions()) {
            if (positions.contains(geometry.xwrap(pos)))
              return true;
          }
        }
      }

      return false;
    });

  for (auto entity : entities)
    m_worldServer->removeEntity(entity->entityId(), false);
}

SpawnerWorld::SpawnerWorld(WorldServer* server)
  : m_worldServer(server) {}

WorldGeometry SpawnerWorld::geometry() const {
  return m_worldServer->geometry();
}

List<RectF> SpawnerWorld::clientWindows() const {
  List<RectF> windows;
  for (auto clientId : m_worldServer->clientIds())
    windows.append(m_worldServer->clientWindow(clientId));
  return windows;
}

bool SpawnerWorld::signalRegion(RectF const& region) const {
  return m_worldServer->signalRegion(RectI::integral(region));
}

CollisionKind SpawnerWorld::collision(Vec2I const& position) const {
  return m_worldServer->getServerTile(position + Vec2I(0, 1)).collision;
}

bool SpawnerWorld::isFreeSpace(RectF const& area) const {
  return !m_worldServer->polyCollision(PolyF(area));
}

bool SpawnerWorld::isBackgroundEmpty(Vec2I const& pos) const {
  return m_worldServer->getServerTile(pos).background == EmptyMaterialId;
}

LiquidLevel SpawnerWorld::liquidLevel(Vec2I const& position) const {
  return m_worldServer->liquidLevel(position);
}

bool SpawnerWorld::spawningProhibited(RectF const& area) const {
  RectI region = RectI::integral(area);

  // Don't spawn the entity if its region overlaps with a dungeon
  for (int x = region.xMin(); x < region.xMax(); ++x) {
    for (int y = region.yMin(); y < region.yMax(); ++y) {
      auto const& tile = m_worldServer->getServerTile({x, y});
      if (tile.collision == CollisionKind::Null || tile.dungeonId != NoDungeonId)
        return true;
    }
  }

  return false;
}

uint64_t SpawnerWorld::spawnSeed() const {
  return m_worldServer->worldTemplate()->worldSeed();
}

SpawnProfile SpawnerWorld::spawnProfile(Vec2F const& position) const {
  Vec2I ipos = Vec2I::floor(position);
  // Block biome, *not* environment biome, includes things like detached
  // biomes.
  if (auto biome = m_worldServer->worldTemplate()->blockBiome(ipos[0], ipos[1])) {
    // Dungeons, including ConstructionDungeonId (player constructed areas)
    // should be immune from spawning.
    auto tile = m_worldServer->getServerTile(ipos);
    if (tile.dungeonId == NoDungeonId)
      return biome->spawnProfile;
  }
  return {};
}

float SpawnerWorld::dayLevel() const {
  return m_worldServer->sky()->dayLevel();
}

float SpawnerWorld::threatLevel() const {
  return m_worldServer->threatLevel();
}

EntityId SpawnerWorld::spawnEntity(EntityPtr entity) const {
  m_worldServer->addEntity(entity);
  return entity->entityId();
}

void SpawnerWorld::despawnEntity(EntityId entityId) {
  m_worldServer->removeEntity(entityId, false);
}

EntityPtr SpawnerWorld::getEntity(EntityId entityId) const {
  return m_worldServer->entity(entityId);
}

WorldGenerator::WorldGenerator(WorldServer* server) : m_worldServer(server) {
  m_microDungeonFactory = make_shared<MicroDungeonFactory>();
}

void WorldGenerator::generateSectorLevel(WorldStorage* worldStorage, Sector const& sector, SectorGenerationLevel generationLevel) {
  if (generationLevel == SectorGenerationLevel::BaseTiles) {
    prepareTiles(worldStorage, sector);
  } else if (generationLevel == SectorGenerationLevel::MicroDungeons) {
    if (!worldStorage->floatingDungeonWorld())
      generateMicroDungeons(worldStorage, sector);
  } else if (generationLevel == SectorGenerationLevel::CaveLiquid) {
    if (!worldStorage->floatingDungeonWorld())
      generateCaveLiquid(worldStorage, sector);
  } else if (generationLevel == SectorGenerationLevel::Finalize) {
    if (!worldStorage->floatingDungeonWorld())
      prepareSector(worldStorage, sector);
    else
      prepareSectorBiomeBlocks(worldStorage, sector);
    m_worldServer->activateLiquidRegion(worldStorage->tileArray()->sectorRegion(sector));
  }
}

void WorldGenerator::sectorLoadLevelChanged(WorldStorage* worldStorage, Sector const& sector, SectorLoadLevel loadLevel) {
  if (loadLevel == SectorLoadLevel::Loaded) {
    if (worldStorage->sectorGenerationLevel(sector) == SectorGenerationLevel::Complete)
      m_worldServer->activateLiquidRegion(worldStorage->tileArray()->sectorRegion(sector));
  }
}

void WorldGenerator::terraformSector(WorldStorage* worldStorage, Sector const& sector) {
  // Logger::info("terraforming sector {}...", sector);
  reapplyBiome(worldStorage, sector);
}

void WorldGenerator::initEntity(WorldStorage*, EntityId entityId, EntityPtr const& entity) {
  entity->init(m_worldServer, entityId, EntityMode::Master);
  if (auto tileEntity = as<TileEntity>(entity))
    m_worldServer->updateTileEntityTiles(tileEntity, false, false);
}

void WorldGenerator::destructEntity(WorldStorage*, EntityPtr const& entity) {
  if (entity->isSlave())
    throw StarException("Cannot destruct slave entity in WorldStorage, something has gone wrong!");
  if (auto tileEntity = as<TileEntity>(entity))
    m_worldServer->updateTileEntityTiles(tileEntity, true, false);
  entity->uninit();
}

bool WorldGenerator::entityKeepAlive(WorldStorage*, EntityPtr const& entity) const {
  return entity->isSlave() || (entity->isMaster() && entity->keepAlive());
}

bool WorldGenerator::entityPersistent(WorldStorage*, EntityPtr const& entity) const {
  return entity->isMaster() && entity->persistent();
}

RpcPromise<Vec2I> WorldGenerator::enqueuePlacement(List<BiomeItemDistribution> distributions, Maybe<DungeonId> id) {
  auto promise = RpcPromise<Vec2I>::createPair();
  m_queuedPlacements.append(QueuedPlacement {
    std::move(distributions),
    id,
    promise.second,
    false,
  });
  return promise.first;
}

void WorldGenerator::replaceBiomeBlocks(ServerTile* tile) {
  if (auto blockBiome = m_worldServer->worldTemplate()->biome(tile->blockBiomeIndex)) {
    if (tile->foreground == BiomeMaterialId) {
      tile->foreground = blockBiome->mainBlock;
      tile->foregroundHueShift = m_worldServer->worldTemplate()->biomeMaterialHueShift(tile->blockBiomeIndex, tile->foreground);
    } else if ((tile->foreground >= Biome1MaterialId) && (tile->foreground <= Biome5MaterialId)) {
      auto& subblocks = blockBiome->subBlocks;
      if (subblocks.size())
        tile->foreground = subblocks[(tile->foreground - Biome1MaterialId) % subblocks.size()];
      else
        tile->foreground = blockBiome->mainBlock;
      tile->foregroundHueShift = m_worldServer->worldTemplate()->biomeMaterialHueShift(tile->blockBiomeIndex, tile->foreground);
    }

    if (tile->background == BiomeMaterialId) {
      tile->background = blockBiome->mainBlock;
      tile->backgroundHueShift =
          m_worldServer->worldTemplate()->biomeMaterialHueShift(tile->blockBiomeIndex, tile->background);
    } else if ((tile->background >= Biome1MaterialId) && (tile->background <= Biome5MaterialId)) {
      auto& subblocks = blockBiome->subBlocks;
      if (subblocks.size())
        tile->background = subblocks[(tile->background - Biome1MaterialId) % subblocks.size()];
      else
        tile->background = blockBiome->mainBlock;
      tile->backgroundHueShift = m_worldServer->worldTemplate()->biomeMaterialHueShift(tile->blockBiomeIndex, tile->background);
    }
  } else {
    if (isBiomeMaterial(tile->foreground)) {
      tile->foreground = EmptyMaterialId;
      tile->foregroundHueShift = 0;
    }
    if (isBiomeMod(tile->foregroundMod)) {
      tile->foregroundMod = NoModId;
      tile->foregroundModHueShift = 0;
    }
    if (isBiomeMaterial(tile->background)) {
      tile->background = EmptyMaterialId;
      tile->backgroundHueShift = 0;
    }
    if (isBiomeMod(tile->backgroundMod)) {
      tile->backgroundMod = NoModId;
      tile->backgroundModHueShift = 0;
    }
  }
}

void WorldGenerator::prepareTiles(WorldStorage* worldStorage, ServerTileSectorArray::Sector const& sector) {
  auto materialDatabase = Root::singleton().materialDatabase();
  auto planet = m_worldServer->worldTemplate();
  // Generate sector.
  auto tileArray = worldStorage->tileArray();
  RectI sectorRegion = tileArray->sectorRegion(sector);
  for (int x = sectorRegion.xMin(); x < sectorRegion.xMax(); ++x) {
    for (int y = sectorRegion.yMin(); y < sectorRegion.yMax(); ++y) {
      Vec2I pos(x, y);
      ServerTile* tile = tileArray->modifyTile(pos);
      starAssert(tile);
      if (!tile)
        continue;

      auto blockInfo = planet->blockInfo(pos[0], pos[1]);

      tile->blockBiomeIndex = blockInfo.blockBiomeIndex;
      tile->environmentBiomeIndex = blockInfo.environmentBiomeIndex;
      tile->biomeTransition = blockInfo.biomeTransition;

      if (tile->foreground == NullMaterialId) {
        tile->foreground = blockInfo.foreground;
        tile->foregroundColorVariant = DefaultMaterialColorVariant;
        tile->foregroundHueShift = planet->biomeMaterialHueShift(tile->blockBiomeIndex, tile->foreground);

        if (materialDatabase->supportsMod(tile->foreground, blockInfo.foregroundMod)) {
          tile->foregroundMod = blockInfo.foregroundMod;
          tile->foregroundModHueShift = planet->biomeModHueShift(tile->blockBiomeIndex, tile->foregroundMod);
        }
      }

      if (tile->background == NullMaterialId) {
        tile->background = blockInfo.background;
        tile->backgroundColorVariant = DefaultMaterialColorVariant;
        tile->backgroundHueShift = planet->biomeMaterialHueShift(tile->blockBiomeIndex, tile->background);

        if (materialDatabase->supportsMod(tile->background, blockInfo.backgroundMod)) {
          tile->backgroundMod = blockInfo.backgroundMod;
          tile->backgroundModHueShift = planet->biomeModHueShift(tile->blockBiomeIndex, tile->backgroundMod);
        }
      }

      if (tile->foreground != EmptyMaterialId) {
        tile->liquid = LiquidStore();
      } else if (blockInfo.oceanLiquid != EmptyLiquidId && pos[1] < blockInfo.oceanLiquidLevel) {
        float pressure = blockInfo.oceanLiquidLevel - pos[1];
        if (tile->background == EmptyMaterialId)
          tile->liquid = LiquidStore::endless(blockInfo.oceanLiquid, pressure);
        else if (blockInfo.encloseLiquids)
          tile->liquid = LiquidStore::filled(blockInfo.oceanLiquid, 1.0f, pressure);
      }
    }
  }
}

void WorldGenerator::generateMicroDungeons(WorldStorage* worldStorage, ServerTileSectorArray::Sector const& sector) {
  auto facade = make_shared<DungeonGeneratorWorld>(m_worldServer, false);

  RectI sectorTiles = worldStorage->tileArray()->sectorRegion(sector);
  RectI bounds = sectorTiles.padded(WorldSectorSize - 1);

  List<pair<BiomeItemPlacement, QueuedPlacement*>> placementQueue;
  for (int x = sectorTiles.xMin(); x < sectorTiles.xMax(); ++x) {
    for (int y = sectorTiles.yMin(); y < sectorTiles.yMax(); ++y) {
      auto potential = m_worldServer->worldTemplate()->potentialBiomeItemsAt(x, y);
      for (auto const& placement : m_worldServer->worldTemplate()->validBiomeItems(x, y, potential))
        placementQueue.append({placement, {}});

      for (auto& p : m_queuedPlacements) {
        WorldTemplate::PotentialBiomeItems queuedItems;
        m_worldServer->worldTemplate()->addPotentialBiomeItems(x, y, queuedItems, p.distributions, BiomePlacementArea::Surface);
        m_worldServer->worldTemplate()->addPotentialBiomeItems(x, y, queuedItems, p.distributions, BiomePlacementArea::Underground);
        for (auto placement : m_worldServer->worldTemplate()->validBiomeItems(x, y, queuedItems))
          placementQueue.append({std::move(placement), &p});
      }
    }
  }

  sort(placementQueue);
  for (auto const& p : placementQueue) {
    auto& placement = p.first;
    auto queued = p.second;
    if (queued && queued->fulfilled)
      continue;

    if (placement.item.is<MicroDungeonNames>()) {
      auto seed = m_worldServer->worldTemplate()->seedFor(placement.position[0], placement.position[1]);
      auto const& dungeonName = staticRandomFrom(placement.item.get<MicroDungeonNames>(), seed);
      Maybe<DungeonId> dungeonId;
      starAssert(!dungeonName.empty());
      if (auto generateResult = m_microDungeonFactory->generate(bounds, dungeonName, placement.position, seed, m_worldServer->threatLevel(), facade)) {
        if (queued) {
          dungeonId = queued->dungeonId;
          queued->promise.fulfill(placement.position);
          queued->fulfilled = true;
        }
        for (auto position : generateResult->second) {
          if (ServerTile* tile = m_worldServer->modifyServerTile(position)) {
            replaceBiomeBlocks(tile);
            tile->dungeonId = dungeonId.value(tile->dungeonId);
          }
        }
      }
    }
  }
  
  m_queuedPlacements = m_queuedPlacements.filtered([&](QueuedPlacement& p) {
      return !p.fulfilled;
    });
}

void WorldGenerator::generateCaveLiquid(WorldStorage* worldStorage, ServerTileSectorArray::Sector const& sector) {
  Set<Vec2I> openNodes = caveLiquidSeeds(worldStorage, sector);

  if (!openNodes.size())
    return;

  auto tileArray = worldStorage->tileArray();

  Vec2I dimensions(tileArray->size());

  auto wrapCoords = [=](Vec2I const& coord) -> Vec2I { return Vec2I{pmod<int>(coord[0], dimensions[0]), coord[1]}; };

  RectI sectorTiles = tileArray->sectorRegion(sector);
  RectI bounds = sectorTiles.padded(Vec2I(WorldSectorSize - 1, WorldSectorSize - 1));

  bounds.min()[1] = clamp<int>(bounds.min()[1], 0, dimensions[1] - 1);
  bounds.max()[1] = clamp<int>(bounds.max()[1], 0, dimensions[1] - 1);

  auto materialDatabase = Root::singleton().materialDatabase();

  auto samplePoint = sectorTiles.center();
  auto blockInfo = m_worldServer->worldTemplate()->blockInfo(samplePoint[0], samplePoint[1]);
  LiquidId fillLiquid = blockInfo.caveLiquid;
  bool fillMicrodungeons = blockInfo.fillMicrodungeons;
  bool encloseLiquids = blockInfo.encloseLiquids;

  Set<Vec2I> badNodes;

  for (int i = bounds.xMin(); i <= bounds.xMax(); i++) {
    badNodes.add({i, bounds.yMin()});
    badNodes.add({i, bounds.yMax()});
  }
  for (int i = bounds.yMin(); i <= bounds.yMax(); i++) {
    badNodes.add({bounds.xMin(), i});
    badNodes.add({bounds.xMax(), i});
  }

  Set<Vec2I> candidateNodes;

  auto propose = [&](Vec2I const& position) {
    if (!bounds.contains(position))
      return;
    if (candidateNodes.contains(position))
      return;
    if (badNodes.contains(position))
      return;
    auto tile = tileArray->tile(wrapCoords(position));
    starAssert(tile.foreground != NullMaterialId);
    if (tile.foreground != EmptyMaterialId) {
      // Not sure why this doesn't poison solid materials, but it does (occasionally) encounter that case
      if (!BlockCollisionSet.contains(materialDatabase->materialCollisionKind(tile.foreground)))
        badNodes.add(position);
      return;
    }
    if ((tile.dungeonId != NoDungeonId && (!fillMicrodungeons || tile.dungeonId != BiomeMicroDungeonId))
        || (!encloseLiquids && tile.background == EmptyMaterialId)
        || (tile.liquid.liquid != fillLiquid && tile.liquid.liquid != EmptyLiquidId)) {
      badNodes.add(position);
      return;
    }
    candidateNodes.add(position);
    openNodes.add(position);
  };

  while (openNodes.size()) {
    auto node = *openNodes.begin();
    openNodes.remove(node);
    propose(node + Vec2I(-1, 0));
    propose(node + Vec2I(1, 0));
    propose(node + Vec2I(0, -1));
  }

  Set<Vec2I> visitedNodes;

  auto poison = [&](Vec2I position) {
    if (!bounds.contains(position))
      return;
    if (visitedNodes.contains(position))
      return;
    visitedNodes.add(position);
    auto tile = tileArray->tile(wrapCoords(position));
    starAssert(tile.foreground != NullMaterialId);
    if (tile.foreground != EmptyMaterialId)
      return;
    badNodes.add(position);
  };

  while (badNodes.size()) {
    auto node = *badNodes.begin();
    badNodes.remove(node);
    candidateNodes.remove(node);
    poison(node + Vec2I(-1, 0));
    poison(node + Vec2I(1, 0));
    poison(node + Vec2I(0, 1)); // upwards, not downwards
  }

  Set<Vec2I> solidSurroundings(candidateNodes);

  auto solids = [&](Vec2I position) {
    auto tile = tileArray->tile(wrapCoords(position));
    starAssert(tile.foreground != NullMaterialId);
    if (tile.foreground != EmptyMaterialId)
      solidSurroundings.add(position);
  };

  for (auto position : candidateNodes) {
    solids(position + Vec2I(1, 0));
    solids(position + Vec2I(-1, 0));
    solids(position + Vec2I(0, 1));
    solids(position + Vec2I(0, -1));
  }

  MaterialId biomeBlock = m_worldServer->worldTemplate()->biome(tileArray->tile(samplePoint).blockBiomeIndex)->mainBlock;
  Map<Vec2I, float> drops = determineLiquidLevel(candidateNodes, solidSurroundings);
  for (auto iter = drops.begin(); iter != drops.end(); ++iter) {
    auto tile = tileArray->modifyTile(wrapCoords(iter->first));
    starAssert(tile);
    if (!tile)
      continue;
    if (iter->second)
      tile->liquid = LiquidStore::filled(fillLiquid, 1.0f, iter->second);
    if (encloseLiquids && tile->background == EmptyMaterialId)
      tile->background = biomeBlock;
  }
}

void WorldGenerator::prepareSector(WorldStorage* worldStorage, ServerTileSectorArray::Sector const& sector) {
  auto materialDatabase = Root::singleton().materialDatabase();
  auto planet = m_worldServer->worldTemplate();
  auto tileArray = worldStorage->tileArray();
  RectI sectorTiles = tileArray->sectorRegion(sector);

  for (int x = sectorTiles.xMin(); x < sectorTiles.xMax(); ++x) {
    for (int y = sectorTiles.yMin(); y < sectorTiles.yMax(); ++y) {
      Vec2I position(x, y);
      ServerTile* tile = tileArray->modifyTile(position);
      starAssert(tile);
      if (!tile)
        continue;
      starAssert(tile->foreground != NullMaterialId);

      if (tile->liquid.source) {
        auto blockInfo = planet->blockInfo(position[0], position[1]);
        // make sure that ocean liquid never exists on tiles without empty
        // background (except in real dungeons)
        if (!isRealDungeon(tile->dungeonId) && tile->background != EmptyMaterialId)
          tile->liquid.source = false;
        // pressurize liquid under the ocean
        if (blockInfo.oceanLiquid != EmptyLiquidId && position[1] < blockInfo.oceanLiquidLevel) {
          float pressure = blockInfo.oceanLiquidLevel - position[1];
          tile->liquid.pressure = pressure;
        }
      }

      if (!isRealMaterial(tile->foreground))
        tile->foregroundColorVariant = DefaultMaterialColorVariant;
      if (!isRealMaterial(tile->background))
        tile->backgroundColorVariant = DefaultMaterialColorVariant;

      replaceBiomeBlocks(tile);
      placeBiomeGrass(worldStorage, tile, position);

      tile->collision = maxCollision(tile->collision, materialDatabase->materialCollisionKind(tile->foreground));
    }
  }

  List<BiomeItemPlacement> placementQueue;
  for (int x = sectorTiles.xMin(); x < sectorTiles.xMax(); ++x) {
    for (int y = sectorTiles.yMin(); y < sectorTiles.yMax(); ++y) {
      auto tile = tileArray->tile(Vec2I(x, y));
      if (tile.dungeonId == NoDungeonId) {
        auto potential = m_worldServer->worldTemplate()->potentialBiomeItemsAt(x, y);
        for (auto const& placement : m_worldServer->worldTemplate()->validBiomeItems(x, y, potential))
          placementQueue.append(placement);
      }
    }
  }

  sort(placementQueue);
  for (auto const& placement : placementQueue) {
    auto seed = m_worldServer->worldTemplate()->seedFor(placement.position[0], placement.position[1]);
    if (placement.item.is<GrassVariant>()) {
      auto& grass = placement.item.get<GrassVariant>();
      placePlant(worldStorage, Root::singleton().plantDatabase()->createPlant(grass, seed), placement.position);
    } else if (placement.item.is<BushVariant>()) {
      auto& bush = placement.item.get<BushVariant>();
      placePlant(worldStorage, Root::singleton().plantDatabase()->createPlant(bush, seed), placement.position);
    } else if (placement.item.is<TreePair>()) {
      auto& treePair = placement.item.get<TreePair>();
      TreeVariant treeVariant;
      if (seed % 2 == 0)
        treeVariant = treePair.first;
      else
        treeVariant = treePair.second;

      placePlant(worldStorage, Root::singleton().plantDatabase()->createPlant(treeVariant, seed), placement.position);
    } else if (placement.item.is<ObjectPool>()) {
      auto& objectPool = placement.item.get<ObjectPool>();
      auto direction = seed % 2 ? Direction::Left : Direction::Right;
      auto objectPair = objectPool.select(seed);
      if (auto object = Root::singleton().objectDatabase()->createForPlacement(
              m_worldServer, objectPair.first, placement.position, direction, objectPair.second))
        m_worldServer->addEntity(object);
    } else if (placement.item.is<TreasureBoxSet>()) {
      auto& treasureBoxSet = placement.item.get<TreasureBoxSet>();
      auto direction = seed % 2 ? Direction::Left : Direction::Right;
      if (auto treasureContainer = Root::singleton().treasureDatabase()->createTreasureChest(
              m_worldServer, treasureBoxSet, placement.position, direction, seed))
        m_worldServer->addEntity(treasureContainer);
    }
  }

  for (int x = sectorTiles.xMin(); x < sectorTiles.xMax(); ++x) {
    for (int y = sectorTiles.yMin(); y < sectorTiles.yMax(); ++y) {
      if (auto* tile = worldStorage->tileArray()->modifyTile({x, y}))
        tile->collisionCacheDirty = true;
    }
  }
}

void WorldGenerator::prepareSectorBiomeBlocks(WorldStorage* worldStorage, ServerTileSectorArray::Sector const& sector) {
  auto tileArray = worldStorage->tileArray();
  auto materialDatabase = Root::singleton().materialDatabase();
  RectI sectorTiles = tileArray->sectorRegion(sector);

  for (int x = sectorTiles.xMin(); x < sectorTiles.xMax(); ++x) {
    for (int y = sectorTiles.yMin(); y < sectorTiles.yMax(); ++y) {
      Vec2I position(x, y);
      ServerTile* tile = tileArray->modifyTile(position);

      replaceBiomeBlocks(tile);
      placeBiomeGrass(worldStorage, tile, position);

      tile->collision = maxCollision(tile->collision, materialDatabase->materialCollisionKind(tile->foreground));
    }
  }
}

void WorldGenerator::placeBiomeGrass(WorldStorage* worldStorage, ServerTile* tile, Vec2I const& position) {
  if (auto blockBiome = m_worldServer->worldTemplate()->biome(tile->blockBiomeIndex)) {
    // determine layer for grass mod calculation
    TileLayer modLayer = tile->foreground != EmptyMaterialId ? TileLayer::Foreground : TileLayer::Background;

    // don't place mods in dungeons unless explicitly specified, also don't
    // touch non-grass mods
    if (tile->mod(modLayer) == BiomeModId || tile->mod(modLayer) == UndergroundBiomeModId
        || (tile->dungeonId == NoDungeonId && tile->mod(modLayer) == NoModId)) {
      // check whether we're floor or ceiling
      auto tileAbove = worldStorage->tileArray()->tile(position + Vec2I(0, 1));
      auto tileBelow = worldStorage->tileArray()->tile(position + Vec2I(0, -1));
      bool isFloor = (tile->foreground != EmptyMaterialId && tileAbove.foreground == EmptyMaterialId) || (tile->background != EmptyMaterialId && tileAbove.background == EmptyMaterialId);
      bool isCeiling = !isFloor && ((tile->foreground != EmptyMaterialId && tileBelow.foreground == EmptyMaterialId) || (tile->background != EmptyMaterialId && tileBelow.background == EmptyMaterialId));

      // get the appropriate placeables for above/below ground
      BiomePlaceables const* placeables;
      if ((isFloor && tileAbove.background != EmptyMaterialId) || (isCeiling && tileBelow.background != EmptyMaterialId))
        placeables = &blockBiome->undergroundPlaceables;
      else
        placeables = &blockBiome->surfacePlaceables;

      // determine the proper grass mod or lack thereof
      ModId grassModId = NoModId;
      if (isFloor) {
        auto grassChance = staticRandomFloat(m_worldServer->worldTemplate()->worldSeed(), position[0], position[1]);
        if (isRealMod(placeables->grassMod) && grassChance <= placeables->grassModDensity)
          grassModId = placeables->grassMod;
      } else if (isCeiling) {
        auto grassChance = staticRandomFloat(m_worldServer->worldTemplate()->worldSeed(), position[0], position[1]);
        if (isRealMod(placeables->ceilingGrassMod) && grassChance <= placeables->ceilingGrassModDensity)
          grassModId = placeables->ceilingGrassMod;
      }

      // set the selected grass mod
      if (modLayer == TileLayer::Foreground) {
        tile->foregroundMod = grassModId;
        tile->backgroundMod = NoModId;
      } else {
        tile->foregroundMod = NoModId;
        tile->backgroundMod = grassModId;
      }
    }

    // update hue shifts appropriately
    tile->foregroundModHueShift = m_worldServer->worldTemplate()->biomeModHueShift(tile->blockBiomeIndex, tile->foregroundMod);
    tile->backgroundModHueShift = m_worldServer->worldTemplate()->biomeModHueShift(tile->blockBiomeIndex, tile->backgroundMod);
  }
}

void WorldGenerator::reapplyBiome(WorldStorage* worldStorage, ServerTileSectorArray::Sector const& sector) {
  auto materialDatabase = Root::singleton().materialDatabase();
  auto planet = m_worldServer->worldTemplate();
  auto tileArray = worldStorage->tileArray();
  RectI sectorTiles = tileArray->sectorRegion(sector);

  // Logger::info("Reapplying biome in sector {}...", sectorTiles);

  auto entities = m_worldServer->entityQuery(RectF(sectorTiles.padded(1)));
  List<TileEntityPtr> biomeTileEntities;
  for (auto entity : entities) {
    if (auto plant = as<Plant>(entity)) {
      biomeTileEntities.append(as<TileEntity>(entity));
    } else if (auto object = as<Object>(entity)) {
      if (object->biomePlaced())
        biomeTileEntities.append(as<TileEntity>(entity));
    }
  }

  List<Vec2I> biomeItemTiles;

  for (int x = sectorTiles.xMin(); x < sectorTiles.xMax(); ++x) {
    for (int y = sectorTiles.yMin(); y < sectorTiles.yMax(); ++y) {
      Vec2I position(x, y);
      ServerTile* tile = m_worldServer->modifyServerTile(position);
      starAssert(tile);
      if (!tile)
        continue;

      auto blockInfo = planet->blockBiomeInfo(position[0], position[1]);
      if (blockInfo.blockBiomeIndex != tile->blockBiomeIndex) {
        auto newBiome = planet->biome(blockInfo.blockBiomeIndex);
        auto oldBiome = planet->biome(tile->blockBiomeIndex);

        biomeTileEntities.filter([&, position](TileEntityPtr tileEntity) {
            if (tileEntity->tilePosition() == position) {
              m_worldServer->removeEntity(tileEntity->entityId(), false);
              return false;
            }
            return true;
          });

        // update biome index
        tile->blockBiomeIndex = blockInfo.blockBiomeIndex;
        tile->environmentBiomeIndex = blockInfo.environmentBiomeIndex;
        tile->biomeTransition = true;

        // replace biome blocks
        if (tile->foreground == oldBiome->mainBlock || oldBiome->subBlocks.contains(tile->foreground)) {
          tile->foreground = blockInfo.foreground;
          tile->foregroundColorVariant = DefaultMaterialColorVariant;
          if (tile->foreground == newBiome->mainBlock)
            tile->foregroundHueShift = newBiome->materialHueShift;
        }

        if (tile->background == oldBiome->mainBlock || oldBiome->subBlocks.contains(tile->background)) {
          tile->background = blockInfo.background;
          tile->backgroundColorVariant = DefaultMaterialColorVariant;
          if (tile->background == newBiome->mainBlock)
            tile->backgroundHueShift = newBiome->materialHueShift;
        }

        if (tile->foreground != EmptyMaterialId || tile->background != EmptyMaterialId) {
          // remove old biome mods
          if (tile->foregroundMod == oldBiome->surfacePlaceables.grassMod || tile->foregroundMod == oldBiome->surfacePlaceables.ceilingGrassMod ||
              tile->foregroundMod == oldBiome->undergroundPlaceables.grassMod || tile->foregroundMod == oldBiome->undergroundPlaceables.ceilingGrassMod) {

            tile->foregroundMod = NoModId;
            tile->foregroundModHueShift = 0;
          }

          if (tile->backgroundMod == oldBiome->surfacePlaceables.grassMod || tile->backgroundMod == oldBiome->surfacePlaceables.ceilingGrassMod ||
              tile->backgroundMod == oldBiome->undergroundPlaceables.grassMod || tile->backgroundMod == oldBiome->undergroundPlaceables.ceilingGrassMod) {

            tile->backgroundMod = NoModId;
            tile->backgroundModHueShift = 0;
          }

          // apply new biome mods
          TileLayer modLayer = tile->foreground != EmptyMaterialId ? TileLayer::Foreground : TileLayer::Background;

          if (tile->mod(modLayer) == NoModId) {
            // check whether we're floor or ceiling
            auto tileAbove = worldStorage->tileArray()->tile(position + Vec2I(0, 1));
            auto tileBelow = worldStorage->tileArray()->tile(position + Vec2I(0, -1));
            bool isFloor = tile->foreground != EmptyMaterialId && tileAbove.foreground == EmptyMaterialId;
            bool isCeiling = !isFloor && tile->foreground != EmptyMaterialId && tileBelow.foreground == EmptyMaterialId;
            bool isModFloor, isModCeiling;
            if (modLayer == TileLayer::Foreground) {
              isModFloor = isFloor;
              isModCeiling = isCeiling;
            } else {
              isModFloor = tile->background != EmptyMaterialId && tileAbove.background == EmptyMaterialId;
              isModCeiling = !isModFloor && tile->background != EmptyMaterialId && tileBelow.background == EmptyMaterialId;
            }

            // get the appropriate placeables for above/below ground
            BiomePlaceables const* placeables;
            if ((isFloor && tileAbove.background != EmptyMaterialId) || (isCeiling && tileBelow.background != EmptyMaterialId))
              placeables = &newBiome->undergroundPlaceables;
            else
              placeables = &newBiome->surfacePlaceables;

            // determine the proper grass mod or lack thereof
            ModId grassModId = NoModId;
            if (isModFloor) {
              auto grassChance = staticRandomFloat(m_worldServer->worldTemplate()->worldSeed(), position[0], position[1]);
              if (isRealMod(placeables->grassMod) && grassChance <= placeables->grassModDensity)
                grassModId = placeables->grassMod;
            } else if (isModCeiling) {
              auto grassChance = staticRandomFloat(m_worldServer->worldTemplate()->worldSeed(), position[0], position[1]);
              if (isRealMod(placeables->ceilingGrassMod) && grassChance <= placeables->ceilingGrassModDensity)
                grassModId = placeables->ceilingGrassMod;
            }

            // set the selected grass mod
            if (modLayer == TileLayer::Foreground && materialDatabase->supportsMod(tile->foreground, grassModId)) {
              tile->foregroundMod = grassModId;
              tile->backgroundMod = NoModId;
            } else if (modLayer == TileLayer::Background && materialDatabase->supportsMod(tile->background, grassModId)) {
              tile->foregroundMod = NoModId;
              tile->backgroundMod = grassModId;
            }
          }
        } else {
          tile->foregroundMod = NoModId;
          tile->backgroundMod = NoModId;
        }

        tile->collision = maxCollision(tile->collision, materialDatabase->materialCollisionKind(tile->foreground));
      }

      if (tile->biomeTransition && !blockInfo.biomeTransition) {
        tile->biomeTransition = false;
        if (!isSolidColliding(tile->collision))
          biomeItemTiles.append(position);
      }
    }
  }

  auto simplePlacePlant = [&](PlantPtr const& plant, Vec2I const& position) {
      if (!plant)
        return false;

      auto spaces = plant->spaces();
      auto roots = plant->roots();
      auto const& primaryRoot = plant->primaryRoot();

      auto blockBiome = planet->worldLayout()->getBiome(worldStorage->tileArray()->tile(position).blockBiomeIndex);

      auto positionValid = [&](Vec2I const& pos) {
          auto primaryTile = worldStorage->tileArray()->tile(pos);
          auto primaryRootTile = worldStorage->tileArray()->tile(pos + primaryRoot);
          if (isConnectableMaterial(primaryTile.foreground) || !isConnectableMaterial(primaryRootTile.foreground))
            return false;

          for (auto root : roots) {
            auto rootTile = worldStorage->tileArray()->tile(root + pos);
            if (!isConnectableMaterial(rootTile.foreground) || rootTile.blockBiomeIndex != primaryTile.blockBiomeIndex ||
                (rootTile.foreground != blockBiome->mainBlock && !blockBiome->subBlocks.contains(rootTile.foreground)))
              return false;
          }

          for (auto space : spaces) {
            Vec2I pspace = space + pos;

            if (!m_worldServer->atTile<TileEntity>(pspace).empty())
              return false;

            auto tile = worldStorage->tileArray()->tile(pspace);
            if (tile.foreground != EmptyMaterialId)
              return false;
          }

          return true;
        };

      List<Vec2I> tryPositions = {
          position,
          position + Vec2I{-1, 0},
          position + Vec2I{1, 0},
          position + Vec2I{-2, 0},
          position + Vec2I{2, 0},
          position + Vec2I{-1, 1},
          position + Vec2I{-1, -1},
          position + Vec2I{1, 1},
          position + Vec2I{1, -1}
        };

      for (auto pos : tryPositions) {
        if (positionValid(pos)) {
          plant->setTilePosition(pos);
          m_worldServer->addEntity(plant);
          return true;
        }
      }

      return false;
    };

  auto placeBiomeItem = [&](BiomeItemPlacement biomeItemPlacement, Vec2I position) {
      auto seed = m_worldServer->worldTemplate()->seedFor(position[0], position[1]);
      if (biomeItemPlacement.item.is<GrassVariant>()) {
        auto& grass = biomeItemPlacement.item.get<GrassVariant>();
        simplePlacePlant(Root::singleton().plantDatabase()->createPlant(grass, seed), position);
      } else if (biomeItemPlacement.item.is<BushVariant>()) {
        auto& bush = biomeItemPlacement.item.get<BushVariant>();
        simplePlacePlant(Root::singleton().plantDatabase()->createPlant(bush, seed), position);
      } else if (biomeItemPlacement.item.is<TreePair>()) {
        auto& treePair = biomeItemPlacement.item.get<TreePair>();
        TreeVariant treeVariant;
        if (seed % 2 == 0)
          treeVariant = treePair.first;
        else
          treeVariant = treePair.second;

        simplePlacePlant(Root::singleton().plantDatabase()->createPlant(treeVariant, seed), position);
      } else if (biomeItemPlacement.item.is<ObjectPool>()) {
        auto& objectPool = biomeItemPlacement.item.get<ObjectPool>();
        auto direction = seed % 2 ? Direction::Left : Direction::Right;
        auto objectPair = objectPool.select(seed);
        if (auto object = Root::singleton().objectDatabase()->createForPlacement(m_worldServer, objectPair.first, position, direction, objectPair.second)) {
          if (object->biomePlaced())
            m_worldServer->addEntity(object);
        }
      }
    };

  for (auto position : biomeItemTiles) {
    ServerTile* tile = m_worldServer->modifyServerTile(position);

    auto blockBiome = planet->worldLayout()->getBiome(tile->blockBiomeIndex);
    auto tileAbove = m_worldServer->getServerTile(position + Vec2I{0, 1});
    auto tileBelow = m_worldServer->getServerTile(position + Vec2I{0, -1});

    if (tile->background != EmptyMaterialId) {
      for (auto const& itemDistribution : blockBiome->undergroundPlaceables.itemDistributions) {
        if (itemDistribution.mode() == BiomePlacementMode::Background) {
          if (auto itemToPlace = itemDistribution.itemToPlace(position[0], position[1]))
            placeBiomeItem(*itemToPlace, position);
        }
      }

      if (isSolidColliding(tileAbove.collision)) {
        for (auto const& itemDistribution : blockBiome->undergroundPlaceables.itemDistributions) {
          if (itemDistribution.mode() == BiomePlacementMode::Ceiling) {
            if (auto itemToPlace = itemDistribution.itemToPlace(position[0], position[1]))
              placeBiomeItem(*itemToPlace, position);
          }
        }
      }

      if (isSolidColliding(tileBelow.collision)) {
        for (auto const& itemDistribution : blockBiome->undergroundPlaceables.itemDistributions) {
          if (itemDistribution.mode() == BiomePlacementMode::Floor) {
            if (auto itemToPlace = itemDistribution.itemToPlace(position[0], position[1]))
              placeBiomeItem(*itemToPlace, position);
          }
        }
      }
    } else {
      if (isSolidColliding(tileBelow.collision)) {
        for (auto const& itemDistribution : blockBiome->surfacePlaceables.itemDistributions) {
          if (itemDistribution.mode() == BiomePlacementMode::Floor) {
            if (auto itemToPlace = itemDistribution.itemToPlace(position[0], position[1]))
              placeBiomeItem(*itemToPlace, position);
          }
        }
      }
    }
  }
}

Set<Vec2I> WorldGenerator::caveLiquidSeeds(WorldStorage* worldStorage, ServerTileSectorArray::Sector const& sector) {
  RectI sectorTiles = worldStorage->tileArray()->sectorRegion(sector);
  auto samplePoint = sectorTiles.center();
  auto blockInfo = m_worldServer->worldTemplate()->blockInfo(samplePoint[0], samplePoint[1]);
  float seedDensity = blockInfo.caveLiquidSeedDensity;
  Set<Vec2I> nodes;
  if (seedDensity > 0) {
    int frequency = int(100 / seedDensity);
    for (int y = frequency * floor(sectorTiles.min()[1] / frequency); y < sectorTiles.max()[1]; y += frequency) {
      for (int x = frequency * floor(sectorTiles.min()[0] / frequency); x < sectorTiles.max()[0]; x += frequency) {
        if (sectorTiles.contains(Vec2I(x, y)))
          nodes.add(Vec2I(x, y));
      }
    }
  }
  return nodes;
}

Map<Vec2I, float> WorldGenerator::determineLiquidLevel(Set<Vec2I> const& spots, Set<Vec2I> const& filled) {
  Set<Vec2I> openSet(spots);
  Map<Vec2I, float> results;

  auto geometry = m_worldServer->geometry();

  while (openSet.size() > 0) {
    Set<Vec2I> cluster;
    Set<Vec2I> openCluster;
    openCluster.add(*(openSet.begin()));
    while (openCluster.size() > 0) {
      Vec2I node = *(openCluster.begin());
      openCluster.remove(node);
      if (openSet.contains(node)) {
        openSet.remove(node);
        cluster.add(node);
        openCluster.add(geometry.xwrap(Vec2I(node.x(), node.y() + 1)));
        openCluster.add(geometry.xwrap(Vec2I(node.x(), node.y() - 1)));
        openCluster.add(geometry.xwrap(Vec2I(node.x() + 1, node.y())));
        openCluster.add(geometry.xwrap(Vec2I(node.x() - 1, node.y())));
      }
    }
    levelCluster(cluster, filled, results);
  }
  return results;
}

void WorldGenerator::levelCluster(Set<Vec2I>& cluster, Set<Vec2I> const& filled, Map<Vec2I, float>& results) {
  int maxY = std::numeric_limits<int>::min();
  int minY = std::numeric_limits<int>::max();
  for (auto iter = cluster.begin(); iter != cluster.end(); iter++) {
    auto droplet = (*iter);
    if (filled.contains(droplet + Vec2I(1, 0)) && filled.contains(droplet + Vec2I(-1, 0))
        && filled.contains(droplet + Vec2I(0, -1))) {
      if (droplet.y() > maxY)
        maxY = droplet.y();
      if (!filled.contains(droplet + Vec2I(0, 1))) {
        if (droplet.y() <= minY)
          minY = droplet.y();
      }
    } else {
      if (droplet.y() <= minY)
        minY = droplet.y() - 1;
    }
  }
  int liquidLevel = std::min(maxY, minY);
  for (auto iter = cluster.begin(); iter != cluster.end(); iter++) {
    int pressure = (liquidLevel - (*iter).y());
    if (pressure >= 0)
      results[*iter] = 1.0f + pressure;
  }
}

bool WorldGenerator::placePlant(WorldStorage* worldStorage, PlantPtr const& plant, Vec2I const& position) {
  if (!plant)
    return false;

  auto spaces = plant->spaces();
  auto roots = plant->roots();
  auto const& primaryRoot = plant->primaryRoot();

  auto background = m_worldServer->getServerTile(position).background;
  bool adjustBackground = background == EmptyMaterialId || background == NullMaterialId;

  auto withinAdjustment = [=](Vec2I const& pos) {
    return PlantAdjustmentLimit - std::abs(pos[0]) > 0 && PlantAdjustmentLimit - std::abs(pos[1]) > 0;
  };

  // Bail out if we don't have at least one free space, and root in the primary
  // root position, or if we're in a dungeon region.
  auto primaryTile = worldStorage->tileArray()->tile(position);
  auto rootTile = worldStorage->tileArray()->tile(position + primaryRoot);
  if (primaryTile.dungeonId != NoDungeonId || rootTile.dungeonId != NoDungeonId)
    return false;
  if (isConnectableMaterial(primaryTile.foreground) || !isConnectableMaterial(rootTile.foreground))
    return false;

  // First bail out if we can't fit anything we're not adjusting
  for (auto space : spaces) {
    Vec2I pspace = space + position;

    if (withinAdjustment(space) && !m_worldServer->atTile<Plant>(pspace).empty())
      return false;

    // Bail out if we hit a different plant's root tile, or if we're not in the
    // adjustment space and we hit a non-empty tile.
    auto tile = worldStorage->tileArray()->tile(pspace);
    if (tile.rootSource || (!withinAdjustment(space) && tile.foreground != EmptyMaterialId))
      return false;
  }

  // Check all the roots outside of the adjustment limit
  for (auto root : roots) {
    root += position;
    if (!withinAdjustment(root) && !isConnectableMaterial(worldStorage->tileArray()->tile(root).foreground))
      return false;
  }

  // Clear all the necessary blocks within the adjustment limit
  for (auto space : spaces) {
    if (!withinAdjustment(space))
      continue;

    space += position;
    if (auto tile = worldStorage->tileArray()->modifyTile(space)) {
      if (isConnectableMaterial(tile->foreground))
        *tile = primaryTile;
      if (adjustBackground)
        tile->background = EmptyMaterialId;
      tile->collision = CollisionKind::None;
      tile->collisionCacheDirty = true;
    } else {
      return false;
    }
  }

  // Make all the root blocks a real material based on the primary root.
  for (auto root : roots) {
    root += position;
    if (auto tile = worldStorage->tileArray()->modifyTile(root)) {
      if (!isRealMaterial(tile->foreground)) {
        *tile = rootTile;
        tile->collision = Root::singleton().materialDatabase()->materialCollisionKind(tile->foreground);
        tile->collisionCacheDirty = true;
      }
    } else {
      return false;
    }
  }

  plant->setTilePosition(position);
  m_worldServer->addEntity(plant);
  return true;
}

}