MiniDay/hamster-ball-bridge
1
0
Fork 0
Code Issues Pull Requests Actions Releases 2 Activity

feat: 支持仓鼠球 1.5+

Browse Source
This commit is contained in:
叁只仓鼠
2024-03-11 19:36:44 +08:00
commit debdcb40e0
45 changed files with 3525 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/main/java/cn/hamster3/service/bungee/BallBridgePlugin.java Normal file
View File

@@ -0,0 +1,27 @@
package cn.hamster3.service.bungee;
import cn.hamster3.mc.plugin.ball.common.api.BallAPI;
import cn.hamster3.service.bungee.command.ServiceCommand;
import cn.hamster3.service.bungee.listener.BridgeListener;
import cn.hamster3.service.bungee.listener.ServiceMainListener;
import cn.hamster3.service.common.util.ServiceLogUtils;
import net.md_5.bungee.api.ProxyServer;
import net.md_5.bungee.api.plugin.Plugin;
public class BallBridgePlugin extends Plugin {
public static void main(String[] args) {
}
@Override
public void onLoad() {
ServiceLogUtils.setLogger(getLogger());
}
@Override
public void onEnable() {
BallAPI.getInstance().getEventBus().register(BridgeListener.INSTANCE);
ProxyServer.getInstance().getPluginManager().registerListener(this, ServiceMainListener.INSTANCE);
ProxyServer.getInstance().getPluginManager().registerCommand(this, ServiceCommand.INSTANCE);
BallAPI.getInstance().subscribeIgnorePrefix("HamsterService");
}
}

141
src/main/java/cn/hamster3/service/bungee/api/ServiceInfoAPI.java Normal file
View File

@@ -0,0 +1,141 @@
package cn.hamster3.service.bungee.api;
import cn.hamster3.mc.plugin.ball.common.api.BallAPI;
import cn.hamster3.mc.plugin.ball.common.entity.BallPlayerInfo;
import cn.hamster3.mc.plugin.ball.common.entity.BallServerInfo;
import cn.hamster3.mc.plugin.ball.common.entity.BallServerType;
import cn.hamster3.service.common.data.ServicePlayerInfo;
import cn.hamster3.service.common.entity.ServiceSenderInfo;
import cn.hamster3.service.common.entity.ServiceSenderType;
import org.jetbrains.annotations.NotNull;
import java.util.HashSet;
import java.util.UUID;
import java.util.stream.Collectors;
@SuppressWarnings("unused")
public class ServiceInfoAPI {
/**
* 获取玩家信息，当玩家不在线时返回 null
*
* @param uuid 玩家的UUID
* @return 玩家信息
*/
public static ServicePlayerInfo getPlayerInfo(@NotNull UUID uuid) {
return transfer(BallAPI.getInstance().getPlayerInfo(uuid));
}
/**
* 获取玩家信息，当玩家不在线时返回 null
*
* @param playerName 玩家ID
* @return 玩家信息
*/
public static ServicePlayerInfo getPlayerInfo(@NotNull String playerName) {
return transfer(BallAPI.getInstance().getPlayerInfo(playerName));
}
/**
* 获取全部在线玩家的信息
*
* @return 玩家们的信息
*/
public static HashSet<ServicePlayerInfo> getOnlinePlayers() {
return BallAPI.getInstance().getAllPlayerInfo().values()
.stream()
.filter(BallPlayerInfo::isOnline)
.map(ServiceInfoAPI::transfer)
.collect(Collectors.toCollection(HashSet::new));
}
/**
* 获取全部在线玩家的信息
*
* @return 玩家们的信息
*/
public static HashSet<ServicePlayerInfo> getAllPlayerInfo() {
return BallAPI.getInstance().getAllPlayerInfo().values()
.stream()
.map(ServiceInfoAPI::transfer)
.collect(Collectors.toCollection(HashSet::new));
}
/**
* 获取服务端信息
*
* @param senderName 服务端id
* @return 服务端信息
*/
public static ServiceSenderInfo getSenderInfo(String senderName) {
return transfer(BallAPI.getInstance().getServerInfo(senderName));
}
/**
* 获取所有连接至服务中心的信息
*
* @return 服务器信息
*/
public static HashSet<ServiceSenderInfo> getAllSenderInfo() {
return BallAPI.getInstance().getAllServerInfo().values()
.stream()
.map(ServiceInfoAPI::transfer)
.collect(Collectors.toCollection(HashSet::new));
}
/**
* 获取当前服务器的名称
*
* @return 服务器id
*/
public static String getLocalServerName() {
return BallAPI.getInstance().getLocalServerId();
}
/**
* 获取当前服务器的别名
*
* @return 服务器别名
*/
public static String getLocalServerNickName() {
return BallAPI.getInstance().getLocalServerInfo().getName();
}
/**
* 获取当前服务器的SenderInfo对象
*
* @return 当前服务器的发送者信息
*/
public static ServiceSenderInfo getLocalSenderInfo() {
return new ServiceSenderInfo(
ServiceSenderType.PROXY,
BallAPI.getInstance().getLocalServerInfo().getId(),
BallAPI.getInstance().getLocalServerInfo().getName()
);
}
public static ServiceSenderInfo transfer(BallServerInfo info) {
if (info == null) {
return null;
}
return new ServiceSenderInfo(
info.getType() == BallServerType.PROXY ? ServiceSenderType.PROXY : ServiceSenderType.BUKKIT,
info.getId(),
info.getName()
);
}
public static ServicePlayerInfo transfer(BallPlayerInfo info) {
if (info == null) {
return null;
}
return new ServicePlayerInfo(
info.getUuid(),
info.getName(),
info.getGameServer(),
info.getProxyServer(),
info.isOnline()
);
}
}

329
src/main/java/cn/hamster3/service/bungee/api/ServiceMessageAPI.java Normal file
View File

@@ -0,0 +1,329 @@
package cn.hamster3.service.bungee.api;
import cn.hamster3.mc.plugin.ball.common.api.BallAPI;
import cn.hamster3.mc.plugin.ball.common.data.BallMessage;
import cn.hamster3.service.common.data.ServiceLocation;
import cn.hamster3.service.common.data.ServicePlayerInfo;
import cn.hamster3.service.common.entity.ServiceMessageInfo;
import cn.hamster3.service.common.util.ComponentUtils;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import net.md_5.bungee.api.ProxyServer;
import net.md_5.bungee.api.connection.ProxiedPlayer;
import java.util.UUID;
@SuppressWarnings("unused")
public abstract class ServiceMessageAPI {
/**
* 订阅某个标签的消息
*
* @param tag 标签
*/
public static void subscribeTag(String tag) {
sendServiceMessage("HamsterService", "subscribeTag", tag);
}
/**
* 取消订阅某个标签的消息
*
* @param tag 标签
*/
public static void unsubscribeTag(String tag) {
sendServiceMessage("HamsterService", "unsubscribeTag", tag);
}
/**
* 发送一条服务消息
*
* @param tag 消息标签
* @param action 执行动作
*/
public static void sendServiceMessage(String tag, String action) {
BallAPI.getInstance().sendRawBallMessage(tag, action);
}
/**
* 发送一条有附加参数的服务消息
*
* @param tag 消息标签
* @param action 执行动作
* @param content 附加参数
*/
public static void sendServiceMessage(String tag, String action, String content) {
BallAPI.getInstance().sendRawBallMessage(tag, action, content);
}
/**
* 发送一条有附加参数的服务消息，使用 String.format() 替换附加参数
*
* @param tag 消息标签
* @param action 执行动作
* @param content 附加参数
* @param args 替换参数
* @see String#format(String, Object...)
*/
public static void sendServiceMessage(String tag, String action, String content, Object... args) {
BallAPI.getInstance().sendRawBallMessage(tag, action, new JsonPrimitive(String.format(content, args)));
}
/**
* 发送一条有附加参数的消息
*
* @param tag 消息标签
* @param action 执行动作
* @param content 附加参数
*/
public static void sendServiceMessage(String tag, String action, JsonElement content) {
BallAPI.getInstance().sendBallMessage(tag, new BallMessage(action, content), false, false);
}
/**
* 自定义服务消息信息并发送
*
* @param info 消息内容
* @param block 是否阻塞（即必须等待消息发送完成，该方法才会返回）
*/
public static void sendServiceMessage(ServiceMessageInfo info, boolean block) {
BallMessage message = new BallMessage(
info.getSenderInfo().getName(),
info.getToServer(),
null,
info.getAction(),
info.getContent()
);
BallAPI.getInstance().sendBallMessage(info.getTag(), message, false, block);
}
/**
* 强制玩家执行一个 bukkit 命令
*
* @param uuid 玩家的uuid
* @param command 命令内容
*/
public static void dispatchBukkitCommand(UUID uuid, String command) {
sendServiceMessage("HamsterService", "dispatchBukkitCommand", command);
}
/**
* 强制玩家执行一个代理端（指BungeeCord等）命令
*
* @param uuid 玩家的uuid
* @param command 命令内容
*/
public static void dispatchProxyCommand(UUID uuid, String command) {
sendServiceMessage("HamsterService", "dispatchProxyCommand", command);
}
/**
* 给玩家发送一条消息
*
* @param uuid 玩家
* @param message 消息
*/
public static void sendPlayerMessage(UUID uuid, String message) {
sendPlayerMessage(uuid, new JsonPrimitive(message));
}
/**
* 给玩家发送一条消息
*
* @param uuid 玩家
* @param message 消息
*/
public static void sendPlayerMessage(UUID uuid, JsonElement message) {
ProxiedPlayer player = ProxyServer.getInstance().getPlayer(uuid);
if (player != null) {
player.sendMessage(ComponentUtils.parseComponentFromJson(message));
return;
}
JsonObject object = new JsonObject();
object.addProperty("uuid", uuid.toString());
object.add("message", message);
sendServiceMessage("HamsterService", "sendPlayerMessage", object);
}
/**
* 给服务器的在线玩家广播一条消息
*
* @param message 消息
* @since 2.1.0
*/
public static void broadcastMessage(String message) {
JsonObject object = new JsonObject();
object.addProperty("text", message);
broadcastMessage(object);
}
/**
* 给服务器的在线玩家广播一条消息
*
* @param message 消息
* @since 2.1.0
*/
public static void broadcastMessage(JsonElement message) {
sendServiceMessage("HamsterService", "broadcastMessage", message);
}
/**
* 把玩家传送到另一个玩家身边
* <p>
* 支持跨服传送
*
* @param sendPlayer 被传送的玩家
* @param toPlayer 传送的目标玩家
* @since 2.1.0
*/
public static void sendPlayerToPlayer(UUID sendPlayer, UUID toPlayer) {
ServicePlayerInfo sendPlayerInfo = ServiceInfoAPI.getPlayerInfo(sendPlayer);
// 如果被传送玩家不在线
if (sendPlayerInfo == null || !sendPlayerInfo.isOnline()) {
return;
}
ServicePlayerInfo toPlayerInfo = ServiceInfoAPI.getPlayerInfo(toPlayer);
// 如果目标玩家不在线
if (toPlayerInfo == null || !toPlayerInfo.isOnline()) {
return;
}
JsonObject object = new JsonObject();
object.addProperty("sendPlayer", sendPlayer.toString());
object.addProperty("toPlayer", toPlayer.toString());
sendServiceMessage("HamsterService", "sendPlayerToPlayer", object);
}
/**
* 把玩家传送到一个位置
* <p>
* 支持跨服传送
*
* @param uuid 玩家的uuid
* @param location 坐标
* @since 2.1.0
*/
public static void sendPlayerToLocation(UUID uuid, ServiceLocation location) {
ServicePlayerInfo playerInfo = ServiceInfoAPI.getPlayerInfo(uuid);
// 如果玩家不在线
if (playerInfo == null || !playerInfo.isOnline()) {
return;
}
// 如果目标服务器不在线
if (ServiceInfoAPI.getSenderInfo(location.getServerName()) == null) {
return;
}
JsonObject object = new JsonObject();
object.addProperty("uuid", uuid.toString());
object.add("location", location.saveToJson());
sendServiceMessage("HamsterService", "sendPlayerToLocation", object);
}
public static void kickPlayer(UUID uuid, String reason) {
kickPlayer(uuid, new JsonPrimitive(reason));
}
public static void kickPlayer(UUID uuid, JsonElement reason) {
ProxiedPlayer player = ProxyServer.getInstance().getPlayer(uuid);
if (player != null) {
player.disconnect(ComponentUtils.parseComponentFromJson(reason));
return;
}
JsonObject object = new JsonObject();
object.addProperty("uuid", uuid.toString());
object.add("reason", reason);
sendServiceMessage("HamsterService", "kickPlayer", object);
}
/**
* 开启/关闭 安全模式
* <p>
* 在安全模式开启时玩家将无法连接至服务器
* <p>
* 且根据 config 的配置不同，有可能会踢出全部在线玩家
*
* @param enable 是否启用
*/
public static void setSafeMode(boolean enable) {
sendServiceMessage("HamsterService", "setSafeMode", new JsonPrimitive(enable));
}
/**
* 发送一条服务消息
*
* @param tag 消息标签
* @param action 执行动作
* @deprecated 你应该使用 sendServiceMessage
* <p>
* 因为这个方法名有歧义
*/
@Deprecated
public static void sendMessage(String tag, String action) {
sendServiceMessage(tag, action);
}
/**
* 发送一条有附加参数的服务消息
*
* @param tag 消息标签
* @param action 执行动作
* @param content 附加参数
* @deprecated 你应该使用 sendServiceMessage
* <p>
* 因为这个方法名有歧义
*/
@Deprecated
public static void sendMessage(String tag, String action, String content) {
sendServiceMessage(tag, action, content);
}
/**
* 发送一条有附加参数的服务消息，使用 String.format() 替换附加参数
*
* @param tag 消息标签
* @param action 执行动作
* @param content 附加参数
* @param args 替换参数
* @see String#format(String, Object...)
* @deprecated 你应该使用 sendServiceMessage
* <p>
* 因为这个方法名有歧义
*/
@Deprecated
public static void sendMessage(String tag, String action, String content, Object... args) {
sendServiceMessage(tag, action, content, args);
}
/**
* 发送一条有附加参数的服务消息
*
* @param tag 消息标签
* @param action 执行动作
* @param content 附加参数
* @deprecated 你应该使用 sendServiceMessage
* <p>
* 因为这个方法名有歧义
*/
@Deprecated
public static void sendMessage(String tag, String action, JsonElement content) {
sendServiceMessage(tag, action, content);
}
/**
* 自定义服务消息信息并发送
*
* @param info 消息内容
* @param block 是否阻塞（即必须等待消息发送完成，该方法才会返回）
* @deprecated 你应该使用 sendServiceMessage
* <p>
* 因为这个方法名有歧义
*/
@Deprecated
public static void sendMessage(ServiceMessageInfo info, boolean block) {
sendServiceMessage(info, block);
}
}

35
src/main/java/cn/hamster3/service/bungee/command/ServiceCommand.java Normal file
View File

@@ -0,0 +1,35 @@
package cn.hamster3.service.bungee.command;
import net.md_5.bungee.api.CommandSender;
import net.md_5.bungee.api.chat.TextComponent;
import net.md_5.bungee.api.plugin.Command;
public class ServiceCommand extends Command {
public static final ServiceCommand INSTANCE = new ServiceCommand();
private ServiceCommand() {
super("serviceb", "service.admin");
}
@Override
public void execute(CommandSender sender, String[] args) {
if (!sender.hasPermission("service.admin")) {
sender.sendMessage(new TextComponent("§c你没有权限执行这个命令!"));
return;
}
if (args.length < 1) {
sender.sendMessage(new TextComponent("§c/service command [bukkit/proxy] [命令内容]"));
return;
}
switch (args[0]) {
case "command": {
SudoConsoleCommand.INSTANCE.onCommand(sender, args);
break;
}
case "": {
break;
}
}
}
}

42
src/main/java/cn/hamster3/service/bungee/command/SudoConsoleCommand.java Normal file
View File

@@ -0,0 +1,42 @@
package cn.hamster3.service.bungee.command;
import cn.hamster3.service.bungee.api.ServiceMessageAPI;
import net.md_5.bungee.api.CommandSender;
import net.md_5.bungee.api.chat.TextComponent;
import org.jetbrains.annotations.NotNull;
public class SudoConsoleCommand {
public static final SudoConsoleCommand INSTANCE = new SudoConsoleCommand();
private SudoConsoleCommand() {
}
public void onCommand(@NotNull CommandSender sender, @NotNull String[] args) {
if (args.length < 3) {
sender.sendMessage(new TextComponent("§c/service command [bukkit/proxy] [命令内容]"));
return;
}
String action;
switch (args[1].toLowerCase()) {
case "bukkit": {
action = "bukkitConsoleCommand";
break;
}
case "proxy": {
action = "proxyConsoleCommand";
break;
}
default: {
sender.sendMessage(new TextComponent("§c/service command [bukkit/proxy] [命令内容]"));
return;
}
}
StringBuilder builder = new StringBuilder();
for (int i = 2; i < args.length; i++) {
builder.append(args[i]).append(" ");
}
ServiceMessageAPI.sendServiceMessage("HamsterService", action, builder.toString());
sender.sendMessage(new TextComponent("§c已广播命令执行信息."));
}
}

21
src/main/java/cn/hamster3/service/bungee/event/MessageEvent.java Normal file
View File

@@ -0,0 +1,21 @@
package cn.hamster3.service.bungee.event;
import cn.hamster3.service.common.entity.ServiceMessageInfo;
import net.md_5.bungee.api.plugin.Event;
/**
* 服务消息事件的基类
*/
@SuppressWarnings("unused")
public class MessageEvent extends Event {
private final ServiceMessageInfo messageInfo;
public MessageEvent(ServiceMessageInfo messageInfo) {
this.messageInfo = messageInfo;
}
public ServiceMessageInfo getMessageInfo() {
return messageInfo;
}
}

14
src/main/java/cn/hamster3/service/bungee/event/MessageReceivedEvent.java Normal file
View File

@@ -0,0 +1,14 @@
package cn.hamster3.service.bungee.event;
import cn.hamster3.service.common.entity.ServiceMessageInfo;
/**
* 从服务中心收到消息时产生的事件
*/
@SuppressWarnings("unused")
public class MessageReceivedEvent extends MessageEvent {
public MessageReceivedEvent(ServiceMessageInfo info) {
super(info);
}
}

44
src/main/java/cn/hamster3/service/bungee/event/MessageSentEvent.java Normal file
View File

@@ -0,0 +1,44 @@
package cn.hamster3.service.bungee.event;
import cn.hamster3.service.common.entity.ServiceMessageInfo;
/**
* 消息发送出去之后产生的事件
*/
@SuppressWarnings("unused")
public class MessageSentEvent extends MessageEvent {
private final boolean success;
private final Throwable cause;
public MessageSentEvent(ServiceMessageInfo info) {
super(info);
success = true;
cause = null;
}
public MessageSentEvent(ServiceMessageInfo messageInfo, Throwable cause) {
super(messageInfo);
success = false;
this.cause = cause;
}
/**
* 消息是否成功发送出去了
*
* @return true代表成功发送
*/
public boolean isSuccess() {
return success;
}
/**
* 若消息发送失败，则失败原因为何
* 若发送成功，则返回null
*
* @return 失败原因
*/
public Throwable getCause() {
return cause;
}
}

45
src/main/java/cn/hamster3/service/bungee/event/ServiceConnectEvent.java Normal file
View File

@@ -0,0 +1,45 @@
package cn.hamster3.service.bungee.event;
import net.md_5.bungee.api.plugin.Event;
/**
* 服务连接事件
*/
@SuppressWarnings("unused")
public class ServiceConnectEvent extends Event {
private final boolean success;
private final Throwable cause;
public ServiceConnectEvent() {
success = true;
cause = null;
}
public ServiceConnectEvent(Throwable cause) {
success = false;
this.cause = cause;
}
/**
* 是否成功连接到服务中心
*
* @return true代表成功
*/
public boolean isSuccess() {
return success;
}
/**
* 如果连接失败了，则返回失败原因
* <p>
* 如果连接成功了，则返回null
*
* @return 失败原因
*/
public Throwable getCause() {
return cause;
}
}

37
src/main/java/cn/hamster3/service/bungee/listener/BridgeListener.java Normal file
View File

@@ -0,0 +1,37 @@
package cn.hamster3.service.bungee.listener;
import cn.hamster3.service.bungee.api.ServiceInfoAPI;
import cn.hamster3.service.bungee.event.MessageReceivedEvent;
import cn.hamster3.service.bungee.event.MessageSentEvent;
import cn.hamster3.service.common.entity.ServiceMessageInfo;
import com.google.common.eventbus.Subscribe;
import net.md_5.bungee.api.ProxyServer;
public class BridgeListener {
public static final BridgeListener INSTANCE = new BridgeListener();
private BridgeListener() {
}
@Subscribe
public void onMessageSent(cn.hamster3.mc.plugin.ball.common.event.message.MessageSentEvent event) {
ProxyServer.getInstance().getPluginManager().callEvent(new MessageSentEvent(new ServiceMessageInfo(
ServiceInfoAPI.getSenderInfo(event.getSenderID()),
event.getReceiverID(),
event.getChannel(),
event.getAction(),
event.getContent()
)));
}
@Subscribe
public void onMessageReceived(cn.hamster3.mc.plugin.ball.common.event.message.MessageReceivedEvent event) {
ProxyServer.getInstance().getPluginManager().callEvent(new MessageReceivedEvent(new ServiceMessageInfo(
ServiceInfoAPI.getSenderInfo(event.getSenderID()),
event.getReceiverID(),
event.getChannel(),
event.getAction(),
event.getContent()
)));
}
}

158
src/main/java/cn/hamster3/service/bungee/listener/ServiceMainListener.java Normal file
View File

@@ -0,0 +1,158 @@
package cn.hamster3.service.bungee.listener;
import cn.hamster3.service.bungee.api.ServiceInfoAPI;
import cn.hamster3.service.bungee.api.ServiceMessageAPI;
import cn.hamster3.service.bungee.event.MessageReceivedEvent;
import cn.hamster3.service.bungee.event.ServiceConnectEvent;
import cn.hamster3.service.common.data.ServiceLocation;
import cn.hamster3.service.common.data.ServicePlayerInfo;
import cn.hamster3.service.common.entity.ServiceMessageInfo;
import cn.hamster3.service.common.entity.ServiceSenderInfo;
import cn.hamster3.service.common.util.ComponentUtils;
import cn.hamster3.service.common.util.ServiceLogUtils;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import net.md_5.bungee.api.ProxyServer;
import net.md_5.bungee.api.connection.ProxiedPlayer;
import net.md_5.bungee.api.event.PlayerDisconnectEvent;
import net.md_5.bungee.api.event.PostLoginEvent;
import net.md_5.bungee.api.event.ServerConnectedEvent;
import net.md_5.bungee.api.plugin.Listener;
import net.md_5.bungee.event.EventHandler;
import net.md_5.bungee.event.EventPriority;
import java.util.UUID;
public class ServiceMainListener implements Listener {
public static final ServiceMainListener INSTANCE = new ServiceMainListener();
private ServiceMainListener() {
}
@EventHandler
public void onServiceConnect(ServiceConnectEvent event) {
if (!event.isSuccess()) {
return;
}
ServiceLogUtils.info("连接至服务中心成功...");
JsonArray playerInfoArray = new JsonArray();
for (ProxiedPlayer player : ProxyServer.getInstance().getPlayers()) {
ServicePlayerInfo playerInfo = new ServicePlayerInfo(
player.getUniqueId(),
player.getName(),
player.getServer().getInfo().getName(),
ServiceInfoAPI.getLocalServerName()
);
playerInfoArray.add(playerInfo.saveToJson());
}
ServiceMessageAPI.sendServiceMessage("HamsterService", "updatePlayerInfoArray", playerInfoArray);
}
@EventHandler
public void onMessageReceived(MessageReceivedEvent event) {
ServiceMessageInfo info = event.getMessageInfo();
if (!"HamsterService".equals(info.getTag())) {
return;
}
switch (info.getAction()) {
case "sendPlayerMessage": {
JsonObject object = info.getContentAsJsonObject();
UUID uuid = UUID.fromString(object.get("uuid").getAsString());
ProxiedPlayer player = ProxyServer.getInstance().getPlayer(uuid);
if (player == null) {
return;
}
player.sendMessage(ComponentUtils.parseComponentFromJson(object.get("message")));
break;
}
case "broadcastMessage": {
ProxyServer.getInstance().broadcast(ComponentUtils.parseComponentFromJson(info.getContentAsJsonObject()));
break;
}
case "proxyConsoleCommand": {
ProxyServer.getInstance().getPluginManager().dispatchCommand(
ProxyServer.getInstance().getConsole(),
info.getContentAsString()
);
break;
}
case "dispatchProxyCommand": {
JsonObject object = info.getContentAsJsonObject();
UUID uuid = UUID.fromString(object.get("uuid").getAsString());
ProxiedPlayer player = ProxyServer.getInstance().getPlayer(uuid);
if (player == null) {
return;
}
ProxyServer.getInstance().getPluginManager().dispatchCommand(player, object.get("command").getAsString());
break;
}
case "sendPlayerToLocation": {
JsonObject object = info.getContent().getAsJsonObject();
UUID uuid = UUID.fromString(object.get("uuid").getAsString());
ProxiedPlayer player = ProxyServer.getInstance().getPlayer(uuid);
if (player == null) {
return;
}
ServiceLocation location = new ServiceLocation(object.getAsJsonObject("location"));
if (location.getServerName().equals(player.getServer().getInfo().getName())) {
return;
}
ServiceSenderInfo senderInfo = ServiceInfoAPI.getSenderInfo(location.getServerName());
if (senderInfo == null) {
return;
}
player.connect(ProxyServer.getInstance().getServerInfo(location.getServerName()));
break;
}
case "kickPlayer": {
JsonObject object = info.getContentAsJsonObject();
UUID uuid = UUID.fromString(object.get("uuid").getAsString());
ProxiedPlayer player = ProxyServer.getInstance().getPlayer(uuid);
if (player != null) {
player.disconnect(ComponentUtils.parseComponentFromJson(object.get("reason")));
return;
}
break;
}
}
}
@EventHandler
public void onServerConnected(ServerConnectedEvent event) {
ProxiedPlayer player = event.getPlayer();
ServicePlayerInfo playerInfo = new ServicePlayerInfo(
player.getUniqueId(),
player.getName(),
event.getServer().getInfo().getName(),
ServiceInfoAPI.getLocalServerName()
);
ServiceMessageAPI.sendServiceMessage("HamsterService", "updatePlayerInfo", playerInfo.saveToJson());
}
@EventHandler(priority = EventPriority.HIGH)
public void onPostLogin(PostLoginEvent event) {
ProxiedPlayer player = event.getPlayer();
ServicePlayerInfo playerInfo = new ServicePlayerInfo(
player.getUniqueId(),
player.getName(),
null,
ServiceInfoAPI.getLocalServerName(),
true
);
ServiceMessageAPI.sendServiceMessage("HamsterService", "playerPostLogin", playerInfo.saveToJson());
}
@EventHandler
public void onPlayerDisconnect(PlayerDisconnectEvent event) {
ProxiedPlayer player = event.getPlayer();
ServicePlayerInfo playerInfo = new ServicePlayerInfo(
player.getUniqueId(),
player.getName(),
null,
ServiceInfoAPI.getLocalServerName(),
false
);
ServiceMessageAPI.sendServiceMessage("HamsterService", "playerDisconnect", playerInfo.saveToJson());
}
}