1. Place rooms on a 36-stud grid

   Rooms land on random grid cells, and overlaps are rejected with GetPartBoundsInBox. Each room opens one of its four doors at random. The first room is the start; the room farthest from it becomes the boss room.

2. Triangulate the doors

   An incremental Delaunay triangulation (Bowyer–Watson) connects door positions. Points are inserted in x order, so triangles whose circumcircle falls behind the sweep are finished early instead of being re-tested. Coordinates are normalized to a unit square to keep the circle math stable.

3. Filter, then repair connectivity

   Skinny triangles and edges longer than 12 cells are dropped. Union–find tracks which rooms are still connected and reconnects any that were cut off using the shortest discarded edges. Both limits are Studio attributes, so they can be tuned without touching code.

4. Build a spanning tree, then add loops

   Prim's algorithm on a binary min-heap picks the shortest set of connections. Edges that lead back to visited rooms get a 1-in-10 chance to stay, up to 11, so players get loops instead of a strict tree.

5. Carve the corridors

   For each connection, a greedy best-first search walks the grid and spawns hallway blocks. Rooms block the search; touching an existing hallway reuses it, so corridors merge into shared halls.

6. Merge pieces and furnish rooms

   A depth-first walk over the hallway graph merges straight runs of 2–4 blocks into longer prefab halls and 2×2 clusters into large chambers. A room setter then places the shop and assigns ambush, easy, trap and mini-boss rooms from prefab pools.

• Each stack records an item id, a quantity, a stack limit from the item's data, and a stack id.
• Adding items tops up a matching stack first. Anything over the limit spills into new stacks, and whatever can't fit once the stack cap is reached is reported as lost.
• Item ids are validated before anything changes: they must be strings in the 0x… format.
• New players start with four default moves and a starter item. Saving between sessions with DataStores is the next step.

local canAdd = math.min(num, itemData.stackable - foundStack.quantity)
foundStack.quantity += canAdd
overflow -= canAdd

while overflow > 0 do
  if playerInventory.LastStackID + 1 < invServer.MaxStack then
    local stackSize = math.min(overflow, itemData.stackable)
    InventoryServer.MakeStack(player, id, stackSize)
    overflow -= stackSize
  else
    print("Inventory Full. You lost: " .. overflow .. " " .. itemData.name)
    break
  end
end

• Each chest drops 1–3 items, with 1–3 of each.
• For each drop, the randomizer rolls 1–10 and walks the pool, adding up weights until the running total reaches the roll. A weight of 5 out of 10 is a 50% chance.
• Duplicate drops are merged by item id before they're added, so a chest never fills two slots with the same item.

Example pool with weights adding up to 10, and the roll range each one covers:

local function chooseItem()
  local randomNum = math.random(1,10)
  local counter = 0
  for rarity, item in pairs(LootPool) do
    counter += item.weight
    if randomNum <= counter then
      return {name = item.name, description = item.description,
              quantity = math.random(1,3), id = item.id}
    end
  end
end