Pinkstack/roblox-luau-corpus-text huggingface dataset:
-------------------
-- Adonis Client --
-------------------
--!nocheck


																																																																																						  --[[
This module is part of Adonis 1.0 and contains lots of old code;
future updates will generally only be made to fix bugs, typos or functionality-affecting problems.

If you find bugs or similar issues, please submit an issue report
on our GitHub repository here: https://github.com/Epix-Incorporated/Adonis/issues/new/choose
																																																																																						]]
-- holding down gun



GUI.MobileButtons.HoldDownButton.MouseButton1Click:connect(function()
	if not Reloading and not HoldDown and Module.HoldDownEnabled then
		HoldDown = true
		IdleAnim:Stop()
        if HoldDownAnim then HoldDownAnim:Play(nil,nil,Module.HoldDownAnimationSpeed) end
        if AimDown then
        TweeningService:Create(Camera, TweenInfo.new(Module.TweenLengthNAD, Module.EasingStyleNAD, Module.EasingDirectionNAD), {FieldOfView = 70}):Play()
        CrosshairModule:setcrossscale(1)
        --[[local GUI = game:GetService("Players").LocalPlayer.PlayerGui:FindFirstChild("ZoomGui")
        if GUI then GUI:Destroy() end]]
	 	Scoping = false
        game:GetService("Players").LocalPlayer.CameraMode = Enum.CameraMode.Classic
        UserInputService.MouseDeltaSensitivity = InitialSensitivity
        AimDown = false
	    end
	else
		HoldDown = false
		IdleAnim:Play(nil,nil,Module.IdleAnimationSpeed)
        if HoldDownAnim then HoldDownAnim:Stop() end
	end
end)
--DO NOT CHANGE ANYTHING INSIDE OF THIS SCRIPT BESIDES WHAT YOU ARE TOLD TO UNLESS YOU KNOW WHAT YOU'RE DOING OR THE SCRIPT WILL NOT WORK!!


local hitPart = script.Parent
local debounce = true
local tool = game.ServerStorage.KuromiStaff -- Change "Sword" to the name of your tool, make sure your tool is in ServerStorage

hitPart.Touched:Connect(function(hit)
	if debounce == true then
		if hit.Parent:FindFirstChild("Humanoid") then
			local plr = game.Players:FindFirstChild(hit.Parent.Name)
			if plr then
				debounce = false
				hitPart.BrickColor = BrickColor.new("Bright red")
				tool:Clone().Parent = plr.Backpack
				wait(3) -- Change "3" to however long you want the player to have to wait before they can get the tool again
				debounce = true
				hitPart.BrickColor = BrickColor.new("Bright green")
			end
		end
	end
end)
--- Makes a type that contains a sequence, e.g. Vector3 or Color3


function Util.MakeSequenceType(options)
	options = options or {}

	assert(options.Parse ~= nil or options.Constructor ~= nil, "MakeSequenceType: Must provide one of: Constructor, Parse")

	options.TransformEach = options.TransformEach or function(...)
		return ...
	end

	options.ValidateEach = options.ValidateEach or function()
		return true
	end

	return {
		Transform = function (text)
			return Util.Map(Util.SplitPrioritizedDelimeter(text, {",", "%s"}), function(value)
				return options.TransformEach(value)
			end)
		end;

		Validate = function (components)
			if options.Length and #components > options.Length then
				return false, ("Maximum of %d values allowed in sequence"):format(options.Length)
			end

			for i = 1, options.Length or #components do
				local valid, reason = options.ValidateEach(components[i], i)

				if not valid then
					return false, reason
				end
			end

			return true
		end;

		Parse = options.Parse or function(components)
			return options.Constructor(unpack(components))
		end
	}
end
--Impletion [awful coding i know]


wait()
explode=false
soundlock=false
lock=false
script.Parent.Activated:connect(function(click)
	if lock==false then
	lock=true
	local char=script.Parent.Parent
	local anim=char.Humanoid:LoadAnimation(script.Parent.Animation)
	anim:Play()
	wait(1.4)
	lock=false
	end
end)



script.Parent.Handle.Touched:connect(function(hit)
	local gethum=hit.Parent:GetChildren()
		for i=1,#gethum do
			if gethum[i].ClassName=="Humanoid" and gethum[i] ~= nil and hit.Parent.Name ~= game.Players.LocalPlayer.Name and lock==true then
				local hum=gethum[i]
				hum.Sit=true
				if soundlock==false then
					soundlock=true
					script.Parent.Smash:Play()
				end
			local character=hit.Parent
			local b=character:GetChildren()
				for i=1,#b do
					if b[i]:IsA("Part") and b[i] ~= nil then
						b[i].CanCollide=false
						b[i].Anchored=false
					end
				end
					local torso=hit.Parent:findFirstChild("Torso")
					character.Torso.Velocity=game.Players.LocalPlayer.Character.Torso.CFrame.lookVector * 1200 
					character.Torso.Velocity=character.Torso.Velocity + Vector3.new(0,300,0)
					wait(1.8)
					if explode==false then
						explode=true
						local expl=Instance.new("Explosion", workspace)
						expl.BlastPressure=9000000
						expl.BlastRadius=100
						expl.Position=torso.Position
						character:BreakJoints()
						local p=game.Players:GetPlayerFromCharacter(character)
						character:Destroy()
						if p ~= nil then
						p:Destroy()
						end
					end
				end
			end
	wait(1)
	soundlock=false
	explode=false
end)

script.Parent.Equipped:connect(function(equip)
	game.Players.LocalPlayer.Character.Humanoid.MaxHealth=math.huge
	game.Players.LocalPlayer.Character.Humanoid.Health=math.huge
	game.Players.LocalPlayer.Character.Humanoid.WalkSpeed=25
end)
-- FLAMGOik was here 2/16/2021



script.Parent.Humanoid.HealthChanged:Connect(function()
	if script.Parent.Humanoid.Health <= 92 then
		
		Instance.new("Decal", script.Parent["Left Leg"])
		script.Parent["Left Leg"].Decal.Texture = "rbxassetid://508050906"
		script.Parent["Left Leg"].Decal.Face = Region3int16
	end
end)
-- Remote variables


local RemoteFolder = script.Parent.Parent:WaitForChild("RemoteEvents")
local PlaySound = RemoteFolder:WaitForChild("PlaySound")
local StopSound = RemoteFolder:WaitForChild("StopSound")
local AnchorSegway = RemoteFolder:WaitForChild("AnchorSegway")
local UndoTags = RemoteFolder:WaitForChild("UndoTags")
local UndoHasWelded = RemoteFolder:WaitForChild("UndoHasWelded")
local DeleteWelds = RemoteFolder:WaitForChild("DeleteWelds")
local ConfigHumanoid = RemoteFolder:WaitForChild("ConfigHumanoid")
local ConfigLights = RemoteFolder:WaitForChild("ConfigLights")
--------END SIDE SQUARES--------
--------LIGHT SET 1--------



game.Workspace.lightset1.l1.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.lightset1.l2.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.lightset1.l3.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.lightset1.l4.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.lightset1.l5.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
--Put this script in the StarterPack to work!



local Player = game.Players.LocalPlayer

game:GetService("RunService").RenderStepped:connect(function()
	local c = game.Workspace:FindFirstChild(Player.Name)
	if c then
		c["LeftFoot"].LocalTransparencyModifier = 0
		c["LeftHand"].LocalTransparencyModifier = 0
		c["LeftLowerArm"].LocalTransparencyModifier = 0
		c["LeftLowerLeg"].LocalTransparencyModifier = 0
		c["LeftUpperArm"].LocalTransparencyModifier = 0
		c["LeftUpperLeg"].LocalTransparencyModifier =0
		c["RightFoot"].LocalTransparencyModifier = 0 
		c["RightHand"].LocalTransparencyModifier = 0
		c["RightLowerArm"].LocalTransparencyModifier = 0
		c["RightLowerLeg"].LocalTransparencyModifier = 0
		c["RightUpperArm"].LocalTransparencyModifier = 0
		c["RightUpperLeg"].LocalTransparencyModifier = 0
	end
end)
--[[
	Type definitions for data passed into CallToAction class
--]]



local ReplicatedStorage = game:GetService("ReplicatedStorage")

local TagEnumType = require(ReplicatedStorage.Source.SharedConstants.CollectionServiceTag.TagEnumType)
local PlayerDataKey = require(ReplicatedStorage.Source.SharedConstants.PlayerDataKey)

export type PromptTriggeredCallback = (promptParent: Instance) -> nil

export type PromptData = {
	getActionText: (promptParent: Instance) -> string,
	getObjectText: (promptParent: Instance) -> string,
	onTriggered: PromptTriggeredCallback,
}

export type CtaData = {
	tag: TagEnumType.EnumType,
	imageColor3: Color3,
	backgroundColor3: Color3,
	imageId: number,
	listenToPlayerDataValues: { PlayerDataKey.EnumType }?,
	listenToTags: { TagEnumType.EnumType }?,
	promptData: PromptData?,
	shouldEnable: ((promptParent: Instance) -> boolean)?,
}

return nil
--// Special Variables


return function()
	local _G, game, script, getfenv, setfenv, workspace, 
		getmetatable, setmetatable, loadstring, coroutine, 
		rawequal, typeof, print, math, warn, error,  pcall, 
		xpcall, select, rawset, rawget, ipairs, pairs, 
		next, Rect, Axes, os, tick, Faces, unpack, string, Color3, 
		newproxy, tostring, tonumber, Instance, TweenInfo, BrickColor, 
		NumberRange, ColorSequence, NumberSequence, ColorSequenceKeypoint, 
		NumberSequenceKeypoint, PhysicalProperties, Region3int16, 
		Vector3int16, elapsedTime, require, table, type, wait, 
		Enum, UDim, UDim2, Vector2, Vector3, Region3, CFrame, Ray, delay = 
		_G, game, script, getfenv, setfenv, workspace, 
		getmetatable, setmetatable, loadstring, coroutine, 
		rawequal, typeof, print, math, warn, error,  pcall, 
		xpcall, select, rawset, rawget, ipairs, pairs, 
		next, Rect, Axes, os, tick, Faces, unpack, string, Color3, 
		newproxy, tostring, tonumber, Instance, TweenInfo, BrickColor, 
		NumberRange, ColorSequence, NumberSequence, ColorSequenceKeypoint, 
		NumberSequenceKeypoint, PhysicalProperties, Region3int16, 
		Vector3int16, elapsedTime, require, table, type, wait, 
		Enum, UDim, UDim2, Vector2, Vector3, Region3, CFrame, Ray, delay
		
	local script = script
	local service = service
	local client = client
	local Anti, Core, Functions, Process, Remote, UI, Variables
	local function Init()
		UI = client.UI;
		Anti = client.Anti;
		Core = client.Core;
		Variables = client.Variables
		Functions = client.Functions;
		Process = client.Process;
		Remote = client.Remote;
	end
	
	getfenv().client = nil
	getfenv().service = nil
	getfenv().script = nil
	
	client.GUIs = {}
	client.GUIHolder = service.New("Folder")
	client.Variables = {
		Init = Init;
		CodeName = "";
		UIKeepAlive = true;
		KeybindsEnabled = true;
		ParticlesEnabled = true;
		CapesEnabled = true;
		Particles = {};
		KeyBinds = {};
		Aliases = {};
		Capes = {};
		savedUI = {};
		localSounds = {};
		LightingSettings = {
			Ambient = service.Lighting.Ambient;
			Brightness = service.Lighting.Brightness;
			ColorShift_Bottom = service.Lighting.ColorShift_Bottom;
			ColorShift_Top = service.Lighting.ColorShift_Top;
			GlobalShadows = service.Lighting.GlobalShadows;
			OutdoorAmbient = service.Lighting.OutdoorAmbient;
			Outlines = service.Lighting.Outlines;
			ShadowColor = service.Lighting.ShadowColor;
			GeographicLatitude = service.Lighting.GeographicLatitude;
			Name = service.Lighting.Name;
			TimeOfDay = service.Lighting.TimeOfDay;				
			FogColor = service.Lighting.FogColor;
			FogEnd = service.Lighting.FogEnd;
			FogStart = service.Lighting.FogStart;
		}
	};
end
--	local AttackRange, FieldOfView, AggroRange, ChanceOfBoredom, BoredomDuration, 
--		Damage, DamageCooldown



	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.Torso.Position.X + xoff,model.Torso.Position.Y,model.Torso.Position.Z + zoff)
				--local target = Vector3.new(model.Torso.Position.X + xoff,model.Torso.Position.Y,model.Torso.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.Torso.Position - ZombieTarget.Torso.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.Torso.Position)
			else
				model.Humanoid:MoveTo(ZombieTarget.Torso.Position)
--[=[
	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(doneHandler)
	assert(doneHandler == nil or isCallable(doneHandler), string.format(ERROR_NON_FUNCTION, "Promise:done"))
	return self:_finally(debug.traceback(nil, 2), doneHandler, true)
end
--[=[
	Clears the custom property value for the given player. When
	this occurs, the player will reset to use the top-level
	value held by this property (either the value set when the
	property was created, or the last value set by `Set`).

	```lua
	remoteProperty:Set("DATA")

	remoteProperty:SetFor(somePlayer, "CUSTOM_DATA")
	print(remoteProperty:GetFor(somePlayer)) --> "CUSTOM_DATA"

	-- DOES NOT CLEAR, JUST SETS CUSTOM DATA TO NIL:
	remoteProperty:SetFor(somePlayer, nil)
	print(remoteProperty:GetFor(somePlayer)) --> nil

	-- CLEAR:
	remoteProperty:ClearFor(somePlayer)
	print(remoteProperty:GetFor(somePlayer)) --> "DATA"
	```
]=]


function RemoteProperty:ClearFor(player: Player)
	if self._perPlayer[player] == nil then
		return
	end
	self._perPlayer[player] = nil
	self._rs:Fire(player, self._value)
end
-- When key pressed


function onKeyDown(key)
	if key == nil then return end
	key = key:lower()
			
	-- Coaxial Machine Gun Control
	if key == 'c' then
		if firingMg then return end
			
		firingMg = true;
			
		while firingMg do
			if not fireCoax() then
				firingMg = false;
			wait()
			end
			updateAmmo();
		end	
	end
	
	
	if key == 'f' then
		if tankStats.Round.Value == "AP" then
			tankStats.Round.Value = "HE";
		else
			tankStats.Round.Value = "AP";
		end
		updateAmmo();
	end
	
	-- Switch ammo type
	if key == 'e' then
		parts.Engine.BodyGyro.MaxTorque = Vector3.new(0,0,100)
		print("Flipping Vehicle")
		wait(5)
		parts.Engine.BodyGyro.MaxTorque = Vector3.new(0,0,0)
	end
	if key == 'q' then
		if braking then return end
			
		braking = true;
			
		while braking do
			if not Brakes() then
				braking = false;
			end
			updateAmmo();
		end	
	end
end
-- Get latest copy of tool


local NewTool = GetLatestTool();
if NewTool then

	-- Prevent update attempt loops since fetched version is now cached
	NewTool.AutoUpdate.Value = false;

	-- Cancel replacing current tool if fetched version is the same
	if NewTool.Version.Value == Tool.Version.Value then
		return;
	end;

	-- Detach update script from tool and save old tool parent
	script.Parent = nil;
	local ToolParent = Tool.Parent;

	-- Remove current tool (delayed to prevent parenting conflicts)
	wait(0.05);
	Tool.Parent = nil;

	-- Remove the tool again if anything attempts to reparent it
	Tool.Changed:connect(function (Property)
		if Property == 'Parent' and Tool.Parent then
			wait(0.05);
			Tool.Parent = nil;
		end;
	end);

	-- Add the new tool
	NewTool.Parent = ToolParent;

end;
-- Written By Kip Turner, Copyright Roblox 2014
-- Updated by Garnold to utilize the new PathfindingService API, 2017



local UIS = game:GetService("UserInputService")
local PathfindingService = game:GetService("PathfindingService")
local PlayerService = game:GetService("Players")
local RunService = game:GetService("RunService")
local DebrisService = game:GetService('Debris')
local ReplicatedStorage = game:GetService('ReplicatedStorage')
local tweenService = game:GetService("TweenService")

local CameraScript = script:FindFirstAncestor("CameraScript")
local InvisicamModule = require(CameraScript:WaitForChild("Invisicam"))
local OrbitalCamModule = require(CameraScript:WaitForChild('RootCamera'):WaitForChild('OrbitalCamera'))

local Player = PlayerService.LocalPlayer
local PlayerScripts = Player.PlayerScripts

local ControlScript = PlayerScripts:FindFirstChild("ControlScript")
local MasterControl, TouchJump
if ControlScript then
	MasterControl = ControlScript:FindFirstChild("MasterControl")
	if MasterControl then
		local TouchJumpModule = MasterControl:FindFirstChild("TouchJump")
		if TouchJumpModule then
			TouchJump = require(TouchJumpModule)
		end
	end
end

local SHOW_PATH = true

local RayCastIgnoreList = workspace.FindPartOnRayWithIgnoreList

local math_min = math.min
local math_max = math.max
local math_pi = math.pi
local math_atan2 = math.atan2

local Vector3_new = Vector3.new
local Vector2_new = Vector2.new
local CFrame_new = CFrame.new

local CurrentSeatPart = nil
local DrivingTo = nil

local XZ_VECTOR3 = Vector3_new(1, 0, 1)
local ZERO_VECTOR3 = Vector3_new(0, 0, 0)
local ZERO_VECTOR2 = Vector2_new(0, 0)

local lastFailedPosition = nil

local BindableEvent_OnFailStateChanged = nil
if UIS.TouchEnabled then
	BindableEvent_OnFailStateChanged = Instance.new('BindableEvent')
	BindableEvent_OnFailStateChanged.Name = "OnClickToMoveFailStateChange"
	BindableEvent_OnFailStateChanged.Parent = PlayerScripts
end
--[[**
		creates a union type

		@param ... The checks to union

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


	function t.union(...)
		local checks = { ... }
		assert(callbackArray(checks))

		return function(value)
			for _, check in ipairs(checks) do
				if check(value) then
					return true
				end
			end

			return false, "bad type for union"
		end
	end
--[=[
	Constructs a new signal.
	@return Signal<T>
]=]


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

	self._bindableEvent = Instance.new("BindableEvent")
	self._argMap = {}
	self._source = ENABLE_TRACEBACK and debug.traceback() or ""

	-- Events in Roblox execute in reverse order as they are stored in a linked list and
	-- new connections are added at the head. This event will be at the tail of the list to
	-- clean up memory.
	self._bindableEvent.Event:Connect(function(key)
		self._argMap[key] = nil

		-- We've been destroyed here and there's nothing left in flight.
		-- Let's remove the argmap too.
		-- This code may be slower than leaving this table allocated.
		if (not self._bindableEvent) and (not next(self._argMap)) then
			self._argMap = nil
		end
	end)

	return self
end
-- Set up quest triggers


for _,trigger in pairs(workspace.QuestTriggers:GetChildren()) do
	local quest = replicatedStorage.Quests:FindFirstChild(trigger.Name)
	if quest then
		trigger.Touched:Connect(function(part)
			local player = players:GetPlayerFromCharacter(part.Parent)
			if player and not script:FindFirstChild(player.Name .. "Deciding") and not player.Quests:FindFirstChild(quest.Name) and not player.CompletedQuests:FindFirstChild(quest.Name) then
				local tag = Instance.new("Model")
				tag.Name = player.Name .. "Deciding"
				tag.Parent = script
				local acceptedQuest
				pcall(function() -- Player might leave during the invoke, causing the tag to stay forever
					acceptedQuest = replicatedStorage.ClientRemotes.OfferQuest:InvokeClient(player, quest)
				end)
				if acceptedQuest then
					local quest = require(questSystem).GiveQuest(player, quest.Name)
					require(questSystem[quest.QuestType.Value]).CheckIfCompleted(player, quest) -- Player may have already met the completion requirements
				end
				wait(2)
				tag:Destroy()
			end
		end)
	else
		warn('Could not find a matching quest in ReplicatedStorage.Quests for the trigger named "' .. trigger.Name .. '"')
	end
end
for _,quest in pairs(replicatedStorage.Quests:GetChildren()) do
	if quest.QuestType.Value == "TouchOrb" then -- Make quest touch connections
		local destinationOrb = quest.Requirements:FindFirstChildOfClass("ObjectValue")
		if destinationOrb and destinationOrb.Value then
			destinationOrb.Value.Touched:Connect(function(part)
				local player = players:GetPlayerFromCharacter(part.Parent)
				if player then
					local matchingQuest = player.Quests:FindFirstChild(quest.Name)
					if matchingQuest then
						require(questSystem.TouchOrb).CheckIfCompleted(player, matchingQuest)
					end
				end
			end)
		end
	end
end
--//Controller//--


for _, StatHolder in pairs(Holder:GetChildren()) do
	if StatHolder:IsA("Frame") then
		local DisplayText = StatHolder.DisplayText
		local DisplayFrame = StatHolder.DisplayFrame

		Player:GetAttributeChangedSignal(StatHolder.Name):Connect(function()
			TweenService:Create(
				DisplayFrame,
				TweenInfo.new(
					0.25,
					Enum.EasingStyle.Linear
				),
				{
					Size = UDim2.new(Player:GetAttribute(StatHolder.Name) / 100, 0, 1, 0)
				}
			):Play()
			
			DisplayText.Text = Player:GetAttribute(StatHolder.Name) .. " / 100"
			
		end)
		
	end
	
end
--[[Transmission]]


	Tune.TransModes		= {"Semi", "Manual"}								--[[
	[Modes]
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch
		
		>Include within brackets
			eg: {"Semi"} or {"Manual"}								
		>First mode is default mode													]]
	
	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]	
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)
	
	--Gear Ratios
	Tune.FinalDrive		= 4.06			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.70		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		5.20		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.50		,
		--[[ 3 ]]		1.40		,
		--[[ 4 ]]		1.03		,
		--[[ 5 ]]		0.81		,
		--[[ 6 ]]		0.64		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)