Hello so i am makeing a custom tnt and i am stuck on how to render the tnt when it is about to explode

Here are my classes u may need

Main Class

package me.wilfsadude.Mod01;

import me.wilfsadude.Mod01.blocks.BlockNuclearBomb;
import me.wilfsadude.Mod01.blocks.BlockUraniumOre;
import me.wilfsadude.Mod01.entitys.EntityNuclearBombPrimed;
import me.wilfsadude.Mod01.lists.BlockList;
import me.wilfsadude.Mod01.lists.ItemList;
import me.wilfsadude.Mod01.world.OreGeneration;
import net.minecraft.block.Block;
import net.minecraft.block.SoundType;
import net.minecraft.block.material.Material;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityType;
import net.minecraft.entity.item.EntityTNTPrimed;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemGroup;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.registry.IRegistry;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.RegistryEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

@Mod("wm01")
public class Mod01 {

    public static Mod01 instance;
    public static final String modid = "wm01";
    private static final Logger logger = LogManager.getLogger(modid);

    public static final ItemGroup grp01 = new Grp01("mod01");

    public Mod01() {

        instance = this;

        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup);
        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::clientRegisteries);

        MinecraftForge.EVENT_BUS.register(this);
    }

    private void setup(final FMLCommonSetupEvent event)
    {
        OreGeneration.setupOreGeneration();
        logger.info("setup method registered");

    }

    private void clientRegisteries(final FMLClientSetupEvent event) {

        logger.info("clientRegisteries method registered.");

    }

    @Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.MOD)
    public static class RegistryEvents {


        public static <T extends Entity> EntityType<T> register(String id, EntityType.Builder<T> builder) {
            EntityType<T> entitytype = builder.build(id);
            IRegistry.field_212629_r.put(new ResourceLocation(modid,id), entitytype);
            return entitytype;
        }

        @SubscribeEvent
        public static void registerItems(final RegistryEvent.Register<Item> event) {

            event.getRegistry().registerAll(
                    ItemList.uranium_ingot = new Item(new Item.Properties().group(grp01)).setRegistryName(location("uranium_ingot")),
                    ItemList.computer_chip = new Item(new Item.Properties().group(grp01)).setRegistryName(location("computer_chip")),

                    ItemList.uranium_ore = new ItemBlock(BlockList.uranium_ore, new Item.Properties().group(grp01)).setRegistryName(BlockList.uranium_ore.getRegistryName()),
                    ItemList.uranium_block = new ItemBlock(BlockList.uranium_block, new Item.Properties().group(grp01)).setRegistryName(BlockList.uranium_block.getRegistryName()),
                    ItemList.nuclear_bomb = new ItemBlock(BlockList.nuclear_bomb, new Item.Properties().group(grp01)).setRegistryName(BlockList.nuclear_bomb.getRegistryName())
            );

            logger.info("Items registered");
        }

        @SubscribeEvent
        public static void registerBlocks(final RegistryEvent.Register<Block> event) {

            event.getRegistry().registerAll(
                    BlockList.uranium_ore = new BlockUraniumOre(Block.Properties.create(Material.ROCK).hardnessAndResistance(3.0F, 3.0F).lightValue(6).sound(SoundType.STONE)).setRegistryName(location("uranium_ore")),
                    BlockList.uranium_block = new Block(Block.Properties.create(Material.IRON).hardnessAndResistance(3.0F, 4.0F).lightValue(8).sound(SoundType.METAL)).setRegistryName(location("uranium_block")),
                    BlockList.nuclear_bomb = new BlockNuclearBomb(Block.Properties.create(Material.TNT).hardnessAndResistance(3.0F, 4.0F).lightValue(8).sound(SoundType.SAND)).setRegistryName(location("nuclear_bomb"))
            );

            logger.info("Blocks registered");
        }

        public static final EntityType<EntityNuclearBombPrimed> TNT = register("nuclear_bomb", EntityType.Builder.create(EntityNuclearBombPrimed.class, EntityNuclearBombPrimed::new));

        private static ResourceLocation location(String name) {
            return new ResourceLocation(modid,name);
        }

    }


}

Block List

package me.wilfsadude.Mod01.lists;

import net.minecraft.block.Block;

public class BlockList {

    public static Block uranium_ore;
    public static Block uranium_block;
    public static Block nuclear_bomb;

}

Block Nuclear Bomb

package me.wilfsadude.Mod01.blocks;

import me.wilfsadude.Mod01.entitys.EntityNuclearBombPrimed;
import net.minecraft.block.Block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.projectile.EntityArrow;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.init.SoundEvents;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.state.BooleanProperty;
import net.minecraft.state.StateContainer;
import net.minecraft.state.properties.BlockStateProperties;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumHand;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.Explosion;
import net.minecraft.world.World;

import javax.annotation.Nullable;

public class BlockNuclearBomb extends Block {
   public static final BooleanProperty field_212569_a = BlockStateProperties.field_212646_x;

   public BlockNuclearBomb(Properties builder) {
      super(builder);
      this.setDefaultState(this.getDefaultState().with(field_212569_a, Boolean.valueOf(false)));
   }

   public void onBlockAdded(IBlockState state, World worldIn, BlockPos pos, IBlockState oldState) {
      if (oldState.getBlock() != state.getBlock()) {
         if (worldIn.isBlockPowered(pos)) {
            this.explode(worldIn, pos);
            worldIn.removeBlock(pos);
         }

      }
   }

   /**
    * Called when a neighboring block was changed and marks that this state should perform any checks during a neighbor
    * change. Cases may include when redstone power is updated, cactus blocks popping off due to a neighboring solid
    * block, etc.
    */
   public void neighborChanged(IBlockState state, World worldIn, BlockPos pos, Block blockIn, BlockPos fromPos) {
      if (worldIn.isBlockPowered(pos)) {
         this.explode(worldIn, pos);
         worldIn.removeBlock(pos);
      }

   }

   public void dropBlockAsItemWithChance(IBlockState state, World worldIn, BlockPos pos, float chancePerItem, int fortune) {
      if (!state.get(field_212569_a)) {
         super.dropBlockAsItemWithChance(state, worldIn, pos, chancePerItem, fortune);
      }
   }

   /**
    * Called before the Block is set to air in the world. Called regardless of if the player's tool can actually collect
    * this block
    */
   public void onBlockHarvested(World worldIn, BlockPos pos, IBlockState state, EntityPlayer player) {
      if (!worldIn.isRemote() && !player.isCreative() && state.get(field_212569_a)) {
         this.explode(worldIn, pos);
      }

      super.onBlockHarvested(worldIn, pos, state, player);
   }

   /**
    * Called when this Block is destroyed by an Explosion
    */
   public void onExplosionDestroy(World worldIn, BlockPos pos, Explosion explosionIn) {
      if (!worldIn.isRemote) {
         EntityNuclearBombPrimed entitynuclearbombprimed = new EntityNuclearBombPrimed(worldIn, (double)((float)pos.getX() + 0.5F), (double)pos.getY(), (double)((float)pos.getZ() + 0.5F), explosionIn.getExplosivePlacedBy());
         entitynuclearbombprimed.setFuse((short)(worldIn.rand.nextInt(entitynuclearbombprimed.getFuse() / 4) + entitynuclearbombprimed.getFuse() / 8));
         worldIn.spawnEntity(entitynuclearbombprimed);
      }
   }

   public void explode(World p_196534_1_, BlockPos p_196534_2_) {
      this.explode(p_196534_1_, p_196534_2_, (EntityLivingBase)null);
   }

   private void explode(World p_196535_1_, BlockPos p_196535_2_, @Nullable EntityLivingBase p_196535_3_) {
      if (!p_196535_1_.isRemote) {
         EntityNuclearBombPrimed entitynuclearbombprimed = new EntityNuclearBombPrimed(p_196535_1_, (double)((float)p_196535_2_.getX() + 0.5F), (double)p_196535_2_.getY(), (double)((float)p_196535_2_.getZ() + 0.5F), p_196535_3_);
         p_196535_1_.spawnEntity(entitynuclearbombprimed);
         p_196535_1_.playSound((EntityPlayer)null, entitynuclearbombprimed.posX, entitynuclearbombprimed.posY, entitynuclearbombprimed.posZ, SoundEvents.ENTITY_TNT_PRIMED, SoundCategory.BLOCKS, 1.0F, 1.0F);
      }
   }

   public boolean onBlockActivated(IBlockState state, World worldIn, BlockPos pos, EntityPlayer player, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ) {
      ItemStack itemstack = player.getHeldItem(hand);
      Item item = itemstack.getItem();
      if (item != Items.FLINT_AND_STEEL && item != Items.FIRE_CHARGE) {
         return super.onBlockActivated(state, worldIn, pos, player, hand, side, hitX, hitY, hitZ);
      } else {
         this.explode(worldIn, pos, player);
         worldIn.setBlockState(pos, Blocks.AIR.getDefaultState(), 11);
         if (item == Items.FLINT_AND_STEEL) {
            itemstack.damageItem(1, player);
         } else {
            itemstack.shrink(1);
         }

         return true;
      }
   }

   public void onEntityCollision(IBlockState state, World worldIn, BlockPos pos, Entity entityIn) {
      if (!worldIn.isRemote && entityIn instanceof EntityArrow) {
         EntityArrow entityarrow = (EntityArrow)entityIn;
         Entity entity = entityarrow.func_212360_k();
         if (entityarrow.isBurning()) {
            this.explode(worldIn, pos, entity instanceof EntityLivingBase ? (EntityLivingBase)entity : null);
            worldIn.removeBlock(pos);
         }
      }

   }

   /**
    * Return whether this block can drop from an explosion.
    */
   public boolean canDropFromExplosion(Explosion explosionIn) {
      return false;
   }

   protected void fillStateContainer(StateContainer.Builder<Block, IBlockState> builder) {
      builder.add(field_212569_a);
   }
}

Entity Nuclear Bomb Primed

package me.wilfsadude.Mod01.entitys;

import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.EntityType;
import net.minecraft.entity.MoverType;
import net.minecraft.init.Particles;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.datasync.DataParameter;
import net.minecraft.network.datasync.DataSerializers;
import net.minecraft.network.datasync.EntityDataManager;
import net.minecraft.world.World;

import javax.annotation.Nullable;

public class EntityNuclearBombPrimed extends Entity {
   private static final DataParameter<Integer> FUSE = EntityDataManager.createKey(EntityNuclearBombPrimed.class, DataSerializers.VARINT);
   @Nullable
   private EntityLivingBase tntPlacedBy;
   /** How long the fuse is */
   private int fuse = 80;

   public EntityNuclearBombPrimed(World worldIn) {
      super(EntityType.TNT, worldIn);
      this.preventEntitySpawning = true;
      this.isImmuneToFire = true;
      this.setSize(0.98F, 0.98F);
   }

   public EntityNuclearBombPrimed(World worldIn, double x, double y, double z, @Nullable EntityLivingBase igniter) {
      this(worldIn);
      this.setPosition(x, y, z);
      float f = (float)(Math.random() * (double)((float)Math.PI * 2F));
      this.motionX = (double)(-((float)Math.sin((double)f)) * 0.02F);
      this.motionY = (double)0.2F;
      this.motionZ = (double)(-((float)Math.cos((double)f)) * 0.02F);
      this.setFuse(80);
      this.prevPosX = x;
      this.prevPosY = y;
      this.prevPosZ = z;
      this.tntPlacedBy = igniter;
   }

   protected void registerData() {
      this.dataManager.register(FUSE, 80);
   }

   /**
    * returns if this entity triggers Block.onEntityWalking on the blocks they walk on. used for spiders and wolves to
    * prevent them from trampling crops
    */
   protected boolean canTriggerWalking() {
      return false;
   }

   /**
    * Returns true if other Entities should be prevented from moving through this Entity.
    */
   public boolean canBeCollidedWith() {
      return !this.removed;
   }

   /**
    * Called to update the entity's position/logic.
    */
   public void tick() {
      this.prevPosX = this.posX;
      this.prevPosY = this.posY;
      this.prevPosZ = this.posZ;
      if (!this.hasNoGravity()) {
         this.motionY -= (double)0.04F;
      }

      this.move(MoverType.SELF, this.motionX, this.motionY, this.motionZ);
      this.motionX *= (double)0.98F;
      this.motionY *= (double)0.98F;
      this.motionZ *= (double)0.98F;
      if (this.onGround) {
         this.motionX *= (double)0.7F;
         this.motionZ *= (double)0.7F;
         this.motionY *= -0.5D;
      }

      --this.fuse;
      if (this.fuse <= 0) {
         this.remove();
         if (!this.world.isRemote) {
            this.explode();
         }
      } else {
         this.handleWaterMovement();
         this.world.spawnParticle(Particles.SMOKE, this.posX, this.posY + 0.5D, this.posZ, 0.0D, 0.0D, 0.0D);
      }

   }

   private void explode() {
      float f = 4.0F;
      this.world.createExplosion(this, this.posX, this.posY + (double)(this.height / 16.0F), this.posZ, 4.0F, true);
   }

   /**
    * Writes the extra NBT data specific to this type of entity. Should <em>not</em> be called from outside this class;
    * use {@link #writeUnlessPassenger} or {@link #writeWithoutTypeId} instead.
    */
   protected void writeAdditional(NBTTagCompound compound) {
      compound.setShort("Fuse", (short)this.getFuse());
   }

   /**
    * (abstract) Protected helper method to read subclass entity data from NBT.
    */
   protected void readAdditional(NBTTagCompound compound) {
      this.setFuse(compound.getShort("Fuse"));
   }

   /**
    * returns null or the entityliving it was placed or ignited by
    */
   @Nullable
   public EntityLivingBase getTntPlacedBy() {
      return this.tntPlacedBy;
   }

   public float getEyeHeight() {
      return 0.0F;
   }

   public void setFuse(int fuseIn) {
      this.dataManager.set(FUSE, fuseIn);
      this.fuse = fuseIn;
   }

   public void notifyDataManagerChange(DataParameter<?> key) {
      if (FUSE.equals(key)) {
         this.fuse = this.getFuseDataManager();
      }

   }

   /**
    * Gets the fuse from the data manager
    */
   public int getFuseDataManager() {
      return this.dataManager.get(FUSE);
   }

   public int getFuse() {
      return this.fuse;
   }
}

Please help

You haven't created an entity renderer for your TNT entity.

3 hours ago, DavidM said:

You haven't created an entity renderer for your TNT entity.

how would i go about doing this

@DavidMhow would i go about doing this

1. There is no need to double post.

2. Create a class (referred to as "Renderer" from now on) that extends 

Render<? extends Entity>

, then override Render#doRender and do your rendering of your entity there. This class is responsible for rendering your entity.

 

Next, create another class (referred to as "RendererFactory" from now on) that implements

IRenderFactory<Renderer>

, then override IRenderFactory#createRenderFor and return an instance of Renderer.

 

Next, call

RenderingRegistry.registerEntityRenderingHandler(${YourEntity}.class, ${instance of RendererFactory});

in the client proxy during preInit (or was it init?). This line is responsible for actually binding Renderer to your entity.

@DavidM

Im sorry about the double post. Please check if I did everything right and what do I do next

1. I dont seem to have a client proxy so was unable to complete the last step

2. I think I did my renderer class wrong

public class Renderer extends Entity {

    public Renderer(EntityType<?> entityTypeIn, World worldIn) {
        super(entityTypeIn, worldIn);
    }

    @Override
    protected void registerData() {

    }

    @Override
    protected void readAdditional(NBTTagCompound compound) {

    }

    @Override
    protected void writeAdditional(NBTTagCompound compound) {

    }
}

I get an error saying "All entityies must have a constructor that takes one net.minecraft.World.world paramater"

3. I think I did this part right

public class RendererFactory implements IRenderFactory<Renderer> {
    @Override
    public Render<? super Renderer> createRenderFor(RenderManager manager) {
        return null;
    }
}

What is next

1. Your renderer is supposed to extends

Render<${insert your tile entity here}>

, not Entity.

 

2.

5 minutes ago, wilfsadude1 said:

I dont seem to have a client proxy so was unable to complete the last step

Set up the proxies then.

9 minutes ago, DavidM said:

Set up the proxies then.

Im sorry if this sounds stupid but how do i do that.

 

Also is this correct

public class Renderer extends EntityNuclearBombPrimed {

    public Renderer(World worldIn) {
        super(worldIn);
    }
}

 

21 minutes ago, wilfsadude1 said:

Also is this correct

No.

The renderer should extend Render<${insert your tile entity here}>, or in your case, Render<EntityNuclearBombPrimed>.

@DavidM

Oooh so like this

public class Renderer extends Render<EntityNuclearBombPrimed> {

    protected Renderer(RenderManager renderManager) {
        super(renderManager);
    }

    @Nullable
    @Override
    protected ResourceLocation getEntityTexture(EntityNuclearBombPrimed entity) {
        return null;
    }
}

now how do I do the proxy thing

Just create a renderer class and then register it using RenderingRegistry.registerEntityRendreringHandler(YourRenderer::new) in the model registry event in your client event subscriber. No need for proxies or a dedicated factory class

@Cadiboo so what code would i use in the class

Here’s a Gist https://gist.github.com/Cadiboo/3f5cdb785affc069af2fa5fdf2d70358

ok ive added it but i get an error here

ModelLoader.setCustomModelResourceLocation(item, 0, new ModelResourceLocation(item.getRegistryName(), "normal"));

on the setCustomModelResourceLocation part. It says it doesnt exist

@Cadiboo

That part of the code has to do with item model registration (which is done automatically in 1.13), not entity renderer registration.

10 minutes ago, wilfsadude1 said:

@Cadiboo

Don’t ping me after only 40 minutes. We do this in our spare time

Edited May 18, 20196 yr by Cadiboo

so i dont need that part

Just now, wilfsadude1 said:

so i dont need that part

Not in 1.13

so it looks like this

@SubscribeEvent
        public static void onRegisterModelsEvent(@Nonnull final ModelRegistryEvent event) {

            registerEntityRenderers();
            LOGGER.debug("Registered entity renderers");

            

        }
        private static void registerEntityRenderers() {

		    RenderingRegistry.registerEntityRenderingHandler(EntityNuclearBombPrimed.class, Renderer::new);

        }

and the renderer class like this

public class Renderer extends Render<EntityNuclearBombPrimed> {

    public Renderer(RenderManager renderManager) {
        super(renderManager);
    }

    @Nullable
    @Override
    protected ResourceLocation getEntityTexture(EntityNuclearBombPrimed entity) {
        return null;
    }
}

 

As long as you have the @EventBusSubscriber setup right on the class that has the @SubscribeEvent that looks right

so now do i have to add a texture for the entity if so where

 

im thinking I change my render class to this

public class Renderer extends Render<EntityNuclearBombPrimed> {

    public Renderer(RenderManager renderManager) {
        super(renderManager);
    }

    @Nullable
    @Override
    protected ResourceLocation getEntityTexture(EntityNuclearBombPrimed entity) {
        return new ResourceLocation(modid,"nuclear_bomb");
    }
}

but it still doesnt render

You would probably need to extend the TNT renderer or at least copy the logic from it

@Cadiboo After looking in my code for a while I'm guessing i need to change this

public EntityNuclearBombPrimed(World worldIn) {
      super(EntityType.TNT, worldIn);
      this.preventEntitySpawning = true;
      this.isImmuneToFire = true;
      this.setSize(0.98F, 0.98F);
   }

and change the super however i dont know what to change it to