Add permanent punishments

- Punishments are now saved as JSON in files named after their targets
- Each punishment type now has its own Java class
- Each file contains a list of JSON objects that is updated every time something changes (e.g. player muted, banned or unbanned)
- Punishments have a unique ID now; if something changes, the new version is added to the list and overwrites the old version
- 'Undo' has been renamed to 'cancel'
- You can no longer mute or ban players if they are already muted or banned

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,34 +0,0 @@
----
-name: Bug report
-about: Report bugs to help us make the plugin better and more reliable.
-title: "[BUG]"
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Server**
-Please provide information about the plugin version and the server.
-This section should include:
-1. Server Software
-2. Server version
-3. Plugin Version you are using
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this plugin
-title: "[REQUEST]"
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

build.gradle

@@ -1,6 +1,6 @@
 plugins {
     id 'java'
-    id("xyz.jpenilla.run-paper") version "2.3.1"
+    id("xyz.jpenilla.run-paper") version "${runPaperVersion}"
 }
 
 group = 'de.shiewk'
@@ -30,17 +30,17 @@ runPaper {
 }
 
 runServer {
-    minecraftVersion("1.21.7")
+    minecraftVersion("1.21.11")
     downloadPlugins {
         // for testing from other client versions
-        modrinth("ViaVersion", "5.4.1")
+        modrinth("ViaVersion", viaVersionVersion)
-        modrinth("ViaBackwards", "5.4.1")
+        modrinth("ViaBackwards", viaVersionVersion)
     }
 }
 
 dependencies {
-    //compileOnly "io.papermc.paper:paper-api:1.21.4-R0.1-SNAPSHOT"
+    //compileOnly "io.papermc.paper:paper-api:${apiVersion}"
-    compileOnly 'dev.folia:folia-api:1.21.4-R0.1-SNAPSHOT'
+    compileOnly "dev.folia:folia-api:${apiVersion}"
 }
 
 jar {

docs/config.md

@@ -0,0 +1,15 @@
+# SModeration config
+
+| Key                      | What it does                                                                                                           |
+|--------------------------|------------------------------------------------------------------------------------------------------------------------|
+| socialspy-commands       | The commands that `/socialspy` will listen to.                                                                         |
+| force-reason             | Whether a reason is required for every punishment.                                                                     |  
+| muted-forbidden-commands | Commands that players are not allowed to run while they are muted.                                                     |
+| features                 | Controls which plugin features are enabled.                                                                            |
+| features.punishments     | Whether the plugin provides punishing features (kick, ban, mute)                                                       |
+| features.smodmenu        | If punishments are enabled, controls whether the SMod Menu can be opened. Has no effect when punishments are disabled. |
+| features.invsee          | Whether the plugin provides invsee feature                                                                             |
+| features.enderchestsee   | Whether the plugin provides enderchestsee feature                                                                      |
+| features.offlinetp       | Whether the plugin provides the offlinetp feature                                                                      |
+| features.socialspy       | Whether the plugin provides the SocialSpy feature                                                                      |
+| features.vanish          | Whether the plugin provides the vanish feature                                                                         |

gradle.properties

@@ -1 +1,4 @@
-pluginVersion = 1.6.0
+pluginVersion = 1.8.2
+apiVersion = 1.21.4-R0.1-SNAPSHOT
+runPaperVersion = 3.0.2
+viaVersionVersion = 5.8.0

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.11-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.0-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/main/java/de/shiewk/smoderation/paper/SModerationPaper.java

@@ -1,85 +1,144 @@
 package de.shiewk.smoderation.paper;
 
+import com.google.gson.Gson;
 import de.shiewk.smoderation.paper.command.*;
-import de.shiewk.smoderation.paper.config.SModerationConfig;
 import de.shiewk.smoderation.paper.input.ChatInput;
 import de.shiewk.smoderation.paper.input.ChatInputListener;
 import de.shiewk.smoderation.paper.listener.*;
-import de.shiewk.smoderation.paper.storage.PunishmentContainer;
+import de.shiewk.smoderation.paper.punishments.Ban;
+import de.shiewk.smoderation.paper.punishments.Kick;
+import de.shiewk.smoderation.paper.punishments.Mute;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
+import de.shiewk.smoderation.paper.translation.TranslatorManager;
+import de.shiewk.smoderation.paper.util.SModLegacy;
 import de.shiewk.smoderation.paper.util.SchedulerUtil;
 import io.papermc.paper.command.brigadier.Commands;
 import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents;
-import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.key.Key;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.format.TextColor;
 import net.kyori.adventure.text.logger.slf4j.ComponentLogger;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.Tag;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
 import org.bukkit.plugin.java.JavaPlugin;
 
-import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
 
 import static de.shiewk.smoderation.paper.command.VanishCommand.isVanished;
 import static de.shiewk.smoderation.paper.command.VanishCommand.toggleVanish;
-import static net.kyori.adventure.text.Component.text;
 import static org.bukkit.Bukkit.getPluginManager;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class SModerationPaper extends JavaPlugin {
 
-    public static final PunishmentContainer container = new PunishmentContainer();
-    public static ComponentLogger LOGGER = null;
-    public static SModerationPaper PLUGIN = null;
-    public static SModerationConfig CONFIG = null;
-    public static File SAVE_FILE = null;
-    private static SkinTextureProvider textureProvider = null;
-
     public static final TextColor PRIMARY_COLOR = TextColor.color(212, 0, 255);
     public static final TextColor SECONDARY_COLOR = TextColor.color(52, 143, 255);
     public static final TextColor INACTIVE_COLOR = NamedTextColor.GRAY;
-    public static final TextComponent CHAT_PREFIX = text("SM \u00BB ").color(PRIMARY_COLOR);
+
+    public static final Gson gson = new Gson();
+    public static ComponentLogger LOGGER = null;
+    public static SModerationPaper PLUGIN = null;
+    private static SkinTextureProvider textureProvider = null;
+
+    private final TranslatorManager translatorManager = new TranslatorManager(
+            Key.key("smoderation", "translations"),
+            createMiniMessage(),
+            "smoderation/translations/",
+            new Locale[] {
+                    Locale.forLanguageTag("en-US"),
+                    Locale.forLanguageTag("de-DE")
+            }
+    );
+
+    private PunishmentManager punishmentManager;
+
+    public static FileConfiguration config() {
+        return PLUGIN.getConfig();
+    }
 
     @Override
     public void onLoad() {
         LOGGER = getComponentLogger();
+        LOGGER.info("Folia: {}", SchedulerUtil.isFolia ? "yes" : "no");
         PLUGIN = this;
-        CONFIG = new SModerationConfig(this.getConfig(), this);
+        LOGGER.info("Loading translations");
-        SAVE_FILE = new File(this.getDataFolder().getAbsolutePath() + "/container.gz");
+        translatorManager.load();
+        updateConfig();
+
+        this.punishmentManager = new PunishmentManager(getDataPath().resolve("punishments.v2"));
+        this.punishmentManager.registerType("mute", new Mute.Factory());
+        this.punishmentManager.registerType("ban", new Ban.Factory());
+        this.punishmentManager.registerType("kick", new Kick.Factory());
+
+        SModLegacy.migrateV1PunishmentsFile(
+                this.punishmentManager,
+                getDataPath().resolve("container.gz"),
+                getDataPath().resolve("v1-backup.gz")
+        );
+    }
+
+    public boolean isFeatureEnabled(String feature){
+        return getConfig().getBoolean("features."+feature, true);
     }
 
     @Override
     public void onEnable() {
-        CONFIG.reload();
+        if (isFeatureEnabled("punishments")) listen(new PunishmentListener(punishmentManager));
+        if (isFeatureEnabled("punishments")) listen(new CacheListener(punishmentManager));
+        if (isFeatureEnabled("invsee")) listen(new InvSeeListener());
+        if (isFeatureEnabled("enderchestsee")) listen(new EnderchestSeeListener());
+        if (isFeatureEnabled("socialspy")) listen(new SocialSpyListener());
+        if (isFeatureEnabled("vanish")) listen(new VanishListener());
 
-        getPluginManager().registerEvents(new PunishmentListener(), this);
+        listen(new CustomInventoryListener());
-        getPluginManager().registerEvents(new CustomInventoryListener(), this);
+        listen(new ChatInputListener());
-        getPluginManager().registerEvents(new InvSeeListener(), this);
-        getPluginManager().registerEvents(new EnderchestSeeListener(), this);
-        getPluginManager().registerEvents(new VanishListener(), this);
-        getPluginManager().registerEvents(new ChatInputListener(), this);
-        getPluginManager().registerEvents(new SocialSpyListener(), this);
 
         getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, event -> {
             Commands commands = event.registrar();
 
-            registerCommand(commands, new KickCommand());
+            if (isFeatureEnabled("punishments")){
-            registerCommand(commands, new ModLogsCommand());
+                registerCommand(commands, new KickCommand(punishmentManager));
-            registerCommand(commands, new SModCommand());
+                registerCommand(commands, new ModLogsCommand(punishmentManager));
-            registerCommand(commands, new InvseeCommand());
+                registerCommand(commands, new UnmuteCommand(punishmentManager));
-            registerCommand(commands, new EnderchestSeeCommand());
+                registerCommand(commands, new UnbanCommand(punishmentManager));
-            registerCommand(commands, new SocialSpyCommand());
+                registerCommand(commands, new MuteCommand(punishmentManager));
-            registerCommand(commands, new VanishCommand());
+                registerCommand(commands, new BanCommand(punishmentManager));
-            registerCommand(commands, new UnmuteCommand());
+
-            registerCommand(commands, new UnbanCommand());
+                if (isFeatureEnabled("smodmenu")){
-            registerCommand(commands, new MuteCommand());
+                    registerCommand(commands, new SModCommand(punishmentManager));
-            registerCommand(commands, new BanCommand());
+                }
+            }
+
+            if (isFeatureEnabled("invsee")) registerCommand(commands, new InvseeCommand());
+            if (isFeatureEnabled("enderchestsee")) registerCommand(commands, new EnderchestSeeCommand());
+            if (isFeatureEnabled("socialspy")) registerCommand(commands, new SocialSpyCommand());
+            if (isFeatureEnabled("vanish")) registerCommand(commands, new VanishCommand());
+            if (isFeatureEnabled("offlinetp")) registerCommand(commands, new OfflineTPCommand());
         });
 
-        SchedulerUtil.scheduleGlobalRepeating(PLUGIN, CustomInventoryListener::onTick, 1, 1);
+        if (SchedulerUtil.isFolia){
+            // Normal ticking logic can cause issues on Folia
+            listen(new FoliaInventoryUpdatingListener());
+        } else {
+            SchedulerUtil.scheduleGlobalRepeating(PLUGIN, CustomInventoryListener::tickAllPaper, 1, 1);
+        }
+
         SchedulerUtil.scheduleGlobalRepeating(PLUGIN, ChatInput::tickAll, 1, 1);
+    }
 
-        container.load(SAVE_FILE);
+    private void listen(Listener listener) {
-
+        getPluginManager().registerEvents(listener, this);
-        LOGGER.info("Folia: {}", SchedulerUtil.isFolia ? "yes" : "no");
     }
 
     private void registerCommand(Commands commands, CommandProvider provider){
@@ -92,7 +151,6 @@ public final class SModerationPaper extends JavaPlugin {
 
     @Override
     public void onDisable() {
-        SModerationPaper.container.save(SModerationPaper.SAVE_FILE);
         for (Player player : Bukkit.getOnlinePlayers()) {
             // in case players are still vanished when the server shuts down
             if (isVanished(player)){
@@ -108,4 +166,58 @@ public final class SModerationPaper extends JavaPlugin {
     public static void setTextureProvider(SkinTextureProvider textureProvider) {
         SModerationPaper.textureProvider = textureProvider;
     }
+
+    private MiniMessage createMiniMessage() {
+        return MiniMessage.builder()
+                .tags(TagResolver.builder()
+                        .resolver(TagResolver.resolver("primary", Tag.styling(style -> style.color(PRIMARY_COLOR))))
+                        .resolver(TagResolver.resolver("secondary", Tag.styling(style -> style.color(SECONDARY_COLOR))))
+                        .resolver(TagResolver.standard())
+                        .build()
+                )
+                .build();
+    }
+
+    private void updateConfig() {
+        LOGGER.info("Updating config");
+        try {
+            FileConfiguration config = getConfig();
+
+            InputStream defaultConfigStream = getResource("default-config.yml");
+            if (defaultConfigStream == null) {
+                throw new IllegalStateException("Default config not found in JAR; could not load");
+            }
+
+            YamlConfiguration defaultConfig = YamlConfiguration.loadConfiguration(new InputStreamReader(defaultConfigStream));
+
+            boolean changedSomething = false;
+            for (String key : defaultConfig.getKeys(true)) {
+                if (!config.contains(key)) {
+                    // There's a new key in the default config
+                    config.set(key, defaultConfig.get(key));
+                    changedSomething = true;
+                }
+
+                List<String> defaultComments = new ArrayList<>(defaultConfig.getComments(key));
+                List<String> comments = new ArrayList<>(config.getComments(key));
+                defaultComments.removeIf(Objects::isNull);
+                comments.removeIf(Objects::isNull);
+
+                if (!defaultComments.equals(comments)) {
+                    // Comments changed
+                    config.setComments(key, defaultConfig.getComments(key));
+                    changedSomething = true;
+                }
+            }
+
+            // Save the updated configuration file
+            if (changedSomething){
+                LOGGER.info("Changing config file to add new options/documentation");
+                saveConfig();
+            }
+
+        } catch (Exception e) {
+            throw new RuntimeException("Could not update config", e);
+        }
+    }
 }

src/main/java/de/shiewk/smoderation/paper/command/BanCommand.java

@@ -8,7 +8,9 @@ import com.mojang.brigadier.tree.LiteralCommandNode;
 import de.shiewk.smoderation.paper.SModerationPaper;
 import de.shiewk.smoderation.paper.command.argument.DurationArgument;
 import de.shiewk.smoderation.paper.command.argument.PlayerUUIDArgument;
+import de.shiewk.smoderation.paper.punishments.Ban;
 import de.shiewk.smoderation.paper.punishments.Punishment;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
 import de.shiewk.smoderation.paper.util.CommandUtil;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
 import org.bukkit.Bukkit;
@@ -21,8 +23,15 @@ import java.util.UUID;
 import static io.papermc.paper.command.brigadier.Commands.argument;
 import static io.papermc.paper.command.brigadier.Commands.literal;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class BanCommand implements CommandProvider {
 
+    private final PunishmentManager punishmentManager;
+
+    public BanCommand(PunishmentManager punishmentManager) {
+        this.punishmentManager = punishmentManager;
+    }
+
     @Override
     public LiteralCommandNode<CommandSourceStack> getCommandNode() {
         return literal("ban")
@@ -39,13 +48,13 @@ public final class BanCommand implements CommandProvider {
     }
 
     private int banWithoutReason(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
-        if (SModerationPaper.CONFIG.shouldForceReason()){
+        if (SModerationPaper.config().getBoolean("force-reason", false)){
-            CommandUtil.error("Please provide a reason.");
+            CommandUtil.errorTranslatable("smod.command.ban.fail.forceReason");
         }
         UUID sender = CommandUtil.getSenderUUID(context.getSource());
         UUID target = context.getArgument("player", UUID.class);
         long duration = context.getArgument("duration", Long.class);
-        executeBan(sender, target, duration, Punishment.DEFAULT_REASON);
+        executeBan(punishmentManager, sender, target, duration, SModerationPaper.config().getString("default-reason", "No reason provided."));
         return Command.SINGLE_SUCCESS;
     }
 
@@ -54,34 +63,38 @@ public final class BanCommand implements CommandProvider {
         UUID target = context.getArgument("player", UUID.class);
         long duration = context.getArgument("duration", Long.class);
         String reason = StringArgumentType.getString(context, "reason");
-        executeBan(sender, target, duration, reason);
+        executeBan(punishmentManager, sender, target, duration, reason);
         return Command.SINGLE_SUCCESS;
     }
 
-    public static void executeBan(UUID sender, UUID target, long duration, String reason) throws CommandSyntaxException {
+    public static void executeBan(PunishmentManager manager, UUID sender, UUID target, long duration, String reason) throws CommandSyntaxException {
         Player targetPlayer = Bukkit.getPlayer(target);
         if (duration == 0){
             if (targetPlayer == null){
-                CommandUtil.error("You can't ban an offline player for less than 1ms.");
+                CommandUtil.errorTranslatable("smod.command.ban.fail.tooShort");
             } else {
-                KickCommand.executeKick(sender, targetPlayer, reason);
+                KickCommand.executeKick(manager, sender, targetPlayer, reason);
             }
             return;
         }
         if (sender.equals(target)) {
-            CommandUtil.error("You can't ban yourself.");
+            CommandUtil.errorTranslatable("smod.command.ban.fail.self");
         } else {
             if (targetPlayer != null && targetPlayer.hasPermission("smod.preventban")){
-                CommandUtil.error("This player can't be banned.");
+                CommandUtil.errorTranslatable("smod.command.ban.fail.protect");
             } else {
-                final Punishment punishment = Punishment.ban(
+                if (!manager.byTargetUUID(target, p -> p instanceof Ban ban && ban.isActive()).isEmpty()) {
+                    CommandUtil.errorTranslatable("smod.command.ban.fail.alreadyBanned");
+                }
+                Punishment punishment = new Ban(
+                        Punishment.generateUUID(),
                         System.currentTimeMillis(),
-                        System.currentTimeMillis() + duration,
                         sender,
                         target,
-                        reason
+                        reason,
+                        duration
                 );
-                Punishment.issue(punishment, SModerationPaper.container);
+                manager.tryIssue(punishment);
             }
         }
     }

src/main/java/de/shiewk/smoderation/paper/command/CommandProvider.java

@@ -6,6 +6,7 @@ import io.papermc.paper.command.brigadier.CommandSourceStack;
 import java.util.Collection;
 import java.util.List;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public interface CommandProvider {
 
     LiteralCommandNode<CommandSourceStack> getCommandNode();

src/main/java/de/shiewk/smoderation/paper/command/EnderchestSeeCommand.java

@@ -7,16 +7,16 @@ import com.mojang.brigadier.tree.LiteralCommandNode;
 import de.shiewk.smoderation.paper.util.CommandUtil;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
 import io.papermc.paper.command.brigadier.argument.ArgumentTypes;
-import net.kyori.adventure.text.Component;
 import org.bukkit.entity.Player;
 
 import java.util.Collection;
 import java.util.List;
 
-import static de.shiewk.smoderation.paper.SModerationPaper.*;
 import static io.papermc.paper.command.brigadier.Commands.argument;
 import static io.papermc.paper.command.brigadier.Commands.literal;
+import static net.kyori.adventure.text.Component.translatable;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class EnderchestSeeCommand implements CommandProvider {
 
     @Override
@@ -32,11 +32,7 @@ public final class EnderchestSeeCommand implements CommandProvider {
     private int openEnderChest(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
         Player sender = CommandUtil.getExecutingPlayer(context.getSource());
         Player target = CommandUtil.getPlayerSingle(context, "player");
-        sender.sendMessage(CHAT_PREFIX.append(
+        sender.sendMessage(translatable("smod.command.ecsee.opening", target.teamDisplayName()));
-                Component.text("Opening ender chest of ").color(PRIMARY_COLOR)
-                        .append(target.teamDisplayName().colorIfAbsent(SECONDARY_COLOR))
-                        .append(Component.text("."))
-        ));
         sender.openInventory(target.getEnderChest());
         return Command.SINGLE_SUCCESS;
     }

src/main/java/de/shiewk/smoderation/paper/command/InvseeCommand.java

@@ -14,11 +14,11 @@ import org.bukkit.entity.Player;
 import java.util.Collection;
 import java.util.List;
 
-import static de.shiewk.smoderation.paper.SModerationPaper.*;
 import static io.papermc.paper.command.brigadier.Commands.argument;
 import static io.papermc.paper.command.brigadier.Commands.literal;
-import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.Component.translatable;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class InvseeCommand implements CommandProvider {
 
     @Override
@@ -44,13 +44,9 @@ public final class InvseeCommand implements CommandProvider {
         Player sender = CommandUtil.getExecutingPlayer(context.getSource());
         Player target = CommandUtil.getPlayerSingle(context, "player");
         if (sender.equals(target)){
-            CommandUtil.error("You can't open your own inventory.");
+            CommandUtil.errorTranslatable("smod.command.invsee.fail.self");
         }
-        sender.sendMessage(CHAT_PREFIX.append(
+        sender.sendMessage(translatable("smod.command.invsee.opening", target.teamDisplayName()));
-                text("Opening inventory of ").color(PRIMARY_COLOR)
-                        .append(target.teamDisplayName().colorIfAbsent(SECONDARY_COLOR))
-                        .append(text("."))
-        ));
         new InvSeeInventory(sender, target).open();
         return Command.SINGLE_SUCCESS;
     }
@@ -59,13 +55,9 @@ public final class InvseeCommand implements CommandProvider {
         Player sender = CommandUtil.getExecutingPlayer(context.getSource());
         Player target = CommandUtil.getPlayerSingle(context, "player");
         if (sender.equals(target)){
-            CommandUtil.error("You can't open your own inventory.");
+            CommandUtil.errorTranslatable("smod.command.invsee.fail.self");
         }
-        sender.sendMessage(CHAT_PREFIX.append(
+        sender.sendMessage(translatable("smod.command.invsee.opening", target.teamDisplayName()));
-                text("Opening inventory of ").color(PRIMARY_COLOR)
-                        .append(target.teamDisplayName().colorIfAbsent(SECONDARY_COLOR))
-                        .append(text("."))
-        ));
         new InvSeeEquipmentInventory(sender, target).open();
         return Command.SINGLE_SUCCESS;
     }

src/main/java/de/shiewk/smoderation/paper/command/KickCommand.java

@@ -6,7 +6,9 @@ import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.mojang.brigadier.tree.LiteralCommandNode;
 import de.shiewk.smoderation.paper.SModerationPaper;
+import de.shiewk.smoderation.paper.punishments.Kick;
 import de.shiewk.smoderation.paper.punishments.Punishment;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
 import de.shiewk.smoderation.paper.util.CommandUtil;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
 import io.papermc.paper.command.brigadier.argument.ArgumentTypes;
@@ -19,8 +21,15 @@ import java.util.UUID;
 import static io.papermc.paper.command.brigadier.Commands.argument;
 import static io.papermc.paper.command.brigadier.Commands.literal;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class KickCommand implements CommandProvider {
 
+    private final PunishmentManager punishmentManager;
+
+    public KickCommand(PunishmentManager punishmentManager) {
+        this.punishmentManager = punishmentManager;
+    }
+
     @Override
     public LiteralCommandNode<CommandSourceStack> getCommandNode() {
         return literal("kick")
@@ -38,34 +47,35 @@ public final class KickCommand implements CommandProvider {
         UUID sender = CommandUtil.getSenderUUID(context.getSource());
         Player target = CommandUtil.getPlayerSingle(context, "player");
         String reason = StringArgumentType.getString(context, "reason");
-        executeKick(sender, target, reason);
+        executeKick(punishmentManager, sender, target, reason);
         return Command.SINGLE_SUCCESS;
     }
 
     private int kickWithoutReason(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
-        if (SModerationPaper.CONFIG.shouldForceReason()){
+        if (SModerationPaper.config().getBoolean("force-reason", false)){
-            CommandUtil.error("Please provide a reason.");
+            CommandUtil.errorTranslatable("smod.command.kick.fail.forceReason");
         }
         UUID sender = CommandUtil.getSenderUUID(context.getSource());
         Player target = CommandUtil.getPlayerSingle(context, "player");
-        executeKick(sender, target, Punishment.DEFAULT_REASON);
+        executeKick(punishmentManager, sender, target, SModerationPaper.config().getString("default-reason", "No reason provided."));
         return Command.SINGLE_SUCCESS;
     }
 
-    public static void executeKick(UUID sender, Player target, String reason) throws CommandSyntaxException {
+    public static void executeKick(PunishmentManager manager, UUID sender, Player target, String reason) throws CommandSyntaxException {
         UUID targetId = target.getUniqueId();
         if (sender.equals(targetId)) {
-            CommandUtil.error("You can't kick yourself.");
+            CommandUtil.errorTranslatable("smod.command.kick.fail.self");
         } else if (target.hasPermission("smod.preventkick")){
-            CommandUtil.error("This player can't be kicked.");
+            CommandUtil.errorTranslatable("smod.command.kick.fail.protect");
         }
-        final Punishment punishment = Punishment.kick(
+        Punishment punishment = new Kick(
+                Punishment.generateUUID(),
                 System.currentTimeMillis(),
                 sender,
                 targetId,
                 reason
         );
-        Punishment.issue(punishment, SModerationPaper.container);
+        manager.tryIssue(punishment);
     }
 
     @Override

src/main/java/de/shiewk/smoderation/paper/command/ModLogsCommand.java

@@ -3,27 +3,34 @@ package de.shiewk.smoderation.paper.command;
 import com.mojang.brigadier.Command;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.tree.LiteralCommandNode;
-import de.shiewk.smoderation.paper.SModerationPaper;
 import de.shiewk.smoderation.paper.command.argument.PlayerUUIDArgument;
 import de.shiewk.smoderation.paper.punishments.Punishment;
-import de.shiewk.smoderation.paper.punishments.PunishmentType;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
+import de.shiewk.smoderation.paper.punishments.TimedPunishment;
 import de.shiewk.smoderation.paper.util.CommandUtil;
 import de.shiewk.smoderation.paper.util.PlayerUtil;
 import de.shiewk.smoderation.paper.util.TimeUtil;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
-import net.kyori.adventure.text.Component;
 import org.bukkit.command.CommandSender;
 
 import java.util.Collection;
 import java.util.List;
 import java.util.UUID;
 
-import static de.shiewk.smoderation.paper.SModerationPaper.*;
 import static io.papermc.paper.command.brigadier.Commands.argument;
 import static io.papermc.paper.command.brigadier.Commands.literal;
+import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.Component.translatable;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class ModLogsCommand implements CommandProvider {
 
+    private final PunishmentManager punishmentManager;
+
+    public ModLogsCommand(PunishmentManager punishmentManager) {
+        this.punishmentManager = punishmentManager;
+    }
+
     @Override
     public LiteralCommandNode<CommandSourceStack> getCommandNode() {
         return literal("modlogs")
@@ -38,21 +45,23 @@ public final class ModLogsCommand implements CommandProvider {
         CommandSender sender = context.getSource().getSender();
         UUID uuid = context.getArgument("player", UUID.class);
         String name = PlayerUtil.offlinePlayerName(uuid);
-        sender.sendMessage(CHAT_PREFIX.append(Component.text("Player ").color(PRIMARY_COLOR)
+        sender.sendMessage(translatable("smod.command.modlogs.heading", text(name), text(uuid.toString())));
-                .append(Component.text(name).color(SECONDARY_COLOR))
+        List<Punishment> punishments = punishmentManager.byTargetUUID(uuid);
-                .append(Component.text(" (%s)".formatted(uuid)).color(INACTIVE_COLOR))));
-        final List<Punishment> punishments = SModerationPaper.container.findAll(p -> p.to.equals(uuid) && p.isActive());
         for (Punishment punishment : punishments) {
-            sender.sendMessage(Component.text("- is currently ").color(PRIMARY_COLOR)
+            if (punishment instanceof TimedPunishment timed && timed.isActive()){
-                    .append(Component.text(punishment.type == PunishmentType.BAN ? "banned" : "muted").color(SECONDARY_COLOR))
+                if (timed.isPermanent()){
-                    .append(Component.text(" until ").color(PRIMARY_COLOR))
+                    sender.sendMessage(translatable("smod.command.modlogs." + punishment.getType() + ".permanent", text(punishment.getReason())));
-                    .append(Component.text(TimeUtil.calendarTimestamp(punishment.until)).color(SECONDARY_COLOR))
+                } else {
-                    .append(Component.text(" (in %s)".formatted(TimeUtil.formatTimeLong(punishment.until - System.currentTimeMillis()))).color(INACTIVE_COLOR))
+                    sender.sendMessage(translatable("smod.command.modlogs." + punishment.getType(),
-                    .append(Component.text(". Reason: ").color(PRIMARY_COLOR))
+                            TimeUtil.calendarTimestamp(timed.getExpiry()),
-                    .append(Component.text(punishment.reason).color(SECONDARY_COLOR)));
+                            TimeUtil.formatTimeLong(timed.getExpiry() - System.currentTimeMillis()),
+                            text(punishment.getReason())
+                    ));
+                }
+            }
         }
         if (punishments.isEmpty()){
-            sender.sendMessage(Component.text("- has no punishments.").color(PRIMARY_COLOR));
+            sender.sendMessage(translatable("smod.command.modlogs.none"));
         }
         return Command.SINGLE_SUCCESS;
     }

src/main/java/de/shiewk/smoderation/paper/command/MuteCommand.java

@@ -8,7 +8,9 @@ import com.mojang.brigadier.tree.LiteralCommandNode;
 import de.shiewk.smoderation.paper.SModerationPaper;
 import de.shiewk.smoderation.paper.command.argument.DurationArgument;
 import de.shiewk.smoderation.paper.command.argument.PlayerUUIDArgument;
+import de.shiewk.smoderation.paper.punishments.Mute;
 import de.shiewk.smoderation.paper.punishments.Punishment;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
 import de.shiewk.smoderation.paper.util.CommandUtil;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
 import org.bukkit.Bukkit;
@@ -21,8 +23,15 @@ import java.util.UUID;
 import static io.papermc.paper.command.brigadier.Commands.argument;
 import static io.papermc.paper.command.brigadier.Commands.literal;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class MuteCommand implements CommandProvider {
 
+    private final PunishmentManager punishmentManager;
+
+    public MuteCommand(PunishmentManager punishmentManager) {
+        this.punishmentManager = punishmentManager;
+    }
+
     @Override
     public LiteralCommandNode<CommandSourceStack> getCommandNode() {
         return literal("mute")
@@ -39,13 +48,13 @@ public final class MuteCommand implements CommandProvider {
     }
 
     private int muteWithoutReason(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
-        if (SModerationPaper.CONFIG.shouldForceReason()){
+        if (SModerationPaper.config().getBoolean("force-reason", false)){
-            CommandUtil.error("Please provide a reason.");
+            CommandUtil.errorTranslatable("smod.command.mute.fail.forceReason");
         }
         UUID sender = CommandUtil.getSenderUUID(context.getSource());
         UUID target = context.getArgument("player", UUID.class);
         long duration = context.getArgument("duration", Long.class);
-        executeMute(sender, target, duration, Punishment.DEFAULT_REASON);
+        executeMute(punishmentManager, sender, target, duration, SModerationPaper.config().getString("default-reason", "No reason provided."));
         return Command.SINGLE_SUCCESS;
     }
 
@@ -54,26 +63,33 @@ public final class MuteCommand implements CommandProvider {
         UUID target = context.getArgument("player", UUID.class);
         long duration = context.getArgument("duration", Long.class);
         String reason = StringArgumentType.getString(context, "reason");
-        executeMute(sender, target, duration, reason);
+        executeMute(punishmentManager, sender, target, duration, reason);
         return Command.SINGLE_SUCCESS;
     }
 
-    public static void executeMute(UUID sender, UUID target, long duration, String reason) throws CommandSyntaxException {
+    public static void executeMute(PunishmentManager manager, UUID sender, UUID target, long duration, String reason) throws CommandSyntaxException {
+        if (duration == 0){
+            CommandUtil.errorTranslatable("smod.command.mute.fail.tooShort");
+        }
         if (sender.equals(target)) {
-            CommandUtil.error("You can't mute yourself.");
+            CommandUtil.errorTranslatable("smod.command.mute.fail.self");
         } else {
             Player targetPlayer = Bukkit.getPlayer(target);
             if (targetPlayer != null && targetPlayer.hasPermission("smod.preventmute")){
-                CommandUtil.error("This player can't be muted.");
+                CommandUtil.errorTranslatable("smod.command.mute.fail.protect");
             } else {
-                final Punishment punishment = Punishment.mute(
+                if (!manager.byTargetUUID(target, p -> p instanceof Mute mute && mute.isActive()).isEmpty()) {
+                    CommandUtil.errorTranslatable("smod.command.mute.fail.alreadyMuted");
+                }
+                Punishment punishment = new Mute(
+                        Punishment.generateUUID(),
                         System.currentTimeMillis(),
-                        System.currentTimeMillis() + duration,
                         sender,
                         target,
-                        reason
+                        reason,
+                        duration
                 );
-                Punishment.issue(punishment, SModerationPaper.container);
+                manager.tryIssue(punishment);
             }
         }
     }

src/main/java/de/shiewk/smoderation/paper/command/OfflineTPCommand.java

@@ -0,0 +1,62 @@
+package de.shiewk.smoderation.paper.command;
+
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import de.shiewk.smoderation.paper.command.argument.OfflinePlayerArgument;
+import de.shiewk.smoderation.paper.util.CommandUtil;
+import de.shiewk.smoderation.paper.util.PlayerUtil;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerTeleportEvent;
+
+import java.util.Collection;
+import java.util.List;
+
+import static io.papermc.paper.command.brigadier.Commands.argument;
+import static io.papermc.paper.command.brigadier.Commands.literal;
+import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.Component.translatable;
+
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
+public final class OfflineTPCommand implements CommandProvider {
+
+    @Override
+    public LiteralCommandNode<CommandSourceStack> getCommandNode() {
+        return literal("offlinetp")
+            .requires(CommandUtil.requirePermission("smod.offlinetp"))
+            .then(argument("player", new OfflinePlayerArgument())
+                    .executes(this::offlineTeleport)
+            )
+            .build();
+    }
+
+    private int offlineTeleport(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
+        Player sender = CommandUtil.getExecutingPlayer(context.getSource());
+        OfflinePlayer player = context.getArgument("player", OfflinePlayer.class);
+
+        Location location = player.getLocation();
+
+        if (location == null) {
+            CommandUtil.errorTranslatable("smod.command.offlinetp.fail.unknown");
+        }
+
+        sender.teleportAsync(location, PlayerTeleportEvent.TeleportCause.COMMAND);
+        sender.sendMessage(translatable("smod.command.offlinetp.teleporting", text(PlayerUtil.offlinePlayerName(player.getUniqueId()))));
+
+        return Command.SINGLE_SUCCESS;
+    }
+
+    @Override
+    public String getCommandDescription() {
+        return "Teleports you to an offline player.";
+    }
+
+    @Override
+    public Collection<String> getAliases() {
+        return List.of("smodofflinetp");
+    }
+}

src/main/java/de/shiewk/smoderation/paper/command/SModCommand.java

@@ -4,8 +4,8 @@ import com.mojang.brigadier.Command;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.mojang.brigadier.tree.LiteralCommandNode;
-import de.shiewk.smoderation.paper.SModerationPaper;
 import de.shiewk.smoderation.paper.inventory.SModMenu;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
 import de.shiewk.smoderation.paper.util.CommandUtil;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
 import org.bukkit.entity.Player;
@@ -15,8 +15,15 @@ import java.util.List;
 
 import static io.papermc.paper.command.brigadier.Commands.literal;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class SModCommand implements CommandProvider {
 
+    private final PunishmentManager punishmentManager;
+
+    public SModCommand(PunishmentManager punishmentManager) {
+        this.punishmentManager = punishmentManager;
+    }
+
     @Override
     public LiteralCommandNode<CommandSourceStack> getCommandNode() {
         return literal("smod")
@@ -27,7 +34,7 @@ public final class SModCommand implements CommandProvider {
 
     private int openMenu(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
         Player player = CommandUtil.getExecutingPlayer(context.getSource());
-        new SModMenu(player, SModerationPaper.container).open();
+        new SModMenu(player, punishmentManager).open();
         return Command.SINGLE_SUCCESS;
     }
 

src/main/java/de/shiewk/smoderation/paper/command/SocialSpyCommand.java

@@ -6,16 +6,15 @@ import com.mojang.brigadier.tree.LiteralCommandNode;
 import de.shiewk.smoderation.paper.listener.SocialSpyListener;
 import de.shiewk.smoderation.paper.util.CommandUtil;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
-import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.command.CommandSender;
 
 import java.util.Collection;
 import java.util.List;
 
-import static de.shiewk.smoderation.paper.SModerationPaper.CHAT_PREFIX;
 import static io.papermc.paper.command.brigadier.Commands.literal;
-import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.Component.translatable;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class SocialSpyCommand implements CommandProvider {
 
     @Override
@@ -29,17 +28,17 @@ public final class SocialSpyCommand implements CommandProvider {
     private int toggleSocialSpy(CommandContext<CommandSourceStack> context) {
         CommandSender sender = context.getSource().getSender();
         final boolean enabled = SocialSpyListener.toggle(sender);
-        sender.sendMessage(CHAT_PREFIX.append(text("SocialSpy ").append(
+        if (enabled){
-                enabled ?
+            sender.sendMessage(translatable("smod.command.socialspy.enabled"));
-                        text("enabled").color(NamedTextColor.GREEN) :
+        } else {
-                        text("disabled").color(NamedTextColor.RED)
+            sender.sendMessage(translatable("smod.command.socialspy.disabled"));
-        ).append(text("."))));
+        }
         return Command.SINGLE_SUCCESS;
     }
 
     @Override
     public String getCommandDescription() {
-        return "Enables socialspy mode (you can see private messages of other players)";
+        return "Enables SocialSpy mode (allows you to see private messages of other players)";
     }
 
     @Override

src/main/java/de/shiewk/smoderation/paper/command/UnbanCommand.java

@@ -1,12 +1,14 @@
 package de.shiewk.smoderation.paper.command;
 
+import com.mojang.brigadier.Command;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.mojang.brigadier.tree.LiteralCommandNode;
-import de.shiewk.smoderation.paper.SModerationPaper;
 import de.shiewk.smoderation.paper.command.argument.PlayerUUIDArgument;
+import de.shiewk.smoderation.paper.punishments.Ban;
 import de.shiewk.smoderation.paper.punishments.Punishment;
-import de.shiewk.smoderation.paper.punishments.PunishmentType;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
+import de.shiewk.smoderation.paper.punishments.TimedPunishment;
 import de.shiewk.smoderation.paper.util.CommandUtil;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
 
@@ -17,8 +19,15 @@ import java.util.UUID;
 import static io.papermc.paper.command.brigadier.Commands.argument;
 import static io.papermc.paper.command.brigadier.Commands.literal;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class UnbanCommand implements CommandProvider {
 
+    private final PunishmentManager punishmentManager;
+
+    public UnbanCommand(PunishmentManager punishmentManager) {
+        this.punishmentManager = punishmentManager;
+    }
+
     @Override
     public LiteralCommandNode<CommandSourceStack> getCommandNode() {
         return literal("unban")
@@ -32,16 +41,17 @@ public final class UnbanCommand implements CommandProvider {
     private int unbanPlayer(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
         UUID senderUUID = CommandUtil.getSenderUUID(context.getSource());
         UUID target = context.getArgument("player", UUID.class);
-        final Punishment punishment = SModerationPaper.container.find(
+        final List<Punishment> punishments = punishmentManager.byTargetUUID(
-                p -> p.to.equals(target) && p.isActive() && p.type == PunishmentType.BAN
+                target,
+                p -> p instanceof Ban ban && ban.isActive()
         );
-        if (punishment != null) {
+        for (Punishment punishment : punishments) {
-            punishment.undo(senderUUID);
+            punishmentManager.cancel((TimedPunishment) punishment, senderUUID);
-            punishment.broadcastUndo(SModerationPaper.container);
-        } else {
-            CommandUtil.error("This player is not banned.");
         }
-        return com.mojang.brigadier.Command.SINGLE_SUCCESS;
+        if (punishments.isEmpty()) {
+            CommandUtil.errorTranslatable("smod.command.unban.fail.notBanned");
+        }
+        return Command.SINGLE_SUCCESS;
     }
 
     @Override

src/main/java/de/shiewk/smoderation/paper/command/UnmuteCommand.java

@@ -4,10 +4,11 @@ import com.mojang.brigadier.Command;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.mojang.brigadier.tree.LiteralCommandNode;
-import de.shiewk.smoderation.paper.SModerationPaper;
 import de.shiewk.smoderation.paper.command.argument.PlayerUUIDArgument;
+import de.shiewk.smoderation.paper.punishments.Mute;
 import de.shiewk.smoderation.paper.punishments.Punishment;
-import de.shiewk.smoderation.paper.punishments.PunishmentType;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
+import de.shiewk.smoderation.paper.punishments.TimedPunishment;
 import de.shiewk.smoderation.paper.util.CommandUtil;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
 
@@ -18,8 +19,15 @@ import java.util.UUID;
 import static io.papermc.paper.command.brigadier.Commands.argument;
 import static io.papermc.paper.command.brigadier.Commands.literal;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class UnmuteCommand implements CommandProvider {
 
+    private final PunishmentManager punishmentManager;
+
+    public UnmuteCommand(PunishmentManager punishmentManager) {
+        this.punishmentManager = punishmentManager;
+    }
+
     @Override
     public LiteralCommandNode<CommandSourceStack> getCommandNode() {
         return literal("unmute")
@@ -33,14 +41,15 @@ public final class UnmuteCommand implements CommandProvider {
     private int unmutePlayer(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
         UUID senderUUID = CommandUtil.getSenderUUID(context.getSource());
         UUID target = context.getArgument("player", UUID.class);
-        final Punishment punishment = SModerationPaper.container.find(
+        final List<Punishment> punishments = punishmentManager.byTargetUUID(
-                p -> p.to.equals(target) && p.isActive() && p.type == PunishmentType.MUTE
+                target,
+                p -> p instanceof Mute mute && mute.isActive()
         );
-        if (punishment != null) {
+        for (Punishment punishment : punishments) {
-            punishment.undo(senderUUID);
+            punishmentManager.cancel((TimedPunishment) punishment, senderUUID);
-            punishment.broadcastUndo(SModerationPaper.container);
+        }
-        } else {
+        if (punishments.isEmpty()) {
-            CommandUtil.error("This player is not muted.");
+            CommandUtil.errorTranslatable("smod.command.unmute.fail.notBanned");
         }
         return Command.SINGLE_SUCCESS;
     }

src/main/java/de/shiewk/smoderation/paper/command/VanishCommand.java

@@ -4,8 +4,8 @@ import com.mojang.brigadier.Command;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.mojang.brigadier.tree.LiteralCommandNode;
-import de.shiewk.smoderation.paper.SModerationPaper;
 import de.shiewk.smoderation.paper.event.VanishToggleEvent;
+import de.shiewk.smoderation.paper.punishments.Punishment;
 import de.shiewk.smoderation.paper.util.CommandUtil;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
 import io.papermc.paper.command.brigadier.argument.ArgumentTypes;
@@ -24,8 +24,9 @@ import java.util.List;
 import static de.shiewk.smoderation.paper.SModerationPaper.*;
 import static io.papermc.paper.command.brigadier.Commands.argument;
 import static io.papermc.paper.command.brigadier.Commands.literal;
-import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.Component.*;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class VanishCommand implements CommandProvider {
 
     public static final NamespacedKey KEY_VANISHED = new NamespacedKey("smoderation", "vanished");
@@ -51,7 +52,7 @@ public final class VanishCommand implements CommandProvider {
     private int toggleVanishForTargets(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
         List<Player> targets = context.getArgument("targets", PlayerSelectorArgumentResolver.class).resolve(context.getSource());
         if (targets.isEmpty()){
-            CommandUtil.error("No player was found.");
+            CommandUtil.errorTranslatable("smod.command.vanish.fail.noPlayersFound");
         } else {
             for (Player target : targets) {
                 toggleVanish(target);
@@ -72,7 +73,7 @@ public final class VanishCommand implements CommandProvider {
 
     @Override
     public String getCommandDescription() {
-        return "Toggles vanish mode which prevents other players from seeing you're online";
+        return "Toggles vanish mode which prevents other players from seeing you're online.";
     }
 
     @Override
@@ -80,7 +81,7 @@ public final class VanishCommand implements CommandProvider {
         return List.of("smvanish", "smodvanish", "v", "smv");
     }
 
-    private static final ObjectArrayList<Player> vanishedPlayers = new ObjectArrayList<>(1);
+    private static final ObjectArrayList<Player> vanishedPlayers = new ObjectArrayList<>(0);
 
     public static void toggleVanish(Player player){
         final boolean newStatus = !isVanished(player);
@@ -91,15 +92,10 @@ public final class VanishCommand implements CommandProvider {
         }
         if (newStatus){
             vanishedPlayers.add(player);
-            for (CommandSender sender : SModerationPaper.container.collectBroadcastTargets()) {
+            for (CommandSender sender : Punishment.getBroadcastTargets()) {
-                sender.sendMessage(CHAT_PREFIX.append(
+                sender.sendMessage(translatable("smod.command.vanish.broadcast.on", player.teamDisplayName()));
-                        player.displayName().colorIfAbsent(SECONDARY_COLOR)
-                ).append(text()
-                        .content(" vanished.")
-                        .color(PRIMARY_COLOR)
-                ));
             }
-            player.sendMessage(CHAT_PREFIX.append(text("You are now vanished.").color(PRIMARY_COLOR)));
+            player.sendMessage(translatable("smod.command.vanish.toggle.on"));
             player.setVisibleByDefault(false);
             for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
                 if (onlinePlayer.hasPermission("smod.vanish.see")){
@@ -108,15 +104,10 @@ public final class VanishCommand implements CommandProvider {
             }
         } else {
             vanishedPlayers.remove(player);
-            for (CommandSender sender : container.collectBroadcastTargets()) {
+            for (CommandSender sender : Punishment.getBroadcastTargets()) {
-                sender.sendMessage(CHAT_PREFIX.append(
+                sender.sendMessage(translatable("smod.command.vanish.broadcast.off", player.teamDisplayName()));
-                        player.displayName().colorIfAbsent(SECONDARY_COLOR)
-                ).append(text()
-                        .content(" re-appeared.")
-                        .color(PRIMARY_COLOR)
-                ));
             }
-            player.sendMessage(CHAT_PREFIX.append(text("You are no longer vanished.").color(PRIMARY_COLOR)));
+            player.sendMessage(translatable("smod.command.vanish.toggle.off"));
             player.setVisibleByDefault(true);
         }
     }
@@ -153,17 +144,13 @@ public final class VanishCommand implements CommandProvider {
 
     public static void listVanishedPlayersTo(CommandSender receiver){
         if (vanishedPlayers.isEmpty()){
-            receiver.sendMessage(CHAT_PREFIX.append(
+            receiver.sendMessage(translatable("smod.command.vanish.list.none"));
-                    text().content("No players are currently vanished.").color(PRIMARY_COLOR)
-            ));
         } else {
-            Component vanishList = CHAT_PREFIX.append(
+            Component vanishList = empty();
-                    text().content("The following players are currently vanished: ").color(PRIMARY_COLOR)
-            );
             for (ObjectListIterator<Player> iterator = vanishedPlayers.iterator(); iterator.hasNext(); ) {
                 Player vanishedPlayer = iterator.next();
                 vanishList = vanishList.append(
-                        vanishedPlayer.displayName().colorIfAbsent(SECONDARY_COLOR)
+                        vanishedPlayer.teamDisplayName().colorIfAbsent(SECONDARY_COLOR)
                 );
                 if (iterator.hasNext()){
                     vanishList = vanishList.append(
@@ -171,7 +158,7 @@ public final class VanishCommand implements CommandProvider {
                     );
                 }
             }
-            receiver.sendMessage(vanishList);
+            receiver.sendMessage(translatable("smod.command.vanish.list", vanishList));
         }
     }
 }

src/main/java/de/shiewk/smoderation/paper/command/argument/DurationArgument.java

@@ -16,15 +16,20 @@ import java.util.concurrent.atomic.AtomicLong;
 import java.util.regex.MatchResult;
 import java.util.regex.Pattern;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class DurationArgument implements CustomArgumentType.Converted<Long, String> {
 
     public static final Pattern DURATION_PATTERN = Pattern.compile("([0-9]{1,9})(ms|s|min|h|d|w|mo|y)");
     public static final Pattern VALIDATION_PATTERN = Pattern.compile("(([0-9]{1,9})(ms|s|min|h|d|w|mo|y))+");
+    public static final long INFINITE_DURATION = -1L;
 
     @Override
     public @NotNull Long convert(@NotNull String nativeType) throws CommandSyntaxException {
+        if (nativeType.startsWith("perm") || nativeType.startsWith("inf")) {
+            return INFINITE_DURATION;
+        }
         if (!VALIDATION_PATTERN.matcher(nativeType).matches()){
-            CommandUtil.error("Please provide a valid duration, e.g. '1d6h30min'");
+            CommandUtil.errorTranslatable("smod.argument.duration.fail.pattern");
         }
         AtomicLong totalDuration = new AtomicLong();
         for (MatchResult result : DURATION_PATTERN.matcher(nativeType).results().toList()) {
@@ -39,7 +44,7 @@ public final class DurationArgument implements CustomArgumentType.Converted<Long
                 case "mo" -> 2_592_000_000L;
                 case "y" -> 31_536_000_000L;
                 default -> {
-                    CommandUtil.error("Invalid time span '%s'".formatted(result.group(2)));
+                    CommandUtil.errorTranslatable("smod.argument.duration.fail.invalid", result.group(2));
                     throw new UnknownError(); // can't happen
                 }
             };
@@ -57,6 +62,8 @@ public final class DurationArgument implements CustomArgumentType.Converted<Long
     public @NotNull <S> CompletableFuture<Suggestions> listSuggestions(@NotNull CommandContext<S> context, @NotNull SuggestionsBuilder builder) {
         if (builder.getRemaining().isBlank()){
             List.of(
+                    "infinite", "inf",
+                    "permanent", "perm",
                     "100ms",
                     "15s",
                     "2min",

src/main/java/de/shiewk/smoderation/paper/command/argument/OfflinePlayerArgument.java

@@ -0,0 +1,42 @@
+package de.shiewk.smoderation.paper.command.argument;
+
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import de.shiewk.smoderation.paper.util.CommandUtil;
+import io.papermc.paper.command.brigadier.argument.CustomArgumentType;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.NonNull;
+
+import java.util.concurrent.CompletableFuture;
+
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
+public final class OfflinePlayerArgument implements CustomArgumentType.Converted<OfflinePlayer, String> {
+
+    @Override
+    public @NonNull OfflinePlayer convert(@NotNull String nativeType) throws CommandSyntaxException {
+        OfflinePlayer player = Bukkit.getOfflinePlayerIfCached(nativeType);
+        if (player != null){
+            return player;
+        } else {
+            CommandUtil.errorTranslatable("smod.argument.offlinePlayer.fail.notCached");
+            throw new AssertionError(); // can't happen
+        }
+    }
+
+    @Override
+    public @NotNull ArgumentType<String> getNativeType() {
+        return StringArgumentType.word();
+    }
+
+    @Override
+    public @NotNull <S> CompletableFuture<Suggestions> listSuggestions(@NotNull CommandContext<S> context, @NotNull SuggestionsBuilder builder) {
+        return builder.buildFuture();
+    }
+
+}

src/main/java/de/shiewk/smoderation/paper/command/argument/PlayerUUIDArgument.java

@@ -16,6 +16,7 @@ import org.jetbrains.annotations.NotNull;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public final class PlayerUUIDArgument implements CustomArgumentType.Converted<UUID, String> {
 
     @Override
@@ -27,7 +28,7 @@ public final class PlayerUUIDArgument implements CustomArgumentType.Converted<UU
             if (player != null){
                 return player.getUniqueId();
             } else {
-                CommandUtil.error("This player is not cached. Try providing an UUID instead.");
+                CommandUtil.errorTranslatable("smod.argument.uuid.fail.notCached");
                 throw new UnknownError(); // can't happen
             }
         }

src/main/java/de/shiewk/smoderation/paper/config/SModerationConfig.java

@@ -1,60 +0,0 @@
-package de.shiewk.smoderation.paper.config;
-
-import de.shiewk.smoderation.paper.SModerationPaper;
-import org.bukkit.configuration.file.FileConfiguration;
-
-import java.util.List;
-
-public class SModerationConfig {
-
-    private final FileConfiguration config;
-    private final SModerationPaper plugin;
-
-    public SModerationConfig(FileConfiguration config, SModerationPaper plugin) {
-        this.config = config;
-        this.plugin = plugin;
-    }
-
-    private List<String> socialSpyCommands = List.of(
-            "w",
-            "tell",
-            "msg",
-            "teammsg",
-            "tm",
-            "minecraft:w",
-            "minecraft:tell",
-            "minecraft:msg",
-            "minecraft:teammsg",
-            "minecraft:tm"
-    );
-    private boolean forceReason = false;
-
-    public void reload(){
-        socialSpyCommands = loadOrSetStringList("socialspy-commands", socialSpyCommands);
-        forceReason = loadOrSetBoolean("force-reason", forceReason);
-    }
-
-    private List<String> loadOrSetStringList(String path, List<String> defaultValue) {
-        if (!config.contains(path)){
-            config.set(path, defaultValue);
-            plugin.saveConfig();
-        }
-        return config.getStringList(path);
-    }
-
-    private boolean loadOrSetBoolean(String path, boolean defaultValue) {
-        if (!config.contains(path)){
-            config.set(path, defaultValue);
-            plugin.saveConfig();
-        }
-        return config.getBoolean(path);
-    }
-
-    public List<String> getSocialSpyCommands(){
-        return socialSpyCommands;
-    }
-
-    public boolean shouldForceReason(){
-        return forceReason;
-    }
-}

src/main/java/de/shiewk/smoderation/paper/event/PunishmentIssueEvent.java

@@ -1,7 +1,7 @@
 package de.shiewk.smoderation.paper.event;
 
 import de.shiewk.smoderation.paper.punishments.Punishment;
-import de.shiewk.smoderation.paper.storage.PunishmentContainer;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
 import org.bukkit.event.Cancellable;
 import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
@@ -11,20 +11,20 @@ public class PunishmentIssueEvent extends Event implements Cancellable {
     private static final HandlerList handlerList = new HandlerList();
 
     private final Punishment punishment;
-    private final PunishmentContainer container;
+    private final PunishmentManager manager;
     private boolean cancelled;
 
-    public PunishmentIssueEvent(Punishment punishment, PunishmentContainer container) {
+    public PunishmentIssueEvent(Punishment punishment, PunishmentManager manager) {
         this.punishment = punishment;
-        this.container = container;
+        this.manager = manager;
     }
 
     public Punishment getPunishment() {
         return punishment;
     }
 
-    public PunishmentContainer getContainer() {
+    public PunishmentManager getPunishmentManager() {
-        return container;
+        return manager;
     }
 
     @Override

src/main/java/de/shiewk/smoderation/paper/input/ChatInput.java

@@ -10,9 +10,9 @@ import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
 
-import static de.shiewk.smoderation.paper.SModerationPaper.CHAT_PREFIX;
+import static de.shiewk.smoderation.paper.SModerationPaper.PRIMARY_COLOR;
 import static net.kyori.adventure.text.Component.text;
-import static net.kyori.adventure.text.format.NamedTextColor.GRAY;
+import static net.kyori.adventure.text.Component.translatable;
 
 public class ChatInput {
     private final Player player;
@@ -42,7 +42,7 @@ public class ChatInput {
         }
         if (remainingTicks % 20 == 0){
             player.showTitle(Title.title(
-                    text().content(getRemainingTicks() / 20 + " seconds").color(GRAY).build(),
+                    translatable("smod.chatInput.remainingTime", text(getRemainingTicks() / 20)),
                     getPrompt(),
                     Title.Times.times(Duration.ZERO, Duration.ofSeconds(2), Duration.ZERO)
             ));
@@ -53,7 +53,7 @@ public class ChatInput {
 
     public static void prompt(Player player, Consumer<Component> consumer, Component prompt, int timeSeconds){
         runningInputs.put(player, new ChatInput(player, prompt, consumer, timeSeconds));
-        player.sendMessage(CHAT_PREFIX.append(prompt));
+        player.sendMessage(prompt.colorIfAbsent(PRIMARY_COLOR));
     }
 
     public Component getPrompt() {

src/main/java/de/shiewk/smoderation/paper/inventory/ConfirmationInventory.java

@@ -1,5 +1,6 @@
 package de.shiewk.smoderation.paper.inventory;
 
+import io.papermc.paper.datacomponent.DataComponentTypes;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
@@ -11,37 +12,38 @@ import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 
+import static de.shiewk.smoderation.paper.inventory.CustomInventory.renderComponent;
+import static net.kyori.adventure.text.Component.translatable;
+
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
 public class ConfirmationInventory implements CustomInventory {
     private final Inventory inventory;
     private final Player player;
-    private final String prompt;
+    private final Component prompt;
-    private final ItemStack yesStack;
-    private final ItemStack noStack;
     private final Runnable onAccept;
     private final Runnable onReject;
-    private final boolean reversed;
 
-    public ConfirmationInventory(Player player, String prompt, Runnable onAccept, Runnable onReject, boolean reversed) {
+    public ConfirmationInventory(Player player, Component prompt, Runnable onAccept, Runnable onReject) {
         this.player = player;
         this.prompt = prompt;
         this.onAccept = onAccept;
         this.onReject = onReject;
-        this.reversed = reversed;
+        inventory = Bukkit.createInventory(this, InventoryType.HOPPER, this.prompt);
-        inventory = Bukkit.createInventory(this, InventoryType.HOPPER, Component.text(this.prompt));
-        yesStack = new ItemStack(Material.LIME_STAINED_GLASS_PANE);
-        noStack = new ItemStack(Material.RED_STAINED_GLASS_PANE);
     }
 
     @Override
     public void refresh() {
-        yesStack.editMeta(meta -> meta.displayName(applyFormatting(Component.text("Yes").color(NamedTextColor.GREEN))));
+        ItemStack accept = new ItemStack(Material.LIME_STAINED_GLASS_PANE);
-        noStack.editMeta(meta -> meta.displayName(applyFormatting(Component.text("No").color(NamedTextColor.RED))));
         ItemStack confirmation = new ItemStack(Material.PAPER);
-        confirmation.editMeta(meta -> meta.displayName(applyFormatting(Component.text(prompt).color(NamedTextColor.GOLD))));
+        ItemStack reject = new ItemStack(Material.RED_STAINED_GLASS_PANE);
 
-        inventory.setItem(reversed ? 4 : 0, noStack);
+        accept.setData(DataComponentTypes.ITEM_NAME, renderComponent(player, applyFormatting(translatable("smod.confirm.yes"))));
+        confirmation.setData(DataComponentTypes.ITEM_NAME, renderComponent(player, prompt.colorIfAbsent(NamedTextColor.GOLD)));
+        reject.setData(DataComponentTypes.ITEM_NAME, renderComponent(player, applyFormatting(translatable("smod.confirm.no"))));
+
+        inventory.setItem(0, accept);
         inventory.setItem(2, confirmation);
-        inventory.setItem(reversed ? 0 : 4, yesStack);
+        inventory.setItem(4, reject);
     }
 
     @Override
@@ -51,11 +53,11 @@ public class ConfirmationInventory implements CustomInventory {
     }
 
     @Override
-    public void click(ItemStack stack, InventoryClickEvent event) {
+    public void click(InventoryClickEvent event) {
-        if (yesStack.equals(stack)){
+        if (event.getSlot() == 0){
             inventory.close();
             onAccept.run();
-        } else if (noStack.equals(stack)) {
+        } else if (event.getSlot() == 4) {
             inventory.close();
             onReject.run();
         }

src/main/java/de/shiewk/smoderation/paper/inventory/CustomInventory.java

@@ -1,17 +1,22 @@
 package de.shiewk.smoderation.paper.inventory;
 
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.TextDecoration;
+import net.kyori.adventure.translation.GlobalTranslator;
 import org.bukkit.Material;
+import org.bukkit.entity.Player;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.ItemStack;
 
+import java.util.List;
+
 public interface CustomInventory extends InventoryHolder {
 
     void refresh();
     void open();
-    void click(ItemStack stack, InventoryClickEvent event);
+    void click(InventoryClickEvent event);
 
     default ItemStack createEmptyStack(){
         ItemStack stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE);
@@ -22,4 +27,15 @@ public interface CustomInventory extends InventoryHolder {
     default Component applyFormatting(Component component){
         return component.decoration(TextDecoration.ITALIC, false);
     }
+
+    static Component renderComponent(Player viewer, Component component){
+        Component render = GlobalTranslator.render(component, viewer.locale());
+        List<Component> oldChildren = render.children();
+        List<Component> newChildren = new ObjectArrayList<>(oldChildren.size());
+        for (Component oldChild : oldChildren) {
+            Component e = renderComponent(viewer, oldChild);
+            newChildren.add(e);
+        }
+        return render.children(newChildren);
+    }
 }

src/main/java/de/shiewk/smoderation/paper/inventory/InvSeeEquipmentInventory.java

@@ -8,7 +8,6 @@ import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.event.inventory.InventoryType;
 import org.bukkit.inventory.EntityEquipment;
 import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 
 import static net.kyori.adventure.text.Component.text;
@@ -44,7 +43,7 @@ public class InvSeeEquipmentInventory implements AutoUpdatingCustomInventory {
     }
 
     @Override
-    public void click(ItemStack stack, InventoryClickEvent event) {
+    public void click(InventoryClickEvent event) {
         if (viewer.hasPermission("smod.invsee.modify") && !subject.hasPermission("smod.invsee.preventmodify")){
             event.setCancelled(false);
             changing = true;

src/main/java/de/shiewk/smoderation/paper/inventory/InvSeeInventory.java

@@ -6,7 +6,6 @@ import org.bukkit.Bukkit;
 import org.bukkit.entity.HumanEntity;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 
 import static net.kyori.adventure.text.Component.text;
@@ -46,7 +45,7 @@ public class InvSeeInventory implements AutoUpdatingCustomInventory {
     }
 
     @Override
-    public void click(ItemStack stack, InventoryClickEvent event) {
+    public void click(InventoryClickEvent event) {
         if (viewer.hasPermission("smod.invsee.modify") && !subject.hasPermission("smod.invsee.preventmodify")){
             event.setCancelled(false);
             changing = true;

src/main/java/de/shiewk/smoderation/paper/inventory/PageableCustomInventory.java

@@ -1,31 +1,40 @@
 package de.shiewk.smoderation.paper.inventory;
 
-import net.kyori.adventure.text.Component;
+import io.papermc.paper.datacomponent.DataComponentTypes;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.format.TextColor;
 import org.bukkit.Material;
+import org.bukkit.entity.Player;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.inventory.ItemStack;
 
+import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.Component.translatable;
+
+@SuppressWarnings("UnstableApiUsage") // Paper Data Component API
 public abstract class PageableCustomInventory implements CustomInventory {
-    public abstract int lastPage();
+
-    public abstract void switchPage();
+    protected final int prevSlot, nextSlot;
-    private ItemStack previousStack = null;
-    private ItemStack nextStack = null;
     private int page = 0;
 
+    public PageableCustomInventory(int prevSlot, int nextSlot) {
+        this.prevSlot = prevSlot;
+        this.nextSlot = nextSlot;
+    }
+
     public int getPage(){
         return page;
     }
 
+    public abstract int lastPage();
+    public abstract void switchPage();
+
     @Override
-    public void click(ItemStack stack, InventoryClickEvent event) {
+    public void click(InventoryClickEvent event) {
-        if (stack != null){
+        if (event.getSlot() == prevSlot) {
-            if (stack.equals(previousStack)){
+            previousPage();
-                previousPage();
+        } else if (event.getSlot() == nextSlot) {
-            } else if (stack.equals(nextStack)) {
+            nextPage();
-                nextPage();
-            }
         }
     }
 
@@ -45,23 +54,21 @@ public abstract class PageableCustomInventory implements CustomInventory {
         }
     }
 
-    public ItemStack createPreviousPageStack(){
+    public ItemStack createPreviousPageStack(Player viewer){
         boolean allowed = page > 0;
         TextColor color = allowed ? NamedTextColor.GREEN : NamedTextColor.RED;
         int skip = allowed ? page : page+1;
         ItemStack stack = new ItemStack(allowed ? Material.GREEN_STAINED_GLASS_PANE : Material.RED_STAINED_GLASS_PANE);
-        stack.editMeta(meta -> meta.displayName(applyFormatting(Component.text("Previous page (%s/%s)".formatted(skip, lastPage()+1)).color(color))));
+        stack.setData(DataComponentTypes.ITEM_NAME, CustomInventory.renderComponent(viewer, applyFormatting(translatable("smod.inventory.previous", text(skip), text(lastPage()+1)).color(color))));
-        previousStack = stack;
         return stack;
     }
 
-    public ItemStack createNextPageStack(){
+    public ItemStack createNextPageStack(Player viewer){
         boolean allowed = page < lastPage();
         TextColor color = allowed ? NamedTextColor.GREEN : NamedTextColor.RED;
         int skip = allowed ? page+2 : page+1;
         ItemStack stack = new ItemStack(allowed ? Material.GREEN_STAINED_GLASS_PANE : Material.RED_STAINED_GLASS_PANE);
-        stack.editMeta(meta -> meta.displayName(applyFormatting(Component.text("Next page (%s/%s)".formatted(skip, lastPage()+1)).color(color))));
+        stack.setData(DataComponentTypes.ITEM_NAME, CustomInventory.renderComponent(viewer, applyFormatting(translatable("smod.inventory.next", text(skip), text(lastPage()+1)).color(color))));
-        nextStack = stack;
         return stack;
     }
 }

src/main/java/de/shiewk/smoderation/paper/inventory/SModMenu.java

@@ -5,92 +5,91 @@ import com.destroystokyo.paper.profile.ProfileProperty;
 import de.shiewk.smoderation.paper.SkinTextureProvider;
 import de.shiewk.smoderation.paper.input.ChatInput;
 import de.shiewk.smoderation.paper.punishments.Punishment;
-import de.shiewk.smoderation.paper.punishments.PunishmentType;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
-import de.shiewk.smoderation.paper.storage.PunishmentContainer;
+import de.shiewk.smoderation.paper.punishments.TimedPunishment;
 import de.shiewk.smoderation.paper.util.PlayerUtil;
 import de.shiewk.smoderation.paper.util.SchedulerUtil;
 import de.shiewk.smoderation.paper.util.TimeUtil;
 import io.papermc.paper.datacomponent.DataComponentTypes;
+import io.papermc.paper.datacomponent.item.ItemLore;
+import it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.TextComponent;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.format.TextDecoration;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
-import org.bukkit.NamespacedKey;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.inventory.meta.SkullMeta;
-import org.bukkit.persistence.PersistentDataContainer;
-import org.bukkit.persistence.PersistentDataType;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.ArrayList;
+import java.io.IOException;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
 import static de.shiewk.smoderation.paper.SModerationPaper.*;
-import static net.kyori.adventure.text.Component.text;
+import static de.shiewk.smoderation.paper.inventory.CustomInventory.renderComponent;
+import static net.kyori.adventure.text.Component.*;
 
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API, Paper Data Component API
 public class SModMenu extends PageableCustomInventory {
 
     public enum Filter {
-        ACTIVE("Active punishments", Punishment::isActive),
+        ACTIVE(translatable("smod.menu.filter.active"), p -> p instanceof TimedPunishment timed && timed.isActive()),
-        OLD("Old punishments", p -> !p.isActive()),
+        OLD(translatable("smod.menu.filter.expired"), p -> !(p instanceof TimedPunishment timed && timed.isActive())),
-        ALL("All punishments", p -> true);
+        ALL(translatable("smod.menu.filter.all"), p -> true);
 
         public static final Material ICON = Material.HOPPER;
 
-        public final String name;
+        public final Component name;
         public final Predicate<Punishment> filter;
-        Filter(String name, Predicate<Punishment> filter) {
+        Filter(Component name, Predicate<Punishment> filter) {
             this.name = name;
             this.filter = filter;
         }
     }
 
     public enum Sort {
-        EXPIRY("Expiry", Comparator.comparingLong(p -> p.until)),
+        EXPIRY(translatable("smod.menu.sort.expiry"), Comparator.comparingLong(p -> p instanceof TimedPunishment timed ? timed.getExpiry() : p.getTimestamp())),
-        TIME("Date", Comparator.comparingLong(p -> p.time)),
+        TIME(translatable("smod.menu.sort.time"), Comparator.comparingLong(Punishment::getTimestamp)),
-        PLAYER_NAME("Player name", (p1, p2) -> String.CASE_INSENSITIVE_ORDER.compare(PlayerUtil.offlinePlayerName(p1.to), PlayerUtil.offlinePlayerName(p2.to))),
+        PLAYER_NAME(translatable("smod.menu.sort.playerName"), (p1, p2) -> String.CASE_INSENSITIVE_ORDER.compare(PlayerUtil.offlinePlayerName(p1.getTargetID()), PlayerUtil.offlinePlayerName(p2.getTargetID()))),
-        MODERATOR_NAME("Moderator name", (p1, p2) -> String.CASE_INSENSITIVE_ORDER.compare(PlayerUtil.offlinePlayerName(p1.by), PlayerUtil.offlinePlayerName(p2.by)));
+        MODERATOR_NAME(translatable("smod.menu.sort.moderatorName"), (p1, p2) -> String.CASE_INSENSITIVE_ORDER.compare(PlayerUtil.offlinePlayerName(p1.getIssuerID()), PlayerUtil.offlinePlayerName(p2.getIssuerID())));
 
         public static final Material ICON = Material.COMPARATOR;
 
-        public final String name;
+        public final Component name;
         public final Comparator<Punishment> comparator;
 
-        Sort(String name, Comparator<Punishment> comparator) {
+        Sort(Component name, Comparator<Punishment> comparator) {
             this.name = name;
             this.comparator = comparator;
         }
     }
-    private static final NamespacedKey PUNISHMENT_STORE_KEY = new NamespacedKey("smod", "punishmentid");
 
     private final Inventory inventory;
     private final Player player;
-    private final PunishmentContainer container;
+    private final PunishmentManager punishmentManager;
+    private final Int2ObjectArrayMap<Punishment> slotMap = new Int2ObjectArrayMap<>(45);
     private List<Punishment> punishments;
-    private ItemStack sortStack = null;
-    private ItemStack filterStack = null;
-    private ItemStack searchStack = null;
-    private ItemStack typeStack = null;
     private int sort = 0;
     private int filter = 0;
     private int type = -1;
+    private int rfId = 0;
     private String searchQuery = null;
 
-    public SModMenu(Player player, PunishmentContainer container) {
+    public SModMenu(Player player, PunishmentManager punishmentManager) {
+        super(45, 53);
         this.player = player;
-        this.container = container;
+        this.punishmentManager = punishmentManager;
-        this.inventory = Bukkit.createInventory(this, 54, text("SMod Menu"));
+        this.inventory = Bukkit.createInventory(this, 54, translatable("smod.menu"));
         reload();
     }
 
@@ -102,16 +101,21 @@ public class SModMenu extends PageableCustomInventory {
         return Filter.values()[filter];
     }
 
-    public PunishmentType getType(){
+    public String getType(){
-        return type == -1 ? null : PunishmentType.values()[type];
+        return type == -1 ? null : punishmentManager.getRegisteredTypes().get(type);
     }
 
-    private void reload(){
+    private void reload() {
-        this.punishments = container.copy().stream()
+        try {
-                .filter(getFilter().filter)
+            this.punishments = this.punishmentManager.getAll()
-                .filter(p -> getType() == null || p.type == getType())
+                    .stream()
-                .filter(p -> p.matchesSearchQuery(searchQuery))
+                    .filter(getFilter().filter)
-                .sorted(getSort().comparator).toList();
+                    .filter(p -> getType() == null || Objects.equals(p.getType(), getType()))
+                    .filter(p -> p.matchesSearchQuery(searchQuery))
+                    .sorted(getSort().comparator).toList();
+        } catch (IOException e) {
+            this.punishments = List.of();
+        }
     }
 
     public void promptSearchQuery(){
@@ -122,7 +126,7 @@ public class SModMenu extends PageableCustomInventory {
                 // chat event is async
                 SchedulerUtil.scheduleForEntity(PLUGIN, player, this::open);
             }
-        }, text("Enter your search query in chat").color(SECONDARY_COLOR), 30);
+        }, translatable("smod.menu.search.query").color(SECONDARY_COLOR), 30);
     }
 
     @Override
@@ -172,12 +176,12 @@ public class SModMenu extends PageableCustomInventory {
         player.playSound(player, Sound.UI_BUTTON_CLICK, 1f, backwards ? 0.8f : 2f);
         if (backwards){
             if (type <= -1){
-                type = PunishmentType.values().length-1;
+                type = punishmentManager.getRegisteredTypes().size()-1;
             } else {
                 type--;
             }
         } else {
-            if (type >= PunishmentType.values().length-1){
+            if (type >= punishmentManager.getRegisteredTypes().size()-1){
                 type = -1;
             } else {
                 type++;
@@ -195,107 +199,110 @@ public class SModMenu extends PageableCustomInventory {
     private ItemStack createFilterItem(){
         final Filter filter = getFilter();
         final ItemStack stack = new ItemStack(Filter.ICON);
-        stack.editMeta(meta -> {
+        stack.setData(DataComponentTypes.ITEM_NAME, renderComponent(player, translatable("smod.menu.filter", filter.name).color(PRIMARY_COLOR)));
-            meta.displayName(applyFormatting(text("Filter: " + filter.name).color(PRIMARY_COLOR)));
+        ItemLore.Builder loreBuilder = ItemLore.lore();
-            ArrayList<Component> lore = new ArrayList<>();
+
-            lore.add(Component.empty());
+        loreBuilder.addLine(empty());
-            for (Filter value : Filter.values()) {
+        for (Filter value : Filter.values()) {
-                final boolean selected = filter == value;
+            final boolean selected = filter == value;
-                Component filterText = applyFormatting(text((selected ? "\u00BB " : "") + value.name).color(selected ? SECONDARY_COLOR : INACTIVE_COLOR));
+            Component filterText = renderComponent(player, applyFormatting(text((selected ? "\u00BB " : ""), selected ? SECONDARY_COLOR : INACTIVE_COLOR).append(value.name)));
-                lore.add(filterText);
+            loreBuilder.addLine(filterText);
-            }
+        }
-            lore.add(Component.empty());
+        loreBuilder.addLine(empty());
-            lore.add(applyFormatting(text("\u00BB Click to switch filter").color(NamedTextColor.GOLD)));
+        loreBuilder.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.filter.switch", NamedTextColor.GOLD))));
-            meta.lore(lore);
+
-        });
+        stack.setData(DataComponentTypes.LORE, loreBuilder.build());
-        filterStack = stack;
         return stack;
     }
 
     private ItemStack createTypeItem(){
-        final PunishmentType type = getType();
+        final String type = getType();
         final ItemStack stack = new ItemStack(Material.CHEST);
-        stack.editMeta(meta -> {
+        stack.setData(DataComponentTypes.ITEM_NAME, renderComponent(player, translatable("smod.menu.type", (type == null ? translatable("smod.menu.type.all") : translatable("smod.punishment.name." + type)))).color(PRIMARY_COLOR));
-            meta.displayName(applyFormatting(text("Type: " + (type == null ? "All" : type.name)).color(PRIMARY_COLOR)));
+
-            ArrayList<Component> lore = new ArrayList<>();
+        ItemLore.Builder loreBuilder = ItemLore.lore();
-            lore.add(Component.empty());
+        loreBuilder.addLine(empty());
-            final Consumer<PunishmentType> addToLore = value -> {
+        final Consumer<String> addToLore = value -> {
-                final boolean selected = type == value;
+            final boolean selected = Objects.equals(type, value);
-                Component typeText = applyFormatting(text((selected ? "\u00BB " : "") + (value == null ? "All" : value.name)).color(selected ? SECONDARY_COLOR : INACTIVE_COLOR));
+            Component typeText = renderComponent(player, applyFormatting(text((selected ? "\u00BB " : ""), selected ? SECONDARY_COLOR : INACTIVE_COLOR).append(value == null ? translatable("smod.menu.type.all") : translatable("smod.punishment.name." + value))));
-                lore.add(typeText);
+            loreBuilder.addLine(typeText);
-            };
+        };
-            addToLore.accept(null);
+        addToLore.accept(null);
-            for (PunishmentType value : PunishmentType.values()) {
+        for (String value : punishmentManager.getRegisteredTypes()) {
-                addToLore.accept(value);
+            addToLore.accept(value);
-            }
+        }
-            lore.add(Component.empty());
+
-            lore.add(applyFormatting(text("\u00BB Click to switch type").color(NamedTextColor.GOLD)));
+        loreBuilder.addLine(empty());
-            meta.lore(lore);
+        loreBuilder.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.type.switch", NamedTextColor.GOLD))));
-        });
+
-        return typeStack = stack;
+        stack.setData(DataComponentTypes.LORE, loreBuilder);
+        return stack;
     }
 
     private ItemStack createSortItem(){
         final Sort sort = getSort();
         final ItemStack stack = new ItemStack(Sort.ICON);
-        stack.editMeta(meta -> {
+        stack.setData(DataComponentTypes.ITEM_NAME, renderComponent(player, translatable("smod.menu.sort", sort.name).color(PRIMARY_COLOR)));
-            meta.displayName(applyFormatting(text("Sort by: " + sort.name).color(PRIMARY_COLOR)));
+
-            ArrayList<Component> lore = new ArrayList<>();
+        ItemLore.Builder loreBuilder = ItemLore.lore();
-            lore.add(Component.empty());
+        loreBuilder.addLine(empty());
-            for (Sort value : Sort.values()) {
+
-                final boolean selected = sort == value;
+        for (Sort value : Sort.values()) {
-                Component sortText = applyFormatting(text((selected ? "\u00BB " : "") + value.name).color(selected ? SECONDARY_COLOR : INACTIVE_COLOR));
+            final boolean selected = sort == value;
-                lore.add(sortText);
+            Component sortText = renderComponent(player, applyFormatting(text((selected ? "\u00BB " : ""), selected ? SECONDARY_COLOR : INACTIVE_COLOR).append(value.name)));
-            }
+            loreBuilder.addLine(sortText);
-            lore.add(Component.empty());
+        }
-            lore.add(applyFormatting(text("\u00BB Click to switch sorting option").color(NamedTextColor.GOLD)));
+
-            meta.lore(lore);
+        loreBuilder.addLine(empty());
-        });
+        loreBuilder.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.sort.switch", NamedTextColor.GOLD))));
-        sortStack = stack;
+
+        stack.setData(DataComponentTypes.LORE, loreBuilder);
         return stack;
     }
 
     private ItemStack createSearchItem(){
         final ItemStack stack = new ItemStack(Material.FLOWER_BANNER_PATTERN);
-        stack.editMeta(meta -> {
+
-            try {
+        try {
-                stack.setData(DataComponentTypes.HIDE_ADDITIONAL_TOOLTIP);
+            stack.setData(DataComponentTypes.HIDE_ADDITIONAL_TOOLTIP);
-            } catch (NoSuchFieldError e) {
+        } catch (NoSuchFieldError e) {
-                // that component is no longer present under that name,
+            // that component is no longer present under that name,
-                // we just create the stack without it instead of throwing
+            // we just create the stack without it instead of throwing
-            }
+        }
-            meta.displayName(applyFormatting(text("Search").color(PRIMARY_COLOR)));
+
-            final ArrayList<Component> lore = new ArrayList<>(List.of(
+        stack.setData(DataComponentTypes.ITEM_NAME, renderComponent(player, translatable("smod.menu.search", PRIMARY_COLOR)));
-                    Component.empty(),
+
-                    applyFormatting(text("Current search query: %s".formatted(searchQuery == null ? "None" : "\"" + searchQuery + "\"")).color(SECONDARY_COLOR)),
+        ItemLore.Builder loreBuilder = ItemLore.lore();
-                    Component.empty(),
+        loreBuilder.addLines(List.of(
-                    applyFormatting(text("\u00BB Click to enter new search query").color(NamedTextColor.GOLD))
+                empty(),
-            ));
+                renderComponent(player, applyFormatting(translatable("smod.menu.search.current", searchQuery == null ? translatable("smod.menu.search.none") : text('"' + searchQuery + '"'))).color(SECONDARY_COLOR)),
-            if (searchQuery != null){
+                empty(),
-                lore.add(applyFormatting(text("\u00BB Right click to remove search query").color(NamedTextColor.GOLD)));
+                renderComponent(player, applyFormatting(translatable("smod.menu.search.new", NamedTextColor.GOLD)))
-            }
+        ));
-            meta.lore(lore);
+        if (searchQuery != null){
-        });
+            loreBuilder.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.search.remove", NamedTextColor.GOLD))));
-        return searchStack = stack;
+        }
+        stack.setData(DataComponentTypes.LORE, loreBuilder);
+        return stack;
     }
 
     private CompletableFuture<ItemStack> createPunishmentItem(Punishment punishment){
         SkinTextureProvider provider = getTextureProvider();
         if (provider != null) {
-            return provider.textureProperty(punishment.to)
+            return provider.textureProperty(punishment.getTargetID())
                     .thenApply(texture -> {
                         ItemStack stack = new ItemStack(Material.PLAYER_HEAD);
                         stack.editMeta(meta -> {
                             if (meta instanceof SkullMeta skullMeta){
-                                PlayerProfile profile = Bukkit.createProfile(punishment.to);
+                                PlayerProfile profile = Bukkit.createProfile(punishment.getTargetID());
                                 profile.setProperty(new ProfileProperty(
                                         "textures",
                                         texture
                                 ));
                                 skullMeta.setPlayerProfile(profile);
                             }
-                            addPunishmentInfo(punishment, meta);
                         });
+                        addPunishmentInfo(punishment, stack);
                         return stack;
                     });
         } else {
@@ -303,48 +310,55 @@ public class SModMenu extends PageableCustomInventory {
             stack.editMeta(meta -> {
                 if (meta instanceof SkullMeta skullMeta){
                     try {
-                        skullMeta.setOwningPlayer(Bukkit.getOfflinePlayer(punishment.to));
+                        skullMeta.setOwningPlayer(Bukkit.getOfflinePlayer(punishment.getTargetID()));
                     } catch (NullPointerException e) {
-                        LOGGER.warn("Player {} has a punishment but was never on this server!", punishment.to);
+                        LOGGER.warn("Player {} has a punishment but was never on this server!", punishment.getTargetID());
                     }
                 }
-                addPunishmentInfo(punishment, meta);
             });
+            addPunishmentInfo(punishment, stack);
             return CompletableFuture.completedFuture(stack);
         }
     }
 
-    private void addPunishmentInfo(Punishment punishment, ItemMeta meta) {
+    private void addPunishmentInfo(Punishment punishment, ItemStack stack) {
-        meta.displayName(applyFormatting(text(punishment.type.name).color(NamedTextColor.RED).decorate(TextDecoration.BOLD)));
+        stack.setData(DataComponentTypes.CUSTOM_NAME, renderComponent(player, applyFormatting(translatable("smod.punishment.name." + punishment.getType(), NamedTextColor.RED).decorate(TextDecoration.BOLD))));
-        ArrayList<Component> lore = new ArrayList<>();
+        ItemLore.Builder lore = ItemLore.lore();
-        lore.add(applyFormatting(text("Player: ").color(SECONDARY_COLOR).append(text(PlayerUtil.offlinePlayerName(punishment.to)).color(PRIMARY_COLOR))));
+
-        lore.add(applyFormatting(text("Punished by: ").color(SECONDARY_COLOR).append(text(PlayerUtil.offlinePlayerName(punishment.by)).color(PRIMARY_COLOR))));
+        lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.player", text(PlayerUtil.offlinePlayerName(punishment.getTargetID()))))));
-        lore.add(applyFormatting(text("Timestamp: ").color(SECONDARY_COLOR).append(text(TimeUtil.calendarTimestamp(punishment.time)).color(PRIMARY_COLOR))));
+        lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.punishedBy", text(PlayerUtil.offlinePlayerName(punishment.getIssuerID()))))));
-        if (punishment.type != PunishmentType.KICK){
+        lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.timestamp", TimeUtil.calendarTimestamp(punishment.getTimestamp())))));
-            lore.add(applyFormatting(text("Duration: ").color(SECONDARY_COLOR).append(text(TimeUtil.formatTimeLong(punishment.until - punishment.time)).color(PRIMARY_COLOR))));
+
-            long remainingTime = punishment.until - System.currentTimeMillis();
+        if (punishment instanceof TimedPunishment timed){
-            final String expires;
+            if (timed.isPermanent()){
-            if (remainingTime > 0){
+                lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.duration", translatable("smod.time.permanent")))));
-                expires = "in " + TimeUtil.formatTimeLong(remainingTime);
+                lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.expiry.never"))));
             } else {
-                remainingTime *= -1;
+                lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.duration", TimeUtil.formatTimeLong(timed.getExpiry() - punishment.getTimestamp())))));
-                expires = TimeUtil.formatTimeLong(remainingTime) + " ago";
+                long remainingTime = timed.getExpiry() - System.currentTimeMillis();
-            }
+                if (remainingTime > 0){
-            lore.add(applyFormatting(text("Expires: ").color(SECONDARY_COLOR).append(text(expires).color(PRIMARY_COLOR))));
+                    lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.expiry.future", TimeUtil.formatTimeLong(remainingTime)))));
-        }
+                } else {
-        lore.add(applyFormatting(text("Reason: ").color(SECONDARY_COLOR).append(text(punishment.reason).color(PRIMARY_COLOR))));
+                    lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.expiry.past", TimeUtil.formatTimeLong(-remainingTime)))));
-        if (punishment.wasUndone()){
+                }
-            lore.add(applyFormatting(text("Undone by: ").color(NamedTextColor.RED).append(text(PlayerUtil.offlinePlayerName(punishment.undoneBy())).color(NamedTextColor.GOLD))));
-        } else if (punishment.isActive()) {
-            if ((punishment.type == PunishmentType.BAN && player.hasPermission("smod.unban")) || (punishment.type == PunishmentType.MUTE && player.hasPermission("smod.unmute"))){
-                lore.add(Component.empty());
-                lore.add(applyFormatting(text("\u00BB Click to undo punishment").color(NamedTextColor.GOLD)));
             }
         }
-        meta.lore(lore);
+
+        lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.reason", text(punishment.getReason())))));
+
+        if (punishment instanceof TimedPunishment timed){
+            if (timed.wasCancelled()){
+                lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.cancelled", text(PlayerUtil.offlinePlayerName(timed.getCancelledBy()))))));
+            } else if (timed.isActive()) {
+                if (player.hasPermission("smod.un" + punishment.getType())){
+                    lore.addLine(empty());
+                    lore.addLine(renderComponent(player, applyFormatting(translatable("smod.menu.info.click", NamedTextColor.GOLD))));
+                }
+            }
+        }
+        stack.setData(DataComponentTypes.LORE, lore);
     }
 
-    private int rfId = 0;
     @Override
     public void refresh() {
         int rfId = ++this.rfId;
@@ -352,11 +366,12 @@ public class SModMenu extends PageableCustomInventory {
             previousPage();
         }
         inventory.clear();
+        slotMap.clear();
         for (int i = 45; i < 54; i++) {
             inventory.setItem(i, createEmptyStack());
         }
-        inventory.setItem(45, createPreviousPageStack());
+        inventory.setItem(prevSlot, createPreviousPageStack(player));
-        inventory.setItem(53, createNextPageStack());
+        inventory.setItem(nextSlot, createNextPageStack(player));
         inventory.setItem(47, createSearchItem());
         inventory.setItem(48, createTypeItem());
         inventory.setItem(50, createFilterItem());
@@ -367,13 +382,9 @@ public class SModMenu extends PageableCustomInventory {
             if (punishments.size() > ci){
                 final Punishment punishment = punishments.get(ci);
                 int slot = i;
+                slotMap.put(slot, punishment);
                 createPunishmentItem(punishment).thenAccept(item -> {
                     if (rfId != this.rfId) return;
-                    if (punishment.isActive()){
-                        if ((punishment.type == PunishmentType.BAN && player.hasPermission("smod.unban")) || (punishment.type == PunishmentType.MUTE && player.hasPermission("smod.unmute"))) {
-                            item.editMeta(meta -> meta.getPersistentDataContainer().set(PUNISHMENT_STORE_KEY, PersistentDataType.LONG, punishment.time));
-                        }
-                    }
                     inventory.setItem(slot, item);
                 }).exceptionally(x -> {
                     LOGGER.warn("Error creating punishment item", x);
@@ -386,40 +397,34 @@ public class SModMenu extends PageableCustomInventory {
     }
 
     @Override
-    public void click(ItemStack stack, InventoryClickEvent event) {
+    public void click(InventoryClickEvent event) {
-        super.click(stack, event);
+        super.click(event);
-        if (stack != null) {
+        int slot = event.getSlot();
-            if (stack.equals(filterStack)){
+        if (slot == 47) {
-                cycleFilter(event.isRightClick());
+            if (event.isRightClick() && searchQuery != null){
-            } else if (stack.equals(sortStack)){
+                player.playSound(player, Sound.UI_BUTTON_CLICK, 1f, 0.8f);
-                cycleSort(event.isRightClick());
+                searchQuery = null;
-            } else if (stack.equals(searchStack)){
+                reload();
-                if (event.isRightClick() && searchQuery != null){
+                refresh();
-                    player.playSound(player, Sound.UI_BUTTON_CLICK, 1f, 0.8f);
+            } else {
-                    searchQuery = null;
+                player.playSound(player, Sound.UI_BUTTON_CLICK, 1f, 2f);
-                    reload();
+                promptSearchQuery();
-                    refresh();
-                } else {
-                    player.playSound(player, Sound.UI_BUTTON_CLICK, 1f, 2f);
-                    promptSearchQuery();
-                }
-            } else if (stack.equals(typeStack)) {
-                cycleType(event.isRightClick());
             }
-            final ItemMeta itemMeta = stack.getItemMeta();
+        } else if (slot == 48) {
-            if (itemMeta != null) {
+            cycleType(event.isRightClick());
-                final PersistentDataContainer persistentDataContainer = itemMeta.getPersistentDataContainer();
+        } else if (slot == 50) {
-                final Long timestamp = persistentDataContainer.get(PUNISHMENT_STORE_KEY, PersistentDataType.LONG);
+            cycleFilter(event.isRightClick());
-                if (timestamp != null) {
+        } else if (slot == 51) {
-                    final Punishment punishment = container.findByTimestamp(timestamp);
+            cycleSort(event.isRightClick());
-                    if (punishment != null) {
+        } else {
-                        new ConfirmationInventory(player, "Do you want to undo this punishment?", () -> {
+            Punishment punishment = slotMap.get(slot);
-                            punishment.undo(player.getUniqueId());
+            if (punishment instanceof TimedPunishment timed && timed.isActive()){
-                            punishment.broadcastUndo(container);
+                if (player.hasPermission("smod.un" + punishment.getType())) {
-                            player.playSound(player, Sound.BLOCK_NOTE_BLOCK_PLING, 1f, 2f);
+                    new ConfirmationInventory(player, translatable("smod.menu.cancelConfirmation"), () -> {
-                            this.open();
+                        punishmentManager.cancel(timed, player.getUniqueId());
-                        }, this::open, false).open();
+                        player.playSound(player, Sound.BLOCK_NOTE_BLOCK_PLING, 1f, 2f);
-                    }
+                        this.open();
+                    }, this::open).open();
                 }
             }
         }

src/main/java/de/shiewk/smoderation/paper/listener/CacheListener.java

@@ -0,0 +1,35 @@
+package de.shiewk.smoderation.paper.listener;
+
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import static de.shiewk.smoderation.paper.SModerationPaper.LOGGER;
+import static net.kyori.adventure.text.Component.translatable;
+
+public class CacheListener implements Listener {
+
+    private final PunishmentManager punishmentManager;
+
+    public CacheListener(PunishmentManager punishmentManager) {
+        this.punishmentManager = punishmentManager;
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event){
+        try {
+            punishmentManager.loadToCache(event.getPlayer().getUniqueId());
+        } catch (Exception e) {
+            LOGGER.error("Failed to load punishments", e);
+            event.getPlayer().kick(translatable("mco.errorMessage.connectionFailure"));
+        }
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event){
+        punishmentManager.removeFromCache(event.getPlayer().getUniqueId());
+    }
+
+}

src/main/java/de/shiewk/smoderation/paper/listener/CustomInventoryListener.java

@@ -15,7 +15,7 @@ public class CustomInventoryListener implements Listener {
     public void onInventoryClick(InventoryClickEvent event){
         if (event.getInventory().getHolder() instanceof CustomInventory customInventory){
             event.setCancelled(true);
-            customInventory.click(event.getCurrentItem(), event);
+            customInventory.click(event);
         }
     }
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
@@ -25,11 +25,15 @@ public class CustomInventoryListener implements Listener {
         }
     }
 
-    public static void onTick(){
+    public static void tickAllPaper(){
         for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
-            if (onlinePlayer.getOpenInventory().getTopInventory().getHolder() instanceof AutoUpdatingCustomInventory ci) {
+            tickForPlayer(onlinePlayer);
-                ci.refresh();
+        }
-            }
+    }
+
+    public static void tickForPlayer(Player onlinePlayer) {
+        if (onlinePlayer.getOpenInventory().getTopInventory().getHolder() instanceof AutoUpdatingCustomInventory ci) {
+            ci.refresh();
         }
     }
 }

src/main/java/de/shiewk/smoderation/paper/listener/FoliaInventoryUpdatingListener.java

@@ -0,0 +1,44 @@
+package de.shiewk.smoderation.paper.listener;
+
+import de.shiewk.smoderation.paper.SModerationPaper;
+import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.metadata.MetadataValue;
+
+public class FoliaInventoryUpdatingListener implements Listener {
+
+    public static final String METADATA_KEY = "smod_invtick";
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event){
+        Player player = event.getPlayer();
+        ScheduledTask task = player.getScheduler().runAtFixedRate(
+                SModerationPaper.PLUGIN,
+                t -> CustomInventoryListener.tickForPlayer(player),
+                null,
+                1,
+                1
+        );
+        player.setMetadata(METADATA_KEY, new FixedMetadataValue(
+                SModerationPaper.PLUGIN,
+                task
+        ));
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event){
+        for (MetadataValue meta : event.getPlayer().getMetadata("smod_invtick")) {
+            if (meta.getOwningPlugin() == SModerationPaper.PLUGIN) {
+                if (meta.value() instanceof ScheduledTask task) {
+                    task.cancel();
+                }
+            }
+        }
+    }
+
+}

src/main/java/de/shiewk/smoderation/paper/listener/PunishmentListener.java

@@ -1,10 +1,10 @@
 package de.shiewk.smoderation.paper.listener;
 
 import de.shiewk.smoderation.paper.SModerationPaper;
-import de.shiewk.smoderation.paper.event.PunishmentIssueEvent;
+import de.shiewk.smoderation.paper.punishments.Ban;
+import de.shiewk.smoderation.paper.punishments.Mute;
 import de.shiewk.smoderation.paper.punishments.Punishment;
-import de.shiewk.smoderation.paper.punishments.PunishmentType;
+import de.shiewk.smoderation.paper.punishments.PunishmentManager;
-import de.shiewk.smoderation.paper.storage.PunishmentContainer;
 import io.papermc.paper.event.player.AsyncChatEvent;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
@@ -12,62 +12,56 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
-import org.bukkit.event.world.WorldSaveEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 
-import static de.shiewk.smoderation.paper.SModerationPaper.CHAT_PREFIX;
+import java.util.List;
+
+import static de.shiewk.smoderation.paper.SModerationPaper.PRIMARY_COLOR;
+import static net.kyori.adventure.text.Component.translatable;
 
 public class PunishmentListener implements Listener {
 
+    private final PunishmentManager punishmentManager;
+
+    public PunishmentListener(PunishmentManager punishmentManager) {
+        this.punishmentManager = punishmentManager;
+    }
+
     @EventHandler(priority = EventPriority.LOW)
     public void onPlayerLogin(AsyncPlayerPreLoginEvent event){
-        // Have to use AsyncPlayerPreLoginEvent since PlayerLoginEvent is deprecated in newer versions
+        List<Punishment> list = punishmentManager.byTargetUUID(event.getUniqueId(), p -> p instanceof Ban ban && ban.isActive());
-        // I would use the new PlayerConnectionValidateLoginEvent but there is literally no API available
+        if (!list.isEmpty()) {
-        // there to get player's UUIDs
+            event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED, list.getFirst().infoMessage());
-        Punishment punishment = SModerationPaper.container.find(p ->
-                p.type == PunishmentType.BAN
-                && p.to.equals(event.getUniqueId())
-                && p.isActive());
-        if (punishment != null){
-            event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED, CHAT_PREFIX.append(punishment.playerMessage()));
         }
     }
 
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
     public void onPlayerChat(AsyncChatEvent event){
         final Player player = event.getPlayer();
-        final Punishment punishment = SModerationPaper.container.find(p ->
+        List<Punishment> list = punishmentManager.byTargetUUID(player.getUniqueId(), p -> p instanceof Mute mute && mute.isActive());
-                p.type == PunishmentType.MUTE
+        if (!list.isEmpty()) {
-                        && p.to.equals(player.getUniqueId())
-                        && p.isActive());
-        if (punishment != null) {
             event.setCancelled(true);
-            player.sendMessage(CHAT_PREFIX.append(punishment.playerMessage()));
+            player.sendMessage(list.getFirst().infoMessage().colorIfAbsent(PRIMARY_COLOR));
         }
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-    public void onPunishmentIssue(PunishmentIssueEvent event){
+    public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event){
-        final Punishment punishment = event.getPunishment();
+        Player player = event.getPlayer();
-        final PunishmentContainer container = event.getContainer();
+        List<Punishment> list = punishmentManager.byTargetUUID(player.getUniqueId(), p -> p instanceof Mute mute && mute.isActive());
-        final Punishment duplicate = container.find(p -> p.to.equals(punishment.to) && p.type == punishment.type && p.isActive());
+        if (!list.isEmpty()) { // Player is muted
-        if (duplicate != null){
+            List<String> forbiddenCommands = SModerationPaper.config().getStringList("muted-forbidden-commands");
-            container.remove(duplicate);
+            final String message = event.getMessage();
-            container.add(new Punishment(duplicate.type, duplicate.time, System.currentTimeMillis(), duplicate.by, duplicate.to, duplicate.reason));
+            if (forbiddenCommands.stream().anyMatch(str ->
-        }
+                    message.toLowerCase().startsWith("/"+str.toLowerCase()+" ")
-        switch (punishment.type){
+                            || message.toLowerCase().startsWith(str.toLowerCase()+" ")
-            case KICK, BAN -> {
+            )){
-                final Player player = Bukkit.getPlayer(punishment.to);
+                Bukkit.getConsoleSender().sendMessage(player.getName() + " tried to run forbidden command while muted");
-                if (player != null) {
+                player.sendMessage(translatable("smod.punishment.playerMessage.mute.chat", PRIMARY_COLOR));
-                    player.kick(CHAT_PREFIX.append(punishment.playerMessage()));
+                event.setCancelled(true);
-                }
             }
         }
+
     }
 
-    @EventHandler
-    public void onWorldSave(WorldSaveEvent event){
-        if (event.getWorld().equals(Bukkit.getServer().getWorlds().getFirst())){
-            SModerationPaper.container.save(SModerationPaper.SAVE_FILE);
-        }
-    }
 }

src/main/java/de/shiewk/smoderation/paper/listener/SocialSpyListener.java

@@ -16,9 +16,8 @@ import org.bukkit.persistence.PersistentDataType;
 
 import java.util.List;
 
-import static de.shiewk.smoderation.paper.SModerationPaper.PRIMARY_COLOR;
-import static de.shiewk.smoderation.paper.SModerationPaper.SECONDARY_COLOR;
 import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.Component.translatable;
 
 public class SocialSpyListener implements Listener {
 
@@ -59,11 +58,11 @@ public class SocialSpyListener implements Listener {
 
     @EventHandler(ignoreCancelled = true, priority = EventPriority.NORMAL)
     public void onPlayerSendCommand(PlayerCommandPreprocessEvent event){
-        List<String> socialSpyCommands = SModerationPaper.CONFIG.getSocialSpyCommands();
+        List<String> socialSpyCommands = SModerationPaper.config().getStringList("socialspy-commands");
         final String message = event.getMessage();
         if (socialSpyCommands.stream().anyMatch(str ->
-                message.startsWith("/"+str+" ")
+                message.toLowerCase().startsWith("/"+str.toLowerCase()+" ")
-                || message.startsWith(str+" ")
+                        || message.toLowerCase().startsWith(str.toLowerCase()+" ")
         )){
             SocialSpyListener.command(event.getPlayer(), message);
         }
@@ -71,13 +70,7 @@ public class SocialSpyListener implements Listener {
 
     public static void command(Player player, String command){
         for (CommandSender target : targets) {
-            target.sendMessage(text("[", PRIMARY_COLOR)
+            target.sendMessage(translatable("smod.socialspy.command", player.teamDisplayName(), text(command)));
-                    .append(text("SocialSpy", SECONDARY_COLOR))
-                    .append(text("] "))
-                    .append(player.displayName().colorIfAbsent(PRIMARY_COLOR))
-                    .append(text(": ", PRIMARY_COLOR))
-                    .append(text(command, SECONDARY_COLOR))
-            );
         }
     }
 

src/main/java/de/shiewk/smoderation/paper/listener/VanishListener.java

@@ -3,22 +3,25 @@ package de.shiewk.smoderation.paper.listener;
 import de.shiewk.smoderation.paper.SModerationPaper;
 import de.shiewk.smoderation.paper.command.VanishCommand;
 import de.shiewk.smoderation.paper.util.SchedulerUtil;
+import io.papermc.paper.event.entity.WardenAngerChangeEvent;
 import net.kyori.adventure.key.Key;
 import net.kyori.adventure.sound.Sound;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.TextDecoration;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityTargetEvent;
 import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerAdvancementDoneEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.persistence.PersistentDataType;
 
 import static de.shiewk.smoderation.paper.SModerationPaper.SECONDARY_COLOR;
 import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.Component.translatable;
 
 public class VanishListener implements Listener {
 
@@ -54,11 +57,7 @@ public class VanishListener implements Listener {
                     broadcast(message.color(null));
                 }
                 SchedulerUtil.scheduleForEntity(SModerationPaper.PLUGIN, player, () -> {
-                    player.sendMessage(SModerationPaper.CHAT_PREFIX
+                    player.sendMessage(translatable("smod.command.vanish.stillEnabled"));
-                            .decorate(TextDecoration.BOLD)
-                            .append(
-                                    text("You are still vanished!")
-                    ));
                     player.playSound(Sound.sound(
                             Key.key("minecraft", "block.beacon.power_select"),
                             Sound.Source.MASTER,
@@ -90,9 +89,33 @@ public class VanishListener implements Listener {
         }
     }
 
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onEntityTarget(EntityTargetEvent event){
+        if (event.getTarget() instanceof Player pl && VanishCommand.isVanished(pl)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onEntityTarget(WardenAngerChangeEvent event){
+        if (event.getTarget() instanceof Player pl && VanishCommand.isVanished(pl)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onAdvancementDone(PlayerAdvancementDoneEvent event){
+        Player pl = event.getPlayer();
+        Component message = event.message();
+        if (VanishCommand.isVanished(pl) && message != null) {
+            broadcast(message);
+            event.message(null);
+        }
+    }
+
     private static void broadcast(Component message) {
         Component result = PREFIX.append(message);
-        SModerationPaper.LOGGER.info(result);
+        Bukkit.getConsoleSender().sendMessage(result);
         for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
             if (onlinePlayer.hasPermission("smod.vanish.see")){
                 onlinePlayer.sendMessage(result);

src/main/java/de/shiewk/smoderation/paper/punishments/Ban.java

@@ -0,0 +1,46 @@
+package de.shiewk.smoderation.paper.punishments;
+
+import de.shiewk.smoderation.paper.inventory.CustomInventory;
+import de.shiewk.smoderation.paper.util.SerializationHelper;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.jspecify.annotations.NonNull;
+
+import java.util.UUID;
+
+public class Ban extends TimedPunishment {
+
+    public Ban(UUID id, long timestamp, UUID issuer, UUID target, String reason, long duration, UUID cancelledBy) {
+        super(id, "ban", timestamp, issuer, target, reason, duration, cancelledBy);
+    }
+
+    public Ban(UUID id, long timestamp, UUID issuer, UUID target, String reason, long duration) {
+        this(id, timestamp, issuer, target, reason, duration, null);
+    }
+
+    public static class Factory implements PunishmentFactory<Ban> {
+
+        @Override
+        public @NonNull Ban deserialize(SerializationHelper helper) {
+            return new Ban(
+                    helper.getUUID("id"),
+                    helper.getLong("timestamp"),
+                    helper.getUUID("issuer"),
+                    helper.getUUID("target"),
+                    helper.getString("reason"),
+                    helper.getLong("duration"),
+                    helper.getUUID("cancelledBy", null)
+            );
+        }
+    }
+
+    @Override
+    public void processIssue() {
+        super.processIssue();
+        final Player player = Bukkit.getPlayer(getTargetID());
+        if (player != null) {
+            player.kick(CustomInventory.renderComponent(player, infoMessage()));
+        }
+    }
+
+}

src/main/java/de/shiewk/smoderation/paper/punishments/Kick.java

@@ -0,0 +1,40 @@
+package de.shiewk.smoderation.paper.punishments;
+
+import de.shiewk.smoderation.paper.inventory.CustomInventory;
+import de.shiewk.smoderation.paper.util.SerializationHelper;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.jspecify.annotations.NonNull;
+
+import java.util.UUID;
+
+public class Kick extends Punishment {
+
+    public Kick(UUID id, long timestamp, UUID issuer, UUID target, String reason) {
+        super(id, "kick", timestamp, issuer, target, reason);
+    }
+
+    public static class Factory implements PunishmentFactory<Kick> {
+
+        @Override
+        public @NonNull Kick deserialize(SerializationHelper helper) {
+            return new Kick(
+                    helper.getUUID("id"),
+                    helper.getLong("timestamp"),
+                    helper.getUUID("issuer"),
+                    helper.getUUID("target"),
+                    helper.getString("reason")
+            );
+        }
+
+    }
+
+    @Override
+    public void processIssue() {
+        super.processIssue();
+        final Player player = Bukkit.getPlayer(getTargetID());
+        if (player != null) {
+            player.kick(CustomInventory.renderComponent(player, infoMessage()));
+        }
+    }
+}

src/main/java/de/shiewk/smoderation/paper/punishments/Mute.java

@@ -0,0 +1,34 @@
+package de.shiewk.smoderation.paper.punishments;
+
+import de.shiewk.smoderation.paper.util.SerializationHelper;
+import org.jspecify.annotations.NonNull;
+
+import java.util.UUID;
+
+public class Mute extends TimedPunishment {
+
+    public Mute(UUID id, long timestamp, UUID issuer, UUID target, String reason, long duration, UUID cancelledBy) {
+        super(id, "mute", timestamp, issuer, target, reason, duration, cancelledBy);
+    }
+
+    public Mute(UUID id, long timestamp, UUID issuer, UUID target, String reason, long duration) {
+        this(id, timestamp, issuer, target, reason, duration, null);
+    }
+
+    public static class Factory implements PunishmentFactory<Mute> {
+
+        @Override
+        public @NonNull Mute deserialize(SerializationHelper helper) {
+            return new Mute(
+                    helper.getUUID("id"),
+                    helper.getLong("timestamp"),
+                    helper.getUUID("issuer"),
+                    helper.getUUID("target"),
+                    helper.getString("reason"),
+                    helper.getLong("duration"),
+                    helper.getUUID("cancelledBy", null)
+            );
+        }
+
+    }
+}

src/main/java/de/shiewk/smoderation/paper/punishments/Punishment.java

@@ -1,261 +1,121 @@
 package de.shiewk.smoderation.paper.punishments;
 
-import de.shiewk.smoderation.paper.event.PunishmentIssueEvent;
-import de.shiewk.smoderation.paper.storage.PunishmentContainer;
-import de.shiewk.smoderation.paper.util.ByteUtil;
 import de.shiewk.smoderation.paper.util.PlayerUtil;
-import de.shiewk.smoderation.paper.util.TimeUtil;
+import de.shiewk.smoderation.paper.util.SerializationHelper;
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
-import java.io.EOFException;
+import java.util.List;
-import java.io.IOException;
+import java.util.Random;
-import java.io.InputStream;
-import java.io.OutputStream;
 import java.util.UUID;
 
-import static de.shiewk.smoderation.paper.SModerationPaper.*;
+import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.Component.translatable;
 
-public class Punishment {
+public abstract class Punishment {
-    public static final String DEFAULT_REASON = "No reason provided.";
-    public final PunishmentType type;
-    public final long time;
-    public final long until;
-    public final UUID by;
-    public final UUID to;
-    public final String reason;
-    private UUID undoneBy;
 
-    public Punishment(PunishmentType type, long time, long until, UUID by, UUID to, String reason) {
+    protected final UUID id;
-        this(type, time, until, by, to, reason, null);
+    protected final String type;
-    }
+    protected final long timestamp;
+    protected final UUID issuer;
+    protected final UUID target;
+    protected final String reason;
 
-    private Punishment(PunishmentType type, long time, long until, UUID by, UUID to, String reason, UUID undoneBy) {
+    protected Punishment(UUID id, String type, long timestamp, UUID issuer, UUID target, String reason) {
+        this.id = id;
         this.type = type;
-        this.time = time;
+        this.timestamp = timestamp;
-        this.until = until;
+        this.issuer = issuer;
-        this.by = by;
+        this.target = target;
-        this.to = to;
         this.reason = reason;
-        this.undoneBy = undoneBy;
     }
 
-    private static byte[] readStreamInternal(InputStream stream, int len) throws IOException {
+    public UUID getID() {
-        final byte[] bytes = stream.readNBytes(len);
+        return id;
-        if (bytes.length != len){
+    }
-            throw new EOFException("Stream has ended before enough bytes were read");
+
+    public String getType() {
+        return type;
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public UUID getIssuerID() {
+        return issuer;
+    }
+
+    public UUID getTargetID() {
+        return target;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+
+    public void addSerializableProperties(SerializationHelper helper){
+        helper.putUUID("id", id);
+        helper.putString("type", type);
+        helper.putLong("timestamp", timestamp);
+        helper.putUUID("issuer", issuer);
+        helper.putUUID("target", target);
+        helper.putString("reason", reason);
+    }
+
+    public boolean matchesSearchQuery(String query){
+        if (query == null) return true;
+        query = query.toLowerCase();
+        return reason.toLowerCase().contains(query)
+                || issuer.toString().equalsIgnoreCase(query)
+                || target.toString().equalsIgnoreCase(query)
+                || PlayerUtil.offlinePlayerName(issuer).toLowerCase().contains(query)
+                || PlayerUtil.offlinePlayerName(target).toLowerCase().contains(query);
+    }
+
+    public Component infoMessage(){
+        return translatable(
+                "smod.punishment.playerMessage." + type,
+                text(PlayerUtil.offlinePlayerName(this.issuer)),
+                text(reason)
+        );
+    }
+
+    public Component adminMessage(){
+        return translatable(
+                "smod.punishment.broadcast." + type,
+                text(PlayerUtil.offlinePlayerName(target)),
+                text(PlayerUtil.offlinePlayerName(issuer)),
+                text(reason)
+        );
+    }
+
+    public void processIssue() {
+        CommandSender sender = PlayerUtil.senderByUUID(target);
+        if (sender != null) {
+            sender.sendMessage(infoMessage());
         }
-        return bytes;
+        for (CommandSender target : getBroadcastTargets()) {
-    }
+            target.sendMessage(adminMessage());
-
-    public static Punishment load(InputStream in) throws IOException {
-        PunishmentType type = PunishmentType.values()[ByteUtil.bytesToInt(readStreamInternal(in, 4))];
-        long time = ByteUtil.bytesToLong(readStreamInternal(in, 8));
-        long until = ByteUtil.bytesToLong(readStreamInternal(in, 8));
-        UUID by = ByteUtil.bytesToUuid(readStreamInternal(in, 16));
-        UUID to = ByteUtil.bytesToUuid(readStreamInternal(in, 16));
-        int reasonLen = ByteUtil.bytesToInt(readStreamInternal(in, 4));
-        String reason = new String(readStreamInternal(in, reasonLen));
-        UUID undoneBy = null;
-        boolean undone = in.read() == 1;
-        if (undone){
-            undoneBy = ByteUtil.bytesToUuid(readStreamInternal(in, 16));
-        }
-        return new Punishment(type, time, until, by, to, reason, undoneBy);
-    }
-
-    public boolean wasUndone(){
-        return undoneBy != null;
-    }
-
-    public UUID undoneBy() {
-        return undoneBy;
-    }
-
-    public void undo(UUID undoneBy){
-        if (this.undoneBy != null){
-            throw new IllegalArgumentException("This punishment was already undone.");
-        }
-        this.undoneBy = undoneBy;
-    }
-
-    public boolean isActive(){
-        return until > System.currentTimeMillis() && !wasUndone();
-    }
-
-    public static Punishment mute(long time, long until, UUID by, UUID to, String reason){
-        return new Punishment(PunishmentType.MUTE, time, until, by, to, reason);
-    }
-
-    public static Punishment ban(long time, long until, UUID by, UUID to, String reason){
-        return new Punishment(PunishmentType.BAN, time, until, by, to, reason);
-    }
-
-    public static Punishment kick(long time, UUID by, UUID to, String reason){
-        return new Punishment(PunishmentType.KICK, time, time, by, to, reason);
-    }
-
-    private static final int BUFFER_LENGTH = 56;
-
-    public void writeBytes(OutputStream stream) throws IOException {
-        stream.write(ByteUtil.intToBytes(type.ordinal()));
-        stream.write(ByteUtil.longToBytes(time));
-        stream.write(ByteUtil.longToBytes(until));
-        stream.write(ByteUtil.uuidToBytes(by));
-        stream.write(ByteUtil.uuidToBytes(to));
-        final byte[] reasonBytes = reason.getBytes();
-        stream.write(ByteUtil.intToBytes(reasonBytes.length));
-        stream.write(reasonBytes);
-        stream.write(wasUndone() ? 1 : 0);
-        if (wasUndone()){
-            stream.write(ByteUtil.uuidToBytes(undoneBy));
         }
     }
 
-    private Component undoMessage(){
+    public static List<CommandSender> getBroadcastTargets() {
-        String msg = "";
+        ObjectArrayList<CommandSender> senders = new ObjectArrayList<>();
-        switch (type){
+        senders.add(Bukkit.getConsoleSender());
-            case MUTE -> msg = "unmuted";
+        for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
-            case KICK -> msg = "unkicked??";
+            if (onlinePlayer.hasPermission("smod.notifications")){
-            case BAN -> msg = "unbanned";
+                senders.add(onlinePlayer);
-        }
-        return Component.text(PlayerUtil.offlinePlayerName(to)).color(SECONDARY_COLOR)
-                .append(Component.text(" was ").color(PRIMARY_COLOR))
-                .append(Component.text(msg))
-                .append(Component.text(" by ").color(PRIMARY_COLOR))
-                .append(Component.text(PlayerUtil.offlinePlayerName(undoneBy)))
-                .append(Component.text(".").color(PRIMARY_COLOR));
-    }
-
-    public void broadcastUndo(PunishmentContainer container){
-        for (CommandSender sender : container.collectBroadcastTargets()) {
-            sender.sendMessage(CHAT_PREFIX.append(undoMessage()));
-        }
-    }
-
-    @Override
-    public String toString() {
-        return "Punishment{" +
-                "type=" + type +
-                ", time=" + time +
-                ", until=" + until +
-                ", by=" + by +
-                ", to=" + to +
-                ", reason=" + reason +
-                '}';
-    }
-
-    public static void issue(Punishment punishment, PunishmentContainer container){
-        final PunishmentIssueEvent event = new PunishmentIssueEvent(punishment, container);
-        Bukkit.getPluginManager().callEvent(event);
-        if (!event.isCancelled()){
-            container.add(punishment);
-            punishment.firstIssue(container);
-        }
-    }
-
-    private Component broadcastMessage(){
-        final String toName = PlayerUtil.offlinePlayerName(to);
-        switch (type) {
-            case MUTE -> {
-                return Component.text(toName).color(SECONDARY_COLOR).append(
-                        Component.text(" has been muted by ").color(PRIMARY_COLOR)
-                        .append(Component.text(PlayerUtil.offlinePlayerName(this.by)).color(SECONDARY_COLOR))
-                        .append(Component.text(" for "))
-                        .append(Component.text(TimeUtil.formatTimeLong(this.until - this.time)).color(SECONDARY_COLOR))
-                        .append(Component.text(".\nReason: "))
-                        .append(Component.text(reason).color(SECONDARY_COLOR)));
-            }
-            case KICK -> {
-                return Component.text(toName).color(SECONDARY_COLOR).append(
-                        Component.text(" has been kicked by ").color(PRIMARY_COLOR)
-                        .append(Component.text(PlayerUtil.offlinePlayerName(this.by)).color(SECONDARY_COLOR))
-                        .append(Component.text(".\nReason: "))
-                        .append(Component.text(reason).color(SECONDARY_COLOR))
-                        .color(PRIMARY_COLOR));
-            }
-            case BAN -> {
-                return Component.text(toName).color(SECONDARY_COLOR).append(
-                        Component.text(" has been banned by ").color(PRIMARY_COLOR)
-                        .append(Component.text(PlayerUtil.offlinePlayerName(this.by)).color(SECONDARY_COLOR))
-                        .append(Component.text(" for "))
-                        .append(Component.text(TimeUtil.formatTimeLong(this.until - this.time)).color(SECONDARY_COLOR))
-                        .append(Component.text(".\nReason: "))
-                        .append(Component.text(reason).color(SECONDARY_COLOR))
-                        .color(PRIMARY_COLOR));
-            }
-            default -> throw new IllegalStateException("Unknown punishment type " + type);
-        }
-    }
-
-    private void broadcastIssue(PunishmentContainer container){
-        for (CommandSender sender : container.collectBroadcastTargets()) {
-            sender.sendMessage(CHAT_PREFIX.append(broadcastMessage()));
-        }
-    }
-
-    private void firstIssue(PunishmentContainer container){
-        switch (type) {
-            case MUTE, BAN -> {
-                final CommandSender sender = PlayerUtil.senderByUUID(to);
-                if (sender != null) {
-                    sender.sendMessage(CHAT_PREFIX.append(playerMessage()));
-                }
             }
         }
-        broadcastIssue(container);
+        return List.copyOf(senders);
     }
 
-    public Component playerMessage(){
+    public static UUID generateUUID() {
-        switch (type) {
+        Random random = new Random();
-            case MUTE -> {
+        return new UUID(System.currentTimeMillis(), random.nextLong());
-                return Component.text("You have been muted by ")
-                    .append(Component.text(PlayerUtil.offlinePlayerName(this.by)).color(SECONDARY_COLOR))
-                    .append(Component.text(".\nReason: "))
-                    .append(Component.text(reason).color(SECONDARY_COLOR))
-                    .append(Component.text("\nYour mute expires in "))
-                    .append(Component.text(TimeUtil.formatTimeLong(this.until - System.currentTimeMillis())).color(SECONDARY_COLOR))
-                    .append(Component.text("."))
-                    .color(PRIMARY_COLOR);
-            }
-            case KICK -> {
-                return Component.text("You have been kicked by ")
-                    .append(Component.text(PlayerUtil.offlinePlayerName(this.by)).color(SECONDARY_COLOR))
-                    .append(Component.text(".\nReason: "))
-                    .append(Component.text(reason).color(SECONDARY_COLOR))
-                    .color(PRIMARY_COLOR);
-            }
-            case BAN -> {
-                return Component.text("You have been banned from this server by ")
-                        .append(Component.text(PlayerUtil.offlinePlayerName(this.by)).color(SECONDARY_COLOR))
-                        .append(Component.text(".\nReason: "))
-                        .append(Component.text(reason).color(SECONDARY_COLOR))
-                        .append(Component.text("\nYour ban expires in "))
-                        .append(Component.text(TimeUtil.formatTimeLong(this.until - System.currentTimeMillis())).color(SECONDARY_COLOR))
-                        .append(Component.text("."))
-                        .color(PRIMARY_COLOR);
-            }
-            default -> throw new IllegalStateException("Unknown punishment type " + type);
-        }
-    }
-
-    public boolean matchesSearchQuery(String searchQuery) {
-        if (searchQuery == null) return true;
-        searchQuery = searchQuery.toLowerCase();
-        return reason.toLowerCase().contains(searchQuery)
-                || by.toString().equalsIgnoreCase(searchQuery)
-                || to.toString().equalsIgnoreCase(searchQuery)
-                || getPlayerName().toLowerCase().contains(searchQuery)
-                || getModeratorName().toLowerCase().contains(searchQuery);
-
-    }
-
-    private String getPlayerName() {
-        return PlayerUtil.offlinePlayerName(to);
-    }
-
-    private String getModeratorName() {
-        return PlayerUtil.offlinePlayerName(by);
     }
 }

src/main/java/de/shiewk/smoderation/paper/punishments/PunishmentFactory.java

@@ -0,0 +1,10 @@
+package de.shiewk.smoderation.paper.punishments;
+
+import de.shiewk.smoderation.paper.util.SerializationHelper;
+import org.jetbrains.annotations.NotNull;
+
+public interface PunishmentFactory<T extends Punishment> {
+
+    @NotNull T deserialize(SerializationHelper helper);
+
+}

src/main/java/de/shiewk/smoderation/paper/punishments/PunishmentManager.java

@@ -0,0 +1,193 @@
+package de.shiewk.smoderation.paper.punishments;
+
+import com.google.gson.JsonObject;
+import com.google.gson.Strictness;
+import com.google.gson.stream.JsonReader;
+import de.shiewk.smoderation.paper.SModerationPaper;
+import de.shiewk.smoderation.paper.event.PunishmentIssueEvent;
+import de.shiewk.smoderation.paper.util.PlayerUtil;
+import de.shiewk.smoderation.paper.util.SerializationHelper;
+import it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap;
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import static de.shiewk.smoderation.paper.SModerationPaper.LOGGER;
+
+public final class PunishmentManager {
+
+    private static final Logger log = LoggerFactory.getLogger(PunishmentManager.class);
+    private final Object2ObjectArrayMap<String, PunishmentFactory<?>> typeRegistry = new Object2ObjectArrayMap<>(1);
+    private final ConcurrentHashMap<UUID, List<Punishment>> cache = new ConcurrentHashMap<>(1);
+    private final Object ioLock = new Object();
+    private final Path dataDir;
+
+    public PunishmentManager(Path dataDir) {
+        this.dataDir = dataDir;
+    }
+
+    private Path getTargetFile(UUID targetUUID){
+        return dataDir.resolve(targetUUID.toString().replace("-", ""));
+    }
+
+    public boolean tryIssue(Punishment punishment) {
+        try {
+            PunishmentIssueEvent event = new PunishmentIssueEvent(punishment, this);
+            Bukkit.getPluginManager().callEvent(event);
+            if (!event.isCancelled()){
+                this.appendToSave(punishment);
+                punishment.processIssue();
+                return true;
+            }
+            return false;
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public List<Punishment> byTargetUUID(UUID target) {
+        List<Punishment> cached = cache.get(target);
+        if (cached != null) {
+            return cached;
+        }
+        synchronized (ioLock) {
+            Path file = getTargetFile(target);
+
+            if (!Files.exists(file)) {
+                return List.of();
+            }
+            try (
+                    BufferedReader reader = Files.newBufferedReader(file);
+                    JsonReader json = new JsonReader(reader)
+            ) {
+                json.setStrictness(Strictness.LENIENT);
+                Object2ObjectArrayMap<UUID, Punishment> punishments = new Object2ObjectArrayMap<>(0);
+                while (json.hasNext()){
+                    JsonObject obj = SModerationPaper.gson.fromJson(json, JsonObject.class);
+                    try {
+                        SerializationHelper helper = new SerializationHelper(obj);
+                        String type = helper.getString("type");
+                        PunishmentFactory<?> factory = typeRegistry.get(type);
+                        if (factory != null){
+                            Punishment punishment = factory.deserialize(helper);
+                            if (!punishment.getTargetID().equals(target)){
+                                LOGGER.warn("Punishment saved in file for {} has incorrect target UUID {}", target, punishment.getTargetID());
+                            } else {
+                                punishments.put(punishment.getID(), punishment);
+                            }
+                        } else {
+                            LOGGER.warn("Unknown punishment type '{}'! Can not load.", type);
+                            LOGGER.warn("Please check your configuration, or see file {} to remove corrupted data.", file);
+                            LOGGER.warn(obj.toString());
+                        }
+                    } catch (Exception e) {
+                        LOGGER.warn("Could not deserialize punishment!", e);
+                        LOGGER.warn("Please check file {} for corrupted data, or remove the corresponding line.", file);
+                        LOGGER.warn(obj.toString());
+                    }
+                }
+                return List.copyOf(punishments.values());
+            } catch (IOException e){
+                throw new RuntimeException("Error while reading punishment file " + file, e);
+            }
+        }
+    }
+
+    public List<Punishment> byTargetUUID(UUID target, Predicate<Punishment> filter) {
+        return byTargetUUID(target).stream().filter(filter).toList();
+    }
+
+    public <T extends Punishment> void registerType(String type, PunishmentFactory<T> factory){
+        if (typeRegistry.containsKey(type)) {
+            throw new IllegalStateException("Punishment type already registered: " + type);
+        }
+        typeRegistry.put(type, factory);
+    }
+
+    public List<String> getRegisteredTypes(){
+        return List.copyOf(typeRegistry.keySet());
+    }
+
+    public void appendToSave(Punishment punishment) throws IOException {
+        synchronized (ioLock) {
+            Path file = getTargetFile(punishment.getTargetID());
+            if (!Files.exists(file)) {
+                Files.createDirectories(dataDir);
+                Files.createFile(file);
+            }
+            try (BufferedWriter writer = Files.newBufferedWriter(file, StandardOpenOption.APPEND)) {
+                JsonObject json = new JsonObject();
+                punishment.addSerializableProperties(new SerializationHelper(json));
+                SModerationPaper.gson.toJson(json, writer);
+                writer.append('\n');
+            }
+        }
+        addToCachedList(punishment);
+    }
+
+    public @NotNull List<Punishment> getAll() throws IOException {
+        ObjectArrayList<Punishment> punishments = new ObjectArrayList<>();
+        synchronized (ioLock) {
+            try (Stream<Path> stream = Files.list(dataDir)) {
+                stream.forEach(file -> {
+                    try {
+                        String name = file.getFileName().toString();
+                        UUID targetUUID = PlayerUtil.uuidFromString(name);
+                        punishments.addAll(byTargetUUID(targetUUID));
+                    } catch (Exception e) {
+                        log.warn("Could not read punishment file {}", file, e);
+                    }
+                });
+            }
+        }
+        return List.copyOf(punishments);
+    }
+
+    public List<Punishment> getAll(Predicate<Punishment> filter) throws IOException {
+        return getAll().stream().filter(filter).toList();
+    }
+
+    public void cancel(TimedPunishment punishment, UUID canceller) {
+        if (!punishment.isActive()){
+            throw new IllegalStateException("This punishment is not active");
+        }
+        punishment.cancel(canceller);
+        try {
+            appendToSave(punishment);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void loadToCache(UUID uuid) {
+        removeFromCache(uuid);
+        cache.put(uuid, byTargetUUID(uuid));
+    }
+
+    public void removeFromCache(UUID uuid) {
+        cache.remove(uuid);
+    }
+
+    private void addToCachedList(Punishment punishment) {
+        cache.computeIfPresent(punishment.getTargetID(), (k, v) -> {
+            ObjectArrayList<Punishment> newList = new ObjectArrayList<>(v);
+            newList.add(punishment);
+            return List.copyOf(newList);
+        });
+    }
+
+}

src/main/java/de/shiewk/smoderation/paper/punishments/PunishmentType.java

@@ -1,13 +0,0 @@
-package de.shiewk.smoderation.paper.punishments;
-
-public enum PunishmentType {
-    MUTE("Mute"),
-    KICK("Kick"),
-    BAN("Ban");
-
-    public final String name;
-
-    PunishmentType(String name) {
-        this.name = name;
-    }
-}

src/main/java/de/shiewk/smoderation/paper/punishments/TimedPunishment.java

@@ -0,0 +1,120 @@
+package de.shiewk.smoderation.paper.punishments;
+
+import de.shiewk.smoderation.paper.command.argument.DurationArgument;
+import de.shiewk.smoderation.paper.util.PlayerUtil;
+import de.shiewk.smoderation.paper.util.SerializationHelper;
+import de.shiewk.smoderation.paper.util.TimeUtil;
+import net.kyori.adventure.text.Component;
+import org.bukkit.command.CommandSender;
+
+import java.util.UUID;
+
+import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.Component.translatable;
+
+public abstract class TimedPunishment extends Punishment {
+
+    protected final long duration;
+    protected UUID cancelledBy;
+
+    protected TimedPunishment(UUID id, String type, long timestamp, UUID issuer, UUID target, String reason, long duration, UUID cancelledBy) {
+        super(id, type, timestamp, issuer, target, reason);
+        this.duration = duration;
+        this.cancelledBy = cancelledBy;
+    }
+
+    public long getDuration() {
+        return duration;
+    }
+
+    public UUID getCancelledBy() {
+        return cancelledBy;
+    }
+
+    public boolean wasCancelled(){
+        return cancelledBy != null;
+    }
+
+    public boolean isActive(){
+        return !wasCancelled() && (isPermanent() || System.currentTimeMillis() < getExpiry());
+    }
+
+    @Override
+    public void addSerializableProperties(SerializationHelper helper) {
+        super.addSerializableProperties(helper);
+        helper.putLong("duration", duration);
+        helper.putUUID("cancelledBy", cancelledBy);
+    }
+
+    @Override
+    public boolean matchesSearchQuery(String query) {
+        if (super.matchesSearchQuery(query)) return true;
+        query = query.toLowerCase();
+        return cancelledBy.toString().equalsIgnoreCase(query)
+                || PlayerUtil.offlinePlayerName(cancelledBy).toLowerCase().contains(query);
+    }
+
+    @Override
+    public Component infoMessage(){
+        if (isPermanent()){
+            return translatable(
+                    "smod.punishment.playerMessage." + type + ".permanent",
+                    text(PlayerUtil.offlinePlayerName(this.issuer)),
+                    text(reason)
+            );
+        } else {
+            return translatable(
+                    "smod.punishment.playerMessage." + type,
+                    text(PlayerUtil.offlinePlayerName(this.issuer)),
+                    text(reason),
+                    TimeUtil.formatTimeLong(this.timestamp + this.duration - System.currentTimeMillis())
+            );
+        }
+    }
+
+    @Override
+    public Component adminMessage(){
+        if (isPermanent()){
+            return translatable(
+                    "smod.punishment.broadcast." + type + ".permanent",
+                    text(PlayerUtil.offlinePlayerName(target)),
+                    text(PlayerUtil.offlinePlayerName(issuer)),
+                    text(reason)
+            );
+        } else {
+            return translatable(
+                    "smod.punishment.broadcast." + type,
+                    text(PlayerUtil.offlinePlayerName(target)),
+                    text(PlayerUtil.offlinePlayerName(issuer)),
+                    text(reason),
+                    TimeUtil.formatTimeLong(this.duration)
+            );
+        }
+    }
+
+    public Component cancelMessage(){
+        return translatable(
+                "smod.punishment.cancel." + type,
+                text(PlayerUtil.offlinePlayerName(target)),
+                text(PlayerUtil.offlinePlayerName(cancelledBy))
+        );
+    }
+
+    public long getExpiry() {
+        return isPermanent() ? Long.MAX_VALUE : getTimestamp() + getDuration();
+    }
+
+    public boolean isPermanent() {
+        return getDuration() == DurationArgument.INFINITE_DURATION;
+    }
+
+    protected void cancel(UUID canceller) {
+        if (this.cancelledBy != null){
+            throw new IllegalArgumentException("This punishment was already cancelled.");
+        }
+        this.cancelledBy = canceller;
+        for (CommandSender sender : getBroadcastTargets()) {
+            sender.sendMessage(cancelMessage());
+        }
+    }
+}

src/main/java/de/shiewk/smoderation/paper/storage/PunishmentContainer.java

@@ -1,124 +0,0 @@
-package de.shiewk.smoderation.paper.storage;
-
-import de.shiewk.smoderation.paper.SModerationPaper;
-import de.shiewk.smoderation.paper.punishments.Punishment;
-import net.kyori.adventure.text.logger.slf4j.ComponentLogger;
-import org.bukkit.Bukkit;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.*;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.function.Predicate;
-import java.util.zip.GZIPInputStream;
-import java.util.zip.GZIPOutputStream;
-
-public class PunishmentContainer {
-
-    private final CopyOnWriteArrayList<Punishment> punishments = new CopyOnWriteArrayList<>();
-
-    public PunishmentContainer(){}
-
-    public void add(Punishment punishment){
-        punishments.add(punishment);
-    }
-
-    public @Nullable Punishment remove(int index){
-        return punishments.remove(index);
-    }
-
-    public void remove(Punishment punishment){
-        punishments.remove(punishment);
-    }
-
-    public @Nullable Punishment find(Predicate<Punishment> predicate){
-        for (Punishment punishment : punishments) {
-            if (predicate.test(punishment)){
-                return punishment;
-            }
-        }
-        return null;
-    }
-
-    public @NotNull List<Punishment> findAll(Predicate<Punishment> predicate){
-        List<Punishment> found = new ArrayList<>();
-        for (Punishment punishment : punishments) {
-            if (predicate.test(punishment)){
-                found.add(punishment);
-            }
-        }
-        return found;
-    }
-
-    public List<CommandSender> collectBroadcastTargets(){
-        ArrayList<CommandSender> senders = new ArrayList<>();
-        for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
-            if (onlinePlayer.hasPermission("smod.notifications")){
-                senders.add(onlinePlayer);
-            }
-        }
-        senders.add(Bukkit.getConsoleSender());
-        return Collections.unmodifiableList(senders);
-    }
-
-    public @Nullable Punishment findByTimestamp(long timestamp){
-        return find(punishment -> punishment.time == timestamp);
-    }
-
-    public ArrayList<Punishment> copy() {
-        return new ArrayList<>(punishments);
-    }
-
-    public synchronized void load(File file){
-        final ComponentLogger logger = SModerationPaper.LOGGER;
-        try {
-            logger.info("Loading from {}", file.getPath());
-            if (!file.isFile()){
-                logger.warn("The file does not exist.");
-            } else {
-                try (FileInputStream fin = new FileInputStream(file)){
-                    GZIPInputStream gzin = new GZIPInputStream(fin);
-                    while (gzin.available() > 0){
-                        add(Punishment.load(gzin));
-                    }
-                }
-                logger.info("Successfully loaded {} items.", punishments.size());
-            }
-        } catch (EOFException e) {
-            logger.error("The file was not correctly saved, {} items could be recovered!", this.punishments.size());
-        } catch (IOException e){
-            logger.error("An error occurred while loading: {}", e.toString());
-            for (StackTraceElement stackTraceElement : e.getStackTrace()) {
-                logger.error(stackTraceElement.toString());
-            }
-        }
-    }
-
-    public synchronized void save(File file) {
-        final ComponentLogger logger = SModerationPaper.LOGGER;
-        try {
-            if (!file.isFile()){
-                file.mkdirs();
-                file.delete();
-                file.createNewFile();
-            }
-            try (FileOutputStream outputStream = new FileOutputStream(file)) {
-                GZIPOutputStream gzout = new GZIPOutputStream(outputStream);
-                for (Punishment punishment : copy()) {
-                    punishment.writeBytes(gzout);
-                }
-                gzout.close();
-            }
-        } catch (IOException e){
-            logger.error("An error occurred while saving: {}", e.toString());
-            for (StackTraceElement stackTraceElement : e.getStackTrace()) {
-                logger.error(stackTraceElement.toString());
-            }
-        }
-    }
-}

src/main/java/de/shiewk/smoderation/paper/translation/TranslatorManager.java

@@ -0,0 +1,48 @@
+package de.shiewk.smoderation.paper.translation;
+
+import com.google.gson.JsonIOException;
+import com.google.gson.JsonSyntaxException;
+import com.google.gson.reflect.TypeToken;
+import de.shiewk.smoderation.paper.SModerationPaper;
+import net.kyori.adventure.key.Key;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.translation.MiniMessageTranslationStore;
+import net.kyori.adventure.translation.GlobalTranslator;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Locale;
+import java.util.Map;
+
+public class TranslatorManager {
+
+    public final String resourcePath;
+    public final Locale[] availableLocales;
+    private final MiniMessageTranslationStore translationStore;
+
+    public TranslatorManager(Key key, MiniMessage miniMessage, String resourcePath, Locale[] availableLocales) {
+        this.resourcePath = resourcePath;
+        this.availableLocales = availableLocales;
+        this.translationStore = MiniMessageTranslationStore.create(key, miniMessage);
+    }
+
+    public void load(){
+        for (Locale locale : availableLocales) {
+            String s = locale.getLanguage() + "_" + locale.getCountry().toLowerCase();
+            try (InputStream stream = SModerationPaper.class.getClassLoader().getResourceAsStream(resourcePath + s + ".json")) {
+                if (stream == null) {
+                    SModerationPaper.LOGGER.warn("Translations for {} not found or not accessible", locale);
+                    continue;
+                }
+
+                Map<String, String> translationMap = SModerationPaper.gson.fromJson(new InputStreamReader(stream), new TypeToken<>(){});
+                translationStore.registerAll(locale, translationMap);
+
+            } catch (IOException | JsonSyntaxException | JsonIOException e) {
+                SModerationPaper.LOGGER.warn("Failed to load translations for {}", locale, e);
+            }
+        }
+        GlobalTranslator.translator().addSource(translationStore);
+    }
+}

src/main/java/de/shiewk/smoderation/paper/util/ByteUtil.java

@@ -1,60 +0,0 @@
-package de.shiewk.smoderation.paper.util;
-
-import java.nio.ByteBuffer;
-import java.util.UUID;
-
-
-/**
- * Utility class for byte-based saving of integers, longs and UUIDs
- */
-public abstract class ByteUtil {
-    private ByteUtil(){}
-
-    public static byte[] longToBytes(long v){
-        ByteBuffer buffer = ByteBuffer.allocate(8);
-        buffer.putLong(v);
-        return buffer.array();
-    }
-
-    public static long bytesToLong(byte[] i){
-        if (i.length != 8){
-            throw new IllegalArgumentException("length must be 8");
-        }
-        ByteBuffer buffer = ByteBuffer.allocate(8);
-        buffer.put(0, i);
-        return buffer.getLong(0);
-    }
-
-    public static byte[] uuidToBytes(UUID uuid){
-        byte[] l = longToBytes(uuid.getLeastSignificantBits());
-        byte[] m = longToBytes(uuid.getMostSignificantBits());
-        return new byte[]{
-                m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7],
-                l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7]
-        };
-    }
-
-    public static UUID bytesToUuid(byte[] i){
-        if (i.length != 16){
-            throw new IllegalArgumentException("length must be 16, was " + i.length);
-        }
-        long l = bytesToLong(new byte[]{ i[8], i[9], i[10], i[11], i[12], i[13], i[14], i[15] });
-        long m = bytesToLong(new byte[]{ i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7] });
-        return new UUID(m, l);
-    }
-
-    public static int bytesToInt(byte[] bytes) {
-        if (bytes.length != 4){
-            throw new IllegalArgumentException("length must be 4");
-        }
-        ByteBuffer buffer = ByteBuffer.allocate(4);
-        buffer.put(0, bytes);
-        return buffer.getInt(0);
-    }
-
-    public static byte[] intToBytes(int value) {
-        ByteBuffer buffer = ByteBuffer.allocate(4);
-        buffer.putInt(value);
-        return buffer.array();
-    }
-}

src/main/java/de/shiewk/smoderation/paper/util/CommandUtil.java

@@ -12,13 +12,16 @@ import org.bukkit.command.ConsoleCommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Arrays;
 import java.util.List;
 import java.util.UUID;
 import java.util.function.Predicate;
 
 import static de.shiewk.smoderation.paper.util.PlayerUtil.UUID_CONSOLE;
+import static net.kyori.adventure.text.Component.translatable;
 
-public abstract class CommandUtil {
+@SuppressWarnings("UnstableApiUsage") // Paper Brigadier API
+public final class CommandUtil {
     private CommandUtil(){}
 
     public static Predicate<CommandSourceStack> requirePermission(String permission) {
@@ -30,7 +33,7 @@ public abstract class CommandUtil {
         if (sender instanceof Player player) {
             return player;
         } else {
-            error("Only players can execute this command.");
+            errorTranslatable("smod.command.fail.players");
             throw new UnknownError(); // can't happen
         }
     }
@@ -42,7 +45,7 @@ public abstract class CommandUtil {
         } else if (sender instanceof ConsoleCommandSender){
             return UUID_CONSOLE;
         } else {
-            error("Only players and the console can execute this command.");
+            errorTranslatable("smod.command.fail.playersConsole");
             throw new UnknownError(); // can't happen
         }
     }
@@ -50,17 +53,27 @@ public abstract class CommandUtil {
     public static Player getPlayerSingle(CommandContext<CommandSourceStack> context, String name) throws CommandSyntaxException {
         @NotNull List<Player> players = context.getArgument(name, PlayerSelectorArgumentResolver.class).resolve(context.getSource());
         if (players.isEmpty()){
-            CommandUtil.error("Please provide a valid player.");
+            errorTranslatable("smod.command.fail.invalidPlayer");
         }
         return players.getFirst();
     }
 
-    public static void error(String message) throws CommandSyntaxException {
+    public static void error(Component message) throws CommandSyntaxException {
         throw new CommandSyntaxException(
                 new SimpleCommandExceptionType(null),
-                MessageComponentSerializer.message().serialize(
+                MessageComponentSerializer.message().serialize(message)
-                        Component.text(message)
-                )
         );
     }
+
+    public static void errorTranslatable(String key) throws CommandSyntaxException {
+        error(translatable(key));
+    }
+
+    public static void errorTranslatable(String key, Component...args) throws CommandSyntaxException {
+        error(translatable(key, args));
+    }
+
+    public static void errorTranslatable(String key, String...args) throws CommandSyntaxException {
+        errorTranslatable(key, Arrays.stream(args).map(Component::text).toArray(Component[]::new));
+    }
 }

src/main/java/de/shiewk/smoderation/paper/util/PlayerUtil.java

@@ -1,21 +1,14 @@
 package de.shiewk.smoderation.paper.util;
 
-import de.shiewk.smoderation.paper.SModerationPaper;
-import de.shiewk.smoderation.paper.punishments.Punishment;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.util.StringUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.UUID;
-import java.util.function.Predicate;
 
-public abstract class PlayerUtil {
+public final class PlayerUtil {
     private PlayerUtil(){}
 
     public static final UUID UUID_CONSOLE = new UUID(0, 0);
@@ -25,21 +18,7 @@ public abstract class PlayerUtil {
             return "CONSOLE";
         }
         OfflinePlayer player = Bukkit.getOfflinePlayer(uuid);
-        return player.getName() == null ? "Unknown Player " + uuid : player.getName();
+        return player.getName() == null ? uuid.toString() : player.getName();
-    }
-
-    public static @Nullable UUID offlinePlayerUUIDByName(String name){
-        final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayerIfCached(name); // getOfflinePlayerIfCached(String) is safer (I have experience with getOfflinePlayer(String) returning wrong UUIDs)
-        if (offlinePlayer != null) {
-            return offlinePlayer.getUniqueId();
-        } else {
-            // try to find uuid by searching through punishments
-            final Punishment punishment = SModerationPaper.container.find(p -> offlinePlayerName(p.to).equalsIgnoreCase(name));
-            if (punishment != null) {
-                return punishment.to;
-            }
-            return null;
-        }
     }
 
     public static @Nullable CommandSender senderByUUID(@NotNull UUID uid){
@@ -50,30 +29,11 @@ public abstract class PlayerUtil {
         }
     }
 
-    public static @Nullable Player findOnlinePlayer(String name){
+    public static UUID uuidFromString(String string) {
-        for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
+        if (string.length() == 36) {
-            if (onlinePlayer.getName().equalsIgnoreCase(name)){
+            return UUID.fromString(string);
-                return onlinePlayer;
+        } else {
-            }
+            return UUID.fromString(string.replaceFirst("(.{8})(.{4})(.{4})(.{4})(.{12})", "$1-$2-$3-$4-$5"));
         }
-        return null;
-    }
-
-    public static List<String> listPlayerNames(){
-        return listPlayerNames(pl -> true);
-    }
-
-    public static List<String> listPlayerNames(final Predicate<Player> predicate) {
-        final ArrayList<String> names = new ArrayList<>();
-        for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
-            if (predicate.test(onlinePlayer)){
-                names.add(onlinePlayer.getName());
-            }
-        }
-        return List.copyOf(names);
-    }
-
-    public static List<String> listPlayerNames(String search) {
-        return StringUtil.copyPartialMatches(search, listPlayerNames(), new ArrayList<>());
     }
 }

src/main/java/de/shiewk/smoderation/paper/util/SModLegacy.java

@@ -0,0 +1,140 @@
+package de.shiewk.smoderation.paper.util;
+
+import de.shiewk.smoderation.paper.punishments.*;
+
+import java.io.EOFException;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.UUID;
+import java.util.zip.GZIPInputStream;
+
+import static de.shiewk.smoderation.paper.SModerationPaper.LOGGER;
+
+public final class SModLegacy {
+    private SModLegacy() {}
+
+    private static byte[] longToBytes(long v){
+        ByteBuffer buffer = ByteBuffer.allocate(8);
+        buffer.putLong(v);
+        return buffer.array();
+    }
+
+    private static long bytesToLong(byte[] i){
+        if (i.length != 8){
+            throw new IllegalArgumentException("length must be 8");
+        }
+        ByteBuffer buffer = ByteBuffer.allocate(8);
+        buffer.put(0, i);
+        return buffer.getLong(0);
+    }
+
+    private static byte[] uuidToBytes(UUID uuid){
+        byte[] l = longToBytes(uuid.getLeastSignificantBits());
+        byte[] m = longToBytes(uuid.getMostSignificantBits());
+        return new byte[]{
+                m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7],
+                l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7]
+        };
+    }
+
+    private static UUID bytesToUuid(byte[] i){
+        if (i.length != 16){
+            throw new IllegalArgumentException("length must be 16, was " + i.length);
+        }
+        long l = bytesToLong(new byte[]{ i[8], i[9], i[10], i[11], i[12], i[13], i[14], i[15] });
+        long m = bytesToLong(new byte[]{ i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7] });
+        return new UUID(m, l);
+    }
+
+    private static int bytesToInt(byte[] bytes) {
+        if (bytes.length != 4){
+            throw new IllegalArgumentException("length must be 4");
+        }
+        ByteBuffer buffer = ByteBuffer.allocate(4);
+        buffer.put(0, bytes);
+        return buffer.getInt(0);
+    }
+
+    private static byte[] intToBytes(int value) {
+        ByteBuffer buffer = ByteBuffer.allocate(4);
+        buffer.putInt(value);
+        return buffer.array();
+    }
+
+    private static byte[] readStreamInternal(InputStream stream, int len) throws IOException {
+        final byte[] bytes = stream.readNBytes(len);
+        if (bytes.length != len){
+            throw new EOFException("Stream has ended before enough bytes were read");
+        }
+        return bytes;
+    }
+
+    public static void migrateV1PunishmentsFile(PunishmentManager manager, Path path, Path copy) {
+        int count = 0;
+        try {
+            if (Files.isRegularFile(path)) {
+                LOGGER.info("Migrating V1 punishment file: {}", path);
+                try (InputStream in = new FileInputStream(path.toFile());
+                     GZIPInputStream gzin = new GZIPInputStream(in)){
+                    while (gzin.available() > 0){
+                        int type = bytesToInt(readStreamInternal(gzin, 4));
+                        long time = bytesToLong(readStreamInternal(gzin, 8));
+                        long until = bytesToLong(readStreamInternal(gzin, 8));
+                        UUID by = bytesToUuid(readStreamInternal(gzin, 16));
+                        UUID to = bytesToUuid(readStreamInternal(gzin, 16));
+                        int reasonLen = bytesToInt(readStreamInternal(gzin, 4));
+                        String reason = new String(readStreamInternal(gzin, reasonLen));
+                        UUID canceller = null;
+                        boolean cancelled = gzin.read() == 1;
+                        if (cancelled){
+                            canceller = bytesToUuid(readStreamInternal(gzin, 16));
+                        }
+                        // Type 0: mute; 1: kick; 2: ban
+                        Punishment p = switch (type){
+                            case 0 -> new Mute(
+                                    Punishment.generateUUID(),
+                                    time,
+                                    by,
+                                    to,
+                                    reason,
+                                    until - time,
+                                    canceller
+                            );
+                            case 1 -> new Kick(
+                                    Punishment.generateUUID(),
+                                    time,
+                                    by,
+                                    to,
+                                    reason
+                            );
+                            case 2 -> new Ban(
+                                    Punishment.generateUUID(),
+                                    time,
+                                    by,
+                                    to,
+                                    reason,
+                                    until - time,
+                                    canceller
+                            );
+                            default -> throw new IllegalArgumentException("Invalid legacy type for punishment: " + type);
+                        };
+                        count++;
+                        manager.appendToSave(p);
+                        LOGGER.info("Migrated: {}", p);
+                    }
+                }
+                LOGGER.info("Successfully loaded {} items.", count);
+                Files.move(path, copy);
+            }
+        } catch (EOFException e) {
+            LOGGER.error("The file was not correctly saved, {} items could be recovered!", count);
+        } catch (IOException e){
+            LOGGER.error("An error occurred while loading", e);
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/de/shiewk/smoderation/paper/util/SerializationHelper.java

@@ -0,0 +1,66 @@
+package de.shiewk.smoderation.paper.util;
+
+import com.google.gson.JsonObject;
+
+import java.util.UUID;
+
+public final class SerializationHelper {
+
+    private final JsonObject json;
+
+    public SerializationHelper(JsonObject json) {
+        this.json = json;
+    }
+
+    public String getString(String key) {
+        try {
+            return json.get(key).getAsString();
+        } catch (NullPointerException e) {
+            throw new IllegalStateException("Key " + key + " does not exist on this object");
+        } catch (UnsupportedOperationException | IllegalStateException e) {
+            throw new IllegalStateException("Tried to get string " + key + ", but is " + json.get(key).getClass().getSimpleName());
+        }
+    }
+
+    public void putString(String key, String value) {
+        json.addProperty(key, value);
+    }
+
+    public long getLong(String key) {
+        try {
+            return json.get(key).getAsLong();
+        } catch (NullPointerException e) {
+            throw new IllegalStateException("Key " + key + " does not exist on this object");
+        } catch (UnsupportedOperationException | IllegalStateException e) {
+            throw new IllegalStateException("Tried to get long " + key + ", but is " + json.get(key).getClass().getSimpleName());
+        } catch (NumberFormatException e) {
+            throw new IllegalStateException("Tried to get long " + key + ", but is malformed: " + json.get(key).getAsString());
+        }
+    }
+
+    public void putLong(String key, long value) {
+        json.addProperty(key, value);
+    }
+
+    public UUID getUUID(String key) {
+        try {
+            return PlayerUtil.uuidFromString(getString(key));
+        } catch (IllegalArgumentException e) {
+            throw new IllegalStateException("UUID " + key + " malformed: " + getString(key));
+        }
+    }
+
+    public UUID getUUID(String key, UUID defaultValue) {
+        try {
+            return getUUID(key);
+        } catch (Exception ignored) {
+            return defaultValue;
+        }
+    }
+
+    public void putUUID(String key, UUID value) {
+        if (value == null) return;
+        json.addProperty(key, value.toString().replace("-", ""));
+    }
+
+}

src/main/java/de/shiewk/smoderation/paper/util/TimeUtil.java

@@ -1,15 +1,19 @@
 package de.shiewk.smoderation.paper.util;
 
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
 import org.jetbrains.annotations.Range;
 
 import java.util.Calendar;
 import java.util.Date;
 import java.util.TimeZone;
 
-public abstract class TimeUtil {
+import static net.kyori.adventure.text.Component.*;
+
+public final class TimeUtil {
     private TimeUtil(){}
 
-    public static String formatTimeLong(long millis){
+    public static Component formatTimeLong(long millis){
         long seconds = millis / 1000;
         millis -= seconds * 1000;
 
@@ -31,95 +35,65 @@ public abstract class TimeUtil {
         long weeks = days / 7;
         days -= weeks * 7;
 
-        StringBuilder builder = new StringBuilder();
+        TextComponent.Builder builder = empty().toBuilder();
 
         if (years > 0){
-            if (!builder.isEmpty()){
+            if (!builder.children().isEmpty()){
-                builder.append(" ");
+                builder.appendSpace();
             }
-            builder.append("%s years".formatted(years));
+            builder.append(translatable("smod.time.years", text(years)));
         }
 
         if (months > 0){
-            if (!builder.isEmpty()){
+            if (!builder.children().isEmpty()){
-                builder.append(" ");
+                builder.appendSpace();
             }
-            builder.append("%s months".formatted(months));
+            builder.append(translatable("smod.time.months", text(months)));
         }
 
         if (weeks > 0){
-            if (!builder.isEmpty()){
+            if (!builder.children().isEmpty()){
-                builder.append(" ");
+                builder.appendSpace();
             }
-            builder.append("%s weeks".formatted(weeks));
+            builder.append(translatable("smod.time.weeks", text(weeks)));
         }
 
         if (days > 0){
-            if (!builder.isEmpty()){
+            if (!builder.children().isEmpty()){
-                builder.append(" ");
+                builder.appendSpace();
             }
-            builder.append("%s days".formatted(days));
+            builder.append(translatable("smod.time.days", text(days)));
         }
 
         if (hours > 0){
-            if (!builder.isEmpty()){
+            if (!builder.children().isEmpty()){
-                builder.append(" ");
+                builder.appendSpace();
             }
-            builder.append("%s hours".formatted(hours));
+            builder.append(translatable("smod.time.hours", text(hours)));
         }
 
         if (minutes > 0){
-            if (!builder.isEmpty()){
+            if (!builder.children().isEmpty()){
-                builder.append(" ");
+                builder.appendSpace();
             }
-            builder.append("%s minutes".formatted(minutes));
+            builder.append(translatable("smod.time.minutes", text(minutes)));
         }
 
         if (seconds > 0){
-            if (!builder.isEmpty()){
+            if (!builder.children().isEmpty()){
-                builder.append(" ");
+                builder.appendSpace();
             }
-            builder.append("%s seconds".formatted(seconds));
+            builder.append(translatable("smod.time.seconds", text(seconds)));
         }
 
-        if (builder.isEmpty()){
+        if (builder.children().isEmpty()){
-            builder.append("%s ms".formatted(millis));
+            builder.append(translatable("smod.time.milliseconds", text(millis)));
         }
 
-        return builder.toString();
+        return builder.build();
     }
 
-    public static long parseDurationMillisSafely(String in){
+    public static Component calendarTimestamp(long time){
-        try {
-            return parseDurationMillis(in);
-        } catch (Throwable e){
-            return -1;
-        }
-    }
-
-    public static long parseDurationMillis(String in){
-        if (in.endsWith("ms")){
-            return Long.parseLong(in.substring(0, in.length()-2));
-        } else if (in.endsWith("s")){
-            return Long.parseLong(in.substring(0, in.length()-1)) * 1000L;
-        } else if (in.endsWith("min")){
-            return Long.parseLong(in.substring(0, in.length()-3)) * 60000L;
-        } else if (in.endsWith("h")){
-            return Long.parseLong(in.substring(0, in.length()-1)) * 3600000L;
-        } else if (in.endsWith("d")){
-            return Long.parseLong(in.substring(0, in.length()-1)) * 86400000L;
-        } else if (in.endsWith("w")){
-            return Long.parseLong(in.substring(0, in.length()-1)) * 604800000L;
-        } else if (in.endsWith("mo")){
-            return Long.parseLong(in.substring(0, in.length()-2)) * 2592000000L;
-        } else if (in.endsWith("y")){
-            return Long.parseLong(in.substring(0, in.length()-1)) * 31536000000L;
-        } else {
-            return -1;
-        }
-    }
-
-    public static String calendarTimestamp(long time){
         Date date = new Date(time);
         Calendar calendar = Calendar.getInstance();
         calendar.setTime(date);
@@ -129,73 +103,22 @@ public abstract class TimeUtil {
         int hour = calendar.get(Calendar.HOUR_OF_DAY);
         int year = calendar.get(Calendar.YEAR);
 
-        String day = numberWithSuffix(calendar.get(Calendar.DAY_OF_MONTH));
+        int day = calendar.get(Calendar.DAY_OF_MONTH);
-        String month = monthName(calendar.get(Calendar.MONTH));
+        Component month = monthName(calendar.get(Calendar.MONTH));
-        return "%s %s %s, %s:%s:%s %s".formatted(
+        return translatable(
+                "smod.time.timestamp",
+                text(year),
                 month,
-                day,
+                text(day),
-                year,
+                text((hour < 10 ? "0" : "") + hour),
-                hour < 10 ? "0" + hour : hour,
+                text((minute < 10 ? "0" : "") + minute),
-                minute < 10 ? "0" + minute : minute,
+                text((second < 10 ? "0" : "") + second),
-                second < 10 ? "0" + second : second,
+                text(zone.getDisplayName(zone.inDaylightTime(calendar.getTime()), TimeZone.SHORT))
-                zone.getDisplayName(false, TimeZone.SHORT)
         );
     }
 
-    private static String numberWithSuffix(int i){
+    public static Component monthName(@Range(from = 0, to = 11) int m){
-        return i + numberSuffix(i);
+        return translatable("smod.time.month." + m);
     }
 
-    private static String numberSuffix(int i){
-        if ((i % 10) == 1 && i != 11){
-            return "st";
-        } else if ((i % 10) == 2 && i != 12){
-            return "nd";
-        } else if ((i % 10) == 3 && i != 13){
-            return "rd";
-        }
-        return "th";
-    }
-
-    public static String monthName(@Range(from = 0, to = 11) int m){
-        switch (m){
-            case 0 -> {
-                return "January";
-            }
-            case 1 -> {
-                return "February";
-            }
-            case 2 -> {
-                return "March";
-            }
-            case 3 -> {
-                return "April";
-            }
-            case 4 -> {
-                return "May";
-            }
-            case 5 -> {
-                return "June";
-            }
-            case 6 -> {
-                return "July";
-            }
-            case 7 -> {
-                return "August";
-            }
-            case 8 -> {
-                return "September";
-            }
-            case 9 -> {
-                return "October";
-            }
-            case 10 -> {
-                return "November";
-            }
-            case 11 -> {
-                return "December";
-            }
-        }
-        return "Unknown Month";
-    }
 }

src/main/resources/default-config.yml

@@ -0,0 +1,54 @@
+# If enabled, punishments can no longer be issued without providing a reason.
+force-reason: false
+
+# The string that should be used when no reason is provided.
+# This has no effect if 'force-reason' is set to true.
+default-reason: No reason provided.
+
+# Allows you to toggle specific plugin features.
+features:
+  # Should punishments be tracked and executed?
+  # Note that disabling this will also disable the SMod menu and
+  # /modlogs command since their only use is viewing punishments
+  punishments: true
+  # Should commands for opening the SMod menu be registered?
+  smodmenu: true
+  # Should commands for viewing player inventories be registered?
+  invsee: true
+  # Should commands for viewing player ender chests be registered?
+  enderchestsee: true
+  # Should commands for teleporting to offline players be registered?
+  offlinetp: true
+  # Should commands for viewing other players' messaging commands be registered?
+  socialspy: true
+  # Should players be able to enable vanish mode?
+  vanish: true
+
+# A list of commands which will be captured and broadcast
+# to players which have SocialSpy enabled (/socialspy).
+socialspy-commands:
+  - w
+  - tell
+  - msg
+  - teammsg
+  - tm
+  - minecraft:w
+  - minecraft:tell
+  - minecraft:msg
+  - minecraft:teammsg
+  - minecraft:tm
+
+# A list of commands which muted players will not be able to run.
+muted-forbidden-commands:
+  - w
+  - tell
+  - msg
+  - teammsg
+  - tm
+  - me
+  - minecraft:w
+  - minecraft:tell
+  - minecraft:msg
+  - minecraft:teammsg
+  - minecraft:tm
+  - minecraft:me

src/main/resources/paper-plugin.yml

@@ -2,7 +2,7 @@ name: SModeration
 version: '${version}'
 main: de.shiewk.smoderation.paper.SModerationPaper
 website: https://github.com/Shiewk/SModeration
-api-version: '1.21.3'
+api-version: '1.21.4'
 load: STARTUP
 authors:
   - Shiewk
@@ -71,4 +71,7 @@ permissions:
     description: Allows the player to see vanished players
   smod.socialspy:
     default: op
-    description: Allows the player to enable SocialSpy
+    description: Allows the player to enable SocialSpy
+  smod.offlinetp:
+    default: op
+    description: Allows the player to teleport themself to offline players

src/main/resources/smoderation/translations/de_de.json

@@ -0,0 +1,122 @@
+{
+  "smod.argument.duration.fail.invalid": "Ungültige Zeit '<arg:0>'",
+  "smod.argument.duration.fail.pattern": "Bitte gib eine gültige Zeit an, z.B. '1d6h30min'",
+  "smod.argument.offlinePlayer.fail.notCached": "Die Daten des Spielers sind nicht gespeichert.",
+  "smod.argument.uuid.fail.notCached": "Die Daten des Spielers sind nicht gespeichert. Versuche, stattdessen seine UUID anzugeben.",
+  "smod.chatInput.remainingTime": "<gray><arg:0> Sekunden",
+  "smod.command.ban.fail.alreadyBanned": "Dieser Spieler ist schon gebannt.",
+  "smod.command.ban.fail.forceReason": "Bitte gib einen Grund an.",
+  "smod.command.ban.fail.protect": "Dieser Spieler kann nicht gebannt werden.",
+  "smod.command.ban.fail.self": "Du kannst dich nicht selbst bannen.",
+  "smod.command.ban.fail.tooShort": "Du kannst Spieler, die nicht online sind, nicht so kurz bannen.",
+  "smod.command.ecsee.opening": "<primary>Enderkiste von <secondary><arg:0></secondary> wird geöffnet.",
+  "smod.command.fail.invalidPlayer": "Bitte gib einen gültigen Spieler an.",
+  "smod.command.fail.players": "Nur Spieler können diesen Befehl ausführen.",
+  "smod.command.fail.playersConsole": "Nur Spieler und die Konsole können diesen Befehl ausführen.",
+  "smod.command.invsee.fail.self": "Du kannst dein eigenes Inventar nicht öffnen.",
+  "smod.command.invsee.opening": "<primary>Inventar von <secondary><arg:0></secondary> wird geöffnet.",
+  "smod.command.kick.fail.forceReason": "Bitte gib einen Grund an.",
+  "smod.command.kick.fail.protect": "Dieser Spieler kann nicht gekickt werden.",
+  "smod.command.kick.fail.self": "Du kannst dich nicht selbst kicken.",
+  "smod.command.modlogs.ban": "<primary>- ist bis <secondary><arg:0></secondary> <gray>(in <arg:1>)</gray> gebannt. Grund: <secondary><arg:2>",
+  "smod.command.modlogs.ban.permanent": "<primary>- ist <secondary>permanent</secondary> gebannt. Grund: <secondary><arg:0>",
+  "smod.command.modlogs.heading": "<primary>Spieler <secondary><arg:0> <gray>(<arg:1>)",
+  "smod.command.modlogs.mute": "<primary>- ist bis <secondary><arg:0></secondary> <gray>(in <arg:1>)</gray> stummgeschaltet. Grund: <secondary><arg:2>",
+  "smod.command.modlogs.mute.permanent": "<primary>- ist <secondary>permanent</secondary> stummgeschaltet. Grund: <secondary><arg:0>",
+  "smod.command.modlogs.none": "<primary>- ist momentan nicht gebannt oder stummgeschaltet.",
+  "smod.command.mute.fail.alreadyMuted": "Dieser Spieler ist schon stummgeschaltet.",
+  "smod.command.mute.fail.forceReason": "Bitte gib einen Grund an.",
+  "smod.command.mute.fail.protect": "Dieser Spieler kann nicht stummgeschaltet werden.",
+  "smod.command.mute.fail.self": "Du kannst dich nicht selbst stummschalten.",
+  "smod.command.mute.fail.tooShort": "Du kannst Spieler nicht so kurz stummschalten.",
+  "smod.command.offlinetp.fail.unknown": "Die Position des Spielers ist nicht bekannt.",
+  "smod.command.offlinetp.teleporting": "<primary>Du wirst zu <secondary><arg:0></secondary> teleportiert.",
+  "smod.command.socialspy.disabled": "<primary>SocialSpy <red>deaktiviert</red>.",
+  "smod.command.socialspy.enabled": "<primary>SocialSpy <green>aktiviert</green>.",
+  "smod.command.unban.fail.notBanned": "Dieser Spieler ist nicht gebannt.",
+  "smod.command.unmute.fail.notMuted": "Dieser Spieler ist nicht stummgeschaltet.",
+  "smod.command.vanish.broadcast.off": "<primary><secondary><arg:0></secondary> ist wieder erschienen.",
+  "smod.command.vanish.broadcast.on": "<primary><secondary><arg:0></secondary> ist verschwunden.",
+  "smod.command.vanish.fail.noPlayersFound": "Kein Spieler wurde gefunden.",
+  "smod.command.vanish.list": "<primary>Diese Spieler sind momentan versteckt: <arg:0>",
+  "smod.command.vanish.list.none": "<primary>Keine Spieler sind gerade versteckt.",
+  "smod.command.vanish.stillEnabled": "<bold><primary>Du bist noch unsichtbar!",
+  "smod.command.vanish.toggle.off": "<primary>Du bist nicht mehr versteckt.",
+  "smod.command.vanish.toggle.on": "<primary>Du bist jetzt unsichtbar.",
+  "smod.confirm.no": "<red>Nein",
+  "smod.confirm.yes": "<green>Ja",
+  "smod.inventory.next": "Nächste Seite (<arg:0>/<arg:1>)",
+  "smod.inventory.previous": "Vorherige Seite (<arg:0>/<arg:1>)",
+  "smod.menu": "SMod Menü",
+  "smod.menu.cancelConfirmation": "Bist du sicher, dass du die Strafe aufheben willst?",
+  "smod.menu.filter": "Filter: <arg:0>",
+  "smod.menu.filter.active": "Aktive Strafen",
+  "smod.menu.filter.all": "Alle Strafen",
+  "smod.menu.filter.expired": "Abgelaufene Strafen",
+  "smod.menu.filter.switch": "\u00BB Klicke, um den Filter zu ändern",
+  "smod.menu.info.cancelled": "<red>Aufgehoben von: <gold><arg:0>",
+  "smod.menu.info.click": "\u00BB Klicke, um die Strafe aufzuheben",
+  "smod.menu.info.duration": "<secondary>Dauer: <primary><arg:0>",
+  "smod.menu.info.expiry.future": "<secondary>Läuft ab: <primary>In <arg:0>",
+  "smod.menu.info.expiry.never": "<secondary>Läuft ab: <primary>Nie",
+  "smod.menu.info.expiry.past": "<secondary>Ist abgelaufen: <primary><arg:0> ago",
+  "smod.menu.info.player": "<secondary>Spieler: <primary><arg:0>",
+  "smod.menu.info.punishedBy": "<secondary>Bestraft von: <primary><arg:0>",
+  "smod.menu.info.reason": "<secondary>Grund: <primary><arg:0>",
+  "smod.menu.info.timestamp": "<secondary>Zeitpunkt: <primary><arg:0>",
+  "smod.menu.search": "Suchen",
+  "smod.menu.search.current": "Aktueller Suchbegriff: <arg:0>",
+  "smod.menu.search.new": "\u00BB Klicke, um einen neuen Suchbegriff einzugeben",
+  "smod.menu.search.none": "Keiner",
+  "smod.menu.search.query": "Gib deinen Suchbegriff in den Chat ein",
+  "smod.menu.search.remove": "\u00BB Rechtsklick, um die Suche aufzuheben",
+  "smod.menu.sort": "Sortieren nach: <arg:0>",
+  "smod.menu.sort.expiry": "Ablaufzeitpunkt",
+  "smod.menu.sort.moderatorName": "Moderatorname",
+  "smod.menu.sort.playerName": "Spielername",
+  "smod.menu.sort.switch": "\u00BB Klicke, um die Sortierung zu ändern",
+  "smod.menu.sort.time": "Ausstellungszeitpunkt",
+  "smod.menu.type": "Typ: <arg:0>",
+  "smod.menu.type.all": "Alle",
+  "smod.menu.type.switch": "\u00BB Klicke, um den Typ zu ändern",
+  "smod.punishment.broadcast.ban": "<primary><secondary><arg:0></secondary> wurde von <secondary><arg:1></secondary> für <secondary><arg:3></secondary> gebannt.<newline>Grund: <secondary><arg:2>",
+  "smod.punishment.broadcast.ban.permanent": "<primary><secondary><arg:0></secondary> wurde von <secondary><arg:1></secondary> <secondary>permanent</secondary> gebannt.<newline>Grund: <secondary><arg:2>",
+  "smod.punishment.broadcast.kick": "<primary><secondary><arg:0></secondary> wurde von <secondary><arg:1></secondary> gekickt.<newline>Grund: <secondary><arg:2>",
+  "smod.punishment.broadcast.mute": "<primary><secondary><arg:0></secondary> wurde von <secondary><arg:1></secondary> für <secondary><arg:3></secondary> stummgeschaltet.<newline>Grund: <secondary><arg:2>",
+  "smod.punishment.broadcast.mute.permanent": "<primary><secondary><arg:0></secondary> wurde von <secondary><arg:1></secondary> <secondary>permanent</secondary> stummgeschaltet.<newline>Grund: <secondary><arg:2>",
+  "smod.punishment.cancel.ban": "<primary><secondary><arg:0></secondary> wurde von <secondary><arg:1></secondary> entbannt.",
+  "smod.punishment.cancel.mute": "<primary><secondary><arg:0></secondary>s Stummschaltung wurde von <secondary><arg:1></secondary> aufgehoben.",
+  "smod.punishment.name.ban": "Bann",
+  "smod.punishment.name.kick": "Kick",
+  "smod.punishment.name.mute": "Stummschaltung",
+  "smod.punishment.playerMessage.ban": "<primary>Du wurdest von <secondary><arg:0></secondary> vom Server gebannt.<newline>Grund: <secondary><arg:1></secondary><newline>Dein Bann läuft in <secondary><arg:2></secondary> ab.",
+  "smod.punishment.playerMessage.ban.permanent": "<primary>Du wurdest von <secondary><arg:0></secondary> vom Server gebannt.<newline>Grund: <secondary><arg:1></secondary><newline>Dein Bann läuft <secondary>nicht</secondary> ab.",
+  "smod.punishment.playerMessage.kick": "<primary>Du wurdest von <secondary><arg:0></secondary> vom Server gekickt.<newline>Grund: <secondary><arg:1>",
+  "smod.punishment.playerMessage.mute": "<primary>Du wurdest von <secondary><arg:0></secondary> stummgeschaltet.<newline>Grund: <secondary><arg:1></secondary><newline>Du kannst in <secondary><arg:2></secondary> wieder schreiben.",
+  "smod.punishment.playerMessage.mute.permanent": "<primary>Du wurdest von <secondary><arg:0></secondary> stummgeschaltet.<newline>Grund: <secondary><arg:1></secondary><newline>Du kannst <secondary>nie</secondary> wieder schreiben.",
+  "smod.punishment.playerMessage.mute.chat": "<primary>Du kannst diesen Befehl nicht ausführen, während du stummgeschaltet bist.",
+  "smod.socialspy.command": "<primary>[<secondary>SocialSpy</secondary>] <arg:0>: <secondary><arg:1>",
+  "smod.time.days": "<arg:0> Tage",
+  "smod.time.hours": "<arg:0> Stunden",
+  "smod.time.milliseconds": "<arg:0> Millisekunden",
+  "smod.time.minutes": "<arg:0> Minuten",
+  "smod.time.month.0": "Januar",
+  "smod.time.month.1": "Februar",
+  "smod.time.month.10": "November",
+  "smod.time.month.11": "Dezember",
+  "smod.time.month.2": "März",
+  "smod.time.month.3": "April",
+  "smod.time.month.4": "Mai",
+  "smod.time.month.5": "Juni",
+  "smod.time.month.6": "Juli",
+  "smod.time.month.7": "August",
+  "smod.time.month.8": "September",
+  "smod.time.month.9": "Oktober",
+  "smod.time.months": "<arg:0> Monate",
+  "smod.time.never": "Nie",
+  "smod.time.permanent": "Permanent",
+  "smod.time.seconds": "<arg:0> Sekunden",
+  "smod.time.timestamp": "<arg:2>. <arg:1> <arg:0> <arg:3>:<arg:4>:<arg:5> <arg:6>",
+  "smod.time.weeks": "<arg:0> Wochen",
+  "smod.time.years": "<arg:0> Jahre"
+}

src/main/resources/smoderation/translations/en_us.json

@@ -0,0 +1,122 @@
+{
+  "smod.argument.duration.fail.invalid": "Invalid duration '<arg:0>'",
+  "smod.argument.duration.fail.pattern": "Please provide a valid duration, e.g. '1d6h30min'",
+  "smod.argument.offlinePlayer.fail.notCached": "That player's data is not saved.",
+  "smod.argument.uuid.fail.notCached": "That player's data is not saved. Try providing an UUID instead.",
+  "smod.chatInput.remainingTime": "<gray><arg:0> seconds",
+  "smod.command.ban.fail.alreadyBanned": "This player is already banned.",
+  "smod.command.ban.fail.forceReason": "Please provide a reason.",
+  "smod.command.ban.fail.protect": "This player can't be banned.",
+  "smod.command.ban.fail.self": "You can't ban yourself.",
+  "smod.command.ban.fail.tooShort": "You can't ban an offline player for less than 1ms.",
+  "smod.command.ecsee.opening": "<primary>Opening ender chest of <secondary><arg:0></secondary>.",
+  "smod.command.fail.invalidPlayer": "Please provide a valid player.",
+  "smod.command.fail.players": "Only players can execute this command.",
+  "smod.command.fail.playersConsole": "Only players and the console can execute this command.",
+  "smod.command.invsee.fail.self": "You can't open your own inventory.",
+  "smod.command.invsee.opening": "<primary>Opening inventory of <secondary><arg:0></secondary>.",
+  "smod.command.kick.fail.forceReason": "Please provide a reason.",
+  "smod.command.kick.fail.protect": "This player can't be kicked.",
+  "smod.command.kick.fail.self": "You can't kick yourself.",
+  "smod.command.modlogs.ban": "<primary>- is banned until <secondary><arg:0></secondary> <gray>(in <arg:1>)</gray>. Reason: <secondary><arg:2>",
+  "smod.command.modlogs.ban.permanent": "<primary>- is banned <secondary>permanently</secondary>. Reason: <secondary><arg:0>",
+  "smod.command.modlogs.heading": "<primary>Player <secondary><arg:0> <gray>(<arg:1>)",
+  "smod.command.modlogs.mute": "<primary>- is muted until <secondary><arg:0></secondary> <gray>(in <arg:1>)</gray>. Reason: <secondary><arg:2>",
+  "smod.command.modlogs.mute.permanent": "<primary>- is muted <secondary>permanently</secondary>. Reason: <secondary><arg:0>",
+  "smod.command.modlogs.none": "<primary>- is not currently muted or banned.",
+  "smod.command.mute.fail.alreadyMuted": "This player is already muted.",
+  "smod.command.mute.fail.forceReason": "Please provide a reason.",
+  "smod.command.mute.fail.protect": "This player can't be muted.",
+  "smod.command.mute.fail.self": "You can't mute yourself.",
+  "smod.command.mute.fail.tooShort": "You can't mute a player for less than 1ms.",
+  "smod.command.offlinetp.fail.unknown": "This player's location is unknown.",
+  "smod.command.offlinetp.teleporting": "<primary>Teleporting you to <secondary><arg:0></secondary>.",
+  "smod.command.socialspy.disabled": "<primary>SocialSpy <red>disabled</red>.",
+  "smod.command.socialspy.enabled": "<primary>SocialSpy <green>enabled</green>.",
+  "smod.command.unban.fail.notBanned": "That player is not banned.",
+  "smod.command.unmute.fail.notMuted": "That player is not muted.",
+  "smod.command.vanish.broadcast.off": "<primary><secondary><arg:0></secondary> re-appeared.",
+  "smod.command.vanish.broadcast.on": "<primary><secondary><arg:0></secondary> vanished.",
+  "smod.command.vanish.fail.noPlayersFound": "No player was found.",
+  "smod.command.vanish.list": "<primary>The following players are currently vanished: <arg:0>",
+  "smod.command.vanish.list.none": "<primary>No players are currently vanished.",
+  "smod.command.vanish.stillEnabled": "<bold><primary>You are still vanished!",
+  "smod.command.vanish.toggle.off": "<primary>You are no longer vanished.",
+  "smod.command.vanish.toggle.on": "<primary>You are now vanished.",
+  "smod.confirm.no": "<red>No",
+  "smod.confirm.yes": "<green>Yes",
+  "smod.inventory.next": "Next page (<arg:0>/<arg:1>)",
+  "smod.inventory.previous": "Previous page (<arg:0>/<arg:1>)",
+  "smod.menu": "SMod Menu",
+  "smod.menu.cancelConfirmation": "Are you sure that you want to cancel this punishment?",
+  "smod.menu.filter": "Filter: <arg:0>",
+  "smod.menu.filter.active": "Active punishments",
+  "smod.menu.filter.all": "All punishments",
+  "smod.menu.filter.expired": "Expired punishments",
+  "smod.menu.filter.switch": "\u00BB Click to switch filter",
+  "smod.menu.info.cancelled": "<red>Cancelled by: <gold><arg:0>",
+  "smod.menu.info.click": "\u00BB Click to cancel punishment",
+  "smod.menu.info.duration": "<secondary>Duration: <primary><arg:0>",
+  "smod.menu.info.expiry.future": "<secondary>Expires: <primary>In <arg:0>",
+  "smod.menu.info.expiry.never": "<secondary>Expires: <primary>Never",
+  "smod.menu.info.expiry.past": "<secondary>Expired: <primary><arg:0> ago",
+  "smod.menu.info.player": "<secondary>Player: <primary><arg:0>",
+  "smod.menu.info.punishedBy": "<secondary>Punished by: <primary><arg:0>",
+  "smod.menu.info.reason": "<secondary>Reason: <primary><arg:0>",
+  "smod.menu.info.timestamp": "<secondary>Timestamp: <primary><arg:0>",
+  "smod.menu.search": "Search",
+  "smod.menu.search.current": "Current search query: <arg:0>",
+  "smod.menu.search.new": "\u00BB Click to enter new search query",
+  "smod.menu.search.none": "None",
+  "smod.menu.search.query": "Enter your search query in the chat",
+  "smod.menu.search.remove": "\u00BB Right click to remove search query",
+  "smod.menu.sort": "Sort by: <arg:0>",
+  "smod.menu.sort.expiry": "Expiry time",
+  "smod.menu.sort.moderatorName": "Moderator name",
+  "smod.menu.sort.playerName": "Player name",
+  "smod.menu.sort.switch": "\u00BB Click to switch sorting option",
+  "smod.menu.sort.time": "Time issued",
+  "smod.menu.type": "Type: <arg:0>",
+  "smod.menu.type.all": "All",
+  "smod.menu.type.switch": "» Click to switch type",
+  "smod.punishment.broadcast.ban": "<primary><secondary><arg:0></secondary> was banned by <secondary><arg:1></secondary> for <secondary><arg:3></secondary>.<newline>Reason: <secondary><arg:2>",
+  "smod.punishment.broadcast.ban.permanent": "<primary><secondary><arg:0></secondary> was banned <secondary>permanently</secondary> by <secondary><arg:1></secondary>.<newline>Reason: <secondary><arg:2>",
+  "smod.punishment.broadcast.kick": "<primary><secondary><arg:0></secondary> was kicked by <secondary><arg:1></secondary>.<newline>Reason: <secondary><arg:2>",
+  "smod.punishment.broadcast.mute": "<primary><secondary><arg:0></secondary> was muted by <secondary><arg:1></secondary> for <secondary><arg:3></secondary>.<newline>Reason: <secondary><arg:2>",
+  "smod.punishment.broadcast.mute.permanent": "<primary><secondary><arg:0></secondary> was muted <secondary>permanently</secondary> by <secondary><arg:1></secondary>.<newline>Reason: <secondary><arg:2>",
+  "smod.punishment.cancel.ban": "<primary><secondary><arg:0></secondary> was unbanned by <secondary><arg:1></secondary>.",
+  "smod.punishment.cancel.mute": "<primary><secondary><arg:0></secondary> was unmuted by <secondary><arg:1></secondary>.",
+  "smod.punishment.name.ban": "Ban",
+  "smod.punishment.name.kick": "Kick",
+  "smod.punishment.name.mute": "Mute",
+  "smod.punishment.playerMessage.ban": "<primary>You have been banned from this server by <secondary><arg:0></secondary>.<newline>Reason: <secondary><arg:1></secondary><newline>Your ban expires in <secondary><arg:2></secondary>.",
+  "smod.punishment.playerMessage.ban.permanent": "<primary>You have been banned from this server by <secondary><arg:0></secondary>.<newline>Reason: <secondary><arg:1></secondary><newline>Your ban <secondary>does not</secondary> expire.",
+  "smod.punishment.playerMessage.kick": "<primary>You have been kicked by <secondary><arg:0></secondary>.<newline>Reason: <secondary><arg:1>",
+  "smod.punishment.playerMessage.mute": "<primary>You have been muted by <secondary><arg:0></secondary>.<newline>Reason: <secondary><arg:1></secondary><newline>Your mute expires in <secondary><arg:2></secondary>.",
+  "smod.punishment.playerMessage.mute.permanent": "<primary>You have been muted by <secondary><arg:0></secondary>.<newline>Reason: <secondary><arg:1></secondary><newline>Your mute <secondary>does not</secondary> expire.",
+  "smod.punishment.playerMessage.mute.chat": "<primary>You can't run this command while you are muted.",
+  "smod.socialspy.command": "<primary>[<secondary>SocialSpy</secondary>] <arg:0>: <secondary><arg:1>",
+  "smod.time.days": "<arg:0> days",
+  "smod.time.hours": "<arg:0> hours",
+  "smod.time.milliseconds": "<arg:0> milliseconds",
+  "smod.time.minutes": "<arg:0> minutes",
+  "smod.time.month.0": "January",
+  "smod.time.month.1": "February",
+  "smod.time.month.10": "November",
+  "smod.time.month.11": "December",
+  "smod.time.month.2": "March",
+  "smod.time.month.3": "April",
+  "smod.time.month.4": "May",
+  "smod.time.month.5": "June",
+  "smod.time.month.6": "July",
+  "smod.time.month.7": "August",
+  "smod.time.month.8": "September",
+  "smod.time.month.9": "October",
+  "smod.time.months": "<arg:0> months",
+  "smod.time.never": "Never",
+  "smod.time.permanent": "Permanent",
+  "smod.time.seconds": "<arg:0> seconds",
+  "smod.time.timestamp": "<arg:2> <arg:1> <arg:0> <arg:3>:<arg:4>:<arg:5> <arg:6>",
+  "smod.time.weeks": "<arg:0> weeks",
+  "smod.time.years": "<arg:0> years"
+}