更新到Minecraft 1.21.10

将命令参数文本抽离到各个文字的翻译文件内，现在只会显示当前语言的提示文字了
但是单人游戏内切换语言后必须重进世界才能完成游戏内热更新，并且独立服务器用不了这个特性，开放局域网的话应该是跟随主机的语言配置
2025-10-16 00:35:04 +08:00 · 2025-10-08 09:19:23 +08:00 · 2025-10-05 15:34:06 +08:00 · 2025-10-05 14:18:43 +08:00 · 2025-10-05 14:14:16 +08:00 · 2025-10-05 14:11:00 +08:00
17 changed files with 457 additions and 306 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -0,0 +1,9 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# Linux start script should use lf
+/gradlew        text eol=lf
+
+# These are Windows script files and should use crlf
+*.bat           text eol=crlf
+
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -0,0 +1,37 @@
+# Automatically build the project and run any configured tests for every push
+# and submitted pull request. This can help catch issues that only occur on
+# certain platforms or Java versions, and provides a first line of defence
+# against bad commits.
+
+name: build
+on: [pull_request, push]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        # Use these Java versions
+        java: [
+          21,    # Current Java LTS
+        ]
+    runs-on: ubuntu-22.04
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+      - name: validate gradle wrapper
+        uses: gradle/wrapper-validation-action@v2
+      - name: setup jdk ${{ matrix.java }}
+        uses: actions/setup-java@v4
+        with:
+          java-version: ${{ matrix.java }}
+          distribution: 'microsoft'
+      - name: make gradle wrapper executable
+        run: chmod +x ./gradlew
+      - name: build
+        run: ./gradlew build
+      - name: capture build artifacts
+        if: ${{ matrix.java == '21' }} # Only upload artifacts built from latest java
+        uses: actions/upload-artifact@v4
+        with:
+          name: Artifacts
+          path: build/libs/
--- a/README.md
+++ b/README.md
@@ -31,21 +31,19 @@
 - /rtp 1000 TheWhiteDog9487  
 将TheWhiteDog9487随机传送到以(0,0)为中心点，1000作为随机半径的范围内的随机一点  

- /rtp 1000 10000 ~ 10000  
+- /rtp 1000 10000 10000  
 将执行命令的玩家随机传送到以(10000,10000)为中心点，1000作为随机半径的范围内的随机一点
-提示：按照道理来说中心坐标是不需要高度（Y轴）的，但由于坐标的类型是Vec3d，所以还是要写高度的。  
-至于高度的具体数值，随便写，代码里也没用到过。  

 - /rtp 1000 TheWhiteDog9487 TheWhiteDog_CN  
 将TheWhiteDog9487随机传送到以TheWhiteDog_CN所在位置为中心点，1000作为随机半径的范围内的随机一点  

- /rtp 1000 TheWhiteDog9487 10000 ~ 10000  
+- /rtp 1000 TheWhiteDog9487 10000 10000  
 将TheWhiteDog9487随机传送到以(10000,10000)为中心点，1000作为随机半径的范围内的随机一点  

 - /rtp TheWhiteDog9487 1000 TheWhiteDog_CN  
 将TheWhiteDog9487随机传送到以TheWhiteDog_CN所在位置为中心点，1000作为随机半径的范围内的随机一点  

- /rtp TheWhiteDog9487 1000 10000 ~ 10000  
+- /rtp TheWhiteDog9487 1000 10000 10000  
 将TheWhiteDog9487随机传送到以(10000,10000)为中心点，1000作为随机半径的范围内的随机一点  

 ### 特别提示
@@ -73,6 +71,9 @@
    1. 服务器需要安装
    2. 客户端不需要

+**注意：情况2和3，如果其他玩家不安装本模组，他们看到的命令执行反馈就无法正确使用翻译，而在这种情况下默认显示中文文本。  
+如果有查看多语言翻译文本的需求 ，那建议还是都装一下吧。**  
+
 # 一些小彩蛋
 你可以使用 /随机传送 来替代 /rtp  
 没错，Minecraft的命令是可以存在非ASCII字符的，所以我就整了一个  
--- a/build.gradle
+++ b/build.gradle
@@ -1,91 +0,0 @@
-plugins {
-	id 'fabric-loom' version '1.5-SNAPSHOT'
-	id 'maven-publish'
-}
-
-version = project.mod_version
-group = project.maven_group
-
-base {
-	archivesName = project.archives_base_name
-}
-
-repositories {
-	// Add repositories to retrieve artifacts from in here.
-	// You should only use this when depending on other mods because
-	// Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
-	// See https://docs.gradle.org/current/userguide/declaring_repositories.html
-	// for more information about repositories.
-}
-
-loom {
-    splitEnvironmentSourceSets()
-
-	mods {
-		"randomteleporter" {
-			sourceSet sourceSets.main
-			sourceSet sourceSets.client
-		}
-	}
-
-}
-
-dependencies {
-	// To change the versions see the gradle.properties file
-	minecraft "com.mojang:minecraft:${project.minecraft_version}"
-	mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
-	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
-
-	// Fabric API. This is technically optional, but you probably want it anyway.
-	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
-	
-	// Uncomment the following line to enable the deprecated Fabric API modules. 
-	// These are included in the Fabric API production distribution and allow you to update your mod to the latest modules at a later more convenient time.
-
-	// modImplementation "net.fabricmc.fabric-api:fabric-api-deprecated:${project.fabric_version}"
-}
-
-processResources {
-	inputs.property "version", project.version
-
-	filesMatching("fabric.mod.json") {
-		expand "version": project.version
-	}
-}
-
-tasks.withType(JavaCompile).configureEach {
-	it.options.release = 17
-}
-
-java {
-	// Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
-	// if it is present.
-	// If you remove this line, sources will not be generated.
-	withSourcesJar()
-
-	sourceCompatibility = JavaVersion.VERSION_17
-	targetCompatibility = JavaVersion.VERSION_17
-}
-
-jar {
-	from("LICENSE") {
-		rename { "${it}_${project.base.archivesName.get()}"}
-	}
-}
-
-// configure the maven publication
-publishing {
-	publications {
-		mavenJava(MavenPublication) {
-			from components.java
-		}
-	}
-
-	// See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
-	repositories {
-		// Add repositories to publish to here.
-		// Notice: This block does NOT have the same function as the block in the top level.
-		// The repositories here will be used for publishing your artifact, not for
-		// retrieving dependencies.
-	}
-}
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -0,0 +1,102 @@
+plugins {
+    id("fabric-loom") version "1.11-SNAPSHOT"
+    id("maven-publish")
+}
+
+version = project.extra["mod_version"] as String
+group = project.extra["maven_group"] as String
+
+base {
+    archivesName.set(project.extra["archives_base_name"] as String)
+}
+
+repositories {
+    // Add repositories to retrieve artifacts from in here.
+    // You should only use this when depending on other mods because
+    // Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
+    // See https://docs.gradle.org/current/userguide/declaring_repositories.html
+    // for more information about repositories.
+    maven {
+        name = "Terraformers"
+        url = uri("https://maven.terraformersmc.com/") }
+}
+
+loom {
+    splitEnvironmentSourceSets()
+
+    mods {
+        create("randomteleporter") {
+            sourceSet(sourceSets["main"])
+            sourceSet(sourceSets["client"])
+        }
+    }
+}
+
+dependencies {
+    // To change the versions see the gradle.properties file
+    minecraft("com.mojang:minecraft:${project.extra["minecraft_version"]}")
+    mappings("net.fabricmc:yarn:${project.extra["yarn_mappings"]}:v2")
+    modImplementation("net.fabricmc:fabric-loader:${project.extra["loader_version"]}")
+
+    // Fabric API. This is technically optional, but you probably want it anyway.
+    modImplementation("net.fabricmc.fabric-api:fabric-api:${project.extra["fabric_version"]}")
+
+    // Uncomment the following line to enable the deprecated Fabric API modules. 
+    // These are included in the Fabric API production distribution and allow you to update your mod to the latest modules at a later more convenient time.
+    // "modImplementation"("net.fabricmc.fabric-api:fabric-api-deprecated:${project.extra["fabric_version"]}")
+
+    // ↓ 开发测试用
+    modRuntimeOnly("com.terraformersmc:modmenu:${project.extra["modmenu_version"]}")
+}
+
+tasks.processResources {
+    inputs.property("version", project.version)
+
+    filesMatching("fabric.mod.json") {
+        expand("version" to project.version)
+    }
+}
+
+tasks.withType<JavaCompile> {
+    options.release.set(21)
+}
+
+java {
+    // Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
+    // if it is present.
+    // If you remove this line, sources will not be generated.
+    withSourcesJar()
+
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+}
+
+tasks.jar {
+    from("LICENSE") {
+        rename { "${it}_${project.base.archivesName.get()}" } }
+}
+
+tasks.remapJar{
+    // https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.Jar.html#org.gradle.api.tasks.bundling.Jar:archiveFileName
+    // 用这个属性设置jar包的文件名格式
+    // 别用上面那个Jar任务的配置，会被remapJar覆盖掉
+    archiveFileName = "${project.base.archivesName.get()}-${project.version} mc${project.extra["minecraft_version"]}.jar"}
+tasks.remapSourcesJar{
+    archiveFileName = "${project.base.archivesName.get()}-${project.version} mc${project.extra["minecraft_version"]}-sources.jar"}
+
+// configure the maven publication
+publishing {
+    publications {
+        create<MavenPublication>("mavenJava") {
+            from(components["java"])
+        }
+    }
+
+    // See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
+    repositories {
+        // Add repositories to publish to here.
+        // Notice: This block does NOT have the same function as the block in the top level.
+        // The repositories here will be used for publishing your artifact, not for
+        // retrieving dependencies.
+    }
+}
--- a/gradle.properties
+++ b/gradle.properties
@@ -4,20 +4,18 @@ org.gradle.parallel=true

 # Fabric Properties
 # check these on https://fabricmc.net/develop
-minecraft_version=1.19.1
-yarn_mappings=1.19.1+build.6
-loader_version=0.15.7
+minecraft_version=1.21.10
+yarn_mappings=1.21.10+build.1
+loader_version=0.17.2

 # Mod Properties
-mod_version=0.2.5
+mod_version=0.4.0
 maven_group=xyz.thewhitedog9487
-archives_base_name=randomteleporter
+archives_base_name=RandomTeleporter

 # Dependencies
-fabric_version=0.58.5+1.19.1
+fabric_version=0.134.1+1.21.10

-loom_libraries_base=https://bmclapi2.bangbang93.com/maven/
-loom_resources_base=https://bmclapi2.bangbang93.com/assets/
-loom_version_manifests=https://bmclapi2.bangbang93.com/mc/game/version_manifest.json
-loom_experimental_versions=https://maven.fabricmc.net/net/minecraft/experimental_versions.json
-loom_fabric_repository=https://repository.hanbings.io/proxy/
+# https://modrinth.com/mod/modmenu/versions
+# https://maven.terraformersmc.com/releases/com/terraformersmc/modmenu
+modmenu_version=16.0.0-rc.1
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
+distributionUrl=https://services.gradle.org/distributions/gradle-9.1.0-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,11 +0,0 @@
-pluginManagement {
-	repositories {
-		maven {
-			name = 'Fabric'
-			url = 'https://maven.aliyun.com/repository/gradle-plugin'
-			url = 'https://maven.fabricmc.net/'
-		}
-		mavenCentral()
-		gradlePluginPortal()
-	}
-}
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -0,0 +1,9 @@
+pluginManagement {
+    repositories {
+        maven {
+            name = "Fabric"
+            url = uri("https://maven.fabricmc.net/") }
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
--- a/src/client/resources/randomteleporter.client.mixins.json
+++ b/src/client/resources/randomteleporter.client.mixins.json
@@ -1,7 +1,7 @@
 {
 	"required": false,
 	"package": "xyz.thewhitedog9487.mixin.client",
-	"compatibilityLevel": "JAVA_17",
+	"compatibilityLevel": "JAVA_21",
 	"client": [

 	],
--- a/src/main/java/xyz/thewhitedog9487/CommandRegister.java
+++ b/src/main/java/xyz/thewhitedog9487/CommandRegister.java
@@ -1,212 +1,262 @@
 package xyz.thewhitedog9487;

-import com.mojang.brigadier.arguments.LongArgumentType;
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
 import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
+import net.minecraft.block.Block;
 import net.minecraft.block.Blocks;
 import net.minecraft.command.argument.EntityArgumentType;
-import net.minecraft.command.argument.Vec3ArgumentType;
+import net.minecraft.command.argument.Vec2ArgumentType;
 import net.minecraft.entity.Entity;
 import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.server.world.ServerWorld;
 import net.minecraft.text.Text;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.Vec2f;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.ChunkStatus;
 import org.jetbrains.annotations.Nullable;

+import java.util.HashSet;
+import java.util.Set;
 import java.util.SplittableRandom;

 import static net.minecraft.server.command.CommandManager.argument;
 import static net.minecraft.server.command.CommandManager.literal;
+import static net.minecraft.world.Heightmap.Type.MOTION_BLOCKING_NO_LEAVES;
+import static xyz.thewhitedog9487.ResourceReloaderListener.*;

 public class CommandRegister {
-    // https://zh.minecraft.wiki/w/%E4%B8%96%E7%95%8C%E7%95%8C%E9%99%90
-    // https://minecraft.wiki/w/World_boundary
-    final static long WorldBoundary = (long) 2.9e7;
-    static byte Retry = 0;
-    static byte PermissionLevel = 2;
+
+    /**
+     * 随机数生成器
+     */
+    final static SplittableRandom SR = new SplittableRandom();
+
+    /**
+     * 传送后用于生成保护平台的方块
+     */
+    final static Block TargetBlock = Blocks.GLASS;
+
+    /**
+     * 传送后会被 {@link CommandRegister#TargetBlock} 替换掉的方块
+     * <br>
+     * 替换中心：被传送目标脚下方块
+     * <br>
+     * 替换范围：替换中心周围半径为一的正方形区域
+     */
+    final static Set<Block> ReplaceToTargetBlock = Set.of(
+            Blocks.AIR,
+            Blocks.VOID_AIR,
+            Blocks.CAVE_AIR,
+            Blocks.WATER,
+            Blocks.LAVA,
+            Blocks.SHORT_GRASS,
+            Blocks.VINE );
+
+    /**
+     * 世界边界
+     * <br>
+     * @see <a href="https://zh.minecraft.wiki/w/%E4%B8%96%E7%95%8C%E8%BE%B9%E7%95%8C#%E5%A4%A7%E5%B0%8F">Minecraft Wiki (中文)</a>
+     * @see <a href="https://minecraft.wiki/w/World_border#General_information">Minecraft Wiki (English)</a>
+     */
+    final static Integer WorldBorder = (int) 2.9e7;
+
+    /**
+     * 执行命令所需权限等级
+     * @see net.minecraft.server.command.TeleportCommand
+     */
+    final static byte PermissionLevel = 2;
+
+    /**
+     * 使用Fabric API向游戏内注册命令
+     * @param Name 根命令名
+     * <br>
+     * @see <a href="https://docs.fabricmc.net/zh_cn/develop/commands/basics">Fabric Wiki (新样式，中文)</a>
+     * @see <a href="https://wiki.fabricmc.net/zh_cn:tutorial:commands">Fabric Wiki (旧样式，中文)</a>
+     * @see <a href="https://docs.fabricmc.net/develop/commands/basics">Fabric Wiki (New style,English)</a>
+     * @see <a href="https://wiki.fabricmc.net/tutorial:commands">Fabric Wiki (Old style,English)</a>
+     */
    public static void Register(String Name){
-        // /rtp
+
        CommandRegistrationCallback.EVENT
                .register((dispatcher, registryAccess, environment) ->{
                    dispatcher.register(literal(Name)
+                            // /rtp
                            .requires(source -> source.hasPermissionLevel(PermissionLevel))
-                            .executes(context -> execute_command(
-                                    context.getSource(),null,null, null)));});
-
-        // /rtp <Radius(半径)>
-        CommandRegistrationCallback.EVENT
-                .register((dispatcher, registryAccess, environment) -> {
-                    dispatcher.register(literal(Name)
-                            .then(argument("Radius(半径)", LongArgumentType.longArg())
+                            .executes(context -> ExecuteCommand(
+                                    context.getSource(),null,null, null))
+                            // /rtp <Radius(半径)>
+                            .then(argument(CommandArgumentName_Radius, IntegerArgumentType.integer(0))
                                    .requires(source -> source.hasPermissionLevel(PermissionLevel))
-                                    .executes(context -> execute_command(
+                                    .executes(context -> ExecuteCommand(
                                            context.getSource(),
-                                            LongArgumentType.getLong(context, "Radius(半径)"),
+                                            IntegerArgumentType.getInteger(context, CommandArgumentName_Radius),
                                            null,
-                                            null))));});
-
-        // /rtp <被传送玩家名(PlayerID)>
-        CommandRegistrationCallback.EVENT
-                .register((dispatcher, registryAccess, environment) -> {
-                    dispatcher.register(literal(Name)
-                            .then(argument("被传送玩家名(PlayerID)", EntityArgumentType.entity())
+                                            null)))
+                            // /rtp <被传送玩家名(PlayerID)>
+                            .then(argument(CommandArgumentName_Target, EntityArgumentType.entity())
                                    .requires(source -> source.hasPermissionLevel(PermissionLevel))
-                                    .executes(context -> execute_command(
+                                    .executes(context -> ExecuteCommand(
                                            context.getSource(),
                                            null,
-                                            EntityArgumentType.getEntity(context,"被传送玩家名(PlayerID)"),
-                                            null))));});
-
-        // /rtp <Radius(半径)> <被传送玩家名(PlayerID)>
-        CommandRegistrationCallback.EVENT
-                .register((dispatcher, registryAccess, environment) -> {
-                    dispatcher.register(literal(Name)
-                            .then(argument("Radius(半径)", LongArgumentType.longArg())
-                                    .then(argument("被传送玩家名(PlayerID)", EntityArgumentType.entity())
+                                            EntityArgumentType.getEntity(context,CommandArgumentName_Target),
+                                            null)))
+                            // /rtp <Radius(半径)> <被传送玩家名(PlayerID)>
+                            .then(argument(CommandArgumentName_Radius, IntegerArgumentType.integer(0))
+                                    .then(argument(CommandArgumentName_Target, EntityArgumentType.entity())
                                            .requires(source -> source.hasPermissionLevel(PermissionLevel))
-                                            .executes(context -> execute_command(
+                                            .executes(context -> ExecuteCommand(
                                                    context.getSource(),
-                                                    LongArgumentType.getLong(context, "Radius(半径)"),
-                                                    EntityArgumentType.getEntity(context,"被传送玩家名(PlayerID)"),
-                                                    null)))));});
-
-        // /rtp <被传送玩家名(PlayerID)> <Radius(半径)>
-        CommandRegistrationCallback.EVENT
-                .register((dispatcher, registryAccess, environment) -> {
-                    dispatcher.register(literal(Name)
-                            .then(argument("被传送玩家名(PlayerID)", EntityArgumentType.entity())
-                                .then(argument("Radius(半径)", LongArgumentType.longArg())
+                                                    IntegerArgumentType.getInteger(context, CommandArgumentName_Radius),
+                                                    EntityArgumentType.getEntity(context,CommandArgumentName_Target),
+                                                    null))))
+                            // /rtp <被传送玩家名(PlayerID)> <Radius(半径)>
+                            .then(argument(CommandArgumentName_Target, EntityArgumentType.entity())
+                                    .then(argument(CommandArgumentName_Radius, IntegerArgumentType.integer(0))
                                            .requires(source -> source.hasPermissionLevel(PermissionLevel))
-                                            .executes(context -> execute_command(
+                                            .executes(context -> ExecuteCommand(
                                                    context.getSource(),
-                                                    LongArgumentType.getLong(context, "Radius(半径)"),
-                                                    EntityArgumentType.getEntity(context,"被传送玩家名(PlayerID)"),
-                                                    null)))));});
-
-//        // /rtp <Radius(半径)> <Origin(随机中心)>
-//        CommandRegistrationCallback.EVENT
-//                .register((dispatcher, registryAccess, environment) -> {
-//                    dispatcher.register(literal(Name)
-//                            .then(argument("Radius(半径)", LongArgumentType.longArg())
-//                                    .then(argument("Origin(随机中心)",EntityArgumentType.player())
-//                                        .requires(source -> source.hasPermissionLevel(PermissionLevel))
-//                                        .executes(context -> execute_command_origin(
-//                                                context.getSource(),
-//                                                LongArgumentType.getLong(context, "Radius(半径)"),
-//                                                null,
-//                                                EntityArgumentType.getEntity(context,"Origin(随机中心)"))))));});
-        // /rtp <Radius(半径)> <OriginPos(随机中心，坐标)>
-        CommandRegistrationCallback.EVENT
-                .register((dispatcher, registryAccess, environment) -> {
-                    dispatcher.register(literal(Name)
-                            .then(argument("Radius(半径)", LongArgumentType.longArg())
-                                    .then(argument("OriginPos(随机中心，坐标)",Vec3ArgumentType.vec3())
+                                                    IntegerArgumentType.getInteger(context, CommandArgumentName_Radius),
+                                                    EntityArgumentType.getEntity(context,CommandArgumentName_Target),
+                                                    null))))
+//                          // /rtp <Radius(半径)> <Origin(随机中心)>
+//                          .then(argument("Radius(半径)", LongArgumentType.longArg())
+//                                  .then(argument("Origin(随机中心)",EntityArgumentType.player())
+//                                          .requires(source -> source.hasPermissionLevel(PermissionLevel))
+//                                          .executes(context -> execute_command_origin(
+//                                                  context.getSource(),
+//                                                  LongArgumentType.getLong(context, "Radius(半径)"),
+//                                                  null,
+//                                                  EntityArgumentType.getEntity(context,"Origin(随机中心)")))))
+                            // /rtp <Radius(半径)> <OriginPos(随机中心，坐标)>
+                            .then(argument(CommandArgumentName_Radius, IntegerArgumentType.integer(0))
+                                    .then(argument(CommandArgumentName_OriginPosition,Vec2ArgumentType.vec2())
                                            .requires(source -> source.hasPermissionLevel(PermissionLevel))
-                                            .executes(context -> execute_command(
+                                            .executes(context -> ExecuteCommand(
                                                    context.getSource(),
-                                                    LongArgumentType.getLong(context, "Radius(半径)"),
+                                                    IntegerArgumentType.getInteger(context, CommandArgumentName_Radius),
                                                    null,
-                                                    Vec3ArgumentType.getVec3(context,"OriginPos(随机中心，坐标)"))))));});
-
-        // /rtp <Radius(半径)> <被传送玩家名(PlayerID)> <OriginEntity(随机中心，实体)>
-        CommandRegistrationCallback.EVENT
-                .register((dispatcher, registryAccess, environment) -> {
-                    dispatcher.register(literal(Name)
-                            .then(argument("Radius(半径)", LongArgumentType.longArg())
-                                    .then(argument("被传送玩家名(PlayerID)", EntityArgumentType.entity())
-                                            .then(argument("OriginEntity(随机中心，实体)",EntityArgumentType.entity())
+                                                    Vec2ArgumentType.getVec2(context,CommandArgumentName_OriginPosition)))))
+                            // /rtp <Radius(半径)> <被传送玩家名(PlayerID)> <OriginEntity(随机中心，实体)>
+                            .then(argument(CommandArgumentName_Radius, IntegerArgumentType.integer(0))
+                                    .then(argument(CommandArgumentName_Target, EntityArgumentType.entity())
+                                            .then(argument(CommandArgumentName_OriginEntity,EntityArgumentType.entity())
                                                    .requires(source -> source.hasPermissionLevel(PermissionLevel))
-                                                    .executes(context -> execute_command_origin(
+                                                    .executes(context -> ExecuteCommand(
                                                            context.getSource(),
-                                                            LongArgumentType.getLong(context, "Radius(半径)"),
-                                                            EntityArgumentType.getEntity(context,"被传送玩家名(PlayerID)"),
-                                                            EntityArgumentType.getEntity(context,"OriginEntity(随机中心，实体)")))))));});
+                                                            IntegerArgumentType.getInteger(context, CommandArgumentName_Radius),
+                                                            EntityArgumentType.getEntity(context,CommandArgumentName_Target),
+                                                            new Vec2f( (float) EntityArgumentType.getEntity( context,CommandArgumentName_OriginEntity).getEntityPos().x,
+                                                                    (float) EntityArgumentType.getEntity( context,CommandArgumentName_OriginEntity).getEntityPos().z ))))))
+                           // /rtp <Radius(半径)> <被传送玩家名(PlayerID)> <OriginPos(随机中心，坐标)>
+                           .then(argument(CommandArgumentName_Radius, IntegerArgumentType.integer(0))
+                                   .then(argument(CommandArgumentName_Target, EntityArgumentType.entity())
+                                           .then(argument(CommandArgumentName_OriginPosition,Vec2ArgumentType.vec2())
+                                                   .requires(source -> source.hasPermissionLevel(PermissionLevel))
+                                                   .executes(context -> ExecuteCommand(
+                                                           context.getSource(),
+                                                           IntegerArgumentType.getInteger(context, CommandArgumentName_Radius),
+                                                           EntityArgumentType.getEntity(context,CommandArgumentName_Target),
+                                                           Vec2ArgumentType.getVec2(context,CommandArgumentName_OriginPosition))))))
+                           // /rtp <被传送玩家名(PlayerID)> <Radius(半径)> <OriginEntity(随机中心，实体)>
+                           .then(argument(CommandArgumentName_Target, EntityArgumentType.entity())
+                                   .then(argument(CommandArgumentName_Radius, IntegerArgumentType.integer(0))
+                                           .then(argument(CommandArgumentName_OriginEntity,EntityArgumentType.entity())
+                                                   .requires(source -> source.hasPermissionLevel(PermissionLevel))
+                                                   .executes(context -> ExecuteCommand(
+                                                           context.getSource(),
+                                                           IntegerArgumentType.getInteger(context, CommandArgumentName_Radius),
+                                                           EntityArgumentType.getEntity(context,CommandArgumentName_Target),
+                                                           new Vec2f( (float) EntityArgumentType.getEntity( context,CommandArgumentName_OriginEntity).getEntityPos().x,
+                                                                   (float) EntityArgumentType.getEntity( context,CommandArgumentName_OriginEntity).getEntityPos().z ))))))
+                           // /rtp <被传送玩家名(PlayerID)> <Radius(半径)> <OriginPos(随机中心，坐标)>
+                           .then(argument(CommandArgumentName_Target, EntityArgumentType.entity())
+                                   .then(argument(CommandArgumentName_Radius, IntegerArgumentType.integer(0))
+                                           .then(argument(CommandArgumentName_OriginPosition,Vec2ArgumentType.vec2())
+                                                   .requires(source -> source.hasPermissionLevel(PermissionLevel))
+                                                   .executes(context -> ExecuteCommand(
+                                                           context.getSource(),
+                                                           IntegerArgumentType.getInteger(context, CommandArgumentName_Radius),
+                                                           EntityArgumentType.getEntity(context,CommandArgumentName_Target),
+                                                           Vec2ArgumentType.getVec2(context,CommandArgumentName_OriginPosition)))))) );});}

-        // /rtp <Radius(半径)> <被传送玩家名(PlayerID)> <OriginPos(随机中心，坐标)>
-        CommandRegistrationCallback.EVENT
-                .register((dispatcher, registryAccess, environment) -> {
-                    dispatcher.register(literal(Name)
-                            .then(argument("Radius(半径)", LongArgumentType.longArg())
-                                    .then(argument("被传送玩家名(PlayerID)", EntityArgumentType.entity())
-                                            .then(argument("OriginPos(随机中心，坐标)",Vec3ArgumentType.vec3())
-                                                    .requires(source -> source.hasPermissionLevel(PermissionLevel))
-                                                    .executes(context -> execute_command(
-                                                            context.getSource(),
-                                                            LongArgumentType.getLong(context, "Radius(半径)"),
-                                                            EntityArgumentType.getEntity(context,"被传送玩家名(PlayerID)"),
-                                                            Vec3ArgumentType.getVec3(context,"OriginPos(随机中心，坐标)")))))));});
-
-        // /rtp <被传送玩家名(PlayerID)> <Radius(半径)> <OriginEntity(随机中心，实体)>
-        CommandRegistrationCallback.EVENT
-                .register((dispatcher, registryAccess, environment) -> {
-                    dispatcher.register(literal(Name)
-                            .then(argument("被传送玩家名(PlayerID)", EntityArgumentType.entity())
-                                    .then(argument("Radius(半径)", LongArgumentType.longArg())
-                                            .then(argument("OriginEntity(随机中心，实体)",EntityArgumentType.entity())
-                                                    .requires(source -> source.hasPermissionLevel(PermissionLevel))
-                                                    .executes(context -> execute_command_origin(
-                                                            context.getSource(),
-                                                            LongArgumentType.getLong(context, "Radius(半径)"),
-                                                            EntityArgumentType.getEntity(context,"被传送玩家名(PlayerID)"),
-                                                            EntityArgumentType.getEntity(context,"OriginEntity(随机中心，实体)")))))));});
-
-        // /rtp <被传送玩家名(PlayerID)> <Radius(半径)> <OriginPos(随机中心，坐标)>
-        CommandRegistrationCallback.EVENT
-                .register((dispatcher, registryAccess, environment) -> {
-                    dispatcher.register(literal(Name)
-                            .then(argument("被传送玩家名(PlayerID)", EntityArgumentType.entity())
-                                    .then(argument("Radius(半径)", LongArgumentType.longArg())
-                                            .then(argument("OriginPos(随机中心，坐标)",Vec3ArgumentType.vec3())
-                                                    .requires(source -> source.hasPermissionLevel(PermissionLevel))
-                                                    .executes(context -> execute_command(
-                                                            context.getSource(),
-                                                            LongArgumentType.getLong(context, "Radius(半径)"),
-                                                            EntityArgumentType.getEntity(context,"被传送玩家名(PlayerID)"),
-                                                            Vec3ArgumentType.getVec3(context,"OriginPos(随机中心，坐标)")))))));});}
+    /**
+     * 向游戏内注册命令
+     * <br>
+     * 是 {@link CommandRegister#Register(String)} 的包装器
+     * @see CommandRegister#Register(String)
+     */
    public static void Register(){
        Register("随机传送");
-        Register("rtp");}
-    static int execute_command(ServerCommandSource Source, @Nullable Long Radius, @Nullable Entity Player, @Nullable Vec3d Origin){
-        Entity entity = Player == null ? Source.getPlayer() : Player;
-        if (entity == null) {
-            Source.sendFeedback(Text.translatable("error.twd.rtp.not_player"), true);
+        Register("rtp");
+    }
+
+    /**
+     *
+     * @param Source 命令执行者
+     * @param Radius 随机选择的目的坐标距离参数 {@code Origin} 的最大距离
+     * @param Entity 被传送的实体
+     * @param Origin 随机选择的目的坐标的中心
+     * @return 命令运行是否成功
+     */
+    static int ExecuteCommand(ServerCommandSource Source, @Nullable Integer Radius, @Nullable Entity Entity, @Nullable Vec2f Origin){
+        Entity TargetEntity = Entity == null ? Source.getPlayer() : Entity;
+        /*
+            ↑
+            Entity TargetEntity = null;
+            if (TargetEntity == null){
+                TargetEntity = Source.getPlayer();}
+            else{
+                TargetEntity = Entity;}
+         */
+        if (TargetEntity == null) {
+            Source.sendFeedback(()->{ return  Text.translatableWithFallback("error.no_target","不存在被传送目标，由非玩家物体执行命令时请显式指定被传送玩家ID"); }, true);
            return -1;}
-        if (Radius == null){Radius = WorldBoundary - (long) 1e4;}
-        Radius = Math.abs(Radius);
-        long Coordinate_X;
-        long Coordinate_Z;
-        if (Origin == null){
-            Coordinate_X = new SplittableRandom().nextLong(-Radius, Radius);
-            Coordinate_Z = new SplittableRandom().nextLong(-Radius, Radius);}
-        else{
-            Coordinate_X = new SplittableRandom().nextLong(Math.round(Origin.getX() - Radius), Math.round(Origin.getX() + Radius));
-            Coordinate_Z = new SplittableRandom().nextLong(Math.round(Origin.getZ() - Radius), Math.round(Origin.getZ() + Radius));}
-        int Coordinate_Y = 320;
-        for (;
-             Blocks.AIR == Source.getWorld().getBlockState(new BlockPos(Math.toIntExact(Coordinate_X), Coordinate_Y, Math.toIntExact(Coordinate_Z))).getBlock() ||
-             Blocks.VOID_AIR == Source.getWorld().getBlockState(new BlockPos(Math.toIntExact(Coordinate_X), Coordinate_Y, Math.toIntExact(Coordinate_Z))).getBlock() ||
-             Blocks.CAVE_AIR == Source.getWorld().getBlockState(new BlockPos(Math.toIntExact(Coordinate_X), Coordinate_Y, Math.toIntExact(Coordinate_Z))).getBlock()
-                ;Coordinate_Y--){}
-        if (Blocks.WATER == Source.getWorld().getBlockState(new BlockPos(Math.toIntExact(Coordinate_X), Coordinate_Y, Math.toIntExact(Coordinate_Z))).getBlock() ||
-            Blocks.LAVA == Source.getWorld().getBlockState(new BlockPos(Math.toIntExact(Coordinate_X), Coordinate_Y, Math.toIntExact(Coordinate_Z))).getBlock()){
-            for (int x = -1; x <= 1; x++) {
-                for (int z = -1; z <= 1; z++) {
-                    Source.getWorld().setBlockState(new BlockPos(Math.toIntExact(Coordinate_X - x), Coordinate_Y, Math.toIntExact(Coordinate_Z - z)), Blocks.GLASS.getDefaultState());}}}
-//        if ( String.valueOf(entity.getWorld().getBiome(new BlockPos(Math.toIntExact(Coordinate_X), Coordinate_Y, Math.toIntExact(Coordinate_Z))).getKey()).equals("minecraft:the_void") ) {
+        if (Radius == null){Radius = (int) (WorldBorder - 1e4);}
+        // ↑ 远离世界边界
+        int Coordinate_X = 0;
+        int Coordinate_Z = 0;
+        try {
+            if (Origin == null){
+                Coordinate_X = SR.nextInt(-Radius, Radius + 1);
+                Coordinate_Z = SR.nextInt(-Radius, Radius + 1); }
+            else{
+                Coordinate_X = SR.nextInt((int) Origin.x - Radius, (int) Origin.x + Radius + 1);
+                Coordinate_Z = SR.nextInt((int) Origin.y - Radius, (int) Origin.y + Radius + 1); } }
+        catch (IllegalArgumentException e) {
+            // 半径为零
+            if (Origin == null) {
+                Source.sendFeedback(()->{ return Text.translatableWithFallback("warning.radius_equal_zero_no_target", "由于你设置的随机半径为0，并且未设置随机中心点坐标，因此什么都不会发生"); },true);
+                return -1;}
+            else {
+                Coordinate_X = (int) Origin.x;
+                Coordinate_Z = (int) Origin.y;
+                int finalCoordinate_X1 = Coordinate_X;
+                int finalCoordinate_Z1 = Coordinate_Z;
+                // ↑ "lambda 表达式中使用的变量应为 final 或有效 final"
+                Source.sendFeedback(()->{ return Text.translatableWithFallback("warning.radius_equal_zero", "警告：由于你设置的随机半径为0，因此在选择出合适高度之后将直接把你传送至%d %d", finalCoordinate_X1, finalCoordinate_Z1); },true);}}
+        World EntityWorld = TargetEntity.getEntityWorld();
+        EntityWorld.getChunk(Coordinate_X >> 4, Coordinate_Z >> 4, ChunkStatus.FULL, true);
+        // ↑ 加载目标区块，不然下面获取到的Coordinate_Y一定是-64
+        // 必须是 >> 4 ，不能是 / 16
+        int Coordinate_Y = EntityWorld.getTopY(MOTION_BLOCKING_NO_LEAVES, Coordinate_X, Coordinate_Z);
+        BlockPos.Mutable BlockPos = new BlockPos.Mutable();
+        for (int x = -1; x <= 1; x++) {
+            for (int z = -1; z <= 1; z++) {
+                // 如果传送到的位置周围一圈是ReplaceToTargetBlock的方块，将其替换为TargetBlock
+                BlockPos.set(Coordinate_X - x, Coordinate_Y - 1, Coordinate_Z - z);
+                var CurrentBlock = EntityWorld.getBlockState(BlockPos).getBlock();
+                if ( ReplaceToTargetBlock.contains(CurrentBlock) ) {
+                    // 只替换ReplaceToTargetBlock内的方块，其余保留
+                    EntityWorld.setBlockState(BlockPos, TargetBlock.getDefaultState());}}}
+//        if ( String.valueOf(TargetEntity.getWorld().getBiome(new BlockPos(Math.toIntExact(Coordinate_X), Coordinate_Y, Math.toIntExact(Coordinate_Z))).getKey()).equals("minecraft:the_void") ) {
 //            Coordinate_Y++;}
-        Coordinate_Y++;
-        Vec3d Coordinate = new Vec3d(Coordinate_X, Coordinate_Y, Coordinate_Z);
-        if (Radius == WorldBoundary && Retry < 126 && entity.getPos().distanceTo(Coordinate) < 1e5){
-            Retry++;
-            execute_command(Source, Radius,null, Origin);
-            return 0;}
-        if (Retry >= 126){
-            Source.sendFeedback(Text.translatable("warning.twd.rtp.retry"), true);}
-        entity.teleport(Coordinate_X + 0.5, Coordinate_Y, Coordinate_Z + 0.5);
-        final long FinalCoordinate_X = Coordinate_X;
-        final int FinalCoordinate_Y = Coordinate_Y;
-        final long FinalCoordinate_Z = Coordinate_Z;
-        Source.sendFeedback(Text.translatable("info.twd.rtp.success", entity.getName(), FinalCoordinate_X, FinalCoordinate_Y, FinalCoordinate_Z),true);
-        return 0;}
-    static int execute_command_origin(ServerCommandSource Source, @Nullable Long Radius, @Nullable Entity Player, Entity Origin){
-        return execute_command(Source, Radius, Player, Origin.getPos());}
+        TargetEntity.teleport((ServerWorld) EntityWorld,Coordinate_X + 0.5, Coordinate_Y, Coordinate_Z + 0.5, new HashSet<>(), TargetEntity.getYaw(), TargetEntity.getPitch(), false);
+        int finalCoordinate_X = Coordinate_X;
+        int finalCoordinate_Z = Coordinate_Z;
+        // ↑ "lambda 表达式中使用的变量应为 final 或有效 final"
+        final var FeedbackFallbackString = String.format("已将玩家%s传送到%d %d %d", TargetEntity.getName().getString(), Coordinate_X, Coordinate_Y, Coordinate_Z);
+        Source.sendFeedback(()->{ return  Text.translatableWithFallback("info.success", FeedbackFallbackString, TargetEntity.getName(), finalCoordinate_X, Coordinate_Y, finalCoordinate_Z); },true);
+        return Command.SINGLE_SUCCESS;}
 }
--- a/src/main/java/xyz/thewhitedog9487/RandomTeleporter.java
+++ b/src/main/java/xyz/thewhitedog9487/RandomTeleporter.java
@@ -9,14 +9,17 @@ public class RandomTeleporter implements ModInitializer {
 	// This logger is used to write text to the console and the log file.
 	// It is considered best practice to use your mod id as the logger's name.
 	// That way, it's clear which mod wrote info, warnings, and errors.
-    public static final Logger LOGGER = LoggerFactory.getLogger("randomteleporter");
+    public static final String MOD_ID = "randomteleporter";
+    public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);

 	@Override
 	public void onInitialize() {
 		// This code runs as soon as Minecraft is in a mod-load-ready state.
 		// However, some things (like resources) may still be uninitialized.
 		// Proceed with mild caution.
+
+        ResourceReloaderListener.Register();
 		CommandRegister.Register();
-		LOGGER.info("Hello Fabric world!");
+		LOGGER.info("RandomTeleporter已写入命令注册回调，目标命令将会在该注册的时候被注册");
 	}
 }
--- a/src/main/java/xyz/thewhitedog9487/ResourceReloaderListener.java
+++ b/src/main/java/xyz/thewhitedog9487/ResourceReloaderListener.java
@@ -0,0 +1,34 @@
+package xyz.thewhitedog9487;
+
+import net.fabricmc.fabric.api.resource.v1.ResourceLoader;
+import net.fabricmc.fabric.api.resource.v1.reloader.SimpleResourceReloader;
+import net.minecraft.text.Text;
+import net.minecraft.util.Identifier;
+
+import static net.minecraft.resource.ResourceType.CLIENT_RESOURCES;
+import static xyz.thewhitedog9487.RandomTeleporter.MOD_ID;
+
+/**
+ * 在游戏资源重新加载之后刷新翻译文本
+ */
+public class ResourceReloaderListener {
+    public static String CommandArgumentName_Radius = "Radius(半径)";
+    public static String CommandArgumentName_Target = "被传送玩家名(PlayerID)";
+    public static String CommandArgumentName_OriginPosition = "OriginPos(随机中心，坐标)";
+    public static String CommandArgumentName_OriginEntity = "OriginEntity(随机中心，实体)";
+
+    public static void Register(){
+        ResourceLoader.get(CLIENT_RESOURCES).registerReloader(Identifier.of(MOD_ID, "translate_text_apply"), new SimpleResourceReloader<Void>() {
+            /**
+             * 用不到，不用管
+             */
+            @Override
+            protected Void prepare(Store store) {
+                return null; }
+
+            @Override
+            protected void apply(Void prepared, Store store) {
+                CommandArgumentName_Radius = Text.translatableWithFallback("command.argument.radius", "Radius(半径)").getString();
+                CommandArgumentName_Target = Text.translatableWithFallback("command.argument.target", "被传送玩家名(PlayerID)").getString();
+                CommandArgumentName_OriginPosition = Text.translatableWithFallback("command.argument.origin_pos", "OriginPos(随机中心，坐标)").getString();
+                CommandArgumentName_OriginEntity = Text.translatableWithFallback("command.argument.origin_entity", "OriginEntity(随机中心，实体)").getString(); } } ); } }
--- a/src/main/resources/assets/randomteleporter/lang/en_us.json
+++ b/src/main/resources/assets/randomteleporter/lang/en_us.json
@@ -1,6 +1,13 @@
 {
  "modmenu.nameTranslation.randomteleporter": "RandomTeleporter",
  "modmenu.descriptionTranslation.randomteleporter": "Added two commands for random teleportation",
-  "twd.bilibili": "Bilibili",
-  "twd.blog": "Blog"
+  "info.success": "Teleported %s to %d %d %d",
+  "error.no_target": "There is no teleported target, and the teleported player ID is explicitly specified when executed by a non-player object",
+  "warning.radius_equal_zero": "Warning: Since you set a random radius of 0, selecting the right height will teleport you directly to %d %d",
+  "warning.radius_equal_zero_no_target": "Warning: Since you set a random radius of 0 and you don't set a random center point coordinates, nothing happens",
+  "bilibili": "Bilibili",
+  "command.argument.radius": "radius",
+  "command.argument.target": "teleported entity",
+  "command.argument.origin_pos": "origin(pos)",
+  "command.argument.origin_entity": "origin(entity)"
 }
--- a/src/main/resources/assets/randomteleporter/lang/zh_cn.json
+++ b/src/main/resources/assets/randomteleporter/lang/zh_cn.json
@@ -1,9 +1,13 @@
 {
  "modmenu.nameTranslation.randomteleporter": "随机传送",
  "modmenu.descriptionTranslation.randomteleporter": "增加了两个用于随机传送的命令",
-  "info.twd.rtp.success": "已将玩家%s传送到%d %d %d",
-  "error.twd.rtp.not_player": "执行命令的不是玩家",
-  "warning.twd.rtp.retry": "重试次数过大，为避免死循环将在本次传送中取消距离保护",
-  "twd.bilibili": "哔哩哔哩主页",
-  "twd.blog": "TheWhiteDog9487的博客"
+  "info.success": "已将玩家%s传送到%d %d %d",
+  "error.no_target": "不存在被传送目标，由非玩家物体执行命令时请显式指定被传送玩家ID",
+  "warning.radius_equal_zero": "警告：由于你设置的随机半径为0，因此在选择出合适高度之后将直接把你传送至%d %d",
+  "warning.radius_equal_zero_no_target": "警告：由于你设置的随机半径为0，并且未设置随机中心点坐标，因此什么都不会发生",
+  "bilibili": "TheWhiteDog9487的哔哩哔哩主页",
+  "command.argument.radius": "半径",
+  "command.argument.target": "被传送实体",
+  "command.argument.origin_pos": "随机中心（坐标）",
+  "command.argument.origin_entity": "随机中心（实体）"
 }
--- a/src/main/resources/fabric.mod.json
+++ b/src/main/resources/fabric.mod.json
@@ -27,10 +27,10 @@
 		}
 	],
 	"depends": {
-		"fabricloader": ">=0.15.7",
-		"minecraft": "~1.19.1",
-		"java": ">=17",
-		"fabric-api": "*"
+		"fabricloader": ">=0.17.2",
+		"minecraft": "1.21.10",
+		"java": ">=21",
+		"fabric-api": ">=0.134.1"
 	},
 	"suggests": {
 		"another-mod": "*"
@@ -38,7 +38,6 @@
 	"custom": {
 		"modmenu": {
 			"links": {
-				"twd.bilibili": "https://space.bilibili.com/401746666",
-				"twd.blog": "www.thewhitedog9487.xyz"},
+				"bilibili": "https://space.bilibili.com/401746666"},
 			"update_checker": true}}
 }
--- a/src/main/resources/randomteleporter.mixins.json
+++ b/src/main/resources/randomteleporter.mixins.json
@@ -1,7 +1,7 @@
 {
 	"required": false,
 	"package": "xyz.thewhitedog9487.mixin",
-	"compatibilityLevel": "JAVA_17",
+	"compatibilityLevel": "JAVA_21",
 	"mixins": [

 	],
Author	SHA1	Message	Date
TheWhiteDog9487	327dd5d168	更新到Minecraft 1.21.10	2025-10-08 09:19:23 +08:00
TheWhiteDog9487	dca7fa256e	将命令参数文本抽离到各个文字的翻译文件内，现在只会显示当前语言的提示文字了但是单人游戏内切换语言后必须重进世界才能完成游戏内热更新，并且独立服务器用不了这个特性，开放局域网的话应该是跟随主机的语言配置	2025-10-05 15:34:06 +08:00
TheWhiteDog9487	74046be828	使用Minecraft内部方法搜索指定坐标内可传送玩家的合适Y 更换大量new BlockPos为BlockPos.Mutable	2025-10-05 14:18:43 +08:00
TheWhiteDog9487	33e01b3d35	现在被传送实体会在自己所在世界内被传送，不会受到命令执行方所在世界和自己不一致的影响重命名函数和变量	2025-10-05 14:14:16 +08:00
TheWhiteDog9487	e7f9ac069a	将随机数生成器需要被替换的方块列表和替换目标方块提取到静态常量并且让随机数的上界+1以使随机范围成为完整闭区间	2025-10-05 14:11:00 +08:00
TheWhiteDog9487	eb85fff326	使单个根名称的命令树一次性完成注册并且现在由Minecraft自己的命令解析器确保用户输入的随机半径>=0 返回标准Command.SINGLE_SUCCESS	2025-10-05 14:09:11 +08:00
TheWhiteDog9487	48a5027cce	更新至Minecraft 1.21.9	2025-10-03 16:51:17 +08:00
TheWhiteDog9487	62c3484c5e	更新Gradle到9.1.0	2025-10-03 16:50:50 +08:00
TheWhiteDog9487	d47907cdf4	更新至Minecraft 1.21.8 Feature Drop和Bugfix混用小版本号的话，年底，不，甚至暑假结束之前有望突破1.21.10	2025-07-18 11:19:41 +08:00
TheWhiteDog9487	8c55311f27	更新至Minecraft 1.21.7 La-la-la-lava, ch-ch-ch-chicken Steve's Lava Chicken, yeah, it's tasty as hell Ooh, mamacita, now you're ringin' the bell Crispy and juicy, now you're havin' a snack Ooh, super spicy, it's a lava attack	2025-07-01 08:49:58 +08:00
TheWhiteDog9487	35ac4dd842	0.3.6 小更改，正常用应该是感受不到的。当随机半径被设置为0的时候不会再抛出异常而导致命令运行失败了。手动处理了这个部分，向玩家发送警告并根据随机中心点是否被设置而决定是否进行传送。	2025-06-18 12:24:29 +08:00
TheWhiteDog9487	34ea09dfd9	依赖项更新至Minecraft 1.21.6	2025-06-18 10:31:14 +08:00
TheWhiteDog9487	ad014a2b1b	更新Gradle至8.14	2025-06-18 10:30:20 +08:00
TheWhiteDog9487	4de867d6aa	Fabric模组模板那边新的文件	2025-03-26 10:28:21 +08:00
TheWhiteDog9487	9770b72448	移除BMCLAPI镜像这个东西可以在`~/.gradle/gradle.properties`里面全局配置，没必要每个项目都写一份，而且这样子还不会影响其他非大陆贡献者	2025-03-26 10:27:40 +08:00
TheWhiteDog9487	66a1529132	更新开发环境Minecraft和Fabric版本	2025-03-26 10:26:02 +08:00
TheWhiteDog9487	96a69f3262	更新Gradle版本以后跟大版本算了，这东西更新速度太恐怖了，小版本我就不跟了	2025-03-26 10:23:23 +08:00
TheWhiteDog9487	da6802f605	0.3.5 适配Minecraft 1.21.4 修正了一个严重Bug，同样是由0.3.3的Vec3d → Vec2f引入。具体表现就是当传送中心被设置为一个实体时，传送中心点的Z轴坐标被错误地设置为给定实体的Y轴（表示高度的那个轴）坐标。可能是我测试的时候没用到这个格式所以没发现问题？反正现在修了，已经没事了。更换Text.translatable成Text.translatableWithFallback，确保未安装模组时至少有人类可读文字，而不是翻译键。补充英语翻译。 ModMenu显示的详细信息中移除掉博客链接。增加了一大堆的JavaDoc.	2024-12-05 16:00:25 +08:00
TheWhiteDog9487	7376393f37	0.3.4 偶然间观测到一个在极端条件下出现的Bug，由上一个版本更新的 Vec3d → Vec2f 引入，赶紧给它修了这是一个可以复现的例子：/rtp @s 1 -23604356.50 23511080.50 这个版本已经没问题了	2024-10-25 14:53:42 +08:00
TheWhiteDog9487	c442f12de4	0.3.3 适配Minecraft 1.21.3 ( 什么连夜OTA正式版坐标类型由Vec3d改为Vec2f，高度一边凉快去根本用不到修正上一个版本命令反馈消息的坐标显示错误，一路Ctrl V没发现问题，红豆泥私密马赛，已经修改好了输出文件名改成首字母大写了	2024-10-25 13:49:09 +08:00
TheWhiteDog9487	e7c99c2364	0.3.2 修改了一下传送落地之后玻璃的放置规则。 - 以前只要脚下是水或岩浆就无条件替换，在极小概率之下可能出现一些麻烦，所以我给改掉了。 - 现在是落地就准备替换，但是只会替换水、岩浆和空气，其他所有都会保留不变。当然最重要的是适配Minecraft 1.21.2 另外针对开发者侧，Gradle语法从Groovy换到了Kotlin，看起来舒服多了。	2024-10-24 09:54:11 +08:00
TheWhiteDog9487	6d3af41b34	更换Gradle语法到Kotlin DSL	2024-10-23 18:16:09 +08:00
TheWhiteDog9487	da8e07baea	模组版本0.3.1对1.21.1构建	2024-10-23 17:21:12 +08:00
TheWhiteDog9487	3d23f397f7	0.3.1 这个版本同时会出1.21和1.21.1两个版本的构建。那个ModMenu内链接名字显示不正常的问题修掉了，改翻译键没改完导致的。输出文件名改掉了，不然两个不同的游戏版本同时发一个模组版本不好弄。那个从来就没有正常工作过的过近距离保护直接下了，可能之后再加回来吧，反正现在那个就没正常过。其他都是开发侧的小改动，用户侧无感知。	2024-08-09 16:34:00 +08:00
TheWhiteDog9487	6eb98f1f94	0.3.0 升级游戏兼容性到1.21 移除翻译键中手动添加的命名空间编译版本升级至JDK21	2024-06-14 14:33:33 +08:00
TheWhiteDog9487	8186159653	0.2.5 突然发现Ved3d类型的方法里有一个计算两点间距离的，那我就把我自己的工具库撤了。然后我把命令权限等级从4下降到了2，和原版的/tp同步。（我记得原版的tp是4级啊？我最早还去源代码里看了一眼，咋回事呢？传送过去生成的保护平台，现在是3x3的玻璃而不是1x1的石头，而且玩家会站在平台的正中心。例行更新Fabric API和Fabric Loader	2024-02-18 20:39:47 +08:00