Merge branch 'master-MC1.11' into master-MC1.12

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

@@ -38,6 +38,7 @@ class Charger extends traits.Environment with traits.PowerAcceptor with traits.R
     create()
 
   val connectors = mutable.Set.empty[Chargeable]
+  val equipment = mutable.Set.empty[ItemStack]
 
   var chargeSpeed = 0.0
 
@@ -79,6 +80,14 @@ class Charger extends traits.Environment with traits.PowerAcceptor with traits.R
 
   // ----------------------------------------------------------------------- //
 
+  private def chargeStack(stack: ItemStack, charge: Double): Unit = {
+    if (!stack.isEmpty && charge > 0) {
+      val missing = node.changeBuffer(-charge)
+      val surplus = ItemCharge.charge(stack, charge + missing) // missing is negative
+      node.changeBuffer(surplus)
+    }
+  }
+
   override def updateEntity() {
     super.updateEntity()
 
@@ -108,11 +117,16 @@ class Charger extends traits.Environment with traits.PowerAcceptor with traits.R
         val charge = Settings.get.chargeRateTablet * chargeSpeed * Settings.get.tickFrequency
         canCharge ||= charge > 0 && node.globalBuffer >= charge * 0.5
         if (canCharge) {
-          (0 until getSizeInventory).map(getStackInSlot).foreach(stack => if (!stack.isEmpty) {
+          (0 until getSizeInventory).map(getStackInSlot).foreach(chargeStack(_, charge))
-            val missing = node.changeBuffer(-charge)
+        }
-            val surplus = ItemCharge.charge(stack, charge + missing) // missing is negative
+      }
-            node.changeBuffer(surplus)
+
-          })
+      // Charging of equipment
+      {
+        val charge = Settings.get.chargeRateTablet * chargeSpeed * Settings.get.tickFrequency
+        canCharge ||= charge > 0 && node.globalBuffer >= charge * 0.5
+        if (canCharge) {
+          equipment.foreach(chargeStack(_, charge))
         }
       }
 
@@ -238,17 +252,35 @@ class Charger extends traits.Environment with traits.PowerAcceptor with traits.R
     }
 
     val players = getWorld.getEntitiesWithinAABB(classOf[EntityPlayer], bounds).collect {
-      case player: EntityPlayer if api.Nanomachines.hasController(player) => new PlayerChargeable(player)
+      case player: EntityPlayer => player
+    }
+
+    val chargeablePlayers = players.collect {
+      case player if api.Nanomachines.hasController(player) => new PlayerChargeable(player)
     }
 
     // Only update list when we have to, keeps pointless block updates to a minimum.
 
-    val newConnectors = robots ++ drones ++ players
+    val newConnectors = robots ++ drones ++ chargeablePlayers
     if (connectors.size != newConnectors.length || (connectors.nonEmpty && (connectors -- newConnectors).nonEmpty)) {
       connectors.clear()
       connectors ++= newConnectors
       getWorld.notifyNeighborsOfStateChange(getPos, getBlockType, false)
     }
+
+    // scan players for chargeable equipment
+    equipment.clear()
+    players.foreach {
+      player => player.inventory.mainInventory.foreach {
+        stack: ItemStack =>
+          if (Option(Driver.driverFor(stack, getClass)) match {
+            case Some(driver) if driver.slot(stack) == Slot.Tablet => true
+            case _ => ItemCharge.canCharge(stack)
+          }) {
+            equipment += stack
+          }
+      }
+    }
   }
 
   trait Chargeable {