Dungeon Teleporter (Finished)

local Teleporter = {
    __call = function(...)
        return {...}
    end,
}
Teleporter.__index = Teleporter

local players = game:GetService("Players")
local teleportService = game:GetService("TeleportService")
local replicatedStorage = game:GetService("ReplicatedStorage")
local runService = game:GetService("RunService")

local packages = replicatedStorage.Packages
local warpNetwork = require(packages.Warp)

local leaveButtonNetwork = warpNetwork.Server("LeaveButton")

function Teleporter.new(dungeonTeleporter: Model)

    local self = setmetatable({
        _teleporter = dungeonTeleporter,
        _placeId = game.PlaceId,
        _playersTable = {},
        _playerLimit = 4,
        _activeConnections = {},
        _deathConnections = {},
        _teleporting = false
    }, Teleporter)

    --[[
    self.__newindex = function(newTable, index, value)
        newTable[index] = value
        return
    end
    --]]

    self:StartRegister()
    return self
end

function Teleporter:CleanDeathConnections()

    for _, connection: RBXScriptConnection in self._deathConnections do

        connection:Disconnect()
    end
end

function Teleporter:Teleport(actionText: TextLabel)
    local playerTable = self._playersTable
    local placeId = self._placeId

    for i = 5, 0, -1 do

        actionText.Text = "Teleporting in " .. i
        if i == 1 then

            self:CleanDeathConnections()
            local success, errorMessage = pcall(function()

                local code = teleportService:ReserveServer(placeId)
                teleportService:TeleportToPrivateServer(placeId, code, playerTable)
            end)

            if not (success) then
                print("----- Teleport Error -----")
                print(errorMessage)
                warn(errorMessage)
                print("----- Teleport Error -----")
            end

            task.wait(4)
            self._teleporting = false
            self:Update(actionText)
        end

        task.wait(1)
    end
end

function Teleporter:Update(actionText: TextLabel)

    actionText.Text = #self._playersTable.."/"..self._playerLimit
end

function Teleporter:StartRegister()

    local model = self._teleporter
    local teleportingZone = model.TeleportingZone
    local teleportData = teleportingZone.TeleportData.Value
    local aboveUi = teleportingZone.AboveUi
    local frame = aboveUi.Frame
    local actionText = frame.ActionText

    -- self._placeId = teleportingZone.PlaceId.Value

    local previousTime = tick()
    local delayEnterTime = .175

    local touchBarrier: UnionOperation = model.TouchBarrier
    self._activeConnections["Touch"] = touchBarrier.Touched:Connect(function(hit)

        local character = hit.Parent
        local player = players:GetPlayerFromCharacter(character)
        if player then

            if not (table.find(self._playersTable, player)) then

                if self._teleporting == false and tick() - previousTime >= delayEnterTime and not (#self._playersTable >= self._playerLimit) then
                    previousTime = tick()

                    character:PivotTo(teleportingZone:GetPivot())
                    table.insert(self._playersTable, player)
                    self:Update(actionText)

                    local humanoid = character.Humanoid
                    local deathConnection = "playerDied".."_"..player.UserId

                    leaveButtonNetwork:Fire(true, player, {action = "show"})

                    self._deathConnections[deathConnection] = humanoid.Died:Connect(function()

                        local found = table.find(self._playersTable, player)
                        if found then

                            table.remove(self._playersTable, found)
                            self._deathConnections[deathConnection]:Disconnect()
                            self:Update(actionText)
                        end
                    end)

                    local leaveConnection = leaveButtonNetwork:Connect(function(playerThatFired)

                        if player == playerThatFired then

                            self._deathConnections[deathConnection]:Disconnect()
                            local found = table.find(self._playersTable, player)
                            if found then
                                table.remove(self._playersTable, found)
                            end
                            if character then

                                character:PivotTo(model.Outside:GetPivot())
                            end

                            self:Update(actionText)
                        end
                    end)
                end
            end
        end
    end)

    local check = nil
    self._activeConnections["Heartbeat"] = runService.Heartbeat:Connect(function(deltaTime)

        if not (self._teleporting) then

            if #self._playersTable > 0 and not (check) then

                check = tick()
            end

            if #self._playersTable <= 0 and check then

                check = nil
            end

            if check then
                if tick() - check > 10 then

                    check = nil
                    self._teleporting = true

                    for _, player in self._playersTable do

                        leaveButtonNetwork:Fire(true, player, {action = "hide"})
                    end

                    self:Teleport(actionText)
                end
            end
        end
    end)

    self._activeConnections["PlayerRemoving"] = players.PlayerRemoving:Connect(function(player)

        local found = table.find(self._playersTable, player)
        if found then

            table.remove(self._playersTable, found)
            self:Update(actionText)
        end
    end)

    local destroyConnection
    destroyConnection = model.Destroying:Connect(function()

        for _, connection: RBXScriptConnection in self._activeConnections do

            connection:Disconnect()
            destroyConnection:Disconnect()
        end
    end)
end

return Teleporter