_rteam = {[1] = "ct", [2] = "t", [0] = "spec"}
function swapsides()
	for p = 1, 32, 1 do
		if player(p, "exists") then
			msg("Server Teams have being swapped")
			parse(string.format("make%s %s", _rteam[player(p, "team")], p))
		end
	end
end

if flacko==nil then flacko={} end
flacko.cash={}

addhook("startround","flacko.cash.spawncash")
function flacko.cash.spawncash(p)
	for i=1, 32 do
		if(player(i,"exists")) then
			parse("setmoney "..i.." 16000")
		end
	end
end

if flacko==nil then flacko={} end
flacko.cash={}

addhook("spawn","flacko.cash.spawn")
function flacko.cash.spawn(p)
     parse("setmoney "..p.." 16000")
end

function selectMain(p)
	strip(p, 50)
	equip(p, 50)
end

wpns = {}
for i = 1, 32, 1 do
	wpns[i] = {nades = 30, gun = 0, credits = 10}
end
nadetext = 'hudtxt2 %s %s "%s>>You have %s grenades<<" 160 100 1'
credittext = 'hudtxt2 %s %s "%s>>You have %s credits<<" 160 120 1'
guntext = 'hudtxt2 %s %s "%s>>%s<<" 160 140 1'

parse('hudtxt 4 "©255100000Type !nade to buy 2 nades for 2 Credits" 160 170 1')
function nade(p)
	local nades = wpns[p].nades
	if wpns[p].nades <= 0 then nades = "no" end
	local gun = "Your Gun is a "..wpns[p].gun
	if wpns[p].gun == 0 then gun = "You do not have a gun" end
	parse(string.format(nadetext, p, 1, "©255000000", nades))
	parse(string.format(credittext, p, 2, "©255000000", wpns[p].credits))
	parse(string.format(guntext, p, 3, "©255000000", gun))
end

addhook("startround", "init")
function init()
	for i = 1, 32, 1 do
		if player(i, "exists") then nade(i) end
	end
end

addhook("die", "die")

function die(p, w)
	if wpns[p].nades < 5 then
		wpns[p].nades = 5

	end
	wpns[p].credits = wpns[p].credits + 5
	nade(p)
end

addhook("spawn", "spawn")

function spawn(p, w)
	nade(p)
	parse("strip "..p.." 0")
	parse("equip "..p.." 51")
	if not wpns[p].gun == 0 then
		parse("equip "..p.." "..wpns[p].gun)
	end
	parse("strip "..p.." 50")
	parse("equip "..p.." 50")
end

addhook("collect", "collect")

function collect(p)
	return 1
end

addhook("buy", "buy")
function buy(p)
	return 1
end

addhook("projectile", "projectile")

function projectile(p, w)
	wpns[p].nades = wpns[p].nades - 1
	nade(p)
	if wpns[p].nades > 0 then
		parse("equip "..p.." 51")
	end
end

addhook("kill", "kill")

function kill(p, w)
	df = 0
	if w == 50 then
		df = 5
	end
	wpns[p].nades = wpns[p].nades + 2 + df
	wpns[p].credits = wpns[p].credits + 3 + df
	nades(p)
	parse("equip "..p.." 51")
end

addhook("leave", "leave")

function leave(p)
	wpns[p] = {nades = 5, gun = 0, credits = 10}
end

addhook("say", "say")
function say(p, t)
	if t == "!nade" then
		if wpns[p].credits >= 2 then
			wpns[p].credits = wpns[p].credits - 2
			wpns[p].nades = wpns[p].nades + 2
			nade(p)
			parse("equip "..p.." 51")
			msg2(p, "©155200000You have bought 2 Nades for 2 Credits.")
		else
			msg2(p, "©255100000You do not have enough credits")
		end
		return 1
	end
end

function digits(n, p, m)
	if not m then m = 10^p - 1 end
	if n == 0 then return "000" end
	if n <= m then
		local _p = 0
		while (n < 10^(p-1)) do
			p = p-1
			_p = _p + 1
		end
		local str = n
		for i = 1, _p, 1 do
			str = "0"..str
		end
		return str
	else
		return m
	end
end

function Color(r, b, g)
	return string.format("©%s%s%s", digits(r, 3, 255), digits(b, 3, 255),digits(g, 3, 255))
end

_msg = msg
function msg(t1, t2, b)
	local centered = ""
	local color = ""
	local text = ""
	if t2 then
		color = t1
		text = t2
	else
		color = ""
		text = t1
	end

	if b then
		centered = "@C"
	end
	return _msg(color..text..centered)
end

say = msg

_msg2 = msg2
function msg2(p, t1, t2, b)

	local centered = ""
	local color = ""
	local text = ""
	if t2 then
		 color = t1
		 text = t2
	else
		 color = ""
		 text = t1
	end

	if b then
		centered = "@C"
	end
	print(string.format("%sSayTo(%s:ID#\'%s\'): %s", color, player(p,"name"), p, text))
	return _msg2(p, color..text..centered)
end

sayto = msg2

-------------------------------------------------------------------
-- Utility: equip() Rewrite. Includes auto stripping. --
-- 31.03.2009 - http://amx2d.co.cc/ - AMX2D Scripting --
-- Author - Lee Gao
-- http://amx2d.co.cc/viewtopic.php?f=12&t=39
-------------------------------------------------------------------

--[[--
**INFO:**
This rewrite of the equip() function automatically
strips all of the conflicting weapons so the weapons
do not overlap. IE: No more of having an AK47 and a M4A1
at the same time.

**USAGE:**
Copy equip.lua (This file) into the sys/lua/ folder
In server.lua, add: dofile("sys/lua/equip.lua")

Equiping: equip(Player, Weapon(Name or ID), NoConflicts)

*Example:*
Player 1 has AK47, Deagle, HE, and Knife.

Do
	equip(1, "M4A1", true) leads to
Result: M4A1, Deagle, HE, and Knife

Do
	equip(1, "Laser", false) or equip(1, "Laser") leads to
Result: Laser, M4A1, Deagle, HE, and Knife.
--]]--

--###################################--
--############ Conditions ###########--
--###################################--

if not amx2d then
	print("Please read the comment on AMX2D exclusive features.")
end
if not equip then dofile("sys/lua/wrapper.lua") end
if not Knife then
	print("Please include Kiffer-Opa's Weapon list.")
	-- Author: Kiffer-Opa
	-- Melee Weapons
	Knife =50;
	Machete =69;
	Wrench =74;
	Claw =78;
	Chainsaw =85;
end
if not trim then
	--[[--
	If trim has not already been declared then just return the
	string and warn developers that they must not add extra spaces
	when calling equip - AMX2D.
	--]]--
	function trim(t) return t end
end
function selectMain(p)
	strip(p, Knife)
	equip(p, Knife)
end
--###################################--
--############# equip() #############--
--###################################--

local _equip = equip -- Preparing to overload function equip.

function equip(p, w, noConflict)
	--If used as equip(player, wpn), then return the normal version.
	if not noConflict then return _equip(p, w) end

	--[[--
	Checks if w is a string, if it is, converts it to the
	wpntype equivalent. Then it checks if the wpntype ID exists.

	**Note:**
	Must have AMX2D loaded to have this feature on, else you
	must use WeaponType instead of a string.
	--]]--

	if amx2d then
		if type(w) == "string" then
			if wpn.id[trim(w)] then
				w = wpn.id[trim(w)]
			else return
			end
		end
	end

	if not wpn.name[tonumber(w)] then return end

	--[[--
	This creates a list of all of the current weapons and
	strips them from the player, then gives him back the
	Knife.
	--]]--

	local _pwpn = {slot={}, oldslot = {}}

	local slot = function(_wpn)
		if (_wpn<=40 and _wpn>=10) or (_wpn<=49 and _wpn>=45) then
			--Primary Weapon - Slot 1
			return 1
		elseif (_wpn < 10) then
			--Secondary Weapon - Slot 2
			return 2
		elseif (_wpn == Knife or _wpn == Machete or _wpn == Wrench or _wpn == Claw or _wpn == Chainsaw) then
			--Melee - Slot 3
			return 3
		elseif (_wpn < 55 and _wpn > 50) then
			--Grenades - Slot 4
			return 4
		else
			--Slotless
			return 0
		end
	end

	selectMain(p)

	while not (player(p, "weapontype") == 50 or player(p, "weapontype") == 0) do
		local _wpn = player(p, "weapontype")
		msg2(p, Color(50, 50, 50), _wpn)
		_pwpn.oldslot[slot(_wpn)] = _wpn
		_pwpn.slot[slot(_wpn)] = _wpn
		_pwpn[_wpn] = _wpn -- In case we need to call _pwpn[wpntyp] to see if it exists.
		strip(p, _wpn)
	end


	--Slot 1 or 2 should strip these weapons.
	if (slot(w) == 1) or (slot(w)==2) then
		msg2(p, Color(50, 50, 50), tostring((slot(w) == 1)))
		_pwpn.slot[slot(w)] = w
	else
		equip(p, w)
	end

	--[[--
	Iterates through all of the slots of the new weapon table and
	equips them using equip (which we do not pass in the last boolean
	and thus will not do a full recusion)
	--]]--

	for k, v in pairs (_pwpn.slot) do
		--Will Re-equip everything, including Knife again.
		equip(p, v)
	end

	selectMain(p)
	return _pwpn -- Returns the old and current slot listing.
end

lua kogg_levelstealing=[i]true/false[/i]

lua kogg_reset()

lua kogg_mapchange=[i]true/false[/i]

lua kogg_defaultmode=[i]<game mode>[/i]

lua kogg_gunlevelsfile="[i]<filename>[/i]"

dofile("sys/lua/KOGG/KOGG.lua")

lua dofile("sys/lua/KOGG/KOGG.lua")

addhook("always","kogg_hud")

addhook("second","kogg_hud")

function split(t, b)
	return toTable(t, b)
end

function toTable(t, b)
	local cmd = {}
	local match = "[^%s]+"
	if b then
		match = "%w+"
	end
	if type(b) == "string" then match = "[^"..b.."]+" end
	if not t then return cmd end
	for word in string.gmatch(t, match) do
		table.insert(cmd, word)
	end
	return cmd
end

function trim(t)
	t = split(t)
	s = ""
	if not t then return end
	for i, v in ipairs(t) do
		s = s.." "..v
	end
	s = string.sub(s, 2)
	return s
end

function example_say(p, t)
	local _t = split(t)
	local cmd = _t[1]
	if not cmd then return nil end
	if cmd == "guns"
		local gun = _t[2] -- The default split automatically trims
		if not gun then return nil end
		if not type(_G[gun]) == "number" then return nil end
		equip(p, _G[gun])
		return 2
	end
end

addhook("say", "sayto")
function sayto(p, text)
	--text = '	!say "Hello AMX2D" 5 '
	text = string.trim(text)
	--text = '!say "Hello AMX2D" 5'
	text = string.qsplit(text)
	--text = {"!say", "Hello AMX2D", "5"}
	local cmd = text[1]
	--cmd = "!say"
	if cmd == "!say" then
		local t = text[2]
		--t = "Hello AMX2D"
		local p = tonumber(text[3])
		--p = 5
		msg2(p, t)
		--msg2(5, "Hello AMX2D")
	end
end

function string.join(t, d)
	if not (type(t) == "table") then return end
	return tostring(t, d)
end

_tostring = tostring
function tostring(t, d)
	if type(t) == "table" then
		if not d then d = "," end
		t = tableToString(t, 1, d)
		t = string.sub(t, 1, #t-#d)
		return t
	end

	if type(_tostring(t)) == "string" then return _tostring(t) end
end

function tableToString(t, n, d)
	local s = ""
	if (n == nil) then n = 1 end
	if not d then d = " " end
	while (n <= #t) do
		s = s .. t[n] .. "".. d
		n = n + 1
	end
	return s
end

function string.trim(t)
	t = string.split(t)
	s = ""
	if not t then return end
	for i, v in ipairs(t) do
		s = s.." "..v
	end
	s = string.sub(s, 2)
	return s
end

function string.split(t, b)
	local cmd = {}
	local match = "[^%s]+"
	if b then
		match = "%w+"
	end
	if type(b) == "string" then match = "[^"..b.."]+" end
	if not t then return invalid() end
	for word in string.gmatch(t, match) do
		table.insert(cmd, word)
	end
	return cmd
end

function string.capitalize(t)
	local str = string.split(t)
	for i, word in ipairs(str) do
		local eword = string.sub(word, 2)
		local bword = string.upper(string.sub(word, 1, 1))
		str[i] = bword..eword
	end
	return tostring(str, " ")
end

function string.letters(t)
	local letters = {}
	for word in string.gmatch(t, ".") do
		table.insert(letters, word)
	end
	return letters
end

function string.word(t, sub)
	local str = string.split(t)
	sub = string.trim(sub)
	local tab = {}
	for i, word in ipairs(str) do
		if word == sub then
			table.insert(tab, i)
		end
	end
	return tab
end

function string.index(t, sub)
	local str = string.letters(t)
	local n = #sub
	local tab = {}
	for i, letter in ipairs(str) do
		if letter == string.sub(sub, 1, 1) then
			local _let = letter
			for _i = 1, n-1, 1 do
				if not str[_i+i] == string.sub(sub, _i, _i) then break end
				_let = _let .. str[_i+i]
			end
			if _let == sub then
				table.insert(tab, i)
			end
		end
	end
	return tab
end

function string.translate(t, d)
	if not (type(d) == "table") then d = string.split(d) end
	for i, v in ipairs(d) do
		d[tostring(v)] = true
	end
	local str = string.letters(t)
	local _t = ""
	for i, letter in ipairs(str) do
		if not d[letter] then
			_t = _t..letter
		end
	end
	return _t
end

function string.qsplit(t)
	local tab = string.split(t, '"')
	if #tab == 1 then
		return string.split(tab[1])
	end
	local ret = {}
	for i, v in ipairs(tab) do
		if i%2 == 0 then
			table.insert(ret, v)
		else
			v = string.split(v)
			for _i, _v in ipairs(v) do
				table.insert(ret, _v)
			end
		end
	end
	return ret
end

--[-- Examples - Uncomment and Run
print(tostring({"1", "2", "3"}, " + "))

print(string.join({"1", "2", "3"}, " + "))

print(string.trim("  asdf sdf s dsf    "))

print(string.split("say I love AMX2D"))

print(string.capitalize("testing something"))

print(string.letters("omfg oO"))

print(string.word("say I love AMX and AMX2D and AMX", "AMX"))

print(string.index("say I love AMX and AMX2D and AMX", "AMX"))

print(string.translate("say I love AMX and AMX2D and AMX", {"a"}))

print(string.qsplit("!say \"Hello AMX2D\" 5"))
--]]--

print(tostring({"1", "2", "3"}, " + "))

1 + 2 + 3

string.join({"1", "2", "3"}, " + ")

1 + 2 + 3

string.trim("  asdf sdf s dsf    ")

asdf sdf s dsf

string.split("say I love AMX2D")

{"say", "I", "love", "AMX2D"}

string.capitalize("testing something")

[b]T[/b]esting [b]S[/b]omething

string.letters("omfg oO")

{"o", "m", "f", "g", " ", "o", "O"}

string.word("say I love AMX and AMX2D and AMX", "AMX")

{4, 7}

string.index("say I love AMX and AMX2D and AMX", "AMX")

{12, 20, 30}

string.translate("say I love AMX2D", {"a"})

"sy I love AMX2D"

string.qsplit('guns "Player 1" AK47')

{"guns", "Player 1", "AK47"}

stream = "afadsf3"

print(ReadByte(stream)) -- Returns ASCII of 'a'

print(ReadByte(stream)) -- Returns ASCII of 'f'

print(ReadLine(stream)) -- Returns the stream from position 3
[code]


output:


[code]
97
103
adsf3

loadfile("struct.lua")()

print(WriteByte(97)..WriteByte(103)..WriteLine("testing"))

astest

--**********************--
--**********************--
--****-=Struct.lua=-****--
--**********************--
--**********************--
--*****************************************--
--This is a port of 3rr0r's bb_udp.py******--
--Note, lua does not have native support***--
--for C styled Data Structure packing******--
--so the packing logic have to be rewritten--
--*****************************************--

--[[

**Author: Lee Gao
**Website: http://tgvserver.info
**Title: Struct.lua
**Description: This is a tool to treat data as
a stream and uses pointers to traverse the "stream"
This is a port of the standard library developed by
3rr0r which was used in the development of his dedicated
servers.

--]]

--Initialization--
readcount = {}

--Utility Functions
function isIn(t, a)
	for i,v in ipairs(a) do
		if v == t then return true end
	end
end

function s_delStream(t)
	if readcount[t] then
		readcount[t] = nil
	end
end

function s_get(t)
	if readcount[t] then
		return string.sub(t,readcount[t])
	else
		readcount[t] = 1
		return t
	end
end

function s_update(t, ln)
	readcount[t] = readcount[t] + ln
	if readcount[t] > #t then
		readcount[t] = 1
	end
end

function getByte(t)
	local t_ = {}
	for i = 1, #t, 1 do
		table.insert(t_, string.byte(t,i))
	end
	return t_
end

function isByte(n)
	for i, v in ipairs(n) do
		if v > 255 then return false end
	end
	return true
end



--Write Functions--

function WriteByte(p)
	if p > 255 then p = 255 elseif p < 0 then p = 0 end
	return(string.char(b1))
end

function WriteShort(p)
	local b1 = p%256
	local b2 = (p-b1)/256
	--[[
	Concept: A short is 2 bytes, the first byte denotes the lower
	255 bytes and the 2nd denotes the upper 255^2 bytes.
	]]
	if not isByte({b1, b2}) then
		return string.char(255)..string.char(255)
	else
		return(string.char(b1)..string.char(b2))
	end
end

function WriteInt(p)
	local b1 = p%256
	local p2 = (p-b1)/256
	local b2 = p2%256
	local p3 = (p2-b2)/256
	local b3 = p3%256
	local b4 = (p3-b3)/256
	--[[
	Concept: Similar to short, but instead of 2 bytes,
	there are 4 bytes. The 1st byte denotes the lower
	255 bytes and the 2nd denotes the 255^2 bytes, the
	3rd denotes the 255^3 bytes and the 4th denotes the
	255^4
	]]
	if not isByte({b1, b2, b3, b4}) then
		return string.char(255)..string.char(255)..string.char(255)..string.char(255)
	end
	return(string.char(b1)..string.char(b2)..string.char(b3)..string.char(b4))
end

function WriteLine(t)
	return(t..string.char(13)..string.char(10))
end

function WriteString(t)
	return(WriteByte(#t)..t)
end

--Read Functions--

function ReadByte(t)
	local stream = s_get(t)
	local byte = getByte(stream)[1]
	s_update(t, 1)
	return byte
end

function ReadShort(t)
	local stream = s_get(t)
	local b1 = getByte(stream)[1]
	local b2 = getByte(stream)[2]
	s_update(t, 2)
	return b2*256+b1
end

function ReadInt(t)
	local stream = s_get(t)
	local b1 = getByte(stream)[1]
	local b2 = getByte(stream)[2]
	local b3 = getByte(stream)[3]
	local b4 = getByte(stream)[4]
	s_update(t, 4)
	return b2*256+b1+b3*256*256+b4*256*256*256
end

function ReadLine(t)
	s = s_get(t)
	if string.find(s, "\n") then
		i = string.find(s,"\n")
		x = string.find(s, string.char(13))
		if x then
			s = string.sub(s, 1, i-2)
		else
			s = string.sub(s, 1, i-1)
		end
		s_update(t, i)

		return s
	else
		s_update(t, #s)
		return s
	end
end

function ReadString(t,n)
	if not n then
		n = ReadByte(t)
	end

	s = s_get(t)
	s = string.sub(s,1,n)
	s_update(t, n)
	return s
end

if not _tostring then _tostring = tostring end

local _table = {}
for k, v in pairs(table) do _table[k] = v end

function table.find(t, o)
	for k, v in pairs(t) do
		if v == o then
			return k
		end
	end
end

function table.seperate(t)
	local itab = {}
	local tab = {}
	for k, v in pairs(t) do
		if type(k) == "number" then
			itab[k] = v
		else
			tab[k] = v
		end
	end
	return itab, tab
end

function table.invert(t, _i)
	local tab = {}
	for k, v in pairs(t) do
		if type(v) == "table" and not _i then
			for _k, _v in pairs(v) do
				tab[_v] = k
			end
		else
			if not tab[v] then
				tab[v] = k
			else
				if not (type(tab[v]) == "table") then
					tab[v] = {tab[v], k}
				else
					table.insert(tab[v], k)
				end
			end
		end
	end
	return tab
end

function table.length(t)
	local n = 0
	for k, v in pairs(t) do
		n = n+1
	end
	return n
end

function table.ascend(x, y)
	return x<y
end

function table.descend(x, y)
	return x>y
end

function table.ssort(t,f)
	if not f then f = table.ascend end
	local i=1
	local x, _x = table.seperate(t)
	local n = table.length(x)
	while i<=n do
		local m,j=i,i+1
		while j<=n do
			if f(x[j],x[m]) then m=j end
			j=j+1
		end
		x[i],x[m]=x[m],x[i]			-- swap x[i] and x[m]
		i=i+1
	end
	return table.join(x, _x, false)
end

function table.sort(t, f)
	return table.seperate(table.ssort(t, f))
end

function table.first(t)
	for k, v in pairs(t) do
		return k, v
	end
end

function table.sfirst(t)
	for k, v in pairs(t) do
		if type(k) == "string" then
			return k, v
		end
	end
end

function table.ifirst(t)
	for k, v in pairs(t) do
		if type(k) == "number" then
			return k, v
		end
	end
end

function table.firstVal(t)
	for k, v in pairs(t) do
		return v
	end
end

function table.sfirstVal(t)
	for k, v in pairs(t) do
		if type(k) == "string" then
			return v
		end
	end
end

function table.ifirstVal(t)
	for k, v in pairs(t) do
		if type(k) == "number" then
			return v
		end
	end
end

function table.join(t1, t2, o)
	local tab = t1
	for k, v in pairs(t2) do
		if (t1[k] and o) or not (t1[k]) then
			tab[k] = v
		end
	end
	return tab
end

local seen = {}
local _s_ = ""
function table.dump(t,i, b)

	seen[t]=true
	if not i then i = "" end

	for k,v in pairs(t) do
		local _v, _b = table.tostring(v)
		_s_ = _s_..i.._tostring(table.tostring(k)).." = ".._tostring(_v).." \n"
		if _b and not seen[v] then
			table.dump(v, i.."\t", true)
		end
	end

	if not b then
		local name = table.find(_G, t)
		if not name then name = "(Anonymous)" end
		_s_ =  "[Table:"..name.. "]\n".._s_
		print (_s_)
		local r = _s_

		_s_ = ""
		seen = {}
		return r
	end
end

function table.tostring(t)
	if not (type(t)  == "table") then if type(t) == "function" then return "fn()" end return _tostring(t) end
	local s = "{"
	local b = false
	for k, v in pairs(t) do
		if type(v) == "string" then v = "'"..v.."'" end
		if type(v) == "function" then v= "fn()" end
		if type(v) == "table" then
			v = "[T]"
			b = true
		end
		s = s .. _tostring(k) .. " = " .. _tostring(v) .. ", "
	end
	s = string.sub(s, 1, #s - 2).."}"
	return s, b
end

function table.stripkeys(t, n)
	local tab = {}
	if not n then n = "key" end
	for k, v in pairs(t) do
		if isTable(v) then
			v[n] = k
			table.insert(tab,v)
		end
	end
	return tab
end

function table.getkeys(t)
	local tab = {}
	for k, v in pairs(t) do
		tab[k] = true
	end
	return tab
end

function table.ismatrix(t)
	local _k, _v = table.first(t)
	if not (type(_v) == "table") then return false end
	local keys = table.getkeys(_v)
	for k, v in pairs(t) do
		if not (type(v) == "table") then return false end
		if not table.havekeys(table.getkeys(v), keys) then return false end
	end
	return true
end

function table.equal(t1, t2)
	for k, v in pairs(t1) do
		if t2[k] ~= v then return false end
	end
	return true
end

function table.havekeys(t1, t2)
	for k, v in pairs(t1) do
		if not t2[k] then return false end
	end
	return true
end

function table.haskey(t, k)
	if not t[k] then return false end
	return true
end

function table.setkey(t, k, p)
	if not table.ismatrix(t) then return t end
	if not table.haskey(table.firstVal(t), k) then return t end
	local tab = {}

	for i, v in pairs(t) do
		tab[v[k]] = v
		if not p then
			tab[v[k]][k] = nil
		end
	end

	return tab
end

function table.get(t, key)
	if not table.ismatrix(t) then return t end
	if not table.haskey(table.firstVal(t), key) then return t end

	local tab = {}
	for k, v in pairs(t) do
		table.insert(tab, {key = k, value = v[key]})
	end
	return tab
end

function table.diff(t1, t2, b)
	local tab1, tab2 = "", ""
	if not b then
		tab1 = table.find(_G, t1)
		tab2 = table.find(_G, t2)
	end
	if not tab1 then tab1 = "Anon:T1" end
	if not tab2 then tab2 = "Anon:T2" end
	local changed = {}
	local removed = {}
	local new = {}
	local same = {}

	for k, v in pairs(t1) do
		if not t2[k] then
			removed[k] = v
		end

		if not (t2[k] == v) then
			changed[k] = {old = v, new = t2[k]}
		end

		if t2[k] == t1[k] then
			same[k] = v
		end
	end

	for k, v in pairs(t2) do
		if not (changed[k] or removed[k] or same[k]) then
			new[k] = v
		end
	end

	return {changed = changed, removed = removed, new = new, same = same, Tables = {t1 = tab1, t2 = tab2}}
end

function isTable(t)
	if type(t) == "table" then return true end
end


--[--
print("!Initial Values of test1d")
test1d = {a = 1, b=2, c=3, d = 3, 3, 2, 4, 2}
table.dump(test1d)

print("!Initial Values of sorted, which is test1d sorted via indices. Note the string keys are unsorted.")
sorted = table.ssort(test1d)
table.dump(sorted)

print("!Sorted using ssort to remove none-indices")
sorted = table.sort(test1d)
table.dump(sorted)

print("!The DIFF between test1d and sorted")
table.dump(table.diff(test1d, table.sort(test1d)))

print("!Inverted values of test1d")
test1d = table.invert(test1d)
table.dump(test1d)

print("!Inverted values of inverted values of test1d")
table.dump(table.invert(test1d, true))

print("!The DIFF between doubleinverted test1d and sorted")
table.dump(table.diff(table.invert(test1d, true), sorted))

print("!Inverted values of inverted values of test1d with smart keys")
test1d = table.invert(test1d)
table.dump(test1d)

print("!Initial Values of _2d matrix")
_2d = {
	lee = {score = 1, rank = 3},
	joe = {score = 2, rank = 2},
	bob = {score = 5, rank = 1}
}
table.dump(_2d)

print("!_2d with its keys stripped as 'name'")
_2d = table.stripkeys(_2d, "name")
table.dump(_2d)

print("!_2d with its 'score' column set as the keys")
_2d = table.setkey(_2d, "score", true)
table.dump(_2d)

print("!Returns a table of the values of column 'score'")
table.dump(table.get(_2d, "score"))

print("!Returns a table of the values of column 'rank'")
table.dump(table.get(_2d, "rank"))


--]]--

addhook("say","player_say")
function player_say(id,txt)
     if(txt=="!usp") then
          parse("equip "..id.." 1")
     if(txt=="!glock") then
          parse("equip "..id.." 2")
     if(txt=="!deagle") then
          parse("equip "..id.." 3")
     end
end

addhook("say","player_say")
function player_say(id,txt)
	if(txt=="!usp") then
		parse("equip "..id.." 1")
	if(txt=="!glock") then
		parse("equip "..id.." 2")
	if(txt=="!deagle") then
		parse("equip "..id.." 3")
	end
end

addhook("say","player_say")
function player_say(id,txt)
	if(txt=="!usp") then
		parse("equip "..id.." 1")end
	if(txt=="!glock") then
		parse("equip "..id.." 2")end
	if(txt=="!deagle") then
		parse("equip "..id.." 3")end
	end
end