Prompt: --[[ Private Functions ]]

Response:
--
local function getVehicleMotors()
	local motors = {}
	for _, c in pairs(constraints:GetChildren()) do
		if c:IsA("CylindricalConstraint") then
			table.insert(motors, c)
        end
    end
	return motors
end

local function getSprings(springType)
	local springs = {}
	local trailer = PackagedVehicle:FindFirstChild("Trailer")

	local function search(children)
		local searchStrutSpring = "StrutSpring"
		local searchFrontSpring = "StrutSpringF"
		local searchTorsionSpring = "TorsionBarSpring"
		for _, c in pairs(children) do
			if c:IsA("SpringConstraint") then
				if springType == "StrutFront" then
					if string.find(c.Name, searchFrontSpring) then
						table.insert(springs, c)
					end
				elseif springType == "StrutRear" then
					if (not string.find(c.Name, searchFrontSpring)) and string.find(c.Name, searchStrutSpring) then
						table.insert(springs, c) -- we have option of Mid and Rear for these
					end
				elseif springType == "TorsionBar" then
					if string.find(c.Name, searchTorsionSpring) then
						table.insert(springs, c)
					end
				end
			end
		end
	end

	search(constraints:GetChildren())
	if trailer then
		search(trailer.Constraints:GetChildren())
	end

	return springs
end

local function getMotorVelocity(motor)
	return motor.Attachment1.WorldAxis:Dot( motor.Attachment1.Parent.RotVelocity )
end

local function adjustSpring( spring, stiffness, damping )
	spring.Stiffness = stiffness
	spring.Damping = damping
end

local function setMotorTorque(torque)
	for _, motor in pairs(Motors) do
		motor.MotorMaxTorque = torque
	end
end

local function setMotorTorqueDamped(torque, velocityDirection, accelDirection)
	for _, motor in pairs(Motors) do
		if VehicleParameters.MaxSpeed == 0 then
			motor.MotorMaxTorque = 0
		else
			local maxSpeed = VehicleParameters.MaxSpeed
			if accelDirection < 0 and velocityDirection < 0 then
				maxSpeed = VehicleParameters.ReverseSpeed
			end

			local r = math.abs(Chassis.driverSeat.Velocity.Magnitude / maxSpeed)
			motor.MotorMaxTorque = math.exp( -3 * r * r ) * torque
		end
	end
end

local function setMotorMaxAcceleration(acceleration)
	for _, motor in pairs(Motors) do
		motor.MotorMaxAngularAcceleration = acceleration
	end
end


Prompt:
--[[**
	ensure value is an Instance and it's ClassName matches the given ClassName

	@param className The class name to check for

	@returns A function that will return true iff the condition is passed
**--]]

Response:
function t.instanceOf(className, childTable)
	assert(t.string(className))

	local childrenCheck
	if childTable ~= nil then
		childrenCheck = t.children(childTable)
	end

	return function(value)
		local instanceSuccess, instanceErrMsg = t.Instance(value)
		if not instanceSuccess then
			return false, instanceErrMsg or ""
		end

		if value.ClassName ~= className then
			return false, string.format("%s expected, got %s", className, value.ClassName)
		end

		if childrenCheck then
			local childrenSuccess, childrenErrMsg = childrenCheck(value)
			if not childrenSuccess then
				return false, childrenErrMsg
			end
		end

		return true
	end
end
t.instance = t.instanceOf


Prompt: --//Services//--

Response:
local TweenService = game:GetService("TweenService")
local RunService = game:GetService("RunService")


Prompt:
--[[
	Returns true if the object is protected by a forcefield
--]]

Response:
return function(obj)
	local protected = false
	local check = obj
	while true do
		local hasFF = false
		for index, child in next, check:GetChildren() do
			if child:IsA'ForceField' then
				hasFF = true
				break
			end
		end
		if hasFF then
			protected = true
			break
		else
			check = check.Parent
			if check == nil or check == game or check.Parent == game then
				break
			end
		end
	end

	return protected
end


Prompt: -- Movement mode standardized to Enum.ComputerCameraMovementMode values

Response:
function ClassicCamera:SetCameraMovementMode(cameraMovementMode)
	BaseCamera.SetCameraMovementMode(self, cameraMovementMode)

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

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

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

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

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

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

	local rotateInput = CameraInput.getRotation()

	self:StepZoom()

	local cameraHeight = self:GetCameraHeight()

	-- Reset tween speed if user is panning
	if CameraInput.getRotation() ~= Vector2.new() 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:CalculateNewLookCFrameFromArg(overrideCameraLookVector, rotateInput)

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

			--offset can be NAN, NAN, NAN if newLookVector has only y component
			if Util.IsFiniteVector3(cameraRelativeOffset) then
				subjectPosition = subjectPosition + cameraRelativeOffset
			end
		else
			local userPanningTheCamera = CameraInput.getRotation() ~= Vector2.new()

			if not userPanningTheCamera and self.lastCameraTransform then

				local isInFirstPerson = self:IsInFirstPerson()

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

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

						local y = Util.GetAngleBetweenXZVectors(forwardVector, self:GetCameraLookVector())
						if Util.IsFinite(y) and math.abs(y) > 0.0001 then
							rotateInput = 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
						rotateInput = rotateInput + Vector2.new(y, 0)
					end
				end
			end
		end

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

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

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

				local flaggedRotateInput = rotateInput

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

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

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

		local toggleOffset = self:GetCameraToggleOffset(timeDelta)
		newCameraFocus = newCameraFocus + toggleOffset
		newCameraCFrame = newCameraCFrame + toggleOffset

		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


Response:
function tagHumanoid(humanoid)
	local plr=game.Players:playerFromCharacter(sp.Parent)
	if plr~=nil then
		local tag=Instance.new("ObjectValue")
		tag.Value=plr
		tag.Name="creator"
		tag.Parent=humanoid
		delay(2,function()
			if tag~=nil then
				tag.Parent=nil
			end
		end)
	end
end

function reload(mouse)
	reloading=true
	mouse.Icon=ReloadCursor
	while sp.Ammo.Value<ClipSize and reloading and enabled do
		wait(ReloadTime/ClipSize)
		if reloading then
			sp.Ammo.Value=sp.Ammo.Value+1
			check()
		else
			break
		end
	end
	check()
	mouse.Icon=Cursors[1]
	reloading=false
end

function onKeyDown(key,mouse)
	key=key:lower()
	if key=="r" and not reloading then
		reload(mouse)
	end
end

function movecframe(p,pos)
	p.Parent=game.Lighting
	p.Position=pos
	p.Parent=game.Workspace
end

function fire(aim)
	sp.Handle.Fire:Play()

	t=r.Stepped:wait()
	last6=last5
	last5=last4
	last4=last3
	last3=last2
	last2=last
	last=t

	local bullet=Bullet:clone()
	local bt2=game.Lighting.BulletTexture:clone()
	bt2.BrickColor=BrickColor.new("Bright red")
	bt2.Mesh.Scale=Vector3.new(.5,.5,2)
	local totalDist=0
	Lengthdist=-RayLength/.5
	local startpoint=sp.Handle.CFrame*BarrlePos
	local dir=(aim)-startpoint
	dir=computeDirection(dir)
	local cfrm=CFrame.new(startpoint, dir+startpoint)
	local hit,pos,normal,time=raycast(game.Workspace, startpoint, cfrm*Vector3.new(0,0,Lengthdist)-startpoint, function(brick)
		if brick.Name=="Glass" then
			return true
		elseif brick.Name=="Bullet" or brick.Name=="BulletTexture" then
			return false
		elseif brick:IsDescendantOf(sp.Parent) then
			return false
		elseif brick.Name=="Handle" then
			if brick.Parent:IsDescendantOf(sp.Parent) then
				return false
			else
				return true
			end
		end
		return true
	end)
	bullet.Parent=game.Workspace
	bt2.Parent=game.Workspace
	if hit~=nil then
		local humanoid=hit.Parent:FindFirstChild("Humanoid")
		if humanoid~=nil then
			local damage=math.random(BaseDamage-(BaseDamage*.25),BaseDamage+(BaseDamage*.25))
			if hit.Name=="Head" then
				damage=damage*1.25
			elseif hit.Name=="Torso" then
			else
				damage=damage*.75
			end
			if humanoid.Health>0 then
				local eplr=game.Players:playerFromCharacter(humanoid.Parent)
				local plr=game.Players:playerFromCharacter(sp.Parent)
				if eplr~=nil and plr~=nil then
				--	if eplr.TeamColor~=plr.TeamColor or eplr.Neutral or plr.Neutral then
						tagHumanoid(humanoid)
						humanoid:TakeDamage(damage)
				--	end
				else
					tagHumanoid(humanoid)
					humanoid:TakeDamage(damage)
				end
			end
		end
		if (hit.Name == "Part10") or (hit.Name == "Part11") or (hit.Name == "Part21") or (hit.Name == "Part23") or (hit.Name == "Part24") or (hit.Name == "Part8") then
			rand = math.random(1,5)
			if rand == 1 then
				workspace.GlassSound:play()
				hit:breakJoints()
			end
		end
		if (hit.Parent:findFirstChild("Hit")) then
			hit.Parent.Health.Value = hit.Parent.Health.Value - BaseDamage/3
		end
		distance=(startpoint-pos).magnitude
		bullet.CFrame=cfrm*CFrame.new(0,0,-distance/2)
		bullet.Mesh.Scale=Vector3.new(.15,.15,distance)
	else
		bullet.CFrame=cfrm*CFrame.new(0,0,-RayLength/2)
		bullet.Mesh.Scale=Vector3.new(.15,.15,RayLength)
	end
	if pos~=nil then
		bt2.CFrame=bullet.CFrame
		movecframe(bt2,pos)
	end
	local deb=game:FindFirstChild("Debris")
	if deb==nil then
		local debris=Instance.new("Debris")
		debris.Parent=game
	end
	check()
	game.Debris:AddItem(bullet,.05)
	game.Debris:AddItem(bt2,.5)
end

function onButton1Up(mouse)
	down=false
end

function onButton1Down(mouse)
	h=sp.Parent:FindFirstChild("Humanoid")
	if not enabled or reloading or down or h==nil then
		return
	end
	if sp.Ammo.Value>0 and h.Health>0 then
		--[[if sp.Ammo.Value<=0 then
			if not reloading then
				reload(mouse)
			end
			return
		end]]
		down=true
		enabled=false
		while down do
			if sp.Ammo.Value<=0 then
				break
			end
			if burst then
				local startpoint=sp.Handle.CFrame*BarrlePos
				local mag=(mouse.Hit.p-startpoint).magnitude
				local rndm=Vector3.new(math.random(-(Spread/10)*mag,(Spread/10)*mag),math.random(-(Spread/10)*mag,(Spread/10)*mag),math.random(-(Spread/10)*mag,(Spread/10)*mag))
				fire(mouse.Hit.p+rndm)
				sp.Ammo.Value=sp.Ammo.Value-1
				if sp.Ammo.Value<=0 then
					break
				end
				wait(.05)
				local startpoint=sp.Handle.CFrame*BarrlePos
				local mag2=((mouse.Hit.p+rndm)-startpoint).magnitude
				local rndm2=Vector3.new(math.random(-(.1/10)*mag2,(.1/10)*mag2),math.random(-(.1/10)*mag2,(.1/10)*mag2),math.random(-(.1/10)*mag2,(.1/10)*mag2))
				fire(mouse.Hit.p+rndm+rndm2)
				sp.Ammo.Value=sp.Ammo.Value-1
				if sp.Ammo.Value<=0 then
					break
				end
				wait(.05)
				fire(mouse.Hit.p+rndm+rndm2+rndm2)
				sp.Ammo.Value=sp.Ammo.Value-1
			elseif shot then
				sp.Ammo.Value=sp.Ammo.Value-1
				local startpoint=sp.Handle.CFrame*BarrlePos
				local mag=(mouse.Hit.p-startpoint).magnitude
				local rndm=Vector3.new(math.random(-(Spread/10)*mag,(Spread/10)*mag),math.random(-(Spread/10)*mag,(Spread/10)*mag),math.random(-(Spread/10)*mag,(Spread/10)*mag))
				fire(mouse.Hit.p+rndm)
				local mag2=((mouse.Hit.p+rndm)-startpoint).magnitude
				local rndm2=Vector3.new(math.random(-(.2/10)*mag2,(.2/10)*mag2),math.random(-(.2/10)*mag2,(.2/10)*mag2),math.random(-(.2/10)*mag2,(.2/10)*mag2))
				fire(mouse.Hit.p+rndm+rndm2)
				local rndm3=Vector3.new(math.random(-(.2/10)*mag2,(.2/10)*mag2),math.random(-(.2/10)*mag2,(.2/10)*mag2),math.random(-(.2/10)*mag2,(.2/10)*mag2))
				fire(mouse.Hit.p+rndm+rndm3)
				local rndm4=Vector3.new(math.random(-(.2/10)*mag2,(.2/10)*mag2),math.random(-(.2/10)*mag2,(.2/10)*mag2),math.random(-(.2/10)*mag2,(.2/10)*mag2))
				fire(mouse.Hit.p+rndm+rndm4)
			else
				sp.Ammo.Value=sp.Ammo.Value-1
				local startpoint=sp.Handle.CFrame*BarrlePos
				local mag=(mouse.Hit.p-startpoint).magnitude
				local rndm=Vector3.new(math.random(-(Spread/10)*mag,(Spread/10)*mag),math.random(-(Spread/10)*mag,(Spread/10)*mag),math.random(-(Spread/10)*mag,(Spread/10)*mag))
				fire(mouse.Hit.p+rndm)
			end
			wait(Firerate)
			if not automatic then
				break
			end
		end
		enabled=true
	else
		sp.Handle.Trigger:Play()
	end
end

function onEquippedLocal(mouse)
	if mouse==nil then
		print("Mouse not found")
		return
	end
	mouse.Icon=Cursors[1]
	mouse.KeyDown:connect(function(key) onKeyDown(key,mouse) end)
	mouse.Button1Down:connect(function() onButton1Down(mouse) end)
	mouse.Button1Up:connect(function() onButton1Up(mouse) end)
	check()
	equiped=true
	if #Cursors>1 then
		while equiped do
			t=r.Stepped:wait()
			local action=sp.Parent:FindFirstChild("Pose")
			if action~=nil then
				if sp.Parent.Pose.Value=="Standing" then
					Spread=MinSpread
				else
					Spread=MinSpread+((1/10)*(MaxSpread-MinSpread))
				end
			else
				Spread=MinSpread
			end
			if t-last<SpreadRate then
				Spread=Spread+.1*(MaxSpread-MinSpread)
			end
			if t-last2<SpreadRate then
				Spread=Spread+.1*(MaxSpread-MinSpread)
			end
			if t-last3<SpreadRate then
				Spread=Spread+.1*(MaxSpread-MinSpread)
			end
			if t-last4<SpreadRate then
				Spread=Spread+.1*(MaxSpread-MinSpread)
			end
			if t-last5<SpreadRate then
				Spread=Spread+.1*(MaxSpread-MinSpread)
			end
			if t-last6<SpreadRate then
				Spread=Spread+.1*(MaxSpread-MinSpread)
			end
			if not reloading then
				local percent=(Spread-MinSpread)/(MaxSpread-MinSpread)
				for i=0,#Cursors-1 do
					if percent>(i/(#Cursors-1))-((1/(#Cursors-1))/2) and percent<(i/(#Cursors-1))+((1/(#Cursors-1))/2) then
						mouse.Icon=Cursors[i+1]
					end
				end
			end
			wait(Firerate*.9)
		end
	end
end
function onUnequippedLocal(mouse)
	equiped=false
	reloading=false
end
sp.Equipped:connect(onEquippedLocal)
sp.Unequipped:connect(onUnequippedLocal)
check()


Prompt: --Stickmasterluke

Response:
sp=script.Parent

powertime=3

equipped=false
powered=false

while sp:FindFirstChild("ElectricWeld")==nil do
	wait()
end
local storeweld=sp.ElectricWeld
local initCF = storeweld.C0

sp.Handle.Touched:connect(function(hit)
	if hit~=nil and powered then
		local eh=hit.Parent:FindFirstChild("Humanoid")
		local h=sp.Parent:FindFirstChild("Humanoid")
		if h~=nil and eh~=nil and h~=eh then
			if h.Health>0 and eh.Health>0 and h.Parent:FindFirstChild("GetTasedBro")==nil then
				--[[powered=false
				sp.Enabled=false]]
				local ts=script.GetTasedBro:clone()
				ts.Parent=hit.Parent
				ts.Disabled=false
			end
		end
	end
end)

sp.Activated:connect(function()
	local chr=sp.Parent
	local h=chr:FindFirstChild("Humanoid")
	if h~=nil then
		if h.Health>0 and not powered then
			sp.Enabled=false
			powered=true
			local s=sp.Handle:FindFirstChild("Sound")
			if s~=nil then
				s:Play()
			end
			delay(0,function()
				local ii=0
				while powered do
					ii=ii+1
					if storeweld and ii%2==0 then
						storeweld.C0 = initCF * CFrame.Angles(0, 0, math.random()/3.0) --* CFrame.Angles(0, 1.3, 0)
					end
					local pain=sp:FindFirstChild("Pain")
					if pain~=nil then
						pain.Transparency=ii%2
					end
					wait(.1)
				end
				storeweld.C0 = initCF
				local s=sp.Handle:FindFirstChild("Sound")
				if s~=nil then
					s:Stop()
				end
				local pain=sp:FindFirstChild("Pain")
				if pain~=nil then
					pain.Transparency=1
				end
			end)
			wait(powertime)
			sp.Enabled=true
			powered=false
		end
	end
end)

sp.Equipped:connect(function()
	equipped=true
	powered=false
	local pain=sp:FindFirstChild("Pain")
	if pain~=nil then
		pain.Transparency=1
	end
	if storeweld then
		storeweld.Parent=sp
	end
end)
sp.Unequipped:connect(function()
	powered=false
	equipped=false
end)


Prompt: ---vars

Response:
local Template = script.Template
local Plr = script.Parent.Parent.Parent
local CarStorage = game.ReplicatedStorage.Vehicles
local ScrollFrame = script.Parent.MainFrame.ScrollingFrame


Prompt:
--////////////////////////////////////////////////////////////////////////////////////////////
--////////////////////////////////////////////////////////////// Code to do chat window fading
--////////////////////////////////////////////////////////////////////////////////////////////

Response:
function CheckIfPointIsInSquare(checkPos, topLeft, bottomRight)
	return (topLeft.X <= checkPos.X and checkPos.X <= bottomRight.X and
		topLeft.Y <= checkPos.Y and checkPos.Y <= bottomRight.Y)
end

local backgroundIsFaded = false
local textIsFaded = false
local lastTextFadeTime = 0
local lastBackgroundFadeTime = 0

local fadedChanged = Instance.new("BindableEvent")
local mouseStateChanged = Instance.new("BindableEvent")
local chatBarFocusChanged = Instance.new("BindableEvent")

function DoBackgroundFadeIn(setFadingTime)
	lastBackgroundFadeTime = tick()
	backgroundIsFaded = false
	fadedChanged:Fire()
	ChatWindow:FadeInBackground((setFadingTime or ChatSettings.ChatDefaultFadeDuration))

	local currentChannelObject = ChatWindow:GetCurrentChannel()
	if (currentChannelObject) then

		local Scroller = MessageLogDisplay.Scroller
		Scroller.ScrollingEnabled = true
		Scroller.ScrollBarThickness = moduleMessageLogDisplay.ScrollBarThickness
	end
end

function DoBackgroundFadeOut(setFadingTime)
	lastBackgroundFadeTime = tick()
	backgroundIsFaded = true
	fadedChanged:Fire()
	ChatWindow:FadeOutBackground((setFadingTime or ChatSettings.ChatDefaultFadeDuration))

	local currentChannelObject = ChatWindow:GetCurrentChannel()
	if (currentChannelObject) then

		local Scroller = MessageLogDisplay.Scroller
		Scroller.ScrollingEnabled = false
		Scroller.ScrollBarThickness = 0
	end
end

function DoTextFadeIn(setFadingTime)
	lastTextFadeTime = tick()
	textIsFaded = false
	fadedChanged:Fire()
	ChatWindow:FadeInText((setFadingTime or ChatSettings.ChatDefaultFadeDuration) * 0)
end

function DoTextFadeOut(setFadingTime)
	lastTextFadeTime = tick()
	textIsFaded = true
	fadedChanged:Fire()
	ChatWindow:FadeOutText((setFadingTime or ChatSettings.ChatDefaultFadeDuration))
end

function DoFadeInFromNewInformation()
	DoTextFadeIn()
	if ChatSettings.ChatShouldFadeInFromNewInformation then
		DoBackgroundFadeIn()
	end
end

function InstantFadeIn()
	DoBackgroundFadeIn(0)
	DoTextFadeIn(0)
end

function InstantFadeOut()
	DoBackgroundFadeOut(0)
	DoTextFadeOut(0)
end

local mouseIsInWindow = nil
function UpdateFadingForMouseState(mouseState)
	mouseIsInWindow = mouseState

	mouseStateChanged:Fire()

	if (ChatBar:IsFocused()) then return end

	if (mouseState) then
		DoBackgroundFadeIn()
		DoTextFadeIn()
	else
		DoBackgroundFadeIn()
	end
end

spawn(function()
	while true do
		RunService.RenderStepped:wait()

		while (mouseIsInWindow or ChatBar:IsFocused()) do
			if (mouseIsInWindow) then
				mouseStateChanged.Event:wait()
			end
			if (ChatBar:IsFocused()) then
				chatBarFocusChanged.Event:wait()
			end
		end

		if (not backgroundIsFaded) then
			local timeDiff = tick() - lastBackgroundFadeTime
			if (timeDiff > ChatSettings.ChatWindowBackgroundFadeOutTime) then
				DoBackgroundFadeOut()
			end

		elseif (not textIsFaded) then
			local timeDiff = tick() - lastTextFadeTime
			if (timeDiff > ChatSettings.ChatWindowTextFadeOutTime) then
				DoTextFadeOut()
			end

		else
			fadedChanged.Event:wait()

		end

	end
end)

function getClassicChatEnabled()
	if ChatSettings.ClassicChatEnabled ~= nil then
		return ChatSettings.ClassicChatEnabled
	end
	return Players.ClassicChat
end

function getBubbleChatEnabled()
	if ChatSettings.BubbleChatEnabled ~= nil then
		return ChatSettings.BubbleChatEnabled
	end
	return Players.BubbleChat
end

function bubbleChatOnly()
	return not getClassicChatEnabled() and getBubbleChatEnabled()
end

function UpdateMousePosition(mousePos)
	if not (moduleApiTable.Visible and moduleApiTable.IsCoreGuiEnabled and (moduleApiTable.TopbarEnabled or ChatSettings.ChatOnWithTopBarOff)) then return end

	if bubbleChatOnly() then
		return
	end

	local windowPos = ChatWindow.GuiObject.AbsolutePosition
	local windowSize = ChatWindow.GuiObject.AbsoluteSize

	local newMouseState = CheckIfPointIsInSquare(mousePos, windowPos, windowPos + windowSize)

	if (newMouseState ~= mouseIsInWindow) then
		UpdateFadingForMouseState(newMouseState)
	end
end

UserInputService.InputChanged:connect(function(inputObject, gameProcessedEvent)
	if (inputObject.UserInputType == Enum.UserInputType.MouseMovement) then
		local mousePos = Vector2.new(inputObject.Position.X, inputObject.Position.Y)
		UpdateMousePosition(mousePos)
	end
end)

UserInputService.TouchTap:connect(function(tapPos, gameProcessedEvent)
	UpdateMousePosition(tapPos[1])
end)

UserInputService.TouchMoved:connect(function(inputObject, gameProcessedEvent)
	local tapPos = Vector2.new(inputObject.Position.X, inputObject.Position.Y)
	UpdateMousePosition(tapPos)
end)

UserInputService.Changed:connect(function(prop)
	if prop == "MouseBehavior" then
		if UserInputService.MouseBehavior == Enum.MouseBehavior.LockCenter then
			local windowPos = ChatWindow.GuiObject.AbsolutePosition
			local windowSize = ChatWindow.GuiObject.AbsoluteSize
			local screenSize = GuiParent.AbsoluteSize

			local centerScreenIsInWindow = CheckIfPointIsInSquare(screenSize/2, windowPos, windowPos + windowSize)
			if centerScreenIsInWindow then
				UserInputService.MouseBehavior = Enum.MouseBehavior.Default
			end
		end
	end
end)


Prompt: -- for fading text

Response:
function UITween.fadeText(object, amount, time, delay)

	local tweenAlpha = TweenInfo.new(
		time, --Time
		Enum.EasingStyle.Quad, --EasingStyle
		Enum.EasingDirection.Out, --EasingDirection
		0, --Repeat count
		false, --Reverses if true
		delay --Delay time
	)

	local tween1 = tweenService:Create(object, tweenAlpha, {TextTransparency = amount})
	tween1:Play()

end


Prompt: -- events

Response:
REMOTES.Effect.OnClientEvent:connect(function(...)
	EFFECTS:Effect(...)
end)


Response:
	 TeamKill = false					--- Enable TeamKill?
	,TeamDamageMultiplier = 1			--- Between 0-1 | This will make you cause less damage if you hit your teammate

	,ReplicatedBullets = true			--- Keep in mind that some bullets will pass through surfaces...

	,AntiBunnyHop = true				--- Enable anti bunny hop system?
	,JumpCoolDown = 0.5					--- Seconds before you can jump again
	,JumpPower = 55						--- Jump power, default is 50

	,RealisticLaser = true				--- True = Laser line is invisible
	,ReplicatedLaser = true
	,ReplicatedFlashlight = true

	,EnableRagdoll = true				--- Enable ragdoll death?
	,TeamTags = false					--- Aaaaaaa
	,HitmarkerSound = true				--- GGWP MLG 360 NO SCOPE xD


Prompt:
-- Bezier.new(x1, y1, x2, y2)
-- @param numbers (x1, y1, x2, y2) The control points of your curve
-- @returns function(t [b, c, d])
--	@param number t the time elapsed [0, d]
--	@param number b beginning value being interpolated (default = 0)
--	@param number c change in value being interpolated (equivalent to: ending - beginning) (default = 1)
--	@param number d duration interpolation is occurring over (default = 1)


Prompt: --!strict

Response:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ReplicatedFirst = game:GetService("ReplicatedFirst")
local Players = game:GetService("Players")

local Conf = require(ReplicatedFirst.Configurations.MainConfiguration)


Prompt: -- In radians the minimum accuracy penalty

Response: local MinSpread = 0.025


Prompt: --Constructor and destructor

Response:
function draw_invincibility:New(holder)
	--Initialize meta reference
	local self = setmetatable({}, {__index = draw_invincibility})

	--Create model instance
	self.holder = holder

	self.invincibility = models:WaitForChild("Invincibility"):clone()
	self.particles = self.invincibility:WaitForChild("RootPart"):WaitForChild("Invincibility"):GetChildren()
	self.invincibility.Parent = self.holder

	--Initialize state
	self.enabled = false
	self.hrp_cf = nil
	self.en_time = 0
	self.part_time = 0
	for _,v in pairs(self.particles) do
		self.part_time = math.max(self.part_time, v.Lifetime.Max)
	end

	return self
end

function draw_invincibility:Destroy()
	--Destroy model instance
	self.invincibility:Destroy()
end


Prompt: --Tune

Response:
local _Select = "AllSeason" --(AllSeason, Slicks, SemiSlicks, AllTerrain, DragRadials, Custom) Caps and space sensitive

local _Custom = {

	TireWearOn         = true    ,

    --Friction and Wear
    FWearSpeed        = .2    , --How fast your tires will degrade (Front)
    FTargetFriction    = .72   , --Friction in optimal conditions (Front)
    FMinFriction     = 0.45   , --Friction in worst conditions (Front)

    RWearSpeed        = .2    , --How fast your tires will degrade (Rear)
    RTargetFriction    = .80  ,  --Friction in optimal conditions (Rear)
    RMinFriction    = 0.45    , --Friction in worst conditions (Rear)

    --Tire Slip
    TCSOffRatio        = 1     , --How much optimal grip your car will lose with TCS off, set to 1 if you dont want any losses.
    WheelLockRatio    = 1/6    , --How much grip your car will lose when locking the wheels
    WheelspinRatio    = 1/1.2  , --How much grip your car will lose when spinning the wheels

    --Wheel Properties
    FFrictionWeight    = 2      , --Ratio of friction between wheel and terrain, the higher it is, the more true to target friction your grip wil be (Front) (PGS)
    RFrictionWeight    = 2      , --Ratio of friction between wheel and terrain, the higher it is, the more true to target friction your grip wil be (Rear) (PGS)
    FLgcyFrWeight    = 0        , --Ratio of friction between wheel and terrain, the higher it is, the more true to target friction your grip wil be (Front)
    RLgcyFrWeight    = 0        , --Ratio of friction between wheel and terrain, the higher it is, the more true to target friction your grip wil be (Rear)

    FElasticity        = 0     , --How much your wheel will bounce (Front) (PGS)
    RElasticity        = 0     , --How much your wheel will bounce (Rear) (PGS)
    FLgcyElasticity    = 0     , --How much your wheel will bounce (Front)
    RLgcyElasticity    = 0     , --How much your wheel will bounce (Rear)

    FElastWeight    = 1      , --Ratio of elasticity between wheel and terrain, the higher it is, the more true to the wheel elasticity it will be (Front) (PGS)
    RElastWeight    = 1      , --Ratio of elasticity between wheel and terrain, the higher it is, the more true to the wheel elasticity it will be (Rear) (PGS)
    FLgcyElWeight    = 10    , --Ratio of elasticity between wheel and terrain, the higher it is, the more true to the wheel elasticity it will be (Front)
    RLgcyElWeight    = 10    , --Ratio of elasticity between wheel and terrain, the higher it is, the more true to the wheel elasticity it will be (Rear)

    --Wear Regen
    RegenSpeed        = 3.6		, --Don't change this
}

local _AllSeason = {

	TireWearOn         = true    ,

    --Friction and Wear
    FWearSpeed        = .2    , --Don't change this
    FTargetFriction    = .61   , -- .58 to .63
    FMinFriction     = 0.35   , --Don't change this

    RWearSpeed        = .2    , --Don't change this
    RTargetFriction    = .63  , -- .58 to .63
    RMinFriction    = 0.35    , --Don't change this

    --Tire Slip
    TCSOffRatio        = 1     , --Don't change this
    WheelLockRatio    = 1/6    , --Don't change this
    WheelspinRatio    = 1/1.2  ,  --Don't change this

    --Wheel Properties
    FFrictionWeight    = 2      , --Don't change this
    RFrictionWeight    = 2      , --Don't change this
    FLgcyFrWeight    = 0        , --Don't change this
    RLgcyFrWeight    = 0        , --Don't change this

    FElasticity        = 0     , --Don't change this
    RElasticity        = 0     , --Don't change this
    FLgcyElasticity    = 0     , --Don't change this
    RLgcyElasticity    = 0     , --Don't change this

    FElastWeight    = 1      , --Don't change this
    RElastWeight    = 1      , --Don't change this
    FLgcyElWeight    = 10    , --Don't change this
    RLgcyElWeight    = 10    , --Don't change this

    --Wear Regen
    RegenSpeed        = 3.6		, --Don't change this
}

local _Slicks = {

	TireWearOn         = true    ,

    --Friction and Wear
    FWearSpeed        = .6    , --Don't change this
    FTargetFriction    = .93   , -- .88 to .93
    FMinFriction     = 0.35   , --Don't change this

    RWearSpeed        = .6    , --Don't change this
    RTargetFriction    = .93  , -- .88 to .93
    RMinFriction    = 0.35    , --Don't change this

    --Tire Slip
    TCSOffRatio        = 1     , --Don't change this
    WheelLockRatio    = 1/6    , --Don't change this
    WheelspinRatio    = 1/1.2  ,  --Don't change this

    --Wheel Properties
    FFrictionWeight    = 0.6      , --Don't change this
    RFrictionWeight    = 0.6      , --Don't change this
    FLgcyFrWeight    = 0        , --Don't change this
    RLgcyFrWeight    = 0        , --Don't change this

    FElasticity        = 0     , --Don't change this
    RElasticity        = 0     , --Don't change this
    FLgcyElasticity    = 0     , --Don't change this
    RLgcyElasticity    = 0     , --Don't change this

    FElastWeight    = 1      , --Don't change this
    RElastWeight    = 1      , --Don't change this
    FLgcyElWeight    = 10    , --Don't change this
    RLgcyElWeight    = 10    , --Don't change this

    --Wear Regen
    RegenSpeed        = 3.6		, --Don't change this
}

local _SemiSlicks = {

	TireWearOn         = true    ,

    --Friction and Wear
    FWearSpeed        = .5    , --Don't change this
    FTargetFriction    = .78   , -- .73 to .78
    FMinFriction     = 0.35   , --Don't change this

    RWearSpeed        = .5    , --Don't change this
    RTargetFriction    = .78  , -- .73 to .78
    RMinFriction    = 0.35    , --Don't change this

    --Tire Slip
    TCSOffRatio        = 1     , --Don't change this
    WheelLockRatio    = 1/6    , --Don't change this
    WheelspinRatio    = 1/1.2  ,  --Don't change this

    --Wheel Properties
    FFrictionWeight    = 0.6      , --Don't change this
    RFrictionWeight    = 0.6      , --Don't change this
    FLgcyFrWeight    = 0        , --Don't change this
    RLgcyFrWeight    = 0        , --Don't change this

    FElasticity        = 0     , --Don't change this
    RElasticity        = 0     , --Don't change this
    FLgcyElasticity    = 0     , --Don't change this
    RLgcyElasticity    = 0     , --Don't change this

    FElastWeight    = 1      , --Don't change this
    RElastWeight    = 1      , --Don't change this
    FLgcyElWeight    = 10    , --Don't change this
    RLgcyElWeight    = 10    , --Don't change this

    --Wear Regen
    RegenSpeed        = 3.6		, --Don't change this
}

local _AllTerrain = {

	TireWearOn         = true    ,

    --Friction and Wear
    FWearSpeed        = .3    , --Don't change this
    FTargetFriction    = .5   , -- .48 to .53
    FMinFriction     = 0.35   , --Don't change this

    RWearSpeed        = .3    , --Don't change this
    RTargetFriction    = .5  , -- .48 to .53
    RMinFriction    = 0.35    , --Don't change this

    --Tire Slip
    TCSOffRatio        = 1     , --Don't change this
    WheelLockRatio    = 1/6    , --Don't change this
    WheelspinRatio    = 1/1.2  ,  --Don't change this

    --Wheel Properties
    FFrictionWeight    = 10      , --Don't change this
    RFrictionWeight    = 10      , --Don't change this
    FLgcyFrWeight    = 0        , --Don't change this
    RLgcyFrWeight    = 0        , --Don't change this

    FElasticity        = 0     , --Don't change this
    RElasticity        = 0     , --Don't change this
    FLgcyElasticity    = 0     , --Don't change this
    RLgcyElasticity    = 0     , --Don't change this

    FElastWeight    = 1      , --Don't change this
    RElastWeight    = 1      , --Don't change this
    FLgcyElWeight    = 10    , --Don't change this
    RLgcyElWeight    = 10    , --Don't change this

    --Wear Regen
    RegenSpeed        = 3.6		, --Don't change this
}

local _DragRadials = {

	TireWearOn         = true    ,

    --Friction and Wear
    FWearSpeed        = 30    , --Don't change this
    FTargetFriction    = 1.2   , -- 1.18 to 1.23
    FMinFriction     = 0.35   , --Don't change this

    RWearSpeed        = 30    , --Don't change this
    RTargetFriction    = 1.2  , -- 1.18 to 1.23
    RMinFriction    = 0.35    , --Don't change this

    --Tire Slip
    TCSOffRatio        = 1     , --Don't change this
    WheelLockRatio    = 1/6    , --Don't change this
    WheelspinRatio    = 1/1.2  ,  --Don't change this

    --Wheel Properties
    FFrictionWeight    = 1      , --Don't change this
    RFrictionWeight    = 1      , --Don't change this
    FLgcyFrWeight    = 0        , --Don't change this
    RLgcyFrWeight    = 0        , --Don't change this

    FElasticity        = 0     , --Don't change this
    RElasticity        = 0     , --Don't change this
    FLgcyElasticity    = 0     , --Don't change this
    RLgcyElasticity    = 0     , --Don't change this

    FElastWeight    = 1      , --Don't change this
    RElastWeight    = 1      , --Don't change this
    FLgcyElWeight    = 10    , --Don't change this
    RLgcyElWeight    = 10    , --Don't change this

    --Wear Regen
    RegenSpeed        = 20		, --Don't change this
}

local car = script.Parent.Parent.Car.Value
local _Tune = require(car["A-Chassis Tune"])
local cValues = script.Parent.Parent:WaitForChild("Values")
local _WHEELTUNE = _AllSeason

if _Select == "DragRadials" then
	_WHEELTUNE = _DragRadials
elseif _Select == "Custom" then
	_WHEELTUNE = _Custom
elseif _Select == "AllTerrain" then
	_WHEELTUNE = _AllTerrain
elseif _Select == "Slicks" then
	_WHEELTUNE = _Slicks
elseif _Select == "SemiSlicks" then
	_WHEELTUNE = _SemiSlicks
else
	_WHEELTUNE = _AllSeason
end

car.DriveSeat.TireStats.Fwear.Value = _WHEELTUNE.FWearSpeed
car.DriveSeat.TireStats.Ffriction.Value = _WHEELTUNE.FTargetFriction
car.DriveSeat.TireStats.Fminfriction.Value = _WHEELTUNE.FMinFriction
car.DriveSeat.TireStats.Ffweight.Value = _WHEELTUNE.FFrictionWeight

car.DriveSeat.TireStats.Rwear.Value = _WHEELTUNE.RWearSpeed
car.DriveSeat.TireStats.Rfriction.Value = _WHEELTUNE.RTargetFriction
car.DriveSeat.TireStats.Rminfriction.Value = _WHEELTUNE.RMinFriction
car.DriveSeat.TireStats.Rfweight.Value = _WHEELTUNE.RFrictionWeight

car.DriveSeat.TireStats.TCS.Value = _WHEELTUNE.TCSOffRatio
car.DriveSeat.TireStats.Lock.Value = _WHEELTUNE.WheelLockRatio
car.DriveSeat.TireStats.Spin.Value = _WHEELTUNE.WheelspinRatio
car.DriveSeat.TireStats.Reg.Value = _WHEELTUNE.RegenSpeed


Prompt:
--	local AttackRange, FieldOfView, AggroRange, ChanceOfBoredom, BoredomDuration,
--		Damage, DamageCooldown

Response:
	local configTable = model.Configurations
	local configs = {}
	local function loadConfig(configName, defaultValue)
		if configTable:FindFirstChild(configName) then
			configs[configName] = configTable:FindFirstChild(configName).Value
		else
			configs[configName] = defaultValue
		end
	end

	loadConfig("AttackRange", 3)
	loadConfig("FieldOfView", 180)
	loadConfig("AggroRange", 200)
	loadConfig("ChanceOfBoredom", .5)
	loadConfig("BoredomDuration", 10)
	loadConfig("Damage", 10)
	loadConfig("DamageCooldown", 1)

	local StateMachine = require(game.ServerStorage.ROBLOX_StateMachine).new()
	local PathLib = require(game.ServerStorage.ROBLOX_PathfindingLibrary).new()
	local ZombieTarget = nil
	local ZombieTargetLastLocation = nil

	local lastBored = os.time()

	-- STATE DEFINITIONS

	-- IdleState: NPC stays still. Refreshes bored timer when started to
	-- allow for random state change
	local IdleState = StateMachine.NewState()
	IdleState.Name = "Idle"
	IdleState.Action = function()
	end
	IdleState.Init = function()
		lastBored = os.time()
	end

	-- SearchState: NPC wanders randomly increasing chance of spotting
	-- enemy. Refreshed bored timer when started to allow for random state
	-- change
	local SearchState = StateMachine.NewState()
	SearchState.Name = "Search"
	local lastmoved = os.time()
	local searchTarget = nil
	SearchState.Action = function()
		-- move to random spot nearby
		if model then
			local now = os.time()
			if now - lastmoved > 2 then
				lastmoved = now
				local xoff = math.random(5, 10)
				if math.random() > .5 then
					xoff = xoff * -1
				end
				local zoff = math.random(5, 10)
				if math.random() > .5 then
					zoff = zoff * -1
				end

				local testtarg = AIUtilities:FindCloseEmptySpace(model)
				--if testtarg then print(testtarg) else print("could not find") end
				searchTarget = Vector3.new(model.HumanoidRootPart.Position.X + xoff,model.HumanoidRootPart.Position.Y,model.HumanoidRootPart.Position.Z + zoff)
				--local target = Vector3.new(model.HumanoidRootPart.Position.X + xoff,model.HumanoidRootPart.Position.Y,model.HumanoidRootPart.Position.Z + zoff)
				--model.Humanoid:MoveTo(target)
				searchTarget = testtarg
			end
			if searchTarget then
				PathLib:MoveToTarget(model, searchTarget)
			end
		end
	end
	SearchState.Init = function()
		lastBored = os.time()
	end

	-- PursueState: Enemy has been spotted, need to give chase.
	local PursueState = StateMachine.NewState()
	PursueState.Name = "Pursue"
	PursueState.Action = function()
		-- Double check we still have target
		if ZombieTarget then
			-- Get distance to target
			local distance = (model.HumanoidRootPart.Position - ZombieTarget.HumanoidRootPart.Position).magnitude
			-- If we're far from target use pathfinding to move. Otherwise just MoveTo
			if distance > configs["AttackRange"] + 5 then
				PathLib:MoveToTarget(model, ZombieTarget.HumanoidRootPart.Position)
			else
				model.Humanoid:MoveTo(ZombieTarget.HumanoidRootPart.Position)


Prompt:
--[[
	Stage implementation
]]

Response:
local Lobby = {}
Lobby.__index = Lobby
Lobby.PlayerAddedConnection = nil

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

	return self
end

function Lobby:playerAdded(player)
	-- Load the character (behind the camera) so StarterGui replicates
	Util.loadCharacter(player)

	player.DevComputerMovementMode = Enum.DevComputerMovementMode.Scriptable
	player.DevTouchMovementMode = Enum.DevTouchMovementMode.Scriptable
end

function Lobby:initialize()
	MatchmakingLobby.run()
end

function Lobby:destroy()
	self.PlayerAddedConnection:disconnect()
	self.PlayerAddedConnection = nil
end


Prompt: -- These are customizeable criteria regarding exactly what is removed, and where it is removed from:

Response:
RemoveTools = true
RemoveHopperBins = true
RemoveFromBackpack = true
RemoveFromCharacter = true
RemoveForceField = false

script.Parent.BrickColor = BrickColor.new(21)

function getPlayer(humanoid)
	local players = game.Players:GetChildren()
	for i = 1, #players do
		if (players[i].Character.Humanoid == humanoid) then return players[i] end
	end
	return nil
end

function checkKeeper(player)
	for i = 1,#keepers do
		if (keepers[i] == player.Name) then return true end
	end
	return false
end

function RemoveWeapons(parent)
	local weapons = parent:GetChildren()
	for i = 1,#weapons do
		if (weapons[i].className == "Tool") and (RemoveTools == true) then
			weapons[i]:remove()
			script.Parent.BrickColor = BrickColor.new(22)
		elseif (weapons[i].className == "HopperBin") and (RemoveHopperBins == true) then
			weapons[i]:remove()
			script.Parent.BrickColor = BrickColor.new(22)
		end
	end
end

local debounce = false

function onTouched(hit)
	local human = hit.Parent:findFirstChild("Humanoid")
	if (human == nil) then return end
	local player = getPlayer(human)
	if (player == nil) then return end

	if (checkKeeper(player) == true) or (debounce == true) then return end

	debounce = true

	if (RemoveFromBackpack == true) then
		local backpack = player.Backpack
		if (table.maxn(backpack:GetChildren()) > 0) then
			RemoveWeapons(backpack)
		end
	end

	if (RemoveFromCharacter == true) then
		RemoveWeapons(player.Character)
	end

	if (RemoveForceField == true) then
		local charparts = player.Character:GetChildren()
		for i = 1,#charparts do
			if (charparts[i].className == "ForceField") then
				charparts[i]:remove()
				script.Parent.BrickColor = BrickColor.new(22)
			end
		end
	end

	wait(0.5)

	script.Parent.BrickColor = BrickColor.new(21)
	debounce = false
end

script.Parent.Touched:connect(onTouched)


Prompt: --WeldRec(P.Parent.Lights)

Response:
for _,v in pairs(weldedParts) do
	if v:IsA("BasePart") then
		v.Anchored = false
	end
end

script.Parent.Keyscreen.Fob.Value = script.Parent
script.Parent.CarModel.Value = script:FindFirstAncestor("DriveSeat").Parent
script.Parent.Filter.Parent = script:FindFirstAncestor("DriveSeat").Parent
wait()
script.Parent.Parent = workspace
wait()
script:Destroy()


Prompt:
--[[
update_settings = {
	ExistingProfileHandle = function(latest_data),
	MissingProfileHandle = function(latest_data),
	EditProfile = function(lastest_data),
}
--]]

Response:
local function StandardProfileUpdateAsyncDataStore(profile_store, profile_key, update_settings, is_user_mock, is_get_call, version) --> loaded_data, key_info
	local loaded_data, key_info
	local success, error_message = pcall(function()
		local transform_function = function(latest_data)

			local missing_profile = false
			local data_corrupted = false
			local global_updates_data = {0, {}}

			if latest_data == nil then
				missing_profile = true
			elseif type(latest_data) ~= "table" then
				missing_profile = true
				data_corrupted = true
			end

			if type(latest_data) == "table" then
				-- Case #1: Profile was loaded
				if type(latest_data.Data) == "table"
					and type(latest_data.MetaData) == "table"
					and type(latest_data.GlobalUpdates) == "table" then

					latest_data.WasCorrupted = false -- Must be set to false if set previously
					global_updates_data = latest_data.GlobalUpdates
					if update_settings.ExistingProfileHandle ~= nil then
						update_settings.ExistingProfileHandle(latest_data)
					end
					-- Case #2: Profile was not loaded but GlobalUpdate data exists
				elseif latest_data.Data == nil
					and latest_data.MetaData == nil
					and type(latest_data.GlobalUpdates) == "table" then

					latest_data.WasCorrupted = false -- Must be set to false if set previously
					global_updates_data = latest_data.GlobalUpdates or global_updates_data
					missing_profile = true
				else
					missing_profile = true
					data_corrupted = true
				end
			end

			-- Case #3: Profile was not created or corrupted and no GlobalUpdate data exists
			if missing_profile == true then
				latest_data = {
					-- Data = nil,
					-- MetaData = nil,
					GlobalUpdates = global_updates_data,
				}
				if update_settings.MissingProfileHandle ~= nil then
					update_settings.MissingProfileHandle(latest_data)
				end
			end

			-- Editing profile:
			if update_settings.EditProfile ~= nil then
				update_settings.EditProfile(latest_data)
			end

			-- Data corruption handling (Silently override with empty profile) (Also run Case #1)
			if data_corrupted == true then
				latest_data.WasCorrupted = true -- Temporary tag that will be removed on first save
			end

			return latest_data, latest_data.UserIds, latest_data.RobloxMetaData
		end
		if is_user_mock == true then -- Used when the profile is accessed through ProfileStore.Mock
			loaded_data, key_info = MockUpdateAsync(UserMockDataStore, profile_store._profile_store_lookup, profile_key, transform_function, is_get_call)
			task.wait() -- Simulate API call yield
		elseif UseMockDataStore == true then -- Used when API access is disabled
			loaded_data, key_info = MockUpdateAsync(MockDataStore, profile_store._profile_store_lookup, profile_key, transform_function, is_get_call)
			task.wait() -- Simulate API call yield
		else
			loaded_data, key_info = CustomWriteQueueAsync(
				function() -- Callback
					if is_get_call == true then
						local get_data, get_key_info
						if version ~= nil then
							local success, error_message = pcall(function()
								get_data, get_key_info = profile_store._global_data_store:GetVersionAsync(profile_key, version)
							end)
							if success == false and type(error_message) == "string" and string.find(error_message, "not valid") ~= nil then
								warn("[ProfileService]: Passed version argument is not valid; Traceback:\n" .. debug.traceback())
							end
						else
							get_data, get_key_info = profile_store._global_data_store:GetAsync(profile_key)
						end
						get_data = transform_function(get_data)
						return get_data, get_key_info
					else
						return profile_store._global_data_store:UpdateAsync(profile_key, transform_function)
					end
				end,
				profile_store._profile_store_lookup, -- Store
				profile_key -- Key
			)
		end
	end)
	if success == true and type(loaded_data) == "table" then
		-- Corruption handling:
		if loaded_data.WasCorrupted == true and is_get_call ~= true then
			RegisterCorruption(
				profile_store._profile_store_name,
				profile_store._profile_store_scope,
				profile_key
			)
		end
		-- Return loaded_data:
		return loaded_data, key_info
	else
		RegisterIssue(
			(error_message ~= nil) and error_message or "Undefined error",
			profile_store._profile_store_name,
			profile_store._profile_store_scope,
			profile_key
		)
		-- Return nothing:
		return nil
	end
end

local function RemoveProfileFromAutoSave(profile)
	local auto_save_index = table.find(AutoSaveList, profile)
	if auto_save_index ~= nil then
		table.remove(AutoSaveList, auto_save_index)
		if auto_save_index < AutoSaveIndex then
			AutoSaveIndex = AutoSaveIndex - 1 -- Table contents were moved left before AutoSaveIndex so move AutoSaveIndex left as well
		end
		if AutoSaveList[AutoSaveIndex] == nil then -- AutoSaveIndex was at the end of the AutoSaveList - reset to 1
			AutoSaveIndex = 1
		end
	end
end

local function AddProfileToAutoSave(profile) -- Notice: Makes sure this profile isn't auto-saved too soon
	-- Add at AutoSaveIndex and move AutoSaveIndex right:
	table.insert(AutoSaveList, AutoSaveIndex, profile)
	if #AutoSaveList > 1 then
		AutoSaveIndex = AutoSaveIndex + 1
	elseif #AutoSaveList == 1 then
		-- First profile created - make sure it doesn't get immediately auto saved:
		LastAutoSave = os.clock()
	end
end

local function ReleaseProfileInternally(profile)
	-- 1) Remove profile object from ProfileService references: --
	-- Clear reference in ProfileStore:
	local profile_store = profile._profile_store
	local loaded_profiles = profile._is_user_mock == true and profile_store._mock_loaded_profiles or profile_store._loaded_profiles
	loaded_profiles[profile._profile_key] = nil
	if next(profile_store._loaded_profiles) == nil and next(profile_store._mock_loaded_profiles) == nil then -- ProfileStore has turned inactive
		local index = table.find(ActiveProfileStores, profile_store)
		if index ~= nil then
			table.remove(ActiveProfileStores, index)
		end
	end
	-- Clear auto update reference:
	RemoveProfileFromAutoSave(profile)
	-- 2) Trigger release listeners: --
	local place_id
	local game_job_id
	local active_session = profile.MetaData.ActiveSession
	if active_session ~= nil then
		place_id = active_session[1]
		game_job_id = active_session[2]
	end
	profile._release_listeners:Fire(place_id, game_job_id)
end

local function CheckForNewGlobalUpdates(profile, old_global_updates_data, new_global_updates_data)
	local global_updates_object = profile.GlobalUpdates -- [GlobalUpdates]
	local pending_update_lock = global_updates_object._pending_update_lock -- {update_id, ...}
	local pending_update_clear = global_updates_object._pending_update_clear -- {update_id, ...}
	-- "old_" or "new_" global_updates_data = {update_index, {{update_id, version_id, update_locked, update_data}, ...}}
	for _, new_global_update in ipairs(new_global_updates_data[2]) do
		-- Find old global update with the same update_id:
		local old_global_update
		for _, global_update in ipairs(old_global_updates_data[2]) do
			if global_update[1] == new_global_update[1] then
				old_global_update = global_update
				break
			end
		end
		-- A global update is new when it didn't exist before or its version_id or update_locked state changed:
		local is_new = false
		if old_global_update == nil or new_global_update[2] > old_global_update[2] or new_global_update[3] ~= old_global_update[3] then
			is_new = true
		end
		if is_new == true then
			-- Active global updates:
			if new_global_update[3] == false then
				-- Check if update is not pending to be locked: (Preventing firing new active update listeners more than necessary)
				local is_pending_lock = false
				for _, update_id in ipairs(pending_update_lock) do
					if new_global_update[1] == update_id then
						is_pending_lock = true
						break
					end
				end
				if is_pending_lock == false then
					-- Trigger new active update listeners:
					global_updates_object._new_active_update_listeners:Fire(new_global_update[1], new_global_update[4])
				end
			end
			-- Locked global updates:
			if new_global_update[3] == true then
				-- Check if update is not pending to be cleared: (Preventing firing new locked update listeners after marking a locked update for clearing)
				local is_pending_clear = false
				for _, update_id in ipairs(pending_update_clear) do
					if new_global_update[1] == update_id then
						is_pending_clear = true
						break
					end
				end
				if is_pending_clear == false then
					-- Trigger new locked update listeners:

					global_updates_object._new_locked_update_listeners:FireUntil(
						function()
							-- Check if listener marked the update to be cleared:
							-- Normally there should be only one listener per profile for new locked global updates, but
							-- in case several listeners are connected we will not trigger more listeners after one listener
							-- marks the locked global update to be cleared.
							return table.find(pending_update_clear, new_global_update[1]) == nil
						end,
						new_global_update[1], new_global_update[4]
					)

				end
			end
		end
	end
end

local function SaveProfileAsync(profile, release_from_session, is_overwriting)
	if type(profile.Data) ~= "table" then
		RegisterCorruption(
			profile._profile_store._profile_store_name,
			profile._profile_store._profile_store_scope,
			profile._profile_key
		)
		error("[ProfileService]: PROFILE DATA CORRUPTED DURING RUNTIME! Profile: " .. profile:Identify())
	end
	if release_from_session == true and is_overwriting ~= true then
		ReleaseProfileInternally(profile)
	end
	ActiveProfileSaveJobs = ActiveProfileSaveJobs + 1
	local last_session_load_count = profile.MetaData.SessionLoadCount
	-- Compare "SessionLoadCount" when writing to profile to prevent a rare case of repeat last save when the profile is loaded on the same server again
	local repeat_save_flag = true -- Released Profile save calls have to repeat until they succeed
	while repeat_save_flag == true do
		if release_from_session ~= true then
			repeat_save_flag = false
		end
		local loaded_data, key_info = StandardProfileUpdateAsyncDataStore(
			profile._profile_store,
			profile._profile_key,
			{
				ExistingProfileHandle = nil,
				MissingProfileHandle = nil,
				EditProfile = function(latest_data)

					local session_owns_profile = false
					local force_load_pending = false

					if is_overwriting ~= true then
						-- 1) Check if this session still owns the profile: --
						local active_session = latest_data.MetaData.ActiveSession
						local force_load_session = latest_data.MetaData.ForceLoadSession
						local session_load_count = latest_data.MetaData.SessionLoadCount

						if type(active_session) == "table" then
							session_owns_profile = IsThisSession(active_session) and session_load_count == last_session_load_count
						end
						if type(force_load_session) == "table" then
							force_load_pending = not IsThisSession(force_load_session)
						end
					else
						session_owns_profile = true
					end

					if session_owns_profile == true then -- We may only edit the profile if this session has ownership of the profile

						if is_overwriting ~= true then
							-- 2) Manage global updates: --
							local latest_global_updates_data = latest_data.GlobalUpdates -- {update_index, {{update_id, version_id, update_locked, update_data}, ...}}
							local latest_global_updates_list = latest_global_updates_data[2]

							local global_updates_object = profile.GlobalUpdates -- [GlobalUpdates]
							local pending_update_lock = global_updates_object._pending_update_lock -- {update_id, ...}
							local pending_update_clear = global_updates_object._pending_update_clear -- {update_id, ...}
							-- Active update locking:
							for i = 1, #latest_global_updates_list do
								for _, lock_id in ipairs(pending_update_lock) do
									if latest_global_updates_list[i][1] == lock_id then
										latest_global_updates_list[i][3] = true
										break
									end
								end
							end
							-- Locked update clearing:
							for _, clear_id in ipairs(pending_update_clear) do
								for i = 1, #latest_global_updates_list do
									if latest_global_updates_list[i][1] == clear_id and latest_global_updates_list[i][3] == true then
										table.remove(latest_global_updates_list, i)
										break
									end
								end
							end
						end

						-- 3) Save profile data: --
						latest_data.Data = profile.Data
						latest_data.RobloxMetaData = profile.RobloxMetaData
						latest_data.UserIds = profile.UserIds

						if is_overwriting ~= true then
							latest_data.MetaData.MetaTags = profile.MetaData.MetaTags -- MetaData.MetaTags is the only actively savable component of MetaData
							latest_data.MetaData.LastUpdate = os.time()
							if release_from_session == true or force_load_pending == true then
								latest_data.MetaData.ActiveSession = nil
							end
						else
							latest_data.MetaData = profile.MetaData
							latest_data.MetaData.ActiveSession = nil
							latest_data.MetaData.ForceLoadSession = nil
							latest_data.GlobalUpdates = profile.GlobalUpdates._updates_latest
						end

					end
				end,
			},
			profile._is_user_mock
		)
		if loaded_data ~= nil and key_info ~= nil then
			if is_overwriting == true then
				break
			end
			repeat_save_flag = false
			-- 4) Set latest data in profile: --
			-- Updating DataStoreKeyInfo:
			profile.KeyInfo = key_info
			-- Setting global updates:
			local global_updates_object = profile.GlobalUpdates -- [GlobalUpdates]
			local old_global_updates_data = global_updates_object._updates_latest
			local new_global_updates_data = loaded_data.GlobalUpdates
			global_updates_object._updates_latest = new_global_updates_data
			-- Setting MetaData:
			local session_meta_data = profile.MetaData
			local latest_meta_data = loaded_data.MetaData
			for key in pairs(SETTINGS.MetaTagsUpdatedValues) do
				session_meta_data[key] = latest_meta_data[key]
			end
			session_meta_data.MetaTagsLatest = latest_meta_data.MetaTags
			-- 5) Check if session still owns the profile: --
			local active_session = loaded_data.MetaData.ActiveSession
			local session_load_count = loaded_data.MetaData.SessionLoadCount
			local session_owns_profile = false
			if type(active_session) == "table" then
				session_owns_profile = IsThisSession(active_session) and session_load_count == last_session_load_count
			end
			local is_active = profile:IsActive()
			if session_owns_profile == true then
				-- 6) Check for new global updates: --
				if is_active == true then -- Profile could've been released before the saving thread finished
					CheckForNewGlobalUpdates(profile, old_global_updates_data, new_global_updates_data)
				end
			else
				-- Session no longer owns the profile:
				-- 7) Release profile if it hasn't been released yet: --
				if is_active == true then
					ReleaseProfileInternally(profile)
				end
				-- Cleanup reference in custom write queue:
				CustomWriteQueueMarkForCleanup(profile._profile_store._profile_store_lookup, profile._profile_key)
				-- Hop ready listeners:
				if profile._hop_ready == false then
					profile._hop_ready = true
					profile._hop_ready_listeners:Fire()
				end
			end
			-- Signaling MetaTagsUpdated listeners after a possible external profile release was handled:
			profile.MetaTagsUpdated:Fire(profile.MetaData.MetaTagsLatest)
			-- Signaling KeyInfoUpdated listeners:
			profile.KeyInfoUpdated:Fire(key_info)
		elseif repeat_save_flag == true then
			task.wait() -- Prevent infinite loop in case DataStore API does not yield
		end
	end
	ActiveProfileSaveJobs = ActiveProfileSaveJobs - 1
end


Prompt:
--[[
	An internal method used by the reconciler to construct a new component
	instance and attach it to the given virtualNode.
]]

Response:
function Component:__mount(reconciler, virtualNode)
	if config.internalTypeChecks then
		internalAssert(Type.of(self) == Type.StatefulComponentClass, "Invalid use of `__mount`")
		internalAssert(Type.of(virtualNode) == Type.VirtualNode, "Expected arg #2 to be of type VirtualNode")
	end

	local currentElement = virtualNode.currentElement
	local hostParent = virtualNode.hostParent

	-- Contains all the information that we want to keep from consumers of
	-- Roact, or even other parts of the codebase like the reconciler.
	local internalData = {
		reconciler = reconciler,
		virtualNode = virtualNode,
		componentClass = self,
		lifecyclePhase = ComponentLifecyclePhase.Init,
	}

	local instance = {
		[Type] = Type.StatefulComponentInstance,
		[InternalData] = internalData,
	}

	setmetatable(instance, self)

	virtualNode.instance = instance

	local props = currentElement.props

	if self.defaultProps ~= nil then
		props = assign({}, self.defaultProps, props)
	end

	instance:__validateProps(props)

	instance.props = props

	local newContext = assign({}, virtualNode.legacyContext)
	instance._context = newContext

	instance.state = assign({}, instance:__getDerivedState(instance.props, {}))

	if instance.init ~= nil then
		instance:init(instance.props)
		assign(instance.state, instance:__getDerivedState(instance.props, instance.state))
	end

	-- It's possible for init() to redefine _context!
	virtualNode.legacyContext = instance._context

	internalData.lifecyclePhase = ComponentLifecyclePhase.Render
	local renderResult = instance:render()

	internalData.lifecyclePhase = ComponentLifecyclePhase.ReconcileChildren
	reconciler.updateVirtualNodeWithRenderResult(virtualNode, hostParent, renderResult)

	if instance.didMount ~= nil then
		internalData.lifecyclePhase = ComponentLifecyclePhase.DidMount
		instance:didMount()
	end

	if internalData.pendingState ~= nil then
		-- __update will handle pendingState, so we don't pass any new element or state
		instance:__update(nil, nil)
	end

	internalData.lifecyclePhase = ComponentLifecyclePhase.Idle
end


Prompt:
--///////////////////////// Constructors
--//////////////////////////////////////

Response:
function module.new(vChatService, name)
	local obj = setmetatable({}, methods)

	obj.ChatService = vChatService

	obj.PlayerObj = nil

	obj.Name = name
	obj.ExtraData = {}

	obj.Channels = {}
	obj.MutedSpeakers = {}
	obj.EventFolder = nil

	return obj
end

return module


Prompt:
-- If penetrate callback has to run more than this many times, it will register a hit and stop calculating penetrations.
-- This only applies for repeated penetrations, e.g. the amount of parts that fit within the space of a single cast segment (NOT the whole bullet's trajectory over its entire lifetime)

Response: local MAX_PENETRATION_TEST_COUNT = 100


Prompt: --!strict

Response:
type Array<T> = { [number]: T }
local map = require(script.Parent.map)

local function join(arr: Array<any>, separator: string?): string
	if #arr == 0 then
		return ""
	end
	-- JS does tostring conversion implicitely but in Lua we need to do that explicitely
	local stringifiedArray = map(arr, function(item)
		return tostring(item)
	end)

	return table.concat(stringifiedArray, separator or ",")
end

return join


Prompt:
--[[function CastLightRay(startPos,endPos,color,segLength,segSpeed,parts,effectfunc)
	local part, nend = game.Workspace:FindPartOnRay( Ray.new(startPos,(endPos-startPos).unit*999.999),Tool.Parent)
	if nend then endPos = nend end

	if part and part.Parent then
		if part.Parent:FindFirstChild('Humanoid') and part.Parent ~=Tool.Parent then
			effectfunc(part.Parent.Humanoid,(endPos-startPos).unit)
		elseif part.Parent.Parent and part.Parent.Parent:FindFirstChild('Humanoid')  and part.Parent.Parent~=Tool.Parent then
			effectfunc(part.Parent.Parent.Humanoid,(endPos-startPos).unit)
		end
	end

	local numSegments = math.floor(math.min((startPos-endPos).magnitude/segLength,50))
	local initNumParts = #parts
	for i=numSegments,initNumParts,1 do
		if parts[i] then
			parts[i]:Destroy()
			parts[i]=nil
		end
	end
	for i=1,numSegments,1 do
		if not parts[i] then
			parts[i] = Instance.new('Part')
			parts[i].Parent = Tool
			parts[i].Anchored = true
			parts[i].FormFactor = 'Custom'
			parts[i].Size = Vector3.new(0,0,segLength)
			parts[i].CanCollide = false
			local tlight = Instance.new('PointLight')
			tlight.Name = 'Light'
			tlight.Parent = parts[i]

		end
		parts[i].BrickColor = color
		parts[i]:WaitForChild('Light').Color = color.Color
		parts[i].Light.Range =((math.sin(tick()*3)+1)*1)+5
		parts[i].Light.Brightness =((math.sin(tick()*3)+1)*1)+1

		parts[i].CFrame = CFrame.new(((i-.4)*(endPos-startPos).unit*segLength)+startPos,endPos)

	end

	return parts
end]]


Prompt: --[ Main ]--

Response:
while (StealthLava.Parent.Character == nil) do wait(1) end
Crouch:Clone().Parent = StealthLava.Parent.Character


Prompt:
--[[
Creates a lower wall part.
--]]

Response:
local function CreateLowerWallPart(Size,CF,Parent)
	return CreatePart(LOWER_WALL_COLOR,Size,CF,Parent)
end


Prompt: --// Char Parts

Response:
local Humanoid = Personagem:WaitForChild('Humanoid')
local Head = Personagem:WaitForChild('Head')
local Torso = Personagem:WaitForChild('Torso')
local HumanoidRootPart = Personagem:WaitForChild('HumanoidRootPart')
local RootJoint = HumanoidRootPart:WaitForChild('RootJoint')
local Neck = Torso:WaitForChild('Neck')
local Right_Shoulder = Torso:WaitForChild('Right Shoulder')
local Left_Shoulder = Torso:WaitForChild('Left Shoulder')
local Right_Hip = Torso:WaitForChild('Right Hip')
local Left_Hip = Torso:WaitForChild('Left Hip')

local Connections = {}

local Debris = game:GetService("Debris")

local Ignore_Model = ACS_Storage:FindFirstChild("Server")

local BulletModel = ACS_Storage:FindFirstChild("Client")

local IgnoreList = {"Ignorable","Glass"}

local Ray_Ignore = {Character, Ignore_Model, Camera, BulletModel, IgnoreList}

Camera.CameraType = Enum.CameraType.Custom
Camera.CameraSubject = Humanoid


Prompt: --Insert new value

Response:
function module:InsertStat(player, locationName, newValue)
	if main.pd[player][locationName] then
		table.insert(main.pd[player][locationName], newValue)
		main.pd[player].DataToUpdate = true
		main.signals.InsertStat:FireClient(player, {locationName, newValue})
	end
end


Prompt:
--------------------------------------------------------------------------------------------------
-- LOOKS FOR PARTS

Response:
function FindParts(Item)
	for _,i in pairs(Item:GetDescendants()) do
		local NoWeld = CheckIgnore(i)
		if NoWeld == false then
			if i:IsA("BasePart") then
				weldit(script.Parent.MainParts.Engine,i)
			end
		end
	end
end
FindParts(script.Parent)

function UnAnchor(Item)
	for _,i in pairs(Item:GetDescendants()) do
		local NoWeld = CheckIgnore(i)
		if NoWeld == false then
			if i:IsA("BasePart") then
				i.Anchored = false
			end
		end
	end
end
UnAnchor(script.Parent)


Prompt: -- Types that can be expressed as vectors of numbers, and so can be animated.

Response:
export type Animatable =
	number |
	CFrame |
	Color3 |
	ColorSequenceKeypoint |
	DateTime |
	NumberRange |
	NumberSequenceKeypoint |
	PhysicalProperties |
	Ray |
	Rect |
	Region3 |
	Region3int16 |
	UDim |
	UDim2 |
	Vector2 |
	Vector2int16 |
	Vector3 |
	Vector3int16


Response:
	,EnableHolster = false
	,HolsterTo = 'Torso'				 -- Put the name of the body part you wanna holster to
	,HolsterPos = CFrame.new(0,0,0) * CFrame.Angles(math.rad(0),math.rad(0),math.rad(0))

	,RightArmPos = CFrame.new(-.815, 0.55, -1.1) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))	--Server
	,LeftArmPos = CFrame.new(.815,0.55,-1.15) * CFrame.Angles(math.rad(-90),math.rad(0),math.rad(0))	--server

	,ServerGunPos = CFrame.new(-.3, -1, -0.4) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))
	,GunPos = CFrame.new(0.3, -0.15, 1) * CFrame.Angles(math.rad(90), math.rad(0), math.rad(0))

	,RightPos = CFrame.new(-.815, 0.15, -1.1) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))	--Client
	,LeftPos = CFrame.new(.815,0.15,-1.15) * CFrame.Angles(math.rad(-90),math.rad(0),math.rad(0))	--Client
}

return Config


Prompt: -- Finds a visible player at a certain position relative to the camera, otherwise returns nil

Response:
local function findSelectedPlayer(objectPosition, camera, playersService, maxClickDistance)
	if camera then
		local ray = camera:ScreenPointToRay(objectPosition.X, objectPosition.Y)
		local raycastResult = workspace:Raycast(ray.Origin, ray.Direction * maxClickDistance) -- sets the max click distance relative to camera
		if raycastResult then
			local hitPart = raycastResult.Instance
			local character = hitPart:FindFirstAncestorOfClass("Model")
			if character then
				-- Prevents selection of an invisible character
				local isVisible = false
				local transparencyValues = {}
				for _, descendant in pairs(character:GetDescendants()) do
					if descendant:IsA("BasePart") or descendant:IsA("Decal") then
						table.insert(transparencyValues, descendant.Transparency)
					end
				end

				-- Check that all character parts are invisible (Transparency = 1)
				for _, value in ipairs(transparencyValues) do
					if value == 0 then
						isVisible = true
					end
				end

				if isVisible then
					local targetPlayer = playersService:GetPlayerFromCharacter(character)
					if targetPlayer then
						return targetPlayer
					end
				end
			end
		end
	end
	return nil
end

ProfileCard.defaultProps = {
	Players = game:GetService("Players"),
	MainFrame = MainFrame,
	Camera = workspace.CurrentCamera,
	UpdateProfileRemoteFunction = script.Parent.Parent.RemoteEvents.UpdateProfileRemoteFunction,
	PulsePrompt = require(script.Parent.PulsePrompt),
}

local ViewTypes = {
	KeyboardView = Vector3.new(0, 6, 0),
	CenterView = Vector3.new(0, 1, 0),
	OriginalView = Vector3.new(0, 0, 0),
}

local gamepadInputs = {
	Enum.UserInputType.Gamepad1,
	Enum.UserInputType.Gamepad2,
	Enum.UserInputType.Gamepad3,
	Enum.UserInputType.Gamepad4,
	Enum.UserInputType.Gamepad5,
	Enum.UserInputType.Gamepad6,
	Enum.UserInputType.Gamepad7,
	Enum.UserInputType.Gamepad8,
}

function ProfileCard:init()
	self.state = {
		userId = self.props.userId,
		isEditing = false,
		showStatusError = false,
		showPrompt = true,
		viewType = ViewTypes.OriginalView,
		activeGamepad = false,
		adornee = nil
	}

	self.setHumanoidMovementEnabled = function(canMoveBool)
		-- Prevents character movement
		local LocalPlayer = self.props.Players.LocalPlayer
		local Character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
		local HumanoidRootPart = Character:WaitForChild("HumanoidRootPart")
		if HumanoidRootPart then
			HumanoidRootPart.Anchored = not canMoveBool
		end
	end

	self.setKeyboardMovementEnabled = function(enabledBool)
		-- Prevents character movement and camera rotation
		if enabledBool then
			self.props.controls:Enable()
			ContextActionService:BindActionAtPriority("RightMouseDisable", function()
				return Enum.ContextActionResult.Pass
			end, false, Enum.ContextActionPriority.Medium.Value, Enum.UserInputType.MouseButton2)
		else
			self.props.controls:Disable()
			ContextActionService:BindActionAtPriority("RightMouseDisable", function()
				return Enum.ContextActionResult.Sink
			end, false, Enum.ContextActionPriority.Medium.Value, Enum.UserInputType.MouseButton2)
		end
	end

	self.getOtherGuis = function()
		local res = {}
		local playerGui = self.props.Players.LocalPlayer:FindFirstChild("PlayerGui")
		if playerGui then
			for _, instance in pairs(playerGui:GetDescendants()) do
				if
					(instance:IsA("ScreenGui") or instance:IsA("BillboardGui"))
					and not instance:GetAttribute("ShowInProfileCard")
					and instance.Enabled
				then
					table.insert(res, instance)
				end
			end
		end

		return res
	end

	self.getShownCoreGuis = function()
		local shownCoreGuis = Cryo.List.filter(Enum.CoreGuiType:GetEnumItems(), function(coreGuiType)
			-- The inclusion of these GUIs will cause the entire screen to flash after an edit to the ProfileCard is saved. Filtering out for now.
			if Enum.CoreGuiType.PlayerList == coreGuiType or Enum.CoreGuiType.All == coreGuiType then
				return false
			end

			return StarterGui:GetCoreGuiEnabled(coreGuiType)
		end)
		return shownCoreGuis
	end

	self.hideGuis = function()
		if callbacks.hideOtherGuis.isCallbackSet() then
			callbacks.hideOtherGuis.fireCallback()
			return
		end

		-- Hide ScreenGuis
		self.disabledGuis = self.getOtherGuis()
		for _, gui in ipairs(self.disabledGuis) do
			gui.Enabled = false
		end

		-- Hide CoreGuis
		self.disabledCoreGuis = self.getShownCoreGuis()
		for _, gui in ipairs(self.disabledCoreGuis) do
			StarterGui:SetCoreGuiEnabled(gui, false)
		end

		-- Hide mobile controls
		self.modalEnabled = UserInputService.ModalEnabled
		UserInputService.ModalEnabled = true
	end

	self.showGuis = function()
		if callbacks.showOtherGuis.isCallbackSet() then
			callbacks.showOtherGuis.fireCallback()
			return
		end

		-- Show guis that were hidden by hideGuis()
		for _, gui in ipairs(self.disabledGuis) do
			gui.Enabled = true
		end
		self.disabledGuis = {}

		for _, gui in ipairs(self.disabledCoreGuis) do
			StarterGui:SetCoreGuiEnabled(gui, true)
		end
		self.disabledCoreGuis = {}

		UserInputService.ModalEnabled = self.modalEabled
	end

	self.toggleEdit = function(object)
		if not self.state.isEditing then
			self:setState({ isEditing = true })
			self.props.Camera.CameraType = Enum.CameraType.Scriptable
			self.hideGuis()

			if UserInputService.TouchEnabled then
				self:setState({ viewType = ViewTypes.CenterView })
			end

			-- Prevent character movement
			self.setHumanoidMovementEnabled(false)
			if UserInputService.KeyboardEnabled then
				self.setKeyboardMovementEnabled(false)
			end
		else
			local filteredTextTable = self.props.UpdateProfileRemoteFunction:InvokeServer(
				self.props.Players.LocalPlayer,
				object.Parent.Status.Text
			)

			if filteredTextTable.success then
				self.showGuis()
				self:setState({ isEditing = false, showStatusError = false, viewType = ViewTypes.OriginalView })
				self.props.Camera.CameraType = Enum.CameraType.Custom

				-- Restore movement
				self.setHumanoidMovementEnabled(true)
				if UserInputService.KeyboardEnabled then
					self.setKeyboardMovementEnabled(true)
				end
			else
				self:setState({ showStatusError = true })

				if UserInputService.TouchEnabled then
					self:setState({ viewType = ViewTypes.CenterView })
				end
			end
		end
	end

	self.updateViewToKeyboard = function()
		self:setState({ viewType = ViewTypes.KeyboardView })
	end

	self.unmount = function()
		self:setState({ userId = Roact.None, isEditing = false })
	end

	self.onInputBegan = function(input, gameProcessedEvent)
		local isValidInput = input.UserInputType == Enum.UserInputType.MouseButton1
			or input.UserInputType == Enum.UserInputType.Touch
		if isValidInput and not self.state.isEditing and not gameProcessedEvent then
			-- Prevents opening a new profile card while editing; also prevents profile card from closing when interacting with engine related UI (eg. chat button)
			local inputPos = input.Position
			local playerGui = self.props.Players.LocalPlayer:WaitForChild("PlayerGui")
			local profileCard = playerGui:FindFirstChild("ProfileCard")
			local shouldUnmount = true

			if profileCard then
				local guis = playerGui:GetGuiObjectsAtPosition(inputPos.X, inputPos.Y)
				for _, g in ipairs(guis) do
					local billboard = g:FindFirstAncestorOfClass("BillboardGui")
					if billboard and billboard == profileCard then
						shouldUnmount = false
					end
				end
			end

			if shouldUnmount then
				local player = findSelectedPlayer(
					inputPos,
					self.props.Camera,
					self.props.Players,
					self.props.configuration.maxClickDistance
				)
				if player then
					-- Opens a new profile card with the relevant player details
					self:setState({ userId = player.UserId, showPrompt = false, viewType = ViewTypes.OriginalView })
				else
					-- Hide an open profile card if input is not on the card itself
					self.unmount()
				end
			end
		end
	end

	self.checkViewport = function(testPos)
		local _, inViewport = self.props.Camera:WorldToViewportPoint(testPos)
		return inViewport
	end

	self.determineStudOffset = function(object)
		if not object then
			return Vector3.new(0, 0, 0)
		elseif self.state.viewType == ViewTypes.KeyboardView or self.state.viewType == ViewTypes.CenterView then
			return self.state.viewType
		end

		local copyCFrame = object.CFrame
		local rightCFrame = copyCFrame + Vector3.new(Constants.STUD_OFFSET_X, 1, 0)
		local leftCFrame = copyCFrame + Vector3.new(-Constants.STUD_OFFSET_X, 1, 0)
		local studsOffsetVector = Vector3.new(0, 0, 0)

		if self.checkViewport(rightCFrame.Position) then
			studsOffsetVector = Vector3.new(Constants.STUD_OFFSET_X, 1, 0)
		elseif self.checkViewport(leftCFrame.Position) then
			studsOffsetVector = Vector3.new(-Constants.STUD_OFFSET_X, 1, 0)
		end

		if self.state.viewType == ViewTypes.OriginalView then
			ViewTypes.OriginalView = studsOffsetVector
		end

		return studsOffsetVector
	end

	self.getAdornee = function(player)
		local adornee = player == self.props.Players.LocalPlayer and player.Character:FindFirstChild("HumanoidRootPart")
			or Anchor.createAnchor(player, player.Character:FindFirstChild("HumanoidRootPart").Position)
		return adornee
	end

	self.profileCard = Roact.createRef()
end

function ProfileCard:render()
	-- Prevent gamepad interaction
	if table.find(gamepadInputs, UserInputService:GetLastInputType()) ~= nil or self.state.activeGamepad then
		return
	end

	local Players = self.props.Players
	local player

	if self.state.userId then
		player = Players:GetPlayerByUserId(self.state.userId)
	end

	return Roact.createFragment({
		Roact.createElement(ProfileCardContext.Provider, { userId = self.state.userId }, {
			ProfileCard = player and Roact.createElement("BillboardGui", {
				Active = true,
				Size = UDim2.new(0, Constants.GUI_SIZE_X, 0, Constants.GUI_SIZE_Y),
				AlwaysOnTop = self.props.configuration.alwaysOnTop,
				Adornee = self.getAdornee(player),
				StudsOffset = self.determineStudOffset(player.Character:FindFirstChild("HumanoidRootPart")),

				[Roact.Ref] = self.profileCard,
			}, {
				MainFrame = Roact.createElement(self.props.MainFrame, {
					controls = self.props.controls,
					isEditing = self.state.isEditing,
					toggleEdit = self.toggleEdit,
					showStatusError = self.state.showStatusError,
					updateViewToKeyboard = self.updateViewToKeyboard,
				}),
			}),
			ExternalEventConnection = Roact.createElement(ExternalEventConnection, {
				event = UserInputService.InputBegan, -- Maybe use Touch/Tap in world, specifically for mobile
				callback = self.onInputBegan,
			}),
			-- Creates a blur effect when editing
			BlurEffectPortal = self.state.isEditing and self.props.configuration.showBlur and Roact.createElement(
				Roact.Portal,
				{ target = self.props.Camera },
				{ BlurEffect = Roact.createElement("BlurEffect") }
			),
		}),
		PersonalIndicator = Roact.createElement(self.props.PulsePrompt, {
			Players = Players,
			adornee = self.props.adornee,
			isEnabled = self.state.showPrompt,
			userId = Players.LocalPlayer.UserId,
		}),
	})
end

function ProfileCard:didMount()
	UserInputService.LastInputTypeChanged:Connect(function(lastInputType)
		if table.find(gamepadInputs, lastInputType) ~= nil then
			self:setState({
				activeGamepad = true,
				isEditing = false,
				showStatusError = false,
				viewType = ViewTypes.OriginalView,
			})
			self.setHumanoidMovementEnabled(true)
			self.props.Camera.CameraType = Enum.CameraType.Custom
			return
		end

		if self.state.activeGamepad then
			self:setState({ activeGamepad = false })
		end
	end)
end

function ProfileCard:didUpdate(prevProps)
	if self.state.userId then
		self.profileCard:getValue():SetAttribute("ShowInProfileCard", true)

		-- Hide the Profile Card from view once it leaves the screen
		local adornee = self.getAdornee(self.props.Players:GetPlayerByUserId(self.state.userId))
		local adorneeOffset = self.determineStudOffset(self.Adornee)

		coroutine.wrap(function(object)
			local inViewport = self.checkViewport(object.Position)
			while inViewport and object do
				wait(1)

				local newCFrame = object.CFrame
				newCFrame = newCFrame * CFrame.new(adorneeOffset)
				inViewport = self.checkViewport(object.Position)
			end
			self.unmount()
		end)(adornee)
	end
end

return withConfiguration(ProfileCard)


Prompt:
-- -- -- -- -- -- --
--DIRECTION SCROLL--
-- -- -- -- -- -- --

Response:
Elevator:WaitForChild("Direction").Changed:connect(function(val)
    if val == 1 then
		This.Display.ARW1.U.Transparency = 0
		This.Display.ARW1.D.Transparency = 1
		This.Display.ARW1.M.Transparency = 0
    elseif val == -1 then
		This.Display.ARW1.U.Transparency = 1
		This.Display.ARW1.D.Transparency = 0
		This.Display.ARW1.M.Transparency = 0
	else
		This.Display.ARW1.U.Transparency = 1
		This.Display.ARW1.D.Transparency = 1
		This.Display.ARW1.M.Transparency = 1
    end
end)


Prompt: -- How many times per second the gun can fire

Response: local FireRate = 1 / 1.33


Prompt: -- Signal class

Response:
local Signal = {}
Signal.__index = Signal

function Signal.new()
	return setmetatable({
		_handlerListHead = false,
	}, Signal)
end

function Signal:Connect(fn)
	local connection = Connection.new(self, fn)
	if self._handlerListHead then
		connection._next = self._handlerListHead
		self._handlerListHead = connection
	else
		self._handlerListHead = connection
	end
	return connection
end


Prompt: --connect

Response:
Tool.Equipped:connect(onEquipped)
Tool.Unequipped:connect(onUnequipped)
Remote.OnClientEvent:connect(onRemote)


Prompt:
-- ROBLOX DEVIATION: Initialize state to a singleton that warns on access and errors on assignment
-- initial state singleton

Response:
local UninitializedState = {}

setmetatable(UninitializedState, {
	__index = function(table, key)
		if _G.__DEV__ then
			console.warn(
				"Attempted to access uninitialized state. Use setState to initialize state"
			)
		end
		return nil
	end,
	__newindex = function(table, key)
		if _G.__DEV__ then
			console.error(
				"Attempted to directly mutate state. Use setState to assign new values to state."
			)
		end
		return nil
	end,
	__tostring = function(self)
		return "<uninitialized component state>"
	end,
	__metatable = "UninitializedState",
})

return UninitializedState


Prompt:
--[[
	Package link auto-generated by Rotriever
]]

Response:
local PackageIndex = script.Parent._Index

local Package = require(PackageIndex["DevModuleInstaller"]["DevModuleInstaller"])

return Package


Prompt:
--////////////////////////////////////////////////////////////////////////////////////////////
--///////////////////////////////////////////////// Code to hook client UI up to server events
--////////////////////////////////////////////////////////////////////////////////////////////

Response:
function DoChatBarFocus()
	if (not ChatWindow:GetCoreGuiEnabled()) then return end
	if (not ChatBar:GetEnabled()) then return end

	if (not ChatBar:IsFocused() and ChatBar:GetVisible()) then
		moduleApiTable:SetVisible(true)
		InstantFadeIn()
		ChatBar:CaptureFocus()
		moduleApiTable.ChatBarFocusChanged:fire(true)
	end
end

chatBarFocusChanged.Event:connect(function(focused)
	moduleApiTable.ChatBarFocusChanged:fire(focused)
end)

function DoSwitchCurrentChannel(targetChannel)
	if (ChatWindow:GetChannel(targetChannel)) then
		ChatWindow:SwitchCurrentChannel(targetChannel)
	end
end

function SendMessageToSelfInTargetChannel(message, channelName, extraData)
	local channelObj = ChatWindow:GetChannel(channelName)
	if (channelObj) then
		local messageData = {
			ID = -1,
			FromSpeaker = nil,
			SpeakerUserId = 0,
			OriginalChannel = channelName,
			IsFiltered = true,
			MessageLength = string.len(message),
			MessageLengthUtf8 = utf8.len(utf8.nfcnormalize(message)),
			Message = trimTrailingSpaces(message),
			MessageType = ChatConstants.MessageTypeSystem,
			Time = os.time(),
			ExtraData = extraData,
		}

		channelObj:AddMessageToChannel(messageData)
	end
end

function chatBarFocused()
	if (not mouseIsInWindow) then
		DoBackgroundFadeIn()
		if (textIsFaded) then
			DoTextFadeIn()
		end
	end

	chatBarFocusChanged:Fire(true)
end


Prompt: --Made by SinisterAlex

Response:
function onTouched(part)

	local h = part.Parent:findFirstChild("Humanoid") or part.Parent:findFirstChild("Zombie")

	if h~=nil then

wait(0.001)
h.Health = 0
children = h.Parent:children()
part.Parent:findFirstChild("Head").BrickColor = BrickColor.new("Bright red")
part.Parent:findFirstChild("Torso").BrickColor = BrickColor.new("Bright red")
part.Parent:findFirstChild("Left Arm").BrickColor = BrickColor.new("Bright red")
part.Parent:findFirstChild("Right Arm").BrickColor = BrickColor.new("Bright red")
part.Parent:findFirstChild("Left Leg").BrickColor = BrickColor.new("Bright red")
part.Parent:findFirstChild("Right Leg").BrickColor = BrickColor.new("Bright red")

part.Parent:findFirstChild("Head").Material = "Plastic"
part.Parent:findFirstChild("Torso").Material = "Plastic"
part.Parent:findFirstChild("Left Arm").Material = "Plastic"
part.Parent:findFirstChild("Right Arm").Material = "Plastic"
part.Parent:findFirstChild("Left Leg").Material = "Plastic"
part.Parent:findFirstChild("Right Leg").Material = "Plastic"

wait(1)

	for i=1,#children do

		if(children[i].className == "Part" and children[i].Name ~= "Torso") then stick(children[i], h.Parent.Torso) end

		if(children[i].className == "Hat") then stick(children[i].Handle, h.Parent.Torso) end

	end

	end

end

script.Parent.Touched:connect(onTouched)


Prompt: -- connect events

Response:
Humanoid.Died:connect(onDied)
Humanoid.Running:connect(onRunning)
Humanoid.Jumping:connect(onJumping)
Humanoid.Climbing:connect(onClimbing)
Humanoid.GettingUp:connect(onGettingUp)
Humanoid.FreeFalling:connect(onFreeFall)
Humanoid.FallingDown:connect(onFallingDown)
Humanoid.Seated:connect(onSeated)
Humanoid.PlatformStanding:connect(onPlatformStanding)
Humanoid.Swimming:connect(onSwimming)

Effects.ChildAdded:connect(function(ch)
	if ch.Name == "Swimming" then
		pose = "Running"
	end
end)


Prompt:
-- 	-- All lines up to what looks like a stack -- or if nothing looks like a stack
-- 	-- (maybe it's a code frame instead), just the first non-empty line.
-- 	-- If the error is a plain "Error:" instead of a SyntaxError or TypeError we
-- 	-- remove the prefix from the message because it is generally not useful.
-- 	local re = RegExp([=[^(?:Error: )?([\s\S]*?(?=\n\s*at\s.*:\d*:\d*)|\s*.*)([\s\S]*)$]=])
-- 	local messageMatch = re:exec(content)
-- 	if not messageMatch then
-- 		-- For typescript
-- 		error('If you hit this error, the regex above is buggy.')
-- 	end
-- 	local message = removeBlankErrorLine(messageMatch[2])
-- 	local stack = removeBlankErrorLine(messageMatch[3])
-- 	return {message = message, stack = stack}
-- end

Response:
return {
	formatStackTrace = formatStackTrace,
	getStackTraceLines = getStackTraceLines,
	-- separateMessageFromStack = separateMessageFromStack
}


Prompt: --Set target steering position based on current velocity

Response:
function Chassis.UpdateSteering(steer, currentVel)
	local baseSteer = steer
	local targetSteer = 0

	local vehicleSeat = Chassis.GetDriverSeat()
	local maxSpeed = VehicleParameters.MaxSpeed
	local maxSteer = VehicleParameters.MaxSteer

	local currentVelocity = vehicleSeat.Velocity

	if LimitSteerAtHighVel then
		local c = SteerLimit * (math.abs(currentVel)/VehicleParameters.MaxSpeed) + 1
		--decrease steer value as speed increases to prevent tipping (handbrake cancels this)
		steer = steer/c
	end
	SteeringPrismatic.TargetPosition = steer * steer * steer * maxSteer
end

function Chassis.UpdateThrottle(currentSpeed, throttle)
	local targetVel = 0
	local effectsThrottleState = false
	local gainModifier = 0

	if math.abs(throttle) < 0.1 then
		-- Idling
		setMotorMaxAcceleration(math.huge)
		setMotorTorque(2000)
	elseif math.sign(throttle * currentSpeed) > 0 or math.abs(currentSpeed) < 0.5 then
		setMotorMaxAcceleration(math.huge)

		local velocity = Chassis.driverSeat.Velocity
		local velocityVector = velocity.Unit
		local directionalVector = Chassis.driverSeat.CFrame.lookVector
		local dotProd = velocityVector:Dot(directionalVector) -- Dot product is a measure of how similar two vectors are; if they're facing the same direction, it is 1, if they are facing opposite directions, it is -1, if perpendicular, it is 0

		setMotorTorqueDamped(ActualDrivingTorque * throttle * throttle, dotProd, math.sign(throttle))
		-- Arbitrary large number
		local movingBackwards = dotProd < 0
		local acceleratingBackwards = throttle < 0
		local useReverse = (movingBackwards and acceleratingBackwards)

		local maxSpeed = (useReverse and VehicleParameters.ReverseSpeed or VehicleParameters.MaxSpeed)
		targetVel = math.sign(throttle) * maxSpeed

		-- if we are approaching max speed, we should take that as an indication of throttling down, even if not from input
		local maxAccelSpeed = targetVel
		local speedPercent = ((maxAccelSpeed-currentSpeed)/maxAccelSpeed) -- 0 if max speed, 1 if stopped

		-- lets say we start throttling down after reaching 75% of max speed, then linearly drop to 0
		local function quad(x)
			return math.sign(x)*(x^2)
		end

		local r = math.abs(velocity.Magnitude / maxSpeed*2.5) -- adding a bit to the max speed so that it sounds better (always trying to rev engines)
		local desiredRPM = math.exp(-3*r*r)

		gainModifier = desiredRPM

		if gainModifier > 0 then
			effectsThrottleState = true
		end
	else
		-- Braking
		setMotorMaxAcceleration(100)
		setMotorTorque(ActualBrakingTorque * throttle * throttle)
		targetVel = math.sign(throttle) * 500
	end

	Chassis.SetMotorVelocity(targetVel)

	Effects:SetThrottleEnabled(effectsThrottleState, gainModifier)

end

local redressingState = false
local targetAttachment
function Chassis.Redress()
	if redressingState then
		return
	end
	redressingState = true
	local p = Chassis.driverSeat.CFrame.Position + Vector3.new( 0,10,0 )
	local xc = Chassis.driverSeat.CFrame.RightVector
	xc = Vector3.new(xc.x,0,xc.z)
	xc = xc.Unit
	local yc = Vector3.new(0,1,0)

	if not targetAttachment then
		targetAttachment = RedressMount.RedressTarget
	end

	targetAttachment.Parent = Workspace.Terrain
	targetAttachment.Position = p
	targetAttachment.Axis = xc
	targetAttachment.SecondaryAxis = yc
	RedressMount.RedressOrientation.Enabled = true
	RedressMount.RedressPosition.Enabled = true
	wait(1.5)
	RedressMount.RedressOrientation.Enabled = false
	RedressMount.RedressPosition.Enabled = false
	targetAttachment.Parent = RedressMount
	wait(2)
	redressingState = false
end

function Chassis.Reset() --Reset user inputs and redress (For when a player exits the vehicle)
	Chassis.UpdateThrottle(1, 1) --Values must  be changed to replicate to client.
	Chassis.UpdateSteering(1, 0) --i.e. setting vel to 0 when it is 0 wont update to clients
	Chassis.EnableHandbrake()
	setMotorTorque(ActualBrakingTorque)
	Chassis.SetMotorVelocity(0)
	Chassis.UpdateSteering(0, 0)
	RedressMount.RedressOrientation.Enabled = true
	RedressMount.RedressPosition.Enabled = true
	RedressMount.RedressOrientation.Enabled = false
	RedressMount.RedressPosition.Enabled = false
	redressingState = false
end

return Chassis


Prompt: --Supercharger

Response: local Whine_Pitch = 1.4		--max pitch of the whine (not exact so might have to mess with it)


Prompt: --- These are the IDs of possible blood textures, I already set 3 up for u k

Response:
local blood_textures = {
	408399602,
	502143538,
	508050784
}


Prompt: --Set up the touched connection.

Response:
TouchConnection = SlingshotBall.Touched:Connect(function(TouchPart)
	SlingshotBallHit(TouchPart)
end)


Prompt:
------------------------------------------------------------------------
-- save current character into token buffer, grabs next character
-- * like luaX:nextc, returns the character read for convenience
------------------------------------------------------------------------

Response:
function luaX:save_and_next(ls)
  self:save(ls, ls.current)
  return self:nextc(ls)
end


Prompt:
--[[
	Index into `Event` to get a prop key for attaching to an event on a Roblox
	Instance.

	Example:

		Roact.createElement("TextButton", {
			Text = "Hello, world!",

			[Roact.Event.MouseButton1Click] = function(rbx)
				print("Clicked", rbx)
			end
		})
]]

Response:
local Type = require(script.Parent.Parent.Type)

local Event = {}

local eventMetatable = {
	__tostring = function(self)
		return ("RoactHostEvent(%s)"):format(self.name)
	end,
}

setmetatable(Event, {
	__index = function(_self, eventName)
		local event = {
			[Type] = Type.HostEvent,
			name = eventName,
		}

		setmetatable(event, eventMetatable)

		Event[eventName] = event

		return event
	end,
})

return Event


Prompt: -- Local private variables and constants

Response:
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 TAU = 2 * math.pi


Prompt: --- Validates that the argument will work without any type errors.

Response:
function Argument:Validate(isFinal)
	if self.RawValue == nil or #self.RawValue == 0 and self.Required == false then
		return true
	end

	if self.Type.Validate or self.Type.ValidateOnce then
		for i = 1, #self.TransformedValues do
			if self.Type.Validate then
				local valid, errorText = self.Type.Validate(self:GetTransformedValue(i))

				if not valid then
					return valid, errorText or "Invalid value"
				end
			end

			if isFinal and self.Type.ValidateOnce then
				local validOnce, errorTextOnce = self.Type.ValidateOnce(self:GetTransformedValue(i))

				if not validOnce then
					return validOnce, errorTextOnce
				end
			end
		end

		return true
	else
		return true
	end
end


Prompt: --[[ Functions overridden from BaseCamera ]]

Response:
--
function LegacyCamera:SetCameraToSubjectDistance(desiredSubjectDistance)
	return BaseCamera.SetCameraToSubjectDistance(self,desiredSubjectDistance)
end

function LegacyCamera:Update(dt)

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

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

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

	if self.cameraType == Enum.CameraType.Fixed then
		if subjectPosition and player and camera then
			local distanceToSubject = self:GetCameraToSubjectDistance()
			local newLookVector = self:CalculateNewLookVectorFromArg(nil, CameraInput.getRotation())

			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
		local subjectCFrame = self:GetSubjectCFrame()
		local cameraPitch = camera.CFrame:ToEulerAnglesYXZ()
		local _, subjectYaw = subjectCFrame:ToEulerAnglesYXZ()

		cameraPitch = math.clamp(cameraPitch - CameraInput.getRotation().Y, -PITCH_LIMIT, PITCH_LIMIT)

		newCameraFocus = CFrame.new(subjectCFrame.p)*CFrame.fromEulerAnglesYXZ(cameraPitch, subjectYaw, 0)
		newCameraCFrame = newCameraFocus*CFrame.new(0, 0, self:StepZoom())

	elseif self.cameraType == Enum.CameraType.Watch then
		if subjectPosition and player and camera then
			local cameraLook = nil

			if subjectPosition == camera.CFrame.p then
				warn("Camera cannot watch subject in same position as itself")
				return camera.CFrame, camera.Focus
			end

			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:CalculateNewLookVectorFromArg(cameraLook, CameraInput.getRotation())

			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


Prompt: --wood

Response:
for i, x in pairs(game.Workspace.ActivationThings.Other.WoodPlanks:GetChildren()) do
	if x:IsA("BasePart") then
		x.Touched:Connect(function(hit)
			if deb then return end
			if hit and hit.Parent and hit.Parent.Parent and hit.Parent.Parent:IsDescendantOf(workspace.Carts)
				or hit and hit.Parent and hit.Parent.Parent.Parent and hit.Parent.Parent.Parent:IsDescendantOf(workspace.Carts) then
				deb = true
				for i, v in pairs(x.Parent:GetChildren()) do
					if v:IsA("Sound") then
						v:Play() continue
					end
					local lastPos = v.CFrame
					v.Anchored = false

					local function fade(part: BasePart)
						for i = 1, 10 do
							part.Transparency = i / 10
							if part.Transparency == 1 then
								part.CanCollide = false
								wait(2)
								part.Anchored = true
								part.Transparency = 0
								wait(8)
								game:GetService("TweenService"):Create(part, TweenInfo.new(1), {CFrame = lastPos}):Play()
								part.CanCollide = true
								part.AssemblyAngularVelocity = Vector3.new(0, 0, 0)
								wait(1)
								if deb then
									deb = false
								end
							end
							wait(0.1)
						end
					end

					task.delay(3, function()
						coroutine.wrap(fade)(v)
					end)

				end
			end
		end)
	end
end