Dynamic blueprints and structure building prototype

Author: Avanatiker

common/src/main/kotlin/com/lambda/graphics/buffer/vao/VAO.kt

@@ -19,8 +19,7 @@ import com.lambda.graphics.gl.VaoUtils.bufferData
 import com.lambda.graphics.gl.VaoUtils.unbindIndexBuffer
 import com.lambda.graphics.gl.VaoUtils.unbindVertexArray
 import com.lambda.graphics.gl.VaoUtils.unbindVertexBuffer
-import com.lambda.threading.mainThread
-import com.lambda.threading.runOnGameThread
+import com.lambda.threading.runGameScheduled
 import com.mojang.blaze3d.systems.RenderSystem.drawElements
 import org.lwjgl.opengl.GL30C.*
 import java.awt.Color
@@ -50,7 +49,7 @@ class VAO(
         val stride = attribGroup.stride
         objectSize = stride * drawMode.indicesCount
 
-        runGameConcurrent {
+        runGameScheduled {
             vertices = byteBuffer(objectSize * 256 * 4)
             verticesPointer = address(vertices)
             verticesPosition = verticesPointer
@@ -198,7 +197,7 @@ class VAO(
     }
 
     fun destroy() {
-        runOnGameThread {
+        runGameScheduled {
             glDeleteBuffers(ibo)
             glDeleteBuffers(vbo)
             glDeleteVertexArrays(vao)

common/src/main/kotlin/com/lambda/interaction/RotationManager.kt

@@ -15,7 +15,7 @@ import com.lambda.interaction.rotation.Rotation.Companion.slerp
 import com.lambda.interaction.rotation.RotationContext
 import com.lambda.interaction.rotation.RotationMode
 import com.lambda.module.modules.client.Baritone
-import com.lambda.threading.runGameConcurrent
+import com.lambda.threading.runGameScheduled
 import com.lambda.threading.runSafe
 import com.lambda.util.math.MathUtils.lerp
 import com.lambda.util.math.MathUtils.toRadian
@@ -50,7 +50,7 @@ object RotationManager : Loadable {
             val packet = event.packet
             if (packet !is PlayerPositionLookS2CPacket) return@listener
 
-            runGameConcurrent {
+            runGameScheduled {
                 reset(Rotation(packet.yaw, packet.pitch))
             }
         }

common/src/main/kotlin/com/lambda/interaction/construction/Blueprint.kt

@@ -1,50 +1,47 @@
 package com.lambda.interaction.construction
 
+import com.lambda.context.SafeContext
 import com.lambda.interaction.construction.verify.TargetState
+import com.lambda.util.BlockUtils.blockPos
+import com.lambda.util.primitives.extension.Structure
 import net.minecraft.structure.StructureTemplate
 import net.minecraft.util.math.BlockBox
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Box
 
-data class Blueprint(
-    private val structure: Map<BlockPos, TargetState>,
-    var offset: BlockPos? = null,
-) {
-    val origin: BlockPos
-        get() = offset ?: structure.keys.firstOrNull() ?: BlockPos.ORIGIN
-
-    private val modifications = mutableMapOf<BlockPos, TargetState>()
-    val structureMap: Map<BlockPos, TargetState>
-        get() {
-            offset?.let {
-                val offsetMap = mutableMapOf<BlockPos, TargetState>()
-                for ((pos, state) in structure) {
-                    offsetMap[pos.add(it)] = state
-                }
-                return offsetMap + modifications
-            }
+abstract class Blueprint {
+    abstract val structure: Structure
 
-            return structure + modifications
+    fun isDone(safeContext: SafeContext) =
+        structure.all { (pos, targetState) ->
+            with(safeContext) {
+                targetState.matches(world.getBlockState(pos), pos, world)
+            }
         }
 
     companion object {
-        fun Box.from(targetState: TargetState) =
-            Blueprint(BlockPos.stream(this).map { BlockPos(it) }.toList().associateWith { targetState })
-
-        fun BlockBox.from(targetState: TargetState) =
-            Blueprint(BlockPos.stream(this).map { BlockPos(it) }.toList().associateWith { targetState })
-
-        fun BlockPos.from(targetState: TargetState) =
-            Blueprint(setOf(this).associateWith { targetState })
+        fun Box.toStructure(targetState: TargetState): Structure =
+            BlockPos.stream(this)
+                .map { it.blockPos }
+                .toList()
+                .associateWith { targetState }
+
+        fun BlockBox.toStructure(targetState: TargetState): Structure =
+            BlockPos.stream(this)
+                .map { it.blockPos }
+                .toList()
+                .associateWith { targetState }
+
+        fun BlockPos.toStructure(targetState: TargetState): Structure =
+            setOf(this)
+                .associateWith { targetState }
 
 //        fun Schematic.fromSchematic() =
-//            Blueprint(this.blockMap.map { it.key to TargetState.BlockState(it.value) }.toMap())
-
-        fun StructureTemplate.fromStructureTemplate() =
-            Blueprint(
-                blockInfoLists
-                    .flatMap { it.all }
-                    .associate { it.pos to TargetState.State(it.state) }
-            )
+//            this.blockMap.map { it.key to TargetState.BlockState(it.value) }.toMap()
+
+        fun StructureTemplate.toStructure(): Structure =
+            blockInfoLists
+                .flatMap { it.all }
+                .associate { it.pos to TargetState.State(it.state) }
     }
 }

common/src/main/kotlin/com/lambda/interaction/construction/DynamicBlueprint.kt

@@ -0,0 +1,27 @@
+package com.lambda.interaction.construction
+
+import com.lambda.context.SafeContext
+import com.lambda.util.primitives.extension.Structure
+import net.minecraft.util.math.Vec3i
+
+data class DynamicBlueprint(
+    val initial: Structure = emptyMap(),
+    val update: SafeContext.(Structure) -> Structure,
+) : Blueprint() {
+    fun update(safeContext: SafeContext) =
+        safeContext.update(structure)
+
+    override val structure: Structure by lazy { initial }
+
+    companion object {
+        fun offset(offset: Vec3i): SafeContext.(Structure) -> Structure = {
+            it.map { (pos, state) ->
+                pos.add(offset) to state
+            }.toMap()
+        }
+
+        fun Structure.toBlueprint(
+            update: SafeContext.(Structure) -> Structure
+        ) = DynamicBlueprint(this, update)
+    }
+}

common/src/main/kotlin/com/lambda/interaction/construction/StaticBlueprint.kt

@@ -0,0 +1,11 @@
+package com.lambda.interaction.construction
+
+import com.lambda.util.primitives.extension.Structure
+
+data class StaticBlueprint(
+    override val structure: Structure
+) : Blueprint() {
+    companion object {
+        fun Structure.toBlueprint() = StaticBlueprint(this)
+    }
+}

common/src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt

@@ -0,0 +1,35 @@
+package com.lambda.interaction.construction.context
+
+import net.minecraft.block.BlockState
+import net.minecraft.util.Hand
+import net.minecraft.util.hit.BlockHitResult
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Direction
+import net.minecraft.util.math.Vec3d
+
+data class BreakContext(
+//    val hitVec: Vec3d,
+    val hitPos: BlockPos,
+    val exposedSides: Int,
+//    val side: Direction,
+    override val distance: Double,
+//    var hand: Hand,
+//    val pointOfView: Vec3d,
+//    val blockState: BlockState,
+) : BuildContext, ComparableContext {
+//    override val resultingPos = hitPos
+//    override fun toBlockHitResult() = BlockHitResult(hitVec, side, hitPos, false)
+
+//    val expectedBlockState = blockState.fluidState.blockState
+
+    override fun compareTo(other: ComparableContext): Int {
+        return when (other) {
+            is BreakContext -> compareByDescending<BreakContext> {
+                it.exposedSides
+            }.thenBy {
+                it.distance
+            }.compare(this, other)
+            else -> 1
+        }
+    }
+}

common/src/main/kotlin/com/lambda/interaction/construction/context/BuildContext.kt

@@ -0,0 +1,10 @@
+package com.lambda.interaction.construction.context
+
+import net.minecraft.util.hit.BlockHitResult
+import net.minecraft.util.math.BlockPos
+
+interface BuildContext {
+    val distance: Double
+//    val resultingPos: BlockPos
+//    fun toBlockHitResult(): BlockHitResult
+}

common/src/main/kotlin/com/lambda/interaction/construction/context/ComparableContext.kt

@@ -0,0 +1,7 @@
+package com.lambda.interaction.construction.context
+
+interface ComparableContext : Comparable<ComparableContext> {
+    override fun compareTo(other: ComparableContext): Int {
+        return 0
+    }
+}

common/src/main/kotlin/com/lambda/interaction/construction/result/BreakResult.kt

@@ -0,0 +1,27 @@
+package com.lambda.interaction.construction.result
+
+import com.lambda.interaction.construction.context.BreakContext
+import com.lambda.task.buildChain
+import com.lambda.task.tasks.BreakBlock.Companion.breakBlock
+
+sealed class BreakResult : BuildResult() {
+
+    /**
+     * Represents a successful break. All checks have been passed.
+     * @param context The context of the break.
+     */
+    data class Success(val context: BreakContext) : Resolvable, BreakResult() {
+        override val rank = Rank.BREAK_SUCCESS
+
+        override val resolve = buildChain {
+            breakBlock(context.hitPos)
+        }
+
+        override fun compareTo(other: ComparableResult<Rank>): Int {
+            return when (other) {
+                is Success -> context.compareTo(other.context)
+                else -> super.compareTo(other)
+            }
+        }
+    }
+}

common/src/main/kotlin/com/lambda/interaction/construction/result/BuildResult.kt

@@ -0,0 +1,18 @@
+package com.lambda.interaction.construction.result
+
+abstract class BuildResult : ComparableResult<Rank> {
+
+    /**
+     * The build action is done.
+     */
+    data object Done : BuildResult() {
+        override val rank = Rank.DONE
+    }
+
+    /**
+     * The build action is ignored.
+     */
+    data object Ignored : BuildResult() {
+        override val rank = Rank.IGNORED
+    }
+}