236 lines
8.5 KiB
Java
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
|
|
}
|
|
}
|