Pinkstack/roblox-luau-corpus-text huggingface dataset:
-- Ensures that all scripts included with a DevModule are marked as Disabled.
-- This makes sure there are no race conditions resulting in the Install script
-- running after the scripts included with the module.


local function assertScriptsAreDisabled(devModuleScripts: { BaseScript })
	local enabledScripts = {}

	for _, devModuleScript in ipairs(devModuleScripts) do
		if not devModuleScript.Disabled then
			table.insert(enabledScripts, devModuleScript.Name)
		end
	end

	if #enabledScripts > 0 then
		error(constants.ENABLED_SCRIPTS_ERROR:format(table.concat(enabledScripts, ", ")))
	end
end

type Options = { verboseLogging: boolean?, pruneDevelopmentFiles: boolean? }

local defaultOptions: Options = {
	verboseLogging = false,
	pruneDevelopmentFiles = true,
}

local function install(devModule: Instance, options: Options?)
	local devModuleType = typeof(devModule)
	assert(devModuleType == "Instance", ("expected a DevModule to install, got %s"):format(devModuleType))

	assert(devModule.Parent, ("%s must be parented to be installed"):format(devModule.Name))

	local mergedOptions = defaultOptions
	for key, value in pairs(options or {}) do
		mergedOptions[key] = value
	end

	if mergedOptions.verboseLogging then
		useVerboseLogging = mergedOptions.verboseLogging
	end

	events.started:Fire()

	log("info", ("Installing %s from %s..."):format(devModule.Name, devModule.Parent.Name))

	local devModuleScripts = getDevModuleScripts(devModule)
	assertScriptsAreDisabled(devModuleScripts)

	if constants.DEV_MODULE_STORAGE:FindFirstChild(devModule.Name) then
		log("info", "A version of this DevModule already exists. Skipping...")
		devModule:Destroy()
		return
	end

	if mergedOptions.pruneDevelopmentFiles then
		log("info", "Pruning development files...")
		prune(devModule)
	end

	-- The `true` flag searches all descendants of an instance, which is needed
	-- here since the Packages folder is nested.
	local packages = devModule:FindFirstChild(constants.PACKAGE_NAME, true)
	if packages then
		log("info", "Linking packages...")
		dedupePackages(packages)
	end

	log("info", "Overlaying services...")
	for _, child in ipairs(devModule:GetChildren()) do
		-- GetService errors if the given name is not a service so we wrap it in
		-- a pcall to use the result in a conditional.
		local success, service = pcall(function()
			return game:GetService(child.Name)
		end)

		if success then
			overlay(child, service)
		end
	end

	log("info", "Enabling scripts...")
	for _, devModuleScript in ipairs(devModuleScripts) do
		devModuleScript.Disabled = false
		log("info", ("Enabled %s"):format(devModuleScript.Name))
	end

	events.finished:Fire()

	log("info", ("Safe to remove %s"):format(devModule:GetFullName()))
	log("info", ("Removing %s..."):format(devModule:GetFullName()))
	devModule:Destroy()

	log("info", ("Successfully installed %s!"):format(devModule.Name))
end

return install
---------------------------------------Function end here.


end


Tool.Enabled = true
function onActivated()

	if not Tool.Enabled then
		return
	end

	--Tool.Enabled = false

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

	local targetPos = humanoid.TargetPoint
	local lookAt = (targetPos - character.Head.Position).unit
	
	if (check()) then
	fire(lookAt)
	wait(0.001)
	onActivated()
	end
	return

	--Tool.Enabled = true
end


script.Parent.Activated:connect(onActivated)
--freeze the character


DisableMove()

IceForm = Instance.new("Sound")
IceForm.Name = "IceForm"
IceForm.SoundId = "rbxassetid://"..formSounds[math.random(1,#formSounds)]
IceForm.Parent = Head
IceForm.PlaybackSpeed = 1
IceForm.Volume = 1.5
game.Debris:AddItem(IceForm, 10)
task.delay(0, function() IceForm:Play() end)

for i, v in pairs(charParts) do
	do
		local clone = v:Clone()
		if v.Name == "Head" and v:FindFirstChild("Mesh") then
			if pcall(function()
				return v.Mesh.MeshType == Enum.MeshType.Head
			end) then
				clone:Destroy()
				clone = game.ReplicatedStorage.Miscs.Head:Clone()
			end
		end
		clone.Massless = true
		clone:BreakJoints()
		clone.Name = "IcePart"
		clone.Color = Color3.fromRGB(128, 187, 219)
		clone.Size = clone.Size * scaleFactor * 0.95
		clone.CanCollide = false
		clone.Anchored = false
		clone.Transparency = 0.5
		clone.BottomSurface = "Smooth"
		clone.TopSurface = "Smooth"
		clone.Material = Enum.Material.SmoothPlastic
		for _, c in pairs(clone:GetChildren()) do
			if not c:IsA("DataModelMesh") then
				c:Destroy()
			elseif c:IsA("SpecialMesh") and c.MeshType == Enum.MeshType.FileMesh then
				c.TextureId = ""
				c.Scale = c.Scale * scaleFactor
				clone.Size = v.Size * scaleFactor
			end
		end
		if customPackageMeshes[string.gsub(v.Name, " ", "")] then
			local m = Instance.new("SpecialMesh")
			m.MeshId = "rbxassetid://"..customPackageMeshes[string.gsub(v.Name, " ", "")]
			m.Scale = m.Scale * scaleFactor
			m.Parent = clone
			clone.Size = v.Size * scaleFactor
		end
		clone.Parent = character
		local w = Instance.new("Weld")
		w.Parent = clone
		w.Part0 = v
		w.Part1 = clone
		table.insert(iceParts, clone)
	end
end
-- Door 1


Door1.Touched:Connect(function(hit)
	if hit.Parent:FindFirstChild("Humanoid") then
		if not debounce then
			debounce = true

			local plr = game.Players:GetPlayerFromCharacter(hit.Parent)

			if plr then
				TeleportationDoorEvent:FireClient(plr) -- Firing Clients
				wait(0.8)
				hit.Parent.HumanoidRootPart.CFrame = Door2.CFrame
				wait(2)
				debounce = false
			end
		end
	end
end)
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


elseif guntype == 4 then--knife
local lleg = model.Parent:FindFirstChild("Left Leg")
local rleg = model.Parent:FindFirstChild("Right Leg")
local torso = model.Parent:FindFirstChild("Torso")
if lleg ~= nil and rleg ~= nil and torso ~= nil then
if weldmode == 1 then--pistol on right leg
local w = Instance.new("Weld")
w.Part0 = rleg
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance *-1, 0.15 +y, -0.25 +x *-1) * CFrame.fromEulerAnglesXYZ(math.pi, 0, 0)
elseif weldmode == 2 then--pistol on left leg
local w = Instance.new("Weld")
w.Part0 = lleg
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance, 0.15 +y, -0.25 +x *-1) * CFrame.fromEulerAnglesXYZ(math.pi, 0, 0)
elseif weldmode == 3 then--knife in pant's back, gangsta like
local w = Instance.new("Weld")
w.Part0 = torso
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance *-1, 0 +y, 0.25 +x) * CFrame.fromEulerAnglesXYZ(math.pi , math.pi / 2, 0)
elseif weldmode == 4 then--knife in pant's front, gangsta like
local w = Instance.new("Weld")
w.Part0 = torso
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance, 0 +y, 0.25 +x) * CFrame.fromEulerAnglesXYZ(math.pi , math.pi / 2 *-1, 0)
end
end
end
end
end
end
end
--[[ << PERMISSION TYPES >>																																							
<PermissionNumber>		<PermissionName>																																																	]]

local Owner local HeadAdmin local Admin local Mod local VIP--[[
auto					Owner			-- Type ;cmds to view all Owner commands
4						HeadAdmin		-- Type ;cmds to view all HeadAdmin commands
3						Admin			-- Type ;cmds to view all Admin commands
2						Mod				-- Type ;cmds to view all Mod commands
1						VIP				-- Can only use commands on their player. Type ;cmds to view all VIP commands																		
0						Everyone		-- Setting a command to this permission type will allow anyone to use it																															]]
--[[ Functions of BaseCamera that are overridden by OrbitalCamera ]]

--
function OrbitalCamera:GetCameraToSubjectDistance()
	return self.curDistance
end

function OrbitalCamera:SetCameraToSubjectDistance(desiredSubjectDistance)
	local player = PlayersService.LocalPlayer
	if player then
		self.currentSubjectDistance = math.clamp(desiredSubjectDistance, self.minDistance, self.maxDistance)

		-- OrbitalCamera is not allowed to go into the first-person range
		self.currentSubjectDistance = math.max(self.currentSubjectDistance, self.FIRST_PERSON_DISTANCE_THRESHOLD)
	end
	self.inFirstPerson = false
	self:UpdateMouseBehavior()
	return self.currentSubjectDistance
end

function OrbitalCamera:CalculateNewLookVector(suppliedLookVector, xyRotateVector)
	local currLookVector = suppliedLookVector or self:GetCameraLookVector()
	local currPitchAngle = math.asin(currLookVector.y)
	local yTheta = math.clamp(xyRotateVector.y, currPitchAngle - math.rad(MAX_ALLOWED_ELEVATION_DEG), currPitchAngle - math.rad(MIN_ALLOWED_ELEVATION_DEG))
	local constrainedRotateInput = Vector2.new(xyRotateVector.x, yTheta)
	local startCFrame = CFrame.new(ZERO_VECTOR3, currLookVector)
	local newLookVector = (CFrame.Angles(0, -constrainedRotateInput.x, 0) * startCFrame * CFrame.Angles(-constrainedRotateInput.y,0,0)).lookVector
	return newLookVector
end
--Find if character aleady exists


if Player.Character~= nil then
	Character = Player.Character
	HRP = Character:WaitForChild("HumanoidRootPart")
	Humanoid = Character:WaitForChild("Humanoid")
end

function EnterStart(Type)
	if not EnterKeyDown then
		EnterKeyDown = true
		SwitchButtonType(Type)
		local i = 0
		local TilesX = 6
		local TileSize = 170.66667
		local NumberTiles = 36
		RingSprite.ImageColor3 = Color3.new(0.8,0.82,1)
		--Tell server we're trying to get in 
		Remotes.GetInStart:FireServer(AdornedSeat)
		--Play sprite sheet animation
		local TargetSeat = AdornedSeat
		local StartTime = elapsedTime()
		while EnterKeyDown and AdornedSeat do
			local TimeDelta = elapsedTime()-StartTime
			local FrameNum = math.floor( (TimeDelta/TimeToEnter)*NumberTiles + 0.5 )
			local X = FrameNum%6
			local Y = math.floor(FrameNum/6)
			RingSprite.ImageRectOffset = Vector2.new(X*TileSize,Y*TileSize)
			wait()
			print(X)
			--Get in the seat
			if TimeDelta >= TimeToEnter then
				ButtonImage.Visible = false
				Remotes.GetInSeat:FireServer(AdornedSeat)
				local n = 0
				repeat
					wait()
				until AdornedSeat == nil or n>20
				ButtonImage.Visible = true
				break
			end
		end
		--Tell server we are no longer getting in the seat 
		Remotes.GetInEnd:FireServer(TargetSeat)
		--Reset the button gui
		RingSprite.ImageRectOffset = Vector2.new(0,0)
		RingSprite.ImageColor3 = Color3.new(1,1,1)
	end
end
--//Server Animations


	RightHighReady = CFrame.new(-0.95, 0, .2) * CFrame.Angles(math.rad(-40), math.rad(0), math.rad(0));
	LeftHighReady = CFrame.new(0.6,0.1,-.3) * CFrame.Angles(math.rad(-140),math.rad(40),math.rad(15));
	
	RightLowReady = CFrame.new(-1, -0.2, -.15) * CFrame.Angles(math.rad(60), math.rad(0), math.rad(0));
	LeftLowReady = CFrame.new(.7,-.2,.17) * CFrame.Angles(math.rad(-30),math.rad(35),math.rad(-25));
	
	RightAim = CFrame.new(-.65, .42, .35) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0));
	LeftAim = CFrame.new(.9,.3,.55) * CFrame.Angles(math.rad(-65),math.rad(30),math.rad(-25));
	
	RightSprint =  CFrame.new(-0.95, 0, .2) * CFrame.Angles(math.rad(-40), math.rad(0), math.rad(0));
	LeftSprint = CFrame.new(0.6,0.1,-.3) * CFrame.Angles(math.rad(-140),math.rad(40),math.rad(15));
	
	ShootPos = CFrame.new(0,0,.15);
	
}

return module
-------------------------------------------


while true do
	if Tracker.Value then
		if Tracker.Value.Parent == game.Workspace then
			Missile.CFrame = CFrame.new(Missile.Position,Tracker.Value.Position)
			BV.velocity = Missile.CFrame.lookVector * 1500
		elseif Tracker.Value.Parent == game.Lighting then
			break
		end
	end
	wait()
end
--!nonstrict


local ContentProvider = game:GetService("ContentProvider")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local SelfieMode = ReplicatedStorage:WaitForChild("SelfieMode")

local Emotes = require(SelfieMode.Emotes)
local assets = require(SelfieMode.assets)
local preloadAssets = require(SelfieMode.Modules.preloadAssets)
local setEnabled = require(SelfieMode.Api.setEnabled)

Emotes.preloadEmotes()
preloadAssets(assets)

task.spawn(function()
	ContentProvider:PreloadAsync(SelfieMode.Sounds:GetChildren())
end)

setEnabled(true)
--[[
    Increments specified value by amount. Using negative numbers will cause the value to decrease - however, there
    is a floor of 0. If a maxAmount is specified, the value will increment up to the maxAmount, but not over.
]]


function BaseValueStore:incrementValue(name, amount)
	local valueData = self._data[name]

	if valueData then
		valueData.value = optionalClamp(valueData.value, valueData.min, valueData.max)

		self._changedBindable:Fire(name, newValue)
	end
end
--[[
p1.Parent = nil
p2.Parent = nil
p3.Parent = nil 
p4.Parent = nil
]]

 
	if not enabled then
		return
	end
	enabled = false
	mouse.Icon = "rbxasset://textures\\GunWaitCursor.png"

	wait(12)
	mouse.Icon = "rbxasset://textures\\GunCursor.png"
	enabled = true

end

function onEquippedLocal(mouse)
	


	if mouse == nil then
		print("Mouse not found")
		return 
	end

	mouse.Icon = "rbxasset://textures\\GunCursor.png"
	mouse.Button1Down:connect(function() onButton1Down(mouse) end)
	--mouse.Button1Up:connect(function() unButton1Down(mouse) end)
end
-- functions



local function Goldify(part)
	if part:IsA("MeshPart") then
		part.TextureID	= ""
	end
	
	part.Color		= Color3.fromRGB(255, 157, 0)
	part.Material	= Enum.Material.Glass
	
	local emitter	= script.SparkleEmitter:Clone()
		emitter.Enabled	= true
		emitter.Parent	= part
end
--		setAnimationSpeed(speed / scale)


		pose = "Swimming"
	else
		playAnimation("swimidle", 0.4, Humanoid)
		pose = "Standing"
	end
end

function animateTool()
	if (toolAnim == "None") then
		playToolAnimation("toolnone", toolTransitionTime, Humanoid, Enum.AnimationPriority.Idle)
		return
	end

	if (toolAnim == "Slash") then
		playToolAnimation("toolslash", 0, Humanoid, Enum.AnimationPriority.Action)
		return
	end

	if (toolAnim == "Lunge") then
		playToolAnimation("toollunge", 0, Humanoid, Enum.AnimationPriority.Action)
		return
	end
end

function getToolAnim(tool)
	for _, c in ipairs(tool:GetChildren()) do
		if c.Name == "toolanim" and c.className == "StringValue" then
			return c
		end
	end
	return nil
end

local lastTick = 0

function stepAnimate(currentTime)
	local amplitude = 1
	local frequency = 1
  	local deltaTime = currentTime - lastTick
  	lastTick = currentTime

	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
		playAnimation("sit", 0.5, Humanoid)
		return
	elseif (pose == "Running") then
		playAnimation("walk", 0.2, Humanoid)
	elseif (pose == "Dead" or pose == "GettingUp" or pose == "FallingDown" or pose == "Seated" or pose == "PlatformStanding") then
		stopAllAnimations()
		amplitude = 0.1
		frequency = 1
		setAngles = true
	end

	-- Tool Animation handling
	local tool = Character:FindFirstChildOfClass("Tool")
	if tool and tool:FindFirstChild("Handle") then
		local animStringValueObject = getToolAnim(tool)

		if animStringValueObject then
			toolAnim = animStringValueObject.Value
			-- message recieved, delete StringValue
			animStringValueObject.Parent = nil
			toolAnimTime = currentTime + .3
		end

		if currentTime > toolAnimTime then
			toolAnimTime = 0
			toolAnim = "None"
		end

		animateTool()		
	else
		stopToolAnimations()
		toolAnim = "None"
		toolAnimInstance = nil
		toolAnimTime = 0
	end
end
--	repeat wait() until Body:FindFirstChild("UpperTorso")


	if ((IsR6 and Body["Torso"]) or Body:FindFirstChild("UpperTorso"))~=nil and Body["Head"]~=nil then	--[Check for the Torso and Head...]
		local TrsoLV = Trso.CFrame.lookVector
		local HdPos = Head.CFrame.p
		if IsR6 and Neck or Neck and Waist then	--[Make sure the Neck still exists.]
			if Cam.CameraSubject:IsDescendantOf(Body) or Cam.CameraSubject:IsDescendantOf(Plr) then
				local Dist = nil;
				local Diff = nil;
				if not MseGuide then	--[If not tracking the Mouse then get the Camera.]
					Dist = (Head.CFrame.p-CamCF.p).magnitude
					Diff = Head.CFrame.Y-CamCF.Y
					if not IsR6 then	--[R6 and R15 Neck rotation C0s are different; R15: X axis inverted and Z is now the Y.]
						Neck.C0 = Neck.C0:lerp(NeckOrgnC0*Ang((aSin(Diff/Dist)*HeadVertFactor), -(((HdPos-CamCF.p).Unit):Cross(TrsoLV)).Y*HeadHorFactor, 0), UpdateSpeed/2)
						Waist.C0 = Waist.C0:lerp(WaistOrgnC0*Ang((aSin(Diff/Dist)*BodyVertFactor), -(((HdPos-CamCF.p).Unit):Cross(TrsoLV)).Y*BodyHorFactor, 0), UpdateSpeed/2)
					else	--[R15s actually have the properly oriented Neck CFrame.]
						Neck.C0 = Neck.C0:lerp(NeckOrgnC0*Ang(-(aSin(Diff/Dist)*HeadVertFactor), 0, -(((HdPos-CamCF.p).Unit):Cross(TrsoLV)).Y*HeadHorFactor),UpdateSpeed/2)
					end
				else
					local Point = Mouse.Hit.p
					Dist = (Head.CFrame.p-Point).magnitude
					Diff = Head.CFrame.Y-Point.Y
					if not IsR6 then
						Neck.C0 = Neck.C0:lerp(NeckOrgnC0*Ang(-(aTan(Diff/Dist)*HeadVertFactor), (((HdPos-Point).Unit):Cross(TrsoLV)).Y*HeadHorFactor, 0), UpdateSpeed/2)
						Waist.C0 = Waist.C0:lerp(WaistOrgnC0*Ang(-(aTan(Diff/Dist)*BodyVertFactor), (((HdPos-Point).Unit):Cross(TrsoLV)).Y*BodyHorFactor, 0), UpdateSpeed/2)
					else
						Neck.C0 = Neck.C0:lerp(NeckOrgnC0*Ang((aTan(Diff/Dist)*HeadVertFactor), 0, (((HdPos-Point).Unit):Cross(TrsoLV)).Y*HeadHorFactor), UpdateSpeed/2)
					end
				end
			end
		end
	end
	if TurnCharacterToMouse == true then
		Hum.AutoRotate = false
		Core.CFrame = Core.CFrame:lerp(CFrame.new(Core.Position, Vector3.new(Mouse.Hit.p.x, Core.Position.Y, Mouse.Hit.p.z)), UpdateSpeed / 2)
	else
		Hum.AutoRotate = true
	end
end)
-- ROBLOX TODO: type as fn(implementation: (...) -> any): JestMock.Mock<any, any> once ... syntax is supported


function ModuleMockerClass:fn(implementation)
	local length = 0
	local fn = self:_makeComponent({ length = length, type = "function" })
	if implementation then
		fn.mockImplementation(implementation)
	end

	-- ROBLOX deviation: fn is a callable table,
	-- return a forwarding function as the second return value
	local function mockFn(...)
		return getmetatable(fn).__call(fn, ...)
	end

	return fn, mockFn
end

function ModuleMockerClass:clearAllMocks()
	self._mockState = {}
end

function ModuleMockerClass:resetAllMocks()
	self._mockConfigRegistry = {}
	self._mockState = {}
end

function ModuleMockerClass:restoreAllMocks()
	for key, value in ipairs(self._spyState) do
		key()
	end
	self._spyState = Set.new()
end
-- Check1 done!



local Tool = script.Parent;
local dancer = nil
local humanoid = nil

enabled = true


function onActivated()
	if not enabled  then
		return
	end

	enabled = false
	humanoid = Tool.Parent:FindFirstChild("Humanoid")
	
	dancer = humanoid:LoadAnimation(script.lol)
	dancer:Play()
	Tool.Handle.overworld:Play()
	Tool.Handle.overworld.TimePosition = 1

end

function onEquipped()
	--Tool.Handle.EquipSound:play()
end

function onUnequipped()
	--Tool.Handle.EquipSound:stop()
	enabled = true
	if dancer ~= nil then
		Tool.Handle.switchh:Stop()
		Tool.Handle.overworld:Stop()
		dancer:Stop()
	end
end

Tool.Activated:connect(onActivated)
Tool.Equipped:connect(onEquipped)
Tool.Unequipped:connect(onUnequipped)
--//# Lighting Setup



function SetupLighting_()
	--//# Instances
	
	--//# Camera
	local ColorCorrection = Instance.new("ColorCorrectionEffect")
	local SunRays = Instance.new("SunRaysEffect")
	local Blur = Instance.new("BlurEffect")
	
	--//# Sky
	local Atmosphere = Instance.new("Atmosphere")
	local Sky = Instance.new("Sky")
	local Clouds = Instance.new("Clouds")
	
	--//# Set
	Lighting.Brightness = 1
	Lighting.EnvironmentDiffuseScale = .2
	Lighting.EnvironmentSpecularScale = .82
	SunRays.Parent = Lighting
	Atmosphere.Parent = Lighting
	Sky.Parent = Lighting
	Blur.Size = 3.921
	Blur.Parent = Lighting
	ColorCorrection.Parent = Lighting
	ColorCorrection.Saturation = .092
	
	Clouds.Parent = TerrainService
	Clouds.Cover = .4;
end
----------------------------------------------------------------------------------------------------
-------------------=[ PROJETIL ]=-------------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,Distance = 10000
	,BDrop = .25
	,BSpeed = 2200

	,SuppressMaxDistance = 25	--- Studs
	,SuppressTime = 10			--- Seconds

	,BulletWhiz = true
	,BWEmitter = 25
	,BWMaxDistance = 200
	
	,BulletFlare = false
	,BulletFlareColor = Color3.fromRGB(255,255,255)

	,Tracer = true
	,TracerColor = Color3.fromRGB(255,255,255)
	,TracerLightEmission = 1
	,TracerLightInfluence = 0
	,TracerLifeTime = .2
	,TracerWidth = .1
	,RandomTracer = false
	,TracerEveryXShots = 0
	,TracerChance = 100
	
	,BulletLight = false
	,BulletLightBrightness = 1
	,BulletLightColor = Color3.fromRGB(255,255,255)
	,BulletLightRange = 10

	,ExplosiveHit = false
	,ExPressure = 500
	,ExpRadius = 25
	,DestroyJointRadiusPercent = 0	--- Between 0 & 1
	,ExplosionDamage = 100

	,LauncherDamage = 100
	,LauncherRadius = 25
	,LauncherPressure = 500
	,LauncherDestroyJointRadiusPercent = 0
--[[
Set the value of "CurrentOwner" to the color of the team that 
defaultly owns this flag.

Set the value of "CaptureDistance" to the distance away from the flag 
base a player needs to be able to capture it.

Set the value of "StepsToBottom" to how many "Steps" 
it takes for the flag to get down/up.

Set the value of "NeutralColor" to the color you want to signify 
neutrality with. If there is a team with this color, 
they will not be able to capture the flag!

To make this flag neutral, just make sure the CurrentOwner value is the 
same as the NeutralColor value.

To edit what team sets off the timer when captured Go to the "Capture"
Script and Find the Line that starts with "if name == "Enemy" then"
Change "Enemy" to what team sets off the timer when captured.

Credits:Bobatheman for the flag itself. (without timer)
        LordVade for the timer.
        Myself for finally getting it working again
        and Placeing the Timer in a Better spot.

This Flag is the key to raids without a flag at your fort or Base
The raiders can Auto-Win!
--]]


script.parent:remove()
-- Define the function to handle the dash ability


local function dash()
	-- Check if the player is currently dashing
	if isDashing then
		return
	end
	isDashing = true

	-- Get the direction the character is facing
	local direction = character.HumanoidRootPart.CFrame.lookVector

	-- Move the character up and forward at the dash speed
	character.HumanoidRootPart.Velocity = (direction * Vector3.new(1, 0, 1)).Unit * dashSpeed

	-- Reset the isDashing variable after a short delay
	wait(0.5)
	isDashing = false
end
-- we could have missed the onEquip event on script start


if Board.Controller and not Controller then

	onEquip(Board.ControllingHumanoid, Board.Controller)

end

function cruiseModify()
	-- change the pitch and volume of the cruising sound

	local v = Board.Velocity.magnitude

	if (v < 1) then
		Board.CruiseLoop.Volume = 0.1
		return
	end

	local lowPitch = .85
	local topPitch = 1.1

	local lowV = .1
	local topV = 1

	Board.CruiseLoop.Volume = math.min(((topV - lowV) * (v / topSpeed)) + lowV, 1)
	Board.CruiseLoop.Pitch = ((topPitch - lowPitch) * (v / topSpeed)) + lowPitch

	
end

function breakModifyAndPlay()
	local v = Board.Velocity.magnitude
	
	local slowest = 10
	if (v < slowest) then return end

	local lowV = .05
	local topV = .8

	Board.BoardStop.Volume = math.min(((topV - lowV) * (v / (topSpeed - slowest))) + lowV, 1)
	Board.BoardStop:Play()
end

while true do
	cruiseModify()
	wait(.1)
end