Webmapview:一个我的世界内置网页地图浏览Fabric模组

1
//copy from https://github.com/CinemaMod/mcef-fabric-example-mod and change by xingwangzhe
2

3
public class BasicBrowser extends Screen {
4
    private static final int BROWSER_DRAW_OFFSET = 20;
5

6
    private MCEFBrowser browser;
7

8
    private final MinecraftClient minecraft = MinecraftClient.getInstance();
9

10
    public BasicBrowser(Text title) {
11
        super(title);
12
    }
13

14
    @Override
15
    protected void init() {
16
        super.init();
17
        if (browser == null) {
18
            String url = UrlManager.fullUrl(UrlManager.defaultUrl);
19
            sendFeedback(url);
20
            boolean transparent = true;
21
            browser = MCEF.createBrowser(url, transparent);
22
            resizeBrowser();
23
        }
24
    }

1
public class UrlManager {
2
    private static final String URL_FILE_NAME = "urls.txt"; // 存储URL列表的文件名
3
    private static final String DEFAULT_URL_FILE_NAME = "default_url.txt"; // 默认URL文件名
4
    private static List<String> urlList = new ArrayList<>(); // 存储URL的列表
5
    public static String defaultUrl="squaremap-demo.jpenilla.xyz"; // 默认URL
6
    public static boolean webmapview=true;
7
    static {
8
        loadUrls();
9
        loadDefaultUrl();
10
    }
11

12
    /**
13
     * 添加一个URL到列表中并保存到文件。
14
     * @param url 要添加的URL字符串
15
     */
16
    public static void addUrl(String url) {
17
        if (!urlList.contains(url)) { // 确保不重复添加相同的URL
18
            urlList.add(url);
19
            saveUrls(); // 保存更新后的URL列表到文件
20
            sendFeedback(Text.translatable("feedback.url.added", url)); // 向玩家发送反馈
21
        } else {
22
            sendFeedback(Text.translatable("feedback.url.exists", url)); // 如果URL已存在，则通知玩家
23
        }
24
    }
25

26
    /**
27
     * 设置默认URL。
28
     * @param url 要设置为默认的URL字符串
29
     */
30
    public static void setDefaultUrl(String url) {
31
        if (urlList.contains(url)) { // 确保URL已经存在于列表中
32
            defaultUrl = url;
33
            saveDefaultUrl(); // 更新默认URL到文件
34
            sendFeedback(Text.translatable("feedback.default.url.updated", url)); // 向玩家发送反馈
35
        } else {
36
            sendFeedback(Text.translatable("feedback.url.not_found", url)); // 如果URL不存在于列表中，则通知玩家
37
        }
38
    }
39

40
    /**
41
     * 获取当前的URL列表。
42
     * @return 包含所有URL的列表
43
     */
44
    public static List<String> getUrlList() {
45
        return urlList;
46
    }
47

48
    /**
49
     * 获取默认URL。
50
     * @return 默认URL字符串
51
     */
52
    public static String getDefaultUrl() {
53
        return defaultUrl;
54
    }
55

56
    /**
57
     * 将当前的URL列表保存到文件中。
58
     */
59
    private static void saveUrls() {
60
        Path configPath = getConfigDirectory().resolve(URL_FILE_NAME); // 获取配置文件路径
61
        try (BufferedWriter writer = Files.newBufferedWriter(configPath)) { // 使用try-with-resources确保资源关闭
62
            for (String url : urlList) {
63
                writer.write(url); // 写入单个URL
64
                writer.newLine(); // 换行以便每个URL占一行
65
            }
66
        } catch (IOException e) {
67
            e.printStackTrace(); // 打印异常信息
68
        }
69
    }
70

71
    /**
72
     * 从文件加载URL列表。
73
     */
74
    private static void loadUrls() {
75
        Path configPath = getConfigDirectory().resolve(URL_FILE_NAME); // 获取配置文件路径
76
        urlList.clear(); // 清空现有列表以准备加载新数据
77
        if (Files.exists(configPath)) { // 如果文件存在，则读取它
78
            try (BufferedReader reader = Files.newBufferedReader(configPath)) { // 使用try-with-resources确保资源关闭
79
                String line;
80
                while ((line = reader.readLine()) != null) { // 循环读取每一行
81
                    urlList.add(line); // 将每行作为一个URL添加到列表中
82
                }
83
            } catch (IOException e) {
84
                e.printStackTrace(); // 打印异常信息
85
            }
86
        }
87
    }
88

89
    /**
90
     * 保存默认URL到文件。
91
     */
92
    private static void saveDefaultUrl() {
93
        Path defaultUrlPath = getConfigDirectory().resolve(DEFAULT_URL_FILE_NAME); // 获取默认URL文件路径
94
        try (BufferedWriter writer = Files.newBufferedWriter(defaultUrlPath)) { // 使用try-with-resources确保资源关闭
95
            if (defaultUrl != null && !defaultUrl.trim().isEmpty()) {
96
                writer.write(defaultUrl); // 写入默认URL
97
            } else {
98
                // 如果没有有效的默认URL，则删除默认URL文件（如果存在）
99
                Files.deleteIfExists(defaultUrlPath);
100
            }
101
        } catch (IOException e) {
102
            e.printStackTrace(); // 打印异常信息
103
        }
104
    }
105

106
    /**
107
     * 从文件加载默认URL。
108
     */
109
    private static void loadDefaultUrl() {
110
        Path defaultUrlPath = getConfigDirectory().resolve(DEFAULT_URL_FILE_NAME); // 获取默认URL文件路径
111
        if (Files.exists(defaultUrlPath)) { // 如果文件存在，则读取它
112
            try (BufferedReader reader = Files.newBufferedReader(defaultUrlPath)) { // 使用try-with-resources确保资源关闭
113
                String line;
114
                if ((line = reader.readLine()) != null) { // 只读取第一行
115
                    defaultUrl = line; // 设置默认URL
116
                }
117
            } catch (IOException e) {
118
                e.printStackTrace(); // 打印异常信息
119
            }
120
        }
121
    }
122

123
    /**
124
     * 获取配置目录路径。
125
     * @return Minecraft配置目录下的路径
126
     */
127
    private static Path getConfigDirectory() {
128
        Path configDir = FabricLoader.getInstance().getConfigDir();
129
        try {
130
            Files.createDirectories(configDir); // 如果目录不存在，则创建之
131
        } catch (IOException e) {
132
            e.printStackTrace();
133
        }
134
        return configDir;
135
    }
136

137
    /**
138
     * 发送反馈信息到聊天栏。
139
     * @param message 要发送的消息
140
     */
141
    public static void sendFeedback(String message) {
142
        MinecraftClient.getInstance().player.sendMessage(Text.of(message), false);
143
    }
144
    public static void sendFeedback(Text textMessage) {
145
        if (MinecraftClient.getInstance().player != null) {
146
            MinecraftClient.getInstance().player.sendMessage(textMessage, false);
147
        }
148
    }
149
    public static void removeUrl(String url) {
150
        if (urlList.remove(url)) { // 如果成功移除URL
151
            saveUrls(); // 保存更新后的URL列表到文件
152

153
            // 如果被删除的URL是默认URL，则清除默认URL设置
154
            if (defaultUrl != null && defaultUrl.equals(url)) {
155
                clearDefaultUrl();
156
            }
157

158
            sendFeedback(Text.translatable("feedback.url.removed", url)); // 向玩家发送反馈
159
        } else {
160
            sendFeedback(Text.translatable("feedback.url.not_found", url)); // 如果URL不存在，则通知玩家
161
        }
162
    }
163

164
    /**
165
     * 清除默认URL设置。
166
     */
167
    private static void clearDefaultUrl() {
168
        defaultUrl = null;
169
        Path defaultUrlPath = getConfigDirectory().resolve(DEFAULT_URL_FILE_NAME); // 获取默认URL文件路径
170
        try {
171
            Files.deleteIfExists(defaultUrlPath); // 删除默认URL文件（如果存在）
172
        } catch (IOException e) {
173
            e.printStackTrace(); // 打印异常信息
174
        }
175
    }
176

177
    public static String fullUrl(String baseUrl) {
178
        MinecraftClient client = MinecraftClient.getInstance();
179
        if (client.player == null || client.world == null|| webmapview==false ) {
180
            sendFeedback(Text.translatable("feedback.player_or_world_not_available")); // 使用翻译文本
181
            return baseUrl; // 如果无法获取玩家或世界信息，则返回原始URL
182
        }
183

184
        // 获取玩家坐标并转换为整数
185
        int playerX = (int) client.player.getX();
186
        int playerZ = (int) client.player.getZ();
187

188
        // 获取玩家所在的世界名称
189
        String worldName = client.world.getRegistryKey().getValue().toString();
190
        if(Objects.equals(worldName, "minecraft:overworld")){
191
            worldName = "world";
192
        } else if (Objects.equals(worldName, "minecraft:the_nether")){
193
            worldName = "world_nether";
194
        } else if (Objects.equals(worldName, "minecraft:the_end")){
195
            worldName = "world_the_end";
196
        }
197

198
        // 构建完整的URL
199
        StringBuilder fullUrlBuilder = new StringBuilder("https://").append(baseUrl).append("/"); // 添加协议头
200
        if (!baseUrl.contains("?")) { // 检查是否已有参数
201
            fullUrlBuilder.append("?");
202
        } else {
203
            fullUrlBuilder.append("&"); // 如果已经有参数，则使用&连接
204
        }
205
        fullUrlBuilder.append("x=").append(playerX)
206
                .append("&z=").append(playerZ)
207
                .append("&zoom=").append("4")
208
                .append("&world=").append(worldName);
209

210
        return fullUrlBuilder.toString();
211
    }
212
}

1
public class WebmapviewClient implements ClientModInitializer {
2

3
    private static CompletableFuture<Suggestions> suggestUrls(CommandContext<?> context, SuggestionsBuilder builder) {
4
        List<String> urls = UrlManager.getUrlList();
5
        urls.forEach(builder::suggest);
6
        return builder.buildFuture();
7
    }
8
    private KeyBinding keyBinding;
9
    @Override
10
    public void onInitializeClient() {
11
//        ClientTickEvents.START_CLIENT_TICK.register((client) -> onTick());
12
        // 注册“addturl”命令，用于添加新的URL
13
        ClientCommandRegistrationCallback.EVENT.register((dispatcher, registryAccess) -> {
14
            dispatcher.register(
15
                    ClientCommandManager.literal("urladd")
16
                            .then(ClientCommandManager.argument("url", StringArgumentType.string())
17
                                    .executes(context -> {
18
                                        String url = StringArgumentType.getString(context, "url");
19
                                        UrlManager.addUrl(url); // 添加URL
20
                                        return 1; // 命令成功执行
21
                                    })
22
                            )
23
            );
24

25
            // 注册“removeurl”命令，用于删除URL
26
            dispatcher.register(
27
                    ClientCommandManager.literal("urlremove")
28
                            .then(ClientCommandManager.argument("url", StringArgumentType.string()).suggests(WebmapviewClient::suggestUrls)
29
                                    .executes(context -> {
30
                                        String url = StringArgumentType.getString(context, "url");
31
                                        UrlManager.removeUrl(url); // 删除URL
32
                                        return 1; // 命令成功执行
33
                                    })
34
                            )
35
            );
36

37
            // 注册“urllist”命令，用于列出所有已添加的URL
38
            dispatcher.register(
39
                    ClientCommandManager.literal("urllist")
40
                            .executes(context -> {
41
                                List<String> urls = UrlManager.getUrlList(); // 获取所有URL
42
                                StringBuilder listMessage = new StringBuilder("Available URLs:\n");
43
                                for (int i = 0; i < urls.size(); i++) {
44
                                    listMessage.append(i + 1).append(": ").append(urls.get(i)).append("\n"); // 格式化输出
45
                                }
46
                                context.getSource().sendFeedback(Text.of(listMessage.toString())); // 向玩家展示结果
47
                                return 1; // 命令成功执行
48
                            })
49
            );
50
            // 注册“urlset”命令，用于设置默认URL
51
            dispatcher.register(
52
                    ClientCommandManager.literal("urlset")
53
                            .then(ClientCommandManager.argument("url", StringArgumentType.string()).suggests(WebmapviewClient::suggestUrls)
54
                                    .executes(context -> {
55
                                        String url = StringArgumentType.getString(context, "url");
56
                                        UrlManager.setDefaultUrl(url); // 设置默认URL
57
                                        return 1; // 命令成功执行
58
                                    })
59
                            )
60
            );
61
            dispatcher.register(
62
                    ClientCommandManager.literal("webmapviewoption")
63
                            .then(ClientCommandManager.argument("url", StringArgumentType.string())
64
                                    .executes(context -> {
65
                                        UrlManager.webmapview = !UrlManager.webmapview;
66
                                        if (UrlManager.webmapview) {
67
                                            sendFeedback("webmapview is enabled");
68
                                        } else {
69
                                            sendFeedback("webmapview is not enabled");
70
                                        }
71

72
                                   return 1; })
73
                            )
74
            );
75
            dispatcher.register(
76
                    ClientCommandManager.literal("webmapview")
77
                            .then(ClientCommandManager.literal("help")
78
                                    .executes(context -> {
79
                                        StringBuilder helpMessage = new StringBuilder();
80
                                        helpMessage.append("/urladd: ").append(Text.translatable("command.urladd.description").getString()).append("\n")
81
                                                .append("/urlremove: ").append(Text.translatable("command.urlremove.description").getString()).append("\n")
82
                                                .append("/urllist: ").append(Text.translatable("command.urllist.description").getString()).append("\n")
83
                                                .append("/urlset: ").append(Text.translatable("command.urlset.description").getString()).append("\n")
84
                                                .append("/webmapviewoption: ").append(Text.translatable("command.webmapviewoption.description").getString()).append("\n");
85
                                        ;
86
                                        sendFeedback((helpMessage.toString()) );
87
                                        return 1;
88
                                    })
89
                            )
90
            );
91
        });
92

93
        // 初始化KeyBinding
94
        keyBinding = new KeyBinding(
95
                "key.webmapview.open_basic_browser",  // 使用唯一标识符
96
                GLFW.GLFW_KEY_H,                      // 默认按键
97
                "category.webmapview"                       // 分类
98
        );
99

100
        // 注册KeyBinding
101
        KeyBindingHelper.registerKeyBinding(keyBinding);
102

103
        final MinecraftClient minecraft = MinecraftClient.getInstance();
104
        // 监听客户端tick事件，处理按键输入
105
        ClientTickEvents.END_CLIENT_TICK.register(client -> {
106
            while (keyBinding.wasPressed()) {
107
                if (!(minecraft.currentScreen instanceof BasicBrowser)) {
108
                    minecraft.setScreen(new BasicBrowser(
109
                            Text.literal("Basic Browser")
110
                    ));
111
                }
112
            }
113
        });
114
    }
115
    }

1
private static final String URL_FILE_NAME = "urls.txt"; // 存储URL列表的文件名
2
    private static final String DEFAULT_URL_FILE_NAME = "default_url.txt"; // 默认URL文件名
3
    private static List<String> urlList = new ArrayList<>(); // 存储URL的列表
4
    public static String defaultUrl="squaremap-demo.jpenilla.xyz"; // 默认URL
5
    public static boolean webmapview=true;