ustc-zzzz / fmltutor Goto Github PK

    this.tileentity = tile;
    for (int i = 0; i < 3; ++i)
    {
        this.addSlotToContainer(new SlotItemHandler(this.tileentity.aInventory, i, 38 + i * 32, 20));
    }
    this.addSlotToContainer(new SlotItemHandler(this.tileentity.bInventory,0,38 + 4 * 32, 20));

package firok.soulcraft.item;

import creativetab.CreativeTabsLoader;
import net.minecraft.item.Item;
import net.minecraft.item.ItemAxe;
import net.minecraft.item.Item.ToolMaterial;
import net.minecraftforge.common.util.EnumHelper;

public class ItemSilverAxe extends ItemAxe
{
    public static final Item.ToolMaterial SILVER = EnumHelper.addToolMaterial("SILVER", 3, 16, 16.0F, 0.0F, 10);

    public ItemSilverAxe()
    {
        super(SILVER);
        this.setUnlocalizedName("silverAxe");
        this.setCreativeTab(CreativeTabsLoader.tabSoulCraft);
    }
}

import net.minecraft.item.ItemAxe;
public class ItemSilverAxe extends ItemAxe;

import net.minecraft.item.ItemPickaxe;
public class ItemSilverAxe extends ItemPickaxe;

if (!event.isCanceled() && !worldIn.isRemote) {
     worldIn.setBlockToAir(pos);
     return true;
}

    public BlockGrassBlock()
    {
        super(Material.ground);
        this.setUnlocalizedName("grassBlock");
        this.setHardness(0.5F);
        this.setStepSound(soundTypeGrass);
    }

package captain.pegger.kingofground.entity;

import javax.annotation.Nullable;

import captain.pegger.kingofground.item.ItemLoader;
import net.minecraft.block.Block;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityAgeable;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.SharedMonsterAttributes;
import net.minecraft.entity.ai.EntityAIAttackMelee;
import net.minecraft.entity.ai.EntityAIAttackRangedBow;
import net.minecraft.entity.ai.EntityAIBase;
import net.minecraft.entity.ai.EntityAIFollowOwner;
import net.minecraft.entity.ai.EntityAIHurtByTarget;
import net.minecraft.entity.ai.EntityAILeapAtTarget;
import net.minecraft.entity.ai.EntityAILookIdle;
import net.minecraft.entity.ai.EntityAINearestAttackableTarget;
import net.minecraft.entity.ai.EntityAIOwnerHurtByTarget;
import net.minecraft.entity.ai.EntityAIOwnerHurtTarget;
import net.minecraft.entity.ai.EntityAISwimming;
import net.minecraft.entity.ai.EntityAITargetNonTamed;
import net.minecraft.entity.ai.EntityAIWander;
import net.minecraft.entity.ai.EntityAIWatchClosest;
import net.minecraft.entity.monster.EntityCreeper;
import net.minecraft.entity.monster.EntityGhast;
import net.minecraft.entity.passive.EntityAnimal;
import net.minecraft.entity.passive.EntityHorse;
import net.minecraft.entity.passive.EntityTameable;
import net.minecraft.entity.passive.EntityWolf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.projectile.EntitySmallFireball;
import net.minecraft.init.Items;
import net.minecraft.init.SoundEvents;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemFood;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.DamageSource;
import net.minecraft.util.EnumHand;
import net.minecraft.util.SoundEvent;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.MathHelper;
import net.minecraft.world.DifficultyInstance;
import net.minecraft.world.World;

public class EntityMage extends EntityTameable
{
    public EntityMage(World worldIn)
    {
        super(worldIn);
        this.setSize(0.8F, 1.8F);
        this.setTamed(false);
    }

    protected void initEntityAI()
    {
        this.tasks.addTask(1, new EntityAISwimming(this));
        this.tasks.addTask(2, new EntityMage.AIFireballAttack(this));
        this.tasks.addTask(3, new EntityAIAttackMelee(this, 1.0D, false));
        this.tasks.addTask(5, new EntityAIFollowOwner(this, 1.0D, 6.0F, 16.0F));
        this.tasks.addTask(7, new EntityAIWander(this, 1.0D));
        this.tasks.addTask(9, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
        this.tasks.addTask(9, new EntityAILookIdle(this));
        this.targetTasks.addTask(1, new EntityAIOwnerHurtByTarget(this));
        this.targetTasks.addTask(2, new EntityAIOwnerHurtTarget(this));
        this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true, new Class[0]));
        if (!this.isTamed())
        {
            this.targetTasks.addTask(5, new EntityAINearestAttackableTarget(this, EntityPlayer.class, false));
        }
    }

    @Override
    protected void applyEntityAttributes()
    {
        super.applyEntityAttributes();
        this.getEntityAttribute(SharedMonsterAttributes.MOVEMENT_SPEED).setBaseValue(0.3600001192092896D);
        this.getEntityAttribute(SharedMonsterAttributes.MAX_HEALTH).setBaseValue(25.0D);
        this.getAttributeMap().registerAttribute(SharedMonsterAttributes.ATTACK_DAMAGE).setBaseValue(2.0D);
    }

    @Override
    protected void entityInit()
    {
        super.entityInit();
    }

    protected void playStepSound(BlockPos pos, Block blockIn)
    {
        this.playSound(SoundEvents.ENTITY_HORSE_STEP, 0.15F, 1.0F);
    }

    @Override
    public EntityAgeable createChild(EntityAgeable ageable)
    {
        return this;
    }

    @Override
    public void writeEntityToNBT(NBTTagCompound compound)
    {
        super.writeEntityToNBT(compound);
    }

    @Override
    public void readEntityFromNBT(NBTTagCompound compound)
    {
        super.readEntityFromNBT(compound);
    }

    @Override
    protected SoundEvent getHurtSound()
    {
        return SoundEvents.ENTITY_VILLAGER_HURT;
    }

    @Override
    protected SoundEvent getDeathSound()
    {
        return SoundEvents.ENTITY_VILLAGER_DEATH;
    }

    @Override
    protected float getSoundVolume()
    {
        return 1F;
    }

    @Override
    public void onLivingUpdate()
    {
        super.onLivingUpdate();
    }

    @Override
    public float getEyeHeight()
    {
        return this.height;
    }

    @Override
    public boolean attackEntityAsMob(Entity entityIn)
    {
        boolean flag = entityIn.attackEntityFrom(DamageSource.causeMobDamage(this),
                ((int) this.getEntityAttribute(SharedMonsterAttributes.ATTACK_DAMAGE).getAttributeValue()));

        if (flag)
        {
            this.applyEnchantments(this, entityIn);
        }

        return flag;
    }

    public boolean processInteract(EntityPlayer player, EnumHand hand, @Nullable ItemStack stack)
    {
        if (this.isTamed())
        {
            if (stack != null)
            {
                if (stack.getItem() instanceof ItemFood)
                {
                    ItemFood itemfood = (ItemFood) stack.getItem();

                    if ((this.getHealth() < 25.0F))
                    {
                        if (!player.capabilities.isCreativeMode)
                        {
                            --stack.stackSize;
                        }

                        this.heal(itemfood.getHealAmount(stack));
                        return true;
                    }
                }

                if (this.isOwner(player) && !this.worldObj.isRemote && !this.isBreedingItem(stack))
                {
                    this.setAttackTarget((EntityLivingBase) null);
                }
            }
        }
        else if (stack != null && stack.getItem() == Items.DIAMOND)
        {
            if (!player.capabilities.isCreativeMode)
            {
                --stack.stackSize;
            }

            if (!this.worldObj.isRemote)
            {
                if (this.rand.nextInt(1) == 0)
                {
                    this.setTamed(true);
                    this.navigator.clearPathEntity();
                    this.setAttackTarget((EntityLivingBase) null);
                    this.setHealth(25.0F);
                    this.setOwnerId(player.getUniqueID());
                    this.playTameEffect(true);
                    this.worldObj.setEntityState(this, (byte) 7);
                }
                else
                {
                    this.playTameEffect(false);
                    this.worldObj.setEntityState(this, (byte) 6);
                }
            }

            return true;
        }

        return super.processInteract(player, hand, stack);
    }

    @Override
    public boolean shouldAttackEntity(EntityLivingBase target, EntityLivingBase owner)
    {
        if (!(target instanceof EntityCreeper) && !(target instanceof EntityGhast))
        {
            if (target instanceof EntityRobber || target instanceof EntityMercenary || target instanceof EntityWolf)
            {
                EntityTameable entitywolf = (EntityTameable) target;

                if (entitywolf.isTamed() && entitywolf.getOwner() == owner)
                {
                    return false;
                }
            }
            return target instanceof EntityPlayer && owner instanceof EntityPlayer
                    && !((EntityPlayer) owner).canAttackPlayer((EntityPlayer) target) ? false
                            : !(target instanceof EntityHorse) || !((EntityHorse) target).isTame();
        }
        else
        {
            return false;
        }
    }

    @Override
    public void onDeath(DamageSource source)
    {
        if (!this.worldObj.isRemote)
        {
            this.entityDropItem(new ItemStack(Items.GOLD_NUGGET, 2), 1F);
            this.entityDropItem(new ItemStack(ItemLoader.summonstone, 1), 1F);
            if (this.rand.nextInt(2) >= 1)
            {
                this.entityDropItem(new ItemStack(ItemLoader.summonstone, 2), 1F);
            }
            super.onDeath(source);
        }
    }

    public static class AIFireballAttack extends EntityAIBase
    {
        private final EntityMage mage;
        private int attackTime;

        public AIFireballAttack(EntityMage mageIn)
        {
            this.mage = mageIn;

        }

        @Override
        public boolean shouldExecute()
        {
            EntityLivingBase target = this.mage.getAttackTarget();
            return target != null && target.isEntityAlive();
        }

        @Override
        public void startExecuting()
        {

        }

        @Override
        public void updateTask()
        {
            --this.attackTime;
            EntityLivingBase target = this.mage.getAttackTarget();
            double d0 = this.mage.getDistanceSqToEntity(target);

            if (d0 < 4.0D)
            {
                this.attackTime = 20;
                this.mage.attackEntityAsMob(target);

                this.mage.getMoveHelper().setMoveTo(target.posX, target.posY, target.posZ, 1.0D);
            }
            else if (d0 < 256.0D)
            {
                this.attackTime = 100;
                double d1 = target.posX - this.mage.posX;
                double d2 = target.getEntityBoundingBox().minY + target.height / 2.0F
                        - (this.mage.posY + this.mage.height / 2.0F);
                double d3 = target.posZ - this.mage.posZ;
                float f = MathHelper.sqrt_float(MathHelper.sqrt_double(d0)) * 0.5F;
                this.mage.worldObj.playEvent((EntityPlayer) null, 1018,
                        new BlockPos((int) this.mage.posX, (int) this.mage.posY, (int) this.mage.posZ), 0);
                EntitySmallFireball entitysmallfireball = new EntitySmallFireball(this.mage.worldObj, this.mage,
                        d1 + this.mage.getRNG().nextGaussian() * f, d2, d3 + this.mage.getRNG().nextGaussian() * f);
                entitysmallfireball.posY = this.mage.posY + this.mage.height / 2.0F + 0.5D;
                this.mage.worldObj.spawnEntityInWorld(entitysmallfireball);

                this.mage.getLookHelper().setLookPositionWithEntity(target, 10.0F, 10.0F);
            }
            else
            {
                this.mage.getNavigator().clearPathEntity();
                this.mage.getMoveHelper().setMoveTo(target.posX, target.posY, target.posZ, 1.0D);
            }

            super.updateTask();
        }
    }
}

        if (modid.length() > 64)
        {
            FMLLog.bigWarning("The modid %s is longer than the recommended maximum of 64 characters. Truncation is enforced in 1.11", modid);
            throw new IllegalArgumentException(String.format("The modid %s is longer than the recommended maximum of 64 characters. Truncation is enforced in 1.11", modid));
        }
        if (!modid.equals(modid.toLowerCase(Locale.ENGLISH)))
        {
            FMLLog.bigWarning("The modid %s is not the same as it's lowercase version. Lowercasing is enforced in 1.11", modid);
            throw new IllegalArgumentException(String.format("The modid %s is not the same as it's lowercase version. Lowercasing will be enforced in 1.11", modid));
        }

`   @SubscribeEvent
    public void onFillBucket(FillBucketEvent event) {
        Fluid fluid = null;
        BlockPos blockpos = null;
        IBlockState blockState = null;
        RayTraceResult tar = event.getTarget();
        if (tar != null) {
            blockpos = tar.getBlockPos();
            blockState = event.world.getBlockState(blockpos);
            fluid = FluidRegistry.lookupFluidForBlock(blockState.getBlock());
        }
        if (fluid != null && new Integer(0).equals(blockState.getValue(BlockFluidBase.LEVEL)))
        {
            FluidStack fluidStack = new FluidStack(fluid, FluidContainerRegistry.BUCKET_VOLUME);
            event.world.setBlockToAir(blockpos);
            event.result = FluidContainerRegistry.fillFluidContainer(fluidStack, event.current);
            event.setResult(Result.ALLOW);
        }
    }

    @Override
    public <T> T getCapability(Capability<T> capability, EnumFacing facing)
    {
        if (CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.equals(capability))
        {
            @SuppressWarnings("unchecked")
            T result = null;
            if (facing == EnumFacing.DOWN)
            {
                result = (T) this.itemOut;
            }
            else if (facing == EnumFacing.UP)
            {
                result = (T) this.itemIn;
            }
            else
            {
                result = (T) this.itemFuel;
            }
            return result;
        }
        return super.getCapability(capability, facing);
    }