Commit unzipped original NetworkedTicTacToeStarter folder

Exercises/NetworkedTicTacToe/lwjgl3/build.gradle

@@ -0,0 +1,185 @@
+
+buildscript {
+  repositories {
+    gradlePluginPortal()
+  }
+  dependencies {
+    classpath "io.github.fourlastor:construo:2.1.0"
+    if(enableGraalNative == 'true') {
+      classpath "org.graalvm.buildtools.native:org.graalvm.buildtools.native.gradle.plugin:0.9.28"
+    }
+  }
+}
+plugins {
+  id "application"
+}
+apply plugin: 'io.github.fourlastor.construo'
+apply plugin: 'org.jetbrains.kotlin.jvm'
+
+
+import io.github.fourlastor.construo.Target
+
+sourceSets.main.resources.srcDirs += [ rootProject.file('assets').path ]
+application.mainClass = 'u0012604.tictactoe.lwjgl3.Lwjgl3Launcher'
+eclipse.project.name = appName + '-lwjgl3'
+java.sourceCompatibility = 8
+java.targetCompatibility = 8
+if (JavaVersion.current().isJava9Compatible()) {
+        compileJava.options.release.set(8)
+}
+kotlin.compilerOptions.jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8)
+
+dependencies {
+  implementation "com.badlogicgames.gdx:gdx-backend-lwjgl3:$gdxVersion"
+  implementation "com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-desktop"
+  implementation "com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-desktop"
+  implementation "com.badlogicgames.gdx:gdx-lwjgl3-angle:$gdxVersion"
+  implementation "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-desktop"
+  implementation project(':core')
+
+  if(enableGraalNative == 'true') {
+    implementation "io.github.berstanio:gdx-svmhelper-backend-lwjgl3:$graalHelperVersion"
+      implementation "io.github.berstanio:gdx-svmhelper-extension-freetype:$graalHelperVersion"
+
+    }
+}
+
+def os = System.properties['os.name'].toLowerCase(Locale.ROOT)
+
+run {
+  workingDir = rootProject.file('assets').path
+// You can uncomment the next line if your IDE claims a build failure even when the app closed properly.
+  //setIgnoreExitValue(true)
+
+  if (os.contains('mac')) jvmArgs += "-XstartOnFirstThread"
+}
+
+jar {
+// sets the name of the .jar file this produces to the name of the game or app, with the version after.
+  archiveFileName.set("${appName}-${projectVersion}.jar")
+// the duplicatesStrategy matters starting in Gradle 7.0; this setting works.
+  duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+  dependsOn configurations.runtimeClasspath
+  from { configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } }
+// these "exclude" lines remove some unnecessary duplicate files in the output JAR.
+  exclude('META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA')
+  dependencies {
+    exclude('META-INF/INDEX.LIST', 'META-INF/maven/**')
+  }
+// setting the manifest makes the JAR runnable.
+// enabling native access helps avoid a warning when Java 24 or later runs the JAR.
+  manifest {
+    attributes 'Main-Class': application.mainClass, 'Enable-Native-Access': 'ALL-UNNAMED'
+  }
+// this last step may help on some OSes that need extra instruction to make runnable JARs.
+  doLast {
+    file(archiveFile).setExecutable(true, false)
+  }
+}
+
+// Builds a JAR that only includes the files needed to run on macOS, not Windows or Linux.
+// The file size for a Mac-only JAR is about 7MB smaller than a cross-platform JAR.
+tasks.register("jarMac") {
+  dependsOn("jar")
+  group("build")
+  jar.archiveFileName.set("${appName}-${projectVersion}-mac.jar")
+  jar.exclude("windows/x86/**", "windows/x64/**", "linux/arm32/**", "linux/arm64/**", "linux/x64/**", "**/*.dll", "**/*.so",
+    'META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA')
+  dependencies {
+    jar.exclude("windows/x86/**", "windows/x64/**", "linux/arm32/**", "linux/arm64/**", "linux/x64/**",
+      'META-INF/INDEX.LIST', 'META-INF/maven/**')
+  }
+}
+
+// Builds a JAR that only includes the files needed to run on Linux, not Windows or macOS.
+// The file size for a Linux-only JAR is about 5MB smaller than a cross-platform JAR.
+tasks.register("jarLinux") {
+  dependsOn("jar")
+  group("build")
+  jar.archiveFileName.set("${appName}-${projectVersion}-linux.jar")
+  jar.exclude("windows/x86/**", "windows/x64/**", "macos/arm64/**", "macos/x64/**", "**/*.dll", "**/*.dylib",
+    'META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA')
+  dependencies {
+    jar.exclude("windows/x86/**", "windows/x64/**", "macos/arm64/**", "macos/x64/**",
+      'META-INF/INDEX.LIST', 'META-INF/maven/**')
+  }
+}
+
+// Builds a JAR that only includes the files needed to run on Windows, not Linux or macOS.
+// The file size for a Windows-only JAR is about 6MB smaller than a cross-platform JAR.
+tasks.register("jarWin") {
+  dependsOn("jar")
+  group("build")
+  jar.archiveFileName.set("${appName}-${projectVersion}-win.jar")
+  jar.exclude("macos/arm64/**", "macos/x64/**", "linux/arm32/**", "linux/arm64/**", "linux/x64/**", "**/*.dylib", "**/*.so",
+    'META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA')
+  dependencies {
+    jar.exclude("macos/arm64/**", "macos/x64/**", "linux/arm32/**", "linux/arm64/**", "linux/x64/**",
+      'META-INF/INDEX.LIST', 'META-INF/maven/**')
+  }
+}
+
+construo {
+    // name of the executable
+    name.set(appName)
+    // human-readable name, used for example in the `.app` name for macOS
+    humanName.set(appName)
+
+    targets.configure {
+      register("linuxX64", Target.Linux) {
+        architecture.set(Target.Architecture.X86_64)
+        jdkUrl.set("https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.15%2B6/OpenJDK17U-jdk_x64_linux_hotspot_17.0.15_6.tar.gz")
+        // Linux does not currently have a way to set the icon on the executable
+      }
+      register("macM1", Target.MacOs) {
+        architecture.set(Target.Architecture.AARCH64)
+        jdkUrl.set("https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.15%2B6/OpenJDK17U-jdk_aarch64_mac_hotspot_17.0.15_6.tar.gz")
+        // macOS needs an identifier
+        identifier.set("u0012604.tictactoe." + appName)
+        // Optional: icon for macOS, as an ICNS file
+        macIcon.set(project.file("icons/logo.icns"))
+      }
+      register("macX64", Target.MacOs) {
+        architecture.set(Target.Architecture.X86_64)
+        jdkUrl.set("https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.15%2B6/OpenJDK17U-jdk_x64_mac_hotspot_17.0.15_6.tar.gz")
+        // macOS needs an identifier
+        identifier.set("u0012604.tictactoe." + appName)
+        // Optional: icon for macOS, as an ICNS file
+        macIcon.set(project.file("icons/logo.icns"))
+      }
+      register("winX64", Target.Windows) {
+        architecture.set(Target.Architecture.X86_64)
+        // Optional: icon for Windows, as a PNG
+        icon.set(project.file("icons/logo.png"))
+        jdkUrl.set("https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.15%2B6/OpenJDK17U-jdk_x64_windows_hotspot_17.0.15_6.zip")
+        // Uncomment the next line to show a console when the game runs, to print messages.
+        //useConsole.set(true)
+      }
+    }
+}
+
+// Equivalent to the jar task; here for compatibility with gdx-setup.
+tasks.register('dist') {
+  dependsOn 'jar'
+}
+
+distributions {
+  main {
+    contents {
+      into('libs') {
+        project.configurations.runtimeClasspath.files.findAll { file ->
+          file.getName() != project.tasks.jar.outputs.files.singleFile.name
+        }.each { file ->
+          exclude file.name
+        }
+      }
+    }
+  }
+}
+
+startScripts.dependsOn(':lwjgl3:jar')
+startScripts.classpath = project.tasks.jar.outputs.files
+
+if(enableGraalNative == 'true') {
+  apply from: file("nativeimage.gradle")
+}

Exercises/NetworkedTicTacToe/lwjgl3/nativeimage.gradle

@@ -0,0 +1,54 @@
+
+project(":lwjgl3") {
+  apply plugin: "org.graalvm.buildtools.native"
+
+  graalvmNative {
+    binaries {
+      main {
+        imageName = appName
+        mainClass = application.mainClass
+        requiredVersion = '23.0'
+        buildArgs.add("-march=compatibility")
+        jvmArgs.addAll("-Dfile.encoding=UTF8")
+        sharedLibrary = false
+        resources.autodetect()
+      }
+    }
+  }
+
+  run {
+    doNotTrackState("Running the app should not be affected by Graal.")
+  }
+
+  // Modified from https://lyze.dev/2021/04/29/libGDX-Internal-Assets-List/ ; thanks again, Lyze!
+  // This creates a resource-config.json file based on the contents of the assets folder (and the libGDX icons).
+  // This file is used by Graal Native to embed those specific files.
+  // This has to run before nativeCompile, so it runs at the start of an unrelated resource-handling command.
+  generateResourcesConfigFile.doFirst {
+    def assetsFolder = new File("${project.rootDir}/assets/")
+    def lwjgl3 = project(':lwjgl3')
+    def resFolder = new File("${lwjgl3.projectDir}/src/main/resources/META-INF/native-image/${lwjgl3.ext.appName}")
+    resFolder.mkdirs()
+    def resFile = new File(resFolder, "resource-config.json")
+    resFile.delete()
+    resFile.append(
+            """{
+  "resources":{
+  "includes":[
+    {
+      "pattern": ".*(""")
+    // This adds every filename in the assets/ folder to a pattern that adds those files as resources.
+    fileTree(assetsFolder).each {
+      // The backslash-Q and backslash-E escape the start and end of a literal string, respectively.
+      resFile.append("\\\\Q${it.name}\\\\E|")
+    }
+    // We also match all of the window icon images this way and the font files that are part of libGDX.
+    resFile.append(
+            """libgdx.+\\\\.png|lsans.+)"
+    }
+  ]},
+  "bundles":[]
+}"""
+    )
+  }
+}

Exercises/NetworkedTicTacToe/lwjgl3/src/main/kotlin/u0012604/tictactoe/lwjgl3/Lwjgl3Launcher.kt

@@ -0,0 +1,40 @@
+@file:JvmName("Lwjgl3Launcher")
+
+package u0012604.tictactoe.lwjgl3
+
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration
+import u0012604.tictactoe.Main
+
+/** Launches the desktop (LWJGL3) application. */
+fun main() {
+    // This handles macOS support and helps on Windows.
+    if (StartupHelper.startNewJvmIfRequired())
+      return
+    Lwjgl3Application(Main(), Lwjgl3ApplicationConfiguration().apply {
+        setTitle("NetworkedTicTacToe")
+        //// 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.
+        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.
+        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.
+
+
+        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/ .
+        setWindowIcon(*(arrayOf(128, 64, 32, 16).map { "libgdx$it.png" }.toTypedArray()))
+
+        //// 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).
+        setOpenGLEmulation(Lwjgl3ApplicationConfiguration.GLEmulation.ANGLE_GLES20, 0, 0)
+
+    })
+}

Exercises/NetworkedTicTacToe/lwjgl3/src/main/kotlin/u0012604/tictactoe/lwjgl3/StartupHelper.kt

@@ -0,0 +1,174 @@
+
+/*
+ * 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 u0012604.tictactoe.lwjgl3
+
+import com.badlogic.gdx.Version
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3NativesLoader
+import org.lwjgl.system.JNI
+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.*
+
+/**
+ * Adds some utilities to ensure that the JVM was started with the
+ * `-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.
+ *
+ * [Based on this java-gaming.org post by kappa](https://jvm-gaming.org/t/starting-jvm-on-mac-with-xstartonfirstthread-programmatically/57547)
+ * @author damios
+ */
+class StartupHelper private constructor() {
+    init {
+        throw UnsupportedOperationException()
+    }
+
+    companion object {
+        private const val JVM_RESTARTED_ARG = "jvmIsRestarted"
+        /**
+         * Starts a new JVM if the application was started on macOS without the
+         * `-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.
+         *
+         * **Usage:**
+         *
+         * ```
+         * fun main() {
+         *   if (StartupHelper.startNewJvmIfRequired(true)) return // This handles macOS support and helps on Windows.
+         *   // after this is the actual main method code
+         * }
+         * ```
+         *
+         * @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
+         */
+        @JvmOverloads
+        fun startNewJvmIfRequired(redirectOutput: Boolean = true): Boolean {
+            val osName = System.getProperty("os.name").lowercase(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.
+                  val programData = System.getenv("ProgramData") ?: "C:\\Temp\\"
+                  val prevTmpDir = System.getProperty("java.io.tmpdir", programData)
+                  val 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", "").isNotEmpty()) {
+                return false
+            }
+
+            // Checks if we are already on the main thread, such as from running via Construo.
+            val objcMsgSend = ObjCRuntime.getLibrary().getFunctionAddress("objc_msgSend")
+            val nsThread = ObjCRuntime.objc_getClass("NSThread")
+            val currentThread = JNI.invokePPP(nsThread, ObjCRuntime.sel_getUid("currentThread"), objcMsgSend)
+            val isMainThread = JNI.invokePPZ(currentThread, ObjCRuntime.sel_getUid("isMainThread"), objcMsgSend)
+            if (isMainThread) return false
+
+            val pid = LibC.getpid()
+
+            // check whether -XstartOnFirstThread is enabled
+            if ("1" == 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" == 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
+            val jvmArgs = ArrayList<String?>()
+            val separator = System.getProperty("file.separator", "/")
+            // The following line is used assuming you target Java 8, the minimum for LWJGL3.
+            val 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 (!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().inputArguments)
+            jvmArgs.add("-cp")
+            jvmArgs.add(System.getProperty("java.class.path"))
+            var mainClass = System.getenv("JAVA_MAIN_CLASS_$pid")
+            if (mainClass == null) {
+                val trace = Thread.currentThread().stackTrace
+                mainClass = if (trace.isNotEmpty()) {
+                    trace[trace.size - 1].className
+                } else {
+                    System.err.println("The main class could not be determined.")
+                    return false
+                }
+            }
+            jvmArgs.add(mainClass)
+            try {
+                if (!redirectOutput) {
+                    val processBuilder = ProcessBuilder(jvmArgs)
+                    processBuilder.start()
+                } else {
+                    val process = ProcessBuilder(jvmArgs)
+                        .redirectErrorStream(true).start()
+                    val processOutput = BufferedReader(
+                        InputStreamReader(process.inputStream)
+                    )
+                    var line: String?
+                    while (processOutput.readLine().also { line = it } != null) {
+                        println(line)
+                    }
+                    process.waitFor()
+                }
+            } catch (e: Exception) {
+                System.err.println("There was a problem restarting the JVM")
+                e.printStackTrace()
+            }
+            return true
+        }
+    }
+}