Roblox/luau_corpus huggingface dataset:
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 213		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 800		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 8000		--		Use sliders to manipulate values
	Tune.Redline		= 9000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 6100
	Tune.PeakSharpness	= 3.8
	Tune.CurveMult		= 0.07
	
	--Incline Compensation
	Tune.InclineComp	= 1.5		-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 900		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 450		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 0			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response, lower = more stable RPM)
------------------------------------------------------------------------
--
-- * used in (lparser) luaY:assignment(), luaY:localfunc(), luaY:funcstat()
------------------------------------------------------------------------
function luaK:storevar(fs, var, ex)
  local k = var.k
  if k == "VLOCAL" then
    self:freeexp(fs, ex)
    self:exp2reg(fs, ex, var.info)
    return
  elseif k == "VUPVAL" then
    local e = self:exp2anyreg(fs, ex)
    self:codeABC(fs, "OP_SETUPVAL", e, var.info, 0)
  elseif k == "VGLOBAL" then
    local e = self:exp2anyreg(fs, ex)
    self:codeABx(fs, "OP_SETGLOBAL", e, var.info)
  elseif k == "VINDEXED" then
    local e = self:exp2RK(fs, ex)
    self:codeABC(fs, "OP_SETTABLE", var.info, var.aux, e)
  else
    assert(0)  -- invalid var kind to store
  end
  self:freeexp(fs, ex)
end
------------------------------------------------------------------------
-- general function to write an instruction into the instruction buffer,
-- sets debug information too
-- * used in luaK:codeABC(), luaK:codeABx()
-- * called directly by (lparser) luaY:whilestat()
------------------------------------------------------------------------
function luaK:code(fs, i, line)
  local f = fs.f
  self:dischargejpc(fs)  -- 'pc' will change
  -- put new instruction in code array
  luaY:growvector(fs.L, f.code, fs.pc, f.sizecode, nil,
                  luaY.MAX_INT, "code size overflow")
  f.code[fs.pc] = i
  -- save corresponding line information
  luaY:growvector(fs.L, f.lineinfo, fs.pc, f.sizelineinfo, nil,
                  luaY.MAX_INT, "code size overflow")
  f.lineinfo[fs.pc] = line
  local pc = fs.pc
  fs.pc = fs.pc + 1
  return pc
end
--		{Id = "slash.xml", Weight = 10},
	},
	ToolLunge = {
		{Id = "http://www.roblox.com/asset/?id=129967478", Weight = 10},
	},
	Wave = {
		{Id = "http://www.roblox.com/asset/?id=128777973", Weight = 10},
	},
	Point = {
		{Id = "http://www.roblox.com/asset/?id=128853357", Weight = 10},
	},
	Dance = {
		{Id = "http://www.roblox.com/asset/?id=130018893", Weight = 10},
		{Id = "http://www.roblox.com/asset/?id=132546839", Weight = 10},
		{Id = "http://www.roblox.com/asset/?id=132546884", Weight = 10},
	},
	Dance2 = {
		{Id = "http://www.roblox.com/asset/?id=160934142", Weight = 10},
		{Id = "http://www.roblox.com/asset/?id=160934298", Weight = 10},
		{Id = "http://www.roblox.com/asset/?id=160934376", Weight = 10},
	},
	Dance3 = {
		{Id = "http://www.roblox.com/asset/?id=160934458", Weight = 10},
		{Id = "http://www.roblox.com/asset/?id=160934530", Weight = 10},
		{Id = "http://www.roblox.com/asset/?id=160934593", Weight = 10},
	},
	Laugh = {
		{Id = "http://www.roblox.com/asset/?id=129423131", Weight = 10},
	},
	Cheer = {
		{Id = "http://www.roblox.com/asset/?id=129423030", Weight = 10},
	},
}
-- Container for temporary connections (disconnected automatically)
local Connections = {};

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

	-- Start up our interface
	ShowUI();
	EnableClickCreation();

	-- Set our current type
	SetType(NewPartTool.Type);

end;

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

	-- Clear unnecessary resources
	HideUI();
	ClearConnections();
	ContextActionService:UnbindAction('BT: Create part')

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 UI then

		-- Reveal the UI
		UI.Visible = true;

		-- Skip UI creation
		return;

	end;

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

	-- Creatable part types
	Types = { 'Normal', 'Truss', 'Wedge', 'Corner', 'Cylinder', 'Ball', 'Seat', 'Vehicle Seat', 'Spawn' };

	-- Create the type selection dropdown
	TypeDropdown = Core.Cheer(UI.TypeOption.Dropdown).Start(Types, '', function (Type)
		SetType(Type);
	end);

end;

function HideUI()
	-- Hides the tool UI

	-- Make sure there's a UI
	if not UI then
		return;
	end;

	-- Hide the UI
	UI.Visible = false;

end;

function SetType(Type)

	-- Update the tool option
	NewPartTool.Type = Type;

	-- Update the UI
	TypeDropdown.SetOption(Type);

end;

function EnableClickCreation()
	-- Allows the user to click anywhere and create a new part

	local function CreateAtTarget(Action, State, Input)

		-- Drag new parts
		if State.Name == 'Begin' then
			DragNewParts = true
			Core.Targeting.CancelSelecting()

			-- Create new part
			CreatePart(NewPartTool.Type)

		-- Disable dragging on release
		elseif State.Name == 'End' then
			DragNewParts = nil
		end

	end

	-- Register input handler
	ContextActionService:BindAction('BT: Create part', CreateAtTarget, false,
		Enum.UserInputType.MouseButton1,
		Enum.UserInputType.Touch
	)

end;

function CreatePart(Type)

	-- Send the creation request to the server
	local Part = Core.SyncAPI:Invoke('CreatePart', Type, CFrame.new(Core.Mouse.Hit.p), Core.Targeting.Scope)

	-- Make sure the part creation succeeds
	if not Part then
		return;
	end;

	-- Put together the history record
	local HistoryRecord = {
		Part = Part;

		Unapply = function (HistoryRecord)
			-- Reverts this change

			-- Remove the part
			Core.SyncAPI:Invoke('Remove', { HistoryRecord.Part });

		end;

		Apply = function (HistoryRecord)
			-- Reapplies this change

			-- Restore the part
			Core.SyncAPI:Invoke('UndoRemove', { HistoryRecord.Part });

		end;

	};

	-- Register the history record
	Core.History.Add(HistoryRecord);

	-- Select the part
	Selection.Replace({ Part });

	-- Switch to the move tool
	local MoveTool = require(Core.Tool.Tools.Move);
	Core.EquipTool(MoveTool);

	-- Enable dragging to allow easy positioning of the created part
	if DragNewParts then
		MoveTool.FreeDragging:SetUpDragging(Part)
	end;

end;
--[=[
	@type PerServiceMiddleware {[string]: Middleware}
	@within KnitClient
]=]
type PerServiceMiddleware = { [string]: Middleware }
--- Recalculate the window height
function Window:UpdateWindowHeight()
	local windowHeight = LINE_HEIGHT

	for _, child in pairs(Gui:GetChildren()) do
		if child:IsA("GuiObject") then
			windowHeight = windowHeight + child.Size.Y.Offset
		end
	end

	Gui.CanvasSize = UDim2.new(Gui.CanvasSize.X.Scale, Gui.CanvasSize.X.Offset, 0, windowHeight)
	Gui.Size =
		UDim2.new(
			Gui.Size.X.Scale,
			Gui.Size.X.Offset,
			0,
			windowHeight > WINDOW_MAX_HEIGHT and WINDOW_MAX_HEIGHT or windowHeight
		)

	Gui.CanvasPosition = Vector2.new(0, math.clamp(windowHeight - 300, 0, math.huge))
end
-- For those who prefer distinct functions
function ControlModule:Disable()
	self.controlsEnabled = false
	
	self:UpdateActiveControlModuleEnabled()
end
-- Services
local Players = game:GetService("Players")
local ContentProvider = game:GetService("ContentProvider")
--[[function util.NewSky(sky,clearchildren)

	local ccbool = clearchildren or true
	local skyc = sky:GetChildren() or game:GetService("ReplicatedStorage").storage.lighting.general:GetChildren()
	
	if ccbool == true then game:GetService("Lighting"):ClearAllChildren() end
	
	for i,v in pairs(skyc) do
		v:Clone().Parent = game:GetService("Lighting")
	end
	
end]]--


return util
--Collision
character.Head.CollisionGroupId = 1
character.UpperTorso.CollisionGroupId = 1
character.LowerTorso.CollisionGroupId = 1
character.HumanoidRootPart.CanCollide = false
character.HumanoidRootPart.CollisionGroupId = 5
character.RightUpperArm.CollisionGroupId = 1
character.LeftUpperArm.CollisionGroupId = 1
character.RightUpperLeg.CollisionGroupId = 1
character.LeftUpperLeg.CollisionGroupId = 1
character.RightLowerArm.CollisionGroupId = 0
character.LeftLowerArm.CollisionGroupId = 0
character.RightLowerLeg.CollisionGroupId = 0
character.LeftLowerLeg.CollisionGroupId = 0
character.RightHand.CollisionGroupId = 1
character.LeftHand.CollisionGroupId = 1
character.RightFoot.CollisionGroupId = 1
character.LeftFoot.CollisionGroupId = 1


end
	
end)
--[[Driving Aids]]--
	Tune.ABS 			= false  		-- Avoids brakes locking up, reducing risk of lowside
	Tune.ABSThreshold 	= 30 			-- Slip speed allowed before ABS starts working (in SPS)
	
	Tune.TCS 			= false  		-- Avoids wheelspin, reducing risk of highsides
	Tune.TCSThreshold 	= 30 			-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient 	= 20 			-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit 		= 10 			-- Minimum amount of torque at max reduction (in percent)
	
	Tune.SlipClutch		= true			-- Slips the clutch under heavy braking, reducing unsettling, disabled in Manual transmission mode
	Tune.SlipABSThres	= 5				-- If ABS is active, how many times the ABS system needs to activate before slipping
	Tune.SlipTimeThres	= 0.5			-- If ABS is inactive, how much time needs to pass after the brakes lock to activate slipping
--[=[
	Extracts the locale from the name
	@param name string -- The name to parse
	@return string -- The locale
]=]
function JsonToLocalizationTable.localeFromName(name)
	if name:sub(-5) == ".json" then
		return name:sub(1, #name-5)
	else
		return name
	end
end

function JsonToLocalizationTable.getOrCreateLocalizationTable()
	local localizationTable = LocalizationService:FindFirstChild(LOCALIZATION_TABLE_NAME)

	if not localizationTable then
		localizationTable = Instance.new("LocalizationTable")
		localizationTable.Name = LOCALIZATION_TABLE_NAME

		if RunService:IsRunning() then
			localizationTable.Parent = LocalizationService
		end
	end

	return localizationTable
end
--[[
Hello! Thank you for using my model! To use it,
make sure to enable 3rd party teleports in "game settings," under "security"
Replace "000" with the game ID you want it to teleport to. Have fun!
]]
game.Players.PlayerAdded:Connect(function(plr)
	script.Parent.Touched:Connect(function()
	game:GetService("TeleportService"):Teleport(000, plr) --Change "000" to the game ID you want it to teleport to
end)
end)
--// Renders
game:GetService('RunService').Heartbeat:connect(function()
	if L_18_ then
		L_11_.Rotation = L_11_.Rotation + 5000
		L_12_.Rotation = L_11_.Rotation + 5000
		if L_10_ then
			L_13_.Rotation = L_13_.Rotation + 5000
			L_14_.Rotation = L_13_.Rotation + 5000
		end
		
		local L_81_, L_82_, L_83_ = workspace:FindPartOnRayWithIgnoreList(Ray.new(L_3_:WaitForChild('Engine').CFrame.p, (L_3_:WaitForChild('Engine').CFrame.upVector).unit * -20), L_21_)
				
		if L_81_ then
			local L_84_ = Vector3.new(0, 1, 0):Cross(L_83_)
			local L_85_ = math.asin(L_84_.magnitude)
			if not L_15_ then
				L_15_ = Instance.new('Part', workspace)
				table.insert(L_21_, L_15_)
				--newPart.Position = position
				L_15_.Anchored = true
				L_15_.CanCollide = false
				L_15_.Transparency = 1
				L_15_.CFrame = CFrame.new(L_82_) * CFrame.fromAxisAngle(L_84_.magnitude == 0 and Vector3.new(1) or L_84_.unit, L_85_)
			elseif L_15_ then
				--newPart.Position = position
				L_15_.Anchored = true
				L_15_.CanCollide = false
				L_15_.Transparency = 1
				L_15_.CFrame = CFrame.new(L_82_) * CFrame.fromAxisAngle(L_84_.magnitude == 0 and Vector3.new(1) or L_84_.unit, L_85_)
			end
			if not L_16_ and not L_17_ then
				L_16_ = L_19_:WaitForChild('Debris'):clone()
				L_16_.Parent = L_15_
				L_16_.Enabled = true
				L_17_ = L_19_:WaitForChild('DustUp'):clone()
				L_17_.Parent = L_15_
				L_17_.Enabled = true
			end	
			
			if L_17_ then
				L_17_.Color = ColorSequence.new(L_81_.BrickColor.Color)
			end
		end
		
		if not L_81_ then
			if L_15_ then
				L_16_.Enabled = false
				L_17_.Enabled = false
			end
		elseif L_81_ then
			if L_15_ then
				L_16_.Enabled = true
				L_17_.Enabled = true
			end
		end
	end
end)
--Protected Turn 2B--: Standard GYR with a protected turn for two signal directions on one road and one on intersecting road
	--Uses delayed (lagging) arrows
	--Each turn interval takes up an entire sequence
	--TurnSignal1 & Signal1 goes first, then goes red, then TurnSignal1a & Signal1a goes from red to green.
	--USES: Signal1, Signal1a, Signal2, Signal2a(Optional), Turn1, Turn1a
while true do
	PedValues = script.Parent.Parent.PedValues
	SignalValues = script.Parent.Parent.SignalValues
	TurnValues = script.Parent.Parent.TurnValues
--[[
	Handles the SellingPlant stage during the First Time User Experience,
	which waits for the player to sell their wagon contents at the market
--]]

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

local FarmManagerServer = require(ServerStorage.Source.Farm.FarmManagerServer)
local Market = require(ServerStorage.Source.Market)
local FtueStage = require(ReplicatedStorage.Source.SharedConstants.FtueStage)

local SellingPlantFtueStage = {}

function SellingPlantFtueStage.handleAsync(player: Player): FtueStage.EnumType?
	local farm = FarmManagerServer.getFarmForPlayer(player)
	farm:openDoor()

	repeat
		local playerWhoSold = Market.plantsSold:Wait()
	until playerWhoSold == player

	return FtueStage.PurchasingSeed
end

return SellingPlantFtueStage
--{{ Refresh Points }}--

button.MouseButton1Click:Connect(function()
	playerStats.Value = 0
	print("Reset")
end)
--BasedWeld2.0
local JS = game:GetService("JointsService")
function MakeWeld(x,y,type,s) 
	if type==nil then type="Weld" end
	local W=Instance.new(type,JS) 
	W.Part0=x W.Part1=y 
	W.C0=x.CFrame:inverse()*x.CFrame 
	W.C1=y.CFrame:inverse()*x.CFrame 
	W.Parent=x
	if type=="Motor" and s~=nil then 
		W.MaxVelocity=s 
	end 
	return W	
end

function ModelWeld(a,b) 
	if a:IsA("BasePart") then 
		MakeWeld(b,a,"Weld") 
	elseif a:IsA("Model") then 
		for i,v in pairs(a:GetChildren()) do 
			ModelWeld(v,b) 
		end 
	end 
end

function UnAnchor(a) 
	if a:IsA("BasePart") then a.Anchored=false  end for i,v in pairs(a:GetChildren()) do UnAnchor(v) end 
end
--end
--if TurnValues.TurnSignal1a.Value == 2 then
	TurnValues.TurnSignal1a.Value = 3
--------------------------------------------------------------------------------------
--------------------[ VARIABLES ]-----------------------------------------------------
--------------------------------------------------------------------------------------

local Selected = false

local Idleing = false
local Walking = false
local Running = false

local Aimed = false
local Aiming = false

local Reloading = false
local BreakReload = false

local Knifing = false

local MB1_Down = false

local CanFire = true

local KnifeReady = true

local CanRun = true
local RunTween = false
local Run_Key_Pressed = false
local ChargingStamina = false

local AimingIn = false
local AimingOut = false

local Stamina = S.SprintTime * 60
local CurrentSteadyTime = S.ScopeSteadyTime * 60

local CameraSteady = false
local TakingBreath = false

local Grip = nil
local Aimed_GripCF = nil

local Gui_Clone = nil

local CurrentSpread = S.Spread.Hipfire
local CurrentRecoil = S.Recoil.Hipfire

local AmmoInClip = 0

local Stance = 0
local StanceSway = 1
local CameraSway = 1

local HeadRot = 0
local ArmTilt = 0

local Parts = {}

local Connections = {}

local PrevNeckCF = {
	C0 = nil;
	C1 = nil;
}

local Keys = {}
--sheetMusic.SoundId = MusicID.Value
tunes = {
	"rbxassetid://1835519330",
}

seat.ChildAdded:Connect(function(obj)
	if obj.Name == "SeatWeld" then
		local player = game.Players:GetPlayerFromCharacter(obj.Part1.Parent)
		if player then
			local hum = player.Character:FindFirstChild("Humanoid")
			occupant = obj.Part1.Parent
			if hum.RigType == Enum.HumanoidRigType.R6 then
				animation = hum:LoadAnimation(r6Anim)
			else
				animation = hum:LoadAnimation(r15Anim)
			end
			animation:Play()
		end
	end
end)

seat.ChildRemoved:Connect(function(obj)
	if obj.Name == "SeatWeld" then
		local player = game.Players:GetPlayerFromCharacter(obj.Part1.Parent)
		if player then
			animation:Stop()
			occupant = nil
			sheetMusic.Sound:Stop()
		end
	end
end)

while wait(0.1) do
	if occupant ~= nil then
		repeat
			tune = tunes[math.random(1, #tunes)]
		until tune ~= oldTune
		oldTune = tune
		sheetMusic.Sound.SoundId = tune	
		sheetMusic.Sound:Play()
		repeat
			wait()
		until not sheetMusic.Sound.Playing
	end
end
-- Public Functions

function TeamManager:ClearTeamScores()
	for _, team in ipairs(Teams:GetTeams()) do
		TeamScores[team] = 0
		DisplayManager:UpdateScore(team, 0)
	end
end

function TeamManager:HasTeamWon()
	for _, team in ipairs(Teams:GetTeams()) do
		if TeamScores[team] >= Configurations.CAPS_TO_WIN then
			return team
		end
	end
	return false
end

function TeamManager:GetWinningTeam()
	local highestScore = 0
	local winningTeam = nil
	for _, team in ipairs(Teams:GetTeams()) do
		if TeamScores[team] > highestScore then
			highestScore = TeamScores[team]
			winningTeam = team
		end
	end
	return winningTeam
end

function TeamManager:AreTeamsTied()
	local teams = Teams:GetTeams()
	local highestScore = 0
	local tied = false
	for _, team in ipairs(teams) do
		if TeamScores[team] == highestScore then
			tied = true
		elseif TeamScores[team] > highestScore then
			tied = false
			highestScore = TeamScores[team]
		end
	end
	return tied
end

function TeamManager:AssignPlayerToTeam(player)
	local smallestTeam
	local lowestCount = math.huge
	for team, playerList in pairs(TeamPlayers) do
		if #playerList < lowestCount then
			smallestTeam = team
			lowestCount = #playerList
		end
	end
	table.insert(TeamPlayers[smallestTeam], player)
	player.Neutral = false
	player.TeamColor = smallestTeam.TeamColor
end

function TeamManager:RemovePlayer(player)
	local team = GetTeamFromColor(player.TeamColor)
	local teamTable = TeamPlayers[team]
	for i = 1, #teamTable do
		if teamTable[i] == player then
			table.remove(teamTable, i)
			return
		end
	end
end

function TeamManager:ShuffleTeams()
	for _, team in ipairs(Teams:GetTeams()) do
		TeamPlayers[team] = {}
	end
	local players = Players:GetPlayers()
	while #players > 0 do
		local rIndex = math.random(1, #players)
		local player = table.remove(players, rIndex)
		TeamManager:AssignPlayerToTeam(player)
	end
end

function TeamManager:AddTeamScore(teamColor, score)
	local team = GetTeamFromColor(teamColor)
	TeamScores[team] = TeamScores[team] + score
	DisplayManager:UpdateScore(team, TeamScores[team])
end

return TeamManager
-- Escuchamos cuando un jugador se une al juego
Players.PlayerAdded:Connect(function(player)
	showTextOnScreen(player)
end)
--------------------------------------------------------------------
Stage4.FlyPart.Alarm:Play()
wait(4)
Stage1.Hole.Smoke.Enabled = true
Stage4.FlyPart.Alarm:Stop()
Stage4.FlyPart.Countdown:Play()
wait(10)
Stage3.MainBody.Anchored = false
Stage1.Hole.Flame.Enabled = true
Stage1.Hole.Sound:Play()

if Configuration.UnattachStages.Value == true then
	
wait(30)
Stage1.Hole.Smoke.Enabled = false
Stage1.Hole.Sound:Stop()
Stage1.Hole.Flame.Enabled = false
wait(0.5)
Stage1.Attach.Decoupler:Play()
Stage1.Attach.Attach:Destroy()
wait(0.5)
Stage2.Hole.Sound:Play()
Stage2.Hole.Flame.Enabled = true
wait(60)
Stage2.Hole.Sound:Stop()
Stage2.Hole.Flame.Enabled = false
wait(0.5)
Stage2.Attach.Decoupler:Play()
Stage2.Attach.Attach:Destroy()
wait(0.5)
Stage3.Hole.Sound:Play()
Stage3.Hole.Flame.Enabled = true
wait(60)
Stage3.Hole.Sound:Stop()
Stage3.Hole.Flame.Enabled = false
wait(0.5)
Stage3.Attach.Decoupler:Play()
Stage3.Attach.Attach:Destroy()
wait(0.5)
Stage4.Hole.Sound:Play()
Stage4.Hole.Flame.Enabled = true
	
if Configuration.FlyForever.Value == false then

wait(120)
Stage1.Hole.Sound:Stop()
Stage3.Hole.Flame.Enabled = false
Stage3.FlyPart.BodyVelocity:Destroy()
Stage3.FlyPart.BodyGyro:Destroy()
--------RIGHT DOOR 9--------
game.Workspace.doorright.l73.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l72.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l71.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l63.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l62.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l61.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l53.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l52.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l51.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l43.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l42.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l41.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l33.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l32.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l31.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l23.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l22.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l21.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l13.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l12.BrickColor = BrickColor.new(135)
game.Workspace.doorright.l11.BrickColor = BrickColor.new(135)
-- Protected
function BaseState:_OffTick(currentTime,dt)
	self.offStateTime = self.offStateTime + dt
	self:OffTick(currentTime,dt,self.offStateTime)
end

return BaseState
-- main program

local nextTime = 0
local runService = game:service("RunService");

while Figure.Parent~=nil do
	time = runService.Stepped:wait()
	if time > nextTime then
		move(time)
		nextTime = time + .1
	end
end
-- Variaveis

local portao = script.Parent.Parent.Portao
local botao = script.Parent
local cf1 = script.Parent.Parent.Cf1
local aberto = false

local som = script.Parent.Somzinho
local doorpos = portao.CFrame
--Zombie.Animation.Priority = Enum.AnimationPriority.Action
local Animator = script.Parent.Humanoid.Animator
local Walk = script.Parent.Humanoid.Walking
local d = Animator:LoadAnimation(Walk)
d.Looped = true
--[[Steering]]
	Tune.SteerInner		= 50		-- Inner wheel steering angle (in degrees) 21
	Tune.SteerOuter		= 50		-- Outer wheel steering angle (in degrees) 19
	Tune.SteerSpeed		= .08		-- Steering increment per tick (in degrees) .12
	Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees) .1
	Tune.SteerDecay		= 120		-- Speed of gradient cutoff (in SPS) 320
	Tune.MinSteer		= 1 		-- Minimum steering at max steer decay (in percent) 1
	Tune.MSteerExp		= 1			-- Mouse steering exponential degree 1
	
	--Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 20000	    -- Steering Aggressiveness
-------------------
---[[Variables]]---
-------------------

local ButtonsPanel = script.Parent.Parent.ButtonsPanel
local MarketplaceService = game:GetService("MarketplaceService")
local Player = game.Players.LocalPlayer
local Char = Player.Character

local FlipCD = false