Files
HungryFrog/src/main/java/com/kasetoatz/hungryfrog/task/FrogEatBlockTask.java
2025-07-08 02:30:03 +02:00

236 lines
8.5 KiB
Java

package com.kasetoatz.hungryfrog.task;
import com.google.common.collect.ImmutableMap;
import com.kasetoatz.hungryfrog.HungryFrog;
import net.minecraft.block.*;
import net.minecraft.command.argument.EntityAnchorArgumentType;
import net.minecraft.entity.EntityPose;
import net.minecraft.entity.ItemEntity;
import net.minecraft.entity.ai.brain.MemoryModuleState;
import net.minecraft.entity.ai.brain.MemoryModuleType;
import net.minecraft.entity.ai.brain.WalkTarget;
import net.minecraft.entity.ai.brain.task.MultiTickTask;
import net.minecraft.entity.ai.pathing.Path;
import net.minecraft.entity.passive.FrogEntity;
import net.minecraft.fluid.FluidState;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.registry.tag.FluidTags;
import net.minecraft.server.world.ServerWorld;
import net.minecraft.sound.SoundCategory;
import net.minecraft.sound.SoundEvent;
import net.minecraft.sound.SoundEvents;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Direction;
import net.minecraft.util.math.Vec3d;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
public class FrogEatBlockTask extends MultiTickTask<FrogEntity>
{
public static final SoundEvent TONGUE_SOUND = SoundEvents.ENTITY_FROG_TONGUE;
public static final SoundEvent EAT_SOUND = SoundEvents.ENTITY_FROG_EAT;
private int eatTick;
private int moveToTargetTick;
private Phase phase;
public FrogEatBlockTask()
{
super(ImmutableMap.of(HungryFrog.BLOCK_TO_EAT, MemoryModuleState.VALUE_PRESENT), 100);
this.phase = Phase.DONE;
}
protected boolean shouldRun(ServerWorld world, FrogEntity frog)
{
Optional<BlockPos> memory = frog.getBrain().getOptionalRegisteredMemory(HungryFrog.BLOCK_TO_EAT);
if (memory.isEmpty())
{
return false;
}
BlockPos pos = memory.get();
boolean reachable = this.isBlockReachable(frog, pos);
if (!reachable)
{
frog.getBrain().forget(HungryFrog.BLOCK_TO_EAT);
this.markTargetAsUnreachable(frog, pos);
}
return reachable && frog.getPose() != EntityPose.CROAKING && frog.getBrain().getOptionalRegisteredMemory(MemoryModuleType.ATTACK_TARGET).isEmpty();
}
protected boolean shouldKeepRunning(ServerWorld world, FrogEntity frog, long time)
{
return frog.getBrain().hasMemoryModule(HungryFrog.BLOCK_TO_EAT) && this.phase != Phase.DONE && !frog.getBrain().hasMemoryModule(MemoryModuleType.IS_PANICKING);
}
protected void run(ServerWorld world, FrogEntity frog, long time)
{
Optional<BlockPos> value = frog.getBrain().getOptionalRegisteredMemory(HungryFrog.BLOCK_TO_EAT);
if (value.isEmpty())
{
return;
}
BlockPos pos = value.get();
frog.lookAt(EntityAnchorArgumentType.EntityAnchor.EYES, Vec3d.of(pos));
frog.getBrain().remember(MemoryModuleType.WALK_TARGET, new WalkTarget(pos, 2.F, 0));
this.moveToTargetTick = 10;
this.phase = Phase.MOVE_TO_TARGET;
}
protected void finishRunning(ServerWorld world, FrogEntity frog, long time)
{
frog.getBrain().forget(HungryFrog.BLOCK_TO_EAT);
frog.setPose(EntityPose.STANDING);
}
private void absorb(ServerWorld world, BlockPos pos)
{
BlockPos.iterateRecursively(pos, 6, 65, (currentPos, queuer) ->
{
for (Direction direction : Direction.values())
{
queuer.accept(currentPos.offset(direction));
}
}, currentPos ->
{
if (currentPos.equals(pos))
{
return BlockPos.IterationState.ACCEPT;
}
else
{
BlockState blockState = world.getBlockState(currentPos);
FluidState fluidState = world.getFluidState(currentPos);
if (!fluidState.isIn(FluidTags.WATER) && !fluidState.isIn(FluidTags.LAVA))
{
return BlockPos.IterationState.SKIP;
}
else if (blockState.getBlock() instanceof FluidDrainable fluidDrainable && !fluidDrainable.tryDrainFluid(null, world, currentPos, blockState).isEmpty())
{
return BlockPos.IterationState.ACCEPT;
}
else
{
if (blockState.getBlock() instanceof FluidBlock)
{
world.setBlockState(currentPos, Blocks.AIR.getDefaultState(), Block.NOTIFY_ALL);
}
else
{
if (!blockState.isOf(Blocks.KELP) && !blockState.isOf(Blocks.KELP_PLANT) && !blockState.isOf(Blocks.SEAGRASS) && !blockState.isOf(Blocks.TALL_SEAGRASS))
{
return BlockPos.IterationState.SKIP;
}
world.setBlockState(currentPos, Blocks.AIR.getDefaultState(), Block.NOTIFY_ALL);
}
return BlockPos.IterationState.ACCEPT;
}
}
});
}
private void eat(ServerWorld world, FrogEntity frog, BlockPos pos)
{
world.playSoundFromEntity(null, frog, EAT_SOUND, SoundCategory.NEUTRAL, 2.0F, 1.0F);
BlockState state = world.getBlockState(pos);
Item item = Item.BLOCK_ITEMS.get(state.getBlock());
if (state.isOf(Blocks.WATER) || state.isOf(Blocks.LAVA))
{
world.setBlockState(pos, Blocks.AIR.getDefaultState(), Block.NOTIFY_ALL);
this.absorb(world, pos);
}
else
{
world.removeBlock(pos, false);
}
if (item == null)
{
return;
}
ItemStack stack = new ItemStack(item);
ItemEntity entity = new ItemEntity(world, frog.getX(), frog.getY(), frog.getZ(), stack);
world.spawnEntity(entity);
}
protected void keepRunning(ServerWorld world, FrogEntity frog, long time)
{
Optional<BlockPos> memory = frog.getBrain().getOptionalRegisteredMemory(HungryFrog.BLOCK_TO_EAT);
if (memory.isEmpty())
{
return;
}
BlockPos pos = memory.get();
switch (this.phase)
{
case MOVE_TO_TARGET:
if (frog.getPos().distanceTo(Vec3d.of(pos)) < 1.75F)
{
world.playSoundFromEntity(null, frog, TONGUE_SOUND, SoundCategory.NEUTRAL, 2.0F, 1.0F);
frog.setPose(EntityPose.USING_TONGUE);
this.eatTick = 0;
this.phase = Phase.CATCH_ANIMATION;
}
else if (this.moveToTargetTick <= 0)
{
frog.getBrain().remember(MemoryModuleType.WALK_TARGET, new WalkTarget(pos, 2.F, 0));
this.moveToTargetTick = 10;
}
else
{
this.moveToTargetTick--;
}
break;
case CATCH_ANIMATION:
if (this.eatTick++ >= 6)
{
this.phase = Phase.EAT_ANIMATION;
this.eat(world, frog, pos);
}
break;
case EAT_ANIMATION:
if (this.eatTick >= 10)
{
this.phase = Phase.DONE;
}
else
{
this.eatTick++;
}
}
}
private boolean isBlockReachable(FrogEntity frog, BlockPos pos)
{
Path path = frog.getNavigation().findPathTo(pos, 0);
return path != null && path.getManhattanDistanceFromTarget() < 1.75F;
}
private void markTargetAsUnreachable(FrogEntity frog, BlockPos pos) {
try
{
List<BlockPos> list = frog.getBrain().getOptionalRegisteredMemory(HungryFrog.UNREACHABLE_BLOCK_TARGETS).orElse(new ArrayList<>());
boolean contains = !list.contains(pos);
if (list.size() == 5 && contains) {
list.removeFirst();
}
if (contains) {
list.add(pos);
}
frog.getBrain().remember(HungryFrog.UNREACHABLE_BLOCK_TARGETS, list, 100L);
}
catch (Exception e)
{
frog.getBrain().forget(HungryFrog.UNREACHABLE_BLOCK_TARGETS);
}
}
private enum Phase
{
MOVE_TO_TARGET,
CATCH_ANIMATION,
EAT_ANIMATION,
DONE
}
}