_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