Merge branch 'stable' into development

src/main/java/emu/grasscutter/command/commands/ChangeSceneCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.List;
+
+@Command(label = "changescene", usage = "changescene <scene id>",
+        description = "Changes your scene", aliases = {"scene"}, permission = "player.changescene")
+public final class ChangeSceneCommand implements CommandHandler {
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (sender == null) {
+            CommandHandler.sendMessage(null, "Run this command in-game.");
+            return;
+        }
+
+        if (args.size() < 1) {
+            CommandHandler.sendMessage(sender, "Usage: changescene <scene id>");
+            return;
+        }
+
+        try {
+            int sceneId = Integer.parseInt(args.get(0));
+            
+            if (sceneId == sender.getSceneId()) {
+            	CommandHandler.sendMessage(sender, "You are already in that scene");
+            	return;
+            }
+            
+            boolean result = sender.getWorld().transferPlayerToScene(sender, sceneId, sender.getPos());
+            CommandHandler.sendMessage(sender, "Changed to scene " + sceneId);
+            
+            if (!result) {
+                CommandHandler.sendMessage(sender, "Scene does not exist");
+            }
+        } catch (Exception e) {
+            CommandHandler.sendMessage(sender, "Usage: changescene <scene id>");
+        }
+    }
+}

src/main/java/emu/grasscutter/command/commands/ClearArtifactsCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.inventory.Inventory;
+import emu.grasscutter.game.inventory.ItemType;
+
+import java.util.List;
+
+@Command(label = "clearartifacts", usage = "clearartifacts",
+        description = "Deletes all unequipped and unlocked level 0 artifacts, including yellow rarity ones from your inventory",
+        aliases = {"clearart"}, permission = "player.clearartifacts")
+public final class ClearArtifactsCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (sender == null) {
+            CommandHandler.sendMessage(null, "Run this command in-game.");
+            return; // TODO: clear player's artifacts from console or other players
+        }
+
+        Inventory playerInventory = sender.getInventory();
+        playerInventory.getItems().values().stream()
+                .filter(item -> item.getItemType() == ItemType.ITEM_RELIQUARY)
+                .filter(item -> item.getLevel() == 1 && item.getExp() == 0)
+                .filter(item -> !item.isLocked() && !item.isEquipped())
+                .forEach(item -> playerInventory.removeItem(item, item.getCount()));
+    }
+}

src/main/java/emu/grasscutter/command/commands/DropCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.data.GenshinData;
+import emu.grasscutter.data.def.ItemData;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.entity.EntityItem;
+import emu.grasscutter.utils.Position;
+
+import java.util.List;
+
+@Command(label = "drop", usage = "drop <itemId|itemName> [amount]",
+        description = "Drops an item near you", aliases = {"d", "dropitem"}, permission = "server.drop")
+public final class DropCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (sender == null) {
+            CommandHandler.sendMessage(null, "Run this command in-game.");
+            return;
+        }
+
+        if (args.size() < 1) {
+            CommandHandler.sendMessage(sender, "Usage: drop <itemId|itemName> [amount]");
+            return;
+        }
+
+        try {
+            int item = Integer.parseInt(args.get(0));
+            int amount = 1;
+            if (args.size() > 1) amount = Integer.parseInt(args.get(1));
+
+            ItemData itemData = GenshinData.getItemDataMap().get(item);
+            if (itemData == null) {
+                CommandHandler.sendMessage(sender, "Invalid item id.");
+                return;
+            }
+
+            if (itemData.isEquip()) {
+                float range = (5f + (.1f * amount));
+                for (int i = 0; i < amount; i++) {
+                    Position pos = sender.getPos().clone().addX((float) (Math.random() * range) - (range / 2)).addY(3f).addZ((float) (Math.random() * range) - (range / 2));
+                    EntityItem entity = new EntityItem(sender.getScene(), sender, itemData, pos, 1);
+                    sender.getScene().addEntity(entity);
+                }
+            } else {
+                EntityItem entity = new EntityItem(sender.getScene(), sender, itemData, sender.getPos().clone().addY(3f), amount);
+                sender.getScene().addEntity(entity);
+            }
+            CommandHandler.sendMessage(sender, String.format("Dropped %s of %s.", amount, item));
+        } catch (NumberFormatException ignored) {
+            CommandHandler.sendMessage(sender, "Invalid item or player ID.");
+        }
+    }
+}
\ No newline at end of file

src/main/java/emu/grasscutter/command/commands/GiveCharCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.data.GenshinData;
+import emu.grasscutter.data.def.AvatarData;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.avatar.GenshinAvatar;
+
+import java.util.List;
+
+@Command(label = "givechar", usage = "givechar <playerId> <avatarId> [level]",
+        description = "Gives the player a specified character", aliases = {"givec"}, permission = "player.givechar")
+public final class GiveCharCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        int target, avatarId, level = 1, ascension;
+
+        if (sender == null && args.size() < 2) {
+            CommandHandler.sendMessage(null, "Usage: givechar <player> <itemId|itemName> [amount]");
+            return;
+        }
+
+        switch (args.size()) {
+            default:
+                CommandHandler.sendMessage(sender, "Usage: givechar <player> <avatarId> [level]");
+                return;
+            case 2:
+                try {
+                    target = Integer.parseInt(args.get(0));
+                    if (Grasscutter.getGameServer().getPlayerByUid(target) == null && sender != null) {
+                        target = sender.getUid();
+                        level = Integer.parseInt(args.get(1));
+                        avatarId = Integer.parseInt(args.get(0));
+                    } else {
+                        avatarId = Integer.parseInt(args.get(1));
+                    }
+                } catch (NumberFormatException ignored) {
+                    // TODO: Parse from avatar name using GM Handbook.
+                    CommandHandler.sendMessage(sender, "Invalid avatar or player ID.");
+                    return;
+                }
+                break;
+            case 3:
+                try {
+                    target = Integer.parseInt(args.get(0));
+                    if (Grasscutter.getGameServer().getPlayerByUid(target) == null) {
+                        CommandHandler.sendMessage(sender, "Invalid player ID.");
+                        return;
+                    }
+
+                    avatarId = Integer.parseInt(args.get(1));
+                    level = Integer.parseInt(args.get(2));
+                } catch (NumberFormatException ignored) {
+                    // TODO: Parse from avatar name using GM Handbook.
+                    CommandHandler.sendMessage(sender, "Invalid avatar or player ID.");
+                    return;
+                }
+                break;
+        }
+
+        GenshinPlayer targetPlayer = Grasscutter.getGameServer().getPlayerByUid(target);
+        if (targetPlayer == null) {
+            CommandHandler.sendMessage(sender, "Player not found.");
+            return;
+        }
+
+        AvatarData avatarData = GenshinData.getAvatarDataMap().get(avatarId);
+        if (avatarData == null) {
+            CommandHandler.sendMessage(sender, "Invalid avatar id.");
+            return;
+        }
+
+        // Calculate ascension level.
+        if (level <= 40) {
+            ascension = (int) Math.ceil(level / 20f);
+        } else {
+            ascension = (int) Math.ceil(level / 10f) - 3;
+        }
+
+        GenshinAvatar avatar = new GenshinAvatar(avatarId);
+        avatar.setLevel(level);
+        avatar.setPromoteLevel(ascension);
+
+        // This will handle stats and talents
+        avatar.recalcStats();
+
+        targetPlayer.addAvatar(avatar);
+        CommandHandler.sendMessage(sender, String.format("Given %s to %s.", avatarId, target));
+    }
+}

src/main/java/emu/grasscutter/command/commands/GiveCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.data.GenshinData;
+import emu.grasscutter.data.def.ItemData;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.inventory.GenshinItem;
+import emu.grasscutter.game.props.ActionReason;
+import emu.grasscutter.server.packet.send.PacketItemAddHintNotify;
+
+import java.util.LinkedList;
+import java.util.List;
+
+@Command(label = "give", usage = "give [player] <itemId|itemName> [amount]",
+        description = "Gives an item to you or the specified player", aliases = {"g", "item", "giveitem"}, permission = "player.give")
+public final class GiveCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        int target, item, amount = 1;
+
+        if (sender == null && args.size() < 2) {
+            CommandHandler.sendMessage(null, "Usage: give <player> <itemId|itemName> [amount]");
+            return;
+        }
+
+        switch (args.size()) {
+            default: // *No args*
+                CommandHandler.sendMessage(sender, "Usage: give [player] <itemId|itemName> [amount]");
+                return;
+            case 1: // <itemId|itemName>
+                try {
+                    item = Integer.parseInt(args.get(0));
+                    target = sender.getUid();
+                } catch (NumberFormatException ignored) {
+                    // TODO: Parse from item name using GM Handbook.
+                    CommandHandler.sendMessage(sender, "Invalid item id.");
+                    return;
+                }
+                break;
+            case 2: // <itemId|itemName> [amount] | [player] <itemId|itemName>
+                try {
+                    target = Integer.parseInt(args.get(0));
+
+                    if (Grasscutter.getGameServer().getPlayerByUid(target) == null && sender != null) {
+                        target = sender.getUid();
+                        item = Integer.parseInt(args.get(0));
+                        amount = Integer.parseInt(args.get(1));
+                    } else {
+                        item = Integer.parseInt(args.get(1));
+                    }
+                } catch (NumberFormatException ignored) {
+                    // TODO: Parse from item name using GM Handbook.
+                    CommandHandler.sendMessage(sender, "Invalid item or player ID.");
+                    return;
+                }
+                break;
+            case 3: // [player] <itemId|itemName> [amount]
+                try {
+                    target = Integer.parseInt(args.get(0));
+
+                    if (Grasscutter.getGameServer().getPlayerByUid(target) == null) {
+                        CommandHandler.sendMessage(sender, "Invalid player ID.");
+                        return;
+                    }
+
+                    item = Integer.parseInt(args.get(1));
+                    amount = Integer.parseInt(args.get(2));
+                } catch (NumberFormatException ignored) {
+                    // TODO: Parse from item name using GM Handbook.
+                    CommandHandler.sendMessage(sender, "Invalid item or player ID.");
+                    return;
+                }
+                break;
+        }
+
+        GenshinPlayer targetPlayer = Grasscutter.getGameServer().getPlayerByUid(target);
+
+        if (targetPlayer == null) {
+            CommandHandler.sendMessage(sender, "Player not found.");
+            return;
+        }
+
+        ItemData itemData = GenshinData.getItemDataMap().get(item);
+        if (itemData == null) {
+            CommandHandler.sendMessage(sender, "Invalid item id.");
+            return;
+        }
+
+        this.item(targetPlayer, itemData, amount);
+
+        CommandHandler.sendMessage(sender, String.format("Given %s of %s to %s.", amount, item, target));
+    }
+
+    private void item(GenshinPlayer player, ItemData itemData, int amount) {
+        if (itemData.isEquip()) {
+            List<GenshinItem> items = new LinkedList<>();
+            for (int i = 0; i < amount; i++) {
+                items.add(new GenshinItem(itemData));
+            }
+            player.getInventory().addItems(items);
+            player.sendPacket(new PacketItemAddHintNotify(items, ActionReason.SubfieldDrop));
+        } else {
+            GenshinItem genshinItem = new GenshinItem(itemData);
+            genshinItem.setCount(amount);
+            player.getInventory().addItem(genshinItem);
+            player.sendPacket(new PacketItemAddHintNotify(genshinItem, ActionReason.SubfieldDrop));
+        }
+    }
+}
+

src/main/java/emu/grasscutter/command/commands/GodModeCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.List;
+
+@Command(label = "godmode", usage = "godmode [playerId]",
+        description = "Prevents you from taking damage", permission = "player.godmode")
+public final class GodModeCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (sender == null) {
+            CommandHandler.sendMessage(null, "Run this command in-game.");
+            return; // TODO: toggle player's godmode statue from console or other players
+        }
+        sender.setGodmode(!sender.inGodmode());
+        sender.dropMessage("Godmode is now " + (sender.inGodmode() ? "enabled" : "disabled") + ".");
+    }
+}

src/main/java/emu/grasscutter/command/commands/HealCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.props.FightProperty;
+import emu.grasscutter.server.packet.send.PacketAvatarFightPropUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketAvatarLifeStateChangeNotify;
+import emu.grasscutter.server.packet.send.PacketEntityFightPropUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketLifeStateChangeNotify;
+
+import java.util.List;
+
+@Command(label = "heal", usage = "heal|h",
+        description = "Heal all characters in your current team.", aliases = {"h"}, permission = "player.heal")
+public class HealCommand implements CommandHandler {
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (sender == null) {
+            CommandHandler.sendMessage(null, "Run this command in-game.");
+            return;
+        }
+        sender.getTeamManager().getActiveTeam().forEach(entity -> {
+            boolean isAlive = entity.isAlive();
+            entity.setFightProperty(
+                    FightProperty.FIGHT_PROP_CUR_HP,
+                    entity.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP)
+            );
+            entity.getWorld().broadcastPacket(new PacketAvatarFightPropUpdateNotify(entity.getAvatar(), FightProperty.FIGHT_PROP_CUR_HP));
+            if (!isAlive) {
+                entity.getWorld().broadcastPacket(new PacketAvatarLifeStateChangeNotify(entity.getAvatar()));
+            }
+        });
+        CommandHandler.sendMessage(sender, "All characters are healed.");
+    }
+}

src/main/java/emu/grasscutter/command/commands/HelpCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.command.CommandMap;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.*;
+
+@Command(label = "help", usage = "help [command]",
+        description = "Sends the help message or shows information about a specified command")
+public final class HelpCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer player, List<String> args) {
+        if (args.size() < 1) {
+            HashMap<String, CommandHandler> handlers = CommandMap.getInstance().getHandlers();
+            List<Command> annotations = new ArrayList<>();
+            for (String key : handlers.keySet()) {
+                Command annotation = handlers.get(key).getClass().getAnnotation(Command.class);
+
+                if (!Arrays.asList(annotation.aliases()).contains(key)) {
+                    if (player != null && !Objects.equals(annotation.permission(), "") && !player.getAccount().hasPermission(annotation.permission()))
+                        continue;
+                    annotations.add(annotation);
+                }
+            }
+
+            SendAllHelpMessage(player, annotations);
+        } else {
+            String command = args.get(0);
+            CommandHandler handler = CommandMap.getInstance().getHandler(command);
+            StringBuilder builder = new StringBuilder(player == null ? "\nHelp - " : "Help - ").append(command).append(": \n");
+            if (handler == null) {
+                builder.append("No command found.");
+            } else {
+                Command annotation = handler.getClass().getAnnotation(Command.class);
+
+                builder.append("   ").append(annotation.description()).append("\n");
+                builder.append("   Usage: ").append(annotation.usage());
+                if (annotation.aliases().length >= 1) {
+                    builder.append("\n").append("   Aliases: ");
+                    for (String alias : annotation.aliases()) {
+                        builder.append(alias).append(" ");
+                    }
+                }
+                if (player != null && !Objects.equals(annotation.permission(), "") && !player.getAccount().hasPermission(annotation.permission())) {
+                    builder.append("\n Warning: You do not have permission to run this command.");
+                }
+            }
+
+            CommandHandler.sendMessage(player, builder.toString());
+        }
+    }
+
+    void SendAllHelpMessage(GenshinPlayer player, List<Command> annotations) {
+        if (player == null) {
+            StringBuilder builder = new StringBuilder("\nAvailable commands:\n");
+            annotations.forEach(annotation -> {
+                builder.append(annotation.label()).append("\n");
+                builder.append("   ").append(annotation.description()).append("\n");
+                builder.append("   Usage: ").append(annotation.usage());
+                if (annotation.aliases().length >= 1) {
+                    builder.append("\n").append("   Aliases: ");
+                    for (String alias : annotation.aliases()) {
+                        builder.append(alias).append(" ");
+                    }
+                }
+
+                builder.append("\n");
+            });
+
+            CommandHandler.sendMessage(null, builder.toString());
+        } else {
+            CommandHandler.sendMessage(player, "Available commands:");
+            annotations.forEach(annotation -> {
+                StringBuilder builder = new StringBuilder(annotation.label()).append("\n");
+                builder.append("   ").append(annotation.description()).append("\n");
+                builder.append("   Usage: ").append(annotation.usage());
+                if (annotation.aliases().length >= 1) {
+                    builder.append("\n").append("   Aliases: ");
+                    for (String alias : annotation.aliases()) {
+                        builder.append(alias).append(" ");
+                    }
+                }
+
+                CommandHandler.sendMessage(player, builder.toString());
+            });
+        }
+    }
+}

src/main/java/emu/grasscutter/command/commands/KickCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.List;
+
+@Command(label = "kick", usage = "kick <player>",
+        description = "Kicks the specified player from the server (WIP)", permission = "server.kick")
+public final class KickCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        int target = Integer.parseInt(args.get(0));
+
+        GenshinPlayer targetPlayer = Grasscutter.getGameServer().getPlayerByUid(target);
+        if (targetPlayer == null) {
+            CommandHandler.sendMessage(sender, "Player not found.");
+            return;
+        }
+
+        if (sender != null) {
+            CommandHandler.sendMessage(sender, String.format("Player [%s:%s] has kicked player [%s:%s]", sender.getAccount().getPlayerUid(), sender.getAccount().getUsername(), target, targetPlayer.getAccount().getUsername()));
+        }
+        CommandHandler.sendMessage(sender, String.format("Kicking player [%s:%s]", target, targetPlayer.getAccount().getUsername()));
+
+        targetPlayer.getSession().close();
+    }
+}

src/main/java/emu/grasscutter/command/commands/KillAllCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.GenshinScene;
+import emu.grasscutter.game.entity.EntityMonster;
+
+import java.util.List;
+
+@Command(label = "killall", usage = "killall [playerUid] [sceneId]",
+        description = "Kill all entities", permission = "server.killall")
+public final class KillAllCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        GenshinScene scene;
+        GenshinPlayer genshinPlayer;
+
+        try {
+            switch (args.size()) {
+                case 0: // *No args*
+                    if (sender == null) {
+                        CommandHandler.sendMessage(null, "Usage: killall [playerUid] [sceneId]");
+                        return;
+                    }
+                    scene = sender.getScene();
+                    break;
+                case 1: // [playerUid]
+                    genshinPlayer = Grasscutter.getGameServer().getPlayerByUid(Integer.parseInt(args.get(0)));
+                    if (genshinPlayer == null) {
+                        CommandHandler.sendMessage(sender, "Player not found or offline.");
+                        return;
+                    }
+                    scene = genshinPlayer.getScene();
+                    break;
+                case 2: // [playerUid] [sceneId]
+                    genshinPlayer = Grasscutter.getGameServer().getPlayerByUid(Integer.parseInt(args.get(0)));
+                    if (genshinPlayer == null) {
+                        CommandHandler.sendMessage(sender, "Player not found or offline.");
+                        return;
+                    }
+                    GenshinScene genshinScene = sender.getWorld().getSceneById(Integer.parseInt(args.get(1)));
+                    if (genshinScene == null) {
+                        CommandHandler.sendMessage(sender, "Scene not found in player world");
+                        return;
+                    }
+                    scene = genshinScene;
+                    break;
+                default:
+                    CommandHandler.sendMessage(sender, "Usage: killall [playerUid] [sceneId]");
+                    return;
+            }
+
+            scene.getEntities().values().stream()
+                    .filter(entity -> entity instanceof EntityMonster)
+                    .forEach(entity -> scene.killEntity(entity, 0));
+            CommandHandler.sendMessage(sender, "Killing all monsters in scene " + scene.getId());
+        } catch (NumberFormatException ignored) {
+            CommandHandler.sendMessage(sender, "Invalid arguments.");
+        }
+    }
+}

src/main/java/emu/grasscutter/command/commands/ListCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.List;
+import java.util.Map;
+
+@Command(label = "list", description = "List online players")
+public class ListCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        Map<Integer, GenshinPlayer> playersMap = Grasscutter.getGameServer().getPlayers();
+
+        CommandHandler.sendMessage(sender, String.format("There are %s player(s) online:", playersMap.size()));
+
+        if (playersMap.size() != 0) {
+            StringBuilder playerSet = new StringBuilder();
+
+            for (Map.Entry<Integer, GenshinPlayer> entry : playersMap.entrySet()) {
+                playerSet.append(entry.getValue().getNickname());
+                playerSet.append(", ");
+            }
+
+            String players = playerSet.toString();
+
+            CommandHandler.sendMessage(sender, players.substring(0, players.length() - 2));
+        }
+    }
+}

src/main/java/emu/grasscutter/command/commands/PermissionCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.Account;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.List;
+
+@Command(label = "permission", usage = "permission <add|remove> <username> <permission>",
+        description = "Grants or removes a permission for a user", permission = "*")
+public final class PermissionCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (args.size() < 3) {
+            CommandHandler.sendMessage(sender, "Usage: permission <add|remove> <username> <permission>");
+            return;
+        }
+
+        String action = args.get(0);
+        String username = args.get(1);
+        String permission = args.get(2);
+
+        Account account = Grasscutter.getGameServer().getAccountByName(username);
+        if (account == null) {
+            CommandHandler.sendMessage(sender, "Account not found.");
+            return;
+        }
+
+        switch (action) {
+            default:
+                CommandHandler.sendMessage(sender, "Usage: permission <add|remove> <username> <permission>");
+                break;
+            case "add":
+                if (account.addPermission(permission)) {
+                    CommandHandler.sendMessage(sender, "Permission added.");
+                } else CommandHandler.sendMessage(sender, "They already have this permission!");
+                break;
+            case "remove":
+                if (account.removePermission(permission)) {
+                    CommandHandler.sendMessage(sender, "Permission removed.");
+                } else CommandHandler.sendMessage(sender, "They don't have this permission!");
+                break;
+        }
+
+        account.save();
+    }
+}
\ No newline at end of file

src/main/java/emu/grasscutter/command/commands/PositionCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.List;
+
+@Command(label = "position", usage = "position", aliases = {"pos"},
+        description = "Get coordinates.")
+public final class PositionCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (sender == null) {
+            CommandHandler.sendMessage(null, "Run this command in-game.");
+            return;
+        }
+
+        sender.dropMessage(String.format("Coord: %.3f, %.3f, %.3f", sender.getPos().getX(), sender.getPos().getY(), sender.getPos().getZ()));
+    }
+}

src/main/java/emu/grasscutter/command/commands/ReloadCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.List;
+
+@Command(label = "reload", usage = "reload",
+        description = "Reload server config", permission = "server.reload")
+public final class ReloadCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        CommandHandler.sendMessage(sender, "Reloading config.");
+        Grasscutter.loadConfig();
+        Grasscutter.getGameServer().getGachaManager().load();
+        Grasscutter.getDispatchServer().loadQueries();
+        CommandHandler.sendMessage(sender, "Reload complete.");
+    }
+}

src/main/java/emu/grasscutter/command/commands/ResetConstCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.game.entity.EntityAvatar;
+
+import java.util.List;
+
+@Command(label = "resetconst", usage = "resetconst [all]",
+        description = "Resets the constellation level on your current active character, will need to relog after using the command to see any changes.",
+        aliases = {"resetconstellation"}, permission = "player.resetconstellation")
+public final class ResetConstCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (sender == null) {
+            CommandHandler.sendMessage(null, "Run this command in-game.");
+            return;
+        }
+
+        if (args.size() > 0 && args.get(0).equalsIgnoreCase("all")) {
+            sender.getAvatars().forEach(this::resetConstellation);
+            sender.dropMessage("Reset all avatars' constellations.");
+        } else {
+            EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+            if (entity == null) {
+                return;
+            }
+
+            GenshinAvatar avatar = entity.getAvatar();
+            this.resetConstellation(avatar);
+
+            sender.dropMessage("Constellations for " + avatar.getAvatarData().getName() + " have been reset. Please relog to see changes.");
+        }
+    }
+
+    private void resetConstellation(GenshinAvatar avatar) {
+        avatar.getTalentIdList().clear();
+        avatar.setCoreProudSkillLevel(0);
+        avatar.recalcStats();
+        avatar.save();
+    }
+}
\ No newline at end of file

src/main/java/emu/grasscutter/command/commands/RestartCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.List;
+
+@Command(label = "restart", usage = "restart - Restarts the current session")
+public final class RestartCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        sender.getSession().close();
+    }
+}

src/main/java/emu/grasscutter/command/commands/SendMessageCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+
+import java.util.List;
+
+@Command(label = "say", usage = "say <player> <message>", description = "Sends a message to a player as the server",
+        aliases = {"sendservmsg", "sendservermessage", "sendmessage"}, permission = "server.sendmessage")
+public final class SendMessageCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (args.size() < 2) {
+            CommandHandler.sendMessage(null, "Usage: sendmessage <player> <message>");
+            return;
+        }
+
+        try {
+            int target = Integer.parseInt(args.get(0));
+            String message = String.join(" ", args.subList(1, args.size()));
+
+            GenshinPlayer targetPlayer = Grasscutter.getGameServer().getPlayerByUid(target);
+            if (targetPlayer == null) {
+                CommandHandler.sendMessage(sender, "Player not found.");
+                return;
+            }
+
+            CommandHandler.sendMessage(targetPlayer, message);
+            CommandHandler.sendMessage(sender, "Message sent.");
+        } catch (NumberFormatException ignored) {
+            CommandHandler.sendMessage(sender, "Invalid player ID.");
+        }
+    }
+}
\ No newline at end of file

src/main/java/emu/grasscutter/command/commands/SetStatsCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.entity.EntityAvatar;
+import emu.grasscutter.game.props.FightProperty;
+import emu.grasscutter.server.packet.send.PacketEntityFightPropUpdateNotify;
+
+import java.util.List;
+
+@Command(label = "setstats", usage = "setstats|stats <stat> <value>",
+        description = "Set fight property for your current active character", aliases = {"stats"}, permission = "player.setstats")
+public final class SetStatsCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (sender == null) {
+            CommandHandler.sendMessage(null, "Run this command in-game.");
+            return;
+        }
+
+        if (args.size() < 2){
+            CommandHandler.sendMessage(sender, "Usage: setstats|stats <stat> <value>");
+            return;
+        }
+
+        String stat = args.get(0);
+        switch (stat) {
+            default:
+                CommandHandler.sendMessage(sender, "Usage: /setstats|stats <hp | def | atk | em | er | crate | cdmg> <value> for basic stats");
+                CommandHandler.sendMessage(sender, "Usage: /stats <epyro | ecryo | ehydro | egeo | edend | eelec | ephys> <amount> for elemental bonus");
+                return;
+            case "hp":
+                try {
+                    int health = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_CUR_HP, health);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_CUR_HP));
+                    CommandHandler.sendMessage(sender, "HP set to " + health + ".");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid HP value.");
+                    return;
+                }
+                break;
+            case "def":
+                try {
+                    int def = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_CUR_DEFENSE, def);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_CUR_DEFENSE));
+                    CommandHandler.sendMessage(sender, "DEF set to " + def + ".");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid DEF value.");
+                    return;
+                }
+                break;
+            case "atk":
+                try {
+                    int atk = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_CUR_ATTACK, atk);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_CUR_ATTACK));
+                    CommandHandler.sendMessage(sender, "ATK set to " + atk + ".");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid ATK value.");
+                    return;
+                }
+                break;
+            case "em":
+                try {
+                    int em = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_ELEMENT_MASTERY, em);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_ELEMENT_MASTERY));
+                    CommandHandler.sendMessage(sender, "Elemental Mastery set to " + em + ".");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid EM value.");
+                    return;
+                }
+                break;
+            case "er":
+                try {
+                    float er = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float erecharge = er / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_CHARGE_EFFICIENCY, erecharge);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_CHARGE_EFFICIENCY));
+                    float iger = erecharge * 100;
+                    CommandHandler.sendMessage(sender, "Energy recharge set to " + iger + "%.");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid ER value.");
+                    return;
+                }
+                break;
+            case "crate":
+                try {
+                    float cr = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float crate = cr / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_CRITICAL, crate);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_CRITICAL));
+                    float igcrate = crate * 100;
+                    CommandHandler.sendMessage(sender, "Crit Rate set to " + igcrate + "%.");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid Crit Rate value.");
+                    return;
+                }
+                break;
+            case "cdmg":
+                try {
+                    float cdmg = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float cdamage = cdmg / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_CRITICAL_HURT, cdamage);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_CRITICAL_HURT));
+                    float igcdmg = cdamage * 100;
+                    CommandHandler.sendMessage(sender, "Crit DMG set to " + igcdmg + "%");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid Crit DMG value.");
+                    return;
+                }
+                break;
+            case "epyro":
+                try {
+                    float epyro = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float pyro = epyro / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_FIRE_ADD_HURT, pyro);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_FIRE_ADD_HURT));
+                    float igpyro = pyro * 100;
+                    CommandHandler.sendMessage(sender, "Pyro DMG Bonus set to " + igpyro + "%");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid Pyro DMG Bonus value.");
+                    return;
+                }
+                break;
+            case "ecryo":
+                try {
+                    float ecryo = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float cryo = ecryo / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_ICE_ADD_HURT, cryo);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_ICE_ADD_HURT));
+                    float igcyro = cryo * 100;
+                    CommandHandler.sendMessage(sender, "Cyro DMG Bonus set to " + igcyro + "%");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid Cryo DMG Bonus value.");
+                    return;
+                }
+                break;
+            case "ehydro":
+                try {
+                    float ehydro = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float hydro = ehydro / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_WATER_ADD_HURT, hydro);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_WATER_ADD_HURT));
+                    float ighydro = hydro * 100;
+                    CommandHandler.sendMessage(sender, "Hydro DMG Bonus set to " + ighydro + "%");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid Hydro DMG Bonus value.");
+                    return;
+                }
+                break;
+            case "eanemo":
+                try {
+                    float eanemo = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float anemo = eanemo / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_WIND_ADD_HURT, anemo);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_WIND_ADD_HURT));
+                    float iganemo = anemo * 100;
+                    CommandHandler.sendMessage(sender, "Anemo DMG Bonus set to " + iganemo + "%");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid Anemo DMG Bonus value.");
+                    return;
+                }
+                break;
+            case "egeo":
+                try {
+                    float egeo = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float geo = egeo / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_ROCK_ADD_HURT, geo);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_ROCK_ADD_HURT));
+                    float iggeo = geo * 100;
+                    CommandHandler.sendMessage(sender, "Geo DMG Bonus set to " + iggeo + "%");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid Geo DMG Bonus value.");
+                    return;
+                }
+                break;
+            case "ethunder":
+            case "eelec":
+                try {
+                    float eelec = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float elec = eelec / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_CRITICAL_HURT, elec);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_CRITICAL_HURT));
+                    float igelec = elec * 100;
+                    CommandHandler.sendMessage(sender, "Electro DMG Bonus set to " + igelec + "%");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid Electro DMG Bonus value.");
+                    return;
+                }
+                break;
+            case "ephys":
+                try {
+                    float ephys = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float phys = ephys / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_PHYSICAL_ADD_HURT, phys);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_PHYSICAL_ADD_HURT));
+                    float igphys = phys * 100;
+                    CommandHandler.sendMessage(sender, "Physical DMG Bonus set to " + igphys + "%");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid Physical DMG Bonus value.");
+                    return;
+                }
+                break;
+            case "edend":
+                try {
+                    float edend = Integer.parseInt(args.get(1));
+                    EntityAvatar entity = sender.getTeamManager().getCurrentAvatarEntity();
+                    float dend = edend / 10000;
+                    entity.setFightProperty(FightProperty.FIGHT_PROP_GRASS_ADD_HURT, dend);
+                    entity.getWorld().broadcastPacket(new PacketEntityFightPropUpdateNotify(entity, FightProperty.FIGHT_PROP_GRASS_ADD_HURT));
+                    float igdend = dend * 100;
+                    CommandHandler.sendMessage(sender, "Dendro DMG Bonus set to " + igdend + "%");
+                } catch (NumberFormatException ignored) {
+                    CommandHandler.sendMessage(sender, "Invalid Dendro DMG Bonus value.");
+                    return;
+                }
+                break;
+        }
+    }
+}

src/main/java/emu/grasscutter/command/commands/SetWorldLevelCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.props.PlayerProperty;
+
+import java.util.List;
+
+@Command(label = "setworldlevel", usage = "setworldlevel <level>",
+        description = "Sets your world level (Relog to see proper effects)",
+        aliases = {"setworldlvl"}, permission = "player.setworldlevel")
+public final class SetWorldLevelCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (sender == null) {
+            CommandHandler.sendMessage(null, "Run this command in-game.");
+            return; // TODO: set player's world level from console or other players
+        }
+
+        if (args.size() < 1) {
+            CommandHandler.sendMessage(sender, "Usage: setworldlevel <level>");
+            return;
+        }
+
+        try {
+            int level = Integer.parseInt(args.get(0));
+
+            // Set in both world and player props
+            sender.getWorld().setWorldLevel(level);
+            sender.setProperty(PlayerProperty.PROP_PLAYER_WORLD_LEVEL, level);
+
+            sender.dropMessage("World level set to " + level + ".");
+        } catch (NumberFormatException ignored) {
+            CommandHandler.sendMessage(null, "Invalid world level.");
+        }
+    }
+}

src/main/java/emu/grasscutter/command/commands/SpawnCommand.java

+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.data.GenshinData;
+import emu.grasscutter.data.def.MonsterData;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.entity.EntityMonster;
+import emu.grasscutter.utils.Position;
+
+import java.util.List;
+
+@Command(label = "spawn", usage = "spawn <entityId|entityName> [level] [amount]",
+        description = "Spawns an entity near you", permission = "server.spawn")
+public final class SpawnCommand implements CommandHandler {
+
+    @Override
+    public void execute(GenshinPlayer sender, List<String> args) {
+        if (sender == null) {
+            CommandHandler.sendMessage(null, "Run this command in-game.");
+            return;
+        }
+
+        if (args.size() < 1) {
+            CommandHandler.sendMessage(sender, "Usage: spawn <entityId|entityName> [amount]");
+            return;
+        }
+
+        try {
+            int entity = Integer.parseInt(args.get(0));
+            int level = args.size() > 1 ? Integer.parseInt(args.get(1)) : 1;
+            int amount = args.size() > 2 ? Integer.parseInt(args.get(2)) : 1;
+
+            MonsterData entityData = GenshinData.getMonsterDataMap().get(entity);
+            if (entityData == null) {
+                CommandHandler.sendMessage(sender, "Invalid entity id.");
+                return;
+            }
+
+            float range = (5f + (.1f * amount));
+            for (int i = 0; i < amount; i++) {
+                Position pos = sender.getPos().clone().addX((float) (Math.random() * range) - (range / 2)).addY(3f).addZ((float) (Math.random() * range) - (range / 2));
+                EntityMonster monster = new EntityMonster(sender.getScene(), entityData, pos, level);
+                sender.getScene().addEntity(monster);
+            }
+            CommandHandler.sendMessage(sender, String.format("Spawned %s of %s.", amount, entity));
+        } catch (NumberFormatException ignored) {
+            CommandHandler.sendMessage(sender, "Invalid item or player ID.");
+        }
+    }
+}