From a16cc76551279748898d7f8d0536f2538a80861f Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:02:12 -0500
Subject: [PATCH 01/14] Update Version to v0.3.0

---
 build.gradle.kts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index 82cd1e0..695880a 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -9,10 +9,11 @@ plugins {
     signing
 }
 
+val v = "0.3.0"
 val jvm = JavaVersion.VERSION_11
 
 group = "xyz.calcugames"
-version = "0.2.2-SNAPSHOT"
+version = if (project.hasProperty("snapshot")) "$v-SNAPSHOT" else v
 
 java {
     sourceCompatibility = jvm

From f81ffd7110aced95982b104858f81a5c4c107eee Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:02:22 -0500
Subject: [PATCH 02/14] Remove Unnecessary `clean` Task

---
 .github/workflows/build.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 86cb7ad..91498fe 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -53,7 +53,7 @@ jobs:
       - name: Change Permissions
         run: chmod +x ./gradlew
       - name: Build with Gradle
-        run: ./gradlew clean assemble publishToMavenLocal
+        run: ./gradlew assemble publishToMavenLocal
 
   test:
     runs-on: ubuntu-latest
@@ -74,7 +74,7 @@ jobs:
       - name: Change Permissions
         run: chmod +x ./gradlew
       - name: Gradle Test
-        run: ./gradlew clean test
+        run: ./gradlew test
 
   deploy:
     runs-on: ubuntu-latest
@@ -94,7 +94,7 @@ jobs:
       - name: Change Permissions
         run: chmod +x ./gradlew
       - name: Build JavaDocs
-        run: ./gradlew clean javadoc
+        run: ./gradlew javadoc
       - name: Deploy JavaDoc
         run: bash javadoc.sh ${GITHUB_SHA::7}
   
@@ -119,4 +119,4 @@ jobs:
         env:
           NEXUS_USERNAME: ${{ secrets.NEXUS_USERNAME }}
           NEXUS_PASSWORD: ${{ secrets.NEXUS_PASSWORD }}
-        run: ./gradlew clean build publish -x test
+        run: ./gradlew publish -Psnapshot=true

From 124299d41d190933cd37b05aff2fe518cd45d623 Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:02:29 -0500
Subject: [PATCH 03/14] Add Release Publishing

---
 .github/workflows/release.yml | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 .github/workflows/release.yml

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..4f68a4e
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,29 @@
+name: Release Project
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    name: Publish to Repository
+    timeout-minutes: 30
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: 'recursive'
+      - name: Set up JDK 111
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '11'
+          cache: 'gradle'
+      - name: Change Permissions
+        run: chmod +x ./gradlew
+      - name: Publish to Repository
+        env:
+          NEXUS_USERNAME: ${{ secrets.NEXUS_USERNAME }}
+          NEXUS_PASSWORD: ${{ secrets.NEXUS_PASSWORD }}
+        run: ./gradlew publish
\ No newline at end of file

From c1b56daed5a735c0d1ea55214f9290587b70339b Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:19:16 -0500
Subject: [PATCH 04/14] Add Matrix Classes

---
 .../levelz/coord/CoordinateMatrix.java        |  69 +++++++++++
 .../levelz/coord/CoordinateMatrix2D.java      | 102 ++++++++++++++++
 .../levelz/coord/CoordinateMatrix3D.java      | 110 ++++++++++++++++++
 3 files changed, 281 insertions(+)
 create mode 100644 src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix.java
 create mode 100644 src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix2D.java
 create mode 100644 src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix3D.java

diff --git a/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix.java b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix.java
new file mode 100644
index 0000000..f02080b
--- /dev/null
+++ b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix.java
@@ -0,0 +1,69 @@
+package xyz.calcugames.levelz.coord;
+
+import org.jetbrains.annotations.NotNull;
+import xyz.calcugames.levelz.Dimension;
+
+import java.util.Iterator;
+import java.util.Set;
+
+/**
+ * Represents a matrix of coordinates.
+ */
+@SuppressWarnings("unchecked")
+public abstract class CoordinateMatrix implements Iterable<Coordinate> {
+
+    /**
+     * Gets the dimension of the matrix.
+     * @return The dimension of the matrix.
+     */
+    @NotNull
+    public abstract Dimension getDimension();
+
+    /**
+     * Gets the coordinates in the matrix.
+     * @return The coordinates in the matrix.
+     */
+    @NotNull
+    public abstract Set<? extends Coordinate> getCoordinates();
+
+    /**
+     * Gets the starting coordinate of the matrix.
+     * @return The starting coordinate of the matrix.
+     */
+    @NotNull
+    public abstract Coordinate getStart();
+
+    /**
+     * Gets the string version of this coordinate matrix.
+     * @return This Coordinate Matrix as a string, represented in LevelZ format.
+     */
+    @Override
+    public abstract String toString();
+
+    @NotNull
+    @Override
+    public final Iterator<Coordinate> iterator() {
+        return (Iterator<Coordinate>) getCoordinates().iterator();
+    }
+
+    @Override
+    public final boolean equals(Object other) {
+        if (this == other) return true;
+        if (other == null || getClass() != other.getClass()) return false;
+
+        CoordinateMatrix that = (CoordinateMatrix) other;
+        if (!getDimension().equals(that.getDimension())) return false;
+        if (!getCoordinates().equals(that.getCoordinates())) return false;
+
+        return getStart().equals(that.getStart());
+    }
+
+    @Override
+    public final int hashCode() {
+        int result = getDimension().hashCode();
+        result = 31 * result + getCoordinates().hashCode();
+        result = 31 * result + getStart().hashCode();
+        return result;
+    }
+
+}
diff --git a/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix2D.java b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix2D.java
new file mode 100644
index 0000000..c9550e9
--- /dev/null
+++ b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix2D.java
@@ -0,0 +1,102 @@
+package xyz.calcugames.levelz.coord;
+
+import org.jetbrains.annotations.NotNull;
+import xyz.calcugames.levelz.Dimension;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+
+/**
+ * Represents a 2D matrix of coordinates.
+ */
+public final class CoordinateMatrix2D extends CoordinateMatrix {
+
+    private final int minX;
+    private final int maxX;
+    private final int minY;
+    private final int maxY;
+    private final Coordinate2D start;
+
+    public CoordinateMatrix2D(int x, int y, @NotNull Coordinate2D start) {
+        this(0, x, 0, y, start);
+    }
+
+    /**
+     * Creates a new 2D matrix of coordinates.
+     * @param minX The minimum x value.
+     * @param maxX The maximum x value.
+     * @param minY The minimum y value.
+     * @param maxY The maximum y value.
+     * @param start The starting coordinate.
+     */
+    public CoordinateMatrix2D(int minX, int maxX, int minY, int maxY, @NotNull Coordinate2D start) {
+        if (minX > maxX) throw new IllegalArgumentException("minX must be less than or equal to maxX");
+        if (minY > maxY) throw new IllegalArgumentException("minY must be less than or equal to maxY");
+        if (start == null) throw new IllegalArgumentException("start cannot be null");
+
+        this.minX = minX;
+        this.maxX = maxX;
+        this.minY = minY;
+        this.maxY = maxY;
+        this.start = start;
+    }
+
+    @Override
+    @NotNull
+    public Dimension getDimension() {
+        return Dimension.TWO;
+    }
+
+    @Override
+    @NotNull
+    public Set<Coordinate2D> getCoordinates() {
+        Set<Coordinate2D> coordinates = new HashSet<>();
+
+        for (int x = min(minX, maxX); x <= max(minX, maxX); x++)
+            for (int y = min(minY, maxY); y <= max(minY, maxY); y++)
+                coordinates.add(new Coordinate2D(start.getX() + x, start.getY() + y));
+
+        return coordinates;
+    }
+
+    @Override
+    @NotNull
+    public Coordinate2D getStart() {
+        return start;
+    }
+
+    @Override
+    public String toString() {
+        return "(" + minX + ", " + maxX + ", " + minY + ", " + maxY + ")^[" + start.getX() + ", " + start.getY() + "]";
+    }
+
+    /**
+     * Parses a 2D matrix of coordinates from a string.
+     * @param string The string to parse.
+     * @return The parsed 2D matrix of coordinates.
+     * @throws IllegalArgumentException if the string is invalid
+     */
+    @NotNull
+    public static CoordinateMatrix2D fromString(@NotNull String string) throws IllegalArgumentException {
+        String[] split = string.split("\\^");
+
+        String[] coords = split[1].replaceAll("[\\[\\]\\s]", "").split(",");
+        String[] matrix = split[0].replaceAll("[()\\s]", "").split(",");
+
+        if (coords.length != 2) throw new IllegalArgumentException("Invalid start coordinate string");
+        if (matrix.length != 4) throw new IllegalArgumentException("Invalid matrix bounds string");
+
+        double cx = Double.parseDouble(coords[0]), cy = Double.parseDouble(coords[1]);
+
+        int x1 = Integer.parseInt(matrix[0]), x2 = Integer.parseInt(matrix[1]);
+        int y1 = Integer.parseInt(matrix[2]), y2 = Integer.parseInt(matrix[3]);
+
+        if (x1 > x2) throw new IllegalArgumentException("minX must be less than or equal to maxX");
+        if (y1 > y2) throw new IllegalArgumentException("minY must be less than or equal to maxY");
+
+        return new CoordinateMatrix2D(x1, x2, y1, y2, new Coordinate2D(cx, cy));
+    }
+}
diff --git a/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix3D.java b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix3D.java
new file mode 100644
index 0000000..bcedd60
--- /dev/null
+++ b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix3D.java
@@ -0,0 +1,110 @@
+package xyz.calcugames.levelz.coord;
+
+import org.jetbrains.annotations.NotNull;
+import xyz.calcugames.levelz.Dimension;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+
+/**
+ * Represents a 3D matrix of coordinates.
+ */
+public final class CoordinateMatrix3D extends CoordinateMatrix {
+
+    private final int minX;
+    private final int maxX;
+    private final int minY;
+    private final int maxY;
+    private final int minZ;
+    private final int maxZ;
+    private final Coordinate3D start;
+
+    public CoordinateMatrix3D(int x, int y, int z, Coordinate3D start) {
+        this(0, x, 0, y, 0, z, start);
+    }
+
+    /**
+     * Creates a new 3D matrix of coordinates.
+     * @param minX The minimum x value.
+     * @param maxX The maximum x value.
+     * @param minY The minimum y value.
+     * @param maxY The maximum y value.
+     * @param minZ The minimum z value.
+     * @param maxZ The maximum z value.
+     * @param start The starting coordinate.
+     */
+    public CoordinateMatrix3D(int minX, int maxX, int minY, int maxY, int minZ, int maxZ, Coordinate3D start) {
+        if (minX > maxX) throw new IllegalArgumentException("minX must be less than or equal to maxX");
+        if (minY > maxY) throw new IllegalArgumentException("minY must be less than or equal to maxY");
+        if (minZ > maxZ) throw new IllegalArgumentException("minZ must be less than or equal to maxZ");
+        if (start == null) throw new IllegalArgumentException("start cannot be null");
+
+        this.minX = minX;
+        this.maxX = maxX;
+        this.minY = minY;
+        this.maxY = maxY;
+        this.minZ = minZ;
+        this.maxZ = maxZ;
+        this.start = start;
+    }
+
+    @Override
+    public Dimension getDimension() {
+        return Dimension.THREE;
+    }
+
+    @Override
+    public Set<Coordinate3D> getCoordinates() {
+        Set<Coordinate3D> coordinates = new HashSet<>();
+
+        for (int x = min(minX, maxX); x <= max(minX, maxX); x++)
+            for (int y = min(minY, maxY); y <= max(minY, maxY); y++)
+                for (int z = min(minZ, maxZ); z <= max(minZ, maxZ); z++)
+                    coordinates.add(new Coordinate3D(start.getX() + x, start.getY() + y, start.getZ() + z));
+
+        return coordinates;
+    }
+
+    @Override
+    public Coordinate3D getStart() {
+        return start;
+    }
+
+    @Override
+    public String toString() {
+        return "(" + minX + ", " + maxX + ", " + minY + ", " + maxY + ", " + minZ + ", " + maxZ + ")^[" + start.getX() + ", " + start.getY() + ", " + start.getZ() + "]";
+    }
+
+    /**
+     * Parses a string into a 3D matrix of coordinates.
+     * @param string The string to parse.
+     * @return The parsed 3D matrix of coordinates.
+     * @throws IllegalArgumentException if the string is invalid
+     */
+    @NotNull
+    public static CoordinateMatrix3D fromString(@NotNull String string) throws IllegalArgumentException {
+        String[] split = string.split("\\^");
+
+        String[] coords = split[1].replaceAll("[\\[\\]\\s]", "").split(",");
+        String[] matrix = split[0].replaceAll("[()\\s]", "").split(",");
+
+        if (coords.length != 3) throw new IllegalArgumentException("Invalid start coordinate string");
+        if (matrix.length != 6) throw new IllegalArgumentException("Invalid matrix bounds string");
+
+        double cx = Double.parseDouble(coords[0]), cy = Double.parseDouble(coords[1]), cz = Double.parseDouble(coords[2]);
+
+        int x1 = Integer.parseInt(matrix[0]), x2 = Integer.parseInt(matrix[1]);
+        int y1 = Integer.parseInt(matrix[2]), y2 = Integer.parseInt(matrix[3]);
+        int z1 = Integer.parseInt(matrix[4]), z2 = Integer.parseInt(matrix[5]);
+
+        if (x1 > x2) throw new IllegalArgumentException("minX must be less than or equal to maxX");
+        if (y1 > y2) throw new IllegalArgumentException("minY must be less than or equal to maxY");
+        if (z1 > z2) throw new IllegalArgumentException("minZ must be less than or equal to maxZ");
+
+        return new CoordinateMatrix3D(x1, x2, y1, y2, z1, z2, new Coordinate3D(cx, cy, cz));
+    }
+
+}

From 712686451bf97ae9e3a0e358751a8f05afff84bb Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:19:26 -0500
Subject: [PATCH 05/14] Use Matrix Classes in Parsing

---
 .../levelz/parser/InternalParser.java         | 40 ++++---------------
 1 file changed, 8 insertions(+), 32 deletions(-)

diff --git a/src/main/java/xyz/calcugames/levelz/parser/InternalParser.java b/src/main/java/xyz/calcugames/levelz/parser/InternalParser.java
index a9f2c31..6f10814 100644
--- a/src/main/java/xyz/calcugames/levelz/parser/InternalParser.java
+++ b/src/main/java/xyz/calcugames/levelz/parser/InternalParser.java
@@ -3,6 +3,8 @@
 import xyz.calcugames.levelz.*;
 import xyz.calcugames.levelz.coord.Coordinate2D;
 import xyz.calcugames.levelz.coord.Coordinate3D;
+import xyz.calcugames.levelz.coord.CoordinateMatrix2D;
+import xyz.calcugames.levelz.coord.CoordinateMatrix3D;
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -109,21 +111,9 @@ static Set<Coordinate2D> read2DPoints(String input) {
             String s = s0.trim();
             if (s.isEmpty()) continue;
 
-            if (s.startsWith("(") && s.endsWith("]")) {
-                String[] split = s.split("\\^");
-
-                String[] coords = split[1].replaceAll("[\\[\\]\\s]", "").split(",");
-                String[] matrix = split[0].replaceAll("[()\\s]", "").split(",");
-
-                double cx = Double.parseDouble(coords[0]), cy = Double.parseDouble(coords[1]);
-
-                int x1 = Integer.parseInt(matrix[0]), x2 = Integer.parseInt(matrix[1]);
-                int y1 = Integer.parseInt(matrix[2]), y2 = Integer.parseInt(matrix[3]);
-
-                for (int x = Math.min(x1, x2); x <= Math.max(x1, x2); x++)
-                    for (int y = Math.min(y1, y2); y <= Math.max(y1, y2); y++)
-                        points.add(new Coordinate2D(cx + x, cy + y));
-            } else
+            if (s.startsWith("(") && s.endsWith("]"))
+                points.addAll(CoordinateMatrix2D.fromString(s).getCoordinates());
+            else
                 points.add(Coordinate2D.fromString(s));
         }
 
@@ -138,23 +128,9 @@ static Set<Coordinate3D> read3DPoints(String input) {
             String s = s0.trim();
             if (s.isEmpty()) continue;
 
-            if (s.startsWith("(") && s.endsWith("]")) {
-                String[] split = s.split("\\^");
-                
-                String[] coords = split[1].replaceAll("[\\[\\]\\s]", "").split(",");
-                String[] matrix = split[0].replaceAll("[()\\s]", "").split(",");
-                
-                double cx = Double.parseDouble(coords[0]), cy = Double.parseDouble(coords[1]), cz = Double.parseDouble(coords[2]);
-                
-                int x1 = Integer.parseInt(matrix[0]), x2 = Integer.parseInt(matrix[1]);
-                int y1 = Integer.parseInt(matrix[2]), y2 = Integer.parseInt(matrix[3]);
-                int z1 = Integer.parseInt(matrix[4]), z2 = Integer.parseInt(matrix[5]);
-
-                for (int x = Math.min(x1, x2); x <= Math.max(x1, x2); x++)
-                    for (int y = Math.min(y1, y2); y <= Math.max(y1, y2); y++)
-                        for (int z = Math.min(z1, z2); z <= Math.max(z1, z2); z++)
-                            points.add(new Coordinate3D(cx + x, cy + y, cz + z));
-            } else
+            if (s.startsWith("(") && s.endsWith("]"))
+                points.addAll(CoordinateMatrix3D.fromString(s).getCoordinates());
+            else
                 points.add(Coordinate3D.fromString(s));
         }
         

From 11de75c972160f97313020f6f8bd42ba647456de Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:23:18 -0500
Subject: [PATCH 06/14] Create Coordinate#getDistance

+ Create Coordinate#fromArray for doubles
---
 .../calcugames/levelz/coord/Coordinate.java   | 26 +++++++++++++++++--
 .../calcugames/levelz/coord/Coordinate2D.java |  9 +++++++
 .../calcugames/levelz/coord/Coordinate3D.java |  9 +++++++
 3 files changed, 42 insertions(+), 2 deletions(-)

diff --git a/src/main/java/xyz/calcugames/levelz/coord/Coordinate.java b/src/main/java/xyz/calcugames/levelz/coord/Coordinate.java
index c68f6fa..88a1305 100644
--- a/src/main/java/xyz/calcugames/levelz/coord/Coordinate.java
+++ b/src/main/java/xyz/calcugames/levelz/coord/Coordinate.java
@@ -14,6 +14,14 @@ public interface Coordinate extends Comparable<Coordinate> {
      */
     double getMagnitude();
 
+    /**
+     * Gets the distance between two Coordinates.
+     * @param other Other Coordinate
+     * @return Distance between Coordinates
+     * @throws IllegalArgumentException if the Coordinates are not the same dimension
+     */
+    double getDistance(@NotNull Coordinate other) throws IllegalArgumentException;
+
     /**
      * Gets the dimension of the Coordinate.
      * @return Coordinate Dimension
@@ -31,9 +39,23 @@ public interface Coordinate extends Comparable<Coordinate> {
      * @param coords Coordinate Array
      * @return A {@linkplain Coordinate2D 2D} or {@linkplain Coordinate3D 3D} Coordinate, depending on array size
      */
+    @NotNull
     static Coordinate fromArray(int[] coords) {
-        if (coords.length == 2) return new Coordinate2D(coords[0], coords[1]);
-        if (coords.length == 3) return new Coordinate3D(coords[0], coords[1], coords[2]);
+        if (coords.length == 2) return new Coordinate2D(coords);
+        if (coords.length == 3) return new Coordinate3D(coords);
+
+        throw new IllegalArgumentException("Invalid Coordinate Length");
+    }
+
+    /**
+     * Creates a Coordinate from an array of doubles.
+     * @param coords Coordinate Array
+     * @return A {@linkplain Coordinate2D 2D} or {@linkplain Coordinate3D 3D} Coordinate, depending on array size
+     */
+    @NotNull
+    static Coordinate fromArray(double[] coords) {
+        if (coords.length == 2) return new Coordinate2D(coords);
+        if (coords.length == 3) return new Coordinate3D(coords);
 
         throw new IllegalArgumentException("Invalid Coordinate Length");
     }
diff --git a/src/main/java/xyz/calcugames/levelz/coord/Coordinate2D.java b/src/main/java/xyz/calcugames/levelz/coord/Coordinate2D.java
index 46c372e..52ddd74 100644
--- a/src/main/java/xyz/calcugames/levelz/coord/Coordinate2D.java
+++ b/src/main/java/xyz/calcugames/levelz/coord/Coordinate2D.java
@@ -98,6 +98,15 @@ public void setY(double y) {
         this.y = y;
     }
 
+    @Override
+    public double getDistance(@NotNull Coordinate coordinate) {
+        if (coordinate == null) throw new IllegalArgumentException("other cannot be null");
+        if (!(coordinate instanceof Coordinate2D)) throw new IllegalArgumentException("Coordinate must be 2D");
+
+        Coordinate2D other = (Coordinate2D) coordinate;
+        return Math.sqrt(Math.pow(other.x - x, 2) + Math.pow(other.y - y, 2));
+    }
+
     @Override
     public double getMagnitude() {
         return Math.sqrt((x * x) + (y * y));
diff --git a/src/main/java/xyz/calcugames/levelz/coord/Coordinate3D.java b/src/main/java/xyz/calcugames/levelz/coord/Coordinate3D.java
index d999d45..d09cc04 100644
--- a/src/main/java/xyz/calcugames/levelz/coord/Coordinate3D.java
+++ b/src/main/java/xyz/calcugames/levelz/coord/Coordinate3D.java
@@ -104,6 +104,15 @@ public void setZ(double z) {
         this.z = z;
     }
 
+    @Override
+    public double getDistance(Coordinate coordinate) {
+        if (coordinate == null) throw new IllegalArgumentException("other cannot be null");
+        if (!(coordinate instanceof Coordinate2D)) throw new IllegalArgumentException("Coordinate must be 3D");
+
+        Coordinate3D other = (Coordinate3D) coordinate;
+        return Math.sqrt(Math.pow(other.x - x, 2) + Math.pow(other.y - y, 2) + Math.pow(other.z - z, 2));
+    }
+
     @Override
     public double getMagnitude() {
         return Math.sqrt((x * x) + (y * y) + (z * z));

From abc4db471707a30f35f993a15f867bc8ee3d7b30 Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:24:35 -0500
Subject: [PATCH 07/14] Support `float` as Coordinate Arguments

---
 .../calcugames/levelz/coord/Coordinate.java   | 13 +++++++++++
 .../calcugames/levelz/coord/Coordinate2D.java | 19 ++++++++++++++++
 .../calcugames/levelz/coord/Coordinate3D.java | 22 +++++++++++++++++++
 3 files changed, 54 insertions(+)

diff --git a/src/main/java/xyz/calcugames/levelz/coord/Coordinate.java b/src/main/java/xyz/calcugames/levelz/coord/Coordinate.java
index 88a1305..01b5276 100644
--- a/src/main/java/xyz/calcugames/levelz/coord/Coordinate.java
+++ b/src/main/java/xyz/calcugames/levelz/coord/Coordinate.java
@@ -47,6 +47,19 @@ static Coordinate fromArray(int[] coords) {
         throw new IllegalArgumentException("Invalid Coordinate Length");
     }
 
+    /**
+     * Creates a Coordinate from an array of floats.
+     * @param coords Coordinate Array
+     * @return A {@linkplain Coordinate2D 2D} or {@linkplain Coordinate3D 3D} Coordinate, depending on array size
+     */
+    @NotNull
+    static Coordinate fromArray(float[] coords) {
+        if (coords.length == 2) return new Coordinate2D(coords);
+        if (coords.length == 3) return new Coordinate3D(coords);
+
+        throw new IllegalArgumentException("Invalid Coordinate Length");
+    }
+
     /**
      * Creates a Coordinate from an array of doubles.
      * @param coords Coordinate Array
diff --git a/src/main/java/xyz/calcugames/levelz/coord/Coordinate2D.java b/src/main/java/xyz/calcugames/levelz/coord/Coordinate2D.java
index 52ddd74..a6d005e 100644
--- a/src/main/java/xyz/calcugames/levelz/coord/Coordinate2D.java
+++ b/src/main/java/xyz/calcugames/levelz/coord/Coordinate2D.java
@@ -31,6 +31,25 @@ public Coordinate2D(int[] xy) {
         this.y = xy[1];
     }
 
+    /**
+     * Constructs a 2D Coordinate.
+     * @param x X Value
+     * @param y Y Value
+     */
+    public Coordinate2D(float x, float y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    /**
+     * Constructs a 2D Coordinate.
+     * @param xy Array of X and Y Values
+     */
+    public Coordinate2D(float[] xy) {
+        this.x = xy[0];
+        this.y = xy[1];
+    }
+
     /**
      * Constructs a 2D Coordinate.
      * @param x X Value
diff --git a/src/main/java/xyz/calcugames/levelz/coord/Coordinate3D.java b/src/main/java/xyz/calcugames/levelz/coord/Coordinate3D.java
index d09cc04..b45d0f0 100644
--- a/src/main/java/xyz/calcugames/levelz/coord/Coordinate3D.java
+++ b/src/main/java/xyz/calcugames/levelz/coord/Coordinate3D.java
@@ -34,6 +34,28 @@ public Coordinate3D(int[] xyz) {
         this.z = xyz[2];
     }
 
+    /**
+     * Constructs a 3D Coordinate.
+     * @param x X Value
+     * @param y Y Value
+     * @param z Z Value
+     */
+    public Coordinate3D(float x, float y, float z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    /**
+     * Constructs a 3D Coordinate.
+     * @param xyz Array of X, Y, and Z Values
+     */
+    public Coordinate3D(float[] xyz) {
+        this.x = xyz[0];
+        this.y = xyz[1];
+        this.z = xyz[2];
+    }
+
     /**
      * Constructs a 3D Coordinate.
      * @param x X Value

From 95f8ff5457b0c6caccfd4ef07f252ab19b222076 Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:39:20 -0500
Subject: [PATCH 08/14] Expose `Block#fromString`, `LevelParser#value`

---
 .../java/xyz/calcugames/levelz/Block.java     | 32 +++++++++++++++
 .../levelz/parser/InternalParser.java         | 40 +------------------
 .../calcugames/levelz/parser/LevelParser.java | 32 +++++++++++++++
 .../java/xyz/calcugames/levelz/TestBlock.java | 27 +++++++++++++
 .../levelz/parser/TestInternalParser.java     | 20 ----------
 .../levelz/parser/TestLevelParser.java        | 14 +++++++
 6 files changed, 107 insertions(+), 58 deletions(-)
 create mode 100644 src/test/java/xyz/calcugames/levelz/TestBlock.java

diff --git a/src/main/java/xyz/calcugames/levelz/Block.java b/src/main/java/xyz/calcugames/levelz/Block.java
index f4959e2..ad770b7 100644
--- a/src/main/java/xyz/calcugames/levelz/Block.java
+++ b/src/main/java/xyz/calcugames/levelz/Block.java
@@ -1,8 +1,13 @@
 package xyz.calcugames.levelz;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.Unmodifiable;
+import xyz.calcugames.levelz.parser.Errors;
+import xyz.calcugames.levelz.parser.LevelParser;
+import xyz.calcugames.levelz.parser.ParseException;
 
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 
@@ -89,4 +94,31 @@ public String toString() {
         if (properties.isEmpty()) return name;
         return name + "<" + properties.toString().replaceAll("[{}]", "") + ">";
     }
+
+    /**
+     * Converts a string into a Block.
+     * @param string The string to convert.
+     * @return The Block, or null if the string is empty.
+     */
+    @Nullable
+    public static Block fromString(@NotNull String string) {
+        if (string.isEmpty()) return null;
+
+        String[] split = string.replaceAll("[\\s>]", "").split("<");
+        String name = split[0].trim();
+
+        if (split.length < 2) return new Block(name, Map.of());
+
+        Map<String, Object> properties = new HashMap<>();
+        String[] props = split[1].split(",");
+
+        for (String entry : props) {
+            String[] kv = entry.split("=");
+            if (kv.length < 2) throw new ParseException(String.format(Errors.INVALID_BLOCK, string));
+
+            properties.put(kv[0], LevelParser.value(kv[1]));
+        }
+
+        return new Block(name, properties);
+    }
 }
diff --git a/src/main/java/xyz/calcugames/levelz/parser/InternalParser.java b/src/main/java/xyz/calcugames/levelz/parser/InternalParser.java
index 6f10814..2711369 100644
--- a/src/main/java/xyz/calcugames/levelz/parser/InternalParser.java
+++ b/src/main/java/xyz/calcugames/levelz/parser/InternalParser.java
@@ -28,21 +28,6 @@ static String[] lines(Reader r, Logger logger) {
         return lines;
     }
 
-    static Object value(String str) {
-        if (str.equalsIgnoreCase("true")) return true;
-        if (str.equalsIgnoreCase("false")) return false;
-
-        try {
-            return Integer.parseInt(str);
-        } catch (NumberFormatException e) {
-            try {
-                return Double.parseDouble(str);
-            } catch (NumberFormatException e1) {
-                return str;
-            }
-        }
-    }
-
     static <T> T roll(Map<T, Double> map, Random seed) {
         double sum = map.values().stream().mapToDouble(Double::doubleValue).sum();
         if (sum > 1.0)
@@ -190,34 +175,13 @@ static Block readBlock(String blockLine, Random seed) {
 
             }
 
-            block = readRawBlock(roll(blockToChance, seed));
+            block = Block.fromString(roll(blockToChance, seed));
         } else
-            block = readRawBlock(blockLine);
+            block = Block.fromString(blockLine);
 
         return block;
     }
 
-    static Block readRawBlock(String input) {
-        if (input.isEmpty()) return null;
-
-        String[] split = input.replaceAll("[\\s>]", "").split("<");
-        String name = split[0].trim();
-
-        if (split.length < 2) return new Block(name, Map.of());
-
-        Map<String, Object> properties = new HashMap<>();
-        String[] props = split[1].split(",");
-
-        for (String entry : props) {
-            String[] kv = entry.split("=");
-            if (kv.length < 2) throw new ParseException(String.format(Errors.INVALID_BLOCK, input));
-
-            properties.put(kv[0], value(kv[1]));
-        }
-
-        return new Block(name, properties);
-    }
-
     static Level parse(String[] file, Random seed) {
         Level level;
 
diff --git a/src/main/java/xyz/calcugames/levelz/parser/LevelParser.java b/src/main/java/xyz/calcugames/levelz/parser/LevelParser.java
index b82c5d5..ff254fe 100644
--- a/src/main/java/xyz/calcugames/levelz/parser/LevelParser.java
+++ b/src/main/java/xyz/calcugames/levelz/parser/LevelParser.java
@@ -1,5 +1,6 @@
 package xyz.calcugames.levelz.parser;
 
+import org.jetbrains.annotations.Nullable;
 import xyz.calcugames.levelz.Level;
 import org.jetbrains.annotations.NotNull;
 
@@ -152,4 +153,35 @@ public InputStream getInputStream() {
         }
     }
 
+    // Utilities
+
+    /**
+     * <p>Converts a string to an object value.</p>
+     * <p>This will do the following:</p>
+     * <ul>
+     *     <li>Convert {@code true} and {@code false} to a boolean primitive</li>
+     *     <li>Attempt to convert integers into a integer primitive</li>
+     *     <li>Attempt to convert doubles into a double primitive</li>
+     *     <li>Otherwise, return the raw string</li>
+     * </ul>
+     * @param str String to convert
+     * @return Object value
+     */
+    @Nullable
+    public static Object value(@Nullable String str) {
+        if (str == null) return null;
+        if (str.equalsIgnoreCase("true")) return true;
+        if (str.equalsIgnoreCase("false")) return false;
+
+        try {
+            return Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            try {
+                return Double.parseDouble(str);
+            } catch (NumberFormatException e1) {
+                return str;
+            }
+        }
+    }
+
 }
diff --git a/src/test/java/xyz/calcugames/levelz/TestBlock.java b/src/test/java/xyz/calcugames/levelz/TestBlock.java
new file mode 100644
index 0000000..b4dd435
--- /dev/null
+++ b/src/test/java/xyz/calcugames/levelz/TestBlock.java
@@ -0,0 +1,27 @@
+package xyz.calcugames.levelz;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+
+public class TestBlock {
+
+    @Test
+    @DisplayName("Test Block#fromString")
+    public void testReadRawBlock() {
+        Assertions.assertEquals(new Block("test", Map.of("test", true)), Block.fromString("test<test=true>"));
+        Assertions.assertEquals(new Block("ball", Map.of("bounce", 5)), Block.fromString("ball<bounce=5>"));
+        Assertions.assertEquals(new Block("stone", Map.of("weight", 5.0)), Block.fromString("stone<weight=5.0>"));
+    }
+
+    @Test
+    @DisplayName("Test Block#toString")
+    public void testWriteRawBlock() {
+        Assertions.assertEquals("test<test=true>", new Block("test", Map.of("test", true)).toString());
+        Assertions.assertEquals("ball<bounce=5>", new Block("ball", Map.of("bounce", 5)).toString());
+        Assertions.assertEquals("stone<weight=5.0>", new Block("stone", Map.of("weight", 5.0)).toString());
+    }
+
+}
diff --git a/src/test/java/xyz/calcugames/levelz/parser/TestInternalParser.java b/src/test/java/xyz/calcugames/levelz/parser/TestInternalParser.java
index 87c31d9..964cc20 100644
--- a/src/test/java/xyz/calcugames/levelz/parser/TestInternalParser.java
+++ b/src/test/java/xyz/calcugames/levelz/parser/TestInternalParser.java
@@ -17,18 +17,6 @@ public class TestInternalParser {
 
     private static final SecureRandom seed = new SecureRandom();
 
-    @Test
-    @DisplayName("Test InternalParser#value")
-    public void testValue() {
-        Assertions.assertEquals(true, value("true"));
-        Assertions.assertEquals(false, value("false"));
-
-        Assertions.assertEquals(5, value("5"));
-        Assertions.assertEquals(5.0, value("5.0"));
-
-        Assertions.assertEquals("Hello, World!", value("Hello, World!"));
-    }
-
     @Test
     @DisplayName("Test InternalParser#read2DPoints")
     public void testRead2DPoints() {
@@ -81,14 +69,6 @@ public void testReadBlock() {
         Assertions.assertNotNull(readBlock("{cobblestone,grass<value=2,other=4>,water<value=5>,magma<temp=0.3,type=lava,wet=false>,air}", seed));
     }
 
-    @Test
-    @DisplayName("Test InternalParser#readRawBlock")
-    public void testReadRawBlock() {
-        Assertions.assertEquals(new Block("test", Map.of("test", true)), readRawBlock("test<test=true>"));
-        Assertions.assertEquals(new Block("ball", Map.of("bounce", 5)), readRawBlock("ball<bounce=5>"));
-        Assertions.assertEquals(new Block("stone", Map.of("weight", 5.0)), readRawBlock("stone<weight=5.0>"));
-    }
-
     @Test
     @DisplayName("Test InternalParser#readHeaders")
     public void testReadHeaders() {
diff --git a/src/test/java/xyz/calcugames/levelz/parser/TestLevelParser.java b/src/test/java/xyz/calcugames/levelz/parser/TestLevelParser.java
index 38053a1..59c85b4 100644
--- a/src/test/java/xyz/calcugames/levelz/parser/TestLevelParser.java
+++ b/src/test/java/xyz/calcugames/levelz/parser/TestLevelParser.java
@@ -11,10 +11,24 @@
 
 import java.io.InputStream;
 
+import static xyz.calcugames.levelz.parser.LevelParser.value;
+
 public class TestLevelParser {
 
     private static final LevelParser.Builder builder = LevelParser.builder();
 
+    @Test
+    @DisplayName("Test LevelParser#value")
+    public void testValue() {
+        Assertions.assertEquals(true, value("true"));
+        Assertions.assertEquals(false, value("false"));
+
+        Assertions.assertEquals(5, value("5"));
+        Assertions.assertEquals(5.0, value("5.0"));
+
+        Assertions.assertEquals("Hello, World!", value("Hello, World!"));
+    }
+
     @Test
     @DisplayName("Test LevelParser#parse")
     public void testParse() {

From f95e35242b9a888a217a238c125f3fe709cd18e5 Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:41:31 -0500
Subject: [PATCH 09/14] Update .gitignore

---
 .gitignore | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index ff85c1c..52ecf4f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,4 +3,5 @@
 build
 .DS_Store
 bin/
-.vscode/
\ No newline at end of file
+.vscode/
+.kotlin/
\ No newline at end of file

From df7098d3bc1ac751188afe76e8117fa7946c465b Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:43:07 -0500
Subject: [PATCH 10/14] Move `CoordinateMatrix#getDimension` as Field

---
 .../calcugames/levelz/coord/CoordinateMatrix.java   | 13 ++++++++++++-
 .../calcugames/levelz/coord/CoordinateMatrix2D.java |  8 ++------
 .../calcugames/levelz/coord/CoordinateMatrix3D.java |  7 ++-----
 3 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix.java b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix.java
index f02080b..8bb3e0e 100644
--- a/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix.java
+++ b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix.java
@@ -12,12 +12,23 @@
 @SuppressWarnings("unchecked")
 public abstract class CoordinateMatrix implements Iterable<Coordinate> {
 
+    private final Dimension dimension;
+
+    /**
+     * Creates a new Coordinate Matrix.
+     */
+    protected CoordinateMatrix(@NotNull Dimension dimension) {
+        this.dimension = dimension;
+    }
+
     /**
      * Gets the dimension of the matrix.
      * @return The dimension of the matrix.
      */
     @NotNull
-    public abstract Dimension getDimension();
+    public final Dimension getDimension() {
+        return dimension;
+    }
 
     /**
      * Gets the coordinates in the matrix.
diff --git a/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix2D.java b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix2D.java
index c9550e9..9f8d87c 100644
--- a/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix2D.java
+++ b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix2D.java
@@ -33,6 +33,8 @@ public CoordinateMatrix2D(int x, int y, @NotNull Coordinate2D start) {
      * @param start The starting coordinate.
      */
     public CoordinateMatrix2D(int minX, int maxX, int minY, int maxY, @NotNull Coordinate2D start) {
+        super(Dimension.TWO);
+
         if (minX > maxX) throw new IllegalArgumentException("minX must be less than or equal to maxX");
         if (minY > maxY) throw new IllegalArgumentException("minY must be less than or equal to maxY");
         if (start == null) throw new IllegalArgumentException("start cannot be null");
@@ -44,12 +46,6 @@ public CoordinateMatrix2D(int minX, int maxX, int minY, int maxY, @NotNull Coord
         this.start = start;
     }
 
-    @Override
-    @NotNull
-    public Dimension getDimension() {
-        return Dimension.TWO;
-    }
-
     @Override
     @NotNull
     public Set<Coordinate2D> getCoordinates() {
diff --git a/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix3D.java b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix3D.java
index bcedd60..1d3d4fe 100644
--- a/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix3D.java
+++ b/src/main/java/xyz/calcugames/levelz/coord/CoordinateMatrix3D.java
@@ -37,6 +37,8 @@ public CoordinateMatrix3D(int x, int y, int z, Coordinate3D start) {
      * @param start The starting coordinate.
      */
     public CoordinateMatrix3D(int minX, int maxX, int minY, int maxY, int minZ, int maxZ, Coordinate3D start) {
+        super(Dimension.THREE);
+
         if (minX > maxX) throw new IllegalArgumentException("minX must be less than or equal to maxX");
         if (minY > maxY) throw new IllegalArgumentException("minY must be less than or equal to maxY");
         if (minZ > maxZ) throw new IllegalArgumentException("minZ must be less than or equal to maxZ");
@@ -51,11 +53,6 @@ public CoordinateMatrix3D(int minX, int maxX, int minY, int maxY, int minZ, int
         this.start = start;
     }
 
-    @Override
-    public Dimension getDimension() {
-        return Dimension.THREE;
-    }
-
     @Override
     public Set<Coordinate3D> getCoordinates() {
         Set<Coordinate3D> coordinates = new HashSet<>();

From a5653e389ac1e2c0ab8a68d91cb568b15c60c7b7 Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:43:13 -0500
Subject: [PATCH 11/14] Create CoordinateMatrix Tests

---
 .../levelz/coord/TestCoordinateMatrix2D.java  | 21 +++++++++++++++++++
 .../levelz/coord/TestCoordinateMatrix3D.java  | 21 +++++++++++++++++++
 2 files changed, 42 insertions(+)
 create mode 100644 src/test/java/xyz/calcugames/levelz/coord/TestCoordinateMatrix2D.java
 create mode 100644 src/test/java/xyz/calcugames/levelz/coord/TestCoordinateMatrix3D.java

diff --git a/src/test/java/xyz/calcugames/levelz/coord/TestCoordinateMatrix2D.java b/src/test/java/xyz/calcugames/levelz/coord/TestCoordinateMatrix2D.java
new file mode 100644
index 0000000..3918deb
--- /dev/null
+++ b/src/test/java/xyz/calcugames/levelz/coord/TestCoordinateMatrix2D.java
@@ -0,0 +1,21 @@
+package xyz.calcugames.levelz.coord;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class TestCoordinateMatrix2D {
+
+    @Test
+    @DisplayName("Test CoordinateMatrix2D#getCoordinates")
+    public void testGetCoordinates() {
+        CoordinateMatrix2D m1 = new CoordinateMatrix2D(0, 4, 0, 4, new Coordinate2D(0, 0));
+        Assertions.assertEquals(25, m1.getCoordinates().size());
+        Assertions.assertTrue(m1.getCoordinates().contains(new Coordinate2D(0, 0)));
+
+        CoordinateMatrix2D m2 = new CoordinateMatrix2D(-4, 4, -4, 4, new Coordinate2D(1, 1));
+        Assertions.assertEquals(81, m2.getCoordinates().size());
+        Assertions.assertTrue(m2.getCoordinates().contains(new Coordinate2D(1, 1)));
+    }
+
+}
diff --git a/src/test/java/xyz/calcugames/levelz/coord/TestCoordinateMatrix3D.java b/src/test/java/xyz/calcugames/levelz/coord/TestCoordinateMatrix3D.java
new file mode 100644
index 0000000..3526064
--- /dev/null
+++ b/src/test/java/xyz/calcugames/levelz/coord/TestCoordinateMatrix3D.java
@@ -0,0 +1,21 @@
+package xyz.calcugames.levelz.coord;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class TestCoordinateMatrix3D {
+
+    @Test
+    @DisplayName("Test CoordinateMatrix3D#getCoordinates")
+    public void testGetCoordinates() {
+        CoordinateMatrix3D m1 = new CoordinateMatrix3D(0, 4, 0, 4, 0, 4, new Coordinate3D(0, 0, 0));
+        Assertions.assertEquals(125, m1.getCoordinates().size());
+        Assertions.assertTrue(m1.getCoordinates().contains(new Coordinate3D(0, 0, 0)));
+
+        CoordinateMatrix3D m2 = new CoordinateMatrix3D(-4, 4, -4, 4, -4, 4, new Coordinate3D(1, 1, 1));
+        Assertions.assertEquals(729, m2.getCoordinates().size());
+        Assertions.assertTrue(m2.getCoordinates().contains(new Coordinate3D(1, 1, 1)));
+    }
+
+}

From 56a5a8238f2096a863e005650b5ce6fe876ff0d4 Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:43:27 -0500
Subject: [PATCH 12/14] Add More Exporter Options

---
 .../xyz/calcugames/levelz/LevelExporter.java  | 89 +++++++++++++++++--
 1 file changed, 84 insertions(+), 5 deletions(-)

diff --git a/src/main/java/xyz/calcugames/levelz/LevelExporter.java b/src/main/java/xyz/calcugames/levelz/LevelExporter.java
index b3ac198..501cd17 100644
--- a/src/main/java/xyz/calcugames/levelz/LevelExporter.java
+++ b/src/main/java/xyz/calcugames/levelz/LevelExporter.java
@@ -4,6 +4,8 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Map;
@@ -77,7 +79,7 @@ public String writeToString() {
             
             for (LevelObject block : blocks)
                 if (blockMap.containsKey(block.getBlock()))
-                    blockMap.put(block.getBlock(), blockMap.get(block.getBlock()) + "*" + block.getCoordinate().toString());
+                    blockMap.put(block.getBlock(), blockMap.get(block.getBlock()) + "*" + block.getCoordinate());
                 else
                     blockMap.put(block.getBlock(), block.getCoordinate().toString());
             
@@ -89,12 +91,50 @@ public String writeToString() {
         return builder.toString();
     }
 
+    /**
+     * <p>Writes to a byte array using the default charset.</p>
+     * <p>The exporter will only write to the byte buffer if there is enough space, stopping if the length if too small.</p>
+     * @param data Byte Array to encode into
+     * @throws IllegalArgumentException if the data is null
+     */
+    public void writeToByteArray(byte[] data) throws IllegalArgumentException {
+        writeToByteArray(data, Charset.defaultCharset());
+    }
+
+    /**
+     * <p>Writes to a byte array.</p>
+     * <p>The exporter will only write to the byte buffer if there is enough space, stopping if the length if too small.</p>
+     * @param data Byte Array to encode into
+     * @param charset Charset to encode bytes with
+     * @throws IllegalArgumentException if the data or charset is null
+     */
+    public void writeToByteArray(byte[] data, @NotNull Charset charset) throws IllegalArgumentException {
+        if (data == null) throw new IllegalArgumentException("Data cannot be null");
+        if (charset == null) throw new IllegalArgumentException("Charset cannot be null");
+
+        String string = writeToString();
+        byte[] bytes = string.getBytes(charset);
+        System.arraycopy(bytes, 0, data, 0, Math.min(bytes.length, data.length));
+    }
+
+    /**
+     * Writes to a file using the default charset. This will create the file if it does not exist.
+     * @param file File
+     * @throws IllegalArgumentException if the file is null
+     */
+    public void writeToFile(@NotNull File file) throws IllegalArgumentException {
+        writeToFile(file, Charset.defaultCharset());
+    }
+
     /**
      * Writes to a file. This will create the file if it does not exist.
      * @param file File
+     * @param charset Charset to encode bytes with
+     * @throws IllegalArgumentException if the file or charset is null
      */
-    public void writeToFile(@NotNull File file) {
+    public void writeToFile(@NotNull File file, @NotNull Charset charset) throws IllegalArgumentException {
         if (file == null) throw new IllegalArgumentException("File cannot be null");
+        if (charset == null) throw new IllegalArgumentException("Charset cannot be null");
 
         if (!file.exists())
             try {
@@ -103,19 +143,58 @@ public void writeToFile(@NotNull File file) {
                 throw new RuntimeException(e);
             }
 
-        writeToPath(file.toPath());
+        writeToPath(file.toPath(), charset);
+    }
+
+    /**
+     * Writes to a file path using the default charset.
+     * @param file File Path
+     * @throws IllegalArgumentException if the path is null
+     */
+    public void writeToPath(@NotNull Path file) throws IllegalArgumentException {
+        writeToPath(file, Charset.defaultCharset());
     }
 
     /**
      * Writes to a file path.
      * @param file File Path
+     * @param charset Charset to encode bytes with
+     * @throws IllegalArgumentException if the path or charset is null
      */
-    public void writeToPath(@NotNull Path file) {
+    public void writeToPath(@NotNull Path file, @NotNull Charset charset) throws IllegalArgumentException {
         if (file == null) throw new IllegalArgumentException("Path cannot be null");
+        if (charset == null) throw new IllegalArgumentException("Charset cannot be null");
+
+        String data = writeToString();
+        try {
+            Files.write(file, data.getBytes(charset));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Writes this level to an output stream using the default charset.
+     * @param stream Output Stream
+     * @throws IllegalArgumentException if the stream is null
+     */
+    public void writeToStream(@NotNull OutputStream stream) throws IllegalArgumentException {
+        writeToStream(stream, Charset.defaultCharset());
+    }
+
+    /**
+     * Writes this level to an output stream.
+     * @param stream Output Stream
+     * @param charset Charset to encode bytes with
+     * @throws IllegalArgumentException if the stream or charset is null
+     */
+    public void writeToStream(@NotNull OutputStream stream, @NotNull Charset charset) throws IllegalArgumentException {
+        if (stream == null) throw new IllegalArgumentException("Stream cannot be null");
+        if (charset == null) throw new IllegalArgumentException("Charset cannot be null");
 
         String data = writeToString();
         try {
-            Files.write(file, data.getBytes());
+            stream.write(data.getBytes(charset));
         } catch (IOException e) {
             throw new RuntimeException(e);
         }

From 40d1901715c5a95ff7775b44982f2841f5b675fa Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:43:32 -0500
Subject: [PATCH 13/14] Collect JaCoCo Reports

---
 .github/workflows/build.yml | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 91498fe..ad6aef3 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -75,6 +75,42 @@ jobs:
         run: chmod +x ./gradlew
       - name: Gradle Test
         run: ./gradlew test
+      - name: Collect JaCoCo Report
+        if: ${{ github.event_name != 'pull_request' }}
+        id: jacoco_reporter
+        uses: PavanMudigonda/jacoco-reporter@v5.0
+        with:
+          coverage_results_path: build/jacoco.xml
+          coverage_report_name: Code Coverage
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          skip_check_run: false
+          minimum_coverage: 85
+          fail_below_threshold: false
+          publish_only_summary: false
+      - name: Print JaCoCo Report
+        if: ${{ github.event_name != 'pull_request' }}
+        run: |
+          echo "| Outcome | Value |" >> $GITHUB_STEP_SUMMARY
+          echo "| --- | --- |" >> $GITHUB_STEP_SUMMARY
+          echo "| Code Coverage % | ${{ steps.jacoco_reporter.outputs.coverage_percentage }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| :heavy_check_mark: Number of Lines Covered | ${{ steps.jacoco_reporter.outputs.covered_lines }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| :x: Number of Lines Missed | ${{ steps.jacoco_reporter.outputs.missed_lines }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| Total Number of Lines | ${{ steps.jacoco_reporter.outputs.total_lines }} |" >> $GITHUB_STEP_SUMMARY
+      - name: Upload Code Coverage Artifacts (Push)
+        if: ${{ github.event_name != 'pull_request' }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: "*/coverage-results.md"
+      - name: Upload Code Coverage Artifacts (Pull Request)
+        if: ${{ github.event_name == 'pull_request' }}
+        uses: madrapps/jacoco-report@v1.7.0
+        with:
+          paths: build/jacoco.xml
+          token: ${{ secrets.GITHUB_TOKEN }}
+          pass-emoji: ✅
+          min-coverage-overall: 85
+          min-coverage-changed-files: 90
 
   deploy:
     runs-on: ubuntu-latest

From 88fd3c2da50f566a2859aa1fc8db4c7556945782 Mon Sep 17 00:00:00 2001
From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:44:27 -0500
Subject: [PATCH 14/14] Upgrade to Gradle 8.10.1

---
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 gradlew                                  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index a441313..0aaefbc 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/gradlew b/gradlew
index 1aa94a4..b740cf1 100755
--- a/gradlew
+++ b/gradlew
@@ -55,7 +55,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.