Pinkstack/roblox-luau-corpus-text huggingface dataset:
-- same as jump for now



function moveFreeFall()
	RightShoulder.MaxVelocity = 0.5
	LeftShoulder.MaxVelocity = 0.5
	RightShoulder:SetDesiredAngle(3.14)
	LeftShoulder:SetDesiredAngle(-3.14)
	RightHip:SetDesiredAngle(0)
	LeftHip:SetDesiredAngle(0)
end

function moveSit()
	RightShoulder.MaxVelocity = 0.15
	LeftShoulder.MaxVelocity = 0.15
	RightShoulder:SetDesiredAngle(3.14 /2)
	LeftShoulder:SetDesiredAngle(-3.14 /2)
	RightHip:SetDesiredAngle(3.14 /2)
	LeftHip:SetDesiredAngle(-3.14 /2)
end

function getTool()	
	for _, kid in ipairs(Figure:GetChildren()) do
		if kid.className == "Tool" then return kid end
	end
	return nil
end

function getToolAnim(tool)
	for _, c in ipairs(tool:GetChildren()) do
		if c.Name == "toolanim" and c.className == "StringValue" then
			return c
		end
	end
	return nil
end

function animateTool()
	
	if (toolAnim == "None") then
		RightShoulder:SetDesiredAngle(1.57)
		LeftShoulder:SetDesiredAngle(-1.57)
		return
	end

	if (toolAnim == "Slash") then
		RightShoulder.MaxVelocity = 0.5
		RightShoulder:SetDesiredAngle(0)

		LeftShoulder.MaxVelocity = 0.5
		LeftShoulder:SetDesiredAngle(0)
		return
	end

	if (toolAnim == "Lunge") then
		RightShoulder.MaxVelocity = 0.5
		LeftShoulder.MaxVelocity = 0.5
		RightHip.MaxVelocity = 0.5
		LeftHip.MaxVelocity = 0.5
		RightShoulder:SetDesiredAngle(1.57)
		--LeftShoulder:SetDesiredAngle(1.0)
		LeftShoulder:SetDesiredAngle(-1.57)
		RightHip:SetDesiredAngle(1.57)
		LeftHip:SetDesiredAngle(1.0)
		return
	end
end

function move(time)
	local amplitude
	local frequency
  
	if (pose == "Jumping") then
		moveJump()
		return
	end

	if (pose == "FreeFall") then
		moveFreeFall()
		return
	end
 
	if (pose == "Seated") then
		moveSit()
		return
	end

	local climbFudge = 0
	
	if (pose == "Running") then
		RightShoulder.MaxVelocity = 0.15
		LeftShoulder.MaxVelocity = 0.15
		amplitude = 1
		frequency = 9
	elseif (pose == "Climbing") then
		RightShoulder.MaxVelocity = 0.5 
		LeftShoulder.MaxVelocity = 0.5
		amplitude = 1
		frequency = 9
		climbFudge = 3.14
	else
		amplitude = 0.1
		frequency = 1
	end

	desiredAngle = amplitude * math.sin(time*frequency)

	RightShoulder:SetDesiredAngle(desiredAngle + climbFudge)
	LeftShoulder:SetDesiredAngle(desiredAngle - climbFudge)
	RightHip:SetDesiredAngle(-desiredAngle)
	LeftHip:SetDesiredAngle(-desiredAngle)


	local tool = getTool()

	if tool then
	
		animStringValueObject = getToolAnim(tool)

		if animStringValueObject then
			toolAnim = animStringValueObject.Value
			-- message recieved, delete StringValue
			animStringValueObject.Parent = nil
			toolAnimTime = time + .3
		end

		if time > toolAnimTime then
			toolAnimTime = 0
			toolAnim = "None"
		end

		animateTool()

		
	else
		toolAnim = "None"
		toolAnimTime = 0
	end
end
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 797		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 9000		--		Use sliders to manipulate values
	Tune.Redline		= 11000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16
	
	--Incline Compensation
	Tune.InclineComp	= 1.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)
-- for fading images


function UITween.fadeBackground(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 tween = tweenService:Create(object, tweenAlpha, {BackgroundTransparency = amount})
	tween:Play()
end
--[[
	ROBLOX deviation: code not ported
	original code:
type FailedResults = Array<{
  content: string;
  result: TestResult.AssertionResult;
}>;

export const formatResultsErrors = (
  testResults: Array<TestResult.AssertionResult>,
  config: StackTraceConfig,
  options: StackTraceOptions,
  testPath?: Path,
): string | null => {
  const failedResults: FailedResults = testResults.reduce<FailedResults>(
    (errors, result) => {
      result.failureMessages.forEach(item => {
        errors.push({content: checkForCommonEnvironmentErrors(item), result});
      });
      return errors;
    },
    [],
  );

  if (!failedResults.length) {
    return null;
  }

  return failedResults
    .map(({result, content}) => {
      let {message, stack} = separateMessageFromStack(content);
      stack = options.noStackTrace
        ? ''
        : STACK_TRACE_COLOR(
            formatStackTrace(stack, config, options, testPath),
          ) + '\n';

      message = indentAllLines(message, MESSAGE_INDENT);

      const title =
        chalk.bold.red(
          TITLE_INDENT +
            TITLE_BULLET +
            result.ancestorTitles.join(ANCESTRY_SEPARATOR) +
            (result.ancestorTitles.length ? ANCESTRY_SEPARATOR : '') +
            result.title,
        ) + '\n';

      return title + '\n' + message + '\n' + stack;
    })
    .join('\n');
};
]]
-- The “edit graph” for sequences a and b corresponds to items:
-- in a on the horizontal axis
-- in b on the vertical axis
--
-- Given a-coordinate of a point in a diagonal, you can compute b-coordinate.
--
-- Forward diagonals kF:
-- zero diagonal intersects top left corner
-- positive diagonals intersect top edge
-- negative diagonals insersect left edge
--
-- Reverse diagonals kR:
-- zero diagonal intersects bottom right corner
-- positive diagonals intersect right edge
-- negative diagonals intersect bottom edge
-- If you want to know how to retexture a hat, read this:  http://www.roblox.com/Forum/ShowPost.aspx?PostID=10502388










debounce = true

function onTouched(hit)
	if (hit.Parent:findFirstChild("Humanoid") ~= nil and debounce == true) then
		debounce = false
		h = Instance.new("Hat")
		p = Instance.new("Part")
		h.Name = "Hat"   -- It doesn't make a difference, but if you want to make your place in Explorer neater, change this to the name of your hat.
		p.Parent = h
		p.Position = hit.Parent:findFirstChild("Head").Position
		p.Name = "Handle" 
		p.formFactor = 0
		p.Size = Vector3.new(-0,-0,-1) 
		p.BottomSurface = 0 
		p.TopSurface = 0 
		p.Locked = true 
		script.Parent.Mesh:clone().Parent = p
		h.Parent = hit.Parent
		h.AttachmentPos = Vector3.new(0,-0.075,0.2) -- Change these to change the positiones of your hat, as I said earlier.
		wait(5)		debounce = true
	end
end

script.Parent.Touched:connect(onTouched)
-- tween engine sound volume when we start driving


local engineStartTween = TweenInfo.new(0.25, Enum.EasingStyle.Quad, Enum.EasingDirection.In, 0, false, 0)

local Remotes = Vehicle:WaitForChild("Remotes")
local Configuration = Vehicle:WaitForChild("Configuration")
local SetThrottleRemote = Remotes:WaitForChild("SetThrottle")
local SetThrottleConnection = nil

local EngineSoundEnabled = true
local TireTrailEnabled = false

local ignitionTime = 1.75 -- seconds

local lastAvgAngularVelocity = 0
local throttleEnabled = false
local lastThrottleUpdate = 0

local enginePower = 0 -- current rpm of the engine
local gainModifier = 1 -- modifier to engine rpm gain (lower if approaching max speed)
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,VRecoil = {20,25}				--- Vertical Recoil
	,HRecoil = {10,15}				--- Horizontal Recoil
	,AimRecover = 0.85					---- Between 0 & 1
	
	,RecoilPunch = 3
	,VPunchBase = 24				--- Vertical Punch
	,HPunchBase = 9					--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless
	
	,AimRecoilReduction = 1.5 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.25
	,MinRecoilPower = 1
	,MaxRecoilPower = 3
	,RecoilPowerStepAmount = 1
	
	,MinSpread = 0					--- Min bullet spread value | Studs
	,MaxSpread = 75					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = 5
	,WalkMultiplier = 0				--- Bullet spread based on player speed

	,SwayBase = 0.25				--- Weapon Base Sway | Studs
	,MaxSway =	1					--- Max sway value based on player stamina | Studs
--------------------------------------------------------------------------



local _WHEELTUNE = {
																		--[[	
			SS6 Presets
	[Eco]		
		WearSpeed = 1,
		TargetFriction = .7,
		MinFriction = .1,
	[Road]		
		WearSpeed = 2,
		TargetFriction = .7,
		MinFriction = .1,
	[Sport]		
		WearSpeed = 3,
		TargetFriction = .79,
		MinFriction = .1,											]]

	TireWearOn 		= true	,
	
	--Friction and Wear
	FWearSpeed		= 10	,
	FTargetFriction	= 52	,
	FMinFriction 	= 26	,
	
	RWearSpeed		= 10	,
	RTargetFriction	= 52	,
	RMinFriction	= 26	,
	
	--Tire Slip
	TCSOffRatio		= 1		,
	WheelLockRatio	= 1/2	,	--SS6 Default = 1/4
	WheelspinRatio	= 1/1.1	,	--SS6 Default = 1/1.2
	
	--Wheel Properties
	FFrictionWeight	= 1		,	--SS6 Default = 1
	RFrictionWeight	= 1		,	--SS6 Default = 1
	FLgcyFrWeight	= 10	,
	RLgcyFrWeight	= 10	,
	
	FElasticity		= .5		,	--SS6 Default = .5
	RElasticity		= .5		,	--SS6 Default = .5
	FLgcyElasticity	= 0		,
	RLgcyElasticity	= 0		,
	
	FElastWeight	= 1		,	--SS6 Default = 1
	RElastWeight	= 1		,	--SS6 Default = 1
	FLgcyElWeight	= 10	,
	RLgcyElWeight	= 10	,
	
	--Wear Regen
	RegenSpeed		= 3.6		--SS6 Default = 3.6
}
--// T key, Horn


mouse.KeyDown:connect(function(key)
	if key=="t" then 
		script.Parent.Parent.Horn.TextTransparency = 0
		veh.Lightbar.middle.Airhorn:Play()
		veh.Lightbar.middle.Wail.Volume = 0
		veh.Lightbar.middle.Yelp.Volume = 0
		veh.Lightbar.middle.Priority.Volume = 0
		script.Parent.Parent.MBOV.Visible = true
		script.Parent.Parent.MBOV.Text = "Made by OfficerVargas"
	end
end)
--Switch button type


function SwitchButtonType(Type)
	if Type == "Keyboard" then
		ButtonImage = ButtonGui.KeyboardImage
		ButtonGui.KeyboardImage.Visible = true
		ButtonGui.GamepadImage.Visible = false
		ButtonGui.TouchImage.Visible = false
	elseif Type == "Gamepad" then
		ButtonImage = ButtonGui.GamepadImage
		ButtonGui.GamepadImage.Visible = true
		ButtonGui.KeyboardImage.Visible = false
		ButtonGui.TouchImage.Visible = false
	elseif Type == "Touch" then
		ButtonImage = ButtonGui.TouchImage
		ButtonGui.GamepadImage.Visible = false
		ButtonGui.KeyboardImage.Visible = false
		ButtonGui.TouchImage.Visible = true
	end
end
--- Runs the command. Handles dispatching to the server if necessary.
-- Command:Validate() must be called before this is called or it will throw.


function Command:Run ()
	if self._Validated == nil then
		error("Must validate a command before running.")
	end

	local beforeRunHook = self.Dispatcher:RunHooks("BeforeRun", self)
	if beforeRunHook then
		return beforeRunHook
	end

	if self.Object.Run then -- We can just Run it here on this machine
		self.Response = self.Object.Run(self, unpack(self:GatherArgumentValues()))
	elseif IsServer then -- Uh oh, we're already on the server and there's no Run function.
		warn(self.Name, "command has no implementation!")
		self.Response = "No implementation."
	else -- We're on the client, so we send this off to the server to let the server see what it can do with it.
		self.Response = self.Dispatcher:Send(self.RawText, self.Object.Data and self.Object.Data(self))
	end

	local afterRunHook = self.Dispatcher:RunHooks("AfterRun", self)
	if afterRunHook then
		return afterRunHook
	else
		return self.Response
	end
end
--[[
	A special key for property tables, which adds user-specified tasks to be run
	when the instance is destroyed.
]]



local Package = script.Parent.Parent
local PubTypes = require(Package.PubTypes)

local Cleanup = {}
Cleanup.type = "SpecialKey"
Cleanup.kind = "Cleanup"
Cleanup.stage = "observer"

function Cleanup:apply(userTask: any, applyTo: Instance, cleanupTasks: {PubTypes.Task})
	table.insert(cleanupTasks, userTask)
end

return Cleanup
--returns the wielding player of this tool


function getPlayer()
	local char = Tool.Parent
	return game:GetService("Players"):GetPlayerFromCharacter(Character)
end

function Toss(direction)
	local handlePos = Vector3.new(Tool.Handle.Position.X, 0, Tool.Handle.Position.Z)
	local spawnPos = Character.Head.Position
	spawnPos  = spawnPos + (direction * 5)
	Tool.Handle.Transparency = 1

	local Object = Tool.Handle:Clone()
	Object.Parent = workspace
	Object.Transparency = 0
	Object.CanCollide = true
	Object.Organizar.Server.Disabled = false
	Object.Interface.Enabled = true

	Object.CFrame = Tool.Handle.CFrame
	Object.Velocity = (direction*AttackVelocity) + Vector3.new(0,AttackVelocity/7.5,0)
	local rand = 11.25
	Object.RotVelocity = Vector3.new(math.random(-rand,rand),math.random(-rand,rand),math.random(-rand,rand))
	Object:SetNetworkOwner(getPlayer())

	local tag = Instance.new("ObjectValue")
	tag.Value = getPlayer()
	tag.Name = "creator"
	tag.Parent = Object
	Tool:Destroy()
end


script.Parent.Power.OnServerEvent:Connect(function(player, Power)
	AttackVelocity = Power
end)

Remote.OnServerEvent:Connect(function(player, mousePosition)
	if not AttackAble then return end
	AttackAble = false
	if Humanoid and Humanoid.RigType == Enum.HumanoidRigType.R15 then
		Remote:FireClient(getPlayer(), "PlayAnimation", "Animation")
	end
	local targetPos = mousePosition.p
	local lookAt = (targetPos - Character.Head.Position).unit
	Toss(lookAt)
	LeftDown = true
end)

function onLeftUp()
	LeftDown = false
end

Tool.Equipped:Connect(function()
	Character = Tool.Parent
	Humanoid = Character:FindFirstChildOfClass("Humanoid")
end)

Tool.Unequipped:Connect(function()
	Character = nil
	Humanoid = nil
end)
--[[
	Represents a tree of test results.

	Each node in the tree corresponds directly to a node in a corresponding
	TestPlan, accessible via the 'planNode' field.

	TestResults objects are produced by TestRunner using TestSession as state.
]]



local TestEnum = require(script.Parent.TestEnum)

local STATUS_SYMBOLS = {
	[TestEnum.TestStatus.Success] = "+",
	[TestEnum.TestStatus.Failure] = "-",
	[TestEnum.TestStatus.Skipped] = "~",
}

local TestResults = {}

TestResults.__index = TestResults
-- initiate



RunService:BindToRenderStep("Mouse", 5, function(deltaTime)
	if MOUSE.Reticle ~= currentReticle then
		currentReticle	= MOUSE.Reticle
		UpdateReticle()
	end
	
	scopeSpring:Update(deltaTime)
	
	if scope and aiming then
		local ratio	= CAMERA.ViewportSize.Y / CAMERA.ViewportSize.X
		MOUSE_GUI.Position	= UDim2.new(0.5 + scopeSpring.Position.X * 0.02 * ratio, 0, 0.5 + scopeSpring.Position.Y * 0.02, 0)
	else
		MOUSE_GUI.Position	= UDim2.new(0.5, 0, 0.5, 0)
	end
	
	SCOPE_GUI.Position	= MOUSE_GUI.Position
	
	local ignore	= {EFFECTS}
	if PLAYER.Character then
		table.insert(ignore, PLAYER.Character)
	end
	
	local h, pos
	local screenPos	= MOUSE_GUI.AbsolutePosition + MOUSE_GUI.AbsoluteSize / 2
	local ray		= CAMERA:ScreenPointToRay(screenPos.X, screenPos.Y, 0)
	local mouseRay	= Ray.new(CAMERA.CFrame.p, ray.Direction * 1000)
	
	local finished	= false
	
	repeat
		h, pos	= Workspace:FindPartOnRayWithIgnoreList(mouseRay, ignore)
		
		if h then
			if h.Parent:FindFirstChildOfClass("Humanoid") then
				finished	= true
			elseif h.Transparency >= 0.5 then
				table.insert(ignore, h)
			else
				if h.CanCollide then
					finished	= true
				else
					table.insert(ignore, h)
				end
			end
		else
			finished	= true
		end
	until finished
	
	MOUSE.ScreenPosition	= screenPos
	MOUSE.WorldPosition		= pos
end)
-- call animations when touch and touch ended


local function onPartTouched(otherPart, screenGui)
	if(otherPart.Name == "HumanoidRootPart") then
		local frame = screenGui.Frame
		local fill = screenGui.Fill
		local title = screenGui.Title
		local body = screenGui.Body
		local plantFrame = screenGui["Plant Circle"]
		local plant = screenGui["Plant Circle"].Plant
		
		UITween.size(frame, frameMid, 0.25, 0, false)
		UITween.size(fill, frameMid, 0.25, 0, false)

		UITween.fadeText(body, 0, 0.25, 0.25)
		UITween.fadeText(title, 0, 0.25, 0.25)
		UITween.size(frame, frameEnd, 0.25, 0.25, false)
		UITween.fadeBackground(title, 0.6, 0.25, 0.25)

		UITween.fade(plant, 0, 0.25, 0.5)
		UITween.fade(plantFrame, 0, 0.25, 0.5)
		UITween.size(fill, fillEnd, 0.25, 0.5, false)
	end
end

local function onPartTouchedEnded(otherPart, screenGui)
	if(otherPart.Name == "HumanoidRootPart") then
		local frame = screenGui.Frame
		local fill = screenGui.Fill
		local title = screenGui.Title
		local body = screenGui.Body
		local plantFrame = screenGui["Plant Circle"]
		local plant = screenGui["Plant Circle"].Plant

		UITween.fadeText(body, 1, 0.25, 0)
		UITween.fadeText(title, 1, 0.25, 0)
		UITween.fadeBackground(title, 1, 0.25, 0)
		UITween.fade(plant, 1, 0.25, 0)
		UITween.fade(plantFrame, 1, 0.25, 0)
		UITween.size(frame, frameMid, 0.25, 0, false)
		UITween.size(fill, frameMid, 0.25, 0, false)
		UITween.size(frame, frameStart, 0.25, 0, false)
		UITween.size(fill, frameStart, 0.25, 0, false)
	end
end


function InteractFact.Init(model)
	local part = model.ScreenTouchPart
	local screenGui = model.PlantScreen.SurfaceGui
	
	-- default sizes
	screenGui.Body.TextTransparency = 1
	screenGui.Title.BackgroundTransparency = 1
	screenGui.Title.TextTransparency = 1
	screenGui.Frame.Size = frameStart
	screenGui.Fill.Size = frameStart
	screenGui["Plant Circle"].ImageTransparency = 1
	screenGui["Plant Circle"].Plant.ImageTransparency = 1	
	
	-- add listeners, that will call a generic function passing specific screenGui
	part.Touched:Connect(function(otherPart)onPartTouched(otherPart, screenGui) end)
	part.TouchEnded:Connect(function(otherPart) onPartTouchedEnded(otherPart, screenGui) end)
end

return InteractFact
--------------------------------



local text

Event.OnClientEvent:Connect(function()
	game.Lighting.Blur.Enabled = true
	script.Parent.Frame.Visible = true
	PopSound:Play()
end)

EditBox.FocusLost:Connect(function(enterPressed)
	if enterPressed then
		text = tostring(EditBox.Text)
	end
end)

SubmitButton.Activated:Connect(function()
	text = tostring(EditBox.Text)
	if text ~= nil and text ~= "" and text ~= " " and string.len(text) < 150 then
		Event:FireServer(text)

		game.Lighting.Blur.Enabled = false
		script.Parent.Frame.Visible = false
		Notification:FireServer("Successfully Edited Stand!")
	end
end)

CancelButton.Activated:Connect(function()
	game.Lighting.Blur.Enabled = false
	script.Parent.Frame.Visible = false
	CancelSound:Play()
end)


UnclaimButton.Activated:Connect(function()
	game.ReplicatedStorage.Events.Unclaim:FireServer(player)
	game.Lighting.Blur.Enabled = false
	script.Parent.Frame.Visible = false
	Notification:FireServer("Successfully Unclaimed Stand!")
end)

RefreshButton.Activated:Connect(function()
	game.ReplicatedStorage.Events.Refresh:FireServer(player, Booth)
	game.Lighting.Blur.Enabled = false
	script.Parent.Frame.Visible = false
	Notification:FireServer("Successfully Refreshed Stand!")
end)

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local EventsFolder = ReplicatedStorage:FindFirstChild("Events")

local EditPromptEvent = EventsFolder:FindFirstChild("EditPlot")


EditPromptEvent.OnClientEvent:Connect(function(plot, value)
	if value == true then
		Booth = plot
		workspace.Stands[plot].Proximity.Attachment.EditPrompt.Enabled = true
		EditPrompt = workspace.Stands[plot].Proximity.Attachment.EditPrompt
		workspace.Stands[plot].Part.BillboardGui.Enabled = true
	else
		workspace.Stands[plot].Proximity.Attachment.EditPrompt.Enabled = false
		EditPrompt = nil
		workspace.Stands[plot].Part.BillboardGui.Enabled = false
	end
end)
--[[Driver Handling]]



	--Driver Sit	
	car.TruckSeat.ChildAdded:connect(function(child)
		if child.Name=="SeatWeld" and child:IsA("Weld") and game.Players:GetPlayerFromCharacter(child.Part1.Parent)~=nil then
			--Distribute Client Interface
			local p=game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			car.TruckSeat:SetNetworkOwner(p)
			local g=script.Parent["A-Chassis Interface"]:Clone()
			g.Parent=p.PlayerGui
		end
	end)
	
	--Driver Leave
	car.TruckSeat.ChildRemoved:connect(function(child)
		if child.Name=="SeatWeld" and child:IsA("Weld") then
			--Remove Flip Force
			if car.TruckSeat:FindFirstChild("Flip")~=nil then
				car.TruckSeat.Flip.MaxTorque = Vector3.new()
			end
			
			--Remove Wheel Force
			for i,v in pairs(car.Wheels:GetChildren()) do
				if v:FindFirstChild("#AV")~=nil then
					if v["#AV"]:IsA("BodyAngularVelocity") then
						if v["#AV"].AngularVelocity.Magnitude>0 then
							v["#AV"].AngularVelocity = Vector3.new()
							v["#AV"].MaxTorque = Vector3.new()
						end
					else
						if v["#AV"].AngularVelocity>0 then
							v["#AV"].AngularVelocity = 0
							v["#AV"].MotorMaxTorque = 0
						end
					end
				end
			end
		end
	end)
-- Customization


	AntiTK = false; -- Set to false to allow TK and damaging of NPC, true for no TK. (To damage NPC, this needs to be false)
	
	MouseSense = 0.5;

	CanAim = true; -- Allows player to aim
	CanBolt = true; -- When shooting, if this is enabled, the bolt will move (SCAR-L, ACR, AK Series)
	
	LaserAttached = true;
	LightAttached = true;
	TracerEnabled = true;
	
	SprintSpeed = 20;
	
	CanCallout = true;
	SuppressCalloutChance = 10;