Bump version

Be a little smarter about our detection of the placed sign

README.md

@@ -6,26 +6,42 @@ features of the mod. For a more stable experience, I recommend checking out the
 [original mod](https://github.com/dan200/ComputerCraft).
 
 ## What?
-CC: Tweaked does not aim to create a competing fork of ComputerCraft, nor am I planning to take it in in a vastly
-different direction to the original mod. In fact, CC: Tweaked aims to be a nurturing ground for various features, with
-a pull request against the original mod being the end goal.
+CC: Tweaked (or CC:T for short) does not aim to create a competing fork of ComputerCraft, nor am I planning to take it
+in in a vastly different direction to the original mod. In fact, CC:T aims to be a nurturing ground for various
+features, with a pull request against the original mod being the end goal.
 
-CC: Tweaked also includes many pull requests from the community which have not yet been merged, offering a large number
+CC:T also includes many pull requests from the community which have not yet been merged, offering a large number
 of additional bug fixes and features over the original mod.
 
+## Features
+CC: Tweaked contains the all features of the latest alpha, as well as numerous fixes, performance improvements and
+several additional features. I'd recommend checking out [the releases page](https://github.com/SquidDev-CC/CC-Tweaked/releases)
+to see the full changes, but here's a couple of the more interesting changes:
+
+ - Replace LuaJ with Cobalt.
+ - Allow running multiple computers at the same time.
+ - Websocket support in the HTTP library.
+ - Wired modems and cables act more like multiparts.
+ - Add map-like rendering for pocket computers and printed pages/books.
+ - Adds the `/computercraft` command, offering various diagnostic tools for server owners. This allows operators to
+   track which computers are hogging resources, turn on and shutdown multiple computers at once and interact with
+   computers remotely.
+ - Add full-block wired modems, allowing one to wrap non-solid peripherals (such as turtles, or chests if Plethora is
+   installed).
+
 ## Relation to CCTweaks?
-This mod has nothing to do with CCTweaks, though there is no denying the name is a throwback to it. However, I do plan
-to migrate some features of CCTweaks into CC: Tweaked.
+This mod has nothing to do with CCTweaks, though there is no denying the name is a throwback to it. That being said,
+several features have been included, such as full block modems, the Cobalt runtime and map-like rendering for pocket
+computers.
 
 ## Contributing
 Any contribution is welcome, be that using the mod, reporting bugs or contributing code. If you do wish to contribute
 code, do consider submitting it to the ComputerCraft repository instead.
 
-That being said, in order to start helping develop CC: Tweaked, you'll need to follow these steps:
+That being said, in order to start helping develop CC:T, you'll need to follow these steps:
 
  - **Clone the repository:** `git clone https://github.com/SquidDev-CC/CC-Tweaked.git && cd CC-Tweaked`
  - **Setup Forge:** `./gradlew setupDecompWorkspace`
  - **Test your changes:** `./gradlew runClient` (or run the `GradleStart` class from your IDE).
- 
-If you want to run CC: Tweaked in a normal Minecraft instance, run `./gradlew build` and copy the `.jar` from 
-`build/libs`.
+
+If you want to run CC:T in a normal Minecraft instance, run `./gradlew build` and copy the `.jar` from `build/libs`.

build.gradle

@@ -15,18 +15,20 @@ buildscript {
 }
 
 plugins {
-    id 'com.matthewprenger.cursegradle' version '1.0.9'
+    id 'com.matthewprenger.cursegradle' version '1.0.10'
 }
 
 apply plugin: 'net.minecraftforge.gradle.forge'
 apply plugin: 'org.ajoberstar.grgit'
+apply plugin: 'maven-publish'
+apply plugin: 'maven'
 
-version = "1.80pr1.5"
+version = "1.80pr1.7"
 group = "org.squiddev"
 archivesBaseName = "cc-tweaked"
 
 minecraft {
-    version = "1.12-14.21.1.2387"
+    version = "1.12.2-14.23.2.2634"
     runDir = "run"
     replace '${version}', project.version
 
@@ -35,7 +37,7 @@ minecraft {
     // stable_#            stables are built at the discretion of the MCP team.
     // Use non-default mappings at your own risk. they may not allways work.
     // simply re-run your setup task after changing the mappings to update your workspace.
-    mappings = "snapshot_20170629"
+    mappings = "snapshot_20180324"
     // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
 }
 
@@ -53,14 +55,17 @@ repositories {
 configurations {
     shade
     compile.extendsFrom shade
+    deployerJars
 }
 
 dependencies {
-    deobfProvided "mezz.jei:jei_1.12:4.7.5.86:api"
-    runtime "mezz.jei:jei_1.12:4.7.5.86"
+    deobfProvided "mezz.jei:jei_1.12.2:4.8.5.159:api"
+    runtime "mezz.jei:jei_1.12.2:4.8.5.159"
     shade 'org.squiddev:Cobalt:0.3.1'
 
     testCompile 'junit:junit:4.11'
+
+    deployerJars "org.apache.maven.wagon:wagon-ssh:3.0.0"
 }
 
 javadoc {
@@ -125,6 +130,59 @@ curseforge {
     }
 }
 
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            from components.java
+            artifact sourceJar
+        }
+    }
+}
+
+uploadArchives {
+    repositories {
+        if(project.hasProperty('mavenUploadUrl')) {
+            mavenDeployer {
+                configuration = configurations.deployerJars
+
+                repository(url: project.property('mavenUploadUrl')) {
+                    authentication(
+                        userName: project.property('mavenUploadUser'),
+                        privateKey: project.property('mavenUploadKey'))
+                }
+
+                pom.project {
+                    name 'CC: Tweaked'
+                    packaging 'jar'
+                    description 'A fork of ComputerCraft which aims to provide earlier access to the more experimental and in-development features of the mod.'
+                    url 'https://github.com/SquidDev-CC/CC-Tweaked'
+
+                    scm {
+                        url 'https://github.com/dan200/ComputerCraft.git'
+                    }
+
+                    issueManagement {
+                        system 'github'
+                        url 'https://github.com/dan200/ComputerCraft/issues'
+                    }
+
+                    licenses {
+                        license {
+                            name 'ComputerCraft Public License, Version 1.0'
+                            url 'https://github.com/dan200/ComputerCraft/blob/master/LICENSE'
+                            distribution 'repo'
+                        }
+                    }
+                }
+
+                pom.whenConfigured { pom ->
+                    pom.dependencies.clear()
+                }
+            }
+        }
+    }
+}
+
 gradle.projectsEvaluated {
     tasks.withType(JavaCompile) {
         options.compilerArgs << "-Xlint"

settings.gradle

@@ -0,0 +1 @@
+rootProject.name = 'cc-tweaked'

src/main/java/dan200/computercraft/ComputerCraft.java

@@ -16,7 +16,6 @@ import dan200.computercraft.api.media.IMediaProvider;
 import dan200.computercraft.api.network.IPacketNetwork;
 import dan200.computercraft.api.network.wired.IWiredElement;
 import dan200.computercraft.api.network.wired.IWiredNode;
-import dan200.computercraft.api.network.wired.IWiredProvider;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.peripheral.IPeripheralProvider;
 import dan200.computercraft.api.permissions.ITurtlePermissionProvider;
@@ -29,6 +28,7 @@ import dan200.computercraft.core.filesystem.ComboMount;
 import dan200.computercraft.core.filesystem.FileMount;
 import dan200.computercraft.core.filesystem.JarMount;
 import dan200.computercraft.core.terminal.Terminal;
+import dan200.computercraft.core.tracking.Tracking;
 import dan200.computercraft.shared.command.CommandComputer;
 import dan200.computercraft.shared.command.CommandComputerCraft;
 import dan200.computercraft.shared.common.DefaultBundledRedstoneProvider;
@@ -61,6 +61,7 @@ import dan200.computercraft.shared.turtle.blocks.BlockTurtle;
 import dan200.computercraft.shared.turtle.blocks.TileTurtle;
 import dan200.computercraft.shared.turtle.upgrades.*;
 import dan200.computercraft.shared.util.*;
+import dan200.computercraft.shared.wired.CapabilityWiredElement;
 import dan200.computercraft.shared.wired.WiredNode;
 import io.netty.buffer.Unpooled;
 import net.minecraft.entity.Entity;
@@ -69,6 +70,7 @@ import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.network.PacketBuffer;
 import net.minecraft.server.MinecraftServer;
+import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.EnumHand;
 import net.minecraft.util.NonNullList;
@@ -96,6 +98,7 @@ import java.net.MalformedURLException;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.util.*;
+import java.util.function.Consumer;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 
@@ -266,7 +269,6 @@ public class ComputerCraft
     private static List<ITurtlePermissionProvider> permissionProviders = new ArrayList<>();
     private static final Map<String, IPocketUpgrade> pocketUpgrades = new HashMap<>();
     private static final Set<ILuaAPIFactory> apiFactories = new LinkedHashSet<>();
-    private static final Set<IWiredProvider> wiredProviders = new LinkedHashSet<>();
 
     // Implementation
     @Mod.Instance( value = ComputerCraft.MOD_ID )
@@ -461,8 +463,7 @@ public class ComputerCraft
     @Mod.EventHandler
     public void onServerStarting( FMLServerStartingEvent event )
     {
-        event.registerServerCommand( new CommandComputer() );
-        event.registerServerCommand( new CommandComputerCraft() );
+        proxy.initServer( event.getServer() );
     }
 
     @Mod.EventHandler
@@ -472,6 +473,7 @@ public class ComputerCraft
         {
             ComputerCraft.serverComputerRegistry.reset();
             WirelessNetwork.resetNetworks();
+            Tracking.reset();
         }
     }
 
@@ -482,6 +484,7 @@ public class ComputerCraft
         {
             ComputerCraft.serverComputerRegistry.reset();
             WirelessNetwork.resetNetworks();
+            Tracking.reset();
         }
     }
 
@@ -733,11 +736,6 @@ public class ComputerCraft
         }
     }
 
-    public static void registerWiredProvider( IWiredProvider provider )
-    {
-        if( provider != null ) wiredProviders.add( provider );
-    }
-
     public static IWiredNode createWiredNodeForElement( IWiredElement element )
     {
         return new WiredNode( element );
@@ -766,20 +764,10 @@ public class ComputerCraft
 
     public static IWiredElement getWiredElementAt( IBlockAccess world, BlockPos pos, EnumFacing side )
     {
-        // Try the handlers in order:
-        for( IWiredProvider provider : wiredProviders )
-        {
-            try
-            {
-                IWiredElement element = provider.getElement( world, pos, side );
-                if( element != null ) return element;
-            }
-            catch( Exception e )
-            {
-                ComputerCraft.log.error( "Wired element provider " + provider + " errored.", e );
-            }
-        }
-        return null;
+        TileEntity tile = world.getTileEntity( pos );
+        return tile != null && tile.hasCapability( CapabilityWiredElement.CAPABILITY, side )
+            ? tile.getCapability( CapabilityWiredElement.CAPABILITY, side )
+            : null;
     }
 
     public static int getDefaultBundledRedstoneOutput( World world, BlockPos pos, EnumFacing side )
@@ -1137,13 +1125,18 @@ public class ComputerCraft
         turtleProxy.addAllUpgradedTurtles( list );
     }
 
-    public static void setEntityDropConsumer( Entity entity, IEntityDropConsumer consumer )
+    public static void setDropConsumer( Entity entity, Consumer<ItemStack> consumer )
     {
-        turtleProxy.setEntityDropConsumer( entity, consumer );
+        turtleProxy.setDropConsumer( entity, consumer );
     }
 
-    public static void clearEntityDropConsumer( Entity entity )
+    public static void setDropConsumer( World world, BlockPos pos, Consumer<ItemStack> consumer )
     {
-        turtleProxy.clearEntityDropConsumer( entity );
+        turtleProxy.setDropConsumer( world, pos, consumer );
+    }
+
+    public static void clearDropConsumer( )
+    {
+        turtleProxy.clearDropConsumer();
     }
 }

src/main/java/dan200/computercraft/api/ComputerCraftAPI.java

@@ -14,7 +14,6 @@ import dan200.computercraft.api.media.IMediaProvider;
 import dan200.computercraft.api.network.IPacketNetwork;
 import dan200.computercraft.api.network.wired.IWiredElement;
 import dan200.computercraft.api.network.wired.IWiredNode;
-import dan200.computercraft.api.network.wired.IWiredProvider;
 import dan200.computercraft.api.peripheral.IComputerAccess;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.peripheral.IPeripheralProvider;
@@ -332,26 +331,6 @@ public final class ComputerCraftAPI
         }
     }
 
-    /**
-     * Registers a peripheral handler to convert blocks into {@link IPeripheral} implementations.
-     *
-     * @param handler The peripheral provider to register.
-     * @see dan200.computercraft.api.peripheral.IPeripheral
-     * @see dan200.computercraft.api.peripheral.IPeripheralProvider
-     */
-    public static void registerWiredProvider( @Nonnull IWiredProvider handler )
-    {
-        findCC();
-        if ( computerCraft_registerWiredProvider != null)
-        {
-            try {
-                computerCraft_registerWiredProvider.invoke( null, handler );
-            } catch (Exception e){
-                // It failed
-            }
-        }
-    }
-
     /**
      * Construct a new wired node for a given wired element
      *
@@ -453,9 +432,6 @@ public final class ComputerCraftAPI
                 computerCraft_registerAPIFactory = findCCMethod( "registerAPIFactory", new Class<?>[] {
                     ILuaAPIFactory.class
                 } );
-                computerCraft_registerWiredProvider = findCCMethod( "registerWiredProvider", new Class<?>[] {
-                    IWiredProvider.class
-                } );
                 computerCraft_createWiredNodeForElement = findCCMethod( "createWiredNodeForElement", new Class<?>[] {
                     IWiredElement.class
                 } );
@@ -499,7 +475,6 @@ public final class ComputerCraftAPI
     private static Method computerCraft_registerPocketUpgrade = null;
     private static Method computerCraft_getWirelessNetwork = null;
     private static Method computerCraft_registerAPIFactory = null;
-    private static Method computerCraft_registerWiredProvider = null;
     private static Method computerCraft_createWiredNodeForElement = null;
     private static Method computerCraft_getWiredElementAt = null;
 }

src/main/java/dan200/computercraft/api/network/wired/IWiredElement.java

@@ -1,11 +1,8 @@
 package dan200.computercraft.api.network.wired;
 
 import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.peripheral.IPeripheral;
 
 import javax.annotation.Nonnull;
-import java.util.Collections;
-import java.util.Map;
 
 /**
  * An object which may be part of a wired network.
@@ -14,30 +11,11 @@ import java.util.Map;
  * as a proxy for all network objects. Whilst the node may change networks, an element's node should remain constant
  * for its lifespan.
  *
- * Elements are generally tied to a block or tile entity in world. One should either register an {@link IWiredProvider}
- * or implement {@link IWiredElementTile} on your tile entity.
- *
- * @see IWiredProvider
- * @see ComputerCraftAPI#registerWiredProvider(IWiredProvider)
- * @see IWiredElementTile
+ * Elements are generally tied to a block or tile entity in world. In such as case, one should provide the
+ * {@link IWiredElement} capability for the appropriate sides.
  */
 public interface IWiredElement extends IWiredSender
 {
-    /**
-     * Fetch the peripherals this network element provides.
-     *
-     * This is only called when initially attaching to a network and after a call to {@link IWiredNode#invalidate()}}, so
-     * one does not <em>need</em> to cache the return value.
-     *
-     * @return The peripherals this node provides.
-     * @see IWiredNode#invalidate()
-     */
-    @Nonnull
-    default Map<String, IPeripheral> getPeripherals()
-    {
-        return Collections.emptyMap();
-    }
-
     /**
      * Called when objects on the network change. This may occur when network nodes are added or removed, or when
      * peripherals change.

src/main/java/dan200/computercraft/api/network/wired/IWiredElementTile.java

@@ -1,22 +0,0 @@
-package dan200.computercraft.api.network.wired;
-
-import net.minecraft.util.EnumFacing;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-/**
- * A {@link net.minecraft.tileentity.TileEntity} which provides a {@link IWiredElement}. This acts
- * as a simpler alternative to a full-blown {@link IWiredProvider}.
- */
-public interface IWiredElementTile
-{
-    /**
-     * Get the wired element of this tile for a given side.
-     *
-     * @param side The side to get the network element from.
-     * @return A network element, or {@code null} if there is no element here.
-     */
-    @Nullable
-    IWiredElement getWiredElement( @Nonnull EnumFacing side );
-}

src/main/java/dan200/computercraft/api/network/wired/IWiredNetwork.java

@@ -1,6 +1,9 @@
 package dan200.computercraft.api.network.wired;
 
+import dan200.computercraft.api.peripheral.IPeripheral;
+
 import javax.annotation.Nonnull;
+import java.util.Map;
 
 /**
  * A wired network is composed of one of more {@link IWiredNode}s, a set of connections between them, and a series
@@ -51,7 +54,8 @@ public interface IWiredNetwork
     /**
      * Sever all connections this node has, removing it from this network.
      *
-     * This should only be used on the server thread.
+     * This should only be used on the server thread. You should only call this on nodes
+     * that your network element owns.
      *
      * @param node The node to remove
      * @return Whether this node was removed from the network. One cannot remove a node from a network where it is the
@@ -62,13 +66,15 @@ public interface IWiredNetwork
     boolean remove( @Nonnull IWiredNode node );
 
     /**
-     * Mark this node's peripherals as having changed.
+     * Update the peripherals a node provides.
      *
-     * This should only be used on the server thread.
+     * This should only be used on the server thread. You should only call this on nodes
+     * that your network element owns.
      *
-     * @param node The node to mark as invalid.
+     * @param node        The node to attach peripherals for.
+     * @param peripherals The new peripherals for this node.
      * @throws IllegalArgumentException If the node is not in the network.
-     * @see IWiredElement#getPeripherals()
+     * @see IWiredNode#updatePeripherals(Map)
      */
-    void invalidate( @Nonnull IWiredNode node );
+    void updatePeripherals( @Nonnull IWiredNode node, @Nonnull Map<String, IPeripheral> peripherals );
 }

src/main/java/dan200/computercraft/api/network/wired/IWiredNode.java

@@ -1,8 +1,10 @@
 package dan200.computercraft.api.network.wired;
 
 import dan200.computercraft.api.network.IPacketNetwork;
+import dan200.computercraft.api.peripheral.IPeripheral;
 
 import javax.annotation.Nonnull;
+import java.util.Map;
 
 /**
  * Wired nodes act as a layer between {@link IWiredElement}s and {@link IWiredNetwork}s.
@@ -72,7 +74,8 @@ public interface IWiredNode extends IPacketNetwork
     /**
      * Sever all connections this node has, removing it from this network.
      *
-     * This should only be used on the server thread.
+     * This should only be used on the server thread. You should only call this on nodes
+     * that your network element owns.
      *
      * @return Whether this node was removed from the network. One cannot remove a node from a network where it is the
      * only element.
@@ -87,12 +90,14 @@ public interface IWiredNode extends IPacketNetwork
     /**
      * Mark this node's peripherals as having changed.
      *
-     * This should only be used on the server thread.
+     * This should only be used on the server thread. You should only call this on nodes
+     * that your network element owns.
      *
-     * @see IWiredElement#getPeripherals()
+     * @param peripherals The new peripherals for this node.
+     * @see IWiredNetwork#updatePeripherals(IWiredNode, Map)
      */
-    default void invalidate()
+    default void updatePeripherals( @Nonnull Map<String, IPeripheral> peripherals )
     {
-        getNetwork().invalidate( this );
+        getNetwork().updatePeripherals( this, peripherals );
     }
 }

src/main/java/dan200/computercraft/api/network/wired/IWiredProvider.java

@@ -1,29 +0,0 @@
-package dan200.computercraft.api.network.wired;
-
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.IBlockAccess;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-/**
- * Fetch or create an {@link IWiredElement} for a block at a given position.
- *
- * @see dan200.computercraft.api.ComputerCraftAPI#registerWiredProvider(IWiredProvider)
- * @see IWiredElementTile
- */
-@FunctionalInterface
-public interface IWiredProvider
-{
-    /**
-     * Extract a wired network element from a block location.
-     *
-     * @param world The world the block is in.
-     * @param pos   The position the block is at.
-     * @param side  The side to get the network element from.
-     * @return A network element, or {@code null} if there is not an element here you'd like to handle.
-     */
-    @Nullable
-    IWiredElement getElement( @Nonnull IBlockAccess world, @Nonnull BlockPos pos, @Nonnull EnumFacing side );
-}

src/main/java/dan200/computercraft/client/gui/GuiPrintout.java

@@ -6,25 +6,19 @@
 
 package dan200.computercraft.client.gui;
 
-import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.core.terminal.TextBuffer;
 import dan200.computercraft.shared.media.inventory.ContainerHeldItem;
 import dan200.computercraft.shared.media.items.ItemPrintout;
-import dan200.computercraft.shared.util.Palette;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.client.renderer.GlStateManager;
-import net.minecraft.util.ResourceLocation;
 import org.lwjgl.input.Mouse;
 
 import java.io.IOException;
 
+import static dan200.computercraft.client.render.PrintoutRenderer.*;
+
 public class GuiPrintout extends GuiContainer
 {
-    private static final ResourceLocation background = new ResourceLocation( "computercraft", "textures/gui/printout.png" );
-    
-    private static final int xSize = 172;
-    private static final int ySize = 209;
-    
     private final boolean m_book;
     private final int m_pages;
     private final TextBuffer[] m_text;
@@ -34,23 +28,18 @@ public class GuiPrintout extends GuiContainer
     public GuiPrintout( ContainerHeldItem container )
     {
         super( container );
-        m_book = (ItemPrintout.getType( container.getStack() ) == ItemPrintout.Type.Book);
 
         String[] text = ItemPrintout.getText( container.getStack() );
         m_text = new TextBuffer[ text.length ];
-        for( int i=0; i<m_text.length; ++i )
-        {
-            m_text[i] = new TextBuffer( text[i] );
-        }
+        for( int i = 0; i < m_text.length; ++i ) m_text[ i ] = new TextBuffer( text[ i ] );
+
         String[] colours = ItemPrintout.getColours( container.getStack() );
         m_colours = new TextBuffer[ colours.length ];
-        for( int i=0; i<m_colours.length; ++i )
-        {
-            m_colours[i] = new TextBuffer( colours[i] );
-        }
+        for( int i = 0; i < m_colours.length; ++i ) m_colours[ i ] = new TextBuffer( colours[ i ] );
 
-        m_pages = Math.max( m_text.length / ItemPrintout.LINES_PER_PAGE, 1 );
         m_page = 0;
+        m_pages = Math.max( m_text.length / ItemPrintout.LINES_PER_PAGE, 1 );
+        m_book = ItemPrintout.getType( container.getStack() ) == ItemPrintout.Type.Book;
     }
 
     @Override
@@ -78,25 +67,19 @@ public class GuiPrintout extends GuiContainer
     }
 
     @Override
-    protected void keyTyped(char c, int k) throws IOException
+    protected void keyTyped( char c, int k ) throws IOException
     {
         super.keyTyped( c, k );
 
         if( k == 205 )
         {
             // Right
-            if( m_page < m_pages - 1 )
-            {
-                m_page = m_page + 1;
-            }
+            if( m_page < m_pages - 1 ) m_page++;
         }
         else if( k == 203 )
         {
-             // Left
-            if( m_page > 0 )
-            {
-                m_page = m_page - 1;
-            }
+            // Left
+            if( m_page > 0 ) m_page--;
         }
     }
 
@@ -106,21 +89,15 @@ public class GuiPrintout extends GuiContainer
         super.handleMouseInput();
 
         int mouseWheelChange = Mouse.getEventDWheel();
-        if (mouseWheelChange < 0)
+        if( mouseWheelChange < 0 )
         {
             // Up
-            if( m_page < m_pages - 1 )
-            {
-                m_page = m_page + 1;
-            }
+            if( m_page < m_pages - 1 ) m_page++;
         }
-        else if (mouseWheelChange > 0) 
+        else if( mouseWheelChange > 0 )
         {
             // Down
-            if( m_page > 0 )
-            {
-                m_page = m_page - 1;
-            }
+            if( m_page > 0 ) m_page--;
         }
     }
 
@@ -135,78 +112,20 @@ public class GuiPrintout extends GuiContainer
     }
 
     @Override
-    public void drawScreen(int mouseX, int mouseY, float f)
+    public void drawScreen( int mouseX, int mouseY, float f )
     {
         // Draw background
+        zLevel = zLevel - 1;
         drawDefaultBackground();
-        
+        zLevel = zLevel + 1;
+
         // Draw the printout
         GlStateManager.color( 1.0f, 1.0f, 1.0f, 1.0f );
-        this.mc.getTextureManager().bindTexture( background );
-        
-        int startY = (height - ySize) / 2;
-        //int startX = (width - xSize) / 2 - (m_page * 8);
-        int startX = (width - (xSize + (m_pages - 1)*8)) / 2;
-        
-        if( m_book )
-        {
-            // Border
-            drawTexturedModalRect( startX - 8, startY - 8, xSize + 48, 0, 12, ySize + 24);
-            drawTexturedModalRect( startX + xSize + (m_pages - 1)*8 - 4, startY - 8, xSize + 48 + 12, 0, 12, ySize + 24);
-            
-            drawTexturedModalRect( startX, startY - 8, 0, ySize, xSize, 12);
-            drawTexturedModalRect( startX, startY + ySize - 4, 0, ySize + 12, xSize, 12);
-            for( int n=1; n<m_pages; ++n )
-            {
-                drawTexturedModalRect( startX + xSize + (n-1)*8, startY - 8, 0, ySize, 8, 12);
-                drawTexturedModalRect( startX + xSize + (n-1)*8, startY + ySize - 4, 0, ySize + 12, 8, 12);
-            }
-        }
-            
-        // Left half
-        if( m_page == 0 )
-        {            
-            drawTexturedModalRect( startX, startY, 24, 0, xSize / 2, ySize);
-            drawTexturedModalRect( startX, startY, 0, 0, 12, ySize);
-        }
-        else
-        {
-            drawTexturedModalRect( startX, startY, 0, 0, 12, ySize);
-            for( int n=1; n<m_page; ++n )
-            {
-                drawTexturedModalRect( startX + n*8, startY, 12, 0, 12, ySize);                
-            }
-            drawTexturedModalRect( startX + m_page*8, startY, 24, 0, xSize / 2, ySize);
-        }
-        
-        // Right half
-        if( m_page == (m_pages - 1) )
-        {
-            drawTexturedModalRect( startX + m_page*8 + xSize/2, startY, 24 + xSize / 2, 0, xSize / 2, ySize);
-            drawTexturedModalRect( startX + m_page*8 + (xSize - 12), startY, 24 + xSize + 12, 0, 12, ySize);
-        }
-        else 
-        {
-            drawTexturedModalRect( startX + (m_pages - 1)*8 + (xSize - 12), startY, 24 + xSize + 12, 0, 12, ySize);
-            for( int n=m_pages-2; n>=m_page; --n )
-            {
-                drawTexturedModalRect( startX + n*8 + (xSize - 12), startY, 24 + xSize, 0, 12, ySize);
-            }
-            drawTexturedModalRect( startX + m_page*8 + xSize/2, startY, 24 + xSize / 2, 0, xSize / 2, ySize);
-        }
 
-        // Draw the text
-        FixedWidthFontRenderer fontRenderer = (FixedWidthFontRenderer)ComputerCraft.getFixedWidthFontRenderer();
-        int x = startX + m_page * 8 + 13;
-        int y = startY + 11;
-        for( int line=0; line<ItemPrintout.LINES_PER_PAGE; ++line )
-        {
-            int lineIdx = ItemPrintout.LINES_PER_PAGE * m_page + line;
-            if( lineIdx >= 0 && lineIdx < m_text.length )
-            {
-                fontRenderer.drawString( m_text[lineIdx], x, y, m_colours[lineIdx], null, 0, 0, false, Palette.DEFAULT );
-            }
-            y = y + FixedWidthFontRenderer.FONT_HEIGHT;
-        }
+        int startY = (height - Y_SIZE) / 2;
+        int startX = (width - X_SIZE) / 2;
+
+        drawBorder( startX, startY, zLevel, m_page, m_pages, m_book );
+        drawText( startX + X_TEXT_MARGIN, startY + Y_TEXT_MARGIN, ItemPrintout.LINES_PER_PAGE * m_page, m_text, m_colours );
     }
 }

src/main/java/dan200/computercraft/client/proxy/CCTurtleProxyClient.java

@@ -210,7 +210,7 @@ public class CCTurtleProxyClient extends CCTurtleProxyCommon
     private static class TurtleItemColour implements IItemColor
     {
         @Override
-        public int getColorFromItemstack( @Nonnull ItemStack stack, int tintIndex )
+        public int colorMultiplier( @Nonnull ItemStack stack, int tintIndex )
         {
             if( tintIndex == 0 )
             {

src/main/java/dan200/computercraft/client/proxy/ComputerCraftProxyClient.java

@@ -9,6 +9,7 @@ package dan200.computercraft.client.proxy;
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.client.gui.*;
 import dan200.computercraft.client.render.ItemPocketRenderer;
+import dan200.computercraft.client.render.ItemPrintoutRenderer;
 import dan200.computercraft.client.render.RenderOverlayCable;
 import dan200.computercraft.client.render.TileEntityCableRenderer;
 import dan200.computercraft.client.render.TileEntityMonitorRenderer;
@@ -34,8 +35,10 @@ import dan200.computercraft.shared.proxy.ComputerCraftProxyCommon;
 import dan200.computercraft.shared.turtle.blocks.TileTurtle;
 import dan200.computercraft.shared.turtle.entity.TurtleVisionCamera;
 import dan200.computercraft.shared.util.Colour;
+import gnu.trove.map.hash.TIntIntHashMap;
 import net.minecraft.block.Block;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiNewChat;
 import net.minecraft.client.renderer.ItemMeshDefinition;
 import net.minecraft.client.renderer.block.model.ModelBakery;
 import net.minecraft.client.renderer.block.model.ModelResourceLocation;
@@ -50,6 +53,7 @@ import net.minecraft.util.IThreadListener;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.SoundEvent;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.ITextComponent;
 import net.minecraft.world.World;
 import net.minecraftforge.client.event.ModelRegistryEvent;
 import net.minecraftforge.client.event.RenderGameOverlayEvent;
@@ -71,6 +75,8 @@ import java.util.List;
 
 public class ComputerCraftProxyClient extends ComputerCraftProxyCommon
 {
+    private static TIntIntHashMap lastCounts = new TIntIntHashMap();
+
     private long m_tick;
     private long m_renderFrame;
     private FixedWidthFontRenderer m_fixedWidthFontRenderer;
@@ -384,6 +390,7 @@ public class ComputerCraftProxyClient extends ComputerCraftProxyCommon
             case ComputerCraftPacket.ComputerTerminalChanged:
             case ComputerCraftPacket.ComputerDeleted:
             case ComputerCraftPacket.PlayRecord:
+            case ComputerCraftPacket.PostChat:
             {
                 // Packet from Server to Client
                 IThreadListener listener = Minecraft.getMinecraft();
@@ -450,6 +457,36 @@ public class ComputerCraftProxyClient extends ComputerCraftProxyCommon
                 {
                     mc.world.playRecord( pos, null );
                 }
+                break;
+            }
+            case ComputerCraftPacket.PostChat:
+            {
+                /*
+                  This allows us to send delete chat messages of the same "category" as the previous one.
+                  It's used by the various /computercraft commands to avoid filling the chat with repetitive
+                  messages.
+                 */
+
+                int id = packet.m_dataInt[0];
+                ITextComponent[] components = new ITextComponent[packet.m_dataString.length];
+                for( int i = 0; i < packet.m_dataString.length; i++ )
+                {
+                    components[i] = ITextComponent.Serializer.jsonToComponent( packet.m_dataString[i] );
+                }
+
+                GuiNewChat chat = Minecraft.getMinecraft().ingameGUI.getChatGUI();
+
+                // Keep track of how many lines we wrote last time, deleting any extra ones.
+                int lastCount = lastCounts.get( id );
+                for( int i = components.length; i < lastCount; i++ ) chat.deleteChatLine( i + id );
+                lastCounts.put( id, components.length );
+
+                // Add new lines
+                for( int i = 0; i < components.length; i++ )
+                {
+                    chat.printChatMessageWithOptionalDeletion( components[i], id + i );
+                }
+                break;
             }
 
         }
@@ -461,6 +498,7 @@ public class ComputerCraftProxyClient extends ComputerCraftProxyCommon
         MinecraftForge.EVENT_BUS.register( handlers );
         MinecraftForge.EVENT_BUS.register( new RenderOverlayCable() );
         MinecraftForge.EVENT_BUS.register( new ItemPocketRenderer() );
+        MinecraftForge.EVENT_BUS.register( new ItemPrintoutRenderer() );
     }
 
     public class ForgeHandlers
@@ -569,7 +607,7 @@ public class ComputerCraftProxyClient extends ComputerCraftProxyCommon
         }
 
         @Override
-        public int getColorFromItemstack( @Nonnull ItemStack stack, int layer )
+        public int colorMultiplier( @Nonnull ItemStack stack, int layer )
         {
             return layer == 0 ? 0xFFFFFF : disk.getColour( stack );
         }

src/main/java/dan200/computercraft/client/render/ItemPrintoutRenderer.java

@@ -0,0 +1,197 @@
+package dan200.computercraft.client.render;
+
+import dan200.computercraft.ComputerCraft;
+import dan200.computercraft.shared.media.items.ItemPrintout;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.ItemRenderer;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.EnumHandSide;
+import net.minecraft.util.math.MathHelper;
+import net.minecraftforge.client.event.RenderItemInFrameEvent;
+import net.minecraftforge.client.event.RenderSpecificHandEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+import static dan200.computercraft.client.gui.FixedWidthFontRenderer.FONT_HEIGHT;
+import static dan200.computercraft.client.gui.FixedWidthFontRenderer.FONT_WIDTH;
+import static dan200.computercraft.client.render.PrintoutRenderer.*;
+import static dan200.computercraft.shared.media.items.ItemPrintout.LINES_PER_PAGE;
+import static dan200.computercraft.shared.media.items.ItemPrintout.LINE_MAX_LENGTH;
+
+public class ItemPrintoutRenderer
+{
+    @SubscribeEvent
+    public void onRenderInHand( RenderSpecificHandEvent event )
+    {
+        ItemStack stack = event.getItemStack();
+        if( stack.getItem() != ComputerCraft.Items.printout ) return;
+
+        event.setCanceled( true );
+
+        EntityPlayer player = Minecraft.getMinecraft().player;
+
+        GlStateManager.pushMatrix();
+        if( event.getHand() == EnumHand.MAIN_HAND && player.getHeldItemOffhand().isEmpty() )
+        {
+            renderPrintoutFirstPersonCentre(
+                event.getInterpolatedPitch(),
+                event.getEquipProgress(),
+                event.getSwingProgress(),
+                stack
+            );
+        }
+        else
+        {
+            renderPrintoutFirstPersonSide(
+                event.getHand() == EnumHand.MAIN_HAND ? player.getPrimaryHand() : player.getPrimaryHand().opposite(),
+                event.getEquipProgress(),
+                event.getSwingProgress(),
+                stack
+            );
+        }
+        GlStateManager.popMatrix();
+    }
+
+    /**
+     * Renders a pocket computer to one side of the player.
+     *
+     * @param side          The side to render on
+     * @param equipProgress The equip progress of this item
+     * @param swingProgress The swing progress of this item
+     * @param stack         The stack to render
+     * @see ItemRenderer#renderMapFirstPersonSide(float, EnumHandSide, float, ItemStack)
+     */
+    private void renderPrintoutFirstPersonSide( EnumHandSide side, float equipProgress, float swingProgress, ItemStack stack )
+    {
+        Minecraft minecraft = Minecraft.getMinecraft();
+        float offset = side == EnumHandSide.RIGHT ? 1f : -1f;
+        GlStateManager.translate( offset * 0.125f, -0.125f, 0f );
+
+        // If the player is not invisible then render a single arm
+        if( !minecraft.player.isInvisible() )
+        {
+            GlStateManager.pushMatrix();
+            GlStateManager.rotate( offset * 10f, 0f, 0f, 1f );
+            minecraft.getItemRenderer().renderArmFirstPerson( equipProgress, swingProgress, side );
+            GlStateManager.popMatrix();
+        }
+
+        // Setup the appropriate transformations. This is just copied from the
+        // corresponding method in ItemRenderer. 
+        GlStateManager.pushMatrix();
+        GlStateManager.translate( offset * 0.51f, -0.08f + equipProgress * -1.2f, -0.75f );
+        float f1 = MathHelper.sqrt( swingProgress );
+        float f2 = MathHelper.sin( f1 * (float) Math.PI );
+        float f3 = -0.5f * f2;
+        float f4 = 0.4f * MathHelper.sin( f1 * ((float) Math.PI * 2f) );
+        float f5 = -0.3f * MathHelper.sin( swingProgress * (float) Math.PI );
+        GlStateManager.translate( offset * f3, f4 - 0.3f * f2, f5 );
+        GlStateManager.rotate( f2 * -45f, 1f, 0f, 0f );
+        GlStateManager.rotate( offset * f2 * -30f, 0f, 1f, 0f );
+
+        renderPrintoutFirstPerson( stack );
+
+        GlStateManager.popMatrix();
+    }
+
+    /**
+     * Render an item in the middle of the screen
+     *
+     * @param pitch         The pitch of the player
+     * @param equipProgress The equip progress of this item
+     * @param swingProgress The swing progress of this item
+     * @param stack         The stack to render
+     * @see ItemRenderer#renderMapFirstPerson(float, float, float)
+     */
+    private void renderPrintoutFirstPersonCentre( float pitch, float equipProgress, float swingProgress, ItemStack stack )
+    {
+        ItemRenderer itemRenderer = Minecraft.getMinecraft().getItemRenderer();
+
+        // Setup the appropriate transformations. This is just copied from the
+        // corresponding method in ItemRenderer.
+        float swingRt = MathHelper.sqrt( swingProgress );
+        float tX = -0.2f * MathHelper.sin( swingProgress * (float) Math.PI );
+        float tZ = -0.4f * MathHelper.sin( swingRt * (float) Math.PI );
+        GlStateManager.translate( 0f, -tX / 2f, tZ );
+        float pitchAngle = itemRenderer.getMapAngleFromPitch( pitch );
+        GlStateManager.translate( 0f, 0.04f + equipProgress * -1.2f + pitchAngle * -0.5f, -0.72f );
+        GlStateManager.rotate( pitchAngle * -85f, 1f, 0f, 0f );
+        itemRenderer.renderArms();
+        float rX = MathHelper.sin( swingRt * (float) Math.PI );
+        GlStateManager.rotate( rX * 20f, 1f, 0f, 0f );
+        GlStateManager.scale( 2f, 2f, 2f );
+
+        renderPrintoutFirstPerson( stack );
+    }
+
+
+    private static void renderPrintoutFirstPerson( ItemStack stack )
+    {
+        // Setup various transformations. Note that these are partially adapated from the corresponding method
+        // in ItemRenderer.renderMapFirstPerson
+        GlStateManager.disableLighting();
+
+        GlStateManager.rotate( 180f, 0f, 1f, 0f );
+        GlStateManager.rotate( 180f, 0f, 0f, 1f );
+        GlStateManager.scale( 0.42f, 0.42f, -0.42f );
+        GlStateManager.translate( -0.5f, -0.48f, 0.0f );
+
+        drawPrintout( stack );
+
+        GlStateManager.enableLighting();
+    }
+
+    @SubscribeEvent
+    public void onRenderInFrame( RenderItemInFrameEvent event )
+    {
+        ItemStack stack = event.getItem();
+        if( stack.getItem() != ComputerCraft.Items.printout ) return;
+
+        event.setCanceled( true );
+
+        GlStateManager.disableLighting();
+
+        // Move a little bit forward to ensure we're not clipping with the frame
+        GlStateManager.translate( 0.0f, 0.0f, -0.001f );
+        GlStateManager.rotate( 180f, 0f, 0f, 1f );
+        GlStateManager.scale( 0.95f, 0.95f, -0.95f );
+        GlStateManager.translate( -0.5f, -0.5f, 0.0f );
+
+        drawPrintout( stack );
+
+        GlStateManager.enableLighting();
+    }
+
+    private static void drawPrintout( ItemStack stack )
+    {
+        int pages = ItemPrintout.getPageCount( stack );
+        boolean book = ItemPrintout.getType( stack ) == ItemPrintout.Type.Book;
+
+        double width = LINE_MAX_LENGTH * FONT_WIDTH + X_TEXT_MARGIN * 2;
+        double height = LINES_PER_PAGE * FONT_HEIGHT + Y_TEXT_MARGIN * 2;
+
+        // Non-books will be left aligned
+        if( !book ) width += offsetAt( pages );
+
+        double visualWidth = width, visualHeight = height;
+
+        // Meanwhile books will be centred
+        if( book )
+        {
+            visualWidth += 2 * COVER_SIZE + 2 * offsetAt( pages );
+            visualHeight += 2 * COVER_SIZE;
+        }
+
+        double max = Math.max( visualHeight, visualWidth );
+
+        // Scale the printout to fit correctly.
+        double scale = 1.0 / max;
+        GlStateManager.scale( scale, scale, scale );
+        GlStateManager.translate( (max - width) / 2.0f, (max - height) / 2.0f, 0.0f );
+
+        drawBorder( 0, 0, -0.01, 0, pages, book );
+        drawText( X_TEXT_MARGIN, Y_TEXT_MARGIN, 0, ItemPrintout.getText( stack ), ItemPrintout.getColours( stack ) );
+    }
+}

src/main/java/dan200/computercraft/client/render/ModelTransformer.java

@@ -189,7 +189,7 @@ public final class ModelTransformer
         private BakedQuadBuilder( VertexFormat format )
         {
             this.format = format;
-            this.vertexData = new int[ format.getNextOffset() ];
+            this.vertexData = new int[ format.getSize() ];
         }
 
         @Nonnull

src/main/java/dan200/computercraft/client/render/PrintoutRenderer.java

@@ -0,0 +1,162 @@
+package dan200.computercraft.client.render;
+
+import dan200.computercraft.ComputerCraft;
+import dan200.computercraft.client.gui.FixedWidthFontRenderer;
+import dan200.computercraft.core.terminal.TextBuffer;
+import dan200.computercraft.shared.util.Palette;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
+
+import static dan200.computercraft.client.gui.FixedWidthFontRenderer.FONT_HEIGHT;
+import static dan200.computercraft.shared.media.items.ItemPrintout.LINES_PER_PAGE;
+
+public class PrintoutRenderer
+{
+    private static final ResourceLocation BG = new ResourceLocation( "computercraft", "textures/gui/printout.png" );
+    private static final double BG_SIZE = 256.0;
+
+    /**
+     * Width of a page
+     */
+    public static final int X_SIZE = 172;
+
+    /**
+     * Height of a page
+     */
+    public static final int Y_SIZE = 209;
+
+    /**
+     * Padding between the left and right of a page and the text
+     */
+    public static final int X_TEXT_MARGIN = 13;
+
+    /**
+     * Padding between the top and bottom of a page and the text
+     */
+    public static final int Y_TEXT_MARGIN = 11;
+
+    /**
+     * Width of the extra page texture
+     */
+    private static final int X_FOLD_SIZE = 12;
+
+    /**
+     * Size of the leather cover
+     */
+    public static final int COVER_SIZE = 12;
+
+    private static final int COVER_Y = Y_SIZE;
+    private static final int COVER_X = X_SIZE + 4 * X_FOLD_SIZE;
+
+    public static void drawText( int x, int y, int start, TextBuffer[] text, TextBuffer[] colours )
+    {
+        FixedWidthFontRenderer fontRenderer = (FixedWidthFontRenderer) ComputerCraft.getFixedWidthFontRenderer();
+
+        for( int line = 0; line < LINES_PER_PAGE && line < text.length; ++line )
+        {
+            fontRenderer.drawString( text[ start + line ], x, y + line * FONT_HEIGHT, colours[ start + line ], null, 0, 0, false, Palette.DEFAULT );
+        }
+    }
+
+    public static void drawText( int x, int y, int start, String[] text, String[] colours )
+    {
+        FixedWidthFontRenderer fontRenderer = (FixedWidthFontRenderer) ComputerCraft.getFixedWidthFontRenderer();
+
+        for( int line = 0; line < LINES_PER_PAGE && line < text.length; ++line )
+        {
+            fontRenderer.drawString( new TextBuffer( text[ start + line ] ), x, y + line * FONT_HEIGHT, new TextBuffer( colours[ start + line ] ), null, 0, 0, false, Palette.DEFAULT );
+        }
+    }
+
+    public static void drawBorder( double x, double y, double z, int page, int pages, boolean isBook )
+    {
+        GlStateManager.color( 1.0f, 1.0f, 1.0f, 1.0f );
+        Minecraft.getMinecraft().getTextureManager().bindTexture( BG );
+
+        Tessellator tessellator = Tessellator.getInstance();
+        BufferBuilder buffer = tessellator.getBuffer();
+        buffer.begin( GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX );
+
+        int leftPages = page;
+        int rightPages = pages - page - 1;
+
+        if( isBook )
+        {
+            // Border
+            double offset = offsetAt( pages );
+            final double left = x - 4 - offset;
+            final double right = x + X_SIZE + offset - 4;
+
+            // Left and right border
+            drawTexture( buffer, left - 4, y - 8, z - 0.02, COVER_X, 0, COVER_SIZE, Y_SIZE + COVER_SIZE * 2 );
+            drawTexture( buffer, right, y - 8, z - 0.02, COVER_X + COVER_SIZE, 0, COVER_SIZE, Y_SIZE + COVER_SIZE * 2 );
+
+            // Draw centre panel (just stretched texture, sorry).
+            drawTexture( buffer,
+                x - offset, y, z - 0.02, X_SIZE + offset * 2, Y_SIZE,
+                COVER_X + COVER_SIZE / 2, COVER_SIZE, COVER_SIZE, Y_SIZE
+            );
+
+            double borderX = left;
+            while( borderX < right )
+            {
+                double thisWidth = Math.min( right - borderX, X_SIZE );
+                drawTexture( buffer, borderX, y - 8, z - 0.02, 0, COVER_Y, thisWidth, COVER_SIZE );
+                drawTexture( buffer, borderX, y + Y_SIZE - 4, z - 0.02, 0, COVER_Y + COVER_SIZE, thisWidth, COVER_SIZE );
+                borderX += thisWidth;
+            }
+        }
+
+        // Left half
+        drawTexture( buffer, x, y, z, X_FOLD_SIZE * 2, 0, X_SIZE / 2, Y_SIZE );
+        for( int n = 0; n <= leftPages; n++ )
+        {
+            drawTexture( buffer,
+                x - offsetAt( n ), y, z - 1e-3 * n,
+                // Use the left "bold" fold for the outermost page
+                n == leftPages ? 0 : X_FOLD_SIZE, 0,
+                X_FOLD_SIZE, Y_SIZE
+            );
+        }
+
+        // Right half
+        drawTexture( buffer, x + X_SIZE / 2, y, z, X_FOLD_SIZE * 2 + X_SIZE / 2, 0, X_SIZE / 2, Y_SIZE );
+        for( int n = 0; n <= rightPages; n++ )
+        {
+            drawTexture( buffer,
+                x + (X_SIZE - X_FOLD_SIZE) + offsetAt( n ), y, z - 1e-3 * n,
+                // Two folds, then the main page. Use the right "bold" fold for the outermost page.
+                X_FOLD_SIZE * 2 + X_SIZE + (n == rightPages ? X_FOLD_SIZE : 0), 0,
+                X_FOLD_SIZE, Y_SIZE
+            );
+        }
+
+        tessellator.draw();
+    }
+
+    private static void drawTexture( BufferBuilder buffer, double x, double y, double z, double u, double v, double width, double height )
+    {
+        buffer.pos( x, y + height, z ).tex( u / BG_SIZE, (v + height) / BG_SIZE ).endVertex();
+        buffer.pos( x + width, y + height, z ).tex( (u + width) / BG_SIZE, (v + height) / BG_SIZE ).endVertex();
+        buffer.pos( x + width, y, z ).tex( (u + width) / BG_SIZE, v / BG_SIZE ).endVertex();
+        buffer.pos( x, y, z ).tex( u / BG_SIZE, v / BG_SIZE ).endVertex();
+    }
+
+    private static void drawTexture( BufferBuilder buffer, double x, double y, double z, double width, double height, double u, double v, double tWidth, double tHeight )
+    {
+        buffer.pos( x, y + height, z ).tex( u / BG_SIZE, (v + tHeight) / BG_SIZE ).endVertex();
+        buffer.pos( x + width, y + height, z ).tex( (u + tWidth) / BG_SIZE, (v + tHeight) / BG_SIZE ).endVertex();
+        buffer.pos( x + width, y, z ).tex( (u + tWidth) / BG_SIZE, v / BG_SIZE ).endVertex();
+        buffer.pos( x, y, z ).tex( u / BG_SIZE, v / BG_SIZE ).endVertex();
+    }
+
+    public static double offsetAt( int page )
+    {
+        return 32 * (1 - Math.pow( 1.2, -page ));
+    }
+}

src/main/java/dan200/computercraft/client/render/TileEntityMonitorRenderer.java

@@ -18,6 +18,7 @@ import dan200.computercraft.shared.util.Palette;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.BufferBuilder;
 import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.OpenGlHelper;
 import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
@@ -47,19 +48,20 @@ public class TileEntityMonitorRenderer extends TileEntitySpecialRenderer<TileMon
 
         if( originTerminal == null ) return;
         TileMonitor origin = originTerminal.getOrigin();
+        BlockPos monitorPos = monitor.getPos();
 
-        // Ensure each monitor is rendered only once
+        // Ensure each monitor terminal is rendered only once. We allow rendering a specific tile
+        // multiple times in a single frame to ensure compatibility with shaders which may run a 
+        // pass multiple times.
         long renderFrame = ComputerCraft.getRenderFrame();
-        if( originTerminal.lastRenderFrame == renderFrame )
+        if( originTerminal.lastRenderFrame == renderFrame && !monitorPos.equals( originTerminal.lastRenderPos ) )
         {
             return;
         }
-        else
-        {
-            originTerminal.lastRenderFrame = renderFrame;
-        }
 
-        BlockPos monitorPos = monitor.getPos();
+        originTerminal.lastRenderFrame = renderFrame;
+        originTerminal.lastRenderPos = monitorPos;
+
         BlockPos originPos = origin.getPos();
         posX += originPos.getX() - monitorPos.getX();
         posY += originPos.getY() - monitorPos.getY();
@@ -96,6 +98,7 @@ public class TileEntityMonitorRenderer extends TileEntitySpecialRenderer<TileMon
 
             // Draw the contents
             GlStateManager.depthMask( false );
+            OpenGlHelper.setLightmapTextureCoords( OpenGlHelper.lightmapTexUnit, 0xFF, 0xFF );
             GlStateManager.disableLighting();
             mc.entityRenderer.disableLightmap();
             try

src/main/java/dan200/computercraft/core/apis/ComputerAccess.java

@@ -3,14 +3,17 @@ package dan200.computercraft.core.apis;
 import dan200.computercraft.api.filesystem.IMount;
 import dan200.computercraft.api.filesystem.IWritableMount;
 import dan200.computercraft.api.peripheral.IComputerAccess;
+import dan200.computercraft.core.computer.Computer;
+import dan200.computercraft.core.computer.IComputerOwned;
 import dan200.computercraft.core.filesystem.FileSystem;
 import dan200.computercraft.core.filesystem.FileSystemException;
 
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import java.util.HashSet;
 import java.util.Set;
 
-public abstract class ComputerAccess implements IComputerAccess
+public abstract class ComputerAccess implements IComputerAccess, IComputerOwned
 {
     private final IAPIEnvironment m_environment;
     private final Set<String> m_mounts = new HashSet<>();
@@ -133,6 +136,13 @@ public abstract class ComputerAccess implements IComputerAccess
         m_environment.queueEvent( event, arguments );
     }
 
+    @Nullable
+    @Override
+    public Computer getComputer()
+    {
+        return m_environment.getComputer();
+    }
+
     private String findFreeLocation( String desiredLoc )
     {
         try

src/main/java/dan200/computercraft/core/apis/FSAPI.java

@@ -15,6 +15,7 @@ import dan200.computercraft.core.apis.handles.EncodedInputHandle;
 import dan200.computercraft.core.apis.handles.EncodedOutputHandle;
 import dan200.computercraft.core.filesystem.FileSystem;
 import dan200.computercraft.core.filesystem.FileSystemException;
+import dan200.computercraft.core.tracking.TrackingField;
 
 import javax.annotation.Nonnull;
 import java.io.InputStream;
@@ -88,6 +89,7 @@ public class FSAPI implements ILuaAPI
             {
                 // list
                 String path = getString( args, 0 );
+                m_env.addTrackingChange( TrackingField.FS_OPS );
                 try {
                     String[] results = m_fileSystem.list( path );
                     Map<Object,Object> table = new HashMap<>();
@@ -162,6 +164,7 @@ public class FSAPI implements ILuaAPI
                 // makeDir
                 String path = getString( args, 0 );
                 try {
+                    m_env.addTrackingChange( TrackingField.FS_OPS );
                     m_fileSystem.makeDir( path );
                     return null;
                 } catch( FileSystemException e ) {
@@ -174,6 +177,7 @@ public class FSAPI implements ILuaAPI
                 String path = getString( args, 0 );
                 String dest = getString( args, 1 );
                 try {
+                    m_env.addTrackingChange( TrackingField.FS_OPS );
                     m_fileSystem.move( path, dest );
                     return null;
                 } catch( FileSystemException e ) {
@@ -186,6 +190,7 @@ public class FSAPI implements ILuaAPI
                 String path = getString( args, 0 );
                 String dest = getString( args, 1 );
                 try {
+                    m_env.addTrackingChange( TrackingField.FS_OPS );
                     m_fileSystem.copy( path, dest );
                     return null;
                 } catch( FileSystemException e ) {
@@ -197,6 +202,7 @@ public class FSAPI implements ILuaAPI
                 // delete
                 String path = getString( args, 0 );
                 try {
+                    m_env.addTrackingChange( TrackingField.FS_OPS );
                     m_fileSystem.delete( path );
                     return null;
                 } catch( FileSystemException e ) {
@@ -208,6 +214,7 @@ public class FSAPI implements ILuaAPI
                 // open
                 String path = getString( args, 0 );
                 String mode = getString( args, 1 );
+                m_env.addTrackingChange( TrackingField.FS_OPS );
                 try {
                     switch( mode )
                     {
@@ -288,6 +295,7 @@ public class FSAPI implements ILuaAPI
                 // find
                 String path = getString( args, 0 );
                 try {
+                    m_env.addTrackingChange( TrackingField.FS_OPS );
                     String[] results = m_fileSystem.find( path );
                     Map<Object,Object> table = new HashMap<>();
                     for(int i=0; i<results.length; ++i ) {

src/main/java/dan200/computercraft/core/apis/HTTPAPI.java

@@ -6,6 +6,7 @@
 
 package dan200.computercraft.core.apis;
 
+import com.google.common.collect.ImmutableSet;
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.api.lua.ILuaAPI;
 import dan200.computercraft.api.lua.ILuaContext;
@@ -21,9 +22,14 @@ import java.util.*;
 import java.util.concurrent.Future;
 
 import static dan200.computercraft.core.apis.ArgumentHelper.*;
+import static dan200.computercraft.core.apis.TableHelper.*;
 
 public class HTTPAPI implements ILuaAPI
 {
+    private static final Set<String> HTTP_METHODS = ImmutableSet.of(
+        "GET", "POST", "HEAD", "OPTIONS", "PUT", "DELETE"
+    );
+
     private final IAPIEnvironment m_apiEnvironment;
     private final List<Future<?>> m_httpTasks;
     private final Set<Closeable> m_closeables;
@@ -38,7 +44,7 @@ public class HTTPAPI implements ILuaAPI
     @Override
     public String[] getNames()
     {
-        return new String[] {
+        return new String[]{
             "http"
         };
     }
@@ -59,7 +65,7 @@ public class HTTPAPI implements ILuaAPI
     }
 
     @Override
-    public void shutdown( )
+    public void shutdown()
     {
         synchronized( m_httpTasks )
         {
@@ -89,7 +95,7 @@ public class HTTPAPI implements ILuaAPI
     @Override
     public String[] getMethodNames()
     {
-        return new String[] {
+        return new String[]{
             "request",
             "checkURL",
             "websocket",
@@ -101,52 +107,68 @@ public class HTTPAPI implements ILuaAPI
     {
         switch( method )
         {
-            case 0:
+            case 0: // request
             {
-                // request
-                // Get URL
-                String urlString = getString( args, 0 );
+                String urlString, postString, requestMethod;
+                Map<Object, Object> headerTable;
+                boolean binary, redirect;
 
-                // Get POST
-                String postString = optString( args, 1, null );
-
-                // Get Headers
-                Map<String, String> headers = null;
-                Map<Object, Object> table = optTable( args, 2, null );
-                if( table != null )
+                if( args.length >= 1 && args[0] instanceof Map )
                 {
-                    headers = new HashMap<>( table.size() );
-                    for( Object key : table.keySet() )
+                    Map<?, ?> options = (Map) args[0];
+                    urlString = getStringField( options, "url" );
+                    postString = optStringField( options, "body", null );
+                    headerTable = optTableField( options, "headers", null );
+                    binary = optBooleanField( options, "binary", false );
+                    requestMethod = optStringField( options, "method", null );
+                    redirect = optBooleanField( options, "redirect", true );
+
+                }
+                else
+                {
+                    // Get URL and post information
+                    urlString = getString( args, 0 );
+                    postString = optString( args, 1, null );
+                    headerTable = optTable( args, 2, null );
+                    binary = optBoolean( args, 3, false );
+                    requestMethod = null;
+                    redirect = true;
+                }
+
+                Map<String, String> headers = null;
+                if( headerTable != null )
+                {
+                    headers = new HashMap<>( headerTable.size() );
+                    for( Object key : headerTable.keySet() )
                     {
-                        Object value = table.get( key );
+                        Object value = headerTable.get( key );
                         if( key instanceof String && value instanceof String )
                         {
-                            headers.put( (String)key, (String)value );
+                            headers.put( (String) key, (String) value );
                         }
                     }
                 }
 
-                // Get binary
-                boolean binary = false;
-                if( args.length >= 4 )
+
+                if( requestMethod != null && !HTTP_METHODS.contains( requestMethod ) )
                 {
-                    binary = args[ 3 ] != null && !args[ 3 ].equals( Boolean.FALSE );
+                    throw new LuaException( "Unsupported HTTP method" );
                 }
 
                 // Make the request
                 try
                 {
                     URL url = HTTPRequest.checkURL( urlString );
-                    HTTPRequest request = new HTTPRequest( m_apiEnvironment, urlString, url, postString, headers, binary );
+                    HTTPRequest request = new HTTPRequest( m_apiEnvironment, urlString, url, postString, headers, binary, requestMethod, redirect );
                     synchronized( m_httpTasks )
                     {
                         m_httpTasks.add( HTTPExecutor.EXECUTOR.submit( request ) );
                     }
-                    return new Object[] { true };
+                    return new Object[]{ true };
                 }
                 catch( HTTPRequestException e )
                 {
-                    return new Object[] { false, e.getMessage() };
+                    return new Object[]{ false, e.getMessage() };
                 }
             }
             case 1:
@@ -164,11 +186,11 @@ public class HTTPAPI implements ILuaAPI
                     {
                         m_httpTasks.add( HTTPExecutor.EXECUTOR.submit( check ) );
                     }
-                    return new Object[] { true };
+                    return new Object[]{ true };
                 }
                 catch( HTTPRequestException e )
                 {
-                    return new Object[] { false, e.getMessage() };
+                    return new Object[]{ false, e.getMessage() };
                 }
             }
             case 2: // websocket
@@ -201,11 +223,11 @@ public class HTTPAPI implements ILuaAPI
                     {
                         m_httpTasks.add( connector );
                     }
-                    return new Object[] { true };
+                    return new Object[]{ true };
                 }
                 catch( HTTPRequestException e )
                 {
-                    return new Object[] { false, e.getMessage() };
+                    return new Object[]{ false, e.getMessage() };
                 }
             }
             default:

src/main/java/dan200/computercraft/core/apis/IAPIEnvironment.java

@@ -9,16 +9,19 @@ package dan200.computercraft.core.apis;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.core.computer.Computer;
 import dan200.computercraft.core.computer.IComputerEnvironment;
+import dan200.computercraft.core.computer.IComputerOwned;
 import dan200.computercraft.core.filesystem.FileSystem;
 import dan200.computercraft.core.terminal.Terminal;
+import dan200.computercraft.core.tracking.TrackingField;
 
-public interface IAPIEnvironment
+public interface IAPIEnvironment extends IComputerOwned
 {
     interface IPeripheralChangeListener
     {
         void onPeripheralChanged( int side, IPeripheral newPeripheral );
     }
-    
+
+    @Override
     Computer getComputer();
     int getComputerID();
     IComputerEnvironment getComputerEnvironment();
@@ -42,4 +45,11 @@ public interface IAPIEnvironment
 
     String getLabel();
     void setLabel( String label );
+
+    void addTrackingChange( TrackingField field, long change );
+
+    default void addTrackingChange( TrackingField field )
+    {
+        addTrackingChange( field, 1 );
+    }
 }

src/main/java/dan200/computercraft/core/apis/PeripheralAPI.java

@@ -15,6 +15,7 @@ import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.core.computer.Computer;
 import dan200.computercraft.core.computer.ComputerThread;
 import dan200.computercraft.core.computer.ITask;
+import dan200.computercraft.core.tracking.TrackingField;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -109,6 +110,7 @@ public class PeripheralAPI implements ILuaAPI, IAPIEnvironment.IPeripheralChange
             }
             if( method >= 0 )
             {
+                m_environment.addTrackingChange( TrackingField.PERIPHERAL_OPS );
                 return m_peripheral.callMethod( this, context, method, arguments );
             }
             else

src/main/java/dan200/computercraft/core/apis/TableHelper.java

@@ -0,0 +1,214 @@
+package dan200.computercraft.core.apis;
+
+import dan200.computercraft.api.lua.LuaException;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Map;
+
+/**
+ * Various helpers for tables
+ */
+public final class TableHelper
+{
+    private TableHelper()
+    {
+        throw new IllegalStateException( "Cannot instantiate singleton " + getClass().getName() );
+    }
+
+    @Nonnull
+    public static LuaException badKey( @Nonnull String key, @Nonnull String expected, @Nullable Object actual )
+    {
+        return badKey( key, expected, ArgumentHelper.getType( actual ) );
+    }
+
+    @Nonnull
+    public static LuaException badKey( @Nonnull String key, @Nonnull String expected, @Nonnull String actual )
+    {
+        return new LuaException( "bad field '" + key + "' (" + expected + " expected, got " + actual + ")" );
+    }
+
+    public static double getNumberField( @Nonnull Map<?, ?> table, @Nonnull String key ) throws LuaException
+    {
+        Object value = table.get( key );
+        if( value instanceof Number )
+        {
+            return ((Number) value).doubleValue();
+        }
+        else
+        {
+            throw badKey( key, "number", value );
+        }
+    }
+
+    public static int getIntField( @Nonnull Map<?, ?> table, @Nonnull String key ) throws LuaException
+    {
+        Object value = table.get( key );
+        if( value instanceof Number )
+        {
+            return (int) ((Number) value).longValue();
+        }
+        else
+        {
+            throw badKey( key, "number", value );
+        }
+    }
+
+    public static double getRealField( @Nonnull Map<?, ?> table, @Nonnull String key ) throws LuaException
+    {
+        return checkReal( key, getNumberField( table, key ) );
+    }
+
+    public static boolean getBooleanField( @Nonnull Map<?, ?> table, @Nonnull String key ) throws LuaException
+    {
+        Object value = table.get( key );
+        if( value instanceof Boolean )
+        {
+            return (Boolean) value;
+        }
+        else
+        {
+            throw badKey( key, "boolean", value );
+        }
+    }
+
+    @Nonnull
+    public static String getStringField( @Nonnull Map<?, ?> table, @Nonnull String key ) throws LuaException
+    {
+        Object value = table.get( key );
+        if( value instanceof String )
+        {
+            return (String) value;
+        }
+        else
+        {
+            throw badKey( key, "string", value );
+        }
+    }
+
+    @SuppressWarnings( "unchecked" )
+    @Nonnull
+    public static Map<Object, Object> getTableField( @Nonnull Map<?, ?> table, @Nonnull String key ) throws LuaException
+    {
+        Object value = table.get( key );
+        if( value instanceof Map )
+        {
+            return (Map<Object, Object>) value;
+        }
+        else
+        {
+            throw badKey( key, "table", value );
+        }
+    }
+
+    public static double optNumberField( @Nonnull Map<?, ?> table, @Nonnull String key, double def ) throws LuaException
+    {
+        Object value = table.get( key );
+        if( value == null )
+        {
+            return def;
+        }
+        else if( value instanceof Number )
+        {
+            return ((Number) value).doubleValue();
+        }
+        else
+        {
+            throw badKey( key, "number", value );
+        }
+    }
+
+    public static int optIntField( @Nonnull Map<?, ?> table, @Nonnull String key, int def ) throws LuaException
+    {
+        Object value = table.get( key );
+        if( value == null )
+        {
+            return def;
+        }
+        else if( value instanceof Number )
+        {
+            return (int) ((Number) value).longValue();
+        }
+        else
+        {
+            throw badKey( key, "number", value );
+        }
+    }
+
+    public static double optRealField( @Nonnull Map<?, ?> table, @Nonnull String key, double def ) throws LuaException
+    {
+        return checkReal( key, optNumberField( table, key, def ) );
+    }
+
+    public static boolean optBooleanField( @Nonnull Map<?, ?> table, @Nonnull String key, boolean def ) throws LuaException
+    {
+        Object value = table.get( key );
+        if( value == null )
+        {
+            return def;
+        }
+        else if( value instanceof Boolean )
+        {
+            return (Boolean) value;
+        }
+        else
+        {
+            throw badKey( key, "boolean", value );
+        }
+    }
+
+    public static String optStringField( @Nonnull Map<?, ?> table, @Nonnull String key, String def ) throws LuaException
+    {
+        Object value = table.get( key );
+        if( value == null )
+        {
+            return def;
+        }
+        else if( value instanceof String )
+        {
+            return (String) value;
+        }
+        else
+        {
+            throw badKey( key, "string", value );
+        }
+    }
+
+    @SuppressWarnings( "unchecked" )
+    public static Map<Object, Object> optTableField( @Nonnull Map<?, ?> table, @Nonnull String key, Map<Object, Object> def ) throws LuaException
+    {
+        Object value = table.get( key );
+        if( value == null )
+        {
+            return def;
+        }
+        else if( value instanceof Map )
+        {
+            return (Map<Object, Object>) value;
+        }
+        else
+        {
+            throw badKey( key, "table", value );
+        }
+    }
+
+    private static double checkReal( @Nonnull String key, double value ) throws LuaException
+    {
+        if( Double.isNaN( value ) )
+        {
+            throw badKey( key, "number", "nan" );
+        }
+        else if( value == Double.POSITIVE_INFINITY )
+        {
+            throw badKey( key, "number", "inf" );
+        }
+        else if( value == Double.NEGATIVE_INFINITY )
+        {
+            throw badKey( key, "number", "-inf" );
+        }
+        else
+        {
+            return value;
+        }
+    }
+}

src/main/java/dan200/computercraft/core/apis/handles/BinaryInputHandle.java

@@ -5,6 +5,7 @@ import dan200.computercraft.api.lua.ILuaContext;
 import dan200.computercraft.api.lua.LuaException;
 
 import javax.annotation.Nonnull;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Arrays;
@@ -13,6 +14,8 @@ import static dan200.computercraft.core.apis.ArgumentHelper.getInt;
 
 public class BinaryInputHandle extends HandleGeneric
 {
+    private static final int BUFFER_SIZE = 8192;
+
     private final InputStream m_stream;
 
     public BinaryInputHandle( InputStream reader )
@@ -45,16 +48,46 @@ public class BinaryInputHandle extends HandleGeneric
                     if( args.length > 0 && args[ 0 ] != null )
                     {
                         int count = getInt( args, 0 );
-                        if( count <= 0 || count >= 1024 * 16 )
+                        if( count < 0 )
                         {
-                            throw new LuaException( "Count out of range" );
+                            // Whilst this may seem absurd to allow reading 0 bytes, PUC Lua it so 
+                            // it seems best to remain somewhat consistent.
+                            throw new LuaException( "Cannot read a negative number of bytes" );
                         }
+                        else if( count <= BUFFER_SIZE )
+                        {
+                            // If we've got a small count, then allocate that and read it.
+                            byte[] bytes = new byte[ count ];
+                            int read = m_stream.read( bytes );
 
-                        byte[] bytes = new byte[ count ];
-                        count = m_stream.read( bytes );
-                        if( count < 0 ) return null;
-                        if( count < bytes.length ) bytes = Arrays.copyOf( bytes, count );
-                        return new Object[] { bytes };
+                            if( read < 0 ) return null;
+                            if( read < count ) bytes = Arrays.copyOf( bytes, read );
+                            return new Object[] { bytes };
+                        }
+                        else
+                        {
+                            byte[] buffer = new byte[ BUFFER_SIZE ];
+
+                            // Read the initial set of bytes, failing if none are read.
+                            int read = m_stream.read( buffer, 0, Math.min( buffer.length, count ) );
+                            if( read == -1 ) return null;
+
+                            ByteArrayOutputStream out = new ByteArrayOutputStream( read );
+                            count -= read;
+                            out.write( buffer, 0, read );
+
+                            // Otherwise read until we either reach the limit or we no longer consume
+                            // the full buffer.
+                            while( read >= buffer.length && count > 0 )
+                            {
+                                read = m_stream.read( buffer, 0, Math.min( BUFFER_SIZE, count ) );
+                                if( read == -1 ) break;
+                                count -= read;
+                                out.write( buffer, 0, read );
+                            }
+
+                            return new Object[] { out.toByteArray() };
+                        }
                     }
                     else
                     {

src/main/java/dan200/computercraft/core/apis/handles/EncodedInputHandle.java

@@ -6,10 +6,12 @@ import dan200.computercraft.api.lua.LuaException;
 import javax.annotation.Nonnull;
 import java.io.*;
 
-import static dan200.computercraft.core.apis.ArgumentHelper.*;
+import static dan200.computercraft.core.apis.ArgumentHelper.optInt;
 
 public class EncodedInputHandle extends HandleGeneric
 {
+    private static final int BUFFER_SIZE = 8192;
+
     private final BufferedReader m_reader;
 
     public EncodedInputHandle( BufferedReader reader )
@@ -111,15 +113,45 @@ public class EncodedInputHandle extends HandleGeneric
                 try
                 {
                     int count = optInt( args, 0, 1 );
-                    if( count <= 0 || count >= 1024 * 16 )
+                    if( count < 0 )
                     {
-                        throw new LuaException( "Count out of range" );
+                        // Whilst this may seem absurd to allow reading 0 characters, PUC Lua it so 
+                        // it seems best to remain somewhat consistent.
+                        throw new LuaException( "Cannot read a negative number of characters" );
+                    }
+                    else if( count <= BUFFER_SIZE )
+                    {
+                        // If we've got a small count, then allocate that and read it.
+                        char[] chars = new char[ count ];
+                        int read = m_reader.read( chars );
+
+                        return read < 0 ? null : new Object[] { new String( chars, 0, read ) };
+                    }
+                    else
+                    {
+                        // If we've got a large count, read in bunches of 8192.
+                        char[] buffer = new char[ BUFFER_SIZE ];
+
+                        // Read the initial set of characters, failing if none are read.
+                        int read = m_reader.read( buffer, 0, Math.min( buffer.length, count ) );
+                        if( read == -1 ) return null;
+
+                        StringBuilder out = new StringBuilder( read );
+                        count -= read;
+                        out.append( buffer, 0, read );
+
+                        // Otherwise read until we either reach the limit or we no longer consume
+                        // the full buffer.
+                        while( read >= BUFFER_SIZE && count > 0 )
+                        {
+                            read = m_reader.read( buffer, 0, Math.min( BUFFER_SIZE, count ) );
+                            if( read == -1 ) break;
+                            count -= read;
+                            out.append( buffer, 0, read );
+                        }
+
+                        return new Object[] { out.toString() };
                     }
-                    char[] bytes = new char[ count ];
-                    count = m_reader.read( bytes );
-                    if( count < 0 ) return null;
-                    String str = new String( bytes, 0, count );
-                    return new Object[] { str };
                 }
                 catch( IOException e )
                 {

src/main/java/dan200/computercraft/core/apis/http/HTTPRequest.java

@@ -15,6 +15,7 @@ import dan200.computercraft.api.lua.LuaException;
 import dan200.computercraft.core.apis.IAPIEnvironment;
 import dan200.computercraft.core.apis.handles.BinaryInputHandle;
 import dan200.computercraft.core.apis.handles.EncodedInputHandle;
+import dan200.computercraft.core.tracking.TrackingField;
 
 import javax.annotation.Nonnull;
 import java.io.*;
@@ -78,8 +79,10 @@ public class HTTPRequest implements Runnable
     private final String m_postText;
     private final Map<String, String> m_headers;
     private boolean m_binary;
+    private final String m_method;
+    private final boolean m_followRedirects;
 
-    public HTTPRequest( IAPIEnvironment environment, String urlString, URL url, final String postText, final Map<String, String> headers, boolean binary ) throws HTTPRequestException
+    public HTTPRequest( IAPIEnvironment environment, String urlString, URL url, final String postText, final Map<String, String> headers, boolean binary, final String method, final boolean followRedirects ) throws HTTPRequestException
     {
         m_environment = environment;
         m_urlString = urlString;
@@ -87,6 +90,8 @@ public class HTTPRequest implements Runnable
         m_binary = binary;
         m_postText = postText;
         m_headers = headers;
+        m_method = method;
+        m_followRedirects = followRedirects;
     }
 
     @Override
@@ -101,7 +106,7 @@ public class HTTPRequest implements Runnable
         {
             // Queue the failure event if not.
             String error = e.getMessage();
-            m_environment.queueEvent( "http_failure", new Object[] { m_urlString, error == null ? "Could not connect" : error, null } );
+            m_environment.queueEvent( "http_failure", new Object[]{ m_urlString, error == null ? "Could not connect" : error, null } );
             return;
         }
 
@@ -119,6 +124,8 @@ public class HTTPRequest implements Runnable
             {
                 connection.setRequestMethod( "GET" );
             }
+            if( m_method != null ) connection.setRequestMethod( m_method );
+            connection.setInstanceFollowRedirects( m_followRedirects );
 
             // Set headers
             connection.setRequestProperty( "accept-charset", "UTF-8" );
@@ -134,6 +141,11 @@ public class HTTPRequest implements Runnable
                 }
             }
 
+            // Add request size and count to the tracker before opening the connection
+            m_environment.addTrackingChange( TrackingField.HTTP_REQUESTS );
+            m_environment.addTrackingChange( TrackingField.HTTP_UPLOAD,
+                getHeaderSize( connection.getRequestProperties() ) + (m_postText == null ? 0 : m_postText.length()) );
+
             // Send POST text
             if( m_postText != null )
             {
@@ -178,6 +190,9 @@ public class HTTPRequest implements Runnable
                 headers.put( header.getKey(), joiner.join( header.getValue() ) );
             }
 
+            m_environment.addTrackingChange( TrackingField.HTTP_DOWNLOAD,
+                getHeaderSize( connection.getHeaderFields() ) + result.length );
+
             InputStream contents = new ByteArrayInputStream( result );
             ILuaObject stream = wrapStream(
                 m_binary ? new BinaryInputHandle( contents ) : new EncodedInputHandle( contents, connection.getContentEncoding() ),
@@ -189,17 +204,17 @@ public class HTTPRequest implements Runnable
             // Queue the appropriate event.
             if( responseSuccess )
             {
-                m_environment.queueEvent( "http_success", new Object[] { m_urlString, stream } );
+                m_environment.queueEvent( "http_success", new Object[]{ m_urlString, stream } );
             }
             else
             {
-                m_environment.queueEvent( "http_failure", new Object[] { m_urlString, "Could not connect", stream } );
+                m_environment.queueEvent( "http_failure", new Object[]{ m_urlString, "Could not connect", stream } );
             }
         }
         catch( IOException e )
         {
             // There was an error
-            m_environment.queueEvent( "http_failure", new Object[] { m_urlString, "Could not connect", null } );
+            m_environment.queueEvent( "http_failure", new Object[]{ m_urlString, "Could not connect", null } );
         }
     }
 
@@ -209,8 +224,8 @@ public class HTTPRequest implements Runnable
         final int methodOffset = oldMethods.length;
 
         final String[] newMethods = Arrays.copyOf( oldMethods, oldMethods.length + 2 );
-        newMethods[ methodOffset + 0 ] = "getResponseCode";
-        newMethods[ methodOffset + 1 ] = "getResponseHeaders";
+        newMethods[methodOffset + 0] = "getResponseCode";
+        newMethods[methodOffset + 1] = "getResponseHeaders";
 
         return new ILuaObject()
         {
@@ -233,12 +248,12 @@ public class HTTPRequest implements Runnable
                     case 0:
                     {
                         // getResponseCode
-                        return new Object[] { responseCode };
+                        return new Object[]{ responseCode };
                     }
                     case 1:
                     {
                         // getResponseHeaders
-                        return new Object[] { responseHeaders };
+                        return new Object[]{ responseHeaders };
                     }
                     default:
                     {
@@ -248,4 +263,15 @@ public class HTTPRequest implements Runnable
             }
         };
     }
+
+    private static long getHeaderSize( Map<String, List<String>> headers )
+    {
+        long size = 0;
+        for( Map.Entry<String, List<String>> header : headers.entrySet() )
+        {
+            size += header.getKey() == null ? 0 : header.getKey().length();
+            for( String value : header.getValue() ) size += value == null ? 0 : value.length() + 1;
+        }
+        return size;
+    }
 }

src/main/java/dan200/computercraft/core/apis/http/WebsocketConnection.java

@@ -12,6 +12,7 @@ import dan200.computercraft.api.lua.ILuaObject;
 import dan200.computercraft.api.lua.LuaException;
 import dan200.computercraft.core.apis.HTTPAPI;
 import dan200.computercraft.core.apis.IAPIEnvironment;
+import dan200.computercraft.core.tracking.TrackingField;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
@@ -71,7 +72,7 @@ public class WebsocketConnection extends SimpleChannelInboundHandler<Object> imp
     private void onClosed()
     {
         close( true );
-        computer.queueEvent( CLOSE_EVENT, new Object[] { url } );
+        computer.queueEvent( CLOSE_EVENT, new Object[]{ url } );
     }
 
     @Override
@@ -102,7 +103,7 @@ public class WebsocketConnection extends SimpleChannelInboundHandler<Object> imp
         if( !handshaker.isHandshakeComplete() )
         {
             handshaker.finishHandshake( ch, (FullHttpResponse) msg );
-            computer.queueEvent( SUCCESS_EVENT, new Object[] { url, this } );
+            computer.queueEvent( SUCCESS_EVENT, new Object[]{ url, this } );
             return;
         }
 
@@ -115,14 +116,19 @@ public class WebsocketConnection extends SimpleChannelInboundHandler<Object> imp
         WebSocketFrame frame = (WebSocketFrame) msg;
         if( frame instanceof TextWebSocketFrame )
         {
-            computer.queueEvent( MESSAGE_EVENT, new Object[] { url, ((TextWebSocketFrame) frame).text() } );
+            String data = ((TextWebSocketFrame) frame).text();
+
+            computer.addTrackingChange( TrackingField.WEBSOCKET_INCOMING, data.length() );
+            computer.queueEvent( MESSAGE_EVENT, new Object[]{ url, data } );
         }
         else if( frame instanceof BinaryWebSocketFrame )
         {
             ByteBuf data = frame.content();
-            byte[] converted = new byte[ data.readableBytes() ];
+            byte[] converted = new byte[data.readableBytes()];
             data.readBytes( converted );
-            computer.queueEvent( MESSAGE_EVENT, new Object[] { url, data } );
+
+            computer.addTrackingChange( TrackingField.WEBSOCKET_INCOMING, converted.length );
+            computer.queueEvent( MESSAGE_EVENT, new Object[]{ url, converted } );
         }
         else if( frame instanceof CloseWebSocketFrame )
         {
@@ -135,7 +141,7 @@ public class WebsocketConnection extends SimpleChannelInboundHandler<Object> imp
     public void exceptionCaught( ChannelHandlerContext ctx, Throwable cause )
     {
         ctx.close();
-        computer.queueEvent( FAILURE_EVENT, new Object[] {
+        computer.queueEvent( FAILURE_EVENT, new Object[]{
             url,
             cause instanceof WebSocketHandshakeException ? cause.getMessage() : "Could not connect"
         } );
@@ -145,7 +151,7 @@ public class WebsocketConnection extends SimpleChannelInboundHandler<Object> imp
     @Override
     public String[] getMethodNames()
     {
-        return new String[] { "receive", "send", "close" };
+        return new String[]{ "receive", "send", "close" };
     }
 
     @Nullable
@@ -159,15 +165,16 @@ public class WebsocketConnection extends SimpleChannelInboundHandler<Object> imp
                 {
                     checkOpen();
                     Object[] event = context.pullEvent( MESSAGE_EVENT );
-                    if( event.length >= 3 && Objects.equal( event[ 1 ], url ) )
+                    if( event.length >= 3 && Objects.equal( event[1], url ) )
                     {
-                        return new Object[] { event[ 2 ] };
+                        return new Object[]{ event[2] };
                     }
                 }
             case 1:
             {
                 checkOpen();
-                String text = arguments.length > 0 && arguments[ 0 ] != null ? arguments[ 0 ].toString() : "";
+                String text = arguments.length > 0 && arguments[0] != null ? arguments[0].toString() : "";
+                computer.addTrackingChange( TrackingField.WEBSOCKET_OUTGOING, text.length() );
                 channel.writeAndFlush( new TextWebSocketFrame( text ) );
                 return null;
             }

src/main/java/dan200/computercraft/core/apis/http/WebsocketConnector.java

@@ -21,6 +21,7 @@ import io.netty.handler.codec.http.HttpObjectAggregator;
 import io.netty.handler.codec.http.websocketx.WebSocketClientHandshaker;
 import io.netty.handler.codec.http.websocketx.WebSocketClientHandshakerFactory;
 import io.netty.handler.codec.http.websocketx.WebSocketVersion;
+import io.netty.handler.codec.http.websocketx.extensions.compression.WebSocketClientCompressionHandler;
 import io.netty.handler.ssl.SslContext;
 import io.netty.handler.ssl.SslContextBuilder;
 
@@ -34,7 +35,7 @@ import java.security.KeyStore;
 import java.util.Map;
 import java.util.concurrent.Future;
 
-/*
+/**
  * Provides functionality to verify and connect to a remote websocket.
  */
 public final class WebsocketConnector
@@ -177,7 +178,7 @@ public final class WebsocketConnector
                 httpHeaders.add( header.getKey(), header.getValue() );
             }
 
-            WebSocketClientHandshaker handshaker = WebSocketClientHandshakerFactory.newHandshaker( uri, WebSocketVersion.V13, null, false, httpHeaders );
+            WebSocketClientHandshaker handshaker = WebSocketClientHandshakerFactory.newHandshaker( uri, WebSocketVersion.V13, null, true, httpHeaders );
             final WebsocketConnection connection = new WebsocketConnection( environment, api, handshaker, address );
 
             new Bootstrap()
@@ -190,7 +191,12 @@ public final class WebsocketConnector
                     {
                         ChannelPipeline p = ch.pipeline();
                         if( ssl != null ) p.addLast( ssl.newHandler( ch.alloc(), uri.getHost(), port ) );
-                        p.addLast( new HttpClientCodec(), new HttpObjectAggregator( 8192 ), connection );
+                        p.addLast(
+                            new HttpClientCodec(),
+                            new HttpObjectAggregator( 8192 ),
+                            WebSocketClientCompressionHandler.INSTANCE,
+                            connection
+                        );
                     }
                 } )
                 .remoteAddress( socketAddress )

src/main/java/dan200/computercraft/core/computer/Computer.java

@@ -20,6 +20,8 @@ import dan200.computercraft.core.filesystem.FileSystemException;
 import dan200.computercraft.core.lua.CobaltLuaMachine;
 import dan200.computercraft.core.lua.ILuaMachine;
 import dan200.computercraft.core.terminal.Terminal;
+import dan200.computercraft.core.tracking.Tracking;
+import dan200.computercraft.core.tracking.TrackingField;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -167,6 +169,12 @@ public class Computer
             m_computer.setLabel( label );
         }
 
+        @Override
+        public void addTrackingChange( TrackingField field, long change )
+        {
+            Tracking.addValue( m_computer, field, change );
+        }
+
         public void onPeripheralChanged( int side, IPeripheral peripheral )
         {
             synchronized( m_computer.m_peripherals )

src/main/java/dan200/computercraft/core/computer/ComputerThread.java

@@ -7,6 +7,7 @@
 package dan200.computercraft.core.computer;
 
 import dan200.computercraft.ComputerCraft;
+import dan200.computercraft.core.tracking.Tracking;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -68,17 +69,17 @@ public class ComputerThread
             s_stopped = false;
             if( s_threads == null || s_threads.length != ComputerCraft.computer_threads )
             {
-                s_threads = new Thread[ ComputerCraft.computer_threads ];
+                s_threads = new Thread[ComputerCraft.computer_threads];
             }
 
             SecurityManager manager = System.getSecurityManager();
             final ThreadGroup group = manager == null ? Thread.currentThread().getThreadGroup() : manager.getThreadGroup();
             for( int i = 0; i < s_threads.length; i++ )
             {
-                Thread thread = s_threads[ i ];
+                Thread thread = s_threads[i];
                 if( thread == null || !thread.isAlive() )
                 {
-                    thread = s_threads[ i ] = new Thread( group, new TaskExecutor(), "ComputerCraft-Computer-Manager-" + s_ManagerCounter.getAndIncrement() );
+                    thread = s_threads[i] = new Thread( group, new TaskExecutor(), "ComputerCraft-Computer-Manager-" + s_ManagerCounter.getAndIncrement() );
                     thread.setDaemon( true );
                     thread.start();
                 }
@@ -223,6 +224,23 @@ public class ComputerThread
                     // Interrupt the thread
                     if( !done )
                     {
+                        StringBuilder builder = new StringBuilder( "Terminating " );
+                        if( computer != null )
+                        {
+                            builder.append( "computer " ).append( computer.getID() );
+                        }
+                        else
+                        {
+                            builder.append( "unknown computer" );
+                        }
+
+                        builder.append( ". Thread is currently running" );
+                        for( StackTraceElement element : thread.getStackTrace() )
+                        {
+                            builder.append( "\n  at " ).append( element );
+                        }
+                        ComputerCraft.log.error( builder.toString() );
+
                         thread.interrupt();
                         thread = null;
                         runner = null;
@@ -233,8 +251,8 @@ public class ComputerThread
             {
                 long stop = System.nanoTime();
                 Computer computer = task.getOwner();
-                if( computer != null ) ComputerTimeTracker.addTiming( computer, stop - start );
-                
+                if( computer != null ) Tracking.addTaskTiming( computer, stop - start );
+
                 // Re-add it back onto the queue or remove it
                 synchronized( s_taskLock )
                 {

src/main/java/dan200/computercraft/core/computer/ComputerTimeTracker.java

@@ -1,116 +0,0 @@
-package dan200.computercraft.core.computer;
-
-import com.google.common.collect.MapMaker;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import java.lang.ref.WeakReference;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Tracks timing information about computers, including how long they ran for
- * and the number of events they handled.
- *
- * Note that this <em>will</em> track computers which have been deleted (hence
- * the presence of {@link #timingLookup} and {@link #timings}
- */
-public class ComputerTimeTracker
-{
-    public static class Timings
-    {
-        private final WeakReference<Computer> computer;
-        private final int computerId;
-
-        private int tasks;
-
-        private long totalTime;
-        private long maxTime;
-
-        public Timings( @Nonnull Computer computer )
-        {
-            this.computer = new WeakReference<>( computer );
-            this.computerId = computer.getID();
-        }
-
-        @Nullable
-        public Computer getComputer()
-        {
-            return computer.get();
-        }
-
-        public int getComputerId()
-        {
-            return computerId;
-        }
-
-        public int getTasks()
-        {
-            return tasks;
-        }
-
-        public long getTotalTime()
-        {
-            return totalTime;
-        }
-
-        public long getMaxTime()
-        {
-            return maxTime;
-        }
-
-        public double getAverage()
-        {
-            return totalTime / (double) tasks;
-        }
-
-        void update( long time )
-        {
-            tasks++;
-            totalTime += time;
-            if( time > maxTime ) maxTime = time;
-        }
-    }
-
-    private static boolean tracking;
-    private static final List<Timings> timings = new ArrayList<>();
-    private static final Map<Computer, Timings> timingLookup = new MapMaker().weakKeys().makeMap();
-
-    public synchronized static void start()
-    {
-        tracking = true;
-
-        timings.clear();
-        timingLookup.clear();
-    }
-
-    public synchronized static boolean stop()
-    {
-        if( !tracking ) return false;
-
-        tracking = false;
-        timingLookup.clear();
-        return true;
-    }
-
-    public static synchronized List<Timings> getTimings()
-    {
-        return new ArrayList<>( timings );
-    }
-
-    public static synchronized void addTiming( Computer computer, long time )
-    {
-        if( !tracking ) return;
-
-        Timings timings = ComputerTimeTracker.timingLookup.get( computer );
-        if( timings == null )
-        {
-            timings = new Timings( computer );
-            timingLookup.put( computer, timings );
-            ComputerTimeTracker.timings.add( timings );
-        }
-
-        timings.update( time );
-    }
-}

src/main/java/dan200/computercraft/core/computer/IComputerOwned.java

@@ -0,0 +1,9 @@
+package dan200.computercraft.core.computer;
+
+import javax.annotation.Nullable;
+
+public interface IComputerOwned
+{
+    @Nullable
+    Computer getComputer();
+}

src/main/java/dan200/computercraft/core/computer/MainThread.java

@@ -6,14 +6,17 @@
 
 package dan200.computercraft.core.computer;
 
-import java.util.LinkedList;
+import dan200.computercraft.core.tracking.Tracking;
+
+import java.util.ArrayDeque;
+import java.util.Queue;
 
 public class MainThread
 {
     private static final int MAX_TASKS_PER_TICK = 1000;
     private static final int MAX_TASKS_TOTAL = 50000;
 
-    private static final LinkedList<ITask> m_outstandingTasks = new LinkedList<>();
+    private static final Queue<ITask> m_outstandingTasks = new ArrayDeque<>();
     private static final Object m_nextUnusedTaskIDLock = new Object();
     private static long m_nextUnusedTaskID = 0;
 
@@ -31,7 +34,7 @@ public class MainThread
         {
             if( m_outstandingTasks.size() < MAX_TASKS_TOTAL )
             {
-                m_outstandingTasks.addLast( task );
+                m_outstandingTasks.offer( task );
                 return true;
             }
         }
@@ -46,14 +49,17 @@ public class MainThread
             ITask task = null;
             synchronized( m_outstandingTasks )
             {
-                if( m_outstandingTasks.size() > 0 )
-                {
-                    task = m_outstandingTasks.removeFirst();
-                }
+                task = m_outstandingTasks.poll();
             }
             if( task != null )
             {
+                long start = System.nanoTime();
                 task.execute();
+
+                long stop = System.nanoTime();
+                Computer computer = task.getOwner();
+                if( computer != null ) Tracking.addServerTiming( computer, stop - start );
+
                 ++tasksThisTick;
             }
             else

src/main/java/dan200/computercraft/core/tracking/ComputerTracker.java

@@ -0,0 +1,117 @@
+package dan200.computercraft.core.tracking;
+
+import dan200.computercraft.core.computer.Computer;
+import gnu.trove.map.hash.TObjectLongHashMap;
+
+import javax.annotation.Nullable;
+import java.lang.ref.WeakReference;
+
+public class ComputerTracker
+{
+    private final WeakReference<Computer> computer;
+    private final int computerId;
+
+    private long tasks;
+    private long totalTime;
+    private long maxTime;
+
+    private long serverCount;
+    private long serverTime;
+
+    private final TObjectLongHashMap<TrackingField> fields;
+
+    public ComputerTracker( Computer computer )
+    {
+        this.computer = new WeakReference<>( computer );
+        this.computerId = computer.getID();
+        this.fields = new TObjectLongHashMap<>();
+    }
+
+    ComputerTracker( ComputerTracker timings )
+    {
+        this.computer = timings.computer;
+        this.computerId = timings.computerId;
+
+        this.tasks = timings.tasks;
+        this.totalTime = timings.totalTime;
+        this.maxTime = timings.maxTime;
+
+        this.serverCount = timings.serverCount;
+        this.serverTime = timings.serverTime;
+
+        this.fields = new TObjectLongHashMap<>( timings.fields );
+    }
+
+    @Nullable
+    public Computer getComputer()
+    {
+        return computer.get();
+    }
+
+    public int getComputerId()
+    {
+        return computerId;
+    }
+
+    public long getTasks()
+    {
+        return tasks;
+    }
+
+    public long getTotalTime()
+    {
+        return totalTime;
+    }
+
+    public long getMaxTime()
+    {
+        return maxTime;
+    }
+
+    public long getAverage()
+    {
+        return totalTime / tasks;
+    }
+
+    void addTaskTiming( long time )
+    {
+        tasks++;
+        totalTime += time;
+        if( time > maxTime ) maxTime = time;
+    }
+
+    void addMainTiming( long time )
+    {
+        serverCount++;
+        serverTime += time;
+    }
+
+    void addValue( TrackingField field, long change )
+    {
+        synchronized( fields )
+        {
+            fields.adjustOrPutValue( field, change, change );
+        }
+    }
+
+    public long get( TrackingField field )
+    {
+        if( field == TrackingField.TASKS ) return tasks;
+        if( field == TrackingField.MAX_TIME ) return maxTime;
+        if( field == TrackingField.TOTAL_TIME ) return totalTime;
+        if( field == TrackingField.AVERAGE_TIME ) return tasks == 0 ? 0 : totalTime / tasks;
+
+        if( field == TrackingField.SERVER_COUNT ) return serverCount;
+        if( field == TrackingField.SERVER_TIME ) return serverTime;
+
+        synchronized( fields )
+        {
+            return fields.get( field );
+        }
+    }
+
+    public String getFormatted( TrackingField field )
+    {
+        return field.format( get( field ) );
+    }
+}

src/main/java/dan200/computercraft/core/tracking/Tracker.java

@@ -0,0 +1,49 @@
+package dan200.computercraft.core.tracking;
+
+import dan200.computercraft.core.computer.Computer;
+
+public interface Tracker
+{
+    @Deprecated
+    default void addTiming( Computer computer, long time )
+    {
+    }
+
+    /**
+     * Report how long a task executed on the computer thread took.
+     *
+     * Computer thread tasks include events or a computer being turned on/off.
+     *
+     * @param computer The computer processing this task
+     * @param time     The time taken for this task.
+     */
+    default void addTaskTiming( Computer computer, long time )
+    {
+        //noinspection deprecation
+        addTiming( computer, time );
+    }
+
+    /**
+     * Report how long a task executed on the server thread took.
+     *
+     * Server tasks include actions performed by peripherals.
+     *
+     * @param computer The computer processing this task
+     * @param time     The time taken for this task.
+     */
+    default void addServerTiming( Computer computer, long time )
+    {
+    }
+
+    /**
+     * Increment an arbitrary field by some value. Implementations may track how often this is called
+     * as well as the change, to compute some level of "average".
+     *
+     * @param computer The computer to increment
+     * @param field    The field to increment.
+     * @param change   The amount to increment said field by.
+     */
+    default void addValue( Computer computer, TrackingField field, long change )
+    {
+    }
+}

src/main/java/dan200/computercraft/core/tracking/Tracking.java

@@ -0,0 +1,80 @@
+package dan200.computercraft.core.tracking;
+
+import dan200.computercraft.core.computer.Computer;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class Tracking
+{
+    static final AtomicInteger tracking = new AtomicInteger( 0 );
+
+    private static final Object lock = new Object();
+    private static final HashMap<UUID, TrackingContext> contexts = new HashMap<>();
+    private static final List<Tracker> trackers = new ArrayList<>();
+
+    public static TrackingContext getContext( UUID uuid )
+    {
+        synchronized( lock )
+        {
+            TrackingContext context = contexts.get( uuid );
+            if( context == null ) contexts.put( uuid, context = new TrackingContext() );
+            return context;
+        }
+    }
+
+    public static void add( Tracker tracker )
+    {
+        synchronized( lock )
+        {
+            trackers.add( tracker );
+            tracking.incrementAndGet();
+        }
+    }
+
+    public static void addTaskTiming( Computer computer, long time )
+    {
+        if( tracking.get() == 0 ) return;
+
+        synchronized( contexts )
+        {
+            for( TrackingContext context : contexts.values() ) context.addTaskTiming( computer, time );
+            for( Tracker tracker : trackers ) tracker.addTaskTiming( computer, time );
+        }
+    }
+
+    public static void addServerTiming( Computer computer, long time )
+    {
+        if( tracking.get() == 0 ) return;
+
+        synchronized( contexts )
+        {
+            for( TrackingContext context : contexts.values() ) context.addServerTiming( computer, time );
+            for( Tracker tracker : trackers ) tracker.addServerTiming( computer, time );
+        }
+    }
+
+    public static void addValue( Computer computer, TrackingField field, long change )
+    {
+        if( tracking.get() == 0 ) return;
+
+        synchronized( lock )
+        {
+            for( TrackingContext context : contexts.values() ) context.addValue( computer, field, change );
+            for( Tracker tracker : trackers ) tracker.addValue( computer, field, change );
+        }
+    }
+
+    public static void reset()
+    {
+        synchronized( lock )
+        {
+            contexts.clear();
+            trackers.clear();
+            tracking.set( 0 );
+        }
+    }
+}

src/main/java/dan200/computercraft/core/tracking/TrackingContext.java

@@ -0,0 +1,111 @@
+package dan200.computercraft.core.tracking;
+
+import com.google.common.collect.MapMaker;
+import dan200.computercraft.core.computer.Computer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Tracks timing information about computers, including how long they ran for
+ * and the number of events they handled.
+ *
+ * Note that this <em>will</em> track computers which have been deleted (hence
+ * the presence of {@link #timingLookup} and {@link #timings}
+ */
+public class TrackingContext implements Tracker
+{
+    private boolean tracking = false;
+
+    private final List<ComputerTracker> timings = new ArrayList<>();
+    private final Map<Computer, ComputerTracker> timingLookup = new MapMaker().weakKeys().makeMap();
+
+    public synchronized void start()
+    {
+        if( !tracking ) Tracking.tracking.incrementAndGet();
+        tracking = true;
+
+        timings.clear();
+        timingLookup.clear();
+    }
+
+    public synchronized boolean stop()
+    {
+        if( !tracking ) return false;
+
+        Tracking.tracking.decrementAndGet();
+        tracking = false;
+        timingLookup.clear();
+        return true;
+    }
+
+    public synchronized List<ComputerTracker> getImmutableTimings()
+    {
+        ArrayList<ComputerTracker> timings = new ArrayList<>( this.timings.size() );
+        for( ComputerTracker timing : this.timings ) timings.add( new ComputerTracker( timing ) );
+        return timings;
+    }
+
+    public synchronized List<ComputerTracker> getTimings()
+    {
+        return new ArrayList<>( timings );
+    }
+
+    @Override
+    public void addTaskTiming( Computer computer, long time )
+    {
+        if( !tracking ) return;
+
+        synchronized( this )
+        {
+            ComputerTracker computerTimings = timingLookup.get( computer );
+            if( computerTimings == null )
+            {
+                computerTimings = new ComputerTracker( computer );
+                timingLookup.put( computer, computerTimings );
+                timings.add( computerTimings );
+            }
+
+            computerTimings.addTaskTiming( time );
+        }
+    }
+
+    @Override
+    public void addServerTiming( Computer computer, long time )
+    {
+        if( !tracking ) return;
+
+        synchronized( this )
+        {
+            ComputerTracker computerTimings = timingLookup.get( computer );
+            if( computerTimings == null )
+            {
+                computerTimings = new ComputerTracker( computer );
+                timingLookup.put( computer, computerTimings );
+                timings.add( computerTimings );
+            }
+
+            computerTimings.addMainTiming( time );
+        }
+    }
+
+    @Override
+    public void addValue( Computer computer, TrackingField field, long change )
+    {
+        if( !tracking ) return;
+
+        synchronized( this )
+        {
+            ComputerTracker computerTimings = timingLookup.get( computer );
+            if( computerTimings == null )
+            {
+                computerTimings = new ComputerTracker( computer );
+                timingLookup.put( computer, computerTimings );
+                timings.add( computerTimings );
+            }
+
+            computerTimings.addValue( field, change );
+        }
+    }
+}

src/main/java/dan200/computercraft/core/tracking/TrackingField.java

@@ -0,0 +1,88 @@
+package dan200.computercraft.core.tracking;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.LongFunction;
+
+public class TrackingField
+{
+    private static final Map<String, TrackingField> fields = new HashMap<>();
+
+    public static final TrackingField TASKS = TrackingField.of( "tasks", "Tasks", x -> String.format( "%4d", x ) );
+    public static final TrackingField TOTAL_TIME = TrackingField.of( "total", "Total time", x -> String.format( "%7.1fms", x / 1e6 ) );
+    public static final TrackingField AVERAGE_TIME = TrackingField.of( "average", "Average time", x -> String.format( "%4.1fms", x / 1e6 ) );
+    public static final TrackingField MAX_TIME = TrackingField.of( "max", "Max time", x -> String.format( "%5.1fms", x / 1e6 ) );
+
+    public static final TrackingField SERVER_COUNT = TrackingField.of( "server_count", "Server task count", x -> String.format( "%4d", x ) );
+    public static final TrackingField SERVER_TIME = TrackingField.of( "server_time", "Server task time", x -> String.format( "%7.1fms", x / 1e6 ) );
+
+    public static final TrackingField PERIPHERAL_OPS = TrackingField.of( "peripheral", "Peripheral calls", TrackingField::formatDefault );
+    public static final TrackingField FS_OPS = TrackingField.of( "fs", "Filesystem operations", TrackingField::formatDefault );
+    public static final TrackingField TURTLE_OPS = TrackingField.of( "turtle", "Turtle operations", TrackingField::formatDefault );
+
+    public static final TrackingField HTTP_REQUESTS = TrackingField.of( "http", "HTTP requests", TrackingField::formatDefault );
+    public static final TrackingField HTTP_UPLOAD = TrackingField.of( "http_upload", "HTTP upload", TrackingField::formatBytes );
+    public static final TrackingField HTTP_DOWNLOAD = TrackingField.of( "http_download", "HTTT download", TrackingField::formatBytes );
+
+    public static final TrackingField WEBSOCKET_INCOMING = TrackingField.of( "websocket_incoming", "Websocket incoming", TrackingField::formatBytes );
+    public static final TrackingField WEBSOCKET_OUTGOING = TrackingField.of( "websocket_outgoing", "Websocket outgoing", TrackingField::formatBytes );
+
+    private final String id;
+    private final String displayName;
+    private final LongFunction<String> format;
+
+    public String id()
+    {
+        return id;
+    }
+
+    public String displayName()
+    {
+        return displayName;
+    }
+
+    private TrackingField( String id, String displayName, LongFunction<String> format )
+    {
+        this.id = id;
+        this.displayName = displayName;
+        this.format = format;
+    }
+
+    public String format( long value )
+    {
+        return format.apply( value );
+    }
+
+    public static TrackingField of( String id, String displayName, LongFunction<String> format )
+    {
+        TrackingField field = new TrackingField( id, displayName, format );
+        fields.put( id, field );
+        return field;
+    }
+
+    public static Map<String, TrackingField> fields()
+    {
+        return Collections.unmodifiableMap( fields );
+    }
+
+    private static String formatDefault( long value )
+    {
+        return String.format( "%6d", value );
+    }
+
+    /**
+     * So technically a kibibyte, but let's not argue here.
+     */
+    private static final int KILOBYTE_SIZE = 1024;
+
+    private static final String SI_PREFIXES = "KMGT";
+
+    private static String formatBytes( long bytes )
+    {
+        if( bytes < 1024 ) return String.format( "%10d B", bytes );
+        int exp = (int) (Math.log( bytes ) / Math.log( KILOBYTE_SIZE ));
+        if( exp > SI_PREFIXES.length() ) exp = SI_PREFIXES.length();
+        return String.format( "%10.1f %siB", bytes / Math.pow( KILOBYTE_SIZE, exp ), SI_PREFIXES.charAt( exp - 1 ) );
+    }
+}

src/main/java/dan200/computercraft/shared/command/CommandComputerCraft.java

@@ -4,9 +4,13 @@ import com.google.common.collect.Sets;
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.core.computer.Computer;
-import dan200.computercraft.core.computer.ComputerTimeTracker;
+import dan200.computercraft.core.tracking.ComputerTracker;
+import dan200.computercraft.core.tracking.Tracking;
+import dan200.computercraft.core.tracking.TrackingContext;
+import dan200.computercraft.core.tracking.TrackingField;
 import dan200.computercraft.shared.command.framework.*;
 import dan200.computercraft.shared.computer.core.ServerComputer;
+import net.minecraft.command.CommandBase;
 import net.minecraft.command.CommandException;
 import net.minecraft.command.ICommandSender;
 import net.minecraft.entity.Entity;
@@ -16,7 +20,6 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.text.ITextComponent;
 import net.minecraft.util.text.TextComponentString;
 import net.minecraft.world.World;
-import net.minecraftforge.common.util.FakePlayer;
 
 import javax.annotation.Nonnull;
 import java.util.*;
@@ -25,6 +28,12 @@ import static dan200.computercraft.shared.command.framework.ChatHelpers.*;
 
 public final class CommandComputerCraft extends CommandDelegate
 {
+    public static final UUID SYSTEM_UUID = new UUID( 0, 0 );
+
+    private static final int DUMP_LIST_ID = 5373952;
+    private static final int DUMP_SINGLE_ID = 1844510720;
+    private static final int TRACK_ID = 373882880;
+
     public CommandComputerCraft()
     {
         super( create() );
@@ -49,7 +58,7 @@ public final class CommandComputerCraft extends CommandDelegate
             {
                 if( arguments.size() == 0 )
                 {
-                    TextTable table = new TextTable( "Instance", "Id", "On", "Position" );
+                    TextTable table = new TextTable( DUMP_LIST_ID, "Computer", "On", "Position" );
 
                     List<ServerComputer> computers = new ArrayList<>( ComputerCraft.serverComputerRegistry.getComputers() );
 
@@ -82,8 +91,7 @@ public final class CommandComputerCraft extends CommandDelegate
                     for( ServerComputer computer : computers )
                     {
                         table.addRow(
-                            linkComputer( computer ),
-                            text( Integer.toString( computer.getID() ) ),
+                            linkComputer( context, computer, computer.getID() ),
                             bool( computer.isOn() ),
                             linkPosition( context, computer )
                         );
@@ -95,7 +103,7 @@ public final class CommandComputerCraft extends CommandDelegate
                 {
                     ServerComputer computer = ComputerSelector.getComputer( arguments.get( 0 ) );
 
-                    TextTable table = new TextTable();
+                    TextTable table = new TextTable( DUMP_SINGLE_ID );
                     table.addRow( header( "Instance" ), text( Integer.toString( computer.getInstanceID() ) ) );
                     table.addRow( header( "Id" ), text( Integer.toString( computer.getID() ) ) );
                     table.addRow( header( "Label" ), text( computer.getLabel() ) );
@@ -311,7 +319,7 @@ public final class CommandComputerCraft extends CommandDelegate
             @Override
             public void execute( @Nonnull CommandContext context, @Nonnull List<String> arguments )
             {
-                ComputerTimeTracker.start();
+                getTimingContext( context ).start();
 
                 String stopCommand = "/" + context.parent().getFullPath() + " stop";
                 context.getSender().sendMessage( list(
@@ -330,23 +338,54 @@ public final class CommandComputerCraft extends CommandDelegate
             @Override
             public void execute( @Nonnull CommandContext context, @Nonnull List<String> arguments ) throws CommandException
             {
-                if( !ComputerTimeTracker.stop() ) throw new CommandException( "Tracking not enabled" );
-                displayTimings( context );
+                TrackingContext timings = getTimingContext( context );
+                if( !timings.stop() ) throw new CommandException( "Tracking not enabled" );
+                displayTimings( context, timings.getImmutableTimings(), TrackingField.AVERAGE_TIME );
             }
         } );
 
         track.register( new SubCommandBase(
-            "dump", "Dump the latest track results", UserLevel.OWNER_OP,
+            "dump", "[kind]", "Dump the latest track results", UserLevel.OWNER_OP,
             "Dump the latest results of computer tracking."
         )
         {
             @Override
             public void execute( @Nonnull CommandContext context, @Nonnull List<String> arguments ) throws CommandException
             {
-                displayTimings( context );
+                TrackingField field = TrackingField.AVERAGE_TIME;
+                if( arguments.size() >= 1 )
+                {
+                    field = TrackingField.fields().get( arguments.get( 0 ) );
+                    if( field == null ) throw new CommandException( "Unknown field '" + arguments.get( 0 ) + "'" );
+                }
+
+                displayTimings( context, getTimingContext( context ).getImmutableTimings(), field );
+            }
+
+            @Nonnull
+            @Override
+            public List<String> getCompletion( @Nonnull CommandContext context, @Nonnull List<String> arguments )
+            {
+                if( arguments.size() == 1 )
+                {
+                    String match = arguments.get( 0 );
+
+                    List<String> out = new ArrayList<>();
+                    for( String key : TrackingField.fields().keySet() )
+                    {
+                        if( CommandBase.doesStringStartWith( match, key ) ) out.add( key );
+                    }
+
+                    out.sort( Comparator.naturalOrder() );
+                    return out;
+                }
+                else
+                {
+                    return super.getCompletion( context, arguments );
+                }
             }
         } );
-        
+
         root.register( new SubCommandBase(
             "reload", "Reload the ComputerCraft config file", UserLevel.OWNER_OP,
             "Reload the ComputerCraft config file"
@@ -365,13 +404,46 @@ public final class CommandComputerCraft extends CommandDelegate
         return root;
     }
 
-    private static ITextComponent linkComputer( ServerComputer computer )
+    private static ITextComponent linkComputer( CommandContext context, ServerComputer serverComputer, int computerId )
     {
-        return link(
-            text( Integer.toString( computer.getInstanceID() ) ),
-            "/computercraft dump " + computer.getInstanceID(),
-            "View more info about this computer"
-        );
+        ITextComponent out = new TextComponentString( "" );
+
+        // Append the computer instance
+        if( serverComputer == null )
+        {
+            out.appendSibling( text( "?" ) );
+        }
+        else
+        {
+            out.appendSibling( link(
+                text( Integer.toString( serverComputer.getInstanceID() ) ),
+                "/computercraft dump " + serverComputer.getInstanceID(),
+                "View more info about this computer"
+            ) );
+        }
+
+        // And ID
+        out.appendText( " (id " + computerId + ")" );
+
+        // And, if we're a player, some useful links
+        if( serverComputer != null && UserLevel.OP.canExecute( context ) && context.fromPlayer() )
+        {
+            out
+                .appendText( " " )
+                .appendSibling( link(
+                    text( "\u261b" ),
+                    "/computercraft tp " + serverComputer.getInstanceID(),
+                    "Teleport to this computer"
+                ) )
+                .appendText( " " )
+                .appendSibling( link(
+                    text( "\u20e2" ),
+                    "/computercraft view " + serverComputer.getInstanceID(),
+                    "View this computer"
+                ) );
+        }
+
+        return out;
     }
 
     private static ITextComponent linkPosition( CommandContext context, ServerComputer computer )
@@ -390,13 +462,22 @@ public final class CommandComputerCraft extends CommandDelegate
         }
     }
 
-    private static void displayTimings( CommandContext context ) throws CommandException
+    private static TrackingContext getTimingContext( CommandContext context )
     {
-        List<ComputerTimeTracker.Timings> timings = ComputerTimeTracker.getTimings();
-        if( timings.isEmpty() ) throw new CommandException( "No timings available" );
+        Entity entity = context.getSender().getCommandSenderEntity();
+        if( entity instanceof EntityPlayerMP )
+        {
+            return Tracking.getContext( entity.getUniqueID() );
+        }
+        else
+        {
+            return Tracking.getContext( SYSTEM_UUID );
+        }
+    }
 
-        timings.sort( Comparator.comparing( ComputerTimeTracker.Timings::getAverage ).reversed() );
-        TextTable table = new TextTable( "Computer", "Tasks", "Total", "Average", "Maximum" );
+    private static void displayTimings( CommandContext context, List<ComputerTracker> timings, TrackingField field ) throws CommandException
+    {
+        if( timings.isEmpty() ) throw new CommandException( "No timings available" );
 
         Map<Computer, ServerComputer> lookup = new HashMap<>();
         int maxId = 0, maxInstance = 0;
@@ -409,41 +490,38 @@ public final class CommandComputerCraft extends CommandDelegate
         }
 
         ICommandSender sender = context.getSender();
-        boolean isPlayer = sender instanceof EntityPlayerMP && !(sender instanceof FakePlayer);
 
-        for( ComputerTimeTracker.Timings entry : timings )
+        timings.sort( Comparator.<ComputerTracker, Long>comparing( x -> x.get( field ) ).reversed() );
+
+        boolean defaultLayout = field == TrackingField.TASKS || field == TrackingField.TOTAL_TIME
+            || field == TrackingField.AVERAGE_TIME || field == TrackingField.MAX_TIME;
+
+
+        TextTable table = defaultLayout
+            ? new TextTable( TRACK_ID, "Computer", "Tasks", "Total", "Average", "Maximum" )
+            : new TextTable( TRACK_ID, "Computer", field.displayName() );
+
+        for( ComputerTracker entry : timings )
         {
             Computer computer = entry.getComputer();
             ServerComputer serverComputer = computer == null ? null : lookup.get( computer );
 
-            ITextComponent computerComponent = new TextComponentString( "" )
-                .appendSibling( serverComputer == null ? text( "?" ) : linkComputer( serverComputer ) )
-                .appendText( " (id " + entry.getComputerId() + ")" );
+            ITextComponent computerComponent = linkComputer( context, serverComputer, entry.getComputerId() );
 
-            if( serverComputer != null && UserLevel.OP.canExecute( context ) && isPlayer )
+            if( defaultLayout )
             {
-                computerComponent
-                    .appendText( " " )
-                    .appendSibling( link(
-                        text( "\u261b" ),
-                        "/computercraft tp " + serverComputer.getInstanceID(),
-                        "Teleport to this computer"
-                    ) )
-                    .appendText( " " )
-                    .appendSibling( link(
-                        text( "\u20e2" ),
-                        "/computercraft view " + serverComputer.getInstanceID(),
-                        "View this computer"
-                    ) );
+                table.addRow(
+                    computerComponent,
+                    text( entry.getFormatted( TrackingField.TASKS ) ),
+                    text( entry.getFormatted( TrackingField.TOTAL_TIME ) ),
+                    text( entry.getFormatted( TrackingField.AVERAGE_TIME ) ),
+                    text( entry.getFormatted( TrackingField.MAX_TIME ) )
+                );
+            }
+            else
+            {
+                table.addRow( computerComponent, text( entry.getFormatted( field ) ) );
             }
-
-            table.addRow(
-                computerComponent,
-                formatted( "%4d", entry.getTasks() ),
-                text( String.format( "%7.1f", entry.getTotalTime() / 1e6 ) + "ms" ),
-                text( String.format( "%4.1f", entry.getAverage() / 1e6 ) + "ms" ),
-                text( String.format( "%5.1f", entry.getMaxTime() / 1e6 ) + "ms" )
-            );
         }
 
         table.displayTo( context.getSender() );

src/main/java/dan200/computercraft/shared/command/ComputerSelector.java

@@ -46,7 +46,7 @@ public final class ComputerSelector
 
             for( int i = 0; i < computers.size(); i++ )
             {
-                if( i > 1 ) builder.append( ", " );
+                if( i > 0 ) builder.append( ", " );
                 builder.append( computers.get( i ).getInstanceID() );
             }
             builder.append( ")" );

src/main/java/dan200/computercraft/shared/command/framework/CommandContext.java

@@ -2,7 +2,9 @@ package dan200.computercraft.shared.command.framework;
 
 import com.google.common.collect.Lists;
 import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.server.MinecraftServer;
+import net.minecraftforge.common.util.FakePlayer;
 
 import java.util.Collections;
 import java.util.List;
@@ -90,4 +92,9 @@ public final class CommandContext
     {
         return sender;
     }
+
+    public boolean fromPlayer()
+    {
+        return sender instanceof EntityPlayerMP && !(sender instanceof FakePlayer);
+    }
 }

src/main/java/dan200/computercraft/shared/command/framework/TextFormatter.java

@@ -0,0 +1,147 @@
+package dan200.computercraft.shared.command.framework;
+
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TextComponentString;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.common.util.FakePlayer;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.Arrays;
+
+import static dan200.computercraft.shared.command.framework.ChatHelpers.coloured;
+
+/**
+ * Adapated from Sponge's PaginationCalculator
+ */
+public class TextFormatter
+{
+    private static final char PADDING_CHAR = '\u02cc';
+
+    /**
+     * Yoinked from FontRenderer
+     *
+     * @see net.minecraft.client.gui.FontRenderer#charWidth
+     * @see net.minecraft.client.gui.FontRenderer#getCharWidth(char)
+     */
+    private static final String CHARACTERS = "\u00c0\u00c1\u00c2\u00c8\u00ca\u00cb\u00cd\u00d3\u00d4\u00d5\u00da\u00df\u00e3\u00f5\u011f\u0130\u0131\u0152\u0153\u015e\u015f\u0174\u0175\u017e\u0207\u0000\u0000\u0000\u0000\u0000\u0000\u0000 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u0000\u00c7\u00fc\u00e9\u00e2\u00e4\u00e0\u00e5\u00e7\u00ea\u00eb\u00e8\u00ef\u00ee\u00ec\u00c4\u00c5\u00c9\u00e6\u00c6\u00f4\u00f6\u00f2\u00fb\u00f9\u00ff\u00d6\u00dc\u00f8\u00a3\u00d8\u00d7\u0192\u00e1\u00ed\u00f3\u00fa\u00f1\u00d1\u00aa\u00ba\u00bf\u00ae\u00ac\u00bd\u00bc\u00a1\u00ab\u00bb\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255d\u255c\u255b\u2510\u2514\u2534\u252c\u251c\u2500\u253c\u255e\u255f\u255a\u2554\u2569\u2566\u2560\u2550\u256c\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256b\u256a\u2518\u250c\u2588\u2584\u258c\u2590\u2580\u03b1\u03b2\u0393\u03c0\u03a3\u03c3\u03bc\u03c4\u03a6\u0398\u03a9\u03b4\u221e\u2205\u2208\u2229\u2261\u00b1\u2265\u2264\u2320\u2321\u00f7\u2248\u00b0\u2219\u00b7\u221a\u207f\u00b2\u25a0\u0000";
+    private static final int[] CHAR_WIDTHS = new int[]{
+        6, 6, 6, 6, 6, 6, 4, 6, 6, 6, 6, 6, 6, 6, 6, 4,
+        4, 6, 7, 6, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1,
+        1, 2, 5, 6, 6, 6, 6, 3, 5, 5, 5, 6, 2, 6, 2, 6,
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 5, 6, 5, 6,
+        7, 6, 6, 6, 6, 6, 6, 6, 6, 4, 6, 6, 6, 6, 6, 6,
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, 6, 4, 6, 6,
+        3, 6, 6, 6, 6, 6, 5, 6, 6, 2, 6, 5, 3, 6, 6, 6,
+        6, 6, 6, 6, 4, 6, 6, 6, 6, 6, 6, 5, 2, 5, 7, 6,
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, 6, 3, 6, 6,
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, 6,
+        6, 3, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 2, 6, 6,
+        8, 9, 9, 6, 6, 6, 8, 8, 6, 8, 8, 8, 8, 8, 6, 6,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 6, 9, 9, 9, 5, 9, 9,
+        8, 7, 7, 8, 7, 8, 8, 8, 7, 8, 8, 7, 9, 9, 6, 7,
+        7, 7, 7, 7, 9, 6, 7, 8, 7, 6, 6, 9, 7, 6, 7, 1
+    };
+
+    private static final int[] EXTRA_CHARS = new int[]{
+        '\u20e2', '\u261b',
+    };
+
+    private static final byte[] EXTRA_WIDTHS = new byte[]{
+        8, 4,
+    };
+
+    public static int getWidth( int codePoint )
+    {
+        // Escape codes
+        if( codePoint == 167 ) return -1;
+
+        // Space and non-breaking space
+        if( codePoint == 32 || codePoint == 160 ) return 4;
+
+        // Built-in characters
+        int nonUnicodeIdx = CHARACTERS.indexOf( codePoint );
+        if( codePoint > 0 && nonUnicodeIdx != -1 ) return CHAR_WIDTHS[nonUnicodeIdx];
+
+        // Other special characters we use.
+        int extraIdx = Arrays.binarySearch( EXTRA_CHARS, codePoint );
+        if( extraIdx >= 0 ) return EXTRA_WIDTHS[extraIdx];
+
+        return 0;
+    }
+
+    public static int getWidth( ITextComponent component )
+    {
+        int total = 0;
+        if( component instanceof TextComponentString )
+        {
+            String contents = component.getUnformattedComponentText();
+
+            int bold = component.getStyle().getBold() ? 1 : 0;
+            for( int i = 0; i < contents.length(); i++ )
+            {
+                int cp = contents.charAt( i );
+                assert cp != '\n';
+                int width = getWidth( cp );
+                if( width < 0 )
+                {
+                    i++;
+                }
+                else
+                {
+                    total += width + bold;
+                }
+            }
+        }
+
+        for( ITextComponent child : component.getSiblings() )
+        {
+            total += getWidth( child );
+        }
+
+        return total;
+    }
+
+    public static boolean isPlayer( ICommandSender sender )
+    {
+        return sender instanceof EntityPlayerMP && !(sender instanceof FakePlayer);
+    }
+
+    public static int getMaxWidth( ICommandSender sender )
+    {
+        return isPlayer( sender ) ? 320 : 80;
+    }
+
+    public static int getWidthFor( ITextComponent component, ICommandSender sender )
+    {
+        return isPlayer( sender ) ? getWidth( component ) : component.getUnformattedText().length();
+    }
+
+    public static int getWidthFor( int codepoint, ICommandSender sender )
+    {
+        return isPlayer( sender ) ? getWidth( codepoint ) : 1;
+    }
+
+    public static void appendFixedWidth( ITextComponent out, ICommandSender sender, ITextComponent entry, int maxWidth )
+    {
+        out.appendSibling( entry );
+
+        int width = getWidthFor( entry, sender );
+        int delta = maxWidth - width;
+
+        int spaceWidth = getWidthFor( ' ', sender );
+        int spaces = delta / spaceWidth;
+        int extra = delta % spaces;
+
+        // Append a fixed number of spaces
+        if( spaces > 0 ) out.appendSibling( new TextComponentString( StringUtils.repeat( ' ', spaces ) ) );
+
+        // Append several minor characters to pad to a full string 
+        if( extra > 0 )
+        {
+            out.appendSibling( coloured( StringUtils.repeat( PADDING_CHAR, extra ), TextFormatting.GRAY ) );
+        }
+    }
+}

src/main/java/dan200/computercraft/shared/command/framework/TextTable.java

@@ -1,113 +1,49 @@
 package dan200.computercraft.shared.command.framework;
 
 import com.google.common.collect.Lists;
+import dan200.computercraft.ComputerCraft;
+import dan200.computercraft.shared.network.ComputerCraftPacket;
 import net.minecraft.command.ICommandSender;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.util.text.ITextComponent;
 import net.minecraft.util.text.TextComponentString;
 import net.minecraft.util.text.TextFormatting;
-import net.minecraftforge.common.util.FakePlayer;
 import org.apache.commons.lang3.StringUtils;
 
 import javax.annotation.Nonnull;
+import java.util.ArrayList;
 import java.util.List;
 
 import static dan200.computercraft.shared.command.framework.ChatHelpers.coloured;
 import static dan200.computercraft.shared.command.framework.ChatHelpers.text;
+import static dan200.computercraft.shared.command.framework.TextFormatter.*;
 
 public class TextTable
 {
-    private static final String CHARACTERS = "\u00c0\u00c1\u00c2\u00c8\u00ca\u00cb\u00cd\u00d3\u00d4\u00d5\u00da\u00df\u00e3\u00f5\u011f\u0130\u0131\u0152\u0153\u015e\u015f\u0174\u0175\u017e\u0207\u0000\u0000\u0000\u0000\u0000\u0000\u0000 !\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u0000\u00c7\u00fc\u00e9\u00e2\u00e4\u00e0\u00e5\u00e7\u00ea\u00eb\u00e8\u00ef\u00ee\u00ec\u00c4\u00c5\u00c9\u00e6\u00c6\u00f4\u00f6\u00f2\u00fb\u00f9\u00ff\u00d6\u00dc\u00f8\u00a3\u00d8\u00d7\u0192\u00e1\u00ed\u00f3\u00fa\u00f1\u00d1\u00aa\u00ba\u00bf\u00ae\u00ac\u00bd\u00bc\u00a1\u00ab\u00bb\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255d\u255c\u255b\u2510\u2514\u2534\u252c\u251c\u2500\u253c\u255e\u255f\u255a\u2554\u2569\u2566\u2560\u2550\u256c\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256b\u256a\u2518\u250c\u2588\u2584\u258c\u2590\u2580\u03b1\u03b2\u0393\u03c0\u03a3\u03c3\u03bc\u03c4\u03a6\u0398\u03a9\u03b4\u221e\u2205\u2208\u2229\u2261\u00b1\u2265\u2264\u2320\u2321\u00f7\u2248\u00b0\u2219\u00b7\u221a\u207f\u00b2\u25a0\u0000";
-    private static final int[] CHAR_WIDTHS = new int[]{
-        6, 6, 6, 6, 6, 6, 4, 6, 6, 6, 6, 6, 6, 6, 6, 4,
-        4, 6, 7, 6, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1,
-        1, 2, 5, 6, 6, 6, 6, 3, 5, 5, 5, 6, 2, 6, 2, 6,
-        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 5, 6, 5, 6,
-        7, 6, 6, 6, 6, 6, 6, 6, 6, 4, 6, 6, 6, 6, 6, 6,
-        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, 6, 4, 6, 6,
-        3, 6, 6, 6, 6, 6, 5, 6, 6, 2, 6, 5, 3, 6, 6, 6,
-        6, 6, 6, 6, 4, 6, 6, 6, 6, 6, 6, 5, 2, 5, 7, 6,
-        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, 6, 3, 6, 6,
-        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, 6,
-        6, 3, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 2, 6, 6,
-        8, 9, 9, 6, 6, 6, 8, 8, 6, 8, 8, 8, 8, 8, 6, 6,
-        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
-        9, 9, 9, 9, 9, 9, 9, 9, 9, 6, 9, 9, 9, 5, 9, 9,
-        8, 7, 7, 8, 7, 8, 8, 8, 7, 8, 8, 7, 9, 9, 6, 7,
-        7, 7, 7, 7, 9, 6, 7, 8, 7, 6, 6, 9, 7, 6, 7, 1
-    };
-
-    private static final ITextComponent SEPARATOR = coloured( " | ", TextFormatting.GRAY );
+    private static final ITextComponent SEPARATOR = coloured( "| ", TextFormatting.GRAY );
     private static final ITextComponent LINE = text( "\n" );
 
-    private static int getWidth( char character, ICommandSender sender )
-    {
-        if( sender instanceof EntityPlayerMP && !(sender instanceof FakePlayer) )
-        {
-            // Use font widths here.
-            if( character == 167 )
-            {
-                return -1;
-            }
-            else if( character == 32 )
-            {
-                return 4;
-            }
-            else if( CHARACTERS.indexOf( character ) != -1 )
-            {
-                return CHAR_WIDTHS[character];
-            }
-            else
-            {
-                // Eh, close enough.
-                return 6;
-            }
-        }
-        else
-        {
-            return 1;
-        }
-    }
-
-    private static int getWidth( ITextComponent text, ICommandSender sender )
-    {
-        int sum = 0;
-        String chars = text.getUnformattedText();
-        for( int i = 0; i < chars.length(); i++ )
-        {
-            sum += getWidth( chars.charAt( i ), sender );
-        }
-
-        return sum;
-    }
-
-    private static boolean isPlayer( ICommandSender sender )
-    {
-        return sender instanceof EntityPlayerMP && !(sender instanceof FakePlayer);
-    }
-
-    private static int getMaxWidth( ICommandSender sender )
-    {
-        return isPlayer( sender ) ? 320 : 80;
-    }
-
+    private final int id;
     private int columns = -1;
     private final ITextComponent[] header;
     private final List<ITextComponent[]> rows = Lists.newArrayList();
 
-    public TextTable( @Nonnull ITextComponent... header )
+    public TextTable( int id, @Nonnull ITextComponent... header )
     {
+        this.id = id;
         this.header = header;
         this.columns = header.length;
     }
 
-    public TextTable()
+    public TextTable( int id )
     {
-        header = null;
+        this.id = id;
+        this.header = null;
     }
 
-    public TextTable( @Nonnull String... header )
+    public TextTable( int id, @Nonnull String... header )
     {
+        this.id = id;
         this.header = new ITextComponent[header.length];
         for( int i = 0; i < header.length; i++ )
         {
@@ -134,128 +70,101 @@ public class TextTable
     {
         if( columns <= 0 ) return;
 
-        final int maxWidth = getMaxWidth( sender );
-
-        int[] minWidths = new int[columns];
         int[] maxWidths = new int[columns];
-        int[] rowWidths = new int[columns];
 
         if( header != null )
         {
             for( int i = 0; i < columns; i++ )
             {
-                maxWidths[i] = minWidths[i] = getWidth( header[i], sender );
+                maxWidths[i] = getWidthFor( header[i], sender );
             }
         }
 
-        // Limit the number of rows to something sensible.
-        int limit = isPlayer( sender ) ? 30 : 100;
-        if( limit > rows.size() ) limit = rows.size();
+        // Limit the number of rows to fit within a single chat window on default Minecraft
+        // options.
+        int height = isPlayer( sender ) ? 18 : 100;
+        int limit = rows.size() <= height ? rows.size() : height - 1;
 
         for( int y = 0; y < limit; y++ )
         {
             ITextComponent[] row = rows.get( y );
             for( int i = 0; i < row.length; i++ )
             {
-                int width = getWidth( row[i], sender );
-                rowWidths[i] += width;
-                if( width > maxWidths[i] )
-                {
-                    maxWidths[i] = width;
-                }
+                int width = getWidthFor( row[i], sender );
+                if( width > maxWidths[i] ) maxWidths[i] = width;
             }
         }
 
-        // Calculate the average width
-        for( int i = 0; i < columns; i++ )
-        {
-            rowWidths[i] = Math.max( rowWidths[i], rows.size() );
-        }
+        // Add a small amount of extra padding. This defaults to 3 spaces for players
+        // and 1 for everyone else.
+        int padding = isPlayer( sender ) ? getWidth( ' ' ) * 3 : 1;
+        for( int i = 0; i < maxWidths.length; i++ ) maxWidths[i] += padding;
 
-        int totalWidth = (columns - 1) * getWidth( SEPARATOR, sender );
+        int totalWidth = (columns - 1) * getWidthFor( SEPARATOR, sender );
         for( int x : maxWidths ) totalWidth += x;
 
         // TODO: Limit the widths of some entries if totalWidth > maxWidth
 
-        ITextComponent out = new TextComponentString( "" );
+        List<ITextComponent> out = new ArrayList<>();
 
         if( header != null )
         {
-            for( int i = 0; i < columns; i++ )
+            TextComponentString line = new TextComponentString( "" );
+            for( int i = 0; i < columns - 1; i++ )
             {
-                if( i != 0 ) out.appendSibling( SEPARATOR );
-                appendFixed( out, sender, header[i], maxWidths[i] );
+                appendFixedWidth( line, sender, header[i], maxWidths[i] );
+                line.appendSibling( SEPARATOR );
             }
-            out.appendSibling( LINE );
+            line.appendSibling( header[columns - 1] );
+            out.add( line );
 
             // Round the width up rather than down
-            int rowCharWidth = getWidth( '=', sender );
+            int rowCharWidth = getWidthFor( '=', sender );
             int rowWidth = totalWidth / rowCharWidth + (totalWidth % rowCharWidth == 0 ? 0 : 1);
-            out.appendSibling( coloured( StringUtils.repeat( '=', rowWidth ), TextFormatting.GRAY ) );
-            out.appendSibling( LINE );
+            out.add( coloured( StringUtils.repeat( '=', rowWidth ), TextFormatting.GRAY ) );
         }
 
         for( int i = 0; i < limit; i++ )
         {
+            TextComponentString line = new TextComponentString( "" );
             ITextComponent[] row = rows.get( i );
-            if( i != 0 ) out.appendSibling( LINE );
-            for( int j = 0; j < columns; j++ )
+            for( int j = 0; j < columns - 1; j++ )
             {
-                if( j != 0 ) out.appendSibling( SEPARATOR );
-                appendFixed( out, sender, row[j], maxWidths[j] );
+                appendFixedWidth( line, sender, row[j], maxWidths[j] );
+                line.appendSibling( SEPARATOR );
             }
+            line.appendSibling( row[columns - 1] );
+            out.add( line );
         }
 
-        if( limit != rows.size() )
+        if( rows.size() > limit )
         {
-            out.appendSibling( LINE );
-            out.appendSibling( coloured( (rows.size() - limit) + " additional rows...", TextFormatting.AQUA ) );
+            out.add( coloured( (rows.size() - limit) + " additional rows...", TextFormatting.AQUA ) );
         }
 
-        sender.sendMessage( out );
-    }
-
-    private static void appendFixed( ITextComponent out, ICommandSender sender, ITextComponent entry, int maxWidth )
-    {
-        int length = getWidth( entry, sender );
-        int delta = length - maxWidth;
-        if( delta < 0 )
+        if( isPlayer( sender ) && id != 0 )
         {
-            // Convert to overflow;
-            delta = -delta;
+            ComputerCraftPacket packet = new ComputerCraftPacket();
+            packet.m_packetType = ComputerCraftPacket.PostChat;
+            packet.m_dataInt = new int[]{ id };
 
-            // We have to remove some padding as there is a padding added between formatted and unformatted text
-            if( !entry.getStyle().isEmpty() && isPlayer( sender ) ) delta -= 1;
-
-            out.appendSibling( entry );
-
-            int spaceWidth = getWidth( ' ', sender );
-
-            int spaces = delta / spaceWidth;
-            int missing = delta % spaceWidth;
-            spaces -= missing;
-
-            ITextComponent component = new TextComponentString( StringUtils.repeat( ' ', spaces < 0 ? 0 : spaces ) );
-            if( missing > 0 )
+            String[] lines = packet.m_dataString = new String[out.size()];
+            for( int i = 0; i < out.size(); i++ )
             {
-                ITextComponent bold = new TextComponentString( StringUtils.repeat( ' ', missing ) );
-                bold.getStyle().setBold( true );
-                component.appendSibling( bold );
+                lines[i] = ITextComponent.Serializer.componentToJson( out.get( i ) );
             }
 
-            out.appendSibling( component );
-        }
-        else if( delta > 0 )
-        {
-            out.appendSibling( entry );
+            ComputerCraft.sendToPlayer( (EntityPlayerMP) sender, packet );
         }
         else
         {
-            out.appendSibling( entry );
-
-            // We have to add some padding as we expect a padding between formatted and unformatted text
-            // and there won't be.
-            if( entry.getStyle().isEmpty() && isPlayer( sender ) ) out.appendText( " " );
+            ITextComponent result = new TextComponentString( "" );
+            for( int i = 0; i < out.size(); i++ )
+            {
+                if( i > 0 ) result.appendSibling( LINE );
+                result.appendSibling( out.get( i ) );
+            }
+            sender.sendMessage( result );
         }
     }
 }

src/main/java/dan200/computercraft/shared/common/BlockGeneric.java

@@ -36,7 +36,7 @@ public abstract class BlockGeneric extends Block implements
     protected BlockGeneric( Material material )
     {
         super( material );
-        this.isBlockContainer = true;
+        this.hasTileEntity = true;
     }
 
     protected abstract IBlockState getDefaultBlockState( int damage, EnumFacing placedSide );

src/main/java/dan200/computercraft/shared/common/ColourableRecipe.java

@@ -86,7 +86,7 @@ public class ColourableRecipe extends IForgeRegistryEntry.Impl<IRecipe> implemen
     }
 
     @Override
-    public boolean isHidden()
+    public boolean isDynamic()
     {
         return true;
     }

src/main/java/dan200/computercraft/shared/common/ServerTerminal.java

@@ -54,6 +54,11 @@ public class ServerTerminal implements ITerminal
         }
     }
 
+    protected void markTerminalChanged()
+    {
+        m_terminalChanged = true;
+    }
+
     public void update()
     {
         m_terminalChangedLastFrame = m_terminalChanged || (m_terminal != null && m_terminal.getChanged());

src/main/java/dan200/computercraft/shared/computer/core/ServerComputer.java

@@ -154,7 +154,7 @@ public class ServerComputer extends ServerTerminal
         return packet;
     }
 
-    private ComputerCraftPacket createTerminalPacket() {
+    protected ComputerCraftPacket createTerminalPacket() {
         ComputerCraftPacket packet = new ComputerCraftPacket();
         packet.m_packetType = ComputerCraftPacket.ComputerTerminalChanged;
         packet.m_dataInt = new int[] { getInstanceID() };
@@ -465,7 +465,7 @@ public class ServerComputer extends ServerTerminal
         }
     }
 
-    private boolean isInteracting( EntityPlayer player )
+    protected boolean isInteracting( EntityPlayer player )
     {
         if( player == null ) return false;
 

src/main/java/dan200/computercraft/shared/media/items/ItemDiskLegacy.java

@@ -54,15 +54,7 @@ public class ItemDiskLegacy extends Item
     @Nonnull
     public static ItemStack createFromIDAndColour( int id, String label, int colour )
     {
-        if( colour != Colour.Blue.getHex() )
-        {
-            return ItemDiskExpanded.createFromIDAndColour( id, label, colour );
-        }
-        
-        ItemStack stack = new ItemStack( ComputerCraft.Items.disk, 1 );
-        ComputerCraft.Items.disk.setDiskID( stack, id );
-        ComputerCraft.Items.disk.setLabel( stack, label );
-        return stack;
+        return ItemDiskExpanded.createFromIDAndColour( id, label, colour );
     }
     
     public int getDiskID( @Nonnull ItemStack stack )

src/main/java/dan200/computercraft/shared/media/recipes/DiskRecipe.java

@@ -91,7 +91,7 @@ public class DiskRecipe extends IForgeRegistryEntry.Impl<IRecipe> implements IRe
     }
 
     @Override
-    public boolean isHidden()
+    public boolean isDynamic()
     {
         return true;
     }

src/main/java/dan200/computercraft/shared/media/recipes/PrintoutRecipe.java

@@ -33,7 +33,7 @@ public class PrintoutRecipe extends IForgeRegistryEntry.Impl<IRecipe> implements
     }
 
     @Override
-    public boolean isHidden()
+    public boolean isDynamic()
     {
         return true;
     }

src/main/java/dan200/computercraft/shared/network/ComputerCraftPacket.java

@@ -33,6 +33,7 @@ public class ComputerCraftPacket
     public static final byte ComputerTerminalChanged = 8;
     public static final byte ComputerDeleted = 9;
     public static final byte PlayRecord = 10;
+    public static final byte PostChat = 11;
 
     // Packet class
     public byte m_packetType;

src/main/java/dan200/computercraft/shared/peripheral/common/BlockCable.java

@@ -332,7 +332,8 @@ public class BlockCable extends BlockPeripheralBase
                         item = PeripheralItemFactory.create( PeripheralType.Cable, null, 1 );
                     }
 
-                    cable.networkChanged();
+                    cable.modemChanged();
+                    cable.connectionsChanged();
                     if( !world.isRemote && !player.capabilities.isCreativeMode ) dropItem( world, pos, item );
 
                     return false;
@@ -382,7 +383,7 @@ public class BlockCable extends BlockPeripheralBase
             TileCable cable = (TileCable) tile;
             if( cable.getPeripheralType() != PeripheralType.WiredModem )
             {
-                cable.networkChanged();
+                cable.connectionsChanged();
             }
         }
 

src/main/java/dan200/computercraft/shared/peripheral/common/ItemCable.java

@@ -98,8 +98,8 @@ public class ItemCable extends ItemPeripheralBase
                     TileEntity tile = world.getTileEntity( pos );
                     if( tile != null && tile instanceof TileCable )
                     {
-                        TileCable cable = (TileCable)tile;
-                        cable.networkChanged();
+                        TileCable cable = (TileCable) tile;
+                        cable.connectionsChanged();
                     }
                     return EnumActionResult.SUCCESS;
                 }
@@ -131,7 +131,8 @@ public class ItemCable extends ItemPeripheralBase
                         if( tile != null && tile instanceof TileCable )
                         {
                             TileCable cable = (TileCable)tile;
-                            cable.networkChanged();
+                            cable.modemChanged();
+                            cable.connectionsChanged();
                         }
                         return EnumActionResult.SUCCESS;
                     }
@@ -153,7 +154,8 @@ public class ItemCable extends ItemPeripheralBase
                         if( tile != null && tile instanceof TileCable )
                         {
                             TileCable cable = (TileCable)tile;
-                            cable.networkChanged();
+                            cable.modemChanged();
+                            cable.connectionsChanged();
                         }
                         return EnumActionResult.SUCCESS;
                     }

src/main/java/dan200/computercraft/shared/peripheral/diskdrive/DiskDrivePeripheral.java

@@ -62,9 +62,9 @@ public class DiskDrivePeripheral implements IPeripheral
         {
             case 0:
             {
-                // isPresent
+                // isDiskPresent
                 return new Object[] {
-                    m_diskDrive.getDiskStack() != null
+                    !m_diskDrive.getDiskStack().isEmpty()
                 };
             }
             case 1:

src/main/java/dan200/computercraft/shared/peripheral/diskdrive/TileDiskDrive.java

@@ -422,6 +422,7 @@ public class TileDiskDrive extends TilePeripheralBase
         return new DiskDrivePeripheral( this );
     }
 
+    @Nonnull
     public ItemStack getDiskStack()
     {
         synchronized( this )

src/main/java/dan200/computercraft/shared/peripheral/modem/TileCable.java

@@ -16,10 +16,7 @@ import dan200.computercraft.shared.peripheral.PeripheralType;
 import dan200.computercraft.shared.peripheral.common.BlockCable;
 import dan200.computercraft.shared.peripheral.common.BlockCableModemVariant;
 import dan200.computercraft.shared.peripheral.common.PeripheralItemFactory;
-import dan200.computercraft.shared.util.IDAssigner;
-import dan200.computercraft.shared.util.PeripheralUtil;
-import dan200.computercraft.api.network.wired.IWiredElementTile;
-import net.minecraft.block.Block;
+import dan200.computercraft.shared.wired.CapabilityWiredElement;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
@@ -31,15 +28,15 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.text.TextComponentTranslation;
 import net.minecraft.world.World;
+import net.minecraftforge.common.capabilities.Capability;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-import java.io.File;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
-public class TileCable extends TileModemBase implements IWiredElementTile
+public class TileCable extends TileModemBase
 {
     public static final double MIN = 0.375;
     public static final double MAX = 1 - MIN;
@@ -75,26 +72,13 @@ public class TileCable extends TileModemBase implements IWiredElementTile
         public Vec3d getPosition()
         {
             BlockPos pos = m_entity.getPos();
-            return new Vec3d( (double) pos.getX() + 0.5, (double) pos.getY() + 0.5, (double) pos.getZ() + 0.5 );
-        }
-
-        @Nonnull
-        @Override
-        public Map<String, IPeripheral> getPeripherals()
-        {
-            IPeripheral peripheral = m_entity.getConnectedPeripheral();
-            return peripheral != null
-                ? Collections.singletonMap( m_entity.getConnectedPeripheralName(), peripheral )
-                : Collections.emptyMap();
+            return new Vec3d( pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5 );
         }
 
         @Override
         protected void attachPeripheral( String name, IPeripheral peripheral )
         {
-            if( !name.equals( m_entity.getConnectedPeripheralName() ) )
-            {
-                ((WiredModemPeripheral) m_entity.m_modem).attachPeripheral( name, peripheral );
-            }
+            ((WiredModemPeripheral) m_entity.m_modem).attachPeripheral( name, peripheral );
         }
 
         @Override
@@ -107,9 +91,9 @@ public class TileCable extends TileModemBase implements IWiredElementTile
     // Members
 
     private boolean m_peripheralAccessAllowed;
-    private int m_attachedPeripheralID;
+    private WiredModemLocalPeripheral m_peripheral = new WiredModemLocalPeripheral();
 
-    private boolean m_destroyed;
+    private boolean m_destroyed = false;
 
     private boolean m_hasDirection = false;
     private boolean m_connectionsFormed = false;
@@ -117,14 +101,6 @@ public class TileCable extends TileModemBase implements IWiredElementTile
     private WiredModemElement m_cable;
     private IWiredNode m_node;
 
-    public TileCable()
-    {
-        m_peripheralAccessAllowed = false;
-        m_attachedPeripheralID = -1;
-
-        m_destroyed = false;
-    }
-
     @Override
     protected ModemPeripheral createPeripheral()
     {
@@ -132,6 +108,13 @@ public class TileCable extends TileModemBase implements IWiredElementTile
         m_node = m_cable.getNode();
         return new WiredModemPeripheral( m_cable )
         {
+            @Nonnull
+            @Override
+            protected WiredModemLocalPeripheral getLocalPeripheral()
+            {
+                return m_peripheral;
+            }
+
             @Nonnull
             @Override
             public Vec3d getPosition()
@@ -287,12 +270,32 @@ public class TileCable extends TileModemBase implements IWiredElementTile
                     ((BlockGeneric) getBlockType()).dropItem( getWorld(), getPos(), PeripheralItemFactory.create( PeripheralType.WiredModem, getLabel(), 1 ) );
                     setLabel( null );
                     setBlockState( getBlockState().withProperty( BlockCable.Properties.MODEM, BlockCableModemVariant.None ) );
-                    networkChanged();
+                    modemChanged();
+                    connectionsChanged();
 
-                    break;
+                    return;
                 }
             }
         }
+
+        if( !world.isRemote && m_peripheralAccessAllowed )
+        {
+            if( m_peripheral.attach( world, getPos(), dir ) ) updateConnectedPeripherals();
+        }
+    }
+
+    @Override
+    public void onNeighbourTileEntityChange( @Nonnull BlockPos neighbour )
+    {
+        super.onNeighbourTileEntityChange( neighbour );
+        if( !world.isRemote && m_peripheralAccessAllowed )
+        {
+            EnumFacing facing = getDirection();
+            if( getPos().offset( facing ).equals( neighbour ) )
+            {
+                if( m_peripheral.attach( world, getPos(), facing ) ) updateConnectedPeripherals();
+            }
+        }
     }
 
     public AxisAlignedBB getModemBounds()
@@ -395,9 +398,9 @@ public class TileCable extends TileModemBase implements IWiredElementTile
             if( !getWorld().isRemote )
             {
                 // On server, we interacted if a peripheral was found
-                String oldPeriphName = getConnectedPeripheralName();
+                String oldPeriphName = m_peripheral.getConnectedName();
                 togglePeripheralAccess();
-                String periphName = getConnectedPeripheralName();
+                String periphName = m_peripheral.getConnectedName();
 
                 if( !Objects.equal( periphName, oldPeriphName ) )
                 {
@@ -432,7 +435,7 @@ public class TileCable extends TileModemBase implements IWiredElementTile
         // Read properties
         super.readFromNBT( nbttagcompound );
         m_peripheralAccessAllowed = nbttagcompound.getBoolean( "peripheralAccess" );
-        m_attachedPeripheralID = nbttagcompound.getInteger( "peripheralID" );
+        m_peripheral.readNBT( nbttagcompound, "" );
     }
 
     @Nonnull
@@ -442,7 +445,7 @@ public class TileCable extends TileModemBase implements IWiredElementTile
         // Write properties
         nbttagcompound = super.writeToNBT( nbttagcompound );
         nbttagcompound.setBoolean( "peripheralAccess", m_peripheralAccessAllowed );
-        nbttagcompound.setInteger( "peripheralID", m_attachedPeripheralID );
+        m_peripheral.writeNBT( nbttagcompound, "" );
         return nbttagcompound;
     }
 
@@ -470,27 +473,31 @@ public class TileCable extends TileModemBase implements IWiredElementTile
         {
             if( !m_connectionsFormed )
             {
-                networkChanged();
-                if( m_peripheralAccessAllowed ) m_node.invalidate();
                 m_connectionsFormed = true;
+
+                connectionsChanged();
+                if( m_peripheralAccessAllowed )
+                {
+                    m_peripheral.attach( world, pos, m_dir );
+                    updateConnectedPeripherals();
+                }
             }
         }
     }
 
-    public void networkChanged()
+    public void connectionsChanged()
     {
         if( getWorld().isRemote ) return;
 
-        if( modemChanged() ) m_node.invalidate();
-
         IBlockState state = getBlockState();
         World world = getWorld();
         BlockPos current = getPos();
         for( EnumFacing facing : EnumFacing.VALUES )
         {
-            if( !world.isBlockLoaded( pos ) ) continue;
-            
-            IWiredElement element = ComputerCraft.getWiredElementAt( world, current.offset( facing ), facing.getOpposite() );
+            BlockPos offset = current.offset( facing );
+            if( !world.isBlockLoaded( offset ) ) continue;
+
+            IWiredElement element = ComputerCraft.getWiredElementAt( world, offset, facing.getOpposite() );
             if( element == null ) continue;
 
             if( BlockCable.canConnectIn( state, facing ) )
@@ -506,27 +513,19 @@ public class TileCable extends TileModemBase implements IWiredElementTile
         }
     }
 
-    private boolean modemChanged()
+    public void modemChanged()
     {
-        if( getWorld().isRemote ) return false;
-
-        boolean requiresUpdate = false;
+        if( getWorld().isRemote ) return;
 
         PeripheralType type = getPeripheralType();
-        if( type == PeripheralType.Cable )
-        {
-            m_attachedPeripheralID = -1;
-        }
-
         if( type != PeripheralType.WiredModemWithCable && m_peripheralAccessAllowed )
         {
             m_peripheralAccessAllowed = false;
-            requiresUpdate = true;
+            m_peripheral.detach();
+            m_node.updatePeripherals( Collections.emptyMap() );
             markDirty();
             updateAnim();
         }
-
-        return requiresUpdate;
     }
 
     // private stuff
@@ -534,61 +533,34 @@ public class TileCable extends TileModemBase implements IWiredElementTile
     {
         if( !m_peripheralAccessAllowed )
         {
+            m_peripheral.attach( world, getPos(), getDirection() );
+            if( !m_peripheral.hasPeripheral() ) return;
+
             m_peripheralAccessAllowed = true;
-            if( getConnectedPeripheral() == null )
-            {
-                m_peripheralAccessAllowed = false;
-                return;
-            }
+            m_node.updatePeripherals( m_peripheral.toMap() );
         }
         else
         {
+            m_peripheral.detach();
+
             m_peripheralAccessAllowed = false;
+            m_node.updatePeripherals( Collections.emptyMap() );
         }
 
         updateAnim();
-        m_node.invalidate();
     }
 
-    private String getConnectedPeripheralName()
+    private void updateConnectedPeripherals()
     {
-        IPeripheral periph = getConnectedPeripheral();
-        if( periph != null )
+        Map<String, IPeripheral> peripherals = m_peripheral.toMap();
+        if( peripherals.isEmpty() )
         {
-            String type = periph.getType();
-            if( m_attachedPeripheralID < 0 )
-            {
-                m_attachedPeripheralID = IDAssigner.getNextIDFromFile( new File(
-                    ComputerCraft.getWorldDir( getWorld() ),
-                    "computer/lastid_" + type + ".txt"
-                ) );
-            }
-            return type + "_" + m_attachedPeripheralID;
+            // If there are no peripherals then disable access and update the display state.
+            m_peripheralAccessAllowed = false;
+            updateAnim();
         }
-        return null;
-    }
 
-    private IPeripheral getConnectedPeripheral()
-    {
-        if( m_peripheralAccessAllowed )
-        {
-            if( getPeripheralType() == PeripheralType.WiredModemWithCable )
-            {
-                EnumFacing facing = getDirection();
-                BlockPos neighbour = getPos().offset( facing );
-                IPeripheral peripheral = getPeripheral( getWorld(), neighbour, facing.getOpposite() );
-                return peripheral == null || peripheral instanceof WiredModemPeripheral ? null : peripheral;
-            }
-        }
-        return null;
-    }
-
-    public static IPeripheral getPeripheral( World world, BlockPos pos, EnumFacing facing )
-    {
-        Block block = world.getBlockState( pos ).getBlock();
-        if( block == ComputerCraft.Blocks.wiredModemFull || block == ComputerCraft.Blocks.cable ) return null;
-
-        return PeripheralUtil.getPeripheral( world, pos, facing );
+        m_node.updatePeripherals( peripherals );
     }
 
     @Override
@@ -597,13 +569,25 @@ public class TileCable extends TileModemBase implements IWiredElementTile
         return true;
     }
 
-    // IWiredElement tile
+    // IWiredElement capability
+
+    @Override
+    public boolean hasCapability( @Nonnull Capability<?> capability, @Nullable EnumFacing facing )
+    {
+        if( capability == CapabilityWiredElement.CAPABILITY ) return BlockCable.canConnectIn( getBlockState(), facing );
+        return super.hasCapability( capability, facing );
+    }
 
     @Nullable
     @Override
-    public IWiredElement getWiredElement( @Nonnull EnumFacing side )
+    public <T> T getCapability( @Nonnull Capability<T> capability, @Nullable EnumFacing facing )
     {
-        return BlockCable.canConnectIn( getBlockState(), side ) ? m_cable : null;
+        if( capability == CapabilityWiredElement.CAPABILITY )
+        {
+            return BlockCable.canConnectIn( getBlockState(), facing ) ? CapabilityWiredElement.CAPABILITY.cast( m_cable ) : null;
+        }
+
+        return super.getCapability( capability, facing );
     }
 
     // IPeripheralTile

src/main/java/dan200/computercraft/shared/peripheral/modem/TileWiredModemFull.java

@@ -9,12 +9,11 @@ package dan200.computercraft.shared.peripheral.modem;
 import com.google.common.base.Objects;
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.api.network.wired.IWiredElement;
-import dan200.computercraft.api.network.wired.IWiredElementTile;
 import dan200.computercraft.api.network.wired.IWiredNode;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.shared.peripheral.common.BlockCable;
 import dan200.computercraft.shared.peripheral.common.TilePeripheralBase;
-import dan200.computercraft.shared.util.IDAssigner;
+import dan200.computercraft.shared.wired.CapabilityWiredElement;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumFacing;
@@ -23,13 +22,13 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.text.TextComponentTranslation;
 import net.minecraft.world.World;
-import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.capabilities.Capability;
 
 import javax.annotation.Nonnull;
-import java.io.File;
+import javax.annotation.Nullable;
 import java.util.*;
 
-public class TileWiredModemFull extends TilePeripheralBase implements IWiredElementTile
+public class TileWiredModemFull extends TilePeripheralBase
 {
     private static class FullElement extends WiredModemElement
     {
@@ -46,10 +45,7 @@ public class TileWiredModemFull extends TilePeripheralBase implements IWiredElem
             for( int i = 0; i < 6; i++ )
             {
                 WiredModemPeripheral modem = m_entity.m_modems[i];
-                if( modem != null && !name.equals( m_entity.getCachedPeripheralName( EnumFacing.VALUES[i] ) ) )
-                {
-                    modem.attachPeripheral( name, peripheral );
-                }
+                if( modem != null ) modem.attachPeripheral( name, peripheral );
             }
         }
 
@@ -77,37 +73,29 @@ public class TileWiredModemFull extends TilePeripheralBase implements IWiredElem
             BlockPos pos = m_entity.getPos();
             return new Vec3d( pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5 );
         }
-
-        @Nonnull
-        @Override
-        public Map<String, IPeripheral> getPeripherals()
-        {
-            return m_entity.getPeripherals();
-        }
     }
 
     private WiredModemPeripheral[] m_modems = new WiredModemPeripheral[6];
 
     private boolean m_peripheralAccessAllowed = false;
-    private int[] m_attachedPeripheralIDs = new int[6];
-    private String[] m_attachedPeripheralTypes = new String[6];
+    private WiredModemLocalPeripheral[] m_peripherals = new WiredModemLocalPeripheral[6];
 
     private boolean m_destroyed = false;
     private boolean m_connectionsFormed = false;
 
     private final WiredModemElement m_element = new FullElement( this );
-    private final IWiredNode node = m_element.getNode();
+    private final IWiredNode m_node = m_element.getNode();
 
     public TileWiredModemFull()
     {
-        Arrays.fill( m_attachedPeripheralIDs, -1 );
+        for( int i = 0; i < m_peripherals.length; i++ ) m_peripherals[i] = new WiredModemLocalPeripheral();
     }
 
     private void remove()
     {
         if( world == null || !world.isRemote )
         {
-            node.remove();
+            m_node.remove();
             m_connectionsFormed = false;
         }
     }
@@ -153,18 +141,29 @@ public class TileWiredModemFull extends TilePeripheralBase implements IWiredElem
     {
         if( !world.isRemote && m_peripheralAccessAllowed )
         {
-            Map<String, IPeripheral> updated = getPeripherals();
-
-            if( updated.isEmpty() )
+            boolean hasChanged = false;
+            for( EnumFacing facing : EnumFacing.VALUES )
             {
-                // If there are no peripherals then disable access and update the display state.
-                m_peripheralAccessAllowed = false;
-                updateAnim();
+                hasChanged |= m_peripherals[facing.ordinal()].attach( world, getPos(), facing );
             }
 
-            // Always invalidate the node: it's more accurate than checking if the peripherals
-            // have changed
-            node.invalidate();
+            if( hasChanged ) updateConnectedPeripherals();
+        }
+    }
+
+    @Override
+    public void onNeighbourTileEntityChange( @Nonnull BlockPos neighbour )
+    {
+        if( !world.isRemote && m_peripheralAccessAllowed )
+        {
+            for( EnumFacing facing : EnumFacing.VALUES )
+            {
+                if( getPos().offset( facing ).equals( neighbour ) )
+                {
+                    WiredModemLocalPeripheral peripheral = m_peripherals[facing.ordinal()];
+                    if( peripheral.attach( world, getPos(), facing ) ) updateConnectedPeripherals();
+                }
+            }
         }
     }
 
@@ -181,9 +180,9 @@ public class TileWiredModemFull extends TilePeripheralBase implements IWiredElem
         if( !getWorld().isRemote )
         {
             // On server, we interacted if a peripheral was found
-            Set<String> oldPeriphName = getPeripherals().keySet();
+            Set<String> oldPeriphName = getConnectedPeripheralNames();
             togglePeripheralAccess();
-            Set<String> periphName = getPeripherals().keySet();
+            Set<String> periphName = getConnectedPeripheralNames();
 
             if( !Objects.equal( periphName, oldPeriphName ) )
             {
@@ -221,17 +220,7 @@ public class TileWiredModemFull extends TilePeripheralBase implements IWiredElem
     {
         super.readFromNBT( tag );
         m_peripheralAccessAllowed = tag.getBoolean( "peripheralAccess" );
-        for( int i = 0; i < m_attachedPeripheralIDs.length; i++ )
-        {
-            if( tag.hasKey( "peripheralID_" + i, Constants.NBT.TAG_ANY_NUMERIC ) )
-            {
-                m_attachedPeripheralIDs[i] = tag.getInteger( "peripheralID_" + i );
-            }
-            if( tag.hasKey( "peripheralType_" + i, Constants.NBT.TAG_STRING ) )
-            {
-                m_attachedPeripheralTypes[i] = tag.getString( "peripheralType_" + i );
-            }
-        }
+        for( int i = 0; i < m_peripherals.length; i++ ) m_peripherals[i].readNBT( tag, "_" + i );
     }
 
     @Nonnull
@@ -240,17 +229,7 @@ public class TileWiredModemFull extends TilePeripheralBase implements IWiredElem
     {
         tag = super.writeToNBT( tag );
         tag.setBoolean( "peripheralAccess", m_peripheralAccessAllowed );
-        for( int i = 0; i < m_attachedPeripheralIDs.length; i++ )
-        {
-            if( m_attachedPeripheralIDs[i] >= 0 )
-            {
-                tag.setInteger( "peripheralID_" + i, m_attachedPeripheralIDs[i] );
-            }
-            if( m_attachedPeripheralTypes[i] != null )
-            {
-                tag.setString( "peripheralType_" + i, m_attachedPeripheralTypes[i] );
-            }
-        }
+        for( int i = 0; i < m_peripherals.length; i++ ) m_peripherals[i].writeNBT( tag, "_" + i );
         return tag;
     }
 
@@ -294,15 +273,24 @@ public class TileWiredModemFull extends TilePeripheralBase implements IWiredElem
 
             if( !m_connectionsFormed )
             {
-                networkChanged();
                 m_connectionsFormed = true;
+
+                connectionsChanged();
+                if( m_peripheralAccessAllowed )
+                {
+                    for( EnumFacing facing : EnumFacing.VALUES )
+                    {
+                        m_peripherals[facing.ordinal()].attach( world, getPos(), facing );
+                    }
+                    updateConnectedPeripherals();
+                }
             }
         }
 
         super.update();
     }
 
-    private void networkChanged()
+    private void connectionsChanged()
     {
         if( getWorld().isRemote ) return;
 
@@ -310,16 +298,15 @@ public class TileWiredModemFull extends TilePeripheralBase implements IWiredElem
         BlockPos current = getPos();
         for( EnumFacing facing : EnumFacing.VALUES )
         {
-            if( !world.isBlockLoaded( pos ) ) continue;
+            BlockPos offset = current.offset( facing );
+            if( !world.isBlockLoaded( offset ) ) continue;
 
-            IWiredElement element = ComputerCraft.getWiredElementAt( world, current.offset( facing ), facing.getOpposite() );
+            IWiredElement element = ComputerCraft.getWiredElementAt( world, offset, facing.getOpposite() );
             if( element == null ) continue;
 
             // If we can connect to it then do so
-            node.connectTo( element.getNode() );
+            m_node.connectTo( element.getNode() );
         }
-
-        node.invalidate();
     }
 
     // private stuff
@@ -327,69 +314,83 @@ public class TileWiredModemFull extends TilePeripheralBase implements IWiredElem
     {
         if( !m_peripheralAccessAllowed )
         {
-            m_peripheralAccessAllowed = true;
-            if( getPeripherals().isEmpty() )
+            boolean hasAny = false;
+            for( EnumFacing facing : EnumFacing.VALUES )
             {
-                m_peripheralAccessAllowed = false;
-                return;
+                WiredModemLocalPeripheral peripheral = m_peripherals[facing.ordinal()];
+                peripheral.attach( world, getPos(), facing );
+                hasAny |= peripheral.hasPeripheral();
             }
+
+            if( !hasAny ) return;
+
+            m_peripheralAccessAllowed = true;
+            m_node.updatePeripherals( getConnectedPeripherals() );
         }
         else
         {
             m_peripheralAccessAllowed = false;
+
+            for( WiredModemLocalPeripheral peripheral : m_peripherals ) peripheral.detach();
+            m_node.updatePeripherals( Collections.emptyMap() );
         }
 
         updateAnim();
-        node.invalidate();
     }
 
-    @Nonnull
-    private Map<String, IPeripheral> getPeripherals()
+    private Set<String> getConnectedPeripheralNames()
+    {
+        if( !m_peripheralAccessAllowed ) return Collections.emptySet();
+
+        Set<String> peripherals = new HashSet<>( 6 );
+        for( WiredModemLocalPeripheral m_peripheral : m_peripherals )
+        {
+            String name = m_peripheral.getConnectedName();
+            if( name != null ) peripherals.add( name );
+        }
+        return peripherals;
+    }
+
+    private Map<String, IPeripheral> getConnectedPeripherals()
     {
         if( !m_peripheralAccessAllowed ) return Collections.emptyMap();
 
         Map<String, IPeripheral> peripherals = new HashMap<>( 6 );
-        for( EnumFacing facing : EnumFacing.VALUES )
-        {
-            BlockPos neighbour = getPos().offset( facing );
-            IPeripheral peripheral = TileCable.getPeripheral( getWorld(), neighbour, facing.getOpposite() );
-            if( peripheral != null && !(peripheral instanceof WiredModemPeripheral) )
-            {
-                String type = peripheral.getType();
-                int id = m_attachedPeripheralIDs[facing.ordinal()];
-                String oldType = m_attachedPeripheralTypes[facing.ordinal()];
-                if( id < 0 || !type.equals( oldType ) )
-                {
-                    m_attachedPeripheralTypes[facing.ordinal()] = type;
-                    id = m_attachedPeripheralIDs[facing.ordinal()] = IDAssigner.getNextIDFromFile( new File(
-                        ComputerCraft.getWorldDir( getWorld() ),
-                        "computer/lastid_" + type + ".txt"
-                    ) );
-                }
-
-                peripherals.put( type + "_" + id, peripheral );
-            }
-        }
-
+        for( WiredModemLocalPeripheral m_peripheral : m_peripherals ) m_peripheral.extendMap( peripherals );
         return peripherals;
     }
 
-    private String getCachedPeripheralName( EnumFacing facing )
+    private void updateConnectedPeripherals()
     {
-        if( !m_peripheralAccessAllowed ) return null;
+        Map<String, IPeripheral> peripherals = getConnectedPeripherals();
+        if( peripherals.isEmpty() )
+        {
+            // If there are no peripherals then disable access and update the display state.
+            m_peripheralAccessAllowed = false;
+            updateAnim();
+        }
 
-        int id = m_attachedPeripheralIDs[facing.ordinal()];
-        String type = m_attachedPeripheralTypes[facing.ordinal()];
-        return id < 0 || type == null ? null : type + "_" + id;
+        m_node.updatePeripherals( peripherals );
     }
 
     // IWiredElementTile
 
-    @Nonnull
     @Override
-    public IWiredElement getWiredElement( @Nonnull EnumFacing side )
+    public boolean hasCapability( @Nonnull Capability<?> capability, @Nullable EnumFacing facing )
     {
-        return m_element;
+        return capability == CapabilityWiredElement.CAPABILITY || super.hasCapability( capability, facing );
+    }
+
+    @Nullable
+    @Override
+    public <T> T getCapability( @Nonnull Capability<T> capability, @Nullable EnumFacing facing )
+    {
+        if( capability == CapabilityWiredElement.CAPABILITY )
+        {
+            return CapabilityWiredElement.CAPABILITY.cast( m_element );
+        }
+
+        return super.getCapability( capability, facing );
     }
 
     // IPeripheralTile
@@ -400,8 +401,16 @@ public class TileWiredModemFull extends TilePeripheralBase implements IWiredElem
         WiredModemPeripheral peripheral = m_modems[side.ordinal()];
         if( peripheral == null )
         {
+            WiredModemLocalPeripheral localPeripheral = m_peripherals[side.ordinal()];
             peripheral = m_modems[side.ordinal()] = new WiredModemPeripheral( m_element )
             {
+                @Nonnull
+                @Override
+                protected WiredModemLocalPeripheral getLocalPeripheral()
+                {
+                    return localPeripheral;
+                }
+
                 @Nonnull
                 @Override
                 public Vec3d getPosition()

src/main/java/dan200/computercraft/shared/peripheral/modem/WiredModemElement.java

@@ -1,7 +1,7 @@
 package dan200.computercraft.shared.peripheral.modem;
 
-import dan200.computercraft.api.network.wired.IWiredNetworkChange;
 import dan200.computercraft.api.network.wired.IWiredElement;
+import dan200.computercraft.api.network.wired.IWiredNetworkChange;
 import dan200.computercraft.api.network.wired.IWiredNode;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.shared.wired.WiredNode;

src/main/java/dan200/computercraft/shared/peripheral/modem/WiredModemLocalPeripheral.java

@@ -0,0 +1,139 @@
+package dan200.computercraft.shared.peripheral.modem;
+
+import dan200.computercraft.ComputerCraft;
+import dan200.computercraft.api.peripheral.IPeripheral;
+import dan200.computercraft.shared.util.IDAssigner;
+import dan200.computercraft.shared.util.PeripheralUtil;
+import net.minecraft.block.Block;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.io.File;
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * Represents a local peripheral exposed on the wired network
+ *
+ * This is responsible for getting the peripheral in world, tracking id and type and determining whether
+ * it has changed.
+ */
+public final class WiredModemLocalPeripheral
+{
+    private int id;
+    private String type;
+
+    private IPeripheral peripheral;
+
+    /**
+     * Attach a new peripheral from the world
+     *
+     * @param world     The world to search in
+     * @param origin    The position to search from
+     * @param direction The direction so search in
+     * @return Whether the peripheral changed.
+     */
+    public boolean attach( @Nonnull World world, @Nonnull BlockPos origin, @Nonnull EnumFacing direction )
+    {
+        IPeripheral oldPeripheral = this.peripheral;
+        IPeripheral peripheral = this.peripheral = getPeripheralFrom( world, origin, direction );
+
+        if( peripheral == null )
+        {
+            return oldPeripheral != null;
+        }
+        else
+        {
+            String type = peripheral.getType();
+            int id = this.id;
+
+            if( id > 0 && this.type == null )
+            {
+                // If we had an ID but no type, then just set the type.
+                this.type = type;
+            }
+            else if( id < 0 || !type.equals( this.type ) )
+            {
+                this.type = type;
+                this.id = IDAssigner.getNextIDFromFile( new File(
+                    ComputerCraft.getWorldDir( world ),
+                    "computer/lastid_" + type + ".txt"
+                ) );
+            }
+
+            return oldPeripheral == null || !oldPeripheral.equals( peripheral );
+        }
+    }
+
+    /**
+     * Detach the current peripheral
+     *
+     * @return Whether the peripheral changed
+     */
+    public boolean detach()
+    {
+        if( peripheral == null ) return false;
+        peripheral = null;
+        return true;
+    }
+
+    @Nullable
+    public String getConnectedName()
+    {
+        return peripheral != null ? type + "_" + id : null;
+    }
+
+    @Nullable
+    public IPeripheral getPeripheral()
+    {
+        return peripheral;
+    }
+
+    public boolean hasPeripheral()
+    {
+        return peripheral != null;
+    }
+
+    public void extendMap( @Nonnull Map<String, IPeripheral> peripherals )
+    {
+        if( peripheral != null ) peripherals.put( type + "_" + id, peripheral );
+    }
+
+    public Map<String, IPeripheral> toMap()
+    {
+        return peripheral == null
+            ? Collections.emptyMap()
+            : Collections.singletonMap( type + "_" + id, peripheral );
+    }
+
+    public void writeNBT( @Nonnull NBTTagCompound tag, @Nonnull String suffix )
+    {
+        if( id >= 0 ) tag.setInteger( "peripheralID" + suffix, id );
+        if( type != null ) tag.setString( "peripheralType" + suffix, type );
+    }
+
+    public void readNBT( @Nonnull NBTTagCompound tag, @Nonnull String suffix )
+    {
+        id = tag.hasKey( "peripheralID" + suffix, Constants.NBT.TAG_ANY_NUMERIC )
+            ? tag.getInteger( "peripheralID" + suffix ) : -1;
+
+        type = tag.hasKey( "peripheralType" + suffix, Constants.NBT.TAG_STRING )
+            ? tag.getString( "peripheralType" + suffix ) : null;
+    }
+
+    private static IPeripheral getPeripheralFrom( World world, BlockPos pos, EnumFacing direction )
+    {
+        BlockPos offset = pos.offset( direction );
+
+        Block block = world.getBlockState( offset ).getBlock();
+        if( block == ComputerCraft.Blocks.wiredModemFull || block == ComputerCraft.Blocks.cable ) return null;
+
+        IPeripheral peripheral = PeripheralUtil.getPeripheral( world, offset, direction.getOpposite() );
+        return peripheral instanceof WiredModemPeripheral ? null : peripheral;
+    }
+}

src/main/java/dan200/computercraft/shared/peripheral/modem/WiredModemPeripheral.java

@@ -10,7 +10,8 @@ import dan200.computercraft.api.network.wired.IWiredNode;
 import dan200.computercraft.api.network.wired.IWiredSender;
 import dan200.computercraft.api.peripheral.IComputerAccess;
 import dan200.computercraft.api.peripheral.IPeripheral;
-import net.minecraft.util.math.Vec3d;
+import dan200.computercraft.core.computer.Computer;
+import dan200.computercraft.core.computer.IComputerOwned;
 import net.minecraft.world.World;
 
 import javax.annotation.Nonnull;
@@ -20,7 +21,7 @@ import java.util.Map;
 
 import static dan200.computercraft.core.apis.ArgumentHelper.getString;
 
-public class WiredModemPeripheral extends ModemPeripheral implements IWiredSender
+public abstract class WiredModemPeripheral extends ModemPeripheral implements IWiredSender
 {
     private final WiredModemElement modem;
 
@@ -58,11 +59,7 @@ public class WiredModemPeripheral extends ModemPeripheral implements IWiredSende
     }
 
     @Nonnull
-    @Override
-    public Vec3d getPosition()
-    {
-        return modem.getPosition();
-    }
+    protected abstract WiredModemLocalPeripheral getLocalPeripheral();
     //endregion
 
     //region IPeripheral
@@ -71,13 +68,14 @@ public class WiredModemPeripheral extends ModemPeripheral implements IWiredSende
     public String[] getMethodNames()
     {
         String[] methods = super.getMethodNames();
-        String[] newMethods = new String[methods.length + 5];
+        String[] newMethods = new String[methods.length + 6];
         System.arraycopy( methods, 0, newMethods, 0, methods.length );
         newMethods[methods.length] = "getNamesRemote";
         newMethods[methods.length + 1] = "isPresentRemote";
         newMethods[methods.length + 2] = "getTypeRemote";
         newMethods[methods.length + 3] = "getMethodsRemote";
         newMethods[methods.length + 4] = "callRemote";
+        newMethods[methods.length + 5] = "getNameLocal";
         return newMethods;
     }
 
@@ -141,6 +139,12 @@ public class WiredModemPeripheral extends ModemPeripheral implements IWiredSende
                 System.arraycopy( arguments, 2, methodArgs, 0, arguments.length - 2 );
                 return callMethodRemote( remoteName, context, methodName, methodArgs );
             }
+            case 5:
+            {
+                // getNameLocal
+                String local = getLocalPeripheral().getConnectedName();
+                return local == null ? null : new Object[]{ local };
+            }
             default:
             {
                 // The regular modem methods
@@ -223,7 +227,7 @@ public class WiredModemPeripheral extends ModemPeripheral implements IWiredSende
 
     private void attachPeripheralImpl( String periphName, IPeripheral peripheral )
     {
-        if( !peripheralWrappers.containsKey( periphName ) )
+        if( !peripheralWrappers.containsKey( periphName ) && !periphName.equals( getLocalPeripheral().getConnectedName() ) )
         {
             RemotePeripheralWrapper wrapper = new RemotePeripheralWrapper( modem, peripheral, getComputer(), periphName );
             peripheralWrappers.put( periphName, wrapper );
@@ -271,7 +275,7 @@ public class WiredModemPeripheral extends ModemPeripheral implements IWiredSende
         throw new LuaException( "No peripheral: " + remoteName );
     }
 
-    private static class RemotePeripheralWrapper implements IComputerAccess
+    private static class RemotePeripheralWrapper implements IComputerAccess, IComputerOwned
     {
         private final WiredModemElement m_element;
         private final IPeripheral m_peripheral;
@@ -406,5 +410,12 @@ public class WiredModemPeripheral extends ModemPeripheral implements IWiredSende
                 return m_element.getRemotePeripherals().get( name );
             }
         }
+
+        @Nullable
+        @Override
+        public Computer getComputer()
+        {
+            return m_computer instanceof IComputerOwned ? ((IComputerOwned) m_computer).getComputer() : null;
+        }
     }
 }

src/main/java/dan200/computercraft/shared/peripheral/monitor/ClientMonitor.java

@@ -2,6 +2,7 @@ package dan200.computercraft.shared.peripheral.monitor;
 
 import dan200.computercraft.shared.common.ClientTerminal;
 import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.util.math.BlockPos;
 
 import java.util.HashSet;
 import java.util.Iterator;
@@ -14,6 +15,7 @@ public class ClientMonitor extends ClientTerminal
     private final TileMonitor origin;
 
     public long lastRenderFrame = -1;
+    public BlockPos lastRenderPos = null;
     public int[] renderDisplayLists = null;
 
     public ClientMonitor( boolean colour, TileMonitor origin )

src/main/java/dan200/computercraft/shared/pocket/core/PocketServerComputer.java

@@ -8,6 +8,7 @@ import dan200.computercraft.shared.computer.core.ComputerFamily;
 import dan200.computercraft.shared.computer.core.ServerComputer;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
@@ -138,7 +139,7 @@ public class PocketServerComputer extends ServerComputer implements IPocketAcces
     {
         if( this.m_upgrade == upgrade ) return;
 
-        synchronized (this)
+        synchronized( this )
         {
             ComputerCraft.Items.pocketComputer.setUpgrade( m_stack, upgrade );
             if( m_entity instanceof EntityPlayer ) ((EntityPlayer) m_entity).inventory.markDirty();
@@ -156,6 +157,9 @@ public class PocketServerComputer extends ServerComputer implements IPocketAcces
             setPosition( entity.getPosition() );
         }
 
+        // If a new entity has picked it up then rebroadcast the terminal to them
+        if( entity != m_entity && entity instanceof EntityPlayerMP ) markTerminalChanged();
+
         m_entity = entity;
         m_stack = stack;
 
@@ -165,4 +169,19 @@ public class PocketServerComputer extends ServerComputer implements IPocketAcces
             invalidatePeripheral();
         }
     }
+
+    public void broadcastState( boolean force )
+    {
+        super.broadcastState( force );
+
+        if( (hasTerminalChanged() || force) && m_entity instanceof EntityPlayerMP )
+        {
+            // Broadcast the state to the current entity if they're not already interacting with it.
+            EntityPlayerMP player = (EntityPlayerMP) m_entity;
+            if( player.connection != null && !isInteracting( player ) )
+            {
+                ComputerCraft.sendToPlayer( player, createTerminalPacket() );
+            }
+        }
+    }
 }

src/main/java/dan200/computercraft/shared/pocket/recipes/PocketComputerUpgradeRecipe.java

@@ -34,7 +34,7 @@ public class PocketComputerUpgradeRecipe extends IForgeRegistryEntry.Impl<IRecip
     }
 
     @Override
-    public boolean isHidden()
+    public boolean isDynamic()
     {
         return true;
     }

src/main/java/dan200/computercraft/shared/proxy/CCTurtleProxyCommon.java

@@ -21,7 +21,6 @@ import dan200.computercraft.shared.turtle.items.ItemTurtleNormal;
 import dan200.computercraft.shared.turtle.items.TurtleItemFactory;
 import dan200.computercraft.shared.turtle.recipes.TurtleUpgradeRecipe;
 import dan200.computercraft.shared.turtle.upgrades.*;
-import dan200.computercraft.shared.util.IEntityDropConsumer;
 import dan200.computercraft.shared.util.ImpostorRecipe;
 import dan200.computercraft.shared.util.InventoryUtil;
 import net.minecraft.block.Block;
@@ -33,33 +32,47 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.item.crafting.IRecipe;
 import net.minecraft.util.NonNullList;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.event.RegistryEvent;
+import net.minecraftforge.event.entity.EntityJoinWorldEvent;
 import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.registry.EntityRegistry;
 import net.minecraftforge.fml.common.registry.GameRegistry;
 import net.minecraftforge.registries.IForgeRegistry;
 
 import javax.annotation.Nonnull;
-import java.util.*;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
 
 public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
-{    
+{
     private Map<Integer, ITurtleUpgrade> m_legacyTurtleUpgrades;
     private Map<String, ITurtleUpgrade> m_turtleUpgrades;
-    private Map<Entity, IEntityDropConsumer> m_dropConsumers;
+
+    private Consumer<ItemStack> dropConsumer;
+    private WeakReference<World> dropWorld;
+    private BlockPos dropPos;
+    private AxisAlignedBB dropBounds;
+    private WeakReference<Entity> dropEntity;
 
     public CCTurtleProxyCommon()
     {
         m_legacyTurtleUpgrades = new HashMap<>();
         m_turtleUpgrades = new HashMap<>();
-        m_dropConsumers = new WeakHashMap<>();
     }
-    
+
     // ICCTurtleProxy implementation
-    
-    @Override        
+
+    @Override
     public void preInit()
     {
         MinecraftForge.EVENT_BUS.register( this );
@@ -75,8 +88,8 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
         // RecipeSorter.register( "computercraft:turtle", TurtleRecipe.class, RecipeSorter.Category.SHAPED, "after:minecraft:shapeless" );
         // RecipeSorter.register( "computercraft:turtle_upgrade", TurtleUpgradeRecipe.class, RecipeSorter.Category.SHAPED, "after:minecraft:shapeless" );
     }
-    
-    @Override        
+
+    @Override
     public void init()
     {
         registerForgeHandlers();
@@ -94,7 +107,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
             ComputerCraft.log.error( message );
             throw new RuntimeException( message );
         }
-        
+
         // Register
         registerTurtleUpgradeInternal( upgrade );
     }
@@ -110,7 +123,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
     {
         return m_legacyTurtleUpgrades.get( legacyId );
     }
-    
+
     @Override
     public ITurtleUpgrade getTurtleUpgrade( @Nonnull ItemStack stack )
     {
@@ -126,7 +139,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
             }
             catch( Exception e )
             {
-                ComputerCraft.log.error("Error getting computer upgrade item", e);
+                ComputerCraft.log.error( "Error getting computer upgrade item", e );
             }
         }
         return null;
@@ -148,7 +161,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
             return true;
         }
     }
-    
+
     private void addAllUpgradedTurtles( ComputerFamily family, NonNullList<ItemStack> list )
     {
         ItemStack basicStack = TurtleItemFactory.create( -1, null, -1, family, null, null, 0, null );
@@ -169,7 +182,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
 
     private void addUpgradedTurtle( ComputerFamily family, ITurtleUpgrade upgrade, List<ItemStack> list )
     {
-        if ( isUpgradeSuitableForFamily( family, upgrade ) )
+        if( isUpgradeSuitableForFamily( family, upgrade ) )
         {
             ItemStack stack = TurtleItemFactory.create( -1, null, -1, family, upgrade, null, 0, null );
             if( !stack.isEmpty() )
@@ -178,54 +191,58 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
             }
         }
     }
-    
+
     @Override
     public void addAllUpgradedTurtles( NonNullList<ItemStack> list )
     {
         addAllUpgradedTurtles( ComputerFamily.Normal, list );
         addAllUpgradedTurtles( ComputerFamily.Advanced, list );
     }
-    
+
     @Override
-    public void setEntityDropConsumer( Entity entity, IEntityDropConsumer consumer )
+    public void setDropConsumer( Entity entity, Consumer<ItemStack> consumer )
     {
-        if( !m_dropConsumers.containsKey( entity ) )
-        {
-            boolean captured = entity.captureDrops;
-            
-            if( !captured )
-            {
-                entity.captureDrops = true;
-                ArrayList<EntityItem> items = entity.capturedDrops;
-                
-                if( items == null || items.size() == 0 )
-                {
-                    m_dropConsumers.put( entity, consumer );
-                }
-            }
-        }
-    }    
-    
+        dropConsumer = consumer;
+        dropEntity = new WeakReference<>( entity );
+        dropWorld = new WeakReference<>( entity.world );
+        dropPos = null;
+        dropBounds = new AxisAlignedBB( entity.getPosition() ).grow( 2, 2, 2 );
+
+        entity.captureDrops = true;
+    }
+
     @Override
-    public void clearEntityDropConsumer( Entity entity )
+    public void setDropConsumer( World world, BlockPos pos, Consumer<ItemStack> consumer )
     {
-        if( m_dropConsumers.containsKey( entity ) )
+        dropConsumer = consumer;
+        dropEntity = null;
+        dropWorld = new WeakReference<>( world );
+        dropPos = pos;
+        dropBounds = new AxisAlignedBB( pos ).grow( 2, 2, 2 );
+    }
+
+    @Override
+    public void clearDropConsumer()
+    {
+        if( dropEntity != null )
         {
-            boolean captured = entity.captureDrops;
-            
-            if( captured )
+            Entity entity = dropEntity.get();
+            if( entity != null )
             {
                 entity.captureDrops = false;
-                ArrayList<EntityItem> items = entity.capturedDrops;
-                
-                if( items != null )
+                if( entity.capturedDrops != null )
                 {
-                    dispatchEntityDrops( entity, items );
-                    items.clear();
+                    for( EntityItem entityItem : entity.capturedDrops ) dropConsumer.accept( entityItem.getItem() );
+                    entity.capturedDrops.clear();
                 }
             }
-            m_dropConsumers.remove( entity );
         }
+
+        dropConsumer = null;
+        dropEntity = null;
+        dropWorld = null;
+        dropPos = null;
+        dropBounds = null;
     }
 
     private void registerTurtleUpgradeInternal( ITurtleUpgrade upgrade )
@@ -289,7 +306,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
     {
         IForgeRegistry<Item> registry = event.getRegistry();
 
-        registry.register( new ItemTurtleLegacy( ComputerCraft.Blocks.turtle).setRegistryName( new ResourceLocation( ComputerCraft.MOD_ID, "turtle" ) ) );
+        registry.register( new ItemTurtleLegacy( ComputerCraft.Blocks.turtle ).setRegistryName( new ResourceLocation( ComputerCraft.MOD_ID, "turtle" ) ) );
         registry.register( new ItemTurtleNormal( ComputerCraft.Blocks.turtleExpanded ).setRegistryName( new ResourceLocation( ComputerCraft.MOD_ID, "turtle_expanded" ) ) );
         registry.register( new ItemTurtleAdvanced( ComputerCraft.Blocks.turtleAdvanced ).setRegistryName( new ResourceLocation( ComputerCraft.MOD_ID, "turtle_advanced" ) ) );
     }
@@ -362,7 +379,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
     private void registerUpgrades()
     {
         // Upgrades
-        ComputerCraft.Upgrades.wirelessModem =  new TurtleModem( false, new ResourceLocation( "computercraft", "wireless_modem" ), 1 );
+        ComputerCraft.Upgrades.wirelessModem = new TurtleModem( false, new ResourceLocation( "computercraft", "wireless_modem" ), 1 );
         registerTurtleUpgradeInternal( ComputerCraft.Upgrades.wirelessModem );
 
         ComputerCraft.Upgrades.craftingTable = new TurtleCraftingTable( 2 );
@@ -447,26 +464,54 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
         GameRegistry.registerTileEntity( TileTurtleExpanded.class, ComputerCraft.LOWER_ID + " : " + "turtleex" );
         GameRegistry.registerTileEntity( TileTurtleAdvanced.class, ComputerCraft.LOWER_ID + " : " + "turtleadv" );
     }
-    
+
     private void registerForgeHandlers()
     {
         ForgeHandlers handlers = new ForgeHandlers();
         MinecraftForge.EVENT_BUS.register( handlers );
     }
-        
-    public class ForgeHandlers
-    {
-        private ForgeHandlers()
-        {
-        }
 
-        // Forge event responses 
-        @SubscribeEvent
+    private class ForgeHandlers
+    {
+        @SubscribeEvent(priority = EventPriority.LOWEST)
         public void onEntityLivingDrops( LivingDropsEvent event )
         {
-            dispatchEntityDrops( event.getEntity(), event.getDrops() );
+            // Capture any mob drops for the current entity
+            if( dropEntity != null && event.getEntity() == dropEntity.get() )
+            {
+                List<EntityItem> drops = event.getDrops();
+                for( EntityItem entityItem : drops ) dropConsumer.accept( entityItem.getItem() );
+                drops.clear();
+            }
         }
-        
+
+        @SubscribeEvent(priority = EventPriority.LOWEST)
+        public void onHarvestDrops( BlockEvent.HarvestDropsEvent event )
+        {
+            // Capture block drops for the current entity
+            if( dropWorld != null && dropWorld.get() == event.getWorld()
+                && dropPos != null && dropPos.equals( event.getPos() ) )
+            {
+                for( ItemStack item : event.getDrops() )
+                {
+                    if( event.getWorld().rand.nextFloat() < event.getDropChance() ) dropConsumer.accept( item );
+                }
+                event.getDrops().clear();
+            }
+        }
+
+        @SubscribeEvent(priority = EventPriority.LOWEST)
+        public void onEntitySpawn( EntityJoinWorldEvent event )
+        {
+            // Capture any nearby item spawns
+            if( dropWorld != null && dropWorld.get() == event.getWorld() && event.getEntity() instanceof EntityItem
+                && dropBounds.contains( event.getEntity().getPositionVector() ) )
+            {
+                dropConsumer.accept( ((EntityItem) event.getEntity()).getItem() );
+                event.setCanceled( true );
+            }
+        }
+
         @SubscribeEvent
         public void onTurtleAction( TurtleActionEvent event) {
             if( ComputerCraft.turtleDisabledActions.contains( event.getAction() ) )
@@ -475,18 +520,5 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
             }
         }
     }
-    
-    private void dispatchEntityDrops( Entity entity, java.util.List<EntityItem> drops )
-    {
-        IEntityDropConsumer consumer = m_dropConsumers.get( entity );
-        if( consumer != null )
-        {
-            // All checks have passed, lets dispatch the drops
-            for(EntityItem entityItem : drops)
-            {
-                consumer.consumeDrop( entity, entityItem.getItem() );
-            }
-            drops.clear();
-        }
-    }
+
 }

src/main/java/dan200/computercraft/shared/proxy/ComputerCraftProxyCommon.java

@@ -10,6 +10,8 @@ import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.core.computer.MainThread;
+import dan200.computercraft.shared.command.CommandComputer;
+import dan200.computercraft.shared.command.CommandComputerCraft;
 import dan200.computercraft.shared.command.ContainerViewComputer;
 import dan200.computercraft.shared.common.ColourableRecipe;
 import dan200.computercraft.shared.common.DefaultBundledRedstoneProvider;
@@ -49,8 +51,9 @@ import dan200.computercraft.shared.pocket.recipes.PocketComputerUpgradeRecipe;
 import dan200.computercraft.shared.turtle.blocks.TileTurtle;
 import dan200.computercraft.shared.turtle.inventory.ContainerTurtle;
 import dan200.computercraft.shared.util.*;
-import dan200.computercraft.shared.wired.DefaultWiredProvider;
+import dan200.computercraft.shared.wired.CapabilityWiredElement;
 import net.minecraft.block.Block;
+import net.minecraft.command.CommandHandler;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
@@ -63,6 +66,7 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.item.crafting.IRecipe;
 import net.minecraft.item.crafting.Ingredient;
 import net.minecraft.network.play.server.SPacketUpdateTileEntity;
+import net.minecraft.server.MinecraftServer;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.*;
 import net.minecraft.util.math.BlockPos;
@@ -115,6 +119,14 @@ public abstract class ComputerCraftProxyCommon implements IComputerCraftProxy
         registerForgeHandlers();
     }
 
+    @Override
+    public void initServer( MinecraftServer server )
+    {
+        CommandHandler handler = (CommandHandler) server.getCommandManager();
+        handler.registerCommand( new CommandComputer() );
+        handler.registerCommand( new CommandComputerCraft() );
+    }
+
     @Override
     public abstract boolean isClient();
 
@@ -154,7 +166,8 @@ public abstract class ComputerCraftProxyCommon implements IComputerCraftProxy
             packet.m_dataInt = new int[] { pos.getX(), pos.getY(), pos.getZ() };
         }
 
-        ComputerCraft.sendToAllPlayers( packet );
+        NetworkRegistry.TargetPoint point = new NetworkRegistry.TargetPoint( world.provider.getDimension(), pos.getX(), pos.getY(), pos.getZ(), 64 );
+        ComputerCraft.sendToAllAround( packet, point );
     }
 
     @Override
@@ -485,7 +498,7 @@ public abstract class ComputerCraftProxyCommon implements IComputerCraftProxy
         ComputerCraftAPI.registerMediaProvider( new DefaultMediaProvider() );
 
         // Register network providers
-        ComputerCraftAPI.registerWiredProvider( new DefaultWiredProvider() );
+        CapabilityWiredElement.register();
     }
 
     private void registerForgeHandlers()

src/main/java/dan200/computercraft/shared/proxy/ICCTurtleProxy.java

@@ -7,12 +7,14 @@
 package dan200.computercraft.shared.proxy;
 
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.shared.util.IEntityDropConsumer;
 import net.minecraft.entity.Entity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.NonNullList;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
 
 import javax.annotation.Nonnull;
+import java.util.function.Consumer;
 
 public interface ICCTurtleProxy
 {
@@ -25,6 +27,7 @@ public interface ICCTurtleProxy
     ITurtleUpgrade getTurtleUpgrade( @Nonnull ItemStack item );
     void addAllUpgradedTurtles( NonNullList<ItemStack> list );
 
-    void setEntityDropConsumer( Entity entity, IEntityDropConsumer consumer );
-    void clearEntityDropConsumer( Entity entity );
+    void setDropConsumer( Entity entity, Consumer<ItemStack> consumer );
+    void setDropConsumer( World world, BlockPos pos, Consumer<ItemStack> consumer );
+    void clearDropConsumer();
 }

src/main/java/dan200/computercraft/shared/proxy/IComputerCraftProxy.java

@@ -16,6 +16,7 @@ import dan200.computercraft.shared.turtle.blocks.TileTurtle;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
+import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.EnumHand;
 import net.minecraft.util.SoundEvent;
 import net.minecraft.util.math.BlockPos;
@@ -28,6 +29,7 @@ public interface IComputerCraftProxy
 {
     void preInit();
     void init();
+    void initServer( MinecraftServer server );
     boolean isClient();
 
     boolean getGlobalCursorBlink();

src/main/java/dan200/computercraft/shared/turtle/apis/TurtleAPI.java

@@ -15,6 +15,7 @@ import dan200.computercraft.api.turtle.TurtleSide;
 import dan200.computercraft.api.turtle.event.TurtleAction;
 import dan200.computercraft.api.turtle.event.TurtleActionEvent;
 import dan200.computercraft.core.apis.IAPIEnvironment;
+import dan200.computercraft.core.tracking.TrackingField;
 import dan200.computercraft.shared.turtle.core.*;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
@@ -161,70 +162,83 @@ public class TurtleAPI implements ILuaAPI
             case 0:
             {
                 // forward
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleMoveCommand( MoveDirection.Forward ) );
             }
             case 1:
             {
                 // back
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleMoveCommand( MoveDirection.Back ) );
             }
             case 2:
             {
                 // up
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleMoveCommand( MoveDirection.Up ) );
             }
             case 3:
             {
                 // down
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleMoveCommand( MoveDirection.Down ) );
             }
             case 4:
             {
                 // turnLeft
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleTurnCommand( TurnDirection.Left ) );
             }
             case 5:
             {
                 // turnRight
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleTurnCommand( TurnDirection.Right ) );
             }
             case 6:
             {
                 // dig
                 Optional<TurtleSide> side = parseSide( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleDigCommand( InteractDirection.Forward, side ) );
             }
             case 7:
             {
                 // digUp
                 Optional<TurtleSide> side = parseSide( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleDigCommand( InteractDirection.Up, side ) );
             }
             case 8:
             {
                 // digDown
                 Optional<TurtleSide> side = parseSide( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleDigCommand( InteractDirection.Down, side ) );
             }
             case 9:
             {
                 // place
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtlePlaceCommand( InteractDirection.Forward, args ) );
             }
             case 10:
             {
                 // placeUp
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtlePlaceCommand( InteractDirection.Up, args ) );
             }
             case 11:
             {
                 // placeDown
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtlePlaceCommand( InteractDirection.Down, args ) );
             }
             case 12:
             {
                 // drop
                 int count = parseCount( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleDropCommand( InteractDirection.Forward, count ) );
             }
             case 13:
@@ -294,48 +308,56 @@ public class TurtleAPI implements ILuaAPI
             {
                 // attack
                 Optional<TurtleSide> side = parseSide( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleAttackCommand( InteractDirection.Forward, side ) );
             }
             case 23:
             {
                 // attackUp
                 Optional<TurtleSide> side = parseSide( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleAttackCommand( InteractDirection.Up, side ) );
             }
             case 24:
             {
                 // attackDown
                 Optional<TurtleSide> side = parseSide( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleAttackCommand( InteractDirection.Down, side ) );
             }
             case 25:
             {
                 // dropUp
                 int count = parseCount( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleDropCommand( InteractDirection.Up, count ) );
             }
             case 26:
             {
                 // dropDown
                 int count = parseCount( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleDropCommand( InteractDirection.Down, count ) );
             }
             case 27:
             {
                 // suck
                 int count = parseCount( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleSuckCommand( InteractDirection.Forward, count ) );
             }
             case 28:
             {
                 // suckUp
                 int count = parseCount( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleSuckCommand( InteractDirection.Up, count ) );
             }
             case 29:
             {
                 // suckDown
                 int count = parseCount( args, 0 );
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleSuckCommand( InteractDirection.Down, count ) );
             }
             case 30:
@@ -389,11 +411,13 @@ public class TurtleAPI implements ILuaAPI
             case 36:
             {
                 // equipLeft
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleEquipCommand( TurtleSide.Left ) );
             }
             case 37:
             {
                 // equipRight
+                m_environment.addTrackingChange( TrackingField.TURTLE_OPS );
                 return tryCommand( context, new TurtleEquipCommand( TurtleSide.Right ) );
             }
             case 38:

src/main/java/dan200/computercraft/shared/turtle/core/TurtleBrain.java

@@ -127,6 +127,8 @@ public class TurtleBrain implements ITurtleAccess
     private TurtleAnimation m_animation;
     private int m_animationProgress;
     private int m_lastAnimationProgress;
+    
+    TurtlePlayer m_cachedPlayer;
 
     public TurtleBrain( TileTurtle turtle )
     {

src/main/java/dan200/computercraft/shared/turtle/core/TurtlePlaceCommand.java

@@ -180,12 +180,12 @@ public class TurtlePlaceCommand implements ITurtleCommand
 
     public static TurtlePlayer createPlayer( ITurtleAccess turtle, BlockPos position, EnumFacing direction )
     {
-        TurtlePlayer turtlePlayer = new TurtlePlayer( turtle );
+        TurtlePlayer turtlePlayer = TurtlePlayer.get( turtle );
         orientPlayer( turtle, turtlePlayer, position, direction );
         return turtlePlayer;
     }
 
-    public static void orientPlayer( ITurtleAccess turtle, TurtlePlayer turtlePlayer, BlockPos position, EnumFacing direction )
+    private static void orientPlayer( ITurtleAccess turtle, TurtlePlayer turtlePlayer, BlockPos position, EnumFacing direction )
     {
         turtlePlayer.posX = position.getX() + 0.5;
         turtlePlayer.posY = position.getY() + 0.5;
@@ -241,7 +241,7 @@ public class TurtlePlaceCommand implements ITurtleCommand
         // Start claiming entity drops
         Entity hitEntity = hit.getKey();
         Vec3d hitPos = hit.getValue();
-        ComputerCraft.setEntityDropConsumer( hitEntity, ( entity, drop ) ->
+        ComputerCraft.setDropConsumer( hitEntity, ( drop ) ->
         {
             ItemStack remainder = InventoryUtil.storeItems( drop, turtle.getItemHandler(), turtle.getSelectedSlot() );
             if( !remainder.isEmpty() )
@@ -285,7 +285,7 @@ public class TurtlePlaceCommand implements ITurtleCommand
         }
 
         // Stop claiming drops
-        ComputerCraft.clearEntityDropConsumer( hitEntity );
+        ComputerCraft.clearDropConsumer();
 
         // Put everything we collected into the turtles inventory, then return
         ItemStack remainder = turtlePlayer.unloadInventory( turtle );
@@ -382,7 +382,7 @@ public class TurtlePlaceCommand implements ITurtleCommand
 
         // Do the deploying (put everything in the players inventory)
         boolean placed = false;
-
+        TileEntity existingTile = turtle.getWorld().getTileEntity( position );
 
         // See PlayerInteractionManager.processRightClickBlock
         PlayerInteractEvent.RightClickBlock event = ForgeHooks.onRightClickBlock( turtlePlayer, EnumHand.MAIN_HAND, position, side, new Vec3d( hitX, hitY, hitZ ) );
@@ -426,12 +426,11 @@ public class TurtlePlaceCommand implements ITurtleCommand
             {
                 World world = turtle.getWorld();
                 TileEntity tile = world.getTileEntity( position );
-                if( tile == null )
+                if( tile == null || tile == existingTile )
                 {
-                    BlockPos newPosition = WorldUtil.moveCoords( position, side );
-                    tile = world.getTileEntity( newPosition );
+                    tile = world.getTileEntity( WorldUtil.moveCoords( position, side ) );
                 }
-                if( tile != null && tile instanceof TileEntitySign )
+                if( tile instanceof TileEntitySign )
                 {
                     TileEntitySign signTile = (TileEntitySign) tile;
                     String s = (String)extraArguments[0];

src/main/java/dan200/computercraft/shared/turtle/core/TurtlePlayer.java

@@ -11,10 +11,16 @@ import dan200.computercraft.api.turtle.ITurtleAccess;
 import dan200.computercraft.shared.util.InventoryUtil;
 import dan200.computercraft.shared.util.WorldUtil;
 import net.minecraft.entity.Entity;
+import net.minecraft.entity.IMerchant;
+import net.minecraft.entity.passive.AbstractHorse;
+import net.minecraft.inventory.IInventory;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntitySign;
 import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.IInteractionObject;
 import net.minecraft.world.World;
 import net.minecraft.world.WorldServer;
 import net.minecraftforge.common.util.FakePlayer;
@@ -30,16 +36,31 @@ public class TurtlePlayer extends FakePlayer
         "[ComputerCraft]"
     );
 
+    /**
+     * Construct a TurtlePlayer which exists in the world
+     *
+     * @param world The world the player exists in
+     * @deprecated This is required by {@link Entity}.
+     */
     @Deprecated
     public TurtlePlayer( World world )
     {
         super( (WorldServer) world, DEFAULT_PROFILE );
     }
-    
-    public TurtlePlayer( ITurtleAccess turtle )
-    {
-        super( (WorldServer) turtle.getWorld(), getProfile( turtle.getOwningPlayer() ));
 
+    private TurtlePlayer( ITurtleAccess turtle )
+    {
+        super( (WorldServer) turtle.getWorld(), getProfile( turtle.getOwningPlayer() ) );
+        setState( turtle );
+    }
+
+    private static GameProfile getProfile( @Nullable GameProfile profile )
+    {
+        return profile != null && profile.isComplete() ? profile : DEFAULT_PROFILE;
+    }
+
+    private void setState( ITurtleAccess turtle )
+    {
         BlockPos position = turtle.getPosition();
         posX = position.getX() + 0.5;
         posY = position.getY() + 0.5;
@@ -47,11 +68,27 @@ public class TurtlePlayer extends FakePlayer
 
         rotationYaw = turtle.getDirection().getHorizontalAngle();
         rotationPitch = 0.0f;
+
+        inventory.clear();
     }
 
-    private static GameProfile getProfile( @Nullable GameProfile profile )
+    public static TurtlePlayer get( ITurtleAccess access )
     {
-        return profile != null && profile.isComplete() ? profile : DEFAULT_PROFILE;
+        if( !(access instanceof TurtleBrain) ) return new TurtlePlayer( access );
+
+        TurtleBrain brain = (TurtleBrain) access;
+        TurtlePlayer player = brain.m_cachedPlayer;
+        if( player == null || player.getGameProfile() != getProfile( access.getOwningPlayer() )
+            || player.getEntityWorld() != access.getWorld() )
+        {
+            player = brain.m_cachedPlayer = new TurtlePlayer( brain );
+        }
+        else
+        {
+            player.setState( access );
+        }
+
+        return player;
     }
 
     public void loadInventory( @Nonnull ItemStack currentStack )
@@ -70,7 +107,7 @@ public class TurtlePlayer extends FakePlayer
         // Store (or drop) anything else we found
         BlockPos dropPosition = turtle.getPosition();
         EnumFacing dropDirection = turtle.getDirection().getOpposite();
-        for( int i=0; i<inventory.getSizeInventory(); ++i )
+        for( int i = 0; i < inventory.getSizeInventory(); ++i )
         {
             ItemStack stack = inventory.getStackInSlot( i );
             if( !stack.isEmpty() )
@@ -87,6 +124,12 @@ public class TurtlePlayer extends FakePlayer
         return results;
     }
 
+    @Override
+    public Vec3d getPositionVector()
+    {
+        return new Vec3d( posX, posY, posZ );
+    }
+
     @Override
     public float getEyeHeight()
     {
@@ -99,6 +142,63 @@ public class TurtlePlayer extends FakePlayer
         return 0.0f;
     }
 
+    @Override
+    public void sendEnterCombat()
+    {
+    }
+
+    @Override
+    public void sendEndCombat()
+    {
+    }
+
+    @Nonnull
+    @Override
+    public SleepResult trySleep( @Nonnull BlockPos bedLocation )
+    {
+        return SleepResult.OTHER_PROBLEM;
+    }
+
+    @Override
+    public void openEditSign( TileEntitySign signTile )
+    {
+    }
+
+    @Override
+    public void displayGui( IInteractionObject guiOwner )
+    {
+    }
+
+    @Override
+    public void displayGUIChest( IInventory chestInventory )
+    {
+    }
+
+    @Override
+    public void displayVillagerTradeGui( IMerchant villager )
+    {
+    }
+
+    @Override
+    public void openGuiHorseInventory( AbstractHorse horse, IInventory inventoryIn )
+    {
+    }
+
+    @Override
+    public void openBook( ItemStack stack, @Nonnull EnumHand hand )
+    {
+    }
+
+    @Override
+    public void updateHeldItem()
+    {
+    }
+
+    @Override
+    protected void onItemUseFinish()
+    {
+    }
+
     @Override
     public void mountEntityAndWakeUp()
     {
@@ -108,9 +208,4 @@ public class TurtlePlayer extends FakePlayer
     public void dismountEntity( @Nonnull Entity entity )
     {
     }
-
-    @Override
-    public void openEditSign( TileEntitySign signTile )
-    {
-    }
 }

src/main/java/dan200/computercraft/shared/turtle/recipes/TurtleUpgradeRecipe.java

@@ -37,7 +37,7 @@ public class TurtleUpgradeRecipe extends IForgeRegistryEntry.Impl<IRecipe> imple
     }
 
     @Override
-    public boolean isHidden()
+    public boolean isDynamic()
     {
         return true;
     }

src/main/java/dan200/computercraft/shared/turtle/upgrades/TurtleHoe.java

@@ -11,13 +11,14 @@ import dan200.computercraft.api.turtle.TurtleCommandResult;
 import dan200.computercraft.api.turtle.TurtleSide;
 import dan200.computercraft.api.turtle.TurtleVerb;
 import dan200.computercraft.shared.turtle.core.TurtlePlaceCommand;
+import dan200.computercraft.shared.turtle.core.TurtlePlayer;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
 import javax.annotation.Nonnull;
@@ -30,20 +31,16 @@ public class TurtleHoe extends TurtleTool
     }
 
     @Override
-    protected boolean canBreakBlock( World world, BlockPos pos )
+    protected boolean canBreakBlock( IBlockState state, World world, BlockPos pos, TurtlePlayer player )
     {
-        if( super.canBreakBlock( world, pos ) )
-        {
-            IBlockState state = world.getBlockState( pos );
-            Material material = state.getMaterial( );
-            return
-                material == Material.PLANTS ||
-                material == Material.CACTUS ||
-                material == Material.GOURD ||
-                material == Material.LEAVES ||
-                material == Material.VINE;
-        }
-        return false;
+        if( !super.canBreakBlock( state, world, pos, player ) ) return false;
+
+        Material material = state.getMaterial();
+        return material == Material.PLANTS ||
+            material == Material.CACTUS ||
+            material == Material.GOURD ||
+            material == Material.LEAVES ||
+            material == Material.VINE;
     }
 
     @Nonnull

src/main/java/dan200/computercraft/shared/turtle/upgrades/TurtleInventoryCrafting.java

@@ -118,7 +118,7 @@ public class TurtleInventoryCrafting extends InventoryCrafting
             }
 
             // Do post-pickup stuff
-            TurtlePlayer turtlePlayer = new TurtlePlayer( m_turtle );
+            TurtlePlayer turtlePlayer = TurtlePlayer.get( m_turtle );
             result.onCrafting( world, turtlePlayer, numToCraft );
             results.add( result );
 

src/main/java/dan200/computercraft/shared/turtle/upgrades/TurtleShovel.java

@@ -11,6 +11,7 @@ import dan200.computercraft.api.turtle.TurtleCommandResult;
 import dan200.computercraft.api.turtle.TurtleSide;
 import dan200.computercraft.api.turtle.TurtleVerb;
 import dan200.computercraft.shared.turtle.core.TurtlePlaceCommand;
+import dan200.computercraft.shared.turtle.core.TurtlePlayer;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.item.Item;
@@ -30,26 +31,22 @@ public class TurtleShovel extends TurtleTool
     }
 
     @Override
-    protected boolean canBreakBlock( World world, BlockPos pos )
+    protected boolean canBreakBlock( IBlockState state, World world, BlockPos pos, TurtlePlayer player )
     {
-        if( super.canBreakBlock( world, pos ) )
-        {
-            IBlockState state = world.getBlockState( pos );
-            Material material = state.getMaterial( );
-            return
-                    material == Material.GROUND ||
-                    material == Material.SAND ||
-                    material == Material.SNOW ||
-                    material == Material.CLAY ||
-                    material == Material.CRAFTED_SNOW ||
-                    material == Material.GRASS ||
-                    material == Material.PLANTS ||
-                    material == Material.CACTUS ||
-                    material == Material.GOURD ||
-                    material == Material.LEAVES ||
-                    material == Material.VINE;
-        }
-        return false;
+        if( !super.canBreakBlock( state, world, pos, player ) ) return false;
+
+        Material material = state.getMaterial();
+        return material == Material.GROUND ||
+            material == Material.SAND ||
+            material == Material.SNOW ||
+            material == Material.CLAY ||
+            material == Material.CRAFTED_SNOW ||
+            material == Material.GRASS ||
+            material == Material.PLANTS ||
+            material == Material.CACTUS ||
+            material == Material.GOURD ||
+            material == Material.LEAVES ||
+            material == Material.VINE;
     }
 
     @Nonnull

src/main/java/dan200/computercraft/shared/turtle/upgrades/TurtleSword.java

@@ -5,11 +5,13 @@
  */
 
 package dan200.computercraft.shared.turtle.upgrades;
+
+import dan200.computercraft.shared.turtle.core.TurtlePlayer;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.item.Item;
-import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
 public class TurtleSword extends TurtleTool
@@ -20,20 +22,16 @@ public class TurtleSword extends TurtleTool
     }
 
     @Override
-    protected boolean canBreakBlock( World world, BlockPos pos )
+    protected boolean canBreakBlock( IBlockState state, World world, BlockPos pos, TurtlePlayer player )
     {
-        if( super.canBreakBlock( world, pos ) )
-        {
-            IBlockState state = world.getBlockState( pos );
-            Material material = state.getMaterial( );
-            return
-                    material == Material.PLANTS ||
-                    material == Material.LEAVES ||
-                    material == Material.VINE ||
-                    material == Material.CLOTH ||
-                    material == Material.WEB;
-        }
-        return false;
+        if( !super.canBreakBlock( state, world, pos, player ) ) return false;
+
+        Material material = state.getMaterial();
+        return material == Material.PLANTS ||
+            material == Material.LEAVES ||
+            material == Material.VINE ||
+            material == Material.CLOTH ||
+            material == Material.WEB;
     }
 
     @Override

src/main/java/dan200/computercraft/shared/turtle/upgrades/TurtleTool.java

@@ -23,20 +23,17 @@ import net.minecraft.client.renderer.block.model.IBakedModel;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.SharedMonsterAttributes;
 import net.minecraft.entity.item.EntityArmorStand;
-import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.DamageSource;
 import net.minecraft.util.EnumFacing;
-import net.minecraft.util.NonNullList;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.World;
-import net.minecraftforge.common.ForgeHooks;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.event.ForgeEventFactory;
 import net.minecraftforge.event.entity.player.AttackEntityEvent;
 import net.minecraftforge.event.world.BlockEvent;
 import net.minecraftforge.fml.relauncher.Side;
@@ -45,7 +42,9 @@ import org.apache.commons.lang3.tuple.Pair;
 
 import javax.annotation.Nonnull;
 import javax.vecmath.Matrix4f;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
 
 public class TurtleTool implements ITurtleUpgrade
 {
@@ -104,7 +103,7 @@ public class TurtleTool implements ITurtleUpgrade
 
     @Nonnull
     @Override
-    @SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     public Pair<IBakedModel, Matrix4f> getModel( ITurtleAccess turtle, @Nonnull TurtleSide side )
     {
         float xOffset = (side == TurtleSide.Left) ? -0.40625f : 0.40625f;
@@ -142,22 +141,15 @@ public class TurtleTool implements ITurtleUpgrade
         }
     }
 
-    protected boolean canBreakBlock( World world, BlockPos pos )
+    protected boolean canBreakBlock( IBlockState state, World world, BlockPos pos, TurtlePlayer player )
     {
-        IBlockState state = world.getBlockState( pos );
         Block block = state.getBlock();
-        return !block.isAir( state, world, pos ) && block != Blocks.BEDROCK && state.getBlockHardness( world, pos ) > -1.0F;
+        return !block.isAir( state, world, pos )
+            && block != Blocks.BEDROCK
+            && state.getPlayerRelativeBlockHardness( player, world, pos ) > 0
+            && block.canEntityDestroy( state, world, pos, player );
     }
-    
-    protected boolean canHarvestBlock( ITurtleAccess turtleAccess, BlockPos pos )
-    {
-        World world = turtleAccess.getWorld();
-        Block block = world.getBlockState( pos ).getBlock();
-        TurtlePlayer turtlePlayer = new TurtlePlayer( turtleAccess );
-        turtlePlayer.loadInventory( m_item.copy() );
-        return ForgeHooks.canHarvestBlock( block, turtlePlayer, world, pos );
-    }
-    
+
     protected float getDamageMultiplier()
     {
         return 3.0f;
@@ -195,20 +187,14 @@ public class TurtleTool implements ITurtleUpgrade
             }
             
             // Start claiming entity drops
-            ComputerCraft.setEntityDropConsumer( hitEntity, ( entity, drop ) ->
-            {
-                ItemStack remainder = InventoryUtil.storeItems( drop, turtle.getItemHandler(), turtle.getSelectedSlot() );
-                if( !remainder.isEmpty() )
-                {
-                    WorldUtil.dropItemStack( remainder, world, position, turtle.getDirection().getOpposite() );
-                }
-            } );
+            List<ItemStack> extra = new ArrayList<>(  );
+            ComputerCraft.setDropConsumer( hitEntity, turtleDropConsumer( turtle, extra ) );
 
             // Attack the entity
             boolean attacked = false;
             if( !hitEntity.hitByEntity( turtlePlayer ) )
             {
-                float damage = (float)turtlePlayer.getEntityAttribute( SharedMonsterAttributes.ATTACK_DAMAGE ).getAttributeValue();
+                float damage = (float) turtlePlayer.getEntityAttribute( SharedMonsterAttributes.ATTACK_DAMAGE ).getAttributeValue();
                 damage *= getDamageMultiplier();
                 if( damage > 0.0f )
                 {
@@ -234,7 +220,7 @@ public class TurtleTool implements ITurtleUpgrade
             }
 
             // Stop claiming drops
-            ComputerCraft.clearEntityDropConsumer( hitEntity );
+            stopConsuming( turtle, extra );
 
             // Put everything we collected into the turtles inventory, then return
             if( attacked )
@@ -251,70 +237,73 @@ public class TurtleTool implements ITurtleUpgrade
     {
         // Get ready to dig
         World world = turtle.getWorld();
-        BlockPos position = turtle.getPosition();
-        BlockPos newPosition = WorldUtil.moveCoords( position, direction );
+        BlockPos turtlePosition = turtle.getPosition();
+        BlockPos blockPosition = WorldUtil.moveCoords( turtlePosition, direction );
 
-        if( WorldUtil.isBlockInWorld( world, newPosition ) &&
-            !world.isAirBlock( newPosition ) &&
-            !WorldUtil.isLiquidBlock( world, newPosition ) )
+        if( WorldUtil.isBlockInWorld( world, blockPosition ) &&
+            !world.isAirBlock( blockPosition ) &&
+            !WorldUtil.isLiquidBlock( world, blockPosition ) )
         {
-            TurtlePlayer turtlePlayer = TurtlePlaceCommand.createPlayer( turtle, position, direction );
+            IBlockState state = world.getBlockState( blockPosition );
+
+            TurtlePlayer turtlePlayer = TurtlePlaceCommand.createPlayer( turtle, turtlePosition, direction );
+            turtlePlayer.loadInventory( m_item.copy() );
+
             if( ComputerCraft.turtlesObeyBlockProtection )
             {
                 // Check spawn protection
-
-                if( MinecraftForge.EVENT_BUS.post( new BlockEvent.BreakEvent( world, newPosition, world.getBlockState( newPosition ), turtlePlayer ) ) )
+                if( MinecraftForge.EVENT_BUS.post( new BlockEvent.BreakEvent( world, blockPosition, state, turtlePlayer ) ) )
                 {
                     return TurtleCommandResult.failure( "Cannot break protected block" );
                 }
-                
-                if( !ComputerCraft.isBlockEditable( world, newPosition, turtlePlayer ) )
+
+                if( !ComputerCraft.isBlockEditable( world, blockPosition, turtlePlayer ) )
                 {
                     return TurtleCommandResult.failure( "Cannot break protected block" );
                 }
             }
 
             // Check if we can break the block
-            if( !canBreakBlock( world, newPosition ) )
+            if( !canBreakBlock( state, world, blockPosition, turtlePlayer ) )
             {
                 return TurtleCommandResult.failure( "Unbreakable block detected" );
             }
 
             // Fire the dig event, checking whether it was cancelled.
-            TurtleBlockEvent.Dig digEvent = new TurtleBlockEvent.Dig( turtle, turtlePlayer, world, newPosition, world.getBlockState( newPosition ), this, side );
+            TurtleBlockEvent.Dig digEvent = new TurtleBlockEvent.Dig( turtle, turtlePlayer, world, blockPosition, state, this, side );
             if( MinecraftForge.EVENT_BUS.post( digEvent ) )
             {
                 return TurtleCommandResult.failure( digEvent.getFailureMessage() );
             }
 
             // Consume the items the block drops
-            if( canHarvestBlock( turtle, newPosition ) )
-            {
-                List<ItemStack> items = getBlockDropped( world, newPosition, turtlePlayer );
-                if( items != null && items.size() > 0 )
-                {
-                    for( ItemStack stack : items )
-                    {
-                        ItemStack remainder = InventoryUtil.storeItems( stack, turtle.getItemHandler(), turtle.getSelectedSlot() );
-                        if( !remainder.isEmpty() )
-                        {
-                            // If there's no room for the items, drop them
-                            WorldUtil.dropItemStack( remainder, world, position, direction );
-                        }
-                    }
-                }
-            }
+            List<ItemStack> extra = new ArrayList<>(  );
+            ComputerCraft.setDropConsumer( world, blockPosition, turtleDropConsumer( turtle, extra ) );
+
+            TileEntity tile = world.getTileEntity( blockPosition );
+
+            // Much of this logic comes from PlayerInteractionManager#tryHarvestBlock, so it's a good idea
+            // to consult there before making any changes.
+
+            // Play the destruction sound
+            world.playEvent( 2001, blockPosition, Block.getStateId( state ) );
 
             // Destroy the block
-            IBlockState previousState = world.getBlockState( newPosition );
-            world.playEvent(2001, newPosition, Block.getStateId(previousState));
-            world.setBlockToAir( newPosition );
+            boolean canHarvest = state.getBlock().canHarvestBlock( world, blockPosition, turtlePlayer );
+            boolean canBreak = state.getBlock().removedByPlayer( state, world, blockPosition, turtlePlayer, canHarvest );
+            if( canBreak ) state.getBlock().onBlockDestroyedByPlayer( world, blockPosition, state );
+            if( canHarvest )
+            {
+                state.getBlock().harvestBlock( world, turtlePlayer, blockPosition, state, tile, turtlePlayer.getHeldItemMainhand() );
+            }
+
+            stopConsuming( turtle, extra );
 
             // Remember the previous block
             if( turtle instanceof TurtleBrain )
             {
-                TurtleBrain brain = (TurtleBrain)turtle;
-                brain.saveBlockChange( newPosition, previousState );
+                TurtleBrain brain = (TurtleBrain) turtle;
+                brain.saveBlockChange( blockPosition, state );
             }
 
             return TurtleCommandResult.success();
@@ -323,22 +312,21 @@ public class TurtleTool implements ITurtleUpgrade
         return TurtleCommandResult.failure( "Nothing to dig here" );
     }
 
-    @SuppressWarnings("deprecation")
-    private List<ItemStack> getBlockDropped( World world, BlockPos pos, EntityPlayer player )
+    private Consumer<ItemStack> turtleDropConsumer( ITurtleAccess turtle, List<ItemStack> extra )
     {
-        IBlockState state = world.getBlockState( pos );
-        Block block = state.getBlock();
-        // Note, we use the deprecated version as some mods override that instead. Those mods are wrong (TM).
-        List<ItemStack> drops = block.getDrops( world, pos, world.getBlockState( pos ), 0 );
-        double chance = ForgeEventFactory.fireBlockHarvesting( drops, world, pos, state, 0, 1, false, player );
-
-        for( int i = drops.size() - 1; i >= 0; i-- )
+        return ( drop ) ->
         {
-            if( world.rand.nextFloat() > chance )
-            {
-                drops.remove( i );
-            }
+            ItemStack remainder = InventoryUtil.storeItems( drop, turtle.getItemHandler(), turtle.getSelectedSlot() );
+            if( !remainder.isEmpty() ) extra.add( remainder );
+        };
+    }
+
+    private void stopConsuming( ITurtleAccess turtle, List<ItemStack> extra )
+    {
+        ComputerCraft.clearDropConsumer();
+        for( ItemStack remainder : extra )
+        {
+            WorldUtil.dropItemStack( remainder, turtle.getWorld(), turtle.getPosition(), turtle.getDirection().getOpposite() );
         }
-        return drops;
     }
 }

src/main/java/dan200/computercraft/shared/util/IEntityDropConsumer.java

@@ -1,16 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2017. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-
-package dan200.computercraft.shared.util;
-import net.minecraft.entity.Entity;
-import net.minecraft.item.ItemStack;
-
-import javax.annotation.Nonnull;
-
-public interface IEntityDropConsumer
-{
-    void consumeDrop( Entity dropper, @Nonnull ItemStack drop );
-}

src/main/java/dan200/computercraft/shared/util/WorldUtil.java

@@ -126,22 +126,8 @@ public class WorldUtil
     }
     
     public static Vec3d getRayEnd( EntityPlayer player) {
-        double reach = 4.5;
-        if( player instanceof EntityPlayerMP )
-        {
-            reach = ((EntityPlayerMP) player).interactionManager.getBlockReachDistance();
-        }
-        else if( player.getEntityWorld().isRemote )
-        {
-            reach = Minecraft.getMinecraft().playerController.getBlockReachDistance();
-        }
-        else if( player.capabilities.isCreativeMode )
-        {
-            reach = 5.0;
-        }
-        
+        double reach = player.getEntityAttribute(EntityPlayer.REACH_DISTANCE).getAttributeValue();
         Vec3d look = player.getLookVec();
-
         return getRayStart( player ).addVector( look.x * reach, look.y * reach, look.z * reach );
     }
     

src/main/java/dan200/computercraft/shared/wired/CapabilityWiredElement.java

@@ -0,0 +1,69 @@
+package dan200.computercraft.shared.wired;
+
+import dan200.computercraft.api.network.wired.IWiredElement;
+import dan200.computercraft.api.network.wired.IWiredNode;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.CapabilityInject;
+import net.minecraftforge.common.capabilities.CapabilityManager;
+
+import javax.annotation.Nonnull;
+
+public class CapabilityWiredElement
+{
+    @CapabilityInject( IWiredElement.class )
+    public static Capability<IWiredElement> CAPABILITY = null;
+
+    public static void register()
+    {
+        CapabilityManager.INSTANCE.register( IWiredElement.class, new NullStorage(), NullElement::new );
+    }
+
+    private static class NullElement implements IWiredElement
+    {
+        @Nonnull
+        @Override
+        public IWiredNode getNode()
+        {
+            throw new IllegalStateException( "Should not use the default element implementation" );
+        }
+
+        @Nonnull
+        @Override
+        public World getWorld()
+        {
+            throw new IllegalStateException( "Should not use the default element implementation" );
+        }
+
+        @Nonnull
+        @Override
+        public Vec3d getPosition()
+        {
+            throw new IllegalStateException( "Should not use the default element implementation" );
+        }
+
+        @Nonnull
+        @Override
+        public String getSenderID()
+        {
+            throw new IllegalStateException( "Should not use the default element implementation" );
+        }
+    }
+
+    private static class NullStorage implements Capability.IStorage<IWiredElement>
+    {
+        @Override
+        public NBTBase writeNBT( Capability<IWiredElement> capability, IWiredElement instance, EnumFacing side )
+        {
+            return null;
+        }
+
+        @Override
+        public void readNBT( Capability<IWiredElement> capability, IWiredElement instance, EnumFacing side, NBTBase base )
+        {
+        }
+    }
+}

src/main/java/dan200/computercraft/shared/wired/DefaultWiredProvider.java

@@ -1,23 +0,0 @@
-package dan200.computercraft.shared.wired;
-
-import dan200.computercraft.api.network.wired.IWiredElement;
-import dan200.computercraft.api.network.wired.IWiredElementTile;
-import dan200.computercraft.api.network.wired.IWiredProvider;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.IBlockAccess;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-public class DefaultWiredProvider implements IWiredProvider
-{
-    @Nullable
-    @Override
-    public IWiredElement getElement( @Nonnull IBlockAccess world, @Nonnull BlockPos pos, @Nonnull EnumFacing side )
-    {
-        TileEntity te = world.getTileEntity( pos );
-        return te instanceof IWiredElementTile ? ((IWiredElementTile) te).getWiredElement( side ) : null;
-    }
-}

src/main/java/dan200/computercraft/shared/wired/WiredNetwork.java

@@ -1,5 +1,7 @@
 package dan200.computercraft.shared.wired;
 
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
 import dan200.computercraft.api.network.Packet;
 import dan200.computercraft.api.network.wired.IWiredNetwork;
 import dan200.computercraft.api.network.wired.IWiredNode;
@@ -283,9 +285,10 @@ public final class WiredNetwork implements IWiredNetwork
     }
 
     @Override
-    public void invalidate( @Nonnull IWiredNode node )
+    public void updatePeripherals( @Nonnull IWiredNode node, @Nonnull Map<String, IPeripheral> newPeripherals )
     {
         WiredNode wired = checkNode( node );
+        Preconditions.checkNotNull( peripherals, "peripherals cannot be null" );
 
         lock.writeLock().lock();
         try
@@ -293,11 +296,10 @@ public final class WiredNetwork implements IWiredNetwork
             if( wired.network != this ) throw new IllegalStateException( "Node is not on this network" );
 
             Map<String, IPeripheral> oldPeripherals = wired.peripherals;
-            Map<String, IPeripheral> newPeripherals = wired.element.getPeripherals();
             WiredNetworkChange change = WiredNetworkChange.changeOf( oldPeripherals, newPeripherals );
             if( change.isEmpty() ) return;
 
-            wired.peripherals = newPeripherals;
+            wired.peripherals = ImmutableMap.copyOf( newPeripherals );
 
             // Detach the old peripherals then remove them.
             peripherals.keySet().removeAll( change.peripheralsRemoved().keySet() );

src/main/java/dan200/computercraft/shared/wired/WiredNetworkChange.java

@@ -10,6 +10,8 @@ import java.util.Map;
 
 public class WiredNetworkChange implements IWiredNetworkChange
 {
+    private static final WiredNetworkChange EMPTY = new WiredNetworkChange( Collections.emptyMap(), Collections.emptyMap() );
+
     private final Map<String, IPeripheral> removed;
     private final Map<String, IPeripheral> added;
 
@@ -26,16 +28,30 @@ public class WiredNetworkChange implements IWiredNetworkChange
 
     public static WiredNetworkChange added( Map<String, IPeripheral> added )
     {
-        return new WiredNetworkChange( Collections.emptyMap(), Collections.unmodifiableMap( added ) );
+        return added.isEmpty() ? EMPTY : new WiredNetworkChange( Collections.emptyMap(), Collections.unmodifiableMap( added ) );
     }
 
     public static WiredNetworkChange removed( Map<String, IPeripheral> removed )
     {
-        return new WiredNetworkChange( Collections.unmodifiableMap( removed ), Collections.emptyMap() );
+        return removed.isEmpty() ? EMPTY : new WiredNetworkChange( Collections.unmodifiableMap( removed ), Collections.emptyMap() );
     }
 
     public static WiredNetworkChange changeOf( Map<String, IPeripheral> oldPeripherals, Map<String, IPeripheral> newPeripherals )
     {
+        // Handle the trivial cases, where all peripherals have been added or removed.
+        if( oldPeripherals.isEmpty() && newPeripherals.isEmpty() )
+        {
+            return EMPTY;
+        }
+        else if( oldPeripherals.isEmpty() )
+        {
+            return new WiredNetworkChange( Collections.emptyMap(), newPeripherals );
+        }
+        else if( newPeripherals.isEmpty() )
+        {
+            return new WiredNetworkChange( oldPeripherals, Collections.emptyMap() );
+        }
+
         Map<String, IPeripheral> added = new HashMap<>( newPeripherals );
         Map<String, IPeripheral> removed = new HashMap<>();
 

src/main/resources/META-INF/computercraft_at.cfg

@@ -1,7 +1,7 @@
 # RecordMedia (and related methods)
 public net.minecraft.item.ItemRecord field_185076_b # sound
 public net.minecraft.item.ItemRecord field_185077_c # displayName
-# ItemPocketRenderer
+# ItemPocketRenderer/ItemPrintoutRenderer
 public net.minecraft.client.renderer.ItemRenderer func_187466_c()V # renderArms
 public net.minecraft.client.renderer.ItemRenderer func_178100_c(F)F # getMapAngleFromPitch
 public net.minecraft.client.renderer.ItemRenderer func_187456_a(FFLnet/minecraft/util/EnumHandSide;)V # renderArmFirstPerson

src/main/resources/assets/computercraft/lua/bios.lua

@@ -662,8 +662,36 @@ end
 if http then
     local nativeHTTPRequest = http.request
 
-    local function wrapRequest( _url, _post, _headers, _binary )
-        local ok, err = nativeHTTPRequest( _url, _post, _headers, _binary )
+    local methods = {
+        GET = true, POST = true, HEAD = true,
+        OPTIONS = true, PUT = true, DELETE = true
+    }
+
+    local function checkKey( options, key, ty, opt )
+        local value = options[key]
+        local valueTy = type(value)
+        
+        if (value ~= nil or not opt) and valueTy ~= ty then
+            error(("bad field '%s' (expected %s, got %s"):format(key, ty, valueTy), 4)
+        end
+    end
+
+    local function checkOptions( options, body )
+        checkKey( options, "url", "string")
+        if body == false 
+        then checkKey( options, "body", "nil" ) 
+        else checkKey( options, "body", "string", not body ) end
+        checkKey( options, "headers", "table", true )
+        checkKey( options, "method", "string", true )
+        checkKey( options, "redirect", "boolean", true )
+
+        if options.method and not methods[options.method] then
+            error( "Unsupported HTTP method", 3 )
+        end
+    end
+
+    local function wrapRequest( _url, ... )
+        local ok, err = nativeHTTPRequest( ... )
         if ok then
             while true do
                 local event, param1, param2, param3 = os.pullEvent()
@@ -678,6 +706,11 @@ if http then
     end
     
     http.get = function( _url, _headers, _binary)
+        if type( _url ) == "table" then
+            checkOptions( _url, false )
+            return wrapRequest( _url.url, _url )
+        end
+
         if type( _url ) ~= "string" then
             error( "bad argument #1 (expected string, got " .. type( _url ) .. ")", 2 ) 
         end
@@ -687,10 +720,15 @@ if http then
         if _binary ~= nil and type( _binary ) ~= "boolean" then
             error( "bad argument #3 (expected boolean, got " .. type( _binary ) .. ")", 2 ) 
         end
-        return wrapRequest( _url, nil, _headers, _binary)
+        return wrapRequest( _url, _url, nil, _headers, _binary )
     end
 
     http.post = function( _url, _post, _headers, _binary)
+        if type( _url ) == "table" then
+            checkOptions( _url, true )
+            return wrapRequest( _url.url, _url )
+        end
+
         if type( _url ) ~= "string" then
             error( "bad argument #1 (expected string, got " .. type( _url ) .. ")", 2 ) 
         end
@@ -703,25 +741,34 @@ if http then
         if _binary ~= nil and type( _binary ) ~= "boolean" then
             error( "bad argument #4 (expected boolean, got " .. type( _binary ) .. ")", 2 ) 
         end
-        return wrapRequest( _url, _post or "", _headers, _binary)
+        return wrapRequest( _url, _url, _post, _headers, _binary )
     end
 
     http.request = function( _url, _post, _headers, _binary )
-        if type( _url ) ~= "string" then
-            error( "bad argument #1 (expected string, got " .. type( _url ) .. ")", 2 ) 
-        end
-        if _post ~= nil and type( _post ) ~= "string" then
-            error( "bad argument #2 (expected string, got " .. type( _post ) .. ")", 2 ) 
-        end
-        if _headers ~= nil and type( _headers ) ~= "table" then
-            error( "bad argument #3 (expected table, got " .. type( _headers ) .. ")", 2 ) 
-        end
-        if _binary ~= nil and type( _binary ) ~= "boolean" then
-            error( "bad argument #4 (expected boolean, got " .. type( _binary ) .. ")", 2 ) 
+        local url
+        if type( _url ) == "table" then
+            checkOptions( _url )
+            url = _url.url
+        else
+            if type( _url ) ~= "string" then
+                error( "bad argument #1 (expected string, got " .. type( _url ) .. ")", 2 ) 
+            end
+            if _post ~= nil and type( _post ) ~= "string" then
+                error( "bad argument #2 (expected string, got " .. type( _post ) .. ")", 2 ) 
+            end
+            if _headers ~= nil and type( _headers ) ~= "table" then
+                error( "bad argument #3 (expected table, got " .. type( _headers ) .. ")", 2 ) 
+            end
+            if _binary ~= nil and type( _binary ) ~= "boolean" then
+                error( "bad argument #4 (expected boolean, got " .. type( _binary ) .. ")", 2 ) 
+            end
+
+            url = _url.url
         end
+
         local ok, err = nativeHTTPRequest( _url, _post, _headers, _binary )
         if not ok then
-            os.queueEvent( "http_failure", _url, err )
+            os.queueEvent( "http_failure", url, err )
         end
         return ok, err
     end

src/main/resources/assets/computercraft/lua/rom/apis/keys.lua

@@ -16,7 +16,7 @@ local tKeys = {
 	"comma",	"period",	"slash",	"rightShift","multiply",	-- 51
 	"leftAlt",	"space",	"capsLock",	"f1",		"f2",			-- 56
 	"f3",		"f4",		"f5",		"f6",		"f7",			-- 61
-	"f8",		"f9",		"f10",		"numLock",	"scollLock",	-- 66	
+	"f8",		"f9",		"f10",		"numLock",	"scrollLock",	-- 66	
 	"numPad7",	"numPad8",	"numPad9",	"numPadSubtract","numPad4",	-- 71
 	"numPad5",	"numPad6",	"numPadAdd","numPad1",	"numPad2",		-- 76
 	"numPad3",	"numPad0",	"numPadDecimal",nil,	nil,			-- 81
@@ -31,7 +31,7 @@ local tKeys = {
 	nil,		nil,		nil,		nil,		nil,			-- 126
 	nil,		nil,		nil,		nil,		nil,			-- 131
 	nil,		nil,		nil,		nil,		nil,			-- 136
-	"numPadEquals",nil,		nil,		"cimcumflex","at",			-- 141
+	"numPadEquals",nil,		nil,		"circumflex","at",			-- 141
 	"colon",	"underscore","kanji",	"stop",		"ax",			-- 146
 	nil,		nil,		nil,		nil,		nil,			-- 151
 	"numPadEnter","rightCtrl",nil,      nil,		nil,			-- 156
@@ -53,6 +53,9 @@ for nKey, sKey in pairs( tKeys ) do
 	keys[sKey] = nKey
 end
 keys["return"] = keys.enter
+--backwards compatibility to earlier, typo prone, versions
+keys.scollLock = keys.scrollLock
+keys.cimcumflex = keys.circumflex
 
 function getName( _nKey )
     if type( _nKey ) ~= "number" then

src/main/resources/assets/computercraft/lua/rom/help/wget.txt

@@ -1,5 +1,7 @@
 wget is a program for downloading files from the internet. This is useful for downloading programs created by other players.
+If no filename is specified wget will try to determine the filename from the URL by stripping any anchors, parameters and trailing slashes and then taking everything remaining after the last slash.
 The HTTP API must be enabled in ComputerCraft.cfg to use this program.
-
 ex:
 "wget http://pastebin.com/raw/CxaWmPrX test" will download the file from the URL http://pastebin.com/raw/CxaWmPrX, and save it as "test".
+"wget http://example.org/test.lua/?foo=bar#qzu" will download the file from the URL http://example.org/test.lua/?foo=bar#qzu and save it as "test.lua"
+"wget http://example.org/" will download the file from the URL http://example.org and save it as "example.org"

src/main/resources/assets/computercraft/lua/rom/programs/http/wget.lua

@@ -1,11 +1,11 @@
 
 local function printUsage()
     print( "Usage:" )
-    print( "wget <url> <filename>" )
+    print( "wget <url> [filename]" )
 end
  
 local tArgs = { ... }
-if #tArgs < 2 then
+if #tArgs < 1 then
     printUsage()
     return
 end
@@ -15,19 +15,15 @@ if not http then
     printError( "Set http_enable to true in ComputerCraft.cfg" )
     return
 end
- 
+
+local function getFilename( sUrl )
+    sUrl = sUrl:gsub( "[#?].*" , "" ):gsub( "/+$" , "" )
+    return sUrl:match( "/([^/]+)$" )
+end
+
 local function get( sUrl )
     write( "Connecting to " .. sUrl .. "... " )
 
-    local ok, err = http.checkURL( sUrl )
-    if not ok then
-        print( "Failed." )
-        if err then
-            printError( err )
-        end
-        return nil
-    end
-
     local response = http.get( sUrl , nil , true )
     if not response then
         print( "Failed." )
@@ -40,10 +36,18 @@ local function get( sUrl )
     response.close()
     return sResponse
 end
- 
+
 -- Determine file to download
 local sUrl = tArgs[1]
-local sFile = tArgs[2]
+
+--Check if the URL is valid
+local ok, err = http.checkURL( sUrl )
+if not ok then
+    printError( err or "Invalid URL." )
+    return
+end
+
+local sFile = tArgs[2] or getFilename( sUrl )
 local sPath = shell.resolve( sFile )
 if fs.exists( sPath ) then
     print( "File already exists" )

src/main/resources/assets/computercraft/lua/rom/programs/shell.lua

@@ -325,9 +325,9 @@ local function completeProgram( sLine )
         -- Add all subdirectories. We don't include files as they will be added in the block below
         local tDirs = fs.complete( sLine, sDir, false, false )
         for i = 1, #tDirs do
+            local sResult = tDirs[i]
             if not tSeen[ sResult ] then
-                local sResult = tDirs[i]
-                table.insert (tResults, sResult )
+                table.insert ( tResults, sResult )
                 tSeen [ sResult ] = true
             end
         end

src/main/resources/assets/computercraft/recipes/skull_cloudy.json

@@ -1,7 +1,7 @@
 {
     "type": "minecraft:crafting_shapeless",
     "ingredients": [
-        { "item": "minecraft:skull", "data": 1 },
+        { "item": "minecraft:skull", "data": 32767 },
         { "item": "computercraft:peripheral", "data": 2 }
     ],
     "result": { 

src/main/resources/assets/computercraft/recipes/skull_dan200.json

@@ -1,7 +1,7 @@
 {
     "type": "minecraft:crafting_shapeless",
     "ingredients": [
-        { "item": "minecraft:skull", "data": 1 },
+        { "item": "minecraft:skull", "data": 32767 },
         { "item": "computercraft:computer", "data": 0 }
     ],
     "result": { 

src/test/java/dan200/computercraft/shared/wired/NetworkTest.java

@@ -23,7 +23,6 @@ import org.junit.Test;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiConsumer;
@@ -379,17 +378,10 @@ public class NetworkTest
             remotePeripherals.putAll( change.peripheralsAdded() );
         }
 
-        @Nonnull
-        @Override
-        public Map<String, IPeripheral> getPeripherals()
-        {
-            return Collections.unmodifiableMap( localPeripherals );
-        }
-
         public NetworkElement addPeripheral( String name )
         {
             localPeripherals.put( name, new NetworkPeripheral() );
-            getNode().invalidate();
+            getNode().updatePeripherals( localPeripherals );
             return this;
         }