My first problem is that when I use an item on the entity that's meant to add 1 to its health multiplier, it adds 2.

 

My second problem is that the entity won't follow the player because it won't recognise the player as its owner.

 

Cat:

public class Cat extends EntityPet
{
public Cat(World world)
{
	super(world);

        this.setSize(0.6F, 0.8F);
        this.getNavigator().setAvoidsWater(true);
        this.targetTasks.addTask(4, new EntityAITargetNonTamed(this, EntityWolf.class, 200, false));
        
	this.breedingItem = Items.fish;
	this.befriendingItem = BPItems.ball_of_yarn;
	this.healingItem = BPItems.tuna;
	this.eyeHeight = 0.8F;
	this.tamedDamage = 6;
	this.baseDamage = 4;
	this.minHealth = 6;
	this.newHealth = 25;
}

    public boolean canMateWith(EntityAnimal p_70878_1_)
    {
        if (p_70878_1_ == this)
        {
            return false;
        }
        else if (!this.isTamed())
        {
            return false;
        }
        else if (!(p_70878_1_ instanceof Cat))
        {
            return false;
        }
        else
        {
            Cat thisPet = (Cat)p_70878_1_;
            return !thisPet.isTamed() ? false : (thisPet.isSitting() ? false : this.isInLove() && thisPet.isInLove());
        }
    }
    protected String getLivingSound()
    {
        return this.isTamed() ? (this.isInLove() ? "mob.cat.purr" : (this.rand.nextInt(4) == 0 ? "mob.cat.purreow" : "mob.cat.meow")) : "";
    }

    protected String getHurtSound()
    {
        return "mob.cat.hitt";
    }

    protected String getDeathSound()
    {
        return "mob.cat.hitt";
    }

    protected Item getDropItem()
    {
        return BPItems.cat_tail;
    }

    public boolean attackEntityAsMob(Entity p_70652_1_)
    {
        return p_70652_1_.attackEntityFrom(DamageSource.causeMobDamage(this), 3.0F);
    }

    public boolean attackEntityFrom(DamageSource p_70097_1_, float p_70097_2_)
    {
        if (this.isEntityInvulnerable())
        {
            return false;
        }
        else
        {
            this.aiSit.setSitting(false);
            return super.attackEntityFrom(p_70097_1_, p_70097_2_);
        }
    }
    @Override
    public Cat createChild(EntityAgeable p_90011_1_)
    {
        Cat cat = new Cat(this.worldObj);
        String s = this.func_152113_b();

        if (s != null && s.trim().length() > 0)
        {
            cat.func_152115_b(s);
            cat.setTamed(true);
        }

        return cat;
    }
    @Override
    public void readEntityFromNBT(NBTTagCompound nbt)
    {
        super.readEntityFromNBT(nbt);
        healthMultiplier = nbt.getInteger("Health Multiplier");
        damageMultiplier = nbt.getInteger("Damage Multiplier");
    }
    @Override
    public void writeEntityToNBT(NBTTagCompound nbt)
    {
        super.readEntityFromNBT(nbt);
        nbt.setInteger("Health Multiplier", this.healthMultiplier);
        nbt.setInteger("Damage Multiplier", this.damageMultiplier);
    }
    
    
    
    
    
    
    
    
    
    public static void createEntity(Class entityClass, String entityName, int solidColour, int spotColour)
    {
    	int id = EntityRegistry.findGlobalUniqueEntityId();
    	
    	Tools.println("Attempting to register 'Cat' entity.");
    	Tools.println("Class: " + entityClass.getCanonicalName() + ".");
    	Tools.println("Name: " + entityName + ".");
    	Tools.println("Egg Colour: " + Integer.toString(solidColour) + ".");
    	Tools.println("Egg Colour: " + Integer.toString(spotColour) + ".");
    	Tools.println("Instance: " + Main.instance.toString() + ".");
    	
    	EntityRegistry.registerGlobalEntityID(entityClass, entityName, id);
    	EntityRegistry.registerModEntity(entityClass, entityName, id, Main.instance, 64, 1, true);
    	EntityList.entityEggs.put(Integer.valueOf(id), new EntityList.EntityEggInfo(id, solidColour, spotColour));
    }
}

 

EntityPet:

public class EntityPet extends EntityTameable
{
public static Item breedingItem, befriendingItem, healingItem;
public static double minHealth, newHealth, speed, strength;
public static float eyeHeight, scale;
public static int baseDamage, tamedDamage, damageMultiplier = 0, healthMultiplier = 0;


    public EntityPet(World p_i1696_1_)
    {
        super(p_i1696_1_);
        this.tasks.addTask(1, new EntityAISwimming(this));
        this.tasks.addTask(2, this.aiSit);
        this.tasks.addTask(3, new EntityAILeapAtTarget(this, 0.4F));
        this.tasks.addTask(4, new EntityAIAttackOnCollide(this, 1.0D, true));
        this.tasks.addTask(5, new EntityAIFollowOwner(this, 1.0D, 10.0F, 2.0F));
        this.tasks.addTask(6, new EntityAIMate(this, 1.0D));
        this.tasks.addTask(7, new EntityAIWander(this, 1.0D));
        this.tasks.addTask(8, new Beg(this, 8.0F));
        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));
        this.setTamed(false);
        
    }
    public static void scale()
{
	if(healthMultiplier == 3 && damageMultiplier == 3)
	{
		scale = 1.2F;
	}
	else
	{
		scale = 1F;
	}
}
    
    public static Item getBreedingItem()
    {
    	return breedingItem;
    }
    public static Item getBefriendingItem()
    {
    	return befriendingItem;
    }

    protected void applyEntityAttributes()
    {
        super.applyEntityAttributes();
        this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(speed);

        if (this.isTamed())
        {
            this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(newHealth + (healthMultiplier * 2));
        }
        else
        {
            this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(minHealth);
        }
    }

    public boolean isAIEnabled()
    {
        return true;
    }

    public void setAttackTarget(EntityLivingBase p_70624_1_)
    {
        super.setAttackTarget(p_70624_1_);

        if (p_70624_1_ == null)
        {
            this.setAngry(false);
        }
        else if (!this.isTamed())
        {
            this.setAngry(true);
        }
    }

    /**
     * main AI tick function, replaces updateEntityActionState
     */
    protected void updateAITick()
    {
        this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
    }

    protected void entityInit()
    {
        super.entityInit();
        this.dataWatcher.addObject(18, new Float(this.getHealth()));
        this.dataWatcher.addObject(19, new Byte((byte)0));
    }
    
    protected String getLivingSound()
    {
        return this.isAngry() ? "mob.wolf.growl" : (this.rand.nextInt(3) == 0 ? (this.isTamed() && this.dataWatcher.getWatchableObjectFloat(18) < 10.0F ? "mob.wolf.whine" : "mob.wolf.panting") : "mob.wolf.bark");
    }

    protected float getSoundVolume()
    {
        return 0.4F;
    }

    public float getEyeHeight()
    {
        return this.height * eyeHeight;
    }

    public boolean attackEntityFrom(DamageSource p_70097_1_, float p_70097_2_)
    {
        if (this.isEntityInvulnerable())
        {
            return false;
        }
        else
        {
            Entity entity = p_70097_1_.getEntity();
            this.aiSit.setSitting(false);

            if (entity != null && !(entity instanceof EntityPlayer) && !(entity instanceof EntityArrow))
            {
                p_70097_2_ = (p_70097_2_ + 1.0F) / 2.0F;
            }

            return super.attackEntityFrom(p_70097_1_, p_70097_2_);
        }
    }

    public boolean attackEntityAsMob(Entity p_70652_1_)
    {
        int i = this.isTamed() ? (tamedDamage * damageMultiplier) : baseDamage;
        return p_70652_1_.attackEntityFrom(DamageSource.causeMobDamage(this), (float)i);
    }

    public void setTamed(boolean p_70903_1_)
    {
        super.setTamed(p_70903_1_);

        if (p_70903_1_)
        {
            this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(newHealth);
        }
        else
        {
            this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(minHealth);
        }
    }

    public boolean interact(EntityPlayer p_70085_1_)
    {
        ItemStack itemstack = p_70085_1_.inventory.getCurrentItem();

        if (this.isTamed())
        {
            if (itemstack != null)
            {
            	if (itemstack.getItem() == BPItems.damageEnhancer)
            	{
            		if(this.damageMultiplier < 3)
            		{
                        if (!p_70085_1_.capabilities.isCreativeMode)
                        {
                            --itemstack.stackSize;
                        }

                        damageMultiplier += 1;
                        Tools.println("Increased pet's damage multiplier to " + damageMultiplier);

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

                        return true;
            			
            		}
            	}if (itemstack.getItem() == BPItems.healthEnhancer)
            	{
            		if(this.healthMultiplier < 3)
            		{
                        if (!p_70085_1_.capabilities.isCreativeMode)
                        {
                            --itemstack.stackSize;
                        }

                        healthMultiplier += 1;
                        Tools.println("Increased pet's health multiplier to " + healthMultiplier);

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

                        return true;
            			
            		}
            	}
                if (itemstack.getItem() == healingItem)
                {
                    ItemFood itemfood = (ItemFood)itemstack.getItem();

                    if (this.dataWatcher.getWatchableObjectFloat(18) < 20.0F)
                    {
                        if (!p_70085_1_.capabilities.isCreativeMode)
                        {
                            --itemstack.stackSize;
                        }

                        this.heal((float)itemfood.func_150905_g(itemstack));

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

                        return true;
                    }
                }
            }

            if (this.func_152114_e(p_70085_1_) && !this.worldObj.isRemote && !this.isBreedingItem(itemstack))
            {
                this.aiSit.setSitting(!this.isSitting());
                this.isJumping = false;
                this.setPathToEntity((PathEntity)null);
                this.setTarget((Entity)null);
                this.setAttackTarget((EntityLivingBase)null);
            }
        }
        else if (itemstack != null && itemstack.getItem() == befriendingItem && !this.isAngry())
        {
            if (!p_70085_1_.capabilities.isCreativeMode)
            {
                --itemstack.stackSize;
            }

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

            if (!this.worldObj.isRemote)
            {
                if (this.rand.nextInt(3) == 0)
                {
                	
                    this.setTamed(true);
                    
                	Tools.println("This is now a pet!");
                	if(this.getOwner() instanceof EntityPlayer)
                	{
                		EntityPlayer player = (EntityPlayer)this.getOwner();
                    	Tools.println("The owner is " + player.getDisplayName());
                	}
                	else
                	{
                		Tools.println("Owner unknown.");
                	}
                	
                    this.setPathToEntity((PathEntity)null);
                    this.setAttackTarget((EntityLivingBase)null);
                    this.aiSit.setSitting(true);
                    this.setHealth(20.0F);
                    this.func_152115_b(p_70085_1_.getUniqueID().toString());
                    this.playTameEffect(true);
                    this.worldObj.setEntityState(this, (byte)7);
                }
                else
                {
                    this.playTameEffect(false);
                    this.worldObj.setEntityState(this, (byte)6);
                }
            }

            return true;
        }

        return super.interact(p_70085_1_);
    }
    
    public boolean isBreedingItem(ItemStack stack)
    {
    	if(stack.getItem() == breedingItem)
    	{
    		return true;
    	}
        return false;
    }

    public int getMaxSpawnedInChunk()
    {
        return 8;
    }

    public boolean isAngry()
    {
        return (this.dataWatcher.getWatchableObjectByte(16) & 2) != 0;
    }

    public void setAngry(boolean p_70916_1_)
    {
        byte b0 = this.dataWatcher.getWatchableObjectByte(16);

        if (p_70916_1_)
        {
            this.dataWatcher.updateObject(16, Byte.valueOf((byte)(b0 | 2)));
        }
        else
        {
            this.dataWatcher.updateObject(16, Byte.valueOf((byte)(b0 & -3)));
        }
    }


    public void func_70918_i(boolean p_70918_1_)
    {
        if (p_70918_1_)
        {
            this.dataWatcher.updateObject(19, Byte.valueOf((byte)1));
        }
        else
        {
            this.dataWatcher.updateObject(19, Byte.valueOf((byte)0));
        }
    }

    public boolean func_70922_bv()
    {
        return this.dataWatcher.getWatchableObjectByte(19) == 1;
    }

    protected boolean canDespawn()
    {
        return !this.isTamed() && this.ticksExisted > 2400;
    }

    public boolean func_142018_a(EntityLivingBase p_142018_1_, EntityLivingBase p_142018_2_)
    {
        if (!(p_142018_1_ instanceof EntityCreeper) && !(p_142018_1_ instanceof EntityGhast))
        {
            if (p_142018_1_ instanceof EntityPet)
            {
            	EntityPet pet = (EntityPet)p_142018_1_;

                if (pet.isTamed() && pet.getOwner() == p_142018_2_)
                {
                    return false;
                }
            }

            return p_142018_1_ instanceof EntityPlayer && p_142018_2_ instanceof EntityPlayer && !((EntityPlayer)p_142018_2_).canAttackPlayer((EntityPlayer)p_142018_1_) ? false : !(p_142018_1_ instanceof EntityHorse) || !((EntityHorse)p_142018_1_).isTame();
        }
        else
        {
            return false;
        }
    }

@Override
public EntityAgeable createChild(EntityAgeable p_90011_1_)
{
	return null;
}
}

Your cat code: (fix it)

@Override
    public void writeEntityToNBT(NBTTagCompound nbt)
    {
        super.readEntityFromNBT(nbt);

 

If everything else is right, this should fix saving.

 

As to health: Why are you saving all those values (about health)?

this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(newHealth + (healthMultiplier * 2));

Error is most likely "healthMultiplier * 2" but idk what you want to archieve, it's more of a "debug it yourself". :C

 

If you have github I could find exact error.