View difference between Paste ID: wrYeNtnr and peu3virk

 --Converted with ttyyuu12345's model to script plugin v4
 if game:GetService("RunService"):IsClient() then error("Script must be server-side in order to work; use h/ and not hl/") end
 local Player,game,owner = owner,game
 local RealPlayer = Player
 do
 	print("FE Compatibility code by Mokiros")
 	local rp = RealPlayer
 	script.Parent = rp.Character
 
 	--RemoteEvent for communicating
 	local Event = Instance.new("RemoteEvent")
 	Event.Name = "UserInput_Event"
 
 	--Fake event to make stuff like Mouse.KeyDown work
 	local function fakeEvent()
 		local t = {_fakeEvent=true,Functions={},Connect=function(self,f)table.insert(self.Functions,f) end}
 		t.connect = t.Connect
 		return t
 	end
 
 	--Creating fake input objects with fake variables
     local m = {Target=nil,Hit=CFrame.new(),KeyUp=fakeEvent(),KeyDown=fakeEvent(),Button1Up=fakeEvent(),Button1Down=fakeEvent(),Button2Up=fakeEvent(),Button2Down=fakeEvent()}
 	local UIS = {InputBegan=fakeEvent(),InputEnded=fakeEvent()}
 	local CAS = {Actions={},BindAction=function(self,name,fun,touch,...)
 		CAS.Actions[name] = fun and {Name=name,Function=fun,Keys={...}} or nil
 	end}
 	--Merged 2 functions into one by checking amount of arguments
 	CAS.UnbindAction = CAS.BindAction
 
 	--This function will trigger the events that have been :Connect()'ed
 	local function te(self,ev,...)
 		local t = m[ev]
 		if t and t._fakeEvent then
 			for _,f in pairs(t.Functions) do
 				f(...)
 			end
 		end
 	end
 	m.TrigEvent = te
 	UIS.TrigEvent = te
 
 	Event.OnServerEvent:Connect(function(plr,io)
 	    if plr~=rp then return end
 		m.Target = io.Target
 		m.Hit = io.Hit
 		if not io.isMouse then
 			local b = io.UserInputState == Enum.UserInputState.Begin
 			if io.UserInputType == Enum.UserInputType.MouseButton1 then
 				return m:TrigEvent(b and "Button1Down" or "Button1Up")
 			end
 			if io.UserInputType == Enum.UserInputType.MouseButton2 then
 				return m:TrigEvent(b and "Button2Down" or "Button2Up")
 			end
 			for _,t in pairs(CAS.Actions) do
 				for _,k in pairs(t.Keys) do
 					if k==io.KeyCode then
 						t.Function(t.Name,io.UserInputState,io)
 					end
 				end
 			end
 			m:TrigEvent(b and "KeyDown" or "KeyUp",io.KeyCode.Name:lower())
 			UIS:TrigEvent(b and "InputBegan" or "InputEnded",io,false)
 	    end
 	end)
 	Event.Parent = NLS([==[
 	local Player = game:GetService("Players").LocalPlayer
 	local Event = script:WaitForChild("UserInput_Event")
 	local Mouse = Player:GetMouse()
 	local UIS = game:GetService("UserInputService")
 	local input = function(io,a)
 		if a then return end
 		--Since InputObject is a client-side instance, we create and pass table instead
 		Event:FireServer({KeyCode=io.KeyCode,UserInputType=io.UserInputType,UserInputState=io.UserInputState,Hit=Mouse.Hit,Target=Mouse.Target})
 	end
 	UIS.InputBegan:Connect(input)
 	UIS.InputEnded:Connect(input)
 	local h,t
 	--Give the server mouse data 30 times every second, but only if the values changed
 	--If player is not moving their mouse, client won't fire events
 	while wait(1/30) do
 		if h~=Mouse.Hit or t~=Mouse.Target then
 			h,t=Mouse.Hit,Mouse.Target
 			Event:FireServer({isMouse=true,Target=t,Hit=h})
 		end
 	end]==],Player.Character)
 
 	----Sandboxed game object that allows the usage of client-side methods and services
 	--Real game object
 	local _rg = game
 
 	--Metatable for fake service
 	local fsmt = {
 		__index = function(self,k)
 			local s = rawget(self,"_RealService")
 			if s then
 				return typeof(s[k])=="function"
 				and function(_,...)return s[k](s,...)end or s[k]
 			end
 		end,
 		__newindex = function(self,k,v)
 			local s = rawget(self,"_RealService")
 			if s then s[k]=v end
 		end
 	}
 	local function FakeService(t,RealService)
 		t._RealService = typeof(RealService)=="string" and _rg:GetService(RealService) or RealService
 		return setmetatable(t,fsmt)
 	end
 
 	--Fake game object
 	local g = {
 		GetService = function(self,s)
 			return rawget(self,s) or _rg:GetService(s)
 		end,
 		Players = FakeService({
 			LocalPlayer = FakeService({GetMouse=function(self)return m end},Player)
 		},"Players"),
 		UserInputService = FakeService(UIS,"UserInputService"),
 		ContextActionService = FakeService(CAS,"ContextActionService"),
 		RunService = FakeService({
 			_btrs = {},
 			RenderStepped = _rg:GetService("RunService").Heartbeat,
 			BindToRenderStep = function(self,name,_,fun)
 				self._btrs[name] = self.Heartbeat:Connect(fun)
 			end,
 			UnbindFromRenderStep = function(self,name)
 				self._btrs[name]:Disconnect()
 			end,
 		},"RunService")
 	}
 	rawset(g.Players,"localPlayer",g.Players.LocalPlayer)
 	g.service = g.GetService
 	FakeService(g,game)
 	--Changing owner to fake player object to support owner:GetMouse()
 	game,owner = g,g.Players.LocalPlayer
 end
 
 function sandbox(var,func)
 	local env = getfenv(func)
 	local newenv = setmetatable({},{
 		__index = function(self,k)
 			if k=="script" then
 				return var
 			else
 				return env[k]
 			end
 		end,
 	})
 	setfenv(func,newenv)
 	return func
 end
 cors = {}
 mas = Instance.new("Model",game:GetService("Lighting"))
 Tool0 = Instance.new("Tool")
 LocalScript1 = Instance.new("LocalScript")
 Script2 = Instance.new("Script")
 Part3 = Instance.new("Part")
 SpecialMesh4 = Instance.new("SpecialMesh")
 Script5 = Instance.new("Script")
 ObjectValue6 = Instance.new("ObjectValue")
 ObjectValue7 = Instance.new("ObjectValue")
 Tool0.Name = "LaserSpecs"
 Tool0.Parent = mas
 Tool0.TextureId = "http://www.roblox.com/asset/?id=100449698"
 Tool0.GripForward = Vector3.new(-0, 1.31134158e-07, -1)
 Tool0.GripPos = Vector3.new(1.53999996, -1.27000034, -1.31999993)
 Tool0.GripUp = Vector3.new(0, 1, 1.31134158e-07)
 LocalScript1.Name = "SpotWeld_Main"
 LocalScript1.Parent = Tool0
 table.insert(cors,sandbox(LocalScript1,function()
 --local mDebugId = game.Workspace.DebugId.Value
 --game.Workspace.DebugId.Value = game.Workspace.DebugId.Value+1
 --print("Running swordscript <"..mDebugId..">")
 
 -------------------------------------
 -- Makes an RBX::Lua Instance using
 -- a table of key-value pairs to
 -- initialize it. Values with numeric
 -- keys will be parented to the object
 -- and other values will be set
 -- as members of the object.
 function Create(ty)
 	return function(data)
 		local obj = Instance.new(ty)
 		for k, v in pairs(data) do
 			if type(k) == 'number' then
 				v.Parent = obj
 			else
 				obj[k] = v
 			end
 		end
 		return obj
 	end
 end
 
 ---------------------------------------
 -- Same as Make, but modifies an existing
 -- object rather than creating ones.
 function Modify(obj, data)
 	for k, v in pairs(data) do
 		if type(data) == 'number' then
 			data.Parent = obj
 		else
 			data[k] = v
 		end
 	end
 	return obj
 end
 
 -----------------------------------------
 -- Creates a class which can be instantiated
 -- using `CreateCLASSNAME( ... )`.
 ---usage:
 --class'MyClass'(function(this, arg1)
 --	this.ClassMember = value
 --	function this.ClassMethod(...) ... end
 --end, function(def)
 --	def.StaticMember = value
 --	 function def.StaticMethod(...) ... end
 --end)
 --local obj = CreateMyClass(arg1)
 ------------------------------------------
 local function class(name)
 	local def = {}
 	getfenv(0)[name] = def
 	return function(ctor, static)
 		local nctor = function(...)
 			local this = {}
 			if ctor then
 				ctor(this, ...)
 			end
 			return this
 		end
 		getfenv(0)['Create'..name] = nctor
 		if static then static(def) end
 	end
 end
 
 
 ---------------------------------------------
 -- Signal class for custom-made events
 --API:
 -- Signal:connect(callback)
 -- Signal:fire(...)
 -- Signal:wait()
 ---------------------------------------------
 class'Signal'(function(this)
 	local mListeners = {}
 	local mWaitObject = Create'BoolValue'{}
 
 	function this:connect(func)
 		local connection = {}
 		function connection:disconnect()
 			mListeners[func] = nil
 		end
 		mListeners[func] = connection
 		return connection
 	end
 
 	function this:fire(...)
 		--print("Fire evt<"..tostring(this).."> from script<"..mDebugId..">")
 		for func, conn in pairs(mListeners) do
 			--print("-> "..tostring(func).."( ... )")
 			func(...)
 		end
 		mWaitObject.Value = not mWaitObject.Value
 	end
 
 	function this:wait()
 		mWaitObject.Changed:wait()
 	end
 end)
 
 
 --------------------------------------------------
 -- Bin class for cleaning up assets
 --API:
 -- Bin:add(func: Function, ident: String)
 -- Bin:clean(ident: String)
 -- Bin:cleanAll()
 --------------------------------------------------
 class'Bin'(function(this)
 	local mGarbage = {}
 
 	function this:add(func, ident)
 		ident = ident or '__unnamed'
 		if not mGarbage[ident] then
 			mGarbage[ident] = {}
 		end
 		mGarbage[ident][#mGarbage[ident]+1] = func
 	end
 
 	function this:clean(ident)
 		local listToCall = mGarbage[ident]
 		if listToCall then
 			for _, func in pairs(listToCall) do
 				func()
 			end
 			mGarbage[ident] = nil
 		end
 	end
 
 	function this:cleanAll()
 		for ident, list in pairs(mGarbage) do
 			for _, func in pairs(list) do
 				func()
 			end
 			mGarbage[ident] = nil
 		end
 	end
 end)
 
 
 -----------------------------------------------------
 -- AnimationProvider class for easy loading of
 -- animation assets into animationtracks once
 -- a humanoid is available.
 --API:
 -- AnimationProvider:registerAnimation(ident, assetid)
 -- AnimationProvider:setHumanoid(humanoid)
 -- AnimationProvider:setTool(tool)
 -- AnimationProvider:getAnimation(ident)
 -----------------------------------------------------
 class'AnimationProvider'(function(this)
 	local mAnimations = {--[[ident => {AnimationId, CurrentTrack, CurrentAnim} ]]}
 	local mCurrentHumanoid = nil
 
 	function this:registerAnimation(ident, assetid)
 		--check for an existing copy of the anim
 		local existingAnim = Tool.Tool:FindFirstChild('ANIM_'..ident)
 
 		--make the data for this anim
 		local animdat = {
 			AnimationId = assetid,
 			CurrentAnim = existingAnim or Create'Animation'{
 				Name = "ANIM_"..ident,
 				AnimationId = assetid,
 			},
 		}
 		mAnimations[ident] = animdat
 
 		--if there's a current tool, put it in there
 		if Tool.Tool then
 			Tool.HUGE_EQUIP_HACK = true
 			animdat.CurrentAnim.Parent = Tool.Tool
 			Tool.HUGE_EQUIP_HACK = false
 		end
 
 		--if there's a humanoid load the animation track
 		if mCurrentHumanoid then
 			animdat.CurrentTrack = mCurrentHumanoid:LoadAnimation(animdat.CurrentAnim)
 		end
 	end
 
 	function this:setHumanoid(humanoid)
 		mCurrentHumanoid = humanoid
 		for _, anim in pairs(mAnimations) do
 			anim.CurrentTrack = humanoid:LoadAnimation(anim.CurrentAnim)
 		end
 	end
 
 	function this:getAnimation(ident)
 		local dat = mAnimations[ident]
 		if not dat then error("Gear Fatal Error: Animation `"..ident.."` not found") end
 		if not dat.CurrentTrack then
 			error("Gear Fatal Error: No Humanoid for animation `"..ident.."` to run in")
 		end
 		return dat.CurrentTrack
 	end
 end)
 
 
 ----------------------------------------------
 -- SoundProvider class
 -- functions similarily to the animationprovider
 ----------------------------------------------
 class'SoundProvider'(function(this)
 	local mSounds = {}
 
 	function this:registerSound(ident, assetid, inpart)
 		inpart = inpart or Tool.Tool:FindFirstChild('Handle')
 		if not inpart then
 			repeat
 				inpart = Tool.Tool.ChildAdded:wait()
 			until inpart.Name == 'Handle'
 		end
 		local existingSound = inpart:FindFirstChild('SOUND_'..ident)
 		local sounddat = {
 			SoundId = assetid,
 			CurrentSound = existingSound or Create'Sound'{
 				Name = 'SOUND_'..ident,
 				SoundId = assetid,
 				Parent = inpart,
 			},
 		}
 		mSounds[ident] = sounddat
 	end
 
 	function this:getSound(ident)
 		local dat = mSounds[ident]
 		if dat then
 			return dat.CurrentSound
 		end
 	end
 end)
 
 
 ----------------------------------------------
 -- DebounceProvider class -- Prevent events
 -- from happening in too rapid succession
 ----------------------------------------------
 class'DebounceProvider'(function(this)
 	local mFlagNameToLastTime = {}
 
 	function this:test(ident, delta)
 		local t = tick()
 		local lastTime = mFlagNameToLastTime[ident] or 0
 		if delta then
 			return (t-lastTime) > delta
 		else
 			return mFlagNameToLastTime[ident]
 		end
 	end
 	function this:set(ident, state)
 		if state then
 			mFlagNameToLastTime[ident] = state
 		elseif state == false then
 			mFlagNameToLastTime[ident] = false
 		else
 			mFlagNameToLastTime[ident] = tick()
 		end
 	end
 end)
 
 
 function TagHumanoid(humanoid)
 	if Tool.Player then
 		local tag = Create'ObjectValue'{
 			Name = "creator",
 			Value = Tool.Player,
 			Parent = humanoid,
 		}
 		game.Debris:AddItem(tag, 1)
 	end
 end
 
 
 ------- wait for any event in a set of events  to fire ------
 function WaitForAny(tb)
 	local evt = tb
 	local conn = {}
 	local eventargs = nil
 	local waitProxy = Create'BoolValue'{}
 	for _, e in pairs(evt) do
 		local c = e:connect(function(...)
 			for _, c in pairs(conn) do
 				c:disconnect()
 			end
 			eventargs = {...}
 			waitProxy.Value = not waitProxy.Value
 		end)
 		conn[#conn+1] = c
 	end
 	--
 	waitProxy.Changed:wait()
 	--
 	return unpack(eventargs)
 end
 
 
 ----------------------------------------------
 
 local EmitterPart = nil
 
 -- Tool singleton class
 --API:
 -- ...
 class'Tool'(nil, function(this)
 	--need this here for the animationprovider to use
 	this.HUGE_EQUIP_HACK = false
 
 	this.Bin = CreateBin()
 	this.AnimationProvider = CreateAnimationProvider()
 	this.DebounceProvider = CreateDebounceProvider()
 	this.SoundProvider = CreateSoundProvider()
 
 	--general values
 	this.Tool = script.Parent
 	this.Player = nil
 	this.Humanoid = nil
 	this.Character = nil
 
 	--============ several flags for the gear
 	--nothing
 
 	--some events
 	this.Equipped = CreateSignal()
 	this.Unequipped = CreateSignal()
 	this.OwnerChange = CreateSignal()
 
 	--mouse utility events
 	this.MouseClick = CreateSignal()
 	this.MouseRelease = CreateSignal()
 	this.MouseDoubleClick = CreateSignal()
 	this.DoubleClickThreshold = 0.2
 	this.MouseDown = false
 	this.KeyDown = CreateSignal()
 
 	local mLastClickTime = 0
 
 	script.Parent.Equipped:connect(function(mouse)
 		--print("Internal Equipped: Time b: "..time())
 		--set up general values in the tool
 		this.Mouse = mouse
 		local curOwner = game.Players:GetPlayerFromCharacter(script.Parent.Parent)
 		if curOwner ~= this.Player then
 			this.Player = curOwner
 			this.OwnerChange:fire(this.Player)
 		end
 		this.Character = this.Player.Character
 		this.Humanoid = this.Character.Humanoid
 		this.AnimationProvider:setHumanoid(this.Humanoid)
 
 		--set up the mouse events
 		mouse.Button1Down:connect(function()
 			this.MouseDown = true
 			local t = tick()
 			if (t-mLastClickTime) < this.DoubleClickThreshold then
 				--prvent multiple double-clicks in a row
 				mLastClickTime = 0
 				this.MouseDoubleClick:fire(mouse)
 			else
 				mLastClickTime = t
 				this.MouseClick:fire(mouse)
 			end
 		end)
 		mouse.Button1Up:connect(function()
 			this.MouseDown = false
 			if EmitterPart then
 				EmitterPart:Destroy()
 				EmitterPart=nil
 			end
 		end)
 		mouse.KeyDown:connect(function(key)
 			this.KeyDown:fire(key)
 		end)
 
 		--done setup, call the equipped function
 		if this.HUGE_EQUIP_HACK then
 			--the HUGE_EQUIP_HACK flags tells the tool that the equip is a synchronous
 			--call as a result of parenting an animation to the character, which happens
 			--when the tool is picked up from the workspace, but not during normal equips
 			--(Why does this happen???), if this is the case, the call should be rederrred
 			--one tick to ensure that all of the gear's loading can complete before it's
 			--equipped event is called.
 			--TODO: Blame John for this.
 			Delay(0, function()
 				this.Equipped:fire(mouse)
 			end)
 		else
 			--otherwise, proceed as normal
 			this.Equipped:fire(mouse)
 		end
 	end)
 
 	script.Parent.Unequipped:connect(function()
 		--before my teardown, fire the event
 		this.Unequipped:fire()
 
 		--delete all my garbage
 		this.Bin:cleanAll()
 	end)
 end)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 local BeamColor = BrickColor.new(Color3.new(255, 0, 0))
 local PartModel = Create'Model'{
 	Name = 'SpotWeld_Parts',
 }
 local Failsafe = nil
 
 Tool.AnimationProvider:registerAnimation('equip', 'http://www.roblox.com/asset/?id=69427262')
 Tool.AnimationProvider:registerAnimation('fire', 'http://www.roblox.com/asset/?id=69427271')
 Tool.AnimationProvider:registerAnimation('hold', 'http://www.roblox.com/asset/?id=69427277')
 
 class'RaycastIgnore'(nil, function(def)
 	local mIgnoreMap = setmetatable({}, {__mode='k'})
 	function def:addIgnore(obj)
 		mIgnoreMap[obj] = true
 	end
 	function def:genIgnoreList()
 		local ignoreList = {}
 		for p, _ in pairs(mIgnoreMap) do
 			ignoreList[#ignoreList+1] = p
 			for _,t in pairs(p:GetChildren()) do
 				if t.Name == 'Effect' then
 					ignoreList[#ignoreList+1] = t
 				end
 			end
 		end
 		for _, ch in pairs(Tool.Character:GetChildren()) do
 			if ch:IsA('BasePart') then
 				ignoreList[#ignoreList+1] = ch
 			end
 			for _, handle in pairs(ch:GetChildren()) do
 				if handle:IsA('BasePart') then
 					ignoreList[#ignoreList+1] = ch
 				end
 			end
 		end
 		return ignoreList
 	end
 end)
 
 class'SpotWeld_Charge'(function(this)
 	this.Completed = CreateSignal()
 	--
 	local mReady = false
 	local mSpokeList = {} --[i] = {Direction, Part, Len, Dist}
 	local mChargeSphere = nil
 	local mFracComplete = 0
 	--
 	local mLocation;
 	--
 	local mCurrentRun = 0
 	--
 	local function genSpokes()
 		if mReady then return end
 		mReady = true
 
 		--make charge sphere
 		mChargeSphere = Create'Part'{
 			Name = 'SpotWeld_ChrageSphere',
 			FormFactor = 'Custom',
 			Anchored = true,
 			CanCollide = false,
 			Transparency = 0.3,
 			BrickColor = BeamColor,
 			Create'SpecialMesh'{MeshType='Sphere',},
 		}
 		RaycastIgnore:addIgnore(mChargeSphere)
 
 		--make new spokes
 		for i = 1, 20 do
 			local spoke = {}
 			spoke.Part = Create'Part'{
 				Name = 'SpotWeld_Spoke',
 				FormFactor = 'Custom',
 				Anchored = true,
 				CanCollide = false,
 				Transparency = 0.3,
 				BrickColor = BeamColor,
 			}
 			RaycastIgnore:addIgnore(spoke.Part)
 			mSpokeList[i] = spoke
 		end
 	end
 	local function randomizeSpokes()
 		for _, spoke in pairs(mSpokeList) do
 			spoke.Direction = CFrame.new(mLocation)*CFrame.Angles(math.random(-1.14, 1.14),
 			                                                      math.random(-1.14, 1.14),
 			                                                      math.random(-1.14, 1.14))
 			spoke.Len = math.random()*1+1
 			spoke.Dist = math.random()*1+1
 			spoke.Part.Size = Vector3.new(0.1, 0.1, spoke.Len)
 		end
 	end
 	local function showSpokes(state)
 		if mReady then
 			local par = ((state) and PartModel or nil)
 			mChargeSphere.Parent = par
 			for _, spoke in pairs(mSpokeList) do
 				spoke.Part.Parent = par
 			end
 		end
 	end
 	local function setSpokes()
 		local sphereSz = mFracComplete
 		mChargeSphere.Size = Vector3.new(sphereSz, sphereSz, sphereSz)
 		mChargeSphere.CFrame = CFrame.new(mLocation)
 		--
 		for _, spoke in pairs(mSpokeList) do
 			local endDistOut = (1-mFracComplete)*spoke.Dist
 			local innerDistOut = endDistOut-spoke.Len-sphereSz
 			local gotLen;
 			if innerDistOut < 0 then
 				gotLen = spoke.Len+innerDistOut
 			else
 				gotLen = spoke.Len
 			end
 			spoke.Part.Size = Vector3.new(0.1, 0.1, spoke.Len+innerDistOut)
 			spoke.Part.CFrame = spoke.Direction*CFrame.new(0, 0, -(endDistOut-gotLen/2))
 		end
 	end
 	--
 	function this:run(location)
 		mLocation = location
 		mCurrentRun = mCurrentRun+1
 		local thisRun = mCurrentRun
 		mFracComplete = 0
 		--
 		genSpokes()
 		randomizeSpokes()
 		showSpokes(true)
 		--
 		Spawn(function()
 			local lastTime = tick()
 			while mCurrentRun == thisRun and mFracComplete < 1 do
 				local now = tick()
 				local dt = now-lastTime
 				lastTime = now
 				--
 				mFracComplete = math.min(1, mFracComplete+dt*2)
 				setSpokes()
 				--
 				wait()
 			end
 			if mCurrentRun == thisRun then
 				showSpokes(false)
 				this.Completed:fire()
 			end
 		end)
 	end
 	function this:stop()
 		showSpokes(false)
 		mCurrentRun = mCurrentRun+1
 	end
 	--
 	function this:destroy()
 		mReady = false
 		mChargeSphere:Destroy()
 		for i, spoke in pairs(mSpokeList) do
 			mSpokeList[i] = nil
 			spoke.Part:Destroy()
 		end
 	end
 end)
 
 
 
 --[[
 locations:
 
     C
    /\
   /  \
   A  B
   locationGetFunc => A, B, C
 ]]
 local function frand(a, b)
 	return a+math.random()*(b-a)
 end
 class'WavyBeam'(function(this, numSegs)
 	local mSegList = {}
 	for i = 1, numSegs do
 		mSegList[i] = Create'Part'{
 			Name = 'SpotWeld_BeamBit',
 			Anchored = true,
 			CanCollide = false,
 			FormFactor = 'Custom',
 			BrickColor = BeamColor,
 			Transparency = 0.3,
 		}
 		RaycastIgnore:addIgnore(mSegList[i])
 	end
 	function this:show(from, to)
 		local totalLen = (from-to).magnitude
 		local wave = math.min(totalLen/5, 1)/2
 		local dirCF = CFrame.new(from, to)
 		local lastPos = dirCF.p --(dirCF*CFrame.new(frand(-wave, wave), frand(-wave, wave), 0)).p
 		for i = 1, numSegs do
 			local p = mSegList[i]
 			p.Parent = PartModel
 			local distToThisEnd = i*(totalLen/numSegs)
 			local newPos;
 			if i == numSegs then
 				newPos = (dirCF*CFrame.new(0,0,-distToThisEnd)).p
 			else
 				newPos = (dirCF*CFrame.new(frand(-wave, wave),
 				                           frand(-wave, wave),
 				                           -distToThisEnd)).p
 			end
 			p.Size = Vector3.new(0.1, 0.1, totalLen/numSegs)
 			p.CFrame = CFrame.new(lastPos, newPos)*CFrame.new(0, 0, -(lastPos-newPos).magnitude/2)
 			lastPos = newPos
 		end
 	end
 	function this:hide()
 		for i = 1, numSegs do
 			mSegList[i].Parent = nil
 		end
 	end
 end)
 class'SpotWeld_Beam'(function(this)
 
 
 	local mParticleEmitter = Create'Part'{
 		Name = 'SpotWeld_ParticleEmitter',
 		Anchored = true,
 		CanCollide = false,
 		Transparency = 1,
 		Create'Sound'{
 			Name = 'HoldSound1',
 			Looped = true,
 			SoundId = 'http://www.roblox.com/asset/?id=811841430',
 			Volume=1
 		},
 		Create'Sound'{
 			Name = 'HoldSound2',
 			Looped = true,
 			SoundId = 'http://www.roblox.com/asset/?id=811841430',
 			Volume=1
 		},
 	}
 	RaycastIgnore:addIgnore(mParticleEmitter)
 	local mBeam_AC = CreateWavyBeam(2)
 	local mBeam_BC = CreateWavyBeam(2)
 	--
 	local mIsShown = false
 	function this:show(a, b, c, showBeam)
 		if not a then
 			this:hide()
 			return
 		end
 
 		--
 		mBeam_AC:show(a, c)
 		mBeam_BC:show(b, c)
 		--
 
 		--
 		if showBeam then
 			--
 			mParticleEmitter.Parent = PartModel
 			mParticleEmitter.CFrame = CFrame.new(c)
 			--
 			if not mIsShown then
 				mParticleEmitter.HoldSound1:Play()
 				Delay(0.5, function() mParticleEmitter.HoldSound2:Play() end)
 			end
 			mIsShown = true
 		else
 			if EmitterPart then
 				EmitterPart:Destroy()
 				EmitterPart=nil
 			end
 			mParticleEmitter.Parent = nil
 			mIsShown = false
 		end
 		--
 	end
 	function this:hide()
 		mIsShown = false
 		--
 		mBeam_AC:hide()
 		mBeam_BC:hide()
 		--
 		mParticleEmitter.Parent = nil
 	end
 end)
 
 --effects
 local ChargeEffect = CreateSpotWeld_Charge()
 local BeamEffect = CreateSpotWeld_Beam()
 
 --helper to show the beam
 function showBeamEffect(target, showBeam)
 	local ch = Tool.Character
 	local head = ch:FindFirstChild("Head")
 	if not (head) then
 		BeamEffect:hide()
 	end
 	--
 	local ray = CFrame.new(head.Position, target)*CFrame.new(0, 2, -1)
 	local a = (head.CFrame*CFrame.new(-.25, 0, 0)).p
 	local b = (head.CFrame*CFrame.new(.25, 0, 0)).p
 	local c = target
 	--
 	--local b = (head.CFrame*CFrame.new(-0.3, 0.15, -0.6)).p
 	BeamEffect:show(a, b, c, showBeam)
 end
 
 
 function findFaceFromCoord(size, loc)
 	local pa, pb = -size/2, size/2
 	local dx = math.min(math.abs(loc.x-pa.x), math.abs(loc.x-pb.x))
 	local dy = math.min(math.abs(loc.y-pa.y), math.abs(loc.y-pb.y))
 	local dz = math.min(math.abs(loc.z-pa.z), math.abs(loc.z-pb.z))
 	--
 	if dx < dy and dx < dz then
 		if math.abs(loc.x-pa.x) < math.abs(loc.x-pb.x) then
 			return Enum.NormalId.Left --'Left'
 		else
 			return Enum.NormalId.Right --'Right'
 		end
 	elseif dy < dx and dy < dz then
 		if math.abs(loc.y-pa.y) < math.abs(loc.y-pb.y) then
 			return Enum.NormalId.Bottom --'Bottom'
 		else
 			return Enum.NormalId.Top --'Top'
 		end
 	elseif dz < dx and dz < dy then
 		if math.abs(loc.z-pa.z) < math.abs(loc.z-pb.z) then
 			return Enum.NormalId.Front --'Front'
 		else
 			return Enum.NormalId.Back --'Back'
 		end
 	end
 end
 
 
 
 function createFire(part, hit)
 	if (part.Parent or game):FindFirstChild("Humanoid") or
 	   ((part.Parent or game).Parent or game):FindFirstChild("Humanoid") then
 	   return
 	end
 	if not EmitterPart then
 		EmitterPart = Create'Part'{
 			Name = 'EmitPart',
 			FormFactor = 'Custom',
 			CanCollide = false,
 			Anchored = true,
 			Size = Vector3.new(.2, .2, .2),
 			Transparency = 1,
 			Parent = script.Parent,
 		}
 		RaycastIgnore:addIgnore(EmitterPart)
 		local emitScript = script:FindFirstChild('Emitter'):Clone()
 		emitScript.Parent=EmitterPart
 		emitScript.Disabled = false
 	end
 
 
 	local hitFace = findFaceFromCoord(part.Size, part.CFrame:toObjectSpace(CFrame.new(hit)))
 	local dir = (part.CFrame-part.Position)*Vector3.FromNormalId(hitFace)
 	if part:IsA('Terrain') then
 		EmitterPart.CFrame = CFrame.new(hit)
 	else
 		EmitterPart.CFrame = CFrame.new(hit, hit+dir)*CFrame.Angles(-math.pi/2, 0, 0)
 	end
 	game.Debris:AddItem(scorch, 5)
 end
 
 
 local mClickNum = 0
 local mSelected = false
 Tool.MouseClick:connect(function()
 	mClickNum = mClickNum+1
 	local thisClick = mClickNum
 	if not Tool.Mouse.Target or not Tool.Character:FindFirstChild("Head") then
 		return
 	end
 	--
 	Tool.AnimationProvider:getAnimation('fire'):Play(0, 1, 4)
 	Spawn(function()
 		repeat until Tool.AnimationProvider:getAnimation('fire').KeyframeReached:wait() == 'complete'
 		Tool.AnimationProvider:getAnimation('hold'):Play(0, 1, 1)
 	end)
 	--
 	Tool.Humanoid.WalkSpeed = 0
 	--
 	local headPos = Tool.Character.Head.Position
 	local hit = Tool.Mouse.Hit.p
 	ChargeEffect:run((CFrame.new(headPos, hit)*CFrame.new(0, 2, -3)).p)
 	ChargeEffect.Completed:wait()
 	ChargeEffect:stop()
 	--
 	local isDamageTick = false
 	local timeOfLastScorch = tick()
 	local partsToIgnore = RaycastIgnore:genIgnoreList()
 	local headPart = Tool.Character:FindFirstChild("Head")
 	while mSelected and Tool.MouseDown and mClickNum == thisClick and headPart do
 		--first, find the true mouse hit, ignoring my ray parts
 		local mouseRay = Tool.Mouse.UnitRay
 		local newRay = Ray.new(mouseRay.Origin, mouseRay.Direction.unit*999.9)
 		local _, hit = game.Workspace:FindPartOnRayWithIgnoreList(newRay, partsToIgnore)
 
 		--found true hit, now go on to raycast to there from firefrom point
 		local headPos = Tool.Character.Head.Position
 		local fireFrom = (CFrame.new(headPos, hit)*CFrame.new(0, 2, -1)).p
 		local castRay = Ray.new(fireFrom, (hit-fireFrom).unit*999.9)
 		local part, target = game.Workspace:FindPartOnRayWithIgnoreList(castRay, partsToIgnore)
 
 		local charHeading = Tool.Character.Torso.CFrame.lookVector
 		local outOfFOV = (math.acos((target-fireFrom).unit:Dot(charHeading)) > 1.5)
 		if not target or outOfFOV then
 			--just shoot arbitrarily ahead
 			showBeamEffect((Tool.Character.Head.CFrame*CFrame.new(0, 0, -10)).p, false)
 
 		elseif (target-fireFrom).magnitude > 50 then
 			--too far away
 			target = fireFrom+(target-fireFrom).unit*50
 			showBeamEffect(target, false)
 
 		else
 			--mechanism to do more damage every other tick
 			isDamageTick = not isDamageTick
 			if isDamageTick then
 				--see if the target exists and is a humanoid
 				local hum = (part.Parent or game):FindFirstChild("Humanoid")
 				hum = hum or ((part.Parent or game).Parent or game):FindFirstChild("Humanoid")
 				if hum then
 					--found a humanoid, do damage
 					TagHumanoid(hum)
 					hum:TakeDamage(500)
 				end
 			end
 
 			--make scorch effects
 			if (tick()-timeOfLastScorch) > 0.1 then
 				timeOfLastScorch = tick()
 				createFire(part, target)
 			end
 
 			--show the beam
 			showBeamEffect(target, true)
 		end
 		wait()
 	end
 	if mClickNum == thisClick then
 		BeamEffect:hide()
 		Tool.Humanoid.WalkSpeed = 16
 		Tool.AnimationProvider:getAnimation('hold'):Stop()
 	end
 end)
 
 local mHatPart = nil
 Tool.Equipped:connect(function()
 	mSelected = true
 	PartModel.Parent = game.Workspace
 	Failsafe = Tool.Tool.Failsafe:Clone()
 	Failsafe.Disabled = false
 	Failsafe.Model.Value = PartModel
 	Failsafe.Humanoid.Value = Tool.Humanoid
 	Failsafe.Parent = PartModel
 	--
 	Tool.AnimationProvider:getAnimation('equip'):Play(0.1, 1, 4)
 	--Tool.Tool.Grip = CFrame.new()
 	Tool.Tool.Handle.Transparency = 1
 	--
 	Spawn(function()
 		--this code causes re-firing of the equipped event fpor some reason?
 		--putting it in a new thread fixes this behavior
 		mHatPart = Tool.Tool.Handle:Clone()
 		mHatPart.Transparency = 0
 		mHatPart.Parent = Tool.Character
 		local w = Create'Weld'{
 			Parent = mHatPart,
 			Part0 = mHatPart,
 			Part1 = Tool.Character:FindFirstChild('Head'),
 			C0 = CFrame.new(0.040000014, 0, 0.0199999996, 1, 0, 0, 0, 1.31134158e-007, 1, 0, -1, 1.31134158e-007),
 			C1 = CFrame.new(0, 0.200000003, -0.100000001, 1, 0, 0, 0, -4.37113883e-008, 1, 0, -1, -4.37113883e-008)
 		}
 	end)
 end)
 
 Tool.Unequipped:connect(function()
 	mSelected = false
 	PartModel.Parent = nil
 	Failsafe:Destroy()
 	Failsafe = nil
 
 	if EmitterPart then
 			EmitterPart:Destroy()
 			EmitterPart=nil
 	end
 	--
 	Tool.AnimationProvider:getAnimation('equip'):Stop()
 	Tool.AnimationProvider:getAnimation('fire'):Stop()
 	Tool.AnimationProvider:getAnimation('hold'):Stop()
 	--kill any running effects
 	ChargeEffect:stop()
 	BeamEffect:hide()
 	--
 	Tool.Humanoid.WalkSpeed = 16
 	--Tool.Handle.Transparency = 0
 	--
 	if mHatPart then
 		mHatPart:Destroy()
 		mHatPart = nil
 	end
 end)
 
 end))
 Script2.Name = "Emitter"
 Script2.Parent = LocalScript1
 Script2.Disabled = true
 table.insert(cors,sandbox(Script2,function()
 local Particle = Instance.new('Part')
 Particle.Name = 'Effect'
 Particle.Size = Vector3.new(.2,.2,.2)
 Particle.CanCollide = false
 Particle.Transparency = 1
 local PartMesh = Instance.new('SpecialMesh')
 PartMesh.Name = 'PartMesh'
 PartMesh.MeshId = 'http://www.roblox.com/asset/?id=87112830'--'http://www.roblox.com/asset/?id=96501868'--
 PartMesh.TextureId = 'http://www.roblox.com/asset/?id=99871304'
 PartMesh.Parent=Particle
 local PartVelocity = Instance.new('BodyVelocity')
 PartVelocity.maxForce = Vector3.new(99999999,99999999,999999)
 PartVelocity.velocity= Vector3.new(0,1,0)
 PartVelocity.Parent=Particle
 local PartSpin = Instance.new('BodyAngularVelocity')
 PartSpin.maxTorque = Vector3.new(999999999,99999999,999999)
 PartSpin.angularvelocity =Vector3.new(1,1,1)
 PartSpin.Parent=Particle
 
 local Lifetime = 2
 local Rate =.1
 
 function TweenTransparency(element,starta,enda,length)
 	local startTime = time()
 	while time() - startTime < length do
 		element.Transparency = ((enda - starta) * ((time() - startTime)/length)) + starta
 		wait(.01)
 	end
 	element.Transparency = enda
 end
 
 function TweenScale(element,starts,ends,length)
 	local startTime = time()
 	while time() - startTime < length do
 		element.Scale = ((ends - starts) * ((time() - startTime)/length)) + starts
 		wait(.01)
 	end
 	element.Scale = ends
 end
 
 function TweenColor(element,startc,endc,length)
 	local startTime = time()
 	while time() - startTime < length do
 		element.VertexColor = ((endc - startc) * ((time() - startTime)/length)) + startc
 		wait(.01)
 	end
 	element.VertexColor = endc
 end
 
 while true do
 	PartVelocity.velocity= Vector3.new((math.random()-.5)/2,math.random()+3,(math.random()-.5)/2)
 	PartMesh.Scale= Vector3.new((math.random()/2)+.2,math.random()/2+.2,math.random()/2+.2)
 	PartSpin.angularvelocity =Vector3.new(math.random()*3,math.random()*3,math.random()*3)
 	Particle.CFrame= script.Parent.CFrame
 	local npart= Particle:Clone()
 	local nmesh = npart:FindFirstChild('PartMesh')
 	npart.Transparency = 1
 	npart.Parent=script.Parent
 
 	Spawn(function()
 		TweenTransparency(npart, 1,.5,.1)
 		TweenTransparency(npart, .5,1,1.5)
 	end)
 	--Spawn(function()
 		--TweenColor(nmesh, Vector3.new(.8+(math.random()*.4),1,1),Vector3.new(.5,.5,.5),1.5)
 	--end)
 	Spawn(function() TweenScale(nmesh,nmesh.Scale,nmesh.Scale*math.random()*.5,1.5) end)
 	game.Debris:AddItem(npart,Lifetime)
 	wait(Rate)
 
 end
 end))
 Part3.Name = "Handle"
 Part3.Parent = Tool0
 Part3.FormFactor = Enum.FormFactor.Symmetric
 Part3.Shape = Enum.PartType.Ball
 Part3.Size = Vector3.new(1, 1, 1)
 Part3.CFrame = CFrame.new(-6.19000006, 0.500001013, -11.4299984, 1, -2.21533113e-17, 9.25474816e-17, 2.21533113e-17, 1, -3.76204621e-17, -9.25474816e-17, 3.76204621e-17, 1)
 Part3.BottomSurface = Enum.SurfaceType.Smooth
 Part3.TopSurface = Enum.SurfaceType.Smooth
 Part3.Position = Vector3.new(-6.19000006, 0.500001013, -11.4299984)
 SpecialMesh4.Parent = Part3
 SpecialMesh4.MeshId = "rbxassetid://907871510"
 SpecialMesh4.Scale = Vector3.new(0.5, 0.5, 0.5)
 SpecialMesh4.TextureId = "rbxassetid://907871561"
 SpecialMesh4.MeshType = Enum.MeshType.FileMesh
 SpecialMesh4.Scale = Vector3.new(0.5, 0.5, 0.5)
 Script5.Name = "Failsafe"
 Script5.Parent = Tool0
 Script5.Disabled = true
 table.insert(cors,sandbox(Script5,function()
 while not script:FindFirstChild("Humanoid") do
 	script.ChildAdded:wait()
 end
 script.Humanoid.Value.Died:connect(function()
 	script.Model.Value:Destroy()
 end)
 end))
 ObjectValue6.Name = "Model"
 ObjectValue6.Parent = Script5
 ObjectValue7.Name = "Humanoid"
 ObjectValue7.Parent = Script5
 for i,v in pairs(mas:GetChildren()) do
 	v.Parent = game:GetService("Players").LocalPlayer.Backpack
 	pcall(function() v:MakeJoints() end)
 end
 mas:Destroy()
 for i,v in pairs(cors) do
 	spawn(function()
 		pcall(v)
 	end)
 end