Roblox/luau_corpus huggingface dataset:
-- Implements Javascript's `Map.prototype.forEach` as defined below
-- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach
function Map:forEach<K, V>(callback: callbackFn<K, V> | callbackFnWithThisArg<K, V>, thisArg: Object?): ()
	if typeof(callback) ~= "function" then
		error("callback is not a function")
	end

	return Array.forEach(self._array, function(key: K)
		local value: V = self._map[key] :: V

		if thisArg ~= nil then
			(callback :: callbackFnWithThisArg<K, V>)(thisArg, value, key, self)
		else
			(callback :: callbackFn<K, V>)(value, key, self)
		end
	end)
end

function Map:has(key): boolean
	return self._map[key] ~= nil
end

function Map:keys()
	return self._array
end

function Map:values()
	return Array.map(self._array, function(key)
		return self._map[key]
	end)
end

function Map:entries()
	return Array.map(self._array, function(key)
		return { key, self._map[key] }
	end)
end

function Map:ipairs()
	return ipairs(self:entries())
end

function Map.__index(self, key)
	local mapProp = rawget(Map, key)
	if mapProp ~= nil then
		return mapProp
	end

	return Map.get(self, key)
end

function Map.__newindex(table_, key, value)
	table_:set(key, value)
end

local function coerceToMap(mapLike: Map<any, any> | Table<any, any>): Map<any, any>
	return instanceOf(mapLike, Map) and mapLike :: Map<any, any> -- ROBLOX: order is preservered
		or Map.new(Object.entries(mapLike)) -- ROBLOX: order is not preserved
end

local function coerceToTable(mapLike: Map<any, any> | Table<any, any>): Table<any, any>
	if not instanceOf(mapLike, Map) then
		return mapLike
	end

	-- create table from map
	return Array.reduce(mapLike:entries(), function(tbl, entry)
		tbl[entry[1]] = entry[2]
		return tbl
	end, {})
end

return {
	Map = Map,
	coerceToMap = coerceToMap,
	coerceToTable = coerceToTable,
}
-- Either a constant value of type T, or a state object containing type T.
export type CanBeState<T> = StateObject<T> | T
--[[
Runs the fire animation.
--]]
function EggCreator:PlayLaunchAnimation()
	--Launch the arm.
	ReleaseMotor.DesiredAngle = 3
	wait(ANIMATION_TIME)
	Egg.Transparency = 1

	--Delay the animation.
	wait(ANIMATION_DELAY_TIME)
	
	--Reset the arm.
	ReleaseMotor.DesiredAngle = 0
	wait(ANIMATION_TIME)
	
	--Reset the egg.
	wait(RELOAD_TIME - (2* ANIMATION_TIME) - ANIMATION_DELAY_TIME)
	Egg.Transparency = 0	
end



return EggCreator
--[[Run]]

	--Print Version
	local ver=require(car["A-Chassis Tune"].README)
	print("Novena: AC6T Loaded - Build "..ver)
	
	--Runtime Loops
	
	-- ~60 c/s
	game["Run Service"].Stepped:connect(function()
		--Steering
		Steering()
		
		--RPM
		RPM()
		
		--Suspension
		if not workspace:PGSIsEnabled() and _Tune.SusEnabled then
			Suspension()
		end
		
		--Power
		Engine()
		
		--Update External Values
		_IsOn = script.Parent.IsOn.Value
		_InControls = script.Parent.ControlsOpen.Value
		script.Parent.Values.Gear.Value = _CGear
		script.Parent.Values.RPM.Value = _RPM
		script.Parent.Values.Boost.Value = (_Boost/2)*_TPsi
		script.Parent.Values.Horsepower.Value = _HP
		script.Parent.Values.HpNatural.Value = _NH
		script.Parent.Values.HpBoosted.Value = _BH*(_Boost/2)
		script.Parent.Values.Torque.Value = _HP * _Tune.EqPoint / _RPM
		script.Parent.Values.TqNatural.Value = _NT
		script.Parent.Values.TqBoosted.Value = _BT*(_Boost/2)
		script.Parent.Values.TransmissionMode.Value = _TMode
		script.Parent.Values.Throttle.Value = _GThrot*_GThrotShift
		script.Parent.Values.Brake.Value = _GBrake
		script.Parent.Values.SteerC.Value = _GSteerC*(1-math.min(car.DriveSeat.Velocity.Magnitude/_Tune.SteerDecay,1-(_Tune.MinSteer/100)))
		script.Parent.Values.SteerT.Value = _GSteerT
		script.Parent.Values.PBrake.Value = _PBrake
		script.Parent.Values.TCS.Value = _TCS
		script.Parent.Values.TCSActive.Value = _TCSActive
		script.Parent.Values.TCSAmt.Value = 1-_TCSAmt
		script.Parent.Values.ABS.Value = _ABS
		script.Parent.Values.ABSActive.Value = _ABSActive
		script.Parent.Values.MouseSteerOn.Value = _MSteer
		script.Parent.Values.Velocity.Value = car.DriveSeat.Velocity
	end)
	
	--15 c/s
	while wait(.0667) do
		--Automatic Transmission
		if _TMode == "Auto" then Auto() end
		
		--Flip
		if _Tune.AutoFlip then Flip() end
	end
--[[Weight and CG]]
	Tune.Weight			= 3214		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		6		,
	 --[[Height]]		4		,
	 --[[Length]]		15		}
	Tune.WeightDist		= 51		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible
	
	--Unsprung Weight
	Tune.FWheelDensity	= .1		-- Front Wheel Density
	Tune.RWheelDensity	= .1		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]
	
	Tune.AxleSize		= 2			-- Size of structural members (larger = MORE STABLE / carry more weight)
	Tune.AxleDensity	= .1		-- Density of structural members
--Handles the ball being touched.
local function SlingshotBallHit(TouchPart)
	if TouchPart.Name == "Handle" or not TouchPart.Parent then return end
	
	local HitHumanoid = TouchPart.Parent:FindFirstChild("Humanoid")
	if HitHumanoid and HitHumanoid.Parent ~= LastHitCharacter then
		if SLINGSHOT_START_DAMAGE == CurrentDamage and TouchPart.Parent == FiredCharacter then 
			return 
		end
		
		LastHitCharacter = HitHumanoid.Parent
		PlayerDamager:DamageHumanoid(GetReflectedByPlayer() or FiredPlayer,HitHumanoid,CurrentDamage,GetDamageName())
	else
		if not TouchPart.CanCollide then return end
		CurrentDamage = CurrentDamage/1.42
		
		if CurrentDamage < 1 and TouchConnection then
			TouchConnection:disconnect()
			TouchConnection = nil
			SlingshotBall:Destroy()
		end
	end
end
-- Make signal strict
setmetatable(Signal, {
	__index = function(_tb, key)
		error(("Attempt to get Signal::%s (not a valid member)"):format(tostring(key)), 2)
	end,
	__newindex = function(_tb, key, _value)
		error(("Attempt to set Signal::%s (not a valid member)"):format(tostring(key)), 2)
	end,
})

return {
	new = Signal.new,
}
--
--
Monster:Initialize()
Monster:InitializeUnique()

while true do
	if not Monster:IsAlive() then
		if Data.IsDead == false then
			Data.IsDead = true
			Data.TimeOfDeath = tick()
			Self.Died:Fire()
		end
		if Data.IsDead == true then
			if tick()-Data.TimeOfDeath > Info.RespawnWaitTime then
				Monster:Respawn()
			end
		end
	end
	
	if Monster:IsAlive() then
		Monster:Update()
	end
	
	wait()
end
--[[Steering]]
	Tune.SteerInner		= 21		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 19		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .12		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 320		-- Speed of gradient cutoff (in SPS)
	Tune.MinSteer		= 1 		-- 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			= 20000	    -- Steering Aggressiveness
--[=[
	Use to determine if the given GuiObject or Rect is within the other
	GuiObject or Rect. This will fail if part of the given GuiObject or Rect
	extends beyond the extents of the other GuiObject or Rect.

	This can be useful in making sure child UI elements do not accidentally leak
	outside of their containers.

	```lua
	expect(a).toBeInside(b) --  Jest
	expect(a).to.be.inside(b) -- TestEZ
	```

	![Example of inside(a, b)](/inside(a,%20b).png)

	@tag relationship
	@within CollisionMatchers2D
]=]
local function inside(a: GuiObject | Rect, b: GuiObject | Rect)
	local aRect = toRect(a)
	local bRect = toRect(b)

	return returnValue(
		isPointInside(aRect.Min, bRect) and isPointInside(aRect.Max, bRect),
		"Is inside the element",
		"Is not inside the element"
	)
end

return inside
--[[Misc]]
	Tune.LoadDelay		= .2		-- Delay before initializing chassis (in seconds)
	Tune.AutoStart		= false		-- Set to false if using manual ignition plugin
	Tune.AutoFlip		= true		-- Set to false if using manual flip plugin
--[[
Applies the theme.
--]]
return function(MapModel)
	--Replace the colors.
	ReplaceColors(MapModel,BrickColor.new("Bright green"),BrickColor.new("Institutional white"))
end
--onselected, save shoulders and get player
script.Parent.Equipped:connect(function()
	if selected then return end
	selected = true
	player = game.Players:playerFromCharacter(script.Parent.Parent)
	local ch = script.Parent.Parent
	WaitForChild(ch, "Torso")
	RSH = WaitForChild(ch.Torso, "Right Shoulder")
	LSH = WaitForChild(ch.Torso, "Left Shoulder")
	GRP = WaitForChild(ch["Right Arm"], "RightGrip")
	_G.Grip = GRP
	--
	RSH.Part1 = nil
	LSH.Part1 = nil
	--
	RW.Part0 = ch.Torso
	RW.C0 = CFrame.new(1.5, 0.5, 0) --* CFrame.fromEulerAnglesXYZ(1.3, 0, -0.5)
	RW.C1 = CFrame.new(0, 0.5, 0)
	RW.Part1 = ch["Right Arm"]
	RW.Parent = ch.Torso
	_G.R = RW
	--
	LW.Part0 = ch.Torso
	LW.C0 = CFrame.new(-1.5, 0.5, 0) --* CFrame.fromEulerAnglesXYZ(1.7, 0, 0.8)
	LW.C1 = CFrame.new(0, 0.5, 0)
	LW.Part1 = ch["Left Arm"]
	LW.Parent = ch.Torso
	_G.L = LW
	--
	--GRP.C0 = CFrame.new(0, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
	--Bring_Arm_Up animation
	for i = 0, 1, 0.05 do
		wait()
		RW.C0 = CFrame.new(1.5, 0.5, 0) * CFrame.fromEulerAnglesXYZ(1.5*i, 0, -0.5*i)
		LW.C0 = CFrame.new(-1.5, 0.5, 0) * CFrame.fromEulerAnglesXYZ(1.6*i, 0, 0.7*i)	
		LW.C1 = CFrame.new(-0.3*i, 1.7*i, 0)
	end
	--put in grip
	wait()
	local rg = (ch["Right Arm"]:FindFirstChild("RightGrip") or GRP)
	if rg ~= GRP then
		GRP.Parent = ch["Right Arm"]
		rg:remove()
	end
end)
--Settings
local MaxDistance = 15
local TimeToEnter = 0.7
local EnterKey = Enum.KeyCode.E
local EnterButton = Enum.KeyCode.ButtonX
--------------------------------------------------
script.Parent.Values.RPM.Changed:connect(function()
	intach.Rotation = -65 + script.Parent.Values.RPM.Value * 250 / 8000
end)

script.Parent.Values.Velocity.Changed:connect(function(property)
	inspd.Rotation = -30 + (440 / 160) * (math.abs(script.Parent.Values.Velocity.Value.Magnitude*((10/12) * (50/88))))
end)

script.Parent.Values.Gear.Changed:connect(function()
	local gearText = script.Parent.Values.Gear.Value
	if gearText == 0 then 
		gearText = "N"
		car.Body.Dash.DashSc.G.Gear.Text = "N"
		car.DriveSeat.Filter:FireServer('reverse',false)
	elseif gearText == -1 then
		gearText = "R"
		car.Body.Dash.DashSc.G.Gear.Text = "R"
		car.DriveSeat.Filter:FireServer('reverse',true)
	end
	car.Body.Dash.DashSc.G.Gear.Text = gearText
end)

script.Parent.Values.PBrake.Changed:connect(function()
	dash.PBrake.Visible = script.Parent.Values.PBrake.Value
end)
--[[

	LOWGames Studios
	Date: 27 October 2022
	by Elder
	
]]--

local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library"));
end)();

return function(p1)
	local f 
	f = p1.Touched:Connect(function()

	end)
	local v1 = p1:GetTouchingParts();
	f:Disconnect();
	return v1;
end;
-- functions

local function GetSquad(player)
	for _, squad in pairs(SQUADS:GetChildren()) do
		if squad:FindFirstChild(player.Name) then
			return squad
		end
	end
end
-- teererererererphof
local player = game.Players:GetPlayerFromCharacter(script.Parent.Parent)

if player ~= nil then
-- ROBLOX TODO: Uncomment this type once Luau has supported ... syntax
-- type Function = (...) -> any;
-- ROBLOX TODO: Fix once Luau has support for default type arguments
type MockDefaultY = Array<any>
type MockFunctionState<T, Y> = {
	calls: Array<Y>,
	instances: Array<T>,
	invocationCallOrder: Array<number>,
	results: Array<MockFunctionResult>,
}
--Get User Input
game:GetService("UserInputService").InputBegan:Connect(function(InputObj)
	if InputObj.UserInputType == Enum.UserInputType.Keyboard then
		if InputObj.KeyCode == EnterKey then
			if AdornedSeat then
				EnterStart("Keyboard")
			else
				ExitSeat()
			end
		end
	elseif InputObj.KeyCode == EnterButton then
		if AdornedSeat then
			EnterStart("Gamepad")
		else
			ExitSeat()
		end
	end	
end)

game:GetService("UserInputService").InputEnded:Connect(function(InputObj)
	if InputObj.UserInputType == Enum.UserInputType.Keyboard then
		if InputObj.KeyCode == EnterKey then
			EnterKeyDown = false
		end
	elseif InputObj.KeyCode == EnterButton then
		if AdornedSeat then
			EnterKeyDown = false
		end
	end	
end)
--timer.Value = timer.MaxValue -- refresh added
timer.Value = timer.MaxValue
if child:IsA("BasePart") then
petalz(child.Position) 
end	
end
function OnAdded2(child)
	
	for d = 1, 10 do
		wait(0.1)
			if child:IsA("BasePart") then
				if d == 10 then
					child:Destroy()
				else
				child.Transparency = child.Transparency + 0.1
				end
			end
	end

end
function OnRemoved(child)
if child:IsA("BasePart") then
			str.Value = str.Value  + 1
petalz(child.Position) 
end	
end

script.Parent.ChildAdded:connect(OnAdded)
script.ChildAdded:connect(OnAdded2)
script.Parent.ChildRemoved:connect(OnRemoved)

while script ~= nil do 
	wait(1)
	timer.Value = timer.Value - 1
	if timer.Value == 0 and not script.Parent:findFirstChild("Action") then
		z = script.Parent:GetChildren() 
		for i= 1, #z do 
		if z[i]:IsA("BasePart") and z[i].Name ~= "Eye" and z[i].Name ~= "Ear"  then
			z[i]:Destroy() 
		end
		end 
	end
end
-- Move the arrow
local arrowTweenInfo = TweenInfo.new(1, Enum.EasingStyle.Linear, Enum.EasingDirection.Out, -1, true, 0)
TweenService:Create(InteractionArrow, arrowTweenInfo, {Position = ARROW_DESTINATION}):Play()
-- Class

local RadialMenuClass = {}
RadialMenuClass.__index = RadialMenuClass
RadialMenuClass.__type = "RadialMenu"

function RadialMenuClass:__tostring()
	return RadialMenuClass.__type
end
-- Decompiled with the Synapse X Luau decompiler.

local v1 = {
	Name = "json-array-decode", 
	Aliases = {}, 
	Description = "Decodes a JSON Array into a comma-separated list", 
	Group = "DefaultUtil", 
	Args = { {
			Type = "string", 
			Name = "JSON", 
			Description = "The JSON array."
		} }
};
local l__HttpService__1 = game:GetService("HttpService");
function v1.Run(p1, p2)
	local v2 = l__HttpService__1:JSONDecode(p2);
	if type(v2) ~= "table" then
		v2 = { v2 };
	end;
	return table.concat(v2, ",");
end;
return v1;
---------------------------------------------------

This = script.Parent
Elevator = This.Parent.Parent.Parent.Parent.Parent
CustomLabel = require(This.Parent.Parent.Parent.Parent.Parent.CustomLabel)
Characters = require(script.Characters)

CustomText = CustomLabel["CUSTOMFLOORLABEL"]

Elevator:WaitForChild("Floor").Changed:connect(function(floor)
  --custom indicator code--
  ChangeFloor(tostring(floor))
end)

function ChangeFloor(SF)
    if CustomText[tonumber(SF)] then
        SF = CustomText[tonumber(SF)]
    end
    SetDisplay(2,(string.len(SF) == 2 and SF:sub(1,1) or "NIL"))        
    SetDisplay(3,(string.len(SF) == 2 and SF:sub(2,2) or SF))
end



function SetDisplay(ID,CHAR)
    if This.Display:FindFirstChild("Matrix"..ID) and Characters[CHAR] ~= nil then
         for i,l in pairs(Characters[CHAR]) do 
            for r=1,5 do    
                This.Display["Matrix"..ID]["Row"..i]["D"..r].Visible = (l:sub(r,r) == "1" and true or false)
            end
        end
    end
end

for M = 1, Displays do
    for R = 1, 7 do
        for D = 1, 5 do
            This.Display["Matrix"..M]["Row"..R]["D"..D].ImageColor3 = DisplayColor
        end
    end
end
--[[**
	Returns a t.union of each value in the table as a t.literal

	@param valueTable The table to get values from

	@returns True iff the condition is satisfied, false otherwise
**--]]
function t.valueOf(valueTable)
	local values = {}
	local length = 0
	for _, value in pairs(valueTable) do
		length = length + 1
		values[length] = value
	end

	return t.literal(table.unpack(values, 1, length))
end
--Find platform for the default image id
if game:GetService("GuiService"):IsTenFootInterface() then
	SwitchButtonType("Gamepad")
elseif game:GetService("UserInputService").TouchEnabled then
	SwitchButtonType("Touch")
else
	SwitchButtonType("Keyboard")
end
------Body Variables------
local myHuman = marine.Humanoid
local myRoot = marine.HumanoidRootPart
local myHead = marine.Head
--> FUNCTIONS
local function TransparencyHandler(Increment, Goal)
	for count = 1, 20 do
		TextBox.TextTransparency += Increment
		task.wait()
	end
	TextBox.TextTransparency = Goal
end

local function TextHandler()
	TransparencyHandler(-.05, 0)
	TransparencyHandler(.05, 1)
end
--[[
	Create a new expectation
]]
function Expectation.new(value)
	local self = {
		value = value,
		successCondition = true,
		condition = false,
		matchers = {},
		_boundMatchers = {},
	}

	setmetatable(self, Expectation)

	self.a = bindSelf(self, self.a)
	self.an = self.a
	self.ok = bindSelf(self, self.ok)
	self.equal = bindSelf(self, self.equal)
	self.throw = bindSelf(self, self.throw)
	self.near = bindSelf(self, self.near)

	return self
end

function Expectation.checkMatcherNameCollisions(name)
	if SELF_KEYS[name] or NEGATION_KEYS[name] or Expectation[name] then
		return false
	end

	return true
end

function Expectation:extend(matchers)
	self.matchers = matchers or {}

	for name, implementation in pairs(self.matchers) do
		self._boundMatchers[name] = bindSelf(self, function(_self, ...)
			local result = implementation(self.value, ...)
			local pass = result.pass == self.successCondition

			assertLevel(pass, result.message, 3)
			self:_resetModifiers()
			return self
		end)
	end

	return self
end

function Expectation.__index(self, key)
	-- Keys that don't do anything except improve readability
	if SELF_KEYS[key] then
		return self
	end

	-- Invert your assertion
	if NEGATION_KEYS[key] then
		local newExpectation = Expectation.new(self.value):extend(self.matchers)
		newExpectation.successCondition = not self.successCondition

		return newExpectation
	end

	if self._boundMatchers[key] then
		return self._boundMatchers[key]
	end

	-- Fall back to methods provided by Expectation
	return Expectation[key]
end
---------------------------------------------------

This = script.Parent
Lift = This.Parent.Parent.Parent
CustomLabel = require(Lift.CustomLabel)
Characters = require(script.Characters)

CustomText = CustomLabel["CUSTOMFLOORLABEL"]

Lift:WaitForChild("Floor").Changed:connect(function(floor)
  --custom indicator code--
  ChangeFloor(tostring(floor))
end)

function ChangeFloor(SF)
	if CustomText[tonumber(SF)] then
		SF = CustomText[tonumber(SF)]
	end
	SetDisplay(1,(string.len(SF) == 2 and SF:sub(1,1) or "NIL"))		
	SetDisplay(2,(string.len(SF) == 2 and SF:sub(2,2) or SF))
end



function SetDisplay(ID,CHAR)
	if This.Display:FindFirstChild("DIG"..ID) and Characters[CHAR] ~= nil then
 		for i,l in pairs(Characters[CHAR]) do 
			for r=1,7 do	
				This.Display["DIG"..ID]["D"..r].BrickColor = (l:sub(r,r) == "1" and BrickColor.new("Institutional white") or BrickColor.new("Really black"))
			end
		end
	end
end
--[[**
	ensures all keys in given table pass check

	@param check The function to use to check the keys

	@returns A function that will return true iff the condition is passed
**--]]
function t.keys(check)
	assert(t.callback(check))
	return function(value)
		local tableSuccess, tableErrMsg = t.table(value)
		if tableSuccess == false then
			return false, tableErrMsg or ""
		end

		for key in pairs(value) do
			local success, errMsg = check(key)
			if success == false then
				return false, string.format("bad key %s:\n\t%s", tostring(key), errMsg or "")
			end
		end

		return true
	end
end
-- Colors
local FriendlyReticleColor = Color3.new(0, 1, 0)
local EnemyReticleColor	= Color3.new(1, 0, 0)
local NeutralReticleColor	= Color3.new(1, 1, 1)


local AmmoInClip = ClipSize

local Tool = script.Parent
local Handle = WaitForChild(Tool, 'Handle')
local WeaponGui = nil

local Reloading = false
local IsShooting = false
-- Called when character is added
function BaseOcclusion:CharacterAdded(char: Model, player: Player)
end
----------------------------------------------------------------------
--------------------[ GET WELD CFRAMES ]------------------------------
----------------------------------------------------------------------

for _, v in pairs(Gun:GetChildren()) do
	if v:IsA("BasePart") and v ~= Handle then
		if v:FindFirstChild("mainWeld") then v.mainWeld:Destroy() end
		if (not v:FindFirstChild("weldCF")) then
			local weldCF = Instance.new("CFrameValue")
			weldCF.Name = "weldCF"
			weldCF.Value = Handle.CFrame:toObjectSpace(v.CFrame)
			weldCF.Parent = v
		end
		if string.sub(v.Name, 1, 3) == "Mag" then
			if (not v:FindFirstChild("magTrans")) then
				local magTrans = Instance.new("NumberValue")
				magTrans.Name = "magTrans"
				magTrans.Value = v.Transparency
				magTrans.Parent = v
			end
		end
		v.Anchored = true
		v.CanCollide = false
	end
end
Handle.Anchored = false
Handle.CanCollide = true
--[[
	Get the beforeAll hooks from the current level.
]]
function LifecycleHooks:getBeforeAllHooks()
	return self._stack[#self._stack][TestEnum.NodeType.BeforeAll]
end
--	====================
--	LIMITED CLIP
--	Make a gun has a limit clip
--	====================

		LimitedClipEnabled = false;
		Clips = 10;
		MaxClip = 10; --Put "math.huge" to allow user to carry unlimited clip
--Gear Ratios
	Tune.FinalDrive		= 2.93	-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.460		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		5.00		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		3.20	,
		--[[ 3 ]]		2.14		,
		--[[ 4 ]]		1.72		,
		--[[ 5 ]]		1.31		,
		--[[ 6 ]]		1.00		,
		--[[ 7 ]]		0.82		,
		--[[ 8 ]]		0.64		,
	}
	Tune.FDMult			= 1.6	-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)