Jump to content
Search In
  • More options...
Find results that contain...
Find results in...

Noob_Master69

Members
  • Posts

    24
  • Joined

  • Last visited

Posts posted by Noob_Master69

  1. Hello, I'm trying to create an event so when the player presses P it rotates the right arm so it looks like he's pointing at something and I've already created a keybind but it doesn't rotate the arm.

     

    Here's my Event code: 

    @Mod.EventBusSubscriber(modid = Main.MOD_ID, bus = Bus.FORGE) 
    public class PointEvent { 
      	@SubscribeEvent 
      	public static void pointEvent(RenderPlayerEvent event) { 
        	PlayerEntity player = event.getPlayer(); 
        	if(Keybind.LIFT.isKeyDown()) { 
          		Main.LOGGER.info("Rotated Arm!"); 
          		event.getRenderer().getEntityModel().bipedRightArm.rotateAngleX = 0.5F; 
        	} 
      	} 
    }

    And here's the keybind code:

    public class Keybind { 
    	public static final KeyBinding LIFT; 
    	public static void init() { 
    		ClientRegistry.registerKeyBinding(Keybind.LIFT); 
    	}
    
    	static { 
    		LIFT = new KeyBinding("imam.key.lift", 80, "key.categories.imam"); 
    	} 
    }

     

  2. Hello, I'm trying to create an event so when the player presses P it rotates the right arm so it looks like he's pointing at something and I've already created a keybind but it doesn't rotate the arm.

     

    Here's my Event code: 

    @Mod.EventBusSubscriber(modid = Main.MOD_ID, bus = Bus.FORGE)
    public class PointEvent {
    	
    	@SubscribeEvent
    	public static void pointEvent(RenderPlayerEvent event) {
    		PlayerEntity player = event.getPlayer();
    		if(Keybind.LIFT.isKeyDown()) {
    			Main.LOGGER.info("Rotated Arm!");
    			event.getRenderer().getEntityModel().bipedRightArm.rotateAngleX = 0.5F;
    		}
    	}
    }

    And here's the keybind code:

    public class Keybind {
        public static final KeyBinding LIFT;
        
        public static void init() {
            ClientRegistry.registerKeyBinding(Keybind.LIFT);
        }
        
        static {
        	LIFT = new KeyBinding("imam.key.lift", 80, "key.categories.imam");
        }
    }

     

  3. 11 hours ago, Draco18s said:

    Because you (quite literally) stole the stack from your recipe manager.

     

    
    ItemStack output = FusionReactorRecipes.getInstance().getSinteringResult(inputs[0], inputs[1]);
    if(!output.isEmpty())
    {
        smelting = output;

     

    You have to call .copy() on it.

    so like this?

    if(!output.copy().isEmpty())
    					{
    						smelting = output;
    						cookTime++;
    						inputs[0].shrink(1);
    						inputs[1].shrink(1);
    						handler.setStackInSlot(0, inputs[0]);
    						handler.setStackInSlot(1, inputs[1]);
    						energy -= 20;
    					}

     

  4. So I've created a custom furnace and it works like I expected it to, until I took out the output. When I remove the output, it just stops smelting.

    Block.class:

    Spoiler

    package galileogalilei.ironmanarmormod.blocks;

    import java.util.Random;

    import galileogalilei.ironmanarmormod.Main;
    import galileogalilei.ironmanarmormod.Reference;
    import galileogalilei.ironmanarmormod.blocks.tileentities.TileEntityElectricFusionReactor;
    import galileogalilei.ironmanarmormod.init.BlockInit;
    import net.minecraft.block.BlockHorizontal;
    import net.minecraft.block.SoundType;
    import net.minecraft.block.material.Material;
    import net.minecraft.block.properties.IProperty;
    import net.minecraft.block.properties.PropertyBool;
    import net.minecraft.block.properties.PropertyDirection;
    import net.minecraft.block.state.BlockStateContainer;
    import net.minecraft.block.state.IBlockState;
    import net.minecraft.entity.EntityLivingBase;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemStack;
    import net.minecraft.tileentity.TileEntity;
    import net.minecraft.util.EnumBlockRenderType;
    import net.minecraft.util.EnumFacing;
    import net.minecraft.util.EnumHand;
    import net.minecraft.util.Mirror;
    import net.minecraft.util.Rotation;
    import net.minecraft.util.math.BlockPos;
    import net.minecraft.world.World;

    public class BlockElectricFusionReactor extends BlockBase
    {
        public static final PropertyDirection FACING = BlockHorizontal.FACING;
        public static final PropertyBool BURNING = PropertyBool.create("burning");
        
        public BlockElectricFusionReactor(String name) 
        {
            super(name, Material.IRON);
            setHardness(8.0f);
            setResistance(25.0f);
            setCreativeTab(Main.BLOCKS);
            setHarvestLevel("pickaxe", 2);
            setLightLevel(9.0f);
            setSoundType(SoundType.METAL);
            this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(BURNING, false));
        }
        
        @Override
        public Item getItemDropped(IBlockState state, Random rand, int fortune) 
        {
            return Item.getItemFromBlock(BlockInit.ELECTRIC_FUSION_REACTOR);
        }
        
        @Override
        public ItemStack getItem(World worldIn, BlockPos pos, IBlockState state)
        {
            return new ItemStack(BlockInit.ELECTRIC_FUSION_REACTOR);
        }
        
        @Override
        public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) 
        {
            if(!worldIn.isRemote)
            {
                playerIn.openGui(Main.instance, Reference.GUI_ELECTRIC_FUSION_REACTOR, worldIn, pos.getX(), pos.getY(), pos.getZ());
            }
            
            return true;
        }
        
        @Override
        public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state) 
        {
            if (!worldIn.isRemote) 
            {
                IBlockState north = worldIn.getBlockState(pos.north());
                IBlockState south = worldIn.getBlockState(pos.south());
                IBlockState west = worldIn.getBlockState(pos.west());
                IBlockState east = worldIn.getBlockState(pos.east());
                EnumFacing face = (EnumFacing)state.getValue(FACING);

                if (face == EnumFacing.NORTH && north.isFullBlock() && !south.isFullBlock()) face = EnumFacing.SOUTH;
                else if (face == EnumFacing.SOUTH && south.isFullBlock() && !north.isFullBlock()) face = EnumFacing.NORTH;
                else if (face == EnumFacing.WEST && west.isFullBlock() && !east.isFullBlock()) face = EnumFacing.EAST;
                else if (face == EnumFacing.EAST && east.isFullBlock() && !west.isFullBlock()) face = EnumFacing.WEST;
                worldIn.setBlockState(pos, state.withProperty(FACING, face), 2);
            }
        }
        
        public static void setState(boolean active, World worldIn, BlockPos pos) 
        {
            IBlockState state = worldIn.getBlockState(pos);
            TileEntity tileentity = worldIn.getTileEntity(pos);
            
            if(active) worldIn.setBlockState(pos, BlockInit.ELECTRIC_FUSION_REACTOR.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, true), 3);
            else worldIn.setBlockState(pos, BlockInit.ELECTRIC_FUSION_REACTOR.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, false), 3);
            
            if(tileentity != null) 
            {
                tileentity.validate();
                worldIn.setTileEntity(pos, tileentity);
            }
        }
        
        @Override
        public boolean hasTileEntity(IBlockState state) 
        {
            return true;
        }
        
        @Override
        public TileEntity createTileEntity(World world, IBlockState state) 
        {
            return new TileEntityElectricFusionReactor();
        }
        
        @Override
        public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer, EnumHand hand) 
        {
            return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
        }
        
        @Override
        public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) 
        {
            worldIn.setBlockState(pos, this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);
        }
        
        @Override
        public EnumBlockRenderType getRenderType(IBlockState state) 
        {
            return EnumBlockRenderType.MODEL;
        }
        
        @Override
        public IBlockState withRotation(IBlockState state, Rotation rot)
        {
            return state.withProperty(FACING, rot.rotate((EnumFacing)state.getValue(FACING)));
        }
        
        @Override
        public IBlockState withMirror(IBlockState state, Mirror mirrorIn) 
        {
            return state.withRotation(mirrorIn.toRotation((EnumFacing)state.getValue(FACING)));
        }
        
        @Override
        protected BlockStateContainer createBlockState() 
        {
            return new BlockStateContainer(this, new IProperty[] {BURNING,FACING});
        }
        
        @Override
        public IBlockState getStateFromMeta(int meta) 
        {
            EnumFacing facing = EnumFacing.getFront(meta);
            if(facing.getAxis() == EnumFacing.Axis.Y) facing = EnumFacing.NORTH;
            return this.getDefaultState().withProperty(FACING, facing);
        }
        
        @Override
        public int getMetaFromState(IBlockState state) 
        {
            return ((EnumFacing)state.getValue(FACING)).getIndex();
        }    
    }

     

    Recipe.class

    Spoiler

    package galileogalilei.ironmanarmormod.blocks.recipes;

    import java.util.Map;
    import java.util.Map.Entry;

    import com.google.common.collect.HashBasedTable;
    import com.google.common.collect.Maps;
    import com.google.common.collect.Table;

    import galileogalilei.ironmanarmormod.init.BlockInit;
    import galileogalilei.ironmanarmormod.init.ItemInit;
    import net.minecraft.init.Blocks;
    import net.minecraft.init.Items;
    import net.minecraft.item.ItemStack;

    public class FusionReactorRecipes 
    {    
        private static final FusionReactorRecipes INSTANCE = new FusionReactorRecipes();
        private final Table<ItemStack, ItemStack, ItemStack> smeltingList = HashBasedTable.<ItemStack, ItemStack, ItemStack>create();
        private final Map<ItemStack, Float> experienceList = Maps.<ItemStack, Float>newHashMap();
        
        public static FusionReactorRecipes getInstance()
        {
            return INSTANCE;
        }
        
        private FusionReactorRecipes() 
        {
            addSinteringRecipe(new ItemStack(Items.DIAMOND), new ItemStack(ItemInit.VIBRANIUM_INGOT), new ItemStack(ItemInit.VIBRANIUM_CORE), 5.0F);
        }

        
        public void addSinteringRecipe(ItemStack input1, ItemStack input2, ItemStack result, float experience) 
        {
            if(getSinteringResult(input1, input2) != ItemStack.EMPTY) return;
            this.smeltingList.put(input1, input2, result);
            this.experienceList.put(result, Float.valueOf(experience));
        }
        
        public ItemStack getSinteringResult(ItemStack input1, ItemStack input2) 
        {
            for(Entry<ItemStack, Map<ItemStack, ItemStack>> entry : this.smeltingList.columnMap().entrySet()) 
            {
                if(this.compareItemStacks(input1, (ItemStack)entry.getKey())) 
                {
                    for(Entry<ItemStack, ItemStack> ent : entry.getValue().entrySet()) 
                    {
                        if(this.compareItemStacks(input2, (ItemStack)ent.getKey())) 
                        {
                            return (ItemStack)ent.getValue();
                        }
                    }
                }
            }
            return ItemStack.EMPTY;
        }
        
        private boolean compareItemStacks(ItemStack stack1, ItemStack stack2)
        {
            return stack2.getItem() == stack1.getItem() && (stack2.getMetadata() == 32767 || stack2.getMetadata() == stack1.getMetadata());
        }
        
        public Table<ItemStack, ItemStack, ItemStack> getDualSmeltingList() 
        {
            return this.smeltingList;
        }
        
        public float getReactingExperience(ItemStack stack)
        {
            for (Entry<ItemStack, Float> entry : this.experienceList.entrySet()) 
            {
                if(this.compareItemStacks(stack, (ItemStack)entry.getKey())) 
                {
                    return ((Float)entry.getValue()).floatValue();
                }
            }
            return 0.0F;
        }
    }

    TileEntity.class

    Spoiler

    package galileogalilei.ironmanarmormod.blocks.tileentities;

    import galileogalilei.ironmanarmormod.blocks.BlockElectricFusionReactor;
    import galileogalilei.ironmanarmormod.blocks.recipes.FusionReactorRecipes;
    import galileogalilei.ironmanarmormod.energy.ImamEnergyStorage;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.item.ItemStack;
    import net.minecraft.nbt.NBTTagCompound;
    import net.minecraft.tileentity.TileEntity;
    import net.minecraft.util.EnumFacing;
    import net.minecraft.util.ITickable;
    import net.minecraft.util.text.ITextComponent;
    import net.minecraft.util.text.TextComponentTranslation;
    import net.minecraftforge.common.capabilities.Capability;
    import net.minecraftforge.energy.CapabilityEnergy;
    import net.minecraftforge.items.CapabilityItemHandler;
    import net.minecraftforge.items.ItemStackHandler;

    public class TileEntityElectricFusionReactor extends TileEntity implements ITickable
    {
        int tick;
        private ImamEnergyStorage storage = new ImamEnergyStorage(25000, 20, 0, 0);
        public ItemStackHandler handler = new ItemStackHandler(3);
        private String customName;
        public int cookTime, energy = storage.getEnergyStored();
        private ItemStack smelting = ItemStack.EMPTY;
        
        @Override
        public boolean hasCapability(Capability<?> capability, EnumFacing facing) 
        {
            if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) return true;
            if(capability == CapabilityEnergy.ENERGY) return true;
            return super.hasCapability(capability, facing);
        }
        
        @Override
        public <T> T getCapability(Capability<T> capability, EnumFacing facing) 
        {
            if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) return (T) this.handler;
            if(capability == CapabilityEnergy.ENERGY) return (T)this.storage;
            return super.getCapability(capability, facing);
        }
        
        @Override
        public NBTTagCompound writeToNBT(NBTTagCompound compound)
        {
            super.writeToNBT(compound);
            compound.setTag("Inventory", this.handler.serializeNBT());
            compound.setInteger("CookTime", cookTime);
            compound.setInteger("GuiEnergy", energy);
            this.storage.writeToNBT(compound);
            compound.setString("Name", getDisplayName().toString());
            return compound;
        }
        
        @Override
        public void readFromNBT(NBTTagCompound compound) 
        {
            super.readFromNBT(compound);
            this.handler.deserializeNBT(compound.getCompoundTag("Inventory"));
            this.storage.readFromNBT(compound);
            this.cookTime = compound.getInteger("CookTime");
            this.energy = compound.getInteger("GuiEnergy");
            if(compound.hasKey("Name")) this.customName = compound.getString("Name");
        }
        
        @Override
        public void update()
        {
            tick++;
            if(tick > 20) tick = 0;
            
            if(tick == 0)
            {
                System.out.println(Integer.toString(energy));
            }
            
            if(world.isBlockPowered(pos)) energy += 100;
            
            ItemStack[] inputs = new ItemStack[] {handler.getStackInSlot(0), handler.getStackInSlot(1)};
            
            if(energy >= 20)
            {
                if(cookTime > 0)
                {
                    energy -= 20;
                    cookTime++;
                    BlockElectricFusionReactor.setState(true, world, pos);
                    if(cookTime == 100)
                    {
                        if(handler.getStackInSlot(2).getCount() > 0)
                        {
                            handler.getStackInSlot(2).grow(1);
                        }
                        else
                        {
                            handler.insertItem(2, smelting, false);
                        }
                        smelting = ItemStack.EMPTY;
                        cookTime = 0;
                        return;
                    }
                }
                else
                {
                    if(!inputs[0].isEmpty() && !inputs[1].isEmpty())
                    {
                        ItemStack output = FusionReactorRecipes.getInstance().getSinteringResult(inputs[0], inputs[1]);
                        if(!output.isEmpty())
                        {
                            smelting = output;
                            cookTime++;
                            inputs[0].shrink(1);
                            inputs[1].shrink(1);
                            handler.setStackInSlot(0, inputs[0]);
                            handler.setStackInSlot(1, inputs[1]);
                            energy -= 20;
                        }
                    }
                }
            }
        }
        
        @Override
        public ITextComponent getDisplayName() 
        {
            return new TextComponentTranslation("container.electric_fusion_reactor");
        }
        
        public int getEnergyStored()
        {
            return this.energy;
        }
        
        public int getMaxEnergyStored()
        {
            return this.storage.getMaxEnergyStored();
        }
        
        public boolean isUsableByPlayer(EntityPlayer player) 
        {
            return this.world.getTileEntity(this.pos) != this ? false : player.getDistanceSq((double)this.pos.getX() + 0.5D, (double)this.pos.getY() + 0.5D, (double)this.pos.getZ() + 0.5D) <= 64.0D;
        }
        
        public int getField(int id) 
        {
            switch(id) 
            {
            case 0:
                return this.cookTime;
            case 1:
                return this.energy;
            default:
                return 0;
            }
        }

        public void setField(int id, int value) 
        {
            switch(id) 
            {
            case 0:
                this.cookTime = value;
                break;
            case 1:
                this.energy = value;
            }
        }
    }

    Container.class

    Spoiler

    package galileogalilei.ironmanarmormod.blocks.containers;

    import galileogalilei.ironmanarmormod.blocks.recipes.FusionReactorRecipes;
    import galileogalilei.ironmanarmormod.blocks.tileentities.TileEntityElectricFusionReactor;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.entity.player.InventoryPlayer;
    import net.minecraft.inventory.Container;
    import net.minecraft.inventory.IContainerListener;
    import net.minecraft.inventory.Slot;
    import net.minecraft.item.ItemStack;
    import net.minecraftforge.items.CapabilityItemHandler;
    import net.minecraftforge.items.IItemHandler;
    import net.minecraftforge.items.SlotItemHandler;

    public class ContainerElectricFusionReactor extends Container
    {
        private final TileEntityElectricFusionReactor tileentity;
        private int cookTime, energy;
        
        public ContainerElectricFusionReactor(InventoryPlayer player, TileEntityElectricFusionReactor tileentity) 
        {
            this.tileentity = tileentity;
            IItemHandler handler = tileentity.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
            
            this.addSlotToContainer(new SlotItemHandler(handler, 0, 44, 21));
            this.addSlotToContainer(new SlotItemHandler(handler, 1, 44, 50));
            this.addSlotToContainer(new SlotItemHandler(handler, 2, 97, 36));
            
            for(int y = 0; y < 3; y++)
            {
                for(int x = 0; x < 9; x++)
                {
                    this.addSlotToContainer(new Slot(player, x + y*9 + 9, 8 + x*18, 84 + y*18));
                }
            }
            
            for(int x = 0; x < 9; x++)
            {
                this.addSlotToContainer(new Slot(player, x, 8 + x * 18, 142));
            }
        }
        
        @Override
        public boolean canInteractWith(EntityPlayer playerIn) 
        {
            return this.tileentity.isUsableByPlayer(playerIn);
        }
        
        @Override
        public void updateProgressBar(int id, int data) 
        {
            this.tileentity.setField(id, data);
        }
        
        @Override
        public void detectAndSendChanges() 
        {
            super.detectAndSendChanges();
            
            for(int i = 0; i < this.listeners.size(); ++i) 
            {
                IContainerListener listener = (IContainerListener)this.listeners.get(i);
                
                if(this.cookTime != this.tileentity.getField(0)) listener.sendWindowProperty(this, 0, this.tileentity.getField(0));
                if(this.energy != this.tileentity.getField(1)) listener.sendWindowProperty(this, 1, this.tileentity.getField(1));
            }
            
            this.cookTime = this.tileentity.getField(0);
            this.energy = this.tileentity.getField(1);
        }
        
        @Override
        public ItemStack transferStackInSlot(EntityPlayer playerIn, int index) 
        {
            ItemStack stack = ItemStack.EMPTY;
            Slot slot = (Slot)this.inventorySlots.get(index);
            
            if(slot != null && slot.getHasStack()) 
            {
                ItemStack stack1 = slot.getStack();
                stack = stack1.copy();
                
                if(index == 2) 
                {
                    if(!this.mergeItemStack(stack1, 4, 40, true)) return ItemStack.EMPTY;
                    slot.onSlotChange(stack1, stack);
                }
                else if(index != 2 && index != 1 && index != 0) 
                {        
                    Slot slot1 = (Slot)this.inventorySlots.get(index + 1);
                    
                    if(!FusionReactorRecipes.getInstance().getSinteringResult(stack1, slot1.getStack()).isEmpty())
                    {
                        if(!this.mergeItemStack(stack1, 0, 2, false)) 
                        {
                            return ItemStack.EMPTY;
                        }
                        else if(index >= 4 && index < 31)
                        {
                            if(!this.mergeItemStack(stack1, 31, 40, false)) return ItemStack.EMPTY;
                        }
                        else if(index >= 31 && index < 40 && !this.mergeItemStack(stack1, 4, 31, false))
                        {
                            return ItemStack.EMPTY;
                        }
                    }
                } 
                else if(!this.mergeItemStack(stack1, 4, 40, false)) 
                {
                    return ItemStack.EMPTY;
                }
                if(stack1.isEmpty())
                {
                    slot.putStack(ItemStack.EMPTY);
                }
                else
                {
                    slot.onSlotChanged();

                }
                if(stack1.getCount() == stack.getCount()) return ItemStack.EMPTY;
                slot.onTake(playerIn, stack1);
            }
            return stack;
        }
    }

    Gui.class

    Spoiler

    package galileogalilei.ironmanarmormod.blocks.guis;

    import galileogalilei.ironmanarmormod.Reference;
    import galileogalilei.ironmanarmormod.blocks.containers.ContainerElectricFusionReactor;
    import galileogalilei.ironmanarmormod.blocks.tileentities.TileEntityElectricFusionReactor;
    import net.minecraft.client.gui.inventory.GuiContainer;
    import net.minecraft.client.renderer.GlStateManager;
    import net.minecraft.entity.player.InventoryPlayer;
    import net.minecraft.util.ResourceLocation;

    public class GuiElectricFusionReactor extends GuiContainer
    {
        private static final ResourceLocation TEXTURES = new ResourceLocation(Reference.MODID + ":textures/gui/electric_fusion_reactor.png");
        private final InventoryPlayer player;
        private final TileEntityElectricFusionReactor tileentity;
        
        public GuiElectricFusionReactor(InventoryPlayer player, TileEntityElectricFusionReactor tileentity) 
        {
            super(new ContainerElectricFusionReactor(player, tileentity));
            this.player = player;
            this.tileentity = tileentity;
        }
        
        @Override
        protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) 
        {
            String tileName = this.tileentity.getDisplayName().getUnformattedText();
            this.fontRenderer.drawString(tileName, (this.xSize / 2 - this.fontRenderer.getStringWidth(tileName) / 2) -5, 6, 4210752);
            this.fontRenderer.drawString(this.player.getDisplayName().getUnformattedText(), 7, this.ySize - 96 + 2, 4210752);
            this.fontRenderer.drawString(Integer.toString(this.tileentity.getEnergyStored()), 115, 72, 4210752);
        }
        
        @Override
        protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY)
        {
            GlStateManager.color(1.0f, 1.0f, 1.0f, 1.0f);
            this.mc.getTextureManager().bindTexture(TEXTURES);
            this.drawTexturedModalRect(this.guiLeft, this.guiTop, 0, 0, this.xSize, this.ySize);
            
            int l = this.getCookProgressScaled(24);
            this.drawTexturedModalRect(this.guiLeft + 63, this.guiTop + 36, 176, 14, l + 1, 16);
            
            int k = this.getEnergyStoredScaled(75);
            this.drawTexturedModalRect(this.guiLeft + 152, this.guiTop + 7, 176, 32, 16, 76 - k);
        }
        
        private int getCookProgressScaled(int pixels)
        {
            int i = this.tileentity.cookTime;
            return i != 0 ? i * pixels / 100 : 0;
        }
        
        private int getEnergyStoredScaled(int pixels)
        {
            int i = this.tileentity.getEnergyStored();
            int j = this.tileentity.getMaxEnergyStored();
            return i != 0 && j != 0 ? i * pixels / j : 0; 
        }
    }

    Machine/Block.class

    Spoiler

    package galileogalilei.ironmanarmormod.blocks.machines;

    import java.util.Random;

    import galileogalilei.ironmanarmormod.Main;
    import galileogalilei.ironmanarmormod.Reference;
    import galileogalilei.ironmanarmormod.blocks.BlockBase;
    import galileogalilei.ironmanarmormod.blocks.tileentities.TileEntityElectricFusionReactor;
    import galileogalilei.ironmanarmormod.init.BlockInit;
    import net.minecraft.block.BlockHorizontal;
    import net.minecraft.block.material.Material;
    import net.minecraft.block.properties.IProperty;
    import net.minecraft.block.properties.PropertyBool;
    import net.minecraft.block.properties.PropertyDirection;
    import net.minecraft.block.state.BlockStateContainer;
    import net.minecraft.block.state.IBlockState;
    import net.minecraft.entity.EntityLivingBase;
    import net.minecraft.entity.item.EntityItem;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemStack;
    import net.minecraft.tileentity.TileEntity;
    import net.minecraft.util.EnumBlockRenderType;
    import net.minecraft.util.EnumFacing;
    import net.minecraft.util.EnumHand;
    import net.minecraft.util.Mirror;
    import net.minecraft.util.Rotation;
    import net.minecraft.util.math.BlockPos;
    import net.minecraft.world.World;

    public class BlockElectricFusionReactor extends BlockBase
    {
        public static final PropertyDirection FACING = BlockHorizontal.FACING;
        public static final PropertyBool BURNING = PropertyBool.create("burning");
        
        public BlockElectricFusionReactor(String name) 
        {
            super(name, Material.IRON);
            setCreativeTab(Main.BLOCKS);
            this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(BURNING, false));
        }
        
        @Override
        public Item getItemDropped(IBlockState state, Random rand, int fortune) 
        {
            return Item.getItemFromBlock(BlockInit.ELECTRIC_FUSION_REACTOR);
        }
        
        @Override
        public ItemStack getItem(World worldIn, BlockPos pos, IBlockState state)
        {
            return new ItemStack(BlockInit.ELECTRIC_FUSION_REACTOR);
        }
        
        @Override
        public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) 
        {
            if(!worldIn.isRemote)
            {
                playerIn.openGui(Main.instance, Reference.GUI_ELECTRIC_FUSION_REACTOR, worldIn, pos.getX(), pos.getY(), pos.getZ());
            }
            
            return true;
        }
        
        @Override
        public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state) 
        {
            if (!worldIn.isRemote) 
            {
                IBlockState north = worldIn.getBlockState(pos.north());
                IBlockState south = worldIn.getBlockState(pos.south());
                IBlockState west = worldIn.getBlockState(pos.west());
                IBlockState east = worldIn.getBlockState(pos.east());
                EnumFacing face = (EnumFacing)state.getValue(FACING);

                if (face == EnumFacing.NORTH && north.isFullBlock() && !south.isFullBlock()) face = EnumFacing.SOUTH;
                else if (face == EnumFacing.SOUTH && south.isFullBlock() && !north.isFullBlock()) face = EnumFacing.NORTH;
                else if (face == EnumFacing.WEST && west.isFullBlock() && !east.isFullBlock()) face = EnumFacing.EAST;
                else if (face == EnumFacing.EAST && east.isFullBlock() && !west.isFullBlock()) face = EnumFacing.WEST;
                worldIn.setBlockState(pos, state.withProperty(FACING, face), 2);
            }
        }
        
        public static void setState(boolean active, World worldIn, BlockPos pos) 
        {
            IBlockState state = worldIn.getBlockState(pos);
            TileEntity tileentity = worldIn.getTileEntity(pos);
            
            if(active) worldIn.setBlockState(pos, BlockInit.ELECTRIC_FUSION_REACTOR.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, true), 3);
            else worldIn.setBlockState(pos, BlockInit.ELECTRIC_FUSION_REACTOR.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, false), 3);
            
            if(tileentity != null) 
            {
                tileentity.validate();
                worldIn.setTileEntity(pos, tileentity);
            }
        }
        
        @Override
        public boolean hasTileEntity() 
        {
            return true;
        }
        
        @Override
        public boolean hasTileEntity(IBlockState state)
        {
            return true;
        }
        
        @Override
        public TileEntity createTileEntity(World world, IBlockState state)
        {
            return new TileEntityElectricFusionReactor();
        }
        
        @Override
        public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer, EnumHand hand) 
        {
            return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
        }
        
        @Override
        public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) 
        {
            worldIn.setBlockState(pos, this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);
        }
        
        @Override
        public void breakBlock(World worldIn, BlockPos pos, IBlockState state) 
        {
            TileEntityElectricFusionReactor tileentity = (TileEntityElectricFusionReactor)worldIn.getTileEntity(pos);
            worldIn.spawnEntity(new EntityItem(worldIn, pos.getX(), pos.getY(), pos.getZ(), tileentity.handler.getStackInSlot(0)));
            worldIn.spawnEntity(new EntityItem(worldIn, pos.getX(), pos.getY(), pos.getZ(), tileentity.handler.getStackInSlot(1)));
            worldIn.spawnEntity(new EntityItem(worldIn, pos.getX(), pos.getY(), pos.getZ(), tileentity.handler.getStackInSlot(2)));
            super.breakBlock(worldIn, pos, state);
        }
        
        @Override
        public EnumBlockRenderType getRenderType(IBlockState state) 
        {
            return EnumBlockRenderType.MODEL;
        }
        
        @Override
        public IBlockState withRotation(IBlockState state, Rotation rot)
        {
            return state.withProperty(FACING, rot.rotate((EnumFacing)state.getValue(FACING)));
        }
        
        @Override
        public IBlockState withMirror(IBlockState state, Mirror mirrorIn) 
        {
            return state.withRotation(mirrorIn.toRotation((EnumFacing)state.getValue(FACING)));
        }
        
        @Override
        protected BlockStateContainer createBlockState() 
        {
            return new BlockStateContainer(this, new IProperty[] {BURNING,FACING});
        }
        
        @Override
        public IBlockState getStateFromMeta(int meta) 
        {
            EnumFacing facing = EnumFacing.getFront(meta);
            if(facing.getAxis() == EnumFacing.Axis.Y) facing = EnumFacing.NORTH;
            return this.getDefaultState().withProperty(FACING, facing);
        }
        
        @Override
        public int getMetaFromState(IBlockState state) 
        {
            return ((EnumFacing)state.getValue(FACING)).getIndex();
        }    
    }

    Can anyone help me please?

  5. 1 hour ago, ZigTheHedge said:

    In your blockstate json add a couple of "normal" variants with different rotations. For example:
     

    
    {
      "forge_marker": 1,
      "defaults": {
        "model": "modid:modblock"
      },
      "variants": {
        "normal": [
          {
            "model": "modid:modblock"
          },
          {
            "model": "modid:modblock",
            "y": 90
          },
          {
            "model": "modid:modblock",
            "y": 180
          },
          {
            "model": "modid:modblock",
            "y": 270
          }
        ],
        "inventory": [{
          "transform": "forge:default-block"
        }]
      }
    }

     

    so will the code look like this?

    Spoiler

    {
      "forge_marker": 1,
      "defaults": {
        "model": "imam:copper_ore"
      },
      "variants": {
        "normal": [
          {
            "model": "imam:copper_ore"
          },
          {
            "model": "imam:copper_ore",
            "y": 90
          },
          {
            "model": "imam:copper_ore",
            "y": 180
          },
          {
            "model": "imam:copper_ore",
            "y": 270
          }
        ],
         "inventory": [{
          "transform": "forge:default-block"
        }]
      }
    }

     

  6. So I've added an ore to my mod with a custom model. And when I put them side by side, it's pretty plain. Can anybody teach me how to add random block rotations so It's not always the same pattern? 

     

    copper_ore.json

    {
    	"credit": "Made with Blockbench",
    	"textures": {
    		"1": "imam:blocks/stone",
    		"2": "imam:blocks/copper",
    		"particle": "imam:blocks/copper"
    	},
    	"elements": [
    		{
    			"from": [0, 0, 0],
    			"to": [16, 16, 16],
    			"faces": {
    				"north": {"uv": [0, 0, 16, 16], "texture": "#1"},
    				"east": {"uv": [0, 0, 16, 16], "texture": "#1"},
    				"south": {"uv": [0, 0, 16, 16], "texture": "#1"},
    				"west": {"uv": [0, 0, 16, 16], "texture": "#1"},
    				"up": {"uv": [0, 0, 16, 16], "texture": "#1"},
    				"down": {"uv": [0, 0, 16, 16], "texture": "#1"}
    			}
    		},
    		{
    			"from": [12, 3, -3],
    			"to": [17, 9, 4],
    			"rotation": {"angle": 45, "axis": "x", "origin": [15.5, 3, 0.5]},
    			"faces": {
    				"north": {"uv": [0, 0, 5, 6], "texture": "#2"},
    				"east": {"uv": [0, 0, 7, 6], "texture": "#2"},
    				"south": {"uv": [0, 0, 5, 6], "texture": "#2"},
    				"west": {"uv": [0, 0, 7, 6], "texture": "#2"},
    				"up": {"uv": [0, 0, 5, 7], "texture": "#2"},
    				"down": {"uv": [0, 0, 5, 7], "texture": "#2"}
    			}
    		},
    		{
    			"from": [6, 1.5, 14.5],
    			"to": [11, 8.5, 20.5],
    			"rotation": {"angle": -22.5, "axis": "x", "origin": [15.5, 3, 0.5]},
    			"faces": {
    				"north": {"uv": [0, 0, 5, 7], "rotation": 180, "texture": "#2"},
    				"east": {"uv": [0, 0, 7, 6], "rotation": 270, "texture": "#2"},
    				"south": {"uv": [0, 0, 5, 7], "texture": "#2"},
    				"west": {"uv": [0, 0, 7, 6], "rotation": 90, "texture": "#2"},
    				"up": {"uv": [0, 0, 5, 6], "rotation": 180, "texture": "#2"},
    				"down": {"uv": [0, 0, 5, 6], "texture": "#2"}
    			}
    		},
    		{
    			"from": [-2, 1.5, 2.5],
    			"to": [3, 8.5, 8.5],
    			"rotation": {"angle": -22.5, "axis": "x", "origin": [15.5, 3, 0.5]},
    			"faces": {
    				"north": {"uv": [0, 0, 5, 7], "rotation": 180, "texture": "#2"},
    				"east": {"uv": [0, 0, 7, 6], "rotation": 270, "texture": "#2"},
    				"south": {"uv": [0, 0, 5, 7], "texture": "#2"},
    				"west": {"uv": [0, 0, 7, 6], "rotation": 90, "texture": "#2"},
    				"up": {"uv": [0, 0, 5, 6], "rotation": 180, "texture": "#2"},
    				"down": {"uv": [0, 0, 5, 6], "texture": "#2"}
    			}
    		},
    		{
    			"from": [18, 12, 7],
    			"to": [25, 18, 14],
    			"rotation": {"angle": 45, "axis": "z", "origin": [15.5, 3, 0.5]},
    			"faces": {
    				"north": {"uv": [0, 0, 7, 6], "rotation": 180, "texture": "#2"},
    				"east": {"uv": [0, 0, 7, 6], "rotation": 180, "texture": "#2"},
    				"south": {"uv": [0, 0, 7, 6], "rotation": 180, "texture": "#2"},
    				"west": {"uv": [0, 0, 7, 6], "rotation": 180, "texture": "#2"},
    				"up": {"uv": [0, 0, 7, 7], "texture": "#2"},
    				"down": {"uv": [0, 0, 7, 7], "texture": "#2"}
    			}
    		},
    		{
    			"from": [3, 7.5, 1.5],
    			"to": [10, 16.5, 8.5],
    			"rotation": {"angle": -22.5, "axis": "x", "origin": [15.5, 3, 0.5]},
    			"faces": {
    				"north": {"uv": [0, 0, 7, 9], "rotation": 180, "texture": "#2"},
    				"east": {"uv": [0, 0, 9, 7], "rotation": 270, "texture": "#2"},
    				"south": {"uv": [0, 0, 7, 9], "texture": "#2"},
    				"west": {"uv": [0, 0, 9, 7], "rotation": 90, "texture": "#2"},
    				"up": {"uv": [0, 0, 7, 7], "rotation": 180, "texture": "#2"},
    				"down": {"uv": [0, 0, 7, 7], "texture": "#2"}
    			}
    		},
    		{
    			"from": [7, 4.5, 9.5],
    			"to": [13, 13.5, 16.5],
    			"rotation": {"angle": 22.5, "axis": "y", "origin": [15.5, 3, 0.5]},
    			"faces": {
    				"north": {"uv": [0, 0, 6, 9], "rotation": 180, "texture": "#2"},
    				"east": {"uv": [0, 0, 9, 7], "rotation": 270, "texture": "#2"},
    				"south": {"uv": [0, 0, 6, 9], "texture": "#2"},
    				"west": {"uv": [0, 0, 9, 7], "rotation": 90, "texture": "#2"},
    				"up": {"uv": [0, 0, 6, 7], "rotation": 180, "texture": "#2"},
    				"down": {"uv": [0, 0, 6, 7], "texture": "#2"}
    			}
    		},
    		{
    			"from": [0, 11.5, 9.5],
    			"to": [6, 17.5, 16.5],
    			"rotation": {"angle": 22.5, "axis": "z", "origin": [15.5, 3, 0.5]},
    			"faces": {
    				"north": {"uv": [0, 0, 6, 6], "rotation": 180, "texture": "#2"},
    				"east": {"uv": [0, 0, 6, 7], "rotation": 270, "texture": "#2"},
    				"south": {"uv": [0, 0, 6, 6], "texture": "#2"},
    				"west": {"uv": [0, 0, 6, 7], "rotation": 90, "texture": "#2"},
    				"up": {"uv": [0, 0, 6, 7], "rotation": 180, "texture": "#2"},
    				"down": {"uv": [0, 0, 6, 7], "texture": "#2"}
    			}
    		},
    		{
    			"from": [1, 0.5, 6.5],
    			"to": [7, 6.5, 13.5],
    			"rotation": {"angle": 22.5, "axis": "z", "origin": [15.5, 3, 0.5]},
    			"faces": {
    				"north": {"uv": [0, 0, 6, 6], "rotation": 180, "texture": "#2"},
    				"east": {"uv": [0, 0, 6, 7], "rotation": 270, "texture": "#2"},
    				"south": {"uv": [0, 0, 6, 6], "texture": "#2"},
    				"west": {"uv": [0, 0, 6, 7], "rotation": 90, "texture": "#2"},
    				"up": {"uv": [0, 0, 6, 7], "rotation": 180, "texture": "#2"},
    				"down": {"uv": [0, 0, 6, 7], "texture": "#2"}
    			}
    		},
    		{
    			"from": [10, -6.5, -1.5],
    			"to": [16, 0.5, 4.5],
    			"rotation": {"angle": -22.5, "axis": "z", "origin": [15.5, 3, 0.5]},
    			"faces": {
    				"north": {"uv": [0, 0, 6, 7], "rotation": 180, "texture": "#2"},
    				"east": {"uv": [0, 0, 7, 6], "rotation": 270, "texture": "#2"},
    				"south": {"uv": [0, 0, 6, 7], "texture": "#2"},
    				"west": {"uv": [0, 0, 7, 6], "rotation": 90, "texture": "#2"},
    				"up": {"uv": [0, 0, 6, 6], "rotation": 180, "texture": "#2"},
    				"down": {"uv": [0, 0, 6, 6], "texture": "#2"}
    			}
    		}
    	]
    }

     

  7. So recently, I've been using Tabula for modelling my armor in my mod. But the weird thing is, it's acting weird, I've made a model but this  shows up:

    And I actually have to do this to put it in the right position:

    Can anybody help me?

    2019-08-05_21.04.37.png

    unknown.png

  8. So I made a custom model for my armor and when I tried it out, the model works but the texture doesn't.

    Here's my model code:

    package com.galileogalilei.ironmanarmormod.model;
    
    import net.minecraft.client.model.ModelBiped;
    import net.minecraft.client.model.ModelRenderer;
    import net.minecraft.entity.Entity;
    
    public class ModelVArmor extends ModelBiped {
    	
        ModelRenderer Headset1;
        ModelRenderer Headset2;
        ModelRenderer Headset3;
        ModelRenderer Spaulder;
      
      public ModelVArmor(float scale) {
    	  super(scale, 0, 64, 64);
    	  
    	  textureWidth = 64;
    	  textureHeight = 64;
        
          Headset1 = new ModelRenderer(this, 0, 32);
          Headset1.addBox(4F, -4F, -3F, 1, 2, 2);
          Headset1.setRotationPoint(0F, 0F, 0F);
          Headset1.setTextureSize(64, 32);
          Headset1.mirror = true;
          setRotation(Headset1, 0F, 0F, 0F);
          
          Headset2 = new ModelRenderer(this, 6, 32);
          Headset2.addBox(4F, -2F, -4F, 1, 1, 1);
          Headset2.setRotationPoint(0F, 0F, 0F);
          Headset2.setTextureSize(64, 32);
          Headset2.mirror = true;
          setRotation(Headset2, 0F, 0F, 0F);
          
          Headset3 = new ModelRenderer(this, 10, 32);
          Headset3.addBox(1F, -1F, -5F, 3, 1, 1);
          Headset3.setRotationPoint(0F, 0F, 0F);
          Headset3.setTextureSize(64, 32);
          Headset3.mirror = true;
          setRotation(Headset3, 0F, 0F, 0F);
          
          Spaulder = new ModelRenderer(this, 0, 36);
          Spaulder.addBox(-0.8F, -3.5F, -2F, 5, 5, 5);
          Spaulder.setRotationPoint(0F, 0F, 0F);
          Spaulder.setTextureSize(64, 32);
          Spaulder.mirror = true;
          setRotation(Spaulder, 0F, 0F, 0.3490659F);
          
          bipedHead.addChild(Headset1);
          bipedHead.addChild(Headset2);
          bipedHead.addChild(Headset3);
          bipedLeftArm.addChild(Spaulder);
      }
      
      public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5) {
        super.render(entity, f, f1, f2, f3, f4, f5);
        setRotationAngles(f, f1, f2, f3, f4, f5, entity);
      }
      
      private void setRotation(ModelRenderer model, float x, float y, float z) {
        model.rotateAngleX = x;
        model.rotateAngleY = y;
        model.rotateAngleZ = z;
      }
    }

    And here's the code for my item:

    package com.galileogalilei.ironmanarmormod.item;
    
    import com.galileogalilei.ironmanarmormod.Main;
    import com.galileogalilei.ironmanarmormod.init.ItemInit;
    import com.galileogalilei.ironmanarmormod.model.ModelVArmor;
    
    import net.minecraft.client.model.ModelBiped;
    import net.minecraft.creativetab.CreativeTabs;
    import net.minecraft.entity.EntityLivingBase;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.inventory.EntityEquipmentSlot;
    import net.minecraft.item.ItemArmor;
    import net.minecraft.item.ItemStack;
    import net.minecraft.potion.Potion;
    import net.minecraft.potion.PotionEffect;
    import net.minecraft.world.World;
    
    public class ItemMark5Armor extends ItemArmor {
    
    	public ItemMark5Armor(ArmorMaterial materialIn, int renderIndexIn, EntityEquipmentSlot equipmentSlotIn) {
    		super(materialIn, renderIndexIn, equipmentSlotIn);
    		this.setCreativeTab(CreativeTabs.COMBAT);
    		this.setMaxStackSize(1);
    	}
    	
    	@Override
    	public void onArmorTick(World world, EntityPlayer player, ItemStack itemStack) {
    		if (player.inventory.armorItemInSlot(3) != null && player.inventory.armorItemInSlot(3).getItem() == ItemInit.MARK_5_HELMET
    				&& player.inventory.armorItemInSlot(2) != null && player.inventory.armorItemInSlot(2).getItem() == ItemInit.MARK_5_CHESTPLATE
    				&& player.inventory.armorItemInSlot(1) != null && player.inventory.armorItemInSlot(1).getItem() == ItemInit.MARK_5_LEGGINGS
    				&& player.inventory.armorItemInSlot(0) != null && player.inventory.armorItemInSlot(0).getItem() == ItemInit.MARK_5_BOOTS) {
    			this.effectPlayer(player, Main.FLY_POTION, 0);
    		}
    	}
    	
    	private void effectPlayer(EntityPlayer player, Potion potion, int amplifier) {
    		if (player.getActivePotionEffect(potion) == null || player.getActivePotionEffect(potion).getDuration() <= 1)
    				player.addPotionEffect(new PotionEffect(potion, 159, amplifier, false, false));
    	}
    	
    	@Override
    	public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, EntityEquipmentSlot armorSlot, ModelBiped _default) {
    		if(!itemStack.isEmpty()) {
    			if(itemStack.getItem() instanceof ItemArmor) {
    				
    				ModelVArmor armorModel = new ModelVArmor(1.0f);
    				ModelVArmor armorModelLegs = new ModelVArmor(0.5f);
    				
    				armorModel.bipedHead.showModel = armorSlot == EntityEquipmentSlot.HEAD;
    				armorModel.bipedHeadwear.showModel = armorSlot == EntityEquipmentSlot.HEAD;
    				armorModel.bipedBody.showModel = (armorSlot == EntityEquipmentSlot.CHEST) || (armorSlot == EntityEquipmentSlot.CHEST);
    				armorModel.bipedRightArm.showModel = armorSlot == EntityEquipmentSlot.CHEST;
    				armorModel.bipedLeftArm.showModel = armorSlot == EntityEquipmentSlot.CHEST;
    				armorModelLegs.bipedRightLeg.showModel = (armorSlot == EntityEquipmentSlot.LEGS) || (armorSlot == EntityEquipmentSlot.FEET);
    				armorModelLegs.bipedLeftLeg.showModel = (armorSlot == EntityEquipmentSlot.LEGS) || (armorSlot == EntityEquipmentSlot.FEET);
    
    				armorModel.isSneak = _default.isSneak;
    				armorModel.isRiding = _default.isRiding;
    				armorModel.isChild = _default.isChild;
    				armorModel.rightArmPose = _default.rightArmPose;
    				armorModel.leftArmPose = _default.leftArmPose;
    				
    				armorModelLegs.isSneak = _default.isSneak;
    				armorModelLegs.isRiding = _default.isRiding;
    				armorModelLegs.isChild = _default.isChild;
    				armorModelLegs.rightArmPose = _default.rightArmPose;
    				armorModelLegs.leftArmPose = _default.leftArmPose;
    
    				return armorModel;
    			}
    		}
    		
    		return null;
    	}
    }

    Can anyone help?

  9. Hi, I have created an item for my mod and I have decided to add a description for it.

    Here's my code:

    package com.galileogalilei.ironmanarmormod.init;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import com.galileogalilei.ironmanarmormod.objects.items.ItemBase;
    
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemStack;
    
    public class ItemInit 
    {
    	public static final List<Item> ITEMS = new ArrayList<Item>();
    	
    	public static Item ARC_REACTOR = new ItemBase("arc_reactor");
    	
    	public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par2List, boolean par4) {
    		Item itemfordesc = null;
    		if (itemfordesc == ItemInit.ARC_REACTOR) {
    		par2List.add("\u00a7a" + "Proof Tony Stark has a Heart.");
    		}
    		}
    }

    But it doesn't seem to work, anyone has any idea why?

  10. On 5/23/2019 at 5:48 PM, Cadiboo said:

    You’ll need to write your own renderer that takes the parts of the textures from 1 file instead of two. As far as I can see, there is no advantage to doing this though.

    I've finally made my renderer but there's a problem.

    Here's my code:

    package com.galileogalilei.ironmanarmormod.client.model;

    import net.minecraft.client.model.ModelBase;
    import net.minecraft.client.model.ModelRenderer;
    import net.minecraft.client.renderer.GlStateManager;
    import net.minecraft.entity.Entity;
    import net.minecraft.entity.EntityLivingBase;
    import net.minecraft.util.EnumHand;
    import net.minecraft.util.EnumHandSide;
    import net.minecraft.util.math.MathHelper;

    public class ModelSuits
      extends ModelBase
    {
      public class ArmPose {

        }

    private static final String ArmPose = null;
    public ModelRenderer field_78116_c;
      public ModelRenderer field_178720_f;
      public ModelRenderer field_78115_e;
      public ModelRenderer field_178723_h;
      public ModelRenderer field_178724_i;
      public ModelRenderer field_178721_j;
      public ModelRenderer field_178722_k;
      public String field_187075_l = ModelSuits.ArmPose;
      public String field_187076_m = ModelSuits.ArmPose;
      public boolean field_78117_n;
      
      public ModelSuits() {
        this(0.0F);
      }
      
      public ModelSuits(float ☃) 
      {
        this(☃, 0.0F, 64, 64);
      }
     

×
×
  • Create New...

Important Information

By using this site, you agree to our Privacy Policy.