Merge branch 'main' into dev-scene

.gitignore

@@ -27,7 +27,8 @@ hs_err_pid*
 .gradle
 
 # Ignore Gradle build output directory
-build
+build/
+out/
 
 # Eclipse
 .project

run.bat

@@ -0,0 +1,7 @@
+@echo off
+
+
+
+::This will not work if your java is in a different location, plugin as necessary
+::this just saves you from changing your PATH
+"C:\Program Files\Java\jdk1.8.0_202\bin\java.exe" -jar ./grasscutter.jar

src/deprecated/java/emu/grasscutter/commands/PlayerCommands.java

@@ -0,0 +1,307 @@
+package emu.grasscutter.commands;
+
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+
+import emu.grasscutter.data.GenshinData;
+import emu.grasscutter.data.def.ItemData;
+import emu.grasscutter.data.def.MonsterData;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.game.entity.EntityAvatar;
+import emu.grasscutter.game.entity.EntityItem;
+import emu.grasscutter.game.entity.EntityMonster;
+import emu.grasscutter.game.entity.GenshinEntity;
+import emu.grasscutter.game.inventory.GenshinItem;
+import emu.grasscutter.game.inventory.ItemType;
+import emu.grasscutter.game.props.ActionReason;
+import emu.grasscutter.game.props.FightProperty;
+import emu.grasscutter.server.packet.send.PacketEntityFightPropUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketItemAddHintNotify;
+import emu.grasscutter.utils.Position;
+
+public class PlayerCommands {
+	private static HashMap<String, PlayerCommand> list = new HashMap<>();
+	
+	static {
+		try {
+			// Look for classes
+			for (Class<?> cls : PlayerCommands.class.getDeclaredClasses()) {
+				// Get non abstract classes
+			    if (!Modifier.isAbstract(cls.getModifiers())) {
+			    	Command commandAnnotation = cls.getAnnotation(Command.class);
+			    	PlayerCommand command = (PlayerCommand) cls.newInstance();
+			    	
+			    	if (commandAnnotation != null) {
+			    		command.setLevel(commandAnnotation.gmLevel());
+			    		for (String alias : commandAnnotation.aliases()) {
+			    			if (alias.length() == 0) {
+			    				continue;
+			    			}
+			    			
+			    			String commandName = "!" + alias;
+					    	list.put(commandName, command);
+					    	commandName = "/" + alias;
+					    	list.put(commandName, command);
+			    		}
+			    	}
+			    	
+			    	String commandName = "!" + cls.getSimpleName().toLowerCase();
+			    	list.put(commandName, command);
+			    	commandName = "/" + cls.getSimpleName().toLowerCase();
+			    	list.put(commandName, command);
+			    }
+		
+			}
+		} catch (Exception e) {
+			
+		}
+	}
+
+	public static void handle(GenshinPlayer player, String msg) {
+		String[] split = msg.split(" ");
+		
+		// End if invalid
+		if (split.length == 0) {
+			return;
+		}
+		
+		//
+		String first = split[0].toLowerCase();
+		PlayerCommand c = PlayerCommands.list.get(first);
+		
+		if (c != null) {
+			// Level check
+			if (player.getGmLevel() < c.getLevel()) {
+				return;
+			}
+			// Execute
+			int len = Math.min(first.length() + 1, msg.length());
+			c.execute(player, msg.substring(len));
+		}
+	}
+	
+	public static abstract class PlayerCommand {
+		// GM level required to use this command
+		private int level;
+		protected int getLevel() { return this.level; }
+		protected void setLevel(int minLevel) { this.level = minLevel; }
+		
+		// Main
+		public abstract void execute(GenshinPlayer player, String raw);
+	}
+	
+	// ================ Commands ================
+	
+	@Command(aliases = {"g", "item", "additem"}, helpText = "/give [item id] [count] - Gives {count} amount of {item id}")
+	public static class Give extends PlayerCommand {
+		@Override
+		public void execute(GenshinPlayer player, String raw) {
+			String[] split = raw.split(" ");
+			int itemId = 0, count = 1;
+			
+			try {
+				itemId = Integer.parseInt(split[0]);
+			} catch (Exception e) {
+				itemId = 0;
+			}
+			
+			try {
+				count = Math.max(Math.min(Integer.parseInt(split[1]), Integer.MAX_VALUE), 1);
+			} catch (Exception e) {
+				count = 1;
+			}
+			
+			// Give
+			ItemData itemData = GenshinData.getItemDataMap().get(itemId);
+			GenshinItem item;
+			
+			if (itemData == null) {
+				player.dropMessage("Error: Item data not found");
+				return;
+			}
+			
+			if (itemData.isEquip()) {
+				List<GenshinItem> items = new LinkedList<>();
+				for (int i = 0; i < count; i++) {
+					item = new GenshinItem(itemData);
+					items.add(item);
+				}
+				player.getInventory().addItems(items);
+				player.sendPacket(new PacketItemAddHintNotify(items, ActionReason.SubfieldDrop));
+			} else {
+				item = new GenshinItem(itemData, count);
+				player.getInventory().addItem(item);
+				player.sendPacket(new PacketItemAddHintNotify(item, ActionReason.SubfieldDrop));
+			}
+		}
+	}
+	
+	@Command(aliases = {"d"}, helpText = "/drop [item id] [count] - Drops {count} amount of {item id}")
+	public static class Drop extends PlayerCommand {
+		@Override
+		public void execute(GenshinPlayer player, String raw) {
+			String[] split = raw.split(" ");
+			int itemId = 0, count = 1;
+			
+			try {
+				itemId = Integer.parseInt(split[0]);
+			} catch (Exception e) {
+				itemId = 0;
+			}
+			
+			try {
+				count = Math.max(Math.min(Integer.parseInt(split[1]), Integer.MAX_VALUE), 1);
+			} catch (Exception e) {
+				count = 1;
+			}
+			
+			// Give
+			ItemData itemData = GenshinData.getItemDataMap().get(itemId);
+			
+			if (itemData == null) {
+				player.dropMessage("Error: Item data not found");
+				return;
+			}
+			
+			if (itemData.isEquip()) {
+				float range = (5f + (.1f * count));
+				for (int i = 0; i < count; i++) {
+					Position pos = player.getPos().clone().addX((float) (Math.random() * range) - (range / 2)).addY(3f).addZ((float) (Math.random() * range) - (range / 2));
+					EntityItem entity = new EntityItem(player.getWorld(), player, itemData, pos, 1);
+					player.getWorld().addEntity(entity);
+				}
+			} else {
+				EntityItem entity = new EntityItem(player.getWorld(), player, itemData, player.getPos().clone().addY(3f), count);
+				player.getWorld().addEntity(entity);
+			}
+		}
+	}
+	
+	@Command(helpText = "/spawn [monster id] [count] - Creates {count} amount of {item id}")
+	public static class Spawn extends PlayerCommand {
+		@Override
+		public void execute(GenshinPlayer player, String raw) {
+			String[] split = raw.split(" ");
+			int monsterId = 0, count = 1, level = 1;
+			
+			try {
+				monsterId = Integer.parseInt(split[0]);
+			} catch (Exception e) {
+				monsterId = 0;
+			}
+			
+			try {
+				level = Math.max(Math.min(Integer.parseInt(split[1]), 200), 1);
+			} catch (Exception e) {
+				level = 1;
+			}
+			
+			try {
+				count = Math.max(Math.min(Integer.parseInt(split[2]), 1000), 1);
+			} catch (Exception e) {
+				count = 1;
+			}
+			
+			// Give
+			MonsterData monsterData = GenshinData.getMonsterDataMap().get(monsterId);
+			
+			if (monsterData == null) {
+				player.dropMessage("Error: Monster data not found");
+				return;
+			}
+			
+			float range = (5f + (.1f * count));
+			for (int i = 0; i < count; i++) {
+				Position pos = player.getPos().clone().addX((float) (Math.random() * range) - (range / 2)).addY(3f).addZ((float) (Math.random() * range) - (range / 2));
+				EntityMonster entity = new EntityMonster(player.getWorld(), monsterData, pos, level);
+				player.getWorld().addEntity(entity);
+			}
+		}
+	}
+	
+	@Command(helpText = "/killall")
+	public static class KillAll extends PlayerCommand {
+		@Override
+		public void execute(GenshinPlayer player, String raw) {
+			List<GenshinEntity> toRemove = new LinkedList<>();
+			for (GenshinEntity entity : player.getWorld().getEntities().values()) {
+				if (entity instanceof EntityMonster) {
+					toRemove.add(entity);
+				}
+			}
+			toRemove.forEach(e -> player.getWorld().killEntity(e, 0));
+		}
+	}
+	
+	@Command(helpText = "/resetconst - Resets all constellations for the currently active character")
+	public static class ResetConst extends PlayerCommand {
+		@Override
+		public void execute(GenshinPlayer player, String raw) {
+			EntityAvatar entity = player.getTeamManager().getCurrentAvatarEntity();
+			
+			if (entity == null) {
+				return;
+			}
+			
+			GenshinAvatar avatar = entity.getAvatar();
+			
+			avatar.getTalentIdList().clear();
+			avatar.setCoreProudSkillLevel(0);
+			avatar.recalcStats();
+			avatar.save();
+			
+			player.dropMessage("Constellations for " + entity.getAvatar().getAvatarData().getName() + " have been reset. Please relogin to see changes.");
+		}
+	}
+	
+	@Command(helpText = "/godmode - Prevents you from taking damage")
+	public static class Godmode extends PlayerCommand {
+		@Override
+		public void execute(GenshinPlayer player, String raw) {
+			player.setGodmode(!player.hasGodmode());
+			player.dropMessage("Godmode is now " + (player.hasGodmode() ? "ON" : "OFF"));
+		}
+	}
+	
+	@Command(helpText = "/sethp [hp]")
+	public static class Sethp extends PlayerCommand {
+		@Override
+		public void execute(GenshinPlayer player, String raw) {
+			String[] split = raw.split(" ");
+			int hp = 0;
+			
+			try {
+				hp = Math.max(Integer.parseInt(split[0]), 1);
+			} catch (Exception e) {
+				hp = 1;
+			}
+			
+			EntityAvatar entity = player.getTeamManager().getCurrentAvatarEntity();
+			
+			if (entity == null) {
+				return;
+			}
+			
+			entity.setFightProperty(FightProperty.FIGHT_PROP_CUR_HP, hp);
+			entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_CUR_HP));
+		}
+	}
+	
+	@Command(aliases = {"clearart"}, helpText = "/clearartifacts")
+	public static class ClearArtifacts extends PlayerCommand {
+		@Override
+		public void execute(GenshinPlayer player, String raw) {
+			List<GenshinItem> toRemove = new LinkedList<>();
+			for (GenshinItem item : player.getInventory().getItems().values()) {
+				if (item.getItemType() == ItemType.ITEM_RELIQUARY && item.getLevel() == 1 && item.getExp() == 0 && !item.isLocked() && !item.isEquipped()) {
+					toRemove.add(item);
+				}
+			}
+			
+			player.getInventory().removeItems(toRemove);
+		}
+	}
+}

src/deprecated/java/emu/grasscutter/commands/ServerCommands.java

@@ -0,0 +1,171 @@
+package emu.grasscutter.commands;
+
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.data.GenshinData;
+import emu.grasscutter.data.def.ItemData;
+import emu.grasscutter.database.DatabaseHelper;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.inventory.GenshinItem;
+import emu.grasscutter.utils.Crypto;
+import emu.grasscutter.utils.Utils;
+
+public class ServerCommands {
+	private static HashMap<String, ServerCommand> list = new HashMap<>();
+	
+	static {
+		try {
+			// Look for classes
+			for (Class<?> cls : ServerCommands.class.getDeclaredClasses()) {
+				// Get non abstract classes
+			    if (!Modifier.isAbstract(cls.getModifiers())) {
+			    	String commandName = cls.getSimpleName().toLowerCase();
+			    	list.put(commandName, (ServerCommand) cls.newInstance());
+			    }
+		
+			}
+		} catch (Exception e) {
+			
+		}
+	}
+
+	public static void handle(String msg) {
+		String[] split = msg.split(" ");
+		
+		// End if invalid
+		if (split.length == 0) {
+			return;
+		}
+		
+		//
+		String first = split[0].toLowerCase();
+		ServerCommand c = ServerCommands.list.get(first);
+		
+		if (c != null) {
+			// Execute
+			int len = Math.min(first.length() + 1, msg.length());
+			c.execute(msg.substring(len));
+		}
+	}
+	
+	public static abstract class ServerCommand {
+		public abstract void execute(String raw);
+	}
+	
+	// ================ Commands ================
+
+	public static class Reload extends ServerCommand {
+		@Override
+		public void execute(String raw) {
+			Grasscutter.getLogger().info("Reloading config.");
+			Grasscutter.loadConfig();
+			Grasscutter.getDispatchServer().loadQueries();
+			Grasscutter.getLogger().info("Reload complete.");
+		}
+	}
+
+	public static class sendMsg extends ServerCommand {
+		@Override
+		public void execute(String raw) {
+			List<String> split = Arrays.asList(raw.split(" "));
+
+			if (split.size() < 2) {
+				Grasscutter.getLogger().error("Invalid amount of args");
+				return;
+			}
+
+			String playerID = split.get(0);
+			String message = split.stream().skip(1).collect(Collectors.joining(" "));
+
+
+			emu.grasscutter.game.Account account = DatabaseHelper.getAccountByPlayerId(Integer.parseInt(playerID));
+			if (account != null) {
+				GenshinPlayer player = Grasscutter.getGameServer().getPlayerById(Integer.parseInt(playerID));
+				if(player != null) {
+					player.dropMessage(message);
+					Grasscutter.getLogger().info(String.format("Successfully sent message to %s: %s", playerID, message));
+				} else {
+					Grasscutter.getLogger().error("Player not online");
+				}
+			} else {
+				Grasscutter.getLogger().error(String.format("Player %s does not exist", playerID));
+			}
+		}
+	}
+	
+	public static class Account extends ServerCommand {
+		@Override
+		public void execute(String raw) {
+			String[] split = raw.split(" ");
+			
+			if (split.length < 2) {
+				Grasscutter.getLogger().error("Invalid amount of args");
+				return;
+			}		
+			
+			String command = split[0].toLowerCase();
+			String username = split[1];
+
+			switch (command) {
+				case "create":
+					if (split.length < 2) {
+						Grasscutter.getLogger().error("Invalid amount of args");
+						return;
+					}		
+					
+					int reservedId = 0;		
+					try {
+						reservedId = Integer.parseInt(split[2]);
+					} catch (Exception e) {
+						reservedId = 0;
+					}
+					
+					emu.grasscutter.game.Account account = DatabaseHelper.createAccountWithId(username, reservedId);
+					if (account != null) {
+						Grasscutter.getLogger().info("Account created" + (reservedId > 0 ? " with an id of " + reservedId : ""));
+					} else {
+						Grasscutter.getLogger().error("Account already exists");
+					}
+					break;
+				case "delete":
+					boolean success = DatabaseHelper.deleteAccount(username);
+					
+					if (success) {
+						Grasscutter.getLogger().info("Account deleted");
+					}
+					break;
+				/*
+				case "setpw":
+				case "setpass":
+				case "setpassword":
+					if (split.length < 3) {
+						Grasscutter.getLogger().error("Invalid amount of args");
+						return;
+					}		
+					
+					account = DatabaseHelper.getAccountByName(username);
+					
+					if (account == null) {
+						Grasscutter.getLogger().error("No account found!");
+						return;
+					}
+					
+					token = split[2];
+					token = PasswordHelper.hashPassword(token);
+					
+					account.setPassword(token);
+					DatabaseHelper.saveAccount(account);
+					
+					Grasscutter.getLogger().info("Password set");
+					break;
+				*/
+			}
+		}
+	}
+}

src/main/java/emu/grasscutter/Grasscutter.java

@@ -7,14 +7,15 @@ import java.io.FileWriter;
 import java.io.InputStreamReader;
 import java.net.InetSocketAddress;
 
+import emu.grasscutter.commands.CommandMap;
 import emu.grasscutter.utils.Utils;
+import org.reflections.Reflections;
 import org.slf4j.LoggerFactory;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 
 import ch.qos.logback.classic.Logger;
-import emu.grasscutter.commands.ServerCommands;
 import emu.grasscutter.data.ResourceLoader;
 import emu.grasscutter.database.DatabaseManager;
 import emu.grasscutter.server.dispatch.DispatchServer;
@@ -23,10 +24,6 @@ import emu.grasscutter.tools.Tools;
 import emu.grasscutter.utils.Crypto;
 
 public final class Grasscutter {
-	static { 
-		System.setProperty("logback.configurationFile", "src/main/resources/logback.xml");
-	}
-	
 	private static final Logger log = (Logger) LoggerFactory.getLogger(Grasscutter.class);
 	private static Config config;
 	
@@ -37,8 +34,13 @@ public final class Grasscutter {
 	private static DispatchServer dispatchServer;
 	private static GameServer gameServer;
 	
+	public static final Reflections reflector = new Reflections();
+	
 	static {
-		// Load configuration.
+		// Declare logback configuration.
+		System.setProperty("logback.configurationFile", "src/main/resources/logback.xml");
+		
+		// Load server configuration.
 		Grasscutter.loadConfig();
 		// Check server structure.
 		Utils.startupCheck();
@@ -100,7 +102,11 @@ public final class Grasscutter {
 		String input;
 		try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
 			while ((input = br.readLine()) != null) {
-				ServerCommands.handle(input);
+				try {
+					CommandMap.getInstance().invoke(null, input);
+				} catch (Exception e) {
+					Grasscutter.getLogger().error("Command error: " + e.getMessage());
+				}
 			}
 		} catch (Exception e) {
 			Grasscutter.getLogger().error("An error occurred.", e);

src/main/java/emu/grasscutter/commands/Command.java

@@ -5,9 +5,19 @@ import java.lang.annotation.RetentionPolicy;
 
 @Retention(RetentionPolicy.RUNTIME) 
 public @interface Command {
-	String[] aliases() default "";
+	String label() default "";
+
+	String usage() default "";
 	
-	int gmLevel() default 1;
+	String[] aliases() default {""};
 	
-	String helpText() default "";
+	Execution execution() default Execution.ALL;
+	
+	String permission() default "";
+	
+	enum Execution {
+		ALL,
+		CONSOLE,
+		PLAYER
+	}
 }

src/main/java/emu/grasscutter/commands/CommandHandler.java

@@ -0,0 +1,28 @@
+package emu.grasscutter.commands;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.List;
+
+public interface CommandHandler {
+    /* Invoked on player execution. */
+    default void execute(GenshinPlayer player, List<String> args) { }
+    /* Invoked on server execution. */
+    default void execute(List<String> args) { }
+    
+    /*
+     * Utilities.
+     */
+
+    /**
+     * Send a message to the target.
+     * @param player The player to send the message to, or null for the server console.
+     * @param message The message to send.
+     */
+    static void sendMessage(GenshinPlayer player, String message) {
+        if(player == null) {
+            Grasscutter.getLogger().info(message);
+        } else player.dropMessage(message);
+    }
+}

src/main/java/emu/grasscutter/commands/CommandMap.java

@@ -0,0 +1,159 @@
+package emu.grasscutter.commands;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.game.Account;
+import emu.grasscutter.game.GenshinPlayer;
+import org.reflections.Reflections;
+
+import java.util.*;
+
+@SuppressWarnings("UnusedReturnValue")
+public final class CommandMap {
+    public static CommandMap getInstance() {
+        return Grasscutter.getGameServer().getCommandMap();
+    }
+    
+    private final Map<String, CommandHandler> commands = new HashMap<>();
+    private final Map<String, Command> annotations = new HashMap<>();
+
+    /**
+     * Register a command handler.
+     * @param label The command label.
+     * @param command The command handler.
+     * @return Instance chaining.
+     */
+    public CommandMap registerCommand(String label, CommandHandler command) {
+        Grasscutter.getLogger().debug("Registered command: " + label);
+        
+        // Get command data.
+        Command annotation = command.getClass().getAnnotation(Command.class);
+        this.annotations.put(label, annotation);
+        this.commands.put(label, command);
+        
+        // Register aliases.
+        if(annotation.aliases().length > 0) {
+            for (String alias : annotation.aliases()) {
+                this.commands.put(alias, command);
+                this.annotations.put(alias, annotation);
+            }
+        } return this;
+    }
+
+    /**
+     * Removes a registered command handler.
+     * @param label The command label.
+     * @return Instance chaining.
+     */
+    public CommandMap unregisterCommand(String label) {
+        Grasscutter.getLogger().debug("Unregistered command: " + label);
+        CommandHandler handler = this.commands.get(label);
+        if(handler == null) return this;
+        
+        Command annotation = handler.getClass().getAnnotation(Command.class);
+        this.annotations.remove(label);
+        this.commands.remove(label);
+        
+        // Unregister aliases.
+        if(annotation.aliases().length > 0) {
+            for (String alias : annotation.aliases()) {
+                this.commands.remove(alias);
+                this.annotations.remove(alias);
+            }
+        }
+        
+        return this;
+    }
+
+    /**
+     * Returns a list of all registered commands.
+     * @return All command handlers as a list.
+     */
+    public List<CommandHandler> getHandlers() {
+        return new LinkedList<>(this.commands.values());
+    }
+
+    /**
+     * Returns a handler by label/alias.
+     * @param label The command label.
+     * @return The command handler.
+     */
+    public CommandHandler getHandler(String label) {
+        return this.commands.get(label);
+    }
+
+    /**
+     * Invoke a command handler with the given arguments.
+     * @param player The player invoking the command or null for the server console.
+     * @param rawMessage The messaged used to invoke the command.
+     */
+    public void invoke(GenshinPlayer player, String rawMessage) {
+        rawMessage = rawMessage.trim();
+        if(rawMessage.length() == 0) {
+            CommandHandler.sendMessage(player, "No command specified.");
+        }
+        
+        // Remove prefix if present.
+        if(!Character.isLetter(rawMessage.charAt(0)))
+            rawMessage = rawMessage.substring(1);
+        
+        // Parse message.
+        String[] split = rawMessage.split(" ");
+        List<String> args = new LinkedList<>(Arrays.asList(split));
+        String label = args.remove(0);
+        
+        // Get command handler.
+        CommandHandler handler = this.commands.get(label);
+        if(handler == null) {
+            CommandHandler.sendMessage(player, "Unknown command: " + label); return;
+        }
+        
+        // Check for permission.
+        if(player != null) {
+            String permissionNode = this.annotations.get(label).permission();
+            Account account = player.getAccount();
+            List<String> permissions = account.getPermissions();
+            if(!permissions.contains("*") && !permissions.contains(permissionNode)) {
+                CommandHandler.sendMessage(player, "You do not have permission to run this command."); return;
+            }
+        }
+        
+        // Execution power check.
+        Command.Execution executionPower = this.annotations.get(label).execution();
+        if(player == null && executionPower == Command.Execution.PLAYER) {
+            CommandHandler.sendMessage(null, "Run this command in-game."); return;
+        } else if (player != null && executionPower == Command.Execution.CONSOLE) {
+            CommandHandler.sendMessage(player, "This command can only be run from the console."); return;
+        }
+        
+        // Invoke execute method for handler.
+        if(player == null) handler.execute(args); 
+        else handler.execute(player, args);
+    }
+    
+    public CommandMap() {
+        this(false);
+    }
+    
+    public CommandMap(boolean scan) {
+        if(scan) this.scan();
+    }
+
+    /**
+     * Scans for all classes annotated with {@link Command} and registers them.
+     */
+    private void scan() {
+        Reflections reflector = Grasscutter.reflector;
+        Set<Class<?>> classes = reflector.getTypesAnnotatedWith(Command.class);
+        classes.forEach(annotated -> {
+            try {
+                Command cmdData = annotated.getAnnotation(Command.class);
+                Object object = annotated.newInstance();
+                if (object instanceof CommandHandler)
+                    this.registerCommand(cmdData.label(), (CommandHandler) object);
+                else Grasscutter.getLogger().error("Class " + annotated.getName() + " is not a CommandHandler!");
+            } catch (Exception exception) {
+                Grasscutter.getLogger().error("Failed to register command handler for " + annotated.getSimpleName(), exception);
+            }
+        });
+    }
+}

src/main/java/emu/grasscutter/commands/PlayerCommands.java

@@ -1,21 +1,18 @@
 package emu.grasscutter.commands;
 
-import java.lang.reflect.Modifier;
+import emu.grasscutter.Grasscutter;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
 import emu.grasscutter.data.GenshinData;
 import emu.grasscutter.data.def.ItemData;
 import emu.grasscutter.data.def.MonsterData;
 import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.GenshinScene;
+import emu.grasscutter.game.World;
 import emu.grasscutter.game.avatar.GenshinAvatar;
 import emu.grasscutter.game.entity.EntityAvatar;
 import emu.grasscutter.game.entity.EntityItem;
 import emu.grasscutter.game.entity.EntityMonster;
-import emu.grasscutter.game.entity.GenshinEntity;
 import emu.grasscutter.game.inventory.GenshinItem;
+import emu.grasscutter.game.inventory.Inventory;
 import emu.grasscutter.game.inventory.ItemType;
 import emu.grasscutter.game.props.ActionReason;
 import emu.grasscutter.game.props.FightProperty;
@@ -23,326 +20,342 @@ import emu.grasscutter.server.packet.send.PacketEntityFightPropUpdateNotify;
 import emu.grasscutter.server.packet.send.PacketItemAddHintNotify;
 import emu.grasscutter.utils.Position;
 
-public class PlayerCommands {
+import java.util.LinkedList;
-	private static HashMap<String, PlayerCommand> commandList = new HashMap<String, PlayerCommand>();
+import java.util.List;
-	private static HashMap<String, PlayerCommand> commandAliasList = new HashMap<String, PlayerCommand>();
 
-	
+/**
-	static {
+ * A container for player-related commands.
-		try {
+ */
-			// Look for classes
+public final class PlayerCommands {
-			for (Class<?> cls : PlayerCommands.class.getDeclaredClasses()) {
+    @Command(label = "give", aliases = {"g", "item", "giveitem"}, 
-				// Get non abstract classes
+            usage = "Usage: give [player] <itemId|itemName> [amount]")
-			    if (!Modifier.isAbstract(cls.getModifiers())) {
+    public static class GiveCommand implements CommandHandler {
-			    	Command commandAnnotation = cls.getAnnotation(Command.class);
-			    	PlayerCommand command = (PlayerCommand) cls.newInstance();
-			    	
-			    	if (commandAnnotation != null) {
-			    		command.setLevel(commandAnnotation.gmLevel());
-						command.setHelpText(commandAnnotation.helpText());
-						for (String alias : commandAnnotation.aliases()) {
-			    			if (alias.length() == 0) {
-			    				continue;
-			    			}
 
-							String commandName = alias;
+        @Override
-							commandAliasList.put(commandName, command);
+        public void execute(GenshinPlayer player, List<String> args) {
-			    		}
+            int target, item, amount = 1;
-			    	}
 
-			    	String commandName = cls.getSimpleName().toLowerCase();
+            switch(args.size()) {
-			    	commandList.put(commandName, command);
+                default:
-			    }
+                    CommandHandler.sendMessage(player, "Usage: give <player> <itemId|itemName> [amount]");
-		
+                    return;
-			}
+                case 1:
-		} catch (Exception e) {
+                    try {
-			
+                        item = Integer.parseInt(args.get(0));
-		}
+                        target = player.getAccount().getPlayerId();
-	}
+                    } catch (NumberFormatException ignored) {
+                        // TODO: Parse from item name using GM Handbook.
+                        CommandHandler.sendMessage(player, "Invalid item id.");
+                        return;
+                    }
+                    break;
+                case 2:
+                    try {
+                        target = Integer.parseInt(args.get(0));
+                        if(Grasscutter.getGameServer().getPlayerById(target) == null) {
+                            target = player.getId(); amount = Integer.parseInt(args.get(1));
+                            item = Integer.parseInt(args.get(0));
+                        } else {
+                            item = Integer.parseInt(args.get(1));
+                        }
+                    } catch (NumberFormatException ignored) {
+                        // TODO: Parse from item name using GM Handbook.
+                        CommandHandler.sendMessage(player, "Invalid item or player ID.");
+                        return;
+                    }
+                    break;
+                case 3:
+                    try {
+                        target = Integer.parseInt(args.get(0));
+                        if(Grasscutter.getGameServer().getPlayerById(target) == null) {
+                            CommandHandler.sendMessage(player, "Invalid player ID."); return;
+                        }
 
-	public static void handle(GenshinPlayer player, String msg) {
+                        item = Integer.parseInt(args.get(1));
-		String[] split = msg.split(" ");
+                        amount = Integer.parseInt(args.get(2));
-		
+                    } catch (NumberFormatException ignored) {
-		// End if invalid
+                        // TODO: Parse from item name using GM Handbook.
-		if (split.length == 0) {
+                        CommandHandler.sendMessage(player, "Invalid item or player ID.");
-			return;
+                        return;
-		}
+                    }
+                    break;
+            }
 
-		String first = split[0].toLowerCase().substring(1);
+            GenshinPlayer targetPlayer = Grasscutter.getGameServer().getPlayerById(target);
-		PlayerCommand c = PlayerCommands.commandList.get(first);
+            if(targetPlayer == null) {
-		PlayerCommand a = PlayerCommands.commandAliasList.get(first);
+                CommandHandler.sendMessage(player, "Player not found."); return;
-		
+            }
-		if (c != null || a != null) {
-			PlayerCommand cmd = c != null ? c : a;
-			// Level check
-			if (player.getGmLevel() < cmd.getLevel()) {
-				return;
-			}
-			// Execute
-			int len = Math.min(split[0].length() + 1, msg.length());
-			cmd.execute(player, msg.substring(len));
-		}
-	}
-	
-	public static abstract class PlayerCommand {
-		// GM level required to use this command
-		private int level;
-		private String helpText;
 
-		protected int getLevel() { return this.level; }
+            ItemData itemData = GenshinData.getItemDataMap().get(item);
-		protected void setLevel(int minLevel) { this.level = minLevel; }
+            if(itemData == null) {
+                CommandHandler.sendMessage(player, "Invalid item id."); return;
+            }
+            
+            this.item(targetPlayer, itemData, amount);
+        }
 
-		protected String getHelpText() { return this.helpText; }
+        /**
-		protected void setHelpText(String helpText) { this.helpText = helpText; }
+         * give [player] [itemId|itemName] [amount]
+         */
+        @Override public void execute(List<String> args) {
+            if(args.size() < 2) {
+                CommandHandler.sendMessage(null, "Usage: give <player> <itemId|itemName> [amount]");
+                return;
+            }
 
-		// Main
+            try {
-		public abstract void execute(GenshinPlayer player, String raw);
+                int target = Integer.parseInt(args.get(0));
-	}
+                int item = Integer.parseInt(args.get(1));
-	
+                int amount = 1; if(args.size() > 2) amount = Integer.parseInt(args.get(2));
-	// ================ Commands ================
+                
+                GenshinPlayer targetPlayer = Grasscutter.getGameServer().getPlayerById(target);
+                if(targetPlayer == null) {
+                    CommandHandler.sendMessage(null, "Player not found."); return;
+                }
+                
+                ItemData itemData = GenshinData.getItemDataMap().get(item);
+                if(itemData == null) {
+                    CommandHandler.sendMessage(null, "Invalid item id."); return;
+                }
+                
+                this.item(targetPlayer, itemData, amount);
+            } catch (NumberFormatException ignored) {
+                CommandHandler.sendMessage(null, "Invalid item or player ID.");
+            }
+        }
+        
+        private void item(GenshinPlayer player, ItemData itemData, int amount) {
+            GenshinItem genshinItem = new GenshinItem(itemData);
+            if(itemData.isEquip()) {
+                List<GenshinItem> items = new LinkedList<>();
+                for(int i = 0; i < amount; i++) {
+                    items.add(genshinItem);
+                } player.getInventory().addItems(items);
+                player.sendPacket(new PacketItemAddHintNotify(items, ActionReason.SubfieldDrop));
+            } else {
+                genshinItem.setCount(amount);
+                player.getInventory().addItem(genshinItem);
+                player.sendPacket(new PacketItemAddHintNotify(genshinItem, ActionReason.SubfieldDrop));
+            }
+        }
+    }
+    
+    @Command(label = "drop", aliases = {"d", "dropitem"}, 
+            usage = "Usage: drop <itemId|itemName> [amount]", 
+            execution = Command.Execution.PLAYER)
+    public static class DropCommand implements CommandHandler {
 
-	@Command(aliases = {"h"}, helpText = "Shows this command")
+        @Override
-	public static class Help extends PlayerCommand {
+        public void execute(GenshinPlayer player, List<String> args) {
+            if(args.size() < 1) {
+                CommandHandler.sendMessage(player, "Usage: drop <itemId|itemName> [amount]");
+                return;
+            }
 
-		@Override
+            try {
-		public void execute(GenshinPlayer player, String raw) {
+                int item = Integer.parseInt(args.get(0));
-			String helpMessage = "Grasscutter Commands: ";
+                int amount = 1; if(args.size() > 1) amount = Integer.parseInt(args.get(1));
-			for (Map.Entry<String, PlayerCommand> cmd : commandList.entrySet()) {
 
-				helpMessage += "\n" + cmd.getKey() + " - " + cmd.getValue().helpText;
+                ItemData itemData = GenshinData.getItemDataMap().get(item);
-			}
+                if(itemData == null) {
+                    CommandHandler.sendMessage(player, "Invalid item id."); return;
+                }
+                if (itemData.isEquip()) {
+                    float range = (5f + (.1f * amount));
+                    for (int i = 0; i < amount; i++) {
+                        Position pos = player.getPos().clone().addX((float) (Math.random() * range) - (range / 2)).addY(3f).addZ((float) (Math.random() * range) - (range / 2));
+                        EntityItem entity = new EntityItem(player.getScene(), player, itemData, pos, 1);
+                        player.getScene().addEntity(entity);
+                    }
+                } else {
+                    EntityItem entity = new EntityItem(player.getScene(), player, itemData, player.getPos().clone().addY(3f), amount);
+                    player.getScene().addEntity(entity);
+                }
+            } catch (NumberFormatException ignored) {
+                CommandHandler.sendMessage(player, "Invalid item or player ID.");
+            }
+        }
+    }
+    
+    @Command(label = "spawn", execution = Command.Execution.PLAYER, 
+            usage = "Usage: spawn <entityId|entityName> [level] [amount]")
+    public static class SpawnCommand implements CommandHandler {
+        
+        @Override
+        public void execute(GenshinPlayer player, List<String> args) {
+            if(args.size() < 1) {
+                CommandHandler.sendMessage(null, "Usage: spawn <entityId|entityName> [amount]");
+                return;
+            }
+            
+            try {
+                int entity = Integer.parseInt(args.get(0));
+                int level = 1; if(args.size() > 1) level = Integer.parseInt(args.get(1));
+                int amount = 1; if(args.size() > 2) amount = Integer.parseInt(args.get(2));
 
-			player.dropMessage(helpMessage);
+                MonsterData entityData = GenshinData.getMonsterDataMap().get(entity);
-		}
+                if(entityData == null) {
-	}
+                    CommandHandler.sendMessage(null, "Invalid entity id."); return;
-	
+                }
-	@Command(aliases = {"g", "item", "additem"}, helpText = "/give [item id] [count] - Gives {count} amount of {item id}")
+
-	public static class Give extends PlayerCommand {
+                float range = (5f + (.1f * amount));
-		@Override
+                for (int i = 0; i < amount; i++) {
-		public void execute(GenshinPlayer player, String raw) {
+                    Position pos = player.getPos().clone().addX((float) (Math.random() * range) - (range / 2)).addY(3f).addZ((float) (Math.random() * range) - (range / 2));
-			String[] split = raw.split(" ");
+                    EntityMonster monster = new EntityMonster(player.getScene(), entityData, pos, level);
-			int itemId = 0, count = 1;
+                    player.getScene().addEntity(monster);
-			
+                }
-			try {
+            } catch (NumberFormatException ignored) {
-				itemId = Integer.parseInt(split[0]);
+                CommandHandler.sendMessage(null, "Invalid item or player ID.");
-			} catch (Exception e) {
+            }
-				itemId = 0;
+        }
-			}
+    }
-			
+    
-			try {
+    @Command(label = "killall", 
-				count = Math.max(Math.min(Integer.parseInt(split[1]), Integer.MAX_VALUE), 1);
+            usage = "Usage: killall [playerUid] [sceneId]")
-			} catch (Exception e) {
+    public static class KillAllCommand implements CommandHandler {
-				count = 1;
+
-			}
+        @Override
-			
+        public void execute(GenshinPlayer player, List<String> args) {
-			// Give
+            GenshinScene scene = player.getScene();
-			ItemData itemData = GenshinData.getItemDataMap().get(itemId);
+            scene.getEntities().values().stream()
-			GenshinItem item;
+                    .filter(entity -> entity instanceof EntityMonster)
-			
+                    .forEach(entity -> scene.killEntity(entity, 0));
-			if (itemData == null) {
+            CommandHandler.sendMessage(null, "Killing all monsters in scene " + scene.getId());
-				player.dropMessage("Error: Item data not found");
+        }
-				return;
+        
-			}
+        @Override
-			
+        public void execute(List<String> args) {
-			if (itemData.isEquip()) {
+            if(args.size() < 2) {
-				List<GenshinItem> items = new LinkedList<>();
+                CommandHandler.sendMessage(null, "Usage: killall [playerUid] [sceneId]"); return;
-				for (int i = 0; i < count; i++) {
+            }
-					item = new GenshinItem(itemData);
+
-					items.add(item);
+            try {
-				}
+            	int playerUid = Integer.parseInt(args.get(0));
-				player.getInventory().addItems(items);
+                int sceneId = Integer.parseInt(args.get(1));
-				player.sendPacket(new PacketItemAddHintNotify(items, ActionReason.SubfieldDrop));
+                
-			} else {
+                GenshinPlayer player = Grasscutter.getGameServer().getPlayerById(playerUid);
-				item = new GenshinItem(itemData, count);
+                if (player == null) {
-				player.getInventory().addItem(item);
+                	CommandHandler.sendMessage(null, "Player not found or offline.");
-				player.sendPacket(new PacketItemAddHintNotify(item, ActionReason.SubfieldDrop));
+                	return;
-			}
+                }
-		}
+                
-	}
+                GenshinScene scene = player.getWorld().getSceneById(sceneId);
-	
+                if (scene == null) {
-	@Command(aliases = {"d"}, helpText = "/drop [item id] [count] - Drops {count} amount of {item id}")
+                	CommandHandler.sendMessage(null, "Scene not found in player world");
-	public static class Drop extends PlayerCommand {
+                	return;
-		@Override
+                }
-		public void execute(GenshinPlayer player, String raw) {
+                
-			String[] split = raw.split(" ");
+                scene.getEntities().values().stream()
-			int itemId = 0, count = 1;
+                        .filter(entity -> entity instanceof EntityMonster)
-			
+                        .forEach(entity -> scene.killEntity(entity, 0));
-			try {
+                CommandHandler.sendMessage(null, "Killing all monsters in scene " + scene.getId());
-				itemId = Integer.parseInt(split[0]);
+            } catch (NumberFormatException ignored) {
-			} catch (Exception e) {
+                CommandHandler.sendMessage(null, "Invalid arguments.");
-				itemId = 0;
+            }
-			}
+        }
-			
+    }
-			try {
+    
-				count = Math.max(Math.min(Integer.parseInt(split[1]), Integer.MAX_VALUE), 1);
+    @Command(label = "resetconst", aliases = {"resetconstellation"}, 
-			} catch (Exception e) {
+            usage = "Usage: resetconst [all]", execution = Command.Execution.PLAYER)
-				count = 1;
+    public static class ResetConstellationCommand implements CommandHandler {
-			}
+        
-			
+        @Override
-			// Give
+        public void execute(GenshinPlayer player, List<String> args) {
-			ItemData itemData = GenshinData.getItemDataMap().get(itemId);
+            if(args.size() > 0 && args.get(0).equalsIgnoreCase("all")) {
-			
+                player.getAvatars().forEach(this::resetConstellation);
-			if (itemData == null) {
+                player.dropMessage("Reset all avatars' constellations.");
-				player.dropMessage("Error: Item data not found");
+            } else {
-				return;
+                EntityAvatar entity = player.getTeamManager().getCurrentAvatarEntity(); 
-			}
+                if(entity == null)
-			
+                    return;
-			if (itemData.isEquip()) {
+                
-				float range = (5f + (.1f * count));
+                GenshinAvatar avatar = entity.getAvatar();
-				for (int i = 0; i < count; i++) {
+                this.resetConstellation(avatar);
-					Position pos = player.getPos().clone().addX((float) (Math.random() * range) - (range / 2)).addY(3f).addZ((float) (Math.random() * range) - (range / 2));
+
-					EntityItem entity = new EntityItem(player.getScene(), player, itemData, pos, 1);
+                player.dropMessage("Constellations for " + avatar.getAvatarData().getName() + " have been reset. Please relog to see changes.");
-					player.getScene().addEntity(entity);
+            }
-				}
+        }
-			} else {
+        
-				EntityItem entity = new EntityItem(player.getScene(), player, itemData, player.getPos().clone().addY(3f), count);
+        private void resetConstellation(GenshinAvatar avatar) {
-				player.getScene().addEntity(entity);
+            avatar.getTalentIdList().clear();
-			}
+            avatar.setCoreProudSkillLevel(0);
-		}
+            avatar.recalcStats();
-	}
+            avatar.save();
-	
+        }
-	@Command(helpText = "/spawn [monster id] [count] - Creates {count} amount of {item id}")
+    }
-	public static class Spawn extends PlayerCommand {
+    
-		@Override
+    @Command(label = "godmode",
-		public void execute(GenshinPlayer player, String raw) {
+            usage = "Usage: godmode", execution = Command.Execution.PLAYER)
-			String[] split = raw.split(" ");
+    public static class GodModeCommand implements CommandHandler {
-			int monsterId = 0, count = 1, level = 1;
+        
-			
+        @Override
-			try {
+        public void execute(GenshinPlayer player, List<String> args) {
-				monsterId = Integer.parseInt(split[0]);
+            player.setGodmode(!player.inGodmode());
-			} catch (Exception e) {
+            player.dropMessage("Godmode is now " + (player.inGodmode() ? "enabled" : "disabled") + ".");
-				monsterId = 0;
+        }
-			}
+    }
-			
+    
-			try {
+    @Command(label = "sethealth", aliases = {"sethp"}, 
-				level = Math.max(Math.min(Integer.parseInt(split[1]), 200), 1);
+            usage = "Usage: sethealth <hp>", execution = Command.Execution.PLAYER)
-			} catch (Exception e) {
+    public static class SetHealthCommand implements CommandHandler {
-				level = 1;
+
-			}
+        @Override
-			
+        public void execute(GenshinPlayer player, List<String> args) {
-			try {
+            if(args.size() < 1) {
-				count = Math.max(Math.min(Integer.parseInt(split[2]), 1000), 1);
+                CommandHandler.sendMessage(null, "Usage: sethealth <hp>"); return;
-			} catch (Exception e) {
+            }
-				count = 1;
+            
-			}
+            try {
-			
+                int health = Integer.parseInt(args.get(0));
-			// Give
+                EntityAvatar entity = player.getTeamManager().getCurrentAvatarEntity();
-			MonsterData monsterData = GenshinData.getMonsterDataMap().get(monsterId);
+                if(entity == null)
-			
+                    return;
-			if (monsterData == null) {
+                
-				player.dropMessage("Error: Monster data not found");
+                entity.setFightProperty(FightProperty.FIGHT_PROP_CUR_HP, health);
-				return;
+                entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_CUR_HP));
-			}
+                player.dropMessage("Health set to " + health + ".");
-			
+            } catch (NumberFormatException ignored) {
-			float range = (5f + (.1f * count));
+                CommandHandler.sendMessage(null, "Invalid health value.");
-			for (int i = 0; i < count; i++) {
+            }
-				Position pos = player.getPos().clone().addX((float) (Math.random() * range) - (range / 2)).addY(3f).addZ((float) (Math.random() * range) - (range / 2));
+        }
-				EntityMonster entity = new EntityMonster(player.getScene(), monsterData, pos, level);
+    }
-				player.getScene().addEntity(entity);
+    
-			}
+    @Command(label = "clearartifacts", aliases = {"clearart"}, 
-		}
+            usage = "Usage: clearartifacts", execution = Command.Execution.PLAYER)
-	}
+    public static class ClearArtifactsCommand implements CommandHandler {
-	
+        @Override
-	@Command(helpText = "/killall")
+        public void execute(GenshinPlayer player, List<String> args) {
-	public static class KillAll extends PlayerCommand {
+            Inventory playerInventory = player.getInventory();
-		@Override
+            playerInventory.getItems().values().stream()
-		public void execute(GenshinPlayer player, String raw) {
+                    .filter(item -> item.getItemType() == ItemType.ITEM_RELIQUARY)
-			List<GenshinEntity> toRemove = new LinkedList<>();
+                    .filter(item -> item.getLevel() == 1 && item.getExp() == 0)
-			for (GenshinEntity entity : player.getScene().getEntities().values()) {
+                    .filter(item -> !item.isLocked() && !item.isEquipped())
-				if (entity instanceof EntityMonster) {
+                    .forEach(item -> playerInventory.removeItem(item, item.getCount()));
-					toRemove.add(entity);
+        }
-				}
+    }
-			}
+
-			toRemove.forEach(e -> player.getScene().killEntity(e, 0));
+    @Command(label = "changescene", aliases = {"scene"}, 
-		}
+            usage = "Usage: changescene <scene id>", execution = Command.Execution.PLAYER)
-	}
+    public static class ChangeSceneCommand implements CommandHandler {
-	
+        @Override
-	@Command(helpText = "/resetconst - Resets all constellations for the currently active character")
+        public void execute(GenshinPlayer player, List<String> args) {
-	public static class ResetConst extends PlayerCommand {
+            if(args.size() < 1) {
-		@Override
+                CommandHandler.sendMessage(null, "Usage: changescene <scene id>"); return;
-		public void execute(GenshinPlayer player, String raw) {
+            }
-			EntityAvatar entity = player.getTeamManager().getCurrentAvatarEntity();
+
-			
+            int sceneId = 0;
-			if (entity == null) {
+        
-				return;
+            try {
-			}
+                sceneId = Integer.parseInt(args.get(0));
-			
+            } catch (Exception e) {
-			GenshinAvatar avatar = entity.getAvatar();
+                return;
-			
+            }
-			avatar.getTalentIdList().clear();
+            
-			avatar.setCoreProudSkillLevel(0);
+            boolean result = player.getWorld().transferPlayerToScene(player, sceneId, player.getPos());
-			avatar.recalcStats();
+            
-			avatar.save();
+            if (!result) {
-			
+                CommandHandler.sendMessage(null, "Scene does not exist or you are already in it");
-			player.dropMessage("Constellations for " + entity.getAvatar().getAvatarData().getName() + " have been reset. Please relogin to see changes.");
+            }
-		}
+        }
-	}
+    }
-	
-	@Command(helpText = "/godmode - Prevents you from taking damage")
-	public static class Godmode extends PlayerCommand {
-		@Override
-		public void execute(GenshinPlayer player, String raw) {
-			player.setGodmode(!player.hasGodmode());
-			player.dropMessage("Godmode is now " + (player.hasGodmode() ? "ON" : "OFF"));
-		}
-	}
-	
-	@Command(helpText = "/sethp [hp]")
-	public static class Sethp extends PlayerCommand {
-		@Override
-		public void execute(GenshinPlayer player, String raw) {
-			String[] split = raw.split(" ");
-			int hp = 0;
-			
-			try {
-				hp = Math.max(Integer.parseInt(split[0]), 1);
-			} catch (Exception e) {
-				hp = 1;
-			}
-			
-			EntityAvatar entity = player.getTeamManager().getCurrentAvatarEntity();
-			
-			if (entity == null) {
-				return;
-			}
-			
-			entity.setFightProperty(FightProperty.FIGHT_PROP_CUR_HP, hp);
-			entity.getScene().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_CUR_HP));
-		}
-	}
-	
-	@Command(aliases = {"clearart"}, helpText = "/clearartifacts")
-	public static class ClearArtifacts extends PlayerCommand {
-		@Override
-		public void execute(GenshinPlayer player, String raw) {
-			List<GenshinItem> toRemove = new LinkedList<>();
-			for (GenshinItem item : player.getInventory().getItems().values()) {
-				if (item.getItemType() == ItemType.ITEM_RELIQUARY && item.getLevel() == 1 && item.getExp() == 0 && !item.isLocked() && !item.isEquipped()) {
-					toRemove.add(item);
-				}
-			}
-			
-			player.getInventory().removeItems(toRemove);
-		}
-	}
-	
-	@Command(aliases = {"scene"}, helpText = "/Changescene [Scene id]")
-	public static class ChangeScene extends PlayerCommand {
-		@Override
-		public void execute(GenshinPlayer player, String raw) {
-			int sceneId = 0;
-		
-			try {
-				sceneId = Integer.parseInt(raw);
-			} catch (Exception e) {
-				return;
-			}
-			
-			boolean result = player.getWorld().transferPlayerToScene(player, sceneId, player.getPos());
-			
-			if (!result) {
-				player.dropMessage("Scene does not exist or you are already in it");
-			}
-		}
-	}
 }

src/main/java/emu/grasscutter/commands/ServerCommands.java

@@ -1,171 +1,212 @@
 package emu.grasscutter.commands;
 
-import java.lang.reflect.Modifier;
+import emu.grasscutter.Grasscutter;
-import java.util.Arrays;
+import emu.grasscutter.database.DatabaseHelper;
-import java.util.HashMap;
+import emu.grasscutter.game.Account;
-import java.util.LinkedList;
+import emu.grasscutter.game.GenshinPlayer;
+
 import java.util.List;
 import java.util.stream.Collectors;
 
-import emu.grasscutter.Grasscutter;
+/**
-import emu.grasscutter.data.GenshinData;
+ * A container for server-related commands.
-import emu.grasscutter.data.def.ItemData;
+ */
-import emu.grasscutter.database.DatabaseHelper;
+public final class ServerCommands {
-import emu.grasscutter.game.GenshinPlayer;
+    @Command(label = "reload", usage = "Usage: reload")
-import emu.grasscutter.game.inventory.GenshinItem;
+    public static class ReloadCommand implements CommandHandler {
-import emu.grasscutter.utils.Crypto;
-import emu.grasscutter.utils.Utils;
 
-public class ServerCommands {
+        @Override
-	private static HashMap<String, ServerCommand> list = new HashMap<>();
+        public void execute(List<String> args) {
-	
+            Grasscutter.getLogger().info("Reloading config.");
-	static {
+            Grasscutter.loadConfig();
-		try {
+            Grasscutter.getDispatchServer().loadQueries();
-			// Look for classes
+            Grasscutter.getLogger().info("Reload complete.");
-			for (Class<?> cls : ServerCommands.class.getDeclaredClasses()) {
+        }
-				// Get non abstract classes
-			    if (!Modifier.isAbstract(cls.getModifiers())) {
-			    	String commandName = cls.getSimpleName().toLowerCase();
-			    	list.put(commandName, (ServerCommand) cls.newInstance());
-			    }
-		
-			}
-		} catch (Exception e) {
-			
-		}
-	}
 
-	public static void handle(String msg) {
+        @Override
-		String[] split = msg.split(" ");
+        public void execute(GenshinPlayer player, List<String> args) {
-		
+            this.execute(args);
-		// End if invalid
+        }
-		if (split.length == 0) {
+    }
-			return;
+    
-		}
+    @Command(label = "sendmessage", aliases = {"sendmsg", "msg"}, 
-		
+            usage = "Usage: sendmessage <player> <message>")
-		//
+    public static class SendMessageCommand implements CommandHandler {
-		String first = split[0].toLowerCase();
-		ServerCommand c = ServerCommands.list.get(first);
-		
-		if (c != null) {
-			// Execute
-			int len = Math.min(first.length() + 1, msg.length());
-			c.execute(msg.substring(len));
-		}
-	}
-	
-	public static abstract class ServerCommand {
-		public abstract void execute(String raw);
-	}
-	
-	// ================ Commands ================
 
-	public static class Reload extends ServerCommand {
+        @Override
-		@Override
+        public void execute(List<String> args) {
-		public void execute(String raw) {
+            if(args.size() < 2) {
-			Grasscutter.getLogger().info("Reloading config.");
+                CommandHandler.sendMessage(null, "Usage: sendmessage <player> <message>"); return;
-			Grasscutter.loadConfig();
+            }
-			Grasscutter.getDispatchServer().loadQueries();
+            
-			Grasscutter.getLogger().info("Reload complete.");
+            try {
-		}
+                int target = Integer.parseInt(args.get(0));
-	}
+                String message = String.join(" ", args.subList(1, args.size()));
 
-	public static class sendMsg extends ServerCommand {
+                GenshinPlayer targetPlayer = Grasscutter.getGameServer().getPlayerById(target);
-		@Override
+                if(targetPlayer == null) {
-		public void execute(String raw) {
+                    CommandHandler.sendMessage(null, "Player not found."); return;
-			List<String> split = Arrays.asList(raw.split(" "));
+                }
+                
+                targetPlayer.dropMessage(message);
+                CommandHandler.sendMessage(null, "Message sent.");
+            } catch (NumberFormatException ignored) {
+                CommandHandler.sendMessage(null, "Invalid player ID.");
+            }
+        }
 
-			if (split.size() < 2) {
+        @Override
-				Grasscutter.getLogger().error("Invalid amount of args");
+        public void execute(GenshinPlayer player, List<String> args) {
-				return;
+            if(args.size() < 2) {
-			}
+                CommandHandler.sendMessage(player, "Usage: sendmessage <player> <message>"); return;
+            }
 
-			String playerID = split.get(0);
+            try {
-			String message = split.stream().skip(1).collect(Collectors.joining(" "));
+                int target = Integer.parseInt(args.get(0));
+                String message = String.join(" ", args.subList(1, args.size()));
 
+                GenshinPlayer targetPlayer = Grasscutter.getGameServer().getPlayerById(target);
+                if(targetPlayer == null) {
+                    CommandHandler.sendMessage(player, "Player not found."); return;
+                }
 
-			emu.grasscutter.game.Account account = DatabaseHelper.getAccountByPlayerId(Integer.parseInt(playerID));
+                targetPlayer.sendMessage(player, message);
-			if (account != null) {
+                CommandHandler.sendMessage(player, "Message sent.");
-				GenshinPlayer player = Grasscutter.getGameServer().getPlayerById(Integer.parseInt(playerID));
+            } catch (NumberFormatException ignored) {
-				if(player != null) {
+                CommandHandler.sendMessage(player, "Invalid player ID.");
-					player.dropMessage(message);
+            }
-					Grasscutter.getLogger().info(String.format("Successfully sent message to %s: %s", playerID, message));
+        }
-				} else {
+    }
-					Grasscutter.getLogger().error("Player not online");
+    
-				}
+    @Command(label = "account", 
-			} else {
+            usage = "Usage: account <create|delete> <username> [uid]", 
-				Grasscutter.getLogger().error(String.format("Player %s does not exist", playerID));
+            execution = Command.Execution.CONSOLE)
-			}
+    public static class AccountCommand implements CommandHandler {
-		}
-	}
-	
-	public static class Account extends ServerCommand {
-		@Override
-		public void execute(String raw) {
-			String[] split = raw.split(" ");
-			
-			if (split.length < 2) {
-				Grasscutter.getLogger().error("Invalid amount of args");
-				return;
-			}		
-			
-			String command = split[0].toLowerCase();
-			String username = split[1];
 
-			switch (command) {
+        @Override
-				case "create":
+        public void execute(List<String> args) {
-					if (split.length < 2) {
+            if(args.size() < 2) {
-						Grasscutter.getLogger().error("Invalid amount of args");
+                CommandHandler.sendMessage(null, "Usage: account <create|delete> <username> [uid]"); return;
-						return;
+            }
-					}		
+            
-					
+            String action = args.get(0);
-					int reservedId = 0;		
+            String username = args.get(1);
-					try {
+            
-						reservedId = Integer.parseInt(split[2]);
+            switch(action) {
-					} catch (Exception e) {
+                default:
-						reservedId = 0;
+                    CommandHandler.sendMessage(null, "Usage: account <create|delete> <username> [uid]");
-					}
+                    return;
-					
+                case "create":
-					emu.grasscutter.game.Account account = DatabaseHelper.createAccountWithId(username, reservedId);
+                    int uid = 0;
-					if (account != null) {
+                    if(args.size() > 2) {
-						Grasscutter.getLogger().info("Account created" + (reservedId > 0 ? " with an id of " + reservedId : ""));
+                        try {
-					} else {
+                            uid = Integer.parseInt(args.get(2));
-						Grasscutter.getLogger().error("Account already exists");
+                        } catch (NumberFormatException ignored) {
-					}
+                            CommandHandler.sendMessage(null, "Invalid UID."); return;
-					break;
+                        }
-				case "delete":
+                    }
-					boolean success = DatabaseHelper.deleteAccount(username);
+
-					
+                    Account account = DatabaseHelper.createAccountWithId(username, uid);
-					if (success) {
+                    if(account == null) {
-						Grasscutter.getLogger().info("Account deleted");
+                        CommandHandler.sendMessage(null, "Account already exists."); return;
-					}
+                    } else {
-					break;
+                        CommandHandler.sendMessage(null, "Account created with UID " + account.getPlayerId() + ".");
-				/*
+                        account.addPermission("*"); // Grant the player superuser permissions.
-				case "setpw":
+                    }
-				case "setpass":
+                    return;
-				case "setpassword":
+                case "delete":
-					if (split.length < 3) {
+                    if(DatabaseHelper.deleteAccount(username)) {
-						Grasscutter.getLogger().error("Invalid amount of args");
+                        CommandHandler.sendMessage(null, "Account deleted."); return;
-						return;
+                    } else CommandHandler.sendMessage(null, "Account not found.");
-					}		
+                    return;
-					
+            }
-					account = DatabaseHelper.getAccountByName(username);
+        }
-					
+    }
-					if (account == null) {
+    
-						Grasscutter.getLogger().error("No account found!");
+    @Command(label = "permission", 
-						return;
+            usage = "Usage: permission <add|remove> <username> <permission>", 
-					}
+            execution = Command.Execution.CONSOLE)
-					
+    public static class PermissionCommand implements CommandHandler {
-					token = split[2];
+
-					token = PasswordHelper.hashPassword(token);
+        @Override
-					
+        public void execute(List<String> args) {
-					account.setPassword(token);
+            if(args.size() < 3) {
-					DatabaseHelper.saveAccount(account);
+                CommandHandler.sendMessage(null, "Usage: permission <add|remove> <username> <permission>"); return;
-					
+            }
-					Grasscutter.getLogger().info("Password set");
+            
-					break;
+            String action = args.get(0);
-				*/
+            String username = args.get(1);
-			}
+            String permission = args.get(2);
-		}
+            
-	}
+            Account account = DatabaseHelper.getAccountByName(username);
+            if(account == null) {
+                CommandHandler.sendMessage(null, "Account not found."); return;
+            }
+            
+            switch(action) {
+                default:
+                    CommandHandler.sendMessage(null, "Usage: permission <add|remove> <username> <permission>");
+                    return;
+                case "add":
+                    if(account.addPermission(permission)) {
+                        CommandHandler.sendMessage(null, "Permission added."); return;
+                    } else CommandHandler.sendMessage(null, "They already have this permission!");
+                    return;
+                case "remove":
+                    if(account.removePermission(permission)) {
+                        CommandHandler.sendMessage(null, "Permission removed."); return;
+                    } else CommandHandler.sendMessage(null, "They don't have this permission!");
+                    return;
+            }
+        }
+    }
+    
+    @Command(label = "help", 
+            usage = "Usage: help [command]")
+    public static class HelpCommand implements CommandHandler {
+
+        @Override
+        public void execute(List<String> args) {
+            List<CommandHandler> handlers = CommandMap.getInstance().getHandlers();
+            List<Command> annotations = handlers.stream()
+                    .map(handler -> handler.getClass().getAnnotation(Command.class))
+                    .collect(Collectors.toList());
+            
+            if(args.size() < 1) {
+                StringBuilder builder = new StringBuilder("Available commands:\n");
+                annotations.forEach(annotation -> builder.append(annotation.usage()).append("\n"));
+                CommandHandler.sendMessage(null, builder.toString());
+            } else {
+                String command = args.get(0);
+                CommandHandler handler = CommandMap.getInstance().getHandler(command);
+                if(handler == null) {
+                    CommandHandler.sendMessage(null, "Command not found."); return;
+                }
+                
+                Command annotation = handler.getClass().getAnnotation(Command.class);
+                CommandHandler.sendMessage(null, annotation.usage());
+            }
+        }
+
+        @Override
+        public void execute(GenshinPlayer player, List<String> args) {
+            List<CommandHandler> handlers = CommandMap.getInstance().getHandlers();
+            List<Command> annotations = handlers.stream()
+                    .map(handler -> handler.getClass().getAnnotation(Command.class))
+                    .collect(Collectors.toList());
+
+            if(args.size() < 1) {
+                annotations.forEach(annotation -> player.dropMessage(annotation.usage()));
+            } else {
+                String command = args.get(0);
+                CommandHandler handler = CommandMap.getInstance().getHandler(command);
+                if(handler == null) {
+                    CommandHandler.sendMessage(player, "Command not found."); return;
+                }
+
+                Command annotation = handler.getClass().getAnnotation(Command.class);
+                CommandHandler.sendMessage(player, annotation.usage());
+            }
+        }
+    }
 }

src/main/java/emu/grasscutter/data/ResourceLoader.java

@@ -2,20 +2,12 @@ package emu.grasscutter.data;
 
 import java.io.File;
 import java.io.FileReader;
-import java.nio.file.Files;
+import java.util.*;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
 import java.util.Map.Entry;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import java.util.stream.Stream;
 
+import emu.grasscutter.utils.Utils;
 import org.reflections.Reflections;
 
 import com.google.gson.reflect.TypeToken;
@@ -39,19 +31,12 @@ public class ResourceLoader {
 			}
 		});
 
-		classList.sort((a, b) -> {
+		classList.sort((a, b) -> b.getAnnotation(ResourceType.class).loadPriority().value() - a.getAnnotation(ResourceType.class).loadPriority().value());
-			return b.getAnnotation(ResourceType.class).loadPriority().value() - a.getAnnotation(ResourceType.class).loadPriority().value();
-		});
 
 		return classList;
 	}
 	
 	public static void loadAll() {
-		// Create resource folder if it doesnt exist
-		File resFolder = new File(Grasscutter.getConfig().RESOURCE_FOLDER);
-		if (!resFolder.exists()) {
-			resFolder.mkdir();
-		}
 		// Load ability lists
 		loadAbilityEmbryos();
 		loadOpenConfig();
@@ -110,7 +95,7 @@ public class ResourceLoader {
 			try {
 				loadFromResource(resourceDefinition, type, map);
 			} catch (Exception e) {
-				Grasscutter.getLogger().error("Error loading resource file: " + type.name(), e);
+				Grasscutter.getLogger().error("Error loading resource file: " + Arrays.toString(type.name()), e);
 			}
 		}
 	}
@@ -153,10 +138,16 @@ public class ResourceLoader {
 			Pattern pattern = Pattern.compile("(?<=ConfigAvatar_)(.*?)(?=.json)");
 			
 			embryoList = new LinkedList<>();
-			File folder = new File(Grasscutter.getConfig().RESOURCE_FOLDER + "BinOutput\\Avatar\\");
+			File folder = new File(Utils.toFilePath(Grasscutter.getConfig().RESOURCE_FOLDER + "BinOutput/Avatar/"));
-			for (File file : folder.listFiles()) {
+			File[] files = folder.listFiles();
-				AvatarConfig config = null;
+			if(files == null) {
-				String avatarName = null;
+				Grasscutter.getLogger().error("Error loading ability embryos: no files found in " + folder.getAbsolutePath());
+				return;
+			}
+			
+			for (File file : files) {
+				AvatarConfig config;
+				String avatarName;
 				
 				Matcher matcher = pattern.matcher(file.getName());
 				if (matcher.find()) {
@@ -209,14 +200,18 @@ public class ResourceLoader {
 			String[] folderNames = {"BinOutput\\Talent\\EquipTalents\\", "BinOutput\\Talent\\AvatarTalents\\"};
 			
 			for (String name : folderNames) {
-				File folder = new File(Grasscutter.getConfig().RESOURCE_FOLDER + name);
+				File folder = new File(Utils.toFilePath(Grasscutter.getConfig().RESOURCE_FOLDER + name));
+				File[] files = folder.listFiles();
+				if(files == null) {
+					Grasscutter.getLogger().error("Error loading open config: no files found in " + folder.getAbsolutePath()); return;
+				}
 				
-				for (File file : folder.listFiles()) {
+				for (File file : files) {
 					if (!file.getName().endsWith(".json")) {
 						continue;
 					}
 					
-					Map<String, OpenConfigData[]> config = null;
+					Map<String, OpenConfigData[]> config;
 					
 					try (FileReader fileReader = new FileReader(file)) {
 						config = Grasscutter.getGsonFactory().fromJson(fileReader, type);

src/main/java/emu/grasscutter/database/DatabaseHelper.java

@@ -36,6 +36,7 @@ public class DatabaseHelper {
 			if (reservedId == GenshinConstants.SERVER_CONSOLE_UID) {
 				return null;
 			}
+			
 			exists = DatabaseHelper.getAccountByPlayerId(reservedId);
 			if (exists != null) {
 				return null;

src/main/java/emu/grasscutter/game/Account.java

@@ -9,6 +9,8 @@ import emu.grasscutter.utils.Crypto;
 import emu.grasscutter.utils.Utils;
 import dev.morphia.annotations.IndexOptions;
 
+import java.util.List;
+
 @Entity(value = "accounts", noClassnameStored = true)
 public class Account {
 	@Id private String id;
@@ -23,6 +25,7 @@ public class Account {
 	
 	private String token;
 	private String sessionKey; // Session token for dispatch server
+	private List<String> permissions;
 
 	@Deprecated
 	public Account() {}
@@ -84,6 +87,22 @@ public class Account {
 		this.save();
 		return this.sessionKey;
 	}
+
+	/**
+	 * The collection of a player's permissions.
+	 */
+	public List<String> getPermissions() {
+		return this.permissions;
+	}
+	
+	public boolean addPermission(String permission) {
+		if(this.permissions.contains(permission)) return false;
+		this.permissions.add(permission); return true;
+	}
+	
+	public boolean removePermission(String permission) {
+		return this.permissions.remove(permission);
+	}
 	
 	// TODO make unique
 	public String generateLoginToken() {

src/main/java/emu/grasscutter/game/GenshinPlayer.java

@@ -1,11 +1,6 @@
 package emu.grasscutter.game;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
 
 import dev.morphia.annotations.*;
 import emu.grasscutter.GenshinConstants;
@@ -494,7 +489,7 @@ public class GenshinPlayer {
 		this.regionId = regionId;
 	}
 	
-	public boolean hasGodmode() {
+	public boolean inGodmode() {
 		return godmode;
 	}
 
@@ -567,6 +562,15 @@ public class GenshinPlayer {
 	public void dropMessage(Object message) {
 		this.sendPacket(new PacketPrivateChatNotify(GenshinConstants.SERVER_CONSOLE_UID, getId(), message.toString()));
 	}
+
+	/**
+	 * Sends a message to another player.
+	 * @param sender The sender of the message.
+	 * @param message The message to send.
+	 */
+	public void sendMessage(GenshinPlayer sender, Object message) {
+		this.sendPacket(new PacketPrivateChatNotify(sender.getId(), this.getId(), message.toString()));
+	}
 	
 	public void interactWith(int gadgetEntityId) {
 		GenshinEntity entity = getScene().getEntityById(gadgetEntityId);

src/main/java/emu/grasscutter/game/GenshinScene.java

@@ -229,7 +229,7 @@ public class GenshinScene {
 		
 		// Godmode check
 		if (target instanceof EntityAvatar) {
-			if (((EntityAvatar) target).getPlayer().hasGodmode()) {
+			if (((EntityAvatar) target).getPlayer().inGodmode()) {
 				return;
 			}
 		}

src/main/java/emu/grasscutter/game/managers/ChatManager.java

@@ -1,14 +1,18 @@
 package emu.grasscutter.game.managers;
 
-import emu.grasscutter.Grasscutter;
+import emu.grasscutter.commands.CommandMap;
-import emu.grasscutter.commands.PlayerCommands;
 import emu.grasscutter.game.GenshinPlayer;
 import emu.grasscutter.net.packet.GenshinPacket;
 import emu.grasscutter.server.game.GameServer;
 import emu.grasscutter.server.packet.send.PacketPlayerChatNotify;
 import emu.grasscutter.server.packet.send.PacketPrivateChatNotify;
 
+import java.util.Arrays;
+import java.util.List;
+
 public class ChatManager {
+	static final List<Character> PREFIXES = Arrays.asList('/', '!');
+	
 	private final GameServer server;
 	
 	public ChatManager(GameServer server) {
@@ -19,15 +23,15 @@ public class ChatManager {
 		return server;
 	}
 
-	public void sendPrivChat(GenshinPlayer player, int targetUid, String message) {
+	public void sendPrivateMessage(GenshinPlayer player, int targetUid, String message) {
 		// Sanity checks
 		if (message == null || message.length() == 0) {
 			return;
 		}
 				
 		// Check if command
-		if (message.charAt(0) == '!' || message.charAt(0) == '/') {
+		if (PREFIXES.contains(message.charAt(0))) {
-			PlayerCommands.handle(player, message);
+			CommandMap.getInstance().invoke(player, message);
 			return;
 		}
 		
@@ -45,7 +49,7 @@ public class ChatManager {
 		target.sendPacket(packet);
 	}
 	
-	public void sendPrivChat(GenshinPlayer player, int targetUid, int emote) {
+	public void sendPrivateMessage(GenshinPlayer player, int targetUid, int emote) {
 		// Get target
 		GenshinPlayer target = getServer().getPlayerById(targetUid);
 		
@@ -60,15 +64,15 @@ public class ChatManager {
 		target.sendPacket(packet);
 	}
 	
-	public void sendTeamChat(GenshinPlayer player, int channel, String message) {
+	public void sendTeamMessage(GenshinPlayer player, int channel, String message) {
 		// Sanity checks
 		if (message == null || message.length() == 0) {
 			return;
 		}
 				
 		// Check if command
-		if (message.charAt(0) == '!') {
+		if (PREFIXES.contains(message.charAt(0))) {
-			PlayerCommands.handle(player, message);
+			CommandMap.getInstance().invoke(player, message);
 			return;
 		}
 
@@ -76,7 +80,7 @@ public class ChatManager {
 		player.getWorld().broadcastPacket(new PacketPlayerChatNotify(player, channel, message));
 	}
 
-	public void sendTeamChat(GenshinPlayer player, int channel, int icon) {
+	public void sendTeamMessage(GenshinPlayer player, int channel, int icon) {
 		// Create and send chat packet
 		player.getWorld().broadcastPacket(new PacketPlayerChatNotify(player, channel, icon));
 	}

src/main/java/emu/grasscutter/server/game/GameServer.java

@@ -1,16 +1,12 @@
 package emu.grasscutter.server.game;
 
 import java.net.InetSocketAddress;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-import java.util.Timer;
-import java.util.TimerTask;
 import java.util.concurrent.ConcurrentHashMap;
 
 import emu.grasscutter.GenshinConstants;
 import emu.grasscutter.Grasscutter;
+import emu.grasscutter.commands.CommandMap;
 import emu.grasscutter.database.DatabaseHelper;
 import emu.grasscutter.game.GenshinPlayer;
 import emu.grasscutter.game.dungeons.DungeonManager;
@@ -23,11 +19,10 @@ import emu.grasscutter.net.packet.PacketHandler;
 import emu.grasscutter.net.proto.SocialDetailOuterClass.SocialDetail;
 import emu.grasscutter.netty.MihoyoKcpServer;
 
-public class GameServer extends MihoyoKcpServer {
+public final class GameServer extends MihoyoKcpServer {
 	private final InetSocketAddress address;
 	private final GameServerPacketHandler packetHandler;
-	private final Timer gameLoop;
+
-	
 	private final Map<Integer, GenshinPlayer> players;
 	
 	private final ChatManager chatManager;
@@ -36,9 +31,11 @@ public class GameServer extends MihoyoKcpServer {
 	private final ShopManager shopManager;
 	private final MultiplayerManager multiplayerManager;
 	private final DungeonManager dungeonManager;
+	private final CommandMap commandMap;
 	
 	public GameServer(InetSocketAddress address) {
 		super(address);
+		
 		this.setServerInitializer(new GameServerInitializer(this));
 		this.address = address;
 		this.packetHandler = new GameServerPacketHandler(PacketHandler.class);
@@ -50,22 +47,22 @@ public class GameServer extends MihoyoKcpServer {
 		this.shopManager = new ShopManager(this);
 		this.multiplayerManager = new MultiplayerManager(this);
 		this.dungeonManager = new DungeonManager(this);
+		this.commandMap = new CommandMap(true);
 		
-		// Ticker
+		// Schedule game loop.
-		this.gameLoop = new Timer();
+		Timer gameLoop = new Timer();
-		this.gameLoop.scheduleAtFixedRate(new TimerTask() {
+		gameLoop.scheduleAtFixedRate(new TimerTask() {
 			@Override
 			public void run() {
 				try {
 					onTick();
 				} catch (Exception e) {
-					// TODO Auto-generated catch block
+					Grasscutter.getLogger().error("An error occurred during game update.", e);
-					e.printStackTrace();
 				}
 			}
 		}, new Date(), 1000L);
 		
-		// Shutdown hook
+		// Hook into shutdown event.
 		Runtime.getRuntime().addShutdownHook(new Thread(this::onServerShutdown));
 	}
 	
@@ -101,6 +98,10 @@ public class GameServer extends MihoyoKcpServer {
 		return dungeonManager;
 	}
 	
+	public CommandMap getCommandMap() {
+		return this.commandMap;
+	}
+	
 	public void registerPlayer(GenshinPlayer player) {
 		getPlayers().put(player.getId(), player);
 	}

src/main/java/emu/grasscutter/server/packet/recv/HandlerPlayerChatReq.java

@@ -17,9 +17,9 @@ public class HandlerPlayerChatReq extends PacketHandler {
 		ChatInfo.ContentCase content = req.getChatInfo().getContentCase();
 		
 		if (content == ChatInfo.ContentCase.TEXT) {
-			session.getServer().getChatManager().sendTeamChat(session.getPlayer(), req.getChannelId(), req.getChatInfo().getText());
+			session.getServer().getChatManager().sendTeamMessage(session.getPlayer(), req.getChannelId(), req.getChatInfo().getText());
 		} else if (content == ChatInfo.ContentCase.ICON) {
-			session.getServer().getChatManager().sendTeamChat(session.getPlayer(), req.getChannelId(), req.getChatInfo().getIcon());
+			session.getServer().getChatManager().sendTeamMessage(session.getPlayer(), req.getChannelId(), req.getChatInfo().getIcon());
 		}
 		
 		session.send(new PacketPlayerChatRsp());

src/main/java/emu/grasscutter/server/packet/recv/HandlerPrivateChatReq.java

@@ -15,9 +15,9 @@ public class HandlerPrivateChatReq extends PacketHandler {
 		PrivateChatReq.ContentCase content = req.getContentCase();
 		
 		if (content == PrivateChatReq.ContentCase.TEXT) {
-			session.getServer().getChatManager().sendPrivChat(session.getPlayer(), req.getTargetUid(), req.getText());
+			session.getServer().getChatManager().sendPrivateMessage(session.getPlayer(), req.getTargetUid(), req.getText());
 		} else if (content == PrivateChatReq.ContentCase.ICON) {
-			session.getServer().getChatManager().sendPrivChat(session.getPlayer(), req.getTargetUid(), req.getIcon());
+			session.getServer().getChatManager().sendPrivateMessage(session.getPlayer(), req.getTargetUid(), req.getIcon());
 		}
 		
 		//session.send(new GenshinPacket(PacketOpcodes.PrivateChatRsp)); // Unused by server

src/main/java/emu/grasscutter/utils/Utils.java

@@ -79,6 +79,15 @@ public final class Utils {
 	    return v7;
 	}
 
+	/**
+	 * Creates a string with the path to a file.
+	 * @param path The path to the file.
+	 * @return A path using the operating system's file separator.
+	 */
+	public static String toFilePath(String path) {
+		return path.replace("/", File.separator);
+	}
+
 	/**
 	 * Checks if a file exists on the file system.
 	 * @param path The path to the file.
@@ -118,6 +127,16 @@ public final class Utils {
 		}
 	}
 
+	/**
+	 * Get object with null fallback.
+	 * @param nonNull The object to return if not null.
+	 * @param fallback The object to return if null.
+	 * @return One of the two provided objects.
+	 */
+	public static <T> T requireNonNullElseGet(T nonNull, T fallback) {
+		return nonNull != null ? nonNull : fallback;
+	}
+
 	/**
 	 * Checks for required files and folders before startup.
 	 */

src/main/resources/logback.xml

@@ -1,7 +1,7 @@
 <Configuration>
   <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
     <encoder>
-      <pattern>[%d{HH:mm:ss}] [%level] %msg%n</pattern>
+      <pattern>[%d{HH:mm:ss}] [%highlight(%level)] %msg%n</pattern>
     </encoder>
   </appender>
   <logger name="org.reflections" level="OFF"/>