R6.R15/Hub

local player = game.Players.LocalPlayer
player.Chatted:connect(function(cht)
	if cht:match(".r6 naruto run")then
		--R6Naruto run
		spawn(function()
			while wait() do
				settings().Physics.AllowSleep = false
				game.Players.LocalPlayer.MaximumSimulationRadius = math.huge*math.huge
				setsimulationradius(math.huge*math.huge,math.huge*math.huge)
			end
		end)
		function Align(Part1,Part0,Position,Angle,name)
			local AlignPos = Instance.new("AlignPosition", Part1);
			AlignPos.Parent.CanCollide = false;
			AlignPos.ApplyAtCenterOfMass = true;
			AlignPos.MaxForce = 67752;
			AlignPos.MaxVelocity = math.huge/9e110;
			AlignPos.ReactionForceEnabled = false;
			AlignPos.Responsiveness = 200;
			AlignPos.RigidityEnabled = false;

			local AlignOrient = Instance.new("AlignOrientation", Part1);
			AlignOrient.MaxAngularVelocity = math.huge/9e110;
			AlignOrient.MaxTorque = 67752;
			AlignOrient.PrimaryAxisOnly = false;
			AlignOrient.ReactionTorqueEnabled = false;
			AlignOrient.Responsiveness = 200;
			AlignOrient.RigidityEnabled = false;

			local AttachmentA=Instance.new("Attachment",Part1);

			local AttachmentB=Instance.new("Attachment",Part0);
			AttachmentB.Orientation = Angle
			AttachmentB.Position = Position
			AttachmentB.Name = name

			AlignPos.Attachment0 = AttachmentA;
			AlignPos.Attachment1 = AttachmentB;

			AlignOrient.Attachment0 = AttachmentA;
			AlignOrient.Attachment1 = AttachmentB;
		end
		char = game.Players.LocalPlayer.Character
		char.Torso["Right Shoulder"]:Destroy();char.Torso["Left Shoulder"]:Destroy();
		Align(char["Right Arm"],char["Torso"],Vector3.new(1.3, 1, 0.4),Vector3.new(-90, 0, 0),"RA")
		Align(char["Left Arm"],char["Torso"],Vector3.new(-1, 1, 0.4),Vector3.new(-90, 0, 0),"LA")
		wait(0.4)
		char.Humanoid.WalkSpeed = 50

	elseif cht:match(".r6 pp")then
		--R15pp
		spawn(function()
			while wait() do
				settings().Physics.AllowSleep = false
				game.Players.LocalPlayer.MaximumSimulationRadius = math.huge*math.huge
				setsimulationradius(math.huge*math.huge,math.huge*math.huge)
			end
		end)
		function Align(Part1,Part0,Position,Angle,name)
			local AlignPos = Instance.new("AlignPosition", Part1);
			AlignPos.Parent.CanCollide = false;
			AlignPos.ApplyAtCenterOfMass = true;
			AlignPos.MaxForce = 67752;
			AlignPos.MaxVelocity = math.huge/9e110;
			AlignPos.ReactionForceEnabled = false;
			AlignPos.Responsiveness = 200;
			AlignPos.RigidityEnabled = false;

			local AlignOrient = Instance.new("AlignOrientation", Part1);
			AlignOrient.MaxAngularVelocity = math.huge/9e110;
			AlignOrient.MaxTorque = 67752;
			AlignOrient.PrimaryAxisOnly = false;
			AlignOrient.ReactionTorqueEnabled = false;
			AlignOrient.Responsiveness = 200;
			AlignOrient.RigidityEnabled = false;

			local AttachmentA=Instance.new("Attachment",Part1);

			local AttachmentB=Instance.new("Attachment",Part0);
			AttachmentB.Orientation = Angle
			AttachmentB.Position = Position
			AttachmentB.Name = name

			AlignPos.Attachment0 = AttachmentA;
			AlignPos.Attachment1 = AttachmentB;

			AlignOrient.Attachment0 = AttachmentA;
			AlignOrient.Attachment1 = AttachmentB;
		end
		char = game.Players.LocalPlayer.Character
		pal = char["Pal Hair"]
		meshy = char ["MeshPartAccessory"]
		cool = char["CoolBoyHair"]
		girl = char["LongStraightHair"]
		pal.Handle.AccessoryWeld:destroy();meshy.Handle.AccessoryWeld:destroy();girl.Handle.AccessoryWeld:destroy();cool.Handle.AccessoryWeld:destroy();
		Align(pal.Handle,char["Torso"],Vector3.new(-0.2, -1.4, -3.5),Vector3.new(0, 0, 0),"Pal")
		Align(cool.Handle,char["Torso"],Vector3.new(-0.2, -1.4, -2.4),Vector3.new(-90, 0, 100),"cool")
		Align(girl.Handle,char["Torso"],Vector3.new(-0.2, -1.4, -1.3),Vector3.new(0, 0, 90),"girly")
		Align(meshy.Handle,char["Torso"],Vector3.new(-0.2, -1.4, -5),Vector3.new(90, 0, 0),"meshy")
		wait(2)
		brian = char["Pal Hair"].Handle.Mesh
		brian:Destroy()
		lilie = char["MeshPartAccessory"].Handle.SpecialMesh
		lilie:Destroy()
		banda = char["LongStraightHair"].Handle.Mesh
		banda:Destroy()
		licon = char["CoolBoyHair"].Handle.Mesh
		licon:Destroy()
		wait(0.8)
		char.Humanoid.WalkSpeed = 30

	elseif cht:match(".r15 naruto run") then
		--R15Naruto run
		spawn(function()
			while wait() do
				settings().Physics.AllowSleep = false
				game.Players.LocalPlayer.MaximumSimulationRadius = math.huge*math.huge
				setsimulationradius(math.huge*math.huge,math.huge*math.huge)
			end
		end)
		function Align(Part1,Part0,Position,Angle,name)
			local AlignPos = Instance.new("AlignPosition", Part1);
			AlignPos.Parent.CanCollide = false;
			AlignPos.ApplyAtCenterOfMass = true;
			AlignPos.MaxForce = 67752;
			AlignPos.MaxVelocity = math.huge/9e110;
			AlignPos.ReactionForceEnabled = false;
			AlignPos.Responsiveness = 200;
			AlignPos.RigidityEnabled = false;

			local AlignOrient = Instance.new("AlignOrientation", Part1);
			AlignOrient.MaxAngularVelocity = math.huge/9e110;
			AlignOrient.MaxTorque = 67752;
			AlignOrient.PrimaryAxisOnly = false;
			AlignOrient.ReactionTorqueEnabled = false;
			AlignOrient.Responsiveness = 200;
			AlignOrient.RigidityEnabled = false;

			local AttachmentA=Instance.new("Attachment",Part1);

			local AttachmentB=Instance.new("Attachment",Part0);
			AttachmentB.Orientation = Angle
			AttachmentB.Position = Position
			AttachmentB.Name = name

			AlignPos.Attachment0 = AttachmentA;
			AlignPos.Attachment1 = AttachmentB;

			AlignOrient.Attachment0 = AttachmentA;
			AlignOrient.Attachment1 = AttachmentB;
		end
		char = game.Players.LocalPlayer.Character
		char["RightUpperArm"].RightShoulder:Destroy();char["RightLowerArm"].RightElbow:Destroy();char["LeftUpperArm"].LeftShoulder:Destroy();char["LeftLowerArm"].LeftElbow:Destroy();
		Align(char["RightUpperArm"],char["UpperTorso"],Vector3.new(1.3, 0.2, 0.4),Vector3.new(-90, 0, 0),"Arm")
		Align(char["RightLowerArm"],char["UpperTorso"],Vector3.new(1.3, 0.2, 1.2),Vector3.new(-87, 0, 0),"Elbow")
		Align(char["LeftUpperArm"],char["UpperTorso"],Vector3.new(-1, 0.2, 0.4),Vector3.new(-90, 0, 0),"Arm2")
		Align(char["LeftLowerArm"],char["UpperTorso"],Vector3.new(-1, 0.2, 1.2),Vector3.new(-87, 0, 0),"Elbow2")
		wait(2)
		brian = char["Pal Hair"].Handle.Mesh
		brian:Destroy()
		lilie = char["MeshPartAccessory"].Handle.SpecialMesh
		lilie:Destroy()
		banda = char["LongStraightHair"].Handle.Mesh
		banda:Destroy()
		licon = char["CoolBoyHair"].Handle.Mesh
		licon:Destroy()
		char.Humanoid.WalkSpeed = 30

	elseif cht:match(".r15 pp") then
		--R15pp
		spawn(function()
			while wait() do
				settings().Physics.AllowSleep = false
				game.Players.LocalPlayer.MaximumSimulationRadius = math.huge*math.huge
				setsimulationradius(math.huge*math.huge,math.huge*math.huge)
			end
		end)
		function Align(Part1,Part0,Position,Angle,name)
			local AlignPos = Instance.new("AlignPosition", Part1);
			AlignPos.Parent.CanCollide = false;
			AlignPos.ApplyAtCenterOfMass = true;
			AlignPos.MaxForce = 67752;
			AlignPos.MaxVelocity = math.huge/9e110;
			AlignPos.ReactionForceEnabled = false;
			AlignPos.Responsiveness = 200;
			AlignPos.RigidityEnabled = false;

			local AlignOrient = Instance.new("AlignOrientation", Part1);
			AlignOrient.MaxAngularVelocity = math.huge/9e110;
			AlignOrient.MaxTorque = 67752;
			AlignOrient.PrimaryAxisOnly = false;
			AlignOrient.ReactionTorqueEnabled = false;
			AlignOrient.Responsiveness = 200;
			AlignOrient.RigidityEnabled = false;

			local AttachmentA=Instance.new("Attachment",Part1);

			local AttachmentB=Instance.new("Attachment",Part0);
			AttachmentB.Orientation = Angle
			AttachmentB.Position = Position
			AttachmentB.Name = name

			AlignPos.Attachment0 = AttachmentA;
			AlignPos.Attachment1 = AttachmentB;

			AlignOrient.Attachment0 = AttachmentA;
			AlignOrient.Attachment1 = AttachmentB;
		end
		char = game.Players.LocalPlayer.Character
		pal = char["Pal Hair"]
		meshy = char ["MeshPartAccessory"]
		cool = char["CoolBoyHair"]
		girl = char["LongStraightHair"]
		pal.Handle.AccessoryWeld:destroy();meshy.Handle.AccessoryWeld:destroy();girl.Handle.AccessoryWeld:destroy();cool.Handle.AccessoryWeld:destroy();
		Align(pal.Handle,char["UpperTorso"],Vector3.new(-0.2, -1.4, -3.5),Vector3.new(0, 0, 0),"Pal")
		Align(cool.Handle,char["UpperTorso"],Vector3.new(-0.2, -1.4, -2.4),Vector3.new(-90, 0, 100),"cool")
		Align(girl.Handle,char["UpperTorso"],Vector3.new(-0.2, -1.4, -1.3),Vector3.new(0, 0, 90),"girly")
		Align(meshy.Handle,char["UpperTorso"],Vector3.new(-0.2, -1.4, -5),Vector3.new(90, 0, 0),"meshy")
		wait(2)
		brian = char["Pal Hair"].Handle.Mesh
		brian:Destroy()
		lilie = char["MeshPartAccessory"].Handle.SpecialMesh
		lilie:Destroy()
		banda = char["LongStraightHair"].Handle.Mesh
		banda:Destroy()
		licon = char["CoolBoyHair"].Handle.Mesh
		licon:Destroy()
		wait(0.8)
		char.Humanoid.WalkSpeed = 25

elseif cht:match(".iy") then
	-- IY
	loadstring(game:HttpGet('https://raw.githubusercontent.com/EdgeIY/infiniteyield/master/source'))()

elseif cht:match(".spiderman") then
	--[[
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")

elseif cht:match(".replicated mesh") then
	local screenGui = game:GetObjects("rbxassetid://3546404827")[1]
	local mainFrame = screenGui.Frame
	local pages = mainFrame.Pages
	local pageLayout = pages.UIPageLayout
	local pageScripts = pages.Scripts
	local interactiveButton = pageScripts.Character.Elements.TextButton
	local utility = pageScripts.Utility
	local utilityElements = utility.Elements
	local pageOptions = pages.Options
	local titleFrame = mainFrame.Title
	local toolbar = mainFrame.Toolbar

	screenGui.LocalScript:Destroy()
	screenGui.Parent = game:GetService("CoreGui")
	interactiveButton.Parent = nil
	mainFrame.Visible = true

	gripCenter = CFrame.new(0, 0, 1) * CFrame.Angles(math.rad(90), 0, 0)
	offset = CFrame.Angles(0, 0, 0)

	_player = {
		p = game:GetService("Players").LocalPlayer;
		b = function()
			return _player.p:FindFirstChild("Backpack")
		end;
		c = function()
			return _player.p.Character
		end;
	}
	_functions = {
		respawn = function()
			local c = _player.c()
			if workspace:FindFirstChild(_player.p.Name) then
				spawn(function()
					wait(.5)
					if _player.c() ~= workspace:FindFirstChild(_player.p.Name) then
						workspace:FindFirstChild(_player.p.Name):BreakJoints()
					end
				end)
			end
			if c then
				c:BreakJoints()
				c:ClearAllChildren()
			end
			local newChar = Instance.new("Model", workspace)
			local hum = Instance.new("Humanoid", newChar)
			local torso = Instance.new("Part", newChar)
			newChar.Name = "respawn_"
			torso.Name = "Torso"
			torso.Transparency = 1
			_player.p.Character = newChar
			torso.Name = ""
			torso.CanCollide = false
			newChar:MoveTo(Vector3.new(999999, 999999, 999999))
		end;
		tools = function(int)
			local toolamount = int or 200

			local LocalPlayer = game:GetService("Players").LocalPlayer
			local runservice = game:GetService("RunService")
			LocalPlayer.Character:FindFirstChild("Humanoid"):UnequipTools()
			local currentamount = #LocalPlayer.Backpack:GetChildren()
			LocalPlayer.Character.Archivable = true
			local tempchar = LocalPlayer.Character:Clone()
			local lastchar = nil
			tempchar.Parent = workspace
			local savepos = LocalPlayer.Character:FindFirstChild("HumanoidRootPart").CFrame
			local renderstepped = runservice.RenderStepped:Connect(function()
				workspace.CurrentCamera.CameraSubject = tempchar:FindFirstChild("Humanoid")
				for _, tool in pairs(LocalPlayer.Backpack:GetChildren()) do
					if tool:IsA("Tool") then
						tool.Parent = LocalPlayer
					end
				end
				for _, char in pairs(workspace:GetChildren()) do
					if char.Name == LocalPlayer.Name and char:FindFirstChildWhichIsA("Humanoid") then
						char.Humanoid.Health = 0
					end
				end
				LocalPlayer.Character:ClearAllChildren()
				local char = Instance.new("Model", workspace)
				Instance.new("Humanoid", char)
				LocalPlayer.Character = char
				if lastchar ~= nil then
					lastchar:Destroy()
				end
				repeat runservice.RenderStepped:Wait() until LocalPlayer.Character ~= nil
				lastchar = char
			end)
			repeat runservice.RenderStepped:Wait() until #LocalPlayer:GetChildren() - 3 - currentamount >= toolamount
			renderstepped:Disconnect()
			repeat runservice.RenderStepped:Wait() until LocalPlayer.Character:FindFirstChild("HumanoidRootPart") ~= nil
			lastchar:Destroy()

			utilityElements.Tools.Text = "Done respawning?"
			repeat runservice.RenderStepped:Wait() until utilityElements.Tools.Text == "Load Tools"

			for _, tool in pairs(LocalPlayer:GetChildren()) do
				if tool:IsA("Tool") then
					tool.Parent = LocalPlayer.Backpack
				end
			end
			LocalPlayer.Character:FindFirstChild("HumanoidRootPart").CFrame = savepos
			tempchar:Destroy()
		end;
		load = function()
			local b = _player.b()
			local c = _player.c()
			local grip = function(tool, cf)
				local origin = CFrame.new(cf.p)
				local x, y, z = cf:toEulerAnglesXYZ()
				local new = CFrame.Angles(x, y, z)
				local grip = (origin * new):inverse()
				tool.Grip = grip
			end
			local model = c:WaitForChild("gay") -- stupid name choice from what a few months ago?? i have nothing against it i swear
			local parts = {}
			wait(1)

			for i, Model in pairs(c:GetChildren()) do
				if Model:IsA("Model") and Model.Name == "gay" then
					for i, v in pairs(Model:GetDescendants()) do
						if v:IsA("BasePart") then
							v.LocalTransparencyModifier = 1
							if v.Name ~= "Ignore" then
								table.insert(parts, v)
							end
						end
						if not v:IsA("BasePart") and not v:IsA("JointInstance") and not v:IsA("BodyMover") and not v:isA("Humanoid") and not v:IsA("Model") then
							v:Remove()
						end
					end
					Model.ChildAdded:Connect(function(c)
						c.Parent = nil
					end)
				end
			end

			for _, part in pairs(parts) do
				local m = Instance.new("BlockMesh", part)
				m.Scale = Vector3.new(0, 0, 0)
			end

			local tools = b:GetChildren()
			for i, tool in pairs(tools) do
				if tool.Parent then
					wrap(function()
						tool.Parent = c
						for i, v in pairs(tool:GetDescendants()) do
							if v:IsA("Sound") or v:IsA("TouchTransmitter") then
								v:Destroy()
							elseif v:IsA("BasePart") then
								v.Massless = true
								v.CanCollide = false
							elseif v:IsA("LocalScript") or v:IsA("Script") then
								v:Destroy()
							end
						end

						if tool:FindFirstChild("Handle") then
							local handle = tool.Handle
							local fakeHandle = handle:Clone()
							fakeHandle.Name = "FakeHandle"
							fakeHandle.Parent = tool
							local w = Instance.new("Weld", handle)
							w.Part0 = fakeHandle
							w.Part1 = handle
							handle.Size = Vector3.new(0, 0, 0)
						end

						tool.Parent = b
					end)
				end
				if (not parts[i]) then
					tools[i] = nil
					tool:Destroy()
				end
			end

			wait(.2)
			local amt = #tools

			wrap(function()
				local connection1

				connection1 = game:GetService("RunService").RenderStepped:Connect(function(step)
					for i = 1, amt do
						local tool = tools[i]
						if parts[i] then
							tool.Parent = b
							tool.Parent = c
						end
					end

					if _player.c() ~= c or c:FindFirstChildWhichIsA("Humanoid").Health == 0 then
						connection1:Disconnect()
					end

					utilityElements.Replicate.Text = ("Replicate (%dfps)"):format(1/step)
				end)
			end)

			local connection2
			connection2 = game:GetService("RunService").Heartbeat:Connect(function()
				for i = 1, amt do
					local tool = tools[i]
					if parts[i] then
						if parts[i].Transparency ~= 1 then
							local p = _cframe.toWorldPoint(parts[i].CFrame) * offset
							grip(tool, p)
						else
							local p = _cframe.toWorldPoint(CFrame.new(0, -250, 0))
							grip(tool, p)
						end
					end
				end
				if _player.c() ~= c or c:FindFirstChildWhichIsA("Humanoid").Health == 0 then
					connection2:Disconnect()
				end
			end)
		end;
	}
	_cframe = {
		diff = function(a, b)
			return (a:Inverse() * b)
		end;
		toWorldPoint = function(a)
			local arm = _player.c():FindFirstChild('Right Arm') or _player.c():FindFirstChild('RightHand')
			local off = arm.CFrame * gripCenter:Inverse()
			if arm.Name == "RightHand" then
				off = arm.CFrame * CFrame.Angles(math.rad(-90), 0, 0)
			end
			return _cframe.diff(off, a)
		end;
		tween = function(object,style,direction,t,goal)
			local tweenservice = game:GetService("TweenService")
			local tweenInfo = TweenInfo.new(t,Enum.EasingStyle[style],Enum.EasingDirection[direction])
			local tween = tweenservice:Create(object,tweenInfo,goal)
			tween:Play()
			return tween
		end;
	}
	scriptList = {
		Character = {
			['Titan']			= {"rbxassetid://3600286284", "rbxassetid://3070358214"};
			['Winged Titan']	= {"rbxassetid://3593786550", "rbxassetid://3070358214"};
			['Part Surround']	= {"rbxassetid://3546680077", "rbxassetid://3546673786"};
		},
		Mechanical = {
			['Spiderbot']		= {"rbxassetid://3040869607", "rbxassetid://3070355648"};
			['Drone']			= {"rbxassetid://3074236927", "rbxassetid://3074245958"};
			['Noise']			= {"rbxassetid://3193712297", "rbxassetid://3070358314"};
		},
		Aesthetic = {
			['Wings']			= {"rbxassetid://3040946714", "rbxassetid://3070358381"};
			['Tail']			= {"rbxassetid://3041387168", "rbxassetid://3070358314"};
			['Star Glitcher']	= {"rbxassetid://3074734519", "rbxassetid://3074751071"};
			['Tentacles']		= {"rbxassetid://3074817074", "rbxassetid://3074820325"};
		},
		Weapon = {
			['Master Hand']		= {"rbxassetid://3040943596", "rbxassetid://3070358267"};
			['Ravenger']		= {"rbxassetid://3040945482", "rbxassetid://3070358154"};
		},
	}
	wrap = function(f)
		return coroutine.wrap(f)()
	end

	if game:GetService("RunService"):IsStudio() then
		guiLib = require(screenGui.GuiLib)
	else
		guiLib = loadstring(screenGui.GuiLib.Source)()
	end

	for title, tbl in pairs(scriptList) do
		local frame = pageScripts[title]
		for name, info in pairs(tbl) do
			local btn = interactiveButton:Clone()
			btn.Name = name
			btn.Text = name
			btn.Parent = frame.Elements
			btn.Icon.Image = info[2]

			guiLib.circleInteractive(btn)
			guiLib.colorInteractive(btn)

			btn.MouseButton1Click:Connect(function()
				local scr = game:GetObjects(info[1])[1]
				local source = scr.Source

				if game:GetService("RunService"):IsStudio() == false then
					for i, v in pairs(scr:GetChildren()) do
						v.Parent = script
					end
					wrap(function()
						local func = loadstring(source)
						spawn(func)
					end)
				else
					scr.Disabled = true
					scr.Parent = _player.c()
					wait(.1)
					scr.Disabled = false
				end
			end)
		end
	end

	repeat wait() until pageLayout.CurrentPage

	guiLib.draggable(mainFrame, titleFrame)
	for i, v in pairs(toolbar:GetChildren()) do
		if v:IsA("TextButton") then
			guiLib.circleInteractive(v, 2, 1)
			v.MouseButton1Click:Connect(function()
				pageLayout:JumpTo(pages[v.Name])
			end)
			pageLayout.Changed:Connect(function(p)
				if pageLayout.CurrentPage.Name == v.Name then
					guiLib.tween(v, "Sine", "Out", .5, {BackgroundColor3 = Color3.fromRGB(255, 118, 26)})
				else
					guiLib.tween(v, "Sine", "Out", .5, {BackgroundColor3 = Color3.fromRGB(236, 109, 17)})
				end
			end)
		end
	end

	for i, v in pairs(utilityElements:GetChildren()) do
		if v:IsA("TextButton") then
			guiLib.circleInteractive(v)
			guiLib.colorInteractive(v)
		end
	end

	utilityElements.Reset.MouseButton1Click:Connect(function()
		local c = _player.c()
		c.Humanoid.Health = 0
		wait(.55)
		for i, v in pairs(c:GetChildren()) do
			if v:IsA("BackpackItem") then
				v.Parent = _player.b()
				v.Parent = _player.p
			end
		end
		repeat wait() until _player.c() ~= c
		_player.c():WaitForChild("Right Arm")
		wait(.25)
		for i, v in pairs(_player.p:GetChildren()) do
			if v:IsA("Tool") then
				v.Parent = _player.b()
			end
		end
	end)

	utilityElements.Block.MouseButton1Click:Connect(function()
		local c = _player.c()
		for _, v in pairs(c:GetChildren()) do
			if v:IsA("BackpackItem") then
				for _, m in pairs(v:GetDescendants()) do
					if m:IsA("DataModelMesh") then
						m:Destroy()
					end
				end
			end
		end
	end)

	local noclip = false
	utilityElements.Noclip.MouseButton1Click:Connect(function()
		noclip = not noclip
	end)

	utilityElements.Tools.MouseButton1Click:Connect(function()
		if utilityElements.Tools.Text == "Load Tools" then
			_functions.tools(120)
		else
			utilityElements.Tools.Text = "Load Tools"
		end
	end)

	utilityElements.Replicate.MouseButton1Click:Connect(function()
		_functions.load()
	end)

	local flipped = 0
	utilityElements.Flip.MouseButton1Click:Connect(function()
		flipped = (flipped + 1) % 4
		if flipped == 0 then
			offset = CFrame.Angles(0, 0, 0)
		elseif flipped == 1 then
			offset = CFrame.Angles(math.rad(90), 0, 0)
		elseif flipped == 2 then
			offset = CFrame.Angles(0, math.rad(90), 0)
		elseif flipped == 3 then
			offset = CFrame.Angles(0, 0, math.rad(90))
		end
	end)

	game:GetService("RunService").Stepped:Connect(function()
		local c = _player.c()
		if noclip then
			local descendants = c:GetDescendants()
			for i = 1, #descendants do
				local v = descendants[i]
				if v:IsA("BasePart") and v.Name ~= "HumanoidRootPart" then
					v.CanCollide = false
				end
			end
		end
	end)

	workspace:WaitForChild("S")

elseif cht:match(".problem") then
    local ProblemsGUI = Instance.new("ScreenGui")
local Problem = Instance.new("ImageLabel")
local Close = Instance.new("TextButton")

ProblemsGUI.Name = "ProblemsGUI"
ProblemsGUI.Parent = game.CoreGui
ProblemsGUI.ZIndexBehavior = Enum.ZIndexBehavior.Sibling

Problem.Name = "Problem"
Problem.Parent = ProblemsGUI
Problem.BackgroundColor3 = Color3.new(1, 1, 1)
Problem.Position = UDim2.new(0.313868612, 0, 0.0322580636, 0)
Problem.Size = UDim2.new(0, 495, 0, 376)
Problem.Image = "rbxassetid://6308255604"

Close.Name = "Close"
Close.Parent = Problem
Close.BackgroundColor3 = Color3.new(1, 1, 1)
Close.Position = UDim2.new(0.886868715, 0, 0.0797872394, 0)
Close.Size = UDim2.new(0, 56, 0, 41)
Close.Font = Enum.Font.SourceSans
Close.Text = "Close"
Close.TextColor3 = Color3.new(0, 0, 0)
Close.TextScaled = true
Close.TextSize = 14
Close.TextWrapped = true
Close.MouseButton1Click:connect(function()
	Problem.Visible = false
end)

elseif cht:match(".commands") then
local Commands = Instance.new("ScreenGui")
local commands = Instance.new("ImageLabel")
local Close = Instance.new("TextButton")

Commands.Name = "Commands"
Commands.Parent = game.CoreGui
Commands.ZIndexBehavior = Enum.ZIndexBehavior.Sibling

commands.Name = "commands"
commands.Parent = Commands
commands.BackgroundColor3 = Color3.new(1, 1, 1)
commands.Position = UDim2.new(0.182481751, 0, 0.130929798, 0)
commands.Size = UDim2.new(0, 491, 0, 388)
commands.Image = "rbxassetid://6308468091"

Close.Name = "Close"
Close.Parent = commands
Close.BackgroundColor3 = Color3.new(1, 1, 1)
Close.Position = UDim2.new(0.883910358, 0, 0.164948449, 0)
Close.Size = UDim2.new(0, 57, 0, 59)
Close.Font = Enum.Font.SourceSans
Close.Text = "Close"
Close.TextColor3 = Color3.new(0, 0, 0)
Close.TextSize = 14
Close.MouseButton1Click:connect(function()
	commands.Visible = false
end)

elseif cht:match(".discord") then
local DiscordGUI = Instance.new("ScreenGui")
local DIscord = Instance.new("TextLabel")
local Clos = Instance.new("TextButton")

DiscordGUI.Name = "DiscordGUI"
DiscordGUI.Parent = game.CoreGui
DiscordGUI.ZIndexBehavior = Enum.ZIndexBehavior.Sibling

DIscord.Name = "DIscord"
DIscord.Parent = DiscordGUI
DIscord.BackgroundColor3 = Color3.new(1, 1, 1)
DIscord.Position = UDim2.new(0.478102177, 0, 0.527514219, 0)
DIscord.Size = UDim2.new(0, 276, 0, 140)
DIscord.Font = Enum.Font.SourceSans
DIscord.Text = "Discord: ruth#3661"
DIscord.TextColor3 = Color3.new(0, 0, 0)
DIscord.TextScaled = true
DIscord.TextSize = 14
DIscord.TextWrapped = true

Clos.Name = "Clos"
Clos.Parent = DIscord
Clos.BackgroundColor3 = Color3.new(1, 1, 1)
Clos.Position = UDim2.new(0.833333373, 0, 0, 0)
Clos.Size = UDim2.new(0, 46, 0, 39)
Clos.Font = Enum.Font.SourceSans
Clos.Text = "X"
Clos.TextColor3 = Color3.new(0.0117647, 1, 0.454902)
Clos.TextScaled = true
Clos.TextSize = 14
Clos.TextWrapped = true
Clos.MouseButton1Click:connect(function()
	DIscord.Visible = false
end)
	end
end)