Merge branch 'master' of https://github.com/Kilobyte22/OpenComputers into switch-upgrades

src/main/resources/application.conf

@@ -766,6 +766,23 @@ opencomputers {
       threads: 4
   }
 
+  switch {
+      # This is the size of a queue of a not upgraded switch.
+      # Increasing it allows to send more messages in a single burst
+      defaultMaxQueueSize: 20
+
+      # This is the amount of additional queue spaces per half upgrade tier
+      # For tier 1 this is multiplied with 1, for 1.5 its muliplied with 2 and so on
+      queueSizeUpgrade: 5
+
+      # The delay a Switch has by default (in ticks). WARNING: A too
+      # low value can cause lag lag on the server.
+      defaultRelayDelay: 5
+
+      # The amount of ticks the delay is *reduced* by per level
+      relayDelayUpgrade: 1
+  }
+
   # Other settings that you might find useful to tweak.
   misc {
       # The maximum width of multi-block screens, in blocks.

src/main/resources/assets/opencomputers/lang/de_DE.lang

@@ -157,6 +157,7 @@ oc:container.Disassembler=Recycler
 oc:container.DiskDrive=Diskettenlaufwerk
 oc:container.Rack=Serverschrank
 oc:container.Server=Server
+oc:container.Switch=Switch
 
 # Keybinds
 key.materialCosts=Materialkosten anzeigen

src/main/resources/assets/opencomputers/lang/en_US.lang

@@ -156,6 +156,7 @@ oc:container.Case=Computer
 oc:container.Disassembler=Disassembler
 oc:container.DiskDrive=Disk Drive
 oc:container.Rack=Server Rack
+oc:container.Switch=Switch
 oc:container.Server=Server
 
 # Keybinds

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

@@ -198,6 +198,13 @@ class Settings(config: Config) {
   val maxConnections = config.getInt("internet.maxTcpConnections") max 0
   val internetThreads = config.getInt("internet.threads") max 1
 
+  // ----------------------------------------------------------------------- //
+  // switch
+  val switchDefaultMaxQueueSize = config.getInt("switch.defaultMaxQueueSize") max 1
+  val switchQueueSizeUpgrade = config.getInt("switch.queueSizeUpgrade") max 0
+  val switchRelayDelayUpgrade = config.getInt("switch.relayDelayUpgrade") max 0
+  val switchDefaultRelayDelay = config.getInt("switch.defaultRelayDelay") max switchRelayDelayUpgrade * 3
+
   // ----------------------------------------------------------------------- //
   // misc
   val maxScreenWidth = config.getInt("misc.maxScreenWidth") max 1

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

@@ -26,6 +26,8 @@ object GuiHandler extends CommonGuiHandler {
         new gui.RobotAssembler(player.inventory, assembler)
       case screen: tileentity.Screen if id == GuiType.Screen.id =>
         new gui.Screen(screen.origin.buffer, screen.tier > 0, () => screen.origin.hasKeyboard, () => screen.origin.buffer.isRenderingEnabled)
+      case router: tileentity.Router if id == GuiType.Router.id =>
+        new gui.Router(player.inventory, router)
       case _ => Items.multi.subItem(player.getCurrentEquippedItem) match {
         case Some(server: item.Server) if id == GuiType.Server.id =>
           new gui.Server(player.inventory, new ServerInventory {

src/main/scala/li/cil/oc/client/gui/Router.scala

@@ -0,0 +1,14 @@
+package li.cil.oc.client.gui
+
+import li.cil.oc.common.{container, tileentity}
+import net.minecraft.entity.player.InventoryPlayer
+import net.minecraft.util.StatCollector
+
+class Router(playerInventory: InventoryPlayer, val router: tileentity.Router) extends DynamicGuiContainer(new container.Router(playerInventory, router)) {
+  override def drawGuiContainerForegroundLayer(mouseX: Int, mouseY: Int) = {
+    super.drawGuiContainerForegroundLayer(mouseX, mouseY)
+    fontRenderer.drawString(
+      StatCollector.translateToLocal(router.getInvName),
+      8, 6, 0x404040)
+  }
+}

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

@@ -21,6 +21,8 @@ abstract class GuiHandler extends IGuiHandler {
         new container.Rack(player.inventory, rack)
       case assembler: tileentity.RobotAssembler if id == GuiType.RobotAssembler.id =>
         new container.RobotAssembler(player.inventory, assembler)
+      case router: tileentity.Router if id == GuiType.Router.id =>
+        new container.Router(player.inventory, router)
       case _ => Items.multi.subItem(player.getCurrentEquippedItem) match {
         case Some(server: item.Server) if id == GuiType.Server.id =>
           new container.Server(player.inventory, new ServerInventory {

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

@@ -11,6 +11,7 @@ object GuiType extends Enumeration {
   Robot,
   Screen,
   Server,
+  Switch,
   Tablet,
   Terminal
 

src/main/scala/li/cil/oc/common/block/Switch.scala

@@ -2,9 +2,9 @@ package li.cil.oc.common.block
 
 import java.util
 
-import li.cil.oc.Settings
+import li.cil.oc.{OpenComputers, Settings}
 import li.cil.oc.client.Textures
-import li.cil.oc.common.tileentity
+import li.cil.oc.common.{GuiType, tileentity}
 import li.cil.oc.util.Tooltip
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.ItemStack
@@ -41,4 +41,19 @@ class Switch(val parent: SimpleDelegator) extends SimpleDelegate {
   override def hasTileEntity = true
 
   override def createTileEntity(world: World) = Some(new tileentity.Router)
+
+  override def rightClick(world: World, x: Int, y: Int, z: Int, player: EntityPlayer,
+                          side: ForgeDirection, hitX: Float, hitY: Float, hitZ: Float) = {
+    world.getBlockTileEntity(x, y, z) match {
+      case switch: tileentity.Router =>
+        if (!player.isSneaking) {
+          if (!world.isRemote) {
+            player.openGui(OpenComputers, GuiType.Switch.id, world, x, y, z)
+          }
+          true
+        }
+        else false
+
+    }
+  }
 }

src/main/scala/li/cil/oc/common/container/Router.scala

@@ -0,0 +1,11 @@
+package li.cil.oc.common.container
+
+import li.cil.oc.api
+import li.cil.oc.common.tileentity
+import net.minecraft.entity.player.InventoryPlayer
+
+class Router(playerInventory: InventoryPlayer, router: tileentity.Router) extends Player(playerInventory, router) {
+  addSlotToContainer(60, 35, api.driver.Slot.Processor)
+  addSlotToContainer(95, 35, api.driver.Slot.Memory)
+  addPlayerInventorySlots(8, 84)
+}

src/main/scala/li/cil/oc/common/tileentity/Router.scala

@@ -5,10 +5,14 @@ import dan200.computer.api.{IComputerAccess, ILuaContext, IPeripheral}
 import li.cil.oc.api.network.{Message, Packet}
 import li.cil.oc.server.PacketSender
 import li.cil.oc.util.mods.Mods
-import li.cil.oc.{Settings, api}
+import li.cil.oc.{Items, Settings, api}
+import li.cil.oc.common.item
 import net.minecraftforge.common.ForgeDirection
 
 import scala.collection.mutable
+import net.minecraft.item.ItemStack
+import li.cil.oc.api.Driver
+import li.cil.oc.api.driver.{Processor, Memory, Slot}
 
 // Note on the CC1.5+1.6 compatibility
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -24,7 +28,7 @@ import scala.collection.mutable
 // old API, so there should be no ClassNotFoundExceptions anyway.
 
 @Optional.Interface(iface = "dan200.computer.api.IPeripheral", modid = "ComputerCraft")
-class Router extends traits.Hub with traits.NotAnalyzable with IPeripheral {
+class Router extends traits.Hub with traits.NotAnalyzable with IPeripheral with traits.ComponentInventory {
   var lastMessage = 0L
 
   val computers = mutable.Map.empty[AnyRef, ComputerWrapper]
@@ -142,6 +146,40 @@ class Router extends traits.Hub with traits.NotAnalyzable with IPeripheral {
       }
     }
   }
+
+  override def isItemValidForSlot(slot: Int, stack: ItemStack) = (slot, Option(Driver.driverFor(stack))) match {
+    case (1, Some(driver)) => driver.slot(stack) == Slot.Memory
+    case (0, Some(driver)) => driver.slot(stack) == Slot.Processor
+    case _ => false
+  }
+
+  override def getInvName = Settings.namespace + "container.Router"
+
+  override def getSizeInventory = 2
+
+  override protected def onItemAdded(slot: Int, stack: ItemStack) {
+    super.onItemAdded(slot, stack)
+    Driver.driverFor(stack) match {
+      case mem: Memory =>
+        maxQueueSize = queueDefaultSize + (Items.multi.subItem(stack) match {
+          case Some(ram: item.Memory) => (ram.tier + 1) * queueUpgradeSize
+          case _ => (mem.tier(stack) + 1) * (queueUpgradeSize * 2)
+        })
+      case cpu: Processor =>
+        relayDelay = relayDefaultDelay -
+          (cpu.tier(stack) * relayUpgradeDelay)
+    }
+  }
+
+
+  override protected def onItemRemoved(slot: Int, stack: ItemStack) {
+    super.onItemRemoved(slot, stack)
+    slot match {
+      case 0 => relayDelay = relayDefaultDelay
+      case 1 => maxQueueSize = queueDefaultSize
+    }
+  }
+
 }
 
 // Abstraction layer for CC computers to support 1.5 and 1.6 API.

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

@@ -19,11 +19,16 @@ trait Hub extends traits.Environment with SidedEnvironment {
 
   protected val queue = mutable.Queue.empty[(ForgeDirection, Packet)]
 
-  protected val maxQueueSize = 20
+  protected def queueDefaultSize = Settings.get.switchDefaultMaxQueueSize
+  protected def queueUpgradeSize = Settings.get.switchQueueSizeUpgrade
+  protected def relayDefaultDelay = Settings.get.switchDefaultRelayDelay
+  protected def relayUpgradeDelay = Settings.get.switchRelayDelayUpgrade
+
+  protected var maxQueueSize = Settings.get.switchDefaultMaxQueueSize
 
   protected var relayCooldown = -1
 
-  protected val relayDelay = 5
+  protected var relayDelay = Settings.get.switchDefaultRelayDelay
 
   // ----------------------------------------------------------------------- //