I am trying to find the styling of this (NOT STEAL IT)

So i went on Sass and got their menu but i already have http://www.facepunch.com/threads/1038569

Just i am trying to find sass’s formatting of the pages/tabs. here is the code

[lua]surface.CreateFont(“coolvetica”, 30, 700, true, false, “StoreFont”)

COLOR_GREY = Color(229, 153, 164, 255)
COLOR_GREEN = Color(113, 164, 122, 255)
COLOR_OWNED = Color(181, 182, 194, 255)
COLOR_BLUE = Color(0, 0, 255, 255)
COLOR_RED = Color(86, 86, 86, 255)
COLOR_CATLABEL = Color(243, 237, 222, 255)
COLOR_GREY = Color(86, 86, 86, 255)
COLOR_SELECTED = Color(255, 0, 0, 255)

STGamemodes.Store.Panel = false
STGamemodes.Store.Loading = true
STGamemodes.Store.Fonts = {}
STGamemodes.Store.LocalItems = {}
STGamemodes.Store.RefreshSettings = true

STGamemodes.Store.ButtonClick = Sound(“buttons/button1.wav”)
STGamemodes.Store.ButtonRelease = Sound(“UI/buttonclickrelease.wav”)
STGamemodes.Store.ButtonRollover = Sound(“UI/buttonrollover.wav”)

function STGamemodes.Store:SelectFont(Text, Wide)
surface.SetFont(“StoreFont”)
local Width, Height = surface.GetTextSize(Text)
if(Width >= Wide) then
local Calc = Width / Wide
local Size = math.floor(30 / Calc)
local Font = “StoreFont.”…Size
if(!self.Fonts[Size]) then
self.Fonts[Size] = true
– print(“Cached Font”, Size)
surface.CreateFont(“coolvetica”, Size, (700 / Calc) / 2, true, false, Font)
end
return Font
end
return “StoreFont”
end

local PANEL = {}
PANEL.Tabs = {}
PANEL.Width = math.max(520, ScrW() / 1.5)
PANEL.Height = math.max(465, ScrH() / 1.5)

function PANEL:Init()
self:SetTitleEx(“Main Menu”)

self:SetDraggable(true)
self:ShowCloseButton(true)
self:SetDeleteOnClose(false)

self:SetMouseInputEnabled(true)
self:SetKeyBoardInputEnabled(true)

self:SetSize(self.Width, self.Height)
self:Center()

local X = 5
local Y = 28
local Width = self:GetWide() - 10
local Height = self:GetTall() - 30

self.PropertySheet = vgui.Create("DPropertySheet", self)
self.PropertySheet:SetPos(X, Y)
self.PropertySheet:SetSize(Width, Height)

Height = Height - 20
Y = Y - 25

self.Help = vgui.Create("STGamemodes.VGUI.Help", self)
self.Help.Mother = self
self.PropertySheet:AddSheet("Help", self.Help, "gui/silkicons/star")
self.Tabs["HELP"] = self.PropertySheet.Items[1]

self.Achievements = vgui.Create("STGamemodes.VGUI.Achievements", self)
self.Achievements.Mother = self
self.PropertySheet:AddSheet("Achievements", self.Achievements, "gui/silkicons/world")
self.Tabs["ACHIEVEMENTS"] = self.PropertySheet.Items[2]

self.Store = vgui.Create("STGamemodes.VGUI.Store", self)
self.Store.Mother = self
self.PropertySheet:AddSheet("Store", self.Store, "gui/silkicons/brick_add")
self.Tabs["STORE"] = self.PropertySheet.Items[3]

self.Settings = vgui.Create("STGamemodes.VGUI.Settings", self)
self.Settings.Mother = self
self.PropertySheet:AddSheet("Settings", self.Settings, "gui/silkicons/plugin")
self.Tabs["SETTINGS"] = self.PropertySheet.Items[4]

self.Servers = vgui.Create("STGamemodes.VGUI.Servers", self)
self.Servers.Mother = self
self.PropertySheet:AddSheet("Servers", self.Servers, "gui/silkicons/car")
self.Tabs["SERVERS"] = self.PropertySheet.Items[5]

self.VIPBenefits = vgui.Create("STGamemodes.VGUI.VIPBenefits", self)
self.VIPBenefits.Mother = self
self.PropertySheet:AddSheet("VIPBenefits", self.VIPBenefits, "gui/silkicons/emoticon_smile")
self.Tabs["VIPBenefits"] = self.PropertySheet.Items[6]

self.Account = vgui.Create("STGamemodes.VGUI.Account", self)
self.Account.Mother = self
self.PropertySheet:AddSheet("Account", self.Account, "gui/silkicons/user")
self.Tabs["Account"] = self.PropertySheet.Items[7]

end

vgui.Register(“STGamemodes.VGUI.Main”, PANEL, “STGamemodes.VGUI.Base”)


local LoadingLabelColor = Color(0, 0, 0, 255)
local ProgressLabelColor = Color(255, 255, 255, 255)
local ProgressPanelBackgroundColor = Color(70, 70, 70, 230)

local PANEL = {}
PANEL.Loading = -1

function PANEL:Init()
self.LoadingLabel = vgui.Create(“DLabel”, self)
self.LoadingLabel:SetFont(“Trebuchet24”)
self.LoadingLabel:SetColor(LoadingLabelColor)
self.LoadingLabel:SetText(“Loading…”)
self.LoadingLabel:SizeToContents()

self.PanelList = vgui.Create("DPanelList", self)
self.PanelList:SetSpacing(5)
self.PanelList:SetPadding(5)
self.PanelList:EnableVerticalScrollbar()

for k,v in pairs(STAchievements.Order) do
	local Panel = vgui.Create("STAchievements.Panel")
	Panel:SetAchievement(STAchievements:Get(v))
	
	self.PanelList:AddItem(Panel)
end

self.ProgressPanel = vgui.Create("DPanel", self)

self.TotalProgress = vgui.Create("DProgressBar", self.ProgressPanel)
self.TotalProgress:SetSize(200, 100)
self.TotalProgress:LabelAsPecentage()
self.TotalProgress:SetMin(0)
self.TotalProgress:SetMax(table.Count(STAchievements.Achievements))
self.TotalProgress:SetValue(0)

self.ProgressLabel = vgui.Create("DLabel", self.ProgressPanel)
self.ProgressLabel:SetFont("Trebuchet18")
self.ProgressLabel:SetColor(ProgressLabelColor)

end

function PANEL:Think()
if(!self.LastThink) then
self.LastThink = CurTime() - 2
end
if(!STAchievements.RefreshPanel and self.LastThink >= CurTime() - 1) then
return
end
self.LastThink = CurTime()
self:Update()
STAchievements.RefreshPanel = false
end

function PANEL:Update()
local Completed = 0

for k,v in pairs(self.PanelList:GetItems()) do
	if(v:Update(STAchievements:IsAchieved(LocalPlayer(), v:GetName()), STAchievements:GetCount(LocalPlayer(), v:GetName()))) then
		Completed = Completed + 1
	else
		Completed = Completed + (STAchievements:GetCount(LocalPlayer(), v:GetName()) / v:GetGoal())
	end
end

self.TotalProgress:SetValue(Completed)
self.ProgressLabel:SetText(Format("You have unlocked %i out of %i achievements!", Completed, table.Count(self.PanelList:GetItems())))

if(self.Loading == STAchievements.Loading) then
	return
end
self.Loading = STAchievements.Loading

if(STAchievements.Loading) then
	self.LoadingLabel:SetVisible(true)
	self.PanelList:SetVisible(false)
	self.ProgressPanel:SetVisible(false)
else
	self.LoadingLabel:SetVisible(false)
	self.PanelList:SetVisible(true)
	self.ProgressPanel:SetVisible(true)
end

end

function PANEL:PerformLayout()
self.LoadingLabel:Center()

self.ProgressPanel:SetTall(55)
self.ProgressPanel:StretchToParent(10, 10, 10, nil)
self.ProgressPanel:SetBackgroundColor(ProgressPanelBackgroundColor)


self.ProgressLabel:SizeToContents()	
self.ProgressLabel:SetPos(5, 5)
self.ProgressLabel:CenterHorizontal()

self.TotalProgress:SetTall(22)
self.TotalProgress:StretchToParent(6, nil, 6, nil)
self.TotalProgress:AlignBottom(6)

self.PanelList:MoveBelow(self.ProgressPanel, 5)
self.PanelList:StretchToParent(10, nil, 10, 10)

end

vgui.Register(“STGamemodes.VGUI.Achievements”, PANEL, “DPanel”)


local PANEL = {}

function PANEL:Init()
self.HTML = vgui.Create(“HTML”, self)
self.HTML:OpenURL(“http://www.sassilization.com/servers/"..string.lower(GAMEMODE:GetGameDescription())..".html”)
self.HTML:StartAnimate()
end

function PANEL:PerformLayout()
self.HTML:StretchToParent(5, 5, 5, 5)
end

vgui.Register(“STGamemodes.VGUI.Help”, PANEL, “DPanel”)


local PANEL = {}
PANEL.Selected = false
PANEL.SelectedCat = false
PANEL.SelectedCatContainer = false
PANEL.Categories = {}
PANEL.CategoryContainers = {}

function PANEL:Init()
self.PanelList = vgui.Create(“DPanelList”, self)
self.PanelList:SetPadding(5)
self.PanelList:SetSpacing(5)
self.PanelList:EnableHorizontal(true)
self.PanelList:SetDrawBackground(false)
self.PanelList:EnableVerticalScrollbar()

for k,v in pairs(STGamemodes.Store:GetCategories()) do
	local Container = vgui.Create("STGamemodes.VGUI.StoreCategoryContainer", self)
	Container:SetInfo(self, k)
	Container:SetVisible(false)
	self.CategoryContainers[k] = Container
	
	local Cat = vgui.Create("STGamemodes.VGUI.StoreCategoryButton", self)
	Cat:SetSize(96, 96)
	Cat:SetText(k)
	Cat:SetInfo(self, v.Mat)
	Cat.Container = Container or false
	
	self.Categories[k] = Cat
	
	self.PanelList:AddItem(Cat)
end

self.BackButton = vgui.Create("DButton", self)
self.BackButton:SetText("Back")
self.BackButton:SetDisabled(true)
function self.BackButton.DoClick()
	self:Select()
end

self.BuyButton = vgui.Create("DButton", self)
self.BuyButton:SetText("Buy")
self.BuyButton:SetDisabled(true)
function self.BuyButton.DoClick()
	self:BuyClick()
end

self.SellButton = vgui.Create("DButton", self)
self.SellButton:SetText("Sell")
self.SellButton:SetDisabled(true)
function self.SellButton.DoClick()
	self:SellClick()
end

end

function PANEL:GetSelected()
return self.Selected
end

function PANEL:SetSelected(Panel)
if(self.Selected != Panel) then
if(self.Selected != false) then
self.Selected.Selected = false
end
self.Selected = Panel
self.Selected.Selected = true
surface.PlaySound(STGamemodes.Store.ButtonRelease)
end
self.BuyButton:SetDisabled(Panel.HasItem)
self.SellButton:SetDisabled(!Panel.HasItem)
end

function PANEL:SetSelectedCat(Panel)
if(self.SelectedCat != Panel) then
if(self.SelectedCat != false) then
self.SelectedCat:SetVisible(false)
end
self.SelectedCat = Panel
self:Select(self.SelectedCat.Container)
surface.PlaySound(STGamemodes.Store.ButtonRelease)
end
end

function PANEL:Select(Container)
if(self.Selected != false) then
self.Selected.Selected = false
end
self.Selected = false
self.BuyButton:SetDisabled(true)
self.SellButton:SetDisabled(true)

if(Container) then
	self.BackButton:SetDisabled(false)
else
	self.SelectedCat = false
	self.BackButton:SetDisabled(true)
end

for k,v in pairs(self.Categories) do
	if(Container) then
		v:SetVisible(false)
	else
		v:SetVisible(true)
	end
end
for k,v in pairs(self.CategoryContainers) do
	if(Container) then
		if(Container == v) then
			v:SetVisible(true)
		else
			v:SetVisible(false)
		end
	else
		v:SetVisible(false)
	end
end

end

function PANEL:BuyClick()
if(!self.Selected) then
return
end
surface.PlaySound(STGamemodes.Store.ButtonClick)
RunConsoleCommand(“st_store_buy”, self.Selected.Text)
end

function PANEL:SellClick()
if(!self.Selected) then
return
end
surface.PlaySound(STGamemodes.Store.ButtonClick)
RunConsoleCommand(“st_store_sell”, self.Selected.Text)
end

function PANEL:PerformLayout()
self.PanelList:StretchToParent(5, 5, 5, 25)

for k,v in pairs(self.CategoryContainers) do
	v:StretchToParent(5, 5, 5, 5)
end

self.BackButton:SetWide(40)
self.BackButton:AlignLeft(5)
self.BackButton:AlignBottom(5)

local Left = self:GetWide() - self.BackButton:GetWide() - 20

self.BuyButton:SetWide(Left / 2)
self.BuyButton:MoveRightOf(self.BackButton, 5)
self.BuyButton:AlignBottom(5)

self.SellButton:SetWide(Left / 2)
self.SellButton:MoveRightOf(self.BuyButton, 5)
self.SellButton:AlignBottom(5)

end

vgui.Register(“STGamemodes.VGUI.Store”, PANEL, “DPanel”)


local PANEL = {}
PANEL.Items = {}
PANEL.Loading = true

function PANEL:Init()
self.LoadingLabel = vgui.Create(“DLabel”, self)
self.LoadingLabel:SetFont(“Trebuchet24”)
self.LoadingLabel:SetColor(LoadingLabelColor)
self.LoadingLabel:SetText(“Loading…”)
self.LoadingLabel:SizeToContents()

self.PanelList = vgui.Create("DPanelList", self)
self.PanelList:NoClipping(false)
self.PanelList:SetPadding(5)
self.PanelList:SetSpacing(5)
self.PanelList:EnableHorizontal(true)
self.PanelList:SetDrawBackground(false)
self.PanelList:EnableVerticalScrollbar()

end

function PANEL:OnThink()
if(STGamemodes.Store:CanBuyCategoryItem(LocalPlayer(), self.Text)) then
self.CanBuy = true
else
self.CanBuy = false
end
end

function PANEL:UpdateHover(Panel)
if(!self.HoverPanel) then
return
end
local x, y = gui.MousePos()
self.HoverPanel:SetPos(x + 5, y + 5)
end

function PANEL:OnHover(Panel, Bool)
if(!self.HoverPanel) then
return
end

if(Bool) then
	if(!Panel.MatModel) then
		return
	end
	
	self.HoverModelPanel:SetModel(Panel.MatModel)
	self:UpdateHover(Panel)
	self.HoverPanel:SetVisible(true)
	self.HoverPanel:SetDrawOnTop(true)
	self.HoverPanel:MakePopup()
else
	if(self.HoverPanel:IsVisible()) then
		self.HoverPanel:SetVisible(false)
	end
end

end

function PANEL:SetInfo(Mother, Cat)
self.Loading = true

self.Items = {}
self.Mother = Mother
self.Cat = Cat

self.LoadingLabel:SetVisible(true)
self.PanelList:SetVisible(false)

local Timer = 0.02
for k,v in pairs(STGamemodes.Store:GetCategoryItems(Cat)) do
	local ItemTable = STGamemodes.Store:GetItem(v)
	if(ItemTable.Price > -1) then
		timer.Simple(Timer, function()
			if(!ValidPanel(self)) then
				return
			end
			local Item = vgui.Create("STGamemodes.VGUI.StoreItemButton")
			Item:NoClipping(false)
			Item:SetSize(96, 96)
			Item:SetText(v)
			Item.Container = self
			
			local ItemTable = STGamemodes.Store:GetItem(v)
			local Mat = ItemTable.Mat
			
			if(Cat == "Player Models" or string.find(string.lower(Mat), "models/player")) then
				Item.MatModel = Mat
				Mat = "store/PModels/PModels_Generic"
				if(!self.HoverPanel) then
					self.HoverPanel = vgui.Create("STGamemodes.VGUI.BasePaint")
					self.HoverPanel:SetSize(150, 125)
					self.HoverPanel:SetZPos(101)
					
					self.HoverModelPanel = vgui.Create("DModelPanel", self.HoverPanel)
					self.HoverModelPanel:StretchToParent(5, 5, 5, 5)
					self.HoverModelPanel:SetAnimSpeed(1)
					self.HoverModelPanel:SetAnimated(true)
					function self.HoverModelPanel:LayoutEntity(Entity)
						if(self.bAnimated) then
							self:RunAnimation()
						end
						Entity:SetAngles(Angle(0, RealTime() * 100, 0))
					end
					
					self.HoverPanel:SetVisible(false)
				end
			end
			Item:SetInfo(self.Mother, Mat)
			
			Item["Price"] = STGamemodes.Store:GetPrice(v, LocalPlayer())
			Item["Description"] = ItemTable.Description
			
			Item:UpdateTooltip()
			
			self.Items[v] = Item
			
			self.PanelList:AddItem(Item)
		end)
		Timer = Timer + 0.02
	end
end
timer.Simple(Timer, function()
	if(!ValidPanel(self)) then
		return
	end
	self.Loading = false
	self.LoadingLabel:SetVisible(false)
	self.PanelList:SetVisible(true)
	self.PanelList:SortByMember("Price", true)
end)

end

function PANEL:PerformLayout()
self.LoadingLabel:Center()
self.PanelList:StretchToParent(5, 5, 5, 25)
end

vgui.Register(“STGamemodes.VGUI.StoreCategoryContainer”, PANEL, “DPanel”)


local PANEL = {}
PANEL.Col = COLOR_GREEN
PANEL.BorderCol = COLOR_GREY

function PANEL:Init()
end

function PANEL:SetText(Text)
self.Text = Text
end

function PANEL:SetInfo(Mother, Mat)
self.Mother = Mother
if(Mat) then
self.Image = vgui.Create(“DImage”, self)
self.Image:SetImage(Mat)
self.Image.OnCursorEntered = function()
self.Hovered = true
end
end
end

function PANEL:Think()
if(!self.LastThink) then
self.LastThink = CurTime() - 2
end
if(self.LastThink >= CurTime() - 1) then
return
end
self.LastThink = CurTime()
self:OnThink()
end

function PANEL:OnCursorEntered()
self.Hovered = true
if(self.Container.OnHover) then
self.Container:OnHover(self, self.Hovered)
end
surface.PlaySound(STGamemodes.Store.ButtonRollover)
end

function PANEL:OnCursorMoved()
if(self.Container.UpdateHover) then
self.Container:UpdateHover(self)
end
end

function PANEL:OnCursorExited()
self.Hovered = false
if(self.Container.OnHover) then
self.Container:OnHover(self, self.Hovered)
end
end

function PANEL:OnMousePressed(MouseCode)
if(MouseCode == MOUSE_LEFT) then
self:Clicked()
end
end

function PANEL:UpdateTooltip()
local Tooltip = self.Text
if(self[“Price”]) then
if(self.HasItem) then
self:SetTooltip("You own this item
You can sell this item for "..tostring(self["Price"] * 0.8)) else local ToolTip = "“…tostring(self[“Price”])
if(self[“Description”] and self[“Description”] != “”) then
ToolTip = ToolTip…”
"…self[“Description”]
end
self:SetToolTip(ToolTip)
end
else
if(self.HasItem) then
self:SetTooltip(“You own everything in this category!”)
elseif(!self.CanBuy) then
self:SetTooltip(“You don’t have enough dough to buy anything in this category!”)
end
end
end

function PANEL:Paint()
if(self.HasItem) then
self.Col = COLOR_OWNED
elseif(self.CanBuy) then
self.Col = COLOR_GREEN
else
self.Col = COLOR_RED
end
if(self.Selected) then
self.BorderCol = COLOR_SELECTED
elseif(self.Hovered) then
self.BorderCol = COLOR_BLUE
else
self.BorderCol = COLOR_GREY
end

local Wide, Tall = self:GetSize()
draw.RoundedBox(6, 0, 0, Wide, Tall, self.BorderCol)
draw.RoundedBox(6, 3, 3, Wide - 6, Tall - 6, self.Col)
draw.SimpleTextOutlined(self.Text, STGamemodes.Store:SelectFont(self.Text, Wide - 10), Wide / 2, Tall - 14, COLOR_CATLABEL, TEXT_ALIGN_CENTER, TEXT_ALIGN_CENTER, 2, color_black)

end

function PANEL:PerformLayout()
if(!self.Image) then
return
end
self.Image:SetZPos(20)
self.Image:SetSize(60, 60)
self.Image:AlignTop(6)
self.Image:CenterHorizontal()
end
vgui.Register(“STGamemodes.VGUI.StoreButton”, PANEL, “DPanel”)


local PANEL = {}

function PANEL:OnThink()
local Count, MaxCount = STGamemodes.Store:HasItemInCategory(LocalPlayer(), self.Text)
if(Count >= MaxCount) then
if(!self.HasItem) then
self.HasItem = true
self:UpdateTooltip()
end
else
self.HasItem = false
if(STGamemodes.Store:CanBuyCategoryItem(LocalPlayer(), self.Text)) then
self.CanBuy = true
else
if(self.CanBuy) then
self.CanBuy = false
self:UpdateTooltip()
end
end
end
end

function PANEL:Clicked()
self.Mother:SetSelectedCat(self)
end

vgui.Register(“STGamemodes.VGUI.StoreCategoryButton”, PANEL, “STGamemodes.VGUI.StoreButton”)


local PANEL = {}

function PANEL:OnThink()
if(STGamemodes.Store:HasItem(LocalPlayer(), self.Text)) then
if(!self.HasItem) then
self.HasItem = true
if(self.Mother:GetSelected() == self) then
self.Mother:SetSelected(self)
end
self:UpdateTooltip()
end
else
self.CanBuy = STGamemodes.Store:CanBuyItem(LocalPlayer(), self.Text)
if(self.HasItem) then
self.HasItem = false
if(self.Mother:GetSelected() == self) then
self.Mother:SetSelected(self)
end
self:UpdateTooltip()
end
end
end

function PANEL:Clicked()
self.Mother:SetSelected(self)
end

vgui.Register(“STGamemodes.VGUI.StoreItemButton”, PANEL, “STGamemodes.VGUI.StoreButton”)


local PANEL = {}
PANEL.ItemPanels = {}

function PANEL:Init()

end

function PANEL:Think()
if(!self.LastThink) then
self.LastThink = CurTime() - 2
end
if(self.LastThink >= CurTime() - 1) then
return
end
self.LastThink = CurTime()
self:Update()
end

function PANEL:Update()
local X = 5
local Y = 5
local Spacing = 10
local ButtonWidth = 60
local ButtonHeight = 25

if(!STGamemodes.Store.RefreshSettings) then
	return
end
STGamemodes.Store.RefreshSettings = false

for k,v in pairs(self.ItemPanels) do
	for k2,v2 in pairs(v) do
		v2:Remove()
	end
end

self.ItemPanels = {}

local LocalItems = STGamemodes.Store.LocalItems

if(LocalItems["Misc"]) then
	self.ItemPanels["Misc"] = {}
	
	self.EnableTrailsCheckBox = vgui.Create("DCheckBoxLabel", self)
	self.EnableTrailsCheckBox:SetPos(X, Y)
	self.EnableTrailsCheckBox:SetWide(135)
	self.EnableTrailsCheckBox:SetText("Enable Trails")
	self.EnableTrailsCheckBox:SetTextColor(color_white)
	self.EnableTrailsCheckBox:SetValue(!file.Exists("DisableTrails.txt"))
	self.EnableTrailsCheckBox:SetTooltip("You can also type '/trails' in chat or bind a key to 'st_enabletrails' to toggle trails")
	function self.EnableTrailsCheckBox.OnChange()
		if(self.EnableTrailsCheckBox:GetChecked()) then
			STGamemodes.EnableTrails = true
			if(file.Exists("DisableTrails.txt")) then
				file.Delete("DisableTrails.txt")
			end
		else
			STGamemodes.EnableTrails = false
			file.Write("DisableTrails.txt", "")
		end
	end
	table.insert(self.ItemPanels["Misc"], self.EnableTrailsCheckBox)
	X = X + self.EnableTrailsCheckBox:GetWide() + Spacing
	
	if(STGamemodes.Store:HasItem(LocalPlayer(), "Ghost Mode")) then
		self.GhostModeCheckBox = vgui.Create("DCheckBoxLabel", self)
		self.GhostModeCheckBox:SetPos(X, Y)
		self.GhostModeCheckBox:SetWide(135)
		self.GhostModeCheckBox:SetText("Ghost Mode")
		self.GhostModeCheckBox:SetTextColor(color_white)
		self.GhostModeCheckBox:SetValue(LocalPlayer():CanGhost())
		function self.GhostModeCheckBox.OnChange()
			if(self.GhostModeCheckBox:GetChecked()) then
				RunConsoleCommand("st_store_ghost", 1)
			else
				RunConsoleCommand("st_store_ghost", 0)
			end
		end
		table.insert(self.ItemPanels["Misc"], self.GhostModeCheckBox)
		X = X + self.GhostModeCheckBox:GetWide() + Spacing
	end
	if(STGamemodes.Store:HasItem(LocalPlayer(), "Third Person Mode")) then
		self.ThirdPersonCheckBox = vgui.Create("DCheckBoxLabel", self)
		self.ThirdPersonCheckBox:SetPos(X, Y)
		self.ThirdPersonCheckBox:SetWide(135)
		self.ThirdPersonCheckBox:SetText("Third Person Mode")
		self.ThirdPersonCheckBox:SetTextColor(color_white)
		self.ThirdPersonCheckBox:SetValue(LocalPlayer():CanThirdPerson())
		self.ThirdPersonCheckBox:SetTooltip("You can also type '/thirdperson' in chat or bind a key to 'st_thirdperson' to toggle third person mode")
		function self.ThirdPersonCheckBox.OnChange()
			if(self.ThirdPersonCheckBox:GetChecked()) then
				RunConsoleCommand("st_store_thirdperson", 1)
			else
				RunConsoleCommand("st_store_thirdperson", 0)
			end
		end
		table.insert(self.ItemPanels["Misc"], self.ThirdPersonCheckBox)
	end
	Y = Y + 16
	X = 5
end

local YDefault = Y

if(LocalItems["Trails"]) then
	local Count, MaxCount = STGamemodes.Store:HasItemInCategory(LocalPlayer(), "Trails", true)
	if(Count > 0) then
		self.ItemPanels["Trails"] = {}
		
		self.Trails = vgui.Create("DComboBox", self)
		self.Trails:SetPos(X, Y)
		self.Trails:SetSize(80, 160)
		self.Trails:SetMultiple(false)
		table.insert(self.ItemPanels["Trails"], self.Trails)
		X = X + self.Trails:GetWide() + Spacing
		
		self.TrailPreview = vgui.Create("DImage", self)
		self.TrailPreview:SetPos(X, Y)
		self.TrailPreview:SetSize(145, 118)
		table.insert(self.ItemPanels["Trails"], self.TrailPreview)
		
		local SelectItem = self.Trails.SelectItem
		function self.Trails:SelectItem(item, onlyme)
			local Name = item:GetValue()
			self:GetParent().TrailPreview:SetImage(STGamemodes.Trails[Name][1])
			return SelectItem(self, item, onlyme)
		end
		
		for k,v in pairs(LocalItems["Trails"]) do
			local Name = string.Trim(k)
			if(Name != "" and STGamemodes.Trails[Name]) then
				local Item = self.Trails:AddItem(Name)
				if(LocalItems["Trails"].Selected == Name) then
					self.Trails:SelectItem(Item, true)
				end
			end
		end
		
		if(!LocalItems["Trails"].Selected) then
			self.Trails:SelectItem(self.Trails:GetItems()[1], true)
		end
		
		table.sort(self.Trails.Items, function(a, b)
			return a:GetValue() < b:GetValue()
		end)
		
		Y = Y + self.TrailPreview:GetTall() + Spacing
		
		self.ChangeTrail = vgui.Create("DButton", self)
		self.ChangeTrail:SetText("Change Trail")
		self.ChangeTrail:SetPos(X, Y)
		self.ChangeTrail:SetSize(ButtonWidth + 10, ButtonHeight)
		function self.ChangeTrail.DoClick()
			local Table = self.Trails.SelectedItems
			if(table.Count(Table) > 0) then
				local Col = self.ColorMixer:GetColor()
				RunConsoleCommand("st_store_trail", Table[1]:GetValue(), Col.r, Col.g, Col.b, Col.a)
			end
		end
		table.insert(self.ItemPanels["Trails"], self.ChangeTrail)
		X = X + self.ChangeTrail:GetWide() + Spacing
		
		self.RemoveTrail = vgui.Create("DButton", self)
		self.RemoveTrail:SetText("Remove Trail")
		self.RemoveTrail:SetPos(X, Y)
		self.RemoveTrail:SetSize(ButtonWidth + 10, ButtonHeight)
		function self.RemoveTrail.DoClick()
			RunConsoleCommand("st_store_trail")
		end
		table.insert(self.ItemPanels["Trails"], self.RemoveTrail)
		X = X + self.RemoveTrail:GetWide() + Spacing
		Y = YDefault
		
		self.ColorMixer = vgui.Create("DColorMixer", self)
		self.ColorMixer:SetPos(X, Y)
		self.ColorMixer:SetSize(260, 150)
		local ColorMixerThink = self.ColorMixer.Think
		function self.ColorMixer:Think()
			local MColor = self:GetColor()
			if(self.MCOlor != MColor) then
				self.MCOlor = MColor
				self:GetParent().TrailPreview:SetImageColor(self.MCOlor)
			end
			return ColorMixerThink(self)
		end
		table.insert(self.ItemPanels["Trails"], self.ColorMixer)
		self.ColorMixer.ColorCube:SetRGB(LocalItems["Trails"].Col or Color(255, 255, 255, 255))
		
		Y = Y + self.Trails:GetTall() + Spacing
		X = 5
	end
end

if(LocalItems["Player Models"]) then
	local Count, MaxCount = STGamemodes.Store:HasItemInCategory(LocalPlayer(), "Player Models", true)
	if(Count > 0) then
		self.ItemPanels["Player Models"] = {}
		
		self.PlayerModels = vgui.Create("DComboBox", self)
		self.PlayerModels:SetPos(X, Y)
		self.PlayerModels:SetSize(80, 200)
		self.PlayerModels:SetMultiple(false)
		table.insert(self.ItemPanels["Player Models"], self.PlayerModels)
		X = X + self.PlayerModels:GetWide() + Spacing
		
		self.PlayerModelPanel = vgui.Create("DModelPanel", self)
		self.PlayerModelPanel.YPos = Y
		self.PlayerModelPanel:SetPos(X, Y)
		self.PlayerModelPanel:SetSize(145, 120)
		self.PlayerModelPanel:SetAnimSpeed(1)
		self.PlayerModelPanel:SetAnimated(true)
		function self.PlayerModelPanel:LayoutEntity(Entity)
			if(self.bAnimated) then
				self:RunAnimation()
			end
			Entity:SetAngles(Angle(0, RealTime() * 100, 0))
		end
		table.insert(self.ItemPanels["Player Models"], self.PlayerModelPanel)
		Y = Y + self.PlayerModelPanel:GetTall() + Spacing
		
		local SelectItem = self.PlayerModels.SelectItem
		function self.PlayerModels:SelectItem(item, onlyme)
			local Name = item:GetValue()
			if(self:GetParent().PlayerModelPanel.SelectedModel != Name) then
				self:GetParent().PlayerModelPanel.SelectedModel = Name
				self:GetParent().PlayerModelPanel:SetModel(STGamemodes.PlayerModels[Name])
			end
			return SelectItem(self, item, onlyme)
		end
		
		for k,v in pairs(LocalItems["Player Models"]) do
			local Name = string.Trim(k)
			if(Name != "" and STGamemodes.PlayerModels[Name]) then
				local Item = self.PlayerModels:AddItem(Name)
				if(LocalItems["Player Models"].Selected == Name) then
					self.PlayerModels:SelectItem(Item, true)
				end
			end
		end
		
		table.sort(self.PlayerModels.Items, function(a, b)
			return a:GetValue() < b:GetValue()
		end)
		
		self.PlayerModelUpdate = vgui.Create("DButton", self)
		self.PlayerModelUpdate:SetText("Update Model")
		self.PlayerModelUpdate:SetPos(X, Y)
		self.PlayerModelUpdate:SetSize(150, ButtonHeight)
		function self.PlayerModelUpdate.DoClick()
			local Table = self.PlayerModels.SelectedItems
			if(table.Count(Table) > 0) then
				RunConsoleCommand("st_store_playermodel", Table[1]:GetValue())
			end
		end
		table.insert(self.ItemPanels["Player Models"], self.PlayerModelUpdate)
		
		Y = self.PlayerModelPanel.YPos
		X = X + self.PlayerModelUpdate:GetWide() + Spacing
	end
end

if(LocalItems["Hats"]) then
	local Count, MaxCount = STGamemodes.Store:HasItemInCategory(LocalPlayer(), "Hats", true)
	if(Count > 0) then
		self.ItemPanels["Hats"] = {}
		
		self.Hats = vgui.Create("DComboBox", self)
		self.Hats:SetPos(X, Y)
		self.Hats:SetSize(80, 160)
		self.Hats:SetMultiple(false)
		table.insert(self.ItemPanels["Hats"], self.Hats)
		X = X + self.Hats:GetWide() + Spacing
		
		self.HatModelPanel = vgui.Create("DModelPanel", self)
		self.HatModelPanel:SetPos(X, Y)
		self.HatModelPanel:SetSize(145, 120)
		self.HatModelPanel:SetCamPos(Vector(15, 15, 10))
		self.HatModelPanel:SetLookAt(Vector(0, 0, 4))
		self.HatModelPanel:SetAnimSpeed(1)
		self.HatModelPanel:SetAnimated(true)
		self.HatModelPanel.AddAng = Angle(0, 0, 0)
		function self.HatModelPanel:LayoutEntity(Entity)
			if(self.bAnimated) then
				self:RunAnimation()
			end
			Entity:SetAngles(Angle(self.AddAng.p, self.AddAng.y + (RealTime() * 100), self.AddAng.r))
		end
		table.insert(self.ItemPanels["Hats"], self.HatModelPanel)
		Y = Y + self.HatModelPanel:GetTall() + Spacing
		
		local SelectItem = self.Hats.SelectItem
		function self.Hats:SelectItem(item, onlyme)
			local Name = item:GetValue()
			if(self:GetParent().HatModelPanel.SelectedModel != Name) then
				self:GetParent().HatModelPanel.SelectedModel = Name
				local Ang = Angle(0, 0, 0)
				local HatPositions = STGamemodes.HatPositions[Name]
				if(HatPositions and HatPositions[4]) then
					Ang.p = HatPositions[4].p - 270
					Ang.y = HatPositions[4].y
					Ang.r = HatPositions[4].r + 270
				end
				self:GetParent().HatModelPanel.AddAng =Ang
				self:GetParent().HatModelPanel:SetModel(STGamemodes.Hats[Name][1])
			end
			return SelectItem(self, item, onlyme)
		end
		
		for k,v in pairs(LocalItems["Hats"]) do
			local Name = string.Trim(k)
			if(Name != "" and STGamemodes.Hats[Name]) then
				local Item = self.Hats:AddItem(Name)
				if(LocalItems["Hats"].Selected == Name) then
					self.Hats:SelectItem(Item, true)
				end
			end
		end
		
		table.sort(self.Hats.Items, function(a, b)
			return a:GetValue() < b:GetValue()
		end)
		
		self.ChangeHat = vgui.Create("DButton", self)
		self.ChangeHat:SetText("Update Hat")
		self.ChangeHat:SetPos(X, Y)
		self.ChangeHat:SetSize(ButtonWidth + 10, ButtonHeight)
		function self.ChangeHat.DoClick()
			local Table = self.Hats.SelectedItems
			if(table.Count(Table) > 0) then
				RunConsoleCommand("st_store_hat", Table[1]:GetValue())
			end
		end
		table.insert(self.ItemPanels["Hats"], self.ChangeHat)
		X = X + self.ChangeHat:GetWide() + Spacing
		
		self.RemoveHat = vgui.Create("DButton", self)
		self.RemoveHat:SetText("Remove Hat")
		self.RemoveHat:SetPos(X, Y)
		self.RemoveHat:SetSize(ButtonWidth + 10, ButtonHeight)
		function self.RemoveHat.DoClick()
			RunConsoleCommand("st_store_hat")
		end
		table.insert(self.ItemPanels["Hats"], self.RemoveHat)
		X = X + self.RemoveHat:GetWide() + Spacing
		Y = 5
	end
end

end

function PANEL:PerformLayout()

end

vgui.Register(“STGamemodes.VGUI.Settings”, PANEL, “DPanel”)


local PANEL = {}

function PANEL:Init()
self.Header = vgui.Create(“DLabel”, self)
self.Header:SetColor(color_black)
self.Header:SetText(“Click the button to join the server”)
self.Header:SizeToContents()

self.Deathrun = vgui.Create("DButton", self)
self.Deathrun:SetText("Deathrun")
function self.Deathrun.DoClick()
	LocalPlayer():ConCommand("connect 216.245.210.131:27015

")
end

self.Climb = vgui.Create("DButton", self)
self.Climb:SetText("Climb")
function self.Climb.DoClick()
	LocalPlayer():ConCommand("connect 216.245.210.132:27015

")
end

self.BunnyHop = vgui.Create("DButton", self)
self.BunnyHop:SetText("Bunny Hop")
function self.BunnyHop.DoClick()
	LocalPlayer():ConCommand("connect 216.245.210.133:27015

")
end

self.Surf = vgui.Create("DButton", self)
self.Surf:SetText("Surf")
function self.Surf.DoClick()
	LocalPlayer():ConCommand("connect 216.245.210.134:27015

")
end
end

function PANEL:PerformLayout()
self.Header:AlignTop((self:GetTall() / 2) - 100)
self.Header:CenterHorizontal()

self.Deathrun:SetWide(100)
self.Deathrun:MoveBelow(self.Header, 5)
self.Deathrun:CenterHorizontal()

self.Climb:SetWide(100)
self.Climb:MoveBelow(self.Deathrun, 5)
self.Climb:CenterHorizontal()

self.BunnyHop:SetWide(100)
self.BunnyHop:MoveBelow(self.Climb, 5)
self.BunnyHop:CenterHorizontal()

self.Surf:SetWide(100)
self.Surf:MoveBelow(self.BunnyHop, 5)
self.Surf:CenterHorizontal()

end

vgui.Register(“STGamemodes.VGUI.Servers”, PANEL, “DPanel”)


local PANEL = {}

function PANEL:Init()
self.Header = vgui.Create(“DLabel”, self)
self.Header:SetColor(color_black)
self.Header:SetText(“VIP’s recieve the following benefits”)
self.Header:SizeToContents()

self.Benefits = vgui.Create("DLabel", self)
self.Benefits:SetColor(color_black)
self.Benefits:SetText([[
	1. Everything in the store is 30% off.
	2. If you're a runner and you kill a death you recieve 240 dough.
	3. If you're a death and you kill a runner you recieve 300 dough.
	4. If you win a round as a runner you recieve 200 dough.
	5. If you win a round as a death you recieve 100 dough.	
	6. In deathrun you get double health and a speed increase.
	7. Higher playlist limit in the jukebox.
	8. Free songs from the jukebox.
	9. You get 2x voting power.
	10. In bunny hop you get 25% more winning dough.
	11. Many benefits in the main sassilization lobby server!
]])
self.Benefits:SizeToContents()

self.Footer = vgui.Create("DLabel", self)
self.Footer:SetColor(color_black)
self.Footer:SetText("Donate over at www.sassilization.com/usercp by logging into your sassilization account")
self.Footer:SizeToContents()

end

function PANEL:PerformLayout()
self.Header:AlignTop((self:GetTall() / 2) - (self.Benefits:GetTall() / 2))
self.Header:CenterHorizontal()

self.Benefits:MoveBelow(self.Header, 5)
self.Benefits:CenterHorizontal()

self.Footer:MoveBelow(self.Benefits, 5)
self.Footer:CenterHorizontal()

end

vgui.Register(“STGamemodes.VGUI.VIPBenefits”, PANEL, “DPanel”)


local PANEL = {}

function PANEL:Init()
self.Header = vgui.Create(“DLabel”, self)
self.Header:SetColor(color_black)
self.Header:SetText(“Your Sassilization account is used to login to the usercp and forums.
Our forums are located at www.sassilization.com/forums
Our usercp is located at www.sassilization.com/usercp”)
self.Header:SizeToContents()

self.LookupUsername = vgui.Create("DButton", self)
self.LookupUsername:SetText("Lookup Username")
function self.LookupUsername.DoClick()
	RunConsoleCommand("st_lookupusername")
end

self.ResetPassword = vgui.Create("DButton", self)
self.ResetPassword:SetText("Reset Password")
function self.ResetPassword.DoClick()
	Derma_QueryFixed("Are you sure you want to reset your account password?

Doing so will cause you to rejoin the server", “Confirmation”,
“Yes”, function()
RunConsoleCommand(“st_resetpassword”)
end,
“No”, function()
end
)
end
end

function PANEL:PerformLayout()
self.Header:AlignTop((self:GetTall() / 2) - 100)
self.Header:CenterHorizontal()

self.LookupUsername:SetWide(100)
self.LookupUsername:MoveBelow(self.Header, 5)
self.LookupUsername:CenterHorizontal()

self.ResetPassword:SetWide(100)
self.ResetPassword:MoveBelow(self.LookupUsername, 5)
self.ResetPassword:CenterHorizontal()

end

vgui.Register(“STGamemodes.VGUI.Account”, PANEL, “DPanel”)


concommand.Add(“st_store”, function(ply, cmd, args)
if(STGamemodes.Store.Loading) then
LocalPlayer():ChatPrint(“Your profile is currently loading. Please wait…”)
return
end
if(!STGamemodes.Store.Panel or !STGamemodes.Store.Panel:IsValid()) then
STGamemodes.Store.Panel = vgui.Create(“STGamemodes.VGUI.Main”)
STGamemodes.Store.Panel:MakePopup()
end
if(!STGamemodes.Store.Panel:IsVisible()) then
STGamemodes.Store.Panel:SetVisible(true)
STGamemodes.Store.Panel:MakePopup()
end
local Tab = args[1]
if(!Tab) then
return
end
local Panel = STGamemodes.Store.Panel.Tabs[string.upper(Tab)]
if(Panel and Panel.Tab and Panel.Tab:IsValid()) then
STGamemodes.Store.Panel.PropertySheet:SetActiveTab(Panel.Tab)
end
end)

usermessage.Hook(“STGamemodes.Store.UserMessageReqLoad”, function(um)
if(STValidEntity(LocalPlayer())) then
RunConsoleCommand(“st_store_requestload”)
end
end)

usermessage.Hook(“STGamemodes.Store.UserMessageItemStart”, function(um)
STGamemodes.Store.Loading = true
STGamemodes.Store.StartUMsg = true
end)

function STGamemodes.Store:UserMessageMultiItemID(um)
for k,v in pairs(self.LoadList) do
local Char = tonumber(um:ReadChar())
local Cat = self:GetCat(v)
if(Cat) then
self.LocalItems[Cat] = self.LocalItems[Cat] or {}
if(Char > 0) then
self.LocalItems[Cat][v] = true
end
end
end
RunConsoleCommand(“st_store_loaded”, “MultiItemID”)
end
usermessage.Hook(“STGamemodes.Store.UserMessageMultiItemID”, function(um) STGamemodes.Store:UserMessageMultiItemID(um) end)

function STGamemodes.Store:UserMessageItem(um)
local Name = um:ReadString()
local Data = um:ReadString()
self.LocalItems[Name] = Json.Decode(Data)
RunConsoleCommand(“st_store_loaded”, Name)
end
usermessage.Hook(“STGamemodes.Store.UserMessageItem”, function(um) STGamemodes.Store:UserMessageItem(um) end)

function STGamemodes.Store:UserMessageCatItem(um)
local Cat = um:ReadString()
local Name = um:ReadString()
local Data = um:ReadString()
self.LocalItems[Cat] = self.LocalItems[Cat] or {}
self.LocalItems[Cat][Name] = Json.Decode(Data)
RunConsoleCommand(“st_store_loaded”, Cat, Name)
self.RefreshSettings = true
end
usermessage.Hook(“STGamemodes.Store.UserMessageCatItem”, function(um) STGamemodes.Store:UserMessageCatItem(um) end)

usermessage.Hook(“STGamemodes.Store.UserMessageItemEnd”, function(um)
STGamemodes.Store.Loading = false
STGamemodes.Store.LoadList = nil
if(STGamemodes.VIP) then
if(STGamemodes.Store:CatItemIsFree(LocalPlayer(), “Trails”)) then
STGamemodes.FreeTrail = true
STGamemodes.Message(“Free Trail”, “Since you are a VIP you get to buy 1 free trail with a value equal to or less than 30k!”)
end
end
end)

usermessage.Hook(“STGamemodes.Store.UserMessageItemFree”, function(um)
STGamemodes.Message(“Free Item”, “Since you are a VIP you have received a free “…um:ReadString()…”!”)
end)[/lua]