Roblox/luau_corpus huggingface dataset:
-- find player's head pos

	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)

	local head = vCharacter:findFirstChild("Head")
	if head == nil then return end

	local dir = mouse_pos - head.Position
	dir = computeDirection(dir)

	local launch = head.Position + 5 * dir

	local delta = mouse_pos - launch
	
	local dy = delta.y
	
	local new_delta = Vector3.new(delta.x, 0, delta.z)
	delta = new_delta

	local dx = delta.magnitude
	local unit_delta = delta.unit
	
	-- acceleration due to gravity in RBX units
	local g = (-9.81 * 20)

	local theta = computeLaunchAngle( dx, dy, g)

	local vy = math.sin(theta)
	local xz = math.cos(theta)
	local vx = unit_delta.x * xz
	local vz = unit_delta.z * xz
	

	local missile = Pellet:clone()
        

	m = Tool.Handle.Mesh:clone()
	m.Parent = missile
	m.Scale = Vector3.new(5,5,5)


	missile.Position = launch
	missile.Velocity = Vector3.new(vx,vy,vz) * VELOCITY

	missile.PelletScript.Disabled = false

	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = vCharacter
	creator_tag.Name = "creator"
	creator_tag.Parent = missile
	
	missile.Parent = game.Workspace

end


function computeLaunchAngle(dx,dy,grav)
	-- arcane
	-- http://en.wikipedia.org/wiki/Trajectory_of_a_projectile
	
	local g = math.abs(grav)
	local inRoot = (VELOCITY*VELOCITY*VELOCITY*VELOCITY) - (g * ((g*dx*dx) + (2*dy*VELOCITY*VELOCITY)))
	if inRoot <= 0 then
		return .25 * math.pi
	end
	local root = math.sqrt(inRoot)
	local inATan1 = ((VELOCITY*VELOCITY) + root) / (g*dx)

	local inATan2 = ((VELOCITY*VELOCITY) - root) / (g*dx)
	local answer1 = math.atan(inATan1)
	local answer2 = math.atan(inATan2)
	if answer1 < answer2 then return answer1 end
	return answer2
end

function computeDirection(vec)
	local lenSquared = vec.magnitude * vec.magnitude
	local invSqrt = 1 / math.sqrt(lenSquared)
	return Vector3.new(vec.x * invSqrt, vec.y * invSqrt, vec.z * invSqrt)
end




Tool.Enabled = true
function onActivated()
	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return 
	end
if loaded==true then
	loaded=false
	local targetPos = humanoid.TargetPoint

	fire(targetPos)
	wait(.2)
	Tool.Enabled = true
elseif loaded==false then
Tool.Parent.Torso["Right Shoulder"].MaxVelocity = 0.6
Tool.Parent.Torso["Right Shoulder"].DesiredAngle = -3.6
	wait(.1)
Tool.Handle.Transparency=0
wait(.1)
	loaded=true
	end
	Tool.Enabled = true
end

script.Parent.Activated:connect(onActivated)
-- Compiled with roblox-ts v2.0.4
local TS = _G[script]
local Div = TS.import(script, script, "elements", "Div").default
local Button = TS.import(script, script, "elements", "Button").default
local Text = TS.import(script, script, "elements", "Text").default
local Input = TS.import(script, script, "elements", "Input").default
return {
	Div = Div,
	Button = Button,
	Text = Text,
	Input = Input,
}
-- strictly used for ServerSceneFramework test file due to conflict when replacing Init with a magic mock
SeekPermissions.timesInitiated = 0

SeekPermissions.Init = function()
	SeekPermissions.SetSeekPermissionsEvent.Event:Connect(SeekPermissions.SetSeekingPermissions)

	SeekPermissions.Players.PlayerRemoving:Connect(function(Player)
		if SeekPermissions.PlayersWithPermission[Player] then
			SeekPermissions.PlayersWithPermission[Player] = nil
		end
	end)

	SeekPermissions.Players.PlayerAdded:Connect(function(Player)
		-- Not sure if we need this conditional here
		if SeekPermissions.Players:FindFirstChild(Player.Name) then
			SeekPermissions.CheckAndApplySeekPermissions(Player)
		end
	end)

	SeekPermissions.timesInitiated += 1
end

return SeekPermissions
--[=[
	Extends the value onto the emitted brio
	@since 3.6.0
	@param ... T
	@return (source: Observable<Brio<U>>) -> Observable<Brio<U | T>>
]=]
function RxBrioUtils.extend(...)
	local args = table.pack(...)

	return Rx.map(function(brio)
		assert(Brio.isBrio(brio), "Bad brio")

		return BrioUtils.extend(brio, table.unpack(args, 1, args.n))
	end)
end
--[=[
	Set a handler that will be called only if the Promise resolves or is cancelled. This method is similar to `finally`, except it doesn't catch rejections.

	:::caution
	`done` should be reserved specifically when you want to perform some operation after the Promise is finished (like `finally`), but you don't want to consume rejections (like in <a href="/roblox-lua-promise/lib/Examples.html#cancellable-animation-sequence">this example</a>). You should use `andThen` instead if you only care about the Resolved case.
	:::

	:::warning
	Like `finally`, if the Promise is cancelled, any Promises chained off of it with `andThen` won't run. Only Promises chained with `done` and `finally` will run in the case of cancellation.
	:::

	Returns a new promise chained from this promise.

	@param doneHandler (status: Status) -> ...any
	@return Promise<...any>
]=]
function Promise.prototype:done(finallyHandler)
	assert(
		finallyHandler == nil or type(finallyHandler) == "function",
		string.format(ERROR_NON_FUNCTION, "Promise:done")
	)
	return self:_finally(debug.traceback(nil, 2), finallyHandler, true)
end
-- Script thanks to the roblox wiki :D


local PhysicsService = game:GetService("PhysicsService")
local Players = game:GetService("Players")

local playerCollisionGroupName = "Players"
PhysicsService:CreateCollisionGroup(playerCollisionGroupName)
PhysicsService:CollisionGroupSetCollidable(playerCollisionGroupName, playerCollisionGroupName, false)

local previousCollisionGroups = {}

local function setCollisionGroup(object)
	if object:IsA("BasePart") then
		previousCollisionGroups[object] = object.CollisionGroupId
		PhysicsService:SetPartCollisionGroup(object, playerCollisionGroupName)
	end
end

local function setCollisionGroupRecursive(object)
	setCollisionGroup(object)

	for _, child in ipairs(object:GetChildren()) do
		setCollisionGroupRecursive(child)
	end
end

local function resetCollisionGroup(object)
	local previousCollisionGroupId = previousCollisionGroups[object]
	if not previousCollisionGroupId then return end 

	local previousCollisionGroupName = PhysicsService:GetCollisionGroupName(previousCollisionGroupId)
	if not previousCollisionGroupName then return end

	PhysicsService:SetPartCollisionGroup(object, previousCollisionGroupName)
	previousCollisionGroups[object] = nil
end

local function onCharacterAdded(character)
	setCollisionGroupRecursive(character)

	character.DescendantAdded:Connect(setCollisionGroup)
	character.DescendantRemoving:Connect(resetCollisionGroup)
end

local function onPlayerAdded(player)
	player.CharacterAdded:Connect(onCharacterAdded)
end

Players.PlayerAdded:Connect(onPlayerAdded)
-- We need to add 2 to these values as a workaround to a documented engine bug
local TextService = game:GetService("TextService")
local function getTextHeight(text, fontSize, font, widthCap)
	return TextService:GetTextSize(text, fontSize, font, Vector2.new(widthCap, 10000)).Y + 2
end

local function getTextWidth(text, fontSize, font)
	return TextService:GetTextSize(text, fontSize, font, Vector2.new(10000, 10000)).X + 2
end

local FitTextLabel = Roact.PureComponent:extend("FitTextLabel")
FitTextLabel.Width = {
	FitToText = {},
}
FitTextLabel.defaultProps = {
	Font = Enum.Font.SourceSans,
	Text = "Label",
	TextSize = 12,
	TextWrapped = true,

	maximumWidth = math.huge,
}

function FitTextLabel:init()
	self.frameRef = Roact.createRef()

	self.onResize = function()
		if not self.frameRef.current then
			return
		end

		self.frameRef.current.Size = self:__getSize(self.frameRef.current)
	end
end

function FitTextLabel:render()
	return Roact.createElement("TextLabel", self:__getFilteredProps())
end

function FitTextLabel:didMount()
	self.onResize()
end

function FitTextLabel:didUpdate()
	self.onResize()
end

function FitTextLabel:__getFilteredProps()
	-- Will return a new prop map after removing
	-- Roact.Children and any defaultProps in an effort
	-- to only return safe Roblox Instance "TextLabel"
	-- properties that may be present.
	local filteredProps = {
		width = Cryo.None,
		maximumWidth = Cryo.None,
		Size = UDim2.new(self.props.width, UDim.new(0, 0)),
		[Roact.Ref] = self.frameRef,

		[Roact.Children] = Cryo.Dictionary.join(self.props[Roact.Children] or {}, {
			sizeConstraint = self.props.maximumWidth < math.huge and Roact.createElement("UISizeConstraint", {
				MaxSize = Vector2.new(self.props.maximumWidth, math.huge),
			})
		})
	}

	return Cryo.Dictionary.join(self.props, filteredProps)
end

function FitTextLabel:__getSize(rbx)
	local maximumWidth = self.props.maximumWidth
	local width = self.props.width
	if width == FitTextLabel.Width.FitToText then
		local textWidth = getTextWidth(self.props.Text, self.props.TextSize, self.props.Font)
		width = UDim.new(0, math.min(textWidth, maximumWidth))
	end

	local widthCap = math.max(maximumWidth < math.huge and maximumWidth or 0, rbx.AbsoluteSize.X)
	local textHeight = getTextHeight(
		self.props.Text,
		self.props.TextSize,
		self.props.Font,
		widthCap
	)

	return UDim2.new(width, UDim.new(0, textHeight))
end

return FitTextLabel
--[=[
	Determines whether a value is a promise or not.

	@param value any
	@return boolean
]=]
function Promise.isPromise(value)
	return type(value) == "table" and value.ClassName == "Promise"
end
--[[
	   ___  _____
	  / _ |/ ___/	Avxnturador | Novena
	 / __ / /__			 LuaInt | Novena
	/_/ |_\___/   Build 6C, Version 1.4, Update 4
	
	Please install this chassis from scratch.
	More info can be found in the README.
	
	New values will have (Username) appended to the end of the description.
]]

local Tune = {}
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]


local autoscaling	= false					--Estimates top speed

local UNITS	= {								--Click on speed to change units
											--First unit is default	
	{
		units			= "KP/H"				,
		scaling			= (10/12) * 1.09728	, -- 1 stud : 10 inches | ft/s to KP/H
		maxSpeed		= 370				,
		spInc			= 40				, -- Increment between labelled notches
	},
	
	{
		units			= "KP/H"			,
		scaling			= (10/12) * 1.09728	, -- 1 stud : 10 inches | ft/s to KP/H
		maxSpeed		= 370				,
		spInc			= 40				, -- Increment between labelled notches
	},
	
	{
		units			= "KP/H"				,
		scaling			= (10/12) * 1.09728 , -- 1 stud : 10 inches | ft/s to KP/H
		maxSpeed		= 370				,
		spInc			= 40				, -- Increment between labelled notches
	}
}
-----------------------
--| Local Functions |--
-----------------------

local function CastRay(fromPoint, toPoint, ignoreList)
	local vector = toPoint - fromPoint
	local ray = Ray.new(fromPoint, vector.Unit * math.min(vector.Magnitude, 999))
	return workspace:FindPartOnRayWithIgnoreList(ray, ignoreList or {}, false, true)
end
--print(GBCF(n.CFrame,v[1].p))
pcall(function() n.CFrame = GBCF(n.CFrame,v[1]:inverse().p)*(v[1]:inverse()-v[1]:inverse().p) end)
end
end
wait()
end
end
Finished = Finished+1
end)
end
repeat wait() until Finished >= AF
Close = false
Opened = false
------//High Ready Animations
self.RightHighReady = CFrame.new(-1, .45, -1.15) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0));
self.LeftHighReady = CFrame.new(.75,.45,-1.15) * CFrame.Angles(math.rad(-90),math.rad(45),math.rad(0));

self.RightElbowHighReady = CFrame.new(0,-0.45,-0.45)  * CFrame.Angles(math.rad(-75), math.rad(0), math.rad(0));
self.LeftElbowHighReady = CFrame.new(0,-.4,-.4)  * CFrame.Angles(math.rad(-60), math.rad(30), math.rad(0));

self.RightWristHighReady = CFrame.new(0,0,0)  * CFrame.Angles(math.rad(0), math.rad(0), math.rad(0));
self.LeftWristHighReady = CFrame.new(0,0,0)  * CFrame.Angles(math.rad(0), math.rad(0), math.rad(0));
-- Decompiled with the Synapse X Luau decompiler.

local v1 = {};
v1.__index = v1;
v1.CameraShakeState = {
	FadingIn = 0, 
	FadingOut = 1, 
	Sustained = 2, 
	Inactive = 3
};
local l__Vector3_new__1 = Vector3.new;
function v1.new(p1, p2, p3, p4)
	if p3 == nil then
		p3 = 0;
	end;
	if p4 == nil then
		p4 = 0;
	end;
	assert(type(p1) == "number", "Magnitude must be a number");
	assert(type(p2) == "number", "Roughness must be a number");
	assert(type(p3) == "number", "FadeInTime must be a number");
	assert(type(p4) == "number", "FadeOutTime must be a number");
	local v2 = {
		Magnitude = p1, 
		Roughness = p2, 
		PositionInfluence = l__Vector3_new__1(), 
		RotationInfluence = l__Vector3_new__1(), 
		DeleteOnInactive = true, 
		roughMod = 1, 
		magnMod = 1, 
		fadeOutDuration = p4, 
		fadeInDuration = p3, 
		sustain = p3 > 0
	};
	local v3
	if p3 > 0 then
		v3 = 0;
	else
		v3 = 1;
	end;
	v2.currentFadeTime = v3;
	v2.tick = Random.new():NextNumber(-100, 100);
	v2._camShakeInstance = true;
	return setmetatable(v2, v1);
end;
local l__math_noise__2 = math.noise;
function v1.UpdateShake(p5, p6)
	local l__tick__4 = p5.tick;
	local v5 = p5.currentFadeTime;
	if p5.fadeInDuration > 0 and p5.sustain then
		if v5 < 1 then
			v5 = v5 + p6 / p5.fadeInDuration;
		elseif p5.fadeOutDuration > 0 then
			p5.sustain = false;
		end;
	end;
	if not p5.sustain then
		v5 = v5 - p6 / p5.fadeOutDuration;
	end;
	if p5.sustain then
		p5.tick = l__tick__4 + p6 * p5.Roughness * p5.roughMod;
	else
		p5.tick = l__tick__4 + p6 * p5.Roughness * p5.roughMod * v5;
	end;
	p5.currentFadeTime = v5;
	return l__Vector3_new__1(l__math_noise__2(l__tick__4, 0) * 0.5, l__math_noise__2(0, l__tick__4) * 0.5, l__math_noise__2(l__tick__4, l__tick__4) * 0.5) * p5.Magnitude * p5.magnMod * v5;
end;
function v1.StartFadeOut(p7, p8)
	if p8 == 0 then
		p7.currentFadeTime = 0;
	end;
	p7.fadeOutDuration = p8;
	p7.fadeInDuration = 0;
	p7.sustain = false;
end;
function v1.StartFadeIn(p9, p10)
	if p10 == 0 then
		p9.currentFadeTime = 1;
	end;
	p9.fadeInDuration = p10 or p9.fadeInDuration;
	p9.fadeOutDuration = 0;
	p9.sustain = true;
end;
function v1.GetScaleRoughness(p11)
	return p11.roughMod;
end;
function v1.SetScaleRoughness(p12, p13)
	p12.roughMod = p13;
end;
function v1.GetScaleMagnitude(p14)
	return p14.magnMod;
end;
function v1.SetScaleMagnitude(p15, p16)
	p15.magnMod = p16;
end;
function v1.GetNormalizedFadeTime(p17)
	return p17.currentFadeTime;
end;
function v1.IsShaking(p18)
	local v6 = true;
	if not (p18.currentFadeTime > 0) then
		v6 = p18.sustain;
	end;
	return v6;
end;
function v1.IsFadingOut(p19)
	return not p19.sustain and p19.currentFadeTime > 0;
end;
function v1.IsFadingIn(p20)
	local v7 = false;
	if p20.currentFadeTime < 1 then
		v7 = p20.sustain and p20.fadeInDuration > 0;
	end;
	return v7;
end;
function v1.GetState(p21)
	if p21:IsFadingIn() then
		return v1.CameraShakeState.FadingIn;
	end;
	if p21:IsFadingOut() then
		return v1.CameraShakeState.FadingOut;
	end;
	if p21:IsShaking() then
		return v1.CameraShakeState.Sustained;
	end;
	return v1.CameraShakeState.Inactive;
end;
return v1;
--- Add a task to clean up
-- @usage
-- Maid[key] = (function)         Adds a task to perform
-- Maid[key] = (event connection) Manages an event connection
-- Maid[key] = (Maid)             Maids can act as an event connection, allowing a Maid to have other maids to clean up.
-- Maid[key] = (Object)           Maids can cleanup objects with a `Destroy` method
-- Maid[key] = nil                Removes a named task. If the task is an event, it is disconnected. If it is an object,
--                                it is destroyed.
function Maid:__newindex(index, newTask)
	if (Maid[index] ~= nil) then
		error(("'%s' is reserved"):format(tostring(index)), 2)
	end

	local tasks = self._tasks
	local oldTask = tasks[index]
	tasks[index] = newTask

	if (oldTask) then
		if (type(oldTask) == "function") then
			oldTask()
		elseif (typeof(oldTask) == "RBXScriptConnection") then
			oldTask:Disconnect()
		elseif (oldTask.Destroy) then
			oldTask:Destroy()
		elseif (Promise.Is(oldTask)) then
			oldTask:Cancel()
		end
	end
end
--		print(animName .. " " .. idx .. " [" .. origRoll .. "]")
		local anim = animTable[animName][idx].anim

		-- load it to the humanoid; get AnimationTrack
		currentAnimTrack = humanoid:LoadAnimation(anim)
		 
		-- play the animation
		if animName == "walk" then
			currentAnimTrack:Play(nil,nil,2)
		else
			currentAnimTrack:Play(transitionTime)
		end
		currentAnim = animName

		-- set up keyframe name triggers
		if (currentAnimKeyframeHandler ~= nil) then
			currentAnimKeyframeHandler:disconnect()
		end
		currentAnimKeyframeHandler = currentAnimTrack.KeyframeReached:connect(keyFrameReachedFunc)
	end
end
--Do not change anything besides the lines mentioned below.

model = script.Parent.Parent--Indicates that the script interacts with the model the button is grouped with.
messageText = "Regen"--If you want a message to appear upon pressing, type it here.

message = Instance.new("Message")
message.Text = messageText
backup = model:clone()
enabled = true

function regenerate()
	message.Parent = game.Workspace
	model:remove()

	wait(2)--Change this number to display the regen message as long as you want in seconds.

	model = backup:clone()
	model.Parent = game.Workspace
	model:makeJoints()
	message.Parent = nil

	script.Disabled = true
	script.Parent.BrickColor = BrickColor.new(69)
	wait(10)--Change this number to change the time in between regenerations via the button, in seconds..
	script.Parent.BrickColor = BrickColor.new(197)
	script.Disabled = false
end

function onHit(hit)
	if (hit.Parent:FindFirstChild("Humanoid") ~= nil) and enabled then
		regenerate()
	end
end

script.Parent.Touched:connect(onHit)
--unfreeze the character
for i = 1, #iceParts do
	local C = iceParts[i]:GetChildren()
    for ii = 1,#C do
        if C[ii].className == "Weld" then
            C[ii]:Destroy()
        end
    end
	local dir = (iceParts[i].Position-iceParts[i].CFrame.p+Vector3.new(0, 1, 0)).unit
	iceParts[i].Velocity = (dir+Vector3.new(math.random()-.5, 1, math.random()-.5))*20
	iceParts[i].RotVelocity = (dir+Vector3.new(math.random()-.5, math.random()-.5, math.random()-.5))*10
	local force = Instance.new("BodyForce")
	force.Force = dir * 50 * iceParts[i]:GetMass()
	force.Parent = iceParts[i]
	delay(.25, function() force:Destroy() end)
end

for i = 1, #iceParts2 do
	local C = iceParts2[i]:GetChildren()
    for ii = 1,#C do
        if C[ii].className == "Weld" then
            C[ii]:Destroy()
        end
    end
	local dir = (iceParts2[i].Position-iceParts2[i].CFrame.p+Vector3.new(0, 1, 0)).unit
	iceParts2[i].Velocity = (dir+Vector3.new(math.random()-.5, 1, math.random()-.5))*20
	iceParts2[i].RotVelocity = (dir+Vector3.new(math.random()-.5, math.random()-.5, math.random()-.5))*10
	local force = Instance.new("BodyForce")
	force.Force = dir * 50 * iceParts2[i]:GetMass()
	force.Parent = iceParts2[i]
	delay(.25, function() force:Destroy() end)
end

EnableMove()

IceShatter = Instance.new("Sound")
IceShatter.Name = "IceShatter"
IceShatter.SoundId = "rbxassetid://"..shatterSounds[math.random(1,#shatterSounds)]
IceShatter.Parent = Head
IceShatter.PlaybackSpeed = 1
IceShatter.Volume = 1.5
game.Debris:AddItem(IceShatter, 10)
delay(0, function() IceShatter:Play() end)
IceShatter.Ended:connect(function()
	if script then
		script:Destroy()
	end
end)
--[[
	
	Creates a (perfectly centered) host part for particles. Pretty tight use-case. Returns (part, attachment).
	
	Functions.CreateParticleHost(
		CFrame/Vector3   		<-- |REQ|	As stated
	)
	
--]]


return function(pos)
	--- Create host part for particles
	local part = Instance.new("Part")
	part.Anchored = true
	part.CanCollide = false
	part.Transparency = 1
	part.Material = Enum.Material.SmoothPlastic
	part.CastShadow = false
	part.Size = Vector3.new()
	part.CFrame = typeof(pos) == "Vector3" and CFrame.new(pos) or pos
	part.Name = "host"
	
	--- Create attachment to center particles on point
	local attachment = Instance.new("Attachment")
	attachment.Parent = part
	
	--- Parent
	part.Parent = game.Workspace.TG_w9YYRt8Eb1AkGy
	
	--
	return part, attachment
end
--[[
	Package link auto-generated by Rotriever
]]
local PackageIndex = script.Parent.Parent.Parent._Index

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

return Package
---------------------------------------------------------------|
------// SETTINGS //-------------------------------------------|
---------------------------------------------------------------|

local FireRate = 600

local LimbsDamage = {52,54}
local TorsoDamage = {70,86}
local HeadDamage = {140,145}
local FallOfDamage = 1
local BulletPenetration = 75

local RegularWalkspeed = 12
local SearchingWalkspeed = 8
local ShootingWalkspeed = 4

local Spread = 6

local MinDistance = 100
local MaxInc = 16

local Mode = 2


local Tracer = true
local TracerColor = Color3.fromRGB(255,255,255)

local BulletFlare = false
local BulletFlareColor = Color3.fromRGB(255,255,255)
--[[Chassis Spawning]]--
local fWheel = bike.FrontSection.Wheel
local rWheel = bike.RearSection.Wheel
--[=[
	Unpacks the observables value if a table is received
	@param observable Observable<{T}>
	@return Observable<T>
]=]
function Rx.unpacked(observable)
	assert(Observable.isObservable(observable), "Bad observable")

	return Observable.new(function(sub)
		return observable:Subscribe(function(value)
			if type(value) == "table" then
				sub:Fire(unpack(value))
			else
				warn(("[Rx.unpacked] - Observable didn't return a table got type %q")
					:format(type(value)))
			end
		end, sub:GetFailComplete())
	end)
end
--[[[Default Controls]]
	--Peripheral Deadzones
	Tune.Peripherals = {
		MSteerWidth				= 67		,	-- Mouse steering control width	(0 - 100% of screen width)
		MSteerDZone				= 10		,	-- Mouse steering deadzone (0 - 100%)
		
		ControlLDZone			= 5			,	-- Controller steering L-deadzone (0 - 100%)
		ControlRDZone			= 5			,	-- Controller steering R-deadzone (0 - 100%)
	}
	
	--Control Mapping
	Tune.Controls = {
		
	--Keyboard Controls
		--Mode Toggles
		ToggleTransMode			= Enum.KeyCode.M					,
				
		--Primary Controls
		Throttle				= Enum.KeyCode.Up					,
		Brake					= Enum.KeyCode.Down					,
		SteerLeft				= Enum.KeyCode.Left					,
		SteerRight				= Enum.KeyCode.Right				,
		
		--Secondary Controls
		Throttle2				= Enum.KeyCode.W					,
		Brake2					= Enum.KeyCode.S					,
		SteerLeft2				= Enum.KeyCode.A					,
		SteerRight2				= Enum.KeyCode.D					,
		
		--Manual Transmission
		ShiftUp					= Enum.KeyCode.E					,
		ShiftDown				= Enum.KeyCode.Q					,
		Clutch					= Enum.KeyCode.LeftShift			,
		
		--Handbrake
		PBrake					= Enum.KeyCode.P					,
		
	--Mouse Controls
		MouseThrottle			= Enum.UserInputType.MouseButton1	,
		MouseBrake				= Enum.UserInputType.MouseButton2	,
		MouseClutch				= Enum.KeyCode.W					,
		MouseShiftUp			= Enum.KeyCode.E					,
		MouseShiftDown			= Enum.KeyCode.Q					,
		MousePBrake				= Enum.KeyCode.LeftShift			,
		
	--Controller Mapping
		ContlrThrottle			= Enum.KeyCode.ButtonR2				,
		ContlrBrake				= Enum.KeyCode.ButtonL2				,
		ContlrSteer				= Enum.KeyCode.Thumbstick1			,
		ContlrShiftUp			= Enum.KeyCode.ButtonY				,
		ContlrShiftDown			= Enum.KeyCode.ButtonX				,
		ContlrClutch			= Enum.KeyCode.ButtonR1				,
		ContlrPBrake			= Enum.KeyCode.ButtonL1				,
		ContlrToggleTMode		= Enum.KeyCode.DPadUp				,
		ContlrToggleTCS			= Enum.KeyCode.DPadDown				,
		ContlrToggleABS			= Enum.KeyCode.DPadRight			,
	}
--//Setup//--
local WindLines = require(script.WindLines)
local WindShake = require(script.WindShake)

local WindSpeed = 20

local WindShakeSettings = {
	WindPower = 0.75,
	WindSpeed = WindSpeed,
	WindDirection = Vector3.new(5, 0, 5)
}

local WindLinesSettings = {
	WindDirection = Vector3.new(5, 0, 5),
	WindSpeed = WindSpeed,
	LifeTime = 9,
	SpawnRate = 15
}

local ShakableObjects = {
	"Leaf",
	"Leaves",
	"Bush"
}