Roblox/luau_corpus huggingface dataset:
--------LEFT DOOR --------
game.Workspace.doorleft.l11.BrickColor = BrickColor.new(1023)
game.Workspace.doorleft.l23.BrickColor = BrickColor.new(1023)
game.Workspace.doorleft.l32.BrickColor = BrickColor.new(1023)
game.Workspace.doorleft.l41.BrickColor = BrickColor.new(1023)
game.Workspace.doorleft.l53.BrickColor = BrickColor.new(1023)
game.Workspace.doorleft.l62.BrickColor = BrickColor.new(1023)
game.Workspace.doorleft.l71.BrickColor = BrickColor.new(1023)

game.Workspace.doorleft.l12.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l21.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l33.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l42.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l51.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l63.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l72.BrickColor = BrickColor.new(106)

game.Workspace.doorleft.l13.BrickColor = BrickColor.new(1013)
game.Workspace.doorleft.l22.BrickColor = BrickColor.new(1013)
game.Workspace.doorleft.l31.BrickColor = BrickColor.new(1013)
game.Workspace.doorleft.l43.BrickColor = BrickColor.new(1013)
game.Workspace.doorleft.l52.BrickColor = BrickColor.new(1013)
game.Workspace.doorleft.l61.BrickColor = BrickColor.new(1013)
game.Workspace.doorleft.l73.BrickColor = BrickColor.new(1013)

game.Workspace.doorleft.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
--Obj
local Frame

local RenderDist = {}

function RenderDist:Setup(UI)
    Frame = UI
    
    Frame.Text.FocusLost:Connect(function()
        local text = math.clamp(tonumber(Frame.Text.Text), 20, self.Modules.Entity.EntitySettings.CacheRemoveDist - 1)
        if (text) then
            Frame.Text.Text = text
            self.Modules.Entity.EntitySettings.MaxRenderDist = text
        else 
            Frame.Text.Text = self.Modules.Entity.EntitySettings.MaxRenderDist
        end
    end)
end 

return RenderDist
-- When character sits, make it go oof!
Humanoid.StateChanged:Connect(function(_, state)
	if state == Enum.HumanoidStateType.Seated then
		Humanoid:TakeDamage(Humanoid.Health)
	end
end)
--health.Changed:connect(function()
--root.Velocity = Vector3.new(0,5000,0)
--end)

local anims = {}
local lastAttack= tick()

local target,targetType

local lastLock = tick()

local fleshDamage = 15
local structureDamage = 10

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
--------------------) Settings
Damage = 0 -- the ammout of health the player or mob will take

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

ZoneModelName = "Spike zone" -- name the zone model

MobHumanoidName = "Humanoid"-- the name of player or mob u want to damage
--  !! This is the uneditable piece. !!

	randomize = math.random(1,#colortable)

for index, child in pairs(tgt:GetChildren()) do -- Generic for, yay!
    if child:IsA("BasePart") and child.Name == paintpart then -- This will root out false positives
	child.BrickColor = BrickColor.new(colortable[randomize])
else end	
end

print("Painted car '" .. tgt.Name  .. "' " .. colortable[randomize] .. ". Destroying script")
script:Destroy()
--!strict
--[=[
	@function every
	@within Array

	@param array {T} -- The array to check.
	@param predicate (value: T, index: number, array: {T}) -> any -- The predicate to use to check the array.
	@return boolean -- Whether every item in the array passes the predicate.

	Checks whether every item in the array passes the predicate.

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

	local value = Every(array, function(item, index)
		return item > 0
	end) -- true

	local value = Every(array, function(item, index)
		return item > 1
	end) -- false
	```
]=]
local function every<T>(array: { T }, predicate: (value: T, index: number, array: { T }) -> any): boolean
	for index, value in ipairs(array) do
		if not predicate(value, index, array) then
			return false
		end
	end

	return true
end

return every
--------------------) Settings
Damage = 0 -- the ammout of health the player or mob will take

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

ZoneModelName = "Hard zone of bone" -- name the zone model

MobHumanoidName = "Humanoid"-- the name of player or mob u want to damage
-- Code to continue tracking & jumping on Active Mobs
task.defer(function()
	while true do
		task.wait(1/4)
		for MobInstance, Mob in ActiveMobs do
			task.spawn(function()
				if not Mob.isDead and not Mob.Destroyed then
					local Player, m = AI:GetClosestPlayer(Mob)
					local Enemy = Mob.Enemy
					
					-- Simulation
					if Mob.Root.Anchored then
						Mob.Root.Anchored = false
					end
					if not Mob.Root:GetNetworkOwner() then
						Mob.Root:SetNetworkOwner(Player)
						task.wait(0.05) -- Give physics more time so it doesn't appear as choppy
					end
					
					-- Tracking
					if Player and Enemy then
						Enemy:MoveTo(Player.Character:GetPivot().Position, Player.Character.PrimaryPart)
					else
						ActiveMobs[MobInstance] = nil
						Mob.Root:SetNetworkOwner()
						Enemy:MoveTo(Mob.Origin.Position)
					end
					
					-- Jumping
					AI:RequestJump(Mob)
				else
					ActiveMobs[MobInstance] = nil
				end
			end)
		end
	end
end)

return AI
--- Encode/compress
Compress.Encode = function(str)
	--- Vars
	local convertedToJSON = false
	
	--- Convert table to JSON
	if type(str) == "table" then
		--- Attempt to conver to JSON
		local success = pcall(function()
			str = _L.Services.HttpService:JSONEncode(str)
			convertedToJSON = true
		end)
		
		--- Failed to encode to JSON (userdata or empty?)
		if (not success) or (not str) then
			_L.Print("Failed to convert table to string", true)
			return
		end
	end
	
	--- Compress string
	local encoded = Encode(str)
	if utf8.len(str) > utf8.len(encoded) then

		--- Successfully compressed
		return encoded
	else

		--- Size of compressed string larger than original
		return str, convertedToJSON
	end
end
--[[Transmission]]
	Tune.TransModes		= {"Semi", "Auto"}												--[[
	[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)
	Tune.ShiftTime = 0				-- The time delay in which you initiate a shift and the car changes gear
	
	--Gear Ratios
	Tune.FinalDrive		= 3.21		 --	[TRANSMISSION CALCULATIONS FOR NERDS]
	Tune.Ratios			= {			 --		SPEED [SPS]	 = (Wheel diameter(studs) * pi(3.14) * RPM) / (60 * Gear Ratio * Final Drive * Multiplier)
		--[[Reverse]]	5.000		,--		WHEEL TORQUE = Engine Torque * Gear Ratio * Final Drive * Multiplier
		--[[Neutral]]	0			,
		--[[ 1 ]]		3.519      	,
		--[[ 2 ]]		2.320		,
		--[[ 3 ]]		1.700		,
		--[[ 4 ]]		1.400		,
		--[[ 5 ]]		0.907		,
	}
	Tune.FDMult			= 1.3			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
-- Public Constructors

function RadioButtonGroupClass.new(frame, radioButtons)
	local self = setmetatable({}, RadioButtonGroupClass)
	
	self._Maid = Lazy.Utilities.Maid.new()
	self._ChangedBind = Instance.new("BindableEvent")
	self._ActiveRadio = radioButtons[1]
	
	self.Frame = frame
	self.RadioButtons = radioButtons
	self.Changed = self._ChangedBind.Event
	
	init(self)
	
	return self
end

function RadioButtonGroupClass.Create(list, max)
	local radios = {}
	
	local function instanceFunc(index, option)
		local radio = Lazy.Classes.RadioButtonLabel.Create(option)
		radio.Frame.LayoutOrder = index
		radios[index] = radio
		return radio.Frame
	end
	
	local frame = Lazy.Constructors.List.Create(list, max or #list, Enum.FillDirection.Vertical, UDim.new(0, 5), instanceFunc)
	
	return RadioButtonGroupClass.new(frame, radios)
end
-- Main class constructor
function Main.new(player, data)
	for _, v in statesTemplate:GetChildren() do
		v:Clone().Parent = player
	end
	
	local dataScope = data.Main
	local self = {}
	self.Data = dataScope
	self._player = player
	self.JoinTime = os.time()
	self.LastPlayTime = dataScope.LastPlayTime
	self.FirstJoinTime = dataScope.FirstJoinTime
	
	setmetatable(self, Main)
	return self
end
--------------------mods

local maincf 		= CFrame.new() --weapon offset of camera
local guncf  		= CFrame.new() --weapon offset of camera
local larmcf 		= CFrame.new() --left arm offset of weapon
local rarmcf 		= CFrame.new() --right arm offset of weapon

local gunbobcf		= CFrame.new()
local recoilcf 		= CFrame.new()
local aimcf 		= CFrame.new()
local AimTween 		= TweenInfo.new(
	0.3,
	Enum.EasingStyle.Linear,
	Enum.EasingDirection.InOut,
	0,
	false,
	0
)

local Ignore_Model = {cam,char,ACS_Workspace.Client,ACS_Workspace.Server}

local ModStorageFolder 	= plr.PlayerGui:FindFirstChild('ModStorage') or Instance.new('Folder')
ModStorageFolder.Parent = plr.PlayerGui
ModStorageFolder.Name 	= 'ModStorage'

function RAND(Min, Max, Accuracy)
	local Inverse = 1 / (Accuracy or 1)
	return (math.random(Min * Inverse, Max * Inverse) / Inverse)
end

SE_GUI = HUDs:WaitForChild("StatusUI"):Clone()
SE_GUI.Parent = plr.PlayerGui 

local BloodScreen 		= TS:Create(SE_GUI.Efeitos.Health, TweenInfo.new(1,Enum.EasingStyle.Circular,Enum.EasingDirection.InOut,-1,true), {Size =  UDim2.new(1.2,0,1.4,0)})
local BloodScreenLowHP 	= TS:Create(SE_GUI.Efeitos.LowHealth, TweenInfo.new(1,Enum.EasingStyle.Circular,Enum.EasingDirection.InOut,-1,true), {Size =  UDim2.new(1.2,0,1.4,0)})

local Crosshair = SE_GUI.Crosshair

local RecoilSpring = SpringMod.new(Vector3.new())
RecoilSpring.d = .1
RecoilSpring.s = 20

local cameraspring = SpringMod.new(Vector3.new())
cameraspring.d	= .5
cameraspring.s	= 20

local SwaySpring = SpringMod.new(Vector3.new())
SwaySpring.d = 0.25
SwaySpring.s = 20

local TWAY, XSWY, YSWY = 0,0,0

local oldtick = tick()
local xTilt = 0
local yTilt = 0
local lastPitch = 0
local lastYaw = 0

local Stance = Evt.Stance
local Stances = 0
local Virar = 0
local CameraX = 0
local CameraY = 0

local Sentado 		= false
local Swimming		= false
local falling 		= false
local cansado 		= false
local Crouched 		= false
local Proned		= false
local Steady 		= false
local CanLean 		= true
local ChangeStance 	= true
--[[Weight and CG]]
	Tune.Weight			= 12000		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		8		,
	 --[[Height]]		4		,
	 --[[Length]]		26		}
	Tune.WeightDist		= 60		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= 1	-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible
	
	--Unsprung Weight
	Tune.FWheelDensity	= .5		-- Front Wheel Density
	Tune.RWheelDensity	= .5		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]
	
	Tune.AxleSize		= 2			-- Size of structural members (larger = more stable/carry more weight)
	Tune.AxleDensity	= .1		-- Density of structural members
-- This script will increase every character's walkspeed to 60



function edit(h)
	if h ~= nil then
		h.WalkSpeed = 60
	end
end

while true do
	cur = game.Players:GetChildren()
	for i = 1, #cur do
		edit(cur[i].Character.Humanoid)
		wait(0.1)
	end
	wait(4)
end
-- Update the position of the confetti.
function _Confetti:Update(paramDeltaTime)
	if (self.Enabled and self.OutOfBounds) then
		--self.Label.ImageColor3 = self.Color;
		self.Position = Vector2.new(0,0);
		self.Power = Vector2.new(self.EmitterPower.X + math.random(10)-5, self.EmitterPower.Y + math.random(10)-5);
		self.Cycles = self.Cycles + 1;
	end;	
	if (
		(not(self.Enabled) and self.OutOfBounds) or
			(not(self.Enabled) and (self.Cycles == 0))) then
		self.Label.Visible = false;
		self.OutOfBounds = true;
		--self.Color = colors[math.random(#colors)];
		return;
	else
		self.Label.Visible = true;
	end;
	local startPosition, currentPosition, currentPower = self.EmitterPosition, self.Position, self.Power;
	local imageLabel = self.Label;
	-- Apply change.
	if (imageLabel) then
		-- Update position.
		local newPosition = Vector2.new(currentPosition.X - currentPower.X, currentPosition.Y - currentPower.Y);
		local newPower = Vector2.new((currentPower.X/1.09) - gravity.X, (currentPower.Y/1.1) - gravity.Y);
		local ViewportSize = Camera.ViewportSize;
		imageLabel.Position = UDim2.new(startPosition.X, newPosition.X, startPosition.Y, newPosition.Y);
		self.OutOfBounds = 
			(imageLabel.AbsolutePosition.X > ViewportSize.X and gravity.X > 0) or
			(imageLabel.AbsolutePosition.Y > ViewportSize.Y and gravity.Y > 0) or
			(imageLabel.AbsolutePosition.X < 0  and gravity.X < 0) or
			(imageLabel.AbsolutePosition.Y < 0 and gravity.Y < 0);
		self.Position, self.Power = newPosition, newPower;
		-- Start spinning if it's reached max height.
		if (newPower.Y < 0) then
			if (self.Size <= 0) then
				self.Side = 1;
				--imageLabel.ImageColor3 = self.Color;
			end;
			if (self.Size >= self.DefaultSize) then 
				self.Side = -1;
				--imageLabel.ImageColor3 = Color3.new(self.Color.r * 0.65, self.Color.g * 0.65, self.Color.b * 0.65);
			end;
			self.Size = self.Size + (self.Side * 2);
			imageLabel.Size = UDim2.new(0, self.DefaultSize, 0, self.Size);				
		end;
	end;
end;
---------------------------
--[[
	--Main anchor point is the DriveSeat <car.DriveSeat>	
	
	Usage:
		MakeWeld(Part1,Part2,WeldType*,MotorVelocity**) *default is "Weld"  **Applies to Motor welds only
		ModelWeld(Model,MainPart)
	Example:
		MakeWeld(car.DriveSeat,misc.PassengerSeat)
		MakeWeld(car.DriveSeat,misc.SteeringWheel,"Motor",.2)
		ModelWeld(car.DriveSeat,misc.Door)
]]
--Weld stuff here
MakeWeld(car.Misc.HighRiser.base,car.DriveSeat)
MakeWeld(car.Misc.HighRiser.H1.bracket1,car.Misc.HighRiser.H1.part2)
MakeWeld(car.Misc.HighRiser.H1.bracket1,car.Misc.HighRiser.H1.part1)
MakeWeld(car.Misc.HighRiser.H2.bracket2,car.Misc.HighRiser.H2.part2)
MakeWeld(car.Misc.HighRiser.H2.bracket2,car.Misc.HighRiser.H2.part1)
MakeWeld(car.Misc.HighRiser.H1.part0,car.Misc.HighRiser.H1.part1,"Motor",.02).Name="Motor"
MakeWeld(car.Misc.HighRiser.H2.part0,car.Misc.HighRiser.H2.part1,"Motor",.02).Name="Motor"
MakeWeld(car.Misc.HighRiser.H1.part0,car.Misc.HighRiser.base)
MakeWeld(car.Misc.HighRiser.H2.part0,car.Misc.HighRiser.base)
-- Add Points:
function PointsService:AddPoints(player, amount)
    local points = self:GetPoints(player)
    points += amount
    self.PointsPerPlayer[player] = points
    if (amount ~= 0) then
        self.PointsChanged:Fire(player, points)
        self.Client.PointsChanged:Fire(player, points)
    end
    if (points > self.Client.MostPoints:Get()) then
        self.Client.MostPoints:Set(points)
    end
end
--[[*
 * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 ]]

local CurrentModule = script.Parent
local Packages = CurrentModule.Parent
local LuauPolyfill = require(Packages.LuauPolyfill)
local Array = LuauPolyfill.Array
local Object = LuauPolyfill.Object
local Set = LuauPolyfill.Set
local WeakMap = LuauPolyfill.WeakMap
type Array<T> = LuauPolyfill.Array<T>
type Set<T> = LuauPolyfill.Set<T>
type WeakMap<T, U> = LuauPolyfill.WeakMap<T, U>
local exports = {}
--/Other
module.EnableLaser 		= true
module.EnableFlashlight = true
module.InfraRed 		= true
--[[
	The entry point for the Fusion library.
]]

local PubTypes = require(script.PubTypes)
local restrictRead = require(script.Utility.restrictRead)

export type StateObject<T> = PubTypes.StateObject<T>
export type CanBeState<T> = PubTypes.CanBeState<T>
export type Symbol = PubTypes.Symbol
export type Value<T> = PubTypes.Value<T>
export type Computed<T> = PubTypes.Computed<T>
export type ForPairs<KO, VO> = PubTypes.ForPairs<KO, VO>
export type ForKeys<KI, KO> = PubTypes.ForKeys<KI, KO>
export type ForValues<VI, VO> = PubTypes.ForKeys<VI, VO>
export type Observer = PubTypes.Observer
export type Tween<T> = PubTypes.Tween<T>
export type Spring<T> = PubTypes.Spring<T>

type Fusion = {
	version: PubTypes.Version,

	New: (className: string) -> ((propertyTable: PubTypes.PropertyTable) -> Instance),
	Hydrate: (target: Instance) -> ((propertyTable: PubTypes.PropertyTable) -> Instance),
	Ref: PubTypes.SpecialKey,
	Cleanup: PubTypes.SpecialKey,
	Children: PubTypes.SpecialKey,
	Out: PubTypes.SpecialKey,
	OnEvent: (eventName: string) -> PubTypes.SpecialKey,
	OnChange: (propertyName: string) -> PubTypes.SpecialKey,

	Value: <T>(initialValue: T) -> Value<T>,
	Computed: <T>(callback: () -> T, destructor: (T) -> ()?) -> Computed<T>,
	ForPairs: <KI, VI, KO, VO, M>(inputTable: CanBeState<{[KI]: VI}>, processor: (KI, VI) -> (KO, VO, M?), destructor: (KO, VO, M?) -> ()?) -> ForPairs<KO, VO>,
	ForKeys: <KI, KO, M>(inputTable: CanBeState<{[KI]: unknown}>, processor: (KI) -> (KO, M?), destructor: (KO, M?) -> ()?) -> ForKeys<KO, unknown>,
	ForValues: <VI, VO, M>(inputTable: CanBeState<{[unknown]: VI}>, processor: (VI) -> (VO, M?), destructor: (VO, M?) -> ()?) -> ForValues<unknown, VO>,
	Observer: (watchedState: StateObject<unknown>) -> Observer,

	Tween: <T>(goalState: StateObject<T>, tweenInfo: TweenInfo?) -> Tween<T>,
	Spring: <T>(goalState: StateObject<T>, speed: number?, damping: number?) -> Spring<T>,

	cleanup: (...unknown) -> (),
	doNothing: (...unknown) -> ()
}

return restrictRead("Fusion", {
	version = {major = 0, minor = 2, isRelease = true},

	New = require(script.Instances.New),
	Hydrate = require(script.Instances.Hydrate),
	Ref = require(script.Instances.Ref),
	Out = require(script.Instances.Out),
	Cleanup = require(script.Instances.Cleanup),
	Children = require(script.Instances.Children),
	OnEvent = require(script.Instances.OnEvent),
	OnChange = require(script.Instances.OnChange),

	Value = require(script.State.Value),
	Computed = require(script.State.Computed),
	ForPairs = require(script.State.ForPairs),
	ForKeys = require(script.State.ForKeys),
	ForValues = require(script.State.ForValues),
	Observer = require(script.State.Observer),

	Tween = require(script.Animation.Tween),
	Spring = require(script.Animation.Spring),

	cleanup = require(script.Utility.cleanup),
	doNothing = require(script.Utility.doNothing)
}) :: Fusion
--Digits
local Digit1 = Object.Digit1Part.SurfaceGui.TextLabel
local Digit2 = Object.Digit2Part.SurfaceGui.TextLabel
local Digit3 = Object.Digit3Part.SurfaceGui.TextLabel
local Code = Object.Code
local EnteredCode = Object.EnteredCode
local Ready = Object.Ready
Digit1.Text = math.random(0,9)
Digit2.Text = math.random(0,9)
Digit3.Text = math.random(0,9)
Code.Value = tostring(Digit1.Text)..""..tostring(Digit2.Text)..""..tostring(Digit3.Text)
Ready = true
-- this script removes its parent from the workspace after 24 seconds
local Debris = game:GetService("Debris")
Debris:AddItem(script.Parent,10)
-- Main Functions --
local _Confetti = {} _Confetti.__index = _Confetti

	-- Set Gravity --
	local gravity = Vector2.new(0,0.85)
	function _Confetti.setGravity(paramVec2)
		gravity = paramVec2
	end
	
	-- Create A Confetti Particle --	
	function _Confetti.createParticle(paramEmitter, paramForce, paramParent)
		
		local _Particle = {} setmetatable(_Particle, _Confetti)

		local xforce = paramForce.X if (xforce < 0) then xforce = xforce * -1 end
		local distanceFromZero = 0 - xforce
		paramForce = Vector2.new(paramForce.X, paramForce.Y + (distanceFromZero * 0.75))
			
		_Particle.EmitterPosition = paramEmitter
		_Particle.EmitterPower = paramForce
		_Particle.Position = Vector2.new(0,0)
		_Particle.Power = paramForce
		_Particle.Color = getColor()
		
		local function getParticle()
			local label = shapes[math.random(#shapes)]:Clone()
			label.Size = UDim2.new(_Particle.DefaultSize, 0, _Particle.DefaultSize, 0)	
			label.ImageColor3 = _Particle.Color
			label.Parent = paramParent
			label.Rotation = math.random(360)
			label.Visible = true
			label.ZIndex = 100
			return label
		end
		
		_Particle.DefaultSize = (math.random(1,2))/20
		_Particle.Label = getParticle()
		_Particle.Size = 1 
		_Particle.Side = -1
		_Particle.OutOfBounds = false
		_Particle.Enabled = true
		_Particle.Cycles = 0	
		
		return _Particle
	end
	
	-- Update Postion Of Confettis --
	function _Confetti:Update()
		if (self.Enabled and self.OutOfBounds) then
			self.Position = Vector2.new(0,0)
			self.Power = Vector2.new(self.EmitterPower.X + math.random(10)-5, self.EmitterPower.Y + math.random(10)-5)
			self.Cycles = self.Cycles + 1
		end	
		if (not(self.Enabled) and self.OutOfBounds) then
			return
		end
		local startPosition, currentPosition, currentPower = self.EmitterPosition, self.Position, self.Power
		local imageLabel = self.Label
		
		if (imageLabel) then

			local newPosition = Vector2.new(currentPosition.X - currentPower.X, currentPosition.Y - currentPower.Y)
			local newPower = Vector2.new((currentPower.X/1.09) - gravity.X, (currentPower.Y/1.1) - gravity.Y)
			local ViewportSize = Camera.ViewportSize
			imageLabel.Position = UDim2.new(startPosition.X, newPosition.X, startPosition.Y, newPosition.Y)
			self.OutOfBounds = 
				(imageLabel.AbsolutePosition.X > ViewportSize.X and gravity.X > 0) or
				(imageLabel.AbsolutePosition.Y > ViewportSize.Y and gravity.Y > 0) or
				(imageLabel.AbsolutePosition.X < 0  and gravity.X < 0) or
				(imageLabel.AbsolutePosition.Y < 0 and gravity.Y < 0)
			self.Position, self.Power = newPosition, newPower
			
			--[[
			if (newPower.Y < 0) then
				if (self.Size <= 0) then
					self.Side = 1
					imageLabel.ImageColor3 = self.Color
				end
				if (self.Size >= self.DefaultSize) then 
					self.Side = -1
					imageLabel.ImageColor3 = Color3.new(self.Color.r * 0.65, self.Color.g * 0.65, self.Color.b * 0.65)
				end
			end
			--]]
		end
	end
	
	-- Stops Confetti --
	function _Confetti:Toggle()
		self.Enabled = not(self.Enabled)
	end
	
return _Confetti
-- Get references to the DockShelf and its children
local dockShelf = script.Parent.Parent.Parent.Parent.Parent.DockShelf
local aFinderButton = dockShelf.EStore
local Minimalise = script.Parent
local window = script.Parent.Parent.Parent
--[=[
	@class Touch
	@client

	The Touch class is part of the Input package.

	```lua
	local Touch = require(packages.Input).Touch
	```
]=]
local Touch = {}
Touch.__index = Touch
--------------------) Settings
Damage = 0 -- the ammout of health the player or mob will take

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

ZoneModelName = "positive zone" -- name the zone model

MobHumanoidName = "Humanoid"-- the name of player or mob u want to damage
-- Implementation of Brian Kernighan's algorithm
function BitOps.numOfSetBits(int)
	local count = 0
	while int ~= 0 do
		int = bit32.band(int, int - 1)
		count = count + 1
	end

	return count
end

return BitOps