Battle Royale Template: Last-Player-Standing Roblox Game

--!strict
-- ServerScriptService/BattleRoyale/MatchManager.lua (phase handlers excerpt)

local handlers: { [MatchPhase]: () -> () } = {
    Waiting = function()
        self:_setPhase("Waiting")
        while self._phase == "Waiting" do
            local playerCount = #Players:GetPlayers()
            if playerCount >= Config.MIN_PLAYERS then
                self:_transitionTo("Countdown")
                return
            end
            task.wait(1)
        end
    end,

    Countdown = function()
        self:_setPhase("Countdown")
        self._countdownRemaining = Config.COUNTDOWN_DURATION

        for i = Config.COUNTDOWN_DURATION, 1, -1 do
            if self._phase ~= "Countdown" then return end
            self._countdownRemaining = i
            MatchStateRemote:FireAllClients("Countdown", i)

            -- Abort countdown if players drop below minimum
            if #Players:GetPlayers() < Config.MIN_PLAYERS then
                self:_transitionTo("Waiting")
                return
            end
            task.wait(1)
        end

        self:_transitionTo("Deploying")
    end,

    InProgress = function()
        self:_setPhase("InProgress")
        self._matchStartTime = os.clock()

        -- Start the storm system
        StormSystem:Start()

        -- Main match loop: check for winner
        while self._phase == "InProgress" do
            local aliveCount = self:GetAliveCount()

            if aliveCount <= 1 then
                local alivePlayers = self:GetAlivePlayers()
                if #alivePlayers == 1 then
                    self._winner = alivePlayers[1]
                end
                self:_transitionTo("Victory")
                return
            end

            -- Tick storm system
            StormSystem:Tick()

            task.wait(0.5)
        end
    end,
}

--!strict
-- ServerScriptService/BattleRoyale/StormSystem.lua

-- Pick a random point inside the current zone for the next smaller zone center
function StormSystem:_pickNextCenter(currentZone: ZoneState, nextRadius: number): (number, number)
    local maxOffset = math.max(0, currentZone.radius - nextRadius)

    if maxOffset <= 0 then
        return currentZone.centerX, currentZone.centerZ
    end

    local angle = math.random() * 2 * math.pi
    local distance = math.random() * maxOffset
    local newCenterX = currentZone.centerX + math.cos(angle) * distance
    local newCenterZ = currentZone.centerZ + math.sin(angle) * distance

    return newCenterX, newCenterZ
end

-- Shrink phase: interpolate current zone toward target with ease-in-out
function StormSystem:_runPhase(phaseConfig: { waitTime: number, shrinkTime: number, radiusFraction: number })
    local nextRadius = Config.ZONE_INITIAL_RADIUS * phaseConfig.radiusFraction
    local nextCenterX, nextCenterZ = self:_pickNextCenter(self._currentZone, nextRadius)

    self._targetZone = {
        centerX = nextCenterX,
        centerZ = nextCenterZ,
        radius = nextRadius,
    }

    -- Wait period: zone is static, target shown on minimap
    self._isShrinking = false
    self:_broadcastZone()

    local waitElapsed = 0
    while waitElapsed < phaseConfig.waitTime and self._running do
        task.wait(1)
        waitElapsed += 1
    end

    if not self._running then return end

    -- Shrink period: interpolate current zone toward target
    self._isShrinking = true
    self:_broadcastZone()

    local startZone: ZoneState = {
        centerX = self._currentZone.centerX,
        centerZ = self._currentZone.centerZ,
        radius = self._currentZone.radius,
    }

    local shrinkElapsed = 0
    while shrinkElapsed < phaseConfig.shrinkTime and self._running do
        local dt = task.wait()
        shrinkElapsed += dt

        local alpha = math.clamp(shrinkElapsed / phaseConfig.shrinkTime, 0, 1)
        -- Smooth ease-in-out interpolation
        local smoothAlpha = alpha * alpha * (3 - 2 * alpha)

        self._currentZone.centerX = startZone.centerX + (self._targetZone.centerX - startZone.centerX) * smoothAlpha
        self._currentZone.centerZ = startZone.centerZ + (self._targetZone.centerZ - startZone.centerZ) * smoothAlpha
        self._currentZone.radius = startZone.radius + (self._targetZone.radius - startZone.radius) * smoothAlpha

        self:_broadcastZone()
    end

    -- Snap to target at end of shrink
    self._currentZone.centerX = self._targetZone.centerX
    self._currentZone.centerZ = self._targetZone.centerZ
    self._currentZone.radius = self._targetZone.radius
    self._isShrinking = false
    self:_broadcastZone()
end

--!strict
-- ServerScriptService/BattleRoyale/LootSpawner.lua

function LootSpawner:SpawnAllLoot()
    self:DespawnAllLoot()

    local spawnPoints = CollectionService:GetTagged(Config.LOOT_SPAWN_TAG)
    print(`[LootSpawner] Spawning loot at {#spawnPoints} points`)

    for _, spawnPoint in spawnPoints do
        if not spawnPoint:IsA("BasePart") then continue end

        local rarity = self:_rollRarity()
        local weaponName = self:_pickWeapon(rarity)
        if not weaponName then continue end

        -- Clone weapon model from ServerStorage
        local weaponTemplate = ServerStorage:FindFirstChild("Weapons")
            and ServerStorage.Weapons:FindFirstChild(weaponName)
        if not weaponTemplate then continue end

        local lootItem = weaponTemplate:Clone()
        lootItem:PivotTo(spawnPoint.CFrame + Vector3.new(0, 1, 0))

        -- Attach rarity metadata
        local rarityValue = Instance.new("StringValue")
        rarityValue.Name = "Rarity"
        rarityValue.Value = rarity
        rarityValue.Parent = lootItem

        -- Add proximity prompt for pickup
        local prompt = Instance.new("ProximityPrompt")
        prompt.ActionText = "Pick Up"
        prompt.ObjectText = `{weaponName} ({rarity})`
        prompt.HoldDuration = 0.15
        prompt.MaxActivationDistance = 8
        prompt.Parent = lootItem.PrimaryPart or lootItem:FindFirstChildWhichIsA("BasePart")

        lootItem.Parent = workspace.LootFolder
        table.insert(spawnedLoot, lootItem)
    end

    print(`[LootSpawner] Spawned {#spawnedLoot} items`)
end

--!strict
-- ServerScriptService/BattleRoyale/EliminationTracker.lua

function EliminationTracker:RecordElimination(victim: Player, killer: Player?, placement: number)
    -- Track placement
    placements[victim] = placement

    -- Track kill count for the killer
    if killer and killer ~= victim then
        killCounts[killer] = (killCounts[killer] or 0) + 1
    end

    -- Log the elimination
    local record: EliminationRecord = {
        victim = victim.Name,
        killer = if killer and killer ~= victim then killer.Name else nil,
        placement = placement,
        timestamp = os.clock(),
    }
    table.insert(eliminations, record)

    -- Broadcast kill feed to all clients
    local killerName = record.killer or "The Storm"
    KillFeedRemote:FireAllClients(killerName, victim.Name, placement)

    -- Drop victim's inventory at their death location
    self:_dropInventory(victim)
end

Build me a 50-player battle royale on a tropical island map. Use the standard
5-zone phases. Add an airdrop system that drops a supply crate with legendary
loot every 3 minutes during InProgress. Include squad mode with teams of 2.