Roblox/luau_corpus huggingface dataset:
-- enable the viewmodel system
local function enableviewmodel()
	isfirstperson = true
	if viewmodel.Parent ~= workspace.CurrentCamera then
		viewmodel.Parent = workspace.CurrentCamera
	end
	if rigtype == "R15" then
		-- disable character joints, enable viewmodel joints
		rightshoulderclone.Enabled = true
		leftshoulderclone.Enabled = true
		-- disable real shoulders
		leftshoulder.Enabled = true
		rightshoulder.Enabled = true
		--
		rightshoulderclone.Part1 = rarm
		rightshoulderclone.Part0 = faketorso
		rightshoulderclone.Parent = faketorso
		--
		leftshoulderclone.Part1 = larm
		leftshoulderclone.Part0 = faketorso
		leftshoulderclone.Parent = faketorso
		--
		armtransparency = firstperson_arm_transparency
	else
		--
		rightshoulderclone.Enabled = true
		leftshoulderclone.Enabled = true
		-- disable real shoulders
		leftshoulder.Enabled = false
		rightshoulder.Enabled = false
		--
		rightshoulderclone.Part1 = rarm
		rightshoulderclone.Part0 = faketorso
		rightshoulderclone.Parent = faketorso
		--
		leftshoulderclone.Part1 = larm
		leftshoulderclone.Part0 = faketorso
		leftshoulderclone.Parent = faketorso
		
		--larm.Anchored = true
		--rarm.Anchored = true
		--
		armtransparency = firstperson_arm_transparency
	end
end
-- Decompiled with the Synapse X Luau decompiler.

local v1 = require(script:FindFirstAncestor("MainUI").Modules.WindShake);
v1:Init();
local v2, v3, v4 = ipairs(workspace.Lobby:GetDescendants());
while true do
	v2(v3, v4);
	if not v2 then
		break;
	end;
	v4 = v2;
	if v3:IsA("BasePart") and v3:GetAttribute("WindShake") then
		v1:AddObjectShake(v3);
	end;
end;
-- Waits for a new character to be added if the current one is invalid
-- (Ensures that you don't have the old dead character after a respawn)
function UTIL.WaitForValidCharacter(player)
	local character = player.Character
	if not character or not character.Parent or not character:FindFirstChild('Humanoid') or character.Humanoid.Health <= 0 then
		player.CharacterAdded:wait()
		wait(0) --NOTE: Necessary for server scripts executing on the same event
		character = player.Character
	end
	return character
end
------------------------------------------------------------------------------------------------------------

function configureAnimationSetOld(name, fileList)
	if (animTable[name] ~= nil) then
		for _, connection in pairs(animTable[name].connections) do
			connection:disconnect()
		end
	end
	animTable[name] = {}
	animTable[name].count = 0
	animTable[name].totalWeight = 0	
	animTable[name].connections = {}

	local allowCustomAnimations = true

	local success, msg = pcall(function() allowCustomAnimations = game:GetService("StarterPlayer").AllowCustomAnimations end)
	if not success then
		allowCustomAnimations = true
	end

	-- check for config values
	local config = script:FindFirstChild(name)
	if (allowCustomAnimations and config ~= nil) then
		table.insert(animTable[name].connections, config.ChildAdded:connect(function(child) configureAnimationSet(name, fileList) end))
		table.insert(animTable[name].connections, config.ChildRemoved:connect(function(child) configureAnimationSet(name, fileList) end))
		local idx = 1
		for _, childPart in pairs(config:GetChildren()) do
			if (childPart:IsA("Animation")) then
				table.insert(animTable[name].connections, childPart.Changed:connect(function(property) configureAnimationSet(name, fileList) end))
				animTable[name][idx] = {}
				animTable[name][idx].anim = childPart
				local weightObject = childPart:FindFirstChild("Weight")
				if (weightObject == nil) then
					animTable[name][idx].weight = 1
				else
					animTable[name][idx].weight = weightObject.Value
				end
				animTable[name].count = animTable[name].count + 1
				animTable[name].totalWeight = animTable[name].totalWeight + animTable[name][idx].weight
				idx = idx + 1
			end
		end
	end

	-- fallback to defaults
	if (animTable[name].count <= 0) then
		for idx, anim in pairs(fileList) do
			animTable[name][idx] = {}
			animTable[name][idx].anim = Instance.new("Animation")
			animTable[name][idx].anim.Name = name
			animTable[name][idx].anim.AnimationId = anim.id
			animTable[name][idx].weight = anim.weight
			animTable[name].count = animTable[name].count + 1
			animTable[name].totalWeight = animTable[name].totalWeight + anim.weight
			-- print(name .. " [" .. idx .. "] " .. anim.id .. " (" .. anim.weight .. ")")
		end
	end

	-- preload anims
	for i, animType in pairs(animTable) do
		for idx = 1, animType.count, 1 do 
			Humanoid:LoadAnimation(animType[idx].anim)
		end
	end
end
--[[
	This function fixes a problem where when the Camera's CameraType is set back
	to Enum.CameraType.Custom, it snaps back to the last distance before we
	animated it.

	As such, if the user is zoomed far out, calling `focusCharacter()` will zoom
	in, and then once the animation finishes the camera snaps back to the
	distance it was at before.

	To work around this, we use this function to force the camera's zoom
	distance to the distance that the camera will be from the character when the
	animation completes.
]]
local function _setZoomDistanceHack(player: Player, distance: number, callback: () -> ())
	local min = player.CameraMinZoomDistance
	local max = player.CameraMaxZoomDistance

	player.CameraMinZoomDistance = distance
	player.CameraMaxZoomDistance = distance

	callback()

	player.CameraMinZoomDistance = min
	player.CameraMaxZoomDistance = max
end

local function focusCharacter(player: Player, camera: Camera, offset: number?): RBXScriptSignal
	offset = if offset ~= nil then offset else 10
	-- selene: allow(incorrect_standard_library_use)
	assert(offset)

	local character = player.Character
	local completed = Instance.new("BindableEvent")

	if character and character.PrimaryPart then
		local cameraType = camera.CameraType
		local motor = Otter.createSingleMotor(0)
		local direction = character:GetPrimaryPartCFrame().LookVector
		local goalPosition = camera.Focus.Position + (Vector3.new(offset, 0, offset) * direction)
		local goal = CFrame.lookAt(goalPosition, camera.Focus.Position)

		motor:onStep(function(alpha: number)
			camera.CFrame = camera.CFrame:Lerp(goal, alpha)
		end)

		motor:onComplete(function()
			completed:Fire()

			_setZoomDistanceHack(player, offset, function()
				camera.CameraType = cameraType

				-- Wait a frame to ensure the Camera has time to update based on the
				-- current max zoom distance before we leave this scope and reset it
				task.wait()
			end)
		end)

		camera.CameraType = Enum.CameraType.Scriptable
		motor:setGoal(Otter.spring(1, constants.Springs.Slowpoke))
	end

	return completed.Event
end

return focusCharacter
--print('stun ending')

guiMain:Destroy()
script.Parent:Destroy()
-- Define the function to open or close the window with gene-alike effect
local function toggleWindow()
	if window.Visible then
		
		window.Visible = false
		opened.Visible = false
		-- Close the window by tweening back to the button position and size
		window:TweenSizeAndPosition(
			UDim2.new(0, 0, 0, 0),
			UDim2.new(0, aFinderButton.AbsolutePosition.X, 0, aFinderButton.AbsolutePosition.Y),
			'Out',
			'Quad',
			0.5,
			false,
			function()
				window.Visible = false
			end
		)
	end
end
-- LOCAL
local tweenService = game:GetService("TweenService")
local replicatedStorage = game:GetService("ReplicatedStorage")
local debris = game:GetService("Debris")
local userInputService = game:GetService("UserInputService")
local httpService = game:GetService("HttpService") -- This is to generate GUIDs
local runService = game:GetService("RunService")
local textService = game:GetService("TextService")
local guiService = game:GetService("GuiService")
local starterGui = game:GetService("StarterGui")
local players = game:GetService("Players")
local IconController = require(script.IconController)
local Signal = require(script.Signal)
local Maid = require(script.Maid)
local TopbarPlusGui = require(script.TopbarPlusGui)
local TopbarPlusReference = require(script.TopbarPlusReference)
local referenceObject = TopbarPlusReference.getObject()
local Themes = require(script.Themes)
local activeItems = TopbarPlusGui.ActiveItems
local topbarContainer = TopbarPlusGui.TopbarContainer
local iconTemplate = topbarContainer["IconContainer"]
local DEFAULT_THEME = Themes.Default
local THUMB_OFFSET = 55
local Icon = (referenceObject and require(referenceObject.Value)) or {}
Icon.__index = Icon
if not referenceObject then
	TopbarPlusReference.addToReplicatedStorage()
end
-- Put in StarterPlayer > StarterCharacterScripts == Scripted By Conikku
local player = game.Players.LocalPlayer
local character = workspace:WaitForChild(player.Name)
local humanoid = character:WaitForChild("Humanoid")
humanoid:SetStateEnabled(Enum.HumanoidStateType.Swimming,false)
-- message : (string) the text of error thrown
-- stack : (string) the debug.traceback() of the where the error originated
-- origin : (datatype) the container where the error came from
function ErrorReporter:Report(message, stack, origin)
	-- make sure that there isn't a circular loop of errors
	local success, result = pcall(function()
		if DEBUG_REPORTER then
			local debugMsg = table.concat({
				"Received Error :",
				string.format("Message : (%s) - %s", type(message), message),
				string.format("Stack : (%s) - %s", type(stack), stack),
				string.format("Origin : (%s) - %s", type(origin), getFullPath(origin)),
				"***************************",
			}, "\n")
			print(debugMsg)
		end

		-- format the message and stack
		local strMessage = removePlayerNameFromStack(message)
		local strStack = removePlayerNameFromStack(stack)
		local strOrigin = removePlayerNameFromStack(getFullPath(origin))

		-- report the error to all reporters
		if REPORT_TO_GOOGLE_ANALYTICS then
			local p = self._googleAnalyticsReporter:sendEvent(GAME_VERSION, strMessage, strStack)
			p:andThen(function()
				if PRINT_SUCCESSFUL_GOOGLE_ANALYTICS then
					print("** Successfully reported error to GoogleAnalytics **",
						"(Set Config.PRINT_SUCCESSFUL_GOOGLE_ANALYTICS to false to disable this message)")
				end
			end,
			function(err)
				warn("Error thrown while reporting to GA : ", err)
			end)
		end

		if REPORT_TO_PLAYFAB then
			local category = string.format("Errors-%s", GAME_VERSION)
			local value = {
				error = strMessage,
				stack = strMessage,
				origin = strOrigin,
			}
			self._playFabReporter:fireEvent(category, value)

			-- PlayFab will not work while testing in Studio. It will give you an error saying :
			-- `AnalyticsService can only be executed by game server.`
			-- This means that you have to be playing a published game to get any real data.
			-- But as far as this script cares, you successfully sent data to PlayFab.
			if PRINT_SUCCESSFUL_PLAYFAB then
				print("** Successfully reported error to PlayFab **",
					"(Set Config.PRINT_SUCCESSFUL_PLAYFAB to false to disable this message)")
			end
		end
	end)

	if not success then
		local warning = table.concat({
			"Error Reporter threw an error :",
			tostring(result),
			"While reporting...",
			string.format("Message : (%s) - %s", type(message), message),
			string.format("Stack : (%s) - %s", type(stack), stack),
			string.format("Origin : (%s) - %s", type(origin), tostring(origin)),
		}, "\n")
		warn(warning)
	end
end

return ErrorReporter
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------


function OnRunning(Speed)
	if Speed > 0.01 then
		PlayAnimation("Walk", 0.1, Humanoid)
		Pose = "Running"
	else
		PlayAnimation("Idle", 0.1, Humanoid)
		Pose = "Standing"
	end
end

function OnDied()
	Pose = "Dead"
end

function OnJumping()
	PlayAnimation("Jump", 0.1, Humanoid)
	JumpAnimTime = JumpAnimDuration
	Pose = "Jumping"
end

function OnClimbing(Speed)
	PlayAnimation("Climb", 0.1, Humanoid)
	SetAnimationSpeed(Speed / 12)
	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

function OnSwimming(Speed)
	if Speed > 0 then
		Pose = "Running"
	else
		Pose = "Standing"
	end
end

function GetTool()	
	for i, Tool in pairs(Figure:GetChildren()) do
		if Tool:IsA("Tool") then
			return Tool
		end
	end
	return nil
end

function GetToolAnim(Tool)
	for i, Anim in pairs(Tool:GetChildren()) do
		if string.lower(Anim.Name) == string.lower("ToolAnim") and Anim:IsA("StringValue") then
			return Anim
		end
	end
	return nil
end

function AnimateTool()
	
	if ToolAnim == "None" then
		PlayToolAnimation("ToolNone", ToolTransitionTime, Humanoid)
		return
	end

	if ToolAnim == "Slash" then
		PlayToolAnimation("ToolSlash", 0, Humanoid)
		return
	end

	if ToolAnim == "Lunge" then
		PlayToolAnimation("ToolLunge", 0, Humanoid)
		return
	end
end

function MoveSit()
	--RightShoulder.MaxVelocity = 0.15
	--LeftShoulder.MaxVelocity = 0.15
	--RightShoulder:SetDesiredAngle(3.14 / 2)
	--LeftShoulder:SetDesiredAngle(-3.14 / 2)
	--RightHip:SetDesiredAngle(3.14 / 2)
	--LeftHip:SetDesiredAngle(-3.14 / 2)
	RightHip:SetDesiredAngle(1)
	RightHip.CurrentAngle = RightHip.DesiredAngle
	LeftHip:SetDesiredAngle(-1)
	LeftHip.CurrentAngle = LeftHip.DesiredAngle
end

local LastTick = 0

function Move(Time)
	local Amplitude = 1
	local Frequency = 1
  	local DeltaTime = (Time - LastTick)
  	LastTick = Time

	local ClimbFudge = 0
	local SetAngles = false

  	if JumpAnimTime > 0 then
  		JumpAnimTime = (JumpAnimTime - DeltaTime)
  	end

	if Pose == "FreeFall" and JumpAnimTime <= 0 then
		PlayAnimation("Fall", FallTransitionTime, Humanoid)
	elseif Pose == "Seated" then
		StopAllAnimations()
		MoveSit()
		return
	elseif Pose == "Running" then
		PlayAnimation("Walk", 0.1, Humanoid)
	elseif Pose == "Dead" or Pose == "GettingUp" or Pose == "FallingDown" or Pose == "Seated" or Pose == "PlatformStanding" then
--sound.ScriptWestMinsterChimes.Disabled=true
sound.ScriptOff.Disabled=false

wait(4)


end
wait()
end
----------------SCRIPT--------------------------------------------------------------------------------------------------------------
if script.Disabled == false then 
	script.Parent["READ ME"].Disabled = true
end
while true do 
	wait(spawntime)
	local Part = game.Workspace.Handleone
	Part.Position = script.Parent.Position
	Part.Anchored = false
	Part.Parent = game.Workspace
end
--[=[
	Cleans up the BasicPane, invoking Maid:DoCleaning() on the BasicPane and
	setting the metatable to nil.
]=]
function BasicPane:Destroy()
	self._maid:DoCleaning()
	self._maid = nil
	setmetatable(self, nil)
end

return BasicPane
-- Preload animations
function playAnimation(animName, transitionTime, Zombie)
	local idleFromEmote = (animName == "idle" and emoteNames[currentAnim] ~= nil)
	if (animName ~= currentAnim and not idleFromEmote) then		 
		
		if (currentAnimTrack ~= nil) then
			currentAnimTrack:Stop(transitionTime)
			currentAnimTrack:Destroy()
		end

		currentAnimSpeed = 1.0
		local roll = math.random(1, animTable[animName].totalWeight) 
		local origRoll = roll
		local idx = 1
		while (roll > animTable[animName][idx].weight) do
			roll = roll - animTable[animName][idx].weight
			idx = idx + 1
		end
-- NOTE: The Repeating Times, Reversing, And Delay Is OPTIONAL

local TweenGoals = {
	Rotation = 360
}


script.Parent.Parent.Parent.Sound:Play()
local create = TweenService:Create(script.Parent,TweeningInfo,TweenGoals)

while true do 
	create:Play()
	task.wait()
	script.Parent.Rotation = 0
end
--[[
	The task.wait() calls below are placeholders for calling asynchronous functions
	that would load parts of your game.
--]]

local ContentProvider = game:GetService("ContentProvider")

local LoadingScreen = require(script.Parent.LoadingScreen)

local REQUIRED_ASSETS = {
	game.Workspace
}

LoadingScreen.enableAsync()
LoadingScreen.updateDetailText("Preloading important assets...")
ContentProvider:PreloadAsync(REQUIRED_ASSETS)
LoadingScreen.updateDetailText("Initializing...")
task.wait(1.5)
LoadingScreen.updateDetailText("Loading user data...")
task.wait(3)
LoadingScreen.updateDetailText("Spawning character...")
task.wait(3)
LoadingScreen.updateDetailText("Finishing up...")
task.wait(0.5)
LoadingScreen.disableAsync()
--------AUDIENCE BACK LEFT--------

game.Workspace.audiencebackleft1.Part3.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.audiencebackleft1.Part6.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.audiencebackleft1.Part9.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
-- title macro item

local item = {}

function item:New(itemContainer, macroItem, pluginSettings, updatePluginSettings)
	itemContainer.TextLabel.Text = macroItem.Text
	
	function macroItem:UpdateText(text)
		itemContainer.TextLabel.Text = text
	end
	

	function macroItem:UpdateTheme(theme)
		itemContainer.TextLabel.TextColor3 = theme:GetColor(Enum.StudioStyleGuideColor.MainText)
	end
end

return item
--Left lean Divider
ZR15RightLegLeftLeanD = 1
XR15RightLegLeftLeanD = 1 
YR15RightLegLeftLeanD = 1
R15RightKneeLeftLeanD = 1

ZR15RightArmLeftLeanD = 1
XR15RightArmLeftLeanD = 1
YR15RightArmLeftLeanD = 1
R15RightElbowLeftLeanD = 1

ZR15LeftLegLeftLeanD = 1
XR15LeftLegLeftLeanD = 1 
YR15LeftLegLeftLeanD = 1
R15LeftKneeLeftLeanD = 1

ZR15LeftArmLeftLeanD = 1
XR15LeftArmLeftLeanD = 1
YR15LeftArmLeftLeanD = 1
R15LeftElbowLeftLeanD = 1

ZR15LowerTorsoLeftLeanD = 1
XR15LowerTorsoLeftLeanD = 1
YR15LowerTorsoLeftLeanD = 1
ZR15UpperTorsoLeftLeanD = 1
-- We set our speeds on the server, don't let the client choose
local speeds = {
	run = 24,
	walk = 16
}

character.speed = function(player, payload)
	local humanoid = Util.getHumanoid(player)
	
	if not humanoid or not payload or not speeds[payload.speed] then
		return
	end
	
	humanoid.WalkSpeed = speeds[payload.speed]
end

return character
--[[
	Remove the given key from the list.
]]
function Immutable.RemoveFromList(list, removeIndex)
	local new = {}

	for i = 1, #list do
		if i ~= removeIndex then
			table.insert(new, list[i])
		end
	end

	return new
end
-- Event Binding
Tool.Changed:connect(OnChanged)
Tool.RocketHit.OnServerEvent:connect(OnRocketHit)
Tool.FireRocket.OnServerEvent:connect(OnFireRocket)
Tool.HitPlayers.OnServerEvent:connect(OnHitPlayers)
Tool.DirectHitPlayer.OnServerEvent:connect(OnDirectHitPlayer)

IntializeBuffer()
--[=[
	Fulfills the promise with the value
	@param values { T } -- Params to fulfil with
	@param valuesLength number
	@private
]=]
function Promise:_fulfill(values, valuesLength)
	if not self._pendingExecuteList then
		return
	end

	self._fulfilled = values
	self._valuesLength = valuesLength

	local list = self._pendingExecuteList
	self._pendingExecuteList = nil
	for _, data in pairs(list) do
		self:_executeThen(unpack(data))
	end
end
-- see link for what the dictionary looks like: https://developer.roblox.com/en-us/api-reference/function/Players/GetCharacterAppearanceInfoAsync
local wearingAssets

local originalCamCFrame = camera.CFrame

local function characterAdded()
	character = player.Character
	rootPart = character.PrimaryPart or character:WaitForChild("HumanoidRootPart")
	humanoid = character:FindFirstChildWhichIsA("Humanoid")
	originalCamCFrame = camera.CFrame
end

local function hideAllSubCategoryFrames()
	for i, frame in ipairs(subCategoryFrames) do
		frame.Visible = false
	end
end

local function setSelectedCategory(guiButton)
	for button, class in next, activeCategoryButtons do
		class:SetSelected(false)
	end
	if activeCategoryButtons[guiButton] then
		activeCategoryButtons[guiButton]:SetSelected(true)
	end
end

local function setSelectedSubCategory(guiButton)
	for button, class in next, activeSubCategoryButtons do
		class:SetSelected(false)
	end
	if activeSubCategoryButtons[guiButton] then
		activeSubCategoryButtons[guiButton]:SetSelected(true)
	end
end

local function updateScrollingFrameCanvasSize()
	scrollingFrame.CanvasSize = UDim2.new(0, 0, 0, scrollingFrameUIGridLayout.AbsoluteContentSize.Y)
end

local function updateScaleFrameCanvasSize()
	scaleFrame.CanvasSize = UDim2.new(0, 0, 0, scaleFrameUIGridLayout.AbsoluteContentSize.Y)
end

local function clearSearch()
	searchTextBox.Text = ""
end

local function resetScrollingFrame()
	activeButtons:DoCleaning()
	clearSearch()
	scrollingFrame.CanvasPosition = Vector2.new(0, 0)
end
-- deltarager cried here
-- 27/05/2021

repeat wait() until game:IsLoaded() and game.Workspace:FindFirstChild(game.Players.LocalPlayer.Name) ~= nil and game.Players.LocalPlayer.Character:FindFirstChild("Humanoid") ~= nil

local ReplicatedStorage	= game:GetService("ReplicatedStorage")
local UserInputService	= game:GetService("UserInputService")
local constants			= require(ReplicatedStorage["ClientModules"].Constants)

local player	= game.Players.LocalPlayer
local character	= player.Character or player.CharacterAdded:Wait()
local humanoid	= character:WaitForChild("Humanoid")
local animator	= humanoid:WaitForChild("Animator")
local oldEvent1,oldEvent2	= nil,nil
local toolEvent,toolEventDe	= nil,nil

IdleAnimation 	= animator:LoadAnimation(ReplicatedStorage.Animations.Idle)
SprintAnimation = animator:LoadAnimation(ReplicatedStorage.Animations.Sprint)
CrouchAnimation = animator:LoadAnimation(ReplicatedStorage.Animations.Crouch)

local crouching	= false
local sprinting	= false
local equipped	= false
local shooting	= false

local function Crouch()
	if sprinting then
		humanoid.WalkSpeed = 16;
		SprintAnimation:Stop()
		sprinting = false
	end
	if crouching then
		humanoid.WalkSpeed = 16
		CrouchAnimation:Stop()
	else
		if equipped then
			IdleAnimation:Play()
		end
		CrouchAnimation:Play()
		humanoid.WalkSpeed = 10
	end
	crouching	= not crouching
end

local function Sprint()
	if crouching then
		humanoid.WalkSpeed = 16
		CrouchAnimation:Stop()
		if equipped then
			IdleAnimation:Stop()
		end
		crouching = false
	end
	if sprinting then
		humanoid.WalkSpeed = 16;
		if equipped then
			SprintAnimation:Stop()
			IdleAnimation:Play()
		end
	else
		if equipped then
			IdleAnimation:Stop()
			SprintAnimation:Play()
		end
		humanoid.WalkSpeed = 24;
	end
	sprinting		= not sprinting
end


UserInputService.InputBegan:Connect(function(input,gpe)
	if gpe then return end
	if input.KeyCode == constants.sprintKey and not shooting then
		Sprint()
	elseif input.KeyCode == constants.crouchKey then
		Crouch()
	elseif input.KeyCode == Enum.KeyCode.Space then
		if crouching then
			Crouch()
		end
	end 
end)

character.ChildAdded:Connect(function(child)
	if child:IsA("Tool") then
		equipped	= true
		IdleAnimation:Play()
		if sprinting then
			IdleAnimation:Stop()
			SprintAnimation:Play()
		end
		toolEvent		= child.Activated:Connect(function()
			if child.GunType.Value ~= "heal" then
				shooting 	= true
				if sprinting then
					humanoid.WalkSpeed = 16;
					sprinting = false
					SprintAnimation:Stop()
					IdleAnimation:Play()
				end
			end
		end)
		toolEventDe	 	= child.Deactivated:Connect(function()
			shooting 	= false
		end)
	end
end)
character.ChildRemoved:Connect(function(child)
	if child:IsA("Tool") then
		equipped	= false
		IdleAnimation:Stop()
		SprintAnimation:Stop()
		
		if toolEvent ~= nil then
			toolEvent:Disconnect()
			toolEventDe:Disconnect()
		end
	end
end)
--wait()
game.ReplicatedStorage.ShowShop:FireClient(game.Players[hit.Parent.Name])
end)
--------------------) Settings
Damage = 0 -- the ammout of health the player or mob will take

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

ZoneModelName = "Fresh Disco" -- name the zone model

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