Also include block destruction.

This includes persistent inventory, location, flying state, etc

regarding this:

https://github.com/SirCmpwn/Craft.Net/blob/master/Craft.Net.Server/MinecraftServer.cs#L356

                            Packet packet = Clients[i].SendQueue.Dequeue();
                            // I don't understand why this happens. The only place the SendQueue
                            // is modified is through Client.SendPacket, and I watched for null packets
                            // entering through there. There is never a null packet that is added
                            // into the packet queue
                            if (packet == null)
                                continue;

you are accessing Queue from more than 1 thread without locking. Queue is not thread safe itself.

if thats really the actual reason for the null problem, simply using concurrent queue instead of the standar queue should solve the problem

http://msdn.microsoft.com/en-us/library/dd267265.aspx

To test the async networking core and create an example for networking support, create support for the 0xFE "server list ping" packet.

The ILogProvider interface should be an abstract view of textual logging. Also required is the ConsoleLogProvider class that will implement ILogProvider.

Create the basic framework for entity management.

For blocks such as torches and pistons

Track how long it takes for clients to respond to keep alive packets and use this value in player lists.

Update player lists on all clients every 60 seconds.

Add support for any item whose use results in the placement of a block, such as flint and steel.

Finish support for manipulating worlds in memory

Rearrange them to make more sense.

Don't implement weather completely, just add a means to bring about a lightning strike

Support must be added for AES encryption using shared keys.

Base maximum speed on player status (flying, sprinting, etc) and ensure that it can be customized by the library user.

Play around with the player abilities packet and try to manipulate player speed, too.

If they have different metadata, the most recently created one will be mirrored on both.

Attempting to set a block at -X where X is a chunk boundary will place the block in an adjacent chunk.

Send player lists, locations, held block, etc

Make blocks such as furnaces and crafting tables non-clickable. Windows come later.

Add Block.EntityWalkedOn and Block.EntityCollision

For packets like entity destruction, look into a means of queuing bulk packets and sending them all at once.

The engine should use asynchronous socket I/O and the server should be completely idle when there are no active connections.

Try setting the receive length to less than that of the whole buffer.

Implement the initial sending of chunks upon player login. In order for this to be complete, the basic chunk management skeleton must be added for asynchronous compression and sending of chunks.

Track the inventory of each player and disallow placement of blocks that are unavailable to them. Survival mode inventory transactions need not be supported.

When tracking entities on the client, the second client sees the first client's nametag and shadow at strange locations.

Eating food, losing hunger, starvation, etc

Add the ability to sleep in beds to manipulate the time of day.

Note that mining in survival mode is working, but time limits and tool damage is not enforced.

Add support for loading worlds from Anvil world saves.

A system for managing visible chunks is required.

Change the namespace and import the block and item classes from LibMinecraft.

Allow players to wear equipment and modify the damage they receive based on the quality of the equipment.