Roblox/luau_corpus huggingface dataset:
-------- OMG HAX

r = game:service("RunService")


local damage = 5


local slash_damage = 8
local lunge_damage = 12

sword = script.Parent.Handle
Tool = script.Parent


local SlashSound = Instance.new("Sound")
SlashSound.SoundId = "rbxasset://sounds\\swordslash.wav"
SlashSound.Parent = sword
SlashSound.Volume = .7

local LungeSound = Instance.new("Sound")
LungeSound.SoundId = "rbxasset://sounds\\swordlunge.wav"
LungeSound.Parent = sword
LungeSound.Volume = .6

local UnsheathSound = Instance.new("Sound")
UnsheathSound.SoundId = "rbxasset://sounds\\unsheath.wav"
UnsheathSound.Parent = sword
UnsheathSound.Volume = 1


function blow(hit)
	local humanoid = hit.Parent:findFirstChild("Humanoid")
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)
	local hum = vCharacter:findFirstChild("Humanoid") -- non-nil if tool held by a character
	if humanoid~=nil and humanoid ~= hum and hum ~= nil then
		-- final check, make sure sword is in-hand

		local right_arm = vCharacter:FindFirstChild("Right Arm")
		if (right_arm ~= nil) then
			local joint = right_arm:FindFirstChild("RightGrip")
			if (joint ~= nil and (joint.Part0 == sword or joint.Part1 == sword)) then
				tagHumanoid(humanoid, vPlayer)
				humanoid:TakeDamage(damage)
				wait(1)
				untagHumanoid(humanoid)
			end
		end


	end
end


function tagHumanoid(humanoid, player)
	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = player
	creator_tag.Name = "creator"
	creator_tag.Parent = humanoid
end

function untagHumanoid(humanoid)
	if humanoid ~= nil then
		local tag = humanoid:findFirstChild("creator")
		if tag ~= nil then
			tag.Parent = nil
		end
	end
end


function attack()
	damage = slash_damage
	SlashSound:play()
	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Slash"
	anim.Parent = Tool
end

function lunge()
	damage = lunge_damage

	LungeSound:play()

	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Lunge"
	anim.Parent = Tool
	
	
	force = Instance.new("BodyVelocity")
	force.velocity = Vector3.new(0,10,0) --Tool.Parent.Torso.CFrame.lookVector * 80
	force.Parent = Tool.Parent.Torso
	wait(.2)
	swordOut()
	wait(.2)
	force.Parent = nil
	wait(.4)
	swordUp()

	damage = slash_damage
end

function swordUp()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,1)
end

function swordOut()
	Tool.GripForward = Vector3.new(0,0,1)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(1,0,0)
end

function swordAcross()
	-- parry
end


Tool.Enabled = true
local last_attack = 0
function onActivated()

	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return 
	end

	t = r.Stepped:wait()

	if (t - last_attack < .2) then
		lunge()
	else
		attack()
	end

	last_attack = t

	--wait(.5)

	Tool.Enabled = true
end


function onEquipped()
	UnsheathSound:play()
end


script.Parent.Activated:connect(onActivated)
script.Parent.Equipped:connect(onEquipped)


connection = sword.Touched:connect(blow)
--// Connections
L_1_.Equipped:connect(function()
	local L_39_ = L_3_:FindFirstChild('Torso')
	local L_40_ = L_3_:FindFirstChild('Head')
	local L_41_ = L_3_:FindFirstChild('HumanoidRootPart')
	
	L_14_ = Instance.new("Motor6D", L_39_)
	L_14_.Parent = L_39_
	L_14_.Name = "Clone"
	L_14_.Part0 = L_41_
	L_14_.Part1 = L_40_
	L_14_.C0 = L_39_:WaitForChild("Neck").C0	
	L_14_.C1 = L_39_:WaitForChild("Neck").C1
-- Settings
local Universal 	= true
local BulletType 	= "Universal"
local Infinite 		= true
local Stored 		= script.Stored

if not Infinite then
	script.Parent.ObjectText = BulletType.." | "..Stored.Value
else
	script.Parent.ObjectText = BulletType
end
-- Local Functions
local function toggleNonTutorialGui(isEnabled)
	local PlayerGui = player.PlayerGui
	
	for _, child in ipairs(PlayerGui:GetChildren()) do
		if child:IsA("GuiObject") and child.Name ~= "Tutorial" then
			child.Enabled = isEnabled
		end
	end
end

local function startTutorial()
	toggleNonTutorialGui(false)
	
	Panels.Visible = true
	Panel1.Visible = true
	Panel2.Visible = false
end

local function nextPanel(input, gameProcessed)
	if Panel1.Visible == true then
		Panel1.Visible = false
		Panel2.Visible = true
		NextButton.ButtonLabel.Text = "GOT IT"
	elseif Panel2.Visible == true then
		Panel2.Visible = false
	
		-- Disable tutorial
		Panels.Visible = false
		
		-- Enable other gui
		toggleNonTutorialGui(true)
		
		if not IS_MOBILE then
			-- Show and tween arrow over move button until player earns
			-- 10 points
			Arrow.Visible = true
			local arrowThread = coroutine.create(
				function()
					local goal = totalPoints.Value + 10
					local startPos = Arrow.Position
			
					repeat
						Arrow:TweenPosition(UDim2.new(startPos.X.Scale, 0, startPos.Y.Scale, -20),
							Enum.EasingDirection.In, Enum.EasingStyle.Quad, 1, true)
						wait(1)
						Arrow:TweenPosition(UDim2.new(startPos.X.Scale, 0, startPos.Y.Scale, 0),
								Enum.EasingDirection.In, Enum.EasingStyle.Quad, 1, true)
						wait(1)
					until totalPoints.Value >= goal
	
					Arrow.Visible = false
				end)
			coroutine.resume(arrowThread)
		end
	end
end
--lights
local Red1 = script.Parent.Red1
local Red2 = script.Parent.Red2
local RL = script.Parent.RL
local RR = script.Parent.RR
local FL = script.Parent.FL
local FR = script.Parent.FR
local f1 = script.Parent.WhiteFront
local f2 = script.Parent.WhiteFront2
local r1 = script.Parent.WhiteBack
local r2 = script.Parent.WhiteBack2
local B1 = script.Parent.Brake
local B2 = script.Parent.Brake2

local lgt = script.Parent.Lighting.Light


function lightson()
	f1.Material = "Neon"
	f2.Material = "Neon"
	Red1.Material = "Neon"
	Red2.Material = "Neon"
	
	lgt.Enabled = true
end
function lightsoff()
	f1.Material = "SmoothPlastic"
	f2.Material = "SmoothPlastic"
	Red1.Material = "SmoothPlastic"
	Red2.Material = "SmoothPlastic"
	
	lgt.Enabled = false
end
function reverse()
	r1.Material = "Neon"
	r2.Material = "Neon"
end
function unreverse()
	r1.Material = "SmoothPlastic"
	r2.Material = "SmoothPlastic"
end
function brake()
	B1.Material = "Neon"
	B2.Material = "Neon"
end
function unbrake()
	B1.Material = "SmoothPlastic"
	B2.Material = "SmoothPlastic"
end
-- Helper function for Determinant of 3x3
local function Det3x3(a,b,c,d,e,f,g,h,i)
	return (a*(e*i-f*h)-b*(d*i-f*g)+c*(d*h-e*g))
end
--[[Drivetrain]]	
Tune.Config			= "RWD"		--"FWD" , "RWD" , "AWD"
-- Define the text button and frames
local textButton = script.Parent
local frame1 = script.Parent.Parent.Phone
local comps = script.Parent.Parent.Components
local apl = comps.cPhonePurchased
local sud = script.Parent.Sound
--Traction Control Settings
Tune.TCSEnabled		= true		-- Implements TCS
Tune.TCSThreshold	= 20		-- 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)
--Make New Model For Rays If Enabled
if makeRays then
	m = Instance.new("Model")
	m.Name = "Rays"
	m.Parent = Workspace
end
-- Infinitely update the target position for the tank
currentElev = 0;
currentRot = 0;
while wait() do
	if (myMouse) then
		-- Position of mouse in world
		mousePoint = myMouse.Hit.p;
		
		-- Vector from tank to mouse point
		targetVector = (mousePoint - parts.GunBase.CFrame.p).unit;
		
		-- Determine where the gun should point
		targetRotations = determineNewDirections(targetVector);
		
		-- For each time we do all that math to determine the angle, we will smoothly rotate the gun towards it in 4 increments
		-- This means less lag (fewer calculations) but it's still smooth
		for i = 1, 4 do		
			newRotations = getSmoothRotation(targetRotations);
			TFE:FireServer('RotateTurret',parts,currentElev, currentRot)
			wait();
		end
	end
end
--Script:

Button.Activated:Connect(function()
	MarketplaceService:PromptProductPurchase(Player, DevProduct.Value)
end)
--[[ @brief Performs an operation on heartbeat based on a condition.
     @param callback The callback function for each heartbeat step.
     @param condition The condition we should check before running callback.
     @param yield Whether this function should yield or return immediately.
--]]
function AnimateLib.ConditionalOnHeartbeat(callback, condition, yield, callbackOnComplete)
	local cxn;
	local event = Utils.new("Event");
	local startTime = tick();
	cxn = game:GetService("RunService").Heartbeat:connect(function(step)
		if condition() then
			callback(step, tick() - startTime)
		else
			cxn:disconnect();
			event:Fire();
			if callbackOnComplete then
				callbackOnComplete();
			end
		end
	end);
	if yield then
		event:wait();
	end
end
--------------------------------------------------------------------------------------------------
On = false
Check = false

function check(Char)
Player = game.Players:FindFirstChild(Char.Name)
if Player ~= nil then
if Group == true then
if Player:IsInGroup(GroupId) == true then
Check = true
end
end
if Friends == true then
if Player:IsFriendsWith(game.CreatorId) == true then
Check = true
end
end
if Bestfriends == true then
if Player:IsBestFriendsWith(game.CreatorId) == true then
Check = true
end
end
if PeopleOn == true then
for i = 1,#People do
if People[i].Name == Player.Name then
Check = true
end
end
end
if Tshirt == true then
if Char:FindFirstChild("Torso") ~= nil and Char.Torso:FindFirstChild("roblox") ~= nil then
if Char.Torso.roblox.Texture == "http://www.roblox.com/asset/?id="..tostring(TTexture) then
Check = true
end
end
end
if Player.userId == game.CreatorId then
Check = true
end
if Pants == true then
if Char:FindFirstChild("Pants") ~= nil then
if Char.Pants.PantsTemplate == "http://www.roblox.com/asset/?id="..tostring(PTexture) then
Check = true
end
end
end
if Shirt == true then
if Char:FindFirstChild("Shirt") ~= nil then
if Char.Shirt.ShirtTemplate == "http://www.roblox.com/asset/?id="..tostring(STexture) then
Check = true
end
end
end
if BC == true then
if Player.MembershipType == "BuildersClub" then
Check = true
end
end
if Veterans == true then
if Player.AccountAge == 365 then
Check = true
end
end
end
end

function open(hit)
if On == false then
On = true
Player = game.Players:FindFirstChild(hit.Parent.Name)
if Player ~= nil then
Orig = script.Parent.Transparency
script.Parent.Transparency = OpenTransparency
script.Parent.CanCollide = false
wait(OpenTime)
script.Parent.CanCollide = true
script.Parent.Transparency = Orig
On = false
end
end
end

function kill(hit)
if hit.Parent ~= nil and hit.Parent:FindFirstChild("Humanoid") ~= nil then
Player = game.Players:FindFirstChild(hit.Parent.Name)
if Player ~= nil then
if Player:IsInGroup(GroupId) == false then
hit.Parent:BreakJoints()
end
end
end
end

function knock(hit)
if hit.Parent ~= nil and hit.Parent:FindFirstChild("Humanoid") ~= nil and hit.Parent:FindFirstChild("Torso") ~= nil then
Player = game.Players:FindFirstChild(hit.Parent.Name)
if Player ~= nil then
if Player:IsInGroup(GroupId) == false then
hit.Parent.Torso.RotVelocity = Vector3.new(50, -230, 50)
end
end
end
end

function ontouched(hit)
print("On")
if hit.Parent ~= nil and hit.Parent:FindFirstChild("Humanoid") ~= nil then
print("On")
check(hit.Parent)
if Check == true then
open(hit)
elseif Check == false then
if Killing == true then
kill(hit)
end
if Knockback == true then
knock(hit)
end
end
Check = false
end
end

script.Parent.Touched:connect(ontouched)
------------------------------------------------------------------------
-- parse a for loop body for both versions of the for loop
-- * used in fornum(), forlist()
------------------------------------------------------------------------
function luaY:forbody(ls, base, line, nvars, isnum)
  -- forbody -> DO block
  local bl = {}  -- BlockCnt
  local fs = ls.fs
  self:adjustlocalvars(ls, 3)  -- control variables
  self:checknext(ls, "TK_DO")
  local prep = isnum and luaK:codeAsBx(fs, "OP_FORPREP", base, luaK.NO_JUMP)
                     or luaK:jump(fs)
  self:enterblock(fs, bl, false)  -- scope for declared variables
  self:adjustlocalvars(ls, nvars)
  luaK:reserveregs(fs, nvars)
  self:block(ls)
  self:leaveblock(fs)  -- end of scope for declared variables
  luaK:patchtohere(fs, prep)
  local endfor = isnum and luaK:codeAsBx(fs, "OP_FORLOOP", base, luaK.NO_JUMP)
                       or luaK:codeABC(fs, "OP_TFORLOOP", base, 0, nvars)
  luaK:fixline(fs, line)  -- pretend that `OP_FOR' starts the loop
  luaK:patchlist(fs, isnum and endfor or luaK:jump(fs), prep + 1)
end
--[[
	INSTALL INSTRUCTIONS:
	Firstly, place this script inside of ServerScriptService.
	
	Secondly, move modules and features that you don't care for into the DeactivatedModules folder, and if any modules in there are ones you would
	like, just drop them into Modules!
	
	Configuration for each module should be stored in a configuration folder inside of the module, or in a module script named "Configuration."
	
	raidRoleplay is meant to be modular, so read the documentation and write your own code, or simply install modules created by others into the
	"Modules" folder.
	
	Finally, global configuration for rank ID and such should be in the Configuration folder attached to this script.
	
	With love,
	r_aidmaster
--]]

require(script:WaitForChild("Assets"):WaitForChild("Loader")).Main() --  Here we go!
--[[ The Module ]]--
local BaseCharacterController = require(script.Parent:WaitForChild("BaseCharacterController"))
local DynamicThumbstick = setmetatable({}, BaseCharacterController)
DynamicThumbstick.__index = DynamicThumbstick

function DynamicThumbstick.new()
	local self = setmetatable(BaseCharacterController.new() :: any, DynamicThumbstick)

	self.moveTouchObject = nil
	self.moveTouchLockedIn = false
	self.moveTouchFirstChanged = false
	self.moveTouchStartPosition = nil

	self.startImage = nil
	self.endImage = nil
	self.middleImages = {}

	self.startImageFadeTween = nil
	self.endImageFadeTween = nil
	self.middleImageFadeTweens = {}

	self.isFirstTouch = true

	self.thumbstickFrame = nil

	self.onRenderSteppedConn = nil

	self.fadeInAndOutBalance = FADE_IN_OUT_BALANCE_DEFAULT
	self.fadeInAndOutHalfDuration = FADE_IN_OUT_HALF_DURATION_DEFAULT
	self.hasFadedBackgroundInPortrait = false
	self.hasFadedBackgroundInLandscape = false

	self.tweenInAlphaStart = nil
	self.tweenOutAlphaStart = nil

	return self
end
-- Options
local USE_CUSTOM_TIME	= false
local USE_MILITARY_TIME	= false
--Both
local Loudness = .75 --volume of the boost supplier (not exact volume so you kinda have to experiment with it also)

script:WaitForChild("Whistle")
script:WaitForChild("Whine")
script:WaitForChild("BOV")

for i,v in pairs(car.DriveSeat:GetChildren()) do
	for _,a in pairs(script:GetChildren()) do
		if v.Name==a.Name then v:Stop() wait() v:Destroy() end
	end
end

car.DriveSeat.ChildRemoved:connect(function(child)
	if child.Name=="SeatWeld" then
		for i,v in pairs(car.DriveSeat:GetChildren()) do
			for _,a in pairs(script:GetChildren()) do
				if v.Name==a.Name then v:Stop() wait() v:Destroy() end
			end
		end
	end
end)

handler:FireServer("newSound","Whistle",car.DriveSeat,script.Whistle.SoundId,0,script.Whistle.Volume,true)
handler:FireServer("newSound","Whine",car.DriveSeat,script.Whine.SoundId,0,script.Whine.Volume,true)
handler:FireServer("newSound","BOV",car.DriveSeat,script.BOV.SoundId,0,script.BOV.Volume,true)
handler:FireServer("playSound","Whistle")
handler:FireServer("playSound","Whine")
car.DriveSeat:WaitForChild("Whistle")
car.DriveSeat:WaitForChild("Whine")
car.DriveSeat:WaitForChild("BOV")
local ticc = tick()
local _TCount = 0
if _Tune.Aspiration == "Single" or _Tune.Aspiration == "Super" then _TCount = 1 elseif _Tune.Aspiration == "Double" then _TCount = 2 end

while wait() do
	local psi = (((script.Parent.Values.Boost.Value)/(_Tune.Boost*_TCount))*2)
	local WP,WV,BP,BV,HP,HV = nil
	
	BOVact = math.floor(psi*20)
	if _Tune.Aspiration == "Single" or _Tune.Aspiration == "Double" then
		WP = (psi)
		WV = (psi/4)*Loudness
		
		BP = (1-(-psi/20))*BOV_Pitch
		BV = (((-0.5+((psi/2)*BOV_Loudness)))*(1 - script.Parent.Values.Throttle.Value))
	
		if BOVact < BOVact2 then if car.DriveSeat.BOV.IsPaused then if FE then handler:FireServer("playSound","BOV") else car.DriveSeat.BOV:Play() end end end
		if BOVact >= BOVact2 then if FE then handler:FireServer("stopSound","BOV") else car.DriveSeat.BOV:Stop() end end
	elseif _Tune.Aspiration == "Super" then
		psi = psi/2
		HP = psi*Whine_Pitch
		HV = (psi/4)*Loudness
	end
		
	if FE then
		handler:FireServer("updateSound","Whistle",script.Whistle.SoundId,WP,WV)
		handler:FireServer("updateSound","Whine",script.Whine.SoundId,HP,HV)
		handler:FireServer("updateSound","BOV",script.BOV.SoundId,BP,BV)
	else
		car.DriveSeat.Whistle.Pitch = WP
		car.DriveSeat.Whistle.Volume = WV
		car.DriveSeat.Whine.Pitch = HP
		car.DriveSeat.Whine.Volume = HV
		car.DriveSeat.BOV.Pitch = BP
		car.DriveSeat.BOV.Volume = BV
	end
	if (tick()-ticc) >= 0.1 then
		BOVact2 = math.floor(psi*20)
		ticc = tick()
	end
end
--------LEFT DOOR --------
game.Workspace.doorleft.l11.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l12.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l13.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l21.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l22.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l23.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l31.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l32.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l33.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l41.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l42.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l43.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l51.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l52.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l53.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l61.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l62.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l63.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l71.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l72.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.l73.BrickColor = BrickColor.new(194)
game.Workspace.doorleft.pillar.BrickColor = BrickColor.new(194)
--[=[
	Catches an error, and allows another observable to be subscribed
	in terms of handling the error.

	:::warning
	This method is not yet tested
	:::

	@param callback (error: TError) -> Observable<TErrorResult>
	@return (source: Observable<T>) -> Observable<T | TErrorResult>
]=]
function Rx.catchError(callback)
	assert(type(callback) == "function", "Bad callback")

	return function(source)
		assert(Observable.isObservable(source), "Bad observable")

		return Observable.new(function(sub)
			local maid = Maid.new()

			-- Yikes, let's hope event ordering is good
			local alive = true
			maid:GiveTask(function()
				alive = false
			end)

			maid:GiveTask(source:Subscribe(
				function(...)
					sub:Fire(...)
				end,
				function(...)
					if not alive then
						-- if we failed because maid was cancelled, then we'll get called here?
						-- I think.
						return
					end

					-- at this point, we can only have one error, so we need to subscribe to the result
					-- and continue the observiable
					local observable = callback(...)
					assert(Observable.isObservable(observable), "Bad observable")

					maid:GiveTask(observable:Subscribe(sub:GetFireFailComplete()))
				end,
				function()
					sub:Complete()
				end));

			return maid
		end)
	end
end
-- Other
local indicator = Instance.new("ImageLabel")
indicator.Name = "Indicator"
indicator.BackgroundTransparency = 1
indicator.Image = "rbxassetid://5278151556"
indicator.Size = UDim2.new(0,32,0,32)
indicator.AnchorPoint = Vector2.new(0.5,0)
indicator.Position = UDim2.new(0.5,0,0,5)
indicator.ScaleType = Enum.ScaleType.Fit
indicator.Visible = false
indicator.Active = true
indicator.Parent = topbarPlusGui
indicator.Active = false
--!strict
local function endsWith(value: string, substring: string, optionalLength: number?): boolean
	local substringLength = substring:len()
	if substringLength == 0 then
		return true
	end
	local valueLength = value:len()
	local length = optionalLength or valueLength
	if length > valueLength then
		length = valueLength
	end
	if length < 1 then
		return false
	end
	local position = length - substringLength + 1
	return value:find(substring, position, true) == position
end

return endsWith
--[[
	Model for an UserAsset
	{
		userAssetId = string,
		userId = name,
		userName = string,
		serialNumber = optional string,
		priceInRobux = optional int
	}
]]
local Modules = game:GetService("Players").LocalPlayer.PlayerGui.AvatarEditorInGame.Modules
local MockId = require(Modules.NotLApp.MockId)

local UserAssetModel = {}

function UserAssetModel.mock()
	local self = {}

	self.userAssetId = tostring(MockId())
	self.userId = tostring(MockId())
	self.userName = ""
	self.serialNumber = tostring(MockId())
	self.priceInRobux = 0

	return self
end

function UserAssetModel.fromSellPageAndResellers(newData)
	local userAssetInfo = {}

	userAssetInfo.userAssetId = tostring(newData.userAssetId)
	if newData.seller then
		userAssetInfo.userId = tostring(newData.seller.id)
		userAssetInfo.userName = newData.seller.name
	end

	userAssetInfo.serialNumber = newData.serialNumber and tostring(newData.serialNumber) or nil
	userAssetInfo.priceInRobux = newData.price
	return userAssetInfo
end

function UserAssetModel.fromPriceInRobux(userAssetId, priceInRobux)
	local userAssetInfo = {}

	userAssetInfo.userAssetId = tostring(userAssetId)
	userAssetInfo.priceInRobux = priceInRobux

	return userAssetInfo
end

return UserAssetModel
--UserInput.MouseBehavior = Enum.MouseBehavior.LockCenter

function CameraModule.new(Position, Rotation, Sensitivity, move)
	local Camera = {}
	
	Camera.Position = Position
	Camera.Rotation = Rotation
	Camera.CFrame = CFrame.new(Position) * CFrame.Angles(math.rad(Rotation.X), math.rad(Rotation.Y), math.rad(Rotation.Z))
	Camera.Target = Vector3.new(1,0,0)
	Camera.PressedKey = nil

	Camera.fpsController = {
		direction = 0,
		pitch = 0,
	}

	Camera.Sensitivity = Sensitivity
	
	Mouse.KeyDown:Connect(function(key)
		Camera.PressedKey = key
	end)

	Mouse.KeyUp:Connect(function()
		Camera.PressedKey = nil
	end)

	function Camera:Movement()
		local key = Camera.PressedKey

		if key == "e" then
			Camera.CFrame += Vector3.new(0,0.4,0)
		elseif key == "q" then
			Camera.CFrame -= Vector3.new(0,0.4,0)
		elseif key == "w" then
			Camera.CFrame += Vector3.new(0.4*math.cos(-Camera.Rotation.Y), 0, 0.4*math.sin(-Camera.Rotation.Y))
		elseif key == "s" then
			Camera.CFrame -= Vector3.new(0.4*math.cos(-Camera.Rotation.Y), 0, 0.4*math.sin(-Camera.Rotation.Y))
		elseif key == "a" then
			Camera.CFrame += Vector3.new(0.4*math.sin(-Camera.Rotation.Y), 0, -0.4*math.cos(-Camera.Rotation.Y))
		elseif key == "d" then
			Camera.CFrame += Vector3.new(-0.4*math.sin(-Camera.Rotation.Y), 0, 0.4*math.cos(-Camera.Rotation.Y))
		end
		
		task.synchronize()
		Camera:Pan(UserInput:GetMouseDelta().X, UserInput:GetMouseDelta().Y)
		task.desynchronize()
	end

	function Camera:Pan(dx, dy)
		Camera.fpsController.direction = math.max(math.min(Camera.fpsController.direction - dy * Camera.Sensitivity, math.pi * 0.5), math.pi * -0.5)
		Camera.fpsController.pitch = Camera.fpsController.pitch - dx * Camera.Sensitivity
		
		local rotationCFrame = CFrame.Angles(0, Camera.fpsController.pitch, 0) * CFrame.Angles(Camera.fpsController.direction, 0, 0)
		local positionCFrame = CFrame.new(Camera.CFrame.Position)

		Camera.CFrame = positionCFrame * rotationCFrame
	end
	
	function Camera:Update()
		Camera.Position = Camera.CFrame.Position
		local xRotation, yRotation, _ = Camera.CFrame:ToOrientation()
		Camera.Rotation = Vector3.new(xRotation, yRotation + math.rad(90), 0)
		
		if move == true then
			Camera:Movement()
		end
	end

	return Camera
end

return CameraModule