Attac

src/api/java/baritone/api/IBaritone.java

@@ -94,6 +94,12 @@ public interface IBaritone {
      */
     IElytraProcess getElytraProcess();
 
+    /**
+     * @return The {@link IAttackProcess} instance
+     * @see IAttackProcess
+     */
+    IAttackProcess getAttackProcess();
+
     /**
      * @return The {@link IWorldProvider} instance
      * @see IWorldProvider

src/api/java/baritone/api/Settings.java

@@ -115,6 +115,11 @@ public final class Settings {
      */
     public final Setting<Boolean> autoTool = new Setting<>(true);
 
+    /**
+     * Automatically select the best available weapon
+     */
+    public final Setting<Boolean> autoWeapon = new Setting<>(true);
+
     /**
      * It doesn't actually take twenty ticks to place a block, this cost is so high
      * because we want to generally conserve blocks which might be limited.
@@ -411,6 +416,26 @@ public final class Settings {
      */
     public final Setting<Integer> blockBreakSpeed = new Setting<>(6);
 
+    /**
+     * Determines if Baritone waits for the attack cooldown to recharge completely before attacking
+     */
+    public final Setting<Boolean> timedAttacks = new Setting<>(true);
+
+    /**
+     * Determines how many ticks between left clicks are allowed.
+     */
+    public final Setting<Integer> leftClickSpeed = new Setting<>(6);
+
+    /**
+     * Assume external aiming functionality
+     */
+    public final Setting<Boolean> assumeExternalAutoAim = new Setting<>(false);
+
+    /**
+     * Assume external attacking functionality
+     */
+    public final Setting<Boolean> assumeExternalKillAura = new Setting<>(false);
+
     /**
      * How many degrees to randomize the pitch and yaw every tick. Set to 0 to disable
      */
@@ -1232,6 +1257,22 @@ public final class Settings {
      */
     public final Setting<Double> followOffsetDistance = new Setting<>(0D);
 
+    /**
+     * The actual GoalNear is set to circle around your selected entity instead of remaining in one place.
+     * This disregards {@link #followOffsetDirection} when enabled.
+     */
+    public final Setting<Boolean> followCircle = new Setting<>(false);
+
+    /**
+     * The yaw amount the target is shifted by
+     */
+    public final Setting<Float> followCircleIncrement = new Setting<>(90F);
+
+    /**
+     * The chance every tick that the follow circle direction is switched from 0 to 100
+     */
+    public final Setting<Double> followCircleSwitchDirectionChance = new Setting<>(2.5D);
+
     /**
      * The actual GoalNear is set in this direction from the entity you're following. This value is in degrees.
      */
@@ -1247,6 +1288,11 @@ public final class Settings {
      */
     public final Setting<Integer> followTargetMaxDistance = new Setting<>(0);
 
+    /**
+     * The distance until you start locking on and attacking entities.
+     */
+    public final Setting<Double> entityAttackRadius = new Setting<>(0D);
+
     /**
      * Turn this on if your exploration filter is enormous, you don't want it to check if it's done,
      * and you are just fine with it just hanging on completion

src/api/java/baritone/api/process/IAttackProcess.java

@@ -0,0 +1,24 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.process;
+
+public interface IAttackProcess extends IBaritoneProcess {
+    boolean isRotating();
+
+    boolean isAttacking();
+}

src/api/java/baritone/api/utils/RayTraceUtils.java

@@ -50,7 +50,7 @@ public static HitResult rayTraceTowards(Entity entity, Rotation rotation, double
         if (wouldSneak) {
             start = inferSneakingEyePosition(entity);
         } else {
-            start = entity.getEyePosition(1.0F); // do whatever is correct
+            start = entity.getEyePosition();
         }
 
         Vec3 direction = RotationUtils.calcLookDirectionFromRotation(rotation);

src/main/java/baritone/Baritone.java

@@ -22,6 +22,7 @@
 import baritone.api.Settings;
 import baritone.api.behavior.IBehavior;
 import baritone.api.event.listener.IEventBus;
+import baritone.api.process.IAttackProcess;
 import baritone.api.process.IBaritoneProcess;
 import baritone.api.process.IElytraProcess;
 import baritone.api.utils.IPlayerContext;
@@ -80,6 +81,7 @@ public class Baritone implements IBaritone {
     private final FarmProcess farmProcess;
     private final InventoryPauserProcess inventoryPauserProcess;
     private final IElytraProcess elytraProcess;
+    private final AttackProcess attackProcess;
 
     private final PathingControlManager pathingControlManager;
     private final SelectionManager selectionManager;
@@ -123,6 +125,7 @@ public class Baritone implements IBaritone {
             this.farmProcess             = this.registerProcess(FarmProcess::new);
             this.inventoryPauserProcess  = this.registerProcess(InventoryPauserProcess::new);
             this.elytraProcess           = this.registerProcess(ElytraProcess::create);
+            this.attackProcess           = this.registerProcess(AttackProcess::new);
             this.registerProcess(BackfillProcess::new);
         }
 
@@ -240,6 +243,11 @@ public IElytraProcess getElytraProcess() {
         return this.elytraProcess;
     }
 
+    @Override
+    public IAttackProcess getAttackProcess() {
+        return this.attackProcess;
+    }
+
     @Override
     public void openClick() {
         new Thread(() -> {

src/main/java/baritone/behavior/PathingBehavior.java

@@ -33,7 +33,6 @@
 import baritone.pathing.movement.CalculationContext;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.path.PathExecutor;
-import baritone.process.ElytraProcess;
 import baritone.utils.PathRenderer;
 import baritone.utils.PathingCommandContext;
 import baritone.utils.pathing.Favoring;
@@ -120,7 +119,7 @@ private void tickPath() {
             pauseRequestedLastTick = false;
             if (unpausedLastTick) {
                 baritone.getInputOverrideHandler().clearAllKeys();
-                baritone.getInputOverrideHandler().getBlockBreakHelper().stopBreakingBlock();
+                baritone.getInputOverrideHandler().getLeftClickHelper().stopBreakingBlock();
             }
             unpausedLastTick = false;
             pausedThisTick = true;
@@ -363,7 +362,7 @@ public void secretInternalSegmentCancel() {
                 current = null;
                 next = null;
                 baritone.getInputOverrideHandler().clearAllKeys();
-                baritone.getInputOverrideHandler().getBlockBreakHelper().stopBreakingBlock();
+                baritone.getInputOverrideHandler().getLeftClickHelper().stopBreakingBlock();
             }
         }
     }

src/main/java/baritone/pathing/movement/MovementHelper.java

@@ -32,6 +32,7 @@
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.util.Mth;
+import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.item.enchantment.EnchantmentHelper;
 import net.minecraft.world.level.block.*;
 import net.minecraft.world.level.block.piston.MovingPistonBlock;
@@ -646,17 +647,31 @@ static void switchToBestToolFor(IPlayerContext ctx, BlockState b) {
      */
     static void switchToBestToolFor(IPlayerContext ctx, BlockState b, ToolSet ts, boolean preferSilkTouch) {
         if (Baritone.settings().autoTool.value && !Baritone.settings().assumeExternalAutoTool.value) {
-            ctx.player().getInventory().selected = ts.getBestSlot(b.getBlock(), preferSilkTouch);
+            ctx.player().getInventory().selected = ts.getBestToolSlot(b.getBlock(), preferSilkTouch);
         }
     }
 
-    static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
-        state.setTarget(new MovementTarget(
-                RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
-                        VecUtils.getBlockPosCenter(pos),
-                        ctx.playerRotations()).withPitch(ctx.playerRotations().getPitch()),
-                false
-        )).setInput(Input.MOVE_FORWARD, true);
+    static void switchToBestWeaponFor(IPlayerContext ctx, LivingEntity target) {
+        switchToBestWeaponFor(ctx, target, new ToolSet(ctx.player()));
+    }
+
+    static void switchToBestWeaponFor(IPlayerContext ctx, LivingEntity target, ToolSet ts) {
+        if (Baritone.settings().autoWeapon.value) {
+            ctx.player().getInventory().selected = ts.getBestWeaponSlot(target);
+        }
+    }
+
+    static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos dest, IBaritone baritone) {
+        if (!baritone.getAttackProcess().isRotating()) {
+            state.setTarget(new MovementTarget(
+                    RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
+                            VecUtils.getBlockPosCenter(dest),
+                            ctx.playerRotations()).withPitch(ctx.playerRotations().getPitch()),
+                    false
+            )).setInput(Input.MOVE_FORWARD, true);
+        } else {
+            moveTowardsWithoutRotation(ctx, state, dest);
+        }
     }
 
     static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state, float idealYaw) {

src/main/java/baritone/pathing/movement/movements/MovementAscend.java

@@ -189,7 +189,7 @@ public MovementState updateState(MovementState state) {
 
             return state;
         }
-        MovementHelper.moveTowards(ctx, state, dest);
+        MovementHelper.moveTowards(ctx, state, dest, baritone);
 
         state.setInput(Input.SNEAK, Baritone.settings().allowWalkOnMagmaBlocks.value && jumpingOnto.is(Blocks.MAGMA_BLOCK));
 

src/main/java/baritone/pathing/movement/movements/MovementDescend.java

@@ -261,9 +261,9 @@ public MovementState updateState(MovementState state) {
 
         if (!playerFeet.equals(dest) || ab > 0.25) {
             if (numTicks++ < 20 && fromStart < 1.25) {
-                MovementHelper.moveTowards(ctx, state, fakeDest);
+                MovementHelper.moveTowards(ctx, state, fakeDest, baritone);
             } else {
-                MovementHelper.moveTowards(ctx, state, dest);
+                MovementHelper.moveTowards(ctx, state, dest, baritone);
             }
         }
         return state;

src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java

@@ -278,7 +278,7 @@ public MovementState updateState(MovementState state) {
             state.setInput(Input.SPRINT, true);
         }
         state.setInput(Input.SNEAK, Baritone.settings().allowWalkOnMagmaBlocks.value && MovementHelper.steppingOnBlocks(ctx).stream().anyMatch(block -> ctx.world().getBlockState(block).is(Blocks.MAGMA_BLOCK)));
-        MovementHelper.moveTowards(ctx, state, dest);
+        MovementHelper.moveTowards(ctx, state, dest, baritone);
         return state;
     }
 

src/main/java/baritone/pathing/movement/movements/MovementDownward.java

@@ -90,7 +90,7 @@ public MovementState updateState(MovementState state) {
         if (numTicks++ < 10 && ab < 0.2) {
             return state;
         }
-        MovementHelper.moveTowards(ctx, state, positionsToBreak[0]);
+        MovementHelper.moveTowards(ctx, state, positionsToBreak[0], baritone);
         return state;
     }
 }

src/main/java/baritone/pathing/movement/movements/MovementParkour.java

@@ -266,7 +266,7 @@ public MovementState updateState(MovementState state) {
             state.setInput(Input.SNEAK, true);
         }
 
-        MovementHelper.moveTowards(ctx, state, dest);
+        MovementHelper.moveTowards(ctx, state, dest, baritone);
         if (ctx.playerFeet().equals(dest)) {
             Block d = BlockStateInterface.getBlock(ctx, dest);
             if (d == Blocks.VINE || d == Blocks.LADDER) {
@@ -302,9 +302,9 @@ public MovementState updateState(MovementState state) {
             } else if (!ctx.playerFeet().equals(dest.relative(direction, -1))) {
                 state.setInput(Input.SPRINT, false);
                 if (ctx.playerFeet().equals(src.relative(direction, -1))) {
-                    MovementHelper.moveTowards(ctx, state, src);
+                    MovementHelper.moveTowards(ctx, state, src, baritone);
                 } else {
-                    MovementHelper.moveTowards(ctx, state, src.relative(direction, -1));
+                    MovementHelper.moveTowards(ctx, state, src.relative(direction, -1), baritone);
                 }
             }
         }

src/main/java/baritone/pathing/movement/movements/MovementPillar.java

@@ -221,15 +221,14 @@ public MovementState updateState(MovementState state) {
             }
              */
 
-            MovementHelper.moveTowards(ctx, state, against);
+            MovementHelper.moveTowards(ctx, state, against, baritone);
             return state;
         } else {
             // Get ready to place a throwaway block
             if (!((Baritone) baritone).getInventoryBehavior().selectThrowawayForLocation(true, src.x, src.y, src.z)) {
                 return state.setStatus(MovementStatus.UNREACHABLE);
             }
 
-            state.setInput(Input.SNEAK, true);
             // since (lower down) we only right click once player.isSneaking, and that happens the tick after we request to sneak
 
             double diffX = ctx.player().position().x - (dest.getX() + 0.5);
@@ -245,9 +244,12 @@ public MovementState updateState(MovementState state) {
 
                 // revise our target to both yaw and pitch if we're going to be moving forward
                 state.setTarget(new MovementState.MovementTarget(rotation, true));
-            } else if (flatMotion < 0.05) {
-                // If our Y coordinate is above our goal, stop jumping
-                state.setInput(Input.JUMP, ctx.player().position().y < dest.getY());
+            } else {
+                state.setInput(Input.SNEAK, true);
+                if (flatMotion < 0.05) {
+                    // If our Y coordinate is above our goal, stop jumping
+                    state.setInput(Input.JUMP, ctx.player().position().y < dest.getY());
+                }
             }
 
 

src/main/java/baritone/pathing/movement/movements/MovementTraverse.java

@@ -286,15 +286,15 @@ public MovementState updateState(MovementState state) {
                     return state.setStatus(MovementStatus.UNREACHABLE);
                 }
             }
-            MovementHelper.moveTowards(ctx, state, against);
+            MovementHelper.moveTowards(ctx, state, against, baritone);
             return state;
         } else {
             wasTheBridgeBlockAlwaysThere = false;
             Block standingOn = BlockStateInterface.get(ctx, feet.below()).getBlock();
             if (standingOn.equals(Blocks.SOUL_SAND) || standingOn instanceof SlabBlock) { // see issue #118
                 double dist = Math.max(Math.abs(dest.getX() + 0.5 - ctx.player().position().x), Math.abs(dest.getZ() + 0.5 - ctx.player().position().z));
                 if (dist < 0.85) { // 0.5 + 0.3 + epsilon
-                    MovementHelper.moveTowards(ctx, state, dest);
+                    MovementHelper.moveTowards(ctx, state, dest, baritone);
                     return state.setInput(Input.MOVE_FORWARD, false)
                             .setInput(Input.MOVE_BACK, true);
                 }

src/main/java/baritone/pathing/path/PathExecutor.java

@@ -589,7 +589,7 @@ private void clearKeys() {
 
     private void cancel() {
         clearKeys();
-        behavior.baritone.getInputOverrideHandler().getBlockBreakHelper().stopBreakingBlock();
+        behavior.baritone.getInputOverrideHandler().getLeftClickHelper().stopBreakingBlock();
         pathPosition = path.length() + 3;
         failed = true;
     }