make the skin renderer less bad (thanks bray)

2024-04-12 18:46:54 +01:00
parent 83a95fb26c
commit 2ea58d8080
71 changed files with 662 additions and 561 deletions
--- a/src/main/java/cc/fascinated/Main.java
+++ b/src/main/java/cc/fascinated/Main.java
@ -0,0 +1,57 @@
+package cc.fascinated;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import lombok.NonNull;
+import lombok.SneakyThrows;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+import java.io.File;
+import java.net.http.HttpClient;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.Objects;
+
+@Log4j2
+@SpringBootApplication
+public class Main {
+
+    public static final Gson GSON = new GsonBuilder()
+            .setDateFormat("MM-dd-yyyy HH:mm:ss")
+            .create();
+    public static final HttpClient HTTP_CLIENT = HttpClient.newHttpClient();
+
+    @SneakyThrows
+    public static void main(String[] args) {
+        File config = new File("application.yml");
+        if (!config.exists()) { // Saving the default config if it doesn't exist locally
+            Files.copy(Objects.requireNonNull(Main.class.getResourceAsStream("/application.yml")), config.toPath(), StandardCopyOption.REPLACE_EXISTING);
+            log.info("Saved the default configuration to '{}', please re-launch the application", // Log the default config being saved
+                    config.getAbsolutePath()
+            );
+            return;
+        }
+        log.info("Found configuration at '{}'", config.getAbsolutePath()); // Log the found config
+
+        SpringApplication.run(Main.class, args); // Start the application
+    }
+
+    @Bean
+    public WebMvcConfigurer configureCors() {
+        return new WebMvcConfigurer() {
+            @Override
+            public void addCorsMappings(@NonNull CorsRegistry registry) {
+                // Allow all origins to access the API
+                registry.addMapping("/**")
+                        .allowedOrigins("*") // Allow all origins
+                        .allowedMethods("*") // Allow all methods
+                        .allowedHeaders("*"); // Allow all headers
+            }
+        };
+    }
+}
--- a/src/main/java/cc/fascinated/common/ColorUtils.java
+++ b/src/main/java/cc/fascinated/common/ColorUtils.java
@ -0,0 +1,81 @@
+package cc.fascinated.common;
+
+import lombok.NonNull;
+import lombok.experimental.UtilityClass;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * @author Braydon
+ */
+@UtilityClass
+public final class ColorUtils {
+    private static final Pattern STRIP_COLOR_PATTERN = Pattern.compile("(?i)§[0-9A-FK-OR]");
+    private static final Map<Character, String> COLOR_MAP = new HashMap<>();
+    static {
+        // Map each color to its corresponding hex code
+        COLOR_MAP.put('0', "#000000"); // Black
+        COLOR_MAP.put('1', "#0000AA"); // Dark Blue
+        COLOR_MAP.put('2', "#00AA00"); // Dark Green
+        COLOR_MAP.put('3', "#00AAAA"); // Dark Aqua
+        COLOR_MAP.put('4', "#AA0000"); // Dark Red
+        COLOR_MAP.put('5', "#AA00AA"); // Dark Purple
+        COLOR_MAP.put('6', "#FFAA00"); // Gold
+        COLOR_MAP.put('7', "#AAAAAA"); // Gray
+        COLOR_MAP.put('8', "#555555"); // Dark Gray
+        COLOR_MAP.put('9', "#5555FF"); // Blue
+        COLOR_MAP.put('a', "#55FF55"); // Green
+        COLOR_MAP.put('b', "#55FFFF"); // Aqua
+        COLOR_MAP.put('c', "#FF5555"); // Red
+        COLOR_MAP.put('d', "#FF55FF"); // Light Purple
+        COLOR_MAP.put('e', "#FFFF55"); // Yellow
+        COLOR_MAP.put('f', "#FFFFFF"); // White
+    }
+
+    /**
+     * Strip the color codes
+     * from the given input.
+     *
+     * @param input the input to strip
+     * @return the stripped input
+     */
+    @NonNull
+    public static String stripColor(@NonNull String input) {
+        return STRIP_COLOR_PATTERN.matcher(input).replaceAll("");
+    }
+
+    /**
+     * Convert the given input into HTML format.
+     * <p>
+     * This will replace each color code with
+     * a span tag with the respective color in
+     * hex format.
+     * </p>
+     *
+     * @param input the input to convert
+     * @return the converted input
+     */
+    @NonNull
+    public static String toHTML(@NonNull String input) {
+        StringBuilder builder = new StringBuilder();
+        boolean nextIsColor = false; // Is the next char a color code?
+
+        for (char character : input.toCharArray()) {
+            // Found color symbol, next color is the color
+            if (character == '§') {
+                nextIsColor = true;
+                continue;
+            }
+            if (nextIsColor) { // Map the current color to its hex code
+                String color = COLOR_MAP.getOrDefault(Character.toLowerCase(character), "");
+                builder.append("<span style=\"color:").append(color).append("\">");
+                nextIsColor = false;
+                continue;
+            }
+            builder.append(character); // Append the char...
+        }
+        return builder.toString();
+    }
+}
--- a/src/main/java/cc/fascinated/common/DNSUtils.java
+++ b/src/main/java/cc/fascinated/common/DNSUtils.java
@ -0,0 +1,58 @@
+package cc.fascinated.common;
+
+import cc.fascinated.model.dns.impl.ARecord;
+import cc.fascinated.model.dns.impl.SRVRecord;
+import lombok.NonNull;
+import lombok.SneakyThrows;
+import lombok.experimental.UtilityClass;
+import org.xbill.DNS.Lookup;
+import org.xbill.DNS.Record;
+import org.xbill.DNS.Type;
+
+/**
+ * @author Braydon
+ */
+@UtilityClass
+public final class DNSUtils {
+    private static final String SRV_QUERY_PREFIX = "_minecraft._tcp.%s";
+
+    /**
+     * Get the resolved address and port of the
+     * given hostname by resolving the SRV records.
+     *
+     * @param hostname the hostname to resolve
+     * @return the resolved address and port, null if none
+     */
+    @SneakyThrows
+    public static SRVRecord resolveSRV(@NonNull String hostname) {
+        Record[] records = new Lookup(SRV_QUERY_PREFIX.formatted(hostname), Type.SRV).run(); // Resolve SRV records
+        if (records == null) { // No records exist
+            return null;
+        }
+        SRVRecord result = null;
+        for (Record record : records) {
+            result = new SRVRecord((org.xbill.DNS.SRVRecord) record);
+        }
+        return result;
+    }
+
+    /**
+     * Get the resolved address of the given
+     * hostname by resolving the A records.
+     *
+     * @param hostname the hostname to resolve
+     * @return the resolved address, null if none
+     */
+    @SneakyThrows
+    public static ARecord resolveA(@NonNull String hostname) {
+        Record[] records = new Lookup(hostname, Type.A).run(); // Resolve A records
+        if (records == null) { // No records exist
+            return null;
+        }
+        ARecord result = null;
+        for (Record record : records) {
+            result = new ARecord((org.xbill.DNS.ARecord) record);
+        }
+        return result;
+    }
+}
--- a/src/main/java/cc/fascinated/common/EnumUtils.java
+++ b/src/main/java/cc/fascinated/common/EnumUtils.java
@ -0,0 +1,26 @@
+package cc.fascinated.common;
+
+import lombok.NonNull;
+import lombok.experimental.UtilityClass;
+
+/**
+ * @author Braydon
+ */
+@UtilityClass
+public final class EnumUtils {
+    /**
+     * Get the enum constant of the specified enum type with the specified name.
+     *
+     * @param enumType the enum type
+     * @param name     the name of the constant to return
+     * @param <T>      the type of the enum
+     * @return the enum constant of the specified enum type with the specified name
+     */
+    public <T extends Enum<T>> T getEnumConstant(@NonNull Class<T> enumType, @NonNull String name) {
+        try {
+            return Enum.valueOf(enumType, name);
+        } catch (IllegalArgumentException ex) {
+            return null;
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/common/ExpiringSet.java
+++ b/src/main/java/cc/fascinated/common/ExpiringSet.java
@ -0,0 +1,132 @@
+package cc.fascinated.common;
+
+import lombok.NonNull;
+import net.jodah.expiringmap.ExpirationPolicy;
+import net.jodah.expiringmap.ExpiringMap;
+
+import java.util.Iterator;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+
+/**
+ * A simple set that expires elements after a certain
+ * amount of time, utilizing the {@link ExpiringMap} library.
+ *
+ * @param <T> The type of element to store within this set
+ * @author Braydon
+ */
+public final class ExpiringSet<T> implements Iterable<T> {
+    /**
+     * The internal cache for this set.
+     */
+    @NonNull private final ExpiringMap<T, Long> cache;
+
+    /**
+     * The lifetime (in millis) of the elements in this set.
+     */
+    private final long lifetime;
+
+    public ExpiringSet(@NonNull ExpirationPolicy expirationPolicy, long duration, @NonNull TimeUnit timeUnit) {
+        this(expirationPolicy, duration, timeUnit, ignored -> {});
+    }
+
+    public ExpiringSet(@NonNull ExpirationPolicy expirationPolicy, long duration, @NonNull TimeUnit timeUnit, @NonNull Consumer<T> onExpire) {
+        //noinspection unchecked
+        this.cache = ExpiringMap.builder()
+                .expirationPolicy(expirationPolicy)
+                .expiration(duration, timeUnit)
+                .expirationListener((key, ignored) -> onExpire.accept((T) key))
+                .build();
+        this.lifetime = timeUnit.toMillis(duration); // Get the lifetime in millis
+    }
+
+    /**
+     * Add an element to this set.
+     *
+     * @param element the element
+     * @return whether the element was added
+     */
+    public boolean add(@NonNull T element) {
+        boolean contains = contains(element); // Does this set already contain the element?
+        this.cache.put(element, System.currentTimeMillis() + this.lifetime);
+        return !contains;
+    }
+
+    /**
+     * Get the entry time of an element in this set.
+     *
+     * @param element the element
+     * @return the entry time, -1 if not contained
+     */
+    public long getEntryTime(@NonNull T element) {
+        return contains(element) ? this.cache.get(element) - this.lifetime : -1L;
+    }
+
+    /**
+     * Check if an element is
+     * contained within this set.
+     *
+     * @param element the element
+     * @return whether the element is contained
+     */
+    public boolean contains(@NonNull T element) {
+        Long timeout = this.cache.get(element); // Get the timeout for the element
+        return timeout != null && (timeout > System.currentTimeMillis());
+    }
+
+    /**
+     * Check if this set is empty.
+     *
+     * @return whether this set is empty
+     */
+    public boolean isEmpty() {
+        return this.cache.isEmpty();
+    }
+
+    /**
+     * Get the size of this set.
+     *
+     * @return the size
+     */
+    public int size() {
+        return this.cache.size();
+    }
+
+    /**
+     * Remove an element from this set.
+     *
+     * @param element the element
+     * @return whether the element was removed
+     */
+    public boolean remove(@NonNull T element) {
+        return this.cache.remove(element) != null;
+    }
+
+    /**
+     * Clear this set.
+     */
+    public void clear() {
+        this.cache.clear();
+    }
+
+    /**
+     * Get the elements in this set.
+     *
+     * @return the elements
+     */
+    @NonNull
+    public Set<T> getElements() {
+        return this.cache.keySet();
+    }
+
+    /**
+     * Returns an iterator over elements of type {@code T}.
+     *
+     * @return an Iterator.
+     */
+    @Override @NonNull
+    public Iterator<T> iterator() {
+        return this.cache.keySet().iterator();
+    }
+}
--- a/src/main/java/cc/fascinated/common/IPUtils.java
+++ b/src/main/java/cc/fascinated/common/IPUtils.java
@ -0,0 +1,42 @@
+package cc.fascinated.common;
+
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class IPUtils {
+    /**
+     * The headers that contain the IP.
+     */
+    private static final String[] IP_HEADERS = new String[] {
+            "CF-Connecting-IP",
+            "X-Forwarded-For"
+    };
+
+    /**
+     * Get the real IP from the given request.
+     *
+     * @param request the request
+     * @return the real IP
+     */
+    public static String getRealIp(HttpServletRequest request) {
+        String ip = request.getRemoteAddr();
+        for (String headerName : IP_HEADERS) {
+            String header = request.getHeader(headerName);
+            if (header == null) {
+                continue;
+            }
+            if (!header.contains(",")) { // Handle single IP
+                ip = header;
+                break;
+            }
+            // Handle multiple IPs
+            String[] ips = header.split(",");
+            for (String ipHeader : ips) {
+                ip = ipHeader;
+                break;
+            }
+        }
+        return ip;
+    }
+}
--- a/src/main/java/cc/fascinated/common/ImageUtils.java
+++ b/src/main/java/cc/fascinated/common/ImageUtils.java
@ -0,0 +1,58 @@
+package cc.fascinated.common;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.SneakyThrows;
+import lombok.extern.log4j.Log4j2;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.geom.AffineTransform;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+@Log4j2
+public class ImageUtils {
+    /**
+     * Scale the given image to the provided size.
+     *
+     * @param image the image to scale
+     * @param size  the size to scale the image to
+     * @return the scaled image
+     */
+    public static BufferedImage resize(BufferedImage image, double size) {
+        BufferedImage scaled = new BufferedImage((int) (image.getWidth() * size), (int) (image.getHeight() * size), BufferedImage.TYPE_INT_ARGB);
+        Graphics2D graphics = scaled.createGraphics();
+        graphics.drawImage(image, AffineTransform.getScaleInstance(size, size), null);
+        graphics.dispose();
+        return scaled;
+    }
+
+    /**
+     * Flip the given image.
+     *
+     * @param image the image to flip
+     * @return the flipped image
+     */
+    public static BufferedImage flip(@NotNull final BufferedImage image) {
+        BufferedImage flipped = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB);
+        Graphics2D graphics = flipped.createGraphics();
+        graphics.drawImage(image, image.getWidth(), 0, 0, image.getHeight(), 0, 0, image.getWidth(), image.getHeight(), null);
+        graphics.dispose();
+        return flipped;
+    }
+
+    /**
+     * Convert an image to bytes.
+     *
+     * @param image the image to convert
+     * @return the image as bytes
+     */
+    @SneakyThrows
+    public static byte[] imageToBytes(BufferedImage image) {
+        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
+            ImageIO.write(image, "png", outputStream);
+            return outputStream.toByteArray();
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/common/JavaMinecraftVersion.java
+++ b/src/main/java/cc/fascinated/common/JavaMinecraftVersion.java
@ -0,0 +1,202 @@
+package cc.fascinated.common;
+
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+import lombok.extern.log4j.Log4j2;
+
+/**
+ * @author Braydon
+ * @see <a href="https://wiki.vg/Protocol_version_numbers">Protocol Version Numbers</a>
+ * @see <a href="https://www.spigotmc.org/wiki/spigot-nms-and-minecraft-versions-1-16">Spigot NMS (1.16+)</a>
+ * @see <a href="https://www.spigotmc.org/wiki/spigot-nms-and-minecraft-versions-1-10-1-15">Spigot NMS (1.10 - 1.15)</a>
+ * @see <a href="https://www.spigotmc.org/wiki/spigot-nms-and-minecraft-versions-legacy">Spigot NMS (1.8 - 1.9)</a>
+ */
+@RequiredArgsConstructor @Getter @ToString @Log4j2(topic = "Minecraft Version")
+public enum JavaMinecraftVersion {
+    V1_20_3(765, "v1_20_R3"), // 1.20.3 & 1.20.4
+    V1_20_2(764, "v1_20_R2"), // 1.20.2
+    V1_20(763, "v1_20_R1"), // 1.20 & 1.20.1
+
+    V1_19_4(762, "v1_19_R3"), // 1.19.4
+    V1_19_3(761, "v1_19_R2"), // 1.19.3
+    V1_19_1(760, "v1_19_R1"), // 1.19.1 & 1.19.2
+    V1_19(759, "v1_19_R1"), // 1.19
+
+    V1_18_2(758, "v1_18_R2"), // 1.18.2
+    V1_18(757, "v1_18_R1"), // 1.18 & 1.18.1
+
+    V1_17_1(756, "v1_17_R1"), // 1.17.1
+    V1_17(755, "v1_17_R1"), // 1.17
+
+    V1_16_4(754, "v1_16_R3"), // 1.16.4 & 1.16.5
+    V1_16_3(753, "v1_16_R2"), // 1.16.3
+    V1_16_2(751, "v1_16_R2"), // 1.16.2
+    V1_16_1(736, "v1_16_R1"), // 1.16.1
+    V1_16(735, "v1_16_R1"), // 1.16
+
+    V1_15_2(578, "v1_15_R1"), // 1.15.2
+    V1_15_1(575, "v1_15_R1"), // 1.15.1
+    V1_15(573, "v1_15_R1"), // 1.15
+
+    V1_14_4(498, "v1_14_R1"), // 1.14.4
+    V1_14_3(490, "v1_14_R1"), // 1.14.3
+    V1_14_2(485, "v1_14_R1"), // 1.14.2
+    V1_14_1(480, "v1_14_R1"), // 1.14.1
+    V1_14(477, "v1_14_R1"), // 1.14
+
+    V1_13_2(404, "v1_13_R2"), // 1.13.2
+    V1_13_1(401, "v1_13_R2"), // 1.13.1
+    V1_13(393, "v1_13_R1"), // 1.13
+
+    V1_12_2(340, "v1_12_R1"), // 1.12.2
+    V1_12_1(338, "v1_12_R1"), // 1.12.1
+    V1_12(335, "v1_12_R1"), // 1.12
+
+    V1_11_1(316, "v1_11_R1"), // 1.11.1 & 1.11.2
+    V1_11(315, "v1_11_R1"), // 1.11
+
+    V1_10(210, "v1_10_R1"), // 1.10.x
+
+    V1_9_3(110, "v1_9_R2"), // 1.9.3 & 1.9.4
+    V1_9_2(109, "v1_9_R1"), // 1.9.2
+    V1_9_1(108, "v1_9_R1"), // 1.9.1
+    V1_9(107, "v1_9_R1"), // 1.9
+
+    V1_8(47, "v1_8_R3"), // 1.8.x
+
+    V1_7_6(5, "v1_7_R4"), // 1.7.6 - 1.7.10
+
+    UNKNOWN(-1, "Unknown");
+
+    // Game Updates
+    public static final JavaMinecraftVersion TRAILS_AND_TALES = JavaMinecraftVersion.V1_20;
+    public static final JavaMinecraftVersion THE_WILD_UPDATE = JavaMinecraftVersion.V1_19;
+    public static final JavaMinecraftVersion CAVES_AND_CLIFFS_PT_2 = JavaMinecraftVersion.V1_18;
+    public static final JavaMinecraftVersion CAVES_AND_CLIFFS_PT_1 = JavaMinecraftVersion.V1_17;
+    public static final JavaMinecraftVersion NETHER_UPDATE = JavaMinecraftVersion.V1_16;
+    public static final JavaMinecraftVersion BUZZY_BEES = JavaMinecraftVersion.V1_15;
+    public static final JavaMinecraftVersion VILLAGE_AND_PILLAGE = JavaMinecraftVersion.V1_14;
+    public static final JavaMinecraftVersion UPDATE_AQUATIC = JavaMinecraftVersion.V1_13;
+    public static final JavaMinecraftVersion WORLD_OF_COLOR_UPDATE = JavaMinecraftVersion.V1_12;
+    public static final JavaMinecraftVersion EXPLORATION_UPDATE = JavaMinecraftVersion.V1_11;
+    public static final JavaMinecraftVersion FROSTBURN_UPDATE = JavaMinecraftVersion.V1_10;
+    public static final JavaMinecraftVersion THE_COMBAT_UPDATE = JavaMinecraftVersion.V1_9;
+    public static final JavaMinecraftVersion BOUNTIFUL_UPDATE = JavaMinecraftVersion.V1_8;
+
+    private static final JavaMinecraftVersion[] VALUES = JavaMinecraftVersion.values();
+
+    /**
+     * The protocol number of this version.
+     */
+    private final int protocol;
+
+    /**
+     * The server version for this version.
+     */
+    private final String nmsVersion;
+
+    /**
+     * The cached name of this version.
+     */
+    private String name;
+
+    /**
+     * Get the name of this protocol version.
+     *
+     * @return the name
+     */
+    public String getName() {
+        // We have a name
+        if (this.name != null) {
+            return this.name;
+        }
+        // Use the server version as the name if unknown
+        if (this == UNKNOWN) {
+            this.name = this.getNmsVersion();
+        } else { // Parse the name
+            this.name = name().substring(1);
+            this.name = this.name.replace("_", ".");
+        }
+        return this.name;
+    }
+
+    /**
+     * Is this version legacy?
+     *
+     * @return whether this version is legacy
+     */
+    public boolean isLegacy() {
+        return this.isBelow(JavaMinecraftVersion.V1_16);
+    }
+
+    /**
+     * Check if this version is
+     * above the one given.
+     *
+     * @param other the other version
+     * @return true if above, otherwise false
+     */
+    public boolean isAbove(JavaMinecraftVersion other) {
+        return this.protocol > other.getProtocol();
+    }
+
+    /**
+     * Check if this version is
+     * or above the one given.
+     *
+     * @param other the other version
+     * @return true if is or above, otherwise false
+     */
+    public boolean isOrAbove(JavaMinecraftVersion other) {
+        return this.protocol >= other.getProtocol();
+    }
+
+    /**
+     * Check if this version is
+     * below the one given.
+     *
+     * @param other the other version
+     * @return true if below, otherwise false
+     */
+    public boolean isBelow(JavaMinecraftVersion other) {
+        return this.protocol < other.getProtocol();
+    }
+
+    /**
+     * Check if this version is
+     * or below the one given.
+     *
+     * @param other the other version
+     * @return true if is or below, otherwise false
+     */
+    public boolean isOrBelow(JavaMinecraftVersion other) {
+        return this.protocol <= other.getProtocol();
+    }
+
+    /**
+     * Get the minimum Minecraft version.
+     *
+     * @return the minimum version
+     */
+    @NonNull
+    public static JavaMinecraftVersion getMinimumVersion() {
+        return VALUES[VALUES.length - 2];
+    }
+
+    /**
+     * Get the version from the given protocol.
+     *
+     * @param protocol the protocol to get the version for
+     * @return the version, null if none
+     */
+    public static JavaMinecraftVersion byProtocol(int protocol) {
+        for (JavaMinecraftVersion version : values()) {
+            if (version.getProtocol() == protocol) {
+                return version;
+            }
+        }
+        return null;
+    }
+}
--- a/src/main/java/cc/fascinated/common/PlayerUtils.java
+++ b/src/main/java/cc/fascinated/common/PlayerUtils.java
@ -0,0 +1,50 @@
+package cc.fascinated.common;
+
+import cc.fascinated.Main;
+import cc.fascinated.exception.impl.BadRequestException;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.SneakyThrows;
+import lombok.experimental.UtilityClass;
+import lombok.extern.log4j.Log4j2;
+
+import java.net.URI;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.UUID;
+
+@UtilityClass @Log4j2
+public class PlayerUtils {
+
+    /**
+     * Gets the UUID from the string.
+     *
+     * @param id the id string
+     * @return the UUID
+     */
+    public static UUID getUuidFromString(String id) {
+        UUID uuid;
+        boolean isFullUuid = id.length() == 36;
+        if (id.length() == 32 || isFullUuid) {
+            try {
+                uuid = isFullUuid ? UUID.fromString(id) : UUIDUtils.addDashes(id);
+            } catch (IllegalArgumentException exception) {
+                throw new BadRequestException("Invalid UUID provided: %s".formatted(id));
+            }
+            return uuid;
+        }
+        return null;
+    }
+
+    /**
+     * Gets the skin data from the URL.
+     *
+     * @return the skin data
+     */
+    @SneakyThrows
+    @JsonIgnore
+    public static byte[] getSkinImage(String url) {
+        HttpResponse<byte[]> response = Main.HTTP_CLIENT.send(HttpRequest.newBuilder(URI.create(url)).build(),
+                HttpResponse.BodyHandlers.ofByteArray());
+        return response.body();
+    }
+}
--- a/src/main/java/cc/fascinated/common/ServerUtils.java
+++ b/src/main/java/cc/fascinated/common/ServerUtils.java
@ -0,0 +1,16 @@
+package cc.fascinated.common;
+
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class ServerUtils {
+
+    /**
+     * Gets the address of the server.
+     *
+     * @return the address of the server
+     */
+    public static String getAddress(String ip, int port) {
+        return ip + (port == 25565 ? "" : ":" + port);
+    }
+}
--- a/src/main/java/cc/fascinated/common/Tuple.java
+++ b/src/main/java/cc/fascinated/common/Tuple.java
@ -0,0 +1,18 @@
+package cc.fascinated.common;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter @AllArgsConstructor
+public class Tuple<L, R> {
+
+    /**
+     * The left value of the tuple.
+     */
+    private final L left;
+
+    /**
+     * The right value of the tuple.
+     */
+    private final R right;
+}
--- a/src/main/java/cc/fascinated/common/UUIDUtils.java
+++ b/src/main/java/cc/fascinated/common/UUIDUtils.java
@ -0,0 +1,36 @@
+package cc.fascinated.common;
+
+import io.micrometer.common.lang.NonNull;
+import lombok.experimental.UtilityClass;
+
+import java.util.UUID;
+
+@UtilityClass
+public class UUIDUtils {
+
+    /**
+     * Add dashes to a UUID.
+     *
+     * @param trimmed the UUID without dashes
+     * @return the UUID with dashes
+     */
+    @NonNull
+    public static UUID addDashes(@NonNull String trimmed) {
+        StringBuilder builder = new StringBuilder(trimmed);
+        for (int i = 0, pos = 20; i < 4; i++, pos -= 4) {
+            builder.insert(pos, "-");
+        }
+        return UUID.fromString(builder.toString());
+    }
+
+    /**
+     * Remove dashes from a UUID.
+     *
+     * @param dashed the UUID with dashes
+     * @return the UUID without dashes
+     */
+    @NonNull
+    public static String removeDashes(@NonNull UUID dashed) {
+        return dashed.toString().replace("-", "");
+    }
+}
--- a/src/main/java/cc/fascinated/common/WebRequest.java
+++ b/src/main/java/cc/fascinated/common/WebRequest.java
@ -0,0 +1,46 @@
+package cc.fascinated.common;
+
+import cc.fascinated.exception.impl.RateLimitException;
+import lombok.experimental.UtilityClass;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
+import org.springframework.web.client.HttpClientErrorException;
+import org.springframework.web.client.RestClient;
+
+@UtilityClass
+public class WebRequest {
+
+    /**
+     * The web client.
+     */
+    private static final RestClient CLIENT = RestClient.builder()
+            .requestFactory(new HttpComponentsClientHttpRequestFactory())
+            .build();
+
+    /**
+     * Gets a response from the given URL.
+     *
+     * @param url the url
+     * @return the response
+     * @param <T> the type of the response
+     */
+    public static <T> T getAsEntity(String url, Class<T> clazz) throws RateLimitException {
+        try {
+            ResponseEntity<T> profile = CLIENT.get()
+                    .uri(url)
+                    .retrieve()
+                    .toEntity(clazz);
+
+            if (profile.getStatusCode().isError()) {
+                return null;
+            }
+            if (profile.getStatusCode().isSameCodeAs(HttpStatus.TOO_MANY_REQUESTS)) {
+                throw new RateLimitException("Rate limit reached");
+            }
+            return profile.getBody();
+        } catch (HttpClientErrorException ex) {
+            return null;
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/common/packet/MinecraftBedrockPacket.java
+++ b/src/main/java/cc/fascinated/common/packet/MinecraftBedrockPacket.java
@ -0,0 +1,23 @@
+package cc.fascinated.common.packet;
+
+import lombok.NonNull;
+
+import java.io.IOException;
+import java.net.DatagramSocket;
+
+/**
+ * Represents a packet in the
+ * Minecraft Bedrock protocol.
+ *
+ * @author Braydon
+ * @see <a href="https://wiki.vg/Raknet_Protocol">Protocol Docs</a>
+ */
+public interface MinecraftBedrockPacket {
+    /**
+     * Process this packet.
+     *
+     * @param socket the socket to process the packet for
+     * @throws IOException if an I/O error occurs
+     */
+    void process(@NonNull DatagramSocket socket) throws IOException;
+}
--- a/src/main/java/cc/fascinated/common/packet/MinecraftJavaPacket.java
+++ b/src/main/java/cc/fascinated/common/packet/MinecraftJavaPacket.java
@ -0,0 +1,66 @@
+package cc.fascinated.common.packet;
+
+import lombok.NonNull;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/**
+ * Represents a packet in the
+ * Minecraft Java protocol.
+ *
+ * @author Braydon
+ * @see <a href="https://wiki.vg/Protocol">Protocol Docs</a>
+ */
+public abstract class MinecraftJavaPacket {
+    /**
+     * Process this packet.
+     *
+     * @param inputStream the input stream to read from
+     * @param outputStream the output stream to write to
+     * @throws IOException if an I/O error occurs
+     */
+    public abstract void process(@NonNull DataInputStream inputStream, @NonNull DataOutputStream outputStream) throws IOException;
+
+    /**
+     * Write a variable integer to the output stream.
+     *
+     * @param outputStream the output stream to write to
+     * @param paramInt the integer to write
+     * @throws IOException if an I/O error occurs
+     */
+    protected final void writeVarInt(DataOutputStream outputStream, int paramInt) throws IOException {
+        while (true) {
+            if ((paramInt & 0xFFFFFF80) == 0) {
+                outputStream.writeByte(paramInt);
+                return;
+            }
+            outputStream.writeByte(paramInt & 0x7F | 0x80);
+            paramInt >>>= 7;
+        }
+    }
+
+    /**
+     * Read a variable integer from the input stream.
+     *
+     * @param inputStream the input stream to read from
+     * @return the integer that was read
+     * @throws IOException if an I/O error occurs
+     */
+    protected final int readVarInt(@NonNull DataInputStream inputStream) throws IOException {
+        int i = 0;
+        int j = 0;
+        while (true) {
+            int k = inputStream.readByte();
+            i |= (k & 0x7F) << j++ * 7;
+            if (j > 5) {
+                throw new RuntimeException("VarInt too big");
+            }
+            if ((k & 0x80) != 128) {
+                break;
+            }
+        }
+        return i;
+    }
+}
--- a/src/main/java/cc/fascinated/common/packet/impl/bedrock/BedrockPacketUnconnectedPing.java
+++ b/src/main/java/cc/fascinated/common/packet/impl/bedrock/BedrockPacketUnconnectedPing.java
@ -0,0 +1,42 @@
+package cc.fascinated.common.packet.impl.bedrock;
+
+import cc.fascinated.common.packet.MinecraftBedrockPacket;
+import lombok.NonNull;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * This packet is sent by the client to the server to
+ * request a pong response from the server. The server
+ * will respond with a string containing the server's status.
+ *
+ * @author Braydon
+ * @see <a href="https://wiki.vg/Raknet_Protocol#Unconnected_Ping">Protocol Docs</a>
+ */
+public final class BedrockPacketUnconnectedPing implements MinecraftBedrockPacket {
+    private static final byte ID = 0x01; // The ID of the packet
+    private static final byte[] MAGIC = { 0, -1, -1, 0, -2, -2, -2, -2, -3, -3, -3, -3, 18, 52, 86, 120 };
+
+    /**
+     * Process this packet.
+     *
+     * @param socket the socket to process the packet for
+     * @throws IOException if an I/O error occurs
+     */
+    @Override
+    public void process(@NonNull DatagramSocket socket) throws IOException {
+        // Construct the packet buffer
+        ByteBuffer buffer = ByteBuffer.allocate(33).order(ByteOrder.LITTLE_ENDIAN);;
+        buffer.put(ID); // Packet ID
+        buffer.putLong(System.currentTimeMillis()); // Timestamp
+        buffer.put(MAGIC); // Magic
+        buffer.putLong(0L); // Client GUID
+
+        // Send the packet
+        socket.send(new DatagramPacket(buffer.array(), 0, buffer.limit()));
+    }
+}
--- a/src/main/java/cc/fascinated/common/packet/impl/bedrock/BedrockPacketUnconnectedPong.java
+++ b/src/main/java/cc/fascinated/common/packet/impl/bedrock/BedrockPacketUnconnectedPong.java
@ -0,0 +1,62 @@
+package cc.fascinated.common.packet.impl.bedrock;
+
+import cc.fascinated.common.packet.MinecraftBedrockPacket;
+import cc.fascinated.model.server.BedrockMinecraftServer;
+import lombok.Getter;
+import lombok.NonNull;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * This packet is sent by the server to the client in
+ * response to the {@link BedrockPacketUnconnectedPing}.
+ *
+ * @author Braydon
+ * @see <a href="https://wiki.vg/Raknet_Protocol#Unconnected_Pong">Protocol Docs</a>
+ */
+@Getter
+public final class BedrockPacketUnconnectedPong implements MinecraftBedrockPacket {
+    private static final byte ID = 0x1C; // The ID of the packet
+
+    /**
+     * The response from the server, null if none.
+     */
+    private String response;
+
+    /**
+     * Process this packet.
+     *
+     * @param socket the socket to process the packet for
+     * @throws IOException if an I/O error occurs
+     */
+    @Override
+    public void process(@NonNull DatagramSocket socket) throws IOException {
+        // Handle receiving of the packet
+        byte[] receiveData = new byte[2048];
+        DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
+        socket.receive(receivePacket);
+
+        // Construct a buffer from the received packet
+        ByteBuffer buffer = ByteBuffer.wrap(receivePacket.getData()).order(ByteOrder.LITTLE_ENDIAN);
+        byte id = buffer.get(); // The received packet id
+        if (id == ID) {
+            String response = new String(buffer.array(), StandardCharsets.UTF_8).trim(); // Extract the response
+
+            // Trim the length of the response (short) from the
+            // start of the string, which begins with the edition name
+            for (BedrockMinecraftServer.Edition edition : BedrockMinecraftServer.Edition.values()) {
+                int startIndex = response.indexOf(edition.name());
+                if (startIndex != -1) {
+                    response = response.substring(startIndex);
+                    break;
+                }
+            }
+            this.response = response;
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/common/packet/impl/java/JavaPacketHandshakingInSetProtocol.java
+++ b/src/main/java/cc/fascinated/common/packet/impl/java/JavaPacketHandshakingInSetProtocol.java
@ -0,0 +1,64 @@
+package cc.fascinated.common.packet.impl.java;
+
+import cc.fascinated.common.packet.MinecraftJavaPacket;
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
+import lombok.ToString;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/**
+ * This packet is sent by the client to the server to set
+ * the hostname, port, and protocol version of the client.
+ *
+ * @author Braydon
+ * @see <a href="https://wiki.vg/Protocol#Handshake">Protocol Docs</a>
+ */
+@AllArgsConstructor @ToString
+public final class JavaPacketHandshakingInSetProtocol extends MinecraftJavaPacket {
+    private static final byte ID = 0x00; // The ID of the packet
+    private static final int STATUS_HANDSHAKE = 1; // The status handshake ID
+
+    /**
+     * The hostname of the server.
+     */
+    @NonNull private final String hostname;
+
+    /**
+     * The port of the server.
+     */
+    private final int port;
+
+    /**
+     * The protocol version of the server.
+     */
+    private final int protocolVersion;
+
+    /**
+     * Process this packet.
+     *
+     * @param inputStream  the input stream to read from
+     * @param outputStream the output stream to write to
+     * @throws IOException if an I/O error occurs
+     */
+    @Override
+    public void process(@NonNull DataInputStream inputStream, @NonNull DataOutputStream outputStream) throws IOException {
+        try (ByteArrayOutputStream handshakeBytes = new ByteArrayOutputStream();
+             DataOutputStream handshake = new DataOutputStream(handshakeBytes)
+        ) {
+            handshake.writeByte(ID); // Write the ID of the packet
+            writeVarInt(handshake, protocolVersion); // Write the protocol version
+            writeVarInt(handshake, hostname.length()); // Write the length of the hostname
+            handshake.writeBytes(hostname); // Write the hostname
+            handshake.writeShort(port); // Write the port
+            writeVarInt(handshake, STATUS_HANDSHAKE); // Write the status handshake ID
+
+            // Write the handshake bytes to the output stream
+            writeVarInt(outputStream, handshakeBytes.size());
+            outputStream.write(handshakeBytes.toByteArray());
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/common/packet/impl/java/JavaPacketStatusInStart.java
+++ b/src/main/java/cc/fascinated/common/packet/impl/java/JavaPacketStatusInStart.java
@ -0,0 +1,62 @@
+package cc.fascinated.common.packet.impl.java;
+
+import cc.fascinated.common.packet.MinecraftJavaPacket;
+import lombok.Getter;
+import lombok.NonNull;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/**
+ * This packet is sent by the client to the server to request the
+ * status of the server. The server will respond with a json object
+ * containing the server's status.
+ *
+ * @author Braydon
+ * @see <a href="https://wiki.vg/Protocol#Status_Request">Protocol Docs</a>
+ */
+@Getter
+public final class JavaPacketStatusInStart extends MinecraftJavaPacket {
+    private static final byte ID = 0x00; // The ID of the packet
+
+    /**
+     * The response json from the server, null if none.
+     */
+    private String response;
+
+    /**
+     * Process this packet.
+     *
+     * @param inputStream  the input stream to read from
+     * @param outputStream the output stream to write to
+     * @throws IOException if an I/O error occurs
+     */
+    @Override
+    public void process(@NonNull DataInputStream inputStream, @NonNull DataOutputStream outputStream) throws IOException {
+        // Send the status request
+        outputStream.writeByte(0x01); // Size of packet
+        outputStream.writeByte(ID);
+
+        // Read the status response
+        readVarInt(inputStream); // Size of the response
+        int id = readVarInt(inputStream);
+        if (id == -1) { // The stream was prematurely ended
+            throw new IOException("Server prematurely ended stream.");
+        } else if (id != ID) { // Invalid packet ID
+            throw new IOException("Server returned invalid packet ID.");
+        }
+
+        int length = readVarInt(inputStream); // Length of the response
+        if (length == -1) { // The stream was prematurely ended
+            throw new IOException("Server prematurely ended stream.");
+        } else if (length == 0) {
+            throw new IOException("Server returned unexpected value.");
+        }
+
+        // Get the json response
+        byte[] data = new byte[length];
+        inputStream.readFully(data);
+        response = new String(data);
+    }
+}
--- a/src/main/java/cc/fascinated/common/renderer/IsometricSkinRenderer.java
+++ b/src/main/java/cc/fascinated/common/renderer/IsometricSkinRenderer.java
@ -0,0 +1,27 @@
+package cc.fascinated.common.renderer;
+
+import cc.fascinated.model.skin.ISkinPart;
+
+import java.awt.*;
+import java.awt.geom.AffineTransform;
+import java.awt.image.BufferedImage;
+
+public abstract class IsometricSkinRenderer<T extends ISkinPart> extends SkinRenderer<T> {
+
+    /**
+     * Draw a part onto the texture.
+     *
+     * @param graphics  the graphics to draw to
+     * @param partImage the part image to draw
+     * @param transform the transform to apply
+     * @param x         the x position to draw at
+     * @param y         the y position to draw at
+     * @param width     the part image width
+     * @param height    the part image height
+     */
+    protected final void drawPart(Graphics2D graphics, BufferedImage partImage, AffineTransform transform,
+                                  double x, double y, int width, int height) {
+        graphics.setTransform(transform);
+        graphics.drawImage(partImage, (int) x, (int) y, width, height, null);
+    }
+}
--- a/src/main/java/cc/fascinated/common/renderer/SkinRenderer.java
+++ b/src/main/java/cc/fascinated/common/renderer/SkinRenderer.java
@ -0,0 +1,95 @@
+package cc.fascinated.common.renderer;
+
+import cc.fascinated.common.ImageUtils;
+import cc.fascinated.model.skin.ISkinPart;
+import cc.fascinated.model.skin.Skin;
+import lombok.SneakyThrows;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+
+public abstract class SkinRenderer<T extends ISkinPart> {
+
+    /**
+     * Get the texture of a part of a skin.
+     *
+     * @param skin the skin to get the part texture from
+     * @param part the part of the skin to get
+     * @param size the size to scale the texture to
+     * @return the texture of the skin part
+     */
+    @SneakyThrows
+    public BufferedImage getVanillaSkinPart(Skin skin, ISkinPart.Vanilla part, double size) {
+        ISkinPart.Vanilla.Coordinates coordinates = part.getCoordinates(); // The coordinates of the part
+
+        // The skin texture is legacy, use legacy coordinates
+        if (skin.isLegacy() && part.hasLegacyCoordinates()) {
+            coordinates = part.getLegacyCoordinates();
+        }
+        int width = part.getWidth(); // The width of the part
+        if (skin.getModel() == Skin.Model.SLIM && part.isFrontArm()) {
+            width--;
+        }
+        BufferedImage skinImage = ImageIO.read(new ByteArrayInputStream(skin.getSkinImage())); // The skin texture
+        BufferedImage partTexture = getSkinPartTexture(skinImage, coordinates.getX(), coordinates.getY(), width, part.getHeight(), size);
+        if (coordinates instanceof ISkinPart.Vanilla.LegacyCoordinates legacyCoordinates && legacyCoordinates.isFlipped()) {
+            partTexture = ImageUtils.flip(partTexture);
+        }
+        return partTexture;
+    }
+
+    /**
+     * Get the texture of a specific part of the skin.
+     *
+     * @param skinImage the skin image to get the part from
+     * @param x         the x position of the part
+     * @param y         the y position of the part
+     * @param width     the width of the part
+     * @param height    the height of the part
+     * @param size      the size to scale the part to
+     * @return the texture of the skin part
+     */
+    @SneakyThrows
+    private BufferedImage getSkinPartTexture(BufferedImage skinImage, int x, int y, int width, int height, double size) {
+        // Create a new BufferedImage for the part of the skin texture
+        BufferedImage headTexture = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+
+        // Crop just the part we want based on our x, y, width, and height
+        headTexture.getGraphics().drawImage(skinImage, 0, 0, width, height, x, y, x + width, y + height, null);
+
+        // Scale the skin part texture
+        if (size > 0D) {
+            headTexture = ImageUtils.resize(headTexture, size);
+        }
+        return headTexture;
+    }
+
+    /**
+     * Apply an overlay to a texture.
+     *
+     * @param graphics     the graphics to overlay on
+     * @param overlayImage the part to overlay
+     */
+    protected void applyOverlay(Graphics2D graphics, BufferedImage overlayImage) {
+        try {
+            graphics.drawImage(overlayImage, 0, 0, null);
+            graphics.dispose();
+        } catch (Exception ignored) {
+            // We can safely ignore this, legacy
+            // skins don't have overlays
+        }
+    }
+
+    /**
+     * Renders the skin part for the player's skin.
+     *
+     * @param skin the player's skin
+     * @param part the skin part to render
+     * @param renderOverlays should the overlays be rendered
+     * @param size the size of the part
+     * @return the rendered skin part
+     */
+    public abstract BufferedImage render(Skin skin, T part, boolean renderOverlays, int size);
+}
--- a/src/main/java/cc/fascinated/common/renderer/impl/BodyRenderer.java
+++ b/src/main/java/cc/fascinated/common/renderer/impl/BodyRenderer.java
@ -0,0 +1,42 @@
+package cc.fascinated.common.renderer.impl;
+
+import cc.fascinated.common.ImageUtils;
+import cc.fascinated.common.renderer.SkinRenderer;
+import cc.fascinated.model.skin.ISkinPart;
+import cc.fascinated.model.skin.Skin;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.extern.log4j.Log4j2;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+
+@AllArgsConstructor @Getter @Log4j2
+public class BodyRenderer extends SkinRenderer<ISkinPart.Custom> {
+    public static final BodyRenderer INSTANCE = new BodyRenderer();
+
+    @Override
+    public BufferedImage render(Skin skin, ISkinPart.Custom part, boolean renderOverlays, int size) {
+        BufferedImage texture = new BufferedImage(16, 32, BufferedImage.TYPE_INT_ARGB); // The texture to return
+        Graphics2D graphics = texture.createGraphics(); // Create the graphics for drawing
+
+        // Get the Vanilla skin parts to draw
+        BufferedImage face = getVanillaSkinPart(skin, ISkinPart.Vanilla.FACE, -1);
+        BufferedImage body = getVanillaSkinPart(skin, ISkinPart.Vanilla.BODY_FRONT, -1);
+        BufferedImage leftArm = getVanillaSkinPart(skin, ISkinPart.Vanilla.LEFT_ARM_FRONT, -1);
+        BufferedImage rightArm = getVanillaSkinPart(skin, ISkinPart.Vanilla.RIGHT_ARM_FRONT, -1);
+        BufferedImage leftLeg = getVanillaSkinPart(skin, ISkinPart.Vanilla.LEFT_LEG_FRONT, -1);
+        BufferedImage rightLeg = getVanillaSkinPart(skin, ISkinPart.Vanilla.RIGHT_LEG_FRONT, -1);
+
+        // Draw the body parts
+        graphics.drawImage(face, 4, 0, null);
+        graphics.drawImage(body, 4, 8, null);
+        graphics.drawImage(leftArm, skin.getModel() == Skin.Model.SLIM ? 1 : 0, 8, null);
+        graphics.drawImage(rightArm, 12, 8, null);
+        graphics.drawImage(leftLeg, 8, 20, null);
+        graphics.drawImage(rightLeg, 4, 20, null);
+
+        graphics.dispose();
+        return ImageUtils.resize(texture, (double) size / 32);
+    }
+}
--- a/src/main/java/cc/fascinated/common/renderer/impl/IsometricHeadRenderer.java
+++ b/src/main/java/cc/fascinated/common/renderer/impl/IsometricHeadRenderer.java
@ -0,0 +1,48 @@
+package cc.fascinated.common.renderer.impl;
+
+import cc.fascinated.common.renderer.IsometricSkinRenderer;
+import cc.fascinated.model.skin.ISkinPart;
+import cc.fascinated.model.skin.Skin;
+
+import java.awt.*;
+import java.awt.geom.AffineTransform;
+import java.awt.image.BufferedImage;
+
+public class IsometricHeadRenderer extends IsometricSkinRenderer<ISkinPart.Custom> {
+    public static final IsometricHeadRenderer INSTANCE = new IsometricHeadRenderer();
+
+    private static final double SKEW_A = 26D / 45D;   // 0.57777777
+    private static final double SKEW_B = SKEW_A * 2D; // 1.15555555
+
+    private static final AffineTransform HEAD_TOP_TRANSFORM = new AffineTransform(1D, -SKEW_A, 1, SKEW_A, 0, 0);
+    private static final AffineTransform FACE_TRANSFORM = new AffineTransform(1D, -SKEW_A, 0D, SKEW_B, 0d, SKEW_A);
+    private static final AffineTransform HEAD_LEFT_TRANSFORM = new AffineTransform(1D, SKEW_A, 0D, SKEW_B, 0D, 0D);
+
+    @Override
+    public BufferedImage render(Skin skin, ISkinPart.Custom part, boolean renderOverlays, int size) {
+        double scale = (size / 8D) / 2.5;
+        double zOffset = scale * 3.5D;
+        double xOffset = scale * 2D;
+
+        BufferedImage texture = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB); // The texture to return
+        Graphics2D graphics = texture.createGraphics(); // Create the graphics for drawing
+
+        // Get the Vanilla skin parts to draw
+        BufferedImage headTop = getVanillaSkinPart(skin, ISkinPart.Vanilla.HEAD_TOP, scale);
+        BufferedImage face = getVanillaSkinPart(skin, ISkinPart.Vanilla.FACE, scale);
+        BufferedImage headLeft = getVanillaSkinPart(skin, ISkinPart.Vanilla.HEAD_LEFT, scale);
+
+        // Draw the top head part
+        drawPart(graphics, headTop, HEAD_TOP_TRANSFORM, -0.5 - zOffset, xOffset + zOffset, headTop.getWidth(), headTop.getHeight() + 2);
+
+        // Draw the face part
+        double x = xOffset + 8 * scale;
+        drawPart(graphics, face, FACE_TRANSFORM, x, x + zOffset - 0.5, face.getWidth(), face.getHeight());
+
+        // Draw the left head part
+        drawPart(graphics, headLeft, HEAD_LEFT_TRANSFORM, xOffset + 1, zOffset - 0.5, headLeft.getWidth(), headLeft.getHeight());
+
+        graphics.dispose();
+        return texture;
+    }
+}
--- a/src/main/java/cc/fascinated/common/renderer/impl/SquareRenderer.java
+++ b/src/main/java/cc/fascinated/common/renderer/impl/SquareRenderer.java
@ -0,0 +1,39 @@
+package cc.fascinated.common.renderer.impl;
+
+import cc.fascinated.common.renderer.SkinRenderer;
+import cc.fascinated.model.skin.ISkinPart;
+import cc.fascinated.model.skin.Skin;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.extern.log4j.Log4j2;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+
+@AllArgsConstructor @Getter @Log4j2
+public class SquareRenderer extends SkinRenderer<ISkinPart.Vanilla> {
+    public static final SquareRenderer INSTANCE = new SquareRenderer();
+
+    @Override
+    public BufferedImage render(Skin skin, ISkinPart.Vanilla part, boolean renderOverlays, int size) {
+        double scale = size / 8D;
+        BufferedImage partImage = getVanillaSkinPart(skin, part, scale); // Get the part image
+        if (!renderOverlays) { // Not rendering overlays
+            return partImage;
+        }
+        // Create a new image, draw our skin part texture, and then apply overlays
+        BufferedImage texture = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB); // The texture to return
+        Graphics2D graphics = texture.createGraphics(); // Create the graphics for drawing
+        graphics.drawImage(partImage, 0, 0, null);
+
+        // Draw part overlays
+        ISkinPart.Vanilla[] overlayParts = part.getOverlays();
+        if (overlayParts != null) {
+            for (ISkinPart.Vanilla overlay : overlayParts) {
+                applyOverlay(graphics, getVanillaSkinPart(skin, overlay, scale));
+            }
+        }
+        graphics.dispose();
+        return texture;
+    }
+}
--- a/src/main/java/cc/fascinated/config/Config.java
+++ b/src/main/java/cc/fascinated/config/Config.java
@ -0,0 +1,34 @@
+package cc.fascinated.config;
+
+import jakarta.annotation.PostConstruct;
+import lombok.Getter;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+
+@Getter @Log4j2
+@Configuration
+public class Config {
+    public static Config INSTANCE;
+
+    @Autowired
+    private Environment environment;
+
+    @Value("${public-url}")
+    private String webPublicUrl;
+
+    /**
+     * Whether the server is in production mode.
+     */
+    private boolean production = false;
+
+    @PostConstruct
+    public void onInitialize() {
+        INSTANCE = this;
+        String environmentProperty = environment.getProperty("ENVIRONMENT", "development");
+        production = environmentProperty.equalsIgnoreCase("production"); // Set the production mode
+        log.info("Server is running in {} mode", production ? "production" : "development");
+    }
+}
--- a/src/main/java/cc/fascinated/config/OpenAPIConfiguration.java
+++ b/src/main/java/cc/fascinated/config/OpenAPIConfiguration.java
@ -0,0 +1,47 @@
+package cc.fascinated.config;
+
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Contact;
+import io.swagger.v3.oas.models.info.Info;
+import io.swagger.v3.oas.models.info.License;
+import io.swagger.v3.oas.models.servers.Server;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.info.BuildProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.List;
+
+@Configuration
+public class OpenAPIConfiguration {
+    /**
+     * The build properties of the
+     * app, null if the app is not built.
+     */
+    private final BuildProperties buildProperties;
+
+    @Autowired
+    public OpenAPIConfiguration(BuildProperties buildProperties) {
+        this.buildProperties = buildProperties;
+    }
+
+    @Bean
+    public OpenAPI defineOpenAPI() {
+        Server server = new Server();
+        server.setUrl(Config.INSTANCE.getWebPublicUrl());
+
+        Contact contact = new Contact();
+        contact.setName("Liam");
+        contact.setEmail("liam@fascinated.cc");
+        contact.setUrl("https://fascinated.cc");
+
+        Info info = new Info();
+        info.setTitle("Minecraft Utilities API");
+        info.setVersion(buildProperties == null ? "N/A" : buildProperties.getVersion());
+        info.setDescription("Wrapper for the Minecraft APIs to make them easier to use.");
+        info.setContact(contact);
+        info.setLicense(new License().name("MIT License").url("https://opensource.org/licenses/MIT"));
+
+        return new OpenAPI().servers(List.of(server)).info(info);
+    }
+ }
--- a/src/main/java/cc/fascinated/config/RedisConfig.java
+++ b/src/main/java/cc/fascinated/config/RedisConfig.java
@ -0,0 +1,73 @@
+package cc.fascinated.config;
+
+import lombok.NonNull;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+
+/**
+ * @author Braydon
+ */
+@Configuration
+@Log4j2(topic = "Redis")
+public class RedisConfig {
+    /**
+     * The Redis server host.
+     */
+    @Value("${spring.data.redis.host}")
+    private String host;
+
+    /**
+     * The Redis server port.
+     */
+    @Value("${spring.data.redis.port}")
+    private int port;
+
+    /**
+     * The Redis database index.
+     */
+    @Value("${spring.data.redis.database}")
+    private int database;
+
+    /**
+     * The optional Redis password.
+     */
+    @Value("${spring.data.redis.auth}")
+    private String auth;
+
+    /**
+     * Build the config to use for Redis.
+     *
+     * @return the config
+     * @see RedisTemplate for config
+     */
+    @Bean @NonNull
+    public RedisTemplate<String, Object> redisTemplate() {
+        RedisTemplate<String, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(jedisConnectionFactory());
+        return template;
+    }
+
+    /**
+     * Build the connection factory to use
+     * when making connections to Redis.
+     *
+     * @return the built factory
+     * @see JedisConnectionFactory for factory
+     */
+    @Bean @NonNull
+    public JedisConnectionFactory jedisConnectionFactory() {
+        log.info("Connecting to Redis at {}:{}/{}", host, port, database);
+        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration(host, port);
+        config.setDatabase(database);
+        if (!auth.trim().isEmpty()) { // Auth with our provided password
+            log.info("Using auth...");
+            config.setPassword(auth);
+        }
+        return new JedisConnectionFactory(config);
+    }
+}
--- a/src/main/java/cc/fascinated/controller/HomeController.java
+++ b/src/main/java/cc/fascinated/controller/HomeController.java
@ -0,0 +1,25 @@
+package cc.fascinated.controller;
+
+import cc.fascinated.config.Config;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@Controller
+@RequestMapping(value = "/")
+public class HomeController {
+
+    /**
+     * The example UUID.
+     */
+    private final String exampleUuid = "eeab5f8a-18dd-4d58-af78-2b3c4543da48";
+    private final String exampleServer = "aetheria.cc";
+
+    @RequestMapping(value = "/")
+    public String home(Model model) {
+        model.addAttribute("player_example_url", Config.INSTANCE.getWebPublicUrl() + "/player/" + exampleUuid);
+        model.addAttribute("java_server_example_url", Config.INSTANCE.getWebPublicUrl() + "/server/java/" + exampleServer);
+        model.addAttribute("swagger_url", Config.INSTANCE.getWebPublicUrl() + "/swagger-ui.html");
+        return "index";
+    }
+}
--- a/src/main/java/cc/fascinated/controller/PlayerController.java
+++ b/src/main/java/cc/fascinated/controller/PlayerController.java
@ -0,0 +1,64 @@
+package cc.fascinated.controller;
+
+import cc.fascinated.model.cache.CachedPlayer;
+import cc.fascinated.model.cache.CachedPlayerName;
+import cc.fascinated.model.skin.Skin;
+import cc.fascinated.service.PlayerService;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.CacheControl;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.concurrent.TimeUnit;
+
+@RestController
+@Tag(name = "Player Controller", description = "The Player Controller is used to get information about a player.")
+@RequestMapping(value = "/player/")
+public class PlayerController {
+
+    private final CacheControl cacheControl = CacheControl.maxAge(1, TimeUnit.HOURS).cachePublic();
+    private final PlayerService playerService;
+
+    @Autowired
+    public PlayerController(PlayerService playerManagerService) {
+        this.playerService = playerManagerService;
+    }
+
+    @ResponseBody
+    @GetMapping(value = "/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<?> getPlayer(
+            @Parameter(description = "The UUID or Username of the player", example = "ImFascinated") @PathVariable String id) {
+        return ResponseEntity.ok()
+                .cacheControl(cacheControl)
+                .body(playerService.getPlayer(id));
+    }
+
+    @ResponseBody
+    @GetMapping(value = "/uuid/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
+    public CachedPlayerName getPlayerUuid(
+            @Parameter(description = "The UUID or Username of the player", example = "ImFascinated") @PathVariable String id) {
+        return playerService.usernameToUuid(id);
+    }
+
+    @GetMapping(value = "/{part}/{id}")
+    public ResponseEntity<?> getPlayerHead(
+            @Parameter(description = "The part of the skin", example = "head") @PathVariable String part,
+            @Parameter(description = "The UUID or Username of the player", example = "ImFascinated") @PathVariable String id,
+            @Parameter(description = "The size of the image", example = "256") @RequestParam(required = false, defaultValue = "256") int size,
+            @Parameter(description = "Whether to render the skin overlay (skin layers)", example = "false") @RequestParam(required = false, defaultValue = "false") boolean overlay,
+            @Parameter(description = "Whether to download the image") @RequestParam(required = false, defaultValue = "false") boolean download) {
+        CachedPlayer player = playerService.getPlayer(id);
+        String dispositionHeader = download ? "attachment; filename=%s.png" : "inline; filename=%s.png";
+
+        // Return the part image
+        return ResponseEntity.ok()
+                .cacheControl(cacheControl)
+                .contentType(MediaType.IMAGE_PNG)
+                .header(HttpHeaders.CONTENT_DISPOSITION, dispositionHeader.formatted(player.getUsername()))
+                .body(playerService.getSkinPart(player, part, overlay, size).getBytes());
+    }
+}
--- a/src/main/java/cc/fascinated/controller/ServerController.java
+++ b/src/main/java/cc/fascinated/controller/ServerController.java
@ -0,0 +1,59 @@
+package cc.fascinated.controller;
+
+import cc.fascinated.model.cache.CachedMinecraftServer;
+import cc.fascinated.service.MojangService;
+import cc.fascinated.service.ServerService;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+@RestController
+@Tag(name = "Server Controller", description = "The Server Controller is used to get information about a server.")
+@RequestMapping(value = "/server/")
+public class ServerController {
+
+    private final ServerService serverService;
+    private final MojangService mojangService;
+
+    @Autowired
+    public ServerController(ServerService serverService, MojangService mojangService) {
+        this.serverService = serverService;
+        this.mojangService = mojangService;
+    }
+
+    @ResponseBody
+    @GetMapping(value = "/{platform}/{hostname}", produces = MediaType.APPLICATION_JSON_VALUE)
+    public CachedMinecraftServer getServer(
+            @Parameter(description = "The platform of the server", example = "java") @PathVariable String platform,
+            @Parameter(description = "The hostname and port of the server", example = "aetheria.cc") @PathVariable String hostname) {
+        return serverService.getServer(platform, hostname);
+    }
+
+    @ResponseBody
+    @GetMapping(value = "/icon/{hostname}", produces = MediaType.IMAGE_PNG_VALUE)
+    public ResponseEntity<?> getServerIcon(
+            @Parameter(description = "The hostname and port of the server", example = "aetheria.cc") @PathVariable String hostname,
+            @Parameter(description = "Whether to download the image") @RequestParam(required = false, defaultValue = "false") boolean download) {
+        String dispositionHeader = download ? "attachment; filename=%s.png" : "inline; filename=%s.png";
+
+        return ResponseEntity.ok()
+                .contentType(MediaType.IMAGE_PNG)
+                .header(HttpHeaders.CONTENT_DISPOSITION, dispositionHeader.formatted(hostname))
+                .body(serverService.getServerFavicon(hostname));
+    }
+
+    @ResponseBody
+    @GetMapping(value = "/blocked/{hostname}", produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<?> getServerBlockedStatus(
+            @Parameter(description = "The hostname of the server", example = "aetheria.cc") @PathVariable String hostname) {
+        return ResponseEntity.ok(Map.of(
+                "blocked", mojangService.isServerBlocked(hostname)
+        ));
+    }
+}
--- a/src/main/java/cc/fascinated/exception/ExceptionControllerAdvice.java
+++ b/src/main/java/cc/fascinated/exception/ExceptionControllerAdvice.java
@ -0,0 +1,45 @@
+package cc.fascinated.exception;
+
+import cc.fascinated.model.response.ErrorResponse;
+import io.micrometer.common.lang.NonNull;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.servlet.resource.NoResourceFoundException;
+
+@ControllerAdvice
+public final class ExceptionControllerAdvice {
+
+    /**
+     * Handle a raised exception.
+     *
+     * @param ex the raised exception
+     * @return the error response
+     */
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<?> handleException(@NonNull Exception ex) {
+        HttpStatus status = null; // Get the HTTP status
+        if (ex instanceof NoResourceFoundException) { // Not found
+            status = HttpStatus.NOT_FOUND;
+        } else if (ex instanceof UnsupportedOperationException) { // Not implemented
+            status = HttpStatus.NOT_IMPLEMENTED;
+        }
+        if (ex.getClass().isAnnotationPresent(ResponseStatus.class)) { // Get from the @ResponseStatus annotation
+            status = ex.getClass().getAnnotation(ResponseStatus.class).value();
+        }
+        String message = ex.getLocalizedMessage(); // Get the error message
+        if (message == null) { // Fallback
+            message = "An internal error has occurred.";
+        }
+        // Print the stack trace if no response status is present
+        if (status == null) {
+            ex.printStackTrace();
+        }
+        if (status == null) { // Fallback to 500
+            status = HttpStatus.INTERNAL_SERVER_ERROR;
+        }
+        return new ResponseEntity<>(new ErrorResponse(status, message), status);
+    }
+}
--- a/src/main/java/cc/fascinated/exception/impl/BadRequestException.java
+++ b/src/main/java/cc/fascinated/exception/impl/BadRequestException.java
@ -0,0 +1,12 @@
+package cc.fascinated.exception.impl;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@ResponseStatus(HttpStatus.BAD_REQUEST)
+public class BadRequestException extends RuntimeException {
+
+    public BadRequestException(String message) {
+        super(message);
+    }
+}
--- a/src/main/java/cc/fascinated/exception/impl/MojangAPIRateLimitException.java
+++ b/src/main/java/cc/fascinated/exception/impl/MojangAPIRateLimitException.java
@ -0,0 +1,9 @@
+package cc.fascinated.exception.impl;
+
+
+public class MojangAPIRateLimitException extends RateLimitException {
+
+    public MojangAPIRateLimitException() {
+        super("Mojang API rate limit exceeded. Please try again later.");
+    }
+}
--- a/src/main/java/cc/fascinated/exception/impl/RateLimitException.java
+++ b/src/main/java/cc/fascinated/exception/impl/RateLimitException.java
@ -0,0 +1,12 @@
+package cc.fascinated.exception.impl;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@ResponseStatus(HttpStatus.TOO_MANY_REQUESTS)
+public class RateLimitException extends RuntimeException {
+
+    public RateLimitException(String message) {
+        super(message);
+    }
+}
--- a/src/main/java/cc/fascinated/exception/impl/ResourceNotFoundException.java
+++ b/src/main/java/cc/fascinated/exception/impl/ResourceNotFoundException.java
@ -0,0 +1,9 @@
+package cc.fascinated.exception.impl;
+
+import lombok.experimental.StandardException;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@StandardException
+@ResponseStatus(HttpStatus.NOT_FOUND)
+public class ResourceNotFoundException extends RuntimeException { }
--- a/src/main/java/cc/fascinated/log/TransactionLogger.java
+++ b/src/main/java/cc/fascinated/log/TransactionLogger.java
@ -0,0 +1,78 @@
+package cc.fascinated.log;
+
+import cc.fascinated.common.IPUtils;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.NonNull;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.core.MethodParameter;
+import org.springframework.http.MediaType;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.http.server.ServerHttpRequest;
+import org.springframework.http.server.ServerHttpResponse;
+import org.springframework.http.server.ServletServerHttpRequest;
+import org.springframework.http.server.ServletServerHttpResponse;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
+
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+@ControllerAdvice
+@Slf4j(topic = "Req/Res Transaction")
+public class TransactionLogger implements ResponseBodyAdvice<Object> {
+    @Override
+    public Object beforeBodyWrite(Object body, @NonNull MethodParameter returnType, @NonNull MediaType selectedContentType,
+                                  @NonNull Class<? extends HttpMessageConverter<?>> selectedConverterType, @NonNull ServerHttpRequest rawRequest,
+                                  @NonNull ServerHttpResponse rawResponse) {
+        HttpServletRequest request = ((ServletServerHttpRequest) rawRequest).getServletRequest();
+        HttpServletResponse response = ((ServletServerHttpResponse) rawResponse).getServletResponse();
+
+        // Get the request ip ip
+        String ip = IPUtils.getRealIp(request);
+
+        // Getting params
+        Map<String, String> params = new HashMap<>();
+        for (Entry<String, String[]> entry : request.getParameterMap().entrySet()) {
+            params.put(entry.getKey(), Arrays.toString(entry.getValue()));
+        }
+
+        // Getting headers
+        Map<String, String> headers = new HashMap<>();
+        Enumeration<String> headerNames = request.getHeaderNames();
+        while (headerNames.hasMoreElements()) {
+            String headerName = headerNames.nextElement();
+            headers.put(headerName, request.getHeader(headerName));
+        }
+
+        // Log the request
+        log.info(String.format("[Req] %s | %s | '%s', params=%s, headers=%s",
+                request.getMethod(),
+                ip,
+                request.getRequestURI(),
+                params,
+                headers
+        ));
+
+        // Getting response headers
+        headers = new HashMap<>();
+        for (String headerName : response.getHeaderNames()) {
+            headers.put(headerName, response.getHeader(headerName));
+        }
+
+        // Log the response
+        log.info(String.format("[Res] %s, headers=%s",
+                response.getStatus(),
+                headers
+        ));
+        return body;
+    }
+
+    @Override
+    public boolean supports(@NonNull MethodParameter returnType, @NonNull Class<? extends HttpMessageConverter<?>> converterType) {
+        return true;
+    }
+}
--- a/src/main/java/cc/fascinated/model/cache/CachedMinecraftServer.java
+++ b/src/main/java/cc/fascinated/model/cache/CachedMinecraftServer.java
@ -0,0 +1,34 @@
+package cc.fascinated.model.cache;
+
+import cc.fascinated.model.server.MinecraftServer;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.*;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.redis.core.RedisHash;
+
+import java.io.Serializable;
+
+/**
+ * @author Braydon
+ */
+@AllArgsConstructor @Setter @Getter @ToString
+@RedisHash(value = "server", timeToLive = 60L) // 1 minute (in seconds)
+public final class CachedMinecraftServer implements Serializable {
+    /**
+     * The id of this cached server.
+     */
+    @Id @NonNull @JsonIgnore
+    private final String id;
+
+    /**
+     * The cached server.
+     */
+    @NonNull
+    private final MinecraftServer server;
+
+    /**
+     * The unix timestamp of when this
+     * server was cached, -1 if not cached.
+     */
+    private long cached;
+}
--- a/src/main/java/cc/fascinated/model/cache/CachedPlayer.java
+++ b/src/main/java/cc/fascinated/model/cache/CachedPlayer.java
@ -0,0 +1,34 @@
+package cc.fascinated.model.cache;
+
+import cc.fascinated.model.mojang.MojangProfile;
+import cc.fascinated.model.player.Cape;
+import cc.fascinated.model.player.Player;
+import cc.fascinated.model.skin.Skin;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import org.springframework.data.redis.core.RedisHash;
+
+import java.io.Serializable;
+import java.util.UUID;
+
+/**
+ * A cacheable {@link Player}.
+ *
+ * @author Braydon
+ */
+@Setter @Getter
+@ToString(callSuper = true)
+@RedisHash(value = "player", timeToLive = 60L * 60L) // 1 hour (in seconds)
+public final class CachedPlayer extends Player implements Serializable {
+    /**
+     * The unix timestamp of when this
+     * player was cached, -1 if not cached.
+     */
+    private long cached;
+
+    public CachedPlayer(UUID uniqueId, String trimmedUniqueId, String username, Skin skin, Cape cape, MojangProfile.ProfileProperty[] rawProperties, long cached) {
+        super(uniqueId, trimmedUniqueId, username, skin, cape, rawProperties);
+        this.cached = cached;
+    }
+}
--- a/src/main/java/cc/fascinated/model/cache/CachedPlayerName.java
+++ b/src/main/java/cc/fascinated/model/cache/CachedPlayerName.java
@ -0,0 +1,27 @@
+package cc.fascinated.model.cache;
+
+import lombok.*;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.redis.core.RedisHash;
+
+import java.util.UUID;
+
+/**
+ * @author Braydon
+ */
+@AllArgsConstructor
+@Getter
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
+@ToString
+@RedisHash(value = "playerName", timeToLive = 60L * 60L) // 1 hour (in seconds)
+public final class CachedPlayerName {
+    /**
+     * The username of the player.
+     */
+    @Id @NonNull private String username;
+
+    /**
+     * The unique id of the player.
+     */
+    @NonNull private UUID uniqueId;
+}
--- a/src/main/java/cc/fascinated/model/cache/CachedPlayerSkinPart.java
+++ b/src/main/java/cc/fascinated/model/cache/CachedPlayerSkinPart.java
@ -0,0 +1,25 @@
+package cc.fascinated.model.cache;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.Setter;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.redis.core.RedisHash;
+
+@Setter
+@Getter
+@AllArgsConstructor
+@RedisHash(value = "player", timeToLive = 60L * 60L) // 1 hour (in seconds)
+public class CachedPlayerSkinPart {
+
+    /**
+     * The ID of the skin part
+     */
+    @Id @NonNull private String id;
+
+    /**
+     * The skin part bytes
+     */
+    private byte[] bytes;
+}
--- a/src/main/java/cc/fascinated/model/dns/DNSRecord.java
+++ b/src/main/java/cc/fascinated/model/dns/DNSRecord.java
@ -0,0 +1,29 @@
+package cc.fascinated.model.dns;
+
+import io.micrometer.common.lang.NonNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Setter @Getter
+@NoArgsConstructor @AllArgsConstructor
+public abstract class DNSRecord {
+    /**
+     * The type of this record.
+     */
+    @NonNull
+    private Type type;
+
+    /**
+     * The TTL (Time To Live) of this record.
+     */
+    private long ttl;
+
+    /**
+     * Types of a record.
+     */
+    public enum Type {
+        A, SRV
+    }
+}
--- a/src/main/java/cc/fascinated/model/dns/impl/ARecord.java
+++ b/src/main/java/cc/fascinated/model/dns/impl/ARecord.java
@ -0,0 +1,24 @@
+package cc.fascinated.model.dns.impl;
+
+import cc.fascinated.model.dns.DNSRecord;
+import io.micrometer.common.lang.NonNull;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.net.InetAddress;
+
+@Setter @Getter
+@NoArgsConstructor
+public final class ARecord extends DNSRecord {
+    /**
+     * The address of this record, null if unresolved.
+     */
+    private String address;
+
+    public ARecord(@NonNull org.xbill.DNS.ARecord bootstrap) {
+        super(Type.A, bootstrap.getTTL());
+        InetAddress address = bootstrap.getAddress();
+        this.address = address == null ? null : address.getHostAddress();
+    }
+}
--- a/src/main/java/cc/fascinated/model/dns/impl/SRVRecord.java
+++ b/src/main/java/cc/fascinated/model/dns/impl/SRVRecord.java
@ -0,0 +1,53 @@
+package cc.fascinated.model.dns.impl;
+
+import cc.fascinated.model.dns.DNSRecord;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import io.micrometer.common.lang.NonNull;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.net.InetSocketAddress;
+
+@Setter @Getter
+@NoArgsConstructor
+public final class SRVRecord extends DNSRecord {
+    /**
+     * The priority of this record.
+     */
+    private int priority;
+
+    /**
+     * The weight of this record.
+     */
+    private int weight;
+
+    /**
+     * The port of this record.
+     */
+    private int port;
+
+    /**
+     * The target of this record.
+     */
+    @NonNull private String target;
+
+    public SRVRecord(@NonNull org.xbill.DNS.SRVRecord bootstrap) {
+        super(Type.SRV, bootstrap.getTTL());
+        priority = bootstrap.getPriority();
+        weight = bootstrap.getWeight();
+        port = bootstrap.getPort();
+        target = bootstrap.getTarget().toString().replaceFirst("\\.$", "");
+    }
+
+    /**
+     * Get a socket address from
+     * the target and port.
+     *
+     * @return the socket address
+     */
+    @NonNull @JsonIgnore
+    public InetSocketAddress getSocketAddress() {
+        return new InetSocketAddress(target, port);
+    }
+}
--- a/src/main/java/cc/fascinated/model/mojang/MojangProfile.java
+++ b/src/main/java/cc/fascinated/model/mojang/MojangProfile.java
@ -0,0 +1,108 @@
+package cc.fascinated.model.mojang;
+
+import cc.fascinated.Main;
+import cc.fascinated.common.Tuple;
+import cc.fascinated.common.UUIDUtils;
+import cc.fascinated.model.player.Cape;
+import cc.fascinated.model.skin.Skin;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.google.gson.JsonObject;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.Base64;
+
+@Getter @NoArgsConstructor @AllArgsConstructor
+public class MojangProfile {
+
+    /**
+     * The UUID of the player.
+     */
+    private String id;
+
+    /**
+     * The name of the player.
+     */
+    private String name;
+
+    /**
+     * The properties of the player.
+     */
+    private ProfileProperty[] properties = new ProfileProperty[0];
+    
+    /**
+     * Get the skin and cape of the player.
+     *
+     * @return the skin and cape of the player
+     */
+    public Tuple<Skin, Cape> getSkinAndCape() {
+        ProfileProperty textureProperty = getProfileProperty("textures");
+        if (textureProperty == null) {
+            return null;
+        }
+        JsonObject texturesJson = textureProperty.getDecodedValue().getAsJsonObject("textures"); // Parse the decoded JSON and get the texture object
+        return new Tuple<>(Skin.fromJson(texturesJson.getAsJsonObject("SKIN")).populatePartUrls(this.getFormattedUuid()),
+                Cape.fromJson(texturesJson.getAsJsonObject("CAPE")));
+    }
+
+    /**
+     * Gets the formatted UUID of the player.
+     *
+     * @return the formatted UUID
+     */
+    public String getFormattedUuid() {
+        return id.length() == 32 ? UUIDUtils.addDashes(id).toString() : id;
+    }
+    
+    /**
+     * Get a profile property for the player
+     *
+     * @return the profile property
+     */
+    public ProfileProperty getProfileProperty(String name) {
+        for (ProfileProperty property : properties) {
+            if (property.getName().equals(name)) {
+                return property;
+            }
+        }
+        return null;
+    }
+
+    @Getter @NoArgsConstructor
+    public static class ProfileProperty {
+        /**
+         * The name of the property.
+         */
+        private String name;
+
+        /**
+         * The base64 value of the property.
+         */
+        private String value;
+
+        /**
+         * The signature of the property.
+         */
+        private String signature;
+
+        /**
+         * Decodes the value for this property.
+         *
+         * @return the decoded value
+         */
+        @JsonIgnore
+        public JsonObject getDecodedValue() {
+            return Main.GSON.fromJson(new String(Base64.getDecoder().decode(this.value)), JsonObject.class);
+        }
+
+        /**
+         * Check if the property is signed.
+         *
+         * @return true if the property is signed, false otherwise
+         */
+        public boolean isSigned() {
+            return signature != null;
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/model/mojang/MojangUsernameToUuid.java
+++ b/src/main/java/cc/fascinated/model/mojang/MojangUsernameToUuid.java
@ -0,0 +1,30 @@
+package cc.fascinated.model.mojang;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter @NoArgsConstructor
+public class MojangUsernameToUuid {
+
+    /**
+     * The UUID of the player.
+     */
+    @JsonProperty("id")
+    private String uuid;
+
+    /**
+     * The name of the player.
+     */
+    @JsonProperty("name")
+    private String username;
+
+    /**
+     * Check if the profile is valid.
+     *
+     * @return if the profile is valid
+     */
+    public boolean isValid() {
+        return uuid != null && username != null;
+    }
+}
--- a/src/main/java/cc/fascinated/model/player/Cape.java
+++ b/src/main/java/cc/fascinated/model/player/Cape.java
@ -0,0 +1,27 @@
+package cc.fascinated.model.player;
+
+import com.google.gson.JsonObject;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter @AllArgsConstructor
+public class Cape {
+
+    /**
+     * The URL of the cape
+     */
+    private final String url;
+
+    /**
+     * Gets the cape from a {@link JsonObject}.
+     *
+     * @param json the JSON object
+     * @return the cape
+     */
+    public static Cape fromJson(JsonObject json) {
+        if (json == null) {
+            return null;
+        }
+        return new Cape(json.get("url").getAsString());
+    }
+}
--- a/src/main/java/cc/fascinated/model/player/Player.java
+++ b/src/main/java/cc/fascinated/model/player/Player.java
@ -0,0 +1,61 @@
+package cc.fascinated.model.player;
+
+import cc.fascinated.common.Tuple;
+import cc.fascinated.common.UUIDUtils;
+import cc.fascinated.model.mojang.MojangProfile;
+import cc.fascinated.model.skin.Skin;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.springframework.data.annotation.Id;
+
+import java.util.UUID;
+
+@Getter @AllArgsConstructor
+public class Player {
+
+    /**
+     * The UUID of the player
+     */
+    @Id private final UUID uniqueId;
+
+    /**
+     * The trimmed UUID of the player
+     */
+    private final String trimmedUniqueId;
+
+    /**
+     * The username of the player
+     */
+    private final String username;
+
+    /**
+     * The skin of the player, null if the
+     * player does not have a skin
+     */
+    private Skin skin;
+
+    /**
+     * The cape of the player, null if the
+     * player does not have a cape
+     */
+    private Cape cape;
+
+    /**
+     * The raw properties of the player
+     */
+    private MojangProfile.ProfileProperty[] rawProperties;
+
+    public Player(MojangProfile profile) {
+        this.uniqueId = UUIDUtils.addDashes(profile.getId());
+        this.trimmedUniqueId = UUIDUtils.removeDashes(this.uniqueId);
+        this.username = profile.getName();
+        this.rawProperties = profile.getProperties();
+
+        // Get the skin and cape
+        Tuple<Skin, Cape> skinAndCape = profile.getSkinAndCape();
+        if (skinAndCape != null) {
+            this.skin = skinAndCape.getLeft();
+            this.cape = skinAndCape.getRight();
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/model/response/ErrorResponse.java
+++ b/src/main/java/cc/fascinated/model/response/ErrorResponse.java
@ -0,0 +1,40 @@
+package cc.fascinated.model.response;
+
+import io.micrometer.common.lang.NonNull;
+import lombok.Getter;
+import lombok.ToString;
+import org.springframework.http.HttpStatus;
+
+import java.util.Date;
+
+@Getter
+@ToString
+public class ErrorResponse {
+    /**
+     * The status code of this error.
+     */
+    @NonNull
+    private final HttpStatus status;
+
+    /**
+     * The HTTP code of this error.
+     */
+    private final int code;
+
+    /**
+     * The message of this error.
+     */
+    @NonNull private final String message;
+
+    /**
+     * The timestamp this error occurred.
+     */
+    @NonNull private final Date timestamp;
+
+    public ErrorResponse(@NonNull HttpStatus status, @NonNull String message) {
+        this.status = status;
+        code = status.value();
+        this.message = message;
+        timestamp = new Date();
+    }
+}
--- a/src/main/java/cc/fascinated/model/server/BedrockMinecraftServer.java
+++ b/src/main/java/cc/fascinated/model/server/BedrockMinecraftServer.java
@ -0,0 +1,121 @@
+package cc.fascinated.model.server;
+
+import cc.fascinated.model.dns.DNSRecord;
+import lombok.*;
+
+/**
+ * A Bedrock edition {@link MinecraftServer}.
+ *
+ * @author Braydon
+ */
+@Getter @ToString(callSuper = true) @EqualsAndHashCode(onlyExplicitlyIncluded = true, callSuper = true)
+public final class BedrockMinecraftServer extends MinecraftServer {
+    /**
+     * The unique ID of this server.
+     */
+    @EqualsAndHashCode.Include @NonNull private final String id;
+
+    /**
+     * The edition of this server.
+     */
+    @NonNull private final Edition edition;
+
+    /**
+     * The version information of this server.
+     */
+    @NonNull private final Version version;
+
+    /**
+     * The gamemode of this server.
+     */
+    @NonNull private final GameMode gamemode;
+
+    private BedrockMinecraftServer(@NonNull String id, @NonNull String hostname, String ip, int port, @NonNull DNSRecord[] records,
+                                   @NonNull Edition edition, @NonNull Version version, @NonNull Players players, @NonNull MOTD motd,
+                                   @NonNull GameMode gamemode) {
+        super(hostname, ip, port, records, motd, players);
+        this.id = id;
+        this.edition = edition;
+        this.version = version;
+        this.gamemode = gamemode;
+    }
+
+    /**
+     * Create a new Bedrock Minecraft server.
+     *
+     * @param hostname the hostname of the server
+     * @param ip the IP address of the server
+     * @param port the port of the server
+     * @param token the status token
+     * @return the Bedrock Minecraft server
+     */
+    @NonNull
+    public static BedrockMinecraftServer create(@NonNull String hostname, String ip, int port, DNSRecord[] records, @NonNull String token) {
+        String[] split = token.split(";"); // Split the token
+        Edition edition = Edition.valueOf(split[0]);
+        Version version = new Version(Integer.parseInt(split[2]), split[3]);
+        Players players = new Players(Integer.parseInt(split[4]), Integer.parseInt(split[5]), null);
+        MOTD motd = MOTD.create(split[1] + "\n" + split[7]);
+        GameMode gameMode = new GameMode(split[8], Integer.parseInt(split[9]));
+        return new BedrockMinecraftServer(
+                split[6],
+                hostname,
+                ip,
+                port,
+                records,
+                edition,
+                version,
+                players,
+                motd,
+                gameMode
+        );
+    }
+
+    /**
+     * The edition of a Bedrock server.
+     */
+    @AllArgsConstructor @Getter
+    public enum Edition {
+        /**
+         * Minecraft: Pocket Edition.
+         */
+        MCPE,
+
+        /**
+         * Minecraft: Education Edition.
+         */
+        MCEE
+    }
+
+    /**
+     * Version information for a server.
+     */
+    @AllArgsConstructor @Getter @ToString
+    public static class Version {
+        /**
+         * The protocol version of the server.
+         */
+        private final int protocol;
+
+        /**
+         * The version name of the server.
+         */
+        @NonNull private final String name;
+    }
+
+    /**
+     * The gamemode of a server.
+     */
+    @AllArgsConstructor @Getter @ToString
+    public static class GameMode {
+        /**
+         * The name of this gamemode.
+         */
+        @NonNull private final String name;
+
+        /**
+         * The numeric of this gamemode.
+         */
+        private final int numericId;
+    }
+}
--- a/src/main/java/cc/fascinated/model/server/JavaMinecraftServer.java
+++ b/src/main/java/cc/fascinated/model/server/JavaMinecraftServer.java
@ -0,0 +1,271 @@
+package cc.fascinated.model.server;
+
+import cc.fascinated.Main;
+import cc.fascinated.common.JavaMinecraftVersion;
+import cc.fascinated.common.ServerUtils;
+import cc.fascinated.config.Config;
+import cc.fascinated.model.dns.DNSRecord;
+import cc.fascinated.model.token.JavaServerStatusToken;
+import com.google.gson.annotations.SerializedName;
+import lombok.*;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.chat.ComponentSerializer;
+
+/**
+ * @author Braydon
+ */
+@Setter @Getter
+public final class JavaMinecraftServer extends MinecraftServer {
+
+    /**
+     * The version of the server.
+     */
+    @NonNull private final Version version;
+
+    /**
+     * The favicon of the server.
+     */
+    private Favicon favicon;
+
+    /**
+     * The mods running on this server.
+     */
+    private ForgeModInfo modInfo;
+
+    /**
+     * The mods running on this server.
+     * <p>
+     *     This is only used for servers
+     *     running 1.13 and above.
+     * </p>
+     */
+    private ForgeData forgeData;
+
+    /**
+     * Whether the server prevents chat reports.
+     */
+    private boolean preventsChatReports;
+
+    /**
+     * Whether the server enforces secure chat.
+     */
+    private boolean enforcesSecureChat;
+
+    /**
+     * Whether the server has previews chat enabled.
+     * <p>
+     *      Chat Preview sends chat messages to the server as they are typed, even before they're sent.
+     *      <a href="https://www.minecraft.net/es-mx/article/minecraft-snapshot-22w19a">More information</a>
+     * </p>
+     */
+    private boolean previewsChat;
+
+    /**
+     * The mojang blocked status for the server.
+     */
+    private boolean mojangBlocked;
+
+    public JavaMinecraftServer(String hostname, String ip, int port, MOTD motd, Players players, DNSRecord[] records,
+                               @NonNull Version version, Favicon favicon, ForgeModInfo modInfo, ForgeData forgeData,
+                               boolean preventsChatReports, boolean enforcesSecureChat, boolean previewsChat) {
+        super(hostname, ip, port, records, motd, players);
+        this.version = version;
+        this.favicon = favicon;
+        this.modInfo = modInfo;
+        this.forgeData = forgeData;
+        this.preventsChatReports = preventsChatReports;
+        this.enforcesSecureChat = enforcesSecureChat;
+        this.previewsChat = previewsChat;
+    }
+
+    /**
+     * Create a new Java Minecraft server.
+     *
+     * @param hostname the hostname of the server
+     * @param ip the IP address of the server
+     * @param port the port of the server
+     * @param token the status token
+     * @return the Java Minecraft server
+     */
+    @NonNull
+    public static JavaMinecraftServer create(@NonNull String hostname, String ip, int port, DNSRecord[] records, @NonNull JavaServerStatusToken token) {
+        String motdString = token.getDescription() instanceof String ? (String) token.getDescription() : null;
+        if (motdString == null) { // Not a string motd, convert from Json
+            motdString = new TextComponent(ComponentSerializer.parse(Main.GSON.toJson(token.getDescription()))).toLegacyText();
+        }
+        return new JavaMinecraftServer(
+                hostname,
+                ip,
+                port,
+                MinecraftServer.MOTD.create(motdString),
+                token.getPlayers(),
+                records,
+                token.getVersion().detailedCopy(),
+                JavaMinecraftServer.Favicon.create(token.getFavicon(), ServerUtils.getAddress(hostname, port)),
+                token.getModInfo(),
+                token.getForgeData(),
+                token.isPreventsChatReports(),
+                token.isEnforcesSecureChat(),
+                token.isPreviewsChat()
+        );
+    }
+
+    @AllArgsConstructor @Getter
+    public static class Version {
+        /**
+         * The version name of the server.
+         */
+        @NonNull
+        private final String name;
+
+        /**
+         * The server platform.
+         */
+        private String platform;
+
+        /**
+         * The protocol version.
+         */
+        private final int protocol;
+
+        /**
+         * The name of the protocol, null if not found.
+         */
+        private final String protocolName;
+
+        /**
+         * Create a more detailed
+         * copy of this object.
+         *
+         * @return the detailed copy
+         */
+        @NonNull
+        public Version detailedCopy() {
+            String platform = null;
+            if (name.contains(" ")) { // Parse the server platform
+                String[] split = name.split(" ");
+                if (split.length == 2) {
+                    platform = split[0];
+                }
+            }
+            JavaMinecraftVersion minecraftVersion = JavaMinecraftVersion.byProtocol(protocol);
+            return new Version(name, platform, protocol, minecraftVersion == null ? null : minecraftVersion.getName());
+        }
+
+    }
+
+    @Getter @AllArgsConstructor
+    public static class Favicon {
+
+        /**
+         * The raw base64 of the favicon.
+         */
+        private final String base64;
+
+        /**
+         * The url to the favicon.
+         */
+        private String url;
+
+        /**
+         * Create a new favicon for a server.
+         *
+         * @param base64 the base64 of the favicon
+         * @param address the address of the server
+         * @return the new favicon
+         */
+        public static Favicon create(String base64, @NonNull String address) {
+            if (base64 == null) { // The server doesn't have a favicon
+                return null;
+            }
+            return new Favicon(base64, Config.INSTANCE.getWebPublicUrl() + "/server/icon/%s".formatted(address));
+        }
+    }
+
+    /**
+     * Forge mod information for a server.
+     */
+    @AllArgsConstructor @Getter @ToString
+    public static class ForgeModInfo {
+        /**
+         * The type of modded server this is.
+         */
+        @NonNull private final String type;
+
+        /**
+         * The list of mods on this server, null or empty if none.
+         */
+        private final ForgeMod[] modList;
+
+        /**
+         * A forge mod for a server.
+         */
+        @AllArgsConstructor @Getter @ToString
+        private static class ForgeMod {
+            /**
+             * The id of this mod.
+             */
+            @NonNull @SerializedName("modid") private final String name;
+
+            /**
+             * The version of this mod.
+             */
+            private final String version;
+        }
+    }
+
+    @AllArgsConstructor @Getter
+    public static class ForgeData {
+
+        /**
+         * The list of mod channels on this server, null or empty if none.
+         */
+        private final Channel[] channels;
+
+        /**
+         * The list of mods on this server, null or empty if none.
+         */
+        private final Mod[] mods;
+
+        /**
+         * Whether the mod list is truncated.
+         */
+        private final boolean truncated;
+
+        /**
+         * The version of the FML network.
+         */
+        private final int fmlNetworkVersion;
+
+        @AllArgsConstructor @Getter
+        public static class Channel {
+            /**
+             * The id of this mod channel.
+             */
+            @NonNull @SerializedName("res") private final String name;
+
+            /**
+             * The version of this mod channel.
+             */
+            private final String version;
+
+            /**
+             * Whether this mod channel is required to join.
+             */
+            private boolean required;
+        }
+
+        @AllArgsConstructor @Getter
+        public static class Mod {
+            /**
+             * The id of this mod.
+             */
+            @NonNull @SerializedName("modId") private final String name;
+
+            /**
+             * The version of this mod.
+             */
+            @SerializedName("modmarker") private final String version;
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/model/server/MinecraftServer.java
+++ b/src/main/java/cc/fascinated/model/server/MinecraftServer.java
@ -0,0 +1,153 @@
+package cc.fascinated.model.server;
+
+import cc.fascinated.common.ColorUtils;
+import cc.fascinated.model.dns.DNSRecord;
+import cc.fascinated.service.pinger.MinecraftServerPinger;
+import cc.fascinated.service.pinger.impl.BedrockMinecraftServerPinger;
+import cc.fascinated.service.pinger.impl.JavaMinecraftServerPinger;
+import io.micrometer.common.lang.NonNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import java.util.Arrays;
+import java.util.UUID;
+
+/**
+ * @author Braydon
+ */
+@AllArgsConstructor
+@Getter @Setter
+public class MinecraftServer {
+
+    /**
+     * The hostname of the server.
+     */
+    private final String hostname;
+
+    /**
+     * The IP address of the server.
+     */
+    private final String ip;
+
+    /**
+     * The port of the server.
+     */
+    private final int port;
+
+    /**
+     * The DNS records for the server.
+     */
+    private final DNSRecord[] records;
+
+    /**
+     * The motd for the server.
+     */
+    private final MOTD motd;
+
+    /**
+     * The players on the server.
+     */
+    private final Players players;
+
+    /**
+     * A platform a Minecraft
+     * server can operate on.
+     */
+    @AllArgsConstructor @Getter
+    public enum Platform {
+        /**
+         * The Java edition of Minecraft.
+         */
+        JAVA(new JavaMinecraftServerPinger(), 25565),
+
+        /**
+         * The Bedrock edition of Minecraft.
+         */
+        BEDROCK(new BedrockMinecraftServerPinger(), 19132);
+
+        /**
+         * The server pinger for this platform.
+         */
+        @NonNull
+        private final MinecraftServerPinger<?> pinger;
+
+        /**
+         * The default server port for this platform.
+         */
+        private final int defaultPort;
+    }
+
+    @AllArgsConstructor @Getter
+    public static class MOTD {
+
+        /**
+         * The raw motd lines
+         */
+        private final String[] raw;
+
+        /**
+         * The clean motd lines
+         */
+        private final String[] clean;
+
+        /**
+         * The html motd lines
+         */
+        private final String[] html;
+
+        /**
+         * Create a new MOTD from a raw string.
+         *
+         * @param raw the raw motd string
+         * @return the new motd
+         */
+        @NonNull
+        public static MOTD create(@NonNull String raw) {
+            String[] rawLines = raw.split("\n"); // The raw lines
+            return new MOTD(
+                    rawLines,
+                    Arrays.stream(rawLines).map(ColorUtils::stripColor).toArray(String[]::new),
+                    Arrays.stream(rawLines).map(ColorUtils::toHTML).toArray(String[]::new)
+            );
+        }
+    }
+
+    /**
+     * Player count data for a server.
+     */
+    @AllArgsConstructor @Getter
+    public static class Players {
+        /**
+         * The online players on this server.
+         */
+        private final int online;
+
+        /**
+         * The maximum allowed players on this server.
+         */
+        private final int max;
+
+        /**
+         * A sample of players on this server, null or empty if no sample.
+         */
+        private final Sample[] sample;
+
+        /**
+         * A sample player.
+         */
+        @AllArgsConstructor @Getter @ToString
+        public static class Sample {
+            /**
+             * The unique id of this player.
+             */
+            @NonNull private final UUID id;
+
+            /**
+             * The name of this player.
+             */
+            @NonNull private final String name;
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/model/skin/ISkinPart.java
+++ b/src/main/java/cc/fascinated/model/skin/ISkinPart.java
@ -0,0 +1,199 @@
+package cc.fascinated.model.skin;
+
+import cc.fascinated.common.renderer.SkinRenderer;
+import cc.fascinated.common.renderer.impl.BodyRenderer;
+import cc.fascinated.common.renderer.impl.IsometricHeadRenderer;
+import cc.fascinated.common.renderer.impl.SquareRenderer;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.awt.image.BufferedImage;
+
+public interface ISkinPart {
+    Enum<?>[][] TYPES = { Vanilla.values(), Custom.values() };
+
+    /**
+     * The name of the part.
+     *
+     * @return the part name
+     */
+    String name();
+
+    /**
+     * Should this part be hidden from the
+     * player skin part urls list?
+     *
+     * @return whether this part should be hidden
+     */
+    boolean hidden();
+
+    /**
+     * Renders the skin part for the skin.
+     *
+     * @param skin the skin
+     * @param renderOverlays should the overlays be rendered
+     * @param size the size of the part
+     * @return the rendered skin part
+     */
+    BufferedImage render(Skin skin, boolean renderOverlays, int size);
+
+    /**
+     * Get a skin part by the given name.
+     *
+     * @param name the name of the part
+     * @return the part, null if none
+     */
+    static ISkinPart getByName(String name) {
+        name = name.toUpperCase();
+        for (Enum<?>[] type : TYPES) {
+            for (Enum<?> part : type) {
+                if (!part.name().equals(name)) {
+                    continue;
+                }
+                return (ISkinPart) part;
+            }
+        }
+        return null;
+    }
+
+    @Getter
+    enum Vanilla implements ISkinPart {
+        // Overlays
+        HEAD_OVERLAY_FACE(true, new Coordinates(40, 8), 8, 8),
+
+        // Head
+        HEAD_TOP(true, new Coordinates(8, 0), 8, 8),
+        FACE(false, new Coordinates(8, 8), 8, 8, HEAD_OVERLAY_FACE),
+        HEAD_LEFT(true, new Coordinates(0, 8), 8, 8),
+        HEAD_RIGHT(true, new Coordinates(16, 8), 8, 8),
+        HEAD_BOTTOM(true, new Coordinates(16, 0), 8, 8),
+        HEAD_BACK(true, new Coordinates(24, 8), 8, 8),
+
+        // Body
+        BODY_FRONT(true, new Coordinates(20, 20), 8, 12),
+
+        // Arms
+        LEFT_ARM_TOP(true, new Coordinates(36, 48), 4, 4),
+        RIGHT_ARM_TOP(true, new Coordinates(44, 16), 4, 4),
+
+        LEFT_ARM_FRONT(true, new Coordinates(44, 20), 4, 12),
+        RIGHT_ARM_FRONT(true, new Coordinates(36, 52), new LegacyCoordinates(44, 20, true), 4, 12),
+
+        // Legs
+        LEFT_LEG_FRONT(true, new Coordinates(4, 20), 4, 12), // Front
+        RIGHT_LEG_FRONT(true, new Coordinates(20, 52), new LegacyCoordinates(4, 20, true), 4, 12); // Front
+
+        /**
+         * Should this part be hidden from the
+         * player skin part urls list?
+         */
+        private final boolean hidden;
+
+        /**
+         * The coordinates of the part.
+         */
+        private final Coordinates coordinates;
+
+        /**
+         * The legacy coordinates of the part.
+         */
+        private final LegacyCoordinates legacyCoordinates;
+
+        /**
+         * The width and height of the part.
+         */
+        private final int width, height;
+
+        /**
+         * The overlays of the part.
+         */
+        private final Vanilla[] overlays;
+
+        Vanilla(boolean hidden, Coordinates coordinates, int width, int height, Vanilla... overlays) {
+            this(hidden, coordinates, null, width, height, overlays);
+        }
+
+        Vanilla(boolean hidden, Coordinates coordinates, LegacyCoordinates legacyCoordinates, int width, int height, Vanilla... overlays) {
+            this.hidden = hidden;
+            this.coordinates = coordinates;
+            this.legacyCoordinates = legacyCoordinates;
+            this.width = width;
+            this.height = height;
+            this.overlays = overlays;
+        }
+
+        @Override
+        public boolean hidden() {
+            return this.isHidden();
+        }
+
+        @Override
+        public BufferedImage render(Skin skin, boolean renderOverlays, int size) {
+            return SquareRenderer.INSTANCE.render(skin, this, renderOverlays, size);
+        }
+
+        /**
+         * Is this part a front arm?
+         *
+         * @return whether this part is a front arm
+         */
+        public boolean isFrontArm() {
+            return this == LEFT_ARM_FRONT || this == RIGHT_ARM_FRONT;
+        }
+
+        /**
+         * Does this part have legacy coordinates?
+         *
+         * @return whether this part has legacy coordinates
+         */
+        public boolean hasLegacyCoordinates() {
+            return legacyCoordinates != null;
+        }
+
+        @AllArgsConstructor @Getter
+        public static class Coordinates {
+            /**
+             * The X and Y position of the part.
+             */
+            private final int x, y;
+        }
+
+        @Getter
+        public static class LegacyCoordinates extends Coordinates {
+            /**
+             * Should the part be flipped horizontally?
+             */
+            private final boolean flipped;
+
+            public LegacyCoordinates(int x, int y) {
+                this(x, y, false);
+            }
+
+            public LegacyCoordinates(int x, int y, boolean flipped) {
+                super(x, y);
+                this.flipped = flipped;
+            }
+        }
+    }
+
+    @AllArgsConstructor @Getter
+    enum Custom implements ISkinPart {
+        HEAD(IsometricHeadRenderer.INSTANCE),
+        BODY(BodyRenderer.INSTANCE);
+
+        /**
+         * The renderer to use for this part
+         */
+        private final SkinRenderer<Custom> renderer;
+
+        @Override
+        public boolean hidden() {
+            return false;
+        }
+
+        @Override
+        public BufferedImage render(Skin skin, boolean renderOverlays, int size) {
+            return renderer.render(skin, this, renderOverlays, size);
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/model/skin/Skin.java
+++ b/src/main/java/cc/fascinated/model/skin/Skin.java
@ -0,0 +1,128 @@
+package cc.fascinated.model.skin;
+
+import cc.fascinated.common.PlayerUtils;
+import cc.fascinated.config.Config;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.gson.JsonObject;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.extern.log4j.Log4j2;
+
+import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+@AllArgsConstructor @NoArgsConstructor
+@Getter @Log4j2
+public class Skin {
+    /**
+     * The default skin, usually used when the skin is not found.
+     */
+    public static final Skin DEFAULT_SKIN = new Skin("http://textures.minecraft.net/texture/60a5bd016b3c9a1b9272e4929e30827a67be4ebb219017adbbc4a4d22ebd5b1",
+            Model.DEFAULT);
+
+    /**
+     * The URL for the skin
+     */
+    private String url;
+
+    /**
+     * The model for the skin
+     */
+    private Model model;
+
+    /**
+     * The legacy status of the skin
+     */
+    private boolean isLegacy = false;
+
+    /**
+     * The skin image for the skin
+     */
+    @JsonIgnore
+    private byte[] skinImage;
+
+    /**
+     * The part URLs of the skin
+     */
+    @JsonProperty("parts")
+    private Map<String, String> partUrls = new HashMap<>();
+
+    public Skin(String url, Model model) {
+        this.url = url;
+        this.model = model;
+
+        this.skinImage = PlayerUtils.getSkinImage(url);
+        if (this.skinImage != null) {
+            try {
+                BufferedImage image = ImageIO.read(new ByteArrayInputStream(this.skinImage));
+                if (image.getWidth() == 64 && image.getHeight() == 32) { // Using the old skin format
+                    this.isLegacy = true;
+                }
+            } catch (Exception ignored) {}
+        }
+    }
+
+    /**
+     * Gets the skin from a {@link JsonObject}.
+     *
+     * @param json the JSON object
+     * @return the skin
+     */
+    public static Skin fromJson(JsonObject json) {
+        if (json == null) {
+            return null;
+        }
+        String url = json.get("url").getAsString();
+        JsonObject metadata = json.getAsJsonObject("metadata");
+        Model model = Model.fromName(metadata == null ? "default" : // Fall back to slim if the model is not found
+                metadata.get("model").getAsString());
+        return new Skin(url, model);
+    }
+
+    /**
+     * Populates the part URLs for the skin.
+     *
+     * @param playerUuid the player's UUID
+     */
+    public Skin populatePartUrls(String playerUuid) {
+        for (Enum<?>[] type : ISkinPart.TYPES) {
+            for (Enum<?> part : type) {
+                ISkinPart skinPart = (ISkinPart) part;
+                if (skinPart.hidden()) {
+                    continue;
+                }
+                String partName = part.name().toLowerCase();
+                this.partUrls.put(partName, Config.INSTANCE.getWebPublicUrl() + "/player/" + partName + "/" + playerUuid);
+            }
+        }
+        return this;
+    }
+
+    /**
+     * The model of the skin.
+     */
+    public enum Model {
+        DEFAULT,
+        SLIM;
+
+        /**
+         * Gets the model from its name.
+         *
+         * @param name the name of the model
+         * @return the model
+         */
+        public static Model fromName(String name) {
+            for (Model model : values()) {
+                if (model.name().equalsIgnoreCase(name)) {
+                    return model;
+                }
+            }
+            return null;
+        }
+    }
+}
--- a/src/main/java/cc/fascinated/model/token/JavaServerStatusToken.java
+++ b/src/main/java/cc/fascinated/model/token/JavaServerStatusToken.java
@ -0,0 +1,69 @@
+package cc.fascinated.model.token;
+
+import cc.fascinated.model.server.JavaMinecraftServer;
+import cc.fascinated.model.server.MinecraftServer;
+import com.google.gson.annotations.SerializedName;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.ToString;
+
+/**
+ * @author Braydon
+ */
+@AllArgsConstructor @Getter @ToString
+public final class JavaServerStatusToken {
+
+    /**
+     * The version of the server.
+     */
+    private final JavaMinecraftServer.Version version;
+
+    /**
+     * The players on the server.
+     */
+    private final MinecraftServer.Players players;
+
+    /**
+     * The mods running on this server.
+     */
+    @SerializedName("modinfo")
+    private JavaMinecraftServer.ForgeModInfo modInfo;
+
+    /**
+     * The mods running on this server.
+     * <p>
+     *     This is only used for servers
+     *     running 1.13 and above.
+     * </p>
+     */
+    private JavaMinecraftServer.ForgeData forgeData;
+
+    /**
+     * The motd of the server.
+     */
+    private final Object description;
+
+    /**
+     * The favicon of the server.
+     */
+    private final String favicon;
+
+    /**
+     * Whether the server prevents chat reports.
+     */
+    private boolean preventsChatReports;
+
+    /**
+     * Whether the server enforces secure chat.
+     */
+    private boolean enforcesSecureChat;
+
+    /**
+     * Whether the server has previews chat enabled.
+     * <p>
+     *      Chat Preview sends chat messages to the server as they are typed, even before they're sent.
+     *      <a href="https://www.minecraft.net/es-mx/article/minecraft-snapshot-22w19a">More information</a>
+     * </p>
+     */
+    private boolean previewsChat;
+}
--- a/src/main/java/cc/fascinated/repository/MinecraftServerCacheRepository.java
+++ b/src/main/java/cc/fascinated/repository/MinecraftServerCacheRepository.java
@ -0,0 +1,11 @@
+package cc.fascinated.repository;
+
+import cc.fascinated.model.cache.CachedMinecraftServer;
+import org.springframework.data.repository.CrudRepository;
+
+/**
+ * A cache repository for {@link CachedMinecraftServer}'s.
+ *
+ * @author Braydon
+ */
+public interface MinecraftServerCacheRepository extends CrudRepository<CachedMinecraftServer, String> { }
--- a/src/main/java/cc/fascinated/repository/PlayerCacheRepository.java
+++ b/src/main/java/cc/fascinated/repository/PlayerCacheRepository.java
@ -0,0 +1,13 @@
+package cc.fascinated.repository;
+
+import cc.fascinated.model.cache.CachedPlayer;
+import org.springframework.data.repository.CrudRepository;
+
+import java.util.UUID;
+
+/**
+ * A cache repository for {@link CachedPlayer}'s.
+ *
+ * @author Braydon
+ */
+public interface PlayerCacheRepository extends CrudRepository<CachedPlayer, UUID> { }
--- a/src/main/java/cc/fascinated/repository/PlayerNameCacheRepository.java
+++ b/src/main/java/cc/fascinated/repository/PlayerNameCacheRepository.java
@ -0,0 +1,15 @@
+package cc.fascinated.repository;
+
+import cc.fascinated.model.cache.CachedPlayerName;
+import org.springframework.data.repository.CrudRepository;
+
+/**
+ * A cache repository for player usernames.
+ * <p>
+ * This will allow us to easily lookup a
+ * player's username and get their uuid.
+ * </p>
+ *
+ * @author Braydon
+ */
+public interface PlayerNameCacheRepository extends CrudRepository<CachedPlayerName, String> { }
--- a/src/main/java/cc/fascinated/repository/PlayerSkinPartCacheRepository.java
+++ b/src/main/java/cc/fascinated/repository/PlayerSkinPartCacheRepository.java
@ -0,0 +1,13 @@
+package cc.fascinated.repository;
+
+import cc.fascinated.model.cache.CachedPlayerSkinPart;
+import org.springframework.data.repository.CrudRepository;
+
+/**
+ * A cache repository for player skin parts.
+ * <p>
+ * This will allow us to easily lookup a
+ * player skin part by it's id.
+ * </p>
+ */
+public interface PlayerSkinPartCacheRepository extends CrudRepository<CachedPlayerSkinPart, String> { }
--- a/src/main/java/cc/fascinated/service/MojangService.java
+++ b/src/main/java/cc/fascinated/service/MojangService.java
@ -0,0 +1,165 @@
+package cc.fascinated.service;
+
+import cc.fascinated.common.ExpiringSet;
+import cc.fascinated.common.WebRequest;
+import cc.fascinated.model.mojang.MojangProfile;
+import cc.fascinated.model.mojang.MojangUsernameToUuid;
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
+import com.google.common.collect.Lists;
+import com.google.common.hash.Hashing;
+import io.micrometer.common.lang.NonNull;
+import lombok.SneakyThrows;
+import lombok.extern.log4j.Log4j2;
+import net.jodah.expiringmap.ExpirationPolicy;
+import org.springframework.stereotype.Service;
+
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+@Service @Log4j2
+public class MojangService {
+
+    private static final String SESSION_SERVER_ENDPOINT = "https://sessionserver.mojang.com";
+    private static final String API_ENDPOINT = "https://api.mojang.com";
+    private static final String FETCH_BLOCKED_SERVERS = SESSION_SERVER_ENDPOINT + "/blockedservers";
+    private static final Splitter DOT_SPLITTER = Splitter.on('.');
+    private static final Joiner DOT_JOINER = Joiner.on('.');
+
+    /**
+     * A list of banned server hashes provided by Mojang.
+     * <p>
+     * This is periodically fetched from Mojang, see
+     * {@link #fetchBlockedServers()} for more info.
+     * </p>
+     *
+     * @see <a href="https://wiki.vg/Mojang_API#Blocked_Servers">Mojang API</a>
+     */
+    private List<String> bannedServerHashes;
+
+    /**
+     * A cache of blocked server hostnames.
+     *
+     * @see #isServerHostnameBlocked(String) for more
+     */
+    private final ExpiringSet<String> blockedServersCache = new ExpiringSet<>(ExpirationPolicy.CREATED, 10L, TimeUnit.MINUTES);
+
+    public MojangService() {
+        new Timer().scheduleAtFixedRate(new TimerTask() {
+            @Override
+            public void run() {
+                fetchBlockedServers();
+            }
+        }, 0L, 60L * 15L * 1000L);
+    }
+
+    /**
+     * Fetch a list of blocked servers from Mojang.
+     */
+    @SneakyThrows
+    private void fetchBlockedServers() {
+        try (
+                InputStream inputStream = new URL(FETCH_BLOCKED_SERVERS).openStream();
+                Scanner scanner = new Scanner(inputStream, StandardCharsets.UTF_8).useDelimiter("\n");
+        ) {
+            List<String> hashes = new ArrayList<>();
+            while (scanner.hasNext()) {
+                hashes.add(scanner.next());
+            }
+            bannedServerHashes = Collections.synchronizedList(hashes);
+            log.info("Fetched {} banned server hashes", bannedServerHashes.size());
+        }
+    }
+
+    /**
+     * Check if the server with the
+     * given hostname is blocked by Mojang.
+     *
+     * @param hostname the server hostname to check
+     * @return whether the hostname is blocked
+     */
+    public boolean isServerBlocked(@NonNull String hostname) {
+        // Remove trailing dots
+        while (hostname.charAt(hostname.length() - 1) == '.') {
+            hostname = hostname.substring(0, hostname.length() - 1);
+        }
+        // Is the hostname banned?
+        if (isServerHostnameBlocked(hostname)) {
+            return true;
+        }
+        List<String> splitDots = Lists.newArrayList(DOT_SPLITTER.split(hostname)); // Split the hostname by dots
+        boolean isIp = splitDots.size() == 4; // Is it an IP address?
+        if (isIp) {
+            for (String element : splitDots) {
+                try {
+                    int part = Integer.parseInt(element);
+                    if (part >= 0 && part <= 255) { // Ensure the part is within the valid range
+                        continue;
+                    }
+                } catch (NumberFormatException ignored) {
+                    // Safely ignore, not a number
+                }
+                isIp = false;
+                break;
+            }
+        }
+        // Check if the hostname is blocked
+        if (!isIp && isServerHostnameBlocked("*." + hostname)) {
+            return true;
+        }
+        // Additional checks for the hostname
+        while (splitDots.size() > 1) {
+            splitDots.remove(isIp ? splitDots.size() - 1 : 0);
+            String starredPart = isIp ? DOT_JOINER.join(splitDots) + ".*" : "*." + DOT_JOINER.join(splitDots);
+            if (isServerHostnameBlocked(starredPart)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Check if the hash for the given
+     * hostname is in the blocked server list.
+     *
+     * @param hostname the hostname to check
+     * @return whether the hostname is blocked
+     */
+    private boolean isServerHostnameBlocked(@NonNull String hostname) {
+        // Check the cache first for the hostname
+        if (blockedServersCache.contains(hostname)) {
+            return true;
+        }
+        String hashed = Hashing.sha1().hashBytes(hostname.toLowerCase().getBytes(StandardCharsets.ISO_8859_1)).toString();
+        boolean blocked = bannedServerHashes.contains(hashed); // Is the hostname blocked?
+        if (blocked) { // Cache the blocked hostname
+            blockedServersCache.add(hostname);
+        }
+        return blocked;
+    }
+
+    /**
+     * Gets the Session Server profile of the
+     * player with the given UUID.
+     *
+     * @param id the uuid or name of the player
+     * @return the profile
+     */
+    public MojangProfile getProfile(String id) {
+        return WebRequest.getAsEntity(SESSION_SERVER_ENDPOINT + "/session/minecraft/profile/" + id, MojangProfile.class);
+    }
+
+    /**
+     * Gets the UUID of the player using
+     * the name of the player.
+     *
+     * @param id the name of the player
+     * @return the profile
+     */
+    public MojangUsernameToUuid getUuidFromUsername(String id) {
+        return WebRequest.getAsEntity(API_ENDPOINT + "/users/profiles/minecraft/" + id, MojangUsernameToUuid.class);
+    }
+}
--- a/src/main/java/cc/fascinated/service/PlayerService.java
+++ b/src/main/java/cc/fascinated/service/PlayerService.java
@ -0,0 +1,164 @@
+package cc.fascinated.service;
+
+import cc.fascinated.common.ImageUtils;
+import cc.fascinated.common.PlayerUtils;
+import cc.fascinated.common.Tuple;
+import cc.fascinated.common.UUIDUtils;
+import cc.fascinated.config.Config;
+import cc.fascinated.exception.impl.MojangAPIRateLimitException;
+import cc.fascinated.exception.impl.RateLimitException;
+import cc.fascinated.exception.impl.ResourceNotFoundException;
+import cc.fascinated.model.cache.CachedPlayer;
+import cc.fascinated.model.cache.CachedPlayerName;
+import cc.fascinated.model.cache.CachedPlayerSkinPart;
+import cc.fascinated.model.mojang.MojangProfile;
+import cc.fascinated.model.mojang.MojangUsernameToUuid;
+import cc.fascinated.model.player.Cape;
+import cc.fascinated.model.player.Player;
+import cc.fascinated.model.skin.ISkinPart;
+import cc.fascinated.model.skin.Skin;
+import cc.fascinated.repository.PlayerCacheRepository;
+import cc.fascinated.repository.PlayerNameCacheRepository;
+import cc.fascinated.repository.PlayerSkinPartCacheRepository;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.awt.image.BufferedImage;
+import java.util.Optional;
+import java.util.UUID;
+
+@Service @Log4j2
+public class PlayerService {
+
+    private final MojangService mojangAPIService;
+    private final PlayerCacheRepository playerCacheRepository;
+    private final PlayerNameCacheRepository playerNameCacheRepository;
+    private final PlayerSkinPartCacheRepository playerSkinPartCacheRepository;
+
+    @Autowired
+    public PlayerService(MojangService mojangAPIService, PlayerCacheRepository playerCacheRepository,
+                         PlayerNameCacheRepository playerNameCacheRepository, PlayerSkinPartCacheRepository playerSkinPartCacheRepository) {
+        this.mojangAPIService = mojangAPIService;
+        this.playerCacheRepository = playerCacheRepository;
+        this.playerNameCacheRepository = playerNameCacheRepository;
+        this.playerSkinPartCacheRepository = playerSkinPartCacheRepository;
+    }
+
+    /**
+     * Get a player from the cache or
+     * from the Mojang API.
+     *
+     * @param id the id of the player
+     * @return the player
+     */
+    public CachedPlayer getPlayer(String id) {
+        String originalId = id;
+        id = id.toUpperCase(); // Convert the id to uppercase to prevent case sensitivity
+        log.info("Getting player: {}", originalId);
+        UUID uuid = PlayerUtils.getUuidFromString(originalId);
+        if (uuid == null) { // If the id is not a valid uuid, get the uuid from the username
+            uuid = usernameToUuid(originalId).getUniqueId();
+        }
+
+        Optional<CachedPlayer> cachedPlayer = playerCacheRepository.findById(uuid);
+        if (cachedPlayer.isPresent() && Config.INSTANCE.isProduction()) { // Return the cached player if it exists
+            log.info("Player {} is cached", originalId);
+            return cachedPlayer.get();
+        }
+
+        try {
+            log.info("Getting player profile from Mojang: {}", originalId);
+            MojangProfile mojangProfile = mojangAPIService.getProfile(uuid.toString()); // Get the player profile from Mojang
+            log.info("Got player profile from Mojang: {}", originalId);
+            Tuple<Skin, Cape> skinAndCape = mojangProfile.getSkinAndCape();
+            CachedPlayer player = new CachedPlayer(
+                    uuid, // Player UUID
+                    UUIDUtils.removeDashes(uuid), // Trimmed UUID
+                    mojangProfile.getName(), // Player Name
+                    skinAndCape.getLeft(), // Skin
+                    skinAndCape.getRight(), // Cape
+                    mojangProfile.getProperties(), // Raw properties
+                    System.currentTimeMillis() // Cache time
+            );
+
+            playerCacheRepository.save(player);
+            player.setCached(-1); // Indicate that the player is not cached
+            return player;
+        } catch (RateLimitException exception) {
+            throw new MojangAPIRateLimitException();
+        }
+    }
+
+    /**
+     * Gets the player's uuid from their username.
+     *
+     * @param username the username of the player
+     * @return the uuid of the player
+     */
+    public CachedPlayerName usernameToUuid(String username) {
+        log.info("Getting UUID from username: {}", username);
+        Optional<CachedPlayerName> cachedPlayerName = playerNameCacheRepository.findById(username.toUpperCase());
+        if (cachedPlayerName.isPresent() && Config.INSTANCE.isProduction()) {
+            return cachedPlayerName.get();
+        }
+        try {
+            MojangUsernameToUuid mojangUsernameToUuid = mojangAPIService.getUuidFromUsername(username);
+            if (mojangUsernameToUuid == null) {
+                log.info("Player with username '{}' not found", username);
+                throw new ResourceNotFoundException("Player with username '%s' not found".formatted(username));
+            }
+            UUID uuid = UUIDUtils.addDashes(mojangUsernameToUuid.getUuid());
+            CachedPlayerName player = new CachedPlayerName(username, uuid);
+            playerNameCacheRepository.save(player);
+            log.info("Got UUID from username: {} -> {}", username, uuid);
+            return player;
+        } catch (RateLimitException exception) {
+            throw new MojangAPIRateLimitException();
+        }
+    }
+
+    /**
+     * Gets a skin part from the player's skin.
+     *
+     * @param player the player
+     * @param partName the name of the part
+     * @param renderOverlay whether to render the overlay
+     * @return the skin part
+     */
+    public CachedPlayerSkinPart getSkinPart(Player player, String partName, boolean renderOverlay, int size) {
+        if (size > 512) {
+            log.info("Size {} is too large, setting to 512", size);
+            size = 512;
+        }
+        ISkinPart part = ISkinPart.getByName(partName); // The skin part to get
+        if (part == null) { // Default to the face
+            part = ISkinPart.Vanilla.FACE;
+            log.warn("Invalid skin part {}, defaulting to {}", partName, part.name());
+        }
+
+        log.info("Getting skin part {} for player: {}", part.name(), player.getUniqueId());
+        String key = "%s-%s-%s-%s".formatted(player.getUniqueId(), part.name(), size, renderOverlay);
+        Optional<CachedPlayerSkinPart> cache = playerSkinPartCacheRepository.findById(key);
+
+        // The skin part is cached
+        if (cache.isPresent() && Config.INSTANCE.isProduction()) {
+            log.info("Skin part {} for player {} is cached", part.name(), player.getUniqueId());
+            return cache.get();
+        }
+
+        long before = System.currentTimeMillis();
+        BufferedImage renderedPart = part.render(player.getSkin(), renderOverlay, size); // Render the skin part
+        log.info("Took {}ms to render skin part {} for player: {}", System.currentTimeMillis() - before, part.name(), player.getUniqueId());
+
+        byte[] skinPartBytes = ImageUtils.imageToBytes(renderedPart); // Convert the image to bytes
+        CachedPlayerSkinPart skinPart = new CachedPlayerSkinPart(
+                key,
+                skinPartBytes
+        );
+        log.info("Fetched skin part {} for player: {}", part.name(), player.getUniqueId());
+
+        playerSkinPartCacheRepository.save(skinPart);
+        return skinPart;
+    }
+}
--- a/src/main/java/cc/fascinated/service/ServerService.java
+++ b/src/main/java/cc/fascinated/service/ServerService.java
@ -0,0 +1,128 @@
+package cc.fascinated.service;
+
+import cc.fascinated.common.DNSUtils;
+import cc.fascinated.common.EnumUtils;
+import cc.fascinated.config.Config;
+import cc.fascinated.exception.impl.BadRequestException;
+import cc.fascinated.exception.impl.ResourceNotFoundException;
+import cc.fascinated.model.cache.CachedMinecraftServer;
+import cc.fascinated.model.dns.DNSRecord;
+import cc.fascinated.model.dns.impl.ARecord;
+import cc.fascinated.model.dns.impl.SRVRecord;
+import cc.fascinated.model.server.JavaMinecraftServer;
+import cc.fascinated.model.server.MinecraftServer;
+import cc.fascinated.repository.MinecraftServerCacheRepository;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.Optional;
+
+@Service @Log4j2
+public class ServerService {
+    private static final String DEFAULT_SERVER_ICON = "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";
+
+    private final MojangService mojangService;
+    private final MinecraftServerCacheRepository serverCacheRepository;
+
+    @Autowired
+    public ServerService(MojangService mojangService, MinecraftServerCacheRepository serverCacheRepository) {
+        this.mojangService = mojangService;
+        this.serverCacheRepository = serverCacheRepository;
+    }
+
+    /**
+     * Ping a server to get the server information.
+     *
+     * @param platformName the name of the platform
+     * @param hostname the hostname of the server
+     * @return the server
+     */
+    public CachedMinecraftServer getServer(String platformName, String hostname) {
+        MinecraftServer.Platform platform = EnumUtils.getEnumConstant(MinecraftServer.Platform.class, platformName.toUpperCase());
+        if (platform == null) {
+            log.info("Invalid platform: {} for server {}", platformName, hostname);
+            throw new BadRequestException("Invalid platform: %s".formatted(platformName));
+        }
+        int port = platform.getDefaultPort();
+        if (hostname.contains(":")) {
+            String[] parts = hostname.split(":");
+            hostname = parts[0];
+            try {
+                port = Integer.parseInt(parts[1]);
+            } catch (NumberFormatException e) {
+                log.info("Invalid port: {} for server {}", parts[1], hostname);
+                throw new BadRequestException("Invalid port: %s".formatted(parts[1]));
+            }
+        }
+        String key = "%s-%s:%s".formatted(platformName, hostname, port);
+        log.info("Getting server: {}:{}", hostname, port);
+
+        // Check if the server is cached
+        Optional<CachedMinecraftServer> cached = serverCacheRepository.findById(key);
+        if (cached.isPresent() && Config.INSTANCE.isProduction()) {
+                log.info("Server {}:{} is cached", hostname, port);
+            return cached.get();
+        }
+
+        List<DNSRecord> records = new ArrayList<>(); // The resolved DNS records for the server
+
+        SRVRecord srvRecord = platform == MinecraftServer.Platform.JAVA ? DNSUtils.resolveSRV(hostname) : null; // Resolve the SRV record
+        if (srvRecord != null) { // SRV was resolved, use the hostname and port
+            records.add(srvRecord); // Going to need this for later
+            InetSocketAddress socketAddress = srvRecord.getSocketAddress();
+            hostname = socketAddress.getHostName();
+            port = socketAddress.getPort();
+        }
+
+        ARecord aRecord = DNSUtils.resolveA(hostname); // Resolve the A record so we can get the IPv4 address
+        String ip = aRecord == null ? null : aRecord.getAddress(); // Get the IP address
+        if (ip != null) { // Was the IP resolved?
+            records.add(aRecord); // Going to need this for later
+            log.info("Resolved hostname: {} -> {}", hostname, ip);
+        }
+
+        CachedMinecraftServer server = new CachedMinecraftServer(
+                key,
+                platform.getPinger().ping(hostname, ip, port, records.toArray(new DNSRecord[0])),
+                System.currentTimeMillis()
+        );
+
+        // Check if the server is blocked by Mojang
+        if (platform == MinecraftServer.Platform.JAVA) {
+            ((JavaMinecraftServer) server.getServer()).setMojangBlocked(mojangService.isServerBlocked(hostname));
+        }
+
+        log.info("Found server: {}:{}", hostname, port);
+        serverCacheRepository.save(server);
+        server.setCached(-1); // Indicate that the server is not cached
+        return server;
+    }
+
+    /**
+     * Gets the server favicon.
+     *
+     * @param hostname the hostname of the server
+     * @return the server favicon, null if not found
+     */
+    public byte[] getServerFavicon(String hostname) {
+        String icon = null; // The server base64 icon
+        try {
+            JavaMinecraftServer.Favicon favicon = ((JavaMinecraftServer) getServer(MinecraftServer.Platform.JAVA.name(), hostname).getServer()).getFavicon();
+            if (favicon != null) { // Use the server's favicon
+                icon = favicon.getBase64();
+                icon = icon.substring(icon.indexOf(",") + 1); // Remove the data type from the server icon
+            }
+        } catch (BadRequestException | ResourceNotFoundException ignored) {
+            // Safely ignore these, we will use the default server icon
+        }
+        if (icon == null) { // Use the default server icon
+            icon = DEFAULT_SERVER_ICON;
+        }
+        return Base64.getDecoder().decode(icon); // Return the decoded favicon
+    }
+}
--- a/src/main/java/cc/fascinated/service/pinger/MinecraftServerPinger.java
+++ b/src/main/java/cc/fascinated/service/pinger/MinecraftServerPinger.java
@ -0,0 +1,12 @@
+package cc.fascinated.service.pinger;
+
+import cc.fascinated.model.dns.DNSRecord;
+import cc.fascinated.model.server.MinecraftServer;
+
+/**
+ * @author Braydon
+ * @param <T> the type of server to ping
+ */
+public interface MinecraftServerPinger<T extends MinecraftServer> {
+    T ping(String hostname, String ip, int port, DNSRecord[] records);
+}
--- a/src/main/java/cc/fascinated/service/pinger/impl/BedrockMinecraftServerPinger.java
+++ b/src/main/java/cc/fascinated/service/pinger/impl/BedrockMinecraftServerPinger.java
@ -0,0 +1,69 @@
+package cc.fascinated.service.pinger.impl;
+
+import cc.fascinated.common.packet.impl.bedrock.BedrockPacketUnconnectedPing;
+import cc.fascinated.common.packet.impl.bedrock.BedrockPacketUnconnectedPong;
+import cc.fascinated.exception.impl.BadRequestException;
+import cc.fascinated.exception.impl.ResourceNotFoundException;
+import cc.fascinated.model.dns.DNSRecord;
+import cc.fascinated.model.server.BedrockMinecraftServer;
+import cc.fascinated.service.pinger.MinecraftServerPinger;
+import lombok.extern.log4j.Log4j2;
+
+import java.io.IOException;
+import java.net.DatagramSocket;
+import java.net.InetSocketAddress;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+
+/**
+ * The {@link MinecraftServerPinger} for pinging
+ * {@link BedrockMinecraftServer} over UDP.
+ *
+ * @author Braydon
+ */
+@Log4j2(topic = "Bedrock MC Server Pinger")
+public final class BedrockMinecraftServerPinger implements MinecraftServerPinger<BedrockMinecraftServer> {
+    private static final int TIMEOUT = 1500; // The timeout for the socket
+
+    /**
+     * Ping the server with the given hostname and port.
+     *
+     * @param hostname the hostname of the server
+     * @param port     the port of the server
+     * @return the server that was pinged
+     */
+    @Override
+    public BedrockMinecraftServer ping(String hostname, String ip, int port, DNSRecord[] records) {
+        log.info("Pinging {}:{}...", hostname, port);
+        long before = System.currentTimeMillis(); // Timestamp before pinging
+
+        // Open a socket connection to the server
+        try (DatagramSocket socket = new DatagramSocket()) {
+            socket.setSoTimeout(TIMEOUT);
+            socket.connect(new InetSocketAddress(hostname, port));
+
+            long ping = System.currentTimeMillis() - before; // Calculate the ping
+            log.info("Pinged {}:{} in {}ms", hostname, port, ping);
+
+            // Send the unconnected ping packet
+            new BedrockPacketUnconnectedPing().process(socket);
+
+            // Handle the received unconnected pong packet
+            BedrockPacketUnconnectedPong unconnectedPong = new BedrockPacketUnconnectedPong();
+            unconnectedPong.process(socket);
+            String response = unconnectedPong.getResponse();
+            if (response == null) { // No pong response
+                throw new ResourceNotFoundException("Server didn't respond to ping");
+            }
+            return BedrockMinecraftServer.create(hostname, ip, port, records, response); // Return the server
+        } catch (IOException ex) {
+            if (ex instanceof UnknownHostException) {
+                throw new BadRequestException("Unknown hostname: %s".formatted(hostname));
+            } else if (ex instanceof SocketTimeoutException) {
+                throw new ResourceNotFoundException(ex);
+            }
+            log.error("An error occurred pinging %s:%s:".formatted(hostname, port), ex);
+        }
+        return null;
+    }
+}
--- a/src/main/java/cc/fascinated/service/pinger/impl/JavaMinecraftServerPinger.java
+++ b/src/main/java/cc/fascinated/service/pinger/impl/JavaMinecraftServerPinger.java
@ -0,0 +1,59 @@
+package cc.fascinated.service.pinger.impl;
+
+import cc.fascinated.Main;
+import cc.fascinated.common.JavaMinecraftVersion;
+import cc.fascinated.common.ServerUtils;
+import cc.fascinated.common.packet.impl.java.JavaPacketHandshakingInSetProtocol;
+import cc.fascinated.common.packet.impl.java.JavaPacketStatusInStart;
+import cc.fascinated.exception.impl.BadRequestException;
+import cc.fascinated.exception.impl.ResourceNotFoundException;
+import cc.fascinated.model.dns.DNSRecord;
+import cc.fascinated.model.server.JavaMinecraftServer;
+import cc.fascinated.model.token.JavaServerStatusToken;
+import cc.fascinated.service.pinger.MinecraftServerPinger;
+import lombok.extern.log4j.Log4j2;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.net.*;
+
+/**
+ * @author Braydon
+ */
+@Log4j2(topic = "Java Pinger")
+public final class JavaMinecraftServerPinger implements MinecraftServerPinger<JavaMinecraftServer> {
+    private static final int TIMEOUT = 1500; // The timeout for the socket
+
+    @Override
+    public JavaMinecraftServer ping(String hostname, String ip, int port, DNSRecord[] records) {
+        log.info("Pinging {}:{}...", hostname, port);
+
+        // Open a socket connection to the server
+        try (Socket socket = new Socket()) {
+            socket.setTcpNoDelay(true);
+            socket.connect(new InetSocketAddress(hostname, port), TIMEOUT);
+
+            // Open data streams to begin packet transaction
+            try (DataInputStream inputStream = new DataInputStream(socket.getInputStream());
+                 DataOutputStream outputStream = new DataOutputStream(socket.getOutputStream())) {
+                // Begin handshaking with the server
+                new JavaPacketHandshakingInSetProtocol(hostname, port, JavaMinecraftVersion.getMinimumVersion().getProtocol()).process(inputStream, outputStream);
+
+                // Send the status request to the server, and await back the response
+                JavaPacketStatusInStart packetStatusInStart = new JavaPacketStatusInStart();
+                packetStatusInStart.process(inputStream, outputStream);
+                JavaServerStatusToken token = Main.GSON.fromJson(packetStatusInStart.getResponse(), JavaServerStatusToken.class);
+                return JavaMinecraftServer.create(hostname, ip, port, records, token);
+            }
+        } catch (IOException ex) {
+            if (ex instanceof UnknownHostException) {
+                throw new BadRequestException("Unknown hostname: %s".formatted(hostname));
+            } else if (ex instanceof ConnectException || ex instanceof SocketTimeoutException) {
+                throw new ResourceNotFoundException(ex);
+            }
+            log.error("An error occurred pinging %s".formatted(ServerUtils.getAddress(hostname, port)), ex);
+        }
+        return null;
+    }
+}