134 lines
4.7 KiB
Kotlin
134 lines
4.7 KiB
Kotlin
package net.shadowfacts.phycon.block.extractor
|
|
|
|
import alexiil.mc.lib.attributes.SearchOptions
|
|
import alexiil.mc.lib.attributes.Simulation
|
|
import alexiil.mc.lib.attributes.item.FixedItemInv
|
|
import alexiil.mc.lib.attributes.item.ItemAttributes
|
|
import alexiil.mc.lib.attributes.item.filter.ExactItemStackFilter
|
|
import net.minecraft.block.BlockState
|
|
import net.minecraft.item.ItemStack
|
|
import net.minecraft.nbt.NbtCompound
|
|
import net.minecraft.util.math.BlockPos
|
|
import net.minecraft.util.math.Direction
|
|
import net.shadowfacts.phycon.api.packet.Packet
|
|
import net.shadowfacts.phycon.init.PhyBlockEntities
|
|
import net.shadowfacts.phycon.block.DeviceBlockEntity
|
|
import net.shadowfacts.phycon.block.FaceDeviceBlock
|
|
import net.shadowfacts.phycon.component.ActivationController
|
|
import net.shadowfacts.phycon.component.NetworkStackDispatcher
|
|
import net.shadowfacts.phycon.component.finishTimedOutPendingInsertions
|
|
import net.shadowfacts.phycon.component.handleItemStack
|
|
import net.shadowfacts.phycon.packet.CapacityPacket
|
|
import net.shadowfacts.phycon.packet.ItemStackPacket
|
|
import net.shadowfacts.phycon.packet.RemoteActivationPacket
|
|
import net.shadowfacts.phycon.util.ActivationMode
|
|
import net.shadowfacts.phycon.util.ClientConfigurableDevice
|
|
import kotlin.properties.Delegates
|
|
|
|
/**
|
|
* @author shadowfacts
|
|
*/
|
|
class ExtractorBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(PhyBlockEntities.EXTRACTOR, pos, state),
|
|
NetworkStackDispatcher<ExtractorBlockEntity.PendingInsertion>,
|
|
ActivationController.ActivatableDevice,
|
|
ClientConfigurableDevice {
|
|
|
|
companion object {
|
|
val SLEEP_TIME = 40L
|
|
}
|
|
|
|
private val facing: Direction
|
|
get() = cachedState[FaceDeviceBlock.FACING]
|
|
|
|
private var inventory: FixedItemInv? = null
|
|
override val pendingInsertions = mutableListOf<PendingInsertion>()
|
|
override val dispatchStackTimeout = 1L
|
|
override val controller = ActivationController(SLEEP_TIME, this)
|
|
|
|
fun updateInventory() {
|
|
val offsetPos = pos.offset(facing)
|
|
val option = SearchOptions.inDirection(facing)
|
|
inventory = ItemAttributes.FIXED_INV.getFirstOrNull(world, offsetPos, option)
|
|
}
|
|
|
|
private fun getInventory(): FixedItemInv? {
|
|
if (inventory == null) updateInventory()
|
|
return inventory
|
|
}
|
|
|
|
override fun handle(packet: Packet) {
|
|
when (packet) {
|
|
is CapacityPacket -> handleCapacity(packet)
|
|
is ItemStackPacket -> handleItemStack(packet)
|
|
is RemoteActivationPacket -> controller.handleRemoteActivation(packet)
|
|
}
|
|
}
|
|
|
|
override fun doHandleItemStack(packet: ItemStackPacket): ItemStack {
|
|
// we can't insert things back into the inventory, so just let them spawn
|
|
return packet.stack
|
|
}
|
|
|
|
override fun createPendingInsertion(stack: ItemStack) = PendingInsertion(stack, counter)
|
|
|
|
override fun finishInsertion(insertion: PendingInsertion): ItemStack {
|
|
val inventory = getInventory() ?: return insertion.stack
|
|
// if the inventory has changed, the old slot index is meaningless
|
|
if (inventory !== insertion.inventory) return insertion.stack
|
|
val extracted = inventory.extractStack(insertion.inventorySlot, ExactItemStackFilter(insertion.stack), ItemStack.EMPTY, insertion.totalCapacity, Simulation.ACTION)
|
|
if (extracted.isEmpty) return insertion.stack
|
|
// if we extracted less than expected, make sure super.finishInsertion doesn't send more than we actually have
|
|
insertion.stack = extracted
|
|
return super.finishInsertion(insertion)
|
|
}
|
|
|
|
override fun tick() {
|
|
super.tick()
|
|
|
|
if (!world!!.isClient) {
|
|
controller.tick()
|
|
|
|
finishTimedOutPendingInsertions()
|
|
}
|
|
}
|
|
|
|
override fun activate(): Boolean {
|
|
val inventory = getInventory() ?: return false
|
|
for (slot in 0 until inventory.slotCount) {
|
|
val slotStack = inventory.getInvStack(slot)
|
|
if (slotStack.isEmpty) continue
|
|
val extractable = inventory.extractStack(slot, ExactItemStackFilter(slotStack), ItemStack.EMPTY, slotStack.count, Simulation.SIMULATE)
|
|
if (extractable.isEmpty) continue
|
|
dispatchItemStack(extractable) { insertion ->
|
|
insertion.inventory = inventory
|
|
insertion.inventorySlot = slot
|
|
}
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
override fun toCommonTag(tag: NbtCompound) {
|
|
super.toCommonTag(tag)
|
|
writeDeviceConfiguration(tag)
|
|
}
|
|
|
|
override fun fromCommonTag(tag: NbtCompound) {
|
|
super.fromCommonTag(tag)
|
|
loadDeviceConfiguration(tag)
|
|
}
|
|
|
|
override fun writeDeviceConfiguration(tag: NbtCompound) {
|
|
tag.putString("ActivationMode", controller.activationMode.name)
|
|
}
|
|
|
|
override fun loadDeviceConfiguration(tag: NbtCompound) {
|
|
controller.activationMode = ActivationMode.valueOf(tag.getString("ActivationMode"))
|
|
}
|
|
|
|
class PendingInsertion(stack: ItemStack, timestamp: Long): NetworkStackDispatcher.PendingInsertion<PendingInsertion>(stack, timestamp) {
|
|
lateinit var inventory: FixedItemInv
|
|
var inventorySlot by Delegates.notNull<Int>()
|
|
}
|
|
}
|