Fishing RNG (#162)

* WIP

* Loot

* Got it sort of working kinda

* Add auto fish catching (doesn't work)

* Did some hackfixes, but most importantly, got it working and fixed some mistakes, still not working 100%

* Did some hackfixes, but most importantly, got it working and fixed some mistakes, still not working 100%

* Detect possible delays and fix several network bugs

* Apply magic correction by MC (PseudoGravity)

* WIP: more user friendly version

* Cleanup and fixes

* Use EM even when there's less data

Co-authored-by: mcrcortex <[email protected]>

Author: Earthcomputer

build.gradle

@@ -11,6 +11,7 @@ version = project.mod_version
 group = project.maven_group
 
 minecraft {
+	accessWidener 'src/main/resources/clientcommands.aw'
 }
 
 repositories {

fishing_bobber_random.txt

@@ -0,0 +1,14 @@
+Constructor:
+  UUID generation (4 calls)
+  3x nextGaussian
+
+Doesn't seem to be any calls when bobber is flying outside of water
+
+- DamageSourcePropertiesLootCondition
+- EntityPropertiesLootCondition
+- LocationCheckLootCondition
+- TimeCheckLootCondition
+- WeatherCheckLootCondition
+- ExplorationMapLootFunction
+- FurnaceSmeltLootFunction
+

gradle.properties

@@ -1,5 +1,5 @@
 # Done to increase the memory available to gradle.
-org.gradle.jvmargs=-Xmx1G
+org.gradle.jvmargs=-Xmx6G
 
 # Fabric Properties
 	# check these on https://modmuss50.me/fabric.html

src/main/java/net/earthcomputer/clientcommands/ClientCommands.java

@@ -48,6 +48,7 @@ public static void registerCommands(CommandDispatcher<ServerCommandSource> dispa
         GammaCommand.register(dispatcher);
         MoteCommand.register(dispatcher);
         ChorusCommand.register(dispatcher);
+        FishCommand.register(dispatcher);
 
         CrackRNGCommand.register(dispatcher);
 

src/main/java/net/earthcomputer/clientcommands/TempRules.java

@@ -1,6 +1,7 @@
 package net.earthcomputer.clientcommands;
 
 import net.earthcomputer.clientcommands.features.EnchantmentCracker;
+import net.earthcomputer.clientcommands.features.FishingCracker;
 import net.earthcomputer.clientcommands.features.PlayerRandCracker;
 import net.minecraft.util.math.MathHelper;
 
@@ -41,6 +42,20 @@ public static void setEnchantingPrediction(boolean enchantingPrediction) {
             EnchantmentCracker.resetCracker();
     }
 
+    @Rule(setter = "setFishingManipulation")
+    private static boolean fishingManipulation = false;
+    public static boolean getFishingManipulation() {
+        return fishingManipulation;
+    }
+    public static void setFishingManipulation(boolean fishingManipulation) {
+        TempRules.fishingManipulation = fishingManipulation;
+        if (fishingManipulation) {
+            ServerBrandManager.rngWarning();
+        } else {
+            FishingCracker.reset();
+        }
+    }
+
     @Rule
     public static boolean playerRNGMaintenance = true;
 

src/main/java/net/earthcomputer/clientcommands/command/CEnchantCommand.java

@@ -27,7 +27,7 @@ public static void register(CommandDispatcher<ServerCommandSource> dispatcher) {
         dispatcher.register(literal("cenchant")
                 .then(literal("--simulate")
                         .redirect(cenchant, ctx -> ctx.getSource().withLevel(((IServerCommandSource) ctx.getSource()).getLevel() | FLAG_SIMULATE)))
-                .then(argument("itemAndEnchantmentsPredicate", itemAndEnchantmentsPredicate())
+                .then(argument("itemAndEnchantmentsPredicate", itemAndEnchantmentsPredicate().withEnchantmentPredicate(ench -> !ench.isTreasure()))
                         .executes(ctx -> cenchant(ctx.getSource(), getItemAndEnchantmentsPredicate(ctx, "itemAndEnchantmentsPredicate")))));
     }
 
@@ -36,7 +36,7 @@ private static int cenchant(ServerCommandSource source, ItemAndEnchantmentsPredi
             Text text = new TranslatableText("commands.cenchant.needEnchantingPrediction")
                     .formatted(Formatting.RED)
                     .append(" ")
-                    .append(getCommandTextComponent("commands.cenchant.needEnchantingPrediction.enable", "/ctemprule set enchantingPrediction true"));
+                    .append(getCommandTextComponent("commands.client.enable", "/ctemprule set enchantingPrediction true"));
             sendFeedback(text);
             return 0;
         }

src/main/java/net/earthcomputer/clientcommands/command/ClientCommandManager.java

@@ -2,7 +2,9 @@
 
 import com.mojang.brigadier.StringReader;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import net.earthcomputer.clientcommands.mixin.InGameHudAccessor;
 import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.hud.InGameHud;
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.command.CommandException;
 import net.minecraft.text.*;
@@ -32,14 +34,20 @@ public static void sendError(Text error) {
         sendFeedback(new LiteralText("").append(error).formatted(Formatting.RED));
     }
 
-    public static void sendFeedback(String message) {
-        sendFeedback(new TranslatableText(message));
+    public static void sendFeedback(String message, Object... args) {
+        sendFeedback(new TranslatableText(message, args));
     }
 
     public static void sendFeedback(Text message) {
         MinecraftClient.getInstance().inGameHud.getChatHud().addMessage(message);
     }
 
+    public static void addOverlayMessage(Text message, int time) {
+        InGameHud inGameHud = MinecraftClient.getInstance().inGameHud;
+        inGameHud.setOverlayMessage(message, false);
+        ((InGameHudAccessor) inGameHud).setOverlayRemaining(time);
+    }
+
     public static int executeCommand(StringReader reader, String command) {
         ClientPlayerEntity player = MinecraftClient.getInstance().player;
         try {

src/main/java/net/earthcomputer/clientcommands/command/FishCommand.java

@@ -0,0 +1,128 @@
+package net.earthcomputer.clientcommands.command;
+
+import com.google.common.collect.ImmutableSet;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import net.earthcomputer.clientcommands.TempRules;
+import net.earthcomputer.clientcommands.command.arguments.ClientItemPredicateArgumentType;
+import net.earthcomputer.clientcommands.features.FishingCracker;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.text.TranslatableText;
+import net.minecraft.util.Formatting;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.Set;
+
+import static com.mojang.brigadier.arguments.IntegerArgumentType.*;
+import static net.earthcomputer.clientcommands.command.arguments.ClientItemPredicateArgumentType.*;
+import static net.earthcomputer.clientcommands.command.arguments.ItemAndEnchantmentsPredicateArgumentType.*;
+import static net.earthcomputer.clientcommands.command.arguments.WithStringArgumentType.*;
+import static net.earthcomputer.clientcommands.command.ClientCommandManager.*;
+import static net.minecraft.server.command.CommandManager.*;
+
+public class FishCommand {
+    private static final Set<Item> ENCHANTABLE_ITEMS = ImmutableSet.of(Items.BOOK, Items.FISHING_ROD, Items.BOW);
+
+    public static void register(CommandDispatcher<ServerCommandSource> dispatcher) {
+        addClientSideCommand("cfish");
+
+        dispatcher.register(literal("cfish")
+            .then(literal("list-goals")
+                .executes(ctx -> listGoals()))
+            .then(literal("add-goal")
+                .then(argument("goal", clientItemPredicate())
+                    .executes(ctx -> addGoal(getClientItemPredicate(ctx, "goal")))))
+            .then(literal("add-enchanted-goal")
+                .then(argument("goal", withString(itemAndEnchantmentsPredicate().withItemPredicate(ENCHANTABLE_ITEMS::contains)))
+                    .executes(ctx -> addEnchantedGoal(getWithString(ctx, "goal", ItemAndEnchantmentsPredicate.class)))))
+            .then(literal("remove-goal")
+                .then(argument("index", integer(1))
+                    .executes(ctx -> removeGoal(getInteger(ctx, "index"))))));
+    }
+
+    private static int listGoals() {
+        if (!checkFishingManipulationEnabled()) {
+            return 0;
+        }
+
+        if (FishingCracker.goals.isEmpty()) {
+            sendFeedback(new TranslatableText("commands.cfish.listGoals.noGoals").styled(style -> style.withColor(Formatting.RED)));
+        } else {
+            sendFeedback("commands.cfish.listGoals.success", FishingCracker.goals.size());
+            for (int i = 0; i < FishingCracker.goals.size(); i++) {
+                sendFeedback((i + 1) + ": " + FishingCracker.goals.get(i).getPrettyString());
+            }
+        }
+
+        return FishingCracker.goals.size();
+    }
+
+    private static int addGoal(ClientItemPredicateArgumentType.ClientItemPredicate goal) {
+        if (!checkFishingManipulationEnabled()) {
+            return 0;
+        }
+
+        FishingCracker.goals.add(goal);
+
+        sendFeedback("commands.cfish.addGoal.success", goal.getPrettyString());
+
+        return FishingCracker.goals.size();
+    }
+
+    private static int addEnchantedGoal(Pair<String, ItemAndEnchantmentsPredicate> stringAndItemAndEnchantments) {
+        if (!checkFishingManipulationEnabled()) {
+            return 0;
+        }
+
+        String string = stringAndItemAndEnchantments.getLeft();
+        ItemAndEnchantmentsPredicate itemAndEnchantments = stringAndItemAndEnchantments.getRight();
+
+        ClientItemPredicate goal = new ClientItemPredicate() {
+            @Override
+            public String getPrettyString() {
+                return string;
+            }
+
+            @Override
+            public boolean test(ItemStack itemStack) {
+                return itemAndEnchantments.test(itemStack);
+            }
+        };
+
+        FishingCracker.goals.add(goal);
+
+        sendFeedback("commands.cfish.addGoal.success", string);
+
+        return FishingCracker.goals.size();
+    }
+
+    private static int removeGoal(int index) throws CommandSyntaxException {
+        if (!checkFishingManipulationEnabled()) {
+            return 0;
+        }
+
+        if (index > FishingCracker.goals.size()) {
+            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.integerTooHigh().create(index, FishingCracker.goals.size());
+        }
+        ClientItemPredicate goal = FishingCracker.goals.remove(index - 1);
+
+        sendFeedback("commands.cfish.removeGoal.success", goal.getPrettyString());
+
+        return FishingCracker.goals.size();
+    }
+
+    private static boolean checkFishingManipulationEnabled() {
+        if (!TempRules.getFishingManipulation()) {
+            sendFeedback(new TranslatableText("commands.cfish.needFishingManipulation")
+                    .styled(style -> style.withColor(Formatting.RED))
+                    .append(" ")
+                    .append(getCommandTextComponent("commands.client.enable", "/ctemprule set fishingManipulation true")));
+            return false;
+        } else {
+            return true;
+        }
+    }
+}

src/main/java/net/earthcomputer/clientcommands/command/arguments/ClientItemPredicateArgumentType.java

@@ -1,6 +1,8 @@
 package net.earthcomputer.clientcommands.command.arguments;
 
 import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
 import net.minecraft.client.MinecraftClient;
@@ -10,9 +12,11 @@
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.NbtHelper;
+import net.minecraft.server.command.ServerCommandSource;
 import net.minecraft.tag.Tag;
 import net.minecraft.text.TranslatableText;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.registry.Registry;
 
 import java.util.function.Predicate;
 
@@ -34,16 +38,20 @@ public static ClientItemPredicateArgumentType clientItemPredicate() {
         return new ClientItemPredicateArgumentType();
     }
 
+    public static ClientItemPredicate getClientItemPredicate(CommandContext<ServerCommandSource> ctx, String name) throws CommandSyntaxException {
+        return ctx.getArgument(name, ClientItemPredicateArgument.class).create(ctx);
+    }
+
     @Override
-    public ItemPredicateArgument parse(StringReader reader) throws CommandSyntaxException {
+    public ClientItemPredicateArgument parse(StringReader reader) throws CommandSyntaxException {
         ItemStringReader itemReader = new ItemStringReader(reader, true).consume();
         if (itemReader.getItem() != null) {
             ItemPredicate predicate = new ItemPredicate(itemReader.getItem(), itemReader.getTag());
             return ctx -> predicate;
         } else {
             Identifier tagId = itemReader.getId();
             return ctx -> {
-                @SuppressWarnings("ConstantConditions") Tag<Item> tag = MinecraftClient.getInstance().getNetworkHandler().getTagManager().getItems().getTag(tagId);
+                @SuppressWarnings("ConstantConditions") Tag.Identified<Item> tag = (Tag.Identified<Item>) MinecraftClient.getInstance().getNetworkHandler().getTagManager().getItems().getTag(tagId);
                 if (tag == null) {
                     throw UNKNOWN_TAG_EXCEPTION.create(tagId.toString());
                 } else {
@@ -53,13 +61,22 @@ public ItemPredicateArgument parse(StringReader reader) throws CommandSyntaxExce
         }
     }
 
+    @FunctionalInterface
+    public interface ClientItemPredicateArgument extends ItemPredicateArgument {
+        @Override
+        ClientItemPredicate create(CommandContext<ServerCommandSource> commandContext) throws CommandSyntaxException;
+    }
+
+    public interface ClientItemPredicate extends Predicate<ItemStack> {
+        String getPrettyString();
+    }
 
 
-    static class TagPredicate implements Predicate<ItemStack> {
-        private final Tag<Item> tag;
+    static class TagPredicate implements ClientItemPredicate {
+        private final Tag.Identified<Item> tag;
         private final CompoundTag compound;
 
-        public TagPredicate(Tag<Item> tag, CompoundTag compound) {
+        public TagPredicate(Tag.Identified<Item> tag, CompoundTag compound) {
             this.tag = tag;
             this.compound = compound;
         }
@@ -68,9 +85,18 @@ public TagPredicate(Tag<Item> tag, CompoundTag compound) {
         public boolean test(ItemStack stack) {
             return this.tag.contains(stack.getItem()) && NbtHelper.matches(this.compound, stack.getTag(), true);
         }
+
+        @Override
+        public String getPrettyString() {
+            String ret = "#" + tag.getId();
+            if (compound != null) {
+                ret += compound;
+            }
+            return ret;
+        }
     }
 
-    static class ItemPredicate implements Predicate<ItemStack> {
+    static class ItemPredicate implements ClientItemPredicate {
         private final Item item;
         private final CompoundTag compound;
 
@@ -83,5 +109,14 @@ public ItemPredicate(Item item, CompoundTag compound) {
         public boolean test(ItemStack stack) {
             return stack.getItem() == this.item && NbtHelper.matches(this.compound, stack.getTag(), true);
         }
+
+        @Override
+        public String getPrettyString() {
+            String ret = String.valueOf(Registry.ITEM.getId(item));
+            if (compound != null) {
+                ret += compound;
+            }
+            return ret;
+        }
     }
 }