Закончил 2-е упражнение 4-й главы

8 files changed, 560 insertions, 0 deletions

diff --git a/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Location.java b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Location.java
new file mode 100644
index 0000000..b2f5a46
--- /dev/null
+++ b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Location.java
@@ -0,0 +1,8 @@
+package net.caraus.labyrinth;
+
+public record Location(boolean leftWall, boolean upWall) {
+    @Override
+    public String toString() {
+        return String.format("(%s, %s)", leftWall, upWall);
+    }
+}
diff --git a/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Main.java b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Main.java
new file mode 100644
index 0000000..0bf0e71
--- /dev/null
+++ b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Main.java
@@ -0,0 +1,63 @@
+package net.caraus.labyrinth;
+
+import com.badlogic.gdx.ApplicationAdapter;
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+import com.badlogic.gdx.graphics.Color;
+import static com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
+import com.badlogic.gdx.utils.ScreenUtils;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+
+/** {@link com.badlogic.gdx.ApplicationListener} implementation shared by all platforms. */
+public class Main extends ApplicationAdapter {
+    private ShapeRenderer shape;
+    private Maze maze;
+    private WaveTracing solver;
+    private float elapsedTime;
+
+    @Override
+    public void create() {
+        shape = new ShapeRenderer();
+
+        FileHandle file = Gdx.files.internal("sample.txt");
+
+        try {
+            this.maze = new Maze(file.reader("utf-8"));
+        } catch (IOException e) {
+        }
+        this.elapsedTime = 0.0f;
+        this.solver = new WaveTracing(this.maze, new Point(0, 0), new Point(this.maze.width() - 1, 0));
+    }
+
+    @Override
+    public void render() {
+        ScreenUtils.clear(0.15f, 0.15f, 0.2f, 1f);
+
+        this.shape.begin(ShapeType.Line);
+
+        this.shape.setColor(Color.RED);
+        this.maze.draw(this.shape);
+
+        this.shape.setColor(Color.GREEN);
+
+        this.elapsedTime += Gdx.graphics.getDeltaTime();
+        if (this.elapsedTime > 1.0f) {
+            if (this.solver.solve() != Solution.CONTINUE) {
+                this.elapsedTime = Float.NEGATIVE_INFINITY;
+            } else {
+                this.elapsedTime -= 1.0f;
+            }
+        }
+        this.solver.draw(this.shape);
+
+        this.shape.end();
+    }
+
+    @Override
+    public void dispose() {
+        this.shape.dispose();
+    }
+}
diff --git a/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Maze.java b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Maze.java
new file mode 100644
index 0000000..eaeb72b
--- /dev/null
+++ b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Maze.java
@@ -0,0 +1,84 @@
+package net.caraus.labyrinth;
+
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+import com.badlogic.gdx.math.Vector2;
+
+import java.io.BufferedReader;
+import java.io.Reader;
+import java.io.IOException;
+
+public final class Maze {
+    private Location[][] maze;
+
+    public static final int[] DX = {1, 0, -1, 0};
+    public static final int[] DY = {0, -1, 0, 1};
+    public static final float CELL_SIZE = 75.0f;
+
+    public Maze(Reader inputReader) throws IOException {
+        BufferedReader reader = new BufferedReader(inputReader);
+
+        String[] inputPair = reader.readLine().split(" ");
+        var width = Integer.parseInt(inputPair[0]);
+        var height = Integer.parseInt(inputPair[1]);
+
+        this.maze = new Location[width + 1][height + 1];
+
+        for (var y = 0; y <= height; ++y) {
+            for (var x = 0; x <= width; ++x) {
+                if (y == height || x == width) {
+                    this.maze[x][y] = new Location(true, true);
+                } else {
+                    inputPair = reader.readLine().split(" ");
+                    this.maze[x][y] = new Location(inputPair[1].equals("1"), inputPair[0].equals("1"));
+                }
+            }
+        }
+    }
+
+    public int width() {
+        return this.maze == null ? 0 : this.maze.length - 1;
+    }
+
+    public int height() {
+        return this.maze == null ? 0 : this.maze[0].length - 1;
+    }
+
+    public void draw(ShapeRenderer shape) {
+        for (var x = 0; x < width(); ++x) {
+            for (var y = 0; y < height(); ++y) {
+                var start = new Vector2((x + 1) * CELL_SIZE, (height() - y + 1) * CELL_SIZE);
+
+                if (this.maze[x][y].upWall()) {
+                    var end = new Vector2(start).add(CELL_SIZE, 0);
+
+                    shape.line(start, end);
+                }
+                if (this.maze[x][y].leftWall()) {
+                    var end = new Vector2(start).sub(0, CELL_SIZE);
+
+                    shape.line(start, end);
+                }
+            }
+        }
+        // Рисуем нижнюю и правую стены.
+        var edge = new Vector2(CELL_SIZE * (width() + 1), CELL_SIZE);
+        shape.line(new Vector2(CELL_SIZE, CELL_SIZE), edge);
+        shape.line(new Vector2(edge).add(0, height() * CELL_SIZE), edge);
+    }
+
+    public boolean canGo(Point xy, int deltaIndex) {
+        if (DX[deltaIndex] == -1) {
+            return !this.maze[xy.x()][xy.y()].leftWall();
+        } else if (DX[deltaIndex] == 1) {
+            return !this.maze[xy.x() + 1][xy.y()].leftWall();
+        } else if (DY[deltaIndex] == -1) {
+            return !this.maze[xy.x()][xy.y()].upWall();
+        } else {
+            return !this.maze[xy.x()][xy.y() + 1].upWall();
+        }
+    }
+
+    public Location at(Point xy) {
+        return this.maze[xy.x()][xy.y()];
+    }
+}
diff --git a/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Point.java b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Point.java
new file mode 100644
index 0000000..6f70d4c
--- /dev/null
+++ b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Point.java
@@ -0,0 +1,4 @@
+package net.caraus.labyrinth;
+
+public record Point(int x, int y) {
+}
diff --git a/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Solution.java b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Solution.java
new file mode 100644
index 0000000..642c87e
--- /dev/null
+++ b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/Solution.java
@@ -0,0 +1,7 @@
+package net.caraus.labyrinth;
+
+public enum Solution {
+    CONTINUE,
+    DONE,
+    NO_SOLUTION
+}
diff --git a/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/WaveTracing.java b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/WaveTracing.java
new file mode 100644
index 0000000..ba6a649
--- /dev/null
+++ b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/WaveTracing.java
@@ -0,0 +1,145 @@
+package net.caraus.labyrinth;
+
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+import java.util.ArrayList;
+import java.util.HashSet;
+
+public class WaveTracing {
+    private Maze maze;
+    private Point start;
+    private Point finish;
+    private int[][] mark;
+    private int n = 1;
+
+    private ArrayList<Point> startLocations = new ArrayList<>();
+    private ArrayList<Point> finishLocations = new ArrayList<>();
+    private Point solution = null;
+
+    public WaveTracing(Maze maze, Point start, Point finish) {
+        this.maze = maze;
+        this.start = start;
+        this.finish = finish;
+
+        initializeMarks();
+    }
+
+    private void initializeMarks() {
+        this.mark = new int[this.maze.width()][this.maze.height()]; // Метки локаций.
+
+        for (var column: mark) {
+            for (var y = 0; y < column.length; ++y) {
+                column[y] = 0;
+            }
+        }
+        mark[this.start.x()][this.start.y()] = 1;
+        mark[this.finish.x()][this.finish.y()] = 1;
+
+        this.startLocations.add(this.start);
+        this.finishLocations.add(this.finish);
+    }
+
+    private ArrayList<Point> solveOneSide(ArrayList<Point> locations) {
+        // Локации со следующим N.
+        ArrayList<Point> nextLocations = new ArrayList<>();
+
+        // Посетить локации, помеченные числом N.
+        for (var nLocation: locations) {
+            // Просмотр соседей.
+            for (var i = 0; i < 4; ++i) {
+                var neighbour = new Point(nLocation.x() + Maze.DX[i], nLocation.y() + Maze.DY[i]);
+
+                if (maze.canGo(nLocation, i) && this.mark[neighbour.x()][neighbour.y()] == 0) {
+                    // Локация доступна и помечена нулем.
+                    // Есть шанс найти решения.
+                    nextLocations.add(neighbour);
+                }
+            }
+        }
+        return nextLocations;
+    }
+
+    private Point startAndFinishIntersect() {
+        HashSet<Point> nextLocations = new HashSet<>(this.startLocations);
+        nextLocations.retainAll(this.finishLocations);
+
+        return nextLocations.stream().findFirst().orElse(null);
+    }
+
+    public Solution solve() {
+        // Пессимично полагаем, что решения нет.
+        var noSolution = true;
+        Point intersection;
+
+        if (this.solution != null) {
+            return Solution.DONE;
+        }
+        this.startLocations = solveOneSide(this.startLocations);
+        if ((intersection = startAndFinishIntersect()) != null) {
+            this.solution = intersection;
+        }
+        this.finishLocations = solveOneSide(this.finishLocations);
+        if ((intersection = startAndFinishIntersect()) != null) {
+            this.solution = intersection;
+        }
+        HashSet<Point> nextLocations = new HashSet<>(this.startLocations);
+        nextLocations.addAll(this.finishLocations);
+
+        for (var nLocation: nextLocations) {
+            this.mark[nLocation.x()][nLocation.y()] = this.n + 1;
+        }
+        if (!nextLocations.isEmpty()) {
+            noSolution = false;
+            this.n += 1;
+        }
+        if (this.solution != null) {
+            return Solution.DONE;
+        } else if (noSolution) {
+            return Solution.NO_SOLUTION;
+        } else {
+            return Solution.CONTINUE;
+        }
+    }
+
+    private void drawProgress(ShapeRenderer shape) {
+        final float markSize = 20.0f;
+        final float halfMark = Maze.CELL_SIZE / 2 - markSize / 2;
+
+        for (var x = 0; x < this.maze.width(); ++x) {
+            for (var y = 0; y < this.maze.height(); ++y) {
+                if (this.mark[x][y] == this.n) {
+                    shape.rect((x + 1) * Maze.CELL_SIZE + halfMark,
+                            (this.maze.height() - y) * Maze.CELL_SIZE + halfMark,
+                            markSize, markSize);
+                }
+            }
+        }
+    }
+
+    private void drawResult(ShapeRenderer shape, Point nLocation) {
+        final float markSize = 20.0f;
+        final float halfMark = Maze.CELL_SIZE / 2 - markSize / 2;
+
+        shape.ellipse((nLocation.x() + 1) * Maze.CELL_SIZE + halfMark,
+                (this.maze.height() - nLocation.y()) * Maze.CELL_SIZE + halfMark,
+                markSize, markSize);
+        var currentN = this.mark[nLocation.x()][nLocation.y()] - 1;
+        if (currentN == 0) {
+            return;
+        }
+        for (var i = 0; i < 4; ++i) {
+            var neighbour = new Point(nLocation.x() + Maze.DX[i], nLocation.y() + Maze.DY[i]);
+
+            if (maze.canGo(nLocation, i) && this.mark[neighbour.x()][neighbour.y()] == currentN) {
+                drawResult(shape, neighbour);
+            }
+        }
+    }
+
+    public void draw(ShapeRenderer shape) {
+        if (this.solution == null) {
+            drawProgress(shape);
+        } else {
+            drawResult(shape, this.solution);
+        }
+    }
+}
diff --git a/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/lwjgl3/Lwjgl3Launcher.java b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/lwjgl3/Lwjgl3Launcher.java
new file mode 100644
index 0000000..d17ac8a
--- /dev/null
+++ b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/lwjgl3/Lwjgl3Launcher.java
@@ -0,0 +1,45 @@
+package net.caraus.labyrinth.lwjgl3;
+
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application;
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration;
+import net.caraus.labyrinth.Main;
+
+/** Launches the desktop (LWJGL3) application. */
+public class Lwjgl3Launcher {
+    public static void main(String[] args) {
+        if (StartupHelper.startNewJvmIfRequired()) return; // This handles macOS support and helps on Windows.
+        createApplication();
+    }
+
+    private static Lwjgl3Application createApplication() {
+        return new Lwjgl3Application(new Main(), getDefaultConfiguration());
+    }
+
+    private static Lwjgl3ApplicationConfiguration getDefaultConfiguration() {
+        Lwjgl3ApplicationConfiguration configuration = new Lwjgl3ApplicationConfiguration();
+        configuration.setTitle("Labyrinth");
+        //// Vsync limits the frames per second to what your hardware can display, and helps eliminate
+        //// screen tearing. This setting doesn't always work on Linux, so the line after is a safeguard.
+        configuration.useVsync(true);
+        //// Limits FPS to the refresh rate of the currently active monitor, plus 1 to try to match fractional
+        //// refresh rates. The Vsync setting above should limit the actual FPS to match the monitor.
+        configuration.setForegroundFPS(Lwjgl3ApplicationConfiguration.getDisplayMode().refreshRate + 1);
+        //// If you remove the above line and set Vsync to false, you can get unlimited FPS, which can be
+        //// useful for testing performance, but can also be very stressful to some hardware.
+        //// You may also need to configure GPU drivers to fully disable Vsync; this can cause screen tearing.
+
+        configuration.setWindowedMode(640, 480);
+        //// You can change these files; they are in lwjgl3/src/main/resources/ .
+        //// They can also be loaded from the root of assets/ .
+        configuration.setWindowIcon("libgdx128.png", "libgdx64.png", "libgdx32.png", "libgdx16.png");
+
+        //// This should improve compatibility with Windows machines with buggy OpenGL drivers, Macs
+        //// with Apple Silicon that have to emulate compatibility with OpenGL anyway, and more.
+        //// This uses the dependency `com.badlogicgames.gdx:gdx-lwjgl3-angle` to function.
+        //// You can choose to remove the following line and the mentioned dependency if you want; they
+        //// are not intended for games that use GL30 (which is compatibility with OpenGL ES 3.0).
+        configuration.setOpenGLEmulation(Lwjgl3ApplicationConfiguration.GLEmulation.ANGLE_GLES20, 0, 0);
+
+        return configuration;
+    }
+}
diff --git a/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/lwjgl3/StartupHelper.java b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/lwjgl3/StartupHelper.java
new file mode 100644
index 0000000..b62cf6f
--- /dev/null
+++ b/Занимательное программирование/4/2_wave/src/main/java/net/caraus/labyrinth/lwjgl3/StartupHelper.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2020 damios
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+//Note, the above license and copyright applies to this file only.
+
+package net.caraus.labyrinth.lwjgl3;
+
+import com.badlogic.gdx.Version;
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3NativesLoader;
+import org.lwjgl.system.macosx.LibC;
+import org.lwjgl.system.macosx.ObjCRuntime;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStreamReader;
+import java.lang.management.ManagementFactory;
+import java.util.ArrayList;
+
+import static org.lwjgl.system.JNI.invokePPP;
+import static org.lwjgl.system.JNI.invokePPZ;
+import static org.lwjgl.system.macosx.ObjCRuntime.objc_getClass;
+import static org.lwjgl.system.macosx.ObjCRuntime.sel_getUid;
+
+/**
+ * Adds some utilities to ensure that the JVM was started with the
+ * {@code -XstartOnFirstThread} argument, which is required on macOS for LWJGL 3
+ * to function. Also helps on Windows when users have names with characters from
+ * outside the Latin alphabet, a common cause of startup crashes.
+ * <br>
+ * <a href="https://jvm-gaming.org/t/starting-jvm-on-mac-with-xstartonfirstthread-programmatically/57547">Based on this java-gaming.org post by kappa</a>
+ * @author damios
+ */
+public class StartupHelper {
+
+    private static final String JVM_RESTARTED_ARG = "jvmIsRestarted";
+
+    private StartupHelper() {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Starts a new JVM if the application was started on macOS without the
+     * {@code -XstartOnFirstThread} argument. This also includes some code for
+     * Windows, for the case where the user's home directory includes certain
+     * non-Latin-alphabet characters (without this code, most LWJGL3 apps fail
+     * immediately for those users). Returns whether a new JVM was started and
+     * thus no code should be executed.
+     * <p>
+     * <u>Usage:</u>
+     *
+     * <pre><code>
+     * public static void main(String... args) {
+     * 	if (StartupHelper.startNewJvmIfRequired(true)) return; // This handles macOS support and helps on Windows.
+     * 	// after this is the actual main method code
+     * }
+     * </code></pre>
+     *
+     * @param redirectOutput
+     *            whether the output of the new JVM should be rerouted to the
+     *            old JVM, so it can be accessed in the same place; keeps the
+     *            old JVM running if enabled
+     * @return whether a new JVM was started and thus no code should be executed
+     *         in this one
+     */
+    public static boolean startNewJvmIfRequired(boolean redirectOutput) {
+        String osName = System.getProperty("os.name").toLowerCase(java.util.Locale.ROOT);
+        if (!osName.contains("mac")) {
+            if (osName.contains("windows")) {
+// Here, we are trying to work around an issue with how LWJGL3 loads its extracted .dll files.
+// By default, LWJGL3 extracts to the directory specified by "java.io.tmpdir", which is usually the user's home.
+// If the user's name has non-ASCII (or some non-alphanumeric) characters in it, that would fail.
+// By extracting to the relevant "ProgramData" folder, which is usually "C:\ProgramData", we avoid this.
+// We also temporarily change the "user.name" property to one without any chars that would be invalid.
+// We revert our changes immediately after loading LWJGL3 natives.
+                String programData = System.getenv("ProgramData");
+                if(programData == null) programData = "C:\\Temp\\"; // if ProgramData isn't set, try some fallback.
+                String prevTmpDir = System.getProperty("java.io.tmpdir", programData);
+                String prevUser = System.getProperty("user.name", "libGDX_User");
+                System.setProperty("java.io.tmpdir", programData + "/libGDX-temp");
+                System.setProperty("user.name", ("User_" + prevUser.hashCode() + "_GDX" + Version.VERSION).replace('.', '_'));
+                Lwjgl3NativesLoader.load();
+                System.setProperty("java.io.tmpdir", prevTmpDir);
+                System.setProperty("user.name", prevUser);
+            }
+            return false;
+        }
+
+        // There is no need for -XstartOnFirstThread on Graal native image
+        if (!System.getProperty("org.graalvm.nativeimage.imagecode", "").isEmpty()) {
+            return false;
+        }
+
+        // Checks if we are already on the main thread, such as from running via Construo.
+        long objc_msgSend = ObjCRuntime.getLibrary().getFunctionAddress("objc_msgSend");
+        long NSThread      = objc_getClass("NSThread");
+        long currentThread = invokePPP(NSThread, sel_getUid("currentThread"), objc_msgSend);
+        boolean isMainThread = invokePPZ(currentThread, sel_getUid("isMainThread"), objc_msgSend);
+        if(isMainThread) return false;
+
+        long pid = LibC.getpid();
+
+        // check whether -XstartOnFirstThread is enabled
+        if ("1".equals(System.getenv("JAVA_STARTED_ON_FIRST_THREAD_" + pid))) {
+            return false;
+        }
+
+        // check whether the JVM was previously restarted
+        // avoids looping, but most certainly leads to a crash
+        if ("true".equals(System.getProperty(JVM_RESTARTED_ARG))) {
+            System.err.println(
+                    "There was a problem evaluating whether the JVM was started with the -XstartOnFirstThread argument.");
+            return false;
+        }
+
+        // Restart the JVM with -XstartOnFirstThread
+        ArrayList<String> jvmArgs = new ArrayList<>();
+        String separator = System.getProperty("file.separator", "/");
+        // The following line is used assuming you target Java 8, the minimum for LWJGL3.
+        String javaExecPath = System.getProperty("java.home") + separator + "bin" + separator + "java";
+        // If targeting Java 9 or higher, you could use the following instead of the above line:
+        //String javaExecPath = ProcessHandle.current().info().command().orElseThrow();
+
+        if (!(new File(javaExecPath)).exists()) {
+            System.err.println(
+                    "A Java installation could not be found. If you are distributing this app with a bundled JRE, be sure to set the -XstartOnFirstThread argument manually!");
+            return false;
+        }
+
+        jvmArgs.add(javaExecPath);
+        jvmArgs.add("-XstartOnFirstThread");
+        jvmArgs.add("-D" + JVM_RESTARTED_ARG + "=true");
+        jvmArgs.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
+        jvmArgs.add("-cp");
+        jvmArgs.add(System.getProperty("java.class.path"));
+        String mainClass = System.getenv("JAVA_MAIN_CLASS_" + pid);
+        if (mainClass == null) {
+            StackTraceElement[] trace = Thread.currentThread().getStackTrace();
+            if (trace.length > 0) {
+                mainClass = trace[trace.length - 1].getClassName();
+            } else {
+                System.err.println("The main class could not be determined.");
+                return false;
+            }
+        }
+        jvmArgs.add(mainClass);
+
+        try {
+            if (!redirectOutput) {
+                ProcessBuilder processBuilder = new ProcessBuilder(jvmArgs);
+                processBuilder.start();
+            } else {
+                Process process = (new ProcessBuilder(jvmArgs))
+                        .redirectErrorStream(true).start();
+                BufferedReader processOutput = new BufferedReader(
+                        new InputStreamReader(process.getInputStream()));
+                String line;
+
+                while ((line = processOutput.readLine()) != null) {
+                    System.out.println(line);
+                }
+
+                process.waitFor();
+            }
+        } catch (Exception e) {
+            System.err.println("There was a problem restarting the JVM");
+            e.printStackTrace();
+        }
+
+        return true;
+    }
+
+    /**
+     * Starts a new JVM if the application was started on macOS without the
+     * {@code -XstartOnFirstThread} argument. Returns whether a new JVM was
+     * started and thus no code should be executed. Redirects the output of the
+     * new JVM to the old one.
+     * <p>
+     * <u>Usage:</u>
+     *
+     * <pre>
+     * public static void main(String... args) {
+     * 	if (StartupHelper.startNewJvmIfRequired()) return; // This handles macOS support and helps on Windows.
+     * 	// the actual main method code
+     * }
+     * </pre>
+     *
+     * @return whether a new JVM was started and thus no code should be executed
+     *         in this one
+     */
+    public static boolean startNewJvmIfRequired() {
+        return startNewJvmIfRequired(true);
+    }
+}