--- a/net/minecraft/world/entity/animal/frog/ShootTongue.java
+++ b/net/minecraft/world/entity/animal/frog/ShootTongue.java
@@ -16,10 +16,15 @@
 import net.minecraft.world.entity.ai.memory.MemoryModuleType;
 import net.minecraft.world.entity.ai.memory.MemoryStatus;
 import net.minecraft.world.entity.ai.memory.WalkTarget;
+import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.pathfinder.Path;
 import net.minecraft.world.phys.Vec3;
+// CraftBukkit start
+import org.bukkit.event.entity.EntityRemoveEvent;
+// CraftBukkit end
 
 public class ShootTongue extends Behavior<Frog> {
+
     public static final int TIME_OUT_DURATION = 100;
     public static final int CATCH_ANIMATION_DURATION = 6;
     public static final int TONGUE_ANIMATION_DURATION = 10;
@@ -32,135 +37,126 @@
     private final SoundEvent tongueSound;
     private final SoundEvent eatSound;
     private Vec3 itemSpawnPos;
-    private ShootTongue.State state = ShootTongue.State.DONE;
+    private ShootTongue.State state;
 
     public ShootTongue(SoundEvent tongueSound, SoundEvent eatSound) {
-        super(
-            ImmutableMap.of(
-                MemoryModuleType.WALK_TARGET,
-                MemoryStatus.VALUE_ABSENT,
-                MemoryModuleType.LOOK_TARGET,
-                MemoryStatus.REGISTERED,
-                MemoryModuleType.ATTACK_TARGET,
-                MemoryStatus.VALUE_PRESENT,
-                MemoryModuleType.IS_PANICKING,
-                MemoryStatus.VALUE_ABSENT
-            ),
-            100
-        );
+        super(ImmutableMap.of(MemoryModuleType.WALK_TARGET, MemoryStatus.VALUE_ABSENT, MemoryModuleType.LOOK_TARGET, MemoryStatus.REGISTERED, MemoryModuleType.ATTACK_TARGET, MemoryStatus.VALUE_PRESENT, MemoryModuleType.IS_PANICKING, MemoryStatus.VALUE_ABSENT), 100);
+        this.state = ShootTongue.State.DONE;
         this.tongueSound = tongueSound;
         this.eatSound = eatSound;
     }
 
-    @Override
     protected boolean checkExtraStartConditions(ServerLevel world, Frog entity) {
-        LivingEntity livingEntity = entity.getBrain().getMemory(MemoryModuleType.ATTACK_TARGET).get();
-        boolean bl = this.canPathfindToTarget(entity, livingEntity);
-        if (!bl) {
+        LivingEntity entityliving = (LivingEntity) entity.getBrain().getMemory(MemoryModuleType.ATTACK_TARGET).get();
+        boolean flag = this.canPathfindToTarget(entity, entityliving);
+
+        if (!flag) {
             entity.getBrain().eraseMemory(MemoryModuleType.ATTACK_TARGET);
-            this.addUnreachableTargetToMemory(entity, livingEntity);
+            this.addUnreachableTargetToMemory(entity, entityliving);
         }
 
-        return bl && entity.getPose() != Pose.CROAKING && Frog.canEat(livingEntity);
+        return flag && entity.getPose() != Pose.CROAKING && Frog.canEat(entityliving);
     }
 
-    @Override
     protected boolean canStillUse(ServerLevel world, Frog entity, long time) {
-        return entity.getBrain().hasMemoryValue(MemoryModuleType.ATTACK_TARGET)
-            && this.state != ShootTongue.State.DONE
-            && !entity.getBrain().hasMemoryValue(MemoryModuleType.IS_PANICKING);
+        return entity.getBrain().hasMemoryValue(MemoryModuleType.ATTACK_TARGET) && this.state != ShootTongue.State.DONE && !entity.getBrain().hasMemoryValue(MemoryModuleType.IS_PANICKING);
     }
 
-    @Override
-    protected void start(ServerLevel serverLevel, Frog frog, long l) {
-        LivingEntity livingEntity = frog.getBrain().getMemory(MemoryModuleType.ATTACK_TARGET).get();
-        BehaviorUtils.lookAtEntity(frog, livingEntity);
-        frog.setTongueTarget(livingEntity);
-        frog.getBrain().setMemory(MemoryModuleType.WALK_TARGET, new WalkTarget(livingEntity.position(), 2.0F, 0));
+    protected void start(ServerLevel worldserver, Frog frog, long i) {
+        LivingEntity entityliving = (LivingEntity) frog.getBrain().getMemory(MemoryModuleType.ATTACK_TARGET).get();
+
+        BehaviorUtils.lookAtEntity(frog, entityliving);
+        frog.setTongueTarget(entityliving);
+        frog.getBrain().setMemory(MemoryModuleType.WALK_TARGET, (new WalkTarget(entityliving.position(), 2.0F, 0))); // CraftBukkit - decompile error
         this.calculatePathCounter = 10;
         this.state = ShootTongue.State.MOVE_TO_TARGET;
     }
 
-    @Override
-    protected void stop(ServerLevel serverLevel, Frog frog, long l) {
+    protected void stop(ServerLevel worldserver, Frog frog, long i) {
         frog.getBrain().eraseMemory(MemoryModuleType.ATTACK_TARGET);
         frog.eraseTongueTarget();
         frog.setPose(Pose.STANDING);
     }
 
     private void eatEntity(ServerLevel world, Frog frog) {
-        world.playSound(null, frog, this.eatSound, SoundSource.NEUTRAL, 2.0F, 1.0F);
+        world.playSound((Player) null, (Entity) frog, this.eatSound, SoundSource.NEUTRAL, 2.0F, 1.0F);
         Optional<Entity> optional = frog.getTongueTarget();
+
         if (optional.isPresent()) {
-            Entity entity = optional.get();
+            Entity entity = (Entity) optional.get();
+
             if (entity.isAlive()) {
                 frog.doHurtTarget(entity);
                 if (!entity.isAlive()) {
-                    entity.remove(Entity.RemovalReason.KILLED);
+                    entity.remove(Entity.RemovalReason.KILLED, EntityRemoveEvent.Cause.DEATH); // CraftBukkit - add Bukkit remove cause
                 }
             }
         }
+
     }
 
-    @Override
-    protected void tick(ServerLevel serverLevel, Frog frog, long l) {
-        LivingEntity livingEntity = frog.getBrain().getMemory(MemoryModuleType.ATTACK_TARGET).get();
-        frog.setTongueTarget(livingEntity);
-        switch (this.state) {
-            case MOVE_TO_TARGET:
-                if (livingEntity.distanceTo(frog) < 1.75F) {
-                    serverLevel.playSound(null, frog, this.tongueSound, SoundSource.NEUTRAL, 2.0F, 1.0F);
+    protected void tick(ServerLevel worldserver, Frog frog, long i) {
+        LivingEntity entityliving = (LivingEntity) frog.getBrain().getMemory(MemoryModuleType.ATTACK_TARGET).get();
+
+        frog.setTongueTarget(entityliving);
+        switch (this.state.ordinal()) {
+            case 0:
+                if (entityliving.distanceTo(frog) < 1.75F) {
+                    worldserver.playSound((Player) null, (Entity) frog, this.tongueSound, SoundSource.NEUTRAL, 2.0F, 1.0F);
                     frog.setPose(Pose.USING_TONGUE);
-                    livingEntity.setDeltaMovement(livingEntity.position().vectorTo(frog.position()).normalize().scale(0.75));
-                    this.itemSpawnPos = livingEntity.position();
+                    entityliving.setDeltaMovement(entityliving.position().vectorTo(frog.position()).normalize().scale(0.75D));
+                    this.itemSpawnPos = entityliving.position();
                     this.eatAnimationTimer = 0;
                     this.state = ShootTongue.State.CATCH_ANIMATION;
                 } else if (this.calculatePathCounter <= 0) {
-                    frog.getBrain().setMemory(MemoryModuleType.WALK_TARGET, new WalkTarget(livingEntity.position(), 2.0F, 0));
+                    frog.getBrain().setMemory(MemoryModuleType.WALK_TARGET, (new WalkTarget(entityliving.position(), 2.0F, 0))); // CraftBukkit - decompile error
                     this.calculatePathCounter = 10;
                 } else {
-                    this.calculatePathCounter--;
+                    --this.calculatePathCounter;
                 }
                 break;
-            case CATCH_ANIMATION:
+            case 1:
                 if (this.eatAnimationTimer++ >= 6) {
                     this.state = ShootTongue.State.EAT_ANIMATION;
-                    this.eatEntity(serverLevel, frog);
+                    this.eatEntity(worldserver, frog);
                 }
                 break;
-            case EAT_ANIMATION:
+            case 2:
                 if (this.eatAnimationTimer >= 10) {
                     this.state = ShootTongue.State.DONE;
                 } else {
-                    this.eatAnimationTimer++;
+                    ++this.eatAnimationTimer;
                 }
-            case DONE:
+            case 3:
         }
+
     }
 
     private boolean canPathfindToTarget(Frog entity, LivingEntity target) {
-        Path path = entity.getNavigation().createPath(target, 0);
-        return path != null && path.getDistToTarget() < 1.75F;
+        Path pathentity = entity.getNavigation().createPath((Entity) target, 0);
+
+        return pathentity != null && pathentity.getDistToTarget() < 1.75F;
     }
 
     private void addUnreachableTargetToMemory(Frog entity, LivingEntity target) {
-        List<UUID> list = entity.getBrain().getMemory(MemoryModuleType.UNREACHABLE_TONGUE_TARGETS).orElseGet(ArrayList::new);
-        boolean bl = !list.contains(target.getUUID());
-        if (list.size() == 5 && bl) {
+        List<UUID> list = (List) entity.getBrain().getMemory(MemoryModuleType.UNREACHABLE_TONGUE_TARGETS).orElseGet(ArrayList::new);
+        boolean flag = !list.contains(target.getUUID());
+
+        if (list.size() == 5 && flag) {
             list.remove(0);
         }
 
-        if (bl) {
+        if (flag) {
             list.add(target.getUUID());
         }
 
         entity.getBrain().setMemoryWithExpiry(MemoryModuleType.UNREACHABLE_TONGUE_TARGETS, list, 100L);
     }
 
-    static enum State {
-        MOVE_TO_TARGET,
-        CATCH_ANIMATION,
-        EAT_ANIMATION,
-        DONE;
+    private static enum State {
+
+        MOVE_TO_TARGET, CATCH_ANIMATION, EAT_ANIMATION, DONE;
+
+        private State() {}
     }
 }
