I'm trying create an item that holds an entity(like an "SpawnEggItem"). But when I try to register the item with an created entity, this entity wasn't been registered yet. There's a priority system to these events? This is my code btw:

Spoiler

public class Registration {

    public static final DeferredRegister<EntityType<?>> ENTITIES = create(ForgeRegistries.ENTITIES);
    public static final DeferredRegister<Item> ITENS = create(ForgeRegistries.ITEMS);


    public static void register(){
        IEventBus fml = FMLJavaModLoadingContext.get().getModEventBus();
        ENTITIES.register(fml);
        ITENS.register(fml);

        ModEntities.register();
        ModItens.register();
    }

    private static <T extends IForgeRegistryEntry<T>> DeferredRegister<T> create(IForgeRegistry<T> registry){
        return DeferredRegister.create(registry, ExampleMod.MOD_ID);
    }

}

 

 

yes there's a priority system, would your item work using a supplier as that's probably the best way to do it

How do I set the priority? "FML" it is something that I don't understand. 

None of the code you've shown here is registering an item.

 

I also don't know why you wrapped DeferredRegister.create in a function with a convoluted signature rather than just going ENTITIES = DeferredRegister.create(ForgeRegistries.ENTITIES);

Here it is the part of the code, the Item:
 

Spoiler

public class ModItens {

  static void register(){ }

  public static Item.Properties getEssenceProperties(){
        return new Item.Properties()
                .tab(ModItemGroups.ESSENCE_TAB)
                .stacksTo(1);
    }
    
    public static final RegistryObject<Item> ESSENCE_PILLAGER_GOLD = Registration.ITENS.register("essence_entity.minecraft.golden_armoured_pillager", () ->
            new Essence(getEssenceProperties(), ModEntities.GOLDEN_ARMOURED_PILLAGER.get(), 5451574, 16167425));

    public static final RegistryObject<Item> ESSENCE_PILLAGER_DIAMOND = Registration.ITENS.register("essence_entity.minecraft.diamond_armoured_pillager", () ->
            new Essence(getEssenceProperties(), ModEntities.DIAMOND_ARMOURED_PILLAGER.get(), 5451574, 9433559));
  
}

 

and the entities' :

Spoiler

public class ModEntities {

    static void register(){
        System.out.println("Registering EntityTypes");
    }

    public static final RegistryObject<EntityType<GoldenArmouredPillager>> GOLDEN_ARMOURED_PILLAGER = Registration.ENTITIES.register("golden_armoured_pillager", () ->
            EntityType.Builder.<GoldenArmouredPillager>of(
                    GoldenArmouredPillager::new,
                    EntityClassification.CREATURE)
                    .canSpawnFarFromPlayer()
                    .sized(0.6F, 1.95F)
                    .clientTrackingRange(8).build("golden_armoured_pillager"));

    public static final RegistryObject<EntityType<DiamondArmouredPillager>> DIAMOND_ARMOURED_PILLAGER = Registration.ENTITIES.register("diamond_armoured_pillager", () ->
            EntityType.Builder.<DiamondArmouredPillager>of(
                    DiamondArmouredPillager::new,
                    EntityClassification.CREATURE)
                    .canSpawnFarFromPlayer()
                    .sized(0.6F, 1.95F)
                    .clientTrackingRange(8).build("diamond_armoured_pillager"));
}

 

 

16 minutes ago, LuccaPossamai said:

new Essence

...and this class?

 

Also, you know it's spelled "items" with an M right?

I'm from Brazil, and I'm used to code in portuguese. Like "items" in english is "itens" in portguese. Here it is the Essence class, and the EssenceItem class. I created 2 different classes to separete and simplify some things. 

Spoiler

public class Essence extends EssenceItem {

    public Essence(Properties properties, @Nullable EntityType tipo, int color1, int color2) {
        super(properties, tipo, color1, color2);

    }

    @Override
    public ActionResultType useOn(ItemUseContext p_195939_1_) {
        return ActionResultType.FAIL;
    }


}

 

Spoiler

public class EssenceItem extends Item {

    private static final Map<EntityType<?>, EssenceItem> BY_ID = Maps.newIdentityHashMap();
    private final int color1;
    private final int color2;
    private final EntityType<?> defaultType;

    public EssenceItem(Properties properties, @Nullable EntityType tipo, int color1, int color2) {
        super(properties);
        this.defaultType = tipo;
        this.color1 = color1;
        this.color2 = color2;
        BY_ID.put(tipo, this);

    }

    @OnlyIn(Dist.CLIENT)
    public int getColor(int p_195983_1_) {
        return p_195983_1_ == 0 ? this.color1 : this.color2;
    }

    @Nullable
    @OnlyIn(Dist.CLIENT)
    public static Item byId(@Nullable EntityType<?> p_200889_0_) {
        return BY_ID.get(p_200889_0_);
    }

    public static Iterable<EssenceItem> essences() {
        return Iterables.unmodifiableIterable(BY_ID.values());
    }

    public EntityType<?> getType(@Nullable CompoundNBT p_208076_1_) {
        if (p_208076_1_ != null && p_208076_1_.contains("EntityTag", 10)) {
            CompoundNBT compoundnbt = p_208076_1_.getCompound("EntityTag");
            if (compoundnbt.contains("id", 8)) {
                return EntityType.byString(compoundnbt.getString("id")).orElse(this.defaultType);
            }
        }

        return this.defaultType;
    }

}

 

 

(1) do not use OnlyIn pretty much ever, and never on methods you are creating whole cloth.

(2) your getType method is never called

(3) your useOn method does a whole lotta nuthin

(4) have you looked at the vanilla spawn egg?

(5) why are you not extending the vanilla spawn egg?

These things you've said interferes in the problem?

25 minutes ago, LuccaPossamai said:

These things you've said interferes in the problem?

the 3 first no, not really. but you should fix them
the last 2 should point you torwards the general direction of how to solve your problem

 

but here is the thing when using RegistryObjects: you can call .get() on static initialization (so since your items are statically initialized, you can't call any RegistryObject#get() in their definition). that's because at static initialization, the RegistryObjects haven't been populated yet, you need to wait until setup to be able to call .get()

so the way to work around this, is to just pass the RegistryObject itself (or any other supplier, the RegistryObject is just a fancy supplier). so then the entity won't try to be unpacked when it doesn't exist yet (i.e.: static initialization), and you unpack the Entity registry object whenever you actually need it.

 

Also, if you look at the vanilla spawn egg, you won't see this that I'm talking about, because vanilla doesn't use RegistryObjects

Thanks bruv!

Oh, also:

5 hours ago, diesieben07 said:

First of all the BLOCKS and ITEMS fields (i.e. your DeferredRegister instances) should not be in a separate class. Put them in the same class or you will have issues.

Because you didn't do this, you had to do this:

Quote

ModEntities.register();
ModItens.register();

And call empty methods.