add gs

RCCService2020/ExtraContent/scripts/PlayerScripts/.robloxrc

@@ -0,0 +1,14 @@
+{
+	"lint": {
+		"MultiLineStatement": "disabled",
+		"DeprecatedGlobal": "fatal",
+		"LocalShadow": "disabled",
+		"LocalUnused": "disabled",
+		"FunctionUnused": "disabled",
+		"ImportUnused": "disabled",
+		"SameLineStatement": "fatal",
+		"ImplicitReturn": "disabled",
+		"UnknownGlobal": "fatal",
+		"GlobalUsedAsLocal": "fatal"
+	}
+}

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterCharacterScripts/.robloxrc

@@ -0,0 +1,8 @@
+{
+	"lint": {
+		"LocalUnused": "fatal",
+		"FunctionUnused": "fatal",
+		"ImportUnused": "fatal",
+		"ImplicitReturn": "fatal"
+	}
+}

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript.lua

@@ -0,0 +1,268 @@
+local RunService = game:GetService('RunService')
+local UserInputService = game:GetService('UserInputService')
+local PlayersService = game:GetService('Players')
+local VRService = game:GetService("VRService")
+local StarterPlayer = game:GetService('StarterPlayer')
+
+
+local RootCamera = script:WaitForChild('RootCamera')
+
+local AttachCamera = require(RootCamera:WaitForChild('AttachCamera'))()
+local FixedCamera = require(RootCamera:WaitForChild('FixedCamera'))()
+local ScriptableCamera = require(RootCamera:WaitForChild('ScriptableCamera'))()
+local TrackCamera = require(RootCamera:WaitForChild('TrackCamera'))()
+local WatchCamera = require(RootCamera:WaitForChild('WatchCamera'))()
+
+local OrbitalCamera = require(RootCamera:WaitForChild('OrbitalCamera'))()
+local ClassicCamera = require(RootCamera:WaitForChild('ClassicCamera'))()
+local FollowCamera = require(RootCamera:WaitForChild('FollowCamera'))()
+local PopperCam = require(script:WaitForChild('PopperCam'))
+local Invisicam = require(script:WaitForChild('Invisicam'))
+local TransparencyController = require(script:WaitForChild('TransparencyController'))()
+
+local VRCamera = require(RootCamera:WaitForChild("VRCamera"))()
+
+local GameSettings = UserSettings().GameSettings
+
+-- register what camera scripts we are using
+do
+	local PlayerScripts = PlayersService.LocalPlayer:WaitForChild("PlayerScripts")
+	local canRegisterCameras = pcall(function() PlayerScripts:RegisterTouchCameraMovementMode(Enum.TouchCameraMovementMode.Default) end)
+
+	if canRegisterCameras then
+		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)
+	end
+end
+
+local CameraTypeEnumMap = 
+{
+	[Enum.CameraType.Attach] = AttachCamera;
+	[Enum.CameraType.Fixed] = FixedCamera;
+	[Enum.CameraType.Scriptable] = ScriptableCamera;
+	[Enum.CameraType.Track] = TrackCamera;
+	[Enum.CameraType.Watch] = WatchCamera;
+	[Enum.CameraType.Follow] = FollowCamera;
+	[Enum.CameraType.Orbital] = OrbitalCamera;
+}
+
+local EnabledCamera = nil
+local EnabledOcclusion = nil
+
+local cameraSubjectChangedConn = nil
+local cameraTypeChangedConn = nil
+local renderSteppedConn = nil
+
+local lastInputType = nil
+local hasLastInput = false
+
+local function IsTouch()
+	return UserInputService.TouchEnabled
+end
+
+local function isClickToMoveOn()
+	local player = PlayersService.LocalPlayer
+	if player then
+		if (hasLastInput and lastInputType == Enum.UserInputType.Touch) or IsTouch() then -- Touch
+			if player.DevTouchMovementMode == Enum.DevTouchMovementMode.ClickToMove or
+					(player.DevTouchMovementMode == Enum.DevTouchMovementMode.UserChoice and GameSettings.TouchMovementMode == Enum.TouchMovementMode.ClickToMove) then
+				return true
+			end
+		else -- Computer
+			if player.DevComputerMovementMode == Enum.DevComputerMovementMode.ClickToMove or
+					(player.DevComputerMovementMode == Enum.DevComputerMovementMode.UserChoice and GameSettings.ComputerMovementMode == Enum.ComputerMovementMode.ClickToMove) then
+				return true
+			end
+		end
+	end
+	return false
+end
+
+local function getCurrentCameraMode()
+	local player = PlayersService.LocalPlayer
+	if player then
+		if (hasLastInput and lastInputType == Enum.UserInputType.Touch) or IsTouch() then -- Touch (iPad, etc...)
+			if player.DevTouchCameraMode == Enum.DevTouchCameraMovementMode.UserChoice then
+				local touchMovementMode = GameSettings.TouchCameraMovementMode
+				if touchMovementMode == Enum.TouchCameraMovementMode.Default then
+					return Enum.TouchCameraMovementMode.Follow.Name
+				end
+				return touchMovementMode.Name
+			else
+				return player.DevTouchCameraMode.Name
+			end
+		else -- Computer
+			if player.DevComputerCameraMode == Enum.DevComputerCameraMovementMode.UserChoice then
+				local computerMovementMode = GameSettings.ComputerCameraMovementMode
+				if computerMovementMode == Enum.ComputerCameraMovementMode.Default then
+					return Enum.ComputerCameraMovementMode.Classic.Name
+				end
+				return computerMovementMode.Name
+			else
+				return player.DevComputerCameraMode.Name
+			end
+		end
+	end
+end
+
+local function getCameraOcclusionMode()
+	local player = PlayersService.LocalPlayer
+	if player then
+		return player.DevCameraOcclusionMode
+	end
+end
+
+local function shouldUseOcclusionModule()
+	local player = PlayersService.LocalPlayer
+	if player and game.Workspace.CurrentCamera and game.Workspace.CurrentCamera.CameraType == Enum.CameraType.Custom then
+		return true
+	end
+	return false
+end
+
+local function Update()
+	if EnabledCamera then
+		EnabledCamera:Update()
+	end
+	if EnabledOcclusion and not VRService.VREnabled then
+		EnabledOcclusion:Update(EnabledCamera)
+	end
+	TransparencyController:Update()
+end
+
+local function SetEnabledCamera(newCamera)
+	if EnabledCamera ~= newCamera then
+		if EnabledCamera then
+			EnabledCamera:SetEnabled(false)
+		end
+		EnabledCamera = newCamera
+		if EnabledCamera then
+			EnabledCamera:SetEnabled(true)
+		end
+	end
+end
+
+local function OnCameraMovementModeChange(newCameraMode)
+	if newCameraMode ~= Enum.DevComputerMovementMode.ClickToMove.Name then
+		local currentCameraType = workspace.CurrentCamera and workspace.CurrentCamera.CameraType
+		if VRService.VREnabled and currentCameraType ~= Enum.CameraType.Scriptable then
+			SetEnabledCamera(VRCamera)
+			TransparencyController:SetEnabled(false)		
+		elseif currentCameraType == Enum.CameraType.Custom and newCameraMode == Enum.ComputerCameraMovementMode.Classic.Name then
+			SetEnabledCamera(ClassicCamera)			
+			TransparencyController:SetEnabled(true)
+		elseif currentCameraType == Enum.CameraType.Custom and newCameraMode == Enum.ComputerCameraMovementMode.Follow.Name then
+			SetEnabledCamera(FollowCamera)
+			TransparencyController:SetEnabled(true)
+		elseif currentCameraType == Enum.CameraType.Custom and newCameraMode == Enum.ComputerCameraMovementMode.Orbital.Name then
+			SetEnabledCamera(OrbitalCamera)
+			TransparencyController:SetEnabled(true)
+		elseif CameraTypeEnumMap[currentCameraType] then
+			SetEnabledCamera(CameraTypeEnumMap[currentCameraType])
+			TransparencyController:SetEnabled(false)
+		else -- Our camera movement code was disabled by the developer
+			SetEnabledCamera(nil)
+			TransparencyController:SetEnabled(false)
+		end
+	end
+	
+	local useOcclusion = shouldUseOcclusionModule()
+	local newOcclusionMode = getCameraOcclusionMode()
+	if EnabledOcclusion == Invisicam and (newOcclusionMode ~= Enum.DevCameraOcclusionMode.Invisicam or (not useOcclusion)) then
+		Invisicam:Cleanup()
+	end
+	
+	-- PopperCam does not work with OrbitalCamera, as OrbitalCamera's distance can be fixed.
+	if useOcclusion then	
+		if newOcclusionMode == Enum.DevCameraOcclusionMode.Zoom and newCameraMode ~= Enum.ComputerCameraMovementMode.Orbital.Name then
+			EnabledOcclusion = PopperCam
+		elseif newOcclusionMode == Enum.DevCameraOcclusionMode.Invisicam then
+			EnabledOcclusion = Invisicam
+		else
+			EnabledOcclusion = nil
+		end
+	else
+		EnabledOcclusion = nil
+	end
+end
+
+local function OnCameraTypeChanged(newCameraType)
+	if newCameraType == Enum.CameraType.Scriptable then
+		UserInputService.MouseBehavior = Enum.MouseBehavior.Default
+	end
+end
+
+
+local function OnCameraSubjectChanged(newSubject)
+	TransparencyController:SetSubject(newSubject)
+end
+
+local function OnNewCamera()
+	OnCameraMovementModeChange(getCurrentCameraMode())
+
+	local currentCamera = workspace.CurrentCamera
+	if currentCamera then
+		if cameraSubjectChangedConn then
+			cameraSubjectChangedConn:disconnect()
+  		end
+
+		if cameraTypeChangedConn then
+			cameraTypeChangedConn:disconnect()
+		end
+
+		cameraSubjectChangedConn = currentCamera:GetPropertyChangedSignal("CameraSubject"):connect(function()
+			OnCameraSubjectChanged(currentCamera.CameraSubject)
+		end)
+	
+		cameraTypeChangedConn = currentCamera:GetPropertyChangedSignal("CameraType"):connect(function()
+			OnCameraMovementModeChange(getCurrentCameraMode())
+			OnCameraTypeChanged(currentCamera.CameraType)
+  		end)
+
+		OnCameraSubjectChanged(currentCamera.CameraSubject)
+		OnCameraTypeChanged(currentCamera.CameraType)
+	end
+end
+
+
+local function OnPlayerAdded(player)
+	workspace.Changed:connect(function(prop)
+		if prop == 'CurrentCamera' then
+			OnNewCamera()
+		end
+	end)
+
+	player.Changed:connect(function(prop)
+		OnCameraMovementModeChange(getCurrentCameraMode())
+	end)
+
+	GameSettings.Changed:connect(function(prop)
+		OnCameraMovementModeChange(getCurrentCameraMode())
+	end)
+
+	RunService:BindToRenderStep("cameraRenderUpdate", Enum.RenderPriority.Camera.Value, Update)
+
+	OnNewCamera()
+	OnCameraMovementModeChange(getCurrentCameraMode())
+end
+
+do
+	while PlayersService.LocalPlayer == nil do PlayersService.PlayerAdded:wait() end
+	hasLastInput = pcall(function()
+		lastInputType = UserInputService:GetLastInputType()
+		UserInputService.LastInputTypeChanged:connect(function(newLastInputType) 
+			lastInputType = newLastInputType
+		end)
+	end)
+	OnPlayerAdded(PlayersService.LocalPlayer)
+end
+
+local function OnVREnabled()
+	OnCameraMovementModeChange(getCurrentCameraMode())
+end
+
+VRService:GetPropertyChangedSignal("VREnabled"):connect(OnVREnabled)

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/.robloxrc

@@ -0,0 +1,5 @@
+{
+	"lint": {
+		"ImportUnused": "fatal"
+	}
+}

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/Invisicam.lua

@@ -0,0 +1,584 @@
+--[[
+	Invisicam
+	
+	Modified 5.16.2017 by AllYourBlox to consider combined transparency when looking through multiple parts, and to add
+	a mode that takes advantage of the reduced cost of ray casts from re-implementing GetPartsObscuringTarget
+	on the C++ side to be O(N) for N parts hit, rather than O(N^2), and to have optimizations specifically
+	improving performance of closely bundled rays. Fading is also removed, since it is a frame rate killer with high-poly models,
+	and on mobile.
+	
+	Based on Invisicam Version 2.5 by OnlyTwentyCharacters
+--]]
+
+local Invisicam = {}
+---------------
+-- Constants --
+---------------
+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, -- Whatever you want!
+	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,
+}
+
+Invisicam.MODE = MODE
+local STARTING_MODE = MODE.SMART_CIRCLE
+
+local LIMB_TRACKING_SET = {
+	-- Common to R6, R15
+	['Head'] = true,
+	
+	-- R6 Only
+	['Left Arm'] = true,
+	['Right Arm'] = true,
+	['Left Leg'] = true,
+	['Right Leg'] = true,
+	
+	-- R15 Only
+	['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
+
+---------------
+-- Variables --
+---------------
+
+local RunService = game:GetService('RunService')
+local PlayersService = game:GetService('Players')
+local Player = PlayersService.LocalPlayer
+
+local Camera = nil
+local Character = nil
+local HumanoidRootPart = nil
+local TorsoPart = nil
+local HeadPart = nil
+
+local Mode = nil
+local BehaviorFunction = nil
+
+local childAddedConn = nil
+local childRemovedConn = nil
+
+local Behaviors = {} -- Map of modes to behavior fns
+local SavedHits = {} -- Objects currently being faded in/out
+local TrackedLimbs = {} -- Used in limb-tracking casting modes
+
+---------------
+--| Utility |--
+---------------
+
+local math_min = math.min
+local math_max = math.max
+local math_cos = math.cos
+local math_sin = math.sin
+local math_pi = math.pi
+
+local Vector3_new = Vector3.new
+local ZERO_VECTOR3 = Vector3_new(0,0,0)
+
+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
+
+-----------------------
+--| Local Functions |--
+-----------------------
+
+local function LimbBehavior(castPoints)
+	for limb, _ in pairs(TrackedLimbs) do
+		castPoints[#castPoints + 1] = limb.Position
+	end
+end
+
+local function MoveBehavior(castPoints)
+	for i = 1, MOVE_CASTS do
+		local position, velocity = HumanoidRootPart.Position, HumanoidRootPart.Velocity
+		local horizontalSpeed = Vector3_new(velocity.X, 0, velocity.Z).Magnitude / 2
+		local offsetVector = (i - 1) * HumanoidRootPart.CFrame.lookVector * horizontalSpeed
+		castPoints[#castPoints + 1] = position + offsetVector
+	end
+end
+
+local function CornerBehavior(castPoints)
+	local cframe = HumanoidRootPart.CFrame
+	local centerPoint = cframe.p
+	local rotation = cframe - centerPoint
+	local halfSize = Character: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
+
+local function CircleBehavior(castPoints)
+	local cframe = nil
+	if Mode == MODE.CIRCLE1 then
+		cframe = HumanoidRootPart.CFrame
+	else
+		local camCFrame = Camera.CoordinateFrame
+		cframe = camCFrame - camCFrame.p + 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	
+
+local function LimbMoveBehavior(castPoints)
+	LimbBehavior(castPoints)
+	MoveBehavior(castPoints)
+end
+
+local function CharacterOutlineBehavior(castPoints)
+	local torsoUp = TorsoPart.CFrame.upVector.unit
+	local torsoRight = TorsoPart.CFrame.rightVector.unit
+	
+	-- Torso cross of points for interior coverage
+	castPoints[#castPoints + 1] = TorsoPart.CFrame.p
+	castPoints[#castPoints + 1] = TorsoPart.CFrame.p + torsoUp
+	castPoints[#castPoints + 1] = TorsoPart.CFrame.p - torsoUp
+	castPoints[#castPoints + 1] = TorsoPart.CFrame.p + torsoRight
+	castPoints[#castPoints + 1] = TorsoPart.CFrame.p - torsoRight
+	if HeadPart then
+		castPoints[#castPoints + 1] = HeadPart.CFrame.p
+	end
+	
+	local cframe = CFrame.new(ZERO_VECTOR3,Vector3_new(Camera.CoordinateFrame.lookVector.X,0,Camera.CoordinateFrame.lookVector.Z))
+	local centerPoint = (TorsoPart and TorsoPart.Position or HumanoidRootPart.Position)
+	
+	local partsWhitelist = {TorsoPart}
+	if HeadPart then
+		partsWhitelist[#partsWhitelist + 1] = 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
+
+-- Helper function for Determinant of 3x3
+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
+
+local function SmartCircleBehavior(castPoints)
+	local torsoUp = TorsoPart.CFrame.upVector.unit
+	local torsoRight = 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] = TorsoPart.CFrame.p
+	castPoints[#castPoints + 1] = TorsoPart.CFrame.p + torsoUp
+	castPoints[#castPoints + 1] = TorsoPart.CFrame.p - torsoUp
+	castPoints[#castPoints + 1] = TorsoPart.CFrame.p + torsoRight
+	castPoints[#castPoints + 1] = TorsoPart.CFrame.p - torsoRight
+	if HeadPart then
+		castPoints[#castPoints + 1] = HeadPart.CFrame.p
+	end
+	
+	local cameraOrientation = Camera.CFrame - Camera.CFrame.p
+	local torsoPoint = Vector3_new(0,0.5,0) + (TorsoPart and TorsoPart.Position or 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 - Camera.CFrame.p
+		
+		local ray = Ray.new(torsoPoint, circlePoint - torsoPoint)
+		local hit, hp, hitNormal = game.Workspace:FindPartOnRayWithIgnoreList(ray, {Character}, 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 d0 = v0.magnitude
+			
+			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 - 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, {Character}, 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, {Character}, false, false )
+	
+			if hit then
+				local castPoint2 = hitPoint - 0.1 * (castPoint - torsoPoint).unit
+				castPoint = castPoint2	
+			end
+		end
+		
+		castPoints[#castPoints + 1] = castPoint
+	end
+end
+
+local function CheckTorsoReference()
+	if Character then
+		TorsoPart = Character:FindFirstChild("Torso")
+		if not TorsoPart then
+			TorsoPart = Character:FindFirstChild("UpperTorso")
+			if not TorsoPart then
+				TorsoPart = Character:FindFirstChild("HumanoidRootPart")
+			end
+		end
+		
+		HeadPart = Character:FindFirstChild("Head")
+	end
+end
+
+local function OnCharacterAdded(character)
+	if childAddedConn then
+		childAddedConn:disconnect()
+		childAddedConn = nil
+	end
+	if childRemovedConn then
+		childRemovedConn:disconnect()
+		childRemovedConn = nil
+	end
+
+	Character = character
+	
+	TrackedLimbs = {}
+	local function childAdded(child)
+		if child:IsA('BasePart') then
+			if LIMB_TRACKING_SET[child.Name] then
+				TrackedLimbs[child] = true
+			end
+
+			if (child.Name == 'Torso' or child.Name == 'UpperTorso') then
+				TorsoPart = child
+			end
+
+			if (child.Name == 'Head') then
+				HeadPart = child
+			end			
+		end
+	end
+	
+	local function childRemoved(child)
+		TrackedLimbs[child] = nil
+		
+		-- If removed/replaced part is 'Torso' or 'UpperTorso' double check that we still have a TorsoPart to use
+		CheckTorsoReference()
+	end	
+	
+	childAddedConn = character.ChildAdded:connect(childAdded)
+	childRemovedConn = character.ChildRemoved:connect(childRemoved)
+	
+	for _, child in pairs(Character:GetChildren()) do
+		childAdded(child)
+	end
+end
+
+local function OnCurrentCameraChanged()
+	local newCamera = workspace.CurrentCamera
+	if newCamera then
+		Camera = newCamera
+	end
+end
+
+-----------------------
+-- Exposed Functions --
+-----------------------
+
+-- Update. Called every frame after the camera movement step
+function Invisicam:Update()
+
+	-- Bail if there is no Character
+	if not Character then return end
+	
+	-- Make sure we still have a HumanoidRootPart
+	if not HumanoidRootPart then
+		local humanoid = Character:FindFirstChildOfClass("Humanoid")
+		if humanoid and humanoid.Torso then
+			HumanoidRootPart = humanoid.Torso
+		else
+			-- Not set up with Humanoid? Try and see if there's one in the Character at all:
+			HumanoidRootPart = Character:FindFirstChild("HumanoidRootPart")
+			if not HumanoidRootPart then
+				-- Bail out, since we're relying on HumanoidRootPart existing
+				return
+			end
+		end
+		local ancestryChangedConn;
+		ancestryChangedConn = HumanoidRootPart.AncestryChanged:connect(function(child, parent)
+			if child == HumanoidRootPart and not parent then 
+				HumanoidRootPart = nil
+				if ancestryChangedConn and ancestryChangedConn.Connected then
+					ancestryChangedConn:Disconnect()
+					ancestryChangedConn = nil
+				end
+			end
+		end)
+	end
+	
+	if not TorsoPart then
+		CheckTorsoReference()
+		if not TorsoPart then
+			-- Bail out, since we're relying on Torso existing, should never happen since we fall back to using HumanoidRootPart as torso
+			return
+		end
+	end
+
+	-- Make a list of world points to raycast to
+	local castPoints = {}
+	BehaviorFunction(castPoints)
+	
+	-- Cast to get a list of objects between the camera and the cast points
+	local currentHits = {}
+	local ignoreList = {Character}
+	local function add(hit)
+		currentHits[hit] = true
+		if not SavedHits[hit] then
+			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 partIsTouchingCamera = {}
+	
+	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 = HeadPart and HeadPart.CFrame.p or castPoints[1]
+		local torsoPoint = TorsoPart and TorsoPart.CFrame.p or castPoints[2]
+		hitParts = 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 = 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(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
+			SavedHits[hitPart] = nil
+		end
+	end
+end
+
+function Invisicam:SetMode(newMode)
+	AssertTypes(newMode, 'number')
+	for modeName, modeNum in pairs(MODE) do
+		if modeNum == newMode then
+			Mode = newMode
+			BehaviorFunction = Behaviors[Mode]
+			return
+		end
+	end
+	error("Invalid mode number")
+end
+
+function Invisicam:SetCustomBehavior(func)
+	AssertTypes(func, 'function')
+	Behaviors[MODE.CUSTOM] = func
+	if Mode == MODE.CUSTOM then
+		BehaviorFunction = func
+	end
+end
+
+function Invisicam:GetObscuredParts()
+	return SavedHits
+end
+
+-- Want to turn off Invisicam? Be sure to call this after.
+function Invisicam:Cleanup()
+	for hit, originalFade in pairs(SavedHits) do
+		hit.LocalTransparencyModifier = originalFade
+	end
+end
+
+---------------------
+--| Running Logic |--
+---------------------
+
+-- Connect to the current and all future cameras
+workspace:GetPropertyChangedSignal("CurrentCamera"):connect(OnCurrentCameraChanged)
+OnCurrentCameraChanged()
+
+Player.CharacterAdded:connect(OnCharacterAdded)
+if Player.Character then
+	OnCharacterAdded(Player.Character)
+end
+
+Behaviors[MODE.CUSTOM] = function() end -- (Does nothing until SetCustomBehavior)
+Behaviors[MODE.LIMBS] = LimbBehavior
+Behaviors[MODE.MOVEMENT] = MoveBehavior
+Behaviors[MODE.CORNERS] = CornerBehavior
+Behaviors[MODE.CIRCLE1] = CircleBehavior
+Behaviors[MODE.CIRCLE2] = CircleBehavior
+Behaviors[MODE.LIMBMOVE] = LimbMoveBehavior
+Behaviors[MODE.SMART_CIRCLE] = SmartCircleBehavior
+Behaviors[MODE.CHAR_OUTLINE] = CharacterOutlineBehavior
+
+Invisicam:SetMode(STARTING_MODE)
+
+return Invisicam

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/PopperCam.lua

@@ -0,0 +1,175 @@
+-- PopperCam Version 16
+-- OnlyTwentyCharacters
+
+local PopperCam = {} -- Guarantees your players won't see outside the bounds of your map!
+
+-----------------
+--| Constants |--
+-----------------
+
+local POP_RESTORE_RATE = 0.3
+local MIN_CAMERA_ZOOM = 0.5
+
+local VALID_SUBJECTS = {
+	'Humanoid',
+	'VehicleSeat',
+	'SkateboardPlatform',
+}
+
+-----------------
+--| Variables |--
+-----------------
+
+local PlayersService = game:GetService('Players')
+
+local Camera = nil
+local CameraSubjectChangeConn = nil
+
+local SubjectPart = nil
+
+local PlayerCharacters = {} -- For ignoring in raycasts
+local VehicleParts = {} -- Also just for ignoring
+
+local LastPopAmount = 0
+local LastZoomLevel = 0
+local PopperEnabled = false
+
+local CFrame_new = CFrame.new
+
+-----------------------
+--| Local Functions |--
+-----------------------
+
+local math_abs = math.abs
+
+local function OnCameraSubjectChanged()
+	VehicleParts = {}
+
+	local newSubject = Camera.CameraSubject
+	if newSubject then
+		-- Determine if we should be popping at all
+		PopperEnabled = false
+		for _, subjectType in pairs(VALID_SUBJECTS) do
+			if newSubject:IsA(subjectType) then
+				PopperEnabled = true
+				break
+			end
+		end
+
+		-- Get all parts of the vehicle the player is controlling
+		if newSubject:IsA('VehicleSeat') then
+			VehicleParts = newSubject:GetConnectedParts(true)
+		end
+  	end
+end
+
+local function OnCharacterAdded(player, character)
+	PlayerCharacters[player] = character
+end
+
+local function OnPlayersChildAdded(child)
+	if child:IsA('Player') then
+		child.CharacterAdded:connect(function(character)
+			OnCharacterAdded(child, character)
+		end)
+		if child.Character then
+			OnCharacterAdded(child, child.Character)
+		end
+	end
+end
+
+local function OnPlayersChildRemoved(child)
+	if child:IsA('Player') then
+		PlayerCharacters[child] = nil
+	end
+end
+ 
+ local function OnWorkspaceChanged(property)
+ 	if property == 'CurrentCamera' then
+ 		local newCamera = workspace.CurrentCamera
+  		if newCamera then
+  			Camera = newCamera
+
+			if CameraSubjectChangeConn then
+				CameraSubjectChangeConn:disconnect()
+			end
+
+			CameraSubjectChangeConn = Camera:GetPropertyChangedSignal("CameraSubject"):connect(OnCameraSubjectChanged)
+			OnCameraSubjectChanged()
+  		end
+	end
+end
+
+-------------------------
+--| Exposed Functions |--
+-------------------------
+
+function PopperCam:Update(EnabledCamera)
+	if PopperEnabled then
+		-- First, prep some intermediate vars
+		local cameraCFrame = Camera.CFrame
+		local focusPoint = Camera.Focus.p
+
+		local ignoreList = {}
+		for _, character in pairs(PlayerCharacters) do
+			ignoreList[#ignoreList + 1] = character
+		end
+		for i = 1, #VehicleParts do
+			ignoreList[#ignoreList + 1] = VehicleParts[i]
+		end
+		
+		-- Get largest cutoff distance
+		local largest = Camera:GetLargestCutoffDistance(ignoreList)
+
+		-- Then check if the player zoomed since the last frame,
+		-- and if so, reset our pop history so we stop tweening
+		local zoomLevel = (cameraCFrame.p - focusPoint).Magnitude
+		if math_abs(zoomLevel - LastZoomLevel) > 0.001 then
+			LastPopAmount = 0
+		end
+		
+		-- Finally, zoom the camera in (pop) by that most-cut-off amount, or the last pop amount if that's more
+		local popAmount = largest
+		if LastPopAmount > popAmount then
+			popAmount = LastPopAmount
+		end
+
+		if popAmount > 0 then
+			Camera.CFrame = cameraCFrame + (cameraCFrame.lookVector * popAmount)
+			LastPopAmount = popAmount - POP_RESTORE_RATE -- Shrink it for the next frame
+			if LastPopAmount < 0 then
+				LastPopAmount = 0
+			end
+		end
+
+		LastZoomLevel = zoomLevel
+		
+		-- Stop shift lock being able to see through walls by manipulating Camera focus inside the wall
+		if EnabledCamera and EnabledCamera:GetShiftLock() and not EnabledCamera:IsInFirstPerson() then
+			if EnabledCamera:GetCameraActualZoom() < 1 then
+				local subjectPosition = EnabledCamera.lastSubjectPosition 
+				if subjectPosition then
+					Camera.Focus = CFrame_new(subjectPosition)
+					Camera.CFrame = CFrame_new(subjectPosition - MIN_CAMERA_ZOOM*EnabledCamera:GetCameraLook(), subjectPosition)
+				end
+			end
+		end
+	end
+end
+
+--------------------
+--| Script Logic |--
+--------------------
+
+-- Connect to the current and all future cameras
+workspace.Changed:connect(OnWorkspaceChanged)
+OnWorkspaceChanged('CurrentCamera')
+
+-- Connect to all Players so we can ignore their Characters
+PlayersService.ChildRemoved:connect(OnPlayersChildRemoved)
+PlayersService.ChildAdded:connect(OnPlayersChildAdded)
+for _, player in pairs(PlayersService:GetPlayers()) do
+	OnPlayersChildAdded(player)
+end
+
+return PopperCam

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/RootCamera/.robloxrc

@@ -0,0 +1,6 @@
+{
+	"lint": {
+		"LocalShadow": "fatal",
+		"ImplicitReturn": "fatal"
+	}
+}

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/RootCamera/AttachCamera.lua

@@ -0,0 +1,75 @@
+local PlayersService = game:GetService('Players')
+local RootCameraCreator = require(script.Parent)
+
+local ZERO_VECTOR2 = Vector2.new(0, 0)
+local XZ_VECTOR = Vector3.new(1,0,1)
+
+local Vector2_new = Vector2.new
+local CFrame_new = CFrame.new
+local math_atan2 = math.atan2
+local math_min = math.min
+
+local function IsFinite(num)
+	return num == num and num ~= 1/0 and num ~= -1/0
+end
+
+-- May return NaN or inf or -inf
+-- This is a way of finding the angle between the two vectors:
+local function findAngleBetweenXZVectors(vec2, vec1)
+	return math_atan2(vec1.X*vec2.Z-vec1.Z*vec2.X, vec1.X*vec2.X + vec1.Z*vec2.Z)
+end
+
+local function CreateAttachCamera()
+	local module = RootCameraCreator()
+	
+	local lastUpdate = tick()
+	function module:Update()
+		local now = tick()
+		
+		local camera = 	workspace.CurrentCamera
+		
+		if lastUpdate == nil or now - lastUpdate > 1 then
+			module:ResetCameraLook()
+			self.LastCameraTransform = nil
+		end	
+		
+		local subjectPosition = self:GetSubjectPosition()		
+		if subjectPosition and camera then
+			local zoom = self:GetCameraZoom()
+			if zoom <= 0 then
+				zoom = 0.1
+			end
+
+
+			local humanoid = self:GetHumanoid()
+			if lastUpdate and humanoid and humanoid.Torso 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 - lastUpdate)
+				local gamepadRotation = self:UpdateGamepad()
+				self.RotateInput = self.RotateInput + (gamepadRotation * delta)		
+				
+				local forwardVector = humanoid.Torso.CFrame.lookVector
+
+				local y = findAngleBetweenXZVectors(forwardVector, self:GetCameraLook())
+				if IsFinite(y) then
+					-- Preserve vertical rotation from user input
+					self.RotateInput = Vector2_new(y, self.RotateInput.Y)
+				end
+			end
+
+			local newLookVector = self:RotateCamera(self:GetCameraLook(), self.RotateInput)
+			self.RotateInput = ZERO_VECTOR2
+
+			camera.Focus = CFrame_new(subjectPosition)
+			local newCFrame = CFrame_new(subjectPosition - (zoom * newLookVector), subjectPosition)
+			camera.CFrame = newCFrame
+			self.LastCameraTransform = newCFrame
+		end
+		lastUpdate = now
+	end
+	
+	return module
+end
+
+return CreateAttachCamera

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/RootCamera/ClassicCamera.lua

@@ -0,0 +1,195 @@
+
+local PlayersService = game:GetService('Players')
+local VRService = game:GetService("VRService")
+
+local RootCameraCreator = require(script.Parent)
+
+local UP_VECTOR = Vector3.new(0, 1, 0)
+local XZ_VECTOR = Vector3.new(1, 0, 1)
+local ZERO_VECTOR2 = Vector2.new(0, 0)
+
+local VR_PITCH_FRACTION = 0.25
+
+local Vector3_new = Vector3.new
+local CFrame_new = CFrame.new
+local math_min = math.min
+local math_max = math.max
+local math_atan2 = math.atan2
+local math_rad = math.rad
+local math_abs = math.abs
+
+local function clamp(low, high, num)
+	return (num > high and high or num < low and low or num)
+end
+
+local function IsFinite(num)
+	return num == num and num ~= 1/0 and num ~= -1/0
+end
+
+local function IsFiniteVector3(vec3)
+	return IsFinite(vec3.x) and IsFinite(vec3.y) and IsFinite(vec3.z)
+end
+
+-- May return NaN or inf or -inf
+-- This is a way of finding the angle between the two vectors:
+local function findAngleBetweenXZVectors(vec2, vec1)
+	return math_atan2(vec1.X*vec2.Z-vec1.Z*vec2.X, vec1.X*vec2.X + vec1.Z*vec2.Z)
+end
+
+local function CreateClassicCamera()
+	local module = RootCameraCreator()
+	
+	local tweenAcceleration = math_rad(220)
+	local tweenSpeed = math_rad(0)
+	local tweenMaxSpeed = math_rad(250)
+	local timeBeforeAutoRotate = 2
+	
+	local lastUpdate = tick()
+	module.LastUserPanCamera = tick()
+	function module:Update()
+		module:ProcessTweens()
+		local now = tick()
+		local timeDelta = (now - lastUpdate)
+		
+		local userPanningTheCamera = (self.UserPanningTheCamera == true)
+		local camera = 	workspace.CurrentCamera
+		local player = PlayersService.LocalPlayer
+		local humanoid = self:GetHumanoid()
+		local cameraSubject = camera and camera.CameraSubject
+		local isInVehicle = cameraSubject and cameraSubject:IsA('VehicleSeat')
+		local isOnASkateboard = cameraSubject and cameraSubject:IsA('SkateboardPlatform')
+		
+		if lastUpdate == nil or now - lastUpdate > 1 then
+			module:ResetCameraLook()
+			self.LastCameraTransform = nil
+		end	
+		
+		if 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, now - lastUpdate)
+				
+				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
+			tweenSpeed = 0
+			module.LastUserPanCamera = tick()
+		end
+		
+		local userRecentlyPannedCamera = now - module.LastUserPanCamera < timeBeforeAutoRotate
+		local subjectPosition = self:GetSubjectPosition()
+		
+		if subjectPosition and player and camera then
+			local zoom = self:GetCameraZoom()
+			if zoom < 0.5 then
+				zoom = 0.5
+			end
+			
+			if self:GetShiftLock() and not self:IsInFirstPerson() then
+				-- We need to use the right vector of the camera after rotation, not before
+				local newLookVector = self:RotateCamera(self:GetCameraLook(), self.RotateInput)
+				local offset = ((newLookVector * XZ_VECTOR):Cross(UP_VECTOR).unit * 1.75)
+
+				if IsFiniteVector3(offset) then
+					subjectPosition = subjectPosition + offset
+				end
+			else
+				if not userPanningTheCamera and self.LastCameraTransform then
+					local isInFirstPerson = self:IsInFirstPerson()
+					if (isInVehicle or isOnASkateboard) and lastUpdate and humanoid and humanoid.Torso then
+						if isInFirstPerson then
+							if self.LastSubjectCFrame and (isInVehicle or isOnASkateboard) and cameraSubject:IsA('BasePart') then
+								local y = -findAngleBetweenXZVectors(self.LastSubjectCFrame.lookVector, cameraSubject.CFrame.lookVector)
+								if 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 = clamp(0, tweenMaxSpeed, tweenSpeed + tweenAcceleration * timeDelta)
+	
+							local percent = clamp(0, 1, tweenSpeed * timeDelta)
+							if self:IsInFirstPerson() then
+								percent = 1
+							end
+							
+							local y = findAngleBetweenXZVectors(forwardVector, self:GetCameraLook())
+							if IsFinite(y) and math_abs(y) > 0.0001 then
+								self.RotateInput = self.RotateInput + Vector2.new(y * percent, 0)
+							end
+						end
+					end
+				end
+			end
+
+			local VREnabled = VRService.VREnabled
+			camera.Focus = VREnabled and self:GetVRFocus(subjectPosition, timeDelta) or CFrame_new(subjectPosition)
+
+			local cameraFocusP = camera.Focus.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 > zoom or self.RotateInput.x ~= 0 then
+					local desiredDist = math_min(distToSubject, zoom)
+					vecToSubject = self:RotateCamera(vecToSubject.unit * XZ_VECTOR, 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
+					
+					camera.CFrame = CFrame_new(newPos, lookAt) + Vector3_new(0, cameraHeight, 0)
+				end
+			else
+				local newLookVector = self:RotateCamera(self:GetCameraLook(), self.RotateInput)
+				self.RotateInput = ZERO_VECTOR2
+				camera.CFrame = CFrame_new(cameraFocusP - (zoom * newLookVector), cameraFocusP)
+			end
+
+			self.LastCameraTransform = camera.CFrame
+			self.LastCameraFocus = camera.Focus
+			if (isInVehicle or isOnASkateboard) and cameraSubject:IsA('BasePart') then
+				self.LastSubjectCFrame = cameraSubject.CFrame
+			else
+				self.LastSubjectCFrame = nil
+			end
+		end
+		
+		lastUpdate = now
+	end
+	
+	return module
+end
+
+return CreateClassicCamera

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/RootCamera/FixedCamera.lua

@@ -0,0 +1,48 @@
+local PlayersService = game:GetService('Players')
+local RootCameraCreator = require(script.Parent)
+
+local ZERO_VECTOR2 = Vector2.new(0, 0)
+
+local CFrame_new = CFrame.new
+local math_min = math.min
+
+local function CreateFixedCamera()
+	local module = RootCameraCreator()
+	
+	local lastUpdate = tick()
+	function module:Update()
+		local now = tick()
+		
+		local camera = 	workspace.CurrentCamera
+		local player = PlayersService.LocalPlayer
+		if lastUpdate == nil or now - lastUpdate > 1 then
+			module:ResetCameraLook()
+			self.LastCameraTransform = nil
+		end
+		
+		if 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 - lastUpdate)
+			local gamepadRotation = self:UpdateGamepad()		
+			self.RotateInput = self.RotateInput + (gamepadRotation * delta)
+		end		
+		
+		local subjectPosition = self:GetSubjectPosition()		
+		if subjectPosition and player and camera then
+			local zoom = self:GetCameraZoom()
+			if zoom <= 0 then
+				zoom = 0.1
+			end
+			local newLookVector = self:RotateCamera(self:GetCameraLook(), self.RotateInput)
+			self.RotateInput = ZERO_VECTOR2
+			
+			camera.CFrame = CFrame_new(camera.CFrame.p, camera.CFrame.p + (zoom * newLookVector))
+			self.LastCameraTransform = camera.CFrame
+		end
+		lastUpdate = now
+	end
+	
+	return module
+end
+
+return CreateFixedCamera

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/RootCamera/FollowCamera.lua

@@ -0,0 +1,192 @@
+local PlayersService = game:GetService('Players')
+local VRService = game:GetService("VRService")
+
+local RootCameraCreator = require(script.Parent)
+
+local CFrame_new = CFrame.new
+local Vector2_new = Vector2.new
+local Vector3_new = Vector3.new
+local math_min = math.min
+local math_max = math.max
+local math_atan2 = math.atan2
+local math_rad = math.rad
+local math_abs = math.abs
+
+local HUMANOIDSTATE_CLIMBING = Enum.HumanoidStateType.Climbing
+local ZERO_VECTOR2 = Vector2.new(0, 0)
+local UP_VECTOR = Vector3.new(0, 1, 0)
+local XZ_VECTOR = Vector3.new(1, 0, 1)
+local ZERO_VECTOR3 = Vector3.new(0, 0, 0)
+local PORTRAIT_OFFSET = Vector3.new(0, -3, 0)
+
+local function clamp(low, high, num)
+	return num > high and high or num < low and low or num
+end
+
+local function IsFinite(num)
+	return num == num and num ~= 1/0 and num ~= -1/0
+end
+
+local function IsFiniteVector3(vec3)
+	return IsFinite(vec3.x) and IsFinite(vec3.y) and IsFinite(vec3.z)
+end
+
+-- May return NaN or inf or -inf
+local function findAngleBetweenXZVectors(vec2, vec1)
+	-- This is a way of finding the angle between the two vectors:
+	return math_atan2(vec1.X*vec2.Z-vec1.Z*vec2.X, vec1.X*vec2.X + vec1.Z*vec2.Z)
+end
+
+local function CreateFollowCamera()
+	local module = RootCameraCreator()
+	
+	local tweenAcceleration = math_rad(220)
+	local tweenSpeed = math_rad(0)
+	local tweenMaxSpeed = math_rad(250)
+	local timeBeforeAutoRotate = 2
+	
+	local lastUpdate = tick()
+	module.LastUserPanCamera = tick()
+	function module:Update()
+		module:ProcessTweens()
+		local now = tick()
+		local timeDelta = (now - lastUpdate)
+		
+		local userPanningTheCamera = (self.UserPanningTheCamera == true)
+		local camera = workspace.CurrentCamera
+		local player = PlayersService.LocalPlayer
+		local humanoid = self:GetHumanoid()
+		local cameraSubject = camera and camera.CameraSubject
+		local isClimbing = humanoid and humanoid:GetState() == HUMANOIDSTATE_CLIMBING
+		local isInVehicle = cameraSubject and cameraSubject:IsA('VehicleSeat')
+		local isOnASkateboard = cameraSubject and cameraSubject:IsA('SkateboardPlatform')
+		
+		if lastUpdate == nil or now - lastUpdate > 1 then
+			module:ResetCameraLook()
+			self.LastCameraTransform = nil
+		end
+		
+		if lastUpdate then
+			
+			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, now - lastUpdate)
+				local angle = 0
+				-- NOTE: Traditional follow camera does not rotate with arrow keys
+				if not (isInVehicle or isOnASkateboard) then
+					angle = angle + (self.TurningLeft and -120 or 0)
+					angle = angle + (self.TurningRight and 120 or 0)
+				end
+				
+				local gamepadRotation = self:UpdateGamepad()
+				if gamepadRotation ~= Vector2.new(0,0) then
+					userPanningTheCamera = true
+					self.RotateInput = self.RotateInput + (gamepadRotation * delta)
+				end
+				
+				if angle ~= 0 then
+					userPanningTheCamera = true
+					self.RotateInput = self.RotateInput + Vector2_new(math_rad(angle * delta), 0)
+				end
+			end
+		end
+		
+		-- Reset tween speed if user is panning
+		if userPanningTheCamera then
+			tweenSpeed = 0
+			module.LastUserPanCamera = tick()
+		end
+		
+		local userRecentlyPannedCamera = now - module.LastUserPanCamera < timeBeforeAutoRotate
+		
+		local subjectPosition = self:GetSubjectPosition()
+		if subjectPosition and player and camera then
+			local zoom = self:GetCameraZoom()
+			if zoom < 0.5 then
+				zoom = 0.5
+			end
+			
+			if self:GetShiftLock() and not self:IsInFirstPerson() then
+				local newLookVector = self:RotateCamera(self:GetCameraLook(), self.RotateInput)
+				local offset = ((newLookVector * XZ_VECTOR):Cross(UP_VECTOR).unit * 1.75)
+				if IsFiniteVector3(offset) then
+					subjectPosition = subjectPosition + offset
+				end
+			else
+				if self.LastCameraTransform and not userPanningTheCamera then
+					local isInFirstPerson = self:IsInFirstPerson()
+					if (isClimbing or isInVehicle or isOnASkateboard) and lastUpdate and humanoid and humanoid.Torso then
+						if isInFirstPerson then
+							if self.LastSubjectCFrame and (isInVehicle or isOnASkateboard) and cameraSubject:IsA('BasePart') then
+								local y = -findAngleBetweenXZVectors(self.LastSubjectCFrame.lookVector, cameraSubject.CFrame.lookVector)
+								if 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 = clamp(0, tweenMaxSpeed, tweenSpeed + tweenAcceleration * timeDelta)
+							
+							local percent = clamp(0, 1, tweenSpeed*timeDelta)
+							if not isClimbing and self:IsInFirstPerson() then
+								percent = 1
+							end
+							local y = findAngleBetweenXZVectors(forwardVector, self:GetCameraLook())
+							-- Check for NaN
+							if IsFinite(y) and math_abs(y) > 0.0001 then
+								self.RotateInput = self.RotateInput + Vector2.new(y * percent, 0)
+							end
+						end
+					elseif not (isInFirstPerson or userRecentlyPannedCamera) and not VRService.VREnabled then
+						local lastVec = -(self.LastCameraTransform.p - subjectPosition)
+						
+						local y = findAngleBetweenXZVectors(lastVec, self:GetCameraLook())
+						
+						-- 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 deadzone to allow more precise forward movements.
+						local thetaCutoff = 0.4
+						
+						-- Check for NaNs
+						if 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
+			local newLookVector = self:RotateCamera(self:GetCameraLook(), self.RotateInput)
+			self.RotateInput = ZERO_VECTOR2
+
+			if VRService.VREnabled then
+				camera.Focus = self:GetVRFocus(subjectPosition, timeDelta)
+			elseif self:IsPortraitMode() then
+				camera.Focus = CFrame_new(subjectPosition + PORTRAIT_OFFSET)
+			else
+				camera.Focus = CFrame_new(subjectPosition)
+			end
+			camera.CFrame = CFrame_new(camera.Focus.p - (zoom * newLookVector), camera.Focus.p) + Vector3.new(0, self:GetCameraHeight(), 0)
+
+			self.LastCameraTransform = camera.CFrame
+			self.LastCameraFocus = camera.Focus
+			if isInVehicle or isOnASkateboard and cameraSubject:IsA('BasePart') then
+				self.LastSubjectCFrame = cameraSubject.CFrame
+			else
+				self.LastSubjectCFrame = nil
+			end
+		end
+		
+		lastUpdate = now
+	end
+	
+	return module
+end
+
+return CreateFollowCamera

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/RootCamera/OrbitalCamera.lua

@@ -0,0 +1,450 @@
+--[[	
+	Orbital Camera 1.0.0
+	AllYourBlox
+		
+	Derived from ClassicCamera, adds camera angle constraints, and represents position values in spherical
+	coordinates (azimuth, elevation, radius), instead of Cartesian coordinates (x, y, z). Azimuth is the
+	angle of rotation about the Y axis, with the zero-angle reference point corresponding to offsetting
+	the camera in the +Z direction, from where it will be looking in the -Z direction by default. Elevation
+	is the angle up from the XZ plane, where zero degrees is on the plane, and +90 degrees is on the +Y
+	axis. Distance is the camera-to-subject distance, the spherical coordinates radius, specified in studs.
+--]]
+
+-- 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 refAzimuthRad
+local curAzimuthRad
+local minAzimuthAbsoluteRad
+local maxAzimuthAbsoluteRad
+local useAzimuthLimits
+local curElevationRad
+local minElevationRad
+local maxElevationRad
+local curDistance
+local minDistance
+local maxDistance
+
+local UNIT_Z = Vector3.new(0,0,1)
+local TAU = 2 * math.pi
+
+local changedSignalConnections = {}
+
+-- End of OrbitalCamera additions
+local PlayersService = game:GetService('Players')
+local VRService = game:GetService("VRService")
+
+local RootCameraCreator = require(script.Parent)
+
+local UP_VECTOR = Vector3.new(0, 1, 0)
+local XZ_VECTOR = Vector3.new(1, 0, 1)
+local ZERO_VECTOR2 = Vector2.new(0, 0)
+
+local VR_PITCH_FRACTION = 0.25
+
+local Vector3_new = Vector3.new
+local CFrame_new = CFrame.new
+local math_min = math.min
+local math_max = math.max
+local math_atan2 = math.atan2
+local math_rad = math.rad
+local math_abs = math.abs
+
+--[[ Gamepad Support ]]--
+local THUMBSTICK_DEADZONE = 0.2
+local r3ButtonDown = false
+local l3ButtonDown = false
+local currentZoomSpeed = 1 -- Multiplier, so 1 == no zooming
+
+local function clamp(value, minValue, maxValue)
+	if maxValue < minValue then
+		maxValue = minValue
+	end
+	return math.clamp(value, minValue, maxValue)
+end
+
+local function IsFinite(num)
+	return num == num and num ~= 1/0 and num ~= -1/0
+end
+
+local function IsFiniteVector3(vec3)
+	return IsFinite(vec3.x) and IsFinite(vec3.y) and IsFinite(vec3.z)
+end
+
+-- May return NaN or inf or -inf
+-- This is a way of finding the angle between the two vectors:
+local function findAngleBetweenXZVectors(vec2, vec1)
+	return math_atan2(vec1.X*vec2.Z-vec1.Z*vec2.X, vec1.X*vec2.X + vec1.Z*vec2.Z)
+end
+
+local function GetValueObject(name, defaultValue)
+	local valueObj = script:FindFirstChild(name)
+	if valueObj then
+		return valueObj.Value
+	end
+	return defaultValue
+end
+
+local function 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
+		externalProperties[name] = valueObj.Value
+	elseif 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 = externalProperties[name]
+	else
+		print("externalProperties table has no entry for ",name)
+		return
+	end
+	
+	if updateFunction then
+		if changedSignalConnections[name] then
+			changedSignalConnections[name]:disconnect()
+		end
+		changedSignalConnections[name] = valueObj.Changed:connect(function(newValue)
+			externalProperties[name] = newValue
+			updateFunction()
+		end)
+	end
+end
+
+local function SetAndBoundsCheckAzimuthValues()
+	minAzimuthAbsoluteRad = math.rad(externalProperties["ReferenceAzimuth"]) - math.abs(math.rad(externalProperties["CWAzimuthTravel"]))
+	maxAzimuthAbsoluteRad = math.rad(externalProperties["ReferenceAzimuth"]) + math.abs(math.rad(externalProperties["CCWAzimuthTravel"]))
+	useAzimuthLimits = externalProperties["UseAzimuthLimits"]
+	if useAzimuthLimits then
+		curAzimuthRad = math.max(curAzimuthRad, minAzimuthAbsoluteRad)
+		curAzimuthRad = math.min(curAzimuthRad, maxAzimuthAbsoluteRad)
+	end
+end
+
+local function 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(externalProperties["MinElevation"], MIN_ALLOWED_ELEVATION_DEG)
+	local maxElevationDeg = math.min(externalProperties["MaxElevation"], MAX_ALLOWED_ELEVATION_DEG)
+	
+	-- Set internal values in radians
+	minElevationRad = math.rad(math.min(minElevationDeg, maxElevationDeg))
+	maxElevationRad = math.rad(math.max(minElevationDeg, maxElevationDeg))
+	curElevationRad = math.max(curElevationRad, minElevationRad)
+	curElevationRad = math.min(curElevationRad, maxElevationRad)
+end
+
+local function SetAndBoundsCheckDistanceValues()
+	minDistance = externalProperties["MinDistance"]
+	maxDistance = externalProperties["MaxDistance"]
+	curDistance = math.max(curDistance, minDistance)
+	curDistance = math.min(curDistance, maxDistance)
+end
+
+-- This loads from, or lazily creates, NumberValue objects for exposed parameters
+local function LoadNumberValueParameters()
+	-- These initial values do not require change listeners since they are read only once
+	LoadOrCreateNumberValueParameter("InitialElevation", "NumberValue", nil)
+	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
+	LoadOrCreateNumberValueParameter("ReferenceAzimuth", "NumberValue", SetAndBoundsCheckAzimuthValues)
+	LoadOrCreateNumberValueParameter("CWAzimuthTravel", "NumberValue", SetAndBoundsCheckAzimuthValues)
+	LoadOrCreateNumberValueParameter("CCWAzimuthTravel", "NumberValue", SetAndBoundsCheckAzimuthValues)
+	LoadOrCreateNumberValueParameter("MinElevation", "NumberValue", SetAndBoundsCheckElevationValues)
+	LoadOrCreateNumberValueParameter("MaxElevation", "NumberValue", SetAndBoundsCheckElevationValues)
+	LoadOrCreateNumberValueParameter("MinDistance", "NumberValue", SetAndBoundsCheckDistanceValues)
+	LoadOrCreateNumberValueParameter("MaxDistance", "NumberValue", SetAndBoundsCheckDistanceValues)
+	LoadOrCreateNumberValueParameter("UseAzimuthLimits", "BoolValue", SetAndBoundsCheckAzimuthValues)
+	
+	-- Internal values set (in radians, from degrees), plus sanitization
+	curAzimuthRad = math.rad(externalProperties["ReferenceAzimuth"])
+	curElevationRad = math.rad(externalProperties["InitialElevation"])
+	curDistance = externalProperties["InitialDistance"]
+	
+	SetAndBoundsCheckAzimuthValues()
+	SetAndBoundsCheckElevationValues()
+	SetAndBoundsCheckDistanceValues()
+end
+
+local function CreateOrbitalCamera()
+	local module = RootCameraCreator()
+	
+	LoadNumberValueParameters()	
+	
+	module.DefaultZoom = curDistance
+	
+	local tweenAcceleration = math_rad(220)
+	local tweenSpeed = math_rad(0)
+	local tweenMaxSpeed = math_rad(250)
+	local timeBeforeAutoRotate = 2
+	
+	local lastUpdate = tick()
+	module.LastUserPanCamera = tick()
+	
+	function module:Update()
+		module:ProcessTweens()
+		local now = tick()
+		local timeDelta = (now - lastUpdate)
+		local userPanningTheCamera = (self.UserPanningTheCamera == true)
+		local camera = 	workspace.CurrentCamera
+		local player = PlayersService.LocalPlayer
+		local humanoid = self:GetHumanoid()
+		local cameraSubject = camera and camera.CameraSubject
+		local isInVehicle = cameraSubject and cameraSubject:IsA('VehicleSeat')
+		local isOnASkateboard = cameraSubject and cameraSubject:IsA('SkateboardPlatform')
+		
+		if lastUpdate == nil or now - lastUpdate > 1 then
+			module:ResetCameraLook()
+			self.LastCameraTransform = nil
+		end	
+		
+		if 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, now - lastUpdate)
+				
+				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
+			tweenSpeed = 0
+			module.LastUserPanCamera = tick()
+		end
+		
+		local userRecentlyPannedCamera = now - module.LastUserPanCamera < timeBeforeAutoRotate
+		local subjectPosition = self:GetSubjectPosition()
+		
+		if subjectPosition and player and camera then
+		
+			
+			local zoom = self:ZoomCamera(curDistance * currentZoomSpeed)
+			
+			
+			if not userPanningTheCamera and self.LastCameraTransform then
+				local isInFirstPerson = self:IsInFirstPerson()
+				if (isInVehicle or isOnASkateboard) and lastUpdate and humanoid and humanoid.Torso then
+					if isInFirstPerson then
+						if self.LastSubjectCFrame and (isInVehicle or isOnASkateboard) and cameraSubject:IsA('BasePart') then
+							local y = -findAngleBetweenXZVectors(self.LastSubjectCFrame.lookVector, cameraSubject.CFrame.lookVector)
+							if 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 = clamp(0, tweenMaxSpeed, tweenSpeed + tweenAcceleration * timeDelta)
+
+						local percent = clamp(0, 1, tweenSpeed * timeDelta)
+						if self:IsInFirstPerson() then
+							percent = 1
+						end
+						
+						local y = findAngleBetweenXZVectors(forwardVector, self:GetCameraLook())
+						if IsFinite(y) and math_abs(y) > 0.0001 then
+							self.RotateInput = self.RotateInput + Vector2.new(y * percent, 0)
+						end
+					end
+				end
+			end
+			
+			local VREnabled = VRService.VREnabled
+			camera.Focus = VREnabled and self:GetVRFocus(subjectPosition, timeDelta) or CFrame_new(subjectPosition)
+
+			local cameraFocusP = camera.Focus.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 > zoom or self.RotateInput.x ~= 0 then
+					local desiredDist = math_min(distToSubject, zoom)
+					vecToSubject = self:RotateCamera(vecToSubject.unit * XZ_VECTOR, 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
+					
+					camera.CFrame = CFrame_new(newPos, lookAt) + Vector3_new(0, cameraHeight, 0)
+				end
+			else
+				-- self.RotateInput is a Vector2 of mouse movement deltas since last update
+				curAzimuthRad = curAzimuthRad - self.RotateInput.x
+				
+				if useAzimuthLimits then
+					curAzimuthRad = clamp(curAzimuthRad, minAzimuthAbsoluteRad, maxAzimuthAbsoluteRad)
+				else
+					curAzimuthRad = (curAzimuthRad ~= 0) and (math.sign(curAzimuthRad) * (math.abs(curAzimuthRad) % TAU)) or 0
+				end
+
+				curDistance = clamp(zoom, minDistance, maxDistance)
+				
+				curElevationRad = clamp(curElevationRad + self.RotateInput.y, minElevationRad,maxElevationRad)
+				
+				local cameraPosVector = curDistance * ( CFrame.fromEulerAnglesYXZ( -curElevationRad, curAzimuthRad, 0 ) * UNIT_Z ) 
+				local camPos = subjectPosition + cameraPosVector
+				
+				camera.CFrame = CFrame.new(camPos, subjectPosition)
+			
+				self.RotateInput = ZERO_VECTOR2
+			end
+
+			self.LastCameraTransform = camera.CFrame
+			self.LastCameraFocus = camera.Focus
+			if (isInVehicle or isOnASkateboard) and cameraSubject:IsA('BasePart') then
+				self.LastSubjectCFrame = cameraSubject.CFrame
+			else
+				self.LastSubjectCFrame = nil
+			end
+		end
+		
+		lastUpdate = now
+	end
+	
+	function module:GetCameraZoom()
+		return curDistance
+	end
+	
+	function module:ZoomCamera(desiredZoom)
+		local player = PlayersService.LocalPlayer
+		if player then
+			curDistance = clamp(desiredZoom, minDistance, maxDistance)
+		end
+
+		local isFirstPerson = self:GetCameraZoom() < 2
+
+		--ShiftLockController:SetIsInFirstPerson(isFirstPerson)
+		-- set mouse behavior
+		self:UpdateMouseBehavior()
+		return self:GetCameraZoom()
+	end
+	
+	function module:ZoomCameraBy(zoomScale)
+		local newDist = curDistance
+		-- Can break into more steps to get more accurate integration
+        newDist = self:rk4Integrator(curDistance, zoomScale, 1)
+		self:ZoomCamera(newDist)
+		return self:GetCameraZoom()
+	end
+
+	function module:ZoomCameraFixedBy(zoomIncrement)
+		return self:ZoomCamera(self:GetCameraZoom() + zoomIncrement)
+	end
+	
+	function module:SetInitialOrientation(humanoid)
+		local newDesiredLook = (humanoid.Torso.CFrame.lookVector - Vector3.new(0,0.23,0)).unit
+		local horizontalShift = findAngleBetweenXZVectors(newDesiredLook, self:GetCameraLook())
+		local vertShift = math.asin(self:GetCameraLook().y) - math.asin(newDesiredLook.y)
+		if not IsFinite(horizontalShift) then
+			horizontalShift = 0
+		end
+		if not IsFinite(vertShift) then
+			vertShift = 0
+		end
+		self.RotateInput = Vector2.new(horizontalShift, vertShift)
+	end
+
+	function module.getGamepadPan(name, state, input)
+		if input.UserInputType == module.activeGamepad and input.KeyCode == Enum.KeyCode.Thumbstick2 then
+			if r3ButtonDown or l3ButtonDown then
+			-- R3 or L3 Thumbstick is depressed, right stick controls dolly in/out
+				if (input.Position.Y > THUMBSTICK_DEADZONE) then
+					currentZoomSpeed = 0.96
+				elseif (input.Position.Y < -THUMBSTICK_DEADZONE) then
+					currentZoomSpeed = 1.04
+				else 
+					currentZoomSpeed = 1.00
+				end
+			else
+				if state == Enum.UserInputState.Cancel then
+					module.GamepadPanningCamera = ZERO_VECTOR2
+					return
+				end		
+				
+				local inputVector = Vector2.new(input.Position.X, -input.Position.Y)
+				if inputVector.magnitude > THUMBSTICK_DEADZONE then
+					module.GamepadPanningCamera = Vector2.new(input.Position.X, -input.Position.Y)
+				else
+					module.GamepadPanningCamera = ZERO_VECTOR2
+				end
+			end
+		end
+	end
+
+	function module.doGamepadZoom(name, state, input)
+		if input.UserInputType == module.activeGamepad and (input.KeyCode == Enum.KeyCode.ButtonR3 or input.KeyCode == Enum.KeyCode.ButtonL3) then
+			if (state == Enum.UserInputState.Begin) then
+				r3ButtonDown = input.KeyCode == Enum.KeyCode.ButtonR3
+				l3ButtonDown = input.KeyCode == Enum.KeyCode.ButtonL3
+			elseif (state == Enum.UserInputState.End) then
+				if (input.KeyCode == Enum.KeyCode.ButtonR3) then
+					r3ButtonDown = false
+				elseif (input.KeyCode == Enum.KeyCode.ButtonL3) then
+					l3ButtonDown = false
+				end
+				if (not r3ButtonDown) and (not l3ButtonDown) then
+					currentZoomSpeed = 1.00
+				end
+			end
+		end
+	end
+	
+	function module:BindGamepadInputActions()
+		local ContextActionService = game:GetService('ContextActionService')
+		ContextActionService:BindAction("OrbitalCamGamepadPan", module.getGamepadPan, false, Enum.KeyCode.Thumbstick2)
+		ContextActionService:BindAction("OrbitalCamGamepadZoom", module.doGamepadZoom, false, Enum.KeyCode.ButtonR3)
+		ContextActionService:BindAction("OrbitalCamGamepadZoomAlt", module.doGamepadZoom, false, Enum.KeyCode.ButtonL3)
+	end
+	
+	return module
+end
+
+return CreateOrbitalCamera

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/RootCamera/ScriptableCamera.lua

@@ -0,0 +1,12 @@
+local RootCameraCreator = require(script.Parent)
+
+local function CreateScriptableCamera()
+	local module = RootCameraCreator()
+
+	function module:Update()
+	end
+	
+	return module
+end
+
+return CreateScriptableCamera

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/RootCamera/TrackCamera.lua

@@ -0,0 +1,54 @@
+local PlayersService = game:GetService('Players')
+local RootCameraCreator = require(script.Parent)
+
+local ZERO_VECTOR2 = Vector2.new(0, 0)
+
+local CFrame_new = CFrame.new
+local math_min = math.min
+
+local function CreateTrackCamera()
+	local module = RootCameraCreator()
+
+	local lastUpdate = tick()
+	function module:Update()
+		local now = tick()
+		
+		local userPanningTheCamera = (self.UserPanningTheCamera == true)
+		local camera = workspace.CurrentCamera
+		local player = PlayersService.LocalPlayer
+		
+		if lastUpdate == nil or now - lastUpdate > 1 then
+			module:ResetCameraLook()
+			self.LastCameraTransform = nil
+		end
+		
+		if 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 - lastUpdate)
+			local gamepadRotation = self:UpdateGamepad()
+			if gamepadRotation ~= ZERO_VECTOR2 then
+				userPanningTheCamera = true
+				self.RotateInput = self.RotateInput + (gamepadRotation * delta)
+			end
+		end
+					
+		local subjectPosition = self:GetSubjectPosition()
+		if subjectPosition and player and camera then
+			local zoom = self:GetCameraZoom()
+			if zoom <= 0 then
+				zoom = 0.1
+			end
+			local newLookVector = self:RotateCamera(self:GetCameraLook(), self.RotateInput)
+			self.RotateInput = ZERO_VECTOR2
+			
+			camera.Focus = CFrame_new(subjectPosition)
+			camera.CFrame = CFrame_new(subjectPosition - (zoom * newLookVector), subjectPosition)
+			self.LastCameraTransform = camera.CoordinateFrame
+		end
+		lastUpdate = now
+	end
+	
+	return module
+end
+
+return CreateTrackCamera

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/RootCamera/VRCamera.lua

@@ -0,0 +1,260 @@
+local PlayersService = game:GetService('Players')
+local UserInputService = game:GetService('UserInputService')
+local VRService = game:GetService("VRService")
+local ContextActionService = game:GetService("ContextActionService")
+
+local LocalPlayer = PlayersService.LocalPlayer
+
+local RootCameraCreator = require(script.Parent)
+
+local XZ_VECTOR = Vector3.new(1, 0, 1)
+local ZERO_VECTOR2 = Vector2.new(0, 0)
+
+local PRESNAP_TIME_OFFSET = 0.5 --seconds
+local PRESNAP_TIME_LATCH = PRESNAP_TIME_OFFSET * 10
+
+local HEIGHT_OFFSET = 3
+local HORZ_OFFSET = 4
+
+local function CreateVRCamera()
+	local module = RootCameraCreator()
+	module.AllowOcclusion = false
+	
+	local lastUpdate = tick()
+	
+	local forceSnap = true
+	local forceSnapPoint = nil
+	local lastLook = Vector3.new(0, 0, -1)
+	
+	local movementUpdateEventConn = nil
+	
+	local lastSnapTimeEstimate = math.huge
+	local snapId = 0	
+	local waitingForSnap = false
+	local snappedHeadOffset = VRService:GetUserCFrame(Enum.UserCFrame.Head).p
+	local snapPendingWhileJumping = false
+	local isJumping = false
+	local autoSnapsPaused = false
+	
+	local currentDestination = nil	
+	
+	local function forceSnapTo(snapPoint)
+		forceSnap = true
+		forceSnapPoint = snapPoint
+		snapId = snapId + 1
+		waitingForSnap = false
+	end	
+	
+	local function onMovementUpdateEvent(updateType, arg1, arg2)
+		if updateType == "targetPoint" then
+			currentDestination = arg1
+		end
+		if updateType == "timing" then
+			local estimatedTimeRemaining = arg1
+			local snapPoint = arg2
+			
+			if waitingForSnap and estimatedTimeRemaining > lastSnapTimeEstimate then
+				--our estimate grew, so cancel this snap and potentially re-evaluate it
+				waitingForSnap = false
+				snapId = snapId + 1
+			end
+			
+			if estimatedTimeRemaining < PRESNAP_TIME_LATCH and estimatedTimeRemaining > PRESNAP_TIME_OFFSET then
+				waitingForSnap = true
+				snapId = snapId + 1
+				local thisSnapId = snapId
+				
+				local timeToWait = estimatedTimeRemaining - PRESNAP_TIME_OFFSET
+				coroutine.wrap(function()
+					wait(timeToWait)
+					if waitingForSnap and snapId == thisSnapId then
+						waitingForSnap = false
+						forceSnap = true
+						forceSnapPoint = snapPoint
+					end
+				end)()
+			end
+		elseif updateType == "shortPath" or updateType == "pathFailure" or updateType == "offtrack" and not autoSnapsPaused then
+			if isJumping then
+				snapPendingWhileJumping = true
+				return
+			end
+			local snapPoint = arg1
+			forceSnapTo(snapPoint)
+		elseif updateType == "force" then
+			snapPendingWhileJumping = false
+			isJumping = false
+			forceSnapTo(nil)
+		end
+	end
+
+	local function onResetCameraAction(actionName, inputState, inputObj)
+		if inputState == Enum.UserInputState.Begin then 
+			autoSnapsPaused = true
+			onMovementUpdateEvent("force", nil, nil) 
+		else
+			autoSnapsPaused = false
+		end
+	end
+	
+	local function bindActions(bind)
+		if bind then
+			ContextActionService:BindActionAtPriority("ResetCameraVR", onResetCameraAction, false, Enum.ContextActionPriority.Low.Value, Enum.KeyCode.ButtonL2)
+		else
+			autoSnapsPaused = false
+			ContextActionService:UnbindAction("ResetCameraVR")
+		end
+	end
+	
+	local lastKnownTorsoPosition = Vector3.new()
+	local function onCharacterAdded(character)
+		local humanoid = character:WaitForChild("Humanoid")
+
+		humanoid.StateChanged:connect(function(oldState, newState)
+			local camera = workspace.CurrentCamera
+			if not camera or camera.CameraSubject ~= humanoid or not VRService.VREnabled then
+				return
+			end
+			if newState == Enum.HumanoidStateType.Jumping then
+				isJumping = true
+			elseif newState == Enum.HumanoidStateType.Landed then
+				if snapPendingWhileJumping then
+					forceSnapTo(nil)
+					snapPendingWhileJumping = false
+				end
+				isJumping = false
+			elseif newState == Enum.HumanoidStateType.Dead then
+				forceSnapTo(nil)
+			elseif newState == Enum.HumanoidStateType.Swimming then
+				if isJumping and snapPendingWhileJumping then
+					--Jumped into water and let go of controls during flight, treat as a normal landing
+					forceSnapTo(nil)
+					snapPendingWhileJumping = false
+				end
+				isJumping = false
+			end
+		end)
+
+		local humanoidRootPart = humanoid.Torso
+		humanoidRootPart.Changed:connect(function(property)
+			local camera = workspace.CurrentCamera
+			local cameraSubject = camera.CameraSubject
+			if camera and cameraSubject == humanoid and property == "CFrame" or property == "Position" then
+				if (humanoidRootPart.Position - lastKnownTorsoPosition).magnitude > 5 then
+					forceSnapTo(nil)
+				end
+			end
+		end)
+	end
+	
+	if LocalPlayer.Character then
+		onCharacterAdded(LocalPlayer.Character)		
+	end
+	LocalPlayer.CharacterAdded:connect(onCharacterAdded)
+	
+	spawn(function()
+		local rootCamera = script.Parent
+		if not rootCamera then return end
+		
+		local cameraScript = rootCamera.Parent
+		if not cameraScript then return end
+		
+		local playerScripts = cameraScript.Parent
+		if not playerScripts then return end
+		
+		local controlScript = playerScripts:WaitForChild("ControlScript")
+		local masterControlModule = controlScript:WaitForChild("MasterControl")
+		local vrNavigationModule = masterControlModule:WaitForChild("VRNavigation")
+		local movementUpdateEvent = vrNavigationModule:WaitForChild("MovementUpdate")
+		
+		movementUpdateEventConn = movementUpdateEvent.Event:connect(onMovementUpdateEvent)
+	end)
+	
+	local onCameraSubjectChangedConn = nil
+	local function onCameraSubjectChanged()
+		local camera = workspace.CurrentCamera
+		if camera and camera.CameraSubject then
+			delay(1, function () forceSnap = true end)
+		end
+	end
+
+	local function onCurrentCameraChanged()
+		if onCameraSubjectChangedConn then
+			onCameraSubjectChangedConn:disconnect()
+			onCameraSubjectChangedConn = nil
+		end
+		if workspace.CurrentCamera then
+			onCameraSubjectChangedConn = workspace.CurrentCamera:GetPropertyChangedSignal("CameraSubject"):connect(onCameraSubjectChanged)
+			onCameraSubjectChanged()
+		end
+	end
+	workspace:GetPropertyChangedSignal("CurrentCamera"):connect(onCurrentCameraChanged)
+	onCurrentCameraChanged()
+	
+	local function onVREnabled()
+		bindActions(VRService.VREnabled)
+	end
+	VRService:GetPropertyChangedSignal("VREnabled"):connect(onVREnabled)
+
+	function module:Update()
+		local now = tick()
+		local timeDelta = now - lastUpdate
+		
+		local camera = workspace.CurrentCamera
+		local cameraSubject = camera and camera.CameraSubject
+		local player = PlayersService.LocalPlayer
+		local subjectPosition = self:GetSubjectPosition()
+		local zoom = self:GetCameraZoom()
+		
+		local subjectPosition = self:GetSubjectPosition()
+		local gamepadRotation = self:UpdateGamepad()			
+		
+		if subjectPosition and currentDestination then
+			local dist = (currentDestination - subjectPosition).magnitude
+			if dist < 10 then
+				forceSnap = true
+				forceSnapPoint = currentDestination
+				currentDestination = nil
+			end
+		end
+		
+		if cameraSubject and cameraSubject:IsA("Humanoid") then
+			local rootPart = cameraSubject.RootPart
+			if rootPart then
+				lastKnownTorsoPosition = rootPart.Position
+			end
+		end
+		
+		local look = lastLook
+		if subjectPosition and forceSnap then
+			forceSnap = false
+
+			local newFocusPoint = subjectPosition
+			if forceSnapPoint then
+				newFocusPoint = Vector3.new(forceSnapPoint.X, subjectPosition.Y, forceSnapPoint.Z)
+			end			
+			
+			camera.Focus = CFrame.new(newFocusPoint)
+			forceSnapPoint = nil
+			look = camera:GetRenderCFrame().lookVector
+			snappedHeadOffset = VRService:GetUserCFrame(Enum.UserCFrame.Head).p
+		end
+		if subjectPosition and player and camera then			
+			local cameraFocusP = camera.Focus.p
+			self.RotateInput = ZERO_VECTOR2
+			look = (look * XZ_VECTOR).unit
+			camera.CFrame = CFrame.new(cameraFocusP - (HORZ_OFFSET * look)) + Vector3.new(0, HEIGHT_OFFSET, 0) - snappedHeadOffset
+			
+			self.LastCameraTransform = camera.CFrame
+			self.LastCameraFocus = camera.Focus
+		end
+		lastLook = look
+		
+		lastUpdate = now
+	end
+	
+	return module
+end
+
+return CreateVRCamera
+

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/RootCamera/WatchCamera.lua

@@ -0,0 +1,63 @@
+local PlayersService = game:GetService('Players')
+local RootCameraCreator = require(script.Parent)
+
+local ZERO_VECTOR2 = Vector2.new(0, 0)
+
+local CFrame_new = CFrame.new
+
+local function CreateWatchCamera()
+	local module = RootCameraCreator()
+	module.PanEnabled = false
+	
+	local lastUpdate = tick()
+	function module:Update()
+		local now = tick()
+		
+		local camera = workspace.CurrentCamera
+		local player = PlayersService.LocalPlayer
+		
+		if lastUpdate == nil or now - lastUpdate > 1 then
+			module:ResetCameraLook()
+			self.LastZoom = nil
+		end	
+		
+
+		local subjectPosition = self:GetSubjectPosition()
+		if subjectPosition and player and camera then
+			local cameraLook = nil
+
+			local humanoid = self:GetHumanoid()
+			if humanoid and humanoid.Torso then
+				-- TODO: let the paging buttons move the camera but not the mouse/touch
+				-- currently neither do
+				local diffVector = subjectPosition - camera.CFrame.p
+				cameraLook = diffVector.unit
+
+				if self.LastZoom and self.LastZoom == self:GetCameraZoom() then
+					-- Don't clobber the zoom if they zoomed the camera
+					local zoom = diffVector.magnitude
+					self:ZoomCamera(zoom)
+				end
+			end
+			
+			local zoom = self:GetCameraZoom()
+			if zoom <= 0 then
+				zoom = 0.1
+			end
+			
+			local newLookVector = self:RotateVector(cameraLook or self:GetCameraLook(), self.RotateInput)
+			self.RotateInput = ZERO_VECTOR2
+			local newFocus = CFrame_new(subjectPosition)
+			local newCamCFrame = CFrame_new(newFocus.p - (zoom * newLookVector), subjectPosition)
+
+			camera.Focus = newFocus
+			camera.CFrame = newCamCFrame
+			self.LastZoom = zoom
+		end
+		lastUpdate = now
+	end
+	
+	return module
+end
+
+return CreateWatchCamera

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/ShiftLockController.lua

@@ -0,0 +1,206 @@
+--[[
+	// FileName: ShiftLockController
+	// Written by: jmargh
+	// Version 1.2
+	// Description: Manages the state of shift lock mode
+
+	// Required by:
+		RootCamera
+
+	// Note: ContextActionService sinks keys, so until we allow binding to ContextActionService without sinking
+	// keys, this module will use UserInputService.
+--]]
+
+local Players = game:GetService('Players')
+local UserInputService = game:GetService('UserInputService')
+-- Settings and GameSettings are read only
+local Settings = UserSettings()	-- ignore warning
+local GameSettings = Settings.GameSettings
+
+local ShiftLockController = {}
+
+--[[ Script Variables ]]--
+while not Players.LocalPlayer do
+	Players.PlayerAdded:wait()
+end
+
+local LocalPlayer = Players.LocalPlayer
+local Mouse = LocalPlayer:GetMouse()
+local PlayerGui = LocalPlayer:WaitForChild('PlayerGui')
+local ScreenGui = nil
+local ShiftLockIcon = nil
+local InputCn = nil
+local IsShiftLockMode = false
+local IsShiftLocked = false
+local IsActionBound = false
+local IsInFirstPerson = false
+
+-- Toggle Event
+ShiftLockController.OnShiftLockToggled = Instance.new('BindableEvent')
+
+-- wrapping long conditional in function
+local function isShiftLockMode()
+	return LocalPlayer.DevEnableMouseLock and GameSettings.ControlMode == Enum.ControlMode.MouseLockSwitch and
+			LocalPlayer.DevComputerMovementMode ~= Enum.DevComputerMovementMode.ClickToMove and
+			GameSettings.ComputerMovementMode ~= Enum.ComputerMovementMode.ClickToMove and
+			LocalPlayer.DevComputerMovementMode ~= Enum.DevComputerMovementMode.Scriptable
+end
+
+if not UserInputService.TouchEnabled then	-- TODO: Remove when safe on mobile
+	IsShiftLockMode = isShiftLockMode()
+end
+
+--[[ Constants ]]--
+local SHIFT_LOCK_OFF = 'rbxasset://textures/ui/mouseLock_off.png'
+local SHIFT_LOCK_ON = 'rbxasset://textures/ui/mouseLock_on.png'
+local SHIFT_LOCK_CURSOR = 'rbxasset://textures/MouseLockedCursor.png'
+
+--[[ Local Functions ]]--
+local function onShiftLockToggled()
+	IsShiftLocked = not IsShiftLocked
+	if IsShiftLocked then
+		ShiftLockIcon.Image = SHIFT_LOCK_ON
+		Mouse.Icon = SHIFT_LOCK_CURSOR
+	else
+		ShiftLockIcon.Image = SHIFT_LOCK_OFF
+		Mouse.Icon = ""
+	end
+	ShiftLockController.OnShiftLockToggled:Fire()
+end
+
+local function initialize()
+	if ScreenGui then
+		ScreenGui:Destroy()
+		ScreenGui = nil
+	end
+	ScreenGui = Instance.new('ScreenGui')
+	ScreenGui.Name = "ControlGui"
+	
+	local frame = Instance.new('Frame')
+	frame.Name = "BottomLeftControl"
+	frame.Size = UDim2.new(0, 130, 0, 46)
+	frame.Position = UDim2.new(0, 0, 1, -46)
+	frame.BackgroundTransparency = 1
+	frame.Parent = ScreenGui
+	
+	ShiftLockIcon = Instance.new('ImageButton')
+	ShiftLockIcon.Name = "MouseLockLabel"
+	ShiftLockIcon.Size = UDim2.new(0, 31, 0, 31)
+	ShiftLockIcon.Position = UDim2.new(0, 12, 0, 2)
+	ShiftLockIcon.BackgroundTransparency = 1
+	ShiftLockIcon.Image = IsShiftLocked and SHIFT_LOCK_ON or SHIFT_LOCK_OFF
+	ShiftLockIcon.Visible = true
+	ShiftLockIcon.Parent = frame
+	
+	ShiftLockIcon.MouseButton1Click:connect(onShiftLockToggled)
+	
+	ScreenGui.Parent = IsShiftLockMode and PlayerGui or nil
+end
+
+--[[ Public API ]]--
+function ShiftLockController:IsShiftLocked()
+	return IsShiftLockMode and IsShiftLocked
+end
+
+function ShiftLockController:SetIsInFirstPerson(isInFirstPerson)
+	IsInFirstPerson = isInFirstPerson
+end
+
+--[[ Input/Settings Changed Events ]]--
+local mouseLockSwitchFunc = function(actionName, inputState, inputObject)
+	if IsShiftLockMode then
+		onShiftLockToggled()
+	end
+end
+
+local function disableShiftLock()
+	if ScreenGui then ScreenGui.Parent = nil end
+	IsShiftLockMode = false
+	Mouse.Icon = ""
+	if InputCn then
+		InputCn:disconnect()
+		InputCn = nil
+	end
+	IsActionBound = false
+	ShiftLockController.OnShiftLockToggled:Fire()
+end
+
+-- TODO: Remove when we figure out ContextActionService without sinking keys
+local function onShiftInputBegan(inputObject, isProcessed)
+	if isProcessed then return end
+	if inputObject.UserInputType == Enum.UserInputType.Keyboard and
+		(inputObject.KeyCode == Enum.KeyCode.LeftShift or inputObject.KeyCode == Enum.KeyCode.RightShift) then
+		--
+		mouseLockSwitchFunc()
+	end
+end
+
+local function enableShiftLock()
+	IsShiftLockMode = isShiftLockMode()
+	if IsShiftLockMode then
+		if ScreenGui then
+			ScreenGui.Parent = PlayerGui
+		end
+		if IsShiftLocked then
+			Mouse.Icon = SHIFT_LOCK_CURSOR
+			ShiftLockController.OnShiftLockToggled:Fire()
+		end
+		if not IsActionBound then
+			InputCn = UserInputService.InputBegan:connect(onShiftInputBegan)
+			IsActionBound = true
+		end
+	end
+end
+
+GameSettings.Changed:connect(function(property)
+	if property == 'ControlMode' then
+		if GameSettings.ControlMode == Enum.ControlMode.MouseLockSwitch then
+			enableShiftLock()
+		else
+			disableShiftLock()
+		end
+	elseif property == 'ComputerMovementMode' then
+		if GameSettings.ComputerMovementMode == Enum.ComputerMovementMode.ClickToMove then
+			disableShiftLock()
+		else
+			enableShiftLock()
+		end
+	end
+end)
+
+LocalPlayer.Changed:connect(function(property)
+	if property == 'DevEnableMouseLock' then
+		if LocalPlayer.DevEnableMouseLock then
+			enableShiftLock()
+		else
+			disableShiftLock()
+		end
+	elseif property == 'DevComputerMovementMode' then
+		if LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.ClickToMove or
+			LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.Scriptable then
+			--
+			disableShiftLock()
+		else
+			enableShiftLock()
+		end
+	end
+end)
+
+LocalPlayer.CharacterAdded:connect(function(character)
+	-- we need to recreate guis on character load
+	if not UserInputService.TouchEnabled then
+		initialize()
+	end
+end)
+
+--[[ Initialization ]]--
+ -- TODO: Remove when safe! ContextActionService crashes touch clients with tupele is 2 or more
+if not UserInputService.TouchEnabled then
+	initialize()
+	if isShiftLockMode() then
+		InputCn = UserInputService.InputBegan:connect(onShiftInputBegan)
+		IsActionBound = true
+	end
+end
+
+return ShiftLockController

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/CameraScript/TransparencyController.lua

@@ -0,0 +1,190 @@
+-- SolarCrane
+
+local MAX_TWEEN_RATE = 2.8 -- per second
+
+local function clamp(low, high, num)
+	return (num > high and high or num < low and low or num)
+end
+
+local math_floor = math.floor
+
+local function Round(num, places)
+	local decimalPivot = 10^places
+	return math_floor(num * decimalPivot + 0.5) / decimalPivot
+end
+
+local function CreateTransparencyController()
+	local module = {}
+
+
+	local LastUpdate = tick()
+	local TransparencyDirty = false
+	local Enabled = false
+	local LastTransparency = nil
+
+	local DescendantAddedConn, DescendantRemovingConn = nil, nil
+	local ToolDescendantAddedConns = {}
+	local ToolDescendantRemovingConns = {}
+	local CachedParts = {}
+
+	local function HasToolAncestor(object)
+		if object.Parent == nil then return false end
+		return object.Parent:IsA('Tool') or HasToolAncestor(object.Parent)
+	end
+
+	local function IsValidPartToModify(part)
+		if part:IsA('BasePart') or part:IsA('Decal') then
+			return not HasToolAncestor(part)
+		end
+		return false
+	end
+
+	local function CachePartsRecursive(object)
+		if object then
+			if IsValidPartToModify(object) then
+				CachedParts[object] = true
+				TransparencyDirty = true
+			end
+			for _, child in pairs(object:GetChildren()) do
+				CachePartsRecursive(child)
+			end
+		end
+	end
+
+	local function TeardownTransparency()
+		for child, _ in pairs(CachedParts) do
+			child.LocalTransparencyModifier = 0
+		end
+		CachedParts = {}
+		TransparencyDirty = true
+		LastTransparency = nil
+
+		if DescendantAddedConn then
+			DescendantAddedConn:disconnect()
+			DescendantAddedConn = nil
+		end
+		if DescendantRemovingConn then
+			DescendantRemovingConn:disconnect()
+			DescendantRemovingConn = nil
+		end
+		for object, conn in pairs(ToolDescendantAddedConns) do
+			conn:disconnect()
+			ToolDescendantAddedConns[object] = nil
+		end
+		for object, conn in pairs(ToolDescendantRemovingConns) do
+			conn:disconnect()
+			ToolDescendantRemovingConns[object] = nil
+		end
+	end
+
+	local function SetupTransparency(character)
+		TeardownTransparency()
+
+		if DescendantAddedConn then DescendantAddedConn:disconnect() end
+		DescendantAddedConn = character.DescendantAdded:connect(function(object)
+			-- This is a part we want to invisify
+			if IsValidPartToModify(object) then
+				CachedParts[object] = true
+				TransparencyDirty = true
+			-- There is now a tool under the character
+			elseif object:IsA('Tool') then
+				if ToolDescendantAddedConns[object] then ToolDescendantAddedConns[object]:disconnect() end
+				ToolDescendantAddedConns[object] = object.DescendantAdded:connect(function(toolChild)
+					CachedParts[toolChild] = nil
+					if toolChild:IsA('BasePart') or toolChild:IsA('Decal') then
+						-- Reset the transparency
+						toolChild.LocalTransparencyModifier = 0
+					end
+				end)
+				if ToolDescendantRemovingConns[object] then ToolDescendantRemovingConns[object]:disconnect() end
+				ToolDescendantRemovingConns[object] = object.DescendantRemoving:connect(function(formerToolChild)
+					wait() -- wait for new parent
+					if character and formerToolChild and formerToolChild:IsDescendantOf(character) then
+						if IsValidPartToModify(formerToolChild) then
+							CachedParts[formerToolChild] = true
+							TransparencyDirty = true
+						end
+					end
+				end)
+			end
+		end)
+		if DescendantRemovingConn then DescendantRemovingConn:disconnect() end
+		DescendantRemovingConn = character.DescendantRemoving:connect(function(object)
+			if CachedParts[object] then
+				CachedParts[object] = nil
+				-- Reset the transparency
+				object.LocalTransparencyModifier = 0
+			end
+		end)
+		CachePartsRecursive(character)
+	end
+
+
+	function module:SetEnabled(newState)
+		if Enabled ~= newState then
+			Enabled = newState
+			self:Update()
+		end
+	end
+
+	function module: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
+			SetupTransparency(character)
+		else
+			TeardownTransparency()
+		end
+	end
+
+	function module:Update()
+		local instant = false
+		local now = tick()
+		local currentCamera = workspace.CurrentCamera
+
+		if currentCamera then
+			local transparency = 0
+			if not Enabled then
+				instant = true
+			else
+				local distance = (currentCamera.Focus.p - currentCamera.CoordinateFrame.p).magnitude
+				transparency = (7 - distance) / 5
+				if transparency < 0.5 then
+					transparency = 0
+				end
+
+				if LastTransparency then
+					local deltaTransparency = transparency - LastTransparency
+					-- Don't tween transparency if it is instant or your character was fully invisible last frame
+					if not instant and transparency < 1 and LastTransparency < 0.95 then
+						local maxDelta = MAX_TWEEN_RATE * (now - LastUpdate)
+						deltaTransparency = clamp(-maxDelta, maxDelta, deltaTransparency)
+					end
+					transparency = LastTransparency + deltaTransparency
+				else
+					TransparencyDirty = true
+				end
+
+				transparency = clamp(0, 1, Round(transparency, 2))
+			end
+
+			if TransparencyDirty or LastTransparency ~= transparency then
+				for child, _ in pairs(CachedParts) do
+					child.LocalTransparencyModifier = transparency
+				end
+				TransparencyDirty = false
+				LastTransparency = transparency
+			end
+		end
+		LastUpdate = now
+	end
+
+	return module
+end
+
+return CreateTransparencyController

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript.lua

@@ -0,0 +1,470 @@
+--[[
+	// FileName: ControlScript.lua
+	// Version 1.1
+	// Written by: jmargh and jeditkacheff
+	// Description: Manages in game controls for both touch and keyboard/mouse devices.
+	
+	// This script will be inserted into PlayerScripts under each player by default. If you want to
+	// create your own custom controls or modify these controls, you must place a script with this
+	// name, ControlScript, under StarterPlayer -> PlayerScripts.
+	
+	// Required Modules:
+		ClickToMove
+		DPad
+		KeyboardMovement
+		Thumbpad
+		Thumbstick
+		TouchJump
+		MasterControl
+		VehicleController
+--]]
+
+--[[ Services ]]--
+local ContextActionService = game:GetService('ContextActionService')
+local Players = game:GetService('Players')
+local UserInputService = game:GetService('UserInputService')
+local VRService = game:GetService('VRService')
+-- Settings and GameSettings are read only
+local Settings = UserSettings()
+local GameSettings = Settings.GameSettings
+
+-- Issue with play solo? (F6)
+while not UserInputService.KeyboardEnabled and not UserInputService.TouchEnabled and not UserInputService.GamepadEnabled do
+	wait()
+end
+
+--[[ Script Variables ]]--
+while not Players.LocalPlayer do
+	wait()
+end
+
+local lastInputType = nil
+local LocalPlayer = Players.LocalPlayer
+local PlayerGui = LocalPlayer:WaitForChild('PlayerGui')
+local IsTouchDevice = UserInputService.TouchEnabled
+local UserMovementMode = IsTouchDevice and GameSettings.TouchMovementMode or GameSettings.ComputerMovementMode
+local DevMovementMode = IsTouchDevice and LocalPlayer.DevTouchMovementMode or LocalPlayer.DevComputerMovementMode
+local IsUserChoice = (IsTouchDevice and DevMovementMode == Enum.DevTouchMovementMode.UserChoice) or (DevMovementMode == Enum.DevComputerMovementMode.UserChoice)
+local TouchGui = nil
+local TouchControlFrame = nil
+local IsModalEnabled = UserInputService.ModalEnabled
+local BindableEvent_OnFailStateChanged = nil
+local isJumpEnabled = false
+
+-- register what control scripts we are using
+do
+	local PlayerScripts = LocalPlayer:WaitForChild("PlayerScripts")
+	local canRegisterControls = pcall(function() PlayerScripts:RegisterTouchMovementMode(Enum.TouchMovementMode.Default) end)
+
+	if canRegisterControls then
+		PlayerScripts:RegisterTouchMovementMode(Enum.TouchMovementMode.Thumbstick)
+		PlayerScripts:RegisterTouchMovementMode(Enum.TouchMovementMode.DPad)
+		PlayerScripts:RegisterTouchMovementMode(Enum.TouchMovementMode.Thumbpad)
+		PlayerScripts:RegisterTouchMovementMode(Enum.TouchMovementMode.ClickToMove)
+		PlayerScripts:RegisterTouchMovementMode(Enum.TouchMovementMode.DynamicThumbstick)
+
+		PlayerScripts:RegisterComputerMovementMode(Enum.ComputerMovementMode.Default)
+		PlayerScripts:RegisterComputerMovementMode(Enum.ComputerMovementMode.KeyboardMouse)
+		PlayerScripts:RegisterComputerMovementMode(Enum.ComputerMovementMode.ClickToMove)
+	end
+end
+
+local DynamicThumbstickAvailable = pcall(function() 
+	return Enum.DevTouchMovementMode.DynamicThumbstick and Enum.TouchMovementMode.DynamicThumbstick
+end)
+
+--[[ Modules ]]--
+local ClickToMoveTouchControls = nil
+local ControlModules = {}
+
+local ControlState = {}
+ControlState.Current = nil
+function ControlState:SwitchTo(newControl)
+	if ControlState.Current == newControl then return end
+	
+	if ControlState.Current then
+		ControlState.Current:Disable()
+	end
+	
+	ControlState.Current = newControl
+	
+	if ControlState.Current then
+		ControlState.Current:Enable()
+	end
+end
+
+function ControlState:IsTouchJumpModuleUsed()
+	return isJumpEnabled
+end
+
+local MasterControl = require(script:WaitForChild('MasterControl'))
+--MasterControl needs access to ControlState in order to be able to fully enable and disable control
+MasterControl.ControlState = ControlState
+
+local DynamicThumbstickModule = require(script.MasterControl:WaitForChild('DynamicThumbstick'))
+local ThumbstickModule = require(script.MasterControl:WaitForChild('Thumbstick'))
+local ThumbpadModule = require(script.MasterControl:WaitForChild('Thumbpad'))
+local DPadModule = require(script.MasterControl:WaitForChild('DPad'))
+local TouchJumpModule = require(script.MasterControl:WaitForChild('TouchJump'))
+local ClickToMoveModule = require(script.MasterControl:WaitForChild('ClickToMoveController'))
+
+MasterControl.TouchJumpModule = TouchJumpModule
+local VRNavigationModule = require(script.MasterControl:WaitForChild('VRNavigation'))
+local keyboardModule = require(script.MasterControl:WaitForChild('KeyboardMovement'))
+ControlModules.Gamepad = require(script.MasterControl:WaitForChild('Gamepad'))
+
+function getTouchModule()
+
+	local module = nil
+	if not IsUserChoice then
+		if DynamicThumbstickAvailable and DevMovementMode == Enum.DevTouchMovementMode.DynamicThumbstick then
+			module = DynamicThumbstickModule
+			isJumpEnabled = true
+		elseif DevMovementMode == Enum.DevTouchMovementMode.Thumbstick then
+			module = ThumbstickModule
+			isJumpEnabled = true
+		elseif DevMovementMode == Enum.DevTouchMovementMode.Thumbpad then
+			module = ThumbpadModule
+			isJumpEnabled = true
+		elseif DevMovementMode == Enum.DevTouchMovementMode.DPad then
+			module = DPadModule
+			isJumpEnabled = false
+		elseif DevMovementMode == Enum.DevTouchMovementMode.ClickToMove then
+            module = ClickToMoveModule
+            isJumpEnabled = false -- TODO: What should this be, true or false?
+		elseif DevMovementMode == Enum.DevTouchMovementMode.Scriptable then
+			module = nil
+		end
+	else
+		if DynamicThumbstickAvailable and UserMovementMode == Enum.TouchMovementMode.DynamicThumbstick then
+			module = DynamicThumbstickModule
+			isJumpEnabled = true
+		elseif UserMovementMode == Enum.TouchMovementMode.Default or UserMovementMode == Enum.TouchMovementMode.Thumbstick then
+			module = ThumbstickModule
+			isJumpEnabled = true
+		elseif UserMovementMode == Enum.TouchMovementMode.Thumbpad then
+			module = ThumbpadModule
+			isJumpEnabled = true
+		elseif UserMovementMode == Enum.TouchMovementMode.DPad then
+			module = DPadModule
+			isJumpEnabled = false
+		elseif UserMovementMode == Enum.TouchMovementMode.ClickToMove then
+			module = ClickToMoveModule
+            isJumpEnabled = false -- TODO: What should this be, true or false?
+		end
+	end
+	return module
+end
+
+function setJumpModule(isEnabled)
+	if not isEnabled then
+		TouchJumpModule:Disable()
+	elseif ControlState.Current == ControlModules.Touch then
+		TouchJumpModule:Enable()
+	end
+end
+
+function setClickToMove()
+	if DevMovementMode == Enum.DevTouchMovementMode.ClickToMove or DevMovementMode == Enum.DevComputerMovementMode.ClickToMove or
+		UserMovementMode == Enum.ComputerMovementMode.ClickToMove or UserMovementMode == Enum.TouchMovementMode.ClickToMove then
+		if lastInputType == Enum.UserInputType.Touch then
+			ClickToMoveTouchControls = ControlState.Current
+		end
+	elseif ClickToMoveTouchControls then
+		ClickToMoveTouchControls:Disable()
+		ClickToMoveTouchControls = nil
+	end
+end
+
+ControlModules.Touch = {}
+ControlModules.Touch.Current = nil
+ControlModules.Touch.LocalPlayerChangedCon = nil
+ControlModules.Touch.GameSettingsChangedCon = nil
+
+function ControlModules.Touch:RefreshControlStyle()
+	if ControlModules.Touch.Current then
+		ControlModules.Touch.Current:Disable()
+	end
+	setJumpModule(false)
+	TouchJumpModule:Disable()
+	ControlModules.Touch:Enable()
+end
+function ControlModules.Touch:DisconnectEvents()
+	if ControlModules.Touch.LocalPlayerChangedCon then
+		ControlModules.Touch.LocalPlayerChangedCon:disconnect()
+		ControlModules.Touch.LocalPlayerChangedCon = nil
+	end
+	if ControlModules.Touch.GameSettingsChangedCon then
+		ControlModules.Touch.GameSettingsChangedCon:disconnect()
+		ControlModules.Touch.GameSettingsChangedCon = nil
+	end
+end
+function ControlModules.Touch:Enable()
+	DevMovementMode = LocalPlayer.DevTouchMovementMode
+	IsUserChoice = DevMovementMode == Enum.DevTouchMovementMode.UserChoice
+	if IsUserChoice then
+		UserMovementMode = GameSettings.TouchMovementMode
+	end
+		
+	local newModuleToEnable = getTouchModule()
+	if newModuleToEnable then
+		setClickToMove()
+		setJumpModule(isJumpEnabled)
+		
+		newModuleToEnable:Enable()
+		ControlModules.Touch.Current = newModuleToEnable
+				
+		if isJumpEnabled then TouchJumpModule:Enable() end
+	end
+	
+	-- This being within the above if statement was causing issues with ClickToMove, which isn't a module within this script.
+	ControlModules.Touch:DisconnectEvents()
+	ControlModules.Touch.LocalPlayerChangedCon = LocalPlayer:GetPropertyChangedSignal("DevTouchMovementMode"):connect(function()
+		ControlModules.Touch:RefreshControlStyle()
+	end)
+	ControlModules.Touch.GameSettingsChangedCon = GameSettings:GetPropertyChangedSignal("TouchMovementMode"):connect(function()
+		ControlModules.Touch:RefreshControlStyle()
+	end)
+end
+function ControlModules.Touch:Disable()
+	ControlModules.Touch:DisconnectEvents()
+	
+	local newModuleToDisable = getTouchModule()
+	
+	if newModuleToDisable == ThumbstickModule or
+		newModuleToDisable == DPadModule or
+		newModuleToDisable == ThumbpadModule or
+		newModuleToDisable == DynamicThumbstickModule then
+			newModuleToDisable:Disable()
+			setJumpModule(false)
+			TouchJumpModule:Disable()
+	end
+	
+	-- UserMovementMode will still have the previous value at this point
+	if UserMovementMode == Enum.ComputerMovementMode.ClickToMove then
+		ClickToMoveModule:Disable()
+	end
+end
+
+local function getKeyboardModule()
+	-- NOTE: Click to move still uses keyboard. Leaving cases in case this ever changes.
+	local whichModule = nil
+	if not IsUserChoice then
+		if DevMovementMode == Enum.DevComputerMovementMode.KeyboardMouse then
+			whichModule = keyboardModule
+		elseif DevMovementMode == Enum.DevComputerMovementMode.ClickToMove then
+			whichModule = keyboardModule
+		end 
+	else
+		if UserMovementMode == Enum.ComputerMovementMode.KeyboardMouse or UserMovementMode == Enum.ComputerMovementMode.Default then
+			whichModule = keyboardModule
+		elseif UserMovementMode == Enum.ComputerMovementMode.ClickToMove then
+			whichModule = keyboardModule
+		end
+	end
+
+	return whichModule
+end
+
+ControlModules.Keyboard = {}
+function ControlModules.Keyboard:RefreshControlStyle()
+	ControlModules.Keyboard:Disable()
+	ControlModules.Keyboard:Enable()
+end
+function ControlModules.Keyboard:Enable()
+	DevMovementMode = LocalPlayer.DevComputerMovementMode
+	IsUserChoice = DevMovementMode == Enum.DevComputerMovementMode.UserChoice
+	if IsUserChoice then
+		UserMovementMode = GameSettings.ComputerMovementMode
+	end
+		
+	local newModuleToEnable = getKeyboardModule()
+	if newModuleToEnable then
+		newModuleToEnable:Enable()
+	end
+	
+	if UserMovementMode == Enum.ComputerMovementMode.ClickToMove then
+		ClickToMoveModule:Enable()
+	end
+	
+	ControlModules.Keyboard:DisconnectEvents()
+	ControlModules.Keyboard.LocalPlayerChangedCon = LocalPlayer.Changed:connect(function(property)
+		if property == 'DevComputerMovementMode' then
+			ControlModules.Keyboard:RefreshControlStyle()
+		end
+	end)
+	
+	ControlModules.Keyboard.GameSettingsChangedCon = GameSettings.Changed:connect(function(property)
+		if property == 'ComputerMovementMode' then
+			ControlModules.Keyboard:RefreshControlStyle()
+		end
+	end)
+end
+function ControlModules.Keyboard:DisconnectEvents()
+	if ControlModules.Keyboard.LocalPlayerChangedCon then
+		ControlModules.Keyboard.LocalPlayerChangedCon:disconnect()
+		ControlModules.Keyboard.LocalPlayerChangedCon = nil
+	end
+	if ControlModules.Keyboard.GameSettingsChangedCon then
+		ControlModules.Keyboard.GameSettingsChangedCon:disconnect()
+		ControlModules.Keyboard.GameSettingsChangedCon = nil
+	end
+end
+function ControlModules.Keyboard:Disable()
+	ControlModules.Keyboard:DisconnectEvents()
+	local newModuleToDisable = getKeyboardModule()
+	if newModuleToDisable then
+		newModuleToDisable:Disable()
+	end
+	
+	-- UserMovementMode will still be set to previous movement type
+	if UserMovementMode == Enum.ComputerMovementMode.ClickToMove then
+		ClickToMoveModule:Disable()
+	end
+end
+
+ControlModules.VRNavigation = {}
+
+function ControlModules.VRNavigation:Enable()
+	VRNavigationModule:Enable()
+end
+
+function ControlModules.VRNavigation:Disable()
+	VRNavigationModule:Disable()
+end
+
+-- not used, but needs to be required
+local VehicleController = require(script.MasterControl:WaitForChild('VehicleController'))
+
+
+--[[ Initialization/Setup ]]--
+local function createTouchGuiContainer()
+	if TouchGui then TouchGui:Destroy() end
+	
+	-- Container for all touch device guis
+	TouchGui = Instance.new('ScreenGui')
+	TouchGui.Name = "TouchGui"
+	TouchGui.ResetOnSpawn = false
+	TouchGui.Parent = PlayerGui
+	
+	TouchControlFrame = Instance.new('Frame')
+	TouchControlFrame.Name = "TouchControlFrame"
+	TouchControlFrame.Size = UDim2.new(1, 0, 1, 0)
+	TouchControlFrame.BackgroundTransparency = 1
+	TouchControlFrame.Parent = TouchGui
+	
+	ThumbstickModule:Create(TouchControlFrame)
+	DPadModule:Create(TouchControlFrame)
+	ThumbpadModule:Create(TouchControlFrame)
+	TouchJumpModule:Create(TouchControlFrame)
+	DynamicThumbstickModule:Create(TouchControlFrame)
+end
+
+--[[ Settings Changed Connections ]]--
+LocalPlayer.Changed:connect(function(property)
+	if lastInputType == Enum.UserInputType.Touch and property == 'DevTouchMovementMode' then
+		ControlState:SwitchTo(ControlModules.Touch)
+	elseif UserInputService.KeyboardEnabled and property == 'DevComputerMovementMode' then
+		ControlState:SwitchTo(ControlModules.Keyboard)
+	end
+end)
+
+GameSettings.Changed:connect(function(property)
+	if not IsUserChoice then return end
+	if property == 'TouchMovementMode' or property == 'ComputerMovementMode' then
+		UserMovementMode = GameSettings[property]
+		if property == 'TouchMovementMode' then
+			ControlState:SwitchTo(ControlModules.Touch)
+		elseif property == 'ComputerMovementMode' then
+			ControlState:SwitchTo(ControlModules.Keyboard)
+		end
+	end
+end)
+
+--[[ Touch Events ]]--
+UserInputService.Changed:connect(function(property)
+	if property == 'ModalEnabled' then
+		IsModalEnabled = UserInputService.ModalEnabled
+
+		if lastInputType == Enum.UserInputType.Touch then
+			if ControlState.Current == ControlModules.Touch and IsModalEnabled then
+				ControlState:SwitchTo(nil)
+			elseif ControlState.Current == nil and not IsModalEnabled then
+				ControlState:SwitchTo(ControlModules.Touch)
+			end
+		end
+	end
+end)
+
+BindableEvent_OnFailStateChanged = MasterControl:GetClickToMoveFailStateChanged()
+
+if BindableEvent_OnFailStateChanged then
+	BindableEvent_OnFailStateChanged.Event:connect(function(isOn)
+		if lastInputType == Enum.UserInputType.Touch and ClickToMoveTouchControls then
+			if isOn then
+				ControlState:SwitchTo(ClickToMoveTouchControls)
+			else
+				ControlState:SwitchTo(nil)
+			end
+		end
+	end)
+end
+
+local switchToInputType = function(newLastInputType)
+	lastInputType = newLastInputType
+	
+	if VRService.VREnabled then
+		ControlState:SwitchTo(ControlModules.VRNavigation)
+		return
+	end
+
+	if lastInputType == Enum.UserInputType.Touch then
+				ControlState:SwitchTo(ControlModules.Touch)
+	elseif lastInputType == Enum.UserInputType.Keyboard or
+			lastInputType == Enum.UserInputType.MouseButton1 or
+			lastInputType == Enum.UserInputType.MouseButton2 or
+			lastInputType == Enum.UserInputType.MouseButton3 or
+			lastInputType == Enum.UserInputType.MouseWheel or
+			lastInputType == Enum.UserInputType.MouseMovement  then
+				ControlState:SwitchTo(ControlModules.Keyboard)
+	elseif lastInputType == Enum.UserInputType.Gamepad1 or
+			lastInputType == Enum.UserInputType.Gamepad2 or
+			lastInputType == Enum.UserInputType.Gamepad3 or
+			lastInputType == Enum.UserInputType.Gamepad4 then
+				ControlState:SwitchTo(ControlModules.Gamepad)
+	end
+end
+
+if IsTouchDevice then
+	createTouchGuiContainer()
+end
+
+MasterControl:Init()
+
+UserInputService.GamepadDisconnected:connect(function(gamepadEnum)
+	local connectedGamepads = UserInputService:GetConnectedGamepads()
+	if #connectedGamepads > 0 then return end
+	
+	if not VRService.VREnabled then
+		if UserInputService.KeyboardEnabled then
+			ControlState:SwitchTo(ControlModules.Keyboard)
+		elseif IsTouchDevice then
+			ControlState:SwitchTo(ControlModules.Touch)
+		end
+	end
+end)
+
+UserInputService.GamepadConnected:connect(function(gamepadEnum)
+	if not VRService.VREnabled then
+		ControlState:SwitchTo(ControlModules.Gamepad)
+	end
+end)
+
+switchToInputType(UserInputService:GetLastInputType())
+UserInputService.LastInputTypeChanged:connect(switchToInputType)
+
+VRService:GetPropertyChangedSignal("VREnabled"):Connect(function()	
+	if VRService.VREnabled then
+		ControlState:SwitchTo(ControlModules.VRNavigation)
+	end
+end)

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/.robloxrc

@@ -0,0 +1,5 @@
+{
+	"lint": {
+		"ImportUnused": "fatal"
+	}
+}

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/MasterControl.lua

@@ -0,0 +1,174 @@
+--[[
+	// FileName: MasterControl
+	// Version 1.0
+	// Written by: jeditkacheff
+	// Description: All character control scripts go thru this script, this script makes sure all actions are performed
+--]]
+
+-- [[ Constants ]]--
+local ZERO_VECTOR3 = Vector3.new(0, 0, 0)
+local STATE_JUMPING = Enum.HumanoidStateType.Jumping
+local STATE_FREEFALL = Enum.HumanoidStateType.Freefall
+local STATE_LANDED = Enum.HumanoidStateType.Landed
+
+--[[ Local Variables ]]--
+local MasterControl = {}
+
+local Players = game:GetService('Players')
+local RunService = game:GetService('RunService')
+
+while not Players.LocalPlayer do
+	Players.PlayerAdded:wait()
+end
+local LocalPlayer = Players.LocalPlayer
+local LocalCharacter = LocalPlayer.Character
+local CachedHumanoid = nil
+
+local isJumping = false
+local moveValue = Vector3.new(0, 0, 0)
+
+local isJumpEnabled = true
+local areControlsEnabled = true
+
+local clickToMoveFailStateChanged = Instance.new("BindableEvent")
+clickToMoveFailStateChanged.Name = "ClickToMoveFailStateChanged"
+
+--[[ Local Functions ]]--
+function MasterControl:GetHumanoid()
+	if LocalCharacter then
+		if CachedHumanoid then
+			return CachedHumanoid
+		else
+			CachedHumanoid = LocalCharacter:FindFirstChildOfClass("Humanoid")
+			return CachedHumanoid
+		end
+	end
+end
+
+local characterAncestryChangedConn = nil
+local characterChildRemovedConn = nil
+local function characterAdded(character)
+	if characterAncestryChangedConn then
+		characterAncestryChangedConn:disconnect()
+	end
+
+	if characterChildRemovedConn then
+		characterChildRemovedConn:disconnect()
+	end	
+	
+	LocalCharacter = character
+	CachedHumanoid = LocalCharacter:FindFirstChildOfClass("Humanoid")
+	characterAncestryChangedConn = character.AncestryChanged:connect(function()
+		if character.Parent == nil then
+			LocalCharacter = nil
+		else
+			LocalCharacter = character
+		end
+	end)
+	
+	characterChildRemovedConn = character.ChildRemoved:connect(function(child)
+		if child == CachedHumanoid then
+			CachedHumanoid = nil
+		end
+	end)
+end
+
+if LocalCharacter then
+	characterAdded(LocalCharacter)
+end
+LocalPlayer.CharacterAdded:connect(characterAdded)
+
+
+local getHumanoid = MasterControl.GetHumanoid
+local moveFunc = LocalPlayer.Move
+local updateMovement = function()
+	
+	if not areControlsEnabled then return end
+	
+	local humanoid = getHumanoid()
+	if not humanoid then return end
+	
+	if isJumpEnabled and isJumping and not humanoid.PlatformStand then
+		local state = humanoid:GetState()
+		if state ~= STATE_JUMPING and state ~= STATE_FREEFALL and state ~= STATE_LANDED then
+			humanoid.Jump = isJumping
+		end
+	end
+
+	moveFunc(LocalPlayer, moveValue, true)
+end
+
+--[[ Public API ]]--
+function MasterControl:Init()
+	RunService:BindToRenderStep("MasterControlStep", Enum.RenderPriority.Input.Value, updateMovement)
+end
+
+function MasterControl:Enable()
+	areControlsEnabled = true
+	isJumpEnabled = true
+	
+	if self.ControlState.Current then
+		self.ControlState.Current:Enable()
+	end
+end
+
+function MasterControl:Disable()
+	
+	if self.ControlState.Current then
+		self.ControlState.Current:Disable()
+	end
+	
+	--After current control state is disabled, moveValue has been set to zero,
+	--Call updateMovement one last time to make sure this propagates to the engine -
+	--Otherwise if disabled while humanoid is moving, humanoid won't stop moving.
+	updateMovement()
+	
+	isJumping = false
+	areControlsEnabled = false
+end
+
+function MasterControl:EnableJump()
+	isJumpEnabled = true
+	if areControlsEnabled and self.ControlState:IsTouchJumpModuleUsed() then
+		self.TouchJumpModule:Enable()
+	end
+end
+
+function MasterControl:DisableJump()
+	isJumpEnabled = false
+	if self.ControlState:IsTouchJumpModuleUsed() then
+		self.TouchJumpModule:Disable()
+	end
+end
+
+function MasterControl:AddToPlayerMovement(playerMoveVector)
+	moveValue = Vector3.new(moveValue.X + playerMoveVector.X, moveValue.Y + playerMoveVector.Y, moveValue.Z + playerMoveVector.Z)
+end
+
+function MasterControl:GetMoveVector()
+	return moveValue
+end
+
+function MasterControl:SetIsJumping(jumping)
+	if not isJumpEnabled then return end
+	isJumping = jumping
+	local humanoid = self:GetHumanoid()
+	if humanoid and not humanoid.PlatformStand then
+		humanoid.Jump = isJumping
+	end
+end
+
+function MasterControl:DoJump()
+	if not isJumpEnabled then return end
+	local humanoid = self:GetHumanoid()
+	if humanoid then
+		humanoid.Jump = true
+	end
+end
+
+function MasterControl:GetClickToMoveFailStateChanged()
+	return clickToMoveFailStateChanged
+end
+
+return MasterControl
+

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/MasterControl/DPad.lua

@@ -0,0 +1,170 @@
+--[[
+	// FileName: DPad
+	// Version 1.0
+	// Written by: jmargh
+	// Description: Implements DPad controls for touch devices
+--]]
+
+local Players = game:GetService('Players')
+local GuiService = game:GetService('GuiService')
+
+local DPad = {}
+
+local MasterControl = require(script.Parent)
+
+--[[ Script Variables ]]--
+while not Players.LocalPlayer do
+	wait()
+end
+local LocalPlayer = Players.LocalPlayer
+local DPadFrame = nil
+local TouchObject = nil
+local OnInputEnded = nil		-- defined in Create()
+
+--[[ Constants ]]--
+local DPAD_SHEET = "rbxasset://textures/ui/DPadSheet.png"
+local COMPASS_DIR = {
+	Vector3.new(1, 0, 0),			-- E
+	Vector3.new(1, 0, 1).unit,		-- SE
+	Vector3.new(0, 0, 1),			-- S
+	Vector3.new(-1, 0, 1).unit,		-- SW
+	Vector3.new(-1, 0, 0),			-- W
+	Vector3.new(-1, 0, -1).unit,	-- NW
+	Vector3.new(0, 0, -1),			-- N
+	Vector3.new(1, 0, -1).unit,		-- NE
+}
+
+--[[ lua Function Cache ]]--
+local ATAN2 = math.atan2
+local FLOOR = math.floor
+local PI = math.pi
+
+--[[ Local Functions ]]--
+local function createArrowLabel(name, position, size, rectOffset, rectSize)
+	local image = Instance.new('ImageLabel')
+	image.Name = name
+	image.Image = DPAD_SHEET
+	image.ImageRectOffset = rectOffset
+	image.ImageRectSize = rectSize
+	image.BackgroundTransparency = 1
+	image.Size = size
+	image.Position = position
+	image.Parent = DPadFrame
+	
+	return image
+end
+
+local function getCenterPosition()
+	return Vector2.new(DPadFrame.AbsolutePosition.x + DPadFrame.AbsoluteSize.x/2, DPadFrame.AbsolutePosition.y + DPadFrame.AbsoluteSize.y/2)
+end
+
+--[[ Public API ]]--
+function DPad:Enable()
+	DPadFrame.Visible = true
+end
+
+function DPad:Disable()
+	DPadFrame.Visible = false
+	OnInputEnded()
+end
+
+function DPad:Create(parentFrame)
+	if DPadFrame then
+		DPadFrame:Destroy()
+		DPadFrame = nil
+	end
+	
+	local position = UDim2.new(0, 10, 1, -230)
+	DPadFrame = Instance.new('Frame')
+	DPadFrame.Name = "DPadFrame"
+	DPadFrame.Active = true
+	DPadFrame.Visible = false
+	DPadFrame.Size = UDim2.new(0, 192, 0, 192)
+	DPadFrame.Position = position
+	DPadFrame.BackgroundTransparency = 1
+	
+	local smArrowSize = UDim2.new(0, 23, 0, 23)
+	local lgArrowSize = UDim2.new(0, 64, 0, 64)
+	local smImgOffset = Vector2.new(46, 46)
+	local lgImgOffset = Vector2.new(128, 128)
+	
+	local bBtn = createArrowLabel("BackButton", UDim2.new(0.5, -32, 1, -64), lgArrowSize, Vector2.new(0, 0), lgImgOffset)
+	local fBtn = createArrowLabel("ForwardButton", UDim2.new(0.5, -32, 0, 0), lgArrowSize, Vector2.new(0, 258), lgImgOffset)
+	local lBtn = createArrowLabel("LeftButton", UDim2.new(0, 0, 0.5, -32), lgArrowSize, Vector2.new(129, 129), lgImgOffset)
+	local rBtn = createArrowLabel("RightButton", UDim2.new(1, -64, 0.5, -32), lgArrowSize, Vector2.new(0, 129), lgImgOffset)
+	local jumpBtn = createArrowLabel("JumpButton", UDim2.new(0.5, -32, 0.5, -32), lgArrowSize, Vector2.new(129, 0), lgImgOffset)
+	local flBtn = createArrowLabel("ForwardLeftButton", UDim2.new(0, 35, 0, 35), smArrowSize, Vector2.new(129, 258), smImgOffset)
+	local frBtn = createArrowLabel("ForwardRightButton", UDim2.new(1, -55, 0, 35), smArrowSize, Vector2.new(176, 258), smImgOffset)
+	flBtn.Visible = false
+	frBtn.Visible = false
+	
+	-- input connections
+	jumpBtn.InputBegan:connect(function(inputObject)
+		MasterControl:DoJump()
+	end)
+	
+	local movementVector = Vector3.new(0,0,0)
+	local function normalizeDirection(inputPosition)
+		local jumpRadius = jumpBtn.AbsoluteSize.x/2
+		local centerPosition = getCenterPosition()
+		local direction = Vector2.new(inputPosition.x - centerPosition.x, inputPosition.y - centerPosition.y)
+		
+		if direction.magnitude > jumpRadius then
+			local angle = ATAN2(direction.y, direction.x)
+			local octant = (FLOOR(8 * angle / (2 * PI) + 8.5)%8) + 1
+			movementVector = COMPASS_DIR[octant]
+		end
+		
+		if not flBtn.Visible and movementVector == COMPASS_DIR[7] then
+			flBtn.Visible = true
+			frBtn.Visible = true
+		end
+	end
+	
+	DPadFrame.InputBegan:connect(function(inputObject)
+		if TouchObject or inputObject.UserInputType ~= Enum.UserInputType.Touch then
+			return
+		end
+		
+		MasterControl:AddToPlayerMovement(-movementVector)
+		
+		TouchObject = inputObject
+		normalizeDirection(TouchObject.Position)
+		
+		MasterControl:AddToPlayerMovement(movementVector)
+	end)
+	
+	DPadFrame.InputChanged:connect(function(inputObject)
+		if inputObject == TouchObject then
+			MasterControl:AddToPlayerMovement(-movementVector)
+			normalizeDirection(TouchObject.Position)
+			MasterControl:AddToPlayerMovement(movementVector)
+			MasterControl:SetIsJumping(false)
+		end
+	end)
+	
+	OnInputEnded = function()
+		TouchObject = nil
+		flBtn.Visible = false
+		frBtn.Visible = false
+		
+		MasterControl:AddToPlayerMovement(-movementVector)
+		movementVector = Vector3.new(0, 0, 0)
+	end
+	
+	DPadFrame.InputEnded:connect(function(inputObject)
+		if inputObject == TouchObject then
+			OnInputEnded()
+		end
+	end)
+	
+	GuiService.MenuOpened:connect(function()
+		if TouchObject then
+			OnInputEnded()
+		end
+	end)
+	
+	DPadFrame.Parent = parentFrame
+end
+
+return DPad

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/MasterControl/DynamicThumbstick.lua

@@ -0,0 +1,559 @@
+--[[
+	// FileName: DynamicThumbstick
+	// Version 0.9
+	// Written by: jhelms
+	// Description: Implements dynamic thumbstick controls for touch devices
+--]]
+local Players = game:GetService("Players")
+local UserInputService = game:GetService("UserInputService")
+local GuiService = game:GetService("GuiService")
+local RunService = game:GetService("RunService")
+local TweenService = game:GetService("TweenService")
+local Settings = UserSettings()
+local GameSettings = Settings.GameSettings
+
+local MasterControl = require(script.Parent)
+
+local Thumbstick = {}
+local Enabled = false
+
+--[[ Script Variables ]]--
+while not Players.LocalPlayer do
+	Players.PlayerAdded:wait()
+end
+local LocalPlayer = Players.LocalPlayer
+
+local Tools = {}
+local ToolEquipped = nil
+
+local RevertAutoJumpEnabledToFalse = false
+
+local ThumbstickFrame = nil
+local GestureArea = nil
+local StartImage = nil
+local EndImage = nil
+local MiddleImages = {}
+
+local MoveTouchObject = nil
+local IsFollowStick = false
+local ThumbstickFrame = nil
+local OnMoveTouchEnded = nil		-- defined in Create()
+local OnTouchMovedCn = nil
+local OnTouchEndedCn = nil
+local TouchActivateCn = nil
+local OnRenderSteppedCn = nil
+local currentMoveVector = Vector3.new(0,0,0)
+local IsFirstTouch = true
+
+--[[ Constants ]]--
+
+local TOUCH_CONTROLS_SHEET = "rbxasset://textures/ui/Input/TouchControlsSheetV2.png"
+
+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 TOUCH_IS_TAP_TIME_THRESHOLD = 0.5
+local TOUCH_IS_TAP_DISTANCE_THRESHOLD = 25
+
+local HasFadedBackgroundInPortrait = false
+local HasFadedBackgroundInLandscape = false
+local FadeInAndOutBackground = true
+local FadeInAndOutMaxAlpha = 0.35
+local TweenInAlphaStart = nil
+local TweenOutAlphaStart = nil
+
+local FADE_IN_OUT_HALF_DURATION_DEFAULT = 0.3
+local FADE_IN_OUT_HALF_DURATION_ORIENTATION_CHANGE = 2
+local FADE_IN_OUT_BALANCE_DEFAULT = 0.5
+local FadeInAndOutHalfDuration = FADE_IN_OUT_HALF_DURATION_DEFAULT
+local FadeInAndOutBalance = FADE_IN_OUT_BALANCE_DEFAULT
+
+local ThumbstickFadeTweenInfo = TweenInfo.new(0.15, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut)
+
+--[[ Local functionality ]]--
+
+local function isDynamicThumbstickEnabled()
+	return ThumbstickFrame and ThumbstickFrame.Visible
+end
+
+local function enableAutoJump(humanoid)
+	if humanoid and isDynamicThumbstickEnabled() then
+		local shouldRevert = humanoid.AutoJumpEnabled == false
+		shouldRevert = shouldRevert and LocalPlayer.DevTouchMovementMode == Enum.DevTouchMovementMode.UserChoice
+		RevertAutoJumpEnabledToFalse = shouldRevert
+		humanoid.AutoJumpEnabled = true
+	end
+end
+
+do
+	local function onCharacterAdded(character)	
+		for _, child in ipairs(LocalPlayer.Character:GetChildren()) do
+			if child:IsA("Tool") then
+				ToolEquipped = child
+			end
+		end
+		character.ChildAdded:Connect(function(child)
+			if child:IsA("Tool") then
+				ToolEquipped = child
+			elseif child:IsA("Humanoid") then
+				enableAutoJump(child)
+			end
+		end)
+		character.ChildRemoved:Connect(function(child)
+			if child:IsA("Tool") then
+				if child == ToolEquipped then
+					ToolEquipped = nil
+				end
+			end
+		end)
+		
+		local humanoid = character:FindFirstChildOfClass("Humanoid")
+		if humanoid then
+			enableAutoJump(humanoid)
+		end
+	end
+	LocalPlayer.CharacterAdded:Connect(onCharacterAdded)
+	if LocalPlayer.Character then
+		onCharacterAdded(LocalPlayer.Character)
+	end
+end
+
+
+
+--[[ Public API ]]--
+function Thumbstick:Enable()
+	Enabled = true
+	ThumbstickFrame.Visible = true
+	local humanoid = MasterControl:GetHumanoid()
+	enableAutoJump(humanoid)
+end
+
+function Thumbstick:Disable()
+	Enabled = false
+	if RevertAutoJumpEnabledToFalse then
+		local humanoid = MasterControl:GetHumanoid()
+		if humanoid then
+			humanoid.AutoJumpEnabled = false
+		end
+	end
+	ThumbstickFrame.Visible = false
+	OnMoveTouchEnded()
+end
+
+function Thumbstick:GetInputObject()
+    return MoveTouchObject
+end
+
+function Thumbstick:Create(parentFrame)
+	if ThumbstickFrame then
+		ThumbstickFrame:Destroy()
+		ThumbstickFrame = nil
+		if OnTouchMovedCn then
+			OnTouchMovedCn:disconnect()
+			OnTouchMovedCn = nil
+		end
+		if OnTouchEndedCn then
+			OnTouchEndedCn:disconnect()
+			OnTouchEndedCn = nil
+		end
+		if OnRenderSteppedCn then
+			OnRenderSteppedCn:disconnect()
+			OnRenderSteppedCn = nil
+		end
+		if TouchActivateCn then
+			TouchActivateCn:disconnect()
+			TouchActivateCn = nil
+		end
+	end
+	
+	local ThumbstickSize = 45
+	local ThumbstickRingSize = 20
+	local MiddleSize = 10
+	local MiddleSpacing = MiddleSize + 4
+	local RadiusOfDeadZone = 2
+	local RadiusOfMaxSpeed = 50
+	
+	local screenSize = parentFrame.AbsoluteSize
+	local isBigScreen = math.min(screenSize.x, screenSize.y) > 500
+	if isBigScreen then
+		ThumbstickSize = ThumbstickSize * 2
+		ThumbstickRingSize = ThumbstickRingSize * 2
+		MiddleSize = MiddleSize * 2
+		MiddleSpacing = MiddleSpacing * 2
+		RadiusOfDeadZone = RadiusOfDeadZone * 2
+		RadiusOfMaxSpeed = RadiusOfMaxSpeed * 2
+	end
+	
+	local color = Color3.fromRGB(255, 255, 255)
+	
+	local function layoutThumbstickFrame(portraitMode)
+		if portraitMode then
+			ThumbstickFrame.Size = UDim2.new(1, 0, 0.4, 0)
+			ThumbstickFrame.Position = UDim2.new(0, 0, 0.6, 0)
+			GestureArea.Size = UDim2.new(1, 0, 0.6, 0)
+			GestureArea.Position = UDim2.new(0, 0, 0, 0)
+		else
+			ThumbstickFrame.Size = UDim2.new(0.4, 0, 2/3, 0)
+			ThumbstickFrame.Position = UDim2.new(0, 0, 1/3, 0)
+			GestureArea.Size = UDim2.new(1, 0, 1, 0)
+			GestureArea.Position = UDim2.new(0, 0, 0, 0)
+		end
+	end
+
+	GestureArea = Instance.new("Frame")
+	GestureArea.Name = "GestureArea"
+	GestureArea.Active = false
+	GestureArea.Visible = true
+	GestureArea.BackgroundTransparency = 1
+	GestureArea.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
+		
+	ThumbstickFrame = Instance.new('Frame')
+	ThumbstickFrame.Name = "DynamicThumbstickFrame"
+	ThumbstickFrame.Active = false
+	ThumbstickFrame.Visible = false
+	ThumbstickFrame.BackgroundTransparency = 1.0
+	ThumbstickFrame.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
+	layoutThumbstickFrame()
+
+	StartImage = Instance.new("ImageLabel")
+	StartImage.Name = "ThumbstickStart"
+	StartImage.Visible = true
+	StartImage.BackgroundTransparency = 1
+	
+	StartImage.Image = TOUCH_CONTROLS_SHEET
+	StartImage.ImageRectOffset = Vector2.new(1,1)
+	StartImage.ImageRectSize = Vector2.new(144, 144)
+	StartImage.ImageColor3 = Color3.new(0, 0, 0)
+	StartImage.AnchorPoint = Vector2.new(0.5, 0.5)
+	StartImage.Position = UDim2.new(0, ThumbstickRingSize * 3.3, 1, -ThumbstickRingSize * 2.8)
+	StartImage.Size = UDim2.new(0, ThumbstickRingSize * 3.7, 0, ThumbstickRingSize * 3.7)
+	StartImage.ZIndex = 10
+	StartImage.Parent = ThumbstickFrame
+	
+	EndImage = Instance.new("ImageLabel")
+	EndImage.Name = "ThumbstickEnd"
+	EndImage.Visible = true
+	EndImage.BackgroundTransparency = 1
+	EndImage.Image = TOUCH_CONTROLS_SHEET
+	EndImage.ImageRectOffset = Vector2.new(1,1)
+	EndImage.ImageRectSize =  Vector2.new(144, 144)
+	EndImage.AnchorPoint = Vector2.new(0.5, 0.5)
+	EndImage.Position = StartImage.Position
+	EndImage.Size = UDim2.new(0, ThumbstickSize * 0.8, 0, ThumbstickSize * 0.8)
+	EndImage.ZIndex = 10
+	EndImage.Parent = ThumbstickFrame
+	
+	for i = 1, NUM_MIDDLE_IMAGES do
+		MiddleImages[i] = Instance.new("ImageLabel")
+		MiddleImages[i].Name = "ThumbstickMiddle"
+		MiddleImages[i].Visible = false
+		MiddleImages[i].BackgroundTransparency = 1
+		MiddleImages[i].Image = TOUCH_CONTROLS_SHEET
+		MiddleImages[i].ImageRectOffset = Vector2.new(1,1)
+		MiddleImages[i].ImageRectSize = Vector2.new(144, 144)
+		MiddleImages[i].ImageTransparency = MIDDLE_TRANSPARENCIES[i]
+		MiddleImages[i].AnchorPoint = Vector2.new(0.5, 0.5)
+		MiddleImages[i].ZIndex = 9
+		MiddleImages[i].Parent = 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
+	
+	MoveTouchObject = nil
+	local MoveTouchStartTime = nil
+	local MoveTouchStartPosition = nil
+
+	local startImageFadeTween, endImageFadeTween, middleImageFadeTweens = nil, nil, {}
+	local function fadeThumbstick(visible)
+		if not visible and MoveTouchObject then
+			return
+		end
+		if IsFirstTouch then return end
+		
+		if startImageFadeTween then
+			startImageFadeTween:Cancel()
+		end
+		if endImageFadeTween then
+			endImageFadeTween:Cancel()
+		end
+		for i = 1, #MiddleImages do
+			if middleImageFadeTweens[i] then
+				middleImageFadeTweens[i]:Cancel()
+			end
+		end
+
+		if visible then
+			startImageFadeTween = TweenService:Create(StartImage, ThumbstickFadeTweenInfo, { ImageTransparency = 0 })
+			startImageFadeTween:Play()
+
+			endImageFadeTween = TweenService:Create(EndImage, ThumbstickFadeTweenInfo, { ImageTransparency = 0.2 })
+			endImageFadeTween:Play()
+
+			for i = 1, #MiddleImages do
+				middleImageFadeTweens[i] = TweenService:Create(MiddleImages[i], ThumbstickFadeTweenInfo, { ImageTransparency = MIDDLE_TRANSPARENCIES[i] })
+				middleImageFadeTweens[i]:Play()
+			end
+		else
+			startImageFadeTween = TweenService:Create(StartImage, ThumbstickFadeTweenInfo, { ImageTransparency = 1 })
+			startImageFadeTween:Play()
+
+			endImageFadeTween = TweenService:Create(EndImage, ThumbstickFadeTweenInfo, { ImageTransparency = 1 })
+			endImageFadeTween:Play()
+
+			for i = 1, #MiddleImages do
+				middleImageFadeTweens[i] = TweenService:Create(MiddleImages[i], ThumbstickFadeTweenInfo, { ImageTransparency = 1 })
+				middleImageFadeTweens[i]:Play()
+			end
+		end
+	end
+	local function fadeThumbstickFrame(fadeDuration, fadeRatio)
+		FadeInAndOutHalfDuration = fadeDuration * 0.5
+		FadeInAndOutBalance = fadeRatio
+		TweenInAlphaStart = tick()
+	end
+		
+	local function doMove(direction)
+		MasterControl:AddToPlayerMovement(-currentMoveVector)
+		
+		currentMoveVector = direction
+		
+		-- Scaled Radial Dead Zone
+		local inputAxisMagnitude = currentMoveVector.magnitude
+		if inputAxisMagnitude < RadiusOfDeadZone then
+			currentMoveVector = Vector3.new()
+		else
+			currentMoveVector = currentMoveVector.unit*(1 - math.max(0, (RadiusOfMaxSpeed - currentMoveVector.magnitude)/RadiusOfMaxSpeed))
+			currentMoveVector = Vector3.new(currentMoveVector.x, 0, currentMoveVector.y)
+		end
+		
+		MasterControl:AddToPlayerMovement(currentMoveVector)
+	end
+	
+	local function layoutMiddleImages(startPos, endPos)
+		local startDist = (ThumbstickSize / 2) + MiddleSize
+		local vector = endPos - startPos
+		local distAvailable = vector.magnitude - (ThumbstickRingSize / 2) - MiddleSize
+		local direction = vector.unit
+
+		local distNeeded = MiddleSpacing * NUM_MIDDLE_IMAGES
+		local spacing = MiddleSpacing
+		
+		if distNeeded < distAvailable then
+			spacing = distAvailable / NUM_MIDDLE_IMAGES
+		end
+			
+		for i = 1, NUM_MIDDLE_IMAGES do
+			local image = 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, MiddleSize * exposedFraction, 0, MiddleSize * exposedFraction)
+			else
+				image.Visible = false
+			end
+		end
+	end
+	
+	local function moveStick(pos)
+		local startPos = Vector2.new(MoveTouchStartPosition.X, MoveTouchStartPosition.Y) - ThumbstickFrame.AbsolutePosition
+		local endPos = Vector2.new(pos.X, pos.Y) - ThumbstickFrame.AbsolutePosition
+		local relativePosition = endPos - startPos
+		local length = relativePosition.magnitude
+		local maxLength = ThumbstickFrame.AbsoluteSize.X
+		
+		length = math.min(length, maxLength)
+		relativePosition = relativePosition*length
+		
+		EndImage.Position = UDim2.new(0, endPos.X, 0, endPos.Y)
+		
+		layoutMiddleImages(startPos, endPos)
+	end
+	
+	-- input connections
+	ThumbstickFrame.InputBegan:connect(function(inputObject)
+		if inputObject.UserInputType ~= Enum.UserInputType.Touch or inputObject.UserInputState ~= Enum.UserInputState.Begin then
+			return
+		end
+		if MoveTouchObject then
+			return
+		end
+		
+		if IsFirstTouch then
+			IsFirstTouch = false
+			local tweenInfo = TweenInfo.new(0.5, Enum.EasingStyle.Quad, Enum.EasingDirection.Out,0,false,0)
+			TweenService:Create(StartImage, tweenInfo, {Size = UDim2.new(0, 0, 0, 0)}):Play()
+			TweenService:Create(EndImage, tweenInfo, {Size = UDim2.new(0, ThumbstickSize, 0, ThumbstickSize), ImageColor3 = Color3.new(0,0,0)}):Play()
+		end
+
+		MoveTouchObject = inputObject
+		MoveTouchStartTime = tick()
+		MoveTouchStartPosition = inputObject.Position
+		local startPosVec2 = Vector2.new(inputObject.Position.X - ThumbstickFrame.AbsolutePosition.X, inputObject.Position.Y - ThumbstickFrame.AbsolutePosition.Y)
+
+		StartImage.Visible = true
+		StartImage.Position = UDim2.new(0, startPosVec2.X, 0, startPosVec2.Y)
+		EndImage.Visible = true
+		EndImage.Position = StartImage.Position
+		
+		fadeThumbstick(true)
+		moveStick(inputObject.Position)
+		
+		if FadeInAndOutBackground then
+			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 = HasFadedBackgroundInLandscape
+						HasFadedBackgroundInLandscape = true
+				elseif playerGui.CurrentScreenOrientation == Enum.ScreenOrientation.Portrait then
+						hasFadedBackgroundInOrientation = HasFadedBackgroundInPortrait
+						HasFadedBackgroundInPortrait = true
+				end
+			end
+
+			if not hasFadedBackgroundInOrientation then
+				FadeInAndOutHalfDuration = FADE_IN_OUT_HALF_DURATION_DEFAULT
+				FadeInAndOutBalance = FADE_IN_OUT_BALANCE_DEFAULT
+				TweenInAlphaStart = tick()
+			end
+		end
+	end)
+	
+	OnTouchMovedCn = UserInputService.TouchMoved:connect(function(inputObject, isProcessed)
+		if inputObject == MoveTouchObject then
+			
+			local direction = Vector2.new(inputObject.Position.x - MoveTouchStartPosition.x, inputObject.Position.y - MoveTouchStartPosition.y)
+			if math.abs(direction.x) > 0 or math.abs(direction.y) > 0 then
+				doMove(direction)
+				moveStick(inputObject.Position)
+			end
+		end
+	end)
+	
+	OnMoveTouchEnded = function(inputObject)
+		if inputObject then
+			local direction = Vector2.new(inputObject.Position.x - MoveTouchStartPosition.x, inputObject.Position.y - MoveTouchStartPosition.y)
+		end
+
+		MoveTouchObject = nil
+		fadeThumbstick(false)
+		
+		MasterControl:AddToPlayerMovement(-currentMoveVector)
+		currentMoveVector = Vector3.new(0,0,0)
+	end
+
+	OnRenderSteppedCn = RunService.RenderStepped:Connect(function(step)
+		if TweenInAlphaStart ~= nil then
+			local delta = tick() - TweenInAlphaStart
+			local fadeInTime = (FadeInAndOutHalfDuration * 2 * FadeInAndOutBalance)
+			ThumbstickFrame.BackgroundTransparency = 1 - FadeInAndOutMaxAlpha*math.min(delta/fadeInTime, 1)
+			if delta > fadeInTime then
+				TweenOutAlphaStart = tick()
+				TweenInAlphaStart = nil
+			end
+		elseif TweenOutAlphaStart ~= nil then
+			local delta = tick() - TweenOutAlphaStart
+			local fadeOutTime = (FadeInAndOutHalfDuration * 2) - (FadeInAndOutHalfDuration * 2 * FadeInAndOutBalance)
+			ThumbstickFrame.BackgroundTransparency = 1 - FadeInAndOutMaxAlpha + FadeInAndOutMaxAlpha*math.min(delta/fadeOutTime, 1)
+			if delta > fadeOutTime  then
+				TweenOutAlphaStart = nil
+			end
+		end
+	end)
+
+	OnTouchEndedCn = UserInputService.TouchEnded:connect(function(inputObject, isProcessed)
+		if inputObject == MoveTouchObject then
+			OnMoveTouchEnded(inputObject)
+		end
+	end)
+	
+	
+	GuiService.MenuOpened:connect(function()
+		if MoveTouchObject then
+			OnMoveTouchEnded(nil)
+		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()
+		FadeInAndOutHalfDuration = 2.5
+		FadeInAndOutBalance = 0.05
+		TweenInAlphaStart = tick()
+	end
+
+	playerGuiChangedConn = playerGui.Changed:connect(function(prop)
+		if prop == "CurrentScreenOrientation" then
+			if (originalScreenOrientationWasLandscape and playerGui.CurrentScreenOrientation == Enum.ScreenOrientation.Portrait) or
+				(not originalScreenOrientationWasLandscape and playerGui.CurrentScreenOrientation ~= Enum.ScreenOrientation.Portrait) then
+					playerGuiChangedConn:disconnect()
+					longShowBackground()
+
+					if originalScreenOrientationWasLandscape then
+						HasFadedBackgroundInPortrait = true
+					else
+						HasFadedBackgroundInLandscape = true
+					end
+			end
+		end
+	end)
+	
+	GestureArea.Parent = parentFrame.Parent
+	ThumbstickFrame.Parent = parentFrame
+
+	spawn(function()
+		if game:IsLoaded() then
+			longShowBackground()
+		else
+			game.Loaded:wait()
+			longShowBackground()
+		end
+	end)
+end
+
+return Thumbstick

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/MasterControl/Gamepad.lua

@@ -0,0 +1,198 @@
+--[[
+	// FileName: Gamepad
+	// Written by: jeditkacheff
+	// Description: Implements movement controls for gamepad devices (XBox, PS4, MFi, etc.)
+--]]
+local Gamepad = {}
+
+local MasterControl = require(script.Parent)
+
+local Players = game:GetService('Players')
+local RunService = game:GetService('RunService')
+local UserInputService = game:GetService('UserInputService')
+local ContextActionService = game:GetService('ContextActionService')
+local StarterPlayer = game:GetService('StarterPlayer')
+local Settings = UserSettings()
+local GameSettings = Settings.GameSettings
+local currentMoveVector = Vector3.new(0,0,0)
+local activateGamepad = nil
+
+local gamepadConnectedCon = nil
+local gamepadDisconnectedCon = nil
+
+while not Players.LocalPlayer do
+	wait()
+end
+local LocalPlayer = Players.LocalPlayer
+
+--[[ Constants ]]--
+local thumbstickDeadzone = 0.22 --raised from 14% on 3/1/16 to accommodate looser XB360 controllers
+
+function assignActivateGamepad()
+	local connectedGamepads = UserInputService:GetConnectedGamepads()
+	if #connectedGamepads > 0 then
+		for i = 1, #connectedGamepads do
+			if activateGamepad == nil then
+				activateGamepad = connectedGamepads[i]
+			elseif connectedGamepads[i].Value < activateGamepad.Value then
+				activateGamepad = connectedGamepads[i]
+			end
+		end
+	end
+	
+	if activateGamepad == nil then -- nothing is connected, at least set up for gamepad1
+		activateGamepad = Enum.UserInputType.Gamepad1
+	end
+end
+
+--[[ Public API ]]--
+function Gamepad:Enable()
+	local forwardValue  = 0
+	local backwardValue = 0
+	local leftValue = 0
+	local rightValue = 0
+	
+	local moveFunc = LocalPlayer.Move
+	local gamepadSupports = UserInputService.GamepadSupports
+	
+	local controlCharacterGamepad = function(actionName, inputState, inputObject)
+		if inputState == Enum.UserInputState.Cancel then
+			MasterControl:AddToPlayerMovement(-currentMoveVector)
+			currentMoveVector =  Vector3.new(0,0,0)
+			return
+		end
+
+		if activateGamepad ~= inputObject.UserInputType then return end
+		if inputObject.KeyCode ~= Enum.KeyCode.Thumbstick1 then return end
+		
+		if inputObject.Position.magnitude > thumbstickDeadzone then
+			MasterControl:AddToPlayerMovement(-currentMoveVector)
+			currentMoveVector =  Vector3.new(inputObject.Position.X, 0, -inputObject.Position.Y)
+			MasterControl:AddToPlayerMovement(currentMoveVector)
+		else
+			MasterControl:AddToPlayerMovement(-currentMoveVector)
+			currentMoveVector =  Vector3.new(0,0,0)
+		end
+	end
+	
+	local jumpCharacterGamepad = function(actionName, inputState, inputObject)
+		if inputState == Enum.UserInputState.Cancel then
+			MasterControl:SetIsJumping(false)
+			return
+		end
+
+		if activateGamepad ~= inputObject.UserInputType then return end
+		if inputObject.KeyCode ~= Enum.KeyCode.ButtonA then return end
+		
+		MasterControl:SetIsJumping(inputObject.UserInputState == Enum.UserInputState.Begin)
+	end
+	
+	local doDpadMoveUpdate = function(userInputType)
+		if LocalPlayer and LocalPlayer.Character then
+			MasterControl:AddToPlayerMovement(-currentMoveVector)
+			currentMoveVector = Vector3.new(leftValue + rightValue,0,forwardValue + backwardValue)
+			MasterControl:AddToPlayerMovement(currentMoveVector)
+		end
+	end
+	
+	local moveForwardFunc = function(actionName, inputState, inputObject)
+		if inputState == Enum.UserInputState.End then
+			forwardValue = -1
+		elseif inputState == Enum.UserInputState.Begin or inputState == Enum.UserInputState.Cancel then
+			forwardValue = 0
+		end
+		
+		doDpadMoveUpdate(inputObject.UserInputType)
+	end
+	
+	local moveBackwardFunc = function(actionName, inputState, inputObject)	
+		if inputState == Enum.UserInputState.End then
+			backwardValue = 1
+		elseif inputState == Enum.UserInputState.Begin or inputState == Enum.UserInputState.Cancel then
+			backwardValue = 0
+		end
+		
+		doDpadMoveUpdate(inputObject.UserInputType)
+	end
+	
+	local moveLeftFunc = function(actionName, inputState, inputObject)	
+		if inputState == Enum.UserInputState.End then
+			leftValue = -1
+		elseif inputState == Enum.UserInputState.Begin or inputState == Enum.UserInputState.Cancel then
+			leftValue = 0
+		end
+		
+		doDpadMoveUpdate(inputObject.UserInputType)
+	end
+	
+	local moveRightFunc = function(actionName, inputState, inputObject)	
+		if inputState == Enum.UserInputState.End then
+			rightValue = 1
+		elseif inputState == Enum.UserInputState.Begin or inputState == Enum.UserInputState.Cancel then
+			rightValue = 0
+		end
+		
+		doDpadMoveUpdate(inputObject.UserInputType)
+	end
+	
+	local function setActivateGamepad()
+		if activateGamepad then
+			ContextActionService:UnbindActivate(activateGamepad, Enum.KeyCode.ButtonR2)
+		end
+		assignActivateGamepad()
+		if activateGamepad then
+			ContextActionService:BindActivate(activateGamepad, Enum.KeyCode.ButtonR2)
+		end
+	end
+	
+	ContextActionService:BindAction("JumpButton",jumpCharacterGamepad, false, Enum.KeyCode.ButtonA)
+	ContextActionService:BindAction("MoveThumbstick",controlCharacterGamepad, false, Enum.KeyCode.Thumbstick1)
+	
+	setActivateGamepad()
+	
+	if not gamepadSupports(UserInputService, activateGamepad, Enum.KeyCode.Thumbstick1) then
+		-- if the gamepad supports thumbsticks, theres no point in having the dpad buttons getting eaten up by these actions
+		ContextActionService:BindAction("forwardDpad", moveForwardFunc, false, Enum.KeyCode.DPadUp)
+		ContextActionService:BindAction("backwardDpad", moveBackwardFunc, false, Enum.KeyCode.DPadDown)
+		ContextActionService:BindAction("leftDpad", moveLeftFunc, false, Enum.KeyCode.DPadLeft)
+		ContextActionService:BindAction("rightDpad", moveRightFunc, false, Enum.KeyCode.DPadRight)
+	end
+	
+	gamepadConnectedCon = UserInputService.GamepadDisconnected:connect(function(gamepadEnum)
+		if activateGamepad ~= gamepadEnum then return end
+		
+		MasterControl:AddToPlayerMovement(-currentMoveVector)
+		currentMoveVector = Vector3.new(0,0,0)
+		
+		activateGamepad = nil
+		setActivateGamepad()
+	end)
+
+	gamepadDisconnectedCon = UserInputService.GamepadConnected:connect(function(gamepadEnum)
+		if activateGamepad == nil then 
+			setActivateGamepad()
+		end
+	end)
+end
+
+function Gamepad:Disable()
+	
+	ContextActionService:UnbindAction("forwardDpad")
+	ContextActionService:UnbindAction("backwardDpad")
+	ContextActionService:UnbindAction("leftDpad")
+	ContextActionService:UnbindAction("rightDpad")
+	
+	ContextActionService:UnbindAction("MoveThumbstick")
+	ContextActionService:UnbindAction("JumpButton")
+	ContextActionService:UnbindActivate(activateGamepad, Enum.KeyCode.ButtonR2)
+	
+	if gamepadConnectedCon then gamepadConnectedCon:disconnect() end
+	if gamepadDisconnectedCon then gamepadDisconnectedCon:disconnect() end
+	
+	activateGamepad = nil
+	MasterControl:AddToPlayerMovement(-currentMoveVector)
+	currentMoveVector = Vector3.new(0,0,0)
+	MasterControl:SetIsJumping(false)
+end
+
+return Gamepad

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/MasterControl/KeyboardMovement.lua

@@ -0,0 +1,175 @@
+--[[
+	// FileName: ComputerMovementKeyboardMovement
+	// Version 1.2
+	// Written by: jeditkacheff/jmargh
+	// Description: Implements movement controls for keyboard devices
+--]]
+local Players = game:GetService('Players')
+local UserInputService = game:GetService('UserInputService')
+local ContextActionService = game:GetService('ContextActionService')
+local StarterPlayer = game:GetService('StarterPlayer')
+local Settings = UserSettings()
+local GameSettings = Settings.GameSettings
+
+local KeyboardMovement = {}
+
+while not Players.LocalPlayer do
+	wait()
+end
+local LocalPlayer = Players.LocalPlayer
+local CachedHumanoid = nil
+local SeatJumpCn = nil
+local TextFocusReleasedCn = nil
+local TextFocusGainedCn = nil
+local WindowFocusReleasedCn = nil
+
+local MasterControl = require(script.Parent)
+local currentMoveVector = Vector3.new(0,0,0)
+
+--[[ Local Functions ]]--
+local function getHumanoid()
+	local character = LocalPlayer and LocalPlayer.Character
+	if character then
+		if CachedHumanoid and CachedHumanoid.Parent == character then
+			return CachedHumanoid
+		else
+			CachedHumanoid = nil
+			for _,child in pairs(character:GetChildren()) do
+				if child:IsA('Humanoid') then
+					CachedHumanoid = child
+					return CachedHumanoid
+				end
+			end
+		end
+	end
+end
+
+--[[ Public API ]]--
+function KeyboardMovement:Enable()
+	if not UserInputService.KeyboardEnabled then
+		return
+	end
+	
+	local forwardValue  = 0
+	local backwardValue = 0
+	local leftValue = 0
+	local rightValue = 0
+	
+	local updateMovement = function(inputState)
+		if inputState == Enum.UserInputState.Cancel then
+			MasterControl:AddToPlayerMovement(-currentMoveVector)
+			currentMoveVector = Vector3.new(0, 0, 0)
+		else
+			MasterControl:AddToPlayerMovement(-currentMoveVector)
+			currentMoveVector = Vector3.new(leftValue + rightValue,0,forwardValue + backwardValue)
+			MasterControl:AddToPlayerMovement(currentMoveVector)	
+		end
+	end
+	
+	local moveForwardFunc = function(actionName, inputState, inputObject)			
+		if inputState == Enum.UserInputState.Begin then
+			forwardValue = -1
+		elseif inputState == Enum.UserInputState.End or inputState == Enum.UserInputState.Cancel then
+			forwardValue = 0
+		end
+		updateMovement(inputState)
+	end
+	
+	local moveBackwardFunc = function(actionName, inputState, inputObject)	
+		if inputState == Enum.UserInputState.Begin then
+			backwardValue = 1
+		elseif inputState == Enum.UserInputState.End or inputState == Enum.UserInputState.Cancel then
+			backwardValue = 0
+		end
+		updateMovement(inputState)
+	end
+	
+	local moveLeftFunc = function(actionName, inputState, inputObject)	
+		if inputState == Enum.UserInputState.Begin then
+			leftValue = -1
+		elseif inputState == Enum.UserInputState.End or inputState == Enum.UserInputState.Cancel then
+			leftValue = 0
+		end
+		updateMovement(inputState)
+	end
+	
+	local moveRightFunc = function(actionName, inputState, inputObject)	
+		if inputState == Enum.UserInputState.Begin then
+			rightValue = 1
+		elseif inputState == Enum.UserInputState.End or inputState == Enum.UserInputState.Cancel then
+			rightValue = 0
+		end
+		updateMovement(inputState)
+	end
+	
+	local jumpFunc = function(actionName, inputState, inputObject)
+		MasterControl:SetIsJumping(inputState == Enum.UserInputState.Begin)
+	end
+	
+	-- TODO: remove up and down arrows, these seem unnecessary
+	ContextActionService:BindActionToInputTypes("forwardMovement", moveForwardFunc, false, Enum.PlayerActions.CharacterForward)
+	ContextActionService:BindActionToInputTypes("backwardMovement", moveBackwardFunc, false, Enum.PlayerActions.CharacterBackward)
+	ContextActionService:BindActionToInputTypes("leftMovement", moveLeftFunc, false, Enum.PlayerActions.CharacterLeft)
+	ContextActionService:BindActionToInputTypes("rightMovement", moveRightFunc, false, Enum.PlayerActions.CharacterRight)
+	ContextActionService:BindActionToInputTypes("jumpAction", jumpFunc, false, Enum.PlayerActions.CharacterJump)
+	-- TODO: make sure we check key state before binding to check if key is already down
+	
+	local function onFocusReleased()
+		local humanoid = getHumanoid()
+		if humanoid then
+			MasterControl:AddToPlayerMovement(-currentMoveVector)
+			currentMoveVector = Vector3.new(0, 0, 0)
+			forwardValue, backwardValue, leftValue, rightValue = 0, 0, 0, 0
+			MasterControl:SetIsJumping(false)
+		end
+	end
+	
+	local function onTextFocusGained(textboxFocused)
+		MasterControl:SetIsJumping(false)
+	end
+	
+	SeatJumpCn = UserInputService.InputBegan:connect(function(inputObject, isProcessed)
+		if inputObject.KeyCode == Enum.KeyCode.Backspace and not isProcessed then
+			local humanoid = getHumanoid()
+			if humanoid and (humanoid.Sit or humanoid.PlatformStand) then
+				MasterControl:DoJump()
+			end
+		end
+	end)
+	
+	TextFocusReleasedCn = UserInputService.TextBoxFocusReleased:connect(onFocusReleased)
+	TextFocusGainedCn = UserInputService.TextBoxFocused:connect(onTextFocusGained)
+	-- TODO: remove pcall when API is live
+	WindowFocusReleasedCn = UserInputService.WindowFocusReleased:connect(onFocusReleased)
+end
+
+function KeyboardMovement:Disable()
+	ContextActionService:UnbindAction("forwardMovement")
+	ContextActionService:UnbindAction("backwardMovement")
+	ContextActionService:UnbindAction("leftMovement")
+	ContextActionService:UnbindAction("rightMovement")
+	ContextActionService:UnbindAction("jumpAction")
+	
+	if SeatJumpCn then
+		SeatJumpCn:disconnect()
+		SeatJumpCn = nil
+	end
+	if TextFocusReleasedCn then
+		TextFocusReleasedCn:disconnect()
+		TextFocusReleasedCn = nil
+	end
+	if TextFocusGainedCn then
+		TextFocusGainedCn:disconnect()
+		TextFocusGainedCn = nil
+	end
+	if WindowFocusReleasedCn then
+		WindowFocusReleasedCn:disconnect()
+		WindowFocusReleasedCn = nil
+	end
+	
+	MasterControl:AddToPlayerMovement(-currentMoveVector)
+	currentMoveVector = Vector3.new(0,0,0)
+	MasterControl:SetIsJumping(false)
+end
+
+return KeyboardMovement

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/MasterControl/Thumbpad.lua

@@ -0,0 +1,228 @@
+--[[
+	// FileName: Thumbpad
+	// Version 1.0
+	// Written by: jmargh
+	// Description: Implements thumbpad controls for touch devices
+--]]
+
+local Players = game:GetService('Players')
+local UserInputService = game:GetService('UserInputService')
+local GuiService = game:GetService('GuiService')
+
+local Thumbpad = {}
+
+local MasterControl = require(script.Parent)
+
+--[[ Script Variables ]]--
+while not Players.LocalPlayer do
+	wait()
+end
+local LocalPlayer = Players.LocalPlayer
+local ThumbpadFrame = nil
+local TouchObject = nil
+local OnInputEnded = nil	-- is defined in Create()
+local OnTouchChangedCn = nil
+local OnTouchEndedCn = nil
+local currentMoveVector = Vector3.new(0,0,0)
+
+--[[ Constants ]]--
+local DPAD_SHEET = "rbxasset://textures/ui/DPadSheet.png"
+local TOUCH_CONTROL_SHEET = "rbxasset://textures/ui/TouchControlsSheet.png"
+
+--[[ Local Functions ]]--
+local function createArrowLabel(name, parent, position, size, rectOffset, rectSize)
+	local image = Instance.new('ImageLabel')
+	image.Name = name
+	image.Image = DPAD_SHEET
+	image.ImageRectOffset = rectOffset
+	image.ImageRectSize = rectSize
+	image.BackgroundTransparency = 1
+	image.ImageColor3 = Color3.new(190/255, 190/255, 190/255)
+	image.Size = size
+	image.Position = position
+	image.Parent = parent
+	
+	return image
+end
+
+--[[ Public API ]]--
+function Thumbpad:Enable()
+	ThumbpadFrame.Visible = true
+end
+
+function Thumbpad:Disable()
+	ThumbpadFrame.Visible = false
+	OnInputEnded()
+end
+
+function Thumbpad:Create(parentFrame)
+	if ThumbpadFrame then
+		ThumbpadFrame:Destroy()
+		ThumbpadFrame = nil
+		if OnTouchChangedCn then
+			OnTouchChangedCn:disconnect()
+			OnTouchChangedCn = nil
+		end
+		if OnTouchEndedCn then
+			OnTouchEndedCn:disconnect()
+			OnTouchEndedCn = nil
+		end
+	end
+	
+	local minAxis = math.min(parentFrame.AbsoluteSize.x, parentFrame.AbsoluteSize.y)
+	local isSmallScreen = minAxis <= 500
+	local thumbpadSize = isSmallScreen and 70 or 120
+	local position = isSmallScreen and UDim2.new(0, thumbpadSize * 1.25, 1, -thumbpadSize - 20) or
+		UDim2.new(0, thumbpadSize/2 - 10, 1, -thumbpadSize * 1.75 - 10)
+	
+	ThumbpadFrame = Instance.new('Frame')
+	ThumbpadFrame.Name = "ThumbpadFrame"
+	ThumbpadFrame.Visible = false
+	ThumbpadFrame.Active = true
+	ThumbpadFrame.Size = UDim2.new(0, thumbpadSize + 20, 0, thumbpadSize + 20)
+	ThumbpadFrame.Position = position
+	ThumbpadFrame.BackgroundTransparency = 1
+	
+	local outerImage = Instance.new('ImageLabel')
+	outerImage.Name = "OuterImage"
+	outerImage.Image = TOUCH_CONTROL_SHEET
+	outerImage.ImageRectOffset = Vector2.new(0, 0)
+	outerImage.ImageRectSize = Vector2.new(220, 220)
+	outerImage.BackgroundTransparency = 1
+	outerImage.Size = UDim2.new(0, thumbpadSize, 0, thumbpadSize)
+	outerImage.Position = UDim2.new(0, 10, 0, 10)
+	outerImage.Parent = ThumbpadFrame
+	
+	local smArrowSize = isSmallScreen and UDim2.new(0, 32, 0, 32) or UDim2.new(0, 64, 0, 64)
+	local lgArrowSize = UDim2.new(0, smArrowSize.X.Offset * 2, 0, smArrowSize.Y.Offset * 2)
+	local imgRectSize = Vector2.new(110, 110)
+	local smImgOffset = isSmallScreen and -4 or -9
+	local lgImgOffset = isSmallScreen and -28 or -55
+	
+	local dArrow = createArrowLabel("DownArrow", outerImage, UDim2.new(0.5, -smArrowSize.X.Offset/2, 1, lgImgOffset), smArrowSize, Vector2.new(8, 8), imgRectSize)
+	local uArrow = createArrowLabel("UpArrow", outerImage, UDim2.new(0.5, -smArrowSize.X.Offset/2, 0, smImgOffset), smArrowSize, Vector2.new(8, 266), imgRectSize)
+	local lArrow = createArrowLabel("LeftArrow", outerImage, UDim2.new(0, smImgOffset, 0.5, -smArrowSize.Y.Offset/2), smArrowSize, Vector2.new(137, 137), imgRectSize)
+	local rArrow = createArrowLabel("RightArrow", outerImage, UDim2.new(1, lgImgOffset, 0.5, -smArrowSize.Y.Offset/2), smArrowSize, Vector2.new(8, 137), imgRectSize)
+	
+	local function doTween(guiObject, endSize, endPosition)
+		guiObject:TweenSizeAndPosition(endSize, endPosition, Enum.EasingDirection.InOut, Enum.EasingStyle.Linear, 0.15, true)
+	end
+	
+	local padOrigin = nil
+	local deadZone = 0.1
+	local isRight, isLeft, isUp, isDown = false, false, false, false
+	local vForward = Vector3.new(0, 0, -1)
+	local vRight = Vector3.new(1, 0, 0)
+	local function doMove(pos)
+		MasterControl:AddToPlayerMovement(-currentMoveVector)
+		
+		local delta = Vector2.new(pos.x, pos.y) - padOrigin
+		currentMoveVector = delta / (thumbpadSize/2)
+		
+		-- Scaled Radial Dead Zone
+		local inputAxisMagnitude = currentMoveVector.magnitude
+		if inputAxisMagnitude < deadZone then
+			currentMoveVector = Vector3.new(0, 0, 0)
+		else
+			currentMoveVector = currentMoveVector.unit * ((inputAxisMagnitude - deadZone) / (1 - deadZone))
+			-- catch possible NAN Vector
+			if currentMoveVector.magnitude == 0 then
+				currentMoveVector = Vector3.new(0, 0, 0)
+			else
+				currentMoveVector = Vector3.new(currentMoveVector.x, 0, currentMoveVector.y).unit
+			end
+		end
+		
+		MasterControl:AddToPlayerMovement(currentMoveVector)
+		
+		local forwardDot = currentMoveVector:Dot(vForward)
+		local rightDot = currentMoveVector:Dot(vRight)
+		if forwardDot > 0.5 then		-- UP
+			if not isUp then
+				isUp, isDown = true, false
+				doTween(uArrow, lgArrowSize, UDim2.new(0.5, -smArrowSize.X.Offset, 0, smImgOffset - smArrowSize.Y.Offset * 1.5))
+				doTween(dArrow, smArrowSize, UDim2.new(0.5, -smArrowSize.X.Offset/2, 1, lgImgOffset))
+			end
+		elseif forwardDot < -0.5 then	-- DOWN
+			if not isDown then
+				isDown, isUp = true, false
+				doTween(dArrow, lgArrowSize, UDim2.new(0.5, -smArrowSize.X.Offset, 1, lgImgOffset + smArrowSize.Y.Offset/2))
+				doTween(uArrow, smArrowSize, UDim2.new(0.5, -smArrowSize.X.Offset/2, 0, smImgOffset))
+			end
+		else
+			isUp, isDown = false, false
+			doTween(dArrow, smArrowSize, UDim2.new(0.5, -smArrowSize.X.Offset/2, 1, lgImgOffset))
+			doTween(uArrow, smArrowSize, UDim2.new(0.5, -smArrowSize.X.Offset/2, 0, smImgOffset))
+		end
+		
+		if rightDot > 0.5 then
+			if not isRight then
+				isRight, isLeft = true, false
+				doTween(rArrow, lgArrowSize, UDim2.new(1, lgImgOffset + smArrowSize.X.Offset/2, 0.5, -smArrowSize.Y.Offset))
+				doTween(lArrow, smArrowSize, UDim2.new(0, smImgOffset, 0.5, -smArrowSize.Y.Offset/2))
+			end
+		elseif rightDot < -0.5 then
+			if not isLeft then
+				isLeft, isRight = true, false
+				doTween(lArrow, lgArrowSize, UDim2.new(0, smImgOffset - smArrowSize.X.Offset * 1.5, 0.5, -smArrowSize.Y.Offset))
+				doTween(rArrow, smArrowSize, UDim2.new(1, lgImgOffset, 0.5, -smArrowSize.Y.Offset/2))
+			end
+		else
+			isRight, isLeft = false, false
+			doTween(lArrow, smArrowSize, UDim2.new(0, smImgOffset, 0.5, -smArrowSize.Y.Offset/2))
+			doTween(rArrow, smArrowSize, UDim2.new(1, lgImgOffset, 0.5, -smArrowSize.Y.Offset/2))
+		end
+	end
+	
+	--input connections
+	ThumbpadFrame.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
+		
+		ThumbpadFrame.Position = UDim2.new(0, inputObject.Position.x - ThumbpadFrame.AbsoluteSize.x/2, 0, inputObject.Position.y - ThumbpadFrame.Size.Y.Offset/2)
+		padOrigin = Vector2.new(ThumbpadFrame.AbsolutePosition.x + ThumbpadFrame.AbsoluteSize.x/2,
+			ThumbpadFrame.AbsolutePosition.y + ThumbpadFrame.AbsoluteSize.y/2)
+		doMove(inputObject.Position)
+		TouchObject = inputObject
+	end)
+	
+	OnTouchChangedCn = UserInputService.TouchMoved:connect(function(inputObject, isProcessed)
+		if inputObject == TouchObject then
+			doMove(TouchObject.Position)
+		end
+	end)
+	
+	OnInputEnded = function()
+		MasterControl:AddToPlayerMovement(-currentMoveVector)
+		currentMoveVector = Vector3.new(0,0,0)
+		MasterControl:SetIsJumping(false)
+
+		ThumbpadFrame.Position = position
+		TouchObject = nil
+		isUp, isDown, isLeft, isRight = false, false, false, false
+		doTween(dArrow, smArrowSize, UDim2.new(0.5, -smArrowSize.X.Offset/2, 1, lgImgOffset))
+		doTween(uArrow, smArrowSize, UDim2.new(0.5, -smArrowSize.X.Offset/2, 0, smImgOffset))
+		doTween(lArrow, smArrowSize, UDim2.new(0, smImgOffset, 0.5, -smArrowSize.Y.Offset/2))
+		doTween(rArrow, smArrowSize, UDim2.new(1, lgImgOffset, 0.5, -smArrowSize.Y.Offset/2))
+	end
+	
+	OnTouchEndedCn = UserInputService.TouchEnded:connect(function(inputObject)
+		if inputObject == TouchObject then
+			OnInputEnded()
+		end
+	end)
+	
+	GuiService.MenuOpened:connect(function()
+		if TouchObject then
+			OnInputEnded()
+		end
+	end)	
+	
+	ThumbpadFrame.Parent = parentFrame
+end
+
+return Thumbpad

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/MasterControl/Thumbstick.lua

@@ -0,0 +1,178 @@
+--[[
+	// FileName: Thumbstick
+	// Version 1.0
+	// Written by: jmargh
+	// Description: Implements thumbstick controls for touch devices
+--]]
+local Players = game:GetService('Players')
+local UserInputService = game:GetService('UserInputService')
+local GuiService = game:GetService('GuiService')
+
+local MasterControl = require(script.Parent)
+
+local Thumbstick = {}
+
+--[[ Script Variables ]]--
+while not Players.LocalPlayer do
+	wait()
+end
+local LocalPlayer = Players.LocalPlayer
+local IsFollowStick = false
+local ThumbstickFrame = nil
+local MoveTouchObject = nil
+local OnTouchEnded = nil		-- defined in Create()
+local OnTouchMovedCn = nil
+local OnTouchEndedCn = nil
+local currentMoveVector = Vector3.new(0,0,0)
+
+--[[ Constants ]]--
+local TOUCH_CONTROL_SHEET = "rbxasset://textures/ui/TouchControlsSheet.png"
+
+--[[ Public API ]]--
+function Thumbstick:Enable()
+	ThumbstickFrame.Visible = true
+end
+
+function Thumbstick:Disable()
+	ThumbstickFrame.Visible = false
+	OnTouchEnded()
+end
+
+function Thumbstick:Create(parentFrame)
+	if ThumbstickFrame then
+		ThumbstickFrame:Destroy()
+		ThumbstickFrame = nil
+		if OnTouchMovedCn then
+			OnTouchMovedCn:disconnect()
+			OnTouchMovedCn = nil
+		end
+		if OnTouchEndedCn then
+			OnTouchEndedCn:disconnect()
+			OnTouchEndedCn = nil
+		end
+	end
+	
+	local minAxis = math.min(parentFrame.AbsoluteSize.x, parentFrame.AbsoluteSize.y)
+	local isSmallScreen = minAxis <= 500
+	local thumbstickSize = isSmallScreen and 70 or 120
+	local position = isSmallScreen and UDim2.new(0, (thumbstickSize/2) - 10, 1, -thumbstickSize - 20) or
+		UDim2.new(0, thumbstickSize/2, 1, -thumbstickSize * 1.75)
+		
+	ThumbstickFrame = Instance.new('Frame')
+	ThumbstickFrame.Name = "ThumbstickFrame"
+	ThumbstickFrame.Active = true
+	ThumbstickFrame.Visible = false
+	ThumbstickFrame.Size = UDim2.new(0, thumbstickSize, 0, thumbstickSize)
+	ThumbstickFrame.Position = position
+	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, thumbstickSize, 0, thumbstickSize)
+	outerImage.Position = UDim2.new(0, 0, 0, 0)
+	outerImage.Parent = ThumbstickFrame
+	
+	local StickImage = Instance.new('ImageLabel')
+	StickImage.Name = "StickImage"
+	StickImage.Image = TOUCH_CONTROL_SHEET
+	StickImage.ImageRectOffset = Vector2.new(220, 0)
+	StickImage.ImageRectSize = Vector2.new(111, 111)
+	StickImage.BackgroundTransparency = 1
+	StickImage.Size = UDim2.new(0, thumbstickSize/2, 0, thumbstickSize/2)
+	StickImage.Position = UDim2.new(0, thumbstickSize/2 - thumbstickSize/4, 0, thumbstickSize/2 - thumbstickSize/4)
+	StickImage.ZIndex = 2
+	StickImage.Parent = ThumbstickFrame
+	
+	local centerPosition = nil
+	local deadZone = 0.05
+	local function doMove(direction)
+		MasterControl:AddToPlayerMovement(-currentMoveVector)
+		
+		currentMoveVector = direction / (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
+		
+		MasterControl:AddToPlayerMovement(currentMoveVector)
+	end
+	
+	local function moveStick(pos)
+		local relativePosition = Vector2.new(pos.x - centerPosition.x, pos.y - centerPosition.y)
+		local length = relativePosition.magnitude
+		local maxLength = ThumbstickFrame.AbsoluteSize.x/2
+		if IsFollowStick and length > maxLength then
+			local offset = relativePosition.unit * maxLength
+			ThumbstickFrame.Position = UDim2.new(
+				0, pos.x - ThumbstickFrame.AbsoluteSize.x/2 - offset.x,
+				0, pos.y - ThumbstickFrame.AbsoluteSize.y/2 - offset.y)
+		else
+			length = math.min(length, maxLength)
+			relativePosition = relativePosition.unit * length
+		end
+		StickImage.Position = UDim2.new(0, relativePosition.x + StickImage.AbsoluteSize.x/2, 0, relativePosition.y + StickImage.AbsoluteSize.y/2)
+	end
+	
+	-- input connections
+	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 MoveTouchObject or inputObject.UserInputType ~= Enum.UserInputType.Touch
+			or inputObject.UserInputState ~= Enum.UserInputState.Begin then
+			return
+		end
+		
+		MoveTouchObject = inputObject
+		ThumbstickFrame.Position = UDim2.new(0, inputObject.Position.x - ThumbstickFrame.Size.X.Offset/2, 0, inputObject.Position.y - ThumbstickFrame.Size.Y.Offset/2)
+		centerPosition = Vector2.new(ThumbstickFrame.AbsolutePosition.x + ThumbstickFrame.AbsoluteSize.x/2,
+			ThumbstickFrame.AbsolutePosition.y + ThumbstickFrame.AbsoluteSize.y/2)
+		local direction = Vector2.new(inputObject.Position.x - centerPosition.x, inputObject.Position.y - centerPosition.y)
+	end)
+	
+	OnTouchMovedCn = UserInputService.TouchMoved:connect(function(inputObject, isProcessed)
+		if inputObject == MoveTouchObject then
+			centerPosition = Vector2.new(ThumbstickFrame.AbsolutePosition.x + ThumbstickFrame.AbsoluteSize.x/2,
+				ThumbstickFrame.AbsolutePosition.y + 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)
+	
+	OnTouchEnded = function()
+		ThumbstickFrame.Position = position
+		StickImage.Position = UDim2.new(0, ThumbstickFrame.Size.X.Offset/2 - thumbstickSize/4, 0, ThumbstickFrame.Size.Y.Offset/2 - thumbstickSize/4)
+		MoveTouchObject = nil
+		
+		MasterControl:AddToPlayerMovement(-currentMoveVector)
+		currentMoveVector = Vector3.new(0,0,0)
+		MasterControl:SetIsJumping(false)
+	end
+	
+	OnTouchEndedCn = UserInputService.TouchEnded:connect(function(inputObject, isProcessed)
+		if inputObject == MoveTouchObject then
+			OnTouchEnded()
+		end
+	end)
+	
+	GuiService.MenuOpened:connect(function()
+		if MoveTouchObject then
+			OnTouchEnded()
+		end
+	end)	
+	
+	ThumbstickFrame.Parent = parentFrame
+end
+
+return Thumbstick

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/MasterControl/TouchJump.lua

@@ -0,0 +1,172 @@
+--[[
+	// FileName: TouchJump
+	// Version 1.0
+	// Written by: jmargh
+	// Description: Implements jump controls for touch devices. Use with Thumbstick and Thumbpad
+--]]
+
+local Players = game:GetService('Players')
+local GuiService = game:GetService('GuiService')
+
+local TouchJump = {}
+
+local MasterControl = require(script.Parent)
+
+--[[ Script Variables ]]--
+while not Players.LocalPlayer do
+	wait()
+end
+local LocalPlayer = Players.LocalPlayer
+local Humanoid = MasterControl:GetHumanoid()
+local JumpButton = nil
+local OnInputEnded = nil		-- defined in Create()
+local CharacterAddedConnection = nil
+local HumStateConnection = nil
+local HumChangeConnection = nil
+local ExternallyEnabled = false
+local JumpPower = 0
+local JumpStateEnabled = true
+
+--[[ Constants ]]--
+local TOUCH_CONTROL_SHEET = "rbxasset://textures/ui/Input/TouchControlsSheetV2.png"
+
+--[[ Private Functions ]]--
+
+local function disableButton()
+	JumpButton.Visible = false
+	OnInputEnded()
+end
+
+local function enableButton()
+	if Humanoid and ExternallyEnabled then
+		if ExternallyEnabled then
+			if Humanoid.JumpPower > 0 then
+				JumpButton.Visible = true
+			end
+		end
+	end
+end
+
+local function updateEnabled()
+	if JumpPower > 0 and JumpStateEnabled then
+		enableButton()
+	else
+		disableButton()
+	end
+end
+
+local function humanoidChanged(prop)
+	if prop == "JumpPower" then
+		JumpPower =  Humanoid.JumpPower
+		updateEnabled()
+	elseif prop == "Parent" then
+		if not Humanoid.Parent then
+			HumChangeConnection:disconnect()
+		end
+	end
+end
+
+local function humandoidStateEnabledChanged(state, isEnabled)
+	if state == Enum.HumanoidStateType.Jumping then
+		JumpStateEnabled = isEnabled
+		updateEnabled()
+	end
+end
+
+local function characterAdded(newCharacter)
+	if HumChangeConnection then
+		HumChangeConnection:disconnect()
+	end
+	-- rebind event to new Humanoid
+	Humanoid = nil
+	repeat
+		Humanoid = MasterControl:GetHumanoid()
+		wait()
+	until Humanoid and Humanoid.Parent == newCharacter
+	HumChangeConnection = Humanoid.Changed:connect(humanoidChanged)
+	HumStateConnection = Humanoid.StateEnabledChanged:connect(humandoidStateEnabledChanged)
+	JumpPower = Humanoid.JumpPower
+	JumpStateEnabled = Humanoid:GetStateEnabled(Enum.HumanoidStateType.Jumping)
+	updateEnabled()
+end
+
+local function setupCharacterAddedFunction()
+	CharacterAddedConnection = LocalPlayer.CharacterAdded:connect(characterAdded)
+	if LocalPlayer.Character then
+		characterAdded(LocalPlayer.Character)
+	end
+end
+
+--[[ Public API ]]--
+function TouchJump:Enable()
+	ExternallyEnabled = true
+	enableButton()
+end
+
+function TouchJump:Disable()
+	ExternallyEnabled = false
+	disableButton()
+end
+
+function TouchJump:Create(parentFrame)
+	if JumpButton then
+		JumpButton:Destroy()
+		JumpButton = nil
+	end
+	
+	local minAxis = math.min(parentFrame.AbsoluteSize.x, parentFrame.AbsoluteSize.y)
+	local isSmallScreen = minAxis <= 500
+	local jumpButtonSize = isSmallScreen and 70 or 120
+	
+	JumpButton = Instance.new('ImageButton')
+	JumpButton.Name = "JumpButton"
+	JumpButton.Visible = false
+	JumpButton.BackgroundTransparency = 1
+	JumpButton.Image = TOUCH_CONTROL_SHEET
+	JumpButton.ImageRectOffset = Vector2.new(1, 146)
+	JumpButton.ImageRectSize = Vector2.new(144, 144)
+	JumpButton.Size = UDim2.new(0, jumpButtonSize, 0, jumpButtonSize)
+
+    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	
+	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
+		JumpButton.ImageRectOffset = Vector2.new(146, 146)
+		MasterControl:SetIsJumping(true)
+	end)
+	
+	OnInputEnded = function()
+		touchObject = nil
+		MasterControl:SetIsJumping(false)
+		JumpButton.ImageRectOffset = Vector2.new(1, 146)
+	end
+	
+	JumpButton.InputEnded:connect(function(inputObject)
+		if inputObject == touchObject then
+			OnInputEnded()
+		end
+	end)
+	
+	GuiService.MenuOpened:connect(function()
+		if touchObject then
+			OnInputEnded()
+		end
+	end)
+	
+	if not CharacterAddedConnection then
+		setupCharacterAddedFunction()
+	end
+	
+	JumpButton.Parent = parentFrame
+end
+
+return TouchJump

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/MasterControl/VRNavigation.lua

@@ -0,0 +1,433 @@
+local VRService = game:GetService("VRService")
+local UserInputService = game:GetService("UserInputService")
+local RunService = game:GetService("RunService")
+local Players = game:GetService("Players")
+local PathfindingService = game:GetService("PathfindingService")
+local ContextActionService = game:GetService("ContextActionService")
+local StarterGui = game:GetService("StarterGui")
+
+local MasterControl = require(script.Parent)
+local PathDisplay = nil
+local LocalPlayer = Players.LocalPlayer
+
+local VRNavigation = {}
+
+local RECALCULATE_PATH_THRESHOLD = 4
+local NO_PATH_THRESHOLD = 12
+local MAX_PATHING_DISTANCE = 200
+local POINT_REACHED_THRESHOLD = 1
+local STOPPING_DISTANCE = 4
+local OFFTRACK_TIME_THRESHOLD = 2
+
+local ZERO_VECTOR3 = Vector3.new(0, 0, 0)
+local XZ_VECTOR3 = Vector3.new(1, 0, 1)
+
+local THUMBSTICK_DEADZONE = 0.22
+
+local navigationRequestedConn = nil
+local heartbeatConn = nil
+
+local currentDestination = nil
+local currentPath = nil
+local currentPoints = nil
+local currentPointIdx = 0
+local currentMoveVector = Vector3.new(0, 0, 0)
+
+local expectedTimeToNextPoint = 0
+local timeReachedLastPoint = tick()
+
+local movementUpdateEvent = Instance.new("BindableEvent")
+movementUpdateEvent.Name = "MovementUpdate"
+movementUpdateEvent.Parent = script
+
+coroutine.wrap(function()
+	local PathDisplayModule = script.Parent.Parent:WaitForChild("PathDisplay")
+	if PathDisplayModule then
+		PathDisplay = require(PathDisplayModule)
+	end
+end)()
+
+local function setLaserPointerMode(mode)
+	pcall(function()
+		StarterGui:SetCore("VRLaserPointerMode", mode)
+	end)
+end
+
+local function getLocalHumanoid()
+	local character = LocalPlayer.Character
+	if not character then
+		return
+	end
+	
+	for _, child in pairs(character:GetChildren()) do
+		if child:IsA("Humanoid") then
+			return child
+		end
+	end
+	return nil
+end
+
+local function hasBothHandControllers()
+	return VRService:GetUserCFrameEnabled(Enum.UserCFrame.RightHand) and VRService:GetUserCFrameEnabled(Enum.UserCFrame.LeftHand)
+end
+
+local function hasAnyHandControllers()
+	return VRService:GetUserCFrameEnabled(Enum.UserCFrame.RightHand) or VRService:GetUserCFrameEnabled(Enum.UserCFrame.LeftHand)
+end
+
+local function isMobileVR()
+	return UserInputService.TouchEnabled
+end
+
+local function hasGamepad()
+	return UserInputService.GamepadEnabled
+end
+
+local function shouldUseNavigationLaser()
+	--Places where we use the navigation laser:
+	-- mobile VR with any number of hands tracked
+	-- desktop VR with only one hand tracked
+	-- desktop VR with no hands and no gamepad (i.e. with Oculus remote?)
+	--using an Xbox controller with a desktop VR headset means no laser since the user has a thumbstick.
+	--in the future, we should query thumbstick presence with a features API
+	if isMobileVR() then
+		return true		
+	else
+		if hasBothHandControllers() then
+			return false
+		end
+		if not hasAnyHandControllers() then
+			return not hasGamepad()
+		end
+		return true
+	end
+end
+
+local function IsFinite(num)
+	return num == num and num ~= 1/0 and num ~= -1/0
+end
+
+local function IsFiniteVector3(vec3)
+	return IsFinite(vec3.x) and IsFinite(vec3.y) and IsFinite(vec3.z)
+end
+
+local moving = false
+
+local function startFollowingPath(newPath)
+	currentPath = newPath
+	currentPoints = currentPath:GetPointCoordinates()
+	currentPointIdx = 1
+	moving = true
+	
+	timeReachedLastPoint = tick()
+	
+	local humanoid = getLocalHumanoid()
+	if humanoid and humanoid.Torso and #currentPoints >= 1 then
+		local dist = (currentPoints[1] - humanoid.Torso.Position).magnitude
+		expectedTimeToNextPoint = dist / humanoid.WalkSpeed
+	end
+	
+	movementUpdateEvent:Fire("targetPoint", currentDestination)	
+end
+
+local function goToPoint(point)
+	currentPath = true
+	currentPoints = { point }
+	currentPointIdx = 1
+	moving = true
+
+	local humanoid = getLocalHumanoid()
+	local distance = (humanoid.Torso.Position - point).magnitude	
+	local estimatedTimeRemaining = distance / humanoid.WalkSpeed 
+	
+	timeReachedLastPoint = tick()
+	expectedTimeToNextPoint = estimatedTimeRemaining
+	
+	movementUpdateEvent:Fire("targetPoint", point)
+end
+
+local function stopFollowingPath()
+	currentPath = nil
+	currentPoints = nil
+	currentPointIdx = 0
+	moving = false
+	MasterControl:AddToPlayerMovement(-currentMoveVector)
+	currentMoveVector = ZERO_VECTOR3
+end
+
+local function tryComputePath(startPos, destination)
+	local numAttempts = 0
+	local newPath = nil
+	
+	while not newPath and numAttempts < 5 do
+		newPath = PathfindingService:ComputeSmoothPathAsync(startPos, destination, MAX_PATHING_DISTANCE)
+		numAttempts = numAttempts + 1
+		
+		if newPath.Status == Enum.PathStatus.ClosestNoPath or newPath.Status == Enum.PathStatus.ClosestOutOfRange then
+			newPath = nil
+			break
+		end
+		
+		if newPath and newPath.Status == Enum.PathStatus.FailStartNotEmpty then
+			startPos = startPos + (destination - startPos).unit
+			newPath = nil
+		end
+		
+		if newPath and newPath.Status == Enum.PathStatus.FailFinishNotEmpty then
+			destination = destination + Vector3.new(0, 1, 0)
+			newPath = nil
+		end
+	end
+	
+	return newPath
+end
+
+local function onNavigationRequest(destinationCFrame, requestedWith)
+	local destinationPosition = destinationCFrame.p
+	local lastDestination = currentDestination
+
+	if not IsFiniteVector3(destinationPosition) then
+		return
+	end
+	
+	currentDestination = destinationPosition
+		
+	local humanoid = getLocalHumanoid()
+	if not humanoid or not humanoid.Torso then
+		return
+	end
+		
+	local currentPosition = humanoid.Torso.Position
+	local distanceToDestination = (currentDestination - currentPosition).magnitude
+		
+	if distanceToDestination < NO_PATH_THRESHOLD then
+		goToPoint(currentDestination)
+		return
+	end		
+		
+	if not lastDestination or (currentDestination - lastDestination).magnitude > RECALCULATE_PATH_THRESHOLD then
+		local newPath = tryComputePath(currentPosition, currentDestination)	
+		if newPath then
+			startFollowingPath(newPath)
+			if PathDisplay then
+				PathDisplay.setCurrentPoints(currentPoints)
+				PathDisplay.renderPath()
+			end
+		else
+			stopFollowingPath()
+			if PathDisplay then
+				PathDisplay.clearRenderedPath()
+			end
+		end
+	else
+		if moving then
+			currentPoints[#currentPoints] = currentDestination
+		else
+			goToPoint(currentDestination)
+		end
+	end
+end
+
+local isJumpBound = false
+local function onJumpAction(actionName, inputState, inputObj)
+	if inputState == Enum.UserInputState.Begin then
+		MasterControl:DoJump()
+	end
+end
+
+local function bindJumpAction(active)
+	if active then
+		if not isJumpBound then
+			isJumpBound = true
+			ContextActionService:BindAction("VRJumpAction", onJumpAction, false, Enum.KeyCode.ButtonA)
+		end
+	else
+		if isJumpBound then
+			isJumpBound = false
+			ContextActionService:UnbindAction("VRJumpAction")
+		end
+	end
+end
+
+local moveLatch = false
+local controlCharacterGamepad = function(actionName, inputState, inputObject)
+	if inputObject.KeyCode ~= Enum.KeyCode.Thumbstick1 then return end
+	
+	if inputState == Enum.UserInputState.Cancel then
+		MasterControl:AddToPlayerMovement(-currentMoveVector)
+		currentMoveVector =  Vector3.new(0,0,0)
+		return
+	end
+	
+	if inputState ~= Enum.UserInputState.End then
+		stopFollowingPath()		
+		if PathDisplay then
+			PathDisplay.clearRenderedPath()
+		end
+		
+		if shouldUseNavigationLaser() then
+			bindJumpAction(true)
+			setLaserPointerMode("Hidden")
+		end
+		
+		if inputObject.Position.magnitude > THUMBSTICK_DEADZONE then
+			MasterControl:AddToPlayerMovement(-currentMoveVector)
+			currentMoveVector = Vector3.new(inputObject.Position.X, 0, -inputObject.Position.Y)
+			if currentMoveVector.magnitude > 0 then
+				currentMoveVector = currentMoveVector.unit * math.min(1, inputObject.Position.magnitude)
+			end
+			MasterControl:AddToPlayerMovement(currentMoveVector)
+
+			moveLatch = true
+		end
+	else
+		MasterControl:AddToPlayerMovement(-currentMoveVector)
+		currentMoveVector =  Vector3.new(0,0,0)
+		
+		if shouldUseNavigationLaser() then
+			bindJumpAction(false)
+			setLaserPointerMode("Navigation")
+		end
+		
+		if moveLatch then
+			moveLatch = false
+			movementUpdateEvent:Fire("offtrack")
+		end
+	end
+end
+
+local function onHeartbeat(dt)
+	local newMoveVector = currentMoveVector
+	local humanoid = getLocalHumanoid()
+	if not humanoid or not humanoid.Torso then
+		return
+	end
+
+	if moving and currentPoints then
+		local currentPosition = humanoid.Torso.Position
+		local goalPosition = currentPoints[1]
+		local vectorToGoal = (goalPosition - currentPosition) * XZ_VECTOR3
+		local moveDist = vectorToGoal.magnitude
+		local moveDir = vectorToGoal / moveDist
+			
+		if moveDist < POINT_REACHED_THRESHOLD then
+			local estimatedTimeRemaining = 0
+			local prevPoint = currentPoints[1]
+			for i, point in pairs(currentPoints) do
+				if i ~= 1 then
+					local dist = (point - prevPoint).magnitude
+					prevPoint = point
+					estimatedTimeRemaining = estimatedTimeRemaining + (dist / humanoid.WalkSpeed)
+				end
+			end					
+			
+			table.remove(currentPoints, 1)
+			currentPointIdx = currentPointIdx + 1
+
+			if #currentPoints == 0 then
+				stopFollowingPath()
+				if PathDisplay then
+					PathDisplay.clearRenderedPath()
+				end
+				return
+			else
+				if PathDisplay then
+					PathDisplay.setCurrentPoints(currentPoints)
+					PathDisplay.renderPath()
+				end
+				
+				local newGoal = currentPoints[1]
+				local distanceToGoal = (newGoal - currentPosition).magnitude
+				expectedTimeToNextPoint = distanceToGoal / humanoid.WalkSpeed
+				timeReachedLastPoint = tick()
+			end
+		else
+			local ignoreTable = { 
+				game.Players.LocalPlayer.Character, 
+				workspace.CurrentCamera 
+			}
+			local obstructRay = Ray.new(currentPosition - Vector3.new(0, 1, 0), moveDir * 3)
+			local obstructPart, obstructPoint, obstructNormal = workspace:FindPartOnRayWithIgnoreList(obstructRay, ignoreTable)		
+				
+			if obstructPart then
+				local heightOffset = Vector3.new(0, 100, 0)
+				local jumpCheckRay = Ray.new(obstructPoint + moveDir * 0.5 + heightOffset, -heightOffset)
+				local jumpCheckPart, jumpCheckPoint, jumpCheckNormal = workspace:FindPartOnRayWithIgnoreList(jumpCheckRay, ignoreTable)		
+				
+				local heightDifference = jumpCheckPoint.Y - currentPosition.Y
+				if heightDifference < 6 and heightDifference > -2 then
+					humanoid.Jump = true
+				end
+			end
+			
+			local timeSinceLastPoint = tick() - timeReachedLastPoint
+			if timeSinceLastPoint > expectedTimeToNextPoint + OFFTRACK_TIME_THRESHOLD then
+				stopFollowingPath()
+				if PathDisplay then
+					PathDisplay.clearRenderedPath()
+				end
+				
+				movementUpdateEvent:Fire("offtrack")
+			end
+				
+			newMoveVector = currentMoveVector:Lerp(moveDir, dt * 10)
+		end
+	end
+	
+	if IsFiniteVector3(newMoveVector) then
+		MasterControl:AddToPlayerMovement(newMoveVector - currentMoveVector)
+		currentMoveVector = newMoveVector
+	end
+end
+
+local userCFrameEnabledConn = nil
+local function onUserCFrameEnabled()
+	if shouldUseNavigationLaser() then
+		bindJumpAction(false)
+		setLaserPointerMode("Navigation")
+	else
+		bindJumpAction(true)
+		setLaserPointerMode("Hidden")
+	end
+end
+
+function VRNavigation:Enable()
+	navigationRequestedConn = VRService.NavigationRequested:connect(onNavigationRequest)
+	heartbeatConn = RunService.Heartbeat:connect(onHeartbeat)
+	
+	ContextActionService:BindAction("MoveThumbstick", controlCharacterGamepad, false, Enum.KeyCode.Thumbstick1)
+	ContextActionService:BindActivate(Enum.UserInputType.Gamepad1, Enum.KeyCode.ButtonR2)	
+	
+	userCFrameEnabledConn = VRService.UserCFrameEnabled:connect(onUserCFrameEnabled)
+	onUserCFrameEnabled()
+
+	pcall(function()
+		VRService:SetTouchpadMode(Enum.VRTouchpad.Left, Enum.VRTouchpadMode.VirtualThumbstick)
+		VRService:SetTouchpadMode(Enum.VRTouchpad.Right, Enum.VRTouchpadMode.ABXY)
+	end)
+end
+
+function VRNavigation:Disable()
+	stopFollowingPath()
+	
+	ContextActionService:UnbindAction("MoveThumbstick")
+	ContextActionService:UnbindActivate(Enum.UserInputType.Gamepad1, Enum.KeyCode.ButtonR2)
+	
+	bindJumpAction(false)
+	setLaserPointerMode("Disabled")
+	
+	if navigationRequestedConn then
+		navigationRequestedConn:disconnect()
+		navigationRequestedConn = nil
+	end
+	if heartbeatConn then
+		heartbeatConn:disconnect()
+		heartbeatConn = nil
+	end
+	if userCFrameEnabledConn then
+		userCFrameEnabledConn:disconnect()
+		userCFrameEnabledConn = nil
+	end
+end
+
+return VRNavigation

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/MasterControl/VehicleController.lua

@@ -0,0 +1,180 @@
+--[[
+	// FileName: VehicleControl
+	// Version 1.0
+	// Written by: jmargh
+	// Description: Implements in-game vehicle controls for all input devices
+	
+	// NOTE: This works for basic vehicles (single vehicle seat). If you use custom VehicleSeat code,
+	// multiple VehicleSeats or your own implementation of a VehicleSeat this will not work.
+--]]
+
+local VehicleController = {}
+
+local ContextActionService = game:GetService('ContextActionService')
+local Players = game:GetService('Players')
+local RunService = game:GetService('RunService')
+
+local MasterControl = require(script.Parent)
+
+while not Players.LocalPlayer do
+	wait()
+end
+local LocalPlayer = Players.LocalPlayer
+local CurrentVehicleSeat = nil
+local CurrentThrottle = 0
+local CurrentSteer = 0
+local HumanoidSeatedCn = nil
+local RenderSteppedCn = nil
+local Accelerating = false
+local Deccelerating = false
+local TurningRight = false
+local TurningLeft = false
+-- 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 function onThrottleAccel(actionName, inputState, inputObject)
+	MasterControl:AddToPlayerMovement(Vector3.new(0, 0, -CurrentThrottle))
+	CurrentThrottle = (inputState == Enum.UserInputState.End or Deccelerating) and 0 or -1
+	MasterControl:AddToPlayerMovement(Vector3.new(0, 0, CurrentThrottle))
+	Accelerating = not (inputState == Enum.UserInputState.End)
+	if (inputState == Enum.UserInputState.End) and Deccelerating then
+		CurrentThrottle = 1
+		MasterControl:AddToPlayerMovement(Vector3.new(0, 0, CurrentThrottle))
+	end
+end
+
+local function onThrottleDeccel(actionName, inputState, inputObject)
+	MasterControl:AddToPlayerMovement(Vector3.new(0, 0, -CurrentThrottle))
+	CurrentThrottle = (inputState == Enum.UserInputState.End or Accelerating) and 0 or 1
+	MasterControl:AddToPlayerMovement(Vector3.new(0, 0, CurrentThrottle))
+	Deccelerating = not (inputState == Enum.UserInputState.End)
+	if (inputState == Enum.UserInputState.End) and Accelerating then
+		CurrentThrottle = -1
+		MasterControl:AddToPlayerMovement(Vector3.new(0, 0, CurrentThrottle))
+	end
+end
+
+local function onSteerRight(actionName, inputState, inputObject)
+	MasterControl:AddToPlayerMovement(Vector3.new(-CurrentSteer, 0, 0))
+	CurrentSteer = (inputState == Enum.UserInputState.End or TurningLeft) and 0 or 1
+	MasterControl:AddToPlayerMovement(Vector3.new(CurrentSteer, 0, 0))
+	TurningRight = not (inputState == Enum.UserInputState.End)
+	if (inputState == Enum.UserInputState.End) and TurningLeft then
+		CurrentSteer = -1
+		MasterControl:AddToPlayerMovement(Vector3.new(CurrentSteer, 0, 0))
+	end
+end
+
+local function onSteerLeft(actionName, inputState, inputObject)
+	MasterControl:AddToPlayerMovement(Vector3.new(-CurrentSteer, 0, 0))
+	CurrentSteer = (inputState == Enum.UserInputState.End or TurningRight) and 0 or -1
+	MasterControl:AddToPlayerMovement(Vector3.new(CurrentSteer, 0, 0))
+	TurningLeft = not (inputState == Enum.UserInputState.End)
+	if (inputState == Enum.UserInputState.End) and TurningRight then
+		CurrentSteer = 1
+		MasterControl:AddToPlayerMovement(Vector3.new(CurrentSteer, 0, 0))
+	end
+end
+
+local function getHumanoid()
+	local character = LocalPlayer and LocalPlayer.Character
+	if character then
+		for _,child in pairs(character:GetChildren()) do
+			if child:IsA('Humanoid') then
+				return child
+			end
+		end
+	end
+end
+
+local function getClosestFittingValue(value)
+	if value > 0.5 then
+		return 1
+	elseif value < -0.5 then
+		return -1
+	end
+	return 0 
+end
+
+local function onRenderStepped()
+	if CurrentVehicleSeat then
+		local moveValue = MasterControl:GetMoveVector()
+		local didSetThrottleSteerFloat = false
+		didSetThrottleSteerFloat = pcall(function()
+			if game:GetService("UserInputService"):GetGamepadConnected(Enum.UserInputType.Gamepad1) and onlyTriggersForThrottle and useTriggersForThrottle then
+				CurrentVehicleSeat.ThrottleFloat = -CurrentThrottle
+			else
+				CurrentVehicleSeat.ThrottleFloat = -moveValue.z
+			end
+			CurrentVehicleSeat.SteerFloat = moveValue.x
+		end)	
+		
+		if didSetThrottleSteerFloat == false then
+			if game:GetService("UserInputService"):GetGamepadConnected(Enum.UserInputType.Gamepad1) and onlyTriggersForThrottle and useTriggersForThrottle then
+				CurrentVehicleSeat.Throttle = -CurrentThrottle
+			else
+				CurrentVehicleSeat.Throttle = getClosestFittingValue(-moveValue.z)
+			end
+			CurrentVehicleSeat.Steer = getClosestFittingValue(moveValue.x)
+		end
+	end
+end
+
+local function onSeated(active, currentSeatPart)
+	if active then
+		if currentSeatPart and currentSeatPart:IsA('VehicleSeat') then
+			CurrentVehicleSeat = currentSeatPart
+			if useTriggersForThrottle then
+				ContextActionService:BindAction("throttleAccel", onThrottleAccel, false, Enum.KeyCode.ButtonR2)
+				ContextActionService:BindAction("throttleDeccel", onThrottleDeccel, false, Enum.KeyCode.ButtonL2)
+			end
+			ContextActionService:BindAction("arrowSteerRight", onSteerRight, false, Enum.KeyCode.Right)
+			ContextActionService:BindAction("arrowSteerLeft", onSteerLeft, false, Enum.KeyCode.Left)
+			local success = pcall(function() RunService:BindToRenderStep("VehicleControlStep", Enum.RenderPriority.Input.Value, onRenderStepped) end)
+
+			if not success then
+				if RenderSteppedCn then return end
+				RenderSteppedCn = RunService.RenderStepped:connect(onRenderStepped)
+			end
+		end
+	else
+		CurrentVehicleSeat = nil
+		if useTriggersForThrottle then
+			ContextActionService:UnbindAction("throttleAccel")
+			ContextActionService:UnbindAction("throttleDeccel")
+		end
+		ContextActionService:UnbindAction("arrowSteerRight")
+		ContextActionService:UnbindAction("arrowSteerLeft")
+		MasterControl:AddToPlayerMovement(Vector3.new(-CurrentSteer, 0, -CurrentThrottle))
+		CurrentThrottle = 0
+		CurrentSteer = 0
+		local success = pcall(function() RunService:UnbindFromRenderStep("VehicleControlStep") end)
+		if not success and RenderSteppedCn then
+			RenderSteppedCn:disconnect()
+			RenderSteppedCn = nil
+		end
+	end
+end
+
+local function CharacterAdded(character)
+	local humanoid = getHumanoid()
+	while not humanoid do
+		wait()
+		humanoid = getHumanoid()
+	end
+	--
+	if HumanoidSeatedCn then
+		HumanoidSeatedCn:disconnect()
+		HumanoidSeatedCn = nil
+	end
+	HumanoidSeatedCn = humanoid.Seated:connect(onSeated)
+end
+
+if LocalPlayer.Character then
+	CharacterAdded(LocalPlayer.Character)
+end
+LocalPlayer.CharacterAdded:connect(CharacterAdded)
+
+return VehicleController

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts/ControlScript/PathDisplay.lua

@@ -0,0 +1,131 @@
+
+
+local PathDisplay = {}
+PathDisplay.spacing = 8
+PathDisplay.image = "rbxasset://textures/Cursors/Gamepad/Pointer.png"
+PathDisplay.imageSize = Vector2.new(2, 2)
+
+local currentPoints = {}
+local renderedPoints = {}
+
+local pointModel = Instance.new("Model")
+pointModel.Name = "PathDisplayPoints"
+
+local adorneePart = Instance.new("Part")
+adorneePart.Anchored = true
+adorneePart.CanCollide = false
+adorneePart.Transparency = 1
+adorneePart.Name = "PathDisplayAdornee"
+adorneePart.CFrame = CFrame.new(0, 0, 0)
+adorneePart.Parent = pointModel
+
+local pointPool = {}
+local poolTop = 30
+for i = 1, poolTop do
+	local point = Instance.new("ImageHandleAdornment")
+	point.Archivable = false
+	point.Adornee = adorneePart
+	point.Image = PathDisplay.image
+	point.Size = PathDisplay.imageSize
+	pointPool[i] = point
+end
+
+local function retrieveFromPool()
+	local point = pointPool[1]
+	if not point then
+		return
+	end
+	
+	pointPool[1], pointPool[poolTop] = pointPool[poolTop], nil
+	poolTop = poolTop - 1
+	return point
+end
+
+local function returnToPool(point)
+	poolTop = poolTop + 1
+	pointPool[poolTop] = point
+end
+
+local function renderPoint(point, isLast)
+	if poolTop == 0 then
+		return
+	end
+
+	local rayDown = Ray.new(point + Vector3.new(0, 2, 0), Vector3.new(0, -8, 0))
+	local hitPart, hitPoint, hitNormal = workspace:FindPartOnRayWithIgnoreList(rayDown, { game.Players.LocalPlayer.Character, workspace.CurrentCamera  }) 	
+	if not hitPart then
+		return
+	end
+
+	local pointCFrame = CFrame.new(hitPoint, hitPoint + hitNormal)
+	
+	local point = retrieveFromPool()
+	point.CFrame = pointCFrame
+	point.Parent = pointModel
+	return point
+end
+
+function PathDisplay.setCurrentPoints(points)
+	if typeof(points) == 'table' then
+		currentPoints = points
+	else
+		currentPoints = {}
+	end
+end
+
+function PathDisplay.clearRenderedPath()
+	for _, oldPoint in ipairs(renderedPoints) do
+		oldPoint.Parent = nil
+		returnToPool(oldPoint)
+	end
+	renderedPoints = {}
+	pointModel.Parent = nil
+end
+
+function PathDisplay.renderPath()
+	PathDisplay.clearRenderedPath()
+	if not currentPoints or #currentPoints == 0 then
+		return
+	end
+
+	local currentIdx = #currentPoints
+	local lastPos = currentPoints[currentIdx]	
+	local distanceBudget = 0
+	
+	renderedPoints[1] = renderPoint(lastPos, true)
+	if not renderedPoints[1] then
+		return
+	end
+	
+	while true do
+		local currentPoint = currentPoints[currentIdx]
+		local nextPoint = currentPoints[currentIdx - 1]
+		
+		if currentIdx < 2 then
+			break
+		else
+			
+			local toNextPoint = nextPoint - currentPoint
+			local distToNextPoint = toNextPoint.magnitude	
+			
+			if distanceBudget > distToNextPoint then
+				distanceBudget = distanceBudget - distToNextPoint
+				currentIdx = currentIdx - 1
+			else
+				local dirToNextPoint = toNextPoint.unit
+				local pointPos = currentPoint + (dirToNextPoint * distanceBudget)
+				local point = renderPoint(pointPos, false)
+				
+				if point then
+					renderedPoints[#renderedPoints + 1] = point
+				end
+				
+				distanceBudget = distanceBudget + PathDisplay.spacing
+			end
+		end
+	end
+	
+	pointModel.Parent = workspace.CurrentCamera
+end
+
+return PathDisplay

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScriptsCommon/.robloxrc

@@ -0,0 +1,7 @@
+{
+	"lint": {
+		"LocalShadow": "fatal",
+		"ImportUnused": "fatal",
+		"ImplicitReturn": "fatal"
+	}
+}

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScriptsCommon/RbxCharacterSounds.lua

@@ -0,0 +1,310 @@
+-- Roblox character sound 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 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 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 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()
+		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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module.lua

@@ -0,0 +1,31 @@
+--[[
+	PlayerModule - This module requires and instantiates the camera and control modules,
+	and provides getters for developers to access methods on these singletons without
+	having to modify Roblox-supplied scripts.
+
+	2018 PlayerScripts Update - AllYourBlox
+--]]
+
+local PlayerModule = {}
+PlayerModule.__index = PlayerModule
+
+function PlayerModule.new()
+	local self = setmetatable({},PlayerModule)
+	self.cameras = require(script:WaitForChild("CameraModule"))
+	self.controls = require(script:WaitForChild("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()

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule.lua

@@ -0,0 +1,567 @@
+--[[
+	CameraModule - This ModuleScript implements a singleton class to manage the
+	selection, activation, and deactivation of the current camera controller,
+	character occlusion controller, and transparency controller. This script binds to
+	RenderStepped at Camera priority and calls the Update() methods on the active
+	controller instances.
+
+	The camera controller ModuleScripts implement classes which are instantiated and
+	activated as-needed, they are no longer all instantiated up front as they were in
+	the previous generation of PlayerScripts.
+
+	2018 PlayerScripts Update - AllYourBlox
+--]]
+
+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
+
+local FFlagUserCameraInputRefactor do
+	local success, result = pcall(function()
+		return UserSettings():IsUserFeatureEnabled("UserCameraInputRefactor2")
+	end)
+	FFlagUserCameraInputRefactor = 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")
+
+-- Static camera utils
+local CameraUtils = require(script:WaitForChild("CameraUtils"))
+local CameraInput = require(script:WaitForChild("CameraInput"))
+
+-- Load Roblox Camera Controller Modules
+local ClassicCamera = require(script:WaitForChild("ClassicCamera"))
+local OrbitalCamera = require(script:WaitForChild("OrbitalCamera"))
+local LegacyCamera = require(script:WaitForChild("LegacyCamera"))
+
+-- Load Roblox Occlusion Modules
+local Invisicam = require(script:WaitForChild("Invisicam"))
+local Poppercam = require(script:WaitForChild("Poppercam"))
+
+-- Load the near-field character transparency controller and the mouse lock "shift lock" controller
+local TransparencyController = require(script:WaitForChild("TransparencyController"))
+local MouseLockController = require(script:WaitForChild("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
+
+
+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
+
+		if FFlagUserCameraInputRefactor and CameraInput.getInputEnabled() then
+			CameraInput.resetInputForFrameEnd()
+		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
+
+local cameraModuleObject = CameraModule.new()
+local cameraApi = {}
+
+if FFlagUserRemoveTheCameraApi then
+	return cameraApi
+else
+	return cameraModuleObject
+end

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/.robloxrc

@@ -0,0 +1,5 @@
+{
+	"lint": {
+		"ImplicitReturn": "fatal"
+	}
+}

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/BaseOcclusion.lua

@@ -0,0 +1,47 @@
+--[[
+	BaseOcclusion - Abstract base class for character occlusion control modules
+	2018 Camera Update - AllYourBlox
+--]]
+
+--[[ 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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/CameraInput.lua

@@ -0,0 +1,494 @@
+local FFlagUserCameraInputRefactor do
+	local success, result = pcall(function()
+		return UserSettings():IsUserFeatureEnabled("UserCameraInputRefactor2")
+	end)
+	FFlagUserCameraInputRefactor = success and result
+end
+
+local ContextActionService = game:GetService("ContextActionService")
+local UserInputService = game:GetService("UserInputService")
+local Players = game:GetService("Players")
+local UserGameSettings = UserSettings():GetService("UserGameSettings")
+
+local player = Players.LocalPlayer
+
+local CAMERA_INPUT_PRIORITY = Enum.ContextActionPriority.Default.Value
+local MB_TAP_LENGTH = 0.3 -- (s) length of time for a short mouse button tap to be registered
+
+local ROTATION_SPEED_KEYS = math.rad(2) -- (rad/s)
+local ROTATION_SPEED_MOUSE = Vector2.new(1, 0.77)*math.rad(0.5) -- (rad/s)
+local ROTATION_SPEED_TOUCH = Vector2.new(1, 0.66)*math.rad(1) -- (rad/s)
+local ROTATION_SPEED_GAMEPAD = Vector2.new(1, 0.77)*math.rad(4) -- (rad/s)
+
+local ZOOM_SPEED_MOUSE = 1 -- (scaled studs/wheel click)
+local ZOOM_SPEED_KEYS = 0.1 -- (studs/s)
+local ZOOM_SPEED_TOUCH = 0.04 -- (scaled studs/DIP %)
+
+local MIN_TOUCH_SENSITIVITY_FRACTION = 0.25 -- 25% sensitivity at 90°
+
+-- right mouse button up & down events
+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 thumbstickCurve do
+	local K_CURVATURE = 2 -- amount of upwards curvature (0 is flat)
+	local K_DEADZONE = 0.1 -- deadzone
+
+	function thumbstickCurve(x)
+		-- remove sign, apply linear deadzone
+		local fDeadzone = (math.abs(x) - K_DEADZONE)/(1 - K_DEADZONE)
+		
+		-- apply exponential curve and scale to fit in [0, 1]
+		local fCurve = (math.exp(K_CURVATURE*fDeadzone) - 1)/(math.exp(K_CURVATURE) - 1)
+		
+		-- reapply sign and clamp
+		return math.sign(x)*math.clamp(fCurve, 0, 1)
+	end
+end
+
+-- Adjust the touch sensitivity so that sensitivity is reduced when swiping up
+-- or down, but stays the same when swiping towards the middle of the screen
+local function adjustTouchPitchSensitivity(delta)
+	local camera = workspace.CurrentCamera
+
+	if not camera then
+		return delta
+	end
+	
+	-- get the camera pitch in world space
+	local pitch = camera.CFrame:ToEulerAnglesYXZ()
+	
+	if delta.Y*pitch >= 0 then
+		-- do not reduce sensitivity when pitching towards the horizon
+		return delta
+	end
+	
+	-- set up a line to fit:
+	-- 1 = f(0)
+	-- 0 = f(±pi/2)
+	local curveY = 1 - (2*math.abs(pitch)/math.pi)^0.75
+
+	-- remap curveY from [0, 1] -> [MIN_TOUCH_SENSITIVITY_FRACTION, 1]
+	local sensitivity = curveY*(1 - MIN_TOUCH_SENSITIVITY_FRACTION) + MIN_TOUCH_SENSITIVITY_FRACTION
+
+	return Vector2.new(1, sensitivity)*delta
+end
+
+local function isInDynamicThumbstickArea(pos)
+	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
+	
+	if not touchGui.Enabled then
+		return false
+	end
+
+	local posTopLeft = thumbstickFrame.AbsolutePosition
+	local posBottomRight = posTopLeft + thumbstickFrame.AbsoluteSize
+
+	return
+		pos.X >= posTopLeft.X and
+		pos.Y >= posTopLeft.Y and
+		pos.X <= posBottomRight.X and
+		pos.Y <= posBottomRight.Y
+end
+
+local CameraInput = {}
+
+do
+	local connectionList = {}
+	
+	local touchPitchSensitivity = 1
+	local gamepadState = {
+		Thumbstick2 = Vector2.new(),
+	}
+	local keyboardState = {
+		Left = 0,
+		Right = 0,
+		I = 0,
+		O = 0
+	}
+	local mouseState = {
+		Movement = Vector2.new(),
+		Wheel = 0, -- PointerAction
+		Pan = Vector2.new(), -- PointerAction
+		Pinch = 0, -- PointerAction
+		MouseButton2 = 0,
+	}
+	local touchState = {
+		Move = Vector2.new(),
+		Pinch = 0,
+	}
+	
+	local gamepadZoomPressBindable = Instance.new("BindableEvent")
+	CameraInput.gamepadZoomPress = gamepadZoomPressBindable.Event
+	
+	function CameraInput.getPanning()
+		for _, input in pairs(UserInputService:GetMouseButtonsPressed()) do
+			if input.UserInputType == Enum.UserInputType.MouseButton2 then
+				return true
+			end
+		end
+		return false
+	end
+	
+	function CameraInput.getRotation()
+		local kKeyboard = Vector2.new(keyboardState.Right - keyboardState.Left, 0)
+		local kGamepad = gamepadState.Thumbstick2
+		local kMouse = mouseState.Movement + mouseState.Pan
+		local kTouch = adjustTouchPitchSensitivity(touchState.Move)
+
+		local result =
+			kKeyboard*ROTATION_SPEED_KEYS +
+			kGamepad*ROTATION_SPEED_GAMEPAD +
+			kMouse*ROTATION_SPEED_MOUSE +
+			kTouch*ROTATION_SPEED_TOUCH
+
+		return result
+	end
+	
+	function CameraInput.getZoomDelta()
+		local kKeyboard = keyboardState.O - keyboardState.I
+		local kMouse = -mouseState.Wheel + mouseState.Pinch
+		local kTouch = -touchState.Pinch
+		return kKeyboard*ZOOM_SPEED_KEYS + kMouse*ZOOM_SPEED_MOUSE + kTouch*ZOOM_SPEED_TOUCH
+	end
+
+	do
+		local function thumbstick(action, state, input)
+			local position = input.Position
+			gamepadState[input.KeyCode.Name] = Vector2.new(thumbstickCurve(position.X), -thumbstickCurve(position.Y))
+		end
+
+		local function mouseMove(action, state, input)
+			local delta = input.Delta
+			mouseState.Movement = Vector2.new(delta.X, delta.Y)
+			return Enum.ContextActionResult.Pass
+		end
+		
+		local function mouseWheel(action, state, input)
+			mouseState.Wheel = input.Position.Z
+			return Enum.ContextActionResult.Pass
+		end
+		
+		local function keypress(action, state, input)
+			keyboardState[input.KeyCode.Name] = state == Enum.UserInputState.Begin and 1 or 0
+		end
+		
+		local function gamepadZoomPress(action, state, input)
+			if state == Enum.UserInputState.Begin then
+				gamepadZoomPressBindable:Fire()
+			end
+		end
+		
+		local function resetInputDevices()
+			for _, device in pairs({
+				gamepadState,
+				keyboardState,
+				mouseState,
+				touchState,
+			}) do
+				for k, v in pairs(device) do
+					if type(v) == "boolean" then
+						device[k] = false
+					else
+						device[k] *= 0 -- Mul by zero to preserve vector types
+					end
+				end
+			end
+		end
+
+		local touchBegan, touchChanged, touchEnded do
+			-- Use TouchPan & TouchPinch when they work in the Studio emulator
+
+			local touches = {} -- {[InputObject] = sunk}
+			local dynamicThumbstickInput -- Special-cased 
+			local lastPinchDiameter
+
+			function touchBegan(input, sunk)
+				assert(input.UserInputType == Enum.UserInputType.Touch)
+				assert(input.UserInputState == Enum.UserInputState.Begin)
+				
+				if dynamicThumbstickInput == nil and isInDynamicThumbstickArea(input.Position) and not sunk then
+					-- any finger down starting in the dynamic thumbstick area should always be
+					-- ignored for camera purposes. these must be handled specially from all other
+					-- inputs, as the DT does not sink inputs by itself
+					dynamicThumbstickInput = input
+					return
+				end
+				
+				-- register the finger
+				touches[input] = sunk
+			end
+
+			function touchEnded(input, sunk)
+				assert(input.UserInputType == Enum.UserInputType.Touch)
+				assert(input.UserInputState == Enum.UserInputState.End)
+				
+				-- reset the DT input
+				if input == dynamicThumbstickInput then
+					dynamicThumbstickInput = nil
+				end
+				
+				-- reset pinch state if one unsunk finger lifts
+				if touches[input] == false then
+					lastPinchDiameter = nil
+				end
+				
+				-- unregister input
+				touches[input] = nil
+			end
+
+			function touchChanged(input, sunk)
+				assert(input.UserInputType == Enum.UserInputType.Touch)
+				assert(input.UserInputState == Enum.UserInputState.Change)
+				
+				-- ignore movement from the DT finger
+				if input == dynamicThumbstickInput then
+					return
+				end
+				
+				-- fixup unknown touches
+				if touches[input] == nil then
+					touches[input] = sunk
+				end
+				
+				-- collect unsunk touches
+				local unsunkTouches = {}
+				for touch, sunk in pairs(touches) do
+					if not sunk then
+						table.insert(unsunkTouches, touch)
+					end
+				end
+				
+				-- 1 finger: pan
+				if #unsunkTouches == 1 then
+					if touches[input] == false then
+						local delta = input.Delta
+						touchState.Move = Vector2.new(delta.X, delta.Y)
+					end
+				end
+				
+				-- 2 fingers: pinch
+				if #unsunkTouches == 2 then
+					local pinchDiameter = (unsunkTouches[1].Position - unsunkTouches[2].Position).Magnitude
+					
+					if lastPinchDiameter then
+						touchState.Pinch = pinchDiameter - lastPinchDiameter
+					end
+					
+					lastPinchDiameter = pinchDiameter
+				else
+					lastPinchDiameter = nil
+				end
+			end
+		end
+
+		local function pointerAction(wheel, pan, pinch, gpe)
+			if not gpe then
+				local inversionVector = Vector2.new(1, UserGameSettings:GetCameraYInvertValue())
+				
+				mouseState.Wheel = wheel
+				mouseState.Pan = pan*inversionVector
+				mouseState.Pinch = -pinch
+			end
+		end
+
+		local function inputBegan(input, sunk)
+			if input.UserInputType == Enum.UserInputType.Touch then
+				touchBegan(input, sunk)
+			end
+		end
+
+		local function inputChanged(input, sunk)
+			if input.UserInputType == Enum.UserInputType.Touch then
+				touchChanged(input, sunk)
+			end
+		end
+
+		local function inputEnded(input, sunk)
+			if input.UserInputType == Enum.UserInputType.Touch then
+				touchEnded(input, sunk)
+			end
+		end
+
+		local inputEnabled = false
+
+		function CameraInput.setInputEnabled(_inputEnabled)
+			assert(FFlagUserCameraInputRefactor)
+
+			if inputEnabled == _inputEnabled then
+				return
+			end
+			inputEnabled = _inputEnabled
+
+			if inputEnabled then -- enable
+				resetInputDevices()
+				
+				ContextActionService:BindActionAtPriority(
+					"RbxCameraThumbstick",
+					thumbstick,
+					false,
+					CAMERA_INPUT_PRIORITY,
+					Enum.KeyCode.Thumbstick2
+				)
+				
+				ContextActionService:BindActionAtPriority(
+					"RbxCameraMouseMove",
+					mouseMove,
+					false,
+					CAMERA_INPUT_PRIORITY,
+					Enum.UserInputType.MouseMovement
+				)
+				
+				ContextActionService:BindActionAtPriority(
+					"RbxCameraKeypress",
+					keypress,
+					false,
+					CAMERA_INPUT_PRIORITY,
+					Enum.KeyCode.Left,
+					Enum.KeyCode.Right,
+					Enum.KeyCode.I,
+					Enum.KeyCode.O
+				)
+				
+				ContextActionService:BindAction(
+					"RbxCameraGamepadZoom",
+					gamepadZoomPress,
+					false,
+					Enum.KeyCode.ButtonR3
+				)
+				
+				table.insert(connectionList, UserInputService.InputBegan:Connect(inputBegan))
+				table.insert(connectionList, UserInputService.InputChanged:Connect(inputChanged))
+				table.insert(connectionList, UserInputService.InputEnded:Connect(inputEnded))
+				table.insert(connectionList, UserInputService.PointerAction:Connect(pointerAction))
+
+			else -- disable
+				ContextActionService:UnbindAction("RbxCameraThumbstick")
+				ContextActionService:UnbindAction("RbxCameraMouseMove")
+				ContextActionService:UnbindAction("RbxCameraMouseWheel")
+				ContextActionService:UnbindAction("RbxCameraKeypress")
+				
+				resetInputDevices()
+				
+				for _, conn in pairs(connectionList) do
+					conn:Disconnect()
+				end
+				connectionList = {}
+			end
+		end
+
+		function CameraInput.getInputEnabled()
+			return inputEnabled
+		end
+		
+		function CameraInput.resetInputForFrameEnd()
+			mouseState.Movement = Vector2.new()
+			touchState.Move = Vector2.new()
+			mouseState.Wheel = 0
+			touchState.Pinch = 0
+		end
+
+		UserInputService.WindowFocused:Connect(resetInputDevices)
+		UserInputService.WindowFocusReleased:Connect(resetInputDevices)
+	end
+end
+
+-- Toggle pan
+do
+	local holdPan = false
+	local togglePan = false
+	local lastRmbDown = 0 -- tick() timestamp of the last right mouse button down event
+	
+	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
+end
+
+return CameraInput

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/CameraToggleStateController.lua

@@ -0,0 +1,84 @@
+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 = require(script.Parent:WaitForChild("CameraInput"))
+local CameraUI = require(script.Parent:WaitForChild("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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/CameraUI.lua

@@ -0,0 +1,197 @@
+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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/CameraUtils.lua

@@ -0,0 +1,172 @@
+--[[
+	CameraUtils - Math utility functions shared by multiple camera scripts
+	2018 Camera Update - AllYourBlox
+--]]
+
+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
+

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/ClassicCamera.lua

@@ -0,0 +1,371 @@
+--[[
+	ClassicCamera - Classic Roblox camera control module
+	2018 Camera Update - AllYourBlox
+
+	Note: This module also handles camera control types Follow and Track, the
+	latter of which is currently not distinguished from Classic
+--]]
+
+-- 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       -- Seconds, used when auto-aligning camera with vehicles
+
+local INITIAL_CAMERA_ANGLE = CFrame.fromOrientation(math.rad(-15), 0, 0)
+local ZOOM_SENSITIVITY_CURVATURE = 0.5
+
+local FFlagUserCameraToggle do
+	local success, result = pcall(function()
+		return UserSettings():IsUserFeatureEnabled("UserCameraToggle")
+	end)
+	FFlagUserCameraToggle = success and result
+end
+
+local FFlagUserCameraInputRefactor do
+	local success, result = pcall(function()
+		return UserSettings():IsUserFeatureEnabled("UserCameraInputRefactor2")
+	end)
+	FFlagUserCameraInputRefactor = success and result
+end
+
+--[[ Services ]]--
+local PlayersService = game:GetService("Players")
+local VRService = game:GetService("VRService")
+
+local CameraInput = require(script.Parent:WaitForChild("CameraInput"))
+local Util = require(script.Parent:WaitForChild("CameraUtils"))
+
+--[[ The Module ]]--
+local BaseCamera = require(script.Parent:WaitForChild("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
+	
+	local rotateInput
+	if FFlagUserCameraInputRefactor then
+		rotateInput = CameraInput.getRotation()
+	else
+		rotateInput = self.rotateInput
+	end
+
+	if FFlagUserCameraInputRefactor then
+		local zoom = self.currentSubjectDistance	
+		local zoomDelta = CameraInput.getZoomDelta()	
+		
+		if math.abs(zoomDelta) > 0 then
+			local newZoom
+			if self.inFirstPerson and zoomDelta < 0 then
+				newZoom = 0.5
+			else
+				if zoomDelta > 0 then
+					newZoom = zoom + zoomDelta*(1 + zoom*ZOOM_SENSITIVITY_CURVATURE)
+				else
+					newZoom = (zoom + zoomDelta) / (1 - zoomDelta*ZOOM_SENSITIVITY_CURVATURE)
+				end
+			end
+
+			self:SetCameraToSubjectDistance(newZoom)
+		end
+	end
+
+	if self.lastUpdate and not FFlagUserCameraInputRefactor 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 FFlagUserCameraInputRefactor then
+		if CameraInput.getRotation() ~= Vector2.new() then
+			tweenSpeed = 0
+			self.lastUserPanCamera = tick()
+		end
+	else
+		if self.userPanningTheCamera then
+			tweenSpeed = 0
+			self.lastUserPanCamera = tick()
+		end
+	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
+			if FFlagUserCameraInputRefactor then 
+				newLookCFrame = self:CalculateNewLookCFrameFromArg(overrideCameraLookVector, rotateInput)
+			else
+				newLookCFrame = self:CalculateNewLookCFrame(overrideCameraLookVector)
+			end
+
+			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
+			local userPanningTheCamera
+			if FFlagUserCameraInputRefactor then
+				userPanningTheCamera = CameraInput.getRotation() ~= Vector2.new()
+			else
+				userPanningTheCamera = self.userPanningTheCamera == true
+			end
+
+			if not 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
+								if FFlagUserCameraInputRefactor then
+									rotateInput = rotateInput + Vector2.new(y, 0)
+								else
+									self.rotateInput = self.rotateInput + Vector2.new(y, 0)
+								end
+							end
+							tweenSpeed = 0
+						end
+					elseif not userRecentlyPannedCamera then
+						local forwardVector = humanoid.Torso.CFrame.lookVector
+						if isOnASkateboard and not FFlagUserCameraInputRefactor 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
+							if FFlagUserCameraInputRefactor then
+								rotateInput = rotateInput + Vector2.new(y * percent, 0)
+							else
+								self.rotateInput = self.rotateInput + Vector2.new(y * percent, 0)
+							end
+						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
+						rotateInput = 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
+
+				local flaggedRotateInput
+				if FFlagUserCameraInputRefactor then
+					flaggedRotateInput = rotateInput
+				else
+					flaggedRotateInput = self.rotateInput
+				end
+
+				-- Only move the camera if it exceeded a maximum distance to the subject in VR
+				if distToSubject > zoom or flaggedRotateInput.x ~= 0 then
+					local desiredDist = math.min(distToSubject, zoom)
+					if FFlagUserCameraInputRefactor then
+						vecToSubject = self:CalculateNewLookFromArg(nil, rotateInput) * desiredDist
+					else
+						vecToSubject = self:CalculateNewLookVector() * desiredDist
+					end
+					local newPos = cameraFocusP - vecToSubject
+					local desiredLookDir = camera.CFrame.lookVector
+					if flaggedRotateInput.x ~= 0 then
+						desiredLookDir = vecToSubject
+					end
+					local lookAt = Vector3.new(newPos.x + desiredLookDir.x, newPos.y, newPos.z + desiredLookDir.z)
+					if not FFlagUserCameraInputRefactor then
+						self.rotateInput = ZERO_VECTOR2
+					end
+
+					newCameraCFrame = CFrame.new(newPos, lookAt) + Vector3.new(0, cameraHeight, 0)
+				end
+			else
+				local newLookVector
+				if FFlagUserCameraInputRefactor then
+					newLookVector = self:CalculateNewLookVectorFromArg(overrideCameraLookVector, rotateInput)
+				else
+					newLookVector = self:CalculateNewLookVector(overrideCameraLookVector)
+					self.rotateInput = ZERO_VECTOR2
+				end
+				newCameraCFrame = CFrame.new(cameraFocusP - (zoom * newLookVector), cameraFocusP)
+			end
+		else -- is FollowCamera
+			local newLookVector
+			if FFlagUserCameraInputRefactor then
+				newLookVector = self:CalculateNewLookVectorFromArg(overrideCameraLookVector, rotateInput)
+			else
+				newLookVector = self:CalculateNewLookVector(overrideCameraLookVector)
+				self.rotateInput = ZERO_VECTOR2
+			end
+
+			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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Invisicam.lua

@@ -0,0 +1,552 @@
+--[[
+	Invisicam - Occlusion module that makes objects occluding character view semi-transparent
+	2018 Camera Update - AllYourBlox		
+--]]
+
+--[[ 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 = require(script.Parent:WaitForChild("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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/LegacyCamera.lua

@@ -0,0 +1,153 @@
+--[[
+	LegacyCamera - Implements legacy controller types: Attach, Fixed, Watch
+	2018 Camera Update - AllYourBlox
+--]]
+
+local FFlagUserCameraInputRefactor do
+	local success, result = pcall(function()
+		return UserSettings():IsUserFeatureEnabled("UserCameraInputRefactor2")
+	end)
+	FFlagUserCameraInputRefactor = success and result
+end
+
+local ZERO_VECTOR2 = Vector2.new(0,0)
+
+local Util = require(script.Parent:WaitForChild("CameraUtils"))
+local CameraInput = require(script.Parent:WaitForChild("CameraInput"))
+
+--[[ Services ]]--
+local PlayersService = game:GetService('Players')
+
+--[[ The Module ]]--
+local BaseCamera = require(script.Parent:WaitForChild("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 and not FFlagUserCameraInputRefactor 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
+			if FFlagUserCameraInputRefactor then
+				newLookVector = self:CalculateNewLookVectorFromArg(nil, CameraInput.getRotation())
+			else
+				newLookVector = self:CalculateNewLookVector()
+				self.rotateInput = ZERO_VECTOR2
+			end
+
+			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 and not FFlagUserCameraInputRefactor 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
+			if FFlagUserCameraInputRefactor then
+				newLookVector = self:CalculateNewLookVectorFromArg(nil, CameraInput.getRotation())
+			else
+				newLookVector = self:CalculateNewLookVector()
+				self.rotateInput = ZERO_VECTOR2
+			end
+
+			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
+			if FFlagUserCameraInputRefactor then
+				newLookVector = self:CalculateNewLookVectorFromArg(cameraLook, CameraInput.getRotation())
+			else
+				newLookVector = self:CalculateNewLookVector(cameraLook)
+				self.rotateInput = ZERO_VECTOR2
+			end
+
+			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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/MouseLockController.lua

@@ -0,0 +1,210 @@
+--[[
+	MouseLockController - Replacement for ShiftLockController, manages use of mouse-locked mode
+	2018 Camera Update - AllYourBlox
+--]]
+
+--[[ 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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/OrbitalCamera.lua

@@ -0,0 +1,429 @@
+--[[
+	OrbitalCamera - Spherical coordinates control camera for top-down games
+	2018 Camera Update - AllYourBlox
+--]]
+
+local FFlagUserCameraInputRefactor do
+	local success, result = pcall(function()
+		return UserSettings():IsUserFeatureEnabled("UserCameraInputRefactor2")
+	end)
+	FFlagUserCameraInputRefactor = success and result
+end
+
+-- 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 = require(script.Parent:WaitForChild("CameraUtils"))
+local CameraInput = require(script.Parent:WaitForChild("CameraInput"))
+
+--[[ Services ]]--
+local PlayersService = game:GetService('Players')
+local VRService = game:GetService("VRService")
+
+--[[ The Module ]]--
+local BaseCamera = require(script.Parent:WaitForChild("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
+		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)
+	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
+
+-- Remove on FFlagUserCameraInputRefactor
+function OrbitalCamera:GetGamepadPan(name, state, input)
+	assert(not FFlagUserCameraInputRefactor)
+
+	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
+
+-- Remove on FFlagUserCameraInputRefactor
+function OrbitalCamera:DoGamepadZoom(name, state, input)
+	assert(not FFlagUserCameraInputRefactor)
+
+	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
+
+-- Remove on FFlagUserCameraInputRefactor
+function OrbitalCamera:BindGamepadInputActions()
+	assert(not FFlagUserCameraInputRefactor)
+
+	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
+	if FFlagUserCameraInputRefactor then
+		userPanningTheCamera = CameraInput.getRotation() ~= Vector2.new()
+	else
+		userPanningTheCamera = self.userPanningTheCamera == true
+	end
+	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 and not FFlagUserCameraInputRefactor 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 flaggedRotateInput
+		if FFlagUserCameraInputRefactor then
+			flaggedRotateInput = CameraInput.getRotation()
+		else
+			flaggedRotateInput = self.rotateInput
+		end
+
+		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 flaggedRotateInput.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(flaggedRotateInput.x, 0)) * desiredDist
+
+				local newPos = cameraFocusP - vecToSubject
+				local desiredLookDir = camera.CFrame.lookVector
+				if flaggedRotateInput.x ~= 0 then
+					desiredLookDir = vecToSubject
+				end
+				local lookAt = Vector3.new(newPos.x + desiredLookDir.x, newPos.y, newPos.z + desiredLookDir.z)
+				if not FFlagUserCameraInputRefactor then
+					self.rotateInput = ZERO_VECTOR2
+				end
+
+				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 - flaggedRotateInput.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 + flaggedRotateInput.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)
+			
+			if not FFlagUserCameraInputRefactor then
+				self.rotateInput = ZERO_VECTOR2
+			end
+		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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam.lua

@@ -0,0 +1,111 @@
+--[[
+	Poppercam - Occlusion module that brings the camera closer to the subject when objects are blocking the view.
+--]]
+
+local ZoomController =  require(script.Parent:WaitForChild("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 = require(script.Parent:WaitForChild("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
+
+return Poppercam

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/TransparencyController.lua

@@ -0,0 +1,189 @@
+--[[
+	TransparencyController - Manages transparency of player character at close camera-to-subject distances
+	2018 Camera Update - AllYourBlox
+--]]
+
+local MAX_TWEEN_RATE = 2.8 -- per second
+
+local Util = require(script.Parent:WaitForChild("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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/ZoomController.lua

@@ -0,0 +1,127 @@
+-- Zoom
+-- Controls the distance between the focus and the camera.
+
+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 = require(script:WaitForChild("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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/ZoomController/.robloxrc

@@ -0,0 +1,7 @@
+{
+	"lint": {
+		"LocalShadow": "fatal",
+		"FunctionUnused": "fatal",
+		"ImportUnused": "fatal"
+	}
+}

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/ZoomController/Popper.lua

@@ -0,0 +1,332 @@
+--------------------------------------------------------------------------------
+-- Popper.lua
+-- Prevents your camera from clipping through walls.
+--------------------------------------------------------------------------------
+
+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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule.lua

@@ -0,0 +1,503 @@
+--[[
+	ControlModule - This ModuleScript implements a singleton class to manage the
+	selection, activation, and deactivation of the current character movement controller.
+	This script binds to RenderStepped at Input priority and calls the Update() methods
+	on the active controller instances.
+
+	The character controller ModuleScripts implement classes which are instantiated and
+	activated as-needed, they are no longer all instantiated up front as they were in
+	the previous generation of PlayerScripts.
+
+	2018 PlayerScripts Update - AllYourBlox
+--]]
+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 = require(script:WaitForChild("Keyboard"))
+local Gamepad = require(script:WaitForChild("Gamepad"))
+local DynamicThumbstick = require(script:WaitForChild("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 require(script:WaitForChild("TouchThumbstick"))
+
+-- These controllers handle only walk/run movement, jumping is handled by the
+-- TouchJump controller if any of these are active
+local ClickToMove = require(script:WaitForChild("ClickToMoveController"))
+local TouchJump = require(script:WaitForChild("TouchJump"))
+
+local VehicleController = require(script:WaitForChild("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
+
+return ControlModule.new()

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/.robloxrc

@@ -0,0 +1,6 @@
+{
+	"lint": {
+		"FunctionUnused": "fatal",
+		"ImportUnused": "fatal"
+	}
+}

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/BaseCharacterController.lua

@@ -0,0 +1,46 @@
+--[[
+	BaseCharacterController - Abstract base class for character controllers, not intended to be
+	directly instantiated.
+
+	2018 PlayerScripts Update - AllYourBlox
+--]]
+
+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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/ClickToMoveDisplay.lua

@@ -0,0 +1,483 @@
+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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/DynamicThumbstick.lua

@@ -0,0 +1,541 @@
+--[[ Constants ]]--
+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 = require(script.Parent:WaitForChild("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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/Gamepad.lua

@@ -0,0 +1,213 @@
+--[[
+	Gamepad Character Control - This module handles controlling your avatar using a game console-style controller
+
+	2018 PlayerScripts Update - AllYourBlox
+--]]
+
+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 = require(script.Parent:WaitForChild("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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/Keyboard.lua

@@ -0,0 +1,176 @@
+--[[
+	Keyboard Character Control - This module handles controlling your avatar from a keyboard
+
+	2018 PlayerScripts Update - AllYourBlox
+--]]
+
+--[[ 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 = require(script.Parent:WaitForChild("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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/PathDisplay.lua

@@ -0,0 +1,131 @@
+
+
+local PathDisplay = {}
+PathDisplay.spacing = 8
+PathDisplay.image = "rbxasset://textures/Cursors/Gamepad/Pointer.png"
+PathDisplay.imageSize = Vector2.new(2, 2)
+
+local currentPoints = {}
+local renderedPoints = {}
+
+local pointModel = Instance.new("Model")
+pointModel.Name = "PathDisplayPoints"
+
+local adorneePart = Instance.new("Part")
+adorneePart.Anchored = true
+adorneePart.CanCollide = false
+adorneePart.Transparency = 1
+adorneePart.Name = "PathDisplayAdornee"
+adorneePart.CFrame = CFrame.new(0, 0, 0)
+adorneePart.Parent = pointModel
+
+local pointPool = {}
+local poolTop = 30
+for i = 1, poolTop do
+	local point = Instance.new("ImageHandleAdornment")
+	point.Archivable = false
+	point.Adornee = adorneePart
+	point.Image = PathDisplay.image
+	point.Size = PathDisplay.imageSize
+	pointPool[i] = point
+end
+
+local function retrieveFromPool()
+	local point = pointPool[1]
+	if not point then
+		return
+	end
+	
+	pointPool[1], pointPool[poolTop] = pointPool[poolTop], nil
+	poolTop = poolTop - 1
+	return point
+end
+
+local function returnToPool(point)
+	poolTop = poolTop + 1
+	pointPool[poolTop] = point
+end
+
+local function renderPoint(point, isLast)
+	if poolTop == 0 then
+		return
+	end
+
+	local rayDown = Ray.new(point + Vector3.new(0, 2, 0), Vector3.new(0, -8, 0))
+	local hitPart, hitPoint, hitNormal = workspace:FindPartOnRayWithIgnoreList(rayDown, { game.Players.LocalPlayer.Character, workspace.CurrentCamera  }) 	
+	if not hitPart then
+		return
+	end
+
+	local pointCFrame = CFrame.new(hitPoint, hitPoint + hitNormal)
+	
+	local point = retrieveFromPool()
+	point.CFrame = pointCFrame
+	point.Parent = pointModel
+	return point
+end
+
+function PathDisplay.setCurrentPoints(points)
+	if typeof(points) == 'table' then
+		currentPoints = points
+	else
+		currentPoints = {}
+	end
+end
+
+function PathDisplay.clearRenderedPath()
+	for _, oldPoint in ipairs(renderedPoints) do
+		oldPoint.Parent = nil
+		returnToPool(oldPoint)
+	end
+	renderedPoints = {}
+	pointModel.Parent = nil
+end
+
+function PathDisplay.renderPath()
+	PathDisplay.clearRenderedPath()
+	if not currentPoints or #currentPoints == 0 then
+		return
+	end
+
+	local currentIdx = #currentPoints
+	local lastPos = currentPoints[currentIdx]	
+	local distanceBudget = 0
+	
+	renderedPoints[1] = renderPoint(lastPos, true)
+	if not renderedPoints[1] then
+		return
+	end
+	
+	while true do
+		local currentPoint = currentPoints[currentIdx]
+		local nextPoint = currentPoints[currentIdx - 1]
+		
+		if currentIdx < 2 then
+			break
+		else
+			
+			local toNextPoint = nextPoint - currentPoint
+			local distToNextPoint = toNextPoint.magnitude	
+			
+			if distanceBudget > distToNextPoint then
+				distanceBudget = distanceBudget - distToNextPoint
+				currentIdx = currentIdx - 1
+			else
+				local dirToNextPoint = toNextPoint.unit
+				local pointPos = currentPoint + (dirToNextPoint * distanceBudget)
+				local point = renderPoint(pointPos, false)
+				
+				if point then
+					renderedPoints[#renderedPoints + 1] = point
+				end
+				
+				distanceBudget = distanceBudget + PathDisplay.spacing
+			end
+		end
+	end
+	
+	pointModel.Parent = workspace.CurrentCamera
+end
+
+return PathDisplay

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/TouchJump.lua

@@ -0,0 +1,203 @@
+--[[
+	// FileName: TouchJump
+	// Version 1.0
+	// Written by: jmargh
+	// Description: Implements jump controls for touch devices. Use with Thumbstick and Thumbpad
+--]]
+
+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 = require(script.Parent:WaitForChild("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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/TouchThumbstick.lua

@@ -0,0 +1,188 @@
+--[[
+	
+	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 = require(script.Parent:WaitForChild("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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/VRNavigation.lua

@@ -0,0 +1,456 @@
+
+--[[
+		VRNavigation
+--]]
+
+local VRService = game:GetService("VRService")
+local UserInputService = game:GetService("UserInputService")
+local RunService = game:GetService("RunService")
+local Players = game:GetService("Players")
+local PathfindingService = game:GetService("PathfindingService")
+local ContextActionService = game:GetService("ContextActionService")
+local StarterGui = game:GetService("StarterGui")
+
+--local MasterControl = require(script.Parent)
+local PathDisplay = nil
+local LocalPlayer = Players.LocalPlayer
+
+--[[ Constants ]]--
+local RECALCULATE_PATH_THRESHOLD = 4
+local NO_PATH_THRESHOLD = 12
+local MAX_PATHING_DISTANCE = 200
+local POINT_REACHED_THRESHOLD = 1
+local OFFTRACK_TIME_THRESHOLD = 2
+local THUMBSTICK_DEADZONE = 0.22
+
+local ZERO_VECTOR3 = Vector3.new(0,0,0)
+local XZ_VECTOR3 = Vector3.new(1,0,1)
+
+--[[ Utility Functions ]]--
+local function IsFinite(num)
+	return num == num and num ~= 1/0 and num ~= -1/0
+end
+
+local function IsFiniteVector3(vec3)
+	return IsFinite(vec3.x) and IsFinite(vec3.y) and IsFinite(vec3.z)
+end
+
+local movementUpdateEvent = Instance.new("BindableEvent")
+movementUpdateEvent.Name = "MovementUpdate"
+movementUpdateEvent.Parent = script
+
+coroutine.wrap(function()
+	local PathDisplayModule = script.Parent:WaitForChild("PathDisplay")
+	if PathDisplayModule then
+		PathDisplay = require(PathDisplayModule)
+	end
+end)()
+
+
+--[[ The Class ]]--
+local BaseCharacterController = require(script.Parent:WaitForChild("BaseCharacterController"))
+local VRNavigation = setmetatable({}, BaseCharacterController)
+VRNavigation.__index = VRNavigation
+
+function VRNavigation.new(CONTROL_ACTION_PRIORITY)
+	local self = setmetatable(BaseCharacterController.new(), VRNavigation)
+
+	self.CONTROL_ACTION_PRIORITY = CONTROL_ACTION_PRIORITY
+
+	self.navigationRequestedConn = nil
+	self.heartbeatConn = nil
+
+	self.currentDestination = nil
+	self.currentPath = nil
+	self.currentPoints = nil
+	self.currentPointIdx = 0
+
+	self.expectedTimeToNextPoint = 0
+	self.timeReachedLastPoint = tick()
+	self.moving = false
+
+	self.isJumpBound = false
+	self.moveLatch = false
+
+	self.userCFrameEnabledConn = nil
+
+	return self
+end
+
+function VRNavigation:SetLaserPointerMode(mode)
+	pcall(function()
+		StarterGui:SetCore("VRLaserPointerMode", mode)
+	end)
+end
+
+function VRNavigation:GetLocalHumanoid()
+	local character = LocalPlayer.Character
+	if not character then
+		return
+	end
+
+	for _, child in pairs(character:GetChildren()) do
+		if child:IsA("Humanoid") then
+			return child
+		end
+	end
+	return nil
+end
+
+function VRNavigation:HasBothHandControllers()
+	return VRService:GetUserCFrameEnabled(Enum.UserCFrame.RightHand) and VRService:GetUserCFrameEnabled(Enum.UserCFrame.LeftHand)
+end
+
+function VRNavigation:HasAnyHandControllers()
+	return VRService:GetUserCFrameEnabled(Enum.UserCFrame.RightHand) or VRService:GetUserCFrameEnabled(Enum.UserCFrame.LeftHand)
+end
+
+function VRNavigation:IsMobileVR()
+	return UserInputService.TouchEnabled
+end
+
+function VRNavigation:HasGamepad()
+	return UserInputService.GamepadEnabled
+end
+
+function VRNavigation:ShouldUseNavigationLaser()
+	--Places where we use the navigation laser:
+	-- mobile VR with any number of hands tracked
+	-- desktop VR with only one hand tracked
+	-- desktop VR with no hands and no gamepad (i.e. with Oculus remote?)
+	--using an Xbox controller with a desktop VR headset means no laser since the user has a thumbstick.
+	--in the future, we should query thumbstick presence with a features API
+	if self:IsMobileVR() then
+		return true
+	else
+		if self:HasBothHandControllers() then
+			return false
+		end
+		if not self:HasAnyHandControllers() then
+			return not self:HasGamepad()
+		end
+		return true
+	end
+end
+
+
+
+function VRNavigation:StartFollowingPath(newPath)
+	currentPath = newPath
+	currentPoints = currentPath:GetPointCoordinates()
+	currentPointIdx = 1
+	moving = true
+
+	timeReachedLastPoint = tick()
+
+	local humanoid = self:GetLocalHumanoid()
+	if humanoid and humanoid.Torso and #currentPoints >= 1 then
+		local dist = (currentPoints[1] - humanoid.Torso.Position).magnitude
+		expectedTimeToNextPoint = dist / humanoid.WalkSpeed
+	end
+
+	movementUpdateEvent:Fire("targetPoint", self.currentDestination)
+end
+
+function VRNavigation:GoToPoint(point)
+	currentPath = true
+	currentPoints = { point }
+	currentPointIdx = 1
+	moving = true
+
+	local humanoid = self:GetLocalHumanoid()
+	local distance = (humanoid.Torso.Position - point).magnitude
+	local estimatedTimeRemaining = distance / humanoid.WalkSpeed
+
+	timeReachedLastPoint = tick()
+	expectedTimeToNextPoint = estimatedTimeRemaining
+
+	movementUpdateEvent:Fire("targetPoint", point)
+end
+
+function VRNavigation:StopFollowingPath()
+	currentPath = nil
+	currentPoints = nil
+	currentPointIdx = 0
+	moving = false
+	self.moveVector = ZERO_VECTOR3
+end
+
+function VRNavigation:TryComputePath(startPos, destination)
+	local numAttempts = 0
+	local newPath = nil
+
+	while not newPath and numAttempts < 5 do
+		newPath = PathfindingService:ComputeSmoothPathAsync(startPos, destination, MAX_PATHING_DISTANCE)
+		numAttempts = numAttempts + 1
+
+		if newPath.Status == Enum.PathStatus.ClosestNoPath or newPath.Status == Enum.PathStatus.ClosestOutOfRange then
+			newPath = nil
+			break
+		end
+
+		if newPath and newPath.Status == Enum.PathStatus.FailStartNotEmpty then
+			startPos = startPos + (destination - startPos).unit
+			newPath = nil
+		end
+
+		if newPath and newPath.Status == Enum.PathStatus.FailFinishNotEmpty then
+			destination = destination + Vector3.new(0, 1, 0)
+			newPath = nil
+		end
+	end
+
+	return newPath
+end
+
+function VRNavigation:OnNavigationRequest(destinationCFrame, inputUserCFrame )
+	local destinationPosition = destinationCFrame.p
+	local lastDestination = self.currentDestination
+
+	if not IsFiniteVector3(destinationPosition) then
+		return
+	end
+
+	self.currentDestination = destinationPosition
+
+	local humanoid = self:GetLocalHumanoid()
+	if not humanoid or not humanoid.Torso then
+		return
+	end
+
+	local currentPosition = humanoid.Torso.Position
+	local distanceToDestination = (self.currentDestination - currentPosition).magnitude
+
+	if distanceToDestination < NO_PATH_THRESHOLD then
+		self:GoToPoint(self.currentDestination)
+		return
+	end
+
+	if not lastDestination or (self.currentDestination - lastDestination).magnitude > RECALCULATE_PATH_THRESHOLD then
+		local newPath = self:TryComputePath(currentPosition, self.currentDestination)
+		if newPath then
+			self:StartFollowingPath(newPath)
+			if PathDisplay then
+				PathDisplay.setCurrentPoints(self.currentPoints)
+				PathDisplay.renderPath()
+			end
+		else
+			self:StopFollowingPath()
+			if PathDisplay then
+				PathDisplay.clearRenderedPath()
+			end
+		end
+	else
+		if moving then
+			self.currentPoints[#currentPoints] = self.currentDestination
+		else
+			self:GoToPoint(self.currentDestination)
+		end
+	end
+end
+
+function VRNavigation:OnJumpAction(actionName, inputState, inputObj)
+	if inputState == Enum.UserInputState.Begin then
+		self.isJumping = true
+	end
+	return Enum.ContextActionResult.Sink
+end
+function VRNavigation:BindJumpAction(active)
+	if active then
+		if not self.isJumpBound then
+			self.isJumpBound = true
+			ContextActionService:BindActionAtPriority("VRJumpAction", (function() return self:OnJumpAction() end), false,
+				self.CONTROL_ACTION_PRIORITY, Enum.KeyCode.ButtonA)
+		end
+	else
+		if self.isJumpBound then
+			self.isJumpBound = false
+			ContextActionService:UnbindAction("VRJumpAction")
+		end
+	end
+end
+
+function VRNavigation:ControlCharacterGamepad(actionName, inputState, inputObject)
+	if inputObject.KeyCode ~= Enum.KeyCode.Thumbstick1 then return end
+
+	if inputState == Enum.UserInputState.Cancel then
+		self.moveVector =  ZERO_VECTOR3
+		return
+	end
+
+	if inputState ~= Enum.UserInputState.End then
+		self:StopFollowingPath()
+		if PathDisplay then
+			PathDisplay.clearRenderedPath()
+		end
+
+		if self:ShouldUseNavigationLaser() then
+			self:BindJumpAction(true)
+			self:SetLaserPointerMode("Hidden")
+		end
+
+		if inputObject.Position.magnitude > THUMBSTICK_DEADZONE then
+			self.moveVector = Vector3.new(inputObject.Position.X, 0, -inputObject.Position.Y)
+			if self.moveVector.magnitude > 0 then
+				self.moveVector = self.moveVector.unit * math.min(1, inputObject.Position.magnitude)
+			end
+
+			self.moveLatch = true
+		end
+	else
+		self.moveVector =  ZERO_VECTOR3
+
+		if self:ShouldUseNavigationLaser() then
+			self:BindJumpAction(false)
+			self:SetLaserPointerMode("Navigation")
+		end
+
+		if self.moveLatch then
+			self.moveLatch = false
+			movementUpdateEvent:Fire("offtrack")
+		end
+	end
+	return Enum.ContextActionResult.Sink
+end
+
+function VRNavigation:OnHeartbeat(dt)
+	local newMoveVector = self.moveVector
+	local humanoid = self:GetLocalHumanoid()
+	if not humanoid or not humanoid.Torso then
+		return
+	end
+
+	if self.moving and self.currentPoints then
+		local currentPosition = humanoid.Torso.Position
+		local goalPosition = currentPoints[1]
+		local vectorToGoal = (goalPosition - currentPosition) * XZ_VECTOR3
+		local moveDist = vectorToGoal.magnitude
+		local moveDir = vectorToGoal / moveDist
+
+		if moveDist < POINT_REACHED_THRESHOLD then
+			local estimatedTimeRemaining = 0
+			local prevPoint = currentPoints[1]
+			for i, point in pairs(currentPoints) do
+				if i ~= 1 then
+					local dist = (point - prevPoint).magnitude
+					prevPoint = point
+					estimatedTimeRemaining = estimatedTimeRemaining + (dist / humanoid.WalkSpeed)
+				end
+			end
+
+			table.remove(currentPoints, 1)
+			currentPointIdx = currentPointIdx + 1
+
+			if #currentPoints == 0 then
+				self:StopFollowingPath()
+				if PathDisplay then
+					PathDisplay.clearRenderedPath()
+				end
+				return
+			else
+				if PathDisplay then
+					PathDisplay.setCurrentPoints(currentPoints)
+					PathDisplay.renderPath()
+				end
+
+				local newGoal = currentPoints[1]
+				local distanceToGoal = (newGoal - currentPosition).magnitude
+				expectedTimeToNextPoint = distanceToGoal / humanoid.WalkSpeed
+				timeReachedLastPoint = tick()
+			end
+		else
+			local ignoreTable = {
+				game.Players.LocalPlayer.Character,
+				workspace.CurrentCamera
+			}
+			local obstructRay = Ray.new(currentPosition - Vector3.new(0, 1, 0), moveDir * 3)
+			local obstructPart, obstructPoint, obstructNormal = workspace:FindPartOnRayWithIgnoreList(obstructRay, ignoreTable)
+
+			if obstructPart then
+				local heightOffset = Vector3.new(0, 100, 0)
+				local jumpCheckRay = Ray.new(obstructPoint + moveDir * 0.5 + heightOffset, -heightOffset)
+				local jumpCheckPart, jumpCheckPoint, jumpCheckNormal = workspace:FindPartOnRayWithIgnoreList(jumpCheckRay, ignoreTable)
+
+				local heightDifference = jumpCheckPoint.Y - currentPosition.Y
+				if heightDifference < 6 and heightDifference > -2 then
+					humanoid.Jump = true
+				end
+			end
+
+			local timeSinceLastPoint = tick() - timeReachedLastPoint
+			if timeSinceLastPoint > expectedTimeToNextPoint + OFFTRACK_TIME_THRESHOLD then
+				self:StopFollowingPath()
+				if PathDisplay then
+					PathDisplay.clearRenderedPath()
+				end
+
+				movementUpdateEvent:Fire("offtrack")
+			end
+
+			newMoveVector = self.moveVector:Lerp(moveDir, dt * 10)
+		end
+	end
+
+	if IsFiniteVector3(newMoveVector) then
+		self.moveVector = newMoveVector
+	end
+end
+
+
+function VRNavigation:OnUserCFrameEnabled()
+	if self:ShouldUseNavigationLaser() then
+		self:BindJumpAction(false)
+		self:SetLaserPointerMode("Navigation")
+	else
+		self:BindJumpAction(true)
+		self:SetLaserPointerMode("Hidden")
+	end
+end
+
+function VRNavigation:Enable(enable)
+
+	self.moveVector = ZERO_VECTOR3
+	self.isJumping = false
+
+	if enable then
+		self.navigationRequestedConn = VRService.NavigationRequested:Connect(function(destinationCFrame, inputUserCFrame) self:OnNavigationRequest(destinationCFrame, inputUserCFrame) end)
+		self.heartbeatConn = RunService.Heartbeat:Connect(function(dt) self:OnHeartbeat(dt) end)
+
+		ContextActionService:BindAction("MoveThumbstick", (function(actionName, inputState, inputObject) return self:ControlCharacterGamepad(actionName, inputState, inputObject) end),
+			false, self.CONTROL_ACTION_PRIORITY, Enum.KeyCode.Thumbstick1)
+		ContextActionService:BindActivate(Enum.UserInputType.Gamepad1, Enum.KeyCode.ButtonR2)
+
+		self.userCFrameEnabledConn = VRService.UserCFrameEnabled:Connect(function() self:OnUserCFrameEnabled() end)
+		self:OnUserCFrameEnabled()
+
+		VRService:SetTouchpadMode(Enum.VRTouchpad.Left, Enum.VRTouchpadMode.VirtualThumbstick)
+		VRService:SetTouchpadMode(Enum.VRTouchpad.Right, Enum.VRTouchpadMode.ABXY)
+
+		self.enabled = true
+	else
+		-- Disable
+		self:StopFollowingPath()
+
+		ContextActionService:UnbindAction("MoveThumbstick")
+		ContextActionService:UnbindActivate(Enum.UserInputType.Gamepad1, Enum.KeyCode.ButtonR2)
+
+		self:BindJumpAction(false)
+		self:SetLaserPointerMode("Disabled")
+
+		if self.navigationRequestedConn then
+			self.navigationRequestedConn:Disconnect()
+			self.navigationRequestedConn = nil
+		end
+		if self.heartbeatConn then
+			self.heartbeatConn:Disconnect()
+			self.heartbeatConn = nil
+		end
+		if self.userCFrameEnabledConn then
+			self.userCFrameEnabledConn:Disconnect()
+			self.userCFrameEnabledConn = nil
+		end
+		self.enabled = false
+	end
+end
+
+return VRNavigation

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/VehicleController.lua

@@ -0,0 +1,188 @@
+--[[
+	// FileName: VehicleControl
+	// Version 1.0
+	// Written by: jmargh
+	// Description: Implements in-game vehicle controls for all input devices
+
+	// NOTE: This works for basic vehicles (single vehicle seat). If you use custom VehicleSeat code,
+	// multiple VehicleSeats or your own implementation of a VehicleSeat this will not work.
+--]]
+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

RCCService2020/ExtraContent/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerScriptsLoader.lua

@@ -0,0 +1,7 @@
+--[[
+	PlayerScriptsLoader - This script requires and instantiates the PlayerModule singleton
+
+	2018 PlayerScripts Update - AllYourBlox
+--]]
+
+require(script.Parent:WaitForChild("PlayerModule"))