#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package GameWorldLogic.FBProcess.GameLogic_Qunying
|
#
|
# @todo:ȺӢ°ñ
|
# @author hxp
|
# @date 2026-03-11
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: ȺӢ°ñ
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2026-03-11 19:00"""
|
#-------------------------------------------------------------------------------
|
|
import DBDataMgr
|
import GameWorld
|
import TurnAttack
|
import ShareDefine
|
import PlayerControl
|
import IpyGameDataPY
|
import PlayerBillboard
|
import PlayerViewCache
|
import ChPyNetSendPack
|
import NetPackCommon
|
import ItemControler
|
import GameFuncComm
|
import PyGameData
|
import FBCommon
|
import ChConfig
|
|
import random
|
import time
|
|
# ¼Ç¼¹¥»÷ÀàÐÍ
|
RecAtkType_Atk = 1 # ·¢Æð¹¥»÷
|
RecAtkType_Def = 2 # ±»¹¥»÷µÄ
|
|
def GetRecServerID(recData): return recData.GetValue1() # Ä¿±êServerID
|
def SetRecServerID(recData, serverID): return recData.SetValue1(serverID)
|
def GetRecAtkType(recData): return recData.GetValue2() # ¹¥»÷ÀàÐÍ 1-·¢Æð¹¥»÷µÄ£¬2-±»¹¥»÷µÄ
|
def SetRecAtkType(recData, atkType): return recData.SetValue2(atkType)
|
def GetRecTagPlayerID(recData): return recData.GetValue3() # Ïà¶Ô¹¥»÷ÀàÐ͵ÄÄ¿±êÍæ¼ÒID
|
def SetRecTagPlayerID(recData, tagPlayerID): return recData.SetValue3(tagPlayerID)
|
def GetRecIsWin(recData): return recData.GetValue4() # ÊÇ·ñ»ñʤ 1-»ñʤ£»2-ʧ°Ü
|
def SetRecIsWin(recData, isWin): return recData.SetValue4(1 if isWin else 0)
|
def GetRecFace(recData): return recData.GetValue5() # Ä¿±êÍ·Ïñ
|
def SetRecFace(recData, face): return recData.SetValue5(face)
|
def GetRecFacePic(recData): return recData.GetValue6()
|
def SetRecFacePic(recData, facePic): return recData.SetValue6(facePic)
|
def GetRecRealmLV(recData): return recData.GetValue7()
|
def SetRecRealmLV(recData, realmLV): return recData.SetValue7(realmLV)
|
def GetRecLV(recData): return recData.GetValue8()
|
def SetRecLV(recData, tagLV): return recData.SetValue8(tagLV)
|
#SetUserData Ãû×Ö¡¢×Ô¼ºÃû´Î¡¢¶Ô·½Ãû´Î
|
|
def OnWeek():
|
serverDay = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_ServerDay) + 1
|
serverDayNeed = IpyGameDataPY.GetFuncCfg("QunyingSet", 1)
|
if serverDayNeed and serverDay < serverDayNeed:
|
GameWorld.DebugLog("¿ª·þÌì²»×ã±¾Öܲ»ÖØÖÃȺӢ°ñ! serverDay=%s < %s" % (serverDay, serverDayNeed))
|
return
|
DoQunyingReset()
|
return
|
|
def OnDay():
|
billboardAwardDict = IpyGameDataPY.GetFuncEvalCfg("QunyingAward", 1, {})
|
PlayerBillboard.DoGiveBillboardAwardByMail(ShareDefine.Def_BT_Qunying, "QunyingDay", billboardAwardDict, "QunyingDay", isClearData=False)
|
return
|
|
def OnServerStart():
|
__fillRobot()
|
return
|
|
def DoQunyingReset():
|
''' Èü¼¾ÖØÖÃ
|
'''
|
GameWorld.Log("=============== ÖØÖÃȺӢ°ñ ===============")
|
|
PyGameData.g_qunyingPlayerMatchDict = {}
|
|
# ½áËãÉÏÈü¼¾ÅÅÐн±Àø
|
billboardAwardDict = IpyGameDataPY.GetFuncEvalCfg("QunyingAward", 2, {})
|
PlayerBillboard.DoGiveBillboardAwardByMail(ShareDefine.Def_BT_Qunying, "QunyingWeek", billboardAwardDict, "QunyingWeek", isClearData=False)
|
|
# ÖØÖÃÅÅÐаñ
|
DBDataMgr.GetBillboardMgr().RemoveBillboard(ShareDefine.Def_BT_Qunying)
|
__fillRobot()
|
|
GameWorld.Log("==========================================")
|
return True
|
|
def __fillRobot():
|
## Ìî³äÂú»úÆ÷ÈË
|
billboardMgr = DBDataMgr.GetBillboardMgr()
|
billBoard = billboardMgr.GetBillboard(ShareDefine.Def_BT_Qunying)
|
maxCount = billBoard.GetMaxCount() # »úÆ÷ÈËÌî³äÊýĬÈÏʹÓðñµ¥×î´óÊý
|
|
robotFPSortList = PlayerViewCache.GetRobotFightPowerSortList(ChConfig.RobotTempNum_Qunying)
|
robotDict = {} # {(rankA, rankB):[robotID], ...}
|
for _, robotID in robotFPSortList:
|
robotIpyData = IpyGameDataPY.GetIpyGameData("Robot", robotID)
|
if not robotIpyData:
|
continue
|
tempValue1 = robotIpyData.GetTempValue1()
|
tempValue2 = robotIpyData.GetTempValue2()
|
rankKey = (tempValue1, tempValue2)
|
if rankKey not in robotDict:
|
robotDict[rankKey] = []
|
robotList = robotDict[rankKey]
|
robotList.append(robotIpyData.GetID())
|
|
layerRobotIDList = []
|
robotKeyList = robotDict.keys()
|
robotKeyList.sort() # °´Ãû´ÎÅÅÐò´¦Àí
|
for robotKey in robotKeyList:
|
rankA, rankB = robotKey
|
robotIDList = robotDict[robotKey]
|
random.shuffle(robotIDList)
|
robotCnt = len(robotIDList)
|
needRobotCnt = rankB - rankA + 1
|
for _ in range(needRobotCnt / robotCnt):
|
layerRobotIDList += robotIDList
|
for index in range(needRobotCnt % robotCnt):
|
layerRobotIDList.append(robotIDList[index])
|
layerRobotIDList = layerRobotIDList[:maxCount]
|
GameWorld.DebugLog("Ìî³äȺӢ°ñ»úÆ÷ÈË: maxCount=%s,fillRobotIDLen=%s" % (maxCount, len(layerRobotIDList)))
|
billBoard.SetOrderRuleByLayer(layerRobotIDList)
|
return
|
|
## ------------------------------------------------------------------------------------------------
|
|
def DoQunyingOpen(curPlayer):
|
storeMax = IpyGameDataPY.GetFuncCfg("QunyingChallenge", 1)
|
PlayerControl.GiveMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket, storeMax, "QunyingOpen")
|
Sync_QunyingInfo(curPlayer) # ¿ªÆô¹¦ÄÜ
|
return
|
|
def OnFBPlayerOnWeek(curPlayer):
|
if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Qunying):
|
return
|
serverDay = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_ServerDay) + 1
|
serverDayNeed = IpyGameDataPY.GetFuncCfg("QunyingSet", 1)
|
# Íæ¼ÒÖØÖÃÓиöÎÊÌ⣬Íæ¼ÒµÄ¹ýÖܲ¢²»Ò»¶¨ÊÇÖÜÒ»´¥·¢£¬¾ßÌå¿´Íæ¼ÒʲôʱºòµÇ¼
|
# ÄÇô¿ÉÄÜ´æÔÚÖܶþÍæ¼Ò²ÅµÇ¼£¬È»ºóÂú×ãÁËÖØÖÃÌõ¼þ£¬µ¼Ö´¥·¢ÁËÍæ¼Ò¸öÈ˵ÄÈü¼¾ÖØÖÃ
|
# Ä¿Ç°Ö»ÓÐˢдÎÊýÐèÒªÖØÖã¬ÔÝʱ²»¿¼ÂÇÕâ¸öÎÊÌ⣬ÕâÖÖÇé¿öÒ»°ãÖ»ÓÐзþ²Å¿ÉÄܳöÏÖ
|
# ¡¾×¢¡¿ÈçÖ®ºóÓÐÐèÒªÖØÖñȽÏÑϽ÷µÄÊý¾Ý£¬ÔòÐèÒª°´Èü¼¾ID¶Ô±È²»Ò»Ñù²ÅÄÜÖØÖÃ
|
if serverDayNeed and serverDay < serverDayNeed:
|
GameWorld.DebugLog("¿ª·þÌì²»×ã±¾Öܲ»ÖØÖÃÍæ¼ÒȺӢ°ñ! serverDay=%s < %s" % (serverDay, serverDayNeed), curPlayer.GetPlayerID())
|
return
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRefreshCnt, 0)
|
Sync_QunyingInfo(curPlayer) # Èü¼¾ÖØÖÃ
|
return
|
|
def OnFBPlayerOnLogin(curPlayer):
|
if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Qunying):
|
return
|
Sync_QunyingInfo(curPlayer) # 怬
|
return
|
|
def __checkAtkQunyingPlayer(curPlayer, tagID, tagRank):
|
'''¼ì²é¿É·ñ¹¥»÷Ä¿±ê
|
'''
|
playerID = curPlayer.GetPlayerID()
|
if not tagID or playerID == tagID:
|
return
|
|
matchRankList = PyGameData.g_qunyingPlayerMatchDict.get(playerID, [])
|
if tagRank not in matchRankList:
|
GameWorld.DebugLog("ȺӢ°ñ²»¿É¹¥»÷²»ÔÚÆ¥ÅäÁбíÀïµÄÄ¿±êÃû´Î! tagID=%s not in matchRankList=%s" % (tagID, matchRankList), playerID)
|
return
|
|
# ÑéÖ¤Ãû´ÎÊÇ·ñ»¹ÓëÇ°¶ËµÄÒ»ÖÂ
|
billboardMgr = DBDataMgr.GetBillboardMgr()
|
billBoard = billboardMgr.GetBillboard(ShareDefine.Def_BT_Qunying)
|
if not billBoard:
|
return
|
layerIDList = billBoard.GetLayerIDList()
|
|
tagIndex = tagRank - 1
|
tagIDNow = 0
|
if 0 <= tagIndex < len(layerIDList):
|
tagIDNow = layerIDList[tagIndex]
|
if tagID != tagIDNow:
|
GameWorld.DebugLog("ȺӢ°ñ¹¥»÷ʱĿ±êÃû´ÎÍæ¼ÒID²»Ò»ÖÂ! tagRank=%s,tagID=%s != tagIDNow=%s" % (tagRank, tagID, tagIDNow), playerID)
|
PlayerControl.NotifyCode(curPlayer, "QunyingTagRankIDErr") # Ä¿±êÍæ¼ÒÃû´ÎÒѸıä
|
DoQunyingMatchRefresh(curPlayer, True, isSys=True)
|
return
|
|
return True
|
|
def OnTurnFightRequest(curPlayer, mapID, funcLineID, tagType, tagID, valueList):
|
## »ØºÏÕ½¶·ÇëÇó
|
|
if not valueList:
|
return
|
|
tagRank = valueList[0] # Ä¿±êÃû´Î
|
quickCnt = valueList[1] if len(valueList) > 1 else 0 # ËÙÕ½´ÎÊý
|
|
# ËÙÕ½
|
if quickCnt > 0:
|
__doQuickFight(curPlayer, mapID, tagID, quickCnt)
|
return
|
|
if not __checkAtkQunyingPlayer(curPlayer, tagID, tagRank):
|
return
|
|
if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket, 1):
|
return
|
|
return True, funcLineID
|
|
def __doQuickFight(curPlayer, mapID, tagID, quickCnt):
|
'''Ö´ÐÐËÙÕ½£¬±Øʤ¡¢Ö»¸ø¹Ì¶¨Õ½¶·½±Àø£¬Ãû´Î²»±ä
|
'''
|
GameWorld.DebugLog("ȺӢ°ñËÙÕ½: tagID=%s,quickCnt=%s" % (tagID, quickCnt))
|
if quickCnt <= 0:
|
return
|
|
if not PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket, quickCnt, "Qunying"):
|
return
|
|
awardItemDict = {}
|
for item in IpyGameDataPY.GetFuncEvalCfg("QunyingChallenge", 3):
|
itemID, itemCount = item[:2]
|
awardItemDict[itemID] = awardItemDict.get(itemID, 0) + itemCount * quickCnt
|
awardItemList = [[itemID, itemCount] for itemID, itemCount in awardItemDict.items()]
|
|
ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["Qunying", False, {}], isNotifyAward=False)
|
|
lineID = 0
|
isPass = 1
|
jsonItemList = []
|
for itemInfo in awardItemList:
|
itemDict = {"ItemID":itemInfo[0], "Count":itemInfo[1]}
|
jsonItemList.append(itemDict)
|
overDict = {FBCommon.Over_itemInfo:jsonItemList, FBCommon.Over_isSweep:1, "tagID":tagID, "quickCnt":quickCnt}
|
FBCommon.NotifyFBOver(curPlayer, mapID, lineID, isPass, overDict)
|
return
|
|
def OnTurnFightAward(curPlayer, guid, mapID, funcLineID, winFaction, statMsg, dateStr, reqData, awardDict):
|
## »ØºÏÕ½¶·½áËã½±Àø
|
if not curPlayer:
|
return
|
|
playerID = curPlayer.GetPlayerID()
|
tagPlayerID = reqData[1]
|
valueList = reqData[2]
|
tagRank = valueList[0] # Ä¿±êÃû´Î
|
isWin = winFaction == ChConfig.Def_FactionA
|
|
GameWorld.DebugLog("½áËãȺӢ°ñÕ½¶·! isWin=%s,tagPlayerID=%s,tagRank=%s" % (isWin, tagPlayerID, tagRank), playerID)
|
canAtkRet = __checkAtkQunyingPlayer(curPlayer, tagPlayerID, tagRank)
|
if not canAtkRet:
|
return
|
|
billboardMgr = DBDataMgr.GetBillboardMgr()
|
billBoard = billboardMgr.GetBillboard(ShareDefine.Def_BT_Qunying)
|
idRankDict = billBoard.GetIDOrderDict()
|
curRank = idRankDict.get(playerID, 0)
|
|
updRank = 0
|
awardItemList = []
|
if isWin:
|
# ʤÀûʱ¹Ì¶¨½±Àø
|
awardItemList = IpyGameDataPY.GetFuncEvalCfg("QunyingChallenge", 3)
|
cmpValue = tagRank
|
if PlayerBillboard.UpdateBillboardLayer(playerID, ShareDefine.Def_BT_Qunying, cmpValue):
|
updRank = tagRank
|
else:
|
GameWorld.DebugLog(" ¸üаñµ¥Ê§°Ü", playerID)
|
|
awardDict.update({FBCommon.Over_itemInfo:FBCommon.GetJsonItemList(awardItemList), "tagPlayerID":tagPlayerID, "updRank":updRank, "curRank":curRank})
|
|
GameWorld.DebugLog(" tagPlayerID=%s,isWin=%s,awardItemList=%s" % (tagPlayerID, isWin, awardItemList), playerID)
|
if not PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket, 1):
|
return
|
|
if isWin:
|
ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["Qunying", False, {}], isNotifyAward=False)
|
|
rankHighest = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRankHighest)
|
if not rankHighest or (1 <= tagRank < rankHighest):
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRankHighest, tagRank)
|
GameWorld.DebugLog(" ¸üÐÂÀúÊ·×î¸ßÅÅÃû! tagRank=%s" % tagRank, playerID)
|
Sync_QunyingInfo(curPlayer) # ¸üÐÂ×î¸ßÅÅÃû
|
|
__updQunyingBatRecord(curPlayer, tagPlayerID, isWin, curRank, tagRank)
|
|
# Õ½¶·½áÊøϵͳǿÖÆË¢ÐÂÆ¥Åä
|
DoQunyingMatchRefresh(curPlayer, True, isSys=True)
|
return
|
|
def __updQunyingBatRecord(curPlayer, tagPlayerID, isWin, curRank, tagRank):
|
## ¸üÐÂÕ½¶·Ïà¹ØÈÕÖ¾¡¢°ñµ¥µÈ
|
|
playerID = curPlayer.GetPlayerID()
|
maxCount = 20
|
|
tagViewCache = PlayerViewCache.FindViewCache(tagPlayerID)
|
|
gameRecMgr = DBDataMgr.GetGameRecMgr()
|
atkRecMgr = gameRecMgr.GetRecTypeIDMgr(ShareDefine.Def_GameRecType_QunyingRecord, playerID)
|
recData = atkRecMgr.AddRecData(maxCount)
|
SetRecAtkType(recData, RecAtkType_Atk)
|
SetRecTagPlayerID(recData, tagPlayerID)
|
SetRecIsWin(recData, isWin)
|
SetRecServerID(recData, tagViewCache.GetServerID() if tagViewCache else 0)
|
SetRecFace(recData, tagViewCache.GetFace() if tagViewCache else 0)
|
SetRecFacePic(recData, tagViewCache.GetFacePic() if tagViewCache else 0)
|
SetRecRealmLV(recData, tagViewCache.GetRealmLV() if tagViewCache else 1)
|
SetRecLV(recData, tagViewCache.GetLV() if tagViewCache else 1)
|
# Ãû×Ö¡¢×Ô¼ºÃû´Î¡¢¶Ô·½Ãû´Î
|
tagPlayerName = tagViewCache.GetPlayerName() if tagViewCache else ""
|
recData.SetUserData({"Name":tagPlayerName, "CurRank":curRank, "TagRank":tagRank})
|
|
# ±»»÷·½
|
if tagPlayerID < ShareDefine.RealPlayerIDStart:
|
#GameWorld.DebugLog("Ä¿±ê·ÇÕæʵÍæ¼Ò²»´¦Àí! tagPlayerID=%s" % tagPlayerID, playerID)
|
return
|
|
# ÓÉÓÚ·Ç°ñµ¥ÉϵÄÍæ¼Ò²»»á±»Æ¥Åäµ½£¬ËùÒÔ±»Æ¥Åäµ½µÄ¿ÉÒÔÀí½âΪһ¶¨ÓÐÕ½¶·¼Ç¼£¬ÒòΪҪÉÏ°ñ±ØÐëÕ½¶·¹ý
|
defRecMgr = gameRecMgr.GetRecTypeIDMgr(ShareDefine.Def_GameRecType_QunyingRecord, tagPlayerID)
|
if not defRecMgr.GetCount():
|
GameWorld.DebugLog("Ä¿±êûÓжÔÕ½¼Ç¼²»´¦Àí! tagPlayerID=%s" % tagPlayerID, playerID)
|
return
|
|
finalRecData = defRecMgr.At(defRecMgr.GetCount() - 1)
|
if not GameWorld.CheckTimeIsSameWeek(finalRecData.GetTime()):
|
GameWorld.DebugLog("Ä¿±ê±¾ÖÜûÓжÔÕ½¼Ç¼²»´¦Àí! tagPlayerID=%s" % tagPlayerID, playerID)
|
return
|
|
recData = defRecMgr.AddRecData(maxCount)
|
SetRecAtkType(recData, RecAtkType_Def)
|
SetRecTagPlayerID(recData, playerID)
|
SetRecIsWin(recData, not isWin)
|
SetRecServerID(recData, curPlayer.GetServerID())
|
SetRecFace(recData, curPlayer.GetFace())
|
SetRecFacePic(recData, curPlayer.GetFacePic())
|
SetRecRealmLV(recData, curPlayer.GetOfficialRank())
|
SetRecLV(recData, curPlayer.GetLV())
|
# Ãû×Ö¡¢×Ô¼ºÃû´Î¡¢¶Ô·½Ãû´Î
|
recData.SetUserData({"Name":curPlayer.GetPlayerName(), "CurRank":tagRank, "TagRank":curRank})
|
return
|
|
def GetQunyingRankHighestAward(curPlayer):
|
rankHighest = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRankHighest)
|
awardRecord = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRankSuccAward)
|
if not rankHighest:
|
return
|
GameWorld.DebugLog("ÁìȡȺӢ°ñÀúÊ·×î¸ßÅÅÃû³É¾Í½±Àø! rankHighest=%s,awardRecord=%s" % (rankHighest, awardRecord))
|
# Ê״δﵽxÃû³É¾Í½±Àø {"Ãû´Î":[[ÎïÆ·ID, ¸öÊý], ...], ...}
|
rankAwardDict = IpyGameDataPY.GetFuncEvalCfg("QunyingAward", 3, {})
|
# Ê״δﵽxÃû³É¾Í½±Àø¼Ç¼Ë÷Òý {"Ãû´Î":¼Ç¼Ë÷Òý, ...}£¬¼Ç¼Ë÷Òý´Ó0¿ªÊ¼µÝÔö£¬ÉÏÏߺó²»ÄÜÐÞ¸Ä
|
rankIndexDict = IpyGameDataPY.GetFuncEvalCfg("QunyingAward", 4, {})
|
awardItemDict = {}
|
for rankStr, itemList in rankAwardDict.items():
|
rank = int(rankStr)
|
if rankHighest > rank:
|
GameWorld.DebugLog(" δ´ïµ½: rank=%s" % rank)
|
continue
|
if rankStr not in rankIndexDict:
|
continue
|
index = rankIndexDict[rankStr]
|
if awardRecord&pow(2, index):
|
GameWorld.DebugLog(" ÒÑÁìÈ¡: rank=%s" % rank)
|
continue
|
awardRecord |= pow(2, index)
|
for itemInfo in itemList:
|
itemID, itemCount = itemInfo[:2]
|
awardItemDict[itemID] = awardItemDict.get(itemID, 0) + itemCount
|
GameWorld.DebugLog(" ¿ÉÁìÈ¡: rank=%s,%s,%s" % (rank, itemList, awardItemDict))
|
awardItemList = [[itemID, itemCount] for itemID, itemCount in awardItemDict.items()]
|
|
GameWorld.DebugLog(" awardRecord=%s,awardRecord=%s" % (awardRecord, awardItemList))
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRankSuccAward, awardRecord)
|
ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["QunyingRankHighest", False, {}])
|
Sync_QunyingInfo(curPlayer) # Áì½±
|
return
|
|
def OnProcess(curPlayer):
|
CheckQunyingTicketRecover(curPlayer)
|
return
|
|
def CheckQunyingTicketRecover(curPlayer):
|
## ¼ì²éÌôÕ½Áî»Ö¸´
|
storeMax = IpyGameDataPY.GetFuncCfg("QunyingChallenge", 1)
|
curTicket = PlayerControl.GetMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket)
|
lastRecoverTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRecoverTime)
|
if curTicket >= storeMax:
|
if lastRecoverTime:
|
GameWorld.DebugLog("ȺӢÌôÕ½ÁîÒÑÂú!")
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRecoverTime, 0)
|
Sync_QunyingInfo(curPlayer) # ÌôÕ½Áî»Ö¸´Âú
|
return
|
|
curTime = int(time.time())
|
passSeconds = curTime - lastRecoverTime
|
if not lastRecoverTime or passSeconds < 0:
|
GameWorld.DebugLog("ÖØÉèȺӢÌôÕ½Áî»Ö¸´Ê±¼ä!")
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRecoverTime, curTime)
|
Sync_QunyingInfo(curPlayer)
|
return
|
|
cdSeconds = IpyGameDataPY.GetFuncCfg("QunyingChallenge", 2) * 60
|
if passSeconds < cdSeconds:
|
#GameWorld.DebugLog("ȺӢÌôÕ½Áî»Ö¸´CDÖÐ: passSeconds=%s < %s, lastRecoverTime=%s" % (passSeconds, cdSeconds, GameWorld.ChangeTimeNumToStr(lastRecoverTime)))
|
return
|
recoverCnt = passSeconds / cdSeconds
|
recoverCnt = min(recoverCnt, storeMax - curTicket)
|
updRecoverTime = curTime - passSeconds % cdSeconds
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRecoverTime, updRecoverTime)
|
GameWorld.DebugLog("»Ö¸´ÈºÓ¢ÌôÕ½Áî: %s,passSeconds=%s,Éϴλָ´:%s" % (recoverCnt, passSeconds, GameWorld.ChangeTimeNumToStr(lastRecoverTime)))
|
PlayerControl.GiveMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket, recoverCnt)
|
if PlayerControl.GetMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket) >= storeMax:
|
GameWorld.DebugLog("ÒÑÂú!")
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRecoverTime, 0)
|
Sync_QunyingInfo(curPlayer)
|
return
|
|
#// B2 10 ȺӢ°ñÆ¥ÅäÍæ¼Ò #tagCSQunyingMatch
|
#
|
#struct tagCSQunyingMatch
|
#{
|
# tagHead Head;
|
# BYTE IsRefresh; // 0-´ò¿ª½çÃæʱ²éѯ£¬1-Ç¿ÖÆË¢ÐÂÆ¥ÅäÁбí
|
#};
|
def OnQunyingMatch(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
isRefresh = clientData.IsRefresh
|
DoQunyingMatchRefresh(curPlayer, isRefresh)
|
return
|
|
def DoQunyingMatchRefresh(curPlayer, isRefresh, isSys=False):
|
## Íæ¼ÒË¢ÐÂÆ¥Åä¶ÔÊÖ
|
playerID = curPlayer.GetPlayerID()
|
GameWorld.DebugLog("ȺӢ°ñÍæ¼ÒË¢ÐÂÆ¥ÅäÁбí: isRefresh=%s,isSys=%s" % (isRefresh, isSys), playerID)
|
|
billboardMgr = DBDataMgr.GetBillboardMgr()
|
billBoard = billboardMgr.GetBillboard(ShareDefine.Def_BT_Qunying)
|
if not billBoard:
|
return
|
layerIDList = billBoard.GetLayerIDList()
|
idRankDict = billBoard.GetIDOrderDict()
|
layerIDCnt = len(layerIDList)
|
playerRank = idRankDict.get(playerID, layerIDCnt + 1) # δÉÏ°ñĬÈÏ×î´óÃû´Î + 1
|
|
# Æ¥Åä¶ÔÏ󻺴æ
|
if playerID not in PyGameData.g_qunyingPlayerMatchDict:
|
PyGameData.g_qunyingPlayerMatchDict[playerID] = []
|
matchRankList = PyGameData.g_qunyingPlayerMatchDict[playerID]
|
if not isRefresh and matchRankList:
|
# ·ÇˢеIJ¢ÇÒÒѾÓмǼµÄÖ±½Óͬ²½
|
GameWorld.DebugLog(" ·ÇË¢ÐÂÇÒÓÐÊý¾Ý£¬Ö±½Óͬ²½! matchRankList=%s" % matchRankList, playerID)
|
__SyncQunyingMatchList(curPlayer, matchRankList, layerIDList)
|
return
|
|
# Æ¥Åä¿ÉÌôսĿ±ê¹æÔò {Íæ¼ÒÃû´Î:[[Ãû´Î²îÖµ, Æ¥Åäx¸ö], ...], ...} Ãû´Î²îÖµÖ§³ÖÕý¸º
|
matchRuleDict = IpyGameDataPY.GetFuncEvalCfg("QunyingMatch", 1, {})
|
rankList = matchRuleDict.keys()
|
rankList.sort()
|
matchRuleList = []
|
for rank in rankList:
|
if playerRank <= rank:
|
matchRuleList = matchRuleDict[rank]
|
break
|
if not matchRuleList:
|
matchRuleList = matchRuleDict[rankList[-1]] # ûÓÐĬÈÏÈ¡×îºóÒ»µµ
|
|
matchRuleList.sort()
|
GameWorld.DebugLog(" layerIDCnt=%s,playerRank=%s,matchRuleList=%s" % (layerIDCnt, playerRank, matchRuleList), playerID)
|
if not matchRuleList:
|
return
|
|
if isRefresh and not isSys:
|
refreshMax = IpyGameDataPY.GetFuncCfg("QunyingMatch", 3)
|
if refreshMax:
|
refreshCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRefreshCnt)
|
if refreshCnt >= refreshMax:
|
GameWorld.DebugLog(" ÒÑ´ï×î´óˢдÎÊý! refreshCnt=%s >= %s" % (refreshCnt, refreshMax), playerID)
|
return
|
costMoney, moneyValue = IpyGameDataPY.GetFuncEvalCfg("QunyingMatch", 2)
|
if not costMoney or not moneyValue or not PlayerControl.PayMoney(curPlayer, costMoney, moneyValue, "Qunying"):
|
return
|
if refreshMax:
|
refreshCnt += 1
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRefreshCnt, refreshCnt)
|
Sync_QunyingInfo(curPlayer) # Ë¢ÐÂÆ¥Åä
|
|
matchRankList = [] # ÒòΪÓÐÌî³ä»úÆ÷ÈË£¬»úÆ÷ÈËID¿ÉÄÜÖظ´£¬¹Ì°´Ãû´ÎλÖÃÆ¥Åä [rank, ...]
|
if 1 <= playerRank <= layerIDCnt:
|
matchRankList.append(playerRank) # Íæ¼ÒÓÐÉÏ°ñʱĬÈÏÒª°üº¬Íæ¼Ò×Ô¼º
|
# [[Ãû´Î²îÖµ, Æ¥Åäx¸ö], ...]
|
# µÚÒ»ÃûʱƥÅäʾÀý: [[50, 4]]
|
# δÉÏ°ñʱƥÅäʾÀý£º[[-500, 5]]
|
# °ñµ¥ÖÐʱƥÅäʾÀý£º[[-300, 1], [-200, 1], [-100, 1],[100, 1]]
|
for mIndex, matchRule in enumerate(matchRuleList):
|
rankDiff, matchCnt = matchRule
|
nextDiff = None
|
if mIndex < len(matchRuleList) - 1:
|
nextDiff = matchRuleList[mIndex + 1][0]
|
|
if mIndex == 0:
|
if rankDiff >= 0: # µÚ1¸ö¾Í¿ªÊ¼Æ¥ÅäºóÃæµÄ£¬Ö±½Ó´ÓÍæ¼ÒºóÒ»Ãû¿ªÊ¼£¬·ñÔòÖ±½Ó´ÓÓëÍæ¼ÒÃû´ÎµÄ²îÖµ¿ªÊ¼
|
fromRank = playerRank + 1
|
else:
|
fromRank = playerRank + rankDiff
|
|
# ·Ç×îºóÒ»µµµÄÇé¿ö
|
if nextDiff != None:
|
if rankDiff < 0 and nextDiff >= 0:
|
toRank = playerRank - 1 # ²îÖµÕý¸º±ä¸ü£¬Ä¬ÈÏÒÔÍæ¼ÒÃû´Î·Öµµ
|
else:
|
toRank = fromRank + (nextDiff - rankDiff) - 1 # ~ ÓëÏÂÒ»µµµÄ²îÖµ
|
|
# ×îºóÒ»µµ
|
else:
|
if rankDiff < 0:
|
toRank = layerIDCnt
|
else:
|
toRank = fromRank + rankDiff - 1
|
|
fromRank = max(fromRank, 1)
|
toRank = min(toRank, layerIDCnt)
|
if fromRank > toRank:
|
GameWorld.ErrLog("Æ¥Åä¹æÔòÒì³£! mIndex=%s,fromRank=%s,toRank=%s,%s" % (mIndex, fromRank, toRank, matchRuleList))
|
break
|
|
randRankList = range(fromRank, toRank + 1)
|
random.shuffle(randRankList)
|
rankCnt = len(randRankList)
|
mCnt = 0
|
# ²»ÓÃÑé֤Ŀ±êID£¬ÔÊÐíÆ¥ÅäÖظ´µÄID£¬Ö»ÒªÆ¥ÅäµÄÄ¿±êÃû´Î²»Öظ´¼´¿É
|
for randRank in randRankList:
|
if randRank in matchRankList:
|
continue
|
tagID = layerIDList[randRank - 1]
|
GameWorld.DebugLog(" Æ¥ÅäÃû´Î: %s ~ %s,%sÃû,randRank=%s,tagID=%s" % (fromRank, toRank, rankCnt, randRank, tagID), playerID)
|
matchRankList.append(randRank)
|
mCnt += 1
|
if mCnt >= matchCnt:
|
break
|
|
if toRank == playerRank - 1:
|
fromRank = toRank + 2
|
else:
|
fromRank = toRank + 1
|
|
if fromRank > layerIDCnt:
|
break
|
|
matchRankList.sort()
|
GameWorld.DebugLog(" Æ¥ÅäÃû´Î½á¹û: matchRankList=%s" % (matchRankList), playerID)
|
PyGameData.g_qunyingPlayerMatchDict[playerID] = matchRankList
|
__SyncQunyingMatchList(curPlayer, matchRankList, layerIDList)
|
return
|
|
def __SyncQunyingMatchList(curPlayer, matchRankList, layerIDList):
|
## ͬ²½Æ¥ÅäÁбí
|
layerIDCnt = len(layerIDList)
|
clientPack = ChPyNetSendPack.tagSCQunyingMatchList()
|
clientPack.MatchList = []
|
for rank in matchRankList:
|
if rank <= 0 or rank > layerIDCnt:
|
continue
|
matchID = layerIDList[rank - 1]
|
viewCache = PlayerViewCache.FindBattleViewCache(matchID)
|
if not viewCache:
|
continue
|
matchInfo = ChPyNetSendPack.tagSCQunyingMatchInfo()
|
matchInfo.Rank = rank
|
matchInfo.PlayerID = matchID
|
if viewCache:
|
fightPower = TurnAttack.GetCacheLineupFightPower(viewCache, ShareDefine.BatPreset_QunyingDef)
|
matchInfo.PlayerName = viewCache.GetPlayerName()
|
matchInfo.RealmLV = viewCache.GetRealmLV()
|
matchInfo.LV = viewCache.GetLV()
|
matchInfo.Face = viewCache.GetFace()
|
matchInfo.FacePic = viewCache.GetFacePic()
|
matchInfo.FightPower = fightPower % ChConfig.Def_PerPointValue
|
matchInfo.FightPowerEx = fightPower / ChConfig.Def_PerPointValue
|
matchInfo.TitleID = viewCache.GetTitleID()
|
matchInfo.ModelMark = viewCache.GetModelMark()
|
matchInfo.EquipShowSwitch = viewCache.GetEquipShowSwitch()
|
matchInfo.ServerID = viewCache.GetServerID()
|
else:
|
matchInfo.PlayerName = "p%s" % matchID
|
clientPack.MatchList.append(matchInfo)
|
clientPack.MatchCount = len(clientPack.MatchList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
def Sync_QunyingInfo(curPlayer):
|
clientPack = ChPyNetSendPack.tagSCQunyingPlayerInfo()
|
clientPack.RefreshCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRefreshCnt)
|
clientPack.LastRecoverTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRecoverTime)
|
clientPack.RankHighest = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRankHighest)
|
clientPack.RankSuccAward = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRankSuccAward)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
