3712 lines
133 KiB
Plaintext
3712 lines
133 KiB
Plaintext
package Sdf1_login;
|
||
|
||
import java.net.InetSocketAddress;
|
||
import java.util.ArrayList;
|
||
import java.util.Arrays;
|
||
import java.util.HashMap;
|
||
import org.bukkit.event.player.PlayerInteractEvent;
|
||
import java.util.Iterator;
|
||
import java.util.List;
|
||
import java.util.Map;
|
||
import java.util.Set;
|
||
import org.bukkit.event.player.PlayerTeleportEvent;
|
||
import org.bukkit.event.player.PlayerMoveEvent;
|
||
import org.bukkit.Location;
|
||
import org.bukkit.entity.Entity;
|
||
import org.bukkit.entity.Villager;
|
||
import Sdf1_login.ChatInputManager.InputType;
|
||
|
||
|
||
|
||
|
||
import java.util.TreeSet;
|
||
import java.util.UUID;
|
||
import java.util.LinkedHashMap;
|
||
import java.util.concurrent.ConcurrentHashMap;
|
||
import org.bukkit.event.entity.EntityDeathEvent;
|
||
import org.bukkit.event.entity.PlayerDeathEvent;
|
||
import org.bukkit.event.inventory.CraftItemEvent;
|
||
import org.bukkit.event.player.PlayerFishEvent;
|
||
|
||
|
||
import net.milkbowl.vault.economy.Economy;
|
||
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.EventPriority;
|
||
import org.bukkit.event.Listener;
|
||
import org.bukkit.event.block.BlockBreakEvent;
|
||
import org.bukkit.event.block.BlockPlaceEvent;
|
||
import org.bukkit.event.entity.EntityDamageByEntityEvent;
|
||
import org.bukkit.event.entity.EntityDamageEvent;
|
||
import org.bukkit.event.inventory.InventoryClickEvent;
|
||
import org.bukkit.event.inventory.InventoryDragEvent;
|
||
import org.bukkit.event.player.AsyncPlayerChatEvent;
|
||
import org.bukkit.event.player.PlayerDropItemEvent;
|
||
import org.bukkit.event.player.PlayerJoinEvent;
|
||
import org.bukkit.event.player.PlayerPickupItemEvent;
|
||
import org.bukkit.event.player.PlayerQuitEvent;
|
||
import org.bukkit.inventory.Inventory;
|
||
import org.bukkit.inventory.ItemStack;
|
||
import org.bukkit.inventory.meta.ItemMeta;
|
||
import org.bukkit.plugin.RegisteredServiceProvider;
|
||
import org.bukkit.plugin.java.JavaPlugin;
|
||
import org.bukkit.command.Command;
|
||
import org.bukkit.command.CommandExecutor;
|
||
import org.bukkit.command.CommandSender;
|
||
import org.bukkit.command.TabCompleter;
|
||
import org.bukkit.scheduler.BukkitRunnable;
|
||
|
||
public class Main extends JavaPlugin
|
||
implements CommandExecutor, Listener,
|
||
TabCompleter {
|
||
|
||
private DatabaseManager db;
|
||
private ConfigManager config;
|
||
private EmailManager email;
|
||
private LoginManager loginMgr;
|
||
private AFKManager afk;
|
||
private GiftManager gift;
|
||
private CheckInManager checkIn;
|
||
private InviteManager invite;
|
||
private PointsManager points;
|
||
private GUIManager gui;
|
||
private ChatInputManager chatInput;
|
||
private Economy economy;
|
||
private VerificationManager verification;
|
||
private IPGroupManager ipGroup;
|
||
private AccountRequestManager accountRequest;
|
||
private TicketManager ticket;
|
||
private ChatFilterManager chatFilter;
|
||
private GarbageManager garbage;
|
||
|
||
private final Set<String> loggedIn =
|
||
new TreeSet<>(
|
||
String.CASE_INSENSITIVE_ORDER);
|
||
private final Set<String> needsPasswordChange =
|
||
new TreeSet<>(
|
||
String.CASE_INSENSITIVE_ORDER);
|
||
private final Set<String> frozenFlightPlayers =
|
||
new TreeSet<>(
|
||
String.CASE_INSENSITIVE_ORDER);
|
||
private final Map<UUID, Long> joinTime =
|
||
new ConcurrentHashMap<>();
|
||
private final Map<UUID, Location> joinLoc =
|
||
new HashMap<>();
|
||
private final Map<String, Long> ipAutoLogin =
|
||
new HashMap<>();
|
||
private static final long IP_SKIP_MS = 300000L;
|
||
|
||
private final Map<UUID, Long> lastActivity =
|
||
new ConcurrentHashMap<>();
|
||
// 登录后首次回收飞行（仅一次）
|
||
private final Set<String> removeFlightOnce =
|
||
new TreeSet<>(
|
||
String.CASE_INSENSITIVE_ORDER);
|
||
private RadioManager radio;
|
||
public RadioManager getRadio() {
|
||
return radio;
|
||
}
|
||
|
||
|
||
private static class PwdRollback {
|
||
final String hash;
|
||
final String salt;
|
||
final long time;
|
||
PwdRollback(String h, String s, long t) {
|
||
hash = h;
|
||
salt = s;
|
||
time = t;
|
||
}
|
||
}
|
||
|
||
private final Map<String, PwdRollback>
|
||
pwdRollback =
|
||
new ConcurrentHashMap<>();
|
||
|
||
public void recordPasswordChange(String name,
|
||
String oldHash, String oldSalt) {
|
||
pwdRollback.put(name,
|
||
new PwdRollback(oldHash, oldSalt,
|
||
System.currentTimeMillis()));
|
||
}
|
||
|
||
// ===== Getters =====
|
||
public DatabaseManager getDb() {
|
||
return db;
|
||
}
|
||
public ConfigManager getConfig2() { return config; }
|
||
public EmailManager getEmail() { return email; }
|
||
public Economy getEconomy() { return economy; }
|
||
public LoginManager getLoginMgr() { return loginMgr; }
|
||
public AFKManager getAfk() { return afk; }
|
||
public GiftManager getGift() { return gift; }
|
||
public CheckInManager getCheckIn() { return checkIn; }
|
||
public InviteManager getInvite() { return invite; }
|
||
public PointsManager getPoints() { return points; }
|
||
public GUIManager getGui() { return gui; }
|
||
public ChatInputManager getChatInput() { return chatInput; }
|
||
public VerificationManager getVerification() { return verification; }
|
||
public IPGroupManager getIPGroup() { return ipGroup; }
|
||
public AccountRequestManager getAccountRequest() { return accountRequest; }
|
||
public TicketManager getTicket() { return ticket; }
|
||
public ChatFilterManager getChatFilter() { return chatFilter; }
|
||
public GarbageManager getGarbage() { return garbage; }
|
||
public Set<String> getLoggedIn() { return loggedIn; }
|
||
public Set<String> getNeedsPasswordChange() { return needsPasswordChange; }
|
||
private WelcomeManager welcome;
|
||
private UpdateChecker updateChecker;
|
||
private QuestTracker questTracker;
|
||
private CommissionManager commission;
|
||
public CommissionManager getCommission() {
|
||
return commission;
|
||
}
|
||
|
||
|
||
|
||
// ===== Enable/Disable =====
|
||
@Override
|
||
public void onEnable() {
|
||
radio = new RadioManager(this);
|
||
getDataFolder().mkdirs();
|
||
config = new ConfigManager(getDataFolder());
|
||
config.loadMessages();
|
||
config.loadSmtp();
|
||
config.loadSettings();
|
||
getCommand("oa").setExecutor(this);
|
||
|
||
db = new DatabaseManager(getDataFolder());
|
||
db.init();
|
||
email = new EmailManager(config);
|
||
loginMgr = new LoginManager(this);
|
||
afk = new AFKManager(config, this);
|
||
gift = new GiftManager(this);
|
||
gift.loadStages();
|
||
checkIn = new CheckInManager(this);
|
||
invite = new InviteManager(this);
|
||
points = new PointsManager(this);
|
||
gui = new GUIManager(this);
|
||
chatInput = new ChatInputManager();
|
||
verification = new VerificationManager(this);
|
||
ipGroup = new IPGroupManager(this,
|
||
config.maxAccountsPerIP);
|
||
accountRequest =
|
||
new AccountRequestManager(this);
|
||
accountRequest.setMode(config.approvalMode);
|
||
accountRequest.setAutoDelayMinutes(
|
||
config.autoApproveDelayMinutes);
|
||
ticket = new TicketManager(this);
|
||
garbage = new GarbageManager(this);
|
||
garbage.init();
|
||
garbage.loadConfig();
|
||
garbage.startAutoCleanup();
|
||
chatFilter = new ChatFilterManager(this);
|
||
chatFilter.loadConfig();
|
||
welcome = new WelcomeManager(this);
|
||
updateChecker = new UpdateChecker(this);
|
||
questTracker = new QuestTracker(this);
|
||
commission = new CommissionManager(this);
|
||
|
||
|
||
setupEconomy();
|
||
|
||
if (getCommand("sdf1_login") != null) {
|
||
getCommand("sdf1_login").setExecutor(this);
|
||
getCommand("sdf1_login").setTabCompleter(this);
|
||
}
|
||
if (getCommand("reg") != null)
|
||
getCommand("reg").setExecutor(this);
|
||
if (getCommand("login") != null)
|
||
getCommand("login").setExecutor(this);
|
||
if (getCommand("l") != null)
|
||
getCommand("l").setExecutor(this);
|
||
if (getCommand("签到") != null)
|
||
getCommand("签到").setExecutor(this);
|
||
if (getCommand("recycle") != null)
|
||
getCommand("recycle").setExecutor(this);
|
||
if (getCommand("垃圾清理") != null)
|
||
getCommand("垃圾清理").setExecutor(this);
|
||
if (getCommand("绑定邮箱") != null)
|
||
getCommand("绑定邮箱").setExecutor(this);
|
||
if (getCommand("找回密码") != null)
|
||
getCommand("找回密码").setExecutor(this);
|
||
if (getCommand("玩家信息") != null)
|
||
getCommand("玩家信息").setExecutor(this);
|
||
if (getCommand("sdf1debug") != null)
|
||
getCommand("sdf1debug").setExecutor(this);
|
||
if (getCommand("oa") != null)
|
||
getCommand("oa").setExecutor(this);
|
||
if (getCommand("menu") != null)
|
||
getCommand("menu").setExecutor(this);
|
||
if (getCommand("radio") != null)
|
||
getCommand("radio").setExecutor(this);
|
||
getServer().getPluginManager()
|
||
.registerEvents(this, this);
|
||
|
||
afk.startCheck();
|
||
startLoginReminder();
|
||
startTimeoutCheck();
|
||
startPasswordReminder();
|
||
startTicketAutoProcess();
|
||
startPlayTimeTracker();
|
||
// 启动后异步检查更新
|
||
updateChecker.checkOnEnable();
|
||
|
||
getLogger().info(
|
||
"Sdf1_login v1.0 | 就绪");
|
||
for (Player online
|
||
: Bukkit.getOnlinePlayers()) {
|
||
radio.sendResourcePack(online);
|
||
}
|
||
|
||
|
||
}
|
||
|
||
@Override
|
||
public void onDisable() {
|
||
if (questTracker != null) {
|
||
questTracker.shutdown();
|
||
}
|
||
if (radio != null) {
|
||
radio.stopAllLoginRadio();
|
||
radio.stopMainRadio();
|
||
}
|
||
|
||
if (questTracker != null) {
|
||
}
|
||
}
|
||
|
||
// 没替换，只是粗略看了下，有几个问题
|
||
private void setupEconomy() {
|
||
if (getServer().getPluginManager()
|
||
.getPlugin("Vault") == null) return;
|
||
RegisteredServiceProvider<Economy> rsp =
|
||
getServer().getServicesManager()
|
||
.getRegistration(
|
||
Economy.class);
|
||
if (rsp != null)
|
||
economy = rsp.getProvider();
|
||
}
|
||
public WelcomeManager getWelcome() {
|
||
return welcome;
|
||
}
|
||
public UpdateChecker getUpdateChecker() {
|
||
return updateChecker;
|
||
}
|
||
public QuestTracker getQuestTracker() {
|
||
return questTracker;
|
||
}
|
||
|
||
// ===== Timers =====
|
||
private void startTimeoutCheck() {
|
||
new BukkitRunnable() {
|
||
public void run() {
|
||
long now = System.currentTimeMillis();
|
||
Iterator<Map.Entry<UUID, Long>> it =
|
||
joinTime.entrySet().iterator();
|
||
while (it.hasNext()) {
|
||
Map.Entry<UUID, Long> entry =
|
||
it.next();
|
||
if (now - entry.getValue()
|
||
> config.loginTimeout
|
||
* 1000L) {
|
||
Player p = Bukkit.getPlayer(
|
||
entry.getKey());
|
||
if (p != null && p.isOnline()
|
||
&& !loggedIn.contains(
|
||
p.getName()))
|
||
p.kickPlayer(config.msg(
|
||
"login_timeout"));
|
||
it.remove();
|
||
}
|
||
}
|
||
}
|
||
}.runTaskTimer(this, 80L, 80L);
|
||
}
|
||
|
||
private void startLoginReminder() {
|
||
new BukkitRunnable() {
|
||
public void run() {
|
||
Iterator<UUID> it =
|
||
joinTime.keySet().iterator();
|
||
while (it.hasNext()) {
|
||
UUID uuid = it.next();
|
||
Player p = Bukkit.getPlayer(uuid);
|
||
if (p == null || !p.isOnline()) {
|
||
it.remove();
|
||
continue;
|
||
}
|
||
if (loggedIn.contains(
|
||
p.getName())) {
|
||
it.remove();
|
||
continue;
|
||
}
|
||
// 已注册→提示登录，未注册→提示注册
|
||
if (db.userExists(p.getName()))
|
||
p.sendMessage(config.msg(
|
||
"not_logged_in"));
|
||
else
|
||
p.sendMessage(config.msg(
|
||
"not_registered"));
|
||
}
|
||
}
|
||
}.runTaskTimer(this, 200L, 200L);
|
||
}
|
||
|
||
private void startPasswordReminder() {
|
||
new BukkitRunnable() {
|
||
public void run() {
|
||
for (Player p :
|
||
Bukkit.getOnlinePlayers()) {
|
||
if (needsPasswordChange.contains(
|
||
p.getName())) {
|
||
p.sendTitle("§c§l请修改密码",
|
||
"§f使用 /sdf1_login pw 修改密码",
|
||
10, 40, 10);
|
||
p.playSound(p.getLocation(),
|
||
Sound.BLOCK_NOTE_BLOCK_PLING,
|
||
1.0f, 1.0f);
|
||
}
|
||
}
|
||
}
|
||
}.runTaskTimer(this, 200L, 200L);
|
||
}
|
||
|
||
private void startTicketAutoProcess() {
|
||
new BukkitRunnable() {
|
||
public void run() {
|
||
if (ticket != null)
|
||
ticket.autoProcessCompleted();
|
||
}
|
||
}.runTaskTimer(this, 6000L, 6000L);
|
||
}
|
||
|
||
// ===== Utils =====
|
||
public String getPlayerIP(Player p) {
|
||
InetSocketAddress addr = p.getAddress();
|
||
if (addr == null) return null;
|
||
return addr.getAddress().getHostAddress();
|
||
}
|
||
|
||
|
||
public void resetActivity(Player p) {
|
||
lastActivity.put(p.getUniqueId(),
|
||
System.currentTimeMillis());
|
||
}
|
||
|
||
public boolean canAutoLogin(Player p) {
|
||
String ip = getPlayerIP(p);
|
||
if (ip == null) return false;
|
||
Long last = ipAutoLogin.get(ip);
|
||
return last != null
|
||
&& System.currentTimeMillis() - last
|
||
< IP_SKIP_MS;
|
||
}
|
||
|
||
public void recordIPLogin(Player p) {
|
||
String ip = getPlayerIP(p);
|
||
if (ip != null)
|
||
ipAutoLogin.put(ip,
|
||
System.currentTimeMillis());
|
||
}
|
||
|
||
public boolean isFrozen(Player p) {
|
||
return !loggedIn.contains(p.getName());
|
||
}
|
||
|
||
private boolean isAdmin(CommandSender sender) {
|
||
if (sender instanceof Player)
|
||
return ((Player) sender)
|
||
.getScoreboardTags()
|
||
.contains(config.adminTag);
|
||
return true;
|
||
}
|
||
|
||
private void clearPlayer(Player p) {
|
||
p.getInventory().clear();
|
||
p.getInventory().setArmorContents(
|
||
new ItemStack[4]);
|
||
p.getInventory().setExtraContents(
|
||
new ItemStack[1]);
|
||
p.setLevel(0);
|
||
p.setExp(0f);
|
||
}
|
||
|
||
public void restoreInventory(Player p) {
|
||
String name = p.getName();
|
||
try {
|
||
String[] backup =
|
||
db.loadInventoryBackup(name);
|
||
if (backup == null
|
||
|| !isValidBackup(backup)) {
|
||
return;
|
||
}
|
||
|
||
debugPrintBase64("恢复前", name,
|
||
backup[0]);
|
||
|
||
ItemStack[] contents =
|
||
InventorySerializer
|
||
.fromBase64(backup[0]);
|
||
if (contents != null)
|
||
p.getInventory()
|
||
.setContents(contents);
|
||
|
||
if (backup[1] != null
|
||
&& !backup[1].isEmpty()) {
|
||
ItemStack[] armor =
|
||
InventorySerializer
|
||
.fromBase64(
|
||
backup[1]);
|
||
if (armor != null)
|
||
p.getInventory()
|
||
.setArmorContents(
|
||
armor);
|
||
}
|
||
|
||
if (backup[2] != null
|
||
&& !backup[2].isEmpty()) {
|
||
ItemStack[] extra =
|
||
InventorySerializer
|
||
.fromBase64(
|
||
backup[2]);
|
||
if (extra != null)
|
||
p.getInventory()
|
||
.setExtraContents(
|
||
extra);
|
||
}
|
||
|
||
int lv = Integer.parseInt(
|
||
backup[3]);
|
||
if (lv > 0) p.setLevel(lv);
|
||
double xp = Double.parseDouble(
|
||
backup[4]);
|
||
if (xp > 0)
|
||
p.setExp((float) xp);
|
||
|
||
debugPrintBase64("恢复后", name,
|
||
InventorySerializer.toBase64(
|
||
p.getInventory()
|
||
.getContents()));
|
||
|
||
getLogger().info(
|
||
"[Sdf1_login] " + name
|
||
+ " 背包已恢复");
|
||
} catch (Exception e) {
|
||
getLogger().severe(
|
||
"[Sdf1_login] 还原背包失败: "
|
||
+ name);
|
||
e.printStackTrace();
|
||
}
|
||
|
||
}
|
||
|
||
|
||
@EventHandler
|
||
public void onBlockPlace_Quest(
|
||
BlockPlaceEvent e) {
|
||
if (questTracker == null) return;
|
||
Player p = e.getPlayer();
|
||
if (isFrozen(p)) return;
|
||
questTracker.onBlockPlaced(
|
||
p.getName(),
|
||
e.getBlock().getType().name());
|
||
}
|
||
|
||
@EventHandler
|
||
public void onMoveBiome(
|
||
PlayerMoveEvent e) {
|
||
if (questTracker == null) return;
|
||
Player p = e.getPlayer();
|
||
if (isFrozen(p)) return;
|
||
Location to = e.getTo();
|
||
if (to == null) return;
|
||
String fromKey = e.getFrom().getBlock()
|
||
.getBiome().getKey().getKey();
|
||
String toKey = to.getBlock()
|
||
.getBiome().getKey().getKey();
|
||
if (fromKey.equals(toKey)) return;
|
||
questTracker.onPlayerMove(
|
||
p.getName(), toKey);
|
||
}
|
||
|
||
|
||
public void backupInventory(Player p) {
|
||
String name = p.getName();
|
||
int cnt = countItems(p)
|
||
+ countArmor(p)
|
||
+ countExtra(p);
|
||
if (cnt == 0) {
|
||
getLogger().warning(
|
||
"[Sdf1_login] " + name
|
||
+ " 背包为空，跳过备份");
|
||
return;
|
||
}
|
||
try {
|
||
String invB64 =
|
||
InventorySerializer.toBase64(
|
||
p.getInventory()
|
||
.getContents());
|
||
String armorB64 =
|
||
InventorySerializer.toBase64(
|
||
p.getInventory()
|
||
.getArmorContents());
|
||
String extraB64 =
|
||
InventorySerializer.toBase64(
|
||
p.getInventory()
|
||
.getExtraContents());
|
||
db.saveInventoryBackup(name, invB64,
|
||
armorB64, extraB64,
|
||
p.getLevel(), p.getExp());
|
||
getLogger().info(
|
||
"[Sdf1_login] " + name
|
||
+ " 背包已备份 (物品:"
|
||
+ cnt + ")");
|
||
} catch (Exception e) {
|
||
getLogger().severe(
|
||
"[Sdf1_login] 背包备份失败: "
|
||
+ name);
|
||
e.printStackTrace();
|
||
}
|
||
}
|
||
|
||
private void hideInventory(Player p) {
|
||
String name = p.getName();
|
||
try {
|
||
debugPrintBase64("清空前", name,
|
||
InventorySerializer.toBase64(
|
||
p.getInventory()
|
||
.getContents()));
|
||
|
||
// 清空背包（备份已在上次退出时保存）
|
||
p.getInventory().clear();
|
||
p.getInventory()
|
||
.setArmorContents(null);
|
||
p.getInventory()
|
||
.setExtraContents(null);
|
||
p.setLevel(0);
|
||
p.setExp(0);
|
||
|
||
debugPrintBase64("清空后", name,
|
||
InventorySerializer.toBase64(
|
||
p.getInventory()
|
||
.getContents()));
|
||
} catch (Exception e) {
|
||
getLogger().severe(
|
||
"[Sdf1_login] hideInventory失败: "
|
||
+ name);
|
||
e.printStackTrace();
|
||
}
|
||
}
|
||
|
||
private void hideInventoryDelayed(Player p,
|
||
int attempt) {
|
||
String name = p.getName();
|
||
if (!p.isOnline()) return;
|
||
if (!isFrozen(p)) return;
|
||
|
||
// 从数据库加载已有备份
|
||
String[] existing =
|
||
db.loadInventoryBackup(name);
|
||
|
||
// 调试打印
|
||
debugPrintBase64("加入-加载DB", name,
|
||
existing != null
|
||
? existing[0] : null);
|
||
|
||
// 无有效备份 → 跳过清空背包
|
||
if (existing == null
|
||
|| !isValidBackup(existing)) {
|
||
getLogger().info(
|
||
"[Sdf1_login] " + name
|
||
+ " 无有效备份，"
|
||
+ "跳过清空背包");
|
||
return;
|
||
}
|
||
|
||
// 有有效备份 → 清空当前背包
|
||
hideInventory(p);
|
||
}
|
||
|
||
|
||
public void autoLogin(Player p,
|
||
String registerType) {
|
||
String name = p.getName();
|
||
String ip = getPlayerIP(p);
|
||
String uuid =
|
||
p.getUniqueId().toString();
|
||
String defaultPwd = "123456aA";
|
||
|
||
if (!db.userExists(name)) {
|
||
if (config.maxAccountsPerIP > 0
|
||
&& ip != null
|
||
&& !ipGroup.canRegister(ip)) {
|
||
p.kickPlayer(
|
||
buildIPKickMessage(p, ip));
|
||
return;
|
||
}
|
||
if (!"manual".equals(
|
||
config.approvalMode)) {
|
||
AccountRequestManager.Request req =
|
||
accountRequest.createRequest(
|
||
name, name, ip);
|
||
if (req != null) {
|
||
p.kickPlayer(
|
||
config.msg("need_approval")
|
||
.replace("{id}",
|
||
String.valueOf(
|
||
req.id)));
|
||
return;
|
||
}
|
||
radio.stopLoginRadio(p);
|
||
|
||
}
|
||
String salt =
|
||
PasswordUtils.generateSalt();
|
||
String hash = PasswordUtils.hash(
|
||
defaultPwd, salt);
|
||
db.createUser(name, hash, salt);
|
||
db.setField(name,
|
||
"premium_uuid", uuid);
|
||
db.setField(name,
|
||
"register_ip", ip);
|
||
db.setField(name,
|
||
"register_type", registerType);
|
||
db.recordIP(name, ip);
|
||
}
|
||
|
||
loggedIn.add(name);
|
||
removeFlightOnce.add(name);
|
||
db.setLoggedIn(name, true);
|
||
db.setField(name,
|
||
"last_login_time",
|
||
System.currentTimeMillis());
|
||
db.setField(name,
|
||
"last_online_check",
|
||
System.currentTimeMillis());
|
||
db.recordIP(name, ip);
|
||
joinTime.remove(p.getUniqueId());
|
||
recordIPLogin(p);
|
||
|
||
// 标记注册登录条件完成
|
||
if (questTracker != null) {
|
||
questTracker.markConditionComplete(
|
||
name, "完成注册登录");
|
||
}
|
||
|
||
// 欢迎信息
|
||
this.getWelcome().onLogin(p);
|
||
|
||
// 只在有有效备份时恢复
|
||
restoreInventory(p);
|
||
|
||
giveMenuSnowball(p);
|
||
p.sendMessage("§a[Sdf1_login] §f您已自动登录！");
|
||
activateBeibao(p);
|
||
pushPendingAlerts(p);
|
||
}
|
||
|
||
// ===== 任务追踪事件 =====
|
||
|
||
@EventHandler
|
||
public void onBlockMine(BlockBreakEvent event) {
|
||
if (questTracker == null) return; // ← 新增
|
||
Player p = event.getPlayer();
|
||
if (isFrozen(p)) return;
|
||
questTracker.onBlockMined(
|
||
p.getName(),
|
||
event.getBlock().getType().name());
|
||
}
|
||
|
||
@EventHandler
|
||
public void onMobDeath(EntityDeathEvent e) {
|
||
if (questTracker == null) return; // ← 新增
|
||
if (e.getEntity().getKiller() == null)
|
||
return;
|
||
Player p = e.getEntity().getKiller();
|
||
questTracker.onMobKill(
|
||
p.getName(),
|
||
e.getEntity().getType().name());
|
||
}
|
||
|
||
@EventHandler
|
||
public void onPlayerDeath(
|
||
PlayerDeathEvent e) {
|
||
if (questTracker == null) return; // ← 新增
|
||
Player killer =
|
||
e.getEntity().getKiller();
|
||
if (killer == null) return;
|
||
questTracker.onPlayerKill(
|
||
killer.getName());
|
||
}
|
||
|
||
@EventHandler
|
||
public void onCraft(
|
||
CraftItemEvent e) {
|
||
if (questTracker == null) return; // ← 新增
|
||
if (!(e.getWhoClicked()
|
||
instanceof Player)) return;
|
||
Player p = (Player) e.getWhoClicked();
|
||
if (isFrozen(p)) return;
|
||
questTracker.onItemCrafted(
|
||
p.getName());
|
||
}
|
||
|
||
@EventHandler
|
||
public void onFish(
|
||
PlayerFishEvent e) {
|
||
if (questTracker == null) return; // ← 新增
|
||
if (e.getState()
|
||
!= PlayerFishEvent
|
||
.State.CAUGHT_FISH) return;
|
||
if (!(e.getCaught()
|
||
instanceof
|
||
org.bukkit.entity.Item)) return;
|
||
Player p = e.getPlayer();
|
||
questTracker.onFishCaught(
|
||
p.getName());
|
||
}
|
||
|
||
// 在线时长追踪（每分钟）
|
||
public void startPlayTimeTracker() {
|
||
Bukkit.getScheduler()
|
||
.runTaskTimer(this,
|
||
() -> {
|
||
if (questTracker == null) return;
|
||
for (Player p :
|
||
Bukkit.getOnlinePlayers()) {
|
||
if (isFrozen(p)) continue;
|
||
questTracker.onPlayTime(
|
||
p.getName(),
|
||
60000L);
|
||
}
|
||
}, 1200L, 1200L);
|
||
}
|
||
|
||
private void activateBeibao(Player p) {
|
||
try {
|
||
org.bukkit.plugin.Plugin cy =
|
||
Bukkit.getPluginManager()
|
||
.getPlugin("CY_beibao");
|
||
if (cy != null && cy.isEnabled())
|
||
cy.getClass().getMethod(
|
||
"onSdf1Activation",
|
||
String.class,
|
||
int.class, int.class)
|
||
.invoke(cy, p.getName(),
|
||
0, 0);
|
||
} catch (Exception ignored) {
|
||
}
|
||
}
|
||
|
||
public void triggerSecurityAlert(Player player,
|
||
String suspiciousIP) {
|
||
String name = player.getName();
|
||
db.recordSecurityAlert(name, suspiciousIP);
|
||
Bukkit.broadcastMessage(
|
||
"§c§l[安全警告] §e" + name
|
||
+ " §f账号疑似遭到 §c"
|
||
+ suspiciousIP
|
||
+ " §f的盗号尝试");
|
||
String emailAddr =
|
||
(String) db.getField(name, "email");
|
||
if (emailAddr != null
|
||
&& !emailAddr.isEmpty()) {
|
||
String body = "玩家 " + name
|
||
+ "：\n您的账号在 "
|
||
+ new java.text.SimpleDateFormat(
|
||
"yyyy-MM-dd HH:mm:ss")
|
||
.format(new java.util.Date())
|
||
+ " 疑似遭到 IP: "
|
||
+ suspiciousIP
|
||
+ " 的盗号尝试。\n"
|
||
+ "建议立即修改密码。";
|
||
final String to = emailAddr;
|
||
final String finalBody = body;
|
||
Bukkit.getScheduler()
|
||
.runTaskAsynchronously(this,
|
||
() -> email
|
||
.sendTempPassword(
|
||
to, name,
|
||
finalBody));
|
||
}
|
||
}
|
||
|
||
public void pushPendingAlerts(Player p) {
|
||
String name = p.getName();
|
||
List<Map<String, Object>> alerts =
|
||
db.getUnnotifiedAlerts(name);
|
||
if (alerts.isEmpty()) return;
|
||
p.sendMessage("§c§l========== 安全报警 ==========");
|
||
for (Map<String, Object> alert : alerts) {
|
||
p.sendMessage("§e时间: §f"
|
||
+ alert.get("alert_date"));
|
||
p.sendMessage("§e可疑IP: §c"
|
||
+ alert.get("alert_ip"));
|
||
db.markAlertNotified(
|
||
((Number) alert.get("id"))
|
||
.intValue());
|
||
}
|
||
p.sendMessage(
|
||
"§c建议使用 §e/sdf1_login pw §c修改密码");
|
||
p.sendMessage(
|
||
"§c§l==================================");
|
||
}
|
||
|
||
public void handleReset(Player p) {
|
||
loginMgr.handleReset(p);
|
||
}
|
||
|
||
public boolean dailySign(Player p) {
|
||
if (checkIn.isCheckedInToday(p.getName()))
|
||
return false;
|
||
p.sendMessage(checkIn.checkIn(p));
|
||
invite.onInviteeCheckIn(p.getName());
|
||
return true;
|
||
}
|
||
|
||
|
||
public void openAccountRequestPanel(Player p) {
|
||
Inventory g = Bukkit.createInventory(
|
||
null, 27, "§e§l账号请求");
|
||
ItemStack gl = new ItemStack(
|
||
Material.GRAY_STAINED_GLASS_PANE);
|
||
ItemMeta glm = gl.getItemMeta();
|
||
if (glm != null) {
|
||
glm.setDisplayName(" ");
|
||
gl.setItemMeta(glm);
|
||
}
|
||
for (int i = 0; i < 27; i++)
|
||
g.setItem(i, gl);
|
||
g.setItem(10, mkItem(Material.BARRIER,
|
||
"§c申请删除账号",
|
||
"§7申请删除自己名下的账号"));
|
||
g.setItem(13, mkItem(Material.PAPER,
|
||
"§6提交工单",
|
||
"§7提交bug反馈、求助、举报等"));
|
||
g.setItem(16, mkItem(Material.REDSTONE,
|
||
"§e找回密码",
|
||
"§7通过邮箱找回密码"));
|
||
g.setItem(22, mkItem(Material.ARROW,
|
||
"§7返回"));
|
||
p.openInventory(g);
|
||
}
|
||
|
||
private void playSuccessSound(Player p) {
|
||
p.playSound(p.getLocation(),
|
||
Sound.BLOCK_NOTE_BLOCK_CHIME,
|
||
1.0f, 0.79f);
|
||
p.playSound(p.getLocation(),
|
||
Sound.BLOCK_NOTE_BLOCK_BASS,
|
||
1.0f, 0.79f);
|
||
p.playSound(p.getLocation(),
|
||
Sound.BLOCK_NOTE_BLOCK_PLING,
|
||
1.0f, 0.79f);
|
||
}
|
||
|
||
private int countItems(Player p) {
|
||
int c = 0;
|
||
for (ItemStack it : p.getInventory()
|
||
.getContents())
|
||
if (it != null && it.getType()
|
||
!= Material.AIR) c++;
|
||
return c;
|
||
}
|
||
|
||
private int countArmor(Player p) {
|
||
int c = 0;
|
||
for (ItemStack it : p.getInventory()
|
||
.getArmorContents())
|
||
if (it != null && it.getType()
|
||
!= Material.AIR) c++;
|
||
return c;
|
||
}
|
||
|
||
private int countExtra(Player p) {
|
||
int c = 0;
|
||
for (ItemStack it : p.getInventory()
|
||
.getExtraContents())
|
||
if (it != null && it.getType()
|
||
!= Material.AIR) c++;
|
||
return c;
|
||
}
|
||
|
||
/**
|
||
* 检查备份是否有效（包含非雪球的真实物品）
|
||
*/
|
||
public boolean isValidBackup(String[] backup) {
|
||
if (backup == null
|
||
|| backup[0] == null
|
||
|| backup[0].isEmpty()) {
|
||
return false;
|
||
}
|
||
try {
|
||
ItemStack[] items =
|
||
InventorySerializer
|
||
.fromBase64(backup[0]);
|
||
if (items == null) return false;
|
||
for (ItemStack item : items) {
|
||
if (item == null
|
||
|| item.getType()
|
||
== Material.AIR)
|
||
continue;
|
||
if (isMenuSnowball(item))
|
||
continue;
|
||
return true;
|
||
}
|
||
} catch (Exception e) {
|
||
return false;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 控制台打印 base64 前10位
|
||
*/
|
||
private void debugPrintBase64(String label,
|
||
String name, String base64) {
|
||
if (base64 == null || base64.isEmpty()) {
|
||
getLogger().info(
|
||
"[BACKUP_DEBUG] " + label
|
||
+ " " + name
|
||
+ ": <empty>");
|
||
return;
|
||
}
|
||
String preview =
|
||
base64.length() > 10
|
||
? base64.substring(0, 10)
|
||
: base64;
|
||
getLogger().info(
|
||
"[BACKUP_DEBUG] " + label + " "
|
||
+ name + ": " + preview);
|
||
}
|
||
|
||
private ItemStack mkItem(Material mat,
|
||
String name, String... lore) {
|
||
ItemStack it = new ItemStack(mat);
|
||
ItemMeta im = it.getItemMeta();
|
||
if (im != null) {
|
||
im.setDisplayName(name);
|
||
if (lore.length > 0) {
|
||
List<String> list =
|
||
new ArrayList<>();
|
||
for (String l : lore)
|
||
if (!l.isEmpty()) list.add(l);
|
||
if (!list.isEmpty())
|
||
im.setLore(list);
|
||
}
|
||
it.setItemMeta(im);
|
||
}
|
||
return it;
|
||
}
|
||
|
||
private String buildIPKickMessage(Player p,
|
||
String ip) {
|
||
List<Map<String, Object>> accounts =
|
||
db.getAccountDetailsByIP(ip);
|
||
StringBuilder sb = new StringBuilder();
|
||
sb.append("§c§l======== IP注册已满 ========\n");
|
||
sb.append("§e您的IP §f").append(ip)
|
||
.append(" §e下已注册 §f")
|
||
.append(accounts.size())
|
||
.append(" §e个账号：\n");
|
||
java.text.SimpleDateFormat sdf =
|
||
new java.text.SimpleDateFormat(
|
||
"yyyy-MM-dd HH:mm");
|
||
int idx = 1;
|
||
for (Map<String, Object> acc : accounts) {
|
||
long regTime = ((Number) acc.get(
|
||
"register_time")).longValue();
|
||
String dateStr = regTime > 0
|
||
? sdf.format(new java.util.Date(
|
||
regTime))
|
||
: "未知";
|
||
sb.append("§7").append(idx)
|
||
.append(". §f")
|
||
.append(acc.get("player_name"))
|
||
.append(" §7注册于: §e")
|
||
.append(dateStr).append("\n");
|
||
idx++;
|
||
}
|
||
sb.append("§7-----------------------------\n");
|
||
sb.append("§e请使用已有账号登录\n");
|
||
sb.append("§e登录后输入 §f/oa §e提交工单\n");
|
||
sb.append("§c§l============================");
|
||
return sb.toString();
|
||
}
|
||
/**
|
||
* 读取备份，返回物品名预览
|
||
*/
|
||
private String getBackupItemPreview(
|
||
int backupId) {
|
||
try {
|
||
String[] backup =
|
||
db.getInventoryBackupById(
|
||
backupId);
|
||
if (backup == null
|
||
|| backup[0] == null
|
||
|| backup[0].isEmpty())
|
||
return "§7空";
|
||
ItemStack[] items =
|
||
InventorySerializer
|
||
.fromBase64(
|
||
backup[0]);
|
||
if (items == null)
|
||
return "§7空";
|
||
Map<String, Integer> counts =
|
||
new LinkedHashMap<>();
|
||
for (ItemStack it : items) {
|
||
if (it == null
|
||
|| it.getType()
|
||
== Material.AIR)
|
||
continue;
|
||
String name = translateMaterial(
|
||
it.getType().name());
|
||
counts.merge(name,
|
||
it.getAmount(),
|
||
Integer::sum);
|
||
}
|
||
if (counts.isEmpty())
|
||
return "§7空";
|
||
StringBuilder sb =
|
||
new StringBuilder();
|
||
int shown = 0;
|
||
for (Map.Entry<String, Integer> en
|
||
: counts.entrySet()) {
|
||
if (shown >= 5) {
|
||
sb.append(" §7...");
|
||
break;
|
||
}
|
||
if (shown > 0)
|
||
sb.append("§7, ");
|
||
sb.append("§f").append(en.getKey())
|
||
.append("§7x")
|
||
.append(en.getValue());
|
||
shown++;
|
||
}
|
||
return sb.toString();
|
||
} catch (Exception e) {
|
||
return "§7解析失败";
|
||
}
|
||
}
|
||
|
||
private String translateMaterial(
|
||
String name) {
|
||
switch (name) {
|
||
case "GRASS_BLOCK":
|
||
return "草方块";
|
||
case "OAK_LOG":
|
||
return "橡木原木";
|
||
case "OAK_PLANKS":
|
||
return "橡木木板";
|
||
case "STONE":
|
||
return "石头";
|
||
case "COBBLESTONE":
|
||
return "圆石";
|
||
case "DIRT":
|
||
return "泥土";
|
||
case "SAND":
|
||
return "沙子";
|
||
case "GRAVEL":
|
||
return "砂砾";
|
||
case "DIAMOND":
|
||
return "钻石";
|
||
case "DIAMOND_ORE":
|
||
return "钻石矿石";
|
||
case "IRON_INGOT":
|
||
return "铁锭";
|
||
case "GOLD_INGOT":
|
||
return "金锭";
|
||
case "COAL":
|
||
return "煤炭";
|
||
case "COAL_ORE":
|
||
return "煤矿石";
|
||
case "RAW_IRON":
|
||
return "粗铁";
|
||
case "RAW_GOLD":
|
||
return "粗金";
|
||
case "OAK_LEAVES":
|
||
return "橡树树叶";
|
||
case "OAK_SAPLING":
|
||
return "橡树树苗";
|
||
case "STICK":
|
||
return "木棍";
|
||
case "CRAFTING_TABLE":
|
||
return "工作台";
|
||
case "FURNACE":
|
||
return "熔炉";
|
||
case "CHEST":
|
||
return "箱子";
|
||
case "TORCH":
|
||
return "火把";
|
||
case "BEDROCK":
|
||
return "基岩";
|
||
case "TNT":
|
||
return "TNT";
|
||
case "REDSTONE":
|
||
return "红石";
|
||
case "REDSTONE_ORE":
|
||
return "红石矿石";
|
||
case "LAPIS_LAZULI":
|
||
return "青金石";
|
||
case "EMERALD":
|
||
return "绿宝石";
|
||
case "EMERALD_ORE":
|
||
return "绿宝石矿石";
|
||
case "OBSIDIAN":
|
||
return "黑曜石";
|
||
case "GLOWSTONE":
|
||
return "萤石";
|
||
case "ARROW":
|
||
return "箭";
|
||
case "BOW":
|
||
return "弓";
|
||
case "IRON_SWORD":
|
||
return "铁剑";
|
||
case "DIAMOND_SWORD":
|
||
return "钻石剑";
|
||
case "IRON_PICKAXE":
|
||
return "铁镐";
|
||
case "DIAMOND_PICKAXE":
|
||
return "钻石镐";
|
||
case "IRON_AXE":
|
||
return "铁斧";
|
||
case "DIAMOND_AXE":
|
||
return "钻石斧";
|
||
case "IRON_HELMET":
|
||
return "铁头盔";
|
||
case "IRON_CHESTPLATE":
|
||
return "铁胸甲";
|
||
case "IRON_LEGGINGS":
|
||
return "铁护腿";
|
||
case "IRON_BOOTS":
|
||
return "铁靴子";
|
||
case "DIAMOND_HELMET":
|
||
return "钻石头盔";
|
||
case "DIAMOND_CHESTPLATE":
|
||
return "钻石胸甲";
|
||
case "DIAMOND_LEGGINGS":
|
||
return "钻石护腿";
|
||
case "DIAMOND_BOOTS":
|
||
return "钻石靴子";
|
||
case "BREAD":
|
||
return "面包";
|
||
case "COOKED_BEEF":
|
||
return "牛排";
|
||
case "COOKED_PORKCHOP":
|
||
return "熟猪排";
|
||
case "COOKED_CHICKEN":
|
||
return "熟鸡肉";
|
||
case "GOLDEN_APPLE":
|
||
return "金苹果";
|
||
case "ENDER_PEARL":
|
||
return "末影珍珠";
|
||
case "BLAZE_ROD":
|
||
return "烈焰棒";
|
||
case "GHAST_TEAR":
|
||
return "恶魂之泪";
|
||
case "NETHER_STAR":
|
||
return "下界之星";
|
||
case "SHULKER_SHELL":
|
||
return "潜影壳";
|
||
case "ELYTRA":
|
||
return "鞘翅";
|
||
case "TOTEM_OF_UNDYING":
|
||
return "不死图腾";
|
||
case "TRIDENT":
|
||
return "三叉戟";
|
||
case "ENCHANTED_GOLDEN_APPLE":
|
||
return "附魔金苹果";
|
||
default:
|
||
// 转中文名格式：SANDSTONE -> 沙石
|
||
return name.toLowerCase()
|
||
.replace("_", " ");
|
||
}
|
||
}
|
||
|
||
@EventHandler
|
||
public void onTeleportBiome(
|
||
PlayerTeleportEvent e) {
|
||
if (questTracker == null) return;
|
||
Player p = e.getPlayer();
|
||
if (isFrozen(p)) return;
|
||
Location to = e.getTo();
|
||
if (to == null) return;
|
||
String toKey = to.getBlock()
|
||
.getBiome().getKey().getKey();
|
||
questTracker.onPlayerMove(
|
||
p.getName(), toKey);
|
||
}
|
||
|
||
@EventHandler
|
||
public void onJoin(PlayerJoinEvent e) {
|
||
Player p = e.getPlayer();
|
||
String name = p.getName();
|
||
String ip = getPlayerIP(p);
|
||
// 重置聊天输入状态（防止上次退出时残留）
|
||
chatInput.reset(p);
|
||
if (needsPasswordChange.contains(name))
|
||
needsPasswordChange.remove(name);
|
||
lastActivity.put(p.getUniqueId(),
|
||
System.currentTimeMillis());
|
||
if (needsPasswordChange.contains(name))
|
||
needsPasswordChange.remove(name);
|
||
|
||
boolean isBedrock =
|
||
verification.isBedrockPlayer(p);
|
||
boolean isOnlineMode =
|
||
verification.isOnlineMode();
|
||
|
||
if (!db.userExists(name)) {
|
||
if (config.maxAccountsPerIP > 0
|
||
&& ip != null
|
||
&& !ipGroup.canRegister(ip)) {
|
||
p.kickPlayer(
|
||
buildIPKickMessage(p, ip));
|
||
return;
|
||
}
|
||
}
|
||
if (isFrozen(p)) {
|
||
p.setAllowFlight(true);
|
||
frozenFlightPlayers.add(p.getName());
|
||
}
|
||
if (questTracker != null) {
|
||
questTracker.debugLogin(p.getName());
|
||
}
|
||
|
||
if (!"manual".equals(config.approvalMode)
|
||
&& !db.userExists(name)) {
|
||
AccountRequestManager.Request req =
|
||
accountRequest.createRequest(
|
||
name, name, ip);
|
||
if (req != null) {
|
||
p.kickPlayer(
|
||
config.msg("need_approval")
|
||
.replace("{id}",
|
||
String.valueOf(
|
||
req.id)));
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (isOnlineMode) {
|
||
autoLogin(p, "premium");
|
||
return;
|
||
}
|
||
if (isBedrock) {
|
||
autoLogin(p, "bedrock");
|
||
return;
|
||
}
|
||
if (canAutoLogin(p)) {
|
||
autoLogin(p, "ip_reconnect");
|
||
return;
|
||
}
|
||
afk.remove(p.getUniqueId());
|
||
afk.recordAction(p.getUniqueId());
|
||
hideInventoryDelayed(p, 0);
|
||
|
||
|
||
verification.verifyPremiumAsync(p,
|
||
isPremium -> {
|
||
if (isPremium) {
|
||
Bukkit.getScheduler()
|
||
.runTask(this,
|
||
() -> autoLogin(p,
|
||
"premium"));
|
||
} else {
|
||
Bukkit.getScheduler()
|
||
.runTask(this, () -> {
|
||
joinTime.put(
|
||
p.getUniqueId(),
|
||
System.currentTimeMillis());
|
||
if (!db.userExists(name))
|
||
p.sendMessage(config.msg(
|
||
"not_registered"));
|
||
else
|
||
p.sendMessage(config.msg(
|
||
"not_logged_in"));
|
||
});
|
||
}
|
||
});
|
||
}
|
||
|
||
@EventHandler
|
||
public void onQuit(PlayerQuitEvent e) {
|
||
Player p = e.getPlayer();
|
||
// 记录冻结状态的飞行
|
||
if (!db.userExists(p.getName())
|
||
|| !loggedIn.contains(p.getName())) {
|
||
p.setAllowFlight(true);
|
||
frozenFlightPlayers.add(p.getName());
|
||
}
|
||
|
||
String name = p.getName();
|
||
chatInput.reset(p);
|
||
|
||
boolean wasLoggedIn =
|
||
loggedIn.contains(name);
|
||
|
||
boolean hasRealItems = false;
|
||
for (ItemStack it : p.getInventory()
|
||
.getContents()) {
|
||
if (it != null
|
||
&& it.getType()
|
||
!= Material.AIR
|
||
&& !isMenuSnowball(it)) {
|
||
hasRealItems = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (wasLoggedIn || hasRealItems) {
|
||
try {
|
||
String contents =
|
||
InventorySerializer
|
||
.toBase64(
|
||
p.getInventory()
|
||
.getContents());
|
||
String armor =
|
||
InventorySerializer
|
||
.toBase64(
|
||
p.getInventory()
|
||
.getArmorContents());
|
||
String extra =
|
||
InventorySerializer
|
||
.toBase64(
|
||
p.getInventory()
|
||
.getExtraContents());
|
||
int level = p.getLevel();
|
||
double exp = p.getExp();
|
||
|
||
debugPrintBase64(
|
||
"退出保存", name, contents);
|
||
db.saveInventoryBackup(name,
|
||
contents, armor, extra,
|
||
level, exp);
|
||
} catch (Exception ex) {
|
||
getLogger().severe(
|
||
"[Sdf1_login] "
|
||
+ "退出保存背包失败: "
|
||
+ name);
|
||
}
|
||
} else {
|
||
getLogger().info(
|
||
"[BACKUP_DEBUG] 退出跳过 "
|
||
+ name + ": 背包为空"
|
||
+ "（插件已清空）");
|
||
}
|
||
|
||
if (wasLoggedIn) {
|
||
loggedIn.remove(name);
|
||
db.setLoggedIn(name, false);
|
||
recordIPLogin(p);
|
||
}
|
||
|
||
frozenFlightPlayers.remove(name); // ← 新增
|
||
lastActivity.remove(p.getUniqueId());
|
||
joinTime.remove(p.getUniqueId());
|
||
joinLoc.remove(p.getUniqueId());
|
||
needsPasswordChange.remove(name);
|
||
}
|
||
|
||
private static final String MENU_SNOWBALL_TAG =
|
||
"sdf1_menu";
|
||
|
||
// 雪球菜单
|
||
public void giveMenuSnowball(Player p) {
|
||
// 检查开关
|
||
Object val = db.getField(
|
||
p.getName(), "menu_snowball");
|
||
if (val != null) {
|
||
int on = val instanceof Number
|
||
? ((Number) val).intValue()
|
||
: 1;
|
||
if (on == 0) {
|
||
return; // 开关关了，不发放
|
||
}
|
||
}
|
||
// 检查是否已有
|
||
for (ItemStack it : p.getInventory()
|
||
.getContents()) {
|
||
if (isMenuSnowball(it)) {
|
||
return;
|
||
}
|
||
}
|
||
// 发放
|
||
ItemStack snow = new ItemStack(
|
||
Material.SNOWBALL);
|
||
ItemMeta im = snow.getItemMeta();
|
||
if (im != null) {
|
||
im.setDisplayName(
|
||
"§e§l[菜单] §f右键打开主菜单");
|
||
List<String> lore =
|
||
new ArrayList<>();
|
||
lore.add("§7右键点击打开功能菜单");
|
||
lore.add("§8" + MENU_SNOWBALL_TAG);
|
||
im.setLore(lore);
|
||
snow.setItemMeta(im);
|
||
}
|
||
int slot = p.getInventory()
|
||
.firstEmpty();
|
||
if (slot >= 0) {
|
||
p.getInventory().setItem(
|
||
slot, snow);
|
||
} else {
|
||
p.getWorld().dropItemNaturally(
|
||
p.getLocation(), snow);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 手动发放雪球菜单（绕过开关检查）
|
||
*/
|
||
public void forceGiveMenuSnowball(
|
||
Player p) {
|
||
// 只检查是否已有
|
||
for (ItemStack it : p.getInventory()
|
||
.getContents()) {
|
||
if (isMenuSnowball(it)) {
|
||
return;
|
||
}
|
||
}
|
||
ItemStack snow = new ItemStack(
|
||
Material.SNOWBALL);
|
||
ItemMeta im = snow.getItemMeta();
|
||
if (im != null) {
|
||
im.setDisplayName(
|
||
"§e§l[菜单] §f右键打开主菜单");
|
||
List<String> lore =
|
||
new ArrayList<>();
|
||
lore.add("§7右键点击打开功能菜单");
|
||
lore.add("§8" + MENU_SNOWBALL_TAG);
|
||
im.setLore(lore);
|
||
snow.setItemMeta(im);
|
||
}
|
||
int slot = p.getInventory()
|
||
.firstEmpty();
|
||
if (slot >= 0) {
|
||
p.getInventory().setItem(
|
||
slot, snow);
|
||
} else {
|
||
p.getWorld().dropItemNaturally(
|
||
p.getLocation(), snow);
|
||
}
|
||
}
|
||
|
||
private boolean isMenuSnowball(ItemStack item) {
|
||
if (item == null
|
||
|| item.getType()
|
||
!= Material.SNOWBALL)
|
||
return false;
|
||
if (!item.hasItemMeta())
|
||
return false;
|
||
ItemMeta im = item.getItemMeta();
|
||
if (im == null) return false;
|
||
if (!im.hasLore()) return false;
|
||
List<String> lore = im.getLore();
|
||
if (lore == null) return false;
|
||
for (String line : lore) {
|
||
if (line.contains(MENU_SNOWBALL_TAG))
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
@EventHandler
|
||
public void onMove(PlayerMoveEvent e) {
|
||
Player p = e.getPlayer();
|
||
|
||
// 已登录：一次性关闭飞行
|
||
if (!isFrozen(p)) {
|
||
if (frozenFlightPlayers.remove(
|
||
p.getName())) {
|
||
p.setAllowFlight(false);
|
||
p.setFlying(false);
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
// 未登录：检查是否能移动
|
||
Location from = e.getFrom();
|
||
Location to = e.getTo();
|
||
if (to == null) return;
|
||
|
||
// 允许转头（无位移）
|
||
if (from.getBlockX() == to.getBlockX()
|
||
&& from.getBlockY() == to.getBlockY()
|
||
&& from.getBlockZ() == to.getBlockZ()) {
|
||
return;
|
||
}
|
||
|
||
// 有位移 → 取消移动
|
||
e.setCancelled(true);
|
||
|
||
// 确保允许飞行（防止被踢出）
|
||
if (!p.getAllowFlight()) {
|
||
p.setAllowFlight(true);
|
||
}
|
||
|
||
// 确保已记录（首次加入时未触发移动的情况）
|
||
if (!frozenFlightPlayers.contains(
|
||
p.getName())) {
|
||
frozenFlightPlayers.add(p.getName());
|
||
}
|
||
}
|
||
|
||
@EventHandler
|
||
public void onInteract(PlayerInteractEvent e) {
|
||
Player p = e.getPlayer();
|
||
ItemStack item = e.getItem();
|
||
if (item == null
|
||
|| item.getType()
|
||
!= Material.SNOWBALL)
|
||
return;
|
||
if (!isMenuSnowball(item)) return;
|
||
if (isFrozen(p)) return;
|
||
if (!loggedIn.contains(p.getName())) return;
|
||
e.setCancelled(true);
|
||
gui.openMain(p);
|
||
}
|
||
|
||
@EventHandler
|
||
public void onBlockBreak(BlockBreakEvent e) {
|
||
Player p = e.getPlayer();
|
||
if (isFrozen(p)) {
|
||
e.setCancelled(true);
|
||
return;
|
||
}
|
||
afk.recordAction(p.getUniqueId());
|
||
}
|
||
|
||
@EventHandler
|
||
public void onBlockPlace(BlockPlaceEvent e) {
|
||
if (isFrozen(e.getPlayer()))
|
||
e.setCancelled(true);
|
||
}
|
||
|
||
@EventHandler
|
||
public void onDrop(PlayerDropItemEvent e) {
|
||
if (isFrozen(e.getPlayer())) {
|
||
e.setCancelled(true);
|
||
return;
|
||
}
|
||
// 禁止丢弃菜单雪球
|
||
ItemStack drop =
|
||
e.getItemDrop().getItemStack();
|
||
if (isMenuSnowball(drop)) {
|
||
e.setCancelled(true);
|
||
}
|
||
}
|
||
|
||
@EventHandler
|
||
public void onPickup(PlayerPickupItemEvent e) {
|
||
if (isFrozen(e.getPlayer()))
|
||
e.setCancelled(true);
|
||
}
|
||
|
||
@EventHandler
|
||
public void onDamage(EntityDamageEvent e) {
|
||
if (e.getEntity() instanceof Player) {
|
||
if (isFrozen((Player) e.getEntity()))
|
||
e.setCancelled(true);
|
||
}
|
||
}
|
||
|
||
@EventHandler
|
||
public void onEntityAttack(
|
||
EntityDamageByEntityEvent e) {
|
||
if (e.getDamager() instanceof Player
|
||
&& isFrozen(
|
||
(Player) e.getDamager()))
|
||
e.setCancelled(true);
|
||
if (e.getEntity() instanceof Player
|
||
&& isFrozen(
|
||
(Player) e.getEntity()))
|
||
e.setCancelled(true);
|
||
}
|
||
|
||
@EventHandler(priority = EventPriority.LOWEST)
|
||
public void onChat(AsyncPlayerChatEvent e) {
|
||
Player p = e.getPlayer();
|
||
String msg = e.getMessage();
|
||
|
||
if (chatInput.getState(p).type
|
||
!= ChatInputManager.InputType.NONE) {
|
||
e.setCancelled(true);
|
||
ChatInputManager.InputType inputType =
|
||
chatInput.getState(p).type;
|
||
if (ticket != null
|
||
&& ticket.handleChatInput(
|
||
p, msg, inputType)) {
|
||
return;
|
||
}
|
||
chatInput.handleInput(p, msg, this);
|
||
return;
|
||
}
|
||
|
||
if (isFrozen(p)) {
|
||
e.setCancelled(true);
|
||
return;
|
||
}
|
||
// 在 onChat 方法中，isFrozen 检查之后
|
||
// （在 chatFilter 检查之前）
|
||
if (!isFrozen(p)
|
||
&& questTracker != null) {
|
||
final String pn = p.getName();
|
||
Bukkit.getScheduler().runTask(this,
|
||
() -> questTracker
|
||
.onPlayerChat(pn));
|
||
}
|
||
|
||
if (chatFilter == null) return;
|
||
// 安全兜底：任何输入状态下跳过过滤
|
||
if (chatInput.getState(p).type
|
||
!= ChatInputManager.InputType.NONE) {
|
||
return;
|
||
}
|
||
|
||
if (chatFilter.isPlayerWhitelisted(
|
||
p.getName())) return;
|
||
// 联控：绑定邮箱/配置SMTP时跳过URL过滤
|
||
InputType inType =
|
||
chatInput.getState(p).type;
|
||
if (inType == InputType.SET_EMAIL
|
||
|| inType == InputType.SET_EMAIL_VERIFY
|
||
|| inType == InputType.SMTP_CONFIG
|
||
|| inType == InputType.SMTP_VERIFY) {
|
||
return;
|
||
}
|
||
|
||
if (chatFilter.isMuted(p.getName())) {
|
||
e.setCancelled(true);
|
||
p.sendMessage(
|
||
chatFilter.msg("chat_muted"));
|
||
return;
|
||
}
|
||
|
||
List<String> urls =
|
||
chatFilter.extractUrls(msg);
|
||
if (urls.isEmpty()) return;
|
||
|
||
for (String u : urls) {
|
||
if (chatFilter.isPlayerWhitelisted(u))
|
||
continue;
|
||
if (!chatFilter.isLikelyDomain(u))
|
||
continue;
|
||
|
||
e.setCancelled(true);
|
||
chatFilter.incrementViolation(
|
||
p.getName());
|
||
int count = chatFilter
|
||
.getViolationCount(p.getName());
|
||
|
||
p.sendMessage(chatFilter
|
||
.msg("chat_url_blocked")
|
||
.replace("{url}", u));
|
||
p.sendMessage(chatFilter
|
||
.msg("chat_url_violation")
|
||
.replace("{count}",
|
||
String.valueOf(count)));
|
||
|
||
chatFilter.applyPunishment(p, count);
|
||
|
||
if (chatFilter.isNotifyAdmin()) {
|
||
String tag = config.adminTag;
|
||
for (Player op :
|
||
Bukkit.getOnlinePlayers()) {
|
||
if (op.getScoreboardTags()
|
||
.contains(tag)
|
||
&& !op.equals(p)) {
|
||
op.sendMessage(chatFilter
|
||
.msg("chat_url_admin_notify")
|
||
.replace("{player}",
|
||
p.getName())
|
||
.replace("{url}", u)
|
||
.replace("{count}",
|
||
String.valueOf(
|
||
count)));
|
||
}
|
||
}
|
||
}
|
||
|
||
if (chatFilter.isNotifyAll()) {
|
||
Bukkit.broadcastMessage(chatFilter
|
||
.msg("chat_url_broadcast")
|
||
.replace("{player}",
|
||
p.getName()));
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
// ===== Inventory Click =====
|
||
// ===== Inventory Click =====
|
||
@EventHandler
|
||
public void onInvClick(InventoryClickEvent e) {
|
||
if (!(e.getWhoClicked() instanceof Player))
|
||
return;
|
||
Player p = (Player) e.getWhoClicked();
|
||
if (isFrozen(p)) {
|
||
e.setCancelled(true);
|
||
return;
|
||
}
|
||
String title = e.getView().getTitle();
|
||
int slot = e.getRawSlot();
|
||
|
||
// Shift+点击背包物品 → 存入垃圾箱
|
||
if (e.isShiftClick()
|
||
&& e.getClickedInventory() != null
|
||
&& e.getClickedInventory()
|
||
!= e.getView().getTopInventory()
|
||
&& e.getCurrentItem() != null
|
||
&& e.getCurrentItem().getType()
|
||
!= Material.AIR
|
||
&& !isMenuSnowball(
|
||
e.getCurrentItem())
|
||
&& title.equals(
|
||
"§6§l垃圾回收站")) {
|
||
e.setCancelled(true);
|
||
|
||
ItemStack clicked =
|
||
e.getCurrentItem().clone();
|
||
|
||
getLogger().info(
|
||
"[垃圾站] Shift存入: "
|
||
+ clicked.getType()
|
||
+ " x" + clicked.getAmount());
|
||
|
||
// 先存入数据库
|
||
garbage.saveItem(clicked);
|
||
|
||
// 关闭背包强制同步服务器与客户端状态
|
||
// （解决Paper的shift-click取消后仍移动物品的问题）
|
||
p.closeInventory();
|
||
|
||
// 1 tick后：移除物品 + 重新打开垃圾站
|
||
Bukkit.getScheduler()
|
||
.runTaskLater(this,
|
||
() -> {
|
||
// 此时物品状态已同步
|
||
// 搜索并移除对应物品
|
||
boolean found = false;
|
||
for (int i = 0;
|
||
i < p.getInventory()
|
||
.getSize();
|
||
i++) {
|
||
ItemStack is =
|
||
p.getInventory()
|
||
.getItem(i);
|
||
if (is != null
|
||
&& is.getType()
|
||
== clicked
|
||
.getType()
|
||
&& is.getAmount()
|
||
== clicked
|
||
.getAmount()) {
|
||
p.getInventory()
|
||
.setItem(
|
||
i,
|
||
null);
|
||
found = true;
|
||
getLogger()
|
||
.info(
|
||
"[垃圾站] "
|
||
+ "移除成功: slot="
|
||
+ i);
|
||
break;
|
||
}
|
||
}
|
||
if (!found) {
|
||
getLogger()
|
||
.info(
|
||
"[垃圾站] "
|
||
+ "物品已被移走");
|
||
}
|
||
|
||
p.updateInventory();
|
||
|
||
// 重新打开垃圾站
|
||
garbage
|
||
.openRecyclePage(
|
||
p,
|
||
garbage
|
||
.getRecyclePage(
|
||
p
|
||
.getName()));
|
||
}, 2L);
|
||
return;
|
||
}
|
||
|
||
|
||
if (needsPasswordChange
|
||
.contains(p.getName())
|
||
&& !title.equals(
|
||
"§6§l任务面板")) {
|
||
e.setCancelled(true);
|
||
p.sendMessage("§c请先修改密码！");
|
||
return;
|
||
}
|
||
// 任务中心
|
||
if (title.equals(
|
||
GUIManager.T_TASK_CENTER)) {
|
||
e.setCancelled(true);
|
||
if (slot == 26) gui.openMain(p);
|
||
else if (slot == 10)
|
||
gui.openGiftStages(p);
|
||
else if (slot == 12)
|
||
gui.openTaskList(p, "主线任务");
|
||
else if (slot == 14)
|
||
gui.openTaskList(p, "支线任务");
|
||
else if (slot == 16) {
|
||
if (dailySign(p)) {
|
||
gui.openTaskCenter(p);
|
||
playSuccessSound(p);
|
||
} else
|
||
p.sendMessage(config.msg(
|
||
"checkin_already"));
|
||
}
|
||
else if (slot == 21) {
|
||
handleCheckInReport(p);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 工单GUI
|
||
if (title.equals(
|
||
TicketManager.T_TICKET_MAIN)
|
||
|| title.equals(
|
||
TicketManager.T_TICKET_CREATE)
|
||
|| title.equals(
|
||
TicketManager.T_TICKET_MY)
|
||
|| title.equals(
|
||
TicketManager.T_TICKET_ADMIN)
|
||
|| title.equals(
|
||
TicketManager.T_TICKET_DETAIL)
|
||
|| title.equals(
|
||
"§d§l服务商面板")
|
||
|| title.equals(
|
||
"§6§l抢单大厅")
|
||
|| title.equals(
|
||
"§b§l我处理中的工单")) {
|
||
e.setCancelled(true);
|
||
ticket.handleClick(
|
||
p, title, slot);
|
||
return;
|
||
}
|
||
|
||
// 垃圾回收站
|
||
if (title.equals("§6§l垃圾回收站")) {
|
||
if (slot < 0 || slot >= 54) return;
|
||
|
||
// 功能格 49-53
|
||
if (slot >= 49 && slot <= 53) {
|
||
e.setCancelled(true);
|
||
garbage.handleClick(
|
||
p, title, slot);
|
||
return;
|
||
}
|
||
|
||
ItemStack inSlot =
|
||
e.getInventory().getItem(slot);
|
||
ItemStack cursor = e.getCursor();
|
||
|
||
// ===== 取出 =====
|
||
if (inSlot != null
|
||
&& inSlot.hasItemMeta()
|
||
&& inSlot.getItemMeta().hasLore()) {
|
||
List<String> lore =
|
||
inSlot.getItemMeta().getLore();
|
||
if (lore != null && !lore.isEmpty()
|
||
&& lore.get(0)
|
||
.startsWith("§7ID: #")) {
|
||
e.setCancelled(true);
|
||
try {
|
||
String numStr = lore.get(0)
|
||
.replace("§7ID: #", "")
|
||
.trim();
|
||
int dbId =
|
||
Integer.parseInt(numStr);
|
||
if (garbage.removeItem(dbId)) {
|
||
ItemStack give =
|
||
inSlot.clone();
|
||
ItemMeta gm =
|
||
give.getItemMeta();
|
||
gm.setLore(null);
|
||
give.setItemMeta(gm);
|
||
p.getInventory()
|
||
.addItem(give);
|
||
e.getInventory()
|
||
.setItem(slot, null);
|
||
}
|
||
} catch (Exception ex) {
|
||
p.sendMessage("§c取出失败");
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
// ===== 光标存入 =====
|
||
if (cursor != null
|
||
&& cursor.getType()
|
||
!= Material.AIR
|
||
&& !isMenuSnowball(cursor)) {
|
||
ItemStack toSave = cursor.clone();
|
||
getLogger().info(
|
||
"[垃圾站] 存入: "
|
||
+ toSave.getType()
|
||
+ " x" + toSave.getAmount());
|
||
garbage.saveItem(toSave);
|
||
e.setCancelled(true);
|
||
Bukkit.getScheduler().runTaskLater(
|
||
this, () -> {
|
||
p.getOpenInventory()
|
||
.setCursor(null);
|
||
garbage.openRecyclePage(p,
|
||
garbage.getRecyclePage(
|
||
p.getName()));
|
||
}, 1L);
|
||
return;
|
||
}
|
||
|
||
// 默认取消
|
||
e.setCancelled(true);
|
||
return;
|
||
}
|
||
|
||
// 主菜单
|
||
if (title.equals(GUIManager.T_MAIN)) {
|
||
e.setCancelled(true);
|
||
if (slot == 10) gui.openMyInfo(p);
|
||
else if (slot == 12) gui.openInvite(p);
|
||
else if (slot == 14)
|
||
p.openInventory(
|
||
points.createShopGUI(p));
|
||
else if (slot == 16)
|
||
gui.openTaskCenter(p);
|
||
else if (slot == 18) ticket.openMain(p);
|
||
else if (slot == 20) {
|
||
if (p.isOp() || p.getScoreboardTags()
|
||
.contains(config.adminTag)) {
|
||
garbage.openRecycle(p);
|
||
}
|
||
}
|
||
|
||
else if (slot == 22 && isAdmin(p)) {
|
||
p.closeInventory();
|
||
chatInput.getState(p).type =
|
||
ChatInputManager.InputType
|
||
.ADMIN_AUTH;
|
||
p.sendMessage("请输入管理密码:");
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
// 我的信息
|
||
if (title.equals(GUIManager.T_MY_INFO)) {
|
||
e.setCancelled(true);
|
||
if (slot == 26) gui.openMain(p);
|
||
else if (slot == 10) {
|
||
if (checkIn.isCheckedInToday(
|
||
p.getName()))
|
||
p.sendMessage(config.msg(
|
||
"checkin_already"));
|
||
else {
|
||
p.sendMessage(
|
||
checkIn.checkIn(p));
|
||
invite.onInviteeCheckIn(
|
||
p.getName());
|
||
playSuccessSound(p);
|
||
gui.openMyInfo(p);
|
||
}
|
||
} else if (slot == 11) {
|
||
chatInput.getState(p).type =
|
||
ChatInputManager.InputType
|
||
.CHANGE_PWD_STEP1;
|
||
p.closeInventory();
|
||
p.sendMessage("§e请输入当前密码:");
|
||
} else if (slot == 12) {
|
||
chatInput.getState(p).type =
|
||
ChatInputManager.InputType
|
||
.BACK_CHECKIN;
|
||
p.closeInventory();
|
||
p.sendMessage("§e请输入补签日期:");
|
||
} else if (slot == 13) {
|
||
String code = (String) db.getField(
|
||
p.getName(), "invite_code");
|
||
if (code == null || code.isEmpty())
|
||
code = invite.generateCode(p);
|
||
p.sendMessage("§e邀请码: " + code);
|
||
} else if (slot == 14) {
|
||
chatInput.getState(p).type =
|
||
ChatInputManager.InputType
|
||
.SET_EMAIL;
|
||
p.closeInventory();
|
||
p.sendMessage("§e请输入邮箱:");
|
||
} else if (slot == 15)
|
||
p.openInventory(
|
||
points.createShopGUI(p));
|
||
return;
|
||
}
|
||
|
||
// 管理面板
|
||
if (title.equals(GUIManager.T_ADMIN)) {
|
||
e.setCancelled(true);
|
||
if (slot == 22) gui.openMain(p);
|
||
else if (slot == 10) {
|
||
chatInput.getState(p).type =
|
||
ChatInputManager.InputType
|
||
.SMTP_CONFIG;
|
||
p.closeInventory();
|
||
p.sendMessage("§e当前SMTP: "
|
||
+ config.getSmtp("smtp地址"));
|
||
p.sendMessage("§e输入新地址(0跳过):");
|
||
} else if (slot == 11)
|
||
gui.openUserManagement(p);
|
||
else if (slot == 12) gui.openMyInfo(p);
|
||
else if (slot == 14)
|
||
p.openInventory(
|
||
points.createShopGUI(p));
|
||
else if (slot == 16) {
|
||
if (e.getClick().isLeftClick()) {
|
||
config.afkEnabled =
|
||
!config.afkEnabled;
|
||
p.sendMessage(config.msg(
|
||
config.afkEnabled
|
||
? "afk_set_enabled"
|
||
: "afk_set_disabled"));
|
||
config.saveSettings();
|
||
gui.openAdmin(p);
|
||
} else if (e.getClick()
|
||
.isRightClick()) {
|
||
p.closeInventory();
|
||
chatInput.getState(p).type =
|
||
ChatInputManager.InputType
|
||
.ADMIN_SET_AFK_TIME;
|
||
p.sendMessage(
|
||
"§e输入挂机时长(分钟):");
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 任务中心
|
||
if (title.equals(
|
||
GUIManager.T_TASK_CENTER)) {
|
||
e.setCancelled(true);
|
||
if (slot == 22) gui.openMain(p);
|
||
else if (slot == 10)
|
||
gui.openGiftStages(p);
|
||
else if (slot == 12)
|
||
gui.openTaskList(p, "主线任务");
|
||
else if (slot == 14)
|
||
gui.openTaskList(p, "支线任务");
|
||
else if (slot == 16) {
|
||
if (dailySign(p)) {
|
||
gui.openTaskCenter(p);
|
||
playSuccessSound(p);
|
||
} else
|
||
p.sendMessage(config.msg(
|
||
"checkin_already"));
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 新人任务
|
||
if (title.equals(
|
||
GUIManager.T_GIFT_STAGES)) {
|
||
e.setCancelled(true);
|
||
if (slot == 53) {
|
||
gui.openTaskCenter(p);
|
||
} else if (slot == 52) {
|
||
// 打卡上报
|
||
handleCheckInReport(p);
|
||
} else if (slot == 4) {
|
||
// 进度标题
|
||
} else if (slot >= 10 && slot < 53) {
|
||
int idx = slot - 10;
|
||
QuestTracker qt = questTracker;
|
||
List<QuestTracker.QuestFile> quests =
|
||
qt.getQuests("新人任务");
|
||
if (idx < quests.size()) {
|
||
QuestTracker.QuestFile qf =
|
||
quests.get(idx);
|
||
boolean done =
|
||
qt.isStageCompleted(
|
||
p.getName(), qf);
|
||
if (done
|
||
&& !qt.hasClaimed(
|
||
p.getName(), qf)) {
|
||
qt.markClaimed(
|
||
p.getName(), qf);
|
||
qt.claimRewards(p, qf);
|
||
gui.openGiftStages(p);
|
||
} else if (done
|
||
&& qt.hasClaimed(
|
||
p.getName(), qf)) {
|
||
p.sendMessage(
|
||
"§c该阶段奖励已领取");
|
||
} else {
|
||
p.sendMessage(
|
||
"§c该阶段尚未完成");
|
||
}
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
// 邀请
|
||
if (title.equals(GUIManager.T_INVITE)) {
|
||
e.setCancelled(true);
|
||
if (slot == 26) gui.openMain(p);
|
||
else if (slot == 10) {
|
||
String code =
|
||
invite.generateCode(p);
|
||
p.sendMessage("§e邀请码: " + code);
|
||
gui.openInvite(p);
|
||
} else if (slot == 16) {
|
||
chatInput.getState(p).type =
|
||
ChatInputManager.InputType
|
||
.INVITE_INPUT_CODE;
|
||
p.closeInventory();
|
||
p.sendMessage("§e请输入邀请码:");
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
// 用户管理
|
||
if (title.equals(
|
||
GUIManager.T_USER_MGMT)) {
|
||
e.setCancelled(true);
|
||
if (slot == 53)
|
||
gui.openAdmin(p);
|
||
else if (slot >= 0 && slot < 45) {
|
||
ItemStack item =
|
||
e.getInventory().getItem(slot);
|
||
if (item != null
|
||
&& item.hasItemMeta()
|
||
&& item.getItemMeta()
|
||
.hasDisplayName())
|
||
gui.openUserDetail(p,
|
||
item.getItemMeta()
|
||
.getDisplayName()
|
||
.replace("§e", "")
|
||
.replace("§a", ""));
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
// 用户详情
|
||
if (title.startsWith("§e§l管理: ")) {
|
||
e.setCancelled(true);
|
||
String tgt = title.substring(
|
||
"§e§l管理: ".length());
|
||
if (slot == 22)
|
||
gui.openUserManagement(p);
|
||
else if (slot == 10) {
|
||
chatInput.getState(p).type =
|
||
ChatInputManager.InputType
|
||
.ADMIN_SET_POINTS;
|
||
chatInput.getState(p)
|
||
.targetPlayer = tgt;
|
||
p.closeInventory();
|
||
p.sendMessage("§e输入" + tgt
|
||
+ "的新积分:");
|
||
} else if (slot == 12) {
|
||
chatInput.getState(p).type =
|
||
ChatInputManager.InputType
|
||
.ADMIN_SET_PWD;
|
||
chatInput.getState(p)
|
||
.targetPlayer = tgt;
|
||
p.closeInventory();
|
||
p.sendMessage("§e输入" + tgt
|
||
+ "的临时密码:");
|
||
} else if (slot == 13) {
|
||
gui.openCheckInRecords(p, tgt);
|
||
} else if (slot == 14) {
|
||
Player tp = Bukkit.getPlayer(tgt);
|
||
if (tp != null && tp.isOnline()) {
|
||
forceGiveMenuSnowball(tp);
|
||
p.sendMessage("§a已发放雪球菜单给 "
|
||
+ tgt);
|
||
} else {
|
||
p.sendMessage("§c玩家不在线");
|
||
}
|
||
} else if (slot == 16) {
|
||
|
||
} else if (slot == 16) {
|
||
chatInput.getState(p).type =
|
||
ChatInputManager.InputType
|
||
.ADMIN_DELETE_CONFIRM;
|
||
chatInput.getState(p)
|
||
.targetPlayer = tgt;
|
||
p.closeInventory();
|
||
p.sendMessage(config.msg(
|
||
"admin_delete_confirm"));
|
||
}
|
||
|
||
return;
|
||
|
||
}
|
||
|
||
|
||
// 积分商城
|
||
if (title.startsWith("§d§l积分商城")) {
|
||
e.setCancelled(true);
|
||
if (slot == 49) gui.openMain(p);
|
||
else if (slot == 50 && isAdmin(p)) {
|
||
gui.openShopAdmin(p);
|
||
} else
|
||
points.handleClick(p, slot);
|
||
return;
|
||
}
|
||
|
||
// 商城管理
|
||
if (title.equals("§c§l商城管理")) {
|
||
e.setCancelled(true);
|
||
if (slot == 49) {
|
||
p.openInventory(
|
||
points.createShopGUI(p));
|
||
return;
|
||
}
|
||
return;
|
||
}
|
||
|
||
// CY背包商城
|
||
if (title.startsWith("§d§lCY背包商城")) {
|
||
e.setCancelled(true);
|
||
int size = e.getInventory().getSize();
|
||
if (slot == size - 1)
|
||
p.openInventory(
|
||
points.createShopGUI(p));
|
||
else points.handleCYClick(p, slot);
|
||
return;
|
||
}
|
||
|
||
// 账号请求面板
|
||
if (title.equals("§e§l账号请求")) {
|
||
e.setCancelled(true);
|
||
if (slot == 22) gui.openMain(p);
|
||
else if (slot == 10) {
|
||
p.closeInventory();
|
||
p.sendMessage("§c§l[确认] §f请输入:");
|
||
p.sendMessage("§e/sdf1_login del "
|
||
+ p.getName());
|
||
} else if (slot == 13) {
|
||
ticket.openCreate(p);
|
||
} else if (slot == 16) {
|
||
p.closeInventory();
|
||
loginMgr.handleReset(p);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 主线/支线任务
|
||
if (title.equals("§d§l主线任务")
|
||
|| title.equals("§d§l支线任务")) {
|
||
e.setCancelled(true);
|
||
if (slot == e.getInventory().getSize() - 1)
|
||
gui.openTaskCenter(p);
|
||
return;
|
||
}
|
||
}
|
||
/**
|
||
* 打卡上报：验证当前阶段条件
|
||
*/
|
||
|
||
private void handleCheckInReport(Player p) {
|
||
QuestTracker qt = questTracker;
|
||
if (qt == null) {
|
||
p.sendMessage("§c任务系统未加载");
|
||
return;
|
||
}
|
||
|
||
p.sendMessage("§e§l[打卡] §f正在检测环境...");
|
||
|
||
// === 检测当前群系 ===
|
||
Location loc = p.getLocation();
|
||
String biomeKey = loc.getBlock()
|
||
.getBiome().getKey().getKey();
|
||
String worldName = loc.getWorld().getName();
|
||
|
||
List<String> biomeMatched =
|
||
qt.checkInBiome(
|
||
p.getName(),
|
||
biomeKey, worldName,
|
||
loc.getX(), loc.getY(),
|
||
loc.getZ());
|
||
|
||
qt.recordCheckIn(
|
||
p.getName(), biomeKey,
|
||
qt.mapBiomeCategory(
|
||
biomeKey, worldName),
|
||
worldName,
|
||
loc.getX(), loc.getY(),
|
||
loc.getZ());
|
||
|
||
p.sendMessage("§7 群系: §e"
|
||
+ biomeKey);
|
||
p.sendMessage("§7 分类: §e"
|
||
+ qt.mapBiomeCategory(
|
||
biomeKey, worldName));
|
||
p.sendMessage("§7 世界: §e"
|
||
+ worldName);
|
||
p.sendMessage("§7 坐标: §e"
|
||
+ String.format("%.0f, %.0f, %.0f",
|
||
loc.getX(), loc.getY(),
|
||
loc.getZ()));
|
||
|
||
if (!biomeMatched.isEmpty()) {
|
||
for (String m : biomeMatched) {
|
||
p.sendMessage("§7 §a✓ " + m);
|
||
}
|
||
}
|
||
|
||
// === 检测附近村庄（50格内有村民） ===
|
||
boolean nearVillage = false;
|
||
for (Entity entity
|
||
: p.getNearbyEntities(50, 50, 50)) {
|
||
if (entity instanceof Villager) {
|
||
nearVillage = true;
|
||
break;
|
||
}
|
||
}
|
||
if (nearVillage) {
|
||
boolean counted =
|
||
qt.onReportVillage(
|
||
p.getName(),
|
||
worldName,
|
||
loc.getX(),
|
||
loc.getY(),
|
||
loc.getZ());
|
||
if (counted) {
|
||
p.sendMessage(
|
||
"§7 §a村庄上报计数成功！");
|
||
} else {
|
||
p.sendMessage(
|
||
"§7 §e村庄32格内已上报过");
|
||
}
|
||
}
|
||
|
||
|
||
// === 验证所有未完成的任务 ===
|
||
p.sendMessage("");
|
||
p.sendMessage("§e§l[打卡] §f正在验证"
|
||
+ "未完成的任务...");
|
||
|
||
List<String> categories =
|
||
Arrays.asList(
|
||
"新人任务",
|
||
"主线任务",
|
||
"支线任务");
|
||
|
||
int totalMet = 0;
|
||
int totalChecked = 0;
|
||
int finishedCount = 0;
|
||
|
||
for (String cat : categories) {
|
||
List<QuestTracker.QuestFile> quests =
|
||
qt.getQuests(cat);
|
||
for (QuestTracker.QuestFile qf
|
||
: quests) {
|
||
if (qt.isStageCompleted(
|
||
p.getName(), qf)) {
|
||
finishedCount++;
|
||
continue;
|
||
}
|
||
if (!qf.hasConditions())
|
||
continue;
|
||
|
||
p.sendMessage("§e§l["
|
||
+ qf.displayName + "]");
|
||
|
||
for (String cond
|
||
: qf.conditions) {
|
||
if (qt.isOptional(cond))
|
||
continue;
|
||
totalChecked++;
|
||
|
||
boolean met =
|
||
qt.isConditionMet(
|
||
p.getName(),
|
||
cond);
|
||
|
||
if (met) {
|
||
totalMet++;
|
||
p.sendMessage("§7 §a✓ "
|
||
+ qt.getProgress(
|
||
p.getName(),
|
||
cond));
|
||
} else {
|
||
p.sendMessage("§7 §c✗ "
|
||
+ qt.getProgress(
|
||
p.getName(),
|
||
cond));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
p.sendMessage("");
|
||
if (finishedCount > 0) {
|
||
p.sendMessage("§7已跳过 "
|
||
+ finishedCount
|
||
+ " 个已完成的阶段");
|
||
}
|
||
if (totalChecked == 0) {
|
||
p.sendMessage(
|
||
"§a§l[打卡] §f没有"
|
||
+ "未完成的条件");
|
||
} else if (totalMet >= totalChecked) {
|
||
p.sendMessage(
|
||
"§a§l[打卡] §f全部通过！("
|
||
+ totalMet + "/"
|
||
+ totalChecked + ")");
|
||
playSuccessSound(p);
|
||
} else {
|
||
p.sendMessage(
|
||
"§c§l[打卡] §f未通过 ("
|
||
+ totalMet + "/"
|
||
+ totalChecked
|
||
+ ") §c请继续完成");
|
||
}
|
||
|
||
gui.openTaskCenter(p);
|
||
}
|
||
|
||
|
||
|
||
@EventHandler
|
||
public void onInvDrag(InventoryDragEvent e) {
|
||
if (!(e.getWhoClicked() instanceof Player))
|
||
return;
|
||
Player p = (Player) e.getWhoClicked();
|
||
if (isFrozen(p)) {
|
||
frozenFlightPlayers.add(p.getName());
|
||
e.setCancelled(true);
|
||
return;
|
||
}
|
||
String t = e.getView().getTitle();
|
||
|
||
// 回收站拖拽
|
||
if (t.equals("§6§l垃圾回收站")) {
|
||
for (int rawSlot :
|
||
e.getRawSlots()) {
|
||
if (rawSlot >= 49) {
|
||
e.setCancelled(true);
|
||
return;
|
||
}
|
||
}
|
||
// 0-48允许拖入，不取消
|
||
// 延迟2tick后扫描格子
|
||
final Player fp = p;
|
||
Bukkit.getScheduler()
|
||
.runTaskLater(this,
|
||
() -> {
|
||
Inventory top = fp
|
||
.getOpenInventory()
|
||
.getTopInventory();
|
||
for (int rawSlot :
|
||
e.getRawSlots()) {
|
||
if (rawSlot < 0
|
||
|| rawSlot >= 49)
|
||
continue;
|
||
ItemStack item =
|
||
top.getItem(rawSlot);
|
||
if (item != null
|
||
&& item.getType()
|
||
!= Material.AIR
|
||
&& !isMenuSnowball(
|
||
item)) {
|
||
garbage.saveItem(
|
||
item.clone());
|
||
top.setItem(
|
||
rawSlot, null);
|
||
}
|
||
}
|
||
}, 2L);
|
||
return;
|
||
}
|
||
|
||
//服务商工单系统
|
||
if (t.equals(TicketManager.T_TICKET_MAIN)
|
||
|| t.equals(
|
||
TicketManager.T_TICKET_CREATE)
|
||
|| t.equals(
|
||
TicketManager.T_TICKET_MY)
|
||
|| t.equals(
|
||
TicketManager.T_TICKET_ADMIN)
|
||
|| t.equals(
|
||
TicketManager.T_TICKET_DETAIL)
|
||
|| t.equals("§d§l服务商面板")
|
||
|| t.equals("§6§l抢单大厅")
|
||
|| t.equals(
|
||
"§b§l我处理中的工单")
|
||
|| t.equals("§6§l我的历史工单")
|
||
|| t.equals("§c§l商城管理")) {
|
||
e.setCancelled(true);
|
||
}
|
||
}
|
||
|
||
// ===== Commands =====
|
||
@Override
|
||
public boolean onCommand(CommandSender sender,
|
||
Command cmd, String label,
|
||
String[] args) {
|
||
|
||
String cmdName = cmd.getName().toLowerCase();
|
||
|
||
if (cmdName.equals("recycle")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
Player pr = (Player) sender;
|
||
if (!pr.isOp()
|
||
&& !pr.getScoreboardTags()
|
||
.contains(config.adminTag)) {
|
||
pr.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
garbage.openRecycle(pr);
|
||
return true;
|
||
}
|
||
|
||
if (cmd.getName().equalsIgnoreCase("radio")) {
|
||
getLogger().info(
|
||
"[Radio] 收到命令: "
|
||
+ Arrays.toString(args));
|
||
|
||
// 统一交给 RadioManager 处理
|
||
radio.handleCommand(sender, args);
|
||
return true;
|
||
}
|
||
|
||
|
||
// /垃圾清理
|
||
if (cmdName.equals("垃圾清理")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
int count = garbage.collectItems();
|
||
sender.sendMessage("§a已清理 "
|
||
+ count + " 个掉落物");
|
||
return true;
|
||
}
|
||
// /menu 开关雪球菜单
|
||
if (cmdName.equals("menu")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage(
|
||
"§c仅玩家可用");
|
||
return true;
|
||
}
|
||
Player p2 = (Player) sender;
|
||
if (args.length == 0) {
|
||
p2.sendMessage(
|
||
"§e用法: /menu <开/关>");
|
||
return true;
|
||
}
|
||
String arg = args[0];
|
||
if (arg.equals("开")) {
|
||
db.setField(p2.getName(),
|
||
"menu_snowball", 1);
|
||
p2.sendMessage(
|
||
"§a雪球菜单已开启，"
|
||
+ "下次进入将发放");
|
||
} else if (arg.equals("关")) {
|
||
db.setField(p2.getName(),
|
||
"menu_snowball", 0);
|
||
p2.sendMessage(
|
||
"§c雪球菜单已关闭，"
|
||
+ "下次进入不再发放");
|
||
} else {
|
||
p2.sendMessage(
|
||
"§e用法: /menu <开/关>");
|
||
}
|
||
return true;
|
||
}
|
||
// /reg
|
||
if (cmdName.equals("reg")
|
||
|| cmdName.equals("注册")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
Player p = (Player) sender;
|
||
chatInput.reset(p);
|
||
if (db.userExists(p.getName())) {
|
||
p.sendMessage(
|
||
"§c您已注册过，请使用 /login");
|
||
return true;
|
||
}
|
||
try {
|
||
loginMgr.handleRegister(p, args);
|
||
} catch (Exception e) {
|
||
getLogger().severe(
|
||
"[Sdf1_login] reg命令异常: "
|
||
+ e.getMessage());
|
||
e.printStackTrace();
|
||
p.sendMessage("§c注册出错，请联系管理员");
|
||
}
|
||
// 注册/登录成功后统一处理
|
||
if (loggedIn.contains(p.getName())) {
|
||
frozenFlightPlayers.remove(p.getName());
|
||
p.setAllowFlight(false);
|
||
p.setFlying(false);
|
||
// 仅关闭冻结期间的飞行
|
||
if (frozenFlightPlayers.remove(
|
||
p.getName())) {
|
||
p.setAllowFlight(false);
|
||
p.setFlying(false);
|
||
removeFlightOnce.add(p.getName());
|
||
if (questTracker != null) {
|
||
questTracker.markConditionComplete(
|
||
p.getName(),
|
||
"完成注册登录");
|
||
}
|
||
this.getWelcome().onLogin(p);
|
||
restoreInventory(p);
|
||
giveMenuSnowball(p);
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
|
||
if (cmdName.equals("login")
|
||
|| cmdName.equals("l")
|
||
|| cmdName.equals("登录")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
Player p = (Player) sender;
|
||
chatInput.reset(p);
|
||
if (loggedIn.contains(p.getName())) {
|
||
frozenFlightPlayers.remove(p.getName());
|
||
p.setAllowFlight(false);
|
||
p.setFlying(false);
|
||
removeFlightOnce.add(p.getName());
|
||
p.sendMessage("§c您已登录");
|
||
return true;
|
||
}
|
||
try {
|
||
loginMgr.handleLogin(p, args);
|
||
} catch (Exception e) {
|
||
getLogger().severe(
|
||
"[Sdf1_login] login命令异常: "
|
||
+ e.getMessage());
|
||
e.printStackTrace();
|
||
p.sendMessage("§c登录出错，请联系管理员");
|
||
}
|
||
// 登录成功后统一处理
|
||
if (loggedIn.contains(p.getName())) {
|
||
if (questTracker != null) {
|
||
questTracker.markConditionComplete(
|
||
p.getName(),
|
||
"完成注册登录");
|
||
}
|
||
this.getWelcome().onLogin(p);
|
||
restoreInventory(p);
|
||
giveMenuSnowball(p);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// /找回密码
|
||
if (cmdName.equals("找回密码")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
handleReset((Player) sender);
|
||
return true;
|
||
}
|
||
|
||
// /签到
|
||
if (cmdName.equals("签到")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
if (dailySign((Player) sender))
|
||
playSuccessSound((Player) sender);
|
||
else
|
||
((Player) sender).sendMessage(
|
||
config.msg("checkin_already"));
|
||
return true;
|
||
}
|
||
|
||
// 绑定邮箱
|
||
if (cmdName.equals("绑定邮箱")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
Player p2 = (Player) sender;
|
||
if (args.length >= 1) {
|
||
String emailAddr = args[0];
|
||
if (!emailAddr.contains("@")
|
||
|| !emailAddr.contains(".")) {
|
||
p2.sendMessage("§c邮箱格式不正确");
|
||
return true;
|
||
}
|
||
String oldEmail = (String) db.getField(
|
||
p2.getName(), "email");
|
||
if (oldEmail != null
|
||
&& !oldEmail.isEmpty()) {
|
||
chatInput.getState(p2).type =
|
||
ChatInputManager.InputType
|
||
.SET_EMAIL_VERIFY;
|
||
chatInput.getState(p2)
|
||
.targetPlayer = emailAddr;
|
||
chatInput.getState(p2)
|
||
.ticketTitle = "need_pwd";
|
||
p2.sendMessage("§e您已绑定邮箱: "
|
||
+ oldEmail);
|
||
p2.sendMessage(
|
||
"§e请输入登录密码以确认修改:");
|
||
} else {
|
||
String code = String.valueOf(
|
||
(int) (Math.random()
|
||
* 900000 + 100000));
|
||
chatInput.getState(p2).type =
|
||
ChatInputManager.InputType
|
||
.SET_EMAIL_VERIFY;
|
||
chatInput.getState(p2)
|
||
.targetPlayer = emailAddr;
|
||
chatInput.getState(p2)
|
||
.ticketTitle = code;
|
||
final String to = emailAddr;
|
||
final String c = code;
|
||
final Player fp = p2;
|
||
Bukkit.getScheduler()
|
||
.runTaskAsynchronously(this,
|
||
() -> {
|
||
boolean sent = email
|
||
.sendVerifyCode(to, c);
|
||
Bukkit.getScheduler().runTask(
|
||
this, () -> {
|
||
if (sent) {
|
||
fp.sendMessage(
|
||
"§a验证码已发送到 "
|
||
+ to);
|
||
fp.sendMessage(
|
||
"§e输入6位验证码(0取消):");
|
||
} else {
|
||
fp.sendMessage(
|
||
"§c发送失败");
|
||
}
|
||
});
|
||
});
|
||
}
|
||
} else {
|
||
chatInput.getState(p2).type =
|
||
ChatInputManager.InputType
|
||
.SET_EMAIL;
|
||
p2.sendMessage("§e请输入邮箱:");
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
// /sdf1debug
|
||
if (cmdName.equals("sdf1debug")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
Player p2 = (Player) sender;
|
||
if (!isAdmin(sender)) {
|
||
p2.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
if (args.length < 2) {
|
||
p2.sendMessage("§e用法: /sdf1debug <玩家> <阶段>");
|
||
return true;
|
||
}
|
||
String tgt = args[0];
|
||
try {
|
||
int stage = Integer.parseInt(args[1]);
|
||
db.setField(tgt, "gift_stage", stage);
|
||
p2.sendMessage("§a已将 " + tgt
|
||
+ " 的任务阶段设为 " + stage);
|
||
} catch (NumberFormatException ex) {
|
||
p2.sendMessage("§c请输入有效数字");
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// /oa
|
||
if (cmdName.equals("oa")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
openAccountRequestPanel(
|
||
(Player) sender);
|
||
return true;
|
||
}
|
||
|
||
// /玩家信息
|
||
if (cmdName.equals("玩家信息")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
gui.openMain((Player) sender);
|
||
return true;
|
||
}
|
||
|
||
// ===== /sdf1_login =====
|
||
if (!cmdName.equals("sdf1_login"))
|
||
return false;
|
||
|
||
if (args.length == 0) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login <子命令>");
|
||
return true;
|
||
}
|
||
gui.openMain((Player) sender);
|
||
return true;
|
||
}
|
||
|
||
String sub = args[0].toLowerCase();
|
||
// update - 检查更新（控制台+玩家均可）
|
||
if (sub.equals("update")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
sender.sendMessage("§e[更新] 正在检测...");
|
||
Bukkit.getScheduler()
|
||
.runTaskAsynchronously(this,
|
||
() -> updateChecker
|
||
.checkUpdate(sender));
|
||
return true;
|
||
}
|
||
|
||
// stop
|
||
if (sub.equals("stop")) {
|
||
if (!(sender instanceof Player)) {
|
||
// 控制台
|
||
if (args.length >= 2) {
|
||
db.clearTempPassword(args[1]);
|
||
sender.sendMessage("§a已报废 "
|
||
+ args[1] + " 的临时密码");
|
||
} else {
|
||
db.clearAllTempPasswords();
|
||
sender.sendMessage(
|
||
"§a已报废所有临时密码");
|
||
}
|
||
return true;
|
||
}
|
||
Player p2 = (Player) sender;
|
||
if (args.length >= 2) {
|
||
String tgt = args[1];
|
||
String myIP =
|
||
getPlayerIP(p2);
|
||
String targetIP =
|
||
db.getPlayerIPByName(tgt);
|
||
if (targetIP == null) {
|
||
Player tp =
|
||
Bukkit.getPlayer(tgt);
|
||
if (tp != null && tp.isOnline())
|
||
targetIP =
|
||
getPlayerIP(tp);
|
||
}
|
||
if (targetIP == null
|
||
|| !targetIP.equals(myIP)) {
|
||
p2.sendMessage(
|
||
"§c只能操作同IP下的玩家");
|
||
return true;
|
||
}
|
||
db.clearTempPassword(tgt);
|
||
p2.sendMessage("§a已报废 " + tgt
|
||
+ " 的临时密码");
|
||
} else {
|
||
db.clearTempPassword(p2.getName());
|
||
p2.sendMessage(
|
||
"§a已报废您的临时密码");
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// reload
|
||
if (sub.equals("reload")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
config.loadMessages();
|
||
config.loadSmtp();
|
||
config.loadSettings();
|
||
chatFilter.loadConfig();
|
||
sender.sendMessage("§a配置已重载！");
|
||
return true;
|
||
}
|
||
// back - 恢复背包备份
|
||
if (sub.equals("back")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
if (args.length < 2) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login back <玩家> [#编号]");
|
||
return true;
|
||
}
|
||
String backTarget = args[1];
|
||
if (args.length >= 3
|
||
&& args[2].startsWith("#")) {
|
||
// /sdf1_login back Aplayer #1
|
||
int backupId;
|
||
try {
|
||
backupId = Integer.parseInt(
|
||
args[2].replace("#", ""));
|
||
} catch (NumberFormatException ex) {
|
||
sender.sendMessage(
|
||
"§c无效编号");
|
||
return true;
|
||
}
|
||
String[] backup =
|
||
db.getInventoryBackupById(
|
||
backupId);
|
||
if (backup == null) {
|
||
sender.sendMessage(
|
||
"§c备份 #" + backupId
|
||
+ " 不存在");
|
||
return true;
|
||
}
|
||
// 如果玩家在线，直接恢复
|
||
Player tp = Bukkit.getPlayer(
|
||
backTarget);
|
||
if (tp != null && tp.isOnline()) {
|
||
try {
|
||
tp.getInventory()
|
||
.setContents(
|
||
InventorySerializer
|
||
.fromBase64(
|
||
backup[0]));
|
||
if (backup[1] != null
|
||
&& !backup[1]
|
||
.isEmpty())
|
||
tp.getInventory()
|
||
.setArmorContents(
|
||
InventorySerializer
|
||
.fromBase64(
|
||
backup[1]));
|
||
if (backup[2] != null
|
||
&& !backup[2]
|
||
.isEmpty())
|
||
tp.getInventory()
|
||
.setExtraContents(
|
||
InventorySerializer
|
||
.fromBase64(
|
||
backup[2]));
|
||
int lv = Integer.parseInt(
|
||
backup[3]);
|
||
if (lv > 0)
|
||
tp.setLevel(lv);
|
||
tp.sendMessage(
|
||
"§a管理员已恢复您的背包");
|
||
sender.sendMessage(
|
||
"§a已恢复 " + backTarget
|
||
+ " 的背包 (备份#"
|
||
+ backupId + ")");
|
||
} catch (Exception e) {
|
||
sender.sendMessage(
|
||
"§c恢复失败: "
|
||
+ e.getMessage());
|
||
}
|
||
} else {
|
||
// 玩家离线：保存到数据库供下次登录恢复
|
||
db.saveInventoryBackup(
|
||
backTarget,
|
||
backup[0],
|
||
backup[1],
|
||
backup[2],
|
||
Integer.parseInt(
|
||
backup[3]),
|
||
Double.parseDouble(
|
||
backup[4]));
|
||
sender.sendMessage(
|
||
"§a" + backTarget
|
||
+ " 离线，备份已写入数据库，"
|
||
+ "下次登录时恢复");
|
||
}
|
||
} else {
|
||
// /sdf1_login back Aplayer
|
||
// 罗列最近5条备份
|
||
List<Map<String, Object>> backups =
|
||
db.getInventoryBackups(
|
||
backTarget, 5);
|
||
if (backups.isEmpty()) {
|
||
sender.sendMessage(
|
||
"§c" + backTarget
|
||
+ " 没有背包备份");
|
||
return true;
|
||
}
|
||
sender.sendMessage(
|
||
"§e§l=== " + backTarget
|
||
+ " 背包备份 ===");
|
||
java.text.SimpleDateFormat sdf =
|
||
new java.text.SimpleDateFormat(
|
||
"MM-dd HH:mm:ss");
|
||
for (Map<String, Object> b :
|
||
backups) {
|
||
int bid = ((Number)
|
||
b.get("id"))
|
||
.intValue();
|
||
Object stObj =
|
||
b.get("save_time");
|
||
long st = stObj != null
|
||
? ((Number) stObj)
|
||
.longValue() : 0;
|
||
String time = st > 0
|
||
? sdf.format(
|
||
new java.util.Date(st))
|
||
: "未知时间";
|
||
String itemNames =
|
||
getBackupItemPreview(
|
||
bid);
|
||
sender.sendMessage(
|
||
"§7#" + bid
|
||
+ " §f" + time
|
||
+ " §7: "
|
||
+ itemNames);
|
||
}
|
||
sender.sendMessage(
|
||
"§7使用 §e/sdf1_login back "
|
||
+ backTarget
|
||
+ " #编号 §7恢复");
|
||
sender.sendMessage(
|
||
"§e§l================================");
|
||
}
|
||
}
|
||
|
||
// pw / password
|
||
if (sub.equals("pw")
|
||
|| sub.equals("password")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
Player p2 = (Player) sender;
|
||
|
||
if (args.length >= 3) {
|
||
// /sdf1_login pw 旧密码 新密码
|
||
String oldPwd = args[1];
|
||
String newPwd = args[2];
|
||
if (!PasswordUtils.validate(
|
||
newPwd)) {
|
||
p2.sendMessage(config.msg(
|
||
"password_format_error"));
|
||
return true;
|
||
}
|
||
String salt = (String) db.getField(
|
||
p2.getName(),
|
||
"password_salt");
|
||
String hash =
|
||
PasswordUtils.hash(
|
||
oldPwd, salt);
|
||
boolean mainOk =
|
||
db.checkPassword(
|
||
p2.getName(), hash);
|
||
boolean tempOk =
|
||
db.checkPasswordOrTemp(
|
||
p2.getName(), hash);
|
||
if (!mainOk && !tempOk) {
|
||
p2.sendMessage(config.msg(
|
||
"password_wrong"));
|
||
return true;
|
||
}
|
||
String oldHash =
|
||
(String) db.getField(
|
||
p2.getName(),
|
||
"password_hash");
|
||
String newSalt =
|
||
PasswordUtils.generateSalt();
|
||
String newHash =
|
||
PasswordUtils.hash(
|
||
newPwd, newSalt);
|
||
if (newHash.equals(oldHash)) {
|
||
p2.sendMessage(config.msg(
|
||
"password_same"));
|
||
return true;
|
||
}
|
||
recordPasswordChange(
|
||
p2.getName(),
|
||
oldHash, salt);
|
||
db.setField(p2.getName(),
|
||
"password_hash", newHash);
|
||
db.setField(p2.getName(),
|
||
"password_salt", newSalt);
|
||
if (!mainOk && tempOk) {
|
||
db.clearTempPassword(
|
||
p2.getName());
|
||
}
|
||
frozenFlightPlayers.remove(p2.getName());
|
||
p2.setAllowFlight(false);
|
||
p2.setFlying(false);
|
||
needsPasswordChange.remove(
|
||
p2.getName());
|
||
p2.sendMessage(config.msg(
|
||
"password_changed"));
|
||
return true;
|
||
}
|
||
|
||
if (args.length == 2) {
|
||
// /sdf1_login pw 旧密码
|
||
// 验证旧密码，然后聊天输入新密码
|
||
String oldPwd = args[1];
|
||
String salt = (String) db.getField(
|
||
p2.getName(),
|
||
"password_salt");
|
||
String hash =
|
||
PasswordUtils.hash(
|
||
oldPwd, salt);
|
||
boolean mainOk =
|
||
db.checkPassword(
|
||
p2.getName(), hash);
|
||
boolean tempOk =
|
||
db.checkPasswordOrTemp(
|
||
p2.getName(), hash);
|
||
if (!mainOk && !tempOk) {
|
||
p2.sendMessage(config.msg(
|
||
"password_wrong"));
|
||
return true;
|
||
}
|
||
chatInput.getState(p2).type =
|
||
ChatInputManager.InputType
|
||
.CHANGE_PWD_STEP2;
|
||
chatInput.getState(p2)
|
||
.ticketTitle =
|
||
mainOk ? "main" : "temp";
|
||
p2.sendMessage(
|
||
"§e请输入新密码:");
|
||
return true;
|
||
}
|
||
|
||
// /sdf1_login pw (无参数)
|
||
chatInput.getState(p2).type =
|
||
ChatInputManager.InputType
|
||
.CHANGE_PWD_STEP1;
|
||
p2.sendMessage(
|
||
"§e请输入当前密码:");
|
||
return true;
|
||
}
|
||
|
||
// email
|
||
if (sub.equals("email")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
Player p2 = (Player) sender;
|
||
if (args.length >= 2) {
|
||
String emailAddr = args[1];
|
||
if (!emailAddr.contains("@")
|
||
|| !emailAddr.contains(".")) {
|
||
p2.sendMessage("§c邮箱格式不正确");
|
||
return true;
|
||
}
|
||
String oldEmail = (String) db.getField(
|
||
p2.getName(), "email");
|
||
if (oldEmail != null
|
||
&& !oldEmail.isEmpty()) {
|
||
// 已绑定：先验证密码
|
||
chatInput.getState(p2).type =
|
||
ChatInputManager.InputType
|
||
.SET_EMAIL_VERIFY;
|
||
chatInput.getState(p2)
|
||
.targetPlayer = emailAddr;
|
||
chatInput.getState(p2)
|
||
.ticketTitle = "need_pwd";
|
||
p2.sendMessage("§e您已绑定邮箱: "
|
||
+ oldEmail);
|
||
p2.sendMessage(
|
||
"§e请输入登录密码以确认修改:");
|
||
} else {
|
||
// 未绑定：直接发验证码
|
||
String code = String.valueOf(
|
||
(int) (Math.random()
|
||
* 900000 + 100000));
|
||
chatInput.getState(p2).type =
|
||
ChatInputManager.InputType
|
||
.SET_EMAIL_VERIFY;
|
||
chatInput.getState(p2)
|
||
.targetPlayer = emailAddr;
|
||
chatInput.getState(p2)
|
||
.ticketTitle = code;
|
||
final String to = emailAddr;
|
||
final String c = code;
|
||
final Player fp = p2;
|
||
Bukkit.getScheduler()
|
||
.runTaskAsynchronously(this,
|
||
() -> {
|
||
boolean sent = email
|
||
.sendVerifyCode(to, c);
|
||
Bukkit.getScheduler().runTask(
|
||
this, () -> {
|
||
if (sent) {
|
||
fp.sendMessage(
|
||
"§a验证码已发送到 "
|
||
+ to);
|
||
fp.sendMessage(
|
||
"§e输入6位验证码(0取消):");
|
||
} else {
|
||
fp.sendMessage(
|
||
"§c发送失败");
|
||
}
|
||
});
|
||
});
|
||
}
|
||
} else {
|
||
chatInput.getState(p2).type =
|
||
ChatInputManager.InputType
|
||
.SET_EMAIL;
|
||
p2.sendMessage("§e请输入邮箱:");
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
// sign
|
||
if (sub.equals("sign")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
if (dailySign((Player) sender))
|
||
playSuccessSound((Player) sender);
|
||
else
|
||
((Player) sender).sendMessage(
|
||
config.msg("checkin_already"));
|
||
return true;
|
||
}
|
||
|
||
// reset
|
||
if (sub.equals("reset")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
loginMgr.handleReset(
|
||
(Player) sender);
|
||
return true;
|
||
}
|
||
|
||
// undo
|
||
if (sub.equals("undo")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
Player p2 = (Player) sender;
|
||
PwdRollback rb =
|
||
pwdRollback.get(p2.getName());
|
||
if (rb == null) {
|
||
p2.sendMessage("§c无可撤销记录");
|
||
return true;
|
||
}
|
||
if (System.currentTimeMillis() - rb.time
|
||
> 600000L) {
|
||
pwdRollback.remove(p2.getName());
|
||
p2.sendMessage("§c撤销已过期");
|
||
return true;
|
||
}
|
||
db.setField(p2.getName(),
|
||
"password_hash", rb.hash);
|
||
db.setField(p2.getName(),
|
||
"password_salt", rb.salt);
|
||
pwdRollback.remove(p2.getName());
|
||
p2.sendMessage("§a密码已撤销！");
|
||
return true;
|
||
}
|
||
|
||
// take
|
||
if (sub.equals("take")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
if (args.length < 3) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login take <玩家> <积分>");
|
||
return true;
|
||
}
|
||
int amount;
|
||
try {
|
||
amount = Integer.parseInt(args[2]);
|
||
} catch (NumberFormatException ex) {
|
||
sender.sendMessage("§c无效数字");
|
||
return true;
|
||
}
|
||
if (!db.deductPoints(args[1], amount)) {
|
||
sender.sendMessage("§c积分不足");
|
||
return true;
|
||
}
|
||
sender.sendMessage("§a已扣除 " + args[1]
|
||
+ " " + amount + " 积分");
|
||
return true;
|
||
}
|
||
|
||
// set
|
||
if (sub.equals("set")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
if (args.length < 3) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login set <玩家> <临时密码>");
|
||
return true;
|
||
}
|
||
String tgt = args[1];
|
||
String tempPwd = args[2];
|
||
if (!PasswordUtils.validate(tempPwd)) {
|
||
sender.sendMessage("§c密码格式不符合要求");
|
||
return true;
|
||
}
|
||
if (!db.userExists(tgt)) {
|
||
sender.sendMessage("§c玩家不存在");
|
||
return true;
|
||
}
|
||
String salt = (String) db.getField(
|
||
tgt, "password_salt");
|
||
String hash = PasswordUtils.hash(
|
||
tempPwd, salt);
|
||
db.setField(tgt, "temp_password", hash);
|
||
db.setField(tgt, "temp_pw_expire",
|
||
System.currentTimeMillis()
|
||
+ 300000L);
|
||
|
||
db.setField(tgt, "temp_pw_used", 0);
|
||
sender.sendMessage("§a已为 " + tgt
|
||
+ " 设置临时密码");
|
||
Player tp = Bukkit.getPlayer(tgt);
|
||
if (tp != null && tp.isOnline())
|
||
tp.kickPlayer(
|
||
"§c管理员已设置临时密码");
|
||
// 邮件通知
|
||
String emailAddr = (String) db.getField(
|
||
tgt, "email");
|
||
if (emailAddr != null
|
||
&& !emailAddr.isEmpty()) {
|
||
String time =
|
||
new java.text.SimpleDateFormat(
|
||
"yyyy-MM-dd HH:mm:ss")
|
||
.format(new java.util.Date());
|
||
String body = "玩家 " + tgt
|
||
+ "：\n您的密码已于 " + time
|
||
+ " 被管理员重置为临时密码。\n"
|
||
+ "如果是本人操作请忽略。\n"
|
||
+ "如非本人操作请立即联系管理员。";
|
||
final String to = emailAddr;
|
||
final String fName = tgt;
|
||
final String bodyF = body;
|
||
Bukkit.getScheduler()
|
||
.runTaskAsynchronously(this,
|
||
() -> email
|
||
.sendTempPassword(
|
||
to, fName,
|
||
bodyF));
|
||
}
|
||
return true;
|
||
}
|
||
// give - 手动发放雪球菜单
|
||
if (sub.equals("give")) {
|
||
if (args.length < 2) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login give <玩家名>");
|
||
return true;
|
||
}
|
||
Player tp = Bukkit.getPlayer(
|
||
args[1]);
|
||
if (tp == null || !tp.isOnline()) {
|
||
sender.sendMessage(
|
||
"§c玩家不在线: "
|
||
+ args[1]);
|
||
return true;
|
||
}
|
||
forceGiveMenuSnowball(tp);
|
||
tp.sendMessage(
|
||
"§a管理员已为您发放菜单雪球");
|
||
sender.sendMessage(
|
||
"§a已发放雪球菜单给 "
|
||
+ args[1]);
|
||
return true;
|
||
}
|
||
|
||
// shopadd
|
||
if (sub.equals("shopadd")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
if (args.length < 4) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login shopadd <名称> <价格> <命令>");
|
||
return true;
|
||
}
|
||
String shopName = args[1];
|
||
int price;
|
||
try {
|
||
price = Integer.parseInt(args[2]);
|
||
} catch (NumberFormatException ex) {
|
||
sender.sendMessage("§c无效数字");
|
||
return true;
|
||
}
|
||
String shopCmd = args[3];
|
||
points.addItem(shopName, price, shopCmd);
|
||
sender.sendMessage("§a已添加商品: "
|
||
+ shopName + " (" + price
|
||
+ "积分)");
|
||
return true;
|
||
}
|
||
|
||
// shopdel
|
||
if (sub.equals("shopdel")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
if (args.length < 2) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login shopdel <序号>");
|
||
return true;
|
||
}
|
||
try {
|
||
int idx = Integer.parseInt(args[1]);
|
||
points.removeItem(idx);
|
||
sender.sendMessage("§a已删除商品 #" + idx);
|
||
} catch (NumberFormatException ex) {
|
||
sender.sendMessage("§c无效数字");
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// get
|
||
if (sub.equals("get")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
if (args.length < 2) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login get <玩家>");
|
||
return true;
|
||
}
|
||
Map<String, Object> user =
|
||
db.getUser(args[1]);
|
||
if (user.isEmpty()) {
|
||
sender.sendMessage("§c玩家不存在");
|
||
return true;
|
||
}
|
||
sender.sendMessage(
|
||
"§e=== " + args[1] + " ===");
|
||
sender.sendMessage("§7积分: §e"
|
||
+ user.getOrDefault("points", 0));
|
||
sender.sendMessage("§7邮箱: §e"
|
||
+ user.getOrDefault("email", "无"));
|
||
sender.sendMessage("§7签到天数: §e"
|
||
+ user.getOrDefault(
|
||
"total_checkin_days", 0));
|
||
sender.sendMessage("§7邀请码: §e"
|
||
+ user.getOrDefault(
|
||
"invite_code", "无"));
|
||
return true;
|
||
}
|
||
|
||
// del
|
||
if (sub.equals("del")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
if (args.length < 2) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login del <玩家>");
|
||
return true;
|
||
}
|
||
db.deleteUser(args[1]);
|
||
sender.sendMessage("§a已删除 " + args[1]);
|
||
Player tp = Bukkit.getPlayer(args[1]);
|
||
if (tp != null && tp.isOnline())
|
||
tp.kickPlayer("§c账号已被管理员删除");
|
||
return true;
|
||
}
|
||
|
||
// kick (挂机)
|
||
if (sub.equals("kick")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
if (args.length < 2) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login kick <开关> [分钟]");
|
||
return true;
|
||
}
|
||
String mode = args[1].toLowerCase();
|
||
if (mode.equals("on")
|
||
|| mode.equals("开")
|
||
|| mode.equals("启用")) {
|
||
config.afkEnabled = true;
|
||
if (args.length >= 3) {
|
||
try {
|
||
config.afkTimeout =
|
||
Integer.parseInt(
|
||
args[2]) * 60;
|
||
} catch (NumberFormatException ignored) {
|
||
}
|
||
}
|
||
config.saveSettings();
|
||
int minutes =
|
||
config.afkTimeout / 60;
|
||
sender.sendMessage(
|
||
"§a挂机踢出已开启，超时: "
|
||
+ minutes + " 分钟");
|
||
} else if (mode.equals("off")
|
||
|| mode.equals("关")
|
||
|| mode.equals("停用")) {
|
||
config.afkEnabled = false;
|
||
config.saveSettings();
|
||
sender.sendMessage(
|
||
"§c挂机踢出已关闭");
|
||
} else {
|
||
sender.sendMessage(
|
||
"§c无效参数 on/off");
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// add
|
||
if (sub.equals("add")) {
|
||
if (!isAdmin(sender)) {
|
||
sender.sendMessage("§c权限不足");
|
||
return true;
|
||
}
|
||
if (args.length < 3) {
|
||
sender.sendMessage(
|
||
"§e用法: /sdf1_login add <玩家> <积分>");
|
||
return true;
|
||
}
|
||
int amount;
|
||
try {
|
||
amount = Integer.parseInt(args[2]);
|
||
} catch (NumberFormatException ex) {
|
||
sender.sendMessage("§c无效数字");
|
||
return true;
|
||
}
|
||
db.addPoints(args[1], amount);
|
||
sender.sendMessage("§a已为 " + args[1]
|
||
+ " 增加 " + amount + " 积分");
|
||
return true;
|
||
}
|
||
|
||
// ticket
|
||
if (sub.equals("ticket")
|
||
|| sub.equals("工单")) {
|
||
if (!(sender instanceof Player)) {
|
||
sender.sendMessage("§c仅玩家可用");
|
||
return true;
|
||
}
|
||
ticket.openMain((Player) sender);
|
||
return true;
|
||
}
|
||
|
||
sender.sendMessage("§c未知参数");
|
||
return true;
|
||
}
|
||
/**
|
||
* 是否是垃圾站展示物品（带ID lore）
|
||
*/
|
||
private boolean isTrashDisplayItem(
|
||
ItemStack item) {
|
||
if (item == null
|
||
|| item.getType()
|
||
== Material.AIR)
|
||
return false;
|
||
if (!item.hasItemMeta())
|
||
return false;
|
||
ItemMeta im = item.getItemMeta();
|
||
if (im == null || !im.hasLore())
|
||
return false;
|
||
List<String> lore = im.getLore();
|
||
if (lore == null || lore.isEmpty())
|
||
return false;
|
||
return lore.get(0)
|
||
.startsWith("§7ID: #");
|
||
}
|
||
|
||
private void sendChatHelp(Player p) {
|
||
p.sendMessage(
|
||
"§e§l======== 聊天过滤帮助 ==========");
|
||
p.sendMessage("§e/chat reload §7- 重载配置");
|
||
p.sendMessage("§e/chat add <URL> §7- 添加白名单URL");
|
||
p.sendMessage("§e/chat remove <URL> §7- 移除白名单URL");
|
||
p.sendMessage("§e/chat addplayer <玩家> §7- 添加白名单玩家");
|
||
p.sendMessage("§e/chat takeplayer <玩家> §7- 移除白名单玩家");
|
||
p.sendMessage("§e/chat unmute <玩家> §7- 解禁玩家");
|
||
p.sendMessage("§e/chat reset <玩家> §7- 重置违规记录");
|
||
p.sendMessage(
|
||
"§e§l==================================");
|
||
}
|
||
private int findEmptySlot(Inventory inv) {
|
||
for (int i = 0; i < 49; i++) {
|
||
ItemStack item = inv.getItem(i);
|
||
if (item == null
|
||
|| item.getType()
|
||
== Material.AIR)
|
||
return i;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
// ===== TabComplete =====
|
||
@Override
|
||
public List<String> onTabComplete(
|
||
CommandSender sender, Command cmd,
|
||
String label, String[] args) {
|
||
List<String> list = new ArrayList<>();
|
||
if (cmd.getName().equalsIgnoreCase(
|
||
"sdf1_login")
|
||
&& args.length == 1) {
|
||
if (isAdmin(sender)) {
|
||
list.addAll(Arrays.asList(
|
||
"reload", "pw", "email",
|
||
"sign", "reset", "undo",
|
||
"get", "del", "set",
|
||
"take", "add", "kick",
|
||
"ticket", "oa", "stop",
|
||
"shopadd", "shopdel","back","update"));
|
||
} else {
|
||
list.addAll(Arrays.asList(
|
||
"pw", "email", "sign",
|
||
"reset", "undo",
|
||
"ticket", "oa", "stop"));
|
||
}
|
||
}
|
||
if (cmd.getName().equalsIgnoreCase("chat")
|
||
&& args.length == 1
|
||
&& isAdmin(sender)) {
|
||
list.addAll(Arrays.asList(
|
||
"reload", "add", "remove",
|
||
"addplayer", "takeplayer",
|
||
"unmute", "reset"));
|
||
}
|
||
return list;
|
||
}
|
||
|
||
} |