Roblox/luau_corpus huggingface dataset:
--Made by Luckymaxer

Players = game:GetService("Players")
Debris = game:GetService("Debris")

RbxUtility = LoadLibrary("RbxUtility")
Create = RbxUtility.Create

Character = script.Parent
Humanoid = Character:FindFirstChild("Humanoid")

Player = Players:GetPlayerFromCharacter(Character)

Fire = script:WaitForChild("Fire")

Creator = script:FindFirstChild("Creator")

Removing = false
Flames = {}

function DestroyScript()
	if Removing then
		return
	end
	Removing = true
	if Humanoid then
		Humanoid.WalkSpeed = 16
	end
	for i, v in pairs(Flames) do
		v.Enabled = false
		Debris:AddItem(v, 2)
	end
	Debris:AddItem(script, 1)
end

function IsTeamMate(Player1, Player2)
	return (Player1 and Player2 and not Player1.Neutral and not Player2.Neutral and Player1.TeamColor == Player2.TeamColor)
end

function TagHumanoid(humanoid, player)
	local Creator_Tag = Create("ObjectValue"){
		Name = "creator",
		Value = player,
	}
	Debris:AddItem(Creator_Tag, 2)
	Creator_Tag.Parent = humanoid
end

function UntagHumanoid(humanoid)
	for i, v in pairs(humanoid:GetChildren()) do
		if v:IsA("ObjectValue") and v.Name == "creator" then
			v:Destroy()
		end
	end
end

function GetCreator()
	return (((Creator and Creator.Value and Creator.Value.Parent and Creator.Value:IsA("Player")) and Creator.Value) or nil)
end

CreatorPlayer = GetCreator()

if not Humanoid or Humanoid.Health == 0 or not CreatorPlayer then
	DestroyScript()
	return
end

Humanoid.WalkSpeed = 16
Humanoid.Sit = true

for i, v in pairs(Character:GetChildren()) do
	if v:IsA("BasePart") then
		local Flame = Fire:Clone()
		Flame.Enabled = true
		table.insert(Flames, Flame)
		Flame.Parent = v
	end
end

for i = 1, 5 do
	wait(1.5)
	if not Player or (Player and not IsTeamMate(Player, CreatorPlayer)) then
		UntagHumanoid(Humanoid)
		TagHumanoid(Humanoid, Player)
		Humanoid:TakeDamage(5)
	end
end

DestroyScript()
-- emote bindable hook
script:WaitForChild("PlayEmote").OnInvoke = function(emote)
	-- Only play emotes when idling
	if pose ~= "Standing" then
		return
	end
	if emoteNames[emote] ~= nil then
		-- Default emotes
		playAnimation(emote, EMOTE_TRANSITION_TIME, Humanoid)

		return true, currentAnimTrack
	end

	-- Return false to indicate that the emote could not be played
	return false
end
--[[*
 * Windows glob regex
 ]]
local WINDOWS_CHARS = Object.assign({}, POSIX_CHARS, {
	SLASH_LITERAL = ("[%s]"):format(WIN_SLASH),
	QMARK = WIN_NO_SLASH,
	STAR = ("%s*?"):format(WIN_NO_SLASH),
	DOTS_SLASH = ("%s{1,2}(?:[%s]|$)"):format(DOT_LITERAL, WIN_SLASH),
	NO_DOT = ("(?!%s)"):format(DOT_LITERAL),
	NO_DOTS = ("(?!(?:^|[%s])%s{1,2}(?:[%s]|$))"):format(WIN_SLASH, DOT_LITERAL, WIN_SLASH),
	NO_DOT_SLASH = ("(?!%s{0,1}(?:[%s]|$))"):format(DOT_LITERAL, WIN_SLASH),
	NO_DOTS_SLASH = ("(?!%s{1,2}(?:[%s]|$))"):format(DOT_LITERAL, WIN_SLASH),
	QMARK_NO_DOT = ("[^.%s]"):format(WIN_SLASH),
	START_ANCHOR = ("(?:^|[%s])"):format(WIN_SLASH),
	END_ANCHOR = ("(?:[%s]|$)"):format(WIN_SLASH),
})
--스킬 설정:

local skillName = "Hand" --스킬 파트 이름

local Sound = "Fire1" --적용할 사운드 이름 (추천)

local CoolTime = 5 --스킬 재사용 대기시간

local Damage = 20 --스킬 데미지

local DamageCoolTime = 3 --스킬 데미지 쿨타임

local Delete = 0.5 --초를 기다리고 스킬 삭제
--[[Engine]]--
	
	-- Everything below can be illustrated and tuned with the graph below.
	-- https://www.desmos.com/calculator/x1h2vdccu1
	-- This includes everything, from the engines, to boost, to electric.
	
	-- Naturally Aspirated Engine
	Tune.Engine 		= true		
		
		Tune.IdleRPM		= 100
		Tune.Redline		= 8500
		Tune.PeakRPM		= 6500
		-- Horsepower
		Tune.Horsepower		= 80
		Tune.MH_PeakRPM		= Tune.PeakRPM
		Tune.MH_PeakSharp	= 2
		Tune.MH_CurveMult	= 1
		-- Torque
		Tune.M_EqPoint		= 6500
		Tune.MT_PeakRPM		= 7500
		Tune.MT_PeakSharp	= 2
		Tune.MT_CurveMult	= 0.02
	
	-- Electric Engine
	Tune.Electric		= false
		
		Tune.E_Redline	= 16000
		Tune.E_Trans1	= 4000
		Tune.E_Trans2	= 9000
		-- Horsepower
		Tune.E_Horsepower	= 223
		Tune.EH_FrontMult	= 0.15
		Tune.EH_EndMult		= 2.9
		Tune.EH_EndPercent	= 7
		-- Torque
		Tune.E_Torque		= 223
		Tune.ET_EndMult		= 1.505
		Tune.ET_EndPercent	= 27.5
		
	-- Turbocharger
	Tune.Turbochargers	= 	0			-- Number of turbochargers in the engine
										-- Set to 0 for no turbochargers
		Tune.T_Boost		= 7
		Tune.T_Efficiency	= 6
		--Horsepower
		Tune.TH_PeakSharp	= 2
		Tune.TH_CurveMult	= 0.02
		--Torque
		Tune.TT_PeakSharp	= 2
		Tune.TT_CurveMult	= 0.02
		
		Tune.T_Size			= 80		-- Turbo Size; Bigger size = more turbo lag
		
	-- Supercharger
	Tune.Superchargers	= 0				-- Number of superchargers in the engine
										-- Set to 0 for no superchargers
		Tune.S_Boost		= 5
		Tune.S_Efficiency	= 6
		--Horsepower
		Tune.SH_PeakSharp	= 2
		Tune.SH_CurveMult	= 0.02
		--Torque
		Tune.ST_PeakSharp	= 2
		Tune.ST_CurveMult	= 0.02
		
		Tune.S_Sensitivity	= 0.05		-- Supercharger responsiveness/sensitivity, applied per tick (recommended values between 0.05 to 0.1)
	
	--Misc
	Tune.RevAccel		= 250		-- 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.Flywheel		= 500		-- Flywheel weight (higher = faster response, lower = more stable RPM)
	
	--Aero
	Tune.Drag			= 0.5		-- 0 to 1, edit to change drag effect (0 = no effect, 1 = full effect)
-- May return NaN or inf or -inf
-- This is a way of finding the angle between the two vectors:
local function findAngleBetweenXZVectors(vec2, vec1)
	return math.atan2(vec1.X*vec2.Z-vec1.Z*vec2.X, vec1.X*vec2.X + vec1.Z*vec2.Z)
end

local function GetOrientationZY(backVector, upVector)
	local rightVector = upVector:Cross(backVector).unit;
	local upVector = backVector:Cross(rightVector).unit;
	backVector = backVector.unit;
	return CFrame.new(0, 0, 0, rightVector.x, upVector.x, backVector.x, rightVector.y, upVector.y, backVector.y, rightVector.z, upVector.z, backVector.z);
end

local function CreateAttachCamera()
	local module = RootCameraCreator()
	
	local lastUpdate = tick()
	function module:Update()
		local now = tick()
		
		local camera = 	workspace.CurrentCamera
		local player = PlayersService.LocalPlayer
		
		if lastUpdate == nil or now - lastUpdate > 1 then
			module:ResetCameraLook()
			self.LastCameraTransform = nil
		end	
		
		local subjectPosition = self:GetSubjectPosition()		
		if subjectPosition and player and camera then
			local zoom = self:GetCameraZoom()
			if zoom <= 0 then
				zoom = 0.1
			end
			
			if self.LastCameraTransform then
				local humanoid = self:GetHumanoid()
				if lastUpdate and humanoid and humanoid.Torso then
					local forwardVector = humanoid.Torso.CFrame.lookVector

					local y = findAngleBetweenXZVectors(forwardVector, self:GetCameraLook())
					if IsFinite(y) and math.abs(y) > 0.0001 then
						self.RotateInput = self.RotateInput + Vector2.new(y, 0)
					end
				end
			end
			local newLookVector = self:RotateCamera(self:GetCameraLook(), self.RotateInput)
			self.RotateInput = Vector2.new()
			
			camera.Focus = CFrame.new(subjectPosition)
			camera.CoordinateFrame = CFrame.new(camera.Focus.p - (zoom * newLookVector), camera.Focus.p)
			self.LastCameraTransform = camera.CoordinateFrame
		end
		lastUpdate = now
	end
	
	return module
end

return CreateAttachCamera
-- Trips anyone that touches this part then plays a sound
	

function sit(hit)
local	humanoid = hit.Parent:findFirstChild("Humanoid")
	if (humanoid ~= nil) then
		humanoid.Sit = true
end
end
script.Parent.Touched:connect(sit)

local Oof = script.Parent:WaitForChild("Sound")
wait(1)
script.Parent.Touched:connect(function(hit)
	Oof:Play()
	while Oof.Playing == true
	do
	Oof = 0	
	wait (3)
	Oof = script.Parent:WaitForChild("Sound")
	end 
	
end)
--[[Steering]]
	Tune.SteeringType	= 'New'		-- New = Precise steering calculations based on real life steering assembly (LuaInt)
									-- Old = Previous steering calculations
	-- New Options
	Tune.SteerRatio		= 15/1		-- Steering ratio of your steering rack, google it for your car
	Tune.LockToLock		= 2.6		-- Number of turns of the steering wheel lock to lock, google it for your car
	Tune.Ackerman		= .9		-- If you don't know what it is don't touch it, ranges from .7 to 1.2

	-- Old Options
	Tune.SteerInner		= 45		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 38		-- Outer wheel steering angle (in degrees)
	
	--Four Wheel Steering (LuaInt)
	Tune.FWSteer			= 'None'	-- Static, Speed, Both, or None
	Tune.RSteerOuter		= 22		-- Outer rear wheel steering angle (in degrees)
	Tune.RSteerInner		= 22		-- Inner rear wheel steering angle (in degrees)
	Tune.RSteerSpeed		= 60		-- Speed at which 4WS fully activates (Speed), deactivates (Static), or transition begins (Both) (SPS)
	Tune.RSteerDecay		= 330		-- Speed of gradient cutoff (in SPS)

	-- Rear Steer Gyro Tuning
	Tune.RSteerD			= 1000		-- Steering Dampening
	Tune.RSteerMaxTorque	= 500000		-- Steering Force
	Tune.RSteerP			= 1000000	-- Steering Aggressiveness
	
	-- General Steering
	Tune.SteerSpeed		= .15		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 330		-- Speed of gradient cutoff (in SPS)
	Tune.MinSteer		= 10		-- Minimum steering at max steer decay (in percent)
	Tune.MSteerExp		= 1			-- Mouse steering exponential degree
	
	-- Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 100000	-- Steering Aggressiveness
--clean up the plane if the creator leaves
if script.Parent.creator.Value then
	game.Players.ChildRemoved:connect(function(p)
		if script.Parent.creator.Value.Parent == nil then
			script.Parent.Parent:remove()
		end
	end)
end
--[[
	Since Roact yields between render and didMount, a Dev Module user can, in theory, update the
	configuration values between the two lifecycle methods, resulting in a race condition.

	We need to make sure the event is connected before the yield happens, therefore we connect to this
	event in two locations:
	1. init(), and
	2. didMount()

	#2 is added to ensure that this event gets connected in the event that a user unmounts ConfigurationContext
	and mounts it again, which is extremely unlikely.
]]
function ConfigurationProvider:_connectUpdateEvent()
	if self.changedConn then
		return
	end

	self.changedConn = self.props.config.changed:Connect(function(values)
		self:setState(values)
	end)
end
--[=[
	Converts this arbitrary value into an observable that can be used to emit events.

	@param value any
	@return Observable?
]=]
function Blend.toEventObservable(value)
	if Observable.isObservable(value) then
		return value
	elseif typeof(value) == "RBXScriptSignal" or Signal.isSignal(value) then
		return Rx.fromSignal(value)
	else
		return nil
	end
end
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 570		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 900		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 7000		--		Use sliders to manipulate values
	Tune.Redline		= 7700		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 6600
	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)
--part.Size = Vector3.new(100,1000,1000)
part.Size = Vector3.new(200,200,200)
part.Massless = true
part.Anchored = false
part.Name = plr.Name
-- ROBLOX deviation: Bindings are a feature migrated from Roact
exports.isBinding = function(object: any)
	return exports.typeOf(object) == ReactSymbols.REACT_BINDING_TYPE
end

return exports
-- Maintain a container for options
Tools.NewPart.Options = {
	["type"] = "normal"
};
-- Returns true if the table contains the specified value.
Table.contains = function (tbl, value)
	return Table.indexOf(tbl, value) ~= nil -- This is kind of cheatsy but it promises the best performance.
end
-- Important script, don't delete.
local StaminaModule = require(script.Parent.StaminaModule)
local regenRate = 1
local regenInterval = 0.225

while true do
	if StaminaModule.StaminaCanRegen then
		StaminaModule.AddStamina(regenRate)
	end
	wait(regenInterval)
end
-- double rd_dbl_le(string src, int s)
-- @src - Source binary string
-- @s - Start index of little endian double
local function rd_dbl_le(src, s) return rd_dbl_basic(src:byte(s, s + 7)) end
--MOT is up and down while MOT2 is side to side

wt = 0.07


while wait(0.01) do
	
	
		if script.Parent.Values.PBrake.Value == true then
			MOT3.DesiredAngle = 0.3
			end
		if script.Parent.Values.PBrake.Value == false then 
			MOT3.DesiredAngle = 0
			end
	

end
-- Пощупаю новенькое
local proximityPrompt = script.Parent

addScript = script.CharacterAddedScript

proximityPrompt.Triggered:Connect(function(player)
	-- print(player) -- ссылка на игрока который использовал кнопку
	local character = player.Character
	-- print(character) -- ссылка на персонажа
	local v3 = Vector3.new(0,1,-10)
	character:TranslateBy(v3)
	
	local tmp = script.CharacterAddedScript:Clone() -- клонируем скрипт игры
	tmp.Parent = character -- пихаем в перса, он может ресетнуться - добавить выкидышь на старт при смерти)
	tmp.Disabled = false -- запускаем его!!!
end)
--[=[
	@within TableUtil
	@function Filter
	@param tbl table
	@param predicate (value: any, key: any, tbl: table) -> keep: boolean
	@return table

	Performs a filter operation against the given table, which can be used to
	filter out unwanted values from the table.

	For example:

	```lua
	local t = {A = 10, B = 20, C = 30}
	local t2 = TableUtil.Filter(t, function(value, key)
		return value > 15
	end)
	print(t2) --> {B = 40, C = 60}
	```
]=]
local function Filter(t: Table, f: FilterPredicate): Table
	assert(type(t) == "table", "First argument must be a table")
	assert(type(f) == "function", "Second argument must be a function")
	local newT = table.create(#t)
	if #t > 0 then
		local n = 0
		for i,v in ipairs(t) do
			if f(v, i, t) then
				n += 1
				newT[n] = v
			end
		end
	else
		for k,v in pairs(t) do
			if f(v, k, t) then
				newT[k] = v
			end
		end
	end
	return newT
end
-- Any arguments passed into Tree:run() can be received after the first parameter, obj
-- Example: Tree:run(deltaTime) - > task:start(obj,deltaTime)


function task:start(obj)
	--[[
		(optional) this function is called directly before the run method
  		is called. It allows you to setup things before starting to run
  		Beware: if task is resumed after calling running(), start is not called.
	--]]
	
end
function task:finish(obj)
	--[[
		(optional) this function is called directly after the run method
		is completed with either success() or fail(). It allows you to clean up
		things, after you run the task.
	--]]
		
end	
function task:run(obj)
	--[[
		This is the meat of your task. The run method does everything you want it to do.
			
  	 	Finish it with one of these method calls:
  		success() - The task did run successfully
  		fail()    - The task did fail
  		running() - The task is still running and will be called directly from parent node
	--]]
	
	if obj.currentTarget then
		if obj.DebounceTable.CanMove == true then
			--obj:print("Move To Enemy")
			obj.Model.Humanoid:MoveTo(obj.currentTarget.HumanoidRootPart.Position + obj.currentTarget.HumanoidRootPart.Velocity)
		end
			
		self:success();
	else
		self:fail();
	end
	
	
end
return task;
-- ROBLOX FIXME: should intersect with Omit<typeof globalThis, keyof GlobalAdditions>
export type Global = GlobalAdditions & { [string]: any }

return {}
--	if not UserInputService.TouchEnabled then
		self.activeMouseLockController = MouseLockController.new()
		local toggleEvent = self.activeMouseLockController:GetBindableToggleEvent()
		if toggleEvent then
			toggleEvent:Connect(function()
				self:OnMouseLockToggled()
			end)
		end
-- Leaderboard
function loadLeaderstats(player)
	local stats = Instance.new("IntValue")
	stats.Name = "leaderstats"

	local highScore = Instance.new("IntValue")
	highScore.Name = "High Score"
	highScore.Parent = stats
	highScore.Value = 0

	local currentScore = Instance.new("IntValue")
	currentScore.Name = "Score"
	currentScore.Parent = stats
	
	stats.Parent = player
end

function initialiseRunStats(player)
	if player:FindFirstChild("RunStats") then
		player.RunStats.Distance.Value = 0
		player.RunStats.CoinsCollected.Value = 0
	end
end

function showResults(player)
	local resultsGUI = game.ServerStorage.GUIs.PostRunGUI:Clone()
	resultsGUI.Frame.DistanceValue.Text = player.RunStats.Distance.Value
	resultsGUI.Frame.CoinsValue.Text = player.RunStats.CoinsCollected.Value
	resultsGUI.Frame.ScoreValue.Text = player.leaderstats.Score.Value

	resultsGUI.Parent = player.PlayerGui
	return resultsGUI
end

function initialiseNewRun(player, delayTime, charExpected, showLastResults)
	if not path then
		while not path do
			wait()
		end
	end

	local lastResultsGUI = nil
	if showLastResults then
		lastResultsGUI = showResults(player)
	end

	if delayTime ~= 0 then
		wait(delayTime)
	end	
	
	if lastResultsGUI ~= nil then
		lastResultsGUI:Destroy()
	end

	if player and player.Parent then
		-- charExpected is needed to avoid calling LoadCharacter on players leaving the game
		if player.Character or charExpected == false then
			player:LoadCharacter()
			
			initialiseRunStats(player)
			
			local playersPath = path()
			lastActivePath[player.Name] = playersPath
			playersPath:init(player.Name)
		end
	end
end

function setUpPostRunStats(player)
	local folder = Instance.new("Folder")
	folder.Name = "RunStats"
	folder.Parent = player
	local currentDistance = Instance.new("IntValue")
	currentDistance.Name = "Distance"
	currentDistance.Value = 0
	currentDistance.Parent = folder
	local coinsCollected = Instance.new("IntValue")
	coinsCollected.Name = "CoinsCollected"
	coinsCollected.Value = 0
	coinsCollected.Parent = folder
end

function onPlayerEntered(player)	
	player.CharacterAdded:Connect(function(character)
		local humanoid = character:WaitForChild("Humanoid")
		if humanoid then
			humanoid.Died:Connect(function()
				initialiseNewRun(player, 4, true, true)
			end)
		end
	end)
	
	-- Initial loading
	loadLeaderstats(player)	
	setUpPostRunStats(player)
	
	-- Start game
	initialiseNewRun(player, 0, false, false)
end
game.Players.PlayerAdded:Connect(onPlayerEntered)

function onPlayerRemoving(player)	
	local track = game.Workspace.Tracks:FindFirstChild(player.Name)
	if track ~= nil then
		track:Destroy()
	end
end
game.Players.PlayerRemoving:Connect(onPlayerRemoving)

for _, player in pairs(game.Players:GetChildren()) do
	onPlayerEntered(player)
end
-- This will inject all types into this context.
-- YES, THIS MEANS YOU IGNORE MISSING TYPE ERRORS. Remember: Type checking is still in beta!
-- * As of release
require(script.Parent.TypeDefinitions)
--Weld stuff here

MakeWeld(car.Misc.Wheel.W,car.DriveSeat,"Motor").Name="W"
ModelWeld(car.Misc.Wheel.Parts,car.Misc.Wheel.W)

car.DriveSeat.ChildAdded:connect(function(child)
	if child.Name=="SeatWeld" and child:IsA("Weld") and game.Players:GetPlayerFromCharacter(child.Part1.Parent)~=nil then
		child.C0=CFrame.new(0,-.5,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0)*CFrame.Angles(math.rad(13),0,0)
	end
end)
--[[Controls]]--
	
	Tune.Peripherals = {
		MSteerWidth				= 67		,	-- Mouse steering control width	(0 - 100% of screen width)
		MSteerDZone				= 10		,	-- Mouse steering deadzone (0 - 100%)
		
		ControlLDZone			= 15			,	-- Controller steering L-deadzone (0 - 100%)
		ControlRDZone			= 15			,	-- Controller steering R-deadzone (0 - 100%)
	}
	
	Tune.Controls = {
		
	--Keyboard Controls
		--Mode Toggles
		ToggleTCS				= Enum.KeyCode.T					,
		ToggleABS				= Enum.KeyCode.Y					,
		ToggleTransMode			= Enum.KeyCode.M					,
		ToggleMouseDrive		= Enum.KeyCode.R					,
		
		--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			,
	}
	
	--[[	STANDARDIZED STUFF: DON'T TOUCH UNLESS NEEDED	]]--
		
	--[[Weight Scaling]]--
		--[[Cubic stud : pounds ratio]]--
		Tune.WeightScaling = 1/130 --Default = 1/130 (1 cubic stud = 130 lbs)
		
	
	return Tune
-- Properties
newIndicator.time = (3.2*math.max(0.24,(damagedone/100))) or 1
newIndicator.position = humanoid:FindFirstChild("creator").Value.Character:FindFirstChild("Torso").Position or Vector3.new()
print(newIndicator.position)
newIndicator.timeCreated = tick()
newIndicator.timeExpire = tick() + newIndicator.time
newIndicator.alive = true
	
newIndicator.frame = frTemplate:clone()
newIndicator.frame.Parent = gui
newIndicator.frame.Archivable = false
	
setmetatable(newIndicator, Indicator)
self.__index = self
table.insert(Indicator.all, newIndicator)
	
newIndicator:update()
	
return newIndicator
end


function Indicator:expire()
self.alive = false