[1.15.2] Custom Bat entity won't attack the player unless really close

[PenWallet]

Hi, I'm working on a mod for 1.15.2. I want this custom Bat entity (IridiumBat) to attack the player on sight. Instead, it's only attacking the player if it's really close. It looks as if the bat is actually trying to get closer to me, but it's like fighting its instruction of flying randomly. I've looked around BatEntity looking for a clue as to what's causing it, but I wouldn't really know what to change.

 

I assigned the ZombieAttackModifiedGoal to the IridiumBat, which is just a modified version of ZombieAttackGoal (made it accept IridiumBat in the constructor parameters and deleted the raiseArms parameters). Because ZombieAttackGoal extends from MeleeAttackGoal, which doesn't accept AmbientEntity in its constructor parameters, I needed to make a MeleeAttackModifiedGoal to accept it as well, which is what ZombieAttackModifiedGoal extends now.

 

IridiumBat.java:

public class IridiumBat extends BatEntity {

    @SuppressWarnings("unchecked")
    public IridiumBat(EntityType<? extends BatEntity> type, World worldIn) {
        super((EntityType<? extends BatEntity>) EntitiesList.IRIDIUM_BAT, worldIn);
    }

    @Override
    protected void registerAttributes() {
        super.registerAttributes();
        this.getAttribute(SharedMonsterAttributes.MAX_HEALTH).setBaseValue(15.0f);
        this.getAttributes().registerAttribute(SharedMonsterAttributes.ATTACK_DAMAGE);
        this.getAttribute(SharedMonsterAttributes.ATTACK_DAMAGE).setBaseValue(1.0f);
        this.getAttribute(SharedMonsterAttributes.FOLLOW_RANGE).setBaseValue(35.0f);
    }

    @Override
    protected void registerGoals() {
        this.goalSelector.addGoal(8, new LookRandomlyGoal(this));
        this.goalSelector.addGoal(8, new LookAtGoal(this, PlayerEntity.class, 8.0F));
        this.goalSelector.addGoal(0, new ZombieAttackModifiedGoal(this, 1.0D, true));
        this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, PlayerEntity.class, false));
    }
}

 

ZombieAttackedModifiedGoal.java:

public class ZombieAttackModifiedGoal extends MeleeAttackModifiedGoal {
    private final IridiumBat bat;

    public ZombieAttackModifiedGoal(IridiumBat bat, double speed, boolean useLongMemory) {
        super(bat, speed, useLongMemory);
        this.bat = bat;
    }

    /**
     * Execute a one shot task or start executing a continuous task
     */
    public void startExecuting() {
        super.startExecuting();
    }

    /**
     * Reset the task's internal state. Called when this task is interrupted by another one
     */
    public void resetTask() {
        super.resetTask();
        this.bat.setAggroed(false);
    }

    /**
     * Keep ticking a continuous task that has already been started
     */
    public void tick() {
        super.tick();
        if (this.attackTick < 10) {
            this.bat.setAggroed(true);
        } else {
            this.bat.setAggroed(false);
        }

    }
}

 

MeleeAttackModifiedGoal.java:

public class MeleeAttackModifiedGoal extends Goal {
    protected final IridiumBat attacker;
    protected int attackTick;
    private final double speedTowardsTarget;
    private final boolean longMemory;
    private Path path;
    private int delayCounter;
    private double targetX;
    private double targetY;
    private double targetZ;
    protected final int attackInterval = 20;
    private long field_220720_k;
    private int failedPathFindingPenalty = 0;
    private boolean canPenalize = false;

    public MeleeAttackModifiedGoal(IridiumBat creature, double speedIn, boolean useLongMemory) {
        this.attacker = creature;
        this.speedTowardsTarget = speedIn;
        this.longMemory = useLongMemory;
        this.setMutexFlags(EnumSet.of(Goal.Flag.MOVE, Goal.Flag.LOOK));
    }

    /**
     * Returns whether the EntityAIBase should begin execution.
     */
    public boolean shouldExecute() {
        long i = this.attacker.world.getGameTime();
        if (i - this.field_220720_k < 20L) {
            return false;
        } else {
            this.field_220720_k = i;
            LivingEntity livingentity = this.attacker.getAttackTarget();
            if (livingentity == null) {
                return false;
            } else if (!livingentity.isAlive()) {
                return false;
            } else {
                if (canPenalize) {
                    if (--this.delayCounter <= 0) {
                        this.path = this.attacker.getNavigator().getPathToEntityLiving(livingentity, 0);
                        this.delayCounter = 4 + this.attacker.getRNG().nextInt(7);
                        return this.path != null;
                    } else {
                        return true;
                    }
                }
                this.path = this.attacker.getNavigator().getPathToEntityLiving(livingentity, 0);
                if (this.path != null) {
                    return true;
                } else {
                    return this.getAttackReachSqr(livingentity) >= this.attacker.getDistanceSq(livingentity.func_226277_ct_(), livingentity.func_226278_cu_(), livingentity.func_226281_cx_());
                }
            }
        }
    }

    /**
     * Returns whether an in-progress EntityAIBase should continue executing
     */
    public boolean shouldContinueExecuting() {
        LivingEntity livingentity = this.attacker.getAttackTarget();
        if (livingentity == null) {
            return false;
        } else if (!livingentity.isAlive()) {
            return false;
        } else if (!this.longMemory) {
            return !this.attacker.getNavigator().noPath();
        } else if (!this.attacker.isWithinHomeDistanceFromPosition(new BlockPos(livingentity))) {
            return false;
        } else {
            return !(livingentity instanceof PlayerEntity) || !livingentity.isSpectator() && !((PlayerEntity)livingentity).isCreative();
        }
    }

    /**
     * Execute a one shot task or start executing a continuous task
     */
    public void startExecuting() {
        this.attacker.getNavigator().setPath(this.path, this.speedTowardsTarget);
        this.attacker.setAggroed(true);
        this.delayCounter = 0;
    }

    /**
     * Reset the task's internal state. Called when this task is interrupted by another one
     */
    public void resetTask() {
        LivingEntity livingentity = this.attacker.getAttackTarget();
        if (!EntityPredicates.CAN_AI_TARGET.test(livingentity)) {
            this.attacker.setAttackTarget((LivingEntity)null);
        }

        this.attacker.setAggroed(false);
        this.attacker.getNavigator().clearPath();
    }

    /**
     * Keep ticking a continuous task that has already been started
     */
    public void tick() {
        LivingEntity livingentity = this.attacker.getAttackTarget();
        this.attacker.getLookController().setLookPositionWithEntity(livingentity, 30.0F, 30.0F);
        double d0 = this.attacker.getDistanceSq(livingentity.func_226277_ct_(), livingentity.func_226278_cu_(), livingentity.func_226281_cx_());
        --this.delayCounter;
        if ((this.longMemory || this.attacker.getEntitySenses().canSee(livingentity)) && this.delayCounter <= 0 && (this.targetX == 0.0D && this.targetY == 0.0D && this.targetZ == 0.0D || livingentity.getDistanceSq(this.targetX, this.targetY, this.targetZ) >= 1.0D || this.attacker.getRNG().nextFloat() < 0.05F)) {
            this.targetX = livingentity.func_226277_ct_();
            this.targetY = livingentity.func_226278_cu_();
            this.targetZ = livingentity.func_226281_cx_();
            this.delayCounter = 4 + this.attacker.getRNG().nextInt(7);
            if (this.canPenalize) {
                this.delayCounter += failedPathFindingPenalty;
                if (this.attacker.getNavigator().getPath() != null) {
                    net.minecraft.pathfinding.PathPoint finalPathPoint = this.attacker.getNavigator().getPath().getFinalPathPoint();
                    if (finalPathPoint != null && livingentity.getDistanceSq(finalPathPoint.x, finalPathPoint.y, finalPathPoint.z) < 1)
                        failedPathFindingPenalty = 0;
                    else
                        failedPathFindingPenalty += 10;
                } else {
                    failedPathFindingPenalty += 10;
                }
            }
            if (d0 > 1024.0D) {
                this.delayCounter += 10;
            } else if (d0 > 256.0D) {
                this.delayCounter += 5;
            }

            if (!this.attacker.getNavigator().tryMoveToEntityLiving(livingentity, this.speedTowardsTarget)) {
                this.delayCounter += 15;
            }
        }

        this.attackTick = Math.max(this.attackTick - 1, 0);
        this.checkAndPerformAttack(livingentity, d0);
    }

    protected void checkAndPerformAttack(LivingEntity enemy, double distToEnemySqr) {
        double d0 = this.getAttackReachSqr(enemy);
        if (distToEnemySqr <= d0 && this.attackTick <= 0) {
            this.attackTick = 20;
            this.attacker.swingArm(Hand.MAIN_HAND);
            this.attacker.attackEntityAsMob(enemy);
        }

    }

    protected double getAttackReachSqr(LivingEntity attackTarget) {
        return (double)(this.attacker.getWidth() * 2.0F * this.attacker.getWidth() * 2.0F + attackTarget.getWidth());
    }
}

 

A small video of the current behavior

 

I'm completely new to modding (just started a few days ago), so any lessons I can learn from this will be most useful, thanks.

[imacatlolol]

The latter half of updateAITasks in the original BatEntity class might be part of the issue. Try playing around with the code there (such as making it only run when the bat doesn't have an attack target) and seeing if that helps.

[PenWallet]

1 minute ago, imacatlolol said:

The latter half of updateAITasks in the original BatEntity class might be part of the issue. Try playing around with the code there (such as making it only run when the bat doesn't have an attack target) and seeing if that helps.

From what you said I understand I will have to copy the original code from BatEntity and change that condition, but how would I check it doesn't have an attack target? Sorry for being such a noob

[imacatlolol]

8 minutes ago, PenWallet said:

From what you said I understand I will have to copy the original code from BatEntity and change that condition, but how would I check it doesn't have an attack target?

You can call getAttackTarget for that. Make sure to also validate the target using canAttack just to keep things clean.

I'd recommend checking out the updateAITasks in BlazeEntity as a reference. Lots of stuff can be learned just by exploring vanilla classes.

8 minutes ago, PenWallet said:

Sorry for being such a noob

Nah don't worry, we all are at the beginning.

[PenWallet]

1 hour ago, imacatlolol said:

You can call getAttackTarget for that. Make sure to also validate the target using canAttack just to keep things clean.

I'd recommend checking out the updateAITasks in BlazeEntity as a reference. Lots of stuff can be learned just by exploring vanilla classes.

Nah don't worry, we all are at the beginning.

Thanks for that, that was definitely a step in the right direction, but now I'm stuck on how to make it move towards the player. I used moveToBlockPosAndAngles() but what it does is teleporting the bat to the player. Any idea on how I would make it move towards me, like a Zombie would (but flying)?

[imacatlolol]

Well there's a few options, but generally you'd want to use setMotion for this sort of thing. I haven't messed around much with entity motion, but if I had to guess, you would first call getMotion to use as a base, then add the look vector (getLookVec) multiplied by some amount. Not sure if it'll work as expected, but it should give you an idea of where to go from there.