-
Workspace
196.2
-500
[RBX954E8B47B46A3F2B34DF83ECC3D3C294]
-
Camera
06295100010001
70
5
-
Terrain
-
Baseplate
true
true
true
false
0-100100010001
4284702562
256
51220512
0
0
0
1
-
Lobby
-
LobbyFloor
true
true
true
false
00110100010001
4294956664
272
60160
0
0
0
1
-
LobbySpawn
true
true
true
false
01110100010001
4283463920
272
12112
0
0
0
0
true
true
-
Sign
true
true
true
false
066-39100010001
4294637030
272
30121
0
0
0
1
-
SurfaceGui
2
1
0
-
TextLabel
1010
1
DO NOT PRESS
true
26
0.78431370.09803920.0980392
-
TheButton
[RBX463A8BCEBCD11FC2326A69CDE3C29B3C]
-
Pedestal
true
true
true
false
051.500-10100001
4294297640
272
31414
0
0
0
2
-
Cap
true
true
true
false
054.500-10100001
4293601320
272
388
0
0
0
2
-
ProximityPrompt
PRESS IT?
DO NOT PRESS
0
12
false
false
-
Players
-
Lighting
14
3
0.43137250.43137250.4901961
0.54901960.58823530.6666667
0.6
0.3
1
false
-
Atmosphere
0.25
0.1
0.78039220.88235291
10.90196080.7843137
0.8
0
-
Bloom
0.6
24
1.6
true
-
ColorCorrection
0.15
0.25
true
-
ReplicatedFirst
-
ReplicatedStorage
-
GameConfig
Events.
-- Settings: which table in each difficulty (Flood / Floor / Ball) the event reads.
-- UnlockRound: the event can't be picked before this round number.
-- Weight: bigger = picked more often.
---------------------------------------------------------------------
GameConfig.Events = {
{ Name = "DisappearingFloor", Settings = "Floor", DisplayName = "THE FLOOR IS LEAVING!", UnlockRound = 1, Weight = 1 },
{ Name = "RisingFlood", Settings = "Flood", DisplayName = "FLOOD! CLIMB!", UnlockRound = 1, Weight = 1 },
{ Name = "RollingBall", Settings = "Ball", DisplayName = "GIANT BALL INCOMING!", UnlockRound = 3, Weight = 1 },
{ Name = "MoonFloor", Settings = "Floor", DisplayName = "MOON MODE! (the floor is STILL leaving)", UnlockRound = 5, Weight = 1 },
}
---------------------------------------------------------------------
-- SOUNDS
-- Paste a Roblox audio asset ID (just the number) between the quotes. Empty = silent, which is fine.
-- Find free audio in the Creator Store (create.roblox.com/store/audio, or Toolbox > Audio in Studio),
-- open a sound, and copy the number from its page address or its "Copy Asset ID" button.
-- Only use audio that is marked free to use. No IDs are included, so the game is silent until you add some.
---------------------------------------------------------------------
GameConfig.Sounds = {
ButtonPress = "", -- a click or buzzer when somebody presses the button
EventStart = "", -- an alarm when the chaos event begins
Survived = "", -- a happy sound for survivors
Volume = 0.6, -- 0 (silent) to 1 (loud)
}
---------------------------------------------------------------------
-- REWARDS (coins, before the difficulty multiplier)
---------------------------------------------------------------------
GameConfig.Rewards = {
Participation = 1, -- everyone who was in the arena
Survive = 10, -- still alive when the event ends
PresserBonus = 5, -- pressed the button AND survived
}
-- Cosmetic trails unlock automatically when your coin total reaches the number.
GameConfig.Cosmetics = {
{ Name = "Bronze Trail", Coins = 50, Color = Color3.fromRGB(205, 127, 50) },
{ Name = "Silver Trail", Coins = 150, Color = Color3.fromRGB(200, 210, 225) },
{ Name = "Gold Trail", Coins = 400, Color = Color3.fromRGB(255, 200, 40) },
{ Name = "Rainbow Trail", Coins = 1000, Rainbow = true },
}
---------------------------------------------------------------------
-- SAVING
-- Saving only works in Studio after you publish, then: File > Experience Settings >
-- Security > "Enable Studio Access to API Services". The game still runs without it.
-- Careful: once it's on, coins you earn while testing in Studio go into the REAL saves.
---------------------------------------------------------------------
GameConfig.SaveData = true
GameConfig.DataStoreName = "DontPressTheButton_v1"
---------------------------------------------------------------------
-- ARENA (built by ArenaBuilder, so events always line up)
---------------------------------------------------------------------
GameConfig.Arena = {
Center = Vector3.new(0, 50, 0), -- floats in the sky; lava waits below
TileSize = 8,
TilesPerSide = 10, -- 10 x 10 tiles = 80 x 80 studs
WallHeight = 40,
LobbySpawn = Vector3.new(0, 1, 110),
ApplyLighting = true, -- set false if you want to design the Lighting yourself
}
---------------------------------------------------------------------
-- COLOURS (cartoony "toy diorama": calm colours everywhere, RED means danger)
---------------------------------------------------------------------
GameConfig.Colors = {
ButtonCap = Color3.fromRGB(235, 40, 40),
Pedestal = Color3.fromRGB(245, 200, 40),
SignBoard = Color3.fromRGB(250, 245, 230),
SignText = Color3.fromRGB(200, 25, 25),
TileA = Color3.fromRGB(120, 205, 190),
TileB = Color3.fromRGB(150, 225, 210),
TileWarning = Color3.fromRGB(255, 160, 40),
Wall = Color3.fromRGB(255, 255, 255),
Water = Color3.fromRGB(40, 150, 240),
Ball = Color3.fromRGB(255, 120, 30),
Lava = Color3.fromRGB(255, 90, 20),
LobbyFloor = Color3.fromRGB(255, 214, 120),
Steps = Color3.fromRGB(80, 120, 240),
}
return GameConfig
]]>
-
RoundLogic
= config.EscalationRounds.Chaos then
return "Chaos"
elseif roundNumber >= config.EscalationRounds.Normal then
return "Normal"
end
return "Chill"
end
-- Events that are unlocked by this round.
function RoundLogic.GetAvailableEvents(config, roundNumber)
local available = {}
for _, event in ipairs(config.Events) do
if roundNumber >= event.UnlockRound then
table.insert(available, event)
end
end
return available
end
-- Pick a random unlocked event, avoiding a repeat of last round when possible.
-- randomNumber is a function returning a number from 0 to 1 (math.random works).
function RoundLogic.PickEvent(config, roundNumber, lastEventName, randomNumber)
randomNumber = randomNumber or math.random
local choices = {}
for _, event in ipairs(RoundLogic.GetAvailableEvents(config, roundNumber)) do
if event.Name ~= lastEventName then
table.insert(choices, event)
end
end
if #choices == 0 then
choices = RoundLogic.GetAvailableEvents(config, roundNumber)
end
if #choices == 0 then
return nil
end
local totalWeight = 0
for _, event in ipairs(choices) do
totalWeight = totalWeight + event.Weight
end
local roll = randomNumber() * totalWeight
for _, event in ipairs(choices) do
roll = roll - event.Weight
if roll < 0 then
return event
end
end
return choices[#choices]
end
-- How many coins does one player get this round?
function RoundLogic.CalculateReward(config, difficultyName, survived, pressedButton)
local rewards = config.Rewards
local coins = rewards.Participation
if survived then
coins = coins + rewards.Survive
if pressedButton then
coins = coins + rewards.PresserBonus
end
end
local multiplier = config.Difficulties[difficultyName].RewardMultiplier
return math.floor(coins * multiplier + 0.5)
end
-- The best cosmetic a coin total has unlocked (or nil).
function RoundLogic.GetBestCosmetic(config, coins)
local best = nil
for _, cosmetic in ipairs(config.Cosmetics) do
if coins >= cosmetic.Coins and (best == nil or cosmetic.Coins > best.Coins) then
best = cosmetic
end
end
return best
end
-- Checks the config for typos and impossible values. Returns a list of problems.
function RoundLogic.ValidateConfig(config)
local problems = {}
local function check(condition, message)
if not condition then
table.insert(problems, message)
end
end
check(config.MinPlayers >= 1, "MinPlayers must be at least 1")
check(config.IntermissionTime > 0, "IntermissionTime must be above 0")
check(config.ButtonPhaseTime > 0, "ButtonPhaseTime must be above 0")
check(config.ResultsTime >= 0, "ResultsTime can't be negative")
local mode = config.DifficultyMode
check(mode == "Escalating" or config.Difficulties[mode] ~= nil, "Unknown DifficultyMode: " .. tostring(mode))
if mode == "Escalating" then
check(config.EscalationRounds.Normal < config.EscalationRounds.Chaos, "EscalationRounds.Normal must come before Chaos")
check(config.Difficulties.Chill and config.Difficulties.Normal and config.Difficulties.Chaos,
"Escalating mode needs Chill, Normal and Chaos difficulties")
end
for name, difficulty in pairs(config.Difficulties) do
check(difficulty.EventTime > 0, name .. ".EventTime must be above 0")
check(difficulty.RewardMultiplier > 0, name .. ".RewardMultiplier must be above 0")
check(difficulty.Flood.RiseTime > 0, name .. ".Flood.RiseTime must be above 0")
check(difficulty.Flood.MaxHeight > 0 and difficulty.Flood.MaxHeight < config.Arena.WallHeight,
name .. ".Flood.MaxHeight must be between 0 and the wall height")
check(difficulty.Floor.WaveInterval > difficulty.Floor.WarnTime,
name .. ".Floor.WaveInterval must be longer than WarnTime")
check(difficulty.Floor.KeepTiles >= 1, name .. ".Floor.KeepTiles must be at least 1")
check(difficulty.Ball.Size > 0 and difficulty.Ball.Size < config.Arena.TileSize * config.Arena.TilesPerSide / 2,
name .. ".Ball.Size is too big for the arena")
check(difficulty.Ball.Count >= 1, name .. ".Ball.Count must be at least 1")
end
local seen = {}
local hasRoundOneEvent = false
for _, event in ipairs(config.Events) do
check(not seen[event.Name], "Event listed twice: " .. tostring(event.Name))
seen[event.Name] = true
check(event.Weight > 0, event.Name .. " needs a Weight above 0")
check(event.UnlockRound >= 1, event.Name .. " UnlockRound must be at least 1")
for difficultyName, difficulty in pairs(config.Difficulties) do
check(difficulty[event.Settings] ~= nil,
event.Name .. " reads settings '" .. tostring(event.Settings) .. "' but " .. difficultyName .. " has none")
end
if event.UnlockRound <= 1 then
hasRoundOneEvent = true
end
end
check(hasRoundOneEvent, "At least one event must unlock on round 1")
for i, cosmetic in ipairs(config.Cosmetics) do
check(cosmetic.Coins > 0, cosmetic.Name .. " needs a coin price above 0")
check(cosmetic.Rainbow or cosmetic.Color, cosmetic.Name .. " needs a Color (or Rainbow = true)")
if i > 1 then
check(cosmetic.Coins > config.Cosmetics[i - 1].Coins, "Cosmetics must be listed cheapest first")
end
end
if config.Sounds then
for key, value in pairs(config.Sounds) do
if key == "Volume" then
check(type(value) == "number" and value >= 0 and value <= 1, "Sounds.Volume must be a number from 0 to 1")
else
check(type(value) == "string" and (value == "" or value:match("^%d+$") ~= nil),
"Sounds." .. tostring(key) .. " must be empty or just the number of an audio asset ID")
end
end
end
return problems
end
return RoundLogic
]]>
-
ServerScriptService
-
ArenaBuilder
10 or math.abs(z) > 10
return Vector3.new(c.X + x, ArenaBuilder.FloorY + (heightAboveFloor or 3), c.Z + z)
end
-- The button floats up out of the way during events. It turns non-solid first,
-- so nobody can stand on it and ride it up to safety.
function ArenaBuilder.LiftButton(height)
local button = workspace:FindFirstChild("TheButton")
if not (button and buttonHomePivot) then
return
end
for _, part in ipairs(button:GetDescendants()) do
if part:IsA("BasePart") then
part.CanCollide = false
end
end
liftCount = liftCount + 1
local myLift = liftCount
task.spawn(function()
for i = 1, 20 do
if liftCount ~= myLift then
return -- the arena was reset, stop moving the button
end
button:PivotTo(buttonHomePivot + Vector3.new(0, height * i / 20, 0))
task.wait(0.05)
end
end)
end
function ArenaBuilder.GetLobbySpot()
local offset = Vector3.new((math.random() * 2 - 1) * 15, 3, (math.random() * 2 - 1) * 15)
return settings.LobbySpawn + offset
end
return ArenaBuilder
]]>
-
CoinManager
data.Coins then
return nil
end
return data
end)
end)
saving[player] = nil
if not ok then
warn("[CoinManager] Save failed for " .. player.Name .. ": " .. tostring(err))
end
end
function CoinManager.Setup()
if GameConfig.SaveData then
local ok, result = pcall(function()
return DataStoreService:GetDataStore(GameConfig.DataStoreName)
end)
if ok then
store = result
else
warn("[CoinManager] Saving is off (turn on API access in Experience Settings > Security): " .. tostring(result))
end
end
Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in ipairs(Players:GetPlayers()) do
task.spawn(onPlayerAdded, player)
end
Players.PlayerRemoving:Connect(function(player)
while saving[player] do
task.wait(0.1) -- an autosave is running; wait, then save the final numbers
end
save(player)
loadedOk[player] = nil -- so the shutdown save below skips them
end)
-- When the server shuts down, save everyone still here, then wait for every save to finish.
game:BindToClose(function()
for _, player in ipairs(Players:GetPlayers()) do
task.spawn(save, player)
end
while next(saving) ~= nil do
task.wait(0.1)
end
end)
task.spawn(function()
while true do
task.wait(AUTOSAVE_SECONDS)
for _, player in ipairs(Players:GetPlayers()) do
task.spawn(save, player)
end
end
end)
end
function CoinManager.AddCoins(player, amount)
local coins = getStat(player, "Coins")
if coins then
coins.Value = coins.Value + amount
end
end
function CoinManager.AddSurvived(player)
local survived = getStat(player, "Survived")
if survived then
survived.Value = survived.Value + 1
end
end
function CoinManager.GetCoins(player)
local coins = getStat(player, "Coins")
return coins and coins.Value or 0
end
return CoinManager
]]>
-
Cosmetics
-
RoundManager
false
0
teleport into arena -> 20s "don't press" -> random event -> rewards -> back to lobby
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
local TweenService = game:GetService("TweenService")
local GameConfig = require(ReplicatedStorage:WaitForChild("GameConfig"))
local RoundLogic = require(ReplicatedStorage:WaitForChild("RoundLogic"))
local ArenaBuilder = require(ServerScriptService:WaitForChild("ArenaBuilder"))
local CoinManager = require(ServerScriptService:WaitForChild("CoinManager"))
local Cosmetics = require(ServerScriptService:WaitForChild("Cosmetics"))
local SoundPlayer = require(ServerScriptService:WaitForChild("SoundPlayer"))
local eventsFolder = ServerScriptService:WaitForChild("Events")
-- Catch config typos right away, with a clear message in the Output window.
local problems = RoundLogic.ValidateConfig(GameConfig)
if #problems > 0 then
for _, problem in ipairs(problems) do
warn("[GameConfig] " .. problem)
end
error("GameConfig has " .. #problems .. " problem(s). Fix them (see the warnings above) and press Play again.")
end
-- The server uses this RemoteEvent to tell every player's screen to shake, flash or show a banner.
local fxRemote = ReplicatedStorage:FindFirstChild("GameFX")
if not fxRemote then
fxRemote = Instance.new("RemoteEvent")
fxRemote.Name = "GameFX"
fxRemote.Parent = ReplicatedStorage
end
local button = ArenaBuilder.Build()
local cap = button:FindFirstChild("Cap")
local prompt = cap:FindFirstChildOfClass("ProximityPrompt")
CoinManager.Setup()
Cosmetics.Setup(fxRemote)
local FALL_DEPTH = 15 -- this far below the floor = you fell, you're out
local roundNumber = 0
local lastEventName = nil
local participants = {} -- [player] = true while they are alive in the arena
local diedConnections = {}
local presser = nil
local buttonArmed = false
local stopEvent = nil -- the running event's stop function (endRound always calls it)
local PRESS_DISTANCE = 15 -- studs; stops cheaters pressing from across the arena
---------------------------------------------------------------------
-- Helpers
---------------------------------------------------------------------
-- Players read these attributes to update their screen (see the HUD LocalScript).
local function setStatus(phase, text, timeLeft)
ReplicatedStorage:SetAttribute("Phase", phase)
ReplicatedStorage:SetAttribute("Status", text)
ReplicatedStorage:SetAttribute("TimeLeft", timeLeft or 0)
end
local function anyoneLeft()
return next(participants) ~= nil
end
local function eliminate(player)
if participants[player] then
participants[player] = nil
if player.Parent then
fxRemote:FireClient(player, "Banner", "ELIMINATED!")
end
end
end
-- Everyone still alive in the arena, with the parts events usually need.
local function getAlive()
local alive = {}
for player in pairs(participants) do
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
local root = character and character:FindFirstChild("HumanoidRootPart")
if humanoid and root and humanoid.Health > 0 then
table.insert(alive, { Player = player, Character = character, Humanoid = humanoid, Root = root })
end
end
return alive
end
-- Counts down to a fixed finish time (so it never drifts). Stops early (and returns true) if stopWhen() becomes true.
-- makeText(timeLeft) returns the status text, e.g. "Next round in 5..."
local function countdown(seconds, phase, makeText, stopWhen)
local finish = os.clock() + seconds
local shown = nil
while true do
local timeLeft = math.ceil(finish - os.clock())
if timeLeft <= 0 then
break
end
if timeLeft ~= shown then
shown = timeLeft
setStatus(phase, makeText(timeLeft), timeLeft)
end
if stopWhen and stopWhen() then
return true
end
task.wait(0.1)
end
return stopWhen ~= nil and stopWhen() == true
end
local function playPressAnimation()
local home = cap.CFrame
local down = TweenService:Create(cap, TweenInfo.new(0.12, Enum.EasingStyle.Quad, Enum.EasingDirection.In), {
CFrame = home - Vector3.new(0, 1.8, 0),
})
down:Play()
task.delay(0.4, function()
TweenService:Create(cap, TweenInfo.new(0.3, Enum.EasingStyle.Back, Enum.EasingDirection.Out), { CFrame = home }):Play()
end)
local sound = cap:FindFirstChildOfClass("Sound") -- add one from the Toolbox if you like
if sound then
sound:Play()
end
SoundPlayer.Play("ButtonPress", cap)
end
local function endRound()
if stopEvent then
pcall(stopEvent)
stopEvent = nil
end
buttonArmed = false
prompt.Enabled = false
for _, connection in ipairs(diedConnections) do
connection:Disconnect()
end
diedConnections = {}
participants = {}
presser = nil
ArenaBuilder.Reset()
end
---------------------------------------------------------------------
-- Things that can happen at any moment
---------------------------------------------------------------------
prompt.Triggered:Connect(function(player)
local root = player.Character and player.Character:FindFirstChild("HumanoidRootPart")
local closeEnough = root and (root.Position - cap.Position).Magnitude <= PRESS_DISTANCE
if buttonArmed and participants[player] and closeEnough then
buttonArmed = false
prompt.Enabled = false
presser = player
end
end)
Players.PlayerRemoving:Connect(function(player)
participants[player] = nil
end)
-- Anyone who falls off the arena is out. (The lava kills too, but this check usually gets there first.)
task.spawn(function()
while true do
task.wait(0.25)
for _, info in ipairs(getAlive()) do
if info.Root.Position.Y < ArenaBuilder.FloorY - FALL_DEPTH then
info.Humanoid.Health = 0
eliminate(info.Player)
end
end
end
end)
---------------------------------------------------------------------
-- One full round
---------------------------------------------------------------------
local function runRound()
while #Players:GetPlayers() < GameConfig.MinPlayers do
setStatus("Waiting", "Waiting for players (" .. #Players:GetPlayers() .. "/" .. GameConfig.MinPlayers .. ")", 0)
task.wait(1)
end
countdown(GameConfig.IntermissionTime, "Intermission", function(timeLeft)
return "Next round in " .. timeLeft .. "..."
end)
-- 1. Teleport everyone with a living character into the arena
ArenaBuilder.Reset()
local roundPlayers = {}
for _, player in ipairs(Players:GetPlayers()) do
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if humanoid and humanoid.Health > 0 and character:FindFirstChild("HumanoidRootPart") then
character:PivotTo(CFrame.new(ArenaBuilder.GetRandomSpot(3)))
participants[player] = true
table.insert(roundPlayers, player)
table.insert(diedConnections, humanoid.Died:Connect(function()
eliminate(player)
end))
end
end
if not anyoneLeft() then
return
end
roundNumber = roundNumber + 1 -- only rounds somebody actually played count
local difficultyName = RoundLogic.GetDifficultyName(GameConfig, roundNumber)
local difficulty = GameConfig.Difficulties[difficultyName]
ReplicatedStorage:SetAttribute("Round", roundNumber)
ReplicatedStorage:SetAttribute("Difficulty", difficultyName)
-- 2. The button phase: 20 seconds of temptation
buttonArmed = true
prompt.Enabled = true
countdown(GameConfig.ButtonPhaseTime, "Button", function(timeLeft)
return "DON'T PRESS THE BUTTON! " .. timeLeft
end, function()
return presser ~= nil or not anyoneLeft()
end)
buttonArmed = false
prompt.Enabled = false
if not anyoneLeft() then
for _, player in ipairs(roundPlayers) do
if player.Parent then
CoinManager.AddCoins(player, GameConfig.Rewards.Participation)
end
end
return
end
if presser == nil and not GameConfig.AutoPressWhenTimeUp then
setStatus("Results", "Nobody pressed it. Boring... but safe.", 0)
for _, player in ipairs(roundPlayers) do
if player.Parent then
CoinManager.AddCoins(player, GameConfig.Rewards.Participation)
end
end
task.wait(GameConfig.ResultsTime)
return
end
-- 3. Somebody pressed it (or the button got impatient)
local presserName = presser and presser.Name
playPressAnimation()
fxRemote:FireAllClients("Flash")
fxRemote:FireAllClients("Shake", 0.8, 0.6)
local event = RoundLogic.PickEvent(GameConfig, roundNumber, lastEventName)
lastEventName = event.Name
if presserName then
setStatus("Pressed", presserName .. " PRESSED THE BUTTON!", 0)
else
setStatus("Pressed", "Nobody pressed it... so it pressed ITSELF!", 0)
end
task.wait(2)
fxRemote:FireAllClients("Banner", event.DisplayName)
SoundPlayer.Play("EventStart", cap)
ArenaBuilder.LiftButton(30)
-- 4. Run the event
local eventModule = eventsFolder:FindFirstChild(event.Name)
if not eventModule then
error("No ModuleScript named '" .. event.Name .. "' inside ServerScriptService > Events")
end
local context = {
Settings = difficulty[event.Settings],
Arena = ArenaBuilder,
Folder = ArenaBuilder.GetEventFolder(),
GetAlive = getAlive,
FX = function(...)
fxRemote:FireAllClients(...)
end,
}
local ok, result = pcall(function()
return require(eventModule).Start(context)
end)
if ok then
stopEvent = result
else
warn("[RoundManager] " .. event.Name .. " crashed when starting: " .. tostring(result))
end
countdown(difficulty.EventTime, "Event", function(timeLeft)
return event.DisplayName .. " " .. timeLeft
end, function()
return not anyoneLeft()
end)
if stopEvent then
pcall(stopEvent)
stopEvent = nil
end
-- 5. Rewards
local survivorCount = 0
for _, player in ipairs(roundPlayers) do
if player.Parent then
local survived = participants[player] == true
local coins = RoundLogic.CalculateReward(GameConfig, difficultyName, survived, player == presser)
CoinManager.AddCoins(player, coins)
if survived then
survivorCount = survivorCount + 1
CoinManager.AddSurvived(player)
fxRemote:FireClient(player, "Banner", "YOU SURVIVED! +" .. coins .. " coins")
else
fxRemote:FireClient(player, "Banner", "Better luck next time. +" .. coins .. " coins")
end
end
end
setStatus("Results", survivorCount .. " of " .. #roundPlayers .. " survived!", 0)
if survivorCount > 0 then
SoundPlayer.Play("Survived", cap)
end
task.wait(GameConfig.ResultsTime)
-- 6. Survivors go back to the lobby (eliminated players already respawned there)
for player in pairs(participants) do
if player.Character then
player.Character:PivotTo(CFrame.new(ArenaBuilder.GetLobbySpot()))
end
end
end
---------------------------------------------------------------------
-- Run rounds forever. If a round ever crashes, log it and start a fresh one.
---------------------------------------------------------------------
while true do
local ok, err = pcall(runRound)
if not ok then
warn("[RoundManager] Round crashed: " .. tostring(err))
setStatus("Waiting", "Oops! Restarting the round...", 0)
task.wait(2)
end
endRound()
end
]]>
-
SoundPlayer
-
Events
-
DisappearingFloor
Events)
-- Tiles flash orange, then vanish. Don't be standing on them. The lava is waiting.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local GameConfig = require(ReplicatedStorage:WaitForChild("GameConfig"))
local DisappearingFloor = {}
function DisappearingFloor.Start(context)
local settings = context.Settings
local remaining = {}
for _, tile in ipairs(context.Arena.GetTiles()) do
table.insert(remaining, tile)
end
local running = true
task.spawn(function()
while running do
local count = math.min(settings.TilesPerWave, #remaining - settings.KeepTiles)
if count > 0 then
local wave = {}
for _ = 1, count do
local tile = table.remove(remaining, math.random(1, #remaining))
tile.Color = GameConfig.Colors.TileWarning
tile.Material = Enum.Material.Neon
table.insert(wave, tile)
end
task.wait(settings.WarnTime)
if not running then
break
end
for _, tile in ipairs(wave) do
tile.Transparency = 1
tile.CanCollide = false
end
end
task.wait(settings.WaveInterval - settings.WarnTime)
end
end)
return function()
running = false
end
end
return DisappearingFloor
]]>
-
MoonFloor
Events)
-- Low gravity AND the floor disappears. Shows how a new event can reuse an old one.
-- It is already switched on in GameConfig.Events (it unlocks on round 5):
-- { Name = "MoonFloor", Settings = "Floor", DisplayName = "MOON MODE! (the floor is STILL leaving)", UnlockRound = 5, Weight = 1 },
local DisappearingFloor = require(script.Parent:WaitForChild("DisappearingFloor"))
local MoonFloor = {}
local MOON_GRAVITY = 50 -- normal Roblox gravity is 196.2
function MoonFloor.Start(context)
local normalGravity = workspace.Gravity
workspace.Gravity = MOON_GRAVITY
context.FX("Banner", "Gravity is broken!")
-- If the floor part breaks, put gravity back before passing the error on.
local started, stopFloor = pcall(DisappearingFloor.Start, context)
if not started then
workspace.Gravity = normalGravity
error(stopFloor)
end
return function()
stopFloor()
workspace.Gravity = normalGravity
end
end
return MoonFloor
]]>
-
RisingFlood
Events)
-- Water fills the arena. Two staircases appear: climb before the water reaches you!
local TweenService = game:GetService("TweenService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local GameConfig = require(ReplicatedStorage:WaitForChild("GameConfig"))
local RisingFlood = {}
local STEP_HEIGHTS = { 4, 8, 12, 16, 20, 24, 28 } -- a 7-stud jump easily goes up 4
local function makeStep(folder, position)
local step = Instance.new("Part")
step.Name = "Step"
step.Anchored = true
step.Size = Vector3.new(8, 1, 8)
step.Position = position
step.Color = GameConfig.Colors.Steps
step.Material = Enum.Material.SmoothPlastic
step.Parent = folder
end
function RisingFlood.Start(context)
local settings = context.Settings
local arena = context.Arena
local center = arena.Center
local floorY = arena.FloorY
local half = arena.Width / 2
-- One staircase along the north wall, a mirrored one along the south wall.
for i, height in ipairs(STEP_HEIGHTS) do
local offsetX = -half + 6 + (i - 1) * 10
local y = floorY + height - 0.5
makeStep(context.Folder, Vector3.new(center.X + offsetX, y, center.Z - half + 6))
makeStep(context.Folder, Vector3.new(center.X - offsetX, y, center.Z + half - 6))
end
local water = Instance.new("Part")
water.Name = "FloodWater"
water.Anchored = true
water.CanCollide = false
water.Material = Enum.Material.Glass
water.Color = GameConfig.Colors.Water
water.Transparency = 0.35
water.Size = Vector3.new(arena.Width, 1, arena.Width)
water.Position = Vector3.new(center.X, floorY + 0.5, center.Z)
water.Parent = context.Folder
local rise = TweenService:Create(water, TweenInfo.new(settings.RiseTime, Enum.EasingStyle.Linear), {
Size = Vector3.new(arena.Width, settings.MaxHeight, arena.Width),
Position = Vector3.new(center.X, floorY + settings.MaxHeight / 2, center.Z),
})
rise:Play()
local running = true
task.spawn(function()
while running do
local elapsed = task.wait(0.25)
if not running then
break
end
local waterTop = water.Position.Y + water.Size.Y / 2
for _, info in ipairs(context.GetAlive()) do
-- the root part is about waist height, so this means "waist-deep or worse"
if info.Root.Position.Y < waterTop then
info.Humanoid:TakeDamage(settings.DamagePerSecond * elapsed)
end
end
end
end)
return function()
running = false
rise:Cancel()
end
end
return RisingFlood
]]>
-
RollingBall
Events)
-- A giant ball picks a victim, pauses, then charges in a straight line. Side-step it!
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local GameConfig = require(ReplicatedStorage:WaitForChild("GameConfig"))
local RollingBall = {}
local AIM_PAUSE = 0.6 -- seconds the ball "thinks" before each charge (your chance to dodge)
local function runBall(context, ball, isRunning)
local settings = context.Settings
local arena = context.Arena
local radius = settings.Size / 2
local limit = arena.Width / 2 - radius
local center = arena.Center
local y = arena.FloorY + radius
local position = ball.Position
local spin = CFrame.new()
while isRunning() do
-- 1. pick a target and aim
local alive = context.GetAlive()
local direction
if #alive > 0 then
local target = alive[math.random(1, #alive)].Root.Position
direction = Vector3.new(target.X - position.X, 0, target.Z - position.Z)
end
if direction == nil or direction.Magnitude < 1 then
local angle = math.random() * math.pi * 2
direction = Vector3.new(math.cos(angle), 0, math.sin(angle))
end
direction = direction.Unit
task.wait(AIM_PAUSE)
-- 2. charge until we hit a wall
local hitWall = false
while isRunning() and not hitWall do
local elapsed = task.wait()
local nextPosition = position + direction * settings.Speed * elapsed
local offsetX = nextPosition.X - center.X
local offsetZ = nextPosition.Z - center.Z
if math.abs(offsetX) > limit or math.abs(offsetZ) > limit then
hitWall = true
offsetX = math.clamp(offsetX, -limit, limit)
offsetZ = math.clamp(offsetZ, -limit, limit)
end
position = Vector3.new(center.X + offsetX, y, center.Z + offsetZ)
-- make it look like it's rolling
local rollAxis = Vector3.new(direction.Z, 0, -direction.X)
spin = CFrame.fromAxisAngle(rollAxis, settings.Speed * elapsed / radius) * spin
ball.CFrame = CFrame.new(position) * spin
for _, info in ipairs(context.GetAlive()) do
if (info.Root.Position - position).Magnitude < radius + 1.5 then
info.Humanoid.Health = 0
end
end
end
if hitWall then
context.FX("Shake", 0.6, 0.4)
end
end
end
function RollingBall.Start(context)
local settings = context.Settings
local running = true
local function isRunning()
return running
end
for i = 1, settings.Count do
local ball = Instance.new("Part")
ball.Name = "GiantBall" .. i
ball.Shape = Enum.PartType.Ball
ball.Size = Vector3.new(settings.Size, settings.Size, settings.Size)
ball.Anchored = true -- the script moves it, so physics can't fling it out of the arena
ball.CanCollide = false
ball.Color = GameConfig.Colors.Ball
ball.Material = Enum.Material.SmoothPlastic
-- start in a corner, away from the middle
local corner = (i % 2 == 1) and 1 or -1
local start = context.Arena.Center + Vector3.new(corner, 0, corner) * (context.Arena.Width / 2 - settings.Size / 2)
ball.Position = Vector3.new(start.X, context.Arena.FloorY + settings.Size / 2, start.Z)
ball.Parent = context.Folder
task.spawn(runBall, context, ball, isRunning)
end
return function()
running = false
end
end
return RollingBall
]]>
-
ServerStorage
-
StarterGui
-
StarterPack
-
StarterPlayer
-
StarterPlayerScripts
-
HUD
false
StarterPlayerScripts)
-- Runs on each player's own computer/phone. It builds the on-screen text and plays screen effects.
-- It only DISPLAYS things; the server decides everything (so nobody can cheat coins from here).
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local TweenService = game:GetService("TweenService")
local player = Players.LocalPlayer
local fxRemote = ReplicatedStorage:WaitForChild("GameFX")
local FONT = Enum.Font.FredokaOne
local SHAKE_ENABLED = true -- set false if screen shake makes anyone feel sick
---------------------------------------------------------------------
-- Build the screen (Scale sizes so it fits phones and big monitors)
---------------------------------------------------------------------
local gui = Instance.new("ScreenGui")
gui.Name = "HUD"
gui.ResetOnSpawn = false -- keep it when your character respawns
local function makeLabel(name, position, size)
local label = Instance.new("TextLabel")
label.Name = name
label.AnchorPoint = Vector2.new(0.5, 0.5)
label.Position = position
label.Size = size
label.BackgroundTransparency = 1
label.Font = FONT
label.TextScaled = true
label.TextColor3 = Color3.fromRGB(255, 255, 255)
label.Text = ""
local stroke = Instance.new("UIStroke")
stroke.Thickness = 3
stroke.Color = Color3.fromRGB(20, 24, 36)
stroke.Parent = label
local limit = Instance.new("UITextSizeConstraint")
limit.MinTextSize = 16
limit.MaxTextSize = 64
limit.Parent = label
label.Parent = gui
return label
end
local status = makeLabel("Status", UDim2.fromScale(0.5, 0.06), UDim2.fromScale(0.6, 0.07))
status.BackgroundTransparency = 0.35
status.BackgroundColor3 = Color3.fromRGB(20, 24, 36)
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0.3, 0)
corner.Parent = status
local timer = makeLabel("Timer", UDim2.fromScale(0.5, 0.16), UDim2.fromScale(0.2, 0.1))
local info = makeLabel("Info", UDim2.fromScale(0.5, 0.96), UDim2.fromScale(0.4, 0.04))
local banner = makeLabel("Banner", UDim2.fromScale(0.5, 0.4), UDim2.fromScale(0.8, 0.12))
banner.TextColor3 = Color3.fromRGB(255, 220, 60)
banner.Visible = false
local flash = Instance.new("Frame")
flash.Name = "Flash"
flash.Size = UDim2.fromScale(1, 1)
flash.BackgroundColor3 = Color3.fromRGB(255, 40, 40)
flash.BackgroundTransparency = 1
flash.BorderSizePixel = 0
flash.ZIndex = 0
flash.Parent = gui
gui.Parent = player:WaitForChild("PlayerGui")
---------------------------------------------------------------------
-- Show what the server is telling us
---------------------------------------------------------------------
local function updateStatus()
status.Text = ReplicatedStorage:GetAttribute("Status") or "Loading..."
local timeLeft = ReplicatedStorage:GetAttribute("TimeLeft") or 0
timer.Text = timeLeft > 0 and tostring(timeLeft) or ""
-- the last 5 seconds of the button phase turn red
local phase = ReplicatedStorage:GetAttribute("Phase")
if phase == "Button" and timeLeft <= 5 then
timer.TextColor3 = Color3.fromRGB(255, 70, 70)
else
timer.TextColor3 = Color3.fromRGB(255, 255, 255)
end
end
local function updateInfo()
local round = ReplicatedStorage:GetAttribute("Round")
local difficulty = ReplicatedStorage:GetAttribute("Difficulty")
if round then
info.Text = "Round " .. round .. " | " .. tostring(difficulty)
end
end
ReplicatedStorage:GetAttributeChangedSignal("Status"):Connect(updateStatus)
ReplicatedStorage:GetAttributeChangedSignal("TimeLeft"):Connect(updateStatus)
ReplicatedStorage:GetAttributeChangedSignal("Round"):Connect(updateInfo)
ReplicatedStorage:GetAttributeChangedSignal("Difficulty"):Connect(updateInfo)
updateStatus()
updateInfo()
---------------------------------------------------------------------
-- Screen effects
---------------------------------------------------------------------
local bannerToken = 0
local function showBanner(text)
bannerToken = bannerToken + 1
local myToken = bannerToken
banner.Text = text
banner.Visible = true
task.delay(2.5, function()
if bannerToken == myToken then -- a newer banner replaces this one
banner.Visible = false
end
end)
end
local function playFlash()
flash.BackgroundTransparency = 0.4
TweenService:Create(flash, TweenInfo.new(0.6), { BackgroundTransparency = 1 }):Play()
end
local function shake(strength, duration)
if not SHAKE_ENABLED then
return
end
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if not humanoid then
return
end
local started = os.clock()
local connection
connection = RunService.RenderStepped:Connect(function()
local progress = (os.clock() - started) / duration
if progress >= 1 or humanoid.Parent == nil then
humanoid.CameraOffset = Vector3.new(0, 0, 0)
connection:Disconnect()
return
end
local amount = strength * (1 - progress) -- fades out
humanoid.CameraOffset = Vector3.new((math.random() * 2 - 1) * amount, (math.random() * 2 - 1) * amount, 0)
end)
end
fxRemote.OnClientEvent:Connect(function(kind, a, b)
if kind == "Banner" then
showBanner(a)
elseif kind == "Flash" then
playFlash()
elseif kind == "Shake" then
shake(a or 0.5, b or 0.5)
end
end)
]]>
-
StarterCharacterScripts
-
Teams
-
SoundService
-
Chat
-
TextChatService
-
LocalizationService
-
TestService