add gs

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"))