初版

pom.xml

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.yaohun.guaji.AuGuaJi</groupId>
+    <artifactId>AuCardBackpack</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+
+
+    <repositories>
+        <repository>
+            <id>public-rpg</id>
+            <url>https://repo.aurora-pixels.com/repository/public-rpg/</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
+            <version>1.12.2</version>
+        </dependency>
+        <dependency>
+            <groupId>com.yaohun.demonapi</groupId>
+            <artifactId>DemonAPI</artifactId>
+            <version>2.1.4</version>
+        </dependency>
+        <dependency>
+            <groupId>com.yaohun.nbtapi</groupId>
+            <artifactId>NBT-API</artifactId>
+            <version>1.12.2</version>
+        </dependency>
+        <dependency>
+            <groupId>com.yaohun.itemku</groupId>
+            <artifactId>AuItemStackLib</artifactId>
+            <version>1.4.4</version>
+        </dependency>
+        <dependency>
+            <groupId>org.serverct.ersha.jd</groupId>
+            <artifactId>AttributePlus</artifactId>
+            <version>2.0</version>
+        </dependency>
+    </dependencies>
+
+</project>

src/README.md

@@ -0,0 +1,27 @@
+# AuCardBackpack 插件
+
+## 插件简介
+一个斗罗RPG常见的魂卡系统，击杀怪掉落魂卡，右键魂卡打开背包并概率吸收魂卡
+
+## 玩法关联插件
+- PaperMC 1.12.2
+- DemonAPI (核心前置支持)
+- AuItemStackLibrary (存储掉落魂卡的战利品)
+- DemonMmKillsStats (击杀怪物后概率掉落魂卡)
+- DemonMmKillsDrop (记录魂卡掉落数量日志)
+- AuItemUse (掉落的魂卡 手持右键鉴定)
+- AuForge (鉴定后输出的装备魂卡)
+- DemonFenJie (分解鉴定后的装备魂卡)
+- DragonCore (属性字符替换、魂卡材质替换)
+
+## 功能结构
+- 战利品阶段（击杀同年限的怪概率掉落魂卡）
+- 背包阶段（可从背包界面取出魂卡）
+- 吸收阶段（确认吸收该魂卡，吸收后关闭背包则触发属性）
+-----------------------------------
+
+# 更新日志
+
+## v1.0.0 - 2025-05-10
+- 绑定命令 `/aucard open` 打开魂卡背包
+- 初步已实现功能的安装和实装

src/main/java/com/yaohun/cardbackpack/AuCardBackpack.java

@@ -0,0 +1,90 @@
+package com.yaohun.cardbackpack;
+
+import com.yaohun.cardbackpack.config.Config;
+import com.yaohun.cardbackpack.gui.CardGui;
+import com.yaohun.cardbackpack.gui.ConfirmGui;
+import com.yaohun.cardbackpack.listener.KillMobsListener;
+import com.yaohun.cardbackpack.listener.PlayerListener;
+import com.yaohun.cardbackpack.manage.DataManager;
+import org.bukkit.Sound;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public class AuCardBackpack extends JavaPlugin {
+
+    private static AuCardBackpack instance;
+    private static DataManager dataManager;
+
+    @Override
+    public void onEnable() {
+        instance = this;
+        dataManager = new DataManager();
+        Config.reloadConfig();
+        getServer().getPluginManager().registerEvents(new CardGui(), this);
+        getServer().getPluginManager().registerEvents(new ConfirmGui(), this);
+        getServer().getPluginManager().registerEvents(new PlayerListener(), this);
+        getServer().getPluginManager().registerEvents(new KillMobsListener(), this);
+    }
+
+    @Override
+    public void onDisable() {
+        getDataManager().SaveAllPlayerData();
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command cmd, String Command, String[] args) {
+        if (args.length == 1 && args[0].equalsIgnoreCase("open")) {
+            CardGui.OpenGui((Player) sender);
+            return true;
+        }
+        if (!sender.isOp()) {
+            return true;
+        }
+        if (args.length == 0) {
+            sender.sendMessage("");
+            sender.sendMessage("§e------- ======= §6魂卡背包 §e======= -------");
+            sender.sendMessage("§2/"+Command+" open §f- §2打开背包");
+            sender.sendMessage("§2/"+Command+" reload §f- §2重载配置文件");
+            sender.sendMessage("§e------- ======= §6魂卡背包  §e======= -------");
+            sender.sendMessage("");
+            return true;
+        }
+        if(args.length == 1 && args[0].equalsIgnoreCase("reload")) {
+            getDataManager().reloadDataManager();
+            sender.sendMessage("§f[§c魂卡§f] §a配置文件已重载.");
+            return true;
+        }
+        return false;
+    }
+
+    public static AuCardBackpack inst() {
+        return instance;
+    }
+
+    public static DataManager getDataManager() {
+        return dataManager;
+    }
+
+    public static void sendMessage(CommandSender sender, String message) {
+        String prefix = Config.langData.getMessage("prefix");
+        if(sender instanceof Player){
+            Player player = (Player) sender;
+            player.sendMessage(prefix+message);
+        } else {
+            sender.sendMessage(prefix+message);
+        }
+    }
+
+    public static void sendMessage(CommandSender sender, String message, Sound sound) {
+        String prefix = Config.langData.getMessage("prefix");
+        if(sender instanceof Player){
+            Player player = (Player) sender;
+            player.sendMessage(prefix+message);
+            player.playSound(player.getLocation(), sound, 0.5f, 1.2f);
+        } else {
+            sender.sendMessage(prefix+message);
+        }
+    }
+}

src/main/java/com/yaohun/cardbackpack/config/Config.java

@@ -0,0 +1,44 @@
+package com.yaohun.cardbackpack.config;
+
+import com.yaohun.cardbackpack.AuCardBackpack;
+import me.Demon.DemonPlugin.DemonAPI;
+import me.Demon.DemonPlugin.data.GuiItemData;
+import me.Demon.DemonPlugin.data.LangData;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.File;
+import java.util.HashMap;
+
+public class Config {
+
+    public static LangData langData;
+    private static HashMap<String, GuiItemData> guiItemDataMap = new HashMap<>();
+
+    public static void reloadConfig() {
+        langData = DemonAPI.getLangData("AuCardBackpack");
+        guiItemDataMap.clear();
+        loadGuiItemData();
+    }
+
+    private static void loadGuiItemData(){
+        File file = new File("plugins/AuSettings","AuCardBackpack.yml");
+        FileConfiguration configuration = YamlConfiguration.loadConfiguration(file);
+        ConfigurationSection section = configuration.getConfigurationSection("GuiItemData");
+        if(section == null){return;}
+        for (String itemKey : section.getKeys(false)){
+            guiItemDataMap.put(itemKey,new GuiItemData(itemKey,section));
+        }
+    }
+
+    public static ItemStack getItemStack(String itemKey) {
+        if(guiItemDataMap.containsKey(itemKey)){
+            return guiItemDataMap.get(itemKey).getItemStack();
+        }
+        return DemonAPI.getErrItems();
+    }
+
+
+}

src/main/java/com/yaohun/cardbackpack/data/CardData.java

@@ -0,0 +1,41 @@
+package com.yaohun.cardbackpack.data;
+
+import com.yaohun.cardbackpack.util.RandomUtil;
+
+public class CardData {
+
+    private String cardKey;
+    private int cardSlot;
+    public int needMoney;
+    public double chance;
+
+    public CardData(String cardKey, int cardSlot, int needMoney, double chance) {
+        this.cardKey = cardKey;
+        this.cardSlot = cardSlot;
+        this.needMoney = needMoney;
+        this.chance = chance;
+    }
+
+    public String getCardKey() {
+        return cardKey;
+    }
+
+    public int getCardSlot() {
+        return cardSlot;
+    }
+
+    public boolean isChance(int addRandom){
+        if(chance >= 100){
+            return true;
+        }
+        if(chance <= 0){
+            return false;
+        }
+        int max = 100 + addRandom;
+        double rand = RandomUtil.getRandomDouble(0,max,1);
+        if(rand < chance / 2){
+            return true;
+        }
+        return false;
+    }
+}

src/main/java/com/yaohun/cardbackpack/data/PlayerData.java

@@ -0,0 +1,59 @@
+package com.yaohun.cardbackpack.data;
+
+import de.tr7zw.itemnbtapi.NBTItem;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+
+public class PlayerData {
+
+    private String name;
+    public HashMap<Integer, ItemStack> itemStackHashMap;
+    private File file;
+    private FileConfiguration configuration;
+
+    public PlayerData(String name) {
+        this.name = name;
+        this.file = new File("plugins/AuData/BackpackCard", name + ".yml");
+        this.configuration = YamlConfiguration.loadConfiguration(this.file);
+        this.itemStackHashMap = new HashMap<>();
+        ConfigurationSection section = this.configuration.getConfigurationSection("Unlock-Slot");
+        if(section != null) {
+            for (String slotKey : section.getKeys(false)) {
+                int slot = Integer.parseInt(slotKey);
+                ItemStack itemStack = section.getItemStack(slotKey);
+                itemStackHashMap.put(slot, itemStack);
+            }
+        }
+    }
+
+    public void SavePlayerData() {
+        configuration.set("Unlock-Slot",null);
+        for (Integer key : itemStackHashMap.keySet()) {
+            ItemStack itemStack = itemStackHashMap.get(key);
+            configuration.set("Unlock-Slot."+key, itemStack);
+        }
+        try {
+            this.configuration.save(this.file);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public boolean isCardYearsExit(String hunkaKey){
+        for (ItemStack itemStack : itemStackHashMap.values()) {
+            NBTItem nbtItem = new NBTItem(itemStack);
+            if(nbtItem.hasKey("hunkaKey")){
+                if(nbtItem.getString("hunkaKey").equals(hunkaKey)){
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

src/main/java/com/yaohun/cardbackpack/gui/CardGui.java

@@ -0,0 +1,163 @@
+package com.yaohun.cardbackpack.gui;
+
+import com.yaohun.cardbackpack.AuCardBackpack;
+import com.yaohun.cardbackpack.config.Config;
+import com.yaohun.cardbackpack.data.PlayerData;
+import com.yaohun.cardbackpack.manage.DataManager;
+import com.yaohun.cardbackpack.util.StackUtil;
+import de.tr7zw.itemnbtapi.NBTItem;
+import me.Demon.DemonPlugin.DemonAPI;
+import me.Demon.DemonPlugin.Util.CDTimeAPI;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.serverct.ersha.jd.AttributeAPI;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class CardGui implements Listener {
+
+    private static String invTitle;
+
+    public CardGui() {
+        invTitle = Config.langData.getMessage("Gui-Title");
+    }
+
+    public static void OpenGui(Player player){
+        String playerName = player.getName();
+        DataManager dataManager = AuCardBackpack.getDataManager();
+        PlayerData playerData = dataManager.getPlayerData(playerName);
+        Inventory inv = Bukkit.createInventory(null,27,invTitle);
+        inv.setItem(0, DemonAPI.glass(11,"§r"));
+        inv.setItem(8, DemonAPI.glass(11,"§r"));
+        for (int i = 9; i < 27;i++){
+            inv.setItem(i,DemonAPI.glass(15,"§r"));
+        }
+        inv.setItem(21, DemonAPI.glass(15,"§r"));
+        inv.setItem(22,DemonAPI.glass(0,"§7[§6魂卡背包§7]"));
+        inv.setItem(23, DemonAPI.glass(15,"§r"));
+        for (int i : new int[]{18,19,20,24,25,26}) {
+            inv.setItem(i,DemonAPI.glass(0,"§7[§6魂卡背包§7]"));
+        }
+        inv.setItem(1,StackUtil.iconHide("§f十年魂卡槽"));
+        inv.setItem(2,StackUtil.iconHide("§e百年魂卡槽"));
+        inv.setItem(3,StackUtil.iconHide("§d千年魂卡槽"));
+        inv.setItem(4,StackUtil.iconHide("§7万年魂卡槽"));
+        inv.setItem(5,StackUtil.iconHide("§c十万年魂卡槽"));
+        inv.setItem(6,StackUtil.iconHide("§r"));
+        inv.setItem(7,StackUtil.iconHide("§r"));
+        // 设置已穿戴的魂卡
+        HashMap<Integer, ItemStack> stackHashMap = playerData.itemStackHashMap;
+        for (Integer slot : stackHashMap.keySet()) {
+            if (stackHashMap.get(slot) != null) {
+                ItemStack stack = stackHashMap.get(slot).clone();
+                if (!DemonAPI.itemIsNull(stack) && !DemonAPI.itemIsLore(stack)) {
+                    ItemMeta meta = stack.getItemMeta();
+                    meta.setDisplayName(meta.getDisplayName() + " §c§l[点击取出]");
+                    stack.setItemMeta(meta);
+                    inv.setItem(slot, stack);
+                }
+            }
+        }
+        player.openInventory(inv);
+    }
+
+    @EventHandler
+    public void onClick(InventoryClickEvent e) {
+        int rawSlot = e.getRawSlot();
+        Player player = (Player) e.getWhoClicked();
+        String playerName = player.getName();
+        Inventory inventory = e.getInventory();
+        if (e.getView().getTitle().equalsIgnoreCase(invTitle)) {
+            if(rawSlot >= 0 && rawSlot < inventory.getSize()){
+                e.setCancelled(true);
+                // 获取点击的物品
+                ItemStack click = e.getCurrentItem();
+                // 判断点击的物品是否是卡牌槽
+                if(rawSlot == 1 || rawSlot == 2 || rawSlot == 3 ||
+                rawSlot == 4 || rawSlot == 5 || rawSlot == 6 || rawSlot == 7){
+                    if(DemonAPI.itemIsNull(click))return;
+                    DataManager dataManager = AuCardBackpack.getDataManager();
+                    PlayerData playerData = dataManager.getPlayerData(playerName);
+                    // 若点击此处并非空白则将物品返还给玩家
+                    if(!click.getType().equals(Material.BARRIER)) {
+                        if(!DemonAPI.itemIsLore(click)) {
+                            ItemStack itemStack = playerData.itemStackHashMap.get(rawSlot);
+                            player.getInventory().addItem(itemStack);
+                            playerData.itemStackHashMap.remove(rawSlot);
+                            inventory.setItem(rawSlot, StackUtil.iconHide("§c§l请放入魂卡"));
+                            player.playSound(player.getLocation(), Sound.BLOCK_COMPARATOR_CLICK, 1, 1);
+                            // 玩家取出这个卡牌后1分钟内肯定会打算吸一个更厉害的魂卡
+                            CDTimeAPI.setPlayerCD(player.getUniqueId(),"cardback_fetch",1000L * 60);
+                        }
+                        return;
+                    }
+                    // 获取鼠标上的物品
+                    ItemStack cursor = e.getCursor();
+                    if(!DemonAPI.itemIsNull(cursor)){
+                        NBTItem nbtItem = new NBTItem(cursor);
+                        if(nbtItem.hasKey("hunkaKey")){
+                            String hunkaKey = nbtItem.getString("hunkaKey");
+                            if(playerData.isCardYearsExit(hunkaKey)){
+                                AuCardBackpack.sendMessage(player,Config.langData.getMessage("quantityLimit"),Sound.ENTITY_VILLAGER_NO);
+                                return;
+                            }
+                            e.setCursor(new ItemStack(Material.AIR));
+                            ConfirmGui.OpenGui(player,cursor,hunkaKey);
+                            // 打开一个新的窗口
+                            player.playSound(player.getLocation(), Sound.BLOCK_COMPARATOR_CLICK,1,1);
+                        } else {
+                            AuCardBackpack.sendMessage(player,Config.langData.getMessage("typeLimitations"),Sound.ENTITY_VILLAGER_NO);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @EventHandler
+    public void onClose(InventoryCloseEvent e){
+        Player player = (Player) e.getPlayer();
+        String playerName = player.getName();
+        Inventory inventory = e.getInventory();
+        if(e.getView().getTitle().equalsIgnoreCase(invTitle)){
+            String attSource = "cardAttribute";
+            AttributeAPI.deleteAttribute(player,attSource);
+            List<String> statsList = new ArrayList<>();
+            PlayerData playerData = AuCardBackpack.getDataManager().getPlayerData(playerName);
+            for (int i : new int[]{0,1,2,3,4,5,6,7}){
+                ItemStack stack = inventory.getItem(i);
+                if(!DemonAPI.itemIsNull(stack)){
+                    NBTItem nbtItem = new NBTItem(stack);
+                    if(nbtItem.hasKey("hunkaKey")){
+                        ItemMeta meta = stack.getItemMeta();
+                        List<String> lore = meta.getLore();
+                        for (int l = 0; l < lore.size(); l++) {
+                            String s = lore.get(l);
+                            if(s.contains("繫") || s.contains("龖") || s.contains("儁")){
+                                statsList.add(s);
+                            }
+                            if(s.contains("鬻 §7物品绑定: §e使用后绑定")){
+                                lore.set(l,"鬻 §7物品已绑定: §e"+playerName);
+                                meta.setLore(lore);
+                                stack.setItemMeta(meta);
+                                playerData.itemStackHashMap.put(i,stack);
+                            }
+                        }
+                    }
+                }
+            }
+            AttributeAPI.addAttribute(player, attSource, statsList);
+        }
+    }
+}

src/main/java/com/yaohun/cardbackpack/gui/ConfirmGui.java

@@ -0,0 +1,115 @@
+package com.yaohun.cardbackpack.gui;
+
+import com.yaohun.cardbackpack.AuCardBackpack;
+import com.yaohun.cardbackpack.config.Config;
+import com.yaohun.cardbackpack.data.CardData;
+import com.yaohun.cardbackpack.data.PlayerData;
+import com.yaohun.cardbackpack.manage.DataManager;
+import com.yaohun.cardbackpack.util.StackUtil;
+import de.tr7zw.itemnbtapi.NBTItem;
+import me.Demon.DemonPlugin.DemonAPI;
+import me.Demon.DemonPlugin.Util.CDTimeAPI;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+public class ConfirmGui implements Listener {
+
+    private static String invTitle;
+    private static String startTitle;
+
+    public ConfirmGui() {
+        invTitle = Config.langData.getMessage("Confiirm-Title");
+        startTitle = invTitle.split("%s")[0];
+    }
+
+    public static void OpenGui(Player player, ItemStack cardStack,String hunkaKey){
+        DataManager dataManager = AuCardBackpack.getDataManager();
+        CardData cardData = dataManager.getCardData(hunkaKey);
+        if(cardData == null){
+            player.closeInventory();
+            player.getInventory().addItem(cardStack);
+            return;
+        }
+        String itemName = cardStack.getItemMeta().getDisplayName();
+        Inventory inv = Bukkit.createInventory(null,9,invTitle.replace("%s",itemName));
+        inv.setItem(1,cardStack);
+        inv.setItem(6, StackUtil.confirmStack(cardData));
+        inv.setItem(8, Config.getItemStack("backStack"));
+        player.openInventory(inv);
+    }
+
+    @EventHandler
+    public void onClick(InventoryClickEvent e) {
+        int rawSlot = e.getRawSlot();
+        Player player = (Player) e.getWhoClicked();
+        String playerName = player.getName();
+        Inventory inventory = e.getInventory();
+        if (e.getView().getTitle().contains(startTitle)) {
+            e.setCancelled(true);
+            if(rawSlot == 8){
+                CardGui.OpenGui(player);
+            }
+            if(rawSlot == 6){
+                ItemStack item = e.getCurrentItem();
+                NBTItem nbtItem = new NBTItem(item);
+                if(nbtItem.hasKey("hunka")){
+                    String hunkaKey = nbtItem.getString("hunka");
+                    CardData cardData = AuCardBackpack.getDataManager().getCardData(hunkaKey);
+                    if(cardData == null){
+                        return;
+                    }
+                    // 判断金币
+                    int needMoney = cardData.needMoney;
+                    if(!DemonAPI.hasMoney(player, needMoney)){
+                        CardGui.OpenGui(player);
+                        String message = Config.langData.getMessage("moneyNotEnough");
+                        AuCardBackpack.sendMessage(player,message.replace("%money%",DemonAPI.MoneyFormat(needMoney)),Sound.ENTITY_VILLAGER_NO);
+                        return;
+                    }
+                    int addRandom = 0;
+                    if(CDTimeAPI.isCD(player.getUniqueId(),"cardback_fetch")){
+                        addRandom = 100;
+                    }
+                    if(cardData.isChance(addRandom)){
+                        int slot = cardData.getCardSlot();
+                        PlayerData playerData = AuCardBackpack.getDataManager().getPlayerData(playerName);
+                        ItemStack stack = inventory.getItem(1);
+                        playerData.itemStackHashMap.put(slot,stack);
+                        inventory.setItem(1,new ItemStack(Material.AIR));
+                        CardGui.OpenGui(player);
+                        String message = Config.langData.getMessage("successfullyInhaled");
+                        String itemName = stack.getItemMeta().getDisplayName();
+                        AuCardBackpack.sendMessage(player,message.replace("%itemName%",itemName),Sound.ENTITY_EXPERIENCE_ORB_PICKUP);
+                    } else {
+                        inventory.setItem(1,new ItemStack(Material.AIR));
+                        player.closeInventory();
+                        CardGui.OpenGui(player);
+                        String message = Config.langData.getMessage("probabilityFailure");
+                        AuCardBackpack.sendMessage(player,message,Sound.ENTITY_VILLAGER_NO);
+                    }
+                }
+            }
+        }
+    }
+
+    @EventHandler
+    public void onClose(InventoryCloseEvent e) {
+        Player player = (Player) e.getPlayer();
+        String playerName = player.getName();
+        Inventory inventory = e.getInventory();
+        if (e.getView().getTitle().contains(startTitle)) {
+            ItemStack itemStack = inventory.getItem(1);
+            if(!DemonAPI.itemIsNull(itemStack) && !DemonAPI.itemIsLore(itemStack)){
+                player.getInventory().addItem(itemStack);
+            }
+        }
+    }
+}

src/main/java/com/yaohun/cardbackpack/listener/KillMobsListener.java

@@ -0,0 +1,73 @@
+package com.yaohun.cardbackpack.listener;
+
+import com.io.yaohun.itemlibrary.api.ItemKuAPI;
+import com.yaohun.cardbackpack.util.RandomUtil;
+import me.Demon.DemonMmKillsDrop.data.DropLogsData;
+import me.Demon.DemonMmKillsDrop.manage.LogsManager;
+import me.Demon.DemonMmKillsStats.Event.KillsMobsStatsEvent;
+import me.Demon.DemonPlugin.DemonAPI;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.inventory.ItemStack;
+import org.serverct.ersha.jd.Ha;
+
+import java.util.HashMap;
+
+public class KillMobsListener implements Listener {
+
+    private static HashMap<String,Double> mobLuckyValue = new HashMap<>();
+
+    private static double getLuckyValue(String mobsType) {
+        if(!mobLuckyValue.containsKey(mobsType)) {
+            return 0.0D;
+        }
+        return mobLuckyValue.get(mobsType);
+    }
+
+    private static void addLuckyValue(String mobsType, double luckyValue) {
+        double nowValue = getLuckyValue(mobsType);
+        if(!mobLuckyValue.containsKey(mobsType)) {
+            mobLuckyValue.put(mobsType, nowValue + luckyValue);
+        }
+        mobLuckyValue.put(mobsType, nowValue + luckyValue);
+    }
+
+    @EventHandler
+    public void onkills(KillsMobsStatsEvent e) {
+        Player player = e.getPlayer();
+        String mobType = e.getMob_type();
+        double luckyValue = getLuckyValue(mobType);
+        double randomChance = RandomUtil.getRandomDouble(0.1D,300.0D,2);
+        if(luckyValue > randomChance) {
+            ItemStack stack = getCardStack(mobType);
+            if(!DemonAPI.itemIsNull(stack)) {
+                player.getInventory().addItem(stack);
+            }
+            mobLuckyValue.put(mobType,0.0D); // 清空幸运值
+        } else {
+            addLuckyValue(mobType, RandomUtil.getRandomDouble(0.1,1.0,1));
+        }
+    }
+
+    public ItemStack getCardStack(String mobsType) {
+        String itemKey = null;
+        if(mobsType.contains("百年")){
+            itemKey = "百年魂卡";
+        }else if(mobsType.contains("千年")){
+            itemKey = "千年魂卡";
+        }else if(mobsType.contains("万年")){
+            itemKey = "万年魂卡";
+        }else if(mobsType.contains("十年")){
+            itemKey = "十年魂卡";
+        }
+        if(itemKey != null) {
+            LogsManager logsManager = me.Demon.DemonMmKillsDrop.Main.getDataManager().getLogsManager();
+            DropLogsData dropLogsData = logsManager.addDropLogsDataMap(mobsType);
+            dropLogsData.addDropKeyAmount(itemKey);
+            return ItemKuAPI.getItemSystemNoLog(itemKey);
+        } else {
+            return null;
+        }
+    }
+}

src/main/java/com/yaohun/cardbackpack/listener/PlayerListener.java

@@ -0,0 +1,32 @@
+package com.yaohun.cardbackpack.listener;
+
+import com.yaohun.cardbackpack.gui.CardGui;
+import de.tr7zw.itemnbtapi.NBTItem;
+import me.Demon.DemonPlugin.DemonAPI;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+
+public class PlayerListener implements Listener {
+
+    @EventHandler
+    public void onMutual(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        if(event.getHand() == EquipmentSlot.HAND){
+            Action action = event.getAction();
+            if(action == Action.RIGHT_CLICK_AIR || action == Action.RIGHT_CLICK_BLOCK){
+                ItemStack stack = player.getInventory().getItemInMainHand();
+                if(!DemonAPI.itemIsNull(stack) && !DemonAPI.itemIsLore(stack)){
+                    NBTItem nbtItem = new NBTItem(stack);
+                    if(nbtItem.hasKey("hunkaKey")){
+                        CardGui.OpenGui(player);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/com/yaohun/cardbackpack/manage/DataManager.java

@@ -0,0 +1,65 @@
+package com.yaohun.cardbackpack.manage;
+
+import com.yaohun.cardbackpack.config.Config;
+import com.yaohun.cardbackpack.data.CardData;
+import com.yaohun.cardbackpack.data.PlayerData;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.serverct.ersha.jd.Ha;
+
+import java.io.File;
+import java.util.HashMap;
+
+public class DataManager {
+
+    private HashMap<String, CardData> cardDataMap = new HashMap<>();
+    private HashMap<String, PlayerData> playerDataMap = new HashMap<>();
+
+
+    public DataManager(){
+        loadCardData();
+    }
+
+    public void reloadDataManager(){
+        SaveAllPlayerData();
+        playerDataMap.clear();
+        cardDataMap.clear();
+        loadCardData();
+        Config.reloadConfig();
+    }
+
+    public void loadCardData(){
+        File file = new File("plugins/AuSettings","AuCardBackpack.yml");
+        FileConfiguration configuration = YamlConfiguration.loadConfiguration(file);
+        ConfigurationSection section = configuration.getConfigurationSection("CardData");
+        if(section != null){
+            for (String hunkaKey : section.getKeys(false)){
+                int slot = section.getInt(hunkaKey+".slot");
+                int money = section.getInt(hunkaKey+".money");
+                double chance = section.getDouble(hunkaKey+".chance");
+                this.cardDataMap.put(hunkaKey,new CardData(hunkaKey,slot,money,chance));
+            }
+        }
+    }
+
+    public void SaveAllPlayerData(){
+        for (PlayerData playerData : playerDataMap.values()) {
+            playerData.SavePlayerData();
+        }
+    }
+
+    public PlayerData getPlayerData(String playerName){
+        if(!this.playerDataMap.containsKey(playerName)){
+            this.playerDataMap.put(playerName, new PlayerData(playerName));
+        }
+        return this.playerDataMap.get(playerName);
+    }
+
+    public CardData getCardData(String hunkaKey){
+        if(this.cardDataMap.containsKey(hunkaKey)){
+           return this.cardDataMap.get(hunkaKey);
+        }
+        return null;
+    }
+}

src/main/java/com/yaohun/cardbackpack/util/RandomUtil.java

@@ -0,0 +1,49 @@
+package com.yaohun.cardbackpack.util;
+
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+import java.util.Random;
+
+public class RandomUtil {
+
+    public static boolean random(double d) {
+        return d >= new Random().nextFloat();
+    }
+
+    public static int getRandomInt(int min, int max) {
+        if (min == max) {
+            return max;
+        }
+        Random r = new Random();
+        int i = min < max ? min : max;
+        int a = min < max ? max : min;
+        return r.nextInt(a - i + 1) + i;
+    }
+
+    public static double getRandomDouble(double min, double max, int scl) {
+        int pow = (int) Math.pow(10, scl);
+        return Math.floor((Math.random() * (max - min) + min) * pow) / pow;
+    }
+
+    public static Location getRandomLocation(World world, double minX, double maxX, double minY, double maxY, double minZ, double maxZ) {
+        double rx = getRandomDouble(minX, maxX, 3);
+        double ry = getRandomDouble(minY, maxY, 3);
+        double rz = getRandomDouble(minZ, maxZ, 3);
+        return new Location(world, rx, ry, rz);
+    }
+
+    public static Location getRandomLocation(Player zhubo, World world, double minX, double maxX, double minY, double maxY, double minZ, double maxZ) {
+        Location location = zhubo.getLocation().add(getRandomInt(-3,3),0,getRandomInt(-3,3));
+        for (int i = 0; i < 10;i++) {
+            Location loc = new Location(world, getRandomDouble(minX, maxX, 3), getRandomDouble(minY, maxY, 3), getRandomDouble(minZ, maxZ, 3));
+            if (loc.distance(zhubo.getLocation()) <= 50) {
+                location = loc;
+                break;
+            }
+        }
+        return location;
+    }
+
+}

src/main/java/com/yaohun/cardbackpack/util/StackUtil.java

@@ -0,0 +1,49 @@
+package com.yaohun.cardbackpack.util;
+
+import com.yaohun.cardbackpack.AuCardBackpack;
+import com.yaohun.cardbackpack.config.Config;
+import com.yaohun.cardbackpack.data.CardData;
+import com.yaohun.cardbackpack.manage.DataManager;
+import de.tr7zw.itemnbtapi.NBTItem;
+import me.Demon.DemonPlugin.DemonAPI;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class StackUtil {
+
+    public static ItemStack iconHide(String name){
+        ItemStack stack = Config.getItemStack("iconHide").clone();
+        ItemMeta meta = stack.getItemMeta();
+        meta.setDisplayName(name);
+        stack.setItemMeta(meta);
+        NBTItem nbtItem = new NBTItem(stack);
+        nbtItem.setString("icon","hide");
+        nbtItem.setString("stex","icon_air");
+        return nbtItem.getItem();
+    }
+
+    public static ItemStack confirmStack(CardData cardData){
+        ItemStack stack = Config.getItemStack("confirmStack").clone();
+        ItemMeta meta = stack.getItemMeta();
+        List<String> lore = meta.getLore();
+        for (int i = 0; i < lore.size(); i++){
+            String string = lore.get(i);
+            if(string.contains("{chance}")){
+                string = string.replace("{chance}",String.valueOf(cardData.chance));
+            }
+            if(string.contains("{money}")){
+                string = string.replace("{money}", DemonAPI.MoneyFormat(cardData.needMoney));
+            }
+            lore.set(i, string);
+        }
+        meta.setLore(lore);
+        stack.setItemMeta(meta);
+        NBTItem nbtItem = new NBTItem(stack);
+        nbtItem.setString("hunka",cardData.getCardKey());
+        return nbtItem.getItem();
+    }
+}

src/main/resources/plugin.yml

@@ -0,0 +1,10 @@
+name: AuCardBackpack
+main: com.yaohun.cardbackpack.AuCardBackpack
+version: 1.0.0
+depend:
+  - DemonAPI
+  - DemonMmKillsStats
+commands:
+  aucard:
+    aliases:
+      - aucard