Added first few classes

Author: Pascalpex

build.gradle.kts

@@ -17,6 +17,7 @@ repositories {
 dependencies {
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
     testImplementation("org.junit.jupiter:junit-jupiter")
+    implementation("net.kyori:adventure-text-minimessage:4.19.0")
     paperweight.paperDevBundle("1.21.4-R0.1-SNAPSHOT")
 }
 

src/main/java/de/pascalpex/pexnpc/Main.java

@@ -1,16 +1,68 @@
 package de.pascalpex.pexnpc;
 
+import de.pascalpex.pexnpc.events.listener.JoinEventListener;
+import de.pascalpex.pexnpc.files.Config;
+import de.pascalpex.pexnpc.files.NpcData;
+import de.pascalpex.pexnpc.npc.NPC;
+import de.pascalpex.pexnpc.util.Metrics;
+import de.pascalpex.pexnpc.util.VersionChecker;
 import org.bukkit.plugin.java.JavaPlugin;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+
 public class Main extends JavaPlugin {
 
+    private static final VersionChecker versionChecker = new VersionChecker();
+
+    private static Main instance;
+    private static Logger logger;
+    private static List<NPC> npcs;
+    private static String version = "";
+
     @Override
     public void onEnable() {
+        version = getPlugin(this.getClass()).getDescription().getVersion();
+        instance = this;
+        logger = getLogger();
+        npcs = new ArrayList<>();
+
+        Config.load();
+        NpcData.load();
+
+        new Metrics(this, 14923);
+
+        if (Config.getUpdateChecker()) {
+            versionChecker.fetchNewestVersion();
+        }
+
+        // Listeners
+        this.getServer().getPluginManager().registerEvents(new JoinEventListener(), this);
     }
 
     @Override
     public void onDisable() {
 
     }
 
+    public static Main getInstance() {
+        return instance;
+    }
+
+    public static Logger logger() {
+        return logger;
+    }
+
+    public static List<NPC> getNpcs() {
+        return npcs;
+    }
+
+    public static String getVersion() {
+        return version;
+    }
+
+    public static VersionChecker getVersionChecker() {
+        return versionChecker;
+    }
 }

src/main/java/de/pascalpex/pexnpc/commands/TabCompletion.java

@@ -0,0 +1,73 @@
+package de.pascalpex.pexnpc.commands;
+
+import de.pascalpex.pexnpc.Main;
+import de.pascalpex.pexnpc.files.NpcData;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class TabCompletion implements org.bukkit.command.TabCompleter {
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        final List<String> completions = new ArrayList<>();
+        if (label.equalsIgnoreCase("pexnpc")) {
+            if (sender instanceof Player) {
+                if (sender.hasPermission("pexnpc.command")) {
+                    if (args.length == 1) {
+                        completions.add("help");
+                        completions.add("reload");
+                        completions.add("create");
+                        completions.add("list");
+                        completions.add("delete");
+                        completions.add("name");
+                        completions.add("movehere");
+                        completions.add("tp");
+                        completions.add("skin");
+                        completions.add("cmd");
+                        completions.add("msg");
+                        completions.add("item");
+                        completions.add("clear");
+                        completions.removeIf(s -> !s.startsWith(args[0].toLowerCase()));
+                    }
+                    if (args.length == 2) {
+                        if (args[0].equalsIgnoreCase("clear") || args[0].equalsIgnoreCase("delete") || args[0].equalsIgnoreCase("name") || args[0].equalsIgnoreCase("tp") || args[0].equalsIgnoreCase("movehere") || args[0].equalsIgnoreCase("skin") || args[0].equalsIgnoreCase("cmd") || args[0].equalsIgnoreCase("msg") || args[0].equalsIgnoreCase("item")) {
+                            for (int i = 1; i <= Main.getNpcs().size(); i++) {
+                                completions.add(String.valueOf(i));
+                            }
+                            completions.removeIf(s -> !s.startsWith(args[1]));
+                        }
+                    }
+                    if (args.length == 3) {
+                        if (args[0].equalsIgnoreCase("item")) {
+                            completions.add("HAND");
+                            completions.add("OFFHAND");
+                            completions.add("HELMET");
+                            completions.add("CHESTPLATE");
+                            completions.add("LEGGINGS");
+                            completions.add("BOOTS");
+                            completions.removeIf(s -> !s.startsWith(args[2].toUpperCase()));
+                        }
+                        if (args[0].equalsIgnoreCase("skin")) {
+                            for (Player player : Bukkit.getOnlinePlayers()) {
+                                completions.add(player.getName());
+                            }
+                            completions.removeIf(s -> !s.toLowerCase().startsWith(args[2].toLowerCase()));
+                        }
+                    }
+                    Collections.sort(completions);
+                    return completions;
+                }
+            }
+        }
+        return null;
+    }
+}

src/main/java/de/pascalpex/pexnpc/events/PacketReader.java

@@ -0,0 +1,86 @@
+package de.pascalpex.pexnpc.events;
+
+import de.pascalpex.pexnpc.npc.NPC;
+import de.pascalpex.pexnpc.util.ReflectionHelper;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToMessageDecoder;
+import net.minecraft.network.Connection;
+import net.minecraft.network.protocol.Packet;
+import net.minecraft.network.protocol.game.ServerboundInteractPacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.ServerGamePacketListenerImpl;
+import de.pascalpex.pexnpc.Main;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class PacketReader {
+
+    Channel channel;
+    public static Map<UUID, Channel> channels = new HashMap<>();
+    public static Map<UUID, Boolean> clicking = new HashMap<>();
+
+    public void inject(Player player) throws NoSuchFieldException, IllegalAccessException {
+        CraftPlayer craftPlayer = (CraftPlayer) player;
+        ServerGamePacketListenerImpl serverConnection = craftPlayer.getHandle().connection;
+        Connection connection = (Connection) ReflectionHelper.getValue(serverConnection, "e");
+        channel = connection.channel;
+        channels.put(player.getUniqueId(), channel);
+
+        if (channel.pipeline().get("PacketInjector") != null) {
+            return;
+        }
+
+        try {
+            channel.pipeline().addAfter("decoder", "PacketInjector", new MessageToMessageDecoder<ServerboundInteractPacket>() {
+
+                @Override
+                protected void decode(ChannelHandlerContext channel, ServerboundInteractPacket packet, List<Object> arg) {
+                    arg.add(packet);
+                    readPacket(player, packet);
+                }
+
+            });
+        } catch (NoSuchElementException ignored) {
+        } // Player is no longer online
+
+    }
+
+    public void uninject(Player player) {
+        channel = channels.get(player.getUniqueId());
+        if (channel == null) {
+            return;
+        }
+        if (channel.pipeline().get("PacketInjector") != null) {
+            channel.pipeline().remove("PacketInjector");
+        }
+        channels.remove(player.getUniqueId());
+    }
+
+    public void readPacket(Player player, Packet<?> packet) {
+
+        String packetName = packet.getClass().getSimpleName();
+        if (packetName.equalsIgnoreCase("PacketPlayInUseEntity") || packetName.equalsIgnoreCase("ServerboundInteractPacket")) {
+
+            int id = (int) ReflectionHelper.getValue(packet, "b");
+
+            for (ServerPlayer npc : Main.getNpcs().stream().map(NPC::getServerPlayer).toList()) {
+                if (npc.getId() == id) {
+                    if (!clicking.containsKey(player.getUniqueId())) {
+                        clicking.put(player.getUniqueId(), true);
+                        Bukkit.getScheduler().scheduleSyncDelayedTask(Main.getInstance(), () -> {
+                            clicking.remove(player.getUniqueId());
+                            Bukkit.getPluginManager().callEvent(new RightClickNPC(player, npc));
+                        }, 1);
+                    }
+                }
+            }
+
+        }
+    }
+
+}

src/main/java/de/pascalpex/pexnpc/events/RightClickNPC.java

@@ -0,0 +1,47 @@
+package de.pascalpex.pexnpc.events;
+
+import net.minecraft.server.level.ServerPlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class RightClickNPC extends Event implements Cancellable {
+
+    private final Player player;
+    private final ServerPlayer npc;
+    private boolean isCancelled;
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public RightClickNPC(Player player, ServerPlayer npc) {
+        this.player = player;
+        this.npc = npc;
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public ServerPlayer getNpc() {
+        return npc;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return isCancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean b) {
+        isCancelled = b;
+    }
+}

src/main/java/de/pascalpex/pexnpc/events/listener/JoinEventListener.java

@@ -0,0 +1,22 @@
+package de.pascalpex.pexnpc.events.listener;
+
+import de.pascalpex.pexnpc.Main;
+import de.pascalpex.pexnpc.files.Config;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public class JoinEventListener implements Listener {
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        Player player = event.getPlayer();
+        if (Config.getUpdateChecker()) {
+            if (player.hasPermission("pexnpc.update")) {
+                Main.getVersionChecker().playerJoin(player);
+            }
+        }
+    }
+
+}

src/main/java/de/pascalpex/pexnpc/files/Config.java

@@ -0,0 +1,76 @@
+package de.pascalpex.pexnpc.files;
+
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+
+public class Config {
+
+    public static File configFile = new File("plugins/PexNPC", "config.yml");
+    public static FileConfiguration config = YamlConfiguration.loadConfiguration(configFile);
+
+    public static void load() {
+        try {
+            configFile.getParentFile().mkdirs();
+            if (!configFile.exists()) {
+                configFile.createNewFile();
+                config.options().header("Skin Mode 1: No second layer, no cape     2: Only second layer     3: Second layer and cape");
+                config.set("skinMode", 2);
+                config.set("prefix", "&7[&ePexNPC&7]");
+                config.set("skinTimeout", 40);
+                save();
+            }
+            config.load(configFile);
+            if (!config.contains("updateChecker")) {
+                config.set("updateChecker", true);
+            }
+            if (!config.contains("logNPCClickedCommands")) {
+                config.set("logNPCClickedCommands", false);
+            }
+            if (!config.contains("spectatorModeOnTeleport")) {
+                config.set("spectatorModeOnTeleport", true);
+            }
+            save();
+        } catch (IOException | InvalidConfigurationException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    public static void save() {
+        try {
+            config.save(configFile);
+        } catch (IOException e) {
+
+            e.printStackTrace();
+        }
+    }
+
+    public static boolean getUpdateChecker() {
+        return config.getBoolean("updateChecker");
+    }
+
+    public static boolean getLogCommands() {
+        return config.getBoolean("logNPCClickedCommands");
+    }
+
+    public static int getSkinMode() {
+        return config.getInt("skinMode");
+    }
+
+    public static String getPrefix() {
+        return config.getString("prefix").replace("&", "§");
+    }
+
+    public static int getSkinTimeout() {
+        return config.getInt("skinTimeout");
+    }
+
+    public static boolean getSpectatorModeOnTeleport() {
+        return config.getBoolean("spectatorModeOnTeleport");
+    }
+
+}