Jump to content

JimiIT92

Members
  • Posts

    866
  • Joined

  • Last visited

  • Days Won

    3

Posts posted by JimiIT92

  1. First, you need to do a class that implements IWorldGenerator, for example i use this (it also show you how to generate a metada blocks and flowers! :) )

    public class WorldGenMinableMW implements IWorldGenerator {
    
    @Override
    public void generate(Random random, int chunkX, int chunkZ, World world,
    		IChunkProvider chunkGenerator, IChunkProvider chunkProvider) {
    
    	switch(world.provider.getDimensionId()) {
    		case 0:
    			generateOverworld(random, world, chunkX*16, chunkZ*16);
    			break;
    		default:
    			generateOverworld(random, world, chunkX*16, chunkZ*16);
    	}
    
    }
    
    private void generateOverworld(Random random, World world, int x, int z) {
    	addOres(MWBlocks.ruby_ore, world, random, x, z, 4, 5, 0, 16);
    	addMetaOres(MWMetadataBlocks.marble.getStateFromMeta(0), world, random, x, z, 6, 15, 0, 30);
    	addMetaOres(MWMetadataBlocks.marble.getStateFromMeta(1), world, random, x, z, 6, 15, 0, 30);
    
    	for(int i = 0; i < 2; i++)
    	{
    		int randPosX = x + random.nextInt(16);
    		int randPosY = random.nextInt(250);
    		int randPosZ = z + random.nextInt(16);
    		(new WorldGenFlowers((BlockFlower)MWBlocks.blue_flower, BlockFlower.EnumFlowerType.DANDELION)).generate(world, random, new BlockPos(randPosX, randPosY, randPosZ));
    	}
    
    }
    
    private void addOres(Block block, World world, Random random, int blockXpos, int blockZpos, int MaxVein, int spawnChance, int minY, int maxY) {
    
    	WorldGenMinable minable = new WorldGenMinable(block.getDefaultState(), random.nextInt(MaxVein));
    	for (int i = 0; i < spawnChance; i++) {
    		int posX = blockXpos + random.nextInt(16);
    		int posZ = blockZpos + random.nextInt(16);
    		int posY = minY + random.nextInt(maxY - minY);
    		minable.generate(world, random, new BlockPos(posX, posY, posZ));
    	}
    
    }
    
    private void addMetaOres(IBlockState block, World world, Random random, int blockXpos, int blockZpos, int MaxVein, int spawnChance, int minY, int maxY) {
    
    	WorldGenMinable minable = new WorldGenMinable(block, random.nextInt(MaxVein));
    	for (int i = 0; i < spawnChance; i++) {
    		int posX = blockXpos + random.nextInt(16);
    		int posZ = blockZpos + random.nextInt(16);
    		int posY = minY + random.nextInt(maxY - minY);
    		minable.generate(world, random, new BlockPos(posX, posY, posZ));
    	}
    
    }
    }
    

     

    Then you need to register that class as a world generator by doing this in the init event of your main mod class (or in a sub class called by that method)

    GameRegistry.registerWorldGenerator(new WorldGenMinableMW(), 1);
    

     

    After this you're fine and your ores should generate as well :)

  2. As by title, if i shoot an arrow with my custom bow, the arrow is not shoot but instead hits the player

     

    Here is my class for the bow (wich i use for many bows, just to not duplicate the code)

    package mw.items;
    
    import mw.core.MW;
    import mw.core.utils.Utils;
    import mw.entities.projectile.EntityAluminiumArrow;
    import mw.entities.projectile.EntityBronzeArrow;
    import mw.entities.projectile.EntityCopperArrow;
    import mw.entities.projectile.EntityFlameArrow;
    import mw.entities.projectile.EntityRubyArrow;
    import mw.entities.projectile.EntitySapphireArrow;
    import mw.entities.projectile.EntitySilverArrow;
    import mw.entities.projectile.dimensions.EntitySacredArrow;
    import net.minecraft.client.resources.model.ModelResourceLocation;
    import net.minecraft.enchantment.Enchantment;
    import net.minecraft.enchantment.EnchantmentHelper;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.entity.projectile.EntityArrow;
    import net.minecraft.item.EnumAction;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemBow;
    import net.minecraft.item.ItemStack;
    import net.minecraft.world.World;
    import net.minecraftforge.common.MinecraftForge;
    import net.minecraftforge.event.entity.player.ArrowLooseEvent;
    import net.minecraftforge.event.entity.player.ArrowNockEvent;
    
    public class ItemBowMW extends ItemBow {
    
    public static final String[] bowPullIconNameArray = new String[] {"pulling_0", "pulling_1", "pulling_2"};
    private Item arrows;
    private String name;
    
    public ItemBowMW(Item arrows, String name)
    {
    	super();
    	Utils.setCombatItemInfo(this, name);
    	this.arrows = arrows;
    	this.name = name;
    }
    
    @Override
    public void onPlayerStoppedUsing(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer, int par4)
    {
    	int j = this.getMaxItemUseDuration(par1ItemStack) - par4;
    
    	ArrowLooseEvent event = new ArrowLooseEvent(par3EntityPlayer, par1ItemStack, j);
    	MinecraftForge.EVENT_BUS.post(event);
    	if (event.isCanceled())
    	{
    		return;
    	}
    	j = event.charge;
    
    	boolean flag = par3EntityPlayer.capabilities.isCreativeMode || EnchantmentHelper.getEnchantmentLevel(Enchantment.infinity.effectId, par1ItemStack) > 0;
    
    	if (flag || par3EntityPlayer.inventory.hasItem(arrows))
    	{
    		float f = (float)j / 20.0F;
    		f = (f * f + f * 2.0F) / 3.0F;
    
    		if ((double)f < 0.1D)
    		{
    			return;
    		}
    
    		if (f > 1.0F)
    		{
    			f = 1.0F;
    		}
    
    		EntityArrow entityarrow = null;
    
    
    		if(name.equals("ruby_bow"))
    		{
    			entityarrow = new EntityRubyArrow(par2World, par3EntityPlayer, f * 2.0F, 0, arrows);
    		}
    		if(name.equals("sapphire_bow"))
    		{
    			entityarrow = new EntitySapphireArrow(par2World, par3EntityPlayer, f * 2.0F, 0, arrows);
    		}
    		if(name.equals("copper_bow"))
    		{
    			entityarrow = new EntityCopperArrow(par2World, par3EntityPlayer, f * 2.0F, 0, arrows);;
    		}
    		if(name.equals("bronze_bow"))
    		{
    			entityarrow = new EntityBronzeArrow(par2World, par3EntityPlayer, f * 2.0F, 0, arrows);
    		}
    		if(name.equals("silver_bow"))
    		{
    			entityarrow = new EntitySilverArrow(par2World, par3EntityPlayer, f * 2.0F, 0, arrows);
    		}
    		if(name.equals("aluminium_bow"))
    		{
    			entityarrow = new EntityAluminiumArrow(par2World, par3EntityPlayer, f * 2.0F, 0, arrows);
    		}
    		if(name.equals("flame_bow"))
    		{
    			entityarrow = new EntityFlameArrow(par2World, par3EntityPlayer, f * 2.0F, 0, arrows);
    			entityarrow.setFire(50);
    		}
    		if(name.equals("sacred_bow"))
    		{
    			entityarrow = new EntitySacredArrow(par2World, par3EntityPlayer, f * 2.0F, 0, arrows);
    		}
    
    		if (f == 1.0F)
    		{
    			entityarrow.setIsCritical(true);
    		}
    
    		int k = EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, par1ItemStack);
    
    		if (k > 0)
    		{
    			entityarrow.setDamage(entityarrow.getDamage() + (double)k * 0.5D + 0.5D);
    		}
    
    		int l = EnchantmentHelper.getEnchantmentLevel(Enchantment.punch.effectId, par1ItemStack);
    
    		if (l > 0)
    		{
    			entityarrow.setKnockbackStrength(l);
    		}
    
    		if (EnchantmentHelper.getEnchantmentLevel(Enchantment.flame.effectId, par1ItemStack) > 0)
    		{
    			entityarrow.setFire(100);
    		}
    
    		par1ItemStack.damageItem(1, par3EntityPlayer);
    		par2World.playSoundAtEntity(par3EntityPlayer, "random.bow", 1.0F, 1.0F / (itemRand.nextFloat() * 0.4F + 1.2F) + f * 0.5F);
    		if(entityarrow instanceof EntityFlameArrow)
    			par2World.playSoundAtEntity(par3EntityPlayer, "fire.fire", 1.0F, 1.0F / (itemRand.nextFloat() * 0.4F + 1.2F) + f * 0.5F);
    
    		if (flag)
    		{
    			entityarrow.canBePickedUp = 1;
    		}
    		else
    		{
    			par3EntityPlayer.inventory.consumeInventoryItem(arrows);
    		}
    
    		if (!par2World.isRemote)
    		{
    			par2World.spawnEntityInWorld(entityarrow);
    		}
    	}
    }
    
    public ItemStack onEaten(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
    {
    	return par1ItemStack;
    }
    
    public int getMaxItemUseDuration(ItemStack par1ItemStack)
    {
    	return 72000;
    }
    
    public EnumAction getItemUseAction(ItemStack par1ItemStack)
    {
    	return EnumAction.BOW;
    }
    
    @Override
        public ModelResourceLocation getModel(ItemStack stack, EntityPlayer player, int useRemaining)
        {
            ModelResourceLocation modelresourcelocation = new ModelResourceLocation(MW.MODID + ":" + name, "inventory");
    
            if(stack.getItem() == this && player.getItemInUse() != null)
            {
                if(useRemaining >= 18)
                {
                    modelresourcelocation = new ModelResourceLocation(MW.MODID + ":" + name + "_" + bowPullIconNameArray[2], "inventory");
                }
                else if(useRemaining > 13)
                {
                    modelresourcelocation = new ModelResourceLocation(MW.MODID + ":" + name + "_" + bowPullIconNameArray[1], "inventory");
                }
                else if(useRemaining > 0)
                {
                    modelresourcelocation = new ModelResourceLocation(MW.MODID + ":" + name + "_" + bowPullIconNameArray[0], "inventory");
                }
            }
            return modelresourcelocation;
        }
    
    @Override
    public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
    {
    	ArrowNockEvent event = new ArrowNockEvent(par3EntityPlayer, par1ItemStack);
    	MinecraftForge.EVENT_BUS.post(event);
    	if (event.isCanceled())
    	{
    		return event.result;
    	}
    
    	if (par3EntityPlayer.capabilities.isCreativeMode || par3EntityPlayer.inventory.hasItem(arrows))
    	{
    		par3EntityPlayer.setItemInUse(par1ItemStack, this.getMaxItemUseDuration(par1ItemStack));
    	}
    
    	return par1ItemStack;
    }
    
    public int getItemEnchantability()
    {
    	return 1;
    }
    
    }
    

     

    This is an EntityArrow (they're pretty much all the same)

    package mw.entities.projectile.dimensions;
    
    import java.util.List;
    
    import mw.core.MWItems;
    import net.minecraft.block.Block;
    import net.minecraft.block.material.Material;
    import net.minecraft.block.state.IBlockState;
    import net.minecraft.enchantment.EnchantmentHelper;
    import net.minecraft.entity.Entity;
    import net.minecraft.entity.EntityLivingBase;
    import net.minecraft.entity.IProjectile;
    import net.minecraft.entity.monster.EntityEnderman;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.entity.player.EntityPlayerMP;
    import net.minecraft.entity.projectile.EntityArrow;
    import net.minecraft.init.Items;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemStack;
    import net.minecraft.nbt.NBTTagCompound;
    import net.minecraft.network.play.server.S2BPacketChangeGameState;
    import net.minecraft.util.AxisAlignedBB;
    import net.minecraft.util.BlockPos;
    import net.minecraft.util.DamageSource;
    import net.minecraft.util.EnumParticleTypes;
    import net.minecraft.util.MathHelper;
    import net.minecraft.util.MovingObjectPosition;
    import net.minecraft.util.ResourceLocation;
    import net.minecraft.util.Vec3;
    import net.minecraft.world.World;
    import net.minecraftforge.fml.relauncher.Side;
    import net.minecraftforge.fml.relauncher.SideOnly;
    
    public class EntitySacredArrow extends EntityArrow implements IProjectile
    {
        private int xTile = -1;
        private int yTile = -1;
        private int zTile = -1;
        private Block inTile;
        private int inData;
        private boolean inGround;
        /** 1 if the player can pick up the arrow */
        public int canBePickedUp;
        /** Seems to be some sort of timer for animating an arrow. */
        public int arrowShake;
        /** The owner of this arrow. */
        public Entity shootingEntity;
        private int ticksInGround;
        private int ticksInAir;
        private double damage = 2.0D;
        /** The amount of knockback an arrow applies when it hits a mob. */
        private int knockbackStrength;
    
        public EntitySacredArrow(World worldIn)
        {
            super(worldIn);
            this.renderDistanceWeight = 10.0D;
            this.setSize(0.5F, 0.5F);
        }
    
        public EntitySacredArrow(World worldIn, double x, double y, double z)
        {
            super(worldIn);
            this.renderDistanceWeight = 10.0D;
            this.setSize(0.5F, 0.5F);
            this.setPosition(x, y, z);
        }
    
        public EntitySacredArrow(World worldIn, EntityLivingBase shooter, EntityLivingBase p_i1755_3_, float p_i1755_4_, float p_i1755_5_)
        {
            super(worldIn);
            this.renderDistanceWeight = 10.0D;
            this.shootingEntity = shooter;
    
            if (shooter instanceof EntityPlayer)
            {
                this.canBePickedUp = 1;
            }
    
            this.posY = shooter.posY + (double)shooter.getEyeHeight() - 0.10000000149011612D;
            double d0 = p_i1755_3_.posX - shooter.posX;
            double d1 = p_i1755_3_.getEntityBoundingBox().minY + (double)(p_i1755_3_.height / 3.0F) - this.posY;
            double d2 = p_i1755_3_.posZ - shooter.posZ;
            double d3 = (double)MathHelper.sqrt_double(d0 * d0 + d2 * d2);
    
            if (d3 >= 1.0E-7D)
            {
                float f2 = (float)(Math.atan2(d2, d0) * 180.0D / Math.PI) - 90.0F;
                float f3 = (float)(-(Math.atan2(d1, d3) * 180.0D / Math.PI));
                double d4 = d0 / d3;
                double d5 = d2 / d3;
                this.setLocationAndAngles(shooter.posX + d4, this.posY, shooter.posZ + d5, f2, f3);
                float f4 = (float)(d3 * 0.20000000298023224D);
                this.setThrowableHeading(d0, d1 + (double)f4, d2, p_i1755_4_, p_i1755_5_);
            }
        }
    
        public EntitySacredArrow(World worldIn, EntityLivingBase shooter, float p_i1756_3_, int p4, Item item)
        {
            super(worldIn);
            this.renderDistanceWeight = 10.0D;
            this.shootingEntity = shooter;
    
            if (shooter instanceof EntityPlayer)
            {
                this.canBePickedUp = 1;
            }
    
            this.setSize(0.5F, 0.5F);
            this.setLocationAndAngles(shooter.posX, shooter.posY + (double)shooter.getEyeHeight(), shooter.posZ, shooter.rotationYaw, shooter.rotationPitch);
            this.posX -= (double)(MathHelper.cos(this.rotationYaw / 180.0F * (float)Math.PI) * 0.16F);
            this.posY -= 0.10000000149011612D;
            this.posZ -= (double)(MathHelper.sin(this.rotationYaw / 180.0F * (float)Math.PI) * 0.16F);
            this.setPosition(this.posX, this.posY, this.posZ);
            this.motionX = (double)(-MathHelper.sin(this.rotationYaw / 180.0F * (float)Math.PI) * MathHelper.cos(this.rotationPitch / 180.0F * (float)Math.PI));
            this.motionZ = (double)(MathHelper.cos(this.rotationYaw / 180.0F * (float)Math.PI) * MathHelper.cos(this.rotationPitch / 180.0F * (float)Math.PI));
            this.motionY = (double)(-MathHelper.sin(this.rotationPitch / 180.0F * (float)Math.PI));
            this.setThrowableHeading(this.motionX, this.motionY, this.motionZ, p_i1756_3_ * 1.5F, 1.0F);
        }
    
        protected void entityInit()
        {
            this.dataWatcher.addObject(16, Byte.valueOf((byte)0));
        }
    
        /**
         * Similar to setArrowHeading, it's point the throwable entity to a x, y, z direction.
         *  
         * @param inaccuracy Higher means more error.
         */
        public void setThrowableHeading(double x, double y, double z, float velocity, float inaccuracy)
        {
            float f2 = MathHelper.sqrt_double(x * x + y * y + z * z);
            x /= (double)f2;
            y /= (double)f2;
            z /= (double)f2;
            x += this.rand.nextGaussian() * (double)(this.rand.nextBoolean() ? -1 : 1) * 0.007499999832361937D * (double)inaccuracy;
            y += this.rand.nextGaussian() * (double)(this.rand.nextBoolean() ? -1 : 1) * 0.007499999832361937D * (double)inaccuracy;
            z += this.rand.nextGaussian() * (double)(this.rand.nextBoolean() ? -1 : 1) * 0.007499999832361937D * (double)inaccuracy;
            x *= (double)velocity;
            y *= (double)velocity;
            z *= (double)velocity;
            this.motionX = x;
            this.motionY = y;
            this.motionZ = z;
            float f3 = MathHelper.sqrt_double(x * x + z * z);
            this.prevRotationYaw = this.rotationYaw = (float)(Math.atan2(x, z) * 180.0D / Math.PI);
            this.prevRotationPitch = this.rotationPitch = (float)(Math.atan2(y, (double)f3) * 180.0D / Math.PI);
            this.ticksInGround = 0;
        }
    
        @SideOnly(Side.CLIENT)
        public void func_180426_a(double p_180426_1_, double p_180426_3_, double p_180426_5_, float p_180426_7_, float p_180426_8_, int p_180426_9_, boolean p_180426_10_)
        {
            this.setPosition(p_180426_1_, p_180426_3_, p_180426_5_);
            this.setRotation(p_180426_7_, p_180426_8_);
        }
    
        /**
         * Sets the velocity to the args. Args: x, y, z
         */
        @SideOnly(Side.CLIENT)
        public void setVelocity(double x, double y, double z)
        {
            this.motionX = x;
            this.motionY = y;
            this.motionZ = z;
    
            if (this.prevRotationPitch == 0.0F && this.prevRotationYaw == 0.0F)
            {
                float f = MathHelper.sqrt_double(x * x + z * z);
                this.prevRotationYaw = this.rotationYaw = (float)(Math.atan2(x, z) * 180.0D / Math.PI);
                this.prevRotationPitch = this.rotationPitch = (float)(Math.atan2(y, (double)f) * 180.0D / Math.PI);
                this.prevRotationPitch = this.rotationPitch;
                this.prevRotationYaw = this.rotationYaw;
                this.setLocationAndAngles(this.posX, this.posY, this.posZ, this.rotationYaw, this.rotationPitch);
                this.ticksInGround = 0;
            }
        }
    
        /**
         * Called to update the entity's position/logic.
         */
        public void onUpdate()
        {
            super.onUpdate();
    
            if (this.prevRotationPitch == 0.0F && this.prevRotationYaw == 0.0F)
            {
                float f = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionZ * this.motionZ);
                this.prevRotationYaw = this.rotationYaw = (float)(Math.atan2(this.motionX, this.motionZ) * 180.0D / Math.PI);
                this.prevRotationPitch = this.rotationPitch = (float)(Math.atan2(this.motionY, (double)f) * 180.0D / Math.PI);
            }
    
            BlockPos blockpos = new BlockPos(this.xTile, this.yTile, this.zTile);
            IBlockState iblockstate = this.worldObj.getBlockState(blockpos);
            Block block = iblockstate.getBlock();
    
            if (block.getMaterial() != Material.air)
            {
                block.setBlockBoundsBasedOnState(this.worldObj, blockpos);
                AxisAlignedBB axisalignedbb = block.getCollisionBoundingBox(this.worldObj, blockpos, iblockstate);
    
                if (axisalignedbb != null && axisalignedbb.isVecInside(new Vec3(this.posX, this.posY, this.posZ)))
                {
                    this.inGround = true;
                }
            }
    
            if (this.arrowShake > 0)
            {
                --this.arrowShake;
            }
    
            if (this.inGround)
            {
                int j = block.getMetaFromState(iblockstate);
    
                if (block == this.inTile && j == this.inData)
                {
                    ++this.ticksInGround;
    
                    if (this.ticksInGround >= 1200)
                    {
                        this.setDead();
                    }
                }
                else
                {
                    this.inGround = false;
                    this.motionX *= (double)(this.rand.nextFloat() * 0.2F);
                    this.motionY *= (double)(this.rand.nextFloat() * 0.2F);
                    this.motionZ *= (double)(this.rand.nextFloat() * 0.2F);
                    this.ticksInGround = 0;
                    this.ticksInAir = 0;
                }
            }
            else
            {
                ++this.ticksInAir;
                Vec3 vec31 = new Vec3(this.posX, this.posY, this.posZ);
                Vec3 vec3 = new Vec3(this.posX + this.motionX, this.posY + this.motionY, this.posZ + this.motionZ);
                MovingObjectPosition movingobjectposition = this.worldObj.rayTraceBlocks(vec31, vec3, false, true, false);
                vec31 = new Vec3(this.posX, this.posY, this.posZ);
                vec3 = new Vec3(this.posX + this.motionX, this.posY + this.motionY, this.posZ + this.motionZ);
    
                if (movingobjectposition != null)
                {
                    vec3 = new Vec3(movingobjectposition.hitVec.xCoord, movingobjectposition.hitVec.yCoord, movingobjectposition.hitVec.zCoord);
                }
    
                Entity entity = null;
                List list = this.worldObj.getEntitiesWithinAABBExcludingEntity(this, this.getEntityBoundingBox().addCoord(this.motionX, this.motionY, this.motionZ).expand(1.0D, 1.0D, 1.0D));
                double d0 = 0.0D;
                int i;
                float f1;
    
                for (i = 0; i < list.size(); ++i)
                {
                    Entity entity1 = (Entity)list.get(i);
    
                    if (entity1.canBeCollidedWith() && (entity1 != this.shootingEntity || this.ticksInAir >= 5))
                    {
                        f1 = 0.3F;
                        AxisAlignedBB axisalignedbb1 = entity1.getEntityBoundingBox().expand((double)f1, (double)f1, (double)f1);
                        MovingObjectPosition movingobjectposition1 = axisalignedbb1.calculateIntercept(vec31, vec3);
    
                        if (movingobjectposition1 != null)
                        {
                            double d1 = vec31.distanceTo(movingobjectposition1.hitVec);
    
                            if (d1 < d0 || d0 == 0.0D)
                            {
                                entity = entity1;
                                d0 = d1;
                            }
                        }
                    }
                }
    
                if (entity != null)
                {
                    movingobjectposition = new MovingObjectPosition(entity);
                }
    
                if (movingobjectposition != null && movingobjectposition.entityHit != null && movingobjectposition.entityHit instanceof EntityPlayer)
                {
                    EntityPlayer entityplayer = (EntityPlayer)movingobjectposition.entityHit;
    
                    if (entityplayer.capabilities.disableDamage || this.shootingEntity instanceof EntityPlayer && !((EntityPlayer)this.shootingEntity).canAttackPlayer(entityplayer))
                    {
                        movingobjectposition = null;
                    }
                }
    
                float f2;
                float f3;
                float f4;
    
                if (movingobjectposition != null)
                {
                    if (movingobjectposition.entityHit != null)
                    {
                        f2 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionY * this.motionY + this.motionZ * this.motionZ);
                        int k = MathHelper.ceiling_double_int((double)f2 * this.damage);
    
                        if (this.getIsCritical())
                        {
                            k += this.rand.nextInt(k / 2 + 2);
                        }
    
                        DamageSource damagesource;
    
                        if (this.shootingEntity == null)
                        {
                            damagesource = MWItems.causeSacredArrowDamage(this, this);
                        }
                        else
                        {
                            damagesource = MWItems.causeSacredArrowDamage(this, this.shootingEntity);
                        }
    
                        if (this.isBurning() && !(movingobjectposition.entityHit instanceof EntityEnderman))
                        {
                            movingobjectposition.entityHit.setFire(5);
                        }
    
                        if (movingobjectposition.entityHit.attackEntityFrom(damagesource, (float)k))
                        {
                            if (movingobjectposition.entityHit instanceof EntityLivingBase)
                            {
                                EntityLivingBase entitylivingbase = (EntityLivingBase)movingobjectposition.entityHit;
    
                                if (!this.worldObj.isRemote)
                                {
                                    entitylivingbase.setArrowCountInEntity(entitylivingbase.getArrowCountInEntity() + 1);
                                }
    
                                if (this.knockbackStrength > 0)
                                {
                                    f4 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionZ * this.motionZ);
    
                                    if (f4 > 0.0F)
                                    {
                                        movingobjectposition.entityHit.addVelocity(this.motionX * (double)this.knockbackStrength * 0.6000000238418579D / (double)f4, 0.1D, this.motionZ * (double)this.knockbackStrength * 0.6000000238418579D / (double)f4);
                                    }
                                }
    
                                if (this.shootingEntity instanceof EntityLivingBase)
                                {
                                    EnchantmentHelper.func_151384_a(entitylivingbase, this.shootingEntity);
                                    EnchantmentHelper.func_151385_b((EntityLivingBase)this.shootingEntity, entitylivingbase);
                                }
    
                                if (this.shootingEntity != null && movingobjectposition.entityHit != this.shootingEntity && movingobjectposition.entityHit instanceof EntityPlayer && this.shootingEntity instanceof EntityPlayerMP)
                                {
                                    ((EntityPlayerMP)this.shootingEntity).playerNetServerHandler.sendPacket(new S2BPacketChangeGameState(6, 0.0F));
                                }
                            }
    
                            this.playSound("random.bowhit", 1.0F, 1.2F / (this.rand.nextFloat() * 0.2F + 0.9F));
    
                            if (!(movingobjectposition.entityHit instanceof EntityEnderman))
                            {
                                this.setDead();
                            }
                        }
                        else
                        {
                            this.motionX *= -0.10000000149011612D;
                            this.motionY *= -0.10000000149011612D;
                            this.motionZ *= -0.10000000149011612D;
                            this.rotationYaw += 180.0F;
                            this.prevRotationYaw += 180.0F;
                            this.ticksInAir = 0;
                        }
                    }
                    else
                    {
                        BlockPos blockpos1 = movingobjectposition.getBlockPos();
                        this.xTile = blockpos1.getX();
                        this.yTile = blockpos1.getY();
                        this.zTile = blockpos1.getZ();
                        iblockstate = this.worldObj.getBlockState(blockpos1);
                        this.inTile = iblockstate.getBlock();
                        this.inData = this.inTile.getMetaFromState(iblockstate);
                        this.motionX = (double)((float)(movingobjectposition.hitVec.xCoord - this.posX));
                        this.motionY = (double)((float)(movingobjectposition.hitVec.yCoord - this.posY));
                        this.motionZ = (double)((float)(movingobjectposition.hitVec.zCoord - this.posZ));
                        f3 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionY * this.motionY + this.motionZ * this.motionZ);
                        this.posX -= this.motionX / (double)f3 * 0.05000000074505806D;
                        this.posY -= this.motionY / (double)f3 * 0.05000000074505806D;
                        this.posZ -= this.motionZ / (double)f3 * 0.05000000074505806D;
                        this.playSound("random.bowhit", 1.0F, 1.2F / (this.rand.nextFloat() * 0.2F + 0.9F));
                        this.inGround = true;
                        this.arrowShake = 7;
                        this.setIsCritical(false);
    
                        if (this.inTile.getMaterial() != Material.air)
                        {
                            this.inTile.onEntityCollidedWithBlock(this.worldObj, blockpos1, iblockstate, this);
                        }
                    }
                }
    
                if (this.getIsCritical())
                {
                    for (i = 0; i < 4; ++i)
                    {
                        this.worldObj.spawnParticle(EnumParticleTypes.CRIT, this.posX + this.motionX * (double)i / 4.0D, this.posY + this.motionY * (double)i / 4.0D, this.posZ + this.motionZ * (double)i / 4.0D, -this.motionX, -this.motionY + 0.2D, -this.motionZ, new int[0]);
                    }
                }
    
                this.posX += this.motionX;
                this.posY += this.motionY;
                this.posZ += this.motionZ;
                f2 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionZ * this.motionZ);
                this.rotationYaw = (float)(Math.atan2(this.motionX, this.motionZ) * 180.0D / Math.PI);
    
                for (this.rotationPitch = (float)(Math.atan2(this.motionY, (double)f2) * 180.0D / Math.PI); this.rotationPitch - this.prevRotationPitch < -180.0F; this.prevRotationPitch -= 360.0F)
                {
                    ;
                }
    
                while (this.rotationPitch - this.prevRotationPitch >= 180.0F)
                {
                    this.prevRotationPitch += 360.0F;
                }
    
                while (this.rotationYaw - this.prevRotationYaw < -180.0F)
                {
                    this.prevRotationYaw -= 360.0F;
                }
    
                while (this.rotationYaw - this.prevRotationYaw >= 180.0F)
                {
                    this.prevRotationYaw += 360.0F;
                }
    
                this.rotationPitch = this.prevRotationPitch + (this.rotationPitch - this.prevRotationPitch) * 0.2F;
                this.rotationYaw = this.prevRotationYaw + (this.rotationYaw - this.prevRotationYaw) * 0.2F;
                f3 = 0.99F;
                f1 = 0.05F;
    
                if (this.isInWater())
                {
                    for (int l = 0; l < 4; ++l)
                    {
                        f4 = 0.25F;
                        this.worldObj.spawnParticle(EnumParticleTypes.WATER_BUBBLE, this.posX - this.motionX * (double)f4, this.posY - this.motionY * (double)f4, this.posZ - this.motionZ * (double)f4, this.motionX, this.motionY, this.motionZ, new int[0]);
                    }
    
                    f3 = 0.6F;
                }
    
                if (this.isWet())
                {
                    this.extinguish();
                }
    
                this.motionX *= (double)f3;
                this.motionY *= (double)f3;
                this.motionZ *= (double)f3;
                this.motionY -= (double)f1;
                this.setPosition(this.posX, this.posY, this.posZ);
                this.doBlockCollisions();
            }
        }
    
        /**
         * (abstract) Protected helper method to write subclass entity data to NBT.
         */
        public void writeEntityToNBT(NBTTagCompound tagCompound)
        {
            tagCompound.setShort("xTile", (short)this.xTile);
            tagCompound.setShort("yTile", (short)this.yTile);
            tagCompound.setShort("zTile", (short)this.zTile);
            tagCompound.setShort("life", (short)this.ticksInGround);
            ResourceLocation resourcelocation = (ResourceLocation)Block.blockRegistry.getNameForObject(this.inTile);
            tagCompound.setString("inTile", resourcelocation == null ? "" : resourcelocation.toString());
            tagCompound.setByte("inData", (byte)this.inData);
            tagCompound.setByte("shake", (byte)this.arrowShake);
            tagCompound.setByte("inGround", (byte)(this.inGround ? 1 : 0));
            tagCompound.setByte("pickup", (byte)this.canBePickedUp);
            tagCompound.setDouble("damage", this.damage);
        }
    
        /**
         * (abstract) Protected helper method to read subclass entity data from NBT.
         */
        public void readEntityFromNBT(NBTTagCompound tagCompund)
        {
            this.xTile = tagCompund.getShort("xTile");
            this.yTile = tagCompund.getShort("yTile");
            this.zTile = tagCompund.getShort("zTile");
            this.ticksInGround = tagCompund.getShort("life");
    
            if (tagCompund.hasKey("inTile", )
            {
                this.inTile = Block.getBlockFromName(tagCompund.getString("inTile"));
            }
            else
            {
                this.inTile = Block.getBlockById(tagCompund.getByte("inTile") & 255);
            }
    
            this.inData = tagCompund.getByte("inData") & 255;
            this.arrowShake = tagCompund.getByte("shake") & 255;
            this.inGround = tagCompund.getByte("inGround") == 1;
    
            if (tagCompund.hasKey("damage", 99))
            {
                this.damage = tagCompund.getDouble("damage");
            }
    
            if (tagCompund.hasKey("pickup", 99))
            {
                this.canBePickedUp = tagCompund.getByte("pickup");
            }
            else if (tagCompund.hasKey("player", 99))
            {
                this.canBePickedUp = tagCompund.getBoolean("player") ? 1 : 0;
            }
        }
    
        /**
         * Called by a player entity when they collide with an entity
         */
        public void onCollideWithPlayer(EntityPlayer entityIn)
        {
            if (!this.worldObj.isRemote && this.inGround && this.arrowShake <= 0)
            {
                boolean flag = this.canBePickedUp == 1 || this.canBePickedUp == 2 && entityIn.capabilities.isCreativeMode;
    
                if (this.canBePickedUp == 1 && !entityIn.inventory.addItemStackToInventory(new ItemStack(MWItems.sacred_arrow, 1)))
                {
                    flag = false;
                }
    
                if (flag)
                {
                    this.playSound("random.pop", 0.2F, ((this.rand.nextFloat() - this.rand.nextFloat()) * 0.7F + 1.0F) * 2.0F);
                    entityIn.onItemPickup(this, 1);
                    this.setDead();
                }
            }
        }
    
        /**
         * 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;
        }
    
        public void setDamage(double p_70239_1_)
        {
            this.damage = p_70239_1_;
        }
    
        public double getDamage()
        {
            return this.damage;
        }
    
        /**
         * Sets the amount of knockback the arrow applies when it hits a mob.
         */
        public void setKnockbackStrength(int p_70240_1_)
        {
            this.knockbackStrength = p_70240_1_;
        }
    
        /**
         * If returns false, the item will not inflict any damage against entities.
         */
        public boolean canAttackWithItem()
        {
            return false;
        }
    
        /**
         * Whether the arrow has a stream of critical hit particles flying behind it.
         */
        public void setIsCritical(boolean p_70243_1_)
        {
            byte b0 = this.dataWatcher.getWatchableObjectByte(16);
    
            if (p_70243_1_)
            {
                this.dataWatcher.updateObject(16, Byte.valueOf((byte)(b0 | 1)));
            }
            else
            {
                this.dataWatcher.updateObject(16, Byte.valueOf((byte)(b0 & -2)));
            }
        }
    
        /**
         * Whether the arrow has a stream of critical hit particles flying behind it.
         */
        public boolean getIsCritical()
        {
            byte b0 = this.dataWatcher.getWatchableObjectByte(16);
            return (b0 & 1) != 0;
        }
    }
    

     

    And this is the function referred in the EntityArrow class (wich is in my Items class)

    public static DamageSource causeSacredArrowDamage (EntitySacredArrow par0EntityOreArrow, Entity par1Entity)
    {
    	return (new EntityDamageSourceIndirect("SacredArrow", par0EntityOreArrow, par1Entity)).setProjectile();
    }
    

     

    In 1.7.10 this code works well so what is changed? :/

     

  3. Class for the log

    package mw.blocks;
    
    import java.util.List;
    
    import com.google.common.base.Predicate;
    
    import mw.core.MWTabs;
    import mw.core.utils.Utils;
    import net.minecraft.block.BlockLog;
    import net.minecraft.block.properties.IProperty;
    import net.minecraft.block.properties.PropertyEnum;
    import net.minecraft.block.state.BlockState;
    import net.minecraft.block.state.IBlockState;
    import net.minecraft.creativetab.CreativeTabs;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemStack;
    import net.minecraftforge.fml.relauncher.Side;
    import net.minecraftforge.fml.relauncher.SideOnly;
    
    public class BlockLogMW extends BlockLog
    {
        public static final PropertyEnum VARIANT = PropertyEnum.create("variant", BlockPlanksMW.EnumType.class, new Predicate()
        {
            public boolean apply(BlockPlanksMW.EnumType type)
            {
                return type.getMetadata() < 4;
            }
            public boolean apply(Object p_apply_1_)
            {
                return this.apply((BlockPlanksMW.EnumType)p_apply_1_);
            }
        });
    
        public BlockLogMW()
        {
            this.setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, BlockPlanksMW.EnumType.APPLE).withProperty(LOG_AXIS, BlockLog.EnumAxis.Y));
            this.setCreativeTab(MWTabs.tabBlock);
    	Utils.setBlockInfo(this, "log", 2.0F, 5.0F);
        }
    
        /**
         * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks)
         */
        @SideOnly(Side.CLIENT)
        public void getSubBlocks(Item itemIn, CreativeTabs tab, List list)
        {
            list.add(new ItemStack(itemIn, 1, BlockPlanksMW.EnumType.APPLE.getMetadata()));
            list.add(new ItemStack(itemIn, 1, BlockPlanksMW.EnumType.PALM.getMetadata()));
        }
    
        /**
         * Convert the given metadata into a BlockState for this Block
         */
        public IBlockState getStateFromMeta(int meta)
        {
            IBlockState iblockstate = this.getDefaultState().withProperty(VARIANT, BlockPlanksMW.EnumType.byMetadata((meta & 3) % 4));
    
            switch (meta & 12)
            {
                case 0:
                    iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.Y);
                    break;
                case 4:
                    iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.X);
                    break;
                case 8:
                    iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.Z);
                    break;
                default:
                    iblockstate = iblockstate.withProperty(LOG_AXIS, BlockLog.EnumAxis.NONE);
            }
    
            return iblockstate;
        }
    
        /**
         * Convert the BlockState into the correct metadata value
         */
        public int getMetaFromState(IBlockState state)
        {
            byte b0 = 0;
            int i = b0 | ((BlockPlanksMW.EnumType)state.getValue(VARIANT)).getMetadata();
    
            switch (BlockLogMW.SwitchEnumAxis.AXIS_LOOKUP[((BlockLogMW.EnumAxis)state.getValue(LOG_AXIS)).ordinal()])
            {
                case 1:
                    i |= 4;
                    break;
                case 2:
                    i |= 8;
                    break;
                case 3:
                    i |= 12;
            }
    
            return i;
        }
    
        protected BlockState createBlockState()
        {
            return new BlockState(this, new IProperty[] {VARIANT, LOG_AXIS});
        }
    
        protected ItemStack createStackedBlock(IBlockState state)
        {
            return new ItemStack(Item.getItemFromBlock(this), 1, ((BlockPlanksMW.EnumType)state.getValue(VARIANT)).getMetadata());
        }
    
        /**
         * Get the damage value that this Block should drop
         */
        public int damageDropped(IBlockState state)
        {
            return ((BlockPlanksMW.EnumType)state.getValue(VARIANT)).getMetadata();
        }
    
        static final class SwitchEnumAxis
            {
                static final int[] AXIS_LOOKUP = new int[blockLog.EnumAxis.values().length];
    
                static
                {
                    try
                    {
                        AXIS_LOOKUP[blockLog.EnumAxis.X.ordinal()] = 1;
                    }
                    catch (NoSuchFieldError var3)
                    {
                        ;
                    }
    
                    try
                    {
                        AXIS_LOOKUP[blockLog.EnumAxis.Z.ordinal()] = 2;
                    }
                    catch (NoSuchFieldError var2)
                    {
                        ;
                    }
    
                    try
                    {
                        AXIS_LOOKUP[blockLog.EnumAxis.NONE.ordinal()] = 3;
                    }
                    catch (NoSuchFieldError var1)
                    {
                        ;
                    }
                }
            }
    }
    

     

    Class for the planks (where it takes the variants, you could also do this in the log file)

    package mw.blocks;
    
    import java.util.List;
    
    import mw.core.MWTabs;
    import mw.core.utils.Utils;
    import net.minecraft.block.Block;
    import net.minecraft.block.material.Material;
    import net.minecraft.block.properties.IProperty;
    import net.minecraft.block.properties.PropertyEnum;
    import net.minecraft.block.state.BlockState;
    import net.minecraft.block.state.IBlockState;
    import net.minecraft.creativetab.CreativeTabs;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemStack;
    import net.minecraft.util.IStringSerializable;
    import net.minecraftforge.fml.relauncher.Side;
    import net.minecraftforge.fml.relauncher.SideOnly;
    
    public class BlockPlanksMW extends Block
    {
        public static final PropertyEnum VARIANT = PropertyEnum.create("variant", BlockPlanksMW.EnumType.class);
    
        public BlockPlanksMW()
        {
            super(Material.wood);
            this.setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, BlockPlanksMW.EnumType.APPLE));
            this.setCreativeTab(MWTabs.tabBlock);
            Utils.setBlockInfo(this, "planks", 1.5F, 10.0F);
        }
    
        /**
         * Get the damage value that this Block should drop
         */
        public int damageDropped(IBlockState state)
        {
            return ((BlockPlanksMW.EnumType)state.getValue(VARIANT)).getMetadata();
        }
    
        /**
         * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks)
         */
        @SideOnly(Side.CLIENT)
        public void getSubBlocks(Item itemIn, CreativeTabs tab, List list)
        {
            BlockPlanksMW.EnumType[] aenumtype = BlockPlanksMW.EnumType.values();
            int i = aenumtype.length;
    
            for (int j = 0; j < i; ++j)
            {
                BlockPlanksMW.EnumType enumtype = aenumtype[j];
                list.add(new ItemStack(itemIn, 1, enumtype.getMetadata()));
            }
        }
    
        /**
         * Convert the given metadata into a BlockState for this Block
         */
        public IBlockState getStateFromMeta(int meta)
        {
            return this.getDefaultState().withProperty(VARIANT, BlockPlanksMW.EnumType.byMetadata(meta));
        }
    
        /**
         * Convert the BlockState into the correct metadata value
         */
        public int getMetaFromState(IBlockState state)
        {
            return ((BlockPlanksMW.EnumType)state.getValue(VARIANT)).getMetadata();
        }
    
        protected BlockState createBlockState()
        {
            return new BlockState(this, new IProperty[] {VARIANT});
        }
    
        public static enum EnumType implements IStringSerializable
        {
            APPLE(0, "apple"),
            PALM(1, "palm");
            private static final BlockPlanksMW.EnumType[] META_LOOKUP = new BlockPlanksMW.EnumType[values().length];
            private final int meta;
            private final String name;
            private final String unlocalizedName;
    
    
            private EnumType(int meta, String name)
            {
                this(meta, name, name);
            }
    
            private EnumType(int meta, String name, String unlocalizedName)
            {
                this.meta = meta;
                this.name = name;
                this.unlocalizedName = unlocalizedName;
            }
    
            public int getMetadata()
            {
                return this.meta;
            }
    
            public String toString()
            {
                return this.name;
            }
    
            public static BlockPlanksMW.EnumType byMetadata(int meta)
            {
                if (meta < 0 || meta >= META_LOOKUP.length)
                {
                    meta = 0;
                }
    
                return META_LOOKUP[meta];
            }
    
            public String getName()
            {
                return this.name;
            }
    
            public String getUnlocalizedName()
            {
                return this.unlocalizedName;
            }
    
            static
            {
                BlockPlanksMW.EnumType[] var0 = values();
                int var1 = var0.length;
    
                for (int var2 = 0; var2 < var1; ++var2)
                {
                    BlockPlanksMW.EnumType var3 = var0[var2];
                    META_LOOKUP[var3.getMetadata()] = var3;
                }
            }
        }
    }
    

     

    Creating the block

    public static Block log;
    log = new BlockLogMW();
    RenderItem renderItem = Minecraft.getMinecraft().getRenderItem();
    GameRegistry.registerBlock(log, ItemLog.class, renderItem);
    ModelBakery.addVariantName(Item.getItemFromBlock(block), new String[]{MW.MODID + ":" + "log_apple", MW.MODID + ":" + "log_palm"});
    		renderItem.getItemModelMesher().register(Item.getItemFromBlock(block), 0, new ModelResourceLocation(MW.MODID + ":" + "log_apple", "inventory"));
    		renderItem.getItemModelMesher().register(Item.getItemFromBlock(block), 1, new ModelResourceLocation(MW.MODID + ":" + "log_palm", "inventory"));
    

    And the last class you need, the ItemLog class

    package mw.blocks.itemblocks;
    
    import net.minecraft.block.Block;
    import net.minecraft.item.ItemBlock;
    import net.minecraft.item.ItemStack;
    
    public class ItemLog extends ItemBlock {
    
    private final static String[] subNames = {
    	"apple", "palm"
    };
    
    public ItemLog(Block id) {
    	super(id);
    	setHasSubtypes(true);
    }
    
    @Override
    public int getMetadata (int damageValue) {
    	return damageValue;
    }
    
    @Override
    public String getUnlocalizedName(ItemStack itemstack) {
    	return "tile.log_" + subNames[itemstack.getItemDamage()] ;
    }
    }
    

     

    Then the .json files

    Blockstate file

    {
        "variants": {
            "axis=y,variant=apple":  { "model": "mw:apple_log" },
            "axis=z,variant=apple":   { "model": "mw:apple_log_side" },
            "axis=x,variant=apple":   { "model": "mw:apple_log_side", "y": 90 },
            "axis=none,variant=apple": { "model": "mw:apple_bark" },
    	"axis=y,variant=palm":  { "model": "mw:palm_log" },
            "axis=z,variant=palm":   { "model": "mw:palm_log_side" },
            "axis=x,variant=palm":   { "model": "mw:palm_log_side", "y": 90 },
            "axis=none,variant=palm": { "model": "mw:palm_bark" }
        }
    }
    

     

    Item model file (you need to do ONE for every variant, in this case one for the apple variant and one for the palm variant)

    {
        "parent": "mw:block/apple_log",
        "display": {
            "thirdperson": {
                "rotation": [ 10, -45, 170 ],
                "translation": [ 0, 1.5, -2.75 ],
                "scale": [ 0.375, 0.375, 0.375 ]
            }
        }
    }
    

     

    Block model file (You need to do 3 models file for each variant, so if you have like in this case 2 variants you need to do 3 files for the apple variant and 3 for the palm variant)

    Normal file (example: apple_log)

    {
        "parent": "block/cube_column",
        "textures": {
            "end": "mw:blocks/log_apple_top",
            "side": "mw:blocks/log_apple"
        }
    }
    

    Block model side file (example: apple_log_side)

    {
        "parent": "block/column_side",
        "textures": {
            "end": "mw:blocks/log_apple_top",
            "side": "mw:blocks/log_apple"
        }
    }
    

    Block model bark side (the log without the top) (example: apple_log_bark)

    {
        "parent": "block/cube_all",
        "textures": {
            "all": "mw:blocks/log_apple"
        }
    }
    

    If you have doubts about this 3 files just look the blockstate file and you will understand :)

  4. yes, i'm really near to finish my mod, hope that there will ben no problems making dimensions :) There only 3 things left to add:

    [ul]

    • Fluids
    • Dimensions
    • Mobs

    [/ul]

    As soon as i implement this in my mod i can work on your :) But i think i will start working on it in parallel with this :)

  5. xD Anyway i looked your mod, except for some blocks that have a custom model it should not be too hard updating that to 1.8 :) Of course i see only the creative inventory (so all the items/blocks), i don't know if there are any dimensions or custom structures or else that need to know the code to be done :)
  6. I'm trying to make a custom fluid but when i place it in the world it doesn't rendering at all.

    Here is a video to show you what i mean :)

    https://youtu.be/n3h6oHNZiic

    As you can see in the inventory the texture is loaded as well, but is not showed when the block is placed

     

    This is the class that i use to make the fluid block

    package mw.blocks.dimensions;
    
    import net.minecraft.block.material.Material;
    import net.minecraft.util.BlockPos;
    import net.minecraft.world.IBlockAccess;
    import net.minecraft.world.World;
    import net.minecraftforge.fluids.BlockFluidClassic;
    import net.minecraftforge.fluids.Fluid;
    import net.minecraftforge.fml.common.registry.GameRegistry;
    
    public class BlockCorruptedWater extends BlockFluidClassic 
    {
    
    public BlockCorruptedWater(Fluid fluid, Material material) 
    {
    	super(fluid, material);
    
    	GameRegistry.registerBlock(this, "corrupted_water");
    }
    
    @Override
    public boolean canDisplace(IBlockAccess world, BlockPos pos)
    {
    	return world.getBlockState(pos).getBlock().getMaterial().isLiquid() || super.canDisplace(world, pos);
    }
    
    //Used to fix a bug in the fml code where the block isn't set to the liquid when flowing into another block.
    @Override
    public boolean displaceIfPossible(World world, BlockPos pos)
    {
    	if(super.displaceIfPossible(world, pos))
    	{
    		world.setBlockState(pos, this.getDefaultState());
    		return true;
    	} else return false;
    }
    }
    

     

    The fluid is registered as well

    public static Fluid corrupted_fluid;
    corrupted_fluid = new Fluid("corrupted_fluid");
    FluidRegistry.registerFluid(corrupted_fluid);
    

    Reference to the class that do this is in the preInit method of the main mod class

     

    And this is how i register the block

    public static BlockCorruptedWater corrupted_water;
    corrupted_water = (BlockCorruptedWater) new BlockCorruptedWater(MWLiquids.corrupted_fluid, Material.water).setUnlocalizedName("corrupted_water");
    

     

    Also the Json files

    -Blockstate

    {
        "variants": {
            "level=0": { "model": "mw:corrupted_water" },
    	"level=1": { "model": "mw:corrupted_water" },
    	"level=2": { "model": "mw:corrupted_water" },
    	"level=3": { "model": "mw:corrupted_water" },
    	"level=4": { "model": "mw:corrupted_water" },
    	"level=5": { "model": "mw:corrupted_water" },
    	"level=6": { "model": "mw:corrupted_water" },
    	"level=7": { "model": "mw:corrupted_water" },
    	"level=8": { "model": "mw:corrupted_water" },
    	"level=9": { "model": "mw:corrupted_water" },
    	"level=10": { "model": "mw:corrupted_water" },
    	"level=11": { "model": "mw:corrupted_water" },
    	"level=12": { "model": "mw:corrupted_water" },
    	"level=13": { "model": "mw:corrupted_water" },
    	"level=14": { "model": "mw:corrupted_water" },
    	"level=15": { "model": "mw:corrupted_water" }
        }
    }
    

     

    -Item

    {
    "parent": "mw:block/corrupted_water",
    "display": {
    	"thirdperson": {
    		"rotation": [10, -45, 170],
    		"translation": [0, 1.5, -2.75],
    		"scale": [0.375, 0.375, 0.375]
    	}
    }
    }
    

     

    -Block

    {
        "parent": "block/cube_all",
        "textures": {
            "all": "mw:blocks/corrupted_water_still",
            "flowing": "mw:blocks/corrupted_water_flow"
        }
    }
    

     

    What am i missing? :/ Thanks in advance to all who will answer me :)

  7. Yay! :D I added this function to my ItemGrassSlab class

    @SideOnly(Side.CLIENT)
        public int getColorFromItemStack(ItemStack stack, int renderPass)
        {
            return this.single.getRenderColor(this.single.getStateFromMeta(stack.getMetadata()));
        }
    

    and it worked :D Thanks for the answer :)

  8. This is the half_grass_slab block model:

    {
    "textures": {
    	"particle": "blocks/dirt",
            "bottom": "blocks/dirt",
            "top": "blocks/grass_top",
            "side": "blocks/grass_side",
            "overlay": "blocks/grass_side_overlay"
    },
    "elements": [
            {   "from": [ 0, 0, 0 ],
                "to": [ 16, 8, 16 ],
                "faces": {
                    "down":  { "uv": [ 0, 0, 16, 16 ], "texture": "#bottom" },
                    "up":    { "uv": [ 0, 0, 16, 16 ], "texture": "#top", "tintindex": 0 },
                    "north": { "uv": [ 0, 0, 16, 16 ], "texture": "#side",   "cullface": "north" },
                    "south": { "uv": [ 0, 0, 16, 16 ], "texture": "#side",   "cullface": "south" },
                    "west":  { "uv": [ 0, 0, 16, 16 ], "texture": "#side",   "cullface": "west" },
                    "east":  { "uv": [ 0, 0, 16, 16 ], "texture": "#side",   "cullface": "east" }
                }
            },
            {   "from": [ 0, 0, 0 ],
                "to": [ 16, 8, 16 ],
                "faces": {
                    "north": { "uv": [ 0, 0, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "north" },
                    "south": { "uv": [ 0, 0, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "south" },
                    "west":  { "uv": [ 0, 0, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "west" },
                    "east":  { "uv": [ 0, 0, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "east" }
                }
            }
        ]
    }
    

     

    This is the upper_grass_slab block model:

    {
    "textures": {
    	"particle": "blocks/dirt",
            "bottom": "blocks/dirt",
            "top": "blocks/grass_top",
            "side": "blocks/grass_side",
            "overlay": "blocks/grass_side_overlay"
    },
    "elements": [
            {   "from": [ 0, 8, 0 ],
                "to": [ 16, 16, 16 ],
                "faces": {
                    "down":  { "uv": [ 0, 0, 16, 16 ], "texture": "#bottom" },
                    "up":    { "uv": [ 0, 0, 16, 16 ], "texture": "#top", "tintindex": 0 },
                    "north": { "uv": [ 0, 0, 16, 16 ], "texture": "#side",   "cullface": "north" },
                    "south": { "uv": [ 0, 0, 16, 16 ], "texture": "#side",   "cullface": "south" },
                    "west":  { "uv": [ 0, 0, 16, 16 ], "texture": "#side",   "cullface": "west" },
                    "east":  { "uv": [ 0, 0, 16, 16 ], "texture": "#side",   "cullface": "east" }
                }
            },
            {   "from": [ 0, 8, 0 ],
                "to": [ 16, 16, 16 ],
                "faces": {
                    "north": { "uv": [ 0, 0, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "north" },
                    "south": { "uv": [ 0, 0, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "south" },
                    "west":  { "uv": [ 0, 0, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "west" },
                    "east":  { "uv": [ 0, 0, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "east" }
                }
            }
        ]
    }
    

     

    And this is the item model file

    {
    "parent": "mw:block/half_grass_slab",
    "display": {
    	"thirdperson": {
    		"rotation": [ 10, -45, 170],
    		"translation": [ 0, 1.5, -2.75],
    		"scale": [ 0.375, 0.375, 0.375]
    	}
    }
    }
    

     

    As mentioned above the slabs itself have no problems, only the rendering in inventory is wrong :/

    This is how it looks right now

    X0x2Qec.png

×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.