Roblox/luau_corpus huggingface dataset:
--watch the video to know where to put it
local repStorage = game:GetService("ReplicatedStorage")
local remote = repStorage:FindFirstChild("Rebirth")

local button = script.Parent

local debounce = false

button.MouseButton1Click:Connect(function()
	local rebirths = game.Players.LocalPlayer.leaderstats:FindFirstChild("Rebirths")
	if not debounce then
		debounce = true
		local playerPoint = rebirths
		remote:FireServer(playerPoint)
		wait(0.001)
		debounce = false
	end
end)

repeat
	local rebirths = game.Players.LocalPlayer.leaderstats:FindFirstChild("Rebirths")
	local textButton = script.Parent
	textButton.Text = "".. tostring(1000000 * (rebirths.Value + 1)) .." Cash "
	wait(0.001)
until script.Parent == nil
--!strict
local RunService = game:GetService("RunService")

local PostSimulation = RunService.Heartbeat

local OPT_INTERVAL_ATTRIBUTE = "Interval"
local OPT_INTERVAL = 3
local OPT_SWITCH_ATTRIBUTE = "Switch"
local OPT_SWITCH = false
local OPT_DEFAULT_MATERIAL = Enum.Material.SmoothPlastic
local OPT_SWITCH_MATERIAL = Enum.Material.ForceField

local Obstacle = {}

Obstacle.__index = Obstacle

function Obstacle.new(instance: Instance)
	local self = setmetatable({}, Obstacle)
	
	self._events = {}
	self._materialCache = {}
	self._lastTick = tick()
	
	self._instance = instance
	self._interval = instance:GetAttribute(OPT_INTERVAL_ATTRIBUTE) or OPT_INTERVAL
	self._switch = instance:GetAttribute(OPT_SWITCH_ATTRIBUTE) or OPT_SWITCH
	
	self:CachePartMaterials()
	
	table.insert(self._events, PostSimulation:Connect(function()
		local now = tick()
		
		if now - self._lastTick < self._interval then
			return
		end
		
		self._lastTick = now
		self:ToggleState()
	end))
	
	self:UpdateParts()
	
	return self
end

function Obstacle:GetAllParts(): {BasePart}
	local parts = {}
	
	if self._instance:IsA("BasePart") then
		table.insert(parts, self._instance::BasePart)
	end
	
	for _, child: BasePart in ipairs(self._instance:GetDescendants()) do
		if child:IsA("BasePart") then
			table.insert(parts, child)
		end
	end
	
	return parts
end

function Obstacle:CachePartMaterials()
	for _, part: BasePart in ipairs(self:GetAllParts()) do
		self._materialCache[part] = part.Material
	end
end

function Obstacle:GetSwitchState(): boolean
	return self._instance:GetAttribute(OPT_SWITCH_ATTRIBUTE) == true
end

function Obstacle:ToggleState()
	self._instance:SetAttribute(OPT_SWITCH_ATTRIBUTE, not self:GetSwitchState())
	self:UpdateParts()
end

function Obstacle:UpdateParts()
	for _, part in ipairs(self:GetAllParts()) do
		self:SetPartMaterial(part)
	end
end

function Obstacle:SetPartMaterial(part: BasePart)
	local switch = self:GetSwitchState()
	
	part.CanCollide = switch
	part.Material = switch and (self._materialCache[part] or OPT_DEFAULT_MATERIAL) or 
		OPT_SWITCH_MATERIAL
end

function Obstacle:Destroy()
	for _, event: RBXScriptConnection in ipairs(self._events) do
		event:Disconnect()
	end
end

return Obstacle
-- Create component
local TextBox = Roact.PureComponent:extend 'TextBox'
-- Encuentra el sonido llamado "hyperx" en el servicio de sonido
local sound = soundService:FindFirstChild("final")
--
tool.Equipped:connect(function()
	equipped = true
	owner = game:GetService("Players"):GetPlayerFromCharacter(tool.Parent)
	character = owner.Character
	local rightarm = Instance.new("Weld", character.Torso)
	rightarm.Part0 = character.Torso
	rightarm.Part1 = character["Right Arm"]
	rightarm.C0 = CFrame.new(1.5,0,0)
	rightarm.Name = "RightArmWeldpunch"
	local leftarm = Instance.new("Weld", character.Torso)
	leftarm.Part0 = character.Torso
	leftarm.Part1 = character["Left Arm"]
	leftarm.C0 = CFrame.new(-1.5,0,0)
	leftarm.Name = "LeftArmWeldpunch"
	local head = Instance.new("Weld", character.Torso)
	head.Part0 = character.Torso
	head.Part1 = character.Head
	head.C0 = CFrame.new(0,1.5,0)
	head.Name = "HeadWeldpunch"
	local humanoidrootpart = Instance.new("Weld", character.HumanoidRootPart)
	humanoidrootpart.Part0 = character.HumanoidRootPart
	humanoidrootpart.Part1 = character.Torso
	humanoidrootpart.Name = "HumanoidRootPartWeldpunch"
	for i,v in pairs(script:GetChildren()) do
		if v.ClassName == "Sound" then
			v.Parent = character.HumanoidRootPart
		end
	end
	cananimate = true
	local savedchar = character
	local lasthp = character:findFirstChildOfClass("Humanoid").Health
	coroutine.wrap(function()
		local humhp = character:findFirstChildOfClass("Humanoid").Health
		while runservice.Stepped:wait() and equipped do
			if character:findFirstChildOfClass("Humanoid").Health < humhp then
				local thedamage = humhp - character:findFirstChildOfClass("Humanoid").Health
				character:findFirstChildOfClass("Humanoid").Health = character:findFirstChildOfClass("Humanoid").Health + thedamage/2.5
			end
			if cananimate then
				head.C0 = head.C0:lerp(CFrame.new(0,1.5,0),0.1)
				humanoidrootpart.C0 = humanoidrootpart.C0:lerp(CFrame.new(),0.2)
				leftarm.C0 = leftarm.C0:lerp(CFrame.new(-0.8,0.15,-0.5) * CFrame.fromEulerAnglesXYZ(math.pi-(math.rad(20)),0,math.rad(15)) * CFrame.new(0,-0.5,0),0.2)
				rightarm.C0 = rightarm.C0:lerp(CFrame.new(0.8,0.15,-0.5) * CFrame.fromEulerAnglesXYZ(math.pi-(math.rad(20)),0,math.rad(-15)) * CFrame.new(0,-0.5,0),0.2)
			end
			humhp = character:findFirstChildOfClass("Humanoid").Health
		end
	end)()
end)
tool.Unequipped:connect(function()
	equipped = false
	instancewhitelist = {}
	mouseclick = false
	cananimate = false
	for i,v in pairs(character.HumanoidRootPart:GetChildren()) do
		if v.ClassName == "Sound" then
			v.Parent = script
		end
	end
	if character.Torso:findFirstChild("LeftArmWeldpunch") then
		character.Torso:findFirstChild("LeftArmWeldpunch"):destroy()
	end
	if character.Torso:findFirstChild("RightArmWeldpunch") then
		character.Torso:findFirstChild("RightArmWeldpunch"):destroy()
	end
	if character.Torso:findFirstChild("HeadWeldpunch") then
		character.Torso:findFirstChild("HeadWeldpunch"):destroy()
	end
	if character:findFirstChild("HumanoidRootPart") then
		if character.HumanoidRootPart:findFirstChild("HumanoidRootPartWeldpunch") then
			character.HumanoidRootPart:findFirstChild("HumanoidRootPartWeldpunch"):destroy()
		end
	end
end)
-- Displays a hint to the player that the GUI auto-hides.
-- 
-- ForbiddenJ

IsGuiDisplayed = script.Parent.IsDisplayed
IsHiddenByOtherGUI = script.Parent.IsHiddenByOtherGUI
SpawnNotification = game.ReplicatedStorage.ClientStorage.SpawnNotification
SmallHint = script.Parent.SmallHint

HasShownLargeHint = false

function Update()
	SmallHint.Visible = not IsGuiDisplayed.Value
	
	if not HasShownLargeHint and not IsGuiDisplayed.Value and not IsHiddenByOtherGUI.Value then
		HasShownLargeHint = true
		
		local notification =
			SpawnNotification:Invoke("Hover mouse to show panel.", nil, -1)
		SmallHint.ImageTransparency = 0
		notification.TextStrokeColor3 = Color3.new(0.7, 0.7, 0.7)
		
		local tween = game.TweenService:Create(
			SmallHint,
			TweenInfo.new(1, Enum.EasingStyle.Linear, Enum.EasingDirection.Out, math.huge),
		{ImageTransparency = 0.85})
		tween.Parent = SmallHint
		tween:Play()
		local tween2 = game.TweenService:Create(
			notification,
			TweenInfo.new(1, Enum.EasingStyle.Linear, Enum.EasingDirection.Out, math.huge),
			{TextStrokeColor3 = Color3.new(0, 0, 0)})
		tween2.Parent = notification
		tween2:Play()
		
		local hintCleanedUp = false
		local function cleanupHint()
			if not hintCleanedUp then
				if notification.Parent ~= nil then
					notification.LifetimeLeft.Value = 0
				end
				tween:Cancel()
				tween:Destroy()
				SmallHint.ImageTransparency = 0.85
				
				hintCleanedUp = true
			end
		end
		
		delay(10, cleanupHint)
		IsGuiDisplayed.Changed:Wait()
		cleanupHint()
	end
end

IsGuiDisplayed.Changed:Connect(Update)

Update()
-- Decompiled with the Synapse X Luau decompiler.

local v1 = {};
local v2 = require(game.ReplicatedStorage.Modules.Lightning);
local v3 = require(game.ReplicatedStorage.Modules.Xeno);
local v4 = require(game.ReplicatedStorage.Modules.CameraShaker);
local l__TweenService__5 = game.TweenService;
local l__Debris__6 = game.Debris;
local l__ReplicatedStorage__1 = game.ReplicatedStorage;
function v1.RunStompFx(p1, p2, p3, p4)
	local v7 = {};
	for v8 = 1, 15 do
		local v9 = l__ReplicatedStorage__1.KillFX[p1].Gate:Clone();
		v9.Parent = workspace.Ignored.Animations;
		local l__p__10 = p2.Parent.UpperTorso.CFrame.p;
		game.Debris:AddItem(v9, 6);
		v9.CFrame = CFrame.new(l__p__10.X + math.random(-35, 35), l__p__10.Y + math.random(17, 35), l__p__10.Z + math.random(-35, 35));
		v9.CFrame = CFrame.lookAt(v9.Position, p2.Position);
		table.insert(v7, v9);
		local v11 = math.random(-360, 360);
		v9.Middle.Cut.Rotation = NumberRange.new(v11, v11);
		task.delay(0.15, function()
			v9.Middle.Cut.Enabled = false;
			v9.Attachment.Effect.Enabled = true;
			v9.FF.Enabled = true;
			v9.Sound:Play();
		end);
		task.wait(0.06);
	end;
	local v12 = {};
	for v13, v14 in pairs(v7) do
		local v15 = l__ReplicatedStorage__1.KillFX[p1].Sword:Clone();
		v15.Parent = workspace.Ignored.Animations;
		game.Debris:AddItem(v15, 5);
		v15.CFrame = v14.CFrame * CFrame.new(0, 0, -1) * CFrame.Angles(-1.5707963267948966, math.rad(math.random(-360, 360)), 0);
		game.TweenService:Create(v15, TweenInfo.new(1, Enum.EasingStyle.Quint), {
			Size = v15.F.Value, 
			CFrame = v14.CFrame * CFrame.new(0, 0, -3) * CFrame.Angles(-1.5707963267948966, math.rad(math.random(-360, 360)), 0)
		}):Play();
		table.insert(v12, v15);
		task.wait(0.04);
	end;
	task.wait(0.25);
	for v16, v17 in pairs(v7) do
		v17.FF.Enabled = false;
		v17.Attachment.Effect.Enabled = false;
	end;
	for v18, v19 in pairs(v12) do
		v19[math.random(1, 3)]:Play();
		local l__Position__20 = v19.Position;
		game.TweenService:Create(v19, TweenInfo.new(0.65, Enum.EasingStyle.Quint), {
			Position = (CFrame.new(p2.Position) * CFrame.new(0, math.random(-0.9, 0.1), 0)).Position
		}):Play();
		task.delay(1, function()
			v19.Charge.Enabled = false;
			game.TweenService:Create(v19, TweenInfo.new(1, Enum.EasingStyle.Quint), {
				Transparency = 1
			}):Play();
		end);
		task.wait(0.025);
	end;
	return nil;
end;
return v1;
-- ROBLOX TODO: add type constraint <EachCallback extends Global.TestCallback>
local function default<EachCallback>(cb_: GlobalCallback?, supportsDone_: boolean?)
	local supportsDone = if supportsDone_ ~= nil then supportsDone_ else true
	local cb = cb_ or unavailableFn
	return function(
		table_: Global_EachTable,
		...: any --[[ ROBLOX comment: Upstream type: <Global.TemplateData> (Array<unknown>) ]]
	)
		local taggedTemplateData = if select("#", ...) > 0 then { ... } else {}

		local function eachBind(title: string, test: Global_EachTestFn<EachCallback>, timeout: number?): ()
			local ok, result = pcall(function()
				local tests = if isArrayTable(taggedTemplateData)
					then buildArrayTests(title, table_)
					else buildTemplateTests(title, table_, taggedTemplateData)

				return Array.forEach(tests, function(row)
					-- ROBLOX FIXME Luau: supports done is known to be a boolean at this point
					return cb(row.title, applyArguments(supportsDone, row.arguments, test), timeout)
				end) :: any
			end)

			if not ok then
				local error_ = ErrorWithStack.new(result.message, eachBind)
				return cb(title, function()
					error(error_)
				end)
			end

			return result
		end
		return eachBind
	end
end
exports.default = default

function isArrayTable(data: Global_TemplateData)
	return #data == 0
end

function buildArrayTests(title: string, table_: Global_EachTable): EachTests
	validateArrayTable(table_)
	return convertArrayTable(title, table_ :: Global_ArrayTable)
end

function buildTemplateTests(title: string, table_: Global_EachTable, taggedTemplateData: Global_TemplateData): EachTests
	local headings = getHeadingKeys((table_ :: Array<string>)[1] :: string)
	validateTemplateTableArguments(headings, taggedTemplateData)
	return convertTemplateTable(title, headings, taggedTemplateData)
end

function getHeadingKeys(headings: string): Array<string>
	return String.split(extractValidTemplateHeadings(headings):gsub("%s+", ""), "|")
end
--[=[
	@type ServerMiddleware {ServerMiddlewareFn}
	@within KnitServer
	An array of server middleware functions.
]=]
type ServerMiddleware = {ServerMiddlewareFn}
--Code--
local function PlayerTouched(Part)
	local Parent = Part.Parent
	if game.Players:GetPlayerFromCharacter(Parent) then
		Parent.Humanoid.Health = 1
		Parent.Humanoid.Walkspeed = 5
		wait(7.5)
		Parent.Humanoid.Walkspeed = 12
		wait(7.5)
		Parent.Humanoid.Walkspeed = 16
	end
end

Brick.Touched:connect(PlayerTouched)
--		print("Wha " .. pose)
		stopAllAnimations()
		amplitude = 0.1
		frequency = 1
		setAngles = true
	end

	if (setAngles) then
		desiredAngle = amplitude * math.sin(time * frequency)

		RightShoulder:SetDesiredAngle(desiredAngle + climbFudge)
		LeftShoulder:SetDesiredAngle(desiredAngle - climbFudge)
		RightHip:SetDesiredAngle(-desiredAngle)
		LeftHip:SetDesiredAngle(-desiredAngle)
	end

	-- Tool Animation handling
	local tool = getTool()
	if tool then
	
		animStringValueObject = getToolAnim(tool)

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

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

		animateTool()		
	else
		stopToolAnimations()
		toolAnim = "None"
		toolAnimTime = 0
	end
end
--[[Steering]]
Tune.SteerInner		= 49		-- Inner wheel steering angle (in degrees)
Tune.SteerOuter		= 50		-- Outer wheel steering angle (in degrees)
Tune.SteerSpeed		= .02		-- Steering increment per tick (in degrees)
Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees)
Tune.SteerDecay		= 150		-- Speed of gradient cutoff (in SPS)
Tune.MinSteer		= 10		-- Minimum steering at max steer decay (in percent)
Tune.MSteerExp		= 1			-- Mouse steering exponential degree
	
	--Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 100000	-- Steering Aggressiveness
-- Inserts `v` into `t` at `i`. Also sets `Index` field in `v`.
local function insert(t,i,v)
	for n = #t,i,-1 do
		local v = t[n]
		v.Index = n+1
		t[n+1] = v
	end
	v.Index = i
	t[i] = v
end
-- Issue with play solo? (F6)
while not UserInputService.KeyboardEnabled and not UserInputService.TouchEnabled and not UserInputService.GamepadEnabled do
	wait()
end
--== Init/config ==--
local car = script.Parent.Car.Value
local inputService = game:GetService("UserInputService")

local sts = script.Start

script:WaitForChild("Start")

local delayToStartEngine = 2.8 														-- The script will wait this many seconds to turn the car on
local delayToStopStartupSound = 0.1												-- The script will wait this many seconds after starting the car before stopping your ignition sound

local primaryKey 	= Enum.KeyCode.LeftShift												-- Which key on your keyboard will start your car?
local modifierKey	= Enum.KeyCode.K									-- I recommend using Right Shift - no conflicts with default AC6 keybinds, and most people never use it anyways
																							-- You could probably get away with Right Control as well
---Command types.
---Process a command as it is being typed. This allows for manipulation of the chat bar.
local IN_PROGRESS_MESSAGE_PROCESSOR = 0
--[=[
	@tag Component Class
	@return Promise<ComponentInstance>

	Resolves a promise once the component instance is present on a given
	Roblox instance.

	An optional `timeout` can be provided to reject the promise if it
	takes more than `timeout` seconds to resolve. If no timeout is
	supplied, `timeout` defaults to 60 seconds.

	```lua
	local MyComponent = require(somewhere.MyComponent)

	MyComponent:WaitForInstance(workspace.SomeInstance):andThen(function(myComponentInstance)
		-- Do something with the component class
	end)
	```
]=]
function Component:WaitForInstance(instance: Instance, timeout: number?)
	local componentInstance = self:FromInstance(instance)
	if componentInstance then
		return Promise.resolve(componentInstance)
	end
	return Promise.fromEvent(self.Started, function(c)
		local match = c.Instance == instance
		if match then
			componentInstance = c
		end
		return match
	end):andThen(function()
		return componentInstance
	end):timeout(if type(timeout) == "number" then timeout else DEFAULT_TIMEOUT)
end
--[[
	Creates a new promise that receives the result of this promise.

	The given callbacks are invoked depending on that result.
]]
function Promise.prototype:_andThen(traceback, successHandler, failureHandler)
	self._unhandledRejection = false

	-- Create a new promise to follow this part of the chain
	return Promise._new(traceback, function(resolve, reject)
		-- Our default callbacks just pass values onto the next promise.
		-- This lets success and failure cascade correctly!

		local successCallback = resolve
		if successHandler then
			successCallback = createAdvancer(
				traceback,
				successHandler,
				resolve,
				reject
			)
		end

		local failureCallback = reject
		if failureHandler then
			failureCallback = createAdvancer(
				traceback,
				failureHandler,
				resolve,
				reject
			)
		end

		if self._status == Promise.Status.Started then
			-- If we haven't resolved yet, put ourselves into the queue
			table.insert(self._queuedResolve, successCallback)
			table.insert(self._queuedReject, failureCallback)
		elseif self._status == Promise.Status.Resolved then
			-- This promise has already resolved! Trigger success immediately.
			successCallback(unpack(self._values, 1, self._valuesLength))
		elseif self._status == Promise.Status.Rejected then
			-- This promise died a terrible death! Trigger failure immediately.
			failureCallback(unpack(self._values, 1, self._valuesLength))
		elseif self._status == Promise.Status.Cancelled then
			-- We don't want to call the success handler or the failure handler,
			-- we just reject this promise outright.
			reject(Error.new({
				error = "Promise is cancelled",
				kind = Error.Kind.AlreadyCancelled,
				context = "Promise created at\n\n" .. traceback,
			}))
		end
	end, self)
end

function Promise.prototype:andThen(successHandler, failureHandler)
	assert(
		successHandler == nil or type(successHandler) == "function" or successHandler.__call ~= nil,
		string.format(ERROR_NON_FUNCTION, "Promise:andThen")
	)
	assert(
		failureHandler == nil or type(failureHandler) == "function" or failureHandler.__call ~= nil,
		string.format(ERROR_NON_FUNCTION, "Promise:andThen")
	)

	return self:_andThen(debug.traceback(nil, 2), successHandler, failureHandler)
end
--[[Weight and CG]]
	Tune.Weight			= 2500		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		6		,
	 --[[Height]]		3.5		,
	 --[[Length]]		14		}
	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
--[[
	Pops a node off of the navigation stack.
]]
function TestSession:popNode()
	assert(#self.nodeStack > 0, "Tried to pop from an empty node stack!")
	table.remove(self.nodeStack, #self.nodeStack)
	table.remove(self.contextStack, #self.contextStack)
	table.remove(self.expectationContextStack, #self.expectationContextStack)
end
--Initialize Chassis
local ScriptsFolder = Car:FindFirstChild("Scripts")
local Chassis = require(ScriptsFolder:WaitForChild("Chassis"))
Chassis.InitializeDrivingValues()
Chassis.Reset()
-- Connection class
local Connection = {}
Connection.__index = Connection

function Connection.new(signal, fn)
	return setmetatable({
		_connected = true,
		_signal = signal,
		_fn = fn,
		_next = false,
	}, Connection)
end

function Connection:Disconnect()
	self._connected = false

	-- Unhook the node, but DON'T clear it. That way any fire calls that are
	-- currently sitting on this node will be able to iterate forwards off of
	-- it, but any subsequent fire calls will not hit it, and it will be GCed
	-- when no more fire calls are sitting on it.
	if self._signal._handlerListHead == self then
		self._signal._handlerListHead = self._next
	else
		local prev = self._signal._handlerListHead
		while prev and prev._next ~= self do
			prev = prev._next
		end
		if prev then
			prev._next = self._next
		end
	end
end
--[[ 
               Manual Ignition Tool Roblox_MELIHCAN10
--]]
wait(0.2) -- Removing this wait could break the script. Please do not touch this.
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------
function luaK:dischargevars(fs, e)
  local k = e.k
  if k == "VLOCAL" then
    e.k = "VNONRELOC"
  elseif k == "VUPVAL" then
    e.info = self:codeABC(fs, "OP_GETUPVAL", 0, e.info, 0)
    e.k = "VRELOCABLE"
  elseif k == "VGLOBAL" then
    e.info = self:codeABx(fs, "OP_GETGLOBAL", 0, e.info)
    e.k = "VRELOCABLE"
  elseif k == "VINDEXED" then
    self:freereg(fs, e.aux)
    self:freereg(fs, e.info)
    e.info = self:codeABC(fs, "OP_GETTABLE", 0, e.info, e.aux)
    e.k = "VRELOCABLE"
  elseif k == "VVARARG" or k == "VCALL" then
    self:setoneret(fs, e)
  else
    -- there is one value available (somewhere)
  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 = 25
local structureDamage = 20

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
--[[
	Create a new TestPlan from a list of specification functions.

	These functions should call a combination of `describe` and `it` (and their
	variants), which will be turned into a test plan to be executed.

	Parameters:
		- modulesList - list of tables describing test modules {
			method, -- specification function described above
			path, -- array of parent entires, first element is the leaf that owns `method`
			pathStringForSorting -- a string representation of `path`, used for sorting of the test plan
		}
		- testNamePattern - Only tests matching this Lua pattern string will run. Pass empty or nil to run all tests
		- extraEnvironment - Lua table holding additional functions and variables to be injected into the specification
							function during execution
]]
function TestPlanner.createPlan(modulesList, testNamePattern, extraEnvironment)
	local plan = TestPlan.new(testNamePattern, extraEnvironment)

	table.sort(modulesList, function(a, b)
		return a.pathStringForSorting < b.pathStringForSorting
	end)

	for _, module in ipairs(modulesList) do
		plan:addRoot(module.path, module.method)
	end

	return plan
end

return TestPlanner
--
FakeTorso.Size = Torso.Size
FakeHumanoidRootPart.Size = HumanoidRootPart.Size
FakeTorso.CFrame = FakeHumanoidRootPart.CFrame
RootHipClone = RootHipJoint:Clone()
RootHipClone.Parent = FakeHumanoidRootPart
RootHipClone.Part0 = FakeHumanoidRootPart
RootHipClone.Part1 = FakeTorso