public Server()
        {
            Log("Starting Server");
            s = this;
            consolePlayer = new ConsolePlayer(s);
            consolePlayer.SetUsername(ConsoleName);
            //Group.DefaultGroup = new DefaultGroup(); //debugging
            mainlevel = new World(0, 127, 0, "main", new Random().Next());
            World.worlds.Add(mainlevel);
            ml = new MainLoop("server");
            #region updatetimer
            ml.Queue(delegate
            {
                updateTimer.Elapsed += delegate
                {
                Player.GlobalUpdate();
                }; updateTimer.Start();
            });
            #endregion
            //TODO AI Update Timer

            //Setup();

            Log("Server Started");

            //new Creeper(new Point3(0, 0, 0), mainlevel);
        }

 public Item(Items item, World l, bool inv = false)
 {
     isInventory = inv;
     e = new Entity(this, l);
     this.id = (short)item;
     OnGround = false;
 }

 public ChunkLoadQueue(int x, int z, bool unload, World world)
 {
     this.x = x;
     this.z = z;
     this.unload = unload;
     this.world = world;
 }

 public override void Use(Player p, params string[] args)
 {
     if (args.Length == 0) { Help(p); return; }
     else if (args.Length == 1)
     {
         Random rand = new Random();
         int seed = new Random().Next();
         p.SendMessage("Creating world with seed: " + seed);
         double x = 0; double y = 127; double z = 0;
         World temp = new World(x, y, z, args[0], seed);
         //while (Chunk.GetChunk((int)x, (int)z, temp).GetBlock((int)x, (int)(y - 1), (int)z) == 0)
         //	y--;
         temp.SpawnY = y;
         World.worlds.Add(temp);
         p.SendMessage("World " + args[0] + " MADE!");
     }
     else if (args.Length == 2 || args.Length == 3)
     {
         int seed = Convert.ToInt32(args[1]);
         p.SendMessage("Creating world with seed: " + seed);
         double x = 0; double y = 127; double z = 0;
         World temp = new World(x, y, z, args[0], seed);
         if (args.Length == 3)
         {
             int limit = Convert.ToInt32(args[2]);
             if (limit > 2)
                 temp.ChunkLimit = limit;
             else { p.SendMessage("maxchunks cannot be less than 3. creating with maxchunks 3."); temp.ChunkLimit = 3; }
         }
         World.worlds.Add(temp);
         p.SendMessage("World " + args[0] + " MADE!");
     }
 }

 public Physics(World w, PSetting setting, int speed)
 {
     this.w = w;
     this.setting = setting;
     this.speed = speed;
     this.random = new Random();
 }

        public Creeper(Point3 pos, World level)
        {
            mye = new Entity(this, level);
            mylevel = level;
            e.pos = pos;

            e.UpdateChunks(false, false);
        }

 public ContainerChest(World level, Point3 point)
 {
     this.level = level;
     this.point = point;
     items = new Item[Size];
     for (int i = 0; i < Size; i++)
         items[i] = Item.Nothing;
 }

 public ChunkGenQueue(int x, int z, World world, bool generate = true, bool populate = true)
 {
     this.generate = generate;
     this.populate = populate;
     this.x = x;
     this.z = z;
     this.world = world;
 }

 public Item(short item, byte count, short meta, World l)
 {
     this.item = (short)item;
     this.meta = meta;
     this.count = count;
     OnGround = false;
     e = new Entity(this, l);
 }

 public WorldChunkManager(World world)
     : this()
 {
     GenLayer[] agenlayer = GenLayer.func_35019_a(world.seed);
     field_34907_a = agenlayer[0];
     field_34906_b = agenlayer[1];
     temperatureLayer = agenlayer[2];
     rainfallLayer = agenlayer[3];
 }

        public Entity(AI ai, World l)
        {
            this.ai = ai;
            id = FreeId();
            isAI = true;
            level = l;

            Entities.Add(id, this);
        }

        public Entity(Player pl, World l)
            : this(l)
        {
            p = pl;
            isPlayer = true;

            UpdateChunks(false, false);

            Entities.Add(id, this);
        }

 public Item(short item, byte count, short meta, World l, double[] pos, byte[] rot)
 {
     this.item = item;
     this.count = count;
     this.meta = meta;
     this.level = l;
     this.pos = pos;
     this.rot = rot;
     OnGround = true;
     e = new Entity(this, l);
     e.UpdateChunks(false, false);
 }

 public Explosion(World world, /*Entity entity,*/ double d, double d1, double d2, float f)
 {
     isFlaming = false;
     ExplosionRNG = new Random();
     destroyedBlockPositions = new HashSet<Point3>();
     worldObj = world;
     //exploder = entity; // Not needed right now
     explosionSize = f;
     explosionX = d;
     explosionY = d1;
     explosionZ = d2;
 }

        public Entity(Item i, World l)
        {
            I = i;
            if (!I.isInventory) id = FreeId();
            isItem = true;
            level = l;

            if (!I.isInventory)
            {
                UpdateChunks(false, false);
                Entities.Add(id, this);
            }
        }

        byte type; //This holds type information, used in deciding which kind of window we need to send.

        #endregion Fields

        #region Constructors

        public Windows(WindowType type, Point3 pos, World world, Player p)
        {
            try
            {
                id = FreeId();
                this.type = (byte)type;
                this.p = p;

                switch (Type)
                {
                    case WindowType.Chest:
                        name = "Chest"; //We change this to "Large Chest" Later if it needs it :3
                        container = world.GetBlockContainer(pos);
                        items = container.Items;
                        container.AddPlayer(p);
                        break;
                    case WindowType.Dispenser:
                        name = "Workbench";
                        //container = world.GetBlockContainer(pos); // We don't have a container for this yet.
                        items = new Item[9];
                        break;
                    case WindowType.Furnace:
                        name = "Furnace";
                        //container = world.GetBlockContainer(pos); // We don't have a container for this yet.
                        items = new Item[3];
                        break;
                    case WindowType.Workbench:
                        name = "Dispenser";
                        items = new Item[10];
                        break;
                    case WindowType.EnchantmentTable:
                        name = "Enchant";
                        items = new Item[1];
                        break;
                    case WindowType.BrewingStand:
                        name = "Brewing Stand";
                        //container = world.GetBlockContainer(pos); // We don't have a container for this yet.
                        items = new Item[4];
                        break;
                }

                if (Type == WindowType.Workbench || Type == WindowType.EnchantmentTable)
                {
                    for (int i = 0; i < InventorySize; i++)
                        items[i] = Item.Nothing;
                }
            }
            catch { Logger.Log("Error making window!"); }
        }

 /// <summary>
 /// Cancel a World Event
 /// </summary>
 /// <param name="e">The event to cancel</param>
 /// <param name="w">The world</param>
 public static void CancelEvent(LevelEvent e, World w)
 {
     switch (e)
     {
         case LevelEvent.PhysicsUpdate:
             w.physics.cancelphysics = true;
             break;
         case LevelEvent.Save:
             World.cancelsave = true;
             break;
         case LevelEvent.ChunkGenerated:
             w.cancelchunk = true;
             break;
     }
 }

 public override void Use(Player p, params string[] args)
 {
     if (args.Length == 0) { Help(p); return; }
     else if (args.Length == 1)
     {
         Random rand = new Random();
         long seed = new Random().Next();
         p.SendMessage("Creating world with seed: " + seed);
         double x = rand.Next(50); double y = 64; double z = rand.Next(50);
         World temp = new World(x, y, z, args[0]);
         //while (Chunk.GetChunk((int)x, (int)z, temp).GetBlock((int)x, (int)(y - 1), (int)z) == 0)
         //	y--;
         temp.SpawnY = y;
         World.worlds.Add(temp);
         p.SendMessage("World " + args[0] + " MADE!");
     }
 }

 public static Container CreateInstance(ContainerType type, World level, Point3 point)
 {
     switch (type)
     {
         case ContainerType.Chest:
             return new ContainerChest(level, point);
         case ContainerType.Furnace:
             // TODO
             break;
         case ContainerType.Dispenser:
             // TODO
             break;
         case ContainerType.BrewingStand:
             // TODO
             break;
     }
     return null;
 }

        public virtual void generate(World world, int i, int j, byte[] abyte0)
        {
            int k = field_947_a;
            field_35530_d = world;
            rand = new java.util.Random(world.seed);
            long l = rand.nextLong();
            long l1 = rand.nextLong();
            for(int i1 = i - k; i1 <= i + k; i1++)
            {
                for(int j1 = j - k; j1 <= j + k; j1++)
                {
                    long l2 = (long)i1 * l;
                    long l3 = (long)j1 * l1;
                    rand = new java.util.Random(l2 ^ l3 ^ world.seed);
                    recursiveGenerate(world, i1, j1, i, j, abyte0);
                }

            }
        }