Entity AI: Getting Custom Mob to attack vanilla creatures

[Mikethecoder4]

I made a custom mob (called an infected) which is essentially a zombie that does't burn in the sun. Im trying to get it to attack passive mobs (like cows, sheep, etc.) as well as players and villagers. However, nothing I do seems to be working.

 

 

I've tried adding the following code into the constructor :

 

this.targetTasks.addTask(2, new EntityAINearestAttackableTarget(this, EntityCow.class, 0, false));

 

But that doesnt seem to work. I have tried using different priorities, removing all the target tasks but that one, and looked though the various classes that make up AI. I'm at a loss for what to do at this point. My Mob is extending the EntityMob class.

 

Here is my full infected classes

 

public class infected extends EntityMob{

protected static final Attribute field_110186_bp = (new RangedAttribute("zombie.spawnReinforcements", 0.0D, 0.0D, 1.0D)).func_111117_a("Spawn Reinforcements Chance");
    private static final UUID babySpeedBoostUUID = UUID.fromString("B9766B59-9566-4402-BC1F-2EE2A276D836");
    private static final AttributeModifier babySpeedBoostModifier = new AttributeModifier(babySpeedBoostUUID, "Baby speed boost", 0.5D, 1);

    /**
     * Ticker used to determine the time remaining for this zombie to convert into a villager when cured.
     */
    private int conversionTime;

    public infected(World par1World)
    {
        super(par1World);
        this.getNavigator().setBreakDoors(true);
        this.getNavigator().setEnterDoors(true);

        //this.tasks.addTask(0, new EntityAISwimming(this));
        this.tasks.addTask(0, new EntityAIBreakDoor(this));
        this.tasks.addTask(1, new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.0D, false));
        this.tasks.addTask(2, new EntityAIAttackOnCollide(this, EntityVillager.class, 1.0D, true));
        this.tasks.addTask(3, new EntityAIMoveTowardsRestriction(this, 1.0D));
        this.tasks.addTask(4, new EntityAIMoveThroughVillage(this, 1.0D, false));
        this.tasks.addTask(5, new EntityAIWander(this, 1.0D));
        this.tasks.addTask(6, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
        this.tasks.addTask(7, new EntityAILookIdle(this));
        this.targetTasks.addTask(1, new EntityAIHurtByTarget(this, true));
        //this.targetTasks.addTask(3, new EntityAINearestAttackableTarget(this, EntityPlayer.class, 0, true));
        this.targetTasks.addTask(2, new EntityAINearestAttackableTarget(this, EntityVillager.class, 0, false));
        this.targetTasks.addTask(2, new EntityAINearestAttackableTarget(this, EntityCow.class, 0, false));
        this.targetTasks.addTask(3, new EntityAINearestAttackableTarget(this, EntityPlayer.class, 0, true)); 
    }

    protected void applyEntityAttributes()
    {
        super.applyEntityAttributes();
        this.getEntityAttribute(SharedMonsterAttributes.followRange).setAttribute(18.0D);
        this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setAttribute(0.44000700417232513D);
        this.getEntityAttribute(SharedMonsterAttributes.attackDamage).setAttribute(4.0D);
        this.getAttributeMap().func_111150_b(field_110186_bp).setAttribute(this.rand.nextDouble() * 0.10000000149011612D);
    }

    protected void entityInit()
    {
        super.entityInit();
        this.getDataWatcher().addObject(12, Byte.valueOf((byte)0));
        this.getDataWatcher().addObject(13, Byte.valueOf((byte)0));
        this.getDataWatcher().addObject(14, Byte.valueOf((byte)0));
    }

    /**
     * Returns the current armor value as determined by a call to InventoryPlayer.getTotalArmorValue
     */
    public int getTotalArmorValue()
    {
        int i = super.getTotalArmorValue() + 2;

        if (i > 20)
        {
            i = 20;
        }

        return i;
    }

    /**
     * Returns true if the newer Entity AI code should be run
     */
    protected boolean isAIEnabled()
    {
        return true;
    }
    
    @Override
    public boolean canAttackClass(Class par1Class)
    {
        return true;
    }


   
    @Override
    public void onLivingUpdate()
    {
    	
    	

        //EntityLiving.onLivingUpdate();
        super.onLivingUpdate();
    }
    
        
        public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
        {
            if (!super.attackEntityFrom(par1DamageSource, par2))
            {
                return false;
            }
            else
            {
                EntityLivingBase entitylivingbase = this.getAttackTarget();

                if (entitylivingbase == null && this.getEntityToAttack() instanceof EntityLivingBase)
                {
                    entitylivingbase = (EntityLivingBase)this.getEntityToAttack();
                }

                if (entitylivingbase == null && par1DamageSource.getEntity() instanceof EntityLivingBase)
                {
                    entitylivingbase = (EntityLivingBase)par1DamageSource.getEntity();
                }

                if (entitylivingbase != null && this.worldObj.difficultySetting >= 3 && (double)this.rand.nextFloat() < this.getEntityAttribute(field_110186_bp).getAttributeValue())
                {
                    int i = MathHelper.floor_double(this.posX);
                    int j = MathHelper.floor_double(this.posY);
                    int k = MathHelper.floor_double(this.posZ);
                    infected entityzombie = new infected(this.worldObj);

                    for (int l = 0; l < 50; ++l)
                    {
                        int i1 = i + MathHelper.getRandomIntegerInRange(this.rand, 7, 40) * MathHelper.getRandomIntegerInRange(this.rand, -1, 1);
                        int j1 = j + MathHelper.getRandomIntegerInRange(this.rand, 7, 40) * MathHelper.getRandomIntegerInRange(this.rand, -1, 1);
                        int k1 = k + MathHelper.getRandomIntegerInRange(this.rand, 7, 40) * MathHelper.getRandomIntegerInRange(this.rand, -1, 1);

                        if (this.worldObj.doesBlockHaveSolidTopSurface(i1, j1 - 1, k1) && this.worldObj.getBlockLightValue(i1, j1, k1) < 10)
                        {
                            entityzombie.setPosition((double)i1, (double)j1, (double)k1);

                            if (this.worldObj.checkNoEntityCollision(entityzombie.boundingBox) && this.worldObj.getCollidingBoundingBoxes(entityzombie, entityzombie.boundingBox).isEmpty() && !this.worldObj.isAnyLiquid(entityzombie.boundingBox))
                            {
                                this.worldObj.spawnEntityInWorld(entityzombie);
                                entityzombie.setAttackTarget(entitylivingbase);
                                entityzombie.onSpawnWithEgg((EntityLivingData)null);
                                this.getEntityAttribute(field_110186_bp).applyModifier(new AttributeModifier("Zombie reinforcement caller charge", -0.05000000074505806D, 0));
                                entityzombie.getEntityAttribute(field_110186_bp).applyModifier(new AttributeModifier("Zombie reinforcement callee charge", -0.05000000074505806D, 0));
                                break;
                            }
                        }
                    }
                }

                return true;
            }
        }

        /**
         * Called to update the entity's position/logic.
         */
        public void onUpdate()
        {
            if (!this.worldObj.isRemote && this.isConverting())
            {
                int i = this.getConversionTimeBoost();
                this.conversionTime -= i;

                if (this.conversionTime <= 0)
                {
                    this.convertToVillager();
                }
            }

            super.onUpdate();
        }

        public boolean attackEntityAsMob(Entity par1Entity)
        {
            boolean flag = super.attackEntityAsMob(par1Entity);

            if (flag && this.getHeldItem() == null && this.isBurning() && this.rand.nextFloat() < (float)this.worldObj.difficultySetting * 0.3F)
            {
                par1Entity.setFire(2 * this.worldObj.difficultySetting);
            }

            return flag;
        }

        /**
         * Returns the sound this mob makes while it's alive.
         */
        protected String getLivingSound()
        {
            return "mob.zombie.say";
        }

        /**
         * Returns the sound this mob makes when it is hurt.
         */
        protected String getHurtSound()
        {
            return "mob.zombie.hurt";
        }

        /**
         * Returns the sound this mob makes on death.
         */
        protected String getDeathSound()
        {
            return "mob.zombie.death";
        }

        /**
         * Plays step sound at given x, y, z for the entity
         */
        protected void playStepSound(int par1, int par2, int par3, int par4)
        {
            this.playSound("mob.zombie.step", 0.15F, 1.0F);
        }

        /**
         * Returns the item ID for the item the mob drops on death.
         */
        protected int getDropItemId()
        {
            return Item.rottenFlesh.itemID;
        }

        /**
         * Get this Entity's EnumCreatureAttribute
         */
        public EnumCreatureAttribute getCreatureAttribute()
        {
            return EnumCreatureAttribute.UNDEAD;
        }

        protected void dropRareDrop(int par1)
        {
            switch (this.rand.nextInt(3))
            {
                case 0:
                    this.dropItem(Item.ingotIron.itemID, 1);
                    break;
                case 1:
                    this.dropItem(Item.carrot.itemID, 1);
                    break;
                case 2:
                    this.dropItem(Item.potato.itemID, 1);
            }
        }

        /**
         * Makes entity wear random armor based on difficulty
         */
        protected void addRandomArmor()
        {
            super.addRandomArmor();

            if (this.rand.nextFloat() < (this.worldObj.difficultySetting == 3 ? 0.05F : 0.01F))
            {
                int i = this.rand.nextInt(3);

                if (i == 0)
                {
                    this.setCurrentItemOrArmor(0, new ItemStack(Item.swordIron));
                }
                else
                {
                    this.setCurrentItemOrArmor(0, new ItemStack(Item.shovelIron));
                }
            }
        }

        /**
         * (abstract) Protected helper method to write subclass entity data to NBT.
         */
        public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
        {
            super.writeEntityToNBT(par1NBTTagCompound);
            /*
            if (this.isChild())
            {
                par1NBTTagCompound.setBoolean("IsBaby", true);
            }

            if (this.isVillager())
            {
                par1NBTTagCompound.setBoolean("IsVillager", true);
            }

            par1NBTTagCompound.setInteger("ConversionTime", this.isConverting() ? this.conversionTime : -1);
           */
        }

        /**
         * (abstract) Protected helper method to read subclass entity data from NBT.
         */
        public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
        {
            super.readEntityFromNBT(par1NBTTagCompound);
            /*
            if (par1NBTTagCompound.getBoolean("IsBaby"))
            {
                this.setChild(true);
            }

            if (par1NBTTagCompound.getBoolean("IsVillager"))
            {
                this.setVillager(true);
            }

            if (par1NBTTagCompound.hasKey("ConversionTime") && par1NBTTagCompound.getInteger("ConversionTime") > -1)
            {
                this.startConversion(par1NBTTagCompound.getInteger("ConversionTime"));
            }
            */
        }

        /**
         * This method gets called when the entity kills another one.
         */
        public void onKillEntity(EntityLivingBase par1EntityLivingBase)
        {
            super.onKillEntity(par1EntityLivingBase);

            if (this.worldObj.difficultySetting >= 2 && par1EntityLivingBase instanceof EntityVillager)
            {
                if (this.worldObj.difficultySetting == 2 && this.rand.nextBoolean())
                {
                    return;
                }

                infected entityzombie = new infected(this.worldObj);
                entityzombie.copyLocationAndAnglesFrom(par1EntityLivingBase);
                this.worldObj.removeEntity(par1EntityLivingBase);
                entityzombie.onSpawnWithEgg((EntityLivingData)null);
                //entityzombie.setVillager(true);

                //if (par1EntityLivingBase.isChild())
               // {
                   // entityzombie.setChild(true);
               // }

                this.worldObj.spawnEntityInWorld(entityzombie);
                this.worldObj.playAuxSFXAtEntity((EntityPlayer)null, 1016, (int)this.posX, (int)this.posY, (int)this.posZ, 0);
            }
        }

        public EntityLivingData onSpawnWithEgg(EntityLivingData par1EntityLivingData)
        {
            Object par1EntityLivingData1 = super.onSpawnWithEgg(par1EntityLivingData);
            float f = this.worldObj.getLocationTensionFactor(this.posX, this.posY, this.posZ);
            this.setCanPickUpLoot(true);
            
            if (par1EntityLivingData1 == null)
            {
                par1EntityLivingData1 = new infectedGroupData(this, this.worldObj.rand.nextFloat() < 0.05F, this.worldObj.rand.nextFloat() < 0.05F, (infectedINNER1)null);
            }

            if (par1EntityLivingData1 instanceof infectedGroupData)
            {
            	infectedGroupData entityzombiegroupdata = (infectedGroupData)par1EntityLivingData1;

                /*if (entityzombiegroupdata.field_142046_b)
                {
                    this.setVillager(true);
                }

                if (entityzombiegroupdata.field_142048_a)
                {
                    this.setChild(true);
                }
                */
            }
            

            this.addRandomArmor();
            this.enchantEquipment();

            if (this.getCurrentItemOrArmor(4) == null)
            {
                Calendar calendar = this.worldObj.getCurrentDate();

                if (calendar.get(2) + 1 == 10 && calendar.get(5) == 31 && this.rand.nextFloat() < 0.25F)
                {
                    this.setCurrentItemOrArmor(4, new ItemStack(this.rand.nextFloat() < 0.1F ? Block.pumpkinLantern : Block.pumpkin));
                    this.equipmentDropChances[4] = 0.0F;
                }
            }

            this.getEntityAttribute(SharedMonsterAttributes.knockbackResistance).applyModifier(new AttributeModifier("Random spawn bonus", this.rand.nextDouble() * 0.05000000074505806D, 0));
            this.getEntityAttribute(SharedMonsterAttributes.followRange).applyModifier(new AttributeModifier("Random zombie-spawn bonus", this.rand.nextDouble() * 1.5D, 2));

            if (this.rand.nextFloat() < f * 0.05F)
            {
                this.getEntityAttribute(field_110186_bp).applyModifier(new AttributeModifier("Leader zombie bonus", this.rand.nextDouble() * 0.25D + 0.5D, 0));
                this.getEntityAttribute(SharedMonsterAttributes.maxHealth).applyModifier(new AttributeModifier("Leader zombie bonus", this.rand.nextDouble() * 3.0D + 1.0D, 2));
            }

            return (EntityLivingData)par1EntityLivingData1;
        }

        /**
         * Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
         */
        public boolean interact(EntityPlayer par1EntityPlayer)
        {
            ItemStack itemstack = par1EntityPlayer.getCurrentEquippedItem();
            /* no converting them
            if (itemstack != null && itemstack.getItem() == Item.appleGold && itemstack.getItemDamage() == 0  && this.isPotionActive(Potion.weakness))
            {
                if (!par1EntityPlayer.capabilities.isCreativeMode)
                {
                    --itemstack.stackSize;
                }

                if (itemstack.stackSize <= 0)
                {
                    par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack)null);
                }

                if (!this.worldObj.isRemote)
                {
                    this.startConversion(this.rand.nextInt(2401) + 3600);
                }

                return true;
            }
            else
            {
                return false;
            }*/
            return false;
        }

        /**
         * Starts converting this zombie into a villager. The zombie converts into a villager after the specified time in
         * ticks.
         */
        protected void startConversion(int par1)
        {
            this.conversionTime = par1;
            this.getDataWatcher().updateObject(14, Byte.valueOf((byte)1));
            this.removePotionEffect(Potion.weakness.id);
            this.addPotionEffect(new PotionEffect(Potion.damageBoost.id, par1, Math.min(this.worldObj.difficultySetting - 1, 0)));
            this.worldObj.setEntityState(this, (byte)16);
        }

        @SideOnly(Side.CLIENT)
        public void handleHealthUpdate(byte par1)
        {
            if (par1 == 16)
            {
                this.worldObj.playSound(this.posX + 0.5D, this.posY + 0.5D, this.posZ + 0.5D, "mob.zombie.remedy", 1.0F + this.rand.nextFloat(), this.rand.nextFloat() * 0.7F + 0.3F, false);
            }
            else
            {
                super.handleHealthUpdate(par1);
            }
        }

        /**
         * Determines if an entity can be despawned, used on idle far away entities
         */
        protected boolean canDespawn()
        {
            return !this.isConverting();
        }

        /**
         * Returns whether this zombie is in the process of converting to a villager
         */
        public boolean isConverting()
        {
            return false;//this.getDataWatcher().getWatchableObjectByte(14) == 1;
        }

        /**
         * Convert this zombie into a villager.
         */
        protected void convertToVillager()
        {
            EntityVillager entityvillager = new EntityVillager(this.worldObj);
            entityvillager.copyLocationAndAnglesFrom(this);
            entityvillager.onSpawnWithEgg((EntityLivingData)null);
            entityvillager.func_82187_q();

            if (this.isChild())
            {
                entityvillager.setGrowingAge(-24000);
            }

            this.worldObj.removeEntity(this);
            this.worldObj.spawnEntityInWorld(entityvillager);
            entityvillager.addPotionEffect(new PotionEffect(Potion.confusion.id, 200, 0));
            this.worldObj.playAuxSFXAtEntity((EntityPlayer)null, 1017, (int)this.posX, (int)this.posY, (int)this.posZ, 0);
        }

        /**
         * Return the amount of time decremented from conversionTime every tick.
         */
        protected int getConversionTimeBoost()
        {
            int i = 1;

            if (this.rand.nextFloat() < 0.01F)
            {
                int j = 0;

                for (int k = (int)this.posX - 4; k < (int)this.posX + 4 && j < 14; ++k)
                {
                    for (int l = (int)this.posY - 4; l < (int)this.posY + 4 && j < 14; ++l)
                    {
                        for (int i1 = (int)this.posZ - 4; i1 < (int)this.posZ + 4 && j < 14; ++i1)
                        {
                            int j1 = this.worldObj.getBlockId(k, l, i1);

                            if (j1 == Block.fenceIron.blockID || j1 == Block.bed.blockID)
                            {
                                if (this.rand.nextFloat() < 0.3F)
                                {
                                    ++i;
                                }

                                ++j;
                            }
                        }
                    }
                }
            }

            return i;
        }
        
        @Override
        protected Entity findPlayerToAttack()
        {
            EntityPlayer entityplayer = this.worldObj.getClosestVulnerablePlayerToEntity(this, 8.0D);
            return entityplayer != null && this.canEntityBeSeen(entityplayer) ? entityplayer : null;
        }

}

[GotoLink]

You need to return true to "using the new AI" method flag.

[Mikethecoder4]

do you mean this function?

 

@Override
    protected boolean isAIEnabled()
    {
        return true;
    }

or a different one? I tried this and it didn't work. still won't attack cows.

 

I've noticed that they will only attack villagers and the player, and won't attack spiders, creepers, zombies, themselves, etc. I haven't tried EVERY mob, but that ones I have tried its all the same.

 

Also, if you do have the ai targetting a mob, and its a higher priority than villager/player, it will be docile. If you put its priority above the HurtByTarget AI task, it basically becomes passive (but doesn't panic).

[saxon564]

I have played around with this concept a bit recently and figured out, for it to attack a mob you have to have BOTH the collision task and the attackable task

 

so you have to have both these:

this.tasks.addTask(2, new EntityAIAttackOnCollide(this, EntityCow.class, 1.0D, true));
this.targetTasks.addTask(2, new EntityAINearestAttackableTarget(this, EntityCow.class, 0, false));

 

try that, i imagine that is you problem.

[Mikethecoder4]

This was it exactly, thank you very much!