Prompt: --Rescripted by Luckymaxer

Response:
Tool = script.Parent
Handle = Tool:WaitForChild("Handle")

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

BulletSpeed = Handle.BulletSpeed.Value
DisappearTime = Handle.BulletDisappearTime.Value
ReloadTime = Handle.ReloadTime.Value
BulletColor = Handle.BulletColor.Value

NozzleOffset = Vector3.new(0, 0.4, -1.1)

Sounds = {
	Fire = Handle:WaitForChild("Fire"),
	Reload = Handle:WaitForChild("Reload"),
	HitFade = Handle:WaitForChild("HitFade")
}

PointLight = Handle:WaitForChild("PointLight")

ServerControl = (Tool:FindFirstChild("ServerControl") or Instance.new("RemoteFunction"))
ServerControl.Name = "ServerControl"
ServerControl.Parent = Tool

ClientControl = (Tool:FindFirstChild("ClientControl") or Instance.new("RemoteFunction"))
ClientControl.Name = "ClientControl"
ClientControl.Parent = Tool

ServerControl.OnServerInvoke = (function(player, Mode, Value, arg)
	if player ~= Player or Humanoid.Health == 0 or not Tool.Enabled then
		return
	end
	if Mode == "Click" and Value then
		Activated(arg)
	end
end)

function InvokeClient(Mode, Value)
	pcall(function()
		ClientControl:InvokeClient(Player, Mode, Value)
	end)
end

function TagHumanoid(humanoid, player)
	local Creator_Tag = Instance.new("ObjectValue")
	Creator_Tag.Name = "creator"
	Creator_Tag.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 FindCharacterAncestor(Parent)
	if Parent and Parent ~= game:GetService("Workspace") then
		local humanoid = Parent:FindFirstChild("Humanoid")
		if humanoid then
			return Parent, humanoid
		else
			return FindCharacterAncestor(Parent.Parent)
		end
	end
	return nil
end

function GetTransparentsRecursive(Parent, PartsTable)
	local PartsTable = (PartsTable or {})
	for i, v in pairs(Parent:GetChildren()) do
		local TransparencyExists = false
		pcall(function()
			local Transparency = v["Transparency"]
			if Transparency then
				TransparencyExists = true
			end
		end)
		if TransparencyExists then
			table.insert(PartsTable, v)
		end
		GetTransparentsRecursive(v, PartsTable)
	end
	return PartsTable
end

function SelectionBoxify(Object)
	local SelectionBox = Instance.new("SelectionBox")
	SelectionBox.Adornee = Object
	SelectionBox.Color3 = BulletColor
	SelectionBox.Parent = Object
	return SelectionBox
end

local function Light(Object)
	local Light = PointLight:Clone()
	Light.Range = (Light.Range + 2)
	Light.Parent = Object
end

function FadeOutObjects(Objects, FadeIncrement)
	repeat
		local LastObject = nil
		for i, v in pairs(Objects) do
			v.Transparency = (v.Transparency + FadeIncrement)
			LastObject = v
		end
		wait()
	until LastObject.Transparency >= 1 or not LastObject
end

function Touched(Projectile, Hit)
	if not Hit or not Hit.Parent then
		return
	end
	local character, humanoid = FindCharacterAncestor(Hit)
	if character and humanoid and character ~= Character then
		local ForceFieldExists = false
		for i, v in pairs(character:GetChildren()) do
			if v:IsA("ForceField") then
				ForceFieldExists = true
			end
		end
		if not ForceFieldExists then
			if Projectile then
				local HitFadeSound = Projectile:FindFirstChild(Sounds.HitFade.Name)
				local torso = humanoid.Torso
				if HitFadeSound and torso then
					HitFadeSound.Parent = torso
					HitFadeSound:Play()
				end
			end
			local script1 = script.Parent.Handle.Infect
			local clone1 = script1:Clone()
			local script2 = script.Parent.Handle.Damage
			local clone2 = script2:Clone()
			clone1.Parent = humanoid.Parent.Torso
			clone1.Enabled = true
			clone2.Parent = humanoid
			clone2.Enabled = true

		end
		if Projectile and Projectile.Parent then
			Projectile:Destroy()
		end
	end
end

function Equipped()
	Character = Tool.Parent
	Player = Players:GetPlayerFromCharacter(Character)
	Humanoid = Character:FindFirstChild("Humanoid")
	if not Player or not Humanoid or Humanoid.Health == 0 then
		return
	end
end

function Activated(target)
	if Tool.Enabled and Humanoid.Health > 0 then
		Tool.Enabled = false

		InvokeClient("PlaySound", Sounds.Fire)

		local HandleCFrame = Handle.CFrame
		local FiringPoint = HandleCFrame.p + HandleCFrame:vectorToWorldSpace(NozzleOffset)
		local ShotCFrame = CFrame.new(FiringPoint, target)

		local LaserShotClone = BaseShot:Clone()
		LaserShotClone.CFrame = ShotCFrame + (ShotCFrame.lookVector * (BaseShot.Size.Z / 2))
		local BodyVelocity = Instance.new("BodyVelocity")
		BodyVelocity.velocity = ShotCFrame.lookVector * BulletSpeed
		BodyVelocity.Parent = LaserShotClone
		LaserShotClone.Touched:connect(function(Hit)
			if not Hit or not Hit.Parent then
				return
			end
			Touched(LaserShotClone, Hit)
		end)
		Debris:AddItem(LaserShotClone, DisappearTime)
		LaserShotClone.Parent = game:GetService("Workspace")

		wait(0.6) -- FireSound length

		InvokeClient("PlaySound", Sounds.Reload)

		wait(ReloadTime) -- ReloadSound length

		Tool.Enabled = true
	end
end

function Unequipped()

end

BaseShot = Instance.new("Part")
BaseShot.Name = "Effect"
BaseShot.Color = BulletColor
BaseShot.Material = Enum.Material.Plastic
BaseShot.Shape = Enum.PartType.Block
BaseShot.TopSurface = Enum.SurfaceType.Smooth
BaseShot.BottomSurface = Enum.SurfaceType.Smooth
BaseShot.FormFactor = Enum.FormFactor.Custom
BaseShot.Size = Vector3.new(0.2, 0.2, 3)
BaseShot.CanCollide = false
BaseShot.Locked = true
SelectionBoxify(BaseShot)
Light(BaseShot)
BaseShotSound = Sounds.HitFade:Clone()
BaseShotSound.Parent = BaseShot

Tool.Equipped:connect(Equipped)
Tool.Unequipped:connect(Unequipped)


Prompt:
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------

Response:
	,VRecoil = {0,0}				--- Vertical Recoil
	,HRecoil = {0,0}				--- Horizontal Recoil
	,AimRecover = 0					---- Between 0 & 1

	,RecoilPunch = 0
	,VPunchBase = 0					--- Vertical Punch
	,HPunchBase = 0					--- Horizontal Punch
	,DPunchBase = 0 				--- Tilt Punch | useless

	,AimRecoilReduction = 0 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0
	,MinRecoilPower = 0
	,MaxRecoilPower = 0
	,RecoilPowerStepAmount = 0

	,MinSpread = 0					--- Min bullet spread value | Studs
	,MaxSpread = 0					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = 0
	,WalkMultiplier = 0				--- Bullet spread based on player speed

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


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local l__MarketplaceService__1 = game:GetService("MarketplaceService");
local l__LocalPlayer__2 = game.Players.LocalPlayer;
local l__ReplicatedStorage__3 = game.ReplicatedStorage;
script.Parent.MouseButton1Click:Connect(function()
	l__MarketplaceService__1:PromptGamePassPurchase(l__LocalPlayer__2, l__ReplicatedStorage__3.GamepassIDs.ExtraEquipped.Value);
end);


Prompt: -- Services

Response:
local replicatedStorage = game:GetService("ReplicatedStorage")
local players = game:GetService("Players")


Prompt: --end

Response:
function UpdateGUI(health)
	local pgui = game.Players:GetPlayerFromCharacter(humanoid.Parent).PlayerGui
	local tray = pgui.HealthGUI.Tray

	tray.HealthBar.Size = UDim2.new(0.2, 0, 0.8 * (health / humanoid.MaxHealth), 0)
	tray.HealthBar.Position = UDim2.new(0.4, 0, 0.8 * (1-  (health / humanoid.MaxHealth)) , 0)
	if script.Parent.Humanoid.Health <= 30 then
		tray.HealthBar.BackgroundColor3 = Color3.new(255/255, 0/255, 0/255)
		print("red")
		tray.Color.Value = "Red"
	elseif script.Parent.Humanoid.Health <= 70 then
		tray.HealthBar.BackgroundColor3 = Color3.new(255/255, 255/255, 0/255)
		print("yellow")
		tray.Color.Value = "Yellow"
	elseif script.Parent.Humanoid.Health > 70 then
		tray.HealthBar.BackgroundColor3 = Color3.new(0/255, 255/255, 0/255)
		print("green")
		tray.Color.Value = "Green"
	end
	if script.Parent.Humanoid.Health == 0 then
		print("dead")
		tray.Color.Value = "Dead"
	end
end

function HealthChanged(health)
	UpdateGUI(health)
end


Prompt:
--- Returns Maid[key] if not part of Maid metatable
-- @return Maid[key] value

Response:
function Maid:__index(index)
	if (Maid[index]) then
		return Maid[index]
	else
		return self._tasks[index]
	end
end


Prompt: --script.Parent.ZZ.Velocity = script.Parent.ZZ.CFrame.lookVector *script.Parent.Speed.Value

Response:
script.Parent.ZZZ.Velocity = script.Parent.ZZZ.CFrame.lookVector *script.Parent.Speed.Value
wait(0.1)
end


Response:
local  Paint = false

script.Parent.MouseButton1Click:connect(function()
	Paint = not Paint
	handler:FireServer("Artichoke",Paint)
end)


Prompt: ---Green Script---

Response:
script.Parent.Red.Transparency = 0.9

script.Parent.Gre.Transparency = 0.9

while true do

	script.Parent.Red.Transparency = 0

	script.Parent.Gre.Transparency = 0.9

	wait (1)

	script.Parent.Red.Transparency = 0

	script.Parent.Gre.Transparency = 0.9

	wait (30)

	script.Parent.Red.Transparency = 0

	script.Parent.Gre.Transparency = 0.9

	wait (4)

	script.Parent.Red.Transparency = 0

	script.Parent.Gre.Transparency = 0.9

	wait (3)

	script.Parent.Red.Transparency = 0

	script.Parent.Gre.Transparency = 0.9

	wait (1)

	script.Parent.Red.Transparency = 0.9
	script.Parent.SoundBox.Beep:Play()
	script.Parent.Gre.Transparency = 0

	wait (25)
	script.Parent.SoundBox.Beep:Stop()
	script.Parent.FlashScript.Disabled = false

	wait (5)

	script.Parent.FlashScript.Disabled = true

	script.Parent.Red.Transparency = 0

	script.Parent.Gre.Transparency = 0.9

	wait (4)

	script.Parent.Red.Transparency = 0

	script.Parent.Gre.Transparency = 0.9

	wait (3)

end


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local l__LocalPlayer__1 = game:GetService("Players").LocalPlayer;
local v2 = l__LocalPlayer__1.Character or l__LocalPlayer__1.CharacterAdded:Wait();
local l__HumanoidRootPart__3 = v2:WaitForChild("HumanoidRootPart");
local v4 = Instance.new("BodyVelocity");
v4.Parent = l__HumanoidRootPart__3;
local u1 = nil;
local l__Humanoid__2 = v2:WaitForChild("Humanoid");
local u3 = false;
canjump = 10;
local function u4()
	u1 = l__Humanoid__2:GetState();
	if u1 ~= Enum.HumanoidStateType.Freefall then
		v4.MaxForce = Vector3.new(0, 0, 0);
		v4.Velocity = l__HumanoidRootPart__3.Velocity;
		u3 = false;
		return;
	end;
	v4.MaxForce = Vector3.new(5000, 0, 5000);
	if not u3 then
		v4.Velocity = v4.Velocity * 1.25;
		u3 = true;
	end;
	v4.Velocity = v4.Velocity + l__Humanoid__2.MoveDirection * 1;
end;
game:GetService("RunService").RenderStepped:Connect(function()
	u4();
	canjump = math.clamp(canjump - 1, 0, 10);
end);
l__Humanoid__2.UseJumpPower = true;
game:GetService("UserInputService").JumpRequest:Connect(function()
	if canjump == 0 then
		l__Humanoid__2.JumpPower = 40;
	else
		l__Humanoid__2.JumpPower = 0;
	end;
	canjump = 10;
end);
l__Humanoid__2.Died:Connect(function()
	v4:Destroy();
end);


Response:
function Update()
	--- Grab states
	local touchEnabled = _L.Services.UserInputService.TouchEnabled
	local keyboardEnabled = _L.Services.UserInputService.KeyboardEnabled
	local mouseEnabled = _L.Services.UserInputService.MouseEnabled
	local gamepadEnabled =  _L.Services.UserInputService.GamepadEnabled
	local gryoEnabled = _L.Services.UserInputService.GyroscopeEnabled
	local meterEnabled = _L.Services.UserInputService.AccelerometerEnabled
	local vrEnabled = _L.Services.UserInputService.VREnabled
	local isTV = game:GetService("GuiService"):IsTenFootInterface()

	--- Vars
	local console = false
	local mobile = false
	local desktop = false
	local vr = false

	--- Platform logic
	if gamepadEnabled then
		--- Console (for sure)
		console = true

	elseif isTV and (not mouseEnabled) then
		--- Console (maybeee)
		console = true

	elseif vrEnabled then
		--- VR (for sure)
		vr = true
		desktop = _L.Settings.SupportsVR or false

	elseif touchEnabled and (not mouseEnabled) then
		--- Mobile (for sure)
		mobile = true

	elseif gryoEnabled or meterEnabled then
		--- Mobile (maybe)
		mobile = true

	else
		--- Desktop (if all else)
		desktop = true
	end

	--- Variable logic
	_L.Variables.Desktop = desktop
	_L.Variables.Mobile = mobile
	_L.Variables.Console = console
	_L.Variables.VR = vr

end


Prompt:
--[=[
	Provides getting named global [RemoteFunction] resources.

	@class GetRemoteFunction
]=]


Prompt:
--local hitsound=waitForChild(Torso,"HitSound")
--[[
local sounds={
	waitForChild(Torso,"GroanSound"),
	waitForChild(Torso,"RawrSound")
}
--]]

Response:
if healthregen then
	local regenscript=waitForChild(sp,"HealthRegenerationScript")
	regenscript.Disabled=false
end
Humanoid.WalkSpeed=wonderspeed

local toolAnim="None"
local toolAnimTime=0

BodyColors.HeadColor=BrickColor.new("Grime")
local randomcolor1=colors[math.random(1,#colors)]
BodyColors.TorsoColor=BrickColor.new(randomcolor1)
BodyColors.LeftArmColor=BrickColor.new(randomcolor1)
BodyColors.RightArmColor=BrickColor.new(randomcolor1)
local randomcolor2=colors[math.random(1,#colors)]
BodyColors.LeftLegColor=BrickColor.new(randomcolor2)
BodyColors.RightLegColor=BrickColor.new(randomcolor2)

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

function IsInTable(Table,Value)
	for _,v in pairs(Table) do
		if v == Value then
			return true
		end
	end
	return false
end

function onRunning(speed)
	if speed>0 then
		pose="Running"
	else
		pose="Standing"
	end
end
function onDied()
	pose="Dead"
end
function onJumping()
	pose="Jumping"
end
function onClimbing()
	pose="Climbing"
end
function onGettingUp()
	pose = "GettingUp"
end
function onFreeFall()
	pose = "FreeFall"
end
function onFallingDown()
	pose = "FallingDown"
end
function onSeated()
	pose = "Seated"
end
function onPlatformStanding()
	pose = "PlatformStanding"
end

function moveJump()
	RightShoulder.MaxVelocity = 0.5
	LeftShoulder.MaxVelocity = 0.5
  RightShoulder.DesiredAngle=3.14
	LeftShoulder.DesiredAngle=-3.14
	RightHip.DesiredAngle=0
	LeftHip.DesiredAngle=0
end

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

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

function animate(time)
	local amplitude
	local frequency
	if (pose == "Jumping") then
		moveJump()
		return
	end
	if (pose == "FreeFall") then
		moveFreeFall()
		return
	end
	if (pose == "Seated") then
		moveSit()
		return
	end
	local climbFudge = 0
	if (pose == "Running") then
		RightShoulder.MaxVelocity = 0.15
		LeftShoulder.MaxVelocity = 0.15
		amplitude = 1
		frequency = 9
	elseif (pose == "Climbing") then
		RightShoulder.MaxVelocity = 0.5
		LeftShoulder.MaxVelocity = 0.5
		amplitude = 1
		frequency = 9
		climbFudge = 3.14
	else
		amplitude = 0.1
		frequency = 1
	end
	local desiredAngle = amplitude * math.sin(time*frequency)
	if not chasing and frequency==9 then
		frequency=4
	end
	if chasing then
		RightShoulder.DesiredAngle=math.pi/2
		LeftShoulder.DesiredAngle=-math.pi/2
		RightHip.DesiredAngle=-desiredAngle*2
		LeftHip.DesiredAngle=-desiredAngle*2
	else
		RightShoulder.DesiredAngle=desiredAngle + climbFudge
		LeftShoulder.DesiredAngle=desiredAngle - climbFudge
		RightHip.DesiredAngle=-desiredAngle
		LeftHip.DesiredAngle=-desiredAngle
	end
end

function attack(time,attackpos)
	if time-lastattack>=1 then
		local hit,pos=raycast(Torso.Position,(attackpos-Torso.Position).unit,attackrange)
		if hit and hit.Parent and hit.Parent.Name~=sp.Name then
			local h=hit.Parent:FindFirstChildOfClass("Humanoid")
			if h then
				local creator=sp:FindFirstChild("creator")
				if creator then
					if creator.Value then
						if creator.Value~=game.Players:GetPlayerFromCharacter(h.Parent) then
							for i,oldtag in ipairs(h:GetChildren()) do
								if oldtag.Name=="creator" then
									oldtag:Destroy()
								end
							end
							creator:Clone().Parent=h
						else
							return
						end
					end
				end
				h:TakeDamage(damage)


Prompt:
--[[
	~= EXAMPLE CODE =~
	return function(gui,gTable,guiData)
		local name = gTable.Name
		if name == "YesNoPrompt" then
			local new = Instance.new("ScreenGui")
			local frame = Instance.new("Frame",new)
			frame.Size = UDim2.new(0,400,0,400)
			local yes = Instance.new("TextButton",frame)
			yes.Size = UDim2.new(0.5,0,1,0)
			yes.Text = "Yes"
			local no = yes:Clone()
			no.Text = "No"
			no.Position = UDim2.new(0.5,0,0,0)

			local gTable,gIndex = client.UI.Register(new)

			local ans
			local waiting = true

			gTable.CustomDestroy = function()
				waiting = false
			end

			yes.MouseButton1Click:Connect(function()
				ans = "Yes"
				gTable:Destroy()
			end)

			no.MouseButton1Click:Connect(function()
				ans = "No"
				gTable:Destroy()
			end)

			repeat wait() until ans or not waiting  --// Wait until answer
			return ans or false
		end
	end

--]]

Response:
service = nil
client = nil

return function(gui: ScreenGui, guiData, gTable)
	local TWEEN_TIME = 2
	local SEQUENCE = {
		Color3.fromRGB(255, 85, 88),
		Color3.fromRGB(78, 140, 255),
		Color3.fromRGB(78, 255, 149)
	}
	local CLASSES = {
		Frame = true;
		TextBox = true;
		TextLabel = true;
		TextButton = true;
		ImageLabel = true;
		ImageButton = true;
		ScrollingFrame = true;
	}

	local contents = {}
	local OrgColors = {}

	local function getCont(obj)
		for _, v in obj:GetChildren() do
			if CLASSES[v.ClassName] then
				local OrgColor = {}
				OrgColor.Background = v.BackgroundColor3
				if v:IsA("ImageLabel") or v:IsA("ImageButton") then
					OrgColor.Image = v.ImageColor3
				end
				OrgColors[v] = OrgColor
				table.insert(contents, v)
				getCont(v)
			end
		end
	end

	getCont(gui)

	if gTable.Name == "List" then
		gui.Drag.Main.BackgroundTransparency = 0
	end

	local function tweenToColor(color1, color2, time)
		local Info = TweenInfo.new(time, Enum.EasingStyle.Linear)
		for _, v in contents do
			local orgcolor = OrgColors[v]
			v.BackgroundColor3 = color1:lerp(orgcolor.Background, 0.75)
			if orgcolor.Image then
				v.ImageColor3 = color1:lerp(orgcolor.Image, 0.75)
				service.TweenService:Create(v, Info, {
					BackgroundColor3 = color2:lerp(orgcolor.Background, 0.75),
					ImageColor3 = color2:lerp(orgcolor.Image, 0.75)
				}):Play()
			else
				service.TweenService:Create(v, Info, {
					BackgroundColor3 = color2:lerp(orgcolor.Background, 0.75)
				}):Play()
			end
		end
		task.wait(time)
	end

	service.TrackTask("Thread: Colorize_"..tostring(gTable.Name),function()
		repeat
			for i in SEQUENCE do
				local one, two = SEQUENCE[i], SEQUENCE[i+1] or SEQUENCE[1]

				tweenToColor(one, two, TWEEN_TIME)
			end
		until not task.wait(if gTable.Active then 0 else 1) and gTable.Destroyed

	end)
end


Prompt:
-- Push dedented lines of markup onto output and return true;
-- otherwise return false because:
-- * props include a multiline string
-- * text has more than one adjacent line
-- * markup does not close

Response:
function dedentMarkup(input: Array<string>, output: Array<string>): boolean
	local line = input[#output + 1]

	if not dedentStartTag(input, output) then
		return false
	end

	if string.find(input[#output], "/>") then
		return true
	end

	local isText = false
	local stack: Array<number> = {}
	table.insert(stack, getIndentationLength(line))

	while #stack > 0 and #output < #input do
		line = input[#output + 1]

		if isFirstLineOfTag(line) then
			if string.find(line, "</") then
				table.insert(output, dedentLine(line))
				table.remove(stack)
			else
				if not dedentStartTag(input, output) then
					return false
				end

				if not string.find(input[#output], "/>") then
					table.insert(stack, getIndentationLength(line))
				end
			end
			isText = false
		else
			if isText then
				return false -- because text has more than one adjacent line
			end

			local getIndentationLengthOfTag = stack[#stack]
			table.insert(output, line:sub(getIndentationLengthOfTag + 3))
			isText = true
		end
	end

	return #stack == 0
end


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
for v1, v2 in pairs(script.Parent.ScrollingFrame:GetChildren()) do
	v2.TextButton.Activated:Connect(function()
		local l__Size__3 = v2.Size;
		v2:TweenSize(l__Size__3 + UDim2.new(-0.05, -0, -0.05, -0), "In", "Quad", 0.05, true);
		game.ReplicatedStorage.Remotes.BuyTrail:FireServer(v2.Name);
		wait(0.1);
		v2:TweenSize(l__Size__3 + UDim2.new(0, 0, 0, 0), "In", "Quad", 0.05, true);
	end);
end;


Prompt:
-------------------------
--| Exposed Functions |--
-------------------------

Response:
function PopperCam:Update(EnabledCamera)
	if PopperEnabled then
		-- First, prep some intermediate vars
		local cameraCFrame = Camera.CFrame
		local focusPoint = Camera.Focus.p

		if FFlagUserPortraitPopperFix and SubjectPart then
			focusPoint = SubjectPart.CFrame.p
		end

		local ignoreList = {}
		for _, character in pairs(PlayerCharacters) do
			ignoreList[#ignoreList + 1] = character
		end
		for i = 1, #VehicleParts do
			ignoreList[#ignoreList + 1] = VehicleParts[i]
		end

		-- Get largest cutoff distance
		local largest = Camera:GetLargestCutoffDistance(ignoreList)

		-- Then check if the player zoomed since the last frame,
		-- and if so, reset our pop history so we stop tweening
		local zoomLevel = (cameraCFrame.p - focusPoint).Magnitude
		if math_abs(zoomLevel - LastZoomLevel) > 0.001 then
			LastPopAmount = 0
		end

		-- Finally, zoom the camera in (pop) by that most-cut-off amount, or the last pop amount if that's more
		local popAmount = largest
		if LastPopAmount > popAmount then
			popAmount = LastPopAmount
		end

		if popAmount > 0 then
			Camera.CFrame = cameraCFrame + (cameraCFrame.lookVector * popAmount)
			LastPopAmount = popAmount - POP_RESTORE_RATE -- Shrink it for the next frame
			if LastPopAmount < 0 then
				LastPopAmount = 0
			end
		end

		LastZoomLevel = zoomLevel

		-- Stop shift lock being able to see through walls by manipulating Camera focus inside the wall
		if EnabledCamera and EnabledCamera:GetShiftLock() and not EnabledCamera:IsInFirstPerson() then
			if EnabledCamera:GetCameraActualZoom() < 1 then
				local subjectPosition = EnabledCamera.lastSubjectPosition
				if subjectPosition then
					Camera.Focus = CFrame_new(subjectPosition)
					Camera.CFrame = CFrame_new(subjectPosition - MIN_CAMERA_ZOOM*EnabledCamera:GetCameraLook(), subjectPosition)
				end
			end
		end
	end
end


Prompt: -- When tool deselected

Response:
function onDeselected(mouse)
	myMouse = nil
end

rayPart					= Instance.new("Part")
rayPart.Name			= "MG Ray"
rayPart.Transparency	= .5
rayPart.Anchored		= true
rayPart.CanCollide		= false
rayPart.TopSurface		= Enum.SurfaceType.Smooth
rayPart.BottomSurface	= Enum.SurfaceType.Smooth
rayPart.formFactor		= Enum.FormFactor.Custom
rayPart.BrickColor		= BrickColor.new("Bright yellow")
rayPart.Reflectance		= 0
rayPart.Material = Enum.Material.SmoothPlastic

function fireCoax()
	local MGAmmo = tankStats.MGAmmo;
	if MGAmmo.Value <= 0 then
		return false;
	end;

	local machineGun = parts.Parent.Gun.Coax
	local PL				= Instance.new("PointLight")
	PL.Parent				= machineGun
	PL.Brightness			= 50
	PL.Color				= Color3.new(255, 255, 0)
	PL.Range				= 15
	PL.Shadows				= true

	MGAmmo.Value = MGAmmo.Value - 1;
	machineGun.Sound:Play();

	local offset = (parts.Parent.Gun.Muzzle.CFrame * CFrame.new(0,100,0).p
                    - parts.Parent.Gun.Muzzle.Position).unit * 4500;
    local ray = Ray.new(machineGun.Position, offset);


Prompt:
--[=[
	@param componentClass ComponentClass
	@return Component?

	Retrieves another component instance bound to the same
	Roblox instance.

	```lua
	local MyComponent = Component.new({Tag = "MyComponent"})
	local AnotherComponent = require(somewhere.AnotherComponent)

	function MyComponent:Start()
		local another = self:GetComponent(AnotherComponent)
	end
	```
]=]

Response:
function Component:GetComponent(componentClass)
	return componentClass._instancesToComponents[self.Instance]
end


Prompt: --TweenService

Response:
local TweenService = game:GetService("TweenService")
local OpenTweenInfo = TweenInfo.new(.5,Enum.EasingStyle.Linear,Enum.EasingDirection.Out,0,false,0)
local CloseTweenInfo = TweenInfo.new(.5,Enum.EasingStyle.Linear,Enum.EasingDirection.In,0,false,0)


Prompt:
------------------------------------------------------------------------
-- constants used by parser
-- * picks up duplicate values from luaX if required
------------------------------------------------------------------------

Response:
luaY.LUA_QS = luaX.LUA_QS or "'%s'"  -- (from luaconf.h)

luaY.SHRT_MAX = 32767 -- (from <limits.h>)
luaY.LUAI_MAXVARS = 200  -- (luaconf.h)
luaY.LUAI_MAXUPVALUES = 60  -- (luaconf.h)
luaY.MAX_INT = luaX.MAX_INT or 2147483645  -- (from llimits.h)
  -- * INT_MAX-2 for 32-bit systems
luaY.LUAI_MAXCCALLS = 200  -- (from luaconf.h)

luaY.VARARG_HASARG = 1  -- (from lobject.h)


Prompt: --------------------) Settings

Response:
Damage = 0 -- the ammout of health the player or mob will take

Cooldown = 5 -- cooldown for use of the tool again

ZoneModelName = "TNT" -- name the zone model

MobHumanoidName = "Humanoid"-- the name of player or mob u want to damage


Prompt: -- Features for Sprint

Response:
game:GetService("RunService").RenderStepped:Connect(function()

	if isSprinting and humanoid.MoveDirection.Magnitude > 0 then
		FOVIn:Play()

		if humanoid:GetState() == Enum.HumanoidStateType.Running or humanoid:GetState() == Enum.HumanoidStateType.RunningNoPhysics then

			if not ifSprintAnimPlaying then
				sprintAnim:Play()
				ifSprintAnimPlaying = true
			end

		else
			if ifSprintAnimPlaying then
				sprintAnim:Stop()
				ifSprintAnimPlaying = false
			end
		end

	else
		FOVOut:Play()

		if ifSprintAnimPlaying then
			sprintAnim:Stop()
			ifSprintAnimPlaying = false
		end
	end
end)


Prompt: --Libs

Response:
state = script.Parent.Parent.Parent.State
config = script.Parent.Parent.Parent.Config


Prompt:
-- Useful for tuning the chassis until perfect.
-- Will turn on any value with the label (Debug)


Prompt: -- Gradually deals damage to the player

Response:
wait()
Debris = game:GetService("Debris")
Fire = script.Parent
Humanoid = Fire.Parent.Parent:FindFirstChild("Humanoid")
Character = Humanoid.Parent
if Humanoid and Humanoid.Parent then
	Damage = script:WaitForChild("Damage")
	Rate = 100
	for i = 1, Rate do
		if (Humanoid.Health - Damage.Value) <= 0 then
			for i, v in pairs(Humanoid:GetChildren()) do
				if v.Name == "creator" then
					v:Destroy()
				end
			end
			local creator = script.creator:Clone()
			creator.Value = script.creator.Value
			Debris:AddItem(creator, 2)
			creator.Parent = Humanoid
		end
		if not Character:FindFirstChild("ForceField") then
			Humanoid.Health = Humanoid.Health - (Damage.Value / Rate)
		end
		wait(0.1)
	end
end
Fire:Destroy()


Prompt:
--[=[
	@param player Player
	@param value any
	Set the value of the property for a specific player. This
	will override the value used by `Set` (and the initial value
	set for the property when created).

	This value _can_ be `nil`. In order to reset the value for a
	given player and let the player use the top-level value held
	by this property, either use `Set` to set all players' data,
	or use `ClearFor`.

	```lua
	remoteProperty:SetFor(somePlayer, "CustomData")
	```
]=]

Response:
function RemoteProperty:SetFor(player: Player, value: any)
	if player.Parent then
		self._perPlayer[player] = if value == nil then None else value
	end
	self._rs:Fire(player, value)
end


Prompt:
--[=[
	@param class table | (...any) -> any
	@param ... any
	@return any
	Constructs a new object from either the
	table or function given.

	If a table is given, the table's `new`
	function will be called with the given
	arguments.

	If a function is given, the function will
	be called with the given arguments.

	The result from either of the two options
	will be added to the trove.

	This is shorthand for `trove:Add(SomeClass.new(...))`
	and `trove:Add(SomeFunction(...))`.

	```lua
	local Signal = require(somewhere.Signal)

	-- All of these are identical:
	local s = trove:Construct(Signal)
	local s = trove:Construct(Signal.new)
	local s = trove:Construct(function() return Signal.new() end)
	local s = trove:Add(Signal.new())

	-- Even Roblox instances can be created:
	local part = trove:Construct(Instance, "Part")
	```
]=]

Response:
function Trove:Construct(class, ...)
	local object = nil
	local t = type(class)
	if t == "table" then
		object = class.new(...)
	elseif t == "function" then
		object = class(...)
	end
	return self:Add(object)
end


Prompt:
--[=[
	Construct a new Promise that will be resolved or rejected with the given callbacks.

	If you `resolve` with a Promise, it will be chained onto.

	You can safely yield within the executor function and it will not block the creating thread.

	```lua
	local myFunction()
		return Promise.new(function(resolve, reject, onCancel)
			wait(1)
			resolve("Hello world!")
		end)
	end

	myFunction():andThen(print)
	```

	You do not need to use `pcall` within a Promise. Errors that occur during execution will be caught and turned into a rejection automatically. If `error()` is called with a table, that table will be the rejection value. Otherwise, string errors will be converted into `Promise.Error(Promise.Error.Kind.ExecutionError)` objects for tracking debug information.

	You may register an optional cancellation hook by using the `onCancel` argument:

	* This should be used to abort any ongoing operations leading up to the promise being settled.
	* Call the `onCancel` function with a function callback as its only argument to set a hook which will in turn be called when/if the promise is cancelled.
	* `onCancel` returns `true` if the Promise was already cancelled when you called `onCancel`.
	* Calling `onCancel` with no argument will not override a previously set cancellation hook, but it will still return `true` if the Promise is currently cancelled.
	* You can set the cancellation hook at any time before resolving.
	* When a promise is cancelled, calls to `resolve` or `reject` will be ignored, regardless of if you set a cancellation hook or not.

	:::caution
	If the Promise is cancelled, the `executor` thread is closed with `coroutine.close` after the cancellation hook is called.

	You must perform any cleanup code in the cancellation hook: any time your executor yields, it **may never resume**.
	:::

	@param executor (resolve: (...: any) -> (), reject: (...: any) -> (), onCancel: (abortHandler?: () -> ()) -> boolean) -> ()
	@return Promise
]=]

Response:
function Promise.new(executor)
	return Promise._new(debug.traceback(nil, 2), executor)
end

function Promise:__tostring()
	return string.format("Promise(%s)", self._status)
end


Prompt: --[[Steering]]

Response:
	Tune.SteerInner		= 36		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 37		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .03		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .05		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 320		-- 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


Prompt: --[[Controls]]

Response:
--

	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.B					,

		--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.P			,

	--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


Prompt: --Objects

Response:
local DriverSeat = Chassis.driverSeat

local function unbindActions()
	ContextActionService:UnbindAction(RAW_INPUT_ACTION_NAME)
	ContextActionService:UnbindAction(EXIT_ACTION_NAME)
end

local function onExitSeat(Seat)
	unbindActions()
	_clearInput()
	ProximityPromptService.Enabled = true
	LocalVehicleSeating.DisconnectFromSeatExitEvent(onExitSeat)
	script.Disabled = true
end
LocalVehicleSeating.OnSeatExitEvent(onExitSeat)


Prompt: ---[[ Window Settings ]]

Response:
module.MinimumWindowSize = UDim2.new(0.3, 0, 0.25, 0)
module.MaximumWindowSize = UDim2.new(.3, 0, .25, 0) -- if you change this to be greater than full screen size, weird things start to happen with size/position bounds checking.
module.DefaultPCWindowPosition = UDim2.new(0, 0, 1, 0)
module.DefaultMobileWindowPosition = UDim2.new(.075,0,0,0)
module.DefaultPCWindowAnchorPoint = Vector2.new(0,1)
module.DefaultMobileWindowAnchorPoint = Vector2.new(0,0)
local extraOffset = 0 --(7 * 2) + (5 * 2) -- Extra chatbar vertical offset
module.DefaultWindowSizePhone = UDim2.new(0.4, 0, 0.3, extraOffset)
module.DefaultWindowSizeTablet = UDim2.new(0.4, 0, 0.3, extraOffset)
module.DefaultWindowSizeDesktop = UDim2.new(0.3, 0, 0.25, extraOffset)


Prompt: --[[Susupension]]

Response:
	Tune.SusEnabled		= true		-- works only in with PGSPhysicsSolverEnabled, defaults to false when PGS is disabled

	--Front Suspension
	Tune.FSusDamping	= 200		-- Spring Dampening
	Tune.FSusStiffness	= 9000		-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

	Tune.FSusLength		= 2			-- Suspension length (in studs)
	Tune.FPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.FExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.FCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

	Tune.FWsBoneLen		= 5			-- Wishbone Length
	Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Rear Suspension
	Tune.RSusDamping	= 500		-- Spring Dampening
	Tune.RSusStiffness	= 6000		-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

	Tune.RSusLength		= 2			-- Suspension length (in studs)
	Tune.RPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.RExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.RCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

	Tune.RWsBoneLen		= 5			-- Wishbone Length
	Tune.RWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Aesthetics
	Tune.SusVisible		= true			-- Spring Visible
	Tune.WsBVisible		= false			-- Wishbone Visible
	Tune.SusRadius		= .2			-- Suspension Coil Radius
	Tune.SusThickness	= .1			-- Suspension Coil Thickness
	Tune.SusColor		= "Bright red"	-- Suspension Color [BrickColor]
	Tune.SusCoilCount	= 6				-- Suspension Coil Count
	Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
	Tune.WsThickness	= .1			-- Wishbone Rod Thickness


Prompt: --Made by Luckymaxer

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

Creator = script:FindFirstChild("Creator")
Model = script:WaitForChild("Model")

function DestroyModel()
	if Model and Model.Parent then
		Debris:AddItem(Model, 1)
		if Model and Model.Parent then
			Model:Destroy()
		end
	end
	Debris:AddItem(script, 1)
	if script and script.Parent then
		script:Destroy()
	end
end

if not Creator or not Creator.Value or not Creator.Value:IsA("Player") or not Creator.Value.Parent or not Model or not Model.Value then
	DestroyModel()
	return
end

Creator = Creator.Value
Model = Model.Value

Character = Creator.Character
if not Character then
	DestroyModel()
	return
end

Creator.Changed:connect(function(Property)
	if Property == "Parent" and not Creator.Parent then
		DestroyModel()
	end
end)

Character.Changed:connect(function(Property)
	if Property == "Parent" and not Character.Parent then
		DestroyModel()
	end
end)

Model.Changed:connect(function(Property)
	if Property == "Parent" and not Model.Parent then
		DestroyModel()
	end
end)


Prompt: -- Initialize surface tool

Response:
local SurfaceTool = require(CoreTools:WaitForChild 'Surface')
Core.AssignHotkey('B', Core.Support.Call(Core.EquipTool, SurfaceTool));
Core.AddToolButton(Core.Assets.SurfaceIcon, 'B', SurfaceTool)


Prompt: --yep

Response:
local deb = false
local info = TweenInfo.new(tweenTime, easingStyle, easingDirection, repeats, reverse, delayTime)
local function tweenModel(model, CF)
	local CFrameValue = Instance.new("CFrameValue")
	CFrameValue.Value = model:GetPrimaryPartCFrame()

	CFrameValue:GetPropertyChangedSignal("Value"):Connect(function()
		model:SetPrimaryPartCFrame(CFrameValue.Value)
	end)

	local tween = tweenService:Create(CFrameValue, info, {Value = CF})
	tween:Play()

	tween.Completed:Connect(function()
		CFrameValue:Destroy()
	end)
end
wait(0)
tweenModel(Model, goal1.CFrame)


Prompt: --!strict

Response:
local Presets = require(script.Parent.Presets)
local Context = {}
function Context.new(presetIndex: string?): Presets.Preset
	local DefaultPresetInfo = Presets['Default']
	local self: Presets.Preset = presetIndex and Presets[presetIndex] or DefaultPresetInfo

	for propertyKey, propertyValue in next, DefaultPresetInfo do
		if not self[propertyKey] then
			self[propertyKey] = propertyValue
		end
	end

	return self
end
return Context


Prompt: -- Variables

Response:
LoadSceneRemoteEventModule.RespawnConnection = nil
LoadSceneRemoteEventModule.lastCalledLoadSceneTime = 0
LoadSceneRemoteEventModule.rng = Random.new()
LoadSceneRemoteEventModule.Player = Players.LocalPlayer
LoadSceneRemoteEventModule.RunService = RunService


Prompt:
--[[Maid
Manages the cleaning of events and other things.

API:
	HireMaid()                        Returns a new Maid object.

	Maid[key] = (function)            Adds a task to perform when cleaning up.
	Maid[key] = (event connection)    Manages an event connection. Anything that isn't a function is assumed to be this.
	Maid[key] = nil                   Removes a named task. If the task is an event, it is disconnected.

	Maid:GiveTask(task)               Same as above, but uses an incremented number as a key.
	Maid:DoCleaning()                 Disconnects all managed events and performs all clean-up tasks.
]]

Response:
local MakeMaid do
	local index = {
		GiveTask = function(self, task)
			local n = #self.Tasks+1
			self.Tasks[n] = task
			return n
		end;
		DoCleaning = function(self)
			local tasks = self.Tasks
			for name,task in pairs(tasks) do
				if type(task) == 'function' then
					task()
				else
					task:disconnect()
				end
				tasks[name] = nil
			end
			-- self.Tasks = {}
		end;
	};

	local mt = {
		__index = function(self, k)
			if index[k] then
				return index[k]
			else
				return self.Tasks[k]
			end
		end;
		__newindex = function(self, k, v)
			local tasks = self.Tasks
			if v == nil then
				-- disconnect if the task is an event
				if type(tasks[k]) ~= 'function' and tasks[k] then
					tasks[k]:disconnect()
				end
			elseif tasks[k] then
				-- clear previous task
				self[k] = nil
			end
			tasks[k] = v
		end;
	}

	function MakeMaid()
		return setmetatable({Tasks={},Instances={}},mt)
	end
end

local function GetCharacter(Descendant)
	-- Returns the Player and Charater that a descendent is part of, if it is part of one.
	-- @param Descendant A child of the potential character.

	local Charater = Descendant
	local Player   = Players:GetPlayerFromCharacter(Charater)

	while not Player do
		if Charater.Parent then
			Charater = Charater.Parent
			Player   = Players:GetPlayerFromCharacter(Charater)
		else
			return nil
		end
	end

	-- Found the player, character must be true.
	return Charater, Player
end


Prompt: --Muffins stuff that has to do with the module things

Response: local ComfShift = _Tune.ComfortShift


Prompt:
-------------------
-- Adonis Client --
-------------------
--!nocheck

Response:
																																																																																--[[
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
																																																																																]]


Prompt: -- holding down gun

Response:
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)


Prompt: --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!!

Response:
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)


Prompt: -- the Tool, reffered to here as "Block." Do not change it!

Response: Block = script.Parent.Key -- You CAN change the name in the quotes "Example Tool"


Prompt: --- Makes a type that contains a sequence, e.g. Vector3 or Color3

Response:
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


Prompt: --Impletion [awful coding i know]

Response:
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)


Prompt: -- FLAMGOik was here 2/16/2021

Response:
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)


Prompt: -- Remote variables

Response:
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")


Prompt: -- canonicalize an angle to +-180 degrees

Response:
function CameraUtils.sanitizeAngle(a: number): number
	return (a + math.pi)%(2*math.pi) - math.pi
end


Prompt:
--[=[
	Destroys the RemoteProperty object.
]=]

Response:
function RemoteProperty:Destroy()
	self._rs:Destroy()
	self._playerRemoving:Disconnect()
end

return RemoteProperty


Prompt:
--[=[
	Alias for `trove:Clean()`.
]=]

Response:
function Trove:Destroy()
	self:Clean()
end

return Trove


Response:
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)


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library"));
end)();
return function(p1, p2, p3, p4)
	if type(p1) ~= "table" then
		p1 = { p1 };
	end;
	local v1 = {};
	for v2,v3 in pairs(p1) do
		if p3 == nil then
			p3 = { 1, Enum.EasingStyle.Linear, Enum.EasingDirection.Out };
		else
			if p3[2] == nil then
				p3[2] = Enum.EasingStyle.Sine;
			elseif type(p3[2]) == "string" then
				if string.lower(p3[2]) == "expo" then
					p3[2] = Enum.EasingStyle.Exponential;
				else
					p3[2] = Enum.EasingStyle[p3[2]];
				end;
			end;
			if p3[3] == nil then
				p3[3] = Enum.EasingDirection.InOut;
			elseif type(p3[3]) == "string" then
				p3[3] = Enum.EasingDirection[p3[3]];
			end;
		end;
		local v5 = u1.TweenService:Create(v3, TweenInfo.new(unpack(p3)), p2);
		if p4 then
			task.delay(p4, function()
				v5:Play();
			end);
		else
			v5:Play();
		end;
		table.insert(v1, v5);
	end;
	return unpack(v1);
end;


Prompt: --Put this script in the StarterPack to work!

Response:
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)


Prompt: --------------------- KODLAND GUN ---------------------------

Response:
local function WaitForChild(parent, childName)
	while not parent:FindFirstChild(childName) do parent.ChildAdded:wait() end
	return parent[childName]
end

local Damage = 18


Prompt:
--[[
	Type definitions for data passed into CallToAction class
--]]

Response:
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


Prompt: --// Special Variables

Response:
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


Prompt:
--	local AttackRange, FieldOfView, AggroRange, ChanceOfBoredom, BoredomDuration,
--		Damage, DamageCooldown

Response:
	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)


Prompt: --script.Parent.Parent.CameraMode="LockFirstPerson" --first person

Response: local head = game.Workspace:findFirstChild(person.Name):findFirstChild("Head")


Prompt: --// Special Variables

Response:
return function(Vargs, GetEnv)
	local env = GetEnv(nil, {script = script})
	setfenv(1, env)

	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, time, Faces, unpack, string, Color3,
		newproxy, tostring, tonumber, Instance, TweenInfo, BrickColor,
		NumberRange, ColorSequence, NumberSequence, ColorSequenceKeypoint,
		NumberSequenceKeypoint, PhysicalProperties, Region3int16,
		Vector3int16, 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, time, Faces, unpack, string, Color3,
		newproxy, tostring, tonumber, Instance, TweenInfo, BrickColor,
		NumberRange, ColorSequence, NumberSequence, ColorSequenceKeypoint,
		NumberSequenceKeypoint, PhysicalProperties, Region3int16,
		Vector3int16, require, table, type, wait,
		Enum, UDim, UDim2, Vector2, Vector3, Region3, CFrame, Ray, delay

	local script = script
	local service = Vargs.Service
	local client = Vargs.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;

		Variables.Init = nil;
	end

	local function RunAfterLoaded()
		--// Get CodeName
		client.Variables.CodeName = client.Remote.Get("Variable", "CodeName")

		Variables.RunAfterLoaded = nil;
	end

	local function RunLast()
		--[[client = service.ReadOnly(client, {
				[client.Variables] = true;
				[client.Handlers] = true;
				G_API = true;
				G_Access = true;
				G_Access_Key = true;
				G_Access_Perms = true;
				Allowed_API_Calls = true;
				HelpButtonImage = true;
				Finish_Loading = true;
				RemoteEvent = true;
				ScriptCache = true;
				Returns = true;
				PendingReturns = true;
				EncodeCache = true;
				DecodeCache = true;
				Received = true;
				Sent = true;
				Service = true;
				Holder = true;
				GUIs = true;
				LastUpdate = true;
				RateLimits = true;

				Init = true;
				RunLast = true;
				RunAfterInit = true;
				RunAfterLoaded = true;
				RunAfterPlugins = true;
			}, true)--]]

			Variables.RunLast = nil;
	end

	getfenv().client = nil
	getfenv().service = nil
	getfenv().script = nil

	client.GUIs = {}
	client.GUIHolder = service.New("Folder")
	client.Variables = {
		Init = Init;
		RunLast = RunLast;
		RunAfterLoaded = RunAfterLoaded;
		CodeName = "";
		UIKeepAlive = true;
		KeybindsEnabled = true;
		ParticlesEnabled = true;
		CapesEnabled = true;
		HideChatCommands = false;
		Particles = {};
		KeyBinds = {};
		Aliases = {};
		Capes = {};
		savedUI = {};
		localSounds = {};
		ESPObjects = {};
		CommunicationsHistory = {};
		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;
		};
		KeycodeNames = require(client.Shared.KeycodeNames);
	};
end


Prompt:
--[=[
	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 this example). 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>
]=]

Response:
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


Prompt:
--[=[
	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"
	```
]=]

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


Prompt: -- When key pressed

Response:
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


Prompt: -- Get latest copy of tool

Response:
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;