feat(appeng): integrate StackApi for full fluid and essentia support.

dependencies.gradle

@@ -5,9 +5,9 @@ dependencies {
     shadowImplementation name: 'OC-JNLua', version: '20230530.0', ext: 'jar'
     shadowImplementation name: 'OC-JNLua-Natives', version: '20220928.1', ext: 'jar'
 
-    api("com.github.GTNewHorizons:AE2FluidCraft-Rework:1.5.39-gtnh:dev")
+    api("com.github.GTNewHorizons:AE2FluidCraft-Rework:1.5.58-gtnh:dev")
     compileOnly("com.github.GTNewHorizons:Angelica:1.0.0-beta68a:api") {transitive = false}
-    api("com.github.GTNewHorizons:Applied-Energistics-2-Unofficial:rv3-betea-777-GTNH:dev")
+    api("com.github.GTNewHorizons:Applied-Energistics-2-Unofficial:rv3-beta-817-GTNH:dev")
     compileOnly("com.github.GTNewHorizons:Avaritiaddons:1.9.3-GTNH:dev") {transitive = false}
     compileOnly("com.github.GTNewHorizons:BloodMagic:1.8.8:dev") {transitive = false}
     compileOnly("com.github.GTNewHorizons:BuildCraft:7.1.48:dev") {transitive = false}
@@ -27,7 +27,7 @@ dependencies {
     compileOnly("com.github.GTNewHorizons:ProjectRed:4.12.8-GTNH:dev") {transitive = false}
     compileOnly("com.github.GTNewHorizons:Railcraft:9.17.12:dev") {transitive = false}
     compileOnly("com.github.GTNewHorizons:StructureLib:1.4.25:dev") {transitive = false}
-    compileOnly("com.github.GTNewHorizons:ThaumicEnergistics:1.7.18-GTNH:dev") {transitive = false}
+    compileOnly("com.github.GTNewHorizons:ThaumicEnergistics:1.7.27-GTNH:dev") {transitive = false}
     compileOnly("com.github.GTNewHorizons:TinkersMechworks:0.4.1:dev") {transitive = false}
     compileOnly("com.github.GTNewHorizons:waila:1.9.15:dev") {transitive = false}
     compileOnly("com.github.GTNewHorizons:WirelessRedstone-CBE:1.7.1:dev") {transitive = false}

src/main/scala/li/cil/oc/integration/ae2fc/Ae2FcUtil.scala

@@ -2,7 +2,25 @@ package li.cil.oc.integration.ae2fc
 
 import appeng.api.storage.data.IAEFluidStack
 import com.glodblock.github.api.FluidCraftAPI
+import com.glodblock.github.loader.ItemAndBlockHolder
+import net.minecraft.block.Block
+import net.minecraft.item.ItemStack
 
 object Ae2FcUtil {
   def canSeeFluidInNetwork(fluid: IAEFluidStack) = fluid != null && fluid.getFluid != null && !FluidCraftAPI.instance().isBlacklistedInDisplay(fluid.getFluid.getClass)
+
+  def isFluidExportBus(stack: ItemStack): Boolean =
+    stack != null && stack.getItem == ItemAndBlockHolder.FLUID_EXPORT_BUS
+
+  def isFluidImportBus(stack: ItemStack): Boolean =
+    stack != null && stack.getItem == ItemAndBlockHolder.FLUID_IMPORT_BUS
+
+  def isFluidInterface(stack: ItemStack): Boolean =
+    stack != null && Block.getBlockFromItem(stack.getItem) == ItemAndBlockHolder.INTERFACE
+
+  def isPartFluidInterface(stack: ItemStack): Boolean =
+    stack != null && stack.getItem == ItemAndBlockHolder.FLUID_INTERFACE
+
+  def isFluidStorageBus(stack: ItemStack): Boolean =
+    stack != null && stack.getItem == ItemAndBlockHolder.FLUID_STORAGE_BUS
 }

src/main/scala/li/cil/oc/integration/ae2fc/ConverterFluidPacket.scala

@@ -0,0 +1,17 @@
+package li.cil.oc.integration.ae2fc
+
+import com.glodblock.github.common.item.ItemFluidPacket
+import li.cil.oc.api.driver.Converter
+import net.minecraft.item.ItemStack
+
+import java.util
+import scala.collection.convert.WrapAsScala._
+
+object ConverterFluidPacket extends Converter {
+
+  override def convert(value: Any, output: util.Map[AnyRef, AnyRef]): Unit = value match {
+    case stack: ItemStack if stack.getItem.isInstanceOf[ItemFluidPacket] =>
+      output += "fluidPacket" -> ItemFluidPacket.getFluidStack(stack)
+    case _ =>
+  }
+}

src/main/scala/li/cil/oc/integration/ae2fc/DriverBlockFluidInterface.scala

@@ -0,0 +1,50 @@
+package li.cil.oc.integration.ae2fc
+
+import appeng.api.storage.data.IAEFluidStack
+import com.glodblock.github.common.tile.TileFluidInterface
+import li.cil.oc.api.driver.{EnvironmentProvider, NamedBlock}
+import li.cil.oc.api.machine.{Arguments, Callback, Context}
+import li.cil.oc.api.network.ManagedEnvironment
+import li.cil.oc.api.prefab.DriverSidedTileEntity
+import li.cil.oc.integration.ManagedTileEntityEnvironment
+import li.cil.oc.integration.appeng.AEStackFactory
+import li.cil.oc.util.ResultWrapper._
+import net.minecraft.item.ItemStack
+import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
+
+object DriverBlockFluidInterface extends DriverSidedTileEntity {
+  def getTileEntityClass: Class[_] = classOf[TileFluidInterface]
+
+  def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
+    new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileFluidInterface])
+
+  final class Environment(val tile: TileFluidInterface) extends ManagedTileEntityEnvironment[TileFluidInterface](tile, "fluid_interface") with NamedBlock {
+
+    override def preferredName = "fluid_interface"
+
+    override def priority = 6
+
+    @Callback(doc = "function([slot:number]):table -- Get the configuration of the fluid interface.")
+    def getFluidInterfaceConfiguration(context: Context, args: Arguments): Array[AnyRef] = {
+      val slot = args.optInteger(0, 0)
+      result(tile.getConfig.getStackInSlot(slot))
+    }
+
+    @Callback(doc = "function([slot:number][, detail:table]):boolean -- Configure the fluid interface.")
+    def setFluidInterfaceConfiguration(context: Context, args: Arguments): Array[AnyRef] = {
+      val (slot, offset) = if (args.isInteger(0)) (args.checkInteger(0), 1) else (0, 0)
+      val stack = if (args.count() <= offset) null.asInstanceOf[IAEFluidStack]
+      else AEStackFactory.parse[IAEFluidStack](args.checkTable(offset))
+      tile.setConfig(slot, stack)
+      result(true)
+    }
+  }
+
+  object Provider extends EnvironmentProvider {
+    override def getEnvironment(stack: ItemStack): Class[_] =
+      if (Ae2FcUtil.isFluidInterface(stack))
+        classOf[Environment]
+      else null
+  }
+}

src/main/scala/li/cil/oc/integration/ae2fc/DriverFluidExportBus.scala

@@ -0,0 +1,56 @@
+package li.cil.oc.integration.ae2fc
+
+import appeng.api.parts.IPartHost
+import appeng.api.storage.data.IAEItemStack
+import com.glodblock.github.common.parts.PartFluidExportBus
+import li.cil.oc.api.driver
+import li.cil.oc.api.driver.{EnvironmentProvider, NamedBlock}
+import li.cil.oc.api.machine.{Arguments, Callback, Context}
+import li.cil.oc.integration.ManagedTileEntityEnvironment
+import li.cil.oc.integration.appeng.internal.PartSharedItemBusBase
+import net.minecraft.item.ItemStack
+import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
+
+import scala.reflect.ClassTag
+
+object DriverFluidExportBus extends driver.SidedBlock {
+  override def worksWith(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): Boolean =
+    world.getTileEntity(x, y, z) match {
+      case container: IPartHost => ForgeDirection.VALID_DIRECTIONS.map(container.getPart).filter(obj => {
+        obj != null
+      }).exists(_.isInstanceOf[PartFluidExportBus])
+      case _ => false
+    }
+
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[IPartHost])
+
+  final class Environment(val host: IPartHost)(implicit val tag: ClassTag[PartFluidExportBus]) extends ManagedTileEntityEnvironment[IPartHost](host, "fluid_exportbus") with NamedBlock with PartSharedItemBusBase[PartFluidExportBus] {
+
+    override def preferredName = "fluid_exportbus"
+
+    override def priority = 2
+
+    @Callback(doc = "function(side:number, [ slot:number]):boolean -- Get the configuration of the export bus pointing in the specified direction.")
+    def getExportConfiguration(context: Context, args: Arguments): Array[AnyRef] = this.getPartConfig(context, args)
+
+    @Callback(doc = "function(side:number[, slot:number][, database:address, entry:number]):boolean OR function(side:number[, slot:number][, detail: table):boolean -- Configure the export bus pointing in the specified direction to export item stacks matching the specified descriptor.")
+    def setExportConfiguration(context: Context, args: Arguments): Array[AnyRef] = this.setPartConfig[IAEItemStack](context, args)
+
+    @Callback(doc = "function(side:number):number -- Get the number of valid slots in this export bus.")
+    def getExportSlotSize(context: Context, args: Arguments): Array[AnyRef] = getSlotSize(context, args)
+
+    @Callback(doc = "function(side:number):boolean -- Get the ore filter of the export bus pointing in the specified direction.")
+    def getExportOreFilter(context: Context, args: Arguments): Array[AnyRef] = this.getPartOreFilter(context, args)
+
+    @Callback(doc = "function(side:number, filter: String):boolean -- Set the ore filter of the export bus pointing in the specified direction.")
+    def setExportOreFilter(context: Context, args: Arguments): Array[AnyRef] = this.setPartOreFilter(context, args)
+  }
+
+  object Provider extends EnvironmentProvider {
+    override def getEnvironment(stack: ItemStack): Class[_] =
+      if (Ae2FcUtil.isFluidExportBus(stack))
+        classOf[Environment]
+      else null
+  }
+}

src/main/scala/li/cil/oc/integration/ae2fc/DriverFluidImportBus.scala

@@ -0,0 +1,56 @@
+package li.cil.oc.integration.ae2fc
+
+import appeng.api.parts.IPartHost
+import appeng.api.storage.data.IAEFluidStack
+import com.glodblock.github.common.parts.PartFluidImportBus
+import li.cil.oc.api.driver
+import li.cil.oc.api.driver.{EnvironmentProvider, NamedBlock}
+import li.cil.oc.api.machine.{Arguments, Callback, Context}
+import li.cil.oc.integration.ManagedTileEntityEnvironment
+import li.cil.oc.integration.appeng.internal.PartSharedItemBusBase
+import net.minecraft.item.ItemStack
+import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
+
+import scala.reflect.ClassTag
+
+object DriverFluidImportBus extends driver.SidedBlock {
+  override def worksWith(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) =
+    world.getTileEntity(x, y, z) match {
+      case container: IPartHost => ForgeDirection.VALID_DIRECTIONS.map(container.getPart).filter(obj => {
+        obj != null
+      }).exists(_.isInstanceOf[PartFluidImportBus])
+      case _ => false
+    }
+
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[IPartHost])
+
+  final class Environment(val host: IPartHost)(implicit val tag: ClassTag[PartFluidImportBus]) extends ManagedTileEntityEnvironment[IPartHost](host, "fluid_importbus") with NamedBlock with PartSharedItemBusBase[PartFluidImportBus] {
+    override def preferredName = "fluid_importbus"
+
+    override def priority = 1
+
+    @Callback(doc = "function(side:number[, slot:number]):boolean -- Get the configuration of the import bus pointing in the specified direction.")
+    def getImportConfiguration(context: Context, args: Arguments): Array[AnyRef] = this.getPartConfig(context, args)
+
+    @Callback(doc = "function(side:number[, slot:number][, database:address, entry:number]):boolean OR function(side:number[, slot:number][, detail:table]):boolean -- Configure the import bus pointing in the specified direction to import item stacks matching the specified descriptor.")
+    def setImportConfiguration(context: Context, args: Arguments): Array[AnyRef] = this.setPartConfig[IAEFluidStack](context, args)
+
+    @Callback(doc = "function(side:number):number -- Get the number of valid slots in this import bus.")
+    def getImportSlotSize(context: Context, args: Arguments): Array[AnyRef] = getSlotSize(context, args)
+
+    @Callback(doc = "function(side:number):boolean -- Get the ore filter of the import bus pointing in the specified direction.")
+    def getImportOreFilter(context: Context, args: Arguments): Array[AnyRef] = this.getPartOreFilter(context, args)
+
+    @Callback(doc = "function(side:number, filter: String):boolean -- Set the ore filter of the import bus pointing in the specified direction.")
+    def setImportOreFilter(context: Context, args: Arguments): Array[AnyRef] = this.setPartOreFilter(context, args)
+  }
+
+  object Provider extends EnvironmentProvider {
+    override def getEnvironment(stack: ItemStack): Class[_] =
+      if (Ae2FcUtil.isFluidImportBus(stack))
+        classOf[Environment]
+      else null
+  }
+
+}

src/main/scala/li/cil/oc/integration/ae2fc/DriverFluidStorageBus.scala

@@ -0,0 +1,55 @@
+package li.cil.oc.integration.ae2fc
+
+import appeng.api.parts.IPartHost
+import appeng.api.storage.data.IAEFluidStack
+import com.glodblock.github.common.parts.PartFluidStorageBus
+import li.cil.oc.api.driver
+import li.cil.oc.api.driver.{EnvironmentProvider, NamedBlock}
+import li.cil.oc.api.machine.{Arguments, Callback, Context}
+import li.cil.oc.integration.ManagedTileEntityEnvironment
+import li.cil.oc.integration.appeng.internal.PartStorageBusBase
+import net.minecraft.item.ItemStack
+import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
+
+import scala.reflect.ClassTag
+
+object DriverFluidStorageBus extends driver.SidedBlock {
+  override def worksWith(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) =
+    world.getTileEntity(x, y, z) match {
+      case container: IPartHost => ForgeDirection.VALID_DIRECTIONS.map(container.getPart).filter(obj => {
+        obj != null
+      }).exists(_.isInstanceOf[PartFluidStorageBus])
+      case _ => false
+    }
+
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[IPartHost])
+
+  final class Environment(val host: IPartHost)(implicit val tag: ClassTag[PartFluidStorageBus]) extends ManagedTileEntityEnvironment[IPartHost](host, "fluid_storagebus") with NamedBlock with PartStorageBusBase[PartFluidStorageBus] {
+    override def preferredName = "fluid_storagebus"
+
+    override def priority = 2
+
+    @Callback(doc = "function(side:number[, slot:number]):boolean -- Get the configuration of the storage bus pointing in the specified direction.")
+    def getStorageConfiguration(context: Context, args: Arguments): Array[AnyRef] = this.getPartConfig(context, args)
+
+    @Callback(doc = "function(side:number[, slot:number][, database:address, entry:number]):boolean OR function(side:number[, slot:number][, detail:table]):boolean -- Configure the storage bus pointing in the specified direction to storage item stacks matching the specified descriptor.")
+    def setStorageConfiguration(context: Context, args: Arguments): Array[AnyRef] = this.setPartConfig[IAEFluidStack](context, args)
+
+    @Callback(doc = "function(side:number):boolean -- Get the ore filter of the storage bus pointing in the specified direction.")
+    def getStorageOreFilter(context: Context, args: Arguments): Array[AnyRef] = this.getPartOreFilter(context, args)
+
+    @Callback(doc = "function(side:number, filter: String):boolean -- Set the ore filter of the storage bus pointing in the specified direction.")
+    def setStorageOreFilter(context: Context, args: Arguments): Array[AnyRef] = this.setPartOreFilter(context, args)
+
+    @Callback(doc = "function(side:number):number -- Get the number of valid slots in this storage bus.")
+    def getStorageSlotSize(context: Context, args: Arguments): Array[AnyRef] = this.getSlotSize(context, args)
+  }
+
+  object Provider extends EnvironmentProvider {
+    override def getEnvironment(stack: ItemStack): Class[_] =
+      if (Ae2FcUtil.isFluidStorageBus(stack))
+        classOf[Environment]
+      else null
+  }
+}

src/main/scala/li/cil/oc/integration/ae2fc/DriverPartFluidInterface.scala

@@ -0,0 +1,60 @@
+package li.cil.oc.integration.ae2fc
+
+import appeng.api.parts.IPartHost
+import appeng.api.storage.data.IAEFluidStack
+import com.glodblock.github.common.parts.PartFluidInterface
+import li.cil.oc.api.driver
+import li.cil.oc.api.driver.{EnvironmentProvider, NamedBlock}
+import li.cil.oc.api.machine.{Arguments, Callback, Context}
+import li.cil.oc.integration.ManagedTileEntityEnvironment
+import li.cil.oc.integration.appeng.AEStackFactory
+import li.cil.oc.integration.appeng.internal.PartInterfaceEnvironment
+import li.cil.oc.util.ExtendedArguments.extendedArguments
+import li.cil.oc.util.ResultWrapper.result
+import net.minecraft.item.ItemStack
+import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
+
+import scala.reflect.ClassTag
+
+object DriverPartFluidInterface extends driver.SidedBlock {
+  override def worksWith(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) =
+    world.getTileEntity(x, y, z) match {
+      case container: IPartHost => ForgeDirection.VALID_DIRECTIONS.map(container.getPart).filter(obj => {
+        obj != null
+      }).exists(_.isInstanceOf[PartFluidInterface])
+      case _ => false
+    }
+
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[IPartHost])
+
+  final class Environment(val host: IPartHost)(implicit val tag: ClassTag[PartFluidInterface]) extends ManagedTileEntityEnvironment[IPartHost](host, "fluid_interface") with NamedBlock with PartInterfaceEnvironment[PartFluidInterface] {
+    override def preferredName = "fluid_interface"
+
+    override def priority = 6
+
+    @Callback(doc = "function(side:number[, slot:number]):table -- Get the configuration of the fluid interface.")
+    def getFluidInterfaceConfiguration(context: Context, args: Arguments): Array[AnyRef] = {
+      val side = args.checkSideAny(0)
+      val slot = args.optInteger(1, 0)
+      result(getPart(side).getConfig.getStackInSlot(slot))
+    }
+
+    @Callback(doc = "function(side:number[, slot:number][, detail:table]):boolean -- Configure the fluid interface.")
+    def setFluidInterfaceConfiguration(context: Context, args: Arguments): Array[AnyRef] = {
+      val side = args.checkSideAny(0)
+      val (slot, offset) = if (args.isInteger(1)) (args.checkInteger(1), 2) else (0, 1)
+      val stack = if (args.count() <= offset) null.asInstanceOf[IAEFluidStack]
+      else AEStackFactory.parse[IAEFluidStack](args.checkTable(offset))
+      getPart(side).setConfig(slot, stack)
+      result(true)
+    }
+  }
+
+  object Provider extends EnvironmentProvider {
+    override def getEnvironment(stack: ItemStack): Class[_] =
+      if (Ae2FcUtil.isPartFluidInterface(stack))
+        classOf[Environment]
+      else null
+  }
+}

src/main/scala/li/cil/oc/integration/ae2fc/ModAe2fc.scala

@@ -3,10 +3,23 @@ package li.cil.oc.integration.ae2fc
 import li.cil.oc.api.Driver
 import li.cil.oc.integration.{Mod, ModProxy, Mods}
 
-object ModAe2fc  extends ModProxy {
+object ModAe2fc extends ModProxy {
   override def getMod: Mod = Mods.Ae2Fc
+
   override def initialize(): Unit = {
     Driver.add(ConverterFluidDrop)
+    Driver.add(ConverterFluidPacket)
     Driver.add(new ConverterFluidCellInventory)
+
+    Driver.add(DriverBlockFluidInterface)
+    Driver.add(DriverBlockFluidInterface.Provider)
+    Driver.add(DriverPartFluidInterface)
+    Driver.add(DriverPartFluidInterface.Provider)
+    Driver.add(DriverFluidExportBus)
+    Driver.add(DriverFluidExportBus.Provider)
+    Driver.add(DriverFluidImportBus)
+    Driver.add(DriverFluidImportBus.Provider)
+    Driver.add(DriverFluidStorageBus)
+    Driver.add(DriverFluidStorageBus.Provider)
   }
 }