[1.7.10] slow custom mob

hello guys,

I have a problem with my custom mob.

I want my mob to run as quick as a player, but I can't get my mob faster than a walking player.

Here is the mob class:

public class EntityChow extends EntityNecromancerMinion{

public EntityChow(World world) {
	super(world);
	setCurrentItemOrArmor(0, new ItemStack(Items.wooden_sword));
}

public void applyEntityAttributes(){
	super.applyEntityAttributes();
	getEntityAttribute(SharedMonsterAttributes.attackDamage).setBaseValue(5);
	getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(5);
}

public EntityChow(Entity entity){
	this(entity, TargetType.DEFENSIVE);
	setCurrentItemOrArmor(0, new ItemStack(Items.wooden_sword));
}

public EntityChow(Entity entity, TargetType target){
	super(entity, target, new Position(entity));
}
}

Here is the class the mob extends:

public abstract class EntityNecromancerMinion extends EntityCreature{
/**
 * The master of the mob. This mob will fight for it's master as long as it is a necromancer.
 */
public Entity master;
/**
 * The UUID of the master as String.
 */
public String masterId;
/**
 * The way this mob will choose its target.
 */
public TargetType targetType;
/**
 * The team of the minion, the master of the minion is always the leader of the team.
 * Every minion of the master is in the same team.
 */
public UndeadTeam team;

private int pathCooldown = 0;
private int strikeCooldown;

public EntityNecromancerMinion(World world) {
	super(world);
}

public EntityNecromancerMinion(Entity owner){
	this(owner, new Position(owner));
}

public EntityNecromancerMinion(Entity owner, Position spawn){
	this(owner, TargetType.DEFENSIVE, spawn);
}

public EntityNecromancerMinion(Entity owner, TargetType type, Position spawn){
	super(owner.worldObj);
	setPosition(spawn.x, spawn.y, spawn.z);
	master = owner;
	team = UndeadTeam.getTeam(owner);
	targetType = type;
}

public EntityNecromancerMinion(Entity owner, double x, double y, double z){
	this(owner, new Position(x, y, z));
}

public EntityNecromancerMinion(Entity owner, TargetType type, double x, double y, double z){
	this(owner, type, new Position(x, y, z));
}

public EnumCreatureAttribute getCreatureAttribute(){
	return EnumCreatureAttribute.UNDEAD;
}

public boolean canDespawn(){
	return false;
}

public void writeEntityToNBT(NBTTagCompound nbt){
	super.writeEntityToNBT(nbt);
	if(master != null){
		nbt.setString("master", master.getUniqueID().toString());
	}
	if(targetType != null){
		targetType.writeToNBT(nbt);
	}
}

public void readEntityFromNBT(NBTTagCompound nbt){
	super.readEntityFromNBT(nbt);
	masterId = nbt.getString("master");
	targetType = TargetType.fromNBT(nbt);
}

public void onUpdate(){
	super.onUpdate();
	if(!worldObj.isRemote){
		if(master == null){
			if(masterId != null && !masterId.isEmpty()){
				master = EntityUtils.getEntityByUUID(worldObj, masterId);
			}
		}
		if(team == null && master != null && !worldObj.isRemote){
			team = UndeadTeam.getTeam(master);
			if(ticksExisted > 50 && team == null){
				worldObj.spawnEntityInWorld(new UndeadTeam(master));
			}
		}
		if(team != null){
			if(!team.members.contains(this)){
				team.members.add(this);
			}
			if(!team.members.contains(master) && master != null){
				team.members.add(master);
			}
			entityToAttack = team.getTarget(this);
		}
		if(entityToAttack != null){
			if(getFightType() == FightType.CLOSECOMBAT){
				if((!hasPath() || pathCooldown == 0) && !worldObj.isRemote){
					pathCooldown = 40;
					setPathToEntity(worldObj.getPathEntityToEntity(this, entityToAttack, (float) getEntityAttribute(SharedMonsterAttributes.followRange).getAttributeValue(), false, false, true, true));
				}
			}
			if(entityToAttack.isDead){
				entityToAttack = null;
			}
		}
		if(strikeCooldown > 0){
			--strikeCooldown;
		}
		if((getFightType() == FightType.CLOSECOMBAT || getFightType() == FightType.MULTIPLY) && (!worldObj.isRemote && entityToAttack != null)){
			if(Position.getSquaredDistance(new Position(this), new Position(entityToAttack)) < 3 && strikeCooldown <= 0){
				entityToAttack.attackEntityFrom(DamageSource.causeMobDamage(this), (float) getEntityAttribute(SharedMonsterAttributes.attackDamage).getAttributeValue());
				strikeCooldown = 10;
			}
		}
		if(master != null){
			double distance = Position.getSquaredDistance(new Position(this), new Position(master));
			if(distance > 32 && entityToAttack == null && !hasPath() && !isGhost()){
				setPathToEntity(worldObj.getPathEntityToEntity(this, master, (float) getEntityAttribute(SharedMonsterAttributes.followRange).getAttributeValue(), false, false, true, true));
			}
			if(distance > 48 && pathCooldown <= 0 && !isGhost()){
				setPathToEntity(worldObj.getPathEntityToEntity(this, master, (float) getEntityAttribute(SharedMonsterAttributes.followRange).getAttributeValue(), false, false, true, true));
				pathCooldown = 20;
			}
		}
	}
}
/**
 * How this entity will fight. It can be ranged, close combat or mulitply.
 * @return How this entity will fight.
 */
public FightType getFightType(){
	return FightType.CLOSECOMBAT;
}

public boolean attackEntityFrom(DamageSource source, float damage){
	Entity entity = source.getEntity();
	if(entity instanceof EntityNecromancerMinion){
		EntityNecromancerMinion minion = (EntityNecromancerMinion) entity;
		if(master != null && master == minion.master){
			return false;
		}
	}
	else if(entity == master && master != null){
		return false;
	}
	else if(entity instanceof EntityLivingBase && team != null){
		team.addTarget(entity, false, true);
	}
	return super.attackEntityFrom(source, damage);
}

public void applyEntityAttributes(){
	super.applyEntityAttributes();
	getAttributeMap().registerAttribute(SharedMonsterAttributes.attackDamage);
	getEntityAttribute(SharedMonsterAttributes.followRange).setBaseValue(64);
}

public boolean interact(EntityPlayer player){
	return true;
}

public boolean isGhost(){
	return false;
}
}

If I set the movement speed slower, the mob will move slower, but how high I make the movementSpeed, the mob will not run faster than a walking player.

Does anybody know how to make this mob faster.