Started refactoring item and inventory system

15 files changed, 29 insertions, 1561 deletions

diff --git a/gamemode/shared/aes.lua b/gamemode/shared/aes.lua
deleted file mode 100644
index 244dc22..0000000
--- a/gamemode/shared/aes.lua
+++ /dev/null
@@ -1,524 +0,0 @@
-local Stream = include("lockbox/stream.lua");
-local Array = include("lockbox/array.lua");
-
-local Bit = include("lockbox/bit.lua");
---local Math = require("math");
-
-
-local AND = bit.band;
-local OR  = bit.bor;
-local NOT = bit.bnot;
-local XOR = bit.bxor;
---local LROT = Bit.lrotate;
---local RROT = Bit.rrotate;
-local LSHIFT = bit.lshift;
-local RSHIFT = bit.rshift;
-
-local SBOX = {
- [0]=0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
- 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
- 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
- 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
- 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
- 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
- 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
- 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
- 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
- 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
- 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
- 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
- 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
- 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
- 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
- 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16};
-
-local ISBOX = {
- [0]=0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
- 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
- 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
- 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
- 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
- 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
- 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
- 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
- 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
- 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
- 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
- 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
- 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
- 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
- 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
- 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D};
-
-local ROW_SHIFT =  {  1,  6, 11, 16,  5, 10, 15,  4,  9, 14,  3,  8, 13,  2,  7, 12,};
-local IROW_SHIFT = {  1, 14, 11,  8,  5,  2, 15, 12,  9,  6,  3, 16, 13, 10,  7,  4,};
-
-local ETABLE = {
- [0]=0x01, 0x03, 0x05, 0x0F, 0x11, 0x33, 0x55, 0xFF, 0x1A, 0x2E, 0x72, 0x96, 0xA1, 0xF8, 0x13, 0x35,
- 0x5F, 0xE1, 0x38, 0x48, 0xD8, 0x73, 0x95, 0xA4, 0xF7, 0x02, 0x06, 0x0A, 0x1E, 0x22, 0x66, 0xAA,
- 0xE5, 0x34, 0x5C, 0xE4, 0x37, 0x59, 0xEB, 0x26, 0x6A, 0xBE, 0xD9, 0x70, 0x90, 0xAB, 0xE6, 0x31,
- 0x53, 0xF5, 0x04, 0x0C, 0x14, 0x3C, 0x44, 0xCC, 0x4F, 0xD1, 0x68, 0xB8, 0xD3, 0x6E, 0xB2, 0xCD,
- 0x4C, 0xD4, 0x67, 0xA9, 0xE0, 0x3B, 0x4D, 0xD7, 0x62, 0xA6, 0xF1, 0x08, 0x18, 0x28, 0x78, 0x88,
- 0x83, 0x9E, 0xB9, 0xD0, 0x6B, 0xBD, 0xDC, 0x7F, 0x81, 0x98, 0xB3, 0xCE, 0x49, 0xDB, 0x76, 0x9A,
- 0xB5, 0xC4, 0x57, 0xF9, 0x10, 0x30, 0x50, 0xF0, 0x0B, 0x1D, 0x27, 0x69, 0xBB, 0xD6, 0x61, 0xA3,
- 0xFE, 0x19, 0x2B, 0x7D, 0x87, 0x92, 0xAD, 0xEC, 0x2F, 0x71, 0x93, 0xAE, 0xE9, 0x20, 0x60, 0xA0,
- 0xFB, 0x16, 0x3A, 0x4E, 0xD2, 0x6D, 0xB7, 0xC2, 0x5D, 0xE7, 0x32, 0x56, 0xFA, 0x15, 0x3F, 0x41,
- 0xC3, 0x5E, 0xE2, 0x3D, 0x47, 0xC9, 0x40, 0xC0, 0x5B, 0xED, 0x2C, 0x74, 0x9C, 0xBF, 0xDA, 0x75,
- 0x9F, 0xBA, 0xD5, 0x64, 0xAC, 0xEF, 0x2A, 0x7E, 0x82, 0x9D, 0xBC, 0xDF, 0x7A, 0x8E, 0x89, 0x80,
- 0x9B, 0xB6, 0xC1, 0x58, 0xE8, 0x23, 0x65, 0xAF, 0xEA, 0x25, 0x6F, 0xB1, 0xC8, 0x43, 0xC5, 0x54,
- 0xFC, 0x1F, 0x21, 0x63, 0xA5, 0xF4, 0x07, 0x09, 0x1B, 0x2D, 0x77, 0x99, 0xB0, 0xCB, 0x46, 0xCA,
- 0x45, 0xCF, 0x4A, 0xDE, 0x79, 0x8B, 0x86, 0x91, 0xA8, 0xE3, 0x3E, 0x42, 0xC6, 0x51, 0xF3, 0x0E,
- 0x12, 0x36, 0x5A, 0xEE, 0x29, 0x7B, 0x8D, 0x8C, 0x8F, 0x8A, 0x85, 0x94, 0xA7, 0xF2, 0x0D, 0x17,
- 0x39, 0x4B, 0xDD, 0x7C, 0x84, 0x97, 0xA2, 0xFD, 0x1C, 0x24, 0x6C, 0xB4, 0xC7, 0x52, 0xF6, 0x01};
-
-local LTABLE = {
- [0]=0x00, 0x00, 0x19, 0x01, 0x32, 0x02, 0x1A, 0xC6, 0x4B, 0xC7, 0x1B, 0x68, 0x33, 0xEE, 0xDF, 0x03,
- 0x64, 0x04, 0xE0, 0x0E, 0x34, 0x8D, 0x81, 0xEF, 0x4C, 0x71, 0x08, 0xC8, 0xF8, 0x69, 0x1C, 0xC1,
- 0x7D, 0xC2, 0x1D, 0xB5, 0xF9, 0xB9, 0x27, 0x6A, 0x4D, 0xE4, 0xA6, 0x72, 0x9A, 0xC9, 0x09, 0x78,
- 0x65, 0x2F, 0x8A, 0x05, 0x21, 0x0F, 0xE1, 0x24, 0x12, 0xF0, 0x82, 0x45, 0x35, 0x93, 0xDA, 0x8E,
- 0x96, 0x8F, 0xDB, 0xBD, 0x36, 0xD0, 0xCE, 0x94, 0x13, 0x5C, 0xD2, 0xF1, 0x40, 0x46, 0x83, 0x38,
- 0x66, 0xDD, 0xFD, 0x30, 0xBF, 0x06, 0x8B, 0x62, 0xB3, 0x25, 0xE2, 0x98, 0x22, 0x88, 0x91, 0x10,
- 0x7E, 0x6E, 0x48, 0xC3, 0xA3, 0xB6, 0x1E, 0x42, 0x3A, 0x6B, 0x28, 0x54, 0xFA, 0x85, 0x3D, 0xBA,
- 0x2B, 0x79, 0x0A, 0x15, 0x9B, 0x9F, 0x5E, 0xCA, 0x4E, 0xD4, 0xAC, 0xE5, 0xF3, 0x73, 0xA7, 0x57,
- 0xAF, 0x58, 0xA8, 0x50, 0xF4, 0xEA, 0xD6, 0x74, 0x4F, 0xAE, 0xE9, 0xD5, 0xE7, 0xE6, 0xAD, 0xE8,
- 0x2C, 0xD7, 0x75, 0x7A, 0xEB, 0x16, 0x0B, 0xF5, 0x59, 0xCB, 0x5F, 0xB0, 0x9C, 0xA9, 0x51, 0xA0,
- 0x7F, 0x0C, 0xF6, 0x6F, 0x17, 0xC4, 0x49, 0xEC, 0xD8, 0x43, 0x1F, 0x2D, 0xA4, 0x76, 0x7B, 0xB7,
- 0xCC, 0xBB, 0x3E, 0x5A, 0xFB, 0x60, 0xB1, 0x86, 0x3B, 0x52, 0xA1, 0x6C, 0xAA, 0x55, 0x29, 0x9D,
- 0x97, 0xB2, 0x87, 0x90, 0x61, 0xBE, 0xDC, 0xFC, 0xBC, 0x95, 0xCF, 0xCD, 0x37, 0x3F, 0x5B, 0xD1,
- 0x53, 0x39, 0x84, 0x3C, 0x41, 0xA2, 0x6D, 0x47, 0x14, 0x2A, 0x9E, 0x5D, 0x56, 0xF2, 0xD3, 0xAB,
- 0x44, 0x11, 0x92, 0xD9, 0x23, 0x20, 0x2E, 0x89, 0xB4, 0x7C, 0xB8, 0x26, 0x77, 0x99, 0xE3, 0xA5,
- 0x67, 0x4A, 0xED, 0xDE, 0xC5, 0x31, 0xFE, 0x18, 0x0D, 0x63, 0x8C, 0x80, 0xC0, 0xF7, 0x70, 0x07};
-
-local MIXTABLE = {
- 0x02, 0x03, 0x01, 0x01,
- 0x01, 0x02, 0x03, 0x01,
- 0x01, 0x01, 0x02, 0x03,
- 0x03, 0x01, 0x01, 0x02};
-
-local IMIXTABLE = {
- 0x0E, 0x0B, 0x0D, 0x09,
- 0x09, 0x0E, 0x0B, 0x0D,
- 0x0D, 0x09, 0x0E, 0x0B,
- 0x0B, 0x0D, 0x09, 0x0E};
-
-local RCON = {
-[0] = 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
-0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
-0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
-0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
-0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
-0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
-0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
-0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
-0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
-0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
-0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
-0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
-0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
-0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
-0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
-0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d};
-
-
-local GMUL = function(A,B)
-	if(A == 0x01) then return B; end
-	if(B == 0x01) then return A; end
-	if(A == 0x00) then return 0; end
-	if(B == 0x00) then return 0; end
-    print("Gettin gthe LTable of " .. A)
-    print("Getting the LTable of " .. B)
-	local LA = LTABLE[A];
-	local LB = LTABLE[B];
-
-	local sum = LA + LB;
-	if (sum > 0xFF) then sum = sum - 0xFF; end
-
-	return ETABLE[sum];
-end
-
-local byteSub = Array.substitute;
-
-local shiftRow = Array.permute;
-
-local mixCol = function(i,mix)
-	local out = {};
-
-	local a,b,c,d;
-    print("I is:")
-    PrintTable(i)
-	a = GMUL(i[ 1],mix[ 1]);
-	b = GMUL(i[ 2],mix[ 2]);
-	c = GMUL(i[ 3],mix[ 3]);
-	d = GMUL(i[ 4],mix[ 4]);
-	out[ 1] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[ 1],mix[ 5]);
-	b = GMUL(i[ 2],mix[ 6]);
-	c = GMUL(i[ 3],mix[ 7]);
-	d = GMUL(i[ 4],mix[ 8]);
-	out[ 2] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[ 1],mix[ 9]);
-	b = GMUL(i[ 2],mix[10]);
-	c = GMUL(i[ 3],mix[11]);
-	d = GMUL(i[ 4],mix[12]);
-	out[ 3] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[ 1],mix[13]);
-	b = GMUL(i[ 2],mix[14]);
-	c = GMUL(i[ 3],mix[15]);
-	d = GMUL(i[ 4],mix[16]);
-	out[ 4] = XOR(XOR(a,b),XOR(c,d));
-
-
-	a = GMUL(i[ 5],mix[ 1]);
-	b = GMUL(i[ 6],mix[ 2]);
-	c = GMUL(i[ 7],mix[ 3]);
-	d = GMUL(i[ 8],mix[ 4]);
-	out[ 5] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[ 5],mix[ 5]);
-	b = GMUL(i[ 6],mix[ 6]);
-	c = GMUL(i[ 7],mix[ 7]);
-	d = GMUL(i[ 8],mix[ 8]);
-	out[ 6] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[ 5],mix[ 9]);
-	b = GMUL(i[ 6],mix[10]);
-	c = GMUL(i[ 7],mix[11]);
-	d = GMUL(i[ 8],mix[12]);
-	out[ 7] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[ 5],mix[13]);
-	b = GMUL(i[ 6],mix[14]);
-	c = GMUL(i[ 7],mix[15]);
-	d = GMUL(i[ 8],mix[16]);
-	out[ 8] = XOR(XOR(a,b),XOR(c,d));
-
-
-	a = GMUL(i[ 9],mix[ 1]);
-	b = GMUL(i[10],mix[ 2]);
-	c = GMUL(i[11],mix[ 3]);
-	d = GMUL(i[12],mix[ 4]);
-	out[ 9] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[ 9],mix[ 5]);
-	b = GMUL(i[10],mix[ 6]);
-	c = GMUL(i[11],mix[ 7]);
-	d = GMUL(i[12],mix[ 8]);
-	out[10] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[ 9],mix[ 9]);
-	b = GMUL(i[10],mix[10]);
-	c = GMUL(i[11],mix[11]);
-	d = GMUL(i[12],mix[12]);
-	out[11] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[ 9],mix[13]);
-	b = GMUL(i[10],mix[14]);
-	c = GMUL(i[11],mix[15]);
-	d = GMUL(i[12],mix[16]);
-	out[12] = XOR(XOR(a,b),XOR(c,d));
-
-
-	a = GMUL(i[13],mix[ 1]);
-	b = GMUL(i[14],mix[ 2]);
-	c = GMUL(i[15],mix[ 3]);
-	d = GMUL(i[16],mix[ 4]);
-	out[13] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[13],mix[ 5]);
-	b = GMUL(i[14],mix[ 6]);
-	c = GMUL(i[15],mix[ 7]);
-	d = GMUL(i[16],mix[ 8]);
-	out[14] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[13],mix[ 9]);
-	b = GMUL(i[14],mix[10]);
-	c = GMUL(i[15],mix[11]);
-	d = GMUL(i[16],mix[12]);
-	out[15] = XOR(XOR(a,b),XOR(c,d));
-	a = GMUL(i[13],mix[13]);
-	b = GMUL(i[14],mix[14]);
-	c = GMUL(i[15],mix[15]);
-	d = GMUL(i[16],mix[16]);
-	out[16] = XOR(XOR(a,b),XOR(c,d));
-
-	return out;
-end
-
-local keyRound = function(key,round)
-	local i=(round-1)*32;
-	local out=key;
-    print("Doing keyRound on key:")
-    PrintTable(key)
-    print("key[i+1]=")
-    print(key[i+1])
-    print("SBOX[out[30+i]]=")
-    print(SBOX[out[30+i]])
-    print("out[30+i]=")
-    print(out[30+i])
-    print("RCON[round]=")
-    print(RCON[round])
-	out[33+i] = XOR(key[ 1+i],XOR(SBOX[key[30+i]],RCON[round]));
-	out[34+i] = XOR(key[ 2+i],SBOX[key[31+i]]);
-	out[35+i] = XOR(key[ 3+i],SBOX[key[32+i]]);
-	out[36+i] = XOR(key[ 4+i],SBOX[key[29+i]]);
-
-	out[37+i] = XOR(out[33+i],key[ 5+i]);
-	out[38+i] = XOR(out[34+i],key[ 6+i]);
-	out[39+i] = XOR(out[35+i],key[ 7+i]);
-	out[40+i] = XOR(out[36+i],key[ 8+i]);
-
-	out[41+i] = XOR(out[37+i],key[ 9+i]);
-	out[42+i] = XOR(out[38+i],key[10+i]);
-	out[43+i] = XOR(out[39+i],key[11+i]);
-	out[44+i] = XOR(out[40+i],key[12+i]);
-
-	out[45+i] = XOR(out[41+i],key[13+i]);
-	out[46+i] = XOR(out[42+i],key[14+i]);
-	out[47+i] = XOR(out[43+i],key[15+i]);
-	out[48+i] = XOR(out[44+i],key[16+i]);
-
-
-	out[49+i] = XOR(SBOX[out[45+i]],key[17+i]);
-	out[50+i] = XOR(SBOX[out[46+i]],key[18+i]);
-	out[51+i] = XOR(SBOX[out[47+i]],key[19+i]);
-	out[52+i] = XOR(SBOX[out[48+i]],key[20+i]);
-
-	out[53+i] = XOR(out[49+i],key[21+i]);
-	out[54+i] = XOR(out[50+i],key[22+i]);
-	out[55+i] = XOR(out[51+i],key[23+i]);
-	out[56+i] = XOR(out[52+i],key[24+i]);
-
-	out[57+i] = XOR(out[53+i],key[25+i]);
-	out[58+i] = XOR(out[54+i],key[26+i]);
-	out[59+i] = XOR(out[55+i],key[27+i]);
-	out[60+i] = XOR(out[56+i],key[28+i]);
-
-	out[61+i] = XOR(out[57+i],key[29+i]);
-	out[62+i] = XOR(out[58+i],key[30+i]);
-	out[63+i] = XOR(out[59+i],key[31+i]);
-	out[64+i] = XOR(out[60+i],key[32+i]);
-
-	return out;
-end
-
-local keyExpand = function(key)
-	local bytes = Array.copy(key);
-
-	for i=1,7 do
-		keyRound(bytes,i);
-	end
-
-	local keys = {};
-
-	keys[ 1] = Array.slice(bytes,1,16);
-	keys[ 2] = Array.slice(bytes,17,32);
-	keys[ 3] = Array.slice(bytes,33,48);
-	keys[ 4] = Array.slice(bytes,49,64);
-	keys[ 5] = Array.slice(bytes,65,80);
-	keys[ 6] = Array.slice(bytes,81,96);
-	keys[ 7] = Array.slice(bytes,97,112);
-	keys[ 8] = Array.slice(bytes,113,128);
-	keys[ 9] = Array.slice(bytes,129,144);
-	keys[10] = Array.slice(bytes,145,160);
-	keys[11] = Array.slice(bytes,161,176);
-	keys[12] = Array.slice(bytes,177,192);
-	keys[13] = Array.slice(bytes,193,208);
-	keys[14] = Array.slice(bytes,209,224);
-	keys[15] = Array.slice(bytes,225,240);
-
-	return keys;
-
-end
-
-local addKey = Array.XOR;
-
-
-
-local AES = {};
-
-AES.blockSize = 16;
-
-AES.encrypt = function(key,block)
-    print("Calling keyExpand on :")
-    PrintTable(key)
-	local key = keyExpand(key);
-
-	--round 0
-	block = addKey(block,key[1]);
-
-    print("block is:")
-    PrintTable(block)
-
-	--round 1
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[2]);
-
-	--round 2
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[3]);
-
-	--round 3
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[4]);
-
-	--round 4
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[5]);
-
-	--round 5
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[6]);
-
-	--round 6
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[7]);
-
-	--round 7
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[8]);
-
-	--round 8
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[9]);
-
-	--round 9
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[10]);
-
-	--round 10
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[11]);
-
-	--round 11
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[12]);
-
-	--round 12
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[13]);
-
-	--round 13
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = mixCol(block,MIXTABLE);
-	block = addKey(block,key[14]);
-
-	--round 14
-	block = byteSub(block,SBOX);
-	block = shiftRow(block,ROW_SHIFT);
-	block = addKey(block,key[15]);
-
-	return block;
-
-end
-
-AES.decrypt = function(key,block)
-
-	local key = keyExpand(key);
-
-	--round 0
-	block = addKey(block,key[15]);
-
-	--round 1
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[14]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 2
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[13]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 3
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[12]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 4
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[11]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 5
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[10]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 6
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[9]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 7
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[8]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 8
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[7]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 9
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[6]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 10
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[5]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 11
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[4]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 12
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[3]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 13
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[2]);
-	block = mixCol(block,IMIXTABLE);
-
-	--round 14
-	block = shiftRow(block,IROW_SHIFT);
-	block = byteSub(block,ISBOX);
-	block = addKey(block,key[1]);
-
-	return block;
-end
-
-return AES;
diff --git a/gamemode/shared/fuzzel.lua b/gamemode/shared/fuzzel.lua
deleted file mode 100644
index 6aad45f..0000000
--- a/gamemode/shared/fuzzel.lua
+++ /dev/null
@@ -1,286 +0,0 @@
---[[
-    Fuzzel v1.3 - Alexander "Apickx" Pickering
-    Entered into the public domain June 2, 2016
-    You are not required to, but consider putting a link to the source in your file's comments!
-
-    Some helper functions for calculateing distance between two strings
-
-    Provides:
-        fuzzel.LevenshteinDistance_extended(string_first, string_second, number_addcost, number_substituecost, number_deletecost)
-            Calculates the Levenshtein Distance between two strings, useing the costs given. "Real" Levenshtein Distance uses values 1,1,1 for costs.
-            returns number_distance
-
-        fuzzel.LevenshteinDistance(string_first, strings_second)
-            Calculates the "real" Levenshtein Distance
-            returns number_distance
-
-        fuzzel.LevensteinRatio(string_first, string_second)
-            The Levenshtein Ratio divided by the first string's length. Useing a ratio is a decent way to determin if a spelling is "close enough"
-            returns number_distance
-
-        fuzzel.DamerauLevenshteinDistance_extended(string_first, string_second, number_addcost, number_substituecost, number_deletecost, number_transpositioncost)
-            Damerau-Levenshtein Distance is almost exactly like Levenshtein Distance, with the caveat that two letters next to each other, with swapped positions only counts as "one" cost (in "real" Damerau-Levenshtein Distance)
-            returns number
-
-        fuzzel.DamerauLevenshteinDistance(stirng_first, strings_second)
-            Calculates the "real" Damerau-Levenshtein Distance
-            returns number
-
-        fuzzel.DamerauLevenshteinRatio(string_first, string_second)
-            The Damerau-Levenshtein Distance divided by the first string's length
-            returns number_ratio
-
-        fuzzel.HammingDistance(string_first, string_second)
-            Purely the number of substitutions needed to change one string into another. Note that both strings must be the same length.
-            returns number_distance
-
-        fuzzel.HammingRatio(string_first, string_second)
-            The hamming distance divided by the length of the first string
-            returns number_ratio
-
-        fuzzel.FuzzyFindDistance(string_needle, vararg_in)
-            in may be either a table, or a list of arguments. fuzzel.FuzzySearchDistance will find the string that most closely resembles needle, based on Damerau-Levenshtein Distance. If multiple options have the same distance, it will return the first one encountered (This may not be in any sort of order!)
-            returns string_closest, number_distance
-
-        fuzzel.FuzzyFindRatio(string_needle, vararg_in)
-            in may be either a table, or a list of arguments. Same as above, except it returns the string with the closest Damerau-Levenshtein ratio.
-            returns string_closest, nubmer_ratio
-
-        fuzzel.FuzzySortDistance(string_needle, vararg_in)
-            Sorts either the table, or the arguments, and returns a table. Uses Damerau-Levenshtein Distance
-            returns table_sorted
-
-        fuzzel.FuzzySortRatio(string needle, vararg_in)
-            Same as above, but uses Damerau-Levenshtein Ratio instead
-            returns table_sorted
-
-        fuzzel.FuzzyAutocompleteDistance(string_needle, vararg in)
-            vararg_in can be either a table, or a list of entries, this will fuzzy sort based on the length of the input, which makes it better at autocompletion than fuzzy sorting. Uses Damerau-Levenshtein Distance.
-            returns table_sorted
-
-        fuzzel.FuzzyAutocompleteRatio(string_needle, vararg_in)
-            Same as above, but uses DamerauLevenshteinRatio
-            returns table_sorted
-
-    Example:
-        Returns a function that will return the closest string to the string it was passed
-        -----------------FuzzelExample.lua------------------
-        --Include the module
-        local fuzzel = require("fuzzel.lua")
-
-        --A couple of options
-        local options = {
-            "Fat Cat",
-            "Lazy Dog",
-            "Brown Fox",
-        }
-
-        --And use it, to see what option closest matches "Lulzy Cat"
-        local close,distance = fuzzel.FuzzyFindDistance("Lulzy Cat", options)
-        print("\"Lulzy Cat\" is close to \"" .. close .. "\", distance:" .. distance)
-
-        --Sort the options to see the order in which they most closely match "Frag God"
-        print("\"Frag God\" is closest to:")
-        for k,v in ipairs(fuzzel.FuzzySortRatio("Frag God",options)) do
-            print(k .. "\t:\t" .. v)
-        end
-        -------------End FuzzelExample.lua------------------
-        Outputs:
-            "Lulzy Cat" is close to "Fat Cat"
-            "Frag God" is closest to:
-            1       :       Fat Cat
-            2       :       Lazy Dog
-            3       :       Brown Fox
-
-    Some easy-to-use mnemonics
-        fuzzel.ld_e = fuzzel.LevenshteinDistance_extended
-        fuzzel.ld = fuzzel.LevenshteinDistance
-        fuzzel.lr = fuzzel.LevensteinRatio
-        fuzzel.dld_e = fuzzel.DamerauLevenshteinDistance_extended
-        fuzzel.dld = fuzzel.DamerauLevenshteinDistance
-        fuzzel.dlr = fuzzel.DamerauLevenshteinRatio
-        fuzzel.hd = fuzzel.HammingDistance
-        fuzzel.hr = fuzzel.HammingRatio
-        fuzzel.ffd = fuzzel.FuzzyFindDistance
-        fuzzel.ffr = fuzzel.FuzzyFindRatio
-        fuzzel.fsd = fuzzel.FuzzySortDistance
-        fuzzel.fsr = fuzzel.FuzzySortRatio
-        fuzzel.fad = fuzzel.FuzzyAutocompleteDistance
-        fuzzel.far = fuzzel.FuzzyAutocompleteRatio
-
-]]--You probably don't want to touch anything past this point
-
---Assign locals to these to the minifier can compress the file better
-local strlen,chrat,min,asrt,prs,iprs,typ,upack,tblins,tblsrt,strsub,tru,fal = string.len,string.byte,math.min,assert,pairs,ipairs,type,unpack,table.insert,table.sort,string.sub,true,false
-
-local fuzzel = {}
-
---A clever way to allow the minifier to minify function names, this basically just assigns variables with their string equivalent.
-local da, le, di, ra, fu, fi, so, ex, ha, au = "Damerau", "Levenshtein", "Distance", "Ratio", "Fuzzy", "Find", "Sort", "_extended", "Hamming", "Autocomplete"
-local LevenshteinDistance_extended,LevenshteinDistance,LevenshteinRatio,DamerauLevenshteinDistance_extended,DamerauLevenshteinDistance,DamerauLevenshteinRatio,FuzzyFindDistance,FuzzyFindRatio,FuzzySortDistance,FuzzySortRatio,HammingDistance,HammingRatio,FuzzyAutocompleteDistance,FuzzyAutocompleteRatio = le..di..ex,le..di,le..ra,da..le..di..ex,da..le..di,da..le..ra,fu..fi..di,fu..fi..ra,fu..so..di,fu..so..ra,ha..di,ha..ra,fu..au..di,fu..au..ra
-
-local function genericDistance( stringa, stringb, addcost, subcost, delcost, ...)
-    local arg = {...}
-
-    --Length of each string
-    local salen, sblen = strlen(stringa), strlen(stringb)
-
-    --Create a 0 matrix the size of len(a) x len(b)
-    local dyntbl = {}
-    for i = 0,salen do
-        dyntbl[i] = {}
-        for j = 0,sblen do
-            dyntbl[i][j] = 0
-        end
-    end
-
-    --Initalize the matrix
-    for i = 1,salen do
-        dyntbl[i][0] = i
-    end
-    for j = 1,sblen do
-        dyntbl[0][j] = j
-    end
-
-    --And build up the matrix based on costs-so-far
-    for j = 1,sblen do
-        for i = 1,salen do
-            local ca,cb = chrat(stringa,i),chrat(stringb,j)
-            dyntbl[i][j] = min(
-                dyntbl[i-1][j] + delcost, --deletion
-                dyntbl[i][j-1] + addcost, --insertion
-                dyntbl[i-1][j-1] + (ca == cb and 0 or subcost) --substituion
-            )
-            if arg[1] and i > 1 and j > 1 and ca == chrat(stringb,j-1) and chrat(stringa,i-1) == cb then
-                dyntbl[i][j] = min(dyntbl[i][j],
-                    dyntbl[i-2][j-2] + (ca == cb and 0 or arg[2])) --transposition
-            end
-        end
-    end
-
-    return dyntbl[salen][sblen]
-end
-
-fuzzel[LevenshteinDistance_extended] = function(stringa, stringb, addcost, subcost, delcost)
-    return genericDistance(stringa, stringb, addcost, subcost, delcost)
-end
-fuzzel.ld_e = fuzzel[LevenshteinDistance_extended]
-
-fuzzel[LevenshteinDistance] = function(stringa,stringb)
-    return fuzzel.ld_e(stringa,stringb,1,1,1)
-end
-fuzzel.ld = fuzzel[LevenshteinDistance]
-
-fuzzel[LevenshteinRatio] = function(stringa,stringb)
-    return fuzzel.ld(stringa,stringb) / strlen(stringa)
-end
-fuzzel.lr = fuzzel[LevenshteinRatio]
-
-fuzzel[DamerauLevenshteinDistance_extended] = function(stringa, stringb, addcost, subcost, delcost, trncost)
-    return genericDistance(stringa,stringb,addcost,subcost,delcost,tru,trncost)
-end
-fuzzel.dld_e = fuzzel[DamerauLevenshteinDistance_extended]
-
-fuzzel[DamerauLevenshteinDistance] = function(stringa,stringb)
-    return fuzzel.dld_e(stringa,stringb,1,1,1,1)
-end
-fuzzel.dld = fuzzel[DamerauLevenshteinDistance]
-
-fuzzel[DamerauLevenshteinRatio] = function(stringa,stringb)
-    return fuzzel.dld(stringa,stringb) / strlen(stringa)
-end
-fuzzel.dlr = fuzzel[DamerauLevenshteinRatio]
-
-fuzzel[HammingDistance] = function(stringa,stringb)
-    local len,dist = strlen(stringa),0
-    asrt(len == strlen(stringb), ha.." "..di.." cannot be calculated on two strings of different lengths:\"" .. stringa .. "\" \"" .. stringb .. "\"")
-    for i = 1,len do
-        dist = dist + ((chrat(stringa,i) ~= chrat(stringb,i)) and 1 or 0)
-    end
-    return dist
-end
-fuzzel.hd = fuzzel[HammingDistance]
-
-fuzzel[HammingRatio] = function(stringa,stringb)
-    return fuzzel.hd(stringa,stringb) / strlen(stringa)
-end
-fuzzel.hr = fuzzel[HammingRatio]
-
-local function FuzzySearch(str,func,...)
-    local arg = {...}
-
-    --Allow varargs, or a table
-    local looparg = typ(arg[1]) == "table" and arg[1] or arg
-
-    --Find the string with the shortest distance to the string we were supplied
-    local tmin,sout = func(looparg[1],str),looparg[1]
-    for k,v in prs(looparg) do
-        local t = func(v,str)
-        if t <= tmin then
-            tmin,sout = t,k
-        end
-    end
-    return looparg[sout], tmin
-end
-
-fuzzel[FuzzyFindDistance] = function(str,...)
-    return upack{FuzzySearch(str,fuzzel.dld,...)}
-end
-fuzzel.ffd = fuzzel[FuzzyFindDistance]
-
-fuzzel[FuzzyFindRatio] = function(str,...)
-    return upack{FuzzySearch(str,fuzzel.dlr,...)}
-end
-
-local function FuzzySort(str, func, short, ...)
-    local arg = {...}
-
-    --allow varargs, or a table
-    local looparg = typ(arg[1]) == "table" and arg[1] or arg
-
-    --Roughly sort everything by it's distance to the string
-    local usorted,sorted,otbl,slen = {},{},{},strlen(str)
-    for k,v in prs(looparg) do
-        local sstr = short and strsub(v,0,slen) or v
-        local dist = func(str,sstr)
-        if usorted[dist] == nil then
-            usorted[dist] = {}
-            tblins(sorted,dist)
-        end
-        tblins(usorted[dist],v)
-    end
-
-    --Actually sort them into something can can be iterated with ipairs
-    tblsrt(sorted)
-
-    --Then build our output table
-    for k,v in iprs(sorted) do
-        for i,j in prs(usorted[v]) do
-            tblins(otbl,j)
-        end
-    end
-    return otbl
-end
-fuzzel.ffr = fuzzel[FuzzyFindRatio]
-
-fuzzel[FuzzySortDistance] = function(str,...)
-    return FuzzySort(str,fuzzel.dld,fal,...)
-end
-fuzzel.fsd = fuzzel[FuzzySortDistance]
-
-fuzzel[FuzzySortRatio] = function(str,...)
-    return FuzzySort(str,fuzzel.dlr,fal,...)
-end
-fuzzel.fsr = fuzzel[FuzzySortRatio]
-
-fuzzel[FuzzyAutocompleteDistance] = function(str, ...)
-    return FuzzySort(str,fuzzel.dld,tru,...)
-end
-fuzzel.fad = fuzzel[FuzzyAutocompleteDistance]
-
-fuzzel[FuzzyAutocompleteRatio] = function(str,...)
-    return FuzzySort(str,fuzzel.dlr,tru,...)
-end
-fuzzel.far = fuzzel[FuzzyAutocompleteRatio]
-
-return fuzzel
diff --git a/gamemode/shared/inventory.lua b/gamemode/shared/inventory.lua
index 006a566..f06d053 100644
--- a/gamemode/shared/inventory.lua
+++ b/gamemode/shared/inventory.lua
@@ -1,3 +1,5 @@
+do return end
+
 --[[
     Various functions to work with inventories
     player:GetCredits()
diff --git a/gamemode/shared/inventory_common.lua b/gamemode/shared/inventory_common.lua
index aaf6afb..c5553fe 100644
--- a/gamemode/shared/inventory_common.lua
+++ b/gamemode/shared/inventory_common.lua
@@ -1,6 +1,7 @@
 --[[
     Some functions that are needed multiple places in the code, to deal with player inventories.
 ]]
+do return end
 print("Hello from inventory_common.lua")
 local invfuncs = {}
 
diff --git a/gamemode/shared/itemsystem/exampleitem.lua b/gamemode/shared/itemsystem/exampleitem.lua
index a21def8..066e107 100644
--- a/gamemode/shared/itemsystem/exampleitem.lua
+++ b/gamemode/shared/itemsystem/exampleitem.lua
@@ -82,4 +82,4 @@ end
 
 print("Hello from exampleitem.lua")
 --Don't forget to register the item!
-ART.RegisterItem(item)
+nrequire("item.lua").RegisterItem(item)
diff --git a/gamemode/shared/loadnpcs.lua b/gamemode/shared/loadnpcs.lua
index 3e1861f..2906597 100644
--- a/gamemode/shared/loadnpcs.lua
+++ b/gamemode/shared/loadnpcs.lua
@@ -1,4 +1,4 @@
-
+do return end
 local f = include("concommands.lua")
 
 ART = ART or {}
diff --git a/gamemode/shared/loadprayers.lua b/gamemode/shared/loadprayers.lua
index 3c94b72..01d538c 100644
--- a/gamemode/shared/loadprayers.lua
+++ b/gamemode/shared/loadprayers.lua
@@ -1,6 +1,7 @@
 --[[
     This file loads in all the prayers
 ]]
+do return end
 local concmd = include("concommands.lua")
 --local autolua = include("../autolua.lua")
 print("Hello from LoadItems.lua!")
diff --git a/gamemode/shared/lockbox/array.lua b/gamemode/shared/lockbox/array.lua
deleted file mode 100644
index 8a2fd30..0000000
--- a/gamemode/shared/lockbox/array.lua
+++ /dev/null
@@ -1,210 +0,0 @@
-local String = string
-local Bit = include("bit.lua");
-
-local XOR = Bit.bxor;
-
-local Array = {};
-
-Array.size = function(array)
-	return #array;
-end
-
-Array.fromString = function(string)
-	local bytes = {};
-
-	local i=1;
-	local byte = String.byte(string,i);
-	while byte ~= nil do
-		bytes[i] = byte;
-		i = i + 1;
-		byte = String.byte(string,i);
-	end
-
-	return bytes;
-
-end
-
-Array.toString = function(bytes)
-	local chars = {};
-	local i=1;
-
-	local byte = bytes[i];
-	while byte ~= nil do
-		chars[i] = String.char(byte);
-		i = i+1;
-		byte = bytes[i];
-	end
-
-	return table.concat(chars,"");
-end
-
-Array.fromStream = function(stream)
-	local array = {};
-	local i=1;
-
-	local byte = stream();
-	while byte ~= nil do
-		array[i] = byte;
-		i = i+1;
-		byte = stream();
-	end
-
-	return array;
-end
-
-Array.readFromQueue = function(queue,size)
-	local array = {};
-
-	for i=1,size do
-		array[i] = queue.pop();
-	end
-
-	return array;
-end
-
-Array.writeToQueue = function(queue,array)
-	local size = Array.size(array);
-
-	for i=1,size do
-		queue.push(array[i]);
-	end
-end
-
-Array.toStream = function(array)
-	local queue = Queue();
-	local i=1;
-
-	local byte = array[i];
-	while byte ~= nil do
-		queue.push(byte);
-		i=i+1;
-		byte = array[i];
-	end
-
-	return queue.pop;
-end
-
-
-local fromHexTable = {};
-for i=0,255 do
-	fromHexTable[String.format("%02X",i)]=i;
-	fromHexTable[String.format("%02x",i)]=i;
-end
-
-Array.fromHex = function(hex)
-	local array = {};
-
-	for i=1,String.len(hex)/2 do
-		local h = String.sub(hex,i*2-1,i*2);
-		array[i] = fromHexTable[h];
-	end
-
-	return array;
-end
-
-
-local toHexTable = {};
-for i=0,255 do
-	toHexTable[i]=String.format("%02X",i);
-end
-
-Array.toHex = function(array)
-	local hex = {};
-	local i = 1;
-
-	local byte = array[i];
-	while byte ~= nil do
-		hex[i] = toHexTable[byte];
-		i=i+1;
-		byte = array[i];
-	end
-
-	return table.concat(hex,"");
-
-end
-
-Array.concat = function(a,b)
-	local concat = {};
-	local out=1;
-
-	local i=1;
-	local byte = a[i];
-	while byte ~= nil do
-		concat[out] = byte;
-		i = i + 1;
-		out = out + 1;
-		byte = a[i];
-	end
-
-	local i=1;
-	local byte = b[i];
-	while byte ~= nil do
-		concat[out] = byte;
-		i = i + 1;
-		out = out + 1;
-		byte = b[i];
-	end
-
-	return concat;
-end
-
-Array.truncate = function(a,newSize)
-	local x = {};
-
-	for i=1,newSize do
-		x[i]=a[i];
-	end
-
-	return x;
-end
-
-Array.XOR = function(a,b)
-	local x = {};
-
-	for k,v in pairs(a) do
-		x[k] = XOR(v,b[k]);
-	end
-
-	return x;
-end
-
-Array.substitute = function(input,sbox)
-	local out = {};
-
-	for k,v in pairs(input) do
-		out[k] = sbox[v];
-	end
-
-	return out;
-end
-
-Array.permute = function(input,pbox)
-	local out = {};
-
-	for k,v in pairs(pbox) do
-		out[k] = input[v];
-	end
-
-	return out;
-end
-
-Array.copy = function(input)
-	local out = {};
-
-	for k,v in pairs(input) do
-		out[k] = v;
-	end
-	return out;
-end
-
-Array.slice = function(input,start,stop)
-	local out = {};
-
-	for i=start,stop do
-		out[i-start+1] = input[i];
-	end
-	return out;
-end
-
-
-return Array;
diff --git a/gamemode/shared/lockbox/base64.lua b/gamemode/shared/lockbox/base64.lua
deleted file mode 100644
index 3d9ffc3..0000000
--- a/gamemode/shared/lockbox/base64.lua
+++ /dev/null
@@ -1,157 +0,0 @@
-local String = string
-local Bit = include("bit.lua");
-
-local Array = include("array.lua");
-local Stream = include("stream.lua");
-
-local AND = Bit.band;
-local OR  = Bit.bor;
-local NOT = Bit.bnot;
-local XOR = Bit.bxor;
-local LROT = Bit.lrotate;
-local RROT = Bit.rrotate;
-local LSHIFT = Bit.lshift;
-local RSHIFT = Bit.rshift;
-
-
-local SYMBOLS = {
-[0]="A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P",
-    "Q","R","S","T","U","V","W","X","Y","Z","a","b","c","d","e","f",
-    "g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v",
-    "w","x","y","z","0","1","2","3","4","5","6","7","8","9","+","/"};
-
-local LOOKUP = {};
-
-for k,v in pairs(SYMBOLS) do
-	LOOKUP[k]=v;
-	LOOKUP[v]=k;
-end
-
-
-local Base64 = {};
-
-Base64.fromStream = function(stream)
-	local bits = 0x00;
-	local bitCount = 0;
-	local base64 = {};
-
-	local byte = stream();
-	while byte ~= nil do
-		bits = OR(LSHIFT(bits,8),byte);
-		bitCount = bitCount + 8;
-		while bitCount >= 6 do
-			bitCount = bitCount - 6;
-			local temp = RSHIFT(bits,bitCount);
-			table.insert(base64,LOOKUP[temp]);
-			bits = AND(bits,NOT(LSHIFT(0xFFFFFFFF,bitCount)));
-		end
-		byte = stream();
-	end
-
-	if (bitCount == 4) then
-		bits = LSHIFT(bits,2);
-		table.insert(base64,LOOKUP[bits]);
-		table.insert(base64,"=");
-	elseif (bitCount == 2) then
-		bits = LSHIFT(bits,4);
-		table.insert(base64,LOOKUP[bits]);
-		table.insert(base64,"==");
-	end
-
-	return table.concat(base64,"");
-end
-
-Base64.fromArray = function(array)
-	local bits = 0x00;
-	local bitCount = 0;
-	local base64 = {};
-
-	local ind = 1;
-
-	local byte = array[ind]; ind = ind + 1;
-	while byte ~= nil do
-		bits = OR(LSHIFT(bits,8),byte);
-		bitCount = bitCount + 8;
-		while bitCount >= 6 do
-			bitCount = bitCount - 6;
-			local temp = RSHIFT(bits,bitCount);
-			table.insert(base64,LOOKUP[temp]);
-			bits = AND(bits,NOT(LSHIFT(0xFFFFFFFF,bitCount)));
-		end
-		byte = array[ind]; ind = ind + 1;
-	end
-
-	if (bitCount == 4) then
-		bits = LSHIFT(bits,2);
-		table.insert(base64,LOOKUP[bits]);
-		table.insert(base64,"=");
-	elseif (bitCount == 2) then
-		bits = LSHIFT(bits,4);
-		table.insert(base64,LOOKUP[bits]);
-		table.insert(base64,"==");
-	end
-
-	return table.concat(base64,"");
-end
-
-Base64.fromString = function(string)
-	return Base64.fromArray(Array.fromString(string));
-end
-
-
-
-Base64.toStream = function(base64)
-	return Stream.fromArray(Base64.toArray(base64));
-end
-
-Base64.toArray = function(base64)
-	local bits = 0x00;
-	local bitCount = 0;
-
-	local bytes = {};
-
-	for c in String.gmatch(base64,".") do
-		if (c == "=") then
-			bits = RSHIFT(bits,2); bitCount = bitCount - 2;
-		else
-			bits = LSHIFT(bits,6); bitCount = bitCount + 6;
-			bits = OR(bits,LOOKUP[c]);
-		end
-
-		while(bitCount >= 8) do
-			bitCount = bitCount - 8;
-			local temp = RSHIFT(bits,bitCount);
-			table.insert(bytes,temp);
-			bits = AND(bits,NOT(LSHIFT(0xFFFFFFFF,bitCount)));
-		end
-	end
-
-	return bytes;
-end
-
-Base64.toString = function(base64)
-	local bits = 0x00;
-	local bitCount = 0;
-
-	local chars = {};
-
-	for c in String.gmatch(base64,".") do
-		if (c == "=") then
-			bits = RSHIFT(bits,2); bitCount = bitCount - 2;
-		else
-			bits = LSHIFT(bits,6); bitCount = bitCount + 6;
-			bits = OR(bits,LOOKUP[c]);
-		end
-
-		while(bitCount >= 8) do
-			bitCount = bitCount - 8;
-			local temp = RSHIFT(bits,bitCount);
-			table.insert(chars,String.char(temp));
-			bits = AND(bits,NOT(LSHIFT(0xFFFFFFFF,bitCount)));
-		end
-	end
-
-	return table.concat(chars,"");
-end
-
-return Base64;
diff --git a/gamemode/shared/lockbox/bit.lua b/gamemode/shared/lockbox/bit.lua
deleted file mode 100644
index 0ccdb82..0000000
--- a/gamemode/shared/lockbox/bit.lua
+++ /dev/null
@@ -1,11 +0,0 @@
-local e = bit
-
--- Workaround to support Lua 5.2 bit32 API with the LuaJIT bit one
-if e.rol and not e.lrotate then
-	e.lrotate = e.rol
-end
-if e.ror and not e.rrotate then
-	e.rrotate = e.ror
-end
-
-return bit
diff --git a/gamemode/shared/lockbox/ecb.lua b/gamemode/shared/lockbox/ecb.lua
deleted file mode 100644
index 67f4514..0000000
--- a/gamemode/shared/lockbox/ecb.lua
+++ /dev/null
@@ -1,191 +0,0 @@
-local Array = include("array.lua");
-local Stream = include("stream.lua");
-local Queue = include("queue.lua");
-
-local Bit = include("bit.lua");
-
-local CBC = {};
-
-CBC.Cipher = function()
-
-	local public = {};
-
-	local key;
-	local blockCipher;
-	local padding;
-	local inputQueue;
-	local outputQueue;
-	local iv;
-
-	public.setKey = function(keyBytes)
-		print("Set key to:")
-		print(keyBytes)
-		key = keyBytes;
-		return public;
-	end
-
-	public.setBlockCipher = function(cipher)
-		blockCipher = cipher;
-		return public;
-	end
-
-	public.setPadding = function(paddingMode)
-		padding = paddingMode;
-		return public;
-	end
-
-	public.init = function()
-		inputQueue = Queue();
-		outputQueue = Queue();
-		iv = nil;
-		return public;
-	end
-
-	public.update = function(messageStream)
-		print("Entering update")
-		local byte = messageStream();
-		while (byte ~= nil) do
-			print("processing byte")
-			inputQueue.push(byte);
-			print("inputQueue.size is:" .. inputQueue.size())
-			print("blockCipher.blockSize:" .. blockCipher.blockSize)
-			if(inputQueue.size() >= blockCipher.blockSize) then
-				print("reading from queue")
-				local block = Array.readFromQueue(inputQueue,blockCipher.blockSize);
-				if(iv == nil) then
-					print("iv was nil, iv is now")
-					iv = block;
-					PrintTable(block)
-				else
-					print("iv was not nil, doing thing")
-					local out = Array.XOR(iv,block);
-					print("Calling encrypt with key:")
-					print(key)
-					print("and out")
-					print(out)
-					out = blockCipher.encrypt(key,out);
-					print("Out was:")
-					print(out)
-					Array.writeToQueue(outputQueue,out);
-					iv = out;
-				end
-			end
-			byte = messageStream();
-		end
-		print("Before update returned, blockCipher was ")
-		PrintTable(blockCipher)
-		return public;
-	end
-
-	public.finish = function()
-		paddingStream = padding(blockCipher.blockSize,inputQueue.getHead());
-		public.update(paddingStream);
-
-		return public;
-	end
-
-	public.getOutputQueue = function()
-		return outputQueue;
-	end
-
-	public.asHex = function()
-        print("Outputqueue is:")
-        PrintTable(outputQueue)
-		return Stream.toHex(outputQueue.pop);
-	end
-
-	public.asBytes = function()
-		return Stream.toArray(outputQueue.pop);
-	end
-
-	return public;
-
-end
-
-
-CBC.Decipher = function()
-
-	local public = {};
-
-	local key;
-	local blockCipher;
-	local padding;
-	local inputQueue;
-	local outputQueue;
-	local iv;
-
-	public.setKey = function(keyBytes)
-		key = keyBytes;
-		return public;
-	end
-
-	public.setBlockCipher = function(cipher)
-		blockCipher = cipher;
-		return public;
-	end
-
-	public.setPadding = function(paddingMode)
-		padding = paddingMode;
-		return public;
-	end
-
-	public.init = function()
-		inputQueue = Queue();
-		outputQueue = Queue();
-		iv = nil;
-		return public;
-	end
-
-	public.update = function(messageStream)
-		print("Updateing decipher with messagestream")
-		local byte = messageStream();
-		while (byte ~= nil) do
-			inputQueue.push(byte);
-			if(inputQueue.size() >= blockCipher.blockSize) then
-				local block = Array.readFromQueue(inputQueue,blockCipher.blockSize);
-
-				if(iv == nil) then
-					iv = block;
-					print("Setting iv to ")
-					PrintTable(iv)
-				else
-					local out = block;
-					out = blockCipher.decrypt(key,out);
-					out = Array.XOR(iv,out);
-					Array.writeToQueue(outputQueue,out);
-					iv = block;
-				end
-			end
-			byte = messageStream();
-		end
-		return public;
-	end
-
-	public.finish = function()
-		paddingStream = padding(blockCipher.blockSize,inputQueue.getHead());
-		public.update(paddingStream);
-
-		return public;
-	end
-
-	public.getOutputQueue = function()
-		return outputQueue;
-	end
-
-	public.asHex = function()
-		return Stream.toHex(outputQueue.pop);
-	end
-
-	public.asBytes = function()
-		return Stream.toArray(outputQueue.pop);
-	end
-
-	public.asString = function()
-		return Stream.toString(outputQueue.pop)
-	end
-
-	return public;
-
-end
-
-return CBC;
diff --git a/gamemode/shared/lockbox/padding.lua b/gamemode/shared/lockbox/padding.lua
deleted file mode 100644
index 72be077..0000000
--- a/gamemode/shared/lockbox/padding.lua
+++ /dev/null
@@ -1,21 +0,0 @@
-local Stream = include("stream.lua");
-
-local ZeroPadding = function(blockSize,byteCount)
-
-	local paddingCount = blockSize - ((byteCount -1) % blockSize) + 1;
-	local bytesLeft = paddingCount;
-
-	local stream = function()
-		if bytesLeft > 0 then
-			bytesLeft = bytesLeft - 1;
-			return 0x00;
-		else
-			return nil;
-		end
-	end
-
-	return stream;
-
-end
-
-return ZeroPadding;
diff --git a/gamemode/shared/lockbox/queue.lua b/gamemode/shared/lockbox/queue.lua
deleted file mode 100644
index 55b067d..0000000
--- a/gamemode/shared/lockbox/queue.lua
+++ /dev/null
@@ -1,47 +0,0 @@
-local Queue = function()
-	local queue = {};
-	local tail = 0;
-	local head = 0;
-
-	local public = {};
-
-	public.push = function(obj)
-		queue[head] = obj;
-		head = head + 1;
-		return;
-	end
-
-	public.pop = function()
-		if tail < head
-		then
-			local obj = queue[tail];
-			queue[tail] = nil;
-			tail = tail + 1;
-			return obj;
-		else
-			return nil;
-		end
-	end
-
-	public.size = function()
-		return head - tail;
-	end
-
-	public.getHead = function()
-		return head;
-	end
-
-	public.getTail = function()
-		return tail;
-	end
-
-	public.reset = function()
-		queue = {};
-		head = 0;
-		tail = 0;
-	end
-
-	return public;
-end
-
-return Queue;
diff --git a/gamemode/shared/lockbox/stream.lua b/gamemode/shared/lockbox/stream.lua
deleted file mode 100644
index aeb3b18..0000000
--- a/gamemode/shared/lockbox/stream.lua
+++ /dev/null
@@ -1,112 +0,0 @@
-local Queue = include("queue.lua");
-local String = string
-
-local Stream = {};
-
-
-Stream.fromString = function(string)
-	local i=0;
-	return function()
-		print("string is:" .. string)
-		print("len is:" .. string.len(string))
-		print("i is:" .. i)
-		i=i+1;
-		if(i <= string.len(string)) then
-			return string.byte(string,i);
-		else
-			return nil;
-		end
-	end
-end
-
-
-Stream.toString = function(stream)
-	local array = {};
-	local i=1;
-
-	local byte = stream();
-	while byte ~= nil do
-		array[i] = String.char(byte);
-		i = i+1;
-		byte = stream();
-	end
-
-	return table.concat(array,"");
-end
-
-
-Stream.fromArray = function(array)
-	local queue = Queue();
-	local i=1;
-
-	local byte = array[i];
-	while byte ~= nil do
-		queue.push(byte);
-		i=i+1;
-		byte = array[i];
-	end
-
-	return queue.pop;
-end
-
-
-Stream.toArray = function(stream)
-	local array = {};
-	local i=1;
-
-	local byte = stream();
-	while byte ~= nil do
-		array[i] = byte;
-		i = i+1;
-		byte = stream();
-	end
-
-	return array;
-end
-
-
-local fromHexTable = {};
-for i=0,255 do
-	fromHexTable[String.format("%02X",i)]=i;
-	fromHexTable[String.format("%02x",i)]=i;
-end
-
-Stream.fromHex = function(hex)
-	local queue = Queue();
-
-	for i=1,String.len(hex)/2 do
-		local h = String.sub(hex,i*2-1,i*2);
-		queue.push(fromHexTable[h]);
-	end
-
-	return queue.pop;
-end
-
-
-
-local toHexTable = {};
-for i=0,255 do
-	toHexTable[i]=String.format("%02X",i);
-end
-
-Stream.toHex = function(stream)
-	print("tohex called with stream")
-	print(stream)
-	local hex = {};
-	local i = 1;
-
-	local byte = stream();
-	print("First byte is")
-	print(byte)
-	while byte ~= nil do
-		print("Createing hex:")
-		print(table.concat(hex,""))
-		hex[i] = toHexTable[byte];
-		i=i+1;
-		byte = stream();
-	end
-
-	return table.concat(hex,"");
-end
-
-return Stream;
diff --git a/gamemode/shared/log.lua b/gamemode/shared/log.lua
new file mode 100644
index 0000000..63d3e0e
--- /dev/null
+++ b/gamemode/shared/log.lua
@@ -0,0 +1,23 @@
+
+local fn = nrequire("fn.lua")
+local col = nrequire("colortheme.lua")
+local log = {}
+
+log.debug = fn.curry(
+                     fn.curry(
+                              MsgC,
+                              col.console.cyan),
+                     fn.curry(
+                              string.format,
+                              "[DEBUG] %s"))
+
+log.warn = fn.compose(
+                      fn.curry(
+                               MsgC,
+                               col.console.yellow),
+                      debug.traceback,
+                      fn.curry(
+                               ErrorNoHalt,
+                               "[WARNING]"))
+
+return log