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..c63c12e 100644 --- a/src/main/java/me/trouper/Functions/Complexers.java +++ b/src/main/java/me/trouper/Functions/Complexers.java @@ -3,13 +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 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 @@ -24,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 + ")"; @@ -52,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 + ")"; @@ -69,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 + ")"; @@ -86,7 +129,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><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor, false) + "<&7>)<&r>"; + } + Utils.verbose("<&dh><&b>mRootDivisor has ran!<&r>" + "\nWanted: " + i + "\nDivisor: " + divisor + "\nDividend: " + dividend + @@ -107,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 + @@ -115,5 +164,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..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,31 +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 + ")"; - } } diff --git a/src/main/java/me/trouper/Main.java b/src/main/java/me/trouper/Main.java index efa2928..76f700d 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,7 +47,6 @@ public class Main { boolean doCopy = false; String mode = "N"; - for (String arg : args) { switch (arg) { case "--copy", "-c" -> doCopy = true; @@ -58,6 +60,14 @@ 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) { 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() { 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) { + + } +}