Freeze Tag - Game Controller

local CurrentMap = workspace:WaitForChild("CurrentMap")

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Maps = ReplicatedStorage:WaitForChild("Maps")
--Events
local SendMessage = ReplicatedStorage:WaitForChild("SendMessage")

local GameController = {
    GamePlaying = false,
    TaggersHaveTeleported = false,
    Taggers = {},
    Runners = {},
}

function GameController:PickMap()
    local Map = Maps:GetChildren()[math.random(1, #Maps:GetChildren())]
    return Map
end

function GameController:AddMap()
    CurrentMap:ClearAllChildren()

    local Map = GameController.PickMap():Clone()
    Map.Parent = CurrentMap

    local IceBlocks = Instance.new("Folder", CurrentMap)
    IceBlocks.Name = "IceBlocks"

    return Map
end

function GameController:PickTeams()
    local Taggers = {}
    local Runners = {}

    local Players = game.Players:GetPlayers()
    local PlayerCount = #Players

    if PlayerCount == 1 then
    elseif PlayerCount >= 2 then
        local TaggerCount = math.floor(PlayerCount/2)

        for Index, Player in pairs(Players) do
            if Index <= TaggerCount then
                --Tagger
                table.insert(Taggers, Player)

            elseif Index > TaggerCount then
                --Runner
                table.insert(Runners, Player)
            end
        end
    end

    return Taggers, Runners
end

function GameController:TeleportRunners(Map, Runners)
    local TaggerSpawn = Map:FindFirstChild("TaggerSpawn")
    local RunnerSpawns = Map:FindFirstChild("RunnerSpawns")

    if TaggerSpawn and RunnerSpawns then
        for _, Runner in pairs(Runners) do
            local Character = Runner.Character or Runner.CharacterAdded:wait()
            if Character then
                local HumanoidRootPart = Character:FindFirstChild("HumanoidRootPart")
                local RandomSpawn = RunnerSpawns:GetChildren()[math.random(1, #RunnerSpawns:GetChildren())]
                HumanoidRootPart.CFrame = CFrame.new(RandomSpawn.Position + Vector3.new(0, 3, 0))
            end
        end
    else
        warn("No Tagger Spawn And/Or No Runner Spawns")
    end
end

function GameController:TaggerReseted(TaggerToMove, TaggerSpawn)
    if GameController.GamePlaying == true and GameController.TaggersHaveTeleported then
        for _, Tagger in pairs(GameController.Taggers) do
            if Tagger == TaggerToMove then
                local Character = TaggerToMove.Character or TaggerToMove.CharacterAdded:wait()
                if Character and TaggerSpawn ~= nil then
                    repeat
                        wait()
                        Character:WaitForChild("HumanoidRootPart").CFrame = CFrame.new(TaggerSpawn.Position)
                    until Character:WaitForChild("HumanoidRootPart").CFrame == CFrame.new(TaggerSpawn.Position)
                end
            end
        end
    end
end

function GameController:TeleportTaggers(Map, Taggers)
    GameController.TaggersHaveTeleported = true

    local TaggerSpawn = Map:FindFirstChild("TaggerSpawn")
    local RunnerSpawns = Map:FindFirstChild("RunnerSpawns")

    if TaggerSpawn and RunnerSpawns then
        for _, Tagger in pairs(Taggers) do
            local Character = Tagger.Character or Tagger.CharacterAdded:wait()
            if Character then
                local HumanoidRootPart = Character:FindFirstChild("HumanoidRootPart")
                HumanoidRootPart.CFrame = CFrame.new(TaggerSpawn.Position + Vector3.new(0, 3, 0))
            end

            Tagger.CharacterAdded:connect(function()
                GameController:TaggerReseted(Tagger, TaggerSpawn)
            end)
        end
    else
        warn("No Tagger Spawn And/Or No Runner Spawns")
    end
end

function GameController:SendRunnersMessage(MessageData)
    for _, Runner in pairs(GameController.Runners) do
        SendMessage:FireClient(Runner, MessageData)
    end
end


function GameController:SendTaggersMessage(MessageData)
    for _, Tagger in pairs(GameController.Taggers) do
        SendMessage:FireClient(Tagger, MessageData)
    end
end

function GameController:PlayerFrozen()
    local IceBlocks = workspace.CurrentMap:WaitForChild("IceBlocks")
    if IceBlocks then
        if #GameController.Runners == #IceBlocks:GetChildren() then
            GameController.EndGame()
        end
    end
end

function GameController:GiveTaggerAbility(Character)
    local Player = game.Players:GetPlayerFromCharacter(Character)

    for _, Tagger in pairs(GameController.Taggers) do

        if Tagger == Player then
            local TaggerAbilityScript = script:WaitForChild("TaggerAbility"):Clone()
            TaggerAbilityScript.Parent = Character:WaitForChild("HumanoidRootPart")
            TaggerAbilityScript.Disabled = false

            return TaggerAbilityScript
        end

    end
end

function GameController:GiveTaggerAbilities(Taggers)
    for _, Tagger in pairs(Taggers) do
        local Character = Tagger.Character or Tagger.CharacterAdded:wait()
        if Character then
            local TaggerAbilityScript = GameController:GiveTaggerAbility(Character)
        end

        Tagger.CharacterAdded:connect(GameController.GiveTaggerAbility)
    end
end

function GameController:EndGame()
    GameController.GamePlaying = false
    GameController.TaggersHaveTeleported = false
end

function GameController:PlayerJoining(Player)
    if GameController.GamePlaying == false and #game.Players:GetChildren() == 1 then
        SendMessage:FireClient(Player, {Message="2 players are required"})
    end
end

function GameController:PlayerLeaving(Player)
    for Index, Tagger in pairs(GameController.Taggers) do
        if Tagger == Player then
            table.remove(GameController.Taggers, Index)
        end
    end

    for Index, Runner in pairs(GameController.Runners) do
        if Runner == Player then
            table.remove(GameController.Runners, Index)
        end
    end

    if GameController.GamePlaying == true then
        if #GameController.Taggers + #GameController.Runners <= 1 then
            GameController:EndGame()
        end

        if #GameController.Taggers == 0 then
            GameController:EndGame()
        end

        if #GameController.Runners == 0 then
            GameController:EndGame()
        end
    end
end

function GameController:Initiate()
    while wait() do
        GameController.GamePlaying = false
        if #game.Players:GetPlayers() >= 2 then
            SendMessage:FireAllClients({Message="Game is starting in 5 seconds"})
            GameController.GamePlaying = true

            local Map = GameController:AddMap()

            wait(5) -- Time for the map to load in

            local Taggers, Runners = GameController:PickTeams()

            GameController.Taggers = Taggers
            GameController.Runners = Runners

            GameController:TeleportRunners(Map, Runners)

            GameController:SendTaggersMessage({Message="Prepare to freeze players!"})
            GameController:SendRunnersMessage({Message="Find a spot to hide before the taggers appear!"})

            wait(15) --Amount of time Runners have to find a hiding spot

            GameController:SendTaggersMessage({Message="Touch a player to freeze them!"})
            GameController:SendRunnersMessage({Message="Try not to get freezed by the taggers!"})

            GameController:TeleportTaggers(Map, Taggers)
            GameController:GiveTaggerAbilities(Taggers)

            local StartingTime = tick()

            while wait() do
                if tick() - StartingTime >= 60 then
                    GameController.EndGame()
                end
                if GameController.GamePlaying == false then
                    break
                end
            end

            --Move all players to lobby and reset humanoid status

            for _, Tagger in pairs(GameController.Taggers) do
                if Tagger.Character then
                    local HumanoidRootPart = Tagger.Character:FindFirstChild("HumanoidRootPart")
                    HumanoidRootPart.Anchored = false
                    if HumanoidRootPart then
                        local TaggerAbility = HumanoidRootPart:FindFirstChild("TaggerAbility")
                        if TaggerAbility then
                            TaggerAbility:Destroy()
                        end
                        HumanoidRootPart.CFrame = CFrame.new(workspace.SpawnLocation.Position)
                    end
                end
            end

            for _, Runner in pairs(GameController.Runners) do
                if Runner.Character then
                    local HumanoidRootPart = Runner.Character:FindFirstChild("HumanoidRootPart")
                    HumanoidRootPart.Anchored = false
                    if HumanoidRootPart then
                        HumanoidRootPart.Anchored = false
                        HumanoidRootPart.CFrame = CFrame.new(workspace.SpawnLocation.Position)
                    end
                end
            end

            GameController.Taggers = {}
            GameController.Runners = {}

            SendMessage:FireAllClients({Message="The game has ended!"})

            wait(10) -- Game intermission
        end
    end
end

return GameController