Moved some stuff into centralized event handler to sync that up with 1.7 better.

src/main/resources/reference.conf

@@ -835,5 +835,8 @@ opencomputers {
       # on computers' save and load performance, so you should not enable
       # this unless you're asked to.
       verbosePersistenceErrors: false
+
+      # Whether to not show your special thinger (if you have one you know it).
+      hideOwnSpecial: false
   }
 }

src/main/scala/li/cil/oc/Settings.scala

@@ -219,6 +219,7 @@ class Settings(config: Config) {
   val geolyzerRange = config.getInt("misc.geolyzerRange")
   val disassembleAllTheThings = config.getBoolean("misc.disassembleAllTheThings")
   val disassemblerBreakChance = config.getDouble("misc.disassemblerBreakChance") max 0 min 1
+  val hideOwnPet = config.getBoolean("misc.hideOwnSpecial")
 }
 
 object Settings {

src/main/scala/li/cil/oc/client/PacketHandler.scala

@@ -1,15 +1,15 @@
 package li.cil.oc.client
 
 import cpw.mods.fml.common.network.Player
-import li.cil.oc.{Localization, Settings}
+import li.cil.oc.Localization
 import li.cil.oc.api.component
+import li.cil.oc.client.renderer.PetRenderer
 import li.cil.oc.common.tileentity._
 import li.cil.oc.common.tileentity.traits._
 import li.cil.oc.common.{PacketType, PacketHandler => CommonPacketHandler}
 import li.cil.oc.util.Audio
 import net.minecraft.client.gui.GuiScreen
 import net.minecraft.entity.player.EntityPlayer
-import net.minecraft.util.ChatMessageComponent
 import net.minecraftforge.common.ForgeDirection
 import org.lwjgl.input.Keyboard
 
@@ -34,6 +34,7 @@ class PacketHandler extends CommonPacketHandler {
       case PacketType.HologramPowerChange => onHologramPowerChange(p)
       case PacketType.HologramScale => onHologramScale(p)
       case PacketType.HologramSet => onHologramSet(p)
+      case PacketType.PetVisibility => onPetVisibility(p)
       case PacketType.PowerState => onPowerState(p)
       case PacketType.RedstoneState => onRedstoneState(p)
       case PacketType.RobotAnimateSwing => onRobotAnimateSwing(p)
@@ -172,6 +173,19 @@ class PacketHandler extends CommonPacketHandler {
       case _ => // Invalid packet.
     }
 
+  def onPetVisibility(p: PacketParser) {
+    val count = p.readInt()
+    for (i <- 0 until count) {
+      val name = p.readUTF()
+      if (p.readBoolean()) {
+        PetRenderer.hidden -= name
+      }
+      else {
+        PetRenderer.hidden += name
+      }
+    }
+  }
+
   def onPowerState(p: PacketParser) =
     p.readTileEntity[PowerInformation]() match {
       case Some(t) =>

src/main/scala/li/cil/oc/client/PacketSender.scala

@@ -1,5 +1,6 @@
 package li.cil.oc.client
 
+import li.cil.oc.Settings
 import li.cil.oc.common.tileentity._
 import li.cil.oc.common.tileentity.traits.Computer
 import li.cil.oc.common.{CompressedPacketBuilder, PacketBuilder, PacketType}
@@ -96,6 +97,14 @@ object PacketSender {
     pb.sendToServer()
   }
 
+  def sendPetVisibility() {
+    val pb = new PacketBuilder(PacketType.PetVisibility)
+
+    pb.writeBoolean(Settings.get.hideOwnPet)
+
+    pb.sendToServer()
+  }
+
   def sendRobotAssemblerStart(t: RobotAssembler) {
     val pb = new PacketBuilder(PacketType.RobotAssemblerStart)
 

src/main/scala/li/cil/oc/client/renderer/PetRenderer.scala

@@ -14,8 +14,11 @@ import net.minecraftforge.event.{EventPriority, ForgeSubscribe}
 import org.lwjgl.opengl.{GL11, GL12}
 
 import scala.collection.convert.WrapAsScala._
+import scala.collection.mutable
 
 object PetRenderer extends ITickHandler {
+  val hidden = mutable.Set.empty[String]
+
   private val entitledPlayers = Map("Kethtar" ->(0.3, 0.9, 0.6))
 
   private val petLocations = com.google.common.cache.CacheBuilder.newBuilder().
@@ -28,7 +31,7 @@ object PetRenderer extends ITickHandler {
   @ForgeSubscribe
   def onPlayerRender(e: RenderPlayerEvent.Pre) {
     val name = e.entityPlayer.getCommandSenderName
-    if (!entitledPlayers.contains(name)) return
+    if (hidden.contains(name) || !entitledPlayers.contains(name)) return
     rendering = Some(entitledPlayers(name))
 
     val worldTime = e.entityPlayer.getEntityWorld.getWorldTime

src/main/scala/li/cil/oc/common/ConnectionHandler.scala

@@ -1,50 +0,0 @@
-package li.cil.oc.common
-
-import cpw.mods.fml.common.network.{IConnectionHandler, Player}
-import li.cil.oc.util.LuaStateFactory
-import li.cil.oc.util.mods.{Mods, ProjectRed}
-import li.cil.oc.{Localization, OpenComputers, Settings, UpdateCheck}
-import net.minecraft.entity.player.EntityPlayerMP
-import net.minecraft.network.packet.{NetHandler, Packet1Login}
-import net.minecraft.network.{INetworkManager, NetLoginHandler}
-import net.minecraft.server.MinecraftServer
-
-object ConnectionHandler extends IConnectionHandler {
-  def playerLoggedIn(player: Player, netHandler: NetHandler, manager: INetworkManager) {
-    if (netHandler.isServerHandler) player match {
-      case p: EntityPlayerMP =>
-        if (!LuaStateFactory.isAvailable) {
-          p.sendChatToPlayer(Localization.Chat.WarningLuaFallback)
-        }
-        if (Mods.ProjectRed.isAvailable && !ProjectRed.isAPIAvailable) {
-          p.sendChatToPlayer(Localization.Chat.WarningProjectRed)
-        }
-        if (!Settings.get.pureIgnorePower && Settings.get.ignorePower) {
-          p.sendChatToPlayer(Localization.Chat.WarningPower)
-        }
-        OpenComputers.tampered match {
-          case Some(event) => p.sendChatToPlayer(Localization.Chat.WarningFingerprint(event))
-          case _ =>
-        }
-        // Do update check in local games and for OPs.
-        if (!MinecraftServer.getServer.isDedicatedServer || MinecraftServer.getServer.getConfigurationManager.isPlayerOpped(p.getCommandSenderName)) {
-          UpdateCheck.checkForPlayer(p)
-        }
-      case _ =>
-    }
-  }
-
-  def connectionReceived(netHandler: NetLoginHandler, manager: INetworkManager) = null
-
-  def connectionOpened(netClientHandler: NetHandler, server: String, port: Int, manager: INetworkManager) {
-  }
-
-  def connectionOpened(netClientHandler: NetHandler, server: MinecraftServer, manager: INetworkManager) {
-  }
-
-  def connectionClosed(manager: INetworkManager) {
-  }
-
-  def clientLoggedIn(clientHandler: NetHandler, manager: INetworkManager, login: Packet1Login) {
-  }
-}

src/main/scala/li/cil/oc/common/CraftingHandler.scala

@@ -1,30 +0,0 @@
-package li.cil.oc.common
-
-import cpw.mods.fml.common.ICraftingHandler
-import li.cil.oc.{Settings, api}
-import net.minecraft.entity.player.EntityPlayer
-import net.minecraft.inventory.IInventory
-import net.minecraft.item.ItemStack
-
-object CraftingHandler extends ICraftingHandler {
-  lazy val navigationUpgrade = api.Items.get("navigationUpgrade")
-
-  override def onCrafting(player: EntityPlayer, craftedStack: ItemStack, inventory: IInventory) = {
-    if (api.Items.get(craftedStack) == navigationUpgrade) {
-      Option(api.Driver.driverFor(craftedStack)).foreach(driver =>
-        for (i <- 0 until inventory.getSizeInventory) {
-          val stack = inventory.getStackInSlot(i)
-          if (stack != null && api.Items.get(stack) == navigationUpgrade) {
-            // Restore the map currently used in the upgrade.
-            val nbt = driver.dataTag(stack)
-            val map = ItemStack.loadItemStackFromNBT(nbt.getCompoundTag(Settings.namespace + "map"))
-            if (!player.inventory.addItemStackToInventory(map)) {
-              player.dropPlayerItemWithRandomChoice(map, false)
-            }
-          }
-        })
-    }
-  }
-
-  override def onSmelting(player: EntityPlayer, item: ItemStack) {}
-}

src/main/scala/li/cil/oc/common/EventHandler.scala

@@ -0,0 +1,142 @@
+package li.cil.oc.common
+
+import java.util
+import java.util.logging.Level
+
+import codechicken.multipart.TMultiPart
+import cpw.mods.fml.common._
+import cpw.mods.fml.common.network.{IConnectionHandler, Player}
+import ic2.api.energy.event.{EnergyTileLoadEvent, EnergyTileUnloadEvent}
+import li.cil.oc._
+import li.cil.oc.api.Network
+import li.cil.oc.client.renderer.PetRenderer
+import li.cil.oc.client.{PacketSender => ClientPacketSender}
+import li.cil.oc.common.tileentity.traits.power
+import li.cil.oc.server.{PacketSender => ServerPacketSender}
+import li.cil.oc.util.LuaStateFactory
+import li.cil.oc.util.mods.{Mods, ProjectRed}
+import net.minecraft.client.Minecraft
+import net.minecraft.entity.player.{EntityPlayer, EntityPlayerMP}
+import net.minecraft.inventory.IInventory
+import net.minecraft.item.ItemStack
+import net.minecraft.network.packet.{NetHandler, Packet1Login}
+import net.minecraft.network.{INetworkManager, NetLoginHandler}
+import net.minecraft.server.MinecraftServer
+import net.minecraft.tileentity.TileEntity
+import net.minecraftforge.common.MinecraftForge
+
+import scala.collection.mutable
+
+object EventHandler extends ITickHandler with IConnectionHandler with ICraftingHandler {
+  val pending = mutable.Buffer.empty[() => Unit]
+
+  def schedule(tileEntity: TileEntity) =
+    if (FMLCommonHandler.instance.getEffectiveSide.isServer) pending.synchronized {
+      pending += (() => Network.joinOrCreateNetwork(tileEntity))
+    }
+
+  @Optional.Method(modid = "ForgeMultipart")
+  def schedule(part: TMultiPart) =
+    if (FMLCommonHandler.instance.getEffectiveSide.isServer) pending.synchronized {
+      pending += (() => Network.joinOrCreateNetwork(part.tile))
+    }
+
+  @Optional.Method(modid = "IC2")
+  def scheduleIC2Add(tileEntity: power.IndustrialCraft2) = pending.synchronized {
+    pending += (() => if (!tileEntity.addedToPowerGrid && !tileEntity.isInvalid) {
+      MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(tileEntity))
+      tileEntity.addedToPowerGrid = true
+    })
+  }
+
+  @Optional.Method(modid = "IC2")
+  def scheduleIC2Remove(tileEntity: power.IndustrialCraft2) = pending.synchronized {
+    pending += (() => if (tileEntity.addedToPowerGrid) {
+      MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(tileEntity))
+      tileEntity.addedToPowerGrid = false
+    })
+  }
+
+  override def getLabel = "OpenComputers Network Initialization Ticker"
+
+  override def ticks() = util.EnumSet.of(TickType.SERVER)
+
+  override def tickStart(`type`: util.EnumSet[TickType], tickData: AnyRef*) {
+    pending.synchronized {
+      val adds = pending.toArray
+      pending.clear()
+      adds
+    } foreach (callback => {
+      try callback() catch {
+        case t: Throwable => OpenComputers.log.log(Level.WARNING, "Error in scheduled tick action.", t)
+      }
+    })
+  }
+
+  override def tickEnd(`type`: util.EnumSet[TickType], tickData: AnyRef*) = {}
+
+  def playerLoggedIn(player: Player, netHandler: NetHandler, manager: INetworkManager) {
+    if (netHandler.isServerHandler) player match {
+      case p: EntityPlayerMP =>
+        if (!LuaStateFactory.isAvailable) {
+          p.sendChatToPlayer(Localization.Chat.WarningLuaFallback)
+        }
+        if (Mods.ProjectRed.isAvailable && !ProjectRed.isAPIAvailable) {
+          p.sendChatToPlayer(Localization.Chat.WarningProjectRed)
+        }
+        if (!Settings.get.pureIgnorePower && Settings.get.ignorePower) {
+          p.sendChatToPlayer(Localization.Chat.WarningPower)
+        }
+        OpenComputers.tampered match {
+          case Some(event) => p.sendChatToPlayer(Localization.Chat.WarningFingerprint(event))
+          case _ =>
+        }
+        ServerPacketSender.sendPetVisibility(None, Some(p))
+        // Do update check in local games and for OPs.
+        if (!MinecraftServer.getServer.isDedicatedServer || MinecraftServer.getServer.getConfigurationManager.isPlayerOpped(p.getCommandSenderName)) {
+          UpdateCheck.checkForPlayer(p)
+        }
+      case _ =>
+    }
+  }
+
+  def connectionReceived(netHandler: NetLoginHandler, manager: INetworkManager) = null
+
+  def connectionOpened(netClientHandler: NetHandler, server: String, port: Int, manager: INetworkManager) {
+  }
+
+  def connectionOpened(netClientHandler: NetHandler, server: MinecraftServer, manager: INetworkManager) {
+  }
+
+  def connectionClosed(manager: INetworkManager) {
+  }
+
+  def clientLoggedIn(clientHandler: NetHandler, manager: INetworkManager, login: Packet1Login) {
+    PetRenderer.hidden.clear()
+    if (Settings.get.hideOwnPet) {
+      PetRenderer.hidden += Minecraft.getMinecraft.thePlayer.getCommandSenderName
+    }
+    ClientPacketSender.sendPetVisibility()
+  }
+
+  lazy val navigationUpgrade = api.Items.get("navigationUpgrade")
+
+  override def onCrafting(player: EntityPlayer, craftedStack: ItemStack, inventory: IInventory) = {
+    if (api.Items.get(craftedStack) == navigationUpgrade) {
+      Option(api.Driver.driverFor(craftedStack)).foreach(driver =>
+        for (i <- 0 until inventory.getSizeInventory) {
+          val stack = inventory.getStackInSlot(i)
+          if (stack != null && api.Items.get(stack) == navigationUpgrade) {
+            // Restore the map currently used in the upgrade.
+            val nbt = driver.dataTag(stack)
+            val map = ItemStack.loadItemStackFromNBT(nbt.getCompoundTag(Settings.namespace + "map"))
+            if (!player.inventory.addItemStackToInventory(map)) {
+              player.dropPlayerItemWithRandomChoice(map, false)
+            }
+          }
+        })
+    }
+  }
+
+  override def onSmelting(player: EntityPlayer, item: ItemStack) {}
+}

src/main/scala/li/cil/oc/common/PacketType.scala

@@ -15,6 +15,7 @@ object PacketType extends Enumeration {
   HologramPowerChange,
   HologramScale,
   HologramSet,
+  PetVisibility, // Goes both ways.
   PowerState,
   RedstoneState,
   RobotAnimateSwing,

src/main/scala/li/cil/oc/common/Proxy.scala

@@ -120,7 +120,7 @@ class Proxy {
 
     OpenComputers.log.info("Initializing event handlers.")
 
-    GameRegistry.registerCraftingHandler(CraftingHandler)
+    GameRegistry.registerCraftingHandler(EventHandler)
 
     ForgeChunkManager.setForcedChunkLoadingCallback(OpenComputers, ChunkloaderUpgradeHandler)
 
@@ -146,10 +146,10 @@ class Proxy {
     // Don't allow driver registration after this point, to avoid issues.
     driver.Registry.locked = true
 
-    TickRegistry.registerTickHandler(TickHandler, Side.SERVER)
+    TickRegistry.registerTickHandler(EventHandler, Side.SERVER)
     TickRegistry.registerTickHandler(SimpleComponentTickHandler.Instance, Side.SERVER)
     GameRegistry.registerPlayerTracker(Keyboard)
-    NetworkRegistry.instance.registerConnectionHandler(ConnectionHandler)
+    NetworkRegistry.instance.registerConnectionHandler(EventHandler)
     MinecraftForge.EVENT_BUS.register(WirelessNetwork)
     MinecraftForge.EVENT_BUS.register(SaveHandler)
   }

src/main/scala/li/cil/oc/common/multipart/CablePart.scala

@@ -7,9 +7,8 @@ import li.cil.oc.api.network.{Message, Node, Visibility}
 import li.cil.oc.api.{Items, network}
 import li.cil.oc.client.renderer.tileentity.CableRenderer
 import li.cil.oc.common.block.{Cable, Delegator}
-import li.cil.oc.server.TickHandler
 import li.cil.oc.util.ExtendedNBT._
-import li.cil.oc.{Settings, api}
+import li.cil.oc.{Settings, api, common}
 import net.minecraft.nbt.NBTTagCompound
 import net.minecraft.util.AxisAlignedBB
 import org.lwjgl.opengl.GL11
@@ -44,7 +43,7 @@ class CablePart(val original: Option[Node] = None) extends DelegatePart with TCu
 
   override def onWorldJoin() {
     super.onWorldJoin()
-    TickHandler.schedule(this)
+    common.EventHandler.schedule(this)
   }
 
   override def onWorldSeparate() {

src/main/scala/li/cil/oc/common/tileentity/traits/Environment.scala

@@ -1,9 +1,9 @@
 package li.cil.oc.common.tileentity.traits
 
 import li.cil.oc.Settings
-import li.cil.oc.api.{driver, network}
 import li.cil.oc.api.network.{Connector, SidedEnvironment}
-import li.cil.oc.server.TickHandler
+import li.cil.oc.api.{driver, network}
+import li.cil.oc.common.EventHandler
 import li.cil.oc.util.ExtendedNBT._
 import net.minecraft.nbt.NBTTagCompound
 import net.minecraftforge.common.ForgeDirection
@@ -24,7 +24,7 @@ trait Environment extends TileEntity with network.Environment with driver.Contai
   override protected def initialize() {
     super.initialize()
     if (isServer) {
-      TickHandler.schedule(this)
+      EventHandler.schedule(this)
     }
   }
 

src/main/scala/li/cil/oc/common/tileentity/traits/power/IndustrialCraft2.scala

@@ -3,7 +3,7 @@ package li.cil.oc.common.tileentity.traits.power
 import cpw.mods.fml.common.Optional
 import ic2.api.energy.tile.IEnergySink
 import li.cil.oc.Settings
-import li.cil.oc.server.TickHandler
+import li.cil.oc.common.EventHandler
 import li.cil.oc.util.mods.Mods
 import net.minecraftforge.common.ForgeDirection
 
@@ -17,17 +17,17 @@ trait IndustrialCraft2 extends Common with IEnergySink {
 
   override def validate() {
     super.validate()
-    if (useIndustrialCraft2Power && !addedToPowerGrid) TickHandler.scheduleIC2Add(this)
+    if (useIndustrialCraft2Power && !addedToPowerGrid) EventHandler.scheduleIC2Add(this)
   }
 
   override def invalidate() {
     super.invalidate()
-    if (useIndustrialCraft2Power && addedToPowerGrid) TickHandler.scheduleIC2Remove(this)
+    if (useIndustrialCraft2Power && addedToPowerGrid) EventHandler.scheduleIC2Remove(this)
   }
 
   override def onChunkUnload() {
     super.onChunkUnload()
-    if (useIndustrialCraft2Power && addedToPowerGrid) TickHandler.scheduleIC2Remove(this)
+    if (useIndustrialCraft2Power && addedToPowerGrid) EventHandler.scheduleIC2Remove(this)
   }
 
   // ----------------------------------------------------------------------- //

src/main/scala/li/cil/oc/server/PacketHandler.scala

@@ -25,6 +25,7 @@ class PacketHandler extends CommonPacketHandler {
       case PacketType.MouseScroll => onMouseScroll(p)
       case PacketType.MouseUp => onMouseUp(p)
       case PacketType.MultiPartPlace => onMultiPartPlace(p)
+      case PacketType.PetVisibility => onPetVisibility(p)
       case PacketType.RobotAssemblerStart => onRobotAssemblerStart(p)
       case PacketType.RobotStateRequest => onRobotStateRequest(p)
       case PacketType.ServerRange => onServerRange(p)
@@ -118,6 +119,22 @@ class PacketHandler extends CommonPacketHandler {
     }
   }
 
+  def onPetVisibility(p: PacketParser) {
+    p.player match {
+      case player: EntityPlayerMP =>
+        if (if (p.readBoolean()) {
+          PetVisibility.hidden.remove(player.getCommandSenderName)
+        }
+        else {
+          PetVisibility.hidden.add(player.getCommandSenderName)
+        }) {
+          // Something changed.
+          PacketSender.sendPetVisibility(Some(player.getCommandSenderName))
+        }
+      case _ => // Invalid packet.
+    }
+  }
+
   def onRobotAssemblerStart(p: PacketParser) =
     p.readTileEntity[RobotAssembler]() match {
       case Some(assembler) => assembler.start()

src/main/scala/li/cil/oc/server/PacketSender.scala

@@ -129,6 +129,28 @@ object PacketSender {
     pb.sendToNearbyPlayers(t)
   }
 
+  def sendPetVisibility(name: Option[String] = None, player: Option[EntityPlayerMP] = None) {
+    val pb = new PacketBuilder(PacketType.ComputerState)
+
+    name match {
+      case Some(n) =>
+        pb.writeInt(1)
+        pb.writeUTF(n)
+        pb.writeBoolean(!PetVisibility.hidden.contains(n))
+      case _ =>
+        pb.writeInt(PetVisibility.hidden.size)
+        for (n <- PetVisibility.hidden) {
+          pb.writeUTF(n)
+          pb.writeBoolean(false)
+        }
+    }
+
+    player match {
+      case Some(p) => pb.sendToPlayer(p)
+      case _ => pb.sendToAllPlayers()
+    }
+  }
+
   def sendPowerState(t: PowerInformation) {
     val pb = new PacketBuilder(PacketType.PowerState)
 

src/main/scala/li/cil/oc/server/PetVisibility.scala

@@ -0,0 +1,7 @@
+package li.cil.oc.server
+
+import scala.collection.mutable
+
+object PetVisibility {
+  val hidden = mutable.Set.empty[String]
+}

src/main/scala/li/cil/oc/server/TickHandler.scala

@@ -1,64 +0,0 @@
-package li.cil.oc.server
-
-import java.util
-import java.util.logging.Level
-
-import codechicken.multipart.TMultiPart
-import cpw.mods.fml.common.{FMLCommonHandler, ITickHandler, Optional, TickType}
-import ic2.api.energy.event.{EnergyTileLoadEvent, EnergyTileUnloadEvent}
-import li.cil.oc.OpenComputers
-import li.cil.oc.api.Network
-import li.cil.oc.common.tileentity.traits.power
-import net.minecraft.tileentity.TileEntity
-import net.minecraftforge.common.MinecraftForge
-
-import scala.collection.mutable
-
-object TickHandler extends ITickHandler {
-  val pending = mutable.Buffer.empty[() => Unit]
-
-  def schedule(tileEntity: TileEntity) =
-    if (FMLCommonHandler.instance.getEffectiveSide.isServer) pending.synchronized {
-      pending += (() => Network.joinOrCreateNetwork(tileEntity))
-    }
-
-  @Optional.Method(modid = "ForgeMultipart")
-  def schedule(part: TMultiPart) =
-    if (FMLCommonHandler.instance.getEffectiveSide.isServer) pending.synchronized {
-      pending += (() => Network.joinOrCreateNetwork(part.tile))
-    }
-
-  @Optional.Method(modid = "IC2")
-  def scheduleIC2Add(tileEntity: power.IndustrialCraft2) = pending.synchronized {
-    pending += (() => if (!tileEntity.addedToPowerGrid && !tileEntity.isInvalid) {
-      MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(tileEntity))
-      tileEntity.addedToPowerGrid = true
-    })
-  }
-
-  @Optional.Method(modid = "IC2")
-  def scheduleIC2Remove(tileEntity: power.IndustrialCraft2) = pending.synchronized {
-    pending += (() => if (tileEntity.addedToPowerGrid) {
-      MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(tileEntity))
-      tileEntity.addedToPowerGrid = false
-    })
-  }
-
-  override def getLabel = "OpenComputers Network Initialization Ticker"
-
-  override def ticks() = util.EnumSet.of(TickType.SERVER)
-
-  override def tickStart(`type`: util.EnumSet[TickType], tickData: AnyRef*) {
-    pending.synchronized {
-      val adds = pending.toArray
-      pending.clear()
-      adds
-    } foreach (callback => {
-      try callback() catch {
-        case t: Throwable => OpenComputers.log.log(Level.WARNING, "Error in scheduled tick action.", t)
-      }
-    })
-  }
-
-  override def tickEnd(`type`: util.EnumSet[TickType], tickData: AnyRef*) = {}
-}