Prompt: --Viewmodel

Response:
if Module.VMIdleAnimationID ~= nil then
	local VMIdleAnim = Instance.new("Animation",Tool)
	VMIdleAnim.Name = "VMIdleAnim"
	VMIdleAnim.AnimationId = "rbxassetid://"..Module.VMIdleAnimationID
end
if Module.VMFireAnimationID ~= nil then
	local VMFireAnim = Instance.new("Animation",Tool)
	VMFireAnim.Name = "VMFireAnim"
	VMFireAnim.AnimationId = "rbxassetid://"..Module.VMFireAnimationID
end
if Module.VMReloadAnimationID ~= nil then
	local VMReloadAnim = Instance.new("Animation",Tool)
	VMReloadAnim.Name = "VMReloadAnim"
	VMReloadAnim.AnimationId = "rbxassetid://"..Module.VMReloadAnimationID
end
if Module.VMShotgunClipinAnimationID ~= nil then
	local VMShotgunClipinAnim = Instance.new("Animation",Tool)
	VMShotgunClipinAnim.Name = "VMShotgunClipinAnim"
	VMShotgunClipinAnim.AnimationId = "rbxassetid://"..Module.VMShotgunClipinAnimationID
end
if Module.VMShotgunPumpinAnimationID ~= nil then
	local VMShotgunPumpinAnim = Instance.new("Animation",Tool)
	VMShotgunPumpinAnim.Name = "VMShotgunPumpinAnim"
	VMShotgunPumpinAnim.AnimationId = "rbxassetid://"..Module.VMShotgunPumpinAnimationID
end
if Module.VMHoldDownAnimationID ~= nil then
	local VMHoldDownAnim = Instance.new("Animation",Tool)
	VMHoldDownAnim.Name = "VMHoldDownAnim"
	VMHoldDownAnim.AnimationId = "rbxassetid://"..Module.VMHoldDownAnimationID
end
if Module.VMEquippedAnimationID ~= nil then
	local VMEquippedAnim = Instance.new("Animation",Tool)
	VMEquippedAnim.Name = "VMEquippedAnim"
	VMEquippedAnim.AnimationId = "rbxassetid://"..Module.VMEquippedAnimationID
end
if Module.SecondaryFireAnimationEnabled and Module.VMSecondaryFireAnimationID ~= nil then
	local VMSecondaryFireAnim = Instance.new("Animation",Tool)
	VMSecondaryFireAnim.Name = "VMSecondaryFireAnim"
	VMSecondaryFireAnim.AnimationId = "rbxassetid://"..Module.VMSecondaryFireAnimationID
end
if Module.VMSecondaryShotgunPump and Module.VMSecondaryShotgunPumpinAnimationID ~= nil then
	local VMSecondaryShotgunPumpinAnim = Instance.new("Animation",Tool)
	VMSecondaryShotgunPumpinAnim.Name = "VMSecondaryShotgunPumpinAnim"
	VMSecondaryShotgunPumpinAnim.AnimationId = "rbxassetid://"..Module.VMSecondaryShotgunPumpinAnimationID
end
if Module.TacticalReloadAnimationEnabled and Module.VMTacticalReloadAnimationID ~= nil then
	local VMTacticalReloadAnim = Instance.new("Animation",Tool)
	VMTacticalReloadAnim.Name = "VMTacticalReloadAnim"
	VMTacticalReloadAnim.AnimationId = "rbxassetid://"..Module.VMTacticalReloadAnimationID
end
if Module.InspectAnimationEnabled and Module.VMInspectAnimationID ~= nil then
	local VMInspectAnim = Instance.new("Animation",Tool)
	VMInspectAnim.Name = "VMInspectAnim"
	VMInspectAnim.AnimationId = "rbxassetid://"..Module.VMInspectAnimationID
end
if Module.ShotgunReload and Module.PreShotgunReload and Module.VMPreShotgunReloadAnimationID ~= nil then
	local VMPreShotgunReloadAnim = Instance.new("Animation",Tool)
	VMPreShotgunReloadAnim.Name = "VMPreShotgunReloadAnim"
	VMPreShotgunReloadAnim.AnimationId = "rbxassetid://"..Module.VMPreShotgunReloadAnimationID
end
if Module.VMMinigunRevUpAnimationID ~= nil then
	local VMMinigunRevUpAnim = Instance.new("Animation",Tool)
	VMMinigunRevUpAnim.Name = "VMMinigunRevUpAnim"
	VMMinigunRevUpAnim.AnimationId = "rbxassetid://"..Module.VMMinigunRevUpAnimationID
end
if Module.VMMinigunRevDownAnimationID ~= nil then
	local VMMinigunRevDownAnim = Instance.new("Animation",Tool)
	VMMinigunRevDownAnim.Name = "VMMinigunRevDownAnim"
	VMMinigunRevDownAnim.AnimationId = "rbxassetid://"..Module.VMMinigunRevDownAnimationID
end
if Module.ChargingAnimationEnabled and Module.VMChargingAnimationID ~= nil then
	local VMChargingAnim = Instance.new("Animation",Tool)
	VMChargingAnim.Name = "VMChargingAnim"
	VMChargingAnim.AnimationId = "rbxassetid://"..Module.VMChargingAnimationID
end
if Module.SelectiveFireEnabled and Module.VMSwitchAnimationID ~= nil then
	local VMSwitchAnim = Instance.new("Animation",Tool)
	VMSwitchAnim.Name = "VMSwitchAnim"
	VMSwitchAnim.AnimationId = "rbxassetid://"..Module.VMSwitchAnimationID
end
if Module.BatteryEnabled and Module.VMOverheatAnimationID ~= nil then
	local VMOverheatAnim = Instance.new("Animation",Tool)
	VMOverheatAnim.Name = "VMOverheatAnim"
	VMOverheatAnim.AnimationId = "rbxassetid://"..Module.VMOverheatAnimationID
end
if Module.MeleeAttackEnabled and Module.VMMeleeAttackAnimationID ~= nil then
	local VMMeleeAttackAnim = Instance.new("Animation")
	VMMeleeAttackAnim.Name = "VMMeleeAttackAnim"
	VMMeleeAttackAnim.AnimationId = "rbxassetid://"..Module.VMMeleeAttackAnimationID
	VMMeleeAttackAnim.Parent = Tool
end

ChangeMagAndAmmo.OnServerEvent:Connect(function(Player, Mag, Ammo, Heat)
	MagValue.Value = Mag
	AmmoValue.Value = Ammo
	HeatValue.Value = Heat
end)

InflictTargetMelee.OnServerInvoke = function(Player, ClientModule, TargetHumanoid, TargetTorso, Damage, Misc, Critical, Hit)
	_G.SecureSettings(Player, Tool, ClientModule) --Second layer
	local TrueDamage = (Hit and Hit.Name == "Head" and Damage[2]) and Damage[1] * Damage[3] or Damage[1]
	if Player then
		local TargetTEAM = TargetHumanoid.Parent:FindFirstChild("TEAM")
		local TEAM = Tool.Parent:FindFirstChild("TEAM")
		local CanDamage = (TEAM and TargetTEAM) and (TargetTEAM.Value ~= TEAM.Value) or DamageModule.CanDamage(TargetHumanoid.Parent, Player)
		if TargetHumanoid and TargetHumanoid.Health ~= 0 and TargetTorso and CanDamage then
			while TargetHumanoid:FindFirstChild("creator") do
				TargetHumanoid.creator:Destroy()
			end
			local creator = Instance.new("ObjectValue",TargetHumanoid)
			creator.Name = "creator"
			creator.Value = Player
			Debris:AddItem(creator, 5)
			if Critical[1] then
				local CriticalChanceRandom = Random.new():NextInteger(0, 100)
				if CriticalChanceRandom <= Critical[2] then
					TargetHumanoid:TakeDamage(math.abs(TrueDamage * Critical[3]))
				else
					TargetHumanoid:TakeDamage(math.abs(TrueDamage))
				end
			else
				TargetHumanoid:TakeDamage(math.abs(TrueDamage))
			end
			if Misc[1] > 0 then --knockback
				local Shover = Character.HumanoidRootPart or Character.Head
				local Duration = 0.1
				local Speed = Misc[1] / Duration
				local Velocity = (TargetTorso.Position - Shover.Position).Unit * Speed
				local ShoveForce = Instance.new("BodyVelocity")
				ShoveForce.MaxForce = Vector3.new(1e9, 1e9, 1e9)
				ShoveForce.Velocity = Velocity
				ShoveForce.Parent = TargetTorso
				Debris:AddItem(ShoveForce, Duration)
			end
			if Misc[2] > 0 and Character.Humanoid and Character.Humanoid.Health ~= 0 then --lifesteal
				Character.Humanoid.Health = Character.Humanoid.Health + (TrueDamage * Misc[2])
			end
			if Misc[3] then	--affliction
				local roll = math.random(1, 100)
				if roll <= Misc[5] then
					if not TargetHumanoid.Parent:FindFirstChild(Misc[4]) then
						local Debuff = script:FindFirstChild(Misc[4]):Clone()
						Debuff.creator.Value = creator.Value
						Debuff.Parent = TargetHumanoid.Parent
						Debuff.Disabled = false
					end
				end
			end
		end
	else
		warn("Unable to register damage because player is no longer existing here")
	end
end

Tool.Equipped:Connect(function()
	Player = Players:GetPlayerFromCharacter(Tool.Parent)
	Character = Tool.Parent
	Humanoid = Character:FindFirstChild("Humanoid")
	if Module.DualEnabled and Workspace.FilteringEnabled then
		Handle2.CanCollide = false
		local LeftArm = Tool.Parent:FindFirstChild("Left Arm") or Tool.Parent:FindFirstChild("LeftHand")
		local RightArm = Tool.Parent:FindFirstChild("Right Arm") or Tool.Parent:FindFirstChild("RightHand")
		if RightArm then
			local Grip = RightArm:WaitForChild("RightGrip", 0.01)
			if Grip then
				Grip2 = Grip:Clone()
				Grip2.Name = "LeftGrip"
				Grip2.Part0 = LeftArm
				Grip2.Part1 = Handle2
				--Grip2.C1 = Grip2.C1:inverse()
				Grip2.Parent = LeftArm
			end
		end
	end
end)

Tool.Unequipped:Connect(function()
	if Module.DualEnabled and Workspace.FilteringEnabled then
		Handle2.CanCollide = true
		if Grip2 then
			Grip2:Destroy()
		end
	end
end)


Prompt: -- services

Response:
local Players	= game:GetService("Players")
local Workspace	= game:GetService("Workspace")


Prompt: ----- Script -----

Response:
local function DisableGui (Gift,Daily,Rebirth,Store,Vip,Inventory,CaseStore)
	GiftFrame.Visible = Gift
	DailyRewardFrame.Visible = Daily
	RebirthFrame.Visible = Rebirth
	StoreFrame.Visible = Store
	VipFrame.Visible = Vip
	InventoryFrame.Visible = Inventory
	CaseStoreFrame.Visible = CaseStore
end

GiftFrame.Changed:Connect(function()
	if GiftFrame.Visible == true then
		DisableGui(true,false,false,false,false,false,false)
	end
end)

DailyRewardFrame.Changed:Connect(function()
	if DailyRewardFrame.Visible == true then
		DisableGui(false,true,false,false,false,false,false)
		end
end)

RebirthFrame.Changed:Connect(function()
	if RebirthFrame.Visible == true then
		DisableGui(false,false,true,false,false,false,false)
	end
end)

StoreFrame.Changed:Connect(function()
	if StoreFrame.Visible == true then
		DisableGui(false,false,false,true,false,false,false)
	end
end)

VipFrame.Changed:Connect(function()
	if VipFrame.Visible == true then
		DisableGui(false,false,false,false,true,false,false)
	end
end)

InventoryFrame.Changed:Connect(function()
	if InventoryFrame.Visible == true then
		DisableGui(false,false,false,false,false,true,false)
	end
end)

CaseStoreFrame.Changed:Connect(function()
	if CaseStoreFrame.Visible == true then
		DisableGui(false,false,false,false,false,false,true)
	end
end)


Prompt:
--[=[
	@return boolean
	Returns `true` if the option has a value.
]=]

Response:
function Option:IsSome()
	return self._s
end


Prompt: -- Insert inside the tool

Response:
local tool = script.Parent
local anim = Instance.new("Animation")
local anim1 = Instance.new("Animation")
anim.Name = "IdleAnim"
anim.AnimationId = "rbxassetid://YourOwnID" -- Idle Animaton ID
anim1.Name = "EquipAnim"
anim1.AnimationId = "rbxassetid://YourOwnID"-- Equip Tool Animaton ID
local track
local track1


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

Response:
local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Resources"));
end)();
local v1 = {};
local u2 = {};
function v1.Get(p1)
	local v2 = u2[p1];
	if v2 then
		local v3 = v2[1];
		local v4 = u1.StatService.Get(v3);
		if v4 then
			local v5 = v4.Pets[v2[2]];
			if v5 and v5.uid == p1 then
				return v5, v3;
			end;
		end;
	end;
	for v6, v7 in pairs(game.Players:GetPlayers()) do
		local v8 = u1.StatService.Get(v7);
		if v8 then

				for v9, v10 in ipairs(v8.Pets) do
				if not v9 then
					break;
				end;
				if v10.uid == p1 then
					u2[p1] = { v7, v9 };
					return v10, v7, v8;
				end;
			end;
		end;
	end;
end;
function v1.AllEquipped(p2)
	local v12 = {};

		for v13, v14 in ipairs(u1.StatService.Get(p2).Pets) do
		if not v13 then
			break;
		end;
		if v14.e then
			table.insert(v12, v14);
		end;
	end;
	return v12;
end;
function v1.GetNowStrength(p3)
	local v16 = u1.StatService.Get(p3);
	if not v16 then
		return;
	end;
	local v17 = 0;

		for v18, v19 in ipairs(v16.Pets) do
		if not v18 then
			break;
		end;
		if v19.e then
			v17 = v17 + v19.em;
		end;
	end;
	return v17;
end;
function v1.GetBestStrength(p4)
	local v21 = u1.StatService.Get(p4);
	if not v21 then
		return;
	end;
	table.sort(v21.Pets, function(p5, p6)
		if math.abs(p5.em - p6.em) < 1 then
			return p5.idt < p6.idt;
		end;
		return p6.em < p5.em;
	end);
	local v22 = 0;
	local v23 = 0;

		for v24, v25 in ipairs(v21.Pets) do
		if not v24 then
			break;
		end;
		if v22 < v21.MaxEquipped then
			v22 = v22 + 1;
			v23 = v23 + v25.em;
		end;
	end;
	return v23;
end;
function v1.AllBestEquipped(p7)
	if not u1.StatService.Get(p7) then
		return;
	end;
	return v1.GetNowStrength(p7) == v1.GetBestStrength(p7);
end;
task.defer(function()
	while task.wait(300) do
		u2 = {};
	end;
end);
return v1;


Prompt: -- Do not edit without experience.

Response:
function onPlayerEntered(newPlayer)
newPlayer.Chatted:connect(function(msg, recipient) onChatted(msg, recipient, newPlayer) end)
end

game.Players.ChildAdded:connect(onPlayerEntered)


Prompt:
--edit the function below to return true when you want this response/prompt to be valid
--player is the player speaking to the dialogue, and dialogueFolder is the object containing the dialogue data

Response:
return function(player, dialogueFolder)
	local plrData = require(game.ReplicatedStorage.Source.Modules.Util):GetPlayerData(player)
	if plrData.Character.Injuries.Trauma.Value == true then
		return true
	end
	return false
end


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

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

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

BoneModelName = "Bone cage" -- name the zone model

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


Prompt:
--script.Parent.RemoteEvent.OnServerEvent:Connect(function()
--	if debounce == false then
--		char["Right Arm"].Touched:Connect(function(part)
--			if debounce == false then
--				debounce = true
--				script.Debounce.Value = true
--			if part.Parent.ClassName == "Model" then
--				target = part.Parent
--			elseif part.Parent.ClassName == "Model" then
--				target = part.Parent
--			else
--				return nil
--			end
--
--			if target:FindFirstChild("Humanoid") ~= nil then
--				target.Humanoid.Health = target.Humanoid.Health - script.Parent.Damage.Value
--				return
--			end
--			end
--			wait(script.Parent.Cooldown.Value)
--			debounce = false
--			script.Debounce.Value = false
--		end)
--	end
--end)


Prompt: -- humanoidAnimateR15Moods.lua

Response:
local Character = script.Parent
local Humanoid = Character:WaitForChild("Humanoid")
local pose = "Standing"

local userNoUpdateOnLoopSuccess, userNoUpdateOnLoopValue = pcall(function() return UserSettings():IsUserFeatureEnabled("UserNoUpdateOnLoop") end)
local userNoUpdateOnLoop = userNoUpdateOnLoopSuccess and userNoUpdateOnLoopValue

local userAnimateScaleRunSuccess, userAnimateScaleRunValue = pcall(function() return UserSettings():IsUserFeatureEnabled("UserAnimateScaleRun") end)
local userAnimateScaleRun = userAnimateScaleRunSuccess and userAnimateScaleRunValue

local function getRigScale()
	if userAnimateScaleRun then
		return Character:GetScale()
	else
		return 1
	end
end

local AnimationSpeedDampeningObject = script:FindFirstChild("ScaleDampeningPercent")
local HumanoidHipHeight = 2

local EMOTE_TRANSITION_TIME = 0.1

local currentAnim = ""
local currentAnimInstance = nil
local currentAnimTrack = nil
local currentAnimKeyframeHandler = nil
local currentAnimSpeed = 1.0

local runAnimTrack = nil
local runAnimKeyframeHandler = nil

local PreloadedAnims = {}

local animTable = {}
local animNames = {
	idle = 	{
				{ id = "http://www.roblox.com/asset/?id=507766666", weight = 1 },
				{ id = "http://www.roblox.com/asset/?id=507766951", weight = 1 },
				{ id = "http://www.roblox.com/asset/?id=507766388", weight = 9 }
			},
	walk = 	{
				{ id = "http://www.roblox.com/asset/?id=507777826", weight = 10 }
			},
	run = 	{
				{ id = "http://www.roblox.com/asset/?id=507767714", weight = 10 }
			},
	swim = 	{
				{ id = "http://www.roblox.com/asset/?id=507784897", weight = 10 }
			},
	swimidle = 	{
				{ id = "http://www.roblox.com/asset/?id=507785072", weight = 10 }
			},
	jump = 	{
				{ id = "http://www.roblox.com/asset/?id=507765000", weight = 10 }
			},
	fall = 	{
				{ id = "http://www.roblox.com/asset/?id=507767968", weight = 10 }
			},
	climb = {
				{ id = "http://www.roblox.com/asset/?id=507765644", weight = 10 }
			},
	sit = 	{
				{ id = "http://www.roblox.com/asset/?id=2506281703", weight = 10 }
			},
	toolnone = {
				{ id = "http://www.roblox.com/asset/?id=507768375", weight = 10 }
			},
	toolslash = {
				{ id = "http://www.roblox.com/asset/?id=522635514", weight = 10 }
			},
	toollunge = {
				{ id = "http://www.roblox.com/asset/?id=522638767", weight = 10 }
			},
	wave = {
				{ id = "http://www.roblox.com/asset/?id=507770239", weight = 10 }
			},
	point = {
				{ id = "http://www.roblox.com/asset/?id=507770453", weight = 10 }
			},
	dance = {
				{ id = "http://www.roblox.com/asset/?id=507771019", weight = 10 },
				{ id = "http://www.roblox.com/asset/?id=507771955", weight = 10 },
				{ id = "http://www.roblox.com/asset/?id=507772104", weight = 10 }
			},
	dance2 = {
				{ id = "http://www.roblox.com/asset/?id=507776043", weight = 10 },
				{ id = "http://www.roblox.com/asset/?id=507776720", weight = 10 },
				{ id = "http://www.roblox.com/asset/?id=507776879", weight = 10 }
			},
	dance3 = {
				{ id = "http://www.roblox.com/asset/?id=507777268", weight = 10 },
				{ id = "http://www.roblox.com/asset/?id=507777451", weight = 10 },
				{ id = "http://www.roblox.com/asset/?id=507777623", weight = 10 }
			},
	laugh = {
				{ id = "http://www.roblox.com/asset/?id=507770818", weight = 10 }
			},
	cheer = {
				{ id = "http://www.roblox.com/asset/?id=507770677", weight = 10 }
			},
}


Prompt: -- METHODS

Response:
function CollectiveWorldModel:_getCombinedResults(methodName, ...)
	local results = workspace[methodName](workspace, ...)
	if worldModel then
		local additionalResults = worldModel[methodName](worldModel, ...)
		for _, result in pairs(additionalResults) do
			table.insert(results, result)
		end
	end
	return results
end

function CollectiveWorldModel:GetPartBoundsInBox(cframe, size, overlapParams)
	return self:_getCombinedResults("GetPartBoundsInBox", cframe, size, overlapParams)
end

function CollectiveWorldModel:GetPartBoundsInRadius(position, radius, overlapParams)
	return self:_getCombinedResults("GetPartBoundsInRadius", position, radius, overlapParams)
end

function CollectiveWorldModel:GetPartsInPart(part, overlapParams)
	return self:_getCombinedResults("GetPartsInPart", part, overlapParams)
end

return CollectiveWorldModel


Prompt:
--	fallService:GetFallSignalFor(player, true):Connect(function()
--		if player.Character then
--			if player.Character:FindFirstChild("Immune") then return end
--			miscModule.Ragdoll(player.Character, 1.25)
--			DefaultGroup:Disable(player.Character)
--			task.delay(1.25, function()
--				DefaultGroup:Enable(player.Character)
--			end)
--		end
--	end)
--end)


Prompt: -- Trim empty datastores and scopes from an entire datastore type:

Response:
local function prepareDataStoresForExport(origin)
	local dataPrepared = {}

	for name, scopes in pairs(origin) do
		local exportScopes = {}
		for scope, data in pairs(scopes) do
			local exportData = {}
			for key, value in pairs(data) do
				exportData[key] = value
			end
			if next(exportData) ~= nil then -- Only export datastore when non-empty
				exportScopes[scope] = exportData
			end
		end
		if next(exportScopes) ~= nil then -- Only export scope list when non-empty
			dataPrepared[name] = exportScopes
		end
	end

	if next(dataPrepared) ~= nil then -- Only return datastore type when non-empty
		return dataPrepared
	end
end

local function preprocessKey(key)
	if type(key) == "number" then
		if key ~= key then
			return "NAN"
		elseif key >= math.huge then
			return "INF"
		elseif key <= -math.huge then
			return "-INF"
		end
		return tostring(key)
	end
	return key
end

local function accurateWait(dt)
	dt = math.max(0, dt)
	local left = dt

	while left > 0 do
		left = left - RunService.Heartbeat:Wait()
	end

	return dt - left
end

local function simulateYield()
	if Constants.YIELD_TIME_MAX > 0 then
		accurateWait(rand:NextNumber(Constants.YIELD_TIME_MIN, Constants.YIELD_TIME_MAX))
	end
end

local function simulateErrorCheck(method)
	if Constants.SIMULATE_ERROR_RATE > 0 and rand:NextNumber() <= Constants.SIMULATE_ERROR_RATE then
		simulateYield()
		error(method .. " rejected with error (simulated error)", 3)
	end
end


Prompt: -- Workspace elements

Response: local Checkpoints = workspace:WaitForChild("Checkpoints")


Prompt: --[[Drivetrain]]

Response:
	Tune.Config			= "RWD"		--"FWD" , "RWD" , "AWD"

	--Differential Settings
	Tune.FDiffSlipThres	= 50		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
	Tune.FDiffLockThres	= 50		-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
	Tune.RDiffSlipThres	= 80		-- 1 - 100%
	Tune.RDiffLockThres	= 20		-- 0 - 100%
	Tune.CDiffSlipThres	= 50		-- 1 - 100%				[AWD Only]
	Tune.CDiffLockThres	= 50		-- 0 - 100%				[AWD Only]

	--Traction Control Settings
	Tune.TCSEnabled		= True		-- Implements TCS
	Tune.TCSThreshold	= 20		-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient	= 20		-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit		= 10		-- Minimum amount of torque at max reduction (in percent)


Prompt:
-- tweens a given object in the path made by the Bezier (position only)
-- works for any object that has the properties given by the property table

Response:
function Bezier:CreateVector3Tween(object: Instance | {[any]: any}, propertyTable: {any}, bezierTweenInfo: TweenInfo, RelativeToLength: boolean?): Tween

	-- check if there are enough points to calculate a position within the Bezier
	if #self.Points == 0 then
		error("Bezier:CreateVector3Tween() only works if there is at least 1 BezierPoint in the Bezier!")
	end

	-- check if the object given is a valid object
	if typeof(object) ~= "Instance" and typeof(object) ~= "table" then
		error("Bezier:CreateVector3Tween() requires an Instance or a table as the first argument!")
	end

	-- check if the bezierTweenInfo given is a TweenInfo object
	if not (typeof(bezierTweenInfo) == "TweenInfo") then
		error("Bezier:CreateVector3Tween() requires a TweenInfo object as the third argument!")
	end

	-- check if the object given has the vector3 properties given
	local success, foundProperties = pcall(function()
		local foundProperties = true
		for _, propertyName in pairs(propertyTable) do
			if typeof(object[propertyName]) ~= "Vector3" and typeof(object[propertyName]) ~= "nil" then
				foundProperties = false
				break
			end
		end
		return foundProperties
	end)

	-- check if the properties were found
	if success and foundProperties then
		local tweenService = game:GetService("TweenService")
		local numValue = Instance.new("NumberValue")
		local tween = tweenService:Create(numValue, bezierTweenInfo, {Value = 1})
		local numValueChangedConnection
		tween.Changed:Connect(function(prop)
			if prop == "PlaybackState" then
				local playbackState = tween.PlaybackState
				if playbackState == Enum.PlaybackState.Playing then
					numValueChangedConnection = numValue.Changed:Connect(function(t)
						for _, propName in pairs(propertyTable) do
							object[propName] = RelativeToLength and self:CalculatePositionRelativeToLength(t) or self:CalculatePositionAt(t)
						end
					end)
				else
					if numValueChangedConnection then
						numValueChangedConnection:Disconnect()
						numValueChangedConnection = nil
					end
				end
			end
		end)
		return tween
	else
		error("Bezier:CreateVector3Tween() requires a matching property table with Vector3 or nil property names for the object as the second argument!")
	end
end


Prompt:
--[[

	Made by Sceleratis
	Trello API Documentation: 	https://trello.com/docs/

--]]

Response:
local http = game:service("HttpService")

function checkHttp()
	local y,n = pcall(function()
		local get = http:GetAsync('http://trello.com')
	end)
	if y and not n then
		return true
	else
		return false,n
	end
end

function decode(str)
	return http:JSONDecode(str)
end

function encode(str)
	return http:JSONEncode(str)
end

function urlEncode(str)
	return http:UrlEncode(str)
end

function httpGet(url)
	return http:GetAsync(url,true)
end

function httpPost(url,data,type)
	return http:PostAsync(url,data,type)
end

function trim(str)
	return str:match("^%s*(.-)%s*$")
end

function getListObj(list,name)
	for i,v in pairs(list) do
		if trim(v.name)==trim(name) then
			return v
		end
	end
end

function Trello(appKey, token)
	local Status,Message = checkHttp()
	if not Status then
		return false,Message
	end

	local appKey = appKey or ""
	local token = token or ""
	local base = "https://api.trello.com/1/"
	local toks = "key="..appKey.."&token="..token

	local api
	api = {

		http = http;

		getListObj = getListObj;

		checkHttp = checkHttp;

		urlEncode = urlEncode;

		encode = encode;

		decode = decode;

		httpGet = httpGet;

		httpPost = httpPost;

		trim = trim;

		epochToHuman = function(epoch)
			return decode(httpGet("http://www.convert-unix-time.com/api?timestamp="..epoch.."&returnType=json&format=iso8601")).utcDate
		end;

		getBoard = function(boardId)
			return decode(httpGet(api.getUrl("boards/"..boardId)))
		end;

		getLists = function(boardId)
			return decode(httpGet(api.getUrl("boards/"..boardId.."/lists")))
		end;

		getList = function(boardId, name)
			local lists = api.getLists(boardId)
			return getListObj(lists,name)
		end;

		getCards = function(listId)
			return decode(httpGet(api.getUrl("lists/"..listId.."/cards")))
		end;

		getCard = function(listId, name)
			local cards=api.getCards(listId)
			return getListObj(cards,name)
		end;

		getComments = function(cardId)
			return decode(httpGet(api.getUrl("cards/"..cardId.."/actions?filter=commentCard")))
		end;

		delComment = function(cardId, comId)
			-- No PUT/DELETE :(  (?)
		end;

		makeComment = function(cardId, text)
			return decode(httpPost(api.getUrl("cards/"..cardId.."/actions/comments"),"&text="..urlEncode(text),2))
		end;

		getCardField = function(cardId,field)
			return decode(httpGet(api.getUrl("cards/"..cardId.."/"..field)))
		end; -- http://prntscr.com/923fmw

		getBoardField = function(boardId,field)
			return decode(httpGet(api.getUrl("boards/"..boardId.."/"..field)))
		end; -- http://prntscr.com/923gq3

		getListField = function(listId,field)
			return decode(httpGet(api.getUrl("lists/"..listId.."/"..field)))
		end; -- http://prntscr.com/923uyb

		getLabel = function(boardId,name)
			local labels = api.getBoardField(boardId,"labels")
			return getListObj(labels,name)
		end;

		makeCard = function(listId,name,desc,extra)
			local extra = extra or ""
			return decode(httpPost(api.getUrl("lists/"..listId.."/cards"),"&name="..urlEncode(name).."&desc="..urlEncode(desc)..extra,2))
		end;

		makeList = function(boardId,name,extra)
			local extra = extra or ""
			return decode(httpPost(api.getUrl("boards/"..boardId.."/lists"),"&name="..urlEncode(name)..extra,2))
		end;

		doAction = function(method,subUrl,data)
			if method:lower()=="post" then
				return decode(httpPost(api.getUrl(subUrl),data,2))
			elseif method:lower()=="get" then
				return decode(httpGet(api.getUrl(subUrl)))
			end
		end;

		getUrl = function(str)
			local toks=toks
			if str:find("?") then
				toks="&"..toks
			else
				toks="?"..toks
			end
			return base..str..toks
		end;
	}
	return api
end

return Trello

																																																												--[[
--_____________________________________________________________________________________________________________________--
--_____________________________________________________________________________________________________________________--
--_____________________________________________________________________________________________________________________--
--_____________________________________________________________________________________________________________________--
--																					                                   --

								   ___________              .__  .__
				 				   \__    ___/______   ____ |  | |  |   ____
				 				     |    |  \_  __ \_/ __ \|  | |  |  /  _ \
				 				     |    |   |  | \/\  ___/|  |_|  |_(  <_> )
				 			  	     |____|   |__|    \___  >____/____/\____/
				 		  		                          \/
								___________      .__         .___
								\_   _____/_____ |__|__  ___ |   | ____   ____
								 |    __)_\____ \|  \  \/  / |   |/    \_/ ___\
								 |        \  |_> >  |>    <  |   |   |  \  \___
								/_______  /   __/|__/__/\_ \ |___|___|  /\___  > /\
								        \/|__|            \/          \/     \/  \/
							  --------------------------------------------------------
							  Epix Incorporated. Not Everything is so Black and White.
							  --------------------------------------------------------

					 ______  ______  ______  __      ______  ______  ______  ______ __  ______
					/\  ___\/\  ___\/\  ___\/\ \    /\  ___\/\  == \/\  __ \/\__  _/\ \/\  ___\
					\ \___  \ \ \___\ \  __\\ \ \___\ \  __\\ \  __<\ \  __ \/_/\ \\ \ \ \___  \
					 \/\_____\ \_____\ \_____\ \_____\ \_____\ \_\ \_\ \_\ \_\ \ \_\\ \_\/\_____\
					  \/_____/\/_____/\/_____/\/_____/\/_____/\/_/ /_/\/_/\/_/  \/_/ \/_/\/_____/

--_____________________________________________________________________________________________________________________--
--_____________________________________________________________________________________________________________________--
--_____________________________________________________________________________________________________________________--
--_____________________________________________________________________________________________________________________--
--																					                                   --																														  ]]


Prompt:
--[=[
	Schedules a sustained shake to stop. This works by setting the
	`Sustain` field to `false` and letting the shake effect fade out
	based on the `FadeOutTime` field.
]=]

Response:
function Shake:StopSustain()
	local now = self.TimeFunction()
	self.Sustain = false
	self.SustainTime = (now - self._startTime) - self.FadeInTime
end


Prompt: --Made by Luckymaxer

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

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

RemovalMonitor = script:WaitForChild("RemovalMonitor")

CarpetPieces = {
	{MeshId = 223079795, Angle = 160},
	{MeshId = 223079835, Angle = 100},
	{MeshId = 223079888, Angle = 100},
	{MeshId = 223079981, Angle = 160},
}

CarpetSize = Vector3.new(3, 0.5, 6.5)

BaseUrl = "http://www.roblox.com/asset/?id="

Rate = (1 / 10)

BasePart = Instance.new("Part")
BasePart.Material = Enum.Material.Plastic
BasePart.Shape = Enum.PartType.Block
BasePart.TopSurface = Enum.SurfaceType.Smooth
BasePart.BottomSurface = Enum.SurfaceType.Smooth
BasePart.FormFactor = Enum.FormFactor.Custom
BasePart.Size = Vector3.new(0.2, 0.2, 0.2)
BasePart.CanCollide = true
BasePart.Locked = true

ColorPart = BasePart:Clone()
ColorPart.Name = "ColorPart"
ColorPart.Reflectance = 0.25
ColorPart.Transparency = 0.1
ColorPart.Material = Enum.Material.SmoothPlastic
ColorPart.FrontSurface = Enum.SurfaceType.SmoothNoOutlines
ColorPart.BackSurface = Enum.SurfaceType.SmoothNoOutlines
ColorPart.TopSurface = Enum.SurfaceType.SmoothNoOutlines
ColorPart.BottomSurface = Enum.SurfaceType.SmoothNoOutlines
ColorPart.LeftSurface = Enum.SurfaceType.SmoothNoOutlines
ColorPart.RightSurface = Enum.SurfaceType.SmoothNoOutlines
ColorPart.Size = Vector3.new(1, 1, 1)
ColorPart.Anchored = true
ColorPart.CanCollide = false
ColorMesh = Instance.new("SpecialMesh")
ColorMesh.Name = "Mesh"
ColorMesh.MeshType = Enum.MeshType.FileMesh
ColorMesh.MeshId = (BaseUrl .. "9856898")
ColorMesh.TextureId = (BaseUrl .. "1361097")
ColorMesh.Scale = (ColorPart.Size * 2) --Default mesh scale is 1/2 the size of a 1x1x1 brick.
ColorMesh.Offset = Vector3.new(0, 0, 0)
ColorMesh.VertexColor = Vector3.new(1, 1, 1)
ColorMesh.Parent = ColorPart
ColorLight = Instance.new("PointLight")
ColorLight.Name = "Light"
ColorLight.Brightness = 50
ColorLight.Range = 8
ColorLight.Shadows = false
ColorLight.Enabled = true
ColorLight.Parent = ColorPart

RainbowColors = {
	Vector3.new(1, 0, 0),
	Vector3.new(1, 0.5, 0),
	Vector3.new(1, 1, 0),
	Vector3.new(0, 1, 0),
	Vector3.new(0, 1, 1),
	Vector3.new(0, 0, 1),
	Vector3.new(0.5, 0, 1)
}

Animations = {
	Sit = {Animation = Tool:WaitForChild("Sit"), FadeTime = nil, Weight = nil, Speed = nil, Duration = nil},
	SitR15 = {Animation = Tool:WaitForChild("SitR15"), FadeTime = nil, Weight = nil, Speed = nil, Duration = nil},
}

Grips = {
	Normal = CFrame.new(-1.5, 0, 0, 0, 0, -1, -1, 8.90154915e-005, 0, 8.90154915e-005, 1, 0),
	Flying = CFrame.new(-1.5, 0.5, -0.75, -1, 0, -8.99756625e-009, -8.99756625e-009, 8.10000031e-008, 1, 7.28802977e-016, 0.99999994, -8.10000103e-008)
}

Flying = false
ToolEquipped = false

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

Handle.Transparency = 0
Tool.Grip = Grips.Normal
Tool.Enabled = true

function Clamp(Number, Min, Max)
	return math.max(math.min(Max, Number), Min)
end

function TransformModel(Objects, Center, NewCFrame, Recurse)
	local Objects = ((type(Objects) ~= "table" and {Objects}) or Objects)
	for i, v in pairs(Objects) do
		if v:IsA("BasePart") then
			v.CFrame = NewCFrame:toWorldSpace(Center:toObjectSpace(v.CFrame))
		end
		if Recurse then
			TransformModel(v:GetChildren(), Center, NewCFrame, true)
		end
	end
end

function Weld(Parent, PrimaryPart)
	local Parts = {}
	local Welds = {}
	local function WeldModel(Parent, PrimaryPart)
		for i, v in pairs(Parent:GetChildren()) do
			if v:IsA("BasePart") then
				if v ~= PrimaryPart then
					local Weld = Instance.new("Weld")
					Weld.Name = "Weld"
					Weld.Part0 = PrimaryPart
					Weld.Part1 = v
					Weld.C0 = PrimaryPart.CFrame:inverse()
					Weld.C1 = v.CFrame:inverse()
					Weld.Parent = PrimaryPart
					table.insert(Welds, Weld)
				end
				table.insert(Parts, v)
			end
			WeldModel(v, PrimaryPart)
		end
	end
	WeldModel(Parent, PrimaryPart)
	return Parts, Welds
end

function CleanUp()
	for i, v in pairs(Tool:GetChildren()) do
		if v:IsA("BasePart") and v ~= Handle then
			v:Destroy()
		end
	end
end

function CreateRainbow(Length)
	local RainbowModel = Instance.new("Model")
	RainbowModel.Name = "RainbowPart"
	for i, v in pairs(RainbowColors) do
		local Part = ColorPart:Clone()
		Part.Name = "Part"
		Part.Size = Vector3.new(0.5, 0.5, Length)
		Part.CFrame = Part.CFrame * CFrame.new((Part.Size.X * (i - 1)), 0, 0)
		Part.Mesh.Scale = (Part.Size * 2)
		Part.Mesh.VertexColor = v
		Part.Light.Color = Color3.new(v.X, v.Y, v.Z)
		Part.Parent = RainbowModel
	end
	local RainbowBoundingBox = BasePart:Clone()
	RainbowBoundingBox.Name = "BoundingBox"
	RainbowBoundingBox.Transparency = 1
	RainbowBoundingBox.Size = RainbowModel:GetModelSize()
	RainbowBoundingBox.Anchored = true
	RainbowBoundingBox.CanCollide = false
	RainbowBoundingBox.CFrame = RainbowModel:GetModelCFrame()
	RainbowBoundingBox.Parent = RainbowModel
	return RainbowModel
end

function GetRainbowModel()
	local ModelName = (Player.Name .. "'s Rainbow")
	local Model = game:GetService("Workspace"):FindFirstChild(ModelName)
	if not Model then
		Model = Instance.new("Model")
		Model.Name = ModelName
		local RemovalMonitorClone = RemovalMonitor:Clone()
		RemovalMonitorClone.Disabled = false
		RemovalMonitorClone.Parent = Model
	end
	return Model
end

function CheckIfAlive()
	return (((Character and Character.Parent and Humanoid and Humanoid.Parent and Humanoid.Health > 0 and Torso and Torso.Parent and Player and Player.Parent) and true) or false)
end

function Activated()
	if not Tool.Enabled then
		return
	end
	Tool.Enabled = false
	Flying = not Flying
	if Flying then
		Handle.Transparency = 1
		CleanUp()
		local CarpetParts = {}
		for i, v in pairs(CarpetPieces) do
			local CarpetPart = BasePart:Clone()
			CarpetPart.Size = Vector3.new(CarpetSize.X, CarpetSize.Y, (CarpetSize.Z / #CarpetPieces))
			local Mesh = Instance.new("SpecialMesh")
			Mesh.MeshType = Enum.MeshType.FileMesh
			Mesh.MeshId = (BaseUrl .. v.MeshId)
			Mesh.TextureId = (BaseUrl .. "223080038")
			Mesh.Scale = Vector3.new(1.125, 1.125, 1.125)
			Mesh.VertexColor = Vector3.new(1, 1, 1)
			Mesh.Offset = Vector3.new(0, 0, 0)
			Mesh.Parent = CarpetPart
			local Weld = Instance.new("Weld")
			Weld.Part0 = Handle
			Weld.Part1 = CarpetPart
			local XOffset = (((i == 1 or i == #CarpetPieces) and -0.005) or 0)
			local YOffset = ((-((Handle.Size.Z / 2) - (CarpetPart.Size.Z / 2))) + ((CarpetPart.Size.Z * (i - 1))) + ((i == 2 and 0.245) or (i == 3 and 0.04) or (i == #CarpetPieces and 0.28) or 0))
			Weld.C1 = CFrame.new(0, XOffset, YOffset)
			Weld.Parent = CarpetPart
			table.insert(CarpetParts, {Part = CarpetPart, Weld = Weld, InitialCFrame = Weld.C0, Angle = v.Angle})
			CarpetPart.Parent = Tool
		end

		Spawn(function()
			local animname = "Sit"
			if Humanoid and Humanoid.RigType == Enum.HumanoidRigType.R15 then
				animname = animname.."R15"
			end
			InvokeClient("PlayAnimation", Animations[animname])
			Tool.Grip = Grips.Flying
		end)

		FlightSpin = Instance.new("BodyGyro")
		FlightSpin.Name = "FlightSpin"
		FlightSpin.P = 1000000
		FlightSpin.maxTorque = Vector3.new(FlightSpin.P, FlightSpin.P, FlightSpin.P)
		FlightSpin.cframe = Torso.CFrame

		FlightPower = Instance.new("BodyVelocity")
		FlightPower.Name = "FlightPower"
		FlightPower.velocity = Vector3.new(0, 0, 0)
		FlightPower.P = 1000000
		FlightPower.maxForce = Vector3.new(FlightPower.P, FlightPower.P, FlightPower.P)
		FlightPower.P = 10000

		FlightHold = Instance.new("BodyPosition")
		FlightHold.Name = "FlightHold"
		FlightHold.P = 100000
		FlightHold.maxForce = Vector3.new(0, 0, 0)
		FlightHold.position = Torso.Position

		FlightSpin.Parent = Torso
		FlightPower.Parent = Torso
		FlightHold.Parent = Torso

		Spawn(function()
			local LastPlace = nil
			while Flying and ToolEquipped and CheckIfAlive() do

				local CurrentPlace = Handle.Position
				local Velocity = Torso.Velocity
				Velocity = Vector3.new(Velocity.X, 0, Velocity.Z).magnitude

				if LastPlace and Velocity > 10 then

					Spawn(function()
						local Model = GetRainbowModel()
						local Distance = (LastPlace - CurrentPlace).magnitude
						local Length = Distance + 3.5

						local RainbowModel = CreateRainbow(Length)

						--Thanks so much to ArceusInator for helping solve this part!
						local RainbowCFrame = CFrame.new((LastPlace + (CurrentPlace - LastPlace).unit * (Distance / 2)), CurrentPlace)

						TransformModel(RainbowModel, RainbowModel:GetModelCFrame(), RainbowCFrame, true)
						Debris:AddItem(RainbowModel, 1)
						RainbowModel.Parent = Model

						if Model and not Model.Parent then
							Model.Parent = game:GetService("Workspace")
						end

						LastPlace = CurrentPlace
					end)
				elseif not LastPlace then
					LastPlace = CurrentPlace
				end

				wait(Rate)
			end
		end)
	elseif not Flying then
		Torso.Velocity = Vector3.new(0, 0, 0)
		Torso.RotVelocity = Vector3.new(0, 0, 0)

		for i, v in pairs({FlightSpin, FlightPower, FlightHold}) do
			if v and v.Parent then
				v:Destroy()
			end
		end
		Spawn(function()
			Tool.Grip = Grips.Normal
			local animname = "Sit"
			if Humanoid and Humanoid.RigType == Enum.HumanoidRigType.R15 then
				animname = animname.."R15"
			end
			InvokeClient("StopAnimation", Animations[animname])
		end)
	end

	wait(2)

	Tool.Enabled = true
end

function Equipped(Mouse)
	Character = Tool.Parent
	Humanoid = Character:FindFirstChild("Humanoid")
	Torso = Character:FindFirstChild("Torso") or Character:FindFirstChild("UpperTorso")
	Player = Players:GetPlayerFromCharacter(Character)
	if not CheckIfAlive() then
		return
	end
	Tool.Grip = Grips.Normal
	ToolEquipped = true
end

function Unequipped()
	Flying = false
	for i, v in pairs({FlightSpin, FlightPower, FlightHold}) do
		if v and v.Parent then
			v:Destroy()
		end
	end
	CleanUp()
	Handle.Transparency = 0
	ToolEquipped = false
end

function OnServerInvoke(player, mode, value)
	if player ~= Player or not ToolEquipped or not value or not CheckIfAlive() then
		return
	end
end

function InvokeClient(Mode, Value)
	local ClientReturn = nil
	pcall(function()
		ClientReturn = ClientControl:InvokeClient(Player, Mode, Value)
	end)
	return ClientReturn
end

CleanUp()

ServerControl.OnServerInvoke = OnServerInvoke

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


Prompt: --// Processing

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 UIFolder = client.UIFolder

	local script = script

	local service = Vargs.Service
	local client = Vargs.Client

	local GetEnv = env.GetEnv

	local Anti, Core, Functions, Process, Remote, UI, Variables, Deps
	local CloneTable, TrackTask
	local function Init()
		UI = client.UI;
		Anti = client.Anti;
		Core = client.Core;
		Variables = client.Variables
		Functions = client.Functions;
		Process = client.Process;
		Remote = client.Remote;
		Deps = client.Deps;

		CloneTable = service.CloneTable;
		TrackTask = service.TrackTask;

		UI.Init = 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)--]]
		UI.DefaultTheme = Remote.Get("Setting","DefaultTheme");
		UI.RunLast = nil;
	end

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

	client.UI = {
		Init = Init;
		RunLast = RunLast;
		GetHolder = function()
			if UI.Holder and UI.Holder.Parent == service.PlayerGui then
				return UI.Holder
			else
				pcall(function()if UI.Holder then UI.Holder:Destroy()end end)
				local new = service.New("ScreenGui", {
					Name = Functions.GetRandom(),
					Parent = service.PlayerGui,
				});
				UI.Holder = new
				return UI.Holder
			end
		end;

		Prepare = function(gui)
			if true then return gui end	--// Disabled

			local gTable = UI.Get(gui,false,true)
			if gui:IsA("ScreenGui") or gui:IsA("GuiMain") then
				local new = Instance.new("TextLabel")
				new.BackgroundTransparency = 1
				new.Size = UDim2.new(1,0,1,0)
				new.Name = gui.Name
				new.Active = true
				new.Text = ""

				for ind,child in gui:GetChildren() do
					child.Parent = new
				end

				if gTable then
					gTable:Register(new)
				end

				gui:Destroy()

				return new
			else
				return gui
			end
		end;

		LoadModule = function(module, data, env)
			data = data or {}

			local ran, func = pcall(require, module)
			local newEnv = GetEnv(env, {
				script = module,
				client = CloneTable(client),
				service = CloneTable(service)
			})

			if newEnv.service.Threads then
				newEnv.service.Threads = CloneTable(service.Threads)
			end

			for i,v in newEnv.client do
				if type(v) == "table" and i ~= "Variables" and i ~= "Handlers" then
					newEnv.client[i] = CloneTable(v)
				end
			end

			if ran then
				--// Temporarily disabled NoEnv; it seems to be causing some issues(?)
				--// ~ Expertcoderz

				--[[if (data.isModifier and not data.modNoEnv) or (not data.isModifier and data.isCode and not data.NoEnv) then
					setfenv(func, env)
				end]]

				local rets = {
					TrackTask(`UI: {module:GetFullName()}`,
						--func,
						setfenv(func, newEnv),
						data,
						newEnv
					)
				}

				if rets[1] then
					return unpack(rets, 2)
				else
					warn("Error while running module", module.Name, rets[2])
					client.LogError(`Error loading {module.Name} - {rets[2]}`)
				end
			else
				warn("Error while loading module", module.Name, tostring(func))
			end
		end;

		GetNew = function(theme, name)
			local foundConfigs = {}
			local endConfig = {}
			local endConfValues = {}

			local confFolder = Instance.new("Folder")
			local debounce = false

			local function func(theme, name, depth)
				local depth = (depth or 11) - 1

				local folder = UIFolder:FindFirstChild(theme) or UIFolder.Default
				if folder then
					local baseValue = folder:FindFirstChild("Base_Theme")
					local baseTheme = baseValue and baseValue.Value
					local foundGUI = folder:FindFirstChild(name) --local foundGUI = (baseValue and folder:FindFirstChild(name)) or UIFolder.Default:FindFirstChild(name)

					if foundGUI then
						local config = foundGUI:FindFirstChild("Config")
						table.insert(foundConfigs, {
							Theme = theme;
							Folder = folder;
							Name = name;
							Found = foundGUI;
							Config = config;
							isModule = foundGUI:IsA("ModuleScript");
						})

						if config then
							baseValue = config:FindFirstChild("BaseTheme") or baseValue
							baseTheme = baseValue and baseValue.Value
						end
					end
					if baseTheme and depth > 0 then
						if UI.DefaultTheme and baseTheme == "Default" and theme ~= UI.DefaultTheme and not debounce then
							func(UI.DefaultTheme, name, depth)
						else
							debounce = true
							func(baseTheme, name, depth)
						end
					end
				end
			end

			--// Find GUI and all default versions under it
			func(theme, name)
			confFolder.Name = "Config"

			--// Create the final config for the found GUI.

			if #foundConfigs > 0 then
				--// Combine all configs found in order  to build full config (in order of closest from target gui to furthest)
				for i,v in foundConfigs do
					if v.Config then
						for k,m in v.Config:GetChildren() do
							if not endConfig[m.Name] then
								if string.sub(m.Name, 1, 5) == "NoEnv" then
									endConfig["Code"] = m
								end

								endConfig[m.Name] = m
							end
						end
					end
				end

				--// Load all config values into the new Config folder
				for i,v in endConfig do
					v:Clone().Parent = confFolder;
				end

				--// Find next module based theme GUI if code not found or first in sequence is module (in theme)
				if foundConfigs[1].isModule then
					return foundConfigs[1].Found, foundConfigs[1].Folder, confFolder
				elseif not endConfig.Code then
					warn("Window config missing code.lua. Are your Base_Themes correct? client.UI.GetNew line 236")
				end

				--// Get rid of an old Config folder and throw the new combination Config folder in
				local new = foundConfigs[1].Found:Clone()
				local oldFolder = new:FindFirstChild'Config'

				if oldFolder then oldFolder:Destroy() end

				confFolder.Parent = new
				return new, foundConfigs[1].Folder, confFolder
			end
		end;

		Make = function(name, data, themeData)
			data = data or {}
			themeData = themeData or Variables.LastServerTheme or {Desktop = "Default"; Mobile = "Mobilius"}

			local theme = Variables.CustomTheme or (service.IsMobile() and themeData.Mobile) or themeData.Desktop
			local folder = UIFolder:FindFirstChild(theme) or UIFolder.Default

			--// Check for any childs with 'NoEnv' and trigger NoEnv
			--// Enforce NoEnv to ensure theme is using it.
			if not data.NoEnv and folder:FindFirstChild("NoEnv") then
				data.NoEnv = true
				data.modNoEnv = true
			end

			--// folder2
			local newGui, _, foundConf = UI.GetNew(theme, name)

			if newGui then
				local isModule = newGui:IsA("ModuleScript")
				local conf = newGui:FindFirstChild("Config")
				local mod = conf and (conf:FindFirstChild("Modifier") or conf:FindFirstChild("NoEnv-Modifier"))

				if mod and not data.modNoEnv then
					data.modNoEnv = string.sub(mod.Name, 1, 5) == "NoEnv"
				end

				if isModule then
					return UI.LoadModule(newGui, data, {
						script = newGui;
					})
				elseif conf and foundConf and foundConf ~= true then
					local code = foundConf:FindFirstChild("Code") or foundConf:FindFirstChild("NoEnv-Code")

					if not data.NoEnv and code then
						data.NoEnv = string.sub(code.Name, 1, 5) == "NoEnv"
					end

					local mult = foundConf.AllowMultiple
					--local keep = foundConf.CanKeepAlive

					local allowMult = mult and mult.Value or true
					local found, num = UI.Get(name)

					if not found or ((num and num>0) and allowMult) then
						local gTable,gIndex = UI.Register(newGui)

						if folder:IsA("ModuleScript") then
							local folderNoEnv = string.sub(folder.Name, 1, 5) == "NoEnv" or folder:FindFirstChild("NoEnv")

							local newEnv = GetEnv{{
								script = folder,
								gTable = gTable
							}}

							local ran, func = pcall(require, folder)
							local rets = {
								--// NoEnv temporarily disabled ~ Expertcoderz
								--[[if folderNoEnv then pcall(func, newGui, gTable, data, newEnv) else]] pcall(setfenv(func, newEnv), newGui, gTable, data, newEnv)
							}

							local ran, ret = rets[1], rets[2]
							if ret ~= nil then
								if type(ret) == "userdata" and Anti.GetClassName(ret) == "ScreenGui" then
									code = (ret:FindFirstChild("Config") and (ret.Config:FindFirstChild("Code") or ret.Config:FindFirstChild("NoEnv-Code"))) or code

									if not data.NoEnv and code then
										data.NoEnv = string.sub(code.Name, 1, 5) == "NoEnv"
									end
								else
									return ret
								end
							end
						end

						newGui.Parent = Variables.GUIHolder
						newGui.Name = Functions.GetRandom()

						data.gIndex = gIndex
						data.gTable = gTable

						code.Parent = conf
						code.Name = name

						if mod then
							UI.LoadModule(mod, data, {
								script = mod;
								gTable = gTable;
								Data = data;
								GUI = newGui;
								isModifier = true;
							})
						end

						return UI.LoadModule(code, data, {
							script = code;
							gTable = gTable;
							Data = data;
							GUI = newGui;
							Theme = theme;
							ThemeFolder = folder;
							isCode = true;
						})
					end
				end
			else
				print("GUI", name, "not found")
			end
		end;

		Get = function(obj,ignore,returnOne)
			local found = {}
			local num = 0
			if obj then
				for ind,g in client.GUIs do
					if g.Name ~= ignore and g.Object ~= ignore and g ~= ignore then
						if type(obj) == "string" then
							if g.Name == obj then
								found[ind] = g
								num = num+1
								if returnOne then return g end
							end
						elseif type(obj) == "userdata" then
							if service.RawEqual(g.Object, obj) then
								found[ind] = g
								num = num+1
								if returnOne then return g end
							end
						elseif type(obj) == "boolean" and obj == true then
							found[ind] = g
							num = num+1
							if returnOne then return g end
						end
					end
				end
			end
			if num<1 then
				return false
			else
				return found,num
			end
		end;

		Remove = function(name, ignore)
			if name == "Chat" and client.Handlers.RemoveCustomChat then
				client.Handlers.RemoveCustomChat()
			else
				local gui = UI.Get(name, ignore)
				if gui then
					for i,v in gui do
						v.Destroy()
					end
				end
			end
		end;

		Register = function(gui, data)
			local gIndex = Functions.GetRandom()
			local gTable;gTable = {
				Object = gui,
				Config = gui:FindFirstChild'Config';
				Name = gui.Name,
				Events = {},
				Class = gui.ClassName,
				Index = gIndex,
				Active = true,
				Ready = function()
					if gTable.Config then gTable.Config.Parent = nil end
					local ran,err = pcall(function()
						local obj = gTable.Object;
						if gTable.Class == "ScreenGui" or gTable.Class == "GuiMain" then
							if obj.DisplayOrder == 0 then
								obj.DisplayOrder = 90000
							end

							obj.Enabled = true
							obj.Parent = service.PlayerGui
						else
							obj.Parent = UI.GetHolder()
						end
					end);

					if ran then
						gTable.Active = true
					else
						warn("Something happened while trying to set the parent of", gTable.Name)
						warn(err)

						gTable:Destroy()
					end
				end,

				BindEvent = function(event, func)
					local signal = event:Connect(func)
					local origDisc = signal.Disconnect
					local Events = gTable.Events
					local disc = function()
						origDisc(signal)
						for i,v in Events do
							if v.Signal == signal then
								table.remove(Events, i)
							end
						end
					end

					table.insert(Events, {
						Signal = signal;
						Remove = disc
					})

					return {
						Disconnect = disc;
						disconnect = disc;
						wait = service.CheckProperty(signal, "wait") and signal.wait
					}, signal
				end,

				ClearEvents = function()
					for i,v in gTable.Events do
						v:Remove()
					end
				end,

				Destroy = function()
					pcall(function()
						if gTable.CustomDestroy then
							gTable.CustomDestroy()
						else
							service.UnWrap(gTable.Object):Destroy()
						end
					end)
					gTable.Destroyed = true
					gTable.Active = false
					client.GUIs[gIndex] = nil
					gTable.ClearEvents()
				end,

				UnRegister = function()
					client.GUIs[gIndex] = nil
					if gTable.AncestryEvent then
						gTable.AncestryEvent:Disconnect()
					end
				end,

				Register = function(tab,new)
					if not new then new = tab end

					new:SetSpecial("Destroy", gTable.Destroy)
					gTable.Object = service.Wrap(new)
					gTable.Class = new.ClassName

					if gTable.AncestryEvent then
						gTable.AncestryEvent:Disconnect()
					end

					gTable.AncestryEvent = new.AncestryChanged:Connect(function(c, parent)
						if client.GUIs[gIndex] and rawequal(c, gTable.Object) then
							if gTable.Class == "TextLabel" and parent == service.PlayerGui then
								task.wait()
								gTable.Object.Parent = UI.GetHolder()
							elseif parent == nil and not gTable.KeepAlive then
								gTable:Destroy()
							elseif parent ~= nil then
								gTable.Active = true
								client.GUIs[gIndex] = gTable
							end
						end
					end)
					client.GUIs[gIndex] = gTable
				end
			}

			if data then
				for i,v in data do
					gTable[i] = v
				end
			end

			gui.Name = Functions.GetRandom()
			gTable:Register(gui)

			return gTable,gIndex
		end
	}

	client.UI.RegisterGui = client.UI.Register
	client.UI.GetGui = client.UI.Get
	client.UI.PrepareGui = client.UI.Prepare
	client.UI.MakeGui = client.UI.Make
end


Prompt: --!strict

Response:
local events = require(script.events)
local install = require(script.install)

local DevModuleInstaller: { [string]: any } = {
	verboseLogging = false,
	pruneDevelopmentFiles = true,

	started = events.started.Event,
	finished = events.finished.Event,
}

function DevModuleInstaller.install(devModule: Folder)
	return install(devModule, {
		verboseLogging = DevModuleInstaller.verboseLogging,
		pruneDevelopmentFiles = DevModuleInstaller.pruneDevelopmentFiles,
	})
end

return DevModuleInstaller


Prompt: --Change the color of the brush when the text box is used

Response:
brushSettings.ColorBox.FocusLost:Connect(function(entered)

	if entered then

		local color = brushSettings.ColorBox.Text
		color = string.gsub(color, " ", "")
		color = string.split(color, ",")

		if tonumber(color[1]) and tonumber(color[2]) and tonumber(color[3]) then

			currentColor = Color3.fromRGB(color[1], color[2], color[3])
		end

		brushSettings.ColorBox.Text = math.floor(currentColor.R * 255 + 0.5) .. ", " .. math.floor(currentColor.G * 255 + 0.5) .. ", " .. math.floor(currentColor.B * 255 + 0.5)

		brushSettings.PaintImage.ImageColor3 = currentColor
	end
end)


Prompt: --// Tracer Vars

Response:
	TracerTransparency = 0;
	TracerLightEmission = 1;
	TracerTextureLength = 0.1;
	TracerLifetime = 0.0005;
	TracerFaceCamera = true;
	TracerColor = BrickColor.new('White');


Prompt:
-- This script is what allows the Shop by UltraWorks to increment player's
-- statistics according to the settings from the editor plugin.
-- If you change something, almost 100% this script will break.


Prompt: --Audio

Response:
local soundBank =  game.ServerStorage.Sounds.NPC.Banto:GetChildren()
banto.Health.Changed:connect(function()
    local hitSound = soundBank[math.random(1,#soundBank)]:Clone()
    hitSound.Parent = banto.PrimaryPart
    hitSound.PlayOnRemove = true
    wait()
    hitSound:Destroy()
end)

while true do
    bp.Parent = banto.PrimaryPart
    local goal
    repeat
    local ray = Ray.new(Vector3.new(origin.p.x+math.random(-tether,tether), banto.PrimaryPart.Position.Y+100, origin.p.z+math.random(-tether,tether)),Vector3.new(0,-130,0))
    local part,pos,norm,mat = workspace:FindPartOnRay(ray,banto)
    if part == workspace.Terrain and mat ~= Enum.Material.Water then
        goal = pos+Vector3.new(0,2.25,0)
    end
    wait()
    until goal
    --Set new goal for banto to MoveTo :)
    walk:Play()
    local pos = banto.PrimaryPart.Position
    local cf = CFrame.new(Vector3.new(pos.X, 0, pos.Z), Vector3.new(goal.X, 0, goal.Z))
    bg.CFrame = cf
    bp.Position = (cf*CFrame.new(0,0,-100)).p

    local start = tick()
    repeat task.wait(.5)
    local ray = Ray.new(banto.PrimaryPart.Position, Vector3.new(0,-140,0))

    until (banto.PrimaryPart.Position-goal).magnitude < 10 or tick()-start >10
    walk:Stop()
    bp.Parent = nil
    wait(math.random(3,8))
end


Prompt: --Rescripted by Luckymaxer

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

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

Player = Players:GetPlayerFromCharacter(Character)

Creator = script:FindFirstChild("Creator")

BaseColor = BrickColor.new("Really black")
DarkProperties = {
	All = {
		--BrickColor = BaseColor,
		Material = Enum.Material.Plastic,
		TextureId = "",
		--Texture = "",
		VertexColor = Vector3.new(BaseColor.Color.r, BaseColor.Color.g, BaseColor.Color.b),
		BaseTextureId = 0,
		OverlayTextureId = 0,
		ShirtTemplate = "",
		PantsTemplate = "",
		SparkleColor = BaseColor.Color,
		Color = BaseColor.Color,
		SecondaryColor = BaseColor.Color,
	},
	Class = {
		ParticleEmitter = {
			Color = ColorSequence.new(BaseColor.Color, BaseColor.Color),
		},
		Sparkles = {
			Color = BaseColor.Color,
			SparkleColor = BaseColor.Color,
		},
		Decal = {
			Texture = "",
		},
	}
}

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

function TagHumanoid(humanoid, player)
	local Creator_Tag = 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 GetAllInstances(Parent)
	local Instances = {}
	local function GetInstances(Parent)
		for i, v in pairs(Parent:GetChildren()) do
			table.insert(Instances, v)
			GetInstances(v)
		end
	end
	GetInstances(Parent)
	return Instances
end

function DarkEffect()

	UntagHumanoid(Humanoid)
	if Creator and Creator.Value and Creator.Value:IsA("Player") then
		TagHumanoid(Humanoid, Creator.Value)
	end
	Humanoid.Health = 0
	Character:BreakJoints()

	local EffectedInstances = GetAllInstances(Character)
	local OriginalInstances = {}
	for i, v in pairs(EffectedInstances) do
		local Instance = {Object = v, Properties = {}}
		local PropertiesAltered = {}
		if v:IsA("Hat") or v:IsA("Tool") then
			for ii, vv in pairs(v:GetChildren()) do
				if vv:IsA("BasePart") then
					vv.Parent = v.Parent
				end
			end
			v:Destroy()
		elseif v:IsA("BasePart") then
			v.CanCollide = true
			v.Anchored = true
			Debris:AddItem(v, 10)
		end
		if v:IsA("BasePart") and v.Name == "HumanoidRootPart" then
		elseif v:IsA("Decal") and v.Name == "face" then
		elseif v:IsA("Clothing") then
			v:Destroy()
		else
			for ii, vv in pairs(DarkProperties.All) do
				pcall(function()
					Instance.Properties[ii] = v[ii]
					PropertiesAltered[ii] = true
					v[ii] = vv
				end)
			end
			for ii, vv in pairs(DarkProperties.Class) do
				if v:IsA(ii) then
					for iii, vvv in pairs(vv) do
						--if not PropertiesAltered[iii] then
							pcall(function()
								Instance.Properties[iii] = v[iii]
								v[iii] = vvv
							end)
						--end
					end
				end
			end
		end
		table.insert(OriginalInstances, Instance)
	end

	wait(0.25)

	for i, v in pairs(EffectedInstances) do
		if v:IsA("BasePart") then
			local BodyVelocity = Instance.new("BodyVelocity")
			BodyVelocity.velocity = (Vector3.new((math.random() - 0.5), 0, (math.random() - 0.5)).Unit * 80)
			BodyVelocity.maxForce = Vector3.new(100000, 100000, 100000)
			BodyVelocity.Parent = v
			v.Anchored = false
		end
	end

end

DarkEffect()

script:Destroy()


Prompt: -- Gradually regenerates the Humanoid's Health over time.

Response:
local REGEN_RATE = 1/200 -- Regenerate this fraction of MaxHealth per second.
local REGEN_STEP = 1 -- Wait this long between each regeneration step.


Prompt: -- Set up the event handlers for the TextButton icons in the gui.Main frame

Response:
local buttons = openGui:GetChildren()
for _, button in ipairs(buttons) do
	if button:IsA("TextButton") then
		button.MouseButton1Click:Connect(function()
			openGui.Visible = false
			toggleWindow(button)
		end)
	end
end


Prompt:
-- ROBLOX deviation: currently no way – type the __call metamethod
-- {
--   __call: (any, any, any?) -> ExpectationResult,
-- -- ROBLOX deviation: [INTERNAL_MATCHER_FLAG]: boolean?
--   [Symbol]: boolean?
-- }

Response:
export type ThrowingMatcherFn = (any) -> ()
export type PromiseMatcherFn = (any) -> Promise<nil>

export type Tester = (any, any) -> boolean?

export type MatcherState = {
	assertionCalls: number,
	currentTestName: string?,
	dontThrow: (() -> ())?,
	error: Error?,
	equals: (any, any, Array<Tester>?, boolean?) -> boolean,
	expand: boolean?,
	expectedAssertionsNumber: number?,
	expectedAssertionsNumberError: Error?,
	isExpectingAssertions: boolean?,
	isExpectingAssertionsError: Error?,
	isNot: boolean,
	promise: string,
	suppressedErrors: Array<Error>,
	testPath: any, -- ROBLOX TODO: Config.Path?,
	utils: Object, -- ROBLOX deviation: no easy way to port to Lua: typeof jestMatcherUtils & {
	--   iterableEquality: Tester;
	--   subsetEquality: Tester;
	-- }
}

export type AsymmetricMatcher = {
	asymmetricMatch: (self: AsymmetricMatcher, other: unknown) -> boolean,
	toString: (self: AsymmetricMatcher) -> string,
	getExpectedType: ((self: AsymmetricMatcher) -> string)?,
	toAsymmetricMatcher: ((self: AsymmetricMatcher) -> string)?,
}


Prompt: -- Recursive table copy.

Response:
function Util.DeepCopy(tbl: AnyTable): AnyTable
	local newTbl = table.clone(tbl)
	for k, v in pairs(newTbl) do
		if type(v) == "table" then
			newTbl[k] = Util.DeepCopy(v)
		end
	end
	return newTbl
end


Prompt:
--[[

	VectorUtil.ClampMagnitude(vector, maxMagnitude)
	VectorUtil.AngleBetween(vector1, vector2)
	VectorUtil.AngleBetweenSigned(vector1, vector2, axisVector)

	EXAMPLES:

		ClampMagnitude:

			Clamps the magnitude of a vector so it is only a certain length.

			ClampMagnitude(Vector3.new(100, 0, 0), 15) == Vector3.new(15, 0, 0)
			ClampMagnitude(Vector3.new(10, 0, 0), 20)  == Vector3.new(10, 0, 0)

		AngleBetween:

			Finds the angle (in radians) between two vectors.

			v1 = Vector3.new(10, 0, 0)
			v2 = Vector3.new(0, 10, 0)
			AngleBetween(v1, v2) == math.rad(90)

		AngleBetweenSigned:

			Same as AngleBetween, but returns a signed value.

			v1 = Vector3.new(10, 0, 0)
			v2 = Vector3.new(0, 0, -10)
			axis = Vector3.new(0, 1, 0)
			AngleBetweenSigned(v1, v2, axis) == math.rad(90)

--]]

Response:
local VectorUtil = {}

function VectorUtil.ClampMagnitude(vector, maxMagnitude)
	return (vector.Magnitude > maxMagnitude and (vector.Unit * maxMagnitude) or vector)
end

function VectorUtil.AngleBetween(vector1, vector2)
	return math.acos(math.clamp(vector1.Unit:Dot(vector2.Unit), -1, 1))
end

function VectorUtil.AngleBetweenSigned(vector1, vector2, axisVector)
	local angle = VectorUtil.AngleBetween(vector1, vector2)
	return angle * math.sign(axisVector:Dot(vector1:Cross(vector2)))
end

return VectorUtil


Prompt:
--[=[
	Extracts the locale from the folder, or a locale and table.
	@param first Instance | string
	@param second table?
	@return LocalizationTable
]=]

Response:
function JsonToLocalizationTable.toLocalizationTable(first, second)
	if typeof(first) == "Instance" then
		local result = JsonToLocalizationTable.loadFolder(first)
		-- result.Name = ("JSONTable_%s"):format(first.Name)
		return result
	elseif type(first) == "string" and type(second) == "table" then
		local result = JsonToLocalizationTable.loadTable(first, second)
		return result
	else
		error("Bad args")
	end
end


Prompt:
--[=[
	@param fn ConnectionFn
	@return SignalConnection

	Connects a function to the signal, which will be called the next time the signal fires. Once
	the connection is triggered, it will disconnect itself.
	```lua
	signal:Once(function(msg, num)
		print(msg, num)
	end)

	signal:Fire("Hello", 25)
	signal:Fire("This message will not go through", 10)
	```
]=]

Response:
function Signal:Once(fn)
	local connection
	local done = false
	connection = self:Connect(function(...)
		if done then
			return
		end
		done = true
		connection:Disconnect()
		fn(...)
	end)
	return connection
end

function Signal:GetConnections()
	local items = {}
	local item = self._handlerListHead
	while item do
		table.insert(items, item)
		item = item._next
	end
	return items
end


Prompt: --StrobeFunctions-----------------------------------------

Response:
script.Parent.Configuration.Strobe.Changed:connect(function()
while script.Parent.Configuration.Strobe.Value == 1 do
		wait(0.01)
colorval = script.Parent.Configuration.Colour.Value
Model.Configuration.LampStatus.Value = 0
for i,v in pairs(Model.Tilt:GetChildren()) do
		if v.Name == "Lamp" then
			v.BrickColor = BrickColor.new(Color3.new(35/255,35/255,35/255))
		end

end
wait(0.01)

Model.Configuration.LampStatus.Value = 1
for i,v in pairs(Model.Tilt:GetChildren()) do
		if v.Name == "Lamp" then
			v.BrickColor = BrickColor.new(colorval)
		end

end

end

while script.Parent.Configuration.Strobe.Value == 2 do
		wait(0.05)
colorval = script.Parent.Configuration.Colour.Value
Model.Configuration.LampStatus.Value = 0
for i,v in pairs(Model.Tilt:GetChildren()) do
		if v.Name == "Lamp" then
			v.BrickColor = BrickColor.new(Color3.new(35/255,35/255,35/255))
		end

end
wait(0.05)

Model.Configuration.LampStatus.Value = 1
for i,v in pairs(Model.Tilt:GetChildren()) do
		if v.Name == "Lamp" then
			v.BrickColor = BrickColor.new(colorval)
		end

end

end

while script.Parent.Configuration.Strobe.Value == 3 do
		wait(1)
colorval = script.Parent.Configuration.Colour.Value
Model.Configuration.LampStatus.Value = 0
for i,v in pairs(Model.Tilt:GetChildren()) do
		if v.Name == "Lamp" then
			v.BrickColor = BrickColor.new(Color3.new(35/255,35/255,35/255))
		end

end
wait(1)

Model.Configuration.LampStatus.Value = 1
for i,v in pairs(Model.Tilt:GetChildren()) do
		if v.Name == "Lamp" then
			v.BrickColor = BrickColor.new(colorval)
		end

end

end

while script.Parent.Configuration.Strobe.Value == 4 do
		wait(math.random())
colorval = script.Parent.Configuration.Colour.Value

Model.Configuration.LampStatus.Value = 0
for i,v in pairs(Model.Tilt:GetChildren()) do
		if v.Name == "Lamp" then
			v.BrickColor = BrickColor.new(Color3.new(35/255,35/255,35/255))
		end

end
wait(math.random())

Model.Configuration.LampStatus.Value = 1
for i,v in pairs(Model.Tilt:GetChildren()) do
		if v.Name == "Lamp" then
			v.BrickColor = BrickColor.new(colorval)

		end

end

end

end)


Prompt: -- map a value from one range to another

Response:
local function map(x, inMin, inMax, outMin, outMax)
	return (x - inMin)*(outMax - outMin)/(inMax - inMin) + outMin
end

local function playSound(sound)
	sound.TimePosition = 0
	sound.Playing = true
end

local function stopSound(sound)
	sound.Playing = false
	sound.TimePosition = 0
end

local function initializeSoundSystem(player, humanoid, rootPart)
	local sounds = {}

	-- initialize sounds
	for name, props in pairs(SOUND_DATA) do
		local sound = Instance.new("Sound")
		sound.Name = name

		-- set default values
		sound.Archivable = false
		sound.EmitterSize = 5
		sound.MaxDistance = 150
		sound.Volume = 0.65

		for propName, propValue in pairs(props) do
			sound[propName] = propValue
		end

		sound.Parent = rootPart
		sounds[name] = sound
	end

	local playingLoopedSounds = {}

	local function stopPlayingLoopedSounds(except)
		for sound in pairs(playingLoopedSounds) do
			if sound ~= except then
				sound.Playing = false
				playingLoopedSounds[sound] = nil
			end
		end
	end

	-- state transition callbacks
	local stateTransitions = {
		[Enum.HumanoidStateType.FallingDown] = function()
			stopPlayingLoopedSounds()
		end,

		[Enum.HumanoidStateType.GettingUp] = function()
			stopPlayingLoopedSounds()
			playSound(sounds.GettingUp)
		end,

		[Enum.HumanoidStateType.Jumping] = function()
			stopPlayingLoopedSounds()
			playSound(sounds.Jumping)
		end,

		[Enum.HumanoidStateType.Swimming] = function()
			local verticalSpeed = math.abs(rootPart.Velocity.Y)
			if verticalSpeed > 0.1 then
				sounds.Splash.Volume = math.clamp(map(verticalSpeed, 100, 350, 0.28, 1), 0, 1)
				playSound(sounds.Splash)
			end
			stopPlayingLoopedSounds(sounds.Swimming)
			sounds.Swimming.Playing = true
			playingLoopedSounds[sounds.Swimming] = true
		end,

		[Enum.HumanoidStateType.Freefall] = function()
			sounds.FreeFalling.Volume = 0
			stopPlayingLoopedSounds(sounds.FreeFalling)
			playingLoopedSounds[sounds.FreeFalling] = true
		end,

		[Enum.HumanoidStateType.Landed] = function()
			stopPlayingLoopedSounds()
			local verticalSpeed = math.abs(rootPart.Velocity.Y)
			if verticalSpeed > 75 then
				sounds.Landing.Volume = math.clamp(map(verticalSpeed, 50, 100, 0, 1), 0, 1)
				playSound(sounds.Landing)
			end
		end,

		[Enum.HumanoidStateType.Running] = function()
			stopPlayingLoopedSounds(sounds.Running)
			sounds.Running.Playing = true
			playingLoopedSounds[sounds.Running] = true
		end,

		[Enum.HumanoidStateType.Climbing] = function()
			local sound = sounds.Climbing
			if math.abs(rootPart.Velocity.Y) > 0.1 then
				sound.Playing = true
				stopPlayingLoopedSounds(sound)
			else
				stopPlayingLoopedSounds()
			end
			playingLoopedSounds[sound] = true
		end,

		[Enum.HumanoidStateType.Seated] = function()
			stopPlayingLoopedSounds()
		end,

		[Enum.HumanoidStateType.Dead] = function()
			stopPlayingLoopedSounds()
			playSound(sounds.Died)
		end,
	}

	-- updaters for looped sounds
	local loopedSoundUpdaters = {
		[sounds.Climbing] = function(dt, sound, vel)
			sound.Playing = vel.Magnitude > 0.1
		end,

		[sounds.FreeFalling] = function(dt, sound, vel)
			if vel.Magnitude > 75 then
				sound.Volume = math.clamp(sound.Volume + 0.9*dt, 0, 1)
			else
				sound.Volume = 0
			end
		end,

		[sounds.Running] = function(dt, sound, vel)
		--sound.Playing = vel.Magnitude > 0.5 and humanoid.MoveDirection.Magnitude > 0.5

		sound.SoundId = FootstepsSoundGroup:WaitForChild(humanoid.FloorMaterial).SoundId
		sound.PlaybackSpeed = FootstepsSoundGroup:WaitForChild(humanoid.FloorMaterial).PlaybackSpeed * (vel.Magnitude/20)
			sound.Volume = FootstepsSoundGroup:WaitForChild(humanoid.FloorMaterial).Volume * (vel.Magnitude/12) * Players.LocalPlayer.Character:WaitForChild("ACS_Client"):WaitForChild("Stances"):WaitForChild("Loudness").Value
			sound.EmitterSize = FootstepsSoundGroup:WaitForChild(humanoid.FloorMaterial).Volume * (vel.Magnitude/12) * 50 * Players.LocalPlayer.Character:WaitForChild("ACS_Client"):WaitForChild("Stances"):WaitForChild("Loudness").Value

		if FootstepsSoundGroup:FindFirstChild(humanoid.FloorMaterial) == nil then
			sound.SoundId = FootstepsSoundGroup:WaitForChild("nil Sound").SoundId
			sound.PlaybackSpeed = FootstepsSoundGroup:WaitForChild("nil Sound").PlaybackSpeed
			sound.EmitterSize = FootstepsSoundGroup:WaitForChild("nil Sound").Volume
			sound.Volume = FootstepsSoundGroup:WaitForChild("nil Sound").Volume
		end
		end,
	}

	-- state substitutions to avoid duplicating entries in the state table
	local stateRemap = {
		[Enum.HumanoidStateType.RunningNoPhysics] = Enum.HumanoidStateType.Running,
	}

	local activeState = stateRemap[humanoid:GetState()] or humanoid:GetState()
	local activeConnections = {}

	local stateChangedConn = humanoid.StateChanged:Connect(function(_, state)
		state = stateRemap[state] or state

		if state ~= activeState then
			local transitionFunc = stateTransitions[state]

			if transitionFunc then
				transitionFunc()
			end

			activeState = state
		end
	end)

	local steppedConn = RunService.Stepped:Connect(function(_, worldDt)
		-- update looped sounds on stepped
		for sound in pairs(playingLoopedSounds) do
			local updater = loopedSoundUpdaters[sound]

			if updater then
				updater(worldDt, sound, rootPart.Velocity)
			end
		end
	end)

	local humanoidAncestryChangedConn
	local rootPartAncestryChangedConn
	local characterAddedConn

	local function terminate()
		stateChangedConn:Disconnect()
		steppedConn:Disconnect()
		humanoidAncestryChangedConn:Disconnect()
		rootPartAncestryChangedConn:Disconnect()
		characterAddedConn:Disconnect()
	end

	humanoidAncestryChangedConn = humanoid.AncestryChanged:Connect(function(_, parent)
		if not parent then
			terminate()
		end
	end)

	rootPartAncestryChangedConn = rootPart.AncestryChanged:Connect(function(_, parent)
		if not parent then
			terminate()
		end
	end)

	characterAddedConn = player.CharacterAdded:Connect(terminate)
end

local function playerAdded(player)
	local function characterAdded(character)
		-- Avoiding memory leaks in the face of Character/Humanoid/RootPart lifetime has a few complications:
		-- * character deparenting is a Remove instead of a Destroy, so signals are not cleaned up automatically.
		-- ** must use a waitForFirst on everything and listen for hierarchy changes.
		-- * the character might not be in the dm by the time CharacterAdded fires
		-- ** constantly check consistency with player.Character and abort if CharacterAdded is fired again
		-- * Humanoid may not exist immediately, and by the time it's inserted the character might be deparented.
		-- * RootPart probably won't exist immediately.
		-- ** by the time RootPart is inserted and Humanoid.RootPart is set, the character or the humanoid might be deparented.

		if not character.Parent then
			waitForFirst(character.AncestryChanged, player.CharacterAdded)
		end

		if player.Character ~= character or not character.Parent then
			return
		end

		local humanoid = character:FindFirstChildOfClass("Humanoid")
		while character:IsDescendantOf(game) and not humanoid do
			waitForFirst(character.ChildAdded, character.AncestryChanged, player.CharacterAdded)
			humanoid = character:FindFirstChildOfClass("Humanoid")
		end

		if player.Character ~= character or not character:IsDescendantOf(game) then
			return
		end

		-- must rely on HumanoidRootPart naming because Humanoid.RootPart does not fire changed signals
		local rootPart = character:FindFirstChild("HumanoidRootPart")
		while character:IsDescendantOf(game) and not rootPart do
			waitForFirst(character.ChildAdded, character.AncestryChanged, humanoid.AncestryChanged, player.CharacterAdded)
			rootPart = character:FindFirstChild("HumanoidRootPart")
		end

		if rootPart and humanoid:IsDescendantOf(game) and character:IsDescendantOf(game) and player.Character == character then
			initializeSoundSystem(player, humanoid, rootPart)
		end
	end

	if player.Character then
		characterAdded(player.Character)
	end
	player.CharacterAdded:Connect(characterAdded)
end

Players.PlayerAdded:Connect(playerAdded)
for _, player in ipairs(Players:GetPlayers()) do
	playerAdded(player)
end

repeat
	wait()
until game.Players.LocalPlayer.Character

local Character = game.Players.LocalPlayer.Character
local Head = Character:WaitForChild("HumanoidRootPart")
local RunningSound = Head:WaitForChild("Running")
local Humanoid = Character:WaitForChild("Humanoid")
local vel = 0

Humanoid.Changed:Connect(function(property)

end)

Humanoid.Running:connect(function(a)
		RunningSound.PlaybackSpeed		 	= FootstepsSoundGroup:WaitForChild(Humanoid.FloorMaterial).PlaybackSpeed * (a/20) * (math.random(30,50)/40)
		RunningSound.Volume 		= FootstepsSoundGroup:WaitForChild(Humanoid.FloorMaterial).Volume * (vel/12)
		RunningSound.EmitterSize 	= FootstepsSoundGroup:WaitForChild(Humanoid.FloorMaterial).Volume * (vel/12) * 50
		vel 						= a
end)


Prompt: --Made by Luckymaxer

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

Players = game:GetService("Players")

ServerControl = Tool:WaitForChild("ServerControl")

function InvokeServer(Mode, Value)
	pcall(function()
		ServerControl:InvokeServer(Mode, Value)
	end)
end

function Equipped(Mouse)
	Character = Tool.Parent
	Player = Players:GetPlayerFromCharacter(Character)
	Humanoid = Character:FindFirstChild("Humanoid")
	if not Player or not Humanoid or Humanoid.Health == 0 then
		return
	end
	Mouse.Button1Down:connect(function()
		InvokeServer("Click", true)
	end)
	Mouse.KeyDown:connect(function(Key)
		InvokeServer("KeyPress", {Key = Key, Down = true})
	end)
end

function Unequipped()
end

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


Prompt:
--[=[
	@class MerchBooth
]=]

Response:
local module = {
	-- Server APIs
	addItemAsync = addItemAsync(serverStore),
	removeItem = removeItem(serverStore),
	addProximityButton = addProximityButton(serverStore),
	removeProximityButton = removeProximityButton(serverStore),

	-- Client APIs
	configure = configure(clientStore),
	resetConfiguration = resetConfiguration(clientStore),
	setCatalogSort = setCatalogSort(clientStore),
	setEnabled = setEnabled(clientStore),
	setControlKeyCodes = setControlKeyCodes(clientStore),

	-- UI states functions (client only)
	openMerchBooth = uiStatesFunctions.openMerchBooth(clientStore),
	openItemView = uiStatesFunctions.openItemView(clientStore),
	closeMerchBooth = uiStatesFunctions.closeMerchBooth(clientStore),
	toggleCatalogButton = uiStatesFunctions.toggleCatalogButton(clientStore),
	isMerchBoothOpen = uiStatesFunctions.isMerchBoothOpen(clientStore),
	isMerchBoothEnabled = uiStatesFunctions.isMerchBoothEnabled(clientStore),

	-- UI states events (client only)
	merchBoothOpened = uiStatesEvents.merchBoothOpened.Event,
	merchBoothClosed = uiStatesEvents.merchBoothClosed.Event,
	catalogViewOpened = uiStatesEvents.catalogViewOpened.Event,
	catalogViewClosed = uiStatesEvents.catalogViewClosed.Event,
	itemViewOpened = uiStatesEvents.itemViewOpened.Event,
	itemViewClosed = uiStatesEvents.itemViewClosed.Event,

	-- Server and client APIs
	getItems = getItems(serverStore, clientStore),
	itemAdded = itemEvents.itemAdded.Event,
	itemRemoved = itemEvents.itemRemoved.Event,

	-- Enums
	Controls = enums.Controls,
}


Prompt: --//Settings

Response: BlurAmount = 50 -- Change this to increase or decrease the blur size


Prompt:
--[[
	Calls the given analytics function and passes the given values.
	Every analytics function sends the categoryIndex and subcategoryIndex from the store.
	assetTypeId: optional
]]

Response:
local function getUserId(state)
	if state.LocalUserId then
		return state.LocalUserId
	end

	if state.RobloxUser and state.RobloxUser.rbxuid then
		return tostring(state.RobloxUser.rbxuid)
	end

	return nil
end

return function(analyticsFunction, value, assetTypeId)
	return function(store)
		local categoryIndex = store:getState().AvatarExperience.AvatarEditor.Categories.category
		local subcategoryIndex = store:getState().AvatarExperience.AvatarEditor.Categories.subcategory
		local userId = getUserId(store:getState())
		analyticsFunction(value, categoryIndex, subcategoryIndex, assetTypeId, userId)
	end
end


Prompt: ---Simply process a completed message.

Response:
local COMPLETED_MESSAGE_PROCESSOR = 1

local module = {}
local methods = {}
methods.__index = methods

function methods:SendSystemMessageToSelf(message, channelObj, extraData)
	local messageData =
	{
		ID = -1,
		FromSpeaker = nil,
		SpeakerUserId = 0,
		OriginalChannel = channelObj.Name,
		IsFiltered = true,
		MessageLength = string.len(message),
		Message = message,
		MessageType = ChatConstants.MessageTypeSystem,
		Time = os.time(),
		ExtraData = extraData,
	}

	channelObj:AddMessageToChannel(messageData)
end

function module.new()
	local obj = setmetatable({}, methods)

	obj.COMMAND_MODULES_VERSION = COMMAND_MODULES_VERSION

	obj.KEY_COMMAND_PROCESSOR_TYPE = KEY_COMMAND_PROCESSOR_TYPE
	obj.KEY_PROCESSOR_FUNCTION = KEY_PROCESSOR_FUNCTION

	obj.IN_PROGRESS_MESSAGE_PROCESSOR = IN_PROGRESS_MESSAGE_PROCESSOR
	obj.COMPLETED_MESSAGE_PROCESSOR = COMPLETED_MESSAGE_PROCESSOR

	return obj
end

return module.new()


Prompt: --Controls

Response:
local _CTRL = _Tune.Controls
local Controls = Instance.new("Folder",script.Parent)
Controls.Name = "Controls"
for i,v in pairs(_CTRL) do
	local a=Instance.new("StringValue",Controls)
	a.Name=i
	a.Value=v.Name
	a.Changed:connect(function()
		if i=="MouseThrottle" or i=="MouseBrake" then
			_CTRL[i]=Enum.UserInputType[a.Value]
		else
			_CTRL[i]=Enum.KeyCode[a.Value]
		end
	end)
end
function DealWithInput(input,IsRobloxFunction)
	if (UserInputService:GetFocusedTextBox()==nil) and not _InControls then --No texting while driving
		if _IsOn and  (input.KeyCode ==_CTRL["ContlrShiftDown"] or (_MSteer and input.KeyCode==_CTRL["MouseShiftDown"]) or ((not _MSteer) and input.KeyCode==_CTRL["ShiftDown"])) and _TMode=="Manual" and (not _ClutchOn) and input.UserInputState == Enum.UserInputState.Begin then
			if _CGear == 0 then _ClutchOn = true end
			_CGear = math.max(_CGear-1,-1)
		elseif _IsOn and  (input.KeyCode ==_CTRL["ContlrShiftUp"] or (_MSteer and input.KeyCode==_CTRL["MouseShiftUp"]) or ((not _MSteer) and input.KeyCode==_CTRL["ShiftUp"])) and _TMode=="Manual" and (not _ClutchOn) and input.UserInputState == Enum.UserInputState.Begin then
			if _CGear == 0 then _ClutchOn = true end
			_CGear = math.min(_CGear+1,#_Tune.Ratios-2)
		elseif _IsOn and  (input.KeyCode ==_CTRL["ContlrClutch"] or (_MSteer and input.KeyCode==_CTRL["MouseClutch"]) or ((not _MSteer) and input.KeyCode==_CTRL["Clutch"])) and _TMode=="Manual" then
			if input.UserInputState == Enum.UserInputState.Begin then
				_ClutchOn = false
			elseif input.UserInputState == Enum.UserInputState.End then
				_ClutchOn = true
			end
		elseif _IsOn and  input.KeyCode ==_CTRL["ContlrPBrake"] or (_MSteer and input.KeyCode==_CTRL["MousePBrake"]) or ((not _MSteer) and input.KeyCode==_CTRL["PBrake"]) then
			if input.UserInputState == Enum.UserInputState.Begin then
				_PBrake = not _PBrake
			elseif input.UserInputState == Enum.UserInputState.End then
				if car.DriveSeat.Velocity.Magnitude>5 then
					_PBrake = false
				end
			end
		elseif (input.KeyCode == _CTRL["ContlrToggleTMode"] or input.KeyCode==_CTRL["ToggleTransMode"]) and input.UserInputState == Enum.UserInputState.Begin then
			local n=1
			for i,v in pairs(_Tune.TransModes) do
				if v==_TMode then n=i break end
			end
			n=n+1
			if n>#_Tune.TransModes then n=1 end
			_TMode = _Tune.TransModes[n]
		elseif _IsOn and ((not _MSteer) and (input.KeyCode==_CTRL["Throttle"] or input.KeyCode == _CTRL["Throttle2"])) or (input.UserInputType == _CTRL["MouseThrottle"] and _MSteer) then
			if input.UserInputState == Enum.UserInputState.Begin then
				_GThrot = 1
			else
				_GThrot = _Tune.IdleThrottle
			end
		elseif ((not _MSteer) and (input.KeyCode==_CTRL["Brake"] or input.KeyCode == _CTRL["Brake2"])) or (input.UserInputType == _CTRL["MouseBrake"] and _MSteer) then
			if input.UserInputState == Enum.UserInputState.Begin then
				_GBrake = 1
			else
				_GBrake = 0
			end
		elseif (not _MSteer) and (input.KeyCode==_CTRL["SteerLeft"] or input.KeyCode == _CTRL["SteerLeft2"]) then
			if input.UserInputState == Enum.UserInputState.Begin then
				_GSteerT = -1
				_SteerL = true
			else
				if _SteerR then
					_GSteerT = 1
				else
					_GSteerT = 0
				end
				_SteerL = false
			end
		elseif (not _MSteer) and (input.KeyCode==_CTRL["SteerRight"] or input.KeyCode == _CTRL["SteerRight2"]) then
			if input.UserInputState == Enum.UserInputState.Begin then
				_GSteerT = 1
				_SteerR = true
			else
				if _SteerL then
					_GSteerT = -1
				else
					_GSteerT = 0
				end
				_SteerR = false
			end
		elseif input.KeyCode ==_CTRL["ToggleMouseDrive"] then
			if input.UserInputState == Enum.UserInputState.End then
				_MSteer = not _MSteer
				_GThrot = _Tune.IdleThrottle
				_GBrake = 0
				_GSteerT = 0
				_ClutchOn = true
			end
		elseif  _IsOn and input.KeyCode == _CTRL["ToggleTCS"] or input.KeyCode == _CTRL["ContlrToggleTCS"] then
			if input.UserInputState == Enum.UserInputState.End then
				_TCS = not _TCS
			end
		end
		if input.UserInputType.Name:find("Gamepad") then
			if input.KeyCode == _CTRL["ContlrSteer"] then
				if math.abs(input.Position.X)>_Tune.ControlDZone then
					_GSteerT = math.abs(input.Position.X-_Tune.ControlDZone)*(input.Position.X/math.abs(input.Position.X))/(1-_Tune.ControlDZone)
				else
					_GSteerT = 0
				end
			elseif _IsOn and input.KeyCode == _CTRL["ContlrThrottle"] then
				_GThrot = math.max(_Tune.IdleThrottle,input.Position.Z)
			elseif input.KeyCode == _CTRL["ContlrBrake"] then
				_GBrake = input.Position.Z
			end
		end
	else
		_GThrot = _Tune.IdleThrottle
		_GSteerT = 0
		_GBrake = 0
		if _CGear~=0 then _ClutchOn = true end
	end
end
UserInputService.InputBegan:connect(DealWithInput)
UserInputService.InputChanged:connect(DealWithInput)
UserInputService.InputEnded:connect(DealWithInput)


Prompt:
--Unlock Script
--Unless you know what you're doing, do not modify this script.

Response:
local unlocked = false --This creates a bool for the door's status.
script.Parent.Touched:Connect(function(hit) --This detects a touch on the part.
	if hit.Parent.Name == "Key" and unlocked == false then --This ensures the touching part is a key.
		unlocked = true --This sets the door's status to unlocked.
		script.Parent.Anchored = false --This unanchors the padlock.
		script.Parent.Unlock:Play() --This plays the unlock sound.
		wait(1) --This waits for 1 second to open the door.
		script.Parent.Parent.Parent.Open:Play() --This plays the open sound.
		script.Parent.Parent.Parent.Transparency = 0.25 --This causes the door to be slightly transparent.
		script.Parent.Parent.Parent.CanCollide = false --This causes the door to stop colliding.
		script.Parent.Parent.Parent.DoorScript.Disabled = false --This allows the door script to run.
		script.Parent.Parent.Parent.NPCDoorScript.Disabled = false --This allows the NPC script to run.
	end
end)


Prompt: --- This will cause a brick to go in motion unanchored or not! ---

Response:
while true do
wait()
for i= 1, 270 do
script.Parent.CFrame = script.Parent.CFrame * CFrame.new(0,1,0)
wait()
end
for i= 1, 270 do
script.Parent.CFrame = script.Parent.CFrame * CFrame.new(0,-1,0)
wait()
end
end


Prompt: --[[Status Vars]]

Response:
	local snsrs = car.Body.Sensors

	local _IsOn = _Tune.AutoStart
	if _Tune.AutoStart then car.DriveSeat.IsOn.Value=true end

	local _GSteerT=0
	local _GSteerC=0
	local _GThrot=0
	local _GBrake=0

	local _ClutchOn = true
	local _ClPressing = false
	local _RPM = 0
	local _HP = 0
	local _OutTorque = 0
	local _CGear = 0
	local _PGear = _CGear
	local _spLimit = 0

	local _TMode = _Tune.TransModes[1]

	local _MSteer = false
	local _SteerL = false
	local _SteerR = false
	local _PBrake = false
	local _TCS = _Tune.TCSEnabled
	local _TCSActive = false
	local _ABS = _Tune.ABSEnabled
	local _ABSActive = false

	local FlipWait=tick()
	local FlipDB=false

	local _InControls = false

	script.Parent.DriveMode.Changed:Connect(function()
		if script.Parent.DriveMode.Value == "SportPlus" then
		   if _Tune.TCSEnabled and _IsOn then
					_TCS = false
		   end
		else
		   if _Tune.TCSEnabled and _IsOn then
					_TCS = true
		   end
		end
	end)


Prompt:
--[[ icon_controller:header
## Functions

#### setGameTheme
```lua
IconController.setGameTheme(theme)
```
Sets the default theme which is applied to all existing and future icons.

----
#### setDisplayOrder
```lua
IconController.setDisplayOrder(number)
```
Changes the DisplayOrder of the TopbarPlus ScreenGui to the given value.

----
#### setTopbarEnabled
```lua
IconController.setTopbarEnabled(bool)
```
When set to ``false``, hides all icons created with TopbarPlus. This can also be achieved by calling ``starterGui:SetCore("TopbarEnabled", false)``.

----
#### setGap
```lua
IconController.setGap(integer, alignment)
```
Defines the offset width (i.e. gap) between each icon for the given alignment, ``left``, ``mid``, ``right``, or all alignments if not specified.

----
#### updateTopbar
```lua
IconController.updateTopbar()
```
Determines how icons should be positioned on the topbar and moves them accordingly.

----
#### clearIconOnSpawn
```lua
IconController.clearIconOnSpawn(icon)
```
Calls destroy on the given icon when the player respawns. This is useful for scenarious where you wish to cleanup icons that are constructed within a Gui with ``ResetOnSpawn`` set to ``true``. For example:

```lua
-- Place at the bottom of your icon creator localscript
local icons = IconController.getIcons()
for _, icon in pairs(icons) do
	IconController.clearIconOnSpawn(icon)
end
```

----
#### getIcons
```lua
local arrayOfIcons = IconController.getIcons()
```
Returns all icons as an array.

----
#### getIcon
```lua
local icon = IconController.getIcon(name)
```
Returns the icon with the given name (or ``false`` if not found). If multiple icons have the same name, then one will be returned randomly.

----

## Properties
#### topbarEnabled
{read-only}
```lua
local bool = IconController.topbarEnabled
```

----
#### controllerModeEnabled
{read-only}
```lua
local bool = IconController.controllerModeEnabled
```

----
#### leftGap
{read-only}
```lua
local gapNumber = IconController.leftGap --[default: '12']
```

----
#### midGap
{read-only}
```lua
local gapNumber = IconController.midGap --[default: '12']
```

----
#### rightGap
{read-only}
```lua
local gapNumber = IconController.rightGap --[default: '12']
```
--]]


Prompt: --Control Mapping

Response:
Tune.Controls = {

	--Keyboard Controls
	--Mode Toggles
	ToggleTCS				= Enum.KeyCode.T					,
	ToggleABS				= Enum.KeyCode.Y					,
	ToggleTransMode			= Enum.KeyCode.M					,
	ToggleMouseDrive		= Enum.KeyCode.R					,

	--Primary Controls
	Throttle				= Enum.KeyCode.Up					,
	Brake					= Enum.KeyCode.Down					,
	SteerLeft				= Enum.KeyCode.Left					,
	SteerRight				= Enum.KeyCode.Right				,

	--Secondary Controls
	Throttle2				= Enum.KeyCode.W					,
	Brake2					= Enum.KeyCode.S					,
	SteerLeft2				= Enum.KeyCode.A					,
	SteerRight2				= Enum.KeyCode.D					,

	--Manual Transmission
	ShiftUp					= Enum.KeyCode.E					,
	ShiftDown				= Enum.KeyCode.Q					,
	Clutch					= Enum.KeyCode.LeftShift			,

	--Handbrake
	PBrake					= Enum.KeyCode.P					,

	--Mouse Controls
	MouseThrottle			= Enum.UserInputType.MouseButton1	,
	MouseBrake				= Enum.UserInputType.MouseButton2	,
	MouseClutch				= Enum.KeyCode.W					,
	MouseShiftUp			= Enum.KeyCode.E					,
	MouseShiftDown			= Enum.KeyCode.Q					,
	MousePBrake				= Enum.KeyCode.LeftShift			,

	--Controller Mapping
	ContlrThrottle			= Enum.KeyCode.ButtonR2				,
	ContlrBrake				= Enum.KeyCode.ButtonL2				,
	ContlrSteer				= Enum.KeyCode.Thumbstick1			,
	ContlrShiftUp			= Enum.KeyCode.ButtonY				,
	ContlrShiftDown			= Enum.KeyCode.ButtonX				,
	ContlrClutch			= Enum.KeyCode.ButtonR1				,
	ContlrPBrake			= Enum.KeyCode.ButtonL1				,
	ContlrToggleTMode		= Enum.KeyCode.ButtonB				,
	ContlrToggleTCS			= Enum.KeyCode.DPadDown				,
	ContlrToggleABS			= Enum.KeyCode.ButtonL3				,
}


Response:
local path
local waypoint

local chaseName = nil

function GetTorso(part)
	local chars = game.Workspace:GetDescendants()
	local chaseRoot = nil
	local chaseTorso = nil
	local chasePlr = nil
	local chaseHuman = nil
	local mag = SearchDistance
	for i = 1, #chars do
		chasePlr = chars[i]
		if chasePlr:IsA'Model' and not chasePlr:FindFirstChild("Enemy") and chasePlr:FindFirstChild("Seen") then
			chaseHuman = getHumanoid(chasePlr)
			chaseRoot = chasePlr:FindFirstChild'HumanoidRootPart'
			if chaseRoot ~= nil and chaseHuman ~= nil and chaseHuman.Health > 0 and not chaseHuman:FindFirstChild("Enemy") and not chasePlr:FindFirstChild("Helper") then
				if (chaseRoot.Position - part).magnitude < mag then
					chaseName = chasePlr.Name
					chaseTorso = chaseRoot
					mag = (chaseRoot.Position - part).magnitude
				end
			end
		end
	end
	return chaseTorso
end

function GetPlayersBodyParts(t)
	local torso = t
	if torso then
		local figure = torso.Parent
		for _, v in pairs(figure:GetChildren())do
			if v:IsA'Part' then
				return v.Name
			end
		end
	else
		return "HumanoidRootPart"
	end
end