diff --git a/implementations/sponge-8.0.0/src/main/java/de/bluecolored/bluemap/sponge/Log4J2Logger.java b/implementations/sponge-8.0.0/src/main/java/de/bluecolored/bluemap/sponge/Log4J2Logger.java index 6390081a..0a7c607d 100644 --- a/implementations/sponge-8.0.0/src/main/java/de/bluecolored/bluemap/sponge/Log4J2Logger.java +++ b/implementations/sponge-8.0.0/src/main/java/de/bluecolored/bluemap/sponge/Log4J2Logger.java @@ -29,7 +29,7 @@ import org.apache.logging.log4j.Logger; public class Log4J2Logger extends AbstractLogger { - private Logger out; + private final Logger out; public Log4J2Logger(Logger out) { this.out = out; diff --git a/implementations/sponge-9.0.0/build.gradle.kts b/implementations/sponge-9.0.0/build.gradle.kts new file mode 100644 index 00000000..bdcb3b19 --- /dev/null +++ b/implementations/sponge-9.0.0/build.gradle.kts @@ -0,0 +1,129 @@ +import org.spongepowered.gradle.plugin.config.PluginLoaders + +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 "7.1.2" + id ("org.spongepowered.gradle.plugin") version "2.0.0" +} + +group = "de.bluecolored.bluemap.bukkit" +version = System.getProperty("bluemap.version") ?: "?" // set by BlueMapCore + +val javaTarget = 17 +java { + sourceCompatibility = JavaVersion.toVersion(javaTarget) + targetCompatibility = JavaVersion.toVersion(javaTarget) +} + +repositories { + mavenCentral() + maven { + setUrl("https://libraries.minecraft.net") + } + maven { + setUrl("https://jitpack.io") + } +} + +dependencies { + api ("de.bluecolored.bluemap.common:BlueMapCommon"){ + //exclude dependencies provided by sponge + exclude( group = "com.google.guava", module = "guava" ) + exclude( group = "com.google.code.gson", module = "gson" ) + exclude( group = "org.apache.commons", module = "commons-lang3" ) + exclude( group = "javax.inject" ) + exclude( group = "com.google.inject" ) + } + + implementation ("org.bstats:bstats-sponge:2.2.1") + + testImplementation ("org.junit.jupiter:junit-jupiter:5.8.2") + testRuntimeOnly ("org.junit.jupiter:junit-jupiter-engine:5.8.2") +} + +sponge { + apiVersion("9.0.0-SNAPSHOT") + license("MIT") + loader { + name(PluginLoaders.JAVA_PLAIN) + version("1.0") + } + plugin("bluemap") { + displayName("bluemap") + entrypoint("de.bluecolored.bluemap.sponge.SpongePlugin") + description("A 3d-map of your Minecraft worlds view-able in your browser using three.js (WebGL)") + contributor("Blue (TBlueF, Lukas Rieger)") { + description("Lead Developer") + } + dependency("spongeapi") { + version("9.0.0-SNAPSHOT") + optional(false) + } + } +} + +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 { + from("src/main/resources") { + include("META-INF/plugins.json") + duplicatesStrategy = DuplicatesStrategy.INCLUDE + + expand ( + "version" to project.version + ) + } +} + +tasks.shadowJar { + destinationDirectory.set(file("../../build/release")) + archiveFileName.set("BlueMap-${project.version}-${project.name}.jar") + + //relocate ("com.flowpowered.math", "de.bluecolored.shadow.flowpowered.math") //DON"T relocate this, because the API depends on it + relocate ("net.querz.nbt", "de.bluecolored.shadow.querz.nbt") + relocate ("com.mojang.brigadier", "de.bluecolored.shadow.mojang.brigadier") + relocate ("com.github.benmanes.caffeine", "de.bluecolored.shadow.benmanes.caffeine") + relocate ("com.google.errorprone", "de.bluecolored.shadow.google.errorprone") + relocate ("org.spongepowered.configurate", "de.bluecolored.shadow.configurate") + relocate ("org.aopalliance", "de.bluecolored.shadow.aopalliance") + relocate ("org.bstats", "de.bluecolored.shadow.bstats") + relocate ("com.typesafe.config", "de.bluecolored.shadow.typesafe.config") + relocate ("org.checkerframework", "de.bluecolored.shadow.checkerframework") + relocate ("org.codehaus", "de.bluecolored.shadow.codehaus") + relocate ("io.leangen.geantyref", "de.bluecolored.shadow.geantyref") + + relocate ("org.apache.commons.dbcp2", "de.bluecolored.shadow.apache.commons.dbcp2") + relocate ("org.apache.commons.io", "de.bluecolored.shadow.apache.commons.io") + relocate ("org.apache.commons.logging", "de.bluecolored.shadow.apache.commons.logging") + relocate ("org.apache.commons.pool2", "de.bluecolored.shadow.apache.commons.pool2") +} + +tasks.register("release") { + dependsOn(tasks.shadowJar) +} diff --git a/implementations/sponge-9.0.0/gradle/wrapper/gradle-wrapper.jar b/implementations/sponge-9.0.0/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 00000000..7454180f Binary files /dev/null and b/implementations/sponge-9.0.0/gradle/wrapper/gradle-wrapper.jar differ diff --git a/implementations/sponge-9.0.0/gradle/wrapper/gradle-wrapper.properties b/implementations/sponge-9.0.0/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 00000000..41dfb879 --- /dev/null +++ b/implementations/sponge-9.0.0/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/implementations/sponge-9.0.0/gradlew b/implementations/sponge-9.0.0/gradlew new file mode 100644 index 00000000..744e882e --- /dev/null +++ b/implementations/sponge-9.0.0/gradlew @@ -0,0 +1,185 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MSYS* | MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=`expr $i + 1` + done + case $i in + 0) set -- ;; + 1) set -- "$args0" ;; + 2) set -- "$args0" "$args1" ;; + 3) set -- "$args0" "$args1" "$args2" ;; + 4) set -- "$args0" "$args1" "$args2" "$args3" ;; + 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=`save "$@"` + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +exec "$JAVACMD" "$@" diff --git a/implementations/sponge-9.0.0/gradlew.bat b/implementations/sponge-9.0.0/gradlew.bat new file mode 100644 index 00000000..107acd32 --- /dev/null +++ b/implementations/sponge-9.0.0/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/implementations/sponge-9.0.0/settings.gradle.kts b/implementations/sponge-9.0.0/settings.gradle.kts new file mode 100644 index 00000000..4f00a912 --- /dev/null +++ b/implementations/sponge-9.0.0/settings.gradle.kts @@ -0,0 +1,3 @@ +rootProject.name = "sponge-9.0.0" + +includeBuild("../../BlueMapCommon") \ No newline at end of file diff --git a/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/EventForwarder.java b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/EventForwarder.java new file mode 100644 index 00000000..0b605552 --- /dev/null +++ b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/EventForwarder.java @@ -0,0 +1,58 @@ +/* + * 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.sponge; + +import de.bluecolored.bluemap.common.plugin.text.Text; +import de.bluecolored.bluemap.common.serverinterface.ServerEventListener; +import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; +import org.spongepowered.api.event.Listener; +import org.spongepowered.api.event.Order; +import org.spongepowered.api.event.message.PlayerChatEvent; +import org.spongepowered.api.event.network.ServerSideConnectionEvent; + +public class EventForwarder { + + private ServerEventListener listener; + + public EventForwarder(ServerEventListener listener) { + this.listener = listener; + } + + @Listener(order = Order.POST) + public void onPlayerJoin(ServerSideConnectionEvent.Join evt) { + listener.onPlayerJoin(evt.player().uniqueId()); + } + + @Listener(order = Order.POST) + public void onPlayerLeave(ServerSideConnectionEvent.Disconnect evt) { + listener.onPlayerJoin(evt.player().uniqueId()); + } + + @Listener(order = Order.POST) + public void onPlayerChat(PlayerChatEvent evt) { + listener.onChatMessage(Text.of(PlainTextComponentSerializer.plainText().serialize(evt.message()))); + } + +} diff --git a/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/Log4J2Logger.java b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/Log4J2Logger.java new file mode 100644 index 00000000..0a7c607d --- /dev/null +++ b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/Log4J2Logger.java @@ -0,0 +1,68 @@ +/* + * 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.sponge; + +import de.bluecolored.bluemap.core.logger.AbstractLogger; +import org.apache.logging.log4j.Logger; + +public class Log4J2Logger extends AbstractLogger { + + private final Logger out; + + public Log4J2Logger(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/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongeCommandSource.java b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongeCommandSource.java new file mode 100644 index 00000000..ccf78012 --- /dev/null +++ b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongeCommandSource.java @@ -0,0 +1,84 @@ +/* + * 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.sponge; + +import com.flowpowered.math.vector.Vector3d; +import de.bluecolored.bluemap.common.plugin.Plugin; +import de.bluecolored.bluemap.common.serverinterface.CommandSource; +import de.bluecolored.bluemap.common.plugin.text.Text; +import de.bluecolored.bluemap.core.world.World; +import net.kyori.adventure.audience.Audience; +import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer; +import org.spongepowered.api.service.permission.Subject; +import org.spongepowered.api.world.Locatable; + +import java.io.IOException; +import java.util.Optional; + +public class SpongeCommandSource implements CommandSource { + + private final Plugin plugin; + private final Audience audience; + private final Subject subject; + + public SpongeCommandSource(Plugin plugin, Audience audience, Subject subject) { + this.plugin = plugin; + this.subject = subject; + this.audience = audience; + } + + @Override + public void sendMessage(Text text) { + audience.sendMessage(GsonComponentSerializer.gson().deserialize(text.toJSONString())); + } + + @Override + public boolean hasPermission(String permission) { + return subject.hasPermission(permission); + } + + @Override + public Optional getPosition() { + if (audience instanceof Locatable) { + return Optional.of(SpongePlugin.fromSpongePoweredVector(((Locatable) audience).location().position())); + } + + return Optional.empty(); + } + + @Override + public Optional getWorld() { + if (audience instanceof Locatable locatable) { + try { + var serverWorld = SpongePlugin.getInstance().getWorld(locatable.serverLocation().world()); + String worldId = plugin.getBlueMap().getWorldId(serverWorld.getSaveFolder()); + return Optional.ofNullable(plugin.getWorlds().get(worldId)); + } catch (IOException ignore) {} + } + + return Optional.empty(); + } + +} diff --git a/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongeCommands.java b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongeCommands.java new file mode 100644 index 00000000..ac20c1d6 --- /dev/null +++ b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongeCommands.java @@ -0,0 +1,166 @@ +/* + * 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.sponge; + +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.Message; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestion; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.tree.CommandNode; +import de.bluecolored.bluemap.common.plugin.Plugin; +import de.bluecolored.bluemap.common.plugin.commands.Commands; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.JoinConfiguration; +import net.kyori.adventure.text.format.NamedTextColor; +import org.spongepowered.api.command.Command; +import org.spongepowered.api.command.CommandCause; +import org.spongepowered.api.command.CommandCompletion; +import org.spongepowered.api.command.CommandResult; +import org.spongepowered.api.command.parameter.ArgumentReader; + +import java.util.*; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class SpongeCommands { + + private final CommandDispatcher dispatcher; + + public SpongeCommands(final Plugin plugin) { + this.dispatcher = new CommandDispatcher<>(); + + // register commands + new Commands<>(plugin, dispatcher, cause -> new SpongeCommandSource(plugin, cause.audience(), cause.subject())); + } + + public Collection getRootCommands(){ + Collection rootCommands = new ArrayList<>(); + + for (CommandNode node : this.dispatcher.getRoot().getChildren()) { + rootCommands.add(new SpongeCommandProxy(node.getName())); + } + + return rootCommands; + } + + public class SpongeCommandProxy implements Command.Raw { + + private final String label; + + protected SpongeCommandProxy(String label) { + this.label = label; + } + + public String getLabel() { + return label; + } + + @Override + public CommandResult process(CommandCause cause, ArgumentReader.Mutable arguments) { + String command = label; + if (!arguments.input().isEmpty()) { + command += " " + arguments.input(); + } + + try { + return CommandResult.builder().result(dispatcher.execute(command, cause)).build(); + } catch (CommandSyntaxException ex) { + Component errText = Component.text(ex.getRawMessage().getString(), NamedTextColor.RED); + + String context = ex.getContext(); + if (context != null) + errText = errText.append(Component.newline()).append(Component.text(context, NamedTextColor.GRAY)); + + return CommandResult.error(errText); + } + } + + @Override + public List complete(CommandCause cause, ArgumentReader.Mutable arguments) { + String command = label; + if (!arguments.input().isEmpty()) { + command += " " + arguments.input(); + } + + List completions = new ArrayList<>(); + + try { + Suggestions suggestions = dispatcher.getCompletionSuggestions(dispatcher.parse(command, cause)).get(100, TimeUnit.MILLISECONDS); + for (Suggestion suggestion : suggestions.getList()) { + String text = suggestion.getText(); + + if (text.indexOf(' ') == -1) { + Message tooltip = suggestion.getTooltip(); + if (tooltip == null) { + completions.add(CommandCompletion.of(text)); + } else { + completions.add(CommandCompletion.of(text, Component.text(tooltip.getString()))); + } + } + } + } catch (InterruptedException ignore) { + Thread.currentThread().interrupt(); + } catch (ExecutionException | TimeoutException ignore) {} + + completions.sort(Comparator.comparing(CommandCompletion::completion)); + + return completions; + } + + @Override + public boolean canExecute(CommandCause cause) { + return true; + } + + @Override + public Optional shortDescription(CommandCause cause) { + return Optional.empty(); + } + + @Override + public Optional extendedDescription(CommandCause cause) { + return Optional.empty(); + } + + @Override + public Component usage(CommandCause cause) { + CommandNode node = dispatcher.getRoot().getChild(label); + if (node == null) return Component.text("/" + label); + + List lines = new ArrayList<>(); + for (String usageString : dispatcher.getSmartUsage(node, cause).values()) { + lines.add(Component.text("/" + label + " ", NamedTextColor.WHITE).append(Component.text(usageString, NamedTextColor.GRAY))); + } + + return Component.join(JoinConfiguration.builder() + .separator(Component.newline()) + .build(), + lines); + } + } + +} diff --git a/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongePlayer.java b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongePlayer.java new file mode 100644 index 00000000..c77ea4de --- /dev/null +++ b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongePlayer.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.sponge; + +import com.flowpowered.math.vector.Vector3d; +import de.bluecolored.bluemap.common.serverinterface.Gamemode; +import de.bluecolored.bluemap.common.serverinterface.Player; +import de.bluecolored.bluemap.common.plugin.text.Text; +import org.spongepowered.api.Sponge; +import org.spongepowered.api.data.Keys; +import org.spongepowered.api.effect.VanishState; +import org.spongepowered.api.effect.potion.PotionEffect; +import org.spongepowered.api.effect.potion.PotionEffectTypes; +import org.spongepowered.api.entity.living.player.gamemode.GameMode; +import org.spongepowered.api.entity.living.player.gamemode.GameModes; +import org.spongepowered.api.entity.living.player.server.ServerPlayer; + +import java.io.IOException; +import java.util.*; + +public class SpongePlayer implements Player { + + private static final Map GAMEMODE_MAP = new HashMap<>(5); + static { + GAMEMODE_MAP.put(GameModes.ADVENTURE.get(), Gamemode.ADVENTURE); + GAMEMODE_MAP.put(GameModes.SURVIVAL.get(), Gamemode.SURVIVAL); + GAMEMODE_MAP.put(GameModes.CREATIVE.get(), Gamemode.CREATIVE); + GAMEMODE_MAP.put(GameModes.SPECTATOR.get(), Gamemode.SPECTATOR); + } + + private final UUID uuid; + private Text name; + private String world; + private Vector3d position; + private Vector3d rotation; + private boolean online; + private boolean sneaking; + private boolean invisible; + private boolean vanished; + private Gamemode gamemode; + + public SpongePlayer(UUID playerUUID) { + this.uuid = playerUUID; + update(); + } + + @Override + public UUID getUuid() { + return this.uuid; + } + + @Override + public Text getName() { + return this.name; + } + + @Override + public String getWorld() { + return this.world; + } + + @Override + public Vector3d getPosition() { + return this.position; + } + + @Override + public Vector3d getRotation() { + return rotation; + } + + @Override + public boolean isOnline() { + return this.online; + } + + @Override + public boolean isSneaking() { + return this.sneaking; + } + + @Override + public boolean isInvisible() { + return this.invisible; + } + + @Override + public boolean isVanished() { + return vanished; + } + + @Override + public Gamemode getGamemode() { + return this.gamemode; + } + + /** + * API access, only call on server thread! + */ + public void update() { + ServerPlayer player = Sponge.server().player(uuid).orElse(null); + if (player == null) { + this.online = false; + return; + } + + this.gamemode = GAMEMODE_MAP.get(player.get(Keys.GAME_MODE).orElse(GameModes.SURVIVAL.get())); + if (this.gamemode == null) this.gamemode = Gamemode.SURVIVAL; + + boolean invis = false; + Optional> effects = player.get(Keys.POTION_EFFECTS); + if (effects.isPresent()) { + for (PotionEffect effect : effects.get()) { + if (effect.type().equals(PotionEffectTypes.INVISIBILITY.get()) && effect.duration().ticks() > 0) invis = true; + } + } + this.invisible = invis; + + this.vanished = player.get(Keys.VANISH_STATE).orElse(VanishState.unvanished()).invisible(); + + this.name = Text.of(player.name()); + this.online = player.isOnline(); + this.position = SpongePlugin.fromSpongePoweredVector(player.position()); + this.rotation = SpongePlugin.fromSpongePoweredVector(player.rotation()); + this.sneaking = player.get(Keys.IS_SNEAKING).orElse(false); + + try { + var world = SpongePlugin.getInstance().getWorld(player.world()); + this.world = SpongePlugin.getInstance().getPlugin().getBlueMap().getWorldId(world.getSaveFolder()); + } catch (IOException e) { + this.world = "unknown"; + } + } + +} diff --git a/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongePlugin.java b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongePlugin.java new file mode 100644 index 00000000..74cf78f8 --- /dev/null +++ b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongePlugin.java @@ -0,0 +1,333 @@ +/* + * 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.sponge; + +import com.flowpowered.math.vector.Vector2i; +import com.flowpowered.math.vector.Vector3d; +import com.flowpowered.math.vector.Vector3i; +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.benmanes.caffeine.cache.LoadingCache; +import com.google.inject.Inject; +import de.bluecolored.bluemap.common.plugin.Plugin; +import de.bluecolored.bluemap.common.serverinterface.Player; +import de.bluecolored.bluemap.common.serverinterface.ServerEventListener; +import de.bluecolored.bluemap.common.serverinterface.ServerInterface; +import de.bluecolored.bluemap.common.serverinterface.ServerWorld; +import de.bluecolored.bluemap.core.BlueMap; +import de.bluecolored.bluemap.core.MinecraftVersion; +import de.bluecolored.bluemap.core.logger.Logger; +import de.bluecolored.bluemap.sponge.SpongeCommands.SpongeCommandProxy; +import org.apache.maven.artifact.versioning.ArtifactVersion; +import org.spongepowered.api.Platform; +import org.spongepowered.api.ResourceKey; +import org.spongepowered.api.Server; +import org.spongepowered.api.Sponge; +import org.spongepowered.api.command.Command; +import org.spongepowered.api.config.ConfigDir; +import org.spongepowered.api.entity.living.player.server.ServerPlayer; +import org.spongepowered.api.event.Listener; +import org.spongepowered.api.event.lifecycle.RefreshGameEvent; +import org.spongepowered.api.event.lifecycle.RegisterCommandEvent; +import org.spongepowered.api.event.lifecycle.StartedEngineEvent; +import org.spongepowered.api.event.lifecycle.StoppingEngineEvent; +import org.spongepowered.api.event.network.ServerSideConnectionEvent; +import org.spongepowered.api.scheduler.ScheduledTask; +import org.spongepowered.api.scheduler.Task; +import org.spongepowered.api.util.Ticks; +import org.spongepowered.api.util.Tristate; +import org.spongepowered.plugin.PluginContainer; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ExecutorService; + +@org.spongepowered.plugin.builtin.jvm.Plugin(Plugin.PLUGIN_ID) +public class SpongePlugin implements ServerInterface { + private static SpongePlugin instance; + + private final PluginContainer pluginContainer; + + @SuppressWarnings("unused") + @Inject + @ConfigDir(sharedRoot = false) + private Path configurationDir; + + private final Plugin pluginInstance; + private final SpongeCommands commands; + + private ExecutorService asyncExecutor; + private ExecutorService syncExecutor; + + private int playerUpdateIndex = 0; + private final Map onlinePlayerMap; + private final List onlinePlayerList; + + private final MinecraftVersion minecraftVersion; + private final LoadingCache worlds; + + @Inject + public SpongePlugin(org.apache.logging.log4j.Logger logger, PluginContainer pluginContainer/*, Metrics.Factory metricsFactory*/) { + Logger.global = new Log4J2Logger(logger); + this.pluginContainer = pluginContainer; + + this.onlinePlayerMap = new ConcurrentHashMap<>(); + this.onlinePlayerList = Collections.synchronizedList(new ArrayList<>()); + + final ArtifactVersion versionFromSponge = Sponge.platform().container(Platform.Component.GAME).metadata().version(); + this.minecraftVersion = new MinecraftVersion( + versionFromSponge.getMajorVersion(), + versionFromSponge.getMinorVersion(), + versionFromSponge.getIncrementalVersion() + ); + + this.pluginInstance = new Plugin("sponge-8.0.0", this); + this.commands = new SpongeCommands(pluginInstance); + + this.worlds = Caffeine.newBuilder() + .executor(BlueMap.THREAD_POOL) + .weakKeys() + .maximumSize(1000) + .build(SpongeWorld::new); + + //bstats + //metricsFactory.make(5911); + + SpongePlugin.instance = this; + } + + @Listener + public void onRegisterCommands(final RegisterCommandEvent event) { + //register commands + for(SpongeCommandProxy command : commands.getRootCommands()) { + event.register(this.pluginContainer, command, command.getLabel()); + } + + } + + @Listener + public void onServerStart(StartedEngineEvent evt) { + asyncExecutor = evt.game().asyncScheduler().executor(pluginContainer); + syncExecutor = evt.engine().scheduler().executor(pluginContainer); + + //start updating players + Task task = Task.builder() + .interval(Ticks.of(1)) + .execute(this::updateSomePlayers) + .plugin(pluginContainer) + .build(); + evt.engine().scheduler().submit(task); + + asyncExecutor.execute(() -> { + try { + Logger.global.logInfo("Loading..."); + pluginInstance.load(); + if (pluginInstance.isLoaded()) Logger.global.logInfo("Loaded!"); + } catch (IOException | RuntimeException e) { + Logger.global.logError("Failed to load!", e); + pluginInstance.unload(); + } + }); + } + + @Listener + public void onServerStop(StoppingEngineEvent evt) { + Logger.global.logInfo("Stopping..."); + evt.engine().scheduler().tasks(pluginContainer).forEach(ScheduledTask::cancel); + pluginInstance.unload(); + Logger.global.logInfo("Saved and stopped!"); + } + + @Listener + public void onServerReload(RefreshGameEvent evt) { + asyncExecutor.execute(() -> { + try { + Logger.global.logInfo("Reloading..."); + pluginInstance.reload(); + Logger.global.logInfo("Reloaded!"); + } catch (IOException | RuntimeException e) { + Logger.global.logError("Failed to load!", e); + pluginInstance.unload(); + } + }); + + // update player list + onlinePlayerMap.clear(); + synchronized (onlinePlayerList) { + onlinePlayerList.clear(); + for (ServerPlayer spongePlayer : Sponge.server().onlinePlayers()) { + SpongePlayer player = new SpongePlayer(spongePlayer.uniqueId()); + onlinePlayerMap.put(spongePlayer.uniqueId(), player); + onlinePlayerList.add(player); + } + } + } + + @Listener + public void onPlayerJoin(ServerSideConnectionEvent.Join evt) { + SpongePlayer player = new SpongePlayer(evt.player().uniqueId()); + onlinePlayerMap.put(evt.player().uniqueId(), player); + onlinePlayerList.add(player); + } + + @Listener + public void onPlayerLeave(ServerSideConnectionEvent.Disconnect evt) { + UUID playerUUID = evt.player().uniqueId(); + onlinePlayerMap.remove(playerUUID); + synchronized (onlinePlayerList) { + onlinePlayerList.removeIf(p -> p.getUuid().equals(playerUUID)); + } + } + + @Override + public MinecraftVersion getMinecraftVersion() { + return minecraftVersion; + } + + @Override + public void registerListener(ServerEventListener listener) { + Sponge.eventManager().registerListeners(this.pluginContainer, new EventForwarder(listener)); + } + + @Override + public void unregisterAllListeners() { + Sponge.eventManager().unregisterListeners(this.pluginContainer); + Sponge.eventManager().registerListeners(this.pluginContainer, this); + } + + @Override + public Collection getLoadedWorlds() { + Collection loadedWorlds = new ArrayList<>(3); + for (var world : Sponge.server().worldManager().worlds()) { + loadedWorlds.add(worlds.get(world)); + } + return loadedWorlds; + } + + @Override + public Optional getWorld(Object world) { + if (world instanceof Path) + return getWorld((Path) world); + + if (world instanceof ResourceKey) { + var serverWorld = Sponge.server().worldManager().world((ResourceKey) world).orElse(null); + if (serverWorld != null) world = serverWorld; + } + + if (world instanceof org.spongepowered.api.world.server.ServerWorld) + return Optional.of(getWorld((org.spongepowered.api.world.server.ServerWorld) world)); + + return Optional.empty(); + } + + public ServerWorld getWorld(org.spongepowered.api.world.server.ServerWorld world) { + return worlds.get(world); + } + + @Override + public Path getConfigFolder() { + return configurationDir; + } + + @Override + public Optional getModsFolder() { + return Optional.of(Path.of("mods")); + } + + @Override + public Collection getOnlinePlayers() { + return onlinePlayerMap.values(); + } + + @Override + public Optional getPlayer(UUID uuid) { + return Optional.ofNullable(onlinePlayerMap.get(uuid)); + } + + @Override + public de.bluecolored.bluemap.core.util.Tristate isMetricsEnabled() { + if (pluginContainer != null) { + Tristate metricsEnabled = Sponge.metricsConfigManager().collectionState(pluginContainer); + if (metricsEnabled != Tristate.UNDEFINED) { + if (metricsEnabled == Tristate.TRUE) return de.bluecolored.bluemap.core.util.Tristate.TRUE; + return de.bluecolored.bluemap.core.util.Tristate.FALSE; + } + } + + return switch (Sponge.metricsConfigManager().globalCollectionState()) { + case TRUE -> de.bluecolored.bluemap.core.util.Tristate.TRUE; + case FALSE -> de.bluecolored.bluemap.core.util.Tristate.FALSE; + default -> de.bluecolored.bluemap.core.util.Tristate.UNDEFINED; + }; + } + + /** + * 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() { + synchronized (onlinePlayerList) { + 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(); + } + } + } + } + + public static Vector3d fromSpongePoweredVector(org.spongepowered.math.vector.Vector3d vec) { + return new Vector3d(vec.x(), vec.y(), vec.z()); + } + + public static Vector3i fromSpongePoweredVector(org.spongepowered.math.vector.Vector3i vec) { + return new Vector3i(vec.x(), vec.y(), vec.z()); + } + + public static Vector2i fromSpongePoweredVector(org.spongepowered.math.vector.Vector2i vec) { + return new Vector2i(vec.x(), vec.y()); + } + + public ExecutorService getSyncExecutor() { + return syncExecutor; + } + + public Plugin getPlugin() { + return pluginInstance; + } + + public static SpongePlugin getInstance() { + return instance; + } +} diff --git a/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongeWorld.java b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongeWorld.java new file mode 100644 index 00000000..080ac4db --- /dev/null +++ b/implementations/sponge-9.0.0/src/main/java/de/bluecolored/bluemap/sponge/SpongeWorld.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.sponge; + +import de.bluecolored.bluemap.common.serverinterface.Dimension; +import de.bluecolored.bluemap.common.serverinterface.ServerWorld; +import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; +import org.spongepowered.api.world.WorldTypes; + +import java.io.IOException; +import java.lang.ref.WeakReference; +import java.nio.file.Path; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.ExecutionException; + +public class SpongeWorld implements ServerWorld { + + private final WeakReference delegate; + private final Path saveFolder; + + public SpongeWorld(org.spongepowered.api.world.server.ServerWorld delegate) { + this.delegate = new WeakReference<>(delegate); + this.saveFolder = delegate.directory() + .resolve(getDimension().getDimensionSubPath()) + .toAbsolutePath().normalize(); + } + + @Override + public Dimension getDimension() { + var world = delegate.get(); + if (world != null) { + if (world.worldType().equals(WorldTypes.THE_NETHER.get())) return Dimension.NETHER; + if (world.worldType().equals(WorldTypes.THE_END.get())) return Dimension.END; + } + return Dimension.OVERWORLD; + } + + @Override + public Optional getId() { + var world = delegate.get(); + if (world != null) { + return Optional.of(world.key().formatted()); + } + return Optional.empty(); + } + + @Override + public Optional getName() { + var world = delegate.get(); + if (world != null) { + return world.properties().displayName() + .map(PlainTextComponentSerializer.plainText()::serialize); + } + return Optional.empty(); + } + + @Override + public boolean persistWorldChanges() throws IOException { + var delegateWorld = delegate.get(); + if (delegateWorld == null) return false; + + try { + return CompletableFuture.supplyAsync(() -> { + try { + return delegateWorld.save(); + } catch (IOException e) { + throw new CompletionException(e); + } + }, SpongePlugin.getInstance().getSyncExecutor()).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 getSaveFolder() { + return this.saveFolder; + } + +} diff --git a/settings.gradle.kts b/settings.gradle.kts index c3770835..c4fb43ed 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -19,3 +19,4 @@ includeBuild("implementations/forge-1.19") includeBuild("implementations/spigot") includeBuild("implementations/sponge-8.0.0") +includeBuild("implementations/sponge-9.0.0")