Adds extensions for registration

buildSrc/src/main/kotlin/BuildConstants.kt

@@ -20,11 +20,12 @@ object BuildConstants {
     const val paperMinecraftVersion = "1.21.1"
     const val fabricLoaderVersion = "0.16.10"
     const val fabricLanguageKotlinVersion = "1.12.3+kotlin.2.0.21"
+    const val fabricApiVersion = "0.115.0+$minecraftVersion"
 
     const val kotestVersion = "5.9.1"
     const val mockkVersion = "1.13.12"
 
-    val uploadModules = listOf(
+    val commonModules = listOf(
         "commands",
         "core",
         "game",
@@ -33,4 +34,8 @@ object BuildConstants {
         "network",
         "persistence",
     )
+    val uploadModules = commonModules + listOf(
+        "paper",
+        "fabric"
+    )
 }

buildSrc/src/main/kotlin/kotlin-project-script.gradle.kts

@@ -29,7 +29,7 @@ kotlin {
 
     sourceSets.all {
         languageSettings {
-            val whitelistModules = BuildConstants.uploadModules.plus("paper")
+            val whitelistModules = BuildConstants.uploadModules
             if (project.name.removePrefix(rootProject.name + "-") in whitelistModules) {
                 listOf("InternalSilkApi", "DelicateSilkApi", "ExperimentalSilkApi").forEach {
                     optIn("net.silkmc.silk.core.annotations.${it}")

settings.gradle.kts

@@ -20,5 +20,6 @@ include("$projectName-network")
 include("$projectName-persistence")
 
 include("$projectName-paper")
+include("$projectName-fabric")
 
 include("$projectName-testmod")

silk-all/build.gradle.kts

@@ -7,9 +7,10 @@ plugins {
 }
 
 dependencies {
-    BuildConstants.uploadModules.forEach {
+    BuildConstants.commonModules.forEach {
         implementation(include(project(":${rootProject.name}-${it}"))!!)
     }
+    implementation(include(modProject(":${rootProject.name}-fabric"))!!)
 }
 
 val modName by extra("$projectTitle (All modules)")

silk-fabric/build.gradle.kts

@@ -0,0 +1,18 @@
+import BuildConstants.fabricApiVersion
+import BuildConstants.projectTitle
+
+description = "Silk Core provides a simple and stable Kotlin API for working with Minecraft"
+
+plugins {
+    `kotlin-project-script`
+    `mod-build-script`
+    `project-publish-script`
+    `kotest-script`
+    `dokka-script`
+}
+
+dependencies {
+    modApi("net.fabricmc.fabric-api:fabric-api:$fabricApiVersion")
+}
+
+val modName by extra("$projectTitle Fabric")

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/client/KeyMappingExtensions.kt

@@ -0,0 +1,13 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.client
+
+import com.mojang.blaze3d.platform.InputConstants
+import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper
+import net.minecraft.client.KeyMapping
+
+fun keyMappingOf(translationKey: String, type: InputConstants.Type = InputConstants.Type.KEYSYM, code: Int, category: String): KeyMapping {
+    return KeyBindingHelper.registerKeyBinding(KeyMapping(translationKey, type, code, category))
+}
+
+fun KeyMapping.asKey(): InputConstants.Key = KeyBindingHelper.getBoundKeyOf(this)

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/registry/ArmorMaterialRegistry.kt

@@ -0,0 +1,44 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.registry
+
+import net.minecraft.core.Holder
+import net.minecraft.resources.ResourceKey
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.sounds.SoundEvent
+import net.minecraft.tags.TagKey
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.equipment.ArmorMaterial
+import net.minecraft.world.item.equipment.ArmorType
+import net.minecraft.world.item.equipment.EquipmentAsset
+import net.minecraft.world.item.equipment.EquipmentAssets
+
+fun armorMaterialOf(
+    baseDurability: Int,
+    defensePoints: Map<ArmorType, Int>,
+    enchantability: Int,
+    equipSound: Holder<SoundEvent>,
+    toughness: Float,
+    knockbackResistance: Float,
+    repairIngredient: TagKey<Item>,
+    layers: ResourceKey<EquipmentAsset>,
+): ArmorMaterial {
+    return ArmorMaterial(
+        baseDurability,
+        defensePoints,
+        enchantability,
+        equipSound,
+        toughness,
+        knockbackResistance,
+        repairIngredient,
+        layers,
+    )
+}
+
+fun armorMaterialKeyOf(id: ResourceLocation): ResourceKey<EquipmentAsset> = resourceKeyOf(EquipmentAssets.ROOT_ID, id)
+
+fun armorMaterialKeyOf(id: String): ResourceKey<EquipmentAsset> = armorMaterialKeyOf(ResourceLocation.parse(id))
+
+fun armorMaterialKeyOf(namespace: String, path: String): ResourceKey<EquipmentAsset> {
+    return armorMaterialKeyOf(ResourceLocation.fromNamespaceAndPath(namespace, path))
+}

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/registry/BlockEntityRegistry.kt

@@ -0,0 +1,26 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.registry
+
+import net.fabricmc.fabric.api.`object`.builder.v1.block.entity.FabricBlockEntityTypeBuilder
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.entity.BlockEntityType
+
+fun <T : BlockEntity> blockEntityTypeOf(
+    vararg blocks: Block,
+    factory: FabricBlockEntityTypeBuilder.Factory<out T>,
+): BlockEntityType<T> {
+    return FabricBlockEntityTypeBuilder.create(factory, *blocks).build()
+}
+
+fun <T : BlockEntityType<V>, V> T.register(id: ResourceLocation): T {
+    return BuiltInRegistries.BLOCK_ENTITY_TYPE.register(id, this)
+}
+
+fun <T : BlockEntityType<V>, V> T.register(id: String): T {
+    return BuiltInRegistries.BLOCK_ENTITY_TYPE.register(id, this)
+}
+

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/registry/BlockRegistry.kt

@@ -0,0 +1,32 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.registry
+
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.state.BlockBehaviour
+
+
+inline fun blockPropertiesOf(
+    copiedBlock: BlockBehaviour? = null,
+    builder: BlockBehaviour.Properties.() -> Unit,
+): BlockBehaviour.Properties {
+    return if (copiedBlock != null)
+        BlockBehaviour.Properties.ofFullCopy(copiedBlock).apply(builder)
+    else
+        BlockBehaviour.Properties.of().apply(builder)
+}
+
+fun <T : Block> T.register(id: ResourceLocation): T {
+    for (blockState in stateDefinition.possibleStates) {
+        Block.BLOCK_STATE_REGISTRY.add(blockState)
+        blockState.initCache()
+    }
+
+    return BuiltInRegistries.BLOCK.register(id, this)
+}
+
+fun <T : Block> T.register(id: String): T {
+    return BuiltInRegistries.BLOCK.register(id, this)
+}

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/registry/CreativeModeTabRegistry.kt

@@ -0,0 +1,33 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.registry
+
+import net.fabricmc.fabric.api.itemgroup.v1.FabricItemGroup
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.network.chat.Component
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.item.CreativeModeTab
+import net.minecraft.world.item.ItemStack
+
+fun creativeModeTabOf(
+    displayName: Component? = null,
+    icon: ItemStack? = null,
+    builder: CreativeModeTab.Builder.() -> Unit,
+): CreativeModeTab {
+    val itemGroupBuilder = FabricItemGroup.builder()
+    if (displayName != null)
+        itemGroupBuilder.title(displayName)
+
+    if (icon != null)
+        itemGroupBuilder.icon { icon }
+
+    return itemGroupBuilder.apply(builder).build()
+}
+
+fun <T : CreativeModeTab> T.register(id: ResourceLocation): T {
+    return BuiltInRegistries.CREATIVE_MODE_TAB.register(id, this)
+}
+
+fun <T : CreativeModeTab> T.register(id: String): T {
+    return BuiltInRegistries.CREATIVE_MODE_TAB.register(id, this)
+}

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/registry/CriterionRegistry.kt

@@ -0,0 +1,11 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.registry
+
+import net.minecraft.advancements.CriterionTrigger
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.resources.ResourceLocation
+
+fun <T : CriterionTrigger<*>> T.register(id: ResourceLocation): T = BuiltInRegistries.TRIGGER_TYPES.register(id, this)
+fun <T : CriterionTrigger<*>> T.register(id: String): T = BuiltInRegistries.TRIGGER_TYPES.register(id, this)
+

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/registry/DataComponentRegistry.kt

@@ -0,0 +1,14 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.registry
+
+import net.minecraft.core.component.DataComponentType
+import kotlin.experimental.ExperimentalTypeInference
+
+
+@OptIn(ExperimentalTypeInference::class)
+fun <T> dataComponentTypeOf(@BuilderInference builder: DataComponentType.Builder<T>.() -> Unit): DataComponentType<T> {
+    val dataComponentTypeBuilder = DataComponentType.builder<T>()
+
+    return dataComponentTypeBuilder.apply(builder).build()
+}

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/registry/EntityTypeRegistry.kt

@@ -0,0 +1,29 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.registry
+
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.core.registries.Registries
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.EntityType
+import net.minecraft.world.entity.MobCategory
+
+fun <T : Entity> entityTypeOf(
+    id: ResourceLocation,
+    category: MobCategory,
+    factory: EntityType.EntityFactory<T>,
+    builder: EntityType.Builder<T>.() -> Unit,
+): EntityType<T> {
+    val entityTypeBuilder = EntityType.Builder.of(factory, category)
+
+    return entityTypeBuilder.apply(builder).build(resourceKeyOf(Registries.ENTITY_TYPE, id))
+}
+
+fun <T : Entity> EntityType<T>.register(id: ResourceLocation): EntityType<T> {
+    return BuiltInRegistries.ENTITY_TYPE.register(id, this)
+}
+
+fun <T : Entity> EntityType<T>.register(id: String): EntityType<T> {
+    return BuiltInRegistries.ENTITY_TYPE.register(id, this)
+}

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/registry/FluidRegistry.kt

@@ -0,0 +1,10 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.registry
+
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.level.material.Fluid
+
+fun <T : Fluid> T.register(id: ResourceLocation): T = BuiltInRegistries.FLUID.register(id, this)
+fun <T : Fluid> T.register(id: String): T = BuiltInRegistries.FLUID.register(id, this)

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/registry/GameRuleRegistry.kt

@@ -0,0 +1,63 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.registry
+
+import net.fabricmc.fabric.api.gamerule.v1.CustomGameRuleCategory
+import net.fabricmc.fabric.api.gamerule.v1.GameRuleFactory
+import net.fabricmc.fabric.api.gamerule.v1.GameRuleRegistry
+import net.fabricmc.fabric.api.gamerule.v1.rule.DoubleRule
+import net.fabricmc.fabric.api.gamerule.v1.rule.EnumRule
+import net.minecraft.network.chat.Component
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.MinecraftServer
+import net.minecraft.world.level.GameRules
+import kotlin.enums.enumEntries
+
+fun <T : GameRules.Value<T>> gameruleOf(name: String, category: GameRules.Category, type: GameRules.Type<T>): GameRules.Key<T> {
+    return GameRuleRegistry.register(name, category, type)
+}
+
+fun <T : GameRules.Value<T>> gameruleOf(name: String, category: CustomGameRuleCategory, type: GameRules.Type<T>): GameRules.Key<T> {
+    return GameRuleRegistry.register(name, category, type)
+}
+
+fun gameruleCategoryOf(id: ResourceLocation, name: Component): CustomGameRuleCategory {
+    return CustomGameRuleCategory(id, name)
+}
+
+fun gameruleCategoryOf(id: String, name: Component): CustomGameRuleCategory {
+    return CustomGameRuleCategory(ResourceLocation.parse(id), name)
+}
+
+fun booleanGamerule(
+    default: Boolean,
+    callback: (MinecraftServer, GameRules.BooleanValue) -> Unit = { _, _ -> },
+): GameRules.Type<GameRules.BooleanValue> {
+    return GameRuleFactory.createBooleanRule(default, callback)
+}
+
+fun intGamerule(
+    default: Int,
+    min: Int = Int.MIN_VALUE,
+    max: Int = Int.MAX_VALUE,
+    callback: (MinecraftServer, GameRules.IntegerValue) -> Unit = { _, _ -> },
+): GameRules.Type<GameRules.IntegerValue> {
+    return GameRuleFactory.createIntRule(default, min, max, callback)
+}
+
+fun doubleGamerule(
+    default: Double,
+    min: Double = Double.MIN_VALUE,
+    max: Double = Double.MAX_VALUE,
+    callback: (MinecraftServer, DoubleRule) -> Unit = { _, _ -> },
+): GameRules.Type<DoubleRule> {
+    return GameRuleFactory.createDoubleRule(default, min, max, callback)
+}
+
+inline fun <reified E : Enum<E>> createEnumRule(
+    default: E,
+    values: List<E> = enumEntries<E>(),
+    noinline callback: (MinecraftServer, EnumRule<E>) -> Unit = { _, _ -> },
+): GameRules.Type<EnumRule<E>> {
+    return GameRuleFactory.createEnumRule(default, values.toTypedArray(), callback)
+}

silk-fabric/src/main/kotlin/net/silkmc/silk/fabric/registry/HolderExtensions.kt

@@ -0,0 +1,11 @@
+@file:Suppress("unused")
+
+package net.silkmc.silk.fabric.registry
+
+import net.minecraft.core.Holder
+
+fun <T : Any> T.asHolder(): Holder<T> = Holder.direct(this)
+
+val <T> Holder<T>.value: T
+    get() = value()
+