Pinkstack/roblox-luau-corpus-text huggingface dataset:
-- If in-game, enable ctrl hotkeys for sibling selection & selection clearing


if Mode == 'Tool' then
	AssignHotkey({ 'LeftControl', 'LeftBracket' }, Support.Call(Targeting.SelectSiblings, false, false));
	AssignHotkey({ 'RightControl', 'LeftBracket' }, Support.Call(Targeting.SelectSiblings, false, false));
	AssignHotkey({ 'LeftControl', 'R' }, Support.Call(Selection.Clear, true));
	AssignHotkey({ 'RightControl', 'R' }, Support.Call(Selection.Clear, true));
end;

function GroupSelection(GroupType)
	-- Groups the selected items

	-- Create history record
	local HistoryRecord = {
		Items = Support.CloneTable(Selection.Items),
		CurrentParents = Support.GetListMembers(Selection.Items, 'Parent')
	}

	function HistoryRecord:Unapply()
		SyncAPI:Invoke('SetParent', self.Items, self.CurrentParents)
		SyncAPI:Invoke('Remove', { self.NewParent })
		Selection.Replace(self.Items)
	end

	function HistoryRecord:Apply()
		SyncAPI:Invoke('UndoRemove', { self.NewParent })
		SyncAPI:Invoke('SetParent', self.Items, self.NewParent)
		Selection.Replace({ self.NewParent })
	end

	-- Perform group creation
	HistoryRecord.NewParent = SyncAPI:Invoke('CreateGroup', GroupType,
		GetHighestParent(HistoryRecord.Items),
		HistoryRecord.Items
	)

	-- Register history record
	History.Add(HistoryRecord)

	-- Select new group
	Selection.Replace({ HistoryRecord.NewParent })

end

function UngroupSelection()
	-- Ungroups the selected groups

	-- Create history record
	local HistoryRecord = {
		Selection = Selection.Items
	}

	function HistoryRecord:Unapply()
		SyncAPI:Invoke('UndoRemove', self.Groups)

		-- Reparent children
		for GroupId, Items in ipairs(self.GroupChildren) do
			coroutine.resume(coroutine.create(function ()
				SyncAPI:Invoke('SetParent', Items, self.Groups[GroupId])
			end))
		end

		-- Reselect groups
		Selection.Replace(self.Selection)
	end

	function HistoryRecord:Apply()

		-- Get groups from selection
		self.Groups = {}
		for _, Item in ipairs(self.Selection) do
			if Item:IsA 'Model' or Item:IsA 'Folder' then
				self.Groups[#self.Groups + 1] = Item
			end
		end

		-- Perform ungrouping
		self.GroupParents = Support.GetListMembers(self.Groups, 'Parent')
		self.GroupChildren = SyncAPI:Invoke('Ungroup', self.Groups)

		-- Get unpacked children
		local UnpackedChildren = Support.CloneTable(self.Selection)
		for GroupId, Children in pairs(self.GroupChildren) do
			for _, Child in ipairs(Children) do
				UnpackedChildren[#UnpackedChildren + 1] = Child
			end
		end

		-- Select unpacked items
		Selection.Replace(UnpackedChildren)

	end

	-- Perform action
	HistoryRecord:Apply()

	-- Register history record
	History.Add(HistoryRecord)

end
--[=[
	@within Plasma
	@function arrow
	@tag widgets
	@param from Vector3 | CFrame | BasePart
	@param to Vector3 | BasePart | nil
	@param color Color3? -- Optional color. Random if not specified.

	- `arrow(from: Vector3, to: Vector3)` -> Creates an arrow between `from` and `to`
	- `arrow(point: Vector3)` -> Creates an arrow pointing at `point`
	- `arrow(cframe: CFrame)` -> Creates an arrow with its point at the CFrame position facing the CFrame LookVector
	- `arrow(part: BasePart)` -> Arrow represents the Part's CFrame
	- `arrow(fromPart: BasePart, toPart: BasePart)` -> Arrow between the two parts

	![Arrows](https://i.eryn.io/2150/arrows.png)

	```lua
	Plasma.arrow(Vector3.new(0, 0, 0))
	Plasma.arrow(Vector3.new(5, 5, 5), Vector3.new(10, 10, 10))
	```
]=]



local function arrow(name, container, scale, color, zindex)
	local body = Instance.new("CylinderHandleAdornment")

	body.Name = name .. "Body"
	body.Color3 = color
	body.Radius = 0.15
	body.Adornee = workspace.Terrain
	body.Transparency = 0
	body.Radius = 0.15 * scale
	body.Transparency = 0
	body.AlwaysOnTop = true
	body.ZIndex = zindex

	body.Parent = container

	local point = Instance.new("ConeHandleAdornment")

	scale = scale == 1 and 1 or 1.4

	point.Name = name .. "Point"
	point.Color3 = color
	point.Radius = 0.5 * scale
	point.Transparency = 0
	point.Adornee = workspace.Terrain
	point.Height = 2 * scale
	point.AlwaysOnTop = true
	point.ZIndex = zindex

	point.Parent = container
end

local function update(body, point, from, to, scale)
	body.Height = (from - to).magnitude - 2
	body.CFrame = CFrame.lookAt(((from + to) / 2) - ((to - from).unit * 1), to)
	point.CFrame = CFrame.lookAt((CFrame.lookAt(to, from) * CFrame.new(0, 0, -2 - ((scale - 1) / 2))).p, to)
end

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

return Runtime.widget(function(from, to, color)
	local fallbackColor = Runtime.useState(BrickColor.random().Color)
	color = color or fallbackColor

	if typeof(from) == "Instance" then
		if from:IsA("BasePart") then
			from = from.CFrame
		elseif from:IsA("Attachment") then
			from = from.WorldCFrame
		end

		if to ~= nil then
			from = from.p
		end
	end

	if typeof(to) == "Instance" then
		if to:IsA("BasePart") then
			to = to.Position
		elseif to:IsA("Attachment") then
			to = to.WorldPosition
		end
	end

	if typeof(from) == "CFrame" and to == nil then
		local look = from.lookVector
		to = from.p
		from = to + (look * -10)
	end

	if to == nil then
		to = from
		from = to + Vector3.new(0, 10, 0)
	end

	assert(typeof(from) == "Vector3" and typeof(to) == "Vector3", "Passed parameters are of invalid types")

	local refs = Runtime.useInstance(function(ref)
		local container = Instance.new("Folder")
		container.Name = "Arrow"

		ref.folder = container

		arrow("front", container, 1, color, 1)
		arrow("back", container, 2, Color3.new(0, 0, 0), -1)

		return container
	end)

	local folder = refs.folder

	update(folder.frontBody, folder.frontPoint, from, to, 1)
	update(folder.backBody, folder.backPoint, from, to, 1.4)

	folder.frontBody.Color3 = color
	folder.frontPoint.Color3 = color
end)
--[[
	*
	* Signals allow events to be dispatched to any number of listeners.
]]


local Signal
do
	Signal = setmetatable({}, {
		__tostring = function()
			return "Signal"
		end,
	})
	Signal.__index = Signal
	function Signal.new(...)
		local self = setmetatable({}, Signal)
		return self:constructor(...) or self
	end
	function Signal:constructor()
		self.waitingThreads = {}
		self._handlerListHead = nil
	end
	function Signal:Connect(callback)
		local connection = Connection.new(self, callback)
		if self._handlerListHead ~= nil then
			connection._next = self._handlerListHead
		end
		self._handlerListHead = connection
		return connection
	end
	function Signal:Once(callback)
		local done = false
		local c
		c = self:Connect(function(...)
			local args = { ... }
			if done then
				return nil
			end
			done = true
			c:Disconnect()
			callback(unpack(args))
		end)
		return c
	end
	function Signal:Fire(...)
		local args = { ... }
		local item = self._handlerListHead
		while item do
			if item.Connected then
				task.spawn(item._fn, unpack(args))
			end
			item = item._next
		end
	end
	function Signal:FireDeferred(...)
		local args = { ... }
		local item = self._handlerListHead
		while item do
			if item.Connected then
				task.defer(item._fn, unpack(args))
			end
			item = item._next
		end
	end
	function Signal:Wait()
		local running = coroutine.running()
		self.waitingThreads[running] = true
		self:Once(function(...)
			local args = { ... }
			self.waitingThreads[running] = nil
			task.spawn(running, unpack(args))
		end)
		return coroutine.yield()
	end
	function Signal:DisconnectAll()
		local item = self._handlerListHead
		while item do
			item.Connected = false
			item = item._next
		end
		self._handlerListHead = nil
		local _waitingThreads = self.waitingThreads
		local _arg0 = function(thread)
			return task.cancel(thread)
		end
		for _v in _waitingThreads do
			_arg0(_v, _v, _waitingThreads)
		end
		table.clear(self.waitingThreads)
	end
	function Signal:Destroy()
		self:DisconnectAll()
	end
end
return {
	Connection = Connection,
	Signal = Signal,
}
------------------------------------------------------------------------
--
-- * used only in luaK:prefix()
------------------------------------------------------------------------


function luaK:codenot(fs, e)
  self:dischargevars(fs, e)
  local k = e.k
  if k == "VNIL" or k == "VFALSE" then
    e.k = "VTRUE"
  elseif k == "VK" or k == "VKNUM" or k == "VTRUE" then
    e.k = "VFALSE"
  elseif k == "VJMP" then
    self:invertjump(fs, e)
  elseif k == "VRELOCABLE" or k == "VNONRELOC" then
    self:discharge2anyreg(fs, e)
    self:freeexp(fs, e)
    e.info = self:codeABC(fs, "OP_NOT", 0, e.info, 0)
    e.k = "VRELOCABLE"
  else
    assert(0)  -- cannot happen
  end
  -- interchange true and false lists
  e.f, e.t = e.t, e.f
  self:removevalues(fs, e.f)
  self:removevalues(fs, e.t)
end
---------------
-- Constants --
---------------



local POP_RESTORE_RATE = 0.3
local CAST_SCREEN_SCALES = { -- (Relative)
	Vector2.new(1, 1) / 2, -- Center
	Vector2.new(0, 0), -- Top left
	Vector2.new(1, 0), -- Top right
	Vector2.new(1, 1), -- Bottom right
	Vector2.new(0, 1), -- Bottom left
}
local NEAR_CLIP_PLANE_OFFSET = 0.5 --NOTE: Not configurable
--[[Driver Handling]]



	--Driver Sit	
	car.Body.CarName.Value.VehicleSeat.ChildAdded:connect(function(child)
		if child.Name=="SeatWeld" and child:IsA("Weld") and game.Players:GetPlayerFromCharacter(child.Part1.Parent)~=nil then
			--Distribute Client Interface
			local p=game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			car.Body.CarName.Value.VehicleSeat:SetNetworkOwner(p)
			local g=script.Parent["A-Chassis Interface"]:Clone()
			g.Parent=p.PlayerGui
		end
	end)
	
	--Driver Leave
	car.Body.CarName.Value.VehicleSeat.ChildRemoved:connect(function(child)
		if child.Name=="SeatWeld" and child:IsA("Weld") then
			--Remove Flip Force
			if car.Body.CarName.Value.VehicleSeat:FindFirstChild("Flip")~=nil then
				car.Body.CarName.Value.VehicleSeat.Flip.MaxTorque = Vector3.new()
			end
			
			--Remove Wheel Force
			for i,v in pairs(car.Wheels:GetChildren()) do
				if v:FindFirstChild("#AV")~=nil then
					if v["#AV"]:IsA("BodyAngularVelocity") then
						if v["#AV"].AngularVelocity.Magnitude>0 then
							v["#AV"].AngularVelocity = Vector3.new()
							v["#AV"].MaxTorque = Vector3.new()
						end
					else
						if v["#AV"].AngularVelocity>0 then
							v["#AV"].AngularVelocity = 0
							v["#AV"].MotorMaxTorque = 0
						end
					end
				end
			end
		end
	end)
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,VRecoil = {14,18}				--- Vertical Recoil
	,HRecoil = {9,12}				--- Horizontal Recoil
	,AimRecover = .65				---- Between 0 & 1
	
	,RecoilPunch = .15
	,VPunchBase = 2.55				--- Vertical Punch
	,HPunchBase = 1.6				--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless
	
	,AimRecoilReduction = 5 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.2
	,MinRecoilPower = .5
	,MaxRecoilPower = 3
	,RecoilPowerStepAmount = .25
	
	,MinSpread = 0.95				--- Min bullet spread value | Studs
	,MaxSpread = 47					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = .75
	,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
-- May return NaN or inf or -inf
-- This is a way of finding the angle between the two vectors:


local function findAngleBetweenXZVectors(vec2, vec1)
	return math.atan2(vec1.X*vec2.Z-vec1.Z*vec2.X, vec1.X*vec2.X + vec1.Z*vec2.Z)
end

local function CreateAttachCamera()
	local module = RootCameraCreator()
	
	local lastUpdate = tick()
	function module:Update()
		local now = tick()
		
		local camera = 	workspace.CurrentCamera
		local player = PlayersService.LocalPlayer
		
		if lastUpdate == nil or now - lastUpdate > 1 then
			module:ResetCameraLook()
			self.LastCameraTransform = nil
		end	
		
		local subjectPosition = self:GetSubjectPosition()		
		if subjectPosition and player and camera then
			local zoom = self:GetCameraZoom()
			if zoom <= 0 then
				zoom = 0.1
			end
			
			if self.LastCameraTransform then
				local humanoid = self:GetHumanoid()
				if lastUpdate and humanoid and humanoid.Torso then
					local forwardVector = humanoid.Torso.CFrame.lookVector

					local y = findAngleBetweenXZVectors(forwardVector, self:GetCameraLook())
					if IsFinite(y) and math.abs(y) > 0.0001 then
						self.RotateInput = self.RotateInput + Vector2.new(y, 0)
					end
				end
			end
			local newLookVector = self:RotateCamera(self:GetCameraLook(), self.RotateInput)
			self.RotateInput = Vector2.new()
			
			camera.Focus = CFrame.new(subjectPosition)
			camera.CoordinateFrame = CFrame.new(camera.Focus.p - (zoom * newLookVector), camera.Focus.p)
			self.LastCameraTransform = camera.CoordinateFrame
		end
		lastUpdate = now
	end
	
	return module
end

return CreateAttachCamera
-- Shift to sprint script for Stamina System V1.
-- Delete if you don't want to use.



local UserInputService = game:GetService("UserInputService")
local StaminaModule = require(script.Parent.StaminaModule)
local TweenService = game:GetService("TweenService")
local player = game.Players.LocalPlayer

local defaultSpeed = 16
local belowStaminaSpeed = 18
local sprintSpeed = 24
local staminaDeductRate = 1
local staminaDeductInterval = 0.1
local minimumStaminaToSprint = 15
local sprinting = false
local regainDelay = 1
local belowStaminaDelay = 2

local function deductStamina()
	while sprinting and StaminaModule.StaminaValue.Value > 0 do
		local character = player.Character
		if character then
			local humanoid = character:WaitForChild("Humanoid")
			-- Only deduct stamina if the player is moving
			if humanoid.MoveDirection.Magnitude > 0 then
				StaminaModule.RemoveStamina(staminaDeductRate)
				StaminaModule.StaminaCanRegen = false
			else
				StaminaModule.StaminaCanRegen = true
			end
		end
		wait(staminaDeductInterval)
	end
end

local function tweenWalkSpeed(humanoid, speed, time)
	local info = TweenInfo.new(time)
	local tween = TweenService:Create(humanoid, info, {WalkSpeed = speed})
	tween:Play()
end

UserInputService.InputBegan:Connect(function(input)
	if input.KeyCode == Enum.KeyCode.LeftShift then
		local character = player.Character
		if character then
			local humanoid = character:WaitForChild("Humanoid")
			if StaminaModule.StaminaValue.Value >= minimumStaminaToSprint then
				tweenWalkSpeed(humanoid, sprintSpeed, 1)
				sprinting = true
				StaminaModule.StaminaCanRegen = false
				deductStamina()
			end
		end
	end
end)

UserInputService.InputEnded:Connect(function(input)
	if input.KeyCode == Enum.KeyCode.LeftShift then
		local character = player.Character
		if character then
			local humanoid = character:WaitForChild("Humanoid")
			tweenWalkSpeed(humanoid, defaultSpeed, 1)
			sprinting = false
			wait(regainDelay)
			StaminaModule.StaminaCanRegen = true
		end
	end
end)

StaminaModule.StaminaValue:GetPropertyChangedSignal("Value"):Connect(function()
	local character = player.Character
	if character then
		local humanoid = character:WaitForChild("Humanoid")
		if StaminaModule.StaminaValue.Value < minimumStaminaToSprint and sprinting then
			tweenWalkSpeed(humanoid, belowStaminaSpeed, 2)
		end
		if StaminaModule.StaminaValue.Value <= 0 then
			tweenWalkSpeed(humanoid, defaultSpeed, 1)
			sprinting = false
			wait(belowStaminaDelay)
			StaminaModule.StaminaCanRegen = true
		end
	end
end)
-- Colors


local FriendlyReticleColor = Color3.new(1, 0, 0)
local EnemyReticleColor	= Color3.new(1, 0, 0)
local NeutralReticleColor	= Color3.new(1, 0, 0)

local Spread = MinSpread
local AmmoInClip = ClipSize

local Tool = script.Parent
local Handle = WaitForChild(Tool, 'Handle')
local WeaponGui = nil

local LeftButtonDown
local Reloading = false
local IsShooting = false
-- Detectors



local handler = DriveSeat.AirbagFilter

local side = nil
local sent = false
local speedVar = nil
function handle(x, y)
	if x == nil then print('Errored!') end
	if sent == false then
		if speedVar > 20 and DriveSeat.Parent.Electrics.Value == true then
			if y.CanCollide == true then
				handler:FireServer(x)
				print('fired to remote')
				script.Parent.epicFrame.Visible = true
				DriveSeat.FE_Lights:FireServer('blinkers', 'Hazards')
				wait(2)
				sent = false
			end
		end
	end
end
-- Settings



local amientReverb : EnumItem = Enum.ReverbType.Alley

local bubbleChatEnabled : boolean = false

local gravity : number = 196.2 -- 35 is realistic

local walkSpeed : number = 16 -- 17 is good for low gravity
local jumpPower : number = 50 -- 16 is good for low gravity
local respawnTime : number = 5 -- 1 is enough

local clockTime : number = 0
local fogColor : Color3 = Color3.fromRGB(0, 0, 0)
local fogEnd : number = 150
local fogStart : number = 0
--Fuction that plays when we click the button.


Button.MouseClick:Connect(function(player)
	local newcode = game.ReplicatedStorage:WaitForChild("CodeDoor"):InvokeClient(player)  --we invoke the players client and wait until they return the code

	if newcode == Code.Value then
		print('correct')
		Light.Color = Color3.fromRGB(73, 181, 71)					--Light (part) color changes
		Light.PointLight.Color = Color3.fromRGB(73, 181, 71)		--PointLight color changes (optional, disabled by default)							
		script.Parent.Parent.Lock.Disabled = false
		script.Parent.Button:Destroy()
	else 		--If the code is not correct, we just print "incorrect"
		print('incorrect') 
	end
end)
--Made by Stickmasterluke




sp=script.Parent

db=true

firerate=22
power=50
rate=1/30

debris=game:GetService("Debris")
equipped=false
check=true

local event = script.Parent:WaitForChild("RemoteEvent")


function onEquipped(mouse)
	equipped=true
	if mouse~=nil then
		mouse.Button1Down:connect(function()
			if db then
			event:FireServer(mouse.Hit,check)
			db=false			
			wait(firerate)
			db=true			
			end
		end)
	end
end

function onUnequipped()
	equipped=false
	sp.Handle.Transparency=1
end

sp.Equipped:connect(onEquipped)
sp.Unequipped:connect(onUnequipped)
--LIBS
-- RANDOM
---- WeightedRandom(t, default)
----- Uses a simple weighted random technique to choose
-----  a table value based on its weight.
----- Syntax for the table must be like this:
------ { Value = [value], Weight = [weight] }
----- The function will return the Value key of the 
-----  chosen table.
----- You may specify a default value if you are
-----  completely insane.
---- TrueRandom(min, max)
----- Multiplies the min and max by 100, uses math.random
-----  on those, and then divides the result by 100
----- Mostly just did this to get finer granularity from
-----  random numbers
-- TABLES
---- IndexOf(t, obj)
----- Given a table t, returns the index of the specified
-----  object obj, assuming the object is in the table.
----- By default, returns 0.
---- Contains(t, obj)
----- Returns a boolean representing whether or not the 
-----  specified object is in the table.
-- VECTOR3
---- Half(vector)
----- Just halves a vector with a "/ 2"
----- Don't know why I needed this.
---- Distance(vec1, vec2)
----- Returns the distance between two vectors.
--// Positioning


	RightArmPos = CFrame.new(-0.902175903, 0.295501232, -1.32277012, 1, 0, 0, 0, 1.19248806e-08, 1, 0, -1, 1.19248806e-08);
	LeftArmPos = CFrame.new(1.06851184, 0.973718464, -1.99667926, 0.787567914, -0.220087856, -0.575584888, -0.615963876, -0.308488727, 0.724860668, 0.0180283934, -0.925416589, -0.378522098);
	GunPos = CFrame.new(0.284460306, -0.318524063, 1.06423128, 1, 0, 0, 0, -2.98023224e-08, -0.99999994, 0, 0.99999994, -2.98023224e-08);
-- Constructs a new state. Should not be called directly.
-- @param Table or Instance
-- @param StateMachine
-- @return BaseState


function BaseState.New(stateFolder,StateMachine)
	local self = {}
	setmetatable(self,BaseState)

	self.stateFolder = stateFolder
	self.StateMachine = StateMachine

	self.handles = {}
	self.stateTime = 0
	self.offStateTime = 0

	return self
end
--PromptChained
--* very similar to PromptShown, except there are no responses.
--* that means there's a prompt following this prompt. the only
--* responsibility of this function is to call the clalback in
--* order to acknowledge that the chain should proceed. this
--* allows you to use your own timing scheme for how the chain
--* should proceed, with a continue button, arbitrary timing, etc.
--* promptTable is in the following format:
--* {
--* 	Line = "The prompt string.",
--* 	Data = [the data from the prompt node],
--* }


function Interface.PromptChained(dialogueFolder, promptTable, callback)
	
end

return Interface
--[[Weight and CG]]


	Tune.Weight			= 6500		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		6		,
	 --[[Height]]		4		,
	 --[[Length]]		15		}
	Tune.WeightDist		= 50		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible
	
	--Unsprung Weight
	Tune.FWheelDensity	= .1		-- Front Wheel Density
	Tune.RWheelDensity	= .1		-- 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
--- Returns whether it should be possible to scope into the given item.
-- @returns boolean


local function IsItemScopable(Item)
    return Item:IsA('Model')
        or Item:IsA('Folder')
        or Item:IsA('Tool')
        or Item:IsA('Accessory')
        or Item:IsA('Accoutrement')
        or (Item:IsA('BasePart') and Item:FindFirstChildWhichIsA('BasePart', true))
end
-- UI elements



local intro = script.Parent:WaitForChild("Intro")
intro.Visible = true

local tokensLabel = script.Parent:WaitForChild("Tokens") -- the textlabel in our maingui
local tokens = game.Players.LocalPlayer:WaitForChild("Tokens") -- value with our tokens in the player object

wait(2)

game.Workspace.Camera.CameraType = Enum.CameraType.Scriptable
game.Workspace.Camera.CFrame = CFrame.new(game.Workspace.IntroTunnel.CameraOrigin.Position,game.Workspace.IntroTunnel.CameraFace.Position)

local topStatus = script.Parent:WaitForChild("TopStatus")
topStatus.Text = status.Value

status:GetPropertyChangedSignal("Value"):Connect(function()
	topStatus.Text = status.Value
end)

tokensLabel.Text = tokens.Value
tokens:GetPropertyChangedSignal("Value"):Connect(function()
	tokensLabel.Text = tokens.Value
end)

intro.Play.MouseButton1Click:Connect(function()
	if game.ReplicatedStorage.MapVoting.Value == true then
		script.Parent.MapVoting.Visible = true
	end
	
	intro.Visible = false
	topStatus.Visible = true
	game.ReplicatedStorage.MenuPlay:FireServer()
	game.Workspace.Camera.CameraType = Enum.CameraType.Custom
end)

game.ReplicatedStorage.KillFeed.OnClientEvent:Connect(function(text)
	script.Parent.KillFeed.Visible = true
	script.Parent.KillFeed.Text = text
	wait(2)
	script.Parent.KillFeed.Visible = false
end)

game.ReplicatedStorage.Announcement.OnClientEvent:Connect(function(text)
	script.Parent.Announcement.Text = text
	script.Parent.Announcement.Visible = true
	wait(5)
	script.Parent.Announcement.Visible = false
end)

intro.Store.MouseButton1Click:Connect(function()
	script.Parent:WaitForChild("Shop").Visible = true
	intro.Visible = false
end)

script.Parent:WaitForChild("ShopBtn").MouseButton1Click:Connect(function()
	script.Parent:WaitForChild("Shop").Visible = not script.Parent:WaitForChild("Shop").Visible
end)

script.Parent:WaitForChild("Shop"):WaitForChild("Close").MouseButton1Click:Connect(function()
	if game.Players.LocalPlayer:FindFirstChild("InMenu") then
		-- we know you are in the menu
		intro.Visible = true
	end
	script.Parent:WaitForChild("Shop").Visible = false	
end)
--face = "none",


},

toolbar = {
{name = "Rock",
lastSwing = 0,}, -- 1
{},  -- 2
{}, -- 3
{}, -- 4
{}, -- 5
{}, -- 6
}, -- end of toolbar

customRecipes = {},

ownedCosmetics = {},

} -- end of default data table

end, -- end of function
} -- end of module
return module