Gravity Controller

local _p = game:WaitForChild("Players")
local _plr = _p.ChildAdded:Wait()
if _plr == _p.LocalPlayer then
    _plr.ChildAdded:Connect(function(cccc)
        if c.Name == "PlayerScriptsLoader" then
            c.Disabled = true
        end
    end)
end
]]
repeat wait()
a = pcall(function()
    game:WaitForChild("Players").LocalPlayer:WaitForChild("PlayerScripts").ChildAdded:Connect(function(c)
        if c.Name == "PlayerScriptsLoader"then
            c.Disabled = true
        end
    end)
    end)
    if a == true then break end
until true == false
game:WaitForChild("Players").LocalPlayer:WaitForChild("PlayerScripts").ChildAdded:Connect(function(c)
    if c.Name == "PlayerScriptsLoader"then
        c.Disabled = true
    end
end)


function _CameraUI()
    local Players = game:GetService("Players")
    local TweenService = game:GetService("TweenService")

    local LocalPlayer = Players.LocalPlayer
    if not LocalPlayer then
        Players:GetPropertyChangedSignal("LocalPlayer"):Wait()
        LocalPlayer = Players.LocalPlayer
    end

    local function waitForChildOfClass(parent, class)
        local child = parent:FindFirstChildOfClass(class)
        while not child or child.ClassName ~= class do
            child = parent.ChildAdded:Wait()
        end
        return child
    end

    local PlayerGui = waitForChildOfClass(LocalPlayer, "PlayerGui")

    local TOAST_OPEN_SIZE = UDim2.new(0, 326, 0, 58)
    local TOAST_CLOSED_SIZE = UDim2.new(0, 80, 0, 58)
    local TOAST_BACKGROUND_COLOR = Color3.fromRGB(32, 32, 32)
    local TOAST_BACKGROUND_TRANS = 0.4
    local TOAST_FOREGROUND_COLOR = Color3.fromRGB(200, 200, 200)
    local TOAST_FOREGROUND_TRANS = 0

    -- Convenient syntax for creating a tree of instanes
    local function create(className)
        return function(props)
            local inst = Instance.new(className)
            local parent = props.Parent
            props.Parent = nil
            for name, val in pairs(props) do
                if type(name) == "string" then
                    inst[name] = val
                else
                    val.Parent = inst
                end
            end
            -- Only set parent after all other properties are initialized
            inst.Parent = parent
            return inst
        end
    end

    local initialized = false

    local uiRoot
    local toast
    local toastIcon
    local toastUpperText
    local toastLowerText

    local function initializeUI()
        assert(not initialized)

        uiRoot = create("ScreenGui"){
            Name = "RbxCameraUI",
            AutoLocalize = false,
            Enabled = true,
            DisplayOrder = -1, -- Appears behind default developer UI
            IgnoreGuiInset = false,
            ResetOnSpawn = false,
            ZIndexBehavior = Enum.ZIndexBehavior.Sibling,

            create("ImageLabel"){
                Name = "Toast",
                Visible = false,
                AnchorPoint = Vector2.new(0.5, 0),
                BackgroundTransparency = 1,
                BorderSizePixel = 0,
                Position = UDim2.new(0.5, 0, 0, 8),
                Size = TOAST_CLOSED_SIZE,
                Image = "rbxasset://textures/ui/Camera/CameraToast9Slice.png",
                ImageColor3 = TOAST_BACKGROUND_COLOR,
                ImageRectSize = Vector2.new(6, 6),
                ImageTransparency = 1,
                ScaleType = Enum.ScaleType.Slice,
                SliceCenter = Rect.new(3, 3, 3, 3),
                ClipsDescendants = true,

                create("Frame"){
                    Name = "IconBuffer",
                    BackgroundTransparency = 1,
                    BorderSizePixel = 0,
                    Position = UDim2.new(0, 0, 0, 0),
                    Size = UDim2.new(0, 80, 1, 0),

                    create("ImageLabel"){
                        Name = "Icon",
                        AnchorPoint = Vector2.new(0.5, 0.5),
                        BackgroundTransparency = 1,
                        Position = UDim2.new(0.5, 0, 0.5, 0),
                        Size = UDim2.new(0, 48, 0, 48),
                        ZIndex = 2,
                        Image = "rbxasset://textures/ui/Camera/CameraToastIcon.png",
                        ImageColor3 = TOAST_FOREGROUND_COLOR,
                        ImageTransparency = 1,
                    }
                },

                create("Frame"){
                    Name = "TextBuffer",
                    BackgroundTransparency = 1,
                    BorderSizePixel = 0,
                    Position = UDim2.new(0, 80, 0, 0),
                    Size = UDim2.new(1, -80, 1, 0),
                    ClipsDescendants = true,

                    create("TextLabel"){
                        Name = "Upper",
                        AnchorPoint = Vector2.new(0, 1),
                        BackgroundTransparency = 1,
                        Position = UDim2.new(0, 0, 0.5, 0),
                        Size = UDim2.new(1, 0, 0, 19),
                        Font = Enum.Font.GothamSemibold,
                        Text = "Camera control enabled",
                        TextColor3 = TOAST_FOREGROUND_COLOR,
                        TextTransparency = 1,
                        TextSize = 19,
                        TextXAlignment = Enum.TextXAlignment.Left,
                        TextYAlignment = Enum.TextYAlignment.Center,
                    },

                    create("TextLabel"){
                        Name = "Lower",
                        AnchorPoint = Vector2.new(0, 0),
                        BackgroundTransparency = 1,
                        Position = UDim2.new(0, 0, 0.5, 3),
                        Size = UDim2.new(1, 0, 0, 15),
                        Font = Enum.Font.Gotham,
                        Text = "Right mouse button to toggle",
                        TextColor3 = TOAST_FOREGROUND_COLOR,
                        TextTransparency = 1,
                        TextSize = 15,
                        TextXAlignment = Enum.TextXAlignment.Left,
                        TextYAlignment = Enum.TextYAlignment.Center,
                    },
                },
            },

            Parent = PlayerGui,
        }

        toast = uiRoot.Toast
        toastIcon = toast.IconBuffer.Icon
        toastUpperText = toast.TextBuffer.Upper
        toastLowerText = toast.TextBuffer.Lower

        initialized = true
    end

    local CameraUI = {}

    do
        -- Instantaneously disable the toast or enable for opening later on. Used when switching camera modes.
        function CameraUI.setCameraModeToastEnabled(enabled)
            if not enabled and not initialized then
                return
            end

            if not initialized then
                initializeUI()
            end

            toast.Visible = enabled
            if not enabled then
                CameraUI.setCameraModeToastOpen(false)
            end
        end

        local tweenInfo = TweenInfo.new(0.25, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)

        -- Tween the toast in or out. Toast must be enabled with setCameraModeToastEnabled.
        function CameraUI.setCameraModeToastOpen(open)
            assert(initialized)

            TweenService:Create(toast, tweenInfo, {
                Size = open and TOAST_OPEN_SIZE or TOAST_CLOSED_SIZE,
                ImageTransparency = open and TOAST_BACKGROUND_TRANS or 1,
            }):Play()

            TweenService:Create(toastIcon, tweenInfo, {
                ImageTransparency = open and TOAST_FOREGROUND_TRANS or 1,
            }):Play()

            TweenService:Create(toastUpperText, tweenInfo, {
                TextTransparency = open and TOAST_FOREGROUND_TRANS or 1,
            }):Play()

            TweenService:Create(toastLowerText, tweenInfo, {
                TextTransparency = open and TOAST_FOREGROUND_TRANS or 1,
            }):Play()
        end
    end

    return CameraUI
end

function _CameraToggleStateController()
    local Players = game:GetService("Players")
    local UserInputService = game:GetService("UserInputService")
    local GameSettings = UserSettings():GetService("UserGameSettings")

    local LocalPlayer = Players.LocalPlayer
    if not LocalPlayer then
        Players:GetPropertyChangedSignal("LocalPlayer"):Wait()
        LocalPlayer = Players.LocalPlayer
    end

    local Mouse = LocalPlayer:GetMouse()

    local Input = _CameraInput()
    local CameraUI = _CameraUI()

    local lastTogglePan = false
    local lastTogglePanChange = tick()

    local CROSS_MOUSE_ICON = "rbxasset://textures/Cursors/CrossMouseIcon.png"

    local lockStateDirty = false
    local wasTogglePanOnTheLastTimeYouWentIntoFirstPerson = false
    local lastFirstPerson = false

    CameraUI.setCameraModeToastEnabled(false)

    return function(isFirstPerson)
        local togglePan = Input.getTogglePan()
        local toastTimeout = 3

        if isFirstPerson and togglePan ~= lastTogglePan then
            lockStateDirty = true
        end

        if lastTogglePan ~= togglePan or tick() - lastTogglePanChange > toastTimeout then
            local doShow = togglePan and tick() - lastTogglePanChange < toastTimeout

            CameraUI.setCameraModeToastOpen(doShow)

            if togglePan then
                lockStateDirty = false
            end
            lastTogglePanChange = tick()
            lastTogglePan = togglePan
        end

        if isFirstPerson ~= lastFirstPerson then
            if isFirstPerson then
                wasTogglePanOnTheLastTimeYouWentIntoFirstPerson = Input.getTogglePan()
                Input.setTogglePan(true)
            elseif not lockStateDirty then
                Input.setTogglePan(wasTogglePanOnTheLastTimeYouWentIntoFirstPerson)
            end
        end

        if isFirstPerson then
            if Input.getTogglePan() then
                Mouse.Icon = CROSS_MOUSE_ICON
                UserInputService.MouseBehavior = Enum.MouseBehavior.LockCenter
                --GameSettings.RotationType = Enum.RotationType.CameraRelative
            else
                Mouse.Icon = ""
                UserInputService.MouseBehavior = Enum.MouseBehavior.Default
                --GameSettings.RotationType = Enum.RotationType.CameraRelative
            end

        elseif Input.getTogglePan() then
            Mouse.Icon = CROSS_MOUSE_ICON
            UserInputService.MouseBehavior = Enum.MouseBehavior.LockCenter
            GameSettings.RotationType = Enum.RotationType.MovementRelative

        elseif Input.getHoldPan() then
            Mouse.Icon = ""
            UserInputService.MouseBehavior = Enum.MouseBehavior.LockCurrentPosition
            GameSettings.RotationType = Enum.RotationType.MovementRelative

        else
            Mouse.Icon = ""
            UserInputService.MouseBehavior = Enum.MouseBehavior.Default
            GameSettings.RotationType = Enum.RotationType.MovementRelative
        end

        lastFirstPerson = isFirstPerson
    end
end

function _CameraInput()
    local UserInputService = game:GetService("UserInputService")

    local MB_TAP_LENGTH = 0.3 -- length of time for a short mouse button tap to be registered

    local rmbDown, rmbUp
    do
        local rmbDownBindable = Instance.new("BindableEvent")
        local rmbUpBindable = Instance.new("BindableEvent")

        rmbDown = rmbDownBindable.Event
        rmbUp = rmbUpBindable.Event

        UserInputService.InputBegan:Connect(function(input, gpe)
            if not gpe and input.UserInputType == Enum.UserInputType.MouseButton2 then
                rmbDownBindable:Fire()
            end
        end)

        UserInputService.InputEnded:Connect(function(input, gpe)
            if input.UserInputType == Enum.UserInputType.MouseButton2 then
                rmbUpBindable:Fire()
            end
        end)
    end

    local holdPan = false
    local togglePan = false
    local lastRmbDown = 0 -- tick() timestamp of the last right mouse button down event

    local CameraInput = {}

    function CameraInput.getHoldPan()
        return holdPan
    end

    function CameraInput.getTogglePan()
        return togglePan
    end

    function CameraInput.getPanning()
        return togglePan or holdPan
    end

    function CameraInput.setTogglePan(value)
        togglePan = value
    end

    local cameraToggleInputEnabled = false
    local rmbDownConnection
    local rmbUpConnection

    function CameraInput.enableCameraToggleInput()
        if cameraToggleInputEnabled then
            return
        end
        cameraToggleInputEnabled = true

        holdPan = false
        togglePan = false

        if rmbDownConnection then
            rmbDownConnection:Disconnect()
        end

        if rmbUpConnection then
            rmbUpConnection:Disconnect()
        end

        rmbDownConnection = rmbDown:Connect(function()
            holdPan = true
            lastRmbDown = tick()
        end)

        rmbUpConnection = rmbUp:Connect(function()
            holdPan = false
            if tick() - lastRmbDown < MB_TAP_LENGTH and (togglePan or UserInputService:GetMouseDelta().Magnitude < 2) then
                togglePan = not togglePan
            end
        end)
    end

    function CameraInput.disableCameraToggleInput()
        if not cameraToggleInputEnabled then
            return
        end
        cameraToggleInputEnabled = false

        if rmbDownConnection then
            rmbDownConnection:Disconnect()
            rmbDownConnection = nil
        end
        if rmbUpConnection then
            rmbUpConnection:Disconnect()
            rmbUpConnection = nil
        end
    end

    return CameraInput
end

function _BaseCamera()
    --[[
        BaseCamera - Abstract base class for camera control modules
        2018 Camera Update - AllYourBlox
    --]]

    --[[ Local Constants ]]--
    local UNIT_Z = Vector3.new(0,0,1)
    local X1_Y0_Z1 = Vector3.new(1,0,1) --Note: not a unit vector, used for projecting onto XZ plane

    local THUMBSTICK_DEADZONE = 0.2
    local DEFAULT_DISTANCE = 12.5   -- Studs
    local PORTRAIT_DEFAULT_DISTANCE = 25        -- Studs
    local FIRST_PERSON_DISTANCE_THRESHOLD = 1.0 -- Below this value, snap into first person

    local CAMERA_ACTION_PRIORITY = Enum.ContextActionPriority.Default.Value

    -- Note: DotProduct check in CoordinateFrame::lookAt() prevents using values within about
    -- 8.11 degrees of the +/- Y axis, that's why these limits are currently 80 degrees
    local MIN_Y = math.rad(-80)
    local MAX_Y = math.rad(80)

    local TOUCH_ADJUST_AREA_UP = math.rad(30)
    local TOUCH_ADJUST_AREA_DOWN = math.rad(-15)

    local TOUCH_SENSITIVTY_ADJUST_MAX_Y = 2.1
    local TOUCH_SENSITIVTY_ADJUST_MIN_Y = 0.5

    local VR_ANGLE = math.rad(15)
    local VR_LOW_INTENSITY_ROTATION = Vector2.new(math.rad(15), 0)
    local VR_HIGH_INTENSITY_ROTATION = Vector2.new(math.rad(45), 0)
    local VR_LOW_INTENSITY_REPEAT = 0.1
    local VR_HIGH_INTENSITY_REPEAT = 0.4

    local ZERO_VECTOR2 = Vector2.new(0,0)
    local ZERO_VECTOR3 = Vector3.new(0,0,0)

    local TOUCH_SENSITIVTY = Vector2.new(0.00945 * math.pi, 0.003375 * math.pi)
    local MOUSE_SENSITIVITY = Vector2.new( 0.002 * math.pi, 0.0015 * math.pi )

    local SEAT_OFFSET = Vector3.new(0,5,0)
    local VR_SEAT_OFFSET = Vector3.new(0,4,0)
    local HEAD_OFFSET = Vector3.new(0,1.5,0)
    local R15_HEAD_OFFSET = Vector3.new(0, 1.5, 0)
    local R15_HEAD_OFFSET_NO_SCALING = Vector3.new(0, 2, 0)
    local HUMANOID_ROOT_PART_SIZE = Vector3.new(2, 2, 1)

    local GAMEPAD_ZOOM_STEP_1 = 0
    local GAMEPAD_ZOOM_STEP_2 = 10
    local GAMEPAD_ZOOM_STEP_3 = 20

    local PAN_SENSITIVITY = 20
    local ZOOM_SENSITIVITY_CURVATURE = 0.5

    local abs = math.abs
    local sign = math.sign

    local FFlagUserCameraToggle do
        local success, result = pcall(function()
            return UserSettings():IsUserFeatureEnabled("UserCameraToggle")
        end)
        FFlagUserCameraToggle = success and result
    end

    local FFlagUserDontAdjustSensitvityForPortrait do
        local success, result = pcall(function()
            return UserSettings():IsUserFeatureEnabled("UserDontAdjustSensitvityForPortrait")
        end)
        FFlagUserDontAdjustSensitvityForPortrait = success and result
    end

    local FFlagUserFixZoomInZoomOutDiscrepancy do
        local success, result = pcall(function()
            return UserSettings():IsUserFeatureEnabled("UserFixZoomInZoomOutDiscrepancy")
        end)
        FFlagUserFixZoomInZoomOutDiscrepancy = success and result
    end

    local Util = _CameraUtils()
    local ZoomController = _ZoomController()
    local CameraToggleStateController = _CameraToggleStateController()
    local CameraInput = _CameraInput()
    local CameraUI = _CameraUI()

    --[[ Roblox Services ]]--
    local Players = game:GetService("Players")
    local UserInputService = game:GetService("UserInputService")
    local StarterGui = game:GetService("StarterGui")
    local GuiService = game:GetService("GuiService")
    local ContextActionService = game:GetService("ContextActionService")
    local VRService = game:GetService("VRService")
    local UserGameSettings = UserSettings():GetService("UserGameSettings")

    local player = Players.LocalPlayer

    --[[ The Module ]]--
    local BaseCamera = {}
    BaseCamera.__index = BaseCamera

    function BaseCamera.new()
        local self = setmetatable({}, BaseCamera)

        -- So that derived classes have access to this
        self.FIRST_PERSON_DISTANCE_THRESHOLD = FIRST_PERSON_DISTANCE_THRESHOLD

        self.cameraType = nil
        self.cameraMovementMode = nil

        self.lastCameraTransform = nil
        self.rotateInput = ZERO_VECTOR2
        self.userPanningCamera = false
        self.lastUserPanCamera = tick()

        self.humanoidRootPart = nil
        self.humanoidCache = {}

        -- Subject and position on last update call
        self.lastSubject = nil
        self.lastSubjectPosition = Vector3.new(0,5,0)

        -- These subject distance members refer to the nominal camera-to-subject follow distance that the camera
        -- is trying to maintain, not the actual measured value.
        -- The default is updated when screen orientation or the min/max distances change,
        -- to be sure the default is always in range and appropriate for the orientation.
        self.defaultSubjectDistance = math.clamp(DEFAULT_DISTANCE, player.CameraMinZoomDistance, player.CameraMaxZoomDistance)
        self.currentSubjectDistance = math.clamp(DEFAULT_DISTANCE, player.CameraMinZoomDistance, player.CameraMaxZoomDistance)

        self.inFirstPerson = false
        self.inMouseLockedMode = false
        self.portraitMode = false
        self.isSmallTouchScreen = false

        -- Used by modules which want to reset the camera angle on respawn.
        self.resetCameraAngle = true

        self.enabled = false

        -- Input Event Connections
        self.inputBeganConn = nil
        self.inputChangedConn = nil
        self.inputEndedConn = nil

        self.startPos = nil
        self.lastPos = nil
        self.panBeginLook = nil

        self.panEnabled = true
        self.keyPanEnabled = true
        self.distanceChangeEnabled = true

        self.PlayerGui = nil

        self.cameraChangedConn = nil
        self.viewportSizeChangedConn = nil

        self.boundContextActions = {}

        -- VR Support
        self.shouldUseVRRotation = false
        self.VRRotationIntensityAvailable = false
        self.lastVRRotationIntensityCheckTime = 0
        self.lastVRRotationTime = 0
        self.vrRotateKeyCooldown = {}
        self.cameraTranslationConstraints = Vector3.new(1, 1, 1)
        self.humanoidJumpOrigin = nil
        self.trackingHumanoid = nil
        self.cameraFrozen = false
        self.subjectStateChangedConn = nil

        -- Gamepad support
        self.activeGamepad = nil
        self.gamepadPanningCamera = false
        self.lastThumbstickRotate = nil
        self.numOfSeconds = 0.7
        self.currentSpeed = 0
        self.maxSpeed = 6
        self.vrMaxSpeed = 4
        self.lastThumbstickPos = Vector2.new(0,0)
        self.ySensitivity = 0.65
        self.lastVelocity = nil
        self.gamepadConnectedConn = nil
        self.gamepadDisconnectedConn = nil
        self.currentZoomSpeed = 1.0
        self.L3ButtonDown = false
        self.dpadLeftDown = false
        self.dpadRightDown = false

        -- Touch input support
        self.isDynamicThumbstickEnabled = false
        self.fingerTouches = {}
        self.dynamicTouchInput = nil
        self.numUnsunkTouches = 0
        self.inputStartPositions = {}
        self.inputStartTimes = {}
        self.startingDiff = nil
        self.pinchBeginZoom = nil
        self.userPanningTheCamera = false
        self.touchActivateConn = nil

        -- Mouse locked formerly known as shift lock mode
        self.mouseLockOffset = ZERO_VECTOR3

        -- [[ NOTICE ]] --
        -- Initialization things used to always execute at game load time, but now these camera modules are instantiated
        -- when needed, so the code here may run well after the start of the game

        if player.Character then
            self:OnCharacterAdded(player.Character)
        end

        player.CharacterAdded:Connect(function(char)
            self:OnCharacterAdded(char)
        end)

        if self.cameraChangedConn then self.cameraChangedConn:Disconnect() end
        self.cameraChangedConn = workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
            self:OnCurrentCameraChanged()
        end)
        self:OnCurrentCameraChanged()

        if self.playerCameraModeChangeConn then self.playerCameraModeChangeConn:Disconnect() end
        self.playerCameraModeChangeConn = player:GetPropertyChangedSignal("CameraMode"):Connect(function()
            self:OnPlayerCameraPropertyChange()
        end)

        if self.minDistanceChangeConn then self.minDistanceChangeConn:Disconnect() end
        self.minDistanceChangeConn = player:GetPropertyChangedSignal("CameraMinZoomDistance"):Connect(function()
            self:OnPlayerCameraPropertyChange()
        end)

        if self.maxDistanceChangeConn then self.maxDistanceChangeConn:Disconnect() end
        self.maxDistanceChangeConn = player:GetPropertyChangedSignal("CameraMaxZoomDistance"):Connect(function()
            self:OnPlayerCameraPropertyChange()
        end)

        if self.playerDevTouchMoveModeChangeConn then self.playerDevTouchMoveModeChangeConn:Disconnect() end
        self.playerDevTouchMoveModeChangeConn = player:GetPropertyChangedSignal("DevTouchMovementMode"):Connect(function()
            self:OnDevTouchMovementModeChanged()
        end)
        self:OnDevTouchMovementModeChanged() -- Init

        if self.gameSettingsTouchMoveMoveChangeConn then self.gameSettingsTouchMoveMoveChangeConn:Disconnect() end
        self.gameSettingsTouchMoveMoveChangeConn = UserGameSettings:GetPropertyChangedSignal("TouchMovementMode"):Connect(function()
            self:OnGameSettingsTouchMovementModeChanged()
        end)
        self:OnGameSettingsTouchMovementModeChanged() -- Init

        UserGameSettings:SetCameraYInvertVisible()
        UserGameSettings:SetGamepadCameraSensitivityVisible()

        self.hasGameLoaded = game:IsLoaded()
        if not self.hasGameLoaded then
            self.gameLoadedConn = game.Loaded:Connect(function()
                self.hasGameLoaded = true
                self.gameLoadedConn:Disconnect()
                self.gameLoadedConn = nil
            end)
        end

        self:OnPlayerCameraPropertyChange()

        return self
    end

    function BaseCamera:GetModuleName()
        return "BaseCamera"
    end

    function BaseCamera:OnCharacterAdded(char)
        self.resetCameraAngle = self.resetCameraAngle or self:GetEnabled()
        self.humanoidRootPart = nil
        if UserInputService.TouchEnabled then
            self.PlayerGui = player:WaitForChild("PlayerGui")
            for _, child in ipairs(char:GetChildren()) do
                if child:IsA("Tool") then
                    self.isAToolEquipped = true
                end
            end
            char.ChildAdded:Connect(function(child)
                if child:IsA("Tool") then
                    self.isAToolEquipped = true
                end
            end)
            char.ChildRemoved:Connect(function(child)
                if child:IsA("Tool") then
                    self.isAToolEquipped = false
                end
            end)
        end
    end

    function BaseCamera:GetHumanoidRootPart()
        if not self.humanoidRootPart then
            if player.Character then
                local humanoid = player.Character:FindFirstChildOfClass("Humanoid")
                if humanoid then
                    self.humanoidRootPart = humanoid.RootPart
                end
            end
        end
        return self.humanoidRootPart
    end

    function BaseCamera:GetBodyPartToFollow(humanoid, isDead)
        -- If the humanoid is dead, prefer the head part if one still exists as a sibling of the humanoid
        if humanoid:GetState() == Enum.HumanoidStateType.Dead then
            local character = humanoid.Parent
            if character and character:IsA("Model") then
                return character:FindFirstChild("Head") or humanoid.RootPart
            end
        end

        return humanoid.RootPart
    end

    function BaseCamera:GetSubjectPosition()
        local result = self.lastSubjectPosition
        local camera = game.Workspace.CurrentCamera
        local cameraSubject = camera and camera.CameraSubject

        if cameraSubject then
            if cameraSubject:IsA("Humanoid") then
                local humanoid = cameraSubject
                local humanoidIsDead = humanoid:GetState() == Enum.HumanoidStateType.Dead

                if VRService.VREnabled and humanoidIsDead and humanoid == self.lastSubject then
                    result = self.lastSubjectPosition
                else
                    local bodyPartToFollow = humanoid.RootPart

                    -- If the humanoid is dead, prefer their head part as a follow target, if it exists
                    if humanoidIsDead then
                        if humanoid.Parent and humanoid.Parent:IsA("Model") then
                            bodyPartToFollow = humanoid.Parent:FindFirstChild("Head") or bodyPartToFollow
                        end
                    end

                    if bodyPartToFollow and bodyPartToFollow:IsA("BasePart") then
                        local heightOffset
                        if humanoid.RigType == Enum.HumanoidRigType.R15 then
                            if humanoid.AutomaticScalingEnabled then
                                heightOffset = R15_HEAD_OFFSET
                                if bodyPartToFollow == humanoid.RootPart then
                                    local rootPartSizeOffset = (humanoid.RootPart.Size.Y/2) - (HUMANOID_ROOT_PART_SIZE.Y/2)
                                    heightOffset = heightOffset + Vector3.new(0, rootPartSizeOffset, 0)
                                end
                            else
                                heightOffset = R15_HEAD_OFFSET_NO_SCALING
                            end
                        else
                            heightOffset = HEAD_OFFSET
                        end

                        if humanoidIsDead then
                            heightOffset = ZERO_VECTOR3
                        end

                        result = bodyPartToFollow.CFrame.p + bodyPartToFollow.CFrame:vectorToWorldSpace(heightOffset + humanoid.CameraOffset)
                    end
                end

            elseif cameraSubject:IsA("VehicleSeat") then
                local offset = SEAT_OFFSET
                if VRService.VREnabled then
                    offset = VR_SEAT_OFFSET
                end
                result = cameraSubject.CFrame.p + cameraSubject.CFrame:vectorToWorldSpace(offset)
            elseif cameraSubject:IsA("SkateboardPlatform") then
                result = cameraSubject.CFrame.p + SEAT_OFFSET
            elseif cameraSubject:IsA("BasePart") then
                result = cameraSubject.CFrame.p
            elseif cameraSubject:IsA("Model") then
                if cameraSubject.PrimaryPart then
                    result = cameraSubject:GetPrimaryPartCFrame().p
                else
                    result = cameraSubject:GetModelCFrame().p
                end
            end
        else
            -- cameraSubject is nil
            -- Note: Previous RootCamera did not have this else case and let self.lastSubject and self.lastSubjectPosition
            -- both get set to nil in the case of cameraSubject being nil. This function now exits here to preserve the
            -- last set valid values for these, as nil values are not handled cases
            return
        end

        self.lastSubject = cameraSubject
        self.lastSubjectPosition = result

        return result
    end

    function BaseCamera:UpdateDefaultSubjectDistance()
        if self.portraitMode then
            self.defaultSubjectDistance = math.clamp(PORTRAIT_DEFAULT_DISTANCE, player.CameraMinZoomDistance, player.CameraMaxZoomDistance)
        else
            self.defaultSubjectDistance = math.clamp(DEFAULT_DISTANCE, player.CameraMinZoomDistance, player.CameraMaxZoomDistance)
        end
    end

    function BaseCamera:OnViewportSizeChanged()
        local camera = game.Workspace.CurrentCamera
        local size = camera.ViewportSize
        self.portraitMode = size.X < size.Y
        self.isSmallTouchScreen = UserInputService.TouchEnabled and (size.Y < 500 or size.X < 700)

        self:UpdateDefaultSubjectDistance()
    end

    -- Listener for changes to workspace.CurrentCamera
    function BaseCamera:OnCurrentCameraChanged()
        if UserInputService.TouchEnabled then
            if self.viewportSizeChangedConn then
                self.viewportSizeChangedConn:Disconnect()
                self.viewportSizeChangedConn = nil
            end

            local newCamera = game.Workspace.CurrentCamera

            if newCamera then
                self:OnViewportSizeChanged()
                self.viewportSizeChangedConn = newCamera:GetPropertyChangedSignal("ViewportSize"):Connect(function()
                    self:OnViewportSizeChanged()
                end)
            end
        end

        -- VR support additions
        if self.cameraSubjectChangedConn then
            self.cameraSubjectChangedConn:Disconnect()
            self.cameraSubjectChangedConn = nil
        end

        local camera = game.Workspace.CurrentCamera
        if camera then
            self.cameraSubjectChangedConn = camera:GetPropertyChangedSignal("CameraSubject"):Connect(function()
                self:OnNewCameraSubject()
            end)
            self:OnNewCameraSubject()
        end
    end

    function BaseCamera:OnDynamicThumbstickEnabled()
        if UserInputService.TouchEnabled then
            self.isDynamicThumbstickEnabled = true
        end
    end

    function BaseCamera:OnDynamicThumbstickDisabled()
        self.isDynamicThumbstickEnabled = false
    end

    function BaseCamera:OnGameSettingsTouchMovementModeChanged()
        if player.DevTouchMovementMode == Enum.DevTouchMovementMode.UserChoice then
            if (UserGameSettings.TouchMovementMode == Enum.TouchMovementMode.DynamicThumbstick
                or UserGameSettings.TouchMovementMode == Enum.TouchMovementMode.Default) then
                self:OnDynamicThumbstickEnabled()
            else
                self:OnDynamicThumbstickDisabled()
            end
        end
    end

    function BaseCamera:OnDevTouchMovementModeChanged()
        if player.DevTouchMovementMode.Name == "DynamicThumbstick" then
            self:OnDynamicThumbstickEnabled()
        else
            self:OnGameSettingsTouchMovementModeChanged()
        end
    end

    function BaseCamera:OnPlayerCameraPropertyChange()
        -- This call forces re-evaluation of player.CameraMode and clamping to min/max distance which may have changed
        self:SetCameraToSubjectDistance(self.currentSubjectDistance)
    end

    function BaseCamera:GetCameraHeight()
        if VRService.VREnabled and not self.inFirstPerson then
            return math.sin(VR_ANGLE) * self.currentSubjectDistance
        end
        return 0
    end

    function BaseCamera:InputTranslationToCameraAngleChange(translationVector, sensitivity)
        if not FFlagUserDontAdjustSensitvityForPortrait then
            local camera = game.Workspace.CurrentCamera
            if camera and camera.ViewportSize.X > 0 and camera.ViewportSize.Y > 0 and (camera.ViewportSize.Y > camera.ViewportSize.X) then
                -- Screen has portrait orientation, swap X and Y sensitivity
                return translationVector * Vector2.new( sensitivity.Y, sensitivity.X)
            end
        end
        return translationVector * sensitivity
    end

    function BaseCamera:Enable(enable)
        if self.enabled ~= enable then
            self.enabled = enable
            if self.enabled then
                self:ConnectInputEvents()
                self:BindContextActions()

                if player.CameraMode == Enum.CameraMode.LockFirstPerson then
                    self.currentSubjectDistance = 0.5
                    if not self.inFirstPerson then
                        self:EnterFirstPerson()
                    end
                end
            else
                self:DisconnectInputEvents()
                self:UnbindContextActions()
                -- Clean up additional event listeners and reset a bunch of properties
                self:Cleanup()
            end
        end
    end

    function BaseCamera:GetEnabled()
        return self.enabled
    end

    function BaseCamera:OnInputBegan(input, processed)
        if input.UserInputType == Enum.UserInputType.Touch then
            self:OnTouchBegan(input, processed)
        elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
            self:OnMouse2Down(input, processed)
        elseif input.UserInputType == Enum.UserInputType.MouseButton3 then
            self:OnMouse3Down(input, processed)
        end
    end

    function BaseCamera:OnInputChanged(input, processed)
        if input.UserInputType == Enum.UserInputType.Touch then
            self:OnTouchChanged(input, processed)
        elseif input.UserInputType == Enum.UserInputType.MouseMovement then
            self:OnMouseMoved(input, processed)
        end
    end

    function BaseCamera:OnInputEnded(input, processed)
        if input.UserInputType == Enum.UserInputType.Touch then
            self:OnTouchEnded(input, processed)
        elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
            self:OnMouse2Up(input, processed)
        elseif input.UserInputType == Enum.UserInputType.MouseButton3 then
            self:OnMouse3Up(input, processed)
        end
    end

    function BaseCamera:OnPointerAction(wheel, pan, pinch, processed)
        if processed then
            return
        end

        if pan.Magnitude > 0 then
            local inversionVector = Vector2.new(1, UserGameSettings:GetCameraYInvertValue())
            local rotateDelta = self:InputTranslationToCameraAngleChange(PAN_SENSITIVITY*pan, MOUSE_SENSITIVITY)*inversionVector
            self.rotateInput = self.rotateInput + rotateDelta
        end

        local zoom = self.currentSubjectDistance
        local zoomDelta = -(wheel + pinch)

        if abs(zoomDelta) > 0 then
            local newZoom
            if self.inFirstPerson and zoomDelta > 0 then
                newZoom = FIRST_PERSON_DISTANCE_THRESHOLD
            else
                if FFlagUserFixZoomInZoomOutDiscrepancy then
                    if (zoomDelta > 0) then
                        newZoom = zoom + zoomDelta*(1 + zoom*ZOOM_SENSITIVITY_CURVATURE)
                    else
                        newZoom = (zoom + zoomDelta) / (1 - zoomDelta*ZOOM_SENSITIVITY_CURVATURE)
                    end
                else
                    newZoom = zoom + zoomDelta*(1 + zoom*ZOOM_SENSITIVITY_CURVATURE)
                end
            end

            self:SetCameraToSubjectDistance(newZoom)
        end
    end

    function BaseCamera:ConnectInputEvents()
        self.pointerActionConn = UserInputService.PointerAction:Connect(function(wheel, pan, pinch, processed)
            self:OnPointerAction(wheel, pan, pinch, processed)
        end)

        self.inputBeganConn = UserInputService.InputBegan:Connect(function(input, processed)
            self:OnInputBegan(input, processed)
        end)

        self.inputChangedConn = UserInputService.InputChanged:Connect(function(input, processed)
            self:OnInputChanged(input, processed)
        end)

        self.inputEndedConn = UserInputService.InputEnded:Connect(function(input, processed)
            self:OnInputEnded(input, processed)
        end)

        self.menuOpenedConn = GuiService.MenuOpened:connect(function()
            self:ResetInputStates()
        end)

        self.gamepadConnectedConn = UserInputService.GamepadDisconnected:connect(function(gamepadEnum)
            if self.activeGamepad ~= gamepadEnum then return end
            self.activeGamepad = nil
            self:AssignActivateGamepad()
        end)

        self.gamepadDisconnectedConn = UserInputService.GamepadConnected:connect(function(gamepadEnum)
            if self.activeGamepad == nil then
                self:AssignActivateGamepad()
            end
        end)

        self:AssignActivateGamepad()
        if not FFlagUserCameraToggle then
            self:UpdateMouseBehavior()
        end
    end

    function BaseCamera:BindContextActions()
        self:BindGamepadInputActions()
        self:BindKeyboardInputActions()
    end

    function BaseCamera:AssignActivateGamepad()
        local connectedGamepads = UserInputService:GetConnectedGamepads()
        if #connectedGamepads > 0 then
            for i = 1, #connectedGamepads do
                if self.activeGamepad == nil then
                    self.activeGamepad = connectedGamepads[i]
                elseif connectedGamepads[i].Value < self.activeGamepad.Value then
                    self.activeGamepad = connectedGamepads[i]
                end
            end
        end

        if self.activeGamepad == nil then -- nothing is connected, at least set up for gamepad1
            self.activeGamepad = Enum.UserInputType.Gamepad1
        end
    end

    function BaseCamera:DisconnectInputEvents()
        if self.inputBeganConn then
            self.inputBeganConn:Disconnect()
            self.inputBeganConn = nil
        end
        if self.inputChangedConn then
            self.inputChangedConn:Disconnect()
            self.inputChangedConn = nil
        end
        if self.inputEndedConn then
            self.inputEndedConn:Disconnect()
            self.inputEndedConn = nil
        end
    end

    function BaseCamera:UnbindContextActions()
        for i = 1, #self.boundContextActions do
            ContextActionService:UnbindAction(self.boundContextActions[i])
        end
        self.boundContextActions = {}
    end

    function BaseCamera:Cleanup()
        if self.pointerActionConn then
            self.pointerActionConn:Disconnect()
            self.pointerActionConn = nil
        end
        if self.menuOpenedConn then
            self.menuOpenedConn:Disconnect()
            self.menuOpenedConn = nil
        end
        if self.mouseLockToggleConn then
            self.mouseLockToggleConn:Disconnect()
            self.mouseLockToggleConn = nil
        end
        if self.gamepadConnectedConn then
            self.gamepadConnectedConn:Disconnect()
            self.gamepadConnectedConn = nil
        end
        if self.gamepadDisconnectedConn then
            self.gamepadDisconnectedConn:Disconnect()
            self.gamepadDisconnectedConn = nil
        end
        if self.subjectStateChangedConn then
            self.subjectStateChangedConn:Disconnect()
            self.subjectStateChangedConn = nil
        end
        if self.viewportSizeChangedConn then
            self.viewportSizeChangedConn:Disconnect()
            self.viewportSizeChangedConn = nil
        end
        if self.touchActivateConn then
            self.touchActivateConn:Disconnect()
            self.touchActivateConn = nil
        end

        self.turningLeft = false
        self.turningRight = false
        self.lastCameraTransform = nil
        self.lastSubjectCFrame = nil
        self.userPanningTheCamera = false
        self.rotateInput = Vector2.new()
        self.gamepadPanningCamera = Vector2.new(0,0)

        -- Reset input states
        self.startPos = nil
        self.lastPos = nil
        self.panBeginLook = nil
        self.isRightMouseDown = false
        self.isMiddleMouseDown = false

        self.fingerTouches = {}
        self.dynamicTouchInput = nil
        self.numUnsunkTouches = 0

        self.startingDiff = nil
        self.pinchBeginZoom = nil

        -- Unlock mouse for example if right mouse button was being held down
        if UserInputService.MouseBehavior ~= Enum.MouseBehavior.LockCenter then
            UserInputService.MouseBehavior = Enum.MouseBehavior.Default
        end
    end

    -- This is called when settings menu is opened
    function BaseCamera:ResetInputStates()
        self.isRightMouseDown = false
        self.isMiddleMouseDown = false
        self:OnMousePanButtonReleased() -- this function doesn't seem to actually need parameters

        if UserInputService.TouchEnabled then
            --[[menu opening was causing serious touch issues
            this should disable all active touch events if
            they're active when menu opens.]]
            for inputObject in pairs(self.fingerTouches) do
                self.fingerTouches[inputObject] = nil
            end
            self.dynamicTouchInput = nil
            self.panBeginLook = nil
            self.startPos = nil
            self.lastPos = nil
            self.userPanningTheCamera = false
            self.startingDiff = nil
            self.pinchBeginZoom = nil
            self.numUnsunkTouches = 0
        end
    end

    function BaseCamera:GetGamepadPan(name, state, input)
        if input.UserInputType == self.activeGamepad and input.KeyCode == Enum.KeyCode.Thumbstick2 then
    --      if self.L3ButtonDown then
    --          -- L3 Thumbstick is depressed, right stick controls dolly in/out
    --          if (input.Position.Y > THUMBSTICK_DEADZONE) then
    --              self.currentZoomSpeed = 0.96
    --          elseif (input.Position.Y < -THUMBSTICK_DEADZONE) then
    --              self.currentZoomSpeed = 1.04
    --          else
    --              self.currentZoomSpeed = 1.00
    --          end
    --      else
                if state == Enum.UserInputState.Cancel then
                    self.gamepadPanningCamera = ZERO_VECTOR2
                    return
                end

                local inputVector = Vector2.new(input.Position.X, -input.Position.Y)
                if inputVector.magnitude > THUMBSTICK_DEADZONE then
                    self.gamepadPanningCamera = Vector2.new(input.Position.X, -input.Position.Y)
                else
                    self.gamepadPanningCamera = ZERO_VECTOR2
                end
            --end
            return Enum.ContextActionResult.Sink
        end
        return Enum.ContextActionResult.Pass
    end

    function BaseCamera:DoKeyboardPanTurn(name, state, input)
        if not self.hasGameLoaded and VRService.VREnabled then
            return Enum.ContextActionResult.Pass
        end

        if state == Enum.UserInputState.Cancel then
            self.turningLeft = false
            self.turningRight = false
            return Enum.ContextActionResult.Sink
        end

        if self.panBeginLook == nil and self.keyPanEnabled then
            if input.KeyCode == Enum.KeyCode.Left then
                self.turningLeft = state == Enum.UserInputState.Begin
            elseif input.KeyCode == Enum.KeyCode.Right then
                self.turningRight = state == Enum.UserInputState.Begin
            end
            return Enum.ContextActionResult.Sink
        end
        return Enum.ContextActionResult.Pass
    end

    function BaseCamera:DoPanRotateCamera(rotateAngle)
        local angle = Util.RotateVectorByAngleAndRound(self:GetCameraLookVector() * Vector3.new(1,0,1), rotateAngle, math.pi*0.25)
        if angle ~= 0 then
            self.rotateInput = self.rotateInput + Vector2.new(angle, 0)
            self.lastUserPanCamera = tick()
            self.lastCameraTransform = nil
        end
    end

    function BaseCamera:DoGamepadZoom(name, state, input)
        if input.UserInputType == self.activeGamepad then
            if input.KeyCode == Enum.KeyCode.ButtonR3 then
                if state == Enum.UserInputState.Begin then
                    if self.distanceChangeEnabled then
                        local dist = self:GetCameraToSubjectDistance()

                        if dist > (GAMEPAD_ZOOM_STEP_2 + GAMEPAD_ZOOM_STEP_3)/2 then
                            self:SetCameraToSubjectDistance(GAMEPAD_ZOOM_STEP_2)
                        elseif dist > (GAMEPAD_ZOOM_STEP_1 + GAMEPAD_ZOOM_STEP_2)/2 then
                            self:SetCameraToSubjectDistance(GAMEPAD_ZOOM_STEP_1)
                        else
                            self:SetCameraToSubjectDistance(GAMEPAD_ZOOM_STEP_3)
                        end
                    end
                end
            elseif input.KeyCode == Enum.KeyCode.DPadLeft then
                self.dpadLeftDown = (state == Enum.UserInputState.Begin)
            elseif input.KeyCode == Enum.KeyCode.DPadRight then
                self.dpadRightDown = (state == Enum.UserInputState.Begin)
            end

            if self.dpadLeftDown then
                self.currentZoomSpeed = 1.04
            elseif self.dpadRightDown then
                self.currentZoomSpeed = 0.96
            else
                self.currentZoomSpeed = 1.00
            end
            return Enum.ContextActionResult.Sink
        end
        return Enum.ContextActionResult.Pass
    --  elseif input.UserInputType == self.activeGamepad and input.KeyCode == Enum.KeyCode.ButtonL3 then
    --      if (state == Enum.UserInputState.Begin) then
    --          self.L3ButtonDown = true
    --      elseif (state == Enum.UserInputState.End) then
    --          self.L3ButtonDown = false
    --          self.currentZoomSpeed = 1.00
    --      end
    --  end
    end

    function BaseCamera:DoKeyboardZoom(name, state, input)
        if not self.hasGameLoaded and VRService.VREnabled then
            return Enum.ContextActionResult.Pass
        end

        if state ~= Enum.UserInputState.Begin then
            return Enum.ContextActionResult.Pass
        end

        if self.distanceChangeEnabled and player.CameraMode ~= Enum.CameraMode.LockFirstPerson then
            if input.KeyCode == Enum.KeyCode.I then
                self:SetCameraToSubjectDistance( self.currentSubjectDistance - 5 )
            elseif input.KeyCode == Enum.KeyCode.O then
                self:SetCameraToSubjectDistance( self.currentSubjectDistance + 5 )
            end
            return Enum.ContextActionResult.Sink
        end
        return Enum.ContextActionResult.Pass
    end

    function BaseCamera:BindAction(actionName, actionFunc, createTouchButton, ...)
        table.insert(self.boundContextActions, actionName)
        ContextActionService:BindActionAtPriority(actionName, actionFunc, createTouchButton,
            CAMERA_ACTION_PRIORITY, ...)
    end

    function BaseCamera:BindGamepadInputActions()
        self:BindAction("BaseCameraGamepadPan", function(name, state, input) return self:GetGamepadPan(name, state, input) end,
            false, Enum.KeyCode.Thumbstick2)
        self:BindAction("BaseCameraGamepadZoom", function(name, state, input) return self:DoGamepadZoom(name, state, input) end,
            false, Enum.KeyCode.DPadLeft, Enum.KeyCode.DPadRight, Enum.KeyCode.ButtonR3)
    end

    function BaseCamera:BindKeyboardInputActions()
        self:BindAction("BaseCameraKeyboardPanArrowKeys", function(name, state, input) return self:DoKeyboardPanTurn(name, state, input) end,
            false, Enum.KeyCode.Left, Enum.KeyCode.Right)
        self:BindAction("BaseCameraKeyboardZoom", function(name, state, input) return self:DoKeyboardZoom(name, state, input) end,
            false, Enum.KeyCode.I, Enum.KeyCode.O)
    end

    local function isInDynamicThumbstickArea(input)
        local playerGui = player:FindFirstChildOfClass("PlayerGui")
        local touchGui = playerGui and playerGui:FindFirstChild("TouchGui")
        local touchFrame = touchGui and touchGui:FindFirstChild("TouchControlFrame")
        local thumbstickFrame = touchFrame and touchFrame:FindFirstChild("DynamicThumbstickFrame")

        if not thumbstickFrame then
            return false
        end

        local frameCornerTopLeft = thumbstickFrame.AbsolutePosition
        local frameCornerBottomRight = frameCornerTopLeft + thumbstickFrame.AbsoluteSize
        if input.Position.X >= frameCornerTopLeft.X and input.Position.Y >= frameCornerTopLeft.Y then
            if input.Position.X <= frameCornerBottomRight.X and input.Position.Y <= frameCornerBottomRight.Y then
                return true
            end
        end

        return false
    end

    ---Adjusts the camera Y touch Sensitivity when moving away from the center and in the TOUCH_SENSITIVTY_ADJUST_AREA
    function BaseCamera:AdjustTouchSensitivity(delta, sensitivity)
        local cameraCFrame = game.Workspace.CurrentCamera and game.Workspace.CurrentCamera.CFrame
        if not cameraCFrame then
            return sensitivity
        end
        local currPitchAngle = cameraCFrame:ToEulerAnglesYXZ()

        local multiplierY = TOUCH_SENSITIVTY_ADJUST_MAX_Y
        if currPitchAngle > TOUCH_ADJUST_AREA_UP and delta.Y < 0 then
            local fractionAdjust = (currPitchAngle - TOUCH_ADJUST_AREA_UP)/(MAX_Y - TOUCH_ADJUST_AREA_UP)
            fractionAdjust = 1 - (1 - fractionAdjust)^3
            multiplierY = TOUCH_SENSITIVTY_ADJUST_MAX_Y - fractionAdjust * (
                TOUCH_SENSITIVTY_ADJUST_MAX_Y - TOUCH_SENSITIVTY_ADJUST_MIN_Y)
        elseif currPitchAngle < TOUCH_ADJUST_AREA_DOWN and delta.Y > 0 then
            local fractionAdjust = (currPitchAngle - TOUCH_ADJUST_AREA_DOWN)/(MIN_Y - TOUCH_ADJUST_AREA_DOWN)
            fractionAdjust = 1 - (1 - fractionAdjust)^3
            multiplierY = TOUCH_SENSITIVTY_ADJUST_MAX_Y - fractionAdjust * (
                TOUCH_SENSITIVTY_ADJUST_MAX_Y - TOUCH_SENSITIVTY_ADJUST_MIN_Y)
        end

        return Vector2.new(
            sensitivity.X,
            sensitivity.Y * multiplierY
        )
    end

    function BaseCamera:OnTouchBegan(input, processed)
        local canUseDynamicTouch = self.isDynamicThumbstickEnabled and not processed
        if canUseDynamicTouch then
            if self.dynamicTouchInput == nil and isInDynamicThumbstickArea(input) then
                -- First input in the dynamic thumbstick area should always be ignored for camera purposes
                -- Even if the dynamic thumbstick does not process it immediately
                self.dynamicTouchInput = input
                return
            end
            self.fingerTouches[input] = processed
            self.inputStartPositions[input] = input.Position
            self.inputStartTimes[input] = tick()
            self.numUnsunkTouches = self.numUnsunkTouches + 1
        end
    end

    function BaseCamera:OnTouchChanged(input, processed)
        if self.fingerTouches[input] == nil then
            if self.isDynamicThumbstickEnabled then
                return
            end
            self.fingerTouches[input] = processed
            if not processed then
                self.numUnsunkTouches = self.numUnsunkTouches + 1
            end
        end

        if self.numUnsunkTouches == 1 then
            if self.fingerTouches[input] == false then
                self.panBeginLook = self.panBeginLook or self:GetCameraLookVector()
                self.startPos = self.startPos or input.Position
                self.lastPos = self.lastPos or self.startPos
                self.userPanningTheCamera = true

                local delta = input.Position - self.lastPos
                delta = Vector2.new(delta.X, delta.Y * UserGameSettings:GetCameraYInvertValue())
                if self.panEnabled then
                    local adjustedTouchSensitivity = TOUCH_SENSITIVTY
                    self:AdjustTouchSensitivity(delta, TOUCH_SENSITIVTY)

                    local desiredXYVector = self:InputTranslationToCameraAngleChange(delta, adjustedTouchSensitivity)
                    self.rotateInput = self.rotateInput + desiredXYVector
                end
                self.lastPos = input.Position
            end
        else
            self.panBeginLook = nil
            self.startPos = nil
            self.lastPos = nil
            self.userPanningTheCamera = false
        end
        if self.numUnsunkTouches == 2 then
            local unsunkTouches = {}
            for touch, wasSunk in pairs(self.fingerTouches) do
                if not wasSunk then
                    table.insert(unsunkTouches, touch)
                end
            end
            if #unsunkTouches == 2 then
                local difference = (unsunkTouches[1].Position - unsunkTouches[2].Position).magnitude
                if self.startingDiff and self.pinchBeginZoom then
                    local scale = difference / math.max(0.01, self.startingDiff)
                    local clampedScale = math.clamp(scale, 0.1, 10)
                    if self.distanceChangeEnabled then
                        self:SetCameraToSubjectDistance(self.pinchBeginZoom / clampedScale)
                    end
                else
                    self.startingDiff = difference
                    self.pinchBeginZoom = self:GetCameraToSubjectDistance()
                end
            end
        else
            self.startingDiff = nil
            self.pinchBeginZoom = nil
        end
    end

    function BaseCamera:OnTouchEnded(input, processed)
        if input == self.dynamicTouchInput then
            self.dynamicTouchInput = nil
            return
        end

        if self.fingerTouches[input] == false then
            if self.numUnsunkTouches == 1 then
                self.panBeginLook = nil
                self.startPos = nil
                self.lastPos = nil
                self.userPanningTheCamera = false
            elseif self.numUnsunkTouches == 2 then
                self.startingDiff = nil
                self.pinchBeginZoom = nil
            end
        end

        if self.fingerTouches[input] ~= nil and self.fingerTouches[input] == false then
            self.numUnsunkTouches = self.numUnsunkTouches - 1
        end
        self.fingerTouches[input] = nil
        self.inputStartPositions[input] = nil
        self.inputStartTimes[input] = nil
    end

    function BaseCamera:OnMouse2Down(input, processed)
        if processed then return end

        self.isRightMouseDown = true
        self:OnMousePanButtonPressed(input, processed)
    end

    function BaseCamera:OnMouse2Up(input, processed)
        self.isRightMouseDown = false
        self:OnMousePanButtonReleased(input, processed)
    end

    function BaseCamera:OnMouse3Down(input, processed)
        if processed then return end

        self.isMiddleMouseDown = true
        self:OnMousePanButtonPressed(input, processed)
    end

    function BaseCamera:OnMouse3Up(input, processed)
        self.isMiddleMouseDown = false
        self:OnMousePanButtonReleased(input, processed)
    end

    function BaseCamera:OnMouseMoved(input, processed)
        if not self.hasGameLoaded and VRService.VREnabled then
            return
        end

        local inputDelta = input.Delta
        inputDelta = Vector2.new(inputDelta.X, inputDelta.Y * UserGameSettings:GetCameraYInvertValue())

        local isInputPanning = FFlagUserCameraToggle and CameraInput.getPanning()
        local isBeginLook = self.startPos and self.lastPos and self.panBeginLook
        local isPanning = isBeginLook or self.inFirstPerson or self.inMouseLockedMode or isInputPanning

        if self.panEnabled and isPanning then
            local desiredXYVector = self:InputTranslationToCameraAngleChange(inputDelta, MOUSE_SENSITIVITY)
            self.rotateInput = self.rotateInput + desiredXYVector
        end

        if self.startPos and self.lastPos and self.panBeginLook then
            self.lastPos = self.lastPos + input.Delta
        end
    end

    function BaseCamera:OnMousePanButtonPressed(input, processed)
        if processed then return end
        if not FFlagUserCameraToggle then
            self:UpdateMouseBehavior()
        end
        self.panBeginLook = self.panBeginLook or self:GetCameraLookVector()
        self.startPos = self.startPos or input.Position
        self.lastPos = self.lastPos or self.startPos
        self.userPanningTheCamera = true
    end

    function BaseCamera:OnMousePanButtonReleased(input, processed)
        if not FFlagUserCameraToggle then
            self:UpdateMouseBehavior()
        end
        if not (self.isRightMouseDown or self.isMiddleMouseDown) then
            self.panBeginLook = nil
            self.startPos = nil
            self.lastPos = nil
            self.userPanningTheCamera = false
        end
    end

    function BaseCamera:UpdateMouseBehavior()
        if FFlagUserCameraToggle and self.isCameraToggle then
            CameraUI.setCameraModeToastEnabled(true)
            CameraInput.enableCameraToggleInput()
            CameraToggleStateController(self.inFirstPerson)
        else
            if FFlagUserCameraToggle then
                CameraUI.setCameraModeToastEnabled(false)
                CameraInput.disableCameraToggleInput()
            end
            -- first time transition to first person mode or mouse-locked third person
            if self.inFirstPerson or self.inMouseLockedMode then
                --UserGameSettings.RotationType = Enum.RotationType.CameraRelative
                UserInputService.MouseBehavior = Enum.MouseBehavior.LockCenter
            else
                UserGameSettings.RotationType = Enum.RotationType.MovementRelative
                if self.isRightMouseDown or self.isMiddleMouseDown then
                    UserInputService.MouseBehavior = Enum.MouseBehavior.LockCurrentPosition
                else
                    UserInputService.MouseBehavior = Enum.MouseBehavior.Default
                end
            end
        end
    end

    function BaseCamera:UpdateForDistancePropertyChange()
        -- Calling this setter with the current value will force checking that it is still
        -- in range after a change to the min/max distance limits
        self:SetCameraToSubjectDistance(self.currentSubjectDistance)
    end

    function BaseCamera:SetCameraToSubjectDistance(desiredSubjectDistance)
        local lastSubjectDistance = self.currentSubjectDistance

        -- By default, camera modules will respect LockFirstPerson and override the currentSubjectDistance with 0
        -- regardless of what Player.CameraMinZoomDistance is set to, so that first person can be made
        -- available by the developer without needing to allow players to mousewheel dolly into first person.
        -- Some modules will override this function to remove or change first-person capability.
        if player.CameraMode == Enum.CameraMode.LockFirstPerson then
            self.currentSubjectDistance = 0.5
            if not self.inFirstPerson then
                self:EnterFirstPerson()
            end
        else
            local newSubjectDistance = math.clamp(desiredSubjectDistance, player.CameraMinZoomDistance, player.CameraMaxZoomDistance)
            if newSubjectDistance < FIRST_PERSON_DISTANCE_THRESHOLD then
                self.currentSubjectDistance = 0.5
                if not self.inFirstPerson then
                    self:EnterFirstPerson()
                end
            else
                self.currentSubjectDistance = newSubjectDistance
                if self.inFirstPerson then
                    self:LeaveFirstPerson()
                end
            end
        end

        -- Pass target distance and zoom direction to the zoom controller
        ZoomController.SetZoomParameters(self.currentSubjectDistance, math.sign(desiredSubjectDistance - lastSubjectDistance))

        -- Returned only for convenience to the caller to know the outcome
        return self.currentSubjectDistance
    end

    function BaseCamera:SetCameraType( cameraType )
        --Used by derived classes
        self.cameraType = cameraType
    end

    function BaseCamera:GetCameraType()
        return self.cameraType
    end

    -- Movement mode standardized to Enum.ComputerCameraMovementMode values
    function BaseCamera:SetCameraMovementMode( cameraMovementMode )
        self.cameraMovementMode = cameraMovementMode
    end

    function BaseCamera:GetCameraMovementMode()
        return self.cameraMovementMode
    end

    function BaseCamera:SetIsMouseLocked(mouseLocked)
        self.inMouseLockedMode = mouseLocked
        if not FFlagUserCameraToggle then
            self:UpdateMouseBehavior()
        end
    end

    function BaseCamera:GetIsMouseLocked()
        return self.inMouseLockedMode
    end

    function BaseCamera:SetMouseLockOffset(offsetVector)
        self.mouseLockOffset = offsetVector
    end

    function BaseCamera:GetMouseLockOffset()
        return self.mouseLockOffset
    end

    function BaseCamera:InFirstPerson()
        return self.inFirstPerson
    end

    function BaseCamera:EnterFirstPerson()
        -- Overridden in ClassicCamera, the only module which supports FirstPerson
    end

    function BaseCamera:LeaveFirstPerson()
        -- Overridden in ClassicCamera, the only module which supports FirstPerson
    end

    -- Nominal distance, set by dollying in and out with the mouse wheel or equivalent, not measured distance
    function BaseCamera:GetCameraToSubjectDistance()
        return self.currentSubjectDistance
    end

    -- Actual measured distance to the camera Focus point, which may be needed in special circumstances, but should
    -- never be used as the starting point for updating the nominal camera-to-subject distance (self.currentSubjectDistance)
    -- since that is a desired target value set only by mouse wheel (or equivalent) input, PopperCam, and clamped to min max camera distance
    function BaseCamera:GetMeasuredDistanceToFocus()
        local camera = game.Workspace.CurrentCamera
        if camera then
            return (camera.CoordinateFrame.p - camera.Focus.p).magnitude
        end
        return nil
    end

    function BaseCamera:GetCameraLookVector()
        return game.Workspace.CurrentCamera and game.Workspace.CurrentCamera.CFrame.lookVector or UNIT_Z
    end

    -- Replacements for RootCamera:RotateCamera() which did not actually rotate the camera
    -- suppliedLookVector is not normally passed in, it's used only by Watch camera
    function BaseCamera:CalculateNewLookCFrame(suppliedLookVector)
        local currLookVector = suppliedLookVector or self:GetCameraLookVector()
        local currPitchAngle = math.asin(currLookVector.y)
        local yTheta = math.clamp(self.rotateInput.y, -MAX_Y + currPitchAngle, -MIN_Y + currPitchAngle)
        local constrainedRotateInput = Vector2.new(self.rotateInput.x, yTheta)
        local startCFrame = CFrame.new(ZERO_VECTOR3, currLookVector)
        local newLookCFrame = CFrame.Angles(0, -constrainedRotateInput.x, 0) * startCFrame * CFrame.Angles(-constrainedRotateInput.y,0,0)
        return newLookCFrame
    end
    function BaseCamera:CalculateNewLookVector(suppliedLookVector)
        local newLookCFrame = self:CalculateNewLookCFrame(suppliedLookVector)
        return newLookCFrame.lookVector
    end

    function BaseCamera:CalculateNewLookVectorVR()
        local subjectPosition = self:GetSubjectPosition()
        local vecToSubject = (subjectPosition - game.Workspace.CurrentCamera.CFrame.p)
        local currLookVector = (vecToSubject * X1_Y0_Z1).unit
        local vrRotateInput = Vector2.new(self.rotateInput.x, 0)
        local startCFrame = CFrame.new(ZERO_VECTOR3, currLookVector)
        local yawRotatedVector = (CFrame.Angles(0, -vrRotateInput.x, 0) * startCFrame * CFrame.Angles(-vrRotateInput.y,0,0)).lookVector
        return (yawRotatedVector * X1_Y0_Z1).unit
    end

    function BaseCamera:GetHumanoid()
        local character = player and player.Character
        if character then
            local resultHumanoid = self.humanoidCache[player]
            if resultHumanoid and resultHumanoid.Parent == character then
                return resultHumanoid
            else
                self.humanoidCache[player] = nil -- Bust Old Cache
                local humanoid = character:FindFirstChildOfClass("Humanoid")
                if humanoid then
                    self.humanoidCache[player] = humanoid
                end
                return humanoid
            end
        end
        return nil
    end

    function BaseCamera:GetHumanoidPartToFollow(humanoid, humanoidStateType)
        if humanoidStateType == Enum.HumanoidStateType.Dead then
            local character = humanoid.Parent
            if character then
                return character:FindFirstChild("Head") or humanoid.Torso
            else
                return humanoid.Torso
            end
        else
            return humanoid.Torso
        end
    end

    function BaseCamera:UpdateGamepad()
        local gamepadPan = self.gamepadPanningCamera
        if gamepadPan and (self.hasGameLoaded or not VRService.VREnabled) then
            gamepadPan = Util.GamepadLinearToCurve(gamepadPan)
            local currentTime = tick()
            if gamepadPan.X ~= 0 or gamepadPan.Y ~= 0 then
                self.userPanningTheCamera = true
            elseif gamepadPan == ZERO_VECTOR2 then
                self.lastThumbstickRotate = nil
                if self.lastThumbstickPos == ZERO_VECTOR2 then
                    self.currentSpeed = 0
                end
            end

            local finalConstant = 0

            if self.lastThumbstickRotate then
                if VRService.VREnabled then
                    self.currentSpeed = self.vrMaxSpeed
                else
                    local elapsedTime = (currentTime - self.lastThumbstickRotate) * 10
                    self.currentSpeed = self.currentSpeed + (self.maxSpeed * ((elapsedTime*elapsedTime)/self.numOfSeconds))

                    if self.currentSpeed > self.maxSpeed then self.currentSpeed = self.maxSpeed end

                    if self.lastVelocity then
                        local velocity = (gamepadPan - self.lastThumbstickPos)/(currentTime - self.lastThumbstickRotate)
                        local velocityDeltaMag = (velocity - self.lastVelocity).magnitude

                        if velocityDeltaMag > 12 then
                            self.currentSpeed = self.currentSpeed * (20/velocityDeltaMag)
                            if self.currentSpeed > self.maxSpeed then self.currentSpeed = self.maxSpeed end
                        end
                    end
                end

                finalConstant = UserGameSettings.GamepadCameraSensitivity * self.currentSpeed
                self.lastVelocity = (gamepadPan - self.lastThumbstickPos)/(currentTime - self.lastThumbstickRotate)
            end

            self.lastThumbstickPos = gamepadPan
            self.lastThumbstickRotate = currentTime

            return Vector2.new( gamepadPan.X * finalConstant, gamepadPan.Y * finalConstant * self.ySensitivity * UserGameSettings:GetCameraYInvertValue())
        end

        return ZERO_VECTOR2
    end

    -- [[ VR Support Section ]] --

    function BaseCamera:ApplyVRTransform()
        if not VRService.VREnabled then
            return
        end

        --we only want this to happen in first person VR
        local rootJoint = self.humanoidRootPart and self.humanoidRootPart:FindFirstChild("RootJoint")
        if not rootJoint then
            return
        end

        local cameraSubject = game.Workspace.CurrentCamera.CameraSubject
        local isInVehicle = cameraSubject and cameraSubject:IsA("VehicleSeat")

        if self.inFirstPerson and not isInVehicle then
            local vrFrame = VRService:GetUserCFrame(Enum.UserCFrame.Head)
            local vrRotation = vrFrame - vrFrame.p
            rootJoint.C0 = CFrame.new(vrRotation:vectorToObjectSpace(vrFrame.p)) * CFrame.new(0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 1, 0)
        else
            rootJoint.C0 = CFrame.new(0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 1, 0)
        end
    end

    function BaseCamera:IsInFirstPerson()
        return self.inFirstPerson
    end

    function BaseCamera:ShouldUseVRRotation()
        if not VRService.VREnabled then
            return false
        end

        if not self.VRRotationIntensityAvailable and tick() - self.lastVRRotationIntensityCheckTime < 1 then
            return false
        end

        local success, vrRotationIntensity = pcall(function() return StarterGui:GetCore("VRRotationIntensity") end)
        self.VRRotationIntensityAvailable = success and vrRotationIntensity ~= nil
        self.lastVRRotationIntensityCheckTime = tick()

        self.shouldUseVRRotation = success and vrRotationIntensity ~= nil and vrRotationIntensity ~= "Smooth"

        return self.shouldUseVRRotation
    end

    function BaseCamera:GetVRRotationInput()
        local vrRotateSum = ZERO_VECTOR2
        local success, vrRotationIntensity = pcall(function() return StarterGui:GetCore("VRRotationIntensity") end)

        if not success then
            return
        end

        local vrGamepadRotation = self.GamepadPanningCamera or ZERO_VECTOR2
        local delayExpired = (tick() - self.lastVRRotationTime) >= self:GetRepeatDelayValue(vrRotationIntensity)

        if math.abs(vrGamepadRotation.x) >= self:GetActivateValue() then
            if (delayExpired or not self.vrRotateKeyCooldown[Enum.KeyCode.Thumbstick2]) then
                local sign = 1
                if vrGamepadRotation.x < 0 then
                    sign = -1
                end
                vrRotateSum = vrRotateSum + self:GetRotateAmountValue(vrRotationIntensity) * sign
                self.vrRotateKeyCooldown[Enum.KeyCode.Thumbstick2] = true
            end
        elseif math.abs(vrGamepadRotation.x) < self:GetActivateValue() - 0.1 then
            self.vrRotateKeyCooldown[Enum.KeyCode.Thumbstick2] = nil
        end
        if self.turningLeft then
            if delayExpired or not self.vrRotateKeyCooldown[Enum.KeyCode.Left] then
                vrRotateSum = vrRotateSum - self:GetRotateAmountValue(vrRotationIntensity)
                self.vrRotateKeyCooldown[Enum.KeyCode.Left] = true
            end
        else
            self.vrRotateKeyCooldown[Enum.KeyCode.Left] = nil
        end
        if self.turningRight then
            if (delayExpired or not self.vrRotateKeyCooldown[Enum.KeyCode.Right]) then
                vrRotateSum = vrRotateSum + self:GetRotateAmountValue(vrRotationIntensity)
                self.vrRotateKeyCooldown[Enum.KeyCode.Right] = true
            end
        else
            self.vrRotateKeyCooldown[Enum.KeyCode.Right] = nil
        end

        if vrRotateSum ~= ZERO_VECTOR2 then
            self.lastVRRotationTime = tick()
        end

        return vrRotateSum
    end

    function BaseCamera:CancelCameraFreeze(keepConstraints)
        if not keepConstraints then
            self.cameraTranslationConstraints = Vector3.new(self.cameraTranslationConstraints.x, 1, self.cameraTranslationConstraints.z)
        end
        if self.cameraFrozen then
            self.trackingHumanoid = nil
            self.cameraFrozen = false
        end
    end

    function BaseCamera:StartCameraFreeze(subjectPosition, humanoidToTrack)
        if not self.cameraFrozen then
            self.humanoidJumpOrigin = subjectPosition
            self.trackingHumanoid = humanoidToTrack
            self.cameraTranslationConstraints = Vector3.new(self.cameraTranslationConstraints.x, 0, self.cameraTranslationConstraints.z)
            self.cameraFrozen = true
        end
    end

    function BaseCamera:OnNewCameraSubject()
        if self.subjectStateChangedConn then
            self.subjectStateChangedConn:Disconnect()
            self.subjectStateChangedConn = nil
        end

        local humanoid = workspace.CurrentCamera and workspace.CurrentCamera.CameraSubject
        if self.trackingHumanoid ~= humanoid then
            self:CancelCameraFreeze()
        end
        if humanoid and humanoid:IsA("Humanoid") then
            self.subjectStateChangedConn = humanoid.StateChanged:Connect(function(oldState, newState)
                if VRService.VREnabled and newState == Enum.HumanoidStateType.Jumping and not self.inFirstPerson then
                    self:StartCameraFreeze(self:GetSubjectPosition(), humanoid)
                elseif newState ~= Enum.HumanoidStateType.Jumping and newState ~= Enum.HumanoidStateType.Freefall then
                    self:CancelCameraFreeze(true)
                end
            end)
        end
    end

    function BaseCamera:GetVRFocus(subjectPosition, timeDelta)
        local lastFocus = self.LastCameraFocus or subjectPosition
        if not self.cameraFrozen then
            self.cameraTranslationConstraints = Vector3.new(self.cameraTranslationConstraints.x, math.min(1, self.cameraTranslationConstraints.y + 0.42 * timeDelta), self.cameraTranslationConstraints.z)
        end

        local newFocus
        if self.cameraFrozen and self.humanoidJumpOrigin and self.humanoidJumpOrigin.y > lastFocus.y then
            newFocus = CFrame.new(Vector3.new(subjectPosition.x, math.min(self.humanoidJumpOrigin.y, lastFocus.y + 5 * timeDelta), subjectPosition.z))
        else
            newFocus = CFrame.new(Vector3.new(subjectPosition.x, lastFocus.y, subjectPosition.z):lerp(subjectPosition, self.cameraTranslationConstraints.y))
        end

        if self.cameraFrozen then
            -- No longer in 3rd person
            if self.inFirstPerson then -- not VRService.VREnabled
                self:CancelCameraFreeze()
            end
            -- This case you jumped off a cliff and want to keep your character in view
            -- 0.5 is to fix floating point error when not jumping off cliffs
            if self.humanoidJumpOrigin and subjectPosition.y < (self.humanoidJumpOrigin.y - 0.5) then
                self:CancelCameraFreeze()
            end
        end

        return newFocus
    end

    function BaseCamera:GetRotateAmountValue(vrRotationIntensity)
        vrRotationIntensity = vrRotationIntensity or StarterGui:GetCore("VRRotationIntensity")
        if vrRotationIntensity then
            if vrRotationIntensity == "Low" then
                return VR_LOW_INTENSITY_ROTATION
            elseif vrRotationIntensity == "High" then
                return VR_HIGH_INTENSITY_ROTATION
            end
        end
        return ZERO_VECTOR2
    end

    function BaseCamera:GetRepeatDelayValue(vrRotationIntensity)
        vrRotationIntensity = vrRotationIntensity or StarterGui:GetCore("VRRotationIntensity")
        if vrRotationIntensity then
            if vrRotationIntensity == "Low" then
                return VR_LOW_INTENSITY_REPEAT
            elseif vrRotationIntensity == "High" then
                return VR_HIGH_INTENSITY_REPEAT
            end
        end
        return 0
    end

    function BaseCamera:Update(dt)
        error("BaseCamera:Update() This is a virtual function that should never be getting called.", 2)
    end

    BaseCamera.UpCFrame = CFrame.new()

    function BaseCamera:UpdateUpCFrame(cf)
        self.UpCFrame = cf
    end
    local ZERO = Vector3.new(0, 0, 0)
    function BaseCamera:CalculateNewLookCFrame(suppliedLookVector)
        local currLookVector = suppliedLookVector or self:GetCameraLookVector()
        currLookVector = self.UpCFrame:VectorToObjectSpace(currLookVector)

        local currPitchAngle = math.asin(currLookVector.y)
        local yTheta = math.clamp(self.rotateInput.y, -MAX_Y + currPitchAngle, -MIN_Y + currPitchAngle)
        local constrainedRotateInput = Vector2.new(self.rotateInput.x, yTheta)
        local startCFrame = CFrame.new(ZERO, currLookVector)
        local newLookCFrame = CFrame.Angles(0, -constrainedRotateInput.x, 0) * startCFrame * CFrame.Angles(-constrainedRotateInput.y,0,0)

        return newLookCFrame
    end

    return BaseCamera
end

function _BaseOcclusion()
    --[[ The Module ]]--
    local BaseOcclusion = {}
    BaseOcclusion.__index = BaseOcclusion
    setmetatable(BaseOcclusion, {
        __call = function(_, ...)
            return BaseOcclusion.new(...)
        end
    })

    function BaseOcclusion.new()
        local self = setmetatable({}, BaseOcclusion)
        return self
    end

    -- Called when character is added
    function BaseOcclusion:CharacterAdded(char, player)
    end

    -- Called when character is about to be removed
    function BaseOcclusion:CharacterRemoving(char, player)
    end

    function BaseOcclusion:OnCameraSubjectChanged(newSubject)
    end

    --[[ Derived classes are required to override and implement all of the following functions ]]--
    function BaseOcclusion:GetOcclusionMode()
        -- Must be overridden in derived classes to return an Enum.DevCameraOcclusionMode value
        warn("BaseOcclusion GetOcclusionMode must be overridden by derived classes")
        return nil
    end

    function BaseOcclusion:Enable(enabled)
        warn("BaseOcclusion Enable must be overridden by derived classes")
    end

    function BaseOcclusion:Update(dt, desiredCameraCFrame, desiredCameraFocus)
        warn("BaseOcclusion Update must be overridden by derived classes")
        return desiredCameraCFrame, desiredCameraFocus
    end

    return BaseOcclusion
end

function _Popper()

    local Players = game:GetService("Players")

    local camera = game.Workspace.CurrentCamera

    local min = math.min
    local tan = math.tan
    local rad = math.rad
    local inf = math.huge
    local ray = Ray.new

    local function getTotalTransparency(part)
        return 1 - (1 - part.Transparency)*(1 - part.LocalTransparencyModifier)
    end

    local function eraseFromEnd(t, toSize)
        for i = #t, toSize + 1, -1 do
            t[i] = nil
        end
    end

    local nearPlaneZ, projX, projY do
        local function updateProjection()
            local fov = rad(camera.FieldOfView)
            local view = camera.ViewportSize
            local ar = view.X/view.Y

            projY = 2*tan(fov/2)
            projX = ar*projY
        end

        camera:GetPropertyChangedSignal("FieldOfView"):Connect(updateProjection)
        camera:GetPropertyChangedSignal("ViewportSize"):Connect(updateProjection)

        updateProjection()

        nearPlaneZ = camera.NearPlaneZ
        camera:GetPropertyChangedSignal("NearPlaneZ"):Connect(function()
            nearPlaneZ = camera.NearPlaneZ
        end)
    end

    local blacklist = {} do
        local charMap = {}

        local function refreshIgnoreList()
            local n = 1
            blacklist = {}
            for _, character in pairs(charMap) do
                blacklist[n] = character
                n = n + 1
            end
        end

        local function playerAdded(player)
            local function characterAdded(character)
                charMap[player] = character
                refreshIgnoreList()
            end
            local function characterRemoving()
                charMap[player] = nil
                refreshIgnoreList()
            end

            player.CharacterAdded:Connect(characterAdded)
            player.CharacterRemoving:Connect(characterRemoving)
            if player.Character then
                characterAdded(player.Character)
            end
        end

        local function playerRemoving(player)
            charMap[player] = nil
            refreshIgnoreList()
        end

        Players.PlayerAdded:Connect(playerAdded)
        Players.PlayerRemoving:Connect(playerRemoving)

        for _, player in ipairs(Players:GetPlayers()) do
            playerAdded(player)
        end
        refreshIgnoreList()
    end

    --------------------------------------------------------------------------------------------
    -- Popper uses the level geometry find an upper bound on subject-to-camera distance.
    --
    -- Hard limits are applied immediately and unconditionally. They are generally caused
    -- when level geometry intersects with the near plane (with exceptions, see below).
    --
    -- Soft limits are only applied under certain conditions.
    -- They are caused when level geometry occludes the subject without actually intersecting
    -- with the near plane at the target distance.
    --
    -- Soft limits can be promoted to hard limits and hard limits can be demoted to soft limits.
    -- We usually don"t want the latter to happen.
    --
    -- A soft limit will be promoted to a hard limit if an obstruction
    -- lies between the current and target camera positions.
    --------------------------------------------------------------------------------------------

    local subjectRoot
    local subjectPart

    camera:GetPropertyChangedSignal("CameraSubject"):Connect(function()
        local subject = camera.CameraSubject
        if subject:IsA("Humanoid") then
            subjectPart = subject.RootPart
        elseif subject:IsA("BasePart") then
            subjectPart = subject
        else
            subjectPart = nil
        end
    end)

    local function canOcclude(part)
        -- Occluders must be:
        -- 1. Opaque
        -- 2. Interactable
        -- 3. Not in the same assembly as the subject

        return
            getTotalTransparency(part) < 0.25 and
            part.CanCollide and
            subjectRoot ~= (part:GetRootPart() or part) and
            not part:IsA("TrussPart")
    end

    -- Offsets for the volume visibility test
    local SCAN_SAMPLE_OFFSETS = {
        Vector2.new( 0.4, 0.0),
        Vector2.new(-0.4, 0.0),
        Vector2.new( 0.0,-0.4),
        Vector2.new( 0.0, 0.4),
        Vector2.new( 0.0, 0.2),
    }

    --------------------------------------------------------------------------------
    -- Piercing raycasts

    local function getCollisionPoint(origin, dir)
        local originalSize = #blacklist
        repeat
            local hitPart, hitPoint = workspace:FindPartOnRayWithIgnoreList(
                ray(origin, dir), blacklist, false, true
            )

            if hitPart then
                if hitPart.CanCollide then
                    eraseFromEnd(blacklist, originalSize)
                    return hitPoint, true
                end
                blacklist[#blacklist + 1] = hitPart
            end
        until not hitPart

        eraseFromEnd(blacklist, originalSize)
        return origin + dir, false
    end

    --------------------------------------------------------------------------------

    local function queryPoint(origin, unitDir, dist, lastPos)
        debug.profilebegin("queryPoint")

        local originalSize = #blacklist

        dist = dist + nearPlaneZ
        local target = origin + unitDir*dist

        local softLimit = inf
        local hardLimit = inf
        local movingOrigin = origin

        repeat
            local entryPart, entryPos = workspace:FindPartOnRayWithIgnoreList(ray(movingOrigin, target - movingOrigin), blacklist, false, true)

            if entryPart then
                if canOcclude(entryPart) then
                    local wl = {entryPart}
                    local exitPart = workspace:FindPartOnRayWithWhitelist(ray(target, entryPos - target), wl, true)

                    local lim = (entryPos - origin).Magnitude

                    if exitPart then
                        local promote = false
                        if lastPos then
                            promote =
                                workspace:FindPartOnRayWithWhitelist(ray(lastPos, target - lastPos), wl, true) or
                                workspace:FindPartOnRayWithWhitelist(ray(target, lastPos - target), wl, true)
                        end

                        if promote then
                            -- Ostensibly a soft limit, but the camera has passed through it in the last frame, so promote to a hard limit.
                            hardLimit = lim
                        elseif dist < softLimit then
                            -- Trivial soft limit
                            softLimit = lim
                        end
                    else
                        -- Trivial hard limit
                        hardLimit = lim
                    end
                end

                blacklist[#blacklist + 1] = entryPart
                movingOrigin = entryPos - unitDir*1e-3
            end
        until hardLimit < inf or not entryPart

        eraseFromEnd(blacklist, originalSize)

        debug.profileend()
        return softLimit - nearPlaneZ, hardLimit - nearPlaneZ
    end

    local function queryViewport(focus, dist)
        debug.profilebegin("queryViewport")

        local fP =  focus.p
        local fX =  focus.rightVector
        local fY =  focus.upVector
        local fZ = -focus.lookVector

        local viewport = camera.ViewportSize

        local hardBoxLimit = inf
        local softBoxLimit = inf

        -- Center the viewport on the PoI, sweep points on the edge towards the target, and take the minimum limits
        for viewX = 0, 1 do
            local worldX = fX*((viewX - 0.5)*projX)

            for viewY = 0, 1 do
                local worldY = fY*((viewY - 0.5)*projY)

                local origin = fP + nearPlaneZ*(worldX + worldY)
                local lastPos = camera:ViewportPointToRay(
                    viewport.x*viewX,
                    viewport.y*viewY
                ).Origin

                local softPointLimit, hardPointLimit = queryPoint(origin, fZ, dist, lastPos)

                if hardPointLimit < hardBoxLimit then
                    hardBoxLimit = hardPointLimit
                end
                if softPointLimit < softBoxLimit then
                    softBoxLimit = softPointLimit
                end
            end
        end
        debug.profileend()

        return softBoxLimit, hardBoxLimit
    end

    local function testPromotion(focus, dist, focusExtrapolation)
        debug.profilebegin("testPromotion")

        local fP = focus.p
        local fX = focus.rightVector
        local fY = focus.upVector
        local fZ = -focus.lookVector

        do
            -- Dead reckoning the camera rotation and focus
            debug.profilebegin("extrapolate")

            local SAMPLE_DT = 0.0625
            local SAMPLE_MAX_T = 1.25

            local maxDist = (getCollisionPoint(fP, focusExtrapolation.posVelocity*SAMPLE_MAX_T) - fP).Magnitude
            -- Metric that decides how many samples to take
            local combinedSpeed = focusExtrapolation.posVelocity.magnitude

            for dt = 0, min(SAMPLE_MAX_T, focusExtrapolation.rotVelocity.magnitude + maxDist/combinedSpeed), SAMPLE_DT do
                local cfDt = focusExtrapolation.extrapolate(dt) -- Extrapolated CFrame at time dt

                if queryPoint(cfDt.p, -cfDt.lookVector, dist) >= dist then
                    return false
                end
            end

            debug.profileend()
        end

        do
            -- Test screen-space offsets from the focus for the presence of soft limits
            debug.profilebegin("testOffsets")

            for _, offset in ipairs(SCAN_SAMPLE_OFFSETS) do
                local scaledOffset = offset
                local pos = getCollisionPoint(fP, fX*scaledOffset.x + fY*scaledOffset.y)
                if queryPoint(pos, (fP + fZ*dist - pos).Unit, dist) == inf then
                    return false
                end
            end

            debug.profileend()
        end

        debug.profileend()
        return true
    end

    local function Popper(focus, targetDist, focusExtrapolation)
        debug.profilebegin("popper")

        subjectRoot = subjectPart and subjectPart:GetRootPart() or subjectPart

        local dist = targetDist
        local soft, hard = queryViewport(focus, targetDist)
        if hard < dist then
            dist = hard
        end
        if soft < dist and testPromotion(focus, targetDist, focusExtrapolation) then
            dist = soft
        end

        subjectRoot = nil

        debug.profileend()
        return dist
    end

    return Popper
end

function _ZoomController()
    local ZOOM_STIFFNESS = 4.5
    local ZOOM_DEFAULT = 12.5
    local ZOOM_ACCELERATION = 0.0375

    local MIN_FOCUS_DIST = 0.5
    local DIST_OPAQUE = 1

    local Popper = _Popper()

    local clamp = math.clamp
    local exp = math.exp
    local min = math.min
    local max = math.max
    local pi = math.pi

    local cameraMinZoomDistance, cameraMaxZoomDistance do
        local Player = game:GetService("Players").LocalPlayer

        local function updateBounds()
            cameraMinZoomDistance = Player.CameraMinZoomDistance
            cameraMaxZoomDistance = Player.CameraMaxZoomDistance
        end

        updateBounds()

        Player:GetPropertyChangedSignal("CameraMinZoomDistance"):Connect(updateBounds)
        Player:GetPropertyChangedSignal("CameraMaxZoomDistance"):Connect(updateBounds)
    end

    local ConstrainedSpring = {} do
        ConstrainedSpring.__index = ConstrainedSpring

        function ConstrainedSpring.new(freq, x, minValue, maxValue)
            x = clamp(x, minValue, maxValue)
            return setmetatable({
                freq = freq, -- Undamped frequency (Hz)
                x = x, -- Current position
                v = 0, -- Current velocity
                minValue = minValue, -- Minimum bound
                maxValue = maxValue, -- Maximum bound
                goal = x, -- Goal position
            }, ConstrainedSpring)
        end

        function ConstrainedSpring:Step(dt)
            local freq = self.freq*2*pi -- Convert from Hz to rad/s
            local x = self.x
            local v = self.v
            local minValue = self.minValue
            local maxValue = self.maxValue
            local goal = self.goal

            -- Solve the spring ODE for position and velocity after time t, assuming critical damping:
            --   2*f*x'[t] + x''[t] = f^2*(g - x[t])
            -- Knowns are x[0] and x'[0].
            -- Solve for x[t] and x'[t].

            local offset = goal - x
            local step = freq*dt
            local decay = exp(-step)

            local x1 = goal + (v*dt - offset*(step + 1))*decay
            local v1 = ((offset*freq - v)*step + v)*decay

            -- Constrain
            if x1 < minValue then
                x1 = minValue
                v1 = 0
            elseif x1 > maxValue then
                x1 = maxValue
                v1 = 0
            end

            self.x = x1
            self.v = v1

            return x1
        end
    end

    local zoomSpring = ConstrainedSpring.new(ZOOM_STIFFNESS, ZOOM_DEFAULT, MIN_FOCUS_DIST, cameraMaxZoomDistance)

    local function stepTargetZoom(z, dz, zoomMin, zoomMax)
        z = clamp(z + dz*(1 + z*ZOOM_ACCELERATION), zoomMin, zoomMax)
        if z < DIST_OPAQUE then
            z = dz <= 0 and zoomMin or DIST_OPAQUE
        end
        return z
    end

    local zoomDelta = 0

    local Zoom = {} do
        function Zoom.Update(renderDt, focus, extrapolation)
            local poppedZoom = math.huge

            if zoomSpring.goal > DIST_OPAQUE then
                -- Make a pessimistic estimate of zoom distance for this step without accounting for poppercam
                local maxPossibleZoom = max(
                    zoomSpring.x,
                    stepTargetZoom(zoomSpring.goal, zoomDelta, cameraMinZoomDistance, cameraMaxZoomDistance)
                )

                -- Run the Popper algorithm on the feasible zoom range, [MIN_FOCUS_DIST, maxPossibleZoom]
                poppedZoom = Popper(
                    focus*CFrame.new(0, 0, MIN_FOCUS_DIST),
                    maxPossibleZoom - MIN_FOCUS_DIST,
                    extrapolation
                ) + MIN_FOCUS_DIST
            end

            zoomSpring.minValue = MIN_FOCUS_DIST
            zoomSpring.maxValue = min(cameraMaxZoomDistance, poppedZoom)

            return zoomSpring:Step(renderDt)
        end

        function Zoom.SetZoomParameters(targetZoom, newZoomDelta)
            zoomSpring.goal = targetZoom
            zoomDelta = newZoomDelta
        end
    end

    return Zoom
end

function _MouseLockController()
    --[[ Constants ]]--
    local DEFAULT_MOUSE_LOCK_CURSOR = "rbxasset://textures/MouseLockedCursor.png"

    local CONTEXT_ACTION_NAME = "MouseLockSwitchAction"
    local MOUSELOCK_ACTION_PRIORITY = Enum.ContextActionPriority.Default.Value

    --[[ Services ]]--
    local PlayersService = game:GetService("Players")
    local ContextActionService = game:GetService("ContextActionService")
    local Settings = UserSettings() -- ignore warning
    local GameSettings = Settings.GameSettings
    local Mouse = PlayersService.LocalPlayer:GetMouse()

    --[[ The Module ]]--
    local MouseLockController = {}
    MouseLockController.__index = MouseLockController

    function MouseLockController.new()
        local self = setmetatable({}, MouseLockController)

        self.isMouseLocked = false
        self.savedMouseCursor = nil
        self.boundKeys = {Enum.KeyCode.LeftShift, Enum.KeyCode.RightShift} -- defaults

        self.mouseLockToggledEvent = Instance.new("BindableEvent")

        local boundKeysObj = script:FindFirstChild("BoundKeys")
        if (not boundKeysObj) or (not boundKeysObj:IsA("StringValue")) then
            -- If object with correct name was found, but it's not a StringValue, destroy and replace
            if boundKeysObj then
                boundKeysObj:Destroy()
            end

            boundKeysObj = Instance.new("StringValue")
            boundKeysObj.Name = "BoundKeys"
            boundKeysObj.Value = "LeftShift,RightShift"
            boundKeysObj.Parent = script
        end

        if boundKeysObj then
            boundKeysObj.Changed:Connect(function(value)
                self:OnBoundKeysObjectChanged(value)
            end)
            self:OnBoundKeysObjectChanged(boundKeysObj.Value) -- Initial setup call
        end

        -- Watch for changes to user's ControlMode and ComputerMovementMode settings and update the feature availability accordingly
        GameSettings.Changed:Connect(function(property)
            if property == "ControlMode" or property == "ComputerMovementMode" then
                self:UpdateMouseLockAvailability()
            end
        end)

        -- Watch for changes to DevEnableMouseLock and update the feature availability accordingly
        PlayersService.LocalPlayer:GetPropertyChangedSignal("DevEnableMouseLock"):Connect(function()
            self:UpdateMouseLockAvailability()
        end)

        -- Watch for changes to DevEnableMouseLock and update the feature availability accordingly
        PlayersService.LocalPlayer:GetPropertyChangedSignal("DevComputerMovementMode"):Connect(function()
            self:UpdateMouseLockAvailability()
        end)

        self:UpdateMouseLockAvailability()

        return self
    end

    function MouseLockController:GetIsMouseLocked()
        return self.isMouseLocked
    end

    function MouseLockController:GetBindableToggleEvent()
        return self.mouseLockToggledEvent.Event
    end

    function MouseLockController:GetMouseLockOffset()
        local offsetValueObj = script:FindFirstChild("CameraOffset")
        if offsetValueObj and offsetValueObj:IsA("Vector3Value") then
            return offsetValueObj.Value
        else
            -- If CameraOffset object was found but not correct type, destroy
            if offsetValueObj then
                offsetValueObj:Destroy()
            end
            offsetValueObj = Instance.new("Vector3Value")
            offsetValueObj.Name = "CameraOffset"
            offsetValueObj.Value = Vector3.new(1.75,0,0) -- Legacy Default Value
            offsetValueObj.Parent = script
        end

        if offsetValueObj and offsetValueObj.Value then
            return offsetValueObj.Value
        end

        return Vector3.new(1.75,0,0)
    end

    function MouseLockController:UpdateMouseLockAvailability()
        local devAllowsMouseLock = PlayersService.LocalPlayer.DevEnableMouseLock
        local devMovementModeIsScriptable = PlayersService.LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.Scriptable
        local userHasMouseLockModeEnabled = GameSettings.ControlMode == Enum.ControlMode.MouseLockSwitch
        local userHasClickToMoveEnabled =  GameSettings.ComputerMovementMode == Enum.ComputerMovementMode.ClickToMove
        local MouseLockAvailable = devAllowsMouseLock and userHasMouseLockModeEnabled and not userHasClickToMoveEnabled and not devMovementModeIsScriptable

        if MouseLockAvailable~=self.enabled then
            self:EnableMouseLock(MouseLockAvailable)
        end
    end

    function MouseLockController:OnBoundKeysObjectChanged(newValue)
        self.boundKeys = {} -- Overriding defaults, note: possibly with nothing at all if boundKeysObj.Value is "" or contains invalid values
        for token in string.gmatch(newValue,"[^%s,]+") do
            for _, keyEnum in pairs(Enum.KeyCode:GetEnumItems()) do
                if token == keyEnum.Name then
                    self.boundKeys[#self.boundKeys+1] = keyEnum
                    break
                end
            end
        end
        self:UnbindContextActions()
        self:BindContextActions()
    end

    --[[ Local Functions ]]--
    function MouseLockController:OnMouseLockToggled()
        self.isMouseLocked = not self.isMouseLocked

        if self.isMouseLocked then
            local cursorImageValueObj = script:FindFirstChild("CursorImage")
            if cursorImageValueObj and cursorImageValueObj:IsA("StringValue") and cursorImageValueObj.Value then
                self.savedMouseCursor = Mouse.Icon
                Mouse.Icon = cursorImageValueObj.Value
            else
                if cursorImageValueObj then
                    cursorImageValueObj:Destroy()
                end
                cursorImageValueObj = Instance.new("StringValue")
                cursorImageValueObj.Name = "CursorImage"
                cursorImageValueObj.Value = DEFAULT_MOUSE_LOCK_CURSOR
                cursorImageValueObj.Parent = script
                self.savedMouseCursor = Mouse.Icon
                Mouse.Icon = DEFAULT_MOUSE_LOCK_CURSOR
            end
        else
            if self.savedMouseCursor then
                Mouse.Icon = self.savedMouseCursor
                self.savedMouseCursor = nil
            end
        end

        self.mouseLockToggledEvent:Fire()
    end

    function MouseLockController:DoMouseLockSwitch(name, state, input)
        if state == Enum.UserInputState.Begin then
            self:OnMouseLockToggled()
            return Enum.ContextActionResult.Sink
        end
        return Enum.ContextActionResult.Pass
    end

    function MouseLockController:BindContextActions()
        ContextActionService:BindActionAtPriority(CONTEXT_ACTION_NAME, function(name, state, input)
            return self:DoMouseLockSwitch(name, state, input)
        end, false, MOUSELOCK_ACTION_PRIORITY, unpack(self.boundKeys))
    end

    function MouseLockController:UnbindContextActions()
        ContextActionService:UnbindAction(CONTEXT_ACTION_NAME)
    end

    function MouseLockController:IsMouseLocked()
        return self.enabled and self.isMouseLocked
    end

    function MouseLockController:EnableMouseLock(enable)
        if enable ~= self.enabled then

            self.enabled = enable

            if self.enabled then
                -- Enabling the mode
                self:BindContextActions()
            else
                -- Disabling
                -- Restore mouse cursor
                if Mouse.Icon~="" then
                    Mouse.Icon = ""
                end

                self:UnbindContextActions()

                -- If the mode is disabled while being used, fire the event to toggle it off
                if self.isMouseLocked then
                    self.mouseLockToggledEvent:Fire()
                end

                self.isMouseLocked = false
            end

        end
    end

    return MouseLockController
end

function _TransparencyController()

    local MAX_TWEEN_RATE = 2.8 -- per second

    local Util = _CameraUtils()

    --[[ The Module ]]--
    local TransparencyController = {}
    TransparencyController.__index = TransparencyController

    function TransparencyController.new()
        local self = setmetatable({}, TransparencyController)

        self.lastUpdate = tick()
        self.transparencyDirty = false
        self.enabled = false
        self.lastTransparency = nil

        self.descendantAddedConn, self.descendantRemovingConn = nil, nil
        self.toolDescendantAddedConns = {}
        self.toolDescendantRemovingConns = {}
        self.cachedParts = {}

        return self
    end


    function TransparencyController:HasToolAncestor(object)
        if object.Parent == nil then return false end
        return object.Parent:IsA('Tool') or self:HasToolAncestor(object.Parent)
    end

    function TransparencyController:IsValidPartToModify(part)
        if part:IsA('BasePart') or part:IsA('Decal') then
            return not self:HasToolAncestor(part)
        end
        return false
    end

    function TransparencyController:CachePartsRecursive(object)
        if object then
            if self:IsValidPartToModify(object) then
                self.cachedParts[object] = true
                self.transparencyDirty = true
            end
            for _, child in pairs(object:GetChildren()) do
                self:CachePartsRecursive(child)
            end
        end
    end

    function TransparencyController:TeardownTransparency()
        for child, _ in pairs(self.cachedParts) do
            child.LocalTransparencyModifier = 0
        end
        self.cachedParts = {}
        self.transparencyDirty = true
        self.lastTransparency = nil

        if self.descendantAddedConn then
            self.descendantAddedConn:disconnect()
            self.descendantAddedConn = nil
        end
        if self.descendantRemovingConn then
            self.descendantRemovingConn:disconnect()
            self.descendantRemovingConn = nil
        end
        for object, conn in pairs(self.toolDescendantAddedConns) do
            conn:Disconnect()
            self.toolDescendantAddedConns[object] = nil
        end
        for object, conn in pairs(self.toolDescendantRemovingConns) do
            conn:Disconnect()
            self.toolDescendantRemovingConns[object] = nil
        end
    end

    function TransparencyController:SetupTransparency(character)
        self:TeardownTransparency()

        if self.descendantAddedConn then self.descendantAddedConn:disconnect() end
        self.descendantAddedConn = character.DescendantAdded:Connect(function(object)
            -- This is a part we want to invisify
            if self:IsValidPartToModify(object) then
                self.cachedParts[object] = true
                self.transparencyDirty = true
            -- There is now a tool under the character
            elseif object:IsA('Tool') then
                if self.toolDescendantAddedConns[object] then self.toolDescendantAddedConns[object]:Disconnect() end
                self.toolDescendantAddedConns[object] = object.DescendantAdded:Connect(function(toolChild)
                    self.cachedParts[toolChild] = nil
                    if toolChild:IsA('BasePart') or toolChild:IsA('Decal') then
                        -- Reset the transparency
                        toolChild.LocalTransparencyModifier = 0
                    end
                end)
                if self.toolDescendantRemovingConns[object] then self.toolDescendantRemovingConns[object]:disconnect() end
                self.toolDescendantRemovingConns[object] = object.DescendantRemoving:Connect(function(formerToolChild)
                    wait() -- wait for new parent
                    if character and formerToolChild and formerToolChild:IsDescendantOf(character) then
                        if self:IsValidPartToModify(formerToolChild) then
                            self.cachedParts[formerToolChild] = true
                            self.transparencyDirty = true
                        end
                    end
                end)
            end
        end)
        if self.descendantRemovingConn then self.descendantRemovingConn:disconnect() end
        self.descendantRemovingConn = character.DescendantRemoving:connect(function(object)
            if self.cachedParts[object] then
                self.cachedParts[object] = nil
                -- Reset the transparency
                object.LocalTransparencyModifier = 0
            end
        end)
        self:CachePartsRecursive(character)
    end


    function TransparencyController:Enable(enable)
        if self.enabled ~= enable then
            self.enabled = enable
            self:Update()
        end
    end

    function TransparencyController:SetSubject(subject)
        local character = nil
        if subject and subject:IsA("Humanoid") then
            character = subject.Parent
        end
        if subject and subject:IsA("VehicleSeat") and subject.Occupant then
            character = subject.Occupant.Parent
        end
        if character then
            self:SetupTransparency(character)
        else
            self:TeardownTransparency()
        end
    end

    function TransparencyController:Update()
        local instant = false
        local now = tick()
        local currentCamera = workspace.CurrentCamera

        if currentCamera then
            local transparency = 0
            if not self.enabled then
                instant = true
            else
                local distance = (currentCamera.Focus.p - currentCamera.CoordinateFrame.p).magnitude
                transparency = (distance<2) and (1.0-(distance-0.5)/1.5) or 0 --(7 - distance) / 5
                if transparency < 0.5 then
                    transparency = 0
                end

                if self.lastTransparency then
                    local deltaTransparency = transparency - self.lastTransparency

                    -- Don't tween transparency if it is instant or your character was fully invisible last frame
                    if not instant and transparency < 1 and self.lastTransparency < 0.95 then
                        local maxDelta = MAX_TWEEN_RATE * (now - self.lastUpdate)
                        deltaTransparency = math.clamp(deltaTransparency, -maxDelta, maxDelta)
                    end
                    transparency = self.lastTransparency + deltaTransparency
                else
                    self.transparencyDirty = true
                end

                transparency = math.clamp(Util.Round(transparency, 2), 0, 1)
            end

            if self.transparencyDirty or self.lastTransparency ~= transparency then
                for child, _ in pairs(self.cachedParts) do
                    child.LocalTransparencyModifier = transparency
                end
                self.transparencyDirty = false
                self.lastTransparency = transparency
            end
        end
        self.lastUpdate = now
    end

    return TransparencyController
end

function _Poppercam()
    local ZoomController =  _ZoomController()

    local TransformExtrapolator = {} do
        TransformExtrapolator.__index = TransformExtrapolator

        local CF_IDENTITY = CFrame.new()

        local function cframeToAxis(cframe)
            local axis, angle = cframe:toAxisAngle()
            return axis*angle
        end

        local function axisToCFrame(axis)
            local angle = axis.magnitude
            if angle > 1e-5 then
                return CFrame.fromAxisAngle(axis, angle)
            end
            return CF_IDENTITY
        end

        local function extractRotation(cf)
            local _, _, _, xx, yx, zx, xy, yy, zy, xz, yz, zz = cf:components()
            return CFrame.new(0, 0, 0, xx, yx, zx, xy, yy, zy, xz, yz, zz)
        end

        function TransformExtrapolator.new()
            return setmetatable({
                lastCFrame = nil,
            }, TransformExtrapolator)
        end

        function TransformExtrapolator:Step(dt, currentCFrame)
            local lastCFrame = self.lastCFrame or currentCFrame
            self.lastCFrame = currentCFrame

            local currentPos = currentCFrame.p
            local currentRot = extractRotation(currentCFrame)

            local lastPos = lastCFrame.p
            local lastRot = extractRotation(lastCFrame)

            -- Estimate velocities from the delta between now and the last frame
            -- This estimation can be a little noisy.
            local dp = (currentPos - lastPos)/dt
            local dr = cframeToAxis(currentRot*lastRot:inverse())/dt

            local function extrapolate(t)
                local p = dp*t + currentPos
                local r = axisToCFrame(dr*t)*currentRot
                return r + p
            end

            return {
                extrapolate = extrapolate,
                posVelocity = dp,
                rotVelocity = dr,
            }
        end

        function TransformExtrapolator:Reset()
            self.lastCFrame = nil
        end
    end

    --[[ The Module ]]--
    local BaseOcclusion = _BaseOcclusion()
    local Poppercam = setmetatable({}, BaseOcclusion)
    Poppercam.__index = Poppercam

    function Poppercam.new()
        local self = setmetatable(BaseOcclusion.new(), Poppercam)
        self.focusExtrapolator = TransformExtrapolator.new()
        return self
    end

    function Poppercam:GetOcclusionMode()
        return Enum.DevCameraOcclusionMode.Zoom
    end

    function Poppercam:Enable(enable)
        self.focusExtrapolator:Reset()
    end

    function Poppercam:Update(renderDt, desiredCameraCFrame, desiredCameraFocus, cameraController)
        local rotatedFocus = CFrame.new(desiredCameraFocus.p, desiredCameraCFrame.p)*CFrame.new(
            0, 0, 0,
            -1, 0, 0,
            0, 1, 0,
            0, 0, -1
        )
        local extrapolation = self.focusExtrapolator:Step(renderDt, rotatedFocus)
        local zoom = ZoomController.Update(renderDt, rotatedFocus, extrapolation)
        return rotatedFocus*CFrame.new(0, 0, zoom), desiredCameraFocus
    end

    -- Called when character is added
    function Poppercam:CharacterAdded(character, player)
    end

    -- Called when character is about to be removed
    function Poppercam:CharacterRemoving(character, player)
    end

    function Poppercam:OnCameraSubjectChanged(newSubject)
    end

    local ZoomController = _ZoomController()

    function Poppercam:Update(renderDt, desiredCameraCFrame, desiredCameraFocus, cameraController)
        local rotatedFocus = desiredCameraFocus * (desiredCameraCFrame - desiredCameraCFrame.p)
        local extrapolation = self.focusExtrapolator:Step(renderDt, rotatedFocus)
        local zoom = ZoomController.Update(renderDt, rotatedFocus, extrapolation)
        return rotatedFocus*CFrame.new(0, 0, zoom), desiredCameraFocus
    end

    return Poppercam
end

function _Invisicam()

    --[[ Top Level Roblox Services ]]--
    local PlayersService = game:GetService("Players")

    --[[ Constants ]]--
    local ZERO_VECTOR3 = Vector3.new(0,0,0)
    local USE_STACKING_TRANSPARENCY = true  -- Multiple items between the subject and camera get transparency values that add up to TARGET_TRANSPARENCY
    local TARGET_TRANSPARENCY = 0.75 -- Classic Invisicam's Value, also used by new invisicam for parts hit by head and torso rays
    local TARGET_TRANSPARENCY_PERIPHERAL = 0.5 -- Used by new SMART_CIRCLE mode for items not hit by head and torso rays

    local MODE = {
        --CUSTOM = 1,       -- Retired, unused
        LIMBS = 2,          -- Track limbs
        MOVEMENT = 3,       -- Track movement
        CORNERS = 4,        -- Char model corners
        CIRCLE1 = 5,        -- Circle of casts around character
        CIRCLE2 = 6,        -- Circle of casts around character, camera relative
        LIMBMOVE = 7,       -- LIMBS mode + MOVEMENT mode
        SMART_CIRCLE = 8,   -- More sample points on and around character
        CHAR_OUTLINE = 9,   -- Dynamic outline around the character
    }

    local LIMB_TRACKING_SET = {
        -- Body parts common to R15 and R6
        ['Head'] = true,

        -- Body parts unique to R6
        ['Left Arm'] = true,
        ['Right Arm'] = true,
        ['Left Leg'] = true,
        ['Right Leg'] = true,

        -- Body parts unique to R15
        ['LeftLowerArm'] = true,
        ['RightLowerArm'] = true,
        ['LeftUpperLeg'] = true,
        ['RightUpperLeg'] = true
    }

    local CORNER_FACTORS = {
        Vector3.new(1,1,-1),
        Vector3.new(1,-1,-1),
        Vector3.new(-1,-1,-1),
        Vector3.new(-1,1,-1)
    }

    local CIRCLE_CASTS = 10
    local MOVE_CASTS = 3
    local SMART_CIRCLE_CASTS = 24
    local SMART_CIRCLE_INCREMENT = 2.0 * math.pi / SMART_CIRCLE_CASTS
    local CHAR_OUTLINE_CASTS = 24

    -- Used to sanitize user-supplied functions
    local function AssertTypes(param, ...)
        local allowedTypes = {}
        local typeString = ''
        for _, typeName in pairs({...}) do
            allowedTypes[typeName] = true
            typeString = typeString .. (typeString == '' and '' or ' or ') .. typeName
        end
        local theType = type(param)
        assert(allowedTypes[theType], typeString .. " type expected, got: " .. theType)
    end

    -- Helper function for Determinant of 3x3, not in CameraUtils for performance reasons
    local function Det3x3(a,b,c,d,e,f,g,h,i)
        return (a*(e*i-f*h)-b*(d*i-f*g)+c*(d*h-e*g))
    end

    -- Smart Circle mode needs the intersection of 2 rays that are known to be in the same plane
    -- because they are generated from cross products with a common vector. This function is computing
    -- that intersection, but it's actually the general solution for the point halfway between where
    -- two skew lines come nearest to each other, which is more forgiving.
    local function RayIntersection(p0, v0, p1, v1)
        local v2 = v0:Cross(v1)
        local d1 = p1.x - p0.x
        local d2 = p1.y - p0.y
        local d3 = p1.z - p0.z
        local denom = Det3x3(v0.x,-v1.x,v2.x,v0.y,-v1.y,v2.y,v0.z,-v1.z,v2.z)

        if (denom == 0) then
            return ZERO_VECTOR3 -- No solution (rays are parallel)
        end

        local t0 = Det3x3(d1,-v1.x,v2.x,d2,-v1.y,v2.y,d3,-v1.z,v2.z) / denom
        local t1 = Det3x3(v0.x,d1,v2.x,v0.y,d2,v2.y,v0.z,d3,v2.z) / denom
        local s0 = p0 + t0 * v0
        local s1 = p1 + t1 * v1
        local s = s0 + 0.5 * ( s1 - s0 )

        -- 0.25 studs is a threshold for deciding if the rays are
        -- close enough to be considered intersecting, found through testing
        if (s1-s0).Magnitude < 0.25 then
            return s
        else
            return ZERO_VECTOR3
        end
    end



    --[[ The Module ]]--
    local BaseOcclusion = _BaseOcclusion()
    local Invisicam = setmetatable({}, BaseOcclusion)
    Invisicam.__index = Invisicam

    function Invisicam.new()
        local self = setmetatable(BaseOcclusion.new(), Invisicam)

        self.char = nil
        self.humanoidRootPart = nil
        self.torsoPart = nil
        self.headPart = nil

        self.childAddedConn = nil
        self.childRemovedConn = nil

        self.behaviors = {}     -- Map of modes to behavior fns
        self.behaviors[MODE.LIMBS] = self.LimbBehavior
        self.behaviors[MODE.MOVEMENT] = self.MoveBehavior
        self.behaviors[MODE.CORNERS] = self.CornerBehavior
        self.behaviors[MODE.CIRCLE1] = self.CircleBehavior
        self.behaviors[MODE.CIRCLE2] = self.CircleBehavior
        self.behaviors[MODE.LIMBMOVE] = self.LimbMoveBehavior
        self.behaviors[MODE.SMART_CIRCLE] = self.SmartCircleBehavior
        self.behaviors[MODE.CHAR_OUTLINE] = self.CharacterOutlineBehavior

        self.mode = MODE.SMART_CIRCLE
        self.behaviorFunction = self.SmartCircleBehavior

        self.savedHits = {}     -- Objects currently being faded in/out
        self.trackedLimbs = {}  -- Used in limb-tracking casting modes

        self.camera = game.Workspace.CurrentCamera

        self.enabled = false
        return self
    end

    function Invisicam:Enable(enable)
        self.enabled = enable

        if not enable then
            self:Cleanup()
        end
    end

    function Invisicam:GetOcclusionMode()
        return Enum.DevCameraOcclusionMode.Invisicam
    end

    --[[ Module functions ]]--
    function Invisicam:LimbBehavior(castPoints)
        for limb, _ in pairs(self.trackedLimbs) do
            castPoints[#castPoints + 1] = limb.Position
        end
    end

    function Invisicam:MoveBehavior(castPoints)
        for i = 1, MOVE_CASTS do
            local position, velocity = self.humanoidRootPart.Position, self.humanoidRootPart.Velocity
            local horizontalSpeed = Vector3.new(velocity.X, 0, velocity.Z).Magnitude / 2
            local offsetVector = (i - 1) * self.humanoidRootPart.CFrame.lookVector * horizontalSpeed
            castPoints[#castPoints + 1] = position + offsetVector
        end
    end

    function Invisicam:CornerBehavior(castPoints)
        local cframe = self.humanoidRootPart.CFrame
        local centerPoint = cframe.p
        local rotation = cframe - centerPoint
        local halfSize = self.char:GetExtentsSize() / 2 --NOTE: Doesn't update w/ limb animations
        castPoints[#castPoints + 1] = centerPoint
        for i = 1, #CORNER_FACTORS do
            castPoints[#castPoints + 1] = centerPoint + (rotation * (halfSize * CORNER_FACTORS[i]))
        end
    end

    function Invisicam:CircleBehavior(castPoints)
        local cframe
        if self.mode == MODE.CIRCLE1 then
            cframe = self.humanoidRootPart.CFrame
        else
            local camCFrame = self.camera.CoordinateFrame
            cframe = camCFrame - camCFrame.p + self.humanoidRootPart.Position
        end
        castPoints[#castPoints + 1] = cframe.p
        for i = 0, CIRCLE_CASTS - 1 do
            local angle = (2 * math.pi / CIRCLE_CASTS) * i
            local offset = 3 * Vector3.new(math.cos(angle), math.sin(angle), 0)
            castPoints[#castPoints + 1] = cframe * offset
        end
    end

    function Invisicam:LimbMoveBehavior(castPoints)
        self:LimbBehavior(castPoints)
        self:MoveBehavior(castPoints)
    end

    function Invisicam:CharacterOutlineBehavior(castPoints)
        local torsoUp = self.torsoPart.CFrame.upVector.unit
        local torsoRight = self.torsoPart.CFrame.rightVector.unit

        -- Torso cross of points for interior coverage
        castPoints[#castPoints + 1] = self.torsoPart.CFrame.p
        castPoints[#castPoints + 1] = self.torsoPart.CFrame.p + torsoUp
        castPoints[#castPoints + 1] = self.torsoPart.CFrame.p - torsoUp
        castPoints[#castPoints + 1] = self.torsoPart.CFrame.p + torsoRight
        castPoints[#castPoints + 1] = self.torsoPart.CFrame.p - torsoRight
        if self.headPart then
            castPoints[#castPoints + 1] = self.headPart.CFrame.p
        end

        local cframe = CFrame.new(ZERO_VECTOR3,Vector3.new(self.camera.CoordinateFrame.lookVector.X,0,self.camera.CoordinateFrame.lookVector.Z))
        local centerPoint = (self.torsoPart and self.torsoPart.Position or self.humanoidRootPart.Position)

        local partsWhitelist = {self.torsoPart}
        if self.headPart then
            partsWhitelist[#partsWhitelist + 1] = self.headPart
        end

        for i = 1, CHAR_OUTLINE_CASTS do
            local angle = (2 * math.pi * i / CHAR_OUTLINE_CASTS)
            local offset = cframe * (3 * Vector3.new(math.cos(angle), math.sin(angle), 0))

            offset = Vector3.new(offset.X, math.max(offset.Y, -2.25), offset.Z)

            local ray = Ray.new(centerPoint + offset, -3 * offset)
            local hit, hitPoint = game.Workspace:FindPartOnRayWithWhitelist(ray, partsWhitelist, false, false)

            if hit then
                -- Use hit point as the cast point, but nudge it slightly inside the character so that bumping up against
                -- walls is less likely to cause a transparency glitch
                castPoints[#castPoints + 1] = hitPoint + 0.2 * (centerPoint - hitPoint).unit
            end
        end
    end

    function Invisicam:SmartCircleBehavior(castPoints)
        local torsoUp = self.torsoPart.CFrame.upVector.unit
        local torsoRight = self.torsoPart.CFrame.rightVector.unit

        -- SMART_CIRCLE mode includes rays to head and 5 to the torso.
        -- Hands, arms, legs and feet are not included since they
        -- are not canCollide and can therefore go inside of parts
        castPoints[#castPoints + 1] = self.torsoPart.CFrame.p
        castPoints[#castPoints + 1] = self.torsoPart.CFrame.p + torsoUp
        castPoints[#castPoints + 1] = self.torsoPart.CFrame.p - torsoUp
        castPoints[#castPoints + 1] = self.torsoPart.CFrame.p + torsoRight
        castPoints[#castPoints + 1] = self.torsoPart.CFrame.p - torsoRight
        if self.headPart then
            castPoints[#castPoints + 1] = self.headPart.CFrame.p
        end

        local cameraOrientation = self.camera.CFrame - self.camera.CFrame.p
        local torsoPoint = Vector3.new(0,0.5,0) + (self.torsoPart and self.torsoPart.Position or self.humanoidRootPart.Position)
        local radius = 2.5

        -- This loop first calculates points in a circle of radius 2.5 around the torso of the character, in the
        -- plane orthogonal to the camera's lookVector. Each point is then raycast to, to determine if it is within
        -- the free space surrounding the player (not inside anything). Two iterations are done to adjust points that
        -- are inside parts, to try to move them to valid locations that are still on their camera ray, so that the
        -- circle remains circular from the camera's perspective, but does not cast rays into walls or parts that are
        -- behind, below or beside the character and not really obstructing view of the character. This minimizes
        -- the undesirable situation where the character walks up to an exterior wall and it is made invisible even
        -- though it is behind the character.
        for i = 1, SMART_CIRCLE_CASTS do
            local angle = SMART_CIRCLE_INCREMENT * i - 0.5 * math.pi
            local offset = radius * Vector3.new(math.cos(angle), math.sin(angle), 0)
            local circlePoint = torsoPoint + cameraOrientation * offset

            -- Vector from camera to point on the circle being tested
            local vp = circlePoint - self.camera.CFrame.p

            local ray = Ray.new(torsoPoint, circlePoint - torsoPoint)
            local hit, hp, hitNormal = game.Workspace:FindPartOnRayWithIgnoreList(ray, {self.char}, false, false )
            local castPoint = circlePoint

            if hit then
                local hprime = hp + 0.1 * hitNormal.unit -- Slightly offset hit point from the hit surface
                local v0 = hprime - torsoPoint -- Vector from torso to offset hit point

                local perp = (v0:Cross(vp)).unit

                -- Vector from the offset hit point, along the hit surface
                local v1 = (perp:Cross(hitNormal)).unit

                -- Vector from camera to offset hit
                local vprime = (hprime - self.camera.CFrame.p).unit

                -- This dot product checks to see if the vector along the hit surface would hit the correct
                -- side of the invisicam cone, or if it would cross the camera look vector and hit the wrong side
                if ( v0.unit:Dot(-v1) < v0.unit:Dot(vprime)) then
                    castPoint = RayIntersection(hprime, v1, circlePoint, vp)

                    if castPoint.Magnitude > 0 then
                        local ray = Ray.new(hprime, castPoint - hprime)
                        local hit, hitPoint, hitNormal = game.Workspace:FindPartOnRayWithIgnoreList(ray, {self.char}, false, false )

                        if hit then
                            local hprime2 = hitPoint + 0.1 * hitNormal.unit
                            castPoint = hprime2
                        end
                    else
                        castPoint = hprime
                    end
                else
                    castPoint = hprime
                end

                local ray = Ray.new(torsoPoint, (castPoint - torsoPoint))
                local hit, hitPoint, hitNormal = game.Workspace:FindPartOnRayWithIgnoreList(ray, {self.char}, false, false )

                if hit then
                    local castPoint2 = hitPoint - 0.1 * (castPoint - torsoPoint).unit
                    castPoint = castPoint2
                end
            end

            castPoints[#castPoints + 1] = castPoint
        end
    end

    function Invisicam:CheckTorsoReference()
        if self.char then
            self.torsoPart = self.char:FindFirstChild("Torso")
            if not self.torsoPart then
                self.torsoPart = self.char:FindFirstChild("UpperTorso")
                if not self.torsoPart then
                    self.torsoPart = self.char:FindFirstChild("HumanoidRootPart")
                end
            end

            self.headPart = self.char:FindFirstChild("Head")
        end
    end

    function Invisicam:CharacterAdded(char, player)
        -- We only want the LocalPlayer's character
        if player~=PlayersService.LocalPlayer then return end

        if self.childAddedConn then
            self.childAddedConn:Disconnect()
            self.childAddedConn = nil
        end
        if self.childRemovedConn then
            self.childRemovedConn:Disconnect()
            self.childRemovedConn = nil
        end

        self.char = char

        self.trackedLimbs = {}
        local function childAdded(child)
            if child:IsA("BasePart") then
                if LIMB_TRACKING_SET[child.Name] then
                    self.trackedLimbs[child] = true
                end

                if child.Name == "Torso" or child.Name == "UpperTorso" then
                    self.torsoPart = child
                end

                if child.Name == "Head" then
                    self.headPart = child
                end
            end
        end

        local function childRemoved(child)
            self.trackedLimbs[child] = nil

            -- If removed/replaced part is 'Torso' or 'UpperTorso' double check that we still have a TorsoPart to use
            self:CheckTorsoReference()
        end

        self.childAddedConn = char.ChildAdded:Connect(childAdded)
        self.childRemovedConn = char.ChildRemoved:Connect(childRemoved)
        for _, child in pairs(self.char:GetChildren()) do
            childAdded(child)
        end
    end

    function Invisicam:SetMode(newMode)
        AssertTypes(newMode, 'number')
        for _, modeNum in pairs(MODE) do
            if modeNum == newMode then
                self.mode = newMode
                self.behaviorFunction = self.behaviors[self.mode]
                return
            end
        end
        error("Invalid mode number")
    end

    function Invisicam:GetObscuredParts()
        return self.savedHits
    end

    -- Want to turn off Invisicam? Be sure to call this after.
    function Invisicam:Cleanup()
        for hit, originalFade in pairs(self.savedHits) do
            hit.LocalTransparencyModifier = originalFade
        end
    end

    function Invisicam:Update(dt, desiredCameraCFrame, desiredCameraFocus)
        -- Bail if there is no Character
        if not self.enabled or not self.char then
            return desiredCameraCFrame, desiredCameraFocus
        end

        self.camera = game.Workspace.CurrentCamera

        -- TODO: Move this to a GetHumanoidRootPart helper, probably combine with CheckTorsoReference
        -- Make sure we still have a HumanoidRootPart
        if not self.humanoidRootPart then
            local humanoid = self.char:FindFirstChildOfClass("Humanoid")
            if humanoid and humanoid.RootPart then
                self.humanoidRootPart = humanoid.RootPart
            else
                -- Not set up with Humanoid? Try and see if there's one in the Character at all:
                self.humanoidRootPart = self.char:FindFirstChild("HumanoidRootPart")
                if not self.humanoidRootPart then
                    -- Bail out, since we're relying on HumanoidRootPart existing
                    return desiredCameraCFrame, desiredCameraFocus
                end
            end

            -- TODO: Replace this with something more sensible
            local ancestryChangedConn
            ancestryChangedConn = self.humanoidRootPart.AncestryChanged:Connect(function(child, parent)
                if child == self.humanoidRootPart and not parent then
                    self.humanoidRootPart = nil
                    if ancestryChangedConn and ancestryChangedConn.Connected then
                        ancestryChangedConn:Disconnect()
                        ancestryChangedConn = nil
                    end
                end
            end)
        end

        if not self.torsoPart then
            self:CheckTorsoReference()
            if not self.torsoPart then
                -- Bail out, since we're relying on Torso existing, should never happen since we fall back to using HumanoidRootPart as torso
                return desiredCameraCFrame, desiredCameraFocus
            end
        end

        -- Make a list of world points to raycast to
        local castPoints = {}
        self.behaviorFunction(self, castPoints)

        -- Cast to get a list of objects between the camera and the cast points
        local currentHits = {}
        local ignoreList = {self.char}
        local function add(hit)
            currentHits[hit] = true
            if not self.savedHits[hit] then
                self.savedHits[hit] = hit.LocalTransparencyModifier
            end
        end

        local hitParts
        local hitPartCount = 0

        -- Hash table to treat head-ray-hit parts differently than the rest of the hit parts hit by other rays
        -- head/torso ray hit parts will be more transparent than peripheral parts when USE_STACKING_TRANSPARENCY is enabled
        local headTorsoRayHitParts = {}

        local perPartTransparencyHeadTorsoHits = TARGET_TRANSPARENCY
        local perPartTransparencyOtherHits = TARGET_TRANSPARENCY

        if USE_STACKING_TRANSPARENCY then

            -- This first call uses head and torso rays to find out how many parts are stacked up
            -- for the purpose of calculating required per-part transparency
            local headPoint = self.headPart and self.headPart.CFrame.p or castPoints[1]
            local torsoPoint = self.torsoPart and self.torsoPart.CFrame.p or castPoints[2]
            hitParts = self.camera:GetPartsObscuringTarget({headPoint, torsoPoint}, ignoreList)

            -- Count how many things the sample rays passed through, including decals. This should only
            -- count decals facing the camera, but GetPartsObscuringTarget does not return surface normals,
            -- so my compromise for now is to just let any decal increase the part count by 1. Only one
            -- decal per part will be considered.
            for i = 1, #hitParts do
                local hitPart = hitParts[i]
                hitPartCount = hitPartCount + 1 -- count the part itself
                headTorsoRayHitParts[hitPart] = true
                for _, child in pairs(hitPart:GetChildren()) do
                    if child:IsA('Decal') or child:IsA('Texture') then
                        hitPartCount = hitPartCount + 1 -- count first decal hit, then break
                        break
                    end
                end
            end

            if (hitPartCount > 0) then
                perPartTransparencyHeadTorsoHits = math.pow( ((0.5 * TARGET_TRANSPARENCY) + (0.5 * TARGET_TRANSPARENCY / hitPartCount)), 1 / hitPartCount )
                perPartTransparencyOtherHits = math.pow( ((0.5 * TARGET_TRANSPARENCY_PERIPHERAL) + (0.5 * TARGET_TRANSPARENCY_PERIPHERAL / hitPartCount)), 1 / hitPartCount )
            end
        end

        -- Now get all the parts hit by all the rays
        hitParts = self.camera:GetPartsObscuringTarget(castPoints, ignoreList)

        local partTargetTransparency = {}

        -- Include decals and textures
        for i = 1, #hitParts do
            local hitPart = hitParts[i]

            partTargetTransparency[hitPart] =headTorsoRayHitParts[hitPart] and perPartTransparencyHeadTorsoHits or perPartTransparencyOtherHits

            -- If the part is not already as transparent or more transparent than what invisicam requires, add it to the list of
            -- parts to be modified by invisicam
            if hitPart.Transparency < partTargetTransparency[hitPart] then
                add(hitPart)
            end

            -- Check all decals and textures on the part
            for _, child in pairs(hitPart:GetChildren()) do
                if child:IsA('Decal') or child:IsA('Texture') then
                    if (child.Transparency < partTargetTransparency[hitPart]) then
                        partTargetTransparency[child] = partTargetTransparency[hitPart]
                        add(child)
                    end
                end
            end
        end

        -- Invisibilize objects that are in the way, restore those that aren't anymore
        for hitPart, originalLTM in pairs(self.savedHits) do
            if currentHits[hitPart] then
                -- LocalTransparencyModifier gets whatever value is required to print the part's total transparency to equal perPartTransparency
                hitPart.LocalTransparencyModifier = (hitPart.Transparency < 1) and ((partTargetTransparency[hitPart] - hitPart.Transparency) / (1.0 - hitPart.Transparency)) or 0
            else -- Restore original pre-invisicam value of LTM
                hitPart.LocalTransparencyModifier = originalLTM
                self.savedHits[hitPart] = nil
            end
        end

        -- Invisicam does not change the camera values
        return desiredCameraCFrame, desiredCameraFocus
    end

    return Invisicam
end

function _LegacyCamera()

    local ZERO_VECTOR2 = Vector2.new(0,0)

    local Util = _CameraUtils()

    --[[ Services ]]--
    local PlayersService = game:GetService('Players')

    --[[ The Module ]]--
    local BaseCamera = _BaseCamera()
    local LegacyCamera = setmetatable({}, BaseCamera)
    LegacyCamera.__index = LegacyCamera

    function LegacyCamera.new()
        local self = setmetatable(BaseCamera.new(), LegacyCamera)

        self.cameraType = Enum.CameraType.Fixed
        self.lastUpdate = tick()
        self.lastDistanceToSubject = nil

        return self
    end

    function LegacyCamera:GetModuleName()
        return "LegacyCamera"
    end

    --[[ Functions overridden from BaseCamera ]]--
    function LegacyCamera:SetCameraToSubjectDistance(desiredSubjectDistance)
        return BaseCamera.SetCameraToSubjectDistance(self,desiredSubjectDistance)
    end

    function LegacyCamera:Update(dt)

        -- Cannot update until cameraType has been set
        if not self.cameraType then return end

        local now = tick()
        local timeDelta = (now - self.lastUpdate)
        local camera =  workspace.CurrentCamera
        local newCameraCFrame = camera.CFrame
        local newCameraFocus = camera.Focus
        local player = PlayersService.LocalPlayer

        if self.lastUpdate == nil or timeDelta > 1 then
            self.lastDistanceToSubject = nil
        end
        local subjectPosition = self:GetSubjectPosition()

        if self.cameraType == Enum.CameraType.Fixed then
            if self.lastUpdate then
                -- Cap out the delta to 0.1 so we don't get some crazy things when we re-resume from
                local delta = math.min(0.1, now - self.lastUpdate)
                local gamepadRotation = self:UpdateGamepad()
                self.rotateInput = self.rotateInput + (gamepadRotation * delta)
            end

            if subjectPosition and player and camera then
                local distanceToSubject = self:GetCameraToSubjectDistance()
                local newLookVector = self:CalculateNewLookVector()
                self.rotateInput = ZERO_VECTOR2

                newCameraFocus = camera.Focus -- Fixed camera does not change focus
                newCameraCFrame = CFrame.new(camera.CFrame.p, camera.CFrame.p + (distanceToSubject * newLookVector))
            end
        elseif self.cameraType == Enum.CameraType.Attach then
            if subjectPosition and camera then
                local distanceToSubject = self:GetCameraToSubjectDistance()
                local humanoid = self:GetHumanoid()
                if self.lastUpdate and humanoid and humanoid.RootPart then

                    -- Cap out the delta to 0.1 so we don't get some crazy things when we re-resume from
                    local delta = math.min(0.1, now - self.lastUpdate)
                    local gamepadRotation = self:UpdateGamepad()
                    self.rotateInput = self.rotateInput + (gamepadRotation * delta)

                    local forwardVector = humanoid.RootPart.CFrame.lookVector

                    local y = Util.GetAngleBetweenXZVectors(forwardVector, self:GetCameraLookVector())
                    if Util.IsFinite(y) then
                        -- Preserve vertical rotation from user input
                        self.rotateInput = Vector2.new(y, self.rotateInput.Y)
                    end
                end

                local newLookVector = self:CalculateNewLookVector()
                self.rotateInput = ZERO_VECTOR2

                newCameraFocus = CFrame.new(subjectPosition)
                newCameraCFrame = CFrame.new(subjectPosition - (distanceToSubject * newLookVector), subjectPosition)
            end
        elseif self.cameraType == Enum.CameraType.Watch then
            if subjectPosition and player and camera then
                local cameraLook = nil

                local humanoid = self:GetHumanoid()
                if humanoid and humanoid.RootPart then
                    local diffVector = subjectPosition - camera.CFrame.p
                    cameraLook = diffVector.unit

                    if self.lastDistanceToSubject and self.lastDistanceToSubject == self:GetCameraToSubjectDistance() then
                        -- Don't clobber the zoom if they zoomed the camera
                        local newDistanceToSubject = diffVector.magnitude
                        self:SetCameraToSubjectDistance(newDistanceToSubject)
                    end
                end

                local distanceToSubject = self:GetCameraToSubjectDistance()
                local newLookVector = self:CalculateNewLookVector(cameraLook)
                self.rotateInput = ZERO_VECTOR2

                newCameraFocus = CFrame.new(subjectPosition)
                newCameraCFrame = CFrame.new(subjectPosition - (distanceToSubject * newLookVector), subjectPosition)

                self.lastDistanceToSubject = distanceToSubject
            end
        else
            -- Unsupported type, return current values unchanged
            return camera.CFrame, camera.Focus
        end

        self.lastUpdate = now
        return newCameraCFrame, newCameraFocus
    end

    return LegacyCamera
end

function _OrbitalCamera()

    -- Local private variables and constants
    local UNIT_Z = Vector3.new(0,0,1)
    local X1_Y0_Z1 = Vector3.new(1,0,1) --Note: not a unit vector, used for projecting onto XZ plane
    local ZERO_VECTOR3 = Vector3.new(0,0,0)
    local ZERO_VECTOR2 = Vector2.new(0,0)
    local TAU = 2 * math.pi

    --[[ Gamepad Support ]]--
    local THUMBSTICK_DEADZONE = 0.2

    -- Do not edit these values, they are not the developer-set limits, they are limits
    -- to the values the camera system equations can correctly handle
    local MIN_ALLOWED_ELEVATION_DEG = -80
    local MAX_ALLOWED_ELEVATION_DEG = 80

    local externalProperties = {}
    externalProperties["InitialDistance"]  = 25
    externalProperties["MinDistance"]      = 10
    externalProperties["MaxDistance"]      = 100
    externalProperties["InitialElevation"] = 35
    externalProperties["MinElevation"]     = 35
    externalProperties["MaxElevation"]     = 35
    externalProperties["ReferenceAzimuth"] = -45    -- Angle around the Y axis where the camera starts. -45 offsets the camera in the -X and +Z directions equally
    externalProperties["CWAzimuthTravel"]  = 90 -- How many degrees the camera is allowed to rotate from the reference position, CW as seen from above
    externalProperties["CCWAzimuthTravel"] = 90 -- How many degrees the camera is allowed to rotate from the reference position, CCW as seen from above
    externalProperties["UseAzimuthLimits"] = false -- Full rotation around Y axis available by default

    local Util = _CameraUtils()

    --[[ Services ]]--
    local PlayersService = game:GetService('Players')
    local VRService = game:GetService("VRService")

    --[[ The Module ]]--
    local BaseCamera = _BaseCamera()
    local OrbitalCamera = setmetatable({}, BaseCamera)
    OrbitalCamera.__index = OrbitalCamera


    function OrbitalCamera.new()
        local self = setmetatable(BaseCamera.new(), OrbitalCamera)

        self.lastUpdate = tick()

        -- OrbitalCamera-specific members
        self.changedSignalConnections = {}
        self.refAzimuthRad = nil
        self.curAzimuthRad = nil
        self.minAzimuthAbsoluteRad = nil
        self.maxAzimuthAbsoluteRad = nil
        self.useAzimuthLimits = nil
        self.curElevationRad = nil
        self.minElevationRad = nil
        self.maxElevationRad = nil
        self.curDistance = nil
        self.minDistance = nil
        self.maxDistance = nil

        -- Gamepad
        self.r3ButtonDown = false
        self.l3ButtonDown = false
        self.gamepadDollySpeedMultiplier = 1

        self.lastUserPanCamera = tick()

        self.externalProperties = {}
        self.externalProperties["InitialDistance"]  = 25
        self.externalProperties["MinDistance"]      = 10
        self.externalProperties["MaxDistance"]      = 100
        self.externalProperties["InitialElevation"]     = 35
        self.externalProperties["MinElevation"]         = 35
        self.externalProperties["MaxElevation"]         = 35
        self.externalProperties["ReferenceAzimuth"]     = -45   -- Angle around the Y axis where the camera starts. -45 offsets the camera in the -X and +Z directions equally
        self.externalProperties["CWAzimuthTravel"]  = 90    -- How many degrees the camera is allowed to rotate from the reference position, CW as seen from above
        self.externalProperties["CCWAzimuthTravel"]     = 90    -- How many degrees the camera is allowed to rotate from the reference position, CCW as seen from above
        self.externalProperties["UseAzimuthLimits"]     = false -- Full rotation around Y axis available by default
        self:LoadNumberValueParameters()

        return self
    end

    function OrbitalCamera:LoadOrCreateNumberValueParameter(name, valueType, updateFunction)
        local valueObj = script:FindFirstChild(name)

        if valueObj and valueObj:isA(valueType) then
            -- Value object exists and is the correct type, use its value
            self.externalProperties[name] = valueObj.Value
        elseif self.externalProperties[name] ~= nil then
            -- Create missing (or replace incorrectly-typed) valueObject with default value
            valueObj = Instance.new(valueType)
            valueObj.Name = name
            valueObj.Parent = script
            valueObj.Value = self.externalProperties[name]
        else
            print("externalProperties table has no entry for ",name)
            return
        end

        if updateFunction then
            if self.changedSignalConnections[name] then
                self.changedSignalConnections[name]:Disconnect()
            end
            self.changedSignalConnections[name] = valueObj.Changed:Connect(function(newValue)
                self.externalProperties[name] = newValue
                updateFunction(self)
            end)
        end
    end

    function OrbitalCamera:SetAndBoundsCheckAzimuthValues()
        self.minAzimuthAbsoluteRad = math.rad(self.externalProperties["ReferenceAzimuth"]) - math.abs(math.rad(self.externalProperties["CWAzimuthTravel"]))
        self.maxAzimuthAbsoluteRad = math.rad(self.externalProperties["ReferenceAzimuth"]) + math.abs(math.rad(self.externalProperties["CCWAzimuthTravel"]))
        self.useAzimuthLimits = self.externalProperties["UseAzimuthLimits"]
        if self.useAzimuthLimits then
            self.curAzimuthRad = math.max(self.curAzimuthRad, self.minAzimuthAbsoluteRad)
            self.curAzimuthRad = math.min(self.curAzimuthRad, self.maxAzimuthAbsoluteRad)
        end
    end

    function OrbitalCamera:SetAndBoundsCheckElevationValues()
        -- These degree values are the direct user input values. It is deliberate that they are
        -- ranged checked only against the extremes, and not against each other. Any time one
        -- is changed, both of the internal values in radians are recalculated. This allows for
        -- A developer to change the values in any order and for the end results to be that the
        -- internal values adjust to match intent as best as possible.
        local minElevationDeg = math.max(self.externalProperties["MinElevation"], MIN_ALLOWED_ELEVATION_DEG)
        local maxElevationDeg = math.min(self.externalProperties["MaxElevation"], MAX_ALLOWED_ELEVATION_DEG)

        -- Set internal values in radians
        self.minElevationRad = math.rad(math.min(minElevationDeg, maxElevationDeg))
        self.maxElevationRad = math.rad(math.max(minElevationDeg, maxElevationDeg))
        self.curElevationRad = math.max(self.curElevationRad, self.minElevationRad)
        self.curElevationRad = math.min(self.curElevationRad, self.maxElevationRad)
    end

    function OrbitalCamera:SetAndBoundsCheckDistanceValues()
        self.minDistance = self.externalProperties["MinDistance"]
        self.maxDistance = self.externalProperties["MaxDistance"]
        self.curDistance = math.max(self.curDistance, self.minDistance)
        self.curDistance = math.min(self.curDistance, self.maxDistance)
    end

    -- This loads from, or lazily creates, NumberValue objects for exposed parameters
    function OrbitalCamera:LoadNumberValueParameters()
        -- These initial values do not require change listeners since they are read only once
        self:LoadOrCreateNumberValueParameter("InitialElevation", "NumberValue", nil)
        self:LoadOrCreateNumberValueParameter("InitialDistance", "NumberValue", nil)

        -- Note: ReferenceAzimuth is also used as an initial value, but needs a change listener because it is used in the calculation of the limits
        self:LoadOrCreateNumberValueParameter("ReferenceAzimuth", "NumberValue", self.SetAndBoundsCheckAzimuthValue)
        self:LoadOrCreateNumberValueParameter("CWAzimuthTravel", "NumberValue", self.SetAndBoundsCheckAzimuthValues)
        self:LoadOrCreateNumberValueParameter("CCWAzimuthTravel", "NumberValue", self.SetAndBoundsCheckAzimuthValues)
        self:LoadOrCreateNumberValueParameter("MinElevation", "NumberValue", self.SetAndBoundsCheckElevationValues)
        self:LoadOrCreateNumberValueParameter("MaxElevation", "NumberValue", self.SetAndBoundsCheckElevationValues)
        self:LoadOrCreateNumberValueParameter("MinDistance", "NumberValue", self.SetAndBoundsCheckDistanceValues)
        self:LoadOrCreateNumberValueParameter("MaxDistance", "NumberValue", self.SetAndBoundsCheckDistanceValues)
        self:LoadOrCreateNumberValueParameter("UseAzimuthLimits", "BoolValue", self.SetAndBoundsCheckAzimuthValues)

        -- Internal values set (in radians, from degrees), plus sanitization
        self.curAzimuthRad = math.rad(self.externalProperties["ReferenceAzimuth"])
        self.curElevationRad = math.rad(self.externalProperties["InitialElevation"])
        self.curDistance = self.externalProperties["InitialDistance"]

        self:SetAndBoundsCheckAzimuthValues()
        self:SetAndBoundsCheckElevationValues()
        self:SetAndBoundsCheckDistanceValues()
    end

    function OrbitalCamera:GetModuleName()
        return "OrbitalCamera"
    end

    function OrbitalCamera:SetInitialOrientation(humanoid)
        if not humanoid or not humanoid.RootPart then
            warn("OrbitalCamera could not set initial orientation due to missing humanoid")
            return
        end
        local newDesiredLook = (humanoid.RootPart.CFrame.lookVector - Vector3.new(0,0.23,0)).unit
        local horizontalShift = Util.GetAngleBetweenXZVectors(newDesiredLook, self:GetCameraLookVector())
        local vertShift = math.asin(self:GetCameraLookVector().y) - math.asin(newDesiredLook.y)
        if not Util.IsFinite(horizontalShift) then
            horizontalShift = 0
        end
        if not Util.IsFinite(vertShift) then
            vertShift = 0
        end
        self.rotateInput = Vector2.new(horizontalShift, vertShift)
    end

    --[[ Functions of BaseCamera that are overridden by OrbitalCamera ]]--
    function OrbitalCamera:GetCameraToSubjectDistance()
        return self.curDistance
    end

    function OrbitalCamera:SetCameraToSubjectDistance(desiredSubjectDistance)
        print("OrbitalCamera SetCameraToSubjectDistance ",desiredSubjectDistance)
        local player = PlayersService.LocalPlayer
        if player then
            self.currentSubjectDistance = math.clamp(desiredSubjectDistance, self.minDistance, self.maxDistance)

            -- OrbitalCamera is not allowed to go into the first-person range
            self.currentSubjectDistance = math.max(self.currentSubjectDistance, self.FIRST_PERSON_DISTANCE_THRESHOLD)
        end
        self.inFirstPerson = false
        self:UpdateMouseBehavior()
        return self.currentSubjectDistance
    end

    function OrbitalCamera:CalculateNewLookVector(suppliedLookVector, xyRotateVector)
        local currLookVector = suppliedLookVector or self:GetCameraLookVector()
        local currPitchAngle = math.asin(currLookVector.y)
        local yTheta = math.clamp(xyRotateVector.y, currPitchAngle - math.rad(MAX_ALLOWED_ELEVATION_DEG), currPitchAngle - math.rad(MIN_ALLOWED_ELEVATION_DEG))
        local constrainedRotateInput = Vector2.new(xyRotateVector.x, yTheta)
        local startCFrame = CFrame.new(ZERO_VECTOR3, currLookVector)
        local newLookVector = (CFrame.Angles(0, -constrainedRotateInput.x, 0) * startCFrame * CFrame.Angles(-constrainedRotateInput.y,0,0)).lookVector
        return newLookVector
    end

    function OrbitalCamera:GetGamepadPan(name, state, input)
        if input.UserInputType == self.activeGamepad and input.KeyCode == Enum.KeyCode.Thumbstick2 then
            if self.r3ButtonDown or self.l3ButtonDown then
            -- R3 or L3 Thumbstick is depressed, right stick controls dolly in/out
                if (input.Position.Y > THUMBSTICK_DEADZONE) then
                    self.gamepadDollySpeedMultiplier = 0.96
                elseif (input.Position.Y < -THUMBSTICK_DEADZONE) then
                    self.gamepadDollySpeedMultiplier = 1.04
                else
                    self.gamepadDollySpeedMultiplier = 1.00
                end
            else
                if state == Enum.UserInputState.Cancel then
                    self.gamepadPanningCamera = ZERO_VECTOR2
                    return
                end

                local inputVector = Vector2.new(input.Position.X, -input.Position.Y)
                if inputVector.magnitude > THUMBSTICK_DEADZONE then
                    self.gamepadPanningCamera = Vector2.new(input.Position.X, -input.Position.Y)
                else
                    self.gamepadPanningCamera = ZERO_VECTOR2
                end
            end
            return Enum.ContextActionResult.Sink
        end
        return Enum.ContextActionResult.Pass
    end

    function OrbitalCamera:DoGamepadZoom(name, state, input)
        if input.UserInputType == self.activeGamepad and (input.KeyCode == Enum.KeyCode.ButtonR3 or input.KeyCode == Enum.KeyCode.ButtonL3) then
            if (state == Enum.UserInputState.Begin) then
                self.r3ButtonDown = input.KeyCode == Enum.KeyCode.ButtonR3
                self.l3ButtonDown = input.KeyCode == Enum.KeyCode.ButtonL3
            elseif (state == Enum.UserInputState.End) then
                if (input.KeyCode == Enum.KeyCode.ButtonR3) then
                    self.r3ButtonDown = false
                elseif (input.KeyCode == Enum.KeyCode.ButtonL3) then
                    self.l3ButtonDown = false
                end
                if (not self.r3ButtonDown) and (not self.l3ButtonDown) then
                    self.gamepadDollySpeedMultiplier = 1.00
                end
            end
            return Enum.ContextActionResult.Sink
        end
        return Enum.ContextActionResult.Pass
    end

    function OrbitalCamera:BindGamepadInputActions()
        self:BindAction("OrbitalCamGamepadPan", function(name, state, input) return self:GetGamepadPan(name, state, input) end,
            false, Enum.KeyCode.Thumbstick2)
        self:BindAction("OrbitalCamGamepadZoom", function(name, state, input) return self:DoGamepadZoom(name, state, input) end,
            false, Enum.KeyCode.ButtonR3, Enum.KeyCode.ButtonL3)
    end


    -- [[ Update ]]--
    function OrbitalCamera:Update(dt)
        local now = tick()
        local timeDelta = (now - self.lastUpdate)
        local userPanningTheCamera = (self.UserPanningTheCamera == true)
        local camera =  workspace.CurrentCamera
        local newCameraCFrame = camera.CFrame
        local newCameraFocus = camera.Focus
        local player = PlayersService.LocalPlayer
        local cameraSubject = camera and camera.CameraSubject
        local isInVehicle = cameraSubject and cameraSubject:IsA('VehicleSeat')
        local isOnASkateboard = cameraSubject and cameraSubject:IsA('SkateboardPlatform')

        if self.lastUpdate == nil or timeDelta > 1 then
            self.lastCameraTransform = nil
        end

        if self.lastUpdate then
            local gamepadRotation = self:UpdateGamepad()

            if self:ShouldUseVRRotation() then
                self.RotateInput = self.RotateInput + self:GetVRRotationInput()
            else
                -- Cap out the delta to 0.1 so we don't get some crazy things when we re-resume from
                local delta = math.min(0.1, timeDelta)

                if gamepadRotation ~= ZERO_VECTOR2 then
                    userPanningTheCamera = true
                    self.rotateInput = self.rotateInput + (gamepadRotation * delta)
                end

                local angle = 0
                if not (isInVehicle or isOnASkateboard) then
                    angle = angle + (self.TurningLeft and -120 or 0)
                    angle = angle + (self.TurningRight and 120 or 0)
                end

                if angle ~= 0 then
                    self.rotateInput = self.rotateInput +  Vector2.new(math.rad(angle * delta), 0)
                    userPanningTheCamera = true
                end
            end
        end

        -- Reset tween speed if user is panning
        if userPanningTheCamera then
            self.lastUserPanCamera = tick()
        end

        local subjectPosition = self:GetSubjectPosition()

        if subjectPosition and player and camera then

            -- Process any dollying being done by gamepad
            -- TODO: Move this
            if self.gamepadDollySpeedMultiplier ~= 1 then
                self:SetCameraToSubjectDistance(self.currentSubjectDistance * self.gamepadDollySpeedMultiplier)
            end

            local VREnabled = VRService.VREnabled
            newCameraFocus = VREnabled and self:GetVRFocus(subjectPosition, timeDelta) or CFrame.new(subjectPosition)

            local cameraFocusP = newCameraFocus.p
            if VREnabled and not self:IsInFirstPerson() then
                local cameraHeight = self:GetCameraHeight()
                local vecToSubject = (subjectPosition - camera.CFrame.p)
                local distToSubject = vecToSubject.magnitude

                -- Only move the camera if it exceeded a maximum distance to the subject in VR
                if distToSubject > self.currentSubjectDistance or self.rotateInput.x ~= 0 then
                    local desiredDist = math.min(distToSubject, self.currentSubjectDistance)

                    -- Note that CalculateNewLookVector is overridden from BaseCamera
                    vecToSubject = self:CalculateNewLookVector(vecToSubject.unit * X1_Y0_Z1, Vector2.new(self.rotateInput.x, 0)) * desiredDist

                    local newPos = cameraFocusP - vecToSubject
                    local desiredLookDir = camera.CFrame.lookVector
                    if self.rotateInput.x ~= 0 then
                        desiredLookDir = vecToSubject
                    end
                    local lookAt = Vector3.new(newPos.x + desiredLookDir.x, newPos.y, newPos.z + desiredLookDir.z)
                    self.RotateInput = ZERO_VECTOR2

                    newCameraCFrame = CFrame.new(newPos, lookAt) + Vector3.new(0, cameraHeight, 0)
                end
            else
                -- self.RotateInput is a Vector2 of mouse movement deltas since last update
                self.curAzimuthRad = self.curAzimuthRad - self.rotateInput.x

                if self.useAzimuthLimits then
                    self.curAzimuthRad = math.clamp(self.curAzimuthRad, self.minAzimuthAbsoluteRad, self.maxAzimuthAbsoluteRad)
                else
                    self.curAzimuthRad = (self.curAzimuthRad ~= 0) and (math.sign(self.curAzimuthRad) * (math.abs(self.curAzimuthRad) % TAU)) or 0
                end

                self.curElevationRad = math.clamp(self.curElevationRad + self.rotateInput.y, self.minElevationRad, self.maxElevationRad)

                local cameraPosVector = self.currentSubjectDistance * ( CFrame.fromEulerAnglesYXZ( -self.curElevationRad, self.curAzimuthRad, 0 ) * UNIT_Z )
                local camPos = subjectPosition + cameraPosVector

                newCameraCFrame = CFrame.new(camPos, subjectPosition)

                self.rotateInput = ZERO_VECTOR2
            end

            self.lastCameraTransform = newCameraCFrame
            self.lastCameraFocus = newCameraFocus
            if (isInVehicle or isOnASkateboard) and cameraSubject:IsA('BasePart') then
                self.lastSubjectCFrame = cameraSubject.CFrame
            else
                self.lastSubjectCFrame = nil
            end
        end

        self.lastUpdate = now
        return newCameraCFrame, newCameraFocus
    end

    return OrbitalCamera
end

function _ClassicCamera()

    -- Local private variables and constants
    local ZERO_VECTOR2 = Vector2.new(0,0)

    local tweenAcceleration = math.rad(220)     --Radians/Second^2
    local tweenSpeed = math.rad(0)              --Radians/Second
    local tweenMaxSpeed = math.rad(250)         --Radians/Second
    local TIME_BEFORE_AUTO_ROTATE = 2.0         --Seconds, used when auto-aligning camera with vehicles

    local INITIAL_CAMERA_ANGLE = CFrame.fromOrientation(math.rad(-15), 0, 0)

    local FFlagUserCameraToggle do
        local success, result = pcall(function()
            return UserSettings():IsUserFeatureEnabled("UserCameraToggle")
        end)
        FFlagUserCameraToggle = success and result
    end

    --[[ Services ]]--
    local PlayersService = game:GetService('Players')
    local VRService = game:GetService("VRService")

    local CameraInput = _CameraInput()
    local Util = _CameraUtils()

    --[[ The Module ]]--
    local BaseCamera = _BaseCamera()
    local ClassicCamera = setmetatable({}, BaseCamera)
    ClassicCamera.__index = ClassicCamera

    function ClassicCamera.new()
        local self = setmetatable(BaseCamera.new(), ClassicCamera)

        self.isFollowCamera = false
        self.isCameraToggle = false
        self.lastUpdate = tick()
        self.cameraToggleSpring = Util.Spring.new(5, 0)

        return self
    end

    function ClassicCamera:GetCameraToggleOffset(dt)
        assert(FFlagUserCameraToggle)

        if self.isCameraToggle then
            local zoom = self.currentSubjectDistance

            if CameraInput.getTogglePan() then
                self.cameraToggleSpring.goal = math.clamp(Util.map(zoom, 0.5, self.FIRST_PERSON_DISTANCE_THRESHOLD, 0, 1), 0, 1)
            else
                self.cameraToggleSpring.goal = 0
            end

            local distanceOffset = math.clamp(Util.map(zoom, 0.5, 64, 0, 1), 0, 1) + 1
            return Vector3.new(0, self.cameraToggleSpring:step(dt)*distanceOffset, 0)
        end

        return Vector3.new()
    end

    -- Movement mode standardized to Enum.ComputerCameraMovementMode values
    function ClassicCamera:SetCameraMovementMode(cameraMovementMode)
        BaseCamera.SetCameraMovementMode(self, cameraMovementMode)

        self.isFollowCamera = cameraMovementMode == Enum.ComputerCameraMovementMode.Follow
        self.isCameraToggle = cameraMovementMode == Enum.ComputerCameraMovementMode.CameraToggle
    end

    function ClassicCamera:Update()
        local now = tick()
        local timeDelta = now - self.lastUpdate

        local camera = workspace.CurrentCamera
        local newCameraCFrame = camera.CFrame
        local newCameraFocus = camera.Focus

        local overrideCameraLookVector = nil
        if self.resetCameraAngle then
            local rootPart = self:GetHumanoidRootPart()
            if rootPart then
                overrideCameraLookVector = (rootPart.CFrame * INITIAL_CAMERA_ANGLE).lookVector
            else
                overrideCameraLookVector = INITIAL_CAMERA_ANGLE.lookVector
            end
            self.resetCameraAngle = false
        end

        local player = PlayersService.LocalPlayer
        local humanoid = self:GetHumanoid()
        local cameraSubject = camera.CameraSubject
        local isInVehicle = cameraSubject and cameraSubject:IsA('VehicleSeat')
        local isOnASkateboard = cameraSubject and cameraSubject:IsA('SkateboardPlatform')
        local isClimbing = humanoid and humanoid:GetState() == Enum.HumanoidStateType.Climbing

        if self.lastUpdate == nil or timeDelta > 1 then
            self.lastCameraTransform = nil
        end

        if self.lastUpdate then
            local gamepadRotation = self:UpdateGamepad()

            if self:ShouldUseVRRotation() then
                self.rotateInput = self.rotateInput + self:GetVRRotationInput()
            else
                -- Cap out the delta to 0.1 so we don't get some crazy things when we re-resume from
                local delta = math.min(0.1, timeDelta)

                if gamepadRotation ~= ZERO_VECTOR2 then
                    self.rotateInput = self.rotateInput + (gamepadRotation * delta)
                end

                local angle = 0
                if not (isInVehicle or isOnASkateboard) then
                    angle = angle + (self.turningLeft and -120 or 0)
                    angle = angle + (self.turningRight and 120 or 0)
                end

                if angle ~= 0 then
                    self.rotateInput = self.rotateInput +  Vector2.new(math.rad(angle * delta), 0)
                end
            end
        end

        local cameraHeight = self:GetCameraHeight()

        -- Reset tween speed if user is panning
        if self.userPanningTheCamera then
            tweenSpeed = 0
            self.lastUserPanCamera = tick()
        end

        local userRecentlyPannedCamera = now - self.lastUserPanCamera < TIME_BEFORE_AUTO_ROTATE
        local subjectPosition = self:GetSubjectPosition()

        if subjectPosition and player and camera then
            local zoom = self:GetCameraToSubjectDistance()
            if zoom < 0.5 then
                zoom = 0.5
            end

            if self:GetIsMouseLocked() and not self:IsInFirstPerson() then
                -- We need to use the right vector of the camera after rotation, not before
                local newLookCFrame = self:CalculateNewLookCFrame(overrideCameraLookVector)

                local offset = self:GetMouseLockOffset()
                local cameraRelativeOffset = offset.X * newLookCFrame.rightVector + offset.Y * newLookCFrame.upVector + offset.Z * newLookCFrame.lookVector

                --offset can be NAN, NAN, NAN if newLookVector has only y component
                if Util.IsFiniteVector3(cameraRelativeOffset) then
                    subjectPosition = subjectPosition + cameraRelativeOffset
                end
            else
                if not self.userPanningTheCamera and self.lastCameraTransform then

                    local isInFirstPerson = self:IsInFirstPerson()

                    if (isInVehicle or isOnASkateboard or (self.isFollowCamera and isClimbing)) and self.lastUpdate and humanoid and humanoid.Torso then
                        if isInFirstPerson then
                            if self.lastSubjectCFrame and (isInVehicle or isOnASkateboard) and cameraSubject:IsA('BasePart') then
                                local y = -Util.GetAngleBetweenXZVectors(self.lastSubjectCFrame.lookVector, cameraSubject.CFrame.lookVector)
                                if Util.IsFinite(y) then
                                    self.rotateInput = self.rotateInput + Vector2.new(y, 0)
                                end
                                tweenSpeed = 0
                            end
                        elseif not userRecentlyPannedCamera then
                            local forwardVector = humanoid.Torso.CFrame.lookVector
                            if isOnASkateboard then
                                forwardVector = cameraSubject.CFrame.lookVector
                            end

                            tweenSpeed = math.clamp(tweenSpeed + tweenAcceleration * timeDelta, 0, tweenMaxSpeed)

                            local percent = math.clamp(tweenSpeed * timeDelta, 0, 1)
                            if self:IsInFirstPerson() and not (self.isFollowCamera and self.isClimbing) then
                                percent = 1
                            end

                            local y = Util.GetAngleBetweenXZVectors(forwardVector, self:GetCameraLookVector())
                            if Util.IsFinite(y) and math.abs(y) > 0.0001 then
                                self.rotateInput = self.rotateInput + Vector2.new(y * percent, 0)
                            end
                        end

                    elseif self.isFollowCamera and (not (isInFirstPerson or userRecentlyPannedCamera) and not VRService.VREnabled) then
                        -- Logic that was unique to the old FollowCamera module
                        local lastVec = -(self.lastCameraTransform.p - subjectPosition)

                        local y = Util.GetAngleBetweenXZVectors(lastVec, self:GetCameraLookVector())

                        -- This cutoff is to decide if the humanoid's angle of movement,
                        -- relative to the camera's look vector, is enough that
                        -- we want the camera to be following them. The point is to provide
                        -- a sizable dead zone to allow more precise forward movements.
                        local thetaCutoff = 0.4

                        -- Check for NaNs
                        if Util.IsFinite(y) and math.abs(y) > 0.0001 and math.abs(y) > thetaCutoff * timeDelta then
                            self.rotateInput = self.rotateInput + Vector2.new(y, 0)
                        end
                    end
                end
            end

            if not self.isFollowCamera then
                local VREnabled = VRService.VREnabled

                if VREnabled then
                    newCameraFocus = self:GetVRFocus(subjectPosition, timeDelta)
                else
                    newCameraFocus = CFrame.new(subjectPosition)
                end

                local cameraFocusP = newCameraFocus.p
                if VREnabled and not self:IsInFirstPerson() then
                    local vecToSubject = (subjectPosition - camera.CFrame.p)
                    local distToSubject = vecToSubject.magnitude

                    -- Only move the camera if it exceeded a maximum distance to the subject in VR
                    if distToSubject > zoom or self.rotateInput.x ~= 0 then
                        local desiredDist = math.min(distToSubject, zoom)
                        vecToSubject = self:CalculateNewLookVectorVR() * desiredDist
                        local newPos = cameraFocusP - vecToSubject
                        local desiredLookDir = camera.CFrame.lookVector
                        if self.rotateInput.x ~= 0 then
                            desiredLookDir = vecToSubject
                        end
                        local lookAt = Vector3.new(newPos.x + desiredLookDir.x, newPos.y, newPos.z + desiredLookDir.z)
                        self.rotateInput = ZERO_VECTOR2

                        newCameraCFrame = CFrame.new(newPos, lookAt) + Vector3.new(0, cameraHeight, 0)
                    end
                else
                    local newLookVector = self:CalculateNewLookVector(overrideCameraLookVector)
                    self.rotateInput = ZERO_VECTOR2
                    newCameraCFrame = CFrame.new(cameraFocusP - (zoom * newLookVector), cameraFocusP)
                end
            else -- is FollowCamera
                local newLookVector = self:CalculateNewLookVector(overrideCameraLookVector)
                self.rotateInput = ZERO_VECTOR2

                if VRService.VREnabled then
                    newCameraFocus = self:GetVRFocus(subjectPosition, timeDelta)
                else
                    newCameraFocus = CFrame.new(subjectPosition)
                end
                newCameraCFrame = CFrame.new(newCameraFocus.p - (zoom * newLookVector), newCameraFocus.p) + Vector3.new(0, cameraHeight, 0)
            end

            if FFlagUserCameraToggle then
                local toggleOffset = self:GetCameraToggleOffset(timeDelta)
                newCameraFocus = newCameraFocus + toggleOffset
                newCameraCFrame = newCameraCFrame + toggleOffset
            end

            self.lastCameraTransform = newCameraCFrame
            self.lastCameraFocus = newCameraFocus
            if (isInVehicle or isOnASkateboard) and cameraSubject:IsA('BasePart') then
                self.lastSubjectCFrame = cameraSubject.CFrame
            else
                self.lastSubjectCFrame = nil
            end
        end

        self.lastUpdate = now
        return newCameraCFrame, newCameraFocus
    end

    function ClassicCamera:EnterFirstPerson()
        self.inFirstPerson = true
        self:UpdateMouseBehavior()
    end

    function ClassicCamera:LeaveFirstPerson()
        self.inFirstPerson = false
        self:UpdateMouseBehavior()
    end

    return ClassicCamera
end

function _CameraUtils()

    local CameraUtils = {}

    local FFlagUserCameraToggle do
        local success, result = pcall(function()
            return UserSettings():IsUserFeatureEnabled("UserCameraToggle")
        end)
        FFlagUserCameraToggle = success and result
    end

    local function round(num)
        return math.floor(num + 0.5)
    end

    -- Critically damped spring class for fluid motion effects
    local Spring = {} do
        Spring.__index = Spring

        -- Initialize to a given undamped frequency and default position
        function Spring.new(freq, pos)
            return setmetatable({
                freq = freq,
                goal = pos,
                pos = pos,
                vel = 0,
            }, Spring)
        end

        -- Advance the spring simulation by `dt` seconds
        function Spring:step(dt)
            local f = self.freq*2*math.pi
            local g = self.goal
            local p0 = self.pos
            local v0 = self.vel

            local offset = p0 - g
            local decay = math.exp(-f*dt)

            local p1 = (offset*(1 + f*dt) + v0*dt)*decay + g
            local v1 = (v0*(1 - f*dt) - offset*(f*f*dt))*decay

            self.pos = p1
            self.vel = v1

            return p1
        end
    end

    CameraUtils.Spring = Spring

    -- map a value from one range to another
    function CameraUtils.map(x, inMin, inMax, outMin, outMax)
        return (x - inMin)*(outMax - outMin)/(inMax - inMin) + outMin
    end

    -- From TransparencyController
    function CameraUtils.Round(num, places)
        local decimalPivot = 10^places
        return math.floor(num * decimalPivot + 0.5) / decimalPivot
    end

    function CameraUtils.IsFinite(val)
        return val == val and val ~= math.huge and val ~= -math.huge
    end

    function CameraUtils.IsFiniteVector3(vec3)
        return CameraUtils.IsFinite(vec3.X) and CameraUtils.IsFinite(vec3.Y) and CameraUtils.IsFinite(vec3.Z)
    end

    -- Legacy implementation renamed
    function CameraUtils.GetAngleBetweenXZVectors(v1, v2)
        return math.atan2(v2.X*v1.Z-v2.Z*v1.X, v2.X*v1.X+v2.Z*v1.Z)
    end

    function  CameraUtils.RotateVectorByAngleAndRound(camLook, rotateAngle, roundAmount)
        if camLook.Magnitude > 0 then
            camLook = camLook.unit
            local currAngle = math.atan2(camLook.z, camLook.x)
            local newAngle = round((math.atan2(camLook.z, camLook.x) + rotateAngle) / roundAmount) * roundAmount
            return newAngle - currAngle
        end
        return 0
    end

    -- K is a tunable parameter that changes the shape of the S-curve
    -- the larger K is the more straight/linear the curve gets
    local k = 0.35
    local lowerK = 0.8
    local function SCurveTranform(t)
        t = math.clamp(t, -1, 1)
        if t >= 0 then
            return (k*t) / (k - t + 1)
        end
        return -((lowerK*-t) / (lowerK + t + 1))
    end

    local DEADZONE = 0.1
    local function toSCurveSpace(t)
        return (1 + DEADZONE) * (2*math.abs(t) - 1) - DEADZONE
    end

    local function fromSCurveSpace(t)
        return t/2 + 0.5
    end

    function CameraUtils.GamepadLinearToCurve(thumbstickPosition)
        local function onAxis(axisValue)
            local sign = 1
            if axisValue < 0 then
                sign = -1
            end
            local point = fromSCurveSpace(SCurveTranform(toSCurveSpace(math.abs(axisValue))))
            point = point * sign
            return math.clamp(point, -1, 1)
        end
        return Vector2.new(onAxis(thumbstickPosition.x), onAxis(thumbstickPosition.y))
    end

    -- This function converts 4 different, redundant enumeration types to one standard so the values can be compared
    function CameraUtils.ConvertCameraModeEnumToStandard(enumValue)
        if enumValue == Enum.TouchCameraMovementMode.Default then
            return Enum.ComputerCameraMovementMode.Follow
        end

        if enumValue == Enum.ComputerCameraMovementMode.Default then
            return Enum.ComputerCameraMovementMode.Classic
        end

        if enumValue == Enum.TouchCameraMovementMode.Classic or
            enumValue == Enum.DevTouchCameraMovementMode.Classic or
            enumValue == Enum.DevComputerCameraMovementMode.Classic or
            enumValue == Enum.ComputerCameraMovementMode.Classic then
            return Enum.ComputerCameraMovementMode.Classic
        end

        if enumValue == Enum.TouchCameraMovementMode.Follow or
            enumValue == Enum.DevTouchCameraMovementMode.Follow or
            enumValue == Enum.DevComputerCameraMovementMode.Follow or
            enumValue == Enum.ComputerCameraMovementMode.Follow then
            return Enum.ComputerCameraMovementMode.Follow
        end

        if enumValue == Enum.TouchCameraMovementMode.Orbital or
            enumValue == Enum.DevTouchCameraMovementMode.Orbital or
            enumValue == Enum.DevComputerCameraMovementMode.Orbital or
            enumValue == Enum.ComputerCameraMovementMode.Orbital then
            return Enum.ComputerCameraMovementMode.Orbital
        end

        if FFlagUserCameraToggle then
            if enumValue == Enum.ComputerCameraMovementMode.CameraToggle or
                enumValue == Enum.DevComputerCameraMovementMode.CameraToggle then
                return Enum.ComputerCameraMovementMode.CameraToggle
            end
        end

        -- Note: Only the Dev versions of the Enums have UserChoice as an option
        if enumValue == Enum.DevTouchCameraMovementMode.UserChoice or
            enumValue == Enum.DevComputerCameraMovementMode.UserChoice then
            return Enum.DevComputerCameraMovementMode.UserChoice
        end

        -- For any unmapped options return Classic camera
        return Enum.ComputerCameraMovementMode.Classic
    end

    return CameraUtils
end

function _CameraModule()
    local CameraModule = {}
    CameraModule.__index = CameraModule

    local FFlagUserCameraToggle do
        local success, result = pcall(function()
            return UserSettings():IsUserFeatureEnabled("UserCameraToggle")
        end)
        FFlagUserCameraToggle = success and result
    end

    local FFlagUserRemoveTheCameraApi do
        local success, result = pcall(function()
            return UserSettings():IsUserFeatureEnabled("UserRemoveTheCameraApi")
        end)
        FFlagUserRemoveTheCameraApi = success and result
    end

    -- NOTICE: Player property names do not all match their StarterPlayer equivalents,
    -- with the differences noted in the comments on the right
    local PLAYER_CAMERA_PROPERTIES =
    {
        "CameraMinZoomDistance",
        "CameraMaxZoomDistance",
        "CameraMode",
        "DevCameraOcclusionMode",
        "DevComputerCameraMode",            -- Corresponds to StarterPlayer.DevComputerCameraMovementMode
        "DevTouchCameraMode",               -- Corresponds to StarterPlayer.DevTouchCameraMovementMode

        -- Character movement mode
        "DevComputerMovementMode",
        "DevTouchMovementMode",
        "DevEnableMouseLock",               -- Corresponds to StarterPlayer.EnableMouseLockOption
    }

    local USER_GAME_SETTINGS_PROPERTIES =
    {
        "ComputerCameraMovementMode",
        "ComputerMovementMode",
        "ControlMode",
        "GamepadCameraSensitivity",
        "MouseSensitivity",
        "RotationType",
        "TouchCameraMovementMode",
        "TouchMovementMode",
    }

    --[[ Roblox Services ]]--
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local UserGameSettings = UserSettings():GetService("UserGameSettings")

    -- Camera math utility library
    local CameraUtils = _CameraUtils()

    -- Load Roblox Camera Controller Modules
    local ClassicCamera = _ClassicCamera()
    local OrbitalCamera = _OrbitalCamera()
    local LegacyCamera = _LegacyCamera()

    -- Load Roblox Occlusion Modules
    local Invisicam = _Invisicam()
    local Poppercam = _Poppercam()

    -- Load the near-field character transparency controller and the mouse lock "shift lock" controller
    local TransparencyController = _TransparencyController()
    local MouseLockController = _MouseLockController()

    -- Table of camera controllers that have been instantiated. They are instantiated as they are used.
    local instantiatedCameraControllers = {}
    local instantiatedOcclusionModules = {}

    -- Management of which options appear on the Roblox User Settings screen
    do
        local PlayerScripts = Players.LocalPlayer:WaitForChild("PlayerScripts")

        PlayerScripts:RegisterTouchCameraMovementMode(Enum.TouchCameraMovementMode.Default)
        PlayerScripts:RegisterTouchCameraMovementMode(Enum.TouchCameraMovementMode.Follow)
        PlayerScripts:RegisterTouchCameraMovementMode(Enum.TouchCameraMovementMode.Classic)

        PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.Default)
        PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.Follow)
        PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.Classic)
        if FFlagUserCameraToggle then
            PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.CameraToggle)
        end
    end

    CameraModule.FFlagUserCameraToggle = FFlagUserCameraToggle


    function CameraModule.new()
        local self = setmetatable({},CameraModule)

        -- Current active controller instances
        self.activeCameraController = nil
        self.activeOcclusionModule = nil
        self.activeTransparencyController = nil
        self.activeMouseLockController = nil

        self.currentComputerCameraMovementMode = nil

        -- Connections to events
        self.cameraSubjectChangedConn = nil
        self.cameraTypeChangedConn = nil

        -- Adds CharacterAdded and CharacterRemoving event handlers for all current players
        for _,player in pairs(Players:GetPlayers()) do
            self:OnPlayerAdded(player)
        end

        -- Adds CharacterAdded and CharacterRemoving event handlers for all players who join in the future
        Players.PlayerAdded:Connect(function(player)
            self:OnPlayerAdded(player)
        end)

        self.activeTransparencyController = TransparencyController.new()
        self.activeTransparencyController:Enable(true)

        if not UserInputService.TouchEnabled then
            self.activeMouseLockController = MouseLockController.new()
            local toggleEvent = self.activeMouseLockController:GetBindableToggleEvent()
            if toggleEvent then
                toggleEvent:Connect(function()
                    self:OnMouseLockToggled()
                end)
            end
        end

        self:ActivateCameraController(self:GetCameraControlChoice())
        self:ActivateOcclusionModule(Players.LocalPlayer.DevCameraOcclusionMode)
        self:OnCurrentCameraChanged() -- Does initializations and makes first camera controller
        RunService:BindToRenderStep("cameraRenderUpdate", Enum.RenderPriority.Camera.Value, function(dt) self:Update(dt) end)

        -- Connect listeners to camera-related properties
        for _, propertyName in pairs(PLAYER_CAMERA_PROPERTIES) do
            Players.LocalPlayer:GetPropertyChangedSignal(propertyName):Connect(function()
                self:OnLocalPlayerCameraPropertyChanged(propertyName)
            end)
        end

        for _, propertyName in pairs(USER_GAME_SETTINGS_PROPERTIES) do
            UserGameSettings:GetPropertyChangedSignal(propertyName):Connect(function()
                self:OnUserGameSettingsPropertyChanged(propertyName)
            end)
        end
        game.Workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
            self:OnCurrentCameraChanged()
        end)

        self.lastInputType = UserInputService:GetLastInputType()
        UserInputService.LastInputTypeChanged:Connect(function(newLastInputType)
            self.lastInputType = newLastInputType
        end)

        return self
    end

    function CameraModule:GetCameraMovementModeFromSettings()
        local cameraMode = Players.LocalPlayer.CameraMode

        -- Lock First Person trumps all other settings and forces ClassicCamera
        if cameraMode == Enum.CameraMode.LockFirstPerson then
            return CameraUtils.ConvertCameraModeEnumToStandard(Enum.ComputerCameraMovementMode.Classic)
        end

        local devMode, userMode
        if UserInputService.TouchEnabled then
            devMode = CameraUtils.ConvertCameraModeEnumToStandard(Players.LocalPlayer.DevTouchCameraMode)
            userMode = CameraUtils.ConvertCameraModeEnumToStandard(UserGameSettings.TouchCameraMovementMode)
        else
            devMode = CameraUtils.ConvertCameraModeEnumToStandard(Players.LocalPlayer.DevComputerCameraMode)
            userMode = CameraUtils.ConvertCameraModeEnumToStandard(UserGameSettings.ComputerCameraMovementMode)
        end

        if devMode == Enum.DevComputerCameraMovementMode.UserChoice then
            -- Developer is allowing user choice, so user setting is respected
            return userMode
        end

        return devMode
    end

    function CameraModule:ActivateOcclusionModule( occlusionMode )
        local newModuleCreator
        if occlusionMode == Enum.DevCameraOcclusionMode.Zoom then
            newModuleCreator = Poppercam
        elseif occlusionMode == Enum.DevCameraOcclusionMode.Invisicam then
            newModuleCreator = Invisicam
        else
            warn("CameraScript ActivateOcclusionModule called with unsupported mode")
            return
        end

        -- First check to see if there is actually a change. If the module being requested is already
        -- the currently-active solution then just make sure it's enabled and exit early
        if self.activeOcclusionModule and self.activeOcclusionModule:GetOcclusionMode() == occlusionMode then
            if not self.activeOcclusionModule:GetEnabled() then
                self.activeOcclusionModule:Enable(true)
            end
            return
        end

        -- Save a reference to the current active module (may be nil) so that we can disable it if
        -- we are successful in activating its replacement
        local prevOcclusionModule = self.activeOcclusionModule

        -- If there is no active module, see if the one we need has already been instantiated
        self.activeOcclusionModule = instantiatedOcclusionModules[newModuleCreator]

        -- If the module was not already instantiated and selected above, instantiate it
        if not self.activeOcclusionModule then
            self.activeOcclusionModule = newModuleCreator.new()
            if self.activeOcclusionModule then
                instantiatedOcclusionModules[newModuleCreator] = self.activeOcclusionModule
            end
        end

        -- If we were successful in either selecting or instantiating the module,
        -- enable it if it's not already the currently-active enabled module
        if self.activeOcclusionModule then
            local newModuleOcclusionMode = self.activeOcclusionModule:GetOcclusionMode()
            -- Sanity check that the module we selected or instantiated actually supports the desired occlusionMode
            if newModuleOcclusionMode ~= occlusionMode then
                warn("CameraScript ActivateOcclusionModule mismatch: ",self.activeOcclusionModule:GetOcclusionMode(),"~=",occlusionMode)
            end

            -- Deactivate current module if there is one
            if prevOcclusionModule then
                -- Sanity check that current module is not being replaced by itself (that should have been handled above)
                if prevOcclusionModule ~= self.activeOcclusionModule then
                    prevOcclusionModule:Enable(false)
                else
                    warn("CameraScript ActivateOcclusionModule failure to detect already running correct module")
                end
            end

            -- Occlusion modules need to be initialized with information about characters and cameraSubject
            -- Invisicam needs the LocalPlayer's character
            -- Poppercam needs all player characters and the camera subject
            if occlusionMode == Enum.DevCameraOcclusionMode.Invisicam then
                -- Optimization to only send Invisicam what we know it needs
                if Players.LocalPlayer.Character then
                    self.activeOcclusionModule:CharacterAdded(Players.LocalPlayer.Character, Players.LocalPlayer )
                end
            else
                -- When Poppercam is enabled, we send it all existing player characters for its raycast ignore list
                for _, player in pairs(Players:GetPlayers()) do
                    if player and player.Character then
                        self.activeOcclusionModule:CharacterAdded(player.Character, player)
                    end
                end
                self.activeOcclusionModule:OnCameraSubjectChanged(game.Workspace.CurrentCamera.CameraSubject)
            end

            -- Activate new choice
            self.activeOcclusionModule:Enable(true)
        end
    end

    -- When supplied, legacyCameraType is used and cameraMovementMode is ignored (should be nil anyways)
    -- Next, if userCameraCreator is passed in, that is used as the cameraCreator
    function CameraModule:ActivateCameraController(cameraMovementMode, legacyCameraType)
        local newCameraCreator = nil

        if legacyCameraType~=nil then
            --[[
                This function has been passed a CameraType enum value. Some of these map to the use of
                the LegacyCamera module, the value "Custom" will be translated to a movementMode enum
                value based on Dev and User settings, and "Scriptable" will disable the camera controller.
            --]]

            if legacyCameraType == Enum.CameraType.Scriptable then
                if self.activeCameraController then
                    self.activeCameraController:Enable(false)
                    self.activeCameraController = nil
                    return
                end
            elseif legacyCameraType == Enum.CameraType.Custom then
                cameraMovementMode = self:GetCameraMovementModeFromSettings()

            elseif legacyCameraType == Enum.CameraType.Track then
                -- Note: The TrackCamera module was basically an older, less fully-featured
                -- version of ClassicCamera, no longer actively maintained, but it is re-implemented in
                -- case a game was dependent on its lack of ClassicCamera's extra functionality.
                cameraMovementMode = Enum.ComputerCameraMovementMode.Classic

            elseif legacyCameraType == Enum.CameraType.Follow then
                cameraMovementMode = Enum.ComputerCameraMovementMode.Follow

            elseif legacyCameraType == Enum.CameraType.Orbital then
                cameraMovementMode = Enum.ComputerCameraMovementMode.Orbital

            elseif legacyCameraType == Enum.CameraType.Attach or
                   legacyCameraType == Enum.CameraType.Watch or
                   legacyCameraType == Enum.CameraType.Fixed then
                newCameraCreator = LegacyCamera
            else
                warn("CameraScript encountered an unhandled Camera.CameraType value: ",legacyCameraType)
            end
        end

        if not newCameraCreator then
            if cameraMovementMode == Enum.ComputerCameraMovementMode.Classic or
                cameraMovementMode == Enum.ComputerCameraMovementMode.Follow or
                cameraMovementMode == Enum.ComputerCameraMovementMode.Default or
                (FFlagUserCameraToggle and cameraMovementMode == Enum.ComputerCameraMovementMode.CameraToggle) then
                newCameraCreator = ClassicCamera
            elseif cameraMovementMode == Enum.ComputerCameraMovementMode.Orbital then
                newCameraCreator = OrbitalCamera
            else
                warn("ActivateCameraController did not select a module.")
                return
            end
        end

        -- Create the camera control module we need if it does not already exist in instantiatedCameraControllers
        local newCameraController
        if not instantiatedCameraControllers[newCameraCreator] then
            newCameraController = newCameraCreator.new()
            instantiatedCameraControllers[newCameraCreator] = newCameraController
        else
            newCameraController = instantiatedCameraControllers[newCameraCreator]
        end

        -- If there is a controller active and it's not the one we need, disable it,
        -- if it is the one we need, make sure it's enabled
        if self.activeCameraController then
            if self.activeCameraController ~= newCameraController then
                self.activeCameraController:Enable(false)
                self.activeCameraController = newCameraController
                self.activeCameraController:Enable(true)
            elseif not self.activeCameraController:GetEnabled() then
                self.activeCameraController:Enable(true)
            end
        elseif newCameraController ~= nil then
            self.activeCameraController = newCameraController
            self.activeCameraController:Enable(true)
        end

        if self.activeCameraController then
            if cameraMovementMode~=nil then
                self.activeCameraController:SetCameraMovementMode(cameraMovementMode)
            elseif legacyCameraType~=nil then
                -- Note that this is only called when legacyCameraType is not a type that
                -- was convertible to a ComputerCameraMovementMode value, i.e. really only applies to LegacyCamera
                self.activeCameraController:SetCameraType(legacyCameraType)
            end
        end
    end

    -- Note: The active transparency controller could be made to listen for this event itself.
    function CameraModule:OnCameraSubjectChanged()
        if self.activeTransparencyController then
            self.activeTransparencyController:SetSubject(game.Workspace.CurrentCamera.CameraSubject)
        end

        if self.activeOcclusionModule then
            self.activeOcclusionModule:OnCameraSubjectChanged(game.Workspace.CurrentCamera.CameraSubject)
        end
    end

    function CameraModule:OnCameraTypeChanged(newCameraType)
        if newCameraType == Enum.CameraType.Scriptable then
            if UserInputService.MouseBehavior == Enum.MouseBehavior.LockCenter then
                UserInputService.MouseBehavior = Enum.MouseBehavior.Default
            end
        end

        -- Forward the change to ActivateCameraController to handle
        self:ActivateCameraController(nil, newCameraType)
    end

    -- Note: Called whenever workspace.CurrentCamera changes, but also on initialization of this script
    function CameraModule:OnCurrentCameraChanged()
        local currentCamera = game.Workspace.CurrentCamera
        if not currentCamera then return end

        if self.cameraSubjectChangedConn then
            self.cameraSubjectChangedConn:Disconnect()
        end

        if self.cameraTypeChangedConn then
            self.cameraTypeChangedConn:Disconnect()
        end

        self.cameraSubjectChangedConn = currentCamera:GetPropertyChangedSignal("CameraSubject"):Connect(function()
            self:OnCameraSubjectChanged(currentCamera.CameraSubject)
        end)

        self.cameraTypeChangedConn = currentCamera:GetPropertyChangedSignal("CameraType"):Connect(function()
            self:OnCameraTypeChanged(currentCamera.CameraType)
        end)

        self:OnCameraSubjectChanged(currentCamera.CameraSubject)
        self:OnCameraTypeChanged(currentCamera.CameraType)
    end

    function CameraModule:OnLocalPlayerCameraPropertyChanged(propertyName)
        if propertyName == "CameraMode" then
            -- CameraMode is only used to turn on/off forcing the player into first person view. The
            -- Note: The case "Classic" is used for all other views and does not correspond only to the ClassicCamera module
            if Players.LocalPlayer.CameraMode == Enum.CameraMode.LockFirstPerson then
                -- Locked in first person, use ClassicCamera which supports this
                if not self.activeCameraController or self.activeCameraController:GetModuleName() ~= "ClassicCamera" then
                    self:ActivateCameraController(CameraUtils.ConvertCameraModeEnumToStandard(Enum.DevComputerCameraMovementMode.Classic))
                end

                if self.activeCameraController then
                    self.activeCameraController:UpdateForDistancePropertyChange()
                end
            elseif Players.LocalPlayer.CameraMode == Enum.CameraMode.Classic then
                -- Not locked in first person view
                local cameraMovementMode =self: GetCameraMovementModeFromSettings()
                self:ActivateCameraController(CameraUtils.ConvertCameraModeEnumToStandard(cameraMovementMode))
            else
                warn("Unhandled value for property player.CameraMode: ",Players.LocalPlayer.CameraMode)
            end

        elseif propertyName == "DevComputerCameraMode" or
               propertyName == "DevTouchCameraMode" then
            local cameraMovementMode = self:GetCameraMovementModeFromSettings()
            self:ActivateCameraController(CameraUtils.ConvertCameraModeEnumToStandard(cameraMovementMode))

        elseif propertyName == "DevCameraOcclusionMode" then
            self:ActivateOcclusionModule(Players.LocalPlayer.DevCameraOcclusionMode)

        elseif propertyName == "CameraMinZoomDistance" or propertyName == "CameraMaxZoomDistance" then
            if self.activeCameraController then
                self.activeCameraController:UpdateForDistancePropertyChange()
            end
        elseif propertyName == "DevTouchMovementMode" then
        elseif propertyName == "DevComputerMovementMode" then
        elseif propertyName == "DevEnableMouseLock" then
            -- This is the enabling/disabling of "Shift Lock" mode, not LockFirstPerson (which is a CameraMode)
            -- Note: Enabling and disabling of MouseLock mode is normally only a publish-time choice made via
            -- the corresponding EnableMouseLockOption checkbox of StarterPlayer, and this script does not have
            -- support for changing the availability of MouseLock at runtime (this would require listening to
            -- Player.DevEnableMouseLock changes)
        end
    end

    function CameraModule:OnUserGameSettingsPropertyChanged(propertyName)
        if propertyName ==  "ComputerCameraMovementMode" then
            local cameraMovementMode = self:GetCameraMovementModeFromSettings()
            self:ActivateCameraController(CameraUtils.ConvertCameraModeEnumToStandard(cameraMovementMode))
        end
    end

    --[[
        Main RenderStep Update. The camera controller and occlusion module both have opportunities
        to set and modify (respectively) the CFrame and Focus before it is set once on CurrentCamera.
        The camera and occlusion modules should only return CFrames, not set the CFrame property of
        CurrentCamera directly.
    --]]
    function CameraModule:Update(dt)
        if self.activeCameraController then
            if FFlagUserCameraToggle then
                self.activeCameraController:UpdateMouseBehavior()
            end

            local newCameraCFrame, newCameraFocus = self.activeCameraController:Update(dt)
            self.activeCameraController:ApplyVRTransform()
            if self.activeOcclusionModule then
                newCameraCFrame, newCameraFocus = self.activeOcclusionModule:Update(dt, newCameraCFrame, newCameraFocus)
            end

            -- Here is where the new CFrame and Focus are set for this render frame
            game.Workspace.CurrentCamera.CFrame = newCameraCFrame
            game.Workspace.CurrentCamera.Focus = newCameraFocus

            -- Update to character local transparency as needed based on camera-to-subject distance
            if self.activeTransparencyController then
                self.activeTransparencyController:Update()
            end
        end
    end

    -- Formerly getCurrentCameraMode, this function resolves developer and user camera control settings to
    -- decide which camera control module should be instantiated. The old method of converting redundant enum types
    function CameraModule:GetCameraControlChoice()
        local player = Players.LocalPlayer

        if player then
            if self.lastInputType == Enum.UserInputType.Touch or UserInputService.TouchEnabled then
                -- Touch
                if player.DevTouchCameraMode == Enum.DevTouchCameraMovementMode.UserChoice then
                    return CameraUtils.ConvertCameraModeEnumToStandard( UserGameSettings.TouchCameraMovementMode )
                else
                    return CameraUtils.ConvertCameraModeEnumToStandard( player.DevTouchCameraMode )
                end
            else
                -- Computer
                if player.DevComputerCameraMode == Enum.DevComputerCameraMovementMode.UserChoice then
                    local computerMovementMode = CameraUtils.ConvertCameraModeEnumToStandard(UserGameSettings.ComputerCameraMovementMode)
                    return CameraUtils.ConvertCameraModeEnumToStandard(computerMovementMode)
                else
                    return CameraUtils.ConvertCameraModeEnumToStandard(player.DevComputerCameraMode)
                end
            end
        end
    end

    function CameraModule:OnCharacterAdded(char, player)
        if self.activeOcclusionModule then
            self.activeOcclusionModule:CharacterAdded(char, player)
        end
    end

    function CameraModule:OnCharacterRemoving(char, player)
        if self.activeOcclusionModule then
            self.activeOcclusionModule:CharacterRemoving(char, player)
        end
    end

    function CameraModule:OnPlayerAdded(player)
        player.CharacterAdded:Connect(function(char)
            self:OnCharacterAdded(char, player)
        end)
        player.CharacterRemoving:Connect(function(char)
            self:OnCharacterRemoving(char, player)
        end)
    end

    function CameraModule:OnMouseLockToggled()
        if self.activeMouseLockController then
            local mouseLocked = self.activeMouseLockController:GetIsMouseLocked()
            local mouseLockOffset = self.activeMouseLockController:GetMouseLockOffset()
            if self.activeCameraController then
                self.activeCameraController:SetIsMouseLocked(mouseLocked)
                self.activeCameraController:SetMouseLockOffset(mouseLockOffset)
            end
        end
    end
    --begin edit
    local Camera = CameraModule
    local IDENTITYCF = CFrame.new()
    local lastUpCFrame = IDENTITYCF

    Camera.UpVector = Vector3.new(0, 1, 0)
    Camera.TransitionRate = 0.15
    Camera.UpCFrame = IDENTITYCF

    function Camera:GetUpVector(oldUpVector)
        return oldUpVector
    end
    local function getRotationBetween(u, v, axis)
        local dot, uxv = u:Dot(v), u:Cross(v)
        if (dot < -0.99999) then return CFrame.fromAxisAngle(axis, math.pi) end
        return CFrame.new(0, 0, 0, uxv.x, uxv.y, uxv.z, 1 + dot)
    end
    function Camera:CalculateUpCFrame()
        local oldUpVector = self.UpVector
        local newUpVector = self:GetUpVector(oldUpVector)

        local backup = game.Workspace.CurrentCamera.CFrame.RightVector
        local transitionCF = getRotationBetween(oldUpVector, newUpVector, backup)
        local vecSlerpCF = IDENTITYCF:Lerp(transitionCF, self.TransitionRate)

        self.UpVector = vecSlerpCF * oldUpVector
        self.UpCFrame = vecSlerpCF * self.UpCFrame

        lastUpCFrame = self.UpCFrame
    end

    function Camera:Update(dt)
        if self.activeCameraController then
            if Camera.FFlagUserCameraToggle then
                self.activeCameraController:UpdateMouseBehavior()
            end

            local newCameraCFrame, newCameraFocus = self.activeCameraController:Update(dt)
            self.activeCameraController:ApplyVRTransform()

            self:CalculateUpCFrame()
            self.activeCameraController:UpdateUpCFrame(self.UpCFrame)

            -- undo shift-lock offset

            local lockOffset = Vector3.new(0, 0, 0)
            if (self.activeMouseLockController and self.activeMouseLockController:GetIsMouseLocked()) then
                lockOffset = self.activeMouseLockController:GetMouseLockOffset()
            end

            local offset = newCameraFocus:ToObjectSpace(newCameraCFrame)
            local camRotation = self.UpCFrame * offset
            newCameraFocus = newCameraFocus - newCameraCFrame:VectorToWorldSpace(lockOffset) + camRotation:VectorToWorldSpace(lockOffset)
            newCameraCFrame = newCameraFocus * camRotation

            --local offset = newCameraFocus:Inverse() * newCameraCFrame
            --newCameraCFrame = newCameraFocus * self.UpCFrame * offset

            if (self.activeCameraController.lastCameraTransform) then
                self.activeCameraController.lastCameraTransform = newCameraCFrame
                self.activeCameraController.lastCameraFocus = newCameraFocus
            end

            if self.activeOcclusionModule then
                newCameraCFrame, newCameraFocus = self.activeOcclusionModule:Update(dt, newCameraCFrame, newCameraFocus)
            end

            game.Workspace.CurrentCamera.CFrame = newCameraCFrame
            game.Workspace.CurrentCamera.Focus = newCameraFocus

            if self.activeTransparencyController then
                self.activeTransparencyController:Update()
            end
        end
    end

    function Camera:IsFirstPerson()
        if self.activeCameraController then
            return self.activeCameraController:InFirstPerson()
        end
        return false
    end

    function Camera:IsMouseLocked()
        if self.activeCameraController then
            return self.activeCameraController:GetIsMouseLocked()
        end
        return false
    end
    function Camera:IsToggleMode()
        if self.activeCameraController then
            return self.activeCameraController.isCameraToggle
        end
        return false
    end
    function Camera:IsCamRelative()
        return self:IsMouseLocked() or self:IsFirstPerson()
        --return self:IsToggleMode(), self:IsMouseLocked(), self:IsFirstPerson()
    end
    --
    local Utils = _CameraUtils()
    function Utils.GetAngleBetweenXZVectors(v1, v2)
        local upCFrame = lastUpCFrame
        v1 = upCFrame:VectorToObjectSpace(v1)
        v2 = upCFrame:VectorToObjectSpace(v2)
        return math.atan2(v2.X*v1.Z-v2.Z*v1.X, v2.X*v1.X+v2.Z*v1.Z)
    end
    --end edit
    local cameraModuleObject = CameraModule.new()
    local cameraApi = {}
    return cameraModuleObject
end

function _ClickToMoveDisplay()
    local ClickToMoveDisplay = {}

    local FAILURE_ANIMATION_ID = "rbxassetid://2874840706"

    local TrailDotIcon = "rbxasset://textures/ui/traildot.png"
    local EndWaypointIcon = "rbxasset://textures/ui/waypoint.png"

    local WaypointsAlwaysOnTop = false

    local WAYPOINT_INCLUDE_FACTOR = 2
    local LAST_DOT_DISTANCE = 3

    local WAYPOINT_BILLBOARD_SIZE = UDim2.new(0, 1.68 * 25, 0, 2 * 25)

    local ENDWAYPOINT_SIZE_OFFSET_MIN = Vector2.new(0, 0.5)
    local ENDWAYPOINT_SIZE_OFFSET_MAX = Vector2.new(0, 1)

    local FAIL_WAYPOINT_SIZE_OFFSET_CENTER = Vector2.new(0, 0.5)
    local FAIL_WAYPOINT_SIZE_OFFSET_LEFT = Vector2.new(0.1, 0.5)
    local FAIL_WAYPOINT_SIZE_OFFSET_RIGHT = Vector2.new(-0.1, 0.5)

    local FAILURE_TWEEN_LENGTH = 0.125
    local FAILURE_TWEEN_COUNT = 4

    local TWEEN_WAYPOINT_THRESHOLD = 5

    local TRAIL_DOT_PARENT_NAME = "ClickToMoveDisplay"

    local TrailDotSize = Vector2.new(1.5, 1.5)

    local TRAIL_DOT_MIN_SCALE = 1
    local TRAIL_DOT_MIN_DISTANCE = 10
    local TRAIL_DOT_MAX_SCALE = 2.5
    local TRAIL_DOT_MAX_DISTANCE = 100

    local PlayersService = game:GetService("Players")
    local TweenService = game:GetService("TweenService")
    local RunService = game:GetService("RunService")
    local Workspace = game:GetService("Workspace")

    local LocalPlayer = PlayersService.LocalPlayer

    local function CreateWaypointTemplates()
        local TrailDotTemplate = Instance.new("Part")
        TrailDotTemplate.Size = Vector3.new(1, 1, 1)
        TrailDotTemplate.Anchored = true
        TrailDotTemplate.CanCollide = false
        TrailDotTemplate.Name = "TrailDot"
        TrailDotTemplate.Transparency = 1
        local TrailDotImage = Instance.new("ImageHandleAdornment")
        TrailDotImage.Name = "TrailDotImage"
        TrailDotImage.Size = TrailDotSize
        TrailDotImage.SizeRelativeOffset = Vector3.new(0, 0, -0.1)
        TrailDotImage.AlwaysOnTop = WaypointsAlwaysOnTop
        TrailDotImage.Image = TrailDotIcon
        TrailDotImage.Adornee = TrailDotTemplate
        TrailDotImage.Parent = TrailDotTemplate

        local EndWaypointTemplate = Instance.new("Part")
        EndWaypointTemplate.Size = Vector3.new(2, 2, 2)
        EndWaypointTemplate.Anchored = true
        EndWaypointTemplate.CanCollide = false
        EndWaypointTemplate.Name = "EndWaypoint"
        EndWaypointTemplate.Transparency = 1
        local EndWaypointImage = Instance.new("ImageHandleAdornment")
        EndWaypointImage.Name = "TrailDotImage"
        EndWaypointImage.Size = TrailDotSize
        EndWaypointImage.SizeRelativeOffset = Vector3.new(0, 0, -0.1)
        EndWaypointImage.AlwaysOnTop = WaypointsAlwaysOnTop
        EndWaypointImage.Image = TrailDotIcon
        EndWaypointImage.Adornee = EndWaypointTemplate
        EndWaypointImage.Parent = EndWaypointTemplate
        local EndWaypointBillboard = Instance.new("BillboardGui")
        EndWaypointBillboard.Name = "EndWaypointBillboard"
        EndWaypointBillboard.Size = WAYPOINT_BILLBOARD_SIZE
        EndWaypointBillboard.LightInfluence = 0
        EndWaypointBillboard.SizeOffset = ENDWAYPOINT_SIZE_OFFSET_MIN
        EndWaypointBillboard.AlwaysOnTop = true
        EndWaypointBillboard.Adornee = EndWaypointTemplate
        EndWaypointBillboard.Parent = EndWaypointTemplate
        local EndWaypointImageLabel = Instance.new("ImageLabel")
        EndWaypointImageLabel.Image = EndWaypointIcon
        EndWaypointImageLabel.BackgroundTransparency = 1
        EndWaypointImageLabel.Size = UDim2.new(1, 0, 1, 0)
        EndWaypointImageLabel.Parent = EndWaypointBillboard


        local FailureWaypointTemplate = Instance.new("Part")
        FailureWaypointTemplate.Size = Vector3.new(2, 2, 2)
        FailureWaypointTemplate.Anchored = true
        FailureWaypointTemplate.CanCollide = false
        FailureWaypointTemplate.Name = "FailureWaypoint"
        FailureWaypointTemplate.Transparency = 1
        local FailureWaypointImage = Instance.new("ImageHandleAdornment")
        FailureWaypointImage.Name = "TrailDotImage"
        FailureWaypointImage.Size = TrailDotSize
        FailureWaypointImage.SizeRelativeOffset = Vector3.new(0, 0, -0.1)
        FailureWaypointImage.AlwaysOnTop = WaypointsAlwaysOnTop
        FailureWaypointImage.Image = TrailDotIcon
        FailureWaypointImage.Adornee = FailureWaypointTemplate
        FailureWaypointImage.Parent = FailureWaypointTemplate
        local FailureWaypointBillboard = Instance.new("BillboardGui")
        FailureWaypointBillboard.Name = "FailureWaypointBillboard"
        FailureWaypointBillboard.Size = WAYPOINT_BILLBOARD_SIZE
        FailureWaypointBillboard.LightInfluence = 0
        FailureWaypointBillboard.SizeOffset = FAIL_WAYPOINT_SIZE_OFFSET_CENTER
        FailureWaypointBillboard.AlwaysOnTop = true
        FailureWaypointBillboard.Adornee = FailureWaypointTemplate
        FailureWaypointBillboard.Parent = FailureWaypointTemplate
        local FailureWaypointFrame = Instance.new("Frame")
        FailureWaypointFrame.BackgroundTransparency = 1
        FailureWaypointFrame.Size = UDim2.new(0, 0, 0, 0)
        FailureWaypointFrame.Position = UDim2.new(0.5, 0, 1, 0)
        FailureWaypointFrame.Parent = FailureWaypointBillboard
        local FailureWaypointImageLabel = Instance.new("ImageLabel")
        FailureWaypointImageLabel.Image = EndWaypointIcon
        FailureWaypointImageLabel.BackgroundTransparency = 1
        FailureWaypointImageLabel.Position = UDim2.new(
            0, -WAYPOINT_BILLBOARD_SIZE.X.Offset/2, 0, -WAYPOINT_BILLBOARD_SIZE.Y.Offset
        )
        FailureWaypointImageLabel.Size = WAYPOINT_BILLBOARD_SIZE
        FailureWaypointImageLabel.Parent = FailureWaypointFrame

        return TrailDotTemplate, EndWaypointTemplate, FailureWaypointTemplate
    end

    local TrailDotTemplate, EndWaypointTemplate, FailureWaypointTemplate = CreateWaypointTemplates()

    local function getTrailDotParent()
        local camera = Workspace.CurrentCamera
        local trailParent = camera:FindFirstChild(TRAIL_DOT_PARENT_NAME)
        if not trailParent then
            trailParent = Instance.new("Model")
            trailParent.Name = TRAIL_DOT_PARENT_NAME
            trailParent.Parent = camera
        end
        return trailParent
    end

    local function placePathWaypoint(waypointModel, position)
        local ray = Ray.new(position + Vector3.new(0, 2.5, 0), Vector3.new(0, -10, 0))
        local hitPart, hitPoint, hitNormal = Workspace:FindPartOnRayWithIgnoreList(
            ray,
            { Workspace.CurrentCamera, LocalPlayer.Character }
        )
        if hitPart then
            waypointModel.CFrame = CFrame.new(hitPoint, hitPoint + hitNormal)
            waypointModel.Parent = getTrailDotParent()
        end
    end

    local TrailDot = {}
    TrailDot.__index = TrailDot

    function TrailDot:Destroy()
        self.DisplayModel:Destroy()
    end

    function TrailDot:NewDisplayModel(position)
        local newDisplayModel = TrailDotTemplate:Clone()
        placePathWaypoint(newDisplayModel, position)
        return newDisplayModel
    end

    function TrailDot.new(position, closestWaypoint)
        local self = setmetatable({}, TrailDot)

        self.DisplayModel = self:NewDisplayModel(position)
        self.ClosestWayPoint = closestWaypoint

        return self
    end

    local EndWaypoint = {}
    EndWaypoint.__index = EndWaypoint

    function EndWaypoint:Destroy()
        self.Destroyed = true
        self.Tween:Cancel()
        self.DisplayModel:Destroy()
    end

    function EndWaypoint:NewDisplayModel(position)
        local newDisplayModel = EndWaypointTemplate:Clone()
        placePathWaypoint(newDisplayModel, position)
        return newDisplayModel
    end

    function EndWaypoint:CreateTween()
        local tweenInfo = TweenInfo.new(0.5, Enum.EasingStyle.Sine, Enum.EasingDirection.Out, -1, true)
        local tween = TweenService:Create(
            self.DisplayModel.EndWaypointBillboard,
            tweenInfo,
            { SizeOffset = ENDWAYPOINT_SIZE_OFFSET_MAX }
        )
        tween:Play()
        return tween
    end

    function EndWaypoint:TweenInFrom(originalPosition)
        local currentPositon = self.DisplayModel.Position
        local studsOffset = originalPosition - currentPositon
        self.DisplayModel.EndWaypointBillboard.StudsOffset = Vector3.new(0, studsOffset.Y, 0)
        local tweenInfo = TweenInfo.new(1, Enum.EasingStyle.Sine, Enum.EasingDirection.Out)
        local tween = TweenService:Create(
            self.DisplayModel.EndWaypointBillboard,
            tweenInfo,
            { StudsOffset = Vector3.new(0, 0, 0) }
        )
        tween:Play()
        return tween
    end

    function EndWaypoint.new(position, closestWaypoint, originalPosition)
        local self = setmetatable({}, EndWaypoint)

        self.DisplayModel = self:NewDisplayModel(position)
        self.Destroyed = false
        if originalPosition and (originalPosition - position).magnitude > TWEEN_WAYPOINT_THRESHOLD then
            self.Tween = self:TweenInFrom(originalPosition)
            coroutine.wrap(function()
                self.Tween.Completed:Wait()
                if not self.Destroyed then
                    self.Tween = self:CreateTween()
                end
            end)()
        else
            self.Tween = self:CreateTween()
        end
        self.ClosestWayPoint = closestWaypoint

        return self
    end

    local FailureWaypoint = {}
    FailureWaypoint.__index = FailureWaypoint

    function FailureWaypoint:Hide()
        self.DisplayModel.Parent = nil
    end

    function FailureWaypoint:Destroy()
        self.DisplayModel:Destroy()
    end

    function FailureWaypoint:NewDisplayModel(position)
        local newDisplayModel = FailureWaypointTemplate:Clone()
        placePathWaypoint(newDisplayModel, position)
        local ray = Ray.new(position + Vector3.new(0, 2.5, 0), Vector3.new(0, -10, 0))
        local hitPart, hitPoint, hitNormal = Workspace:FindPartOnRayWithIgnoreList(
            ray, { Workspace.CurrentCamera, LocalPlayer.Character }
        )
        if hitPart then
            newDisplayModel.CFrame = CFrame.new(hitPoint, hitPoint + hitNormal)
            newDisplayModel.Parent = getTrailDotParent()
        end
        return newDisplayModel
    end

    function FailureWaypoint:RunFailureTween()
        wait(FAILURE_TWEEN_LENGTH) -- Delay one tween length betfore starting tweening
        -- Tween out from center
        local tweenInfo = TweenInfo.new(FAILURE_TWEEN_LENGTH/2, Enum.EasingStyle.Sine, Enum.EasingDirection.Out)
        local tweenLeft = TweenService:Create(self.DisplayModel.FailureWaypointBillboard, tweenInfo,
            { SizeOffset = FAIL_WAYPOINT_SIZE_OFFSET_LEFT })
        tweenLeft:Play()

        local tweenLeftRoation = TweenService:Create(self.DisplayModel.FailureWaypointBillboard.Frame, tweenInfo,
            { Rotation = 10 })
        tweenLeftRoation:Play()

        tweenLeft.Completed:wait()

        -- Tween back and forth
        tweenInfo = TweenInfo.new(FAILURE_TWEEN_LENGTH, Enum.EasingStyle.Sine, Enum.EasingDirection.Out,
            FAILURE_TWEEN_COUNT - 1, true)
        local tweenSideToSide = TweenService:Create(self.DisplayModel.FailureWaypointBillboard, tweenInfo,
            { SizeOffset = FAIL_WAYPOINT_SIZE_OFFSET_RIGHT})
        tweenSideToSide:Play()

        -- Tween flash dark and roate left and right
        tweenInfo = TweenInfo.new(FAILURE_TWEEN_LENGTH, Enum.EasingStyle.Sine, Enum.EasingDirection.Out,
            FAILURE_TWEEN_COUNT - 1, true)
        local tweenFlash = TweenService:Create(self.DisplayModel.FailureWaypointBillboard.Frame.ImageLabel, tweenInfo,
            { ImageColor3 = Color3.new(0.75, 0.75, 0.75)})
        tweenFlash:Play()

        local tweenRotate = TweenService:Create(self.DisplayModel.FailureWaypointBillboard.Frame, tweenInfo,
            { Rotation = -10 })
        tweenRotate:Play()

        tweenSideToSide.Completed:wait()

        -- Tween back to center
        tweenInfo = TweenInfo.new(FAILURE_TWEEN_LENGTH/2, Enum.EasingStyle.Sine, Enum.EasingDirection.Out)
        local tweenCenter = TweenService:Create(self.DisplayModel.FailureWaypointBillboard, tweenInfo,
            { SizeOffset = FAIL_WAYPOINT_SIZE_OFFSET_CENTER })
        tweenCenter:Play()

        local tweenRoation = TweenService:Create(self.DisplayModel.FailureWaypointBillboard.Frame, tweenInfo,
            { Rotation = 0 })
        tweenRoation:Play()

        tweenCenter.Completed:wait()

        wait(FAILURE_TWEEN_LENGTH) -- Delay one tween length betfore removing
    end

    function FailureWaypoint.new(position)
        local self = setmetatable({}, FailureWaypoint)

        self.DisplayModel = self:NewDisplayModel(position)

        return self
    end

    local failureAnimation = Instance.new("Animation")
    failureAnimation.AnimationId = FAILURE_ANIMATION_ID

    local lastHumanoid = nil
    local lastFailureAnimationTrack = nil

    local function getFailureAnimationTrack(myHumanoid)
        if myHumanoid == lastHumanoid then
            return lastFailureAnimationTrack
        end
        lastFailureAnimationTrack = myHumanoid:LoadAnimation(failureAnimation)
        lastFailureAnimationTrack.Priority = Enum.AnimationPriority.Action
        lastFailureAnimationTrack.Looped = false
        return lastFailureAnimationTrack
    end

    local function findPlayerHumanoid()
        local character = LocalPlayer.Character
        if character then
            return character:FindFirstChildOfClass("Humanoid")
        end
    end

    local function createTrailDots(wayPoints, originalEndWaypoint)
        local newTrailDots = {}
        local count = 1
        for i = 1, #wayPoints - 1 do
            local closeToEnd = (wayPoints[i].Position - wayPoints[#wayPoints].Position).magnitude < LAST_DOT_DISTANCE
            local includeWaypoint = i % WAYPOINT_INCLUDE_FACTOR == 0 and not closeToEnd
            if includeWaypoint then
                local trailDot = TrailDot.new(wayPoints[i].Position, i)
                newTrailDots[count] = trailDot
                count = count + 1
            end
        end

        local newEndWaypoint = EndWaypoint.new(wayPoints[#wayPoints].Position, #wayPoints, originalEndWaypoint)
        table.insert(newTrailDots, newEndWaypoint)

        local reversedTrailDots = {}
        count = 1
        for i = #newTrailDots, 1, -1 do
            reversedTrailDots[count] = newTrailDots[i]
            count = count + 1
        end
        return reversedTrailDots
    end

    local function getTrailDotScale(distanceToCamera, defaultSize)
        local rangeLength = TRAIL_DOT_MAX_DISTANCE - TRAIL_DOT_MIN_DISTANCE
        local inRangePoint = math.clamp(distanceToCamera - TRAIL_DOT_MIN_DISTANCE, 0, rangeLength)/rangeLength
        local scale = TRAIL_DOT_MIN_SCALE + (TRAIL_DOT_MAX_SCALE - TRAIL_DOT_MIN_SCALE)*inRangePoint
        return defaultSize * scale
    end

    local createPathCount = 0
    -- originalEndWaypoint is optional, causes the waypoint to tween from that position.
    function ClickToMoveDisplay.CreatePathDisplay(wayPoints, originalEndWaypoint)
        createPathCount = createPathCount + 1
        local trailDots = createTrailDots(wayPoints, originalEndWaypoint)

        local function removePathBeforePoint(wayPointNumber)
            -- kill all trailDots before and at wayPointNumber
            for i = #trailDots, 1, -1 do
                local trailDot = trailDots[i]
                if trailDot.ClosestWayPoint <= wayPointNumber then
                    trailDot:Destroy()
                    trailDots[i] = nil
                else
                    break
                end
            end
        end

        local reiszeTrailDotsUpdateName = "ClickToMoveResizeTrail" ..createPathCount
        local function resizeTrailDots()
            if #trailDots == 0 then
                RunService:UnbindFromRenderStep(reiszeTrailDotsUpdateName)
                return
            end
            local cameraPos = Workspace.CurrentCamera.CFrame.p
            for i = 1, #trailDots do
                local trailDotImage = trailDots[i].DisplayModel:FindFirstChild("TrailDotImage")
                if trailDotImage then
                    local distanceToCamera = (trailDots[i].DisplayModel.Position - cameraPos).magnitude
                    trailDotImage.Size = getTrailDotScale(distanceToCamera, TrailDotSize)
                end
            end
        end
        RunService:BindToRenderStep(reiszeTrailDotsUpdateName, Enum.RenderPriority.Camera.Value - 1, resizeTrailDots)

        local function removePath()
            removePathBeforePoint(#wayPoints)
        end

        return removePath, removePathBeforePoint
    end

    local lastFailureWaypoint = nil
    function ClickToMoveDisplay.DisplayFailureWaypoint(position)
        if lastFailureWaypoint then
            lastFailureWaypoint:Hide()
        end
        local failureWaypoint = FailureWaypoint.new(position)
        lastFailureWaypoint = failureWaypoint
        coroutine.wrap(function()
            failureWaypoint:RunFailureTween()
            failureWaypoint:Destroy()
            failureWaypoint = nil
        end)()
    end

    function ClickToMoveDisplay.CreateEndWaypoint(position)
        return EndWaypoint.new(position)
    end

    function ClickToMoveDisplay.PlayFailureAnimation()
        local myHumanoid = findPlayerHumanoid()
        if myHumanoid then
            local animationTrack = getFailureAnimationTrack(myHumanoid)
            animationTrack:Play()
        end
    end

    function ClickToMoveDisplay.CancelFailureAnimation()
        if lastFailureAnimationTrack ~= nil and lastFailureAnimationTrack.IsPlaying then
            lastFailureAnimationTrack:Stop()
        end
    end

    function ClickToMoveDisplay.SetWaypointTexture(texture)
        TrailDotIcon = texture
        TrailDotTemplate, EndWaypointTemplate, FailureWaypointTemplate = CreateWaypointTemplates()
    end

    function ClickToMoveDisplay.GetWaypointTexture()
        return TrailDotIcon
    end

    function ClickToMoveDisplay.SetWaypointRadius(radius)
        TrailDotSize = Vector2.new(radius, radius)
        TrailDotTemplate, EndWaypointTemplate, FailureWaypointTemplate = CreateWaypointTemplates()
    end

    function ClickToMoveDisplay.GetWaypointRadius()
        return TrailDotSize.X
    end

    function ClickToMoveDisplay.SetEndWaypointTexture(texture)
        EndWaypointIcon = texture
        TrailDotTemplate, EndWaypointTemplate, FailureWaypointTemplate = CreateWaypointTemplates()
    end

    function ClickToMoveDisplay.GetEndWaypointTexture()
        return EndWaypointIcon
    end

    function ClickToMoveDisplay.SetWaypointsAlwaysOnTop(alwaysOnTop)
        WaypointsAlwaysOnTop = alwaysOnTop
        TrailDotTemplate, EndWaypointTemplate, FailureWaypointTemplate = CreateWaypointTemplates()
    end

    function ClickToMoveDisplay.GetWaypointsAlwaysOnTop()
        return WaypointsAlwaysOnTop
    end

    return ClickToMoveDisplay
end

function _BaseCharacterController()

    local ZERO_VECTOR3 = Vector3.new(0,0,0)

    --[[ The Module ]]--
    local BaseCharacterController = {}
    BaseCharacterController.__index = BaseCharacterController

    function BaseCharacterController.new()
        local self = setmetatable({}, BaseCharacterController)
        self.enabled = false
        self.moveVector = ZERO_VECTOR3
        self.moveVectorIsCameraRelative = true
        self.isJumping = false
        return self
    end

    function BaseCharacterController:OnRenderStepped(dt)
        -- By default, nothing to do
    end

    function BaseCharacterController:GetMoveVector()
        return self.moveVector
    end

    function BaseCharacterController:IsMoveVectorCameraRelative()
        return self.moveVectorIsCameraRelative
    end

    function BaseCharacterController:GetIsJumping()
        return self.isJumping
    end

    -- Override in derived classes to set self.enabled and return boolean indicating
    -- whether Enable/Disable was successful. Return true if controller is already in the requested state.
    function BaseCharacterController:Enable(enable)
        error("BaseCharacterController:Enable must be overridden in derived classes and should not be called.")
        return false
    end

    return BaseCharacterController
end

function _VehicleController()
    local ContextActionService = game:GetService("ContextActionService")

    --[[ Constants ]]--
    -- Set this to true if you want to instead use the triggers for the throttle
    local useTriggersForThrottle = true
    -- Also set this to true if you want the thumbstick to not affect throttle, only triggers when a gamepad is conected
    local onlyTriggersForThrottle = false
    local ZERO_VECTOR3 = Vector3.new(0,0,0)

    local AUTO_PILOT_DEFAULT_MAX_STEERING_ANGLE = 35


    -- Note that VehicleController does not derive from BaseCharacterController, it is a special case
    local VehicleController = {}
    VehicleController.__index = VehicleController

    function VehicleController.new(CONTROL_ACTION_PRIORITY)
        local self = setmetatable({}, VehicleController)

        self.CONTROL_ACTION_PRIORITY = CONTROL_ACTION_PRIORITY

        self.enabled = false
        self.vehicleSeat = nil
        self.throttle = 0
        self.steer = 0

        self.acceleration = 0
        self.decceleration = 0
        self.turningRight = 0
        self.turningLeft = 0

        self.vehicleMoveVector = ZERO_VECTOR3

        self.autoPilot = {}
        self.autoPilot.MaxSpeed = 0
        self.autoPilot.MaxSteeringAngle = 0

        return self
    end

    function VehicleController:BindContextActions()
        if useTriggersForThrottle then
            ContextActionService:BindActionAtPriority("throttleAccel", (function(actionName, inputState, inputObject)
                self:OnThrottleAccel(actionName, inputState, inputObject)
                return Enum.ContextActionResult.Pass
            end), false, self.CONTROL_ACTION_PRIORITY, Enum.KeyCode.ButtonR2)
            ContextActionService:BindActionAtPriority("throttleDeccel", (function(actionName, inputState, inputObject)
                self:OnThrottleDeccel(actionName, inputState, inputObject)
                return Enum.ContextActionResult.Pass
            end), false, self.CONTROL_ACTION_PRIORITY, Enum.KeyCode.ButtonL2)
        end
        ContextActionService:BindActionAtPriority("arrowSteerRight", (function(actionName, inputState, inputObject)
            self:OnSteerRight(actionName, inputState, inputObject)
            return Enum.ContextActionResult.Pass
        end), false, self.CONTROL_ACTION_PRIORITY, Enum.KeyCode.Right)
        ContextActionService:BindActionAtPriority("arrowSteerLeft", (function(actionName, inputState, inputObject)
            self:OnSteerLeft(actionName, inputState, inputObject)
            return Enum.ContextActionResult.Pass
        end), false, self.CONTROL_ACTION_PRIORITY, Enum.KeyCode.Left)
    end

    function VehicleController:Enable(enable, vehicleSeat)
        if enable == self.enabled and vehicleSeat == self.vehicleSeat then
            return
        end

        self.enabled = enable
        self.vehicleMoveVector = ZERO_VECTOR3

        if enable then
            if vehicleSeat then
                self.vehicleSeat = vehicleSeat

                self:SetupAutoPilot()
                self:BindContextActions()
            end
        else
            if useTriggersForThrottle then
                ContextActionService:UnbindAction("throttleAccel")
                ContextActionService:UnbindAction("throttleDeccel")
            end
            ContextActionService:UnbindAction("arrowSteerRight")
            ContextActionService:UnbindAction("arrowSteerLeft")
            self.vehicleSeat = nil
        end
    end

    function VehicleController:OnThrottleAccel(actionName, inputState, inputObject)
        if inputState == Enum.UserInputState.End or inputState == Enum.UserInputState.Cancel then
            self.acceleration = 0
        else
            self.acceleration = -1
        end
        self.throttle = self.acceleration + self.decceleration
    end

    function VehicleController:OnThrottleDeccel(actionName, inputState, inputObject)
        if inputState == Enum.UserInputState.End or inputState == Enum.UserInputState.Cancel then
            self.decceleration = 0
        else
            self.decceleration = 1
        end
        self.throttle = self.acceleration + self.decceleration
    end

    function VehicleController:OnSteerRight(actionName, inputState, inputObject)
        if inputState == Enum.UserInputState.End or inputState == Enum.UserInputState.Cancel then
            self.turningRight = 0
        else
            self.turningRight = 1
        end
        self.steer = self.turningRight + self.turningLeft
    end

    function VehicleController:OnSteerLeft(actionName, inputState, inputObject)
        if inputState == Enum.UserInputState.End or inputState == Enum.UserInputState.Cancel then
            self.turningLeft = 0
        else
            self.turningLeft = -1
        end
        self.steer = self.turningRight + self.turningLeft
    end

    -- Call this from a function bound to Renderstep with Input Priority
    function VehicleController:Update(moveVector, cameraRelative, usingGamepad)
        if self.vehicleSeat then
            if cameraRelative then
                -- This is the default steering mode
                moveVector = moveVector + Vector3.new(self.steer, 0, self.throttle)
                if usingGamepad and onlyTriggersForThrottle and useTriggersForThrottle then
                    self.vehicleSeat.ThrottleFloat = -self.throttle
                else
                    self.vehicleSeat.ThrottleFloat = -moveVector.Z
                end
                self.vehicleSeat.SteerFloat = moveVector.X

                return moveVector, true
            else
                -- This is the path following mode
                local localMoveVector = self.vehicleSeat.Occupant.RootPart.CFrame:VectorToObjectSpace(moveVector)

                self.vehicleSeat.ThrottleFloat = self:ComputeThrottle(localMoveVector)
                self.vehicleSeat.SteerFloat = self:ComputeSteer(localMoveVector)

                return ZERO_VECTOR3, true
            end
        end
        return moveVector, false
    end

    function VehicleController:ComputeThrottle(localMoveVector)
        if localMoveVector ~= ZERO_VECTOR3 then
            local throttle = -localMoveVector.Z
            return throttle
        else
            return 0.0
        end
    end

    function VehicleController:ComputeSteer(localMoveVector)
        if localMoveVector ~= ZERO_VECTOR3 then
            local steerAngle = -math.atan2(-localMoveVector.x, -localMoveVector.z) * (180 / math.pi)
            return steerAngle / self.autoPilot.MaxSteeringAngle
        else
            return 0.0
        end
    end

    function VehicleController:SetupAutoPilot()
        -- Setup default
        self.autoPilot.MaxSpeed = self.vehicleSeat.MaxSpeed
        self.autoPilot.MaxSteeringAngle = AUTO_PILOT_DEFAULT_MAX_STEERING_ANGLE

        -- VehicleSeat should have a MaxSteeringAngle as well.
        -- Or we could look for a child "AutoPilotConfigModule" to find these values
        -- Or allow developer to set them through the API as like the CLickToMove customization API
    end

    return VehicleController
end

function _TouchJump()

    local Players = game:GetService("Players")
    local GuiService = game:GetService("GuiService")

    --[[ Constants ]]--
    local TOUCH_CONTROL_SHEET = "rbxasset://textures/ui/Input/TouchControlsSheetV2.png"

    --[[ The Module ]]--
    local BaseCharacterController = _BaseCharacterController()
    local TouchJump = setmetatable({}, BaseCharacterController)
    TouchJump.__index = TouchJump

    function TouchJump.new()
        local self = setmetatable(BaseCharacterController.new(), TouchJump)

        self.parentUIFrame = nil
        self.jumpButton = nil
        self.characterAddedConn = nil
        self.humanoidStateEnabledChangedConn = nil
        self.humanoidJumpPowerConn = nil
        self.humanoidParentConn = nil
        self.externallyEnabled = false
        self.jumpPower = 0
        self.jumpStateEnabled = true
        self.isJumping = false
        self.humanoid = nil -- saved reference because property change connections are made using it

        return self
    end

    function TouchJump:EnableButton(enable)
        if enable then
            if not self.jumpButton then
                self:Create()
            end
            local humanoid = Players.LocalPlayer.Character and Players.LocalPlayer.Character:FindFirstChildOfClass("Humanoid")
            if humanoid and self.externallyEnabled then
                if self.externallyEnabled then
                    if humanoid.JumpPower > 0 then
                        self.jumpButton.Visible = true
                    end
                end
            end
        else
            self.jumpButton.Visible = false
            self.isJumping = false
            self.jumpButton.ImageRectOffset = Vector2.new(1, 146)
        end
    end

    function TouchJump:UpdateEnabled()
        if self.jumpPower > 0 and self.jumpStateEnabled then
            self:EnableButton(true)
        else
            self:EnableButton(false)
        end
    end

    function TouchJump:HumanoidChanged(prop)
        local humanoid = Players.LocalPlayer.Character and Players.LocalPlayer.Character:FindFirstChildOfClass("Humanoid")
        if humanoid then
            if prop == "JumpPower" then
                self.jumpPower =  humanoid.JumpPower
                self:UpdateEnabled()
            elseif prop == "Parent" then
                if not humanoid.Parent then
                    self.humanoidChangeConn:Disconnect()
                end
            end
        end
    end

    function TouchJump:HumanoidStateEnabledChanged(state, isEnabled)
        if state == Enum.HumanoidStateType.Jumping then
            self.jumpStateEnabled = isEnabled
            self:UpdateEnabled()
        end
    end

    function TouchJump:CharacterAdded(char)
        if self.humanoidChangeConn then
            self.humanoidChangeConn:Disconnect()
            self.humanoidChangeConn = nil
        end

        self.humanoid = char:FindFirstChildOfClass("Humanoid")
        while not self.humanoid do
            char.ChildAdded:wait()
            self.humanoid = char:FindFirstChildOfClass("Humanoid")
        end

        self.humanoidJumpPowerConn = self.humanoid:GetPropertyChangedSignal("JumpPower"):Connect(function()
            self.jumpPower =  self.humanoid.JumpPower
            self:UpdateEnabled()
        end)

        self.humanoidParentConn = self.humanoid:GetPropertyChangedSignal("Parent"):Connect(function()
            if not self.humanoid.Parent then
                self.humanoidJumpPowerConn:Disconnect()
                self.humanoidJumpPowerConn = nil
                self.humanoidParentConn:Disconnect()
                self.humanoidParentConn = nil
            end
        end)

        self.humanoidStateEnabledChangedConn = self.humanoid.StateEnabledChanged:Connect(function(state, enabled)
            self:HumanoidStateEnabledChanged(state, enabled)
        end)

        self.jumpPower = self.humanoid.JumpPower
        self.jumpStateEnabled = self.humanoid:GetStateEnabled(Enum.HumanoidStateType.Jumping)
        self:UpdateEnabled()
    end

    function TouchJump:SetupCharacterAddedFunction()
        self.characterAddedConn = Players.LocalPlayer.CharacterAdded:Connect(function(char)
            self:CharacterAdded(char)
        end)
        if Players.LocalPlayer.Character then
            self:CharacterAdded(Players.LocalPlayer.Character)
        end
    end

    function TouchJump:Enable(enable, parentFrame)
        if parentFrame then
            self.parentUIFrame = parentFrame
        end
        self.externallyEnabled = enable
        self:EnableButton(enable)
    end

    function TouchJump:Create()
        if not self.parentUIFrame then
            return
        end

        if self.jumpButton then
            self.jumpButton:Destroy()
            self.jumpButton = nil
        end

        local minAxis = math.min(self.parentUIFrame.AbsoluteSize.x, self.parentUIFrame.AbsoluteSize.y)
        local isSmallScreen = minAxis <= 500
        local jumpButtonSize = isSmallScreen and 70 or 120

        self.jumpButton = Instance.new("ImageButton")
        self.jumpButton.Name = "JumpButton"
        self.jumpButton.Visible = false
        self.jumpButton.BackgroundTransparency = 1
        self.jumpButton.Image = TOUCH_CONTROL_SHEET
        self.jumpButton.ImageRectOffset = Vector2.new(1, 146)
        self.jumpButton.ImageRectSize = Vector2.new(144, 144)
        self.jumpButton.Size = UDim2.new(0, jumpButtonSize, 0, jumpButtonSize)

        self.jumpButton.Position = isSmallScreen and UDim2.new(1, -(jumpButtonSize*1.5-10), 1, -jumpButtonSize - 20) or
            UDim2.new(1, -(jumpButtonSize*1.5-10), 1, -jumpButtonSize * 1.75)

        local touchObject = nil
        self.jumpButton.InputBegan:connect(function(inputObject)
            --A touch that starts elsewhere on the screen will be sent to a frame's InputBegan event
            --if it moves over the frame. So we check that this is actually a new touch (inputObject.UserInputState ~= Enum.UserInputState.Begin)
            if touchObject or inputObject.UserInputType ~= Enum.UserInputType.Touch
                or inputObject.UserInputState ~= Enum.UserInputState.Begin then
                return
            end

            touchObject = inputObject
            self.jumpButton.ImageRectOffset = Vector2.new(146, 146)
            self.isJumping = true
        end)

        local OnInputEnded = function()
            touchObject = nil
            self.isJumping = false
            self.jumpButton.ImageRectOffset = Vector2.new(1, 146)
        end

        self.jumpButton.InputEnded:connect(function(inputObject)
            if inputObject == touchObject then
                OnInputEnded()
            end
        end)

        GuiService.MenuOpened:connect(function()
            if touchObject then
                OnInputEnded()
            end
        end)

        if not self.characterAddedConn then
            self:SetupCharacterAddedFunction()
        end

        self.jumpButton.Parent = self.parentUIFrame
    end

    return TouchJump
end

function _ClickToMoveController()
    --[[ Roblox Services ]]--
    local UserInputService = game:GetService("UserInputService")
    local PathfindingService = game:GetService("PathfindingService")
    local Players = game:GetService("Players")
    local DebrisService = game:GetService('Debris')
    local StarterGui = game:GetService("StarterGui")
    local Workspace = game:GetService("Workspace")
    local CollectionService = game:GetService("CollectionService")
    local GuiService = game:GetService("GuiService")

    --[[ Configuration ]]
    local ShowPath = true
    local PlayFailureAnimation = true
    local UseDirectPath = false
    local UseDirectPathForVehicle = true
    local AgentSizeIncreaseFactor = 1.0
    local UnreachableWaypointTimeout = 8

    --[[ Constants ]]--
    local movementKeys = {
        [Enum.KeyCode.W] = true;
        [Enum.KeyCode.A] = true;
        [Enum.KeyCode.S] = true;
        [Enum.KeyCode.D] = true;
        [Enum.KeyCode.Up] = true;
        [Enum.KeyCode.Down] = true;
    }

    local FFlagUserNavigationClickToMoveSkipPassedWaypointsSuccess, FFlagUserNavigationClickToMoveSkipPassedWaypointsResult = pcall(function() return UserSettings():IsUserFeatureEnabled("UserNavigationClickToMoveSkipPassedWaypoints") end)
    local FFlagUserNavigationClickToMoveSkipPassedWaypoints = FFlagUserNavigationClickToMoveSkipPassedWaypointsSuccess and FFlagUserNavigationClickToMoveSkipPassedWaypointsResult

    local Player = Players.LocalPlayer

    local ClickToMoveDisplay = _ClickToMoveDisplay()

    local ZERO_VECTOR3 = Vector3.new(0,0,0)
    local ALMOST_ZERO = 0.000001


    --------------------------UTIL LIBRARY-------------------------------
    local Utility = {}
    do
        local function FindCharacterAncestor(part)
            if part then
                local humanoid = part:FindFirstChildOfClass("Humanoid")
                if humanoid then
                    return part, humanoid
                else
                    return FindCharacterAncestor(part.Parent)
                end
            end
        end
        Utility.FindCharacterAncestor = FindCharacterAncestor

        local function Raycast(ray, ignoreNonCollidable, ignoreList)
            ignoreList = ignoreList or {}
            local hitPart, hitPos, hitNorm, hitMat = Workspace:FindPartOnRayWithIgnoreList(ray, ignoreList)
            if hitPart then
                if ignoreNonCollidable and hitPart.CanCollide == false then
                    -- We always include character parts so a user can click on another character
                    -- to walk to them.
                    local _, humanoid = FindCharacterAncestor(hitPart)
                    if humanoid == nil then
                        table.insert(ignoreList, hitPart)
                        return Raycast(ray, ignoreNonCollidable, ignoreList)
                    end
                end
                return hitPart, hitPos, hitNorm, hitMat
            end
            return nil, nil
        end
        Utility.Raycast = Raycast
    end

    local humanoidCache = {}
    local function findPlayerHumanoid(player)
        local character = player and player.Character
        if character then
            local resultHumanoid = humanoidCache[player]
            if resultHumanoid and resultHumanoid.Parent == character then
                return resultHumanoid
            else
                humanoidCache[player] = nil -- Bust Old Cache
                local humanoid = character:FindFirstChildOfClass("Humanoid")
                if humanoid then
                    humanoidCache[player] = humanoid
                end
                return humanoid
            end
        end
    end

    --------------------------CHARACTER CONTROL-------------------------------
    local CurrentIgnoreList
    local CurrentIgnoreTag = nil

    local TaggedInstanceAddedConnection = nil
    local TaggedInstanceRemovedConnection = nil

    local function GetCharacter()
        return Player and Player.Character
    end

    local function UpdateIgnoreTag(newIgnoreTag)
        if newIgnoreTag == CurrentIgnoreTag then
            return
        end
        if TaggedInstanceAddedConnection then
            TaggedInstanceAddedConnection:Disconnect()
            TaggedInstanceAddedConnection = nil
        end
        if TaggedInstanceRemovedConnection then
            TaggedInstanceRemovedConnection:Disconnect()
            TaggedInstanceRemovedConnection = nil
        end
        CurrentIgnoreTag = newIgnoreTag
        CurrentIgnoreList = {GetCharacter()}
        if CurrentIgnoreTag ~= nil then
            local ignoreParts = CollectionService:GetTagged(CurrentIgnoreTag)
            for _, ignorePart in ipairs(ignoreParts) do
                table.insert(CurrentIgnoreList, ignorePart)
            end
            TaggedInstanceAddedConnection = CollectionService:GetInstanceAddedSignal(
                CurrentIgnoreTag):Connect(function(ignorePart)
                table.insert(CurrentIgnoreList, ignorePart)
            end)
            TaggedInstanceRemovedConnection = CollectionService:GetInstanceRemovedSignal(
                CurrentIgnoreTag):Connect(function(ignorePart)
                for i = 1, #CurrentIgnoreList do
                    if CurrentIgnoreList[i] == ignorePart then
                        CurrentIgnoreList[i] = CurrentIgnoreList[#CurrentIgnoreList]
                        table.remove(CurrentIgnoreList)
                        break
                    end
                end
            end)
        end
    end

    local function getIgnoreList()
        if CurrentIgnoreList then
            return CurrentIgnoreList
        end
        CurrentIgnoreList = {}
        table.insert(CurrentIgnoreList, GetCharacter())
        return CurrentIgnoreList
    end

    -----------------------------------PATHER--------------------------------------

    local function Pather(endPoint, surfaceNormal, overrideUseDirectPath)
        local this = {}

        local directPathForHumanoid
        local directPathForVehicle
        if overrideUseDirectPath ~= nil then
            directPathForHumanoid = overrideUseDirectPath
            directPathForVehicle = overrideUseDirectPath
        else
            directPathForHumanoid = UseDirectPath
            directPathForVehicle = UseDirectPathForVehicle
        end

        this.Cancelled = false
        this.Started = false

        this.Finished = Instance.new("BindableEvent")
        this.PathFailed = Instance.new("BindableEvent")

        this.PathComputing = false
        this.PathComputed = false

        this.OriginalTargetPoint = endPoint
        this.TargetPoint = endPoint
        this.TargetSurfaceNormal = surfaceNormal

        this.DiedConn = nil
        this.SeatedConn = nil
        this.BlockedConn = nil
        this.TeleportedConn = nil

        this.CurrentPoint = 0

        this.HumanoidOffsetFromPath = ZERO_VECTOR3

        this.CurrentWaypointPosition = nil
        this.CurrentWaypointPlaneNormal = ZERO_VECTOR3
        this.CurrentWaypointPlaneDistance = 0
        this.CurrentWaypointNeedsJump = false;

        this.CurrentHumanoidPosition = ZERO_VECTOR3
        this.CurrentHumanoidVelocity = 0

        this.NextActionMoveDirection = ZERO_VECTOR3
        this.NextActionJump = false

        this.Timeout = 0

        this.Humanoid = findPlayerHumanoid(Player)
        this.OriginPoint = nil
        this.AgentCanFollowPath = false
        this.DirectPath = false
        this.DirectPathRiseFirst = false

        local rootPart = this.Humanoid and this.Humanoid.RootPart
        if rootPart then
            -- Setup origin
            this.OriginPoint = rootPart.CFrame.p

            -- Setup agent
            local agentRadius = 2
            local agentHeight = 5
            local agentCanJump = true

            local seat = this.Humanoid.SeatPart
            if seat and seat:IsA("VehicleSeat") then
                -- Humanoid is seated on a vehicle
                local vehicle = seat:FindFirstAncestorOfClass("Model")
                if vehicle then
                    -- Make sure the PrimaryPart is set to the vehicle seat while we compute the extends.
                    local tempPrimaryPart = vehicle.PrimaryPart
                    vehicle.PrimaryPart = seat

                    -- For now, only direct path
                    if directPathForVehicle then
                        local extents = vehicle:GetExtentsSize()
                        agentRadius = AgentSizeIncreaseFactor * 0.5 * math.sqrt(extents.X * extents.X + extents.Z * extents.Z)
                        agentHeight = AgentSizeIncreaseFactor * extents.Y
                        agentCanJump = false
                        this.AgentCanFollowPath = true
                        this.DirectPath = directPathForVehicle
                    end

                    -- Reset PrimaryPart
                    vehicle.PrimaryPart = tempPrimaryPart
                end
            else
                local extents = GetCharacter():GetExtentsSize()
                agentRadius = AgentSizeIncreaseFactor * 0.5 * math.sqrt(extents.X * extents.X + extents.Z * extents.Z)
                agentHeight = AgentSizeIncreaseFactor * extents.Y
                agentCanJump = (this.Humanoid.JumpPower > 0)
                this.AgentCanFollowPath = true
                this.DirectPath = directPathForHumanoid
                this.DirectPathRiseFirst = this.Humanoid.Sit
            end

            -- Build path object
            this.pathResult = PathfindingService:CreatePath({AgentRadius = agentRadius, AgentHeight = agentHeight, AgentCanJump = agentCanJump})
        end

        function this:Cleanup()
            if this.stopTraverseFunc then
                this.stopTraverseFunc()
                this.stopTraverseFunc = nil
            end

            if this.MoveToConn then
                this.MoveToConn:Disconnect()
                this.MoveToConn = nil
            end

            if this.BlockedConn then
                this.BlockedConn:Disconnect()
                this.BlockedConn = nil
            end

            if this.DiedConn then
                this.DiedConn:Disconnect()
                this.DiedConn = nil
            end

            if this.SeatedConn then
                this.SeatedConn:Disconnect()
                this.SeatedConn = nil
            end

            if this.TeleportedConn then
                this.TeleportedConn:Disconnect()
                this.TeleportedConn = nil
            end

            this.Started = false
        end

        function this:Cancel()
            this.Cancelled = true
            this:Cleanup()
        end

        function this:IsActive()
            return this.AgentCanFollowPath and this.Started and not this.Cancelled
        end

        function this:OnPathInterrupted()
            -- Stop moving
            this.Cancelled = true
            this:OnPointReached(false)
        end

        function this:ComputePath()
            if this.OriginPoint then
                if this.PathComputed or this.PathComputing then return end
                this.PathComputing = true
                if this.AgentCanFollowPath then
                    if this.DirectPath then
                        this.pointList = {
                            PathWaypoint.new(this.OriginPoint, Enum.PathWaypointAction.Walk),
                            PathWaypoint.new(this.TargetPoint, this.DirectPathRiseFirst and Enum.PathWaypointAction.Jump or Enum.PathWaypointAction.Walk)
                        }
                        this.PathComputed = true
                    else
                        this.pathResult:ComputeAsync(this.OriginPoint, this.TargetPoint)
                        this.pointList = this.pathResult:GetWaypoints()
                        this.BlockedConn = this.pathResult.Blocked:Connect(function(blockedIdx) this:OnPathBlocked(blockedIdx) end)
                        this.PathComputed = this.pathResult.Status == Enum.PathStatus.Success
                    end
                end
                this.PathComputing = false
            end
        end

        function this:IsValidPath()
            this:ComputePath()
            return this.PathComputed and this.AgentCanFollowPath
        end

        this.Recomputing = false
        function this:OnPathBlocked(blockedWaypointIdx)
            local pathBlocked = blockedWaypointIdx >= this.CurrentPoint
            if not pathBlocked or this.Recomputing then
                return
            end

            this.Recomputing = true

            if this.stopTraverseFunc then
                this.stopTraverseFunc()
                this.stopTraverseFunc = nil
            end

            this.OriginPoint = this.Humanoid.RootPart.CFrame.p

            this.pathResult:ComputeAsync(this.OriginPoint, this.TargetPoint)
            this.pointList = this.pathResult:GetWaypoints()
            if #this.pointList > 0 then
                this.HumanoidOffsetFromPath = this.pointList[1].Position - this.OriginPoint
            end
            this.PathComputed = this.pathResult.Status == Enum.PathStatus.Success

            if ShowPath then
                this.stopTraverseFunc, this.setPointFunc = ClickToMoveDisplay.CreatePathDisplay(this.pointList)
            end
            if this.PathComputed then
                this.CurrentPoint = 1 -- The first waypoint is always the start location. Skip it.
                this:OnPointReached(true) -- Move to first point
            else
                this.PathFailed:Fire()
                this:Cleanup()
            end

            this.Recomputing = false
        end

        function this:OnRenderStepped(dt)
            if this.Started and not this.Cancelled then
                -- Check for Timeout (if a waypoint is not reached within the delay, we fail)
                this.Timeout = this.Timeout + dt
                if this.Timeout > UnreachableWaypointTimeout then
                    this:OnPointReached(false)
                    return
                end

                -- Get Humanoid position and velocity
                this.CurrentHumanoidPosition = this.Humanoid.RootPart.Position + this.HumanoidOffsetFromPath
                this.CurrentHumanoidVelocity = this.Humanoid.RootPart.Velocity

                -- Check if it has reached some waypoints
                while this.Started and this:IsCurrentWaypointReached() do
                    this:OnPointReached(true)
                end

                -- If still started, update actions
                if this.Started then
                    -- Move action
                    this.NextActionMoveDirection = this.CurrentWaypointPosition - this.CurrentHumanoidPosition
                    if this.NextActionMoveDirection.Magnitude > ALMOST_ZERO then
                        this.NextActionMoveDirection = this.NextActionMoveDirection.Unit
                    else
                        this.NextActionMoveDirection = ZERO_VECTOR3
                    end
                    -- Jump action
                    if this.CurrentWaypointNeedsJump then
                        this.NextActionJump = true
                        this.CurrentWaypointNeedsJump = false   -- Request jump only once
                    else
                        this.NextActionJump = false
                    end
                end
            end
        end

        function this:IsCurrentWaypointReached()
            local reached = false

            -- Check we do have a plane, if not, we consider the waypoint reached
            if this.CurrentWaypointPlaneNormal ~= ZERO_VECTOR3 then
                -- Compute distance of Humanoid from destination plane
                local dist = this.CurrentWaypointPlaneNormal:Dot(this.CurrentHumanoidPosition) - this.CurrentWaypointPlaneDistance
                -- Compute the component of the Humanoid velocity that is towards the plane
                local velocity = -this.CurrentWaypointPlaneNormal:Dot(this.CurrentHumanoidVelocity)
                -- Compute the threshold from the destination plane based on Humanoid velocity
                local threshold = math.max(1.0, 0.0625 * velocity)
                -- If we are less then threshold in front of the plane (between 0 and threshold) or if we are behing the plane (less then 0), we consider we reached it
                reached = dist < threshold
            else
                reached = true
            end

            if reached then
                this.CurrentWaypointPosition = nil
                this.CurrentWaypointPlaneNormal = ZERO_VECTOR3
                this.CurrentWaypointPlaneDistance = 0
            end

            return reached
        end

        function this:OnPointReached(reached)

            if reached and not this.Cancelled then
                -- First, destroyed the current displayed waypoint
                if this.setPointFunc then
                    this.setPointFunc(this.CurrentPoint)
                end

                local nextWaypointIdx = this.CurrentPoint + 1

                if nextWaypointIdx > #this.pointList then
                    -- End of path reached
                    if this.stopTraverseFunc then
                        this.stopTraverseFunc()
                    end
                    this.Finished:Fire()
                    this:Cleanup()
                else
                    local currentWaypoint = this.pointList[this.CurrentPoint]
                    local nextWaypoint = this.pointList[nextWaypointIdx]

                    -- If airborne, only allow to keep moving
                    -- if nextWaypoint.Action ~= Jump, or path mantains a direction
                    -- Otherwise, wait until the humanoid gets to the ground
                    local currentState = this.Humanoid:GetState()
                    local isInAir = currentState == Enum.HumanoidStateType.FallingDown
                        or currentState == Enum.HumanoidStateType.Freefall
                        or currentState == Enum.HumanoidStateType.Jumping

                    if isInAir then
                        local shouldWaitForGround = nextWaypoint.Action == Enum.PathWaypointAction.Jump
                        if not shouldWaitForGround and this.CurrentPoint > 1 then
                            local prevWaypoint = this.pointList[this.CurrentPoint - 1]

                            local prevDir = currentWaypoint.Position - prevWaypoint.Position
                            local currDir = nextWaypoint.Position - currentWaypoint.Position

                            local prevDirXZ = Vector2.new(prevDir.x, prevDir.z).Unit
                            local currDirXZ = Vector2.new(currDir.x, currDir.z).Unit

                            local THRESHOLD_COS = 0.996 -- ~cos(5 degrees)
                            shouldWaitForGround = prevDirXZ:Dot(currDirXZ) < THRESHOLD_COS
                        end

                        if shouldWaitForGround then
                            this.Humanoid.FreeFalling:Wait()

                            -- Give time to the humanoid's state to change
                            -- Otherwise, the jump flag in Humanoid
                            -- will be reset by the state change
                            wait(0.1)
                        end
                    end

                    -- Move to the next point
                    if FFlagUserNavigationClickToMoveSkipPassedWaypoints then
                        this:MoveToNextWayPoint(currentWaypoint, nextWaypoint, nextWaypointIdx)
                    else
                        if this.setPointFunc then
                            this.setPointFunc(nextWaypointIdx)
                        end
                        if nextWaypoint.Action == Enum.PathWaypointAction.Jump then
                            this.Humanoid.Jump = true
                        end
                        this.Humanoid:MoveTo(nextWaypoint.Position)

                        this.CurrentPoint = nextWaypointIdx
                    end
                end
            else
                this.PathFailed:Fire()
                this:Cleanup()
            end
        end

        function this:MoveToNextWayPoint(currentWaypoint, nextWaypoint, nextWaypointIdx)
            -- Build next destination plane
            -- (plane normal is perpendicular to the y plane and is from next waypoint towards current one (provided the two waypoints are not at the same location))
            -- (plane location is at next waypoint)
            this.CurrentWaypointPlaneNormal = currentWaypoint.Position - nextWaypoint.Position
            this.CurrentWaypointPlaneNormal = Vector3.new(this.CurrentWaypointPlaneNormal.X, 0, this.CurrentWaypointPlaneNormal.Z)
            if this.CurrentWaypointPlaneNormal.Magnitude > ALMOST_ZERO then
                this.CurrentWaypointPlaneNormal = this.CurrentWaypointPlaneNormal.Unit
                this.CurrentWaypointPlaneDistance = this.CurrentWaypointPlaneNormal:Dot(nextWaypoint.Position)
            else
                -- Next waypoint is the same as current waypoint so no plane
                this.CurrentWaypointPlaneNormal = ZERO_VECTOR3
                this.CurrentWaypointPlaneDistance = 0
            end

            -- Should we jump
            this.CurrentWaypointNeedsJump = nextWaypoint.Action == Enum.PathWaypointAction.Jump;

            -- Remember next waypoint position
            this.CurrentWaypointPosition = nextWaypoint.Position

            -- Move to next point
            this.CurrentPoint = nextWaypointIdx

            -- Finally reset Timeout
            this.Timeout = 0
        end

        function this:Start(overrideShowPath)
            if not this.AgentCanFollowPath then
                this.PathFailed:Fire()
                return
            end

            if this.Started then return end
            this.Started = true

            ClickToMoveDisplay.CancelFailureAnimation()

            if ShowPath then
                if overrideShowPath == nil or overrideShowPath then
                    this.stopTraverseFunc, this.setPointFunc = ClickToMoveDisplay.CreatePathDisplay(this.pointList, this.OriginalTargetPoint)
                end
            end

            if #this.pointList > 0 then
                -- Determine the humanoid offset from the path's first point
                -- Offset of the first waypoint from the path's origin point
                this.HumanoidOffsetFromPath = Vector3.new(0, this.pointList[1].Position.Y - this.OriginPoint.Y, 0)

                -- As well as its current position and velocity
                this.CurrentHumanoidPosition = this.Humanoid.RootPart.Position + this.HumanoidOffsetFromPath
                this.CurrentHumanoidVelocity = this.Humanoid.RootPart.Velocity

                -- Connect to events
                this.SeatedConn = this.Humanoid.Seated:Connect(function(isSeated, seat) this:OnPathInterrupted() end)
                this.DiedConn = this.Humanoid.Died:Connect(function() this:OnPathInterrupted() end)
                this.TeleportedConn = this.Humanoid.RootPart:GetPropertyChangedSignal("CFrame"):Connect(function() this:OnPathInterrupted() end)

                -- Actually start
                this.CurrentPoint = 1 -- The first waypoint is always the start location. Skip it.
                this:OnPointReached(true) -- Move to first point
            else
                this.PathFailed:Fire()
                if this.stopTraverseFunc then
                    this.stopTraverseFunc()
                end
            end
        end

        --We always raycast to the ground in the case that the user clicked a wall.
        local offsetPoint = this.TargetPoint + this.TargetSurfaceNormal*1.5
        local ray = Ray.new(offsetPoint, Vector3.new(0,-1,0)*50)
        local newHitPart, newHitPos = Workspace:FindPartOnRayWithIgnoreList(ray, getIgnoreList())
        if newHitPart then
            this.TargetPoint = newHitPos
        end
        this:ComputePath()

        return this
    end

    -------------------------------------------------------------------------

    local function CheckAlive()
        local humanoid = findPlayerHumanoid(Player)
        return humanoid ~= nil and humanoid.Health > 0
    end

    local function GetEquippedTool(character)
        if character ~= nil then
            for _, child in pairs(character:GetChildren()) do
                if child:IsA('Tool') then
                    return child
                end
            end
        end
    end

    local ExistingPather = nil
    local ExistingIndicator = nil
    local PathCompleteListener = nil
    local PathFailedListener = nil

    local function CleanupPath()
        if ExistingPather then
            ExistingPather:Cancel()
            ExistingPather = nil
        end
        if PathCompleteListener then
            PathCompleteListener:Disconnect()
            PathCompleteListener = nil
        end
        if PathFailedListener then
            PathFailedListener:Disconnect()
            PathFailedListener = nil
        end
        if ExistingIndicator then
            ExistingIndicator:Destroy()
        end
    end

    local function HandleMoveTo(thisPather, hitPt, hitChar, character, overrideShowPath)
        if ExistingPather then
            CleanupPath()
        end
        ExistingPather = thisPather
        thisPather:Start(overrideShowPath)

        PathCompleteListener = thisPather.Finished.Event:Connect(function()
            CleanupPath()
            if hitChar then
                local currentWeapon = GetEquippedTool(character)
                if currentWeapon then
                    currentWeapon:Activate()
                end
            end
        end)
        PathFailedListener = thisPather.PathFailed.Event:Connect(function()
            CleanupPath()
            if overrideShowPath == nil or overrideShowPath then
                local shouldPlayFailureAnim = PlayFailureAnimation and not (ExistingPather and ExistingPather:IsActive())
                if shouldPlayFailureAnim then
                    ClickToMoveDisplay.PlayFailureAnimation()
                end
                ClickToMoveDisplay.DisplayFailureWaypoint(hitPt)
            end
        end)
    end

    local function ShowPathFailedFeedback(hitPt)
        if ExistingPather and ExistingPather:IsActive() then
            ExistingPather:Cancel()
        end
        if PlayFailureAnimation then
            ClickToMoveDisplay.PlayFailureAnimation()
        end
        ClickToMoveDisplay.DisplayFailureWaypoint(hitPt)
    end

    function OnTap(tapPositions, goToPoint, wasTouchTap)
        -- Good to remember if this is the latest tap event
        local camera = Workspace.CurrentCamera
        local character = Player.Character

        if not CheckAlive() then return end

        -- This is a path tap position
        if #tapPositions == 1 or goToPoint then
            if camera then
                local unitRay = camera:ScreenPointToRay(tapPositions[1].x, tapPositions[1].y)
                local ray = Ray.new(unitRay.Origin, unitRay.Direction*1000)

                local myHumanoid = findPlayerHumanoid(Player)
                local hitPart, hitPt, hitNormal = Utility.Raycast(ray, true, getIgnoreList())

                local hitChar, hitHumanoid = Utility.FindCharacterAncestor(hitPart)
                if wasTouchTap and hitHumanoid and StarterGui:GetCore("AvatarContextMenuEnabled") then
                    local clickedPlayer = Players:GetPlayerFromCharacter(hitHumanoid.Parent)
                    if clickedPlayer then
                        CleanupPath()
                        return
                    end
                end
                if goToPoint then
                    hitPt = goToPoint
                    hitChar = nil
                end
                if hitPt and character then
                    -- Clean up current path
                    CleanupPath()
                    local thisPather = Pather(hitPt, hitNormal)
                    if thisPather:IsValidPath() then
                        HandleMoveTo(thisPather, hitPt, hitChar, character)
                    else
                        -- Clean up
                        thisPather:Cleanup()
                        -- Feedback here for when we don't have a good path
                        ShowPathFailedFeedback(hitPt)
                    end
                end
            end
        elseif #tapPositions >= 2 then
            if camera then
                -- Do shoot
                local currentWeapon = GetEquippedTool(character)
                if currentWeapon then
                    currentWeapon:Activate()
                end
            end
        end
    end

    local function DisconnectEvent(event)
        if event then
            event:Disconnect()
        end
    end

    --[[ The ClickToMove Controller Class ]]--
    local KeyboardController = _Keyboard()
    local ClickToMove = setmetatable({}, KeyboardController)
    ClickToMove.__index = ClickToMove

    function ClickToMove.new(CONTROL_ACTION_PRIORITY)
        local self = setmetatable(KeyboardController.new(CONTROL_ACTION_PRIORITY), ClickToMove)

        self.fingerTouches = {}
        self.numUnsunkTouches = 0
        -- PC simulation
        self.mouse1Down = tick()
        self.mouse1DownPos = Vector2.new()
        self.mouse2DownTime = tick()
        self.mouse2DownPos = Vector2.new()
        self.mouse2UpTime = tick()

        self.keyboardMoveVector = ZERO_VECTOR3

        self.tapConn = nil
        self.inputBeganConn = nil
        self.inputChangedConn = nil
        self.inputEndedConn = nil
        self.humanoidDiedConn = nil
        self.characterChildAddedConn = nil
        self.onCharacterAddedConn = nil
        self.characterChildRemovedConn = nil
        self.renderSteppedConn = nil
        self.menuOpenedConnection = nil

        self.running = false

        self.wasdEnabled = false

        return self
    end

    function ClickToMove:DisconnectEvents()
        DisconnectEvent(self.tapConn)
        DisconnectEvent(self.inputBeganConn)
        DisconnectEvent(self.inputChangedConn)
        DisconnectEvent(self.inputEndedConn)
        DisconnectEvent(self.humanoidDiedConn)
        DisconnectEvent(self.characterChildAddedConn)
        DisconnectEvent(self.onCharacterAddedConn)
        DisconnectEvent(self.renderSteppedConn)
        DisconnectEvent(self.characterChildRemovedConn)
        DisconnectEvent(self.menuOpenedConnection)
    end

    function ClickToMove:OnTouchBegan(input, processed)
        if self.fingerTouches[input] == nil and not processed then
            self.numUnsunkTouches = self.numUnsunkTouches + 1
        end
        self.fingerTouches[input] = processed
    end

    function ClickToMove:OnTouchChanged(input, processed)
        if self.fingerTouches[input] == nil then
            self.fingerTouches[input] = processed
            if not processed then
                self.numUnsunkTouches = self.numUnsunkTouches + 1
            end
        end
    end

    function ClickToMove:OnTouchEnded(input, processed)
        if self.fingerTouches[input] ~= nil and self.fingerTouches[input] == false then
            self.numUnsunkTouches = self.numUnsunkTouches - 1
        end
        self.fingerTouches[input] = nil
    end


    function ClickToMove:OnCharacterAdded(character)
        self:DisconnectEvents()

        self.inputBeganConn = UserInputService.InputBegan:Connect(function(input, processed)
            if input.UserInputType == Enum.UserInputType.Touch then
                self:OnTouchBegan(input, processed)
            end

            -- Cancel path when you use the keyboard controls if wasd is enabled.
            if self.wasdEnabled and processed == false and input.UserInputType == Enum.UserInputType.Keyboard
                and movementKeys[input.KeyCode] then
                CleanupPath()
                ClickToMoveDisplay.CancelFailureAnimation()
            end
            if input.UserInputType == Enum.UserInputType.MouseButton1 then
                self.mouse1DownTime = tick()
                self.mouse1DownPos = input.Position
            end
            if input.UserInputType == Enum.UserInputType.MouseButton2 then
                self.mouse2DownTime = tick()
                self.mouse2DownPos = input.Position
            end
        end)

        self.inputChangedConn = UserInputService.InputChanged:Connect(function(input, processed)
            if input.UserInputType == Enum.UserInputType.Touch then
                self:OnTouchChanged(input, processed)
            end
        end)

        self.inputEndedConn = UserInputService.InputEnded:Connect(function(input, processed)
            if input.UserInputType == Enum.UserInputType.Touch then
                self:OnTouchEnded(input, processed)
            end

            if input.UserInputType == Enum.UserInputType.MouseButton2 then
                self.mouse2UpTime = tick()
                local currPos = input.Position
                -- We allow click to move during path following or if there is no keyboard movement
                local allowed = ExistingPather or self.keyboardMoveVector.Magnitude <= 0
                if self.mouse2UpTime - self.mouse2DownTime < 0.25 and (currPos - self.mouse2DownPos).magnitude < 5 and allowed then
                    local positions = {currPos}
                    OnTap(positions)
                end
            end
        end)

        self.tapConn = UserInputService.TouchTap:Connect(function(touchPositions, processed)
            if not processed then
                OnTap(touchPositions, nil, true)
            end
        end)

        self.menuOpenedConnection = GuiService.MenuOpened:Connect(function()
            CleanupPath()
        end)

        local function OnCharacterChildAdded(child)
            if UserInputService.TouchEnabled then
                if child:IsA('Tool') then
                    child.ManualActivationOnly = true
                end
            end
            if child:IsA('Humanoid') then
                DisconnectEvent(self.humanoidDiedConn)
                self.humanoidDiedConn = child.Died:Connect(function()
                    if ExistingIndicator then
                        DebrisService:AddItem(ExistingIndicator.Model, 1)
                    end
                end)
            end
        end

        self.characterChildAddedConn = character.ChildAdded:Connect(function(child)
            OnCharacterChildAdded(child)
        end)
        self.characterChildRemovedConn = character.ChildRemoved:Connect(function(child)
            if UserInputService.TouchEnabled then
                if child:IsA('Tool') then
                    child.ManualActivationOnly = false
                end
            end
        end)
        for _, child in pairs(character:GetChildren()) do
            OnCharacterChildAdded(child)
        end
    end

    function ClickToMove:Start()
        self:Enable(true)
    end

    function ClickToMove:Stop()
        self:Enable(false)
    end

    function ClickToMove:CleanupPath()
        CleanupPath()
    end

    function ClickToMove:Enable(enable, enableWASD, touchJumpController)
        if enable then
            if not self.running then
                if Player.Character then -- retro-listen
                    self:OnCharacterAdded(Player.Character)
                end
                self.onCharacterAddedConn = Player.CharacterAdded:Connect(function(char)
                    self:OnCharacterAdded(char)
                end)
                self.running = true
            end
            self.touchJumpController = touchJumpController
            if self.touchJumpController then
                self.touchJumpController:Enable(self.jumpEnabled)
            end
        else
            if self.running then
                self:DisconnectEvents()
                CleanupPath()
                -- Restore tool activation on shutdown
                if UserInputService.TouchEnabled then
                    local character = Player.Character
                    if character then
                        for _, child in pairs(character:GetChildren()) do
                            if child:IsA('Tool') then
                                child.ManualActivationOnly = false
                            end
                        end
                    end
                end
                self.running = false
            end
            if self.touchJumpController and not self.jumpEnabled then
                self.touchJumpController:Enable(true)
            end
            self.touchJumpController = nil
        end

        -- Extension for initializing Keyboard input as this class now derives from Keyboard
        if UserInputService.KeyboardEnabled and enable ~= self.enabled then

            self.forwardValue  = 0
            self.backwardValue = 0
            self.leftValue = 0
            self.rightValue = 0

            self.moveVector = ZERO_VECTOR3

            if enable then
                self:BindContextActions()
                self:ConnectFocusEventListeners()
            else
                self:UnbindContextActions()
                self:DisconnectFocusEventListeners()
            end
        end

        self.wasdEnabled = enable and enableWASD or false
        self.enabled = enable
    end

    function ClickToMove:OnRenderStepped(dt)
        -- Reset jump
        self.isJumping = false

        -- Handle Pather
        if ExistingPather then
            -- Let the Pather update
            ExistingPather:OnRenderStepped(dt)

            -- If we still have a Pather, set the resulting actions
            if ExistingPather then
                -- Setup move (NOT relative to camera)
                self.moveVector = ExistingPather.NextActionMoveDirection
                self.moveVectorIsCameraRelative = false

                -- Setup jump (but do NOT prevent the base Keayboard class from requesting jumps as well)
                if ExistingPather.NextActionJump then
                    self.isJumping = true
                end
            else
                self.moveVector = self.keyboardMoveVector
                self.moveVectorIsCameraRelative = true
            end
        else
            self.moveVector = self.keyboardMoveVector
            self.moveVectorIsCameraRelative = true
        end

        -- Handle Keyboard's jump
        if self.jumpRequested then
            self.isJumping = true
        end
    end

    -- Overrides Keyboard:UpdateMovement(inputState) to conditionally consider self.wasdEnabled and let OnRenderStepped handle the movement
    function ClickToMove:UpdateMovement(inputState)
        if inputState == Enum.UserInputState.Cancel then
            self.keyboardMoveVector = ZERO_VECTOR3
        elseif self.wasdEnabled then
            self.keyboardMoveVector = Vector3.new(self.leftValue + self.rightValue, 0, self.forwardValue + self.backwardValue)
        end
    end

    -- Overrides Keyboard:UpdateJump() because jump is handled in OnRenderStepped
    function ClickToMove:UpdateJump()
        -- Nothing to do (handled in OnRenderStepped)
    end

    --Public developer facing functions
    function ClickToMove:SetShowPath(value)
        ShowPath = value
    end

    function ClickToMove:GetShowPath()
        return ShowPath
    end

    function ClickToMove:SetWaypointTexture(texture)
        ClickToMoveDisplay.SetWaypointTexture(texture)
    end

    function ClickToMove:GetWaypointTexture()
        return ClickToMoveDisplay.GetWaypointTexture()
    end

    function ClickToMove:SetWaypointRadius(radius)
        ClickToMoveDisplay.SetWaypointRadius(radius)
    end

    function ClickToMove:GetWaypointRadius()
        return ClickToMoveDisplay.GetWaypointRadius()
    end

    function ClickToMove:SetEndWaypointTexture(texture)
        ClickToMoveDisplay.SetEndWaypointTexture(texture)
    end

    function ClickToMove:GetEndWaypointTexture()
        return ClickToMoveDisplay.GetEndWaypointTexture()
    end

    function ClickToMove:SetWaypointsAlwaysOnTop(alwaysOnTop)
        ClickToMoveDisplay.SetWaypointsAlwaysOnTop(alwaysOnTop)
    end

    function ClickToMove:GetWaypointsAlwaysOnTop()
        return ClickToMoveDisplay.GetWaypointsAlwaysOnTop()
    end

    function ClickToMove:SetFailureAnimationEnabled(enabled)
        PlayFailureAnimation = enabled
    end

    function ClickToMove:GetFailureAnimationEnabled()
        return PlayFailureAnimation
    end

    function ClickToMove:SetIgnoredPartsTag(tag)
        UpdateIgnoreTag(tag)
    end

    function ClickToMove:GetIgnoredPartsTag()
        return CurrentIgnoreTag
    end

    function ClickToMove:SetUseDirectPath(directPath)
        UseDirectPath = directPath
    end

    function ClickToMove:GetUseDirectPath()
        return UseDirectPath
    end

    function ClickToMove:SetAgentSizeIncreaseFactor(increaseFactorPercent)
        AgentSizeIncreaseFactor = 1.0 + (increaseFactorPercent / 100.0)
    end

    function ClickToMove:GetAgentSizeIncreaseFactor()
        return (AgentSizeIncreaseFactor - 1.0) * 100.0
    end

    function ClickToMove:SetUnreachableWaypointTimeout(timeoutInSec)
        UnreachableWaypointTimeout = timeoutInSec
    end

    function ClickToMove:GetUnreachableWaypointTimeout()
        return UnreachableWaypointTimeout
    end

    function ClickToMove:SetUserJumpEnabled(jumpEnabled)
        self.jumpEnabled = jumpEnabled
        if self.touchJumpController then
            self.touchJumpController:Enable(jumpEnabled)
        end
    end

    function ClickToMove:GetUserJumpEnabled()
        return self.jumpEnabled
    end

    function ClickToMove:MoveTo(position, showPath, useDirectPath)
        local character = Player.Character
        if character == nil then
            return false
        end
        local thisPather = Pather(position, Vector3.new(0, 1, 0), useDirectPath)
        if thisPather and thisPather:IsValidPath() then
            HandleMoveTo(thisPather, position, nil, character, showPath)
            return true
        end
        return false
    end

    return ClickToMove
end

function _TouchThumbstick()
    local Players = game:GetService("Players")
    local GuiService = game:GetService("GuiService")
    local UserInputService = game:GetService("UserInputService")
    --[[ Constants ]]--
    local ZERO_VECTOR3 = Vector3.new(0,0,0)
    local TOUCH_CONTROL_SHEET = "rbxasset://textures/ui/TouchControlsSheet.png"
    --[[ The Module ]]--
    local BaseCharacterController = _BaseCharacterController()
    local TouchThumbstick = setmetatable({}, BaseCharacterController)
    TouchThumbstick.__index = TouchThumbstick
    function TouchThumbstick.new()
        local self = setmetatable(BaseCharacterController.new(), TouchThumbstick)

        self.isFollowStick = false

        self.thumbstickFrame = nil
        self.moveTouchObject = nil
        self.onTouchMovedConn = nil
        self.onTouchEndedConn = nil
        self.screenPos = nil
        self.stickImage = nil
        self.thumbstickSize = nil -- Float

        return self
    end
    function TouchThumbstick:Enable(enable, uiParentFrame)
        if enable == nil then return false end          -- If nil, return false (invalid argument)
        enable = enable and true or false               -- Force anything non-nil to boolean before comparison
        if self.enabled == enable then return true end  -- If no state change, return true indicating already in requested state

        self.moveVector = ZERO_VECTOR3
        self.isJumping = false

        if enable then
            -- Enable
            if not self.thumbstickFrame then
                self:Create(uiParentFrame)
            end
            self.thumbstickFrame.Visible = true
        else
            -- Disable
            self.thumbstickFrame.Visible = false
            self:OnInputEnded()
        end
        self.enabled = enable
    end
    function TouchThumbstick:OnInputEnded()
        self.thumbstickFrame.Position = self.screenPos
        self.stickImage.Position = UDim2.new(0, self.thumbstickFrame.Size.X.Offset/2 - self.thumbstickSize/4, 0, self.thumbstickFrame.Size.Y.Offset/2 - self.thumbstickSize/4)

        self.moveVector = ZERO_VECTOR3
        self.isJumping = false
        self.thumbstickFrame.Position = self.screenPos
        self.moveTouchObject = nil
    end
    function TouchThumbstick:Create(parentFrame)

        if self.thumbstickFrame then
            self.thumbstickFrame:Destroy()
            self.thumbstickFrame = nil
            if self.onTouchMovedConn then
                self.onTouchMovedConn:Disconnect()
                self.onTouchMovedConn = nil
            end
            if self.onTouchEndedConn then
                self.onTouchEndedConn:Disconnect()
                self.onTouchEndedConn = nil
            end
        end

        local minAxis = math.min(parentFrame.AbsoluteSize.x, parentFrame.AbsoluteSize.y)
        local isSmallScreen = minAxis <= 500
        self.thumbstickSize = isSmallScreen and 70 or 120
        self.screenPos = isSmallScreen and UDim2.new(0, (self.thumbstickSize/2) - 10, 1, -self.thumbstickSize - 20) or
            UDim2.new(0, self.thumbstickSize/2, 1, -self.thumbstickSize * 1.75)

        self.thumbstickFrame = Instance.new("Frame")
        self.thumbstickFrame.Name = "ThumbstickFrame"
        self.thumbstickFrame.Active = true
        self.thumbstickFrame.Visible = false
        self.thumbstickFrame.Size = UDim2.new(0, self.thumbstickSize, 0, self.thumbstickSize)
        self.thumbstickFrame.Position = self.screenPos
        self.thumbstickFrame.BackgroundTransparency = 1

        local outerImage = Instance.new("ImageLabel")
        outerImage.Name = "OuterImage"
        outerImage.Image = TOUCH_CONTROL_SHEET
        outerImage.ImageRectOffset = Vector2.new()
        outerImage.ImageRectSize = Vector2.new(220, 220)
        outerImage.BackgroundTransparency = 1
        outerImage.Size = UDim2.new(0, self.thumbstickSize, 0, self.thumbstickSize)
        outerImage.Position = UDim2.new(0, 0, 0, 0)
        outerImage.Parent = self.thumbstickFrame

        self.stickImage = Instance.new("ImageLabel")
        self.stickImage.Name = "StickImage"
        self.stickImage.Image = TOUCH_CONTROL_SHEET
        self.stickImage.ImageRectOffset = Vector2.new(220, 0)
        self.stickImage.ImageRectSize = Vector2.new(111, 111)
        self.stickImage.BackgroundTransparency = 1
        self.stickImage.Size = UDim2.new(0, self.thumbstickSize/2, 0, self.thumbstickSize/2)
        self.stickImage.Position = UDim2.new(0, self.thumbstickSize/2 - self.thumbstickSize/4, 0, self.thumbstickSize/2 - self.thumbstickSize/4)
        self.stickImage.ZIndex = 2
        self.stickImage.Parent = self.thumbstickFrame

        local centerPosition = nil
        local deadZone = 0.05

        local function DoMove(direction)

            local currentMoveVector = direction / (self.thumbstickSize/2)

            -- Scaled Radial Dead Zone
            local inputAxisMagnitude = currentMoveVector.magnitude
            if inputAxisMagnitude < deadZone then
                currentMoveVector = Vector3.new()
            else
                currentMoveVector = currentMoveVector.unit * ((inputAxisMagnitude - deadZone) / (1 - deadZone))
                -- NOTE: Making currentMoveVector a unit vector will cause the player to instantly go max speed
                -- must check for zero length vector is using unit
                currentMoveVector = Vector3.new(currentMoveVector.x, 0, currentMoveVector.y)
            end

            self.moveVector = currentMoveVector
        end

        local function MoveStick(pos)
            local relativePosition = Vector2.new(pos.x - centerPosition.x, pos.y - centerPosition.y)
            local length = relativePosition.magnitude
            local maxLength = self.thumbstickFrame.AbsoluteSize.x/2
            if self.isFollowStick and length > maxLength then
                local offset = relativePosition.unit * maxLength
                self.thumbstickFrame.Position = UDim2.new(
                    0, pos.x - self.thumbstickFrame.AbsoluteSize.x/2 - offset.x,
                    0, pos.y - self.thumbstickFrame.AbsoluteSize.y/2 - offset.y)
            else
                length = math.min(length, maxLength)
                relativePosition = relativePosition.unit * length
            end
            self.stickImage.Position = UDim2.new(0, relativePosition.x + self.stickImage.AbsoluteSize.x/2, 0, relativePosition.y + self.stickImage.AbsoluteSize.y/2)
        end

        -- input connections
        self.thumbstickFrame.InputBegan:Connect(function(inputObject)
            --A touch that starts elsewhere on the screen will be sent to a frame's InputBegan event
            --if it moves over the frame. So we check that this is actually a new touch (inputObject.UserInputState ~= Enum.UserInputState.Begin)
            if self.moveTouchObject or inputObject.UserInputType ~= Enum.UserInputType.Touch
                or inputObject.UserInputState ~= Enum.UserInputState.Begin then
                return
            end

            self.moveTouchObject = inputObject
            self.thumbstickFrame.Position = UDim2.new(0, inputObject.Position.x - self.thumbstickFrame.Size.X.Offset/2, 0, inputObject.Position.y - self.thumbstickFrame.Size.Y.Offset/2)
            centerPosition = Vector2.new(self.thumbstickFrame.AbsolutePosition.x + self.thumbstickFrame.AbsoluteSize.x/2,
                self.thumbstickFrame.AbsolutePosition.y + self.thumbstickFrame.AbsoluteSize.y/2)
            local direction = Vector2.new(inputObject.Position.x - centerPosition.x, inputObject.Position.y - centerPosition.y)
        end)

        self.onTouchMovedConn = UserInputService.TouchMoved:Connect(function(inputObject, isProcessed)
            if inputObject == self.moveTouchObject then
                centerPosition = Vector2.new(self.thumbstickFrame.AbsolutePosition.x + self.thumbstickFrame.AbsoluteSize.x/2,
                    self.thumbstickFrame.AbsolutePosition.y + self.thumbstickFrame.AbsoluteSize.y/2)
                local direction = Vector2.new(inputObject.Position.x - centerPosition.x, inputObject.Position.y - centerPosition.y)
                DoMove(direction)
                MoveStick(inputObject.Position)
            end
        end)

        self.onTouchEndedConn = UserInputService.TouchEnded:Connect(function(inputObject, isProcessed)
            if inputObject == self.moveTouchObject then
                self:OnInputEnded()
            end
        end)

        GuiService.MenuOpened:Connect(function()
            if self.moveTouchObject then
                self:OnInputEnded()
            end
        end)

        self.thumbstickFrame.Parent = parentFrame
    end
    return TouchThumbstick
end

function _DynamicThumbstick()
    local ZERO_VECTOR3 = Vector3.new(0,0,0)
    local TOUCH_CONTROLS_SHEET = "rbxasset://textures/ui/Input/TouchControlsSheetV2.png"

    local DYNAMIC_THUMBSTICK_ACTION_NAME = "DynamicThumbstickAction"
    local DYNAMIC_THUMBSTICK_ACTION_PRIORITY = Enum.ContextActionPriority.High.Value

    local MIDDLE_TRANSPARENCIES = {
        1 - 0.89,
        1 - 0.70,
        1 - 0.60,
        1 - 0.50,
        1 - 0.40,
        1 - 0.30,
        1 - 0.25
    }
    local NUM_MIDDLE_IMAGES = #MIDDLE_TRANSPARENCIES

    local FADE_IN_OUT_BACKGROUND = true
    local FADE_IN_OUT_MAX_ALPHA = 0.35

    local FADE_IN_OUT_HALF_DURATION_DEFAULT = 0.3
    local FADE_IN_OUT_BALANCE_DEFAULT = 0.5
    local ThumbstickFadeTweenInfo = TweenInfo.new(0.15, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut)

    local Players = game:GetService("Players")
    local GuiService = game:GetService("GuiService")
    local UserInputService = game:GetService("UserInputService")
    local ContextActionService = game:GetService("ContextActionService")
    local RunService = game:GetService("RunService")
    local TweenService = game:GetService("TweenService")

    local LocalPlayer = Players.LocalPlayer
    if not LocalPlayer then
        Players:GetPropertyChangedSignal("LocalPlayer"):Wait()
        LocalPlayer = Players.LocalPlayer
    end

    --[[ The Module ]]--
    local BaseCharacterController = _BaseCharacterController()
    local DynamicThumbstick = setmetatable({}, BaseCharacterController)
    DynamicThumbstick.__index = DynamicThumbstick

    function DynamicThumbstick.new()
        local self = setmetatable(BaseCharacterController.new(), DynamicThumbstick)

        self.moveTouchObject = nil
        self.moveTouchLockedIn = false
        self.moveTouchFirstChanged = false
        self.moveTouchStartPosition = nil

        self.startImage = nil
        self.endImage = nil
        self.middleImages = {}

        self.startImageFadeTween = nil
        self.endImageFadeTween = nil
        self.middleImageFadeTweens = {}

        self.isFirstTouch = true

        self.thumbstickFrame = nil

        self.onRenderSteppedConn = nil

        self.fadeInAndOutBalance = FADE_IN_OUT_BALANCE_DEFAULT
        self.fadeInAndOutHalfDuration = FADE_IN_OUT_HALF_DURATION_DEFAULT
        self.hasFadedBackgroundInPortrait = false
        self.hasFadedBackgroundInLandscape = false

        self.tweenInAlphaStart = nil
        self.tweenOutAlphaStart = nil

        return self
    end

    -- Note: Overrides base class GetIsJumping with get-and-clear behavior to do a single jump
    -- rather than sustained jumping. This is only to preserve the current behavior through the refactor.
    function DynamicThumbstick:GetIsJumping()
        local wasJumping = self.isJumping
        self.isJumping = false
        return wasJumping
    end

    function DynamicThumbstick:Enable(enable, uiParentFrame)
        if enable == nil then return false end          -- If nil, return false (invalid argument)
        enable = enable and true or false               -- Force anything non-nil to boolean before comparison
        if self.enabled == enable then return true end  -- If no state change, return true indicating already in requested state

        if enable then
            -- Enable
            if not self.thumbstickFrame then
                self:Create(uiParentFrame)
            end

            self:BindContextActions()
        else
            ContextActionService:UnbindAction(DYNAMIC_THUMBSTICK_ACTION_NAME)
            -- Disable
            self:OnInputEnded() -- Cleanup
        end

        self.enabled = enable
        self.thumbstickFrame.Visible = enable
    end

    -- Was called OnMoveTouchEnded in previous version
    function DynamicThumbstick:OnInputEnded()
        self.moveTouchObject = nil
        self.moveVector = ZERO_VECTOR3
        self:FadeThumbstick(false)
    end

    function DynamicThumbstick:FadeThumbstick(visible)
        if not visible and self.moveTouchObject then
            return
        end
        if self.isFirstTouch then return end

        if self.startImageFadeTween then
            self.startImageFadeTween:Cancel()
        end
        if self.endImageFadeTween then
            self.endImageFadeTween:Cancel()
        end
        for i = 1, #self.middleImages do
            if self.middleImageFadeTweens[i] then
                self.middleImageFadeTweens[i]:Cancel()
            end
        end

        if visible then
            self.startImageFadeTween = TweenService:Create(self.startImage, ThumbstickFadeTweenInfo, { ImageTransparency = 0 })
            self.startImageFadeTween:Play()

            self.endImageFadeTween = TweenService:Create(self.endImage, ThumbstickFadeTweenInfo, { ImageTransparency = 0.2 })
            self.endImageFadeTween:Play()

            for i = 1, #self.middleImages do
                self.middleImageFadeTweens[i] = TweenService:Create(self.middleImages[i], ThumbstickFadeTweenInfo, { ImageTransparency = MIDDLE_TRANSPARENCIES[i] })
                self.middleImageFadeTweens[i]:Play()
            end
        else
            self.startImageFadeTween = TweenService:Create(self.startImage, ThumbstickFadeTweenInfo, { ImageTransparency = 1 })
            self.startImageFadeTween:Play()

            self.endImageFadeTween = TweenService:Create(self.endImage, ThumbstickFadeTweenInfo, { ImageTransparency = 1 })
            self.endImageFadeTween:Play()

            for i = 1, #self.middleImages do
                self.middleImageFadeTweens[i] = TweenService:Create(self.middleImages[i], ThumbstickFadeTweenInfo, { ImageTransparency = 1 })
                self.middleImageFadeTweens[i]:Play()
            end
        end
    end

    function DynamicThumbstick:FadeThumbstickFrame(fadeDuration, fadeRatio)
        self.fadeInAndOutHalfDuration = fadeDuration * 0.5
        self.fadeInAndOutBalance = fadeRatio
        self.tweenInAlphaStart = tick()
    end

    function DynamicThumbstick:InputInFrame(inputObject)
        local frameCornerTopLeft = self.thumbstickFrame.AbsolutePosition
        local frameCornerBottomRight = frameCornerTopLeft + self.thumbstickFrame.AbsoluteSize
        local inputPosition = inputObject.Position
        if inputPosition.X >= frameCornerTopLeft.X and inputPosition.Y >= frameCornerTopLeft.Y then
            if inputPosition.X <= frameCornerBottomRight.X and inputPosition.Y <= frameCornerBottomRight.Y then
                return true
            end
        end
        return false
    end

    function DynamicThumbstick:DoFadeInBackground()
        local playerGui = LocalPlayer:FindFirstChildOfClass("PlayerGui")
        local hasFadedBackgroundInOrientation = false

        -- only fade in/out the background once per orientation
        if playerGui then
            if playerGui.CurrentScreenOrientation == Enum.ScreenOrientation.LandscapeLeft or
                playerGui.CurrentScreenOrientation == Enum.ScreenOrientation.LandscapeRight then
                    hasFadedBackgroundInOrientation = self.hasFadedBackgroundInLandscape
                    self.hasFadedBackgroundInLandscape = true
            elseif playerGui.CurrentScreenOrientation == Enum.ScreenOrientation.Portrait then
                    hasFadedBackgroundInOrientation = self.hasFadedBackgroundInPortrait
                    self.hasFadedBackgroundInPortrait = true
            end
        end

        if not hasFadedBackgroundInOrientation then
            self.fadeInAndOutHalfDuration = FADE_IN_OUT_HALF_DURATION_DEFAULT
            self.fadeInAndOutBalance = FADE_IN_OUT_BALANCE_DEFAULT
            self.tweenInAlphaStart = tick()
        end
    end

    function DynamicThumbstick:DoMove(direction)
        local currentMoveVector = direction

        -- Scaled Radial Dead Zone
        local inputAxisMagnitude = currentMoveVector.magnitude
        if inputAxisMagnitude < self.radiusOfDeadZone then
            currentMoveVector = ZERO_VECTOR3
        else
            currentMoveVector = currentMoveVector.unit*(
                1 - math.max(0, (self.radiusOfMaxSpeed - currentMoveVector.magnitude)/self.radiusOfMaxSpeed)
            )
            currentMoveVector = Vector3.new(currentMoveVector.x, 0, currentMoveVector.y)
        end

        self.moveVector = currentMoveVector
    end


    function DynamicThumbstick:LayoutMiddleImages(startPos, endPos)
        local startDist = (self.thumbstickSize / 2) + self.middleSize
        local vector = endPos - startPos
        local distAvailable = vector.magnitude - (self.thumbstickRingSize / 2) - self.middleSize
        local direction = vector.unit

        local distNeeded = self.middleSpacing * NUM_MIDDLE_IMAGES
        local spacing = self.middleSpacing

        if distNeeded < distAvailable then
            spacing = distAvailable / NUM_MIDDLE_IMAGES
        end

        for i = 1, NUM_MIDDLE_IMAGES do
            local image = self.middleImages[i]
            local distWithout = startDist + (spacing * (i - 2))
            local currentDist = startDist + (spacing * (i - 1))

            if distWithout < distAvailable then
                local pos = endPos - direction * currentDist
                local exposedFraction = math.clamp(1 - ((currentDist - distAvailable) / spacing), 0, 1)

                image.Visible = true
                image.Position = UDim2.new(0, pos.X, 0, pos.Y)
                image.Size = UDim2.new(0, self.middleSize * exposedFraction, 0, self.middleSize * exposedFraction)
            else
                image.Visible = false
            end
        end
    end

    function DynamicThumbstick:MoveStick(pos)
        local vector2StartPosition = Vector2.new(self.moveTouchStartPosition.X, self.moveTouchStartPosition.Y)
        local startPos = vector2StartPosition - self.thumbstickFrame.AbsolutePosition
        local endPos = Vector2.new(pos.X, pos.Y) - self.thumbstickFrame.AbsolutePosition
        self.endImage.Position = UDim2.new(0, endPos.X, 0, endPos.Y)
        self:LayoutMiddleImages(startPos, endPos)
    end

    function DynamicThumbstick:BindContextActions()
        local function inputBegan(inputObject)
            if self.moveTouchObject then
                return Enum.ContextActionResult.Pass
            end

            if not self:InputInFrame(inputObject) then
                return Enum.ContextActionResult.Pass
            end

            if self.isFirstTouch then
                self.isFirstTouch = false
                local tweenInfo = TweenInfo.new(0.5, Enum.EasingStyle.Quad, Enum.EasingDirection.Out,0,false,0)
                TweenService:Create(self.startImage, tweenInfo, {Size = UDim2.new(0, 0, 0, 0)}):Play()
                TweenService:Create(
                    self.endImage,
                    tweenInfo,
                    {Size = UDim2.new(0, self.thumbstickSize, 0, self.thumbstickSize), ImageColor3 = Color3.new(0,0,0)}
                ):Play()
            end

            self.moveTouchLockedIn = false
            self.moveTouchObject = inputObject
            self.moveTouchStartPosition = inputObject.Position
            self.moveTouchFirstChanged = true

            if FADE_IN_OUT_BACKGROUND then
                self:DoFadeInBackground()
            end

            return Enum.ContextActionResult.Pass
        end

        local function inputChanged(inputObject)
            if inputObject == self.moveTouchObject then
                if self.moveTouchFirstChanged then
                    self.moveTouchFirstChanged = false

                    local startPosVec2 = Vector2.new(
                        inputObject.Position.X - self.thumbstickFrame.AbsolutePosition.X,
                        inputObject.Position.Y - self.thumbstickFrame.AbsolutePosition.Y
                    )
                    self.startImage.Visible = true
                    self.startImage.Position = UDim2.new(0, startPosVec2.X, 0, startPosVec2.Y)
                    self.endImage.Visible = true
                    self.endImage.Position = self.startImage.Position

                    self:FadeThumbstick(true)
                    self:MoveStick(inputObject.Position)
                end

                self.moveTouchLockedIn = true

                local direction = Vector2.new(
                    inputObject.Position.x - self.moveTouchStartPosition.x,
                    inputObject.Position.y - self.moveTouchStartPosition.y
                )
                if math.abs(direction.x) > 0 or math.abs(direction.y) > 0 then
                    self:DoMove(direction)
                    self:MoveStick(inputObject.Position)
                end
                return Enum.ContextActionResult.Sink
            end
            return Enum.ContextActionResult.Pass
        end

        local function inputEnded(inputObject)
            if inputObject == self.moveTouchObject then
                self:OnInputEnded()
                if self.moveTouchLockedIn then
                    return Enum.ContextActionResult.Sink
                end
            end
            return Enum.ContextActionResult.Pass
        end

        local function handleInput(actionName, inputState, inputObject)
            if inputState == Enum.UserInputState.Begin then
                return inputBegan(inputObject)
            elseif inputState == Enum.UserInputState.Change then
                return inputChanged(inputObject)
            elseif inputState == Enum.UserInputState.End then
                return inputEnded(inputObject)
            elseif inputState == Enum.UserInputState.Cancel then
                self:OnInputEnded()
            end
        end

        ContextActionService:BindActionAtPriority(
            DYNAMIC_THUMBSTICK_ACTION_NAME,
            handleInput,
            false,
            DYNAMIC_THUMBSTICK_ACTION_PRIORITY,
            Enum.UserInputType.Touch)
    end

    function DynamicThumbstick:Create(parentFrame)
        if self.thumbstickFrame then
            self.thumbstickFrame:Destroy()
            self.thumbstickFrame = nil
            if self.onRenderSteppedConn then
                self.onRenderSteppedConn:Disconnect()
                self.onRenderSteppedConn = nil
            end
        end

        self.thumbstickSize = 45
        self.thumbstickRingSize = 20
        self.middleSize = 10
        self.middleSpacing = self.middleSize + 4
        self.radiusOfDeadZone = 2
        self.radiusOfMaxSpeed = 20

        local screenSize = parentFrame.AbsoluteSize
        local isBigScreen = math.min(screenSize.x, screenSize.y) > 500
        if isBigScreen then
            self.thumbstickSize = self.thumbstickSize * 2
            self.thumbstickRingSize = self.thumbstickRingSize * 2
            self.middleSize = self.middleSize * 2
            self.middleSpacing = self.middleSpacing * 2
            self.radiusOfDeadZone = self.radiusOfDeadZone * 2
            self.radiusOfMaxSpeed = self.radiusOfMaxSpeed * 2
        end

        local function layoutThumbstickFrame(portraitMode)
            if portraitMode then
                self.thumbstickFrame.Size = UDim2.new(1, 0, 0.4, 0)
                self.thumbstickFrame.Position = UDim2.new(0, 0, 0.6, 0)
            else
                self.thumbstickFrame.Size = UDim2.new(0.4, 0, 2/3, 0)
                self.thumbstickFrame.Position = UDim2.new(0, 0, 1/3, 0)
            end
        end

        self.thumbstickFrame = Instance.new("Frame")
        self.thumbstickFrame.BorderSizePixel = 0
        self.thumbstickFrame.Name = "DynamicThumbstickFrame"
        self.thumbstickFrame.Visible = false
        self.thumbstickFrame.BackgroundTransparency = 1.0
        self.thumbstickFrame.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
        self.thumbstickFrame.Active = false
        layoutThumbstickFrame(false)

        self.startImage = Instance.new("ImageLabel")
        self.startImage.Name = "ThumbstickStart"
        self.startImage.Visible = true
        self.startImage.BackgroundTransparency = 1
        self.startImage.Image = TOUCH_CONTROLS_SHEET
        self.startImage.ImageRectOffset = Vector2.new(1,1)
        self.startImage.ImageRectSize = Vector2.new(144, 144)
        self.startImage.ImageColor3 = Color3.new(0, 0, 0)
        self.startImage.AnchorPoint = Vector2.new(0.5, 0.5)
        self.startImage.Position = UDim2.new(0, self.thumbstickRingSize * 3.3, 1, -self.thumbstickRingSize  * 2.8)
        self.startImage.Size = UDim2.new(0, self.thumbstickRingSize  * 3.7, 0, self.thumbstickRingSize  * 3.7)
        self.startImage.ZIndex = 10
        self.startImage.Parent = self.thumbstickFrame

        self.endImage = Instance.new("ImageLabel")
        self.endImage.Name = "ThumbstickEnd"
        self.endImage.Visible = true
        self.endImage.BackgroundTransparency = 1
        self.endImage.Image = TOUCH_CONTROLS_SHEET
        self.endImage.ImageRectOffset = Vector2.new(1,1)
        self.endImage.ImageRectSize =  Vector2.new(144, 144)
        self.endImage.AnchorPoint = Vector2.new(0.5, 0.5)
        self.endImage.Position = self.startImage.Position
        self.endImage.Size = UDim2.new(0, self.thumbstickSize * 0.8, 0, self.thumbstickSize * 0.8)
        self.endImage.ZIndex = 10
        self.endImage.Parent = self.thumbstickFrame

        for i = 1, NUM_MIDDLE_IMAGES do
            self.middleImages[i] = Instance.new("ImageLabel")
            self.middleImages[i].Name = "ThumbstickMiddle"
            self.middleImages[i].Visible = false
            self.middleImages[i].BackgroundTransparency = 1
            self.middleImages[i].Image = TOUCH_CONTROLS_SHEET
            self.middleImages[i].ImageRectOffset = Vector2.new(1,1)
            self.middleImages[i].ImageRectSize = Vector2.new(144, 144)
            self.middleImages[i].ImageTransparency = MIDDLE_TRANSPARENCIES[i]
            self.middleImages[i].AnchorPoint = Vector2.new(0.5, 0.5)
            self.middleImages[i].ZIndex = 9
            self.middleImages[i].Parent = self.thumbstickFrame
        end

        local CameraChangedConn = nil
        local function onCurrentCameraChanged()
            if CameraChangedConn then
                CameraChangedConn:Disconnect()
                CameraChangedConn = nil
            end
            local newCamera = workspace.CurrentCamera
            if newCamera then
                local function onViewportSizeChanged()
                    local size = newCamera.ViewportSize
                    local portraitMode = size.X < size.Y
                    layoutThumbstickFrame(portraitMode)
                end
                CameraChangedConn = newCamera:GetPropertyChangedSignal("ViewportSize"):Connect(onViewportSizeChanged)
                onViewportSizeChanged()
            end
        end
        workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(onCurrentCameraChanged)
        if workspace.CurrentCamera then
            onCurrentCameraChanged()
        end

        self.moveTouchStartPosition = nil

        self.startImageFadeTween = nil
        self.endImageFadeTween = nil
        self.middleImageFadeTweens = {}

        self.onRenderSteppedConn = RunService.RenderStepped:Connect(function()
            if self.tweenInAlphaStart ~= nil then
                local delta = tick() - self.tweenInAlphaStart
                local fadeInTime = (self.fadeInAndOutHalfDuration * 2 * self.fadeInAndOutBalance)
                self.thumbstickFrame.BackgroundTransparency = 1 - FADE_IN_OUT_MAX_ALPHA*math.min(delta/fadeInTime, 1)
                if delta > fadeInTime then
                    self.tweenOutAlphaStart = tick()
                    self.tweenInAlphaStart = nil
                end
            elseif self.tweenOutAlphaStart ~= nil then
                local delta = tick() - self.tweenOutAlphaStart
                local fadeOutTime = (self.fadeInAndOutHalfDuration * 2) - (self.fadeInAndOutHalfDuration * 2 * self.fadeInAndOutBalance)
                self.thumbstickFrame.BackgroundTransparency = 1 - FADE_IN_OUT_MAX_ALPHA + FADE_IN_OUT_MAX_ALPHA*math.min(delta/fadeOutTime, 1)
                if delta > fadeOutTime  then
                    self.tweenOutAlphaStart = nil
                end
            end
        end)

        self.onTouchEndedConn = UserInputService.TouchEnded:connect(function(inputObject)
            if inputObject == self.moveTouchObject then
                self:OnInputEnded()
            end
        end)

        GuiService.MenuOpened:connect(function()
            if self.moveTouchObject then
                self:OnInputEnded()
            end
        end)

        local playerGui = LocalPlayer:FindFirstChildOfClass("PlayerGui")
        while not playerGui do
            LocalPlayer.ChildAdded:wait()
            playerGui = LocalPlayer:FindFirstChildOfClass("PlayerGui")
        end

        local playerGuiChangedConn = nil
        local originalScreenOrientationWasLandscape =   playerGui.CurrentScreenOrientation == Enum.ScreenOrientation.LandscapeLeft or
                                                        playerGui.CurrentScreenOrientation == Enum.ScreenOrientation.LandscapeRight

        local function longShowBackground()
            self.fadeInAndOutHalfDuration = 2.5
            self.fadeInAndOutBalance = 0.05
            self.tweenInAlphaStart = tick()
        end

        playerGuiChangedConn = playerGui:GetPropertyChangedSignal("CurrentScreenOrientation"):Connect(function()
            if (originalScreenOrientationWasLandscape and playerGui.CurrentScreenOrientation == Enum.ScreenOrientation.Portrait) or
                (not originalScreenOrientationWasLandscape and playerGui.CurrentScreenOrientation ~= Enum.ScreenOrientation.Portrait) then

                playerGuiChangedConn:disconnect()
                longShowBackground()

                if originalScreenOrientationWasLandscape then
                    self.hasFadedBackgroundInPortrait = true
                else
                    self.hasFadedBackgroundInLandscape = true
                end
            end
        end)

        self.thumbstickFrame.Parent = parentFrame

        if game:IsLoaded() then
            longShowBackground()
        else
            coroutine.wrap(function()
                game.Loaded:Wait()
                longShowBackground()
            end)()
        end
    end

    return DynamicThumbstick
end

function _Gamepad()
    local UserInputService = game:GetService("UserInputService")
    local ContextActionService = game:GetService("ContextActionService")

    --[[ Constants ]]--
    local ZERO_VECTOR3 = Vector3.new(0,0,0)
    local NONE = Enum.UserInputType.None
    local thumbstickDeadzone = 0.2

    --[[ The Module ]]--
    local BaseCharacterController = _BaseCharacterController()
    local Gamepad = setmetatable({}, BaseCharacterController)
    Gamepad.__index = Gamepad

    function Gamepad.new(CONTROL_ACTION_PRIORITY)
        local self = setmetatable(BaseCharacterController.new(), Gamepad)

        self.CONTROL_ACTION_PRIORITY = CONTROL_ACTION_PRIORITY

        self.forwardValue  = 0
        self.backwardValue = 0
        self.leftValue = 0
        self.rightValue = 0

        self.activeGamepad = NONE   -- Enum.UserInputType.Gamepad1, 2, 3...
        self.gamepadConnectedConn = nil
        self.gamepadDisconnectedConn = nil
        return self
    end

    function Gamepad:Enable(enable)
        if not UserInputService.GamepadEnabled then
            return false
        end

        if enable == self.enabled then
            -- Module is already in the state being requested. True is returned here since the module will be in the state
            -- expected by the code that follows the Enable() call. This makes more sense than returning false to indicate
            -- no action was necessary. False indicates failure to be in requested/expected state.
            return true
        end

        self.forwardValue  = 0
        self.backwardValue = 0
        self.leftValue = 0
        self.rightValue = 0
        self.moveVector = ZERO_VECTOR3
        self.isJumping = false

        if enable then
            self.activeGamepad = self:GetHighestPriorityGamepad()
            if self.activeGamepad ~= NONE then
                self:BindContextActions()
                self:ConnectGamepadConnectionListeners()
            else
                -- No connected gamepads, failure to enable
                return false
            end
        else
            self:UnbindContextActions()
            self:DisconnectGamepadConnectionListeners()
            self.activeGamepad = NONE
        end

        self.enabled = enable
        return true
    end

    -- This function selects the lowest number gamepad from the currently-connected gamepad
    -- and sets it as the active gamepad
    function Gamepad:GetHighestPriorityGamepad()
        local connectedGamepads = UserInputService:GetConnectedGamepads()
        local bestGamepad = NONE -- Note that this value is higher than all valid gamepad values
        for _, gamepad in pairs(connectedGamepads) do
            if gamepad.Value < bestGamepad.Value then
                bestGamepad = gamepad
            end
        end
        return bestGamepad
    end

    function Gamepad:BindContextActions()

        if self.activeGamepad == NONE then
            -- There must be an active gamepad to set up bindings
            return false
        end

        local handleJumpAction = function(actionName, inputState, inputObject)
            self.isJumping = (inputState == Enum.UserInputState.Begin)
            return Enum.ContextActionResult.Sink
        end

        local handleThumbstickInput = function(actionName, inputState, inputObject)

            if inputState == Enum.UserInputState.Cancel then
                self.moveVector = ZERO_VECTOR3
                return Enum.ContextActionResult.Sink
            end

            if self.activeGamepad ~= inputObject.UserInputType then
                return Enum.ContextActionResult.Pass
            end
            if inputObject.KeyCode ~= Enum.KeyCode.Thumbstick1 then return end

            if inputObject.Position.magnitude > thumbstickDeadzone then
                self.moveVector  =  Vector3.new(inputObject.Position.X, 0, -inputObject.Position.Y)
            else
                self.moveVector = ZERO_VECTOR3
            end
            return Enum.ContextActionResult.Sink
        end

        ContextActionService:BindActivate(self.activeGamepad, Enum.KeyCode.ButtonR2)
        ContextActionService:BindActionAtPriority("jumpAction", handleJumpAction, false,
            self.CONTROL_ACTION_PRIORITY, Enum.KeyCode.ButtonA)
        ContextActionService:BindActionAtPriority("moveThumbstick", handleThumbstickInput, false,
            self.CONTROL_ACTION_PRIORITY, Enum.KeyCode.Thumbstick1)

        return true
    end

    function Gamepad:UnbindContextActions()
        if self.activeGamepad ~= NONE then
            ContextActionService:UnbindActivate(self.activeGamepad, Enum.KeyCode.ButtonR2)
        end
        ContextActionService:UnbindAction("moveThumbstick")
        ContextActionService:UnbindAction("jumpAction")
    end

    function Gamepad:OnNewGamepadConnected()
        -- A new gamepad has been connected.
        local bestGamepad = self:GetHighestPriorityGamepad()

        if bestGamepad == self.activeGamepad then
            -- A new gamepad was connected, but our active gamepad is not changing
            return
        end

        if bestGamepad == NONE then
            -- There should be an active gamepad when GamepadConnected fires, so this should not
            -- normally be hit. If there is no active gamepad, unbind actions but leave
            -- the module enabled and continue to listen for a new gamepad connection.
            warn("Gamepad:OnNewGamepadConnected found no connected gamepads")
            self:UnbindContextActions()
            return
        end

        if self.activeGamepad ~= NONE then
            -- Switching from one active gamepad to another
            self:UnbindContextActions()
        end

        self.activeGamepad = bestGamepad
        self:BindContextActions()
    end

    function Gamepad:OnCurrentGamepadDisconnected()
        if self.activeGamepad ~= NONE then
            ContextActionService:UnbindActivate(self.activeGamepad, Enum.KeyCode.ButtonR2)
        end

        local bestGamepad = self:GetHighestPriorityGamepad()

        if self.activeGamepad ~= NONE and bestGamepad == self.activeGamepad then
            warn("Gamepad:OnCurrentGamepadDisconnected found the supposedly disconnected gamepad in connectedGamepads.")
            self:UnbindContextActions()
            self.activeGamepad = NONE
            return
        end

        if bestGamepad == NONE then
            -- No active gamepad, unbinding actions but leaving gamepad connection listener active
            self:UnbindContextActions()
            self.activeGamepad = NONE
        else
            -- Set new gamepad as active and bind to tool activation
            self.activeGamepad = bestGamepad
            ContextActionService:BindActivate(self.activeGamepad, Enum.KeyCode.ButtonR2)
        end
    end

    function Gamepad:ConnectGamepadConnectionListeners()
        self.gamepadConnectedConn = UserInputService.GamepadConnected:Connect(function(gamepadEnum)
            self:OnNewGamepadConnected()
        end)

        self.gamepadDisconnectedConn = UserInputService.GamepadDisconnected:Connect(function(gamepadEnum)
            if self.activeGamepad == gamepadEnum then
                self:OnCurrentGamepadDisconnected()
            end
        end)

    end

    function Gamepad:DisconnectGamepadConnectionListeners()
        if self.gamepadConnectedConn then
            self.gamepadConnectedConn:Disconnect()
            self.gamepadConnectedConn = nil
        end

        if self.gamepadDisconnectedConn then
            self.gamepadDisconnectedConn:Disconnect()
            self.gamepadDisconnectedConn = nil
        end
    end

    return Gamepad
end

function _Keyboard()

    --[[ Roblox Services ]]--
    local UserInputService = game:GetService("UserInputService")
    local ContextActionService = game:GetService("ContextActionService")

    --[[ Constants ]]--
    local ZERO_VECTOR3 = Vector3.new(0,0,0)

    --[[ The Module ]]--
    local BaseCharacterController = _BaseCharacterController()
    local Keyboard = setmetatable({}, BaseCharacterController)
    Keyboard.__index = Keyboard

    function Keyboard.new(CONTROL_ACTION_PRIORITY)
        local self = setmetatable(BaseCharacterController.new(), Keyboard)

        self.CONTROL_ACTION_PRIORITY = CONTROL_ACTION_PRIORITY

        self.textFocusReleasedConn = nil
        self.textFocusGainedConn = nil
        self.windowFocusReleasedConn = nil

        self.forwardValue  = 0
        self.backwardValue = 0
        self.leftValue = 0
        self.rightValue = 0

        self.jumpEnabled = true

        return self
    end

    function Keyboard:Enable(enable)
        if not UserInputService.KeyboardEnabled then
            return false
        end

        if enable == self.enabled then
            -- Module is already in the state being requested. True is returned here since the module will be in the state
            -- expected by the code that follows the Enable() call. This makes more sense than returning false to indicate
            -- no action was necessary. False indicates failure to be in requested/expected state.
            return true
        end

        self.forwardValue  = 0
        self.backwardValue = 0
        self.leftValue = 0
        self.rightValue = 0
        self.moveVector = ZERO_VECTOR3
        self.jumpRequested = false
        self:UpdateJump()

        if enable then
            self:BindContextActions()
            self:ConnectFocusEventListeners()
        else
            self:UnbindContextActions()
            self:DisconnectFocusEventListeners()
        end

        self.enabled = enable
        return true
    end

    function Keyboard:UpdateMovement(inputState)
        if inputState == Enum.UserInputState.Cancel then
            self.moveVector = ZERO_VECTOR3
        else
            self.moveVector = Vector3.new(self.leftValue + self.rightValue, 0, self.forwardValue + self.backwardValue)
        end
    end

    function Keyboard:UpdateJump()
        self.isJumping = self.jumpRequested
    end

    function Keyboard:BindContextActions()

        -- Note: In the previous version of this code, the movement values were not zeroed-out on UserInputState. Cancel, now they are,
        -- which fixes them from getting stuck on.
        -- We return ContextActionResult.Pass here for legacy reasons.
        -- Many games rely on gameProcessedEvent being false on UserInputService.InputBegan for these control actions.
        local handleMoveForward = function(actionName, inputState, inputObject)
            self.forwardValue = (inputState == Enum.UserInputState.Begin) and -1 or 0
            self:UpdateMovement(inputState)
            return Enum.ContextActionResult.Pass
        end

        local handleMoveBackward = function(actionName, inputState, inputObject)
            self.backwardValue = (inputState == Enum.UserInputState.Begin) and 1 or 0
            self:UpdateMovement(inputState)
            return Enum.ContextActionResult.Pass
        end

        local handleMoveLeft = function(actionName, inputState, inputObject)
            self.leftValue = (inputState == Enum.UserInputState.Begin) and -1 or 0
            self:UpdateMovement(inputState)
            return Enum.ContextActionResult.Pass
        end

        local handleMoveRight = function(actionName, inputState, inputObject)
            self.rightValue = (inputState == Enum.UserInputState.Begin) and 1 or 0
            self:UpdateMovement(inputState)
            return Enum.ContextActionResult.Pass
        end

        local handleJumpAction = function(actionName, inputState, inputObject)
            self.jumpRequested = self.jumpEnabled and (inputState == Enum.UserInputState.Begin)
            self:UpdateJump()
            return Enum.ContextActionResult.Pass
        end

        -- TODO: Revert to KeyCode bindings so that in the future the abstraction layer from actual keys to
        -- movement direction is done in Lua
        ContextActionService:BindActionAtPriority("moveForwardAction", handleMoveForward, false,
            self.CONTROL_ACTION_PRIORITY, Enum.PlayerActions.CharacterForward)
        ContextActionService:BindActionAtPriority("moveBackwardAction", handleMoveBackward, false,
            self.CONTROL_ACTION_PRIORITY, Enum.PlayerActions.CharacterBackward)
        ContextActionService:BindActionAtPriority("moveLeftAction", handleMoveLeft, false,
            self.CONTROL_ACTION_PRIORITY, Enum.PlayerActions.CharacterLeft)
        ContextActionService:BindActionAtPriority("moveRightAction", handleMoveRight, false,
            self.CONTROL_ACTION_PRIORITY, Enum.PlayerActions.CharacterRight)
        ContextActionService:BindActionAtPriority("jumpAction", handleJumpAction, false,
            self.CONTROL_ACTION_PRIORITY, Enum.PlayerActions.CharacterJump)
    end

    function Keyboard:UnbindContextActions()
        ContextActionService:UnbindAction("moveForwardAction")
        ContextActionService:UnbindAction("moveBackwardAction")
        ContextActionService:UnbindAction("moveLeftAction")
        ContextActionService:UnbindAction("moveRightAction")
        ContextActionService:UnbindAction("jumpAction")
    end

    function Keyboard:ConnectFocusEventListeners()
        local function onFocusReleased()
            self.moveVector = ZERO_VECTOR3
            self.forwardValue  = 0
            self.backwardValue = 0
            self.leftValue = 0
            self.rightValue = 0
            self.jumpRequested = false
            self:UpdateJump()
        end

        local function onTextFocusGained(textboxFocused)
            self.jumpRequested = false
            self:UpdateJump()
        end

        self.textFocusReleasedConn = UserInputService.TextBoxFocusReleased:Connect(onFocusReleased)
        self.textFocusGainedConn = UserInputService.TextBoxFocused:Connect(onTextFocusGained)
        self.windowFocusReleasedConn = UserInputService.WindowFocused:Connect(onFocusReleased)
    end

    function Keyboard:DisconnectFocusEventListeners()
        if self.textFocusReleasedCon then
            self.textFocusReleasedCon:Disconnect()
            self.textFocusReleasedCon = nil
        end
        if self.textFocusGainedConn then
            self.textFocusGainedConn:Disconnect()
            self.textFocusGainedConn = nil
        end
        if self.windowFocusReleasedConn then
            self.windowFocusReleasedConn:Disconnect()
            self.windowFocusReleasedConn = nil
        end
    end

    return Keyboard
end

function _ControlModule()
    local ControlModule = {}
    ControlModule.__index = ControlModule

    --[[ Roblox Services ]]--
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local Workspace = game:GetService("Workspace")
    local UserGameSettings = UserSettings():GetService("UserGameSettings")

    -- Roblox User Input Control Modules - each returns a new() constructor function used to create controllers as needed
    local Keyboard = _Keyboard()
    local Gamepad = _Gamepad()
    local DynamicThumbstick = _DynamicThumbstick()

    local FFlagUserMakeThumbstickDynamic do
        local success, value = pcall(function()
            return UserSettings():IsUserFeatureEnabled("UserMakeThumbstickDynamic")
        end)
        FFlagUserMakeThumbstickDynamic = success and value
    end

    local TouchThumbstick = FFlagUserMakeThumbstickDynamic and DynamicThumbstick or _TouchThumbstick()

    -- These controllers handle only walk/run movement, jumping is handled by the
    -- TouchJump controller if any of these are active
    local ClickToMove = _ClickToMoveController()
    local TouchJump = _TouchJump()

    local VehicleController = _VehicleController()

    local CONTROL_ACTION_PRIORITY = Enum.ContextActionPriority.Default.Value

    -- Mapping from movement mode and lastInputType enum values to control modules to avoid huge if elseif switching
    local movementEnumToModuleMap = {
        [Enum.TouchMovementMode.DPad] = DynamicThumbstick,
        [Enum.DevTouchMovementMode.DPad] = DynamicThumbstick,
        [Enum.TouchMovementMode.Thumbpad] = DynamicThumbstick,
        [Enum.DevTouchMovementMode.Thumbpad] = DynamicThumbstick,
        [Enum.TouchMovementMode.Thumbstick] = TouchThumbstick,
        [Enum.DevTouchMovementMode.Thumbstick] = TouchThumbstick,
        [Enum.TouchMovementMode.DynamicThumbstick] = DynamicThumbstick,
        [Enum.DevTouchMovementMode.DynamicThumbstick] = DynamicThumbstick,
        [Enum.TouchMovementMode.ClickToMove] = ClickToMove,
        [Enum.DevTouchMovementMode.ClickToMove] = ClickToMove,

        -- Current default
        [Enum.TouchMovementMode.Default] = DynamicThumbstick,

        [Enum.ComputerMovementMode.Default] = Keyboard,
        [Enum.ComputerMovementMode.KeyboardMouse] = Keyboard,
        [Enum.DevComputerMovementMode.KeyboardMouse] = Keyboard,
        [Enum.DevComputerMovementMode.Scriptable] = nil,
        [Enum.ComputerMovementMode.ClickToMove] = ClickToMove,
        [Enum.DevComputerMovementMode.ClickToMove] = ClickToMove,
    }

    -- Keyboard controller is really keyboard and mouse controller
    local computerInputTypeToModuleMap = {
        [Enum.UserInputType.Keyboard] = Keyboard,
        [Enum.UserInputType.MouseButton1] = Keyboard,
        [Enum.UserInputType.MouseButton2] = Keyboard,
        [Enum.UserInputType.MouseButton3] = Keyboard,
        [Enum.UserInputType.MouseWheel] = Keyboard,
        [Enum.UserInputType.MouseMovement] = Keyboard,
        [Enum.UserInputType.Gamepad1] = Gamepad,
        [Enum.UserInputType.Gamepad2] = Gamepad,
        [Enum.UserInputType.Gamepad3] = Gamepad,
        [Enum.UserInputType.Gamepad4] = Gamepad,
    }

    local lastInputType

    function ControlModule.new()
        local self = setmetatable({},ControlModule)

        -- The Modules above are used to construct controller instances as-needed, and this
        -- table is a map from Module to the instance created from it
        self.controllers = {}

        self.activeControlModule = nil  -- Used to prevent unnecessarily expensive checks on each input event
        self.activeController = nil
        self.touchJumpController = nil
        self.moveFunction = Players.LocalPlayer.Move
        self.humanoid = nil
        self.lastInputType = Enum.UserInputType.None

        -- For Roblox self.vehicleController
        self.humanoidSeatedConn = nil
        self.vehicleController = nil

        self.touchControlFrame = nil

        self.vehicleController = VehicleController.new(CONTROL_ACTION_PRIORITY)

        Players.LocalPlayer.CharacterAdded:Connect(function(char) self:OnCharacterAdded(char) end)
        Players.LocalPlayer.CharacterRemoving:Connect(function(char) self:OnCharacterRemoving(char) end)
        if Players.LocalPlayer.Character then
            self:OnCharacterAdded(Players.LocalPlayer.Character)
        end

        RunService:BindToRenderStep("ControlScriptRenderstep", Enum.RenderPriority.Input.Value, function(dt)
            self:OnRenderStepped(dt)
        end)

        UserInputService.LastInputTypeChanged:Connect(function(newLastInputType)
            self:OnLastInputTypeChanged(newLastInputType)
        end)


        UserGameSettings:GetPropertyChangedSignal("TouchMovementMode"):Connect(function()
            self:OnTouchMovementModeChange()
        end)
        Players.LocalPlayer:GetPropertyChangedSignal("DevTouchMovementMode"):Connect(function()
            self:OnTouchMovementModeChange()
        end)

        UserGameSettings:GetPropertyChangedSignal("ComputerMovementMode"):Connect(function()
            self:OnComputerMovementModeChange()
        end)
        Players.LocalPlayer:GetPropertyChangedSignal("DevComputerMovementMode"):Connect(function()
            self:OnComputerMovementModeChange()
        end)

        --[[ Touch Device UI ]]--
        self.playerGui = nil
        self.touchGui = nil
        self.playerGuiAddedConn = nil

        if UserInputService.TouchEnabled then
            self.playerGui = Players.LocalPlayer:FindFirstChildOfClass("PlayerGui")
            if self.playerGui then
                self:CreateTouchGuiContainer()
                self:OnLastInputTypeChanged(UserInputService:GetLastInputType())
            else
                self.playerGuiAddedConn = Players.LocalPlayer.ChildAdded:Connect(function(child)
                    if child:IsA("PlayerGui") then
                        self.playerGui = child
                        self:CreateTouchGuiContainer()
                        self.playerGuiAddedConn:Disconnect()
                        self.playerGuiAddedConn = nil
                        self:OnLastInputTypeChanged(UserInputService:GetLastInputType())
                    end
                end)
            end
        else
            self:OnLastInputTypeChanged(UserInputService:GetLastInputType())
        end

        return self
    end

    -- Convenience function so that calling code does not have to first get the activeController
    -- and then call GetMoveVector on it. When there is no active controller, this function returns
    -- nil so that this case can be distinguished from no current movement (which returns zero vector).
    function ControlModule:GetMoveVector()
        if self.activeController then
            return self.activeController:GetMoveVector()
        end
        return Vector3.new(0,0,0)
    end

    function ControlModule:GetActiveController()
        return self.activeController
    end

    function ControlModule:EnableActiveControlModule()
        if self.activeControlModule == ClickToMove then
            -- For ClickToMove, when it is the player's choice, we also enable the full keyboard controls.
            -- When the developer is forcing click to move, the most keyboard controls (WASD) are not available, only jump.
            self.activeController:Enable(
                true,
                Players.LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.UserChoice,
                self.touchJumpController
            )
        elseif self.touchControlFrame then
            self.activeController:Enable(true, self.touchControlFrame)
        else
            self.activeController:Enable(true)
        end
    end

    function ControlModule:Enable(enable)
        if not self.activeController then
            return
        end

        if enable == nil then
            enable = true
        end
        if enable then
            self:EnableActiveControlModule()
        else
            self:Disable()
        end
    end

    -- For those who prefer distinct functions
    function ControlModule:Disable()
        if self.activeController then
            self.activeController:Enable(false)

            if self.moveFunction then
                self.moveFunction(Players.LocalPlayer, Vector3.new(0,0,0), true)
            end
        end
    end


    -- Returns module (possibly nil) and success code to differentiate returning nil due to error vs Scriptable
    function ControlModule:SelectComputerMovementModule()
        if not (UserInputService.KeyboardEnabled or UserInputService.GamepadEnabled) then
            return nil, false
        end

        local computerModule
        local DevMovementMode = Players.LocalPlayer.DevComputerMovementMode

        if DevMovementMode == Enum.DevComputerMovementMode.UserChoice then
            computerModule = computerInputTypeToModuleMap[lastInputType]
            if UserGameSettings.ComputerMovementMode == Enum.ComputerMovementMode.ClickToMove and computerModule == Keyboard then
                -- User has ClickToMove set in Settings, prefer ClickToMove controller for keyboard and mouse lastInputTypes
                computerModule = ClickToMove
            end
        else
            -- Developer has selected a mode that must be used.
            computerModule = movementEnumToModuleMap[DevMovementMode]

            -- computerModule is expected to be nil here only when developer has selected Scriptable
            if (not computerModule) and DevMovementMode ~= Enum.DevComputerMovementMode.Scriptable then
                warn("No character control module is associated with DevComputerMovementMode ", DevMovementMode)
            end
        end

        if computerModule then
            return computerModule, true
        elseif DevMovementMode == Enum.DevComputerMovementMode.Scriptable then
            -- Special case where nil is returned and we actually want to set self.activeController to nil for Scriptable
            return nil, true
        else
            -- This case is for when computerModule is nil because of an error and no suitable control module could
            -- be found.
            return nil, false
        end
    end

    -- Choose current Touch control module based on settings (user, dev)
    -- Returns module (possibly nil) and success code to differentiate returning nil due to error vs Scriptable
    function ControlModule:SelectTouchModule()
        if not UserInputService.TouchEnabled then
            return nil, false
        end
        local touchModule
        local DevMovementMode = Players.LocalPlayer.DevTouchMovementMode
        if DevMovementMode == Enum.DevTouchMovementMode.UserChoice then
            touchModule = movementEnumToModuleMap[UserGameSettings.TouchMovementMode]
        elseif DevMovementMode == Enum.DevTouchMovementMode.Scriptable then
            return nil, true
        else
            touchModule = movementEnumToModuleMap[DevMovementMode]
        end
        return touchModule, true
    end

    local function calculateRawMoveVector(humanoid, cameraRelativeMoveVector)
        local camera = Workspace.CurrentCamera
        if not camera then
            return cameraRelativeMoveVector
        end

        if humanoid:GetState() == Enum.HumanoidStateType.Swimming then
            return camera.CFrame:VectorToWorldSpace(cameraRelativeMoveVector)
        end

        local c, s
        local _, _, _, R00, R01, R02, _, _, R12, _, _, R22 = camera.CFrame:GetComponents()
        if R12 < 1 and R12 > -1 then
            -- X and Z components from back vector.
            c = R22
            s = R02
        else
            -- In this case the camera is looking straight up or straight down.
            -- Use X components from right and up vectors.
            c = R00
            s = -R01*math.sign(R12)
        end
        local norm = math.sqrt(c*c + s*s)
        return Vector3.new(
            (c*cameraRelativeMoveVector.x + s*cameraRelativeMoveVector.z)/norm,
            0,
            (c*cameraRelativeMoveVector.z - s*cameraRelativeMoveVector.x)/norm
        )
    end

    function ControlModule:OnRenderStepped(dt)
        if self.activeController and self.activeController.enabled and self.humanoid then
            -- Give the controller a chance to adjust its state
            self.activeController:OnRenderStepped(dt)

            -- Now retrieve info from the controller
            local moveVector = self.activeController:GetMoveVector()
            local cameraRelative = self.activeController:IsMoveVectorCameraRelative()

            local clickToMoveController = self:GetClickToMoveController()
            if self.activeController ~= clickToMoveController then
                if moveVector.magnitude > 0 then
                    -- Clean up any developer started MoveTo path
                    clickToMoveController:CleanupPath()
                else
                    -- Get move vector for developer started MoveTo
                    clickToMoveController:OnRenderStepped(dt)
                    moveVector = clickToMoveController:GetMoveVector()
                    cameraRelative = clickToMoveController:IsMoveVectorCameraRelative()
                end
            end

            -- Are we driving a vehicle ?
            local vehicleConsumedInput = false
            if self.vehicleController then
                moveVector, vehicleConsumedInput = self.vehicleController:Update(moveVector, cameraRelative, self.activeControlModule==Gamepad)
            end

            -- If not, move the player
            -- Verification of vehicleConsumedInput is commented out to preserve legacy behavior,
            -- in case some game relies on Humanoid.MoveDirection still being set while in a VehicleSeat
            --if not vehicleConsumedInput then
                if cameraRelative then
                    moveVector = calculateRawMoveVector(self.humanoid, moveVector)
                end
                self.moveFunction(Players.LocalPlayer, moveVector, false)
            --end

            -- And make them jump if needed
            self.humanoid.Jump = self.activeController:GetIsJumping() or (self.touchJumpController and self.touchJumpController:GetIsJumping())
        end
    end

    function ControlModule:OnHumanoidSeated(active, currentSeatPart)
        if active then
            if currentSeatPart and currentSeatPart:IsA("VehicleSeat") then
                if not self.vehicleController then
                    self.vehicleController = self.vehicleController.new(CONTROL_ACTION_PRIORITY)
                end
                self.vehicleController:Enable(true, currentSeatPart)
            end
        else
            if self.vehicleController then
                self.vehicleController:Enable(false, currentSeatPart)
            end
        end
    end

    function ControlModule:OnCharacterAdded(char)
        self.humanoid = char:FindFirstChildOfClass("Humanoid")
        while not self.humanoid do
            char.ChildAdded:wait()
            self.humanoid = char:FindFirstChildOfClass("Humanoid")
        end

        if self.touchGui then
            self.touchGui.Enabled = true
        end

        if self.humanoidSeatedConn then
            self.humanoidSeatedConn:Disconnect()
            self.humanoidSeatedConn = nil
        end
        self.humanoidSeatedConn = self.humanoid.Seated:Connect(function(active, currentSeatPart)
            self:OnHumanoidSeated(active, currentSeatPart)
        end)
    end

    function ControlModule:OnCharacterRemoving(char)
        self.humanoid = nil

        if self.touchGui then
            self.touchGui.Enabled = false
        end
    end

    -- Helper function to lazily instantiate a controller if it does not yet exist,
    -- disable the active controller if it is different from the on being switched to,
    -- and then enable the requested controller. The argument to this function must be
    -- a reference to one of the control modules, i.e. Keyboard, Gamepad, etc.
    function ControlModule:SwitchToController(controlModule)
        if not controlModule then
            if self.activeController then
                self.activeController:Enable(false)
            end
            self.activeController = nil
            self.activeControlModule = nil
        else
            if not self.controllers[controlModule] then
                self.controllers[controlModule] = controlModule.new(CONTROL_ACTION_PRIORITY)
            end

            if self.activeController ~= self.controllers[controlModule] then
                if self.activeController then
                    self.activeController:Enable(false)
                end
                self.activeController = self.controllers[controlModule]
                self.activeControlModule = controlModule -- Only used to check if controller switch is necessary

                if self.touchControlFrame and (self.activeControlModule == ClickToMove
                            or self.activeControlModule == TouchThumbstick
                            or self.activeControlModule == DynamicThumbstick) then
                    if not self.controllers[TouchJump] then
                        self.controllers[TouchJump] = TouchJump.new()
                    end
                    self.touchJumpController = self.controllers[TouchJump]
                    self.touchJumpController:Enable(true, self.touchControlFrame)
                else
                    if self.touchJumpController then
                        self.touchJumpController:Enable(false)
                    end
                end

                self:EnableActiveControlModule()
            end
        end
    end

    function ControlModule:OnLastInputTypeChanged(newLastInputType)
        if lastInputType == newLastInputType then
            warn("LastInputType Change listener called with current type.")
        end
        lastInputType = newLastInputType

        if lastInputType == Enum.UserInputType.Touch then
            -- TODO: Check if touch module already active
            local touchModule, success = self:SelectTouchModule()
            if success then
                while not self.touchControlFrame do
                    wait()
                end
                self:SwitchToController(touchModule)
            end
        elseif computerInputTypeToModuleMap[lastInputType] ~= nil then
            local computerModule = self:SelectComputerMovementModule()
            if computerModule then
                self:SwitchToController(computerModule)
            end
        end
    end

    -- Called when any relevant values of GameSettings or LocalPlayer change, forcing re-evalulation of
    -- current control scheme
    function ControlModule:OnComputerMovementModeChange()
        local controlModule, success =  self:SelectComputerMovementModule()
        if success then
            self:SwitchToController(controlModule)
        end
    end

    function ControlModule:OnTouchMovementModeChange()
        local touchModule, success = self:SelectTouchModule()
        if success then
            while not self.touchControlFrame do
                wait()
            end
            self:SwitchToController(touchModule)
        end
    end

    function ControlModule:CreateTouchGuiContainer()
        if self.touchGui then self.touchGui:Destroy() end

        -- Container for all touch device guis
        self.touchGui = Instance.new("ScreenGui")
        self.touchGui.Name = "TouchGui"
        self.touchGui.ResetOnSpawn = false
        self.touchGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
        self.touchGui.Enabled = self.humanoid ~= nil

        self.touchControlFrame = Instance.new("Frame")
        self.touchControlFrame.Name = "TouchControlFrame"
        self.touchControlFrame.Size = UDim2.new(1, 0, 1, 0)
        self.touchControlFrame.BackgroundTransparency = 1
        self.touchControlFrame.Parent = self.touchGui

        self.touchGui.Parent = self.playerGui
    end

    function ControlModule:GetClickToMoveController()
        if not self.controllers[ClickToMove] then
            self.controllers[ClickToMove] = ClickToMove.new(CONTROL_ACTION_PRIORITY)
        end
        return self.controllers[ClickToMove]
    end

    function ControlModule:IsJumping()
        if self.activeController then
            return self.activeController:GetIsJumping() or (self.touchJumpController and self.touchJumpController:GetIsJumping())
        end
        return false
    end

    return ControlModule.new()
end

function _PlayerModule()
    local PlayerModule = {}
    PlayerModule.__index = PlayerModule
    function PlayerModule.new()
        local self = setmetatable({},PlayerModule)
        self.cameras = _CameraModule()
        self.controls = _ControlModule()
        return self
    end
    function PlayerModule:GetCameras()
        return self.cameras
    end
    function PlayerModule:GetControls()
        return self.controls
    end
    function PlayerModule:GetClickToMoveController()
        return self.controls:GetClickToMoveController()
    end
    return PlayerModule.new()
end

function _sounds()

    local SetState = Instance.new("BindableEvent",script)

    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")

    local SOUND_DATA = {
        Climbing = {
            SoundId = "rbxasset://sounds/action_footsteps_plastic.mp3",
            Looped = true,
        },
        Died = {
            SoundId = "rbxasset://sounds/uuhhh.mp3",
        },
        FreeFalling = {
            SoundId = "rbxasset://sounds/action_falling.mp3",
            Looped = true,
        },
        GettingUp = {
            SoundId = "rbxasset://sounds/action_get_up.mp3",
        },
        Jumping = {
            SoundId = "rbxasset://sounds/action_jump.mp3",
        },
        Landing = {
            SoundId = "rbxasset://sounds/action_jump_land.mp3",
        },
        Running = {
            SoundId = "rbxasset://sounds/action_footsteps_plastic.mp3",
            Looped = true,
            Pitch = 1.85,
        },
        Splash = {
            SoundId = "rbxasset://sounds/impact_water.mp3",
        },
        Swimming = {
            SoundId = "rbxasset://sounds/action_swim.mp3",
            Looped = true,
            Pitch = 1.6,
        },
    }

     -- wait for the first of the passed signals to fire
    local function waitForFirst(...)
        local shunt = Instance.new("BindableEvent")
        local slots = {...}

        local function fire(...)
            for i = 1, #slots do
                slots[i]:Disconnect()
            end

            return shunt:Fire(...)
        end

        for i = 1, #slots do
            slots[i] = slots[i]:Connect(fire)
        end

        return shunt.Event:Wait()
    end

    -- map a value from one range to another
    local function map(x, inMin, inMax, outMin, outMax)
        return (x - inMin)*(outMax - outMin)/(inMax - inMin) + outMin
    end

    local function playSound(sound)
        sound.TimePosition = 0
        sound.Playing = true
    end

    local function stopSound(sound)
        sound.Playing = false
        sound.TimePosition = 0
    end

    local function shallowCopy(t)
        local out = {}
        for k, v in pairs(t) do
            out[k] = v
        end
        return out
    end

    local function initializeSoundSystem(player, humanoid, rootPart)
        local sounds = {}

        -- initialize sounds
        for name, props in pairs(SOUND_DATA) do
            local sound = Instance.new("Sound")
            sound.Name = name

            -- set default values
            sound.Archivable = false
            sound.EmitterSize = 5
            sound.MaxDistance = 150
            sound.Volume = 0.65

            for propName, propValue in pairs(props) do
                sound[propName] = propValue
            end

            sound.Parent = rootPart
            sounds[name] = sound
        end

        local playingLoopedSounds = {}

        local function stopPlayingLoopedSounds(except)
            for sound in pairs(shallowCopy(playingLoopedSounds)) do
                if sound ~= except then
                    sound.Playing = false
                    playingLoopedSounds[sound] = nil
                end
            end
        end

        -- state transition callbacks
        local stateTransitions = {
            [Enum.HumanoidStateType.FallingDown] = function()
                stopPlayingLoopedSounds()
            end,

            [Enum.HumanoidStateType.GettingUp] = function()
                stopPlayingLoopedSounds()
                playSound(sounds.GettingUp)
            end,

            [Enum.HumanoidStateType.Jumping] = function()
                stopPlayingLoopedSounds()
                playSound(sounds.Jumping)
            end,

            [Enum.HumanoidStateType.Swimming] = function()
                local verticalSpeed = math.abs(rootPart.Velocity.Y)
                if verticalSpeed > 0.1 then
                    sounds.Splash.Volume = math.clamp(map(verticalSpeed, 100, 350, 0.28, 1), 0, 1)
                    playSound(sounds.Splash)
                end
                stopPlayingLoopedSounds(sounds.Swimming)
                sounds.Swimming.Playing = true
                playingLoopedSounds[sounds.Swimming] = true
            end,

            [Enum.HumanoidStateType.Freefall] = function()
                sounds.FreeFalling.Volume = 0
                stopPlayingLoopedSounds(sounds.FreeFalling)
                playingLoopedSounds[sounds.FreeFalling] = true
            end,

            [Enum.HumanoidStateType.Landed] = function()
                stopPlayingLoopedSounds()
                local verticalSpeed = math.abs(rootPart.Velocity.Y)
                if verticalSpeed > 75 then
                    sounds.Landing.Volume = math.clamp(map(verticalSpeed, 50, 100, 0, 1), 0, 1)
                    playSound(sounds.Landing)
                end
            end,

            [Enum.HumanoidStateType.Running] = function()
                stopPlayingLoopedSounds(sounds.Running)
                sounds.Running.Playing = true
                playingLoopedSounds[sounds.Running] = true
            end,

            [Enum.HumanoidStateType.Climbing] = function()
                local sound = sounds.Climbing
                if math.abs(rootPart.Velocity.Y) > 0.1 then
                    sound.Playing = true
                    stopPlayingLoopedSounds(sound)
                else
                    stopPlayingLoopedSounds()
                end
                playingLoopedSounds[sound] = true
            end,

            [Enum.HumanoidStateType.Seated] = function()
                stopPlayingLoopedSounds()
            end,

            [Enum.HumanoidStateType.Dead] = function()
                stopPlayingLoopedSounds()
                playSound(sounds.Died)
            end,
        }

        -- updaters for looped sounds
        local loopedSoundUpdaters = {
            [sounds.Climbing] = function(dt, sound, vel)
                sound.Playing = vel.Magnitude > 0.1
            end,

            [sounds.FreeFalling] = function(dt, sound, vel)
                if vel.Magnitude > 75 then
                    sound.Volume = math.clamp(sound.Volume + 0.9*dt, 0, 1)
                else
                    sound.Volume = 0
                end
            end,

            [sounds.Running] = function(dt, sound, vel)
                sound.Playing = vel.Magnitude > 0.5 and humanoid.MoveDirection.Magnitude > 0.5
            end,
        }

        -- state substitutions to avoid duplicating entries in the state table
        local stateRemap = {
            [Enum.HumanoidStateType.RunningNoPhysics] = Enum.HumanoidStateType.Running,
        }

        local activeState = stateRemap[humanoid:GetState()] or humanoid:GetState()
        local activeConnections = {}

        local stateChangedConn = humanoid.StateChanged:Connect(function(_, state)
            state = stateRemap[state] or state

            if state ~= activeState then
                local transitionFunc = stateTransitions[state]

                if transitionFunc then
                    transitionFunc()
                end

                activeState = state
            end
        end)

        local customStateChangedConn = SetState.Event:Connect(function(state)
            state = stateRemap[state] or state

            if state ~= activeState then
                local transitionFunc = stateTransitions[state]

                if transitionFunc then
                    transitionFunc()
                end

                activeState = state
            end
        end)

        local steppedConn = RunService.Stepped:Connect(function(_, worldDt)
            -- update looped sounds on stepped
            for sound in pairs(playingLoopedSounds) do
                local updater = loopedSoundUpdaters[sound]

                if updater then
                    updater(worldDt, sound, rootPart.Velocity)
                end
            end
        end)

        local humanoidAncestryChangedConn
        local rootPartAncestryChangedConn
        local characterAddedConn

        local function terminate()
            stateChangedConn:Disconnect()
            customStateChangedConn:Disconnect()
            steppedConn:Disconnect()
            humanoidAncestryChangedConn:Disconnect()
            rootPartAncestryChangedConn:Disconnect()
            characterAddedConn:Disconnect()
        end

        humanoidAncestryChangedConn = humanoid.AncestryChanged:Connect(function(_, parent)
            if not parent then
                terminate()
            end
        end)

        rootPartAncestryChangedConn = rootPart.AncestryChanged:Connect(function(_, parent)
            if not parent then
                terminate()
            end
        end)

        characterAddedConn = player.CharacterAdded:Connect(terminate)
    end

    local function playerAdded(player)
        local function characterAdded(character)
            -- Avoiding memory leaks in the face of Character/Humanoid/RootPart lifetime has a few complications:
            -- * character deparenting is a Remove instead of a Destroy, so signals are not cleaned up automatically.
            -- ** must use a waitForFirst on everything and listen for hierarchy changes.
            -- * the character might not be in the dm by the time CharacterAdded fires
            -- ** constantly check consistency with player.Character and abort if CharacterAdded is fired again
            -- * Humanoid may not exist immediately, and by the time it's inserted the character might be deparented.
            -- * RootPart probably won't exist immediately.
            -- ** by the time RootPart is inserted and Humanoid.RootPart is set, the character or the humanoid might be deparented.

            if not character.Parent then
                waitForFirst(character.AncestryChanged, player.CharacterAdded)
            end

            if player.Character ~= character or not character.Parent then
                return
            end

            local humanoid = character:FindFirstChildOfClass("Humanoid")
            while character:IsDescendantOf(game) and not humanoid do
                waitForFirst(character.ChildAdded, character.AncestryChanged, player.CharacterAdded)
                humanoid = character:FindFirstChildOfClass("Humanoid")
            end

            if player.Character ~= character or not character:IsDescendantOf(game) then
                return
            end

            -- must rely on HumanoidRootPart naming because Humanoid.RootPart does not fire changed signals
            local rootPart = character:FindFirstChild("HumanoidRootPart")
            while character:IsDescendantOf(game) and not rootPart do
                waitForFirst(character.ChildAdded, character.AncestryChanged, humanoid.AncestryChanged, player.CharacterAdded)
                rootPart = character:FindFirstChild("HumanoidRootPart")
            end

            if rootPart and humanoid:IsDescendantOf(game) and character:IsDescendantOf(game) and player.Character == character then
                initializeSoundSystem(player, humanoid, rootPart)
            end
        end

        if player.Character then
            characterAdded(player.Character)
        end
        player.CharacterAdded:Connect(characterAdded)
    end

    Players.PlayerAdded:Connect(playerAdded)
    for _, player in ipairs(Players:GetPlayers()) do
        playerAdded(player)
    end
    return SetState
end

function _StateTracker()
    local EPSILON = 0.1

    local SPEED = {
        ["onRunning"] = true,
        ["onClimbing"] = true
    }

    local INAIR = {
        ["onFreeFall"] = true,
        ["onJumping"] = true
    }

    local STATEMAP = {
        ["onRunning"] = Enum.HumanoidStateType.Running,
        ["onJumping"] = Enum.HumanoidStateType.Jumping,
        ["onFreeFall"] = Enum.HumanoidStateType.Freefall
    }

    local StateTracker = {}
    StateTracker.__index = StateTracker

    function StateTracker.new(humanoid, soundState)
        local self = setmetatable({}, StateTracker)

        self.Humanoid = humanoid
        self.HRP = humanoid.RootPart

        self.Speed = 0
        self.State = "onRunning"
        self.Jumped = false
        self.JumpTick = tick()

        self.SoundState = soundState

        self._ChangedEvent = Instance.new("BindableEvent")
        self.Changed = self._ChangedEvent.Event

        return self
    end

    function StateTracker:Destroy()
        self._ChangedEvent:Destroy()
    end

    function StateTracker:RequestedJump()
        self.Jumped = true
        self.JumpTick = tick()
    end

    function StateTracker:OnStep(gravityUp, grounded, isMoving)
        local cVelocity = self.HRP.Velocity
        local gVelocity = cVelocity:Dot(gravityUp)

        local oldState, oldSpeed = self.State, self.Speed

        local newState
        local newSpeed = cVelocity.Magnitude

        if (not grounded) then
            if (gVelocity > 0) then
                if (self.Jumped) then
                    newState = "onJumping"
                else
                    newState = "onFreeFall"
                end
            else
                if (self.Jumped) then
                    self.Jumped = false
                end
                newState = "onFreeFall"
            end
        else
            if (self.Jumped and tick() - self.JumpTick > 0.1) then
                self.Jumped = false
            end
            newSpeed = (cVelocity - gVelocity*gravityUp).Magnitude
            newState = "onRunning"
        end

        newSpeed = isMoving and newSpeed or 0

        if (oldState ~= newState or (SPEED[newState] and math.abs(oldSpeed - newSpeed) > EPSILON)) then
            self.State = newState
            self.Speed = newSpeed
            self.SoundState:Fire(STATEMAP[newState])
            self._ChangedEvent:Fire(self.State, self.Speed)
        end
    end

    return StateTracker
end
function _InitObjects()
    local model = workspace:FindFirstChild("objects") or game:GetObjects("rbxassetid://5045408489")[1]
    local SPHERE = model:WaitForChild("Sphere")
    local FLOOR = model:WaitForChild("Floor")
    local VFORCE = model:WaitForChild("VectorForce")
    local BGYRO = model:WaitForChild("BodyGyro")
    local function initObjects(self)
        local hrp = self.HRP
        local humanoid = self.Humanoid
        local sphere = SPHERE:Clone()
        sphere.Parent = self.Character
        local floor = FLOOR:Clone()
        floor.Parent = self.Character
        local isR15 = (humanoid.RigType == Enum.HumanoidRigType.R15)
        local height = isR15 and (humanoid.HipHeight + 0.05) or 2
        local weld = Instance.new("Weld")
        weld.C0 = CFrame.new(0, -height, 0.1)
        weld.Part0 = hrp
        weld.Part1 = sphere
        weld.Parent = sphere
        local weld2 = Instance.new("Weld")
        weld2.C0 = CFrame.new(0, -(height + 1.5), 0)
        weld2.Part0 = hrp
        weld2.Part1 = floor
        weld2.Parent = floor
        local gyro = BGYRO:Clone()
        gyro.CFrame = hrp.CFrame
        gyro.Parent = hrp
        local vForce = VFORCE:Clone()
        vForce.Attachment0 = isR15 and hrp:WaitForChild("RootRigAttachment") or hrp:WaitForChild("RootAttachment")
        vForce.Parent = hrp
        return sphere, gyro, vForce, floor
    end
    return initObjects
end
local plr = game.Players.LocalPlayer
local ms = plr:GetMouse()
local char
plr.CharacterAdded:Connect(function(c)
    char = c
end)
function _R6()
    function r6()
    local Figure = char
    local Torso = Figure:WaitForChild("Torso")
    local RightShoulder = Torso:WaitForChild("Right Shoulder")
    local LeftShoulder = Torso:WaitForChild("Left Shoulder")
    local RightHip = Torso:WaitForChild("Right Hip")
    local LeftHip = Torso:WaitForChild("Left Hip")
    local Neck = Torso:WaitForChild("Neck")
    local Humanoid = Figure:WaitForChild("Humanoid")
    local pose = "Standing"
    local currentAnim = ""
    local currentAnimInstance = nil
    local currentAnimTrack = nil
    local currentAnimKeyframeHandler = nil
    local currentAnimSpeed = 1.0
    local animTable = {}
    local animNames = {
        idle =  {
                    { id = "http://www.roblox.com/asset/?id=180435571", weight = 9 },
                    { id = "http://www.roblox.com/asset/?id=180435792", weight = 1 }
                },
        walk =  {
                    { id = "http://www.roblox.com/asset/?id=180426354", weight = 10 }
                },
        run =   {
                    { id = "run.xml", weight = 10 }
                },
        jump =  {
                    { id = "http://www.roblox.com/asset/?id=125750702", weight = 10 }
                },
        fall =  {
                    { id = "http://www.roblox.com/asset/?id=180436148", weight = 10 }
                },
        climb = {
                    { id = "http://www.roblox.com/asset/?id=180436334", weight = 10 }
                },
        sit =   {
                    { id = "http://www.roblox.com/asset/?id=178130996", weight = 10 }
                },
        toolnone = {
                    { id = "http://www.roblox.com/asset/?id=182393478", weight = 10 }
                },
        toolslash = {
                    { id = "http://www.roblox.com/asset/?id=129967390", weight = 10 }
    --              { id = "slash.xml", weight = 10 }
                },
        toollunge = {
                    { id = "http://www.roblox.com/asset/?id=129967478", weight = 10 }
                },
        wave = {
                    { id = "http://www.roblox.com/asset/?id=128777973", weight = 10 }
                },
        point = {
                    { id = "http://www.roblox.com/asset/?id=128853357", weight = 10 }
                },
        dance1 = {
                    { id = "http://www.roblox.com/asset/?id=182435998", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=182491037", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=182491065", weight = 10 }
                },
        dance2 = {
                    { id = "http://www.roblox.com/asset/?id=182436842", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=182491248", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=182491277", weight = 10 }
                },
        dance3 = {
                    { id = "http://www.roblox.com/asset/?id=182436935", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=182491368", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=182491423", weight = 10 }
                },
        laugh = {
                    { id = "http://www.roblox.com/asset/?id=129423131", weight = 10 }
                },
        cheer = {
                    { id = "http://www.roblox.com/asset/?id=129423030", weight = 10 }
                },
    }
    local dances = {"dance1", "dance2", "dance3"}
    -- Existance in this list signifies that it is an emote, the value indicates if it is a looping emote
    local emoteNames = { wave = false, point = false, dance1 = true, dance2 = true, dance3 = true, laugh = false, cheer = false}
    function configureAnimationSet(name, fileList)
        if (animTable[name] ~= nil) then
            for _, connection in pairs(animTable[name].connections) do
                connection:disconnect()
            end
        end
        animTable[name] = {}
        animTable[name].count = 0
        animTable[name].totalWeight = 0
        animTable[name].connections = {}
        -- check for config values
        local config = script:FindFirstChild(name)
        if (config ~= nil) then
    --      print("Loading anims " .. name)
            table.insert(animTable[name].connections, config.ChildAdded:connect(function(child) configureAnimationSet(name, fileList) end))
            table.insert(animTable[name].connections, config.ChildRemoved:connect(function(child) configureAnimationSet(name, fileList) end))
            local idx = 1
            for _, childPart in pairs(config:GetChildren()) do
                if (childPart:IsA("Animation")) then
                    table.insert(animTable[name].connections, childPart.Changed:connect(function(property) configureAnimationSet(name, fileList) end))
                    animTable[name][idx] = {}
                    animTable[name][idx].anim = childPart
                    local weightObject = childPart:FindFirstChild("Weight")
                    if (weightObject == nil) then
                        animTable[name][idx].weight = 1
                    else
                        animTable[name][idx].weight = weightObject.Value
                    end
                    animTable[name].count = animTable[name].count + 1
                    animTable[name].totalWeight = animTable[name].totalWeight + animTable[name][idx].weight
        --          print(name .. " [" .. idx .. "] " .. animTable[name][idx].anim.AnimationId .. " (" .. animTable[name][idx].weight .. ")")
                    idx = idx + 1
                end
            end
        end
        -- fallback to defaults
        if (animTable[name].count <= 0) then
            for idx, anim in pairs(fileList) do
                animTable[name][idx] = {}
                animTable[name][idx].anim = Instance.new("Animation")
                animTable[name][idx].anim.Name = name
                animTable[name][idx].anim.AnimationId = anim.id
                animTable[name][idx].weight = anim.weight
                animTable[name].count = animTable[name].count + 1
                animTable[name].totalWeight = animTable[name].totalWeight + anim.weight
    --          print(name .. " [" .. idx .. "] " .. anim.id .. " (" .. anim.weight .. ")")
            end
        end
    end
    -- Setup animation objects
    function scriptChildModified(child)
        local fileList = animNames[child.Name]
        if (fileList ~= nil) then
            configureAnimationSet(child.Name, fileList)
        end
    end

    script.ChildAdded:connect(scriptChildModified)
    script.ChildRemoved:connect(scriptChildModified)


    for name, fileList in pairs(animNames) do
        configureAnimationSet(name, fileList)
    end

    -- ANIMATION

    -- declarations
    local toolAnim = "None"
    local toolAnimTime = 0

    local jumpAnimTime = 0
    local jumpAnimDuration = 0.3

    local toolTransitionTime = 0.1
    local fallTransitionTime = 0.3
    local jumpMaxLimbVelocity = 0.75

    -- functions

    function stopAllAnimations()
        local oldAnim = currentAnim

        -- return to idle if finishing an emote
        if (emoteNames[oldAnim] ~= nil and emoteNames[oldAnim] == false) then
            oldAnim = "idle"
        end

        currentAnim = ""
        currentAnimInstance = nil
        if (currentAnimKeyframeHandler ~= nil) then
            currentAnimKeyframeHandler:disconnect()
        end

        if (currentAnimTrack ~= nil) then
            currentAnimTrack:Stop()
            currentAnimTrack:Destroy()
            currentAnimTrack = nil
        end
        return oldAnim
    end

    function setAnimationSpeed(speed)
        if speed ~= currentAnimSpeed then
            currentAnimSpeed = speed
            currentAnimTrack:AdjustSpeed(currentAnimSpeed)
        end
    end

    function keyFrameReachedFunc(frameName)
        if (frameName == "End") then

            local repeatAnim = currentAnim
            -- return to idle if finishing an emote
            if (emoteNames[repeatAnim] ~= nil and emoteNames[repeatAnim] == false) then
                repeatAnim = "idle"
            end

            local animSpeed = currentAnimSpeed
            playAnimation(repeatAnim, 0.0, Humanoid)
            setAnimationSpeed(animSpeed)
        end
    end

    -- Preload animations
    function playAnimation(animName, transitionTime, humanoid)

        local roll = math.random(1, animTable[animName].totalWeight)
        local origRoll = roll
        local idx = 1
        while (roll > animTable[animName][idx].weight) do
            roll = roll - animTable[animName][idx].weight
            idx = idx + 1
        end
    --      print(animName .. " " .. idx .. " [" .. origRoll .. "]")
        local anim = animTable[animName][idx].anim

        -- switch animation
        if (anim ~= currentAnimInstance) then

            if (currentAnimTrack ~= nil) then
                currentAnimTrack:Stop(transitionTime)
                currentAnimTrack:Destroy()
            end

            currentAnimSpeed = 1.0

            -- load it to the humanoid; get AnimationTrack
            currentAnimTrack = humanoid:LoadAnimation(anim)
            currentAnimTrack.Priority = Enum.AnimationPriority.Core

            -- play the animation
            currentAnimTrack:Play(transitionTime)
            currentAnim = animName
            currentAnimInstance = anim

            -- set up keyframe name triggers
            if (currentAnimKeyframeHandler ~= nil) then
                currentAnimKeyframeHandler:disconnect()
            end
            currentAnimKeyframeHandler = currentAnimTrack.KeyframeReached:connect(keyFrameReachedFunc)

        end

    end

    -------------------------------------------------------------------------------------------
    -------------------------------------------------------------------------------------------

    local toolAnimName = ""
    local toolAnimTrack = nil
    local toolAnimInstance = nil
    local currentToolAnimKeyframeHandler = nil

    function toolKeyFrameReachedFunc(frameName)
        if (frameName == "End") then
    --      print("Keyframe : ".. frameName)
            playToolAnimation(toolAnimName, 0.0, Humanoid)
        end
    end


    function playToolAnimation(animName, transitionTime, humanoid, priority)

            local roll = math.random(1, animTable[animName].totalWeight)
            local origRoll = roll
            local idx = 1
            while (roll > animTable[animName][idx].weight) do
                roll = roll - animTable[animName][idx].weight
                idx = idx + 1
            end
    --      print(animName .. " * " .. idx .. " [" .. origRoll .. "]")
            local anim = animTable[animName][idx].anim

            if (toolAnimInstance ~= anim) then

                if (toolAnimTrack ~= nil) then
                    toolAnimTrack:Stop()
                    toolAnimTrack:Destroy()
                    transitionTime = 0
                end

                -- load it to the humanoid; get AnimationTrack
                toolAnimTrack = humanoid:LoadAnimation(anim)
                if priority then
                    toolAnimTrack.Priority = priority
                end

                -- play the animation
                toolAnimTrack:Play(transitionTime)
                toolAnimName = animName
                toolAnimInstance = anim

                currentToolAnimKeyframeHandler = toolAnimTrack.KeyframeReached:connect(toolKeyFrameReachedFunc)
            end
    end

    function stopToolAnimations()
        local oldAnim = toolAnimName

        if (currentToolAnimKeyframeHandler ~= nil) then
            currentToolAnimKeyframeHandler:disconnect()
        end

        toolAnimName = ""
        toolAnimInstance = nil
        if (toolAnimTrack ~= nil) then
            toolAnimTrack:Stop()
            toolAnimTrack:Destroy()
            toolAnimTrack = nil
        end


        return oldAnim
    end

    -------------------------------------------------------------------------------------------
    -------------------------------------------------------------------------------------------


    function onRunning(speed)
        if speed > 0.01 then
            playAnimation("walk", 0.1, Humanoid)
            if currentAnimInstance and currentAnimInstance.AnimationId == "http://www.roblox.com/asset/?id=180426354" then
                setAnimationSpeed(speed / 14.5)
            end
            pose = "Running"
        else
            if emoteNames[currentAnim] == nil then
                playAnimation("idle", 0.1, Humanoid)
                pose = "Standing"
            end
        end
    end

    function onDied()
        pose = "Dead"
    end

    function onJumping()
        playAnimation("jump", 0.1, Humanoid)
        jumpAnimTime = jumpAnimDuration
        pose = "Jumping"
    end

    function onClimbing(speed)
        playAnimation("climb", 0.1, Humanoid)
        setAnimationSpeed(speed / 12.0)
        pose = "Climbing"
    end

    function onGettingUp()
        pose = "GettingUp"
    end

    function onFreeFall()
        if (jumpAnimTime <= 0) then
            playAnimation("fall", fallTransitionTime, Humanoid)
        end
        pose = "FreeFall"
    end

    function onFallingDown()
        pose = "FallingDown"
    end

    function onSeated()
        pose = "Seated"
    end

    function onPlatformStanding()
        pose = "PlatformStanding"
    end

    function onSwimming(speed)
        if speed > 0 then
            pose = "Running"
        else
            pose = "Standing"
        end
    end

    function getTool()
        for _, kid in ipairs(Figure:GetChildren()) do
            if kid.className == "Tool" then return kid end
        end
        return nil
    end

    function getToolAnim(tool)
        for _, c in ipairs(tool:GetChildren()) do
            if c.Name == "toolanim" and c.className == "StringValue" then
                return c
            end
        end
        return nil
    end

    function animateTool()

        if (toolAnim == "None") then
            playToolAnimation("toolnone", toolTransitionTime, Humanoid, Enum.AnimationPriority.Idle)
            return
        end

        if (toolAnim == "Slash") then
            playToolAnimation("toolslash", 0, Humanoid, Enum.AnimationPriority.Action)
            return
        end

        if (toolAnim == "Lunge") then
            playToolAnimation("toollunge", 0, Humanoid, Enum.AnimationPriority.Action)
            return
        end
    end

    function moveSit()
        RightShoulder.MaxVelocity = 0.15
        LeftShoulder.MaxVelocity = 0.15
        RightShoulder:SetDesiredAngle(3.14 /2)
        LeftShoulder:SetDesiredAngle(-3.14 /2)
        RightHip:SetDesiredAngle(3.14 /2)
        LeftHip:SetDesiredAngle(-3.14 /2)
    end

    local lastTick = 0

    function move(time)
        local amplitude = 1
        local frequency = 1
        local deltaTime = time - lastTick
        lastTick = time

        local climbFudge = 0
        local setAngles = false

        if (jumpAnimTime > 0) then
            jumpAnimTime = jumpAnimTime - deltaTime
        end

        if (pose == "FreeFall" and jumpAnimTime <= 0) then
            playAnimation("fall", fallTransitionTime, Humanoid)
        elseif (pose == "Seated") then
            playAnimation("sit", 0.5, Humanoid)
            return
        elseif (pose == "Running") then
            playAnimation("walk", 0.1, Humanoid)
        elseif (pose == "Dead" or pose == "GettingUp" or pose == "FallingDown" or pose == "Seated" or pose == "PlatformStanding") then
    --      print("Wha " .. pose)
            stopAllAnimations()
            amplitude = 0.1
            frequency = 1
            setAngles = true
        end

        if (setAngles) then
            local desiredAngle = amplitude * math.sin(time * frequency)

            RightShoulder:SetDesiredAngle(desiredAngle + climbFudge)
            LeftShoulder:SetDesiredAngle(desiredAngle - climbFudge)
            RightHip:SetDesiredAngle(-desiredAngle)
            LeftHip:SetDesiredAngle(-desiredAngle)
        end

        -- Tool Animation handling
        local tool = getTool()
        if tool and tool:FindFirstChild("Handle") then

            local animStringValueObject = getToolAnim(tool)

            if animStringValueObject then
                toolAnim = animStringValueObject.Value
                -- message recieved, delete StringValue
                animStringValueObject.Parent = nil
                toolAnimTime = time + .3
            end

            if time > toolAnimTime then
                toolAnimTime = 0
                toolAnim = "None"
            end

            animateTool()
        else
            stopToolAnimations()
            toolAnim = "None"
            toolAnimInstance = nil
            toolAnimTime = 0
        end
    end


    local events = {}
    local eventHum = Humanoid

    local function onUnhook()
        for i = 1, #events do
            events[i]:Disconnect()
        end
        events = {}
    end

    local function onHook()
        onUnhook()

        pose = eventHum.Sit and "Seated" or "Standing"

        events = {
            eventHum.Died:connect(onDied),
            eventHum.Running:connect(onRunning),
            eventHum.Jumping:connect(onJumping),
            eventHum.Climbing:connect(onClimbing),
            eventHum.GettingUp:connect(onGettingUp),
            eventHum.FreeFalling:connect(onFreeFall),
            eventHum.FallingDown:connect(onFallingDown),
            eventHum.Seated:connect(onSeated),
            eventHum.PlatformStanding:connect(onPlatformStanding),
            eventHum.Swimming:connect(onSwimming)
        }
    end


    onHook()

    -- setup emote chat hook
    game:GetService("Players").LocalPlayer.Chatted:connect(function(msg)
        local emote = ""
        if msg == "/e dance" then
            emote = dances[math.random(1, #dances)]
        elseif (string.sub(msg, 1, 3) == "/e ") then
            emote = string.sub(msg, 4)
        elseif (string.sub(msg, 1, 7) == "/emote ") then
            emote = string.sub(msg, 8)
        end

        if (pose == "Standing" and emoteNames[emote] ~= nil) then
            playAnimation(emote, 0.1, Humanoid)
        end

    end)


    -- main program

    -- initialize to idle
    playAnimation("idle", 0.1, Humanoid)
    pose = "Standing"

    spawn(function()
        while Figure.Parent ~= nil do
            local _, time = wait(0.1)
            move(time)
        end
    end)

    return {
        onRunning = onRunning,
        onDied = onDied,
        onJumping = onJumping,
        onClimbing = onClimbing,
        onGettingUp = onGettingUp,
        onFreeFall = onFreeFall,
        onFallingDown = onFallingDown,
        onSeated = onSeated,
        onPlatformStanding = onPlatformStanding,
        onHook = onHook,
        onUnhook = onUnhook
    }

    end
    return r6()
end

function _R15()
    local function r15()

    local Character = char
    local Humanoid = Character:WaitForChild("Humanoid")
    local pose = "Standing"

    local userNoUpdateOnLoopSuccess, userNoUpdateOnLoopValue = pcall(function() return UserSettings():IsUserFeatureEnabled("UserNoUpdateOnLoop") end)
    local userNoUpdateOnLoop = userNoUpdateOnLoopSuccess and userNoUpdateOnLoopValue
    local userAnimationSpeedDampeningSuccess, userAnimationSpeedDampeningValue = pcall(function() return UserSettings():IsUserFeatureEnabled("UserAnimationSpeedDampening") end)
    local userAnimationSpeedDampening = userAnimationSpeedDampeningSuccess and userAnimationSpeedDampeningValue

    local animateScriptEmoteHookFlagExists, animateScriptEmoteHookFlagEnabled = pcall(function()
        return UserSettings():IsUserFeatureEnabled("UserAnimateScriptEmoteHook")
    end)
    local FFlagAnimateScriptEmoteHook = animateScriptEmoteHookFlagExists and animateScriptEmoteHookFlagEnabled

    local AnimationSpeedDampeningObject = script:FindFirstChild("ScaleDampeningPercent")
    local HumanoidHipHeight = 2

    local EMOTE_TRANSITION_TIME = 0.1

    local currentAnim = ""
    local currentAnimInstance = nil
    local currentAnimTrack = nil
    local currentAnimKeyframeHandler = nil
    local currentAnimSpeed = 1.0

    local runAnimTrack = nil
    local runAnimKeyframeHandler = nil

    local animTable = {}
    local animNames = {
        idle =  {
                    { id = "http://www.roblox.com/asset/?id=507766666", weight = 1 },
                    { id = "http://www.roblox.com/asset/?id=507766951", weight = 1 },
                    { id = "http://www.roblox.com/asset/?id=507766388", weight = 9 }
                },
        walk =  {
                    { id = "http://www.roblox.com/asset/?id=507777826", weight = 10 }
                },
        run =   {
                    { id = "http://www.roblox.com/asset/?id=507767714", weight = 10 }
                },
        swim =  {
                    { id = "http://www.roblox.com/asset/?id=507784897", weight = 10 }
                },
        swimidle =  {
                    { id = "http://www.roblox.com/asset/?id=507785072", weight = 10 }
                },
        jump =  {
                    { id = "http://www.roblox.com/asset/?id=507765000", weight = 10 }
                },
        fall =  {
                    { id = "http://www.roblox.com/asset/?id=507767968", weight = 10 }
                },
        climb = {
                    { id = "http://www.roblox.com/asset/?id=507765644", weight = 10 }
                },
        sit =   {
                    { id = "http://www.roblox.com/asset/?id=2506281703", weight = 10 }
                },
        toolnone = {
                    { id = "http://www.roblox.com/asset/?id=507768375", weight = 10 }
                },
        toolslash = {
                    { id = "http://www.roblox.com/asset/?id=522635514", weight = 10 }
                },
        toollunge = {
                    { id = "http://www.roblox.com/asset/?id=522638767", weight = 10 }
                },
        wave = {
                    { id = "http://www.roblox.com/asset/?id=507770239", weight = 10 }
                },
        point = {
                    { id = "http://www.roblox.com/asset/?id=507770453", weight = 10 }
                },
        dance = {
                    { id = "http://www.roblox.com/asset/?id=507771019", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=507771955", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=507772104", weight = 10 }
                },
        dance2 = {
                    { id = "http://www.roblox.com/asset/?id=507776043", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=507776720", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=507776879", weight = 10 }
                },
        dance3 = {
                    { id = "http://www.roblox.com/asset/?id=507777268", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=507777451", weight = 10 },
                    { id = "http://www.roblox.com/asset/?id=507777623", weight = 10 }
                },
        laugh = {
                    { id = "http://www.roblox.com/asset/?id=507770818", weight = 10 }
                },
        cheer = {
                    { id = "http://www.roblox.com/asset/?id=507770677", weight = 10 }
                },
    }

    -- Existance in this list signifies that it is an emote, the value indicates if it is a looping emote
    local emoteNames = { wave = false, point = false, dance = true, dance2 = true, dance3 = true, laugh = false, cheer = false}

    local PreloadAnimsUserFlag = false
    local PreloadedAnims = {}
    local successPreloadAnim, msgPreloadAnim = pcall(function()
        PreloadAnimsUserFlag = UserSettings():IsUserFeatureEnabled("UserPreloadAnimations")
    end)
    if not successPreloadAnim then
        PreloadAnimsUserFlag = false
    end

    math.randomseed(tick())

    function findExistingAnimationInSet(set, anim)
        if set == nil or anim == nil then
            return 0
        end

        for idx = 1, set.count, 1 do
            if set[idx].anim.AnimationId == anim.AnimationId then
                return idx
            end
        end

        return 0
    end

    function configureAnimationSet(name, fileList)
        if (animTable[name] ~= nil) then
            for _, connection in pairs(animTable[name].connections) do
                connection:disconnect()
            end
        end
        animTable[name] = {}
        animTable[name].count = 0
        animTable[name].totalWeight = 0
        animTable[name].connections = {}

        local allowCustomAnimations = true

        local success, msg = pcall(function() allowCustomAnimations = game:GetService("StarterPlayer").AllowCustomAnimations end)
        if not success then
            allowCustomAnimations = true
        end

        -- check for config values
        local config = script:FindFirstChild(name)
        if (allowCustomAnimations and config ~= nil) then
            table.insert(animTable[name].connections, config.ChildAdded:connect(function(child) configureAnimationSet(name, fileList) end))
            table.insert(animTable[name].connections, config.ChildRemoved:connect(function(child) configureAnimationSet(name, fileList) end))

            local idx = 0
            for _, childPart in pairs(config:GetChildren()) do
                if (childPart:IsA("Animation")) then
                    local newWeight = 1
                    local weightObject = childPart:FindFirstChild("Weight")
                    if (weightObject ~= nil) then
                        newWeight = weightObject.Value
                    end
                    animTable[name].count = animTable[name].count + 1
                    idx = animTable[name].count
                    animTable[name][idx] = {}
                    animTable[name][idx].anim = childPart
                    animTable[name][idx].weight = newWeight
                    animTable[name].totalWeight = animTable[name].totalWeight + animTable[name][idx].weight
                    table.insert(animTable[name].connections, childPart.Changed:connect(function(property) configureAnimationSet(name, fileList) end))
                    table.insert(animTable[name].connections, childPart.ChildAdded:connect(function(property) configureAnimationSet(name, fileList) end))
                    table.insert(animTable[name].connections, childPart.ChildRemoved:connect(function(property) configureAnimationSet(name, fileList) end))
                end
            end
        end

        -- fallback to defaults
        if (animTable[name].count <= 0) then
            for idx, anim in pairs(fileList) do
                animTable[name][idx] = {}
                animTable[name][idx].anim = Instance.new("Animation")
                animTable[name][idx].anim.Name = name
                animTable[name][idx].anim.AnimationId = anim.id
                animTable[name][idx].weight = anim.weight
                animTable[name].count = animTable[name].count + 1
                animTable[name].totalWeight = animTable[name].totalWeight + anim.weight
            end
        end

        -- preload anims
        if PreloadAnimsUserFlag then
            for i, animType in pairs(animTable) do
                for idx = 1, animType.count, 1 do
                    if PreloadedAnims[animType[idx].anim.AnimationId] == nil then
                        Humanoid:LoadAnimation(animType[idx].anim)
                        PreloadedAnims[animType[idx].anim.AnimationId] = true
                    end
                end
            end
        end
    end

    ------------------------------------------------------------------------------------------------------------

    function configureAnimationSetOld(name, fileList)
        if (animTable[name] ~= nil) then
            for _, connection in pairs(animTable[name].connections) do
                connection:disconnect()
            end
        end
        animTable[name] = {}
        animTable[name].count = 0
        animTable[name].totalWeight = 0
        animTable[name].connections = {}

        local allowCustomAnimations = true

        local success, msg = pcall(function() allowCustomAnimations = game:GetService("StarterPlayer").AllowCustomAnimations end)
        if not success then
            allowCustomAnimations = true
        end

        -- check for config values
        local config = script:FindFirstChild(name)
        if (allowCustomAnimations and config ~= nil) then
            table.insert(animTable[name].connections, config.ChildAdded:connect(function(child) configureAnimationSet(name, fileList) end))
            table.insert(animTable[name].connections, config.ChildRemoved:connect(function(child) configureAnimationSet(name, fileList) end))
            local idx = 1
            for _, childPart in pairs(config:GetChildren()) do
                if (childPart:IsA("Animation")) then
                    table.insert(animTable[name].connections, childPart.Changed:connect(function(property) configureAnimationSet(name, fileList) end))
                    animTable[name][idx] = {}
                    animTable[name][idx].anim = childPart
                    local weightObject = childPart:FindFirstChild("Weight")
                    if (weightObject == nil) then
                        animTable[name][idx].weight = 1
                    else
                        animTable[name][idx].weight = weightObject.Value
                    end
                    animTable[name].count = animTable[name].count + 1
                    animTable[name].totalWeight = animTable[name].totalWeight + animTable[name][idx].weight
                    idx = idx + 1
                end
            end
        end

        -- fallback to defaults
        if (animTable[name].count <= 0) then
            for idx, anim in pairs(fileList) do
                animTable[name][idx] = {}
                animTable[name][idx].anim = Instance.new("Animation")
                animTable[name][idx].anim.Name = name
                animTable[name][idx].anim.AnimationId = anim.id
                animTable[name][idx].weight = anim.weight
                animTable[name].count = animTable[name].count + 1
                animTable[name].totalWeight = animTable[name].totalWeight + anim.weight
                -- print(name .. " [" .. idx .. "] " .. anim.id .. " (" .. anim.weight .. ")")
            end
        end

        -- preload anims
        if PreloadAnimsUserFlag then
            for i, animType in pairs(animTable) do
                for idx = 1, animType.count, 1 do
                    Humanoid:LoadAnimation(animType[idx].anim)
                end
            end
        end
    end

    -- Setup animation objects
    function scriptChildModified(child)
        local fileList = animNames[child.Name]
        if (fileList ~= nil) then
            configureAnimationSet(child.Name, fileList)
        end
    end

    script.ChildAdded:connect(scriptChildModified)
    script.ChildRemoved:connect(scriptChildModified)


    for name, fileList in pairs(animNames) do
        configureAnimationSet(name, fileList)
    end

    -- ANIMATION

    -- declarations
    local toolAnim = "None"
    local toolAnimTime = 0

    local jumpAnimTime = 0
    local jumpAnimDuration = 0.31

    local toolTransitionTime = 0.1
    local fallTransitionTime = 0.2

    local currentlyPlayingEmote = false

    -- functions

    function stopAllAnimations()
        local oldAnim = currentAnim

        -- return to idle if finishing an emote
        if (emoteNames[oldAnim] ~= nil and emoteNames[oldAnim] == false) then
            oldAnim = "idle"
        end

        if FFlagAnimateScriptEmoteHook and currentlyPlayingEmote then
            oldAnim = "idle"
            currentlyPlayingEmote = false
        end

        currentAnim = ""
        currentAnimInstance = nil
        if (currentAnimKeyframeHandler ~= nil) then
            currentAnimKeyframeHandler:disconnect()
        end

        if (currentAnimTrack ~= nil) then
            currentAnimTrack:Stop()
            currentAnimTrack:Destroy()
            currentAnimTrack = nil
        end

        -- clean up walk if there is one
        if (runAnimKeyframeHandler ~= nil) then
            runAnimKeyframeHandler:disconnect()
        end

        if (runAnimTrack ~= nil) then
            runAnimTrack:Stop()
            runAnimTrack:Destroy()
            runAnimTrack = nil
        end

        return oldAnim
    end

    function getHeightScale()
        if Humanoid then
            if not Humanoid.AutomaticScalingEnabled then
                return 1
            end

            local scale = Humanoid.HipHeight / HumanoidHipHeight
            if userAnimationSpeedDampening then
                if AnimationSpeedDampeningObject == nil then
                    AnimationSpeedDampeningObject = script:FindFirstChild("ScaleDampeningPercent")
                end
                if AnimationSpeedDampeningObject ~= nil then
                    scale = 1 + (Humanoid.HipHeight - HumanoidHipHeight) * AnimationSpeedDampeningObject.Value / HumanoidHipHeight
                end
            end
            return scale
        end
        return 1
    end

    local smallButNotZero = 0.0001
    function setRunSpeed(speed)
        local speedScaled = speed * 1.25
        local heightScale = getHeightScale()
        local runSpeed = speedScaled / heightScale

        if runSpeed ~= currentAnimSpeed then
            if runSpeed < 0.33 then
                currentAnimTrack:AdjustWeight(1.0)
                runAnimTrack:AdjustWeight(smallButNotZero)
            elseif runSpeed < 0.66 then
                local weight = ((runSpeed - 0.33) / 0.33)
                currentAnimTrack:AdjustWeight(1.0 - weight + smallButNotZero)
                runAnimTrack:AdjustWeight(weight + smallButNotZero)
            else
                currentAnimTrack:AdjustWeight(smallButNotZero)
                runAnimTrack:AdjustWeight(1.0)
            end
            currentAnimSpeed = runSpeed
            runAnimTrack:AdjustSpeed(runSpeed)
            currentAnimTrack:AdjustSpeed(runSpeed)
        end
    end

    function setAnimationSpeed(speed)
        if currentAnim == "walk" then
                setRunSpeed(speed)
        else
            if speed ~= currentAnimSpeed then
                currentAnimSpeed = speed
                currentAnimTrack:AdjustSpeed(currentAnimSpeed)
            end
        end
    end

    function keyFrameReachedFunc(frameName)
        if (frameName == "End") then
            if currentAnim == "walk" then
                if userNoUpdateOnLoop == true then
                    if runAnimTrack.Looped ~= true then
                        runAnimTrack.TimePosition = 0.0
                    end
                    if currentAnimTrack.Looped ~= true then
                        currentAnimTrack.TimePosition = 0.0
                    end
                else
                    runAnimTrack.TimePosition = 0.0
                    currentAnimTrack.TimePosition = 0.0
                end
            else
                local repeatAnim = currentAnim
                -- return to idle if finishing an emote
                if (emoteNames[repeatAnim] ~= nil and emoteNames[repeatAnim] == false) then
                    repeatAnim = "idle"
                end

                if FFlagAnimateScriptEmoteHook and currentlyPlayingEmote then
                    if currentAnimTrack.Looped then
                        -- Allow the emote to loop
                        return
                    end

                    repeatAnim = "idle"
                    currentlyPlayingEmote = false
                end

                local animSpeed = currentAnimSpeed
                playAnimation(repeatAnim, 0.15, Humanoid)
                setAnimationSpeed(animSpeed)
            end
        end
    end

    function rollAnimation(animName)
        local roll = math.random(1, animTable[animName].totalWeight)
        local origRoll = roll
        local idx = 1
        while (roll > animTable[animName][idx].weight) do
            roll = roll - animTable[animName][idx].weight
            idx = idx + 1
        end
        return idx
    end

    local function switchToAnim(anim, animName, transitionTime, humanoid)
        -- switch animation
        if (anim ~= currentAnimInstance) then

            if (currentAnimTrack ~= nil) then
                currentAnimTrack:Stop(transitionTime)
                currentAnimTrack:Destroy()
            end

            if (runAnimTrack ~= nil) then
                runAnimTrack:Stop(transitionTime)
                runAnimTrack:Destroy()
                if userNoUpdateOnLoop == true then
                    runAnimTrack = nil
                end
            end

            currentAnimSpeed = 1.0

            -- load it to the humanoid; get AnimationTrack
            currentAnimTrack = humanoid:LoadAnimation(anim)
            currentAnimTrack.Priority = Enum.AnimationPriority.Core

            -- play the animation
            currentAnimTrack:Play(transitionTime)
            currentAnim = animName
            currentAnimInstance = anim

            -- set up keyframe name triggers
            if (currentAnimKeyframeHandler ~= nil) then
                currentAnimKeyframeHandler:disconnect()
            end
            currentAnimKeyframeHandler = currentAnimTrack.KeyframeReached:connect(keyFrameReachedFunc)

            -- check to see if we need to blend a walk/run animation
            if animName == "walk" then
                local runAnimName = "run"
                local runIdx = rollAnimation(runAnimName)

                runAnimTrack = humanoid:LoadAnimation(animTable[runAnimName][runIdx].anim)
                runAnimTrack.Priority = Enum.AnimationPriority.Core
                runAnimTrack:Play(transitionTime)

                if (runAnimKeyframeHandler ~= nil) then
                    runAnimKeyframeHandler:disconnect()
                end
                runAnimKeyframeHandler = runAnimTrack.KeyframeReached:connect(keyFrameReachedFunc)
            end
        end
    end

    function playAnimation(animName, transitionTime, humanoid)
        local idx = rollAnimation(animName)
        local anim = animTable[animName][idx].anim

        switchToAnim(anim, animName, transitionTime, humanoid)
        currentlyPlayingEmote = false
    end

    function playEmote(emoteAnim, transitionTime, humanoid)
        switchToAnim(emoteAnim, emoteAnim.Name, transitionTime, humanoid)
        currentlyPlayingEmote = true
    end

    -------------------------------------------------------------------------------------------
    -------------------------------------------------------------------------------------------

    local toolAnimName = ""
    local toolAnimTrack = nil
    local toolAnimInstance = nil
    local currentToolAnimKeyframeHandler = nil

    function toolKeyFrameReachedFunc(frameName)
        if (frameName == "End") then
            playToolAnimation(toolAnimName, 0.0, Humanoid)
        end
    end


    function playToolAnimation(animName, transitionTime, humanoid, priority)
            local idx = rollAnimation(animName)
            local anim = animTable[animName][idx].anim

            if (toolAnimInstance ~= anim) then

                if (toolAnimTrack ~= nil) then
                    toolAnimTrack:Stop()
                    toolAnimTrack:Destroy()
                    transitionTime = 0
                end

                -- load it to the humanoid; get AnimationTrack
                toolAnimTrack = humanoid:LoadAnimation(anim)
                if priority then
                    toolAnimTrack.Priority = priority
                end

                -- play the animation
                toolAnimTrack:Play(transitionTime)
                toolAnimName = animName
                toolAnimInstance = anim

                currentToolAnimKeyframeHandler = toolAnimTrack.KeyframeReached:connect(toolKeyFrameReachedFunc)
            end
    end

    function stopToolAnimations()
        local oldAnim = toolAnimName

        if (currentToolAnimKeyframeHandler ~= nil) then
            currentToolAnimKeyframeHandler:disconnect()
        end

        toolAnimName = ""
        toolAnimInstance = nil
        if (toolAnimTrack ~= nil) then
            toolAnimTrack:Stop()
            toolAnimTrack:Destroy()
            toolAnimTrack = nil
        end

        return oldAnim
    end

    -------------------------------------------------------------------------------------------
    -------------------------------------------------------------------------------------------
    -- STATE CHANGE HANDLERS

    function onRunning(speed)
        if speed > 0.75 then
            local scale = 16.0
            playAnimation("walk", 0.2, Humanoid)
            setAnimationSpeed(speed / scale)
            pose = "Running"
        else
            if emoteNames[currentAnim] == nil and not currentlyPlayingEmote then
                playAnimation("idle", 0.2, Humanoid)
                pose = "Standing"
            end
        end
    end

    function onDied()
        pose = "Dead"
    end

    function onJumping()
        playAnimation("jump", 0.1, Humanoid)
        jumpAnimTime = jumpAnimDuration
        pose = "Jumping"
    end

    function onClimbing(speed)
        local scale = 5.0
        playAnimation("climb", 0.1, Humanoid)
        setAnimationSpeed(speed / scale)
        pose = "Climbing"
    end

    function onGettingUp()
        pose = "GettingUp"
    end

    function onFreeFall()
        if (jumpAnimTime <= 0) then
            playAnimation("fall", fallTransitionTime, Humanoid)
        end
        pose = "FreeFall"
    end

    function onFallingDown()
        pose = "FallingDown"
    end

    function onSeated()
        pose = "Seated"
    end

    function onPlatformStanding()
        pose = "PlatformStanding"
    end

    -------------------------------------------------------------------------------------------
    -------------------------------------------------------------------------------------------

    function onSwimming(speed)
        if speed > 1.00 then
            local scale = 10.0
            playAnimation("swim", 0.4, Humanoid)
            setAnimationSpeed(speed / scale)
            pose = "Swimming"
        else
            playAnimation("swimidle", 0.4, Humanoid)
            pose = "Standing"
        end
    end

    function animateTool()
        if (toolAnim == "None") then
            playToolAnimation("toolnone", toolTransitionTime, Humanoid, Enum.AnimationPriority.Idle)
            return
        end

        if (toolAnim == "Slash") then
            playToolAnimation("toolslash", 0, Humanoid, Enum.AnimationPriority.Action)
            return
        end

        if (toolAnim == "Lunge") then
            playToolAnimation("toollunge", 0, Humanoid, Enum.AnimationPriority.Action)
            return
        end
    end

    function getToolAnim(tool)
        for _, c in ipairs(tool:GetChildren()) do
            if c.Name == "toolanim" and c.className == "StringValue" then
                return c
            end
        end
        return nil
    end

    local lastTick = 0

    function stepAnimate(currentTime)
        local amplitude = 1
        local frequency = 1
        local deltaTime = currentTime - lastTick
        lastTick = currentTime

        local climbFudge = 0
        local setAngles = false

        if (jumpAnimTime > 0) then
            jumpAnimTime = jumpAnimTime - deltaTime
        end

        if (pose == "FreeFall" and jumpAnimTime <= 0) then
            playAnimation("fall", fallTransitionTime, Humanoid)
        elseif (pose == "Seated") then
            playAnimation("sit", 0.5, Humanoid)
            return
        elseif (pose == "Running") then
            playAnimation("walk", 0.2, Humanoid)
        elseif (pose == "Dead" or pose == "GettingUp" or pose == "FallingDown" or pose == "Seated" or pose == "PlatformStanding") then
            stopAllAnimations()
            amplitude = 0.1
            frequency = 1
            setAngles = true
        end

        -- Tool Animation handling
        local tool = Character:FindFirstChildOfClass("Tool")
        if tool and tool:FindFirstChild("Handle") then
            local animStringValueObject = getToolAnim(tool)

            if animStringValueObject then
                toolAnim = animStringValueObject.Value
                -- message recieved, delete StringValue
                animStringValueObject.Parent = nil
                toolAnimTime = currentTime + .3
            end

            if currentTime > toolAnimTime then
                toolAnimTime = 0
                toolAnim = "None"
            end

            animateTool()
        else
            stopToolAnimations()
            toolAnim = "None"
            toolAnimInstance = nil
            toolAnimTime = 0
        end
    end

    -- connect events

    local events = {}
    local eventHum = Humanoid

    local function onUnhook()
        for i = 1, #events do
            events[i]:Disconnect()
        end
        events = {}
    end

    local function onHook()
        onUnhook()

        pose = eventHum.Sit and "Seated" or "Standing"

        events = {
            eventHum.Died:connect(onDied),
            eventHum.Running:connect(onRunning),
            eventHum.Jumping:connect(onJumping),
            eventHum.Climbing:connect(onClimbing),
            eventHum.GettingUp:connect(onGettingUp),
            eventHum.FreeFalling:connect(onFreeFall),
            eventHum.FallingDown:connect(onFallingDown),
            eventHum.Seated:connect(onSeated),
            eventHum.PlatformStanding:connect(onPlatformStanding),
            eventHum.Swimming:connect(onSwimming)
        }
    end


    onHook()

    -- setup emote chat hook
    game:GetService("Players").LocalPlayer.Chatted:connect(function(msg)
        local emote = ""
        if (string.sub(msg, 1, 3) == "/e ") then
            emote = string.sub(msg, 4)
        elseif (string.sub(msg, 1, 7) == "/emote ") then
            emote = string.sub(msg, 8)
        end

        if (pose == "Standing" and emoteNames[emote] ~= nil) then
            playAnimation(emote, EMOTE_TRANSITION_TIME, Humanoid)
        end
    end)

    --[[ emote bindable hook
    if FFlagAnimateScriptEmoteHook then
        script:WaitForChild("PlayEmote").OnInvoke = function(emote)
            -- Only play emotes when idling
            if pose ~= "Standing" then
                return
            end
            if emoteNames[emote] ~= nil then
                -- Default emotes
                playAnimation(emote, EMOTE_TRANSITION_TIME, Humanoid)
                return true
            elseif typeof(emote) == "Instance" and emote:IsA("Animation") then
                -- Non-default emotes
                playEmote(emote, EMOTE_TRANSITION_TIME, Humanoid)
                return true
            end
            -- Return false to indicate that the emote could not be played
            return false
        end
    end
    ]]
    -- initialize to idle
    playAnimation("idle", 0.1, Humanoid)
    pose = "Standing"
    -- loop to handle timed state transitions and tool animations
    spawn(function()
        while Character.Parent ~= nil do
            local _, currentGameTime = wait(0.1)
            stepAnimate(currentGameTime)
        end
    end)
    return {
        onRunning = onRunning,
        onDied = onDied,
        onJumping = onJumping,
        onClimbing = onClimbing,
        onGettingUp = onGettingUp,
        onFreeFall = onFreeFall,
        onFallingDown = onFallingDown,
        onSeated = onSeated,
        onPlatformStanding = onPlatformStanding,
        onHook = onHook,
        onUnhook = onUnhook
    }
    end
    return r15()
end
while true do
    wait(.1)
    if plr.Character ~= nil then
        char = plr.Character
        break
    end
end
function _Controller()
    local humanoid = char:WaitForChild("Humanoid")
    local animFuncs = {}
    if (humanoid.RigType == Enum.HumanoidRigType.R6) then
        animFuncs = _R6()
    else
        animFuncs = _R15()
    end
    print("Animation succes")
    return animFuncs
end
function _AnimationHandler()
local AnimationHandler = {}
AnimationHandler.__index = AnimationHandler

function AnimationHandler.new(humanoid, animate)
    local self = setmetatable({}, AnimationHandler)

    self._AnimFuncs = _Controller()
    self.Humanoid = humanoid

    return self
end

function AnimationHandler:EnableDefault(bool)
    if (bool) then
        self._AnimFuncs.onHook()
    else
        self._AnimFuncs.onUnhook()
    end
end

function AnimationHandler:Run(name, ...)
    self._AnimFuncs[name](...)
end

return AnimationHandler
end

function _GravityController()

local ZERO = Vector3.new(0, 0, 0)
local UNIT_X = Vector3.new(1, 0, 0)
local UNIT_Y = Vector3.new(0, 1, 0)
local UNIT_Z = Vector3.new(0, 0, 1)
local VEC_XY = Vector3.new(1, 0, 1)

local IDENTITYCF = CFrame.new()

local JUMPMODIFIER = 1.2
local TRANSITION = 0.15
local WALKF = 200 / 3

local UIS = game:GetService("UserInputService")
local RUNSERVICE = game:GetService("RunService")

local InitObjects = _InitObjects()
local AnimationHandler = _AnimationHandler()
local StateTracker = _StateTracker()

-- Class

local GravityController = {}
GravityController.__index = GravityController

-- Private Functions

local function getRotationBetween(u, v, axis)
    local dot, uxv = u:Dot(v), u:Cross(v)
    if (dot < -0.99999) then return CFrame.fromAxisAngle(axis, math.pi) end
    return CFrame.new(0, 0, 0, uxv.x, uxv.y, uxv.z, 1 + dot)
end

local function lookAt(pos, forward, up)
    local r = forward:Cross(up)
    local u = r:Cross(forward)
    return CFrame.fromMatrix(pos, r.Unit, u.Unit)
end

local function getMass(array)
    local mass = 0
    for _, part in next, array do
        if (part:IsA("BasePart")) then
            mass = mass + part:GetMass()
        end
    end
    return mass
end

-- Public Constructor
local ExecutedPlayerModule = _PlayerModule()
local ExecutedSounds = _sounds()
function GravityController.new(player)
    local self = setmetatable({}, GravityController)

    --[[ Camera
    local loaded = player.PlayerScripts:WaitForChild("PlayerScriptsLoader"):WaitForChild("Loaded")
    if (not loaded.Value) then
        --loaded.Changed:Wait()
    end
    ]]
    local playerModule = ExecutedPlayerModule
    self.Controls = playerModule:GetControls()
    self.Camera = playerModule:GetCameras()

    -- Player and character
    self.Player = player
    self.Character = player.Character
    self.Humanoid = player.Character:WaitForChild("Humanoid")
    self.HRP = player.Character:WaitForChild("HumanoidRootPart")

    -- Animation
    self.AnimationHandler = AnimationHandler.new(self.Humanoid, self.Character:WaitForChild("Animate"))
    self.AnimationHandler:EnableDefault(false)
    local ssss = game:GetService("Players").LocalPlayer.PlayerScripts:FindFirstChild("SetState") or Instance.new("BindableEvent",game:GetService("Players").LocalPlayer.PlayerScripts)
    local soundState = ExecutedSounds
    ssss.Name = "SetState"

    self.StateTracker = StateTracker.new(self.Humanoid, soundState)
    self.StateTracker.Changed:Connect(function(name, speed)
        self.AnimationHandler:Run(name, speed)
    end)

    -- Collider and forces
    local collider, gyro, vForce, floor = InitObjects(self)

    floor.Touched:Connect(function() end)
    collider.Touched:Connect(function() end)

    self.Collider = collider
    self.VForce = vForce
    self.Gyro = gyro
    self.Floor = floor

    -- Attachment to parts
    self.LastPart = workspace.Terrain
    self.LastPartCFrame = IDENTITYCF

    -- Gravity properties
    self.GravityUp = UNIT_Y
    self.Ignores = {self.Character}

    function self.Camera.GetUpVector(this, oldUpVector)
        return self.GravityUp
    end

    -- Events etc
    self.Humanoid.PlatformStand = true

    self.CharacterMass = getMass(self.Character:GetDescendants())
    self.Character.AncestryChanged:Connect(function() self.CharacterMass = getMass(self.Character:GetDescendants()) end)

    self.JumpCon = RUNSERVICE.RenderStepped:Connect(function(dt)
        if (self.Controls:IsJumping()) then
            self:OnJumpRequest()
        end
    end)

    self.DeathCon = self.Humanoid.Died:Connect(function() self:Destroy() end)
    self.SeatCon = self.Humanoid.Seated:Connect(function(active) if (active) then self:Destroy() end end)
    self.HeartCon = RUNSERVICE.Heartbeat:Connect(function(dt) self:OnHeartbeatStep(dt) end)
    RUNSERVICE:BindToRenderStep("GravityStep", Enum.RenderPriority.Input.Value + 1, function(dt) self:OnGravityStep(dt) end)


    return self
end

-- Public Methods

function GravityController:Destroy()
    self.JumpCon:Disconnect()
    self.DeathCon:Disconnect()
    self.SeatCon:Disconnect()
    self.HeartCon:Disconnect()

    RUNSERVICE:UnbindFromRenderStep("GravityStep")

    self.Collider:Destroy()
    self.VForce:Destroy()
    self.Gyro:Destroy()
    self.StateTracker:Destroy()

    self.Humanoid.PlatformStand = false
    self.AnimationHandler:EnableDefault(true)

    self.GravityUp = UNIT_Y
end

function GravityController:GetGravityUp(oldGravity)
    return oldGravity
end

function GravityController:IsGrounded(isJumpCheck)
    if (not isJumpCheck) then
        local parts = self.Floor:GetTouchingParts()
        for _, part in next, parts do
            if (not part:IsDescendantOf(self.Character)) then
                return true
            end
        end
    else
        if (self.StateTracker.Jumped) then
            return false
        end

        -- 1. check we are touching something with the collider
        local valid = {}
        local parts = self.Collider:GetTouchingParts()
        for _, part in next, parts do
            if (not part:IsDescendantOf(self.Character)) then
                table.insert(valid, part)
            end
        end

        if (#valid > 0) then
            -- 2. do a decently long downwards raycast
            local max = math.cos(self.Humanoid.MaxSlopeAngle)
            local ray = Ray.new(self.Collider.Position, -10 * self.GravityUp)
            local hit, pos, normal = workspace:FindPartOnRayWithWhitelist(ray, valid, true)

            -- 3. use slope to decide on jump
            if (hit and max <= self.GravityUp:Dot(normal)) then
                return true
            end
        end
    end
    return false
end

function GravityController:OnJumpRequest()
    if (not self.StateTracker.Jumped and self:IsGrounded(true)) then
        local hrpVel = self.HRP.Velocity
        self.HRP.Velocity = hrpVel + self.GravityUp*self.Humanoid.JumpPower*JUMPMODIFIER
        self.StateTracker:RequestedJump()
    end
end

function GravityController:GetMoveVector()
    return self.Controls:GetMoveVector()
end

function GravityController:OnHeartbeatStep(dt)
    local ray = Ray.new(self.Collider.Position, -1.1*self.GravityUp)
    local hit, pos, normal = workspace:FindPartOnRayWithIgnoreList(ray, self.Ignores)
    local lastPart = self.LastPart

    if (hit and lastPart and lastPart == hit) then
        local offset = self.LastPartCFrame:ToObjectSpace(self.HRP.CFrame)
        self.HRP.CFrame = hit.CFrame:ToWorldSpace(offset)
    end

    self.LastPart = hit
    self.LastPartCFrame = hit and hit.CFrame
end

function GravityController:OnGravityStep(dt)
    -- update gravity up vector
    local oldGravity = self.GravityUp
    local newGravity = self:GetGravityUp(oldGravity)

    local rotation = getRotationBetween(oldGravity, newGravity, workspace.CurrentCamera.CFrame.RightVector)
    rotation = IDENTITYCF:Lerp(rotation, TRANSITION)

    self.GravityUp = rotation * oldGravity

    -- get world move vector
    local camCF = workspace.CurrentCamera.CFrame
    local fDot = camCF.LookVector:Dot(newGravity)
    local cForward = math.abs(fDot) > 0.5 and -math.sign(fDot)*camCF.UpVector or camCF.LookVector

    local left = cForward:Cross(-newGravity).Unit
    local forward = -left:Cross(newGravity).Unit

    local move = self:GetMoveVector()
    local worldMove = forward*move.z - left*move.x
    worldMove = worldMove:Dot(worldMove) > 1 and worldMove.Unit or worldMove

    local isInputMoving = worldMove:Dot(worldMove) > 0

    -- get the desired character cframe
    local hrpCFLook = self.HRP.CFrame.LookVector
    local charF = hrpCFLook:Dot(forward)*forward + hrpCFLook:Dot(left)*left
    local charR = charF:Cross(newGravity).Unit
    local newCharCF = CFrame.fromMatrix(ZERO, charR, newGravity, -charF)

    local newCharRotation = IDENTITYCF
    if (isInputMoving) then
        newCharRotation = IDENTITYCF:Lerp(getRotationBetween(charF, worldMove, newGravity), 0.7)
    end

    -- calculate forces
    local g = workspace.Gravity
    local gForce = g * self.CharacterMass * (UNIT_Y - newGravity)

    local cVelocity = self.HRP.Velocity
    local tVelocity = self.Humanoid.WalkSpeed * worldMove
    local gVelocity = cVelocity:Dot(newGravity)*newGravity
    local hVelocity = cVelocity - gVelocity

    if (hVelocity:Dot(hVelocity) < 1) then
        hVelocity = ZERO
    end

    local dVelocity = tVelocity - hVelocity
    local walkForceM = math.min(10000, WALKF * self.CharacterMass * dVelocity.Magnitude / (dt*60))
    local walkForce = walkForceM > 0 and dVelocity.Unit*walkForceM or ZERO

    -- mouse lock
    local charRotation = newCharRotation * newCharCF

    if (self.Camera:IsCamRelative()) then
        local lv = workspace.CurrentCamera.CFrame.LookVector
        local hlv = lv - charRotation.UpVector:Dot(lv)*charRotation.UpVector
        charRotation = lookAt(ZERO, hlv, charRotation.UpVector)
    end

    -- get state
    self.StateTracker:OnStep(self.GravityUp, self:IsGrounded(), isInputMoving)

    -- update values
    self.VForce.Force = walkForce + gForce
    self.Gyro.CFrame = charRotation
end
return GravityController
end
function _Draw3D()
    local module = {}

    -- Style Guide

    module.StyleGuide = {
        Point = {
            Thickness = 0.5;
            Color = Color3.new(0, 1, 0);
        },

        Line = {
            Thickness = 0.1;
            Color = Color3.new(1, 1, 0);
        },

        Ray = {
            Thickness = 0.1;
            Color = Color3.new(1, 0, 1);
        },

        Triangle = {
            Thickness = 0.05;
        };

        CFrame = {
            Thickness = 0.1;
            RightColor3 = Color3.new(1, 0, 0);
            UpColor3 = Color3.new(0, 1, 0);
            BackColor3 = Color3.new(0, 0, 1);
            PartProperties = {
                Material = Enum.Material.SmoothPlastic;
            };
        }
    }

    -- CONSTANTS

    local WEDGE = Instance.new("WedgePart")
    WEDGE.Material = Enum.Material.SmoothPlastic
    WEDGE.Anchored = true
    WEDGE.CanCollide = false

    local PART = Instance.new("Part")
    PART.Size = Vector3.new(0.1, 0.1, 0.1)
    PART.Anchored = true
    PART.CanCollide = false
    PART.TopSurface = Enum.SurfaceType.Smooth
    PART.BottomSurface = Enum.SurfaceType.Smooth
    PART.Material = Enum.Material.SmoothPlastic

    -- Functions

    local function draw(properties, style)
        local part = PART:Clone()
        for k, v in next, properties do
            part[k] = v
        end
        if (style) then
            for k, v in next, style do
                if (k ~= "Thickness") then
                    part[k] = v
                end
            end
        end
        return part
    end

    function module.Draw(parent, properties)
        properties.Parent = parent
        return draw(properties, nil)
    end

    function module.Point(parent, cf_v3)
        local thickness = module.StyleGuide.Point.Thickness
        return draw({
            Size = Vector3.new(thickness, thickness, thickness);
            CFrame = (typeof(cf_v3) == "CFrame" and cf_v3 or CFrame.new(cf_v3));
            Parent = parent;
        }, module.StyleGuide.Point)
    end

    function module.Line(parent, a, b)
        local thickness = module.StyleGuide.Line.Thickness
        return draw({
            CFrame = CFrame.new((a + b)/2, b);
            Size = Vector3.new(thickness, thickness, (b - a).Magnitude);
            Parent = parent;
        }, module.StyleGuide.Line)
    end

    function module.Ray(parent, origin, direction)
        local thickness = module.StyleGuide.Ray.Thickness
        return draw({
            CFrame = CFrame.new(origin + direction/2, origin + direction);
            Size = Vector3.new(thickness, thickness, direction.Magnitude);
            Parent = parent;
        }, module.StyleGuide.Ray)
    end

    function module.Triangle(parent, a, b, c)
        local ab, ac, bc = b - a, c - a, c - b
        local abd, acd, bcd = ab:Dot(ab), ac:Dot(ac), bc:Dot(bc)

        if (abd > acd and abd > bcd) then
            c, a = a, c
        elseif (acd > bcd and acd > abd) then
            a, b = b, a
        end

        ab, ac, bc = b - a, c - a, c - b

        local right = ac:Cross(ab).Unit
        local up = bc:Cross(right).Unit
        local back = bc.Unit

        local height = math.abs(ab:Dot(up))
        local width1 = math.abs(ab:Dot(back))
        local width2 = math.abs(ac:Dot(back))

        local thickness = module.StyleGuide.Triangle.Thickness

        local w1 = WEDGE:Clone()
        w1.Size = Vector3.new(thickness, height, width1)
        w1.CFrame = CFrame.fromMatrix((a + b)/2, right, up, back)
        w1.Parent = parent

        local w2 = WEDGE:Clone()
        w2.Size = Vector3.new(thickness, height, width2)
        w2.CFrame = CFrame.fromMatrix((a + c)/2, -right, up, -back)
        w2.Parent = parent

        for k, v in next, module.StyleGuide.Triangle do
            if (k ~= "Thickness") then
                w1[k] = v
                w2[k] = v
            end
        end

        return w1, w2
    end

    function module.CFrame(parent, cf)
        local origin = cf.Position
        local r = cf.RightVector
        local u = cf.UpVector
        local b = -cf.LookVector

        local thickness = module.StyleGuide.CFrame.Thickness

        local right = draw({
            CFrame = CFrame.new(origin + r/2, origin + r);
            Size = Vector3.new(thickness, thickness, r.Magnitude);
            Color = module.StyleGuide.CFrame.RightColor3;
            Parent = parent;
        }, module.StyleGuide.CFrame.PartProperties)

        local up = draw({
            CFrame = CFrame.new(origin + u/2, origin + u);
            Size = Vector3.new(thickness, thickness, r.Magnitude);
            Color = module.StyleGuide.CFrame.UpColor3;
            Parent = parent;
        }, module.StyleGuide.CFrame.PartProperties)

        local back = draw({
            CFrame = CFrame.new(origin + b/2, origin + b);
            Size = Vector3.new(thickness, thickness, u.Magnitude);
            Color = module.StyleGuide.CFrame.BackColor3;
            Parent = parent;
        }, module.StyleGuide.CFrame.PartProperties)

        return right, up, back
    end

    -- Return

    return module
end
function _Draw2D()
    local module = {}

    -- Style Guide

    module.StyleGuide = {
        Point = {
            BorderSizePixel = 0;
            Size = UDim2.new(0, 4, 0, 4);
            BorderColor3 = Color3.new(0, 0, 0);
            BackgroundColor3 = Color3.new(0, 1, 0);
        },

        Line = {
            Thickness = 1;
            BorderSizePixel = 0;
            BorderColor3 = Color3.new(0, 0, 0);
            BackgroundColor3 = Color3.new(0, 1, 0);
        },

        Ray = {
            Thickness = 1;
            BorderSizePixel = 0;
            BorderColor3 = Color3.new(0, 0, 0);
            BackgroundColor3 = Color3.new(0, 1, 0);
        },

        Triangle = {
            ImageTransparency = 0;
            ImageColor3 = Color3.new(0, 1, 0);
        }
    }

    -- CONSTANTS

    local HALF = Vector2.new(0.5, 0.5)

    local RIGHT = "rbxassetid://2798177521"
    local LEFT = "rbxassetid://2798177955"

    local IMG = Instance.new("ImageLabel")
    IMG.BackgroundTransparency = 1
    IMG.AnchorPoint = HALF
    IMG.BorderSizePixel = 0

    local FRAME = Instance.new("Frame")
    FRAME.BorderSizePixel = 0
    FRAME.Size = UDim2.new(0, 0, 0, 0)
    FRAME.BackgroundColor3 = Color3.new(1, 1, 1)

    -- Functions

    function draw(properties, style)
        local frame = FRAME:Clone()
        for k, v in next, properties do
            frame[k] = v
        end
        if (style) then
            for k, v in next, style do
                if (k ~= "Thickness") then
                    frame[k] = v
                end
            end
        end
        return frame
    end

    function module.Draw(parent, properties)
        properties.Parent = parent
        return draw(properties, nil)
    end

    function module.Point(parent, v2)
        return draw({
            AnchorPoint = HALF;
            Position = UDim2.new(0, v2.x, 0, v2.y);
            Parent = parent;
        }, module.StyleGuide.Point)
    end

    function module.Line(parent, a, b)
        local v = (b - a)
        local m = (a + b)/2

        return draw({
            AnchorPoint = HALF;
            Position = UDim2.new(0, m.x, 0, m.y);
            Size = UDim2.new(0, module.StyleGuide.Line.Thickness, 0, v.magnitude);
            Rotation = math.deg(math.atan2(v.y, v.x)) - 90;
            BackgroundColor3 = Color3.new(1, 1, 0);
            Parent = parent;
        }, module.StyleGuide.Line)
    end

    function module.Ray(parent, origin, direction)
        local a, b = origin, origin + direction
        local v = (b - a)
        local m = (a + b)/2

        return draw({
            AnchorPoint = HALF;
            Position = UDim2.new(0, m.x, 0, m.y);
            Size = UDim2.new(0, module.StyleGuide.Ray.Thickness, 0, v.magnitude);
            Rotation = math.deg(math.atan2(v.y, v.x)) - 90;
            Parent = parent;
        }, module.StyleGuide.Ray)
    end

    function module.Triangle(parent, a, b, c)
        local ab, ac, bc = b - a, c - a, c - b
        local abd, acd, bcd = ab:Dot(ab), ac:Dot(ac), bc:Dot(bc)

        if (abd > acd and abd > bcd) then
            c, a = a, c
        elseif (acd > bcd and acd > abd) then
            a, b = b, a
        end

        ab, ac, bc = b - a, c - a, c - b

        local unit = bc.unit
        local height = unit:Cross(ab)
        local flip = (height >= 0)
        local theta = math.deg(math.atan2(unit.y, unit.x)) + (flip and 0 or 180)

        local m1 = (a + b)/2
        local m2 = (a + c)/2

        local w1 = IMG:Clone()
        w1.Image = flip and RIGHT or LEFT
        w1.AnchorPoint = HALF
        w1.Size = UDim2.new(0, math.abs(unit:Dot(ab)), 0, height)
        w1.Position = UDim2.new(0, m1.x, 0, m1.y)
        w1.Rotation = theta
        w1.Parent = parent

        local w2 = IMG:Clone()
        w2.Image = flip and LEFT or RIGHT
        w2.AnchorPoint = HALF
        w2.Size = UDim2.new(0, math.abs(unit:Dot(ac)), 0, height)
        w2.Position = UDim2.new(0, m2.x, 0, m2.y)
        w2.Rotation = theta
        w2.Parent = parent

        for k, v in next, module.StyleGuide.Triangle do
            w1[k] = v
            w2[k] = v
        end

        return w1, w2
    end

    -- Return

    return module
end
function _DrawClass()
    local Draw2DModule = _Draw2D()
    local Draw3DModule = _Draw3D()

    --

    local DrawClass = {}
    local DrawClassStorage = setmetatable({}, {__mode = "k"})
    DrawClass.__index = DrawClass

    function DrawClass.new(parent)
        local self = setmetatable({}, DrawClass)

        self.Parent = parent
        DrawClassStorage[self] = {}

        self.Draw3D = {}
        for key, func in next, Draw3DModule do
            self.Draw3D[key] = function(...)
                local returns = {func(self.Parent, ...)}
                for i = 1, #returns do
                    table.insert(DrawClassStorage[self], returns[i])
                end
                return unpack(returns)
            end
        end

        self.Draw2D = {}
        for key, func in next, Draw2DModule do
            self.Draw2D[key] = function(...)
                local returns = {func(self.Parent, ...)}
                for i = 1, #returns do
                    table.insert(DrawClassStorage[self], returns[i])
                end
                return unpack(returns)
            end
        end

        return self
    end

    --

    function DrawClass:Clear()
        local t = DrawClassStorage[self]
        while (#t > 0) do
            local part = table.remove(t)
            if (part) then
                part:Destroy()
            end
        end
        DrawClassStorage[self] = {}
    end

    --

    return DrawClass
end


--END TEST

local PLAYERS = game:GetService("Players")

local GravityController = _GravityController()
local Controller = GravityController.new(PLAYERS.LocalPlayer)

local DrawClass = _DrawClass()

local PI2 = math.pi*2
local ZERO = Vector3.new(0, 0, 0)

local LOWER_RADIUS_OFFSET = 3
local NUM_DOWN_RAYS = 24
local ODD_DOWN_RAY_START_RADIUS = 3
local EVEN_DOWN_RAY_START_RADIUS = 2
local ODD_DOWN_RAY_END_RADIUS = 1.66666
local EVEN_DOWN_RAY_END_RADIUS = 1

local NUM_FEELER_RAYS = 9
local FEELER_LENGTH = 2
local FEELER_START_OFFSET = 2
local FEELER_RADIUS = 3.5
local FEELER_APEX_OFFSET = 1
local FEELER_WEIGHTING = 8

function GetGravityUp(self, oldGravityUp)
    local ignoreList = {}
    for i, player in next, PLAYERS:GetPlayers() do
        ignoreList[i] = player.Character
    end

    -- get the normal

    local hrpCF = self.HRP.CFrame
    local isR15 = (self.Humanoid.RigType == Enum.HumanoidRigType.R15)

    local origin = isR15 and hrpCF.p or hrpCF.p + 0.35*oldGravityUp
    local radialVector = math.abs(hrpCF.LookVector:Dot(oldGravityUp)) < 0.999 and hrpCF.LookVector:Cross(oldGravityUp) or hrpCF.RightVector:Cross(oldGravityUp)

    local centerRayLength = 25
    local centerRay = Ray.new(origin, -centerRayLength * oldGravityUp)
    local centerHit, centerHitPoint, centerHitNormal = workspace:FindPartOnRayWithIgnoreList(centerRay, ignoreList)

    --[[disable
    DrawClass:Clear()
    DrawClass.Draw3D.Ray(centerRay.Origin, centerRay.Direction)
    ]]
    local downHitCount = 0
    local totalHitCount = 0
    local centerRayHitCount = 0
    local evenRayHitCount = 0
    local oddRayHitCount = 0

    local mainDownNormal = ZERO
    if (centerHit) then
        mainDownNormal = centerHitNormal
        centerRayHitCount = 0
    end

    local downRaySum = ZERO
    for i = 1, NUM_DOWN_RAYS do
        local dtheta = PI2 * ((i-1)/NUM_DOWN_RAYS)

        local angleWeight = 0.25 + 0.75 * math.abs(math.cos(dtheta))
        local isEvenRay = (i%2 == 0)
        local startRadius = isEvenRay and EVEN_DOWN_RAY_START_RADIUS or ODD_DOWN_RAY_START_RADIUS
        local endRadius = isEvenRay and EVEN_DOWN_RAY_END_RADIUS or ODD_DOWN_RAY_END_RADIUS
        local downRayLength = centerRayLength

        local offset = CFrame.fromAxisAngle(oldGravityUp, dtheta) * radialVector
        local dir = (LOWER_RADIUS_OFFSET * -oldGravityUp + (endRadius - startRadius) * offset)
        local ray = Ray.new(origin + startRadius * offset, downRayLength * dir.unit)
        local hit, hitPoint, hitNormal = workspace:FindPartOnRayWithIgnoreList(ray, ignoreList)
        --[[disable
        DrawClass.Draw3D.Ray(ray.Origin, ray.Direction)
        ]]
        if (hit) then
            downRaySum = downRaySum + angleWeight * hitNormal
            downHitCount = downHitCount + 1
            if isEvenRay then
                evenRayHitCount = evenRayHitCount + 1
            else
                oddRayHitCount = oddRayHitCount + 1
            end
        end
    end

    local feelerHitCount = 0
    local feelerNormalSum = ZERO

    for i = 1, NUM_FEELER_RAYS do
        local dtheta = 2 * math.pi * ((i-1)/NUM_FEELER_RAYS)
        local angleWeight =  0.25 + 0.75 * math.abs(math.cos(dtheta))
        local offset = CFrame.fromAxisAngle(oldGravityUp, dtheta) * radialVector
        local dir = (FEELER_RADIUS * offset + LOWER_RADIUS_OFFSET * -oldGravityUp).unit
        local feelerOrigin = origin - FEELER_APEX_OFFSET * -oldGravityUp + FEELER_START_OFFSET * dir
        local ray = Ray.new(feelerOrigin, FEELER_LENGTH * dir)
        local hit, hitPoint, hitNormal = workspace:FindPartOnRayWithIgnoreList(ray, ignoreList)
        --[[disable
        DrawClass.Draw3D.Ray(ray.Origin, ray.Direction)
        ]]
        if (hit) then
            feelerNormalSum = feelerNormalSum + FEELER_WEIGHTING * angleWeight * hitNormal --* hitDistSqInv
            feelerHitCount = feelerHitCount + 1
        end
    end

    if (centerRayHitCount + downHitCount + feelerHitCount > 0) then
        local normalSum = mainDownNormal + downRaySum + feelerNormalSum
        if (normalSum ~= ZERO) then
            return normalSum.unit
        end
    end

    return oldGravityUp
end

Controller.GetGravityUp = GetGravityUp

-- E is toggle
game:GetService("ContextActionService"):BindAction("Toggle", function(action, state, input)
    if not (state == Enum.UserInputState.Begin) then
        return
    end

    if (Controller) then
        Controller:Destroy()
        Controller = nil
    else
        Controller = GravityController.new(PLAYERS.LocalPlayer)
        Controller.GetGravityUp = GetGravityUp
    end
end, false, Enum.KeyCode.Z)
print("end")