refactor!: convert Site-63 to Structure (Part 1)

Author: xtexx

src/main/kotlin/scpsharp/content/facility/FacilityGenerator.kt

@@ -0,0 +1,68 @@
+package scpsharp.content.facility
+
+import net.minecraft.registry.Registries
+import net.minecraft.registry.tag.TagKey
+import net.minecraft.structure.StructurePiece
+import net.minecraft.structure.StructurePieceType
+import net.minecraft.structure.StructurePiecesCollector
+import net.minecraft.structure.StructurePiecesHolder
+import net.minecraft.util.math.BlockBox
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Direction
+import net.minecraft.world.gen.structure.Structure
+import kotlin.jvm.optionals.getOrNull
+
+class FacilityGenerator(val ctx: Structure.Context) : StructurePiecesHolder {
+
+    val pieces = StackAllocator<StructurePiece> { a, b -> a.boundingBox.intersects(b.boundingBox) }
+    val depth by pieces::depth
+
+    inline fun piece(crossinline content: FacilityGenerator.() -> Boolean): Boolean {
+        pieces.push()
+        return try {
+            if (content()) {
+                pieces.squash()
+                true
+            } else {
+                pieces.drop()
+                false
+            }
+        } catch (e: Throwable) {
+            pieces.drop()
+            false
+        }
+    }
+
+    fun add(piece: StructurePiece) = pieces.tryAllocate(piece)
+
+    override fun addPiece(piece: StructurePiece) {
+        pieces.allocate(piece)
+    }
+
+    override fun getIntersecting(box: BlockBox) = pieces.find { it.boundingBox.intersects(box) }
+
+    fun collect(collector: StructurePiecesCollector) {
+        pieces.freeze()
+        check(depth == 1) { "Trying to collect structure pieces when there are more than one layers" }
+        val piecesIter = pieces.iterator()
+        check(piecesIter.hasNext()) { "Nothing to collect" }
+        piecesIter.forEach { collector.addPiece(it) }
+    }
+
+    fun random(tag: TagKey<StructurePieceType>, pos: BlockPos, direction: Direction) =
+        Registries.STRUCTURE_PIECE.getOrCreateEntryList(tag)
+            .toList()
+            .run {
+                if (isEmpty()) error("Nothing registered in $tag")
+                val randomEntry = elementAt(ctx.random.nextInt(size))!!
+                val random = randomEntry.keyOrValue
+                val value = random.left().getOrNull()?.value?.let { Registries.STRUCTURE_PIECE.get(it) }
+                    ?: random.right().get()
+                if (value is FacilityStructurePiece.Type) {
+                    value.invoke(this@FacilityGenerator, pos, direction)
+                } else {
+                    error("$tag registered $randomEntry but is SCP# incompatible structure pieces")
+                }
+            }
+
+}

src/main/kotlin/scpsharp/content/facility/FacilityStructure.kt

@@ -0,0 +1,40 @@
+package scpsharp.content.facility
+
+import com.mojang.datafixers.util.Either
+import net.minecraft.structure.StructurePiecesCollector
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Direction
+import net.minecraft.world.Heightmap
+import net.minecraft.world.gen.structure.Structure
+import java.util.*
+
+abstract class FacilityStructure(config: Config) : Structure(config) {
+
+    companion object {
+
+        @JvmStatic
+        protected fun getStructurePosition(
+            ctx: Context,
+            heightmap: Heightmap.Type = Heightmap.Type.WORLD_SURFACE_WG,
+            generator: FacilityGenerator.(pos: BlockPos, direction: Direction) -> Boolean
+        ): Optional<StructurePosition> {
+            val chunkPos = ctx.chunkPos()
+            val y = ctx.chunkGenerator()
+                .getHeightInGround(
+                    chunkPos.centerX, chunkPos.centerZ, heightmap,
+                    ctx.world(), ctx.noiseConfig()
+                )
+            val pos = BlockPos(chunkPos.centerX, y, chunkPos.centerZ)
+            val collector = StructurePiecesCollector()
+            val generatorContext = FacilityGenerator(ctx)
+            return if (generatorContext.generator(pos, Direction.random(ctx.random))) {
+                generatorContext.collect(collector)
+                Optional.of(StructurePosition(pos, Either.right(collector)))
+            } else {
+                Optional.empty()
+            }
+        }
+
+    }
+
+}

src/main/kotlin/scpsharp/content/facility/FacilityStructurePiece.kt

@@ -0,0 +1,41 @@
+package scpsharp.content.facility
+
+import net.minecraft.nbt.NbtCompound
+import net.minecraft.structure.StructureContext
+import net.minecraft.structure.StructurePiece
+import net.minecraft.structure.StructurePieceType
+import net.minecraft.util.math.BlockBox
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.ChunkPos
+import net.minecraft.util.math.Direction
+import net.minecraft.util.math.random.Random
+import net.minecraft.world.StructureWorldAccess
+import net.minecraft.world.gen.StructureAccessor
+import net.minecraft.world.gen.chunk.ChunkGenerator
+
+abstract class FacilityStructurePiece : StructurePiece {
+
+    constructor(type: StructurePieceType, length: Int, boundingBox: BlockBox) : super(type, length, boundingBox)
+    constructor(type: StructurePieceType, nbt: NbtCompound) : super(type, nbt)
+
+    abstract override fun writeNbt(context: StructureContext, nbt: NbtCompound)
+
+    abstract override fun generate(
+        world: StructureWorldAccess,
+        structureAccessor: StructureAccessor,
+        chunkGenerator: ChunkGenerator,
+        random: Random,
+        chunkBox: BlockBox,
+        chunkPos: ChunkPos,
+        pivot: BlockPos
+    )
+
+    interface Type : StructurePieceType {
+
+        override fun load(context: StructureContext, nbt: NbtCompound): StructurePiece
+
+        operator fun invoke(generator: FacilityGenerator, pos: BlockPos, direction: Direction): Boolean
+
+    }
+
+}

src/main/kotlin/scpsharp/content/facility/FacilityTags.kt

@@ -0,0 +1,19 @@
+package scpsharp.content.facility
+
+import net.minecraft.block.Block
+import net.minecraft.registry.Registries
+import net.minecraft.registry.RegistryKeys
+import net.minecraft.registry.tag.TagKey
+import scpsharp.util.id
+
+object FacilityTags {
+
+    val FACILITY_KEEP: TagKey<Block> = TagKey.of(Registries.BLOCK.key, id("facility_keep"))
+
+    val START = TagKey.of(RegistryKeys.STRUCTURE_PIECE, id("facility/start"))!!
+    val PART = TagKey.of(RegistryKeys.STRUCTURE_PIECE, id("facility/part"))!!
+    val CONTAINMENT_ROOM = TagKey.of(RegistryKeys.STRUCTURE_PIECE, id("facility/containment_room"))!!
+    val CORRIDOR = TagKey.of(RegistryKeys.STRUCTURE_PIECE, id("facility/corridor"))!!
+    val CROSSING = TagKey.of(RegistryKeys.STRUCTURE_PIECE, id("facility/crossing"))!!
+
+}

src/main/kotlin/scpsharp/content/facility/StackAllocator.kt

@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2023  SCPSharp Team
+ *
+ * This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License. See LICENSE file for more.
+ */
+package scpsharp.content.facility
+
+import java.util.*
+
+class StackAllocator<T>(val conflictMatcher: (T, T) -> Boolean) : Iterable<T> {
+
+    private val layers = Stack<MutableSet<T>>()
+
+    @Transient
+    var frozen = false
+        private set
+    val active get() = !frozen
+
+    init {
+        push()
+    }
+
+    val topLayer get() = layers.peek()!!
+    val depth get() = layers.size
+
+    private fun checkActive() {
+        check(!frozen) { "Trying to operate a frozen SpaceAllocator" }
+    }
+
+    fun freeze() {
+        checkActive()
+        frozen = true
+    }
+
+    fun push() {
+        checkActive()
+        layers.push(mutableSetOf())
+    }
+
+    fun drop() {
+        checkActive()
+        check(layers.size > 1) { "Could not drop the last layer" }
+        layers.pop()
+    }
+
+    fun squash() {
+        checkActive()
+        check(layers.size > 1) { "Could not squash the last layer" }
+        val elements = layers.pop()!!
+        topLayer += elements
+    }
+
+    fun allocate(value: T) {
+        check(tryAllocate(value)) { "Failed to allocate $value" }
+    }
+
+    fun tryAllocate(value: T): Boolean {
+        checkActive()
+        if (layers.any { layer -> layer.any { conflictMatcher(value, it) } }) {
+            return false
+        }
+        return topLayer.add(value)
+    }
+
+    fun release(value: T) {
+        checkActive()
+        check(topLayer.remove(value)) { error("Element is not allocated on the top layer: $value") }
+    }
+
+    override fun iterator() = object : Iterator<T> {
+        val layersIter = layers.iterator()
+        var elementIter: Iterator<T>? = null
+
+        private fun seekToNext() {
+            while (elementIter?.hasNext() != true) {
+                if (layersIter.hasNext()) {
+                    elementIter = layersIter.next()!!.iterator()
+                } else {
+                    break
+                }
+            }
+        }
+
+        override fun hasNext(): Boolean {
+            seekToNext()
+            return elementIter?.hasNext() ?: false
+        }
+
+        override fun next(): T {
+            seekToNext()
+            return elementIter!!.next()
+        }
+    }
+
+}