I was originally going to message you privately, but I decided to place this here in case anyone else was interested.
The generation can be broken down into 2 main steps
- Repeatedly generate rooms until the desired room count is met
- Once the number of rooms is met, seal off any empty door ways.
But I’m getting ahead of myself. The generation uses a set of pre made rooms, which are stored in server storage. In the image below, you can see all the room’s I’m currently using.
Each room can have it’s own shape, name, design, colour, lighting - however, to ensure they all connect together correctly, they must all share the same doorway.
Therefore, I made the following two pieces:
A “node” to connect two rooms together.
And the doorway itself.
Then, looking at each room, we can see these standardised doors and connection points.
Now for the scripting, I’ll do this in semi-pseudocode because the original is pretty messy.
The file structure looks something like this, the Util module is just to prevent the main script from becoming clogged with too many functions. In my version, both scripts were modules, and a different “main” script would call the generate function, but here I’ve opted to do it with a normal script instead - this thing is up to you really.
--=== MAIN SCRIPT INSIDE SERVERSCRIPTSERVICE ==---
local ServerStorage = game:GetService("ServerStorage")
local Util = require(script.Util) -- a module for storing functions about room generation
function generate_map(room_count)
--// Delete the current map if there is one
if workspace:FindFirstChild("Map") then
workspace.Map:Destroy()
end
workspace.Terrain:Clear() -- this is to remove the water
--// Create a new map
local map_folder = Instance.new("Folder", workspace)
map_folder.Name = "Map"
-- Create the map data
local current_map = { -- a table which stores all the data relevant to the map generation process
rooms = {}, -- a list of all the currently spawned in rooms
available_nodes = {}, -- a list of all the nodes which can be connected to
}
-- Create the starting room (safe room thingy)
Util.CreateBase(current_map)
-- Repeatedly generate rooms until the room count is met
while #current_map.rooms ~= room_count do
Util.AttemptRoomCreation(current_map)
end
-- Seal of all the still open doorways
while #current_map.available_nodes > 0 do
Util.SealNode(current_map, current_map.available_nodes[1])
end
print("GENERATION FINISHED")
return current_map
end
So that main loop is pretty simple, the tricky part is the generate room method and the seal node method. Below is the util module with practically nothing in it.
-- SERVICES
local ServerStorage = game:GetService("ServerStorage")
-- Assets
local rooms_folder = ServerStorage.Assets.CompletedRooms
local cap = ServerStorage.Assets.Cap -- for sealing empty doors
-- MODULE
local util = {}
return util
To begin, I’ll add the create base function.
function util.CreateBase(current_map)
local base = rooms_folder.Base:Clone() -- create a copy
base.Parent = workspace.Map
base:PivotTo(CFrame.new(Vector3.new(0,50,0))) -- this is just some set position for the main room to start in
table.insert(current_map.rooms, base) -- now we add it to the table, so the map knows we've added a room
-- CRUCIAL: We need to add all of this rooms available nodes to the available nodes table
end
This is a good time to talk about how nodes are stored in a room model. I just have a folder called nodes which holds all the nodes in that room.
Next, I’ll make a generic function which will do the following:
- given a room
- get all of its available nodes
- add to the available nodes list
-- note, this isn't using util.add_nodes()
function add_nodes(map, room)
for _, node in pairs(room.Nodes:GetChildren()) do
table.insert(map.available_nodes, node)
end
end
-- now we can finish the create base method
function util.CreateBase(current_map)
local base = rooms_folder.Base:Clone() -- create a copy
base.Parent = workspace.Map
base:PivotTo(CFrame.new(Vector3.new(0,50,0))) -- this is just some set position for the main room to start in
table.insert(current_map.rooms, base) -- now we add it to the table, so the map knows we've added a room
-- CRUCIAL: We need to add all of this rooms available nodes to the available nodes table
add_nodes(current_map, base)
end
The next biggest thing to add is the attempt to create room function. This will require lots of other functions to work, but I’ll implement this function first.
function util.AttemptRoomCreation(current_map)
-- Create new room
local new_room = get_random_room():Clone() -- another function we need to write
-- Pick a node within the room to be its root (this is the node which connects to the map as it is)
local self_node = get_random_node_within_room(new_room)
new_room.PrimaryPart = self_node -- this is to make the whole room model "anchor"/"pivot" around this specific node
-- Pick an available node to join this node to
local join_node = get_random_node_within_map(current_map)
-- JOIN
new_room:PivotTo(CFrame.lookAt(join_node.Position, join_node.Position - join_node.CFrame.lookVector))
-- Now we need to ensure that by adding this room, we haven't made some weird collision
local bounding_box = get_bounding_box(new_room)
local params = OverlapParams.new()
params.FilterType = Enum.RaycastFilterType.Exclude
params.FilterDescendantsInstances = {new_room}
local collided = workspace:GetPartBoundsInBox(bounding_box.frame, bounding_box.size, params)
if #collided < 15 then
-- This function handles adding the new room to the map table and stuff
RoomSuccess(current_map, new_room, bounding_box, join_node, self_node)
return "success"
else
-- This function handles removing the room if it collided weirdly
RoomFail(current_map, new_room, bounding_box)
return "fail"
end
end
So hopefully the logic is easy enough to step through. I want to make two quick caveats though.
- To position the room models, I was using the methods “model:PivotTo()” - I don’t know if this is the optimal way of doing this, recently I’ve been using the model:SetPrimaryPartCFrame() method. Again, which you use (if any of these) is really up to you.
- You might wonder why I do this:
Here’s what I remember: when the two rooms were in position, their walls would slightly overlap, so even if the room generated fine, it was still colliding with some parts. Therefore, I randomly chose 15 to be the threshold. THIS IS A TERRIBLE SOLUTION - you’re “magic number threshold” will be different depending on how your rooms are made, and the threshold will be completely different per each wall in each room. BETTER SOLUTION: Add the room you’re joining to to the over lap params filter table, like so:
Okay, two final things.
First, here are the functions needed for the function we just wrote.
function get_random_room()
local rooms = rooms_folder:GetChildren()
local random_room = rooms[math.random(1, #rooms)]
if random_room.Name == "Base" then
return get_random_room()
else
return random_room
end
end
function get_random_node_within_room(room)
local nodes = room.Nodes:GetChildren()
return nodes[math.random(1, #nodes)]
end
function get_random_node_within_map(map)
return map.available_nodes[math.random(1, #map.available_nodes)]
end
function get_bounding_box(room)
local bb_frame, bb_size = room:GetBoundingBox()
return {
frame = bb_frame,
size = bb_size
}
end
And here are the success and fail functions.
function add_nodes(map, room)
for _, node in pairs(room.Nodes:GetChildren()) do
table.insert(map.available_nodes, node)
end
end
function remove_node(map, node)
table.remove(map.available_nodes, table.find(map.available_nodes, node))
node:Destroy()
end
function FailRoom(map, room, bounding_box)
room:Destroy() -- easy
end
function SuccessRoom(map, room, bounding_box, node1, node2)
room.Parent = workspace.Map
table.insert(map.rooms, room)
add_nodes(map, room) -- this is one we wrote ages ago, it just adds all of this rooms nodes to the table
convert_water_in_room(room) -- I wont go into this function, but it basically just creates some terrain water
-- since we just connected these nodes, they're no longer "available", so we've got to remove them
remove_node(map, node1); remove_node(map, node2) -- still need to write this one
end
FINAL THING! - this is going on forever.
Now, the script will generate a whole structure, but those “available nodes” will still be empty archways, so now we need to seal them.
function util.SealNode(current_map, node)
local newCap = cap:Clone()
newCap.CFrame = node.CFrame * CFrame.new(0,7,-1) * CFrame.Angles(0, math.rad(90), 0)
newCap.Parent = workspace.Map
remove_node(current_map, node)
end
Note that the “cap” asset is just a part which is sized to fit the archway we made at the start.
Okay, so I’ll post the utility module in full now.
-- UTILITY
-- SERVICES
local ServerStorage = game:GetService("ServerStorage")
-- Assets
local rooms_folder = ServerStorage.Assets.CompletedRooms
local cap = ServerStorage.Assets.Cap -- for sealing empty doors
function add_nodes(map, room)
for _, node in pairs(room.Nodes:GetChildren()) do
table.insert(map.available_nodes, node)
end
end
function remove_node(map, node)
table.remove(map.available_nodes, table.find(map.available_nodes, node))
node:Destroy()
end
function get_random_room()
local rooms = rooms_folder:GetChildren()
local random_room = rooms[math.random(1, #rooms)]
if random_room.Name == "Base" then
return get_random_room()
else
return random_room
end
end
function get_random_node_within_room(room)
local nodes = room.Nodes:GetChildren()
return nodes[math.random(1, #nodes)]
end
function get_random_node_within_map(map)
return map.available_nodes[math.random(1, #map.available_nodes)]
end
function get_bounding_box(room)
local bb_frame, bb_size = room:GetBoundingBox()
return {
frame = bb_frame,
size = bb_size
}
end
function FailRoom(map, room, bounding_box)
room:Destroy() -- easy
end
function SuccessRoom(map, room, bounding_box, node1, node2)
room.Parent = workspace.Map
table.insert(map.rooms, room)
add_nodes(map, room) -- this is one we wrote ages ago, it just adds all of this rooms nodes to the table
convert_water_in_room(room) -- I wont go into this function, but it basically just creates some terrain water
remove_node(map, node1); remove_node(map, node2) -- still need to write this one
end
-- MODULE
local util = {}
function util.CreateBase(current_map)
local base = rooms_folder.Base:Clone() -- create a copy
base.Parent = workspace.Map
base:PivotTo(CFrame.new(Vector3.new(0,50,0))) -- this is just some set position for the main room to start in
table.insert(current_map.rooms, base) -- now we add it to the table, so the map knows we've added a room
-- CRUCIAL: We need to add all of this rooms available nodes to the available nodes table
add_nodes(current_map, base)
end
function util.AttemptRoomCreation(current_map)
-- Create new room
local new_room = get_random_room():Clone() -- another function we need to write
-- Pick a node within the room to be its root (this is the node which connects to the map as it is)
local self_node = get_random_node_within_room(new_room)
new_room.PrimaryPart = self_node -- this is to make the whole room model "anchor"/"pivot" around this specific node
-- Pick an available node to join this node to
local join_node = get_random_node_within_map(current_map)
-- JOIN
new_room:PivotTo(CFrame.lookAt(join_node.Position, join_node.Position - join_node.CFrame.lookVector))
-- Now we need to ensure that by adding this room, we haven't made some weird collision
local bounding_box = get_bounding_box(new_room)
local params = OverlapParams.new()
params.FilterType = Enum.RaycastFilterType.Exclude
params.FilterDescendantsInstances = {new_room, joining_room}
local collided = workspace:GetPartBoundsInBox(bounding_box.frame, bounding_box.size, params)
if #collided < 15 then
-- This function handles adding the new room to the map table and stuff
SuccessRoom(current_map, new_room, bounding_box, join_node, self_node)
return "success"
else
-- This function handles removing the room if it collided weirdly
FailRoom(current_map, new_room, bounding_box)
return "fail"
end
end
function util.SealNode(current_map, node)
local newCap = cap:Clone()
newCap.CFrame = node.CFrame * CFrame.new(0,7,-1) * CFrame.Angles(0, math.rad(90), 0)
newCap.Parent = workspace.Map
remove_node(current_map, node)
end
return util
Final thoughts:
One potential drawback is the fact that all doors have to be the same size. We can get around this by making various types. For example, you could have small, medium and large. Then, large nodes must connect to large nodes, medium to medium, etc etc.
Another problem is the fact that with this system, loops will never form. You can think of this system as generating a graph, adding on nodes with one connection each time, like so:
So this is never possible
I never got round to fixing this though!
Okay done, sorry that was so long - I get a bit carried away. Hopefully it’s all understandable, do ask questions though!
