Merge pull request #835 from pylonmc/idra/recipe-rewrite

DIVINIA RATIO COQUINARIA™

Author: LordIdra

nms/src/main/kotlin/io/github/pylonmc/rebar/nms/NmsAccessorImpl.kt

@@ -72,7 +72,14 @@ import kotlin.math.max
 import kotlin.math.min
 import com.mojang.datafixers.util.Pair as NmsPair
 import net.minecraft.world.entity.EquipmentSlot as NmsEquipmentSlot
-
+import net.minecraft.world.item.ItemStack as NmsItemStack
+import net.minecraft.core.component.DataComponentType as NmsDataComponentType
+
+/**
+ * Documentation is in [NmsAccessor].
+ *
+ * @see NmsAccessor
+ */
 @Suppress("unused")
 object NmsAccessorImpl : NmsAccessor {
 
@@ -337,6 +344,11 @@ object NmsAccessorImpl : NmsAccessor {
         }
     }
 
+    fun getBukkitType(nmsType: NmsDataComponentType<*>): PaperDataComponentType<*, *>? {
+        val bukkitType = PaperDataComponentType.minecraftToBukkit(nmsType) as? PaperDataComponentType<*, *>
+        return if (bukkitType !is PaperDataComponentType.Unimplemented<*, *>) bukkitType else null
+    }
+
     override fun getOverriddenTypes(itemStack: ItemStack): List<DataComponentType> {
         val schema = RebarItemSchema.fromStack(itemStack)
         val nmsStack = (itemStack as CraftItemStack).handle
@@ -346,10 +358,119 @@ object NmsAccessorImpl : NmsAccessor {
             val types = mutableListOf<DataComponentType>()
             for (type in nmsTemplate.components.keySet()) {
                 if (nmsTemplate.get(type) != nmsStack.get(type)) {
-                    types.add(PaperDataComponentType.minecraftToBukkit(type))
+                    types.add(getBukkitType(type) ?: continue)
                 }
             }
+            return types
+        }
+        return nmsStack.componentsPatch.entrySet().mapNotNull { getBukkitType(it.key) }
+    }
+
+    fun <T: Any, NMS: Any> componentMatches(itemStack: NmsItemStack, type: PaperDataComponentType.ValuedImpl<T, NMS>, value: Any?): Boolean {
+        val nmsType = PaperDataComponentType.bukkitToMinecraft<NMS>(type)
+        val nmsValue = itemStack.get(nmsType)
+        if (nmsValue == value) {
+            return true
+        } else if (value == null || nmsValue == null) {
+            return false
         }
-        return nmsStack.componentsPatch.entrySet().map { PaperDataComponentType.minecraftToBukkit(it.key) }
+
+        val adaptedValue = type.adapter.fromVanilla(nmsValue)
+        return adaptedValue == value
+    }
+
+    fun componentMatches(itemStack: NmsItemStack, type: PaperDataComponentType.NonValuedImpl<*, *>, hasValue: Boolean): Boolean {
+        val nmsType = PaperDataComponentType.bukkitToMinecraft<Unit>(type)
+        return itemStack.has(nmsType) == hasValue
+    }
+
+    fun <T: Any, NMS: Any> convertNmsValue(type: PaperDataComponentType<T, NMS>, nmsValue: Any): T {
+        return type.adapter.fromVanilla(nmsValue as NMS)
+    }
+
+    override fun overriddenComponents(itemStack: ItemStack, exact: Boolean): Map<DataComponentType, Any?> {
+        val nmsComponents = mutableMapOf<NmsDataComponentType<*>, Any?>()
+        val schema = RebarItemSchema.fromStack(itemStack)
+        val nmsStack = (itemStack as CraftItemStack).handle
+        if (schema != null && !exact) {
+            val template = schema.getOriginalTemplate()
+            val nmsTemplate = (template as CraftItemStack).handle
+            for (type in nmsTemplate.components.keySet()) {
+                val realValue = nmsStack.get(type)
+                if (nmsTemplate.get(type) != realValue) {
+                    nmsComponents[type] = realValue
+                }
+            }
+        } else {
+            for (component in nmsStack.componentsPatch.entrySet()) {
+                nmsComponents[component.key] = component.value.orElse(null)
+            }
+        }
+
+        val components = mutableMapOf<DataComponentType, Any?>()
+        for (component in nmsComponents) {
+            val bukkitType = getBukkitType(component.key) ?: continue
+            val bukkitValue = component.value?.let { convertNmsValue(bukkitType, it) }
+            components[bukkitType] = bukkitValue
+        }
+        return components
+    }
+
+    override fun hasDefaultComponents(itemStack: ItemStack, components: Set<DataComponentType>): Boolean {
+        val schema = RebarItemSchema.fromStack(itemStack)
+        val nmsStack = (itemStack as CraftItemStack).handle
+        if (schema != null) {
+            val template = schema.getOriginalTemplate()
+            val nmsTemplate = (template as CraftItemStack).handle
+            for (type in components) {
+                val nmsType = PaperDataComponentType.bukkitToMinecraft<Any>(type)
+                if (nmsTemplate.get(nmsType) != nmsStack.get(nmsType)) {
+                    return false
+                }
+            }
+            return true
+        }
+        return components.none {
+            val nmsType = PaperDataComponentType.bukkitToMinecraft<Any>(it)
+            nmsStack.hasNonDefault(nmsType)
+        }
+    }
+
+    override fun isDefaultComponents(itemStack: ItemStack): Boolean {
+        val schema = RebarItemSchema.fromStack(itemStack)
+        val nmsStack = (itemStack as CraftItemStack).handle
+        if (schema != null) {
+            val template = schema.getOriginalTemplate()
+            val nmsTemplate = (template as CraftItemStack).handle
+            for (type in nmsTemplate.components.keySet()) {
+                if (nmsTemplate.get(type) != nmsStack.get(type)) {
+                    return false
+                }
+            }
+            return true
+        }
+        return nmsStack.componentsPatch.size() == 0
+    }
+
+    override fun componentsMatch(itemStack: ItemStack, components: Map<DataComponentType, Any?>): Boolean {
+        val nmsStack = (itemStack as CraftItemStack).handle
+        for (component in components) {
+            val type = component.key
+            val value = component.value
+            val matches = when (type) {
+                is PaperDataComponentType.NonValuedImpl<*, *> -> componentMatches(nmsStack, type, value != null)
+                is PaperDataComponentType.ValuedImpl<*, *> -> componentMatches(nmsStack, type, value)
+                else -> true // should be unreachable
+            }
+            if (!matches) {
+                return false
+            }
+        }
+        return true
+    }
+
+    override fun componentsEqual(itemStack: ItemStack, components: Map<DataComponentType, Any?>): Boolean {
+        val nmsStack = (itemStack as CraftItemStack).handle
+        return componentsMatch(itemStack, components) && nmsStack.componentsPatch.size() == components.size
     }
 }

rebar/src/main/kotlin/io/github/pylonmc/rebar/Rebar.kt

@@ -35,16 +35,16 @@ import io.github.pylonmc.rebar.item.research.Research
 import io.github.pylonmc.rebar.logistics.CargoRoutes
 import io.github.pylonmc.rebar.metrics.RebarMetrics
 import io.github.pylonmc.rebar.recipe.ConfigurableRecipeType
-import io.github.pylonmc.rebar.recipe.RebarRecipeListener
-import io.github.pylonmc.rebar.recipe.RecipeCompletion
+import io.github.pylonmc.rebar.recipe.logic.RebarRecipeListener
+import io.github.pylonmc.rebar.recipe.logic.RecipeCompletion
 import io.github.pylonmc.rebar.recipe.RecipeType
 import io.github.pylonmc.rebar.registry.RebarRegistry
 import io.github.pylonmc.rebar.util.delayTicks
 import io.github.pylonmc.rebar.item.interfaces.*
 import io.github.pylonmc.rebar.nms.NmsAccessor
 import io.github.pylonmc.rebar.util.mergeResource
 import io.github.pylonmc.rebar.waila.Waila
-import io.github.pylonmc.rebar.waila.WailaPlaceholders
+import io.github.pylonmc.rebar.integration.WailaPlaceholders
 import io.papermc.paper.ServerBuildInfo
 import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents
 import kotlinx.coroutines.CoroutineScope
@@ -371,7 +371,7 @@ object Rebar : JavaPlugin(), RebarAddon {
         val start = System.currentTimeMillis()
 
         for (addon in RebarRegistry.ADDONS) {
-            mergeResource(addon, "researches.yml", "researches/${addon.key.namespace}.yml", false)
+            mergeResource(addon, Rebar, "researches.yml", "researches/${addon.key.namespace}.yml", false)
         }
 
         val researchDir = dataPath.resolve("researches")

rebar/src/main/kotlin/io/github/pylonmc/rebar/block/interfaces/CargoRebarBlock.kt

@@ -38,16 +38,21 @@ import kotlin.collections.iterator
 import kotlin.math.min
 
 /**
- * Represents a block that can connect to cargo ducts and use them to interface
- * with other RebarCargoBlocks.
+ * If you are looking to allow logistics systems (including cargo) to add/remove items
+ * from your block, see [LogisticRebarBlock]. This interface is specifically for blocks
+ * which connect to cargo ducts or directly to other CargoRebarBlocks.
+ *
+ * Represents a block that can connect to cargo ducts or directly to other RebarCargoBlocks.
  *
  * Each face can have one logistic group which cargo ducts (or other RebarCargoBlocks)
  * connected to that face are allowed to interface with.
  *
- * In your place constructor, you will need to call [addCargoLogisticGroup] for all
- * the block faces you want to be able to connect cargo ducts to, and also
+ * In your place constructor, you will need to call [CargoRebarBlock.addCargoLogisticGroup]
+ * for all the block faces you want to be able to connect cargo ducts to, and also
  * `setCargoTransferRate` to set the maximum number of items that can be transferred
  * out of this block per cargo tick.
+ *
+ * @see LogisticRebarBlock
  */
 interface CargoRebarBlock : LogisticRebarBlock, EntityHolderRebarBlock {
 
@@ -130,6 +135,12 @@ interface CargoRebarBlock : LogisticRebarBlock, EntityHolderRebarBlock {
         }
     }
 
+    /**
+     * This function will tick each face which has a logistic group by finding the
+     * block and face which the face connects to (either directly or via cargo ducts)
+     * and trying to move items from the source faces on this block to their
+     * corresponding target faces.
+     */
     @ApiStatus.Internal
     fun tickCargo() {
         for ((face, group) in cargoBlockData.groups) {
@@ -153,6 +164,11 @@ interface CargoRebarBlock : LogisticRebarBlock, EntityHolderRebarBlock {
         }
     }
 
+    /**
+     * Attempts to move cargo from [sourceGroup] to [targetGroup]. This assumes that routing
+     * logic has been performed, we know where items need to be transferred to, and now we
+     * just need to actually transfer the items.
+     */
     @ApiStatus.Internal
     fun tickCargoFace(sourceGroup: LogisticGroup, targetGroup: LogisticGroup) {
         for (sourceSlot in sourceGroup.slots) {

rebar/src/main/kotlin/io/github/pylonmc/rebar/block/interfaces/DirectionalRebarBlock.kt

@@ -16,6 +16,8 @@ import java.util.IdentityHashMap
 /**
  * Represents a block that has a specific facing direction.
  *
+ * You should set [DirectionalRebarBlock.facing] in your place constructor. The face you set will be persisted over reloads.
+ *
  * Internally only used for rotating [RebarBlock.blockTextureEntity]s.
  */
 interface DirectionalRebarBlock : Keyed {

rebar/src/main/kotlin/io/github/pylonmc/rebar/block/interfaces/EntityCulledRebarBlock.kt

@@ -6,6 +6,9 @@ import org.bukkit.Bukkit
 import org.bukkit.entity.Player
 import java.util.UUID
 
+/**
+ * TODO docs (JustAHuman)
+ */
 interface EntityCulledRebarBlock : CulledRebarBlock {
     /**
      * Any entity id's that should be culled when the block is considered culled by the BlockTextureEngine.

rebar/src/main/kotlin/io/github/pylonmc/rebar/block/interfaces/EntityGroupCulledRebarBlock.kt

@@ -14,7 +14,7 @@ import java.util.UUID
  * on the display entities (multiple blocks use the same entity), and therefor should
  * only cull said entities if all blocks using that entity are culled.
  */
-interface EntityGroupCulledRebarBlock : GroupCulledRebarBLock {
+interface EntityGroupCulledRebarBlock : GroupCulledRebarBlock {
     override val cullingGroups: Iterable<EntityCullingGroup>
 
     override val isCulledAsync: Boolean
@@ -25,7 +25,7 @@ interface EntityGroupCulledRebarBlock : GroupCulledRebarBLock {
         return group.entityIds.firstOrNull()?.let { player.isVisibilityInverted(it) } ?: true
     }
 
-    override fun onGroupVisible(player: Player, group: GroupCulledRebarBLock.CullingGroup) {
+    override fun onGroupVisible(player: Player, group: GroupCulledRebarBlock.CullingGroup) {
         if (group !is EntityCullingGroup) return
         for (entityId in group.entityIds) {
             if (player.isVisibilityInverted(entityId)) {
@@ -36,7 +36,7 @@ interface EntityGroupCulledRebarBlock : GroupCulledRebarBLock {
         }
     }
 
-    override fun onGroupCulled(player: Player, group: GroupCulledRebarBLock.CullingGroup) {
+    override fun onGroupCulled(player: Player, group: GroupCulledRebarBlock.CullingGroup) {
         if (group !is EntityCullingGroup) return
         for (entityId in group.entityIds) {
             if (!player.isVisibilityInverted(entityId)) {
@@ -49,7 +49,7 @@ interface EntityGroupCulledRebarBlock : GroupCulledRebarBLock {
 
     class EntityCullingGroup(
         id: String,
-        blocks: MutableSet<GroupCulledRebarBLock> = mutableSetOf(),
+        blocks: MutableSet<GroupCulledRebarBlock> = mutableSetOf(),
         val entityIds: MutableSet<UUID> = mutableSetOf()
-    ) : GroupCulledRebarBLock.CullingGroup(id, blocks)
+    ) : GroupCulledRebarBlock.CullingGroup(id, blocks)
 }

rebar/src/main/kotlin/io/github/pylonmc/rebar/block/interfaces/FacadeRebarBlock.kt

@@ -20,8 +20,6 @@ interface FacadeRebarBlock : InteractRebarBlockHandler {
      */
     val block: Block
 
-    val facadeDefaultBlockType: Material
-
     @MultiHandler(priorities = [EventPriority.MONITOR])
     override fun onInteractedWith(event: PlayerInteractEvent, priority: EventPriority) {
         if (!event.action.isRightClick || event.player.isSneaking || event.hand != EquipmentSlot.HAND) {

rebar/src/main/kotlin/io/github/pylonmc/rebar/block/interfaces/FluidBufferRebarBlock.kt

@@ -19,17 +19,20 @@ import kotlin.math.max
  *
  * In more detail: Usually, fluid machines store fluids in internal 'buffers.'
  * For example, the press has an internal buffer used to store plant oil, of
- * size 1000mB by default. This is a common enough thing that we created a new
- * interface to handle it: RebarFluidBufferBlock. This interface allows your
- * block to easily manage fluid buffers.
+ * size 1000mB by default. This is a common enough thing that we created this
+ * interface to handle it. This interface allows your block to easily manage
+ * fluid buffers.
  *
- * You will need to call `createFluidBuffer` when your block is placed
- * and specify the buffer's fluid type, capacity, whether it can take in
- * fluids from input points, and whether it can supply fluids to output
- * points.
+ * You will need to call [FluidBufferRebarBlock.createFluidBuffer]
+ * when your block is placed and specify the buffer's fluid type, capacity,
+ * whether it can take in fluids from input points, and whether it can supply
+ * fluids to output points.
  *
  * You do not need to handle saving buffers or implement any of the
- * `RebarFluidBlock` methods for this; this is all done automatically.
+ * [FluidRebarBlock] methods for this; this is all done automatically.
+ *
+ * @see FluidTankRebarBlock
+ * @see FluidRebarBlock
  */
 interface FluidBufferRebarBlock : FluidRebarBlock {
     private val fluidBuffers: MutableMap<RebarFluid, FluidBufferData>

rebar/src/main/kotlin/io/github/pylonmc/rebar/block/interfaces/FluidRebarBlock.kt

@@ -12,7 +12,7 @@ import org.bukkit.inventory.ItemStack
 import org.jetbrains.annotations.MustBeInvokedByOverriders
 
 /**
- * A block that interacts with fluids in some way.
+ * A block that interacts with the fluid system.
  *
  * This is a very flexible class which requires you to define exactly how fluid should
  * be input and output. You are responsible for keeping track of any state, like how
@@ -25,7 +25,6 @@ import org.jetbrains.annotations.MustBeInvokedByOverriders
  *
  * Multiple inputs/outputs are not supported. You can have at most 1 input and 1 output.
  *
- *
  * @see FluidBufferRebarBlock
  * @see FluidTankRebarBlock
  */

rebar/src/main/kotlin/io/github/pylonmc/rebar/block/interfaces/FluidTankRebarBlock.kt

@@ -18,13 +18,16 @@ import kotlin.math.max
  * time, but can store many types of fluids. `RebarFluidTank` implements this
  * pattern.
  *
- * You must call [setCapacity] for this
- * block to work.
+ * To use this interface, call [FluidTankRebarBlock.setCapacity] in your place
+ * constructor and implement [isAllowedFluid] to control which fluids can be
+ * stored in this tank.
  *
  * As with [FluidBufferRebarBlock], you do not need to handle saving buffers
  * or implement any of the [FluidRebarBlock] methods for this; this is all
  * done automatically.
  *
+ * @see FluidBufferRebarBlock
+ * @see FluidRebarBlock
  */
 interface FluidTankRebarBlock : FluidRebarBlock {
 
@@ -61,6 +64,8 @@ interface FluidTankRebarBlock : FluidRebarBlock {
     val fluidSpaceRemaining: Double
             get() = fluidData.capacity - fluidData.amount
 
+    fun isAllowedFluid(fluid: RebarFluid): Boolean
+
     /**
      * Sets the type of fluid in the fluid tank.
      */
@@ -135,8 +140,6 @@ interface FluidTankRebarBlock : FluidRebarBlock {
     fun removeFluid(amount: Double): Boolean
             = setFluid(fluidAmount - amount)
 
-    fun isAllowedFluid(fluid: RebarFluid): Boolean
-
     override fun fluidAmountRequested(fluid: RebarFluid): Double{
         if (!isAllowedFluid(fluid)) {
             return 0.0