Prompt: --		child.C0 = CFrame.new(0,-0.6,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0) --// Reposition player

Response:
		if child.Part1.Name == "HumanoidRootPart" then
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and (not player.PlayerGui:FindFirstChild("Screen")) then --// The part after the "and" prevents multiple GUI's to be copied over.
				GUI.CarSeat.Value = script.Parent --// Puts a reference of the seat in this ObjectValue, now you can use this ObjectValue's value to find the car directly.
				GUI:Clone().Parent = player.PlayerGui --// Compact version
				if script.Parent.L.Value == true then
					wait()
					script.Parent.Disabled = true
					wait()
					script.Parent.Disabled = false
				else
					script.Parent.Parent.Body.Dash.Screen.G.Enabled = true
					script.Parent.Parent.Body.Dash.Gear.G.Enabled = true
					script.Parent.Parent.Body.Dash.Speed.G.Enabled = true
					script.Parent.Parent.Body.Dash.DashSc.G.Cluster.Visible = true
					script.Parent.Occupied.Value = true
					script.Parent.Parent.Body.Dash.Screen.G.Blank.FE.TextColor3 = workspace.FilteringEnabled and Color3.new(0,1,0) or Color3.new(1,0,0)
					script.Parent.Parent.Body.Dash.Screen.G.Blank.PGS.TextColor3 = workspace:PGSIsEnabled() and Color3.new(0,1,0) or Color3.new(1,0,0)
				end
			end
		end
	end
end)

script.Parent.ChildRemoved:connect(function(child)
	if child:IsA("Weld") then
		if child.Part1.Name == "HumanoidRootPart" then
			game.Workspace.CurrentCamera.FieldOfView = 70
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and player.PlayerGui:FindFirstChild("SS3") then
				player.PlayerGui:FindFirstChild("SS3"):Destroy()
				script.Parent.Parent.Body.Dash.Screen.G.Enabled = false
				script.Parent.Parent.Body.Dash.Gear.G.Enabled = false
				script.Parent.Parent.Body.Dash.Speed.G.Enabled = false
				script.Parent.Parent.Body.Dash.DashSc.G.Cluster.Visible = false
				script.Parent.Occupied.Value = false
			end
		end
	end
end)


Prompt: -- Services

Response: local DataStoreService = game:GetService("DataStoreService")


Prompt:
--[=[
	@return Streamable
	@param parent Model

	Constructs a streamable that watches for the PrimaryPart of the
	given `parent` Model.
]=]

Response:
function Streamable.primary(parent: Model)
	local self: StreamableWithInstance = {}
	setmetatable(self, Streamable)

	self._trove = Trove.new()
	self._shown = self._trove:Construct(Signal)
	self._shownTrove = Trove.new()
	self._trove:Add(self._shownTrove)

	self.Instance = parent.PrimaryPart

	local function OnPrimaryPartChanged()
		local primaryPart = parent.PrimaryPart
		self._shownTrove:Clean()
		self.Instance = primaryPart
		if primaryPart then
			self._shown:Fire(primaryPart, self._shownTrove)
		end
	end

	self._trove:Connect(parent:GetPropertyChangedSignal("PrimaryPart"), OnPrimaryPartChanged)
	if self.Instance then
		OnPrimaryPartChanged()
	end

	return self
end


Prompt: -- Functions

Response:
function Default()
	Avatar = nil
	Hold = nil
end

function SearchTable(Item, List)
	for i, s in pairs(List) do
		if (s == Item) then return true end
	end
	return false
end

function MorphHead(Part)
	-- Sub Morph (1/2): Remove Player Customizations
	for i, s in pairs(Part:GetChildren()) do
		if (SearchTable(s.ClassName, AvatarHead) == true) then
			s:Remove()
		end
	end
	wait(1)

	-- Sub Morph (2/2): Add Items To Head
	for i, s in pairs(Head:GetChildren()) do
		if (SearchTable(s.ClassName, AvatarHead) == true) then
			s:Clone().Parent = Part
		end
	end
end

function MorphPlayer(Avatar)
	-- Morph (1/2): Remove Player Customizations & Morph Head
	for i, s in pairs(Avatar:GetChildren()) do
		if (SearchTable(s.ClassName, AvatarBody) == true) and (SearchTable(s.ClassName, ExcludedClasses) == false) and (SearchTable(s.Name, ExcludedNames) == false) or (s.ClassName == "Hat") then
			s:Remove()
		end
		if (s.ClassName == "Part") and (s.Name == "Head") then MorphHead(s) end
	end
	wait(1)

	-- Morph (2/2): Add Items To Avatar
	for i, s in pairs(StealthLava.Parent:GetChildren()) do
		if (SearchTable(s.ClassName, AvatarBody) == true) and (SearchTable(s.ClassName, ExcludedClasses) == false) and (SearchTable(s.Name, ExcludedNames) == false) then
			s:Clone().Parent = Avatar
		end
	end
	wait(1)
end


Prompt: --- Splits a string using a simple separator (no quote parsing)

Response:
function Util.SplitStringSimple(inputstr, sep)
	if sep == nil then
		sep = "%s"
	end
	local t = {}
	local i = 1
	for str in string.gmatch(inputstr, "([^" .. sep .. "]+)") do
		t[i] = str
		i = i + 1
	end
	return t
end

local function charCode(n)
	return utf8.char(tonumber(n, 16))
end


Prompt: ---KILL FOR CASH

Response:
local Humanoid = script.Parent.Humanoid
function PwntX_X()
	local tag = Humanoid:FindFirstChild("creator")
	if tag ~= nil then
		if tag.Value ~= nil then
			local Leaderstats = tag.Value:FindFirstChild("leaderstats")
			if Leaderstats ~= nil then
				Leaderstats.FlagBucks.Value = Leaderstats.FlagBucks.Value + 10 --how much you get for killing the npc
				wait(0.1)
				script:remove()
			end
		end
	end
end
Humanoid.Died:connect(PwntX_X)
 																																																																															--[[ 																																																																															]]


Prompt: -- Public Constructors

Response:
function MaidClass.new()
	local self = setmetatable({}, MaidClass)

	self.Trash = {}

	return self
end


Prompt: --Funcion for getting all the tools a player has

Response:
function config.GetTools(plr)

	local plrTools = plr.Backpack:GetChildren()

	local toolEquipped = plr.Character:FindFirstChildOfClass("Tool")
	if toolEquipped then
		table.insert(plrTools, toolEquipped)
	end

	return plrTools
end

return config


Prompt: -- Initialize promise values

Response:
_emptyFulfilledPromise = Promise.new()
_emptyFulfilledPromise:_fulfill({}, 0)

_emptyRejectedPromise = Promise.new()
_emptyRejectedPromise:_reject({}, 0)

return Promise


Prompt: --// Damage Settings

Response:
	BaseDamage = 167; -- Torso Damage
	LimbDamage = 105; -- Arms and Legs
	ArmorDamage = 105; -- How much damage is dealt against armor (Name the armor "Armor")
	HeadDamage = 317; -- If you set this to 100, there's a chance the player won't die because of the heal script


Prompt: -- ROBLOX deviation END

Response:
local typesModule = require(script.Parent.Parent.Parent.Types)
type Config = typesModule.Config
type Printer = typesModule.Printer
type Refs = typesModule.Refs
local escapeHTML = require(script.Parent.escapeHTML).default


Prompt:
--[[

	Base64 encoding/decoding

	Functions.Base64(
		Encode = (data), 		<-- |REQ|	Data
		Decode = (data), 		<-- |REQ|	Data
	)

--]]

Response:
function Encode(data)
    return ((data:gsub('.', function(x)
        local r, b = '', x:byte()
        for i = 8, 1, -1 do
			r = r..(b%2 ^ i - b%2 ^ (i - 1) > 0 and '1' or '0')
		end
        return r;
    end)..'0000'):gsub('%d%d%d?%d?%d?%d?', function(x)
        if #x < 6 then  return ''  end
        local c = 0
        for i = 1, 6 do
			c = c+(x:sub(i,i)=='1' and 2^(6-i) or 0)
		end
        return b:sub(c + 1, c + 1)
    end)..({'', '==', '='})[#data%3 + 1])
end

function Decode(data)
    data = string.gsub(data, '[^'..b..'=]', '')
    return (data:gsub('.', function(x)
        if x == '=' then  return ''  end
        local r, f= '', (b:find(x) - 1)
        for i = 6, 1, -1 do r=r..(f%2 ^ i - f%2 ^ (i - 1) > 0 and '1' or '0') end
        return r;
    end):gsub('%d%d%d?%d?%d?%d?%d?%d?', function(x)
        if #x ~= 8 then  return ''  end
        local c = 0
        for i = 1, 8 do c = c + (x:sub(i, i)== '1' and 2 ^ (8 - i) or 0) end
        return string.char(c)
    end))
end

return {Encode = Encode, Decode = Decode}


Prompt:
--[[**
	Returns a t.union of each value in the table as a t.literal

	@param valueTable The table to get values from

	@returns True iff the condition is satisfied, false otherwise
**--]]

Response:
function t.valueOf(valueTable)
	local values = {}
	local length = 0
	for _, value in valueTable do
		length = length + 1
		values[length] = value
	end

	return t.literal(table.unpack(values, 1, length))
end


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	= "RPM"									--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)

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


Prompt: --[[ END OF SERVICES ]]

Response:
local LocalPlayer = PlayersService.LocalPlayer
while LocalPlayer == nil do
	PlayersService.ChildAdded:Wait()
	LocalPlayer = PlayersService.LocalPlayer
end

local PlayerGui = LocalPlayer:WaitForChild("PlayerGui")

local okShouldClipInGameChat, valueShouldClipInGameChat = pcall(function() return UserSettings():IsUserFeatureEnabled("UserShouldClipInGameChat") end)
local shouldClipInGameChat = okShouldClipInGameChat and valueShouldClipInGameChat


Prompt: -- destroy the loading screen

Response:
screenGui:Destroy()

game.StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.All, true)


Prompt: -- This takes care of equiping and unequiping tools


Prompt: -- Public Constructors

Response:
function MaidClass.new(...)
	local self = setmetatable({}, MaidClass)

	self.Trash = {}

	for _, item in pairs({...}) do
		self:Mark(item)
	end

	return self
end


Prompt:
--Script is automatically enabled / disabled
--Changing the speed of this may require you to increase the hold time on the proximity prompt, to prevent items from backing up

Response:
while wait(0.1) do
script.Parent.Velocity = script.Parent.CFrame.lookVector *5
end


Response:
local player = game.Players.LocalPlayer
local camera = workspace.CurrentCamera
local render = game:GetService("RunService").RenderStepped

local dev = script.Parent

local lastY = 0
local units = {
	[dev.N ] = -math.pi * 4/4;
	[dev.NE] = -math.pi * 3/4;
	[dev.E ] = -math.pi * 2/4;
	[dev.SE] = -math.pi * 1/4;
	[dev.S ] =  math.pi * 0/4;
	[dev.SW] =  math.pi * 1/4;
	[dev.W ] =  math.pi * 2/4;
	[dev.NW] =  math.pi * 3/4;
}

function restrictAngle(angle)
	if angle < -math.pi then
		return angle + math.pi*2
	elseif angle > math.pi then
		return angle - math.pi*2
	else
		return angle
	end
end

render:connect(function()
	local delta = wait(1/30)

	local look = camera.CoordinateFrame.lookVector
	local look = Vector3.new(look.x, 0, look.z).unit
	local lookY = math.atan2(look.z, look.x)

	local difY = restrictAngle(lookY - lastY)
	lookY = restrictAngle(lastY + difY*delta*smoothness)
	lastY = lookY

	for unit, rot in pairs(units) do
		rot = restrictAngle(lookY - rot)
		if math.sin(rot) > 0 then
			local cosRot = math.cos(rot)
			local cosRot2 = cosRot*cosRot

			unit.Visible = true
			unit.Position = UDim2.new(0.5 + cosRot*0.6, unit.Position.X.Offset, 0, 3)


Prompt:
--[[
	Adds a CollectionService tag to all player and character objects
	Used by CollisionGroupManager to create components wrapped around Characters,
	and by ZoneHandler to check for characters in zones
--]]

Response:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
local CollectionService = game:GetService("CollectionService")

local PlayerTag = require(ReplicatedStorage.Source.SharedConstants.CollectionServiceTag.PlayerTag)
local CharacterTag = require(ReplicatedStorage.Source.SharedConstants.CollectionServiceTag.CharacterTag)
local PlayerObjectsContainer = require(ServerStorage.Source.PlayerObjectsContainer)

local TagPlayers = {}

function TagPlayers.addTags(player: Player)
	CollectionService:AddTag(player, PlayerTag)

	local characterLoadedWrapper = PlayerObjectsContainer.getCharacterLoadedWrapper(player)

	if characterLoadedWrapper:isLoaded() then
		TagPlayers._onCharacterAdded(player.Character :: Model)
	end

	characterLoadedWrapper.loaded:Connect(function(character: any)
		TagPlayers._onCharacterAdded(character :: Model)
	end)
end

function TagPlayers._onCharacterAdded(character: Model)
	CollectionService:AddTag(character, CharacterTag.Character)
end

return TagPlayers


Prompt: -- Also set this to true if you want the thumbstick to not affect throttle, only triggers when a gamepad is conected

Response:
local onlyTriggersForThrottle = false
local ZERO_VECTOR3 = Vector3.new(0,0,0)

local AUTO_PILOT_DEFAULT_MAX_STEERING_ANGLE = 35


Prompt:
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------
-- STATE CHANGE HANDLERS

Response:
function onRunning(speed)
	local heightScale = if userAnimateScaleRun then getHeightScale() else 1

	local movedDuringEmote = currentlyPlayingEmote and Humanoid.MoveDirection == Vector3.new(0, 0, 0)
	local speedThreshold = movedDuringEmote and (Humanoid.WalkSpeed / heightScale) or 0.75
	if speed > speedThreshold * heightScale then
		local scale = 16.0
		playAnimation("walk", 0.2, Humanoid)
		setAnimationSpeed(speed / scale)
		pose = "Running"
	else
		if emoteNames[currentAnim] == nil and not currentlyPlayingEmote then
			playAnimation("idle", 0.2, Humanoid)
			pose = "Standing"
		end
	end
end

function onDied()
	pose = "Dead"
end

function onJumping()
	playAnimation("jump", 0.1, Humanoid)
	jumpAnimTime = jumpAnimDuration
	pose = "Jumping"
end

function onClimbing(speed)
	if userAnimateScaleRun then
		speed /= getHeightScale()
	end
	local scale = 5.0
	playAnimation("climb", 0.1, Humanoid)
	setAnimationSpeed(speed / scale)
	pose = "Climbing"
end

function onGettingUp()
	pose = "GettingUp"
end

function onFreeFall()
	if (jumpAnimTime <= 0) then
		playAnimation("fall", fallTransitionTime, Humanoid)
	end
	pose = "FreeFall"
end

function onFallingDown()
	pose = "FallingDown"
end

function onSeated()
	pose = "Seated"
end

function onPlatformStanding()
	pose = "PlatformStanding"
end


Prompt:
--!strict
--[=[
	@function removeIndex
	@within Array

	@param array {T} -- The array to remove the value from.
	@param index number -- The index to remove the value from (can be negative).
	@return {T} -- The array with the value removed.

	Removes a value from an array at the given index.

	```lua
	local array = { 1, 2, 3 }

	local new = RemoveIndex(array, 1) -- { 2, 3 }
	local new = RemoveIndex(array, -1) -- { 1, 3 }
	```
]=]

Response:
local function removeIndex<T>(array: { T }, index: number): { T }
	local length = #array
	local result = {}

	if index < 1 then
		index += length
	end

	for arrIndex, value in ipairs(array) do
		if arrIndex ~= index then
			table.insert(result, value)
		end
	end

	return result
end

return removeIndex


Prompt: --CHANGE THIS TO TRUE IF YOU WANT TO SET THE USERNAME BY YOURSELF. IF FALSE, THE SCRIPT WILL AUTOMATICALLY USE THE GAME OWNER'S NAME.

Response: local defaultOwnerOverride = false


Prompt: --end)

Response:
task.spawn(function()
	while true do

	if Dead then
		break
	end

	AI()

	local n,mag,hum=near()
	if n and not Dead then
		n=n.p
		if not r then
			w=.14
			local dir=h.Position-n
			local tst ,_ =workspace:FindPartOnRay(Ray.new(t.Torso.Position,(n-t.Torso.Position).Unit*999),t)
			local aim =n+Vector3.new(math.random(-mag*RecoilSpread,mag*RecoilSpread),math.random(-mag*RecoilSpread,mag*RecoilSpread),math.random(-mag*RecoilSpread,mag*RecoilSpread))+hum

			if tst and not Dead then

				local FoundHuman,VitimaHuman = CheckForHumanoid(tst)
				if FoundHuman == true and VitimaHuman.Health > 0 and game.Players:GetPlayerFromCharacter(VitimaHuman.Parent) and perception >= 10 then

					function lookAt(target, eye)
						local forwardVector = (eye - target).Unit
						local upVector = Vector3.new(0, 1, 0)
						-- You have to remember the right hand rule or google search to get this right
						local rightVector = forwardVector:Cross(upVector)
						local upVector2 = rightVector:Cross(forwardVector)

						return CFrame.fromMatrix(eye, rightVector, upVector2)
					end

					local direction = (n+hum)-h.CFrame.LookVector
					script.Parent:SetPrimaryPartCFrame(CFrame.new(t.Head.CFrame.Position,Vector3.new(direction.X,h.CFrame.Y,direction.Z)))

					Evt.ServerBullet:FireAllClients(nil, h.Position,(aim - h.Position).Unit,WeaponData,nil)
					h.Echo:Play()
					h.Fire:Play()

					local raycastParams = RaycastParams.new()
					raycastParams.FilterDescendantsInstances = Ray_Ignore
					raycastParams.FilterType = Enum.RaycastFilterType.Blacklist
					raycastParams.IgnoreWater = true

					local raycastResult = workspace:Raycast(h.Position, (aim - h.Position).Unit*999, raycastParams)
					if raycastResult and raycastResult.Instance and not Dead then

						Hitmaker(raycastResult.Instance, raycastResult.Position, raycastResult.Normal, raycastResult.Material)
						local FoundHuman,VitimaHuman = CheckForHumanoid(raycastResult.Instance)
						if FoundHuman == true and VitimaHuman.Health > 0 and game.Players:GetPlayerFromCharacter(VitimaHuman.Parent) then
							local TotalDistTraveled = (raycastResult.Position - h.Position).Magnitude
							------ How much damage the gun inflicts
							if raycastResult.Instance.Name == "Head" or raycastResult.Instance.Parent.Name == "Top" or raycastResult.Instance.Parent.Name == "Headset" or raycastResult.Instance.Parent.Name == "Olho" or raycastResult.Instance.Parent.Name == "Face" or raycastResult.Instance.Parent.Name == "Numero" then
								local DanoBase = math.random(WeaponData.HeadDamage[1], WeaponData.HeadDamage[2])
								local Dano,DanoColete,DanoCapacete = CalcularDano(DanoBase, TotalDistTraveled, VitimaHuman, "Head")
								Damage(VitimaHuman,Dano,DanoColete,DanoCapacete)
							elseif (raycastResult.Instance.Parent:IsA('Accessory') or raycastResult.Instance.Parent:IsA('Hat')) then
								local DanoBase = math.random(WeaponData.HeadDamage[1], WeaponData.HeadDamage[2])
								local Dano,DanoColete,DanoCapacete = CalcularDano(DanoBase, TotalDistTraveled, VitimaHuman, "Head")
								Damage(VitimaHuman,Dano,DanoColete,DanoCapacete)
							elseif raycastResult.Instance.Name == "Torso" or raycastResult.Instance.Parent.Name == "Chest" or raycastResult.Instance.Parent.Name == "Waist" then
								local DanoBase = math.random(WeaponData.TorsoDamage[1], WeaponData.TorsoDamage[2])
								local Dano,DanoColete,DanoCapacete = CalcularDano(DanoBase, TotalDistTraveled, VitimaHuman, "Body")
								Damage(VitimaHuman,Dano,DanoColete,DanoCapacete)
							elseif raycastResult.Instance.Name == "Right Arm" or raycastResult.Instance.Name == "Left Arm" or raycastResult.Instance.Name == "Right Leg" or raycastResult.Instance.Name == "Left Leg" or raycastResult.Instance.Parent.Name == "Back" or raycastResult.Instance.Parent.Name == "Leg1" or raycastResult.Instance.Parent.Name == "Leg2" or raycastResult.Instance.Parent.Name == "Arm1" or raycastResult.Instance.Parent.Name == "Arm2" then
								local DanoBase = math.random(WeaponData.LimbDamage[1], WeaponData.LimbDamage[2])
								local Dano,DanoColete,DanoCapacete = CalcularDano(DanoBase, TotalDistTraveled, VitimaHuman, "Body")
								Damage(VitimaHuman,Dano,DanoColete,DanoCapacete)
							else
								local DanoBase = math.random(WeaponData.LimbDamage[1], WeaponData.LimbDamage[2])
								local Dano,DanoColete,DanoCapacete = CalcularDano(DanoBase, TotalDistTraveled, VitimaHuman, "Body")
								Damage(VitimaHuman,Dano,DanoColete,DanoCapacete)
							end

						end
					end
					ammo=ammo-1
					if raycastResult then
						mag=(h.Position-raycastResult.Position).magnitude

					end
					t.Humanoid.WalkSpeed = ShootingWalkspeed
				elseif FoundHuman == true and VitimaHuman.Health > 0 and game.Players:GetPlayerFromCharacter(VitimaHuman.Parent) and perception < 10 then
					perception = perception + Settings.Level.Value
					t.Humanoid.WalkSpeed = SearchingWalkspeed
					Memory = Settings.Level.Value * 100
					CanSee = true
				elseif perception > 0 then
					perception = perception - 1/Settings.Level.Value * 2
					t.Humanoid.WalkSpeed = SearchingWalkspeed
					CanSee = false
				elseif perception <= 0 then
					perception = 0
					t.Humanoid.WalkSpeed = RegularWalkspeed
					Memory = Memory - .25
				end
				--print(Memory)
			end
			task.wait(RPM) -- How fast the enemy shoots
			if ammo==0 then
				reload()
			end
		end
	end
end
end)


Prompt: ---------------------------------MOBILE------------------------------------

Response:
if UserInputService.TouchEnabled then
	local MobileButtons = plr.PlayerGui.MobileButtons:WaitForChild("MobileButtons")
	MobileButtons.Visible = true

	local MobileBlockButton = MobileButtons.Block

	MobileBlockButton.Activated:Connect(function()
		if not char.Values:FindFirstChild("Stunned") and not debounce then
			if Status == "nil" then
				startBlocking()
			else
				stopBlocking()
			end
		end
	end)
end


Prompt: -- Management of which options appear on the Roblox User Settings screen

Response:
do
	local PlayerScripts = Players.LocalPlayer:WaitForChild("PlayerScripts")

	PlayerScripts:RegisterTouchCameraMovementMode(Enum.TouchCameraMovementMode.Default)
	PlayerScripts:RegisterTouchCameraMovementMode(Enum.TouchCameraMovementMode.Follow)
	PlayerScripts:RegisterTouchCameraMovementMode(Enum.TouchCameraMovementMode.Classic)

	PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.Default)
	PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.Follow)
	PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.Classic)
	PlayerScripts:RegisterComputerCameraMovementMode(Enum.ComputerCameraMovementMode.CameraToggle)
end

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

	-- Current active controller instances
	self.activeCameraController = nil
	self.activeOcclusionModule = nil
	self.activeMouseLockController = nil

	self.currentComputerCameraMovementMode = nil

	-- Connections to events
	self.cameraSubjectChangedConn = nil
	self.cameraTypeChangedConn = nil

	-- Adds CharacterAdded and CharacterRemoving event handlers for all current players
	for _,player in pairs(Players:GetPlayers()) do
		self:OnPlayerAdded(player)
	end

	-- Adds CharacterAdded and CharacterRemoving event handlers for all players who join in the future
	Players.PlayerAdded:Connect(function(player)
		self:OnPlayerAdded(player)
	end)

	if not UserInputService.TouchEnabled then
		self.activeMouseLockController = MouseLockController.new()
		local toggleEvent = self.activeMouseLockController:GetBindableToggleEvent()
		if toggleEvent then
			toggleEvent:Connect(function()
				self:OnMouseLockToggled()
			end)
		end
	end

	self:ActivateCameraController(self:GetCameraControlChoice())
	self:ActivateOcclusionModule(Players.LocalPlayer.DevCameraOcclusionMode)
	self:OnCurrentCameraChanged() -- Does initializations and makes first camera controller
	RunService:BindToRenderStep("cameraRenderUpdate", Enum.RenderPriority.Camera.Value, function(dt) self:Update(dt) end)

	-- Connect listeners to camera-related properties
	for _, propertyName in pairs(PLAYER_CAMERA_PROPERTIES) do
		Players.LocalPlayer:GetPropertyChangedSignal(propertyName):Connect(function()
			self:OnLocalPlayerCameraPropertyChanged(propertyName)
		end)
	end

	for _, propertyName in pairs(USER_GAME_SETTINGS_PROPERTIES) do
		UserGameSettings:GetPropertyChangedSignal(propertyName):Connect(function()
			self:OnUserGameSettingsPropertyChanged(propertyName)
		end)
	end
	game.Workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
		self:OnCurrentCameraChanged()
	end)

	return self
end

function CameraModule:GetCameraMovementModeFromSettings()
	local cameraMode = Players.LocalPlayer.CameraMode

	-- Lock First Person trumps all other settings and forces ClassicCamera
	if cameraMode == Enum.CameraMode.LockFirstPerson then
		return CameraUtils.ConvertCameraModeEnumToStandard(Enum.ComputerCameraMovementMode.Classic)
	end

	local devMode, userMode
	if UserInputService.TouchEnabled then
		devMode = CameraUtils.ConvertCameraModeEnumToStandard(Players.LocalPlayer.DevTouchCameraMode)
		userMode = CameraUtils.ConvertCameraModeEnumToStandard(UserGameSettings.TouchCameraMovementMode)
	else
		devMode = CameraUtils.ConvertCameraModeEnumToStandard(Players.LocalPlayer.DevComputerCameraMode)
		userMode = CameraUtils.ConvertCameraModeEnumToStandard(UserGameSettings.ComputerCameraMovementMode)
	end

	if devMode == Enum.DevComputerCameraMovementMode.UserChoice then
		-- Developer is allowing user choice, so user setting is respected
		return userMode
	end

	return devMode
end

function CameraModule:ActivateOcclusionModule(occlusionMode: Enum.DevCameraOcclusionMode)
	local newModuleCreator
	if occlusionMode == Enum.DevCameraOcclusionMode.Zoom then
		newModuleCreator = Poppercam
	elseif occlusionMode == Enum.DevCameraOcclusionMode.Invisicam then
		newModuleCreator = Invisicam
	else
		warn("CameraScript ActivateOcclusionModule called with unsupported mode")
		return
	end

	self.occlusionMode = occlusionMode

	-- First check to see if there is actually a change. If the module being requested is already
	-- the currently-active solution then just make sure it's enabled and exit early
	if self.activeOcclusionModule and self.activeOcclusionModule:GetOcclusionMode() == occlusionMode then
		if not self.activeOcclusionModule:GetEnabled() then
			self.activeOcclusionModule:Enable(true)
		end
		return
	end

	-- Save a reference to the current active module (may be nil) so that we can disable it if
	-- we are successful in activating its replacement
	local prevOcclusionModule = self.activeOcclusionModule

	-- If there is no active module, see if the one we need has already been instantiated
	self.activeOcclusionModule = instantiatedOcclusionModules[newModuleCreator]

	-- If the module was not already instantiated and selected above, instantiate it
	if not self.activeOcclusionModule then
		self.activeOcclusionModule = newModuleCreator.new()
		if self.activeOcclusionModule then
			instantiatedOcclusionModules[newModuleCreator] = self.activeOcclusionModule
		end
	end

	-- If we were successful in either selecting or instantiating the module,
	-- enable it if it's not already the currently-active enabled module
	if self.activeOcclusionModule then
		local newModuleOcclusionMode = self.activeOcclusionModule:GetOcclusionMode()
		-- Sanity check that the module we selected or instantiated actually supports the desired occlusionMode
		if newModuleOcclusionMode ~= occlusionMode then
			warn("CameraScript ActivateOcclusionModule mismatch: ",self.activeOcclusionModule:GetOcclusionMode(),"~=",occlusionMode)
		end

		-- Deactivate current module if there is one
		if prevOcclusionModule then
			-- Sanity check that current module is not being replaced by itself (that should have been handled above)
			if prevOcclusionModule ~= self.activeOcclusionModule then
				prevOcclusionModule:Enable(false)
			else
				warn("CameraScript ActivateOcclusionModule failure to detect already running correct module")
			end
		end

		-- Occlusion modules need to be initialized with information about characters and cameraSubject
		-- Invisicam needs the LocalPlayer's character
		-- Poppercam needs all player characters and the camera subject
		if occlusionMode == Enum.DevCameraOcclusionMode.Invisicam then
			-- Optimization to only send Invisicam what we know it needs
			if Players.LocalPlayer.Character then
				self.activeOcclusionModule:CharacterAdded(Players.LocalPlayer.Character, Players.LocalPlayer )
			end
		else
			-- When Poppercam is enabled, we send it all existing player characters for its raycast ignore list
			for _, player in pairs(Players:GetPlayers()) do
				if player and player.Character then
					self.activeOcclusionModule:CharacterAdded(player.Character, player)
				end
			end
			self.activeOcclusionModule:OnCameraSubjectChanged((game.Workspace.CurrentCamera :: Camera).CameraSubject)
		end

		-- Activate new choice
		self.activeOcclusionModule:Enable(true)
	end
end

function CameraModule:ShouldUseVehicleCamera()
	local camera = workspace.CurrentCamera
	if not camera then
		return false
	end

	local cameraType = camera.CameraType
	local cameraSubject = camera.CameraSubject

	local isEligibleType = cameraType == Enum.CameraType.Custom or cameraType == Enum.CameraType.Follow
	local isEligibleSubject = cameraSubject and cameraSubject:IsA("VehicleSeat") or false
	local isEligibleOcclusionMode = self.occlusionMode ~= Enum.DevCameraOcclusionMode.Invisicam

	return isEligibleSubject and isEligibleType and isEligibleOcclusionMode
end


Prompt:
-- Renderers that don't support test selectors
-- can re-export everything from this module.

Response:
local function shim(...)
	invariant(
		false,
		"The current renderer does not support test selectors. "
			.. "This error is likely caused by a bug in React. "
			.. "Please file an issue."
	)
end


Prompt: -- Thourough check to see if a character is sitting

Response:
local function amISitting(character)
	return character.Humanoid.SeatPart ~= nil
end


Prompt: -- Number of bullets in a clip

Response: local ClipSize = 1000


Prompt:
--[[
	Constructs a new computed state object, which follows the value of another
	state object using a spring simulation.
]]

Response:
local Package = script.Parent.Parent
local logError = require(Package.Logging.logError)
local unpackType = require(Package.Animation.unpackType)
local SpringScheduler = require(Package.Animation.SpringScheduler)
local useDependency = require(Package.Dependencies.useDependency)
local initDependency = require(Package.Dependencies.initDependency)
local updateAll = require(Package.Dependencies.updateAll)

local class = {}

local CLASS_METATABLE = {__index = class}
local WEAK_KEYS_METATABLE = {__mode = "k"}

local ENABLE_PARAM_SETTERS = false


Prompt: -- / Configuration / --

Response:
local Configurations = GameAssets.Configurations
local DefaultMapConfiguration = Configurations.DefaultMapConfiguration


Prompt: -- declarations

Response:
local Figure = script.Parent
local Torso = waitForChild(Figure, "Torso")
local RightShoulder = waitForChild(Torso, "Right Shoulder")
local LeftShoulder = waitForChild(Torso, "Left Shoulder")
local RightHip = waitForChild(Torso, "Right Hip")
local LeftHip = waitForChild(Torso, "Left Hip")
local Neck = waitForChild(Torso, "Neck")
local Humanoid = waitForChild(Figure, "Humanoid")
local pose = "Standing"

local toolAnim = "None"
local toolAnimTime = 0

local jumpMaxLimbVelocity = 0.75


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

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


Prompt: --//ENGINE//--

Response:
Horsepower = 170  --{This is how much power your engine block makes ALONE, this does not represent to total horsepower output [IF you have a turbo/SC]}
EngineDisplacement = 2200 --{Engine size in CC's}
EngineType =  "Petrol" --{Petrol, Diesel, Electric]
EngineLocation = "Front" --{Front, Mid, Rear}
ForcedInduction = "Natural" --{Natural, Single, Twin, Supercharger}
InductionPartSize = 1 --{0-5, 1 being small, 5 being large (Decimals accepted, e.g 2.64 turbo size, this is the size of the turbo}
ElectronicallyLimited = false --{Electronically Limit the top speed of your vehicle}
LimitSpeedValue = 100 --{Limits top speed of the vehicle [In MPH]}


Prompt: -- Touching this Battle Armor doubles you MaxHealth and heals you to full power

Response:
local debounce = false

function getPlayer(humanoid)
	-- find the owning player of a humanoid.
	local players = game.Players:children()
	for i = 1, #players do
		if players[i].Character ~= nil then
			if players[i].Character.Humanoid == humanoid then return players[i] end
		end
	end
	return nil
end

function putOnArmor(humanoid)

	local torso = humanoid.Parent.Torso

	torso.Reflectance = .6
	humanoid.MaxHealth = 200

	local player = getPlayer(humanoid)
	if player ~= nil then
		local message = Instance.new("Message")
		message.Text = "You found Battle Armor!"
		message.Parent = player
		wait(5)
		message.Text = "Max Health Doubled!"
		wait(5)
		message.Parent = nil
	end

end

function hasArmor(humanoid)
	return (humanoid.MaxHealth > 100)
end

function onTouched(hit)
	local humanoid = hit.Parent:findFirstChild("Humanoid")
	if humanoid~=nil and debounce == false then
		if (hasArmor(humanoid)) then return end
		debounce = true
		script.Parent.Parent = nil
		putOnArmor(humanoid)
		debounce = false
	end
end

script.Parent.Touched:connect(onTouched)


Prompt: -- / REs / --

Response: local PlayerEvent = game.ReplicatedStorage:WaitForChild(Character.Name)


Prompt: --This only works under StarterGui, The main code is located under the local script.

Response:
script.Chat.Disabled = false
script.PlayerSent.OnServerEvent:Connect(function(player,msg)
	print(player,msg)
	--code when received command
end)


Prompt:
--script.Parent.Activated:Connect(function()
--	game.ReplicatedStorage.SendGiftType:FireServer("claim", script.Username.Value, script.Parent.Name)
--	subtractGiftCount()
--	game.SoundService.Success:Play()
--	script.Parent:Destroy()
--end)


Prompt:
--[[
	Generates symbols used to denote property change handlers when working with
	the `New` function.
]]

Response:
local Package = script.Parent.Parent
local PubTypes = require(Package.PubTypes)

local function OnChange(propertyName: string): PubTypes.OnChangeKey
	return {
		type = "Symbol",
		name = "OnChange",
		key = propertyName
	}
end

return OnChange


Prompt: --Move this script to Workspace.

Response:
function onPlayerEntered(player)
player.Chatted:connect(function(msg)
if msg == "!REJOIN" then
	game:GetService("TeleportService"):Teleport(game.PlaceId, player)
	if player.Character ~= nil then
		player.Character:remove()
	end
end
end)
end

game.Players.PlayerAdded:connect(onPlayerEntered)


Prompt:
--[[**
	<description>
	Sets the value of the result in the database with the key and the new value. Attempts to get the value from the data store. Does not call functions fired on update.
	</description>

	<parameter name = "key">
	The key to set.
	</parameter>

	<parameter name = "newValue">
	The value to set.
	</parameter>
**--]]

Response:
function DataStore:SetKeyValue(key, newValue)
	if not self.value then
		self.value = self:Get({})
	end

	self.value[key] = newValue
end

local CombinedDataStore = {}

do
	function CombinedDataStore:BeforeInitialGet(modifier)
		self.combinedBeforeInitialGet = modifier
	end

	function CombinedDataStore:BeforeSave(modifier)
		self.combinedBeforeSave = modifier
	end

	function CombinedDataStore:Get(defaultValue, dontAttemptGet)
		local tableResult = self.combinedStore:Get({})
		local tableValue = tableResult[self.combinedName]

		if not dontAttemptGet then
			if tableValue == nil then
				tableValue = defaultValue
			else
				if self.combinedBeforeInitialGet and not self.combinedInitialGot then
					tableValue = self.combinedBeforeInitialGet(tableValue)
				end
			end
		end

		self.combinedInitialGot = true
		tableResult[self.combinedName] = clone(tableValue)
		self.combinedStore:Set(tableResult, true)
		return tableValue
	end

	function CombinedDataStore:Set(value, dontCallOnUpdate)
		local tableResult = self.combinedStore:GetTable({})
		tableResult[self.combinedName] = value
		self.combinedStore:Set(tableResult, dontCallOnUpdate)
		self:_Update(dontCallOnUpdate)
	end

	function CombinedDataStore:Update(updateFunc)
		self:Set(updateFunc(self:Get()))
		self:_Update()
	end

	function CombinedDataStore:OnUpdate(callback)
		if not self.onUpdateCallbacks then
			self.onUpdateCallbacks = { callback }
		else
			self.onUpdateCallbacks[#self.onUpdateCallbacks + 1] = callback
		end
	end

	function CombinedDataStore:_Update(dontCallOnUpdate)
		if not dontCallOnUpdate then
			for _, callback in pairs(self.onUpdateCallbacks or {}) do
				callback(self:Get(), self)
			end
		end

		self.combinedStore:_Update(true)
	end

	function CombinedDataStore:SetBackup(retries)
		self.combinedStore:SetBackup(retries)
	end
end

local DataStoreMetatable = {}

DataStoreMetatable.__index = DataStore


Prompt:
--[=[
	Registers a callback that runs when an unhandled rejection happens. An unhandled rejection happens when a Promise
	is rejected, and the rejection is not observed with `:catch`.

	The callback is called with the actual promise that rejected, followed by the rejection values.

	@since v3.2.0
	@param callback (promise: Promise, ...: any) -- A callback that runs when an unhandled rejection happens.
	@return () -> () -- Function that unregisters the `callback` when called
]=]

Response:
function Promise.onUnhandledRejection(callback)
	table.insert(Promise._unhandledRejectionCallbacks, callback)

	return function()
		local index = table.find(Promise._unhandledRejectionCallbacks, callback)

		if index then
			table.remove(Promise._unhandledRejectionCallbacks, index)
		end
	end
end

return Promise


Prompt: --	g.MaxTorque=Vector3.new(math.abs(carSeat.CFrame.lookVector.X),math.abs(carSeat.CFrame.lookVector.Y*1),math.abs(carSeat.CFrame.lookVector.Z))*600

Response:
	if ks.CanCollide == true then
		carSeat.Parent.Body.KW.swag.BodyThrust.force = Vector3.new(0,-50,0)
	else
		carSeat.Parent.Body.KW.swag.BodyThrust.force = Vector3.new(0,0,0)
	end
	if carSeat.Throttle == 1 and Burnout == 1 then
		wheel2.Smoke.Enabled = true
		wheel2.Smoke.Opacity = (speedw/50)
		wheel2.Smoke.RiseVelocity = (speedw/100)
	else
		wheel2.Smoke.Enabled = false
	end
	if carSeat.Throttle == -1 then
		carSeat.Parent.Body.Lights.Brake.Material = "Neon"
		carSeat.Parent.Body.Lights.Brake.BrickColor = BrickColor.new("Really red")
	else
		carSeat.Parent.Body.Lights.Brake.Material = "SmoothPlastic"
		carSeat.Parent.Body.Lights.Brake.BrickColor = BrickColor.new("Pearl")
	end
end


Prompt: --[[ FUNCTIONS ]]

Response:
--

Players.PlayerAdded:connect(function(player) -- player Joins Game
	if player.MembershipType == Enum.MembershipType.Premium then -- if they are premium

		--[[ EXTRA PLAYER LEADERSTATS]]--

		local AddedGems = 15 -- how many points to add

		player.leaderstats.Gems.Value = player.leaderstats.Gems.Value + AddedGems -- adding The Points everytime they join the game

		-- || CHANGE NAME HERE ^^^^^					AND CHANGE ^^ IF ITS DIFFERENT || --

		--[[ EXTRA PLAYER GEAR ]]--

		local starterGear = player:WaitForChild("StarterGear") -- starter gear
		local specialTool = ServerStorage:FindFirstChild("Tool"):Clone() -- getting special tool

		specialTool.Parent = starterGear -- setting parent to starter gear

		--[[ EXTRA HEALTH/SUPER POWERS (COMMENT OUT IF YOU DON'T WANT IT) ]] --

		player.CharacterAdded:connect(function(char)
			local humanoid = char:findFirstChild("Humanoid")

			if humanoid then
				humanoid.MaxHealth = 300
				humanoid.Health = humanoid.MaxHealth
				humanoid.WalksSpeed = 100
				humanoid.JumpPower = 250
			end

		end)

	end
end)


Prompt:
--[[
userInput.TouchLongPress:Connect(function(touchPositions, state, processed)
	if (processed or state ~= Enum.UserInputState.Begin) then return end
	Mobile.SwitchView = true
end)
]]

Response: return Mobile


Prompt: -- options -------------------------

Response:
setupmode = "Manual" -- Manual or Auto (if you want to pick what plugins you have yourself or you want it to be automated)
soundplugin = "SoundSuite"	-- StockSound, SoundSuite or 1.5 Sound (no others are supported, sorry!) (MANUAL ONLY)
camkey = "v" -- the key you use for first person camera
level = 50 -- 0% - 100%
exceptions = {"Pedal","Shift"} -- put names of audios to ignore here (AUTO ONLY)


Prompt:
--[=[
	@param name string
	@param inboundMiddleware ClientMiddleware?
	@param outboundMiddleware ClientMiddleware?
	@return ClientRemoteSignal
	Returns a new ClientRemoteSignal that mirrors the matching RemoteSignal created by
	ServerComm with the same matching `name`.
]=]

Response:
function ClientComm:GetSignal(name: string, inboundMiddleware: ClientMiddleware?, outboundMiddleware: ClientMiddleware?)
	return Comm.Client.GetSignal(self._instancesFolder, name, inboundMiddleware, outboundMiddleware)
end


Prompt:
--[[
	ControlModule - This ModuleScript implements a singleton class to manage the
	selection, activation, and deactivation of the current character movement controller.
	This script binds to RenderStepped at Input priority and calls the Update() methods
	on the active controller instances.

	The character controller ModuleScripts implement classes which are instantiated and
	activated as-needed, they are no longer all instantiated up front as they were in
	the previous generation of PlayerScripts.

	2018 PlayerScripts Update - AllYourBlox
--]]

Response:
local ControlModule = {}
ControlModule.__index = ControlModule


Prompt: --[[ END OF SERVICES ]]

Response:
local LocalPlayer = PlayersService.LocalPlayer
while LocalPlayer == nil do
	PlayersService.ChildAdded:wait()
	LocalPlayer = PlayersService.LocalPlayer
end

local PlayerGui = LocalPlayer:WaitForChild("PlayerGui")

local okShouldClipInGameChat, valueShouldClipInGameChat = pcall(function() return UserSettings():IsUserFeatureEnabled("UserShouldClipInGameChat") end)
local shouldClipInGameChat = okShouldClipInGameChat and valueShouldClipInGameChat


Prompt:
--////////////////////////////// Include
--//////////////////////////////////////

Response:
local Chat = game:GetService("Chat")
local clientChatModules = Chat:WaitForChild("ClientChatModules")
local modulesFolder = script.Parent
local moduleChannelsTab = require(modulesFolder:WaitForChild("ChannelsTab"))
local MessageSender = require(modulesFolder:WaitForChild("MessageSender"))
local ChatSettings = require(clientChatModules:WaitForChild("ChatSettings"))
local CurveUtil = require(modulesFolder:WaitForChild("CurveUtil"))


Prompt: --// Firemode Functions

Response:
function CreateBullet(L_200_arg1)
	local L_201_ = L_59_.Position
	local L_202_ = (L_4_.Hit.p - L_201_).unit
	local L_203_ = CFrame.Angles(math.rad(math.random(-L_200_arg1, L_200_arg1)), math.rad(math.random(-L_200_arg1, L_200_arg1)), math.rad(math.random(-L_200_arg1, L_200_arg1)))
	L_202_ = L_203_ * L_202_
	local L_204_ = CFrame.new(L_201_, L_201_ + L_202_)

	local L_205_ = Instance.new("Part", L_101_)
	game.Debris:AddItem(L_205_, 10)
	L_205_.Shape = Enum.PartType.Ball
	L_205_.Size = Vector3.new(1, 1, 12)
	L_205_.Name = "Bullet"
	L_205_.TopSurface = "Smooth"
	L_205_.BottomSurface = "Smooth"
	L_205_.BrickColor = BrickColor.new("Bright green")
	L_205_.Material = "Neon"
	L_205_.CanCollide = false
		--Bullet.CFrame = FirePart.CFrame + (Grip.CFrame.p - Grip.CFrame.p)
	L_205_.CFrame = L_204_

	local L_206_ = Instance.new("Sound")
	L_206_.SoundId = "rbxassetid://341519743"
	L_206_.Looped = true
	L_206_:Play()
	L_206_.Parent = L_205_
	L_206_.Volume = 0.4
	L_206_.MaxDistance = 30

	L_205_.Transparency = 1
	local L_207_ = L_205_:GetMass()
	local L_208_ = Instance.new('BodyForce', L_205_)

	if not L_83_ then
		L_208_.Force = L_24_.BulletPhysics
		L_205_.Velocity = L_202_ * L_24_.BulletSpeed
	else
		L_208_.Force = L_24_.ExploPhysics
		L_205_.Velocity = L_202_ * L_24_.ExploSpeed
	end

	local L_209_ = Instance.new('Attachment', L_205_)
	L_209_.Position = Vector3.new(0.1, 0, 0)
	local L_210_ = Instance.new('Attachment', L_205_)
	L_210_.Position = Vector3.new(-0.1, 0, 0)

	local L_211_ = TracerCalculation()

	if L_24_.TracerEnabled == true and L_211_ then
		local L_212_ = Instance.new('Trail', L_205_)
		L_212_.Attachment0 = L_209_
		L_212_.Attachment1 = L_210_
		L_212_.Transparency = NumberSequence.new(L_24_.TracerTransparency)
		L_212_.LightEmission = L_24_.TracerLightEmission
		L_212_.TextureLength = L_24_.TracerTextureLength
		L_212_.Lifetime = L_24_.TracerLifetime
		L_212_.FaceCamera = L_24_.TracerFaceCamera
		L_212_.Color = ColorSequence.new(L_24_.TracerColor.Color)
	end

	if L_1_:FindFirstChild('Shell') and not L_83_ then
		CreateShell()
	end

	delay(0.2, function()
		L_205_.Transparency = 0
	end)

	return L_205_
end

function CheckForHumanoid(L_213_arg1)
	local L_214_ = false
	local L_215_ = nil
	if L_213_arg1 then
		if (L_213_arg1.Parent:FindFirstChild("Humanoid") or L_213_arg1.Parent.Parent:FindFirstChild("Humanoid")) then
			L_214_ = true
			if L_213_arg1.Parent:FindFirstChild('Humanoid') then
				L_215_ = L_213_arg1.Parent.Humanoid
			elseif L_213_arg1.Parent.Parent:FindFirstChild('Humanoid') then
				L_215_ = L_213_arg1.Parent.Parent.Humanoid
			end
		else
			L_214_ = false
		end
	end
	return L_214_, L_215_
end

function CastRay(L_216_arg1)
	local L_217_, L_218_, L_219_
	local L_220_ = L_56_.Position;
	local L_221_ = L_216_arg1.Position;
	local L_222_ = 0

	local L_223_ = L_83_

	while true do
		L_106_:wait()
		L_221_ = L_216_arg1.Position;
		L_222_ = L_222_ + (L_221_ - L_220_).magnitude
		L_217_, L_218_, L_219_ = workspace:FindPartOnRayWithIgnoreList(Ray.new(L_220_, (L_221_ - L_220_)), IgnoreList);
		local L_224_ = Vector3.new(0, 1, 0):Cross(L_219_)
		local L_225_ = math.asin(L_224_.magnitude) -- division by 1 is redundant
		if L_222_ > L_24_.BulletDecay then
			L_216_arg1:Destroy()
			break
		end
		if L_217_ and (L_217_ and L_217_.Transparency >= 1 or L_217_.CanCollide == false) and L_217_.Name ~= 'Right Arm' and L_217_.Name ~= 'Left Arm' and L_217_.Name ~= 'Right Leg' and L_217_.Name ~= 'Left Leg' and L_217_.Name ~= 'Armor' then
			table.insert(IgnoreList, L_217_)
		end

		if L_217_ then
			L_224_ = Vector3.new(0, 1, 0):Cross(L_219_)
			L_225_ = math.asin(L_224_.magnitude) -- division by 1 is redundant

			L_118_:FireServer(L_218_)

			local L_226_ = CheckForHumanoid(L_217_)
			if L_226_ == false then
				L_216_arg1:Destroy()
				local L_227_ = L_113_:InvokeServer(L_218_, L_224_, L_225_, L_219_, "Part", L_217_)
			elseif L_226_ == true then
				L_216_arg1:Destroy()
				local L_228_ = L_113_:InvokeServer(L_218_, L_224_, L_225_, L_219_, "Human", L_217_)
			end
		end

		if L_217_ and L_223_ then
			L_116_:FireServer(L_218_)
		end

		if L_217_ then
			local L_229_, L_230_ = CheckForHumanoid(L_217_)
			if L_229_ then
				L_111_:FireServer(L_230_)
				if L_24_.AntiTK then
					if game.Players:FindFirstChild(L_230_.Parent.Name) and game.Players:FindFirstChild(L_230_.Parent.Name).TeamColor ~= L_2_.TeamColor or L_230_.Parent:FindFirstChild('Vars') and game.Players:FindFirstChild(L_230_.Parent:WaitForChild('Vars'):WaitForChild('BotID').Value) and L_2_.TeamColor ~= L_230_.Parent:WaitForChild('Vars'):WaitForChild('teamColor').Value then
						if L_217_.Name == 'Head' then
							L_110_:FireServer(L_230_, L_24_.HeadDamage)
							local L_231_ = L_19_:WaitForChild('BodyHit'):clone()
							L_231_.Parent = L_2_.PlayerGui
							L_231_:Play()
							game:GetService("Debris"):addItem(L_231_, L_231_.TimeLength)
						end
						if L_217_.Name ~= 'Head' and not (L_217_.Parent:IsA('Accessory') or L_217_.Parent:IsA('Hat')) then
							if L_217_.Name ~= 'Torso' and L_217_.Name ~= 'HumanoidRootPart' and L_217_.Name ~= 'Armor' then
								L_110_:FireServer(L_230_, L_24_.LimbDamage)
							elseif L_217_.Name == 'Torso' or L_217_.Name == 'HumanoidRootPart' and L_217_.Name ~= 'Armor'  then
								L_110_:FireServer(L_230_, L_24_.BaseDamage)
							elseif L_217_.Name == 'Armor' then
								L_110_:FireServer(L_230_, L_24_.ArmorDamage)
							end
							local L_232_ = L_19_:WaitForChild('BodyHit'):clone()
							L_232_.Parent = L_2_.PlayerGui
							L_232_:Play()
							game:GetService("Debris"):addItem(L_232_, L_232_.TimeLength)
						end
						if (L_217_.Parent:IsA('Accessory') or L_217_.Parent:IsA('Hat')) then
							L_110_:FireServer(L_230_, L_24_.HeadDamage)
							local L_233_ = L_19_:WaitForChild('BodyHit'):clone()
							L_233_.Parent = L_2_.PlayerGui
							L_233_:Play()
							game:GetService("Debris"):addItem(L_233_, L_233_.TimeLength)
						end
					end
				else
					if L_217_.Name == 'Head' then
						L_110_:FireServer(L_230_, L_24_.HeadDamage)
						local L_234_ = L_19_:WaitForChild('BodyHit'):clone()
						L_234_.Parent = L_2_.PlayerGui
						L_234_:Play()
						game:GetService("Debris"):addItem(L_234_, L_234_.TimeLength)
					end
					if L_217_.Name ~= 'Head' and not (L_217_.Parent:IsA('Accessory') or L_217_.Parent:IsA('Hat')) then
						if L_217_.Name ~= 'Torso' and L_217_.Name ~= 'HumanoidRootPart' and L_217_.Name ~= 'Armor' then
							L_110_:FireServer(L_230_, L_24_.LimbDamage)
						elseif L_217_.Name == 'Torso' or L_217_.Name == 'HumanoidRootPart' and L_217_.Name ~= 'Armor' then
							L_110_:FireServer(L_230_, L_24_.BaseDamage)
						elseif L_217_.Name == 'Armor' then
							L_110_:FireServer(L_230_, L_24_.ArmorDamage)
						end
						local L_235_ = L_19_:WaitForChild('BodyHit'):clone()
						L_235_.Parent = L_2_.PlayerGui
						L_235_:Play()
						game:GetService("Debris"):addItem(L_235_, L_235_.TimeLength)
					end
					if (L_217_.Parent:IsA('Accessory') or L_217_.Parent:IsA('Hat')) then
						L_110_:FireServer(L_230_, L_24_.HeadDamage)
						local L_236_ = L_19_:WaitForChild('BodyHit'):clone()
						L_236_.Parent = L_2_.PlayerGui
						L_236_:Play()
						game:GetService("Debris"):addItem(L_236_, L_236_.TimeLength)
					end
				end
			end
		end

		if L_217_ and L_217_.Parent:FindFirstChild("Humanoid") then
			return L_217_, L_218_;
		end
		L_220_ = L_221_;
	end
end

function fireSemi()
	if L_15_ then
		L_69_ = false
		Recoiling = true
		Shooting = true

		--CheckReverb()
		if L_54_ then
			L_54_:FireServer(L_59_:WaitForChild('Fire').SoundId, L_59_)
		else
			L_59_:WaitForChild('Fire'):Play()
		end
		L_109_:FireServer()
		L_102_ = CreateBullet(L_24_.BulletSpread)
		L_103_ = L_103_ - 1
		UpdateAmmo()
		RecoilFront = true
		local L_237_, L_238_ = spawn(function()
			CastRay(L_102_)
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_103_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)

		wait(L_24_.Firerate)

		local L_239_ = JamCalculation()
		if L_239_ then
			L_69_ = false
		else
			L_69_ = true
		end
		Shooting = false
	end
end

function fireExplo()
	if L_15_ then
		L_69_ = false
		Recoiling = true
		Shooting = true
		if L_54_ then
			L_54_:FireServer(L_60_:WaitForChild('Fire').SoundId, L_60_)
		else
			L_60_:WaitForChild('Fire'):Play()
		end
		L_109_:FireServer()
		L_102_ = CreateBullet(L_24_.BulletSpread)
		L_105_ = L_105_ - 1
		UpdateAmmo()
		RecoilFront = true
		local L_240_, L_241_ = spawn(function()
			CastRay(L_102_)
		end)

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)

		L_69_ = false
		Shooting = false
	end
end

function fireShot()
	if L_15_ then
		L_69_ = false
		Recoiling = true
		Shooting = true
		RecoilFront = true
		--CheckReverb()
		if L_54_ then
			L_54_:FireServer(L_59_:WaitForChild('Fire').SoundId, L_59_)
		else
			L_59_:WaitForChild('Fire'):Play()
		end
		L_109_:FireServer()
		for L_243_forvar1 = 1, L_24_.ShotNum do
			spawn(function()
				L_102_ = CreateBullet(L_24_.BulletSpread)
			end)
			local L_244_, L_245_ = spawn(function()
				CastRay(L_102_)
			end)
		end

		for L_246_forvar1, L_247_forvar2 in pairs(L_59_:GetChildren()) do
			if L_247_forvar2.Name:sub(1, 7) == "FlashFX" then
				L_247_forvar2.Enabled = true
			end
		end

		delay(1 / 30, function()
			for L_248_forvar1, L_249_forvar2 in pairs(L_59_:GetChildren()) do
				if L_249_forvar2.Name:sub(1, 7) == "FlashFX" then
					L_249_forvar2.Enabled = false
				end
			end
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_103_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)
		L_103_ = L_103_ - 1
		UpdateAmmo()
		wait(L_24_.Firerate)

		L_76_ = true
		IdleAnim()
		L_76_ = false

		local L_242_ = JamCalculation()
		if L_242_ then
			L_69_ = false
		else
			L_69_ = true
		end

		Shooting = false
	end
end

function fireBoltAction()
	if L_15_ then
		L_69_ = false
		Recoiling = true
		Shooting = true
		--CheckReverb()
		if L_54_ then
			L_54_:FireServer(L_59_:WaitForChild('Fire').SoundId, L_59_)
		else
			L_59_:WaitForChild('Fire'):Play()
		end
		L_109_:FireServer()
		L_102_ = CreateBullet(L_24_.BulletSpread)
		L_103_ = L_103_ - 1
		UpdateAmmo()
		RecoilFront = true
		local L_250_, L_251_ = spawn(function()
			CastRay(L_102_)
		end)

		for L_253_forvar1, L_254_forvar2 in pairs(L_59_:GetChildren()) do
			if L_254_forvar2.Name:sub(1, 7) == "FlashFX" then
				L_254_forvar2.Enabled = true
			end
		end

		delay(1 / 30, function()
			for L_255_forvar1, L_256_forvar2 in pairs(L_59_:GetChildren()) do
				if L_256_forvar2.Name:sub(1, 7) == "FlashFX" then
					L_256_forvar2.Enabled = false
				end
			end
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_103_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)
		wait(L_24_.Firerate)

		L_76_ = true
		BoltBackAnim()
		BoltForwardAnim()
		IdleAnim()
		L_76_ = false

		local L_252_ = JamCalculation()
		if L_252_ then
			L_69_ = false
		else
			L_69_ = true
		end

		Shooting = false
	end
end

function fireAuto()
	while not Shooting and L_103_ > 0 and L_68_ and L_69_ and L_15_ do
		L_69_ = false
		Recoiling = true
		--CheckReverb()
		if L_54_ then
			L_54_:FireServer(L_59_:WaitForChild('Fire').SoundId, L_59_)
		else
			L_59_:WaitForChild('Fire'):Play()
		end
		L_109_:FireServer()
		L_103_ = L_103_ - 1
		UpdateAmmo()
		Shooting = true
		RecoilFront = true
		L_102_ = CreateBullet(L_24_.BulletSpread)
		local L_257_, L_258_ = spawn(function()
			CastRay(L_102_)
		end)

		for L_260_forvar1, L_261_forvar2 in pairs(L_59_:GetChildren()) do
			if L_261_forvar2.Name:sub(1, 7) == "FlashFX" then
				L_261_forvar2.Enabled = true
			end
		end

		delay(1 / 30, function()
			for L_262_forvar1, L_263_forvar2 in pairs(L_59_:GetChildren()) do
				if L_263_forvar2.Name:sub(1, 7) == "FlashFX" then
					L_263_forvar2.Enabled = false
				end
			end
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_103_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)
		wait(L_24_.Firerate)

		local L_259_ = JamCalculation()
		if L_259_ then
			L_69_ = false
		else
			L_69_ = true
		end

		Shooting = false
	end
end

function fireBurst()
	if not Shooting and L_103_ > 0 and L_68_ and L_15_ then
		for L_264_forvar1 = 1, L_24_.BurstNum do
			if L_103_ > 0 and L_68_ then
				L_69_ = false
				Recoiling = true
			--CheckReverb()
				if L_54_ then
					L_54_:FireServer(L_59_:WaitForChild('Fire').SoundId, L_59_)
				else
					L_59_:WaitForChild('Fire'):Play()
				end
				L_109_:FireServer()
				L_102_ = CreateBullet(L_24_.BulletSpread)
				local L_265_, L_266_ = spawn(function()
					CastRay(L_102_)
				end)

				for L_268_forvar1, L_269_forvar2 in pairs(L_59_:GetChildren()) do
					if L_269_forvar2.Name:sub(1, 7) == "FlashFX" then
						L_269_forvar2.Enabled = true
					end
				end

				delay(1 / 30, function()
					for L_270_forvar1, L_271_forvar2 in pairs(L_59_:GetChildren()) do
						if L_271_forvar2.Name:sub(1, 7) == "FlashFX" then
							L_271_forvar2.Enabled = false
						end
					end
				end)

				if L_24_.CanBolt == true then
					BoltingBackAnim()
					delay(L_24_.Firerate / 2, function()
						if L_24_.CanSlideLock == false then
							BoltingForwardAnim()
						elseif L_24_.CanSlideLock == true then
							if L_103_ > 0 then
								BoltingForwardAnim()
							end
						end
					end)
				end

				L_103_ = L_103_ - 1
				UpdateAmmo()
				RecoilFront = true
				delay(L_24_.Firerate / 2, function()
					Recoiling = false
					RecoilFront = false
				end)
				wait(L_24_.Firerate)

				local L_267_ = JamCalculation()
				if L_267_ then
					L_69_ = false
				else
					L_69_ = true
				end

			end
			Shooting = true
		end
		Shooting = false
	end
end

function Shoot()
	if L_15_ and L_69_ then
		if L_92_ == 1 then
			fireSemi()
		elseif L_92_ == 2 then
			fireAuto()
		elseif L_92_ == 3 then
			fireBurst()
		elseif L_92_ == 4 then
			fireBoltAction()
		elseif L_92_ == 5 then
			fireShot()
		elseif L_92_ == 6 then
			fireExplo()
		end
	end
end


Prompt: -- there's plenty of room for more

Response: return module


Prompt: --Set up event for when the server is shutting down.

Response:
StartShutdown.OnClientEvent:Connect(function()
	--Create the Gui and have it semi-transparent for 1 second.
	local Gui,Background = CreateTeleportScreen()
	Background.BackgroundTransparency = 0.5
	Gui.Parent = game.Players.LocalPlayer:WaitForChild("PlayerGui")
	wait(1)

	--Tween the transparency to 0.
	local Start = tick()
	local Time = 0.5
	while tick() - Start < Time do
		local Dif = tick() - Start
		local Ratio = Dif/Time
		Background.BackgroundTransparency = 0.5 * (1 - Ratio)
		RenderStepped:Wait()
	end
	Background.BackgroundTransparency = 0
end)


Prompt:
--[=[
	Constructs a new Signal that wraps around an RBXScriptSignal.

	@param rbxScriptSignal RBXScriptSignal -- Existing RBXScriptSignal to wrap
	@return Signal

	For example:
	```lua
	local signal = Signal.Wrap(workspace.ChildAdded)
	signal:Connect(function(part) print(part.Name .. " added") end)
	Instance.new("Part").Parent = workspace
	```
]=]

Response:
function Signal.Wrap<T...>(rbxScriptSignal: RBXScriptSignal): Signal<T...>
	assert(
		typeof(rbxScriptSignal) == "RBXScriptSignal",
		"Argument #1 to Signal.Wrap must be a RBXScriptSignal; got " .. typeof(rbxScriptSignal)
	)
	local signal = Signal.new()
	signal._proxyHandler = rbxScriptSignal:Connect(function(...)
		signal:Fire(...)
	end)
	return signal
end


Prompt:
--health.Changed:connect(function()
--root.Velocity = Vector3.new(0,5000,0)
--end)

Response:
local anims = {}
local lastAttack= tick()

local target,targetType

local lastLock = tick()

local fleshDamage = 50
local structureDamage = 100

local path = nil

for _,animObject in next,animations do
anims[animObject.Name] = hum:LoadAnimation(animObject)
end

function Attack(thing,dmg)
if tick()-lastAttack > 2 then
hum:MoveTo(root.Position)
lastAttack = tick()
anims.AntWalk:Stop()
anims.AntMelee:Play()

if thing.ClassName == "Player" then
root.FleshHit:Play()
ant:SetPrimaryPartCFrame(CFrame.new(root.Position,Vector3.new(target.Character.PrimaryPart.Position.X,root.Position.Y,target.Character.PrimaryPart.Position.Z)))

elseif thing.ClassName == "Model" then
root.StructureHit:Play()
end

rep.Events.NPCAttack:Fire(thing,dmg)
end
end

function Move(point)
hum:MoveTo(point)
if not anims.AntWalk.IsPlaying then
anims.AntWalk:Play()
end
end

function ScanForPoint()
local newPoint
local rayDir = Vector3.new(math.random(-100,100)/100,0,math.random(-100,100)/100)
local ray = Ray.new(root.Position,rayDir*math.random(10,50),ant)
local part,pos = workspace:FindPartOnRay(ray)
Move(pos)
enRoute = true
end


Prompt: --Positions

Response:
local xpos = script.Parent.Position.X
local ypos = script.Parent.Position.Y
local zpos = script.Parent.Position.Z

local size = Vector3.new(xsize, ysize, zsize)
local newsize = Vector3.new(xsize + 0.1, ysize + 0.1, zsize + 0.1)

while true do
	script.Parent.Size = newsize
	script.Parent.Position = Vector3.new(xpos,ypos + 0.05,zpos)
	wait(0.2)
	script.Parent.Size = size
	script.Parent.Position = Vector3.new(xpos,ypos,zpos)
	wait(0.2)
end


Prompt:
--[=[
	@param instance Instance
	@return RBXScriptConnection
	Attaches the Janitor to a Roblox instance. Once this
	instance is removed from the game (parent or ancestor's
	parent set to `nil`), the Janitor will automatically
	clean up.

	:::caution
	Will throw an error if `instance` is not a descendant
	of the game hierarchy.
	:::
]=]

Response:
function Janitor:AttachToInstance(instance: Instance)
	assert(instance:IsDescendantOf(game), "Instance is not a descendant of the game hierarchy")
	return self:Connect(instance.AncestryChanged, function(_child, parent)
		if not parent then
			self:Destroy()
		end
	end)
end


Prompt:
--		if rot>-math.pi/8 then
--			rot=rot-math.pi/20
--		end

Response:
		spd.velocity=chg+(engine.CFrame.lookVector-Vector3.new(0.5,0,0))*inc
		--gyro.cframe=mouse.Hit
		--gyro.cframe=gyro.cframe*CFrame.Angles(0,-math.pi/5,rot)
	else
		rot=0
	end

end


Prompt:
--[[
	ClassicCamera - Classic Roblox camera control module
	2018 Camera Update - AllYourBlox

	Note: This module also handles camera control types Follow and Track, the
	latter of which is currently not distinguished from Classic
--]]


Prompt: --Scripted by DermonDarble

Response:
local userInputService = game:GetService("UserInputService")
local player = game.Players.LocalPlayer
local character = player.Character
local humanoid = character.Humanoid
local horse = script:WaitForChild("Horse").Value

local horseGui = script:WaitForChild("HorseGui")
horseGui.Parent = player.PlayerGui

humanoid:SetStateEnabled(Enum.HumanoidStateType.Jumping, false)

local rideAnimation = humanoid:LoadAnimation(horse.Animations.Ride)
rideAnimation:Play()

local movement = Vector3.new(0, 0, 0)

userInputService.InputBegan:connect(function(inputObject, gameProcessedEvent)
	if not gameProcessedEvent then
		if inputObject.KeyCode == Enum.KeyCode.W or inputObject.KeyCode == Enum.KeyCode.Up then
			movement = Vector3.new(movement.X, movement.Y, -1)
		elseif inputObject.KeyCode == Enum.KeyCode.S or inputObject.KeyCode == Enum.KeyCode.Down then
			movement = Vector3.new(movement.X, movement.Y, 1)
		elseif inputObject.KeyCode == Enum.KeyCode.A or inputObject.KeyCode == Enum.KeyCode.Left then
			movement = Vector3.new(-1, movement.Y, movement.Z)
		elseif inputObject.KeyCode == Enum.KeyCode.D or inputObject.KeyCode == Enum.KeyCode.Right then
			movement = Vector3.new(1, movement.Y, movement.Z)
		elseif inputObject.KeyCode == Enum.KeyCode.Space then
			local ray = Ray.new(horse.HumanoidRootPart.Position + Vector3.new(0, -4.3, 0), Vector3.new(0, -1, 0))
			local hit, position = game.Workspace:FindPartOnRay(ray, horse)
			if hit and hit.CanCollide then
				horse.Humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
			end
		elseif inputObject.KeyCode == Enum.KeyCode.LeftShift then
			humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
		end
	end
end)

userInputService.InputEnded:connect(function(inputObject, gameProcessedEvent)
	if not gameProcessedEvent then
		if inputObject.KeyCode == Enum.KeyCode.W or inputObject.KeyCode == Enum.KeyCode.Up then
			if movement.Z < 0 then
				movement = Vector3.new(movement.X, movement.Y, 0)
			end
		elseif inputObject.KeyCode == Enum.KeyCode.S or inputObject.KeyCode == Enum.KeyCode.Down then
			if movement.Z > 0 then
				movement = Vector3.new(movement.X, movement.Y, 0)
			end
		elseif inputObject.KeyCode == Enum.KeyCode.A or inputObject.KeyCode == Enum.KeyCode.Left then
			if movement.X < 0 then
				movement = Vector3.new(0, movement.Y, movement.Z)
			end
		elseif inputObject.KeyCode == Enum.KeyCode.D or inputObject.KeyCode == Enum.KeyCode.Right then
			if movement.X > 0 then
				movement = Vector3.new(0, movement.Y, movement.Z)
			end
		end
	end
end)

spawn(function()
	while horse.Seat.Occupant == humanoid do
		game:GetService("RunService").RenderStepped:wait()
		horse.Humanoid:Move(movement, true)
	end
	horseGui:Destroy()
	humanoid:SetStateEnabled(Enum.HumanoidStateType.Jumping, true)
	horse.Humanoid:Move(Vector3.new())
	rideAnimation:Stop()
	script:Destroy()
end)


Prompt:
-- setup emote chat hook (not nessessary)
--[[game.Players.LocalPlayer.Chatted:connect(function(msg)
	local emote = ""
	if msg == "/e dance" then
		emote = dances[math.random(1, #dances)]
	elseif (string.sub(msg, 1, 3) == "/e ") then
		emote = string.sub(msg, 4)
	elseif (string.sub(msg, 1, 7) == "/emote ") then
		emote = string.sub(msg, 8)
	end

	if (pose == "Standing" and emoteNames[emote] ~= nil) then
		playAnimation(emote, 0.1, Humanoid)
	end

end)]]


Response:
Displays = 3 -- Sets how many displays this scripts will use...
DisplayColor = Color3.fromRGB(33, 84, 185)
UColor = Color3.fromRGB(33, 84, 185)
DColor = Color3.fromRGB(33, 84, 185)
ArrowDelay = 0.05


Prompt: --Rescripted by Luckymaxer

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

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

Speed = 250
Duration = 1

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

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

PointLight = Handle:WaitForChild("PointLight")

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

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

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

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

function TagHumanoid(humanoid, player)
	local Creator_Tag = Instance.new("ObjectValue")
	Creator_Tag.Name = "creator"
	Creator_Tag.Value = player
	Debris:AddItem(Creator_Tag, 2)
	Creator_Tag.Parent = humanoid
end

function UntagHumanoid(humanoid)
	for i, v in pairs(humanoid:GetChildren()) do
		if v:IsA("ObjectValue") and v.Name == "creator" then
			v:Destroy()
		end
	end
end

function FindCharacterAncestor(Parent)
	if Parent and Parent ~= game:GetService("Workspace") then
		local humanoid = Parent:FindFirstChild("Humanoid")
		if humanoid then
			return Parent, humanoid
		else
			return FindCharacterAncestor(Parent.Parent)
		end
	end
	return nil
end

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

function SelectionBoxify(Object)
	local SelectionBox = Instance.new("SelectionBox")
	SelectionBox.Adornee = Object
	SelectionBox.Color = BrickColor.new("Toothpaste")
	SelectionBox.Parent = Object
	return SelectionBox
end

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

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

function Dematerialize(character, humanoid, FirstPart)
	if not character or not humanoid then
		return
	end

	humanoid.WalkSpeed = 0

	local Parts = {}

	for i, v in pairs(character:GetChildren()) do
		if v:IsA("BasePart") then
			v.Anchored = true
			table.insert(Parts, v)
		elseif v:IsA("LocalScript") or v:IsA("Script") then
			v:Destroy()
		end
	end

	local SelectionBoxes = {}

	local FirstSelectionBox = SelectionBoxify(FirstPart)
	Light(FirstPart)
	wait(0.05)

	for i, v in pairs(Parts) do
		if v ~= FirstPart then
			table.insert(SelectionBoxes, SelectionBoxify(v))
			Light(v)
		end
	end

	local ObjectsWithTransparency = GetTransparentsRecursive(character)
	FadeOutObjects(ObjectsWithTransparency, 0.1)

	wait(0.5)

	character:BreakJoints()
	humanoid.Health = 0

	Debris:AddItem(character, 2)

	local FadeIncrement = 0.05
	Delay(0.2, function()
		FadeOutObjects({FirstSelectionBox}, FadeIncrement)
		if character and character.Parent then
			character:Destroy()
		end
	end)
	FadeOutObjects(SelectionBoxes, FadeIncrement)
end

function Touched(Projectile, Hit)
	if not Hit or not Hit.Parent then
		return
	end
	local character, humanoid = FindCharacterAncestor(Hit)
	if character and humanoid and character ~= Character then
		local ForceFieldExists = false
		for i, v in pairs(character:GetChildren()) do
			if v:IsA("ForceField") then
				ForceFieldExists = true
			end
		end
		if not ForceFieldExists then
			if Projectile then
				local HitFadeSound = Projectile:FindFirstChild(Sounds.HitFade.Name)
				local torso = humanoid.Torso
				if HitFadeSound and torso then
					HitFadeSound.Parent = torso
					HitFadeSound:Play()
				end
			end
			Dematerialize(character, humanoid, Hit)
		end
		if Projectile and Projectile.Parent then
			Projectile:Destroy()
		end
	end
end

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

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

		InvokeClient("PlaySound", Sounds.Fire)

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

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

		wait(0.6) -- FireSound length

		InvokeClient("PlaySound", Sounds.Reload)

		wait(0.75) -- ReloadSound length

		Tool.Enabled = true
	end
end

function Unequipped()

end

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

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


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

Response:
local function OnActivated()
	local myModel = MyPlayer.Character
	if Tool.Enabled and myModel and myModel:FindFirstChildOfClass("Humanoid") and myModel.Humanoid.Health > 0 then
		Tool.Enabled = false
		script.Parent.Handle.FireSound:Play()
		local Pos = MouseLoc:InvokeClient(MyPlayer)
		-- Create a clone of Rocket and set its color
		local rocketClone = Rocket:Clone()
		DebrisService:AddItem(rocketClone, 30)
		rocketClone.BrickColor = MyPlayer.TeamColor

		-- Position the rocket clone and launch!
		local spawnPosition = (ToolHandle.CFrame * CFrame.new(5, 0, 0)).p
		rocketClone.CFrame = CFrame.new(spawnPosition, Pos) --NOTE: This must be done before assigning Parent
		rocketClone.Velocity = rocketClone.CFrame.lookVector * ROCKET_SPEED --NOTE: This should be done before assigning Parent
		rocketClone.Parent = workspace
		rocketClone:SetNetworkOwner(nil)

		wait(RELOAD_TIME)

		Tool.Enabled = true
		script.Parent.Handle.Ready:Play()
	end
end

function OnEquipped()
	MyPlayer = PlayersService:GetPlayerFromCharacter(Tool.Parent)
end


Prompt: --[[ Settings Changed Connections ]]

Response:
--
LocalPlayer.Changed:connect(function(property)
	if lastInputType == Enum.UserInputType.Touch and property == 'DevTouchMovementMode' then
		ControlState:SwitchTo(ControlModules.Touch)
	elseif UserInputService.KeyboardEnabled and property == 'DevComputerMovementMode' then
		ControlState:SwitchTo(ControlModules.Keyboard)
	end
end)

GameSettings.Changed:connect(function(property)
	if not IsUserChoice then return end
	if property == 'TouchMovementMode' or property == 'ComputerMovementMode' then
		UserMovementMode = GameSettings[property]
		if property == 'ComputerMovementMode' then
			ControlState:SwitchTo(ControlModules.Keyboard)
		end
	end
end)


Prompt:
--vehicle.Nose.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, 0, -1)) end)
--vehicle.Bumper_Front.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, 0, -1)) end)
--vehicle.Bumper_Back.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, 0, 1)) end)
--vehicle.Tailgate.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, 0, 1)) end)
--vehicle.ExhaustPipe.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, 0, 1)) end)

Response:
frontForceField.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, -1, 0)) end)
backForceField.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, 1, 0)) end)

vehicle.Wheel_BackLeft.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, 0, -1)) end)
vehicle.Wheel_FrontLeft.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, 0, -1)) end)
vehicle.Wheel_BackRight.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, 0, 1)) end)
vehicle.Wheel_FrontRight.Touched:connect(function (hitPart) onTouch(hitPart, Vector3.new(0, 0, 1)) end)

local vehicleDamaged = false
function checkIfVehicleIsDamaged()
	if (not frontForceField.Parent or not backForceField.Parent) and not vehicleDamaged and allowDamage then
		vehicleDamaged = true
		script.IsDamaged.Value = true
		vehicle.VehicleScript.Disabled = true
		vehicleSmoke.Enabled = true
		vehicle.VehicleSeat.MaxSpeed = 0
		vehicle.ExhaustPipe.Smoke.Enabled = false
		-- Break Joints
		vehicle.Wheel_BackLeft:BreakJoints()
		vehicle.Wheel_FrontLeft:BreakJoints()
		vehicle.Wheel_BackRight:BreakJoints()
		vehicle.Wheel_FrontRight:BreakJoints()
		hood:BreakJoints()
	end
end

vehicle.ChildRemoved:connect(checkIfVehicleIsDamaged)


Response:
	-- Command Settings
										--- List of user IDs able to use regen and clear commands
	,HostList = {						--- Game owners automatically have perms, commands always work in studio
		57158149,
	}
	,HostRank = 255					--- If the game is group owned, anyone above this rank number will automatically have command perms
	,CommandPrefix = "/"

	--	Command List
	--		/ClearGuns		Removes dropped guns from workspace
	--		/ResetGlass		Replaces broken glass and removes shards
	--		/ResetLights	Fixes broken lights
	--		/ResetAll		Fixes both lights and glass
	--		/ACSlog			View kill log

	-- Keybinds

	,LeanLeft = Enum.KeyCode.Q
	,LeanRight = Enum.KeyCode.E
	,Crouch = Enum.KeyCode.C
	,StandUp = Enum.KeyCode.X
	,Sprint = Enum.KeyCode.LeftShift
	,SlowWalk = Enum.KeyCode.Z

	,Reload = Enum.KeyCode.R
	,FireMode = Enum.KeyCode.V
	,CheckMag = Enum.KeyCode.M
	,ZeroUp = Enum.KeyCode.RightBracket
	,ZeroDown = Enum.KeyCode.LeftBracket
	,DropGun = Enum.KeyCode.Backspace

	,SwitchSights = Enum.KeyCode.T
	,ToggleLight = Enum.KeyCode.J
	,ToggleLaser = Enum.KeyCode.H
	,ToggleBipod = Enum.KeyCode.B

	,Interact = Enum.KeyCode.G
	,ToggleNVG = Enum.KeyCode.N

	-- Effects Settings

	,BreakLights = true					--- Can break any part named "Light" with a light inside of it

	,BreakGlass = true					--- Can shatter glass with bullets
	,GlassName = "Glass"				--- Name of parts that can shatter
	,ShardDespawn = 60					--- How long glass stays before being removed

	,ShellLimit = 100					--- Max number of ejected shells that can be on the ground
	,ShellDespawn = 0					--- Shells will be deleted after being on the ground for this amount of time, 0 = No despawn

	-- Weapon Drop Settings

	,WeaponDropping = true				--- Enable weapon dropping with backspace?
	,WeaponCollisions = true			--- Allow weapons to collide with each other
	,SpawnStacking = false				--- Enabling this allows multiple guns to be spawned by one spawner, causing them to 'stack'
	,MaxDroppedWeapons = 10				--- Max number of weapons that can be dropped at once
	,PickupDistance = 7					--- Max distance from which a player can pickup guns

	,DropWeaponsOnDeath = false			--- Drop all guns on death
	,DropWeaponsOnLeave = false			--- Drop all guns when the player leaves the game

	,TimeDespawn = true					--- Enable a timer for weapon deletion
	,WeaponDespawnTime = 30			--- If TimeDespawn is enabled, dropped guns are deleted after this time

	-- Misc Settings

	,AmmoBoxDespawn = 300				--- Max time ammo boxes will be on the ground

	,EquipInVehicleSeat = true			--- Allow players to use weapons while operating a vehicle
	,EquipInSeat = true					--- Allow players to use weapons in regular seats
	,DisableInSeat = true				--- Prevents movement keybinds from messing with vehicle scripts like blizzard

	,WeaponWeight = true				--- Enables the WeaponWeight setting in guns, slowing down the player while a gun is equipped

	,HeadMovement = true				--- Toggles head movement
}

return ServerConfig


Prompt: --Made by Luckymaxer

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

Debris = game:GetService("Debris")

WindDirection = script:FindFirstChild("WindDirection")
Force = script:FindFirstChild("Force")

Parts = {}

BaseColor = BrickColor.new("Really red")
Color = BaseColor.Color

Gravity = 196.20

Duration = 3

Classes = {
	BasePart = {
		BrickColor = BaseColor,
		Material = Enum.Material.Plastic,
		Reflectance = 0,
		Transparency = 0.75,
	},
	FileMesh = {
		TextureId = "",
	},
	DataModelMesh = {
		VertexColor = Vector3.new(Color.r, Color.g, Color.b),
	},
	CharacterMesh = {
		BaseTextureId = 0,
		OverlayTextureId = 0,
	},
	Shirt = {
		ShirtTemplate = "",
	},
	Pants = {
		PantsTemplate = "",
	},
	FaceInstance = {
		Texture = "",
	},
	Sparkles = {
		SparkleColor = Color,
		Enabled = false,
	},
	Fire = {
		Color = Color,
		SecondaryColor = Color,
		Enabled = false,
	},
	Smoke = {
		Color = Color,
		Enabled = false,
	},
	Light = {
		Color = Color,
		Enabled = false,
	},
	ParticleEmitter = {
		Color = ColorSequence.new(Color, Color),
		Enabled = false,
	}
}

Fire = script:FindFirstChild("Fire")

Objects = {}
RemovedObjects = {}
FakeParts = {}
Hats = {}
Tools = {}
Particles = {}

function DestroyScript()
	Debris:AddItem(script, 0.5)
end

function TweenNumber(Start, Goal, Time)
	return ((Goal - Start) / Time)
end

function Decorate(Object)
	local ObjectData = {
		Object = nil,
		Properties = {},
	}
	for i, v in pairs(Classes) do
		if Object:IsA(i) then
			if Object:IsA("CharacterMesh") then
				local Mesh = Instance.new("SpecialMesh")
				Mesh.MeshType = Enum.MeshType.FileMesh
				Mesh.MeshId = ("http://www.roblox.com/asset/?id=" .. Object.MeshId)
				for ii, vv in pairs(Character:GetChildren()) do
					if vv:IsA("BasePart") and Object.BodyPart.Name == string.gsub(vv.Name, " ", "") then
						Mesh.Parent = vv
						table.insert(RemovedObjects, {Object = Object, NewObject = Mesh, Parent = Object.Parent})
						Object.Parent = nil
					end
				end
			elseif Object:IsA("BasePart") and Object.Transparency >= 1 then
			else
				ObjectData.Object = Object
				for ii, vv in pairs(v) do
					local PropertyValue = nil
					local PropertyValueSet = false
					pcall(function()
						PropertyValue = Object[ii]
						PropertyValueSet = true
						Object[ii] = vv
					end)
					if PropertyValueSet then
						ObjectData.Properties[ii] = PropertyValue
					end
				end
			end
		end
	end
	table.insert(Objects, ObjectData)
end

function Redesign(Parent)
	for i, v in pairs(Parent:GetChildren()) do
		if v ~= script then
			Decorate(v)
			Redesign(v)
		end
	end
end

if not Humanoid or not WindDirection then
	DestroyScript()
	return
end

for i, v in pairs(Character:GetChildren()) do
	if v:IsA("Hat") or v:IsA("Tool") then
		local FakeObject = v:Clone()
		Decorate(FakeObject)
		table.insert(((v:IsA("Hat") and Hats) or Tools), v)
		for ii, vv in pairs(FakeObject:GetChildren()) do
			if vv:IsA("BasePart") then
				local FakePart = vv:Clone()
				FakePart.Name = v.Name
				table.insert(FakeParts, FakePart)
				FakePart.Parent = Character
				FakePart.CFrame = vv.CFrame
			end
		end
	end
end

Humanoid:UnequipTools()

for i, v in pairs({Hats, Tools}) do
	for ii, vv in pairs(v) do
		vv.Parent = nil
	end
end

Redesign(Character)

local GhostModel = Instance.new("Model")
GhostModel.Name = "GhostModel"

for i, v in pairs(Character:GetChildren()) do
	if v:IsA("BasePart") then
		if v.Name ~= "HumanoidRootPart" then
			local FakePart = v:Clone()
			FakePart.Name = "Part"
			FakePart.CanCollide = false
			for ii, vv in pairs(FakePart:GetChildren()) do
				if not vv:IsA("DataModelMesh") then
					vv:Destroy()
				end
			end
			table.insert(FakeParts, FakePart)
			local Mass = (v:GetMass() * Gravity ^ 2)
			local BodyVelocity = Instance.new("BodyVelocity")
			BodyVelocity.maxForce = Vector3.new(Mass, Mass, Mass)
			BodyVelocity.velocity = (WindDirection.Value * Force.Value)
			BodyVelocity.Parent = FakePart
			FakePart.Parent = GhostModel
			local FireParticle = Fire:Clone()
			FireParticle.Enabled = true
			table.insert(Particles, FireParticle)
			FireParticle.Parent = FakePart
		end
		v:Destroy()
	end
end

Spawn(function()
	local Start = Classes.BasePart.Transparency
	local End = 1
	local Time = 0.75
	local Rate = (1 / 30)
	local Frames = (Time / Rate)
	for i = 1, Frames do
		local Transparency = (Start + TweenNumber(Start, End, (Frames / (i + 1))))
		for ii, vv in pairs(FakeParts) do
			if vv and vv.Parent then
				vv.Transparency = Transparency
			end
		end
		wait(Rate)
	end
	for i, v in pairs(Particles) do
		v.Enabled = false
	end
end)

Debris:AddItem(GhostModel, 5)
GhostModel.Parent = game:GetService("Workspace")


Prompt: --- FUNCTIONS ---

Response:
local isFreecam = false
local MouseListening = false
Freecam = function()
	UserInputService.MouseIconEnabled = not UserInputService.MouseIconEnabled

	if not isFreecam then
		isFreecam = not isFreecam

		Camera.CameraType = "Scriptable"
		-- When mouse button 1 is held down go move camera forward in direction its facing, go backwards with mouse button 2
		MouseListening = true
		while MouseListening do
			task.wait()

			local MouseInstancePos = Mouse.Hit.Position
			-- Look at MouseInstancePos
			local Final = CFrame.new(Camera.CFrame.Position, MouseInstancePos)

			local DownButtons = UserInputService:GetMouseButtonsPressed()
			if #DownButtons ~= 0 then
				if DownButtons[1].UserInputType == Enum.UserInputType.MouseButton1 then
					Final *= CFrame.new(0, 0, -5)
				elseif DownButtons[1].UserInputType == Enum.UserInputType.MouseButton2 then
					Final *= CFrame.new(0, 0, 5)
				end
			end

			TweenService:Create(Camera, TweenInfo.new(0.25), {CFrame = Final}):Play()
		end
	else
		isFreecam = not isFreecam
		MouseListening = false
		Player.Character.HumanoidRootPart.CFrame = Camera.CFrame
		Camera.CameraType = "Custom"
	end
end

ShiftLockToggle = function()

	Locked = not Locked

	-- Fix HRP to the camera direction
	local HumanoidRootPart = Player.Character.HumanoidRootPart
	local previousAngle = 0
	while Locked do
		task.wait()
		local cameraForward = Camera.CFrame.LookVector
		cameraForward = Vector3.new(cameraForward.x, 0, cameraForward.z).Unit

		local angle = math.atan2(-cameraForward.x, -cameraForward.z)
		HumanoidRootPart.CFrame = CFrame.new(HumanoidRootPart.Position) * CFrame.Angles(0, angle, 0)
	end

end

Run = function(Humanoid, KeyCode)
	Humanoid.WalkSpeed = 23.5

	local RunAnimation = Humanoid:LoadAnimation(script.Run)
	RunAnimation:Play()

	if not isMobile then
		repeat task.wait() until not UserInputService:IsKeyDown(KeyCode)
	else
		UserInputService.InputEnded:Wait()
	end
	Humanoid.WalkSpeed = 16

	RunAnimation:Stop()
	RunAnimation:Remove()
end

Input = function(Input, Typing)
	if Typing then return end

	repeat task.wait() until Player.Character
	local Character = Player.Character
	local Humanoid = Character:WaitForChild("Humanoid")

	local KeyCode = Input.KeyCode

	if table.find(DirectionalKeys, KeyCode) then

		if (tick() - LastDirectional < 0.2) and LastKeyDown == KeyCode then
			Run(Humanoid, KeyCode)
		end

		LastDirectional = tick()
	end

	LastKeyDown = KeyCode

end


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 = "epic", 	ID = 27697743}, -- Zero Project - Gothic
			{Name = "halo", 	ID = 1034065}, -- Halo Theme
			{Name = "cursed", 	ID = 1372257}, -- Cursed Abbey
			{Name = "extreme", 	ID = 11420933}, -- TOPW
			{Name = "tacos", 	ID = 142376088}, -- Parry Gripp - Raining Tacos
			{Name = "awaken", 	ID = 27697277}, -- Positively Dark - Awakening
			{Name = "mario", 	ID = 1280470}, -- SM64 Theme
			{Name = "chrono", 	ID = 1280463}, -- Chrono Trigger Theme
			{Name = "dotr", 	ID = 11420922}, -- DOTR | ▼ --- ▼ I do not speak tags
			{Name = "entertain", 	ID = 27697267}, -- ##### ###### - Entertainer Rag
			{Name = "fantasy", 	ID = 1280473}, -- FFVII Battle AC
			{Name = "final", 	ID = 1280414}, -- Final Destination
			{Name = "emblem", 	ID = 1372259}, -- Fire Emblem
			{Name = "flight", 	ID = 27697719}, -- Daniel Bautista - Flight of the Bumblebee
			{Name = "gothic", 	ID = 27697743}, -- Zero Project - Gothic
			{Name = "hiphop", 	ID = 27697735}, -- Jeff Syndicate - Hip Hop
			{Name = "intro", 	ID = 27697707}, -- Daniel Bautista - Intro
			{Name = "mule", 	ID = 1077604}, -- M.U.L.E
			{Name = "film", 	ID = 27697713}, -- Daniel Bautista - Music for a Film
			{Name = "schala", 	ID = 5985787}, -- Schala
			{Name = "tunnel",	ID = 9650822}, -- S4Tunnel
			{Name = "spanish", 	ID = 5982975}, -- TheBuzzer
			{Name = "venom", 	ID = 1372262}, -- Star Fox Theme
			{Name = "guitar", 	ID = 5986151}, -- 5986151
			{Name = "hardstyle", 	ID = 1839246774}, -- Hardstyle
			{Name = "crabrave", 	ID = 5410086218}, -- Noisestorm - Crab Rave
		};

		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: -- perform the update loop

Response:
if rigtype == "R15" then

	-- do the r15 update loop
	stepped_con = game:GetService("RunService").RenderStepped:Connect(function()
		-- checkfirstperson() checks if camera is first person and enables/disables the viewmodel accordingly
		checkfirstperson()
		-- update loop
		if isfirstperson == true then
			-- make arms visible
			visiblearms(true)
			-- update walk sway if we are walking
			if isrunning == true and includewalksway and humanoid:GetState() ~= Enum.HumanoidStateType.Freefall and humanoid:GetState() ~= Enum.HumanoidStateType.Landed then
				walksway = walksway:lerp(
					CFrame.new(

						(0.1*swaysize) * math.sin(tick() * (2 * humanoid.WalkSpeed/4)),
						(0.1*swaysize) * math.cos(tick() * (4 * humanoid.WalkSpeed/4)),
						0

					)*
						CFrame.Angles(

							0,
							0,
							(-.05*swaysize) * math.sin(tick() * (2 * humanoid.WalkSpeed/4))

						)
					,0.1*sensitivity)
			else
				walksway = walksway:Lerp(CFrame.new(), 0.05*sensitivity)
			end
			--
			local delta = uis:GetMouseDelta()
			if includecamerasway then
				sway = sway:Lerp(Vector3.new(delta.X,delta.Y,delta.X/2), 0.1*sensitivity)
			end
			--
			if includestrafe then
				strafesway = strafesway:Lerp(CFrame.Angles(0,0,-rootpart.CFrame.rightVector:Dot(humanoid.MoveDirection)/(10/swaysize)), 0.1*sensitivity)
			end
			--
			if includejumpsway then
				jumpsway = jumpswaygoal.Value
			end
			-- update animation transform for viewmodel
			rightshoulderclone.Transform = rightshoulder.Transform
			leftshoulderclone.Transform = leftshoulder.Transform
			if firstperson_waist_movements_enabled then
				waistclone.Transform = waist.Transform
			end
			-- cframe the viewmodel
			local finalcf = (camera.CFrame*walksway*jumpsway*strafesway*CFrame.Angles(math.rad(sway.Y*swaysize),math.rad(sway.X*swaysize)/10,math.rad(sway.Z*swaysize)/2))+(camera.CFrame.UpVector*(-1.7-(headoffset.Y+(aimoffset.Value.Y))))+(camera.CFrame.LookVector*(headoffset.Z+(aimoffset.Value.Z)))+(camera.CFrame.RightVector*(-headoffset.X-(aimoffset.Value.X)+(-(sway.X*swaysize)/75)))
			viewmodel:SetPrimaryPartCFrame(finalcf)
		end
	end)
elseif rigtype == "R6" then

	-- do the R6 update loop
	stepped_con = game:GetService("RunService").RenderStepped:Connect(function()
		swaysize = script.WalkSwayMultiplier.Value
		-- checkfirstperson() checks if camera is first person and enables/disables the viewmodel accordingly
		checkfirstperson()
		-- update loop
		if isfirstperson == true then
			-- make arms visible
			visiblearms(true)
			-- update walk sway if we are walking
			if isrunning == true and includewalksway and humanoid:GetState() ~= Enum.HumanoidStateType.Freefall and humanoid:GetState() ~= Enum.HumanoidStateType.Landed then
				walksway = walksway:lerp(
					CFrame.new(

						(0.07*swaysize) * math.sin(tick() * (2 * humanoid.WalkSpeed/4)),
						(0.07*swaysize) * math.cos(tick() * (4 * humanoid.WalkSpeed/4)),
						0

					)*
						CFrame.Angles(

							0,
							0,
							(-.03*swaysize) * math.sin(tick() * (2 * humanoid.WalkSpeed/4))

						)
					,0.2*sensitivity)
			else
				walksway = walksway:Lerp(CFrame.new(), 0.05*sensitivity)
			end
			--
			local delta = uis:GetMouseDelta()
			--
			if includecamerasway then
				sway = sway:Lerp(Vector3.new(delta.X,delta.Y,delta.X/2), 0.1*sensitivity)
			end
			--
			if includestrafe then
				strafesway = strafesway:Lerp(CFrame.Angles(0,0,-rootpart.CFrame.rightVector:Dot(humanoid.MoveDirection)/(20/swaysize)), 0.1*sensitivity)
			end
			--
			if includejumpsway == true then
				jumpsway = jumpswaygoal.Value
			end
			-- update animation transform for viewmodel
			rightshoulderclone.Transform = rightshoulder.Transform
			leftshoulderclone.Transform = leftshoulder.Transform
			-- cframe the viewmodel
			local finalcf = (camera.CFrame*walksway*jumpsway*strafesway*CFrame.Angles(math.rad(sway.Y*swaysize),math.rad(sway.X*swaysize)/10,math.rad(sway.Z*swaysize)/2))+(camera.CFrame.UpVector*(-1.7-(headoffset.Y+(aimoffset.Value.Y))))+(camera.CFrame.LookVector*(headoffset.Z+(aimoffset.Value.Z)))+(camera.CFrame.RightVector*(-headoffset.X-(aimoffset.Value.X)+(-(sway.X*swaysize)/75)))
			viewmodel:SetPrimaryPartCFrame(finalcf * script.CFrameAimOffset.Value:Inverse())
		end
	end)
end


Prompt: --Made by Luckymaxer

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

RbxUtility = LoadLibrary("RbxUtility")
Create = RbxUtility.Create

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

Player = Players:GetPlayerFromCharacter(Character)

Fire = script:WaitForChild("Fire")

Creator = script:FindFirstChild("Creator")

Removing = false
Flames = {}

function DestroyScript()
	if Removing then
		return
	end
	Removing = true
	if Humanoid then
		Humanoid.WalkSpeed = 16
	end
	for i, v in pairs(Flames) do
		v.Enabled = false
		Debris:AddItem(v, 2)
	end
	Debris:AddItem(script, 1)
end

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

function TagHumanoid(humanoid, player)
	local Creator_Tag = Create("ObjectValue"){
		Name = "creator",
		Value = player,
	}
	Debris:AddItem(Creator_Tag, 2)
	Creator_Tag.Parent = humanoid
end

function UntagHumanoid(humanoid)
	for i, v in pairs(humanoid:GetChildren()) do
		if v:IsA("ObjectValue") and v.Name == "creator" then
			v:Destroy()
		end
	end
end

function GetCreator()
	return (((Creator and Creator.Value and Creator.Value.Parent and Creator.Value:IsA("Player")) and Creator.Value) or nil)
end

CreatorPlayer = GetCreator()

if not Humanoid or Humanoid.Health == 0 or not CreatorPlayer then
	DestroyScript()
	return
end

Humanoid.WalkSpeed = 16
Humanoid.Sit = true

for i, v in pairs(Character:GetChildren()) do
	if v:IsA("BasePart") then
		local Flame = Fire:Clone()
		Flame.Enabled = true
		table.insert(Flames, Flame)
		Flame.Parent = v
	end
end

for i = 1, 5 do
	wait(1.5)
	if not Player or (Player and not IsTeamMate(Player, CreatorPlayer)) then
		UntagHumanoid(Humanoid)
		TagHumanoid(Humanoid, Player)
		Humanoid:TakeDamage(5)
	end
end

DestroyScript()


Prompt:
--[[
	if tonumber(textbox.Text) then
		module.Ads[(textbox.Parent.LayoutOrder-1)/2][4] = tonumber(textbox.Text) - 1
		print(module.Ads[(textbox.Parent.LayoutOrder-1)/2])
	else
		module.Ads[(textbox.Parent.LayoutOrder-1)/2][4] = 16
		print(module.Ads[(textbox.Parent.LayoutOrder-1)/2])
	end
	textbox.Text=module.Ads[(textbox.Parent.LayoutOrder-1)/2][4].."m"
	]]


Prompt: -- emote bindable hook

Response:
script:WaitForChild("PlayEmote").OnInvoke = function(emote)
	-- Only play emotes when idling
	if pose ~= "Standing" then
		return
	end
	if emoteNames[emote] ~= nil then
		-- Default emotes
		playAnimation(emote, EMOTE_TRANSITION_TIME, Humanoid)

		return true, currentAnimTrack
	end

	-- Return false to indicate that the emote could not be played
	return false
end