BlockItem объекты вместо Block

[GoogleTan]

Я имею регистрацию блоков:

object PhoenixBlocks
{
    val BLOCKS = KDeferredRegister(ForgeRegistries.BLOCKS, Phoenix.MOD_ID)

    val UPDATER           : Block by BLOCKS.register("updater") { UpdaterBlock }
    val FERTILE_END_STONE : Block by BLOCKS.register("fertile_end_stone") { FertileEndStoneBlock }
    val ANTI_AIR          : Block by BLOCKS.register("anti_air")          { AntiAirBlock         }
    val POTTERY_BARREL    : Block by BLOCKS.register("pottery_barrel",    ::PotteryBarrelBlock)
    val ELECTRIC_BARREL   : Block by BLOCKS.register("electric_barrel",   ::ElectricBarrelBlock)
    val END_STONE_COLUMN  : Block by BLOCKS.register("end_stone_column")  { EndStoneColumnBlock }
    val OVEN              : Block by BLOCKS.register("oven",              ::OvenBlock           )
    val SETA              : Block by BLOCKS.register("seta") { SetaBlock }
    val ZIRCONIUM         : Block by BLOCKS.register("zirconium_ore") { ZirconiumOreBlock }
    val ARMORED_GLASS     : Block by BLOCKS.register("armored_glass") { ArmoredGlassBlock }
}

И тайлов:

object PhoenixTiles
{
    val TILE_ENTITIES = KDeferredRegister(ForgeRegistries.TILE_ENTITIES, Phoenix.MOD_ID)
 
    val POTTERY_BARREL  by TILE_ENTITIES.register("pottery_barrel") { TileEntityType.Builder.create({ PotteryBarrelTile() }, PhoenixBlocks.POTTERY_BARREL).build(null) }
    val OVEN            by TILE_ENTITIES.register("oven")           { TileEntityType.Builder.create({ OvenTile() }, PhoenixBlocks.OVEN).build(null) }
    val ELECTRIC_BARREL by TILE_ENTITIES.register("electric_barrel") { TileEntityType.Builder.create({ ElectricBarrelTile() }, PhoenixBlocks.POTTERY_BARREL).build(null) }
}

Очевидно, что в любом объекте класса PhoenixBlocks BlockItem быть не может, но они там лежат. Есть идеи что не так?

 

[hohserg]

Покажи код:
UpdaterBlock
KDeferredRegister
Скомпилируй мод, декомпилируй и покажи java-эквивалент этого места: PhoenixBlocks.getPOTTERY_BARREL

 

[GoogleTan]

UpdaterBlock

object UpdaterBlock : Block(Properties.create(Material.ROCK).setLightLevel { 5 }.hardnessAndResistance(-1f))
{
    override fun onBlockActivated(
        state: BlockState,
        worldIn: World,
        pos: BlockPos,
        player: PlayerEntity,
        handIn: Hand,
        hit: BlockRayTraceResult
    ): ActionResultType
    {
        if (!worldIn.isRemote && worldIn.dimensionKey === DimensionType.THE_END_ID)
        {
            val stageOld = StageManager.getStage()
            worldIn.playSound(pos.x.toDouble(), pos.y.toDouble(), pos.z.toDouble(), CHANGE_STAGE, SoundCategory.BLOCKS, 1f, 1f, true)
            StageManager.addPart()
            for (entity in worldIn.players)
            {
                entity.sendStatusMessage(TranslationTextComponent("phoenix.message.newstage"), false)
                entity.sendStatusMessage(
                    StringTextComponent((StageManager.getStage() + 1).toString() + " " + (StageManager.getPart() + 1) + " "),
                    false
                )
            }
            worldIn.setBlockState(pos, Blocks.AIR.defaultState)
        }
        return super.onBlockActivated(state, worldIn, pos, player, handIn, hit)
    }
}

KDeferredRegister

/**
 * Alternative version of [DeferredRegister] that creates
 * [ObjectHolderDelegate] instances instead of [RegistryObject].
 */
public class KDeferredRegister<V : IForgeRegistryEntry<V>>(
    public val registry: IForgeRegistry<V>,
    public val modid: String,
) {
    /**
     * A map of all registry objects and their value suppliers.
     */
    private val entries = LinkedHashMap<ObjectHolderDelegate<out V>, () -> V>()

    /**
     * Alternative constructor that uses a class instead of a registry.
     */
    public constructor(registryClass: Class<V>, modid: String) : this(RegistryManager.ACTIVE.getRegistry(registryClass), modid)

    /**
     * Registers this deferred register to the `KotlinEventBus`.
     */
    public fun register(bus: KotlinEventBus) {
        bus.addGenericListener(registry.registrySuperType, ::addEntries)
    }

    /**
     * Registers this deferred register to the `IEventBus`.
     */
    @Deprecated("Use a KotlinEventBus. Forge's EventBus does not support function references for event listeners.")
    public fun register(bus: IEventBus) {
        // function references are not supported by Forge's eventbus
        bus.addGenericListener(registry.registrySuperType) { event: RegistryEvent.Register<V> ->
            addEntries(event)
        }
    }

    /**
     * Adds a registry object to this deferred registry.
     *
     * @param name the path of the new registry object's registry name with namespace [modid]
     * @param supplier the function to initialize the value of the new registry object with and
     *                 to reset the value when forge adds reloadable registries.
     *
     * @return A new [ObjectHolderDelegate] with the given registry name and value
     */
    public fun <T : V> register(name: String, supplier: () -> T): ReadOnlyProperty<Any?, T> {
        val key = ResourceLocation(modid, name)
        val a = ObjectHolderDelegate<T>(key, registry)

        entries[a] = { supplier().setRegistryName(key) }

        return a
    }

    public fun getEntries(): Set<ObjectHolderDelegate<out V>> {
        return entries.keys
    }

    /**
     * Adds all entries in this registry to the corresponding game registries.
     */
    private fun addEntries(event: RegistryEvent.Register<V>) {
        val registry = event.registry

        for ((objectHolder, supplier) in entries) {
            registry.register(supplier())
            // pass true to always update the entry
            objectHolder.accept { true }
        }
    }
}

Код не декомпилится)

 

[GoogleTan]

Решение:
По неизвестной причине, для RegistryEvent.Register<Item> отыгрываются все RegistryEvent.Register. Нужно добавить проверку:

    fun onRegisterItems(event: RegistryEvent.Register<Item>)
    {
        if(event.registry == ForgeRegistries.ITEMS)
        {
            ...
        }
    }