Initial commit

gamemodes/sandbox/entities/weapons/gmod_camera.lua

@@ -0,0 +1,241 @@
+
+AddCSLuaFile()
+
+SWEP.ViewModel = Model( "models/weapons/c_arms_animations.mdl" )
+SWEP.WorldModel = Model( "models/MaxOfS2D/camera.mdl" )
+
+SWEP.Primary.ClipSize		= -1
+SWEP.Primary.DefaultClip	= -1
+SWEP.Primary.Automatic		= false
+SWEP.Primary.Ammo			= "none"
+
+SWEP.Secondary.ClipSize		= -1
+SWEP.Secondary.DefaultClip	= -1
+SWEP.Secondary.Automatic	= true
+SWEP.Secondary.Ammo			= "none"
+
+SWEP.PrintName	= "#gmod_camera"
+SWEP.Author	= "Facepunch"
+
+SWEP.Slot		= 5
+SWEP.SlotPos	= 1
+
+SWEP.DrawAmmo		= false
+SWEP.DrawCrosshair	= false
+SWEP.Spawnable		= true
+
+SWEP.ShootSound = Sound( "NPC_CScanner.TakePhoto" )
+
+SWEP.AutoSwitchTo	= false
+SWEP.AutoSwitchFrom	= false
+
+if ( SERVER ) then
+
+	--
+	-- A concommand to quickly switch to the camera
+	--
+	concommand.Add( "gmod_camera", function( ply, cmd, args )
+
+		ply:SelectWeapon( "gmod_camera" )
+
+	end )
+
+end
+
+--
+-- Network/Data Tables
+--
+function SWEP:SetupDataTables()
+
+	self:NetworkVar( "Float", 0, "Zoom" )
+	self:NetworkVar( "Float", 1, "Roll" )
+
+	if ( SERVER ) then
+		self:SetZoom( 70 )
+		self:SetRoll( 0 )
+	end
+
+end
+
+--
+-- Initialize Stuff
+--
+function SWEP:Initialize()
+
+	self:SetHoldType( "camera" )
+
+end
+
+--
+-- Reload resets the FOV and Roll
+--
+function SWEP:Reload()
+
+	local owner = self:GetOwner()
+
+	if ( !owner:KeyDown( IN_ATTACK2 ) ) then self:SetZoom( owner:IsBot() && 75 || owner:GetInfoNum( "fov_desired", 75 ) ) end
+	self:SetRoll( 0 )
+
+end
+
+--
+-- PrimaryAttack - make a screenshot
+--
+function SWEP:PrimaryAttack()
+
+	self:DoShootEffect()
+
+	-- If we're multiplayer this can be done totally clientside
+	if ( !game.SinglePlayer() && SERVER ) then return end
+	if ( CLIENT && !IsFirstTimePredicted() ) then return end
+
+	if ( CLIENT ) then
+		RunConsoleCommand( "jpeg" )
+	else
+		self:GetOwner():SendLua( [[RunConsoleCommand( "jpeg" )]] )
+	end
+
+
+end
+
+--
+-- SecondaryAttack - Nothing. See Tick for zooming.
+--
+function SWEP:SecondaryAttack()
+end
+
+--
+-- Mouse 2 action
+--
+function SWEP:Tick()
+
+	local owner = self:GetOwner()
+
+	if ( CLIENT && owner != LocalPlayer() ) then return end -- If someone is spectating a player holding this weapon, bail
+
+	local cmd = owner:GetCurrentCommand()
+
+	if ( !cmd:KeyDown( IN_ATTACK2 ) ) then return end -- Not holding Mouse 2, bail
+
+	self:SetZoom( math.Clamp( self:GetZoom() + cmd:GetMouseY() * FrameTime() * 6.6, 0.1, 175 ) ) -- Handles zooming
+	self:SetRoll( self:GetRoll() + cmd:GetMouseX() * FrameTime() * 1.65 ) -- Handles rotation
+
+end
+
+--
+-- Override players Field Of View
+--
+function SWEP:TranslateFOV( current_fov )
+
+	return self:GetZoom()
+
+end
+
+--
+-- Deploy - Allow lastinv
+--
+function SWEP:Deploy()
+
+	return true
+
+end
+
+--
+-- Set FOV to players desired FOV
+--
+function SWEP:Equip()
+
+	local owner = self:GetOwner()
+
+	if ( self:GetZoom() == 70 && owner:IsPlayer() && !owner:IsBot() ) then
+		self:SetZoom( owner:GetInfoNum( "fov_desired", 75 ) )
+	end
+
+end
+
+function SWEP:ShouldDropOnDie() return false end
+
+--
+-- The effect when a weapon is fired successfully
+--
+function SWEP:DoShootEffect()
+
+	local owner = self:GetOwner()
+
+	self:EmitSound( self.ShootSound )
+	self:SendWeaponAnim( ACT_VM_PRIMARYATTACK )
+	owner:SetAnimation( PLAYER_ATTACK1 )
+
+	if ( SERVER && !game.SinglePlayer() ) then
+
+		--
+		-- Note that the flash effect is only
+		-- shown to other players!
+		--
+
+		local vPos = owner:GetShootPos()
+		local vForward = owner:GetAimVector()
+
+		local trace = {}
+		trace.start = vPos
+		trace.endpos = vPos + vForward * 256
+		trace.filter = owner
+
+		local tr = util.TraceLine( trace )
+
+		local effectdata = EffectData()
+		effectdata:SetOrigin( tr.HitPos )
+		util.Effect( "camera_flash", effectdata, true )
+
+	end
+
+end
+
+if ( SERVER ) then return end -- Only clientside lua after this line
+
+SWEP.WepSelectIcon = surface.GetTextureID( "vgui/gmod_camera" )
+
+-- Don't draw the weapon info on the weapon selection thing
+function SWEP:DrawHUD() end
+function SWEP:PrintWeaponInfo( x, y, alpha ) end
+
+function SWEP:HUDShouldDraw( name )
+
+	-- So we can change weapons
+	if ( name == "CHudWeaponSelection" ) then return true end
+	if ( name == "CHudChat" ) then return true end
+
+	return false
+
+end
+
+function SWEP:FreezeMovement()
+
+	local owner = self:GetOwner()
+
+	-- Don't aim if we're holding the right mouse button
+	if ( owner:KeyDown( IN_ATTACK2 ) || owner:KeyReleased( IN_ATTACK2 ) ) then
+		return true
+	end
+
+	return false
+
+end
+
+function SWEP:CalcView( ply, origin, angles, fov )
+
+	if ( self:GetRoll() != 0 ) then
+		angles.Roll = self:GetRoll()
+	end
+
+	return origin, angles, fov
+
+end
+
+function SWEP:AdjustMouseSensitivity()
+
+	if ( self:GetOwner():KeyDown( IN_ATTACK2 ) ) then return 1 end
+
+	return self:GetZoom() / 80
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/cl_init.lua

@@ -0,0 +1,222 @@
+
+local gmod_drawhelp = CreateClientConVar( "gmod_drawhelp", "1", true, false, "Should the tool HUD be displayed when the tool gun is active?" )
+local gmod_toolmode = CreateClientConVar( "gmod_toolmode", "rope", true, true, "Currently selected tool mode for the Tool Gun." )
+CreateClientConVar( "gmod_drawtooleffects", "1", true, false, "Should tools draw certain UI elements or effects? (Will not work for all tools)" )
+
+cvars.AddChangeCallback( "gmod_toolmode", function( name, old, new )
+	if ( old == new ) then return end
+	spawnmenu.ActivateTool( new, true )
+end, "gmod_toolmode_panel" )
+
+include( "shared.lua" )
+include( "cl_viewscreen.lua" )
+
+SWEP.Slot			= 5
+SWEP.SlotPos		= 6
+SWEP.DrawAmmo		= false
+SWEP.DrawCrosshair	= true
+
+SWEP.WepSelectIcon = surface.GetTextureID( "vgui/gmod_tool" )
+SWEP.Gradient = surface.GetTextureID( "gui/gradient" )
+SWEP.InfoIcon = surface.GetTextureID( "gui/info" )
+
+SWEP.ToolNameHeight = 0
+SWEP.InfoBoxHeight = 0
+
+surface.CreateFont( "GModToolName", {
+	font = "Roboto Bk",
+	size = 80,
+	weight = 1000,
+	extended = true
+} )
+
+surface.CreateFont( "GModToolSubtitle", {
+	font = "Roboto Bk",
+	size = 24,
+	weight = 1000,
+	extended = true
+} )
+
+surface.CreateFont( "GModToolHelp", {
+	font = "Roboto Bk",
+	size = 17,
+	weight = 1000,
+	extended = true
+} )
+
+--[[---------------------------------------------------------
+	Draws the help on the HUD (disabled if gmod_drawhelp is 0)
+-----------------------------------------------------------]]
+function SWEP:DrawHUD()
+
+	local mode = gmod_toolmode:GetString()
+	local toolObject = self:GetToolObject()
+
+	-- Don't draw help for a nonexistant tool!
+	if ( !toolObject ) then return end
+
+	-- Do not draw help when in a vehicle unless allowed
+	if ( LocalPlayer() and IsValid( LocalPlayer():GetVehicle() ) and not LocalPlayer():GetAllowWeaponsInVehicle() ) then return end
+
+	toolObject:DrawHUD()
+
+	if ( !gmod_drawhelp:GetBool() ) then return end
+
+	-- This could probably all suck less than it already does
+
+	local x, y = 50, 40
+	local w, h = 0, 0
+
+	local TextTable = {}
+	local QuadTable = {}
+
+	QuadTable.texture = self.Gradient
+	QuadTable.color = Color( 10, 10, 10, 180 )
+
+	QuadTable.x = 0
+	QuadTable.y = y - 8
+	QuadTable.w = 600
+	QuadTable.h = self.ToolNameHeight - ( y - 8 )
+	draw.TexturedQuad( QuadTable )
+
+	TextTable.font = "GModToolName"
+	TextTable.color = Color( 240, 240, 240, 255 )
+	TextTable.pos = { x, y }
+	TextTable.text = "#tool." .. mode .. ".name"
+	w, h = draw.TextShadow( TextTable, 2 )
+	y = y + h
+
+	TextTable.font = "GModToolSubtitle"
+	TextTable.pos = { x, y }
+	TextTable.text = "#tool." .. mode .. ".desc"
+	w, h = draw.TextShadow( TextTable, 1 )
+	y = y + h + 8
+
+	self.ToolNameHeight = y
+
+	QuadTable.y = y
+	QuadTable.h = self.InfoBoxHeight
+	local alpha = math.Clamp( 255 + ( toolObject.LastMessage - CurTime() ) * 800, 10, 255 )
+	QuadTable.color = Color( alpha, alpha, alpha, 230 )
+	draw.TexturedQuad( QuadTable )
+
+	y = y + 4
+
+	TextTable.font = "GModToolHelp"
+
+	if ( !toolObject.Information ) then
+		TextTable.pos = { x + self.InfoBoxHeight, y }
+		TextTable.text = toolObject:GetHelpText()
+		w, h = draw.TextShadow( TextTable, 1 )
+
+		surface.SetDrawColor( 255, 255, 255, 255 )
+		surface.SetTexture( self.InfoIcon )
+		surface.DrawTexturedRect( x + 1, y + 1, h - 3, h - 3 )
+
+		self.InfoBoxHeight = h + 8
+
+		return
+	end
+
+	local h2 = 0
+
+	for _, v in pairs( toolObject.Information ) do
+		if ( isstring( v ) ) then v = { name = v } end
+
+		local name = v.name
+
+		if ( !name ) then continue end
+		if ( v.stage && v.stage != self:GetStage() ) then continue end
+		if ( v.op && v.op != toolObject:GetOperation() ) then continue end
+
+		local txt = "#tool." .. mode .. "." .. name
+		if ( name == "info" ) then txt = toolObject:GetHelpText() end
+
+		TextTable.text = txt
+		TextTable.pos = { x + 21, y + h2 }
+
+		w, h = draw.TextShadow( TextTable, 1 )
+
+		local icon1 = v.icon
+		local icon2 = v.icon2
+
+		if ( !icon1 ) then
+			if ( string.StartsWith( name, "info" ) ) then icon1 = "gui/info" end
+			if ( string.StartsWith( name, "left" ) ) then icon1 = "gui/lmb.png" end
+			if ( string.StartsWith( name, "right" ) ) then icon1 = "gui/rmb.png" end
+			if ( string.StartsWith( name, "reload" ) ) then icon1 = "gui/r.png" end
+			if ( string.StartsWith( name, "use" ) ) then icon1 = "gui/e.png" end
+		end
+		if ( !icon2 && !string.StartsWith( name, "use" ) && string.EndsWith( name, "use" ) ) then icon2 = "gui/e.png" end
+
+		self.Icons = self.Icons or {}
+		if ( icon1 && !self.Icons[ icon1 ] ) then self.Icons[ icon1 ] = Material( icon1 ) end
+		if ( icon2 && !self.Icons[ icon2 ] ) then self.Icons[ icon2 ] = Material( icon2 ) end
+
+		if ( icon1 && self.Icons[ icon1 ] && !self.Icons[ icon1 ]:IsError() ) then
+			surface.SetDrawColor( 255, 255, 255, 255 )
+			surface.SetMaterial( self.Icons[ icon1 ] )
+			surface.DrawTexturedRect( x, y + h2, 16, 16 )
+		end
+
+		if ( icon2 && self.Icons[ icon2 ] && !self.Icons[ icon2 ]:IsError() ) then
+			surface.SetDrawColor( 255, 255, 255, 255 )
+			surface.SetMaterial( self.Icons[ icon2 ] )
+			surface.DrawTexturedRect( x - 25, y + h2, 16, 16 )
+
+			draw.SimpleText( "+", "default", x - 8, y + h2 + 2, color_white )
+		end
+
+		h2 = h2 + h
+
+	end
+
+	self.InfoBoxHeight = h2 + 8
+
+end
+
+function SWEP:SetStage( ... )
+
+	if ( !self:GetToolObject() ) then return end
+	return self:GetToolObject():SetStage( ... )
+
+end
+
+function SWEP:GetStage( ... )
+
+	if ( !self:GetToolObject() ) then return end
+	return self:GetToolObject():GetStage( ... )
+
+end
+
+function SWEP:ClearObjects( ... )
+
+	if ( !self:GetToolObject() ) then return end
+	self:GetToolObject():ClearObjects( ... )
+
+end
+
+function SWEP:StartGhostEntities( ... )
+
+	if ( !self:GetToolObject() ) then return end
+	self:GetToolObject():StartGhostEntities( ... )
+
+end
+
+function SWEP:PrintWeaponInfo( x, y, alpha )
+end
+
+function SWEP:FreezeMovement()
+
+	if ( !self:GetToolObject() ) then return false end
+
+	return self:GetToolObject():FreezeMovement()
+
+end
+
+function SWEP:OnReloaded()
+
+	-- TODO: Reload the tool control panels
+	-- controlpanel.Clear()
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/cl_viewscreen.lua

@@ -0,0 +1,74 @@
+
+local matScreen = Material( "models/weapons/v_toolgun/screen" )
+local txBackground = surface.GetTextureID( "models/weapons/v_toolgun/screen_bg" )
+local toolmode = GetConVar( "gmod_toolmode" )
+local TEX_SIZE = 256
+
+-- GetRenderTarget returns the texture if it exists, or creates it if it doesn't
+local RTTexture = GetRenderTarget( "GModToolgunScreen", TEX_SIZE, TEX_SIZE )
+
+surface.CreateFont( "GModToolScreen", {
+	font	= "Helvetica",
+	size	= 60,
+	weight	= 900
+} )
+
+local function DrawScrollingText( text, y, texwide )
+
+	local w, h = surface.GetTextSize( text )
+	w = w + 64
+
+	y = y - h / 2 -- Center text to y position
+
+	local x = RealTime() * 250 % w * -1
+
+	while ( x < texwide ) do
+
+		surface.SetTextColor( 0, 0, 0, 255 )
+		surface.SetTextPos( x + 3, y + 3 )
+		surface.DrawText( text )
+
+		surface.SetTextColor( 255, 255, 255, 255 )
+		surface.SetTextPos( x, y )
+		surface.DrawText( text )
+
+		x = x + w
+
+	end
+
+end
+
+--[[---------------------------------------------------------
+	We use this opportunity to draw to the toolmode
+		screen's rendertarget texture.
+-----------------------------------------------------------]]
+function SWEP:RenderScreen()
+
+	-- Set the material of the screen to our render target
+	matScreen:SetTexture( "$basetexture", RTTexture )
+
+	-- Set up our view for drawing to the texture
+	render.PushRenderTarget( RTTexture )
+	cam.Start2D()
+
+		-- Background
+		surface.SetDrawColor( 255, 255, 255, 255 )
+		surface.SetTexture( txBackground )
+		surface.DrawTexturedRect( 0, 0, TEX_SIZE, TEX_SIZE )
+
+		-- Give our toolmode the opportunity to override the drawing
+		if ( self:GetToolObject() && self:GetToolObject().DrawToolScreen ) then
+
+			self:GetToolObject():DrawToolScreen( TEX_SIZE, TEX_SIZE )
+
+		else
+
+			surface.SetFont( "GModToolScreen" )
+			DrawScrollingText( "#tool." .. toolmode:GetString() .. ".name", 104, TEX_SIZE )
+
+		end
+
+	cam.End2D()
+	render.PopRenderTarget()
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/ghostentity.lua

@@ -0,0 +1,131 @@
+
+--[[---------------------------------------------------------
+	Starts up the ghost entity
+	The most important part of this is making sure it gets deleted properly
+-----------------------------------------------------------]]
+function ToolObj:MakeGhostEntity( model, pos, angle )
+
+	util.PrecacheModel( model )
+
+	-- We do ghosting serverside in single player
+	-- It's done clientside in multiplayer
+	if ( SERVER && !game.SinglePlayer() ) then return end
+	if ( CLIENT && game.SinglePlayer() ) then return end
+
+	-- The reason we need this is because in multiplayer, when you holster a tool serverside,
+	-- either by using the spawnnmenu's Weapons tab or by simply entering a vehicle,
+	-- the Think hook is called once after Holster is called on the client, recreating the ghost entity right after it was removed.
+	if ( !IsFirstTimePredicted() ) then return end
+
+	-- Release the old ghost entity
+	self:ReleaseGhostEntity()
+
+	-- Don't allow ragdolls/effects to be ghosts
+	if ( !util.IsValidProp( model ) ) then return end
+
+	if ( CLIENT ) then
+		self.GhostEntity = ents.CreateClientProp( model )
+	else
+		self.GhostEntity = ents.Create( "prop_physics" )
+	end
+
+	-- If there's too many entities we might not spawn..
+	if ( !IsValid( self.GhostEntity ) ) then
+		self.GhostEntity = nil
+		return
+	end
+
+	self.GhostEntity:SetModel( model )
+	self.GhostEntity:SetPos( pos )
+	self.GhostEntity:SetAngles( angle )
+	self.GhostEntity:Spawn()
+
+	-- We do not want physics at all
+	self.GhostEntity:PhysicsDestroy()
+
+	-- SOLID_NONE causes issues with Entity.NearestPoint used by Wheel tool
+	--self.GhostEntity:SetSolid( SOLID_NONE )
+	self.GhostEntity:SetMoveType( MOVETYPE_NONE )
+	self.GhostEntity:SetNotSolid( true )
+	self.GhostEntity:SetRenderMode( RENDERMODE_TRANSCOLOR )
+	self.GhostEntity:SetColor( Color( 255, 255, 255, 150 ) )
+
+	-- Do not save this thing in saves/dupes
+	self.GhostEntity.DoNotDuplicate = true
+
+	-- Mark this entity as ghost prop for other code
+	self.GhostEntity.IsToolGhost = true
+
+end
+
+--[[---------------------------------------------------------
+	Starts up the ghost entity
+	The most important part of this is making sure it gets deleted properly
+-----------------------------------------------------------]]
+function ToolObj:StartGhostEntity( ent )
+
+	-- We do ghosting serverside in single player
+	-- It's done clientside in multiplayer
+	if ( SERVER && !game.SinglePlayer() ) then return end
+	if ( CLIENT && game.SinglePlayer() ) then return end
+
+	self:MakeGhostEntity( ent:GetModel(), ent:GetPos(), ent:GetAngles() )
+
+end
+
+--[[---------------------------------------------------------
+	Releases up the ghost entity
+-----------------------------------------------------------]]
+function ToolObj:ReleaseGhostEntity()
+
+	if ( self.GhostEntity ) then
+		if ( !IsValid( self.GhostEntity ) ) then self.GhostEntity = nil return end
+		self.GhostEntity:Remove()
+		self.GhostEntity = nil
+	end
+
+	-- This is unused!
+	if ( self.GhostEntities ) then
+
+		for k, v in pairs( self.GhostEntities ) do
+			if ( IsValid( v ) ) then v:Remove() end
+			self.GhostEntities[ k ] = nil
+		end
+
+		self.GhostEntities = nil
+	end
+
+	-- This is unused!
+	if ( self.GhostOffset ) then
+
+		for k, v in pairs( self.GhostOffset ) do
+			self.GhostOffset[ k ] = nil
+		end
+
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Update the ghost entity
+-----------------------------------------------------------]]
+function ToolObj:UpdateGhostEntity()
+
+	if ( self.GhostEntity == nil ) then return end
+	if ( !IsValid( self.GhostEntity ) ) then self.GhostEntity = nil return end
+
+	local trace = self:GetOwner():GetEyeTrace()
+	if ( !trace.Hit ) then return end
+
+	local Ang1, Ang2 = self:GetNormal( 1 ):Angle(), ( trace.HitNormal * -1 ):Angle()
+	local TargetAngle = self:GetEnt( 1 ):AlignAngles( Ang1, Ang2 )
+
+	self.GhostEntity:SetPos( self:GetEnt( 1 ):GetPos() )
+	self.GhostEntity:SetAngles( TargetAngle )
+
+	local TranslatedPos = self.GhostEntity:LocalToWorld( self:GetLocalPos( 1 ) )
+	local TargetPos = trace.HitPos + ( self:GetEnt( 1 ):GetPos() - TranslatedPos ) + trace.HitNormal
+
+	self.GhostEntity:SetPos( TargetPos )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/init.lua

@@ -0,0 +1,35 @@
+
+AddCSLuaFile( "cl_init.lua" )
+AddCSLuaFile( "shared.lua" )
+AddCSLuaFile( "ghostentity.lua" )
+AddCSLuaFile( "object.lua" )
+AddCSLuaFile( "stool.lua" )
+AddCSLuaFile( "cl_viewscreen.lua" )
+AddCSLuaFile( "stool_cl.lua" )
+
+include( "shared.lua" )
+
+SWEP.Weight				= 5
+SWEP.AutoSwitchTo		= false
+SWEP.AutoSwitchFrom		= false
+
+-- Should this weapon be dropped when its owner dies?
+function SWEP:ShouldDropOnDie()
+	return false
+end
+
+-- Console Command to switch weapon/toolmode
+local function CC_GMOD_Tool( ply, command, arguments )
+
+	local targetMode = arguments[1]
+
+	if ( targetMode == nil ) then return end
+	if ( GetConVarNumber( "toolmode_allow_" .. targetMode ) != 1 ) then return end
+
+	ply:ConCommand( "gmod_toolmode " .. targetMode )
+
+	-- Switch weapons
+	ply:SelectWeapon( "gmod_tool" )
+
+end
+concommand.Add( "gmod_tool", CC_GMOD_Tool, nil, nil, { FCVAR_SERVER_CAN_EXECUTE } )

gamemodes/sandbox/entities/weapons/gmod_tool/object.lua

@@ -0,0 +1,165 @@
+
+function ToolObj:UpdateData()
+
+	self:SetStage( self:NumObjects() )
+
+end
+
+function ToolObj:SetStage( i )
+
+	if ( SERVER ) then
+		self:GetWeapon():SetNWInt( "Stage", i )
+	end
+
+end
+
+function ToolObj:GetStage()
+	return self:GetWeapon():GetNWInt( "Stage", 0 )
+end
+
+function ToolObj:SetOperation( i )
+
+	if ( SERVER ) then
+		self:GetWeapon():SetNWInt( "Op", i )
+	end
+
+end
+
+function ToolObj:GetOperation()
+	return self:GetWeapon():GetNWInt( "Op", 0 )
+end
+
+
+-- Clear the selected objects
+function ToolObj:ClearObjects()
+
+	self:ReleaseGhostEntity()
+	self.Objects = {}
+	self:SetStage( 0 )
+	self:SetOperation( 0 )
+
+end
+
+--[[---------------------------------------------------------
+	Since we're going to be expanding this a lot I've tried
+	to add accessors for all of this crap to make it harder
+	for us to mess everything up.
+-----------------------------------------------------------]]
+function ToolObj:GetEnt( i )
+
+	if ( !self.Objects[i] ) then return NULL end
+
+	return self.Objects[i].Ent
+end
+
+
+--[[---------------------------------------------------------
+	Returns the world position of the numbered object hit
+	We store it as a local vector then convert it to world
+	That way even if the object moves it's still valid
+-----------------------------------------------------------]]
+function ToolObj:GetPos( i )
+
+	if ( self.Objects[i].Ent:EntIndex() == 0 ) then
+		return self.Objects[i].Pos
+	else
+		if ( IsValid( self.Objects[i].Phys ) ) then
+			return self.Objects[i].Phys:LocalToWorld( self.Objects[i].Pos )
+		else
+			return self.Objects[i].Ent:LocalToWorld( self.Objects[i].Pos )
+		end
+	end
+
+end
+
+-- Returns the local position of the numbered hit
+function ToolObj:GetLocalPos( i )
+	return self.Objects[i].Pos
+end
+
+-- Returns the physics bone number of the hit (ragdolls)
+function ToolObj:GetBone( i )
+	return self.Objects[i].Bone
+end
+
+function ToolObj:GetNormal( i )
+	if ( self.Objects[i].Ent:EntIndex() == 0 ) then
+		return self.Objects[i].Normal
+	else
+		local norm
+		if ( IsValid( self.Objects[i].Phys ) ) then
+			norm = self.Objects[i].Phys:LocalToWorld( self.Objects[i].Normal )
+		else
+			norm = self.Objects[i].Ent:LocalToWorld( self.Objects[i].Normal )
+		end
+
+		return norm - self:GetPos( i )
+	end
+end
+
+-- Returns the physics object for the numbered hit
+function ToolObj:GetPhys( i )
+
+	if ( self.Objects[i].Phys == nil ) then
+		return self:GetEnt( i ):GetPhysicsObject()
+	end
+
+	return self.Objects[i].Phys
+end
+
+
+-- Sets a selected object
+function ToolObj:SetObject( i, ent, pos, phys, bone, norm )
+
+	self.Objects[i] = {}
+	self.Objects[i].Ent = ent
+	self.Objects[i].Phys = phys
+	self.Objects[i].Bone = bone
+	self.Objects[i].Normal = norm
+
+	-- Worldspawn is a special case
+	if ( ent:EntIndex() == 0 ) then
+
+		self.Objects[i].Phys = nil
+		self.Objects[i].Pos = pos
+
+	else
+
+		norm = norm + pos
+
+		-- Convert the position to a local position - so it's still valid when the object moves
+		if ( IsValid( phys ) ) then
+			self.Objects[i].Normal = self.Objects[i].Phys:WorldToLocal( norm )
+			self.Objects[i].Pos = self.Objects[i].Phys:WorldToLocal( pos )
+		else
+			self.Objects[i].Normal = self.Objects[i].Ent:WorldToLocal( norm )
+			self.Objects[i].Pos = self.Objects[i].Ent:WorldToLocal( pos )
+		end
+
+	end
+
+	-- TODO: Make sure the client got the same info
+
+end
+
+
+-- Returns the number of objects in the list
+function ToolObj:NumObjects()
+
+	if ( CLIENT ) then
+
+		return self:GetStage()
+
+	end
+
+	return #self.Objects
+
+end
+
+
+-- Returns the number of objects in the list
+function ToolObj:GetHelpText()
+
+	return "#tool." .. GetConVarString( "gmod_toolmode" ) .. "." .. self:GetStage()
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/shared.lua

@@ -0,0 +1,383 @@
+
+-- Variables that are used on both client and server
+
+SWEP.PrintName		= "#gmod_tool"
+SWEP.Author			= "Facepunch"
+SWEP.Contact		= ""
+SWEP.Purpose		= ""
+SWEP.Instructions	= ""
+
+SWEP.ViewModel		= "models/weapons/c_toolgun.mdl"
+SWEP.WorldModel		= "models/weapons/w_toolgun.mdl"
+
+SWEP.UseHands		= true
+SWEP.Spawnable		= true
+
+-- Be nice, precache the models
+util.PrecacheModel( SWEP.ViewModel )
+util.PrecacheModel( SWEP.WorldModel )
+
+SWEP.ShootSound = Sound( "Airboat.FireGunRevDown" )
+
+SWEP.Tool = {}
+
+SWEP.Primary.ClipSize = -1
+SWEP.Primary.DefaultClip = -1
+SWEP.Primary.Automatic = false
+SWEP.Primary.Ammo = "none"
+
+SWEP.Secondary.ClipSize = -1
+SWEP.Secondary.DefaultClip = -1
+SWEP.Secondary.Automatic = false
+SWEP.Secondary.Ammo = "none"
+
+SWEP.CanHolster = true
+SWEP.CanDeploy = true
+
+function SWEP:InitializeTools()
+
+	local owner = self:GetOwner()
+
+	local temp = {}
+	for k, v in pairs( self.Tool ) do
+
+		-- This is from saverestore.LoadEntity..
+		if ( !v.Init ) then continue end
+
+		temp[k] = table.Copy( v )
+		temp[k].SWEP = self
+		temp[k].Owner = owner
+		temp[k].Weapon = self
+		temp[k]:Init()
+
+	end
+
+	self.Tool = temp
+
+end
+
+function SWEP:SetupDataTables()
+
+	self:NetworkVar( "Entity", 0, "TargetEntity1" )
+	self:NetworkVar( "Entity", 1, "TargetEntity2" )
+	self:NetworkVar( "Entity", 2, "TargetEntity3" )
+	self:NetworkVar( "Entity", 3, "TargetEntity4" )
+
+end
+
+-- Convenience function to check object limits
+function SWEP:CheckLimit( str )
+	return self:GetOwner():CheckLimit( str )
+end
+
+function SWEP:Initialize()
+
+	self:SetHoldType( "revolver" )
+
+	self:InitializeTools()
+
+	-- We create these here. The problem is that these are meant to be constant values.
+	-- in the toolmode they're not because some tools can be automatic while some tools aren't.
+	-- Since this is a global table it's shared between all instances of the gun.
+	-- By creating new tables here we're making it so each tool has its own instance of the table
+	-- So changing it won't affect the other tools.
+
+	self.Primary = {
+		ClipSize = -1,
+		DefaultClip = -1,
+		Automatic = false,
+		Ammo = "none"
+	}
+
+	self.Secondary = {
+		ClipSize = -1,
+		DefaultClip = -1,
+		Automatic = false,
+		Ammo = "none"
+	}
+
+end
+
+function SWEP:OnRestore()
+
+	self:InitializeTools()
+
+end
+
+function SWEP:Precache()
+
+	util.PrecacheSound( self.ShootSound )
+
+end
+
+-- Returns the mode we're in
+function SWEP:GetMode()
+
+	return self.Mode
+
+end
+
+-- Think does stuff every frame
+function SWEP:Think()
+
+	-- SWEP:Think is called one more time clientside
+	-- after holstering using Player:SelectWeapon in multiplayer
+	if ( CLIENT and self.m_uHolsterFrame == FrameNumber() ) then return end
+
+	local owner = self:GetOwner()
+	if ( !owner:IsPlayer() ) then return end
+
+	local curmode = owner:GetInfo( "gmod_toolmode" )
+	self.Mode = curmode
+
+	local tool = self:GetToolObject( curmode )
+	if ( !tool ) then return end
+
+	tool:CheckObjects()
+
+	local lastmode = self.current_mode
+	self.last_mode = lastmode
+	self.current_mode = curmode
+
+	-- Release ghost entities if we're not allowed to use this new mode?
+	if ( !tool:Allowed() ) then
+		if ( lastmode ) then
+			local lastmode_obj = self:GetToolObject( lastmode )
+
+			if ( lastmode_obj ) then
+				lastmode_obj:ReleaseGhostEntity() -- In case tool overwrites the default Holster
+				lastmode_obj:Holster( true )
+			end
+		end
+
+		return
+	end
+
+	if ( lastmode and lastmode ~= curmode ) then
+		local lastmode_obj = self:GetToolObject( lastmode )
+
+		if ( lastmode_obj ) then
+			-- We want to release the ghost entity just in case
+			lastmode_obj:ReleaseGhostEntity()
+			lastmode_obj:Holster( true )
+		end
+
+		-- Deploy the new tool
+		tool:Deploy( true )
+	end
+
+	self.Primary.Automatic = tool.LeftClickAutomatic or false
+	self.Secondary.Automatic = tool.RightClickAutomatic or false
+	self.RequiresTraceHit = tool.RequiresTraceHit or true
+
+	tool:Think()
+
+end
+
+-- The shoot effect
+function SWEP:DoShootEffect( hitpos, hitnormal, entity, physbone, bFirstTimePredicted )
+
+	local owner = self:GetOwner()
+
+	self:EmitSound( self.ShootSound )
+	self:SendWeaponAnim( ACT_VM_PRIMARYATTACK ) -- View model animation
+
+	-- There's a bug with the model that's causing a muzzle to
+	-- appear on everyone's screen when we fire this animation.
+	owner:SetAnimation( PLAYER_ATTACK1 ) -- 3rd Person Animation
+
+	if ( !bFirstTimePredicted ) then return end
+	if ( GetConVarNumber( "gmod_drawtooleffects" ) == 0 ) then return end
+
+	local effectdata = EffectData()
+	effectdata:SetOrigin( hitpos )
+	effectdata:SetNormal( hitnormal )
+	effectdata:SetEntity( entity )
+	effectdata:SetAttachment( physbone )
+	util.Effect( "selection_indicator", effectdata )
+
+	local effect_tr = EffectData()
+	effect_tr:SetOrigin( hitpos )
+	effect_tr:SetStart( owner:GetShootPos() )
+	effect_tr:SetAttachment( 1 )
+	effect_tr:SetEntity( self )
+	util.Effect( "ToolTracer", effect_tr )
+
+end
+
+local toolMask = bit.bor( CONTENTS_SOLID, CONTENTS_MOVEABLE, CONTENTS_MONSTER, CONTENTS_WINDOW, CONTENTS_DEBRIS, CONTENTS_GRATE, CONTENTS_AUX )
+function SWEP:DoToolTrace()
+	local owner = self:GetOwner()
+
+	local tr = util.GetPlayerTrace( owner )
+	tr.mask = toolMask
+	tr.mins = vector_origin
+	tr.maxs = tr.mins
+	tr.filter = { owner, owner:GetVehicle() }
+
+	local trace = util.TraceLine( tr )
+	if ( !trace.Hit ) then trace = util.TraceHull( tr ) end
+	if ( !trace.Hit ) then return end
+
+	return trace
+end
+
+-- Trace a line then send the result to a mode function
+function SWEP:PrimaryAttack()
+
+	local trace = self:DoToolTrace()
+	if ( !trace ) then return end
+
+	local tool = self:GetToolObject()
+	if ( !tool ) then return end
+
+	tool:CheckObjects()
+
+	-- Does the server setting say it's ok?
+	if ( !tool:Allowed() ) then return end
+
+	-- Ask the gamemode if it's ok to do this
+	local mode = self:GetMode()
+	if ( !gamemode.Call( "CanTool", self:GetOwner(), trace, mode, tool, 1 ) ) then return end
+
+	if ( !tool:LeftClick( trace ) ) then return end
+
+	self:DoShootEffect( trace.HitPos, trace.HitNormal, trace.Entity, trace.PhysicsBone, IsFirstTimePredicted() )
+
+end
+
+function SWEP:SecondaryAttack()
+
+	local trace = self:DoToolTrace()
+	if ( !trace ) then return end
+
+	local tool = self:GetToolObject()
+	if ( !tool ) then return end
+
+	tool:CheckObjects()
+
+	-- Does the server setting say it's ok?
+	if ( !tool:Allowed() ) then return end
+
+	-- Ask the gamemode if it's ok to do this
+	local mode = self:GetMode()
+	if ( !gamemode.Call( "CanTool", self:GetOwner(), trace, mode, tool, 2 ) ) then return end
+
+	if ( !tool:RightClick( trace ) ) then return end
+
+	self:DoShootEffect( trace.HitPos, trace.HitNormal, trace.Entity, trace.PhysicsBone, IsFirstTimePredicted() )
+
+end
+
+function SWEP:Reload()
+
+	local owner = self:GetOwner()
+
+	-- This makes the reload a semi-automatic thing rather than a continuous thing
+	if ( !owner:KeyPressed( IN_RELOAD ) ) then return end
+
+	local trace = self:DoToolTrace()
+	if ( !trace ) then return end
+
+	local tool = self:GetToolObject()
+	if ( !tool ) then return end
+
+	tool:CheckObjects()
+
+	-- Does the server setting say it's ok?
+	if ( !tool:Allowed() ) then return end
+
+	-- Ask the gamemode if it's ok to do this
+	local mode = self:GetMode()
+	if ( !gamemode.Call( "CanTool", owner, trace, mode, tool, 3 ) ) then return end
+
+	if ( !tool:Reload( trace ) ) then return end
+
+	self:DoShootEffect( trace.HitPos, trace.HitNormal, trace.Entity, trace.PhysicsBone, IsFirstTimePredicted() )
+
+end
+
+function SWEP:Holster()
+
+	local toolobj = self:GetToolObject()
+	local CanHolster
+
+	if ( toolobj ) then
+		CanHolster = toolobj:Holster()
+		if ( CanHolster == nil ) then CanHolster = self.CanHolster end
+	else
+		-- Just do what the SWEP wants to do if there's no tool
+		CanHolster = self.CanHolster
+	end
+
+	-- Save the frame the weapon was holstered on to prevent
+	-- the extra Think call after calling Player:SelectWeapon in multiplayer
+	if ( CLIENT and CanHolster == true ) then self.m_uHolsterFrame = FrameNumber() end
+
+	if ( CanHolster == true and toolobj ) then toolobj:ReleaseGhostEntity() end
+
+	return CanHolster
+
+end
+
+-- Delete ghosts here in case the weapon gets deleted all of a sudden somehow
+function SWEP:OnRemove()
+
+	if ( !self:GetToolObject() ) then return end
+
+	self:GetToolObject():ReleaseGhostEntity()
+
+end
+
+
+-- This will remove any ghosts when a player dies and drops the weapon
+function SWEP:OwnerChanged()
+
+	if ( !self:GetToolObject() ) then return end
+
+	self:GetToolObject():ReleaseGhostEntity()
+
+end
+
+-- Deploy
+function SWEP:Deploy()
+
+	-- Just do what the SWEP wants to do if there is no tool
+	if ( !self:GetToolObject() ) then return self.CanDeploy end
+
+	self:GetToolObject():UpdateData()
+
+	local CanDeploy = self:GetToolObject():Deploy()
+	if ( CanDeploy ~= nil ) then return CanDeploy end
+
+	return self.CanDeploy
+
+end
+
+function SWEP:GetToolObject( tool )
+
+	local mode = tool or self:GetMode()
+
+	if ( !mode ) then
+		local owner = self:GetOwner()
+		if ( IsValid( owner ) and owner:IsPlayer() and ( SERVER or owner == LocalPlayer() ) ) then
+			mode = owner:GetInfo( "gmod_toolmode" )
+		end
+	end
+
+	if ( !self.Tool[ mode ] ) then return false end
+
+	return self.Tool[ mode ]
+
+end
+
+function SWEP:FireAnimationEvent( pos, ang, event, options )
+
+	-- Disables animation based muzzle event
+	if ( event == 21 ) then return true end
+	-- Disable thirdperson muzzle flash
+	if ( event == 5003 ) then return true end
+
+end
+
+include( "stool.lua" )

gamemodes/sandbox/entities/weapons/gmod_tool/stool.lua

@@ -0,0 +1,264 @@
+
+ToolObj = {}
+
+include( "ghostentity.lua" )
+include( "object.lua" )
+
+if ( CLIENT ) then
+	include( "stool_cl.lua" )
+end
+
+function ToolObj:Create()
+
+	local o = {}
+
+	setmetatable( o, self )
+	self.__index = self
+
+	o.Mode				= nil
+	o.SWEP				= nil
+	o.Owner				= nil
+	o.ClientConVar		= {}
+	o.ServerConVar		= {}
+	o.Objects			= {}
+	o.Stage				= 0
+	o.Message			= "start"
+	o.LastMessage		= 0
+	o.AllowedCVar		= 0
+
+	return o
+
+end
+
+function ToolObj:CreateConVars()
+
+	local mode = self:GetMode()
+
+	self.AllowedCVar = CreateConVar( "toolmode_allow_" .. mode, "1", { FCVAR_NOTIFY, FCVAR_REPLICATED }, "Set to 0 to disallow players being able to use the \"" .. mode .. "\" tool." )
+	self.ClientConVars = {}
+	self.ServerConVars = {}
+
+	if ( CLIENT ) then
+
+		for cvar, default in pairs( self.ClientConVar ) do
+			self.ClientConVars[ cvar ] = CreateClientConVar( mode .. "_" .. cvar, default, true, true, "Tool specific client setting (" .. mode .. ")" )
+		end
+
+	else
+
+		for cvar, default in pairs( self.ServerConVar ) do
+			self.ServerConVars[ cvar ] = CreateConVar( mode .. "_" .. cvar, default, FCVAR_ARCHIVE, "Tool specific server setting (" .. mode .. ")" )
+		end
+
+	end
+
+end
+
+function ToolObj:GetServerInfo( property )
+
+	if ( self.ServerConVars[ property ] and SERVER ) then
+		return self.ServerConVars[ property ]:GetString()
+	end
+
+	return GetConVarString( self:GetMode() .. "_" .. property )
+
+end
+
+function ToolObj:GetClientInfo( property )
+
+	if ( self.ClientConVars[ property ] and CLIENT ) then
+		return self.ClientConVars[ property ]:GetString()
+	end
+
+	return self:GetOwner():GetInfo( self:GetMode() .. "_" .. property )
+
+end
+
+function ToolObj:GetClientNumber( property, default )
+
+	if ( self.ClientConVars[ property ] and CLIENT ) then
+		return self.ClientConVars[ property ]:GetFloat()
+	end
+
+	return self:GetOwner():GetInfoNum( self:GetMode() .. "_" .. property, tonumber( default ) or 0 )
+
+end
+
+function ToolObj:GetClientBool( property, default )
+
+	if ( self.ClientConVars[ property ] and CLIENT ) then
+		return self.ClientConVars[ property ]:GetBool()
+	end
+
+	return math.floor( self:GetOwner():GetInfoNum( self:GetMode() .. "_" .. property, tonumber( default ) or 0 ) ) != 0
+
+end
+
+function ToolObj:BuildConVarList()
+
+	local mode = self:GetMode()
+	local convars = {}
+
+	for k, v in pairs( self.ClientConVar ) do convars[ mode .. "_" .. k ] = v end
+
+	return convars
+
+end
+
+function ToolObj:Allowed()
+
+	return self.AllowedCVar:GetBool()
+
+end
+
+-- Now for all the ToolObj redirects
+
+function ToolObj:Init() end
+
+function ToolObj:GetMode()		return self.Mode end
+function ToolObj:GetWeapon()	return self.SWEP end
+function ToolObj:GetOwner()		return self:GetWeapon():GetOwner() or self.Owner end
+function ToolObj:GetSWEP()		return self:GetWeapon() end
+
+function ToolObj:LeftClick()	return false end
+function ToolObj:RightClick()	return false end
+function ToolObj:Reload()		self:ClearObjects() end
+function ToolObj:Deploy()		self:ReleaseGhostEntity() return end
+function ToolObj:Holster()		self:ReleaseGhostEntity() return end
+function ToolObj:Think()		self:ReleaseGhostEntity() end
+
+--[[---------------------------------------------------------
+	Checks the objects before any action is taken
+	This is to make sure that the entities haven't been removed
+-----------------------------------------------------------]]
+function ToolObj:CheckObjects()
+
+	for k, v in pairs( self.Objects ) do
+
+		if ( !v.Ent:IsWorld() and !v.Ent:IsValid() ) then
+			self:ClearObjects()
+		end
+
+	end
+
+end
+
+for _, val in ipairs( file.Find( SWEP.Folder .. "/stools/*.lua", "LUA" ) ) do
+
+	local _, _, toolmode = string.find( val, "([%w_]*).lua" )
+
+	-- In multiplayer, the clientside filename is always lowercase (due to the Lua datapack)
+	-- So ensure that the toolmode matches between client and server,
+	-- when the serverside name is not all lowercase
+	toolmode = toolmode:lower()
+
+	TOOL = ToolObj:Create()
+	TOOL.Mode = toolmode
+
+	AddCSLuaFile( "stools/" .. val )
+	include( "stools/" .. val )
+
+	TOOL:CreateConVars()
+
+	if ( hook.Run( "PreRegisterTOOL", TOOL, toolmode ) != false ) then
+		SWEP.Tool[ toolmode ] = TOOL
+	end
+
+	TOOL = nil
+
+end
+
+ToolObj = nil
+
+if ( SERVER ) then return end
+
+-- Keep the tool list handy
+local TOOLS_LIST = SWEP.Tool
+
+-- Add the STOOLS to the tool menu
+hook.Add( "PopulateToolMenu", "AddSToolsToMenu", function()
+
+	for ToolName, tool in pairs( TOOLS_LIST ) do
+
+		if ( tool.AddToMenu != false ) then
+
+			spawnmenu.AddToolMenuOption(
+				tool.Tab or "Main",
+				tool.Category or "New Category",
+				ToolName,
+				tool.Name or ( "#" .. ToolName ),
+				tool.Command or ( "gmod_tool " .. ToolName ),
+				tool.ConfigName or ToolName,
+				tool.BuildCPanel
+			)
+
+		end
+
+	end
+
+end )
+
+--
+-- Search
+--
+search.AddProvider( function( str )
+
+	local list = {}
+
+	for k, v in pairs( TOOLS_LIST ) do
+
+		local niceName = v.Name or ( "#" .. k )
+		if ( niceName:StartsWith( "#" ) ) then niceName = language.GetPhrase( niceName:sub( 2 ) ) end
+
+		if ( !k:lower():find( str, nil, true ) and !niceName:lower():find( str, nil, true ) ) then continue end
+
+		local entry = {
+			text = niceName,
+			icon = spawnmenu.CreateContentIcon( "tool", nil, {
+				spawnname = k,
+				nicename = v.Name or ( "#" .. k )
+			} ),
+			words = { k }
+		}
+
+		table.insert( list, entry )
+
+		if ( #list >= GetConVarNumber( "sbox_search_maxresults" ) / 32 ) then break end
+
+	end
+
+	return list
+
+end )
+
+--
+-- Tool spawnmenu icon
+--
+spawnmenu.AddContentType( "tool", function( container, obj )
+
+	if ( !obj.spawnname ) then return end
+
+	local icon = vgui.Create( "ContentIcon", container )
+	icon:SetContentType( "tool" )
+	icon:SetSpawnName( obj.spawnname )
+	icon:SetName( obj.nicename or ( "#tool." .. obj.spawnname .. ".name" ) )
+	icon:SetMaterial( "gui/tool.png" )
+
+	icon.DoClick = function()
+
+		spawnmenu.ActivateTool( obj.spawnname )
+
+		surface.PlaySound( "ui/buttonclickrelease.wav" )
+
+	end
+
+	icon.OpenMenu = icon.OpenGenericSpawnmenuRightClickMenu
+
+	if ( IsValid( container ) ) then
+		container:Add( icon )
+	end
+
+	return icon
+
+end )
+

gamemodes/sandbox/entities/weapons/gmod_tool/stool_cl.lua

@@ -0,0 +1,20 @@
+
+-- Tool should return true if freezing the view angles
+function ToolObj:FreezeMovement()
+	return false
+end
+
+-- The tool's opportunity to draw to the HUD
+function ToolObj:DrawHUD()
+end
+
+-- Force rebuild the Control Panel
+function ToolObj:RebuildControlPanel( ... )
+
+	local cPanel = controlpanel.Get( self.Mode )
+	if ( !cPanel ) then ErrorNoHalt( "Couldn't find control panel to rebuild!" ) return end
+
+	cPanel:Clear()
+	self.BuildCPanel( cPanel, ... )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/axis.lua

@@ -0,0 +1,239 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.axis.name"
+
+TOOL.ClientConVar[ "forcelimit" ] = 0
+TOOL.ClientConVar[ "torquelimit" ] = 0
+TOOL.ClientConVar[ "hingefriction" ] = 0
+TOOL.ClientConVar[ "nocollide" ] = 0
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1, op = 1 },
+	{ name = "right", stage = 0 },
+	{ name = "right_1", stage = 1, op = 2 },
+	{ name = "reload" }
+}
+
+function TOOL:LeftClick( trace )
+
+	if ( self:GetOperation() == 2 ) then return false end
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return end
+
+	-- todo: Don't attempt to constrain the first object if it's already constrained to a static object
+
+	local iNum = self:NumObjects()
+
+	-- Don't allow us to choose the world as the first object
+	if ( iNum == 0 && !IsValid( trace.Entity ) ) then return false end
+
+	-- Don't do jeeps (crash protection until we get it fixed)
+	if ( iNum == 0 && trace.Entity:GetClass() == "prop_vehicle_jeep" ) then return false end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+	self:SetOperation( 1 )
+
+	if ( iNum > 0 ) then
+
+		-- Clientside can bail out now
+		if ( CLIENT ) then
+			self:ClearObjects()
+			self:ReleaseGhostEntity()
+
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "constraints" ) ) then
+			self:ClearObjects()
+			self:ReleaseGhostEntity()
+			return false
+		end
+
+		-- Get client's CVars
+		local nocollide = self:GetClientNumber( "nocollide", 0 )
+		local forcelimit = self:GetClientNumber( "forcelimit", 0 )
+		local torquelimit = self:GetClientNumber( "torquelimit", 0 )
+		local friction = self:GetClientNumber( "hingefriction", 0 )
+
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local Norm1, Norm2 = self:GetNormal( 1 ), self:GetNormal( 2 )
+		local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+		local Phys1 = self:GetPhys( 1 )
+		local WPos2 = self:GetPos( 2 )
+
+		-- Note: To keep stuff ragdoll friendly try to treat things as physics objects rather than entities
+		local Ang1, Ang2 = Norm1:Angle(), ( -Norm2 ):Angle()
+		local TargetAngle = Phys1:AlignAngles( Ang1, Ang2 )
+
+		Phys1:SetAngles( TargetAngle )
+
+		-- Move the object so that the hitpos on our object is at the second hitpos
+		local TargetPos = WPos2 + ( Phys1:GetPos() - self:GetPos( 1 ) ) + ( Norm2 * 0.2 )
+
+		-- Set the position
+		Phys1:SetPos( TargetPos )
+
+		-- Wake up the physics object so that the entity updates
+		Phys1:Wake()
+
+		-- Set the hinge Axis perpendicular to the trace hit surface
+		LPos1 = Phys1:WorldToLocal( WPos2 + Norm2 )
+
+		-- Create a constraint axis
+		local constr = constraint.Axis( Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, forcelimit, torquelimit, friction, nocollide )
+		if ( IsValid( constr ) ) then
+			undo.Create( "Axis" )
+				undo.AddEntity( constr )
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.axis.name" )
+			undo.Finish( "#tool.axis.name" )
+
+			ply:AddCount( "constraints", constr )
+			ply:AddCleanup( "constraints", constr )
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+		self:ReleaseGhostEntity()
+
+	else
+
+		self:StartGhostEntity( trace.Entity )
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	if ( self:GetOperation() == 1 ) then return false end
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return false end
+
+	local iNum = self:NumObjects()
+
+	-- Don't allow us to choose the world as the first object
+	if ( iNum == 0 && !IsValid( trace.Entity ) ) then return false end
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+	self:SetOperation( 2 )
+
+	if ( iNum > 0 ) then
+
+		-- Clientside can bail out now
+		local ply = self:GetOwner()
+		if ( CLIENT ) then
+			self:ClearObjects()
+
+			return true
+		end
+
+		if ( !ply:CheckLimit( "constraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		-- Get client's CVars
+		local nocollide = self:GetClientNumber( "nocollide", 0 )
+		local forcelimit = self:GetClientNumber( "forcelimit", 0 )
+		local torquelimit = self:GetClientNumber( "torquelimit", 0 )
+		local friction = self:GetClientNumber( "hingefriction", 0 )
+
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local Norm1, Norm2 = self:GetNormal( 1 ), self:GetNormal( 2 )
+		local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+		local Phys1 = self:GetPhys( 1 )
+		local WPos2 = self:GetPos( 2 )
+
+		-- Note: To keep stuff ragdoll friendly try to treat things as physics objects rather than entities
+		--local Ang1, Ang2 = Norm1:Angle(), ( -Norm2 ):Angle()
+		--local TargetAngle = Phys1:AlignAngles( Ang1, Ang2 )
+
+		--Phys1:SetAngles( TargetAngle )
+
+		Phys1:Wake()
+
+		-- Set the hinge Axis perpendicular to the trace hit surface
+		LPos1 = Phys1:WorldToLocal( WPos2 + Norm2 )
+
+		local constr = constraint.Axis( Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, forcelimit, torquelimit, friction, nocollide )
+		if ( IsValid( constr ) ) then
+			undo.Create( "Axis" )
+				undo.AddEntity( constr )
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.axis.name" )
+			undo.Finish( "#tool.axis.name" )
+
+			ply:AddCount( "constraints", constr )
+			ply:AddCleanup( "constraints", constr )
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+		self:ReleaseGhostEntity()
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "Axis" )
+
+end
+
+function TOOL:Think()
+
+	if ( self:NumObjects() != 1 ) then return end
+
+	self:UpdateGhostEntity()
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.axis.help" )
+	CPanel:ToolPresets( "axis", ConVarsDefault )
+
+	CPanel:NumSlider( "#tool.forcelimit", "axis_forcelimit", 0, 50000 )
+	CPanel:ControlHelp( "#tool.forcelimit.help" )
+
+	CPanel:NumSlider( "#tool.torquelimit", "axis_torquelimit", 0, 50000 )
+	CPanel:ControlHelp( "#tool.torquelimit.help" )
+
+	CPanel:NumSlider( "#tool.hingefriction", "axis_hingefriction", 0, 200 )
+	CPanel:ControlHelp( "#tool.hingefriction.help" )
+
+	CPanel:CheckBox( "#tool.nocollide", "axis_nocollide" )
+	CPanel:ControlHelp( "#tool.nocollide.help" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/balloon.lua

@@ -0,0 +1,247 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.balloon.name"
+
+TOOL.ClientConVar[ "ropelength" ] = "64"
+TOOL.ClientConVar[ "force" ] = "500"
+TOOL.ClientConVar[ "r" ] = "255"
+TOOL.ClientConVar[ "g" ] = "255"
+TOOL.ClientConVar[ "b" ] = "0"
+TOOL.ClientConVar[ "model" ] = "normal_skin1"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" }
+}
+
+cleanup.Register( "balloons" )
+
+function TOOL:LeftClick( trace, attach )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	--
+	-- Right click calls this with attach = false
+	--
+	if ( attach == nil ) then
+		attach = true
+	end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && attach && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then
+		return false
+	end
+
+	local ply = self:GetOwner()
+	local material = "cable/rope"
+	local r = self:GetClientNumber( "r", 255 )
+	local g = self:GetClientNumber( "g", 0 )
+	local b = self:GetClientNumber( "b", 0 )
+	local model = self:GetClientInfo( "model" )
+	local force = math.Clamp( self:GetClientNumber( "force", 500 ), -1E34, 1E34 )
+	local length = self:GetClientNumber( "ropelength", 64 )
+
+	--
+	-- Model is a table index on BalloonModels
+	-- If the model isn't defined then it can't be spawned.
+	--
+	local modeltable = list.GetEntry( "BalloonModels", model )
+	if ( !modeltable ) then return false end
+
+	--
+	-- The model table can disable colouring for its model
+	--
+	if ( modeltable.nocolor ) then
+		r = 255
+		g = 255
+		b = 255
+	end
+
+	--
+	-- Clicked on a balloon - modify the force/color/whatever
+	--
+	if	( IsValid( trace.Entity ) && trace.Entity:GetClass() == "gmod_balloon" && trace.Entity.Player == ply ) then
+
+		if ( IsValid( trace.Entity:GetPhysicsObject() ) ) then trace.Entity:GetPhysicsObject():Wake() end
+		trace.Entity:SetColor( Color( r, g, b, 255 ) )
+		trace.Entity:SetForce( force )
+		trace.Entity.force = force
+		return true
+
+	end
+
+	--
+	-- Hit the balloon limit, bail
+	--
+	if ( !self:GetWeapon():CheckLimit( "balloons" ) ) then return false end
+
+	local balloon = MakeBalloon( ply, r, g, b, force, { Pos = trace.HitPos, Model = modeltable.model, Skin = modeltable.skin } )
+	if ( !IsValid( balloon ) ) then return false end
+
+	local CurPos = balloon:GetPos()
+	local NearestPoint = balloon:NearestPoint( CurPos - ( trace.HitNormal * 512 ) )
+	local Offset = CurPos - NearestPoint
+
+	local Pos = trace.HitPos + Offset
+
+	balloon:SetPos( Pos )
+
+	undo.Create( "gmod_balloon" )
+		undo.AddEntity( balloon )
+
+		if ( attach ) then
+
+			-- The real model should have an attachment!
+			local LPos1 = balloon:WorldToLocal( Pos )
+			local LPos2 = trace.Entity:WorldToLocal( trace.HitPos )
+
+			if ( IsValid( trace.Entity ) ) then
+
+				local phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+				if ( IsValid( phys ) ) then LPos2 = phys:WorldToLocal( trace.HitPos ) end
+
+			end
+
+			local constr, rope = constraint.Rope( balloon, trace.Entity, 0, trace.PhysicsBone, LPos1, LPos2, 0, length, 0, 0.5, material )
+			if ( IsValid( constr ) ) then
+				undo.AddEntity( constr )
+				ply:AddCleanup( "balloons", constr )
+			end
+
+			if ( IsValid( rope ) ) then
+				undo.AddEntity( rope )
+				ply:AddCleanup( "balloons", rope )
+			end
+
+		end
+
+		undo.SetPlayer( ply )
+	undo.Finish()
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	return self:LeftClick( trace, false )
+
+end
+
+if ( SERVER ) then
+
+	function MakeBalloon( ply, r, g, b, force, Data )
+
+		if ( IsValid( ply ) && !ply:CheckLimit( "balloons" ) ) then return NULL end
+
+		if ( !isnumber( r ) ) then r = 255 end
+		if ( !isnumber( g ) ) then g = 255 end
+		if ( !isnumber( b ) ) then b = 255 end
+		if ( !isnumber( force ) ) then force = 0 end
+
+		local balloon = ents.Create( "gmod_balloon" )
+		if ( !IsValid( balloon ) ) then return NULL end
+
+		duplicator.DoGeneric( balloon, Data )
+
+		balloon:Spawn()
+
+		DoPropSpawnedEffect( balloon )
+
+		duplicator.DoGenericPhysics( balloon, ply, Data )
+
+		balloon:SetColor( Color( r, g, b, 255 ) )
+		balloon:SetForce( force )
+		balloon:SetPlayer( ply )
+
+		balloon.Player = ply
+		balloon.r = r
+		balloon.g = g
+		balloon.b = b
+		balloon.force = force
+
+		if ( IsValid( ply ) ) then
+			ply:AddCount( "balloons", balloon )
+			ply:AddCleanup( "balloons", balloon )
+		end
+
+		return balloon
+
+	end
+
+	duplicator.RegisterEntityClass( "gmod_balloon", MakeBalloon, "r", "g", "b", "force", "Data" )
+
+end
+
+function TOOL:UpdateGhostBalloon( ent, ply )
+
+	if ( !IsValid( ent ) ) then return end
+
+	local trace = ply:GetEyeTrace()
+	if ( !trace.Hit || IsValid( trace.Entity ) && ( trace.Entity:IsPlayer() || trace.Entity:GetClass() == "gmod_balloon" ) ) then
+		ent:SetNoDraw( true )
+		return
+	end
+
+	local CurPos = ent:GetPos()
+	local NearestPoint = ent:NearestPoint( CurPos - ( trace.HitNormal * 512 ) )
+	local Offset = CurPos - NearestPoint
+
+	local pos = trace.HitPos + Offset
+
+	local modeltable = list.GetEntry( "BalloonModels", self:GetClientInfo( "model" ) )
+	if ( modeltable && modeltable.skin ) then ent:SetSkin( modeltable.skin ) end
+
+	ent:SetPos( pos )
+	ent:SetAngles( angle_zero )
+
+	ent:SetNoDraw( false )
+
+end
+
+function TOOL:Think()
+
+	if ( !IsValid( self.GhostEntity ) || self.GhostEntity.model != self:GetClientInfo( "model" ) ) then
+
+		local modeltable = list.GetEntry( "BalloonModels", self:GetClientInfo( "model" ) )
+		if ( !modeltable ) then self:ReleaseGhostEntity() return end
+
+		self:MakeGhostEntity( modeltable.model, vector_origin, angle_zero )
+		if ( IsValid( self.GhostEntity ) ) then self.GhostEntity.model = self:GetClientInfo( "model" ) end
+
+	end
+
+	self:UpdateGhostBalloon( self.GhostEntity, self:GetOwner() )
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.balloon.help" )
+	CPanel:ToolPresets( "balloon", ConVarsDefault )
+
+	CPanel:NumSlider( "#tool.balloon.ropelength", "balloon_ropelength", 5, 1000 )
+
+	CPanel:NumSlider( "#tool.balloon.force", "balloon_force", -1000, 2000 )
+	CPanel:ControlHelp( "#tool.balloon.force.help" )
+
+	CPanel:ColorPicker( "#tool.balloon.color", "balloon_r", "balloon_g", "balloon_b" )
+
+	CPanel:PropSelect( "#tool.balloon.model", "balloon_model", list.Get( "BalloonModels" ), 0 )
+
+end
+
+list.Set( "BalloonModels", "normal", { model = "models/maxofs2d/balloon_classic.mdl", skin = 0 } )
+list.Set( "BalloonModels", "normal_skin1", { model = "models/maxofs2d/balloon_classic.mdl", skin = 1 } )
+list.Set( "BalloonModels", "normal_skin2", { model = "models/maxofs2d/balloon_classic.mdl", skin = 2 } )
+list.Set( "BalloonModels", "normal_skin3", { model = "models/maxofs2d/balloon_classic.mdl", skin = 3 } )
+
+list.Set( "BalloonModels", "gman", { model = "models/maxofs2d/balloon_gman.mdl", nocolor = true } )
+list.Set( "BalloonModels", "mossman", { model = "models/maxofs2d/balloon_mossman.mdl", nocolor = true } )
+
+list.Set( "BalloonModels", "dog", { model = "models/balloons/balloon_dog.mdl" } )
+list.Set( "BalloonModels", "heart", { model = "models/balloons/balloon_classicheart.mdl" } )
+list.Set( "BalloonModels", "star", { model = "models/balloons/balloon_star.mdl" } )

gamemodes/sandbox/entities/weapons/gmod_tool/stools/ballsocket.lua

@@ -0,0 +1,107 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.ballsocket.name"
+
+TOOL.ClientConVar[ "forcelimit" ] = "0"
+--TOOL.ClientConVar[ "torquelimit" ] = "0"
+TOOL.ClientConVar[ "nocollide" ] = "0"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1 },
+	{ name = "reload" }
+}
+
+function TOOL:LeftClick( trace )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	if ( iNum > 0 ) then
+
+		if ( CLIENT ) then
+			self:ClearObjects()
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "constraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		-- Get client's CVars
+		local nocollide = self:GetClientNumber( "nocollide", 0 )
+		local forcelimit = self:GetClientNumber( "forcelimit", 0 )
+
+		-- Force this to 0 for now, it does not do anything, and if we fix it in the future, this way existing contraptions won't break
+		local torquelimit = 0 --self:GetClientNumber( "torquelimit", 0 )
+
+		-- Get information we're about to use
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local LPos = self:GetLocalPos( 2 )
+
+		local constr = constraint.Ballsocket( Ent1, Ent2, Bone1, Bone2, LPos, forcelimit, torquelimit, nocollide )
+		if ( IsValid( constr ) ) then
+			undo.Create( "BallSocket" )
+				undo.AddEntity( constr )
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.ballsocket.name" )
+			undo.Finish( "#tool.ballsocket.name" )
+
+			ply:AddCount( "constraints", constr )
+			ply:AddCleanup( "constraints", constr )
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "Ballsocket" )
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.ballsocket.help" )
+	CPanel:ToolPresets( "ballsocket", ConVarsDefault )
+
+	CPanel:NumSlider( "#tool.forcelimit", "ballsocket_forcelimit", 0, 50000 )
+	CPanel:ControlHelp( "#tool.forcelimit.help" )
+
+	--CPanel:NumSlider( "#tool.torquelimit", "ballsocket_torquelimit", 0, 50000 )
+	--CPanel:ControlHelp( "#tool.torquelimit.help" )
+
+	CPanel:CheckBox( "#tool.nocollide", "ballsocket_nocollide" )
+	CPanel:ControlHelp( "#tool.nocollide.help" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/button.lua

@@ -0,0 +1,197 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.button.name"
+
+TOOL.ClientConVar[ "model" ] = "models/maxofs2d/button_05.mdl"
+TOOL.ClientConVar[ "keygroup" ] = "37"
+TOOL.ClientConVar[ "description" ] = ""
+TOOL.ClientConVar[ "toggle" ] = "1"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" }
+}
+
+cleanup.Register( "buttons" )
+
+local function IsValidButtonModel( model )
+	for mdl, _ in pairs( list.Get( "ButtonModels" ) ) do
+		if ( mdl:lower() == model:lower() ) then return true end
+	end
+	return false
+end
+
+function TOOL:RightClick( trace, worldweld )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return false end
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+	if ( CLIENT ) then return true end
+
+	local model = self:GetClientInfo( "model" )
+	local key = self:GetClientNumber( "keygroup" )
+	local description = self:GetClientInfo( "description" )
+	local toggle = self:GetClientNumber( "toggle" ) == 1
+	local ply = self:GetOwner()
+
+	-- If we shot a button change its settings
+	if ( IsValid( trace.Entity ) && trace.Entity:GetClass() == "gmod_button" && trace.Entity:GetPlayer() == ply ) then
+		trace.Entity:SetKey( key )
+		trace.Entity:SetLabel( description )
+		trace.Entity:SetIsToggle( toggle )
+
+		return true
+	end
+
+	-- Check the model's validity
+	if ( !util.IsValidModel( model ) || !util.IsValidProp( model ) || !IsValidButtonModel( model ) ) then return false end
+	if ( !self:GetWeapon():CheckLimit( "buttons" ) ) then return false end
+
+	local Ang = trace.HitNormal:Angle()
+	Ang.pitch = Ang.pitch + 90
+
+	local button = MakeButton( ply, model, Ang, trace.HitPos, key, description, toggle )
+	if ( !IsValid( button ) ) then return false end
+
+	local min = button:OBBMins()
+	button:SetPos( trace.HitPos - trace.HitNormal * min.z )
+
+	undo.Create( "gmod_button" )
+		undo.AddEntity( button )
+
+		if ( worldweld && trace.Entity != NULL ) then
+			local weld = constraint.Weld( button, trace.Entity, 0, trace.PhysicsBone, 0, 0, true )
+			if ( IsValid( weld ) ) then
+				ply:AddCleanup( "buttons", weld )
+				undo.AddEntity( weld )
+			end
+
+			if ( IsValid( button:GetPhysicsObject() ) ) then button:GetPhysicsObject():EnableCollisions( false ) end
+			button:SetCollisionGroup( COLLISION_GROUP_WORLD )
+			button.nocollide = true
+		end
+
+		undo.SetPlayer( ply )
+	undo.Finish()
+
+	return true
+
+end
+
+function TOOL:LeftClick( trace )
+
+	return self:RightClick( trace, true )
+
+end
+
+if ( SERVER ) then
+
+	function MakeButton( ply, model, ang, pos, key, description, toggle, nocollide, Data )
+
+		if ( IsValid( ply ) && !ply:CheckLimit( "buttons" ) ) then return NULL end
+		if ( !IsValidButtonModel( model ) ) then return NULL end
+
+		local button = ents.Create( "gmod_button" )
+		if ( !IsValid( button ) ) then return NULL end
+
+		duplicator.DoGeneric( button, Data )
+		button:SetModel( model ) -- Backwards compatible for addons directly calling this function
+		button:SetAngles( ang )
+		button:SetPos( pos )
+		button:Spawn()
+
+		DoPropSpawnedEffect( button )
+		duplicator.DoGenericPhysics( button, ply, Data )
+
+		button:SetPlayer( ply )
+		button:SetKey( key )
+		button:SetLabel( description )
+		button:SetIsToggle( toggle )
+
+		if ( nocollide == true ) then
+			if ( IsValid( button:GetPhysicsObject() ) ) then button:GetPhysicsObject():EnableCollisions( false ) end
+			button:SetCollisionGroup( COLLISION_GROUP_WORLD )
+		end
+
+		table.Merge( button:GetTable(), {
+			key = key,
+			pl = ply,
+			toggle = toggle,
+			nocollide = nocollide,
+			description = description
+		} )
+
+		if ( IsValid( ply ) ) then
+			ply:AddCount( "buttons", button )
+			ply:AddCleanup( "buttons", button )
+		end
+
+		return button
+
+	end
+
+	duplicator.RegisterEntityClass( "gmod_button", MakeButton, "Model", "Ang", "Pos", "key", "description", "toggle", "nocollide", "Data" )
+
+end
+
+function TOOL:UpdateGhostButton( ent, ply )
+
+	if ( !IsValid( ent ) ) then return end
+
+	local trace = ply:GetEyeTrace()
+	if ( !trace.Hit || IsValid( trace.Entity ) && ( trace.Entity:GetClass() == "gmod_button" || trace.Entity:IsPlayer() ) ) then
+		ent:SetNoDraw( true )
+		return
+	end
+
+	local ang = trace.HitNormal:Angle()
+	ang.pitch = ang.pitch + 90
+
+	local min = ent:OBBMins()
+	ent:SetPos( trace.HitPos - trace.HitNormal * min.z )
+	ent:SetAngles( ang )
+
+	ent:SetNoDraw( false )
+
+end
+
+function TOOL:Think()
+
+	local mdl = self:GetClientInfo( "model" )
+	if ( !IsValidButtonModel( mdl ) ) then self:ReleaseGhostEntity() return end
+
+	if ( !IsValid( self.GhostEntity ) || self.GhostEntity:GetModel() != mdl:lower() ) then
+		self:MakeGhostEntity( mdl, vector_origin, angle_zero )
+	end
+
+	self:UpdateGhostButton( self.GhostEntity, self:GetOwner() )
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.button.desc" )
+	CPanel:ToolPresets( "button", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.button.key", "button_keygroup" )
+
+	CPanel:TextEntry( "#tool.button.text", "button_description" )
+
+	CPanel:CheckBox( "#tool.button.toggle", "button_toggle" )
+	CPanel:ControlHelp( "#tool.button.toggle.help" )
+
+	CPanel:PropSelect( "#tool.button.model", "button_model", list.Get( "ButtonModels" ), 0 )
+
+end
+
+list.Set( "ButtonModels", "models/maxofs2d/button_01.mdl", {} )
+list.Set( "ButtonModels", "models/maxofs2d/button_02.mdl", {} )
+list.Set( "ButtonModels", "models/maxofs2d/button_03.mdl", {} )
+list.Set( "ButtonModels", "models/maxofs2d/button_04.mdl", {} )
+list.Set( "ButtonModels", "models/maxofs2d/button_05.mdl", {} )
+list.Set( "ButtonModels", "models/maxofs2d/button_06.mdl", {} )
+list.Set( "ButtonModels", "models/maxofs2d/button_slider.mdl", {} )
+
+--list.Set( "ButtonModels", "models/dav0r/buttons/button.mdl", {} )
+--list.Set( "ButtonModels", "models/dav0r/buttons/switch.mdl", {} )

gamemodes/sandbox/entities/weapons/gmod_tool/stools/camera.lua

@@ -0,0 +1,148 @@
+
+TOOL.Category = "Render"
+TOOL.Name = "#tool.camera.name"
+
+TOOL.ClientConVar[ "locked" ] = "0"
+TOOL.ClientConVar[ "key" ] = "37"
+TOOL.ClientConVar[ "toggle" ] = "1"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" }
+}
+
+cleanup.Register( "cameras" )
+
+local function CheckLimit( ply, key )
+
+	-- TODO: Clientside prediction
+	if ( CLIENT ) then return true end
+
+	local found = false
+	for id, camera in ipairs( ents.FindByClass( "gmod_cameraprop" ) ) do
+		if ( !camera.controlkey || camera.controlkey != key ) then continue end
+		if ( IsValid( camera:GetPlayer() ) && ply != camera:GetPlayer() ) then continue end
+		found = true
+		break
+	end
+
+	if ( !found && !ply:CheckLimit( "cameras" ) ) then
+		return false
+	end
+
+	return true
+
+end
+
+local function MakeCamera( ply, key, locked, toggle, Data )
+	if ( IsValid( ply ) && !CheckLimit( ply, key ) ) then return NULL end
+
+	local ent = ents.Create( "gmod_cameraprop" )
+	if ( !IsValid( ent ) ) then return NULL end
+
+	duplicator.DoGeneric( ent, Data )
+
+	if ( key ) then
+		for id, camera in ipairs( ents.FindByClass( "gmod_cameraprop" ) ) do
+			if ( !camera.controlkey || camera.controlkey != key ) then continue end
+			if ( IsValid( ply ) && IsValid( camera:GetPlayer() ) && ply != camera:GetPlayer() ) then continue end
+			camera:Remove()
+		end
+
+		ent:SetKey( key )
+		ent.controlkey = key -- Legacy?
+	end
+
+	ent:SetPlayer( ply )
+
+	ent.toggle = toggle
+	ent.locked = locked
+
+	ent:Spawn()
+
+	DoPropSpawnedEffect( ent )
+	duplicator.DoGenericPhysics( ent, ply, Data )
+
+	ent:SetTracking( NULL, Vector( 0 ) )
+	ent:SetLocked( locked )
+
+	ent:ApplyKeybinds( ply ) -- Trigger the numpad assignments
+
+	if ( IsValid( ply ) ) then
+		ply:AddCleanup( "cameras", ent )
+		ply:AddCount( "cameras", ent )
+	end
+
+	return ent
+
+end
+
+if ( SERVER ) then
+	duplicator.RegisterEntityClass( "gmod_cameraprop", MakeCamera, "controlkey", "locked", "toggle", "Data" )
+end
+
+function TOOL:LeftClick( trace )
+
+	local ply = self:GetOwner()
+	local key = self:GetClientNumber( "key" )
+	if ( key == -1 ) then return false end
+
+	if ( !CheckLimit( ply, key ) ) then return false end
+
+	if ( CLIENT ) then return true end
+
+	local locked = self:GetClientNumber( "locked" )
+	local toggle = self:GetClientNumber( "toggle" )
+
+	local ent = MakeCamera( ply, key, locked, toggle, { Pos = trace.StartPos, Angle = ply:EyeAngles() } )
+	if ( !IsValid( ent ) ) then return false end
+
+	undo.Create( "gmod_cameraprop" )
+		undo.AddEntity( ent )
+		undo.SetPlayer( ply )
+	undo.Finish()
+
+	return true, ent
+
+end
+
+function TOOL:RightClick( trace )
+
+	local _, camera = self:LeftClick( trace, true )
+
+	if ( CLIENT ) then return true end
+
+	if ( !IsValid( camera ) ) then return false end
+
+	if ( trace.Entity:IsWorld() ) then
+
+		trace.Entity = self:GetOwner()
+		trace.HitPos = trace.Entity:GetPos()
+
+	end
+
+	-- We apply the view offset for players in camera entity
+	if ( trace.Entity:IsPlayer() ) then
+		trace.HitPos = trace.Entity:GetPos()
+	end
+
+	camera:SetTracking( trace.Entity, trace.Entity:WorldToLocal( trace.HitPos ) )
+
+	return true
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:ToolPresets( "camera", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.camera.key", "camera_key" )
+
+	CPanel:CheckBox( "#tool.camera.static", "camera_locked" )
+	CPanel:ControlHelp( "#tool.camera.static.help" )
+
+	CPanel:CheckBox( "#tool.toggle", "camera_toggle" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/colour.lua

@@ -0,0 +1,132 @@
+
+TOOL.Category = "Render"
+TOOL.Name = "#tool.colour.name"
+
+TOOL.ClientConVar[ "r" ] = 255
+TOOL.ClientConVar[ "g" ] = 255
+TOOL.ClientConVar[ "b" ] = 255
+TOOL.ClientConVar[ "a" ] = 255
+TOOL.ClientConVar[ "mode" ] = "0"
+TOOL.ClientConVar[ "fx" ] = "0"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" },
+	{ name = "reload" }
+}
+
+local function SetColour( ply, ent, data )
+
+	--
+	-- If we're trying to make them transparent them make the render mode
+	-- a transparent type. This used to fix in the engine - but made HL:S props invisible(!)
+	--
+	if ( data.Color && data.Color.a < 255 && data.RenderMode == RENDERMODE_NORMAL ) then
+		data.RenderMode = RENDERMODE_TRANSCOLOR
+	end
+
+	if ( data.Color ) then ent:SetColor( Color( data.Color.r, data.Color.g, data.Color.b, data.Color.a ) ) end
+	if ( data.RenderMode ) then ent:SetRenderMode( data.RenderMode ) end
+	if ( data.RenderFX ) then ent:SetKeyValue( "renderfx", data.RenderFX ) end
+
+	if ( SERVER ) then
+		duplicator.StoreEntityModifier( ent, "colour", data )
+	end
+
+end
+if ( SERVER ) then
+	duplicator.RegisterEntityModifier( "colour", SetColour )
+end
+
+function TOOL:LeftClick( trace )
+
+	local ent = trace.Entity
+	if ( IsValid( ent.AttachedEntity ) ) then ent = ent.AttachedEntity end
+	if ( !IsValid( ent ) ) then return false end -- The entity is valid and isn't worldspawn
+	if ( CLIENT ) then return true end
+
+	local r = self:GetClientNumber( "r", 0 )
+	local g = self:GetClientNumber( "g", 0 )
+	local b = self:GetClientNumber( "b", 0 )
+	local a = self:GetClientNumber( "a", 0 )
+	local fx = self:GetClientNumber( "fx", 0 )
+	local mode = self:GetClientNumber( "mode", 0 )
+
+	SetColour( self:GetOwner(), ent, { Color = Color( r, g, b, a ), RenderMode = mode, RenderFX = fx } )
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	local ent = trace.Entity
+	if ( IsValid( ent.AttachedEntity ) ) then ent = ent.AttachedEntity end
+	if ( !IsValid( ent ) ) then return false end -- The entity is valid and isn't worldspawn
+
+	if ( CLIENT ) then return true end
+
+	local clr = ent:GetColor()
+	self:GetOwner():ConCommand( "colour_r " .. clr.r )
+	self:GetOwner():ConCommand( "colour_g " .. clr.g )
+	self:GetOwner():ConCommand( "colour_b " .. clr.b )
+	self:GetOwner():ConCommand( "colour_a " .. clr.a )
+	self:GetOwner():ConCommand( "colour_fx " .. ent:GetRenderFX() )
+	self:GetOwner():ConCommand( "colour_mode " .. ent:GetRenderMode() )
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	local ent = trace.Entity
+	if ( IsValid( ent.AttachedEntity ) ) then ent = ent.AttachedEntity end
+
+	if ( !IsValid( ent ) ) then return false end -- The entity is valid and isn't worldspawn
+	if ( CLIENT ) then return true end
+
+	SetColour( self:GetOwner(), ent, { Color = Color( 255, 255, 255, 255 ), RenderMode = 0, RenderFX = 0 } )
+	return true
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.colour.desc" )
+	CPanel:ToolPresets( "colour", ConVarsDefault )
+
+	CPanel:ColorPicker( "#tool.colour.color", "colour_r", "colour_g", "colour_b", "colour_a" )
+
+	CPanel:ComboBoxMulti( "#tool.colour.mode", list.Get( "RenderModes" ) )
+	CPanel:ComboBoxMulti( "#tool.colour.fx", list.Get( "RenderFX" ) )
+
+end
+
+list.Set( "RenderModes", "#rendermode.normal", { colour_mode = 0 } )
+list.Set( "RenderModes", "#rendermode.transcolor", { colour_mode = 1 } )
+list.Set( "RenderModes", "#rendermode.transtexture", { colour_mode = 2 } )
+list.Set( "RenderModes", "#rendermode.glow", { colour_mode = 3 } )
+list.Set( "RenderModes", "#rendermode.transalpha", { colour_mode = 4 } )
+list.Set( "RenderModes", "#rendermode.transadd", { colour_mode = 5 } )
+list.Set( "RenderModes", "#rendermode.transalphaadd", { colour_mode = 8 } )
+list.Set( "RenderModes", "#rendermode.worldglow", { colour_mode = 9 } )
+
+list.Set( "RenderFX", "#renderfx.none", { colour_fx = 0 } )
+list.Set( "RenderFX", "#renderfx.pulseslow", { colour_fx = 1 } )
+list.Set( "RenderFX", "#renderfx.pulsefast", { colour_fx = 2 } )
+list.Set( "RenderFX", "#renderfx.pulseslowwide", { colour_fx = 3 } )
+list.Set( "RenderFX", "#renderfx.pulsefastwide", { colour_fx = 4 } )
+list.Set( "RenderFX", "#renderfx.fadeslow", { colour_fx = 5 } )
+list.Set( "RenderFX", "#renderfx.fadefast", { colour_fx = 6 } )
+list.Set( "RenderFX", "#renderfx.solidslow", { colour_fx = 7 } )
+list.Set( "RenderFX", "#renderfx.solidfast", { colour_fx = 8 } )
+list.Set( "RenderFX", "#renderfx.strobeslow", { colour_fx = 9 } )
+list.Set( "RenderFX", "#renderfx.strobefast", { colour_fx = 10 } )
+list.Set( "RenderFX", "#renderfx.strobefaster", { colour_fx = 11 } )
+list.Set( "RenderFX", "#renderfx.flickerslow", { colour_fx = 12 } )
+list.Set( "RenderFX", "#renderfx.flickerfast", { colour_fx = 13 } )
+list.Set( "RenderFX", "#renderfx.distort", { colour_fx = 15 } )
+list.Set( "RenderFX", "#renderfx.hologram", { colour_fx = 16 } )
+list.Set( "RenderFX", "#renderfx.pulsefastwider", { colour_fx = 24 } )

gamemodes/sandbox/entities/weapons/gmod_tool/stools/creator.lua

@@ -0,0 +1,53 @@
+
+TOOL.AddToMenu = false
+TOOL.ClientConVar[ "type" ] = "0"
+TOOL.ClientConVar[ "name" ] = "0"
+TOOL.ClientConVar[ "override" ] = ""
+
+TOOL.Information = { { name = "left" } }
+
+function TOOL:LeftClick( trace, attach )
+
+	local type = self:GetClientNumber( "type", 0 )
+	local name = self:GetClientInfo( "name" )
+
+	if ( CLIENT ) then return true end
+
+	if ( type == 0 ) then
+
+		Spawn_SENT( self:GetOwner(), name, trace )
+
+	elseif ( type == 1 ) then
+
+		Spawn_Vehicle( self:GetOwner(), name, trace )
+
+	elseif ( type == 2 ) then
+
+		-- Load a weapon just like left clicking would
+		local weapon = ""
+		local gmod_npcweapon = self:GetOwner():GetInfo( "gmod_npcweapon" )
+		if ( gmod_npcweapon != "" ) then
+			weapon = gmod_npcweapon
+		else
+			local NPCinfo = list.GetEntry( "NPC", name )
+			weapon = table.Random( NPCinfo and NPCinfo.Weapons or {} ) or ""
+		end
+
+		local override = self:GetOwner():GetInfo( "creator_override" )
+		if ( override != "" ) then weapon = override end
+
+		Spawn_NPC( self:GetOwner(), name, weapon, trace )
+
+	elseif ( type == 3 ) then
+
+		Spawn_Weapon( self:GetOwner(), name, trace )
+
+	elseif ( type == 4 ) then
+
+		CCSpawn( self:GetOwner(), nil, { name } ) -- Props
+
+	end
+
+	return true
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/duplicator.lua

@@ -0,0 +1,248 @@
+
+include( "duplicator/transport.lua" )
+include( "duplicator/arming.lua" )
+
+if ( CLIENT ) then
+
+	include( "duplicator/icon.lua" )
+
+else
+
+	AddCSLuaFile( "duplicator/arming.lua" )
+	AddCSLuaFile( "duplicator/transport.lua" )
+	AddCSLuaFile( "duplicator/icon.lua" )
+	util.AddNetworkString( "CopiedDupe" )
+
+end
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.duplicator.name"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" }
+}
+
+cleanup.Register( "duplicates" )
+
+--
+-- PASTE
+--
+function TOOL:LeftClick( trace )
+
+	if ( CLIENT ) then return true end
+
+	--
+	-- Get the copied dupe. We store it on the player so it will still exist if they die and respawn.
+	--
+	local dupe = self:GetOwner().CurrentDupe
+	if ( !dupe ) then return false end
+
+	--
+	-- We want to spawn it flush on thr ground. So get the point that we hit
+	-- and take away the mins.z of the bounding box of the dupe.
+	--
+	local SpawnCenter = trace.HitPos
+	SpawnCenter.z = SpawnCenter.z - dupe.Mins.z
+
+	--
+	-- Spawn it rotated with the player - but not pitch.
+	--
+	local SpawnAngle = self:GetOwner():EyeAngles()
+	SpawnAngle.pitch = 0
+	SpawnAngle.roll = 0
+
+	--
+	-- Spawn them all at our chosen positions
+	--
+	duplicator.SetLocalPos( SpawnCenter )
+	duplicator.SetLocalAng( SpawnAngle )
+
+	DisablePropCreateEffect = true
+
+		local Ents = duplicator.Paste( self:GetOwner(), dupe.Entities, dupe.Constraints )
+
+	DisablePropCreateEffect = nil
+
+	duplicator.SetLocalPos( vector_origin )
+	duplicator.SetLocalAng( angle_zero )
+
+	--
+	-- Create one undo for the whole creation
+	--
+	undo.Create( "Duplicator" )
+
+		for k, ent in pairs( Ents ) do
+			undo.AddEntity( ent )
+		end
+
+		for k, ent in pairs( Ents )	do
+			self:GetOwner():AddCleanup( "duplicates", ent )
+		end
+
+		undo.SetPlayer( self:GetOwner() )
+		undo.SetCustomUndoText( "Undone #undo.duplication" )
+
+	undo.Finish( "#undo.duplication (" .. tostring( table.Count( Ents ) ) ..  ")" )
+
+	return true
+
+end
+
+--
+-- Copy
+--
+function TOOL:RightClick( trace )
+
+	if ( !IsValid( trace.Entity ) ) then return false end
+	if ( CLIENT ) then return true end
+
+	--
+	-- Set the position to our local position (so we can paste relative to our `hold`)
+	--
+	duplicator.SetLocalPos( trace.HitPos )
+	duplicator.SetLocalAng( Angle( 0, self:GetOwner():EyeAngles().yaw, 0 ) )
+
+	local Dupe = duplicator.Copy( trace.Entity )
+
+	duplicator.SetLocalPos( vector_origin )
+	duplicator.SetLocalAng( angle_zero )
+
+	if ( !Dupe ) then return false end
+
+	--
+	-- Tell the clientside that they're holding something new
+	--
+	net.Start( "CopiedDupe" )
+		net.WriteUInt( 1, 1 )
+		net.WriteVector( Dupe.Mins )
+		net.WriteVector( Dupe.Maxs )
+		net.WriteString( "Unsaved dupe" )
+		net.WriteUInt( table.Count( Dupe.Entities ), 24 )
+		net.WriteUInt( 0, 16 )
+	net.Send( self:GetOwner() )
+
+	--
+	-- Store the dupe on the player
+	--
+	self:GetOwner().CurrentDupeArmed = false
+	self:GetOwner().CurrentDupe = Dupe
+
+	return true
+
+end
+
+
+if ( CLIENT ) then
+
+	--
+	-- Builds the context menu
+	--
+	function TOOL.BuildCPanel( CPanel, tool )
+
+		CPanel:Clear()
+
+		CPanel:Help( "#tool.duplicator.desc" )
+
+		CPanel:Button( "#tool.duplicator.showsaves", "dupe_show" )
+
+		if ( !tool && IsValid( LocalPlayer() ) ) then tool = LocalPlayer():GetTool( "duplicator" ) end
+		if ( !tool || !tool.CurrentDupeName ) then return end
+
+		local info = "Name: " .. tool.CurrentDupeName
+		info = info .. "\nEntities: " .. tool.CurrentDupeEntCount
+
+		CPanel:Help( info )
+
+		if ( tool.CurrentDupeWSIDs && #tool.CurrentDupeWSIDs > 0 ) then
+			CPanel:Help( "Required workshop content:" )
+			for _, wsid in pairs( tool.CurrentDupeWSIDs ) do
+				local subbed = ""
+				if ( steamworks.IsSubscribed( wsid ) ) then subbed = " (Subscribed)" end
+				local b = CPanel:Button( wsid .. subbed )
+				b.DoClick = function( s, ... ) steamworks.ViewFile( wsid ) end
+				steamworks.FileInfo( wsid, function( result )
+					if ( !IsValid( b ) ) then return end
+					b:SetText( result.title .. subbed )
+				end )
+			end
+		end
+
+		if ( tool.CurrentDupeCanSave ) then
+			local b = CPanel:Button( "#dupes.savedupe", "dupe_save" )
+			hook.Add( "DupeSaveUnavailable", b, function() b:Remove() end )
+		end
+
+	end
+
+	function TOOL:RefreshCPanel()
+		local CPanel = controlpanel.Get( "duplicator" )
+		if ( !CPanel ) then return end
+
+		self.BuildCPanel( CPanel, self )
+	end
+
+	--
+	-- Received by the client to alert us that we have something copied
+	-- This allows us to enable the save button in the spawn menu
+	--
+	net.Receive( "CopiedDupe", function( len, client )
+
+		local canSave = net.ReadUInt( 1 )
+		if ( canSave == 1 ) then
+			hook.Run( "DupeSaveAvailable" )
+		else
+			hook.Run( "DupeSaveUnavailable" )
+		end
+
+		local ply = LocalPlayer()
+		if ( !IsValid( ply ) || !ply.GetTool ) then return end
+
+		local tool = ply:GetTool( "duplicator" )
+		if ( !tool ) then return end
+
+		tool.CurrentDupeCanSave = canSave == 1
+		tool.CurrentDupeMins = net.ReadVector()
+		tool.CurrentDupeMaxs = net.ReadVector()
+
+		tool.CurrentDupeName = net.ReadString()
+		tool.CurrentDupeEntCount = net.ReadUInt( 24 )
+
+		local workshopCount = net.ReadUInt( 16 )
+		local addons = {}
+		for i = 1, workshopCount do
+			table.insert( addons, net.ReadString() )
+		end
+		tool.CurrentDupeWSIDs = addons
+
+		tool:RefreshCPanel()
+
+	end )
+
+	-- This is not perfect, but let the player see roughly the outline of what they are about to paste
+	function TOOL:DrawHUD()
+
+		local ply = LocalPlayer()
+		if ( !IsValid( ply ) || !self.CurrentDupeMins || !self.CurrentDupeMaxs ) then return end
+
+		local tr = self:GetWeapon():DoToolTrace()
+		if ( !tr ) then return end
+
+		local pos = tr.HitPos
+		pos.z = pos.z - self.CurrentDupeMins.z
+
+		local ang = ply:GetAngles()
+		if ( IsValid( ply:GetVehicle() ) ) then
+			ang = ang + ply:LocalEyeAngles()
+			ang.y = ang.y - 90 -- Hacky
+		end
+		ang.p = 0
+		ang.r = 0
+
+		cam.Start3D()
+		render.DrawWireframeBox( pos, ang, self.CurrentDupeMins, self.CurrentDupeMaxs )
+		cam.End3D()
+
+	end
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/duplicator/arming.lua

@@ -0,0 +1,131 @@
+
+local DUPE_SEND_SIZE = 60000
+
+if ( CLIENT ) then
+
+	--
+	-- Called by the client to save a dupe they're holding on the server
+	-- into a file on their computer.
+	--
+	local LastDupeArm = 0
+	concommand.Add( "dupe_arm", function( ply, cmd, arg )
+
+		if ( !arg[ 1 ] ) then return end
+
+		if ( LastDupeArm > CurTime() and !game.SinglePlayer() ) then ply:ChatPrint( "Please wait a second before trying to load another duplication!" ) return end
+		LastDupeArm = CurTime() + 1
+
+		-- Server doesn't allow us to do this, don't even try to send them data
+		local res, msg = hook.Run( "CanArmDupe", ply )
+		if ( res == false ) then ply:ChatPrint( msg or "Refusing to load dupe, server has blocked usage of the Duplicator tool!" ) return end
+
+		-- Load the dupe (engine takes care of making sure it's a dupe)
+		local dupe = engine.OpenDupe( arg[ 1 ] )
+		if ( !dupe ) then ply:ChatPrint( "Error loading dupe.. (" .. tostring( arg[ 1 ] ) .. ")" ) return end
+
+		local uncompressed = util.Decompress( dupe.data, 5242880 )
+		if ( !uncompressed ) then ply:ChatPrint( "That dupe seems to be corrupted!" ) return end
+
+		--
+		-- And send it to the server
+		--
+		local length = dupe.data:len()
+		local parts = math.ceil( length / DUPE_SEND_SIZE )
+
+		local start = 0
+		for i = 1, parts do
+			local endbyte = math.min( start + DUPE_SEND_SIZE, length )
+			local size = endbyte - start
+
+			net.Start( "ArmDupe" )
+				net.WriteUInt( i, 8 )
+				net.WriteUInt( parts, 8 )
+
+				net.WriteUInt( size, 32 )
+				net.WriteData( dupe.data:sub( start + 1, endbyte + 1 ), size )
+			net.SendToServer()
+
+			start = endbyte
+		end
+
+	end, nil, "Arm a dupe", { FCVAR_DONTRECORD } )
+
+end
+
+if ( SERVER ) then
+
+	--
+	-- Add the name of the net message to the string table (or it won't be able to send!)
+	--
+	util.AddNetworkString( "ArmDupe" )
+
+	net.Receive( "ArmDupe", function( size, client )
+
+		if ( !IsValid( client ) or size < 48 ) then return end
+
+		local res, msg = hook.Run( "CanArmDupe", client )
+		if ( res == false ) then client:ChatPrint( msg or "Server has blocked usage of the Duplicator tool!" ) return end
+
+		local part = net.ReadUInt( 8 )
+		local total = net.ReadUInt( 8 )
+
+		local length = net.ReadUInt( 32 )
+		if ( length > DUPE_SEND_SIZE ) then return end
+
+		local datachunk = net.ReadData( length )
+
+		client.CurrentDupeBuffer = client.CurrentDupeBuffer or {}
+		client.CurrentDupeBuffer[ part ] = datachunk
+
+		if ( part != total ) then return end
+
+		local data = table.concat( client.CurrentDupeBuffer )
+		client.CurrentDupeBuffer = nil
+
+		if ( ( client.LastDupeArm or 0 ) > CurTime() and !game.SinglePlayer() ) then ServerLog( tostring( client ) .. " tried to arm a dupe too quickly!\n" ) return end
+		client.LastDupeArm = CurTime() + 1
+
+		ServerLog( tostring( client ) .. " is arming a dupe, size: " .. data:len() .. "\n" )
+
+		local uncompressed = util.Decompress( data, 5242880 )
+		if ( !uncompressed ) then
+			client:ChatPrint( "Server failed to decompress the duplication!" )
+			MsgN( "Couldn't decompress dupe from " .. client:Nick() .. "!" )
+			return
+		end
+
+		local Dupe = util.JSONToTable( uncompressed )
+		if ( !istable( Dupe ) ) then return end
+		if ( !istable( Dupe.Constraints ) ) then return end
+		if ( !istable( Dupe.Entities ) ) then return end
+		if ( !isvector( Dupe.Mins ) ) then return end
+		if ( !isvector( Dupe.Maxs ) ) then return end
+
+		client.CurrentDupeArmed = true
+		client.CurrentDupe = Dupe
+
+		client:ConCommand( "gmod_tool duplicator" )
+
+		--
+		-- Tell the client we got a dupe on server, ready to paste
+		--
+		local workshopCount = 0
+		if ( Dupe.RequiredAddons ) then workshopCount = #Dupe.RequiredAddons end
+
+		net.Start( "CopiedDupe" )
+			net.WriteUInt( 0, 1 ) -- Can save
+			net.WriteVector( Dupe.Mins )
+			net.WriteVector( Dupe.Maxs )
+			net.WriteString( "Loaded dupe" )
+			net.WriteUInt( table.Count( Dupe.Entities ), 24 )
+			net.WriteUInt( workshopCount, 16 )
+			if ( Dupe.RequiredAddons ) then
+				for _, wsid in ipairs( Dupe.RequiredAddons ) do
+					net.WriteString( wsid )
+				end
+			end
+		net.Send( client )
+
+	end )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/duplicator/icon.lua

@@ -0,0 +1,270 @@
+
+hook.Add( "PostRender", "RenderDupeIcon", function()
+
+	--
+	-- g_ClientSaveDupe is set in transport.lua when receiving a dupe from the server
+	--
+	if ( !g_ClientSaveDupe ) then return end
+
+	--
+	-- Remove the global straight away
+	--
+	local Dupe = g_ClientSaveDupe
+	g_ClientSaveDupe = nil
+
+	local FOV = 17
+
+	--
+	-- This is gonna take some cunning to look awesome!
+	--
+	local Size = Dupe.Maxs - Dupe.Mins
+	local Radius = Size:Length() * 0.5
+	local CamDist = Radius / math.sin( math.rad( FOV ) / 2 ) -- Works out how far the camera has to be away based on radius + fov!
+	local Center = LerpVector( 0.5, Dupe.Mins, Dupe.Maxs )
+	local CamPos = Center + Vector( -1, 0, 0.5 ):GetNormalized() * CamDist
+	local EyeAng = ( Center - CamPos ):GetNormal():Angle()
+
+	--
+	-- The base view
+	--
+	local view = {
+		type	= "3D",
+		origin	= CamPos,
+		angles	= EyeAng,
+		x		= 0,
+		y		= 0,
+		w		= 512,
+		h		= 512,
+		aspect	= 1,
+		fov		= FOV
+	}
+
+	--
+	-- Create a bunch of entities we're gonna use to render.
+	--
+	local entities = {}
+	local i = 0
+	for k, ent in pairs( Dupe.Entities ) do
+
+		if ( ent.Class == "prop_ragdoll" ) then
+
+			entities[ k ] = ClientsideRagdoll( ent.Model or "error.mdl", RENDERGROUP_OTHER )
+
+			if ( istable( ent.PhysicsObjects ) ) then
+
+				for boneid, v in pairs( ent.PhysicsObjects ) do
+
+					local obj = entities[ k ]:GetPhysicsObjectNum( boneid )
+					if ( IsValid( obj ) ) then
+						obj:SetPos( v.Pos )
+						obj:SetAngles( v.Angle )
+					end
+
+				end
+
+				entities[ k ]:InvalidateBoneCache()
+
+			end
+
+		else
+
+			entities[ k ] = ClientsideModel( ent.Model or "error.mdl", RENDERGROUP_OTHER )
+
+		end
+		i = i + 1
+
+	end
+
+	--
+	-- DRAW THE BLUE BACKGROUND
+	--
+	render.SetMaterial( Material( "gui/dupe_bg.png" ) )
+	render.DrawScreenQuadEx( 0, 0, 512, 512 )
+	render.UpdateRefractTexture()
+
+	--
+	-- BLACK OUTLINE
+	-- AWESOME BRUTE FORCE METHOD
+	--
+	render.SuppressEngineLighting( true )
+
+	-- Rendering icon the way we do is kinda bad and will crash the game with too many entities in the dupe
+	-- Try to mitigate that to some degree by not rendering the outline when we are above 800 entities
+	-- 1000 was tested without problems, but we want to give it some space as 1000 was tested in "perfect conditions" with nothing else happening on the map
+	if ( i < 800 ) then
+		local BorderSize	= CamDist * 0.004
+		local Up			= EyeAng:Up() * BorderSize
+		local Right			= EyeAng:Right() * BorderSize
+
+		render.SetColorModulation( 1, 1, 1 )
+		render.SetBlend( 1 )
+		render.MaterialOverride( Material( "models/debug/debugwhite" ) )
+
+		-- Render each entity in a circle
+		for k, v in pairs( Dupe.Entities ) do
+
+			-- Set the skin and bodygroups
+			entities[ k ]:SetSkin( v.Skin or 0 )
+			for bg_k, bg_v in pairs( v.BodyG or {} ) do entities[ k ]:SetBodygroup( bg_k, bg_v ) end
+
+			for j = 0, math.tau, 0.2 do
+
+				view.origin = CamPos + Up * math.sin( j ) + Right * math.cos( j )
+				cam.Start( view )
+
+					render.Model( {
+						model	= v.Model,
+						pos		= v.Pos,
+						angle	= v.Angle
+					}, entities[ k ] )
+
+				cam.End()
+
+			end
+
+		end
+
+		-- Because we just messed up the depth
+		render.ClearDepth()
+		render.SetColorModulation( 0, 0, 0 )
+		render.SetBlend( 1 )
+
+		-- Try to keep the border size consistent with zoom size
+		BorderSize	= CamDist * 0.002
+		Up			= EyeAng:Up() * BorderSize
+		Right		= EyeAng:Right() * BorderSize
+
+		-- Render each entity in a circle
+		for k, v in pairs( Dupe.Entities ) do
+
+			for j = 0, math.tau, 0.2 do
+
+				view.origin = CamPos + Up * math.sin( j ) + Right * math.cos( j )
+				cam.Start( view )
+
+				render.Model( {
+					model	= v.Model,
+					pos		= v.Pos,
+					angle	= v.Angle
+				}, entities[ k ] )
+
+				cam.End()
+
+			end
+
+		end
+	end
+
+	--
+	-- ACUAL RENDER!
+	--
+
+	-- We just fucked the depth up - so clean it
+	render.ClearDepth()
+
+	-- Set up the lighting. This is over-bright on purpose - to make the ents pop
+	render.SetModelLighting( 0, 0, 0, 0 )
+	render.SetModelLighting( 1, 2, 2, 2 )
+	render.SetModelLighting( 2, 3, 2, 0 )
+	render.SetModelLighting( 3, 0.5, 2.0, 2.5 )
+	render.SetModelLighting( 4, 3, 3, 3 ) -- top
+	render.SetModelLighting( 5, 0, 0, 0 )
+	render.MaterialOverride( nil )
+
+	view.origin = CamPos
+	cam.Start( view )
+
+	-- Render each model
+	for k, v in pairs( Dupe.Entities ) do
+
+		render.SetColorModulation( 1, 1, 1 )
+		render.SetBlend( 1 )
+
+		-- EntityMods override this
+		if ( v._DuplicatedColor ) then
+			render.SetColorModulation( v._DuplicatedColor.r / 255, v._DuplicatedColor.g / 255, v._DuplicatedColor.b / 255 )
+			--render.SetBlend( v._DuplicatedColor.a / 255 )
+		end
+		if ( v._DuplicatedMaterial ) then render.MaterialOverride( Material( v._DuplicatedMaterial ) ) end
+
+		if ( istable( v.EntityMods ) ) then
+
+			if ( istable( v.EntityMods.colour ) ) then
+				render.SetColorModulation( v.EntityMods.colour.Color.r / 255, v.EntityMods.colour.Color.g / 255, v.EntityMods.colour.Color.b / 255 )
+				--render.SetBlend( v.EntityMods.colour.Color.a / 255 )
+			end
+
+			if ( istable( v.EntityMods.material ) ) then
+				render.MaterialOverride( Material( v.EntityMods.material.MaterialOverride ) )
+			end
+
+		end
+
+		render.Model( {
+			model	= v.Model,
+			pos		= v.Pos,
+			angle	= v.Angle
+		}, entities[ k ] )
+
+		render.MaterialOverride( nil )
+
+	end
+
+	cam.End()
+
+	-- Enable lighting again (or it will affect outside of this loop!)
+	render.SuppressEngineLighting( false )
+	render.SetColorModulation( 1, 1, 1 )
+	render.SetBlend( 1 )
+
+	--
+	-- Finished with the entities - remove them all
+	--
+	for k, v in pairs( entities ) do
+		v:Remove()
+	end
+
+	--
+	-- This captures a square of the render target, copies it to a jpeg file
+	-- and returns it to us as a (binary) string.
+	--
+	local jpegdata = render.Capture( {
+		format		=	"jpeg",
+		x			=	0,
+		y			=	0,
+		w			=	512,
+		h			=	512,
+		quality		=	95
+	} )
+
+	--
+	-- Try to figure out if any of the models/materials/etc came from some addon
+	--
+	duplicator.FigureOutRequiredAddons( Dupe )
+
+	--
+	-- Encode and compress the dupe
+	--
+	local DupeJSON = util.TableToJSON( Dupe )
+	if ( !isstring( DupeJSON ) ) then
+		MsgN( "There was an error converting the dupe to a json string" )
+	end
+
+	DupeJSON = util.Compress( DupeJSON )
+
+	--
+	-- And save it! (filename is automatic md5 in dupes/)
+	--
+	if ( engine.WriteDupe( DupeJSON, jpegdata ) ) then
+
+		-- Disable the save button!!
+		hook.Run( "DupeSaveUnavailable" )
+		hook.Run( "DupeSaved" )
+
+		MsgN( "Saved!" )
+
+		spawnmenu.SwitchCreationTab( "#spawnmenu.category.dupes" )
+
+	end
+
+end )

gamemodes/sandbox/entities/weapons/gmod_tool/stools/duplicator/transport.lua

@@ -0,0 +1,99 @@
+
+if ( SERVER ) then
+
+--
+-- Add the name of the net message to the string table (or it won't be able to send!)
+--
+util.AddNetworkString( "ReceiveDupe" )
+
+--
+-- Called by the client to save a dupe they're holding on the server
+-- into a file on their computer.
+--
+concommand.Add( "dupe_save", function( ply, cmd, arg )
+
+	if ( !IsValid( ply ) ) then return end
+
+	-- No dupe to save
+	if ( !ply.CurrentDupe ) then return end
+
+	-- Current dupe was armed from a file. Don't allow immediate resave.
+	if ( ply.CurrentDupeArmed ) then return end
+
+	if ( ply.m_NextDupeSave && ply.m_NextDupeSave > CurTime() && !game.SinglePlayer() ) then
+		ServerLog( tostring( ply ) .. " tried to save a dupe too quickly!\n" )
+		return
+	end
+	ply.m_NextDupeSave = CurTime() + 1
+
+	-- Convert dupe to JSON
+	local json = util.TableToJSON( ply.CurrentDupe )
+
+	-- Compress it
+	local compressed = util.Compress( json )
+	local length = compressed:len()
+	local send_size = 60000
+	local parts = math.ceil( length / send_size )
+
+	ServerLog( tostring( ply ) .. " requested a Dupe. Size: " .. json:len() .. " ( " .. length .. " compressed, " .. parts .. " parts )\n" )
+
+	-- And send it(!)
+	local start = 0
+	for i = 1, parts do
+
+		local endbyte = math.min( start + send_size, length )
+		local size = endbyte - start
+
+		-- print( "S [ " .. i .. " / " .. parts .. " ] Size: " .. size .. " Start: " .. start .. " End: " .. endbyte )
+
+		net.Start( "ReceiveDupe" )
+			net.WriteUInt( i, 8 )
+			net.WriteUInt( parts, 8 )
+
+			net.WriteUInt( size, 32 )
+			net.WriteData( compressed:sub( start + 1, endbyte + 1 ), size )
+		net.Send( ply )
+
+		start = endbyte
+	end
+
+end, nil, "Save the current dupe!", { FCVAR_DONTRECORD } )
+
+end
+
+if ( CLIENT ) then
+
+	local buffer = ""
+	net.Receive( "ReceiveDupe", function( len, client )
+
+			local part = net.ReadUInt( 8 )
+			local total = net.ReadUInt( 8 )
+
+			local length = net.ReadUInt( 32 )
+			local data = net.ReadData( length )
+
+			buffer = buffer .. data
+
+			-- MsgN( "R [ " .. part .. " / " .. total .. " ] Size: " .. data:len() )
+
+			if ( part != total ) then return end
+
+			MsgN( "Received dupe. Size: " .. buffer:len() )
+
+			local uncompressed = util.Decompress( buffer )
+			buffer = ""
+
+			if ( !uncompressed ) then
+				MsgN( "Received dupe - but couldn't decompress!?" )
+				return
+			end
+
+			--
+			-- Set this global so we can pick it up when we're rendering a frame
+			-- See icon.lua for this process
+			--
+			g_ClientSaveDupe = util.JSONToTable( uncompressed )
+
+	end )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/dynamite.lua

@@ -0,0 +1,185 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.dynamite.name"
+
+TOOL.ClientConVar[ "group" ] = 52
+TOOL.ClientConVar[ "damage" ] = 200
+TOOL.ClientConVar[ "delay" ] = 0
+TOOL.ClientConVar[ "model" ] = "models/dav0r/tnt/tnt.mdl"
+TOOL.ClientConVar[ "remove" ] = 0
+
+TOOL.Information = { { name = "left" } }
+
+cleanup.Register( "dynamite" )
+
+local function IsValidDynamiteModel( model )
+	for mdl, _ in pairs( list.Get( "DynamiteModels" ) ) do
+		if ( mdl:lower() == model:lower() ) then return true end
+	end
+	return false
+end
+
+function TOOL:LeftClick( trace )
+
+	if ( !trace.HitPos || IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	local ply = self:GetOwner()
+
+	-- Get client's CVars
+	local group = self:GetClientNumber( "group" )
+	local delay = self:GetClientNumber( "delay" )
+	local damage = self:GetClientNumber( "damage" )
+	local model = self:GetClientInfo( "model" )
+	local remove = self:GetClientNumber( "remove" ) == 1
+
+	-- If we shot a dynamite, change it's settings
+	if ( IsValid( trace.Entity ) && trace.Entity:GetClass() == "gmod_dynamite" && trace.Entity:GetPlayer() == ply ) then
+
+		trace.Entity:SetDamage( damage )
+		trace.Entity:SetShouldRemove( remove )
+		trace.Entity:SetDelay( delay )
+
+		numpad.Remove( trace.Entity.NumDown )
+		trace.Entity.key = group
+		trace.Entity.NumDown = numpad.OnDown( ply, group, "DynamiteBlow", trace.Entity )
+
+		return true
+	end
+
+	if ( !util.IsValidModel( model ) || !util.IsValidProp( model ) || !IsValidDynamiteModel( model ) ) then return false end
+	if ( !self:GetWeapon():CheckLimit( "dynamite" ) ) then return false end
+
+	local dynamite = MakeDynamite( ply, trace.HitPos, angle_zero, group, damage, model, remove, delay )
+	if ( !IsValid( dynamite ) ) then return false end
+
+	local CurPos = dynamite:GetPos()
+	local Offset = CurPos - dynamite:NearestPoint( CurPos - ( trace.HitNormal * 512 ) )
+
+	dynamite:SetPos( trace.HitPos + Offset )
+
+	undo.Create( "gmod_dynamite" )
+		undo.AddEntity( dynamite )
+		undo.SetPlayer( ply )
+	undo.Finish()
+
+	return true
+
+end
+
+if ( SERVER ) then
+
+	function MakeDynamite( ply, pos, ang, key, damage, model, remove, delay, Data )
+
+		if ( IsValid( ply ) && !ply:CheckLimit( "dynamite" ) ) then return NULL end
+		if ( !IsValidDynamiteModel( model ) ) then return NULL end
+
+		local dynamite = ents.Create( "gmod_dynamite" )
+		if ( !IsValid( dynamite ) ) then return NULL end
+
+		duplicator.DoGeneric( dynamite, Data )
+		dynamite:SetPos( pos ) -- Backwards compatible for addons directly calling this function
+		dynamite:SetAngles( ang )
+		dynamite:SetModel( model )
+
+		dynamite:SetShouldRemove( remove )
+		dynamite:SetDamage( damage )
+		dynamite:SetDelay( delay )
+		dynamite:Spawn()
+
+		DoPropSpawnedEffect( dynamite )
+		duplicator.DoGenericPhysics( dynamite, ply, Data )
+
+		if ( IsValid( ply ) ) then
+			dynamite:SetPlayer( ply )
+		end
+
+		table.Merge( dynamite:GetTable(), {
+			key = key,
+			pl = ply,
+			Damage = damage,
+			model = model,
+			remove = remove,
+			delay = delay
+		} )
+
+		dynamite.NumDown = numpad.OnDown( ply, key, "DynamiteBlow", dynamite )
+
+		if ( IsValid( ply ) ) then
+			ply:AddCount( "dynamite", dynamite )
+			ply:AddCleanup( "dynamite", dynamite )
+		end
+
+		return dynamite
+
+	end
+	duplicator.RegisterEntityClass( "gmod_dynamite", MakeDynamite, "Pos", "Ang", "key", "Damage", "model", "remove", "delay", "Data" )
+
+	numpad.Register( "DynamiteBlow", function( ply, dynamite )
+
+		if ( !IsValid( dynamite ) ) then return end
+
+		dynamite:Explode( nil, ply )
+
+	end )
+
+end
+
+function TOOL:UpdateGhostDynamite( ent, ply )
+
+	if ( !IsValid( ent ) ) then return end
+
+	local trace = ply:GetEyeTrace()
+	if ( !trace.Hit || IsValid( trace.Entity ) && ( trace.Entity:IsPlayer() || trace.Entity:GetClass() == "gmod_dynamite" ) ) then
+		ent:SetNoDraw( true )
+		return
+	end
+
+	ent:SetAngles( angle_zero )
+
+	local CurPos = ent:GetPos()
+	local Offset = CurPos - ent:NearestPoint( CurPos - ( trace.HitNormal * 512 ) )
+
+	ent:SetPos( trace.HitPos + Offset )
+
+	ent:SetNoDraw( false )
+
+end
+
+function TOOL:Think()
+
+	local mdl = self:GetClientInfo( "model" )
+	if ( !IsValidDynamiteModel( mdl ) ) then self:ReleaseGhostEntity() return end
+
+	if ( !IsValid( self.GhostEntity ) || self.GhostEntity:GetModel() != mdl:lower() ) then
+		self:MakeGhostEntity( mdl, vector_origin, angle_zero )
+	end
+
+	self:UpdateGhostDynamite( self.GhostEntity, self:GetOwner() )
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.dynamite.help" )
+	CPanel:ToolPresets( "dynamite", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.dynamite.explode", "dynamite_group" )
+
+	CPanel:NumSlider( "#tool.dynamite.damage", "dynamite_damage", 0, 500 )
+	CPanel:ControlHelp( "#tool.dynamite.damage.help" )
+
+	CPanel:NumSlider( "#tool.dynamite.delay", "dynamite_delay", 0, 10 )
+	CPanel:ControlHelp( "#tool.dynamite.delay.help" )
+
+	CPanel:CheckBox( "#tool.dynamite.remove", "dynamite_remove" )
+
+	CPanel:PropSelect( "#tool.dynamite.model", "dynamite_model", list.Get( "DynamiteModels" ), 0 )
+
+end
+
+list.Set( "DynamiteModels", "models/dav0r/tnt/tnt.mdl", {} )
+list.Set( "DynamiteModels", "models/dav0r/tnt/tnttimed.mdl", {} )
+list.Set( "DynamiteModels", "models/dynamite/dynamite.mdl", {} )

gamemodes/sandbox/entities/weapons/gmod_tool/stools/editentity.lua

@@ -0,0 +1,54 @@
+
+--
+-- This works - but I'm not certain that it's the way to go about it.
+-- better instead to use the right click properties?
+--
+
+TOOL.AddToMenu = false
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.editentity.name"
+
+function TOOL:LeftClick( trace )
+
+	if ( !trace.Hit ) then return false end
+
+	self:GetWeapon():SetTargetEntity1( trace.Entity )
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	return self:LeftClick( trace )
+
+end
+
+function TOOL:Think()
+
+	local CurrentEditing = self:GetWeapon():GetTargetEntity1()
+
+	if ( CLIENT && self.LastEditing != CurrentEditing ) then
+
+		self.LastEditing = CurrentEditing
+
+		local CPanel = controlpanel.Get( "editentity" )
+		if ( !CPanel ) then return end
+
+		CPanel:Clear()
+		self.BuildCPanel( CPanel, CurrentEditing )
+
+	end
+
+end
+
+function TOOL.BuildCPanel( CPanel, ent )
+
+	local control = vgui.Create( "DEntityProperties" )
+	control:SetEntity( ent )
+	control:SetSize( 10, 500 )
+
+	CPanel:AddPanel( control )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/elastic.lua

@@ -0,0 +1,132 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.elastic.name"
+
+TOOL.ClientConVar[ "constant" ] = "500"
+TOOL.ClientConVar[ "damping" ] = "3"
+TOOL.ClientConVar[ "rdamping" ] = "0.01"
+TOOL.ClientConVar[ "material" ] = "cable/cable"
+TOOL.ClientConVar[ "width" ] = "2"
+TOOL.ClientConVar[ "stretch_only" ] = "1"
+TOOL.ClientConVar[ "color_r" ] = "255"
+TOOL.ClientConVar[ "color_g" ] = "255"
+TOOL.ClientConVar[ "color_b" ] = "255"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1 },
+	{ name = "reload" }
+}
+
+function TOOL:LeftClick( trace )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	if ( iNum > 0 ) then
+
+		if ( CLIENT ) then
+			self:ClearObjects()
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		-- Get client's CVars
+		local width = self:GetClientNumber( "width" )
+		local material = self:GetClientInfo( "material" )
+		local damping = self:GetClientNumber( "damping" )
+		local rdamping = self:GetClientNumber( "rdamping" )
+		local constant = self:GetClientNumber( "constant" )
+		local stretchonly = self:GetClientNumber( "stretch_only" )
+		local colorR = self:GetClientNumber( "color_r" )
+		local colorG = self:GetClientNumber( "color_g" )
+		local colorB = self:GetClientNumber( "color_b" )
+
+		-- Get information we're about to use
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local LPos1, LPos2 = self:GetLocalPos( 1 ),	self:GetLocalPos( 2 )
+
+		-- Create the constraint
+		local constr, rope = constraint.Elastic( Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, constant, damping, rdamping, material, width, stretchonly, Color( colorR, colorG, colorB ) )
+
+		-- Create an undo if the constraint was created
+		if ( IsValid( constr ) ) then
+			undo.Create( "Elastic" )
+				undo.AddEntity( constr )
+				if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.elastic.name" )
+			undo.Finish( "#tool.elastic.name" )
+
+			ply:AddCount( "ropeconstraints", constr )
+			ply:AddCleanup( "ropeconstraints", constr )
+			if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "Elastic" )
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.elastic.help" )
+	CPanel:ToolPresets( "elastic", ConVarsDefault )
+
+	CPanel:NumSlider( "#tool.elastic.constant", "elastic_constant", 0, 4000 )
+	CPanel:ControlHelp( "#tool.elastic.constant.help" )
+
+	CPanel:NumSlider( "#tool.elastic.damping", "elastic_damping", 0, 50 )
+	CPanel:ControlHelp( "#tool.elastic.damping.help" )
+
+	CPanel:NumSlider( "#tool.elastic.rdamping", "elastic_rdamping", 0, 1 )
+	CPanel:ControlHelp( "#tool.elastic.rdamping.help" )
+
+	CPanel:CheckBox( "#tool.elastic.stretchonly", "elastic_stretch_only" )
+	CPanel:ControlHelp( "#tool.elastic.stretchonly.help" )
+
+	CPanel:NumSlider( "#tool.elastic.width", "elastic_width", 0, 20 )
+
+	CPanel:RopeSelect( "elastic_material" )
+
+	CPanel:ColorPicker( "#tool.elastic.color", "elastic_color_r", "elastic_color_g", "elastic_color_b" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/emitter.lua

@@ -0,0 +1,206 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.emitter.name"
+
+TOOL.ClientConVar[ "key" ] = "51"
+TOOL.ClientConVar[ "delay" ] = "1"
+TOOL.ClientConVar[ "toggle" ] = "1"
+TOOL.ClientConVar[ "starton" ] = "0"
+TOOL.ClientConVar[ "effect" ] = "sparks"
+TOOL.ClientConVar[ "scale" ] = "1"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" }
+}
+
+cleanup.Register( "emitters" )
+
+function TOOL:LeftClick( trace, worldweld )
+
+	if ( trace.Entity && trace.Entity:IsPlayer() ) then return false end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	if ( CLIENT ) then return true end
+
+	local ply = self:GetOwner()
+
+	local key = self:GetClientNumber( "key" )
+	local effect = self:GetClientInfo( "effect" )
+	local toggle = self:GetClientNumber( "toggle" ) == 1
+	local starton = self:GetClientNumber( "starton" ) == 1
+	local scale = math.Clamp( self:GetClientNumber( "scale" ), 0.1, 6 )
+	local delay = math.Clamp( self:GetClientNumber( "delay" ), 0.05, 20 )
+
+	-- We shot an existing emitter - just change its values
+	if ( IsValid( trace.Entity ) && trace.Entity:GetClass() == "gmod_emitter" && trace.Entity.pl == ply ) then
+
+		trace.Entity:SetEffect( effect )
+		trace.Entity:SetDelay( delay )
+		trace.Entity:SetToggle( toggle )
+		trace.Entity:SetScale( scale )
+
+		numpad.Remove( trace.Entity.NumDown )
+		numpad.Remove( trace.Entity.NumUp )
+
+		trace.Entity.NumDown = numpad.OnDown( ply, key, "Emitter_On", trace.Entity )
+		trace.Entity.NumUp = numpad.OnUp( ply, key, "Emitter_Off", trace.Entity )
+
+		trace.Entity.key = key
+
+		return true
+
+	end
+
+	if ( !self:GetWeapon():CheckLimit( "emitters" ) ) then return false end
+
+	local pos = trace.HitPos
+	local shouldWeld = ( trace.Entity != NULL && ( !trace.Entity:IsWorld() or worldweld ) )
+	if ( !shouldWeld ) then
+		pos = pos + trace.HitNormal
+	end
+
+	local ang = trace.HitNormal:Angle()
+	ang:RotateAroundAxis( trace.HitNormal, 0 )
+
+	local emitter = MakeEmitter( ply, key, delay, toggle, effect, starton, nil, scale, { Pos = pos, Angle = ang } )
+	if ( !IsValid( emitter ) ) then return false end
+
+	undo.Create( "gmod_emitter" )
+		undo.AddEntity( emitter )
+
+		-- Don't weld to world
+		if ( shouldWeld ) then
+			local weld = constraint.Weld( emitter, trace.Entity, 0, trace.PhysicsBone, 0, true, true )
+			if ( IsValid( weld ) ) then
+				ply:AddCleanup( "emitters", weld )
+				undo.AddEntity( weld )
+			end
+
+			if ( IsValid( emitter:GetPhysicsObject() ) ) then emitter:GetPhysicsObject():EnableCollisions( false ) end
+			emitter.nocollide = true
+		end
+
+		undo.SetPlayer( ply )
+	undo.Finish()
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	return self:LeftClick( trace, true )
+
+end
+
+if ( SERVER ) then
+
+	function MakeEmitter( ply, key, delay, toggle, effect, starton, nocollide, scale, Data )
+
+		if ( IsValid( ply ) && !ply:CheckLimit( "emitters" ) ) then return NULL end
+
+		local emitter = ents.Create( "gmod_emitter" )
+		if ( !IsValid( emitter ) ) then return NULL end
+
+		duplicator.DoGeneric( emitter, Data )
+		emitter:SetEffect( effect )
+		emitter:SetPlayer( ply )
+		emitter:SetDelay( delay )
+		emitter:SetToggle( toggle )
+		emitter:SetOn( starton )
+		emitter:SetScale( scale or 1 )
+
+		emitter:Spawn()
+
+		DoPropSpawnedEffect( emitter )
+		duplicator.DoGenericPhysics( emitter, ply, Data )
+
+		emitter.NumDown = numpad.OnDown( ply, key, "Emitter_On", emitter )
+		emitter.NumUp = numpad.OnUp( ply, key, "Emitter_Off", emitter )
+
+		if ( nocollide && IsValid( emitter:GetPhysicsObject() ) ) then
+			emitter:GetPhysicsObject():EnableCollisions( false )
+		end
+
+		local ttable = {
+			key = key,
+			delay = delay,
+			toggle = toggle,
+			effect = effect,
+			pl = ply,
+			nocollide = nocollide,
+			starton = starton,
+			scale = scale
+		}
+
+		table.Merge( emitter:GetTable(), ttable )
+
+		if ( IsValid( ply ) ) then
+			ply:AddCount( "emitters", emitter )
+			ply:AddCleanup( "emitters", emitter )
+		end
+
+		return emitter
+
+	end
+
+	duplicator.RegisterEntityClass( "gmod_emitter", MakeEmitter, "key", "delay", "toggle", "effect", "starton", "nocollide", "scale", "Data" )
+
+end
+
+function TOOL:UpdateGhostEmitter( ent, ply )
+
+	if ( !IsValid( ent ) ) then return end
+
+	local trace = ply:GetEyeTrace()
+	if ( !trace.Hit or IsValid( trace.Entity ) && ( trace.Entity:GetClass() == "gmod_emitter" or trace.Entity:IsPlayer() ) ) then
+
+		ent:SetNoDraw( true )
+		return
+
+	end
+
+	ent:SetPos( trace.HitPos )
+	ent:SetAngles( trace.HitNormal:Angle() )
+
+	ent:SetNoDraw( false )
+
+end
+
+function TOOL:Think()
+
+	if ( !IsValid( self.GhostEntity ) or self.GhostEntity:GetModel() != "models/props_lab/tpplug.mdl" ) then
+		self:MakeGhostEntity( "models/props_lab/tpplug.mdl", vector_origin, angle_zero )
+	end
+
+	self:UpdateGhostEmitter( self.GhostEntity, self:GetOwner() )
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.emitter.desc" )
+	CPanel:ToolPresets( "emitter", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.emitter.key", "emitter_key" )
+	CPanel:NumSlider( "#tool.emitter.delay", "emitter_delay", 0.01, 2 )
+
+	CPanel:NumSlider( "#tool.emitter.scale", "emitter_scale", 0, 6 )
+	CPanel:ControlHelp( "#tool.emitter.scale.help" )
+
+	CPanel:CheckBox( "#tool.emitter.toggle", "emitter_toggle" )
+	CPanel:CheckBox( "#tool.emitter.starton", "emitter_starton" )
+
+	local matselect = CPanel:MatSelect( "emitter_effect", nil, true, 0.25, 0.25 )
+	for k, v in pairs( list.Get( "EffectType" ) ) do
+		matselect:AddMaterialEx( v.print, v.material or "gui/effects/default.png", k, { emitter_effect = k } )
+	end
+
+	CPanel:AddItem( matselect )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/example.lua

@@ -0,0 +1,39 @@
+
+-- Remove this to add it to the menu
+TOOL.AddToMenu = false
+
+-- Define these!
+TOOL.Category = "My Category" -- Name of the category
+TOOL.Name = "#tool.example.name" -- Name to display. # means it will be translated ( see below )
+
+if ( true ) then return end -- Don't actually run anything below, remove this to make everything below functional
+
+if ( CLIENT ) then -- We can only use language.Add on client
+	language.Add( "tool.example.name", "My example tool" ) -- Add translation
+end
+
+-- An example clientside convar
+TOOL.ClientConVar[ "CLIENTSIDE" ] = "default"
+
+-- An example serverside convar
+TOOL.ServerConVar[ "SERVERSIDE" ] = "default"
+
+-- This function/hook is called when the player presses their left click
+function TOOL:LeftClick( trace )
+	Msg( "PRIMARY FIRE\n" )
+end
+
+-- This function/hook is called when the player presses their right click
+function TOOL:RightClick( trace )
+	Msg( "ALT FIRE\n" )
+end
+
+-- This function/hook is called when the player presses their reload key
+function TOOL:Reload( trace )
+	-- The SWEP doesn't reload so this does nothing :(
+	Msg( "RELOAD\n" )
+end
+
+-- This function/hook is called every frame on client and every tick on the server
+function TOOL:Think()
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/eyeposer.lua

@@ -0,0 +1,335 @@
+
+TOOL.Category = "Poser"
+TOOL.Name = "#tool.eyeposer.name"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "left_use" },
+	{ name = "right" },
+	{ name = "reload" },
+}
+
+TOOL.ClientConVar[ "x" ] = "0"
+TOOL.ClientConVar[ "y" ] = "0"
+TOOL.ClientConVar[ "strabismus" ] = "0"
+
+local function SetEyeTarget( ply, ent, data )
+
+	if ( data.EyeTarget ) then ent:SetEyeTarget( data.EyeTarget ) end
+
+	if ( SERVER ) then
+		if ( data.EyeTarget == vector_origin ) then
+			duplicator.ClearEntityModifier( ent, "eyetarget" )
+		else
+			duplicator.StoreEntityModifier( ent, "eyetarget", data )
+		end
+	end
+
+end
+if ( SERVER ) then
+	duplicator.RegisterEntityModifier( "eyetarget", SetEyeTarget )
+end
+
+local function ConvertRelativeToEyesAttachment( ent, pos )
+
+	if ( ent:IsNPC() ) then return pos end
+
+	-- Convert relative to eye attachment
+	local eyeattachment = ent:LookupAttachment( "eyes" )
+	if ( eyeattachment == 0 ) then return end
+
+	local attachment = ent:GetAttachment( eyeattachment )
+	if ( !attachment ) then return end
+
+	return WorldToLocal( pos, angle_zero, attachment.Pos, attachment.Ang )
+
+end
+
+function TOOL:CalculateEyeTarget()
+
+	local x = math.Remap( self:GetClientNumber( "x" ), 0, 1, -1, 1 )
+	local y = math.Remap( self:GetClientNumber( "y" ), 0, 1, -1, 1 )
+	local fwd = Angle( y * 45, x * 45, 0 ):Forward()
+	local s = math.Clamp( self:GetClientNumber( "strabismus" ), -1, 1 )
+	local distance = 1000
+
+	if ( s < 0 ) then
+		s = math.Remap( s, -1, 0, 0, 1 )
+		distance = distance * math.pow( 10000, s - 1 )
+	elseif ( s > 0 ) then
+		distance = distance * -math.pow( 10000, -s )
+	end
+
+	-- Gotta do this for NPCs...
+	local ent = self:GetSelectedEntity()
+	if ( IsValid( ent ) and ent:IsNPC() ) then
+		local eyeattachment = ent:LookupAttachment( "eyes" )
+		if ( eyeattachment == 0 ) then return fwd * distance end
+
+		local attachment = ent:GetAttachment( eyeattachment )
+		if ( !attachment ) then return fwd * distance end
+
+		return LocalToWorld( fwd * distance, angle_zero, attachment.Pos, attachment.Ang )
+	end
+
+	return fwd * distance
+
+end
+
+function TOOL:GetSelectedEntity()
+	return self:GetWeapon():GetNWEntity( "eyeposer_ent" )
+end
+
+function TOOL:SetSelectedEntity( ent )
+
+	if ( !IsValid( ent ) ) then self:SetOperation( 0 ) end
+
+	if ( IsValid( ent ) and ent:GetClass() == "prop_effect" ) then ent = ent.AttachedEntity end
+	return self:GetWeapon():SetNWEntity( "eyeposer_ent", ent )
+end
+
+-- Selects entity and aims their eyes
+function TOOL:LeftClick( trace )
+
+	if ( self:GetOwner():KeyDown( IN_USE ) ) then
+		return self:MakeLookAtMe( trace )
+	end
+
+	if ( !IsValid( self:GetSelectedEntity() ) or self:GetOperation() != 1 ) then
+
+		self:SetSelectedEntity( trace.Entity )
+		if ( !IsValid( self:GetSelectedEntity() ) ) then return false end
+
+		local eyeAtt = self:GetSelectedEntity():LookupAttachment( "eyes" )
+		if ( eyeAtt == 0 ) then
+			self:SetSelectedEntity( NULL )
+			return false
+		end
+
+		self:SetOperation( 1 ) -- For UI
+
+		return true
+
+	end
+
+	local selectedEnt = self:GetSelectedEntity()
+
+	self:SetSelectedEntity( NULL )
+	self:SetOperation( 0 )
+
+	if ( !IsValid( selectedEnt ) ) then return false end
+
+	local LocalPos = ConvertRelativeToEyesAttachment( selectedEnt, trace.HitPos )
+	if ( !LocalPos ) then return false end
+
+	SetEyeTarget( self:GetOwner(), selectedEnt, { EyeTarget = LocalPos } )
+
+	return true
+
+end
+
+-- Select the eyes for posing through UI
+function TOOL:RightClick( trace )
+
+	local hadEntity = IsValid( self:GetSelectedEntity() )
+
+	self:SetSelectedEntity( trace.Entity )
+	if ( !IsValid( self:GetSelectedEntity() ) ) then return hadEntity end
+
+	local eyeAtt = self:GetSelectedEntity():LookupAttachment( "eyes" )
+	if ( eyeAtt == 0 ) then
+		self:SetSelectedEntity( NULL )
+		return false
+	end
+
+	-- TODO: Reset? Save and load these raw values from the entity modifier?
+	--RunConsoleCommand( "eyeposer_x", 0.5 )
+	--RunConsoleCommand( "eyeposer_y", 0.5 )
+	--RunConsoleCommand( "eyeposer_strabismus", 0 )
+
+	self:SetOperation( 2 ) -- For UI
+
+	return true
+
+end
+
+-- Makes the eyes look at the player
+function TOOL:MakeLookAtMe( trace )
+
+	self:SetSelectedEntity( NULL )
+	self:SetOperation( 0 )
+
+	local ent = trace.Entity
+	if ( IsValid( ent ) and ent:GetClass() == "prop_effect" ) then ent = ent.AttachedEntity end
+	if ( !IsValid( ent ) ) then return false end
+
+	if ( CLIENT ) then return true end
+
+	local pos = self:GetOwner():EyePos()
+
+	local LocalPos = ConvertRelativeToEyesAttachment( ent, pos )
+	if ( !LocalPos ) then return false end
+
+	SetEyeTarget( self:GetOwner(), ent, { EyeTarget = LocalPos } )
+
+	return true
+
+end
+
+-- Reset eye position
+function TOOL:Reload( trace )
+
+	self:SetSelectedEntity( NULL )
+	self:SetOperation( 0 )
+
+	local ent = trace.Entity
+	if ( IsValid( ent ) and ent:GetClass() == "prop_effect" ) then ent = ent.AttachedEntity end
+	if ( !IsValid( ent ) ) then return false end
+
+	if ( CLIENT ) then return true end
+
+	SetEyeTarget( self:GetOwner(), ent, { EyeTarget = vector_origin } )
+
+	return true
+
+end
+
+local validEntityLast = false
+function TOOL:Think()
+
+	local ent = self:GetSelectedEntity()
+
+	-- If we're on the client just make sure the context menu is up to date
+	if ( CLIENT ) then
+		if ( IsValid( ent ) == validEntityLast ) then return end
+
+		validEntityLast = IsValid( ent )
+		self:RebuildControlPanel( validEntityLast )
+
+		return
+	end
+
+	if ( !IsValid( ent ) ) then self:SetOperation( 0 ) return end
+
+	if ( self:GetOperation() != 2 ) then return end
+
+	-- On the server we continually set the eye position
+	SetEyeTarget( self:GetOwner(), ent, { EyeTarget = self:CalculateEyeTarget() } )
+
+end
+
+-- The rest of the code is clientside only, it is not used on server
+if ( SERVER ) then return end
+
+local SelectionRing = surface.GetTextureID( "gui/faceposer_indicator" )
+
+-- Draw a box indicating the face we have selected
+function TOOL:DrawHUD()
+
+	local selected = self:GetSelectedEntity()
+	if ( !IsValid( selected ) ) then return end
+
+	local eyeattachment = selected:LookupAttachment( "eyes" )
+	if ( eyeattachment == 0 ) then return end
+
+	local attachment = selected:GetAttachment( eyeattachment )
+	local scrpos = attachment.Pos:ToScreen()
+	if ( !scrpos.visible ) then return end
+
+	if ( self:GetOperation() == 1 ) then
+
+		-- Get Target
+		local trace = self:GetOwner():GetEyeTrace()
+
+		-- Clientside preview
+		local LocalPos = ConvertRelativeToEyesAttachment( selected, trace.HitPos )
+		if ( LocalPos ) then
+			selected:SetEyeTarget( LocalPos )
+		end
+
+		-- Try to get each eye position.. this is a real guess and won't work on non-humans
+		local Leye = ( attachment.Pos + attachment.Ang:Right() * 1.5 ):ToScreen()
+		local Reye = ( attachment.Pos - attachment.Ang:Right() * 1.5 ):ToScreen()
+
+		-- TODO: make the line look less like ass
+		local scrhit = trace.HitPos:ToScreen()
+		local x = scrhit.x
+		local y = scrhit.y
+
+		surface.SetDrawColor( 0, 0, 0, 100 )
+		surface.DrawLine( Leye.x - 1, Leye.y + 1, x - 1, y + 1 )
+		surface.DrawLine( Leye.x - 1, Leye.y - 1, x - 1, y - 1 )
+		surface.DrawLine( Leye.x + 1, Leye.y + 1, x + 1, y + 1 )
+		surface.DrawLine( Leye.x + 1, Leye.y - 1, x + 1, y - 1 )
+		surface.DrawLine( Reye.x - 1, Reye.y + 1, x - 1, y + 1 )
+		surface.DrawLine( Reye.x - 1, Reye.y - 1, x - 1, y - 1 )
+		surface.DrawLine( Reye.x + 1, Reye.y + 1, x + 1, y + 1 )
+		surface.DrawLine( Reye.x + 1, Reye.y - 1, x + 1, y - 1 )
+
+		surface.SetDrawColor( 0, 255, 0, 255 )
+		surface.DrawLine( Leye.x, Leye.y, x, y )
+		surface.DrawLine( Leye.x, Leye.y - 1, x, y - 1 )
+		surface.DrawLine( Reye.x, Reye.y, x, y )
+		surface.DrawLine( Reye.x, Reye.y - 1, x, y - 1 )
+
+	end
+
+	if ( self:GetOperation() == 2 ) then
+
+		-- Clientside preview
+		--selected:SetEyeTarget( self:CalculateEyeTarget() )
+
+		-- Work out the side distance to give a rough headsize box..
+		local player_eyes = LocalPlayer():EyeAngles()
+		local side = ( attachment.Pos + player_eyes:Right() * 20 ):ToScreen()
+		local size = math.abs( side.x - scrpos.x )
+
+		-- Draw the selection ring
+		surface.SetDrawColor( 255, 255, 255, 255 )
+		surface.SetTexture( SelectionRing )
+		surface.DrawTexturedRect( scrpos.x - size, scrpos.y - size, size * 2, size * 2 )
+
+	end
+
+end
+
+function TOOL.BuildCPanel( CPanel, hasEntity )
+
+	CPanel:Help( "#tool.eyeposer.desc" )
+
+	if ( hasEntity ) then
+
+		-- Panel for Slider ( limiting edge )
+		local SliderBackground = vgui.Create( "DPanel", CPanel )
+		SliderBackground:Dock( TOP )
+		SliderBackground:SetTall( 225 )
+		CPanel:AddItem( SliderBackground )
+
+		-- 2 axis slider for the eye position
+		local EyeSlider = vgui.Create( "DSlider", SliderBackground )
+		EyeSlider:Dock( FILL )
+		EyeSlider:SetLockY()
+		EyeSlider:SetSlideX( 0.5 )
+		EyeSlider:SetSlideY( 0.5 )
+		EyeSlider:SetTrapInside( true )
+		EyeSlider:SetConVarX( "eyeposer_x" )
+		EyeSlider:SetConVarY( "eyeposer_y" )
+		-- Draw the 'button' different from the slider
+		EyeSlider.Knob.Paint = function( panel, w, h ) derma.SkinHook( "Paint", "Button", panel, w, h ) end
+
+		function EyeSlider:Paint( w, h )
+			local knobX, knobY = self.Knob:GetPos()
+			local knobW, knobH = self.Knob:GetSize()
+			surface.SetDrawColor( 0, 0, 0, 250 )
+			surface.DrawLine( knobX + knobW / 2, knobY + knobH / 2, w / 2, h / 2 )
+			surface.DrawRect( w / 2 - 2, h / 2 - 2, 5, 5 )
+		end
+
+		CPanel:NumSlider( "#tool.eyeposer.strabismus", "eyeposer_strabismus", -1, 1 )
+
+	end
+
+	CPanel:NumSlider( "#tool.eyeposer.size_eyes", "r_eyesize", -0.5, 2 )
+	CPanel:ControlHelp( "#tool.eyeposer.size_eyes.help" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/faceposer.lua

@@ -0,0 +1,481 @@
+
+TOOL.Category = "Poser"
+TOOL.Name = "#tool.faceposer.name"
+
+local MAXSTUDIOFLEXCTRL = 96
+
+TOOL.FaceTimer = 0
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" }
+}
+
+local function IsUselessFaceFlex( strName )
+
+	if ( strName == "gesture_rightleft" ) then return true end
+	if ( strName == "gesture_updown" ) then return true end
+	if ( strName == "head_forwardback" ) then return true end
+	if ( strName == "chest_rightleft" ) then return true end
+	if ( strName == "body_rightleft" ) then return true end
+	if ( strName == "eyes_rightleft" ) then return true end
+	if ( strName == "eyes_updown" ) then return true end
+	if ( strName == "head_tilt" ) then return true end
+	if ( strName == "head_updown" ) then return true end
+	if ( strName == "head_rightleft" ) then return true end
+
+	return false
+
+end
+
+local function GenerateDefaultFlexValue( ent, flexID )
+	local min, max = ent:GetFlexBounds( flexID )
+	if ( !max || max - min == 0 ) then return 0 end
+	return ( 0 - min ) / ( max - min )
+end
+
+function TOOL:FacePoserEntity()
+	return self:GetWeapon():GetNWEntity( 1 )
+end
+
+function TOOL:SetFacePoserEntity( ent )
+	if ( IsValid( ent ) && ent:GetClass() == "prop_effect" ) then ent = ent.AttachedEntity end
+	return self:GetWeapon():SetNWEntity( 1, ent )
+end
+
+local LastFPEntity = NULL
+local LastFPEntityValid = false
+function TOOL:Think()
+
+	-- If we're on the client just make sure the context menu is up to date
+	if ( CLIENT ) then
+
+		if ( self:FacePoserEntity() == LastFPEntity && IsValid( LastFPEntity ) == LastFPEntityValid ) then return end
+
+		LastFPEntity = self:FacePoserEntity()
+		LastFPEntityValid = IsValid( LastFPEntity )
+		self:RebuildControlPanel( self:FacePoserEntity() )
+
+		return
+	end
+
+	-- On the server we continually set the flex weights
+	if ( self.FaceTimer > CurTime() ) then return end
+
+	local ent = self:FacePoserEntity()
+	if ( !IsValid( ent ) ) then return end
+
+	local FlexNum = ent:GetFlexNum()
+	if ( FlexNum <= 0 ) then return end
+
+	for i = 0, FlexNum do
+
+		local num = self:GetClientNumber( "flex" .. i )
+		ent:SetFlexWeight( i, num )
+
+	end
+
+	local num = self:GetClientNumber( "scale" )
+	ent:SetFlexScale( num )
+
+end
+
+--[[---------------------------------------------------------
+	Alt fire sucks the facepose from the model's face
+-----------------------------------------------------------]]
+function TOOL:RightClick( trace )
+
+	local ent = trace.Entity
+	if ( IsValid( ent ) && ent:GetClass() == "prop_effect" ) then ent = ent.AttachedEntity end
+
+	if ( SERVER ) then
+		self:SetFacePoserEntity( ent )
+	end
+
+	if ( !IsValid( ent ) ) then return true end
+
+	local FlexNum = ent:GetFlexNum()
+	if ( FlexNum == 0 ) then return false end
+
+	if ( SERVER ) then
+
+		-- This stops it applying the current sliders to the newly selected face..
+		-- it should probably be linked to the ping somehow.. but 1 second seems pretty safe
+		self.FaceTimer = CurTime() + 1
+
+		-- In multiplayer the rest is only done on the client to save bandwidth.
+		-- We can't do that in single player because these functions don't get called on the client
+		if ( !game.SinglePlayer() ) then return true end
+
+	end
+
+	for i = 0, FlexNum - 1 do
+
+		local Weight = 0
+		if ( !ent:HasFlexManipulatior() ) then
+			Weight = GenerateDefaultFlexValue( ent, i )
+		elseif ( i <= FlexNum ) then
+			Weight = ent:GetFlexWeight( i )
+		end
+
+		self:GetOwner():ConCommand( "faceposer_flex" .. i .. " " .. Weight )
+
+	end
+
+	self:GetOwner():ConCommand( "faceposer_scale " .. ent:GetFlexScale() )
+
+	return true
+
+end
+
+--[[---------------------------------------------------------
+	Just select as the current object
+	Current settings will get applied
+-----------------------------------------------------------]]
+function TOOL:LeftClick( trace )
+
+	local ent = trace.Entity
+	if ( IsValid( ent ) && ent:GetClass() == "prop_effect" ) then ent = ent.AttachedEntity end
+
+	if ( !IsValid( ent ) ) then return false end
+	if ( ent:GetFlexNum() == 0 ) then return false end
+
+	self.FaceTimer = 0
+	self:SetFacePoserEntity( ent )
+
+	return true
+
+end
+
+if ( SERVER ) then
+
+	local function CC_Face_Randomize( ply, command, arguments )
+
+		for i = 0, MAXSTUDIOFLEXCTRL do
+			local num = math.Rand( 0, 1 )
+			ply:ConCommand( "faceposer_flex" .. i .. " " .. string.format( "%.3f", num ) )
+		end
+
+	end
+
+	concommand.Add( "faceposer_randomize", CC_Face_Randomize )
+
+end
+
+-- The rest of the code is clientside only, it is not used on server
+if ( SERVER ) then return end
+
+for i = 0, MAXSTUDIOFLEXCTRL do
+	TOOL.ClientConVar[ "flex" .. i ] = "0"
+end
+
+TOOL.ClientConVar[ "scale" ] = "1.0"
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel, faceEntity )
+
+	CPanel:Help( "#tool.faceposer.desc" )
+
+	if ( !IsValid( faceEntity ) || faceEntity:GetFlexNum() == 0 ) then return end
+
+	CPanel:ToolPresets( "face", ConVarsDefault )
+
+	local QuickFace = vgui.Create( "MatSelect", CPanel )
+	QuickFace:SetItemWidth( 64 )
+	QuickFace:SetItemHeight( 32 )
+
+	QuickFace.List:SetSpacing( 1 )
+	QuickFace.List:SetPadding( 0 )
+
+	QuickFace:SetAutoHeight( true )
+
+	local Clear = {}
+	for i = 0, MAXSTUDIOFLEXCTRL do
+		Clear[ "faceposer_flex" .. i ] = GenerateDefaultFlexValue( faceEntity, i )
+	end
+	QuickFace:AddMaterialEx( "#faceposer.clear", "vgui/face/clear", nil, Clear )
+
+	-- Todo: These really need to be the name of the flex.
+	QuickFace:AddMaterialEx( "#faceposer.openeyes", "vgui/face/open_eyes", nil, {
+		faceposer_flex0 = "1",
+		faceposer_flex1 = "1",
+		faceposer_flex2 = "0",
+		faceposer_flex3 = "0",
+		faceposer_flex4 = "0",
+		faceposer_flex5 = "0",
+		faceposer_flex6 = "0",
+		faceposer_flex7 = "0",
+		faceposer_flex8 = "0",
+		faceposer_flex9 = "0"
+	} )
+
+	QuickFace:AddMaterialEx( "#faceposer.closeeyes", "vgui/face/close_eyes", nil, {
+		faceposer_flex0 = "0",
+		faceposer_flex1 = "0",
+		faceposer_flex2 = "1",
+		faceposer_flex3 = "1",
+		faceposer_flex4 = "1",
+		faceposer_flex5 = "1",
+		faceposer_flex6 = "1",
+		faceposer_flex7 = "1",
+		faceposer_flex8 = "1",
+		faceposer_flex9 = "1"
+	} )
+
+	QuickFace:AddMaterialEx( "#faceposer.angryeyebrows", "vgui/face/angry_eyebrows", nil, {
+		faceposer_flex10 = "0",
+		faceposer_flex11 = "0",
+		faceposer_flex12 = "1",
+		faceposer_flex13 = "1",
+		faceposer_flex14 = "0.5",
+		faceposer_flex15 = "0.5"
+	} )
+
+	QuickFace:AddMaterialEx( "#faceposer.normaleyebrows", "vgui/face/normal_eyebrows", nil, {
+		faceposer_flex10 = "0",
+		faceposer_flex11 = "0",
+		faceposer_flex12 = "0",
+		faceposer_flex13 = "0",
+		faceposer_flex14 = "0",
+		faceposer_flex15 = "0"
+	} )
+
+	QuickFace:AddMaterialEx( "#faceposer.sorryeyebrows", "vgui/face/sorry_eyebrows", nil, {
+		faceposer_flex10 = "1",
+		faceposer_flex11 = "1",
+		faceposer_flex12 = "0",
+		faceposer_flex13 = "0",
+		faceposer_flex14 = "0",
+		faceposer_flex15 = "0"
+	} )
+
+	QuickFace:AddMaterialEx( "#faceposer.grin", "vgui/face/grin", nil, {
+		faceposer_flex20 = "1",
+		faceposer_flex21 = "1",
+		faceposer_flex22 = "1",
+		faceposer_flex23 = "1",
+		faceposer_flex24 = "0",
+		faceposer_flex25 = "0",
+		faceposer_flex26 = "0",
+		faceposer_flex27 = "1",
+		faceposer_flex28 = "1",
+		faceposer_flex29 = "0",
+		faceposer_flex30 = "0",
+		faceposer_flex31 = "0",
+		faceposer_flex32 = "0",
+		faceposer_flex33 = "1",
+		faceposer_flex34 = "1",
+		faceposer_flex35 = "0",
+		faceposer_flex36 = "0",
+		faceposer_flex37 = "0",
+		faceposer_flex38 = "0",
+		faceposer_flex39 = "1",
+		faceposer_flex40 = "0",
+		faceposer_flex41 = "0",
+		faceposer_flex42 = "1",
+		faceposer_flex43 = "1"
+	} )
+
+	QuickFace:AddMaterialEx( "#faceposer.sad", "vgui/face/sad", nil, {
+		faceposer_flex20 = "0",
+		faceposer_flex21 = "0",
+		faceposer_flex22 = "0",
+		faceposer_flex23 = "0",
+		faceposer_flex24 = "1",
+		faceposer_flex25 = "1",
+		faceposer_flex26 = "0.0",
+		faceposer_flex27 = "0",
+		faceposer_flex28 = "0",
+		faceposer_flex29 = "0",
+		faceposer_flex30 = "0",
+		faceposer_flex31 = "0",
+		faceposer_flex32 = "0",
+		faceposer_flex33 = "0",
+		faceposer_flex34 = "0",
+		faceposer_flex35 = "0",
+		faceposer_flex36 = "0",
+		faceposer_flex37 = "0",
+		faceposer_flex38 = "0.5",
+		faceposer_flex39 = "0",
+		faceposer_flex40 = "0",
+		faceposer_flex41 = "0",
+		faceposer_flex42 = "0",
+		faceposer_flex43 = "0"
+	} )
+
+	QuickFace:AddMaterialEx( "#faceposer.smile", "vgui/face/smile", nil, {
+		faceposer_flex20 = "1",
+		faceposer_flex21 = "1",
+		faceposer_flex22 = "1",
+		faceposer_flex23 = "1",
+		faceposer_flex24 = "0",
+		faceposer_flex25 = "0",
+		faceposer_flex26 = "0",
+		faceposer_flex27 = "0.6",
+		faceposer_flex28 = "0.4",
+		faceposer_flex29 = "0",
+		faceposer_flex30 = "0",
+		faceposer_flex31 = "0",
+		faceposer_flex32 = "0",
+		faceposer_flex33 = "1",
+		faceposer_flex34 = "1",
+		faceposer_flex35 = "0",
+		faceposer_flex36 = "0",
+		faceposer_flex37 = "0",
+		faceposer_flex38 = "0",
+		faceposer_flex39 = "0",
+		faceposer_flex40 = "1",
+		faceposer_flex41 = "1",
+		faceposer_flex42 = "0",
+		faceposer_flex43 = "0",
+		faceposer_flex44 = "0",
+	} )
+
+	CPanel:AddItem( QuickFace )
+
+	CPanel:NumSlider( "#tool.faceposer.scale", "faceposer_scale", -5, 5 ):SetHeight( 16 )
+	CPanel:ControlHelp( "#tool.faceposer.scale.help" )
+
+	CPanel:Button( "#tool.faceposer.randomize", "faceposer_randomize" )
+
+	local filter = CPanel:TextEntry( "#spawnmenu.quick_filter_tool" )
+	filter:SetUpdateOnType( true )
+
+	-- Group flex controllers by their type..
+	local flexGroups = {}
+	for i = 0, faceEntity:GetFlexNum() - 1 do
+		local name = faceEntity:GetFlexName( i )
+
+		if ( !IsUselessFaceFlex( name ) ) then
+			local group = faceEntity:GetFlexType( i )
+
+			if ( group == name ) then group = language.GetPhrase( "#spawnmenu.category.other" ) end
+
+			local min, max = faceEntity:GetFlexBounds( i )
+
+			flexGroups[ group ] = flexGroups[ group ] or { sortId = table.Count( flexGroups ), items = {} }
+			table.insert( flexGroups[ group ].items, { name = name, id = i, min = min, max = max, default = GenerateDefaultFlexValue( faceEntity, i ) } )
+		end
+	end
+
+	local flexControllers = {}
+	local moreThanOneGroup = table.Count( flexGroups ) > 1
+	for group, groupData in SortedPairsByMemberValue( flexGroups, "sortId" ) do
+		local items = groupData.items
+
+		local groupForm = vgui.Create( "DForm", CPanel )
+		groupForm:SetLabel( string.NiceName( group ) )
+
+		-- Give the DForm a nice outline
+		groupForm.GetBackgroundColor = function() return color_white end
+
+		function groupForm:Paint( w, h )
+			derma.SkinHook( "Paint", "CategoryList", self, w, h )
+			derma.SkinHook( "Paint", "CollapsibleCategory", self, w, h )
+		end
+
+		CPanel:AddItem( groupForm )
+
+		for id, item in SortedPairsByMemberValue( items, "id" ) do
+			local ctrl = groupForm:NumSlider( string.NiceName( item.name ), "faceposer_flex" .. item.id, item.min, item.max )
+			ctrl:SetDefaultValue( item.default )
+			ctrl:SetHeight( 11 ) -- This makes the controls all bunched up like how we want
+			ctrl:DockPadding( 0, -6, 0, -4 ) -- Try to make the lower part of the text visible
+			ctrl.originalName = item.name
+			table.insert( flexControllers, ctrl )
+
+			if ( item.id >= MAXSTUDIOFLEXCTRL ) then
+				ctrl:SetEnabled( false )
+				ctrl:SetTooltip( "#tool.faceposer.too_many_flexes" )
+			end
+		end
+
+		-- Per category random/clear
+		if ( moreThanOneGroup ) then
+			local btnContainer = vgui.Create( "Panel", groupForm )
+			btnContainer:SetHeight( 22 )
+
+			local btnRnd = vgui.Create( "DButton", btnContainer )
+			btnRnd:SetText( "#tool.faceposer.randomize" )
+			btnRnd:Dock( FILL )
+			btnRnd.DoClick = function()
+				for id, item in pairs( items ) do
+					local num = math.Rand( item.min, item.max )
+					LocalPlayer():ConCommand( "faceposer_flex" .. item.id .. " " .. string.format( "%.2f", num ) )
+				end
+			end
+
+			local btnClear = vgui.Create( "DButton", btnContainer )
+			btnClear:SetText( "#faceposer.clear" )
+			btnClear:DockMargin( 8, 0, 0, 0 )
+			btnClear:Dock( RIGHT )
+			btnClear.DoClick = function()
+				for id, item in pairs( items ) do
+					LocalPlayer():ConCommand( "faceposer_flex" .. item.id .. " " .. string.format( "%.2f", item.default ) )
+				end
+			end
+
+			groupForm:AddItem( btnContainer )
+		end
+
+		-- HACK: Add some padding to the bottom of the list, because Dock won't
+		local padding = vgui.Create( "Panel", groupForm )
+		padding:SetHeight( 0 )
+		groupForm:AddItem( padding )
+
+	end
+
+	-- Actual searching
+	filter.OnValueChange = function( pnl, txt )
+		for id, flxpnl in ipairs( flexControllers ) do
+			if ( !flxpnl:GetText():lower():find( txt:lower(), nil, true ) && !flxpnl.originalName:lower():find( txt:lower(), nil, true ) ) then
+				flxpnl:SetVisible( false )
+			else
+				flxpnl:SetVisible( true )
+			end
+
+			flxpnl:InvalidateParent()
+		end
+		CPanel:InvalidateChildren()
+	end
+end
+
+local FacePoser = surface.GetTextureID( "gui/faceposer_indicator" )
+
+-- Draw a box indicating the face we have selected
+function TOOL:DrawHUD()
+
+	if ( GetConVarNumber( "gmod_drawtooleffects" ) == 0 ) then return end
+
+	local selected = self:FacePoserEntity()
+
+	if ( !IsValid( selected ) || selected:IsWorld() || selected:GetFlexNum() == 0 ) then return end
+
+	local pos = selected:GetPos()
+	local eyeattachment = selected:LookupAttachment( "eyes" )
+	if ( eyeattachment != 0 ) then
+		local attachment = selected:GetAttachment( eyeattachment )
+		pos = attachment.Pos
+	else
+		-- The model has no "eyes" attachment, try to find a bone with "head" in its name
+		for i = 0, selected:GetBoneCount() - 1 do
+			if ( selected:GetBoneName( i ) && selected:GetBoneName( i ):lower():find( "head" ) ) then
+				pos = selected:GetBonePosition( i )
+			end
+		end
+	end
+
+	local scrpos = pos:ToScreen()
+	if ( !scrpos.visible ) then return end
+
+	-- Work out the side distance to give a rough headsize box..
+	local player_eyes = LocalPlayer():EyeAngles()
+	local side = ( pos + player_eyes:Right() * 20 ):ToScreen()
+	local size = math.abs( side.x - scrpos.x )
+
+	surface.SetDrawColor( 255, 255, 255, 255 )
+	surface.SetTexture( FacePoser )
+	surface.DrawTexturedRect( scrpos.x - size, scrpos.y - size, size * 2, size * 2 )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/finger.lua

@@ -0,0 +1,628 @@
+
+TOOL.Category = "Poser"
+TOOL.Name = "#tool.finger.name"
+
+TOOL.RequiresTraceHit = true
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" }
+}
+
+local VarsOnHand = 15
+
+-- Returns true if it has TF2 hands
+local function HasTF2Hands( pEntity )
+	return pEntity:LookupBone( "bip_hand_L" ) != nil
+end
+
+-- Returns true if it has Portal 2 hands
+local function HasP2Hands( pEntity )
+	return pEntity:LookupBone( "wrist_A_L" ) != nil || pEntity:LookupBone( "index_1_L" ) != nil
+end
+
+local TranslateTable_TF2 = {}
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger0" ] = "bip_thumb_0_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger01" ] = "bip_thumb_1_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger02" ] = "bip_thumb_2_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger1" ] = "bip_index_0_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger11" ] = "bip_index_1_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger12" ] = "bip_index_2_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger2" ] = "bip_middle_0_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger21" ] = "bip_middle_1_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger22" ] = "bip_middle_2_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger3" ] = "bip_ring_0_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger31" ] = "bip_ring_1_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger32" ] = "bip_ring_2_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger4" ] = "bip_pinky_0_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger41" ] = "bip_pinky_1_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_L_Finger42" ] = "bip_pinky_2_L"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger0" ] = "bip_thumb_0_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger01" ] = "bip_thumb_1_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger02" ] = "bip_thumb_2_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger1" ] = "bip_index_0_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger11" ] = "bip_index_1_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger12" ] = "bip_index_2_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger2" ] = "bip_middle_0_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger21" ] = "bip_middle_1_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger22" ] = "bip_middle_2_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger3" ] = "bip_ring_0_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger31" ] = "bip_ring_1_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger32" ] = "bip_ring_2_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger4" ] = "bip_pinky_0_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger41" ] = "bip_pinky_1_R"
+TranslateTable_TF2[ "ValveBiped.Bip01_R_Finger42" ] = "bip_pinky_2_R"
+
+local TranslateTable_Zeno = {}
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger0" ] = "Bip01_L_Finger0"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger01" ] = "Bip01_L_Finger01"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger02" ] = "Bip01_L_Finger02"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger1" ] = "Bip01_L_Finger1"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger11" ] = "Bip01_L_Finger11"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger12" ] = "Bip01_L_Finger12"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger2" ] = "Bip01_L_Finger2"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger21" ] = "Bip01_L_Finger21"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger22" ] = "Bip01_L_Finger22"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger3" ] = "Bip01_L_Finger3"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger31" ] = "Bip01_L_Finger31"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger32" ] = "Bip01_L_Finger32"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger4" ] = "Bip01_L_Finger4"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger41" ] = "Bip01_L_Finger41"
+TranslateTable_Zeno[ "ValveBiped.Bip01_L_Finger42" ] = "Bip01_L_Finger42"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger0" ] = "Bip01_R_Finger0"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger01" ] = "Bip01_R_Finger01"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger02" ] = "Bip01_R_Finger02"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger1" ] = "Bip01_R_Finger1"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger11" ] = "Bip01_R_Finger11"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger12" ] = "Bip01_R_Finger12"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger2" ] = "Bip01_R_Finger2"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger21" ] = "Bip01_R_Finger21"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger22" ] = "Bip01_R_Finger22"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger3" ] = "Bip01_R_Finger3"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger31" ] = "Bip01_R_Finger31"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger32" ] = "Bip01_R_Finger32"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger4" ] = "Bip01_R_Finger4"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger41" ] = "Bip01_R_Finger41"
+TranslateTable_Zeno[ "ValveBiped.Bip01_R_Finger42" ] = "Bip01_R_Finger42"
+
+local TranslateTable_INS = {}
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger0" ] = "L Finger0"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger01" ] = "L Finger01"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger02" ] = "L Finger02"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger1" ] = "L Finger1"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger11" ] = "L Finger11"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger12" ] = "L Finger12"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger2" ] = "L Finger2"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger21" ] = "L Finger21"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger22" ] = "L Finger22"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger3" ] = "L Finger3"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger31" ] = "L Finger31"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger32" ] = "L Finger32"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger4" ] = "L Finger4"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger41" ] = "L Finger41"
+TranslateTable_INS[ "ValveBiped.Bip01_L_Finger42" ] = "L Finger42"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger0" ] = "R Finger0"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger01" ] = "R Finger01"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger02" ] = "R Finger02"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger1" ] = "R Finger1"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger11" ] = "R Finger11"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger12" ] = "R Finger12"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger2" ] = "R Finger2"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger21" ] = "R Finger21"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger22" ] = "R Finger22"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger3" ] = "R Finger3"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger31" ] = "R Finger31"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger32" ] = "R Finger32"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger4" ] = "R Finger4"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger41" ] = "R Finger41"
+TranslateTable_INS[ "ValveBiped.Bip01_R_Finger42" ] = "R Finger42"
+
+local TranslateTable_Chell = {}
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger0" ] = "thumb_base_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger01" ] = "thumb_mid_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger02" ] = "thumb_end_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger1" ] = "index_base_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger11" ] = "index_mid_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger12" ] = "index_end_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger2" ] = "mid_base_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger21" ] = "mid_mid_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger22" ] = "mid_end_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger3" ] = "ring_base_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger31" ] = "ring_mid_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger32" ] = "ring_end_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger4" ] = "pinky_base_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger41" ] = "pinky_mid_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_L_Finger42" ] = "pinky_end_L"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger0" ] = "thumb_base_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger01" ] = "thumb_mid_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger02" ] = "thumb_end_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger1" ] = "index_base_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger11" ] = "index_mid_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger12" ] = "index_end_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger2" ] = "mid_base_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger21" ] = "mid_mid_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger22" ] = "mid_end_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger3" ] = "ring_base_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger31" ] = "ring_mid_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger32" ] = "ring_end_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger4" ] = "pinky_base_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger41" ] = "pinky_mid_R"
+TranslateTable_Chell[ "ValveBiped.Bip01_R_Finger42" ] = "pinky_end_R"
+
+local TranslateTable_EggBot = {}
+TranslateTable_EggBot[ "ValveBiped.Bip01_L_Finger0" ] = "thumb2_0_A_L"
+TranslateTable_EggBot[ "ValveBiped.Bip01_L_Finger01" ] = "thumb2_1_A_L"
+TranslateTable_EggBot[ "ValveBiped.Bip01_L_Finger02" ] = "thumb2_2_A_L"
+TranslateTable_EggBot[ "ValveBiped.Bip01_L_Finger1" ] = "index2_0_A_L"
+TranslateTable_EggBot[ "ValveBiped.Bip01_L_Finger11" ] = "index2_1_A_L"
+TranslateTable_EggBot[ "ValveBiped.Bip01_L_Finger12" ] = "index2_2_A_L"
+TranslateTable_EggBot[ "ValveBiped.Bip01_L_Finger2" ] = "mid2_0_A_L"
+TranslateTable_EggBot[ "ValveBiped.Bip01_L_Finger21" ] = "mid2_1_A_L"
+TranslateTable_EggBot[ "ValveBiped.Bip01_L_Finger22" ] = "mid2_2_A_L"
+TranslateTable_EggBot[ "ValveBiped.Bip01_R_Finger0" ] = "thumb3_0_A_R"
+TranslateTable_EggBot[ "ValveBiped.Bip01_R_Finger01" ] = "thumb3_1_A_R"
+TranslateTable_EggBot[ "ValveBiped.Bip01_R_Finger02" ] = "thumb3_2_A_R"
+TranslateTable_EggBot[ "ValveBiped.Bip01_R_Finger1" ] = "index3_0_A_R"
+TranslateTable_EggBot[ "ValveBiped.Bip01_R_Finger11" ] = "index3_1_A_R"
+TranslateTable_EggBot[ "ValveBiped.Bip01_R_Finger12" ] = "index3_2_A_R"
+TranslateTable_EggBot[ "ValveBiped.Bip01_R_Finger2" ] = "mid3_0_A_R"
+TranslateTable_EggBot[ "ValveBiped.Bip01_R_Finger21" ] = "mid3_1_A_R"
+TranslateTable_EggBot[ "ValveBiped.Bip01_R_Finger22" ] = "mid3_2_A_R"
+
+local TranslateTable_Poral2 = {}
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger0" ] = "thumb_0_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger01" ] = "thumb_1_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger02" ] = "thumb_2_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger1" ] = "index_0_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger11" ] = "index_1_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger12" ] = "index_2_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger2" ] = "mid_0_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger21" ] = "mid_1_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger22" ] = "mid_2_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger3" ] = "ring_0_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger31" ] = "ring_1_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_L_Finger32" ] = "ring_2_L"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger0" ] = "thumb_0_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger01" ] = "thumb_1_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger02" ] = "thumb_2_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger1" ] = "index_0_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger11" ] = "index_1_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger12" ] = "index_2_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger2" ] = "mid_0_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger21" ] = "mid_1_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger22" ] = "mid_2_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger3" ] = "ring_0_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger31" ] = "ring_1_R"
+TranslateTable_Poral2[ "ValveBiped.Bip01_R_Finger32" ] = "ring_2_R"
+
+local TranslateTable_DOG = {}
+TranslateTable_DOG[ "ValveBiped.Bip01_L_Finger0" ] = "Dog_Model.Thumb1_L"
+TranslateTable_DOG[ "ValveBiped.Bip01_L_Finger01" ] = "Dog_Model.Thumb2_L"
+--TranslateTable_DOG[ "ValveBiped.Bip01_L_Finger02" ] = "Dog_Model.Thumb3_L"
+TranslateTable_DOG[ "ValveBiped.Bip01_L_Finger1" ] = "Dog_Model.Index1_L"
+TranslateTable_DOG[ "ValveBiped.Bip01_L_Finger11" ] = "Dog_Model.Index2_L"
+TranslateTable_DOG[ "ValveBiped.Bip01_L_Finger12" ] = "Dog_Model.Index3_L"
+TranslateTable_DOG[ "ValveBiped.Bip01_L_Finger4" ] = "Dog_Model.Pinky1_L"
+TranslateTable_DOG[ "ValveBiped.Bip01_L_Finger41" ] = "Dog_Model.Pinky2_L"
+TranslateTable_DOG[ "ValveBiped.Bip01_L_Finger42" ] = "Dog_Model.Pinky3_L"
+TranslateTable_DOG[ "ValveBiped.Bip01_R_Finger0" ] = "Dog_Model.Thumb1_R"
+TranslateTable_DOG[ "ValveBiped.Bip01_R_Finger01" ] = "Dog_Model.Thumb2_R"
+TranslateTable_DOG[ "ValveBiped.Bip01_R_Finger02" ] = "Dog_Model.Thumb3_R"
+TranslateTable_DOG[ "ValveBiped.Bip01_R_Finger1" ] = "Dog_Model.Index1_R"
+TranslateTable_DOG[ "ValveBiped.Bip01_R_Finger11" ] = "Dog_Model.Index2_R"
+TranslateTable_DOG[ "ValveBiped.Bip01_R_Finger12" ] = "Dog_Model.Index3_R"
+TranslateTable_DOG[ "ValveBiped.Bip01_R_Finger4" ] = "Dog_Model.Pinky1_R"
+TranslateTable_DOG[ "ValveBiped.Bip01_R_Finger41" ] = "Dog_Model.Pinky2_R"
+TranslateTable_DOG[ "ValveBiped.Bip01_R_Finger42" ] = "Dog_Model.Pinky3_R"
+
+local TranslateTable_VORT = {}
+TranslateTable_VORT[ "ValveBiped.Bip01_L_Finger1" ] = "ValveBiped.index1_L"
+TranslateTable_VORT[ "ValveBiped.Bip01_L_Finger11" ] = "ValveBiped.index2_L"
+TranslateTable_VORT[ "ValveBiped.Bip01_L_Finger12" ] = "ValveBiped.index3_L"
+TranslateTable_VORT[ "ValveBiped.Bip01_L_Finger4" ] = "ValveBiped.pinky1_L"
+TranslateTable_VORT[ "ValveBiped.Bip01_L_Finger41" ] = "ValveBiped.pinky2_L"
+TranslateTable_VORT[ "ValveBiped.Bip01_L_Finger42" ] = "ValveBiped.pinky3_L"
+TranslateTable_VORT[ "ValveBiped.Bip01_R_Finger1" ] = "ValveBiped.index1_R"
+TranslateTable_VORT[ "ValveBiped.Bip01_R_Finger11" ] = "ValveBiped.index2_R"
+TranslateTable_VORT[ "ValveBiped.Bip01_R_Finger12" ] = "ValveBiped.index3_R"
+TranslateTable_VORT[ "ValveBiped.Bip01_R_Finger4" ] = "ValveBiped.pinky1_R"
+TranslateTable_VORT[ "ValveBiped.Bip01_R_Finger41" ] = "ValveBiped.pinky2_R"
+TranslateTable_VORT[ "ValveBiped.Bip01_R_Finger42" ] = "ValveBiped.pinky3_R"
+
+function TOOL:HandEntity()
+	return self:GetWeapon():GetNWEntity( "HandEntity" )
+end
+
+function TOOL:HandNum()
+	return self:GetWeapon():GetNWInt( "HandNum" )
+end
+
+function TOOL:SetHand( ent, iHand )
+	self:GetWeapon():SetNWEntity( "HandEntity", ent )
+	self:GetWeapon():SetNWInt( "HandNum", iHand )
+end
+
+-- Translate the fingernum, part and hand into an real bone number
+local function GetFingerBone( self, fingernum, part, hand )
+
+	---- START HL2 BONE LOOKUP ----------------------------------
+	local Name = "ValveBiped.Bip01_L_Finger" .. fingernum
+	if ( hand == 1 ) then Name = "ValveBiped.Bip01_R_Finger" .. fingernum end
+	if ( part != 0 ) then Name = Name .. part end
+
+	local boneid = self:LookupBone( Name )
+	if ( boneid ) then return boneid end
+	---- END HL2 BONE LOOKUP ----------------------------------
+
+	---- START TF BONE LOOKUP ----------------------------------
+	local TranslatedName = TranslateTable_TF2[ Name ]
+	if ( TranslatedName ) then
+		local bone = self:LookupBone( TranslatedName )
+		if ( bone ) then return bone end
+	end
+	---- END TF BONE LOOKUP ----------------------------------
+
+	---- START Zeno BONE LOOKUP ----------------------------------
+	TranslatedName = TranslateTable_Zeno[ Name ]
+	if ( TranslatedName ) then
+		local bone = self:LookupBone( TranslatedName )
+		if ( bone ) then return bone end
+	end
+	---- END Zeno BONE LOOKUP ----------------------------------
+
+	---- START DOG BONE LOOKUP ----------------------------------
+	TranslatedName = TranslateTable_DOG[ Name ]
+	if ( TranslatedName ) then
+		local bone = self:LookupBone( TranslatedName )
+		if ( bone ) then return bone end
+	end
+	---- END DOG BONE LOOKUP ----------------------------------
+
+	---- START VORT BONE LOOKUP ----------------------------------
+	TranslatedName = TranslateTable_VORT[ Name ]
+	if ( TranslatedName ) then
+		local bone = self:LookupBone( TranslatedName )
+		if ( bone ) then return bone end
+	end
+	---- END VORT BONE LOOKUP ----------------------------------
+
+	---- START Chell BONE LOOKUP ----------------------------------
+	TranslatedName = TranslateTable_Chell[ Name ]
+	if ( TranslatedName ) then
+		local bone = self:LookupBone( TranslatedName )
+		if ( bone ) then return bone end
+	end
+	---- END Chell BONE LOOKUP ----------------------------------
+
+	---- START EggBot ( Portal 2 ) BONE LOOKUP ----------------------------------
+	TranslatedName = TranslateTable_EggBot[ Name ]
+	if ( TranslatedName ) then
+		local bone = self:LookupBone( TranslatedName )
+		if ( bone ) then return bone end
+	end
+	---- END EggBot BONE LOOKUP ----------------------------------
+
+	---- START Portal 2 ( Ball Bot ) BONE LOOKUP ----------------------------------
+	TranslatedName = TranslateTable_Poral2[ Name ]
+	if ( TranslatedName ) then
+		local bone = self:LookupBone( TranslatedName )
+		if ( bone ) then return bone end
+	end
+	---- END Portal 2 BONE LOOKUP ----------------------------------
+
+	---- START Ins BONE LOOKUP ----------------------------------
+	TranslatedName = TranslateTable_INS[ Name ]
+	if ( TranslatedName ) then
+		local bone = self:LookupBone( TranslatedName )
+		if ( bone ) then return bone end
+	end
+	---- END Insurgency BONE LOOKUP ----------------------------------
+
+end
+
+-- Cache the finger bone numbers for faster access
+local function SetupFingers( self )
+
+	if ( self.FingerIndex ) then return end
+
+	self.FingerIndex = {}
+
+	local i = 1
+
+	for hand = 0, 1 do
+		for finger = 0, 4 do
+			for part = 0, 2 do
+
+				self.FingerIndex[ i ] = GetFingerBone( self, finger, part, hand )
+
+				i = i + 1
+
+			end
+		end
+	end
+
+end
+
+-- Apply the current tool values to entity's hand
+function TOOL:ApplyValues( pEntity, iHand )
+
+	if ( CLIENT ) then return end
+
+	SetupFingers( pEntity )
+
+	local bTF2 = HasTF2Hands( pEntity )
+	local bP2 = HasP2Hands( pEntity )
+
+	for i = 0, VarsOnHand - 1 do
+
+		local Var = self:GetClientInfo( i )
+		local VecComp = string.Explode( " ", Var )
+
+		local Ang = nil
+
+		if ( bP2 ) then
+			if ( i < 3 ) then
+				Ang = Angle( tonumber( VecComp[1] ), tonumber( VecComp[2] ), 0 )
+			else
+				Ang = Angle( -tonumber( VecComp[2] ), tonumber( VecComp[1] ), 0 )
+			end
+
+		elseif ( bTF2 ) then
+
+			if ( i < 3 ) then
+				Ang = Angle( 0, tonumber( VecComp[2] ), tonumber( VecComp[1] ) )
+			else
+				Ang = Angle( 0, tonumber( VecComp[1] ), -tonumber( VecComp[2] ) )
+			end
+
+		else
+			if ( i < 3 ) then
+				Ang = Angle( tonumber( VecComp[2] ), tonumber( VecComp[1] ), 0 )
+			else
+				Ang = Angle( tonumber( VecComp[1] ), tonumber( VecComp[2] ), 0 )
+			end
+		end
+
+		local bone = pEntity.FingerIndex[ i + iHand * VarsOnHand + 1 ]
+		if ( bone ) then
+			pEntity:ManipulateBoneAngles( bone, Ang )
+		end
+
+	end
+
+end
+
+-- Hope we don't have any one armed models
+function TOOL:GetHandPositions( pEntity )
+
+	local LeftHand = pEntity:LookupBone( "ValveBiped.Bip01_L_Hand" )
+	if ( !LeftHand ) then LeftHand = pEntity:LookupBone( "bip_hand_L" ) end
+	if ( !LeftHand ) then LeftHand = pEntity:LookupBone( "Bip01_L_Hand" ) end
+	if ( !LeftHand ) then LeftHand = pEntity:LookupBone( "Dog_Model.Hand_L" ) end -- DOG
+	if ( !LeftHand ) then LeftHand = pEntity:LookupBone( "ValveBiped.Hand1_L" ) end -- Vortigaunt
+	if ( !LeftHand ) then LeftHand = pEntity:LookupBone( "wrist_L" ) end -- Chell
+	if ( !LeftHand ) then LeftHand = pEntity:LookupBone( "L Hand" ) end -- Insurgency
+	if ( !LeftHand ) then LeftHand = pEntity:LookupBone( "wrist_A_L" ) end -- Portal 2 Egg bot
+
+	local RightHand = pEntity:LookupBone( "ValveBiped.Bip01_R_Hand" )
+	if ( !RightHand ) then RightHand = pEntity:LookupBone( "bip_hand_R" ) end
+	if ( !RightHand ) then RightHand = pEntity:LookupBone( "Bip01_R_Hand" ) end
+	if ( !RightHand ) then RightHand = pEntity:LookupBone( "Bip01_R_Hand" ) end
+	if ( !RightHand ) then RightHand = pEntity:LookupBone( "Dog_Model.Hand_R" ) end
+	if ( !RightHand ) then RightHand = pEntity:LookupBone( "ValveBiped.Hand1_R" ) end
+	if ( !RightHand ) then RightHand = pEntity:LookupBone( "wrist_R" ) end
+	if ( !RightHand ) then RightHand = pEntity:LookupBone( "R Hand" ) end
+	if ( !RightHand ) then RightHand = pEntity:LookupBone( "wrist_A_R" ) end
+
+	if ( !LeftHand || !RightHand ) then return false end
+
+	local LeftHandMatrix = pEntity:GetBoneMatrix( LeftHand )
+	local RightHandMatrix = pEntity:GetBoneMatrix( RightHand )
+	if ( !LeftHandMatrix || !RightHandMatrix ) then return false end
+
+	return LeftHandMatrix, RightHandMatrix
+
+end
+
+-- Applies current convar hand to picked hand
+function TOOL:LeftClick( trace )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return false end
+	--if ( trace.Entity:GetClass() != "prop_ragdoll" && !trace.Entity:IsNPC() ) then return false end
+
+	local LeftHandMatrix, RightHandMatrix = self:GetHandPositions( trace.Entity )
+
+	if ( !LeftHandMatrix ) then return false end
+	if ( CLIENT ) then return true end
+
+	local LeftHand = ( LeftHandMatrix:GetTranslation() - trace.HitPos ):Length()
+	local RightHand = ( RightHandMatrix:GetTranslation() - trace.HitPos ):Length()
+
+	if ( LeftHand < RightHand ) then
+
+		self:ApplyValues( trace.Entity, 0 )
+
+	else
+
+		self:ApplyValues( trace.Entity, 1 )
+
+	end
+
+	return true
+
+end
+
+-- Selects picked hand and sucks off convars
+function TOOL:RightClick( trace )
+
+	local ent = trace.Entity
+	if ( IsValid( ent ) && ent:GetClass() == "prop_effect" ) then ent = ent.AttachedEntity end
+
+	if ( !IsValid( ent ) || ent:IsPlayer() ) then self:SetHand( NULL, 0 ) return true end
+	--if ( ent:GetClass() != "prop_ragdoll" && ent:GetClass() != "prop_dynamic" && !ent:IsNPC() ) then return false end
+
+	if ( CLIENT ) then return false end
+
+	local LeftHandMatrix, RightHandMatrix = self:GetHandPositions( ent )
+	if ( !LeftHandMatrix ) then return false end
+
+	local LeftHand = ( LeftHandMatrix:GetTranslation() - trace.HitPos ):Length()
+	local RightHand = ( RightHandMatrix:GetTranslation() - trace.HitPos ):Length()
+
+	local Hand = 0
+	if ( LeftHand < RightHand ) then
+
+		self:SetHand( ent, 0 )
+
+	else
+
+		self:SetHand( ent, 1 )
+		Hand = 1
+
+	end
+
+	--
+	-- Make sure entity has fingers set up!
+	--
+	SetupFingers( ent )
+
+	local bTF2 = HasTF2Hands( ent )
+
+	--
+	-- Rwead the variables from the angles of the fingers, into our convars
+	--
+	for i = 0, VarsOnHand-1 do
+
+		local bone = ent.FingerIndex[ i + Hand * VarsOnHand + 1 ]
+		if ( bone ) then
+
+			local Ang = ent:GetManipulateBoneAngles( bone )
+
+			if ( bTF2 ) then
+
+				if ( i < 3 ) then
+					self:GetOwner():ConCommand( Format( "finger_%s %.1f %.1f", i, Ang.Roll, Ang.Yaw ) )
+				else
+					self:GetOwner():ConCommand( Format( "finger_%s %.1f %.1f", i, Ang.Yaw, -Ang.Roll ) )
+				end
+			else
+				if ( i < 3 ) then
+					self:GetOwner():ConCommand( Format( "finger_%s %.1f %.1f", i, Ang.Yaw, Ang.Pitch ) )
+				else
+					self:GetOwner():ConCommand( Format( "finger_%s %.1f %.1f", i, Ang.Pitch, Ang.Yaw ) )
+				end
+			end
+
+		end
+
+	end
+
+	-- We don't want to send the finger poses to the client straight away
+	-- because they will get the old poses that are currently in their convars
+	-- We need to wait until they convars get updated with the sucked pose
+	self.NextUpdate = CurTime() + 0.5
+
+	return true
+
+end
+
+local OldHand = nil
+local OldEntity = nil
+local OldEntityValid = false
+
+--[[
+	Updates the selected entity with the values from the convars
+	Also, on the client it rebuilds the control panel if we have
+	selected a new entity or hand
+]]
+function TOOL:Think()
+
+	local selected = self:HandEntity()
+	local hand = self:HandNum()
+
+	if ( self.NextUpdate && self.NextUpdate > CurTime() ) then return end
+
+	if ( CLIENT && ( OldHand != hand || OldEntity != selected || IsValid( selected ) != OldEntityValid ) ) then
+
+		OldHand = hand
+		OldEntity = selected
+		OldEntityValid = IsValid( selected )
+
+		self:RebuildControlPanel( self:HandEntity(), self:HandNum() )
+
+	end
+
+	if ( !IsValid( selected ) ) then return end
+	if ( selected:IsWorld() ) then return end
+
+	self:ApplyValues( selected, hand )
+
+end
+
+if ( SERVER ) then return end
+-- Notice the return above.
+-- The rest of this file CLIENT ONLY.
+
+for i = 0, VarsOnHand do
+	TOOL.ClientConVar[ "" .. i ] = "0 0"
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel, ent, hand )
+
+	CPanel:Help( "#tool.finger.desc" )
+
+	if ( !IsValid( ent ) ) then return end
+
+	CPanel:ToolPresets( "finger", ConVarsDefault )
+
+	SetupFingers( ent )
+
+	if ( !ent.FingerIndex ) then return end
+
+	-- Detect mitten hands
+	local NumVars = table.Count( ent.FingerIndex )
+
+	local fingerPoser = vgui.Create( "fingerposer", CPanel )
+	fingerPoser:ControlValues( { hand = hand, numvars = NumVars } )
+	CPanel:AddPanel( fingerPoser )
+
+	CPanel:CheckBox( "#tool.finger.restrict_axis", "finger_restrict" )
+
+end
+
+local FacePoser = surface.GetTextureID( "gui/faceposer_indicator" )
+
+-- Draw a circle around the selected hand
+function TOOL:DrawHUD()
+
+	if ( GetConVarNumber( "gmod_drawtooleffects" ) == 0 ) then return end
+
+	local selected = self:HandEntity()
+	local hand = self:HandNum()
+
+	if ( !IsValid( selected ) ) then return end
+	if ( selected:IsWorld() ) then return end
+
+	local lefthand, righthand = self:GetHandPositions( selected )
+
+	local BoneMatrix = lefthand
+	if ( hand == 1 ) then BoneMatrix = righthand end
+	if ( !BoneMatrix ) then return end
+
+	local vPos = BoneMatrix:GetTranslation()
+
+	local scrpos = vPos:ToScreen()
+	if ( !scrpos.visible ) then return end
+
+	-- Work out the side distance to give a rough headsize box..
+	local player_eyes = LocalPlayer():EyeAngles()
+	local side = ( vPos + player_eyes:Right() * 20 ):ToScreen()
+	local size = math.abs( side.x - scrpos.x )
+
+	surface.SetDrawColor( 255, 255, 255, 255 )
+	surface.SetTexture( FacePoser )
+	surface.DrawTexturedRect( scrpos.x - size, scrpos.y - size, size * 2, size * 2 )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/hoverball.lua

@@ -0,0 +1,246 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.hoverball.name"
+
+TOOL.ClientConVar[ "keyup" ] = "46"
+TOOL.ClientConVar[ "keydn" ] = "43"
+TOOL.ClientConVar[ "keyon" ] = "40"
+TOOL.ClientConVar[ "speed" ] = "5"
+TOOL.ClientConVar[ "resistance" ] = "5"
+TOOL.ClientConVar[ "strength" ] = "10"
+TOOL.ClientConVar[ "model" ] = "models/dav0r/hoverball.mdl"
+
+TOOL.Information = { { name = "left" } }
+
+cleanup.Register( "hoverballs" )
+
+local function IsValidHoverballModel( model )
+	for mdl, _ in pairs( list.Get( "HoverballModels" ) ) do
+		if ( mdl:lower() == model:lower() ) then return true end
+	end
+	return false
+end
+
+function TOOL:LeftClick( trace )
+
+	if ( trace.Entity && trace.Entity:IsPlayer() ) then return false end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	if ( CLIENT ) then return true end
+
+	local ply = self:GetOwner()
+
+	local model = self:GetClientInfo( "model" )
+	local key_d = self:GetClientNumber( "keydn" )
+	local key_u = self:GetClientNumber( "keyup" )
+	local key_o = self:GetClientNumber( "keyon" )
+	local speed = self:GetClientNumber( "speed" )
+	local strength = math.Clamp( self:GetClientNumber( "strength" ), 0.1, 20 )
+	local resistance = math.Clamp( self:GetClientNumber( "resistance" ), 0, 20 )
+
+	-- We shot an existing hoverball - just change its values
+	if ( IsValid( trace.Entity ) && trace.Entity:GetClass() == "gmod_hoverball" && trace.Entity:GetPlayer() == ply ) then
+
+		trace.Entity:SetSpeed( speed )
+		trace.Entity:SetAirResistance( resistance )
+		trace.Entity:SetStrength( strength )
+
+		numpad.Remove( trace.Entity.NumDown )
+		numpad.Remove( trace.Entity.NumUp )
+		numpad.Remove( trace.Entity.NumBackDown )
+		numpad.Remove( trace.Entity.NumBackUp )
+		numpad.Remove( trace.Entity.NumToggle )
+
+		trace.Entity.NumDown = numpad.OnDown( ply, key_u, "Hoverball_Up", trace.Entity, true )
+		trace.Entity.NumUp = numpad.OnUp( ply, key_u, "Hoverball_Up", trace.Entity, false )
+
+		trace.Entity.NumBackDown = numpad.OnDown( ply, key_d, "Hoverball_Down", trace.Entity, true )
+		trace.Entity.NumBackUp = numpad.OnUp( ply, key_d, "Hoverball_Down", trace.Entity, false )
+
+		trace.Entity.NumToggle = numpad.OnDown( ply, key_o, "Hoverball_Toggle", trace.Entity )
+
+		trace.Entity.key_u = key_u
+		trace.Entity.key_d = key_d
+		trace.Entity.key_o = key_o
+		trace.Entity.speed = speed
+		trace.Entity.strength = strength
+		trace.Entity.resistance = resistance
+
+		return true
+
+	end
+
+	if ( !util.IsValidModel( model ) || !util.IsValidProp( model ) || !IsValidHoverballModel( model ) ) then return false end
+	if ( !self:GetWeapon():CheckLimit( "hoverballs" ) ) then return false end
+
+	local ball = MakeHoverBall( ply, trace.HitPos, key_d, key_u, speed, resistance, strength, model, nil, key_o )
+	if ( !IsValid( ball ) ) then return false end
+
+	local ang = trace.HitNormal:Angle()
+	ang.pitch = ang.pitch + 90
+	ball:SetAngles( ang )
+
+	local CurPos = ball:GetPos()
+	local NearestPoint = ball:NearestPoint( CurPos - ( trace.HitNormal * 512 ) )
+	local Offset = CurPos - NearestPoint
+	ball:SetPos( trace.HitPos + Offset )
+
+	undo.Create( "gmod_hoverball" )
+		undo.AddEntity( ball )
+
+		-- Don't weld to world
+		if ( IsValid( trace.Entity ) ) then
+
+			local weld = constraint.Weld( ball, trace.Entity, 0, trace.PhysicsBone, 0, 0, true )
+			if ( IsValid( weld ) ) then
+				ply:AddCleanup( "hoverballs", weld )
+				undo.AddEntity( weld )
+			end
+
+			if ( IsValid( ball:GetPhysicsObject() ) ) then ball:GetPhysicsObject():EnableCollisions( false ) end
+			ball:SetCollisionGroup( COLLISION_GROUP_WORLD )
+			ball.nocollide = true
+
+		end
+
+		undo.SetPlayer( ply )
+	undo.Finish()
+
+	return true
+
+end
+
+if ( SERVER ) then
+
+	function MakeHoverBall( ply, pos, key_d, key_u, speed, resistance, strength, model, nocollide, key_o, Data )
+
+		if ( IsValid( ply ) && !ply:CheckLimit( "hoverballs" ) ) then return NULL end
+		if ( !IsValidHoverballModel( model ) ) then return NULL end
+
+		local ball = ents.Create( "gmod_hoverball" )
+		if ( !IsValid( ball ) ) then return NULL end
+
+		duplicator.DoGeneric( ball, Data )
+		ball:SetPos( pos ) -- Backwards compatible for addons directly calling this function
+		ball:SetModel( model )
+		ball:Spawn()
+
+		DoPropSpawnedEffect( ball )
+		duplicator.DoGenericPhysics( ball, ply, Data )
+
+		ball:SetSpeed( speed )
+		ball:SetAirResistance( resistance )
+		ball:SetStrength( strength )
+
+		if ( IsValid( ply ) ) then
+			ball:SetPlayer( ply )
+		end
+
+		ball.NumDown = numpad.OnDown( ply, key_u, "Hoverball_Up", ball, true )
+		ball.NumUp = numpad.OnUp( ply, key_u, "Hoverball_Up", ball, false )
+
+		ball.NumBackDown = numpad.OnDown( ply, key_d, "Hoverball_Down", ball, true )
+		ball.NumBackUp = numpad.OnUp( ply, key_d, "Hoverball_Down", ball, false )
+
+		if ( key_o ) then ball.NumToggle = numpad.OnDown( ply, key_o, "Hoverball_Toggle", ball ) end
+
+		if ( nocollide == true ) then
+			if ( IsValid( ball:GetPhysicsObject() ) ) then ball:GetPhysicsObject():EnableCollisions( false ) end
+			ball:SetCollisionGroup( COLLISION_GROUP_WORLD )
+		end
+
+		local ttable = {
+			key_d = key_d,
+			key_u = key_u,
+			key_o = key_o,
+			pl = ply,
+			nocollide = nocollide,
+			speed = speed,
+			strength = strength,
+			resistance = resistance,
+			model = model
+		}
+
+		table.Merge( ball:GetTable(), ttable )
+
+		if ( IsValid( ply ) ) then
+			ply:AddCount( "hoverballs", ball )
+			ply:AddCleanup( "hoverballs", ball )
+		end
+
+		return ball
+
+	end
+	duplicator.RegisterEntityClass( "gmod_hoverball", MakeHoverBall, "Pos", "key_d", "key_u", "speed", "resistance", "strength", "model", "nocollide", "key_o", "Data" )
+
+end
+
+function TOOL:UpdateGhostHoverball( ent, ply )
+
+	if ( !IsValid( ent ) ) then return end
+
+	local trace = ply:GetEyeTrace()
+	if ( !trace.Hit || IsValid( trace.Entity ) && ( trace.Entity:GetClass() == "gmod_hoverball" || trace.Entity:IsPlayer() ) ) then
+
+		ent:SetNoDraw( true )
+		return
+
+	end
+
+	local ang = trace.HitNormal:Angle()
+	ang.pitch = ang.pitch + 90
+	ent:SetAngles( ang )
+
+	local CurPos = ent:GetPos()
+	local NearestPoint = ent:NearestPoint( CurPos - ( trace.HitNormal * 512 ) )
+	local Offset = CurPos - NearestPoint
+	ent:SetPos( trace.HitPos + Offset )
+
+	ent:SetNoDraw( false )
+
+end
+
+function TOOL:Think()
+
+	local mdl = self:GetClientInfo( "model" )
+	if ( !IsValidHoverballModel( mdl ) ) then self:ReleaseGhostEntity() return end
+
+	if ( !IsValid( self.GhostEntity ) || self.GhostEntity:GetModel() != mdl:lower() ) then
+		self:MakeGhostEntity( mdl, vector_origin, angle_zero )
+	end
+
+	self:UpdateGhostHoverball( self.GhostEntity, self:GetOwner() )
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.hoverball.help" )
+	CPanel:ToolPresets( "hoverball", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.hoverball.up", "hoverball_keyup", "#tool.hoverball.down", "hoverball_keydn" )
+	CPanel:KeyBinder( "#tool.hoverball.key", "hoverball_keyon" )
+
+	CPanel:NumSlider( "#tool.hoverball.speed", "hoverball_speed", 0, 20 )
+	CPanel:ControlHelp( "#tool.hoverball.speed.help" )
+
+	CPanel:NumSlider( "#tool.hoverball.resistance", "hoverball_resistance", 0, 10 )
+	CPanel:ControlHelp( "#tool.hoverball.resistance.help" )
+
+	CPanel:NumSlider( "#tool.hoverball.strength", "hoverball_strength", 0.1, 10 )
+	CPanel:ControlHelp( "#tool.hoverball.strength.help" )
+
+	CPanel:PropSelect( "#tool.hoverball.model", "hoverball_model", list.Get( "HoverballModels" ), 0 )
+
+end
+
+list.Set( "HoverballModels", "models/dav0r/hoverball.mdl", {} )
+list.Set( "HoverballModels", "models/maxofs2d/hover_basic.mdl", {} )
+list.Set( "HoverballModels", "models/maxofs2d/hover_classic.mdl", {} )
+list.Set( "HoverballModels", "models/maxofs2d/hover_plate.mdl", {} )
+list.Set( "HoverballModels", "models/maxofs2d/hover_propeller.mdl", {} )
+list.Set( "HoverballModels", "models/maxofs2d/hover_rings.mdl", {} )

gamemodes/sandbox/entities/weapons/gmod_tool/stools/hydraulic.lua

@@ -0,0 +1,255 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.hydraulic.name"
+
+TOOL.ClientConVar[ "group" ] = "37"
+TOOL.ClientConVar[ "width" ] = "3"
+TOOL.ClientConVar[ "addlength" ] = "100"
+TOOL.ClientConVar[ "fixed" ] = "1"
+TOOL.ClientConVar[ "speed" ] = "64"
+TOOL.ClientConVar[ "toggle" ] = "1"
+TOOL.ClientConVar[ "material" ] = "cable/rope"
+TOOL.ClientConVar[ "color_r" ] = "255"
+TOOL.ClientConVar[ "color_g" ] = "255"
+TOOL.ClientConVar[ "color_b" ] = "255"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1, op = 1 },
+	{ name = "right", stage = 0 },
+	{ name = "reload" }
+}
+
+function TOOL:LeftClick( trace )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return false end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+	self:SetOperation( 1 )
+
+	if ( iNum > 0 ) then
+
+		if ( CLIENT ) then
+			self:ClearObjects()
+			return true
+		end
+
+		if ( ( !IsValid( self:GetEnt( 1 ) ) && !IsValid( self:GetEnt( 2 ) ) ) || iNum > 1 ) then
+			self:ClearObjects()
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		-- Get client's CVars
+		local width = self:GetClientNumber( "width", 3 )
+		local bind = self:GetClientNumber( "group", 1 )
+		local addLength = self:GetClientNumber( "addlength", 0 )
+		local fixed = self:GetClientNumber( "fixed", 1 )
+		local speed = self:GetClientNumber( "speed", 64 )
+		local material = self:GetClientInfo( "material" )
+		local toggle = self:GetClientNumber( "toggle" ) != 0
+		local colorR = self:GetClientNumber( "color_r" )
+		local colorG = self:GetClientNumber( "color_g" )
+		local colorB = self:GetClientNumber( "color_b" )
+
+		-- Get information we're about to use
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+		local WPos1, WPos2 = self:GetPos( 1 ), self:GetPos( 2 )
+
+		local lengthMin = ( WPos1 - WPos2 ):Length()
+		local lengthMax = lengthMin + addLength
+
+		local constr, rope, controller, slider = constraint.Hydraulic( ply, Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, lengthMin, lengthMax, width, bind, fixed, speed, material, toggle, Color( colorR, colorG, colorB ) )
+		if ( IsValid( constr ) ) then
+			undo.Create( "Hydraulic" )
+				undo.AddEntity( constr )
+				if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+				if ( IsValid( slider ) ) then undo.AddEntity( slider ) end
+				if ( IsValid( controller ) ) then undo.AddEntity( controller ) end
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.hydraulic.name" )
+			undo.Finish( "#tool.hydraulic.name" )
+
+			ply:AddCount( "ropeconstraints", constr )
+			ply:AddCleanup( "ropeconstraints", constr )
+			if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+			if ( IsValid( slider ) ) then ply:AddCleanup( "ropeconstraints", slider ) end
+			if ( IsValid( controller ) ) then ply:AddCleanup( "ropeconstraints", controller ) end
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	if ( self:GetOperation() == 1 ) then return false end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	local ply = self:GetOwner()
+
+	local tr_new = {}
+	tr_new.start = trace.HitPos
+	tr_new.endpos = trace.HitPos + ( trace.HitNormal * 16384 )
+	tr_new.filter = { ply }
+	if ( IsValid( trace.Entity ) ) then
+		table.insert( tr_new.filter, trace.Entity )
+	end
+
+	local tr = util.TraceLine( tr_new )
+	if ( !tr.Hit ) then
+		self:ClearObjects()
+		return
+	end
+
+	-- Don't try to constrain world to world
+	if ( trace.HitWorld && tr.HitWorld ) then
+		self:ClearObjects()
+		return
+	end
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then
+		self:ClearObjects()
+		return
+	end
+
+	if ( IsValid( tr.Entity ) && tr.Entity:IsPlayer() ) then
+		self:ClearObjects()
+		return
+	end
+
+	-- Check to see if the player can create a hydraulic constraint with the entity in the trace
+	if ( !hook.Run( "CanTool", ply, tr, "hydraulic", self, 2 ) ) then
+		self:ClearObjects()
+		return
+	end
+
+	local Phys2 = tr.Entity:GetPhysicsObjectNum( tr.PhysicsBone )
+	self:SetObject( 2, tr.Entity, tr.HitPos, Phys2, tr.PhysicsBone, tr.HitNormal )
+
+	if ( CLIENT ) then
+		self:ClearObjects()
+		return true
+	end
+
+	if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+		self:ClearObjects()
+		return false
+	end
+
+	-- Get client's CVars
+	local width = self:GetClientNumber( "width", 3 )
+	local bind = self:GetClientNumber( "group", 1 )
+	local AddLength = self:GetClientNumber( "addlength", 0 )
+	local fixed = self:GetClientNumber( "fixed", 1 )
+	local speed = self:GetClientNumber( "speed", 64 )
+	local material = self:GetClientInfo( "material" )
+	local toggle = self:GetClientNumber( "toggle" ) != 0
+	local colorR = self:GetClientNumber( "color_r" )
+	local colorG = self:GetClientNumber( "color_g" )
+	local colorB = self:GetClientNumber( "color_b" )
+
+	-- Get information we're about to use
+	local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+	local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+	local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+	local WPos1, WPos2 = self:GetPos( 1 ), self:GetPos( 2 )
+
+	local Length1 = ( WPos1 - WPos2 ):Length()
+	local Length2 = Length1 + AddLength
+
+	local constr, rope, controller, slider = constraint.Hydraulic( ply, Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, Length1, Length2, width, bind, fixed, speed, material, toggle, Color( colorR, colorG, colorB ) )
+	if ( IsValid( constr ) ) then
+		undo.Create( "Hydraulic" )
+			undo.AddEntity( constr )
+			if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+			if ( IsValid( slider ) ) then undo.AddEntity( slider ) end
+			if ( IsValid( controller ) ) then undo.AddEntity( controller ) end
+			undo.SetPlayer( ply )
+			undo.SetCustomUndoText( "Undone #tool.hydraulic.name" )
+		undo.Finish( "#tool.hydraulic.name" )
+
+		ply:AddCount( "ropeconstraints", constr )
+		ply:AddCleanup( "ropeconstraints", constr )
+		if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+		if ( IsValid( slider ) ) then ply:AddCleanup( "ropeconstraints", slider ) end
+		if ( IsValid( controller ) ) then ply:AddCleanup( "ropeconstraints", controller ) end
+	end
+
+	-- Clear the objects so we're ready to go again
+	self:ClearObjects()
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "Hydraulic" )
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.hydraulic.help" )
+	CPanel:ToolPresets( "hydraulic", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.hydraulic.controls", "hydraulic_group" )
+
+	CPanel:NumSlider( "#tool.hydraulic.addlength", "hydraulic_addlength", -1000, 1000 )
+	CPanel:ControlHelp( "#tool.hydraulic.addlength.help" )
+
+	CPanel:NumSlider( "#tool.hydraulic.speed", "hydraulic_speed", 0, 50 )
+	CPanel:ControlHelp( "#tool.hydraulic.speed.help" )
+
+	CPanel:CheckBox( "#tool.hydraulic.fixed", "hydraulic_fixed" )
+	CPanel:ControlHelp( "#tool.hydraulic.fixed.help" )
+
+	CPanel:CheckBox( "#tool.toggle", "hydraulic_toggle" )
+	CPanel:ControlHelp( "#tool.toggle.help" )
+
+	CPanel:NumSlider( "#tool.hydraulic.width", "hydraulic_width", 0, 5 )
+
+	CPanel:RopeSelect( "hydraulic_material" )
+
+	CPanel:ColorPicker( "#tool.hydraulic.color", "hydraulic_color_r", "hydraulic_color_g", "hydraulic_color_b" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/inflator.lua

@@ -0,0 +1,147 @@
+
+TOOL.Category = "Poser"
+TOOL.Name = "#tool.inflator.name"
+
+TOOL.LeftClickAutomatic = true
+TOOL.RightClickAutomatic = true
+TOOL.RequiresTraceHit = true
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" },
+	{ name = "reload" }
+}
+
+local ScaleYZ = {
+	"ValveBiped.Bip01_L_UpperArm",
+	"ValveBiped.Bip01_L_Forearm",
+	"ValveBiped.Bip01_L_Thigh",
+	"ValveBiped.Bip01_L_Calf",
+	"ValveBiped.Bip01_R_UpperArm",
+	"ValveBiped.Bip01_R_Forearm",
+	"ValveBiped.Bip01_R_Thigh",
+	"ValveBiped.Bip01_R_Calf",
+	"ValveBiped.Bip01_Spine2",
+	"ValveBiped.Bip01_Spine1",
+	"ValveBiped.Bip01_Spine",
+	"ValveBiped.Bip01_Spinebut",
+
+	-- Vortigaunt
+	"ValveBiped.spine4",
+	"ValveBiped.spine3",
+	"ValveBiped.spine2",
+	"ValveBiped.spine1",
+	"ValveBiped.hlp_ulna_R",
+	"ValveBiped.hlp_ulna_L",
+	"ValveBiped.arm1_L",
+	"ValveBiped.arm1_R",
+	"ValveBiped.arm2_L",
+	"ValveBiped.arm2_R",
+	"ValveBiped.leg_bone1_L",
+	"ValveBiped.leg_bone1_R",
+	"ValveBiped.leg_bone2_L",
+	"ValveBiped.leg_bone2_R",
+	"ValveBiped.leg_bone3_L",
+	"ValveBiped.leg_bone3_R",
+
+	-- Team Fortress 2
+	"bip_knee_L",
+	"bip_knee_R",
+	"bip_hip_R",
+	"bip_hip_L",
+}
+
+local ScaleXZ = {
+	"ValveBiped.Bip01_pelvis",
+
+	-- Team Fortress 2
+	"bip_upperArm_L",
+	"bip_upperArm_R",
+	"bip_lowerArm_L",
+	"bip_lowerArm_R",
+	"bip_forearm_L",
+	"bip_forearm_R",
+}
+
+local function GetNiceBoneScale( name, scale )
+
+	if ( table.HasValue( ScaleYZ, name ) or string.find( name:lower(), "leg" ) or string.find( name:lower(), "arm" ) ) then
+		return Vector( 0, scale, scale )
+	end
+
+	if ( table.HasValue( ScaleXZ, name ) ) then
+		return Vector( scale, 0, scale )
+	end
+
+	return Vector( scale, scale, scale )
+
+end
+
+--Scale the specified bone by Scale
+local function ScaleBone( ent, bone, scale )
+
+	if ( !bone or CLIENT ) then return false end
+
+	local physBone = ent:TranslateBoneToPhysBone( bone )
+	for i = 0, ent:GetBoneCount() do
+		if ( ent:TranslateBoneToPhysBone( i ) != physBone ) then continue end
+
+		-- Some bones are scaled only in certain directions (like legs don't scale on length)
+		local v = GetNiceBoneScale( ent:GetBoneName( i ), scale ) * 0.1
+		local TargetScale = ent:GetManipulateBoneScale( i ) + v * 0.1
+
+		if ( TargetScale.x < 0 ) then TargetScale.x = 0 end
+		if ( TargetScale.y < 0 ) then TargetScale.y = 0 end
+		if ( TargetScale.z < 0 ) then TargetScale.z = 0 end
+
+		ent:ManipulateBoneScale( i, TargetScale )
+	end
+
+end
+
+--Scale UP
+function TOOL:LeftClick( trace, scale )
+
+	if ( !IsValid( trace.Entity ) ) then return false end
+	if ( !trace.Entity:IsNPC() and trace.Entity:GetClass() != "prop_ragdoll" /*&& !trace.Entity:IsPlayer()*/ ) then return false end
+
+	local bone = trace.Entity:TranslatePhysBoneToBone( trace.PhysicsBone )
+	ScaleBone( trace.Entity, bone, scale or 1 )
+	self:GetWeapon():SetNextPrimaryFire( CurTime() + 0.01 )
+
+	local effectdata = EffectData()
+	effectdata:SetOrigin( trace.HitPos )
+	util.Effect( "inflator_magic", effectdata )
+
+	return false
+
+end
+
+-- Scale DOWN
+function TOOL:RightClick( trace )
+
+	return self:LeftClick( trace, -1 )
+
+end
+
+-- Reset scaling
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) ) then return false end
+	if ( !trace.Entity:IsNPC() and trace.Entity:GetClass() != "prop_ragdoll" /*&& !trace.Entity:IsPlayer()*/ ) then return false end
+
+	if ( CLIENT ) then return true end
+
+	for i = 0, trace.Entity:GetBoneCount() do
+		trace.Entity:ManipulateBoneScale( i, Vector( 1, 1, 1 ) )
+	end
+
+	return true
+
+end
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.inflator.desc" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/lamp.lua

@@ -0,0 +1,287 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.lamp.name"
+
+TOOL.ClientConVar[ "r" ] = "255"
+TOOL.ClientConVar[ "g" ] = "255"
+TOOL.ClientConVar[ "b" ] = "255"
+TOOL.ClientConVar[ "key" ] = "37"
+TOOL.ClientConVar[ "fov" ] = "90"
+TOOL.ClientConVar[ "distance" ] = "1024"
+TOOL.ClientConVar[ "brightness" ] = "4"
+TOOL.ClientConVar[ "texture" ] = "effects/flashlight001"
+TOOL.ClientConVar[ "model" ] = "models/lamps/torch.mdl"
+TOOL.ClientConVar[ "toggle" ] = "1"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" },
+}
+
+cleanup.Register( "lamps" )
+
+local function IsValidLampModel( model )
+	for mdl, _ in pairs( list.Get( "LampModels" ) ) do
+		if ( mdl:lower() == model:lower() ) then return true end
+	end
+	return false
+end
+
+function TOOL:LeftClick( trace )
+
+	if ( IsValid( trace.Entity ) and trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	local ply = self:GetOwner()
+	local pos = trace.HitPos
+
+	local r = math.Clamp( self:GetClientNumber( "r" ), 0, 255 )
+	local g = math.Clamp( self:GetClientNumber( "g" ), 0, 255 )
+	local b = math.Clamp( self:GetClientNumber( "b" ), 0, 255 )
+	local key = self:GetClientNumber( "key" )
+	local mdl = self:GetClientInfo( "model" )
+	local fov = self:GetClientNumber( "fov" )
+	local distance = self:GetClientNumber( "distance" )
+	local bright = self:GetClientNumber( "brightness" )
+	local toggle = self:GetClientNumber( "toggle" ) != 1
+
+	local tex = self:GetClientInfo( "texture" )
+	local mat = Material( tex )
+	local texture = mat:GetString( "$basetexture" )
+
+	if ( IsValid( trace.Entity ) and trace.Entity:GetClass() == "gmod_lamp" and trace.Entity:GetPlayer() == ply ) then
+
+		trace.Entity:SetColor( Color( r, g, b, 255 ) )
+		trace.Entity:SetFlashlightTexture( texture )
+		trace.Entity:SetLightFOV( fov )
+		trace.Entity:SetDistance( distance )
+		trace.Entity:SetBrightness( bright )
+		trace.Entity:SetToggle( !toggle )
+		trace.Entity:UpdateLight()
+
+		numpad.Remove( trace.Entity.NumDown )
+		numpad.Remove( trace.Entity.NumUp )
+
+		trace.Entity.NumDown = numpad.OnDown( ply, key, "LampToggle", trace.Entity, 1 )
+		trace.Entity.NumUp = numpad.OnUp( ply, key, "LampToggle", trace.Entity, 0 )
+
+		-- For duplicator
+		trace.Entity.Texture = texture
+		trace.Entity.fov = fov
+		trace.Entity.distance = distance
+		trace.Entity.r = r
+		trace.Entity.g = g
+		trace.Entity.b = b
+		trace.Entity.brightness = bright
+		trace.Entity.KeyDown = key
+
+		return true
+
+	end
+
+	if ( !util.IsValidModel( mdl ) or !util.IsValidProp( mdl ) or !IsValidLampModel( mdl ) ) then return false end
+	if ( !self:GetWeapon():CheckLimit( "lamps" ) ) then return false end
+
+	local lamp = MakeLamp( ply, r, g, b, key, toggle, texture, mdl, fov, distance, bright, !toggle, { Pos = pos, Angle = angle_zero } )
+	if ( !IsValid( lamp ) ) then return false end
+
+	local CurPos = lamp:GetPos()
+	local NearestPoint = lamp:NearestPoint( CurPos - ( trace.HitNormal * 512 ) )
+	local LampOffset = CurPos - NearestPoint
+
+	lamp:SetPos( trace.HitPos + LampOffset )
+
+	undo.Create( "gmod_lamp" )
+		undo.AddEntity( lamp )
+		undo.SetPlayer( self:GetOwner() )
+	undo.Finish()
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	if ( !IsValid( trace.Entity ) or trace.Entity:GetClass() != "gmod_lamp" ) then return false end
+	if ( CLIENT ) then return true end
+
+	local ent = trace.Entity
+	local ply = self:GetOwner()
+
+	ply:ConCommand( "lamp_fov " .. ent:GetLightFOV() )
+	ply:ConCommand( "lamp_distance " .. ent:GetDistance() )
+	ply:ConCommand( "lamp_brightness " .. ent:GetBrightness() )
+	ply:ConCommand( "lamp_texture " .. ent:GetFlashlightTexture() )
+
+	if ( ent:GetToggle() ) then
+		ply:ConCommand( "lamp_toggle 1" )
+	else
+		ply:ConCommand( "lamp_toggle 0" )
+	end
+
+	local clr = ent:GetColor()
+	ply:ConCommand( "lamp_r " .. clr.r )
+	ply:ConCommand( "lamp_g " .. clr.g )
+	ply:ConCommand( "lamp_b " .. clr.b )
+
+	return true
+
+end
+
+if ( SERVER ) then
+
+	function MakeLamp( ply, r, g, b, keyDown, toggle, texture, model, fov, distance, brightness, on, Data )
+
+		if ( IsValid( ply ) and !ply:CheckLimit( "lamps" ) ) then return NULL end
+		if ( !IsValidLampModel( model ) ) then return NULL end
+
+		local lamp = ents.Create( "gmod_lamp" )
+		if ( !IsValid( lamp ) ) then return NULL end
+
+		duplicator.DoGeneric( lamp, Data )
+		lamp:SetModel( model ) -- Backwards compatible for addons directly calling this function
+		lamp:SetFlashlightTexture( texture )
+		lamp:SetLightFOV( fov )
+		lamp:SetColor( Color( r, g, b, 255 ) )
+		lamp:SetDistance( distance )
+		lamp:SetBrightness( brightness )
+		lamp:Switch( on )
+		lamp:SetToggle( !toggle )
+
+		lamp:Spawn()
+
+		DoPropSpawnedEffect( lamp )
+
+		duplicator.DoGenericPhysics( lamp, ply, Data )
+
+		lamp:SetPlayer( ply )
+
+		if ( IsValid( ply ) ) then
+			ply:AddCount( "lamps", lamp )
+			ply:AddCleanup( "lamps", lamp )
+		end
+
+		lamp.Texture = texture
+		lamp.KeyDown = keyDown
+		lamp.fov = fov
+		lamp.distance = distance
+		lamp.r = r
+		lamp.g = g
+		lamp.b = b
+		lamp.brightness = brightness
+
+		lamp.NumDown = numpad.OnDown( ply, keyDown, "LampToggle", lamp, 1 )
+		lamp.NumUp = numpad.OnUp( ply, keyDown, "LampToggle", lamp, 0 )
+
+		return lamp
+
+	end
+	duplicator.RegisterEntityClass( "gmod_lamp", MakeLamp, "r", "g", "b", "KeyDown", "Toggle", "Texture", "Model", "fov", "distance", "brightness", "on", "Data" )
+
+	numpad.Register( "LampToggle", function( ply, ent, onoff )
+
+		if ( !IsValid( ent ) ) then return false end
+		if ( !ent:GetToggle() ) then ent:Switch( onoff == 1 ) return end
+
+		if ( numpad.FromButton() ) then
+
+			ent:Switch( onoff == 1 )
+			return
+
+		end
+
+		if ( onoff == 0 ) then return end
+
+		return ent:Toggle()
+
+	end )
+
+end
+
+function TOOL:UpdateGhostLamp( ent, ply )
+
+	if ( !IsValid( ent ) ) then return end
+
+	local trace = ply:GetEyeTrace()
+	if ( !trace.Hit or IsValid( trace.Entity ) and ( trace.Entity:IsPlayer() or trace.Entity:GetClass() == "gmod_lamp" ) ) then
+
+		ent:SetNoDraw( true )
+		return
+
+	end
+
+	local CurPos = ent:GetPos()
+	local NearestPoint = ent:NearestPoint( CurPos - ( trace.HitNormal * 512 ) )
+	local LampOffset = CurPos - NearestPoint
+
+	ent:SetPos( trace.HitPos + LampOffset )
+
+	ent:SetNoDraw( false )
+
+end
+
+function TOOL:Think()
+
+	local mdl = self:GetClientInfo( "model" )
+	if ( !IsValidLampModel( mdl ) ) then self:ReleaseGhostEntity() return end
+
+	if ( !IsValid( self.GhostEntity ) or self.GhostEntity:GetModel() != mdl:lower() ) then
+		self:MakeGhostEntity( mdl, vector_origin, angle_zero )
+	end
+
+	self:UpdateGhostLamp( self.GhostEntity, self:GetOwner() )
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.lamp.desc" )
+	CPanel:ToolPresets( "lamp", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.lamp.key", "lamp_key" )
+
+	CPanel:NumSlider( "#tool.lamp.fov", "lamp_fov", 10, 170 )
+	CPanel:NumSlider( "#tool.lamp.distance", "lamp_distance", 64, 2048 )
+	CPanel:NumSlider( "#tool.lamp.brightness", "lamp_brightness", 0, 8 )
+
+	CPanel:CheckBox( "#tool.lamp.toggle", "lamp_toggle" )
+
+	CPanel:ColorPicker( "#tool.lamp.color", "lamp_r", "lamp_g", "lamp_b" )
+
+	local MatSelect = CPanel:MatSelect( "lamp_texture", nil, false, 0.33, 0.33 )
+	MatSelect.Height = 4
+	for k, v in pairs( list.Get( "LampTextures" ) ) do
+		MatSelect:AddMaterial( v.Name or k, k )
+	end
+
+	CPanel:PropSelect( "#tool.lamp.model", "lamp_model", list.Get( "LampModels" ), 0 )
+
+end
+
+list.Set( "LampTextures", "effects/flashlight001", { Name = "#lamptexture.default" } )
+list.Set( "LampTextures", "effects/flashlight/slit", { Name = "#lamptexture.slit" } )
+list.Set( "LampTextures", "effects/flashlight/circles", { Name = "#lamptexture.circles" } )
+list.Set( "LampTextures", "effects/flashlight/window", { Name = "#lamptexture.window" } )
+list.Set( "LampTextures", "effects/flashlight/logo", { Name = "#lamptexture.logo" } )
+list.Set( "LampTextures", "effects/flashlight/gradient", { Name = "#lamptexture.gradient" } )
+list.Set( "LampTextures", "effects/flashlight/bars", { Name = "#lamptexture.bars" } )
+list.Set( "LampTextures", "effects/flashlight/tech", { Name = "#lamptexture.techdemo" } )
+list.Set( "LampTextures", "effects/flashlight/soft", { Name = "#lamptexture.soft" } )
+list.Set( "LampTextures", "effects/flashlight/hard", { Name = "#lamptexture.hard" } )
+list.Set( "LampTextures", "effects/flashlight/caustics", { Name = "#lamptexture.caustics" } )
+list.Set( "LampTextures", "effects/flashlight/square", { Name = "#lamptexture.square" } )
+list.Set( "LampTextures", "effects/flashlight/camera", { Name = "#lamptexture.camera" } )
+list.Set( "LampTextures", "effects/flashlight/view", { Name = "#lamptexture.view" } )
+
+list.Set( "LampModels", "models/lamps/torch.mdl", {} )
+list.Set( "LampModels", "models/maxofs2d/lamp_flashlight.mdl", { Offset = Vector( 8.5, 0, 0 ) } )
+list.Set( "LampModels", "models/maxofs2d/lamp_projector.mdl", { Offset = Vector( 8.5, 0, 0 ) } )
+list.Set( "LampModels", "models/props_wasteland/light_spotlight01_lamp.mdl", { Offset = Vector( 9, 0, 4 ), Skin = 1, Scale = 3 } )
+list.Set( "LampModels", "models/props_wasteland/light_spotlight02_lamp.mdl", { Offset = Vector( 5.5, 0, 0 ), Skin = 1 } )
+list.Set( "LampModels", "models/props_c17/light_decklight01_off.mdl", { Offset = Vector( 3, 0, 0 ), Skin = 1, Scale = 3 } )
+list.Set( "LampModels", "models/props_wasteland/prison_lamp001c.mdl", { Offset = Vector( 0, 0, -5 ), Angle = Angle( 90, 0, 0 ) } )
+
+-- This works, but the ghost entity is invisible due to $alphatest...
+--list.Set( "LampModels", "models/props_c17/lamp_standard_off01.mdl", { Offset = Vector( 5.20, 0.25, 8 ), Angle = Angle( 90, 0, 0 ), NearZ = 6 } )

gamemodes/sandbox/entities/weapons/gmod_tool/stools/leafblower.lua

@@ -0,0 +1,37 @@
+
+TOOL.AddToMenu = false
+
+--
+-- This tool is the most important aspect of Garry's Mod
+--
+
+TOOL.LeftClickAutomatic = true
+
+function TOOL:LeftClick( trace )
+
+	if ( CLIENT ) then return end
+
+	util.PrecacheSound( "ambient/wind/wind_hit2.wav" )
+	self:GetOwner():EmitSound( "ambient/wind/wind_hit2.wav" )
+
+	if ( IsValid( trace.Entity ) and IsValid( trace.Entity:GetPhysicsObject() ) ) then
+
+		local phys = trace.Entity:GetPhysicsObject()	-- The physics object
+		local direction = trace.StartPos - trace.HitPos	-- The direction of the force
+		local force = 32								-- The ideal amount of force
+		local distance = direction:Length()				-- The distance the phys object is from the gun
+		local maxdistance = 512							-- The max distance the gun should reach
+
+		-- Lessen the force from a distance
+		local ratio = math.Clamp( 1 - ( distance / maxdistance ), 0, 1 )
+
+		-- Set up the 'real' force and the offset of the force
+		local vForce = -direction * ( force * ratio )
+		local vOffset = trace.HitPos
+
+		-- Apply it!
+		phys:ApplyForceOffset( vForce, vOffset )
+
+	end
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/light.lua

@@ -0,0 +1,232 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.light.name"
+
+TOOL.ClientConVar[ "ropelength" ] = "64"
+TOOL.ClientConVar[ "ropematerial" ] = "cable/rope"
+TOOL.ClientConVar[ "r" ] = "255"
+TOOL.ClientConVar[ "g" ] = "255"
+TOOL.ClientConVar[ "b" ] = "255"
+TOOL.ClientConVar[ "brightness" ] = "2"
+TOOL.ClientConVar[ "size" ] = "256"
+TOOL.ClientConVar[ "key" ] = "37"
+TOOL.ClientConVar[ "toggle" ] = "1"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" }
+}
+
+cleanup.Register( "lights" )
+
+function TOOL:LeftClick( trace, attach )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+	if ( attach == nil ) then attach = true end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && attach && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local ply = self:GetOwner()
+
+	local pos, ang = trace.HitPos + trace.HitNormal * 8, trace.HitNormal:Angle() - Angle( 90, 0, 0 )
+
+	local r = math.Clamp( self:GetClientNumber( "r" ), 0, 255 )
+	local g = math.Clamp( self:GetClientNumber( "g" ), 0, 255 )
+	local b = math.Clamp( self:GetClientNumber( "b" ), 0, 255 )
+	local brght = math.Clamp( self:GetClientNumber( "brightness" ), -10, 20 )
+	local size = self:GetClientNumber( "size" )
+	local toggle = self:GetClientNumber( "toggle" ) != 1
+
+	local key = self:GetClientNumber( "key" )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:GetClass() == "gmod_light" && trace.Entity:GetPlayer() == ply ) then
+
+		trace.Entity:SetColor( Color( r, g, b, 255 ) )
+		trace.Entity.r = r
+		trace.Entity.g = g
+		trace.Entity.b = b
+		trace.Entity.Brightness = brght
+		trace.Entity.Size = size
+
+		trace.Entity:SetBrightness( brght )
+		trace.Entity:SetLightSize( size )
+		trace.Entity:SetToggle( !toggle )
+
+		trace.Entity.KeyDown = key
+
+		numpad.Remove( trace.Entity.NumDown )
+		numpad.Remove( trace.Entity.NumUp )
+
+		trace.Entity.NumDown = numpad.OnDown( ply, key, "LightToggle", trace.Entity, 1 )
+		trace.Entity.NumUp = numpad.OnUp( ply, key, "LightToggle", trace.Entity, 0 )
+
+		return true
+
+	end
+
+	if ( !self:GetWeapon():CheckLimit( "lights" ) ) then return false end
+
+	local light = MakeLight( ply, r, g, b, brght, size, toggle, !toggle, key, { Pos = pos, Angle = ang } )
+	if ( !IsValid( light ) ) then return false end
+
+	undo.Create( "gmod_light" )
+		undo.AddEntity( light )
+
+		if ( attach ) then
+
+			local length = math.Clamp( self:GetClientNumber( "ropelength" ), 4, 1024 )
+			local material = self:GetClientInfo( "ropematerial" )
+
+			local LPos1 = Vector( 0, 0, 6.5 )
+			local LPos2 = trace.Entity:WorldToLocal( trace.HitPos )
+
+			if ( IsValid( trace.Entity ) ) then
+
+				local phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+				if ( IsValid( phys ) ) then
+					LPos2 = phys:WorldToLocal( trace.HitPos )
+				end
+
+			end
+
+			local constr, rope = constraint.Rope( light, trace.Entity, 0, trace.PhysicsBone, LPos1, LPos2, 0, length, 0, 1, material )
+			if ( IsValid( constr ) ) then
+				undo.AddEntity( constr )
+				ply:AddCleanup( "lights", constr )
+			end
+			if ( IsValid( rope ) ) then
+				undo.AddEntity( rope )
+				ply:AddCleanup( "lights", rope )
+			end
+
+		end
+
+		undo.SetPlayer( ply )
+	undo.Finish()
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	return self:LeftClick( trace, false )
+
+end
+
+if ( SERVER ) then
+
+	function MakeLight( ply, r, g, b, brght, size, toggle, on, keyDown, Data )
+
+		if ( IsValid( ply ) && !ply:CheckLimit( "lights" ) ) then return NULL end
+
+		local light = ents.Create( "gmod_light" )
+		if ( !IsValid( light ) ) then return NULL end
+
+		duplicator.DoGeneric( light, Data )
+
+		light:SetColor( Color( r, g, b, 255 ) )
+		light:SetBrightness( brght )
+		light:SetLightSize( size )
+		light:SetToggle( !toggle )
+		light:SetOn( on )
+
+		light:Spawn()
+
+		DoPropSpawnedEffect( light )
+
+		duplicator.DoGenericPhysics( light, ply, Data )
+
+		light:SetPlayer( ply )
+
+		light.lightr = r
+		light.lightg = g
+		light.lightb = b
+		light.Brightness = brght
+		light.Size = size
+		light.KeyDown = keyDown
+		light.on = on
+
+		light.NumDown = numpad.OnDown( ply, keyDown, "LightToggle", light, 1 )
+		light.NumUp = numpad.OnUp( ply, keyDown, "LightToggle", light, 0 )
+
+		if ( IsValid( ply ) ) then
+			ply:AddCount( "lights", light )
+			ply:AddCleanup( "lights", light )
+		end
+
+		return light
+
+	end
+	duplicator.RegisterEntityClass( "gmod_light", MakeLight, "lightr", "lightg", "lightb", "Brightness", "Size", "Toggle", "on", "KeyDown", "Data" )
+
+	local function Toggle( ply, ent, onoff )
+
+		if ( !IsValid( ent ) ) then return false end
+		if ( !ent:GetToggle() ) then ent:SetOn( onoff == 1 ) return end
+
+		if ( numpad.FromButton() ) then
+
+			ent:SetOn( onoff == 1 )
+			return
+
+		end
+
+		if ( onoff == 0 ) then return end
+
+		return ent:Toggle()
+
+	end
+	numpad.Register( "LightToggle", Toggle )
+
+end
+
+function TOOL:UpdateGhostLight( ent, ply )
+
+	if ( !IsValid( ent ) ) then return end
+
+	local trace = ply:GetEyeTrace()
+	if ( !trace.Hit || IsValid( trace.Entity ) && ( trace.Entity:IsPlayer() || trace.Entity:GetClass() == "gmod_light" ) ) then
+
+		ent:SetNoDraw( true )
+		return
+
+	end
+
+	ent:SetPos( trace.HitPos + trace.HitNormal * 8 )
+	ent:SetAngles( trace.HitNormal:Angle() - Angle( 90, 0, 0 ) )
+
+	ent:SetNoDraw( false )
+
+end
+
+function TOOL:Think()
+
+	if ( !IsValid( self.GhostEntity ) || self.GhostEntity:GetModel() != "models/maxofs2d/light_tubular.mdl" ) then
+		self:MakeGhostEntity( "models/maxofs2d/light_tubular.mdl", vector_origin, angle_zero )
+	end
+
+	self:UpdateGhostLight( self.GhostEntity, self:GetOwner() )
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.light.desc" )
+	CPanel:ToolPresets( "light", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.light.key", "light_key" )
+
+	CPanel:NumSlider( "#tool.light.ropelength", "light_ropelength", 0, 256 )
+	CPanel:NumSlider( "#tool.light.brightness", "light_brightness", -6, 6, 0 )
+	CPanel:NumSlider( "#tool.light.size", "light_size", 0, 1024 )
+
+	CPanel:CheckBox( "#tool.light.toggle", "light_toggle" )
+
+	CPanel:ColorPicker( "#tool.light.color", "light_r", "light_g", "light_b" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/material.lua

@@ -0,0 +1,156 @@
+
+TOOL.Category = "Render"
+TOOL.Name = "#tool.material.name"
+
+TOOL.ClientConVar[ "override" ] = "debug/env_cubemap_model"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" },
+	{ name = "reload" }
+}
+
+--
+-- Duplicator function
+--
+local function SetMaterial( Player, Entity, Data )
+
+	if ( SERVER ) then
+
+		--
+		-- Make sure this is in the 'allowed' list in multiplayer - to stop people using exploits
+		--
+		if ( !game.SinglePlayer() && !list.Contains( "OverrideMaterials", Data.MaterialOverride ) && Data.MaterialOverride != "" ) then return end
+
+		Entity:SetMaterial( Data.MaterialOverride )
+		duplicator.StoreEntityModifier( Entity, "material", Data )
+	end
+
+	return true
+
+end
+if ( SERVER ) then
+	duplicator.RegisterEntityModifier( "material", SetMaterial )
+end
+
+-- Left click applies the current material
+function TOOL:LeftClick( trace )
+
+	local ent = trace.Entity
+	if ( IsValid( ent.AttachedEntity ) ) then ent = ent.AttachedEntity end
+	if ( !IsValid( ent ) ) then return false end -- The entity is valid and isn't worldspawn
+	if ( CLIENT ) then return true end
+
+	local mat = self:GetClientInfo( "override" )
+	SetMaterial( self:GetOwner(), ent, { MaterialOverride = mat } )
+	return true
+
+end
+
+-- Right click copies the material
+function TOOL:RightClick( trace )
+
+	local ent = trace.Entity
+	if ( IsValid( ent.AttachedEntity ) ) then ent = ent.AttachedEntity end
+	if ( !IsValid( ent ) ) then return false end -- The entity is valid and isn't worldspawn
+	if ( CLIENT ) then return true end
+
+	self:GetOwner():ConCommand( "material_override " .. ent:GetMaterial() )
+
+	return true
+
+end
+
+-- Reload reverts the material
+function TOOL:Reload( trace )
+
+	local ent = trace.Entity
+	if ( IsValid( ent.AttachedEntity ) ) then ent = ent.AttachedEntity end
+	if ( !IsValid( ent ) ) then return false end -- The entity is valid and isn't worldspawn
+	if ( CLIENT ) then return true end
+
+	SetMaterial( self:GetOwner(), ent, { MaterialOverride = "" } )
+	return true
+
+end
+
+list.Add( "OverrideMaterials", "models/wireframe" )
+list.Add( "OverrideMaterials", "debug/env_cubemap_model" )
+list.Add( "OverrideMaterials", "models/shadertest/shader3" )
+list.Add( "OverrideMaterials", "models/shadertest/shader4" )
+list.Add( "OverrideMaterials", "models/shadertest/shader5" )
+list.Add( "OverrideMaterials", "models/shiny" )
+list.Add( "OverrideMaterials", "models/debug/debugwhite" )
+list.Add( "OverrideMaterials", "Models/effects/comball_sphere" )
+list.Add( "OverrideMaterials", "Models/effects/comball_tape" )
+list.Add( "OverrideMaterials", "Models/effects/splodearc_sheet" )
+list.Add( "OverrideMaterials", "Models/effects/vol_light001" )
+list.Add( "OverrideMaterials", "models/props_combine/stasisshield_sheet" )
+list.Add( "OverrideMaterials", "models/props_combine/portalball001_sheet" )
+list.Add( "OverrideMaterials", "models/props_combine/com_shield001a" )
+list.Add( "OverrideMaterials", "models/props_c17/frostedglass_01a" )
+list.Add( "OverrideMaterials", "models/props_lab/Tank_Glass001" )
+list.Add( "OverrideMaterials", "models/props_combine/tprings_globe" )
+list.Add( "OverrideMaterials", "models/rendertarget" )
+list.Add( "OverrideMaterials", "models/screenspace" )
+list.Add( "OverrideMaterials", "brick/brick_model" )
+list.Add( "OverrideMaterials", "models/props_pipes/GutterMetal01a" )
+list.Add( "OverrideMaterials", "models/props_pipes/Pipesystem01a_skin3" )
+list.Add( "OverrideMaterials", "models/props_wasteland/wood_fence01a" )
+list.Add( "OverrideMaterials", "models/props_foliage/tree_deciduous_01a_trunk" )
+list.Add( "OverrideMaterials", "models/props_c17/FurnitureFabric003a" )
+list.Add( "OverrideMaterials", "models/props_c17/FurnitureMetal001a" )
+list.Add( "OverrideMaterials", "models/props_c17/paper01" )
+list.Add( "OverrideMaterials", "models/flesh" )
+
+-- phx
+list.Add( "OverrideMaterials", "phoenix_storms/metalset_1-2" )
+list.Add( "OverrideMaterials", "phoenix_storms/metalfloor_2-3" )
+list.Add( "OverrideMaterials", "phoenix_storms/plastic" )
+list.Add( "OverrideMaterials", "phoenix_storms/wood" )
+list.Add( "OverrideMaterials", "phoenix_storms/bluemetal" )
+list.Add( "OverrideMaterials", "phoenix_storms/cube" )
+list.Add( "OverrideMaterials", "phoenix_storms/dome" )
+list.Add( "OverrideMaterials", "phoenix_storms/gear" )
+list.Add( "OverrideMaterials", "phoenix_storms/stripes" )
+list.Add( "OverrideMaterials", "phoenix_storms/wire/pcb_green" )
+list.Add( "OverrideMaterials", "phoenix_storms/wire/pcb_red" )
+list.Add( "OverrideMaterials", "phoenix_storms/wire/pcb_blue" )
+
+list.Add( "OverrideMaterials", "hunter/myplastic" )
+list.Add( "OverrideMaterials", "models/XQM/LightLinesRed_tool" )
+
+if ( IsMounted( "tf" ) ) then
+	list.Add( "OverrideMaterials", "models/player/shared/gold_player" )
+	list.Add( "OverrideMaterials", "models/player/shared/ice_player" )
+end
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.material.help" )
+
+	local filter = CPanel:TextEntry( "#spawnmenu.quick_filter_tool" )
+	filter:SetUpdateOnType( true )
+
+	-- Remove duplicate materials. table.HasValue is used to preserve material order
+	local materials = {}
+	for id, str in ipairs( list.Get( "OverrideMaterials" ) ) do
+		if ( !table.HasValue( materials, str ) ) then
+			table.insert( materials, str )
+		end
+	end
+
+	local matlist = CPanel:MatSelect( "material_override", materials, true, 0.25, 0.25 )
+
+	filter.OnValueChange = function( s, txt )
+		for id, pnl in ipairs( matlist.Controls ) do
+			if ( !pnl.Value:lower():find( txt:lower(), nil, true ) ) then
+				pnl:SetVisible( false )
+			else
+				pnl:SetVisible( true )
+			end
+		end
+		matlist:InvalidateChildren()
+		CPanel:InvalidateChildren()
+	end
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/motor.lua

@@ -0,0 +1,168 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.motor.name"
+
+TOOL.ClientConVar[ "torque" ] = "500"
+TOOL.ClientConVar[ "friction" ] = "1"
+TOOL.ClientConVar[ "nocollide" ] = "1"
+TOOL.ClientConVar[ "forcetime" ] = "0"
+TOOL.ClientConVar[ "fwd" ] = "45"
+TOOL.ClientConVar[ "bwd" ] = "42"
+TOOL.ClientConVar[ "toggle" ] = "0"
+TOOL.ClientConVar[ "forcelimit" ] = "0"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1 },
+	{ name = "reload"}
+}
+
+function TOOL:LeftClick( trace )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+
+	-- Don't allow us to choose the world as the first object
+	if ( iNum == 0 && !IsValid( trace.Entity ) ) then return end
+
+	-- Don't allow us to choose the same object
+	if ( iNum == 1 && trace.Entity == self:GetEnt( 1 ) ) then return end
+
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	if ( iNum > 0 ) then
+
+		if ( CLIENT ) then
+			self:ClearObjects()
+			self:ReleaseGhostEntity()
+
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "constraints" ) ) then
+			self:ClearObjects()
+			self:ReleaseGhostEntity()
+			return false
+		end
+
+		-- Get client's CVars
+		local torque = self:GetClientNumber( "torque" )
+		local friction = self:GetClientNumber( "friction" )
+		local nocollide = self:GetClientNumber( "nocollide" )
+		local time = self:GetClientNumber( "forcetime" )
+		local forekey = self:GetClientNumber( "fwd" )
+		local backkey = self:GetClientNumber( "bwd" )
+		local toggle = self:GetClientNumber( "toggle" ) != 0
+		local limit = self:GetClientNumber( "forcelimit" )
+
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+		local Norm1, Norm2 = self:GetNormal( 1 ), self:GetNormal( 2 )
+		local Phys1 = self:GetPhys( 1 )
+		local WPos2 = self:GetPos( 2 )
+
+		-- Note: To keep stuff ragdoll friendly try to treat things as physics objects rather than entities
+		local Ang1, Ang2 = Norm1:Angle(), ( -Norm2 ):Angle()
+		local TargetAngle = Phys1:AlignAngles( Ang1, Ang2 )
+
+		Phys1:SetAngles( TargetAngle )
+
+		-- Move the object so that the hitpos on our object is at the second hitpos
+		local TargetPos = WPos2 + ( Phys1:GetPos() - self:GetPos( 1 ) ) + ( Norm2 * 0.2 )
+
+		-- Set the position
+		Phys1:SetPos( TargetPos )
+
+		-- Wake up the physics object so that the entity updates
+		Phys1:Wake()
+
+		-- Set the hinge Axis perpendicular to the trace hit surface
+		LPos1 = Phys1:WorldToLocal( WPos2 + Norm2 * 64 )
+
+		local constr, axis = constraint.Motor( Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, friction, torque, time, nocollide, toggle, ply, limit, forekey, backkey, 1 )
+		if ( IsValid( constr ) ) then
+			undo.Create( "Motor" )
+				undo.AddEntity( constr )
+				if ( IsValid( axis ) ) then undo.AddEntity( axis ) end
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.motor.name" )
+			undo.Finish( "#tool.motor.name" )
+
+			ply:AddCount( "constraints", constr )
+			ply:AddCleanup( "constraints", constr )
+			if ( IsValid( axis ) ) then ply:AddCleanup( "constraints", axis ) end
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+		self:ReleaseGhostEntity()
+
+	else
+
+		self:StartGhostEntity( trace.Entity )
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "Motor" )
+
+end
+
+function TOOL:Think()
+
+	if ( self:NumObjects() != 1 ) then return end
+
+	self:UpdateGhostEntity()
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.motor.help" )
+	CPanel:ToolPresets( "motor", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.motor.numpad1", "motor_fwd", "#tool.motor.numpad2", "motor_bwd" )
+
+	CPanel:NumSlider( "#tool.motor.torque", "motor_torque", 0, 10000 )
+
+	CPanel:NumSlider( "#tool.forcelimit", "motor_forcelimit", 0, 50000 )
+	CPanel:ControlHelp( "#tool.forcelimit.help" )
+
+	CPanel:NumSlider( "#tool.hingefriction", "motor_friction", 0, 100 )
+	CPanel:ControlHelp( "#tool.hingefriction.help" )
+
+	CPanel:NumSlider( "#tool.motor.forcetime", "motor_forcetime", 0, 120 )
+	CPanel:ControlHelp( "#tool.motor.forcetime.help" )
+
+	CPanel:CheckBox( "#tool.nocollide", "motor_nocollide" )
+	CPanel:ControlHelp( "#tool.nocollide.help" )
+
+	CPanel:CheckBox( "#tool.toggle", "motor_toggle" )
+	CPanel:ControlHelp( "#tool.toggle.help" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/muscle.lua

@@ -0,0 +1,267 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.muscle.name"
+
+TOOL.ClientConVar[ "group" ] = "37"
+TOOL.ClientConVar[ "width" ] = "2"
+TOOL.ClientConVar[ "addlength" ] = "100"
+TOOL.ClientConVar[ "fixed" ] = "1"
+TOOL.ClientConVar[ "period" ] = "1"
+TOOL.ClientConVar[ "material" ] = "cable/rope"
+TOOL.ClientConVar[ "starton" ] = "0"
+TOOL.ClientConVar[ "color_r" ] = "255"
+TOOL.ClientConVar[ "color_g" ] = "255"
+TOOL.ClientConVar[ "color_b" ] = "255"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1, op = 1 },
+	{ name = "right", stage = 0 },
+	{ name = "reload" }
+}
+
+function TOOL:LeftClick( trace )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+	self:SetOperation( 1 )
+
+	if ( iNum > 0 ) then
+
+		if ( CLIENT ) then
+			self:ClearObjects()
+			return true
+		end
+
+		if ( ( !IsValid( self:GetEnt( 1 ) ) && !IsValid( self:GetEnt( 2 ) ) ) || iNum > 1 ) then
+
+			self:ClearObjects()
+			return true
+
+		end
+
+		-- Get client's CVars
+		local width = self:GetClientNumber( "width", 3 )
+		local bind = self:GetClientNumber( "group", 1 )
+		local AddLength = self:GetClientNumber( "addlength", 0 )
+		local fixed = self:GetClientNumber( "fixed", 1 )
+		local period = self:GetClientNumber( "period", 1 )
+		local starton = self:GetClientNumber( "starton" ) == 1
+		local material = self:GetClientInfo( "material" )
+		local colorR = self:GetClientNumber( "color_r" )
+		local colorG = self:GetClientNumber( "color_g" )
+		local colorB = self:GetClientNumber( "color_b" )
+
+		-- If AddLength is 0 then what's the point.
+		if ( AddLength == 0 ) then
+			self:ClearObjects()
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		if ( period <= 0 ) then period = 0.1 end
+
+		AddLength = math.Clamp( AddLength, -1000, 1000 )
+
+		-- Get information we're about to use
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+		local WPos1, WPos2 = self:GetPos( 1 ), self:GetPos( 2 )
+
+		local Length1 = ( WPos1 - WPos2 ):Length()
+		local Length2 = Length1 + AddLength
+
+		local amp = Length2 - Length1
+
+		local constr, rope, controller, slider = constraint.Muscle( ply, Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, Length1, Length2, width, bind, fixed, period, amp, starton, material, Color( colorR, colorG, colorB, 255 ) )
+		if ( IsValid( constr ) ) then
+			undo.Create( "Muscle" )
+				undo.AddEntity( constr )
+				if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+				if ( IsValid( slider ) ) then undo.AddEntity( slider ) end
+				if ( IsValid( controller ) ) then undo.AddEntity( controller ) end
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.muscle.name" )
+			undo.Finish( "#tool.muscle.name" )
+
+			ply:AddCount( "ropeconstraints", constr )
+			ply:AddCleanup( "ropeconstraints", constr )
+			if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+			if ( IsValid( slider ) ) then ply:AddCleanup( "ropeconstraints", slider ) end
+			if ( IsValid( controller ) ) then ply:AddCleanup( "ropeconstraints", controller ) end
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	if ( self:GetOperation() == 1 ) then return false end
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	local ply = self:GetOwner()
+
+	local tr_new = {}
+	tr_new.start = trace.HitPos
+	tr_new.endpos = trace.HitPos + ( trace.HitNormal * 16384 )
+	tr_new.filter = { ply }
+	if ( IsValid( trace.Entity ) ) then
+		table.insert( tr_new.filter, trace.Entity )
+	end
+
+	local tr = util.TraceLine( tr_new )
+	if ( !tr.Hit ) then
+		self:ClearObjects()
+		return false
+	end
+
+	-- Don't try to constrain world to world
+	if ( trace.HitWorld && tr.HitWorld ) then
+		self:ClearObjects()
+		return false
+	end
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then
+		self:ClearObjects()
+		return false
+	end
+	if ( IsValid( tr.Entity ) && tr.Entity:IsPlayer() ) then
+		self:ClearObjects()
+		return false
+	end
+
+	-- Check to see if the player can create a muscle constraint with the entity in the trace
+	if ( !hook.Run( "CanTool", ply, tr, "muscle", self, 2 ) ) then
+		self:ClearObjects()
+		return false
+	end
+
+	local Phys2 = tr.Entity:GetPhysicsObjectNum( tr.PhysicsBone )
+	self:SetObject( 2, tr.Entity, tr.HitPos, Phys2, tr.PhysicsBone, tr.HitNormal )
+
+	if ( CLIENT ) then
+		self:ClearObjects()
+		return true
+	end
+
+	if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+		self:ClearObjects()
+		return false
+	end
+
+	-- Get client's CVars
+	local width = self:GetClientNumber( "width", 3 )
+	local bind = self:GetClientNumber( "group", 1 )
+	local AddLength = self:GetClientNumber( "addlength", 0 )
+	local fixed = self:GetClientNumber( "fixed", 1 )
+	local period = self:GetClientNumber( "period", 64 )
+	local starton = self:GetClientNumber( "starton" ) > 0
+	local material = self:GetClientInfo( "material" )
+	local colorR = self:GetClientNumber( "color_r" )
+	local colorG = self:GetClientNumber( "color_g" )
+	local colorB = self:GetClientNumber( "color_b" )
+
+	-- Get information we're about to use
+	local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+	local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+	local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+	local WPos1, WPos2 = self:GetPos( 1 ), self:GetPos( 2 )
+
+	local Length1 = ( WPos1 - WPos2 ):Length()
+	local Length2 = Length1 + AddLength
+
+	local amp = Length2 - Length1
+
+	local constr, rope, controller, slider = constraint.Muscle( ply, Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, Length1, Length2, width, bind, fixed, period, amp, starton, material, Color( colorR, colorG, colorB, 255 ) )
+	if ( IsValid( constr ) ) then
+		undo.Create( "Muscle" )
+			undo.AddEntity( constr )
+			if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+			if ( IsValid( slider ) ) then undo.AddEntity( slider ) end
+			if ( IsValid( controller ) ) then undo.AddEntity( controller ) end
+			undo.SetPlayer( ply )
+			undo.SetCustomUndoText( "Undone #tool.muscle.name" )
+		undo.Finish( "#tool.muscle.name" )
+
+		ply:AddCount( "ropeconstraints", constr )
+		ply:AddCleanup( "ropeconstraints", constr )
+		if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+		if ( IsValid( slider ) ) then ply:AddCleanup( "ropeconstraints", slider ) end
+		if ( IsValid( controller ) ) then ply:AddCleanup( "ropeconstraints", controller ) end
+	end
+
+	-- Clear the objects so we're ready to go again
+	self:ClearObjects()
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "Muscle" )
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.muscle.help" )
+	CPanel:ToolPresets( "muscle", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.muscle.numpad", "muscle_group" )
+
+	CPanel:NumSlider( "#tool.muscle.length", "muscle_addlength", -1000, 1000 )
+	CPanel:ControlHelp( "#tool.muscle.length.help" )
+
+	CPanel:NumSlider( "#tool.muscle.period", "muscle_period", 0, 10 )
+	CPanel:ControlHelp( "#tool.muscle.period.help" )
+
+	CPanel:CheckBox( "#tool.muscle.fixed", "muscle_fixed" )
+	CPanel:ControlHelp( "#tool.muscle.fixed.help" )
+
+	CPanel:CheckBox( "#tool.muscle.starton", "muscle_starton" )
+	CPanel:ControlHelp( "#tool.muscle.starton.help" )
+
+	CPanel:NumSlider( "#tool.muscle.width", "muscle_width", 0, 5 )
+
+	CPanel:RopeSelect( "muscle_material" )
+
+	CPanel:ColorPicker( "#tool.muscle.color", "muscle_color_r", "muscle_color_g", "muscle_color_b" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/nocollide.lua

@@ -0,0 +1,109 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.nocollide.name"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1 },
+	{ name = "right" },
+	{ name = "reload" }
+}
+
+cleanup.Register( "nocollide" )
+
+function TOOL:LeftClick( trace )
+
+	if ( !IsValid( trace.Entity ) ) then return end
+	if ( trace.Entity:IsPlayer() ) then return end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	if ( CLIENT ) then
+
+		if ( iNum > 0 ) then self:ClearObjects() end
+		return true
+
+	end
+
+	if ( iNum > 0 ) then
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "constraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+
+		local constr = constraint.NoCollide( Ent1, Ent2, Bone1, Bone2, true )
+		if ( IsValid( constr ) ) then
+			undo.Create( "NoCollide" )
+				undo.AddEntity( constr )
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.nocollide.name" )
+			undo.Finish( "#tool.nocollide.name" )
+
+			ply:AddCount( "constraints", constr )
+			ply:AddCleanup( "nocollide", constr )
+		end
+
+		self:ClearObjects()
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	if ( !IsValid( trace.Entity ) ) then return end
+	if ( trace.Entity:IsPlayer() ) then return end
+
+	if ( CLIENT ) then return true end
+
+	if ( trace.Entity:GetCollisionGroup() == COLLISION_GROUP_WORLD ) then
+
+		trace.Entity:SetCollisionGroup( COLLISION_GROUP_NONE )
+
+	else
+
+		trace.Entity:SetCollisionGroup( COLLISION_GROUP_WORLD )
+
+	end
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "NoCollide" )
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.nocollide.desc" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/paint.lua

@@ -0,0 +1,168 @@
+
+TOOL.Category = "Render"
+TOOL.Name = "#tool.paint.name"
+
+TOOL.LeftClickAutomatic = true
+TOOL.RightClickAutomatic = true
+TOOL.RequiresTraceHit = true
+
+TOOL.ClientConVar[ "decal" ] = "Blood"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" },
+	{ name = "reload" }
+}
+
+local function PlaceDecal( ply, ent, data )
+
+	if ( !IsValid( ent ) && !ent:IsWorld() ) then return end
+	if ( CLIENT ) then return end
+
+	local bone
+	if ( data.bone && data.bone < ent:GetPhysicsObjectCount() ) then bone = ent:GetPhysicsObjectNum( data.bone ) end
+	if ( !IsValid( bone ) ) then bone = ent:GetPhysicsObject() end
+	if ( !IsValid( bone ) ) then bone = ent end
+
+	util.Decal( data.decal, bone:LocalToWorld( data.Pos1 ), bone:LocalToWorld( data.Pos2 ), ply )
+
+	local i = ent.DecalCount or 0
+	i = i + 1
+	duplicator.StoreEntityModifier( ent, "decal" .. i, data )
+	ent.DecalCount = i
+
+end
+
+--
+-- Register decal duplicator
+--
+if ( SERVER ) then
+	for i = 1, 32 do
+
+		duplicator.RegisterEntityModifier( "decal" .. i, function( ply, ent, data )
+			timer.Simple( i * 0.05, function() PlaceDecal( ply, ent, data ) end )
+		end )
+
+	end
+end
+
+function TOOL:Reload( trace )
+	if ( !IsValid( trace.Entity ) ) then return false end
+
+	trace.Entity:RemoveAllDecals()
+
+	if ( SERVER ) then
+		for i = 1, 32 do
+			duplicator.ClearEntityModifier( trace.Entity, "decal" .. i )
+		end
+		trace.Entity.DecalCount = nil
+	end
+
+	return true
+end
+
+function TOOL:LeftClick( trace )
+
+	return self:RightClick( trace, true )
+
+end
+
+function TOOL:RightClick( trace, bNoDelay )
+
+	self:GetWeapon():EmitSound( "SprayCan.Paint" )
+	local decal = self:GetClientInfo( "decal" )
+
+	local Pos1 = trace.HitPos + trace.HitNormal
+	local Pos2 = trace.HitPos - trace.HitNormal
+
+	local Bone
+	if ( trace.PhysicsBone && trace.PhysicsBone < trace.Entity:GetPhysicsObjectCount() ) then Bone = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone ) end
+	if ( !IsValid( Bone ) ) then Bone = trace.Entity:GetPhysicsObject() end
+	if ( !IsValid( Bone ) ) then Bone = trace.Entity end
+
+	Pos1 = Bone:WorldToLocal( Pos1 )
+	Pos2 = Bone:WorldToLocal( Pos2 )
+
+	PlaceDecal( self:GetOwner(), trace.Entity, { Pos1 = Pos1, Pos2 = Pos2, bone = trace.PhysicsBone, decal = decal } )
+
+	if ( bNoDelay ) then
+		self:GetWeapon():SetNextPrimaryFire( CurTime() + 0.05 )
+		self:GetWeapon():SetNextSecondaryFire( CurTime() + 0.05 )
+	else
+		self:GetWeapon():SetNextPrimaryFire( CurTime() + 0.2 )
+		self:GetWeapon():SetNextSecondaryFire( CurTime() + 0.2 )
+	end
+
+	return false
+
+end
+
+game.AddDecal( "Eye", "decals/eye" )
+game.AddDecal( "Dark", "decals/dark" )
+game.AddDecal( "Smile", "decals/smile" )
+game.AddDecal( "Light", "decals/light" )
+game.AddDecal( "Cross", "decals/cross" )
+game.AddDecal( "Nought", "decals/nought" )
+game.AddDecal( "Noughtsncrosses", "decals/noughtsncrosses" )
+
+list.Add( "PaintMaterials", "Eye" )
+list.Add( "PaintMaterials", "Smile" )
+list.Add( "PaintMaterials", "Light" )
+list.Add( "PaintMaterials", "Dark" )
+list.Add( "PaintMaterials", "Blood" )
+list.Add( "PaintMaterials", "YellowBlood" )
+list.Add( "PaintMaterials", "Impact.Metal" )
+list.Add( "PaintMaterials", "Scorch" )
+list.Add( "PaintMaterials", "BeerSplash" )
+list.Add( "PaintMaterials", "ExplosiveGunshot" )
+list.Add( "PaintMaterials", "BirdPoop" )
+list.Add( "PaintMaterials", "PaintSplatPink" )
+list.Add( "PaintMaterials", "PaintSplatGreen" )
+list.Add( "PaintMaterials", "PaintSplatBlue" )
+list.Add( "PaintMaterials", "ManhackCut" )
+list.Add( "PaintMaterials", "FadingScorch" )
+list.Add( "PaintMaterials", "Antlion.Splat" )
+list.Add( "PaintMaterials", "Splash.Large" )
+list.Add( "PaintMaterials", "BulletProof" )
+list.Add( "PaintMaterials", "GlassBreak" )
+list.Add( "PaintMaterials", "Impact.Sand" )
+list.Add( "PaintMaterials", "Impact.BloodyFlesh" )
+list.Add( "PaintMaterials", "Impact.Antlion" )
+list.Add( "PaintMaterials", "Impact.Glass" )
+list.Add( "PaintMaterials", "Impact.Wood" )
+list.Add( "PaintMaterials", "Impact.Concrete" )
+list.Add( "PaintMaterials", "Noughtsncrosses" )
+list.Add( "PaintMaterials", "Nought" )
+list.Add( "PaintMaterials", "Cross" )
+
+function TOOL.BuildCPanel( CPanel )
+
+	-- Remove duplicates.
+	local Options = {}
+	for id, str in ipairs( list.Get( "PaintMaterials" ) ) do
+		if ( !table.HasValue( Options, str ) ) then
+			table.insert( Options, str )
+		end
+	end
+
+	table.sort( Options )
+
+	local listbox = vgui.Create( "DListView" )
+	listbox:SetMultiSelect( false )
+	listbox:AddColumn( "#tool.paint.texture" )
+	listbox:SetTall( 17 + table.Count( Options ) * 17 )
+	listbox:SortByColumn( 1, false )
+	function listbox:OnRowSelected( LineID, Line )
+		for k, v in pairs( Line.data ) do
+			RunConsoleCommand( k, v )
+		end
+	end
+	for k, decal in ipairs( Options ) do
+		local line = listbox:AddLine( decal )
+		line.data = { paint_decal = decal, gmod_tool = "paint" }
+
+		if ( GetConVarString( "paint_decal" ) == tostring( decal ) ) then line:SetSelected( true ) end
+	end
+	CPanel:AddItem( listbox )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/physprop.lua

@@ -0,0 +1,63 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.physprop.name"
+
+TOOL.ClientConVar[ "gravity_toggle" ] = "1"
+TOOL.ClientConVar[ "material" ] = "metal_bouncy"
+
+TOOL.Information = { { name = "left" } }
+
+function TOOL:LeftClick( trace )
+
+	if ( !IsValid( trace.Entity ) ) then return false end
+	if ( trace.Entity:IsPlayer() || trace.Entity:IsWorld() ) then return false end
+
+	-- Make sure there's a physics object to manipulate
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	-- Client can bail out here and assume we're going ahead
+	if ( CLIENT ) then return true end
+
+	-- Get the entity/bone from the trace
+	local ent = trace.Entity
+	local Bone = trace.PhysicsBone
+
+	-- Get client's CVars
+	local gravity = self:GetClientNumber( "gravity_toggle" ) == 1
+	local material = self:GetClientInfo( "material" )
+
+	-- Set the properties
+
+	construct.SetPhysProp( self:GetOwner(), ent, Bone, nil, { GravityToggle = gravity, Material = material } )
+
+	DoPropSpawnedEffect( ent )
+
+	return true
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:ToolPresets( "physprop", ConVarsDefault )
+
+	CPanel:ComboBoxMulti( "#tool.physprop.material", list.Get( "PhysicsMaterials" ) )
+
+	CPanel:CheckBox( "#tool.physprop.gravity", "physprop_gravity_toggle" )
+
+end
+
+list.Set( "PhysicsMaterials", "#physprop.metalbouncy", { physprop_material = "metal_bouncy" } )
+list.Set( "PhysicsMaterials", "#physprop.metal", { physprop_material = "metal" } )
+list.Set( "PhysicsMaterials", "#physprop.dirt", { physprop_material = "dirt" } )
+list.Set( "PhysicsMaterials", "#physprop.slime", { physprop_material = "slipperyslime" } )
+list.Set( "PhysicsMaterials", "#physprop.wood", { physprop_material = "wood" } )
+list.Set( "PhysicsMaterials", "#physprop.glass", { physprop_material = "glass" } )
+list.Set( "PhysicsMaterials", "#physprop.concrete", { physprop_material = "concrete_block" } )
+list.Set( "PhysicsMaterials", "#physprop.ice", { physprop_material = "ice" } )
+list.Set( "PhysicsMaterials", "#physprop.rubber", { physprop_material = "rubber" } )
+list.Set( "PhysicsMaterials", "#physprop.paper", { physprop_material = "paper" } )
+list.Set( "PhysicsMaterials", "#physprop.flesh", { physprop_material = "zombieflesh" } )
+list.Set( "PhysicsMaterials", "#physprop.superice", { physprop_material = "gmod_ice" } )
+list.Set( "PhysicsMaterials", "#physprop.superbouncy", { physprop_material = "gmod_bouncy" } )

gamemodes/sandbox/entities/weapons/gmod_tool/stools/pulley.lua

@@ -0,0 +1,126 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.pulley.name"
+
+TOOL.ClientConVar[ "width" ] = "3"
+TOOL.ClientConVar[ "forcelimit" ] = "0"
+TOOL.ClientConVar[ "rigid" ] = "0"
+TOOL.ClientConVar[ "material" ] = "cable/cable"
+TOOL.ClientConVar[ "color_r" ] = "255"
+TOOL.ClientConVar[ "color_g" ] = "255"
+TOOL.ClientConVar[ "color_b" ] = "255"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1 },
+	{ name = "left_2", stage = 2 },
+	{ name = "left_3", stage = 3 },
+	{ name = "reload" }
+}
+
+function TOOL:LeftClick( trace )
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return false end
+	if ( !IsValid( trace.Entity ) && ( iNum == nil || iNum == 0 || iNum > 2 ) ) then return false end
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	if ( iNum > 2 ) then
+
+		if ( CLIENT ) then return true end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		local width = self:GetClientNumber( "width" )
+		local forcelimit = self:GetClientNumber( "forcelimit" )
+		local rigid = self:GetClientNumber( "rigid" ) == 1
+		local material = self:GetClientInfo( "material" )
+		local colorR = self:GetClientNumber( "color_r" )
+		local colorG = self:GetClientNumber( "color_g" )
+		local colorB = self:GetClientNumber( "color_b" )
+
+		-- Get information we're about to use
+		local Ent1 = self:GetEnt( 1 )
+		local Ent4 = self:GetEnt( 4 )
+		local Bone1 = self:GetBone( 1 )
+		local Bone4 = self:GetBone( 4 )
+		local LPos1 = self:GetLocalPos( 1 )
+		local LPos4 = self:GetLocalPos( 4 )
+		local WPos2 = self:GetPos( 2 )
+		local WPos3 = self:GetPos( 3 )
+
+		local constr, rope1, rope2, rope3 = constraint.Pulley( Ent1, Ent4, Bone1, Bone4, LPos1, LPos4, WPos2, WPos3, forcelimit, rigid, width, material, Color( colorR, colorG, colorB ) )
+		if ( IsValid( constr ) ) then
+			undo.Create( "Pulley" )
+				undo.AddEntity( constr )
+				if ( IsValid( rope1 ) ) then undo.AddEntity( rope1 ) end
+				if ( IsValid( rope2 ) ) then undo.AddEntity( rope2 ) end
+				if ( IsValid( rope3 ) ) then undo.AddEntity( rope3 ) end
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.pulley.name" )
+			undo.Finish( "#tool.pulley.name" )
+
+			ply:AddCount( "ropeconstraints", constr )
+			ply:AddCleanup( "ropeconstraints", constr )
+			if ( IsValid( rope1 ) ) then ply:AddCleanup( "ropeconstraints", rope1 ) end
+			if ( IsValid( rope2 ) ) then ply:AddCleanup( "ropeconstraints", rope2 ) end
+			if ( IsValid( rope3 ) ) then ply:AddCleanup( "ropeconstraints", rope3 ) end
+		end
+
+		self:ClearObjects()
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "Pulley" )
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.pulley.help" )
+	CPanel:ToolPresets( "pulley", ConVarsDefault )
+
+	CPanel:NumSlider( "#tool.forcelimit", "pulley_forcelimit", 0, 1000 )
+	CPanel:ControlHelp( "#tool.forcelimit.help" )
+
+	CPanel:CheckBox( "#tool.pulley.rigid", "pulley_rigid" )
+	CPanel:ControlHelp( "#tool.pulley.rigid.help" )
+
+	CPanel:NumSlider( "#tool.pulley.width", "pulley_width", 0, 10 )
+
+	CPanel:RopeSelect( "pulley_material" )
+
+	CPanel:ColorPicker( "#tool.pulley.color", "pulley_color_r", "pulley_color_g", "pulley_color_b" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/remover.lua

@@ -0,0 +1,103 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.remover.name"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" },
+	{ name = "reload" }
+}
+
+local function DoRemoveEntity( ent )
+
+	if ( !IsValid( ent ) || ent:IsPlayer() ) then return false end
+
+	-- Nothing for the client to do here
+	if ( CLIENT ) then return true end
+
+	-- Remove all constraints (this stops ropes from hanging around)
+	constraint.RemoveAll( ent )
+
+	-- Remove it properly in 1 second
+	timer.Simple( 1, function() if ( IsValid( ent ) ) then ent:Remove() end end )
+
+	-- Make it non solid
+	ent:SetNotSolid( true )
+	ent:SetMoveType( MOVETYPE_NONE )
+	ent:SetNoDraw( true )
+
+	-- Send Effect
+	local ed = EffectData()
+		ed:SetOrigin( ent:GetPos() )
+		ed:SetEntity( ent )
+	util.Effect( "entity_remove", ed, true, true )
+
+	return true
+
+end
+
+--
+-- Remove a single entity
+--
+function TOOL:LeftClick( trace )
+
+	if ( DoRemoveEntity( trace.Entity ) ) then
+
+		if ( !CLIENT ) then
+			self:GetOwner():SendLua( "achievements.Remover()" )
+		end
+
+		return true
+
+	end
+
+	return false
+
+end
+
+--
+-- Remove this entity and everything constrained
+--
+function TOOL:RightClick( trace )
+
+	local entity = trace.Entity
+	if ( !IsValid( entity ) || entity:IsPlayer() ) then return false end
+
+	-- Client can bail out now.
+	if ( CLIENT ) then return true end
+
+	local ConstrainedEntities = constraint.GetAllConstrainedEntities( entity )
+	local Count = 0
+
+	-- Loop through all the entities in the system
+	for _, ent in pairs( ConstrainedEntities ) do
+
+		if ( DoRemoveEntity( ent ) ) then
+			Count = Count + 1
+		end
+
+	end
+
+	self:GetOwner():SendLua( string.format( "for i=1,%i do achievements.Remover() end", Count ) )
+
+	return true
+
+end
+
+--
+-- Reload removes all constraints on the targetted entity
+--
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveAll( trace.Entity )
+
+end
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.remover.desc" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/rope.lua

@@ -0,0 +1,201 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.rope.name"
+
+TOOL.ClientConVar[ "forcelimit" ] = "0"
+TOOL.ClientConVar[ "addlength" ] = "0"
+TOOL.ClientConVar[ "material" ] = "cable/rope"
+TOOL.ClientConVar[ "width" ] = "2"
+TOOL.ClientConVar[ "rigid" ] = "0"
+TOOL.ClientConVar[ "color_r" ] = "255"
+TOOL.ClientConVar[ "color_g" ] = "255"
+TOOL.ClientConVar[ "color_b" ] = "255"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1 },
+	{ name = "right", stage = 1 },
+	{ name = "reload" }
+}
+
+function TOOL:LeftClick( trace )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	if ( iNum > 0 ) then
+
+		if ( CLIENT ) then
+			self:ClearObjects()
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		-- Get client's CVars
+		local forcelimit = self:GetClientNumber( "forcelimit" )
+		local addlength = self:GetClientNumber( "addlength" )
+		local material = self:GetClientInfo( "material" )
+		local width = self:GetClientNumber( "width" )
+		local rigid = self:GetClientNumber( "rigid" ) == 1
+
+		local colorR = self:GetClientNumber( "color_r" )
+		local colorG = self:GetClientNumber( "color_g" )
+		local colorB = self:GetClientNumber( "color_b" )
+
+		-- Get information we're about to use
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local WPos1, WPos2 = self:GetPos( 1 ), self:GetPos( 2 )
+		local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+		local length = ( WPos1 - WPos2 ):Length()
+
+		local constr, rope = constraint.Rope( Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, length, addlength, forcelimit, width, material, rigid, Color( colorR, colorG, colorB ) )
+		if ( IsValid( constr ) ) then
+			-- Add the constraint to the players undo table
+			undo.Create( "Rope" )
+				undo.AddEntity( constr )
+				if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.rope.name" )
+			undo.Finish( "#tool.rope.name" )
+
+			ply:AddCount( "ropeconstraints", constr )
+			ply:AddCleanup( "ropeconstraints", constr )
+			if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return end
+
+	local iNum = self:NumObjects()
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	if ( iNum > 0 ) then
+
+		if ( CLIENT ) then
+			self:ClearObjects()
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		-- Get client's CVars
+		local forcelimit = self:GetClientNumber( "forcelimit" )
+		local addlength = self:GetClientNumber( "addlength" )
+		local material = self:GetClientInfo( "material" )
+		local width = self:GetClientNumber( "width" )
+		local rigid = self:GetClientNumber( "rigid" ) == 1
+
+		local colorR = self:GetClientNumber( "color_r" )
+		local colorG = self:GetClientNumber( "color_g" )
+		local colorB = self:GetClientNumber( "color_b" )
+
+		-- Get information we're about to use
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local WPos1, WPos2 = self:GetPos( 1 ), self:GetPos( 2 )
+		local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+		local length = ( WPos1 - WPos2 ):Length()
+
+		local constr, rope = constraint.Rope( Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, length, addlength, forcelimit, width, material, rigid, Color( colorR, colorG, colorB ) )
+		if ( IsValid( constr ) ) then
+			-- Add the constraint to the players undo table
+			undo.Create( "Rope" )
+				undo.AddEntity( constr )
+				if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.rope.name" )
+			undo.Finish( "#tool.rope.name" )
+
+			ply:AddCount( "ropeconstraints", constr )
+			ply:AddCleanup( "ropeconstraints", constr )
+			if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+		end
+
+		-- Clear the objects and set the last object as object 1
+		self:ClearObjects()
+
+		iNum = self:NumObjects()
+		self:SetObject( iNum + 1, Ent2, trace.HitPos, Phys, Bone2, trace.HitNormal )
+		self:SetStage( iNum + 1 )
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "Rope" )
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.rope.help" )
+	CPanel:ToolPresets( "rope", ConVarsDefault )
+
+	CPanel:NumSlider( "#tool.forcelimit", "rope_forcelimit", 0, 1000 )
+	CPanel:ControlHelp( "#tool.forcelimit.help" )
+
+	CPanel:NumSlider( "#tool.rope.addlength", "rope_addlength", -500, 500 )
+	CPanel:ControlHelp( "#tool.rope.addlength.help" )
+
+	CPanel:CheckBox( "#tool.rope.rigid", "rope_rigid" )
+	CPanel:ControlHelp( "#tool.rope.rigid.help" )
+
+	CPanel:NumSlider( "#tool.rope.width", "rope_width", 0, 10 )
+
+	CPanel:RopeSelect( "rope_material" )
+
+	CPanel:ColorPicker( "#tool.rope.color", "rope_color_r", "rope_color_g", "rope_color_b" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/slider.lua

@@ -0,0 +1,201 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.slider.name"
+
+TOOL.ClientConVar[ "width" ] = "1.5"
+TOOL.ClientConVar[ "material" ] = "cable/cable"
+TOOL.ClientConVar[ "color_r" ] = "255"
+TOOL.ClientConVar[ "color_g" ] = "255"
+TOOL.ClientConVar[ "color_b" ] = "255"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1, op = 1 },
+	{ name = "right", stage = 0 },
+	{ name = "reload" }
+}
+
+function TOOL:LeftClick( trace )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+	self:SetOperation( 1 )
+
+	if ( iNum > 0 ) then
+
+		if ( CLIENT ) then
+			self:ClearObjects()
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+	
+		-- Get client's CVars
+		local width = self:GetClientNumber( "width", 1.5 )
+		local material = self:GetClientInfo( "material" )
+
+		local colorR = self:GetClientNumber( "color_r" )
+		local colorG = self:GetClientNumber( "color_g" )
+		local colorB = self:GetClientNumber( "color_b" )
+
+		-- Get information we're about to use
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+
+		local constr, rope = constraint.Slider( Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, width, material, Color( colorR, colorG, colorB ) )
+		if ( IsValid( constr ) ) then
+			undo.Create( "Slider" )
+				undo.AddEntity( constr )
+				if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.slider.name" )
+			undo.Finish( "#tool.slider.name" )
+
+			ply:AddCount( "ropeconstraints", constr )
+			ply:AddCleanup( "ropeconstraints", constr )
+			if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	if ( self:GetOperation() == 1 ) then return false end
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	local tr_new = {}
+	tr_new.start = trace.HitPos
+	tr_new.endpos = trace.HitPos + ( trace.HitNormal * 16384 )
+	tr_new.filter = { self:GetOwner() }
+	if ( IsValid( trace.Entity ) ) then
+		table.insert( tr_new.filter, trace.Entity )
+	end
+
+	local tr = util.TraceLine( tr_new )
+	if ( !tr.Hit ) then
+		self:ClearObjects()
+		return
+	end
+
+	-- Don't try to constrain world to world
+	if ( trace.HitWorld && tr.HitWorld ) then
+		self:ClearObjects()
+		return
+	end
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then
+		self:ClearObjects()
+		return
+	end
+	if ( IsValid( tr.Entity ) && tr.Entity:IsPlayer() ) then
+		self:ClearObjects()
+		return
+	end
+
+	-- Check to see if the player can create a slider constraint with the entity in the trace
+	if ( !hook.Run( "CanTool", self:GetOwner(), tr, "slider", self, 2 ) ) then
+		self:ClearObjects()
+		return
+	end
+
+	local Phys2 = tr.Entity:GetPhysicsObjectNum( tr.PhysicsBone )
+	self:SetObject( 2, tr.Entity, tr.HitPos, Phys2, tr.PhysicsBone, trace.HitNormal )
+
+	if ( CLIENT ) then
+		self:ClearObjects()
+		return true
+	end
+
+	local ply = self:GetOwner()
+	if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+		self:ClearObjects()
+		return false
+	end
+
+	local width = self:GetClientNumber( "width", 1.5 )
+	local material = self:GetClientInfo( "material" )
+
+	local colorR = self:GetClientNumber( "color_r" )
+	local colorG = self:GetClientNumber( "color_g" )
+	local colorB = self:GetClientNumber( "color_b" )
+
+	-- Get information we're about to use
+	local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+	local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+	local LPos1, LPos2 = self:GetLocalPos( 1 ),	self:GetLocalPos( 2 )
+
+	local constr, rope = constraint.Slider( Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, width, material, Color( colorR, colorG, colorB ) )
+	if ( IsValid( constr ) ) then
+		undo.Create( "Slider" )
+			undo.AddEntity( constr )
+			if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+			undo.SetPlayer( ply )
+			undo.SetCustomUndoText( "Undone #tool.slider.name" )
+		undo.Finish( "#tool.slider.name" )
+
+		ply:AddCount( "ropeconstraints", constr )
+		ply:AddCleanup( "ropeconstraints", constr )
+		if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+	end
+
+	-- Clear the objects so we're ready to go again
+	self:ClearObjects()
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "Slider" )
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.slider.help" )
+	CPanel:ToolPresets( "slider", ConVarsDefault )
+
+	CPanel:NumSlider( "#tool.slider.width", "slider_width", 0, 10 )
+
+	CPanel:RopeSelect( "slider_material" )
+
+	CPanel:ColorPicker( "#tool.slider.color", "slider_color_r", "slider_color_g", "slider_color_b" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/thruster.lua

@@ -0,0 +1,295 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.thruster.name"
+
+TOOL.ClientConVar[ "force" ] = "1500"
+TOOL.ClientConVar[ "model" ] = "models/props_phx2/garbage_metalcan001a.mdl"
+TOOL.ClientConVar[ "keygroup" ] = "45"
+TOOL.ClientConVar[ "keygroup_back" ] = "42"
+TOOL.ClientConVar[ "toggle" ] = "0"
+TOOL.ClientConVar[ "collision" ] = "0"
+TOOL.ClientConVar[ "effect" ] = "fire"
+TOOL.ClientConVar[ "damageable" ] = "0"
+TOOL.ClientConVar[ "soundname" ] = "PhysicsCannister.ThrusterLoop"
+
+TOOL.Information = { { name = "left" } }
+
+cleanup.Register( "thrusters" )
+
+local function IsValidThrusterModel( model )
+	for mdl, _ in pairs( list.Get( "ThrusterModels" ) ) do
+		if ( mdl:lower() == model:lower() ) then return true end
+	end
+	return false
+end
+
+function TOOL:LeftClick( trace )
+
+	if ( trace.Entity && trace.Entity:IsPlayer() ) then return false end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	if ( CLIENT ) then return true end
+
+	local ply = self:GetOwner()
+
+	local force = math.Clamp( self:GetClientNumber( "force" ), 0, 1E10 )
+	local model = self:GetClientInfo( "model" )
+	local key = self:GetClientNumber( "keygroup" )
+	local key_bk = self:GetClientNumber( "keygroup_back" )
+	local toggle = self:GetClientNumber( "toggle" )
+	local collision = self:GetClientNumber( "collision" ) == 0
+	local effect = self:GetClientInfo( "effect" )
+	local damageable = self:GetClientNumber( "damageable" )
+	local soundname = self:GetClientInfo( "soundname" )
+
+	-- If we shot a thruster change its force
+	if ( IsValid( trace.Entity ) && trace.Entity:GetClass() == "gmod_thruster" && trace.Entity.pl == ply ) then
+
+		trace.Entity:SetForce( force )
+		trace.Entity:SetEffect( effect )
+		trace.Entity:SetToggle( toggle == 1 )
+		trace.Entity.ActivateOnDamage = damageable == 1
+		trace.Entity:SetSound( soundname )
+
+		numpad.Remove( trace.Entity.NumDown )
+		numpad.Remove( trace.Entity.NumUp )
+		numpad.Remove( trace.Entity.NumBackDown )
+		numpad.Remove( trace.Entity.NumBackUp )
+
+		trace.Entity.NumDown = numpad.OnDown( ply, key, "Thruster_On", trace.Entity, 1 )
+		trace.Entity.NumUp = numpad.OnUp( ply, key, "Thruster_Off", trace.Entity, 1 )
+
+		trace.Entity.NumBackDown = numpad.OnDown( ply, key_bk, "Thruster_On", trace.Entity, -1 )
+		trace.Entity.NumBackUp = numpad.OnUp( ply, key_bk, "Thruster_Off", trace.Entity, -1 )
+
+		trace.Entity.key = key
+		trace.Entity.key_bk = key_bk
+		trace.Entity.force = force
+		trace.Entity.toggle = toggle
+		trace.Entity.effect = effect
+		trace.Entity.damageable = damageable
+
+		return true
+	end
+
+	if ( !util.IsValidModel( model ) || !util.IsValidProp( model ) || !IsValidThrusterModel( model ) ) then return false end
+	if ( !self:GetWeapon():CheckLimit( "thrusters" ) ) then return false end
+
+	local Ang = trace.HitNormal:Angle()
+	Ang.pitch = Ang.pitch + 90
+
+	local thruster = MakeThruster( ply, model, Ang, trace.HitPos, key, key_bk, force, toggle, effect, damageable, soundname )
+	if ( !IsValid( thruster ) ) then return false end
+
+	local min = thruster:OBBMins()
+	thruster:SetPos( trace.HitPos - trace.HitNormal * min.z )
+
+	undo.Create( "gmod_thruster" )
+		undo.AddEntity( thruster )
+
+		-- Don't weld to world
+		if ( IsValid( trace.Entity ) ) then
+
+			local weld = constraint.Weld( thruster, trace.Entity, 0, trace.PhysicsBone, 0, collision, true )
+			if ( IsValid( weld ) ) then
+				ply:AddCleanup( "thrusters", weld )
+				undo.AddEntity( weld )
+			end
+
+			-- Don't disable collision if it's not attached to anything
+			if ( collision ) then
+
+				if ( IsValid( thruster:GetPhysicsObject() ) ) then thruster:GetPhysicsObject():EnableCollisions( false ) end
+				thruster:SetCollisionGroup( COLLISION_GROUP_WORLD )
+				thruster.nocollide = true
+
+			end
+
+		end
+
+		undo.SetPlayer( ply )
+	undo.Finish()
+
+	return true
+
+end
+
+if ( SERVER ) then
+
+	function MakeThruster( ply, model, ang, pos, key, key_bck, force, toggle, effect, damageable, soundname, nocollide, Data )
+
+		if ( IsValid( ply ) && !ply:CheckLimit( "thrusters" ) ) then return NULL end
+		if ( !IsValidThrusterModel( model ) ) then return NULL end
+
+		local thruster = ents.Create( "gmod_thruster" )
+		if ( !IsValid( thruster ) ) then return NULL end
+
+		duplicator.DoGeneric( thruster, Data )
+		thruster:SetModel( model ) -- Backwards compatible for addons directly calling this function
+		thruster:SetAngles( ang )
+		thruster:SetPos( pos )
+		thruster:Spawn()
+
+		DoPropSpawnedEffect( thruster )
+
+		duplicator.DoGenericPhysics( thruster, ply, Data )
+
+		force = math.Clamp( force, 0, 1E10 )
+
+		thruster:SetEffect( effect )
+		thruster:SetForce( force )
+		thruster:SetToggle( toggle == 1 )
+		thruster.ActivateOnDamage = ( damageable == 1 )
+		thruster:SetPlayer( ply )
+		thruster:SetSound( soundname )
+
+		thruster.NumDown = numpad.OnDown( ply, key, "Thruster_On", thruster, 1 )
+		thruster.NumUp = numpad.OnUp( ply, key, "Thruster_Off", thruster, 1 )
+
+		thruster.NumBackDown = numpad.OnDown( ply, key_bck, "Thruster_On", thruster, -1 )
+		thruster.NumBackUp = numpad.OnUp( ply, key_bck, "Thruster_Off", thruster, -1 )
+
+		if ( nocollide == true ) then
+			if ( IsValid( thruster:GetPhysicsObject() ) ) then thruster:GetPhysicsObject():EnableCollisions( false ) end
+			thruster:SetCollisionGroup( COLLISION_GROUP_WORLD )
+		end
+
+		table.Merge( thruster:GetTable(), {
+			key = key,
+			key_bck = key_bck,
+			force = force,
+			toggle = toggle,
+			pl = ply,
+			effect = effect,
+			nocollide = nocollide,
+			damageable = damageable,
+			soundname = soundname
+		} )
+
+		if ( IsValid( ply ) ) then
+			ply:AddCount( "thrusters", thruster )
+			ply:AddCleanup( "thrusters", thruster )
+		end
+
+
+		return thruster
+
+	end
+
+	duplicator.RegisterEntityClass( "gmod_thruster", MakeThruster, "Model", "Ang", "Pos", "key", "key_bck", "force", "toggle", "effect", "damageable", "soundname", "nocollide", "Data" )
+
+end
+
+function TOOL:UpdateGhostThruster( ent, ply )
+
+	if ( !IsValid( ent ) ) then return end
+
+	local trace = ply:GetEyeTrace()
+	if ( !trace.Hit || IsValid( trace.Entity ) && ( trace.Entity:GetClass() == "gmod_thruster" || trace.Entity:IsPlayer() ) ) then
+
+		ent:SetNoDraw( true )
+		return
+
+	end
+
+	local ang = trace.HitNormal:Angle()
+	ang.pitch = ang.pitch + 90
+
+	local min = ent:OBBMins()
+	ent:SetPos( trace.HitPos - trace.HitNormal * min.z )
+	ent:SetAngles( ang )
+
+	ent:SetNoDraw( false )
+
+end
+
+function TOOL:Think()
+
+	local mdl = self:GetClientInfo( "model" )
+	if ( !IsValidThrusterModel( mdl ) ) then self:ReleaseGhostEntity() return end
+
+	if ( !IsValid( self.GhostEntity ) || self.GhostEntity:GetModel() != mdl:lower() ) then
+		self:MakeGhostEntity( mdl, vector_origin, angle_zero )
+	end
+
+	self:UpdateGhostThruster( self.GhostEntity, self:GetOwner() )
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.thruster.desc" )
+	CPanel:ToolPresets( "thruster", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.thruster.forward", "thruster_keygroup", "#tool.thruster.back", "thruster_keygroup_back" )
+
+	CPanel:NumSlider( "#tool.thruster.force", "thruster_force", 1, 10000 )
+
+	local combo = CPanel:ComboBoxMulti( "#tool.thruster.effect" )
+	for k, v in pairs( list.Get( "ThrusterEffects" ) ) do
+		combo:AddOption( k, { thruster_effect = v.thruster_effect } )
+	end
+
+	CPanel:ComboBoxMulti( "#tool.thruster.sound", list.Get( "ThrusterSounds" ) )
+
+	CPanel:CheckBox( "#tool.thruster.toggle", "thruster_toggle" )
+	CPanel:CheckBox( "#tool.thruster.collision", "thruster_collision" )
+	CPanel:CheckBox( "#tool.thruster.damagable", "thruster_damageable" )
+
+	CPanel:PropSelect( "#tool.thruster.model", "thruster_model", list.Get( "ThrusterModels" ), 0 )
+
+end
+
+list.Set( "ThrusterSounds", "#thrustersounds.none", { thruster_soundname = "" } )
+list.Set( "ThrusterSounds", "#thrustersounds.steam", { thruster_soundname = "PhysicsCannister.ThrusterLoop" } )
+list.Set( "ThrusterSounds", "#thrustersounds.zap", { thruster_soundname = "WeaponDissolve.Charge" } )
+list.Set( "ThrusterSounds", "#thrustersounds.beam", { thruster_soundname = "WeaponDissolve.Beam" } )
+list.Set( "ThrusterSounds", "#thrustersounds.elevator", { thruster_soundname = "eli_lab.elevator_move" } )
+list.Set( "ThrusterSounds", "#thrustersounds.energy", { thruster_soundname = "combine.sheild_loop" } )
+list.Set( "ThrusterSounds", "#thrustersounds.ring", { thruster_soundname = "k_lab.ringsrotating" } )
+list.Set( "ThrusterSounds", "#thrustersounds.resonance", { thruster_soundname = "k_lab.teleport_rings_high" } )
+list.Set( "ThrusterSounds", "#thrustersounds.dropship", { thruster_soundname = "k_lab2.DropshipRotorLoop" } )
+list.Set( "ThrusterSounds", "#thrustersounds.machine", { thruster_soundname = "Town.d1_town_01_spin_loop" } )
+
+list.Set( "ThrusterModels", "models/dav0r/thruster.mdl", {} )
+list.Set( "ThrusterModels", "models/MaxOfS2D/thruster_projector.mdl", {} )
+list.Set( "ThrusterModels", "models/MaxOfS2D/thruster_propeller.mdl", {} )
+list.Set( "ThrusterModels", "models/thrusters/jetpack.mdl", {} )
+list.Set( "ThrusterModels", "models/props_junk/plasticbucket001a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_junk/PropaneCanister001a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_junk/propane_tank001a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_junk/PopCan01a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_junk/MetalBucket01a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_lab/jar01a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_c17/lampShade001a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_c17/canister_propane01a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_c17/canister01a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_c17/canister02a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_trainstation/trainstation_ornament002.mdl", {} )
+list.Set( "ThrusterModels", "models/props_junk/TrafficCone001a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_c17/clock01.mdl", {} )
+list.Set( "ThrusterModels", "models/props_junk/terracotta01.mdl", {} )
+list.Set( "ThrusterModels", "models/props_c17/TrapPropeller_Engine.mdl", {} )
+list.Set( "ThrusterModels", "models/props_c17/FurnitureSink001a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_trainstation/trainstation_ornament001.mdl", {} )
+list.Set( "ThrusterModels", "models/props_trainstation/trashcan_indoor001b.mdl", {} )
+list.Set( "ThrusterModels", "models/props_c17/pottery02a.mdl", {} )
+list.Set( "ThrusterModels", "models/props_c17/pottery03a.mdl", {} )
+
+--PHX
+list.Set( "ThrusterModels", "models/props_phx2/garbage_metalcan001a.mdl", {} )
+
+--Tile Model Pack Thrusters
+list.Set( "ThrusterModels", "models/hunter/plates/plate.mdl", {} )
+list.Set( "ThrusterModels", "models/hunter/blocks/cube025x025x025.mdl", {} )
+
+--XQM Model Pack Thrusters
+list.Set( "ThrusterModels", "models/XQM/AfterBurner1.mdl", {} )
+list.Set( "ThrusterModels", "models/XQM/AfterBurner1Medium.mdl", {} )
+list.Set( "ThrusterModels", "models/XQM/AfterBurner1Big.mdl", {} )
+list.Set( "ThrusterModels", "models/XQM/AfterBurner1Huge.mdl", {} )
+list.Set( "ThrusterModels", "models/XQM/AfterBurner1Large.mdl", {} )

gamemodes/sandbox/entities/weapons/gmod_tool/stools/trails.lua

@@ -0,0 +1,161 @@
+
+TOOL.Category = "Render"
+TOOL.Name = "#tool.trails.name"
+
+TOOL.ClientConVar[ "r" ] = 255
+TOOL.ClientConVar[ "g" ] = 255
+TOOL.ClientConVar[ "b" ] = 255
+TOOL.ClientConVar[ "a" ] = 255
+
+TOOL.ClientConVar[ "length" ] = 5
+TOOL.ClientConVar[ "startsize" ] = 32
+TOOL.ClientConVar[ "endsize" ] = 0
+
+TOOL.ClientConVar[ "material" ] = "trails/lol"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" }
+}
+
+cleanup.Register( "trails" )
+
+local function SetTrails( ply, ent, data )
+
+	if ( IsValid( ent.SToolTrail ) ) then
+
+		ent.SToolTrail:Remove()
+		ent.SToolTrail = nil
+
+	end
+
+	if ( !data ) then
+
+		duplicator.ClearEntityModifier( ent, "trail" )
+		return
+
+	end
+
+	-- Just don't even bother with invisible trails
+	if ( data.StartSize <= 0 && data.EndSize <= 0 ) then return end
+
+		-- This is here to fix crash exploits
+	if ( !game.SinglePlayer() ) then
+
+		-- Lock down the trail material - only allow what the server allows
+		if ( !list.Contains( "trail_materials", data.Material ) ) then return end
+
+		-- Clamp sizes in multiplayer
+		data.Length = math.Clamp( data.Length, 0.1, 10 )
+		data.EndSize = math.Clamp( data.EndSize, 0, 128 )
+		data.StartSize = math.Clamp( data.StartSize, 0, 128 )
+
+	end
+
+	data.StartSize = math.max( 0.0001, data.StartSize )
+
+	local trail_entity = util.SpriteTrail( ent, 0, data.Color, false, data.StartSize, data.EndSize, data.Length, 1 / ( ( data.StartSize + data.EndSize ) * 0.5 ), data.Material .. ".vmt" )
+
+	ent.SToolTrail = trail_entity
+
+	if ( IsValid( ply ) ) then
+		ply:AddCleanup( "trails", trail_entity )
+	end
+
+	duplicator.StoreEntityModifier( ent, "trail", data )
+
+	return trail_entity
+
+end
+if ( SERVER ) then
+	duplicator.RegisterEntityModifier( "trail", SetTrails )
+end
+
+function TOOL:LeftClick( trace )
+
+	if ( !IsValid( trace.Entity ) ) then return false end
+	if ( trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	local r = math.Clamp( self:GetClientNumber( "r", 255 ), 0, 255 )
+	local g = math.Clamp( self:GetClientNumber( "g", 255 ), 0, 255 )
+	local b = math.Clamp( self:GetClientNumber( "b", 255 ), 0, 255 )
+	local a = math.Clamp( self:GetClientNumber( "a", 255 ), 0, 255 )
+
+	local length = self:GetClientNumber( "length", 5 )
+	local endsize = self:GetClientNumber( "endsize", 0 )
+	local startsize = self:GetClientNumber( "startsize", 32 )
+	local mat = self:GetClientInfo( "material" )
+
+	local trail = SetTrails( self:GetOwner(), trace.Entity, {
+		Color = Color( r, g, b, a ),
+		Length = length,
+		StartSize = startsize,
+		EndSize = endsize,
+		Material = mat
+	} )
+
+	if ( IsValid( trail ) ) then
+		undo.Create( "Trail" )
+			undo.AddEntity( trail )
+			undo.SetPlayer( self:GetOwner() )
+			undo.SetCustomUndoText( "Undone #tool.trails.name" )
+		undo.Finish( "#tool.trails.name" )
+	end
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	if ( !IsValid( trace.Entity ) ) then return false end
+	if ( trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	SetTrails( self:GetOwner(), trace.Entity, nil )
+	return true
+
+end
+
+--
+-- Add default materials to list
+-- Note: Addons can easily add to this list in their -- own file placed in autorun or something.
+--
+list.Set( "trail_materials", "#trail.plasma", "trails/plasma" )
+list.Set( "trail_materials", "#trail.tube", "trails/tube" )
+list.Set( "trail_materials", "#trail.electric", "trails/electric" )
+list.Set( "trail_materials", "#trail.smoke", "trails/smoke" )
+list.Set( "trail_materials", "#trail.laser", "trails/laser" )
+list.Set( "trail_materials", "#trail.physbeam", "trails/physbeam" )
+list.Set( "trail_materials", "#trail.love", "trails/love" )
+list.Set( "trail_materials", "#trail.lol", "trails/lol" )
+
+if ( IsMounted( "tf" ) ) then
+	list.Set( "trail_materials", "#trail.beam001_blu", "effects/beam001_blu" )
+	list.Set( "trail_materials", "#trail.beam001_red", "effects/beam001_red" )
+	list.Set( "trail_materials", "#trail.beam001_white", "effects/beam001_white" )
+	list.Set( "trail_materials", "#trail.arrowtrail_blu", "effects/arrowtrail_blu" )
+	list.Set( "trail_materials", "#trail.arrowtrail_red", "effects/arrowtrail_red" )
+	list.Set( "trail_materials", "#trail.repair_claw_trail_blue", "effects/repair_claw_trail_blue" )
+	list.Set( "trail_materials", "#trail.repair_claw_trail_red", "effects/repair_claw_trail_red" )
+	list.Set( "trail_materials", "#trail.australiumtrail_red", "effects/australiumtrail_red" )
+	list.Set( "trail_materials", "#trail.beam_generic01", "effects/beam_generic01" )
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.trails.desc" )
+	CPanel:ToolPresets( "trails", ConVarsDefault )
+
+	CPanel:ColorPicker( "#tool.trails.color", "trails_r", "trails_g", "trails_b", "trails_a" )
+
+	CPanel:NumSlider( "#tool.trails.length", "trails_length", 0, 10 )
+	CPanel:NumSlider( "#tool.trails.startsize", "trails_startsize", 0, 128 )
+	CPanel:NumSlider( "#tool.trails.endsize", "trails_endsize", 0, 128 )
+
+	CPanel:MatSelect( "trails_material", list.Get( "trail_materials" ), true, 0.25, 0.25 )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/weld.lua

@@ -0,0 +1,301 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.weld.name"
+
+TOOL.ClientConVar[ "forcelimit" ] = "0"
+TOOL.ClientConVar[ "nocollide" ] = "0"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1, op = 2 },
+	{ name = "right", stage = 0 },
+	{ name = "right_1", stage = 1, op = 1 },
+	{ name = "right_2", stage = 2, op = 1 },
+	{ name = "reload" }
+}
+
+function TOOL:LeftClick( trace )
+
+	if ( self:GetOperation() == 1 ) then return false end
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return false end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	if ( CLIENT ) then
+		if ( iNum > 0 ) then self:ClearObjects() end
+		return true
+	end
+
+	self:SetOperation( 2 )
+
+	if ( iNum == 0 ) then
+
+		self:SetStage( 1 )
+		return true
+
+	end
+
+	if ( iNum == 1 ) then
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "constraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		-- Get client's CVars
+		local forcelimit = self:GetClientNumber( "forcelimit" )
+		local nocollide = self:GetClientNumber( "nocollide", 0 ) != 0
+
+		-- Get information we're about to use
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+
+		local constr = constraint.Weld( Ent1, Ent2, Bone1, Bone2, forcelimit, nocollide )
+		if ( IsValid( constr ) ) then
+
+			undo.Create( "Weld" )
+				undo.AddEntity( constr )
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.weld.name" )
+			undo.Finish( "#tool.weld.name" )
+
+			ply:AddCount( "constraints", constr )
+			ply:AddCleanup( "constraints", constr )
+
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+
+	end
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	if ( self:GetOperation() == 2 ) then return false end
+
+	-- Make sure the object we're about to use is valid
+	local iNum = self:NumObjects()
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+
+	-- You can click anywhere on the 3rd pass
+	if ( iNum < 2 ) then
+
+		-- If there's no physics object then we can't constraint it!
+		if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+		-- Don't weld players, or to players
+		if ( trace.Entity:IsPlayer() ) then return false end
+
+		-- Don't do anything with stuff without any physics..
+		if ( SERVER && !IsValid( Phys ) ) then return false end
+
+	end
+
+	if ( iNum == 0 ) then
+
+		if ( !IsValid( trace.Entity ) ) then return false end
+		if ( trace.Entity:GetClass() == "prop_vehicle_jeep" ) then return false end
+
+	end
+
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+	self:SetOperation( 1 )
+
+	--
+	-- Stage 0 - grab an object, make a ghost entity
+	--
+	if ( iNum == 0 ) then
+
+		self:StartGhostEntity( trace.Entity )
+		self:SetStage( 1 )
+		return true
+
+	end
+
+	--
+	-- Stage 1 - choose the spot and object to weld it to
+	--
+	if ( iNum == 1 ) then
+
+		if ( CLIENT ) then
+			self:ReleaseGhostEntity()
+			return true
+		end
+
+		-- Get information we're about to use
+		local Norm1, Norm2 = self:GetNormal( 1 ), self:GetNormal( 2 )
+		local Phys1 = self:GetPhys( 1 )
+		local WPos2 = self:GetPos( 2 )
+
+		-- Note: To keep stuff ragdoll friendly try to treat things as physics objects rather than entities
+		local Ang1, Ang2 = Norm1:Angle(), ( -Norm2 ):Angle()
+		local TargetAngle = Phys1:AlignAngles( Ang1, Ang2 )
+
+		Phys1:SetAngles( TargetAngle )
+
+		-- Move the object so that the hitpos on our object is at the second hitpos
+		local TargetPos = WPos2 + ( Phys1:GetPos() - self:GetPos( 1 ) )
+
+		-- Set the position
+		Phys1:SetPos( TargetPos )
+		Phys1:EnableMotion( false )
+
+		-- Wake up the physics object so that the entity updates
+		Phys1:Wake()
+
+		self.RotAxis = Norm2
+
+		self:ReleaseGhostEntity()
+
+		self:SetStage( 2 )
+
+		return true
+
+	end
+
+	--
+	-- Stage 2 - Weld it in place.
+	--
+	if ( iNum == 2 ) then
+
+		if ( CLIENT ) then
+			self:ClearObjects()
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "constraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		-- Get client's CVars
+		local forcelimit = self:GetClientNumber( "forcelimit" )
+		local nocollide = self:GetClientNumber( "nocollide", 0 ) != 0
+
+		-- Get information we're about to use
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ),	self:GetBone( 2 )
+		local Phys1 = self:GetPhys( 1 )
+
+		-- The entity became invalid half way through
+		if ( !IsValid( Ent1 ) ) then
+
+			self:ClearObjects()
+			return false
+
+		end
+
+		local constr = constraint.Weld( Ent1, Ent2, Bone1, Bone2, forcelimit, nocollide )
+		if ( IsValid( constr ) ) then
+
+			Phys1:EnableMotion( true )
+
+			undo.Create( "Weld" )
+				undo.AddEntity( constr )
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.weld.name" )
+			undo.Finish( "#tool.weld.name" )
+
+			ply:AddCount( "constraints", constr )
+			ply:AddCleanup( "constraints", constr )
+
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+		return true
+
+	end
+
+end
+
+function TOOL:Think()
+
+	if ( self:NumObjects() < 1 ) then return end
+
+	if ( self:GetOperation() == 1 ) then
+
+		if ( SERVER && !IsValid( self:GetEnt( 1 ) ) ) then
+
+			self:ClearObjects()
+			return
+
+		end
+
+		if ( self:NumObjects() == 1 ) then
+
+			self:UpdateGhostEntity()
+			return
+
+		end
+
+		if ( SERVER && self:NumObjects() == 2 ) then
+
+			local Phys1 = self:GetPhys( 1 )
+
+			local cmd = self:GetOwner():GetCurrentCommand()
+
+			local degrees = cmd:GetMouseX() * 0.05
+
+			local angle = Phys1:RotateAroundAxis( self.RotAxis, degrees )
+
+			Phys1:SetAngles( angle )
+
+			-- Move so spots join up
+			local TargetPos = self:GetPos( 2 ) + ( Phys1:GetPos() - self:GetPos( 1 ) )
+			Phys1:SetPos( TargetPos )
+			Phys1:Wake()
+
+		end
+
+	end
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	self:ClearObjects()
+
+	return constraint.RemoveConstraints( trace.Entity, "Weld" )
+
+end
+
+function TOOL:FreezeMovement()
+
+	return self:GetOperation() == 1 && self:GetStage() == 2
+
+end
+
+function TOOL:Holster()
+
+	self:ClearObjects()
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.weld.help" )
+	CPanel:ToolPresets( "weld", ConVarsDefault )
+
+	CPanel:NumSlider( "#tool.forcelimit", "weld_forcelimit", 0, 1000 )
+	CPanel:ControlHelp( "#tool.forcelimit.help" )
+
+	CPanel:CheckBox( "#tool.nocollide", "weld_nocollide" )
+
+end

gamemodes/sandbox/entities/weapons/gmod_tool/stools/wheel.lua

@@ -0,0 +1,449 @@
+
+TOOL.Category = "Construction"
+TOOL.Name = "#tool.wheel.name"
+
+TOOL.ClientConVar[ "torque" ] = "3000"
+TOOL.ClientConVar[ "friction" ] = "1"
+TOOL.ClientConVar[ "nocollide" ] = "1"
+TOOL.ClientConVar[ "forcelimit" ] = "0"
+TOOL.ClientConVar[ "fwd" ] = "45"
+TOOL.ClientConVar[ "bck" ] = "42"
+TOOL.ClientConVar[ "toggle" ] = "0"
+TOOL.ClientConVar[ "model" ] = "models/props_vehicles/carparts_wheel01a.mdl"
+TOOL.ClientConVar[ "rx" ] = "90"
+TOOL.ClientConVar[ "ry" ] = "0"
+TOOL.ClientConVar[ "rz" ] = "90"
+
+TOOL.Information = {
+	{ name = "left" },
+	{ name = "right" },
+	{ name = "use" }
+}
+
+cleanup.Register( "wheels" )
+
+local function IsValidWheelModel( model )
+	for mdl, _ in pairs( list.Get( "WheelModels" ) ) do
+		if ( mdl:lower() == model:lower() ) then return true end
+	end
+	return false
+end
+
+-- Places a wheel
+function TOOL:LeftClick( trace )
+
+	if ( trace.Entity and trace.Entity:IsPlayer() ) then return false end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER and !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	if ( CLIENT ) then return true end
+
+	if ( !self:GetWeapon():CheckLimit( "wheels" ) ) then return false end
+
+	-- Check the model's validity
+	local model = self:GetClientInfo( "model" )
+	if ( !util.IsValidModel( model ) or !util.IsValidProp( model ) or !IsValidWheelModel( model ) ) then return false end
+
+	-- Get client's CVars
+	local torque = self:GetClientNumber( "torque" )
+	local friction = self:GetClientNumber( "friction" )
+	local nocollide = self:GetClientNumber( "nocollide" )
+	local limit = self:GetClientNumber( "forcelimit" )
+	local toggle = self:GetClientNumber( "toggle" ) != 0
+
+	local fwd = self:GetClientNumber( "fwd" )
+	local bck = self:GetClientNumber( "bck" )
+
+	local ply = self:GetOwner()
+
+	-- Make sure we have our wheel angle
+	self.wheelAngle = Angle( math.NormalizeAngle( self:GetClientNumber( "rx" ) ), math.NormalizeAngle( self:GetClientNumber( "ry" ) ), math.NormalizeAngle( self:GetClientNumber( "rz" ) ) )
+
+	-- Create the wheel
+	local wheelEnt = MakeWheel( ply, trace.HitPos, trace.HitNormal:Angle() + self.wheelAngle, model, fwd, bck, nil, nil, toggle, torque )
+	if ( !IsValid( wheelEnt ) ) then return false end
+
+	-- Position
+	local CurPos = wheelEnt:GetPos()
+	local NearestPoint = wheelEnt:NearestPoint( CurPos - ( trace.HitNormal * 512 ) )
+	local wheelOffset = CurPos - NearestPoint
+
+	wheelEnt:SetPos( trace.HitPos + wheelOffset )
+
+	-- Wake up the physics object so that the entity updates
+	if ( IsValid( wheelEnt:GetPhysicsObject() ) ) then wheelEnt:GetPhysicsObject():Wake() end
+
+	-- Set the hinge Axis perpendicular to the trace hit surface
+	local targetPhys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	local LPos1 = wheelEnt:GetPhysicsObject():WorldToLocal( wheelEnt:GetPos() + trace.HitNormal )
+	local LPos2 = targetPhys:WorldToLocal( trace.HitPos )
+
+	local constr, axis = constraint.Motor( wheelEnt, trace.Entity, 0, trace.PhysicsBone, LPos1, LPos2, friction, torque, 0, nocollide, toggle, ply, limit )
+
+	undo.Create( "gmod_wheel" )
+		if ( IsValid( constr ) ) then
+			undo.AddEntity( constr )
+			ply:AddCleanup( "wheels", constr )
+		end
+		if ( IsValid( axis ) ) then
+			undo.AddEntity( axis )
+			ply:AddCleanup( "wheels", axis )
+		end
+		undo.AddEntity( wheelEnt )
+		undo.SetPlayer( ply )
+	undo.Finish()
+
+	wheelEnt:SetMotor( constr )
+	wheelEnt:SetDirection( constr.direction )
+	wheelEnt:SetAxis( trace.HitNormal )
+	wheelEnt:DoDirectionEffect()
+
+	return true
+
+end
+
+-- Apply new values to the wheel
+function TOOL:RightClick( trace )
+
+	if ( trace.Entity and trace.Entity:GetClass() != "gmod_wheel" ) then return false end
+	if ( CLIENT ) then return true end
+
+	local wheelEnt = trace.Entity
+
+	-- Only change your own wheels..
+	if ( IsValid( wheelEnt:GetPlayer() ) and wheelEnt:GetPlayer() != self:GetOwner() ) then
+		return false
+	end
+
+	-- Get client's CVars
+	local torque = self:GetClientNumber( "torque" )
+	local toggle = self:GetClientNumber( "toggle" ) != 0
+	local fwd = self:GetClientNumber( "fwd" )
+	local bck = self:GetClientNumber( "bck" )
+	-- TODO: Friction
+	-- TODO: Force Limit
+
+	wheelEnt.BaseTorque = torque
+	wheelEnt:SetTorque( torque )
+	wheelEnt:SetToggle( toggle )
+
+	-- Make sure the table exists!
+	wheelEnt.KeyBinds = wheelEnt.KeyBinds or {}
+
+	wheelEnt.key_f = fwd
+	wheelEnt.key_r = bck
+
+	-- Remove old binds
+	numpad.Remove( wheelEnt.KeyBinds[ 1 ] )
+	numpad.Remove( wheelEnt.KeyBinds[ 2 ] )
+	numpad.Remove( wheelEnt.KeyBinds[ 3 ] )
+	numpad.Remove( wheelEnt.KeyBinds[ 4 ] )
+
+	-- Add new binds
+	wheelEnt.KeyBinds[ 1 ] = numpad.OnDown( self:GetOwner(), fwd, "WheelForward", wheelEnt, true )
+	wheelEnt.KeyBinds[ 2 ] = numpad.OnUp( self:GetOwner(), fwd, "WheelForward", wheelEnt, false )
+	wheelEnt.KeyBinds[ 3 ] = numpad.OnDown( self:GetOwner(), bck, "WheelReverse", wheelEnt, true )
+	wheelEnt.KeyBinds[ 4 ] = numpad.OnUp( self:GetOwner(), bck, "WheelReverse", wheelEnt, false )
+
+	return true
+
+end
+
+if ( SERVER ) then
+
+	-- For duplicator, creates the wheel.
+	function MakeWheel( ply, pos, ang, model, key_f, key_r, axis, direction, toggle, baseTorque, Data )
+
+		if ( IsValid( ply ) and !ply:CheckLimit( "wheels" ) ) then return NULL end
+		if ( !IsValidWheelModel( model ) ) then return NULL end
+
+		local wheel = ents.Create( "gmod_wheel" )
+		if ( !IsValid( wheel ) ) then return NULL end
+
+		duplicator.DoGeneric( wheel, Data )
+		wheel:SetModel( model ) -- Backwards compatible for addons directly calling this function
+		wheel:SetPos( pos )
+		wheel:SetAngles( ang )
+		wheel:Spawn()
+
+		DoPropSpawnedEffect( wheel )
+
+		wheel:SetPlayer( ply )
+
+		duplicator.DoGenericPhysics( wheel, ply, Data )
+
+		wheel.key_f = key_f
+		wheel.key_r = key_r
+
+		if ( axis ) then
+			wheel.Axis = axis
+		end
+
+		wheel:SetDirection( direction or 1 )
+		wheel:SetToggle( toggle or false )
+
+		wheel:SetBaseTorque( baseTorque )
+		wheel:UpdateOverlayText()
+
+		wheel.KeyBinds = {}
+
+		-- Bind to keypad
+		wheel.KeyBinds[ 1 ] = numpad.OnDown( ply, key_f, "WheelForward", wheel, true )
+		wheel.KeyBinds[ 2 ] = numpad.OnUp( ply, key_f, "WheelForward", wheel, false )
+		wheel.KeyBinds[ 3 ] = numpad.OnDown( ply, key_r, "WheelReverse", wheel, true )
+		wheel.KeyBinds[ 4 ] = numpad.OnUp( ply, key_r, "WheelReverse", wheel, false )
+
+		if ( IsValid( ply ) ) then
+			ply:AddCount( "wheels", wheel )
+			ply:AddCleanup( "wheels", wheel )
+		end
+
+		return wheel
+
+	end
+	duplicator.RegisterEntityClass( "gmod_wheel", MakeWheel, "Pos", "Ang", "Model", "key_f", "key_r", "Axis", "Direction", "Toggle", "BaseTorque", "Data" )
+
+end
+
+function TOOL:UpdateGhostWheel( ent, ply )
+
+	if ( !IsValid( ent ) ) then return end
+
+	local trace = ply:GetEyeTrace()
+	if ( !trace.Hit or IsValid( trace.Entity ) and ( trace.Entity:IsPlayer() /*|| trace.Entity:GetClass() == "gmod_wheel"*/ ) ) then
+
+		ent:SetNoDraw( true )
+		return
+
+	end
+
+	local Ang = trace.HitNormal:Angle() + self.wheelAngle
+	ent:SetAngles( Ang )
+
+	local CurPos = ent:GetPos()
+	local NearestPoint = ent:NearestPoint( CurPos - ( trace.HitNormal * 512 ) )
+	local WheelOffset = CurPos - NearestPoint
+	ent:SetPos( trace.HitPos + WheelOffset )
+
+	ent:SetNoDraw( false )
+
+end
+
+-- Maintains the ghost wheel
+function TOOL:Think()
+
+	local mdl = self:GetClientInfo( "model" )
+	if ( !IsValidWheelModel( mdl ) ) then self:ReleaseGhostEntity() return end
+
+	if ( !IsValid( self.GhostEntity ) or self.GhostEntity:GetModel() != mdl:lower() ) then
+		self.wheelAngle = Angle( math.NormalizeAngle( self:GetClientNumber( "rx" ) ), math.NormalizeAngle( self:GetClientNumber( "ry" ) ), math.NormalizeAngle( self:GetClientNumber( "rz" ) ) )
+		self:MakeGhostEntity( mdl, vector_origin, angle_zero )
+	end
+
+	self:UpdateGhostWheel( self.GhostEntity, self:GetOwner() )
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.wheel.desc" )
+	CPanel:ToolPresets( "wheel", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.wheel.forward", "wheel_fwd", "#tool.wheel.reverse", "wheel_bck" )
+
+	CPanel:NumSlider( "#tool.wheel.torque", "wheel_torque", 10, 10000 )
+	CPanel:NumSlider( "#tool.wheel.forcelimit", "wheel_forcelimit", 0, 50000 )
+	CPanel:NumSlider( "#tool.wheel.friction", "wheel_friction", 0, 100 )
+
+	CPanel:CheckBox( "#tool.wheel.nocollide", "wheel_nocollide" )
+	CPanel:CheckBox( "#tool.wheel.toggle", "wheel_toggle" )
+
+	CPanel:PropSelect( "#tool.wheel.model", "wheel_model", list.Get( "WheelModels" ), 0 )
+
+end
+
+-- Don't copy paste all of those ridiculous angles, just use one variable for all of them
+local zero = { wheel_rx = 0, wheel_ry = 0, wheel_rz = 0 }
+local one = { wheel_rx = 90, wheel_ry = 0, wheel_rz = 0 }
+local two = { wheel_rx = 90, wheel_ry = 0, wheel_rz = 90 }
+
+list.Set( "WheelModels", "models/props_junk/sawblade001a.mdl", one )
+list.Set( "WheelModels", "models/props_vehicles/carparts_wheel01a.mdl", two )
+list.Set( "WheelModels", "models/props_vehicles/apc_tire001.mdl", zero )
+list.Set( "WheelModels", "models/props_vehicles/tire001a_tractor.mdl", zero )
+list.Set( "WheelModels", "models/props_vehicles/tire001b_truck.mdl", zero )
+list.Set( "WheelModels", "models/props_vehicles/tire001c_car.mdl", zero )
+list.Set( "WheelModels", "models/props_wasteland/controlroom_filecabinet002a.mdl", one )
+list.Set( "WheelModels", "models/props_borealis/bluebarrel001.mdl", one )
+list.Set( "WheelModels", "models/props_c17/oildrum001.mdl", one )
+list.Set( "WheelModels", "models/props_c17/playground_carousel01.mdl", one )
+list.Set( "WheelModels", "models/props_c17/chair_office01a.mdl", one )
+list.Set( "WheelModels", "models/props_c17/TrapPropeller_Blade.mdl", one )
+list.Set( "WheelModels", "models/props_wasteland/wheel01.mdl", two )
+list.Set( "WheelModels", "models/props_trainstation/trainstation_clock001.mdl", zero )
+list.Set( "WheelModels", "models/props_junk/metal_paintcan001a.mdl", one )
+list.Set( "WheelModels", "models/props_c17/pulleywheels_large01.mdl", zero )
+
+list.Set( "WheelModels", "models/props_phx/oildrum001_explosive.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/breakable_tire.mdl", one )
+list.Set( "WheelModels", "models/props_phx/gibs/tire1_gib.mdl", one )
+list.Set( "WheelModels", "models/props_phx/normal_tire.mdl", one )
+list.Set( "WheelModels", "models/props_phx/mechanics/medgear.mdl", one )
+list.Set( "WheelModels", "models/props_phx/mechanics/biggear.mdl", one )
+list.Set( "WheelModels", "models/props_phx/gears/bevel9.mdl", one )
+list.Set( "WheelModels", "models/props_phx/gears/bevel90_24.mdl", one )
+list.Set( "WheelModels", "models/props_phx/gears/bevel12.mdl", one )
+list.Set( "WheelModels", "models/props_phx/gears/bevel24.mdl", one )
+list.Set( "WheelModels", "models/props_phx/gears/bevel36.mdl", one )
+list.Set( "WheelModels", "models/props_phx/gears/spur9.mdl", one )
+list.Set( "WheelModels", "models/props_phx/gears/spur12.mdl", one )
+list.Set( "WheelModels", "models/props_phx/gears/spur24.mdl", one )
+list.Set( "WheelModels", "models/props_phx/gears/spur36.mdl", one )
+list.Set( "WheelModels", "models/props_phx/smallwheel.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/747wheel.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/trucktire.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/trucktire2.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/metal_wheel1.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/metal_wheel2.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/wooden_wheel1.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/wooden_wheel2.mdl", one )
+list.Set( "WheelModels", "models/props_phx/construct/metal_plate_curve360.mdl", one )
+list.Set( "WheelModels", "models/props_phx/construct/metal_plate_curve360x2.mdl", one )
+list.Set( "WheelModels", "models/props_phx/construct/wood/wood_curve360x1.mdl", one )
+list.Set( "WheelModels", "models/props_phx/construct/wood/wood_curve360x2.mdl", one )
+list.Set( "WheelModels", "models/props_phx/construct/windows/window_curve360x1.mdl", one )
+list.Set( "WheelModels", "models/props_phx/construct/windows/window_curve360x2.mdl", one )
+list.Set( "WheelModels", "models/props_phx/trains/wheel_medium.mdl", one )
+list.Set( "WheelModels", "models/props_phx/trains/medium_wheel_2.mdl", one )
+list.Set( "WheelModels", "models/props_phx/trains/double_wheels.mdl", one )
+list.Set( "WheelModels", "models/props_phx/trains/double_wheels2.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/drugster_back.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/drugster_front.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/monster_truck.mdl", one )
+list.Set( "WheelModels", "models/props_phx/misc/propeller2x_small.mdl", one )
+list.Set( "WheelModels", "models/props_phx/misc/propeller3x_small.mdl", one )
+list.Set( "WheelModels", "models/props_phx/misc/paddle_small.mdl", one )
+list.Set( "WheelModels", "models/props_phx/misc/paddle_small2.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/magnetic_small.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/magnetic_small_base.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/magnetic_medium.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/magnetic_med_base.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/magnetic_large.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/magnetic_large_base.mdl", one )
+list.Set( "WheelModels", "models/props_phx/wheels/moped_tire.mdl", one )
+
+--Tile Model Pack Wheels
+list.Set( "WheelModels", "models/hunter/misc/cone1x05.mdl", one )
+list.Set( "WheelModels", "models/hunter/tubes/circle2x2.mdl", one )
+list.Set( "WheelModels", "models/hunter/tubes/circle4x4.mdl", one )
+
+--Primitive Mechanics
+list.Set( "WheelModels", "models/mechanics/wheels/bmw.mdl", one )
+list.Set( "WheelModels", "models/mechanics/wheels/bmwl.mdl", one )
+list.Set( "WheelModels", "models/mechanics/wheels/rim_1.mdl", one )
+list.Set( "WheelModels", "models/mechanics/wheels/tractor.mdl", one )
+list.Set( "WheelModels", "models/mechanics/wheels/wheel_2.mdl", one )
+list.Set( "WheelModels", "models/mechanics/wheels/wheel_2l.mdl", one )
+list.Set( "WheelModels", "models/mechanics/wheels/wheel_extruded_48.mdl", one )
+list.Set( "WheelModels", "models/mechanics/wheels/wheel_race.mdl", one )
+list.Set( "WheelModels", "models/mechanics/wheels/wheel_smooth2.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear12x12.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear12x12_large.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear12x12_small.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear12x24.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear12x24_large.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear12x24_small.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear12x6.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear12x6_large.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear12x6_small.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear16x12.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear16x12_large.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear16x12_small.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear16x24.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear16x24_large.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear16x24_small.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear16x6.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear16x6_large.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear16x6_small.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear24x12.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear24x12_large.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear24x12_small.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear24x24.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear24x24_large.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear24x24_small.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear24x6.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear24x6_large.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears/gear24x6_small.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_12t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_18t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_24t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_36t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_48t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_60t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_12t2.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_18t2.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_24t2.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_36t2.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_48t2.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_60t2.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_12t3.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_18t3.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_24t3.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_36t3.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_48t3.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/gear_60t3.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/bevel_12t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/bevel_18t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/bevel_24t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/bevel_36t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/bevel_48t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/bevel_60t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/vert_12t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/vert_18t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/vert_24t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/vert_36t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/pinion_20t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/pinion_40t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/pinion_80t1.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/pinion_20t2.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/pinion_40t2.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/pinion_80t2.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/pinion_20t3.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/pinion_40t3.mdl", one )
+list.Set( "WheelModels", "models/Mechanics/gears2/pinion_80t3.mdl", one )
+
+--XQM Model Pack Wheels
+list.Set( "WheelModels", "models/NatesWheel/nateswheel.mdl", zero )
+list.Set( "WheelModels", "models/NatesWheel/nateswheelwide.mdl", zero )
+list.Set( "WheelModels", "models/XQM/JetEnginePropeller.mdl", zero )
+list.Set( "WheelModels", "models/XQM/JetEnginePropellerMedium.mdl", zero )
+list.Set( "WheelModels", "models/XQM/JetEnginePropellerBig.mdl", zero )
+list.Set( "WheelModels", "models/XQM/JetEnginePropellerHuge.mdl", zero )
+list.Set( "WheelModels", "models/XQM/JetEnginePropellerLarge.mdl", zero )
+list.Set( "WheelModels", "models/XQM/HelicopterRotor.mdl", zero )
+list.Set( "WheelModels", "models/XQM/HelicopterRotorMedium.mdl", zero )
+list.Set( "WheelModels", "models/XQM/HelicopterRotorBig.mdl", zero )
+list.Set( "WheelModels", "models/XQM/HelicopterRotorHuge.mdl", zero )
+list.Set( "WheelModels", "models/XQM/HelicopterRotorLarge.mdl", zero )
+list.Set( "WheelModels", "models/XQM/Propeller1.mdl", zero )
+list.Set( "WheelModels", "models/XQM/Propeller1Medium.mdl", zero )
+list.Set( "WheelModels", "models/XQM/Propeller1Big.mdl", zero )
+list.Set( "WheelModels", "models/XQM/Propeller1Huge.mdl", zero )
+list.Set( "WheelModels", "models/XQM/Propeller1Large.mdl", zero )
+list.Set( "WheelModels", "models/XQM/AirPlaneWheel1.mdl", zero )
+list.Set( "WheelModels", "models/XQM/AirPlaneWheel1Medium.mdl", zero )
+list.Set( "WheelModels", "models/XQM/AirPlaneWheel1Big.mdl", zero )
+list.Set( "WheelModels", "models/XQM/AirPlaneWheel1Huge.mdl", zero )
+list.Set( "WheelModels", "models/XQM/AirPlaneWheel1Large.mdl", zero )
+
+--Xeon133's Wheels
+list.Set( "WheelModels", "models/xeon133/offroad/Off-road-20.mdl", zero )
+list.Set( "WheelModels", "models/xeon133/offroad/Off-road-30.mdl", zero )
+list.Set( "WheelModels", "models/xeon133/offroad/Off-road-40.mdl", zero )
+list.Set( "WheelModels", "models/xeon133/offroad/Off-road-50.mdl", zero )
+list.Set( "WheelModels", "models/xeon133/offroad/Off-road-60.mdl", zero )
+list.Set( "WheelModels", "models/xeon133/offroad/Off-road-70.mdl", zero )
+list.Set( "WheelModels", "models/xeon133/offroad/Off-road-80.mdl", zero )

gamemodes/sandbox/entities/weapons/gmod_tool/stools/winch.lua

@@ -0,0 +1,224 @@
+
+TOOL.Category = "Constraints"
+TOOL.Name = "#tool.winch.name"
+
+TOOL.ClientConVar[ "rope_material" ] = "cable/rope"
+TOOL.ClientConVar[ "rope_width" ] = "3"
+TOOL.ClientConVar[ "fwd_speed" ] = "64"
+TOOL.ClientConVar[ "bwd_speed" ] = "64"
+TOOL.ClientConVar[ "fwd_group" ] = "44"
+TOOL.ClientConVar[ "bwd_group" ] = "41"
+TOOL.ClientConVar[ "color_r" ] = "255"
+TOOL.ClientConVar[ "color_g" ] = "255"
+TOOL.ClientConVar[ "color_b" ] = "255"
+
+TOOL.Information = {
+	{ name = "left", stage = 0 },
+	{ name = "left_1", stage = 1, op = 1 },
+	{ name = "right", stage = 0 },
+	{ name = "reload" }
+}
+
+function TOOL:LeftClick( trace )
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then return end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local iNum = self:NumObjects()
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( iNum + 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+	self:SetOperation( 1 )
+
+	if ( iNum > 0 ) then
+
+		if ( CLIENT ) then
+			self:ClearObjects()
+			return true
+		end
+
+		local ply = self:GetOwner()
+		if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+			self:ClearObjects()
+			return false
+		end
+
+		-- Get client's CVars
+		local material = self:GetClientInfo( "rope_material" )
+		local width = self:GetClientNumber( "rope_width", 3 )
+		local fwd_bind = self:GetClientNumber( "fwd_group", 44 )
+		local bwd_bind = self:GetClientNumber( "bwd_group", 41 )
+		local fwd_speed = self:GetClientNumber( "fwd_speed", 64 )
+		local bwd_speed = self:GetClientNumber( "bwd_speed", 64 )
+		local colorR = self:GetClientNumber( "color_r" )
+		local colorG = self:GetClientNumber( "color_g" )
+		local colorB = self:GetClientNumber( "color_b" )
+		local toggle = false
+
+		-- Get information we're about to use
+		local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+		local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+		local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+
+		local constr, rope, controller = constraint.Winch( ply, Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, width, fwd_bind, bwd_bind, fwd_speed, bwd_speed, material, toggle, Color( colorR, colorG, colorB ) )
+		if ( IsValid( constr ) ) then
+			undo.Create( "Winch" )
+				undo.AddEntity( constr )
+				if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+				if ( IsValid( controller ) ) then undo.AddEntity( controller ) end
+				undo.SetPlayer( ply )
+				undo.SetCustomUndoText( "Undone #tool.winch.name" )
+			undo.Finish( "#tool.winch.name" )
+
+			ply:AddCount( "ropeconstraints", constr )
+			ply:AddCleanup( "ropeconstraints", constr )
+			if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+			if ( IsValid( controller ) ) then ply:AddCleanup( "ropeconstraints", controller ) end
+		end
+
+		-- Clear the objects so we're ready to go again
+		self:ClearObjects()
+
+	else
+
+		self:SetStage( iNum + 1 )
+
+	end
+
+	return true
+
+end
+
+function TOOL:RightClick( trace )
+
+	if ( self:GetOperation() == 1 ) then return false end
+
+	-- If there's no physics object then we can't constraint it!
+	if ( SERVER && !util.IsValidPhysicsObject( trace.Entity, trace.PhysicsBone ) ) then return false end
+
+	local Phys = trace.Entity:GetPhysicsObjectNum( trace.PhysicsBone )
+	self:SetObject( 1, trace.Entity, trace.HitPos, Phys, trace.PhysicsBone, trace.HitNormal )
+
+	local ply = self:GetOwner()
+
+	local tr_new = {}
+	tr_new.start = trace.HitPos
+	tr_new.endpos = trace.HitPos + ( trace.HitNormal * 16384 )
+	tr_new.filter = { ply }
+	if ( IsValid( trace.Entity ) ) then
+		table.insert( tr_new.filter, trace.Entity )
+	end
+
+	local tr = util.TraceLine( tr_new )
+	if ( !tr.Hit ) then
+		self:ClearObjects()
+		return false
+	end
+
+	-- Don't try to constrain world to world
+	if ( trace.HitWorld && tr.HitWorld ) then
+		self:ClearObjects()
+		return false
+	end
+
+	if ( IsValid( trace.Entity ) && trace.Entity:IsPlayer() ) then
+		self:ClearObjects()
+		return false
+	end
+	if ( IsValid( tr.Entity ) && tr.Entity:IsPlayer() ) then
+		self:ClearObjects()
+		return false
+	end
+
+	-- Check to see if the player can create a winch constraint with the entity in the trace
+	if ( !hook.Run( "CanTool", ply, tr, "winch", self, 2 ) ) then
+		self:ClearObjects()
+		return false
+	end
+
+	local Phys2 = tr.Entity:GetPhysicsObjectNum( tr.PhysicsBone )
+	self:SetObject( 2, tr.Entity, tr.HitPos, Phys2, tr.PhysicsBone, trace.HitNormal )
+
+	if ( CLIENT ) then
+		self:ClearObjects()
+		return true
+	end
+
+	if ( !ply:CheckLimit( "ropeconstraints" ) ) then
+		self:ClearObjects()
+		return false
+	end
+
+	-- Get client's CVars
+	local material = self:GetClientInfo( "rope_material" )
+	local width = self:GetClientNumber( "rope_width", 3 )
+	local fwd_bind = self:GetClientNumber( "fwd_group", 44 )
+	local bwd_bind = self:GetClientNumber( "bwd_group", 41 )
+	local fwd_speed = self:GetClientNumber( "fwd_speed", 64 )
+	local bwd_speed = self:GetClientNumber( "bwd_speed", 64 )
+	local colorR = self:GetClientNumber( "color_r" )
+	local colorG = self:GetClientNumber( "color_g" )
+	local colorB = self:GetClientNumber( "color_b" )
+	local toggle = false
+
+	-- Get information we're about to use
+	local Ent1, Ent2 = self:GetEnt( 1 ), self:GetEnt( 2 )
+	local Bone1, Bone2 = self:GetBone( 1 ), self:GetBone( 2 )
+	local LPos1, LPos2 = self:GetLocalPos( 1 ), self:GetLocalPos( 2 )
+
+	local constr, rope, controller = constraint.Winch( self:GetOwner(), Ent1, Ent2, Bone1, Bone2, LPos1, LPos2, width, fwd_bind, bwd_bind, fwd_speed, bwd_speed, material, toggle, Color( colorR, colorG, colorB ) )
+	if ( IsValid( constr ) ) then
+		undo.Create( "Winch" )
+			undo.AddEntity( constr )
+			if ( IsValid( rope ) ) then undo.AddEntity( rope ) end
+			if ( IsValid( controller ) ) then undo.AddEntity( controller ) end
+			undo.SetPlayer( ply )
+			undo.SetCustomUndoText( "Undone #tool.winch.name" )
+		undo.Finish( "#tool.winch.name" )
+
+		ply:AddCount( "ropeconstraints", constr )
+		ply:AddCleanup( "ropeconstraints", constr )
+		if ( IsValid( rope ) ) then ply:AddCleanup( "ropeconstraints", rope ) end
+		if ( IsValid( controller ) ) then ply:AddCleanup( "ropeconstraints", controller ) end
+	end
+
+	-- Clear the objects so we're ready to go again
+	self:ClearObjects()
+
+	return true
+
+end
+
+function TOOL:Reload( trace )
+
+	if ( !IsValid( trace.Entity ) || trace.Entity:IsPlayer() ) then return false end
+	if ( CLIENT ) then return true end
+
+	return constraint.RemoveConstraints( trace.Entity, "Winch" )
+
+end
+
+local ConVarsDefault = TOOL:BuildConVarList()
+
+function TOOL.BuildCPanel( CPanel )
+
+	CPanel:Help( "#tool.winch.help" )
+	CPanel:ToolPresets( "winch", ConVarsDefault )
+
+	CPanel:KeyBinder( "#tool.winch.forward", "winch_fwd_group", "#tool.winch.backward", "winch_bwd_group" )
+
+	CPanel:NumSlider( "#tool.winch.fspeed", "winch_fwd_speed", 0, 1000 )
+	CPanel:ControlHelp( "#tool.winch.fspeed.help" )
+
+	CPanel:NumSlider( "#tool.winch.bspeed", "winch_bwd_speed", 0, 1000 )
+	CPanel:ControlHelp( "#tool.winch.bspeed.help" )
+
+	CPanel:NumSlider( "#tool.winch.width", "winch_rope_width", 0, 10 )
+
+	CPanel:RopeSelect( "winch_rope_material" )
+
+	CPanel:ColorPicker( "#tool.winch.color", "winch_color_r", "winch_color_g", "winch_color_b" )
+
+end

gamemodes/sandbox/entities/weapons/manhack_welder.lua

@@ -0,0 +1,169 @@
+
+-- Variables that are used on both client and server
+
+SWEP.Instructions	= "Shoot a prop to attach a Manhack.\nRight click to attach a rollermine."
+SWEP.Author			= "Facepunch"
+
+SWEP.Spawnable			= true
+SWEP.AdminOnly			= true
+SWEP.UseHands			= true
+
+SWEP.ViewModel			= "models/weapons/c_pistol.mdl"
+SWEP.WorldModel			= "models/weapons/w_pistol.mdl"
+
+SWEP.Primary.ClipSize		= -1
+SWEP.Primary.DefaultClip	= -1
+SWEP.Primary.Automatic		= false
+SWEP.Primary.Ammo			= "none"
+
+SWEP.Secondary.ClipSize		= -1
+SWEP.Secondary.DefaultClip	= -1
+SWEP.Secondary.Automatic	= false
+SWEP.Secondary.Ammo			= "none"
+
+SWEP.Weight				= 5
+SWEP.AutoSwitchTo		= false
+SWEP.AutoSwitchFrom		= false
+
+SWEP.PrintName			= "#manhack_welder"
+SWEP.Slot				= 3
+SWEP.SlotPos			= 1
+SWEP.DrawAmmo			= false
+SWEP.DrawCrosshair		= true
+SWEP.UseHands			= true
+
+local ShootSound = Sound( "Metal.SawbladeStick" )
+
+--[[---------------------------------------------------------
+	Reload does nothing
+-----------------------------------------------------------]]
+function SWEP:Reload()
+end
+
+--[[---------------------------------------------------------
+	Think does nothing
+-----------------------------------------------------------]]
+function SWEP:Think()
+end
+
+--[[---------------------------------------------------------
+	PrimaryAttack
+-----------------------------------------------------------]]
+function SWEP:PrimaryAttack()
+
+	local owner = self:GetOwner()
+
+	local tr = util.TraceLine( util.GetPlayerTrace( owner ) )
+	--if ( tr.HitWorld ) then return end
+
+	if ( IsFirstTimePredicted() ) then
+		local effectdata = EffectData()
+		effectdata:SetOrigin( tr.HitPos )
+		effectdata:SetNormal( tr.HitNormal )
+		effectdata:SetMagnitude( 8 )
+		effectdata:SetScale( 1 )
+		effectdata:SetRadius( 16 )
+		util.Effect( "Sparks", effectdata )
+	end
+
+	self:EmitSound( ShootSound )
+
+	self:ShootEffects()
+
+	-- The rest is only done on the server
+	if ( CLIENT ) then return end
+
+	-- Make a manhack
+	local ent = ents.Create( "npc_manhack" )
+	if ( !IsValid( ent ) ) then return end
+
+	ent:SetPos( tr.HitPos + owner:GetAimVector() * -16 )
+	ent:SetAngles( tr.HitNormal:Angle() )
+	ent:Spawn()
+
+	local weld = nil
+
+	if ( tr.HitWorld ) then
+
+		-- freeze it in place
+		ent:GetPhysicsObject():EnableMotion( false )
+
+	else
+
+		-- Weld it to the object that we hit
+		weld = constraint.Weld( tr.Entity, ent, tr.PhysicsBone, 0, 0 )
+
+	end
+
+	if ( owner:IsPlayer() ) then
+		undo.Create( "npc_manhack" )
+			undo.AddEntity( weld )
+			undo.AddEntity( ent )
+			undo.SetPlayer( owner )
+		undo.Finish()
+	end
+
+end
+
+--[[---------------------------------------------------------
+	SecondaryAttack
+-----------------------------------------------------------]]
+function SWEP:SecondaryAttack()
+
+	local owner = self:GetOwner()
+
+	local tr = util.TraceLine( util.GetPlayerTrace( owner ) )
+	--if ( tr.HitWorld ) then return end
+
+	self:EmitSound( ShootSound )
+	self:ShootEffects()
+
+	if ( IsFirstTimePredicted() ) then
+		local effectdata = EffectData()
+		effectdata:SetOrigin( tr.HitPos )
+		effectdata:SetNormal( tr.HitNormal )
+		effectdata:SetMagnitude( 8 )
+		effectdata:SetScale( 1 )
+		effectdata:SetRadius( 16 )
+		util.Effect( "Sparks", effectdata )
+	end
+
+
+	-- The rest is only done on the server
+	if ( CLIENT ) then return end
+
+	-- Make a manhack
+	local ent = ents.Create( "npc_rollermine" )
+	if ( !IsValid( ent ) ) then return end
+
+	ent:SetPos( tr.HitPos + owner:GetAimVector() * -16 )
+	ent:SetAngles( tr.HitNormal:Angle() )
+	ent:Spawn()
+
+	local weld = nil
+
+	if ( !tr.HitWorld ) then
+
+		-- Weld it to the object that we hit
+		weld = constraint.Weld( tr.Entity, ent, tr.PhysicsBone, 0, 0 )
+
+	end
+
+	if ( owner:IsPlayer() ) then
+		undo.Create( "npc_rollermine" )
+			undo.AddEntity( weld )
+			undo.AddEntity( ent )
+			undo.SetPlayer( owner )
+		undo.Finish()
+	end
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: ShouldDropOnDie
+	Desc: Should this weapon be dropped when its owner dies?
+-----------------------------------------------------------]]
+function SWEP:ShouldDropOnDie()
+	return false
+end