372 lines
14 KiB
Kotlin
372 lines
14 KiB
Kotlin
package top.r3944realms.ltdmanager.module
|
|
|
|
import kotlinx.coroutines.*
|
|
import kotlinx.serialization.Serializable
|
|
import kotlinx.serialization.json.Json
|
|
import top.r3944realms.ltdmanager.mcserver.McServerStatus
|
|
import top.r3944realms.ltdmanager.napcat.NapCatClient
|
|
import top.r3944realms.ltdmanager.napcat.data.ID
|
|
import top.r3944realms.ltdmanager.napcat.data.MessageElement
|
|
import top.r3944realms.ltdmanager.napcat.data.MessageType
|
|
import top.r3944realms.ltdmanager.napcat.event.message.GetFriendMsgHistoryEvent
|
|
import top.r3944realms.ltdmanager.napcat.request.message.SendForwardMsgRequest
|
|
import top.r3944realms.ltdmanager.napcat.request.other.SendGroupMsgRequest
|
|
import top.r3944realms.ltdmanager.utils.LoggerUtil
|
|
import java.io.File
|
|
import java.util.concurrent.locks.ReentrantLock
|
|
import kotlin.concurrent.withLock
|
|
|
|
class McServerStatusModule(
|
|
private val groupMessagePollingModule: GroupMessagePollingModule,
|
|
private val selfId: Long,
|
|
private val selfNickName: String,
|
|
private val cooldownSeconds: Long = 60,
|
|
private val commands: List<String> = listOf("/mcs", "/s"),
|
|
private val presetServer: Map<Set<String>, String> = mapOf(
|
|
setOf("hp", "hypixel") to "mc.hypixel.net",
|
|
setOf("pm", "mineplex") to "play.mineplex.com"
|
|
)
|
|
) : BaseModule(), PersistentState<McServerStatusModule.CooldownState> {
|
|
private val presetServerByAlias: Map<String, String> by lazy {
|
|
presetServer.flatMap { (aliases, ip) ->
|
|
aliases.map { it.lowercase() to ip }
|
|
}.toMap()
|
|
}
|
|
fun getServerIp(alias: String): String? = presetServerByAlias[alias.lowercase()]
|
|
override val name: String = "McServerStatusModule"
|
|
private var scope: CoroutineScope? = null
|
|
private val stateFile = getStateFile("mc_server_status_state.json")
|
|
private val stateBackupFile = getStateFile("mc_server_status_state.json.bak")
|
|
private val fileLock = ReentrantLock()
|
|
private var cooldownState = loadState()
|
|
|
|
override fun getStateFile(): File = stateFile
|
|
override fun getState(): CooldownState = cooldownState
|
|
|
|
override fun onLoad() {
|
|
LoggerUtil.logger.info("[$name] 模块已装载，目标群组: ${groupMessagePollingModule.targetGroupId}")
|
|
|
|
scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
|
|
scope!!.launch {
|
|
LoggerUtil.logger.info("[$name] 轮询协程启动")
|
|
groupMessagePollingModule.messagesFlow.collect { messages ->
|
|
if (loaded) handleMessages(messages)
|
|
}
|
|
}
|
|
}
|
|
|
|
override suspend fun onUnload() {
|
|
saveState(cooldownState)
|
|
scope?.cancel()
|
|
LoggerUtil.logger.info("[$name] 模块已卸载完成")
|
|
}
|
|
|
|
private suspend fun handleMessages(messages: List<GetFriendMsgHistoryEvent.SpecificMsg>) {
|
|
if (messages.isEmpty()) return
|
|
val triggerMsgs = filterTriggerMessages(messages)
|
|
if (triggerMsgs.isEmpty()) return
|
|
|
|
try {
|
|
triggerMsgs.forEach {
|
|
processCommand(it)
|
|
}
|
|
} catch (e: Exception) {
|
|
sendFailedMessage(napCatClient, text = "系统错误，请联系管理员: $e")
|
|
} finally {
|
|
saveState(cooldownState)
|
|
}
|
|
}
|
|
private suspend fun filterTriggerMessages(messages: List<GetFriendMsgHistoryEvent.SpecificMsg>)
|
|
: List<GetFriendMsgHistoryEvent.SpecificMsg> {
|
|
|
|
val filtered = messages.asSequence()
|
|
.filter { msg ->
|
|
// 忽略自己消息
|
|
msg.userId != selfId &&
|
|
// 新消息判断
|
|
(msg.time > cooldownState.getLastTriggerTime(msg.userId) ||
|
|
(msg.time == cooldownState.getLastTriggerTime(msg.userId) &&
|
|
msg.realId > cooldownState.getLastTriggerRealId(msg.userId)))
|
|
}
|
|
.filter { msg ->
|
|
// 检查命令
|
|
msg.message.any { seg ->
|
|
seg.type == MessageType.Text &&
|
|
(
|
|
seg.data.text?.let { text -> commands.any { cmd -> text.startsWith(cmd) } } == true
|
|
)
|
|
}
|
|
}
|
|
.filter { runBlocking { handleCooldown(it) } } // 这里处理冷却
|
|
.toList()
|
|
|
|
return filtered
|
|
}
|
|
private suspend fun sendFailedMessage(
|
|
client: NapCatClient,
|
|
qq: Long? = null,
|
|
realId: Long? = null,
|
|
time: Long? = null,
|
|
text: String = "失败消息"
|
|
) {
|
|
LoggerUtil.logger.info("[$name] 发送失败消息: realId=$realId, text=$text")
|
|
if (realId != null && qq != null && time != null) {
|
|
val request = SendGroupMsgRequest(
|
|
MessageElement.reply(ID.long(realId), text),
|
|
ID.long(groupMessagePollingModule.targetGroupId)
|
|
)
|
|
client.sendUnit(request)
|
|
LoggerUtil.logger.info("[$name] 已发送 失败消息")
|
|
|
|
// 更新触发的最大 realId
|
|
cooldownState = cooldownState.updateLastTrigger(qq, realId, time)
|
|
} else {
|
|
val request = SendGroupMsgRequest(
|
|
listOf(MessageElement.text(text)),
|
|
ID.long(groupMessagePollingModule.targetGroupId)
|
|
)
|
|
client.sendUnit(request)
|
|
LoggerUtil.logger.info("[$name] 已发送 失败消息[无指定对象]")
|
|
}
|
|
}
|
|
/** 冷却提示消息 */
|
|
|
|
private suspend fun handleCooldown(msg: GetFriendMsgHistoryEvent.SpecificMsg): Boolean {
|
|
val trigger = cooldownState.map[msg.userId]
|
|
val lastTriggerTime = trigger?.time ?: -1L
|
|
val lastCooldownRealId = trigger?.lastCooldownRealId ?: -1L
|
|
val nowSec = System.currentTimeMillis() / 1000
|
|
|
|
// 未触发过或者已超过冷却
|
|
if (lastTriggerTime == -1L || nowSec - lastTriggerTime >= cooldownSeconds) {
|
|
return true
|
|
}
|
|
|
|
// 冷却中且未发送过冷却提示
|
|
if (msg.realId != lastCooldownRealId) {
|
|
val remaining = ((cooldownSeconds - (nowSec - lastTriggerTime))).coerceAtLeast(1)
|
|
val msgText = "⏳ 查询过于频繁， $remaining 秒后执行查询，切勿重复发送"
|
|
sendCooldownMessage(napCatClient, msg.userId, msg.realId, msgText)
|
|
cooldownState = cooldownState.updateLastCooldownRealId(msg.userId, msg.realId)
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
private suspend fun sendCooldownMessage(client: NapCatClient, qq: Long, realId: Long, text: String) {
|
|
val request = SendGroupMsgRequest(
|
|
MessageElement.reply(ID.long(realId), text),
|
|
ID.long(groupMessagePollingModule.targetGroupId)
|
|
)
|
|
client.sendUnit(request)
|
|
}
|
|
|
|
|
|
|
|
private suspend fun processCommand(msg: GetFriendMsgHistoryEvent.SpecificMsg) {
|
|
// 找出文本内容
|
|
val text = msg.message
|
|
.firstOrNull { it.type == MessageType.Text }
|
|
?.data?.text
|
|
?.trim()
|
|
?: return
|
|
|
|
// 解析命令
|
|
val matchedCommand = commands.firstOrNull { text.startsWith(it) } ?: return
|
|
var address = text.removePrefix(matchedCommand).trim()
|
|
|
|
// 使用预设别名替换
|
|
presetServerByAlias[address.lowercase()]?.let { presetIp ->
|
|
address = presetIp
|
|
}
|
|
|
|
if (address.isEmpty()) {
|
|
sendFailedMessage(
|
|
napCatClient,
|
|
msg.userId,
|
|
msg.realId,
|
|
msg.time,
|
|
"❌ 请输入服务器地址，例如 /mcs n2.akiracloud.net:10599"
|
|
)
|
|
return
|
|
}
|
|
|
|
try {
|
|
val status = mcSrvStatusClient.getServerStatus(address) // 返回 McServerStatus
|
|
|
|
// 检查是否查询失败
|
|
if (!status.online) {
|
|
sendFailedMessage(
|
|
napCatClient, msg.userId, msg.realId, msg.time,
|
|
"❌ 查询失败，请检查服务器地址或服务器是否在线"
|
|
)
|
|
return
|
|
}
|
|
|
|
// 查询成功，发送状态消息
|
|
sendStatusForwardMessage(napCatClient, msg, address, status, msg.realId, msg.time)
|
|
|
|
} catch (e: Exception) {
|
|
LoggerUtil.logger.error("查询服务器状态失败: $address", e)
|
|
sendFailedMessage(
|
|
napCatClient,
|
|
msg.userId,
|
|
msg.realId,
|
|
msg.time,
|
|
"❌ 查询失败，请检查服务器地址或服务器是否在线"
|
|
)
|
|
}
|
|
}
|
|
|
|
// ---------------- 转发消息封装 ----------------
|
|
private suspend fun sendStatusForwardMessage(
|
|
client: NapCatClient,
|
|
msg: GetFriendMsgHistoryEvent.SpecificMsg,
|
|
address: String,
|
|
status: McServerStatus,
|
|
realId: Long,
|
|
time: Long
|
|
) {
|
|
LoggerUtil.logger.info("[$name] 发送服务器状态转发消息: realId=$realId, address=$address, online=${status.online}")
|
|
|
|
val messages = mutableListOf<SendForwardMsgRequest.Message>()
|
|
|
|
// ① 服务器基本信息 + MOTD
|
|
val motdText = status.motd?.clean?.joinToString("\n") ?: "无 MOTD"
|
|
val basicInfo = buildString {
|
|
appendLine("🌐 服务器: $address")
|
|
appendLine("─".repeat(25))
|
|
appendLine("MOTD:\n$motdText")
|
|
}
|
|
messages.add(SendForwardMsgRequest.Message(SendForwardMsgRequest.PurpleData(basicInfo), MessageType.Text))
|
|
|
|
// ② 玩家列表
|
|
val playerList = status.players?.list?.joinToString("\n") { it.name } ?: "无"
|
|
val playersInfo = buildString {
|
|
appendLine("📊 在线: ${status.players?.online ?: 0}/${status.players?.max ?: 0}")
|
|
appendLine("👥 玩家:\n$playerList")
|
|
}
|
|
messages.add(SendForwardMsgRequest.Message(SendForwardMsgRequest.PurpleData(playersInfo), MessageType.Text))
|
|
|
|
// ③ 版本 + 状态
|
|
val versionStatus = buildString {
|
|
appendLine("🎮 版本: ${status.version ?: "未知"}")
|
|
appendLine("✅ 状态: ${if (status.online) "在线" else "离线"}")
|
|
status.software?.let { appendLine("💻 软件: $it") }
|
|
}
|
|
messages.add(SendForwardMsgRequest.Message(SendForwardMsgRequest.PurpleData(versionStatus), MessageType.Text))
|
|
|
|
// ④ 摘要信息
|
|
val summaryText = buildString {
|
|
appendLine("📌 查询摘要")
|
|
appendLine("─".repeat(20))
|
|
appendLine("服务器: $address")
|
|
appendLine("在线玩家: ${status.players?.online ?: 0}/${status.players?.max ?: 0}")
|
|
appendLine("状态: ${if (status.online) "在线" else "离线"}")
|
|
appendLine("🕐 ${getCurrentTime()}")
|
|
appendLine("🤖 由 $selfNickName 提供")
|
|
}
|
|
messages.add(SendForwardMsgRequest.Message(SendForwardMsgRequest.PurpleData(summaryText), MessageType.Text))
|
|
|
|
// 封装 Forward 消息
|
|
val topMessage = SendForwardMsgRequest.TopForwardMsg(
|
|
data = SendForwardMsgRequest.MessageData(
|
|
content = messages,
|
|
nickname = selfNickName,
|
|
userId = ID.long(selfId)
|
|
),
|
|
type = MessageType.Node
|
|
)
|
|
|
|
val request = SendForwardMsgRequest(
|
|
groupId = ID.long(groupMessagePollingModule.targetGroupId),
|
|
messages = listOf(topMessage),
|
|
news = listOf(
|
|
SendForwardMsgRequest.ForwardModelNews("点击查看服务器状态与玩家列表"),
|
|
SendForwardMsgRequest.ForwardModelNews("在线 ${status.players?.online ?: 0} / ${status.players?.max ?: 0}"),
|
|
SendForwardMsgRequest.ForwardModelNews("更新时间: ${getCurrentTime()}")
|
|
),
|
|
prompt = "服务器状态查询结果",
|
|
source = "🎮 服务器状态",
|
|
summary = "在线 ${status.players?.online ?: 0} / ${status.players?.max ?: 0} 人"
|
|
)
|
|
|
|
client.sendUnit(request)
|
|
LoggerUtil.logger.info("[$name] 已发送服务器状态转发消息")
|
|
|
|
// 更新冷却状态
|
|
cooldownState = cooldownState.updateLastTrigger(msg.userId, realId, time)
|
|
}
|
|
|
|
|
|
|
|
// 时间格式化
|
|
private fun getCurrentTime(): String {
|
|
return java.time.LocalDateTime.now()
|
|
.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
|
|
}
|
|
|
|
// ---------------- 状态持久化 ----------------
|
|
@Serializable
|
|
data class CooldownState(
|
|
val map: Map<Long, TriggerDetail> = emptyMap()
|
|
) {
|
|
fun getLastTriggerTime(qq: Long): Long = map[qq]?.time ?: -1
|
|
fun getLastTriggerRealId(qq: Long): Long = map[qq]?.realId ?: -1
|
|
fun updateLastTrigger(qq: Long, realId: Long, time: Long = -1): CooldownState {
|
|
val old = map[qq]
|
|
val newTime = if (time != -1L) time else old?.time ?: -1
|
|
val newMap = map.toMutableMap().apply {
|
|
put(qq, TriggerDetail(realId, newTime, old?.lastCooldownRealId ?: -1))
|
|
}
|
|
return copy(map = newMap)
|
|
}
|
|
fun updateLastCooldownRealId(qq: Long, realId: Long): CooldownState {
|
|
val old = map[qq]
|
|
val newMap = map.toMutableMap().apply {
|
|
put(qq, TriggerDetail(
|
|
realId = old?.realId ?: -1,
|
|
time = old?.time ?: -1,
|
|
lastCooldownRealId = realId
|
|
))
|
|
}
|
|
return copy(map = newMap)
|
|
}
|
|
}
|
|
|
|
@Serializable
|
|
data class TriggerDetail(
|
|
val realId: Long,
|
|
val time: Long,
|
|
val lastCooldownRealId: Long = -1L
|
|
)
|
|
|
|
override fun loadState(): CooldownState {
|
|
return try {
|
|
val fileToRead = when {
|
|
stateFile.exists() -> stateFile
|
|
stateBackupFile.exists() -> stateBackupFile
|
|
else -> null
|
|
}
|
|
if (fileToRead == null) return CooldownState()
|
|
val content = fileToRead.readText()
|
|
Json.decodeFromString(CooldownState.serializer(), content)
|
|
} catch (e: Exception) {
|
|
LoggerUtil.logger.warn("[$name] 状态恢复失败，使用默认值", e)
|
|
CooldownState()
|
|
}
|
|
}
|
|
|
|
override fun saveState(state: CooldownState) {
|
|
fileLock.withLock {
|
|
try {
|
|
val json = Json.encodeToString(CooldownState.serializer(), state)
|
|
if (stateFile.exists()) stateFile.copyTo(stateBackupFile, overwrite = true)
|
|
stateFile.writeText(json)
|
|
} catch (e: Exception) {
|
|
LoggerUtil.logger.error("[$name] 保存状态失败", e)
|
|
}
|
|
}
|
|
}
|
|
}
|