Pinkstack/roblox-luau-corpus-text huggingface dataset:
-- Main --



Players.PlayerAdded:Connect(function(plr)
	local DonatedStore = Datastore2("Donated", plr) 
	local RaisedStore = Datastore2("Raised", plr)

	local Leaderstats = Instance.new("Folder") -- Create leaderstats obv
	Leaderstats.Name = 'leaderstats'

	local Donated = Instance.new("IntValue", Leaderstats)
	Donated.Value = DonatedStore:Get(0) -- Get is basically adding the argumented amount to your saved data
	Donated.Name = "Donated"

	local Raised = Instance.new("IntValue", Leaderstats)
	Raised.Name = "Raised"
	Raised.Value = RaisedStore:Get(0) -- Same thing as above


	DonatedStore:OnUpdate(function(NewDonated)
		Donated.Value = NewDonated
	end)

	RaisedStore:OnUpdate(function(NewRaised) -- Same as above
		Raised.Value = NewRaised
	end)

	Leaderstats.Parent = plr -- Set leaderstats parent AFTER assigning everything

end)
-- Zoom related functions



function ShoulderCamera:isZoomed()
	return self.zoomState
end

function ShoulderCamera:setHideToolWhileZoomed(hide)
	self.hideToolWhileZoomed = hide
end

function ShoulderCamera:setZoomFactor(zoomFactor)
	self.currentZoomFactor = zoomFactor
	local nominalFOVRadians = math.rad(self.fieldOfView)
	local nominalImageHeight = math.tan(nominalFOVRadians / 2)
	local zoomedImageHeight = nominalImageHeight / self.currentZoomFactor
	self.zoomedFOV = math.deg(math.atan(zoomedImageHeight) * 2)
	self:updateZoomState()
end

function ShoulderCamera:resetZoomFactor()
	self:setZoomFactor(self.defaultZoomFactor)
end

function ShoulderCamera:setForceZoomed(zoomed)
	if self.forcedZoomed == zoomed then return end
	self.forcedZoomed = zoomed
	self:updateZoomState()
end

function ShoulderCamera:setZoomedFromInput(zoomedFromInput)
	if self.zoomedFromInput == zoomedFromInput or (self.currentHumanoid and self.currentHumanoid:GetState() == Enum.HumanoidStateType.Dead) then
		return
	end
	
	self.zoomedFromInput = zoomedFromInput
	self:updateZoomState()
end

function ShoulderCamera:updateZoomState()
	local isZoomed = self.forcedZoomed
	if self.canZoom and not self.forcedZoomed then
		isZoomed = self.zoomedFromInput
	end

	if not self.enabled or not self.currentTool then
		isZoomed = false
	end

	self.zoomState = isZoomed

	self.currentMouseRadsPerPixel = isZoomed and self.zoomedMouseRadsPerPixel or self.mouseRadsPerPixel
	self.currentTouchSensitivity = isZoomed and self.zoomedTouchSensitivity or self.touchSensitivity

	if self.currentCamera then
		self.desiredFieldOfView = self:getCurrentFieldOfView()
	end
end

function ShoulderCamera:onZoomAction(actionName, inputState, inputObj)
	if not self.enabled or not self.canZoom or not self.currentCamera or not self.currentCharacter then
		self:setZoomedFromInput(false)
		return Enum.ContextActionResult.Pass
	end
	
	self:setZoomedFromInput(inputState == Enum.UserInputState.Begin)
	return Enum.ContextActionResult.Sink
end
--!strict



return function(TextService)
	--[[
		Takes a string and converts it into pages of text that fit within the given constraints

		Parameters:
		text: The text to paginate
		containerHeight: The height of the container the text should fit into
		containerWidth: The width of the container the text should fit into
		textSize: The size of the text
		font: The font used to display the text

		Returns:
		An array of strings representing the pages of text
	]]
	local function paginate(
		text: string,
		containerHeight: number,
		containerWidth: number,
		textSize: number,
		font: Enum.Font
	): { string }
		local paginatedText = {}

		local textBounds = Vector2.new(containerWidth, math.huge)

		-- Add to the string until it is too large, then paginate and start again
		local workingString = ""
		local word = ""

		if text:find(" ") then
			-- Iterate over words
			for first, last in utf8.graphemes(text) do
				local grapheme = text:sub(first, last)

				if grapheme:match("%s") then
					-- See if this word pushes the text size over the limit
					local newString = workingString .. word
					local bounds = TextService:GetTextSize(newString, textSize, font, textBounds)

					if bounds.Y > containerHeight then
						-- If the word made workingString go over the limit,
						-- add the workingString without the word
						table.insert(paginatedText, workingString)

						-- Set the new working string to the word
						workingString = word
					else
						-- Otherwise add the word to the workingString
						workingString = newString
					end

					word = grapheme
				else
					word = word .. grapheme
				end
			end

			-- Add the remaining words to the paginated list
			local newString = workingString .. word
			local bounds = TextService:GetTextSize(newString, textSize, font, textBounds)
			if bounds.Y > containerHeight then
				table.insert(paginatedText, workingString)
				table.insert(paginatedText, word)
			else
				table.insert(paginatedText, newString)
			end
		else
			-- Iterate over graphemes
			for first, last in utf8.graphemes(text) do
				local grapheme = text:sub(first, last)

				local newString = workingString .. grapheme
				local bounds = TextService:GetTextSize(newString, textSize, font, textBounds)
				if bounds.Y > containerHeight then
					table.insert(paginatedText, workingString)
					workingString = grapheme
				else
					workingString = newString
				end
			end

			table.insert(paginatedText, workingString)
		end

		return paginatedText
	end

	return paginate
end
--function ClassZombie:SetWaypoints(Goal)
--	local g = 1
--	local arr = ClassZombie:FindWay(Goal)
--	for k, v in pairs(arr) do
--		wait(1)
--		local part = game.ReplicatedStorage.WayPoint:Clone()
--		part.Position = Vector3.new(math.floor(v.Position.X),6,math.floor(v.Position.Z))
--		part.Parent = script.Parent.WayPoints
--		part.Name = g
--		g = g + 1
--	end
--	return script.Parent.WayPoints:GetChildren()
--end
--Sick Tunes--



local function AttachParticleControl(source_part)
	
	local prtc = nil
	
	local function Start()
		prtc = script.SickNotes:clone()
		prtc.Parent = source_part
	end
	
	local function Update()
		
	end
	
	local function Stop()
		if prtc ~= nil then
			prtc:destroy()
			prtc = nil
		end
	end
	
	return {Start = Start, Update = Update, Stop = Stop}
end

return AttachParticleControl
--[[ LICENSE
lua-bit-numberlua License

===============================================================================

Copyright (C) 2008, David Manura.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

===============================================================================
--]]
-----------------------------------Checks if the area where the tree is regenerating has parts on it ---------------


			local p = tree:GetChildren()
			--print (#p)
			local PPC = tree:GetPrimaryPartCFrame()
			--GetPartBoundsInBox Defines
			local filterObjects = {}
			local maxObjectsAllowed = math.huge
			local overlapParams = OverlapParams.new()
			overlapParams.CollisionGroup = "Default"
			overlapParams.FilterDescendantsInstances = filterObjects
			overlapParams.FilterType = Enum.RaycastFilterType.Blacklist
			overlapParams.MaxParts = maxObjectsAllowed
			local boundsbox = Vector3.new(12,31,12)
			local boundsboxCenter = CFrame.new(PPC.X, PPC.Y + 16.5, PPC.Z)
			local regenbox = workspace:GetPartBoundsInBox(boundsboxCenter, boundsbox, overlapParams)
			-- print (#regenbox)
			if #regenbox <= #p then
--Right	0	
--Top	1	
--Back	2	
--Left	3	
--Bottom	4	
--Front	5


v = 1	
s = 0
osi = 0
print(s)
if s == 0 or s == 3 then
	osi = p.Size.x - 1
elseif s == 1 or s == 4 then
	osi = p.Size.y - 1
elseif s == 2 or s == 5 then
	osi = p.Size.z - 1
end

function open()
	for i = 1, osi, v do
		local r = p:Resize(s, -v)
		if not r then
			repeat
				wait(0.1)
			until
				p:Resize(s, -v) == true
		end
		wait(0.1)
	end
end

function close()
	for i = 1, osi, v do
		local r = p:Resize(s, v)
		if not r then
			repeat
				wait(0.1)
			until
				p:Resize(s, v) == true
		end
		wait(0.1)
	end
end

script.Parent.opened.Changed:connect(function (v)
	if v then
		open()
	else
		close()
	end
end)
-- variables:


wait()

v3 = Vector3
v2 = nil

function wt() wait() end -- Smooth

load = 0

repeat wt'' load = load + 1 until load < 2
load = load + 4

velo = 20
s_ = v3.new(script.Parent.Size.x, script.Parent.Size.y, script.Parent.Size.z)
scale = 4

function_ = true

print(v3, 'load: '..load, '')
-- RANK, RANK NAMES & SPECIFIC USERS


Ranks = {
	{6,	"Owner",		};
	{5,	"HeadAdmin",	{"",0},	};
	{4,	"Admin",		{"",0},	};
	{3,	"Mod",			{"",0},	};
	{2,	"VIP",			{"",0},	};
	{1,	"NonAdmin",		};
};
-- Luke




local model = script.Parent
local cache = {}
local closeTime = 0


local OPEN_TIME = 3


function openDoor()
	local currentTime = tick()
	if currentTime > closeTime then	-- This means the door is currently closed
		closeTime = currentTime + OPEN_TIME

		-- Open
		--todo: play sound
		for part,transparency in pairs(cache) do
			if part then
				part.Transparency = 1
			end
		end

		-- Wait
		while closeTime > tick() do
			wait(closeTime-tick())
		end

		-- Close
		--todo: play sound
		for part,transparency in pairs(cache) do
			if part and part.Parent then
				part.Transparency = transparency
			end
		end

	else
		-- If currently open, the hold door open for longer
		closeTime = currentTime + OPEN_TIME
	end
end

function touched(hit)
	if hit and hit.Parent then
		local humanoid = hit.Parent:FindFirstChildOfClass('Humanoid')
		if humanoid and humanoid.Health > 0 then
			openDoor()
		end
	end
end

for _,part in pairs(model:GetChildren()) do
	if part:IsA('BasePart') then
		part.Touched:connect(touched)
		cache[part] = part.Transparency
	end
end
-- Using GUID so no conflict occur



script.Parent.OnInvoke = function(Player, Duration)
	if not UsedGUID[Player] then
		UsedGUID[Player] = {}
		if Player.Character:FindFirstChild("Humanoid") then
			Player.Character.Humanoid.WalkSpeed = 0
			Player.Character.Humanoid.JumpHeight = 0
			Player.Character.Humanoid.JumpPower = 0
		end
	end
	local GUID = GenerateGUID(Player)
	UsedGUID[Player][GUID] = true
	task.delay(Duration, function()
		if not UsedGUID[Player] then return end
		UsedGUID[Player][GUID] = nil
		if tlength(UsedGUID[Player]) > 0 then return end
		UsedGUID[Player] = nil
		if not Player.Character or not Player.Character:FindFirstChild("Humanoid") then return end
		Player.Character.Humanoid.WalkSpeed = StarterPlayer.CharacterWalkSpeed
		if Engine:IsGrabbing(Player) then return end
		Player.Character.Humanoid.JumpHeight = StarterPlayer.CharacterJumpHeight
		Player.Character.Humanoid.JumpPower = StarterPlayer.CharacterJumpPower
	end)
end
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,VRecoil = {12,16}				--- Vertical Recoil
	,HRecoil = {5,7}				--- Horizontal Recoil
	,AimRecover = .7				---- Between 0 & 1
	
	,RecoilPunch = .15
	,VPunchBase = 2.5				--- Vertical Punch
	,HPunchBase = 1.7				--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless
	
	,AimRecoilReduction = 5 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.15
	,MinRecoilPower = .5
	,MaxRecoilPower = 3.5
	,RecoilPowerStepAmount = .25
	
	,MinSpread = 0.56				--- Min bullet spread value | Studs
	,MaxSpread = 35					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = 0.5
	,WalkMultiplier = 0				--- Bullet spread based on player speed

	,SwayBase = 0.25				--- Weapon Base Sway | Studs
	,MaxSway =	1.5					--- Max sway value based on player stamina | Studs
--////////////////////////////// Include
--//////////////////////////////////////


local ChatConstants = require(ReplicatedModules:WaitForChild("ChatConstants"))

local ChatChannel = require(modulesFolder:WaitForChild("ChatChannel"))
local Speaker = require(modulesFolder:WaitForChild("Speaker"))
local Util = require(modulesFolder:WaitForChild("Util"))

local ChatLocalization = nil
pcall(function() ChatLocalization = require(game:GetService("Chat").ClientChatModules.ChatLocalization :: any) end)
ChatLocalization = ChatLocalization or {}

if not ChatLocalization.FormatMessageToSend or not ChatLocalization.LocalizeFormattedMessage then
	function ChatLocalization:FormatMessageToSend(key,default) return default end
end

local function allSpaces(inputString)
	local testString = string.gsub(inputString, " ", "")
	return string.len(testString) == 0
end
--Main function


local function AttachAuraControl(source_part, eff_cont) --(source_part, effect_container)
	
	local AnimObj
	
	local function Start()
		AnimObj = {}
		AnimObj["LastUpdate"] = tick()
		
		AnimObj["Parts"] = {}
		
		for i = 1, 3 do
			local np = EFFECT_LIB.NewInvisiblePart()
			
			local particlez = script.Energy:Clone()
			particlez.Parent = np
			particlez.Enabled = true
			
			AnimObj["Parts"][i] = np
	
			np.Parent = eff_cont
		end
	end
	
	local function Update()
		local loop = EFFECT_LIB.Loop(3)
		local loop2 = EFFECT_LIB.Loop(8)
		
		for i = 1, #AnimObj["Parts"] do
			local res_cf = source_part.CFrame * CFrame.Angles(0, 0, math.rad(45 * math.sin(math.rad(360 * loop2)))) * CFrame.Angles(0, math.rad(loop * 360 + (360 / #AnimObj["Parts"] * (i - 1))), 0) * CFrame.new(0, 0, -3) * CFrame.Angles(0, math.rad(90), 0)
			AnimObj["Parts"][i].CFrame = source_part.CFrame - source_part.CFrame.p + res_cf.p
		end
	end
	
	local function Stop()
		eff_cont:ClearAllChildren()
		AnimObj = nil
	end
	
	return {Start = Start, Update = Update, Stop = Stop}
end

return AttachAuraControl
-- assume we are in the character, let's check



function sepuku()
	script.Parent = nil
end

local h = script.Parent:FindFirstChild("Humanoid")

if (h == nil) then sepuku() end

local oldSpeed = h.WalkSpeed
h.WalkSpeed = h.WalkSpeed * 3




local torso = script.Parent:FindFirstChild("Torso")

if (torso == nil) then sepuku() end


local head = script.Parent:FindFirstChild("Head")
if (head == nil) then head = torso end



local s = Instance.new("Fire")
s.Color = Color3.new(153, 0, 255)
s.Parent = torso


local count = h:FindFirstChild("CoffeeCount")
if (count == nil) then
	count = Instance.new("IntValue")
	count.Name = "CoffeeCount"
	count.Value = 1
	count.Parent = h
else
	
	if (count.Value > 3) then
		if (math.random() > .5) then

			local sound = Instance.new("Sound")
			sound.SoundId = "rbxasset://sounds\\Rocket shot.wav"
			sound.Parent = head
			sound.Volume = 1
			sound:play()

			local e = Instance.new("Explosion")
			e.BlastRadius = 4
			e.Position = head.Position
			
			s:Clone().Parent = head
			e.Parent = head
			

		end
	end
	count.Value = count.Value + 1
end

wait(30)

h.WalkSpeed = oldSpeed
s:Remove()


script.Parent = nil
--[[
	The TextReporter uses the results from a completed test to output text to
	standard output and TestService.
]]



local TestService = game:GetService("TestService")

local TestEnum = require(script.Parent.Parent.TestEnum)

local INDENT = (" "):rep(3)
local STATUS_SYMBOLS = {
	[TestEnum.TestStatus.Success] = "+",
	[TestEnum.TestStatus.Failure] = "-",
	[TestEnum.TestStatus.Skipped] = "~"
}
local UNKNOWN_STATUS_SYMBOL = "?"

local TextReporter = {}

local function compareNodes(a, b)
	return a.planNode.phrase:lower() < b.planNode.phrase:lower()
end

local function reportNode(node, buffer, level)
	buffer = buffer or {}
	level = level or 0

	if node.status == TestEnum.TestStatus.Skipped then
		return buffer
	end

	local line

	if node.status then
		local symbol = STATUS_SYMBOLS[node.status] or UNKNOWN_STATUS_SYMBOL

		line = ("%s[%s] %s"):format(
			INDENT:rep(level),
			symbol,
			node.planNode.phrase
		)
	else
		line = ("%s%s"):format(
			INDENT:rep(level),
			node.planNode.phrase
		)
	end

	table.insert(buffer, line)
	table.sort(node.children, compareNodes)

	for _, child in ipairs(node.children) do
		reportNode(child, buffer, level + 1)
	end

	return buffer
end

local function reportRoot(node)
	local buffer = {}
	table.sort(node.children, compareNodes)

	for _, child in ipairs(node.children) do
		reportNode(child, buffer, 0)
	end

	return buffer
end

local function report(root)
	local buffer = reportRoot(root)

	return table.concat(buffer, "\n")
end

function TextReporter.report(results)
	local resultBuffer = {
		"Test results:",
		report(results),
		("%d passed, %d failed, %d skipped"):format(
			results.successCount,
			results.failureCount,
			results.skippedCount
		)
	}

	print(table.concat(resultBuffer, "\n"))

	if results.failureCount > 0 then
		print(("%d test nodes reported failures."):format(results.failureCount))
	end

	if #results.errors > 0 then
		print("Errors reported by tests:")
		print("")

		for _, message in ipairs(results.errors) do
			TestService:Error(message)

			-- Insert a blank line after each error
			print("")
		end
	end
end

return TextReporter
------------------
--SPAWNING--
------------------



miked=script.Parent

itlh=miked.Torso:findFirstChild("Left Hip")
itlh.Part0=miked.Torso
itlh.Part1=miked:findFirstChild("Left Leg")
itlh.C0=CFrame.new(-4, -4, 0, 0, 0, -1, 0, 1, 0, 1, 0, 0)
itlh.C1 = CFrame.new(-2, 4, 0, -0, -0, -1, 0, 1, 0, 1, 0, 0)

itrh=miked.Torso:findFirstChild("Right Hip")
itrh.Part0=miked.Torso
itrh.Part1=miked:findFirstChild("Right Leg")
itrh.C0=CFrame.new(4, -4, 0, 0, 0, 1, 0, 1, 0, -1, 0, 0)
itrh.C1 = CFrame.new(2, 4, 0, 0, 0, 1, 0, 1, 0, -1, -0, -0)

itls=miked.Torso:findFirstChild("Left Shoulder")
itls.Part1=miked.Torso
itls.C0=CFrame.new(8, 2, 0, 0, 0, -1, 0, 1, 0, 1, 0, 0)
itls.Part0=miked:findFirstChild("Left Arm")
itls.C1 = CFrame.new(2, 2, 0, -0, -0, -1, 0, 1, 0, 1, 0, 0)

itrs=miked.Torso:findFirstChild("Right Shoulder")
itrs.Part1=miked.Torso
itrs.C0=CFrame.new(-8, 2, 0, 0, 0, 1, 0, 1, 0, -1, 0, 0)
itrs.Part0=miked:findFirstChild("Right Arm")
itrs.C1 = CFrame.new(-2, 2, 0, 0, 0, 1, 0, 1, 0, -1, -0, -0)

local w = Instance.new("Weld")
w.Parent = miked.Torso
w.Part0 = w.Parent
w.Part1 = miked.TE
w.C0 = CFrame.new(0, -8, 0)

miked.Head:makeJoints()
-- Container for temporary connections (disconnected automatically)


local Connections = {};

function DecorateTool.Equip()
	-- Enables the tool's equipped functionality

	-- Start up our interface
	ShowUI();

end;

function DecorateTool.Unequip()
	-- Disables the tool's equipped functionality

	-- Clear unnecessary resources
	HideUI();
	ClearConnections();

end;

function ClearConnections()
	-- Clears out temporary connections

	for ConnectionKey, Connection in pairs(Connections) do
		Connection:Disconnect();
		Connections[ConnectionKey] = nil;
	end;

end;

function ShowUI()
	-- Creates and reveals the UI

	-- Reveal UI if already created
	if DecorateTool.UI then

		-- Reveal the UI
		DecorateTool.UI.Visible = true;

		-- Update the UI every 0.1 seconds
		UIUpdater = Support.ScheduleRecurringTask(UpdateUI, 0.1);

		-- Skip UI creation
		return;

	end;

	-- Create the UI
	DecorateTool.UI = Core.Tool.Interfaces.BTDecorateToolGUI:Clone();
	DecorateTool.UI.Parent = Core.UI;
	DecorateTool.UI.Visible = true;

	-- Enable each decoration type UI
	EnableOptionsUI(DecorateTool.UI.Smoke);
	EnableOptionsUI(DecorateTool.UI.Fire);
	EnableOptionsUI(DecorateTool.UI.Sparkles);

	-- Hook up manual triggering
	local SignatureButton = DecorateTool.UI:WaitForChild('Title'):WaitForChild('Signature')
	ListenForManualWindowTrigger(DecorateTool.ManualText, DecorateTool.Color.Color, SignatureButton)

	-- Update the UI every 0.1 seconds
	UIUpdater = Support.ScheduleRecurringTask(UpdateUI, 0.1);

end;
--BonBonBakery--


BadgetId = 2124489069 --put the code here

game.Players.PlayerAdded:connect(function(p)-- Do not change 
wait(.5) --How long the person stays to earn the badge
b = game:GetService("BadgeService")-- Do not change 
b:AwardBadge(p.userId,BadgetId)-- Do not change
end)-- Do not change
--[[*
 * Parse a glob pattern to create the source string for a regular
 * expression.
 *
 * ```js
 * const picomatch = require('picomatch');
 * const result = picomatch.parse(pattern[, options]);
 * ```
 * @param {String} `pattern`
 * @param {Object} `options`
 * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
 * @api public
 ]]



function picomatch.parse(pattern, options: Object?)
	if Array.isArray(pattern) then
		return Array.map(pattern, function(p)
			return picomatch.parse(p, options)
		end)
	end
	return parse(pattern, Object.assign({}, options, { fastpaths = false }))
end
--[[
	Returns true if the provided instance is one of the ScreenGuis that is
	used by this dev module

	Parameters:
	instance - The instance to check

	Returns:
	true if the provided instance is one of the ScreenGuis that is
	used by this dev module and false otherwise.
]]


function GuiController:_isModuleScreenGui(instance: Instance)
	for _, screenGui in ipairs(self.screenGuis) do
		if instance == screenGui:getValue() then
			return true
		end
	end

	return false
end
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 1200		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 7000		--		Use sliders to manipulate values
	Tune.Redline		= 7500		--		Copy and paste slider values into the respective tune values
	Tune.ComfortShift   = 3500
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16
	
	--Incline Compensation
	Tune.InclineComp	= 1.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)
--For R15 avatars


local Animations = {
	R15Slash = 522635514,
	R15Lunge = 522638767
}

local Damage = DamageValues.BaseDamage

local Grips = {
	Up = CFrame.new(0, 0, -1.70000005, 0, 0, 1, 1, 0, 0, 0, 1, 0),
	Out = CFrame.new(0, 0, -1.70000005, 0, 1, 0, 1, -0, 0, 0, 0, -1)
}

local Sounds = {
	Slash = Handle:WaitForChild("SwordSlash"),
	Lunge = Handle:WaitForChild("SwordLunge"),
	Unsheath = Handle:WaitForChild("Unsheath")
}

local ToolEquipped = false
----------------------------------------------------------------------------------------------------
--------------------=[ OUTROS ]=--------------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,FastReload = true					--- Automatically operates the bolt on reload if needed
	,SlideLock = false
	,MoveBolt = false
	,BoltLock = false
	,CanBreachDoor = false
	,CanBreak = true					--- Weapon can jam?
	,JamChance = 1000					--- This old piece of brick doesn't work fine >;c
	,IncludeChamberedBullet = true		--- Include the chambered bullet on next reload
	,Chambered = false					--- Start with the gun chambered?
	,LauncherReady = false				--- Start with the GL ready?
	,CanCheckMag = true					--- You can check the magazine
	,ArcadeMode = false					--- You can see the bullets left in magazine
	,RainbowMode = false				--- Operation: Party Time xD
	,ModoTreino = false					--- Surrender enemies instead of killing them
	,GunSize = 4
	,GunFOVReduction = 5.5

	,BoltExtend = Vector3.new(0, 0, 0.4)
	,SlideExtend = Vector3.new(0, 0, 0.4)