1.21.3 WIP

1 files changed, 269 insertions, 426 deletions

diff --git a/src/main/kotlin/gui/entity/FakeWorld.kt b/src/main/kotlin/gui/entity/FakeWorld.kt
index f354d5a..c17f2ad 100644
--- a/src/main/kotlin/gui/entity/FakeWorld.kt
+++ b/src/main/kotlin/gui/entity/FakeWorld.kt
@@ -1,35 +1,28 @@
-
 package moe.nea.firmament.gui.entity
 
-import com.mojang.datafixers.util.Pair
-import com.mojang.serialization.Lifecycle
-import java.util.*
+import java.util.UUID
 import java.util.function.BooleanSupplier
 import java.util.function.Consumer
-import java.util.stream.Stream
-import kotlin.jvm.optionals.getOrNull
-import kotlin.streams.asSequence
 import net.minecraft.block.Block
 import net.minecraft.block.BlockState
 import net.minecraft.component.type.MapIdComponent
 import net.minecraft.entity.Entity
+import net.minecraft.entity.damage.DamageSource
 import net.minecraft.entity.player.PlayerEntity
 import net.minecraft.fluid.Fluid
+import net.minecraft.item.FuelRegistry
 import net.minecraft.item.map.MapState
+import net.minecraft.particle.ParticleEffect
 import net.minecraft.recipe.BrewingRecipeRegistry
-import net.minecraft.recipe.Ingredient
 import net.minecraft.recipe.RecipeManager
-import net.minecraft.registry.BuiltinRegistries
+import net.minecraft.recipe.RecipePropertySet
+import net.minecraft.recipe.StonecuttingRecipe
+import net.minecraft.recipe.display.CuttingRecipeDisplay
 import net.minecraft.registry.DynamicRegistryManager
-import net.minecraft.registry.Registry
+import net.minecraft.registry.Registries
 import net.minecraft.registry.RegistryKey
 import net.minecraft.registry.RegistryKeys
-import net.minecraft.registry.RegistryWrapper
 import net.minecraft.registry.entry.RegistryEntry
-import net.minecraft.registry.entry.RegistryEntryInfo
-import net.minecraft.registry.entry.RegistryEntryList
-import net.minecraft.registry.entry.RegistryEntryOwner
-import net.minecraft.registry.tag.TagKey
 import net.minecraft.resource.featuretoggle.FeatureFlags
 import net.minecraft.resource.featuretoggle.FeatureSet
 import net.minecraft.scoreboard.Scoreboard
@@ -43,11 +36,8 @@ import net.minecraft.util.math.Box
 import net.minecraft.util.math.ChunkPos
 import net.minecraft.util.math.Direction
 import net.minecraft.util.math.Vec3d
-import net.minecraft.util.math.random.Random
-import net.minecraft.util.profiler.DummyProfiler
 import net.minecraft.world.BlockView
 import net.minecraft.world.Difficulty
-import net.minecraft.world.GameRules
 import net.minecraft.world.MutableWorldProperties
 import net.minecraft.world.World
 import net.minecraft.world.biome.Biome
@@ -59,430 +49,283 @@ import net.minecraft.world.chunk.EmptyChunk
 import net.minecraft.world.chunk.light.LightingProvider
 import net.minecraft.world.entity.EntityLookup
 import net.minecraft.world.event.GameEvent
+import net.minecraft.world.explosion.ExplosionBehavior
 import net.minecraft.world.tick.OrderedTick
 import net.minecraft.world.tick.QueryableTickScheduler
 import net.minecraft.world.tick.TickManager
 
-fun <T> makeRegistry(registryWrapper: RegistryWrapper.Impl<T>, key: RegistryKey<out Registry<T>>): Registry<T> {
-    val inverseLookup = registryWrapper.streamEntries()
-        .asSequence().map { it.value() to it.registryKey() }
-        .toMap()
-    val idLookup = registryWrapper.streamEntries()
-        .asSequence()
-        .map { it.registryKey() }
-        .withIndex()
-        .associate { it.value to it.index }
-    val map = registryWrapper.streamEntries().asSequence().map { it.registryKey() to it.value() }.toMap(mutableMapOf())
-    val inverseIdLookup = idLookup.asIterable().associate { (k, v) -> v to k }
-    return object : Registry<T> {
-        override fun get(key: RegistryKey<T>?): T? {
-            return registryWrapper.getOptional(key).getOrNull()?.value()
-        }
-
-        override fun iterator(): MutableIterator<T> {
-            return object : MutableIterator<T> {
-                val iterator = registryWrapper.streamEntries().iterator()
-                override fun hasNext(): Boolean {
-                    return iterator.hasNext()
-                }
-
-                override fun next(): T {
-                    return iterator.next().value()
-                }
-
-                override fun remove() {
-                    TODO("Not yet implemented")
-                }
-            }
-        }
-
-        override fun getRawId(value: T?): Int {
-            return idLookup[inverseLookup[value ?: return -1] ?: return -1] ?: return -1
-        }
-
-        override fun get(id: Identifier?): T? {
-            return get(RegistryKey.of(key, id))
-        }
-
-        override fun get(index: Int): T? {
-            return get(inverseIdLookup[index] ?: return null)
-        }
-
-        override fun size(): Int {
-            return idLookup.size
-        }
-
-        override fun getKey(): RegistryKey<out Registry<T>> {
-            return key
-        }
-
-        override fun getEntryInfo(key: RegistryKey<T>?): Optional<RegistryEntryInfo> {
-            TODO("Not yet implemented")
-        }
-
-        override fun getLifecycle(): Lifecycle {
-            return Lifecycle.stable()
-        }
-
-        override fun getDefaultEntry(): Optional<RegistryEntry.Reference<T>> {
-            return Optional.empty()
-        }
-
-        override fun getIds(): MutableSet<Identifier> {
-            return idLookup.keys.mapTo(mutableSetOf()) { it.value }
-        }
-
-        override fun getEntrySet(): MutableSet<MutableMap.MutableEntry<RegistryKey<T>, T>> {
-            return map.entries
-        }
-
-        override fun getKeys(): MutableSet<RegistryKey<T>> {
-            return map.keys
-        }
-
-        override fun getRandom(random: Random?): Optional<RegistryEntry.Reference<T>> {
-            return registryWrapper.streamEntries().findFirst()
-        }
-
-        override fun containsId(id: Identifier?): Boolean {
-            return idLookup.containsKey(RegistryKey.of(key, id ?: return false))
-        }
-
-        override fun freeze(): Registry<T> {
-            return this
-        }
-
-        override fun getEntry(rawId: Int): Optional<RegistryEntry.Reference<T>> {
-            val x = inverseIdLookup[rawId] ?: return Optional.empty()
-            return Optional.of(RegistryEntry.Reference.standAlone(registryWrapper, x))
-        }
-
-        override fun streamEntries(): Stream<RegistryEntry.Reference<T>> {
-            return registryWrapper.streamEntries()
-        }
-
-        override fun streamTagsAndEntries(): Stream<Pair<TagKey<T>, RegistryEntryList.Named<T>>> {
-            return streamTags().map { Pair(it, getOrCreateEntryList(it)) }
-        }
-
-        override fun streamTags(): Stream<TagKey<T>> {
-            return registryWrapper.streamTagKeys()
-        }
-
-        override fun clearTags() {
-        }
-
-        override fun getEntryOwner(): RegistryEntryOwner<T> {
-            return registryWrapper
-        }
-
-        override fun getReadOnlyWrapper(): RegistryWrapper.Impl<T> {
-            return registryWrapper
-        }
-
-        override fun populateTags(tagEntries: MutableMap<TagKey<T>, MutableList<RegistryEntry<T>>>?) {
-        }
-
-        override fun getOrCreateEntryList(tag: TagKey<T>?): RegistryEntryList.Named<T> {
-            return getEntryList(tag).orElseGet { RegistryEntryList.of(registryWrapper, tag) }
-        }
-
-        override fun getEntryList(tag: TagKey<T>?): Optional<RegistryEntryList.Named<T>> {
-            return registryWrapper.getOptional(tag ?: return Optional.empty())
-        }
-
-        override fun getEntry(value: T): RegistryEntry<T> {
-            return registryWrapper.getOptional(inverseLookup[value]!!).get()
-        }
-
-        override fun getEntry(key: RegistryKey<T>?): Optional<RegistryEntry.Reference<T>> {
-            return registryWrapper.getOptional(key ?: return Optional.empty())
-        }
-
-        override fun getEntry(id: Identifier?): Optional<RegistryEntry.Reference<T>> {
-            TODO("Not yet implemented")
-        }
-
-        override fun createEntry(value: T): RegistryEntry.Reference<T> {
-            TODO("Not yet implemented")
-        }
-
-        override fun contains(key: RegistryKey<T>?): Boolean {
-            return getEntry(key).isPresent
-        }
-
-        override fun getId(value: T): Identifier? {
-            return (inverseLookup[value] ?: return null).value
-        }
-
-        override fun getKey(entry: T): Optional<RegistryKey<T>> {
-            return Optional.ofNullable(inverseLookup[entry ?: return Optional.empty()])
-        }
-    }
-}
-
 fun createDynamicRegistry(): DynamicRegistryManager.Immutable {
-    val wrapperLookup = BuiltinRegistries.createWrapperLookup()
-    return object : DynamicRegistryManager.Immutable {
-        override fun <E : Any?> getOptional(key: RegistryKey<out Registry<out E>>): Optional<Registry<E>> {
-            val lookup = wrapperLookup.getOptionalWrapper(key).getOrNull() ?: return Optional.empty()
-            val registry = makeRegistry(lookup, key as RegistryKey<out Registry<E>>)
-            return Optional.of(registry)
-        }
-
-        fun <T> entry(reg: RegistryKey<out Registry<T>>): DynamicRegistryManager.Entry<T> {
-            return DynamicRegistryManager.Entry(reg, getOptional(reg).get())
-        }
-
-        override fun streamAllRegistries(): Stream<DynamicRegistryManager.Entry<*>> {
-            return wrapperLookup.streamAllRegistryKeys()
-                .map { entry(it as RegistryKey<out Registry<Any>>) }
-        }
-    }
+	return DynamicRegistryManager.of(Registries.REGISTRIES)
 }
 
 class FakeWorld(
-    registries: DynamicRegistryManager.Immutable = createDynamicRegistry(),
+	registries: DynamicRegistryManager.Immutable = createDynamicRegistry(),
 ) : World(
-    Properties,
-    RegistryKey.of(RegistryKeys.WORLD, Identifier.of("firmament", "fakeworld")),
-    registries,
-    registries[RegistryKeys.DIMENSION_TYPE].entryOf(
-        RegistryKey.of(
-            RegistryKeys.DIMENSION_TYPE,
-            Identifier.of("minecraft", "overworld")
-        )
-    ),
-    { DummyProfiler.INSTANCE },
-    true,
-    false,
-    0, 0
+	Properties,
+	RegistryKey.of(RegistryKeys.WORLD, Identifier.of("firmament", "fakeworld")),
+	registries,
+	registries.getOrThrow(RegistryKeys.DIMENSION_TYPE).getEntry(
+		Identifier.of("minecraft", "overworld")
+	).get(),
+	true,
+	false,
+	0L,
+	0
 ) {
-    object Properties : MutableWorldProperties {
-        override fun getSpawnPos(): BlockPos {
-            return BlockPos.ORIGIN
-        }
+	object Properties : MutableWorldProperties {
+		override fun getSpawnPos(): BlockPos {
+			return BlockPos.ORIGIN
+		}
 
-        override fun getSpawnAngle(): Float {
-            return 0F
-        }
+		override fun getSpawnAngle(): Float {
+			return 0F
+		}
 
-        override fun getTime(): Long {
-            return 0
-        }
+		override fun getTime(): Long {
+			return 0
+		}
 
-        override fun getTimeOfDay(): Long {
-            return 0
-        }
+		override fun getTimeOfDay(): Long {
+			return 0
+		}
 
-        override fun isThundering(): Boolean {
-            return false
-        }
+		override fun isThundering(): Boolean {
+			return false
+		}
 
-        override fun isRaining(): Boolean {
-            return false
-        }
+		override fun isRaining(): Boolean {
+			return false
+		}
 
-        override fun setRaining(raining: Boolean) {
-        }
+		override fun setRaining(raining: Boolean) {
+		}
 
-        override fun isHardcore(): Boolean {
-            return false
-        }
-
-        override fun getGameRules(): GameRules {
-            return GameRules()
-        }
-
-        override fun getDifficulty(): Difficulty {
-            return Difficulty.HARD
-        }
-
-        override fun isDifficultyLocked(): Boolean {
-            return false
-        }
-
-        override fun setSpawnPos(pos: BlockPos?, angle: Float) {}
-    }
+		override fun isHardcore(): Boolean {
+			return false
+		}
+
+		override fun getDifficulty(): Difficulty {
+			return Difficulty.HARD
+		}
+
+		override fun isDifficultyLocked(): Boolean {
+			return false
+		}
+
+		override fun setSpawnPos(pos: BlockPos?, angle: Float) {}
+	}
+
+	override fun getPlayers(): List<PlayerEntity> {
+		return emptyList()
+	}
 
-    override fun getPlayers(): List<PlayerEntity> {
-        return emptyList()
-    }
-
-    override fun getBrightness(direction: Direction?, shaded: Boolean): Float {
-        return 1f
-    }
-
-    override fun getGeneratorStoredBiome(biomeX: Int, biomeY: Int, biomeZ: Int): RegistryEntry<Biome> {
-        return registryManager.get(RegistryKeys.BIOME).entryOf(BiomeKeys.PLAINS)
-    }
-
-    override fun getEnabledFeatures(): FeatureSet {
-        return FeatureFlags.VANILLA_FEATURES
-    }
-
-    class FakeTickScheduler<T> : QueryableTickScheduler<T> {
-        override fun scheduleTick(orderedTick: OrderedTick<T>?) {
-        }
-
-        override fun isQueued(pos: BlockPos?, type: T): Boolean {
-            return true
-        }
-
-        override fun getTickCount(): Int {
-            return 0
-        }
-
-        override fun isTicking(pos: BlockPos?, type: T): Boolean {
-            return true
-        }
-
-    }
-
-    override fun getBlockTickScheduler(): QueryableTickScheduler<Block> {
-        return FakeTickScheduler()
-    }
-
-    override fun getFluidTickScheduler(): QueryableTickScheduler<Fluid> {
-        return FakeTickScheduler()
-    }
-
-
-    class FakeChunkManager(val world: FakeWorld) : ChunkManager() {
-        override fun getChunk(x: Int, z: Int, leastStatus: ChunkStatus?, create: Boolean): Chunk {
-            return EmptyChunk(
-                world,
-                ChunkPos(x, z),
-                world.registryManager.get(RegistryKeys.BIOME).entryOf(BiomeKeys.PLAINS)
-            )
-        }
-
-        override fun getWorld(): BlockView {
-            return world
-        }
-
-        override fun tick(shouldKeepTicking: BooleanSupplier?, tickChunks: Boolean) {
-        }
-
-        override fun getDebugString(): String {
-            return "FakeChunkManager"
-        }
-
-        override fun getLoadedChunkCount(): Int {
-            return 0
-        }
-
-        override fun getLightingProvider(): LightingProvider {
-            return FakeLightingProvider(this)
-        }
-    }
-
-    class FakeLightingProvider(chunkManager: FakeChunkManager) : LightingProvider(chunkManager, false, false)
-
-    override fun getChunkManager(): ChunkManager {
-        return FakeChunkManager(this)
-    }
-
-    override fun playSound(
-        source: PlayerEntity?,
-        x: Double,
-        y: Double,
-        z: Double,
-        sound: RegistryEntry<SoundEvent>?,
-        category: SoundCategory?,
-        volume: Float,
-        pitch: Float,
-        seed: Long
-    ) {
-    }
-
-    override fun syncWorldEvent(player: PlayerEntity?, eventId: Int, pos: BlockPos?, data: Int) {
-    }
-
-    override fun emitGameEvent(event: RegistryEntry<GameEvent>?, emitterPos: Vec3d?, emitter: GameEvent.Emitter?) {
-    }
-
-    override fun updateListeners(pos: BlockPos?, oldState: BlockState?, newState: BlockState?, flags: Int) {
-    }
-
-    override fun playSoundFromEntity(
-        source: PlayerEntity?,
-        entity: Entity?,
-        sound: RegistryEntry<SoundEvent>?,
-        category: SoundCategory?,
-        volume: Float,
-        pitch: Float,
-        seed: Long
-    ) {
-    }
-
-    override fun asString(): String {
-        return "FakeWorld"
-    }
-
-    override fun getEntityById(id: Int): Entity? {
-        return null
-    }
-
-    override fun getTickManager(): TickManager {
-        return TickManager()
-    }
-
-    override fun getMapState(id: MapIdComponent?): MapState? {
-        return null
-    }
-
-    override fun putMapState(id: MapIdComponent?, state: MapState?) {
-    }
-
-    override fun increaseAndGetMapId(): MapIdComponent {
-        return MapIdComponent(0)
-    }
-
-    override fun setBlockBreakingInfo(entityId: Int, pos: BlockPos?, progress: Int) {
-    }
-
-    override fun getScoreboard(): Scoreboard {
-        return Scoreboard()
-    }
-
-    override fun getRecipeManager(): RecipeManager {
-        return RecipeManager(registryManager)
-    }
-
-    object FakeEntityLookup : EntityLookup<Entity> {
-        override fun get(id: Int): Entity? {
-            return null
-        }
-
-        override fun get(uuid: UUID?): Entity? {
-            return null
-        }
-
-        override fun iterate(): MutableIterable<Entity> {
-            return mutableListOf()
-        }
-
-        override fun <U : Entity?> forEachIntersects(
-            filter: TypeFilter<Entity, U>?,
-            box: Box?,
-            consumer: LazyIterationConsumer<U>?
-        ) {
-        }
-
-        override fun forEachIntersects(box: Box?, action: Consumer<Entity>?) {
-        }
-
-        override fun <U : Entity?> forEach(filter: TypeFilter<Entity, U>?, consumer: LazyIterationConsumer<U>?) {
-        }
-
-    }
-
-    override fun getEntityLookup(): EntityLookup<Entity> {
-        return FakeEntityLookup
-    }
-
-    override fun getBrewingRecipeRegistry(): BrewingRecipeRegistry {
-        return BrewingRecipeRegistry.EMPTY
-    }
+	override fun getBrightness(direction: Direction?, shaded: Boolean): Float {
+		return 1f
+	}
+
+	override fun getGeneratorStoredBiome(biomeX: Int, biomeY: Int, biomeZ: Int): RegistryEntry<Biome> {
+		return registryManager.getOptionalEntry(BiomeKeys.PLAINS).get()
+	}
+
+	override fun getSeaLevel(): Int {
+		return 0
+	}
+
+	override fun getEnabledFeatures(): FeatureSet {
+		return FeatureFlags.VANILLA_FEATURES
+	}
+
+	class FakeTickScheduler<T> : QueryableTickScheduler<T> {
+		override fun scheduleTick(orderedTick: OrderedTick<T>?) {
+		}
+
+		override fun isQueued(pos: BlockPos?, type: T): Boolean {
+			return true
+		}
+
+		override fun getTickCount(): Int {
+			return 0
+		}
+
+		override fun isTicking(pos: BlockPos?, type: T): Boolean {
+			return true
+		}
+
+	}
+
+	override fun getBlockTickScheduler(): QueryableTickScheduler<Block> {
+		return FakeTickScheduler()
+	}
+
+	override fun getFluidTickScheduler(): QueryableTickScheduler<Fluid> {
+		return FakeTickScheduler()
+	}
+
+
+	class FakeChunkManager(val world: FakeWorld) : ChunkManager() {
+		override fun getChunk(x: Int, z: Int, leastStatus: ChunkStatus?, create: Boolean): Chunk {
+			return EmptyChunk(
+				world,
+				ChunkPos(x, z),
+				world.registryManager.getOptionalEntry(BiomeKeys.PLAINS).get()
+			)
+		}
+
+		override fun getWorld(): BlockView {
+			return world
+		}
+
+		override fun tick(shouldKeepTicking: BooleanSupplier?, tickChunks: Boolean) {
+		}
+
+		override fun getDebugString(): String {
+			return "FakeChunkManager"
+		}
+
+		override fun getLoadedChunkCount(): Int {
+			return 0
+		}
+
+		override fun getLightingProvider(): LightingProvider {
+			return FakeLightingProvider(this)
+		}
+	}
+
+	class FakeLightingProvider(chunkManager: FakeChunkManager) : LightingProvider(chunkManager, false, false)
+
+	override fun getChunkManager(): ChunkManager {
+		return FakeChunkManager(this)
+	}
+
+	override fun playSound(
+		source: PlayerEntity?,
+		x: Double,
+		y: Double,
+		z: Double,
+		sound: RegistryEntry<SoundEvent>?,
+		category: SoundCategory?,
+		volume: Float,
+		pitch: Float,
+		seed: Long
+	) {
+	}
+
+	override fun syncWorldEvent(player: PlayerEntity?, eventId: Int, pos: BlockPos?, data: Int) {
+	}
+
+	override fun emitGameEvent(event: RegistryEntry<GameEvent>?, emitterPos: Vec3d?, emitter: GameEvent.Emitter?) {
+	}
+
+	override fun updateListeners(pos: BlockPos?, oldState: BlockState?, newState: BlockState?, flags: Int) {
+	}
+
+	override fun playSoundFromEntity(
+		source: PlayerEntity?,
+		entity: Entity?,
+		sound: RegistryEntry<SoundEvent>?,
+		category: SoundCategory?,
+		volume: Float,
+		pitch: Float,
+		seed: Long
+	) {
+	}
+
+	override fun createExplosion(
+		entity: Entity?,
+		damageSource: DamageSource?,
+		behavior: ExplosionBehavior?,
+		x: Double,
+		y: Double,
+		z: Double,
+		power: Float,
+		createFire: Boolean,
+		explosionSourceType: ExplosionSourceType?,
+		smallParticle: ParticleEffect?,
+		largeParticle: ParticleEffect?,
+		soundEvent: RegistryEntry<SoundEvent>?
+	) {
+		TODO("Not yet implemented")
+	}
+
+	override fun asString(): String {
+		return "FakeWorld"
+	}
+
+	override fun getEntityById(id: Int): Entity? {
+		return null
+	}
+
+	override fun getTickManager(): TickManager {
+		return TickManager()
+	}
+
+	override fun getMapState(id: MapIdComponent?): MapState? {
+		return null
+	}
+
+	override fun putMapState(id: MapIdComponent?, state: MapState?) {
+	}
+
+	override fun increaseAndGetMapId(): MapIdComponent {
+		return MapIdComponent(0)
+	}
+
+	override fun setBlockBreakingInfo(entityId: Int, pos: BlockPos?, progress: Int) {
+	}
+
+	override fun getScoreboard(): Scoreboard {
+		return Scoreboard()
+	}
+
+	override fun getRecipeManager(): RecipeManager {
+		return object : RecipeManager {
+			override fun getPropertySet(key: RegistryKey<RecipePropertySet>?): RecipePropertySet {
+				return RecipePropertySet.EMPTY
+			}
+
+			override fun getStonecutterRecipes(): CuttingRecipeDisplay.Grouping<StonecuttingRecipe> {
+				return CuttingRecipeDisplay.Grouping.empty()
+			}
+		}
+	}
+
+	object FakeEntityLookup : EntityLookup<Entity> {
+		override fun get(id: Int): Entity? {
+			return null
+		}
+
+		override fun get(uuid: UUID?): Entity? {
+			return null
+		}
+
+		override fun iterate(): MutableIterable<Entity> {
+			return mutableListOf()
+		}
+
+		override fun <U : Entity?> forEachIntersects(
+			filter: TypeFilter<Entity, U>?,
+			box: Box?,
+			consumer: LazyIterationConsumer<U>?
+		) {
+		}
+
+		override fun forEachIntersects(box: Box?, action: Consumer<Entity>?) {
+		}
+
+		override fun <U : Entity?> forEach(filter: TypeFilter<Entity, U>?, consumer: LazyIterationConsumer<U>?) {
+		}
+
+	}
+
+	override fun getEntityLookup(): EntityLookup<Entity> {
+		return FakeEntityLookup
+	}
+
+	override fun getBrewingRecipeRegistry(): BrewingRecipeRegistry {
+		return BrewingRecipeRegistry.EMPTY
+	}
+
+	override fun getFuelRegistry(): FuelRegistry {
+		TODO("Not yet implemented")
+	}
 }