diff --git a/common/src/main/java/fr/rakambda/fallingtree/common/tree/Tree.java b/common/src/main/java/fr/rakambda/fallingtree/common/tree/Tree.java index 7cc324c2..64669be1 100644 --- a/common/src/main/java/fr/rakambda/fallingtree/common/tree/Tree.java +++ b/common/src/main/java/fr/rakambda/fallingtree/common/tree/Tree.java @@ -2,142 +2,41 @@ import fr.rakambda.fallingtree.common.wrapper.IBlockPos; import fr.rakambda.fallingtree.common.wrapper.ILevel; -import lombok.Getter; -import lombok.RequiredArgsConstructor; import org.jspecify.annotations.NonNull; -import java.util.Arrays; import java.util.Collection; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.Map; import java.util.Optional; -import java.util.Set; -import static java.util.Comparator.comparingInt; -import static java.util.Objects.isNull; -import static java.util.stream.Collectors.toSet; +import java.util.stream.Stream; -@RequiredArgsConstructor -public class Tree{ - @Getter - @NonNull - private final ILevel level; - @Getter - @NonNull - private final IBlockPos hitPos; - @Getter - private final Set parts = new LinkedHashSet<>(); - private final Map partCounts = new LinkedHashMap<>(); +public interface Tree{ - public void addPart(@NonNull TreePart treePart){ - parts.add(treePart); - partCounts.compute(treePart.treePartType(), (key, value) -> { - if(isNull(value)){ - return 1; - } - return value + 1; - }); - } + int getBreakableCount(); - public void removePartsHigherThan(int y, @NonNull TreePartType partType){ - parts.removeIf(part -> { - if(part.treePartType() == partType && part.blockPos().getY() > y){ - decrementPartCount(partType); - return true; - } - return false; - }); - } + @NonNull Optional getLastSequencePart(); - public int getBreakableCount(){ - return Arrays.stream(TreePartType.getValues()) - .filter(TreePartType::isBreakable) - .mapToInt(this::getPartCount) - .sum(); - } + @NonNull Optional getLastSequenceLogPart(); - private int getPartCount(@NonNull TreePartType treePartType){ - return partCounts.computeIfAbsent(treePartType, key -> 0); - } + @NonNull Collection getBreakableLogs(); - public int getSize(){ - return partCounts.values().stream().mapToInt(i -> i).sum(); - } + @NonNull Collection getBreakableParts(); - private void decrementPartCount(@NonNull TreePartType partType){ - partCounts.computeIfPresent(partType, (type, count) -> Math.max(0, count - 1)); - } + int getLogCount(); - @NonNull - public Optional getLastSequencePart(){ - return getParts().stream() - .max(comparingInt(TreePart::sequence)); - } + @NonNull Optional getTopMostLog(); - @NonNull - public Optional getLastSequenceLogPart(){ - return getParts().stream() - .filter(part -> part.treePartType().isLog()) - .max(comparingInt(TreePart::sequence)); - } + @NonNull Optional getBottomMostLog(); - @NonNull - public Collection getBreakableLogs(){ - return getParts().stream() - .filter(part -> part.treePartType().isLog()) - .filter(part -> part.treePartType().isBreakable()) - .collect(toSet()); - } + @NonNull Optional getTopMostPart(); - @NonNull - public Collection getBreakableParts(){ - return getParts().stream() - .filter(part -> part.treePartType().isBreakable()) - .collect(toSet()); - } + @NonNull Collection getNetherWarts(); - public int getLogCount(){ - return getPartCount(TreePartType.LOG); - } + @NonNull Collection getMangroveRoots(); - @NonNull - public Optional getTopMostLog(){ - return getBreakableLogs().stream() - .map(TreePart::blockPos) - .max(comparingInt(IBlockPos::getY)); - } + @NonNull Optional getStart(); - @NonNull - public Optional getBottomMostLog(){ - return getBreakableLogs().stream() - .map(TreePart::blockPos) - .min(comparingInt(IBlockPos::getY)); - } + @NonNull Stream getPartsStream(); - @NonNull - private Optional getTopMostPart(){ - return getParts().stream() - .map(TreePart::blockPos) - .max(comparingInt(IBlockPos::getY)); - } + ILevel getLevel(); - @NonNull - public Collection getNetherWarts(){ - return getParts().stream() - .filter(part -> part.treePartType() == TreePartType.NETHER_WART) - .collect(toSet()); - } - - @NonNull - public Collection getMangroveRoots(){ - return getParts().stream() - .filter(part -> part.treePartType() == TreePartType.MANGROVE_ROOTS) - .collect(toSet()); - } - - @NonNull - public Optional getStart(){ - return getParts().stream() - .filter(part -> part.treePartType() == TreePartType.LOG_START) - .findFirst(); - } + IBlockPos getHitPos(); } + diff --git a/common/src/main/java/fr/rakambda/fallingtree/common/tree/TreeHandler.java b/common/src/main/java/fr/rakambda/fallingtree/common/tree/TreeHandler.java index 073f1a97..5276e73d 100644 --- a/common/src/main/java/fr/rakambda/fallingtree/common/tree/TreeHandler.java +++ b/common/src/main/java/fr/rakambda/fallingtree/common/tree/TreeHandler.java @@ -34,67 +34,143 @@ public class TreeHandler{ private final FallingTreeCommon mod; private final Map speedCache = new ConcurrentHashMap<>(); - public boolean shouldCancelEvent(@NonNull ILevel level, @NonNull IPlayer player, @NonNull IBlockPos originPos, @NonNull IBlockState originState, @Nullable IBlockEntity originEntity){ - if(!mod.isPlayerInRightState(player)){ + public class TreeHandlerState{ + @NonNull + private final IPlayer player; + @NonNull + private final ILevel level; + @NonNull + private final IBlockPos originPos; + @NonNull + private final IBlockState originState; + @Nullable + private final IBlockEntity originEntity; + + @Nullable + private Tree treeCache = null; + + public TreeHandlerState(@NonNull IPlayer player, @NonNull ILevel level, @NonNull IBlockPos originPos, @NonNull IBlockState originState, @Nullable IBlockEntity originEntity){ + this.player = player; + this.level = level; + this.originPos = originPos; + this.originState = originState; + this.originEntity = originEntity; + } + + public Tree getTree() throws TreeTooBigException{ + if(this.treeCache == null){ + this.treeCache = mod.getTreeBuilder().getTree(player, level, originPos, originState, originEntity).orElse(null); + } + + return this.treeCache; + } + + public boolean shouldCancelEvent(){ + if(!mod.isPlayerInRightState(player)){ + return false; + } + if(shouldPreserveTool(player)){ + return true; + } + try{ + this.getTree(); + } + catch(TreeTooBigException e){ + return false; + } return false; } - if(shouldPreserveTool(player)){ - return true; + + @NonNull + public IBreakAttemptResult breakTree(boolean isCancellable){ + if(!level.isServer()){ + return AbortedResult.NOT_SERVER; + } + if(!mod.getConfiguration().getTrees().isTreeBreaking()){ + return AbortedResult.NOT_ENABLED; + } + + if(!mod.checkForceToolUsage(player, level, originPos)){ + mod.notifyPlayer(player, mod.translate("chat.fallingtree.force_tool_usage", mod.getConfiguration().getTrees().getMaxScanSize())); + return AbortedResult.REQUIRED_TOOL_ABSENT; + } + + if(!mod.isPlayerInRightState(player)){ + return AbortedResult.INVALID_PLAYER_STATE; + } + + try{ + var tree = this.getTree(); + if(tree == null){ + return AbortedResult.NO_SUCH_TREE; + } + + var breakMode = getBreakMode(player.getMainHandItem()); + return getBreakingHandler(breakMode).breakTree(isCancellable, player, tree); + } + catch(TreeTooBigException e){ + mod.notifyPlayer(player, mod.translate("chat.fallingtree.tree_too_big", mod.getConfiguration().getTrees().getMaxScanSize())); + return AbortedResult.TREE_TOO_BIG_SCAN; + } + catch(BreakTreeTooSmallException e){ + // mod.notifyPlayer(player, mod.translate("chat.fallingtree.break_tree_too_small", mod.getConfiguration().getTrees().getMinSize())); + return AbortedResult.TREE_TOO_SMALL_BREAK; + } + catch(BreakTreeTooBigException e){ + mod.notifyPlayer(player, mod.translate("chat.fallingtree.break_tree_too_big", mod.getConfiguration().getTrees().getMaxSize())); + return AbortedResult.TREE_TOO_BIG_BREAK; + } } - try{ - mod.getTreeBuilder().getTree(player, level, originPos, originState, originEntity).isEmpty(); + + @NonNull + public Optional getBreakSpeed(float originalSpeed){ + if(!mod.getConfiguration().getTrees().isTreeBreaking()){ + return Optional.empty(); + } + if(!getBreakMode(player.getMainHandItem()).isApplySpeedMultiplier()){ + return Optional.empty(); + } + if(!mod.isPlayerInRightState(player)){ + return Optional.empty(); + } + + var cacheSpeed = speedCache.compute(player.getUUID(), (uuid, speed) -> { + if(isNull(speed) || !speed.isValid(originPos)){ + speed = getSpeed(originalSpeed); + } + return speed; + }); + return Optional.ofNullable(cacheSpeed).map(CacheSpeed::getSpeed); } - catch(TreeTooBigException e){ - return false; + + @Nullable + private CacheSpeed getSpeed(float originalSpeed){ + var speedMultiplicand = mod.getConfiguration().getTools().getSpeedMultiplicand(); + try{ + return speedMultiplicand <= 0 ? null : + Optional.ofNullable(this.getTree()) + .map(tree -> new CacheSpeed(originPos, originalSpeed / ((float) speedMultiplicand * tree.getLogCount()))) + .orElse(null); + } + catch(TreeTooBigException e){ + return null; + } } - return false; } private boolean shouldPreserveTool(@NonNull IPlayer player){ var handItem = player.getMainHandItem(); return mod.getConfiguration().getTools().getDurabilityMode().shouldPreserve(handItem.getDurability()); } + @NonNull + public TreeHandlerState create(@NonNull ILevel level, @NonNull IPlayer player, @NonNull IBlockPos originPos, @NonNull IBlockState originState) { + return create(level, player, originPos, originState, null); + } + @NonNull - public IBreakAttemptResult breakTree(boolean isCancellable, @NonNull ILevel level, @NonNull IPlayer player, @NonNull IBlockPos originPos, @NonNull IBlockState originState, @Nullable IBlockEntity originEntity){ - if(!level.isServer()){ - return AbortedResult.NOT_SERVER; - } - if(!mod.getConfiguration().getTrees().isTreeBreaking()){ - return AbortedResult.NOT_ENABLED; - } - - if(!mod.checkForceToolUsage(player, level, originPos)){ - mod.notifyPlayer(player, mod.translate("chat.fallingtree.force_tool_usage", mod.getConfiguration().getTrees().getMaxScanSize())); - return AbortedResult.REQUIRED_TOOL_ABSENT; - } - - if(!mod.isPlayerInRightState(player)){ - return AbortedResult.INVALID_PLAYER_STATE; - } - - try{ - var treeOptional = mod.getTreeBuilder().getTree(player, level, originPos, originState, originEntity); - if(treeOptional.isEmpty()){ - return AbortedResult.NO_SUCH_TREE; - } - - var tree = treeOptional.get(); - var breakMode = getBreakMode(player.getMainHandItem()); - return getBreakingHandler(breakMode).breakTree(isCancellable, player, tree); - } - catch(TreeTooBigException e){ - mod.notifyPlayer(player, mod.translate("chat.fallingtree.tree_too_big", mod.getConfiguration().getTrees().getMaxScanSize())); - return AbortedResult.TREE_TOO_BIG_SCAN; - } - catch(BreakTreeTooSmallException e){ - // mod.notifyPlayer(player, mod.translate("chat.fallingtree.break_tree_too_small", mod.getConfiguration().getTrees().getMinSize())); - return AbortedResult.TREE_TOO_SMALL_BREAK; - } - catch(BreakTreeTooBigException e){ - mod.notifyPlayer(player, mod.translate("chat.fallingtree.break_tree_too_big", mod.getConfiguration().getTrees().getMaxSize())); - return AbortedResult.TREE_TOO_BIG_BREAK; - } + public TreeHandlerState create(@NonNull ILevel level, @NonNull IPlayer player, @NonNull IBlockPos originPos, @NonNull IBlockState originState, @Nullable IBlockEntity originEntity) { + return new TreeHandlerState(player, level, originPos, originState, originEntity); } @NonNull @@ -114,39 +190,4 @@ private ITreeBreakingHandler getBreakingHandler(@NonNull BreakMode breakMode){ case SHIFT_DOWN -> ShiftDownTreeBreakingHandler.getInstance(mod); }; } - - @NonNull - public Optional getBreakSpeed(@NonNull IPlayer player, @NonNull IBlockPos blockPos, @NonNull IBlockState blockState, float originalSpeed){ - if(!mod.getConfiguration().getTrees().isTreeBreaking()){ - return Optional.empty(); - } - if(!getBreakMode(player.getMainHandItem()).isApplySpeedMultiplier()){ - return Optional.empty(); - } - if(!mod.isPlayerInRightState(player)){ - return Optional.empty(); - } - - var cacheSpeed = speedCache.compute(player.getUUID(), (uuid, speed) -> { - if(isNull(speed) || !speed.isValid(blockPos)){ - speed = getSpeed(player, blockPos, blockState, originalSpeed); - } - return speed; - }); - return Optional.ofNullable(cacheSpeed).map(CacheSpeed::getSpeed); - } - - @Nullable - private CacheSpeed getSpeed(@NonNull IPlayer player, @NonNull IBlockPos pos, @NonNull IBlockState blockState, float originalSpeed){ - var speedMultiplicand = mod.getConfiguration().getTools().getSpeedMultiplicand(); - try{ - return speedMultiplicand <= 0 ? null : - mod.getTreeBuilder().getTree(player, player.getLevel(), pos, blockState, null) - .map(tree -> new CacheSpeed(pos, originalSpeed / ((float) speedMultiplicand * tree.getLogCount()))) - .orElse(null); - } - catch(TreeTooBigException e){ - return null; - } - } } diff --git a/common/src/main/java/fr/rakambda/fallingtree/common/tree/breaking/FallingAnimationTreeBreakingHandler.java b/common/src/main/java/fr/rakambda/fallingtree/common/tree/breaking/FallingAnimationTreeBreakingHandler.java index 9ac8b2b6..3eef9bdd 100644 --- a/common/src/main/java/fr/rakambda/fallingtree/common/tree/breaking/FallingAnimationTreeBreakingHandler.java +++ b/common/src/main/java/fr/rakambda/fallingtree/common/tree/breaking/FallingAnimationTreeBreakingHandler.java @@ -81,7 +81,7 @@ public IBreakAttemptResult breakTree(boolean isCancellable, @NonNull IPlayer pla var lootHandler = new LootHandler(wantToBreakCount, mod.getConfiguration().getTrees().getTrunkLootPercentage()); var brokenCount = 0; var breakablePartsLeft = wantToBreakCount; - var breakableParts = tree.getParts().stream().sorted(mod.getConfiguration().getTrees().getBreakOrder().getComparator()).toList(); + var breakableParts = tree.getPartsStream().sorted(mod.getConfiguration().getTrees().getBreakOrder().getComparator()).toList(); for(var part : breakableParts){ if(part.treePartType().isBreakable()){ if(breakablePartsLeft == 0){ diff --git a/common/src/main/java/fr/rakambda/fallingtree/common/tree/builder/MutableTree.java b/common/src/main/java/fr/rakambda/fallingtree/common/tree/builder/MutableTree.java new file mode 100644 index 00000000..1521d854 --- /dev/null +++ b/common/src/main/java/fr/rakambda/fallingtree/common/tree/builder/MutableTree.java @@ -0,0 +1,219 @@ +package fr.rakambda.fallingtree.common.tree.builder; + +import fr.rakambda.fallingtree.common.tree.Tree; +import fr.rakambda.fallingtree.common.tree.TreePart; +import fr.rakambda.fallingtree.common.tree.TreePartType; +import fr.rakambda.fallingtree.common.wrapper.IBlockPos; +import fr.rakambda.fallingtree.common.wrapper.ILevel; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import org.jspecify.annotations.NonNull; +import org.jspecify.annotations.Nullable; +import java.util.Arrays; +import java.util.Collection; +import java.util.Comparator; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Stream; +import static java.util.Comparator.comparingInt; +import static java.util.Objects.isNull; +import static java.util.stream.Collectors.toSet; + +@RequiredArgsConstructor +class MutableTree implements Tree{ + @Getter + @NonNull + private final ILevel level; + @Getter + @NonNull + private final IBlockPos hitPos; + @Getter + private final Set parts = new LinkedHashSet<>(); + private final Map partCounts = new LinkedHashMap<>(); + private final ExtremumBlocks extremumBlocks = new ExtremumBlocks(); + + void addPart(@NonNull TreePart treePart){ + parts.add(treePart); + partCounts.compute(treePart.treePartType(), (key, value) -> { + if(isNull(value)){ + return 1; + } + return value + 1; + }); + } + + void removePartsHigherThan(int y, @NonNull TreePartType partType){ + parts.removeIf(part -> { + if(part.treePartType() == partType && part.blockPos().getY() > y){ + decrementPartCount(partType); + this.extremumBlocks.onRemoved(part); + return true; + } + return false; + }); + } + + @Override + public int getBreakableCount(){ + return Arrays.stream(TreePartType.getValues()) + .filter(TreePartType::isBreakable) + .mapToInt(this::getPartCount) + .sum(); + } + + private int getPartCount(@NonNull TreePartType treePartType){ + return partCounts.computeIfAbsent(treePartType, key -> 0); + } + + int getSize(){ + return partCounts.values().stream().mapToInt(i -> i).sum(); + } + + private void decrementPartCount(@NonNull TreePartType partType){ + partCounts.computeIfPresent(partType, (type, count) -> Math.max(0, count - 1)); + } + + @Override + public @NonNull Optional getLastSequencePart(){ + return getParts().stream() + .max(comparingInt(TreePart::sequence)); + } + + @Override + public @NonNull Optional getLastSequenceLogPart(){ + return getParts().stream() + .filter(part -> part.treePartType().isLog()) + .max(comparingInt(TreePart::sequence)); + } + + @Override + public @NonNull Collection getBreakableLogs(){ + return getParts().stream() + .filter(part -> part.treePartType().isLog()) + .filter(part -> part.treePartType().isBreakable()) + .collect(toSet()); + } + + @Override + public @NonNull Collection getBreakableParts(){ + return getParts().stream() + .filter(part -> part.treePartType().isBreakable()) + .collect(toSet()); + } + + @Override + public int getLogCount(){ + return getPartCount(TreePartType.LOG); + } + + private class ExtremumBlocks{ + + @Nullable + private TreePart topMostLog = null; + + @Nullable + private TreePart bottomMostLog = null; + + @Nullable + private TreePart logStart = null; + + public Optional getTopMostLog(){ + if(topMostLog != null){ + return Optional.of(topMostLog); + } + + this.topMostLog = parts.stream() + .filter(treePart -> treePart.treePartType() == TreePartType.LOG) + .max(Comparator.comparing(treePart -> treePart.blockPos().getY())) + .orElse(null); + + return Optional.ofNullable(topMostLog); + } + + public Optional getBottomMostLog(){ + if(bottomMostLog != null){ + return Optional.of(bottomMostLog); + } + + this.bottomMostLog = parts.stream() + .filter(treePart -> treePart.treePartType() == TreePartType.LOG) + .min(Comparator.comparing(treePart -> treePart.blockPos().getY())) + .orElse(null); + + return Optional.ofNullable(bottomMostLog); + } + + public Optional getLogStart(){ + if(logStart != null){ + return Optional.of(logStart); + } + + this.logStart = parts.stream() + .filter(treePart -> treePart.treePartType() == TreePartType.LOG_START) + .findFirst() + .orElse(null); + + return Optional.ofNullable(logStart); + } + + public void onRemoved(@NonNull final TreePart removedTreePart){ + if(topMostLog != null && topMostLog.equals(removedTreePart)){ + this.topMostLog = null; + } + + if(bottomMostLog != null && bottomMostLog.equals(removedTreePart)){ + this.bottomMostLog = null; + } + + if(logStart != null && logStart.equals(removedTreePart)){ + this.logStart = null; + } + } + } + + @Override + public @NonNull Optional getTopMostLog(){ + return extremumBlocks.getTopMostLog() + .map(TreePart::blockPos); + } + + @Override + public @NonNull Optional getBottomMostLog(){ + return extremumBlocks.getBottomMostLog() + .map(TreePart::blockPos); + } + + @Override + public @NonNull Optional getTopMostPart(){ + return getParts().stream() + .map(TreePart::blockPos) + .max(comparingInt(IBlockPos::getY)); + } + + @Override + public @NonNull Collection getNetherWarts(){ + return getParts().stream() + .filter(part -> part.treePartType() == TreePartType.NETHER_WART) + .collect(toSet()); + } + + @Override + public @NonNull Collection getMangroveRoots(){ + return getParts().stream() + .filter(part -> part.treePartType() == TreePartType.MANGROVE_ROOTS) + .collect(toSet()); + } + + @Override + public @NonNull Optional getStart(){ + return extremumBlocks.getLogStart(); + } + + @Override + public @NonNull Stream getPartsStream(){ + return getParts().stream(); + } +} diff --git a/common/src/main/java/fr/rakambda/fallingtree/common/tree/builder/TreeBuilder.java b/common/src/main/java/fr/rakambda/fallingtree/common/tree/builder/TreeBuilder.java index 40e53aa3..45160fdf 100644 --- a/common/src/main/java/fr/rakambda/fallingtree/common/tree/builder/TreeBuilder.java +++ b/common/src/main/java/fr/rakambda/fallingtree/common/tree/builder/TreeBuilder.java @@ -48,7 +48,7 @@ public Optional getTree(@NonNull IPlayer player, @NonNull ILevel level, @N var maxScanSize = mod.getConfiguration().getTrees().getMaxScanSize(); var toAnalyzePos = new PriorityQueue(); var analyzedPos = new HashSet(); - var tree = new Tree(level, originPos); + var tree = new MutableTree(level, originPos); var detectionMode = getDetectionMode(level, originPos); var firstPositionFetcher = getFirstPositionFetcher(detectionMode); toAnalyzePos.add(new ToAnalyzePos(firstPositionFetcher, originPos, originBlock, originPos, originBlock, originState, originEntity, TreePartType.LOG_START, 0, 0)); @@ -106,7 +106,7 @@ public Optional getTree(@NonNull IPlayer player, @NonNull ILevel level, @N return Optional.of(tree); } - private static void postProcess(@NonNull Tree tree){ + private static void postProcess(@NonNull MutableTree tree){ tree.getTopMostLog().ifPresent(topMostLog -> tree.removePartsHigherThan(topMostLog.getY() + 1, TreePartType.NETHER_WART)); } diff --git a/fabric/src/main/java/fr/rakambda/fallingtree/fabric/event/BlockBreakListener.java b/fabric/src/main/java/fr/rakambda/fallingtree/fabric/event/BlockBreakListener.java index 2439a120..3bc6987d 100644 --- a/fabric/src/main/java/fr/rakambda/fallingtree/fabric/event/BlockBreakListener.java +++ b/fabric/src/main/java/fr/rakambda/fallingtree/fabric/event/BlockBreakListener.java @@ -39,7 +39,7 @@ public boolean beforeBlockBreak(Level level, Player player, BlockPos blockPos, B return true; } - return !mod.getTreeHandler().shouldCancelEvent(wrappedLevel, wrappedPlayer, wrappedPos, wrappedState, wrappedEntity); + return !mod.getTreeHandler().create(wrappedLevel, wrappedPlayer, wrappedPos, wrappedState, wrappedEntity).shouldCancelEvent(); } @Override @@ -50,6 +50,6 @@ public void afterBlockBreak(Level level, Player player, BlockPos blockPos, Block var wrappedState = new BlockStateWrapper(blockState); var wrappedEntity = Optional.ofNullable(blockEntity).map(BlockEntityWrapper::new).orElse(null); - mod.getTreeHandler().breakTree(false, wrappedLevel, wrappedPlayer, wrappedPos, wrappedState, wrappedEntity); + mod.getTreeHandler().create(wrappedLevel, wrappedPlayer, wrappedPos, wrappedState, wrappedEntity).breakTree(false); } } diff --git a/forge/src/main/java/fr/rakambda/fallingtree/forge/event/BlockBreakListener.java b/forge/src/main/java/fr/rakambda/fallingtree/forge/event/BlockBreakListener.java index 92edcdaf..7adf7c69 100644 --- a/forge/src/main/java/fr/rakambda/fallingtree/forge/event/BlockBreakListener.java +++ b/forge/src/main/java/fr/rakambda/fallingtree/forge/event/BlockBreakListener.java @@ -29,7 +29,7 @@ public void onBreakSpeed(@Nonnull PlayerEvent.BreakSpeed event){ var wrappedPos = new BlockPosWrapper(optionalPos.get()); var wrappedState = new BlockStateWrapper(event.getState()); - var result = mod.getTreeHandler().getBreakSpeed(wrappedPlayer, wrappedPos, wrappedState, event.getNewSpeed()); + var result = mod.getTreeHandler().create(wrappedPlayer.getLevel(), wrappedPlayer, wrappedPos, wrappedState).getBreakSpeed(event.getNewSpeed()); if(result.isEmpty()){ return; } @@ -48,11 +48,13 @@ public boolean onBlockBreakEvent(@Nonnull BlockEvent.BreakEvent event){ var wrappedState = new BlockStateWrapper(event.getState()); var wrappedEntity = wrappedLevel.getBlockEntity(wrappedPos); - if(mod.getTreeHandler().shouldCancelEvent(wrappedLevel, wrappedPlayer, wrappedPos, wrappedState, wrappedEntity)){ + final var treeHandler = mod.getTreeHandler().create(wrappedLevel, wrappedPlayer, wrappedPos, wrappedState, wrappedEntity); + + if(treeHandler.shouldCancelEvent()){ return true; } - var result = mod.getTreeHandler().breakTree(true, wrappedLevel, wrappedPlayer, wrappedPos, wrappedState, wrappedEntity); + var result = treeHandler.breakTree(true); return result.shouldCancel(); } } diff --git a/neoforge/src/main/java/fr/rakambda/fallingtree/neoforge/event/BlockBreakListener.java b/neoforge/src/main/java/fr/rakambda/fallingtree/neoforge/event/BlockBreakListener.java index 30b00d10..c534799d 100644 --- a/neoforge/src/main/java/fr/rakambda/fallingtree/neoforge/event/BlockBreakListener.java +++ b/neoforge/src/main/java/fr/rakambda/fallingtree/neoforge/event/BlockBreakListener.java @@ -11,7 +11,6 @@ import net.minecraft.server.level.ServerLevel; import net.neoforged.bus.api.SubscribeEvent; import net.neoforged.neoforge.event.entity.player.PlayerEvent; -import net.neoforged.neoforge.event.level.BlockEvent; import net.neoforged.neoforge.event.level.block.BreakBlockEvent; import org.jspecify.annotations.NonNull; import javax.annotation.Nonnull; @@ -36,7 +35,7 @@ public void onBreakSpeed(@Nonnull PlayerEvent.BreakSpeed event){ var wrappedPos = new BlockPosWrapper(optionalPos.get()); var wrappedState = new BlockStateWrapper(event.getState()); - var result = mod.getTreeHandler().getBreakSpeed(wrappedPlayer, wrappedPos, wrappedState, event.getNewSpeed()); + var result = mod.getTreeHandler().create(wrappedPlayer.getLevel(), wrappedPlayer, wrappedPos, wrappedState).getBreakSpeed(event.getNewSpeed()); if(result.isEmpty()){ return; } @@ -59,12 +58,14 @@ public void onBlockBreakEvent(@Nonnull BreakBlockEvent event){ var wrappedState = new BlockStateWrapper(event.getState()); var wrappedEntity = wrappedLevel.getBlockEntity(wrappedPos); - if(mod.getTreeHandler().shouldCancelEvent(wrappedLevel, wrappedPlayer, wrappedPos, wrappedState, wrappedEntity)){ + final var treeHandler = mod.getTreeHandler().create(wrappedLevel, wrappedPlayer, wrappedPos, wrappedState, wrappedEntity); + + if(treeHandler.shouldCancelEvent()){ event.setCanceled(true); return; } - var result = mod.getTreeHandler().breakTree(true, wrappedLevel, wrappedPlayer, wrappedPos, wrappedState, wrappedEntity); + var result = treeHandler.breakTree(true); if(result.shouldCancel()){ event.setCanceled(true); }