From 288ae6f6be8b3291710ccb6440ca60c0f09d0a82 Mon Sep 17 00:00:00 2001 From: obvWolf Date: Mon, 6 Nov 2023 01:28:34 -0600 Subject: [PATCH 1/8] Starting to make a complexer toggler and picker --- .idea/misc.xml | 1 - build.gradle | 3 ++- .../java/me/trouper/Functions/Complexers.java | 12 +++++++++++- src/main/java/me/trouper/Functions/Eval.java | 8 ++++++++ src/main/java/me/trouper/Functions/Obf.java | 4 ++++ src/main/java/me/trouper/Main.java | 12 +++++++++++- src/main/java/me/trouper/Utils/Utils.java | 19 +++++++++++-------- 7 files changed, 47 insertions(+), 12 deletions(-) diff --git a/.idea/misc.xml b/.idea/misc.xml index 04bf2a8..7323540 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,4 +1,3 @@ - diff --git a/build.gradle b/build.gradle index 33dd302..98b7a2f 100644 --- a/build.gradle +++ b/build.gradle @@ -3,7 +3,7 @@ plugins { } group 'me.trouper' -version '0.0.3' +version '0.0.4' repositories { mavenCentral() @@ -11,6 +11,7 @@ repositories { dependencies { implementation 'net.objecthunter:exp4j:0.4.8' + implementation 'com.ezylang:EvalEx:3.0.5' testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1' } diff --git a/src/main/java/me/trouper/Functions/Complexers.java b/src/main/java/me/trouper/Functions/Complexers.java index 3489b17..78c869d 100644 --- a/src/main/java/me/trouper/Functions/Complexers.java +++ b/src/main/java/me/trouper/Functions/Complexers.java @@ -9,6 +9,12 @@ import static me.trouper.Functions.Eval.eval; import static me.trouper.Functions.Eval.isPerfectSquare; public class Complexers { + /* Complexer Toggles */ + public static boolean divide; + public static boolean power; + public static boolean root; + public static boolean mrDividend; + public static boolean mrDivisor; /** * Safe to use with D mode @@ -86,7 +92,10 @@ public class Complexers { int dividend = random.nextInt(9)+i+10; int divisor = Utils.moduRootDivisor(dividend,i); String result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; - Utils.verbose("<&dh><&b>mRootDivisor has been ran!<&r>" + + if (deep) { + result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; + } + Utils.verbose("<&dh><&b>mRootDivisor has ran!<&r>" + "\nWanted: " + i + "\nDivisor: " + divisor + "\nDividend: " + dividend + @@ -115,5 +124,6 @@ public class Complexers { "\nResult: " + result); if (eval(result) != i) Utils.verbose("<&ch>Failed to mRootDividend<&r> " + i + ", Attempted: " + result + "=" + eval(result)); return (eval(result) == i) ? result : "(" + i + ")"; + } } diff --git a/src/main/java/me/trouper/Functions/Eval.java b/src/main/java/me/trouper/Functions/Eval.java index 7d55f66..400c17b 100644 --- a/src/main/java/me/trouper/Functions/Eval.java +++ b/src/main/java/me/trouper/Functions/Eval.java @@ -1,5 +1,8 @@ package me.trouper.Functions; +import com.ezylang.evalex.EvaluationException; +import com.ezylang.evalex.data.EvaluationValue; +import com.ezylang.evalex.parser.ParseException; import me.trouper.Utils.Utils; import net.objecthunter.exp4j.Expression; import net.objecthunter.exp4j.ExpressionBuilder; @@ -21,4 +24,9 @@ public class Eval { public static boolean isInt(double number) { return (number == Math.floor(number)) && !Double.isInfinite(number); } + public static double evalM(String exp) throws EvaluationException, ParseException { + com.ezylang.evalex.Expression expression = new com.ezylang.evalex.Expression(exp); + EvaluationValue result = expression.evaluate(); + return result.getNumberValue().doubleValue(); + } } diff --git a/src/main/java/me/trouper/Functions/Obf.java b/src/main/java/me/trouper/Functions/Obf.java index ff24ef4..fc1d39f 100644 --- a/src/main/java/me/trouper/Functions/Obf.java +++ b/src/main/java/me/trouper/Functions/Obf.java @@ -171,4 +171,8 @@ public class Obf { return (eval(toAdd) == target) ? toAdd : "(" + target + ")"; } + + public static String pickComplexer() { + return "e"; + } } diff --git a/src/main/java/me/trouper/Main.java b/src/main/java/me/trouper/Main.java index efa2928..9da85ff 100644 --- a/src/main/java/me/trouper/Main.java +++ b/src/main/java/me/trouper/Main.java @@ -1,5 +1,6 @@ package me.trouper; +import me.trouper.Functions.Complexers; import me.trouper.Functions.Obf; import me.trouper.Utils.Timer; import me.trouper.Utils.Utils; @@ -7,6 +8,7 @@ import me.trouper.Utils.Utils; import java.util.Scanner; import static me.trouper.Functions.Eval.eval; +import static me.trouper.Functions.Eval.evalM; import static me.trouper.Utils.Utils.removeColors; public class Main { @@ -14,6 +16,7 @@ public class Main { public static boolean deep; public static boolean color; public static boolean printHelp; + /* Statistics */ public static int expCount = 0; public static int factorCount = 0; @@ -44,6 +47,11 @@ public class Main { boolean doCopy = false; String mode = "N"; + Complexers.divide = true; + Complexers.power = true; + Complexers.root = true; + Complexers.mrDividend = true; + Complexers.mrDivisor = true; for (String arg : args) { switch (arg) { @@ -58,6 +66,8 @@ public class Main { } } + + if (mode.equals("TEST")) { while (true) { System.out.print("Enter an expression (or 'exit' to exit): "); @@ -68,7 +78,7 @@ public class Main { } try { - double result = eval(userInput); + double result = evalM(userInput); System.out.println("Result: " + result); } catch (Exception e) { System.out.println("Error: " + e.getMessage()); diff --git a/src/main/java/me/trouper/Utils/Utils.java b/src/main/java/me/trouper/Utils/Utils.java index b0dc8f3..2da742a 100644 --- a/src/main/java/me/trouper/Utils/Utils.java +++ b/src/main/java/me/trouper/Utils/Utils.java @@ -39,14 +39,17 @@ public class Utils { } public static void printHelp() { - System.out.println("Usage: java -jar Countroll-.jar [options]"); - System.out.println("Options:"); - System.out.println(" --copy, -c Copy the generated expression to the clipboard"); - System.out.println(" --verbose, -v Enable verbose mode"); - System.out.println(" --deep, -d Enable deep obfuscation (under development)"); - System.out.println(" --color, -rgb Enable colored output"); - System.out.println(" --help, --h, -h Show this help message"); - System.out.println("Note: When using multiple options, separate them with spaces."); + System.out.println(""" + Usage: java -jar Countroll-.jar [options] + Options: values are formated as such: -m=d or -t=root + --copy, -c Copy the generated expression to the clipboard + --verbose, -v Enable verbose mode + --deep, -d Enable deep obfuscation (under development) + --color, -rgb Enable colored output + --help, --h, -h Show this help message + --mode, -m Toggle the mode Values (Long): [duckgroup, numselli] Values (Brief): [d, n] + --toggle, -t Toggle off Complexer Values: [divide, power, root, mrDividend, mrDivisor] + Note: When using multiple options, separate them with spaces."""); System.exit(0); } public static void printColorKey() { From 33d823f7540909e3ed814d7dd67f9efd1b1c9390 Mon Sep 17 00:00:00 2001 From: TheTrouper <93684527+thetrouper@users.noreply.github.com> Date: Mon, 6 Nov 2023 16:12:54 -0600 Subject: [PATCH 2/8] Finished up complexer picker, it has some bugs, so im making a better verbose system --- .../java/me/trouper/Functions/Complexers.java | 66 +++++++++++++++---- src/main/java/me/trouper/Functions/Obf.java | 35 +--------- src/main/java/me/trouper/Main.java | 12 ++-- src/main/java/me/trouper/Utils/Verbose.java | 7 ++ 4 files changed, 68 insertions(+), 52 deletions(-) create mode 100644 src/main/java/me/trouper/Utils/Verbose.java diff --git a/src/main/java/me/trouper/Functions/Complexers.java b/src/main/java/me/trouper/Functions/Complexers.java index 78c869d..c63c12e 100644 --- a/src/main/java/me/trouper/Functions/Complexers.java +++ b/src/main/java/me/trouper/Functions/Complexers.java @@ -3,19 +3,59 @@ package me.trouper.Functions; import me.trouper.Main; import me.trouper.Utils.Utils; -import java.util.Random; +import java.util.*; import static me.trouper.Functions.Eval.eval; import static me.trouper.Functions.Eval.isPerfectSquare; public class Complexers { /* Complexer Toggles */ - public static boolean divide; - public static boolean power; - public static boolean root; - public static boolean mrDividend; - public static boolean mrDivisor; + public static boolean useDivide; + public static boolean usePower; + public static boolean useRoot; + public static boolean useRDividend; + public static boolean useRDivisor; + public static String pickComplexer() { + List enabledComplexers = new ArrayList<>(); + + if (useDivide) enabledComplexers.add("divide"); + if (usePower) enabledComplexers.add("power"); + if (useRoot) enabledComplexers.add("root"); + if (useRDividend) enabledComplexers.add("mrDividend"); + if (useRDivisor) enabledComplexers.add("mrDivisor"); + + Collections.shuffle(enabledComplexers); + if (!enabledComplexers.isEmpty()) { + return enabledComplexers.get(0); + } else { + return "NONE"; + } + } + public static String complex(int i, boolean deep) { + String complexer = pickComplexer(); + if (isPerfectSquare(i)) complexer = "power"; + switch (complexer) { + case "divide" -> { + return divide(i,deep); + } + case "power" -> { + return power(i,deep); + } + case "root" -> { + return root(i,deep); + } + case "mrDividend" -> { + return mRootDividend(i,deep); + } + case "mrDivisor" -> { + return mRootDivisor(i,deep); + } + default -> { + return divide(i,false); + } + } + } /** * Safe to use with D mode * @param i Integer to divide @@ -30,13 +70,10 @@ public class Complexers { boolean expFac = false; boolean expDoub = false; - if (isPerfectSquare(factor)) expFac = true; - if (isPerfectSquare(doubled)) expDoub = true; - String result = "<&f>(<&r><&e>" + doubled + "<&b>/<&r><&e>" + factor + "<&f>)<&r>"; if (deep) { - result = "<&3>(<&r><&d>" + ((expDoub) ? power(doubled,false) : divide(doubled,false)) + "<&b>/<&r><&d>" + ((expFac) ? power(factor,false) : divide(factor,false)) + "<&3>)<&r>"; + result = "<&3>(<&r><&d>" + (complex(doubled,false)) + "<&b>/<&r><&d>" + (complex(factor,false)) + "<&3>)<&r>"; } if (eval(result) != i) Utils.verbose("Failed to divide " + i + ", Attempted: " + result + "=" + eval(result)); return eval(result) == i ? result : "(" + i + ")"; @@ -58,7 +95,7 @@ public class Complexers { String result = "<&r><&f>(<&e>" + root + "<&b>^<&e>2<&f>)<&r>"; if (deep) { - result = "<&r><&3>(<&d>" + divide(root,false) + "<&b>^<&d>2<&3>)<&r>"; + result = "<&r><&3>(<&d>" + complex(root,false) + "<&b>^<&d>2<&3>)<&r>"; } if (eval(result) != i) Utils.verbose("<&ch>Failed to power <&r>" + i + ", Attempted: " + result + "=" + eval(result)); return eval(result) == i ? result : "(" + i + ")"; @@ -75,7 +112,7 @@ public class Complexers { String result = "<&9>sqrt<&r><&f>(<&r><&e>" + squared + "<&f>)<&r>"; if (deep) { - result = "<&1>sqrt<&r><&3>(<&r><&d>" + divide(squared,false) + "<&3>)<&r>"; + result = "<&1>sqrt<&r><&3>(<&r><&d>" + complex(squared, false) + "<&3>)<&r>"; } if (eval(result) != i) Utils.verbose("<&ch>Failed to root <&r>" + i + ", Attempted: " + result + "=" + eval(result)); return (eval(result) == i) ? result : "(" + i + ")"; @@ -93,7 +130,7 @@ public class Complexers { int divisor = Utils.moduRootDivisor(dividend,i); String result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; if (deep) { - result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; + result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor, false) + "<&7>)<&r>"; } Utils.verbose("<&dh><&b>mRootDivisor has ran!<&r>" + "\nWanted: " + i + @@ -116,6 +153,9 @@ public class Complexers { int divisor = random.nextInt(9)+i+10; int dividend = Utils.moduRootDividend(divisor,i); String result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; + if (deep) { + result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor,false) + "<&7>)<&r>"; + } Utils.verbose("<&dh><&b>mRootDividend has been ran!<&r>" + "\nWanted:" + i + "\nDivisor: " + divisor + diff --git a/src/main/java/me/trouper/Functions/Obf.java b/src/main/java/me/trouper/Functions/Obf.java index fc1d39f..f62d060 100644 --- a/src/main/java/me/trouper/Functions/Obf.java +++ b/src/main/java/me/trouper/Functions/Obf.java @@ -53,7 +53,7 @@ public class Obf { eval = (int) eval(expression.toString()); } - final String toAdd = complex(ri,deep,"n"); + final String toAdd = Complexers.complex(ri,deep); if (eval < target) { if (target - eval > 4069) { @@ -110,7 +110,7 @@ public class Obf { int ri = random.nextInt(9)+1; - final String toAdd = complex(ri,deep,"d"); + final String toAdd = Complexers.complex(ri,deep); if (eval < target) { if (target - eval > 4096) { @@ -144,35 +144,4 @@ public class Obf { } return expression.toString(); } - public static String increase(int target, int current, boolean deep, String mode) { - return target + "" + current; - } - public static String complex(int target, boolean deep, String mode) { - Random random = new Random(); - String toAdd = "(" + target + ")"; - int rComplexer; - switch (mode) { - case "n" -> rComplexer = random.nextInt(4)+1; - case "d" -> rComplexer = random.nextInt(3)+1; - default -> rComplexer = 1; - } - if (target == 1) { - toAdd = Complexers.power(target,deep); - } else if (isPerfectSquare(target)) { - toAdd = Complexers.power(target,deep); - } else { - switch (rComplexer) { - case 1 -> toAdd = Complexers.divide(target,deep); - case 2 -> toAdd = Complexers.mRootDivisor(target,deep); - case 3 -> toAdd = Complexers.mRootDividend(target,deep); - case 4 -> toAdd = Complexers.root(target,deep); // Won't reach this one, if its "d" due to it stopping at 3 - } - } - - return (eval(toAdd) == target) ? toAdd : "(" + target + ")"; - } - - public static String pickComplexer() { - return "e"; - } } diff --git a/src/main/java/me/trouper/Main.java b/src/main/java/me/trouper/Main.java index 9da85ff..76f700d 100644 --- a/src/main/java/me/trouper/Main.java +++ b/src/main/java/me/trouper/Main.java @@ -47,12 +47,6 @@ public class Main { boolean doCopy = false; String mode = "N"; - Complexers.divide = true; - Complexers.power = true; - Complexers.root = true; - Complexers.mrDividend = true; - Complexers.mrDivisor = true; - for (String arg : args) { switch (arg) { case "--copy", "-c" -> doCopy = true; @@ -67,6 +61,12 @@ public class Main { } + Complexers.useRoot = !mode.equals("D"); + Complexers.usePower = true; + Complexers.useDivide = true; + Complexers.useRDivisor = true; + Complexers.useRDividend = true; + if (mode.equals("TEST")) { while (true) { diff --git a/src/main/java/me/trouper/Utils/Verbose.java b/src/main/java/me/trouper/Utils/Verbose.java new file mode 100644 index 0000000..1e7646d --- /dev/null +++ b/src/main/java/me/trouper/Utils/Verbose.java @@ -0,0 +1,7 @@ +package me.trouper.Utils; + +public class Verbose { + public static void send(String message, String klass, String type) { + + } +} From b909e44e3049e02c546a337f68875d1d7ff35763 Mon Sep 17 00:00:00 2001 From: obvWolf Date: Mon, 6 Nov 2023 01:28:34 -0600 Subject: [PATCH 3/8] Starting to make a complexer toggler and picker --- .idea/misc.xml | 1 - build.gradle | 3 ++- .../java/me/trouper/Functions/Complexers.java | 12 +++++++++++- src/main/java/me/trouper/Functions/Eval.java | 8 ++++++++ src/main/java/me/trouper/Functions/Obf.java | 4 ++++ src/main/java/me/trouper/Main.java | 12 +++++++++++- src/main/java/me/trouper/Utils/Utils.java | 19 +++++++++++-------- 7 files changed, 47 insertions(+), 12 deletions(-) diff --git a/.idea/misc.xml b/.idea/misc.xml index 04bf2a8..7323540 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,4 +1,3 @@ - diff --git a/build.gradle b/build.gradle index 33dd302..98b7a2f 100644 --- a/build.gradle +++ b/build.gradle @@ -3,7 +3,7 @@ plugins { } group 'me.trouper' -version '0.0.3' +version '0.0.4' repositories { mavenCentral() @@ -11,6 +11,7 @@ repositories { dependencies { implementation 'net.objecthunter:exp4j:0.4.8' + implementation 'com.ezylang:EvalEx:3.0.5' testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1' } diff --git a/src/main/java/me/trouper/Functions/Complexers.java b/src/main/java/me/trouper/Functions/Complexers.java index 3489b17..78c869d 100644 --- a/src/main/java/me/trouper/Functions/Complexers.java +++ b/src/main/java/me/trouper/Functions/Complexers.java @@ -9,6 +9,12 @@ import static me.trouper.Functions.Eval.eval; import static me.trouper.Functions.Eval.isPerfectSquare; public class Complexers { + /* Complexer Toggles */ + public static boolean divide; + public static boolean power; + public static boolean root; + public static boolean mrDividend; + public static boolean mrDivisor; /** * Safe to use with D mode @@ -86,7 +92,10 @@ public class Complexers { int dividend = random.nextInt(9)+i+10; int divisor = Utils.moduRootDivisor(dividend,i); String result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; - Utils.verbose("<&dh><&b>mRootDivisor has been ran!<&r>" + + if (deep) { + result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; + } + Utils.verbose("<&dh><&b>mRootDivisor has ran!<&r>" + "\nWanted: " + i + "\nDivisor: " + divisor + "\nDividend: " + dividend + @@ -115,5 +124,6 @@ public class Complexers { "\nResult: " + result); if (eval(result) != i) Utils.verbose("<&ch>Failed to mRootDividend<&r> " + i + ", Attempted: " + result + "=" + eval(result)); return (eval(result) == i) ? result : "(" + i + ")"; + } } diff --git a/src/main/java/me/trouper/Functions/Eval.java b/src/main/java/me/trouper/Functions/Eval.java index 7d55f66..400c17b 100644 --- a/src/main/java/me/trouper/Functions/Eval.java +++ b/src/main/java/me/trouper/Functions/Eval.java @@ -1,5 +1,8 @@ package me.trouper.Functions; +import com.ezylang.evalex.EvaluationException; +import com.ezylang.evalex.data.EvaluationValue; +import com.ezylang.evalex.parser.ParseException; import me.trouper.Utils.Utils; import net.objecthunter.exp4j.Expression; import net.objecthunter.exp4j.ExpressionBuilder; @@ -21,4 +24,9 @@ public class Eval { public static boolean isInt(double number) { return (number == Math.floor(number)) && !Double.isInfinite(number); } + public static double evalM(String exp) throws EvaluationException, ParseException { + com.ezylang.evalex.Expression expression = new com.ezylang.evalex.Expression(exp); + EvaluationValue result = expression.evaluate(); + return result.getNumberValue().doubleValue(); + } } diff --git a/src/main/java/me/trouper/Functions/Obf.java b/src/main/java/me/trouper/Functions/Obf.java index ff24ef4..fc1d39f 100644 --- a/src/main/java/me/trouper/Functions/Obf.java +++ b/src/main/java/me/trouper/Functions/Obf.java @@ -171,4 +171,8 @@ public class Obf { return (eval(toAdd) == target) ? toAdd : "(" + target + ")"; } + + public static String pickComplexer() { + return "e"; + } } diff --git a/src/main/java/me/trouper/Main.java b/src/main/java/me/trouper/Main.java index efa2928..9da85ff 100644 --- a/src/main/java/me/trouper/Main.java +++ b/src/main/java/me/trouper/Main.java @@ -1,5 +1,6 @@ package me.trouper; +import me.trouper.Functions.Complexers; import me.trouper.Functions.Obf; import me.trouper.Utils.Timer; import me.trouper.Utils.Utils; @@ -7,6 +8,7 @@ import me.trouper.Utils.Utils; import java.util.Scanner; import static me.trouper.Functions.Eval.eval; +import static me.trouper.Functions.Eval.evalM; import static me.trouper.Utils.Utils.removeColors; public class Main { @@ -14,6 +16,7 @@ public class Main { public static boolean deep; public static boolean color; public static boolean printHelp; + /* Statistics */ public static int expCount = 0; public static int factorCount = 0; @@ -44,6 +47,11 @@ public class Main { boolean doCopy = false; String mode = "N"; + Complexers.divide = true; + Complexers.power = true; + Complexers.root = true; + Complexers.mrDividend = true; + Complexers.mrDivisor = true; for (String arg : args) { switch (arg) { @@ -58,6 +66,8 @@ public class Main { } } + + if (mode.equals("TEST")) { while (true) { System.out.print("Enter an expression (or 'exit' to exit): "); @@ -68,7 +78,7 @@ public class Main { } try { - double result = eval(userInput); + double result = evalM(userInput); System.out.println("Result: " + result); } catch (Exception e) { System.out.println("Error: " + e.getMessage()); diff --git a/src/main/java/me/trouper/Utils/Utils.java b/src/main/java/me/trouper/Utils/Utils.java index b0dc8f3..2da742a 100644 --- a/src/main/java/me/trouper/Utils/Utils.java +++ b/src/main/java/me/trouper/Utils/Utils.java @@ -39,14 +39,17 @@ public class Utils { } public static void printHelp() { - System.out.println("Usage: java -jar Countroll-.jar [options]"); - System.out.println("Options:"); - System.out.println(" --copy, -c Copy the generated expression to the clipboard"); - System.out.println(" --verbose, -v Enable verbose mode"); - System.out.println(" --deep, -d Enable deep obfuscation (under development)"); - System.out.println(" --color, -rgb Enable colored output"); - System.out.println(" --help, --h, -h Show this help message"); - System.out.println("Note: When using multiple options, separate them with spaces."); + System.out.println(""" + Usage: java -jar Countroll-.jar [options] + Options: values are formated as such: -m=d or -t=root + --copy, -c Copy the generated expression to the clipboard + --verbose, -v Enable verbose mode + --deep, -d Enable deep obfuscation (under development) + --color, -rgb Enable colored output + --help, --h, -h Show this help message + --mode, -m Toggle the mode Values (Long): [duckgroup, numselli] Values (Brief): [d, n] + --toggle, -t Toggle off Complexer Values: [divide, power, root, mrDividend, mrDivisor] + Note: When using multiple options, separate them with spaces."""); System.exit(0); } public static void printColorKey() { From 21e842a31ebce007725cd1a6d117ea2fbf662461 Mon Sep 17 00:00:00 2001 From: TheTrouper <93684527+thetrouper@users.noreply.github.com> Date: Mon, 6 Nov 2023 16:12:54 -0600 Subject: [PATCH 4/8] Finished up complexer picker, it has some bugs, so im making a better verbose system --- .../java/me/trouper/Functions/Complexers.java | 66 +++++++++++++++---- src/main/java/me/trouper/Functions/Obf.java | 35 +--------- src/main/java/me/trouper/Main.java | 12 ++-- src/main/java/me/trouper/Utils/Verbose.java | 7 ++ 4 files changed, 68 insertions(+), 52 deletions(-) create mode 100644 src/main/java/me/trouper/Utils/Verbose.java diff --git a/src/main/java/me/trouper/Functions/Complexers.java b/src/main/java/me/trouper/Functions/Complexers.java index 78c869d..c63c12e 100644 --- a/src/main/java/me/trouper/Functions/Complexers.java +++ b/src/main/java/me/trouper/Functions/Complexers.java @@ -3,19 +3,59 @@ package me.trouper.Functions; import me.trouper.Main; import me.trouper.Utils.Utils; -import java.util.Random; +import java.util.*; import static me.trouper.Functions.Eval.eval; import static me.trouper.Functions.Eval.isPerfectSquare; public class Complexers { /* Complexer Toggles */ - public static boolean divide; - public static boolean power; - public static boolean root; - public static boolean mrDividend; - public static boolean mrDivisor; + public static boolean useDivide; + public static boolean usePower; + public static boolean useRoot; + public static boolean useRDividend; + public static boolean useRDivisor; + public static String pickComplexer() { + List enabledComplexers = new ArrayList<>(); + + if (useDivide) enabledComplexers.add("divide"); + if (usePower) enabledComplexers.add("power"); + if (useRoot) enabledComplexers.add("root"); + if (useRDividend) enabledComplexers.add("mrDividend"); + if (useRDivisor) enabledComplexers.add("mrDivisor"); + + Collections.shuffle(enabledComplexers); + if (!enabledComplexers.isEmpty()) { + return enabledComplexers.get(0); + } else { + return "NONE"; + } + } + public static String complex(int i, boolean deep) { + String complexer = pickComplexer(); + if (isPerfectSquare(i)) complexer = "power"; + switch (complexer) { + case "divide" -> { + return divide(i,deep); + } + case "power" -> { + return power(i,deep); + } + case "root" -> { + return root(i,deep); + } + case "mrDividend" -> { + return mRootDividend(i,deep); + } + case "mrDivisor" -> { + return mRootDivisor(i,deep); + } + default -> { + return divide(i,false); + } + } + } /** * Safe to use with D mode * @param i Integer to divide @@ -30,13 +70,10 @@ public class Complexers { boolean expFac = false; boolean expDoub = false; - if (isPerfectSquare(factor)) expFac = true; - if (isPerfectSquare(doubled)) expDoub = true; - String result = "<&f>(<&r><&e>" + doubled + "<&b>/<&r><&e>" + factor + "<&f>)<&r>"; if (deep) { - result = "<&3>(<&r><&d>" + ((expDoub) ? power(doubled,false) : divide(doubled,false)) + "<&b>/<&r><&d>" + ((expFac) ? power(factor,false) : divide(factor,false)) + "<&3>)<&r>"; + result = "<&3>(<&r><&d>" + (complex(doubled,false)) + "<&b>/<&r><&d>" + (complex(factor,false)) + "<&3>)<&r>"; } if (eval(result) != i) Utils.verbose("Failed to divide " + i + ", Attempted: " + result + "=" + eval(result)); return eval(result) == i ? result : "(" + i + ")"; @@ -58,7 +95,7 @@ public class Complexers { String result = "<&r><&f>(<&e>" + root + "<&b>^<&e>2<&f>)<&r>"; if (deep) { - result = "<&r><&3>(<&d>" + divide(root,false) + "<&b>^<&d>2<&3>)<&r>"; + result = "<&r><&3>(<&d>" + complex(root,false) + "<&b>^<&d>2<&3>)<&r>"; } if (eval(result) != i) Utils.verbose("<&ch>Failed to power <&r>" + i + ", Attempted: " + result + "=" + eval(result)); return eval(result) == i ? result : "(" + i + ")"; @@ -75,7 +112,7 @@ public class Complexers { String result = "<&9>sqrt<&r><&f>(<&r><&e>" + squared + "<&f>)<&r>"; if (deep) { - result = "<&1>sqrt<&r><&3>(<&r><&d>" + divide(squared,false) + "<&3>)<&r>"; + result = "<&1>sqrt<&r><&3>(<&r><&d>" + complex(squared, false) + "<&3>)<&r>"; } if (eval(result) != i) Utils.verbose("<&ch>Failed to root <&r>" + i + ", Attempted: " + result + "=" + eval(result)); return (eval(result) == i) ? result : "(" + i + ")"; @@ -93,7 +130,7 @@ public class Complexers { int divisor = Utils.moduRootDivisor(dividend,i); String result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; if (deep) { - result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; + result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor, false) + "<&7>)<&r>"; } Utils.verbose("<&dh><&b>mRootDivisor has ran!<&r>" + "\nWanted: " + i + @@ -116,6 +153,9 @@ public class Complexers { int divisor = random.nextInt(9)+i+10; int dividend = Utils.moduRootDividend(divisor,i); String result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; + if (deep) { + result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor,false) + "<&7>)<&r>"; + } Utils.verbose("<&dh><&b>mRootDividend has been ran!<&r>" + "\nWanted:" + i + "\nDivisor: " + divisor + diff --git a/src/main/java/me/trouper/Functions/Obf.java b/src/main/java/me/trouper/Functions/Obf.java index fc1d39f..f62d060 100644 --- a/src/main/java/me/trouper/Functions/Obf.java +++ b/src/main/java/me/trouper/Functions/Obf.java @@ -53,7 +53,7 @@ public class Obf { eval = (int) eval(expression.toString()); } - final String toAdd = complex(ri,deep,"n"); + final String toAdd = Complexers.complex(ri,deep); if (eval < target) { if (target - eval > 4069) { @@ -110,7 +110,7 @@ public class Obf { int ri = random.nextInt(9)+1; - final String toAdd = complex(ri,deep,"d"); + final String toAdd = Complexers.complex(ri,deep); if (eval < target) { if (target - eval > 4096) { @@ -144,35 +144,4 @@ public class Obf { } return expression.toString(); } - public static String increase(int target, int current, boolean deep, String mode) { - return target + "" + current; - } - public static String complex(int target, boolean deep, String mode) { - Random random = new Random(); - String toAdd = "(" + target + ")"; - int rComplexer; - switch (mode) { - case "n" -> rComplexer = random.nextInt(4)+1; - case "d" -> rComplexer = random.nextInt(3)+1; - default -> rComplexer = 1; - } - if (target == 1) { - toAdd = Complexers.power(target,deep); - } else if (isPerfectSquare(target)) { - toAdd = Complexers.power(target,deep); - } else { - switch (rComplexer) { - case 1 -> toAdd = Complexers.divide(target,deep); - case 2 -> toAdd = Complexers.mRootDivisor(target,deep); - case 3 -> toAdd = Complexers.mRootDividend(target,deep); - case 4 -> toAdd = Complexers.root(target,deep); // Won't reach this one, if its "d" due to it stopping at 3 - } - } - - return (eval(toAdd) == target) ? toAdd : "(" + target + ")"; - } - - public static String pickComplexer() { - return "e"; - } } diff --git a/src/main/java/me/trouper/Main.java b/src/main/java/me/trouper/Main.java index 9da85ff..76f700d 100644 --- a/src/main/java/me/trouper/Main.java +++ b/src/main/java/me/trouper/Main.java @@ -47,12 +47,6 @@ public class Main { boolean doCopy = false; String mode = "N"; - Complexers.divide = true; - Complexers.power = true; - Complexers.root = true; - Complexers.mrDividend = true; - Complexers.mrDivisor = true; - for (String arg : args) { switch (arg) { case "--copy", "-c" -> doCopy = true; @@ -67,6 +61,12 @@ public class Main { } + Complexers.useRoot = !mode.equals("D"); + Complexers.usePower = true; + Complexers.useDivide = true; + Complexers.useRDivisor = true; + Complexers.useRDividend = true; + if (mode.equals("TEST")) { while (true) { diff --git a/src/main/java/me/trouper/Utils/Verbose.java b/src/main/java/me/trouper/Utils/Verbose.java new file mode 100644 index 0000000..1e7646d --- /dev/null +++ b/src/main/java/me/trouper/Utils/Verbose.java @@ -0,0 +1,7 @@ +package me.trouper.Utils; + +public class Verbose { + public static void send(String message, String klass, String type) { + + } +} From 324e11722f63d77b43bbea83af7df5d3a9afcb04 Mon Sep 17 00:00:00 2001 From: obvWolf Date: Mon, 6 Nov 2023 22:36:41 -0600 Subject: [PATCH 5/8] Making a universal intObf that can dynamicaly toggle the complexers and increasers that it uses (currently failing at it though) --- .idea/jarRepositories.xml | 5 + build.gradle | 7 +- .../me/trouper/{Main.java => Countroll.java} | 37 +++--- .../java/me/trouper/Data/ConfigManager.java | 76 +++++++++++++ .../java/me/trouper/Functions/Complexers.java | 55 ++++----- src/main/java/me/trouper/Functions/Eval.java | 19 +--- .../java/me/trouper/Functions/Increasers.java | 43 +++++-- src/main/java/me/trouper/Functions/Obf.java | 107 +++++++++++++----- src/main/java/me/trouper/Utils/Utils.java | 35 ++++-- src/main/java/me/trouper/Utils/Verbose.java | 29 ++++- src/main/resources/Manifest.mf | 2 +- 11 files changed, 309 insertions(+), 106 deletions(-) rename src/main/java/me/trouper/{Main.java => Countroll.java} (84%) create mode 100644 src/main/java/me/trouper/Data/ConfigManager.java diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml index fdc392f..9bc006e 100644 --- a/.idea/jarRepositories.xml +++ b/.idea/jarRepositories.xml @@ -16,5 +16,10 @@ \ No newline at end of file diff --git a/build.gradle b/build.gradle index 98b7a2f..9036833 100644 --- a/build.gradle +++ b/build.gradle @@ -7,11 +7,14 @@ version '0.0.4' repositories { mavenCentral() + maven { + url 'https://nexus.stirante.com/repository/maven-snapshots/' + } } dependencies { implementation 'net.objecthunter:exp4j:0.4.8' - implementation 'com.ezylang:EvalEx:3.0.5' + implementation group: 'com.google.code.gson', name: 'gson', version: '2.7' testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1' } @@ -22,7 +25,7 @@ test { jar { manifest { - attributes 'Main-Class': 'me.trouper.Main' + attributes 'Main-Class': 'me.trouper.Countroll' } from { configurations.runtimeClasspath.collect { diff --git a/src/main/java/me/trouper/Main.java b/src/main/java/me/trouper/Countroll.java similarity index 84% rename from src/main/java/me/trouper/Main.java rename to src/main/java/me/trouper/Countroll.java index 76f700d..ce66c30 100644 --- a/src/main/java/me/trouper/Main.java +++ b/src/main/java/me/trouper/Countroll.java @@ -1,23 +1,26 @@ package me.trouper; +import me.trouper.Data.ConfigManager; import me.trouper.Functions.Complexers; import me.trouper.Functions.Obf; import me.trouper.Utils.Timer; import me.trouper.Utils.Utils; +import me.trouper.Utils.Verbose; import java.util.Scanner; import static me.trouper.Functions.Eval.eval; -import static me.trouper.Functions.Eval.evalM; import static me.trouper.Utils.Utils.removeColors; -public class Main { - public static boolean verbose; +public class Countroll { + public static boolean doCopy; public static boolean deep; public static boolean color; public static boolean printHelp; + public static String mode; /* Statistics */ + public static int errorCount = 0; public static int expCount = 0; public static int factorCount = 0; public static int addCount = 0; @@ -41,32 +44,36 @@ public class Main { rootCount = 0; perfectCount = 0; total = 0; + errorCount = 0; } public static void main(String[] args) { + Scanner scanner = new Scanner(System.in); - boolean doCopy = false; - String mode = "N"; + ConfigManager.loadConfig(); for (String arg : args) { switch (arg) { case "--copy", "-c" -> doCopy = true; - case "--verbose", "-v" -> verbose = true; + case "--verbose", "-v" -> Verbose.all = true; case "--deep", "-d" -> deep = true; case "--color", "-rgb" -> color = true; case "--help", "--h", "-h" -> printHelp = true; - case "--mode=numselli", "-m=n" -> mode = "N"; + case "--mode=test", "-m=t" -> mode = "TEST"; case "--mode=duckgroup", "-m=d" -> mode = "D"; - case "--mode=TEST", "-m=t" -> mode = "TEST"; + case "--mode=numselli", "-m=n" -> mode = "N"; + case "--mode=universal", "-m=u" -> mode = "U"; } } + Verbose.send("INIT","Loading config"); - Complexers.useRoot = !mode.equals("D"); + Verbose.send("INIT","Config loaded, mode: " + mode); + Complexers.useRoot = true; Complexers.usePower = true; Complexers.useDivide = true; Complexers.useRDivisor = true; Complexers.useRDividend = true; - + if (mode.equals("D")) Complexers.useRoot = false; if (mode.equals("TEST")) { while (true) { @@ -78,7 +85,7 @@ public class Main { } try { - double result = evalM(userInput); + double result = eval(userInput); System.out.println("Result: " + result); } catch (Exception e) { System.out.println("Error: " + e.getMessage()); @@ -95,14 +102,14 @@ public class Main { int target = scanner.nextInt(); Timer obfTimer = Timer.start(); String expression = null; - switch (mode) { - case "N" -> expression = Obf.obfIntN(target, deep); - case "D" -> expression = Obf.obfIntD(target, deep); - } + + expression = Obf.obfIntN(target,deep); + long obfTime = obfTimer.end().timePassed(); double output = eval(removeColors(expression)); System.out.println("\nStatistics" + + "\nErrors: " + errorCount + "\nExponents: " + expCount + "\nFactors: " + factorCount + "\nAdditions: " + addCount + diff --git a/src/main/java/me/trouper/Data/ConfigManager.java b/src/main/java/me/trouper/Data/ConfigManager.java new file mode 100644 index 0000000..0bd73ad --- /dev/null +++ b/src/main/java/me/trouper/Data/ConfigManager.java @@ -0,0 +1,76 @@ +package me.trouper.Data; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonIOException; +import com.google.gson.JsonSyntaxException; +import me.trouper.Countroll; +import me.trouper.Utils.Verbose; + +import java.io.*; +import java.util.HashMap; +import java.util.Map; + +public class ConfigManager { + private static final String CONFIG_FILENAME = "countroll.json"; + + public static void loadConfig() { + File configFile = new File(CONFIG_FILENAME); + + if (!configFile.exists()) { + generateDefaultConfig(); + } else { + try (Reader reader = new FileReader(configFile)) { + Gson gson = new Gson(); + Map config = gson.fromJson(reader, HashMap.class); + setMainClassVariables(config); + } catch (JsonSyntaxException | JsonIOException | IOException e) { + e.printStackTrace(); + generateDefaultConfig(); + } + } + } + + private static void generateDefaultConfig() { + Map defaultConfig = new HashMap<>(); + defaultConfig.put("doCopy", false); + defaultConfig.put("deep", false); + defaultConfig.put("color", false); + defaultConfig.put("printHelp", false); + defaultConfig.put("mode", "N"); + defaultConfig.put("verbose.all",false); + defaultConfig.put("verbose.processes",true); + defaultConfig.put("verbose.loops",false); + defaultConfig.put("verbose.eval",false); + defaultConfig.put("verbose.complexers",false); + defaultConfig.put("verbose.increasers",false); + defaultConfig.put("verbose.utils",false); + defaultConfig.put("verbose.errors",true); + + try (Writer writer = new FileWriter(CONFIG_FILENAME)) { + Gson gson = new GsonBuilder().setPrettyPrinting().create(); + gson.toJson(defaultConfig, writer); + } catch (IOException e) { + e.printStackTrace(); + } + setMainClassVariables(defaultConfig); + } + + private static void setMainClassVariables(Map config) { + Verbose.send("INIT", "Loading main class variables"); + Countroll.doCopy = (boolean) config.get("doCopy"); + Countroll.deep = (boolean) config.get("deep"); + Countroll.color = (boolean) config.get("color"); + Countroll.printHelp = (boolean) config.get("printHelp"); + Countroll.mode = (String) config.get("mode"); + Verbose.all = (boolean) config.get("verbose.all"); + Verbose.processes = (boolean) config.get("verbose.processes"); + Verbose.loops = (boolean) config.get("verbose.loops"); + Verbose.eval = (boolean) config.get("verbose.eval"); + Verbose.complexers = (boolean) config.get("verbose.complexers"); + Verbose.increasers = (boolean) config.get("verbose.increasers"); + Verbose.utils = (boolean) config.get("verbose.utils"); + Verbose.errors = (boolean) config.get("verbose.errors"); + Verbose.send("INIT","mode = " + Countroll.mode); + } +} diff --git a/src/main/java/me/trouper/Functions/Complexers.java b/src/main/java/me/trouper/Functions/Complexers.java index c63c12e..c24860a 100644 --- a/src/main/java/me/trouper/Functions/Complexers.java +++ b/src/main/java/me/trouper/Functions/Complexers.java @@ -1,7 +1,8 @@ package me.trouper.Functions; -import me.trouper.Main; +import me.trouper.Countroll; import me.trouper.Utils.Utils; +import me.trouper.Utils.Verbose; import java.util.*; @@ -40,6 +41,7 @@ public class Complexers { return divide(i,deep); } case "power" -> { + if (!isPerfectSquare(i)) return complex(i,deep); return power(i,deep); } case "root" -> { @@ -49,7 +51,7 @@ public class Complexers { return mRootDividend(i,deep); } case "mrDivisor" -> { - return mRootDivisor(i,deep); + return mRootDivisor(i,false); } default -> { return divide(i,false); @@ -62,21 +64,20 @@ public class Complexers { * @return Colored String */ public static String divide(int i, boolean deep) { - Main.divideCount++; + Verbose.send("COMP", "Running Divide Complexer, I:" + i + " Deep: " + deep); + Countroll.divideCount++; Random random = new Random(); int factor = random.nextInt(9)+1; int doubled = i * factor; - boolean expFac = false; - boolean expDoub = false; String result = "<&f>(<&r><&e>" + doubled + "<&b>/<&r><&e>" + factor + "<&f>)<&r>"; if (deep) { result = "<&3>(<&r><&d>" + (complex(doubled,false)) + "<&b>/<&r><&d>" + (complex(factor,false)) + "<&3>)<&r>"; } - if (eval(result) != i) Utils.verbose("Failed to divide " + i + ", Attempted: " + result + "=" + eval(result)); - return eval(result) == i ? result : "(" + i + ")"; + if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to divide <&r>" + i + ", Attempted: " + result + "=" + eval(result)); + return eval(result) == i ? result : "<&ch>(" + i + ")<&r>"; } /** @@ -86,10 +87,8 @@ public class Complexers { * @return Colored String */ public static String power(int i, boolean deep) { - Main.powerCount++; - if (!Eval.isPerfectSquare(i)) { - return "(" + i + ")"; - } + Verbose.send("COMP", "Running Power Complexer, I:" + i + " Deep: " + deep); + Countroll.powerCount++; int root = (int) Math.sqrt(i); String result = "<&r><&f>(<&e>" + root + "<&b>^<&e>2<&f>)<&r>"; @@ -97,8 +96,8 @@ public class Complexers { if (deep) { result = "<&r><&3>(<&d>" + complex(root,false) + "<&b>^<&d>2<&3>)<&r>"; } - if (eval(result) != i) Utils.verbose("<&ch>Failed to power <&r>" + i + ", Attempted: " + result + "=" + eval(result)); - return eval(result) == i ? result : "(" + i + ")"; + if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to power <&r>" + i + ", Attempted: " + result + "=" + eval(result)); + return eval(result) == i ? result : "<&ch>(" + i + ")<&r>"; } /** @@ -107,15 +106,16 @@ public class Complexers { * @return Colored String */ public static String root(int i, boolean deep) { - Main.rootCount++; + Verbose.send("COMP", "Running Root Complexer, I:" + i + " Deep: " + deep); + Countroll.rootCount++; int squared = (int) Math.pow(i,2); String result = "<&9>sqrt<&r><&f>(<&r><&e>" + squared + "<&f>)<&r>"; if (deep) { result = "<&1>sqrt<&r><&3>(<&r><&d>" + complex(squared, false) + "<&3>)<&r>"; } - if (eval(result) != i) Utils.verbose("<&ch>Failed to root <&r>" + i + ", Attempted: " + result + "=" + eval(result)); - return (eval(result) == i) ? result : "(" + i + ")"; + if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to root <&r>" + i + ", Attempted: " + result + "=" + eval(result)); + return (eval(result) == i) ? result : "<&ch>(" + i + ")<&r>"; } /** @@ -124,22 +124,24 @@ public class Complexers { * @return Colored string */ public static String mRootDivisor(int i, boolean deep) { - Main.rDivisorCount++; + Verbose.send("COMP", "Running mrDivisor Complexer, I:" + i + " Deep: " + deep); + Countroll.rDivisorCount++; Random random = new Random(); - int dividend = random.nextInt(9)+i+10; + int dividend = random.nextInt(9)+random.nextInt(48)+1+i; int divisor = Utils.moduRootDivisor(dividend,i); String result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; if (deep) { - result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor, false) + "<&7>)<&r>"; + result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor,false) + "<&7>)<&r>"; } - Utils.verbose("<&dh><&b>mRootDivisor has ran!<&r>" + + + Verbose.send("COMP","<&dh><&b>mRootDivisor has ran!<&r>" + "\nWanted: " + i + "\nDivisor: " + divisor + "\nDividend: " + dividend + "\nCheck: " + dividend + "%" + divisor + "=" + i + "\nResult: " + result); - if (eval(result) != i) Utils.verbose("<&ch>Failed to mRootDivisor<&r> " + i + ", Attempted: " + result + "=" + eval(result)); - return (eval(result) == i) ? result : "(" + i + ")"; + if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to mRootDivisor<&r> " + i + ", Attempted: " + result + "=" + eval(result)); + return (eval(result) == i) ? result : mRootDividend(i,false); } /** @@ -148,7 +150,8 @@ public class Complexers { * @return Colored String */ public static String mRootDividend(int i, boolean deep) { - Main.rDividendCount++; + Verbose.send("COMP", "Running mrDividend Complexer, I:" + i + " Deep: " + deep); + Countroll.rDividendCount++; Random random = new Random(); int divisor = random.nextInt(9)+i+10; int dividend = Utils.moduRootDividend(divisor,i); @@ -156,14 +159,14 @@ public class Complexers { if (deep) { result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor,false) + "<&7>)<&r>"; } - Utils.verbose("<&dh><&b>mRootDividend has been ran!<&r>" + + Verbose.send("COMP","<&dh><&b>mRootDividend has been ran!<&r>" + "\nWanted:" + i + "\nDivisor: " + divisor + "\nDividend: " + dividend + "\nCheck: " + dividend + "%" + divisor + "=" + i + "\nResult: " + result); - if (eval(result) != i) Utils.verbose("<&ch>Failed to mRootDividend<&r> " + i + ", Attempted: " + result + "=" + eval(result)); - return (eval(result) == i) ? result : "(" + i + ")"; + if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to mRootDividend<&r> " + i + ", Attempted: " + result + "=" + eval(result)); + return (eval(result) == i) ? result : "<&ch>(" + i + ")<&r>"; } } diff --git a/src/main/java/me/trouper/Functions/Eval.java b/src/main/java/me/trouper/Functions/Eval.java index 400c17b..b2c3978 100644 --- a/src/main/java/me/trouper/Functions/Eval.java +++ b/src/main/java/me/trouper/Functions/Eval.java @@ -1,32 +1,23 @@ package me.trouper.Functions; -import com.ezylang.evalex.EvaluationException; -import com.ezylang.evalex.data.EvaluationValue; -import com.ezylang.evalex.parser.ParseException; import me.trouper.Utils.Utils; +import me.trouper.Utils.Verbose; import net.objecthunter.exp4j.Expression; import net.objecthunter.exp4j.ExpressionBuilder; public class Eval { public static double eval(String expression) { final String cleaned = Utils.removeColors(expression); - Utils.verbose("Evaluating Expression: " + cleaned); + Verbose.send("EVAL","Evaluating Expression: " + cleaned); Expression exp = new ExpressionBuilder(cleaned).build(); return exp.evaluate(); } public static boolean isPerfectSquare(int num) { - if (num < 0) { - return false; - } - int sqrt = (int) Math.sqrt(num); - return sqrt * sqrt == num; + if (num == 0) return false; + final double sq = Math.sqrt(num); + return sq == Math.floor(sq); } public static boolean isInt(double number) { return (number == Math.floor(number)) && !Double.isInfinite(number); } - public static double evalM(String exp) throws EvaluationException, ParseException { - com.ezylang.evalex.Expression expression = new com.ezylang.evalex.Expression(exp); - EvaluationValue result = expression.evaluate(); - return result.getNumberValue().doubleValue(); - } } diff --git a/src/main/java/me/trouper/Functions/Increasers.java b/src/main/java/me/trouper/Functions/Increasers.java index 9d93f5d..dba800f 100644 --- a/src/main/java/me/trouper/Functions/Increasers.java +++ b/src/main/java/me/trouper/Functions/Increasers.java @@ -1,29 +1,56 @@ package me.trouper.Functions; +import me.trouper.Countroll; +import me.trouper.Utils.Utils; +import me.trouper.Utils.Verbose; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + import static me.trouper.Functions.Eval.eval; import static me.trouper.Functions.Eval.isPerfectSquare; public class Increasers { - public static String multiply(int i, int factor, boolean deep) { - boolean useExp = isPerfectSquare(i); + public static String increase(int current, int target, int i, boolean deep) { + + if (target - current > 4069) { + return power(i,10,deep); + } else if (target - current > 10000000) { + return power(i,8,deep); + } else if (target - current > 1000000) { + return power(i,6,deep); + } else if (target - current > 100000) { + return power(i,4,deep); + } else if (target - current > 10000) { + return power(i,3,deep); + } else if (target - current > 1000) { + return power(i,2,deep); + } else if (target - current > 100) { + return multiply(i,9,deep); + } else { + return multiply(i,2,deep); + } + } + public static String multiply(int i, int factor, boolean deep) { + Countroll.factorCount++; String result = "<&7>(<&r><&2>" + i + "<&b>*<&r><&2>" + factor + "<&7>)<&r>"; if (deep) { - result = "<&7>(<&r><&2>" + (useExp ? Complexers.power(i,true) : Complexers.divide(i,true)) + "<&b>*<&r><&2>" + factor + "<&7>)<&r>"; + result = "<&7>(<&r><&2>" + (Complexers.complex(i,true)) + "<&b>*<&r><&2>" + Complexers.complex(i,true) + "<&7>)<&r>"; } - + if (!(eval(result) == i * factor)) Verbose.send("ERR", "Failed multiply increaser!"); return eval(result) == i * factor ? result : "(" + i + ")"; } public static String power(int i, int exp, boolean deep) { - boolean useExp = isPerfectSquare(i); - + Countroll.powerCount++; String result = "<&7>(<&r><&2>" + i + "<&b>^<&r><&2>" + exp + "<&7>)<&r>"; if (deep) { - result = "<&7>(<&r><&2>" + (useExp ? Complexers.power(i,true) : Complexers.divide(i,true)) + "<&b>^<&r><&2>" + exp + "<&7>)<&r>"; + result = "<&7>(<&r><&2>" + Complexers.complex(i,true) + "<&b>^<&r><&2>" + Complexers.complex(i,true) + "<&7>)<&r>"; } - + if (!(eval(result) == Math.pow(i,exp))) Verbose.send("ERR", "Failed power increaser!"); return eval(result) == Math.pow(i,exp) ? result : "(" + i + ")"; } } diff --git a/src/main/java/me/trouper/Functions/Obf.java b/src/main/java/me/trouper/Functions/Obf.java index f62d060..31aac2b 100644 --- a/src/main/java/me/trouper/Functions/Obf.java +++ b/src/main/java/me/trouper/Functions/Obf.java @@ -1,15 +1,61 @@ package me.trouper.Functions; -import me.trouper.Main; +import me.trouper.Countroll; +import me.trouper.Utils.Verbose; import java.util.Random; import static me.trouper.Functions.Eval.*; import static me.trouper.Functions.Eval.eval; import static me.trouper.Utils.Utils.removeColors; -import static me.trouper.Utils.Utils.verbose; public class Obf { + public static String obfInt(int target) { + Verbose.send("PROC", "Starting Obfuscation (Universal)"); + StringBuilder expression = new StringBuilder(); + Random rand = new Random(); + + // INIT + int init = rand.nextInt(9)+1; + Verbose.send("PROC", "Initializing Expression: " + init); + expression.append("<&dh><&f>").append(init).append("<&r>"); + + // MAIN LOOP + Verbose.send("PROC", "Beginning Main Loop: "); + while (eval(expression.toString()) != target) { + + Countroll.total++; + int current = (int) eval(expression.toString()); + int ri = rand.nextInt(9)+1; + + if (!isInt(eval(expression.toString()))) { + System.out.println("Something went horribly wrong, Here is the relevant info." + + "\nEvaluation: " + eval(expression.toString()) + + "\nRandom Pick: " + ri + + "\nCaught at: \n" + removeColors(expression.toString())); + break; + } + + String comp = Complexers.complex(ri,Countroll.deep); + String incr = Increasers.increase(current,target,ri,Countroll.deep); + + if (current < target) { + Countroll.addCount++; + expression.append("<&b>+<&r><&e>").append(comp).append("<&r>"); + if (target - current > 128) { + expression.append("<&b>+<&r><&e>").append(incr).append("<&r>"); + } + } + if (current > target) { + Countroll.subCount++; + expression.append("<&b>-<&r><&e>").append(comp).append("<&r>"); + if (current - target > 128) { + expression.append("<&b>-<&r><&e>").append(incr).append("<&r>"); + } + } + } + return expression.toString(); + } /** * ObfIntN will work for Numselli's counting bot * @param target Integer to reach @@ -23,12 +69,12 @@ public class Obf { Random random = new Random(); int initializer = random.nextInt(9)+1; - verbose("Initializing Expression: " + initializer); + Verbose.send("PROC","Initializing Expression: " + initializer); expression.append("<&dh><&f>").append(initializer).append("<&r>"); while (eval(expression.toString()) != target) { - Main.total++; + Countroll.total++; int eval = (int) eval(expression.toString()); int ri = random.nextInt(9)+1; int op = random.nextInt(2); @@ -43,12 +89,12 @@ public class Obf { break; } - verbose("Random: " + ri); - verbose("Current: " + eval(expression.toString())); + Verbose.send("LOOP","Random: " + ri); + Verbose.send("LOOP","Current: " + eval(expression.toString())); if (isPerfectSquare(eval) && eval != 1) { - Main.perfectCount++; - verbose("PERFECT SQUARE TIME! (" + Main.perfectCount+ ")"); + Countroll.perfectCount++; + Verbose.send("LOOP","PERFECT SQUARE TIME! (" + Countroll.perfectCount+ ")"); expression.insert(0,"<&eh><&b>sqrt(<&r>").append("<&eh><&b>)<&r>"); eval = (int) eval(expression.toString()); } @@ -57,34 +103,34 @@ public class Obf { if (eval < target) { if (target - eval > 4069) { - Main.expCount++; - verbose("Large than (" + Main.expCount + ")"); + Countroll.expCount++; + Verbose.send("LOOP","Large than (" + Countroll.expCount + ")"); expression.append("<&b>*<&r><&a>").append(Increasers.power(ri,3,deep)).append("<&r>"); } else if (target - eval > 1048) { - Main.expCount++; - verbose("Large than (" + Main.expCount + ")"); + Countroll.expCount++; + Verbose.send("LOOP","Large than (" + Countroll.expCount + ")"); expression.append("<&b>*<&r><&a>").append(Increasers.power(ri,2,deep)).append("<&r>"); } else if (target - eval > 128) { - Main.factorCount++; - verbose("Big than (" + Main.factorCount + ")"); + Countroll.factorCount++; + Verbose.send("LOOP","Big than (" + Countroll.factorCount + ")"); expression.append("<&b>*<&r><&a>").append(Increasers.multiply(ri,9,deep)).append("<&r>"); } - Main.addCount++; + Countroll.addCount++; expression.append("<&b>+<&r><&e>").append(toAdd).append("<&r>"); - verbose("Less than (" + Main.addCount + ")"); + Verbose.send("LOOP","Less than (" + Countroll.addCount + ")"); } if (eval > target) { - Main.subCount++; + Countroll.subCount++; expression.insert(0,"<&c>(<&r>").append("<&c>)<&r>"); expression.append("<&b>-<&r><&e>").append(toAdd).append("<&r>"); - verbose("Greater than (" + Main.subCount + ")"); + Verbose.send("LOOP","Greater than (" + Countroll.subCount + ")"); } } - verbose("Broke out of loop. Value: " + eval(expression.toString())); - verbose("Expression: " + expression); - verbose("Expression (Cleaned): " + removeColors(expression.toString())); + Verbose.send("PROC","Broke out of loop. Value: " + eval(expression.toString())); + Verbose.send("EVAL","Expression: " + expression); + Verbose.send("EVAL","Expression (Cleaned): " + removeColors(expression.toString())); return expression.toString(); } @@ -101,11 +147,10 @@ public class Obf { Random random = new Random(); int initializer = random.nextInt(9)+1; - verbose("Initializing Expression: " + initializer); expression.append("<&dh><&f>").append(initializer).append("<&r>"); while (eval(expression.toString()) != target) { - Main.total++; + Countroll.total++; int eval = (int) eval(expression.toString()); int ri = random.nextInt(9)+1; @@ -114,30 +159,30 @@ public class Obf { if (eval < target) { if (target - eval > 4096) { - Main.expCount++; + Countroll.expCount++; expression.append("<&b>*<&r>").append(Increasers.power(ri,4,deep)); } else if (target - eval > 1048) { - Main.expCount++; + Countroll.expCount++; expression.append("<&b>*<&r>").append(Increasers.power(ri,2,deep)); } else if (target - eval > 128) { - Main.factorCount++; + Countroll.factorCount++; expression.append("<&b>*<&r>").append(Increasers.multiply(ri,2,deep)); } - Main.addCount++; + Countroll.addCount++; expression.append("<&b>+<&r>").append(toAdd); } if (eval > target) { if (eval - target > 4096) { - Main.expCount++; + Countroll.expCount++; expression.append("<&b>-<&r>").append(Increasers.power(ri,5,deep)); } else if (eval - target> 1048) { - Main.expCount++; + Countroll.expCount++; expression.append("<&b>-<&r>").append(Increasers.power(ri,3,deep)); } else if (eval - target > 128) { - Main.factorCount++; + Countroll.factorCount++; expression.append("<&b>-<&r>").append(Increasers.multiply(ri,2,deep)); } - Main.subCount++; + Countroll.subCount++; expression.insert(0,"<&c>(<&r>").append("<&c>)<&r>"); expression.append("<&b>-<&r>").append(toAdd); } diff --git a/src/main/java/me/trouper/Utils/Utils.java b/src/main/java/me/trouper/Utils/Utils.java index 2da742a..acdfba2 100644 --- a/src/main/java/me/trouper/Utils/Utils.java +++ b/src/main/java/me/trouper/Utils/Utils.java @@ -1,7 +1,8 @@ package me.trouper.Utils; import me.trouper.Data.MC2Ansi; -import me.trouper.Main; +import me.trouper.Countroll; +import me.trouper.Functions.Eval; import java.awt.*; import java.awt.datatransfer.Clipboard; @@ -9,14 +10,26 @@ import java.awt.datatransfer.StringSelection; import java.util.Map; public class Utils { + public static int calcExp(int difference) { + int result = 1; + + if (difference >= 4096) result = 2; + if (difference >= 8192) result = 3; + if (difference >= 16384) result = 4; + if (difference >= 32768) result = 5; + if (difference >= 65536) result = 6; + if (difference >= 131072) result = 7; + if (difference >= 262144) result = 8; + if (difference >= 524288) result = 9; + if (difference >= 1048576) result = 10; + + return result; + } public static void copyToClip(String text) { StringSelection parsed = new StringSelection(text); Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard(); clipboard.setContents(parsed,null); } - public static void verbose(String text) { - if (Main.verbose) System.out.println(activateColors(text)); - } public static String removeColors(String input) { return input.replaceAll("<&[0-9a-fr]>|<&[0-9a-frh]h>", ""); } @@ -70,12 +83,20 @@ public class Utils { * @return The divisor */ public static int moduRootDivisor(int dividend, int modulus) { + int divisor = dividend - modulus; - verbose("<&1h><&e>Finding mrDivisor:<&r> " + + Verbose.send("UTIL","<&1h><&e>Finding mrDivisor:<&r> " + "\nDividend (Given): " + dividend + "\nDivisor (Unknown): " + divisor + - "\nModulus (Given): " + modulus); + "\nModulus (Given): " + modulus + + "\nCheck: " + dividend + "%" + divisor + "=" + Eval.eval(dividend + "%" + divisor)); return divisor; + /* + int divisor = 1; + while (divisor * dividend % modulus != 0 || divisor != 1) { + divisor++; + } + return divisor;*/ } /** @@ -87,7 +108,7 @@ public class Utils { */ public static int moduRootDividend(int divisor, int modulus) { int dividend = modulus + divisor; - verbose("<&1h><&e>Finding mrDivisor:<&r> " + + Verbose.send("UTIL","<&1h><&e>Finding mrDivisor:<&r> " + "\nDividend (Unknown): " + dividend + "\nDivisor (Given): " + divisor + "\nModulus (Given): " + modulus); diff --git a/src/main/java/me/trouper/Utils/Verbose.java b/src/main/java/me/trouper/Utils/Verbose.java index 1e7646d..047f588 100644 --- a/src/main/java/me/trouper/Utils/Verbose.java +++ b/src/main/java/me/trouper/Utils/Verbose.java @@ -1,7 +1,32 @@ package me.trouper.Utils; -public class Verbose { - public static void send(String message, String klass, String type) { +import me.trouper.Countroll; +public class Verbose { + public static boolean processes; + public static boolean all; + public static boolean loops; + public static boolean eval; + public static boolean complexers; + public static boolean increasers; + public static boolean utils; + public static boolean errors; + public static void send(String type, String message) { + message = Utils.activateColors(message); + if (all) { + System.out.println(message); + return; + } + if (type.equals("INIT")) System.out.println(message); + if (type.equals("PROC") && processes) System.out.println(message); + if (type.equals("LOOP") && loops) System.out.println(message); + if (type.equals("UTIL") && utils) System.out.println(message); + if (type.equals("EVAL") && eval) System.out.println(message); + if (type.equals("COMP") && complexers) System.out.println(message); + if (type.equals("INCR") && increasers) System.out.println(message); + if (type.equals("ERR") && errors) { + System.out.println(message); + Countroll.errorCount++; + } } } diff --git a/src/main/resources/Manifest.mf b/src/main/resources/Manifest.mf index 09f1bfb..abe096b 100644 --- a/src/main/resources/Manifest.mf +++ b/src/main/resources/Manifest.mf @@ -1,2 +1,2 @@ Manifest-Version: 1.0 -Main-Class: me.trouper.Main +Main-Class: me.trouper.Countroll From 2a31690d610c31efd89a81472c2ac9044bdbe7d3 Mon Sep 17 00:00:00 2001 From: obvWolf Date: Tue, 7 Nov 2023 20:31:53 -0600 Subject: [PATCH 6/8] Cleaned up the main class and finished the config manager --- README.md | 28 ++++ src/main/java/me/trouper/Countroll.java | 151 +++++++++++------- .../java/me/trouper/Data/ConfigManager.java | 21 ++- .../java/me/trouper/Functions/Complexers.java | 35 +--- .../java/me/trouper/Functions/Increasers.java | 55 ++++--- src/main/java/me/trouper/Functions/Obf.java | 13 +- 6 files changed, 184 insertions(+), 119 deletions(-) diff --git a/README.md b/README.md index 94495ba..3f3a27f 100644 --- a/README.md +++ b/README.md @@ -53,6 +53,34 @@ Make sure you have Java 17 or higher installed on your system! 3. Build with gradle `$ ./gradlew build` 4. Build will be output to `/Countroll/build/libs` +# Config With Comments + +```json +{ // The config is in json, there are no comments allowed in the countroll.json + "doCopy": false, // Automaticaly copying to clipboard + "deep": false, // Deep obfuscation, doubling output size + "verbose.errors": true, // Error printing + "color": true, // Razor Chroma RGB xpressions are outputed + "useRoot": true, // Uses sqrt() function + "verbose.complexers": false, // Shows what the complexers are doing + "show.progress": false, // Shows the current eval as the expression is building + "useDivide": true, // Toggles the divide complexer + "verbose.eval": false, // Shows what the eval function is doing + "verbose.processes": true, // Shows non looping verbose + "printHelp": false, // Prints a help message then exits + "mode": "U", // Switch modes + // U is universal, and will follow all the comlpexer toggles for fully custom setup + // D is duckgroup mode, and will not use lettered functions + // N is numselli mode, and will enable all complexers + "verbose.all": false, // Shows all the verbose + "usePower": true, // Toggles power complexer + "useModDividend": true, // Toggles moduRootDividend complexer (doesnt use letters) + "verbose.utils": false, // Shows what the Utils are doing + "verbose.increasers": false, // Shows what the increasers are doing + "verbose.loops": false // Shows what the loops are doing +} +``` + # Up Next Development will continue with the addition of bitwise operations AND (&) and OR (|) - Both bots support these operators, and it will be in both modes diff --git a/src/main/java/me/trouper/Countroll.java b/src/main/java/me/trouper/Countroll.java index ce66c30..7cc7adb 100644 --- a/src/main/java/me/trouper/Countroll.java +++ b/src/main/java/me/trouper/Countroll.java @@ -10,9 +10,11 @@ import me.trouper.Utils.Verbose; import java.util.Scanner; import static me.trouper.Functions.Eval.eval; +import static me.trouper.Utils.Utils.copyToClip; import static me.trouper.Utils.Utils.removeColors; public class Countroll { + public static boolean showProgress; public static boolean doCopy; public static boolean deep; public static boolean color; @@ -47,10 +49,35 @@ public class Countroll { errorCount = 0; } public static void main(String[] args) { - Scanner scanner = new Scanner(System.in); ConfigManager.loadConfig(); + parseCommandLineArguments(args); + + Verbose.send("INIT", "Loading config"); + Verbose.send("INIT", "Config loaded, mode: " + mode); + + if (mode.equals("D")) { + Complexers.useRoot = false; + } + + if (mode.equals("TEST")) { + handleTestMode(scanner); + } + + if (printHelp) { + Utils.printHelp(); + System.exit(0); + } + if (color) { + Utils.printColorKey(); + } + + handleTargetIntegers(scanner); + scanner.close(); + } + + private static void parseCommandLineArguments(String[] args) { for (String arg : args) { switch (arg) { case "--copy", "-c" -> doCopy = true; @@ -64,80 +91,92 @@ public class Countroll { case "--mode=universal", "-m=u" -> mode = "U"; } } + } - Verbose.send("INIT","Loading config"); + private static void handleTestMode(Scanner scanner) { + while (true) { + System.out.print("Enter an expression (or 'exit' to exit): "); + String userInput = scanner.next(); - Verbose.send("INIT","Config loaded, mode: " + mode); - Complexers.useRoot = true; - Complexers.usePower = true; - Complexers.useDivide = true; - Complexers.useRDivisor = true; - Complexers.useRDividend = true; - if (mode.equals("D")) Complexers.useRoot = false; + if (userInput.equals("exit")) { + System.exit(0); + } - if (mode.equals("TEST")) { - while (true) { - System.out.print("Enter an expression (or 'exit' to exit): "); - String userInput = scanner.next(); - - if (userInput.equals("exit")) { - System.exit(0); - } - - try { - double result = eval(userInput); - System.out.println("Result: " + result); - } catch (Exception e) { - System.out.println("Error: " + e.getMessage()); - } + try { + double result = eval(userInput); + System.out.println("Result: " + result); + } catch (Exception e) { + System.out.println("Error: " + e.getMessage()); } } + } - if (printHelp) Utils.printHelp(); - if (color) Utils.printColorKey(); - + private static void handleTargetIntegers(Scanner scanner) { while (true) { System.out.print("Enter Target Integer: "); if (scanner.hasNextInt()) { int target = scanner.nextInt(); + Timer obfTimer = Timer.start(); - String expression = null; - - expression = Obf.obfIntN(target,deep); - + String expression = Obf.obfInt(target); long obfTime = obfTimer.end().timePassed(); + double output = eval(removeColors(expression)); - System.out.println("\nStatistics" + - "\nErrors: " + errorCount + - "\nExponents: " + expCount + - "\nFactors: " + factorCount + - "\nAdditions: " + addCount + - "\nSubtractions: " + subCount + - "\nDivisors: " + divideCount + - "\nPowers: " + powerCount + - "\nmRootDividends: " + rDividendCount + - "\nmRootDivisors: " + rDivisorCount + - "\nRoots Taken: " + rootCount + - "\nPerfect Squares Found: " + perfectCount + - "\nTotal steps taken: " + total); - System.out.println("\nElapsed Time: " + obfTime + "ms"); - System.out.println("\nTarget Integer: " + target); - - if (output == target) { - System.out.println(Utils.activateColors("<&2h><&f>Expression Correct<&r>\n\n" + ((color) ? expression : removeColors(expression)))); - if (doCopy) Utils.copyToClip(removeColors(expression)); - clearStats(); - } else { - System.out.println(Utils.activateColors("<&ch><&0>!!!! INCORRECT !!!!<&r>\n\n" + ((color) ? expression : removeColors(expression)))); - } + printStatistics(obfTime); + printReport(target,expression,output); + if (doCopy) copyToClip(removeColors(expression)); } else { System.out.println("Exiting the program."); break; } } - - scanner.close(); + } + private static void printReport(int target, String expression, double output) { + String report; + if (target == output) { + report = String.format(""" + ╔═══════[ Report ]═════════ + ║ Target Integer: %d + ║ Final Result: %s <&ah><&b>✔<&r> + ║ Expression Length: %s + ╚══════════════════════════ + + >> %s + """,target,output,expression.length(),expression); + } else { + report = String.format(""" + ╔═══════[ Report ]═════════ + ║ Target Integer: %d + ║ Final Result: %s <&ch><&e>❌<&r> + ║ Expression Length: %s + ╚══════════════════════════ + + >> %s + """,target,output,expression.length(),expression); + } + System.out.println((color) ? Utils.activateColors(report) : removeColors(report)); } + private static void printStatistics(long time) { + String statistics = String.format(""" + + ╔═══════[ Statistics ]═════════ + ║ Exponents: %d + ║ Factors: %d + ║ Additions: %d + ║ Subtractions: %d + ║ Divisors: %d + ║ Powers: %d + ║ mRootDividends: %d + ║ Roots Taken: %d + ║ Perfect Squares Found: %d + ║ Errors: %d + ╠══════════════════════════════ + ║ Total steps taken: %d + ║ Elapsed Time: %d + ╚══════════════════════════════ + """, expCount, factorCount, addCount, subCount, divideCount, powerCount, rDividendCount, rootCount, perfectCount, errorCount, total, time); + System.out.println(statistics); + } } diff --git a/src/main/java/me/trouper/Data/ConfigManager.java b/src/main/java/me/trouper/Data/ConfigManager.java index 0bd73ad..92f74a8 100644 --- a/src/main/java/me/trouper/Data/ConfigManager.java +++ b/src/main/java/me/trouper/Data/ConfigManager.java @@ -5,6 +5,7 @@ import com.google.gson.GsonBuilder; import com.google.gson.JsonIOException; import com.google.gson.JsonSyntaxException; import me.trouper.Countroll; +import me.trouper.Functions.Complexers; import me.trouper.Utils.Verbose; import java.io.*; @@ -23,7 +24,7 @@ public class ConfigManager { try (Reader reader = new FileReader(configFile)) { Gson gson = new Gson(); Map config = gson.fromJson(reader, HashMap.class); - setMainClassVariables(config); + getConfig(config); } catch (JsonSyntaxException | JsonIOException | IOException e) { e.printStackTrace(); generateDefaultConfig(); @@ -33,11 +34,16 @@ public class ConfigManager { private static void generateDefaultConfig() { Map defaultConfig = new HashMap<>(); + defaultConfig.put("useDivide", true); + defaultConfig.put("usePower", true); + defaultConfig.put("useRoot", true); + defaultConfig.put("useModDividend", true); defaultConfig.put("doCopy", false); defaultConfig.put("deep", false); - defaultConfig.put("color", false); + defaultConfig.put("color", true); defaultConfig.put("printHelp", false); - defaultConfig.put("mode", "N"); + defaultConfig.put("mode", "U"); + defaultConfig.put("show.progress", false); defaultConfig.put("verbose.all",false); defaultConfig.put("verbose.processes",true); defaultConfig.put("verbose.loops",false); @@ -53,11 +59,16 @@ public class ConfigManager { } catch (IOException e) { e.printStackTrace(); } - setMainClassVariables(defaultConfig); + getConfig(defaultConfig); } - private static void setMainClassVariables(Map config) { + private static void getConfig(Map config) { Verbose.send("INIT", "Loading main class variables"); + Complexers.useDivide = (boolean) config.get("useDivide"); + Complexers.usePower = (boolean) config.get("usePower"); + Complexers.useRoot = (boolean) config.get("useRoot"); + Complexers.useRDividend = (boolean) config.get("useModDividend"); + Countroll.showProgress = (boolean) config.get("show.progress"); Countroll.doCopy = (boolean) config.get("doCopy"); Countroll.deep = (boolean) config.get("deep"); Countroll.color = (boolean) config.get("color"); diff --git a/src/main/java/me/trouper/Functions/Complexers.java b/src/main/java/me/trouper/Functions/Complexers.java index c24860a..ea1454a 100644 --- a/src/main/java/me/trouper/Functions/Complexers.java +++ b/src/main/java/me/trouper/Functions/Complexers.java @@ -15,7 +15,6 @@ public class Complexers { public static boolean usePower; public static boolean useRoot; public static boolean useRDividend; - public static boolean useRDivisor; public static String pickComplexer() { List enabledComplexers = new ArrayList<>(); @@ -24,7 +23,6 @@ public class Complexers { if (usePower) enabledComplexers.add("power"); if (useRoot) enabledComplexers.add("root"); if (useRDividend) enabledComplexers.add("mrDividend"); - if (useRDivisor) enabledComplexers.add("mrDivisor"); Collections.shuffle(enabledComplexers); if (!enabledComplexers.isEmpty()) { @@ -41,7 +39,9 @@ public class Complexers { return divide(i,deep); } case "power" -> { - if (!isPerfectSquare(i)) return complex(i,deep); + if (!isPerfectSquare(i)) { + return divide(i,deep); + } return power(i,deep); } case "root" -> { @@ -50,9 +50,6 @@ public class Complexers { case "mrDividend" -> { return mRootDividend(i,deep); } - case "mrDivisor" -> { - return mRootDivisor(i,false); - } default -> { return divide(i,false); } @@ -118,32 +115,6 @@ public class Complexers { return (eval(result) == i) ? result : "<&ch>(" + i + ")<&r>"; } - /** - * Uses modulus (ri%divisor)=i - * @param i Modulus to return - * @return Colored string - */ - public static String mRootDivisor(int i, boolean deep) { - Verbose.send("COMP", "Running mrDivisor Complexer, I:" + i + " Deep: " + deep); - Countroll.rDivisorCount++; - Random random = new Random(); - int dividend = random.nextInt(9)+random.nextInt(48)+1+i; - int divisor = Utils.moduRootDivisor(dividend,i); - String result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>"; - if (deep) { - result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor,false) + "<&7>)<&r>"; - } - - Verbose.send("COMP","<&dh><&b>mRootDivisor has ran!<&r>" + - "\nWanted: " + i + - "\nDivisor: " + divisor + - "\nDividend: " + dividend + - "\nCheck: " + dividend + "%" + divisor + "=" + i + - "\nResult: " + result); - if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to mRootDivisor<&r> " + i + ", Attempted: " + result + "=" + eval(result)); - return (eval(result) == i) ? result : mRootDividend(i,false); - } - /** * Uses modulus (dividend%ri)=i * @param i Modulus to return diff --git a/src/main/java/me/trouper/Functions/Increasers.java b/src/main/java/me/trouper/Functions/Increasers.java index dba800f..05cfb55 100644 --- a/src/main/java/me/trouper/Functions/Increasers.java +++ b/src/main/java/me/trouper/Functions/Increasers.java @@ -14,43 +14,56 @@ import static me.trouper.Functions.Eval.isPerfectSquare; public class Increasers { public static String increase(int current, int target, int i, boolean deep) { - - if (target - current > 4069) { - return power(i,10,deep); - } else if (target - current > 10000000) { - return power(i,8,deep); - } else if (target - current > 1000000) { - return power(i,6,deep); - } else if (target - current > 100000) { - return power(i,4,deep); - } else if (target - current > 10000) { - return power(i,3,deep); - } else if (target - current > 1000) { - return power(i,2,deep); - } else if (target - current > 100) { - return multiply(i,9,deep); + if (target - current > 64000) { + Countroll.expCount++; + return Increasers.power(i,4,deep); + } else if (target - current > 4069) { + Countroll.expCount++; + return Increasers.power(i,3,deep); + } else if (target - current > 1048) { + Countroll.expCount++; + return Increasers.power(i,2,deep); + } else if (target - current > 128) { + Countroll.factorCount++; + return Increasers.multiply(i,9,deep); } else { return multiply(i,2,deep); } } public static String multiply(int i, int factor, boolean deep) { Countroll.factorCount++; - String result = "<&7>(<&r><&2>" + i + "<&b>*<&r><&2>" + factor + "<&7>)<&r>"; + String result; if (deep) { result = "<&7>(<&r><&2>" + (Complexers.complex(i,true)) + "<&b>*<&r><&2>" + Complexers.complex(i,true) + "<&7>)<&r>"; + if (eval(result) == i * factor) return result; } - if (!(eval(result) == i * factor)) Verbose.send("ERR", "Failed multiply increaser!"); - return eval(result) == i * factor ? result : "(" + i + ")"; + + result = "<&7>(<&r><&2>" + i + "<&b>*<&r><&2>" + factor + "<&7>)<&r>"; + double calc = eval(result); + + if (!(calc == Math.multiplyExact(i,factor))) Verbose.send("ERR", "Failed multiply increaser! " + + "\nAttempted expression: " + result + + "\nTarget: " + i + + "\nCalc: " + calc); + return calc == i * factor ? result : "(" + i + ")"; } public static String power(int i, int exp, boolean deep) { Countroll.powerCount++; - String result = "<&7>(<&r><&2>" + i + "<&b>^<&r><&2>" + exp + "<&7>)<&r>"; + String result; if (deep) { result = "<&7>(<&r><&2>" + Complexers.complex(i,true) + "<&b>^<&r><&2>" + Complexers.complex(i,true) + "<&7>)<&r>"; + if (eval(result) == Math.pow(i,exp)) return result; } - if (!(eval(result) == Math.pow(i,exp))) Verbose.send("ERR", "Failed power increaser!"); - return eval(result) == Math.pow(i,exp) ? result : "(" + i + ")"; + + result = "<&7>(<&r><&2>" + i + "<&b>^<&r><&2>" + exp + "<&7>)<&r>"; + double calc = eval(result); + + if (!(calc == Math.pow(i,exp))) Verbose.send("ERR", "Failed multiply increaser! " + + "\nAttempted expression: " + result + + "\nTarget: " + i + + "\nCalc: " + calc); + return calc == Math.pow(i,exp) ? result : "(" + i + ")"; } } diff --git a/src/main/java/me/trouper/Functions/Obf.java b/src/main/java/me/trouper/Functions/Obf.java index 31aac2b..f3c5024 100644 --- a/src/main/java/me/trouper/Functions/Obf.java +++ b/src/main/java/me/trouper/Functions/Obf.java @@ -23,11 +23,12 @@ public class Obf { // MAIN LOOP Verbose.send("PROC", "Beginning Main Loop: "); while (eval(expression.toString()) != target) { - Countroll.total++; int current = (int) eval(expression.toString()); int ri = rand.nextInt(9)+1; + if (Countroll.showProgress) System.out.println("Current Evaluation: " + current); + // Checking for it still being a whole number if (!isInt(eval(expression.toString()))) { System.out.println("Something went horribly wrong, Here is the relevant info." + "\nEvaluation: " + eval(expression.toString()) + @@ -37,23 +38,25 @@ public class Obf { } String comp = Complexers.complex(ri,Countroll.deep); - String incr = Increasers.increase(current,target,ri,Countroll.deep); - + // Case for if its below if (current < target) { Countroll.addCount++; expression.append("<&b>+<&r><&e>").append(comp).append("<&r>"); if (target - current > 128) { - expression.append("<&b>+<&r><&e>").append(incr).append("<&r>"); + expression.append("<&b>*<&r><&e>").append(Increasers.increase(current,target,ri,Countroll.deep)).append("<&r>"); } } + + // Case for if its above if (current > target) { Countroll.subCount++; expression.append("<&b>-<&r><&e>").append(comp).append("<&r>"); if (current - target > 128) { - expression.append("<&b>-<&r><&e>").append(incr).append("<&r>"); + expression.append("<&b>-<&r><&e>").append(Increasers.increase(target,current,ri,Countroll.deep)).append("<&r>"); } } } + Verbose.send("PROC", "Broke out of loop."); return expression.toString(); } /** From df83249701e71b3412eaa79838e65cb7de81769c Mon Sep 17 00:00:00 2001 From: obvWolf Date: Tue, 7 Nov 2023 20:39:20 -0600 Subject: [PATCH 7/8] Updated gson import --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 9036833..0d207df 100644 --- a/build.gradle +++ b/build.gradle @@ -14,7 +14,7 @@ repositories { dependencies { implementation 'net.objecthunter:exp4j:0.4.8' - implementation group: 'com.google.code.gson', name: 'gson', version: '2.7' + implementation group: 'com.google.code.gson', name: 'gson', version: '2.8.9' testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1' } From 922c126f967c7748720f6e8fd736a5b5b2f168cb Mon Sep 17 00:00:00 2001 From: obvWolf Date: Tue, 7 Nov 2023 20:57:06 -0600 Subject: [PATCH 8/8] Updated README to reflect the recent changes Also I forgot to increment version counter so that has been done too --- README.md | 83 ++++++++++++++++++++++++++++++++-------------------- build.gradle | 2 +- 2 files changed, 52 insertions(+), 33 deletions(-) diff --git a/README.md b/README.md index 3f3a27f..4a68b6b 100644 --- a/README.md +++ b/README.md @@ -11,6 +11,7 @@ Countroll uses the following operators to make your integer as complex as possib - Division | / - Square Root | sqrt() - Exponentiation | ^ +- Modulus | % ## Compatibility @@ -38,6 +39,56 @@ There are multiple command line arguments you can use for ease of use | --help | --h, -h | Shows a message like this table | | --mode | -m | Changes the mode of the bot | +# Config With Comments +Dont fancy command line interfaces? Config is now implemented with json, here is a commented version +```json +{ + "printHelp": false, // Will print help then exit + "mode": "U", // Switch Modes + // U is universal, and will follow all the comlpexer toggles for fully custom setup + // D is duckgroup mode, and will not use lettered functions + // N is numselli mode, and will enable all complexers + "doCopy": false, // Automatically copies the expression to your clipboard + "deep": false, // Executes the Complexers on every integer twice (Doubles output size) + "color": true, // Makes the output Razor Chroma RGB + "useDivide": true, // Toggles the divide Complexer + "useRoot": true, // Toggles the sqrt() Complexer + "usePower": true, // Toggles the power Complexer + "useModDividend": true, // Toggles the Modulus Complexer + "show.progress": false, // Shows the current integer evaluation of the expression + "verbose.all": false, // Enables all the verbose + "verbose.processes": true, // Toggles verbose for main processes + "verbose.complexers": false, // Toggles verbose for the complexers + "verbose.increasers": false, // Toggles verbose for the increasers + "verbose.utils": false, // Toggles verbose for the utils + "verbose.eval": false, // Toggles verbose for the eval function + "verbose.loops": false, // Toggles verbose for the loops itterations + "verbose.errors": true // Toggles verbose errors +} +``` +When the config generates automatically it will generate in a random order, here is the ordered version if you prefer to have it readable +```json +{ + "printHelp": false, + "mode": "U", + "doCopy": false, + "deep": false, + "color": true, + "useDivide": true, + "useRoot": true, + "usePower": true, + "useModDividend": true, + "show.progress": false, + "verbose.all": false, + "verbose.processes": true, + "verbose.complexers": false, + "verbose.increasers": false, + "verbose.utils": false, + "verbose.eval": false, + "verbose.loops": false, + "verbose.errors": true +} +``` ## Modes: You can change the bot's mode with the --mode option - `--mode=numselli` or `-m=n` Uses Square Root @@ -53,35 +104,3 @@ Make sure you have Java 17 or higher installed on your system! 3. Build with gradle `$ ./gradlew build` 4. Build will be output to `/Countroll/build/libs` -# Config With Comments - -```json -{ // The config is in json, there are no comments allowed in the countroll.json - "doCopy": false, // Automaticaly copying to clipboard - "deep": false, // Deep obfuscation, doubling output size - "verbose.errors": true, // Error printing - "color": true, // Razor Chroma RGB xpressions are outputed - "useRoot": true, // Uses sqrt() function - "verbose.complexers": false, // Shows what the complexers are doing - "show.progress": false, // Shows the current eval as the expression is building - "useDivide": true, // Toggles the divide complexer - "verbose.eval": false, // Shows what the eval function is doing - "verbose.processes": true, // Shows non looping verbose - "printHelp": false, // Prints a help message then exits - "mode": "U", // Switch modes - // U is universal, and will follow all the comlpexer toggles for fully custom setup - // D is duckgroup mode, and will not use lettered functions - // N is numselli mode, and will enable all complexers - "verbose.all": false, // Shows all the verbose - "usePower": true, // Toggles power complexer - "useModDividend": true, // Toggles moduRootDividend complexer (doesnt use letters) - "verbose.utils": false, // Shows what the Utils are doing - "verbose.increasers": false, // Shows what the increasers are doing - "verbose.loops": false // Shows what the loops are doing -} -``` - -# Up Next -Development will continue with the addition of bitwise operations AND (&) and OR (|) -- Both bots support these operators, and it will be in both modes - diff --git a/build.gradle b/build.gradle index 0d207df..c5f0723 100644 --- a/build.gradle +++ b/build.gradle @@ -3,7 +3,7 @@ plugins { } group 'me.trouper' -version '0.0.4' +version '0.0.5' repositories { mavenCentral()