add gs

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module.lua

@@ -0,0 +1,27 @@
+--[[
+	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
+
+return PlayerModule.new()

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule.lua

@@ -0,0 +1,548 @@
+--[[
+	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
+
+-- 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 StarterPlayer = game:GetService("StarterPlayer")
+local UserGameSettings = UserSettings():GetService("UserGameSettings")
+
+-- Camera math utility library
+local CameraUtils = require(script:WaitForChild("CameraUtils"))
+
+-- 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 do
+	local success, useNewPoppercam = pcall(UserSettings().IsUserFeatureEnabled, UserSettings(), "UserNewPoppercam")
+	if success and useNewPoppercam then
+		Poppercam = require(script:WaitForChild("Poppercam"))
+	else
+		Poppercam = require(script:WaitForChild("Poppercam_Classic"))
+	end
+end
+
+-- 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")
+	local canRegisterCameras = pcall(function() PlayerScripts:RegisterTouchCameraMovementMode(Enum.TouchCameraMovementMode.Default) end)
+	if canRegisterCameras then
+		PlayerScripts:RegisterTouchCameraMovementMode(Enum.TouchCameraMovementMode.Follow)
+		PlayerScripts:RegisterTouchCameraMovementMode(Enum.TouchCameraMovementMode.Classic)
+
+		PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.Default)
+		PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.Follow)
+		PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.Classic)
+	end
+end
+
+
+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
+	
+	
+	self:OnPlayerAdded(Players.LocalPlayer)
+
+	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 = nil 
+	self.hasLastInput = pcall(function()
+		self.lastInputType = UserInputService:GetLastInputType()
+		UserInputService.LastInputTypeChanged:Connect(function(newLastInputType) 
+			self.lastInputType = newLastInputType
+		end)
+	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 = nil
+	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
+			-- Poppercam and any others that get added in the future and need the full player list for 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 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 = nil
+	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)
+	local newCameraCFrame = nil
+	local newCameraFocus = nil
+	
+	if self.activeCameraController then
+		newCameraCFrame, newCameraFocus = self.activeCameraController:Update(dt)
+		self.activeCameraController:ApplyVRTransform()
+	else
+		newCameraCFrame = game.Workspace.CurrentCamera.CFrame
+		newCameraFocus = game.Workspace.CurrentCamera.Focus
+	end
+	
+	if self.activeOcclusionModule then
+		newCameraCFrame, newCameraFocus = self.activeOcclusionModule:Update(dt, newCameraCFrame, newCameraFocus)
+	end
+	
+	-- Here is where the new CFrame and Focus are set for this render frame
+	game.Workspace.CurrentCamera.CFrame = newCameraCFrame
+	game.Workspace.CurrentCamera.Focus = newCameraFocus
+	
+	-- Update to character local transparency as needed based on camera-to-subject distance
+	if self.activeTransparencyController then
+		self.activeTransparencyController:Update()
+	end
+end
+
+-- 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.hasLastInput and 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
+
+
+
+return CameraModule.new()

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/BaseOcclusion.lua

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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/CameraUtils.lua

@@ -0,0 +1,125 @@
+--[[
+	CameraUtils - Math utility functions shared by multiple camera scripts
+	2018 Camera Update - AllYourBlox		
+--]]
+
+local CameraUtils = {}
+
+local function round(num)
+	return math.floor(num + 0.5)
+end
+
+-- Note, arguments do not match the new math.clamp
+-- Eventually we will replace these calls with math.clamp, but right now
+-- this is safer as math.clamp is not tolerant of min>max
+function CameraUtils.Clamp(low, high, val)
+	return math.min(math.max(val, low), high)
+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 = CameraUtils.Clamp(-1,1,t)
+	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 CameraUtils.Clamp(-1, 1, point)
+	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
+	
+	-- 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
+

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/ClassicCamera.lua

@@ -0,0 +1,240 @@
+--[[
+	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.0 		--Seconds, used when auto-aligning camera with vehicles
+local PORTRAIT_OFFSET = Vector3.new(0,-3,0)
+
+--[[ Services ]]--
+local PlayersService = game:GetService('Players')
+local VRService = game:GetService("VRService")
+
+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.lastUpdate = tick()
+
+	return self
+end
+
+function ClassicCamera:GetModuleName()
+	return "ClassicCamera"
+end
+
+-- Movement mode standardized to Enum.ComputerCameraMovementMode values
+function ClassicCamera:SetCameraMovementMode( cameraMovementMode )
+	BaseCamera.SetCameraMovementMode(self,cameraMovementMode)
+	self.isFollowCamera = cameraMovementMode == Enum.ComputerCameraMovementMode.Follow
+end
+
+function ClassicCamera:Test()
+	print("ClassicCamera:Test()")
+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 player = PlayersService.LocalPlayer
+	local humanoid = self:GetHumanoid()
+	local cameraSubject = camera.CameraSubject
+	local isInVehicle = cameraSubject and cameraSubject:IsA('VehicleSeat')
+	local isOnASkateboard = cameraSubject and cameraSubject:IsA('SkateboardPlatform')
+	local isClimbing = humanoid and humanoid:GetState() == Enum.HumanoidStateType.Climbing
+
+	if self.lastUpdate == nil or timeDelta > 1 then
+		self.lastCameraTransform = nil
+	end
+
+	if self.lastUpdate then
+		local gamepadRotation = self:UpdateGamepad()
+
+		if self:ShouldUseVRRotation() then
+			self.rotateInput = self.rotateInput + self:GetVRRotationInput()
+		else
+			-- Cap out the delta to 0.1 so we don't get some crazy things when we re-resume from
+			local delta = math.min(0.1, timeDelta)
+
+			if gamepadRotation ~= ZERO_VECTOR2 then
+				self.rotateInput = self.rotateInput + (gamepadRotation * delta)
+			end
+
+			local angle = 0
+			if not (isInVehicle or isOnASkateboard) then
+				angle = angle + (self.turningLeft and -120 or 0)
+				angle = angle + (self.turningRight and 120 or 0)
+			end
+
+			if angle ~= 0 then
+				self.rotateInput = self.rotateInput +  Vector2.new(math.rad(angle * delta), 0)
+			end
+		end
+	end
+
+	-- Reset tween speed if user is panning
+	if self.userPanningTheCamera then
+		tweenSpeed = 0
+		self.lastUserPanCamera = tick()
+	end
+
+	local userRecentlyPannedCamera = now - self.lastUserPanCamera < TIME_BEFORE_AUTO_ROTATE
+	local subjectPosition = self:GetSubjectPosition()
+
+	if subjectPosition and player and camera then
+		local zoom = self:GetCameraToSubjectDistance()
+		if zoom < 0.5 then
+			zoom = 0.5
+		end
+
+		if self:GetIsMouseLocked() and not self:IsInFirstPerson() then
+			-- We need to use the right vector of the camera after rotation, not before
+			local newLookCFrame = self:CalculateNewLookCFrame()
+
+			local offset = self:GetMouseLockOffset()
+			local cameraRelativeOffset = offset.X * newLookCFrame.rightVector + offset.Y * newLookCFrame.upVector + offset.Z * newLookCFrame.lookVector
+
+			--offset can be NAN, NAN, NAN if newLookVector has only y component
+			if Util.IsFiniteVector3(cameraRelativeOffset) then
+				subjectPosition = subjectPosition + cameraRelativeOffset
+			end
+		else
+			if not self.userPanningTheCamera and self.lastCameraTransform then
+
+				local isInFirstPerson = self:IsInFirstPerson()
+
+				if (isInVehicle or isOnASkateboard or (self.isFollowCamera and isClimbing)) and self.lastUpdate and humanoid and humanoid.Torso then
+					if isInFirstPerson then
+						if self.lastSubjectCFrame and (isInVehicle or isOnASkateboard) and cameraSubject:IsA('BasePart') then
+							local y = -Util.GetAngleBetweenXZVectors(self.lastSubjectCFrame.lookVector, cameraSubject.CFrame.lookVector)
+							if Util.IsFinite(y) then
+								self.rotateInput = self.rotateInput + Vector2.new(y, 0)
+							end
+							tweenSpeed = 0
+						end
+					elseif not userRecentlyPannedCamera then
+						local forwardVector = humanoid.Torso.CFrame.lookVector
+						if isOnASkateboard then
+							forwardVector = cameraSubject.CFrame.lookVector
+						end
+
+						tweenSpeed = Util.Clamp(0, tweenMaxSpeed, tweenSpeed + tweenAcceleration * timeDelta)
+
+						local percent = Util.Clamp(0, 1, tweenSpeed * timeDelta)
+						if self:IsInFirstPerson() and not (self.isFollowCamera and self.isClimbing) then
+							percent = 1
+						end
+
+						local y = Util.GetAngleBetweenXZVectors(forwardVector, self:GetCameraLookVector())
+						if Util.IsFinite(y) and math.abs(y) > 0.0001 then
+							self.rotateInput = self.rotateInput + Vector2.new(y * percent, 0)
+						end
+					end
+
+				elseif self.isFollowCamera and (not (isInFirstPerson or userRecentlyPannedCamera) and not VRService.VREnabled) then
+					-- Logic that was unique to the old FollowCamera module
+					local lastVec = -(self.lastCameraTransform.p - subjectPosition)
+
+					local y = Util.GetAngleBetweenXZVectors(lastVec, self:GetCameraLookVector())
+
+					-- This cutoff is to decide if the humanoid's angle of movement,
+					-- relative to the camera's look vector, is enough that
+					-- we want the camera to be following them. The point is to provide
+					-- a sizable dead zone to allow more precise forward movements.
+					local thetaCutoff = 0.4
+
+					-- Check for NaNs
+					if Util.IsFinite(y) and math.abs(y) > 0.0001 and math.abs(y) > thetaCutoff * timeDelta then
+						self.rotateInput = self.rotateInput + Vector2.new(y, 0)
+					end
+				end
+			end
+		end
+
+		if not self.isFollowCamera then
+			local VREnabled = VRService.VREnabled
+			newCameraFocus = VREnabled and self:GetVRFocus(subjectPosition, timeDelta) or CFrame.new(subjectPosition)
+
+			local cameraFocusP = newCameraFocus.p
+			if VREnabled and not self:IsInFirstPerson() then
+				local cameraHeight = self:GetCameraHeight()
+				local vecToSubject = (subjectPosition - camera.CFrame.p)
+				local distToSubject = vecToSubject.magnitude
+
+				-- Only move the camera if it exceeded a maximum distance to the subject in VR
+				if distToSubject > zoom or self.rotateInput.x ~= 0 then
+					local desiredDist = math.min(distToSubject, zoom)
+					vecToSubject = self:CalculateNewLookVectorVR() * desiredDist
+					local newPos = cameraFocusP - vecToSubject
+					local desiredLookDir = camera.CFrame.lookVector
+					if self.rotateInput.x ~= 0 then
+						desiredLookDir = vecToSubject
+					end
+					local lookAt = Vector3.new(newPos.x + desiredLookDir.x, newPos.y, newPos.z + desiredLookDir.z)
+					self.rotateInput = ZERO_VECTOR2
+
+					newCameraCFrame = CFrame.new(newPos, lookAt) + Vector3.new(0, cameraHeight, 0)
+				end
+			else
+				local newLookVector = self:CalculateNewLookVector()
+				self.rotateInput = ZERO_VECTOR2
+				newCameraCFrame = CFrame.new(cameraFocusP - (zoom * newLookVector), cameraFocusP)
+			end
+		else -- is FollowCamera
+			local newLookVector = self:CalculateNewLookVector()
+			self.rotateInput = ZERO_VECTOR2
+
+			if VRService.VREnabled then
+				newCameraFocus = self:GetVRFocus(subjectPosition, timeDelta)
+			elseif self.portraitMode then
+				newCameraFocus = CFrame.new(subjectPosition + PORTRAIT_OFFSET)
+			else
+				newCameraFocus = CFrame.new(subjectPosition)
+			end
+			newCameraCFrame = CFrame.new(newCameraFocus.p - (zoom * newLookVector), newCameraFocus.p) + Vector3.new(0, self:GetCameraHeight(), 0)
+		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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Invisicam.lua

@@ -0,0 +1,560 @@
+--[[
+	Invisicam - Occlusion module that makes objects occluding character view semi-transparent
+	2018 Camera Update - AllYourBlox		
+--]]
+
+--[[ Camera Maths Utilities Library ]]--
+local Util = require(script.Parent:WaitForChild("CameraUtils"))
+
+--[[ Top Level Roblox Services ]]--
+local PlayersService = game:GetService("Players")
+local RunService = game:GetService("RunService")
+
+--[[ 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 = nil
+	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 d0 = v0.magnitude
+			
+			local perp = (v0:Cross(vp)).unit
+
+			-- Vector from the offset hit point, along the hit surface
+			local v1 = (perp:Cross(hitNormal)).unit
+			
+			-- Vector from camera to offset hit
+			local vprime = (hprime - 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 modeName, 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 partIsTouchingCamera = {}
+	
+	local perPartTransparencyHeadTorsoHits = TARGET_TRANSPARENCY
+	local perPartTransparencyOtherHits = TARGET_TRANSPARENCY
+	
+	if USE_STACKING_TRANSPARENCY then
+	
+		-- This first call uses head and torso rays to find out how many parts are stacked up
+		-- for the purpose of calculating required per-part transparency
+		local headPoint = 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

RCCService2018/content/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 private variables and constants
+local UNIT_X = Vector3.new(1,0,0)
+local UNIT_Y = Vector3.new(0,1,0)
+local UNIT_Z = Vector3.new(0,0,1)
+local 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 VR_PITCH_FRACTION = 0.25
+local tweenAcceleration = math.rad(220)		--Radians/Second^2
+local tweenSpeed = math.rad(0)				--Radians/Second
+local tweenMaxSpeed = math.rad(250)			--Radians/Second
+local TIME_BEFORE_AUTO_ROTATE = 2.0 		--Seconds, used when auto-aligning camera with vehicles
+local PORTRAIT_OFFSET = Vector3.new(0,-3,0)
+
+local Util = require(script.Parent:WaitForChild("CameraUtils"))
+
+--[[ Services ]]--
+local PlayersService = game:GetService('Players')
+local VRService = game:GetService("VRService")
+
+--[[ 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
+
+function LegacyCamera:Test()
+	print("LegacyCamera:Test()")
+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
+	local humanoid = self:GetHumanoid()
+	local cameraSubject = camera and 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.lastDistanceToSubject = nil
+	end
+	local subjectPosition = self:GetSubjectPosition()	
+	
+	if self.cameraType == Enum.CameraType.Fixed then
+		if self.lastUpdate then
+			-- Cap out the delta to 0.1 so we don't get some crazy things when we re-resume from
+			local delta = math.min(0.1, now - self.lastUpdate)
+			local gamepadRotation = self:UpdateGamepad()		
+			self.rotateInput = self.rotateInput + (gamepadRotation * delta)
+		end		
+		
+		if subjectPosition and player and camera then
+			local distanceToSubject = self:GetCameraToSubjectDistance()
+			local newLookVector = self:CalculateNewLookVector()
+			self.rotateInput = ZERO_VECTOR2
+			
+			newCameraFocus = camera.Focus -- Fixed camera does not change focus
+			newCameraCFrame = CFrame.new(camera.CFrame.p, camera.CFrame.p + (distanceToSubject * newLookVector))
+		end
+	elseif self.cameraType == Enum.CameraType.Attach then
+		if subjectPosition and camera then
+			local distanceToSubject = self:GetCameraToSubjectDistance()
+			local humanoid = self:GetHumanoid()
+			if self.lastUpdate and humanoid and humanoid.RootPart then
+				
+				-- Cap out the delta to 0.1 so we don't get some crazy things when we re-resume from
+				local delta = math.min(0.1, now - self.lastUpdate)
+				local gamepadRotation = self:UpdateGamepad()
+				self.rotateInput = self.rotateInput + (gamepadRotation * delta)		
+				
+				local forwardVector = humanoid.RootPart.CFrame.lookVector
+
+				local y = Util.GetAngleBetweenXZVectors(forwardVector, self:GetCameraLookVector())
+				if Util.IsFinite(y) then
+					-- Preserve vertical rotation from user input
+					self.rotateInput = Vector2.new(y, self.rotateInput.Y)
+				end
+			end
+
+			local newLookVector = self:CalculateNewLookVector()
+			self.rotateInput = ZERO_VECTOR2
+
+			newCameraFocus = CFrame.new(subjectPosition)
+			newCameraCFrame = CFrame.new(subjectPosition - (distanceToSubject * newLookVector), subjectPosition)
+		end
+	elseif self.cameraType == Enum.CameraType.Watch then
+		if subjectPosition and player and camera then
+			local cameraLook = nil
+
+			local humanoid = self:GetHumanoid()
+			if humanoid and humanoid.RootPart then
+				local diffVector = subjectPosition - camera.CFrame.p
+				cameraLook = diffVector.unit
+
+				if self.lastDistanceToSubject and self.lastDistanceToSubject == self:GetCameraToSubjectDistance() then
+					-- Don't clobber the zoom if they zoomed the camera
+					local newDistanceToSubject = diffVector.magnitude
+					self:SetCameraToSubjectDistance(newDistanceToSubject)
+				end
+			end
+			
+			local distanceToSubject = self:GetCameraToSubjectDistance()
+			local newLookVector = self:CalculateNewLookVector(cameraLook)
+			self.rotateInput = ZERO_VECTOR2
+			
+			newCameraFocus = CFrame.new(subjectPosition)
+			newCameraCFrame = CFrame.new(subjectPosition - (distanceToSubject * newLookVector), subjectPosition)
+
+			self.lastDistanceToSubject = distanceToSubject
+		end
+	else
+		-- Unsupported type, return current values unchanged
+		return camera.CFrame, camera.Focus
+	end
+	
+	self.lastUpdate = now
+	return newCameraCFrame, newCameraFocus
+end
+
+return LegacyCamera

RCCService2018/content/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 Util = require(script.Parent:WaitForChild("CameraUtils"))
+
+--[[ Services ]]--
+local PlayersService = game:GetService("Players")
+local UserInputService = game:GetService("UserInputService")
+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.inputBeganConn = nil
+	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 keyCode, keyEnum in pairs(Enum.KeyCode:GetEnumItems()) do
+			if token == keyEnum.Name then
+				self.boundKeys[#self.boundKeys+1] = keyEnum
+				break
+			end
+		end
+	end
+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:OnInputBegan(input, processed)
+	if processed then return end
+	
+	if input.UserInputType == Enum.UserInputType.Keyboard then
+		for _, keyCode in pairs(self.boundKeys) do
+			if keyCode == input.KeyCode then
+				self:OnMouseLockToggled()
+				return
+			end
+		end
+	end
+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
+			if self.inputBeganConn then
+				self.inputBeganConn:Disconnect()
+			end
+			self.inputBeganConn = UserInputService.InputBegan:Connect(function(input, processed)
+				self:OnInputBegan(input, processed)
+			end)
+		else
+			-- Disabling
+			-- Restore mouse cursor
+			if Mouse.Icon~="" then
+				Mouse.Icon = ""
+			end
+			if self.inputBeganConn then
+				self.inputBeganConn:Disconnect()
+			end
+			self.inputBeganConn = nil
+
+			-- 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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/OrbitalCamera.lua

@@ -0,0 +1,417 @@
+--[[
+	OrbitalCamera - Spherical coordinates control camera for top-down games
+	2018 Camera Update - AllYourBlox		
+--]]
+
+-- Local private variables and constants
+local UNIT_X = Vector3.new(1,0,0)
+local UNIT_Y = Vector3.new(0,1,0)
+local UNIT_Z = Vector3.new(0,0,1)
+local 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
+
+local VR_PITCH_FRACTION = 0.25
+local tweenAcceleration = math.rad(220)		--Radians/Second^2
+local tweenSpeed = math.rad(0)				--Radians/Second
+local tweenMaxSpeed = math.rad(250)			--Radians/Second
+local TIME_BEFORE_AUTO_ROTATE = 2.0 		--Seconds, used when auto-aligning camera with vehicles
+local PORTRAIT_OFFSET = Vector3.new(0,-3,0)
+
+--[[ 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"))
+
+--[[ Services ]]--
+local PlayersService = game:GetService('Players')
+local VRService = game:GetService("VRService")
+
+--[[ Utility functions specific to OrbitalCamera ]]--
+local function GetValueObject(name, defaultValue)
+	local valueObj = script:FindFirstChild(name)
+	if valueObj then
+		return valueObj.Value
+	end
+	return defaultValue
+end
+
+--[[ 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
+		print("externalProperties table has no entry for ",name)
+		return
+	end
+	
+	if updateFunction then
+		if self.changedSignalConnections[name] then
+			self.changedSignalConnections[name]:Disconnect()
+		end
+		self.changedSignalConnections[name] = valueObj.Changed:Connect(function(newValue)
+			self.externalProperties[name] = newValue
+			updateFunction(self)
+		end)
+	end
+end
+
+function OrbitalCamera:SetAndBoundsCheckAzimuthValues()
+	self.minAzimuthAbsoluteRad = math.rad(self.externalProperties["ReferenceAzimuth"]) - math.abs(math.rad(self.externalProperties["CWAzimuthTravel"]))
+	self.maxAzimuthAbsoluteRad = math.rad(self.externalProperties["ReferenceAzimuth"]) + math.abs(math.rad(self.externalProperties["CCWAzimuthTravel"]))
+	self.useAzimuthLimits = self.externalProperties["UseAzimuthLimits"]
+	if self.useAzimuthLimits then
+		self.curAzimuthRad = math.max(self.curAzimuthRad, self.minAzimuthAbsoluteRad)
+		self.curAzimuthRad = math.min(self.curAzimuthRad, self.maxAzimuthAbsoluteRad)
+	end
+end
+
+function OrbitalCamera:SetAndBoundsCheckElevationValues()
+	-- These degree values are the direct user input values. It is deliberate that they are
+	-- ranged checked only against the extremes, and not against each other. Any time one
+	-- is changed, both of the internal values in radians are recalculated. This allows for
+	-- A developer to change the values in any order and for the end results to be that the
+	-- internal values adjust to match intent as best as possible.
+	local minElevationDeg = math.max(self.externalProperties["MinElevation"], MIN_ALLOWED_ELEVATION_DEG)
+	local maxElevationDeg = math.min(self.externalProperties["MaxElevation"], MAX_ALLOWED_ELEVATION_DEG)
+	
+	-- Set internal values in radians
+	self.minElevationRad = math.rad(math.min(minElevationDeg, maxElevationDeg))
+	self.maxElevationRad = math.rad(math.max(minElevationDeg, maxElevationDeg))
+	self.curElevationRad = math.max(self.curElevationRad, self.minElevationRad)
+	self.curElevationRad = math.min(self.curElevationRad, self.maxElevationRad)
+end
+
+function OrbitalCamera:SetAndBoundsCheckDistanceValues()
+	self.minDistance = self.externalProperties["MinDistance"]
+	self.maxDistance = self.externalProperties["MaxDistance"]
+	self.curDistance = math.max(self.curDistance, self.minDistance)
+	self.curDistance = math.min(self.curDistance, self.maxDistance)
+end
+
+-- This loads from, or lazily creates, NumberValue objects for exposed parameters
+function OrbitalCamera:LoadNumberValueParameters()
+	-- These initial values do not require change listeners since they are read only once
+	self:LoadOrCreateNumberValueParameter("InitialElevation", "NumberValue", nil)
+	self:LoadOrCreateNumberValueParameter("InitialDistance", "NumberValue", nil)
+	
+	-- Note: ReferenceAzimuth is also used as an initial value, but needs a change listener because it is used in the calculation of the limits
+	self:LoadOrCreateNumberValueParameter("ReferenceAzimuth", "NumberValue", self.SetAndBoundsCheckAzimuthValue)
+	self:LoadOrCreateNumberValueParameter("CWAzimuthTravel", "NumberValue", self.SetAndBoundsCheckAzimuthValues)
+	self:LoadOrCreateNumberValueParameter("CCWAzimuthTravel", "NumberValue", self.SetAndBoundsCheckAzimuthValues)
+	self:LoadOrCreateNumberValueParameter("MinElevation", "NumberValue", self.SetAndBoundsCheckElevationValues)
+	self:LoadOrCreateNumberValueParameter("MaxElevation", "NumberValue", self.SetAndBoundsCheckElevationValues)
+	self:LoadOrCreateNumberValueParameter("MinDistance", "NumberValue", self.SetAndBoundsCheckDistanceValues)
+	self:LoadOrCreateNumberValueParameter("MaxDistance", "NumberValue", self.SetAndBoundsCheckDistanceValues)
+	self:LoadOrCreateNumberValueParameter("UseAzimuthLimits", "BoolValue", self.SetAndBoundsCheckAzimuthValues)
+	
+	-- Internal values set (in radians, from degrees), plus sanitization
+	self.curAzimuthRad = math.rad(self.externalProperties["ReferenceAzimuth"])
+	self.curElevationRad = math.rad(self.externalProperties["InitialElevation"])
+	self.curDistance = self.externalProperties["InitialDistance"]
+	
+	self:SetAndBoundsCheckAzimuthValues()
+	self:SetAndBoundsCheckElevationValues()
+	self:SetAndBoundsCheckDistanceValues()
+end
+
+function OrbitalCamera:GetModuleName()
+	return "OrbitalCamera"
+end
+
+function OrbitalCamera:SetInitialOrientation(humanoid)
+	if not humanoid or not humanoid.RootPart then
+		warn("OrbitalCamera could not set initial orientation due to missing humanoid")
+		return
+	end
+	local newDesiredLook = (humanoid.RootPart.CFrame.lookVector - Vector3.new(0,0.23,0)).unit
+	local horizontalShift = Util.GetAngleBetweenXZVectors(newDesiredLook, self:GetCameraLookVector())
+	local vertShift = math.asin(self:GetCameraLookVector().y) - math.asin(newDesiredLook.y)
+	if not Util.IsFinite(horizontalShift) then
+		horizontalShift = 0
+	end
+	if not Util.IsFinite(vertShift) then
+		vertShift = 0
+	end
+	self.rotateInput = Vector2.new(horizontalShift, vertShift)
+end
+
+--[[ Functions of BaseCamera that are overridden by OrbitalCamera ]]--
+function OrbitalCamera:GetCameraToSubjectDistance()
+	return self.curDistance
+end
+	
+function OrbitalCamera:SetCameraToSubjectDistance(desiredSubjectDistance)
+	print("OrbitalCamera SetCameraToSubjectDistance ",desiredSubjectDistance)
+	local player = PlayersService.LocalPlayer
+	if player then
+		self.currentSubjectDistance = Util.Clamp(self.minDistance, self.maxDistance, desiredSubjectDistance)
+		
+		-- 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 = Util.Clamp(currPitchAngle - math.rad(MAX_ALLOWED_ELEVATION_DEG), currPitchAngle - math.rad(MIN_ALLOWED_ELEVATION_DEG), xyRotateVector.y)
+	local constrainedRotateInput = Vector2.new(xyRotateVector.x, yTheta)	
+	local startCFrame = CFrame.new(ZERO_VECTOR3, currLookVector)
+	local newLookVector = (CFrame.Angles(0, -constrainedRotateInput.x, 0) * startCFrame * CFrame.Angles(-constrainedRotateInput.y,0,0)).lookVector	
+	return newLookVector
+end
+
+function OrbitalCamera:GetGamepadPan(name, state, input)
+	if input.UserInputType == self.activeGamepad and input.KeyCode == Enum.KeyCode.Thumbstick2 then
+		if self.r3ButtonDown or self.l3ButtonDown then
+		-- R3 or L3 Thumbstick is depressed, right stick controls dolly in/out
+			if (input.Position.Y > THUMBSTICK_DEADZONE) then
+				self.gamepadDollySpeedMultiplier = 0.96
+			elseif (input.Position.Y < -THUMBSTICK_DEADZONE) then
+				self.gamepadDollySpeedMultiplier = 1.04
+			else 
+				self.gamepadDollySpeedMultiplier = 1.00
+			end
+		else
+			if state == Enum.UserInputState.Cancel then
+				self.gamepadPanningCamera = ZERO_VECTOR2
+				return
+			end		
+			
+			local inputVector = Vector2.new(input.Position.X, -input.Position.Y)
+			if inputVector.magnitude > THUMBSTICK_DEADZONE then
+				self.gamepadPanningCamera = Vector2.new(input.Position.X, -input.Position.Y)
+			else
+				self.gamepadPanningCamera = ZERO_VECTOR2
+			end
+		end
+	end
+end
+
+function OrbitalCamera:DoGamepadZoom(name, state, input)
+	if input.UserInputType == self.activeGamepad and (input.KeyCode == Enum.KeyCode.ButtonR3 or input.KeyCode == Enum.KeyCode.ButtonL3) then
+		if (state == Enum.UserInputState.Begin) then
+			self.r3ButtonDown = input.KeyCode == Enum.KeyCode.ButtonR3
+			self.l3ButtonDown = input.KeyCode == Enum.KeyCode.ButtonL3
+		elseif (state == Enum.UserInputState.End) then
+			if (input.KeyCode == Enum.KeyCode.ButtonR3) then
+				self.r3ButtonDown = false
+			elseif (input.KeyCode == Enum.KeyCode.ButtonL3) then
+				self.l3ButtonDown = false
+			end
+			if (not self.r3ButtonDown) and (not self.l3ButtonDown) then
+				self.gamepadDollySpeedMultiplier = 1.00
+			end
+		end
+	end
+end
+
+function OrbitalCamera:BindGamepadInputActions()
+	local ContextActionService = game:GetService('ContextActionService')
+	
+	ContextActionService:BindAction("OrbitalCamGamepadPan", function(name, state, input) self:GetGamepadPan(name, state, input) end, false, Enum.KeyCode.Thumbstick2)	
+	ContextActionService:BindAction("OrbitalCamGamepadZoom", function(name, state, input) self:DoGamepadZoom(name, state, input) end, false, Enum.KeyCode.ButtonR3)
+	ContextActionService:BindAction("OrbitalCamGamepadZoomAlt", function(name, state, input) self:DoGamepadZoom(name, state, input) end, false, Enum.KeyCode.ButtonL3)
+end
+
+
+-- [[ Update ]]--
+function OrbitalCamera:Update(dt)
+	local now = tick()
+	local timeDelta = (now - self.lastUpdate)
+	local userPanningTheCamera = (self.UserPanningTheCamera == true)
+	local camera = 	workspace.CurrentCamera
+	local newCameraCFrame = camera.CFrame
+	local newCameraFocus = camera.Focus
+	local player = PlayersService.LocalPlayer
+	local humanoid = self:GetHumanoid()
+	local cameraSubject = camera and camera.CameraSubject
+	local isInVehicle = cameraSubject and cameraSubject:IsA('VehicleSeat')
+	local isOnASkateboard = cameraSubject and cameraSubject:IsA('SkateboardPlatform')
+	
+	if self.lastUpdate == nil or timeDelta > 1 then
+		self.lastCameraTransform = nil
+	end	
+	
+	if self.lastUpdate then
+		local gamepadRotation = self:UpdateGamepad()
+		
+		if self:ShouldUseVRRotation() then				
+			self.RotateInput = self.RotateInput + self:GetVRRotationInput()
+		else
+			-- Cap out the delta to 0.1 so we don't get some crazy things when we re-resume from
+			local delta = math.min(0.1, timeDelta)
+			
+			if gamepadRotation ~= ZERO_VECTOR2 then
+				userPanningTheCamera = true
+				self.rotateInput = self.rotateInput + (gamepadRotation * delta)
+			end
+
+			local angle = 0
+			if not (isInVehicle or isOnASkateboard) then
+				angle = angle + (self.TurningLeft and -120 or 0)
+				angle = angle + (self.TurningRight and 120 or 0)
+			end
+			
+			if angle ~= 0 then
+				self.rotateInput = self.rotateInput +  Vector2.new(math.rad(angle * delta), 0)
+				userPanningTheCamera = true
+			end
+		end
+	end
+
+	-- Reset tween speed if user is panning
+	if userPanningTheCamera then
+		tweenSpeed = 0
+		self.lastUserPanCamera = tick()
+	end
+	
+	local userRecentlyPannedCamera = now - self.lastUserPanCamera < TIME_BEFORE_AUTO_ROTATE
+	local subjectPosition = self:GetSubjectPosition()
+	
+	if subjectPosition and player and camera then
+	
+		-- Process any dollying being done by gamepad
+		-- TODO: Move this
+		if self.gamepadDollySpeedMultiplier ~= 1 then
+			self:SetCameraToSubjectDistance(self.currentSubjectDistance * self.gamepadDollySpeedMultiplier)
+		end
+		
+		local VREnabled = VRService.VREnabled
+		newCameraFocus = VREnabled and self:GetVRFocus(subjectPosition, timeDelta) or CFrame.new(subjectPosition)
+
+		local cameraFocusP = newCameraFocus.p
+		if VREnabled and not self:IsInFirstPerson() then
+			local cameraHeight = self:GetCameraHeight()
+			local vecToSubject = (subjectPosition - camera.CFrame.p)
+			local distToSubject = vecToSubject.magnitude
+
+			-- Only move the camera if it exceeded a maximum distance to the subject in VR
+			if distToSubject > self.currentSubjectDistance or self.rotateInput.x ~= 0 then
+				local desiredDist = math.min(distToSubject, self.currentSubjectDistance)
+				
+				-- Note that CalculateNewLookVector is overridden from BaseCamera
+				vecToSubject = self:CalculateNewLookVector(vecToSubject.unit * X1_Y0_Z1, Vector2.new(self.rotateInput.x, 0)) * desiredDist
+				
+				local newPos = cameraFocusP - vecToSubject
+				local desiredLookDir = camera.CFrame.lookVector
+				if self.rotateInput.x ~= 0 then
+					desiredLookDir = vecToSubject
+				end
+				local lookAt = Vector3.new(newPos.x + desiredLookDir.x, newPos.y, newPos.z + desiredLookDir.z)
+				self.RotateInput = ZERO_VECTOR2
+				
+				newCameraCFrame = CFrame.new(newPos, lookAt) + Vector3.new(0, cameraHeight, 0)
+			end
+		else
+			-- self.RotateInput is a Vector2 of mouse movement deltas since last update
+			self.curAzimuthRad = self.curAzimuthRad - self.rotateInput.x
+			
+			if self.useAzimuthLimits then
+				self.curAzimuthRad = Util.Clamp(self.minAzimuthAbsoluteRad, self.maxAzimuthAbsoluteRad, self.curAzimuthRad)
+			else
+				self.curAzimuthRad = (self.curAzimuthRad ~= 0) and (math.sign(self.curAzimuthRad) * (math.abs(self.curAzimuthRad) % TAU)) or 0
+			end
+
+			self.curElevationRad = Util.Clamp(self.minElevationRad, self.maxElevationRad, self.curElevationRad + self.rotateInput.y)
+			
+			local cameraPosVector = self.currentSubjectDistance * ( CFrame.fromEulerAnglesYXZ( -self.curElevationRad, self.curAzimuthRad, 0 ) * UNIT_Z ) 
+			local camPos = subjectPosition + cameraPosVector
+			
+			newCameraCFrame = CFrame.new(camPos, subjectPosition)
+		
+			self.rotateInput = ZERO_VECTOR2
+		end
+
+		self.lastCameraTransform = newCameraCFrame
+		self.lastCameraFocus = newCameraFocus
+		if (isInVehicle or isOnASkateboard) and cameraSubject:IsA('BasePart') then
+			self.lastSubjectCFrame = cameraSubject.CFrame
+		else
+			self.lastSubjectCFrame = nil
+		end
+	end
+	
+	self.lastUpdate = now
+	return newCameraCFrame, newCameraFocus
+end
+
+return OrbitalCamera

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam.lua

@@ -0,0 +1,219 @@
+--[[
+	Poppercam - Occlusion module that brings the camera closer to the subject when objects are blocking the view.
+--]]
+
+--[[ Camera Maths Utilities Library ]]--
+local Util = require(script.Parent:WaitForChild("CameraUtils"))
+
+local RunService = game:GetService("RunService")
+local PlayersService = game:GetService("Players")
+local ContextActionService = game:GetService("ContextActionService")
+local UserInputService = game:GetService("UserInputService")
+local GameSettings = UserSettings().GameSettings
+
+-- Note: Zoom and Subject modules return single functions, Zoom() and Subject() respectively,
+-- whereas Rotate returns a table with two functions, Step() and GetDelta()
+local Zoom =  require(script:WaitForChild("Zoom"))
+local Subject =  require(script:WaitForChild("Subject"))
+
+local Rotate =  require(script:WaitForChild("Rotate"))
+local SetTransparency =  require(script:WaitForChild("SetTransparency"))
+
+
+-- From Input
+local INPUT_PRIORITY = Enum.ContextActionPriority.Low.Value
+local ROTATION_SPEED_KEYS    = math.rad(120)
+local ROTATION_SPEED_MOUSE   = Vector2.new(1, 0.77)*math.rad(15)
+local ROTATION_SPEED_GAMEPAD = Vector2.new(1, 0.77)*math.rad(165)
+local ZOOM_SPEED_MOUSE = 4
+local ZOOM_SPEED_KEYS = 0.75
+
+-- Gamepad Thumbstick Helper Function
+local AnalogCurve do
+	local DEADZONE = 0.1
+	function AnalogCurve(x)
+		local y = (math.abs(x) - DEADZONE)/(1 - DEADZONE)
+		y = 0.255000975*(2^(2.299113817*y) - 1)
+		return math.clamp(y, 0, 1)*math.sign(x)
+	end
+end
+
+
+local portraitPopperFixFlagExists, portraitPopperFixFlagEnabled = pcall(function()
+	return UserSettings():IsUserFeatureEnabled("UserPortraitPopperFix")
+end)
+local FFlagUserPortraitPopperFix = portraitPopperFixFlagExists and portraitPopperFixFlagEnabled
+
+
+--[[ 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.gamepad = {
+		Thumbstick2 = Vector2.new(),
+	}
+	self.keyboard = {
+		Left = 0,
+		Right = 0,
+		I = 0,
+		O = 0
+	}
+	self.mouse = {
+		Movement = Vector2.new(),
+		Wheel = 0,
+	}
+	
+	self.UISConnections = {}
+	self.steppedConn =  nil
+	self.worldDt = 1/60
+	return self
+end
+
+function Poppercam:GetPanning()
+	for _, input in ipairs(UserInputService:GetMouseButtonsPressed()) do
+		if input.UserInputType == Enum.UserInputType.MouseButton2 then
+			return true
+		end
+	end
+	return false
+end
+
+function Poppercam:GetRotation()
+	local kKeyboard = Vector2.new(self.keyboard.Left - self.keyboard.Right, 0)
+	local kGamepad = self.gamepad.Thumbstick2
+	local kMouse = self.mouse.Movement
+	self.mouse.Movement = Vector2.new()
+	local result = kKeyboard*ROTATION_SPEED_KEYS + kGamepad*ROTATION_SPEED_GAMEPAD + kMouse*ROTATION_SPEED_MOUSE
+	return result.Y, result.X
+end
+
+function Poppercam:GetZoomDelta()
+	local kKeyboard = self.keyboard.O - self.keyboard.I
+	local kMouse = -self.mouse.Wheel
+	self.mouse.Wheel = 0
+	return kKeyboard*ZOOM_SPEED_KEYS + kMouse*ZOOM_SPEED_MOUSE
+end
+
+function Poppercam:GetOcclusionMode()
+	return Enum.DevCameraOcclusionMode.Zoom
+end
+
+function Poppercam:Enable(enable)
+	if enable then
+		-- Enabling	
+		self:BindInputs()		
+	else
+		-- Disabling
+		self:UnbindInputs()
+		self:ResetDeviceInputs()
+	end
+end
+
+function Poppercam:Update(renderDt, desiredCameraCFrame, desiredCameraFocus)
+	self.camera = game.Workspace.CurrentCamera
+	if self.camera.CameraType == Enum.CameraType.Custom then
+		local subject, subjectTransform, subjectRoot = Subject(self.worldDt)
+		if subject then
+			local pitch, yaw = self:GetRotation()
+			local zoomDelta = self:GetZoomDelta()
+			local newFocus = Rotate:Step(self.worldDt, subjectTransform, pitch, yaw) -- vehicle yaw spring must use the world step
+			local zoom, transparency, firstPerson = Zoom(renderDt, zoomDelta, newFocus, subjectRoot)
+			local newCameraCFrame = newFocus*CFrame.new(0, 0, zoom)
+			return newCameraCFrame, newFocus
+		end
+	end
+	
+	return desiredCameraCFrame, desiredCameraFocus
+end
+
+function Poppercam:ResetDeviceInputs()
+	for _, device in pairs{self.gamepad, self.keyboard, self.mouse} do
+		for k, v in pairs(device) do
+			device[k] = v*0
+		end
+	end
+end
+
+function Poppercam:BindInputs()
+	local function Thumbstick(action, state, input)
+		local position = input.Position
+		self.gamepad[input.KeyCode.Name] = Vector2.new(AnalogCurve(position.X), AnalogCurve(position.Y))
+	end
+
+	local function MouseMove(action, state, input)
+		local delta = input.Delta
+		self.mouse.Movement = Vector2.new(-delta.X, -delta.Y)
+		return Enum.ContextActionResult.Pass
+	end
+	
+	local function MouseWheel(action, state, input)
+		self.mouse.Wheel = input.Position.Z
+		return Enum.ContextActionResult.Pass
+	end
+	
+	local function Keypress(action, state, input)
+		self.keyboard[input.KeyCode.Name] = state == Enum.UserInputState.Begin and 1 or 0
+	end
+		
+	ContextActionService:BindActionAtPriority("Camera/Thumbstick", Thumbstick, false, INPUT_PRIORITY,
+		Enum.KeyCode.Thumbstick2
+	)
+	ContextActionService:BindActionAtPriority("Camera/MouseMove",  MouseMove, false, INPUT_PRIORITY,
+		Enum.UserInputType.MouseMovement
+	)
+	ContextActionService:BindActionAtPriority("Camera/MouseWheel", MouseWheel, false, INPUT_PRIORITY,
+		Enum.UserInputType.MouseWheel
+	)
+	ContextActionService:BindActionAtPriority("Camera/Keypress", Keypress, false, INPUT_PRIORITY,
+		Enum.KeyCode.Left,
+		Enum.KeyCode.Right,
+		Enum.KeyCode.I,
+		Enum.KeyCode.O
+	)
+	
+	local resetFunction = function() self:ResetDeviceInputs() end
+	self.UISConnections["TextBoxFocused"] = UserInputService.TextBoxFocused:Connect(resetFunction)		
+	self.UISConnections["TextBoxFocusReleased"] = UserInputService.TextBoxFocusReleased:Connect(resetFunction)
+	self.UISConnections["WindowFocused"] = UserInputService.WindowFocused:Connect(resetFunction)
+	self.UISConnections["WindowFocusReleased"] = UserInputService.WindowFocusReleased:Connect(resetFunction)
+	
+	self.steppedConn = RunService.Stepped:Connect(function(t,dt)
+		self.worldDt = dt
+	end)
+end
+
+function Poppercam:UnbindInputs()
+	ContextActionService:UnbindAction("Camera/Thumbstick")
+	ContextActionService:UnbindAction("Camera/MouseMove")
+	ContextActionService:UnbindAction("Camera/MouseWheel")
+	ContextActionService:UnbindAction("Camera/Keypress")	
+	
+	for _, connection in pairs(self.UISConnections) do
+		connection:Disconnect()
+	end
+	self.UISConnections = {}
+		
+	if self.steppedConn then
+		self.steppedConn:Disconnect()
+	end
+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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam/Rotate.lua

@@ -0,0 +1,45 @@
+
+local tau = math.pi*2
+local clamp = math.clamp
+local fromEulerYXZ = CFrame.fromEulerAnglesYXZ
+
+local function lowpass(responsiveness)
+	local x = 0
+	return function(nx)
+		x = responsiveness*nx + (1 - responsiveness)*x
+		return x
+	end
+end
+
+------------------------------------------------------------------------------
+
+local PITCH_LIMIT = math.rad(88)
+
+local pitch = math.rad(-10)
+local yaw = math.rad(90)
+
+local dPitch = 0
+local dYaw = 0
+local oldSubjectTransform
+
+local dpf = lowpass(0.01)
+local dyf = lowpass(0.01)
+
+------------------------------------------------------------------------------
+
+local Rotate = {} do
+	function Rotate:Step(worldDt, subjectTransform, dPitch, dYaw)
+		yaw = (yaw + dYaw*worldDt)%tau
+		pitch = clamp(pitch + dPitch*worldDt, -PITCH_LIMIT, PITCH_LIMIT)
+		oldSubjectTransform = subjectTransform*fromEulerYXZ(pitch, yaw, 0)
+		return oldSubjectTransform
+	end
+	
+	function Rotate:GetDelta(dt)
+		local dp = dpf(dPitch)
+		local dy = dyf(dYaw)
+		return fromEulerYXZ(dp*dt, dy*dt, 0)
+	end
+end
+
+return Rotate

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam/SetTransparency.lua

@@ -0,0 +1,19 @@
+local lastSubject = nil
+local lastTransparency = 0
+
+return function(subject, transparency)
+	if transparency == lastTransparency and subject == lastSubject then
+		return
+	end
+	
+	lastSubject = subject
+	lastTransparency = transparency
+	
+	local descendants = subject:GetDescendants()
+	for i = 1, #descendants do
+		local obj = descendants[i]
+		if obj:IsA'BasePart' then
+			obj.LocalTransparencyModifier = transparency
+		end
+	end
+end

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam/Subject.lua

@@ -0,0 +1,75 @@
+local ROOT_FOCUS_OFFSET = CFrame.new(0, 2, 0)
+
+local Maid = require(script:WaitForChild("Maid"))
+local AngleSpring = require(script:WaitForChild("AngleSpring"))
+
+local camera = game.Workspace.CurrentCamera
+
+---------------------------------------------------------------------------------------
+
+local subjectModel = nil
+local subjectRootPart = nil
+local subjectIsVehicle = false
+
+---------------------------------------------------------------------------------------
+
+do
+	local maid = Maid.new()
+
+	local function SubjectChanged()
+		maid:sweep()
+		local subj = camera.CameraSubject
+		
+		local function handleHumanoid(humanoid, isVehicle)
+			subjectModel = humanoid.Parent
+			subjectRootPart = humanoid.RootPart
+			subjectIsVehicle = isVehicle
+			maid:mark(humanoid:GetPropertyChangedSignal('RootPart'):Connect(SubjectChanged))
+			maid:mark(humanoid:GetPropertyChangedSignal('Parent'):Connect(SubjectChanged))
+		end
+		
+		if subj and subj:IsA('Humanoid') then
+			handleHumanoid(subj, false)
+		elseif subj and subj:IsA('VehicleSeat') then
+			handleHumanoid(subj.Occupant, true)
+		else
+			subjectModel = nil
+			subjectRootPart = nil
+			subjectIsVehicle = false
+		end
+	end
+
+	SubjectChanged()
+	camera:GetPropertyChangedSignal'CameraSubject':Connect(SubjectChanged)
+end
+
+---------------------------------------------------------------------------------------
+
+local yawSpring = AngleSpring.new(2, 0)
+
+return function(dt)
+	if subjectModel and subjectRootPart then
+		
+		local subjectTransform = subjectRootPart.CFrame*ROOT_FOCUS_OFFSET
+		if not subjectIsVehicle then
+			subjectTransform = CFrame.new(subjectTransform.p)
+		else
+			local _, yaw = subjectTransform:toEulerAnglesYXZ()
+			yawSpring:setGoal(yaw)
+			yawSpring:step(dt)
+			subjectTransform = CFrame.new(subjectTransform.p)*CFrame.fromEulerAnglesYXZ(0, yawSpring:getState(), 0)
+		end
+		
+		return subjectModel, subjectTransform, subjectRootPart
+	else
+		return nil, CFrame.new(), Vector3.new()
+	end
+end
+
+
+
+
+
+
+
+

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam/Subject/AngleSpring.lua

@@ -0,0 +1,49 @@
+-- Critically damped angular spring
+
+local AngleSpring = {} do
+	AngleSpring.__index = AngleSpring
+
+	local pi = math.pi
+	local tau = math.pi*2
+	local exp = math.exp
+	
+	function AngleSpring.new(frequency, position)
+		local self = setmetatable({}, AngleSpring)
+		
+		self.f = frequency -- nominal frequency
+		self.g = position -- goal position
+		self.p = position -- position
+		self.v = position*0 -- velocity (*0 so that the types match)
+		
+		return self
+	end
+
+	function AngleSpring:setGoal(g)
+		self.g = g
+	end
+	
+	function AngleSpring:getState()
+		return self.p, self.v
+	end
+
+	function AngleSpring:step(dt)
+		local f = self.f*tau
+		local g = self.g
+		local p = self.p
+		local v = self.v
+
+		local offset = (p - g + pi)%tau - pi
+		local decay = exp(-dt*f)
+
+		-- Given:
+		--   f^2*(x[dt] - g) + 2*d*f*x'[dt] + x''[dt] = 0,
+		--   x[0] = p,
+		--   x'[0] = v
+		-- Solve for x[dt], x'[dt]
+		
+		self.p = (v*dt + offset*(f*dt + 1))*decay + g
+		self.v = (v - f*dt*(offset*f + v))*decay
+	end
+end
+
+return AngleSpring

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam/Subject/Maid.lua

@@ -0,0 +1,41 @@
+local Maid = {} do
+	Maid.__index = Maid
+	
+	local destructors = {
+		['function'] = function(item)
+			item()
+		end,
+		['Instance'] = function(item)
+			item:Destroy()
+		end,
+		['RBXScriptConnection'] = function(item)
+			item:Disconnect()
+		end,
+	}
+	
+	function Maid.new()
+		local self = setmetatable({}, Maid)
+		self.trash = {}
+		return self
+	end
+
+	function Maid:mark(item)
+		if destructors[typeof(item)] then
+			local trash = self.trash
+			trash[#trash + 1] = item
+		else
+			error(('No destructor defined for type "%s"'):format(typeof(item)), 2)
+		end
+	end
+	
+	function Maid:sweep()
+		local trash = self.trash
+		for i = 1, #trash do
+			local item = trash[i]
+			destructors[typeof(item)](item)
+		end
+		self.trash = {}
+	end
+end
+
+return Maid

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam/Zoom.lua

@@ -0,0 +1,82 @@
+--------------------------------------------------------------------------------
+-- Zoom.lua
+-- Controls the distance between the focus and the camera.
+--------------------------------------------------------------------------------
+
+local ZOOM_STIFFNESS    = 4.5
+local ZOOM_DEFAULT      = 16
+local ZOOM_ACCELERATION = 0.0375
+
+local ZOOM_OPAQUE       = 2
+local ZOOM_TRANSPARENT  = 0.5
+
+local ConstrainedSpring = require(script:WaitForChild("ConstrainedSpring"))
+local Popper = require(script:WaitForChild("Popper"))
+
+local cframe = CFrame.new
+local clamp = math.clamp
+local min = math.min
+local max = math.max
+
+local DIST_MIN, DIST_MAX do
+	local Player = game:GetService("Players").LocalPlayer
+
+	local function updateBounds()
+		DIST_MIN = Player.CameraMinZoomDistance
+		DIST_MAX = Player.CameraMaxZoomDistance
+	end
+
+	updateBounds()
+
+	Player:GetPropertyChangedSignal('CameraMinZoomDistance'):Connect(updateBounds)
+	Player:GetPropertyChangedSignal('CameraMaxZoomDistance'):Connect(updateBounds)
+end
+
+--------------------------------------------------------------------------------
+
+local zoomSpring = ConstrainedSpring.new(ZOOM_STIFFNESS, ZOOM_DEFAULT, DIST_MIN, DIST_MAX)
+
+local function zoomToTransparency(zoom)
+	zoom = clamp(zoom, ZOOM_TRANSPARENT, ZOOM_OPAQUE)
+	local t = (zoom - ZOOM_TRANSPARENT)/(ZOOM_OPAQUE - ZOOM_TRANSPARENT)
+	return 1 - (3 - 2*t)*t*t
+end
+
+local function stepTargetZoom(z, dz, zoomMin, zoomMax)
+	z = clamp(z + dz*(1 + z*ZOOM_ACCELERATION), zoomMin, zoomMax)
+	if z < ZOOM_OPAQUE then
+		z = dz <= 0 and zoomMin or ZOOM_OPAQUE
+	end
+	return z
+end
+
+--------------------------------------------------------------------------------
+
+function Zoom(renderDt, zoomDelta, focus, subjectRootPart)
+	
+	local prmax = max(zoomSpring.x, stepTargetZoom(zoomSpring.goal, zoomDelta, DIST_MIN, DIST_MAX))
+	
+	local poppedZoom = Popper(focus*cframe(0, 0, DIST_MIN), prmax - DIST_MIN, subjectRootPart) + DIST_MIN
+	
+	local zoomMin = DIST_MIN
+	local zoomMax = min(DIST_MAX, poppedZoom)
+	zoomSpring:setBounds(zoomMin, zoomMax)
+	
+	local isPopped = zoomSpring.goal > zoomMax
+	
+	if zoomDelta ~= 0 then
+		if not isPopped then
+			zoomSpring.goal = stepTargetZoom(zoomSpring.goal, zoomDelta, zoomMin, zoomMax)
+		elseif zoomDelta < 0 then
+			zoomSpring.goal = stepTargetZoom(zoomMax, zoomDelta, zoomMin, zoomMax)
+		end
+	end
+	
+	local zoom = zoomSpring:step(renderDt)
+	local fp = zoomSpring.goal == DIST_MIN
+	local transparency = fp and zoomToTransparency(zoom) or 0
+	
+	return zoom, transparency, fp
+end
+
+return Zoom

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam/Zoom/ConstrainedSpring.lua

@@ -0,0 +1,61 @@
+local ConstrainedSpring = {} do
+	ConstrainedSpring.__index = ConstrainedSpring
+	
+	local exp = math.exp
+	local tau = 2*math.pi
+
+	function ConstrainedSpring.new(f, x, min, max)
+		x = math.clamp(x, min, max)
+		local self = setmetatable({}, ConstrainedSpring)		
+		self.f = f
+		self.x = x
+		self.dx = 0
+		self.min = min
+		self.max = max
+		self.goal = x
+		return self
+	end
+
+	function ConstrainedSpring:step(dt)
+		local f = self.f*tau
+		local x = self.x
+		local dx = self.dx
+		local min = self.min
+		local max = self.max
+		local goal = self.goal
+		
+		-- Given:
+		--   f^2*(x[dt] - g) + 2*d*f*x'[dt] + x''[dt] = 0,
+		--   x[0] = p,
+		--   x'[0] = v
+		-- Solve for x[dt], x'[dt]
+		
+		local offset = goal - x
+		local step = f*dt
+		local decay = exp(-step)
+		
+		x = goal + (dx*dt - offset*(step + 1))*decay
+		dx = ((offset*f - dx)*step + dx)*decay
+		
+		-- Constrain
+		if x < min then
+			x = min
+			dx = 0
+		elseif x > max then
+			x = max
+			dx = 0
+		end
+
+		self.x = x
+		self.dx = dx
+		
+		return x
+	end
+	
+	function ConstrainedSpring:setBounds(min, max)
+		self.min = min
+		self.max = max
+	end
+end
+
+return ConstrainedSpring

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam/Zoom/Popper.lua

@@ -0,0 +1,341 @@
+--------------------------------------------------------------------------------
+-- Popper.lua
+-- Prevents your camera from clipping through walls.
+--------------------------------------------------------------------------------
+
+local Rotate = require(script.Parent.Parent:WaitForChild("Rotate"))
+
+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 eraseFromEnd(t, toSize)
+	for i = #t, toSize + 1, -1 do
+		t[i] = nil
+	end
+end
+
+local nearZ, 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()
+
+	nearZ = camera.NearZ
+	camera:GetPropertyChangedSignal('NearPlaneZ'):Connect(function()
+		nearZ = camera.NearPlaneZ
+	end)
+end
+
+local blacklist = {} do
+	local charMap = {}
+
+	local function refreshIgnoreList()
+		local n = 1
+		blacklist = {}
+		for player, 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
+
+	do
+		local Players = game:GetService('Players')
+		
+		Players.PlayerAdded:Connect(playerAdded)
+		Players.PlayerRemoving:Connect(playerRemoving)
+		
+		for _, player in ipairs(Players:GetPlayers()) do
+			playerAdded(player)
+		end
+		refreshIgnoreList()
+	end
+end
+
+--------------------------------------------------------------------------------------------
+-- Popper uses the level geometry find an upper bound on subject-to-camera distance.
+-- 
+-- Hard limits are applied immediately and unconditionally. They're generally caused
+-- when level geometry intersects with the near plane (with exceptions, see below).
+-- 
+-- Soft limits are only applied under certain conditions.
+-- They're 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 subjectRootPart
+
+-- @todo cache
+local function canCollide(part)
+	return subjectRootPart:CanCollideWith(part)
+end
+
+local function canOcclude(part)
+	-- Filter for opaque, interactable objects
+	return
+		part.Transparency < 0.2 and
+		canCollide(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, blacklist)
+	local originalSize = #blacklist
+	repeat
+		local hitPart, hitPoint = workspace:FindPartOnRayWithIgnoreList(
+			ray(origin, dir), blacklist, false, true
+		)
+		
+		if hitPart then
+			if canCollide(hitPart) 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 + nearZ
+	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, false, true)
+
+				local lim = (entryPos - origin).Magnitude
+
+				if exitPart then
+					local promote = false
+					if lastPos then
+						promote = 
+							workspace:FindPartOnRayWithWhitelist(ray(lastPos, target - lastPos), wl, false, true) or
+							workspace:FindPartOnRayWithWhitelist(ray(target, lastPos - target), wl, false, 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
+		end
+	until hardLimit < inf or not entryPart
+	
+	eraseFromEnd(blacklist, originalSize)
+	
+	debug.profileend()
+	return softLimit - nearZ, hardLimit - nearZ
+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 + nearZ*(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 getBodyScale(humanoid, scaleName)
+	local scaleValue = humanoid:FindFirstChild(scaleName)
+	if scaleValue and scaleValue:IsA('NumberValue') then
+		return scaleValue.Value
+	end
+	return 1
+end
+
+local function testPromotion(focus, dist)
+	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 vel = subjectRootPart.Velocity
+		local speed = vel.Magnitude
+		local maxDist = (getCollisionPoint(fP, vel*SAMPLE_MAX_T) - fP).Magnitude
+		
+		for dt = 0, min(SAMPLE_MAX_T, maxDist/speed), SAMPLE_DT do
+			local origin = fP + vel*dt
+			local dir = -(focus*Rotate:GetDelta(dt)).lookVector
+			
+			if queryPoint(origin, dir, 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')
+		
+		local humanoid = subjectRootPart.Parent:FindFirstChildOfClass('Humanoid')
+		
+		if humanoid then
+			local scaleX = getBodyScale(humanoid, 'BodyWidthScale')
+			local scaleY = getBodyScale(humanoid, 'BodyHeightScale')
+			local scaleZ = getBodyScale(humanoid, 'BodyDepthScale')
+			
+			local sampleScale = Vector2.new(math.sqrt(scaleX*scaleX + scaleZ*scaleZ), scaleY)
+			
+			for _, offset in ipairs(SCAN_SAMPLE_OFFSETS) do
+				local scaledOffset = offset*sampleScale
+				local pos, isHit = getCollisionPoint(fP, fX*scaledOffset.x + fY*scaledOffset.y)
+				if queryPoint(pos, (fP + fZ*dist - pos).Unit, dist) == inf then
+					return false
+				end
+			end
+		end
+		
+		debug.profileend()
+	end
+	
+	debug.profileend()
+	return true
+end
+
+--------------------------------------------------------------------------------
+
+function Popper(focus, targetDist, _subjectRootPart)
+	debug.profilebegin('popper')
+	
+	subjectRootPart = _subjectRootPart
+	
+	local dist = targetDist
+	local soft, hard = queryViewport(focus, targetDist)
+	if hard < dist then
+		dist = hard
+	end
+	if soft < dist and testPromotion(focus, targetDist) then
+		dist = soft
+	end
+
+	subjectRootPart = nil
+	
+	debug.profileend()
+	return dist
+end
+
+return Popper

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/CameraModule/Poppercam_Classic.lua

@@ -0,0 +1,174 @@
+--[[
+	Poppercam - Occlusion module that brings the camera closer to the subject when objects are blocking the view
+	Refactored for 2018 Camera Update but functionality is unchanged - AllYourBlox		
+--]]
+
+--[[ Camera Maths Utilities Library ]]--
+local Util = require(script.Parent:WaitForChild("CameraUtils"))
+
+local PlayersService = game:GetService("Players")
+local POP_RESTORE_RATE = 0.3
+local MIN_CAMERA_ZOOM = 0.5
+local VALID_SUBJECTS = {
+	'Humanoid',
+	'VehicleSeat',
+	'SkateboardPlatform',
+}
+
+local portraitPopperFixFlagExists, portraitPopperFixFlagEnabled = pcall(function()
+	return UserSettings():IsUserFeatureEnabled("UserPortraitPopperFix")
+end)
+local FFlagUserPortraitPopperFix = portraitPopperFixFlagExists and portraitPopperFixFlagEnabled
+
+
+--[[ 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.camera = nil
+	self.cameraSubjectChangeConn = nil
+	
+	self.subjectPart = nil
+	
+	self.playerCharacters = {} 	-- For ignoring in raycasts
+	self.vehicleParts = {} 		-- Also just for ignoring
+	
+	self.lastPopAmount = 0
+	self.lastZoomLevel = 0
+	self.popperEnabled = false
+	
+	return self
+end
+
+function Poppercam:GetOcclusionMode()
+	return Enum.DevCameraOcclusionMode.Zoom
+end
+
+function Poppercam:Enable(enable)
+	
+end
+
+-- Called when character is added
+function Poppercam:CharacterAdded(char, player)
+	self.playerCharacters[player] = char
+end
+
+-- Called when character is about to be removed
+function Poppercam:CharacterRemoving(char, player)
+	self.playerCharacters[player] = nil
+end
+
+function Poppercam:Update(dt, desiredCameraCFrame, desiredCameraFocus)
+	if self.popperEnabled then
+		self.camera = game.Workspace.CurrentCamera
+		local newCameraCFrame = desiredCameraCFrame
+		local focusPoint = desiredCameraFocus.p
+
+		if FFlagUserPortraitPopperFix and self.subjectPart then
+			focusPoint = self.subjectPart.CFrame.p
+		end
+
+		local ignoreList = {}
+		for _, character in pairs(self.playerCharacters) do
+			ignoreList[#ignoreList + 1] = character
+		end
+		for i = 1, #self.vehicleParts do
+			ignoreList[#ignoreList + 1] = self.vehicleParts[i]
+		end
+		
+		-- Get largest cutoff distance
+		-- Note that the camera CFrame must be set here, because the current implementation of GetLargestCutoffDistance
+		-- uses the current camera CFrame directly (it cannot yet be passed the desiredCameraCFrame).
+		local prevCameraCFrame = self.camera.CFrame
+		self.camera.CFrame = desiredCameraCFrame
+		self.camera.Focus = desiredCameraFocus
+		local largest = self.camera:GetLargestCutoffDistance(ignoreList)
+
+		-- Then check if the player zoomed since the last frame,
+		-- and if so, reset our pop history so we stop tweening
+		local zoomLevel = (desiredCameraCFrame.p - focusPoint).Magnitude
+		if math.abs(zoomLevel - self.lastZoomLevel) > 0.001 then
+			self.lastPopAmount = 0
+		end
+		
+		-- Finally, zoom the camera in (pop) by that most-cut-off amount, or the last pop amount if that's more
+		local popAmount = largest
+		if self.lastPopAmount > popAmount then
+			popAmount = self.lastPopAmount
+		end
+
+		if popAmount > 0 then
+			newCameraCFrame = desiredCameraCFrame + (desiredCameraCFrame.lookVector * popAmount)
+			self.lastPopAmount = popAmount - POP_RESTORE_RATE -- Shrink it for the next frame
+			if self.lastPopAmount < 0 then
+				self.lastPopAmount = 0
+			end
+		end
+
+		self.lastZoomLevel = zoomLevel
+		
+		-- Stop shift lock being able to see through walls by manipulating Camera focus inside the wall
+--		if EnabledCamera and EnabledCamera:GetShiftLock() and not EnabledCamera:IsInFirstPerson() then
+--			if EnabledCamera:GetCameraActualZoom() < 1 then
+--				local subjectPosition = EnabledCamera.lastSubjectPosition 
+--				if subjectPosition then
+--					Camera.Focus = CFrame_new(subjectPosition)
+--					Camera.CFrame = CFrame_new(subjectPosition - MIN_CAMERA_ZOOM*EnabledCamera:GetCameraLook(), subjectPosition)
+--				end
+--			end
+--		end
+		return newCameraCFrame, desiredCameraFocus
+	end
+	
+	-- Return unchanged values
+	return desiredCameraCFrame, desiredCameraFocus
+end
+
+function Poppercam:OnCameraSubjectChanged(newSubject)
+	self.vehicleParts = {}
+
+	self.lastPopAmount = 0
+
+	if newSubject then
+		-- Determine if we should be popping at all
+		self.popperEnabled = false
+		for _, subjectType in pairs(VALID_SUBJECTS) do
+			if newSubject:IsA(subjectType) then
+				self.popperEnabled = true
+				break
+			end
+		end
+
+		-- Get all parts of the vehicle the player is controlling
+		if newSubject:IsA('VehicleSeat') then
+			self.vehicleParts = newSubject:GetConnectedParts(true)
+		end
+	
+		if FFlagUserPortraitPopperFix then
+			if newSubject:IsA("BasePart") then
+				self.subjectPart = newSubject
+			elseif newSubject:IsA("Model") then
+				if newSubject.PrimaryPart then
+					self.subjectPart = newSubject.PrimaryPart
+				else
+					-- Model has no PrimaryPart set, just use first BasePart
+					-- we can find as better-than-nothing solution (can still fail)
+					for _, child in pairs(newSubject:GetChildren()) do
+						if child:IsA("BasePart") then
+							self.subjectPart = child
+							break
+						end
+					end	
+				end
+			elseif newSubject:IsA("Humanoid") then
+				self.subjectPart = newSubject.RootPart
+  			end
+  		end
+  	end
+end
+
+return Poppercam

RCCService2018/content/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 = Util.Clamp(-maxDelta, maxDelta, deltaTransparency)
+				end
+				transparency = self.lastTransparency + deltaTransparency
+			else
+				self.transparencyDirty = true
+			end
+
+			transparency = Util.Clamp(0, 1, Util.Round(transparency, 2))
+		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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule.lua

@@ -0,0 +1,405 @@
+--[[
+	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 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 TouchDPad = require(script:WaitForChild("TouchDPad"))
+local DynamicThumbstick = require(script:WaitForChild("DynamicThumbstick"))
+
+-- 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 TouchThumbstick = require(script:WaitForChild("TouchThumbstick"))
+local TouchThumbpad = require(script:WaitForChild("TouchThumbpad"))
+local TouchJump = require(script:WaitForChild("TouchJump"))
+
+-- Mapping from movement mode and lastInputType enum values to control modules to avoid huge if elseif switching
+local movementEnumToModuleMap = {
+	[Enum.TouchMovementMode.DPad] = TouchDPad,
+	[Enum.DevTouchMovementMode.DPad] = TouchDPad,
+	[Enum.TouchMovementMode.Thumbpad] = TouchThumbpad,
+	[Enum.DevTouchMovementMode.Thumbpad] = TouchThumbpad,
+	[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] = TouchThumbstick,
+
+	[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,
+}
+
+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
+	self.cameraRelative = true
+	
+	-- For Roblox self.vehicleController
+	self.humanoidSeatedConn = nil
+	self.vehicleController = nil
+	
+	self.touchControlFrame = nil
+	
+	self.vehicleController = require(script:WaitForChild("VehicleController"))
+	
+	Players.LocalPlayer.CharacterAdded:Connect(function(char) self:OnCharacterAdded(char) end)
+	Players.LocalPlayer.CharacterRemoving:Connect(function(char) self:OnCharacterAdded(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)
+	
+	local propertyChangeListeners = {
+		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 nil
+end
+
+function ControlModule:GetActiveController()
+	return self.activeController
+end
+
+function ControlModule:Enable(enable)
+	if not self.activeController then
+		return
+	end
+	
+	if enable == nil then
+		enable = true
+	end
+	if enable then
+		if self.touchControlFrame then
+			self.activeController:Enable(true, self.touchControlFrame)
+		else
+			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 spacebar to jump.
+				self.activeController:Enable(true, Players.LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.UserChoice)
+			else				
+				self.activeController:Enable(true)
+			end
+		end
+	else
+		self.activeController:Enable(false)
+	end
+end
+
+-- For those who prefer distinct functions
+function ControlModule:Disable()
+	if self.activeController then
+		self.activeController:Enable(false)
+	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 = nil
+	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 = nil
+	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
+
+function ControlModule:OnRenderStepped(dt)
+	if self.activeController and self.activeController.enabled and self.humanoid then
+		local moveVector = self.activeController:GetMoveVector()
+
+		local vehicleConsumedInput = false
+		if self.vehicleController then
+			moveVector, vehicleConsumedInput = self.vehicleController:Update(moveVector, self.activeControlModule==Gamepad)
+		end
+
+		-- User 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
+			self.moveFunction(Players.LocalPlayer, moveVector, self.cameraRelative)
+		--end
+
+		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()
+			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.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
+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()
+		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 then
+				self.activeController:Enable(true, self.touchControlFrame)
+			else
+				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 spacebar to jump.
+					self.activeController:Enable(true, Players.LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.UserChoice)
+				else				
+					self.activeController:Enable(true)
+				end
+			end
+			if self.touchControlFrame and (self.activeControlModule == TouchThumbpad
+									or self.activeControlModule == TouchThumbstick
+									or self.activeControlModule == ClickToMove
+									or self.activeControlModule == DynamicThumbstick) then
+				self.touchJumpController = self.controllers[TouchJump]
+				if not self.touchJumpController then
+					self.touchJumpController = TouchJump.new()
+				end
+				self.touchJumpController:Enable(true, self.touchControlFrame)
+			else
+				if self.touchJumpController then
+					self.touchJumpController:Enable(false)
+				end
+			end
+		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.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
+
+return ControlModule.new()

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/BaseCharacterController.lua

@@ -0,0 +1,40 @@
+--[[
+	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)
+
+--[[ Roblox Services ]]--
+local Players = game:GetService("Players")
+
+--[[ The Module ]]--
+local BaseCharacterController = {}
+BaseCharacterController.__index = BaseCharacterController
+
+function BaseCharacterController.new()
+	local self = setmetatable({}, BaseCharacterController)
+	self.enabled = false
+	self.moveVector = ZERO_VECTOR3
+	self.isJumping = false
+	return self
+end
+
+function BaseCharacterController:GetMoveVector()
+	return self.moveVector
+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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/DynamicThumbstick.lua

@@ -0,0 +1,530 @@
+--[[ Constants ]]--
+local ZERO_VECTOR3 = Vector3.new(0,0,0)
+local TOUCH_CONTROLS_SHEET = "rbxasset://textures/ui/Input/TouchControlsSheetV2.png"
+
+local MIDDLE_TRANSPARENCIES = {
+	1 - 0.89,
+	1 - 0.70,
+	1 - 0.60,
+	1 - 0.50,
+	1 - 0.40,
+	1 - 0.30,
+	1 - 0.25
+}
+local NUM_MIDDLE_IMAGES = #MIDDLE_TRANSPARENCIES
+
+local 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 RunService = game:GetService("RunService")
+local TweenService = game:GetService("TweenService")
+
+--[[ 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.humanoid = nil
+
+	self.tools = {}
+	self.toolEquipped = nil
+
+	self.revertAutoJumpEnabledToFalse = false
+
+	self.moveTouchObject = nil
+	self.moveTouchStartPosition = nil
+
+	self.startImage = nil
+	self.endImage = nil
+	self.middleImages = {}
+
+	self.startImageFadeTween = nil
+	self.endImageFadeTween = nil
+	self.middleImageFadeTweens = {}
+
+	self.isFirstTouch = true
+
+	self.isFollowStick = false
+	self.thumbstickFrame = nil
+	self.onTouchMovedConn = nil
+	self.onTouchEndedConn = nil
+	self.onTouchActivateConn = 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
+
+	-- If this module changes a player's humanoid's AutoJumpEnabled, it saves
+	-- the previous state in this variable to revert to
+	self.shouldRevertAutoJumpOnDisable = false
+
+	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:EnableAutoJump(enable)
+	local humanoid = Players.LocalPlayer.Character and Players.LocalPlayer.Character:FindFirstChildOfClass("Humanoid")
+	if humanoid then
+		if enable then
+			self.shouldRevertAutoJumpOnDisable = (humanoid.AutoJumpEnabled == false) and (Players.LocalPlayer.DevTouchMovementMode == Enum.DevTouchMovementMode.UserChoice)
+			humanoid.AutoJumpEnabled = true
+		elseif self.shouldRevertAutoJumpOnDisable then
+			humanoid.AutoJumpEnabled = false
+		end
+	end
+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
+
+		if Players.LocalPlayer.Character then
+			self:OnCharacterAdded(Players.LocalPlayer.Character)
+		else
+			Players.LocalPlayer.CharacterAdded:Connect(function(char)
+				self:OnCharacterAdded(char)
+			end)
+		end
+	else
+		-- Disable
+		self:OnInputEnded() -- Cleanup
+	end
+
+	self.enabled = enable
+	self.thumbstickFrame.Visible = enable
+end
+
+function DynamicThumbstick:OnCharacterAdded(char)
+
+	for _, child in ipairs(char:GetChildren()) do
+		if child:IsA("Tool") then
+			self.toolEquipped = child
+		end
+	end
+
+	char.ChildAdded:Connect(function(child)
+		if child:IsA("Tool") then
+			self.toolEquipped = child
+		elseif child:IsA("Humanoid") then
+			self:EnableAutoJump(true)
+		end
+
+	end)
+	char.ChildRemoved:Connect(function(child)
+		if child == self.toolEquipped then
+			self.toolEquipped = nil
+		end
+	end)
+
+	self.humanoid = char:FindFirstChildOfClass("Humanoid")
+	if self.humanoid then
+		self:EnableAutoJump(true)
+	end
+end
+
+-- Was called OnMoveTouchEnded in previous version
+function DynamicThumbstick:OnInputEnded()
+	self.moveTouchObject = nil
+	self.moveVector = ZERO_VECTOR3
+	self:FadeThumbstick(false)
+	self.thumbstickFrame.Active = true
+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: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.onTouchEndedCon:Disconnect()
+			self.onTouchEndedCon = nil
+		end
+		if self.onRenderSteppedConn then
+			self.onRenderSteppedConn:Disconnect()
+			self.onRenderSteppedConn = nil
+		end
+		if self.onTouchActivateConn then
+			self.onTouchActivateConn:Disconnect()
+			self.onTouchActivateConn = nil
+		end
+	end
+
+	local ThumbstickSize = 45
+	local ThumbstickRingSize = 20
+	local MiddleSize = 10
+	local MiddleSpacing = MiddleSize + 4
+	local RadiusOfDeadZone = 2
+	local RadiusOfMaxSpeed = 20
+
+	local screenSize = parentFrame.AbsoluteSize
+	local isBigScreen = math.min(screenSize.x, screenSize.y) > 500
+	if isBigScreen then
+		ThumbstickSize = ThumbstickSize * 2
+		ThumbstickRingSize = ThumbstickRingSize * 2
+		MiddleSize = MiddleSize * 2
+		MiddleSpacing = MiddleSpacing * 2
+		RadiusOfDeadZone = RadiusOfDeadZone * 2
+		RadiusOfMaxSpeed = RadiusOfMaxSpeed * 2
+	end
+
+	local 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("TextButton")
+	self.thumbstickFrame.Text = ""
+	self.thumbstickFrame.Name = "DynamicThumbstickFrame"
+	self.thumbstickFrame.Visible = false
+	self.thumbstickFrame.BackgroundTransparency = 1.0
+	self.thumbstickFrame.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
+	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, ThumbstickRingSize * 3.3, 1, -ThumbstickRingSize * 2.8)
+	self.startImage.Size = UDim2.new(0, ThumbstickRingSize * 3.7, 0, 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, ThumbstickSize * 0.8, 0, 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 = {}
+
+	local function doMove(direction)
+		local currentMoveVector = direction
+
+		-- Scaled Radial Dead Zone
+		local inputAxisMagnitude = currentMoveVector.magnitude
+		if inputAxisMagnitude < RadiusOfDeadZone then
+			currentMoveVector = Vector3.new()
+		else
+			currentMoveVector = currentMoveVector.unit*(1 - math.max(0, (RadiusOfMaxSpeed - currentMoveVector.magnitude)/RadiusOfMaxSpeed))
+			currentMoveVector = Vector3.new(currentMoveVector.x, 0, currentMoveVector.y)
+		end
+
+		self.moveVector = currentMoveVector
+	end
+
+	local function layoutMiddleImages(startPos, endPos)
+		local startDist = (ThumbstickSize / 2) + MiddleSize
+		local vector = endPos - startPos
+		local distAvailable = vector.magnitude - (ThumbstickRingSize / 2) - MiddleSize
+		local direction = vector.unit
+
+		local distNeeded = MiddleSpacing * NUM_MIDDLE_IMAGES
+		local spacing = MiddleSpacing
+
+		if distNeeded < distAvailable then
+			spacing = distAvailable / NUM_MIDDLE_IMAGES
+		end
+
+		for i = 1, NUM_MIDDLE_IMAGES do
+			local image = 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, MiddleSize * exposedFraction, 0, MiddleSize * exposedFraction)
+			else
+				image.Visible = false
+			end
+		end
+	end
+
+	local function moveStick(pos)
+		local startPos = Vector2.new(self.moveTouchStartPosition.X, self.moveTouchStartPosition.Y) - 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)
+		layoutMiddleImages(startPos, endPos)
+	end
+
+	-- input connections
+	self.thumbstickFrame.InputBegan:Connect(function(inputObject)
+		if inputObject.UserInputType ~= Enum.UserInputType.Touch or inputObject.UserInputState ~= Enum.UserInputState.Begin then
+			return
+		end
+		if self.moveTouchObject then
+			return
+		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, ThumbstickSize, 0, ThumbstickSize), ImageColor3 = Color3.new(0,0,0)}):Play()
+		end
+
+		self.moveTouchObject = inputObject
+		self.moveTouchStartPosition = inputObject.Position
+		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)
+		moveStick(inputObject.Position)
+
+		if FADE_IN_OUT_BACKGROUND then
+			local playerGui = Players.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
+	end)
+
+	self.onTouchMovedConn = UserInputService.TouchMoved:connect(function(inputObject)
+		if inputObject == self.moveTouchObject then
+			self.thumbstickFrame.Active = false
+			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
+				doMove(direction)
+				moveStick(inputObject.Position)
+			end
+		end
+	end)
+
+	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 = Players.LocalPlayer:FindFirstChildOfClass("PlayerGui")
+	while not playerGui do
+		Players.LocalPlayer.ChildAdded:wait()
+		playerGui = Players.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.Changed:connect(function(prop)
+		if prop == "CurrentScreenOrientation" then
+			if (originalScreenOrientationWasLandscape and playerGui.CurrentScreenOrientation == Enum.ScreenOrientation.Portrait) or
+				(not originalScreenOrientationWasLandscape and playerGui.CurrentScreenOrientation ~= Enum.ScreenOrientation.Portrait) then
+
+				playerGuiChangedConn:disconnect()
+				longShowBackground()
+
+				if originalScreenOrientationWasLandscape then
+					self.hasFadedBackgroundInPortrait = true
+				else
+					self.hasFadedBackgroundInLandscape = true
+				end
+			end
+		end
+	end)
+
+	self.thumbstickFrame.Parent = parentFrame
+
+	spawn(function()
+		if game:IsLoaded() then
+			longShowBackground()
+		else
+			game.Loaded:wait()
+			longShowBackground()
+		end
+	end)
+end
+
+return DynamicThumbstick

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/Gamepad.lua

@@ -0,0 +1,234 @@
+--[[
+	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()
+	local self = setmetatable(BaseCharacterController.new(), Gamepad)
+	
+	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
+	
+	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 updateMovement = function(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
+	
+	-- 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.
+	local handleMoveForward = function(actionName, inputState, inputObject)			
+		self.forwardValue = (inputState == Enum.UserInputState.Begin) and -1 or 0
+		updateMovement(inputState)
+	end
+	
+	local handleMoveBackward = function(actionName, inputState, inputObject)	
+		self.backwardValue = (inputState == Enum.UserInputState.Begin) and 1 or 0
+		updateMovement(inputState)
+	end
+	
+	local handleMoveLeft = function(actionName, inputState, inputObject)	
+		self.leftValue = (inputState == Enum.UserInputState.Begin) and -1 or 0
+		updateMovement(inputState)
+	end
+	
+	local handleMoveRight = function(actionName, inputState, inputObject)	
+		self.rightValue = (inputState == Enum.UserInputState.Begin) and 1 or 0
+		updateMovement(inputState)
+	end
+	
+	local handleJumpAction = function(actionName, inputState, inputObject)
+		self.isJumping = (inputState == Enum.UserInputState.Begin)
+	end
+	
+	local handleThumbstickInput = function(actionName, inputState, inputObject)
+		if self.activeGamepad ~= inputObject.UserInputType then return end
+		if inputObject.KeyCode ~= Enum.KeyCode.Thumbstick1 then return end
+		
+		if inputState == Enum.UserInputState.Cancel then
+			self.moveVector = ZERO_VECTOR3
+			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
+	end
+	
+	ContextActionService:BindActivate(self.activeGamepad, Enum.KeyCode.ButtonR2)
+	ContextActionService:BindAction("jumpAction",handleJumpAction, false, Enum.KeyCode.ButtonA)
+	ContextActionService:BindAction("moveThumbstick",handleThumbstickInput, false, 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
+		ContextActionService:UnbindActivate(self.activeGamepad, Enum.KeyCode.ButtonR2)
+	end
+	
+	self.activeGamepad = bestGamepad
+	ContextActionService:BindActivate(self.activeGamepad, Enum.KeyCode.ButtonR2)
+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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/Keyboard.lua

@@ -0,0 +1,149 @@
+--[[
+	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()
+	local self = setmetatable(BaseCharacterController.new(), Keyboard)
+	
+	self.textFocusReleasedConn = nil
+	self.textFocusGainedConn = nil
+	self.windowFocusReleasedConn = nil
+	
+	self.forwardValue  = 0
+	self.backwardValue = 0
+	self.leftValue = 0
+	self.rightValue = 0
+	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
+	
+	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: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.
+	local handleMoveForward = function(actionName, inputState, inputObject)			
+		self.forwardValue = (inputState == Enum.UserInputState.Begin) and -1 or 0
+		self:UpdateMovement(inputState)
+	end
+	
+	local handleMoveBackward = function(actionName, inputState, inputObject)	
+		self.backwardValue = (inputState == Enum.UserInputState.Begin) and 1 or 0
+		self:UpdateMovement(inputState)
+	end
+	
+	local handleMoveLeft = function(actionName, inputState, inputObject)	
+		self.leftValue = (inputState == Enum.UserInputState.Begin) and -1 or 0
+		self:UpdateMovement(inputState)
+	end
+	
+	local handleMoveRight = function(actionName, inputState, inputObject)	
+		self.rightValue = (inputState == Enum.UserInputState.Begin) and 1 or 0
+		self:UpdateMovement(inputState)
+	end
+	
+	local handleJumpAction = function(actionName, inputState, inputObject)
+		self.isJumping = (inputState == Enum.UserInputState.Begin)
+	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:BindAction("moveForwardAction", handleMoveForward, false, Enum.PlayerActions.CharacterForward)
+	ContextActionService:BindAction("moveBackwardAction", handleMoveBackward, false, Enum.PlayerActions.CharacterBackward)
+	ContextActionService:BindAction("moveLeftAction", handleMoveLeft, false, Enum.PlayerActions.CharacterLeft)
+	ContextActionService:BindAction("moveRightAction", handleMoveRight, false, Enum.PlayerActions.CharacterRight)
+	ContextActionService:BindAction("jumpAction",handleJumpAction,false,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.isJumping = false
+	end
+	
+	local function onTextFocusGained(textboxFocused)
+		self.isJumping = false
+	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

RCCService2018/content/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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/TouchDPad.lua

@@ -0,0 +1,176 @@
+--[[
+	
+	
+	
+--]]
+
+local Players = game:GetService("Players")
+local GuiService = game:GetService("GuiService")
+
+--[[ Constants ]]--
+local DPAD_SHEET = "rbxasset://textures/ui/DPadSheet.png"
+local ZERO_VECTOR3 = Vector3.new(0,0,0)
+local COMPASS_DIR = {
+	Vector3.new(1, 0, 0),			-- E
+	Vector3.new(1, 0, 1).unit,		-- SE
+	Vector3.new(0, 0, 1),			-- S
+	Vector3.new(-1, 0, 1).unit,		-- SW
+	Vector3.new(-1, 0, 0),			-- W
+	Vector3.new(-1, 0, -1).unit,	-- NW
+	Vector3.new(0, 0, -1),			-- N
+	Vector3.new(1, 0, -1).unit,		-- NE
+}
+
+
+--[[ The Module ]]--
+local BaseCharacterController = require(script.Parent:WaitForChild("BaseCharacterController"))
+local TouchDPad = setmetatable({}, BaseCharacterController)
+TouchDPad.__index = TouchDPad
+
+function TouchDPad.new()
+	local self = setmetatable(BaseCharacterController.new(), TouchDPad)
+	
+	self.DPadFrame = nil
+	self.touchObject = nil
+	self.flBtn = nil
+	self.frBtn = nil
+	
+	return self
+end
+
+--[[ Local Functions ]]--
+local function CreateArrowLabel(name, position, size, rectOffset, rectSize, parent)
+	local image = Instance.new("ImageLabel")
+	image.Name = name
+	image.Image = DPAD_SHEET
+	image.ImageRectOffset = rectOffset
+	image.ImageRectSize = rectSize
+	image.BackgroundTransparency = 1
+	image.Size = size
+	image.Position = position
+	image.Parent = parent
+	return image
+end
+
+function TouchDPad:GetCenterPosition()
+	return Vector2.new(self.DPadFrame.AbsolutePosition.x + self.DPadFrame.AbsoluteSize.x * 0.5, self.DPadFrame.AbsolutePosition.y + self.DPadFrame.AbsoluteSize.y * 0.5)
+end
+
+function TouchDPad: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.DPadFrame then
+			self:Create(uiParentFrame)
+		end
+		self.DPadFrame.Visible = true
+	else 
+		-- Disable
+		self.DPadFrame.Visible = false
+		self:OnInputEnded()
+	end
+	self.enabled = enable
+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 TouchDPad:GetIsJumping()
+	local wasJumping = self.isJumping
+	self.isJumping = false
+	return wasJumping
+end
+
+function TouchDPad:OnInputEnded()
+	self.touchObject =nil
+	if self.flBtn then self.flBtn.Visible = false end
+	if self.frBtn then self.frBtn.Visible = false end
+	self.moveVector = ZERO_VECTOR3
+end
+
+function TouchDPad:Create(parentFrame)
+	if self.DPadFrame then
+		self.DPadFrame:Destroy()
+		self.DPadFrame = nil
+	end
+	
+	local position = UDim2.new(0, 10, 1, -230)
+	self.DPadFrame = Instance.new("Frame")
+	self.DPadFrame.Name = "DPadFrame"
+	self.DPadFrame.Active = true
+	self.DPadFrame.Visible = false
+	self.DPadFrame.Size = UDim2.new(0, 192, 0, 192)
+	self.DPadFrame.Position = position
+	self.DPadFrame.BackgroundTransparency = 1
+	
+	local smArrowSize = UDim2.new(0, 23, 0, 23)
+	local lgArrowSize = UDim2.new(0, 64, 0, 64)
+	local smImgOffset = Vector2.new(46, 46)
+	local lgImgOffset = Vector2.new(128, 128)
+	
+	local bBtn = CreateArrowLabel("BackButton", UDim2.new(0.5, -32, 1, -64), lgArrowSize, Vector2.new(0, 0), lgImgOffset, self.DPadFrame)
+	local fBtn = CreateArrowLabel("ForwardButton", UDim2.new(0.5, -32, 0, 0), lgArrowSize, Vector2.new(0, 258), lgImgOffset, self.DPadFrame)
+	local lBtn = CreateArrowLabel("LeftButton", UDim2.new(0, 0, 0.5, -32), lgArrowSize, Vector2.new(129, 129), lgImgOffset, self.DPadFrame)
+	local rBtn = CreateArrowLabel("RightButton", UDim2.new(1, -64, 0.5, -32), lgArrowSize, Vector2.new(0, 129), lgImgOffset, self.DPadFrame)
+	local jumpBtn = CreateArrowLabel("JumpButton", UDim2.new(0.5, -32, 0.5, -32), lgArrowSize, Vector2.new(129, 0), lgImgOffset, self.DPadFrame)
+	self.flBtn = CreateArrowLabel("ForwardLeftButton", UDim2.new(0, 35, 0, 35), smArrowSize, Vector2.new(129, 258), smImgOffset, self.DPadFrame)
+	self.frBtn = CreateArrowLabel("ForwardRightButton", UDim2.new(1, -55, 0, 35), smArrowSize, Vector2.new(176, 258), smImgOffset, self.DPadFrame)
+	self.flBtn.Visible = false
+	self.frBtn.Visible = false
+	
+	-- input connections
+	jumpBtn.InputBegan:Connect(function(inputObject)
+		self.isJumping = true
+	end)
+	
+	local function normalizeDirection(inputPosition)
+		local jumpRadius = jumpBtn.AbsoluteSize.x*0.5
+		local centerPosition = self:GetCenterPosition()
+		local direction = Vector2.new(inputPosition.x - centerPosition.x, inputPosition.y - centerPosition.y)
+		
+		if direction.magnitude > jumpRadius then
+			local angle = math.atan2(direction.y, direction.x)
+			local octant = (math.floor(8 * angle / (2 * math.pi) + 8.5)%8) + 1
+			self.moveVector = COMPASS_DIR[octant]
+		end
+		
+		if not self.flBtn.Visible and self.moveVector == COMPASS_DIR[7] then
+			self.flBtn.Visible = true
+			self.frBtn.Visible = true
+		end
+	end
+	
+	self.DPadFrame.InputBegan:Connect(function(inputObject)
+		if self.touchObject or inputObject.UserInputType ~= Enum.UserInputType.Touch then
+			return
+		end
+		
+		self.touchObject = inputObject
+		normalizeDirection(self.touchObject.Position)
+	end)
+	
+	self.DPadFrame.InputChanged:Connect(function(inputObject)
+		if inputObject == self.touchObject then
+			normalizeDirection(self.touchObject.Position)
+			self.isJumping = false
+		end
+	end)
+	
+	self.DPadFrame.InputEnded:connect(function(inputObject)
+		if inputObject == self.touchObject then
+			self:OnInputEnded()
+		end
+	end)
+	
+	GuiService.MenuOpened:Connect(function()
+		if self.touchObject then
+			self:OnInputEnded()
+		end
+	end)
+	
+	self.DPadFrame.Parent = parentFrame
+end
+
+return TouchDPad

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/TouchJump.lua

@@ -0,0 +1,201 @@
+--[[
+	// 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(176, 222)
+	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)
+	self.parentUIFrame = parentFrame
+	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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/TouchThumbpad.lua

@@ -0,0 +1,247 @@
+--[[
+	
+	TouchThumbpad
+	
+--]]
+
+local Players = game:GetService("Players")
+local UserInputService = game:GetService("UserInputService")
+local GuiService = game:GetService("GuiService")
+
+--[[ Constants ]]--
+local DPAD_SHEET = "rbxasset://textures/ui/DPadSheet.png"
+local TOUCH_CONTROL_SHEET = "rbxasset://textures/ui/TouchControlsSheet.png"
+local ZERO_VECTOR3 = Vector3.new(0,0,0)
+local UNIT_Z = Vector3.new(0,0,1)
+local UNIT_X = Vector3.new(1,0,0)
+
+--[[ The Module ]]--
+local BaseCharacterController = require(script.Parent:WaitForChild("BaseCharacterController"))
+local TouchThumbpad = setmetatable({}, BaseCharacterController)
+TouchThumbpad.__index = TouchThumbpad
+
+function TouchThumbpad.new()
+	local self = setmetatable(BaseCharacterController.new(), TouchThumbpad)
+	
+	self.thumbpadFrame = nil
+	self.touchChangedConn = nil
+	self.touchEndedConn = nil
+	self.menuOpenedConn = nil
+	self.screenPos = nil
+	self.isRight, self.isLeft, self.isUp, self.isDown = false, false, false, false
+	self.smArrowSize = nil
+	self.lgArrowSize = nil
+	self.smImgOffset = nil
+	self.lgImgOffset = nil
+	return self
+end
+
+--[[ Local Helper Functions ]]--
+local function doTween(guiObject, endSize, endPosition)
+	guiObject:TweenSizeAndPosition(endSize, endPosition, Enum.EasingDirection.InOut, Enum.EasingStyle.Linear, 0.15, true)
+end
+
+local function CreateArrowLabel(name, position, size, rectOffset, rectSize, parent)
+	local image = Instance.new("ImageLabel")
+	image.Name = name
+	image.Image = DPAD_SHEET
+	image.ImageRectOffset = rectOffset
+	image.ImageRectSize = rectSize
+	image.BackgroundTransparency = 1
+	image.ImageColor3 = Color3.fromRGB(190, 190, 190)
+	image.Size = size
+	image.Position = position
+	image.Parent = parent
+	return image
+end
+
+function TouchThumbpad: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.thumbpadFrame then
+			self:Create(uiParentFrame)
+		end
+		self.thumbpadFrame.Visible = true
+	else 
+		-- Disable
+		self.thumbpadFrame.Visible = false
+		self:OnInputEnded()
+	end
+	self.enabled = enable
+end
+	
+function TouchThumbpad:OnInputEnded()
+	self.moveVector = Vector3.new(0,0,0)
+	self.isJumping = false
+
+	self.thumbpadFrame.Position = self.screenPos
+	self.touchObject = nil
+	self.isUp, self.isDown, self.isLeft, self.isRight = false, false, false, false
+	doTween(self.dArrow, self.smArrowSize, UDim2.new(0.5, -0.5*self.smArrowSize.X.Offset, 1, self.lgImgOffset))
+	doTween(self.uArrow, self.smArrowSize, UDim2.new(0.5, -0.5*self.smArrowSize.X.Offset, 0, self.smImgOffset))
+	doTween(self.lArrow, self.smArrowSize, UDim2.new(0, self.smImgOffset, 0.5, -0.5*self.smArrowSize.Y.Offset))
+	doTween(self.rArrow, self.smArrowSize, UDim2.new(1, self.lgImgOffset, 0.5, -0.5*self.smArrowSize.Y.Offset))
+end
+
+function TouchThumbpad:Create(parentFrame)
+	if self.thumbpadFrame then
+		self.thumbpadFrame:Destroy()
+		self.thumbpadFrame = nil
+	end
+	if self.touchChangedConn then
+		self.touchChangedConn:Disconnect()
+		self.touchChangedConn = nil
+	end
+	if self.touchEndedConn then
+		self.touchEndedConn:Disconnect()
+		self.touchEndedConn = nil
+	end
+	if self.menuOpenedConn then
+		self.menuOpenedConn:Disconnect()
+		self.menuOpenedConn = nil
+	end
+	
+	local minAxis = math.min(parentFrame.AbsoluteSize.x, parentFrame.AbsoluteSize.y)
+	local isSmallScreen = minAxis <= 500
+	local thumbpadSize = isSmallScreen and 70 or 120
+	self.screenPos = isSmallScreen and UDim2.new(0, thumbpadSize * 1.25, 1, -thumbpadSize - 20) or
+		UDim2.new(0, thumbpadSize * 0.5 - 10, 1, -thumbpadSize * 1.75 - 10)
+	
+	self.thumbpadFrame = Instance.new("Frame")
+	self.thumbpadFrame.Name = "ThumbpadFrame"
+	self.thumbpadFrame.Visible = false
+	self.thumbpadFrame.Active = true
+	self.thumbpadFrame.Size = UDim2.new(0, thumbpadSize + 20, 0, thumbpadSize + 20)
+	self.thumbpadFrame.Position = self.screenPos
+	self.thumbpadFrame.BackgroundTransparency = 1
+	
+	local outerImage = Instance.new("ImageLabel")
+	outerImage.Name = "OuterImage"
+	outerImage.Image = TOUCH_CONTROL_SHEET
+	outerImage.ImageRectOffset = Vector2.new(0, 0)
+	outerImage.ImageRectSize = Vector2.new(220, 220)
+	outerImage.BackgroundTransparency = 1
+	outerImage.Size = UDim2.new(0, thumbpadSize, 0, thumbpadSize)
+	outerImage.Position = UDim2.new(0, 10, 0, 10)
+	outerImage.Parent = self.thumbpadFrame
+	
+	self.smArrowSize = isSmallScreen and UDim2.new(0, 32, 0, 32) or UDim2.new(0, 64, 0, 64)
+	self.lgArrowSize = UDim2.new(0, self.smArrowSize.X.Offset * 2, 0, self.smArrowSize.Y.Offset * 2)
+	local imgRectSize = Vector2.new(110, 110)
+	self.smImgOffset = isSmallScreen and -4 or -9
+	self.lgImgOffset = isSmallScreen and -28 or -55
+	
+	self.dArrow = CreateArrowLabel("DownArrow", UDim2.new(0.5, -0.5*self.smArrowSize.X.Offset, 1, self.lgImgOffset), self.smArrowSize, Vector2.new(8, 8), imgRectSize, outerImage)
+	self.uArrow = CreateArrowLabel("UpArrow", UDim2.new(0.5, -0.5*self.smArrowSize.X.Offset, 0, self.smImgOffset), self.smArrowSize, Vector2.new(8, 266), imgRectSize, outerImage)
+	self.lArrow = CreateArrowLabel("LeftArrow", UDim2.new(0, self.smImgOffset, 0.5, -0.5*self.smArrowSize.Y.Offset), self.smArrowSize, Vector2.new(137, 137), imgRectSize, outerImage)
+	self.rArrow = CreateArrowLabel("RightArrow", UDim2.new(1, self.lgImgOffset, 0.5, -0.5*self.smArrowSize.Y.Offset), self.smArrowSize, Vector2.new(8, 137), imgRectSize, outerImage)
+	
+	local function doTween(guiObject, endSize, endPosition)
+		guiObject:TweenSizeAndPosition(endSize, endPosition, Enum.EasingDirection.InOut, Enum.EasingStyle.Linear, 0.15, true)
+	end
+	
+	local padOrigin = nil
+	local deadZone = 0.1
+	self.isRight, self.isLeft, self.isUp, self.isDown = false, false, false, false
+	
+	local function doMove(pos)
+		
+		local moveDelta = pos - padOrigin
+		local moveVector2 = 2 * moveDelta / thumbpadSize
+		
+		-- Scaled Radial Dead Zone
+		if moveVector2.Magnitude < deadZone then
+			self.moveVector = ZERO_VECTOR3
+		else
+			moveVector2 = moveVector2.unit * ((moveVector2.Magnitude - deadZone) / (1 - deadZone))
+			
+			-- prevent NAN Vector from trying to do zerovector.Unit
+			if moveVector2.Magnitude == 0 then
+				self.moveVector = ZERO_VECTOR3
+			else
+				self.moveVector = Vector3.new(moveVector2.x, 0, moveVector2.y).Unit
+			end
+		end
+		
+		local forwardDot = self.moveVector:Dot(-UNIT_Z)
+		local rightDot = self.moveVector:Dot(UNIT_X)
+		
+		if forwardDot > 0.5 then		-- UP
+			if not self.isUp then
+				self.isUp, self.isDown = true, false
+				doTween(self.uArrow, self.lgArrowSize, UDim2.new(0.5, -self.smArrowSize.X.Offset, 0, self.smImgOffset - 1.5*self.smArrowSize.Y.Offset))
+				doTween(self.dArrow, self.smArrowSize, UDim2.new(0.5, -0.5*self.smArrowSize.X.Offset, 1, self.lgImgOffset))
+			end
+		elseif forwardDot < -0.5 then	-- DOWN
+			if not self.isDown then
+				self.isDown, self.isUp = true, false
+				doTween(self.dArrow, self.lgArrowSize, UDim2.new(0.5, -self.smArrowSize.X.Offset, 1, self.lgImgOffset + 0.5*self.smArrowSize.Y.Offset))
+				doTween(self.uArrow, self.smArrowSize, UDim2.new(0.5, -0.5*self.smArrowSize.X.Offset, 0, self.smImgOffset))
+			end
+		else
+			self.isUp, self.isDown = false, false
+			doTween(self.dArrow, self.smArrowSize, UDim2.new(0.5, -0.5*self.smArrowSize.X.Offset, 1, self.lgImgOffset))
+			doTween(self.uArrow, self.smArrowSize, UDim2.new(0.5, -0.5*self.smArrowSize.X.Offset, 0, self.smImgOffset))
+		end
+		
+		if rightDot > 0.5 then
+			if not self.isRight then
+				self.isRight, self.isLeft = true, false
+				doTween(self.rArrow, self.lgArrowSize, UDim2.new(1, self.lgImgOffset + 0.5*self.smArrowSize.X.Offset, 0.5, -self.smArrowSize.Y.Offset))
+				doTween(self.lArrow, self.smArrowSize, UDim2.new(0, self.smImgOffset, 0.5, -0.5*self.smArrowSize.Y.Offset))
+			end
+		elseif rightDot < -0.5 then
+			if not self.isLeft then
+				self.isLeft, self.isRight = true, false
+				doTween(self.lArrow, self.lgArrowSize, UDim2.new(0, self.smImgOffset - 1.5*self.smArrowSize.X.Offset, 0.5, -self.smArrowSize.Y.Offset))
+				doTween(self.rArrow, self.smArrowSize, UDim2.new(1, self.lgImgOffset, 0.5, -0.5*self.smArrowSize.Y.Offset))
+			end
+		else
+			self.isRight, self.isLeft = false, false
+			doTween(self.lArrow, self.smArrowSize, UDim2.new(0, self.smImgOffset, 0.5, -0.5*self.smArrowSize.Y.Offset))
+			doTween(self.rArrow, self.smArrowSize, UDim2.new(1, self.lgImgOffset, 0.5, -0.5*self.smArrowSize.Y.Offset))
+		end
+	end
+	
+	--input connections
+	self.thumbpadFrame.InputBegan:connect(function(inputObject)
+		--A touch that starts elsewhere on the screen will be sent to a frame's InputBegan event
+		--if it moves over the frame. So we check that this is actually a new touch (inputObject.UserInputState ~= Enum.UserInputState.Begin)
+		if self.touchObject or inputObject.UserInputType ~= Enum.UserInputType.Touch
+			or inputObject.UserInputState ~= Enum.UserInputState.Begin then
+			return
+		end
+		
+		self.thumbpadFrame.Position = UDim2.new(0, inputObject.Position.x - 0.5*self.thumbpadFrame.AbsoluteSize.x, 0, inputObject.Position.y - 0.5*self.thumbpadFrame.Size.Y.Offset)
+		padOrigin = Vector3.new(self.thumbpadFrame.AbsolutePosition.x +0.5* self.thumbpadFrame.AbsoluteSize.x,
+			self.thumbpadFrame.AbsolutePosition.y + 0.5*self.thumbpadFrame.AbsoluteSize.y, 0)
+		doMove(inputObject.Position)
+		self.touchObject = inputObject
+	end)
+	
+	self.touchChangedConn = UserInputService.TouchMoved:connect(function(inputObject, isProcessed)
+		if inputObject == self.touchObject then
+			doMove(self.touchObject.Position)
+		end
+	end)
+	
+	self.touchEndedConn = UserInputService.TouchEnded:Connect(function(inputObject)
+		if inputObject == self.touchObject then
+			self:OnInputEnded()
+		end
+	end)
+	
+	self.menuOpenedConn = GuiService.MenuOpened:Connect(function()
+		if self.touchObject then
+			self:OnInputEnded()
+		end
+	end)	
+	
+	self.thumbpadFrame.Parent = parentFrame
+end
+
+return TouchThumbpad

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/TouchThumbstick.lua

@@ -0,0 +1,194 @@
+--[[
+	
+	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
+	
+	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 = Vector3.new(0,0,0)
+	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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/VRNavigation.lua

@@ -0,0 +1,448 @@
+
+--[[
+		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 STOPPING_DISTANCE = 4
+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()
+	local self = setmetatable(BaseCharacterController.new(), VRNavigation)
+	
+	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
+end
+function VRNavigation:BindJumpAction(active)
+	if active then
+		if not self.isJumpBound then
+			self.isJumpBound = true
+			ContextActionService:BindAction("VRJumpAction", (function() self:OnJumpAction() end), false, 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
+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)
+	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) self:ControlCharacterGamepad(actionName, inputState, inputObject) end), false, Enum.KeyCode.Thumbstick1)
+		ContextActionService:BindActivate(Enum.UserInputType.Gamepad1, Enum.KeyCode.ButtonR2)	
+		
+		self.userCFrameEnabledConn = VRService.UserCFrameEnabled:Connect(function() self:OnUserCFrameEnabled() end)
+		self:OnUserCFrameEnabled()
+	
+		pcall(function()
+			VRService:SetTouchpadMode(Enum.VRTouchpad.Left, Enum.VRTouchpadMode.VirtualThumbstick)
+			VRService:SetTouchpadMode(Enum.VRTouchpad.Right, Enum.VRTouchpadMode.ABXY)
+		end)
+		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

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerModule.module/ControlModule/VehicleController.lua

@@ -0,0 +1,104 @@
+--[[
+	// 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")
+local Players = game:GetService("Players")
+local RunService = game:GetService("RunService")
+
+--[[ 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)
+
+-- Note that VehicleController does not derive from BaseCharacterController, it is a special case
+local VehicleController = {}
+VehicleController.__index = VehicleController
+
+function VehicleController.new()
+	local self = setmetatable({}, VehicleController)
+	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
+
+	return self
+end
+
+function VehicleController:Enable(enable, vehicleSeat)
+	if enable == self.enabled and vehicleSeat == self.vehicleSeat then
+		return
+	end
+	
+	if enable then
+		if vehicleSeat then
+			self.vehicleSeat = vehicleSeat
+			if useTriggersForThrottle then
+				ContextActionService:BindAction("throttleAccel", (function() self:OnThrottleAccel() end), false, Enum.KeyCode.ButtonR2)
+				ContextActionService:BindAction("throttleDeccel", (function() self:OnThrottleDeccel() end), false, Enum.KeyCode.ButtonL2)
+			end
+			ContextActionService:BindAction("arrowSteerRight", (function() self:OnSteerRight() end), false, Enum.KeyCode.Right)
+			ContextActionService:BindAction("arrowSteerLeft", (function() self:OnSteerLeft() end), false, Enum.KeyCode.Left)
+		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)	
+	self.acceleration = (inputState ~= Enum.UserInputState.End) and -1 or 0
+	self.throttle = self.acceleration + self.decceleration
+end
+
+function VehicleController:OnThrottleDeccel(actionName, inputState, inputObject)
+	self.decceleration = (inputState ~= Enum.UserInputState.End) and 1 or 0
+	self.throttle = self.acceleration + self.decceleration
+end
+
+function VehicleController:OnSteerRight(actionName, inputState, inputObject)
+	self.turningRight = (inputState ~= Enum.UserInputState.End) and 1 or 0
+	self.steer = self.turningRight + self.turningLeft
+end
+
+function VehicleController:OnSteerLeft(actionName, inputState, inputObject)
+	self.turningLeft = (inputState ~= Enum.UserInputState.End) and -1 or 0
+	self.steer = self.turningRight + self.turningLeft
+end
+
+-- Call this from a function bound to Renderstep with Input Priority
+function VehicleController:Update(moveVector, usingGamepad)
+	if self.vehicleSeat then
+		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
+	end
+	return moveVector, false
+end
+
+return VehicleController

RCCService2018/content/scripts/PlayerScripts/StarterPlayerScripts_NewStructure/PlayerScriptsLoader.lua

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