From 0ec7de0df20923e279d325879ec6af8433dd8075 Mon Sep 17 00:00:00 2001 From: "Lukas Rieger (Blue)" Date: Fri, 14 Jun 2024 00:28:38 +0200 Subject: [PATCH] Update fabric forge and neoforge implementations to 1.21 --- .../fabric-1.20.5/build.gradle.kts | 177 ++++++++++++ .../fabric-1.20.5/settings.gradle.kts | 13 + .../bluemap/fabric/FabricCommandSource.java | 90 ++++++ .../bluemap/fabric/FabricEventForwarder.java | 76 +++++ .../bluecolored/bluemap/fabric/FabricMod.java | 241 ++++++++++++++++ .../bluemap/fabric/FabricPlayer.java | 157 +++++++++++ .../bluemap/fabric/FabricWorld.java | 110 ++++++++ .../bluemap/fabric/Log4jLogger.java | 69 +++++ .../main/resources/assets/bluemap/icon.png | Bin 0 -> 10593 bytes .../src/main/resources/fabric.mod.json | 33 +++ implementations/fabric/build.gradle.kts | 13 +- .../bluemap/fabric/FabricWorld.java | 2 +- implementations/forge-1.20.6/build.gradle | 195 +++++++++++++ .../forge-1.20.6/settings.gradle.kts | 3 + .../bluemap/forge/ForgeCommandSource.java | 78 ++++++ .../bluemap/forge/ForgeEventForwarder.java | 67 +++++ .../bluecolored/bluemap/forge/ForgeMod.java | 262 ++++++++++++++++++ .../bluemap/forge/ForgePlayer.java | 154 ++++++++++ .../bluecolored/bluemap/forge/ForgeWorld.java | 111 ++++++++ .../bluemap/forge/Log4jLogger.java | 69 +++++ .../src/main/resources/META-INF/mods.toml | 26 ++ .../src/main/resources/pack.mcmeta | 6 + implementations/forge/build.gradle | 8 +- .../bluecolored/bluemap/forge/ForgeWorld.java | 2 +- implementations/neoforge/build.gradle | 6 +- implementations/neoforge/gradle.properties | 10 +- .../bluecolored/bluemap/forge/ForgeWorld.java | 2 +- settings.gradle.kts | 2 + 28 files changed, 1960 insertions(+), 22 deletions(-) create mode 100644 implementations/fabric-1.20.5/build.gradle.kts create mode 100644 implementations/fabric-1.20.5/settings.gradle.kts create mode 100644 implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricCommandSource.java create mode 100644 implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricEventForwarder.java create mode 100644 implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricMod.java create mode 100644 implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricPlayer.java create mode 100644 implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricWorld.java create mode 100644 implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/Log4jLogger.java create mode 100644 implementations/fabric-1.20.5/src/main/resources/assets/bluemap/icon.png create mode 100644 implementations/fabric-1.20.5/src/main/resources/fabric.mod.json create mode 100644 implementations/forge-1.20.6/build.gradle create mode 100644 implementations/forge-1.20.6/settings.gradle.kts create mode 100644 implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeCommandSource.java create mode 100644 implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeEventForwarder.java create mode 100644 implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeMod.java create mode 100644 implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgePlayer.java create mode 100644 implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java create mode 100644 implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/Log4jLogger.java create mode 100644 implementations/forge-1.20.6/src/main/resources/META-INF/mods.toml create mode 100644 implementations/forge-1.20.6/src/main/resources/pack.mcmeta diff --git a/implementations/fabric-1.20.5/build.gradle.kts b/implementations/fabric-1.20.5/build.gradle.kts new file mode 100644 index 00000000..27517b4e --- /dev/null +++ b/implementations/fabric-1.20.5/build.gradle.kts @@ -0,0 +1,177 @@ +import com.matthewprenger.cursegradle.CurseArtifact +import com.matthewprenger.cursegradle.CurseProject +import com.matthewprenger.cursegradle.CurseRelation +import com.matthewprenger.cursegradle.Options +import net.fabricmc.loom.task.RemapJarTask + +plugins { + java + `java-library` + id("com.diffplug.spotless") version "6.1.2" + id ("com.github.node-gradle.node") version "3.0.1" + id ("com.github.johnrengelman.shadow") version "8.1.1" + id ("fabric-loom") version "1.6-SNAPSHOT" + id ("com.modrinth.minotaur") version "2.+" + id ("com.matthewprenger.cursegradle") version "1.4.0" +} + +group = "de.bluecolored.bluemap" +version = System.getProperty("bluemap.version") ?: "?" // set by BlueMapCore + +val javaTarget = 21 +java { + sourceCompatibility = JavaVersion.toVersion(javaTarget) + targetCompatibility = JavaVersion.toVersion(javaTarget) + + withSourcesJar() +} + +repositories { + mavenCentral() + maven ("https://libraries.minecraft.net") + maven ("https://maven.fabricmc.net/") + maven ("https://oss.sonatype.org/content/repositories/snapshots") + maven ("https://repo.bluecolored.de/releases") +} + +val shadowInclude: Configuration by configurations.creating + +configurations { + implementation.get().extendsFrom(shadowInclude) +} + +dependencies { + shadowInclude ("de.bluecolored.bluemap:BlueMapCommon") { + //exclude dependencies provided by fabric + exclude (group = "com.google.guava", module = "guava") + exclude (group = "com.google.code.gson", module = "gson") + exclude (group = "com.mojang", module = "brigadier") + } + + minecraft ("com.mojang:minecraft:1.20.5") + mappings ("net.fabricmc:yarn:1.20.5+build.1") + modImplementation ("net.fabricmc:fabric-loader:0.15.10") + modImplementation ("net.fabricmc.fabric-api:fabric-api:0.97.8+1.20.5") + modImplementation("me.lucko:fabric-permissions-api:0.1-SNAPSHOT") + + testImplementation ("org.junit.jupiter:junit-jupiter:5.9.0") + testRuntimeOnly ("org.junit.jupiter:junit-jupiter-engine:5.9.0") +} + +spotless { + java { + target ("src/*/java/**/*.java") + + licenseHeaderFile("../../HEADER") + indentWithSpaces() + trimTrailingWhitespace() + } +} + +tasks.withType(JavaCompile::class).configureEach { + options.apply { + encoding = "utf-8" + } +} + +tasks.withType(AbstractArchiveTask::class).configureEach { + isReproducibleFileOrder = true + isPreserveFileTimestamps = false +} + +tasks.test { + useJUnitPlatform() +} + +tasks.processResources { + inputs.property ("version", project.version) + + filesMatching("fabric.mod.json") { + expand ("version" to project.version) + } +} + +tasks.shadowJar { + configurations = listOf(shadowInclude) + + //relocate ("com.flowpowered.math", "de.bluecolored.shadow.flowpowered.math") //DON"T relocate this, because the API depends on it + relocate ("com.typesafe.config", "de.bluecolored.shadow.typesafe.config") + relocate ("de.bluecolored.bluenbt", "de.bluecolored.shadow.bluenbt") + relocate ("org.spongepowered.configurate", "de.bluecolored.shadow.configurate") + relocate ("com.github.benmanes.caffeine", "de.bluecolored.shadow.benmanes.caffeine") + relocate ("org.aopalliance", "de.bluecolored.shadow.aopalliance") + relocate ("javax.inject", "de.bluecolored.shadow.javax.inject") + relocate ("org.checkerframework", "de.bluecolored.shadow.checkerframework") + relocate ("org.codehaus", "de.bluecolored.shadow.codehaus") + relocate ("io.leangen.geantyref", "de.bluecolored.shadow.geantyref") + relocate ("io.airlift", "de.bluecolored.shadow.airlift") + relocate ("net.jpountz", "de.bluecolored.shadow.jpountz") + + relocate ("com.google.errorprone", "de.bluecolored.shadow.google.errorprone") + relocate ("com.google.inject", "de.bluecolored.shadow.google.inject") + + relocate ("org.apache.commons.dbcp2", "de.bluecolored.shadow.apache.commons.dbcp2") + relocate ("org.apache.commons.logging", "de.bluecolored.shadow.apache.commons.logging") + relocate ("org.apache.commons.pool2", "de.bluecolored.shadow.apache.commons.pool2") +} + +tasks.register("remappedShadowJar", type = RemapJarTask::class) { + destinationDirectory.set(file("../../build/release")) + archiveFileName.set("BlueMap-${project.version}-${project.name}.jar") + dependsOn (tasks.shadowJar) + inputFile.set(tasks.shadowJar.get().archiveFile) + addNestedDependencies.set(true) +} + +tasks.register("release") { + dependsOn("remappedShadowJar") +} + +modrinth { + token.set(System.getenv("MODRINTH_TOKEN")) + projectId.set("swbUV1cr") + versionNumber.set("${project.version}-${project.name}") + changelog.set(file("../../release.md") + .readText() + .replace("{version}", project.version.toString())) + uploadFile.set(tasks.findByName("remappedShadowJar")) + gameVersions.addAll("1.20.5", "1.20.6") + dependencies { + required.project("P7dR8mSH") // Fabric API + } +} + +curseforge { + apiKey = System.getenv("CURSEFORGE_TOKEN") ?: "" + project(closureOf { + id = "406463" + changelogType = "markdown" + changelog = file("../../release.md") + .readText() + .replace("{version}", project.version.toString()) + releaseType = "release" + + addGameVersion("Fabric") + + addGameVersion("Java 21") + + addGameVersion("1.20.5") + addGameVersion("1.20.6") + + mainArtifact(tasks.findByName("remappedShadowJar"), closureOf { + relations(closureOf { + requiredDependency("fabric-api") + }) + }) + }) + options(closureOf { + javaVersionAutoDetect = false + javaIntegration = false + forgeGradleIntegration = false + }) +} + +tasks.register("publish") { + dependsOn("modrinth") + dependsOn("curseforge") +} diff --git a/implementations/fabric-1.20.5/settings.gradle.kts b/implementations/fabric-1.20.5/settings.gradle.kts new file mode 100644 index 00000000..99ed8cbd --- /dev/null +++ b/implementations/fabric-1.20.5/settings.gradle.kts @@ -0,0 +1,13 @@ +pluginManagement { + repositories { + maven { + name = "Fabric" + url = uri("https://maven.fabricmc.net/") + } + gradlePluginPortal() + } +} + +rootProject.name = "fabric-1.20.5" + +includeBuild("../../BlueMapCommon") diff --git a/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricCommandSource.java b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricCommandSource.java new file mode 100644 index 00000000..85b0f2e6 --- /dev/null +++ b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricCommandSource.java @@ -0,0 +1,90 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.fabric; + +import com.flowpowered.math.vector.Vector3d; +import de.bluecolored.bluemap.common.plugin.Plugin; +import de.bluecolored.bluemap.common.plugin.text.Text; +import de.bluecolored.bluemap.common.serverinterface.CommandSource; +import de.bluecolored.bluemap.common.serverinterface.ServerWorld; +import de.bluecolored.bluemap.core.world.World; +import me.lucko.fabric.api.permissions.v0.Permissions; +import net.minecraft.registry.BuiltinRegistries; +import net.minecraft.registry.RegistryWrapper; +import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.util.math.Vec3d; + +import java.util.Optional; + +public class FabricCommandSource implements CommandSource { + + private static final RegistryWrapper.WrapperLookup lookup = BuiltinRegistries.createWrapperLookup(); + + private final FabricMod mod; + private final Plugin plugin; + private final ServerCommandSource delegate; + + public FabricCommandSource(FabricMod mod, Plugin plugin, ServerCommandSource delegate) { + this.mod = mod; + this.plugin = plugin; + this.delegate = delegate; + } + + @Override + public void sendMessage(Text text) { + delegate.sendFeedback( + () -> net.minecraft.text.Text.Serialization + .fromJson(text.toJSONString(), lookup), + false + ); + } + + @Override + public boolean hasPermission(String permission) { + try { + Class.forName("me.lucko.fabric.api.permissions.v0.Permissions"); + return Permissions.check(delegate, permission, 1); + } catch (ClassNotFoundException ex) { + return delegate.hasPermissionLevel(1); + } + } + + @Override + public Optional getPosition() { + Vec3d pos = delegate.getPosition(); + if (pos != null) { + return Optional.of(new Vector3d(pos.x, pos.y, pos.z)); + } + + return Optional.empty(); + } + + @Override + public Optional getWorld() { + ServerWorld serverWorld = mod.getServerWorld(delegate.getWorld()); + return Optional.ofNullable(plugin.getWorld(serverWorld)); + } + +} diff --git a/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricEventForwarder.java b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricEventForwarder.java new file mode 100644 index 00000000..411e1c34 --- /dev/null +++ b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricEventForwarder.java @@ -0,0 +1,76 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.fabric; + +import de.bluecolored.bluemap.common.serverinterface.ServerEventListener; +import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.network.ServerPlayerEntity; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.UUID; + +public class FabricEventForwarder { + + private final FabricMod mod; + private final Collection eventListeners; + + public FabricEventForwarder(FabricMod mod) { + this.mod = mod; + this.eventListeners = new ArrayList<>(1); + + ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> { + this.onPlayerJoin(server, handler.getPlayer()); + }); + + ServerPlayConnectionEvents.DISCONNECT.register((handler, server) -> { + this.onPlayerLeave(server, handler.getPlayer()); + }); + } + + public synchronized void addEventListener(ServerEventListener listener) { + this.eventListeners.add(listener); + } + + public synchronized void removeAllListeners() { + this.eventListeners.clear(); + } + + public synchronized void onPlayerJoin(MinecraftServer server, ServerPlayerEntity player) { + if (this.mod.getServer() != server) return; + + UUID uuid = player.getUuid(); + for (ServerEventListener listener : eventListeners) listener.onPlayerJoin(uuid); + } + + public synchronized void onPlayerLeave(MinecraftServer server, ServerPlayerEntity player) { + if (this.mod.getServer() != server) return; + + UUID uuid = player.getUuid(); + for (ServerEventListener listener : eventListeners) listener.onPlayerLeave(uuid); + } + +} diff --git a/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricMod.java b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricMod.java new file mode 100644 index 00000000..2d2c3fa1 --- /dev/null +++ b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricMod.java @@ -0,0 +1,241 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.fabric; + +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.benmanes.caffeine.cache.LoadingCache; +import de.bluecolored.bluemap.common.plugin.Plugin; +import de.bluecolored.bluemap.common.plugin.commands.Commands; +import de.bluecolored.bluemap.common.serverinterface.Player; +import de.bluecolored.bluemap.common.serverinterface.Server; +import de.bluecolored.bluemap.common.serverinterface.ServerEventListener; +import de.bluecolored.bluemap.common.serverinterface.ServerWorld; +import de.bluecolored.bluemap.core.BlueMap; +import de.bluecolored.bluemap.core.logger.Logger; +import net.fabricmc.api.ModInitializer; +import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback; +import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents; +import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents; +import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents; +import net.minecraft.SharedConstants; +import net.minecraft.registry.RegistryKey; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.network.ServerPlayerEntity; +import net.minecraft.util.Identifier; +import net.minecraft.world.World; +import org.apache.logging.log4j.LogManager; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +public class FabricMod implements ModInitializer, Server { + + private final Plugin pluginInstance; + private MinecraftServer serverInstance = null; + + private final FabricEventForwarder eventForwarder; + + private final LoadingCache worlds; + + private int playerUpdateIndex = 0; + private final Map onlinePlayerMap; + private final List onlinePlayerList; + + public FabricMod() { + Logger.global.clear(); + Logger.global.put(new Log4jLogger(LogManager.getLogger(Plugin.PLUGIN_NAME))); + + this.onlinePlayerMap = new ConcurrentHashMap<>(); + this.onlinePlayerList = Collections.synchronizedList(new ArrayList<>()); + + pluginInstance = new Plugin("fabric", this); + + this.eventForwarder = new FabricEventForwarder(this); + this.worlds = Caffeine.newBuilder() + .executor(BlueMap.THREAD_POOL) + .weakKeys() + .maximumSize(1000) + .build(FabricWorld::new); + } + + @Override + public void onInitialize() { + + //register commands + CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> + new Commands<>(pluginInstance, dispatcher, fabricSource -> + new FabricCommandSource(this, pluginInstance, fabricSource) + ) + ); + + ServerLifecycleEvents.SERVER_STARTED.register((MinecraftServer server) -> { + this.serverInstance = server; + + new Thread(()->{ + Logger.global.logInfo("Loading BlueMap..."); + + try { + pluginInstance.load(); + if (pluginInstance.isLoaded()) Logger.global.logInfo("BlueMap loaded!"); + } catch (IOException e) { + Logger.global.logError("Failed to load bluemap!", e); + pluginInstance.unload(); + } + }, "BlueMap-Plugin-Loading").start(); + }); + + ServerLifecycleEvents.SERVER_STOPPING.register((MinecraftServer server) -> { + pluginInstance.unload(); + Logger.global.logInfo("BlueMap unloaded!"); + }); + + ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> { + this.onPlayerJoin(server, handler.getPlayer()); + }); + + ServerPlayConnectionEvents.DISCONNECT.register((handler, server) -> { + this.onPlayerLeave(server, handler.getPlayer()); + }); + + ServerTickEvents.END_SERVER_TICK.register((MinecraftServer server) -> { + if (server == this.serverInstance) this.updateSomePlayers(); + }); + } + + @Override + public String getMinecraftVersion() { + return SharedConstants.getGameVersion().getId(); + } + + @Override + public void registerListener(ServerEventListener listener) { + eventForwarder.addEventListener(listener); + } + + @Override + public void unregisterAllListeners() { + eventForwarder.removeAllListeners(); + } + + @Override + public Collection getLoadedServerWorlds() { + Collection loadedWorlds = new ArrayList<>(3); + for (net.minecraft.server.world.ServerWorld serverWorld : serverInstance.getWorlds()) { + loadedWorlds.add(worlds.get(serverWorld)); + } + return loadedWorlds; + } + + @SuppressWarnings("unchecked") + @Override + public Optional getServerWorld(Object world) { + + if (world instanceof String) { + Identifier identifier = Identifier.tryParse((String) world); + if (identifier != null) world = serverInstance.getWorld(RegistryKey.of(RegistryKeys.WORLD, identifier)); + } + + if (world instanceof RegistryKey) { + try { + world = serverInstance.getWorld((RegistryKey) world); + } catch (ClassCastException ignored) {} + } + + if (world instanceof net.minecraft.server.world.ServerWorld) + return Optional.of(getServerWorld((net.minecraft.server.world.ServerWorld) world)); + + return Optional.empty(); + } + + public ServerWorld getServerWorld(net.minecraft.server.world.ServerWorld serverWorld) { + return worlds.get(serverWorld); + } + + @Override + public Path getConfigFolder() { + return Path.of("config", "bluemap"); + } + + @Override + public Optional getModsFolder() { + return Optional.of(Path.of("mods")); + } + + public void onPlayerJoin(MinecraftServer server, ServerPlayerEntity playerInstance) { + if (this.serverInstance != server) return; + + FabricPlayer player = new FabricPlayer(playerInstance, this); + onlinePlayerMap.put(player.getUuid(), player); + onlinePlayerList.add(player); + } + + public void onPlayerLeave(MinecraftServer server, ServerPlayerEntity player) { + if (this.serverInstance != server) return; + + UUID playerUUID = player.getUuid(); + onlinePlayerMap.remove(playerUUID); + synchronized (onlinePlayerList) { + onlinePlayerList.removeIf(p -> p.getUuid().equals(playerUUID)); + } + } + + public MinecraftServer getServer() { + return this.serverInstance; + } + + public Plugin getPluginInstance() { + return pluginInstance; + } + + @Override + public Collection getOnlinePlayers() { + return onlinePlayerMap.values(); + } + + /** + * Only update some of the online players each tick to minimize performance impact on the server-thread. + * Only call this method on the server-thread. + */ + private void updateSomePlayers() { + int onlinePlayerCount = onlinePlayerList.size(); + if (onlinePlayerCount == 0) return; + + int playersToBeUpdated = onlinePlayerCount / 20; //with 20 tps, each player is updated once a second + if (playersToBeUpdated == 0) playersToBeUpdated = 1; + + for (int i = 0; i < playersToBeUpdated; i++) { + playerUpdateIndex++; + if (playerUpdateIndex >= 20 && playerUpdateIndex >= onlinePlayerCount) playerUpdateIndex = 0; + + if (playerUpdateIndex < onlinePlayerCount) { + onlinePlayerList.get(playerUpdateIndex).update(); + } + } + } + +} diff --git a/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricPlayer.java b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricPlayer.java new file mode 100644 index 00000000..692256dd --- /dev/null +++ b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricPlayer.java @@ -0,0 +1,157 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.fabric; + +import com.flowpowered.math.vector.Vector3d; +import de.bluecolored.bluemap.common.plugin.text.Text; +import de.bluecolored.bluemap.common.serverinterface.Gamemode; +import de.bluecolored.bluemap.common.serverinterface.Player; +import de.bluecolored.bluemap.common.serverinterface.ServerWorld; +import net.minecraft.entity.effect.StatusEffectInstance; +import net.minecraft.entity.effect.StatusEffects; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.network.ServerPlayerEntity; +import net.minecraft.util.math.Vec3d; +import net.minecraft.world.GameMode; +import net.minecraft.world.LightType; + +import java.util.EnumMap; +import java.util.Map; +import java.util.UUID; + +public class FabricPlayer implements Player { + + private static final Map GAMEMODE_MAP = new EnumMap<>(GameMode.class); + static { + GAMEMODE_MAP.put(GameMode.ADVENTURE, Gamemode.ADVENTURE); + GAMEMODE_MAP.put(GameMode.SURVIVAL, Gamemode.SURVIVAL); + GAMEMODE_MAP.put(GameMode.CREATIVE, Gamemode.CREATIVE); + GAMEMODE_MAP.put(GameMode.SPECTATOR, Gamemode.SPECTATOR); + } + + private final UUID uuid; + private Text name; + private ServerWorld world; + private Vector3d position; + private Vector3d rotation; + private int skyLight; + private int blockLight; + private boolean sneaking; + private boolean invisible; + private Gamemode gamemode; + + private final FabricMod mod; + + public FabricPlayer(ServerPlayerEntity player, FabricMod mod) { + this.uuid = player.getUuid(); + this.mod = mod; + + update(player); + } + + @Override + public UUID getUuid() { + return this.uuid; + } + + @Override + public Text getName() { + return this.name; + } + + @Override + public ServerWorld getWorld() { + return this.world; + } + + @Override + public Vector3d getPosition() { + return this.position; + } + + @Override + public Vector3d getRotation() { + return rotation; + } + + @Override + public int getSkyLight() { + return skyLight; + } + + @Override + public int getBlockLight() { + return blockLight; + } + + @Override + public boolean isSneaking() { + return this.sneaking; + } + + @Override + public boolean isInvisible() { + return this.invisible; + } + + @Override + public Gamemode getGamemode() { + return this.gamemode; + } + + /** + * Only call on server thread! + */ + public void update() { + MinecraftServer server = mod.getServer(); + if (server == null) return; + + ServerPlayerEntity player = server.getPlayerManager().getPlayer(uuid); + if (player == null) return; + + update(player); + } + + public void update(ServerPlayerEntity player) { + this.gamemode = GAMEMODE_MAP.get(player.interactionManager.getGameMode()); + if (this.gamemode == null) this.gamemode = Gamemode.SURVIVAL; + + StatusEffectInstance invis = player.getStatusEffect(StatusEffects.INVISIBILITY); + this.invisible = invis != null && invis.getDuration() > 0; + + this.name = Text.of(player.getName().getString()); + + Vec3d pos = player.getPos(); + this.position = new Vector3d(pos.getX(), pos.getY(), pos.getZ()); + this.rotation = new Vector3d(player.getPitch(), player.getHeadYaw(), 0); + this.sneaking = player.isSneaking(); + + this.skyLight = player.getWorld().getLightingProvider().get(LightType.SKY).getLightLevel(player.getBlockPos()); + this.blockLight = player.getWorld().getLightingProvider().get(LightType.BLOCK).getLightLevel(player.getBlockPos()); + + this.world = mod.getServerWorld(player.getServerWorld()); + } + +} diff --git a/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricWorld.java b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricWorld.java new file mode 100644 index 00000000..ff4468d9 --- /dev/null +++ b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/FabricWorld.java @@ -0,0 +1,110 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.fabric; + +import de.bluecolored.bluemap.common.serverinterface.ServerWorld; +import de.bluecolored.bluemap.core.util.Key; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.Identifier; +import net.minecraft.util.WorldSavePath; + +import java.io.IOException; +import java.lang.ref.WeakReference; +import java.nio.file.Path; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.ExecutionException; + +public class FabricWorld implements ServerWorld { + + private final WeakReference delegate; + private final Path worldFolder; + private final Key dimension; + + public FabricWorld(net.minecraft.server.world.ServerWorld delegate) { + this.delegate = new WeakReference<>(delegate); + + MinecraftServer server = delegate.getServer(); + this.worldFolder = delegate.getServer().getRunDirectory().toPath() + .resolve(server.getSavePath(WorldSavePath.ROOT)); + + Identifier id = delegate.getRegistryKey().getValue(); + this.dimension = new Key(id.getNamespace(), id.getPath()); + } + + @Override + public boolean persistWorldChanges() throws IOException { + net.minecraft.server.world.ServerWorld world = delegate.get(); + if (world == null) return false; + + var taskResult = CompletableFuture.supplyAsync(() -> { + try { + world.save(null, true, false); + return true; + } catch (Exception e) { + throw new CompletionException(e); + } + }, world.getServer()); + + try { + return taskResult.get(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new IOException(e); + } catch (ExecutionException e) { + Throwable t = e.getCause(); + if (t instanceof IOException) throw (IOException) t; + if (t instanceof IllegalArgumentException) throw (IllegalArgumentException) t; + throw new IOException(t); + } + } + + @Override + public Path getWorldFolder() { + return worldFolder; + } + + @Override + public Key getDimension() { + return dimension; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + FabricWorld that = (FabricWorld) o; + Object world = delegate.get(); + return world != null && world.equals(that.delegate.get()); + } + + @Override + public int hashCode() { + Object world = delegate.get(); + return world != null ? world.hashCode() : 0; + } + +} diff --git a/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/Log4jLogger.java b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/Log4jLogger.java new file mode 100644 index 00000000..9e60f395 --- /dev/null +++ b/implementations/fabric-1.20.5/src/main/java/de/bluecolored/bluemap/fabric/Log4jLogger.java @@ -0,0 +1,69 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.fabric; + +import org.apache.logging.log4j.Logger; + +import de.bluecolored.bluemap.core.logger.AbstractLogger; + +public class Log4jLogger extends AbstractLogger { + + private final Logger out; + + public Log4jLogger(Logger out) { + this.out = out; + } + + @Override + public void logError(String message, Throwable throwable) { + out.error(message, throwable); + } + + @Override + public void logWarning(String message) { + out.warn(message); + } + + @Override + public void logInfo(String message) { + out.info(message); + } + + @Override + public void logDebug(String message) { + if (out.isDebugEnabled()) out.debug(message); + } + + @Override + public void noFloodDebug(String message) { + if (out.isDebugEnabled()) super.noFloodDebug(message); + } + + @Override + public void noFloodDebug(String key, String message) { + if (out.isDebugEnabled()) super.noFloodDebug(key, message); + } + +} diff --git a/implementations/fabric-1.20.5/src/main/resources/assets/bluemap/icon.png b/implementations/fabric-1.20.5/src/main/resources/assets/bluemap/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..65d56d7a88fd8adb9003df6e0c10424b0ec8e375 GIT binary patch literal 10593 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 vi6!A+?}%zq>>?r?=0.15.10", + "fabric": "*", + "fabric-api-base": "*", + "minecraft": "*" + }, + "suggests": {} +} diff --git a/implementations/fabric/build.gradle.kts b/implementations/fabric/build.gradle.kts index 27517b4e..ab95a919 100644 --- a/implementations/fabric/build.gradle.kts +++ b/implementations/fabric/build.gradle.kts @@ -48,10 +48,10 @@ dependencies { exclude (group = "com.mojang", module = "brigadier") } - minecraft ("com.mojang:minecraft:1.20.5") - mappings ("net.fabricmc:yarn:1.20.5+build.1") - modImplementation ("net.fabricmc:fabric-loader:0.15.10") - modImplementation ("net.fabricmc.fabric-api:fabric-api:0.97.8+1.20.5") + minecraft ("com.mojang:minecraft:1.21") + mappings ("net.fabricmc:yarn:1.21+build.1") + modImplementation ("net.fabricmc:fabric-loader:0.15.11") + modImplementation ("net.fabricmc.fabric-api:fabric-api:0.100.1+1.21") modImplementation("me.lucko:fabric-permissions-api:0.1-SNAPSHOT") testImplementation ("org.junit.jupiter:junit-jupiter:5.9.0") @@ -135,7 +135,7 @@ modrinth { .readText() .replace("{version}", project.version.toString())) uploadFile.set(tasks.findByName("remappedShadowJar")) - gameVersions.addAll("1.20.5", "1.20.6") + gameVersions.addAll("1.21") dependencies { required.project("P7dR8mSH") // Fabric API } @@ -155,8 +155,7 @@ curseforge { addGameVersion("Java 21") - addGameVersion("1.20.5") - addGameVersion("1.20.6") + addGameVersion("1.21") mainArtifact(tasks.findByName("remappedShadowJar"), closureOf { relations(closureOf { diff --git a/implementations/fabric/src/main/java/de/bluecolored/bluemap/fabric/FabricWorld.java b/implementations/fabric/src/main/java/de/bluecolored/bluemap/fabric/FabricWorld.java index ff4468d9..ff1c106d 100644 --- a/implementations/fabric/src/main/java/de/bluecolored/bluemap/fabric/FabricWorld.java +++ b/implementations/fabric/src/main/java/de/bluecolored/bluemap/fabric/FabricWorld.java @@ -47,7 +47,7 @@ public FabricWorld(net.minecraft.server.world.ServerWorld delegate) { this.delegate = new WeakReference<>(delegate); MinecraftServer server = delegate.getServer(); - this.worldFolder = delegate.getServer().getRunDirectory().toPath() + this.worldFolder = delegate.getServer().getRunDirectory() .resolve(server.getSavePath(WorldSavePath.ROOT)); Identifier id = delegate.getRegistryKey().getValue(); diff --git a/implementations/forge-1.20.6/build.gradle b/implementations/forge-1.20.6/build.gradle new file mode 100644 index 00000000..bfb6604c --- /dev/null +++ b/implementations/forge-1.20.6/build.gradle @@ -0,0 +1,195 @@ +buildscript { + repositories { + // These repositories are only for Gradle plugins, put any other repositories in the repository block further below + maven { url = 'https://maven.minecraftforge.net' } + mavenCentral() + } + dependencies { + classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '[6.0.24,6.2)', changing: true + } +} + +plugins { + id "java" + id "java-library" + id "com.diffplug.spotless" version "6.1.2" + id "com.github.node-gradle.node" version "3.0.1" + id "com.github.johnrengelman.shadow" version "8.1.1" + id "com.modrinth.minotaur" version "2.+" + id "com.matthewprenger.cursegradle" version "1.4.0" +} + +apply plugin: "net.minecraftforge.gradle" + +group = "de.bluecolored.bluemap" +version = System.getProperty("bluemap.version") ?: "?" // set by BlueMapCore +archivesBaseName = 'bluemap' + +java.toolchain.languageVersion = JavaLanguageVersion.of(21) + +minecraft { + mappings channel: 'official', version: '1.20.6' + + reobf = false + + runs { + server { + workingDirectory project.file('run') + property 'forge.logging.markers', 'REGISTRIES' + property 'forge.logging.console.level', 'debug' + + mods { + bluemap { + source sourceSets.main + } + } + } + } +} + +sourceSets.main.resources { srcDir 'src/generated/resources' } + +repositories { + mavenCentral() + maven { url = "https://libraries.minecraft.net" } + maven { url = "https://repo.bluecolored.de/releases" } +} + +configurations { + implementation.extendsFrom(shadowInclude) +} + +dependencies { + minecraft 'net.minecraftforge:forge:1.20.6-50.0.13' + + shadowInclude ("de.bluecolored.bluemap:BlueMapCommon") { + //exclude dependencies provided by forge + exclude (group: "com.google.guava", module: "guava") + exclude (group: "com.google.code.gson", module: "gson") + exclude (group: "com.mojang", module: "brigadier") + } + + testImplementation ("org.junit.jupiter:junit-jupiter:5.8.2") + testRuntimeOnly ("org.junit.jupiter:junit-jupiter-engine:5.8.2") +} + +spotless { + java { + target ("src/*/java/**/*.java") + + licenseHeaderFile("../../HEADER") + indentWithSpaces() + trimTrailingWhitespace() + } +} + +jar { + manifest { + attributes([ + "Specification-Title" : "bluemap", + "Specification-Vendor" : "bluemap", + "Specification-Version" : "1", // We are version 1 of ourselves + "Implementation-Title" : project.name, + "Implementation-Version" : project.jar.archiveVersion, + "Implementation-Vendor" : "bluemap", + "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ") + ]) + } +} + +tasks.withType(JavaCompile).configureEach { + options.encoding = "utf-8" +} + +tasks.withType(AbstractArchiveTask).configureEach { + setReproducibleFileOrder(true) + setPreserveFileTimestamps(false) +} + +test { + useJUnitPlatform() +} + +shadowJar { + def version = System.getProperty("bluemap.version") ?: "" // set by BlueMapCore + destinationDirectory.set(file("../../build/release")) + archiveFileName.set("BlueMap-${project.version}-${project.name}.jar") + + configurations = [project.configurations.shadowInclude] + + //relocate ("com.flowpowered.math", "de.bluecolored.shadow.flowpowered.math") //DON"T relocate this, because the API depends on it + relocate ("com.typesafe.config", "de.bluecolored.shadow.typesafe.config") + relocate ("de.bluecolored.bluenbt", "de.bluecolored.shadow.bluenbt") + relocate ("org.spongepowered.configurate", "de.bluecolored.shadow.configurate") + relocate ("com.github.benmanes.caffeine", "de.bluecolored.shadow.benmanes.caffeine") + relocate ("org.aopalliance", "de.bluecolored.shadow.aopalliance") + relocate ("javax.inject", "de.bluecolored.shadow.javax.inject") + relocate ("org.checkerframework", "de.bluecolored.shadow.checkerframework") + relocate ("org.codehaus", "de.bluecolored.shadow.codehaus") + relocate ("io.leangen.geantyref", "de.bluecolored.shadow.geantyref") + relocate ("io.airlift", "de.bluecolored.shadow.airlift") + relocate ("net.jpountz", "de.bluecolored.shadow.jpountz") + + relocate ("com.google.errorprone", "de.bluecolored.shadow.google.errorprone") + relocate ("com.google.inject", "de.bluecolored.shadow.google.inject") + + relocate ("org.apache.commons.dbcp2", "de.bluecolored.shadow.apache.commons.dbcp2") + relocate ("org.apache.commons.logging", "de.bluecolored.shadow.apache.commons.logging") + relocate ("org.apache.commons.pool2", "de.bluecolored.shadow.apache.commons.pool2") +} + +processResources { + from(sourceSets.main.resources.srcDirs) { + include 'mcmod.info','META-INF/mods.toml' + duplicatesStrategy = DuplicatesStrategy.WARN + + expand ( + version: project.version + ) + } +} + +task release { + dependsOn(shadowJar) +} + +modrinth { + token = System.getenv("MODRINTH_TOKEN") + projectId = "swbUV1cr" + versionNumber = "${project.version}-${project.name}" + changelog = file("../../release.md") + .getText() + .replace("{version}", project.version.toString()) + uploadFile = shadowJar + gameVersions = ["1.20.6"] +} + +curseforge { + apiKey = System.getenv("CURSEFORGE_TOKEN") ?: "" + project { + id = "406463" + changelogType = "markdown" + changelog = file("../../release.md") + .getText() + .replace("{version}", project.version.toString()) + releaseType = "release" + + addGameVersion "Forge" + + addGameVersion "Java 21" + + addGameVersion "1.20.6" + + mainArtifact shadowJar + } + options { + javaVersionAutoDetect = false + javaIntegration = false + forgeGradleIntegration = false + } +} + +task publish { + dependsOn(tasks.findByName("modrinth")) + dependsOn(tasks.findByName("curseforge")) +} diff --git a/implementations/forge-1.20.6/settings.gradle.kts b/implementations/forge-1.20.6/settings.gradle.kts new file mode 100644 index 00000000..7425b900 --- /dev/null +++ b/implementations/forge-1.20.6/settings.gradle.kts @@ -0,0 +1,3 @@ +rootProject.name = "forge-1.20.6" + +includeBuild("../../BlueMapCommon") diff --git a/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeCommandSource.java b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeCommandSource.java new file mode 100644 index 00000000..564b7b25 --- /dev/null +++ b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeCommandSource.java @@ -0,0 +1,78 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.forge; + +import com.flowpowered.math.vector.Vector3d; +import de.bluecolored.bluemap.common.plugin.Plugin; +import de.bluecolored.bluemap.common.plugin.text.Text; +import de.bluecolored.bluemap.common.serverinterface.CommandSource; +import de.bluecolored.bluemap.common.serverinterface.ServerWorld; +import de.bluecolored.bluemap.core.world.World; +import net.minecraft.commands.CommandSourceStack; +import net.minecraft.core.HolderLookup; +import net.minecraft.data.registries.VanillaRegistries; +import net.minecraft.network.chat.Component; + +import java.util.Optional; + +public class ForgeCommandSource implements CommandSource { + + private static final HolderLookup.Provider lookup = VanillaRegistries.createLookup(); + + private final ForgeMod mod; + private final Plugin plugin; + private final CommandSourceStack delegate; + + public ForgeCommandSource(ForgeMod mod, Plugin plugin, CommandSourceStack delegate) { + this.mod = mod; + this.plugin = plugin; + this.delegate = delegate; + } + + @Override + public void sendMessage(Text text) { + var component = Component.Serializer.fromJsonLenient(text.toJSONString(), lookup); + if (component != null) + delegate.sendSuccess(() -> component, false); + } + + @Override + public boolean hasPermission(String permission) { + return delegate.hasPermission(1); + } + + @Override + public Optional getPosition() { + var pos = delegate.getPosition(); + return Optional.of(new Vector3d(pos.x, pos.y, pos.z)); + } + + @Override + public Optional getWorld() { + ServerWorld serverWorld = mod.getServerWorld(delegate.getLevel()); + return Optional.ofNullable(plugin.getWorld(serverWorld)); + } + +} diff --git a/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeEventForwarder.java b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeEventForwarder.java new file mode 100644 index 00000000..f4311881 --- /dev/null +++ b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeEventForwarder.java @@ -0,0 +1,67 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.forge; + +import de.bluecolored.bluemap.common.serverinterface.ServerEventListener; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent; +import net.minecraftforge.event.entity.player.PlayerEvent.PlayerLoggedOutEvent; +import net.minecraftforge.eventbus.api.SubscribeEvent; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.UUID; + +public class ForgeEventForwarder { + + private final Collection eventListeners; + + public ForgeEventForwarder() { + this.eventListeners = new ArrayList<>(1); + + MinecraftForge.EVENT_BUS.register(this); + } + + public synchronized void addEventListener(ServerEventListener listener) { + this.eventListeners.add(listener); + } + + public synchronized void removeAllListeners() { + this.eventListeners.clear(); + } + + @SubscribeEvent + public synchronized void onPlayerJoin(PlayerLoggedInEvent evt) { + UUID uuid = evt.getEntity().getUUID(); + for (ServerEventListener listener : eventListeners) listener.onPlayerJoin(uuid); + } + + @SubscribeEvent + public synchronized void onPlayerLeave(PlayerLoggedOutEvent evt) { + UUID uuid = evt.getEntity().getUUID(); + for (ServerEventListener listener : eventListeners) listener.onPlayerLeave(uuid); + } + +} diff --git a/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeMod.java b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeMod.java new file mode 100644 index 00000000..2a3277f1 --- /dev/null +++ b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeMod.java @@ -0,0 +1,262 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.forge; + +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.benmanes.caffeine.cache.LoadingCache; +import de.bluecolored.bluemap.common.plugin.Plugin; +import de.bluecolored.bluemap.common.plugin.commands.Commands; +import de.bluecolored.bluemap.common.serverinterface.Player; +import de.bluecolored.bluemap.common.serverinterface.Server; +import de.bluecolored.bluemap.common.serverinterface.ServerEventListener; +import de.bluecolored.bluemap.common.serverinterface.ServerWorld; +import de.bluecolored.bluemap.core.BlueMap; +import de.bluecolored.bluemap.core.logger.Logger; +import net.minecraft.SharedConstants; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceKey; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ServerLevel; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.level.Level; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.RegisterCommandsEvent; +import net.minecraftforge.event.TickEvent.ServerTickEvent; +import net.minecraftforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent; +import net.minecraftforge.event.entity.player.PlayerEvent.PlayerLoggedOutEvent; +import net.minecraftforge.event.server.ServerStartedEvent; +import net.minecraftforge.event.server.ServerStartingEvent; +import net.minecraftforge.event.server.ServerStoppingEvent; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.IExtensionPoint; +import net.minecraftforge.fml.ModLoadingContext; +import net.minecraftforge.fml.common.Mod; +import org.apache.logging.log4j.LogManager; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +@Mod(Plugin.PLUGIN_ID) +public class ForgeMod implements Server { + + private final Plugin pluginInstance; + private MinecraftServer serverInstance = null; + + private final ForgeEventForwarder eventForwarder; + private final LoadingCache worlds; + + private int playerUpdateIndex = 0; + private final Map onlinePlayerMap; + private final List onlinePlayerList; + + public ForgeMod() { + Logger.global.clear(); + Logger.global.put(new Log4jLogger(LogManager.getLogger(Plugin.PLUGIN_NAME))); + + this.onlinePlayerMap = new ConcurrentHashMap<>(); + this.onlinePlayerList = Collections.synchronizedList(new ArrayList<>()); + + this.pluginInstance = new Plugin("forge", this); + + this.eventForwarder = new ForgeEventForwarder(); + this.worlds = Caffeine.newBuilder() + .executor(BlueMap.THREAD_POOL) + .weakKeys() + .maximumSize(1000) + .build(ForgeWorld::new); + + MinecraftForge.EVENT_BUS.register(this); + + //Make sure the mod being absent on the other network side does not cause the client to display the server as incompatible + ModLoadingContext.get().registerExtensionPoint( + IExtensionPoint.DisplayTest.class, + () -> new IExtensionPoint.DisplayTest( + () -> IExtensionPoint.DisplayTest.IGNORESERVERONLY, + (a, b) -> true + ) + ); + } + + @SubscribeEvent + public void onServerStarting(ServerStartingEvent event) { + this.serverInstance = event.getServer(); + } + + @SubscribeEvent + public void onRegisterCommands(RegisterCommandsEvent event) { + //register commands + new Commands<>(pluginInstance, event.getDispatcher(), forgeSource -> + new ForgeCommandSource(this, pluginInstance, forgeSource) + ); + } + + @SubscribeEvent + public void onServerStarted(ServerStartedEvent event) { + //save worlds to generate level.dat files + serverInstance.saveAllChunks(false, true, true); + + new Thread(() -> { + Logger.global.logInfo("Loading..."); + + try { + pluginInstance.load(); + if (pluginInstance.isLoaded()) Logger.global.logInfo("Loaded!"); + } catch (IOException e) { + Logger.global.logError("Failed to load bluemap!", e); + pluginInstance.unload(); + } + }, "BlueMap-Plugin-Loading").start(); + } + + @SubscribeEvent + public void onServerStopping(ServerStoppingEvent event) { + pluginInstance.unload(); + Logger.global.logInfo("BlueMap unloaded!"); + } + + @SubscribeEvent + public void onTick(ServerTickEvent evt) { + updateSomePlayers(); + } + + @Override + public String getMinecraftVersion() { + return SharedConstants.getCurrentVersion().getId(); + } + + @Override + public void registerListener(ServerEventListener listener) { + eventForwarder.addEventListener(listener); + } + + @Override + public void unregisterAllListeners() { + eventForwarder.removeAllListeners(); + } + + @Override + public Collection getLoadedServerWorlds() { + Collection loadedWorlds = new ArrayList<>(3); + for (ServerLevel serverWorld : serverInstance.getAllLevels()) { + loadedWorlds.add(worlds.get(serverWorld)); + } + return loadedWorlds; + } + + @SuppressWarnings("unchecked") + @Override + public Optional getServerWorld(Object world) { + + if (world instanceof String) { + ResourceLocation resourceLocation = ResourceLocation.tryParse((String) world); + if (resourceLocation != null) world = serverInstance.getLevel(ResourceKey.create(Registries.DIMENSION, resourceLocation)); + } + + if (world instanceof ResourceKey) { + try { + world = serverInstance.getLevel((ResourceKey) world); + } catch (ClassCastException ignored) {} + } + + if (world instanceof ServerLevel) + return Optional.of(getServerWorld((ServerLevel) world)); + + return Optional.empty(); + } + + public ServerWorld getServerWorld(ServerLevel world) { + return worlds.get(world); + } + + @Override + public Path getConfigFolder() { + return Path.of("config", "bluemap"); + } + + @Override + public Optional getModsFolder() { + return Optional.of(Path.of("mods")); + } + + @SubscribeEvent + public void onPlayerJoin(PlayerLoggedInEvent evt) { + var playerInstance = evt.getEntity(); + if (!(playerInstance instanceof ServerPlayer)) return; + + ForgePlayer player = new ForgePlayer(playerInstance.getUUID(), this); + onlinePlayerMap.put(player.getUuid(), player); + onlinePlayerList.add(player); + } + + @SubscribeEvent + public void onPlayerLeave(PlayerLoggedOutEvent evt) { + var player = evt.getEntity(); + if (!(player instanceof ServerPlayer)) return; + + UUID playerUUID = player.getUUID(); + onlinePlayerMap.remove(playerUUID); + synchronized (onlinePlayerList) { + onlinePlayerList.removeIf(p -> p.getUuid().equals(playerUUID)); + } + } + + public MinecraftServer getServer() { + return this.serverInstance; + } + + public Plugin getPlugin() { + return this.pluginInstance; + } + + @Override + public Collection getOnlinePlayers() { + return onlinePlayerMap.values(); + } + + /** + * Only update some of the online players each tick to minimize performance impact on the server-thread. + * Only call this method on the server-thread. + */ + private void updateSomePlayers() { + int onlinePlayerCount = onlinePlayerList.size(); + if (onlinePlayerCount == 0) return; + + int playersToBeUpdated = onlinePlayerCount / 20; //with 20 tps, each player is updated once a second + if (playersToBeUpdated == 0) playersToBeUpdated = 1; + + for (int i = 0; i < playersToBeUpdated; i++) { + playerUpdateIndex++; + if (playerUpdateIndex >= 20 && playerUpdateIndex >= onlinePlayerCount) playerUpdateIndex = 0; + + if (playerUpdateIndex < onlinePlayerCount) { + onlinePlayerList.get(playerUpdateIndex).update(); + } + } + } + +} diff --git a/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgePlayer.java b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgePlayer.java new file mode 100644 index 00000000..e90501b3 --- /dev/null +++ b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgePlayer.java @@ -0,0 +1,154 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.forge; + +import com.flowpowered.math.vector.Vector3d; +import de.bluecolored.bluemap.common.plugin.text.Text; +import de.bluecolored.bluemap.common.serverinterface.Gamemode; +import de.bluecolored.bluemap.common.serverinterface.Player; +import de.bluecolored.bluemap.common.serverinterface.ServerWorld; +import net.minecraft.core.BlockPos; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.effect.MobEffectInstance; +import net.minecraft.world.effect.MobEffects; +import net.minecraft.world.level.GameType; +import net.minecraft.world.level.LightLayer; +import net.minecraft.world.phys.Vec3; + +import java.util.EnumMap; +import java.util.Map; +import java.util.UUID; + +public class ForgePlayer implements Player { + + private static final Map GAMEMODE_MAP = new EnumMap<>(GameType.class); + static { + GAMEMODE_MAP.put(GameType.ADVENTURE, Gamemode.ADVENTURE); + GAMEMODE_MAP.put(GameType.SURVIVAL, Gamemode.SURVIVAL); + GAMEMODE_MAP.put(GameType.CREATIVE, Gamemode.CREATIVE); + GAMEMODE_MAP.put(GameType.SPECTATOR, Gamemode.SPECTATOR); + } + + private final UUID uuid; + private Text name; + private ServerWorld world; + private Vector3d position; + private Vector3d rotation; + private int skyLight; + private int blockLight; + private boolean sneaking; + private boolean invisible; + private Gamemode gamemode; + + private final ForgeMod mod; + + public ForgePlayer(UUID playerUuid, ForgeMod mod) { + this.uuid = playerUuid; + this.mod = mod; + + update(); + } + + @Override + public UUID getUuid() { + return this.uuid; + } + + @Override + public Text getName() { + return this.name; + } + + @Override + public ServerWorld getWorld() { + return this.world; + } + + @Override + public Vector3d getPosition() { + return this.position; + } + + @Override + public Vector3d getRotation() { + return rotation; + } + + @Override + public int getSkyLight() { + return skyLight; + } + + @Override + public int getBlockLight() { + return blockLight; + } + + @Override + public boolean isSneaking() { + return this.sneaking; + } + + @Override + public boolean isInvisible() { + return this.invisible; + } + + @Override + public Gamemode getGamemode() { + return this.gamemode; + } + + /** + * Only call on server thread! + */ + public void update() { + MinecraftServer server = mod.getServer(); + if (server == null) return; + + ServerPlayer player = server.getPlayerList().getPlayer(uuid); + if (player == null) return; + + this.gamemode = GAMEMODE_MAP.getOrDefault(player.gameMode.getGameModeForPlayer(), Gamemode.SURVIVAL); + if (this.gamemode == null) this.gamemode = Gamemode.SURVIVAL; + + MobEffectInstance invis = player.getEffect(MobEffects.INVISIBILITY); + this.invisible = invis != null && invis.getDuration() > 0; + + this.name = Text.of(player.getName().getString()); + + Vec3 pos = player.getPosition(1f); + this.position = new Vector3d(pos.x(), pos.y(), pos.z()); + this.rotation = new Vector3d(player.getXRot(), player.getYHeadRot(), 0); + this.sneaking = player.isCrouching(); + + this.skyLight = player.level().getChunkSource().getLightEngine().getLayerListener(LightLayer.SKY).getLightValue(new BlockPos(player.getBlockX(), player.getBlockY(), player.getBlockZ())); + this.blockLight = player.level().getChunkSource().getLightEngine().getLayerListener(LightLayer.BLOCK).getLightValue(new BlockPos(player.getBlockX(), player.getBlockY(), player.getBlockZ())); + + this.world = mod.getServerWorld(player.serverLevel()); + } + +} diff --git a/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java new file mode 100644 index 00000000..dc2284be --- /dev/null +++ b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java @@ -0,0 +1,111 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.forge; + +import de.bluecolored.bluemap.common.serverinterface.ServerWorld; +import de.bluecolored.bluemap.core.util.Key; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ServerLevel; +import net.minecraft.world.level.storage.LevelResource; + +import java.io.IOException; +import java.lang.ref.WeakReference; +import java.nio.file.Path; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.ExecutionException; + +public class ForgeWorld implements ServerWorld { + + private final WeakReference delegate; + private final Path worldFolder; + private final Key dimension; + + public ForgeWorld(ServerLevel delegate) { + this.delegate = new WeakReference<>(delegate); + + MinecraftServer server = delegate.getServer(); + this.worldFolder = delegate.getServer().getServerDirectory().toPath() + .resolve(server.getWorldPath(LevelResource.ROOT)); + + ResourceLocation id = delegate.dimension().location(); + this.dimension = new Key(id.getNamespace(), id.getPath()); + } + + @Override + public boolean persistWorldChanges() throws IOException { + ServerLevel world = delegate.get(); + if (world == null) return false; + + var taskResult = CompletableFuture.supplyAsync(() -> { + try { + world.save(null, true, false); + return true; + } catch (Exception e) { + throw new CompletionException(e); + } + }, world.getServer()); + + try { + return taskResult.get(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new IOException(e); + } catch (ExecutionException e) { + Throwable t = e.getCause(); + if (t instanceof IOException) throw (IOException) t; + if (t instanceof IllegalArgumentException) throw (IllegalArgumentException) t; + throw new IOException(t); + } + } + + @Override + public Path getWorldFolder() { + return worldFolder; + } + + @Override + public Key getDimension() { + return dimension; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + ForgeWorld that = (ForgeWorld) o; + Object world = delegate.get(); + return world != null && world.equals(that.delegate.get()); + } + + @Override + public int hashCode() { + Object world = delegate.get(); + return world != null ? world.hashCode() : 0; + } + +} diff --git a/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/Log4jLogger.java b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/Log4jLogger.java new file mode 100644 index 00000000..a77265e0 --- /dev/null +++ b/implementations/forge-1.20.6/src/main/java/de/bluecolored/bluemap/forge/Log4jLogger.java @@ -0,0 +1,69 @@ +/* + * This file is part of BlueMap, licensed under the MIT License (MIT). + * + * Copyright (c) Blue (Lukas Rieger) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package de.bluecolored.bluemap.forge; + +import org.apache.logging.log4j.Logger; + +import de.bluecolored.bluemap.core.logger.AbstractLogger; + +public class Log4jLogger extends AbstractLogger { + + private final Logger out; + + public Log4jLogger(Logger out) { + this.out = out; + } + + @Override + public void logError(String message, Throwable throwable) { + out.error(message, throwable); + } + + @Override + public void logWarning(String message) { + out.warn(message); + } + + @Override + public void logInfo(String message) { + out.info(message); + } + + @Override + public void logDebug(String message) { + if (out.isDebugEnabled()) out.debug(message); + } + + @Override + public void noFloodDebug(String message) { + if (out.isDebugEnabled()) super.noFloodDebug(message); + } + + @Override + public void noFloodDebug(String key, String message) { + if (out.isDebugEnabled()) super.noFloodDebug(key, message); + } + +} diff --git a/implementations/forge-1.20.6/src/main/resources/META-INF/mods.toml b/implementations/forge-1.20.6/src/main/resources/META-INF/mods.toml new file mode 100644 index 00000000..e5f5a4cb --- /dev/null +++ b/implementations/forge-1.20.6/src/main/resources/META-INF/mods.toml @@ -0,0 +1,26 @@ +modLoader="javafml" +loaderVersion="[44,)" +license="MIT" +issueTrackerURL="https://github.com/BlueMap-Minecraft/BlueMap/issues" +[[mods]] +modId="bluemap" +version="${version}" +displayName="BlueMap" +displayURL="https://github.com/BlueMap-Minecraft/BlueMap" +authors="Blue (TBlueF, Lukas Rieger)" +description=''' +A 3d-map of your Minecraft worlds view-able in your browser using three.js (WebGL) +''' + +[[dependencies.bluemap]] + modId="forge" + mandatory=true + versionRange="[50,)" + ordering="NONE" + side="SERVER" +[[dependencies.bluemap]] + modId="minecraft" + mandatory=true + versionRange="[1.20.6,)" + ordering="NONE" + side="SERVER" diff --git a/implementations/forge-1.20.6/src/main/resources/pack.mcmeta b/implementations/forge-1.20.6/src/main/resources/pack.mcmeta new file mode 100644 index 00000000..0f95ce1c --- /dev/null +++ b/implementations/forge-1.20.6/src/main/resources/pack.mcmeta @@ -0,0 +1,6 @@ +{ + "pack": { + "description": "BlueMap - A 3d-map of your Minecraft worlds view-able in your browser using three.js (WebGL)", + "pack_format": 8 + } +} diff --git a/implementations/forge/build.gradle b/implementations/forge/build.gradle index bfb6604c..9b020e78 100644 --- a/implementations/forge/build.gradle +++ b/implementations/forge/build.gradle @@ -28,7 +28,7 @@ archivesBaseName = 'bluemap' java.toolchain.languageVersion = JavaLanguageVersion.of(21) minecraft { - mappings channel: 'official', version: '1.20.6' + mappings channel: 'official', version: '1.21' reobf = false @@ -60,7 +60,7 @@ configurations { } dependencies { - minecraft 'net.minecraftforge:forge:1.20.6-50.0.13' + minecraft 'net.minecraftforge:forge:1.21-51.0.1' shadowInclude ("de.bluecolored.bluemap:BlueMapCommon") { //exclude dependencies provided by forge @@ -161,7 +161,7 @@ modrinth { .getText() .replace("{version}", project.version.toString()) uploadFile = shadowJar - gameVersions = ["1.20.6"] + gameVersions = ["1.21"] } curseforge { @@ -178,7 +178,7 @@ curseforge { addGameVersion "Java 21" - addGameVersion "1.20.6" + addGameVersion "1.21" mainArtifact shadowJar } diff --git a/implementations/forge/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java b/implementations/forge/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java index dc2284be..404f5e91 100644 --- a/implementations/forge/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java +++ b/implementations/forge/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java @@ -48,7 +48,7 @@ public ForgeWorld(ServerLevel delegate) { this.delegate = new WeakReference<>(delegate); MinecraftServer server = delegate.getServer(); - this.worldFolder = delegate.getServer().getServerDirectory().toPath() + this.worldFolder = delegate.getServer().getServerDirectory() .resolve(server.getWorldPath(LevelResource.ROOT)); ResourceLocation id = delegate.dimension().location(); diff --git a/implementations/neoforge/build.gradle b/implementations/neoforge/build.gradle index 700e8bc4..e8fd2e96 100644 --- a/implementations/neoforge/build.gradle +++ b/implementations/neoforge/build.gradle @@ -1,7 +1,7 @@ plugins { id "java" id "java-library" - id "net.neoforged.gradle.userdev" version '7.0.120' + id "net.neoforged.gradle.userdev" version '7.0.142' id "com.diffplug.spotless" version "6.1.2" id "com.github.node-gradle.node" version "3.0.1" id "com.modrinth.minotaur" version "2.+" @@ -127,7 +127,7 @@ modrinth { .replace("{version}", project.version.toString()) uploadFile = shadowJar loaders = ["neoforge"] - gameVersions = ["1.20.6"] + gameVersions = ["1.21"] } curseforge { @@ -144,7 +144,7 @@ curseforge { addGameVersion "Java 21" - addGameVersion "1.20.6" + addGameVersion "1.21" mainArtifact shadowJar } diff --git a/implementations/neoforge/gradle.properties b/implementations/neoforge/gradle.properties index 5f51b4da..07c1fb5d 100644 --- a/implementations/neoforge/gradle.properties +++ b/implementations/neoforge/gradle.properties @@ -4,11 +4,11 @@ org.gradle.debug=false neogradle.subsystems.parchment.minecraftVersion=1.20.6 neogradle.subsystems.parchment.mappingsVersion=2024.05.01 -minecraft_version=1.20.6 -minecraft_version_range=[1.20.6,1.21) -neo_version=20.6.43-beta -neo_version_range=[20.5,) -loader_version_range=[2,) +minecraft_version=1.21 +minecraft_version_range=[1.21,) +neo_version=21.0.0-beta +neo_version_range=[21.0.0-beta,) +loader_version_range=[4,) mod_id=bluemap mod_name=BlueMap diff --git a/implementations/neoforge/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java b/implementations/neoforge/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java index dc2284be..404f5e91 100644 --- a/implementations/neoforge/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java +++ b/implementations/neoforge/src/main/java/de/bluecolored/bluemap/forge/ForgeWorld.java @@ -48,7 +48,7 @@ public ForgeWorld(ServerLevel delegate) { this.delegate = new WeakReference<>(delegate); MinecraftServer server = delegate.getServer(); - this.worldFolder = delegate.getServer().getServerDirectory().toPath() + this.worldFolder = delegate.getServer().getServerDirectory() .resolve(server.getWorldPath(LevelResource.ROOT)); ResourceLocation id = delegate.dimension().location(); diff --git a/settings.gradle.kts b/settings.gradle.kts index b7e50cbb..52e023eb 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -21,7 +21,9 @@ includeBuild("implementations/sponge") includeBuild("implementations/forge-1.18.1") includeBuild("implementations/forge-1.19.4") includeBuild("implementations/forge-1.20") +includeBuild("implementations/forge-1.20.6") includeBuild("implementations/fabric-1.18") includeBuild("implementations/fabric-1.19.4") includeBuild("implementations/fabric-1.20") +includeBuild("implementations/fabric-1.20.5")