GongFuServer/script/module/jjcnewladder/jjcNewLadderDB.lua

--------------------------------
-- 文件名       :   jjcNewLadderDB.lua
-- 文件说明     :   天梯赛-DB数据
-- 创建时间     :   2025/05/06
-- 创建人       :   FC
--------------------------------

local LuaMongo = _G.lua_mongo
local Config = require("Config")
local DB = require("common.DB")
local Util = require("common.Util")
local CommonDB = require("common.CommonDB")
local CombatVideo = require("combat.CombatVideo")
local CreateRole = require("role.CreateRole")
local WarZoneConf = require("excel.WarZone")
local JjcExcel = require("excel.jjc")
local JjcNewLadderDefine = require("jjcnewladder.jjcNewLadderDefine")
local Timer = require("core.Timer")
local JjcNewLadderMiddle = require("jjcnewladder.jjcNewLadderMiddle")

local nServerOffSet = 810538  -- 配置中服务器ID偏移量

JJCNEWLADDERDB_PLAYER_RANK = {}     -- 天梯赛真人对应排名
JJCNEWLADDERDB_ROBOT_RANK = {}      -- 机器人对应排名信息
JJCNEWLADDERDB_ALL_RANK = {}        -- 天梯赛排行榜信息

UUID_2_RANK = {}

local nRandNum = 50                 -- 随机次数，防止找到重复的
local nFindRivalNum = 5             -- 匹配的对手

local Jjc_QueryByUuid = {uuid = nil}        -- DB查询数据

-------------------------------- 以下是战区归宿的第一个服操作 ---------------------------
-- 获取战区服务器ID
function JjcNewLadderDB_ConfServerID2TrueServerID(nServerIDConf)
    return nServerIDConf + nServerOffSet - 1
end

-- 获取战区配置服务器ID
function JjcNewLadderDB_TrueServerID2ConfServerID(nServerID)
    return nServerID - nServerOffSet + 1
end

-- 判断是否是战区所属的第一个服
local function JjcNewLadderDB_IsFirstServer(nServerID)
    local nServerIDConf = JjcNewLadderDB_TrueServerID2ConfServerID(nServerID)
    print("[JjcNewLadderDB_IsFirstServer] nServerIDConf = "..nServerIDConf)

    local bRet = false
    for _, v in ipairs(WarZoneConf.group) do
        print("[JjcNewLadderDB_IsFirstServer] nMinServerID = "..v.nMinServerID)
        if v.nMinServerID == nServerIDConf then
            bRet = true
            break
        end

        -- 大于了，没必要找直接返回
        if v.nMinServerID > nServerIDConf then
            break
        end
    end

    return bRet
end

-- 移除数据
local function JjcNewLadderDB_RemoveDB(uuid)
    if not uuid then return end
    Jjc_QueryByUuid.uuid = uuid
	LuaMongo.remove(DB.db_jjcLadder, QueryByUuid)
end

-- 更新数据
local function JjcNewLadderDB_UpdateData(tRankData)
	if not tRankData.uuid then return end
	QueryByUuid.uuid = tRankData.uuid
	LuaMongo.update(DB.db_jjcLadder, QueryByUuid, tRankData)
end

-- 插入数据
local function JjcNewLadderDB_InsertData(tRankData)
    LuaMongo.insert(DB.db_jjcLadder, tRankData)
end

-- 判断是否是NPC
local function JjcNewLadderDB_isNpc(tRankData)
	if tRankData.nPoint and tRankData.nMonsterOutID then
		return true
	end

    return false
end

local function JjcNewLadderDB_AddNpc(tNpcConfig, nID)
    local jjcData = {}
	local r = math.random(1, #tNpcConfig.monsterOutID)
	jjcData.monsterOutID = tNpcConfig.monsterOutID[r]
	jjcData.lv = 50
    jjcData.head = CreateRole.getRandomHead()
	jjcData.name = CreateRole.getRandomName()
	jjcData.body = CreateRole.getRandomBody()
	jjcData.identity = CreateRole.getFakeIdentityMax()
	jjcData.point = tNpcConfig.initPoint
	jjcData.zhandouli = math.random(tNpcConfig.zhandouli[1], tNpcConfig.zhandouli[2])
	jjcData.time = os.time()
    jjcData.uuid = nID
    jjcData.nIsHuman = 0
    jjcData.nServerID = Config.SVR_INDEX
    jjcData.ServerName = "寻宝"..Config.NEW_SVR_INDEX.."区"
    jjcData.nInFight = 0
    jjcData.nLastFightTime = 0
	LuaMongo.insert(DB.db_jjcLadder, jjcData)
	JJCNEWLADDERDB_ALL_RANK[#JJCNEWLADDERDB_ALL_RANK + 1] = jjcData
	
	if #JJCNEWLADDERDB_ROBOT_RANK < JjcNewLadderDefine.JJC_NEWLADDER_ROBOT_NUM then
		JJCNEWLADDERDB_ROBOT_RANK[#JJCNEWLADDERDB_ROBOT_RANK + 1] = jjcData
	end
    print("[JjcNewLadderDB_AddNpc] 初始化机器人成功 nID = "..nID)
end

-- 初始化机器人数据
local function JjcNewLadderDB_InitRobot()
    if false == JjcNewLadderDB_IsFirstServer(Config.SVR_INDEX) then
        return
    end

    print("[JjcNewLadderDB_InitRobot] 初始化机器人数据开始")
    -- 生成NPC数据
    local nID = 1
    for _, npcConfig in ipairs(JjcExcel.skyladdernpc) do
        for i = 1, npcConfig.cnt do
            JjcNewLadderDB_AddNpc(npcConfig, nID)
            nID = nID + 1
        end
    end
end

local function JjcNewLadderDB_ownCmp(a, b)
	if a.point ~= b.point then
		return a.point > b.point
	end
	return a.time < b.time
end

-- 进行排序
local function JjcNewLadderDB_SortRank()
    if #JJCNEWLADDERDB_ALL_RANK > 1 then
		table.sort(JJCNEWLADDERDB_ALL_RANK, JjcNewLadderDB_ownCmp)
	end

    print("[JjcNewLadderDB_SortRank] 排序结束")
	for rank = 1, #JJCNEWLADDERDB_ALL_RANK do
		local uuid = JJCNEWLADDERDB_ALL_RANK[rank].uuid
		UUID_2_RANK[uuid] = rank
	end
end

-- 战区第一个服清理数据
local function JjcNewLadderDB_FirstServerRest(nOperate)
    JJCNEWLADDERDB_PLAYER_RANK = {}
    JJCNEWLADDERDB_ROBOT_RANK = {}
    JJCNEWLADDERDB_ALL_RANK = {}
    UUID_2_RANK = {}
    LuaMongo.remove(DB.db_jjcLadder)

    -- for i = 1, nLen, 1 do
    --     local tRankData = JJCNEWLADDERDB_ALL_RANK[i]
    --     if false == JjcNewLadderDB_isNpc(tRankData) then
    --         JjcNewLadderDB_RemoveDB(tRankData.uuid)
    --     end
    --     JJCNEWLADDERDB_ALL_RANK[i] = nil
    -- end

    -- 
    -- 初始化机器人
    if true == nOperate then
        print("[JjcNewLadderDB_FirstServerRest] 初始化机器人数据")
        JjcNewLadderDB_InitRobot()
    end

    -- 进行排序和映射
    JjcNewLadderDB_SortRank()
end

-- 根据 uuid从db中取data
local function JjcNewLadderDB_GetDBDataByUid(uuid)
    -- MiddleRankQueryForData = {nRankType = 1, nRankSubType = 1, nServerKey = 1 ,uuid = 1}
   
    Jjc_QueryByUuid.uuid = uuid

    local data = {}
    LuaMongo.find(DB.db_jjcLadder, Jjc_QueryByUuid)
    return LuaMongo.next(data) and data
end

-- 更新DB数据
local function JjcNewLadderDB_UpdateDBData(data)
    local oldData = JjcNewLadderDB_GetDBDataByUid(data.uuid)
    if oldData then
        Jjc_QueryByUuid.uuid = data.uuid
        LuaMongo.update(DB.db_jjcLadder, Jjc_QueryByUuid, data)
        print("[JjcNewLadderDB_UpdateDBData] 存在旧数据进行更新")
    else
        LuaMongo.insert(DB.db_jjcLadder, data)
        print("[JjcNewLadderDB_UpdateDBData] 不存在旧数据直接进行插入")
    end
end

-- 初始化数据
function JjcNewLadderDB_Init()
    if JjcNewLadderDB_IsFirstServer(Config.SVR_INDEX) then
        JjcNewLadderDB_FirstServerRest(true)
    end

    -- 清理录像
    CombatVideo.cleanJJCLadderVideo()
end

-- 判断是否为空
local function JjcNewLadderDB_isEmpty()
    LuaMongo.find(DB.db_jjcLadder)
	local data = {}
	if not LuaMongo.next(data) then    
		return true
	end

    return false
end

-- 加载数据
local function JjcNewLadderDB_LoadData()
    LuaMongo.find(DB.db_jjcLadder)
    while true do
    	local data = {}
    	if not LuaMongo.next(data) then    
    		break
    	end	

    	if data.point then
    		JJCNEWLADDERDB_ALL_RANK[#JJCNEWLADDERDB_ALL_RANK + 1] = data
        else
            print("[JjcNewLadderDB_LoadData] 居然存在没有积分的 数据 uuid = "..data.uuid)
    	end
    end

    print("[JjcNewLadderDB_LoadData] 加载数据完成，共加载 "..#JJCNEWLADDERDB_ALL_RANK)

    -- 加载完排序
    JjcNewLadderDB_SortRank()

    print("[JjcNewLadderDB_LoadData] 排序完成")

    for i = 1, #JJCNEWLADDERDB_ALL_RANK do
    	if #JJCNEWLADDERDB_ROBOT_RANK >= JjcNewLadderDefine.JJC_NEWLADDER_ROBOT_NUM then
    		break
    	end

    	local tRankData = JJCNEWLADDERDB_ALL_RANK[i]
    	if tRankData.nIsHuman == 1 then
			JJCNEWLADDERDB_ROBOT_RANK[#JJCNEWLADDERDB_ROBOT_RANK + 1] = tRankData   		
    	end
    end
end

-- 起服操作
function JjcNewLadderDB_initAfterStart()
    if _G.is_middle == true then 
        return
    end

    print("[JjcNewLadderDB_initAfterStart] DB数据开始初始化")
    if true == JjcNewLadderDB_IsFirstServer(Config.SVR_INDEX) then
        print("[JjcNewLadderDB_initAfterStart] 是首个服进行DB数据操作")
        
        if true == JjcNewLadderDB_isEmpty() then
            print("[JjcNewLadderDB_initAfterStart] DB数据为空进行初始化机器人数据")

            JjcNewLadderDB_Init()
        else
            print("[JjcNewLadderDB_initAfterStart] DB数据不为空进行加载DB数据")

            JjcNewLadderDB_LoadData()
        end
    else
        print("[JjcNewLadderDB_initAfterStart] 不是首个服返回")
    end
end

-- 定时操作
function JjcNewLadderDB_OnHourOpen()
    JjcNewLadderDB_Init()
end

-------------------------------- 战区归宿的第一个服操作结束 ---------------------------

-------------------------------- 内部调用函数 ---------------------------
-- 加入匹配数据
local function JjcNewLadderDB_AddRival(uuid, tChoseRankID)
    local nNowRank = UUID_2_RANK[uuid]
    local tRankData = JJCNEWLADDERDB_ALL_RANK[nNowRank]
    if not tRankData then
        return false
    end

    tRankData.tRival = {}

    for nRank, _ in pairs(tChoseRankID) do
        local tChoseRankData = JJCNEWLADDERDB_ALL_RANK[nRank]
        local uuidChose, nIsHuman = tChoseRankData.uuid, tChoseRankData.nIsHuman
        if not uuidChose or not nIsHuman then
            tRankData.tRival = {}
            return false
        end

        table.insert(tRankData.tRival, {uuid = uuidChose, nIsHuman = nIsHuman})
    end

    return true
end

function JjcNewLadderDB_CheckIsReset()
    local nNowTime = os.time()
    local nEndTime = CommonDB.GetJjcLadderEndTime()
    if 0 >= nEndTime then
        local tDate = os.date("*t",nNowTime)
        if tDate.wday >= JjcNewLadderDefine.JJC_NEWLADDER_OPENDAY and JjcNewLadderDefine.JJC_NEWLADDER_OPENDAY <= tDate.wday then
            return true
        end

        return false
    else
        return nNowTime > nEndTime
    end
end

-- 加入人物
function JjcNewLadderDB_AddHuman(tData)
    local rank = JJCNEWLADDERDB_PLAYER_RANK[tData.uuid]
	if rank then
        return true
    end

    local JjcDBData = {
        nIsHuman = 1,       -- 是否是真人
        name = tData.name,
        uuid = tData.uuid,
        nServerID = tData.nSrcServerID,
        szServerName = tData.szServerName,
        headFrame = tData.headFrame,
        head = tData.head,
        time = os.time(),
        point = JjcNewLadderDefine.JJC_NEWLADDER_POINT,
        tRival = {},
        nInFight = 0,
        nLastFightTime = 0
        -- zhandouli = tData.zhandouli
    }

	LuaMongo.insert(DB.db_jjc, JjcDBData)

    JJCNEWLADDERDB_ALL_RANK[#JJCNEWLADDERDB_ALL_RANK + 1] = JjcDBData
	JjcNewLadderDB_SortRank()

    return true
end

-- 匹配对手
function JjcNewLadderDB_MatchRival(uuid)
    local nNowRank = UUID_2_RANK[uuid]
    local nMachRank = nNowRank
    if nNowRank < 1000 then
        nMachRank = 1000
    end
    local nMatchMinRank = math.max(nMachRank - 50, 1)
    local nMatchMaxRank = math.min(nMachRank + 10, 1000)

    local tChoseID, nFindNum = {}, 0

    -- 找50次
    for i = 1, nRandNum, 1 do
        local nFindRank = math.random(nMatchMinRank, nMatchMaxRank)
        if not tChoseID[nFindRank] then
            tChoseID[nFindRank] = 1
            nFindNum = nFindNum + 1
        end

        if nFindNum >= nFindRivalNum then
            break
        end  
    end

    if nFindNum < 5 then
        return nil
    end

    local bAddRival = JjcNewLadderDB_AddRival(uuid, tChoseID)
    if false == bAddRival then
        return nil
    end

    return tChoseID
end

-- 匹配一次对手
function JjcNewLadderDB_MatchOneRival(uuid, tChoseRank)
    local nNowRank = UUID_2_RANK[uuid]
    local nMachRank = nNowRank
    if nNowRank < 1000 then
        nMachRank = 1000
    end
    local nMatchMinRank = math.max(nMachRank - 50, 1)
    local nMatchMaxRank = math.min(nMachRank + 10, 1000)

    for i = 1, nRandNum, 1 do
        local nFindRank = math.random(nMatchMinRank, nMatchMaxRank)
        if not tChoseRank[nFindRank] then
            return nFindRank
        end
    end

    return -1
end

-- 通过uid获取对应的DB数据
function JjcNewLadderDB_GetDBDataByuid(uuid)
    local nRank = UUID_2_RANK[uuid]
    if not nRank then
        return nil
    end

    return JJCNEWLADDERDB_ALL_RANK[nRank]
end

-- 通过排名获取对应的DB数据
function JjcNewLadderDB_GetDBDataByRank(nRank)
    return JJCNEWLADDERDB_ALL_RANK[nRank]
end

function JjcNewLadderDB_GetRankByuid(uuid)
    return UUID_2_RANK[uuid]
end

-- 增加积分点数
function JjcNewLadderDB_AddPoint(uuid, nAddPointNum)
    local tRankData = JjcNewLadderDB_GetDBDataByuid(uuid)
    if tRankData then
        tRankData.point = tRankData.point + nAddPointNum
        -- 更新DB数据
        JjcNewLadderDB_UpdateDBData(tRankData)
        JjcNewLadderDB_SortRank()
    end
end

-- 发送对应的数据给奖励
function JjcNewLadderDB_OnSendPlayerRank(uuid, nServerID, nRank)
    JjcNewLadderMiddle.JjcNewLadderMiddle_SendPrizeMail(uuid, nServerID, nRank)
end

-- 延迟时间 遍历排行榜 发送奖励
function JjcNewLadderDB_OnTimeSendMail()
    -- 再排序一次
    JjcNewLadderDB_SortRank()

    for nRank = 1, JjcNewLadderDefine.JJC_NEWLADDER_SEND_RANKPRIZE_LEN, 1 do
        local tRankData = JJCNEWLADDERDB_ALL_RANK[nRank]
        if tRankData.nIsHuman == 1 then
            local nLaterTime = math.random(5, 10)
            local uuid, nServerID = tRankData.uuid, tRankData.nServerID
            Timer.addLater(nLaterTime, JjcNewLadderDB_OnSendPlayerRank, uuid, nServerID, nRank)
        end
    end
end

function JjcNewLadderDB_SendRankMail()
    local nLaterTime = math.random(10, 60)
    Timer.addLater(nLaterTime, JjcNewLadderDB_OnTimeSendMail)
end

-------------------------------- 内部调用函数 ---------------------------