How to make a hide and seek game in Roblox Studio

What makes a hide and seek game work

The loop in one line: hide (or count), wait in a spot with your heart racing, get found or survive, swap roles, play again.

• Both roles are fun. Hiders need tension, seekers need a fair chance. If seekers rarely find anyone, nobody wants to seek.
• A real head start. The seeker must not see where people go. Block their view and freeze them during the hiding phase.
• Good spots, not perfect ones. A spot inside a wall or under the map ruins the round. Every spot should be findable by a careful seeker.
• Found players stay in. Turning found hiders into extra seekers keeps them playing instead of waiting.
• Short rounds. Three minutes of seeking is plenty for a small map.

Hide and seek shares its round structure with killer vs survivors games; this guide keeps it to tagging and hiding, with no combat.

The systems you need

Build plan: from a baseplate to launch

First playable

1. Build a lobby with a SpawnLocation, and one small map: a house with a few rooms, furniture and a yard. Put a part named MapSpawn in it and keep the map in the Workspace for now.
2. Create two teams in the Teams service named Seekers and Hiders, with AutoAssignable off.
3. Add the round script below, and a Tag RemoteEvent in ReplicatedStorage.
4. Add the seeker's tag input: a LocalScript that, when the seeker clicks a character, fires Tag with that player. The server decides whether it counts.
5. Test with three players in Studio's multi-client test: one seeker, two hiders, one full round.

First public test

One map, rounds of one minute hiding and three minutes seeking, coins for both roles. Watch where hiders go: a spot every winner uses is too good, and a room nobody enters is wasted. Also count how often seekers find nobody; if it is more than one round in three, the map is too big or the time too short.

What to add for launch

• Three or more maps of different sizes, rotated or voted on.
• Found hiders become seekers, so the end of a round speeds up.
• A seeker tool with a short cooldown and a hit sound, so tagging feels physical.
• Taunts for hiders: a sound they can play once a round for bonus coins, which helps seekers too.
• Saved coins and a shop for cosmetics.
• The Maturity and Compliance Questionnaire in the Creator Dashboard: Roblox restricts who can play a game without content maturity information.

The defining mechanic: rounds and fair tags

This server script runs the whole round. It picks the seeker who has waited longest, puts everyone on the map, freezes the seeker for the hiding phase, then accepts tags only while seeking, only from seekers, and only when the two characters are within TAG_RANGE studs on the server. Found hiders join the seekers.

ReplicatedStorage
  Tag RemoteEvent
Teams
  Seekers Team
  Hiders Team
Workspace
  Map Model
    MapSpawn Part
ServerScriptService
  HideAndSeek Script new

-- Script in ServerScriptService named HideAndSeek.
-- Picks a seeker fairly, runs hide and seek phases, and checks every tag on the server.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Teams = game:GetService("Teams")

local HIDE_TIME = 30
local SEEK_TIME = 180
local TAG_RANGE = 8 -- studs between the two characters

local tagEvent = ReplicatedStorage:WaitForChild("Tag") :: RemoteEvent
local seekers = Teams:WaitForChild("Seekers") :: Team
local hiders = Teams:WaitForChild("Hiders") :: Team
local mapSpawn = workspace:WaitForChild("Map"):WaitForChild("MapSpawn") :: BasePart

local roundsSinceSeeking: { [Player]: number } = {}
local seeking = false

local function setStatus(text: string, timeLeft: number)
	ReplicatedStorage:SetAttribute("Status", text)
	ReplicatedStorage:SetAttribute("TimeLeft", timeLeft)
end

local function humanoidOf(player: Player): Humanoid?
	local character = player.Character
	return if character then character:FindFirstChildOfClass("Humanoid") else nil
end

local function pickSeeker(players: { Player }): Player
	local best = players[1]
	for _, player in players do
		if (roundsSinceSeeking[player] or 0) > (roundsSinceSeeking[best] or 0) then
			best = player
		end
	end
	return best
end

local function hidersLeft(): number
	return #hiders:GetPlayers()
end

tagEvent.OnServerEvent:Connect(function(seeker, target)
	if not seeking or seeker.Team ~= seekers then
		return
	end
	if typeof(target) ~= "Instance" or not target:IsA("Player") or target.Team ~= hiders then
		return
	end
	local a = seeker.Character and seeker.Character:GetPivot().Position
	local b = target.Character and target.Character:GetPivot().Position
	if not a or not b or (a - b).Magnitude > TAG_RANGE then
		return -- too far away on the server: ignore
	end
	target.Team = seekers -- found: now helps seek
	local tags = seeker:GetAttribute("Tags")
	seeker:SetAttribute("Tags", (if typeof(tags) == "number" then tags else 0) + 1)
end)

while true do
	local players = Players:GetPlayers()
	if #players < 2 then
		setStatus("Waiting for players", 0)
		task.wait(2)
		continue
	end

	local seeker = pickSeeker(players)
	for _, player in players do
		roundsSinceSeeking[player] = (roundsSinceSeeking[player] or 0) + 1
		player.Neutral = false
		player.Team = if player == seeker then seekers else hiders
		local character = player.Character
		if character then
			character:PivotTo(mapSpawn.CFrame + Vector3.new(math.random(-6, 6), 4, math.random(-6, 6)))
		end
	end
	roundsSinceSeeking[seeker] = 0

	-- hiding phase: the seeker cannot move
	local seekerHumanoid = humanoidOf(seeker)
	if seekerHumanoid then
		seekerHumanoid.WalkSpeed = 0
	end
	seeker:SetAttribute("Blind", true) -- a LocalScript shows a black screen while this is true
	for t = HIDE_TIME, 1, -1 do
		setStatus("Hide!", t)
		task.wait(1)
	end
	seeker:SetAttribute("Blind", false)
	if seekerHumanoid then
		seekerHumanoid.WalkSpeed = 16
	end

	-- seeking phase
	seeking = true
	local t = SEEK_TIME
	while t > 0 and hidersLeft() > 0 do
		setStatus("Seek!", t)
		task.wait(1)
		t -= 1
	end
	seeking = false

	local winners = hiders:GetPlayers()
	setStatus(if #winners > 0 then `Hiders win ({#winners} left)` else "Seekers win", 0)
	for _, player in winners do
		local wins = player:GetAttribute("Wins")
		player:SetAttribute("Wins", (if typeof(wins) == "number" then wins else 0) + 1)
	end
	task.wait(5)
	for _, player in Players:GetPlayers() do
		player.Neutral = true -- off both teams until the next round
		task.spawn(player.LoadCharacterAsync, player) -- back to the lobby
	end
	task.wait(10)
end

The distance check is what keeps tags honest. A player's own computer moves their character, so a cheating seeker could report a tag from across the map. The server compares the two characters' positions as it sees them and ignores anything further than TAG_RANGE. Set it a little above the reach of your tag tool so real tags never fail.

Put the blind screen in a LocalScript in StarterPlayerScripts: watch the local player's Blind attribute with GetAttributeChangedSignal and show a full-screen black frame while it is true. If the seeker leaves mid-round, the loop keeps going with any found hiders as seekers; add a check that ends the round when the Seekers team is empty.

The hard part: a map with good spots

In hide and seek the map does most of the game design. A great round needs spots of every kind, and none that break the game:

• Every size of spot. Behind a sofa (quick, easy to find), inside a wardrobe (better), on top of a shelf you need to jump to (clever). Mix them in every room.
• No glitch spots. Players will try to get inside walls, under floors and outside the map. Make walls thick, put an invisible ceiling over the map, and add a kill zone under it that sends players back.
• Loops and exits. A hider who is spotted should have somewhere to run. Rooms with two doors make chases fun instead of instant.
• Size for the player count. A map that takes about a minute to walk around fits 8 to 12 players. Bigger servers need bigger maps or more seekers.
• Light and sound. Dim corners hide players; footsteps give them away. Both are tools for balance.

Monetization that fits hide and seek

Selling ways to be impossible to find, or to see through walls, breaks the game for everyone else. Sell style and convenience:

A developer product must be granted through MarketplaceService.ProcessReceipt so a purchase is never lost; the game pass guide covers pass checks and prompts. You cannot turn on private servers and paid access at the same time. Roblox also pays creators through Creator Rewards, which replaced engagement-based payouts on 24 July 2025. Rewarded video ads, where your game qualifies, must reward a developer product and cannot be random: double coins for the next round fits.

What brings players back

• New maps. A new map is the biggest update a hide and seek game can ship, and it needs no new code if maps share the same parts.
• Stats for both roles. Rounds survived and players tagged, on a leaderboard.
• Cosmetics bought with coins. Coins earned from both roles, spent on looks that do not change hiding.
• Daily rewards. A login streak that pays coins (daily rewards).
• Friends. Party up in the lobby and offer private servers for groups.

Build a hide and seek game with RoCode

RoCode is an independent AI agent for Roblox Studio. You describe what you want in a web chat, and its free Studio plugin writes the Luau and creates the scripts, parts and UI in the place you have open. For a hide and seek game it works in rounds: first the map and the round loop, then tagging, then rewards and more maps.

Build this in Studio ↗

It cannot make custom meshes or animations, publish the game, or tell you whether your spots are fun: you still play rounds with friends. Free credits every day, no card needed. How RoCode builds a game.

Questions

Sources and further reading

• Roblox Creator Docs: Teams
• Roblox Creator Docs: Humanoid.WalkSpeed
• Roblox Creator Docs: Player:LoadCharacterAsync
• Roblox Creator Docs: security tactics. check what clients send
• Roblox Creator Docs: Developer products
• Roblox Creator Docs: Creator Rewards
• RoCode guide: Round system
• RoCode guide: Team system

How the code was checked: every script on this page passes Luau's strict type checker against Roblox's API definitions (luau-lsp, 4 November 2026). A type check catches misspelt APIs and wrong types, not game logic, so playtest in Studio before you publish.