Initial commit

lua/includes/extensions/angle.lua

@@ -0,0 +1,18 @@
+local meta = FindMetaTable( "Angle" )
+
+-- Nothing in here, still leaving this file here just in case
+
+--[[---------------------------------------------------------
+	Angle Snap to nearest interval of degrees
+-----------------------------------------------------------]]
+function meta:SnapTo( component, degrees )
+
+	if ( degrees == 0 ) then ErrorNoHalt( "The snap degrees must be non-zero.\n" ); return self; end
+	if ( !self[ component ] ) then ErrorNoHalt( "You must choose a valid component of Angle( p || pitch, y || yaw, r || roll ) to snap such as Angle( 80, 40, 30 ):SnapTo( \"p\", 90 ):SnapTo( \"y\", 45 ):SnapTo( \"r\", 40 ); and yes, you can keep adding snaps.\n" ); return self; end
+
+	self[ component ] = math.Round( self[ component ] / degrees ) * degrees
+	self[ component ] = math.NormalizeAngle( self[ component ] )
+
+	return self
+
+end

lua/includes/extensions/client/entity.lua

@@ -0,0 +1,17 @@
+
+if ( SERVER ) then return end
+
+local meta = FindMetaTable( "Entity" )
+if ( !meta ) then return end
+
+
+--
+-- You can set the render angles and render origin on
+-- any entity. It will then render the entity at that
+-- origin using those angles.
+--
+-- Set them to nil if you don't want to override anything.
+--
+
+AccessorFunc( meta, "m_RenderAngles", "RenderAngles" )
+AccessorFunc( meta, "m_RenderOrigin", "RenderOrigin" )

lua/includes/extensions/client/globals.lua

@@ -0,0 +1,14 @@
+
+
+if ( SERVER ) then return end
+
+
+function ScreenScale( width )
+	return width * ( ScrW() / 640.0 )
+end
+
+function ScreenScaleH( height )
+	return height * ( ScrH() / 480.0 )
+end
+
+SScale = ScreenScale

lua/includes/extensions/client/panel.lua

@@ -0,0 +1,621 @@
+
+include ( "panel/animation.lua" )
+include ( "panel/dragdrop.lua" )
+include ( "panel/selections.lua" )
+include ( "panel/scriptedpanels.lua" )
+
+local meta = FindMetaTable( "Panel" )
+
+AccessorFunc( meta, "m_strCookieName", "CookieName" )
+
+meta.SetFGColorEx = meta.SetFGColor
+meta.SetBGColorEx = meta.SetBGColor
+
+--[[---------------------------------------------------------
+	Name: SetFGColor
+	Desc: Override to make it possible to pass Color's
+-----------------------------------------------------------]]
+function meta:SetFGColor( r, g, b, a )
+
+	if ( istable( r ) ) then
+		return self:SetFGColorEx( r.r, r.g, r.b, r.a )
+	end
+
+	return self:SetFGColorEx( r, g, b, a )
+
+end
+
+--[[---------------------------------------------------------
+	Name: SetBGColor
+	Desc: Override to make it possible to pass Color's
+-----------------------------------------------------------]]
+function meta:SetBGColor( r, g, b, a )
+
+	if ( istable( r ) ) then
+		return self:SetBGColorEx( r.r, r.g, r.b, r.a )
+	end
+
+	return self:SetBGColorEx( r, g, b, a )
+
+end
+
+--[[---------------------------------------------------------
+	Name: SetHeight
+-----------------------------------------------------------]]
+function meta:SetHeight( h )
+	self:SetSize( self:GetWide(), h )
+end
+meta.SetTall = meta.SetHeight
+
+--[[---------------------------------------------------------
+	Name: SetHeight
+-----------------------------------------------------------]]
+function meta:SetWidth( w )
+	self:SetSize( w, self:GetTall() )
+end
+meta.SetWide = meta.SetWidth
+
+
+--[[---------------------------------------------------------
+	Name: Set/GetX/Y
+-----------------------------------------------------------]]
+function meta:GetX()
+	local x, y = self:GetPos()
+	return x
+end
+function meta:GetY()
+	local x, y = self:GetPos()
+	return y
+end
+function meta:SetX( x )
+	self:SetPos( x, self:GetY() )
+end
+function meta:SetY( y )
+	self:SetPos( self:GetX(), y )
+end
+
+--[[---------------------------------------------------------
+	Name: StretchToParent (borders)
+-----------------------------------------------------------]]
+function meta:StretchToParent( l, u, r, d )
+
+	local w, h = self:GetParent():GetSize()
+
+	if ( l != nil ) then
+		self.x = l
+	end
+
+	if ( u != nil ) then
+		self.y = u
+	end
+
+	if ( r != nil ) then
+		self:SetWide( w - self.x - r )
+	end
+
+	if ( d != nil ) then
+		self:SetTall( h - self.y - d )
+	end
+
+	--self:SetPos( l, u )
+	--self:SetSize( w - (r + l), h - (d + u) )
+
+end
+
+--[[---------------------------------------------------------
+	Name: CopyHeight
+-----------------------------------------------------------]]
+function meta:CopyHeight( pnl )
+	self:SetTall( pnl:GetTall() )
+end
+
+--[[---------------------------------------------------------
+	Name: CopyWidth
+-----------------------------------------------------------]]
+function meta:CopyWidth( pnl )
+	self:SetWide( pnl:GetWide() )
+end
+
+--[[---------------------------------------------------------
+	Name: CopyPos
+-----------------------------------------------------------]]
+function meta:CopyPos( pnl )
+	self:SetPos( pnl:GetPos() )
+end
+
+--[[---------------------------------------------------------
+	Name: Align with the edge of the parent
+-----------------------------------------------------------]]
+function meta:AlignBottom( m ) self:SetPos( self.x, self:GetParent():GetTall() - self:GetTall() - ( m or 0 ) ) end
+function meta:AlignRight( m ) self:SetPos( self:GetParent():GetWide() - self:GetWide() - ( m or 0 ), self.y ) end
+function meta:AlignTop( m ) self:SetPos( self.x, m or 0 ) end
+function meta:AlignLeft( m ) self:SetPos( m or 0, self.y ) end
+
+--[[---------------------------------------------------------
+	Name: Move relative to another panel
+-----------------------------------------------------------]]
+function meta:MoveAbove( pnl, m ) self:SetPos( self.x, pnl.y - self:GetTall() - ( m or 0 ) ) end
+function meta:MoveBelow( pnl, m ) self:SetPos( self.x, pnl.y + pnl:GetTall() + ( m or 0 ) ) end
+function meta:MoveRightOf( pnl, m ) self:SetPos( pnl.x + pnl:GetWide() + ( m or 0 ), self.y ) end
+function meta:MoveLeftOf( pnl, m ) self:SetPos( pnl.x - self:GetWide() - ( m or 0 ), self.y ) end
+
+--[[---------------------------------------------------------
+	Name: StretchRightTo
+-----------------------------------------------------------]]
+function meta:StretchRightTo( pnl, m ) self:SetWide( pnl.x - self.x - ( m or 0 ) ) end
+function meta:StretchBottomTo( pnl, m ) self:SetTall( pnl.y - self.y - ( m or 0 ) ) end
+
+--[[---------------------------------------------------------
+	Name: CenterVertical
+-----------------------------------------------------------]]
+function meta:CenterVertical( fraction )
+	self:SetY( self:GetParent():GetTall() * ( fraction or 0.5 ) - self:GetTall() * 0.5 )
+end
+
+--[[---------------------------------------------------------
+	Name: CenterHorizontal
+-----------------------------------------------------------]]
+function meta:CenterHorizontal( fraction )
+	self:SetX( self:GetParent():GetWide() * ( fraction or 0.5 ) - self:GetWide() * 0.5 )
+end
+
+--[[---------------------------------------------------------
+	Name: CenterHorizontal
+-----------------------------------------------------------]]
+function meta:Center()
+
+	self:CenterVertical()
+	self:CenterHorizontal()
+
+end
+
+--[[---------------------------------------------------------
+	Name: CopyBounds
+-----------------------------------------------------------]]
+function meta:CopyBounds( pnl )
+
+	local x, y, w, h = pnl:GetBounds()
+
+	self:SetPos( x, y )
+	self:SetSize( w, h )
+
+end
+
+--[[---------------------------------------------------------
+	Name: GetCookieNumber
+-----------------------------------------------------------]]
+function meta:SetCookieName( cookiename )
+
+	self.m_strCookieName = cookiename
+
+	-- If we have a loadcookies function, call it.
+	if ( self.LoadCookies ) then
+		self:LoadCookies()
+		self:InvalidateLayout()
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: GetCookieNumber
+-----------------------------------------------------------]]
+function meta:GetCookieNumber( cookiename, default )
+
+	local name = self:GetCookieName()
+	if ( !name ) then return default end
+
+	return cookie.GetNumber( name .. "." .. cookiename, default )
+
+end
+
+--[[---------------------------------------------------------
+	Name: GetCookie
+-----------------------------------------------------------]]
+function meta:GetCookie( cookiename, default )
+
+	local name = self:GetCookieName()
+	if ( !name ) then return default end
+
+	return cookie.GetString( name .. "." .. cookiename, default )
+
+end
+
+--[[---------------------------------------------------------
+	Name: SetCookie
+-----------------------------------------------------------]]
+function meta:SetCookie( cookiename, value )
+
+	local name = self:GetCookieName()
+	if ( !name ) then return end
+
+	return cookie.Set( name .. "." .. cookiename, value )
+
+end
+
+--[[---------------------------------------------------------
+	Name: DeleteCookie
+-----------------------------------------------------------]]
+function meta:DeleteCookie( cookiename )
+
+	local name = self:GetCookieName()
+	if ( !name ) then return end
+
+	return cookie.Delete( name .. "." .. cookiename )
+
+end
+
+--[[---------------------------------------------------------
+	Name: InvalidateParent
+-----------------------------------------------------------]]
+function meta:InvalidateParent( layoutnow )
+
+	local parent = self:GetParent()
+	if ( !parent ) then return end
+	if ( self.LayingOutParent ) then return end
+
+	self.LayingOutParent = true
+	parent:InvalidateLayout( layoutnow )
+	self.LayingOutParent = false
+
+end
+
+--[[---------------------------------------------------------
+	Name: PositionLabel
+-----------------------------------------------------------]]
+function meta:PositionLabel( labelWidth, x, y, lbl, ctrl )
+
+	lbl:SetWide( labelWidth )
+	lbl:SetPos( x, y )
+
+	ctrl.y = y
+	ctrl:MoveRightOf( lbl, 0 )
+
+	return y + math.max( lbl:GetTall(), ctrl:GetTall() )
+
+end
+
+--[[---------------------------------------------------------
+	Name: GetTooltip
+-----------------------------------------------------------]]
+function meta:GetTooltip()
+	return self.strTooltipText
+end
+
+--[[---------------------------------------------------------
+	Name: GetTooltipPanel
+-----------------------------------------------------------]]
+function meta:GetTooltipPanel()
+	return self.pnlTooltipPanel
+end
+
+--[[---------------------------------------------------------
+	Name: GetTooltipDelay
+-----------------------------------------------------------]]
+function meta:GetTooltipDelay()
+	return self.numTooltipDelay
+end
+
+--[[---------------------------------------------------------
+	Name: SetTooltip
+-----------------------------------------------------------]]
+function meta:SetTooltip( tooltip )
+	self.strTooltipText = tooltip
+end
+meta.SetToolTip = meta.SetTooltip
+
+--[[---------------------------------------------------------
+	Name: SetTooltipPanel
+-----------------------------------------------------------]]
+function meta:SetTooltipPanel( panel )
+	self.pnlTooltipPanel = panel
+	if ( IsValid( panel ) ) then panel:SetVisible( false ) end
+end
+meta.SetToolTipPanel = meta.SetTooltipPanel
+
+-- Override which panel will be created instead of DTooltip
+function meta:SetTooltipPanelOverride( panel )
+	self.pnlTooltipPanelOverride = panel
+end
+
+--[[---------------------------------------------------------
+	Name: SetTooltipDelay
+-----------------------------------------------------------]]
+function meta:SetTooltipDelay( delay )
+	self.numTooltipDelay = delay
+end
+
+--[[---------------------------------------------------------
+	Name: SizeToContentsY (Only works on Labels)
+-----------------------------------------------------------]]
+function meta:SizeToContentsY( addval )
+
+	local w, h = self:GetContentSize()
+	if ( !w || !h ) then return end
+
+	self:SetTall( h + ( addval or 0 ) )
+
+end
+
+--[[---------------------------------------------------------
+	Name: SizeToContentsX (Only works on Labels)
+-----------------------------------------------------------]]
+function meta:SizeToContentsX( addval )
+
+	local w, h = self:GetContentSize()
+	if ( !w || !h ) then return end
+
+	self:SetWide( w + ( addval or 0 ) )
+
+end
+
+-- Make sure all children update their skin, if SOMEHOW they cached their skin before the parent
+local function InvalidateSkinRecurse( self )
+
+	for id, pnl in pairs( self:GetChildren() ) do
+		InvalidateSkinRecurse( pnl )
+		pnl.m_iSkinIndex = nil
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: SetSkin
+-----------------------------------------------------------]]
+function meta:SetSkin( strSkin )
+
+	if ( self.m_ForceSkinName == strSkin ) then return end
+
+	self.m_ForceSkinName = strSkin
+	self.m_iSkinIndex = nil
+
+	InvalidateSkinRecurse( self )
+
+end
+
+--[[---------------------------------------------------------
+	Name: GetSkin
+-----------------------------------------------------------]]
+function meta:GetSkin()
+
+	local skin = nil
+
+	if ( derma.SkinChangeIndex() == self.m_iSkinIndex ) then
+
+		skin = self.m_Skin
+		if ( skin ) then return skin end
+
+	end
+
+	-- We have a default skin
+	if ( !skin && self.m_ForceSkinName ) then
+		skin = derma.GetNamedSkin( self.m_ForceSkinName )
+	end
+
+	-- No skin, inherit from parent
+	local parent = self:GetParent()
+	if ( !skin && IsValid( parent ) ) then
+		skin = parent:GetSkin()
+	end
+
+	-- Parent had no skin, use default
+	if ( !skin ) then
+		skin = derma.GetDefaultSkin()
+	end
+
+	-- Save skin details on us so we don't have to keep looking up
+	self.m_Skin = skin
+	self.m_iSkinIndex = derma.SkinChangeIndex()
+
+	self:InvalidateLayout( false )
+
+	return skin
+
+end
+
+--[[---------------------------------------------------------
+	Name: ToggleVisible
+-----------------------------------------------------------]]
+function meta:ToggleVisible()
+	self:SetVisible( !self:IsVisible() )
+end
+
+function meta:Distance( pnl )
+
+	if ( !IsValid( pnl ) ) then return 0 end
+
+	return self:DistanceFrom( pnl.x + pnl:GetWide() * 0.5, pnl.y + pnl:GetTall() * 0.5 )
+
+end
+
+function meta:DistanceFrom( x, y )
+
+	local x = self.x + self:GetWide() * 0.5 - x
+	local y = self.y + self:GetTall() * 0.5 - y
+
+	return math.sqrt( x * x + y * y )
+
+end
+
+--[[---------------------------------------------------------
+	Name: Retusn the child position on this panel. Even if its parented to children of children.
+-----------------------------------------------------------]]
+function meta:GetChildPosition( pnl )
+
+	local x = 0
+	local y = 0
+
+	while ( IsValid( pnl ) && pnl != self ) do
+
+		x = x + pnl.x
+		y = y + pnl.y
+
+		pnl = pnl:GetParent()
+
+	end
+
+	return x, y
+
+end
+
+--[[---------------------------------------------------------
+	Name: Returns true if the panel is valid. This does not
+		check the type. If the passed object is anything other
+		than a panel or nil, this will error. (speed)
+-----------------------------------------------------------]]
+function ValidPanel( pnl )
+
+	if ( !pnl ) then return false end
+
+	return pnl:IsValid()
+
+end
+
+function meta:InvalidateChildren( bRecurse )
+
+	for k, v in ipairs( self:GetChildren() ) do
+
+		if ( bRecurse ) then
+			v:InvalidateChildren( true )
+		else
+			v:InvalidateLayout( true )
+		end
+
+	end
+
+	self:InvalidateLayout( true )
+
+end
+
+function meta:IsOurChild( child )
+
+	if ( !IsValid( child ) ) then return false end
+
+	return child:HasParent( self )
+
+end
+
+function meta:CopyBase( pnl )
+
+	self:CopyBounds( pnl )
+	self:Dock( pnl:GetDock() )
+
+	// TODO. More.
+
+end
+
+function meta:Add( pnl )
+
+	if ( isstring( pnl ) ) then
+		local pnl = vgui.Create( pnl, self )
+		return pnl
+	end
+
+	if ( istable( pnl ) ) then
+		local pnl = vgui.CreateFromTable( pnl, self )
+		return pnl
+	end
+
+	pnl:SetParent( self )
+	return pnl
+
+end
+
+function meta:GetClosestChild( x, y )
+
+	local distance = 9999
+	local closest = nil
+
+	for k, v in ipairs( self:GetChildren() ) do
+		local dist = v:DistanceFrom( x, y )
+		if ( dist < distance ) then
+			distance = dist
+			closest = v
+		end
+	end
+
+	return closest, distance
+
+end
+
+function meta:LocalCursorPos()
+	return self:ScreenToLocal( gui.MouseX(), gui.MouseY() )
+end
+
+function meta:MoveToAfter( pnl )
+
+	local children = self:GetParent():GetChildren()
+
+	-- remove us from the table
+	table.RemoveByValue( children, self )
+
+	-- find the key, where we want to be
+	local key = table.KeyFromValue( children, pnl )
+
+	if ( key ) then
+		-- insert us where we wanna be
+		table.insert( children, key + 1, self )
+	else
+		return false
+	end
+
+	for k, v in ipairs( children ) do
+		v:SetZPos( k )
+	end
+
+end
+
+function meta:MoveToBefore( pnl )
+
+	local children = self:GetParent():GetChildren()
+
+	-- remove us from the table
+	table.RemoveByValue( children, self )
+
+	-- find the key, where we want to be
+	local key = table.KeyFromValue( children, pnl )
+
+	if ( key ) then
+		-- insert us where we wanna be
+		table.insert( children, key, self )
+	else
+		return false
+	end
+
+	for k, v in ipairs( children ) do
+		v:SetZPos( k )
+	end
+
+end
+
+function meta:Clear()
+
+	for k, panel in ipairs( self:GetChildren() ) do
+		panel:Remove()
+	end
+
+end
+
+function meta:IsHovered()
+	return vgui.GetHoveredPanel() == self
+end
+
+function meta:Show()
+	self:SetVisible( true )
+end
+
+function meta:Hide()
+	self:SetVisible( false )
+end
+
+function meta:IsChildHovered( bImmediate )
+
+	local Hovered = vgui.GetHoveredPanel()
+	if ( !IsValid( Hovered ) ) then return false end
+	if ( Hovered == self ) then return false end
+
+	-- Check immediate child only (with support for old depth parameter)
+	if ( bImmediate == true or bImmediate == 1 ) then return Hovered:GetParent() == self end
+
+	return Hovered:HasParent( self )
+
+end

lua/includes/extensions/client/panel/animation.lua

@@ -0,0 +1,365 @@
+
+if ( SERVER ) then return end
+
+local meta = FindMetaTable( "Panel" )
+
+--[[---------------------------------------------------------
+	Name: SetTerm
+	Desc: Kill the panel at this time
+-----------------------------------------------------------]]
+function meta:SetTerm( term )
+
+	self.Term = SysTime() + term
+	self:SetAnimationEnabled( true )
+
+end
+
+--[[---------------------------------------------------------
+	Name: AnimationThinkInternal
+-----------------------------------------------------------]]  
+function meta:AnimationThinkInternal()
+
+	local systime = SysTime()
+
+	if ( self.Term && self.Term <= systime ) then self:Remove() return end
+	if ( !self.m_AnimList ) then return end -- This can happen if we only have term
+
+	for k, anim in pairs( self.m_AnimList ) do
+
+		if ( systime >= anim.StartTime ) then
+
+			local Fraction = math.TimeFraction( anim.StartTime, anim.EndTime, systime )
+			Fraction = math.Clamp( Fraction, 0, 1 )
+
+			if ( anim.Think ) then
+
+				local Frac = Fraction ^ anim.Ease
+
+				-- Ease of -1 == ease in out
+				if ( anim.Ease < 0 ) then
+					Frac = Fraction ^ ( 1.0 - ( ( Fraction - 0.5 ) ) )
+				elseif ( anim.Ease > 0 && anim.Ease < 1 ) then
+					Frac = 1 - ( ( 1 - Fraction ) ^ ( 1 / anim.Ease ) )
+				end
+
+				anim:Think( self, Frac )
+			end
+
+			if ( Fraction == 1 ) then
+
+				if ( anim.OnEnd ) then anim:OnEnd( self ) end
+
+				self.m_AnimList[k] = nil
+			end
+
+		end
+
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: SetAnimationEnabled
+	Desc: Enables animations on a panel
+-----------------------------------------------------------]]  
+function meta:SetAnimationEnabled( b )
+
+	if ( !b ) then
+		self.AnimationThink = nil
+		return
+	end
+
+	if ( self.AnimationThink ) then return end
+
+	self.AnimationThink = self.AnimationThinkInternal
+
+end
+
+function meta:Stop()
+
+	self.m_AnimList = {}
+
+end
+
+function meta:Queue()
+
+	self.m_AnimQueue = true
+
+end
+
+function meta:AnimTail()
+
+	local last = SysTime()
+
+	for k, anim in pairs( self.m_AnimList ) do
+		last = math.max( last, anim.EndTime )
+	end
+
+	return last
+
+end
+
+--[[---------------------------------------------------------
+	Name: NewAnimation
+	Desc: Creates a new animation
+-----------------------------------------------------------]]  
+function meta:NewAnimation( length, delay, ease, callback )
+
+	if ( delay == nil ) then delay = 0 end
+	if ( ease == nil ) then ease = -1 end
+
+	if ( self.m_AnimQueue ) then
+
+		delay = delay + self:AnimTail()
+		self.m_AnimQueue = false
+
+	else
+
+		delay = delay + SysTime()
+
+	end
+
+	local anim = {
+		EndTime = delay + length,
+		StartTime = delay,
+		Ease = ease,
+		OnEnd = callback
+	}
+
+	self:SetAnimationEnabled( true )
+	if ( self.m_AnimList == nil ) then self.m_AnimList = {} end
+
+	table.insert( self.m_AnimList, anim )
+
+	return anim
+
+end
+
+local function MoveThink( anim, panel, fraction )
+
+	if ( !anim.StartPos ) then anim.StartPos = Vector( panel.x, panel.y, 0 ) end
+	local pos = LerpVector( fraction, anim.StartPos, anim.Pos )
+	panel:SetPos( pos.x, pos.y )
+
+end
+
+--[[---------------------------------------------------------
+	Name: MoveTo
+-----------------------------------------------------------]]
+function meta:MoveTo( x, y, length, delay, ease, callback )
+
+	if ( self.x == x && self.y == y ) then return end
+
+	local anim = self:NewAnimation( length, delay, ease, callback )
+	anim.Pos = Vector( x, y, 0 )
+	anim.Think = MoveThink
+
+end
+
+local function SizeThink( anim, panel, fraction )
+
+	if ( !anim.StartSize ) then local w, h = panel:GetSize() anim.StartSize = Vector( w, h, 0 ) end
+
+	local size = LerpVector( fraction, anim.StartSize, anim.Size )
+
+	if ( anim.SizeX && anim.SizeY ) then
+		panel:SetSize( size.x, size.y )
+	elseif ( anim.SizeX ) then
+		panel:SetWide( size.x )
+	else
+		panel:SetTall( size.y )
+	end
+
+	if ( panel:GetDock() > 0 ) then
+		panel:InvalidateParent()
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: SizeTo
+-----------------------------------------------------------]]
+function meta:SizeTo( w, h, length, delay, ease, callback )
+
+	local anim = self:NewAnimation( length, delay, ease, callback )
+
+	anim.SizeX = w != -1
+	anim.SizeY = h != -1
+
+	if ( !anim.SizeX ) then  w = self:GetWide() end
+	if ( !anim.SizeY ) then  h = self:GetTall() end
+
+	anim.Size = Vector( w, h, 0 )
+
+	anim.Think = SizeThink
+	return anim
+
+end
+
+--[[---------------------------------------------------------
+	Name: SlideUp
+-----------------------------------------------------------]]
+function meta:SlideUp( length )
+
+	local height = self:GetTall()
+	local anim = self:SizeTo( -1, 0, length )
+	anim.OnEnd = function()
+		self:SetVisible( false )
+		self:SetTall( height )
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: SlideDown
+-----------------------------------------------------------]]
+function meta:SlideDown( length )
+
+	local height = self:GetTall()
+	self:SetVisible( true )
+	self:SetTall( 0 )
+
+	local anim = self:SizeTo( -1, height, length )
+
+end
+
+local function ColorThink( anim, panel, fraction )
+
+	if ( !anim.StartColor ) then anim.StartColor = panel:GetColor() end
+
+	panel:SetColor( Color( Lerp( fraction, anim.StartColor.r, anim.Color.r ),
+					Lerp( fraction, anim.StartColor.g, anim.Color.g ),
+					Lerp( fraction, anim.StartColor.b, anim.Color.b ),
+					Lerp( fraction, anim.StartColor.a, anim.Color.a ) ) )
+
+end
+
+--[[---------------------------------------------------------
+	Name: ColorTo
+-----------------------------------------------------------]]
+function meta:ColorTo( col, length, delay, callback )
+
+	-- We can only use this on specific panel types!
+	if ( !self.SetColor ) then return end
+	if ( !self.GetColor ) then return end
+
+	local anim = self:NewAnimation( length, delay, nil, callback )
+	anim.Color = col
+	anim.Think = ColorThink
+
+end
+
+local function AlphaThink( anim, panel, fraction )
+
+	if ( !anim.StartAlpha ) then anim.StartAlpha = panel:GetAlpha() end
+
+	panel:SetAlpha( Lerp( fraction, anim.StartAlpha, anim.Alpha ) )
+
+end
+
+--[[---------------------------------------------------------
+	Name: AlphaTo
+-----------------------------------------------------------]]
+function meta:AlphaTo( alpha, length, delay, callback )
+
+	local anim = self:NewAnimation( length, delay, nil, callback )
+	anim.Alpha = alpha
+	anim.Think = AlphaThink
+
+end
+
+local function MoveByThink( anim, panel, fraction )
+
+	if ( !anim.StartPos ) then
+		anim.StartPos = Vector( panel.x, panel.y, 0 )
+		anim.Pos = anim.StartPos + anim.Pos
+	end
+
+	local pos = LerpVector( fraction, anim.StartPos, anim.Pos )
+	panel:SetPos( pos.x, pos.y )
+
+end
+
+--[[---------------------------------------------------------
+	Name: MoveBy
+-----------------------------------------------------------]]
+function meta:MoveBy( x, y, length, delay, ease, callback )
+
+	local anim = self:NewAnimation( length, delay, ease, callback )
+	anim.Pos = Vector( x, y, 0 )
+	anim.Think = MoveByThink
+
+end
+
+-- This code is bad and will run forever, never reaching the targetpos.
+local function LerpPositions( anim, panel )
+
+	if ( !panel.TargetPos ) then return end
+
+	local Speed = FrameTime() * 100 * anim.Speed
+	local Pos = Vector( panel.x, panel.y, 0 )
+	local Distance = panel.TargetPos - Pos
+	local Length = Distance:Length()
+
+	if ( anim.UseGravity && Length > 1 ) then
+		Speed = Speed * ( Length * 0.1 )
+	else
+		Speed = Speed * 10
+	end
+
+	if ( Length < Speed ) then
+		panel:SetPosReal( panel.TargetPos.x, panel.TargetPos.y )
+		panel.TargetPos = nil
+		return
+	end
+
+	Distance:Normalize()
+	Distance = Pos + ( Distance * Speed )
+
+	panel:SetPosReal( Distance.x, Distance.y )
+
+end
+
+local function NewSetPos( self, x, y )
+
+	self.TargetPos = Vector( x, y )
+
+end
+
+local function NewGetPos( self )
+
+	return self.TargetPos.x, self.TargetPos.y
+
+end
+
+--[[---------------------------------------------------------
+	Name: LerpPositions
+-----------------------------------------------------------]]
+function meta:LerpPositions( speed, usegravity )
+
+	if ( self.SetPosReal ) then return end
+
+	NewSetPos( self, self:GetPos() )
+
+	self.SetPosReal = self.SetPos
+	self.SetPos = NewSetPos
+	self.GetPosReal = self.GetPos
+	self.GetPos = NewGetPos
+
+	self.LerpAnim = self:NewAnimation( 86400 )
+	self.LerpAnim.Speed = speed
+	self.LerpAnim.UseGravity = usegravity
+	self.LerpAnim.Think = LerpPositions
+
+end
+
+--
+-- DisableLerp
+--
+function meta:DisableLerp()
+
+	self.LerpAnim = nil
+	self.SetPos = self.SetPosReal
+	self.GetPos = self.GetPosReal
+
+end

lua/includes/extensions/client/panel/dragdrop.lua

@@ -0,0 +1,585 @@
+
+if ( SERVER ) then return end
+
+dragndrop = {}
+
+function dragndrop.Clear()
+
+	dragndrop.m_Receiver		= nil
+	dragndrop.m_ReceiverSlot	= nil
+	dragndrop.m_HoverStart		= nil
+	dragndrop.m_MouseCode		= 0
+	dragndrop.m_DragWatch		= nil
+	dragndrop.m_MouseX			= 0
+	dragndrop.m_MouseY			= 0
+	dragndrop.m_DraggingMain	= nil
+	dragndrop.m_Dragging		= nil
+	dragndrop.m_DropMenu		= nil
+
+end
+
+function dragndrop.IsDragging()
+
+	if ( dragndrop.m_Dragging != nil ) then return true end
+
+	return false
+
+end
+
+function dragndrop.HandleDroppedInGame()
+
+	local panel = vgui.GetHoveredPanel()
+	if ( !IsValid( panel ) ) then return end
+	if ( panel:GetClassName() != "CGModBase" ) then return end
+
+end
+
+function dragndrop.Drop()
+
+	if ( dragndrop.HandleDroppedInGame() ) then
+		dragndrop.StopDragging()
+		return
+	end
+
+	-- Show the menu
+	if ( dragndrop.m_MouseCode == MOUSE_RIGHT && dragndrop.m_ReceiverSlot && dragndrop.m_ReceiverSlot.Menu ) then
+
+		local x, y = dragndrop.m_Receiver:LocalCursorPos()
+
+		local menu = DermaMenu()
+		menu.OnRemove = function( m ) -- If user clicks outside of the menu - drop the dragging
+			dragndrop.StopDragging()
+		end
+
+		for k, v in pairs( dragndrop.m_ReceiverSlot.Menu ) do
+
+			local opt = menu:AddOption( v, function()
+
+				dragndrop.CallReceiverFunction( true, k, x, y )
+				dragndrop.StopDragging()
+
+			end )
+
+			-- HACK: This is lame, but there's no other way that I can see to get icons for these
+			if ( k == "move" ) then opt:SetIcon( "icon16/arrow_turn_right.png" ) end
+			if ( k == "copy" ) then opt:SetIcon( "icon16/arrow_branch.png" ) end
+
+		end
+
+		menu:Open()
+
+		dragndrop.m_DropMenu = menu
+
+		return
+
+	end
+
+	dragndrop.CallReceiverFunction( true, nil, nil, nil )
+	dragndrop.StopDragging()
+
+end
+
+function dragndrop.StartDragging()
+
+	if ( !dragndrop.m_DragWatch:IsSelected() ) then
+
+		dragndrop.m_Dragging = { dragndrop.m_DragWatch }
+
+	else
+
+		local canvas = dragndrop.m_DragWatch:GetSelectionCanvas()
+		dragndrop.m_Dragging = {}
+
+		for k, v in pairs( canvas:GetSelectedChildren() ) do
+
+			if ( !v.m_DragSlot ) then continue end
+
+			table.insert( dragndrop.m_Dragging, v )
+
+		end
+
+	end
+
+	for k, v in pairs( dragndrop.m_Dragging ) do
+
+		if ( !IsValid( v ) ) then continue end
+
+		v:OnStartDragging()
+
+	end
+
+	dragndrop.m_DraggingMain = dragndrop.m_DragWatch
+	dragndrop.m_DraggingMain:MouseCapture( true )
+	dragndrop.m_DragWatch = nil
+
+end
+
+function dragndrop.StopDragging()
+
+	if ( IsValid( dragndrop.m_Receiver ) ) then
+		dragndrop.m_Receiver:DragHoverEnd()
+		dragndrop.m_Receiver = nil
+	end
+
+	for k, v in pairs( dragndrop.m_Dragging or {} ) do
+
+		if ( !IsValid( v ) ) then continue end
+		v:OnStopDragging()
+
+	end
+
+	dragndrop.Clear()
+
+end
+
+function dragndrop.UpdateReceiver()
+
+	local hovered = vgui.GetHoveredPanel()
+	local receiver = nil
+	local receiverslot = nil
+
+	if ( IsValid( hovered ) ) then
+		receiver, receiverslot = hovered:GetValidReceiverSlot()
+	end
+
+	if ( IsValid( dragndrop.m_Receiver ) ) then
+
+		if ( receiver == dragndrop.m_Receiver ) then return end
+
+		dragndrop.m_Receiver:DragHoverEnd()
+
+	end
+
+	if ( !IsValid( receiver ) ) then
+		dragndrop.m_Receiver = nil
+		dragndrop.m_ReceiverSlot = nil
+	end
+
+	dragndrop.m_Receiver = receiver
+	dragndrop.m_ReceiverSlot = receiverslot
+
+end
+
+--
+-- Return all the dragged panels that match this name
+--
+function dragndrop.GetDroppable( name )
+
+	if ( !name ) then return dragndrop.m_Dragging end
+	if ( !dragndrop.m_Dragging ) then return end
+
+	local t = {}
+	for id, pnl in pairs( dragndrop.m_Dragging ) do
+		if ( pnl.m_DragSlot && pnl.m_DragSlot[ name ] ) then table.insert( t, pnl ) end
+	end
+	return t
+
+end
+
+function dragndrop.CallReceiverFunction( bDoDrop, command, mx, my )
+
+	if ( !dragndrop.m_ReceiverSlot ) then return end
+	if ( !IsValid( dragndrop.m_Receiver ) ) then return end
+
+	local x, y = dragndrop.m_Receiver:LocalCursorPos()
+	if ( mx ) then x = mx end
+	if ( my ) then y = my end
+
+	if ( dragndrop.m_ReceiverSlot.Func ) then
+
+		local droppable = dragndrop.GetDroppable( dragndrop.m_ReceiverSlot.Name )
+
+		dragndrop.m_ReceiverSlot.Func( dragndrop.m_Receiver, droppable, bDoDrop, command, x, y )
+
+	end
+
+end
+
+function dragndrop.Think()
+
+	if ( IsValid( dragndrop.m_DropMenu ) ) then return end
+
+	--
+	-- We're dragging but no mouse buttons are down..
+	-- So force the drop whereever it is!
+	--
+	--[[if ( dragndrop.m_Dragging != nil && !input.IsMouseDown( MOUSE_LEFT ) && !input.IsMouseDown( MOUSE_RIGHT ) ) then
+		dragndrop.m_Dragging:DragMouseRelease( dragndrop.m_MouseCode )
+		return
+	end]]
+
+	--
+	-- We're holding down a panel, watch for start of dragging
+	--
+	if ( IsValid( dragndrop.m_DragWatch ) ) then
+
+		local dist = math.abs( dragndrop.m_MouseX - gui.MouseX() ) + math.abs( dragndrop.m_MouseY - gui.MouseY() )
+		if ( dist > 20 ) then
+			dragndrop.StartDragging()
+			return
+		end
+
+	end
+
+	if ( dragndrop.m_Dragging != nil ) then
+
+		dragndrop.HoverThink()
+		dragndrop.UpdateReceiver()
+
+		if ( IsValid( dragndrop.m_Receiver ) ) then
+			dragndrop.CallReceiverFunction( false )
+		end
+
+	end
+
+end
+
+hook.Add( "DrawOverlay", "DragNDropPaint", function()
+
+	if ( dragndrop.m_Dragging == nil ) then return end
+	if ( dragndrop.m_DraggingMain == nil ) then return end
+	if ( IsValid( dragndrop.m_DropMenu ) ) then return end
+
+	local hold_offset_x = 65535
+	local hold_offset_y = 65535
+
+	-- Find the top, left most panel
+	for k, v in pairs( dragndrop.m_Dragging ) do
+
+		if ( !IsValid( v ) ) then continue end
+
+		hold_offset_x = math.min( hold_offset_x, v.x )
+		hold_offset_y = math.min( hold_offset_y, v.y )
+
+	end
+
+	local wasEnabled = DisableClipping( true )
+
+		local Alpha = 0.7
+		if ( IsValid( dragndrop.m_Hovered ) ) then Alpha = 0.8 end
+		surface.SetAlphaMultiplier( Alpha )
+
+			local ox = gui.MouseX() - hold_offset_x + 8
+			local oy = gui.MouseY() - hold_offset_y + 8
+
+			for k, v in pairs( dragndrop.m_Dragging ) do
+
+				if ( !IsValid( v ) ) then continue end
+
+				local dist = 512 - v:Distance( dragndrop.m_DraggingMain )
+
+				if ( dist < 0 ) then continue end
+
+				dist = dist / 512
+				surface.SetAlphaMultiplier( Alpha * dist )
+
+				v.PaintingDragging = true
+				v:PaintAt( ox + v.x - v:GetWide() / 2, oy + v.y - v:GetTall() / 2 ) -- fill the gap between the top left corner and the mouse position
+				v.PaintingDragging = nil
+
+			end
+
+		surface.SetAlphaMultiplier( 1.0 )
+
+	DisableClipping( wasEnabled )
+
+end )
+hook.Add( "Think", "DragNDropThink", dragndrop.Think )
+
+
+
+
+
+--
+--
+--
+-- Panel Drag n Drop Extensions
+--
+--
+--
+
+local meta = FindMetaTable( "Panel" )
+
+--
+-- Make this panel droppable
+--
+function meta:Droppable( name )
+
+	self.m_DragSlot = self.m_DragSlot or {}
+
+	self.m_DragSlot[ name ] = {}
+
+	return self.m_DragSlot[ name ]
+
+end
+
+--
+-- Make this pannel a drop target
+--
+function meta:Receiver( name, func, menu )
+
+	self.m_ReceiverSlot = self.m_ReceiverSlot or {}
+
+	self.m_ReceiverSlot[ name ] = {}
+	self.m_ReceiverSlot[ name ].Name = name
+	self.m_ReceiverSlot[ name ].Func = func
+	self.m_ReceiverSlot[ name ].Menu = menu
+
+end
+
+--
+-- Drag parent means that when we start to
+-- drag this panel, we'll really start
+-- dragging the defined parent
+--
+function meta:SetDragParent( parent )
+	self.m_pDragParent = parent
+end
+
+function meta:GetValidReceiverSlot()
+
+	if ( self.m_ReceiverSlot ) then
+
+		-- Find matching slot..
+		for k, v in pairs( self.m_ReceiverSlot ) do
+
+			if ( !dragndrop.m_DraggingMain.m_DragSlot ) then continue end
+
+			local slot = dragndrop.m_DraggingMain.m_DragSlot[ k ]
+			if ( !slot ) then continue end
+
+			return self, v
+
+		end
+
+	end
+
+	if ( !IsValid( self:GetParent() ) ) then
+		return false
+	end
+
+	return self:GetParent():GetValidReceiverSlot()
+
+end
+
+function meta:IsDraggable()
+
+	return self.m_DragSlot != nil
+
+end
+
+function meta:IsDragging()
+
+	if ( !self.m_DragSlot ) then return false end
+
+	return self.Dragging
+
+end
+
+function meta:DroppedOn( pnl )
+	-- For override.
+end
+
+function meta:OnDrop()
+
+	-- We're being dropped on something
+	-- we can create a new panel here and return it, so that instead of
+	-- dropping us - it drops the new panel instead! We remain where we are!
+
+	-- By default we return ourself
+
+	return self
+
+end
+
+function meta:OnStartDragging()
+
+	self.Dragging = true
+	self:InvalidateLayout()
+
+	if ( self:IsSelectable() ) then
+
+		local canvas = self:GetSelectionCanvas()
+
+		if ( IsValid( canvas ) && !self:IsSelected() ) then
+			canvas:UnselectAll()
+		end
+
+	end
+
+end
+
+function meta:OnStopDragging()
+	self.Dragging = false
+end
+
+function meta:DragMousePress( mcode )
+
+	if ( IsValid( dragndrop.m_DropMenu ) ) then return end
+	if ( dragndrop.IsDragging() ) then dragndrop.StopDragging() return end
+
+	if ( IsValid( self.m_pDragParent ) and self.m_pDragParent ~= self ) then
+		return self.m_pDragParent:DragMousePress( mcode )
+	end
+
+	if ( !self.m_DragSlot ) then return end
+
+	dragndrop.Clear()
+	dragndrop.m_MouseCode = mcode
+	dragndrop.m_DragWatch = self
+	dragndrop.m_MouseX = gui.MouseX()
+	dragndrop.m_MouseY = gui.MouseY()
+
+end
+
+function meta:DragClick( mcode )
+
+	self:MouseCapture( true )
+	-- Clicking one mouse button while dragging with another!
+	-- Return true to stop us clicking and selecting stuff below..
+	return true
+
+end
+
+function meta:DragMouseRelease( mcode )
+
+	if ( IsValid( dragndrop.m_DropMenu ) ) then return end
+
+	-- This wasn't the button we clicked with - so don't release drag
+	if ( dragndrop.IsDragging() && dragndrop.m_MouseCode != mcode ) then
+
+		return self:DragClick( mcode )
+
+	end
+
+	if ( !dragndrop.IsDragging() ) then
+		dragndrop.Clear()
+		return false
+	end
+
+	dragndrop.Drop()
+
+	-- Todo.. we should only do this if we enabled it!
+	if ( gui.EnableScreenClicker ) then
+		gui.EnableScreenClicker( false )
+	end
+
+	self:MouseCapture( false )
+	return true
+
+end
+
+function meta:SetDropTarget( x, y, w, h )
+
+	if ( !self.m_bDrawingPaintOver ) then
+		self.m_OldPaintOver = self.PaintOver
+		self.m_bDrawingPaintOver = true
+	end
+
+	self.PaintOver = function()
+
+		if ( self.m_OldPaintOver ) then
+			self:m_OldPaintOver()
+		end
+
+		self:DrawDragHover( x, y, w, h )
+
+	end
+
+end
+
+
+
+--
+-- Drag Hover
+--
+-- These functions are used for things like trees
+-- So that when you hover over the tree while dragging something
+-- it will open up the tree. This works regardless of whether the
+-- is droppable or not.
+--
+-- Implement DragHoverClick in your panel class to get this functionality
+--
+function meta:DragHover( HoverTime )
+
+	--
+	-- Call DragHoverClick if we've been hovering for 0.1 seconds..
+	--
+	if ( HoverTime < 0.1 ) then dragndrop.m_bHoverClick = false end
+	if ( HoverTime > 0.1 && !dragndrop.m_bHoverClick ) then
+
+		self:DragHoverClick( HoverTime )
+		dragndrop.m_bHoverClick = true
+
+	end
+
+end
+
+function meta:DrawDragHover( x, y, w, h )
+
+	DisableClipping( true )
+
+	surface.SetDrawColor( 255, 0, 255, 100 )
+	surface.DrawRect( x, y, w, h )
+
+	surface.SetDrawColor( 255, 220, 255, 230 )
+	surface.DrawOutlinedRect( x, y, w, h )
+
+	surface.SetDrawColor( 255, 100, 255, 50 )
+	surface.DrawOutlinedRect( x - 1, y - 1, w + 2, h + 2 )
+
+	DisableClipping( false )
+
+end
+
+function meta:DragHoverEnd()
+
+	if ( !self.m_bDrawingPaintOver ) then return end
+
+	self.PaintOver = self.m_OldPaintOver
+	self.m_bDrawingPaintOver = false
+
+end
+
+function meta:DragHoverClick( HoverTime )
+end
+
+
+
+
+--
+--
+-- This is called to open stuff when you're hovering over it.
+--
+--
+
+local LastHoverThink = nil
+local LastHoverChangeTime = 0
+local LastX = 0
+local LastY = 0
+
+function dragndrop.HoverThink()
+
+	local hovered = vgui.GetHoveredPanel()
+	local x = gui.MouseX()
+	local y = gui.MouseY()
+
+	-- Hovering a different panel
+	if ( LastHoverThink != hovered or x != LastX or y != LastY ) then
+
+		LastHoverChangeTime = SysTime()
+		LastHoverThink = hovered
+
+	end
+
+	-- Hovered panel might do stuff when we're hovering it
+	-- so give it a chance to do that now.
+	if ( IsValid( LastHoverThink ) ) then
+
+		LastX = x
+		LastY = y
+		LastHoverThink:DragHover( SysTime() - LastHoverChangeTime )
+
+	end
+
+end

lua/includes/extensions/client/panel/scriptedpanels.lua

@@ -0,0 +1,129 @@
+
+if ( SERVER ) then return end
+
+local PanelFactory = {}
+
+local panel_metatable = FindMetaTable( "Panel" )
+
+baseclass.Set( "Panel",				panel_metatable )
+baseclass.Set( "Label",				panel_metatable )
+baseclass.Set( "EditablePanel",		panel_metatable )
+
+-- Keep the old function
+vgui.CreateX = vgui.Create
+
+function vgui.GetControlTable( classname )
+	return PanelFactory[ classname ]
+end
+
+function vgui.Exists( classname )
+	return PanelFactory[ classname ] != nil
+end
+
+function vgui.Create( classname, parent, name )
+
+	-- Is this a user-created panel?
+	if ( PanelFactory[ classname ] ) then
+
+		local metatable = PanelFactory[ classname ]
+
+		local panel = vgui.Create( metatable.Base, parent, name or classname )
+		if ( !panel ) then
+			Error( "Tried to create panel with invalid base '" .. metatable.Base .. "'\n" );
+		end
+
+		table.Merge( panel:GetTable(), metatable )
+		panel.BaseClass = PanelFactory[ metatable.Base ]
+		panel.ClassName = classname
+
+		-- Call the Init function if we have it
+		if ( panel.Init ) then
+			panel:Init()
+		end
+
+		panel:Prepare()
+
+		return panel
+
+	end
+
+	return vgui.CreateX( classname, parent, name or classname )
+
+end
+
+function vgui.CreateFromTable( metatable, parent, name )
+
+	if ( !istable( metatable ) ) then return nil end
+
+	local panel = vgui.Create( metatable.Base, parent, name )
+
+	table.Merge( panel:GetTable(), metatable )
+	panel.BaseClass = PanelFactory[ metatable.Base ]
+
+	-- Call the Init function if we have it
+	if ( panel.Init ) then
+		panel:Init()
+	end
+
+	panel:Prepare()
+
+	return panel
+
+end
+
+function vgui.Register( classname, mtable, base )
+
+	-- Remove the global
+	PANEL = nil
+
+	-- Default base is Panel
+	mtable.Base = base or "Panel"
+	mtable.Init = mtable.Init or function() end
+
+	PanelFactory[ classname ] = mtable
+	baseclass.Set( classname, mtable )
+
+	local mt = {}
+	mt.__index = function( t, k )
+
+		if ( PanelFactory[ mtable.Base ] && PanelFactory[ mtable.Base ][k] ) then return PanelFactory[ mtable.Base ][k] end
+		return panel_metatable[k]
+
+	end
+
+	setmetatable( mtable, mt )
+
+	return mtable
+
+end
+
+function vgui.RegisterTable( mtable, base )
+
+	-- Remove the global
+	PANEL = nil
+
+	mtable.Base = base or "Panel"
+	mtable.Init = mtable.Init or function() end
+
+	return mtable
+
+end
+
+function vgui.RegisterFile( filename )
+
+	local OldPanel = PANEL
+
+	PANEL = {}
+
+	-- The included file should fill the PANEL global.
+	include( filename )
+
+	local mtable = PANEL
+	PANEL = OldPanel
+
+	mtable.Base = mtable.Base or "Panel"
+	mtable.Init = mtable.Init or function() end
+
+	return mtable
+
+end

lua/includes/extensions/client/panel/selections.lua

@@ -0,0 +1,249 @@
+
+if ( SERVER ) then return end
+
+local StartX = 0
+local StartY = 0
+local SelectionCanvas = nil
+
+local meta = FindMetaTable( "Panel" )
+
+function meta:SetSelectionCanvas( bSet )
+
+	self.m_bSelectionCanvas = bSet
+	self:SetMouseInputEnabled( true )
+
+end
+
+function meta:IsSelectionCanvas()
+
+	return self.m_bSelectionCanvas
+
+end
+
+function meta:SetSelectable( bSet )
+
+	self.m_bSelectable = bSet
+
+end
+
+function meta:ToggleSelection()
+
+	self:SetSelected( !self.m_bSelected )
+
+end
+
+function meta:UnselectAll()
+
+	self:SetSelected( false )
+
+	for k, v in ipairs( self:GetChildren() ) do
+		v:UnselectAll()
+	end
+
+end
+
+
+
+function meta:SetSelected( bSet )
+
+	if ( self.m_bSelected == bSet ) then return end
+
+	self.m_bSelected = bSet
+
+	if ( self.ApplySchemeSettings ) then
+		self:ApplySchemeSettings()
+	end
+
+end
+
+function meta:IsSelected( bSet )
+
+	if ( !self:IsSelectable() ) then return false end
+	return self.m_bSelected == true
+
+end
+
+function meta:IsSelectable()
+
+	return self.m_bSelectable == true
+
+end
+
+local function GetSelectionRect()
+
+	if ( !SelectionCanvas ) then
+		debug.Trace()
+		return
+	end
+
+	local CurX, CurY = SelectionCanvas:ScreenToLocal( gui.MouseX(), gui.MouseY() )
+
+	local x = math.min( CurX, StartX )
+	local y = math.min( CurY, StartY )
+
+	local w = math.abs( CurX - StartX )
+	local h = math.abs( CurY - StartY )
+
+	return x, y, w, h
+
+end
+
+function meta:DrawSelections()
+
+	if ( !self.m_bSelectable ) then return end
+	if ( !self.m_bSelected ) then return end
+
+	local w, h = self:GetSize()
+
+	surface.SetDrawColor( 255, 0, 255, 100 )
+	surface.DrawRect( 0, 0, w, h )
+
+end
+
+local function PaintSelectionBox( self )
+
+	if ( !IsValid( SelectionCanvas ) ) then return end
+	local x, y, w, h = GetSelectionRect()
+
+	surface.SetDrawColor( 255, 0, 255, 50 )
+	surface.DrawRect( x, y, w, h )
+
+	surface.SetDrawColor( 255, 200, 255, 200 )
+	surface.DrawOutlinedRect( x, y, w, h )
+
+end
+
+function meta:GetSelectionCanvas()
+
+	if ( !self.m_bSelectionCanvas ) then
+
+		local parent = self:GetParent()
+		if ( IsValid( parent ) ) then
+			return parent:GetSelectionCanvas()
+		end
+
+		return nil
+
+	end
+
+	return self
+
+end
+
+
+function meta:StartBoxSelection()
+
+	if ( !self.m_bSelectionCanvas ) then
+
+		local parent = self:GetParent()
+		if ( IsValid( parent ) ) then
+			return parent:StartBoxSelection()
+		end
+
+		return
+
+	end
+
+	self:MouseCapture( true )
+
+	if ( !input.IsShiftDown() && !input.IsControlDown() ) then
+		self:UnselectAll()
+	end
+
+	SelectionCanvas = self
+
+	StartX, StartY = self:ScreenToLocal( gui.MouseX(), gui.MouseY() )
+
+	self.PaintOver_Old = self.PaintOver
+	self.PaintOver = PaintSelectionBox
+
+end
+
+function meta:GetChildrenInRect( x, y, w, h )
+
+	local tab = {}
+
+	for k, v in ipairs( self:GetChildren() ) do
+
+		local vw, vh = v:GetSize()
+
+		if ( !self:IsVisible() ) then continue end
+		if ( x > v.x + vw ) then continue end
+		if ( y > v.y + vh ) then continue end
+		if ( v.x > x + w ) then continue end
+		if ( v.y > y + h ) then continue end
+
+		if ( v.m_bSelectable ) then
+			table.insert( tab, v )
+		end
+
+		table.Add( tab, v:GetChildrenInRect( x - v.x, y - v.y, w, h ) )
+
+	end
+
+
+	return tab
+
+end
+
+function meta:GetSelectedChildren()
+
+	local tab = {}
+
+	for k, v in ipairs( self:GetChildren() ) do
+
+		if ( v:IsSelected() ) then
+			table.insert( tab, v )
+		end
+
+		table.Add( tab, v:GetSelectedChildren() )
+
+	end
+
+	return tab
+
+end
+
+function meta:NumSelectedChildren()
+
+	local i = 0
+
+	for k, v in ipairs( self:GetChildren() ) do
+
+		if ( v:IsSelected() ) then
+			i = i + 1
+		end
+
+	end
+
+	return i
+
+end
+
+function meta:EndBoxSelection()
+
+	if ( SelectionCanvas != self ) then return false end
+
+	self:MouseCapture( false )
+
+	self.PaintOver = self.PaintOver_Old
+	self.PaintOver_Old = nil
+
+	for k, v in ipairs( self:GetChildrenInRect( GetSelectionRect() ) ) do
+
+		-- If player is holding shift, add new planels to existing selections, do not toggle
+		-- This mimics already familiar behavior of Windows Explorer, etc
+		if ( input.IsShiftDown() ) then
+			v:SetSelected( true )
+		else
+			v:ToggleSelection()
+		end
+
+	end
+
+	SelectionCanvas = nil
+	StartX, StartY = 0, 0
+
+	return true
+
+end

lua/includes/extensions/client/player.lua

@@ -0,0 +1,76 @@
+
+if ( SERVER ) then return end
+
+
+local meta = FindMetaTable( "Player" )
+
+
+local playerOptions = {}
+local bindTranslation = {}
+bindTranslation["slot1"] = 1
+bindTranslation["slot2"] = 2
+bindTranslation["slot3"] = 3
+bindTranslation["slot4"] = 4
+bindTranslation["slot5"] = 5
+bindTranslation["slot6"] = 6
+bindTranslation["slot7"] = 7
+bindTranslation["slot8"] = 8
+bindTranslation["slot9"] = 9
+bindTranslation["slot0"] = 0
+
+--[[---------------------------------------------------------
+   Name:	PlayerOption
+   Params: 	<name> <timeout> <input function> <draw function>
+   Desc:	
+-----------------------------------------------------------]]  
+function meta:AddPlayerOption( name, timeout, in_func, draw_func )
+
+	local option = {}
+		option.timeout = timeout
+		option.in_func = in_func
+		option.draw_func = draw_func
+
+	if (timeout != -1) then
+		option.timeout = CurTime() + timeout
+	end
+
+	playerOptions[ name ] = option
+
+end
+
+
+local function hook_PlayerOptionInput( pl, bind, down )
+
+	if (!down || !bindTranslation[bind]) then return end
+	
+	for k, v in pairs( playerOptions ) do
+	
+		if ( v.timeout == -1 || v.timeout > CurTime() ) then
+		
+			-- If the function returns true then remove this player option
+			if ( v.in_func( bindTranslation[bind] ) ) then
+				playerOptions[k] = nil
+			end
+			
+			return true
+		else
+			playerOptions[k] = nil
+		end
+	end
+	
+end
+
+hook.Add( "PlayerBindPress", "PlayerOptionInput", hook_PlayerOptionInput )
+
+local function hook_PlayerOptionDraw()
+
+	for k, v in pairs( playerOptions ) do
+	
+		if (v.draw_func) then v.draw_func() end
+		return
+		
+	end
+
+end
+
+hook.Add( "HUDPaint", "PlayerOptionDraw", hook_PlayerOptionDraw )

lua/includes/extensions/client/render.lua

@@ -0,0 +1,196 @@
+
+-- We don't want this to run in menu state, and render.GetAmbientLightColor doesn't exist in menu state
+if ( !render || !render.GetAmbientLightColor ) then return end
+
+--[[---------------------------------------------------------
+  Short aliases for stencil constants
+-----------------------------------------------------------]]
+
+STENCIL_NEVER = STENCILCOMPARISONFUNCTION_NEVER
+STENCIL_LESS = STENCILCOMPARISONFUNCTION_LESS
+STENCIL_EQUAL = STENCILCOMPARISONFUNCTION_EQUAL
+STENCIL_LESSEQUAL = STENCILCOMPARISONFUNCTION_LESSEQUAL
+STENCIL_GREATER = STENCILCOMPARISONFUNCTION_GREATER
+STENCIL_NOTEQUAL = STENCILCOMPARISONFUNCTION_NOTEQUAL
+STENCIL_GREATEREQUAL = STENCILCOMPARISONFUNCTION_GREATEREQUAL
+STENCIL_ALWAYS = STENCILCOMPARISONFUNCTION_ALWAYS
+
+STENCIL_KEEP = STENCILOPERATION_KEEP
+STENCIL_ZERO = STENCILOPERATION_ZERO
+STENCIL_REPLACE = STENCILOPERATION_REPLACE
+STENCIL_INCRSAT = STENCILOPERATION_INCRSAT
+STENCIL_DECRSAT = STENCILOPERATION_DECRSAT
+STENCIL_INVERT = STENCILOPERATION_INVERT
+STENCIL_INCR = STENCILOPERATION_INCR
+STENCIL_DECR = STENCILOPERATION_DECR
+
+--[[---------------------------------------------------------
+   Name:	ClearRenderTarget
+   Params: 	<texture> <color>
+   Desc:	Clear a render target
+-----------------------------------------------------------]]
+function render.ClearRenderTarget( rt, color )
+
+	render.PushRenderTarget( rt )
+		render.Clear( color.r, color.g, color.b, color.a )
+	render.PopRenderTarget()
+
+end
+
+
+--[[---------------------------------------------------------
+   Name:	SupportsHDR
+   Params:
+   Desc:	Return true if the client supports HDR
+-----------------------------------------------------------]]
+function render.SupportsHDR( )
+
+	if ( render.GetDXLevel() < 80 ) then return false end
+
+	return true
+
+end
+
+
+--[[---------------------------------------------------------
+   Name:	CopyTexture
+   Params: 	<texture from> <texture to>
+   Desc:	Copy the contents of one texture to another
+-----------------------------------------------------------]]
+function render.CopyTexture( from, to )
+
+	render.PushRenderTarget( from )
+		render.CopyRenderTargetToTexture( to )
+	render.PopRenderTarget()
+
+end
+
+local matColor = Material( "color" )
+
+function render.SetColorMaterial()
+	render.SetMaterial( matColor )
+end
+
+local matColorIgnoreZ = Material( "color_ignorez" )
+
+function render.SetColorMaterialIgnoreZ()
+	render.SetMaterial( matColorIgnoreZ )
+end
+
+local mat_BlurX			= Material( "pp/blurx" )
+local mat_BlurY			= Material( "pp/blury" )
+local tex_Bloom1		= render.GetBloomTex1()
+
+function render.BlurRenderTarget( rt, sizex, sizey, passes )
+
+	mat_BlurX:SetTexture( "$basetexture", rt )
+	mat_BlurY:SetTexture( "$basetexture", tex_Bloom1 )
+	mat_BlurX:SetFloat( "$size", sizex )
+	mat_BlurY:SetFloat( "$size", sizey )
+
+	for i=1, passes+1 do
+
+		render.SetRenderTarget( tex_Bloom1 )
+		render.SetMaterial( mat_BlurX )
+		render.DrawScreenQuad()
+
+		render.SetRenderTarget( rt )
+		render.SetMaterial( mat_BlurY )
+		render.DrawScreenQuad()
+
+	end
+
+end
+
+local camera2DTable = { type = "2D" }
+function cam.Start2D()
+
+	return cam.Start( camera2DTable )
+
+end
+
+function cam.Start3D( pos, ang, fov, x, y, w, h, znear, zfar )
+
+	local tab = {}
+
+	tab.type = "3D"
+	tab.origin = pos
+	tab.angles = ang
+
+	if ( fov != nil ) then tab.fov = fov end
+
+	if ( x != nil && y != nil && w != nil && h != nil ) then
+
+		tab.x			= x
+		tab.y			= y
+		tab.w			= w
+		tab.h			= h
+		tab.aspect		= ( w / h )
+
+	end
+
+	if ( znear != nil && zfar != nil ) then
+
+		tab.znear	= znear
+		tab.zfar	= zfar
+
+	end
+
+	return cam.Start( tab )
+
+end
+
+local matFSB = Material( "pp/motionblur" )
+
+function render.DrawTextureToScreen( tex )
+
+	matFSB:SetFloat( "$alpha", 1.0 )
+	matFSB:SetTexture( "$basetexture", tex )
+
+	render.SetMaterial( matFSB )
+	render.DrawScreenQuad()
+
+end
+
+function render.DrawTextureToScreenRect( tex, x, y, w, h )
+
+	matFSB:SetFloat( "$alpha", 1.0 )
+	matFSB:SetTexture( "$basetexture", tex )
+
+	render.SetMaterial( matFSB )
+	render.DrawScreenQuadEx( x, y, w, h )
+
+end
+
+
+--
+-- This isn't very fast. If you're doing something every frame you should find a way to
+-- cache a ClientsideModel and keep it around! This is fine for rendering to a render
+-- target once - or something.
+--
+
+function render.Model( tbl, ent )
+
+	local inent = ent
+
+	if ( ent == nil ) then
+		ent = ClientsideModel( tbl.model or "error.mdl", RENDERGROUP_OTHER )
+	end
+
+	if ( !IsValid( ent ) ) then return end
+
+	ent:SetModel( tbl.model or "error.mdl" )
+	ent:SetNoDraw( true )
+
+	ent:SetPos( tbl.pos or vector_origin )
+	ent:SetAngles( tbl.angle or angle_zero )
+	ent:DrawModel()
+
+	--
+	-- If we created the model, then remove it!
+	--
+	if ( inent != ent ) then
+		ent:Remove()
+	end
+
+end

lua/includes/extensions/coroutine.lua

@@ -0,0 +1,26 @@
+
+--
+-- The client needs this file
+--
+AddCSLuaFile()
+
+if ( !coroutine ) then return end
+
+--
+-- Name: coroutine.wait
+-- Desc: Yield's the coroutine for so many seconds before returning.\n\nThis should only be called in a coroutine. This function uses CurTime() - not RealTime().
+-- Arg1: number|seconds|The number of seconds to wait
+-- Ret1: 
+--
+function coroutine.wait( seconds )
+
+	local endtime = CurTime() + seconds
+	while ( true ) do
+
+		if ( endtime < CurTime() ) then return end
+
+		coroutine.yield()
+
+	end
+	  
+end

lua/includes/extensions/debug.lua

@@ -0,0 +1,51 @@
+
+if ( !debug ) then return end
+
+--[[---------------------------------------------------------
+	Name: Trace
+	Desc: Dumps a trace to the console..
+
+Trace:
+	1: Line 21	"Trace"			includes/extensions/debug.lua
+	2: Line 222	"WriteTable"	includes/modules/saverestore.lua
+	3: Line 170	"WriteVar"		includes/modules/saverestore.lua
+	4: Line 259	"WriteTable"	includes/modules/saverestore.lua
+	5: Line 170	"WriteVar"		includes/modules/saverestore.lua
+	6: Line 259	"WriteTable"	includes/modules/saverestore.lua
+	7: Line 272	"Func"			includes/extensions/entity_networkvars.lua
+	8: Line 396	"(null)"		includes/modules/saverestore.lua
+
+	This trace shows that the function was called from the engine (line 8) in save restore.
+	Save restore then called something in entity_networkvars for some reason. Then
+	that function called WriteTable(6), which called other functions until it got to the trace
+	in 1 which was called by WriteTable in saverestore.lua
+
+-----------------------------------------------------------]]
+function debug.Trace()
+
+	local level = 1
+
+	Msg( "\nTrace:\n" )
+
+	while true do
+
+		local info = debug.getinfo( level, "Sln" )
+		if ( !info ) then break end
+
+		if ( info.what ) == "C" then
+
+			Msg( string.format( "\t%i: C function\t\"%s\"\n", level, info.name ) )
+
+		else
+
+			Msg( string.format( "\t%i: Line %d\t\"%s\"\t\t%s\n", level, info.currentline, info.name, info.short_src ) )
+
+		end
+
+		level = level + 1
+
+	end
+
+	Msg( "\n" )
+
+end

lua/includes/extensions/entity.lua

@@ -0,0 +1,712 @@
+
+local meta = FindMetaTable( "Entity" )
+
+-- Return if there's nothing to add on to
+if ( !meta ) then return end
+
+function meta:SetSpawnFlags( flags )
+	self:SetKeyValue( "spawnflags", flags )
+end
+
+function meta:AddSpawnFlags( flags )
+	self:SetKeyValue( "spawnflags", bit.bor( self:GetSpawnFlags(), flags ) )
+end
+
+function meta:RemoveSpawnFlags( flags )
+	self:SetKeyValue( "spawnflags", bit.band( self:GetSpawnFlags(), bit.bnot( flags ) ) )
+end
+
+function meta:GetShouldPlayPickupSound()
+	return self.m_bPlayPickupSound or false
+end
+
+function meta:SetShouldPlayPickupSound( bPlaySound )
+	self.m_bPlayPickupSound = tobool( bPlaySound ) or false
+end
+
+--
+-- Entity index accessor. This used to be done in engine, but it's done in Lua now because it's faster
+--
+function meta:__index( key )
+
+	--
+	-- Search the metatable. We can do this without dipping into C, so we do it first.
+	--
+	local val = meta[ key ]
+	if ( val != nil ) then return val end
+
+	--
+	-- Search the entity table
+	--
+	local tab = meta.GetTable( self )
+	if ( tab ) then
+		local tabval = tab[ key ]
+		if ( tabval != nil ) then return tabval end
+	end
+
+	--
+	-- Legacy: sometimes use self.Owner to get the owner.. so lets carry on supporting that stupidness
+	-- This needs to be retired, just like self.Entity was.
+	--
+	if ( key == "Owner" ) then return meta.GetOwner( self ) end
+
+	return nil
+
+end
+
+--[[---------------------------------------------------------
+	Name: Short cut to add entities to the table
+-----------------------------------------------------------]]
+function meta:GetVar( name, default )
+
+	local Val = self:GetTable()[ name ]
+	if ( Val == nil ) then return default end
+
+	return Val
+
+end
+
+if ( SERVER ) then
+
+	function meta:SetCreator( ply --[[= NULL]] )
+		if ( ply == nil ) then
+			ply = NULL
+		elseif ( !isentity( ply ) ) then
+			error( "bad argument #1 to 'SetCreator' (Entity expected, got " .. type( ply ) .. ")", 2 )
+		end
+
+		self.m_PlayerCreator = ply
+	end
+
+	function meta:GetCreator()
+		return self.m_PlayerCreator or NULL
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: Returns true if the entity has constraints attached to it
+-----------------------------------------------------------]]
+function meta:IsConstrained()
+
+	if ( CLIENT ) then return self:GetNWBool( "IsConstrained" ) end
+
+	local c = self:GetTable().Constraints
+	local bIsConstrained = false
+
+	if ( c ) then
+
+		for k, v in pairs( c ) do
+			if ( IsValid( v ) ) then bIsConstrained = true break end
+			c[ k ] = nil
+		end
+
+	end
+
+	self:SetNWBool( "IsConstrained", bIsConstrained )
+	return bIsConstrained
+
+end
+
+--[[---------------------------------------------------------
+	Name: Short cut to set tables on the entity table
+-----------------------------------------------------------]]
+function meta:SetVar( name, value )
+
+	self:GetTable()[ name ] = value
+
+end
+
+--[[---------------------------------------------------------
+	Name: CallOnRemove
+	Desc: Call this function when this entity dies.
+	Calls the function like Function( <entity>, <optional args> )
+-----------------------------------------------------------]]
+function meta:CallOnRemove( name, func, ... )
+
+	local mytable = self:GetTable()
+	mytable.OnDieFunctions = mytable.OnDieFunctions or {}
+
+	mytable.OnDieFunctions[ name ] = { Name = name, Function = func, Args = { ... } }
+
+end
+
+--[[---------------------------------------------------------
+	Name: RemoveCallOnRemove
+	Desc: Removes the named hook
+-----------------------------------------------------------]]
+function meta:RemoveCallOnRemove( name )
+
+	local mytable = self:GetTable()
+	mytable.OnDieFunctions = mytable.OnDieFunctions or {}
+	mytable.OnDieFunctions[ name ] = nil
+
+end
+
+--[[---------------------------------------------------------
+	Simple mechanism for calling the die functions.
+-----------------------------------------------------------]]
+local function DoDieFunction( ent )
+
+	if ( !ent or !ent.OnDieFunctions ) then return end
+
+	for k, v in pairs( ent.OnDieFunctions ) do
+
+		-- Functions aren't saved - so this could be nil if we loaded a game.
+		if ( v && v.Function ) then
+
+			v.Function( ent, unpack( v.Args ) )
+
+		end
+
+	end
+
+end
+
+hook.Add( "EntityRemoved", "DoDieFunction", DoDieFunction )
+
+function meta:PhysWake()
+
+	local phys = self:GetPhysicsObject()
+	if ( !IsValid( phys ) ) then return end
+
+	phys:Wake()
+
+end
+
+-- This makes these a bit faster
+function meta:GetColor()
+
+	return Color( self:GetColor4Part() )
+
+end
+
+function meta:SetColor( col )
+
+	-- Backwards compatibility
+	if ( !col ) then
+		return self:SetColor4Part( 255, 255, 255, 255 )
+	end
+
+	self:SetColor4Part( col.r, col.g, col.b, col.a )
+
+end
+
+function meta:GetChildBones( bone )
+
+	local bonecount = self:GetBoneCount()
+	if ( bonecount == 0 or bonecount < bone ) then return end
+
+	local bones = {}
+
+	for k = 0, bonecount - 1 do
+		if ( self:GetBoneParent( k ) != bone ) then continue end
+		table.insert( bones, k )
+	end
+
+	return bones
+
+end
+
+function DTVar_ReceiveProxyGL( ent, name, id, val )
+	if ( ent.CallDTVarProxies ) then
+		ent:CallDTVarProxies( name, id, val )
+	end
+end
+
+function meta:InstallDataTable()
+
+	self.dt = {}
+	local typetable = {}
+	local datatable = {}
+	local keytable = {}
+	local dtmeta = {}
+	local editing = {}
+
+	dtmeta.__index = function ( ent, key )
+
+		local dt = datatable[ key ]
+		if ( dt == nil ) then return end
+
+		return dt.GetFunc( self, dt.index, key )
+
+	end
+
+	dtmeta.__newindex = function( ent, key, value )
+
+		local dt = datatable[ key ]
+		if ( dt == nil ) then return end
+
+		dt.SetFunc( self, dt.index, value )
+
+	end
+
+	local function FindUnusedIndex( typename )
+
+		local tbl = typetable[ typename ]
+		if ( !tbl ) then return 0 end
+
+		for i = 0, 31 do
+			if ( !tbl[i] ) then return i end
+		end
+
+	end
+
+	self.IsDTVarSlotUsed = function( ent, typename, index )
+
+		local tbl = typetable[ typename ]
+		if ( !tbl or !tbl[index] ) then return false end
+		return true
+
+	end
+
+	self.DTVar = function( ent, typename, index, name )
+
+		if ( isstring( index ) && !name ) then
+			name = index
+			index = FindUnusedIndex( typename )
+		elseif ( !index && isstring( name ) ) then
+			index = FindUnusedIndex( typename )
+		end
+
+		local SetFunc = ent[ "SetDT" .. typename ]
+		local GetFunc = ent[ "GetDT" .. typename ]
+
+		if ( !SetFunc or !GetFunc ) then
+			MsgN( "Couldn't addvar ", name, " - type ", typename, " is invalid!" )
+			return
+		end
+
+		local data = {
+			index = index,
+			name = name,
+			SetFunc = SetFunc,
+			GetFunc = GetFunc,
+			typename = typename,
+			Notify = {}
+		}
+
+		typetable[ typename ] = typetable[ typename ] or {}
+		typetable[ typename ][ index ] = data
+		datatable[ name ] = data
+
+		return data
+
+	end
+
+	--
+	-- Access to the editing table
+	--
+	self.GetEditingData = function()
+		return editing
+	end
+
+	--
+	-- Adds an editable variable.
+	--
+	self.SetupEditing = function( ent, name, keyname, data )
+
+		if ( !data ) then return end
+
+		if ( !data.title ) then data.title = name end
+
+		editing[ keyname ] = data
+
+	end
+
+	self.SetupKeyValue = function( ent, keyname, kvtype, setfunc, getfunc, other_data )
+
+		keyname = keyname:lower()
+
+		keytable[ keyname ] = {
+			KeyName		= keyname,
+			Set			= setfunc,
+			Get			= getfunc,
+			Type		= kvtype
+		}
+
+		if ( other_data ) then
+
+			table.Merge( keytable[ keyname ], other_data )
+
+		end
+
+	end
+
+	local CallProxies = function( ent, tbl, name, oldval, newval )
+
+		for i = 1, #tbl do
+			tbl[ i ]( ent, name, oldval, newval )
+		end
+
+	end
+
+	self.CallDTVarProxies = function( ent, typename, index, newVal )
+
+		local t = typetable[ typename ] && typetable[ typename ][ index ] or nil
+		if ( t ) then
+			CallProxies( ent, t.Notify, t.name, t.GetFunc( ent, index ), newVal )
+		end
+
+	end
+
+	self.NetworkVar = function( ent, typename, index, name, other_data )
+
+		if ( isstring( index ) && ( istable( name ) or !name ) ) then
+			other_data = name
+			name = index
+			index = FindUnusedIndex( typename )
+		elseif ( !index && isstring( name ) ) then
+			index = FindUnusedIndex( typename )
+		end
+
+		local t = ent.DTVar( ent, typename, index, name )
+
+		-- Some addons call these on the entity table, and that used to work, so we keep that
+		ent[ "Set" .. name ] = function( selfent, value )
+			CallProxies( ent, t.Notify, name, t.GetFunc( ent, index ), value )
+			t.SetFunc( ent, index, value )
+		end
+
+		ent[ "Get" .. name ] = function( selfent )
+			return t.GetFunc( ent, index )
+		end
+
+		if ( !other_data ) then return end
+
+		-- This KeyName stuff is absolutely unnecessary, there's absolutely no reason for it to exist
+		-- But we cannot remove it now because dupes will break. It should've used the "name" variable
+		if ( other_data.KeyName ) then
+			ent:SetupKeyValue( other_data.KeyName, typename, ent[ "Set" .. name ], ent[ "Get" .. name ], other_data )
+			ent:SetupEditing( name, other_data.KeyName, other_data.Edit )
+		end
+
+	end
+
+	--
+	-- Add a function that gets called when the variable changes
+	-- Note: this doesn't work on the client yet - which drastically reduces its usefulness.
+	--
+	self.NetworkVarNotify = function( ent, name, func )
+
+		if ( !datatable[ name ] ) then error( "calling NetworkVarNotify on missing network var " .. name ) end
+
+		table.insert( datatable[ name ].Notify, func )
+
+	end
+
+	--
+	-- Create an accessor of an element. This is mainly so you can use spare
+	-- network vars (vectors, angles) to network single floats.
+	--
+	self.NetworkVarElement = function( ent, typename, index, element, name, other_data )
+
+		if ( isstring( index ) && isstring( element ) ) then
+			other_data = name
+			name = element
+			element = index
+			index = FindUnusedIndex( typename )
+		elseif ( !index && isstring( name ) ) then
+			index = FindUnusedIndex( typename )
+		end
+
+		local t = ent.DTVar( ent, typename, index, name )
+		t.element = element
+
+		ent[ "Set" .. name ] = function( selfent, value )
+			local old = t.GetFunc( selfent, index )
+			old[ element ] = value
+			t.SetFunc( selfent, index, old )
+		end
+
+		ent[ "Get" .. name ] = function( selfent )
+			return t.GetFunc( selfent, index )[ element ]
+		end
+
+		if ( !other_data ) then return end
+
+		-- This KeyName stuff is absolutely unnecessary, there's absolutely no reason for it to exist
+		-- But we cannot remove it now because dupes will break. It should've used the "name" variable
+		if ( other_data.KeyName ) then
+			ent:SetupKeyValue( other_data.KeyName, "float", ent[ "Set" .. name ], ent[ "Get" .. name ], other_data )
+			ent:SetupEditing( name, other_data.KeyName, other_data.Edit )
+		end
+
+	end
+
+	self.SetNetworkKeyValue = function( ent, key, value )
+
+		key = key:lower()
+
+		local k = keytable[ key ]
+		if ( !k ) then return end
+
+		local v = util.StringToType( value, k.Type )
+		if ( v == nil ) then return end
+
+		k.Set( ent, v )
+		return true
+
+	end
+
+	self.SetNetworkVarsFromMapInput = function( ent, name, data )
+
+		name = name:lower()
+		if ( !string.StartsWith( name, "set" ) ) then return end
+
+		name = string.sub( name, 4 )
+		if ( name == "" ) then return end
+
+		-- Only allow setting variables that were marked as editable!
+		local k = keytable[ name ]
+		if ( !k || !k.Edit ) then return end
+
+		local v = util.StringToType( data, k.Type )
+		if ( v == nil ) then return end
+
+		-- Special case for colors. FGD (maps) use color255 format, while colors in this system use unit vectors.
+		if ( k.Edit.type == "VectorColor" ) then
+			v = v / 255
+		end
+
+		k.Set( ent, v )
+		return true
+
+	end
+
+	self.GetNetworkKeyValue = function( ent, key )
+
+		key = key:lower()
+
+		local k = keytable[ key ]
+		if ( !k ) then return end
+
+		return k.Get( ent )
+
+	end
+
+	--
+	-- Called by the duplicator system to get the network vars
+	--
+	self.GetNetworkVars = function( ent )
+
+		local dt = {}
+
+		for k, v in pairs( datatable ) do
+
+			-- Don't try to save entities (yet?)
+			if ( v.typename == "Entity" ) then continue end
+
+			if ( v.element ) then
+				dt[ k ] = v.GetFunc( ent, v.index )[ v.element ]
+			else
+				dt[ k ] = v.GetFunc( ent, v.index )
+			end
+
+		end
+
+		--
+		-- If there's nothing in our table - then return nil.
+		--
+		if ( table.IsEmpty( dt ) ) then return nil end
+
+		return dt
+
+	end
+
+	--
+	-- Called by the duplicator system to restore from network vars
+	--
+	self.RestoreNetworkVars = function( ent, tab )
+
+		if ( !tab ) then return end
+
+		-- Loop this entities data table
+		for k, v in pairs( datatable ) do
+
+			-- If it contains this entry
+			if ( tab[ k ] == nil ) then continue end
+
+			-- Support old saves/dupes with incorrectly saved data
+			if ( v.element && ( isangle( tab[ k ] ) or isvector( tab[ k ] ) ) ) then
+				tab[ k ] = tab[ k ][ v.element ]
+			end
+
+			-- Set it.
+			if ( ent[ "Set" .. k ] ) then
+				ent[ "Set" .. k ]( ent, tab[ k ] )
+			else
+				v.SetFunc( ent, v.index, tab[ k ] )
+			end
+
+		end
+
+	end
+
+	setmetatable( self.dt, dtmeta )
+
+	--
+	-- In sandbox the client can edit certain values on certain entities
+	-- we implement this here incase any other gamemodes want to use it
+	-- although it is of course deactivated by default.
+	--
+
+	--
+	-- This function takes a keyname and a value - both strings.
+	--
+	--
+	-- Called serverside it will set the value.
+	--
+	self.EditValue = function( ent, variable, value )
+
+		if ( !isstring( variable ) ) then return end
+		if ( !isstring( value ) ) then return end
+
+		--
+		-- It can be called clientside to send a message to the server
+		-- to request a change of value.
+		--
+		if ( CLIENT ) then
+
+			net.Start( "editvariable" )
+				net.WriteEntity( ent )
+				net.WriteString( variable )
+				net.WriteString( value )
+			net.SendToServer()
+
+		end
+
+		--
+		-- Called serverside it simply changes the value
+		--
+		if ( SERVER ) then
+
+			ent:SetNetworkKeyValue( variable, value )
+
+		end
+
+	end
+
+end
+
+if ( SERVER ) then
+
+	util.AddNetworkString( "editvariable" )
+
+	net.Receive( "editvariable", function( len, client )
+
+		local ent = net.ReadEntity()
+
+		if ( !IsValid( ent ) ) then return end
+		if ( !isfunction( ent.GetEditingData ) ) then return end
+		if ( ent.AdminOnly && !( client:IsAdmin() or game.SinglePlayer() ) ) then return end
+
+		local key = net.ReadString()
+
+		-- Is this key in our edit table?
+		local editor = ent:GetEditingData()[ key ]
+		if ( !istable( editor ) ) then return end
+
+		local val = net.ReadString()
+		hook.Run( "VariableEdited", ent, client, key, val, editor )
+
+	end )
+
+	function meta:GetUnFreezable()
+		return self.m_bUnFreezable or false
+	end
+
+	function meta:SetUnFreezable( bFreeze )
+		self.m_bUnFreezable = tobool( bFreeze ) or false
+	end
+
+end
+
+--
+-- Networked var proxies
+--
+function meta:SetNetworked2VarProxy( name, func )
+
+	if ( !self.NWVarProxies ) then
+		self.NWVarProxies = {}
+	end
+
+	self.NWVarProxies[ name ] = func
+
+end
+
+function meta:GetNetworked2VarProxy( name )
+
+	if ( self.NWVarProxies ) then
+		local func = self.NWVarProxies[ name ]
+		if ( isfunction( func ) ) then
+			return func
+		end
+	end
+
+	return nil
+
+end
+
+meta.SetNW2VarProxy = meta.SetNetworked2VarProxy
+meta.GetNW2VarProxy = meta.GetNetworked2VarProxy
+
+hook.Add( "EntityNetworkedVarChanged", "NetworkedVars", function( ent, name, oldValue, newValue )
+
+	if ( ent.NWVarProxies ) then
+		local func = ent.NWVarProxies[ name ]
+
+		if ( isfunction( func ) ) then
+			func( ent, name, oldValue, newValue )
+		end
+	end
+
+end )
+
+--
+-- Vehicle Extensions
+--
+local vehicle = FindMetaTable( "Vehicle" )
+
+--
+-- We steal some DT slots by default for vehicles
+-- to control the third person view. You should use
+-- these functions if you want to play with them because
+-- they might eventually be moved into the engine - so manually
+-- editing the DT values will stop working.
+--
+function vehicle:SetVehicleClass( s )
+
+	self:SetDTString( 3, s )
+
+end
+
+function vehicle:GetVehicleClass()
+
+	return self:GetDTString( 3 )
+
+end
+
+function vehicle:SetThirdPersonMode( b )
+
+	self:SetDTBool( 3, b )
+
+end
+
+function vehicle:GetThirdPersonMode()
+
+	return self:GetDTBool( 3 )
+
+end
+
+function vehicle:SetCameraDistance( dist )
+
+	self:SetDTFloat( 3, dist )
+
+end
+
+function vehicle:GetCameraDistance()
+
+	return self:GetDTFloat( 3 )
+
+end

lua/includes/extensions/entity_iter.lua

@@ -0,0 +1,39 @@
+
+local inext = ipairs( {} )
+
+local EntityCache = nil
+function ents.Iterator()
+
+	if ( EntityCache == nil ) then EntityCache = ents.GetAll() end
+
+	return inext, EntityCache, 0
+
+end
+
+local PlayerCache = nil
+function player.Iterator()
+
+	if ( PlayerCache == nil ) then PlayerCache = player.GetAll() end
+
+	return inext, PlayerCache, 0
+
+end
+
+-- Called by the engine just before OnEntityCreated & just after EntityRemoved hooks
+function InvalidateInternalEntityCache( isPly )
+
+	EntityCache = nil
+	if ( isPly ) then PlayerCache = nil end
+
+end
+
+local function InvalidateInternalEntityCacheOld( ent )
+
+	InvalidateInternalEntityCache( ent:IsPlayer() )
+
+end
+
+-- These are for non-updated servers
+-- TODO: Remove me after update is released (past June 2025)
+hook.Add( "OnEntityCreated", "ents.Iterator", InvalidateInternalEntityCacheOld )
+hook.Add( "EntityRemoved", "ents.Iterator", InvalidateInternalEntityCacheOld )

lua/includes/extensions/ents.lua

@@ -0,0 +1,20 @@
+
+function ents.FindByClassAndParent( classname, entity )
+
+	if ( !IsValid( entity ) ) then return end
+
+	local out = {}
+
+	for k, v in ipairs( ents.FindByClass( classname ) ) do
+
+		if ( v:GetParent() == entity ) then
+			table.insert( out, v )
+		end
+
+	end
+
+	if ( out[1] == nil ) then return end
+
+	return out
+
+end

lua/includes/extensions/file.lua

@@ -0,0 +1,41 @@
+
+function file.Read( filename, path )
+
+	if ( path == true ) then path = "GAME" end
+	if ( path == nil || path == false ) then path = "DATA" end
+
+	local f = file.Open( filename, "rb", path )
+	if ( !f ) then return nil end
+
+	local str = f:Read( f:Size() )
+
+	f:Close()
+
+	if ( !str ) then str = "" end
+	return str
+
+end
+
+function file.Write( filename, contents )
+
+	local f = file.Open( filename, "wb", "DATA" )
+	if ( !f ) then return false end
+
+	f:Write( contents )
+	f:Close()
+
+	return true
+
+end
+
+function file.Append( filename, contents )
+
+	local f = file.Open( filename, "ab", "DATA" )
+	if ( !f ) then return false end
+
+	f:Write( contents )
+	f:Close()
+
+	return true
+
+end

lua/includes/extensions/game.lua

@@ -0,0 +1,54 @@
+
+local AmmoTypes = {}
+
+--
+-- Called by modders to add a new ammo type.
+-- Ammo types aren't something you can add on the fly. You have one
+-- opportunity during loadtime. The ammo types should also be IDENTICAL on 
+-- server and client. 
+-- If they're not you will receive errors and maybe even crashes.
+--
+--
+--		game.AddAmmoType( 
+--		{
+--			name		=	"customammo",
+--			dmgtype		=	DMG_BULLET,
+--			tracer		=	TRACER_LINE_AND_WHIZ,
+--			plydmg		=	20,
+--			npcdmg		=	20,
+--			force		=	100,
+--			minsplash	=	10,
+--			maxsplash	=	100
+--		})
+--
+function game.AddAmmoType( tbl )
+	if ( !isstring( tbl.name ) ) then
+		ErrorNoHalt( "bad argument #1 to 'AddAmmoType' ('name' key expected a string, got " .. type( tbl.name ) .. ")\n" )
+		return
+	end
+
+	local name = string.lower( tbl.name )
+
+	for id, ammo in ipairs( AmmoTypes ) do
+		if ( name == string.lower( ammo.name ) ) then
+			AmmoTypes[ id ] = tbl
+			return
+		end
+	end
+
+	table.insert( AmmoTypes, tbl )
+end
+
+--
+-- Called by the engine to retrive the ammo types. 
+-- You should never have to call this manually.
+--
+function game.BuildAmmoTypes()
+	--
+	-- Sort the table by name here to assure that the ammo types
+	--  are inserted in the same order on both server and client
+	--
+	table.SortByMember( AmmoTypes, "name", true )
+
+	return AmmoTypes
+end

lua/includes/extensions/math.lua

@@ -0,0 +1,269 @@
+
+include( "math/ease.lua" )
+
+math.tau = 2 * math.pi
+
+--[[---------------------------------------------------------
+	Name: DistanceSqr( low, high )
+	Desc: Squared Distance between two 2d points, use this instead of math.Distance as it is more cpu efficient.
+------------------------------------------------------------]]
+function math.DistanceSqr( x1, y1, x2, y2 )
+	local xd = x2 - x1
+	local yd = y2 - y1
+	return xd * xd + yd * yd
+end
+
+--[[---------------------------------------------------------
+	Name: Distance( low, high )
+	Desc: Distance between two 2d points
+------------------------------------------------------------]]
+function math.Distance( x1, y1, x2, y2 )
+	local xd = x2 - x1
+	local yd = y2 - y1
+	return math.sqrt( xd * xd + yd * yd )
+end
+math.Dist = math.Distance -- Backwards compatibility
+
+--[[---------------------------------------------------------
+	Name: BinToInt( bin )
+	Desc: Convert a binary string to an integer number
+------------------------------------------------------------]]
+function math.BinToInt( bin )
+	return tonumber( bin, 2 )
+end
+
+--[[---------------------------------------------------------
+	Name: IntToBin( int )
+	Desc: Convert an integer number to a binary string (the string len will be a multiple of three)
+------------------------------------------------------------]]
+local intbin = {
+	["0"] = "000", ["1"] = "001", ["2"] = "010", ["3"] = "011",
+	["4"] = "100", ["5"] = "101", ["6"] = "110", ["7"] = "111"
+}
+
+function math.IntToBin( int )
+	local str = string.gsub( string.format( "%o", int ), "(.)", function ( d ) return intbin[ d ] end )
+	return str
+end
+
+--[[---------------------------------------------------------
+	Name: Clamp( in, low, high )
+	Desc: Clamp value between 2 values
+------------------------------------------------------------]]
+function math.Clamp( _in, low, high )
+	return math.min( math.max( _in, low ), high )
+end
+
+--[[---------------------------------------------------------
+	Name: Rand( low, high )
+	Desc: Random number between low and high
+-----------------------------------------------------------]]
+function math.Rand( low, high )
+	return low + ( high - low ) * math.random()
+end
+
+math.Max = math.max
+math.Min = math.min
+
+--[[---------------------------------------------------------
+	Name: EaseInOut(fProgress, fEaseIn, fEaseOut)
+	Desc: Provided by garry from the facewound source and converted
+			to Lua by me :p
+	Usage: math.EaseInOut(0.1, 0.5, 0.5) - all parameters should be between 0 and 1
+-----------------------------------------------------------]]
+function math.EaseInOut( frac, easeIn, easeOut )
+	if ( frac == 0 or frac == 1 ) then return frac end
+
+	if ( easeIn == nil ) then easeIn = 0 end
+	if ( easeOut == nil ) then easeOut = 1 end
+
+	local fSumEase = easeIn + easeOut
+
+	if ( fSumEase == 0 ) then return frac end
+	if ( fSumEase > 1 ) then
+		easeIn = easeIn / fSumEase
+		easeOut = easeOut / fSumEase
+	end
+
+	local fProgressCalc = 1 / ( 2 - easeIn - easeOut )
+
+	if ( frac < easeIn ) then
+		return ( ( fProgressCalc / easeIn ) * frac * frac )
+	elseif ( frac < 1 - easeOut ) then
+		return ( fProgressCalc * ( 2 * frac - easeIn ) )
+	else
+		frac = 1 - frac
+		return ( 1 - ( fProgressCalc / easeOut ) * frac * frac )
+	end
+end
+
+function math.calcBSplineN( i, k, t, tInc )
+	local knot = ( i - 3 ) * tInc
+
+	if ( k <= 1 ) then
+		if ( knot <= t && t < knot + tInc ) then
+			return 1
+		end
+
+		return 0
+	end
+
+	local count = i + k - 4
+	local len = count * tInc
+	local knots = len - knot
+
+	local nknot = k - 1
+	local ret = 0
+
+	if ( knots > 0 ) then
+		ret = ( t - knot ) * math.calcBSplineN( i, nknot, t, tInc ) / knots
+	end
+
+	local sb = nknot * tInc
+
+	if ( sb > 0 ) then
+		ret = ret + ( len + tInc - t ) * math.calcBSplineN( i + 1, nknot, t, tInc ) / sb
+	end
+
+	return ret
+end
+
+function math.BSplinePoint( frac, points, frac_max )
+	local len = #points
+	local tInc = frac_max / ( len - 3 )
+	frac = frac + tInc
+
+	local ret = Vector()
+	for i = 1, len do
+		ret:Add( math.calcBSplineN( i, 4, frac, tInc ) * points[ i ] )
+	end
+
+	return ret
+end
+
+--[[---------------------------------------------------------
+	Cubic hermite spline
+	p0, p1 - points; m0, m1 - tangets; frac - fraction along the curve (0-1)
+-----------------------------------------------------------]]
+function math.CHSpline( frac, p0, m0, p1, m1 )
+	if ( frac >= 1 ) then return p1 end
+	if ( frac <= 0 ) then return p0 end
+
+	local t2 = frac * frac
+	local t3 = frac * t2
+
+	return p0 * ( 2 * t3 - 3 * t2 + 1 ) +
+		m0 * ( t3 - 2 * t2 + frac ) +
+		p1 * ( -2 * t3 + 3 * t2 ) +
+		m1 * ( t3 - t2 )
+end
+
+-- Round to the nearest integer
+function math.Round( num, idp )
+	local mult = 10 ^ ( idp or 0 )
+	return math.floor( num * mult + 0.5 ) / mult
+end
+
+-- Rounds towards zero
+function math.Truncate( num, idp )
+	local mult = 10 ^ ( idp or 0 )
+	return ( num < 0 and math.ceil or math.floor )( num * mult ) / mult
+end
+
+function math.Approach( cur, target, inc )
+	if ( cur < target ) then
+		return math.min( cur + math.abs( inc ), target )
+	end
+
+	if ( cur > target ) then
+		return math.max( cur - math.abs( inc ), target )
+	end
+
+	return target
+end
+
+function math.NormalizeAngle( a )
+	return ( a + 180 ) % 360 - 180
+end
+
+function math.AngleDifference( a, b )
+	local diff = math.NormalizeAngle( a - b )
+
+	if ( diff < 180 ) then
+		return diff
+	end
+
+	return diff - 360
+end
+
+function math.ApproachAngle( cur, target, inc )
+	return math.Approach( cur, cur + math.AngleDifference( target, cur ), inc )
+end
+
+function math.TimeFraction( Start, End, Current )
+	return ( Current - Start ) / ( End - Start )
+end
+
+function math.Remap( value, inMin, inMax, outMin, outMax )
+	return outMin + ( ( ( value - inMin ) / ( inMax - inMin ) ) * ( outMax - outMin ) )
+end
+
+-- Snaps the provided number to the nearest multiple
+function math.SnapTo( num, multiple )
+	return math.floor( num / multiple + 0.5 ) * multiple
+end
+
+--[[---------------------------------------------------------
+	Name: CubicBezier( frac, p0, p1, p2, p3 )
+	Desc: Lerp point between points with cubic bezier
+-----------------------------------------------------------]]
+function math.CubicBezier( frac, p0, p1, p2, p3 )
+	local frac2 = frac * frac
+	local inv = 1 - frac
+	local inv2 = inv * inv
+
+	return inv2 * inv * p0 + 3 * inv2 * frac * p1 + 3 * inv * frac2 * p2 + frac2 * frac * p3
+end
+
+--[[---------------------------------------------------------
+	Name: QuadraticBezier( frac, p0, p1, p2 )
+	Desc: Lerp point between points with quadratic bezier
+-----------------------------------------------------------]]
+function math.QuadraticBezier( frac, p0, p1, p2 )
+	local frac2 = frac * frac
+	local inv = 1 - frac
+	local inv2 = inv * inv
+
+	return inv2 * p0 + 2 * inv * frac * p1 + frac2 * p2
+end
+
+--[[---------------------------------------------------------
+	Name: Factorial( num )
+	Desc: Calculate the factorial value of num
+-----------------------------------------------------------]]
+function math.Factorial( num )
+	if ( num < 0 ) then
+		return nil
+	elseif ( num < 2 ) then
+		return 1
+	end
+
+	local res = 1
+	for i = 2, num do
+		res = res * i
+	end
+
+	return res
+end
+
+--[[---------------------------------------------------------
+	Name: IsNearlyEqual( a, b, tolerance )
+	Desc: Checks if two floating point numbers are nearly equal
+-----------------------------------------------------------]]
+function math.IsNearlyEqual( a, b, tolerance )
+	if ( tolerance == nil ) then
+		tolerance = 1e-8
+	end
+
+	return math.abs( a - b ) <= tolerance
+end

lua/includes/extensions/math/ease.lua

@@ -0,0 +1,191 @@
+module("math.ease", package.seeall)
+
+--[[---------------------------------------------------------
+	Source code of functions
+-----------------------------------------------------------]]
+
+-- https://github.com/Facepunch/garrysmod/pull/1755
+-- https://web.archive.org/web/20201212082306/https://easings.net/
+-- https://web.archive.org/web/20201218211606/https://raw.githubusercontent.com/ai/easings.net/master/src/easings.yml
+
+--[[---------------------------------------------------------
+	Easing constants
+-----------------------------------------------------------]]
+
+local c1 = 1.70158
+local c3 = c1 + 1
+local c2 = c1 * 1.525
+local c4 = ( 2 * math.pi ) / 3
+local c5 = ( 2 * math.pi ) / 4.5
+local n1 = 7.5625
+local d1 = 2.75
+
+--[[---------------------------------------------------------
+	To reduce _G lookups, we'll localize some commonly
+	used functions in this extension
+-----------------------------------------------------------]]
+
+local pi = math.pi
+local cos = math.cos
+local sin = math.sin
+local sqrt = math.sqrt
+
+--[[---------------------------------------------------------
+	Easing functions
+-----------------------------------------------------------]]
+
+function InSine( x )
+	return 1 - cos( ( x * pi ) / 2 )
+end
+
+function OutSine( x )
+	return sin( ( x * pi ) / 2 )
+end
+
+function InOutSine( x )
+	return -( cos( pi * x ) - 1 ) / 2
+end
+
+function InQuad( x )
+	return x ^ 2
+end
+
+function OutQuad( x )
+	return 1 - ( 1 - x ) * ( 1 - x )
+end
+
+function InOutQuad( x )
+	return x < 0.5 && 2 * x ^ 2 || 1 - ( ( -2 * x + 2 ) ^ 2 ) / 2
+end
+
+function InCubic( x )
+	return x ^ 3
+end
+
+function OutCubic( x )
+	return 1 - ( ( 1 - x ) ^ 3 )
+end
+
+function InOutCubic( x )
+	return x < 0.5 && 4 * x ^ 3 || 1 - ( ( -2 * x + 2 ) ^ 3 ) / 2
+end
+
+function InQuart( x )
+	return x ^ 4
+end
+
+function OutQuart( x )
+	return 1 - ( ( 1 - x ) ^ 4 )
+end
+
+function InOutQuart( x )
+	return x < 0.5 && 8 * x ^ 4 || 1 - ( ( -2 * x + 2 ) ^ 4 ) / 2
+end
+
+function InQuint( x )
+	return x ^ 5
+end
+
+function OutQuint( x )
+	return 1 - ( ( 1 - x ) ^ 5 )
+end
+
+function InOutQuint( x )
+	return x < 0.5 && 16 * x ^ 5 || 1 - ( ( -2 * x + 2 ) ^ 5 ) / 2
+end
+
+function InExpo( x )
+	return x == 0 && 0 || ( 2 ^ ( 10 * x - 10 ) )
+end
+
+function OutExpo( x )
+	return x == 1 && 1 || 1 - ( 2 ^ ( -10 * x ) )
+end
+
+function InOutExpo( x )
+	return x == 0
+		&& 0
+		|| x == 1
+		&& 1
+		|| x < 0.5 && ( 2 ^ ( 20 * x - 10 ) ) / 2
+		|| ( 2 - ( 2 ^ ( -20 * x + 10 ) ) ) / 2
+end
+
+function InCirc( x )
+	return 1 - sqrt( 1 - ( x ^ 2 ) )
+end
+
+function OutCirc( x )
+	return sqrt( 1 - ( ( x - 1 ) ^ 2 ) )
+end
+
+function InOutCirc( x )
+	return x < 0.5
+		&& ( 1 - sqrt( 1 - ( ( 2 * x ) ^ 2 ) ) ) / 2
+		|| ( sqrt( 1 - ( ( -2 * x + 2 ) ^ 2 ) ) + 1 ) / 2
+end
+
+function InBack( x )
+	return c3 * x ^ 3 - c1 * x ^ 2
+end
+
+function OutBack( x )
+	return 1 + c3 * ( ( x - 1 ) ^ 3 ) + c1 * ( ( x - 1 ) ^ 2 )
+end
+
+function InOutBack( x )
+	return x < 0.5
+		&& ( ( ( 2 * x ) ^ 2 ) * ( ( c2 + 1 ) * 2 * x - c2 ) ) / 2
+		|| ( ( ( 2 * x - 2 ) ^ 2 ) * ( ( c2 + 1 ) * ( x * 2 - 2 ) + c2 ) + 2 ) / 2
+end
+
+function InElastic( x )
+	return x == 0
+		&& 0
+		|| x == 1
+		&& 1
+		|| -( 2 ^ ( 10 * x - 10 ) ) * sin( ( x * 10 - 10.75 ) * c4 )
+end
+
+function OutElastic( x )
+	return x == 0
+		&& 0
+		|| x == 1
+		&& 1
+		|| ( 2 ^ ( -10 * x ) ) * sin( ( x * 10 - 0.75 ) * c4 ) + 1
+end
+
+function InOutElastic( x )
+	return x == 0
+		&& 0
+		|| x == 1
+		&& 1
+		|| x < 0.5
+		&& -( ( 2 ^ ( 20 * x - 10 ) ) * sin( ( 20 * x - 11.125 ) * c5 ) ) / 2
+		|| ( ( 2 ^ ( -20 * x + 10 ) ) * sin( ( 20 * x - 11.125 ) * c5 ) ) / 2 + 1
+end
+
+function InBounce( x )
+	return 1 - OutBounce( 1 - x )
+end
+
+function OutBounce( x )
+	if ( x < 1 / d1 ) then
+		return n1 * x ^ 2
+	elseif ( x < 2 / d1 ) then
+		x = x - ( 1.5 / d1 )
+		return n1 * x ^ 2 + 0.75
+	elseif ( x < 2.5 / d1 ) then
+		x = x - ( 2.25 / d1 )
+		return n1 * x ^ 2 + 0.9375
+	else
+		x = x - ( 2.625 / d1 )
+		return n1 * x ^ 2 + 0.984375
+	end
+end
+
+function InOutBounce( x )
+	return x < 0.5
+		&& ( 1 - OutBounce( 1 - 2 * x ) ) / 2
+		|| ( 1 + OutBounce( 2 * x - 1 ) ) / 2
+end

lua/includes/extensions/motionsensor.lua

@@ -0,0 +1,258 @@
+
+--
+-- Should never really happen.
+--
+motionsensor = motionsensor or {}
+
+
+--
+-- These bones are used to draw the debug
+-- kinect skeleton. You just need to loop through
+-- and draw a line between each of these bones.
+--
+motionsensor.DebugBones =
+{
+	-- Torso
+	{ SENSORBONE.HEAD,				SENSORBONE.SHOULDER },
+	{ SENSORBONE.SHOULDER,			SENSORBONE.SHOULDER_LEFT },
+	{ SENSORBONE.SHOULDER,			SENSORBONE.SHOULDER_RIGHT },
+	{ SENSORBONE.SHOULDER,			SENSORBONE.SPINE },
+	{ SENSORBONE.SHOULDER,			SENSORBONE.HIP },
+	{ SENSORBONE.HIP,				SENSORBONE.HIP_LEFT },
+	{ SENSORBONE.HIP,				SENSORBONE.HIP_RIGHT },
+
+	-- Left Arm
+	{ SENSORBONE.SHOULDER_LEFT,		SENSORBONE.ELBOW_LEFT },
+	{ SENSORBONE.ELBOW_LEFT,		SENSORBONE.WRIST_LEFT },
+	{ SENSORBONE.WRIST_LEFT,		SENSORBONE.HAND_LEFT },
+
+	-- Right Arm
+	{ SENSORBONE.SHOULDER_RIGHT,	SENSORBONE.ELBOW_RIGHT },
+	{ SENSORBONE.ELBOW_RIGHT,		SENSORBONE.WRIST_RIGHT },
+	{ SENSORBONE.WRIST_RIGHT,		SENSORBONE.HAND_RIGHT },
+
+	-- left leg
+	{ SENSORBONE.HIP_LEFT,			SENSORBONE.KNEE_LEFT },
+	{ SENSORBONE.KNEE_LEFT,			SENSORBONE.ANKLE_LEFT },
+	{ SENSORBONE.ANKLE_LEFT,		SENSORBONE.FOOT_LEFT },
+
+	-- right leg
+	{ SENSORBONE.HIP_RIGHT,			SENSORBONE.KNEE_RIGHT },
+	{ SENSORBONE.KNEE_RIGHT,		SENSORBONE.ANKLE_RIGHT },
+	{ SENSORBONE.ANKLE_RIGHT,		SENSORBONE.FOOT_RIGHT },
+}
+
+motionsensor.ChooseBuilderFromEntity = function( ent )
+
+	local builders = list.Get( "SkeletonConvertor" )
+
+	for k, v in pairs( builders ) do
+
+		if ( v:IsApplicable( ent ) ) then return k end
+
+	end
+
+	return "ValveBiped"
+
+end
+
+motionsensor.ProcessAngle = function( translator, sensor, pos, ang, special_vectors, boneid, v )
+
+	local a = nil
+	local b = nil
+	local up = special_vectors["up"]
+
+	--
+	-- Using a vector from another angle.
+	-- If the angle isn't processed yet return
+	-- we will be added to the list to process again.
+	--
+	if ( v.up_up ) then
+		if ( !ang[ v.up_up ] ) then return end
+		up = ang[ v.up_up ]:Up()
+	end
+
+	if ( v.up_dn ) then
+		if ( !ang[ v.up_dn ] ) then return end
+		up = ang[ v.up_dn ]:Up() * -1
+	end
+
+	if ( v.up_fwd ) then
+		if ( !ang[ v.up_fwd ] ) then return end
+		up = ang[ v.up_fwd ]:Forward()
+	end
+
+	if ( v.up_lft ) then
+		if ( !ang[ v.up_lft ] ) then return end
+		up = ang[ v.up_lft ]:Right() * -1
+	end
+
+	if ( v.up_rgt ) then
+		if ( !ang[ v.up_rgt ] ) then return end
+		up = ang[ v.up_rgt ]:Right()
+	end
+
+	--
+	-- From -> To vectors
+	--
+	if ( v.from_sensor ) then	a = sensor[ v.from_sensor ]		end
+	if ( v.to_sensor ) then		b = sensor[ v.to_sensor ]		end
+	if ( v.from ) then			a = pos[ v.from ]				end
+	if ( v.to ) then			b = pos[ v.to ]					end
+
+	--
+	-- We can offer special vectors to define 'up'
+	--
+	if ( isstring( v.up ) ) then
+		up = special_vectors[ v.up ]
+	end
+
+	if ( a == nil or b == nil or up == nil ) then return end
+
+	ang[ boneid ]	= ( a - b ):GetNormal():AngleEx( up:GetNormal() );
+
+	if ( v.adjust ) then
+		ang[ boneid ] = ang[ boneid ] + v.adjust
+	end
+
+	return true
+
+end
+
+--
+-- Processes the AnglesTable from a skeleton constructor
+--
+motionsensor.ProcessAnglesTable = function( translator, sensor, pos, rotation )
+
+	if ( !translator.AnglesTable ) then return {} end
+
+	local ang = {}
+
+	local special_vectors = {}
+	special_vectors["right"]	= rotation:Right()
+	special_vectors["left"]		= special_vectors["right"] * -1
+	special_vectors["up"]		= rotation:Up()
+	special_vectors["down"]		= special_vectors["up"] * -1
+	special_vectors["forward"]	= special_vectors["down"]:Cross( special_vectors["right"] )
+	special_vectors["backward"]	= special_vectors["forward"] * -1
+
+	special_vectors["hips_left"]	= ( sensor[SENSORBONE.HIP_RIGHT] - sensor[SENSORBONE.HIP_LEFT] ):GetNormal()
+	special_vectors["hips_up"]		= ( sensor[SENSORBONE.HIP] - sensor[SENSORBONE.SHOULDER] ):GetNormal()
+	special_vectors["hips_back"]	= special_vectors["hips_up"]:Cross( special_vectors["hips_left"] )
+	special_vectors["hips_fwd"]		= special_vectors["hips_back"] * -1
+
+	special_vectors["chest_lft"]	= ( sensor[SENSORBONE.SHOULDER_RIGHT] - sensor[SENSORBONE.SHOULDER_LEFT] ):GetNormal()
+	special_vectors["chest_rgt"]	= special_vectors["chest_lft"] * -1
+	special_vectors["chest_up"]		= ( sensor[SENSORBONE.SPINE] - sensor[SENSORBONE.SHOULDER] ):GetNormal()
+	special_vectors["chest_dn"]		= special_vectors["chest_up"] * -1
+	special_vectors["chest_bck"]	= special_vectors["chest_up"]:Cross( special_vectors["chest_lft"] )
+	special_vectors["chest_fwd"]	= special_vectors["chest_bck"] * -1
+
+	special_vectors["head_up"]		= ( sensor[SENSORBONE.SHOULDER] - sensor[SENSORBONE.HEAD] ):GetNormal()
+	special_vectors["head_back"]	= special_vectors["head_up"]:Cross( special_vectors["chest_lft"] )
+
+	local reprocess = {}
+
+	for k, v in pairs( translator.AnglesTable ) do
+
+		table.insert( reprocess, k )
+
+	end
+
+	for iPasses = 1, 5 do
+
+		local cur_process = reprocess
+		reprocess = {}
+
+		for k, v in pairs( cur_process ) do
+
+			if ( !motionsensor.ProcessAngle( translator, sensor, pos, ang, special_vectors, v, translator.AnglesTable[v] ) ) then
+				table.insert( reprocess, v )
+			end
+
+		end
+
+		if ( table.IsEmpty( reprocess ) ) then
+			--DebugInfo( 0, iPasses .. " Passes" )
+			return ang
+		end
+
+	end
+
+	--
+	-- If we got here then we're doing something wrong.
+	-- It should have out'ed before completing 5 passes.
+	--
+	DebugInfo( 0, "motionsensor.ProcessAnglesTable: 4+ passes!" )
+	return ang
+
+end
+
+--
+-- Processes the PositionTable from a skeleton constructor
+--
+motionsensor.ProcessPositionTable = function( translator, sensor )
+
+	if ( !translator.PositionTable ) then return {} end
+
+	local pos = {}
+
+	for k, v in pairs( translator.PositionTable ) do
+
+		-- A number means get value straight from the sensor
+		if ( isnumber( v ) ) then pos[ k ] = sensor[ v ] end
+
+		if ( istable( v ) and v.type == "lerp" ) then
+
+			pos[ k ] = LerpVector( v.value, sensor[ v.from ], sensor[ v.to ] )
+
+		end
+
+	end
+
+	return pos
+
+end
+
+--
+-- Called to build the skeleton
+--
+motionsensor.BuildSkeleton = function( translator, player, rotation )
+
+	--
+	-- The kinect animations are recorded on the skunt, so rotate towards the player
+	--
+	rotation:RotateAroundAxis( rotation:Up(), -90 )
+
+	--
+	-- Pre-get and rotate all the player positions
+	--
+	local sensor = {}
+	for i = 0, 19 do
+		sensor[ i ] = player:MotionSensorPos( i )
+		sensor[ i ]:Rotate( rotation )
+	end
+
+	if ( translator.PrePosition ) then
+		translator:PrePosition( sensor )
+	end
+
+	--
+	-- Fill out the position table..
+	--
+	local pos = motionsensor.ProcessPositionTable( translator, sensor )
+
+	--
+	-- Fill out the angles
+	--
+	local ang = motionsensor.ProcessAnglesTable( translator, sensor, pos, rotation )
+
+	--
+	-- Allow the bone builder to make any last minute changes
+	--
+	translator:Complete( player, sensor, rotation, pos, ang )
+
+	return pos, ang, sensor
+
+end
+

lua/includes/extensions/net.lua

@@ -0,0 +1,238 @@
+
+-- TODO: Hack. Move to where color is defined?
+TYPE_COLOR = 255
+
+net.Receivers = {}
+
+--
+-- Set up a function to receive network messages
+--
+function net.Receive( name, func )
+
+	net.Receivers[ name:lower() ] = func
+
+end
+
+--
+-- A message has been received from the network..
+--
+function net.Incoming( len, client )
+
+	local i = net.ReadHeader()
+	local strName = util.NetworkIDToString( i )
+
+	if ( !strName ) then return end
+
+	local func = net.Receivers[ strName:lower() ]
+	if ( !func ) then return end
+
+	--
+	-- len includes the 16 bit int which told us the message name
+	--
+	len = len - 16
+
+	func( len, client )
+
+end
+
+--
+-- Read/Write a boolean to the stream
+--
+net.WriteBool = net.WriteBit
+
+function net.ReadBool()
+
+	return net.ReadBit() == 1
+
+end
+
+--
+-- Read/Write an entity to the stream
+--
+function net.WriteEntity( ent )
+
+	if ( !IsValid( ent ) ) then
+		net.WriteUInt( 0, MAX_EDICT_BITS )
+	else
+		net.WriteUInt( ent:EntIndex(), MAX_EDICT_BITS )
+	end
+
+end
+
+function net.ReadEntity()
+
+	local i = net.ReadUInt( MAX_EDICT_BITS )
+	if ( !i ) then return end
+
+	return Entity( i )
+
+end
+
+
+--
+-- Read/Write a player to the stream
+--
+
+-- TODO: Replace with MAX_PLAYER_BITS
+local maxplayers_bits = math.ceil( math.log( 1 + game.MaxPlayers() ) / math.log( 2 ) )
+
+function net.WritePlayer( ply )
+	net.WriteUInt( IsValid( ply ) and ply:IsPlayer() and ply:EntIndex() or 0, maxplayers_bits )
+end
+
+function net.ReadPlayer()
+	return Entity( net.ReadUInt( maxplayers_bits ) )
+end
+
+
+--
+-- Read/Write a color to/from the stream
+--
+function net.WriteColor( col, writeAlpha )
+	if ( writeAlpha == nil ) then writeAlpha = true end
+
+	assert( IsColor( col ), "net.WriteColor: color expected, got ".. type( col ) )
+
+	local r, g, b, a = col:Unpack()
+	net.WriteUInt( r, 8 )
+	net.WriteUInt( g, 8 )
+	net.WriteUInt( b, 8 )
+
+	if ( writeAlpha ) then
+		net.WriteUInt( a, 8 )
+	end
+end
+
+function net.ReadColor( readAlpha )
+	if ( readAlpha == nil ) then readAlpha = true end
+
+	local r, g, b =
+		net.ReadUInt( 8 ),
+		net.ReadUInt( 8 ),
+		net.ReadUInt( 8 )
+
+	local a = 255
+	if ( readAlpha ) then a = net.ReadUInt( 8 ) end
+
+	return Color( r, g, b, a )
+
+end
+
+--
+-- Write a whole table to the stream
+-- This is less optimal than writing each
+-- item individually and in a specific order
+-- because it adds type information before each var
+--
+function net.WriteTable( tab, seq )
+
+	if ( seq ) then
+
+		local len = #tab
+		net.WriteUInt( len, 32 )
+
+		for i = 1, len do
+
+			net.WriteType( tab[ i ] )
+
+		end
+
+	else
+
+		for k, v in pairs( tab ) do
+
+			net.WriteType( k )
+			net.WriteType( v )
+
+		end
+
+		-- End of table
+		net.WriteType( nil )
+
+	end
+
+end
+
+function net.ReadTable( seq )
+
+	local tab = {}
+
+	if ( seq ) then
+
+		for i = 1, net.ReadUInt( 32 ) do
+
+			tab[ i ] = net.ReadType()
+
+		end
+
+	else
+
+		while true do
+
+			local k = net.ReadType()
+			if ( k == nil ) then break end
+
+			tab[ k ] = net.ReadType()
+
+		end
+
+	end
+
+	return tab
+
+end
+
+net.WriteVars =
+{
+	[TYPE_NIL]			= function ( t, v )	net.WriteUInt( t, 8 )								end,
+	[TYPE_STRING]		= function ( t, v )	net.WriteUInt( t, 8 )	net.WriteString( v )		end,
+	[TYPE_NUMBER]		= function ( t, v )	net.WriteUInt( t, 8 )	net.WriteDouble( v )		end,
+	[TYPE_TABLE]		= function ( t, v )	net.WriteUInt( t, 8 )	net.WriteTable( v )			end,
+	[TYPE_BOOL]			= function ( t, v )	net.WriteUInt( t, 8 )	net.WriteBool( v )			end,
+	[TYPE_ENTITY]		= function ( t, v )	net.WriteUInt( t, 8 )	net.WriteEntity( v )		end,
+	[TYPE_VECTOR]		= function ( t, v )	net.WriteUInt( t, 8 )	net.WriteVector( v )		end,
+	[TYPE_ANGLE]		= function ( t, v )	net.WriteUInt( t, 8 )	net.WriteAngle( v )			end,
+	[TYPE_MATRIX]		= function ( t, v ) net.WriteUInt( t, 8 )	net.WriteMatrix( v )		end,
+	[TYPE_COLOR]		= function ( t, v ) net.WriteUInt( t, 8 )	net.WriteColor( v )			end,
+}
+
+function net.WriteType( v )
+	local typeid = nil
+
+	if IsColor( v ) then
+		typeid = TYPE_COLOR
+	else
+		typeid = TypeID( v )
+	end
+
+	local wv = net.WriteVars[ typeid ]
+	if ( wv ) then return wv( typeid, v ) end
+
+	error( "net.WriteType: Couldn't write " .. type( v ) .. " (type " .. typeid .. ")" )
+
+end
+
+net.ReadVars =
+{
+	[TYPE_NIL]		= function ()	return nil end,
+	[TYPE_STRING]	= function ()	return net.ReadString() end,
+	[TYPE_NUMBER]	= function ()	return net.ReadDouble() end,
+	[TYPE_TABLE]	= function ()	return net.ReadTable() end,
+	[TYPE_BOOL]		= function ()	return net.ReadBool() end,
+	[TYPE_ENTITY]	= function ()	return net.ReadEntity() end,
+	[TYPE_VECTOR]	= function ()	return net.ReadVector() end,
+	[TYPE_ANGLE]	= function ()	return net.ReadAngle() end,
+	[TYPE_MATRIX]	= function ()	return net.ReadMatrix() end,
+	[TYPE_COLOR]	= function ()	return net.ReadColor() end,
+}
+
+function net.ReadType( typeid )
+
+	typeid = typeid or net.ReadUInt( 8 )
+
+	local rv = net.ReadVars[ typeid ]
+	if ( rv ) then return rv() end
+
+	error( "net.ReadType: Couldn't read type " .. typeid )
+
+end

lua/includes/extensions/player.lua

@@ -0,0 +1,305 @@
+
+local meta = FindMetaTable( "Player" )
+local entity = FindMetaTable( "Entity" )
+
+-- Return if there's nothing to add on to
+if ( !meta ) then return end
+
+--
+-- Entity index accessor. This used to be done in engine, but it's done in Lua now because it's faster
+--
+function meta:__index( key )
+
+	--
+	-- Search the metatable. We can do this without dipping into C, so we do it first.
+	--
+	local val = meta[key]
+	if ( val ~= nil ) then return val end
+
+	--
+	-- Search the entity metatable
+	--
+	local entval = entity[key]
+	if ( entval ~= nil ) then return entval end
+
+	--
+	-- Search the entity table
+	--
+	local tab = entity.GetTable( self )
+	if ( tab ) then
+		return tab[ key ]
+	end
+
+	return nil
+
+end
+
+if ( !sql.TableExists( "playerpdata" ) ) then
+
+	sql.Query( "CREATE TABLE IF NOT EXISTS playerpdata ( infoid TEXT NOT NULL PRIMARY KEY, value TEXT );" )
+
+end
+
+--[[---------------------------------------------------------
+	Name: DebugInfo
+	Desc: Prints debug information for the player
+		( this is just an example )
+-----------------------------------------------------------]]
+function meta:DebugInfo()
+
+	Msg( "Name: " .. self:Name() .. "\n" )
+	Msg( "Pos: " .. tostring( self:GetPos() ) .. "\n" )
+
+end
+
+-- Helpful aliases
+meta.GetName = meta.Nick
+meta.Name = meta.Nick
+
+--[[---------------------------------------------------------
+	Name: ConCommand
+	Desc: Overrides the default ConCommand function
+-----------------------------------------------------------]]
+if ( CLIENT ) then
+
+	local SendConCommand = meta.ConCommand
+	local CommandList = nil
+
+	function meta:ConCommand( command, bSkipQueue )
+
+		if ( bSkipQueue or IsConCommandBlocked( command ) ) then
+			SendConCommand( self, command )
+		else
+			CommandList = CommandList or {}
+			table.insert( CommandList, command )
+		end
+
+	end
+
+	local function SendQueuedConsoleCommands()
+
+		if ( !CommandList ) then return end
+
+		local BytesSent = 0
+
+		for k, v in pairs( CommandList ) do
+
+			SendConCommand( LocalPlayer(), v )
+			CommandList[ k ] = nil
+
+			-- Only send x bytes per tick
+			BytesSent = BytesSent + v:len()
+			if ( BytesSent > 128 ) then
+				break
+			end
+
+		end
+
+		-- Turn the table into a nil so we can return easy
+		if ( table.IsEmpty( CommandList ) ) then
+
+			CommandList = nil
+
+		end
+
+	end
+
+	hook.Add( "Tick", "SendQueuedConsoleCommands", SendQueuedConsoleCommands )
+
+end
+
+--[[---------------------------------------------------------
+	GetPData
+	Saves persist data for this player
+-----------------------------------------------------------]]
+function meta:GetPData( name, default )
+
+	-- First try looking up using the new key
+	local key = Format( "%s[%s]", self:SteamID64(), name )
+	local val = sql.QueryValue( "SELECT value FROM playerpdata WHERE infoid = " .. SQLStr( key ) .. " LIMIT 1" )
+	if ( val == nil ) then
+
+		-- Not found? Look using the old key
+		local oldkey = Format( "%s[%s]", self:UniqueID(), name )
+		val = sql.QueryValue( "SELECT value FROM playerpdata WHERE infoid = " .. SQLStr( oldkey ) .. " LIMIT 1" )
+		if ( val == nil ) then return default end
+
+	end
+
+	return val
+
+end
+
+--[[---------------------------------------------------------
+	SetPData
+	Set persistant data
+-----------------------------------------------------------]]
+function meta:SetPData( name, value )
+
+	-- Remove old value
+	local oldkey = Format( "%s[%s]", self:UniqueID(), name )
+	sql.Query( "DELETE FROM playerpdata WHERE infoid = " .. SQLStr( oldkey ) )
+
+	local key = Format( "%s[%s]", self:SteamID64(), name )
+	return sql.Query( "REPLACE INTO playerpdata ( infoid, value ) VALUES ( " .. SQLStr( key ) .. ", " .. SQLStr( value ) .. " )" ) ~= false
+
+end
+
+--[[---------------------------------------------------------
+	RemovePData
+	Remove persistant data
+-----------------------------------------------------------]]
+function meta:RemovePData( name )
+
+	-- First old key
+	local oldkey = Format( "%s[%s]", self:UniqueID(), name )
+	local removed = sql.Query( "DELETE FROM playerpdata WHERE infoid = " .. SQLStr( oldkey ) ) ~= false
+
+	-- Then new key
+	local key = Format( "%s[%s]", self:SteamID64(), name )
+	local removed2 = sql.Query( "DELETE FROM playerpdata WHERE infoid = " .. SQLStr( key ) ) ~= false
+
+	return removed or removed2
+
+end
+
+--
+-- If they have their preferred default weapon then switch to it
+--
+function meta:SwitchToDefaultWeapon()
+
+	local weapon = self:GetInfo( "cl_defaultweapon" )
+
+	if ( self:HasWeapon( weapon ) ) then
+		self:SelectWeapon( weapon )
+	end
+
+end
+
+--
+-- Can use flashlight?
+--
+function meta:AllowFlashlight( bAble ) self.m_bFlashlight = bAble end
+function meta:CanUseFlashlight() return self.m_bFlashlight == true end
+
+-- A function to set up player hands, so coders don't have to copy all the code everytime.
+-- Call this in PlayerSpawn hook
+function meta:SetupHands( spec_ply )
+
+	local oldhands = self:GetHands()
+	if ( IsValid( oldhands ) ) then
+		oldhands:Remove()
+	end
+
+	local hands = ents.Create( "gmod_hands" )
+	if ( IsValid( hands ) ) then
+		hands:DoSetup( self, spec_ply )
+		hands:Spawn()
+	end
+
+end
+
+--
+-- Those functions have been removed from the engine since AddFlag and RemoveFlag
+-- made them obsolete, but we'll keep a Lua version of them for backward compatibility
+--
+if ( SERVER ) then
+
+--[[---------------------------------------------------------
+	Freeze
+	Freezes or unfreezes the player
+-----------------------------------------------------------]]
+function meta:Freeze( b )
+
+	if ( b ) then
+		self:AddFlags( FL_FROZEN )
+	else
+		self:RemoveFlags( FL_FROZEN )
+	end
+
+end
+
+--[[---------------------------------------------------------
+	GodEnable
+	Enables godmode on the player
+-----------------------------------------------------------]]
+function meta:GodEnable()
+
+	self:AddFlags( FL_GODMODE )
+
+end
+
+--[[---------------------------------------------------------
+	GodDisable
+	Disables godmode on the player
+-----------------------------------------------------------]]
+function meta:GodDisable()
+
+	self:RemoveFlags( FL_GODMODE )
+
+end
+
+end
+
+--[[---------------------------------------------------------
+	IsFrozen
+	Returns true if the player is frozen
+-----------------------------------------------------------]]
+function meta:IsFrozen()
+
+	return self:IsFlagSet( FL_FROZEN )
+
+end
+
+--[[---------------------------------------------------------
+	HasGodMode
+	Returns true if the player is in godmode
+-----------------------------------------------------------]]
+function meta:HasGodMode()
+
+	return self:IsFlagSet( FL_GODMODE )
+
+end
+
+-- These are totally in the wrong place.
+function player.GetByAccountID( ID )
+	for _, pl in player.Iterator() do
+		if ( pl:AccountID() == ID ) then
+			return pl
+		end
+	end
+
+	return false
+end
+
+function player.GetByUniqueID( ID )
+	for _, pl in player.Iterator() do
+		if ( pl:UniqueID() == ID ) then
+			return pl
+		end
+	end
+
+	return false
+end
+
+function player.GetBySteamID( ID )
+	ID = string.upper( ID )
+
+	for _, pl in player.Iterator() do
+		if ( pl:SteamID() == ID ) then
+			return pl
+		end
+	end
+
+	return false
+end
+
+function player.GetBySteamID64( ID )
+	for _, pl in player.Iterator() do
+		if ( pl:SteamID64() == ID ) then
+			return pl
+		end
+	end
+
+	return false
+end

lua/includes/extensions/player_auth.lua

@@ -0,0 +1,129 @@
+
+local meta = FindMetaTable( "Player" )
+if ( not meta ) then return end
+
+--[[---------------------------------------------------------
+	Name: IsAdmin
+	Desc: Returns if a player is an admin.
+-----------------------------------------------------------]]
+function meta:IsAdmin()
+
+	if ( self:IsSuperAdmin() ) then return true end
+	if ( self:IsUserGroup( "admin" ) ) then return true end
+
+	return false
+
+end
+
+--[[---------------------------------------------------------
+	Name: IsSuperAdmin
+	Desc: Returns if a player is a superadmin.
+-----------------------------------------------------------]]
+function meta:IsSuperAdmin()
+
+	return self:IsUserGroup( "superadmin" )
+
+end
+
+--[[---------------------------------------------------------
+	Name: IsUserGroup
+	Desc: Returns if a player is in the specified usergroup.
+-----------------------------------------------------------]]
+function meta:IsUserGroup( name )
+
+	if ( not self:IsValid() ) then return false end
+
+	return self:GetUserGroup() == name
+
+end
+
+--[[---------------------------------------------------------
+	Name: GetUserGroup
+	Desc: Returns the player's usergroup.
+-----------------------------------------------------------]]
+function meta:GetUserGroup()
+
+	return self:GetNWString( "UserGroup", "user" )
+
+end
+
+
+--[[---------------------------------------------------------
+	This is the meat and spunk of the player auth system
+-----------------------------------------------------------]]
+
+if ( not SERVER ) then return end
+
+--[[---------------------------------------------------------
+	Name: SetUserGroup
+	Desc: Sets the player's usergroup. ( Serverside Only )
+-----------------------------------------------------------]]
+function meta:SetUserGroup( name )
+
+	self:SetNWString( "UserGroup", name )
+
+end
+
+
+-- SteamIds table..
+-- STEAM_0:1:7099:
+--		name	=	garry
+--		group	=	superadmin
+
+local SteamIDs = {}
+
+local function LoadUsersFile()
+
+	local txt = file.Read( "settings/users.txt", "MOD" )
+	if ( not txt ) then MsgN( "Failed to load settings/users.txt!" ) return end
+
+	-- Load the users file
+	local UsersKV = util.KeyValuesToTable( txt )
+	if ( not UsersKV ) then MsgN( "Failed to parse settings/users.txt!" ) return end
+
+	SteamIDs = {}
+
+	-- Extract the data into the SteamIDs table
+	for key, tab in pairs( UsersKV ) do
+		for name, steamid in pairs( tab ) do
+			SteamIDs[ steamid ] = {}
+			SteamIDs[ steamid ].name = name
+			SteamIDs[ steamid ].group = key
+		end
+	end
+
+end
+
+LoadUsersFile()
+
+function util.GetUserGroups()
+
+	return SteamIDs
+
+end
+
+hook.Add( "PlayerInitialSpawn", "PlayerAuthSpawn", function( ply )
+
+	local steamid = ply:SteamID()
+
+	if ( game.SinglePlayer() or ply:IsListenServerHost() ) then
+		ply:SetUserGroup( "superadmin" )
+		return
+	end
+
+	if ( SteamIDs[ steamid ] == nil ) then
+		ply:SetUserGroup( "user" )
+		return
+	end
+
+	-- Admin SteamID need to be fully authenticated by Steam!
+	if ( ply.IsFullyAuthenticated and not ply:IsFullyAuthenticated() ) then
+		ply:ChatPrint( string.format( "Hey '%s' - Your SteamID wasn't fully authenticated, so your usergroup has not been set to '%s'.", SteamIDs[ steamid ].name, SteamIDs[ steamid ].group ) )
+		ply:ChatPrint( "Try restarting Steam." )
+		return
+	end
+
+	ply:SetUserGroup( SteamIDs[ steamid ].group )
+	ply:ChatPrint( string.format( "Hey '%s' - You're in the '%s' group on this server.", SteamIDs[ steamid ].name, SteamIDs[ steamid ].group ) )
+
+end )

lua/includes/extensions/string.lua

@@ -0,0 +1,444 @@
+
+local string = string
+local math = math
+
+--[[---------------------------------------------------------
+	Name: string.ToTable( string )
+-----------------------------------------------------------]]
+function string.ToTable( input )
+	local tbl = {}
+
+	-- For numbers, as some addons do this..
+	local str = tostring( input )
+
+	for i = 1, #str do
+		tbl[i] = string.sub( str, i, i )
+	end
+
+	return tbl
+end
+
+--[[---------------------------------------------------------
+	Name: string.JavascriptSafe( string )
+	Desc: Takes a string and escapes it for insertion in to a JavaScript string
+-----------------------------------------------------------]]
+local javascript_escape_replacements = {
+	["\\"] = "\\\\",
+	["\0"] = "\\x00" ,
+	["\b"] = "\\b" ,
+	["\t"] = "\\t" ,
+	["\n"] = "\\n" ,
+	["\v"] = "\\v" ,
+	["\f"] = "\\f" ,
+	["\r"] = "\\r" ,
+	["\""] = "\\\"",
+	["\'"] = "\\\'",
+	["`"] = "\\`",
+	["$"] = "\\$",
+	["{"] = "\\{",
+	["}"] = "\\}"
+}
+
+function string.JavascriptSafe( str )
+
+	str = string.gsub( str, ".", javascript_escape_replacements )
+
+	-- U+2028 and U+2029 are treated as line separators in JavaScript, handle separately as they aren't single-byte
+	str = string.gsub( str, "\226\128\168", "\\\226\128\168" )
+	str = string.gsub( str, "\226\128\169", "\\\226\128\169" )
+
+	return str
+
+end
+
+--[[---------------------------------------------------------
+	Name: string.PatternSafe( string )
+	Desc: Takes a string and escapes it for insertion in to a Lua pattern
+-----------------------------------------------------------]]
+local pattern_escape_replacements = {
+	["("] = "%(",
+	[")"] = "%)",
+	["."] = "%.",
+	["%"] = "%%",
+	["+"] = "%+",
+	["-"] = "%-",
+	["*"] = "%*",
+	["?"] = "%?",
+	["["] = "%[",
+	["]"] = "%]",
+	["^"] = "%^",
+	["$"] = "%$",
+	["\0"] = "%z"
+}
+
+function string.PatternSafe( str )
+	return ( string.gsub( str, ".", pattern_escape_replacements ) )
+end
+
+--[[---------------------------------------------------------
+	Name: explode(seperator ,string)
+	Desc: Takes a string and turns it into a table
+	Usage: string.explode( " ", "Seperate this string")
+-----------------------------------------------------------]]
+local totable = string.ToTable
+local string_sub = string.sub
+local string_find = string.find
+local string_len = string.len
+function string.Explode( separator, str, withpattern )
+	if ( separator == "" ) then return totable( str ) end
+	if ( withpattern == nil ) then withpattern = false end
+
+	local ret = {}
+	local current_pos = 1
+
+	for i = 1, string_len( str ) do
+		local start_pos, end_pos = string_find( str, separator, current_pos, not withpattern )
+		if ( not start_pos ) then break end
+		ret[ i ] = string_sub( str, current_pos, start_pos - 1 )
+		current_pos = end_pos + 1
+	end
+
+	ret[ #ret + 1 ] = string_sub( str, current_pos )
+
+	return ret
+end
+
+function string.Split( str, delimiter )
+	return string.Explode( delimiter, str )
+end
+
+--[[---------------------------------------------------------
+	Name: Implode( seperator, Table)
+	Desc: Takes a table and turns it into a string
+	Usage: string.Implode( " ", { "This", "Is", "A", "Table" } )
+-----------------------------------------------------------]]
+function string.Implode( seperator, Table ) return
+	table.concat( Table, seperator )
+end
+
+--[[---------------------------------------------------------
+	Name: GetExtensionFromFilename( path )
+	Desc: Returns extension from path
+	Usage: string.GetExtensionFromFilename("garrysmod/lua/modules/string.lua")
+-----------------------------------------------------------]]
+function string.GetExtensionFromFilename( path )
+	for i = #path, 1, -1 do
+		local c = string.sub( path, i, i )
+		if ( c == "/" or c == "\\" ) then return nil end
+		if ( c == "." ) then return string.sub( path, i + 1 ) end
+	end
+
+	return nil
+end
+
+--[[---------------------------------------------------------
+	Name: StripExtension( path )
+-----------------------------------------------------------]]
+function string.StripExtension( path )
+	for i = #path, 1, -1 do
+		local c = string.sub( path, i, i )
+		if ( c == "/" or c == "\\" ) then return path end
+		if ( c == "." ) then return string.sub( path, 1, i - 1 ) end
+	end
+
+	return path
+end
+
+--[[---------------------------------------------------------
+	Name: GetPathFromFilename( path )
+	Desc: Returns path from filepath
+	Usage: string.GetPathFromFilename("garrysmod/lua/modules/string.lua")
+-----------------------------------------------------------]]
+function string.GetPathFromFilename( path )
+	for i = #path, 1, -1 do
+		local c = string.sub( path, i, i )
+		if ( c == "/" or c == "\\" ) then return string.sub( path, 1, i ) end
+	end
+
+	return ""
+end
+
+--[[---------------------------------------------------------
+	Name: GetFileFromFilename( path )
+	Desc: Returns file with extension from path
+	Usage: string.GetFileFromFilename("garrysmod/lua/modules/string.lua")
+-----------------------------------------------------------]]
+function string.GetFileFromFilename( path )
+	for i = #path, 1, -1 do
+		local c = string.sub( path, i, i )
+		if ( c == "/" or c == "\\" ) then return string.sub( path, i + 1 ) end
+	end
+
+	return path
+end
+
+--[[-----------------------------------------------------------------
+	Name: FormattedTime( TimeInSeconds, Format )
+	Desc: Given a time in seconds, returns formatted time
+			If 'Format' is not specified the function returns a table
+			conatining values for hours, mins, secs, ms
+
+	Examples: string.FormattedTime( 123.456, "%02i:%02i:%02i")	==> "02:03:45"
+			  string.FormattedTime( 123.456, "%02i:%02i")		==> "02:03"
+			  string.FormattedTime( 123.456, "%2i:%02i")		==> " 2:03"
+			  string.FormattedTime( 123.456 )					==> { h = 0, m = 2, s = 3, ms = 45 }
+-------------------------------------------------------------------]]
+function string.FormattedTime( seconds, format )
+	if ( not seconds ) then seconds = 0 end
+	local hours = math.floor( seconds / 3600 )
+	local minutes = math.floor( ( seconds / 60 ) % 60 )
+	local millisecs = ( seconds - math.floor( seconds ) ) * 100
+	seconds = math.floor( seconds % 60 )
+
+	if ( format ) then
+		return string.format( format, minutes, seconds, millisecs )
+	else
+		return { h = hours, m = minutes, s = seconds, ms = millisecs }
+	end
+end
+
+--[[---------------------------------------------------------
+	Name: Old time functions
+-----------------------------------------------------------]]
+function string.ToMinutesSecondsMilliseconds( TimeInSeconds ) return string.FormattedTime( TimeInSeconds, "%02i:%02i:%02i" ) end
+function string.ToMinutesSeconds( TimeInSeconds ) return string.FormattedTime( TimeInSeconds, "%02i:%02i" ) end
+
+local function pluralizeString( str, quantity )
+	return str .. ( ( quantity ~= 1 ) and "s" or "" )
+end
+
+function string.NiceTime( seconds )
+
+	if ( seconds == nil ) then return "a few seconds" end
+
+	if ( seconds < 60 ) then
+		local t = math.floor( seconds )
+		return t .. pluralizeString( " second", t )
+	end
+
+	if ( seconds < 60 * 60 ) then
+		local t = math.floor( seconds / 60 )
+		return t .. pluralizeString( " minute", t )
+	end
+
+	if ( seconds < 60 * 60 * 24 ) then
+		local t = math.floor( seconds / (60 * 60) )
+		return t .. pluralizeString( " hour", t )
+	end
+
+	if ( seconds < 60 * 60 * 24 * 7 ) then
+		local t = math.floor( seconds / ( 60 * 60 * 24 ) )
+		return t .. pluralizeString( " day", t )
+	end
+
+	if ( seconds < 60 * 60 * 24 * 365 ) then
+		local t = math.floor( seconds / ( 60 * 60 * 24 * 7 ) )
+		return t .. pluralizeString( " week", t )
+	end
+
+	local t = math.floor( seconds / ( 60 * 60 * 24 * 365 ) )
+	return t .. pluralizeString( " year", t )
+
+end
+
+function string.Left( str, num ) return string.sub( str, 1, num ) end
+function string.Right( str, num ) return string.sub( str, -num ) end
+
+function string.Replace( str, tofind, toreplace )
+	local tbl = string.Explode( tofind, str )
+	if ( tbl[ 1 ] ) then return table.concat( tbl, toreplace ) end
+	return str
+end
+
+--[[---------------------------------------------------------
+	Name: Trim( s )
+	Desc: Removes leading and trailing spaces from a string.
+			Optionally pass char to trim that character from the ends instead of space
+-----------------------------------------------------------]]
+function string.Trim( s, char )
+	if ( char ) then char = string.PatternSafe( char ) else char = "%s" end
+	return string.match( s, "^" .. char .. "*(.-)" .. char .. "*$" ) or s
+end
+
+--[[---------------------------------------------------------
+	Name: TrimRight( s )
+	Desc: Removes trailing spaces from a string.
+			Optionally pass char to trim that character from the ends instead of space
+-----------------------------------------------------------]]
+function string.TrimRight( s, char )
+	if ( char ) then char = string.PatternSafe( char ) else char = "%s" end
+	return string.match( s, "^(.-)" .. char .. "*$" ) or s
+end
+
+--[[---------------------------------------------------------
+	Name: TrimLeft( s )
+	Desc: Removes leading spaces from a string.
+			Optionally pass char to trim that character from the ends instead of space
+-----------------------------------------------------------]]
+function string.TrimLeft( s, char )
+	if ( char ) then char = string.PatternSafe( char ) else char = "%s" end
+	return string.match( s, "^" .. char .. "*(.+)$" ) or s
+end
+
+function string.NiceSize( size )
+
+	size = tonumber( size )
+
+	if ( size <= 0 ) then return "0" end
+	if ( size < 1000 ) then return size .. " Bytes" end
+	if ( size < 1000 * 1000 ) then return math.Round( size / 1000, 2 ) .. " KB" end
+	if ( size < 1000 * 1000 * 1000 ) then return math.Round( size / ( 1000 * 1000 ), 2 ) .. " MB" end
+
+	return math.Round( size / ( 1000 * 1000 * 1000 ), 2 ) .. " GB"
+
+end
+
+-- Note: These use Lua index numbering, not what you'd expect
+-- ie they start from 1, not 0.
+
+function string.SetChar( s, k, v )
+
+	return string.sub( s, 0, k - 1 ) .. v .. string.sub( s, k + 1 )
+
+end
+
+function string.GetChar( s, k )
+
+	return string.sub( s, k, k )
+
+end
+
+local meta = getmetatable( "" )
+
+function meta:__index( key )
+
+	local val = string[ key ]
+	if ( val ~= nil ) then
+		return val
+	elseif ( tonumber( key ) ) then
+		return string.sub( self, key, key )
+	end
+
+end
+
+function string.StartsWith( str, start )
+
+	return string.sub( str, 1, string.len( start ) ) == start
+
+end
+string.StartWith = string.StartsWith
+
+function string.EndsWith( str, endStr )
+
+	return endStr == "" or string.sub( str, -string.len( endStr ) ) == endStr
+
+end
+
+function string.FromColor( color )
+
+	return Format( "%i %i %i %i", color.r, color.g, color.b, color.a )
+
+end
+
+function string.ToColor( str )
+
+	local r, g, b, a = string.match( str, "(%d+) (%d+) (%d+) (%d+)" )
+	return Color( tonumber( r ) or 255, tonumber( g ) or 255, tonumber( b ) or 255, tonumber( a ) or 255 )
+
+end
+
+function string.Comma( number, str )
+
+	if ( str ~= nil and not isstring( str ) ) then
+		error( "bad argument #2 to 'string.Comma' (string expected, got " .. type( str ) .. ")", 2 )
+	elseif ( str ~= nil and string.match( str, "%d" ) ~= nil ) then
+		error( "bad argument #2 to 'string.Comma' (non-numerical values expected, got " .. str .. ")", 2 )
+	end
+
+	local replace = str == nil and "%1,%2" or "%1" .. str .. "%2"
+
+	if ( isnumber( number ) ) then
+		number = string.format( "%f", number )
+		number = string.match( number, "^(.-)%.?0*$" ) -- Remove trailing zeros
+	end
+
+	local index = -1
+	while index ~= 0 do number, index = string.gsub( number, "^(-?%d+)(%d%d%d)", replace ) end
+
+	return number
+
+end
+
+function string.Interpolate( str, lookuptable )
+
+	return ( string.gsub( str, "{([_%a][_%w]*)}", lookuptable ) )
+
+end
+
+function string.CardinalToOrdinal( cardinal )
+
+	local basedigit = cardinal % 10
+
+	if ( basedigit == 1 ) then
+		if ( cardinal % 100 == 11 ) then
+			return cardinal .. "th"
+		end
+
+		return cardinal .. "st"
+	elseif ( basedigit == 2 ) then
+		if ( cardinal % 100 == 12 ) then
+			return cardinal .. "th"
+		end
+
+		return cardinal .. "nd"
+	elseif ( basedigit == 3 ) then
+		if ( cardinal % 100 == 13 ) then
+			return cardinal .. "th"
+		end
+
+		return cardinal .. "rd"
+	end
+
+	return cardinal .. "th"
+
+end
+
+function string.NiceName( name )
+
+	name = name:Replace( "_", " " )
+
+	-- Try to split text into words, where words would start with single uppercase character
+	local newParts = {}
+	for id, str in ipairs( string.Explode( " ", name ) ) do
+		local wordStart = 1
+		for i = 2, str:len() do
+			local c = str[ i ]
+			if ( c:upper() == c ) then
+				local toAdd = str:sub( wordStart, i - 1 )
+				if ( toAdd:upper() == toAdd ) then continue end
+				table.insert( newParts, toAdd )
+				wordStart = i
+			end
+
+		end
+
+		table.insert( newParts, str:sub( wordStart, str:len() ) )
+	end
+
+	-- Capitalize
+	--[[
+	for i, word in ipairs( newParts ) do
+		if ( #word == 1 ) then
+			newParts[i] = string.upper( word )
+		else
+			newParts[i] = string.upper( string.sub( word, 1, 1 ) ) .. string.sub( word, 2 )
+		end
+	end
+
+	return table.concat( newParts, " " )]]
+
+	local ret = table.concat( newParts, " " )
+	ret = string.upper( string.sub( ret, 1, 1 ) ) .. string.sub( ret, 2 )
+	return ret
+
+end

lua/includes/extensions/table.lua

@@ -0,0 +1,806 @@
+
+function table.Pack( ... )
+	return { ... }, select( "#", ... )
+end
+
+--[[---------------------------------------------------------
+	Name: Inherit( t, base )
+	Desc: Copies any missing data from base to t
+-----------------------------------------------------------]]
+function table.Inherit( t, base )
+
+	for k, v in pairs( base ) do
+		if ( t[ k ] == nil ) then t[ k ] = v end
+	end
+
+	t[ "BaseClass" ] = base
+
+	return t
+
+end
+
+--[[---------------------------------------------------------
+	Name: Copy(t, lookup_table)
+	Desc: Taken straight from http://lua-users.org/wiki/PitLibTablestuff
+		and modified to the new Lua 5.1 code by me.
+		Original function by PeterPrade!
+-----------------------------------------------------------]]
+function table.Copy( t, lookup_table )
+	if ( t == nil ) then return nil end
+
+	local copy = {}
+	setmetatable( copy, debug.getmetatable( t ) )
+	for i, v in pairs( t ) do
+		if ( !istable( v ) ) then
+			copy[ i ] = v
+		else
+			lookup_table = lookup_table or {}
+			lookup_table[ t ] = copy
+			if ( lookup_table[ v ] ) then
+				copy[ i ] = lookup_table[ v ] -- we already copied this table. reuse the copy.
+			else
+				copy[ i ] = table.Copy( v, lookup_table ) -- not yet copied. copy it.
+			end
+		end
+	end
+	return copy
+end
+
+--[[---------------------------------------------------------
+	Name: Empty( tab )
+	Desc: Empty a table
+-----------------------------------------------------------]]
+function table.Empty( tab )
+	for k, v in pairs( tab ) do
+		tab[ k ] = nil
+	end
+end
+
+--[[---------------------------------------------------------
+	Name: IsEmpty( tab )
+	Desc: Returns whether a table has iterable items in it, useful for non-sequential tables
+-----------------------------------------------------------]]
+function table.IsEmpty( tab )
+	return next( tab ) == nil
+end
+
+--[[---------------------------------------------------------
+	Name: CopyFromTo( FROM, TO )
+	Desc: Make TO exactly the same as FROM - but still the same table.
+-----------------------------------------------------------]]
+function table.CopyFromTo( from, to )
+
+	-- Erase values from table TO
+	table.Empty( to )
+
+	-- Copy values over
+	table.Merge( to, from )
+
+end
+
+--[[---------------------------------------------------------
+	Name: Merge
+	Desc: xx
+-----------------------------------------------------------]]
+function table.Merge( dest, source, forceOverride )
+
+	for k, v in pairs( source ) do
+		if ( !forceOverride and istable( v ) and istable( dest[ k ] ) ) then
+			-- don't overwrite one table with another
+			-- instead merge them recurisvely
+			table.Merge( dest[ k ], v )
+		else
+			dest[ k ] = v
+		end
+	end
+
+	return dest
+
+end
+
+--[[---------------------------------------------------------
+	Name: HasValue
+	Desc: Returns whether the value is in given table
+-----------------------------------------------------------]]
+function table.HasValue( t, val )
+	for k, v in pairs( t ) do
+		if ( v == val ) then return true end
+	end
+	return false
+end
+
+--[[---------------------------------------------------------
+	Name: table.Add( dest, source )
+	Desc: Unlike merge this adds the two tables together and discards keys.
+-----------------------------------------------------------]]
+function table.Add( dest, source )
+	-- The tables should be different otherwise this will just freeze the whole game
+	if ( dest == source ) then return dest end
+
+	-- At least one of them needs to be a table or this whole thing will fall on its ass
+	if ( !istable( source ) ) then return dest end
+	if ( !istable( dest ) ) then dest = {} end
+
+	for k, v in pairs( source ) do
+		table.insert( dest, v )
+	end
+
+	return dest
+end
+
+--[[---------------------------------------------------------
+	Name: table.SortDesc( table )
+	Desc: Like Lua's default sort, but descending
+-----------------------------------------------------------]]
+function table.SortDesc( t )
+	return table.sort( t, function( a, b ) return a > b end )
+end
+
+--[[---------------------------------------------------------
+	Name: table.SortByKey( table )
+	Desc: Returns a table sorted numerically by Key value
+-----------------------------------------------------------]]
+function table.SortByKey( t, desc )
+
+	local temp = {}
+
+	for key, _ in pairs( t ) do table.insert( temp, key ) end
+	if ( desc ) then
+		table.sort( temp, function( a, b ) return t[ a ] < t[ b ] end )
+	else
+		table.sort( temp, function( a, b ) return t[ a ] > t[ b ] end )
+	end
+
+	return temp
+
+end
+
+--[[---------------------------------------------------------
+	Name: table.Count( table )
+	Desc: Returns the number of keys in a table
+-----------------------------------------------------------]]
+function table.Count( t )
+	local i = 0
+	for k in pairs( t ) do i = i + 1 end
+	return i
+end
+
+--[[---------------------------------------------------------
+	Name: table.Random( table )
+	Desc: Return a random key
+-----------------------------------------------------------]]
+function table.Random( t )
+	local rk = math.random( 1, table.Count( t ) )
+	local i = 1
+	for k, v in pairs( t ) do
+		if ( i == rk ) then return v, k end
+		i = i + 1
+	end
+end
+
+--[[---------------------------------------------------------
+	Name: table.Shuffle( table )
+	Desc: Performs an inline Fisher-Yates shuffle on the table in O(n) time
+-----------------------------------------------------------]]
+function table.Shuffle( t )
+	local n = #t
+	for i = 1, n - 1 do
+		local j = math.random( i, n )
+		t[ i ], t[ j ] = t[ j ], t[ i ]
+	end
+end
+
+--[[----------------------------------------------------------------------
+	Name: table.IsSequential( table )
+	Desc: Returns true if the tables
+		keys are sequential
+-------------------------------------------------------------------------]]
+function table.IsSequential( t )
+	local i = 1
+	for key, value in pairs( t ) do
+		if ( t[ i ] == nil ) then return false end
+		i = i + 1
+	end
+	return true
+end
+
+--[[---------------------------------------------------------
+	Name: table.ToString( table,name,nice )
+	Desc: Convert a simple table to a string
+		table = the table you want to convert (table)
+		name  = the name of the table (string)
+		nice  = whether to add line breaks and indents (bool)
+-----------------------------------------------------------]]
+local function MakeTable( t, nice, indent, done )
+	local str = ""
+	done = done or {}
+	indent = indent or 0
+
+	local idt = ""
+	if ( nice ) then idt = string.rep( "\t", indent ) end
+
+	local nl, tab  = "", ""
+	if ( nice ) then nl, tab = "\n", "\t" end
+
+	local sequential = table.IsSequential( t )
+
+	for key, value in pairs( t ) do
+
+		str = str .. idt .. tab .. tab
+
+		if !sequential then
+			if ( isnumber( key ) or isbool( key ) ) then
+				key = "[" .. tostring( key ) .. "]" .. tab .. "="
+			else
+				key = tostring( key ) .. tab .. "="
+			end
+		else
+			key = ""
+		end
+
+		if ( istable( value ) and !done[ value ] ) then
+
+			if ( IsColor( value ) ) then
+				done[ value ] = true
+				value = "Color(" .. value.r .. "," .. value.g .. "," .. value.b .. "," .. value.a .. ")"
+				str = str .. key .. tab .. value .. "," .. nl
+			else
+				done[ value ] = true
+				str = str .. key .. tab .. '{' .. nl .. MakeTable( value, nice, indent + 1, done )
+				str = str .. idt .. tab .. tab .. tab .. tab .. "}," .. nl
+			end
+
+		else
+
+			if ( isstring( value ) ) then
+				value = '"' .. tostring( value ) .. '"'
+			elseif ( isvector( value ) ) then
+				value = "Vector(" .. value.x .. "," .. value.y .. "," .. value.z .. ")"
+			elseif ( isangle( value ) ) then
+				value = "Angle(" .. value.pitch .. "," .. value.yaw .. "," .. value.roll .. ")"
+			else
+				value = tostring( value )
+			end
+
+			str = str .. key .. tab .. value .. "," .. nl
+
+		end
+
+	end
+	return str
+end
+
+function table.ToString( t, n, nice )
+	local nl, tab  = "", ""
+	if ( nice ) then nl, tab = "\n", "\t" end
+
+	local str = ""
+	if ( n ) then str = n .. tab .. "=" .. tab end
+	return str .. "{" .. nl .. MakeTable( t, nice ) .. "}"
+end
+
+--[[---------------------------------------------------------
+	Name: table.Sanitise( table )
+	Desc: Converts a table containing vectors, angles, bools so it can be converted to and from keyvalues
+-----------------------------------------------------------]]
+function table.Sanitise( t, done )
+
+	done = done or {}
+	local tbl = {}
+
+	for k, v in pairs ( t ) do
+
+		if ( istable( v ) and !IsColor( v ) and !done[ v ] ) then
+
+			done[ v ] = true
+			tbl[ k ] = table.Sanitise( v, done )
+
+		else
+
+			if ( isvector( v ) ) then
+
+				local x, y, z = v.x, v.y, v.z
+				if y == 0 then y = nil end
+				if z == 0 then z = nil end
+				tbl[ k ] = { __type = "Vector", x = x, y = y, z = z }
+
+			elseif ( isangle( v ) ) then
+
+				local p, y, r = v.pitch, v.yaw, v.roll
+				if p == 0 then p = nil end
+				if y == 0 then y = nil end
+				if r == 0 then r = nil end
+				tbl[ k ] = { __type = "Angle", p = p, y = y, r = r }
+
+			elseif ( IsColor( v ) ) then
+
+				local r, g, b, a = v.r, v.g, v.b, v.a
+				if r == 255 then r = nil end
+				if g == 255 then g = nil end
+				if b == 255 then b = nil end
+				if a == 255 then a = nil end
+				tbl[ k ] = { __type = "Color", r = r, g = g, b = b, a = a }
+
+			elseif ( isbool( v ) ) then
+
+				tbl[ k ] = { __type = "Bool", tostring( v ) }
+
+			else
+
+				tbl[ k ] = tostring( v )
+
+			end
+
+		end
+
+	end
+
+	return tbl
+
+end
+
+--[[---------------------------------------------------------
+	Name: table.DeSanitise( table )
+	Desc: Converts a Sanitised table back
+-----------------------------------------------------------]]
+function table.DeSanitise( t, done )
+
+	done = done or {}
+	local tbl = {}
+
+	for k, v in pairs ( t ) do
+
+		if ( istable( v ) and !IsColor( v ) and !done[ v ] ) then
+
+			done[ v ] = true
+
+			if ( v.__type ) then
+
+				if ( v.__type == "Vector" ) then
+
+					tbl[ k ] = Vector( v.x or 0, v.y, v.z )
+
+				elseif ( v.__type == "Angle" ) then
+
+					tbl[ k ] = Angle( v.p or 0, v.y, v.r )
+
+				elseif ( v.__type == "Color" ) then
+
+					tbl[ k ] = Color( v.r or 255, v.g or 255, v.b or 255, v.a or 255 )
+
+				elseif ( v.__type == "Bool" ) then
+
+					tbl[ k ] = ( v[ 1 ] == "true" )
+
+				end
+
+			else
+
+				tbl[ k ] = table.DeSanitise( v, done )
+
+			end
+
+		else
+
+			tbl[ k ] = v
+
+		end
+
+	end
+
+	return tbl
+
+end
+
+function table.ForceInsert( t, v )
+
+	if ( t == nil ) then t = {} end
+
+	table.insert( t, v )
+
+	return t
+
+end
+
+--[[---------------------------------------------------------
+	Name: table.SortByMember( table )
+	Desc: Sorts table by named member
+-----------------------------------------------------------]]
+function table.SortByMember( tab, memberName, bAsc )
+
+	local TableMemberSort = function( a, b, MemberName, bReverse )
+
+		--
+		-- All this error checking kind of sucks, but really is needed
+		--
+		if ( !istable( a ) ) then return !bReverse end
+		if ( !istable( b ) ) then return bReverse end
+		if ( !a[ MemberName ] ) then return !bReverse end
+		if ( !b[ MemberName ] ) then return bReverse end
+
+		if ( isstring( a[ MemberName ] ) ) then
+
+			if ( bReverse ) then
+				return a[ MemberName ]:lower() < b[ MemberName ]:lower()
+			else
+				return a[ MemberName ]:lower() > b[ MemberName ]:lower()
+			end
+
+		end
+
+		if ( bReverse ) then
+			return a[ MemberName ] < b[ MemberName ]
+		else
+			return a[ MemberName ] > b[ MemberName ]
+		end
+
+	end
+
+	table.sort( tab, function( a, b ) return TableMemberSort( a, b, memberName, bAsc or false ) end )
+
+end
+
+--[[---------------------------------------------------------
+	Name: table.LowerKeyNames( table )
+	Desc: Lowercase the keynames of all tables
+-----------------------------------------------------------]]
+function table.LowerKeyNames( tab )
+
+	local OutTable = {}
+
+	for k, v in pairs( tab ) do
+
+		-- Recurse
+		if ( istable( v ) ) then
+			v = table.LowerKeyNames( v )
+		end
+
+		OutTable[ k ] = v
+
+		if ( isstring( k ) ) then
+
+			OutTable[ k ]  = nil
+			OutTable[ string.lower( k ) ] = v
+
+		end
+
+	end
+
+	return OutTable
+
+end
+
+--[[---------------------------------------------------------
+	Name: table.CollapseKeyValue( table )
+	Desc: Collapses a table with keyvalue structure
+-----------------------------------------------------------]]
+function table.CollapseKeyValue( Table )
+
+	local OutTable = {}
+
+	for k, v in pairs( Table ) do
+
+		local Val = v.Value
+
+		if ( istable( Val ) ) then
+			Val = table.CollapseKeyValue( Val )
+		end
+
+		OutTable[ v.Key ] = Val
+
+	end
+
+	return OutTable
+
+end
+
+--[[---------------------------------------------------------
+	Name: table.ClearKeys( table, bSaveKey )
+	Desc: Clears the keys, converting to a numbered format
+-----------------------------------------------------------]]
+function table.ClearKeys( Table, bSaveKey )
+
+	local OutTable = {}
+
+	for k, v in pairs( Table ) do
+		if ( bSaveKey ) then
+			v.__key = k
+		end
+		table.insert( OutTable, v )
+	end
+
+	return OutTable
+
+end
+
+local function keyValuePairs( state )
+
+	state.Index = state.Index + 1
+
+	local keyValue = state.KeyValues[ state.Index ]
+	if ( !keyValue ) then return end
+
+	return keyValue.key, keyValue.val
+
+end
+
+local function toKeyValues( tbl )
+
+	local result = {}
+
+	for k, v in pairs( tbl ) do
+		table.insert( result, { key = k, val = v } )
+	end
+
+	return result
+
+end
+
+local function getKeys( tbl )
+
+	local keys, i = {}, 0
+
+	for k in pairs( tbl ) do
+		i = i + 1
+		keys[ i ] = k
+	end
+
+	return keys
+
+end
+
+--[[---------------------------------------------------------
+	A Pairs function
+		Sorted by TABLE KEY
+-----------------------------------------------------------]]
+function SortedPairs( pTable, Desc )
+
+	local keys = getKeys( pTable )
+
+	if ( Desc ) then
+		table.sort( keys, function( a, b )
+			return a > b
+		end )
+	else
+		table.sort( keys, function( a, b )
+			return a < b
+		end )
+	end
+
+	local i, key = 1, nil
+	return function()
+		key, i = keys[ i ], i + 1
+		return key, pTable[ key ]
+	end
+
+end
+
+--[[---------------------------------------------------------
+	A Pairs function
+		Sorted by VALUE
+-----------------------------------------------------------]]
+function SortedPairsByValue( pTable, Desc )
+
+	local sortedTbl = toKeyValues( pTable )
+
+	if ( Desc ) then
+		table.sort( sortedTbl, function( a, b ) return a.val > b.val end )
+	else
+		table.sort( sortedTbl, function( a, b ) return a.val < b.val end )
+	end
+
+	return keyValuePairs, { Index = 0, KeyValues = sortedTbl }
+
+end
+
+--[[---------------------------------------------------------
+	A Pairs function
+		Sorted by Member Value (All table entries must be a table!)
+-----------------------------------------------------------]]
+function SortedPairsByMemberValue( pTable, pValueName, Desc )
+
+	local sortedTbl = toKeyValues( pTable )
+
+	for k, v in pairs( sortedTbl ) do
+		v.member = v.val[ pValueName ]
+	end
+
+	table.SortByMember( sortedTbl, "member", !Desc )
+
+	return keyValuePairs, { Index = 0, KeyValues = sortedTbl }
+
+end
+
+--[[---------------------------------------------------------
+	A Pairs function
+-----------------------------------------------------------]]
+function RandomPairs( pTable, Desc )
+
+	local sortedTbl = toKeyValues( pTable )
+
+	for k, v in pairs( sortedTbl ) do
+		v.rand = math.random( 1, 1000000 )
+	end
+
+	-- descending/ascending for a random order, really?
+	if ( Desc ) then
+		table.sort( sortedTbl, function( a, b ) return a.rand > b.rand end )
+	else
+		table.sort( sortedTbl, function( a, b ) return a.rand < b.rand end )
+	end
+
+	return keyValuePairs, { Index = 0, KeyValues = sortedTbl }
+
+end
+
+--[[---------------------------------------------------------
+	GetFirstKey
+-----------------------------------------------------------]]
+function table.GetFirstKey( t )
+	local k, _ = next( t )
+	return k
+end
+
+function table.GetFirstValue( t )
+	local _, v = next( t )
+	return v
+end
+
+function table.GetLastKey( t )
+	local k, _ = next( t, table.Count( t ) - 1 )
+	return k
+end
+
+function table.GetLastValue( t )
+	local _, v = next( t, table.Count( t ) - 1 )
+	return v
+end
+
+function table.FindNext( tab, val )
+	local bfound = false
+	for k, v in pairs( tab ) do
+		if ( bfound ) then return v end
+		if ( val == v ) then bfound = true end
+	end
+
+	return table.GetFirstValue( tab )
+end
+
+function table.FindPrev( tab, val )
+
+	local last = table.GetLastValue( tab )
+	for k, v in pairs( tab ) do
+		if ( val == v ) then return last end
+		last = v
+	end
+
+	return last
+
+end
+
+function table.GetWinningKey( tab )
+
+	local highest = -math.huge
+	local winner = nil
+
+	for k, v in pairs( tab ) do
+		if ( v > highest ) then
+			winner = k
+			highest = v
+		end
+	end
+
+	return winner
+
+end
+
+function table.KeyFromValue( tbl, val )
+	for key, value in pairs( tbl ) do
+		if ( value == val ) then return key end
+	end
+end
+
+function table.RemoveByValue( tbl, val )
+
+	local key = table.KeyFromValue( tbl, val )
+	if ( !key ) then return false end
+
+	if ( isnumber( key ) ) then
+		table.remove( tbl, key )
+	else
+		tbl[ key ] = nil
+	end
+
+	return key
+
+end
+
+function table.KeysFromValue( tbl, val )
+	local res = {}
+	for key, value in pairs( tbl ) do
+		if ( value == val ) then res[ #res + 1 ] = key end
+	end
+	return res
+end
+
+function table.MemberValuesFromKey( tab, key )
+	local res = {}
+	for k, v in pairs( tab ) do
+		if ( istable( v ) and v[ key ] != nil ) then res[ #res + 1 ] = v[ key ] end
+	end
+	return res
+end
+
+function table.Reverse( tbl )
+
+	local len = #tbl
+	local ret = {}
+
+	for i = len, 1, -1 do
+		ret[ len - i + 1 ] = tbl[ i ]
+	end
+
+	return ret
+
+end
+
+function table.ForEach( tab, funcname )
+
+	for k, v in pairs( tab ) do
+		funcname( k, v )
+	end
+
+end
+
+function table.GetKeys( tab )
+
+	local keys = {}
+	local id = 1
+
+	for k, v in pairs( tab ) do
+		keys[ id ] = k
+		id = id + 1
+	end
+
+	return keys
+
+end
+
+function table.Flip( tab )
+
+	local res = {}
+
+	for k, v in pairs( tab ) do
+		res[ v ] = k
+	end
+
+	return res
+
+end
+
+-- Polyfill for table.move on 32-bit
+-- Don't forget to remove this when it's no longer necessary
+if ( !table.move ) then
+	function table.move( sourceTbl, from, to, dest, destTbl )
+
+		if ( !istable( sourceTbl ) ) then error( "bad argument #1 to 'move' (table expected, got " .. type( sourceTbl ) .. ")", 2 ) end
+		if ( !isnumber( from ) ) then error( "bad argument #2 to 'move' (number expected, got " .. type( from ) .. ")", 2 ) end
+		if ( !isnumber( to ) ) then error( "bad argument #3 to 'move' (number expected, got " .. type( to ) .. ")", 2 ) end
+		if ( !isnumber( dest ) ) then error( "bad argument #4 to 'move' (number expected, got " .. type( dest ) .. ")", 2 ) end
+		if ( destTbl != nil ) then
+			if ( !istable( destTbl ) ) then error( "bad argument #5 to 'move' (table expected, got " .. type( destTbl ) .. ")", 2 ) end
+		else
+			destTbl = sourceTbl
+		end
+
+		local buffer = { unpack( sourceTbl, from, to ) }
+
+		dest = math.floor( dest - 1 )
+		for i, v in ipairs( buffer ) do
+			destTbl[ dest + i ] = v
+		end
+
+		return destTbl
+
+	end
+end

lua/includes/extensions/util.lua

@@ -0,0 +1,418 @@
+
+-- Return if there's nothing to add on to
+if ( !util ) then return end
+
+if ( CLIENT ) then
+	include( "util/worldpicker.lua" )
+end
+
+--[[---------------------------------------------------------
+   Name:	IsValidPhysicsObject
+   Params:	<ent> <num>
+   Desc:	Returns true if physics object is valid, false if not
+-----------------------------------------------------------]]
+function util.IsValidPhysicsObject( ent, num )
+
+	-- Make sure the entity is valid
+	if ( !ent or ( !ent:IsValid() and !ent:IsWorld() ) ) then return false end
+
+	-- This is to stop attaching to walking NPCs.
+	-- Although this is possible and `works', it can severly reduce the
+	-- performance of the server.. Plus they don't pay attention to constraints
+	-- anyway - so we're not really losing anything.
+
+	local MoveType = ent:GetMoveType()
+	if ( !ent:IsWorld() and MoveType != MOVETYPE_VPHYSICS and !( ent:GetModel() and ent:GetModel():StartsWith( "*" ) ) ) then return false end
+
+	local Phys = ent:GetPhysicsObjectNum( num )
+	return IsValid( Phys )
+
+end
+
+--[[---------------------------------------------------------
+	Name: GetPlayerTrace( ply, dir )
+	Desc: Returns a generic trace table for the player
+			(dir is optional, defaults to the player's aim)
+-----------------------------------------------------------]]
+function util.GetPlayerTrace( ply, dir )
+
+	dir = dir or ply:GetAimVector()
+
+	local trace = {}
+
+	trace.start = ply:EyePos()
+	trace.endpos = trace.start + ( dir * ( 4096 * 8 ) )
+	trace.filter = ply
+
+	return trace
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: QuickTrace( origin, offset, filter )
+	Desc: Quick trace
+-----------------------------------------------------------]]
+function util.QuickTrace( origin, dir, filter )
+
+	local trace = {}
+
+	trace.start = origin
+	trace.endpos = origin + dir
+	trace.filter = filter
+
+	return util.TraceLine( trace )
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: tobool( in )
+	Desc: Turn variable into bool
+-----------------------------------------------------------]]
+util.tobool = tobool
+
+
+--[[---------------------------------------------------------
+	Name: LocalToWorld( ent, lpos, bone )
+	Desc: Convert the local position on an entity to world pos
+-----------------------------------------------------------]]
+function util.LocalToWorld( ent, lpos, bone )
+
+	bone = bone or 0
+	if ( ent:EntIndex() == 0 ) then
+		return lpos
+	else
+		if ( IsValid( ent:GetPhysicsObjectNum( bone ) ) ) then
+			return ent:GetPhysicsObjectNum( bone ):LocalToWorld( lpos )
+		else
+			return ent:LocalToWorld( lpos )
+		end
+	end
+
+	return nil
+
+end
+
+
+--[[---------------------------------------------------------
+	Returns year, month, day and hour, minute, second in a formatted string.
+-----------------------------------------------------------]]
+function util.DateStamp()
+
+	local t = os.date( '*t' )
+	return t.year .. "-" .. t.month .. "-" .. t.day .. " " .. Format( "%02i-%02i-%02i", t.hour, t.min, t.sec )
+
+end
+
+--[[---------------------------------------------------------
+	Convert a string to a certain type
+-----------------------------------------------------------]]
+function util.StringToType( str, typename )
+
+	typename = typename:lower()
+
+	if ( typename == "vector" )	then return Vector( str ) end
+	if ( typename == "angle" )	then return Angle( str ) end
+	if ( typename == "float" || typename == "number" )	then return tonumber( str ) end
+	if ( typename == "int" )	then local v = tonumber( str ) return v and math.Round( v ) or nil end
+	if ( typename == "bool" || typename == "boolean" )	then return tobool( str ) end
+	if ( typename == "string" )	then return tostring( str ) end
+	if ( typename == "entity" )	then return Entity( str ) end
+
+	MsgN( "util.StringToType: unknown type \"", typename, "\"!" )
+
+end
+
+--
+-- Convert a type to a (nice, but still parsable) string
+--
+function util.TypeToString( v )
+
+	local iD = TypeID( v )
+
+	if ( iD == TYPE_VECTOR or iD == TYPE_ANGLE ) then
+		return string.format( "%.2f %.2f %.2f", v:Unpack() )
+	end
+
+	if ( iD == TYPE_NUMBER ) then
+		return util.NiceFloat( v )
+	end
+
+	return tostring( v )
+
+end
+
+
+--
+-- Formats a float by stripping off extra 0's and .'s
+--
+--	0.00	->		0
+--	0.10	->		0.1
+--	1.00	->		1
+--	1.49	->		1.49
+--	5.90	->		5.9
+--
+function util.NiceFloat( f )
+
+	local str = string.format( "%f", f )
+
+	str = str:TrimRight( "0" )
+	str = str:TrimRight( "." )
+
+	return str
+
+end
+
+
+
+--
+-- Timer
+--
+--
+local T =
+{
+	--
+	-- Resets the timer to nothing
+	--
+	Reset = function( self )
+
+		self.starttime = CurTime() - self.starttime
+		self.endtime = nil
+
+	end,
+
+	--
+	-- Starts the timer, call with end time
+	--
+	Start = function( self, time )
+
+		self.starttime = CurTime()
+		self.endtime = CurTime() + ( time or 0 )
+
+	end,
+
+	--
+	-- Returns true if the timer has been started
+	--
+	Started = function( self )
+
+		return self.endtime != nil
+
+	end,
+
+	--
+	-- Returns true if the time has elapsed
+	--
+	Elapsed = function( self )
+
+		return self.endtime == nil or self.endtime <= CurTime()
+
+	end,
+
+	--
+	-- Returns the amount of time that has passed since the Timer was started
+	--
+	GetElaspedTime = function( self )
+
+		return self:Started() and CurTime() - self.starttime or self.starttime
+
+	end
+}
+
+T.__index = T
+
+--
+-- Create a new timer object
+--
+function util.Timer( startdelay )
+
+	local t = {}
+	setmetatable( t, T )
+	t:Start( startdelay or 0 )
+	return t
+
+end
+
+local function PopStack( self, num )
+
+	if ( num == nil ) then
+		num = 1
+	elseif ( num < 0 ) then
+		error( string.format( "attempted to pop %d elements in stack, expected >= 0", num ), 3 )
+	else
+		num = math.floor( num )
+	end
+
+	local len = self[ 0 ]
+
+	if ( num > len ) then
+		error( string.format( "attempted to pop %u element%s in stack of length %u", num, num == 1 and "" or "s", len ), 3 )
+	end
+
+	return num, len
+
+end
+
+local STACK =
+{
+	Push = function( self, obj )
+		local len = self[ 0 ] + 1
+		self[ len ] = obj
+		self[ 0 ] = len
+	end,
+
+	Pop = function( self, num )
+		local len
+		num, len = PopStack( self, num )
+
+		if ( num == 0 ) then
+			return nil
+		end
+
+		local newlen = len - num
+		self[ 0 ] = newlen
+
+		newlen = newlen + 1
+		local ret = self[ newlen ]
+
+		-- Pop up to the last element
+		for i = len, newlen, -1 do
+			self[ i ] = nil
+		end
+
+		return ret
+	end,
+
+	PopMulti = function( self, num )
+		local len
+		num, len = PopStack( self, num )
+
+		if ( num == 0 ) then
+			return {}
+		end
+
+		local newlen = len - num
+		self[ 0 ] = newlen
+
+		local ret = {}
+		local retpos = 0
+
+		-- Pop each element and add it to the table
+		-- Iterate in reverse since the stack is internally stored
+		-- with 1 being the bottom element and len being the top
+		-- But the return will have 1 as the top element
+		for i = len, newlen + 1, -1 do
+			retpos = retpos + 1
+			ret[ retpos ] = self[ i ]
+
+			self[ i ] = nil
+		end
+
+		return ret
+	end,
+
+	Top = function( self )
+		local len = self[ 0 ]
+
+		if ( len == 0 ) then
+			return nil
+		end
+
+		return self[ len ]
+	end,
+
+	Size = function( self )
+		return self[ 0 ]
+	end
+}
+
+STACK.__index = STACK
+
+function util.Stack()
+	return setmetatable( { [ 0 ] = 0 }, STACK )
+end
+
+-- Helper for the following functions. This is not ideal but we cannot change this because it will break existing addons.
+local function GetUniqueID( sid )
+	return util.CRC( "gm_" .. sid .. "_gm" )
+end
+
+--[[---------------------------------------------------------
+	Name: GetPData( steamid, name, default )
+	Desc: Gets the persistant data from a player by steamid
+-----------------------------------------------------------]]
+function util.GetPData( steamid, name, default )
+
+	-- First try looking up using the new key
+	local key = Format( "%s[%s]", util.SteamIDTo64( steamid ), name )
+	local val = sql.QueryValue( "SELECT value FROM playerpdata WHERE infoid = " .. SQLStr( key ) .. " LIMIT 1" )
+	if ( val == nil ) then
+
+		-- Not found? Look using the old key
+		local oldkey = Format( "%s[%s]", GetUniqueID( steamid ), name )
+		val = sql.QueryValue( "SELECT value FROM playerpdata WHERE infoid = " .. SQLStr( oldkey ) .. " LIMIT 1" )
+		if ( val == nil ) then return default end
+
+	end
+
+	return val
+
+end
+
+--[[---------------------------------------------------------
+	Name: SetPData( steamid, name, value )
+	Desc: Sets the persistant data of a player by steamid
+-----------------------------------------------------------]]
+function util.SetPData( steamid, name, value )
+
+	local key = Format( "%s[%s]", util.SteamIDTo64( steamid ), name )
+	sql.Query( "REPLACE INTO playerpdata ( infoid, value ) VALUES ( " .. SQLStr( key ) .. ", " .. SQLStr( value ) .. " )" )
+
+end
+
+--[[---------------------------------------------------------
+	Name: RemovePData( steamid, name )
+	Desc: Removes the persistant data from a player by steamid
+-----------------------------------------------------------]]
+function util.RemovePData( steamid, name )
+
+	-- First the old key
+	local oldkey = Format( "%s[%s]", GetUniqueID( steamid ), name )
+	sql.Query( "DELETE FROM playerpdata WHERE infoid = " .. SQLStr( oldkey ) )
+
+	-- Then the new key. util.SteamIDTo64 is not ideal, but nothing we can do about it now
+	local key = Format( "%s[%s]", util.SteamIDTo64( steamid ), name )
+	sql.Query( "DELETE FROM playerpdata WHERE infoid = " .. SQLStr( key ) )
+
+end
+
+--[[---------------------------------------------------------
+	Name: IsBinaryModuleInstalled( name )
+	Desc: Returns whether a binary module with the given name is present on disk
+-----------------------------------------------------------]]
+local suffix = ( { "osx64", "osx", "linux64", "linux", "win64", "win32" } )[
+	( system.IsWindows() and 4 or 0 )
+	+ ( system.IsLinux() and 2 or 0 )
+	+ ( jit.arch == "x86" and 1 or 0 )
+	+ 1
+]
+local fmt = "lua/bin/gm" .. ( ( CLIENT and !MENU_DLL ) and "cl" or "sv" ) .. "_%s_%s.dll"
+function util.IsBinaryModuleInstalled( name )
+	if ( !isstring( name ) ) then
+		error( "bad argument #1 to 'IsBinaryModuleInstalled' (string expected, got " .. type( name ) .. ")", 2 )
+	elseif ( #name == 0 ) then
+		error( "bad argument #1 to 'IsBinaryModuleInstalled' (string cannot be empty)", 2 )
+	end
+
+	if ( file.Exists( string.format( fmt, name, suffix ), "MOD" ) ) then
+		return true
+	end
+
+	-- Edge case - on Linux 32-bit x86-64 branch, linux32 is also supported as a suffix
+	if ( jit.versionnum != 20004 and jit.arch == "x86" and system.IsLinux() ) then
+		return file.Exists( string.format( fmt, name, "linux32" ), "MOD" )
+	end
+
+	return false
+end

lua/includes/extensions/util/worldpicker.lua

@@ -0,0 +1,56 @@
+--
+--
+-- worldpicker is for picking an entity from the game while you have the GUI open.
+-- Calling util.worldpicker.Start( func ) will hide all GUI and let you pick an entity from
+-- the game world. Once selected it will call your passed function with the trace.
+--
+-- It's used in the icon editor
+--
+--
+
+local bDoing = false
+local fnAction = nil
+
+util.worldpicker = {
+	--
+	-- Start world picking
+	--
+	Start = function( func )
+
+		bDoing = true
+		fnAction = func
+		gui.EnableScreenClicker( true )
+
+	end,
+
+	--
+	-- Finish world picking - you shouldn't have to call this (called from hook below)
+	--
+	Finish = function( tr )
+
+		bDoing = false
+		fnAction( tr )
+		gui.EnableScreenClicker( false )
+
+	end,
+
+	Active = function() return bDoing end
+}
+
+hook.Add( "VGUIMousePressAllowed", "WorldPickerMouseDisable", function( code )
+
+	if ( !bDoing ) then return end
+
+	local dir = gui.ScreenToVector( input.GetCursorPos() )
+	local tr = util.TraceLine( {
+		start = LocalPlayer():GetShootPos(),
+		endpos = LocalPlayer():GetShootPos() + dir * 32768,
+		filter = LocalPlayer()
+	} )
+
+	util.worldpicker.Finish( tr )
+
+	-- Don't register this click
+	return true
+
+end )

lua/includes/extensions/vector.lua

@@ -0,0 +1,12 @@
+local meta = FindMetaTable( "Vector" )
+
+-- Nothing in here, still leaving this file here just in case
+
+--[[---------------------------------------------------------
+	Converts Vector To Color - alpha precision lost, must reset
+-----------------------------------------------------------]]
+function meta:ToColor( )
+
+	return Color( self.x * 255, self.y * 255, self.z * 255 )
+
+end

lua/includes/extensions/weapon.lua

@@ -0,0 +1,45 @@
+
+AddCSLuaFile()
+
+local meta		= FindMetaTable( "Weapon" )
+local entity	= FindMetaTable( "Entity" )
+
+-- Return if there's nothing to add on to
+if ( !meta ) then return end
+
+--
+-- Entity index accessor. This used to be done in engine, but it's done in Lua now because it's faster
+--
+function meta:__index( key )
+
+	--
+	-- Search the metatable. We can do this without dipping into C, so we do it first.
+	--
+	local val = meta[key]
+	if ( val != nil ) then return val end
+
+	--
+	-- Search the entity metatable
+	--
+	local val = entity[key]
+	if ( val != nil ) then return val end
+
+	--
+	-- Search the entity table
+	--
+	local tab = entity.GetTable( self )
+	if ( tab != nil ) then
+		local val = tab[ key ]
+		if ( val != nil ) then return val end
+	end
+
+	--
+	-- Legacy: sometimes use self.Owner to get the owner.. so lets carry on supporting that stupidness
+	-- This needs to be retired, just like self.Entity was.
+	--
+	if ( key == "Owner" ) then return entity.GetOwner( self ) end
+	
+	return nil
+	
+end
+

lua/includes/gmsave.lua

@@ -0,0 +1,115 @@
+
+gmsave = {}
+
+if ( CLIENT ) then return end
+
+include( "gmsave/entity_filters.lua" )
+include( "gmsave/player.lua" )
+
+local g_WavSound = 1
+
+function gmsave.LoadMap( strMapContents, ply, callback )
+
+	-- TODO: Do this in engine before sending it to this function.
+
+	-- Strip off any crap before the start char..
+	local startchar = string.find( strMapContents, '' )
+	if ( startchar != nil ) then
+		strMapContents = string.sub( strMapContents, startchar )
+	end
+
+	-- Strip off any crap after the end char..
+	strMapContents = strMapContents:reverse()
+	local startchar = string.find( strMapContents, '
' )
+	if ( startchar != nil ) then
+		strMapContents = string.sub( strMapContents, startchar )
+	end
+	strMapContents = strMapContents:reverse()
+
+	-- END TODO
+
+	local tab = util.JSONToTable( strMapContents )
+
+	if ( !istable( tab ) ) then
+		-- Error loading save!
+		MsgN( "gm_load: Couldn't decode from json!" )
+		return false
+	end
+
+	-- Existing addons are forcing us to do this
+	-- The issue is that some addons overwrite game.CleanUpMap
+	-- Making the 3rd argument not exist
+	hook.Add( "PostCleanupMap", "GMod_Load_Save", function()
+		hook.Remove( "PostCleanupMap", "GMod_Load_Save" )
+
+		if ( IsValid( ply ) ) then
+
+			ply:SendLua( "hook.Run( \"OnSpawnMenuClose\" )" )
+
+			g_WavSound = g_WavSound + 1
+			if ( g_WavSound > 4 ) then g_WavSound = 1 end
+
+			ply:SendLua( string.format( "surface.PlaySound( \"garrysmod/save_load%d.wav\" )", g_WavSound ) )
+
+			gmsave.PlayerLoad( ply, tab.Player )
+
+		end
+
+		timer.Simple( 0.1, function()
+
+			DisablePropCreateEffect = true
+			duplicator.RemoveMapCreatedEntities()
+			duplicator.Paste( ply, tab.Entities, tab.Constraints )
+			DisablePropCreateEffect = nil
+
+			if ( IsValid( ply ) ) then
+				gmsave.PlayerLoad( ply, tab.Player )
+			end
+
+			-- Since this save system is inferior to Source's, we gotta make sure this entity is disabled on load of a save
+			-- On maps like Portal's testchmb_a_00.bsp this entity takes away player control and will not restore it
+			-- if the player is not in a very specific place.
+			timer.Simple( 1, function()
+				for id, ent in ipairs( ents.FindByClass( "point_viewcontrol" ) ) do
+					ent:Fire( "Disable" )
+				end
+			end )
+
+			if ( callback ) then callback() end
+
+		end )
+	end )
+
+	game.CleanUpMap( false, nil, function() end )
+
+end
+
+function gmsave.SaveMap( ply )
+
+	local Ents = ents.GetAll()
+
+	for k, v in ipairs( Ents ) do
+
+		if ( !gmsave.ShouldSaveEntity( v, v:GetSaveTable() ) || v:IsConstraint() ) then
+			Ents[ k ] = nil
+		end
+
+	end
+
+	-- This is to copy the constraints that are applied to the world only (ropes, etc)
+	-- It will not actually save and then try to restore the world entity, as that would cause issues
+	table.insert( Ents, game.GetWorld() )
+
+	local tab = duplicator.CopyEnts( Ents )
+	if ( !tab ) then return end
+
+	tab.Player = gmsave.PlayerSave( ply )
+
+	--
+	-- Try to figure out if any of the models/materials/etc came from some addon
+	--
+	duplicator.FigureOutRequiredAddons( tab )
+
+	return util.TableToJSON( tab )
+
+end

lua/includes/gmsave/entity_filters.lua

@@ -0,0 +1,84 @@
+
+local ClassInfo = {} 
+
+ClassInfo[ "scene_manager" ]				= { ['save'] = false }
+ClassInfo[ "predicted_viewmodel" ]			= { ['save'] = false }
+ClassInfo[ "player" ]						= { ['save'] = false }
+ClassInfo[ "physgun_beam" ]					= { ['save'] = false }
+ClassInfo[ "worldspawn" ]					= { ['save'] = false }
+ClassInfo[ "player_manager" ]				= { ['save'] = false }
+ClassInfo[ "bodyque" ]						= { ['save'] = false }
+ClassInfo[ "info_player_start" ]			= { ['save'] = false }
+ClassInfo[ "ai_hint" ]						= { ['save'] = false }
+ClassInfo[ "ai_network" ]					= { ['save'] = false }
+ClassInfo[ "light" ]						= { ['save'] = false }
+ClassInfo[ "ai_network" ]					= { ['save'] = false }
+ClassInfo[ "env_tonemap_controller" ]		= { ['save'] = false }
+ClassInfo[ "path_corner" ]					= { ['save'] = false }
+ClassInfo[ "point_spotlight" ]				= { ['save'] = false }
+ClassInfo[ "func_brush" ]					= { ['save'] = false }
+ClassInfo[ "water_lod_control" ]			= { ['save'] = false }
+ClassInfo[ "spotlight_end" ]				= { ['save'] = false }
+ClassInfo[ "beam" ]							= { ['save'] = false }
+ClassInfo[ "lua_run" ]						= { ['save'] = false }
+ClassInfo[ "trigger_multiple" ]				= { ['save'] = false }
+ClassInfo[ "func_button" ]					= { ['save'] = false }
+ClassInfo[ "soundent" ]						= { ['save'] = false }
+ClassInfo[ "sky_camera" ]					= { ['save'] = false }
+ClassInfo[ "env_fog_controller" ]			= { ['save'] = false }
+ClassInfo[ "env_sun" ]						= { ['save'] = false }
+ClassInfo[ "phys_constraintsystem" ]		= { ['save'] = false }
+ClassInfo[ "keyframe_rope" ]				= { ['save'] = false }
+ClassInfo[ "logic_auto" ]					= { ['save'] = false }
+ClassInfo[ "physics_npc_solver" ]			= { ['save'] = false }
+ClassInfo[ "env_sun" ]						= { ['save'] = false }
+ClassInfo[ "env_wind" ]						= { ['save'] = false }
+ClassInfo[ "env_fog_controller" ]			= { ['save'] = false }
+ClassInfo[ "infodecal" ]					= { ['save'] = false }
+ClassInfo[ "info_projecteddecal" ]			= { ['save'] = false }
+ClassInfo[ "info_node" ]					= { ['save'] = false }
+ClassInfo[ "info_map_parameters" ]			= { ['save'] = false }
+ClassInfo[ "info_ladder" ]					= { ['save'] = false }
+ClassInfo[ "path_corner" ]					= { ['save'] = false }
+ClassInfo[ "point_viewcontrol" ]			= { ['save'] = false }
+ClassInfo[ "scene_manager" ]				= { ['save'] = false }
+ClassInfo[ "shadow_control" ]				= { ['save'] = false }
+ClassInfo[ "sky_camera" ]					= { ['save'] = false }
+ClassInfo[ "soundent" ]						= { ['save'] = false }
+
+function gmsave.ShouldSaveEntity( ent, t )
+
+	local info = ClassInfo[ t.classname ]
+
+	--
+	-- Filtered out - we don't want to save these entity types!
+	--
+	if ( info && info.save == false ) then return false end
+
+	--
+	-- Should we save the parent entity?
+	-- If not, don't save this!
+	--
+	local parent = ent:GetParent()
+	if ( IsValid( parent ) ) then
+		if ( !gmsave.ShouldSaveEntity( parent, parent:GetSaveTable() ) ) then return false end
+	end
+
+	--
+	-- If this is a weapon, and it has a valid owner.. don't save it!
+	--
+	if ( ent:IsWeapon() && IsValid( ent:GetOwner() ) ) then
+		return false
+	end
+
+	-- Do not save entities that do not want to be saved
+	if ( ent.DoNotDuplicate ) then
+		return false
+	end
+
+	--
+	-- Default action is to save..
+	--
+	return true
+
+end

lua/includes/gmsave/physics.lua

@@ -0,0 +1,96 @@
+
+--
+-- Creates a save table for a single entity
+--
+function gmsave.PhysicsSave( ent )
+
+	if ( ent:GetPhysicsObjectCount() == 0 ) then return end
+
+	local tab = {}
+
+	for k = 0, ent:GetPhysicsObjectCount() - 1 do
+
+		local obj = ent:GetPhysicsObjectNum( k )
+
+		tab[ k ] = {}
+		tab[ k ].origin = tostring( obj:GetPos() )
+		tab[ k ].angles = tostring( obj:GetAngles() )
+		tab[ k ].mass = tostring( obj:GetMass() )
+		tab[ k ].material = tostring( obj:GetMaterial() )
+		if ( !obj:IsMotionEnabled() ) then tab[ k ].frozen = 1 end
+		if ( !obj:IsCollisionEnabled() ) then tab[ k ].nocollide = 1 end
+		if ( !obj:IsGravityEnabled() ) then tab[ k ].nogravity = 1 end
+		if ( !obj:IsDragEnabled() ) then tab[ k ].nodrag = 1 end
+
+	end
+
+	return tab
+
+end
+
+--
+-- Creates a save table from a table of entities
+--
+function gmsave.PhysicsSaveList( ents )
+
+	local tabPhys = {}
+
+	for k, v in pairs( ents ) do
+
+		if ( !IsValid( v ) ) then continue end
+
+		tabPhys[ v.GMSaveName ] = gmsave.PhysicsSave( v )
+		if ( tabPhys[ v.GMSaveName ] ) then
+			tabPhys[ v.GMSaveName ].entity = v.GMSaveName
+		end
+
+	end
+
+	return tabPhys
+
+end
+
+--
+-- Creates a single entity from a table
+--
+function gmsave.PhysicsLoad( t, ent )
+
+	for k = 0, ent:GetPhysicsObjectCount() - 1 do
+
+		local tab = t[ k ]
+		if ( !tab ) then continue end
+
+		local obj = ent:GetPhysicsObjectNum( k )
+		if ( !IsValid( obj ) ) then continue end
+
+		obj:SetPos( Vector( tab.origin ) )
+		obj:SetAngles( Angle( tab.angles ) )
+		obj:SetMass( tab.mass )
+		obj:SetMaterial( tab.material )
+
+		if ( tab.frozen ) then obj:EnableMotion( false ) end
+		if ( tab.nocollide ) then obj:EnableCollisions( false ) end
+		if ( tab.nogravity ) then obj:EnableGravity( false ) end
+		if ( tab.nodrag ) then obj:EnableDrag( false ) end
+
+	end
+
+end
+
+--
+-- Restores multiple entitys from a table
+--
+function gmsave.PhysicsLoadFromTable( tab, ents )
+
+	if ( !tab ) then return end
+
+	for k, v in pairs( tab ) do
+
+		local ent = ents[ k ]
+		if ( !IsValid( ent ) ) then continue end
+
+		gmsave.PhysicsLoad( v, ent )
+
+	end
+
+end

lua/includes/gmsave/player.lua

@@ -0,0 +1,22 @@
+
+function gmsave.PlayerSave( ent )
+
+	local tab = {}
+
+	tab.Origin = ent:GetPos()
+	tab.Angle = ent:GetAimVector():Angle()
+	tab.MoveType = ent:GetMoveType()
+
+	return tab
+
+end
+
+function gmsave.PlayerLoad( ent, tab )
+
+	if ( tab == nil ) then return end
+
+	if ( tab.Origin ) then ent:SetPos( tab.Origin ) end
+	if ( tab.Angle ) then ent:SetEyeAngles( tab.Angle ) end
+	if ( tab.MoveType ) then ent:SetMoveType( tab.MoveType ) end
+
+end

lua/includes/gui/icon_progress.lua

@@ -0,0 +1,57 @@
+
+local g_Progress = nil
+
+hook.Add( "SpawniconGenerated", "SpawniconGenerated", function( lastmodel, imagename, modelsleft )
+
+	if ( !IsValid( g_Progress ) ) then
+
+		g_Progress = vgui.Create( "DPanel" )
+		g_Progress:SetSize( 64 + 10, 64 + 10 + 20 )
+		g_Progress:SetBackgroundColor( Color( 0, 0, 0, 100 ) )
+		g_Progress:SetDrawOnTop( true )
+		g_Progress:DockPadding( 5, 0, 5, 5 )
+		g_Progress.Think = function()
+
+			if ( SysTime() - g_Progress.LastTouch < 3 ) then return end
+
+			g_Progress:Remove()
+			g_Progress.LastTouch = SysTime()
+
+		end
+
+		local label = g_Progress:Add( "DLabel" )
+		label:Dock( BOTTOM )
+		label:SetText( "remaining" )
+		label:SetTextColor( color_white )
+		label:SetExpensiveShadow( 1, Color( 0, 0, 0, 200 ) )
+		label:SetContentAlignment( 5 )
+		label:SetHeight( 14 )
+		label:SetFont( "DefaultSmall" )
+
+		g_Progress.Label = g_Progress:Add( "DLabel" )
+		g_Progress.Label:Dock( BOTTOM )
+		g_Progress.Label:SetTextColor( color_white )
+		g_Progress.Label:SetExpensiveShadow( 1, Color( 0, 0, 0, 200 ) )
+		g_Progress.Label:SetContentAlignment( 5 )
+		g_Progress.Label:SetFont( "DermaDefaultBold" )
+		g_Progress.Label:SetHeight( 14 )
+
+		g_Progress.icon = vgui.Create( "DImage", g_Progress )
+		g_Progress.icon:SetSize( 64, 64 )
+		g_Progress.icon:Dock( TOP )
+
+	end
+
+	g_Progress.LastTouch = SysTime()
+
+	imagename = imagename:Replace( "materials\\", "" )
+	imagename = imagename:Replace( "materials/", "" )
+
+	g_Progress.icon:SetImage( imagename )
+
+	g_Progress:AlignRight( 10 )
+	g_Progress:AlignBottom( 10 )
+
+	g_Progress.Label:SetText( modelsleft )
+
+end )

lua/includes/init.lua

@@ -0,0 +1,124 @@
+
+--[[---------------------------------------------------------
+	Non-Module includes
+-----------------------------------------------------------]]
+
+include( "util.lua" )			-- Misc Utilities
+include( "util/sql.lua" )		-- Includ sql here so it's available at loadtime to modules.
+
+include( "extensions/net.lua" )
+
+--[[---------------------------------------------------------
+	Shared Modules
+-----------------------------------------------------------]]
+
+require( "baseclass" )
+require( "concommand" )			-- Console Commands
+require( "saverestore" )		-- Save/Restore
+require( "hook" )				-- Gamemode hooks
+require( "gamemode" )			-- Gamemode manager
+require( "weapons" )			-- SWEP manager
+require( "scripted_ents" )		-- Scripted Entities
+require( "player_manager" )		-- Player models/class manager
+require( "numpad" )
+require( "team" )
+require( "undo" )
+require( "cleanup" )
+require( "duplicator" )
+require( "constraint" )
+require( "construct" )
+require( "usermessage" )
+require( "list" )
+require( "cvars" )
+require( "http" )
+require( "properties" )
+require( "widget" )
+require( "cookie" )
+require( "utf8" )
+
+require( "drive" )
+include( "drive/drive_base.lua" )
+include( "drive/drive_noclip.lua" )
+
+--[[---------------------------------------------------------
+	Serverside only modules
+-----------------------------------------------------------]]
+
+if ( SERVER ) then
+
+	require( "ai_task" )
+	require( "ai_schedule" )
+
+end
+
+
+--[[---------------------------------------------------------
+	Clientside only modules
+-----------------------------------------------------------]]
+
+if ( CLIENT ) then
+
+	require( "draw" )		-- 2D Draw library
+	require( "markup" )		-- Text markup library
+	require( "effects" )
+	require( "halo" )
+	require( "killicon" )
+	require( "spawnmenu" )
+	require( "controlpanel" )
+	require( "presets" )
+	require( "menubar" )
+	require( "matproxy" )
+
+	include( "util/model_database.lua" )	-- Store information on models as they're loaded
+	include( "util/vgui_showlayout.lua" ) 	-- VGUI Performance Debug
+	include( "util/tooltips.lua" )
+	include( "util/client.lua" )
+	include( "util/javascript_util.lua" )
+	include( "util/workshop_files.lua" )
+	include( "gui/icon_progress.lua" )
+
+end
+
+
+--[[---------------------------------------------------------
+	Shared modules
+-----------------------------------------------------------]]
+include( "gmsave.lua" )
+
+--[[---------------------------------------------------------
+	Extensions
+
+	Load extensions that we specifically need for the menu,
+	to reduce the chances of loading something that might
+	cause errors.
+-----------------------------------------------------------]]
+
+include( "extensions/entity_iter.lua" )
+include( "extensions/file.lua" )
+include( "extensions/angle.lua" )
+include( "extensions/debug.lua" )
+include( "extensions/entity.lua" )
+include( "extensions/ents.lua" )
+include( "extensions/math.lua" )
+include( "extensions/player.lua" )
+include( "extensions/player_auth.lua" )
+include( "extensions/string.lua" )
+include( "extensions/table.lua" )
+include( "extensions/util.lua" )
+include( "extensions/vector.lua" )
+include( "extensions/game.lua" )
+include( "extensions/motionsensor.lua" )
+include( "extensions/weapon.lua" )
+include( "extensions/coroutine.lua" )
+
+if ( CLIENT ) then
+
+	include( "extensions/client/entity.lua" )
+	include( "extensions/client/globals.lua" )
+	include( "extensions/client/panel.lua" )
+	include( "extensions/client/player.lua" )
+	include( "extensions/client/render.lua" )
+
+	require( "search" )
+
+end

lua/includes/init_menu.lua

@@ -0,0 +1,45 @@
+
+--[[---------------------------------------------------------
+	Non-Module includes
+-----------------------------------------------------------]]
+include( "util.lua" )
+include( "util/sql.lua" ) -- Include sql here so it's available at loadtime to modules.
+
+
+--[[---------------------------------------------------------
+	Modules
+-----------------------------------------------------------]]
+require( "concommand" )
+require( "list" )
+require( "hook" )
+require( "draw" )
+require( "http" )
+require( "cvars" )
+require( "cookie" )
+require( "baseclass" )
+require( "utf8" )
+require( "markup" )
+
+--[[---------------------------------------------------------
+	Extensions
+
+	Load extensions that we specifically need for the menu,
+	to reduce the chances of loading something that might
+	cause errors.
+-----------------------------------------------------------]]
+include( "extensions/string.lua" )
+include( "extensions/table.lua" )
+include( "extensions/math.lua" )
+include( "extensions/client/panel.lua" )
+include( "extensions/util.lua" )
+include( "extensions/file.lua" )
+include( "extensions/debug.lua" )
+include( "extensions/client/render.lua" )
+include( "extensions/client/globals.lua" )
+
+include( "util/vgui_showlayout.lua" )
+include( "util/workshop_files.lua" )
+include( "util/javascript_util.lua" )
+include( "util/tooltips.lua" )
+
+include( "menu/derma_icon_browser.lua" )

lua/includes/menu.lua

@@ -0,0 +1,9 @@
+--=============================================================================--
+--  ___  ___   _   _   _    __   _   ___ ___ __ __
+-- |_ _|| __| / \ | \_/ |  / _| / \ | o \ o \\ V /
+--  | | | _| | o || \_/ | ( |_n| o ||   /   / \ / 
+--  |_| |___||_n_||_| |_|  \__/|_n_||_|\\_|\\ |_|  2007
+--										 
+--=============================================================================--
+
+include( "menu/menu.lua" )

lua/includes/modules/ai_schedule.lua

@@ -0,0 +1,98 @@
+
+-- Serverside only.
+if ( CLIENT ) then return end
+
+local setmetatable	= setmetatable
+local tostring		= tostring
+local table			= table
+local ai_task		= ai_task
+
+module( "ai_schedule" )
+
+-- Define the Schedule object
+
+local Schedule = {}
+Schedule.__index = Schedule
+
+--[[---------------------------------------------------------
+	Name: Init
+	Sets the object up. Called automatically from ai_schedule.new.
+-----------------------------------------------------------]]
+function Schedule:Init( _debugname_ )
+
+	self.DebugName	= tostring( _debugname_ )
+	self.Tasks		= {}
+	self.TaskCount	= 0
+
+end
+
+--[[---------------------------------------------------------
+
+	Adds an engine task to the schedule
+
+	schd:EngTask( "TASK_TARGET_PLAYER", 0 )
+
+-----------------------------------------------------------]]
+function Schedule:EngTask( _taskname_, _taskdata_ )
+
+	local NewTask = ai_task.New()
+	NewTask:InitEngine( _taskname_, _taskdata_ )
+	self.TaskCount = table.insert( self.Tasks, NewTask )
+
+end
+
+--[[---------------------------------------------------------
+
+	Adds Lua NPC task to the schedule
+
+	schdChase:AddTask( "LookForPlayer", "AnyDataYouWant" )
+
+	will call the functions
+
+	NPC:TaskStart_LookForPlayer( "AnyDataYouWant" )	- once on start
+	NPC:Task_LookForPlayer( "AnyDataYouWant" ) 		- every think until TaskComplete
+
+-----------------------------------------------------------]]
+function Schedule:AddTask( _functionname_, _data_ )
+
+	local NewTask = ai_task.New()
+	NewTask:InitFunctionName( "TaskStart_" .. _functionname_, "Task_" .. _functionname_, _data_ )
+	self.TaskCount = table.insert( self.Tasks, NewTask )
+
+end
+
+--[[---------------------------------------------------------
+
+	The same as above but you get to specify the exact
+		function name to call
+
+-----------------------------------------------------------]]
+function Schedule:AddTaskEx( _start, _run, _data_ )
+
+	local NewTask = ai_task.New()
+	NewTask:InitFunctionName( _start, _run, _data_ )
+	self.TaskCount = table.insert( self.Tasks, NewTask )
+
+end
+
+function Schedule:NumTasks()
+	return self.TaskCount
+end
+
+function Schedule:GetTask( num )
+	return self.Tasks[ num ]
+end
+
+--[[---------------------------------------------------------
+	Create a new empty task (this is ai_schedule.New )
+-----------------------------------------------------------]]
+function New( debugname )
+
+	local pNewSchedule = {}
+	setmetatable( pNewSchedule, Schedule )
+
+	pNewSchedule:Init( debugname )
+
+	return pNewSchedule
+
+end

lua/includes/modules/ai_task.lua

@@ -0,0 +1,123 @@
+
+-- Serverside only.
+if ( CLIENT ) then return end
+
+local setmetatable	= setmetatable
+--local table			= table
+local ai			= ai
+
+module( "ai_task" )
+
+--[[---------------------------------------------------------
+	ENUMs for which kind of task it is.
+-----------------------------------------------------------]]
+local TYPE_ENGINE	= 1
+local TYPE_FNAME	= 2
+
+--[[---------------------------------------------------------
+	Keep track of created tasks
+	UNDONE: There's no need for this right now.
+-----------------------------------------------------------]]
+--local Task_Index = {}
+
+--[[---------------------------------------------------------
+	Task metatable
+-----------------------------------------------------------]]
+local Task = {}
+Task.__index = Task
+
+function Task:Init()
+	self.Type = nil
+end
+
+--[[---------------------------------------------------------
+	Creates an engine based task
+-----------------------------------------------------------]]
+function Task:InitEngine( _taskname_, _taskdata_ )
+
+	self.TaskName	= _taskname_
+	self.TaskID		= nil
+	self.TaskData	= _taskdata_
+	self.Type		= TYPE_ENGINE
+
+end
+
+--[[---------------------------------------------------------
+	Creates an engine based task
+-----------------------------------------------------------]]
+function Task:InitFunctionName( _start, _end, _taskdata_ )
+	self.StartFunctionName	= _start
+	self.FunctionName		= _end
+	self.TaskData			= _taskdata_
+	self.Type				= TYPE_FNAME
+end
+
+function Task:IsEngineType()
+	return ( self.Type == TYPE_ENGINE )
+end
+
+function Task:IsFNameType()
+	return ( self.Type == TYPE_FNAME )
+end
+
+function Task:Start( npc )
+
+	if ( self:IsFNameType() ) then self:Start_FName( npc ) return end
+
+	if ( self:IsEngineType() ) then
+
+		if ( !self.TaskID ) then self.TaskID = ai.GetTaskID( self.TaskName ) end
+
+		npc:StartEngineTask( self.TaskID, self.TaskData )
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Start_FName (called from Task:Start)
+-----------------------------------------------------------]]
+function Task:Start_FName( npc )
+
+	if ( !self.StartFunctionName ) then return end
+	--if ( !npc[ self.StartFunctionName ] ) then return end
+
+	-- Run the start function. Safely.
+	npc[ self.StartFunctionName ]( npc, self.TaskData )
+
+end
+
+function Task:Run( npc )
+
+	if ( self:IsFNameType() ) then self:Run_FName( npc ) return end
+
+	if ( self:IsEngineType() ) then
+		npc:RunEngineTask( self.TaskID, self.TaskData )
+	end
+
+end
+
+function Task:Run_FName( npc )
+
+	if ( !self.FunctionName ) then return end
+	--if (!npc[ self.StartFunctionName ]) then return end
+
+	-- Run the start function. Safely.
+	npc[ self.FunctionName ]( npc, self.TaskData )
+
+end
+
+--[[---------------------------------------------------------
+	Create a new empty task (this is ai_task.New )
+-----------------------------------------------------------]]
+function New()
+
+	local pNewTask = {}
+	setmetatable( pNewTask, Task )
+
+	pNewTask:Init()
+
+	--table.insert( Task_Index, pNewTask )
+
+	return pNewTask
+
+end

lua/includes/modules/baseclass.lua

@@ -0,0 +1,58 @@
+
+
+--
+-- The baseclass module uses upvalues to give the impression of inheritence.
+--
+-- At the top of your class file add 
+--
+-- DEFINE_BASECLASS( "base_class_name" )
+--
+-- Now the local variable BaseClass will be available.
+-- ( in engine DEFINE_BASECLASS is replaced with "local BaseClass = baseclass.Get" )
+--
+-- Baseclasses are added using baseclass.Set - this is done automatically for:
+--
+--		> widgets
+--		> panels
+--		> drive modes
+--		> entities
+--		> weapons
+-- 
+-- Classes don't have to be created in any particular order. The system is 
+-- designed to work with whatever order the classes are defined.
+--
+-- The only caveat is that classnames must be unique. 
+-- eg Creating a panel and widget with the same name will cause problems.
+--
+
+module( "baseclass", package.seeall )
+
+local BaseClassTable = {}
+
+function Get( name )
+
+	if ( ENT )	then ENT.Base = name end
+	if ( SWEP ) then SWEP.Base = name end
+	
+	BaseClassTable[name] = BaseClassTable[name] or {}
+	
+	return BaseClassTable[name]
+	
+end
+
+function Set( name, tab )
+
+	if ( !BaseClassTable[name] ) then
+
+		BaseClassTable[name] =  tab
+
+	else
+
+		table.Merge( BaseClassTable[name], tab )
+		setmetatable( BaseClassTable[name], getmetatable(tab) )
+
+	end
+
+	BaseClassTable[name].ThisClass = name
+
+end

lua/includes/modules/cleanup.lua

@@ -0,0 +1,241 @@
+
+module( "cleanup", package.seeall )
+
+local cleanup_types = {}
+
+local function IsType( type )
+
+	for key, val in pairs( cleanup_types ) do
+
+		if ( val == type ) then return true end
+
+	end
+
+	return false
+
+end
+
+function Register( type )
+
+	if ( type == "all" ) then return end
+
+	for key, val in pairs( cleanup_types ) do
+
+		if val == type then return end
+
+	end
+
+	table.insert( cleanup_types, type )
+
+end
+
+function GetTable()
+	return cleanup_types
+end
+
+
+if ( SERVER ) then
+
+	local cleanup_list = {}
+
+	function GetList()
+		return cleanup_list
+	end
+
+	local function Save( save )
+
+		saverestore.WriteTable( cleanup_list, save )
+
+	end
+
+	local function Restore( restore )
+
+		cleanup_list = saverestore.ReadTable( restore )
+
+	end
+
+	saverestore.AddSaveHook( "CleanupTable", Save )
+	saverestore.AddRestoreHook( "CleanupTable", Restore )
+
+	function Add( pl, type, ent )
+
+		if ( !ent ) then return end
+
+		if ( !IsType( type ) ) then return end
+
+		local id = pl:UniqueID()
+
+		cleanup_list[ id ] = cleanup_list[ id ] or {}
+		cleanup_list[ id ][ type ] = cleanup_list[ id ][ type ] or {}
+
+		if ( !IsValid( ent ) ) then return end
+
+		table.insert( cleanup_list[ id ][ type ], ent )
+
+	end
+
+	function ReplaceEntity( from, to )
+
+		local ActionTaken = false
+
+		for _, PlayerTable in pairs( cleanup_list ) do
+			for _, TypeTable in pairs( PlayerTable ) do
+				for key, ent in pairs( TypeTable ) do
+
+					if ( ent == from ) then
+						TypeTable[ key ] = to
+						ActionTaken = true
+					end
+
+				end
+			end
+		end
+
+		return ActionTaken
+
+	end
+
+
+	function CC_Cleanup( pl, command, args )
+
+		if ( !IsValid( pl ) ) then return end
+
+		local id = pl:UniqueID()
+
+		if ( !cleanup_list[ id ] ) then return end
+
+		if ( !args[ 1 ] ) then
+
+			local count = 0
+
+			for key, val in pairs( cleanup_list[ id ] ) do
+
+				for _, ent in pairs( val ) do
+
+					if ( IsValid( ent ) ) then ent:Remove() end
+					count = count + 1
+
+				end
+
+				table.Empty( val )
+
+			end
+
+			-- Send tooltip command to client
+			if ( count > 0 ) then
+				pl:SendLua( "hook.Run('OnCleanup','all')" )
+			end
+
+			return
+
+		end
+
+		if ( !IsType( args[1] ) ) then return end
+		if ( !cleanup_list[id][ args[1] ] ) then return end
+
+		for key, ent in pairs( cleanup_list[id][ args[1] ] ) do
+
+			if ( IsValid( ent ) ) then ent:Remove() end
+
+		end
+
+		table.Empty( cleanup_list[id][ args[1] ] )
+
+		-- Send tooltip command to client
+		pl:SendLua( string.format( "hook.Run('OnCleanup',%q)", args[1] ) )
+
+	end
+
+	function CC_AdminCleanup( pl, command, args )
+
+		if ( IsValid( pl ) && !pl:IsAdmin() ) then return end
+
+		if ( !args[ 1 ] ) then
+
+			for key, ply in pairs( cleanup_list ) do
+
+				for _, type in pairs( ply ) do
+
+					for __, ent in pairs( type ) do
+
+						if ( IsValid( ent ) ) then ent:Remove() end
+
+					end
+
+					table.Empty( type )
+
+				end
+
+			end
+
+			game.CleanUpMap( false, nil, function()
+				-- Send tooltip command to client
+				if ( IsValid( pl ) ) then pl:SendLua( "hook.Run('OnCleanup','all')" ) end
+			end )
+
+			return
+
+		end
+
+		if ( !IsType( args[ 1 ] ) ) then return end
+
+		for key, ply in pairs( cleanup_list ) do
+
+			if ( ply[ args[ 1 ] ] != nil ) then
+
+				for id, ent in pairs( ply[ args[ 1 ] ] ) do
+
+					if ( IsValid( ent ) ) then ent:Remove() end
+
+				end
+
+				table.Empty( ply[ args[ 1 ] ] )
+
+			end
+
+		end
+
+		-- Send tooltip command to client
+		if ( IsValid( pl ) ) then pl:SendLua( string.format( "hook.Run('OnCleanup',%q)", args[1] ) ) end
+
+	end
+
+	concommand.Add( "gmod_cleanup", CC_Cleanup, nil, "", { FCVAR_DONTRECORD } )
+	concommand.Add( "gmod_admin_cleanup", CC_AdminCleanup, nil, "", { FCVAR_DONTRECORD } )
+
+else
+
+	function UpdateUI()
+
+		local cleanup_types_s = {}
+		for id, val in pairs( cleanup_types ) do
+			cleanup_types_s[ language.GetPhrase( "Cleanup_" .. val ) ] = val
+		end
+
+		local Panel = controlpanel.Get( "User_Cleanup" )
+		if ( IsValid( Panel ) ) then
+			Panel:Clear()
+			Panel:Help( "#spawnmenu.utilities.cleanup.help" )
+			Panel:Button( "#spawnmenu.utilities.cleanup.all", "gmod_cleanup" )
+
+			for key, val in SortedPairs( cleanup_types_s ) do
+				Panel:Button( key, "gmod_cleanup", val )
+			end
+		end
+
+		local AdminPanel = controlpanel.Get( "Admin_Cleanup" )
+		if ( IsValid( AdminPanel ) ) then
+			AdminPanel:Clear()
+			AdminPanel:Help( "#spawnmenu.utilities.cleanup.help" )
+			AdminPanel:Button( "#spawnmenu.utilities.cleanup.all", "gmod_admin_cleanup" )
+
+			for key, val in SortedPairs( cleanup_types_s ) do
+				AdminPanel:Button( key, "gmod_admin_cleanup", val )
+			end
+		end
+
+	end
+
+	hook.Add( "PostReloadToolsMenu", "BuildCleanupUI", UpdateUI )
+
+end

lua/includes/modules/concommand.lua

@@ -0,0 +1,75 @@
+
+local AddConsoleCommand = AddConsoleCommand
+local string = string
+local Msg = Msg
+
+--[[---------------------------------------------------------
+   Name: concommand
+   Desc: A module to take care of the registration and calling
+         of Lua console commands.
+-----------------------------------------------------------]]
+module( "concommand" )
+
+local CommandList = {}
+local CompleteList = {}
+
+--[[---------------------------------------------------------
+   Name: concommand.GetTable( )
+   Desc: Returns the table of console commands and auto complete
+-----------------------------------------------------------]]
+function GetTable()
+	return CommandList, CompleteList
+end
+
+--[[---------------------------------------------------------
+   Name: concommand.Add( name, func, completefunc )
+   Desc: Register a new console command
+-----------------------------------------------------------]]
+function Add( name, func, completefunc, help, flags )
+	local LowerName = string.lower( name )
+	CommandList[ LowerName ] = func
+	CompleteList[ LowerName ] = completefunc
+	AddConsoleCommand( name, help, flags )
+end
+
+--[[---------------------------------------------------------
+   Name: concommand.Remove( name )
+   Desc: Removes a console command
+-----------------------------------------------------------]]
+function Remove( name )
+	local LowerName = string.lower( name )
+	CommandList[ LowerName ] = nil
+	CompleteList[ LowerName ] = nil
+end
+
+--[[---------------------------------------------------------
+   Name: concommand.Run( )
+   Desc: Called by the engine when an unknown console command is run
+-----------------------------------------------------------]]
+function Run( player, command, arguments, argumentsStr )
+
+	local LowerCommand = string.lower( command )
+
+	if ( CommandList[ LowerCommand ] != nil ) then
+		CommandList[ LowerCommand ]( player, command, arguments, argumentsStr )
+		return true
+	end
+
+	Msg( "Unknown command: " .. command .. "\n" )
+
+	return false
+end
+
+--[[---------------------------------------------------------
+   Name: concommand.AutoComplete( )
+   Desc: Returns a table for the autocompletion
+-----------------------------------------------------------]]
+function AutoComplete( command, argumentsStr, arguments )
+
+	local LowerCommand = string.lower( command )
+
+	if ( CompleteList[ LowerCommand ] != nil ) then
+		return CompleteList[ LowerCommand ]( command, argumentsStr, arguments )
+	end
+
+end

lua/includes/modules/construct.lua

@@ -0,0 +1,153 @@
+
+local ents = ents
+local SERVER = SERVER
+local duplicator = duplicator
+local numpad = numpad
+local Msg = Msg
+local IsValid = IsValid
+
+module( "construct" )
+
+if SERVER then
+
+	function SetPhysProp( Player, Entity, BoneID, Bone, Data )
+
+		if ( !IsValid( Bone ) ) then
+
+			Bone = Entity:GetPhysicsObjectNum( BoneID )
+			if ( !IsValid( Bone ) ) then
+				Msg( "SetPhysProp: Error applying attributes to invalid physics object!\n" )
+				return
+			end
+
+		end
+
+		if ( Data.GravityToggle != nil )	then Bone:EnableGravity( Data.GravityToggle ) end
+		if ( Data.Material != nil )			then Bone:SetMaterial( Data.Material ) end
+
+		-- todo: Rename/Implement
+		--[[
+		if ( Data.motionb != nil )	then Bone:EnableMotion( Data.motionb ) end
+		if ( Data.mass != nil )			then Bone:SetMass( Data.mass ) end
+		if ( Data.dragb != nil )		then Bone:EnableDrag( Data.dragb ) end
+		if ( Data.drag != nil )			then Bone:SetDragCoefficient( Data.drag ) end
+		if ( Data.buoyancy != nil )		then Bone:SetBuoyancyRatio( Data.buoyancy ) end
+		if ( Data.rotdamping != nil )	then Bone:SetDamping( PhysBone:GetSpeedDamping(), Data.rotdamping ) end
+		if ( Data.speeddamping != nil )	then Bone:SetDamping( Data.speeddamping, PhysBone:GetRotDamping() ) end
+		--]]
+
+		-- HACK HACK
+		-- If we don't do this the prop will be motion enabled and will
+		-- slide through the world with no gravity.
+		if ( !Bone:IsMoveable() ) then
+
+			Bone:EnableMotion( true )
+			Bone:EnableMotion( false )
+
+		end
+
+		duplicator.StoreBoneModifier( Entity, BoneID, "physprops", Data )
+
+	end
+
+	duplicator.RegisterBoneModifier( "physprops", SetPhysProp )
+
+
+	local function MagnetOff( pl, magnet )
+
+		if ( !IsValid( magnet ) ) then return false end
+		if ( magnet:GetTable().toggle != 0 ) then return true end
+
+		magnet:Fire( "TurnOff", "" , 0 )
+
+		return true
+
+	end
+
+
+	local function MagnetOn( pl, magnet )
+
+		if ( !IsValid( magnet ) ) then return false end
+
+		if ( magnet:GetTable().toggle != 0 ) then
+
+			magnet:GetTable().toggle_state = !magnet:GetTable().toggle_state
+
+			if ( magnet:GetTable().toggle_state ) then
+				magnet:Fire( "TurnOn", "" , 0 )
+			else
+				magnet:Fire( "TurnOff", "" , 0 )
+			end
+
+			return true
+
+		end
+
+		magnet:Fire( "TurnOn", "" , 0 )
+
+		return true
+
+	end
+
+	numpad.Register( "MagnetOff", MagnetOff )
+	numpad.Register( "MagnetOn", MagnetOn )
+
+	function Magnet( pl, pos, angle, model, material, key, maxobjects, strength, nopull, allowrot, alwayson, toggle, Vel, aVel, frozen )
+
+		local magnet = ents.Create( "phys_magnet" )
+		magnet:SetPos( pos )
+		magnet:SetAngles( angle )
+		magnet:SetModel( model )
+		if ( material ) then magnet:SetMaterial( material ) end
+
+		local spawnflags = 4
+		if ( nopull && nopull > 0 ) then spawnflags = spawnflags - 4 end		-- no pull required: remove the suck flag
+		if ( allowrot && allowrot > 0 ) then spawnflags = spawnflags + 8 end
+
+		if ( maxobjects ) then magnet:SetKeyValue( "maxobjects", maxobjects ) end
+		if ( strength ) then magnet:SetKeyValue( "forcelimit", strength ) end
+		magnet:SetKeyValue( "overridescript", "surfaceprop,metal")
+		magnet:SetKeyValue( "massScale", 0 )
+
+		magnet:Activate()
+		magnet:Spawn()
+
+		if ( IsValid( magnet:GetPhysicsObject() ) ) then
+			local Phys = magnet:GetPhysicsObject()
+			if ( Vel ) then Phys:SetVelocity( Vel ) end
+			if ( aVel ) then Phys:AddAngleVelocity( aVel ) end
+			Phys:EnableMotion( frozen != true )
+		end
+
+		if ( alwayson && alwayson > 0 ) then
+			magnet:Input( "TurnOn", nil, nil, nil )
+		else
+			magnet:Input( "TurnOff", nil, nil, nil )
+		end
+
+		local mtable = {
+			Model = model,
+			material = material,
+			key = key,
+			maxobjects = maxobjects,
+			strength = strength,
+			nopull = nopull,
+			allowrot = allowrot,
+			alwayson = alwayson,
+			toggle = toggle
+		}
+
+		magnet:SetTable( mtable )
+
+		if ( key ) then
+			numpad.OnDown( pl, key, "MagnetOn", magnet )
+			numpad.OnUp( pl, key, "MagnetOff", magnet )
+		end
+
+		return magnet
+
+	end
+
+	duplicator.RegisterEntityClass( "phys_magnet", Magnet, "Pos", "Ang", "Model", "material", "key", "maxobjects", "strength", "nopull", "allowrot", "alwayson", "toggle", "Vel", "aVel", "frozen" )
+
+end

lua/includes/modules/controlpanel.lua

@@ -0,0 +1,47 @@
+
+local ControlPanels = {}
+
+module( "controlpanel", package.seeall )
+
+-- A hack for a very annoying race condition where spawnmenu_reload deletes the controlpanels on the next frame
+-- But some panels are updated "this" frame after spawnmenu reloaded
+local function ShouldReCreate( pnl )
+	if ( !IsValid( pnl ) || pnl:IsMarkedForDeletion() ) then return true end
+
+	local p = pnl
+	-- Can't use IsValid because it's false for marked for deletion panels
+	while ( IsValid( p ) && p:GetParent() != nil ) do
+		if ( p:GetParent():IsMarkedForDeletion() ) then return true end
+		p = p:GetParent()
+	end
+
+	return false
+end
+
+function Get( name )
+
+	if ( ShouldReCreate( ControlPanels[ name ] ) ) then
+		local cp = vgui.Create( "ControlPanel" )
+		if ( !cp ) then
+
+			debug.Trace()
+			Error( "controlpanel.Get() - Error creating a ControlPanel!\nYou're calling this function too early! Call it in a hook!\n" )
+			return nil
+
+		end
+
+		cp:SetVisible( false )
+		cp.Name = name
+		ControlPanels[ name ] = cp
+
+	end
+
+	return ControlPanels[ name ]
+
+end
+
+function Clear()
+
+	ControlPanels = {}
+
+end

lua/includes/modules/cookie.lua

@@ -0,0 +1,133 @@
+
+if ( !sql.TableExists( "cookies" ) ) then
+
+	sql.Query( "CREATE TABLE IF NOT EXISTS cookies ( key TEXT NOT NULL PRIMARY KEY, value TEXT );" )
+
+end
+
+module( "cookie", package.seeall )
+
+local CachedEntries = {}
+local BufferedWrites = {}
+local BufferedDeletes = {}
+
+local function GetCache( key )
+
+	if ( BufferedDeletes[ key ] ) then return nil end
+
+	local entry = CachedEntries[ key ]
+
+	if ( entry == nil || SysTime() > entry[ 1 ] ) then
+		local name = SQLStr( key )
+		local val = sql.QueryValue( "SELECT value FROM cookies WHERE key = " .. name )
+
+		if !val then
+			return false
+		end
+
+		CachedEntries[ key ] = { SysTime() + 30, val }
+	end
+
+	return CachedEntries[ key ][ 2 ]
+
+end
+
+local function FlushCache()
+
+	CachedEntries = {}
+	BufferedWrites = {}
+	BufferedDeletes = {}
+
+end
+
+local function CommitToSQLite()
+
+	sql.Begin()
+
+	for k, v in pairs( BufferedWrites ) do
+		sql.Query( "INSERT OR REPLACE INTO cookies ( key, value ) VALUES ( " .. SQLStr( k ) .. ", " .. SQLStr( v ) .. " )" )
+	end
+
+	for k, v in pairs( BufferedDeletes ) do
+		sql.Query( "DELETE FROM cookies WHERE key = " .. SQLStr( k ) )
+	end
+
+	BufferedWrites = {}
+	BufferedDeletes = {}
+
+	sql.Commit()
+
+end
+
+local function ScheduleCommit()
+
+	timer.Create( "Cookie_CommitToSQLite", 0.1, 1, CommitToSQLite )
+
+end
+
+local function SetCache( key, value )
+
+	if ( value == nil ) then return Delete( key ) end
+
+	if CachedEntries[ key ] then
+		CachedEntries[ key ][ 1 ] = SysTime() + 30
+		CachedEntries[ key ][ 2 ] = value
+	else
+		CachedEntries[ key ] = { SysTime() + 30, value }
+	end
+
+	BufferedWrites[ key ] = value
+
+	ScheduleCommit()
+
+end
+
+-- Get a String Value
+function GetString( name, default )
+
+	local val = GetCache( name )
+	if ( !val ) then return default end
+
+	return val
+
+end
+
+-- Get a Number Value
+function GetNumber( name, default )
+
+	local val = GetCache( name )
+	if ( !val ) then return default end
+
+	return tonumber( val )
+
+end
+
+-- Delete a Value
+function Delete( name )
+
+	CachedEntries[ name ] = nil
+	BufferedWrites[ name ] = nil
+	BufferedDeletes[ name ] = true
+
+	ScheduleCommit()
+
+end
+
+-- Set a Value
+function Set( name, value )
+
+	SetCache( name, value )
+
+end
+
+hook.Add( "ShutDown", "SaveCookiesOnShutdown", CommitToSQLite )
+
+if ( !CLIENT_DLL ) then return end
+
+concommand.Add( "lua_cookieclear", function( ply, command, arguments )
+
+	sql.Query( "DELETE FROM cookies" )
+	FlushCache()
+
+end )
+

lua/includes/modules/cvars.lua

@@ -0,0 +1,147 @@
+
+local table				= table
+local type				= type
+local istable 			= istable
+local isstring			= isstring
+local assert			= assert
+local format			= string.format
+local GetConVar			= GetConVar
+
+--[[---------------------------------------------------------
+	Name: cvar
+	Desc: Callbacks when cvars change
+-----------------------------------------------------------]]
+module( "cvars" )
+
+local ConVars = {}
+
+--[[---------------------------------------------------------
+	Name: GetConVarCallbacks
+	Desc: Returns a table of the given ConVars callbacks
+-----------------------------------------------------------]]
+function GetConVarCallbacks( name, createIfNotFound )
+
+	local tab = ConVars[ name ]
+	if ( createIfNotFound and !tab ) then
+		tab = {}
+		ConVars[ name ] = tab
+	end
+
+	return tab
+
+end
+
+--[[---------------------------------------------------------
+	Name: OnConVarChanged
+	Desc: Called by the engine
+-----------------------------------------------------------]]
+function OnConVarChanged( name, old, new )
+
+	local tab = GetConVarCallbacks( name )
+	if ( !tab ) then return end
+
+	for i = 1, #tab do
+		local callback = tab[ i ]
+		if ( istable( callback ) ) then
+			callback[ 1 ]( name, old, new )
+		else
+			callback( name, old, new )
+		end
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: AddChangeCallback
+	Desc: Adds a callback to be called when convar changes
+-----------------------------------------------------------]]
+function AddChangeCallback( name, func, identifier )
+
+	if ( identifier ) then
+		assert( isstring( identifier ), format( "bad argument #%i (string expected, got %s)", 3, type( identifier ) ) )
+	end
+
+	local tab = GetConVarCallbacks( name, true )
+
+	if ( !identifier ) then
+		table.insert( tab, func )
+		return
+	end
+
+	for i = 1, #tab do
+		local callback = tab[ i ]
+		if ( istable( callback ) and callback[ 2 ] == identifier ) then
+			callback[ 1 ] = func
+			return
+		end
+	end
+
+	table.insert( tab, { func, identifier } )
+
+end
+
+--[[---------------------------------------------------------
+	Name: RemoveChangeCallback
+	Desc: Removes callback with identifier
+-----------------------------------------------------------]]
+function RemoveChangeCallback( name, identifier )
+
+	if ( identifier ) then
+		assert( isstring( identifier ), format( "bad argument #%i (string expected, got %s)", 2, type( identifier ) ) )
+	end
+
+	local tab = GetConVarCallbacks( name, true )
+	for i = 1, #tab do
+		local callback = tab[ i ]
+		if ( istable( callback ) and callback[ 2 ] == identifier ) then
+			table.remove( tab, i )
+			break
+		end
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: String
+	Desc: Retrieves console variable as a string
+-----------------------------------------------------------]]
+function String( name, default )
+
+	local convar = GetConVar( name )
+	if ( convar ~= nil ) then
+		return convar:GetString()
+	end
+
+	return default
+
+end
+
+--[[---------------------------------------------------------
+	Name: Number
+	Desc: Retrieves console variable as a number
+-----------------------------------------------------------]]
+function Number( name, default )
+
+	local convar = GetConVar( name )
+	if ( convar ~= nil ) then
+		return convar:GetFloat()
+	end
+
+	return default
+
+end
+
+--[[---------------------------------------------------------
+	Name: Bool
+	Desc: Retrieves console variable as a boolean
+-----------------------------------------------------------]]
+function Bool( name, default )
+
+	local convar = GetConVar( name )
+	if ( convar ~= nil ) then
+		return convar:GetBool()
+	end
+
+	return default
+
+end

lua/includes/modules/draw.lua

@@ -0,0 +1,314 @@
+
+local string = string
+local surface = surface
+local math = math
+local Color = Color
+local tostring = tostring
+local color_white = color_white
+
+module( "draw" )
+
+--[[---------------------------------------------------------
+	Constants used for text alignment.
+	These must be the same values as in the markup module.
+-----------------------------------------------------------]]
+TEXT_ALIGN_LEFT		= 0
+TEXT_ALIGN_CENTER	= 1
+TEXT_ALIGN_RIGHT	= 2
+TEXT_ALIGN_TOP		= 3
+TEXT_ALIGN_BOTTOM	= 4
+
+--[[---------------------------------------------------------
+	Textures we use to get shit done
+-----------------------------------------------------------]]
+local tex_corner8	= surface.GetTextureID( "gui/corner8" )
+local tex_corner16	= surface.GetTextureID( "gui/corner16" )
+local tex_corner32	= surface.GetTextureID( "gui/corner32" )
+local tex_corner64	= surface.GetTextureID( "gui/corner64" )
+local tex_corner512	= surface.GetTextureID( "gui/corner512" )
+local tex_white		= surface.GetTextureID( "vgui/white" )
+
+local CachedFontHeights = {}
+
+--[[---------------------------------------------------------
+	Name: GetFontHeight( font )
+	Desc: Returns the height of a single line
+-----------------------------------------------------------]]
+function GetFontHeight( font )
+
+	if ( CachedFontHeights[ font ] != nil ) then
+		return CachedFontHeights[ font ]
+	end
+
+	surface.SetFont( font )
+	local w, h = surface.GetTextSize( "W" )
+	CachedFontHeights[ font ] = h
+
+	return h
+
+end
+
+--[[---------------------------------------------------------
+	Name: SimpleText(text, font, x, y, colour)
+	Desc: Simple "draw text at position function"
+		  color is a table with r/g/b/a elements
+-----------------------------------------------------------]]
+function SimpleText( text, font, x, y, colour, xalign, yalign )
+
+	text	= tostring( text )
+	font	= font		or "DermaDefault"
+	x		= x			or 0
+	y		= y			or 0
+	xalign	= xalign	or TEXT_ALIGN_LEFT
+	yalign	= yalign	or TEXT_ALIGN_TOP
+
+	surface.SetFont( font )
+	local w, h = surface.GetTextSize( text )
+
+	if ( xalign == TEXT_ALIGN_CENTER ) then
+		x = x - w / 2
+	elseif ( xalign == TEXT_ALIGN_RIGHT ) then
+		x = x - w
+	end
+
+	if ( yalign == TEXT_ALIGN_CENTER ) then
+		y = y - h / 2
+	elseif ( yalign == TEXT_ALIGN_BOTTOM ) then
+		y = y - h
+	end
+
+	surface.SetTextPos( math.ceil( x ), math.ceil( y ) )
+
+	if ( colour != nil ) then
+		surface.SetTextColor( colour.r, colour.g, colour.b, colour.a )
+	else
+		surface.SetTextColor( 255, 255, 255, 255 )
+	end
+
+	surface.DrawText( text )
+
+	return w, h
+
+end
+
+--[[---------------------------------------------------------
+	Name: SimpleTextOutlined( text, font, x, y, colour, xalign, yalign, outlinewidth, outlinecolour )
+	Desc: Simple draw text at position, but this will expand newlines and tabs.
+		  color is a table with r/g/b/a elements
+-----------------------------------------------------------]]
+function SimpleTextOutlined(text, font, x, y, colour, xalign, yalign, outlinewidth, outlinecolour)
+
+	local steps = ( outlinewidth * 2 ) / 3
+	if ( steps < 1 ) then steps = 1 end
+
+	for _x = -outlinewidth, outlinewidth, steps do
+		for _y = -outlinewidth, outlinewidth, steps do
+			SimpleText( text, font, x + _x, y + _y, outlinecolour, xalign, yalign )
+		end
+	end
+
+	return SimpleText( text, font, x, y, colour, xalign, yalign )
+
+end
+
+--[[---------------------------------------------------------
+	Name: DrawText(text, font, x, y, colour, align )
+	Desc: Simple draw text at position, but this will expand newlines and tabs.
+		  color is a table with r/g/b/a elements
+-----------------------------------------------------------]]
+local gmatch = string.gmatch
+local find = string.find
+local ceil = math.ceil
+local GetTextSize = surface.GetTextSize
+local max = math.max
+function DrawText( text, font, x, y, colour, xalign )
+
+	if ( font == nil ) then font = "DermaDefault" end
+	if ( text != nil ) then text = tostring( text ) end
+	if ( x == nil ) then x = 0 end
+	if ( y == nil ) then y = 0 end
+
+	local curX = x
+	local curY = y
+	local curString = ""
+
+	surface.SetFont( font )
+	local sizeX, lineHeight = GetTextSize( "\n" )
+	local tabWidth = 50
+
+	for str in gmatch( text, "[^\n]*" ) do
+		if #str > 0 then
+			if find( str, "\t" ) then -- there's tabs, some more calculations required
+				for tabs, str2 in gmatch( str, "(\t*)([^\t]*)" ) do
+					curX = ceil( ( curX + tabWidth * max( #tabs - 1, 0 ) ) / tabWidth ) * tabWidth
+
+					if #str2 > 0 then
+						SimpleText( str2, font, curX, curY, colour, xalign )
+
+						local w, _ = GetTextSize( str2 )
+						curX = curX + w
+					end
+				end
+			else -- there's no tabs, this is easy
+				SimpleText( str, font, curX, curY, colour, xalign )
+			end
+		else
+			curX = x
+			curY = curY + ( lineHeight / 2 )
+		end
+	end
+end
+
+--[[---------------------------------------------------------
+	Name: RoundedBox( bordersize, x, y, w, h, color )
+	Desc: Draws a rounded box - ideally bordersize will be 8 or 16
+	Usage: color is a table with r/g/b/a elements
+-----------------------------------------------------------]]
+function RoundedBox( bordersize, x, y, w, h, color )
+
+	return RoundedBoxEx( bordersize, x, y, w, h, color, true, true, true, true )
+
+end
+
+--[[---------------------------------------------------------
+	Name: RoundedBox( bordersize, x, y, w, h, color )
+	Desc: Draws a rounded box - ideally bordersize will be 8 or 16
+	Usage: color is a table with r/g/b/a elements
+-----------------------------------------------------------]]
+function RoundedBoxEx( bordersize, x, y, w, h, color, tl, tr, bl, br )
+
+	surface.SetDrawColor( color.r, color.g, color.b, color.a )
+
+	-- Do not waste performance if they don't want rounded corners
+	if ( bordersize <= 0 ) then
+		surface.DrawRect( x, y, w, h )
+		return
+	end
+
+	x = math.Round( x )
+	y = math.Round( y )
+	w = math.Round( w )
+	h = math.Round( h )
+	bordersize = math.min( math.Round( bordersize ), math.floor( w / 2 ), math.floor( h / 2 ) )
+
+	-- Draw as much of the rect as we can without textures
+	surface.DrawRect( x + bordersize, y, w - bordersize * 2, h )
+	surface.DrawRect( x, y + bordersize, bordersize, h - bordersize * 2 )
+	surface.DrawRect( x + w - bordersize, y + bordersize, bordersize, h - bordersize * 2 )
+
+	local tex = tex_corner8
+	if ( bordersize > 8 ) then tex = tex_corner16 end
+	if ( bordersize > 16 ) then tex = tex_corner32 end
+	if ( bordersize > 32 ) then tex = tex_corner64 end
+	if ( bordersize > 64 ) then tex = tex_corner512 end
+
+	surface.SetTexture( tex )
+
+	if ( tl ) then
+		surface.DrawTexturedRectUV( x, y, bordersize, bordersize, 0, 0, 1, 1 )
+	else
+		surface.DrawRect( x, y, bordersize, bordersize )
+	end
+
+	if ( tr ) then
+		surface.DrawTexturedRectUV( x + w - bordersize, y, bordersize, bordersize, 1, 0, 0, 1 )
+	else
+		surface.DrawRect( x + w - bordersize, y, bordersize, bordersize )
+	end
+
+	if ( bl ) then
+		surface.DrawTexturedRectUV( x, y + h -bordersize, bordersize, bordersize, 0, 1, 1, 0 )
+	else
+		surface.DrawRect( x, y + h - bordersize, bordersize, bordersize )
+	end
+
+	if ( br ) then
+		surface.DrawTexturedRectUV( x + w - bordersize, y + h - bordersize, bordersize, bordersize, 1, 1, 0, 0 )
+	else
+		surface.DrawRect( x + w - bordersize, y + h - bordersize, bordersize, bordersize )
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: WordBox( bordersize, x, y, font, color, font, color, fontcolor, xalign, yalign )
+	Desc: Draws a rounded box - ideally bordersize will be 8 or 16
+	Usage: color is a table with r/g/b/a elements
+-----------------------------------------------------------]]
+function WordBox( bordersize, x, y, text, font, color, fontcolor, xalign, yalign )
+
+	surface.SetFont( font )
+	local w, h = surface.GetTextSize( text )
+
+	if ( xalign == TEXT_ALIGN_CENTER ) then
+		x = x - ( bordersize + w / 2 )
+	elseif ( xalign == TEXT_ALIGN_RIGHT ) then
+		x = x - ( bordersize * 2 + w )
+	end
+
+	if ( yalign == TEXT_ALIGN_CENTER ) then
+		y = y - ( bordersize + h / 2 )
+	elseif ( yalign == TEXT_ALIGN_BOTTOM ) then
+		y = y - ( bordersize * 2 + h )
+	end
+
+	RoundedBox( bordersize, x, y, w+bordersize * 2, h+bordersize * 2, color )
+
+	surface.SetTextColor( fontcolor.r, fontcolor.g, fontcolor.b, fontcolor.a )
+	surface.SetTextPos( x + bordersize, y + bordersize )
+	surface.DrawText( text )
+
+	return w + bordersize * 2, h + bordersize * 2
+
+end
+
+--[[---------------------------------------------------------
+	Name: Text( table )
+	Desc: Draws text from a table
+-----------------------------------------------------------]]
+function Text( tab )
+
+	return SimpleText( tab.text, tab.font, tab.pos[ 1 ], tab.pos[ 2 ], tab.color, tab.xalign, tab.yalign )
+
+end
+
+--[[---------------------------------------------------------
+	Name: TextShadow( table )
+	Desc: Draws text from a table
+-----------------------------------------------------------]]
+function TextShadow( tab, distance, alpha )
+
+	alpha = alpha or 200
+
+	local color = tab.color
+	local pos = tab.pos
+	tab.color = Color( 0, 0, 0, alpha )
+	tab.pos = { pos[ 1 ] + distance, pos[ 2 ] + distance }
+
+	Text( tab )
+
+	tab.color = color
+	tab.pos = pos
+
+	return Text( tab )
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: TexturedQuad( table )
+	Desc: pawrapper
+-----------------------------------------------------------]]
+function TexturedQuad( tab )
+
+	local color = tab.color or color_white
+
+	surface.SetTexture( tab.texture )
+	surface.SetDrawColor( color.r, color.g, color.b, color.a )
+	surface.DrawTexturedRect( tab.x, tab.y, tab.w, tab.h )
+
+end
+
+function NoTexture()
+	surface.SetTexture( tex_white )
+end

lua/includes/modules/drive.lua

@@ -0,0 +1,241 @@
+
+local IsValid		= IsValid
+local setmetatable	= setmetatable
+local SERVER		= SERVER
+local util			= util
+local ErrorNoHalt	= ErrorNoHalt
+local baseclass		= baseclass
+local LocalPlayer	= LocalPlayer
+
+module( "drive" )
+
+local Type = {}
+
+function Register( name, table, base )
+
+	Type[ name ] = table
+
+	--
+	-- If we have a base method then hook
+	-- it up in the meta table
+	--
+	if ( base ) then
+		Type[ base ] = Type[ base ] or baseclass.Get( base )
+		setmetatable( Type[ name ], { __index = Type[ base ] } )
+	end
+
+	if ( SERVER ) then
+		util.AddNetworkString( name )
+	end
+
+	--
+	-- drive methods cooperate with the baseclass system
+	-- /lua/includes/modules/baseclass.lua
+	--
+	baseclass.Set( name, Type[ name ] )
+
+end
+
+function PlayerStartDriving( ply, ent, mode )
+
+	local method = Type[mode]
+	if ( !method ) then ErrorNoHalt( "Unknown drive type " .. ( mode ) .. "!\n" ) return end
+
+	local id = util.NetworkStringToID( mode )
+
+	ply:SetDrivingEntity( ent, id )
+
+end
+
+function PlayerStopDriving( ply )
+
+	ply:SetDrivingEntity( nil )
+
+end
+
+function GetMethod( ply )
+
+	--
+	-- Not driving, return immediately
+	--
+	if ( !ply:IsDrivingEntity() ) then return end
+
+	local ent = ply:GetDrivingEntity()
+	local modeid = ply:GetDrivingMode()
+
+	--
+	-- Entity is invalid or mode isn't set - return out
+	--
+	if ( !IsValid( ent ) || modeid == 0 ) then return end
+
+	--
+	-- Have we already got a drive method? If so then reuse.
+	--
+	local method = ply.m_CurrentDriverMethod
+	if ( method && method.Entity == ent && method.ModeID == modeid ) then return method end
+
+	--
+	-- No method - lets create one. Get the string from the modeid.
+	--
+	local modename = util.NetworkIDToString( modeid )
+	if ( !modename ) then return end
+
+	--
+	-- Get that type. Fail if we don't have the type.
+	--
+	local type = Type[ modename ]
+	if ( !type ) then return end
+
+	local method = {}
+	method.Entity = ent
+	method.Player = ply
+	method.ModeID = modeid
+
+	setmetatable( method, { __index = type } )
+
+	ply.m_CurrentDriverMethod = method
+
+	method:Init()
+	return method
+
+end
+
+function DestroyMethod( pl )
+
+	if ( !IsValid( pl ) ) then return end
+
+	pl.m_CurrentDriverMethod = nil
+
+end
+--
+-- Called when the player first
+-- starts driving this entity
+--
+function Start( ply, ent )
+
+	if ( SERVER ) then
+
+		-- Set this to the ent's view entity
+		ply:SetViewEntity( ent )
+
+		-- Save the player's eye angles
+		ply.m_PreDriveEyeAngles = ply:EyeAngles()
+		ply.m_PreDriveObserveMode = ply:GetObserverMode()
+
+		-- Lock the player's eye angles to our angles
+		local ang = ent:GetAngles()
+		ply:SetEyeAngles( ang )
+
+		-- Hide the controlling player's world model
+		ply:DrawWorldModel( false )
+
+	end
+
+end
+
+--
+-- Clientside, the client creates the cmd (usercommand)
+-- from their input device (mouse, keyboard) and then
+-- it's sent to the server. Restrict view angles here :)
+--
+function CreateMove( cmd )
+
+	local method = GetMethod( LocalPlayer() )
+	if ( !method ) then return end
+
+	method:SetupControls( cmd )
+	return true
+
+end
+
+--
+-- Optionally alter the view
+--
+function CalcView( ply, view )
+
+	local method = GetMethod( ply )
+	if ( !method ) then return end
+
+	method:CalcView( view )
+	return true
+
+end
+
+--
+-- The user command is received by the server and then
+-- converted into a move. This is also run clientside
+-- when in multiplayer, for prediction to work.
+--
+function StartMove( ply, mv, cmd )
+
+	local method = GetMethod( ply )
+	if ( !method ) then return end
+
+	method:StartMove( mv, cmd )
+	return true
+
+end
+
+
+--
+-- The move is executed here.
+--
+function Move( ply, mv )
+
+	local method = GetMethod( ply )
+	if ( !method ) then return end
+
+	method:Move( mv )
+	return true
+
+end
+
+--
+-- The move is finished. Copy mv back into the target.
+--
+function FinishMove( ply, mv )
+
+	local method = GetMethod( ply )
+	if ( !method ) then return end
+
+	method:FinishMove( mv )
+
+	if ( method.StopDriving ) then
+		PlayerStopDriving( ply )
+	end
+
+	return true
+
+end
+
+--
+-- Player has stopped driving the entity
+--
+function End( ply, ent )
+
+	--
+	-- If the player is valid then set the view entity to nil
+	--
+	if ( SERVER && IsValid( ply ) ) then
+
+		if ( ply.m_PreDriveEyeAngles != nil ) then
+			ply:SetEyeAngles( ply.m_PreDriveEyeAngles )
+			ply.m_PreDriveEyeAngles = nil
+		end
+
+		if ( ply.m_PreDriveObserveMode != nil ) then
+			ply:SetObserverMode( ply.m_PreDriveObserveMode )
+			ply.m_PreDriveObserveMode = nil
+		end
+
+		ply:SetViewEntity( nil )
+
+		-- Show the controlling player's world model
+		ply:DrawWorldModel( true )
+
+	end
+
+	DestroyMethod( ply )
+
+end
+

lua/includes/modules/effects.lua

@@ -0,0 +1,77 @@
+local ents = ents
+local pairs = pairs
+local ipairs = ipairs
+local string = string
+local table = table
+
+--[[---------------------------------------------------------
+   Name: effects
+   Desc: Engine effects hooking
+-----------------------------------------------------------]]
+module( "effects" )
+
+local EffectList = {}
+
+function Register( t, name )
+
+	name = string.lower( name )
+
+	local old = EffectList[ name ]
+
+	EffectList[ name ] = t
+
+	--
+	-- If we're reloading this entity class
+	-- then refresh all the existing entities.
+	--
+	if ( old != nil ) then
+
+		--
+		-- For each entity using this class
+		--
+		for _, entity in ipairs( ents.FindByClass( name ) ) do
+
+			--
+			-- Replace the contents with this entity table
+			--
+			table.Merge( entity, t )
+
+		end
+
+	end
+
+end
+
+function Create( name, retval )
+
+	name = string.lower( name )
+
+	--Msg( "Create.. ".. name .. "\n" )
+
+	if ( EffectList[ name ] == nil ) then return nil end
+
+	local NewEffect = retval or {}
+
+	for k, v in pairs( EffectList[ name ] ) do
+
+		NewEffect[ k ] = v
+
+	end
+
+	table.Merge( NewEffect, EffectList[ "base" ] )
+
+	return NewEffect
+
+end
+
+function GetList()
+
+	local result = {}
+
+	for k, v in pairs( EffectList ) do
+		table.insert( result, v )
+	end
+
+	return result
+
+end

lua/includes/modules/gamemode.lua

@@ -0,0 +1,86 @@
+
+local gmod			= gmod
+local Msg			= Msg
+local hook			= hook
+local table			= table
+local baseclass		= baseclass
+
+--[[---------------------------------------------------------
+	Name: gamemode
+	Desc: A module to manage gamemodes
+-----------------------------------------------------------]]
+module( "gamemode" )
+
+local GameList = {}
+
+--[[---------------------------------------------------------
+	Name: RegisterGamemode( table, string )
+	Desc: Used to register your gamemode with the engine
+-----------------------------------------------------------]]
+function Register( t, name, derived )
+
+	local CurrentGM = gmod.GetGamemode()
+
+	if ( CurrentGM ) then
+
+		if ( CurrentGM.FolderName == name ) then
+			table.Merge( CurrentGM, t )
+			Call( "OnReloaded" );
+		end
+
+		if ( CurrentGM.BaseClass && CurrentGM.BaseClass.FolderName == name ) then
+			table.Merge( CurrentGM.BaseClass, t )
+			Call( "OnReloaded" );
+		end
+
+	end
+
+	-- This gives the illusion of inheritence
+	if ( name != "base" ) then
+
+		local basetable = Get( derived )
+		if ( basetable ) then
+			t = table.Inherit( t, basetable )
+		else
+			Msg( "Warning: Couldn't find derived gamemode (", derived, ")\n" )
+		end
+
+	end
+
+	GameList[ name ] = t
+
+	--
+	-- Using baseclass for gamemodes kind of sucks, because
+	-- the base gamemode is called "base" - and they have to all be unique.
+	-- so here we prefix the gamemode name with "gamemode_" - and when using
+	-- DEFINE_BASECLASS you're expected to do the same.
+	--
+	baseclass.Set( "gamemode_" .. name, t )
+
+end
+
+--[[---------------------------------------------------------
+	Name: Get( string )
+	Desc: Get a gamemode by name.
+-----------------------------------------------------------]]
+function Get( name )
+	return GameList[ name ]
+end
+
+--[[---------------------------------------------------------
+	Name: Call( name, args )
+	Desc: Calls a gamemode function
+-----------------------------------------------------------]]
+local currentGM
+function Call( name, ... )
+
+	if ( !currentGM ) then
+		currentGM = gmod.GetGamemode()
+	end
+
+	-- If the gamemode function doesn't exist just return false
+	if ( currentGM && currentGM[name] == nil ) then return false end
+
+	return hook.Call( name, currentGM, ... )
+
+end

lua/includes/modules/halo.lua

@@ -0,0 +1,150 @@
+
+module( "halo", package.seeall )
+
+local mat_Copy		= Material( "pp/copy" )
+local mat_Add		= Material( "pp/add" )
+local mat_Sub		= Material( "pp/sub" )
+local rt_Store		= render.GetScreenEffectTexture( 0 )
+local rt_Blur		= render.GetScreenEffectTexture( 1 )
+
+local List = {}
+local RenderEnt = NULL
+
+function Add( entities, color, blurx, blury, passes, add, ignorez )
+
+	if ( table.IsEmpty( entities ) ) then return end
+	if ( add == nil ) then add = true end
+	if ( ignorez == nil ) then ignorez = false end
+
+	local t =
+	{
+		Ents = entities,
+		Color = color,
+		BlurX = blurx or 2,
+		BlurY = blury or 2,
+		DrawPasses = passes or 1,
+		Additive = add,
+		IgnoreZ = ignorez
+	}
+
+	table.insert( List, t )
+
+end
+
+function RenderedEntity()
+	return RenderEnt
+end
+
+function Render( entry )
+
+	local rt_Scene = render.GetRenderTarget()
+
+	-- Store a copy of the original scene
+	render.CopyRenderTargetToTexture( rt_Store )
+
+	-- Clear our scene so that additive/subtractive rendering with it will work later
+	if ( entry.Additive ) then
+		render.Clear( 0, 0, 0, 255, false, true )
+	else
+		render.Clear( 255, 255, 255, 255, false, true )
+	end
+
+	-- For certain materials this is necessary to not have the entire screen go pitch black
+	-- For example the glass doors in Episode 2 GMan sequence
+	render.UpdateRefractTexture()
+
+	-- Render colored props to the scene and set their pixels high
+	cam.Start3D()
+		render.SetStencilEnable( true )
+			render.SuppressEngineLighting( true )
+			cam.IgnoreZ( entry.IgnoreZ )
+
+				render.SetStencilWriteMask( 1 )
+				render.SetStencilTestMask( 1 )
+				render.SetStencilReferenceValue( 1 )
+
+				render.SetStencilCompareFunction( STENCIL_ALWAYS )
+				render.SetStencilPassOperation( STENCIL_REPLACE )
+				render.SetStencilFailOperation( STENCIL_KEEP )
+				render.SetStencilZFailOperation( STENCIL_KEEP )
+
+					for k, v in pairs( entry.Ents ) do
+						if ( !IsValid( v ) or v:GetNoDraw() ) then continue end
+
+						RenderEnt = v
+
+						v:DrawModel()
+					end
+
+					RenderEnt = NULL
+
+				render.SetStencilCompareFunction( STENCIL_EQUAL )
+				render.SetStencilPassOperation( STENCIL_KEEP )
+				-- render.SetStencilFailOperation( STENCIL_KEEP )
+				-- render.SetStencilZFailOperation( STENCIL_KEEP )
+
+					cam.Start2D()
+						local entryColor = entry.Color
+						surface.SetDrawColor( entryColor.r, entryColor.g, entryColor.b, entryColor.a )
+						surface.DrawRect( 0, 0, ScrW(), ScrH() )
+					cam.End2D()
+
+			cam.IgnoreZ( false )
+			render.SuppressEngineLighting( false )
+		render.SetStencilEnable( false )
+	cam.End3D()
+
+	-- Store a blurred version of the colored props in an RT
+	render.CopyRenderTargetToTexture( rt_Blur )
+	render.BlurRenderTarget( rt_Blur, entry.BlurX, entry.BlurY, 1 )
+
+	-- Restore the original scene
+	render.SetRenderTarget( rt_Scene )
+	mat_Copy:SetTexture( "$basetexture", rt_Store )
+	mat_Copy:SetString( "$color", "1 1 1" )
+	mat_Copy:SetString( "$alpha", "1" )
+	render.SetMaterial( mat_Copy )
+	render.DrawScreenQuad()
+
+	-- Draw back our blured colored props additively/subtractively, ignoring the high bits
+	render.SetStencilEnable( true )
+
+		render.SetStencilCompareFunction( STENCIL_NOTEQUAL )
+		-- render.SetStencilPassOperation( STENCIL_KEEP )
+		-- render.SetStencilFailOperation( STENCIL_KEEP )
+		-- render.SetStencilZFailOperation( STENCIL_KEEP )
+
+		if ( entry.Additive ) then
+			mat_Add:SetTexture( "$basetexture", rt_Blur )
+			render.SetMaterial( mat_Add )
+		else
+			mat_Sub:SetTexture( "$basetexture", rt_Blur )
+			render.SetMaterial( mat_Sub )
+		end
+
+		for i = 0, entry.DrawPasses do
+			render.DrawScreenQuad()
+		end
+
+	render.SetStencilEnable( false )
+
+	-- Return original values
+	render.SetStencilTestMask( 0 )
+	render.SetStencilWriteMask( 0 )
+	render.SetStencilReferenceValue( 0 )
+
+end
+
+hook.Add( "PostDrawEffects", "RenderHalos", function()
+
+	hook.Run( "PreDrawHalos" )
+
+	if ( #List == 0 ) then return end
+
+	for k, v in ipairs( List ) do
+		Render( v )
+	end
+
+	List = {}
+
+end )

lua/includes/modules/hook.lua

@@ -0,0 +1,143 @@
+local gmod = gmod
+local pairs = pairs
+local isfunction = isfunction
+local isstring = isstring
+local isnumber = isnumber
+local isbool = isbool
+local IsValid = IsValid
+local type = type
+local ErrorNoHaltWithStack = ErrorNoHaltWithStack
+
+module( "hook" )
+
+local Hooks = {}
+
+--[[---------------------------------------------------------
+    Name: GetTable
+    Desc: Returns a table of all hooks.
+-----------------------------------------------------------]]
+function GetTable()
+	return Hooks
+end
+
+--[[---------------------------------------------------------
+    Name: Add
+    Args: string hookName, any identifier, function func
+    Desc: Add a hook to listen to the specified event.
+-----------------------------------------------------------]]
+function Add( event_name, name, func )
+
+	if ( !isstring( event_name ) ) then ErrorNoHaltWithStack( "bad argument #1 to 'Add' (string expected, got " .. type( event_name ) .. ")" ) return end
+	if ( !isfunction( func ) ) then ErrorNoHaltWithStack( "bad argument #3 to 'Add' (function expected, got " .. type( func ) .. ")" ) return end
+
+	local notValid = name == nil || isnumber( name ) or isbool( name ) or isfunction( name ) or !name.IsValid
+	if ( !isstring( name ) and notValid ) then ErrorNoHaltWithStack( "bad argument #2 to 'Add' (string expected, got " .. type( name ) .. ")" ) return end
+
+	if ( Hooks[ event_name ] == nil ) then
+		Hooks[ event_name ] = {}
+	end
+
+	Hooks[ event_name ][ name ] = func
+
+end
+
+
+--[[---------------------------------------------------------
+    Name: Remove
+    Args: string hookName, identifier
+    Desc: Removes the hook with the given indentifier.
+-----------------------------------------------------------]]
+function Remove( event_name, name )
+
+	if ( !isstring( event_name ) ) then ErrorNoHaltWithStack( "bad argument #1 to 'Remove' (string expected, got " .. type( event_name ) .. ")" ) return end
+
+	local notValid = isnumber( name ) or isbool( name ) or isfunction( name ) or !name.IsValid
+	if ( !isstring( name ) and notValid ) then ErrorNoHaltWithStack( "bad argument #2 to 'Remove' (string expected, got " .. type( name ) .. ")" ) return end
+
+	if ( !Hooks[ event_name ] ) then return end
+
+	Hooks[ event_name ][ name ] = nil
+
+end
+
+
+--[[---------------------------------------------------------
+    Name: Run
+    Args: string hookName, vararg args
+    Desc: Calls hooks associated with the hook name.
+-----------------------------------------------------------]]
+local currentGM
+
+function Run( name, ... )
+	if ( !currentGM ) then
+		currentGM = gmod and gmod.GetGamemode() or nil
+	end
+
+	return Call( name, currentGM, ... )
+end
+
+
+--[[---------------------------------------------------------
+    Name: Run
+    Args: string hookName, table gamemodeTable, vararg args
+    Desc: Calls hooks associated with the hook name.
+-----------------------------------------------------------]]
+function Call( name, gm, ... )
+
+	--
+	-- Run hooks
+	--
+	local HookTable = Hooks[ name ]
+	if ( HookTable != nil ) then
+
+		local a, b, c, d, e, f;
+
+		for k, v in pairs( HookTable ) do
+
+			if ( isstring( k ) ) then
+
+				--
+				-- If it's a string, it's cool
+				--
+				a, b, c, d, e, f = v( ... )
+
+			else
+
+				--
+				-- If the key isn't a string - we assume it to be an entity
+				-- Or panel, or something else that IsValid works on.
+				--
+				if ( IsValid( k ) ) then
+					--
+					-- If the object is valid - pass it as the first argument (self)
+					--
+					a, b, c, d, e, f = v( k, ... )
+				else
+					--
+					-- If the object has become invalid - remove it
+					--
+					HookTable[ k ] = nil
+				end
+			end
+
+			--
+			-- Hook returned a value - it overrides the gamemode function
+			--
+			if ( a != nil ) then
+				return a, b, c, d, e, f
+			end
+
+		end
+	end
+
+	--
+	-- Call the gamemode function
+	--
+	if ( !gm ) then return end
+
+	local GamemodeFunction = gm[ name ]
+	if ( GamemodeFunction == nil ) then return end
+
+	return GamemodeFunction( gm, ... )
+
+end

lua/includes/modules/http.lua

@@ -0,0 +1,107 @@
+
+local HTTP = HTTP
+
+--[[---------------------------------------------------------
+	HTTP Module. Interaction with HTTP.
+-----------------------------------------------------------]]
+module( "http" )
+
+--[[---------------------------------------------------------
+
+	Get the contents of a webpage.
+
+	Callback should be
+
+	function callback( (args optional), contents, size )
+
+-----------------------------------------------------------]]
+function Fetch( url, onsuccess, onfailure, header )
+
+	local request = {
+		url			= url,
+		method		= "get",
+		headers		= header or {},
+
+		success = function( code, body, headers )
+
+			if ( !onsuccess ) then return end
+
+			onsuccess( body, body:len(), headers, code )
+
+		end,
+
+		failed = function( err )
+
+			if ( !onfailure ) then return end
+
+			onfailure( err )
+
+		end
+	}
+
+	local success = HTTP( request )
+	if ( !success && onfailure ) then onfailure( "HTTP failed" ) end
+
+end
+
+function Post( url, params, onsuccess, onfailure, header )
+
+	local request = {
+		url			= url,
+		method		= "post",
+		parameters	= params,
+		headers		= header or {},
+
+		success = function( code, body, headers )
+
+			if ( !onsuccess ) then return end
+
+			onsuccess( body, body:len(), headers, code )
+
+		end,
+
+		failed = function( err )
+
+			if ( !onfailure ) then return end
+
+			onfailure( err )
+
+		end
+	}
+
+	local success = HTTP( request )
+	if ( !success && onfailure ) then onfailure( "HTTP failed" ) end
+
+end
+
+--[[
+
+Or use HTTP( table )
+
+local request = {
+	url			= "http://pastebin.com/raw.php?i=3jsf50nL",
+	method		= "post",
+
+	parameters = {
+		id			= "548",
+		country		= "England"
+	}
+
+	success = function( code, body, headers )
+
+		Msg( "Request Successful\n" )
+		Msg( "Code: ", code, "\n" )
+		Msg( "Body Length:\n", body:len(), "\n" )
+		Msg( "Body:\n", body, "\n" )
+		PrintTable( headers )
+
+	end,
+
+	failed = function( reason )
+		Msg( "Request failed: ", reason, "\n" )
+	end
+}
+
+HTTP( request )
+
+--]]

lua/includes/modules/killicon.lua

@@ -0,0 +1,205 @@
+
+-- Globals that we need
+local surface = surface
+local Msg = Msg
+local Color = Color
+local Material = Material
+
+--[[---------------------------------------------------------
+   Name: killicon
+   Desc: Stores and serves killicons for deathnotice
+-----------------------------------------------------------]]
+module( "killicon" )
+
+local Icons = {}
+local TYPE_FONT = 0
+local TYPE_MATERIAL = 1
+local TYPE_MATERIAL_UV = 2
+
+function AddFont( name, font, character, color, heightScale )
+
+	Icons[name] = {
+		type		= TYPE_FONT,
+		font		= font,
+		character	= character,
+		color		= color or Color( 255, 80, 0 ),
+
+		-- Correct certain icons
+		heightScale = heightScale
+	}
+
+end
+
+function Add( name, material, color )
+
+	Icons[name] = {
+		type		= TYPE_MATERIAL,
+		material	= Material( material ),
+		color		= color or Color( 255, 255, 255 )
+	}
+
+end
+
+function AddTexCoord( name, material, color, x, y, w, h )
+
+	Icons[name] = {
+		type		= TYPE_MATERIAL_UV,
+		material	= Material( material ),
+		color		= color,
+		tex_x		= x,
+		tex_y		= y,
+		tex_w		= w,
+		tex_h		= h
+	}
+
+end
+
+function AddAlias( name, alias )
+
+	Icons[name] = Icons[alias]
+
+end
+
+function Exists( name )
+
+	return Icons[name] != nil
+
+end
+
+function GetSize( name, dontEqualizeHeight )
+
+	if ( !Icons[name] ) then
+		Msg( "Warning: killicon not found '" .. name .. "'\n" )
+		Icons[name] = Icons["default"]
+	end
+
+	local t = Icons[name]
+
+	-- Check the cache
+	if ( t.size ) then
+
+		-- Maintain the old behavior
+		if ( !dontEqualizeHeight ) then return t.size.adj_w, t.size.adj_h end
+
+		return t.size.w, t.size.h
+	end
+
+	local w, h = 0, 0
+
+	if ( t.type == TYPE_FONT ) then
+
+		surface.SetFont( t.font )
+		w, h = surface.GetTextSize( t.character )
+
+		if ( t.heightScale ) then h = h * t.heightScale end
+
+	elseif ( t.type == TYPE_MATERIAL ) then
+
+		w, h = t.material:Width(), t.material:Height()
+
+	elseif ( t.type == TYPE_MATERIAL_UV ) then
+
+		w = t.tex_w
+		h = t.tex_h
+
+	end
+
+	t.size = {}
+	t.size.w = w or 32
+	t.size.h = h or 32
+
+	-- Height adjusted behavior
+	if ( t.type == TYPE_FONT ) then
+		t.size.adj_w, t.size.adj_h = surface.GetTextSize( t.character )
+		-- BUG: This is not same height as the texture icons, and we cannot change it beacuse backwards compability
+	else
+		surface.SetFont( "HL2MPTypeDeath" )
+		local _, fh = surface.GetTextSize( "0" )
+		fh = fh * 0.75 -- Fudge it slightly
+
+		-- Resize, maintaining aspect ratio
+		t.size.adj_w = w * ( fh / h )
+		t.size.adj_h = fh
+	end
+
+	-- Maintain the old behavior
+	if ( !dontEqualizeHeight ) then return t.size.adj_w, t.size.adj_h end
+
+	return w, h
+
+end
+
+local function DrawInternal( x, y, name, alpha, noCorrections, dontEqualizeHeight )
+
+	alpha = alpha or 255
+
+	if ( !Icons[name] ) then
+		Msg( "Warning: killicon not found '" .. name .. "'\n" )
+		Icons[name] = Icons["default"]
+	end
+
+	local t = Icons[name]
+
+	local w, h = GetSize( name, dontEqualizeHeight )
+
+	if ( !noCorrections ) then x = x - w * 0.5 end
+
+	if ( t.type == TYPE_FONT ) then
+
+		-- HACK: Default font killicons are anchored to the top, so correct for it
+		if ( noCorrections && !dontEqualizeHeight ) then
+			local _, h2 = GetSize( name, !dontEqualizeHeight )
+			y = y + ( h - h2 ) / 2
+		end
+
+		if ( !noCorrections ) then y = y - h * 0.1 end
+
+		surface.SetTextPos( x, y )
+		surface.SetFont( t.font )
+		surface.SetTextColor( t.color.r, t.color.g, t.color.b, alpha )
+		surface.DrawText( t.character )
+
+	end
+
+	if ( t.type == TYPE_MATERIAL ) then
+
+		if ( !noCorrections ) then y = y - h * 0.3 end
+
+		surface.SetMaterial( t.material )
+		surface.SetDrawColor( t.color.r, t.color.g, t.color.b, alpha )
+		surface.DrawTexturedRect( x, y, w, h )
+
+	end
+
+	if ( t.type == TYPE_MATERIAL_UV ) then
+
+		if ( !noCorrections ) then y = y - h * 0.3 end
+
+		local tw = t.material:Width()
+		local th = t.material:Height()
+		surface.SetMaterial( t.material )
+		surface.SetDrawColor( t.color.r, t.color.g, t.color.b, alpha )
+		surface.DrawTexturedRectUV( x, y, w, h, t.tex_x / tw, t.tex_y / th, ( t.tex_x + t.tex_w ) / tw, ( t.tex_y + t.tex_h ) / th )
+
+	end
+
+end
+
+-- Old function with weird vertical adjustments
+function Draw( x, y, name, alpha )
+
+	DrawInternal( x, y, name, alpha )
+
+end
+
+-- The new function that doesn't have the weird vertical adjustments
+function Render( x, y, name, alpha, dontEqualizeHeight )
+
+	DrawInternal( x, y, name, alpha, true, dontEqualizeHeight )
+
+end
+
+local Color_Icon = Color( 255, 80, 0, 255 )
+
+Add( "default", "HUD/killicons/default", Color_Icon )
+AddAlias( "suicide", "default" )

lua/includes/modules/list.lua

@@ -0,0 +1,86 @@
+
+local table 	= table
+local pairs		= pairs
+local istable		= istable
+
+module( "list" )
+
+
+local Lists = {}
+
+function Get( listid )
+
+	return table.Copy( GetForEdit( listid ) )
+
+end
+
+function GetForEdit( listid, nocreate )
+
+	local list = Lists[ listid ]
+
+	if ( !nocreate && list == nil ) then
+		list = {}
+		Lists[ listid ] = list
+	end
+
+	return list
+
+end
+
+function GetTable()
+
+	return table.GetKeys( Lists )
+
+end
+
+function Add( listid, value )
+
+	return table.insert( GetForEdit( listid ), value )
+
+end
+
+function Contains( listid, value )
+
+	local list = Lists[ listid ]
+	if ( list == nil ) then return false end
+
+	for k, v in pairs( list ) do
+		if ( v == value ) then return true end
+	end
+
+	return false
+
+end
+
+function Set( listid, key, value )
+
+	GetForEdit( listid )[ key ] = value
+
+end
+
+function RemoveEntry( listid, key )
+
+	GetForEdit( listid )[ key ] = nil
+
+end
+
+function HasEntry( listid, key )
+
+	local list = Lists[ listid ]
+
+	return list != nil && list[ key ] != nil
+
+end
+
+function GetEntry( listid, key )
+
+	local list = GetForEdit( listid )
+	local value = list[ key ]
+
+	if ( istable( value ) ) then
+		value = table.Copy( value )
+	end
+
+	return value
+
+end

lua/includes/modules/markup.lua

@@ -0,0 +1,557 @@
+
+local string = string
+local table = table
+local surface = surface
+local tostring = tostring
+local ipairs = ipairs
+local setmetatable = setmetatable
+local tonumber = tonumber
+local math = math
+local utf8 = utf8
+local _Color = Color
+
+local MarkupObject = {}
+MarkupObject.__index = MarkupObject
+RegisterMetaTable( "MarkupObject", MarkupObject )
+
+module( "markup" )
+
+--[[---------------------------------------------------------
+	Name: Constants used for text alignment.
+		  These must be the same values as in the draw module.
+-----------------------------------------------------------]]
+TEXT_ALIGN_LEFT		= 0
+TEXT_ALIGN_CENTER	= 1
+TEXT_ALIGN_RIGHT	= 2
+TEXT_ALIGN_TOP		= 3
+TEXT_ALIGN_BOTTOM	= 4
+
+--[[---------------------------------------------------------
+	Name: Color( Color( r, g, b, a ) )
+	Desc: Convenience function which converts a Color object into a string
+		  which can be used in the <color=r,g,b,a></color> tag
+
+		  e.g. Color( 255, 0, 0, 150 ) -> 255,0,0,150
+			   Color( 255, 0, 0 )      -> 255,0,0
+			   Color( 255, 0, 0, 255 ) -> 255,0,0
+
+	Usage: markup.Color( Color( r, g, b, a ) )
+-----------------------------------------------------------]]
+function Color( col )
+	return
+		col.r .. "," ..
+		col.g .. "," ..
+		col.b ..
+		-- If the alpha value is 255, we don't need to include it in the <color> tag, so just omit it:
+		( col.a == 255 and "" or ( "," .. col.a ) )
+end
+
+local Color = _Color
+
+--[[---------------------------------------------------------
+	Name: Temporary information used when building text frames.
+-----------------------------------------------------------]]
+local colour_stack = { Color( 255, 255, 255 ) }
+local font_stack = { "DermaDefault" }
+local blocks = {}
+
+local colourmap = {
+
+	-- it's all black and white
+	["black"] =		Color( 0, 0, 0 ),
+	["white"] =		Color( 255, 255, 255 ),
+
+	-- it's greys
+	["dkgrey"] =	Color( 64, 64, 64 ),
+	["grey"] =		Color( 128, 128, 128 ),
+	["ltgrey"] =	Color( 192, 192, 192 ),
+
+	-- account for speeling mistakes
+	["dkgray"] =	Color( 64, 64, 64 ),
+	["gray"] =		Color( 128, 128, 128 ),
+	["ltgray"] =	Color( 192, 192, 192 ),
+
+	-- normal colours
+	["red"] =		Color( 255, 0, 0 ),
+	["green"] =		Color( 0, 255, 0 ),
+	["blue"] =		Color( 0, 0, 255 ),
+	["yellow"] =	Color( 255, 255, 0 ),
+	["purple"] =	Color( 255, 0, 255 ),
+	["cyan"] =		Color( 0, 255, 255 ),
+	["turq"] =		Color( 0, 255, 255 ),
+
+	-- dark variations
+	["dkred"] =		Color( 128, 0, 0 ),
+	["dkgreen"] =	Color( 0, 128, 0 ),
+	["dkblue"] =	Color( 0, 0, 128 ),
+	["dkyellow"] =	Color( 128, 128, 0 ),
+	["dkpurple"] =	Color( 128, 0, 128 ),
+	["dkcyan"] =	Color( 0, 128, 128 ),
+	["dkturq"] =	Color( 0, 128, 128 ),
+
+	-- light variations
+	["ltred"] =		Color( 255, 128, 128 ),
+	["ltgreen"] =	Color( 128, 255, 128 ),
+	["ltblue"] =	Color( 128, 128, 255 ),
+	["ltyellow"] =	Color( 255, 255, 128 ),
+	["ltpurple"] =	Color( 255, 128, 255 ),
+	["ltcyan"] =	Color( 128, 255, 255 ),
+	["ltturq"] =	Color( 128, 255, 255 ),
+}
+
+--[[---------------------------------------------------------
+	Name: colourMatch( c )
+	Desc: Match a colour name to an rgb value.
+	Usage: ** INTERNAL ** Do not use!
+-----------------------------------------------------------]]
+local function colourMatch( c )
+	return colourmap[ string.lower( c ) ]
+end
+
+--[[---------------------------------------------------------
+	Name: ExtractParams(p1,p2,p3)
+	Desc: This function is used to extract the tag information.
+	Usage: ** INTERNAL ** Do not use!
+-----------------------------------------------------------]]
+local function ExtractParams( p1, p2, p3 )
+
+	if ( string.sub( p1, 1, 1 ) == "/" ) then
+
+		local tag = string.sub( p1, 2 )
+
+		if ( tag == "color" or tag == "colour" ) then
+			table.remove( colour_stack )
+		elseif ( tag == "font" or tag == "face" ) then
+			table.remove( font_stack )
+		end
+
+	else
+
+		if ( p1 == "color" or p1 == "colour" ) then
+
+			local rgba = colourMatch( p2 )
+
+			if ( rgba == nil ) then
+				rgba = Color( 255, 255, 255, 255 )
+				local x = { "r", "g", "b", "a" }
+				local n = 1
+				for k, v in string.gmatch( p2, "(%d+),?" ) do
+					rgba[ x[ n ] ] = tonumber( k )
+					n = n + 1
+				end
+			end
+
+			table.insert( colour_stack, rgba )
+
+		elseif ( p1 == "font" or p1 == "face" ) then
+
+			table.insert( font_stack, tostring( p2 ) )
+
+		end
+
+	end
+end
+
+--[[---------------------------------------------------------
+	Name: CheckTextOrTag( p )
+	Desc: This function places data in the "blocks" table
+		  depending of if p is a tag, or some text
+	Usage: ** INTERNAL ** Do not use!
+-----------------------------------------------------------]]
+local function CheckTextOrTag( p )
+	if ( p == "" ) then return end
+	if ( p == nil ) then return end
+
+	if ( string.sub( p, 1, 1 ) == "<" ) then
+		string.gsub( p, "<([/%a]*)=?([^>]*)", ExtractParams )
+	else
+
+		local text_block = {}
+		text_block.text = p
+		text_block.colour = colour_stack[ #colour_stack ]
+		text_block.font = font_stack[ #font_stack ]
+		table.insert( blocks, text_block )
+
+	end
+end
+
+--[[---------------------------------------------------------
+	Name: ProcessMatches(p1,p2,p3)
+	Desc: CheckTextOrTag for 3 parameters. Called by string.gsub
+	Usage: ** INTERNAL ** Do not use!
+-----------------------------------------------------------]]
+local function ProcessMatches( p1, p2, p3 )
+	if ( p1 ) then CheckTextOrTag( p1 ) end
+	if ( p2 ) then CheckTextOrTag( p2 ) end
+	if ( p3 ) then CheckTextOrTag( p3 ) end
+end
+
+--[[---------------------------------------------------------
+	Name: MarkupObject:GetWidth()
+	Desc: Returns the width of a markup block
+	Usage: ml:GetWidth()
+-----------------------------------------------------------]]
+function MarkupObject:GetWidth()
+	return self.totalWidth
+end
+
+--[[---------------------------------------------------------
+	Name: MarkupObject:GetMaxWidth()
+	Desc: Returns the maximum width of a markup block
+	Usage: ml:GetMaxWidth()
+-----------------------------------------------------------]]
+function MarkupObject:GetMaxWidth()
+	return self.maxWidth or self.totalWidth
+end
+
+--[[---------------------------------------------------------
+	Name: MarkupObject:GetHeight()
+	Desc: Returns the height of a markup block
+	Usage: ml:GetHeight()
+-----------------------------------------------------------]]
+function MarkupObject:GetHeight()
+	return self.totalHeight
+end
+
+function MarkupObject:Size()
+	return self.totalWidth, self.totalHeight
+end
+
+--[[---------------------------------------------------------
+	Name: MarkupObject:Draw(xOffset, yOffset, halign, valign, alphaoverride)
+	Desc: Draw the markup text to the screen as position xOffset, yOffset.
+		  Halign and Valign can be used to align the text relative to its offset.
+		  Alphaoverride can be used to override the alpha value of the text-colour.
+		  textAlign can be used to align the actual text inside of its bounds.
+	Usage: MarkupObject:Draw(100, 100)
+-----------------------------------------------------------]]
+function MarkupObject:Draw( xOffset, yOffset, halign, valign, alphaoverride, textAlign )
+	for i, blk in ipairs( self.blocks ) do
+		local y = yOffset + ( blk.height - blk.thisY ) + blk.offset.y
+		local x = xOffset
+
+		if ( halign == TEXT_ALIGN_CENTER ) then		x = x - ( self.totalWidth / 2 )
+		elseif ( halign == TEXT_ALIGN_RIGHT ) then	x = x - self.totalWidth
+		end
+
+		x = x + blk.offset.x
+
+		if ( valign == TEXT_ALIGN_CENTER ) then		y = y - ( self.totalHeight / 2 )
+		elseif ( valign == TEXT_ALIGN_BOTTOM ) then	y = y - self.totalHeight
+		end
+
+		local alpha = blk.colour.a
+		if ( alphaoverride ) then alpha = alphaoverride end
+
+		surface.SetFont( blk.font )
+		surface.SetTextColor( blk.colour.r, blk.colour.g, blk.colour.b, alpha )
+
+		surface.SetTextPos( x, y )
+		if ( textAlign ~= TEXT_ALIGN_LEFT ) then
+			local lineWidth = self.lineWidths[ blk.offset.y ]
+			if ( lineWidth ) then
+				if ( textAlign == TEXT_ALIGN_CENTER ) then
+					surface.SetTextPos( x + ( ( self.totalWidth - lineWidth ) / 2 ), y )
+				elseif ( textAlign == TEXT_ALIGN_RIGHT ) then
+					surface.SetTextPos( x + ( self.totalWidth - lineWidth ), y )
+				end
+			end
+		end
+
+		surface.DrawText( blk.text )
+	end
+end
+
+--[[---------------------------------------------------------
+	Name: Escape(str)
+	Desc: Converts a string to its escaped, markup-safe equivalent
+	Usage: markup.Escape( "<font=Default>The font will remain unchanged & these < > & symbols will also appear normally</font>" )
+-----------------------------------------------------------]]
+local escapeEntities, unescapeEntities = {
+	["&"] = "&amp;",
+	["<"] = "&lt;",
+	[">"] = "&gt;"
+}, {
+	["&amp;"] = "&",
+	["&lt;"] = "<",
+	["&gt;"] = ">"
+}
+function Escape( str )
+	return ( string.gsub( tostring( str ), "[&<>]", escapeEntities ) )
+end
+
+--[[---------------------------------------------------------
+	Name: Parse(ml, maxwidth)
+	Desc: Parses the pseudo-html markup language, and creates a
+		  MarkupObject, which can be used to the draw the
+		  text to the screen. Valid tags are: font and colour.
+		  \n and \t are also available to move to the next line,
+		  or insert a tab character.
+		  Maxwidth can be used to make the text wrap to a specific
+		  width and allows for text alignment (e.g. centering) inside
+		  the bounds.
+	Usage: markup.Parse( "<font=Default>changed font</font>\n<colour=255,0,255,255>changed colour</colour>" )
+-----------------------------------------------------------]]
+function Parse( ml, maxwidth )
+
+	ml = utf8.force( ml ) -- Ensure we have valid UTF-8 data
+
+	colour_stack = { Color( 255, 255, 255 ) }
+	font_stack = { "DermaDefault" }
+	blocks = {}
+
+	if ( !string.find( ml, "<" ) ) then
+		ml = ml .. "<nop>"
+	end
+
+	string.gsub( ml, "([^<>]*)(<[^>]+.)([^<>]*)", ProcessMatches )
+
+	local xOffset = 0
+	local yOffset = 0
+	local xSize = 0
+	local xMax = 0
+	local thisMaxY = 0
+	local new_block_list = {}
+	local ymaxes = {}
+	local lineWidths = {}
+
+	local lineHeight = 0
+	for i, blk in ipairs( blocks ) do
+
+		surface.SetFont( blk.font )
+
+		blk.text = string.gsub( blk.text, "(&.-;)", unescapeEntities )
+
+		local thisY = 0
+		local curString = ""
+		for j, c in utf8.codes( blk.text ) do
+
+			local ch = utf8.char( c )
+
+			if ( ch == "\n" ) then
+
+				if ( thisY == 0 ) then
+					thisY = lineHeight
+					thisMaxY = lineHeight
+				else
+					lineHeight = thisY
+				end
+
+				if ( string.len( curString ) > 0 ) then
+					local x1 = surface.GetTextSize( curString )
+
+					local new_block = {
+						text = curString,
+						font = blk.font,
+						colour = blk.colour,
+						thisY = thisY,
+						thisX = x1,
+						offset = {
+							x = xOffset,
+							y = yOffset
+						}
+					}
+					table.insert( new_block_list, new_block )
+					if ( xOffset + x1 > xMax ) then
+						xMax = xOffset + x1
+					end
+				end
+
+				xOffset = 0
+				xSize = 0
+				yOffset = yOffset + thisMaxY
+				thisY = 0
+				curString = ""
+				thisMaxY = 0
+
+			elseif ( ch == "\t" ) then
+
+				if ( string.len( curString ) > 0 ) then
+					local x1 = surface.GetTextSize( curString )
+
+					local new_block = {
+						text = curString,
+						font = blk.font,
+						colour = blk.colour,
+						thisY = thisY,
+						thisX = x1,
+						offset = {
+							x = xOffset,
+							y = yOffset
+						}
+					}
+					table.insert( new_block_list, new_block )
+					if ( xOffset + x1 > xMax ) then
+						xMax = xOffset + x1
+					end
+				end
+
+				curString = ""
+
+				local xOldSize = xSize
+				xSize = 0
+				local xOldOffset = xOffset
+				xOffset = math.ceil( ( xOffset + xOldSize ) / 50 ) * 50
+
+				if ( xOffset == xOldOffset ) then
+					xOffset = xOffset + 50
+
+					if ( maxwidth and xOffset > maxwidth ) then
+						-- Needs a new line
+						if ( thisY == 0 ) then
+							thisY = lineHeight
+							thisMaxY = lineHeight
+						else
+							lineHeight = thisY
+						end
+						xOffset = 0
+						yOffset = yOffset + thisMaxY
+						thisY = 0
+						thisMaxY = 0
+					end
+				end
+			else
+				local x, y = surface.GetTextSize( ch )
+
+				if ( x == nil ) then return end
+
+				if ( maxwidth and maxwidth > x ) then
+					if ( xOffset + xSize + x >= maxwidth ) then
+
+						-- need to: find the previous space in the curString
+						--          if we can't find one, take off the last character
+						--          and insert as a new block, incrementing the y etc
+
+						local lastSpacePos = string.len( curString )
+						for k = 1,string.len( curString ) do
+							local chspace = string.sub( curString, k, k )
+							if ( chspace == " " ) then
+								lastSpacePos = k
+							end
+						end
+
+						local previous_block = new_block_list[ #new_block_list ]
+						local wrap = lastSpacePos == string.len( curString ) && lastSpacePos > 0
+						if ( previous_block and previous_block.text:match( " $" ) and wrap and surface.GetTextSize( blk.text ) < maxwidth ) then
+							-- If the block was preceded by a space, wrap the block onto the next line first, as we can probably fit it there
+							local trimmed, trimCharNum = previous_block.text:gsub( " +$", "" )
+							if ( trimCharNum > 0 ) then
+								previous_block.text = trimmed
+								previous_block.thisX = surface.GetTextSize( previous_block.text )
+							end
+						else
+							if ( wrap ) then
+								-- If the block takes up multiple lines (and has no spaces), split it up
+								local sequenceStartPos = utf8.offset( curString, 0, lastSpacePos )
+								ch = string.match( curString, utf8.charpattern, sequenceStartPos ) .. ch
+								j = utf8.offset( curString, 1, sequenceStartPos )
+								curString = string.sub( curString, 1, sequenceStartPos - 1 )
+							else
+								-- Otherwise, strip the trailing space and start a new line
+								ch = string.sub( curString, lastSpacePos + 1 ) .. ch
+								j = lastSpacePos + 1
+								curString = string.sub( curString, 1, math.max( lastSpacePos - 1, 0 ) )
+							end
+
+							local m = 1
+							while ( string.sub( ch, m, m ) == " " ) do
+								m = m + 1
+							end
+							ch = string.sub( ch, m )
+
+							local x1, y1 = surface.GetTextSize( curString )
+
+							if ( y1 > thisMaxY ) then
+								thisMaxY = y1
+								ymaxes[ yOffset ] = thisMaxY
+								lineHeight = y1
+							end
+
+							local new_block = {
+								text = curString,
+								font = blk.font,
+								colour = blk.colour,
+								thisY = thisY,
+								thisX = x1,
+								offset = {
+									x = xOffset,
+									y = yOffset
+								}
+							}
+							table.insert( new_block_list, new_block )
+
+							if ( xOffset + x1 > xMax ) then
+								xMax = xOffset + x1
+							end
+
+							curString = ""
+						end
+
+						xOffset = 0
+						xSize = 0
+						x, y = surface.GetTextSize( ch )
+						yOffset = yOffset + thisMaxY
+						thisY = 0
+						thisMaxY = 0
+					end
+				end
+
+				curString = curString .. ch
+
+				thisY = y
+				xSize = xSize + x
+
+				if ( y > thisMaxY ) then
+					thisMaxY = y
+					ymaxes[ yOffset ] = thisMaxY
+					lineHeight = y
+				end
+			end
+		end
+
+		if ( string.len( curString ) > 0 ) then
+
+			local x1 = surface.GetTextSize( curString )
+
+			local new_block = {
+				text = curString,
+				font = blk.font,
+				colour = blk.colour,
+				thisY = thisY,
+				thisX = x1,
+				offset = {
+					x = xOffset,
+					y = yOffset
+				}
+			}
+			table.insert( new_block_list, new_block )
+
+			lineHeight = thisY
+
+			if ( xOffset + x1 > xMax ) then
+				xMax = xOffset + x1
+			end
+			xOffset = xOffset + x1
+		end
+		xSize = 0
+	end
+
+	local totalHeight = 0
+	for i, blk in ipairs( new_block_list ) do
+		blk.height = ymaxes[ blk.offset.y ]
+
+		if ( blk.offset.y + blk.height > totalHeight ) then
+			totalHeight = blk.offset.y + blk.height
+		end
+
+		lineWidths[ blk.offset.y ] = math.max( lineWidths[ blk.offset.y ] or 0, blk.offset.x + blk.thisX )
+	end
+
+	return setmetatable( {
+		totalHeight = totalHeight,
+		totalWidth = xMax,
+		maxWidth = maxwidth,
+		lineWidths = lineWidths,
+		blocks = new_block_list
+	}, MarkupObject )
+end

lua/includes/modules/matproxy.lua

@@ -0,0 +1,79 @@
+
+
+module( "matproxy", package.seeall )
+
+ProxyList = {}
+ActiveList = {}
+
+--
+-- Called by engine, returns true if we're overriding a proxy
+--
+function ShouldOverrideProxy( name )
+
+	return ProxyList[ name ] != nil
+
+end
+
+--
+-- Called to add a new proxy (see lua/matproxy/ for examples)
+--
+function Add( tbl )
+
+	if ( !tbl.name ) then return end
+	if ( !tbl.bind ) then return end
+
+	local bReloading = ProxyList[ tbl.name ] != nil
+
+	ProxyList[ tbl.name ] = tbl
+
+	--
+	-- If we're reloading then reload all the active entries that use this proxy
+	--
+	if ( bReloading ) then
+
+		for k, v in pairs( ActiveList ) do
+
+			if ( tbl.name != v.name ) then continue end
+
+			Msg( "Reloading: ", v.Material, "\n" )
+			Init( tbl.name, k, v.Material, v.Values )
+
+		end
+
+	end
+
+end
+
+--
+-- Called by the engine from OnBind
+--
+function Call( name, mat, ent )
+
+	local proxy = ActiveList[ name ]
+	if ( !proxy ) then return end
+	if ( !proxy.bind ) then return end
+
+	proxy:bind( proxy.Material, ent )
+
+end
+
+--
+-- Called by the engine from OnBind
+--
+function Init( name, uname, mat, values )
+
+	local proxy = ProxyList[ name ]
+	if ( !proxy ) then return end
+
+	ActiveList[ uname ] = table.Copy( proxy )
+	local active_proxy = ActiveList[ uname ]
+
+	-- Store these incase we reload
+	active_proxy.Values = values
+	active_proxy.Material = mat
+
+	if ( !active_proxy.init ) then return end
+
+	active_proxy:init( mat, values )
+
+end

lua/includes/modules/menubar.lua

@@ -0,0 +1,39 @@
+
+menubar = {}
+
+function menubar.Init()
+
+	menubar.Control = vgui.Create( "DMenuBar" )
+	menubar.Control:Dock( TOP )
+	menubar.Control:SetVisible( false )
+	
+	hook.Run( "PopulateMenuBar", menubar.Control )
+
+end
+
+function menubar.ParentTo( pnl )
+
+	// I don't like this
+	if ( !IsValid( menubar.Control ) ) then
+		menubar.Init()
+	end
+
+	menubar.Control:SetParent( pnl )
+	menubar.Control:MoveToBack()
+	menubar.Control:SetHeight( 30 )
+	menubar.Control:SetVisible( true )
+
+end
+
+function menubar.IsParent( pnl )
+
+	return menubar.Control:GetParent() == pnl
+
+end
+
+
+hook.Add( "OnGamemodeLoaded", "CreateMenuBar", function()
+
+	menubar.Init()
+
+end )

lua/includes/modules/notification.lua

@@ -0,0 +1,295 @@
+
+surface.CreateFont( "GModNotify", {
+	font	= "Arial",
+	size	= 21,
+	weight	= 0,
+	extended = true
+} )
+
+NOTIFY_GENERIC	= 0
+NOTIFY_ERROR	= 1
+NOTIFY_UNDO		= 2
+NOTIFY_HINT		= 3
+NOTIFY_CLEANUP	= 4
+
+module( "notification", package.seeall )
+
+local NoticeMaterial = {}
+
+NoticeMaterial[ NOTIFY_GENERIC ]	= Material( "vgui/notices/generic" )
+NoticeMaterial[ NOTIFY_ERROR ]		= Material( "vgui/notices/error" )
+NoticeMaterial[ NOTIFY_UNDO ]		= Material( "vgui/notices/undo" )
+NoticeMaterial[ NOTIFY_HINT ]		= Material( "vgui/notices/hint" )
+NoticeMaterial[ NOTIFY_CLEANUP ]	= Material( "vgui/notices/cleanup" )
+
+local Notices = {}
+
+function AddProgress( uid, text, frac )
+
+	if ( IsValid( Notices[ uid ] ) ) then
+
+		Notices[ uid ].StartTime = SysTime()
+		Notices[ uid ].Length = -1
+		Notices[ uid ]:SetText( text )
+		Notices[ uid ]:SetProgress( frac )
+		return
+
+	end
+
+	local parent = nil
+	if ( GetOverlayPanel ) then parent = GetOverlayPanel() end
+
+	local Panel = vgui.Create( "NoticePanel", parent )
+	Panel.StartTime = SysTime()
+	Panel.Length = -1
+	Panel.VelX = -5
+	Panel.VelY = 0
+	Panel.fx = ScrW() + 200
+	Panel.fy = ScrH()
+	Panel:SetAlpha( 255 )
+	Panel:SetText( text )
+	Panel:SetPos( Panel.fx, Panel.fy )
+	Panel:SetProgress( frac )
+
+	Notices[ uid ] = Panel
+
+end
+
+function Kill( uid )
+
+	if ( !IsValid( Notices[ uid ] ) ) then return end
+
+	Notices[ uid ].StartTime = SysTime()
+	Notices[ uid ].Length = 0.8
+
+end
+
+function AddLegacy( text, type, length )
+
+	local parent = nil
+	if ( GetOverlayPanel ) then parent = GetOverlayPanel() end
+
+	local Panel = vgui.Create( "NoticePanel", parent )
+	Panel.StartTime = SysTime()
+	Panel.Length = math.max( length, 0 )
+	Panel.VelX = -5
+	Panel.VelY = 0
+	Panel.fx = ScrW() + 200
+	Panel.fy = ScrH()
+	Panel:SetAlpha( 255 )
+	Panel:SetText( text )
+	Panel:SetLegacyType( type )
+	Panel:SetPos( Panel.fx, Panel.fy )
+
+	table.insert( Notices, Panel )
+
+end
+
+-- This is ugly because it's ripped straight from the old notice system
+local function UpdateNotice( pnl, total_h )
+
+	local x = pnl.fx
+	local y = pnl.fy
+
+	local w = pnl:GetWide() + 16
+	local h = pnl:GetTall() + 4
+
+	local ideal_y = ScrH() - 150 - h - total_h
+	local ideal_x = ScrW() - w - 20
+
+	local timeleft = pnl.StartTime - ( SysTime() - pnl.Length )
+	if ( pnl.Length < 0 ) then timeleft = 1 end
+
+	-- Cartoon style about to go thing
+	if ( timeleft < 0.7 ) then
+		ideal_x = ideal_x - 50
+	end
+
+	-- Gone!
+	if ( timeleft < 0.2 ) then
+		ideal_x = ideal_x + w * 2
+	end
+
+	local spd = RealFrameTime() * 15
+
+	y = y + pnl.VelY * spd
+	x = x + pnl.VelX * spd
+
+	local dist = ideal_y - y
+	pnl.VelY = pnl.VelY + dist * spd * 1
+	if ( math.abs( dist ) < 2 && math.abs( pnl.VelY ) < 0.1 ) then pnl.VelY = 0 end
+	dist = ideal_x - x
+	pnl.VelX = pnl.VelX + dist * spd * 1
+	if ( math.abs( dist ) < 2 && math.abs( pnl.VelX ) < 0.1 ) then pnl.VelX = 0 end
+
+	-- Friction.. kind of FPS independant.
+	pnl.VelX = pnl.VelX * ( 0.95 - RealFrameTime() * 8 )
+	pnl.VelY = pnl.VelY * ( 0.95 - RealFrameTime() * 8 )
+
+	pnl.fx = x
+	pnl.fy = y
+
+	-- If the panel is too high up (out of screen), do not update its position. This lags a lot when there are lot of panels outside of the screen
+	if ( ideal_y > -ScrH() ) then
+		pnl:SetPos( pnl.fx, pnl.fy )
+	end
+
+	return total_h + h
+
+end
+
+local function Update()
+
+	if ( !Notices ) then return end
+
+	local h = 0
+	for key, pnl in pairs( Notices ) do
+
+		h = UpdateNotice( pnl, h )
+
+	end
+
+	for k, Panel in pairs( Notices ) do
+
+		if ( !IsValid( Panel ) || Panel:KillSelf() ) then Notices[ k ] = nil end
+
+	end
+
+end
+
+hook.Add( "Think", "NotificationThink", Update )
+
+local PANEL = {}
+
+function PANEL:Init()
+
+	self:DockPadding( 3, 3, 3, 3 )
+
+	self.Label = vgui.Create( "DLabel", self )
+	self.Label:Dock( FILL )
+	self.Label:SetFont( "GModNotify" )
+	self.Label:SetTextColor( color_white )
+	self.Label:SetExpensiveShadow( 1, Color( 0, 0, 0, 200 ) )
+	self.Label:SetContentAlignment( 5 )
+
+	self:SetBackgroundColor( Color( 20, 20, 20, 255 * 0.6 ) )
+
+end
+
+function PANEL:SetText( txt )
+
+	self.Label:SetText( txt )
+	self:SizeToContents()
+
+end
+
+function PANEL:SizeToContents()
+
+	self.Label:SizeToContents()
+
+	local width, tall = self.Label:GetSize()
+
+	tall = math.max( tall, 32 ) + 6
+	width = width + 20
+
+	if ( IsValid( self.Image ) ) then
+		width = width + 32 + 8
+
+		local x = ( tall - 36 ) / 2
+		self.Image:DockMargin( 0, x, 0, x )
+	end
+
+	if ( self.Progress ) then
+		tall = tall + 10
+		self.Label:DockMargin( 0, 0, 0, 10 )
+	end
+
+	self:SetSize( width, tall )
+
+	self:InvalidateLayout()
+
+end
+
+function PANEL:SetLegacyType( t )
+
+	self.Image = vgui.Create( "DImageButton", self )
+	self.Image:SetMaterial( NoticeMaterial[ t ] )
+	self.Image:SetSize( 32, 32 )
+	self.Image:Dock( LEFT )
+	self.Image:DockMargin( 0, 0, 8, 0 )
+	self.Image.DoClick = function()
+		self.StartTime = 0
+	end
+
+	self:SizeToContents()
+
+end
+
+function PANEL:Paint( w, h )
+
+	local shouldDraw = !( LocalPlayer && IsValid( LocalPlayer() ) && IsValid( LocalPlayer():GetActiveWeapon() ) && LocalPlayer():GetActiveWeapon():GetClass() == "gmod_camera" )
+
+	if ( IsValid( self.Label ) ) then self.Label:SetVisible( shouldDraw ) end
+	if ( IsValid( self.Image ) ) then self.Image:SetVisible( shouldDraw ) end
+
+	if ( !shouldDraw ) then return end
+
+	self.BaseClass.Paint( self, w, h )
+
+	if ( !self.Progress ) then return end
+
+	local boxX, boxY = 10, self:GetTall() - 13
+	local boxW, boxH = self:GetWide() - 20, 5
+	local boxInnerW = boxW - 2
+
+	surface.SetDrawColor( 0, 100, 0, 150 )
+	surface.DrawRect( boxX, boxY, boxW, boxH )
+
+	surface.SetDrawColor( 0, 50, 0, 255 )
+	surface.DrawRect( boxX + 1, boxY + 1, boxW - 2, boxH - 2 )
+
+	local w = math.ceil( boxInnerW * 0.25 )
+	local x = math.fmod( math.floor( SysTime() * 200 ), boxInnerW + w ) - w
+
+	if ( self.ProgressFrac ) then
+		x = 0
+		w = math.ceil( boxInnerW * self.ProgressFrac )
+	end
+
+	if ( x + w > boxInnerW ) then w = math.ceil( boxInnerW - x ) end
+	if ( x < 0 ) then
+		w = w + x
+		x = 0
+	end
+
+	surface.SetDrawColor( 0, 255, 0, 255 )
+	surface.DrawRect( boxX + 1 + x, boxY + 1, w, boxH - 2 )
+
+end
+
+function PANEL:SetProgress( frac )
+
+	self.Progress = true
+	self.ProgressFrac = frac
+
+	self:SizeToContents()
+
+end
+
+function PANEL:KillSelf()
+
+	-- Infinite length
+	if ( self.Length < 0 ) then return false end
+
+	if ( self.StartTime + self.Length < SysTime() ) then
+
+		self:Remove()
+		return true
+
+	end
+
+	return false
+
+end
+
+vgui.Register( "NoticePanel", PANEL, "DPanel" )

lua/includes/modules/numpad.lua

@@ -0,0 +1,250 @@
+
+--[[---------------------------------------------------------
+	This module was primarily developed to enable toolmodes
+	to share the numpad.
+
+	Scripted Entities can add functions to be excecuted when
+	a certain key on the numpad is pressed or released.
+-----------------------------------------------------------]]
+
+if ( !SERVER ) then return end
+
+local tonumber		= tonumber
+local pairs			= pairs
+local unpack		= unpack
+local table			= table
+local saverestore	= saverestore
+local math			= math
+local IsValid		= IsValid
+local type			= type
+local ErrorNoHaltWithStack = ErrorNoHaltWithStack
+local KEY_NONE		= KEY_NONE
+
+module( "numpad" )
+
+local functions = {}
+local keys_in = {}
+local keys_out = {}
+local lastindex = 1
+local button_fired = false
+
+function FromButton()
+
+	return button_fired == true
+
+end
+
+local function Save( save )
+
+	saverestore.WriteTable( keys_in, save )
+	saverestore.WriteTable( keys_out, save )
+	saverestore.WriteVar( lastindex, save )
+
+end
+
+local function Restore( restore )
+
+	keys_in = saverestore.ReadTable( restore )
+	keys_out = saverestore.ReadTable( restore )
+	lastindex = saverestore.ReadVar( restore )
+
+end
+
+saverestore.AddSaveHook( "NumpadModule", Save )
+saverestore.AddRestoreHook( "NumpadModule", Restore )
+
+--[[---------------------------------------------------------
+	Returns a unique index based on a player.
+-----------------------------------------------------------]]
+local function GetPlayerIndex( ply )
+
+	if ( !IsValid( ply ) ) then return 0 end
+
+	return ply:SteamID64()
+
+end
+
+--[[---------------------------------------------------------
+	Fires the impulse to the child functions
+-----------------------------------------------------------]]
+local function FireImpulse( tab, pl, idx )
+
+	if ( idx == nil ) then
+		idx = GetPlayerIndex( pl )
+	end
+
+	if ( !tab ) then return end
+	if ( !tab[ idx ] ) then return end
+
+	for k, v in pairs( tab[ idx ] ) do
+
+		local func = functions[ v.name ]
+
+		local retval = func( pl, unpack( v.arg ) )
+
+		-- Remove hook
+		if ( retval == false ) then
+			tab[ idx ][ k ] = nil
+		end
+
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Console Command
+-----------------------------------------------------------]]
+function Activate( pl, num, bIsButton )
+
+	local key = math.Clamp( tonumber( num ), 0, 256 )
+
+	-- Hack. Kinda. Don't call it again until the key has been lifted.
+	-- When holding down 9 or 3 on the numpad it will repeat. Ignore that.
+	if ( IsValid( pl ) ) then
+		pl.keystate = pl.keystate or {}
+		if ( pl.keystate[ key ] ) then return end
+		pl.keystate[ key ] = true
+	end
+
+	button_fired = bIsButton
+
+		FireImpulse( keys_in[ key ], pl, nil )
+
+		-- And fire `all`
+		FireImpulse( keys_in[ key ], pl, 0 )
+
+	button_fired = false
+
+end
+
+--[[---------------------------------------------------------
+	Console Command
+-----------------------------------------------------------]]
+function Deactivate( pl, num, bIsButton )
+
+	local key = math.Clamp( tonumber( num ) , 0, 256 )
+
+	if ( IsValid( pl ) ) then
+		pl.keystate = pl.keystate or {}
+		pl.keystate[ key ] = nil
+	end
+
+	button_fired = bIsButton
+
+		FireImpulse( keys_out[ key ], pl, nil )
+
+		-- And fire `all`
+		FireImpulse( keys_out[ key ], pl, 0 )
+
+	button_fired = false
+
+end
+
+--[[---------------------------------------------------------
+	Toggle
+-----------------------------------------------------------]]
+function Toggle( pl, num )
+
+	local key = math.Clamp( tonumber( num ), 0, 256 )
+
+	pl.keystate = pl.keystate or {}
+	if ( pl.keystate[ key ] ) then return Deactivate( pl, num ) end
+
+	return Activate( pl, num )
+
+end
+
+--[[---------------------------------------------------------
+	Adds an impulse to to the specified table
+-----------------------------------------------------------]]
+local function AddImpulse( table, ply, impulse )
+
+	lastindex = lastindex + 1
+
+	local idx = GetPlayerIndex( ply )
+	table[ idx ] = table[ idx ] or {}
+	table[ idx ][ lastindex ] = impulse
+
+	return lastindex
+
+end
+
+--[[---------------------------------------------------------
+	Adds a function to call when ply presses key
+-----------------------------------------------------------]]
+function OnDown( ply, key, name, ... )
+
+	if ( !key || key ~= key ) then ErrorNoHaltWithStack( "bad argument #2 to 'numpad.OnDown' (number expected, got ", type( key ), ")" ) return end
+	if ( key == KEY_NONE ) then return end
+
+	keys_in[ key ] = keys_in[ key ] or {}
+
+	local impulse = {}
+	impulse.name = name
+	impulse.arg = { ... }
+
+	table.insert( impulse.arg, GetPlayerIndex( ply ) )
+
+	return AddImpulse( keys_in[ key ], ply, impulse )
+
+end
+
+--[[---------------------------------------------------------
+	Adds a function to call when ply releases key
+-----------------------------------------------------------]]
+function OnUp( ply, key, name, ... )
+
+	if ( !key || key ~= key ) then ErrorNoHaltWithStack( "bad argument #2 to 'numpad.OnUp' (number expected, got ", type( key ), ")" ) return end
+	if ( key == KEY_NONE ) then return end
+
+	keys_out[ key ] = keys_out[ key ] or {}
+
+	local impulse = {}
+	impulse.name = name
+	impulse.arg = { ... }
+
+	table.insert( impulse.arg, GetPlayerIndex( ply ) )
+
+	return AddImpulse( keys_out[ key ], ply, impulse )
+
+end
+
+--[[---------------------------------------------------------
+	Removes key from tab (by unique index)
+-----------------------------------------------------------]]
+local function RemoveFromKeyTable( tab, idx )
+
+	for k, v_key in pairs( tab ) do
+
+		for k_, v_player in pairs( v_key ) do
+
+			if ( v_player[ idx ] != nil ) then
+				v_player[ idx ] = nil
+			end
+
+		end
+
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Removes key (by unique index)
+-----------------------------------------------------------]]
+function Remove( idx )
+
+	if ( !idx ) then return end
+
+	RemoveFromKeyTable( keys_out, idx )
+	RemoveFromKeyTable( keys_in, idx )
+
+end
+
+--[[---------------------------------------------------------
+	Register a function
+-----------------------------------------------------------]]
+function Register( name, func )
+
+	functions[ name ] = func
+
+end

lua/includes/modules/player_manager.lua

@@ -0,0 +1,457 @@
+
+local ErrorNoHalt = ErrorNoHalt
+local baseclass = baseclass
+local setmetatable = setmetatable
+local SERVER = SERVER
+local string = string
+local table = table
+local util = util
+
+module( "player_manager" )
+
+-- Stores a table of valid player models
+local ModelList = {}
+local ModelListRev = {}
+local HandNames = {}
+
+--[[---------------------------------------------------------
+	Utility to add models to the acceptable model list
+-----------------------------------------------------------]]
+function AddValidModel( name, model )
+
+	ModelList[ name ] = model
+	ModelListRev[ string.lower( model ) ] = name
+
+end
+
+--
+-- Valid hands
+--
+function AddValidHands( name, model, skin, body, matchBodySkin )
+
+	HandNames[ name ] = { model = model, skin = skin or 0, body = body or "0000000", matchBodySkin = matchBodySkin or false }
+
+end
+
+--[[---------------------------------------------------------
+	Return list of all valid player models
+-----------------------------------------------------------]]
+function AllValidModels( )
+	return ModelList
+end
+
+
+--[[---------------------------------------------------------
+	Translate the simple name of a model
+	into the full model name
+-----------------------------------------------------------]]
+function TranslatePlayerModel( name )
+
+	if ( ModelList[ name ] != nil ) then
+		return ModelList[ name ]
+	end
+
+	return "models/player/kleiner.mdl"
+end
+
+-- Translate from the full model name to simple model name
+function TranslateToPlayerModelName( model )
+
+	model = string.lower( model )
+
+	if ( ModelListRev[ model ] != nil ) then
+		return ModelListRev[ model ]
+	end
+
+	return "kleiner"
+end
+
+--
+-- Translate hands based on model
+--
+function TranslatePlayerHands( name )
+
+	if ( HandNames[ name ] != nil ) then
+		return HandNames[ name ]
+	end
+
+	return { model = "models/weapons/c_arms_citizen.mdl", skin = 0, body = "100000000" }
+end
+
+--[[---------------------------------------------------------
+	Compile a list of valid player models
+-----------------------------------------------------------]]
+
+AddValidModel( "alyx",			"models/player/alyx.mdl" )
+AddValidHands( "alyx",			"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "barney",		"models/player/barney.mdl" )
+AddValidHands( "barney",		"models/weapons/c_arms_combine.mdl",		0, "0000000" )
+
+AddValidModel( "breen",			"models/player/breen.mdl" )
+AddValidHands( "breen",			"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "charple",		"models/player/charple.mdl" )
+AddValidHands( "charple",		"models/weapons/c_arms_citizen.mdl",		2, "0000000" )
+
+AddValidModel( "chell",			"models/player/p2_chell.mdl" )
+AddValidHands( "chell",			"models/weapons/c_arms_chell.mdl",			0, "0000000" )
+
+AddValidModel( "corpse",		"models/player/corpse1.mdl" )
+AddValidHands( "corpse",		"models/weapons/c_arms_citizen.mdl",		2, "0000000" )
+
+AddValidModel( "combine",		"models/player/combine_soldier.mdl" )
+AddValidHands( "combine",		"models/weapons/c_arms_combine.mdl",		0, "0000000" )
+
+AddValidModel( "combineprison",	"models/player/combine_soldier_prisonguard.mdl" )
+AddValidHands( "combineprison",	"models/weapons/c_arms_combine.mdl",		0, "0000000" )
+
+AddValidModel( "combineelite",	"models/player/combine_super_soldier.mdl" )
+AddValidHands( "combineelite",	"models/weapons/c_arms_combine.mdl",		0, "0000000" )
+
+AddValidModel( "eli",			"models/player/eli.mdl" )
+AddValidHands( "eli",			"models/weapons/c_arms_citizen.mdl",		1, "0000000" )
+
+AddValidModel( "gman",			"models/player/gman_high.mdl" )
+AddValidHands( "gman",			"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "kleiner",		"models/player/kleiner.mdl" )
+AddValidHands( "kleiner",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "monk",			"models/player/monk.mdl" )
+AddValidHands( "monk",			"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "mossman",		"models/player/mossman.mdl" )
+AddValidHands( "mossman",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "mossmanarctic",	"models/player/mossman_arctic.mdl" )
+AddValidHands( "mossmanarctic",	"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "odessa",		"models/player/odessa.mdl" )
+AddValidHands( "odessa",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "police",		"models/player/police.mdl" )
+AddValidHands( "police",		"models/weapons/c_arms_combine.mdl",		0, "0000000" )
+
+AddValidModel( "policefem",		"models/player/police_fem.mdl" )
+AddValidHands( "policefem",		"models/weapons/c_arms_combine.mdl",		0, "0000000" )
+
+AddValidModel( "magnusson",		"models/player/magnusson.mdl" )
+AddValidHands( "magnusson",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "stripped",		"models/player/soldier_stripped.mdl" )
+AddValidHands( "stripped",		"models/weapons/c_arms_hev.mdl",			2, "0000000" )
+
+AddValidModel( "zombie",		"models/player/zombie_classic.mdl" )
+AddValidHands( "zombie",		"models/weapons/c_arms_citizen.mdl",		2, "0000000" )
+
+AddValidModel( "zombiefast",	"models/player/zombie_fast.mdl" )
+AddValidHands( "zombiefast",	"models/weapons/c_arms_citizen.mdl",		2, "0000000" )
+
+AddValidModel( "female01",		"models/player/Group01/female_01.mdl" )
+AddValidHands( "female01",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "female02",		"models/player/Group01/female_02.mdl" )
+AddValidHands( "female02",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "female03",		"models/player/Group01/female_03.mdl" )
+AddValidHands( "female03",		"models/weapons/c_arms_citizen.mdl",		1, "0000000" )
+AddValidModel( "female04",		"models/player/Group01/female_04.mdl" )
+AddValidHands( "female04",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "female05",		"models/player/Group01/female_05.mdl" )
+AddValidHands( "female05",		"models/weapons/c_arms_citizen.mdl",		1, "0000000" )
+AddValidModel( "female06",		"models/player/Group01/female_06.mdl" )
+AddValidHands( "female06",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "female07",		"models/player/Group03/female_01.mdl" )
+AddValidHands( "female07",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "female08",		"models/player/Group03/female_02.mdl" )
+AddValidHands( "female08",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "female09",		"models/player/Group03/female_03.mdl" )
+AddValidHands( "female09",		"models/weapons/c_arms_refugee.mdl",		1, "0100000" )
+AddValidModel( "female10",		"models/player/Group03/female_04.mdl" )
+AddValidHands( "female10",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "female11",		"models/player/Group03/female_05.mdl" )
+AddValidHands( "female11",		"models/weapons/c_arms_refugee.mdl",		1, "0100000" )
+AddValidModel( "female12",		"models/player/Group03/female_06.mdl" )
+AddValidHands( "female12",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+
+AddValidModel( "male01",		"models/player/Group01/male_01.mdl" )
+AddValidHands( "male01",		"models/weapons/c_arms_citizen.mdl",		1, "0000000" )
+AddValidModel( "male02",		"models/player/Group01/male_02.mdl" )
+AddValidHands( "male02",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "male03",		"models/player/Group01/male_03.mdl" )
+AddValidHands( "male03",		"models/weapons/c_arms_citizen.mdl",		1, "0000000" )
+AddValidModel( "male04",		"models/player/Group01/male_04.mdl" )
+AddValidHands( "male04",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "male05",		"models/player/Group01/male_05.mdl" )
+AddValidHands( "male05",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "male06",		"models/player/Group01/male_06.mdl" )
+AddValidHands( "male06",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "male07",		"models/player/Group01/male_07.mdl" )
+AddValidHands( "male07",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "male08",		"models/player/Group01/male_08.mdl" )
+AddValidHands( "male08",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "male09",		"models/player/Group01/male_09.mdl" )
+AddValidHands( "male09",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+AddValidModel( "male10",		"models/player/Group03/male_01.mdl" )
+AddValidHands( "male10",		"models/weapons/c_arms_refugee.mdl",		1, "0100000" )
+AddValidModel( "male11",		"models/player/Group03/male_02.mdl" )
+AddValidHands( "male11",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "male12",		"models/player/Group03/male_03.mdl" )
+AddValidHands( "male12",		"models/weapons/c_arms_refugee.mdl",		1, "0100000" )
+AddValidModel( "male13",		"models/player/Group03/male_04.mdl" )
+AddValidHands( "male13",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "male14",		"models/player/Group03/male_05.mdl" )
+AddValidHands( "male14",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "male15",		"models/player/Group03/male_06.mdl" )
+AddValidHands( "male15",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "male16",		"models/player/Group03/male_07.mdl" )
+AddValidHands( "male16",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "male17",		"models/player/Group03/male_08.mdl" )
+AddValidHands( "male17",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "male18",		"models/player/Group03/male_09.mdl" )
+AddValidHands( "male18",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+
+AddValidModel( "medic01",		"models/player/Group03m/male_01.mdl" )
+AddValidHands( "medic01",		"models/weapons/c_arms_refugee.mdl",		1, "0100000" )
+AddValidModel( "medic02",		"models/player/Group03m/male_02.mdl" )
+AddValidHands( "medic02",		"models/weapons/c_arms_refugee.mdl",		0, "0000000" )
+AddValidModel( "medic03",		"models/player/Group03m/male_03.mdl" )
+AddValidHands( "medic03",		"models/weapons/c_arms_refugee.mdl",		1, "0100000" )
+AddValidModel( "medic04",		"models/player/Group03m/male_04.mdl" )
+AddValidHands( "medic04",		"models/weapons/c_arms_refugee.mdl",		0, "0000000" )
+AddValidModel( "medic05",		"models/player/Group03m/male_05.mdl" )
+AddValidHands( "medic05",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "medic06",		"models/player/Group03m/male_06.mdl" )
+AddValidHands( "medic06",		"models/weapons/c_arms_refugee.mdl",		0, "0000000" )
+AddValidModel( "medic07",		"models/player/Group03m/male_07.mdl" )
+AddValidHands( "medic07",		"models/weapons/c_arms_refugee.mdl",		0, "0000000" )
+AddValidModel( "medic08",		"models/player/Group03m/male_08.mdl" )
+AddValidHands( "medic08",		"models/weapons/c_arms_refugee.mdl",		0, "0000000" )
+AddValidModel( "medic09",		"models/player/Group03m/male_09.mdl" )
+AddValidHands( "medic09",		"models/weapons/c_arms_refugee.mdl",		0, "0000000" )
+AddValidModel( "medic10",		"models/player/Group03m/female_01.mdl" )
+AddValidHands( "medic10",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "medic11",		"models/player/Group03m/female_02.mdl" )
+AddValidHands( "medic11",		"models/weapons/c_arms_refugee.mdl",		0, "0000000" )
+AddValidModel( "medic12",		"models/player/Group03m/female_03.mdl" )
+AddValidHands( "medic12",		"models/weapons/c_arms_refugee.mdl",		1, "0000000" )
+AddValidModel( "medic13",		"models/player/Group03m/female_04.mdl" )
+AddValidHands( "medic13",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "medic14",		"models/player/Group03m/female_05.mdl" )
+AddValidHands( "medic14",		"models/weapons/c_arms_refugee.mdl",		0, "0100000" )
+AddValidModel( "medic15",		"models/player/Group03m/female_06.mdl" )
+AddValidHands( "medic15",		"models/weapons/c_arms_refugee.mdl",		1, "0100000" )
+
+AddValidModel( "refugee01",		"models/player/Group02/male_02.mdl" )
+AddValidHands( "refugee01",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "refugee02",		"models/player/Group02/male_04.mdl" )
+AddValidHands( "refugee02",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "refugee03",		"models/player/Group02/male_06.mdl" )
+AddValidHands( "refugee03",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+AddValidModel( "refugee04",		"models/player/Group02/male_08.mdl" )
+AddValidHands( "refugee04",		"models/weapons/c_arms_citizen.mdl",		0, "0000000" )
+
+--
+-- Game specific player models! (EP2, CSS, DOD)
+-- Moving them to here since we're now shipping all required files / fallbacks
+
+AddValidModel( "magnusson",	"models/player/magnusson.mdl" )
+AddValidHands( "magnusson",	"models/weapons/c_arms_citizen.mdl", 0, "0000000" )
+AddValidModel( "skeleton",	"models/player/skeleton.mdl" )
+AddValidHands( "skeleton",	"models/weapons/c_arms_citizen.mdl", 2, "0000000" )
+AddValidModel( "zombine",	"models/player/zombie_soldier.mdl" )
+AddValidHands( "zombine",	"models/weapons/c_arms_combine.mdl", 0, "0000000" )
+
+AddValidModel( "hostage01",	"models/player/hostage/hostage_01.mdl" )
+AddValidModel( "hostage02",	"models/player/hostage/hostage_02.mdl" )
+AddValidModel( "hostage03",	"models/player/hostage/hostage_03.mdl" )
+AddValidModel( "hostage04",	"models/player/hostage/hostage_04.mdl" )
+
+AddValidModel( "css_arctic",	"models/player/arctic.mdl" )
+AddValidHands( "css_arctic",	"models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
+AddValidModel( "css_gasmask",	"models/player/gasmask.mdl" )
+AddValidHands( "css_gasmask",	"models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
+AddValidModel( "css_guerilla",	"models/player/guerilla.mdl" )
+AddValidHands( "css_guerilla",	"models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
+AddValidModel( "css_leet",		"models/player/leet.mdl" )
+AddValidHands( "css_leet",		"models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
+AddValidModel( "css_phoenix",	"models/player/phoenix.mdl" )
+AddValidHands( "css_phoenix",	"models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
+AddValidModel( "css_riot",		"models/player/riot.mdl" )
+AddValidHands( "css_riot",		"models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
+AddValidModel( "css_swat",		"models/player/swat.mdl" )
+AddValidHands( "css_swat",		"models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
+AddValidModel( "css_urban",		"models/player/urban.mdl" )
+AddValidHands( "css_urban",		"models/weapons/c_arms_cstrike.mdl", 7, "10000000" )
+
+AddValidModel( "dod_german",	"models/player/dod_german.mdl" )
+AddValidHands( "dod_german",	"models/weapons/c_arms_dod.mdl", 0, "10000000" )
+AddValidModel( "dod_american",	"models/player/dod_american.mdl" )
+AddValidHands( "dod_american",	"models/weapons/c_arms_dod.mdl", 1, "10000000" )
+
+
+--
+-- Player Class Stuff
+--
+
+local Type = {}
+
+function GetPlayerClasses()
+
+	return table.Copy( Type )
+
+end
+
+local function LookupPlayerClass( ply )
+
+	local id = ply:GetClassID()
+	if ( id == 0 ) then return end
+
+	--
+	-- Check the cache
+	--
+	local plyClass = ply.m_CurrentPlayerClass
+	if ( plyClass && plyClass.Player == ply ) then
+		if ( plyClass.ClassID == id && plyClass.Func ) then return plyClass end -- current class is still good, behave normally
+		if ( plyClass.ClassChanged ) then plyClass:ClassChanged() end -- the class id changed, remove the old class
+	end
+
+	--
+	-- No class, lets create one
+	--
+	local classname = util.NetworkIDToString( id )
+	if ( !classname ) then return end
+
+	--
+	-- Get that type. Fail if we don't have the type.
+	--
+	local t = Type[ classname ]
+	if ( !t ) then return end
+
+	local newClass = {
+		Player = ply,
+		ClassID = id,
+		Func = function() end
+	}
+
+	setmetatable( newClass, { __index = t } )
+
+	ply.m_CurrentPlayerClass = newClass
+
+	-- TODO: We probably want to reset previous DTVar stuff on the player
+	newClass.Player:InstallDataTable()
+	newClass:SetupDataTables()
+	newClass:Init()
+	return newClass
+
+end
+
+function RegisterClass( name, tab, base )
+
+	Type[ name ] = tab
+
+	--
+	-- If we have a base method then hook
+	-- it up in the meta table
+	--
+	if ( base ) then
+
+		if ( !Type[ name ] ) then ErrorNoHalt( "RegisterClass - deriving " .. name .. " from unknown class " .. base .. "!\n" ) end
+		setmetatable( Type[ name ], { __index = Type[ base ] } )
+
+	end
+
+	if ( SERVER ) then
+		util.AddNetworkString( name )
+	end
+
+	--
+	-- drive methods cooperate with the baseclass system
+	-- /lua/includes/modules/baseclass.lua
+	--
+	baseclass.Set( name, Type[ name ] )
+
+end
+
+function SetPlayerClass( ply, classname )
+
+	if ( !Type[ classname ] ) then ErrorNoHalt( "SetPlayerClass - attempt to use unknown player class " .. classname .. "!\n" ) end
+
+	local id = util.NetworkStringToID( classname )
+	ply:SetClassID( id )
+
+	-- Initialize the player class so the datatable and everything is set up
+	-- This probably could be done better
+	LookupPlayerClass( ply )
+
+end
+
+function GetPlayerClass( ply )
+
+	local id = ply:GetClassID()
+	if ( id == 0 ) then return end
+
+	return util.NetworkIDToString( id )
+
+end
+
+function GetPlayerClassTable( ply )
+
+	local id = ply:GetClassID()
+	if ( id == 0 ) then return end
+
+	local ct = Type[ util.NetworkIDToString( id ) ]
+	if ( !ct ) then return end
+
+	return table.Copy( ct )
+
+end
+
+function ClearPlayerClass( ply )
+
+	ply:SetClassID( 0 )
+
+end
+
+function RunClass( ply, funcname, ... )
+
+	local class = LookupPlayerClass( ply )
+	if ( !class ) then return end
+
+	local func = class[ funcname ]
+	if ( !func ) then ErrorNoHalt( "Function " .. funcname .. " not found on player class!\n" ) return end
+
+	return func( class, ... )
+
+end
+
+--
+-- Should be called on spawn automatically to set the variables below
+-- This is called in the base gamemode :PlayerSpawn function
+--
+function OnPlayerSpawn( ply, transiton )
+
+	local class = LookupPlayerClass( ply )
+	if ( !class ) then return end
+
+	ply:SetSlowWalkSpeed( class.SlowWalkSpeed )
+	ply:SetWalkSpeed( class.WalkSpeed )
+	ply:SetRunSpeed( class.RunSpeed )
+	ply:SetCrouchedWalkSpeed( class.CrouchedWalkSpeed )
+	ply:SetDuckSpeed( class.DuckSpeed )
+	ply:SetUnDuckSpeed( class.UnDuckSpeed )
+	ply:SetJumpPower( class.JumpPower )
+	ply:AllowFlashlight( class.CanUseFlashlight )
+	ply:ShouldDropWeapon( class.DropWeaponOnDie )
+	ply:SetNoCollideWithTeammates( class.TeammateNoCollide )
+	ply:SetAvoidPlayers( class.AvoidPlayers )
+
+	if ( !transiton ) then
+		ply:SetMaxHealth( class.MaxHealth )
+		ply:SetMaxArmor( class.MaxArmor )
+		ply:SetHealth( class.StartHealth )
+		ply:SetArmor( class.StartArmor )
+	end
+
+end

lua/includes/modules/presets.lua

@@ -0,0 +1,91 @@
+
+module( "presets", package.seeall )
+
+-- TODO: A function to check/replace invalid characters for filenames!
+
+local Presets = LoadPresets()
+
+function GetTable( presetname )
+
+	if ( !presetname ) then return end
+	presetname = presetname:Trim()
+	if ( presetname == "" ) then return end
+
+	Presets[ presetname ] = Presets[ presetname ] or {}
+
+	return Presets[ presetname ]
+
+end
+
+function Exists( presetname, strName )
+
+	if ( !presetname || !strName ) then return false end
+	presetname = presetname:Trim()
+	strName = strName:Trim()
+	if ( presetname == "" || strName == "" ) then return false end
+
+	if ( !Presets[ presetname ] || !Presets[ presetname ][ strName ] ) then return false end
+
+	return true
+
+end
+
+function Add( presetname, strName, pTable )
+
+	if ( !presetname || !strName ) then return end
+	presetname = presetname:Trim()
+	strName = strName:Trim()
+	if ( presetname == "" || strName == "" ) then return end
+
+	Presets[ presetname ] = Presets[ presetname ] or {}
+	Presets[ presetname ][ strName ] = pTable
+
+	-- Only save the specific preset group, not ALL of them
+	SavePresets( { [ presetname ] = Presets[ presetname ] } )
+
+end
+
+function Rename( presetname, strName, strToName )
+
+	if ( !presetname || !strName || !strToName || strName == strToName ) then return end
+	presetname = presetname:Trim()
+	strName = strName:Trim()
+	strToName = strToName:Trim()
+	if ( presetname == "" || strName == "" || strToName == "" || strName == strToName ) then return end
+
+	Presets[ presetname ] = Presets[ presetname ] or {}
+	Presets[ presetname ][ strToName ] = Presets[ presetname ][ strName ]
+	Presets[ presetname ][ strName ] = nil
+
+	-- Only save the specific preset group, not ALL of them
+	SavePresets( { [ presetname ] = Presets[ presetname ] } )
+
+end
+
+function Remove( presetname, strName )
+
+	if ( !presetname || !strName ) then return end
+	presetname = presetname:Trim()
+	strName = strName:Trim()
+	if ( presetname == "" || strName == "" ) then return end
+
+	Presets[ presetname ] = Presets[ presetname ] or {}
+	Presets[ presetname ][ strName ] = nil
+
+	-- Only save the specific preset group, not ALL of them
+	SavePresets( { [ presetname ] = Presets[ presetname ] } )
+
+end
+
+-- Internal helper functions to not copypaste same code
+function BadNameAlert()
+
+	Derma_Message( "#preset.badname_desc", "#preset.badname_title", "#preset.okay" )
+
+end
+
+function OverwritePresetPrompt( func )
+
+	Derma_Query( "#preset.exists_desc", "#preset.exists_title", "#preset.overwrite", func, "#preset.cancel" )
+
+end

lua/includes/modules/properties.lua

@@ -0,0 +1,254 @@
+
+module( "properties", package.seeall )
+
+local meta = {
+	MsgStart = function( self )
+
+		net.Start( "properties" )
+		net.WriteString( self.InternalName )
+
+	end,
+
+	MsgEnd = function( self )
+
+		net.SendToServer()
+
+	end
+}
+
+meta.__index = meta
+
+List = {}
+-- .MenuLabel				[string]	Label to show on opened menu
+-- .Filter( ent )			[function]	Return true if we should show a menu for this entity
+-- .Action( ent )			[function]	On menu choice selected
+-- .Order					[int]		The order in which it should be shown on the menu
+-- .Receive( len, ply )		[function]	A message has been received from the clientside version
+
+function Add( name, tab )
+
+	name = name:lower()
+	tab.InternalName = name
+	setmetatable( tab, meta )
+
+	List[ name ] = tab
+
+end
+
+function Remove( name )
+
+	if ( !name || name == "" ) then return end
+
+	name = name:lower()
+
+	if ( !List[ name ] ) then return end
+
+	List[ name ] = nil
+
+end
+
+local function AddToggleOption( data, menu, ent, ply, tr )
+
+	if ( !menu.ToggleSpacer ) then
+		menu.ToggleSpacer = menu:AddSpacer()
+		menu.ToggleSpacer:SetZPos( 500 )
+	end
+
+	local option = menu:AddOption( data.MenuLabel, function() data:Action( ent, tr ) end )
+	option:SetChecked( data:Checked( ent, ply ) )
+	option:SetZPos( 501 )
+	return option
+
+end
+
+local function AddOption( data, menu, ent, ply, tr )
+
+	if ( data.Type == "toggle" ) then return AddToggleOption( data, menu, ent, ply, tr ) end
+
+	if ( data.PrependSpacer ) then
+		menu:AddSpacer()
+	end
+
+	local option = menu:AddOption( data.MenuLabel, function() data:Action( ent, tr ) end )
+
+	if ( data.MenuIcon ) then
+		option:SetImage( data.MenuIcon )
+	end
+
+	if ( data.MenuOpen ) then
+		data.MenuOpen( data, option, ent, tr )
+	end
+
+	return option
+
+end
+
+function OpenEntityMenu( ent, tr )
+
+	local menu = DermaMenu()
+
+	for k, v in SortedPairsByMemberValue( List, "Order" ) do
+
+		if ( !v.Filter ) then continue end
+		if ( !v:Filter( ent, LocalPlayer() ) ) then continue end
+
+		local option = AddOption( v, menu, ent, LocalPlayer(), tr )
+
+		if ( v.OnCreate ) then v:OnCreate( menu, option ) end
+
+	end
+
+	menu:Open()
+
+end
+
+function OnScreenClick( eyepos, eyevec )
+
+	local ent, tr = GetHovered( eyepos, eyevec )
+	if ( !IsValid( ent ) ) then return end
+
+	OpenEntityMenu( ent, tr )
+
+end
+
+-- Use this check in your properties to see if given entity can be affected by it
+-- Ideally this should be done automatically for you, but due to how this system was set up, its now impossible
+function CanBeTargeted( ent, ply )
+	if ( !IsValid( ent ) ) then return false end
+	if ( ent:IsPlayer() ) then return false end
+
+	-- Check the range if player object is given
+	-- This is not perfect, but it is close enough and its definitely better than nothing
+	if ( IsValid( ply ) ) then
+		local mins = ent:OBBMins()
+		local maxs = ent:OBBMaxs()
+		local maxRange = math.max( math.abs( mins.x ) + maxs.x, math.abs( mins.y ) + maxs.y, math.abs( mins.z ) + maxs.z )
+		local pos = ent:LocalToWorld( ent:OBBCenter() ) --ent:GetPos()
+
+		if ( pos:Distance( ply:GetShootPos() ) > maxRange + 1024 ) then return false end
+	end
+
+	return !( ent:GetPhysicsObjectCount() < 1 && ent:GetSolid() == SOLID_NONE && bit.band( ent:GetSolidFlags(), FSOLID_USE_TRIGGER_BOUNDS ) == 0 && bit.band( ent:GetSolidFlags(), FSOLID_CUSTOMRAYTEST ) == 0 )
+end
+
+function GetHovered( eyepos, eyevec )
+
+	local ply = LocalPlayer()
+	local filter = ply:GetViewEntity()
+
+	if ( filter == ply ) then
+		local veh = ply:GetVehicle()
+
+		if ( veh:IsValid() && ( !veh:IsVehicle() || !veh:GetThirdPersonMode() ) ) then
+			-- A dirty hack for prop_vehicle_crane. util.TraceLine returns the vehicle but it hits phys_bone_follower - something that needs looking into
+			filter = { filter, veh, unpack( ents.FindByClass( "phys_bone_follower" ) ) }
+		end
+	end
+
+	local trace = util.TraceLine( {
+		start = eyepos,
+		endpos = eyepos + eyevec * 1024,
+		filter = filter
+	} )
+
+	-- Hit COLLISION_GROUP_DEBRIS and stuff
+	if ( !trace.Hit || !IsValid( trace.Entity ) ) then
+		trace = util.TraceLine( {
+			start = eyepos,
+			endpos = eyepos + eyevec * 1024,
+			filter = filter,
+			mask = MASK_ALL
+		} )
+	end
+
+	if ( !trace.Hit || !IsValid( trace.Entity ) ) then return end
+
+	return trace.Entity, trace
+
+end
+
+-- Receives commands from clients
+if ( SERVER ) then
+
+	util.AddNetworkString( "properties" )
+
+	net.Receive( "properties", function( len, client )
+		if ( !IsValid( client ) ) then return end
+
+		local name = net.ReadString()
+		if ( !name ) then return end
+
+		local prop = List[ name ]
+		if ( !prop ) then return end
+		if ( !prop.Receive ) then return end
+
+		prop:Receive( len, client )
+
+	end )
+
+end
+
+if ( CLIENT ) then
+
+	hook.Add( "PreDrawHalos", "PropertiesHover", function()
+
+		if ( !IsValid( vgui.GetHoveredPanel() ) || !vgui.GetHoveredPanel():IsWorldClicker() ) then return end
+
+		-- TODO: Remove this hack when every client has MainEyePos
+		local ent = GetHovered( MainEyePos and MainEyePos() or EyePos(), LocalPlayer():GetAimVector() )
+		if ( !IsValid( ent ) ) then return end
+
+		local c = Color( 255, 255, 255, 255 )
+		c.r = 200 + math.sin( RealTime() * 50 ) * 55
+		c.g = 200 + math.sin( RealTime() * 20 ) * 55
+		c.b = 200 + math.cos( RealTime() * 60 ) * 55
+
+		local t = { ent }
+		if ( ent.GetActiveWeapon && IsValid( ent:GetActiveWeapon() ) ) then table.insert( t, ent:GetActiveWeapon() ) end
+		halo.Add( t, c, 2, 2, 2, true, false )
+
+	end )
+
+	hook.Add( "GUIMousePressed", "PropertiesClick", function( code, vector )
+
+		if ( !IsValid( vgui.GetHoveredPanel() ) || !vgui.GetHoveredPanel():IsWorldClicker() ) then return end
+
+		if ( code == MOUSE_RIGHT && !input.IsButtonDown( MOUSE_LEFT ) ) then
+			OnScreenClick( MainEyePos and MainEyePos() or EyePos(), vector )
+		end
+
+	end )
+
+	local wasPressed = false
+	hook.Add( "PreventScreenClicks", "PropertiesPreventClicks", function()
+
+		if ( !input.IsButtonDown( MOUSE_RIGHT ) ) then wasPressed = false end
+
+		if ( wasPressed && input.IsButtonDown( MOUSE_RIGHT ) && !input.IsButtonDown( MOUSE_LEFT ) ) then return true end
+
+		if ( !IsValid( vgui.GetHoveredPanel() ) || !vgui.GetHoveredPanel():IsWorldClicker() ) then return end
+
+		local ply = LocalPlayer()
+		if ( !IsValid( ply ) ) then return end
+
+		--
+		-- Are we pressing the right mouse button?
+		-- (We check whether we're pressing the left too, to allow for physgun freezes)
+		--
+		if ( input.IsButtonDown( MOUSE_RIGHT ) && !input.IsButtonDown( MOUSE_LEFT ) ) then
+
+			--
+			-- Are we hovering an entity? If so, then stomp the action
+			--
+			local hovered = GetHovered( MainEyePos and MainEyePos() or EyePos(), ply:GetAimVector() )
+
+			if ( IsValid( hovered ) ) then
+				wasPressed = true
+				return true
+			end
+
+		end
+
+	end )
+
+end

lua/includes/modules/saverestore.lua

@@ -0,0 +1,428 @@
+
+local Msg			= Msg
+local type			= type
+local pairs			= pairs
+local gmod			= gmod
+local table			= table
+
+--[[
+
+	This module is to help bind the engine's saverestore stuff to Lua.
+
+	This is so we can save Lua stuff in the save game file. The entities
+	should automatically save most of their table contents to the save file.
+
+	!!Warning!!: Editing this file may render old saves useless.
+
+	You can hook into this system like so
+
+	local function MySaveFunction( save )
+		saverestore.WriteTable( my_table, save )
+	end
+
+	local function MyRestoreFunction( restore )
+		my_table = saverestore.ReadTable( restore )
+	end
+
+	saverestore.AddSaveHook( "HookNameHere", MySaveFunction )
+	saverestore.AddRestoreHook( "HookNameHere", MyRestoreFunction )
+
+--]]
+
+module( "saverestore" )
+
+local TYPE_NONE		= 0
+local TYPE_FLOAT	= 1 -- Treat all numbers as floats (they're all the same to Lua)
+local TYPE_STRING	= 2
+local TYPE_ENTITY	= 3
+local TYPE_VECTOR	= 4
+local TYPE_TABLE	= 5
+local TYPE_BOOL		= 6
+local TYPE_ANGLE	= 7
+
+local SaveHooks = {}
+local RestoreHooks = {}
+local TableRefs = {}
+local TableRef = 1
+
+function PreSave()
+
+	TableRefs = {}
+	TableRef = 1
+
+end
+
+function PreRestore()
+
+	TableRefs = {}
+	TableRef = 1
+
+end
+
+--[[---------------------------------------------------------
+	Name: GetTypeStr
+	Desc: Given a string returns a TYPE_
+-----------------------------------------------------------]]
+local function GetTypeStr( name )
+
+	if ( name == "function" ) then return TYPE_NONE end
+
+	if ( name == "number" ) then return TYPE_FLOAT end
+	if ( name == "string" ) then return TYPE_STRING end
+	if ( name == "Entity" ) then return TYPE_ENTITY end
+	if ( name == "Vehicle" ) then return TYPE_ENTITY end
+	if ( name == "NPC" ) then return TYPE_ENTITY end
+	if ( name == "Player" ) then return TYPE_ENTITY end
+	if ( name == "Weapon" ) then return TYPE_ENTITY end
+	if ( name == "Vector" ) then return TYPE_VECTOR end
+	if ( name == "Angle" ) then return TYPE_ANGLE end
+	if ( name == "table" ) then return TYPE_TABLE end
+	if ( name == "boolean" ) then return TYPE_BOOL end
+
+	-- These aren't saved
+	if ( name == "ConVar" ) then return TYPE_NONE end
+	if ( name == "PhysObj" ) then return TYPE_NONE end
+
+	-- Bitch about it incase I've forgot to hook a savable type up
+	Msg( "Can't save or load unknown type " .. name .. "\n" )
+	return TYPE_NONE
+
+end
+
+--[[---------------------------------------------------------
+	Name: GetType
+	Desc: Given a variable returns a TYPE_
+-----------------------------------------------------------]]
+local function GetType( var )
+
+	return GetTypeStr( type(var) )
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: IsWritable
+	Desc: Returns true if we can save the K/V pair
+-----------------------------------------------------------]]
+local function IsWritable( k, v )
+
+	local itype = GetType( k )
+	if ( itype == TYPE_NONE ) then return false end
+	if ( itype == TYPE_STRING && k == "SR_Recursion" ) then return false end
+
+	local itype = GetType( v )
+	if ( itype == TYPE_NONE ) then return false end
+
+	return true
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: WriteVar
+	Desc: Writes a single variable to the save
+-----------------------------------------------------------]]
+function WritableKeysInTable( t )
+
+	local i = 0
+
+	for k, v in pairs( t ) do
+		if ( IsWritable( k, v ) ) then
+			i = i + 1
+		end
+	end
+
+	return i
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: WriteVar
+	Desc: Writes a single variable to the save
+-----------------------------------------------------------]]
+function WriteVar( var, save )
+
+	local itype = GetType( var )
+	if ( itype == TYPE_NONE ) then return end
+
+	save:StartBlock( type( var ) )
+
+		if ( itype == TYPE_FLOAT ) then
+			save:WriteFloat( var )
+		elseif ( itype == TYPE_BOOL ) then
+			save:WriteBool( var )
+		elseif ( itype == TYPE_STRING ) then
+			save:WriteString( var )
+		elseif ( itype == TYPE_ENTITY ) then
+			save:WriteEntity( var )
+		elseif ( itype == TYPE_ANGLE ) then
+			save:WriteAngle( var )
+		elseif ( itype == TYPE_VECTOR ) then
+			save:WriteVector( var )
+		elseif ( itype == TYPE_TABLE ) then
+			WriteTable( var, save )
+		else
+			Msg( "Error! Saving unsupported Type: " .. type( var ) .. "\n" )
+		end
+
+	save:EndBlock()
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: ReadVar
+	Desc: Reads a single variable
+-----------------------------------------------------------]]
+function ReadVar( restore )
+
+	local retval = 0
+	local typename = restore:StartBlock()
+
+		local itype = GetTypeStr( typename )
+
+		if ( itype == TYPE_FLOAT ) then
+			retval = restore:ReadFloat()
+		elseif ( itype == TYPE_BOOL ) then
+			retval = restore:ReadBool()
+		elseif ( itype == TYPE_STRING ) then
+			retval = restore:ReadString()
+		elseif ( itype == TYPE_ENTITY ) then
+			retval = restore:ReadEntity()
+		elseif ( itype == TYPE_ANGLE ) then
+			retval = restore:ReadAngle()
+		elseif ( itype == TYPE_VECTOR ) then
+			retval = restore:ReadVector()
+		elseif ( itype == TYPE_TABLE ) then
+			retval = ReadTable( restore )
+		else
+			Msg( "Error! Loading unsupported Type: " .. typename .. "\n" )
+		end
+
+	restore:EndBlock()
+
+	return retval
+
+end
+
+--[[---------------------------------------------------------
+	Name: WriteTable
+	Desc: Writes a table to the save
+-----------------------------------------------------------]]
+function WriteTable( tab, save )
+
+	-- Write a blank table (because read will be expecting one)
+	if ( tab == nil ) then
+
+		save:StartBlock( "Table" )
+		save:EndBlock()
+
+	end
+
+	-- We have already saved this table
+	if ( TableRefs[ tab ] ) then
+
+		save:StartBlock( "TableRef" )
+			save:WriteInt( TableRefs[ tab ] )
+		save:EndBlock()
+
+		return
+
+	end
+
+	TableRefs[ tab ] = TableRef
+
+	save:StartBlock( "Table" )
+
+		local iCount = WritableKeysInTable( tab )
+
+		save:WriteInt( TableRef )
+		TableRef = TableRef + 1
+
+		save:WriteInt( iCount )
+
+		for k, v in pairs( tab ) do
+
+			if ( IsWritable( k, v ) ) then
+
+				WriteVar( k, save )
+				WriteVar( v, save )
+
+			end
+
+		end
+
+	save:EndBlock()
+
+end
+
+--[[---------------------------------------------------------
+	Name: ReadTable
+	Desc: Assumes a table is waiting to be read, returns a table
+-----------------------------------------------------------]]
+function ReadTable( restore )
+
+	local name = restore:StartBlock()
+	local tab = {}
+
+	if ( name == "TableRef" ) then
+
+		local ref = restore:ReadInt()
+		if ( !TableRefs[ ref ] ) then
+			TableRefs[ ref ] = {}
+			restore:EndBlock()
+			ErrorNoHaltWithStack( "Failed to read SaveRestore table!" )
+			return
+		end
+
+		tab = TableRefs[ ref ]
+
+	else
+
+		local iRef = restore:ReadInt()
+		local iCount = restore:ReadInt()
+
+		if ( TableRefs[ iRef ] ) then
+			tab = TableRefs[ iRef ]
+		end
+
+		for i = 0, iCount - 1 do
+
+			local k = ReadVar( restore )
+			local v = ReadVar( restore )
+			tab[ k ] = v
+
+		end
+
+		TableRefs[ iRef ] = tab
+
+	end
+
+	restore:EndBlock()
+
+	return tab
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: SaveEntity
+	Desc: Called by the engine for each entity
+-----------------------------------------------------------]]
+function SaveEntity( ent, save )
+
+	save:StartBlock( "EntityTable" )
+
+		WriteTable( ent:GetTable(), save )
+
+	save:EndBlock()
+
+end
+
+--[[---------------------------------------------------------
+	Name: LoadEntity
+	Desc: Called by the engine for each entity
+-----------------------------------------------------------]]
+function LoadEntity( ent, restore )
+
+	local EntTable = ent:GetTable()
+
+	local name = restore:StartBlock()
+
+		if ( name == "EntityTable" ) then
+
+			table.Merge( EntTable, ReadTable( restore ) )
+
+		end
+
+	restore:EndBlock()
+
+	ent:SetTable( EntTable )
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: AddSaveHook
+	Desc: Adds a hook enabling something to save something..
+-----------------------------------------------------------]]
+function AddSaveHook( name, func )
+
+	local h = {}
+	h.Name = name
+	h.Func = func
+	SaveHooks[ name ] = h
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: AddRestoreHook
+	Desc: Adds a hook enabling something to restore something..
+-----------------------------------------------------------]]
+function AddRestoreHook( name, func )
+
+	local h = {}
+	h.Name = name
+	h.Func = func
+	RestoreHooks[ name ] = h
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: SaveGlobal
+	Desc: Should save any Lua stuff that isn't entity based.
+-----------------------------------------------------------]]
+function SaveGlobal( save )
+
+	save:StartBlock( "GameMode" )
+		WriteTable( gmod.GetGamemode(), save )
+	save:EndBlock()
+
+	for k, v in pairs( SaveHooks ) do
+
+		save:StartBlock( v.Name )
+
+			v.Func( save )
+
+		save:EndBlock()
+
+	end
+
+end
+
+
+--[[---------------------------------------------------------
+	Name: LoadGlobal
+	Desc: ...
+-----------------------------------------------------------]]
+function LoadGlobal( restore )
+
+	local name = restore:StartBlock()
+
+		if ( name == "GameMode" ) then
+			table.Merge( gmod.GetGamemode(), ReadTable( restore ) )
+		end
+
+	restore:EndBlock()
+
+
+	while ( name != "EndGlobal" ) do
+
+		name = restore:StartBlock()
+
+			local tab = RestoreHooks[ name ]
+			if ( tab ) then
+
+				tab.Func( restore )
+
+			end
+
+		restore:EndBlock()
+
+	end
+
+end
+

lua/includes/modules/scripted_ents.lua

@@ -0,0 +1,278 @@
+
+--[[---------------------------------------------------------
+	Name: scripted_ents
+	Desc: Scripted Entity factory
+-----------------------------------------------------------]]
+
+module( "scripted_ents", package.seeall )
+
+local Aliases = {}
+local SEntList = {}
+
+local BaseClasses = {}
+BaseClasses[ "anim" ] = "base_anim"
+BaseClasses[ "point" ] = "base_point"
+BaseClasses[ "brush" ] = "base_brush"
+BaseClasses[ "filter" ] = "base_filter"
+
+--[[---------------------------------------------------------
+	Name: TableInherit( t, base )
+	Desc: Copies any missing data from base to t
+-----------------------------------------------------------]]
+local function TableInherit( t, base )
+
+	for k, v in pairs( base ) do
+
+		if ( t[ k ] == nil ) then
+			t[ k ] = v
+		elseif ( k != "BaseClass" && istable( t[ k ] ) && istable( v ) ) then
+			TableInherit( t[ k ], v )
+		end
+
+	end
+
+	t[ "BaseClass" ] = base
+
+	return t
+
+end
+
+--[[---------------------------------------------------------
+	Name: IsBasedOn( name, base )
+	Desc: Checks if name is based on base
+-----------------------------------------------------------]]
+function IsBasedOn( name, base )
+	local t = GetStored( name )
+	if not t then return false end
+	if t.Base == name then return false end
+
+	if t.Base == base then return true end
+	return IsBasedOn( t.Base, base )
+end
+
+function Register( t, name )
+
+	if ( hook.Run( "PreRegisterSENT", t, name ) == false ) then return end
+
+	if ( isstring( t.ClassNameOverride ) ) then name = t.ClassNameOverride end
+
+	local Base = t.Base
+	if ( !Base ) then Base = BaseClasses[ t.Type ] end
+
+	local old = SEntList[ name ]
+	local tab = {}
+
+	tab.type		= t.Type
+	tab.t			= t
+	tab.isBaseType	= true
+	tab.Base		= Base
+	tab.t.ClassName	= name
+
+	if ( !Base ) then
+		Msg( "WARNING: Scripted entity " .. name .. " has an invalid base entity!\n" )
+	end
+
+	SEntList[ name ] = tab
+
+	-- Allow all SENTS to be duplicated, unless specified
+	if ( !t.DisableDuplicator ) then
+		duplicator.Allow( name )
+	end
+
+	--
+	-- If we're reloading this entity class
+	-- then refresh all the existing entities.
+	--
+	if ( old != nil ) then
+
+		--
+		-- For each entity using this class
+		--
+		for _, entity in ipairs( ents.FindByClass( name ) ) do
+
+			--
+			-- Replace the contents with this entity table
+			--
+			table.Merge( entity, tab.t )
+
+			--
+			-- Call OnReloaded hook (if it has one)
+			--
+			if ( entity.OnReloaded ) then
+				entity:OnReloaded()
+			end
+
+		end
+
+		-- Update entity table of entities that are based on this entity
+		for _, e in ipairs( ents.GetAll() ) do
+			if ( IsBasedOn( e:GetClass(), name ) ) then
+
+				table.Merge( e, Get( e:GetClass() ) )
+
+				if ( e.OnReloaded ) then
+					e:OnReloaded()
+				end
+			end
+		end
+
+	end
+
+	if ( !t.Spawnable ) then return end
+
+	list.Set( "SpawnableEntities", name, {
+		-- Required information
+		PrintName		= t.PrintName,
+		ClassName		= name,
+		Category		= t.Category,
+
+		-- Optional information
+		NormalOffset	= t.NormalOffset,
+		DropToFloor		= t.DropToFloor,
+		Author			= t.Author,
+		AdminOnly		= t.AdminOnly,
+		Information		= t.Information,
+		ScriptedEntityType = t.ScriptedEntityType,
+		IconOverride	= t.IconOverride
+	} )
+
+end
+
+--
+-- All scripts have been loaded...
+--
+function OnLoaded()
+
+	--
+	-- Once all the scripts are loaded we can set up the baseclass
+	-- - we have to wait until they're all setup because load order
+	-- could cause some entities to load before their bases!
+	--
+	for k, v in pairs( SEntList ) do
+
+		baseclass.Set( k, Get( k ) )
+
+	end
+
+end
+
+function Get( name, retval )
+
+	-- Do we have an alias?
+	if ( Aliases[ name ] ) then
+		name = Aliases[ name ]
+	end
+
+	if ( SEntList[ name ] == nil ) then return nil end
+
+	-- Create/copy a new table
+	local retval = retval or {}
+	for k, v in pairs( SEntList[ name ].t ) do
+		if ( istable( v ) ) then
+			retval[ k ] = table.Copy( v )
+		else
+			retval[ k ] = v
+		end
+	end
+
+	-- Derive from base class
+	if ( SEntList[ name ].Base != name ) then
+
+		local base = Get( SEntList[ name ].Base )
+
+		if ( !base ) then
+			Msg("ERROR: Trying to derive entity " .. tostring( name ) .. " from non existant entity " .. tostring( SEntList[ name ].Base ) .. "!\n" )
+		else
+			retval = TableInherit( retval, base )
+		end
+
+	end
+
+	return retval
+
+end
+
+function GetType( name )
+
+	for k, v in pairs( BaseClasses ) do
+		if ( name == v ) then return k end
+	end
+
+	local ent = SEntList[ name ]
+	if ( ent == nil ) then return nil end
+
+	if ( ent.type ) then
+		return ent.type
+	end
+
+	if ( ent.Base ) then
+		return GetType( ent.Base )
+	end
+
+	return nil
+
+end
+
+--[[---------------------------------------------------------
+	Name: GetStored( string )
+	Desc: Gets the REAL sent table, not a copy
+-----------------------------------------------------------]]
+function GetStored( name )
+	return SEntList[ name ]
+end
+
+--[[---------------------------------------------------------
+	Name: GetList( string )
+	Desc: Get a list of all the registered SENTs
+-----------------------------------------------------------]]
+function GetList()
+	local result = {}
+
+	for k,v in pairs( SEntList ) do
+		result[ k ] = v
+	end
+
+	return result
+end
+
+function GetSpawnable()
+
+	local result = {}
+
+	for k, v in pairs( SEntList ) do
+
+		local tab = v.t
+
+		if ( tab.Spawnable ) then
+			table.insert( result, tab )
+		end
+
+	end
+
+	return result
+
+end
+
+function Alias( From, To )
+
+	Aliases[ From ] = To
+
+end
+
+function GetMember( entity_name, membername )
+
+	if ( !entity_name ) then return end
+
+	local ent = SEntList[ entity_name ]
+
+	if ( !ent ) then return end
+
+	local member = ent.t[ membername ]
+	if ( member != nil ) then return member end
+
+	-- If our base is the same as us - don't infinite loop!
+	if ( entity_name == ent.Base ) then return end
+
+	return GetMember( ent.Base, membername )
+
+end

lua/includes/modules/search.lua

@@ -0,0 +1,49 @@
+
+module( "search", package.seeall )
+
+local Providers = {}
+
+function AddProvider( func, id )
+
+	local prov = {
+		func = func,
+	}
+
+	if ( id ) then
+		Providers[ id ] = prov
+	else
+		table.insert( Providers, prov )
+	end
+
+end
+
+function GetResults( str, types, maxResults )
+
+	if ( !maxResults || maxResults < 1 ) then maxResults = 1024 end
+
+	local str = str:lower()
+	if ( str == "" ) then return {} end
+
+	local results = {}
+
+	for k, v in pairs( Providers ) do
+		if ( isstring( types ) ) then
+			if ( types != k ) then continue end
+		elseif ( istable( types ) ) then
+			if ( !table.HasValue( types, k ) ) then continue end
+		end
+
+		local tbl = v.func( str )
+		for _, e in pairs( tbl ) do
+			table.insert( results, e )
+		end
+
+		if ( #results >= maxResults ) then break end
+
+	end
+
+	-- Todo. Sort, weighted?
+
+	return results
+
+end

lua/includes/modules/spawnmenu.lua

@@ -0,0 +1,311 @@
+
+local spawnmenu_engine = spawnmenu
+
+module( "spawnmenu", package.seeall )
+
+local g_ToolMenu = {}
+local CreationMenus = {}
+local PropTable = {}
+local PropTableCustom = {}
+
+local ActiveToolPanel = nil
+local ActiveSpawnlistID = 1000
+
+--[[---------------------------------------------------------
+
+	Tool Tabs
+
+-----------------------------------------------------------]]
+
+function SetActiveControlPanel( pnl )
+	ActiveToolPanel = pnl
+end
+
+function ActiveControlPanel()
+	return ActiveToolPanel
+end
+
+function GetTools()
+	return g_ToolMenu
+end
+
+function GetToolMenu( name, label, icon )
+
+	--
+	-- This is a dirty hack so that Main stays at the front of the tabs.
+	--
+	if ( name == "Main" ) then name = "AAAAAAA_Main" end
+
+	label = label or name
+	icon = icon or "icon16/wrench.png"
+
+	for k, v in ipairs( g_ToolMenu ) do
+
+		if ( v.Name == name ) then return v.Items end
+
+	end
+
+	local NewMenu = { Name = name, Items = {}, Label = label, Icon = icon }
+	table.insert( g_ToolMenu, NewMenu )
+
+	--
+	-- Order the tabs by NAME
+	--
+	table.SortByMember( g_ToolMenu, "Name", true )
+
+	return NewMenu.Items
+
+end
+
+function ClearToolMenus()
+
+	g_ToolMenu = {}
+
+end
+
+function AddToolTab( strName, strLabel, Icon )
+
+	GetToolMenu( strName, strLabel, Icon )
+
+end
+
+function SwitchToolTab( id )
+
+	local Tab = g_SpawnMenu:GetToolMenu():GetToolPanel( id )
+	if ( !IsValid( Tab ) or !IsValid( Tab.PropertySheetTab ) ) then return end
+
+	Tab.PropertySheetTab:DoClick()
+
+end
+
+function ActivateToolPanel( tabId, ctrlPnl, toolName )
+
+	local Tab = g_SpawnMenu:GetToolMenu():GetToolPanel( tabId )
+	if ( !IsValid( Tab ) ) then return end
+
+	spawnmenu.SetActiveControlPanel( ctrlPnl )
+
+	if ( ctrlPnl ) then
+		Tab:SetActive( ctrlPnl )
+	end
+
+	SwitchToolTab( tabId )
+
+	if ( toolName && Tab.SetActiveToolText ) then
+		Tab:SetActiveToolText( toolName )
+	end
+
+end
+
+-- While technically tool class names CAN be duplicate, it normally should never happen.
+function ActivateTool( strName, noCommand )
+
+	-- I really don't like this triple loop
+	for tab, v in ipairs( g_ToolMenu ) do
+		for _, category in pairs( v.Items ) do
+			for _, item in pairs( category ) do
+
+				if ( istable( item ) && item.ItemName && item.ItemName == strName ) then
+
+					if ( !noCommand && item.Command && string.len( item.Command ) > 1 ) then
+						RunConsoleCommand( unpack( string.Explode( " ", item.Command ) ) )
+					end
+
+					local cp = controlpanel.Get( strName )
+					if ( !cp:GetInitialized() ) then
+						cp:FillViaTable( { Text = item.Text, ControlPanelBuildFunction = item.CPanelFunction } )
+					end
+
+					ActivateToolPanel( tab, cp, strName )
+
+					return
+
+				end
+
+			end
+		end
+	end
+
+end
+
+function AddToolCategory( tab, RealName, PrintName )
+
+	local Menu = GetToolMenu( tab )
+
+	-- Does this category already exist?
+	for k, v in ipairs( Menu ) do
+
+		if ( v.Text == PrintName ) then return end
+		if ( v.ItemName == RealName ) then return end
+
+	end
+
+	table.insert( Menu, { Text = PrintName, ItemName = RealName } )
+
+end
+
+function AddToolMenuOption( tab, category, itemname, text, command, controls, cpanelfunction, TheTable )
+
+	local Menu = GetToolMenu( tab )
+	local CategoryTable = nil
+
+	for k, v in ipairs( Menu ) do
+		if ( v.ItemName && v.ItemName == category ) then CategoryTable = v break end
+	end
+
+	-- No table found.. lets create one
+	if ( !CategoryTable ) then
+		CategoryTable = { Text = "#" .. category, ItemName = category }
+		table.insert( Menu, CategoryTable )
+	end
+
+	TheTable = TheTable or {}
+
+	TheTable.ItemName = itemname
+	TheTable.Text = text
+	TheTable.Command = command
+	TheTable.Controls = controls
+	TheTable.CPanelFunction = cpanelfunction
+
+	table.insert( CategoryTable, TheTable )
+
+	-- Keep the table sorted
+	table.SortByMember( CategoryTable, "Text", true )
+
+end
+
+--[[---------------------------------------------------------
+
+	Creation Tabs
+
+-----------------------------------------------------------]]
+function AddCreationTab( strName, pFunction, pMaterial, iOrder, strTooltip )
+
+	iOrder = iOrder or 1000
+
+	pMaterial = pMaterial or "icon16/exclamation.png"
+
+	CreationMenus[ strName ] = { Function = pFunction, Icon = pMaterial, Order = iOrder, Tooltip = strTooltip }
+
+end
+
+function GetCreationTabs()
+
+	return CreationMenus
+
+end
+
+function SwitchCreationTab( id )
+
+	local tab = g_SpawnMenu:GetCreationMenu():GetCreationTab( id )
+	if ( !tab or !IsValid( tab.Tab ) ) then return end
+
+	tab.Tab:DoClick()
+
+end
+
+--[[---------------------------------------------------------
+
+	Spawn lists
+
+-----------------------------------------------------------]]
+function GetPropTable()
+
+	return PropTable
+
+end
+
+function GetCustomPropTable()
+
+	return PropTableCustom
+
+end
+
+function AddPropCategory( strFilename, strName, tabContents, icon, id, parentid, needsapp )
+
+	PropTableCustom[ strFilename ] = {
+		name = strName,
+		contents = tabContents,
+		icon = icon,
+		id = id or ActiveSpawnlistID,
+		parentid = parentid or 0,
+		needsapp = needsapp
+	}
+
+	if ( !id ) then ActiveSpawnlistID = ActiveSpawnlistID + 1 end
+
+end
+
+-- Populate the spawnmenu from the text files (engine)
+function PopulateFromEngineTextFiles()
+
+	-- Reset the already loaded prop list before loading them again.
+	-- This caused the spawnlists to duplicate into crazy trees when spawnmenu_reload'ing after saving edited spawnlists
+	PropTable = {}
+
+	spawnmenu_engine.PopulateFromTextFiles( function( strFilename, strName, tabContents, icon, id, parentid, needsapp )
+		PropTable[ strFilename ] = {
+			name = strName,
+			contents = tabContents,
+			icon = icon,
+			id = id,
+			parentid = parentid or 0,
+			needsapp = needsapp
+		}
+	end )
+
+end
+
+-- Save the spawnfists to text files (engine)
+function DoSaveToTextFiles( props )
+
+	spawnmenu_engine.SaveToTextFiles( props )
+
+end
+
+--[[
+
+Content Providers
+
+Functions that populate the spawnmenu from the spawnmenu txt files.
+
+function MyFunction( ContentPanel, ObjectTable )
+
+	local myspawnicon = CreateSpawnicon( ObjectTable.model )
+	ContentPanel:AddItem( myspawnicon )
+
+end
+
+spawnmenu.AddContentType( "model", MyFunction )
+
+--]]
+
+local cp = {}
+
+function AddContentType( name, func )
+	cp[ name ] = func
+end
+
+function GetContentType( name )
+
+	if ( !name ) then
+		ErrorNoHaltWithStack( "spawnmenu.GetContentType got an invalid value\n" )
+		return
+	end
+
+	if ( !cp[ name ] ) then
+
+		cp[ name ] = function() end
+		Msg( "spawnmenu.GetContentType( ", name, " ) - not found!\n" )
+
+	end
+
+	return cp[ name ]
+end
+
+function CreateContentIcon( type, parent, tbl )
+
+	local ctrlpnl = GetContentType( type )
+	if ( ctrlpnl ) then return ctrlpnl( parent, tbl ) end
+
+end

lua/includes/modules/team.lua

@@ -0,0 +1,223 @@
+module( "team", package.seeall )
+
+local TeamInfo = {}
+local DefaultColor = Color( 255, 255, 100, 255 )
+
+TeamInfo[TEAM_CONNECTING] 	= { Name = "Joining/Connecting", 	Color = DefaultColor, 	Score = 0, 	Joinable = false }
+TeamInfo[TEAM_UNASSIGNED] 	= { Name = "Unassigned", 			Color = DefaultColor, 	Score = 0, 	Joinable = false }
+TeamInfo[TEAM_SPECTATOR] 	= { Name = "Spectator", 			Color = DefaultColor, 	Score = 0, 	Joinable = true }
+
+--[[------------------------------------------------------------
+
+	Call this to set up your team. It should be called in
+	a shared file. This system assumes that your teams are
+	static. If you want to have dynamic teams you need to
+	code this yourself.
+
+	id should be a number. It's best to do something like
+
+	TEAM_TERRORISTS = 2
+
+	at the top of your code somewhere so you can reference
+	teams via a variable rather than a number.
+
+--------------------------------------------------------------]]
+function SetUp( id, name, color, joinable )
+
+	if ( joinable == nil ) then joinable = true end
+
+	TeamInfo[id] = { Name = name, Color = color, Score = 0, Joinable = joinable }
+
+end
+
+
+function GetAllTeams()
+
+	return TeamInfo -- copyof?
+
+end
+
+function Valid( id )
+
+	if ( !TeamInfo[id] ) then return false end
+	return true
+
+end
+
+function Joinable( id )
+
+	if ( !TeamInfo[id] ) then return false end
+	return TeamInfo[id].Joinable
+
+end
+
+function GetSpawnPoint( id )
+
+	if ( !TeamInfo[id] ) then return end
+	return TeamInfo[id].SpawnPointTable
+
+end
+
+function GetSpawnPoints( id )
+
+	if ( IsTableOfEntitiesValid( TeamInfo[id].SpawnPoints ) ) then return TeamInfo[id].SpawnPoints end
+
+	local SpawnPointTable = team.GetSpawnPoint( id )
+	if ( !SpawnPointTable ) then return end
+
+	TeamInfo[id].SpawnPoints = {}
+
+	for k, entname in pairs( SpawnPointTable ) do
+
+		TeamInfo[id].SpawnPoints = table.Add( TeamInfo[id].SpawnPoints, ents.FindByClass( entname ) )
+
+	end
+
+	return TeamInfo[id].SpawnPoints
+
+end
+
+function SetSpawnPoint( id, ent_name )
+
+	if ( !TeamInfo[id] ) then return end
+	if ( !istable( ent_name ) ) then ent_name = { ent_name } end
+
+	TeamInfo[id].SpawnPointTable = ent_name
+
+end
+
+function SetClass( id, classtable )
+
+	if ( !TeamInfo[id] ) then return end
+	if ( !istable( classtable ) ) then classtable = { classtable } end
+
+	TeamInfo[id].SelectableClasses = classtable
+
+end
+
+function GetClass( id )
+
+	if ( !TeamInfo[id] ) then return end
+	return TeamInfo[id].SelectableClasses
+
+end
+
+function TotalDeaths( index )
+
+	local score = 0
+
+	for _, ply in ipairs(player.GetAll()) do
+		if ( ply:Team() == index ) then
+			score = score + ply:Deaths()
+		end
+	end
+
+	return score
+
+end
+
+function TotalFrags( index )
+
+	local score = 0
+
+	for _, ply in ipairs(player.GetAll()) do
+		if ( ply:Team() == index ) then
+			score = score + ply:Frags()
+		end
+	end
+
+	return score
+
+end
+
+function NumPlayers( index )
+
+	local players = 0
+
+	for _, ply in ipairs(player.GetAll()) do
+		if ( ply:Team() == index ) then
+			players = players + 1
+		end
+	end
+
+	return players
+
+end
+
+function GetPlayers( index )
+
+	local TeamPlayers = {}
+
+	for _, ply in ipairs(player.GetAll()) do
+		if ( ply:Team() == index ) then
+			table.insert(TeamPlayers, ply)
+		end
+	end
+
+	return TeamPlayers
+
+end
+
+function GetScore( index )
+
+	return GetGlobalInt( "Team." .. tostring( index ) .. ".Score", 0 )
+
+end
+
+function GetName( index )
+
+	if ( !TeamInfo[index] ) then return "" end
+	return TeamInfo[index].Name
+
+end
+
+function SetColor( index, color )
+
+	if ( !TeamInfo[ index ] ) then return false end
+	TeamInfo[ index ].Color = color
+
+	return color
+
+end
+
+function GetColor( index )
+
+	local color = TeamInfo[index] && TeamInfo[index].Color || DefaultColor
+	return Color( color.r, color.g, color.b, color.a )
+
+end
+
+function SetScore( index, score )
+
+	return SetGlobalInt( "Team." .. tostring( index ) .. ".Score", score )
+
+end
+
+function AddScore(index, score)
+
+	SetScore( index, GetScore( index ) + score )
+
+end
+
+function BestAutoJoinTeam()
+
+	local SmallestTeam = TEAM_UNASSIGNED
+	local SmallestPlayers = 1000
+
+	for id, tm in pairs( team.GetAllTeams() ) do
+
+		if ( id != TEAM_SPECTATOR && id != TEAM_UNASSIGNED && id != TEAM_CONNECTING && tm.Joinable ) then
+
+			local PlayerCount = team.NumPlayers( id )
+			if ( PlayerCount < SmallestPlayers || (PlayerCount == SmallestPlayers && id < SmallestTeam ) ) then
+				SmallestPlayers = PlayerCount
+				SmallestTeam = id
+			end
+
+		end
+
+	end
+
+	return SmallestTeam
+
+end

lua/includes/modules/undo.lua

@@ -0,0 +1,517 @@
+
+module( "undo", package.seeall )
+
+-- undo.Create("Wheel")
+-- undo.AddEntity( axis )
+-- undo.AddEntity( constraint )
+-- undo.SetPlayer( self.Owner )
+-- undo.Finish()
+
+if ( CLIENT ) then
+
+	local ClientUndos = {}
+	local bIsDirty = true
+
+	--[[---------------------------------------------------------
+		GetTable
+		Returns the undo table for whatever reason
+	-----------------------------------------------------------]]
+	function GetTable()
+		return ClientUndos
+	end
+
+	--[[---------------------------------------------------------
+		UpdateUI
+		Actually updates the UI. Removes old controls and
+		re-creates them using the new data.
+	-----------------------------------------------------------]]
+	local function UpdateUI()
+
+		local Panel = controlpanel.Get( "Undo" )
+		if ( !IsValid( Panel ) ) then return end
+
+		Panel:Clear()
+		Panel:Help( "#spawnmenu.utilities.undo.help" )
+
+		local ComboBox = Panel:ListBox()
+		ComboBox:SetTall( 500 )
+
+		local Limit = 100
+		local Count = 0
+		for k, v in ipairs( ClientUndos ) do
+
+			local Item = ComboBox:AddItem( tostring( v.Name ) )
+			Item.DoClick = function() RunConsoleCommand( "gmod_undonum", tostring( v.Key ) ) end
+
+			Count = Count + 1
+			if ( Count > Limit ) then break end
+
+		end
+
+	end
+
+	--[[---------------------------------------------------------
+		AddUndo
+		Called from server. Adds a new undo to our UI
+	-----------------------------------------------------------]]
+	net.Receive( "Undo_AddUndo", function()
+
+		local key = net.ReadInt( 16 )
+		local name = net.ReadString()
+
+		-- HACK: To support localization of "#prop_physics (models/path.mdl)"
+		if ( name[ 1 ] == "#" and string.find( name, " (", nil, true ) ) then
+			local undoName, undoSecondary = string.match( name, "^(#.*) %((.*)%)$" )
+			if ( undoName and undoSecondary ) then
+				name = string.format( "%s (%s)", language.GetPhrase( undoName ), language.GetPhrase( undoSecondary ) )
+			end
+		end
+
+		table.insert( ClientUndos, 1, { Key = key, Name = name } )
+
+		MakeUIDirty()
+
+	end )
+
+	-- Called from server, fires GM:OnUndo
+	net.Receive( "Undo_FireUndo", function()
+
+		local name = net.ReadString()
+		local hasCustomText = net.ReadBool()
+		local customtext
+		if ( hasCustomText ) then
+			customtext = net.ReadString()
+		end
+
+		hook.Run( "OnUndo", name, customtext )
+
+	end )
+
+
+	--[[---------------------------------------------------------
+		Undone
+		Called from server. Notifies us that one of our undos
+		has been undone or made redundant. We act by updating
+		out data (We wait until the UI is viewed until updating)
+	-----------------------------------------------------------]]
+	local function Undone()
+
+		local key = net.ReadInt( 16 )
+
+		local NewUndo = {}
+		local i = 1
+		for k, v in ipairs( ClientUndos ) do
+
+			if ( v.Key != key ) then
+				NewUndo [ i ] = v
+				i = i + 1
+			end
+		end
+
+		ClientUndos = NewUndo
+		NewUndo = nil
+
+		MakeUIDirty()
+
+	end
+	net.Receive( "Undo_Undone", Undone )
+
+	--[[---------------------------------------------------------
+		MakeUIDirty
+		Makes the UI dirty - it will re-create the controls
+		the next time it is viewed.
+	-----------------------------------------------------------]]
+	function MakeUIDirty()
+
+		bIsDirty = true
+
+	end
+
+	--[[---------------------------------------------------------
+		CPanelPaint
+		Called when the inner panel of the undo CPanel is painted
+		We hook onto this to determine when the panel is viewed.
+		When it's viewed we update the UI if it's marked as dirty
+	-----------------------------------------------------------]]
+	local function CPanelUpdate( panel )
+
+		-- This is kind of a shitty way of doing it - but we only want
+		-- to update the UI when it's visible.
+		if ( bIsDirty ) then
+
+			-- Doing this in a timer so it calls it in a sensible place
+			-- Calling in the paint function could cause all kinds of problems
+			-- It's a hack but hey welcome to GMod!
+			timer.Simple( 0, UpdateUI )
+			bIsDirty = false
+
+		end
+
+	end
+
+	--[[---------------------------------------------------------
+		SetupUI
+		Adds a hook (CPanelPaint) to the control panel paint
+		function so we can determine when it is being drawn.
+	-----------------------------------------------------------]]
+	function SetupUI()
+
+		local UndoPanel = controlpanel.Get( "Undo" )
+		if ( !IsValid( UndoPanel ) ) then return end
+
+		-- Mark as dirty please
+		MakeUIDirty()
+
+		-- Panels only think when they're visible
+		UndoPanel.Think = CPanelUpdate
+
+	end
+
+	hook.Add( "PostReloadToolsMenu", "BuildUndoUI", SetupUI )
+
+end
+
+
+if ( !SERVER ) then return end
+
+local PlayerUndo = {}
+-- PlayerUndo
+--	- Player UniqueID
+--		- Undo Table
+--			- Name
+--			- Entities (table of ents)
+--			- Owner (player)
+
+local Current_Undo = nil
+
+util.AddNetworkString( "Undo_Undone" )
+util.AddNetworkString( "Undo_AddUndo" )
+util.AddNetworkString( "Undo_FireUndo" )
+
+--[[---------------------------------------------------------
+	GetTable
+	Returns the undo table for whatever reason
+-----------------------------------------------------------]]
+function GetTable()
+	return PlayerUndo
+end
+
+--[[---------------------------------------------------------
+	GetTable
+	Save/Restore the undo tables
+-----------------------------------------------------------]]
+local function Save( save )
+
+	saverestore.WriteTable( PlayerUndo, save )
+
+end
+
+local function Restore( restore )
+
+	PlayerUndo = saverestore.ReadTable( restore )
+
+end
+
+saverestore.AddSaveHook( "UndoTable", Save )
+saverestore.AddRestoreHook( "UndoTable", Restore )
+
+--[[---------------------------------------------------------
+	Start a new undo
+-----------------------------------------------------------]]
+function Create( text )
+
+	Current_Undo = {}
+	Current_Undo.Name			= text
+	Current_Undo.Entities		= {}
+	Current_Undo.Owner			= nil
+	Current_Undo.Functions		= {}
+
+end
+
+--[[---------------------------------------------------------
+	Adds an entity to this undo (The entity is removed on undo)
+-----------------------------------------------------------]]
+function SetCustomUndoText( CustomUndoText )
+
+	if ( !Current_Undo ) then return end
+
+	Current_Undo.CustomUndoText = CustomUndoText
+
+end
+
+--[[---------------------------------------------------------
+	Adds an entity to this undo (The entity is removed on undo)
+-----------------------------------------------------------]]
+function AddEntity( ent )
+
+	if ( !Current_Undo ) then return end
+	if ( !IsValid( ent ) ) then return end
+
+	table.insert( Current_Undo.Entities, ent )
+
+end
+
+--[[---------------------------------------------------------
+	Add a function to call to this undo
+-----------------------------------------------------------]]
+function AddFunction( func, ... )
+
+	if ( !Current_Undo ) then return end
+	if ( !func ) then return end
+
+	table.insert( Current_Undo.Functions, { func, {...} } )
+
+end
+
+--[[---------------------------------------------------------
+	Replace Entity
+-----------------------------------------------------------]]
+function ReplaceEntity( from, to )
+
+	local ActionTaken = false
+
+	for _, PlayerTable in pairs( PlayerUndo ) do
+		for _, UndoTable in pairs( PlayerTable ) do
+			if ( UndoTable.Entities ) then
+
+				for key, ent in pairs( UndoTable.Entities ) do
+					if ( ent == from ) then
+						UndoTable.Entities[ key ] = to
+						ActionTaken = true
+					end
+				end
+
+			end
+		end
+	end
+
+	return ActionTaken
+
+end
+
+
+--[[---------------------------------------------------------
+	Sets who's undo this is
+-----------------------------------------------------------]]
+function SetPlayer( ply )
+
+	if ( !Current_Undo ) then return end
+	if ( !IsValid( ply ) ) then return end
+
+	Current_Undo.Owner = ply
+
+end
+
+--[[---------------------------------------------------------
+	SendUndoneMessage
+	Sends a message to notify the client that one of their
+	undos has been removed. They can then update their GUI.
+-----------------------------------------------------------]]
+local function SendUndoneMessage( ent, id, ply )
+
+	if ( !IsValid( ply ) ) then return end
+
+	-- For further optimization we could queue up the ids and send them
+	-- in one batch every 0.5 seconds or something along those lines.
+
+	net.Start( "Undo_Undone" )
+		net.WriteInt( id, 16 )
+	net.Send( ply )
+
+end
+
+--[[---------------------------------------------------------
+	Checks whether an undo is allowed to be created
+-----------------------------------------------------------]]
+local function Can_CreateUndo( undo )
+
+	local call = hook.Run( "CanCreateUndo", undo.Owner, undo )
+
+	return call == true or call == nil
+
+end
+
+--[[---------------------------------------------------------
+	Finish
+-----------------------------------------------------------]]
+function Finish( NiceText )
+
+	if ( !Current_Undo ) then return end
+
+	-- Do not add undos that have no owner or anything to undo
+	if ( !IsValid( Current_Undo.Owner ) or ( table.IsEmpty( Current_Undo.Entities ) && table.IsEmpty( Current_Undo.Functions ) ) or !Can_CreateUndo( Current_Undo ) ) then
+		Current_Undo = nil
+		return false
+	end
+
+	local index = Current_Undo.Owner:UniqueID()
+	PlayerUndo[ index ] = PlayerUndo[ index ] or {}
+
+	Current_Undo.NiceText = NiceText or ( "#" .. Current_Undo.Name )
+
+	local id = table.insert( PlayerUndo[ index ], Current_Undo )
+
+	net.Start( "Undo_AddUndo" )
+		net.WriteInt( id, 16 )
+		net.WriteString( Current_Undo.NiceText )
+	net.Send( Current_Undo.Owner )
+
+	-- Have one of the entities in the undo tell us when it gets undone.
+	if ( IsValid( Current_Undo.Entities[ 1 ] ) ) then
+
+		local ent = Current_Undo.Entities[ 1 ]
+		ent:CallOnRemove( "undo" .. id, SendUndoneMessage, id, Current_Undo.Owner )
+
+	end
+
+	Current_Undo = nil
+	
+	return true
+
+end
+
+--[[---------------------------------------------------------
+	Undos an undo
+-----------------------------------------------------------]]
+function Do_Undo( undo )
+
+	if ( !undo ) then return false end
+
+	if ( hook.Run( "PreUndo", undo ) == false ) then return end
+
+	local count = 0
+
+	-- Call each function
+	if ( undo.Functions ) then
+		for index, func in pairs( undo.Functions ) do
+
+			local success = func[ 1 ]( undo, unpack( func[ 2 ] ) )
+			if ( success != false ) then
+				count = count + 1
+			end
+
+		end
+	end
+
+	-- Remove each entity in this undo
+	if ( undo.Entities ) then
+		for index, entity in pairs( undo.Entities ) do
+
+			if ( IsValid( entity ) ) then
+				entity:Remove()
+				count = count + 1
+			end
+
+		end
+	end
+
+	if ( count > 0 ) then
+		net.Start( "Undo_FireUndo" )
+			net.WriteString( undo.Name )
+			net.WriteBool( undo.CustomUndoText != nil )
+			if ( undo.CustomUndoText != nil ) then
+				net.WriteString( undo.CustomUndoText )
+			end
+		net.Send( undo.Owner )
+	end
+
+	hook.Run( "PostUndo", undo, count )
+
+	return count
+
+end
+
+--[[---------------------------------------------------------
+	Checks whether a player is allowed to undo
+-----------------------------------------------------------]]
+local function Can_Undo( ply, undo )
+
+	local call = hook.Run( "CanUndo", ply, undo )
+
+	return call == true or call == nil
+
+end
+
+--[[---------------------------------------------------------
+	Console command
+-----------------------------------------------------------]]
+local function CC_UndoLast( pl, command, args )
+
+	local index = pl:UniqueID()
+	PlayerUndo[ index ] = PlayerUndo[ index ] or {}
+
+	local last = nil
+	local lastk = nil
+
+	for k, v in pairs( PlayerUndo[ index ] ) do
+
+		lastk = k
+		last = v
+
+	end
+
+	-- No undos
+	if ( !last ) then return end
+
+	-- This is quite messy, but if the player rejoined the server
+	-- 'Owner' might no longer be a valid entity. So replace the Owner
+	-- with the player that is doing the undoing
+	last.Owner = pl
+
+	if ( !Can_Undo( pl, last ) ) then return end
+
+	local count = Do_Undo( last )
+
+	net.Start( "Undo_Undone" )
+		net.WriteInt( lastk, 16 )
+	net.Send( pl )
+
+	PlayerUndo[ index ][ lastk ] = nil
+
+	-- If our last undo object is already deleted then compact
+	-- the undos until we hit one that does something
+	if ( count == 0 ) then
+		CC_UndoLast( pl )
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Console command
+-----------------------------------------------------------]]
+local function CC_UndoNum( ply, command, args )
+
+	if ( !args[ 1 ] ) then return end
+
+	local index = ply:UniqueID()
+	PlayerUndo[ index ] = PlayerUndo[ index ] or {}
+
+	local UndoNum = tonumber( args[ 1 ] )
+	if ( !UndoNum ) then return end
+
+	local TheUndo = PlayerUndo[ index ][ UndoNum ]
+	if ( !TheUndo ) then return end
+
+	-- Do the same as above
+	TheUndo.Owner = ply
+
+	if ( !Can_Undo( ply, TheUndo ) ) then return end
+
+	-- Undo!
+	Do_Undo( TheUndo )
+
+	-- Notify the client UI that the undo happened
+	-- This is normally called by the deleted entity via SendUndoneMessage
+	-- But in cases where the undo only has functions that will not do
+	net.Start( "Undo_Undone" )
+		net.WriteInt( UndoNum, 16 )
+	net.Send( ply )
+
+	-- Don't delete the entry completely so nothing new takes its place and ruin CC_UndoLast's logic (expecting newest entry be at highest index)
+	PlayerUndo[ index ][ UndoNum ] = {}
+
+end
+
+concommand.Add( "undo",			CC_UndoLast, nil, "", { FCVAR_DONTRECORD } )
+concommand.Add( "gmod_undo",	CC_UndoLast, nil, "", { FCVAR_DONTRECORD } )
+concommand.Add( "gmod_undonum",	CC_UndoNum, nil, "", { FCVAR_DONTRECORD } )

lua/includes/modules/usermessage.lua

@@ -0,0 +1,87 @@
+
+-- Globals that we are going to use
+local unpack	= unpack
+local Msg		= Msg
+
+--[[
+	This is merely a convenience function. If you pass numbers
+	using this they're always sent as long. Which sucks if you're sending
+	numbers that are always under 100 etc.
+--]]
+function SendUserMessage( name, ply, ... )
+
+	if ( CLIENT ) then return end
+
+	umsg.Start( name, ply )
+
+	for k, v in ipairs( { ... } ) do
+		local t = TypeID( v )
+
+		if ( t == TYPE_STRING ) then
+			umsg.String( v )
+		elseif ( t == TYPE_ENTITY ) then
+			umsg.Entity( v )
+		elseif ( t == TYPE_NUMBER ) then
+			umsg.Long( v )
+		elseif ( t == TYPE_VECTOR ) then
+			umsg.Vector( v )
+		elseif ( t == TYPE_ANGLE ) then
+			umsg.Angle( v )
+		elseif ( t == TYPE_BOOL ) then
+			umsg.Bool( v )
+		else
+			ErrorNoHalt( "SendUserMessage: Couldn't send type " .. type( v ) .. "\n" )
+		end
+	end
+
+	umsg.End()
+
+end
+
+--[[---------------------------------------------------------
+	Name: usermessage
+	Desc: Enables the server to send the client messages (in a bandwidth friendly manner)
+-----------------------------------------------------------]]
+module( "usermessage" )
+
+local Hooks = {}
+
+--[[---------------------------------------------------------
+	Name: GetTable
+	Desc: Returns the table of hooked usermessages
+-----------------------------------------------------------]]
+function GetTable()
+
+	return Hooks
+
+end
+
+--[[---------------------------------------------------------
+	Name: Hook
+	Desc: Adds a hook
+-----------------------------------------------------------]]
+function Hook( messagename, func, ... )
+
+	Hooks[ messagename ] = {}
+
+	Hooks[ messagename ].Function 	= func
+	Hooks[ messagename ].PreArgs	= { ... }
+
+end
+
+--[[---------------------------------------------------------
+	Name: Call( name, args )
+	Desc: Called by the engine to call a gamemode hook
+-----------------------------------------------------------]]
+function IncomingMessage( MessageName, msg )
+
+	if ( Hooks[ MessageName ] ) then
+
+		Hooks[ MessageName ].Function( msg, unpack( Hooks[ MessageName ].PreArgs ) )
+		return
+
+	end
+
+	Msg( "Warning: Unhandled usermessage '" .. MessageName .. "'\n" )
+
+end

lua/includes/modules/utf8.lua

@@ -0,0 +1,377 @@
+local bit		= bit
+local error		= error
+local ipairs	= ipairs
+local string	= string
+local table		= table
+local unpack	= unpack
+local math		= math
+
+module( "utf8" )
+
+--
+-- Pattern that can be used with the string library to match a single UTF-8 byte-sequence.
+-- This expects the string to contain valid UTF-8 data.
+--
+charpattern = "[%z\x01-\x7F\xC2-\xF4][\x80-\xBF]*"
+
+--
+-- Transforms indexes of a string to be positive.
+-- Negative indices will wrap around like the string library's functions.
+--
+local function strRelToAbs( str, ... )
+
+	local args = { ... }
+
+	for k, v in ipairs( args ) do
+		v = v > 0 and v or math.max( #str + v + 1, 1 )
+
+		if v < 1 or v > #str + 1 then
+			error( "bad index to string (out of range)", 3 )
+		end
+
+		args[ k ] = v
+	end
+
+	return unpack( args )
+
+end
+
+-- Decodes a single UTF-8 byte-sequence from a string, ensuring it is valid
+-- Returns the index of the first/last chars of a sequence and its codepoint
+--
+local function decode( str, startPos )
+
+	startPos = strRelToAbs( str, startPos or 1 )
+
+	local b1 = str:byte( startPos, startPos )
+
+	-- End of string
+	if not b1 then
+		return nil
+	end
+
+	-- Single-byte sequence
+	if b1 < 0x80 then
+		return startPos, startPos, b1
+	end
+
+	-- Validate first byte of multi-byte sequence
+	if b1 > 0xF4 or b1 < 0xC2 then
+		return nil
+	end
+
+	-- Get 'supposed' amount of continuation bytes from primary byte
+	local contByteCount =	b1 >= 0xF0 and 3 or
+							b1 >= 0xE0 and 2 or
+							b1 >= 0xC0 and 1
+
+	local endPos    = startPos + contByteCount
+	local codePoint = 0
+
+	-- The string doesn't have enough data for this many continutation bytes
+	if #str < endPos then
+		return nil
+	end
+
+	-- Validate our continuation bytes
+	for _, bX in ipairs { str:byte( startPos + 1, endPos ) } do
+
+		-- Invalid continuation byte hit
+		if bit.band( bX, 0xC0 ) ~= 0x80 then
+			return nil
+		end
+
+		codePoint = bit.bor( bit.lshift( codePoint, 6 ), bit.band( bX, 0x3F ) )
+		b1 = bit.lshift( b1, 1 )
+
+	end
+
+	codePoint = bit.bor( codePoint, bit.lshift( bit.band( b1, 0x7F ), contByteCount * 5 ) )
+
+	return startPos, endPos, codePoint
+
+end
+
+--
+-- Takes zero or more integers and returns a string containing the UTF-8 representation of each
+--
+function char( ... )
+
+	local buf = {}
+
+	for k, v in ipairs { ... } do
+
+		if v < 0 or v > 0x10FFFF then
+			error( "bad argument #" .. k .. " to char (out of range)", 2 )
+		end
+
+		local b1, b2, b3, b4 = nil, nil, nil, nil
+
+		if v < 0x80 then -- Single-byte sequence
+
+			table.insert( buf, string.char( v ) )
+
+		elseif v < 0x800 then -- Two-byte sequence
+
+			b1 = bit.bor( 0xC0, bit.band( bit.rshift( v, 6 ), 0x1F ) )
+			b2 = bit.bor( 0x80, bit.band( v, 0x3F ) )
+
+			table.insert( buf, string.char( b1, b2 ) )
+
+		elseif v < 0x10000 then -- Three-byte sequence
+
+			b1 = bit.bor( 0xE0, bit.band( bit.rshift( v, 12 ), 0x0F ) )
+			b2 = bit.bor( 0x80, bit.band( bit.rshift( v, 6 ), 0x3F ) )
+			b3 = bit.bor( 0x80, bit.band( v, 0x3F ) )
+
+			table.insert( buf, string.char( b1, b2, b3 ) )
+
+		else -- Four-byte sequence
+
+			b1 = bit.bor( 0xF0, bit.band( bit.rshift( v, 18 ), 0x07 ) )
+			b2 = bit.bor( 0x80, bit.band( bit.rshift( v, 12 ), 0x3F ) )
+			b3 = bit.bor( 0x80, bit.band( bit.rshift( v, 6 ), 0x3F ) )
+			b4 = bit.bor( 0x80, bit.band( v, 0x3F ) )
+
+			table.insert( buf, string.char( b1, b2, b3, b4 ) )
+
+		end
+
+	end
+
+	return table.concat( buf, "" )
+
+end
+
+--
+-- Iterates over a UTF-8 string similarly to pairs
+-- k = index of sequence, v = string value of sequence
+--
+function codes( str )
+
+	local i = 1
+
+	return function()
+
+		-- Have we hit the end of the iteration set?
+		if i > #str then
+			return nil
+		end
+
+		local startPos, endPos, codePoint = decode( str, i )
+
+		if not startPos then
+			error( "invalid UTF-8 code", 2 )
+		end
+
+		i = endPos + 1
+
+		return startPos, codePoint
+
+	end
+
+end
+
+--
+-- Returns an integer-representation of the UTF-8 sequence(s) in a string
+-- startPos defaults to 1, endPos defaults to startPos
+--
+function codepoint( str, startPos, endPos )
+
+	startPos, endPos = strRelToAbs( str, startPos or 1, endPos or startPos or 1 )
+
+	local ret = {}
+
+	repeat
+		local seqStartPos, seqEndPos, codePoint = decode( str, startPos )
+
+		if not seqStartPos then
+			error( "invalid UTF-8 code", 2 )
+		end
+
+		-- Increment current string index
+		startPos = seqEndPos + 1
+
+		table.insert( ret, codePoint )
+	until seqEndPos >= endPos
+
+	return unpack( ret )
+
+end
+
+--
+-- Returns the length of a UTF-8 string. false, index is returned if an invalid sequence is hit
+-- startPos defaults to 1, endPos defaults to -1
+--
+function len( str, startPos, endPos )
+
+	startPos, endPos = strRelToAbs( str, startPos or 1, endPos or -1 )
+
+	local len = 0
+
+	while endPos >= startPos and startPos <= #str do
+		local seqStartPos, seqEndPos = decode( str, startPos )
+
+		-- Hit an invalid sequence?
+		if not seqStartPos then
+			return false, startPos
+		end
+
+		-- Increment current string pointer
+		startPos = seqEndPos + 1
+
+		-- Increment length
+		len = len + 1
+	end
+
+	return len
+
+end
+
+--
+-- Returns the byte-index of the n'th UTF-8-character after the given byte-index (nil if none)
+-- startPos defaults to 1 when n is positive and -1 when n is negative
+-- If 0 is zero, this function instead returns the byte-index of the UTF-8-character startPos lies within.
+--
+function offset( str, n, startPos )
+
+	if startPos and ( startPos > #str or -startPos > #str or startPos == 0 ) then
+		error( "bad index to string (out of range)", 2 )
+	end
+
+	local pos = ( n >= 0 ) and 1 or #str
+	      pos = strRelToAbs( str, startPos or pos )
+
+	-- Back up to the start of this byte sequence
+	if n == 0 then
+
+		while pos > 0 and not decode( str, pos ) do
+			pos = pos - 1
+		end
+
+		return pos
+
+	end
+
+	--
+	-- Make sure we're on a valid sequence
+	--
+	if not decode( str, pos ) then
+		error( "initial position is a continuation byte", 2 )
+	end
+
+	-- Back up to (-n) byte sequences
+	if n < 0 then
+
+		for i = 1, -n do
+			pos = pos - 1
+
+			while pos > 0 and not decode( str, pos ) do
+				pos = pos - 1
+			end
+		end
+
+		if pos < 1 then
+			return nil
+		end
+
+		return pos
+
+	end
+
+	-- Jump forward (n) byte sequences
+	if n > 0 then
+
+		for i = 1, n do
+			pos = pos + 1
+
+			while pos <= #str and not decode( str, pos ) do
+				pos = pos + 1
+			end
+		end
+
+		if pos > #str then
+			return nil
+		end
+
+		return pos
+
+	end
+
+end
+
+--
+-- Forces a string to contain only valid UTF-8 data.
+-- Invalid sequences are replaced with U+FFFD.
+--
+function force( str )
+
+	local buf = {}
+
+	local curPos, endPos = 1, #str
+
+	-- Empty string?
+	if endPos == 0 then
+		return str
+	end
+
+	repeat
+
+		local seqStartPos, seqEndPos = decode( str, curPos )
+
+		if not seqStartPos then
+
+			table.insert( buf, char( 0xFFFD ) )
+			curPos = curPos + 1
+
+		else
+
+			table.insert( buf, str:sub( seqStartPos, seqEndPos ) )
+			curPos = seqEndPos + 1
+
+		end
+
+	until curPos > endPos
+
+	return table.concat( buf, "" )
+
+end
+
+--
+-- Converts a relative index to an absolute
+-- This is different from the above in that it cares about characters and not bytes
+--
+local function strRelToAbsChar( str, pos )
+	if pos < 0 then
+		pos = math.max( pos + len( str ) + 1, 0 )
+	end
+	return pos
+end
+
+--
+-- UTF-8 compilant version of str[idx]
+--
+function GetChar( str, idx )
+	idx = strRelToAbsChar( str, idx )
+
+	if idx == 0 then return "" end
+	if idx > len( str ) then return "" end
+
+	local off = offset( str, idx - 1 )
+	return char( codepoint( str, off ) )
+end
+
+--
+-- UTF-8 compilant version of string.sub
+--
+function sub( str, charstart, charend )
+	charstart = strRelToAbsChar( str, charstart )
+	charend = strRelToAbsChar( str, charend or -1 )
+
+	local buf = {}
+	for i = charstart, charend do
+		buf[#buf + 1] = GetChar( str, i )
+	end
+
+	return table.concat( buf )
+end

lua/includes/modules/weapons.lua

@@ -0,0 +1,185 @@
+
+module( "weapons", package.seeall )
+
+local WeaponList = {}
+
+--[[---------------------------------------------------------
+	Name: TableInherit( t, base )
+	Desc: Copies any missing data from base to t
+-----------------------------------------------------------]]
+local function TableInherit( t, base )
+
+	for k, v in pairs( base ) do
+
+		if ( t[ k ] == nil ) then
+			t[ k ] = v
+		elseif ( k != "BaseClass" && istable( t[ k ] ) && istable( v ) ) then
+			TableInherit( t[ k ], v )
+		end
+
+	end
+
+	t[ "BaseClass" ] = base
+
+	return t
+
+end
+
+--[[---------------------------------------------------------
+	Name: IsBasedOn( name, base )
+	Desc: Checks if name is based on base
+-----------------------------------------------------------]]
+function IsBasedOn( name, base )
+	local t = GetStored( name )
+	if ( !t ) then return false end
+	if ( t.Base == name ) then return false end
+
+	if ( t.Base == base ) then return true end
+	return IsBasedOn( t.Base, base )
+end
+
+
+--[[---------------------------------------------------------
+	Name: Register( table, string, bool )
+	Desc: Used to register your SWEP with the engine
+-----------------------------------------------------------]]
+function Register( t, name )
+
+	if ( hook.Run( "PreRegisterSWEP", t, name ) == false ) then return end
+
+	if ( isstring( t.ClassNameOverride ) ) then name = t.ClassNameOverride end
+
+	local old = WeaponList[ name ]
+	t.ClassName = name
+	WeaponList[ name ] = t
+
+	--baseclass.Set( name, t )
+
+	list.Set( "Weapon", name, {
+		ClassName = name,
+		PrintName = t.PrintName or name,
+		Category = t.Category or "#spawnmenu.category.other",
+		Spawnable = t.Spawnable,
+		AdminOnly = t.AdminOnly,
+		ScriptedEntityType = t.ScriptedEntityType,
+		IconOverride = t.IconOverride
+	} )
+
+	-- Allow all SWEPS to be duplicated, unless specified
+	if ( !t.DisableDuplicator ) then
+		duplicator.Allow( name )
+	end
+
+	--
+	-- If we're reloading this entity class
+	-- then refresh all the existing entities.
+	--
+	if ( old != nil ) then
+
+		-- Update SWEP table of entities that are based on this SWEP
+		for _, e in ipairs( ents.GetAll() ) do
+			local class = e:GetClass()
+
+			if ( class == name ) then
+				--
+				-- Replace the contents with this entity table
+				--
+				table.Merge( e, t )
+
+				--
+				-- Call OnReloaded hook (if it has one)
+				--
+				if ( e.OnReloaded ) then
+					e:OnReloaded()
+				end
+			end
+
+			if ( IsBasedOn( class, name ) ) then
+				table.Merge( e, Get( class ) )
+
+				if ( e.OnReloaded ) then
+					e:OnReloaded()
+				end
+			end
+		end
+
+	end
+
+end
+
+--
+-- All scripts have been loaded...
+--
+function OnLoaded()
+
+	--
+	-- Once all the scripts are loaded we can set up the baseclass
+	-- - we have to wait until they're all setup because load order
+	-- could cause some entities to load before their bases!
+	--
+	for k, v in pairs( WeaponList ) do
+
+		baseclass.Set( k, Get( k ) )
+
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: Get( string )
+	Desc: Get a weapon by name.
+-----------------------------------------------------------]]
+function Get( name, retval )
+
+	local Stored = GetStored( name )
+	if ( !Stored ) then return nil end
+
+	-- Create/copy a new table
+	local retval = retval or {}
+	for k, v in pairs( Stored ) do
+		if ( istable( v ) ) then
+			retval[ k ] = table.Copy( v )
+		else
+			retval[ k ] = v
+		end
+	end
+	retval.Base = retval.Base or "weapon_base"
+
+	-- If we're not derived from ourselves (a base weapon)
+	-- then derive from our 'Base' weapon.
+	if ( retval.Base != name ) then
+
+		local base = Get( retval.Base )
+
+		if ( !base ) then
+			Msg( "ERROR: Trying to derive weapon " .. tostring( name ) .. " from non existant SWEP " .. tostring( retval.Base ) .. "!\n" )
+		else
+			retval = TableInherit( retval, base )
+		end
+
+	end
+
+	return retval
+end
+
+--[[---------------------------------------------------------
+	Name: GetStored( string )
+	Desc: Gets the REAL weapon table, not a copy
+-----------------------------------------------------------]]
+function GetStored( name )
+	return WeaponList[ name ]
+end
+
+--[[---------------------------------------------------------
+	Name: GetList( string )
+	Desc: Get a list of all the registered SWEPs
+-----------------------------------------------------------]]
+function GetList()
+	local result = {}
+
+	for k, v in pairs( WeaponList ) do
+		table.insert( result, v )
+	end
+
+	return result
+end

lua/includes/modules/widget.lua

@@ -0,0 +1,175 @@
+
+
+--
+-- Widgets are like gui controls in the 3D world(!!!)
+--
+
+widgets = {}
+local widgetEntities = {}
+
+--
+-- Holds the currently hovered widget
+--
+widgets.Hovered = nil
+widgets.HoveredPos = vector_origin
+
+--
+-- Holds the current pressed widget
+--
+widgets.Pressed = nil
+
+local tr = {}
+local trace = {
+	output = tr,
+	filter = widgetEntities,
+	whitelist = true,
+}
+
+local function UpdateHovered( pl )
+
+	if ( !IsValid( pl ) ) then return end
+
+	if ( !pl:Alive() ) then
+		pl:SetHoveredWidget( NULL )
+		return
+	end
+
+	local eyePos = pl:EyePos()
+	local aimVector = pl:GetAimVector()
+	aimVector:Mul( 256 )
+	aimVector:Add( eyePos )
+
+	trace.start = eyePos
+	trace.endpos = aimVector
+
+--	debugoverlay.Line( trace.start, trace.endpos, 0.5 )
+
+	widgets.Tracing = true
+	util.TraceLine( trace )
+	widgets.Tracing = false
+
+	if ( !IsValid( tr.Entity ) || tr.Entity:IsWorld() ) then
+		pl:SetHoveredWidget( NULL )
+		return
+	end
+
+--	debugoverlay.Cross( tr.HitPos, 1, 60 )
+
+	pl:SetHoveredWidget( tr.Entity )
+	pl.WidgetHitPos = tr.HitPos
+
+	return tr.Entity
+
+end
+
+local function UpdateButton( pl, mv, btn, mousebutton, hvr, prs )
+
+	local now = mv:KeyDown( btn )
+	local was = mv:KeyWasDown( btn )
+
+	if ( now && !was && IsValid( hvr ) ) then
+		hvr:OnPress( pl, mousebutton, mv )
+	end
+
+	if ( !now && was && IsValid( prs ) ) then
+		prs:OnRelease( pl, mousebutton, mv )
+	end
+
+end
+
+--
+-- The idea here is to have exactly the same
+-- behaviour on the client as the server.
+--
+function widgets.PlayerTick( pl, mv )
+
+	local hvr = UpdateHovered( pl )
+	local prs = pl:GetPressedWidget()
+
+	UpdateButton( pl, mv, IN_ATTACK, 1, hvr, prs )
+	UpdateButton( pl, mv, IN_ATTACK2, 2, hvr, prs )
+
+	if ( IsValid( prs ) ) then
+		prs:PressedThinkInternal( pl, mv )
+	end
+
+end
+
+---
+---  Render the widgets!
+---
+
+-- Function stub for backwards compatibility
+function widgets.RenderMe( ent )
+	-- We do this solely for backwards compatibility
+	ent._WantsWidgetRender = true
+end
+
+local function RenderWidgets()
+
+	local prs = LocalPlayer():GetPressedWidget()
+	local prsValid = IsValid( prs )
+
+	cam.Start3D( EyePos(), EyeAngles() )
+
+		for _, v in ipairs( widgetEntities ) do
+
+			--
+			-- The pressed widget gets to decide what should draw
+			--
+			if ( prsValid && !prs:PressedShouldDraw( v ) ) then continue end
+			if ( !v._WantsWidgetRender ) then continue end
+
+			v:OverlayRender()
+			v._WantsWidgetRender = nil
+
+		end
+
+	cam.End3D()
+
+end
+
+hook.Add( "OnEntityCreated", "CreateWidgets", function( ent )
+
+	timer.Simple( 0.001, function()
+
+		if ( !ent:IsWidget() ) then return end
+
+		table.insert( widgetEntities, ent )
+		hook.Add( "PlayerTick", "TickWidgets", widgets.PlayerTick )
+
+		if ( CLIENT ) then
+			hook.Add( "PostDrawEffects", "RenderWidgets", RenderWidgets )
+		end
+
+	end )
+
+end )
+
+hook.Add( "EntityRemoved", "RemoveWidgets", function( ent )
+
+	if ( !ent:IsWidget() ) then return end
+
+	for k, v in next, widgetEntities do
+		if ( v == ent ) then
+			table.remove( widgetEntities, k )
+			break
+		end
+	end
+
+	if ( #widgetEntities == 0 ) then
+		hook.Remove( "PlayerTick", "TickWidgets" )
+
+		if ( CLIENT ) then
+			hook.Remove( "PostDrawEffects", "RenderWidgets" )
+		end
+	end
+
+end )
+
+local ENTITY = FindMetaTable( "Entity" )
+
+function ENTITY:IsWidget()
+	return self.Widget
+end
+

lua/includes/util.lua

@@ -0,0 +1,534 @@
+
+--
+-- Hack for debug.getregistry
+--
+local meta = {}
+function meta.__index( self, key )
+	return FindMetaTable( key )
+end
+function meta.__newindex( self, key, value )
+	rawset( self, key, value )
+
+	if ( isstring( key ) and istable( value ) ) then
+		RegisterMetaTable( key, value )
+	end
+end
+
+local tbl = {}
+setmetatable( tbl, meta )
+function debug.getregistry() return tbl end
+
+--
+-- Seed the rand!
+--
+math.randomseed( os.time() )
+
+--
+-- Alias string.Format to global Format
+--
+Format = string.format
+
+--
+-- Send C the flags for any materials we want to create
+--
+local C_Material = Material
+function Material( name, words )
+
+	if ( !words ) then return C_Material( name ) end
+
+	local str = (words:find("vertexlitgeneric") and "1" or "0")
+	str = str .. (words:find("nocull") and "1" or "0")
+	str = str .. (words:find("alphatest") and "1" or "0")
+	str = str .. (words:find("mips") and "1" or "0")
+	str = str .. (words:find("noclamp") and "1" or "0")
+	str = str .. (words:find("smooth") and "1" or "0")
+	str = str .. (words:find("ignorez") and "1" or "0")
+
+	return C_Material( name, str )
+
+end
+
+local C_type = type
+function type( v )
+
+	local v_type = C_type( v )
+	if ( v_type != "userdata" ) then return v_type end
+
+	local metatable = getmetatable( v )
+	if ( !metatable ) then return "UserData" end
+
+	local metaName = metatable.MetaName
+	if ( C_type( metaName ) != "string" ) then return "UserData" end
+
+	return metaName
+
+end
+
+--[[---------------------------------------------------------
+	IsTableOfEntitiesValid
+-----------------------------------------------------------]]
+function IsTableOfEntitiesValid( tab )
+
+	if ( !tab ) then return false end
+
+	for k, v in pairs( tab ) do
+		if ( !IsValid( v ) ) then return false end
+	end
+
+	return true
+
+end
+
+--[[---------------------------------------------------------
+	Color related functions - they now have their own
+	metatable so better put them in their own separate
+	file
+-----------------------------------------------------------]]
+
+include( "util/color.lua" )
+
+--[[---------------------------------------------------------
+	Prints a table to the console
+-----------------------------------------------------------]]
+function PrintTable( t, indent, done )
+	local Msg = Msg
+
+	done = done or {}
+	indent = indent or 0
+	local keys = table.GetKeys( t )
+
+	table.sort( keys, function( a, b )
+		if ( isnumber( a ) and isnumber( b ) ) then return a < b end
+		return tostring( a ) < tostring( b )
+	end )
+
+	done[ t ] = true
+
+	for i = 1, #keys do
+		local key = keys[ i ]
+		local value = t[ key ]
+		key = ( type( key ) == "string" ) and "[\"" .. key .. "\"]" || "[" .. tostring( key ) .. "]"
+		Msg( string.rep( "\t", indent ) )
+
+		if  ( istable( value ) and !done[ value ] ) then
+
+			done[ value ] = true
+			Msg( key, ":\n" )
+			PrintTable ( value, indent + 2, done )
+			done[ value ] = nil
+
+		else
+
+			Msg( key, "\t=\t", value, "\n" )
+
+		end
+
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Returns a random vector
+-----------------------------------------------------------]]
+function VectorRand( min, max )
+	min = min || -1
+	max = max || 1
+	return Vector( math.Rand( min, max ), math.Rand( min, max ), math.Rand( min, max ) )
+end
+
+--[[---------------------------------------------------------
+	Returns a random angle
+-----------------------------------------------------------]]
+function AngleRand( min, max )
+	return Angle( math.Rand( min || -90, max || 90 ), math.Rand( min || -180, max || 180 ), math.Rand( min || -180, max || 180 ) )
+end
+
+--[[---------------------------------------------------------
+	Returns a random color
+-----------------------------------------------------------]]
+function ColorRand( alpha )
+	if ( alpha ) then
+		return Color( math.random( 0, 255 ), math.random( 0, 255 ), math.random( 0, 255 ), math.random( 0, 255 ) )
+	end
+
+	return Color( math.random( 0, 255 ), math.random( 0, 255 ), math.random( 0, 255 ) )
+end
+
+
+--[[---------------------------------------------------------
+	Convenience function to precache a sound
+-----------------------------------------------------------]]
+function Sound( name )
+	util.PrecacheSound( name )
+	return name
+end
+
+--[[---------------------------------------------------------
+	Convenience function to precache a model
+-----------------------------------------------------------]]
+function Model( name )
+	util.PrecacheModel( name )
+	return name
+end
+
+--[[---------------------------------------------------------
+	Convenience function to precache a particle
+-----------------------------------------------------------]]
+function Particle( name )
+	if ( CLIENT ) then
+		game.AddParticles( name )
+	end
+	return name
+end
+
+-- Some nice globals so we don't keep creating objects for no reason
+vector_origin		= Vector( 0, 0, 0 )
+vector_up			= Vector( 0, 0, 1 )
+angle_zero			= Angle( 0, 0, 0 )
+
+color_white			= Color( 255, 255, 255, 255 )
+color_black			= Color( 0, 0, 0, 255 )
+color_transparent	= Color( 255, 255, 255, 0 )
+
+--[[---------------------------------------------------------
+	Includes the file - and adds it so the CS file list
+-----------------------------------------------------------]]
+function IncludeCS( filename )
+	if ( SERVER ) then
+		AddCSLuaFile( filename )
+	end
+
+	return include( filename )
+end
+
+-- Globals
+FORCE_STRING	= 1
+FORCE_NUMBER	= 2
+FORCE_BOOL		= 3
+FORCE_ANGLE		= 4
+FORCE_COLOR		= 5
+FORCE_VECTOR	= 6
+
+--[[---------------------------------------------------------
+	AccessorFunc
+	Quickly make Get/Set accessor fuctions on the specified table
+-----------------------------------------------------------]]
+function AccessorFunc( tab, varname, name, iForce )
+
+	if ( !tab ) then debug.Trace() end
+
+	tab[ "Get" .. name ] = function( self ) return self[ varname ] end
+
+	if ( iForce == FORCE_STRING ) then
+		tab[ "Set" .. name ] = function( self, v ) self[ varname ] = tostring( v ) end
+	return end
+
+	if ( iForce == FORCE_NUMBER ) then
+		tab[ "Set" .. name ] = function( self, v ) self[ varname ] = tonumber( v ) end
+	return end
+
+	if ( iForce == FORCE_BOOL ) then
+		tab[ "Set" .. name ] = function( self, v ) self[ varname ] = tobool( v ) end
+	return end
+
+	if ( iForce == FORCE_ANGLE ) then
+		tab[ "Set" .. name ] = function( self, v ) self[ varname ] = Angle( v ) end
+	return end
+
+	if ( iForce == FORCE_COLOR ) then
+		tab[ "Set" .. name ] = function( self, v )
+			if ( type( v ) == "Vector" ) then self[ varname ] = v:ToColor()
+			else self[ varname ] = string.ToColor( tostring( v ) ) end
+		end
+	return end
+
+	if ( iForce == FORCE_VECTOR ) then
+		tab[ "Set" .. name ] = function( self, v )
+			if ( IsColor( v ) ) then self[ varname ] = v:ToVector()
+			else self[ varname ] = Vector( v ) end
+		end
+	return end
+
+	tab[ "Set" .. name ] = function( self, v ) self[ varname ] = v end
+
+end
+
+--[[---------------------------------------------------------
+	Returns true if object is valid (is not nil and IsValid)
+-----------------------------------------------------------]]
+function IsValid( object )
+
+	if ( !object ) then return false end
+
+	local isvalid = object.IsValid
+	if ( !isvalid ) then return false end
+
+	return isvalid( object )
+
+end
+
+--[[---------------------------------------------------------
+	Safely remove an entity
+-----------------------------------------------------------]]
+function SafeRemoveEntity( ent )
+
+	if ( !IsValid( ent ) || ent:IsPlayer() ) then return end
+
+	ent:Remove()
+
+end
+
+--[[---------------------------------------------------------
+	Safely remove an entity (delayed)
+-----------------------------------------------------------]]
+function SafeRemoveEntityDelayed( ent, timedelay )
+
+	if ( !IsValid( ent ) || ent:IsPlayer() ) then return end
+
+	timer.Simple( timedelay, function() SafeRemoveEntity( ent ) end )
+
+end
+
+--[[---------------------------------------------------------
+	Simple lerp
+-----------------------------------------------------------]]
+function Lerp( delta, from, to )
+
+	if ( delta > 1 ) then return to end
+	if ( delta < 0 ) then return from end
+
+	return from + ( to - from ) * delta
+
+end
+
+--[[---------------------------------------------------------
+	Convert Var to Bool
+-----------------------------------------------------------]]
+function tobool( val )
+	if ( val == nil || val == false || val == 0 || val == "0" || val == "false" ) then return false end
+	return true
+end
+
+--[[---------------------------------------------------------
+	Universal function to filter out crappy models by name
+-----------------------------------------------------------]]
+local UselessModels = {
+	"_gesture", "_anim", "_gst", "_pst", "_shd", "_ss", "_posture", "_anm",
+	"ghostanim","_paths", "_shared", "anim_", "gestures_", "shared_ragdoll_"
+}
+
+function IsUselessModel( modelname )
+
+	modelname = modelname:lower()
+
+	if ( !modelname:find( ".mdl", 1, true ) ) then return true end
+
+	for k, v in ipairs( UselessModels ) do
+		if ( modelname:find( v, 1, true ) ) then
+			return true
+		end
+	end
+
+	return false
+
+end
+
+UTIL_IsUselessModel = IsUselessModel
+
+--[[---------------------------------------------------------
+	Given a number, returns the right 'th
+-----------------------------------------------------------]]
+local STNDRD_TBL = { "st", "nd", "rd" }
+function STNDRD( num )
+	num = num % 100
+	if ( num > 10 and num < 20 ) then
+		return "th"
+	end
+
+	return STNDRD_TBL[ num % 10 ] or "th"
+end
+
+--[[---------------------------------------------------------
+	From Simple Gamemode Base (Rambo_9)
+-----------------------------------------------------------]]
+function TimedSin( freq, min, max, offset )
+	return math.sin( freq * math.tau * CurTime() + offset ) * ( max - min ) * 0.5 + min
+end
+
+--[[---------------------------------------------------------
+	From Simple Gamemode Base (Rambo_9)
+-----------------------------------------------------------]]
+function TimedCos( freq, min, max, offset )
+	return math.cos( freq * math.tau * CurTime() + offset ) * ( max - min ) * 0.5 + min
+end
+
+--[[---------------------------------------------------------
+	IsEnemyEntityName
+-----------------------------------------------------------]]
+local EnemyNames = {
+	-- Half-Life 1.
+	monster_alien_grunt = true, monster_nihilanth = true, monster_tentacle = true, monster_alien_slave = true,
+	monster_bigmomma = true, monster_bullchicken = true, monster_gargantua = true, monster_human_assassin = true,
+	monster_babycrab = true, monster_human_grunt = true, monster_cockroach = true, monster_houndeye = true,
+	monster_zombie = true, monster_headcrab = true, monster_alien_controller = true, monster_turret = true,
+	monster_miniturret = true, monster_sentry = true,
+
+	-- Half-Life 2.
+	npc_antlion = true, npc_antlionguard = true, npc_antlionguardian = true, npc_barnacle = true,
+	npc_breen = true, npc_clawscanner = true, npc_combine_s = true, npc_cscanner = true, npc_fastzombie = true,
+	npc_fastzombie_torso = true, npc_headcrab = true, npc_headcrab_fast = true, npc_headcrab_poison = true,
+	npc_hunter = true, npc_metropolice = true, npc_manhack = true, npc_poisonzombie = true, npc_strider = true,
+	npc_stalker = true, npc_zombie = true, npc_zombie_torso = true, npc_zombine = true, npc_combine_camera = true,
+	npc_turret_ceiling = true, npc_combinedropship = true, npc_combinegunship = true, npc_helicopter = true,
+	npc_turret_floor = true, npc_antlion_worker = true, npc_headcrab_black = true
+}
+
+function IsEnemyEntityName( victimtype )
+	return EnemyNames[ victimtype ] or false
+end
+
+--[[---------------------------------------------------------
+	IsFriendEntityName
+-----------------------------------------------------------]]
+local FriendlyNames = {
+	-- Half-Life 1.
+	monster_scientist = true, monster_barney = true,
+
+	-- Half-Life 2.
+	npc_alyx = true, npc_barney = true, npc_citizen = true, npc_dog = true, npc_eli = true,
+	npc_fisherman = true, npc_gman = true, npc_kleiner = true, npc_magnusson = true,
+	npc_monk = true, npc_mossman = true, npc_odessa = true, npc_vortigaunt = true
+}
+
+function IsFriendEntityName( victimtype )
+	return FriendlyNames[ victimtype ] or false
+end
+
+--[[---------------------------------------------------------
+	Is content mounted?
+		IsMounted( "cstrike" )
+		IsMounted( 4010 )
+-----------------------------------------------------------]]
+function IsMounted( name )
+
+	if ( name == "episodic" || name == "ep2" || name == "lostcoast" ) then
+		name = "hl2"
+	end
+
+	local games = engine.GetGames()
+
+	for k, v in pairs( games ) do
+
+		if ( !v.mounted ) then continue end
+
+		if ( v.depot == name ) then return true end
+		if ( v.folder == name ) then return true end
+
+	end
+
+	return false
+
+end
+
+--[[---------------------------------------------------------
+	Replacement for C++'s iff ? aa : bb
+-----------------------------------------------------------]]
+function Either( iff, aa, bb )
+	if ( iff ) then return aa end
+	return bb
+end
+
+--
+-- You can use this function to add your own CLASS_ var.
+-- Adding in this way will ensure your CLASS_ doesn't collide with another
+--
+-- ie Add_NPC_Class( "MY_CLASS" )
+
+function Add_NPC_Class( name )
+	_G[ name ] = NUM_AI_CLASSES
+	NUM_AI_CLASSES = NUM_AI_CLASSES + 1
+end
+
+if ( CLIENT ) then
+
+	--[[---------------------------------------------------------
+		Remember/Restore cursor position..
+		Clientside only
+		If you have a system where you hold a key to show the cursor
+		Call RememberCursorPosition when the key is released and call
+		RestoreCursorPosition to restore the cursor to where it was
+		when the key was released.
+		If you don't the cursor will appear in the middle of the screen
+	-----------------------------------------------------------]]
+	local StoredCursorPos = {}
+
+	function RememberCursorPosition()
+
+		local x, y = input.GetCursorPos()
+
+		-- If the cursor isn't visible it will return 0,0 ignore it.
+		if ( x == 0 and y == 0 ) then return end
+
+		StoredCursorPos.x, StoredCursorPos.y = x, y
+
+	end
+
+	function RestoreCursorPosition()
+
+		if ( !StoredCursorPos.x || !StoredCursorPos.y ) then return end
+		input.SetCursorPos( StoredCursorPos.x, StoredCursorPos.y )
+
+	end
+
+end
+
+--
+-- This is supposed to be clientside, but was exposed to both states for years due to a bug.
+--
+function CreateClientConVar( name, default, shouldsave, userdata, helptext, min, max )
+
+	local iFlags = 0
+
+	if ( shouldsave || shouldsave == nil ) then
+		iFlags = bit.bor( iFlags, FCVAR_ARCHIVE )
+	end
+
+	if ( userdata ) then
+		iFlags = bit.bor( iFlags, FCVAR_USERINFO )
+	end
+
+	return CreateConVar( name, default, iFlags, helptext, min, max )
+
+end
+
+--[[---------------------------------------------------------
+	Convar access functions
+-----------------------------------------------------------]]
+
+local ConVarCache = {}
+
+function GetConVar( name )
+	local c = ConVarCache[ name ]
+	if ( !c ) then
+		c = GetConVar_Internal( name )
+		if ( !c ) then
+			return
+		end
+
+		ConVarCache[ name ] = c
+	end
+
+	return c
+end
+
+function GetConVarNumber( name )
+	if ( name == "maxplayers" ) then return game.MaxPlayers() end -- Backwards compatibility
+	local c = GetConVar( name )
+	return ( c and c:GetFloat() ) or 0
+end
+
+function GetConVarString( name )
+	if ( name == "maxplayers" ) then return tostring( game.MaxPlayers() ) end -- ew
+	local c = GetConVar( name )
+	return ( c and c:GetString() ) or ""
+end

lua/includes/util/client.lua

@@ -0,0 +1,325 @@
+
+--[[---------------------------------------------------------
+	Get the real frame time, instead of the
+		host_timescale linked frametime. This is for things
+		like GUI effects. NOT FOR REAL IN GAME STUFF(!!!)
+-----------------------------------------------------------]]
+local FrameTime = 0
+local LastQuery = 0
+
+function RealFrameTime() return FrameTime end
+
+local function RealFrameTimeThink()
+
+	FrameTime = math.Clamp( SysTime() - LastQuery, 0, 0.1 )
+	LastQuery = SysTime()
+
+end
+
+hook.Add( "Think", "RealFrameTime", RealFrameTimeThink ) -- Think is called after every frame on the client.
+
+-- Make Portal 2 materials work out of the box
+matproxy.Add( {
+	name = "FizzlerVortex",
+	init = function( self, mat, values )
+	end,
+	bind = function( self, mat, ent )
+		mat:SetFloat( "$flow_color_intensity", 1 )
+
+		-- Less than ideal, but serves as an example
+		--[[local entities = {}
+		for k, v in pairs( ents.FindInSphere( ent:GetPos(), ent:BoundingRadius() ) ) do
+			if ( v == ent || v:GetMoveType() != MOVETYPE_VPHYSICS ) then continue end
+
+			table.insert( entities, v )
+		end
+		table.sort( entities, function( a, b ) return a:GetPos():Distance( ent:GetPos() ) < b:GetPos():Distance( ent:GetPos() ) end )
+
+		if ( entities[ 1 ] ) then
+			mat:SetFloat( "$FLOW_VORTEX1", 1 )
+			mat:SetVector( "$FLOW_VORTEX_POS1", entities[ 1 ]:GetPos() )
+		else
+			mat:SetFloat( "$FLOW_VORTEX1", 0 )
+		end
+		if ( entities[ 2 ] ) then
+			mat:SetFloat( "$FLOW_VORTEX2", 1 )
+			mat:SetVector( "$FLOW_VORTEX_POS2", entities[ 2 ]:GetPos() )
+		else
+			mat:SetFloat( "$FLOW_VORTEX2", 0 )
+		end]]
+	end
+} )
+
+local function RenderSpawnIcon_Prop( model, pos, middle, size )
+
+	if ( size < 900 ) then
+		size = size * ( 1 - ( size / 900 ) )
+	else
+		size = size * ( 1 - ( size / 4096 ) )
+	end
+
+	size = math.Clamp( size, 5, 1000 )
+
+	local ViewAngle = Angle( 25, 220, 0 )
+	local ViewPos = pos + ViewAngle:Forward() * size * -15
+	local view = {}
+
+	view.fov		= 4 + size * 0.04
+	view.origin		= ViewPos + middle
+	view.znear		= 1
+	view.zfar		= ViewPos:Distance( pos ) + size * 2
+	view.angles		= ViewAngle
+
+	return view
+
+end
+
+local function RenderSpawnIcon_Ragdoll( model, pos, middle, size )
+
+	local at = model:GetAttachment( model:LookupAttachment( "eyes" ) )
+	if ( !at ) then at = { Pos = model:GetPos(), Ang = model:GetAngles() } end
+
+	local ViewAngle = at.Ang + Angle( -10, 160, 0 )
+	local ViewPos = at.Pos + ViewAngle:Forward() * -60 + ViewAngle:Up() * -2
+	local view = {}
+
+	view.fov		= 10
+	view.origin		= ViewPos
+	view.znear		= 0.1
+	view.zfar		= 100
+	view.angles		= ViewAngle
+
+	return view
+
+end
+
+--
+-- For some TF2 ragdolls which do not have "eye" attachments
+--
+local function RenderSpawnIcon_Ragdoll_Head( model, pos, middle, size )
+
+	local at = model:GetAttachment( model:LookupAttachment( "head" ) )
+	if ( !at ) then at = { Pos = model:GetPos(), Ang = model:GetAngles() } end
+
+	local ViewAngle = at.Ang + Angle( -10, 160, 0 )
+	local ViewPos = at.Pos + ViewAngle:Forward() * -67 + ViewAngle:Up() * -7 + ViewAngle:Right() * 1.5
+	local view = {}
+
+	view.fov		= 10
+	view.origin		= ViewPos
+	view.znear		= 0.1
+	view.zfar		= 100
+	view.angles		= ViewAngle
+
+	return view
+
+end
+
+local function RenderSpawnIcon_Ragdoll_Facemask( model, pos, middle, size )
+
+	local at = model:GetAttachment( model:LookupAttachment( "facemask" ) )
+	if ( !at ) then at = { Pos = model:GetPos(), Ang = model:GetAngles() } end
+
+	local ViewAngle = at.Ang
+	ViewAngle:RotateAroundAxis( ViewAngle:Right(), -10 )
+	ViewAngle:RotateAroundAxis( ViewAngle:Up(), 160 )
+	local ViewPos = at.Pos + ViewAngle:Forward() * -67 + ViewAngle:Up() * -2 + ViewAngle:Right() * -1
+	local view = {}
+
+	view.fov		= 10
+	view.origin		= ViewPos
+	view.znear		= 0.1
+	view.zfar		= 100
+	view.angles		= ViewAngle
+
+	return view
+
+end
+
+local function RenderSpawnIcon_Ragdoll_Forward( model, pos, middle, size )
+
+	local at = model:GetAttachment( model:LookupAttachment( "forward" ) )
+	if ( !at ) then at = { Pos = model:GetPos(), Ang = model:GetAngles() } end
+
+	local ViewAngle = at.Ang + Angle( 10, -20, 0 )
+	local ViewPos = at.Pos + ViewAngle:Forward() * -67 + ViewAngle:Up() * -1 + ViewAngle:Right() * 2.5
+	local view = {}
+
+	view.fov		= 10
+	view.origin		= ViewPos
+	view.znear		= 0.1
+	view.zfar		= 100
+	view.angles		= ViewAngle
+
+	return view
+
+end
+
+local function RenderSpawnIcon_DOD( model, pos, middle, size )
+
+	local ViewAngle = Angle( 0, 160, 0 )
+	local ViewPos = pos + ViewAngle:Forward() * -67 + ViewAngle:Up() * 30 + ViewAngle:Right() * 2.5
+	local view = {}
+
+	view.fov		= 10
+	view.origin		= ViewPos + middle
+	view.znear		= 1
+	view.zfar		= ViewPos:Distance( pos ) + size * 2
+	view.angles		= ViewAngle
+
+	return view
+
+end
+
+local function RenderSpawnIcon_CS( model, pos, middle, size )
+
+	local ViewAngle = Angle( 0, 160, 0 )
+	local ViewPos = pos + ViewAngle:Forward() * -70 + ViewAngle:Up() * 32.4 + ViewAngle:Right() * 1.5
+	local view = {}
+
+	view.fov		= 10
+	view.origin		= ViewPos + middle
+	view.znear		= 1
+	view.zfar		= ViewPos:Distance( pos ) + size * 2
+	view.angles		= ViewAngle
+
+	return view
+
+end
+
+local function RenderSpawnIcon_Special( model, pos, middle, size, x, y, z )
+
+	local ViewAngle = Angle( 15, 140, 0 )
+	local ViewPos = pos + ViewAngle:Forward() * x + ViewAngle:Up() * y + ViewAngle:Right() * z
+	local view = {}
+
+	view.fov		= 20
+	view.origin		= ViewPos + middle
+	view.znear		= 1
+	view.zfar		= ViewPos:Distance( pos ) + size * 2
+	view.angles		= ViewAngle
+
+	return view
+
+end
+
+SpawniconGenFunctions = {}
+
+function PositionSpawnIcon( model, pos, noAngles )
+
+	local mn, mx = model:GetRenderBounds()
+	local middle = ( mn + mx ) * 0.5
+	local size = 0
+	size = math.max( size, math.abs( mn.x ) + math.abs( mx.x ) )
+	size = math.max( size, math.abs( mn.y ) + math.abs( mx.y ) )
+	size = math.max( size, math.abs( mn.z ) + math.abs( mx.z ) )
+
+	model:SetPos( pos )
+	if ( !noAngles ) then model:SetAngles( angle_zero ) end
+
+	local ModelName = model:GetModel()
+	ModelName = string.Replace( ModelName, "--", "/" )
+	ModelName = string.Replace( ModelName, "\\", "/" )
+	ModelName = string.Replace( ModelName, "//", "/" )
+	ModelName = string.Replace( ModelName, "\\\\", "/" )
+
+	local fnc = SpawniconGenFunctions[ ModelName ]
+	if ( fnc ) then return fnc( model, pos, middle, size ) end
+
+	if ( model:LookupAttachment( "eyes" ) > 0 ) then
+		return RenderSpawnIcon_Ragdoll( model, pos, middle, size )
+	end
+
+	if ( model:LookupAttachment( "head" ) > 0 ) then
+		return RenderSpawnIcon_Ragdoll_Head( model, pos, middle, size )
+	end
+
+	-- CS:GO Player Models
+	if ( model:LookupAttachment( "facemask" ) > 0 ) then
+		return RenderSpawnIcon_Ragdoll_Facemask( model, pos, middle, size )
+	end
+
+	-- CS:GO Hostages
+	if ( model:LookupAttachment( "forward" ) > 0 ) then
+		return RenderSpawnIcon_Ragdoll_Forward( model, pos, middle, size )
+	end
+
+	return RenderSpawnIcon_Prop( model, pos, middle, size )
+
+end
+
+-- DOD Player Models
+SpawniconGenFunctions[ "models/player/american_assault.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/american_mg.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/american_rifleman.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/american_rocket.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/american_sniper.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/american_support.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/german_assault.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/german_mg.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/german_rifleman.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/german_rocket.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/german_sniper.mdl" ] = RenderSpawnIcon_DOD
+SpawniconGenFunctions[ "models/player/german_support.mdl" ] = RenderSpawnIcon_DOD
+
+-- CS Player Models
+SpawniconGenFunctions[ "models/player/ct_gign.mdl" ] = RenderSpawnIcon_CS
+SpawniconGenFunctions[ "models/player/ct_sas.mdl" ] = RenderSpawnIcon_CS
+SpawniconGenFunctions[ "models/player/ct_urban.mdl" ] = RenderSpawnIcon_CS
+SpawniconGenFunctions[ "models/player/ct_gsg9.mdl" ] = RenderSpawnIcon_CS
+SpawniconGenFunctions[ "models/player/t_leet.mdl" ] = RenderSpawnIcon_CS
+SpawniconGenFunctions[ "models/player/t_phoenix.mdl" ] = RenderSpawnIcon_CS
+SpawniconGenFunctions[ "models/player/t_arctic.mdl" ] = RenderSpawnIcon_CS
+SpawniconGenFunctions[ "models/player/t_guerilla.mdl" ] = RenderSpawnIcon_CS
+
+-- L4D Models
+SpawniconGenFunctions[ "models/infected/witch.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -40, 25, 0 ) end
+SpawniconGenFunctions[ "models/infected/smoker.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -60, 33, 10 ) end
+SpawniconGenFunctions[ "models/infected/hunter.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -50, 26, 2 ) end
+SpawniconGenFunctions[ "models/infected/hulk.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -70, 30, 11 ) end
+SpawniconGenFunctions[ "models/infected/boomer.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -50, 27, 0 ) end
+
+SpawniconGenFunctions[ "models/infected/common_female01.mdl" ] = function ( model, pos, middle, size )
+
+	local at = model:GetAttachment( model:LookupAttachment( "forward" ) )
+	if ( !at ) then at = { Pos = model:GetPos(), Ang = model:GetAngles() } end
+
+	local ViewAngle = at.Ang + Angle( 180, 180, 0 ) + Angle( 10, -85, -85 )
+	local ViewPos = at.Pos + ViewAngle:Forward() * -76 + ViewAngle:Up() * -1.5 + ViewAngle:Right() * 0
+	return { fov = 10, origin = ViewPos, znear = 0.1, zfar = 200, angles = ViewAngle }
+
+end
+
+SpawniconGenFunctions[ "models/infected/common_female_nurse01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_female01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_female_rural01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_female01.mdl" ]
+
+SpawniconGenFunctions[ "models/infected/common_male01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_female01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_test.mdl" ] = SpawniconGenFunctions[ "models/infected/common_female01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_morph_test.mdl" ] = SpawniconGenFunctions[ "models/infected/common_female01.mdl" ] -- Bad start animation
+SpawniconGenFunctions[ "models/infected/common_male_fallen_survivor.mdl" ] = SpawniconGenFunctions[ "models/infected/common_female01.mdl" ] -- Bad start animation
+
+SpawniconGenFunctions[ "models/infected/common_male_baggagehandler_01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_male01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_male_pilot.mdl" ] = SpawniconGenFunctions[ "models/infected/common_male01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_male_rural01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_male01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_male_suit.mdl" ] = SpawniconGenFunctions[ "models/infected/common_male01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_military_male01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_male01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_police_male01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_male01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_patient_male01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_male01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_surgeon_male01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_male01.mdl" ] -- Bad start animation
+SpawniconGenFunctions[ "models/infected/common_tsaagent_male01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_male01.mdl" ]
+SpawniconGenFunctions[ "models/infected/common_worker_male01.mdl" ] = SpawniconGenFunctions[ "models/infected/common_male01.mdl" ]
+
+-- ZPS Zombies
+SpawniconGenFunctions[ "models/zombies/zombie0/zombie0.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -100, 17, 10 ) end
+SpawniconGenFunctions[ "models/zombies/zombie1/zombie1.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -100, 17, 10 ) end
+SpawniconGenFunctions[ "models/zombies/zombie2/zombie2.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -100, 17, 10 ) end
+SpawniconGenFunctions[ "models/zombies/zombie3/zombie3.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -100, 17, 10 ) end
+SpawniconGenFunctions[ "models/zombies/zombie4/zombie4.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -100, 17, 10 ) end
+SpawniconGenFunctions[ "models/zombies/zombie5/zombie5.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -100, 17, 10 ) end
+
+-- L4D2
+SpawniconGenFunctions[ "models/infected/boomette.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -50, 28, 0 ) end
+SpawniconGenFunctions[ "models/infected/charger.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -70, 14, 20 ) end
+SpawniconGenFunctions[ "models/infected/jockey.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -50, 0, 7 ) end
+SpawniconGenFunctions[ "models/infected/spitter.mdl" ] = function( a, b, c, d ) return RenderSpawnIcon_Special( a, b, c, d, -1, 0, -70 ) end -- as good as deleted
+SpawniconGenFunctions[ "models/infected/hulk_dlc3.mdl" ] = SpawniconGenFunctions[ "models/infected/hulk.mdl" ]

lua/includes/util/color.lua

@@ -0,0 +1,427 @@
+
+local COLOR = {}
+COLOR.__index = COLOR
+
+--[[---------------------------------------------------------
+	Register our metatable to make it accessible using FindMetaTable
+-----------------------------------------------------------]]
+RegisterMetaTable( "Color", COLOR )
+
+--[[---------------------------------------------------------
+	To easily create a color table
+-----------------------------------------------------------]]
+function Color( r, g, b, a )
+
+	return setmetatable( {
+		r = math.min( tonumber( r ), 255 ),
+		g = math.min( tonumber( g ), 255 ),
+		b = math.min( tonumber( b ), 255 ),
+		a = math.min( tonumber( a or 255 ), 255 )
+	}, COLOR )
+
+end
+
+--[[---------------------------------------------------------
+	Change the alpha of a color
+-----------------------------------------------------------]]
+function ColorAlpha( c, a )
+
+	return Color( c.r, c.g, c.b, a )
+
+end
+
+--[[---------------------------------------------------------
+	Checks if the given variable is a color object
+-----------------------------------------------------------]]
+function IsColor( obj )
+
+	return getmetatable( obj ) == COLOR
+
+end
+
+--[[---------------------------------------------------------
+	Different color represntations
+-----------------------------------------------------------]]
+function HSVToColor( h, s, v )
+
+	h = h % 360
+
+	local c = v * s
+	local x = c * ( 1 - math.abs( ( h / 60 ) % 2 - 1 ) )
+	local m = v - c
+
+	local r, g, b
+	if ( h < 60 ) then
+		r, g, b = c, x, 0
+	elseif ( h < 120 ) then
+		r, g, b = x, c, 0
+	elseif ( h < 180 ) then
+		r, g, b = 0, c, x
+	elseif ( h < 240 ) then
+		r, g, b = 0, x, c
+	elseif ( h < 300 ) then
+		r, g, b = x, 0, c
+	else
+		r, g, b = c, 0, x
+	end
+
+	return Color(
+		math.Clamp( math.floor( ( r + m ) * 255 ), 0, 255 ),
+		math.Clamp( math.floor( ( g + m ) * 255 ), 0, 255 ),
+		math.Clamp( math.floor( ( b + m ) * 255 ), 0, 255 )
+	)
+
+end
+
+function HSLToColor( h, s, l )
+
+	h = h % 360
+
+	local c = ( 1 - math.abs( 2 * l - 1 ) ) * s
+	local x = c * ( 1 - math.abs( ( h / 60 ) % 2 - 1 ) )
+	local m = l - c / 2
+
+	local r, g, b
+	if ( h < 60 ) then
+		r, g, b = c, x, 0
+	elseif ( h < 120 ) then
+		r, g, b = x, c, 0
+	elseif ( h < 180 ) then
+		r, g, b = 0, c, x
+	elseif ( h < 240 ) then
+		r, g, b = 0, x, c
+	elseif ( h < 300 ) then
+		r, g, b = x, 0, c
+	else
+		r, g, b = c, 0, x
+	end
+
+	return Color(
+		math.Clamp( math.floor( ( r + m ) * 255 ), 0, 255 ),
+		math.Clamp( math.floor( ( g + m ) * 255 ), 0, 255 ),
+		math.Clamp( math.floor( ( b + m ) * 255 ), 0, 255 )
+	)
+
+end
+
+function HWBToColor( h, w, b )
+
+	local v = 1 - b
+	local s = 0
+	if ( v > 0 ) then
+		s = 1 - w / v
+	end
+
+	return HSVToColor( h, s, v )
+
+end
+
+local hex_to_dec = {}
+for code = 48, 57 do hex_to_dec[ code ] = code - 48 end  -- '0'–'9'
+for code = 65, 70 do hex_to_dec[ code ] = code - 55 end  -- 'A'–'F'
+for code = 97, 102 do hex_to_dec[ code ] = code - 87 end -- 'a'–'f'
+
+function HexToColor( hex )
+
+	local idx = string.byte( hex, 1 ) == 35 and 2 or 1 -- '#' check without allocation
+	local len = #hex - ( idx - 1 )
+
+	if ( len == 3 or len == 4 ) then
+
+		local r, g, b, a = string.byte( hex, idx, idx + len - 1 )
+		r = hex_to_dec[ r ]
+		g = hex_to_dec[ g ]
+		b = hex_to_dec[ b ]
+		a = a and hex_to_dec[ a ] or 15
+
+		if !( r and g and b and a ) then
+			return error( "invalid hex input: " .. hex )
+		end
+
+		return Color( r * 16 + r, g * 16 + g, b * 16 + b, a * 16 + a )
+
+	elseif ( len == 6 or len == 8 ) then
+
+		local r1, r2, g1, g2, b1, b2, a1, a2 = string.byte( hex, idx, idx + len - 1 )
+		r1, r2 = hex_to_dec[ r1 ], hex_to_dec[ r2 ]
+		g1, g2 = hex_to_dec[ g1 ], hex_to_dec[ g2 ]
+		b1, b2 = hex_to_dec[ b1 ], hex_to_dec[ b2 ]
+		a1, a2 = a1 and hex_to_dec[ a1 ] or 15, a2 and hex_to_dec[ a2 ] or 15
+
+		if !( r1 and r2 and g1 and g2 and b1 and b2 and a1 and a2 ) then
+			return error( "invalid hex input: " .. hex )
+		end
+
+		return Color( r1 * 16 + r2, g1 * 16 + g2, b1 * 16 + b2, a1 * 16 + a2 )
+
+	end
+
+	return error( "invalid hex input: " .. hex )
+
+end
+
+--[[---------------------------------------------------------
+	Returns color as a string
+-----------------------------------------------------------]]
+function COLOR:__tostring()
+
+	return string.format( "%d %d %d %d", self.r, self.g, self.b, self.a )
+
+end
+
+--[[---------------------------------------------------------
+	Compares two colors
+-----------------------------------------------------------]]
+function COLOR:__eq( c )
+
+	return self.r == c.r and self.g == c.g and self.b == c.b and self.a == c.a
+
+end
+
+--[[---------------------------------------------------------
+	Converts a color to HSL color space
+-----------------------------------------------------------]]
+function COLOR:ToHSL()
+
+	return ColorToHSL( self )
+
+end
+
+--[[---------------------------------------------------------
+	Converts a color to HSV color space
+-----------------------------------------------------------]]
+function COLOR:ToHSV()
+
+	return ColorToHSV( self )
+
+end
+
+--[[---------------------------------------------------------
+	Converts a color to HWB color space
+-----------------------------------------------------------]]
+function COLOR:ToHWB()
+
+	local h, s, v = self:ToHSV()
+	return h, ( 1 - s ) * v, 1 - v
+
+end
+
+--[[---------------------------------------------------------
+	Converts color to a hex string
+-----------------------------------------------------------]]
+function COLOR:ToHex( omitAlpha )
+
+	if ( omitAlpha or self.a == 255 ) then
+		return string.format( "#%02x%02x%02x", self.r, self.g, self.b )
+	end
+
+	return string.format( "#%02x%02x%02x%02x", self.r, self.g, self.b, self.a )
+
+end
+
+--[[---------------------------------------------------------
+	Converts color to vector - loss of precision / alpha lost
+-----------------------------------------------------------]]
+function COLOR:ToVector()
+
+	return Vector( self.r / 255, self.g / 255, self.b / 255 )
+
+end
+
+--[[---------------------------------------------------------
+	Unpacks the color into four variables
+-----------------------------------------------------------]]
+function COLOR:Unpack()
+
+	return self.r, self.g, self.b, self.a
+
+end
+
+function COLOR:Copy()
+
+    return Color( self.r, self.g, self.b, self.a )
+
+end
+
+function COLOR:Lerp( target_clr, frac )
+
+	return Color(
+		Lerp( frac, self.r, target_clr.r ),
+		Lerp( frac, self.g, target_clr.g ),
+		Lerp( frac, self.b, target_clr.b ),
+		Lerp( frac, self.a, target_clr.a )
+	)
+
+end
+
+function COLOR:SetUnpacked( r, g, b, a )
+
+	if ( r != nil and !isnumber( r ) ) then error( "bad argument #1 to 'SetUnpacked' (number expected, got " .. type( r ) .. ")", 2 ) end
+	if ( g != nil and !isnumber( g ) ) then error( "bad argument #2 to 'SetUnpacked' (number expected, got " .. type( g ) .. ")", 2 ) end
+	if ( b != nil and !isnumber( b ) ) then error( "bad argument #3 to 'SetUnpacked' (number expected, got " .. type( b ) .. ")", 2 ) end
+	if ( a != nil and !isnumber( a ) ) then error( "bad argument #4 to 'SetUnpacked' (number expected, got " .. type( a ) .. ")", 2 ) end
+
+	self.r = r or 255
+	self.g = g or 255
+	self.b = b or 255
+	self.a = a or 255
+
+end
+
+function COLOR:ToTable()
+
+	return { self.r, self.g, self.b, self.a }
+
+end
+
+local function ColorCopy( dest, origin )
+
+	dest.r = origin.r
+	dest.g = origin.g
+	dest.b = origin.b
+
+end
+
+-- HSV hue
+function COLOR:GetHue()
+
+	local hue = self:ToHSV()
+	return hue
+
+end
+
+function COLOR:SetHue( hue )
+
+	local _, saturation, brightness = self:ToHSV()
+	hue = hue % 360
+	ColorCopy( self, HSVToColor( hue, saturation, brightness ) )
+
+end
+
+function COLOR:AddHue( hueAdd )
+
+	local hue, saturation, brightness = self:ToHSV()
+	hue = ( hue + hueAdd ) % 360
+	ColorCopy( self, HSVToColor( hue, saturation, brightness ) )
+
+end
+
+-- HSV saturation
+function COLOR:GetSaturation()
+
+	local _, saturation = self:ToHSV()
+	return saturation
+
+end
+
+function COLOR:SetSaturation( saturation )
+
+	local hue, _, brightness = self:ToHSV()
+	saturation = math.Clamp( saturation, 0, 1 )
+	ColorCopy( self, HSVToColor( hue, saturation, brightness ) )
+
+end
+
+function COLOR:AddSaturation( saturationAdd )
+
+	local hue, saturation, brightness = self:ToHSV()
+	saturation = math.Clamp( saturation + saturationAdd, 0, 1 )
+	ColorCopy( self, HSVToColor( hue, saturation, brightness ) )
+
+end
+
+-- HSV brightness
+function COLOR:GetBrightness()
+
+	local _, _, brightness = self:ToHSV()
+	return brightness
+
+end
+
+function COLOR:SetBrightness( brightness )
+
+	local hue, saturation = self:ToHSV()
+	brightness = math.Clamp( brightness, 0, 1 )
+	ColorCopy( self, HSVToColor( hue, saturation, brightness ) )
+
+end
+
+function COLOR:AddBrightness( brightnessAdd )
+
+	local hue, saturation, brightness = self:ToHSV()
+	brightness = math.Clamp( brightness + brightnessAdd, 0, 1 )
+	ColorCopy( self, HSVToColor( hue, saturation, brightness ) )
+
+end
+
+-- HSL lightness
+function COLOR:GetLightness()
+
+	local _, _, lightness = self:ToHSL()
+	return lightness
+
+end
+
+function COLOR:SetLightness( lightness )
+
+	local hue, saturation = self:ToHSL()
+	lightness = math.Clamp( lightness, 0, 1 )
+	ColorCopy( self, HSLToColor( hue, saturation, lightness ) )
+
+end
+
+function COLOR:AddLightness( lightnessAdd )
+
+	local hue, saturation, lightness = self:ToHSL()
+	lightness = math.Clamp( lightness + lightnessAdd, 0, 1 )
+	ColorCopy( self, HSLToColor( hue, saturation, lightness ) )
+
+end
+
+-- HWB whiteness
+function COLOR:GetWhiteness()
+
+	local _, whiteness = self:ToHWB()
+	return whiteness
+
+end
+
+function COLOR:SetWhiteness( whiteness )
+
+	local hue, _, blackness = self:ToHWB()
+	whiteness = math.Clamp( whiteness, 0, 1 )
+	ColorCopy( self, HWBToColor( hue, whiteness, blackness ) )
+
+end
+
+function COLOR:AddWhiteness( whitenessAdd )
+
+	local hue, whiteness, blackness = self:ToHWB()
+	whiteness = math.Clamp( whiteness + whitenessAdd, 0, 1 )
+	ColorCopy( self, HWBToColor( hue, whiteness, blackness ) )
+
+end
+
+-- HWB blackness
+function COLOR:GetBlackness()
+
+	local _, _, blackness = self:ToHWB()
+	return blackness
+
+end
+
+function COLOR:SetBlackness( blackness )
+
+	local hue, whiteness = self:ToHWB()
+	blackness = math.Clamp( blackness, 0, 1 )
+	ColorCopy( self, HWBToColor( hue, whiteness, blackness ) )
+
+end
+
+function COLOR:AddBlackness( blacknessAdd )
+
+	local hue, whiteness, blackness = self:ToHWB()
+	blackness = math.Clamp( blackness + blacknessAdd, 0, 1 )
+	ColorCopy( self, HWBToColor( hue, whiteness, blackness ) )
+
+end

lua/includes/util/javascript_util.lua

@@ -0,0 +1,40 @@
+
+function JS_Language( html )
+
+	html:AddFunction( "language", "Update", function( phrase )
+		if ( !phrase ) then return end
+		return language.GetPhrase( phrase )
+	end )
+
+end
+
+function JS_Utility( html )
+
+	html:AddFunction( "util", "MotionSensorAvailable", function()
+		return motionsensor.IsAvailable()
+	end )
+
+end
+
+function JS_Workshop( html )
+
+	html:AddFunction( "gmod", "OpenWorkshopFile", function( param ) steamworks.ViewFile( param ) end )
+	html:AddFunction( "gmod", "DeleteLocal", function( param ) file.Delete( param, "MOD" ) end )
+	html:AddFunction( "gmod", "FetchItems", function( namespace, cat, offset, perpage, extraTags, searchText, filter, sort )
+		_G[ namespace ]:Fetch( cat, tonumber( offset ), tonumber( perpage ), string.Explode( ",", extraTags ), searchText, filter, sort )
+	end )
+	html:AddFunction( "gmod", "Vote", function( id, vote ) steamworks.Vote( id, tobool( vote ) ) end )
+	html:AddFunction( "gmod", "SetFavorite", function( id, vote ) steamworks.SetFavorite( id, tobool( vote ) ) end )
+	html:AddFunction( "gmod", "Publish", function( namespace, filePath, background ) _G[ namespace ]:Publish( filePath, background ) end )
+
+	// Dupes
+	html:AddFunction( "gmod", "DownloadDupe", function( param ) ws_dupe:DownloadAndArm( param ) end )
+	html:AddFunction( "gmod", "ArmDupe", function( param ) ws_dupe:Arm( param ) end )
+	html:AddFunction( "gmod", "SaveDupe", function() RunConsoleCommand( "dupe_save", "spawnmenu" ) end )
+
+	// Saves
+	html:AddFunction( "gmod", "DownloadSave", function( param ) ws_save:DownloadAndLoad( param ) end )
+	html:AddFunction( "gmod", "LoadSave", function( param ) ws_save:Load( param ) end )
+	html:AddFunction( "gmod", "SaveSave", function() RunConsoleCommand( "gm_save", "spawnmenu" ) end )
+
+end

lua/includes/util/model_database.lua

@@ -0,0 +1,93 @@
+--=============================================================================--
+--  ___  ___   _   _   _    __   _   ___ ___ __ __
+-- |_ _|| __| / \ | \_/ |  / _| / \ | o \ o \\ V /
+--  | | | _| | o || \_/ | ( |_n| o ||   /   / \ / 
+--  |_| |___||_n_||_| |_|  \__/|_n_||_|\\_|\\ |_|  2007
+--										 
+--=============================================================================--
+
+local DatabasedModels = {}
+
+if ( !sql.TableExists( "modelinfo" ) ) then
+
+	sql.Query( [[CREATE TABLE IF NOT EXISTS modelinfo ( name TEXT NOT NULL PRIMARY KEY, 
+														poseparams INTEGER,
+														numsequences INTEGER,
+														numattachments INTEGER,
+														numbonecontrollers INTEGER,
+														numskins INTEGER,
+														size INTEGER );]] )
+	
+end
+
+--[[---------------------------------------------------------
+    Called from the engine on model load to enable Lua to cache
+	the model stats in a database, so that rather than building
+	all in one go, they'll get updated as the player plays.
+-----------------------------------------------------------]]
+function OnModelLoaded( ModelName, NumPoseParams, NumSeq, NumAttachments, NumBoneControllers, NumSkins, Size )
+
+	local ModelName = string.lower( string.gsub( ModelName, "\\", "/" ) )
+	ModelName = "models/".. ModelName
+
+	-- No need to store a model more than once per session
+	if ( DatabasedModels[ ModelName ] ) then return end
+	DatabasedModels[ ModelName ] = true
+	
+	-- Just in case. Don't want errors spewing all over 
+	--  the place every time a model loads.
+	if ( !sql.TableExists( "modelinfo" ) ) then return end
+	
+	local safeModelName = SQLStr( ModelName )
+	
+	--
+	-- We delete the old entry because this model may have been updated.
+	-- The chances are very slim, but there's no real harm in it.
+	--
+	sql.Query( "DELETE FROM modelinfo WHERE model = "..safeModelName )
+	sql.Query( Format( [[INSERT INTO modelinfo ( name, 
+												poseparams, 
+												numsequences, 
+												numattachments, 
+												numbonecontrollers, 
+												numskins, 
+												size ) 
+								
+												VALUES 
+							
+												( %s, %i, %i, %i, %i, %i, %i ) ]], 
+							
+												safeModelName,
+												NumPoseParams,
+												NumSeq, 
+												NumAttachments,
+												NumBoneControllers, 
+												NumSkins,
+												Size							
+												) )
+	--[[
+	MsgN( ModelName, 
+		"\nNumPoseParams: ", NumPoseParams,
+		"\nNumSeq: ", NumSeq, 
+		"\nNumAttachments: ", NumAttachments, 
+		"\nNumBoneControllers: ", NumBoneControllers, 
+		"\nNumSkins: ", NumSkins, 
+		"\nSize: ", Size )
+	--]]
+
+end
+
+--[[---------------------------------------------------------
+    Returns the number of skins this model has. If we don't
+	know, it will return 0
+-----------------------------------------------------------]]
+function NumModelSkins( ModelName )
+
+	local ModelName = string.lower( ModelName )
+	local safeModelName = SQLStr( ModelName )
+	local num = sql.QueryValue( "SELECT numskins FROM modelinfo WHERE name = " .. safeModelName )
+	if ( num == nil ) then return 0 end
+	
+	return tonumber( num ) or 0
+
+end

lua/includes/util/sql.lua

@@ -0,0 +1,109 @@
+
+-- Return if there's nothing to add on to
+if ( !sql ) then return end
+
+
+--[[----------------------------------------------------------
+	Attempts to make a string safe to put into the database
+------------------------------------------------------------]]
+function sql.SQLStr( str_in, bNoQuotes )
+
+	local str = tostring( str_in )
+
+	str = str:gsub( "'", "''" )
+
+	local null_chr = string.find( str, "\0" )
+	if ( null_chr ) then
+		str = string.sub( str, 1, null_chr - 1 )
+	end
+
+	if ( bNoQuotes ) then
+		return str
+	end
+
+	return "'" .. str .. "'"
+end
+
+SQLStr = sql.SQLStr
+
+
+--[[---------------------------------------------------------
+	Returns true if the table exists. False if it doesn't
+-----------------------------------------------------------]]
+function sql.TableExists( name )
+
+	local r = sql.Query( "SELECT name FROM sqlite_master WHERE name=" .. SQLStr( name ) .. " AND type='table'" )
+
+	return r and true or false
+
+end
+
+--[[---------------------------------------------------------
+	Returns true if the index exists. False if it doesn't
+-----------------------------------------------------------]]
+function sql.IndexExists( name )
+
+	local r = sql.Query( "SELECT name FROM sqlite_master WHERE name=" .. SQLStr( name ) .. " AND type='index'" )
+
+	return r and true or false
+
+end
+
+--[[---------------------------------------------------------
+	Query and get a single row
+	eg sql.QueryRow( "SELECT * from ratings LIMIT 1" )
+-----------------------------------------------------------]]
+function sql.QueryRow( query, row )
+
+	row = row or 1
+
+	local r = sql.Query( query )
+
+	if ( r ) then return r[ row ] end
+
+	return r
+
+end
+
+--[[---------------------------------------------------------
+	Query and get a single value
+	eg sql.QueryValue( "SELECT count(*) from ratings" )
+-----------------------------------------------------------]]
+function sql.QueryValue( query )
+
+	local r = sql.QueryRow( query )
+
+	if ( r ) then
+
+		-- Is this really the best way to get the first/only value in a table
+		for k, v in pairs( r ) do return v end
+
+	end
+
+	return r
+
+end
+
+--[[---------------------------------------------------------
+	Call before lots of inserts (100+), will hold off writing to disk
+	until Commit is called, which will increase performance (a lot)
+-----------------------------------------------------------]]
+function sql.Begin()
+	sql.Query( "BEGIN;" )
+end
+
+
+--[[---------------------------------------------------------
+	See Above
+-----------------------------------------------------------]]
+function sql.Commit()
+	sql.Query( "COMMIT;" )
+end
+
+
+--[[----------------------------------------------------------
+	m_strError is set by the dll
+------------------------------------------------------------]]
+function sql.LastError()
+	return sql.m_strError
+end

lua/includes/util/tooltips.lua

@@ -0,0 +1,81 @@
+
+local Tooltip = nil
+--local TooltippedPanel = nil
+
+--[[---------------------------------------------------------
+	Name: ChangeTooltip
+	Called from engine on hovering over a panel
+-----------------------------------------------------------]]
+function RemoveTooltip()
+
+	if ( !IsValid( Tooltip ) ) then return true end
+
+	-- Helper for SetTooltipPanelOverride
+	if ( Tooltip.Close ) then Tooltip:Close() else Tooltip:Remove() end
+	Tooltip = nil
+
+	return true
+
+end
+
+--[[---------------------------------------------------------
+	Name: FindTooltip
+-----------------------------------------------------------]]
+function FindTooltip( panel )
+
+	-- Look at the parent panel for tooltips.
+	while ( IsValid( panel ) ) do
+
+		if ( panel.strTooltipText || panel.pnlTooltipPanel || panel.pnlTooltipPanelOverride ) then
+			return panel.strTooltipText, panel.pnlTooltipPanel, panel, panel.pnlTooltipPanelOverride
+		end
+
+		panel = panel:GetParent()
+
+	end
+
+end
+
+--[[---------------------------------------------------------
+	Name: ChangeTooltip
+	Called from engine on hovering over a panel
+-----------------------------------------------------------]]
+function ChangeTooltip( panel )
+
+	RemoveTooltip()
+
+	local Text, ContentPanel, PositionPanel, PanelOverride = FindTooltip( panel )
+	if ( !Text && !IsValid( ContentPanel ) && !PanelOverride ) then return end
+
+	Tooltip = vgui.Create( PanelOverride or "DTooltip" )
+
+	if ( Text ) then
+
+		Tooltip:SetText( Text )
+
+	elseif ( IsValid( ContentPanel ) ) then
+
+		Tooltip:SetContents( ContentPanel, false )
+
+	end
+
+	Tooltip:OpenForPanel( PositionPanel )
+	--TooltippedPanel = panel
+
+end
+
+--[[---------------------------------------------------------
+	Name: EndTooltip
+	Called from engine on exiting from a panel
+-----------------------------------------------------------]]
+function EndTooltip( panel )
+
+	-- Don't do these checks, the engine has a problem with determing
+	-- which panel is currently being hovered in some very specific and unknown conditions
+
+	--if ( !IsValid( TooltippedPanel ) ) then return end
+	--if ( TooltippedPanel != panel ) then return end
+
+	RemoveTooltip()
+
+end

lua/includes/util/vgui_showlayout.lua

@@ -0,0 +1,41 @@
+
+local Panels = {}
+
+hook.Add( "DrawOverlay", "VGUIShowLayoutPaint", function()
+
+	for panel, data in pairs( Panels ) do
+
+		if ( panel:IsValid() ) then
+
+			local x, y = panel:LocalToScreen( 0, 0 )
+
+			local Alpha = math.Clamp( (data.Time - SysTime()) / 0.3, 0, 1 ) * 100
+
+			surface.SetDrawColor( 255, 0, 0, Alpha )
+			surface.DrawRect( x, y, panel:GetWide(), panel:GetTall() )
+
+			surface.SetDrawColor( 0, 255, 0, Alpha )
+			surface.DrawOutlinedRect( x, y, panel:GetWide(), panel:GetTall() )
+
+			-- vgui_visualizelayout 2?
+			-- draw.SimpleText( panel:GetZPos(), "Default", x + 3, y, color_white )
+
+		end
+
+		if ( !panel:IsValid() || data.Time < SysTime() ) then
+			Panels[ panel ] = nil
+		end
+
+	end
+
+end )
+
+-- Called from the engine
+function VisualizeLayout( panel )
+
+	local tab = {}
+	tab.Time = SysTime() + 0.3
+
+	Panels[ panel ] = tab
+
+end

lua/includes/util/workshop_files.lua

@@ -0,0 +1,298 @@
+
+local PreviewCache = {}
+local InfoCache = {}
+local ListCache = {}
+
+function WorkshopFileBase( namespace, requiredtags )
+
+	local ret = {}
+	ret.HTML = nil
+
+	function ret:Fetch( type, offset, perpage, extratags, searchText, filter, sort )
+
+		local tags = table.Copy( requiredtags )
+		for k, v in pairs( extratags ) do
+			if ( v == "" ) then continue end
+			table.insert( tags, v )
+		end
+
+		if ( type == "local" ) then
+			return self:FetchLocal( offset, perpage )
+		end
+		if ( type == "subscribed" ) then
+			return self:FetchSubscribed( offset, perpage, tags, searchText, false, filter, sort )
+		end
+		if ( type == "subscribed_ugc" ) then
+			return self:FetchSubscribed( offset, perpage, tags, searchText, true, filter, sort )
+		end
+
+		local userid = "0"
+		if ( type == "mine" ) then userid = "1" end
+
+		local cachename = type .. "-" .. table.concat( tags, "/" ) .. offset .. "-" .. perpage .. "-" .. userid
+
+		if ( type != "favorite" && ListCache[ cachename ] ) then
+			self:FillFileInfo( ListCache[ cachename ] )
+			return
+		end
+
+		steamworks.GetList( type, tags, offset, perpage, 0, userid, function( data )
+			if ( type != "favorite" ) then ListCache[ cachename ] = data end
+			self:FillFileInfo( data )
+		end )
+
+	end
+
+	function ret:FetchSubscribed( offset, perpage, tags, searchText, isUGC, filter, sort )
+
+		local subscriptions = {}
+		if ( isUGC ) then
+			subscriptions = engine.GetUserContent()
+		else
+			subscriptions = engine.GetAddons()
+		end
+
+		for id, e in pairs( subscriptions ) do
+			if ( e.timeadded == 0 ) then e.timeadded = os.time() end
+		end
+
+		if ( sort == "title" ) then
+			table.sort( subscriptions, function( a, b )
+				return a.title:lower() < b.title:lower()
+			end )
+		elseif ( sort == "size" ) then
+			table.sort( subscriptions, function( a, b )
+				return a.size > b.size
+			end )
+		elseif ( sort == "updated" ) then
+			table.sort( subscriptions, function( a, b )
+				return a.updated > b.updated
+			end )
+		else
+			table.sort( subscriptions, function( a, b )
+				return a.timeadded > b.timeadded
+			end )
+		end
+
+		-- First build a list of items that fit our search terms
+		local searchedItems = {}
+		local localFileHack = -1
+		for id, item in pairs( subscriptions ) do
+
+			-- This is a dirty hack for local addons, ideally should be done in engine, or not use solely IDs to identify addons
+			if ( item.wsid == "0" ) then
+				item.wsid = tostring( localFileHack ) -- why is this a string?
+				localFileHack = localFileHack - 1
+			end
+
+			-- Search for tags
+			local found = true
+			for _, tag in pairs( tags ) do
+				if ( !item.tags:lower():find( tag, 1, true ) ) then found = false end
+			end
+			if ( !found ) then continue end
+
+			-- Search for searchText
+			if ( searchText:Trim() != "" && !item.title:lower():find( searchText:lower(), 1, true ) ) then
+				continue
+			end
+
+			if ( filter && filter == "enabledonly" && !steamworks.ShouldMountAddon( item.wsid ) ) then
+				continue
+			end
+			if ( filter && filter == "disabledonly" && steamworks.ShouldMountAddon( item.wsid ) ) then
+				continue
+			end
+
+			searchedItems[ #searchedItems + 1 ] = item
+
+		end
+
+		-- Build the page!
+		local data = {
+			totalresults = #searchedItems,
+			extraresults = {}, -- The local info about the addon
+			otherresults = {}, -- The complete list of IDs that match the search query for the Addons menu UI
+			results = {}
+		}
+
+		-- Add the list of all items for "select all" in the UI
+		local i = 0
+		for id, item in ipairs( searchedItems ) do
+			data.otherresults[ i ] = item.wsid
+			i = i + 1
+		end
+
+		-- Add the actual results for the requested range
+		local p = 0
+		while ( p < perpage ) do
+
+			if ( searchedItems[ offset + p + 1 ] ) then
+
+				local res = table.insert( data.results, searchedItems[ offset + p + 1 ].wsid )
+				data.extraresults[ res ] = searchedItems[ offset + p + 1 ]
+
+			end
+
+			p = p + 1
+
+		end
+
+		self:FillFileInfo( data, isUGC )
+
+	end
+
+	function ret:RetrieveUserName( steamid, func )
+		steamworks.RequestPlayerInfo( steamid, function( name )
+			self.HTML:Call( namespace .. ".ReceiveUserName( \"" .. steamid:JavascriptSafe() .. "\", \"" .. name:JavascriptSafe() .. "\" )" )
+			if ( func ) then func( name ) end
+		end )
+	end
+
+	function ret:FillFileInfo( results, isUGC )
+
+		--
+		-- File info failed..
+		--
+		if ( !results ) then return end
+
+		--
+		-- Send the file index..
+		--
+		local json = util.TableToJSON( results, false )
+		self.HTML:Call( namespace .. ".ReceiveIndex( " .. json .. " )" )
+
+		--
+		-- Request info on each file..
+		--
+		for k, v in pairs( results.results ) do
+
+			v = v:JavascriptSafe()
+
+			--
+			-- Got it cached?
+			--
+			if ( PreviewCache[ v ] ) then
+
+				self.HTML:Call( namespace .. ".ReceiveImage( \"" .. v .. "\", \"" .. PreviewCache[ v ] .. "\" )" )
+
+			end
+
+			--
+			-- Get the file information
+			--
+			if ( tonumber( v ) <= 0 ) then
+
+				-- Local addon
+				local extra = results.extraresults[ k ]
+				if ( !extra ) then extra = {} end
+
+				extra.ownername = "Local"
+				extra.description = "Non workshop .gma addon. (" .. extra.file .. ")"
+				extra.floating = true
+
+				local jsonExtra = util.TableToJSON( extra, false )
+
+				self.HTML:Call( namespace .. ".ReceiveFileInfo( \"" .. v .. "\", " .. jsonExtra .. " )" )
+				self.HTML:Call( namespace .. ".ReceiveImage( \"" .. v .. "\", \"html/img/localaddon.png\" )" )
+
+				-- Do not try to get votes for this one
+				continue
+
+			elseif ( InfoCache[ v ] ) then
+
+				self.HTML:Call( namespace .. ".ReceiveFileInfo( \"" .. v .. "\", " .. InfoCache[ v ] .. " )" )
+
+				if ( MENU_DLL ) then
+					-- This could've changed..
+					steamworks.FileUserInfo( v, function( info )
+						if ( info.error ) then return end
+
+						local localUI = util.TableToJSON( info, false )
+						self.HTML:Call( namespace .. ".ReceiveFileUserInfo( \"" .. v .. "\", " .. localUI .. " )" )
+					end )
+				end
+
+			else
+
+				steamworks.FileInfo( v, function( result )
+
+					if ( !result || result.error != nil ) then
+						-- Try to get the title from the GetAddons(), this probably could be done more efficiently
+						local title = "Offline addon"
+						for id, t in pairs( isUGC && engine.GetUserContent() || engine.GetAddons() ) do
+							if ( tonumber( v ) == tonumber( t.wsid ) ) then title = t.title break end
+						end
+
+						local jsonErr = util.TableToJSON( { title = title, description = "Failed to get addon info, error code " .. ( result && result.error || "unknown" ) }, false )
+						self.HTML:Call( namespace .. ".ReceiveFileInfo( \"" .. v .. "\", " .. jsonErr .. " )" )
+						return
+					end
+
+					if ( result.description ) then
+						result.description = string.gsub( result.description, "%[img%]([^%]]*)%[/img%]", "" ) -- Gotta remove inner content of img tags
+						result.description = string.gsub( result.description, "%[([^%]]*)%]", "" )
+						result.description = string.Trim( result.description )
+					end
+
+					if ( result.owner && ( !result.ownername || result.ownername == "" || result.ownername == "[unknown]" ) ) then
+						self:RetrieveUserName( result.owner, function( name )
+							result.ownername = name
+
+							local jsonUN = util.TableToJSON( result, false )
+							InfoCache[ v ] = jsonUN
+						end )
+					end
+
+					local jsonFI = util.TableToJSON( result, false )
+					InfoCache[ v ] = jsonFI
+					self.HTML:Call( namespace .. ".ReceiveFileInfo( \"" .. v .. "\", " .. jsonFI .. " )" )
+
+					--
+					-- Now we have the preview id - get the preview image!
+					--
+					if ( !PreviewCache[ v ] && result.previewid ) then
+
+						steamworks.Download( result.previewid, false, function( name )
+
+							-- Download failed
+							if ( !name ) then return end
+
+							PreviewCache[ v ] = name:JavascriptSafe()
+							self.HTML:Call( namespace .. ".ReceiveImage( \"" .. v .. "\", \"" .. PreviewCache[ v ] .. "\" )" )
+
+						end )
+
+					end
+
+					if ( MENU_DLL ) then
+						steamworks.FileUserInfo( v, function( info )
+							if ( info.error ) then return end
+
+							local localUI = util.TableToJSON( info, false )
+							self.HTML:Call( namespace .. ".ReceiveFileUserInfo( \"" .. v .. "\", " .. localUI .. " )" )
+						end )
+					end
+
+				end )
+			end
+
+		end
+
+	end
+
+	function ret:Publish( filename, image )
+
+		--MsgN( "PUBLISHING ", filename )
+		--MsgN( "Image ", image )
+
+		local window = vgui.Create( "UGCPublishWindow" )
+		window:Setup( namespace, filename, image, self )
+		window:MakePopup()
+		window:DoModal() -- We want the user to either finish this or quit
+
+	end
+
+	return ret
+
+end

lua/includes/vgui_base.lua

@@ -0,0 +1,55 @@
+
+include( "vgui/DFrame.lua" )
+include( "vgui/DButton.lua" )
+include( "vgui/DTooltip.lua" )
+include( "vgui/DDragBase.lua" )
+include( "vgui/DLabel.lua" )
+include( "vgui/DImage.lua" )
+include( "vgui/DPanel.lua" )
+include( "vgui/DPropertySheet.lua" )
+include( "vgui/DHorizontalScroller.lua" )
+include( "vgui/DPanelList.lua" )
+include( "vgui/DListLayout.lua" )
+include( "vgui/DVScrollBar.lua" )
+include( "vgui/DHScrollBar.lua" )
+include( "vgui/DScrollBarGrip.lua" )
+include( "vgui/DCategoryCollapse.lua" )
+include( "vgui/DListView_Line.lua" )
+include( "vgui/DListView.lua" )
+include( "vgui/DListView_Column.lua" )
+include( "vgui/DForm.lua" )
+include( "vgui/DComboBox.lua" )
+include( "vgui/DTextEntry.lua" )
+include( "vgui/DCheckBox.lua" )
+include( "vgui/DNumberWang.lua" )
+include( "vgui/DMenu.lua" )
+include( "vgui/DMenuOption.lua" )
+include( "vgui/DMenuBar.lua" )
+include( "vgui/DColumnSheet.lua" )
+include( "vgui/DScrollPanel.lua" )
+include( "vgui/DGrid.lua" )
+include( "vgui/DLabelURL.lua" )
+include( "vgui/DHTMLControls.lua" )
+include( "vgui/DImageButton.lua" )
+include( "vgui/DHTML.lua" )
+include( "vgui/DPanelOverlay.lua" )
+include( "vgui/DDrawer.lua" )
+include( "vgui/DTree.lua" )
+include( "vgui/DTree_Node.lua" )
+include( "vgui/DTree_Node_Button.lua" )
+include( "vgui/DExpandButton.lua" )
+include( "vgui/DNumberScratch.lua" )
+include( "vgui/DNumSlider.lua" )
+include( "vgui/DSlider.lua" )
+include( "vgui/DProgress.lua" )
+include( "vgui/DCategoryList.lua" )
+include( "vgui/DSizeToContents.lua" )
+include( "vgui/DIconBrowser.lua" )
+include( "vgui/DIconLayout.lua" )
+include( "vgui/DColorButton.lua" )
+include( "vgui/DColorPalette.lua" )
+include( "vgui/DColorMixer.lua" )
+include( "vgui/DColorCube.lua" )
+include( "vgui/DAlphaBar.lua" )
+include( "vgui/DRGBPicker.lua" )
+include( "vgui/DPanPanel.lua" )