namespace Holo.Managers
{
    using Holo;
    using Ion.Storage;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Data;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Threading;

    public static class catalogueManager
    {
        private static Dictionary<int, string> CatalogueNames;
        private static Hashtable cataloguePages;
        private static Hashtable itemCache;
        private static Hashtable PageCache = new Hashtable();

        private static void cachePage(int pageID)
        {
            DataRow dRow;
            DatabaseClient dbClient;
            using (dbClient = Eucalypt.dbManager.GetClient())
            {
                dRow = dbClient.getRow("SELECT indexname,minrank,displayname,style_layout,img_header,img_side,label_description,label_misc,label_moredetails,page_brother,content_else,header_else FROM catalogue_pages WHERE indexid = '" + pageID + "'");
            }
            if ((pageID <= 0) || (dRow.Table.Rows.Count != 0))
            {
                DataTable dTable;
                object[] pageObject = dRow.ItemArray;
                string[] pageData = new string[pageObject.Length];
                for (int a = 0; a < pageData.Length; a++)
                {
                    pageData[a] = pageObject[a].ToString();
                }
                string pageIndexName = "";
                StringBuilder pageBuilder = new StringBuilder();
                cataloguePage objPage = new cataloguePage();
                if (pageID > 0)
                {
                    pageIndexName = pageData[0];
                    objPage.displayName = pageData[2];
                    objPage.minRank = Convert.ToByte(bool.Parse(pageData[1]));
                    if (pageData[10] != "")
                    {
                        pageBuilder.Append(pageData[10]);
                        objPage.pageData = pageBuilder.ToString();
                        cataloguePages.Add(pageIndexName, objPage);
                        return;
                    }
                    if (pageData[11] != "")
                    {
                        pageBuilder.Append(pageData[11]);
                    }
                    else
                    {
                        pageBuilder.Append(pageData[3] + Convert.ToChar(2));
                        if (pageData[4] != "")
                        {
                            pageBuilder.Append("K" + pageData[4] + Convert.ToChar(2));
                        }
                        if (pageData[5] != "")
                        {
                            pageBuilder.Append(pageData[5] + Convert.ToChar(2) + Convert.ToChar(2));
                        }
                        if (pageData[6] != "")
                        {
                            pageBuilder.Append("K" + pageData[6].Replace("<br>", Convert.ToString(Convert.ToChar(13))) + Convert.ToChar(2));
                        }
                        if (pageData[7] != "")
                        {
                            pageBuilder.Append(pageData[8].Replace("<br>", Convert.ToString(Convert.ToChar(13))) + Convert.ToChar(2));
                        }
                        pageBuilder.Append(pageData[7].Replace("<br>", Convert.ToString(Convert.ToChar(13))) + Convert.ToChar(2));
                        if (pageData[9] != "")
                        {
                            string[] miscDetail = pageData[9].Split(new char[] { Convert.ToChar(2) });
                            for (int m = 0; m < miscDetail.Length; m++)
                            {
                                pageBuilder.Append(miscDetail[m].Replace("<br>", Convert.ToString(Convert.ToChar(13))) + Convert.ToChar(2));
                            }
                        }
                    }
                }
                using (dbClient = Eucalypt.dbManager.GetClient())
                {
                    dTable = dbClient.getTable("SELECT tid, typeid, catalogue_cost_credits, catalogue_cost_pixels, door, tradeable, recycleable, name_cct, top, status_max, next_to_required, rights_required, drink_ids FROM catalogue_items WHERE catalogue_id_page = '" + pageID + "' ORDER BY catalogue_id_index ASC");
                }
                int count = dTable.Rows.Count;
                int[] itemTemplateIDs = new int[count];
                int[] itemTypeIDs = new int[count];
                int[] itemLengths = new int[count];
                int[] itemWidths = new int[count];
                int[] itemCosts_Credits = new int[count];
                int[] itemCosts_Pixels = new int[count];
                int[] itemDoorFlags = new int[count];
                int[] itemTradeableFlags = new int[count];
                int[] itemRecycleableFlags = new int[count];
                int[] statusMax = new int[count];
                int[] nexttoRequired = new int[count];
                int[] rightsRequired = new int[count];
                string[] strPoster = new string[count];
                string[] itemNames = new string[count];
                string[] itemDescs = new string[count];
                string[] itemCCTs = new string[count];
                string[] itemTopHs = new string[count];
                string[] itemDrinks = new string[count];
                int[] itemID = new int[count];
                int i = 0;
                foreach (DataRow dbRow in dTable.Rows)
                {
                    itemTemplateIDs[i] = Convert.ToInt32(dbRow["tid"]);
                    itemTypeIDs[i] = Convert.ToInt32(dbRow["typeid"]);
                    itemCosts_Credits[i] = Convert.ToInt32(dbRow["catalogue_cost_credits"]);
                    itemCosts_Pixels[i] = Convert.ToInt32(dbRow["catalogue_cost_pixels"]);
                    itemDoorFlags[i] = Convert.ToInt32(dbRow["door"]);
                    itemTradeableFlags[i] = Convert.ToInt32(dbRow["tradeable"]);
                    itemRecycleableFlags[i] = Convert.ToInt32(dbRow["recycleable"]);
                    itemCCTs[i] = Convert.ToString(dbRow["name_cct"]);
                    itemTopHs[i] = Convert.ToString(dbRow["top"]);
                    statusMax[i] = Convert.ToInt32(dbRow["status_max"]);
                    nexttoRequired[i] = Convert.ToInt32(dbRow["next_to_required"]);
                    rightsRequired[i] = Convert.ToInt32(dbRow["rights_required"]);
                    itemDrinks[i] = Convert.ToString(dbRow["drink_ids"]);
                    string[] nameCheck = itemCCTs[i].Split(new char[] { ' ' });
                    using (dbClient = Eucalypt.dbManager.GetClient())
                    {
                        strPoster[i] = "";
                        if (itemCCTs[i].Contains("wallpaper "))
                        {
                            strPoster[i] = itemCCTs[i].Replace("wallpaper ", "");
                            itemCCTs[i] = "wallpaper";
                        }
                        else if (itemCCTs[i].Contains("landscape "))
                        {
                            strPoster[i] = itemCCTs[i].Replace("landscape ", "");
                            itemCCTs[i] = "landscape";
                        }
                        if (nameCheck[0] == "poster ")
                        {
                            itemCCTs[i] = nameCheck[0];
                            strPoster[i] = nameCheck[1];
                        }
                        itemID[i] = itemTemplateIDs[i];
                        if (itemCCTs[i] == "wallpaper")
                        {
                            itemCCTs[i] = "wallpaper " + strPoster[i];
                        }
                        else if (itemCCTs[i] == "poster")
                        {
                            string[] CS$0$0003;
                            IntPtr CS$0$0004;
                            (CS$0$0003 = itemCCTs)[(int) (CS$0$0004 = (IntPtr) i)] = CS$0$0003[(int) CS$0$0004] + " " + nameCheck[1];
                        }
                        else if (itemCCTs[i] == "landscape")
                        {
                            itemCCTs[i] = "landscape " + strPoster[i];
                        }
                        if (itemCCTs[i].Contains("avatar_effect"))
                        {
                            itemLengths[i] = 0;
                            itemWidths[i] = 0;
                        }
                        else
                        {
                            string itemWidth = dbClient.getString("SELECT width FROM dynamic_items WHERE name_cct = '" + itemCCTs[i].Split(new char[] { ' ' })[0] + "'");
                            string itemLength = dbClient.getString("SELECT length FROM dynamic_items WHERE name_cct = '" + itemCCTs[i].Split(new char[] { ' ' })[0] + "'");
                            if (itemWidth == "")
                            {
                                itemWidth = Convert.ToString(0);
                            }
                            if (itemLength == "")
                            {
                                itemLength = Convert.ToString(0);
                            }
                            itemLengths[i] = Convert.ToInt32(itemLength);
                            itemWidths[i] = Convert.ToInt32(itemWidth);
                        }
                    }
                    i++;
                }
                pageBuilder.Append(Encoding.encodeVL64(dTable.Rows.Count));
                for (i = 0; i < itemTemplateIDs.Length; i++)
                {
                    if (Config.enableHappyHour)
                    {
                        itemCosts_Credits[i] = 0;
                        if (itemCosts_Pixels[i] > 0)
                        {
                            itemCosts_Credits[i] = 1;
                        }
                        itemCosts_Pixels[i] /= 2;
                    }
                    if (stringManager.getStringPart(itemCCTs[i], 0, 4) != "deal")
                    {
                        itemCache.Add(itemTemplateIDs[i], new itemTemplate(itemCCTs[i], Convert.ToByte(itemTypeIDs[i]), itemLengths[i], itemWidths[i], double.Parse(itemTopHs[i]), itemDoorFlags[i] == 1, itemTradeableFlags[i] == 1, itemRecycleableFlags[i] == 1, statusMax[i], nexttoRequired[i], rightsRequired[i], itemDrinks[i], itemID[i]));
                        if (pageID != -1)
                        {
                            pageBuilder.Append(string.Concat(new object[] { Encoding.encodeVL64(itemTemplateIDs[i]), itemCCTs[i], Convert.ToChar(2), Encoding.encodeVL64(itemCosts_Credits[i]), Encoding.encodeVL64(itemCosts_Pixels[i]), "I" }));
                            if (itemTypeIDs[i] == 0)
                            {
                                pageBuilder.Append("i");
                            }
                            else if (itemCCTs[i].Contains("avatar_effect"))
                            {
                                pageBuilder.Append("e");
                            }
                            else
                            {
                                pageBuilder.Append("s");
                            }
                            if (itemCCTs[i].Contains("avatar_effect"))
                            {
                                pageBuilder.Append(string.Concat(new object[] { Convert.ToChar(2), Encoding.encodeVL64(int.Parse(itemCCTs[i].Replace("avatar_effect", ""))), Convert.ToChar(2), "IPO" }));
                            }
                            else
                            {
                                string custInformation = "";
                                if (itemCCTs[i].Contains(" "))
                                {
                                    custInformation = itemCCTs[i].Split(new char[] { ' ' })[1];
                                }
                                pageBuilder.Append(string.Concat(new object[] { Convert.ToChar(2), Encoding.encodeVL64(itemID[i]), custInformation, Convert.ToChar(2), "IM" }));
                            }
                        }
                    }
                }
                if (pageID != -1)
                {
                    objPage.pageData = pageBuilder.ToString();
                    cataloguePages.Add(pageIndexName, objPage);
                }
            }
        }

        public static void CachePages()
        {
            for (int i = 1; i < 8; i++)
            {
                PageCache.Add(i, getDynamicPageIndex(i));
            }
            Out.WriteLine("Catalogue cached");
        }

        private static string getDynamicPageIndex(int userRank)
        {
            string CS$1$0000;
            try
            {
                StringBuilder listBuilder = new StringBuilder();
                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                {
                    string[] pageNames = dataHandling.dColToArray(dbClient.getColumn("SELECT indexname FROM catalogue_categories WHERE minrank <= '" + userRank + "' ORDER BY indexid ASC"));
                    int catIcon = 0;
                    int catColour = 0;
                    int catID = 0;
                    int catContent = 0;
                    int catCount = 0;
                    int subcatCount = 0;
                    int lstID = 0;
                    bool catNull = true;
                    string lstName = "";
                    string catContent_add = "";
                    catCount = dbClient.getInt("SELECT COUNT(indexname) FROM catalogue_categories WHERE minrank <= '" + userRank + "'");
                    for (int i = 0; i < pageNames.Length; i++)
                    {
                        if (catNull)
                        {
                            listBuilder.Append(Encoding.encodeVL64(0));
                        }
                        catNull = true;
                        catIcon = dbClient.getInt("SELECT icon FROM catalogue_categories WHERE indexname = '" + pageNames[i] + "' LIMIT 1");
                        catIcon = dbClient.getInt("SELECT icon FROM catalogue_categories WHERE indexname = '" + pageNames[i] + "' LIMIT 1");
                        catColour = dbClient.getInt("SELECT colour FROM catalogue_categories WHERE indexname = '" + pageNames[i] + "' LIMIT 1");
                        catID = dbClient.getInt("SELECT indexid FROM catalogue_categories WHERE indexname = '" + pageNames[i] + "' LIMIT 1");
                        catContent = dbClient.getInt("SELECT content FROM catalogue_categories WHERE indexname = '" + pageNames[i] + "' LIMIT 1");
                        subcatCount = dbClient.getInt(string.Concat(new object[] { "SELECT COUNT(indexid) FROM catalogue_pages WHERE incategory = '", catID, "' AND minrank <= '", userRank, "'" }));
                        if (catCount != 0)
                        {
                            listBuilder.Append(Encoding.encodeVL64(catCount));
                            catCount = 0;
                        }
                        if (catContent == 0)
                        {
                            catContent_add = "M";
                        }
                        else
                        {
                            catContent_add = Encoding.encodeVL64(catContent);
                        }
                        if (subcatCount == 0)
                        {
                            listBuilder.Append(string.Concat(new object[] { Encoding.encodeVL64(1), Encoding.encodeVL64(catColour), Encoding.encodeVL64(catIcon), catContent_add, pageNames[i], Convert.ToChar(2), Encoding.encodeVL64(0) }));
                        }
                        else
                        {
                            listBuilder.Append(string.Concat(new object[] { Encoding.encodeVL64(1), Encoding.encodeVL64(catColour), Encoding.encodeVL64(catIcon), catContent_add, pageNames[i], Convert.ToChar(2), Encoding.encodeVL64(0), Encoding.encodeVL64(subcatCount) }));
                        }
                        if (subcatCount != 0)
                        {
                            string[] catNames = dataHandling.dColToArray(dbClient.getColumn(string.Concat(new object[] { "SELECT indexname FROM catalogue_pages WHERE incategory = '", catID, "' AND minrank <= '", userRank, "' ORDER BY indexid ASC" })));
                            for (int b = 0; b < catNames.Length; b++)
                            {
                                if (catNames[b] != "")
                                {
                                    lstID = dbClient.getInt("SELECT indexid FROM catalogue_pages WHERE indexname = '" + catNames[b] + "' LIMIT 1");
                                    lstName = dbClient.getString("SELECT displayname FROM catalogue_pages WHERE indexname = '" + catNames[b] + "' LIMIT 1");
                                    int styleColour = dbClient.getInt("SELECT style_colour FROM catalogue_pages WHERE indexname = '" + catNames[b] + "' LIMIT 1");
                                    int styleIcon = dbClient.getInt("SELECT style_icon FROM catalogue_pages WHERE indexname = '" + catNames[b] + "' LIMIT 1");
                                    listBuilder.Append("I" + Encoding.encodeVL64(styleColour) + Encoding.encodeVL64(styleIcon) + Encoding.encodeVL64(lstID) + lstName);
                                }
                                listBuilder.Append(Convert.ToChar(2) + "HH");
                            }
                            catNull = false;
                        }
                    }
                    CS$1$0000 = listBuilder.ToString();
                }
            }
            catch
            {
                CS$1$0000 = Convert.ToChar(2).ToString();
            }
            return CS$1$0000;
        }

        public static string getPage(string pageName, byte userRank)
        {
            try
            {
                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                {
                    pageName = dbClient.getString("SELECT indexname FROM catalogue_pages WHERE indexid = '" + Encoding.decodeVL64(pageName) + "'");
                }
                cataloguePage objPage = (cataloguePage) cataloguePages[pageName];
                if (userRank < objPage.minRank)
                {
                    return "";
                }
                return objPage.pageData;
            }
            catch
            {
                return "";
            }
        }

        public static bool getPageExists(string pageName)
        {
            return cataloguePages.ContainsKey(cataloguePages.ContainsKey(pageName));
        }

        public static string getPageIndex(int Rank)
        {
            return (string) PageCache[Rank];
        }

        public static itemTemplate getTemplate(int templateID)
        {
            try
            {
                return (itemTemplate) itemCache[templateID];
            }
            catch
            {
                return new itemTemplate();
            }
        }

        public static void handlePurchase(int templateID, int receiverID, int roomID, string decorID, int presentBoxID, int teleportID1)
        {
            int itemID;
            DatabaseClient dbClient;
            string Sprite = getTemplate(templateID).Sprite;
            bool handlePresentbox = true;
            int FurnitureType = 0;
            switch (Sprite)
            {
                case "landscape":
                case "wallpaper":
                case "floor":
                    FurnitureType = 1;
                    break;
            }
            if (Sprite == "roomdimmer")
            {
                FurnitureType = 2;
            }
            if (Sprite.Contains("post.it"))
            {
                FurnitureType = 4;
            }
            if (getTemplate(templateID).maxStatus == -1)
            {
                FurnitureType = 3;
            }
            switch (FurnitureType)
            {
                case 1:
                    itemID = lastItemID;
                    using (dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dbClient.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", decorID, "' WHERE id = '", itemID, "' LIMIT 1" }));
                    }
                    break;

                case 2:
                {
                    itemID = lastItemID;
                    string defaultPreset = "1,#000000,155";
                    string defaultSetPreset = "1,1,1,#000000,155";
                    using (dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dbClient.runQuery(string.Concat(new object[] { "INSERT INTO furniture_moodlight(id,roomid,preset_cur,preset_1,preset_2,preset_3) VALUES ('", itemID, "','0','1','", defaultPreset, "','", defaultPreset, "','", defaultPreset, "')" }));
                        dbClient.runQuery(string.Concat(new object[] { "UPDATE furniture SET var = '", defaultSetPreset, "' WHERE id = '", itemID, "' LIMIT 1" }));
                    }
                    break;
                }
                case 3:
                {
                    int itemID1 = teleportID1;
                    using (dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dbClient.runQuery(string.Concat(new object[] { "INSERT INTO furniture(tid,ownerid,roomid,teleportid) VALUES ('", templateID, "','", receiverID, "','", roomID, "','", itemID1, "')" }));
                        int itemID2 = lastItemID;
                        dbClient.runQuery(string.Concat(new object[] { "UPDATE furniture SET teleportid = '", itemID2, "' WHERE id = '", itemID1, "' LIMIT 1" }));
                        if (presentBoxID > 0)
                        {
                            dbClient.runQuery(string.Concat(new object[] { "INSERT INTO furniture_presents(id,itemid) VALUES ('", presentBoxID, "','", itemID1, "')" }));
                            dbClient.runQuery(string.Concat(new object[] { "INSERT INTO furniture_presents(id,itemid) VALUES ('", presentBoxID, "','", itemID2, "')" }));
                        }
                    }
                    handlePresentbox = false;
                    break;
                }
                case 4:
                    itemID = lastItemID;
                    using (dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dbClient.runQuery("UPDATE furniture SET var = '20' WHERE id = '" + itemID + "' LIMIT 1");
                    }
                    break;

                default:
                    if (stringManager.getStringPart(Sprite, 0, 10) == "sound_set_")
                    {
                        itemID = lastItemID;
                        int soundSet = int.Parse(Sprite.Substring(10));
                        using (dbClient = Eucalypt.dbManager.GetClient())
                        {
                            dbClient.runQuery(string.Concat(new object[] { "UPDATE furniture SET soundmachine_soundset = '", soundSet, "' WHERE id = '", itemID, "' LIMIT 1" }));
                        }
                    }
                    break;
            }
            if ((presentBoxID > 0) && handlePresentbox)
            {
                using (dbClient = Eucalypt.dbManager.GetClient())
                {
                    dbClient.runQuery(string.Concat(new object[] { "INSERT INTO furniture_presents(id,itemid) VALUES ('", presentBoxID, "','", lastItemID, "')" }));
                }
            }
        }

        public static void Init(bool Update)
        {
            DataTable dCol;
            using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
            {
                dCol = dbClient.getTable("SELECT indexid, indexname FROM catalogue_pages ORDER BY indexid");
            }
            cataloguePages = new Hashtable();
            itemCache = new Hashtable();
            CatalogueNames = new Dictionary<int, string>();
            foreach (DataRow dRow in dCol.Rows)
            {
                int ID = Convert.ToInt32(dRow["indexid"]);
                CatalogueNames.Add(ID, Convert.ToString(dRow["indexname"]));
                cachePage(ID);
            }
            cachePage(Convert.ToInt32(-1));
            Out.WriteLine(string.Concat(new object[] { "Successfully cached ", cataloguePages.Count, " catalogue pages and ", itemCache.Count, " item templates!" }));
            CachePages();
            if (Update)
            {
                Thread.CurrentThread.Abort();
            }
        }

        public static string tradeItemList(int[] itemIDs)
        {
            StringBuilder List = new StringBuilder();
            int countFurnitures = 0;
            string containItem = "";
            for (int i = 0; i < itemIDs.Length; i++)
            {
                if (!containItem.Contains("<" + itemIDs[i] + ">") && (itemIDs[i] != 0))
                {
                    DataRow dRow;
                    using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                    {
                        dRow = dbClient.getRow("SELECT tid, var FROM furniture WHERE id = '" + itemIDs[i] + "'");
                    }
                    int templateID = Convert.ToInt32(dRow["tid"]);
                    itemTemplate Template = getTemplate(templateID);
                    int useVar = 0;
                    if (Template.Sprite == "poster")
                    {
                        useVar = int.Parse(Template.Colour);
                    }
                    if ((Template.Sprite == "post.it") || (Template.Sprite == "post.it.vd"))
                    {
                        useVar = Convert.ToInt32(dRow["var"]);
                    }
                    if (Template.typeID == 0)
                    {
                        List.Append(string.Concat(new object[] { Encoding.encodeVL64(itemIDs[i]), "i\x0002", Encoding.encodeVL64(itemIDs[i]), Encoding.encodeVL64(templateID), useVar, "\x0002HHH" }));
                    }
                    else
                    {
                        List.Append(Encoding.encodeVL64(itemIDs[i]) + "s\x0002" + Encoding.encodeVL64(itemIDs[i]) + Encoding.encodeVL64(templateID) + "K\x0002RDPAYvGM");
                    }
                    object CS$0$0004 = containItem;
                    containItem = string.Concat(new object[] { CS$0$0004, "<", itemIDs[i], ">" });
                    countFurnitures++;
                }
            }
            return (Encoding.encodeVL64(countFurnitures) + List.ToString());
        }

        public static string wallPositionOK(string wallPosition)
        {
            try
            {
                string[] posD = wallPosition.Split(new char[] { ' ' });
                if ((posD[2] != "l") && (posD[2] != "r"))
                {
                    return "";
                }
                string[] widD = posD[0].Substring(3).Split(new char[] { ',' });
                int widthX = int.Parse(widD[0]);
                int widthY = int.Parse(widD[1]);
                if ((((widthX < 0) || (widthY < 0)) || (widthX > 200)) || (widthY > 200))
                {
                    return "";
                }
                string[] lenD = posD[1].Substring(2).Split(new char[] { ',' });
                int lengthX = int.Parse(lenD[0]);
                int lengthY = int.Parse(lenD[1]);
                if ((((lengthX < 0) || (lengthY < 0)) || (lengthX > 200)) || (lengthY > 200))
                {
                    return "";
                }
                return string.Concat(new object[] { ":w=", widthX, ",", widthY, " l=", lengthX, ",", lengthY, " ", posD[2] });
            }
            catch
            {
                return "";
            }
        }

        public static int lastItemID
        {
            get
            {
                using (DatabaseClient dbClient = Eucalypt.dbManager.GetClient())
                {
                    return dbClient.getInt("SELECT MAX(id) FROM furniture");
                }
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct cataloguePage
        {
            internal string displayName;
            internal string pageData;
            internal byte minRank;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct itemTemplate
        {
            internal byte typeID;
            internal string Sprite;
            internal string Colour;
            internal int Length;
            internal int Width;
            internal double topH;
            internal bool isDoor;
            internal bool isTradeable;
            internal bool isRecycleable;
            internal int maxStatus;
            internal int rightsRequired;
            internal int nexttoRequired;
            internal string drinkIDs;
            internal int indexID;
            public itemTemplate(bool b)
            {
                this.typeID = 1;
                this.Sprite = "";
                this.Colour = "null";
                this.Length = 1;
                this.Width = 1;
                this.topH = 0.0;
                this.isDoor = false;
                this.isTradeable = true;
                this.isRecycleable = false;
                this.maxStatus = 1;
                this.nexttoRequired = 0;
                this.rightsRequired = 1;
                this.indexID = 0;
                this.drinkIDs = "";
            }

            public itemTemplate(string Sprite, byte typeID, int Length, int Width, double topH, bool isDoor, bool isTradeable, bool isRecycleable, int maxStatus, int nexttoRequired, int rightsRequired, string drinkIDs, int dataID)
            {
                if (Sprite.Contains(" "))
                {
                    this.Sprite = Sprite.Split(new char[] { ' ' })[0];
                    this.Colour = Sprite.Split(new char[] { ' ' })[1];
                }
                else
                {
                    this.Sprite = Sprite;
                    this.Colour = "null";
                }
                this.typeID = typeID;
                this.Length = Length;
                this.Width = Width;
                this.topH = topH;
                this.isDoor = isDoor;
                this.isTradeable = isTradeable;
                this.isRecycleable = isRecycleable;
                this.maxStatus = maxStatus;
                this.nexttoRequired = nexttoRequired;
                this.rightsRequired = rightsRequired;
                this.drinkIDs = drinkIDs;
                this.indexID = dataID;
            }
        }
    }
}