#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package GameWorldArena
|
#
|
# @todo:¾º¼¼³¡ - ±¾·þ
|
# @author hxp
|
# @date 2020-12-07
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: ¾º¼¼³¡ - ±¾·þ£¬OnWeekEx ÖØÖ㬿ª·þÇ°X¶¨ÖÆÌìÄڹ̶¨ÎªÒ»¸öÈü¼¾£¬ºÏ·þ²»´¦Àí
|
#
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2020-12-07 19:30"""
|
#-------------------------------------------------------------------------------
|
|
import GameWorld
|
import ShareDefine
|
import PlayerControl
|
import FormulaControl
|
import PlayerBillboard
|
import PlayerViewCache
|
import PlayerCompensation
|
import PlayerDBGSEvent
|
import ChPyNetSendPack
|
import DataRecordPack
|
import NetPackCommon
|
import IpyGameDataPY
|
import PyGameData
|
|
import random
|
import time
|
import json
|
|
MaxRobotID = 9900 # ×î´ó»úÆ÷ÈËID£¬²»³¬¹ý 9999
|
RandRobotID = 9000 # Ô¤Áô¸øËæ»ú»úÆ÷ÈËÓõÄÆðʼID£¬²»³¬¹ý MaxRobotID£¬ÇÒ (MaxRobotID - RandRobotID) ²»Äܳ¬¹ý MaxBattleRecCount
|
MaxBattleRecCount = 50 # Íæ¼Ò×î´ó¶ÔÕ½¼Ç¼±£´æÌõÊý
|
|
Def_RecType_ArenaBattleRecord = ShareDefine.Def_UniversalGameRecType_ArenaBattleRecord
|
|
## ¾º¼¼³¡Æ¥ÅäÍæ¼ÒÐÅÏ¢£¬½ö×öÄڴ滺´æ£¬²»×ö³Ö¾Ã»¯´æ´¢£¬ÖØÆô·þÎñÆ÷ʱЧ£¬Ï൱ÓÚά»¤·þÎñÆ÷ºóÍæ¼Ò¿ÉÃâ·ÑË¢ÐÂÒ»´Î
|
class ArenaMatchPlayer():
|
|
def __init__(self):
|
# name¡¢RealmLV¡¢FightPower ²»¼Ç¼£¬ÕæʵÍæ¼Ò¶Á²é¿´»º´æ£¬»úÆ÷ÈËÇ°¶Ë×ÔÐд¦Àí
|
# RealmLV ¶Á¾³½ç±í°´µÈ¼¶È¡¶ÔÓ¦¾³½ç
|
# FightPower È¡µÈ¼¶±íÈ¡¶ÔÓ¦²Î¿¼Õ½Á¦
|
self.ResetData()
|
return
|
|
def ResetData(self):
|
# Ë¢ÐÂÆ¥ÅäµÄʱºòÐèÒªÖØÖÃÏ£¬²»Öظ´´´½¨ÊµÀý
|
self.tagPlayerID = 0 # СÓÚ10000µÄΪ»úÆ÷ÈËID
|
self.tagLV = 0
|
self.tagJob = 0
|
self.tagScore = 0
|
return
|
|
class ArenaBattleRec():
|
''' ¾º¼¼³¡¶ÔÕ½¼Ç¼Êý¾Ý
|
¶îÍâ˵Ã÷£º
|
ÒòΪÓÐÖ÷¶¯¶ÔÕ½µÄ²Å»áÉÏ°ñ£¬¶øÖ»ÓжÔÕ½¹ýµÄµÄ²Å»á±»Æ¥Åäµ½£¬ËùÒÔ¿ÉÈÏΪֻҪÓжÔÕ½¼Ç¼£¬×îºóÒ»Ìõ¼Ç¼¼´Îª×îеÄÊý¾Ý¼Ç¼
|
Òò´Ë¿ÉÒÔÓÃÀ´´æ´¢×ÔÉíÏà¹ØµÄÊý¾Ý£¬¿ÉÓÃÓÚÀëÏß±»±ðÈËÆ¥Å䵽ʱÔÝ´æÊý¾ÝÓã¬ÉÏÏߺóÈ¡×îºóÒ»Ìõ¶ÔÕ½¼Ç¼¸üÐÂÊý¾Ý
|
'''
|
|
def __init__(self, playerID):
|
self.playerID = playerID
|
# name¡¢RealmLV¡¢FightPower ²»¼Ç¼£¬ÕæʵÍæ¼Ò¶Á²é¿´»º´æ£¬»úÆ÷ÈËÇ°¶Ë×ÔÐд¦Àí
|
# RealmLV ¶Á¾³½ç±í°´µÈ¼¶È¡¶ÔÓ¦¾³½ç
|
# FightPower È¡µÈ¼¶±íÈ¡¶ÔÓ¦²Î¿¼Õ½Á¦
|
self.tagPlayerID = 0 # СÓÚ10000µÄΪ»úÆ÷ÈËID
|
self.tagLV = 0
|
self.tagJob = 0
|
self.tagScore = 0
|
|
self.addScore = 0
|
self.isWin = 0
|
self.battleTime = 0
|
|
# ¶îÍâ´æ´¢µÄ¸öÈ˼Ǽ
|
self.isDispose = 0 # ÊÇ·ñÒѾ´¦Àí¹ý¸Ã¼Ç¼£¬ÀëÏß/ÍÑ»ú±»Ìôսʱ£¬ÔÝʱΪδ´¦Àí£¬ÉÏÏߺóͬ²½´¦Àí
|
self.updScore = 0
|
return
|
|
''' ¶ÔÕ½¼Ç¼ ShareDefine.Def_UniversalGameRecType_ArenaBattleRecord
|
value1 playerID Íæ¼ÒID
|
value2 tagPlayerID Ä¿±êÍæ¼ÒID£¬Ð¡ÓÚ10000Ϊ»úÆ÷ÈË
|
value3 tagLVJob Ä¿±êµÈ¼¶Ö°Òµ£¬Ò»°ã»úÆ÷ÈËʱÓÐÓà lv*10 + job
|
value4 tagScore Ä¿±ê»ý·Ö£¬·Çʵʱ»ý·Ö£¬Ò»°ã»úÆ÷ÈËʱÓÐÓÃ
|
strValue1 resultInfo isWin,addScore
|
strValue2 updInfo isDispose,updScore
|
'''
|
|
''' °ñµ¥Êý¾Ý '''
|
def GetArenaBillID(billData): return billData.GetID()
|
def GetArenaBillName(billData): return billData.GetName1()
|
def SetArenaBillName(billData, name): return billData.SetName1(name)
|
def GetArenaBillJob(billData): return billData.GetType2()
|
def GetArenaBillRealmLV(billData): return billData.GetValue1()
|
def SetArenaBillRealmLV(billData, realmLV): return billData.SetValue1(realmLV)
|
def GetArenaBillLV(billData): return billData.GetValue2()
|
def SetArenaBillLV(billData, lv): billData.SetValue2(lv)
|
def GetArenaBillScore(billData): return billData.GetCmpValue()
|
def SetArenaBillScore(billData, score): return billData.SetCmpValue(score)
|
def GetArenaBillFightPower(billData): return billData.GetCmpValue2() * ShareDefine.Def_PerPointValue + billData.GetCmpValue3()
|
def SetArenaBillFightPower(billData, fightPower):
|
billData.SetCmpValue2(fightPower / ShareDefine.Def_PerPointValue)
|
billData.SetCmpValue3(fightPower % ShareDefine.Def_PerPointValue)
|
return
|
|
def RepairArenaBillboardFightPower():
|
## ÐÞÕý¾º¼¼³¡°ñµ¥µÄÕ½Á¦Êý¾Ý£¬Ö§³Ö20ÒÚ£¬bt3_1.100.1 Ï´δó°æ±¾¸üкó¿Éɾ³ý
|
|
repairStateKey = "RepairArenaBillboardFightPower"
|
repairState = PlayerDBGSEvent.GetDBGSTrig_ByKey(repairStateKey)
|
if repairState:
|
GameWorld.DebugLog("=== ÒѾÐÞÕý¾º¼¼³¡°ñµ¥Êý¾Ý ===")
|
return
|
|
GameWorld.Log("=== ÐÞÕý¾º¼¼³¡°ñµ¥Êý¾Ý Start ===")
|
|
worldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ArenaWorldLV, worldLV)
|
GameWorld.Log(" SetDBGSTrig_ByKey %s=%s" % (PlayerDBGSEvent.Def_ArenaWorldLV, worldLV))
|
|
robotMaxCount = IpyGameDataPY.GetFuncCfg("ArenaRobot", 1)
|
__RandRobotLVList(robotMaxCount)
|
GameWorld.Log(" PyGameData.g_arenaRobotLVList len=%s, %s" % (len(PyGameData.g_arenaRobotLVList), PyGameData.g_arenaRobotLVList))
|
|
billBoard = GameWorld.GetBillboard().FindBillboard(ShareDefine.Def_BT_Arena)
|
if not billBoard:
|
return
|
|
for index in xrange(billBoard.GetCount()):
|
|
order = index + 1
|
billBoardData = billBoard.At(index)
|
if not billBoardData:
|
continue
|
|
playerID = billBoardData.GetID()
|
fightPower = billBoardData.GetCmpValue2() # ¾ÉÕ½Á¦Ö»´æÔڱȽÏÖµ2
|
|
if playerID <= MaxRobotID:
|
curLV = GetArenaBillLV(billBoardData)
|
updLV = curLV
|
if index < len(PyGameData.g_arenaRobotLVList):
|
updLV = PyGameData.g_arenaRobotLVList[index]
|
GameWorld.Log(" ÐÞÕý»úÆ÷È˵ȼ¶: order=%s,playerID=%s,curLV=%s,updLV=%s"
|
% (order, playerID, curLV, updLV))
|
SetArenaBillLV(billBoardData, updLV)
|
SetArenaBillFightPower(billBoardData, 0)
|
continue
|
|
curCache = PlayerViewCache.FindViewCache(playerID)
|
if curCache:
|
cacheDict = PlayerViewCache.GetCachePropDataDict(curCache)
|
fightPower = cacheDict["FightPower"]
|
|
SetArenaBillFightPower(billBoardData, fightPower)
|
GameWorld.Log(" ÐÞÕýÕæÍæ¼ÒÕ½Á¦: order=%s,playerID=%s,fightPower=%s,cmpValue2=%s,cmpValue3=%s"
|
% (order, playerID, fightPower, billBoardData.GetCmpValue2(), billBoardData.GetCmpValue3()))
|
|
billBoard.Sort()
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(repairStateKey, 1)
|
GameWorld.Log("=== ÐÞÕý¾º¼¼³¡°ñµ¥µÄÕ½Á¦Êý¾Ý OK ===")
|
return
|
|
def OnServerStart():
|
universalRecMgr = GameWorld.GetUniversalRecMgr()
|
recDataList = universalRecMgr.GetTypeList(Def_RecType_ArenaBattleRecord)
|
GameWorld.Log("¿ª·þ¼ÓÔر¾·þ¾º¼¼³¡¶ÔÕ½¼Ç¼! %s" % recDataList.Count())
|
for index in xrange(recDataList.Count()):
|
recData = recDataList.At(index)
|
playerID = recData.GetValue1()
|
|
battleRec = ArenaBattleRec(playerID)
|
battleRec.battleTime = recData.GetTime()
|
battleRec.tagPlayerID = recData.GetValue2()
|
battleRec.tagLV = recData.GetValue3() / 10
|
battleRec.tagJob = recData.GetValue3() % 10
|
battleRec.tagScore = recData.GetValue4()
|
|
strValue1 = recData.GetStrValue1()
|
resultInfo = strValue1.split(",") if strValue1 else []
|
battleRec.isWin = int(resultInfo[0] if len(resultInfo) > 0 else 0)
|
battleRec.addScore = int(resultInfo[1] if len(resultInfo) > 1 else 0)
|
|
strValue2 = recData.GetStrValue2()
|
updInfo = strValue2.split(",") if strValue2 else []
|
battleRec.isDispose = int(updInfo[0] if len(updInfo) > 0 else 0)
|
battleRec.updScore = int(updInfo[1] if len(updInfo) > 1 else 0)
|
|
battleRecList = GetPlayerArenaBattleRecList(playerID)
|
battleRecList.append(battleRec)
|
|
GameWorld.DebugLog(" ¼ÓÔØÍæ¼Ò¶ÔÕ½¼Ç¼: playerID=%s, |%s| %s" % (playerID, strValue1, json.dumps(battleRec , default=lambda obj:obj.__dict__)))
|
|
|
OSSeasonState = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ArenaOSSeasonState)
|
if not OSSeasonState and __DoArenaSeasonReset("OnServerStart"):
|
pass
|
|
# ûÓÐÖØÖà »ò ÖØÖÃʧ°Ü ²Å´¦ÀíÒÔÏÂÄÚÈÝ
|
else:
|
billBoard = GameWorld.GetBillboard().FindBillboard(ShareDefine.Def_BT_Arena)
|
if billBoard:
|
# ÓÐÊý¾ÝµÄ»°ÉèÖñ¾¹¦ÄÜÅäÖõÄ×î´ó°ñµ¥Êý
|
if billBoard.GetCount() > 0:
|
robotMaxCount = IpyGameDataPY.GetFuncCfg("ArenaRobot", 1)
|
PlayerBillboard.UpdateBillboardMaxCount(ShareDefine.Def_BT_Arena, robotMaxCount)
|
__RandRobotLVList(robotMaxCount)
|
else:
|
__ResetArenaRobotBillboard()
|
|
RepairArenaBillboardFightPower()
|
return
|
|
def OnServerClose():
|
universalRecMgr = GameWorld.GetUniversalRecMgr()
|
universalRecMgr.Delete(Def_RecType_ArenaBattleRecord)
|
|
GameWorld.Log("¹Ø·þ±£´æ±¾·þ¾º¼¼³¡¼Ç¼! %s" % len(PyGameData.g_arenaPlayerBattleRecDict))
|
recDataList = universalRecMgr.GetTypeList(Def_RecType_ArenaBattleRecord)
|
for battleRecList in PyGameData.g_arenaPlayerBattleRecDict.values():
|
for battleRec in battleRecList:
|
recData = recDataList.AddRec()
|
recData.SetTime(battleRec.battleTime)
|
|
recData.SetValue1(battleRec.playerID)
|
recData.SetValue2(battleRec.tagPlayerID)
|
recData.SetValue3(battleRec.tagLV * 10 + battleRec.tagJob)
|
recData.SetValue4(battleRec.tagScore)
|
|
recData.SetStrValue1("%s,%s" % (int(battleRec.isWin), battleRec.addScore))
|
recData.SetStrValue2("%s,%s" % (int(battleRec.isDispose), battleRec.updScore))
|
|
return
|
|
def GetPlayerArenaBattleRecList(playerID):
|
## »ñÈ¡Íæ¼Ò¶ÔÕ½¼Ç¼Áбí
|
if playerID not in PyGameData.g_arenaPlayerBattleRecDict:
|
PyGameData.g_arenaPlayerBattleRecDict[playerID] = []
|
return PyGameData.g_arenaPlayerBattleRecDict[playerID]
|
|
def IsArenaBattlePlayer(playerID): return playerID in PyGameData.g_arenaPlayerBattleRecDict
|
|
def SendMapServerArenaInfo():
|
## ֪ͨµØͼÐÅÏ¢
|
|
return
|
|
def OnPlayerLogin(curPlayer):
|
## Íæ¼ÒµÇ¼
|
|
if PlayerControl.GetIsTJG(curPlayer):
|
return
|
|
playerID = curPlayer.GetPlayerID()
|
curBattleRecList = GetPlayerArenaBattleRecList(playerID)
|
|
updScore = None
|
# µ¹Ðò±éÀú
|
for battleRec in curBattleRecList[::-1]:
|
if battleRec.isDispose:
|
continue
|
battleRec.isDispose = 1
|
|
if updScore == None:
|
updScore = battleRec.updScore # Ö»¸üÐÂÒ»´Î£¬¼´×îºóÒ»Ìõ¼Ç¼
|
|
if updScore != None:
|
__SyncPlayerBechallengedUpdScore(curPlayer, updScore)
|
|
return
|
|
def OnDayEx():
|
|
# ÏÈ´¦ÀíÿÈÕ½áËã
|
__DoGiveBillboardAward("Day")
|
|
customMaxServerDay = IpyGameDataPY.GetFuncCfg("OperationAction", 1)
|
openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1
|
if openServerDay <= customMaxServerDay:
|
GameWorld.Log("OnDayExʱ¾º¼¼³¡¿ª·þ¶¨ÖÆÈü¼¾½øÐÐÖУ¬²»´¦Àí! openServerDay=%s <= %s" % (openServerDay, customMaxServerDay))
|
return
|
|
# ¾º¼¼³¡¿ª·þÇ°¶¨ÖÆXÌìÈü¼¾×´Ì¬ 0-δ±ÈÈü¹ý£¬1-½øÐÐÖУ¬>1½áËãʱµÄ¿ª·þÌì
|
OSSeasonState = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ArenaOSSeasonState)
|
if OSSeasonState > 1:
|
GameWorld.Log("OnDayExʱ¾º¼¼³¡¿ª·þ¶¨ÖÆÈü¼¾ÒѽáËã¹ý£¬²»´¦Àí! OSSeasonState=%s" % (OSSeasonState))
|
return
|
|
__DoArenaSeasonReset("OpenServerSeason")
|
return
|
|
def OnWeekEx():
|
customMaxServerDay = IpyGameDataPY.GetFuncCfg("OperationAction", 1)
|
openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1
|
if openServerDay <= customMaxServerDay:
|
GameWorld.Log("OnWeekExʱÔÚ¿ª·þ¶¨ÖÆÌìÄÚ£¬²»´¦Àí¾º¼¼³¡Èü¼¾ÖØÖÃ! openServerDay=%s <= %s" % (openServerDay, customMaxServerDay))
|
return
|
|
OSSeasonState = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ArenaOSSeasonState)
|
if not OSSeasonState or OSSeasonState == 1 or OSSeasonState == openServerDay:
|
GameWorld.Log("OnWeekExʱ¾º¼¼³¡¿ª·þ¶¨ÖÆÈü¼¾½øÐÐÖлòͬһÌì½áË㣬²»´¦ÀíÖØÖÃ! openServerDay=%s,OSSeasonState=%s" % (openServerDay, OSSeasonState))
|
return
|
|
__DoArenaSeasonReset("OnWeekExSeason")
|
return
|
|
def __DoArenaSeasonReset(resetName):
|
''' Èü¼¾ÖØÖÃ
|
Èü¼¾¹æÔò£ºÇ°¶¨ÖÆÔËÓª×î´ó¿ª·þÌìΪһ¸öÈü¼¾£¬ºóÐø°´ OnWeekEx ÖØÖÃ
|
'''
|
|
openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1
|
OSSeasonState = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ArenaOSSeasonState)
|
worldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)
|
GameWorld.Log("ÖØÖþº¼¼³¡! resetName=%s,openServerDay=%s,OSSeasonState=%s,worldLV=%s"
|
% (resetName, openServerDay, OSSeasonState, worldLV))
|
|
customMaxServerDay = IpyGameDataPY.GetFuncCfg("OperationAction", 1)
|
if openServerDay <= customMaxServerDay and OSSeasonState != 0:
|
GameWorld.Log("¿ª·þ¶¨ÖÆÌìÄÚ²»ÄÜÖØÖã¡")
|
return
|
|
# ½áËãÉÏÈü¼¾ÅÅÐн±Àø
|
__DoGiveBillboardAward("Week")
|
|
# ÖØÖÃÅÅÐаñ
|
__ResetArenaRobotBillboard()
|
|
# ɾ³ý¶ÔÕ½¼Ç¼
|
GameWorld.GetUniversalRecMgr().Delete(Def_RecType_ArenaBattleRecord)
|
PyGameData.g_arenaPlayerBattleRecDict = {}
|
PyGameData.g_arenaPlayerMatchDict = {}
|
|
# ¸üÐÂÐÂÈü¼¾ÐÅÏ¢
|
if openServerDay <= customMaxServerDay and OSSeasonState == 0:
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ArenaOSSeasonState, 1)
|
else:
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ArenaOSSeasonState, customMaxServerDay + 1)
|
|
# ×îºó֪ͨµØͼÐÂÈü¼¾ÐÅÏ¢
|
SendMapServerArenaInfo()
|
GameWorld.Log("=============== ÖØÖþº¼¼³¡OK ===============")
|
return True
|
|
def __ResetArenaRobotBillboard():
|
## ÖØÖþº¼¼³¡»úÆ÷ÈËÅÅÐаñ£¬Èü¼¾ÖØÖÃʱ »ò Æô¶¯·þÎñÆ÷ʱ°ñµ¥Êý¾ÝΪ¿Õ£¨ºÏ·þÊ×´ÎÆô¶¯£©
|
|
# Çå³ý°ñµ¥
|
billBoard = GameWorld.GetBillboard().FindBillboard(ShareDefine.Def_BT_Arena)
|
if not billBoard:
|
return
|
billBoard.Clear()
|
robotMaxCount = IpyGameDataPY.GetFuncCfg("ArenaRobot", 1)
|
GameWorld.Log(" ÖØÖóõʼ»¯¾º¼¼³¡»úÆ÷ÈË°ñµ¥! robotMaxCount=%s" % robotMaxCount)
|
PlayerBillboard.UpdateBillboardMaxCount(ShareDefine.Def_BT_Arena, robotMaxCount)
|
|
PyGameData.g_arenaRobotLVList = []
|
worldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ArenaWorldLV, worldLV)
|
GameWorld.Log(" worldLV=%s" % worldLV)
|
|
# »ñÈ¡»úÆ÷ÈËËæ»úµÈ¼¶¡¢»ý·ÖÁбí
|
robotLVList = __RandRobotLVList(robotMaxCount)
|
robotScoreList = __RandRobotScoreList(robotMaxCount)
|
|
GameWorld.Log(" robotLVList: %s, %s" % (len(robotLVList), robotLVList))
|
GameWorld.Log(" robotScoreList: %s, %s" % (len(robotScoreList), robotScoreList))
|
|
openJobList = IpyGameDataPY.GetFuncEvalCfg("OpenJob", 1)
|
# »úÆ÷È˲åÈë°ñµ¥£¬µ¹Ðò²åÈ룬²»ÓÃÅÅÐò
|
robotID = 0
|
for i in xrange(robotMaxCount - 1, -1, -1):
|
robotLV = robotLVList[i]
|
robotScore = robotScoreList[i]
|
robotID += 1
|
robotName = "" # ¹Ì¶¨£¬Ç°¶Ë×ÔÐÐÏÔʾ
|
opInfo = ""
|
robotJob = random.choice(openJobList) # Ëæ»ú¿ª·ÅµÄÖ°Òµ
|
robotRealmLV = 0 # Ç°¶Ë ¶Á¾³½ç±íÈ¡µÈ¼¶¶ÔÓ¦¾³½ç
|
robotFightPower = 0 # Ç°¶Ë ¶ÁµÈ¼¶±íÈ¡µÈ¼¶¶ÔÓ¦Õ½Á¦
|
|
type2 = robotJob
|
value1 = robotRealmLV
|
value2 = robotLV
|
cmpValue = robotScore
|
cmpValue2 = robotFightPower / ShareDefine.Def_PerPointValue
|
cmpValue3 = robotFightPower % ShareDefine.Def_PerPointValue
|
PlayerBillboard.UpdatePlayerBillboard(robotID, robotName, opInfo, ShareDefine.Def_BT_Arena, type2, value1, value2, cmpValue, autoSort=False, cmpValue2=cmpValue2, cmpValue3=cmpValue3)
|
|
billBoard.Sort()
|
return
|
|
def __RandRobotLVList(robotMaxCount):
|
''' Ëæ»ú»úÆ÷È˵ȼ¶
|
@param robotMaxCount: »úÆ÷ÈËÊýÁ¿
|
@return: ÉýÐòÅźõĻúÆ÷È˵ȼ¶Áбí
|
'''
|
|
robotMinLV, robotMaxLV = __GetRobotLVRange()
|
|
# ÄѶȵȼ¶²½³¤£¬ÎªÁËÄѶȵÝÔöʱ£¬µÈ¼¶¿´ÆðÀ´ÂÒÒ»µã£¬ÓÖÄÜÈ·±£ÄѶȵÝÔö£¬ËùÒÔ¼ÓÈë´Ë¸ÅÄî
|
difficultLVStep = IpyGameDataPY.GetFuncCfg("ArenaRobot", 4)
|
|
lvList = []
|
lvCount = robotMaxLV - robotMinLV + 1 # µÈ¼¶²îÖµÊýÁ¿
|
lvAvg = lvCount / float(robotMaxCount) # È˾ùµÈ¼¶
|
oneLVRobotCount = 1 / lvAvg # 1¸öµÈ¼¶ÀíÂÛÉÏÓм¸¸ö»úÆ÷ÈË
|
|
minLV = 0
|
difficultRobotCountEx = 0
|
for lv in xrange(robotMinLV, robotMaxLV + difficultLVStep, difficultLVStep):
|
if lv >= robotMaxLV:
|
break
|
if minLV == 0:
|
minLV = lv
|
maxLV = lv + difficultLVStep - 1
|
|
difficultRobotCount = oneLVRobotCount * difficultLVStep + difficultRobotCountEx # ͬ¸öÄѶȵȼ¶»úÆ÷ÈË×ÜÊý
|
difficultRobotCountEx = difficultRobotCount % 1
|
|
if difficultRobotCount < 1:
|
continue
|
|
for _ in xrange(int(difficultRobotCount)):
|
lvList.append(random.randint(minLV, maxLV))
|
|
minLV = 0
|
|
if len(lvList) > robotMaxCount:
|
lvList = lvList[:robotMaxCount]
|
else:
|
# Èç¹û»¹²»¹»£¬Ö±½ÓÓÃ×îºóÒ»¸öÄѶȲ¹×ãÈËÊý
|
while len(lvList) < robotMaxCount:
|
lvList.append(random.randint(robotMaxLV - difficultLVStep, robotMaxLV))
|
|
lvList[0] = robotMinLV
|
lvList[-1] = robotMaxLV
|
PyGameData.g_arenaRobotLVList = sorted(lvList, reverse=True)
|
return lvList
|
|
def __GetRobotLVRange():
|
## »ñÈ¡Èü¼¾»úÆ÷È˵ȼ¶·¶Î§
|
worldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ArenaWorldLV)
|
worldLV = max(1, worldLV)
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
maxCnt = ipyDataMgr.GetWorldLVCount()
|
worldLVTime = 0
|
if worldLV <= maxCnt:
|
worldLVIpyData = ipyDataMgr.GetWorldLVByIndex(worldLV - 1)
|
worldLVTime = worldLVIpyData.GetOpenServerSecond()
|
|
minLV, maxLV = IpyGameDataPY.GetFuncEvalCfg("ArenaRobot", 2) # »úÆ÷ÈË×îС¡¢×î´óµÈ¼¶
|
|
robotMaxLV = minLV
|
maxWorldLVTime = eval(IpyGameDataPY.GetFuncCfg("ArenaRobot", 3))
|
for i in xrange(worldLV - 1, maxCnt):
|
ipyData = ipyDataMgr.GetWorldLVByIndex(i)
|
if i == maxCnt - 1:
|
robotMaxLV = ipyData.GetWorldLV()
|
else:
|
nextIpyData = IpyGameDataPY.IPY_Data().GetWorldLVByIndex(i + 1)
|
if ipyData.GetOpenServerSecond() <= maxWorldLVTime < nextIpyData.GetOpenServerSecond():
|
robotMaxLV = ipyData.GetWorldLV()
|
break
|
|
robotMaxLV = max(minLV, min(maxLV, robotMaxLV))
|
GameWorld.Log(" »úÆ÷È˵ȼ¶·¶Î§: worldLV=%s,worldLVTime=%s,maxWorldLVTime=%s,minLV=%s,robotMaxLV=%s"
|
% (worldLV, worldLVTime, maxWorldLVTime, minLV, robotMaxLV))
|
return minLV, robotMaxLV
|
|
def __RandRobotScoreList(robotMaxCount):
|
''' Ëæ»ú»úÆ÷ÈË»ý·Ö
|
@param minScore: »úÆ÷ÈË×îС»ý·Ö
|
@param maxScore: »úÆ÷ÈË×î´ó»ý·Ö
|
@param robotMaxCount: »úÆ÷ÈËÊýÁ¿
|
@return: ÉýÐòÅźõĻúÆ÷ÈË»ý·ÖÁбí
|
'''
|
|
minScore, maxScore = IpyGameDataPY.GetFuncEvalCfg("ArenaSet", 1)
|
|
scoreCount = maxScore - minScore + 1 # »ý·Ö²îÖµÊýÁ¿
|
scoreAvg = scoreCount / float(robotMaxCount) # È˾ù»ý·Ö
|
|
oneScoreRobotCount = 1 / scoreAvg # 1¸ö»ý·ÖÀíÂÛÉÏÓм¸¸ö»úÆ÷ÈË
|
|
scoreList = []
|
minS = 0
|
robotCountEx = 0
|
for score in xrange(minScore, maxScore + 1):
|
if minS == 0:
|
minS = score
|
|
robotCount = oneScoreRobotCount * 1 + robotCountEx
|
robotCountEx = robotCount % 1
|
|
if robotCount < 1:
|
continue
|
|
for _ in xrange(int(robotCount)):
|
if minS == score:
|
scoreList.append(score)
|
else:
|
scoreList.append(random.randint(minS, score))
|
minS = 0
|
|
if len(scoreList) > robotMaxCount:
|
scoreList = scoreList[:robotMaxCount]
|
else:
|
# Èç¹û»¹²»¹»£¬Ö±½ÓÓÃ×îºóÒ»¸öÄѶȲ¹×ãÈËÊý
|
while len(scoreList) < robotMaxCount:
|
scoreList.append(maxScore)
|
|
scoreList[0] = minScore
|
scoreList[-1] = maxScore
|
scoreList.sort()
|
return scoreList
|
|
def __DoGiveBillboardAward(awardType):
|
## ¾º¼¼³¡½áËãÅÅÐн±Àø£¬ ÿÈÕ¡¢Èü¼¾Í¨ÓÃ
|
|
GameWorld.Log("=== ¾º¼¼³¡½áËãÅÅÐн±Àø! === %s" % awardType)
|
|
billBoard = GameWorld.GetBillboard().FindBillboard(ShareDefine.Def_BT_Arena)
|
if not billBoard:
|
return
|
|
if awardType == "Day":
|
billboradAwardDict = IpyGameDataPY.GetFuncEvalCfg("ArenaBillboradAward", 1, {})
|
floorAwardList = IpyGameDataPY.GetFuncEvalCfg("ArenaBillboradAward", 2)
|
elif awardType == "Week":
|
billboradAwardDict = IpyGameDataPY.GetFuncEvalCfg("ArenaBillboradAward", 3, {})
|
floorAwardList = IpyGameDataPY.GetFuncEvalCfg("ArenaBillboradAward", 4)
|
else:
|
return
|
|
orderList = []
|
for orderStr in billboradAwardDict.keys():
|
orderList.append(int(orderStr))
|
orderList.sort()
|
GameWorld.Log(" ½±ÀøÃû´ÎÁбí: %s" % orderList)
|
|
awardOrder = orderList[0]
|
orderPlayerIDDict = {}
|
billboardCount, billboardMaxCount = billBoard.GetCount(), billBoard.GetMaxCount()
|
GameWorld.Log(" °ñµ¥Êý¾ÝÊý! billboardCount=%s,billboardMaxCount=%s" % (billboardCount, billboardMaxCount))
|
for index in xrange(billboardCount):
|
billBoardData = billBoard.At(index)
|
if not billBoardData:
|
continue
|
order = index + 1
|
|
if order > awardOrder:
|
nextOrderIndex = orderList.index(awardOrder) + 1
|
if nextOrderIndex >= len(orderList):
|
break
|
awardOrder = orderList[nextOrderIndex]
|
|
playerID = billBoardData.GetID()
|
if playerID <= MaxRobotID:
|
# »úÆ÷È˲»´¦Àí
|
continue
|
|
#playerName = billBoardData.GetName1()
|
orderPlayerIDDict[playerID] = [order, awardOrder]
|
|
awardList = billboradAwardDict[str(awardOrder)]
|
PlayerCompensation.SendMailByKey("ArenaBillboardAward%s" % awardType, [playerID], awardList, [order])
|
|
GameWorld.Log(" ½±ÀøÍæ¼ÒÃû´ÎÐÅÏ¢: %s" % orderPlayerIDDict)
|
|
# ÆäËûµÄ»ñµÃ±£µ×½±Àø
|
orderPlayerIDList = orderPlayerIDDict.keys()
|
floorPlayerIDList = []
|
for playerID, battleRecList in PyGameData.g_arenaPlayerBattleRecDict.items():
|
if playerID in orderPlayerIDList:
|
continue
|
if not battleRecList:
|
#GameWorld.DebugLog("ûÓжÔÕ½¼Ç¼µÄ²»·¢! ", playerID)
|
continue
|
floorPlayerIDList.append(playerID)
|
PlayerCompensation.SendMailByKey("ArenaFloorAward%s" % awardType, [playerID], floorAwardList)
|
|
GameWorld.Log(" ½±Àø±£µ×Íæ¼ÒÐÅÏ¢: %s" % floorPlayerIDList)
|
return
|
|
def MapServer_Arena(curPlayer, msgList):
|
GameWorld.DebugLog("MapServer_Arena %s" % str(msgList), curPlayer.GetPlayerID())
|
if not msgList:
|
return
|
|
cmd = msgList[0]
|
cmdDict = msgList[1] if len(msgList) > 1 else {}
|
retDict = {}
|
|
# Æ¥ÅäË¢ÐÂ
|
if cmd == "MatchRefresh":
|
__DoArenaMatchRefresh(curPlayer, cmdDict["isRefresh"], cmdDict["playerLV"], cmdDict["playerScore"], cmdDict.get("gmMatchIDList"))
|
|
# ¶ÔÕ½½áËã
|
elif cmd == "BattleResult":
|
retDict = __DoArenaBattleResult(curPlayer, cmdDict)
|
|
return msgList + [retDict]
|
|
def __DoArenaMatchRefresh(curPlayer, isRefresh, playerLV, playerScore, gmMatchIDList=None):
|
## Íæ¼ÒË¢ÐÂÆ¥Åä¶ÔÊÖ
|
|
playerID = curPlayer.GetPlayerID()
|
higherOrderPerList = IpyGameDataPY.GetFuncEvalCfg("ArenaMatch", 1)
|
lowerOrderPerList = IpyGameDataPY.GetFuncEvalCfg("ArenaMatch", 2)
|
|
GameWorld.DebugLog("¾º¼¼³¡Íæ¼ÒË¢ÐÂÆ¥ÅäÁбí: isRefresh=%s,playerLV=%s,playerScore=%s" % (isRefresh, playerLV, playerScore), playerID)
|
GameWorld.DebugLog(" higherOrderPerList=%s,lowerOrderPerList=%s" % (higherOrderPerList, lowerOrderPerList), playerID)
|
|
# Æ¥Åä¶ÔÏ󻺴æ
|
needMatchCount = len(higherOrderPerList) + len(lowerOrderPerList)
|
#GameWorld.DebugLog(" Æ¥Å仺´æ: %s" % PyGameData.g_arenaPlayerMatchDict, playerID)
|
if playerID not in PyGameData.g_arenaPlayerMatchDict:
|
PyGameData.g_arenaPlayerMatchDict[playerID] = []
|
matchList = PyGameData.g_arenaPlayerMatchDict[playerID]
|
if len(matchList) > needMatchCount:
|
matchList = matchList[:needMatchCount] # ɾ³ý¶àÓàµÄ¸öÊý£¬Ò»°ã¶¼ÊÇÏàͬµÄ£¬³ý·ÇÐÞ¸ÄÆ¥ÅäÊýÖضÁÅäÖÃ
|
if not isRefresh and len(matchList) == needMatchCount:
|
# ·ÇˢеIJ¢ÇÒÒѾÓмǼµÄÖ±½Óͬ²½
|
GameWorld.DebugLog(" ·ÇË¢ÐÂÇÒÓÐÊý¾Ý£¬Ö±½Óͬ²½£¡", playerID)
|
__SyncMatchList(curPlayer, matchList)
|
return
|
|
#maxOrder = IpyGameDataPY.GetFuncCfg("ArenaRobot", 1) # ÕâÀï²»¶ÁÅäÖã¬Ö±½ÓʹÓðñµ¥Êý
|
billBoard = GameWorld.GetBillboard().FindBillboard(ShareDefine.Def_BT_Arena)
|
if not billBoard:
|
return
|
playerOrder = billBoard.IndexOfByID(playerID) + 1 # Íæ¼ÒÔÚÅÅÐаñÖеÄÃû´Î£¬Ã»ÓÐÃû´ÎΪ-1
|
maxOrder = billBoard.GetCount()
|
if playerOrder <= 0:
|
playerOrder = maxOrder + 1
|
|
GameWorld.DebugLog(" maxOrder=%s,playerOrder=%s" % (maxOrder, playerOrder), playerID)
|
highRandOrder, lowRandOrder = IpyGameDataPY.GetFuncEvalCfg("ArenaMatch", 5) # Ç°XÃûÆ¥Åä±È×Ô¼º¸ßÃû´Îʱֱ½ÓËæ»ú
|
matchOrderList = [] # Æ¥Åäµ½µÄÃû´Î
|
# ·ÇµÚÒ»ÃûµÄÆ¥Åä±È×ÔÉíÃû´Î¸ßµÄ
|
if playerOrder > 1 and higherOrderPerList:
|
higherOrderCount = playerOrder - 1 # ±ÈÍæ¼Ò¸ßµÄÃû´ÎµÄ¸öÊý
|
# СÓÚ10¸öµÄÖ±½Ó´¿Ëæ»ú
|
if 0 < higherOrderCount < highRandOrder:
|
randOrderList = range(1, playerOrder)
|
random.shuffle(randOrderList)
|
matchOrderList.extend(randOrderList[:len(higherOrderPerList)])
|
GameWorld.DebugLog(" Ö±½ÓËæ»ú½Ï¸ßÃû´Î! higherOrderCount=%s,randOrderList=%s,matchOrderList=%s"
|
% (higherOrderCount, randOrderList, matchOrderList), playerID)
|
|
# °´±ÈÀý»®·Ö
|
elif higherOrderCount >= highRandOrder:
|
randMaxOrder = playerOrder - 1
|
for per in higherOrderPerList:
|
per = min(per, 100) # ×î¶àµ½100
|
tagOrder = int(playerOrder - higherOrderCount * per / 100.0)
|
if tagOrder <= 0 or randMaxOrder <= 0 or tagOrder > randMaxOrder:
|
GameWorld.ErrLog("¾º¼¼³¡Æ¥Åä¸ßÃû´ÎÍæ¼Ò±ÈÀý·¶Î§ÅäÖôíÎó! playerOrder(%s) - higherOrderCount(%s)*per(%s) = tagOrder(%s) <= 0 or randMaxOrder(%s)<=0 or tagOrder > randMaxOrder higherOrderPerList=%s"
|
% (playerOrder, higherOrderCount, per, tagOrder, randMaxOrder, higherOrderPerList))
|
break
|
randOrder = random.randint(tagOrder, randMaxOrder)
|
if randOrder != playerOrder and randOrder not in matchOrderList:
|
matchOrderList.append(randOrder)
|
GameWorld.DebugLog(" ¸ù¾Ý±ÈÀýËæ»ú½Ï¸ßÃû´Î! higherOrderCount=%s,per=%s,randOrder=(%s~%s)%s,matchOrderList=%s"
|
% (higherOrderCount, per, tagOrder, randMaxOrder, randOrder, matchOrderList), playerID)
|
randMaxOrder = tagOrder - 1
|
|
# ¸ßÃû´Î²»×ãµÄ£¬ÓõÍÃû´Î²¹×㣬һ°ãÊÇÇ°¼¸Ãû²Å»áÓÐÕâ¸öÐèÇó
|
higherLackCount = max(0, len(higherOrderPerList) - len(matchOrderList))
|
|
# ·Ç×îºóÒ»ÃûµÄÆ¥Åä±È×ÔÉíÃû´ÎµÍµÄ
|
if 1 <= playerOrder < maxOrder and lowerOrderPerList:
|
lowerOrderCount = maxOrder - playerOrder # ±ÈÍæ¼ÒµÍµÄÃû´ÎµÄ¸öÊý
|
# СÓÚ10¸öµÄÖ±½Ó´¿Ëæ»ú
|
if 0 < lowerOrderCount < lowRandOrder:
|
randOrderList = range(playerOrder + 1, maxOrder + 1)
|
random.shuffle(randOrderList)
|
matchOrderList.extend(randOrderList[:len(lowerOrderPerList)])
|
GameWorld.DebugLog(" Ö±½ÓËæ»ú½ÏµÍÃû´Î! lowerOrderCount=%s,randOrderList=%s,matchOrderList=%s"
|
% (lowerOrderCount, randOrderList, matchOrderList), playerID)
|
|
# °´±ÈÀý»®·Ö
|
elif lowerOrderCount >= lowRandOrder:
|
randMinOrder = playerOrder + 1
|
for per in lowerOrderPerList:
|
per = min(per, 100) # ×î¶àµ½100
|
tagOrder = int(playerOrder + lowerOrderCount * per / 100.0)
|
if tagOrder > maxOrder or randMinOrder > maxOrder or randMinOrder > tagOrder:
|
GameWorld.ErrLog("¾º¼¼³¡Æ¥ÅäµÍÃû´ÎÍæ¼Ò±ÈÀý·¶Î§ÅäÖôíÎó! playerOrder(%s) - lowerOrderCount(%s)*per(%s) = tagOrder(%s) > maxOrder(%s) or randMinOrder(%s)>maxOrder or randMinOrder > tagOrder lowerOrderPerList=%s"
|
% (playerOrder, lowerOrderCount, per, tagOrder, maxOrder, randMinOrder, lowerOrderPerList))
|
break
|
randOrder = random.randint(randMinOrder, tagOrder)
|
if randOrder != playerOrder and randOrder not in matchOrderList:
|
matchOrderList.append(randOrder)
|
GameWorld.DebugLog(" ¸ù¾Ý±ÈÀýËæ»ú½ÏµÍÃû´Î! lowerOrderCount=%s,per=%s,randOrder=(%s~%s)%s,matchOrderList=%s"
|
% (lowerOrderCount, per, randMinOrder, tagOrder, randOrder, matchOrderList), playerID)
|
randMinOrder = tagOrder + 1
|
|
# ¸ßÃû´Î²»×㻹ÐèÒª¶îÍâ²¹µÄ£¬Ö±½Ó´ÓÍæ¼ÒÃû´Î+1 ~ ×îºóÒ»¸öµÍ°Ù·Ö±ÈÃû´Î ¼äËæ»ú
|
doCount = 50
|
while higherLackCount > 0 and doCount > 0:
|
doCount -= 1
|
randOrderMin = playerOrder + 1
|
randOrderMax = min(tagOrder, maxOrder)
|
randOrder = random.randint(randOrderMin, randOrderMax)
|
if randOrder != playerOrder and randOrder not in matchOrderList:
|
matchOrderList.append(randOrder)
|
higherLackCount -= 1
|
GameWorld.DebugLog(" ¸ßÃû´Î²»×㣬ʹÓýϵÍÃû´Î²¹³ä! higherLackCount=%s,randOrder=(%s~%s)%s,matchOrderList=%s"
|
% (higherLackCount, randOrderMin, randOrderMax, randOrder, matchOrderList), playerID)
|
|
matchOrderList.sort()
|
# GMÖ¸¶¨Æ¥Åä²âÊÔ
|
if gmMatchIDList != None and curPlayer.GetGMLevel():
|
gmMatchOrderList = []
|
for gmMatchID in gmMatchIDList:
|
if gmMatchID == playerID:
|
GameWorld.DebugAnswer(curPlayer, "Ä¿±êID²»ÄÜÊÇ×Ô¼º!ÎÞ·¨Æ¥Åä!%s" % gmMatchID)
|
continue
|
gmMatchOrder = billBoard.IndexOfByID(gmMatchID) + 1
|
if gmMatchOrder <= 0:
|
GameWorld.DebugAnswer(curPlayer, "Ä¿±êID²»ÔÚ°ñµ¥ÉÏ!ÎÞ·¨Æ¥Åä!%s" % gmMatchID)
|
continue
|
if gmMatchOrder in matchOrderList:
|
continue
|
gmMatchOrderList.append(gmMatchOrder)
|
GameWorld.DebugAnswer(curPlayer, "Ö¸¶¨Æ¥ÅäID(%s),order(%s)" % (gmMatchID, gmMatchOrder))
|
|
GameWorld.DebugLog("matchOrderList=%s,needMatchCount=%s" % (str(matchOrderList), needMatchCount))
|
if matchOrderList:
|
matchOrderList = matchOrderList[:needMatchCount - len(gmMatchOrderList)]
|
matchOrderList += gmMatchOrderList
|
matchOrderList.sort()
|
|
matchRobotRate = IpyGameDataPY.GetFuncCfg("ArenaMatch", 4) # ÿ´Î¿ÉÖ±½ÓÆ¥ÅäÒ»¸ö»úÆ÷È˸ÅÂÊ
|
if matchRobotRate and matchOrderList and len(matchOrderList) >= needMatchCount and GameWorld.CanHappen(matchRobotRate, 100):
|
popOrder = matchOrderList.pop(-1) # È¥µô×îºóÒ»¸ö
|
GameWorld.DebugLog(" ¸ÅÂÊÆ¥Åäµ½Ò»¸ö»úÆ÷ÈË£¬È¥µô×îºóÒ»¸ö! matchRobotRate=%s,popOrder=%s" % (matchRobotRate, popOrder), playerID)
|
|
GameWorld.DebugLog(" ×îÖÕÆ¥Åäµ½µÄÃû´ÎÁбí: matchOrderList=%s" % matchOrderList, playerID)
|
|
# Ëæ»ú»úÆ÷È˱¸ÓÃÐÅÏ¢
|
openJobList = IpyGameDataPY.GetFuncEvalCfg("OpenJob", 1)
|
|
minLV, _ = IpyGameDataPY.GetFuncEvalCfg("ArenaRobot", 2) # »úÆ÷ÈË×îС¡¢×î´óµÈ¼¶
|
randMinLV, randMaxLV = minLV - 10, minLV
|
#randMinLV = min(minLV, int(playerLV * randRobotLVPerRange[0] / 100.0))
|
#randMaxLV = min(maxLV, int(playerLV * randRobotLVPerRange[1] / 100.0))
|
|
randRobotScorePerRange = IpyGameDataPY.GetFuncEvalCfg("ArenaMatch", 3)
|
randMinScore = int(playerScore * randRobotScorePerRange[0] / 100.0)
|
randMaxScore = int(playerScore * randRobotScorePerRange[1] / 100.0)
|
|
# ÕÒ³ö¶ÔÕ½ÁбíÖÐ×îеÄÒ»ÌõËæ»ú»úÆ÷ÈËID£¬ÓÃÓÚºóÃæÉú³ÉеÄËæ»ú»úÆ÷ÈËIDÓã¬È·±£²»Öظ´
|
lastRandRobotID = RandRobotID
|
curBattleRecList = GetPlayerArenaBattleRecList(playerID)
|
for battleRec in curBattleRecList[::-1]:
|
if battleRec.tagPlayerID >= RandRobotID and battleRec.tagPlayerID <= MaxRobotID:
|
lastRandRobotID = battleRec.tagPlayerID
|
break
|
|
GameWorld.DebugLog(" Ëæ»ú»úÆ÷È˱¸ÓÃÐÅÏ¢: lastRandRobotID=%s,LV(%s ~ %s),score(%s ~ %s)"
|
% (lastRandRobotID, randMinLV, randMaxLV, randMinScore, randMaxScore), playerID)
|
|
for i in xrange(needMatchCount):
|
if len(matchList) > i:
|
matchPlayer = matchList[i]
|
else:
|
matchPlayer = ArenaMatchPlayer()
|
matchList.append(matchPlayer)
|
matchPlayer.ResetData()
|
|
if matchOrderList:
|
matchOrder = matchOrderList.pop(0)
|
matchIndex = matchOrder - 1
|
# ÔÚ°ñµ¥ÉϵÄÖ±½ÓÈ¡°ñµ¥Êý¾Ý
|
if billBoard and 0 <= matchIndex < billBoard.GetCount():
|
billData = billBoard.At(matchIndex)
|
matchPlayer.tagPlayerID = GetArenaBillID(billData)
|
|
# ±»Æ¥ÅäµÄʱºò±»¶¯¸üаñµ¥ÖеÄÍæ¼ÒÊý¾Ý£¬²»ÅÅÐò£¬Ö»¸üÐÂÊýÖµ£¬ÕâЩÊýÖµ²»Ó°ÏìÅÅÐò£¬Õ½¶·Á¦Îª¶þ¼¶ÅÅÐò£¬¿ÉºöÂÔ
|
if matchPlayer.tagPlayerID > MaxRobotID:
|
curCache = PlayerViewCache.FindViewCache(matchPlayer.tagPlayerID)
|
if curCache:
|
cacheDict = PlayerViewCache.GetCachePropDataDict(curCache)
|
SetArenaBillName(billData, cacheDict["Name"])
|
SetArenaBillRealmLV(billData, cacheDict["RealmLV"])
|
SetArenaBillLV(billData, cacheDict["LV"])
|
SetArenaBillFightPower(billData, cacheDict["FightPower"])
|
else:
|
if matchIndex < len(PyGameData.g_arenaRobotLVList):
|
robotLV = PyGameData.g_arenaRobotLVList[matchIndex] # ͬ²½¸üлúÆ÷ÈË°ñµ¥±ä»¯µÈ¼¶
|
SetArenaBillLV(billData, robotLV)
|
|
matchPlayer.tagLV = GetArenaBillLV(billData)
|
matchPlayer.tagJob = GetArenaBillJob(billData)
|
matchPlayer.tagScore = GetArenaBillScore(billData)
|
|
GameWorld.DebugLog(" %s Æ¥ÅäÔÚ°ñµ¥ÉϵÄ: tagPlayerID=%s,tagLV=%s,tagScore=%s,matchOrder=%s"
|
% (i + 1, matchPlayer.tagPlayerID, matchPlayer.tagLV, matchPlayer.tagScore, matchOrder), playerID)
|
continue
|
|
# ʣϵÄËæ»úÉú³É²»ÔÚ°ñµ¥ÉϵĻúÆ÷ÈË
|
lastRandRobotID += 1
|
if lastRandRobotID > MaxRobotID:
|
lastRandRobotID = RandRobotID
|
matchPlayer.tagPlayerID = lastRandRobotID
|
matchPlayer.tagJob = random.choice(openJobList)
|
matchPlayer.tagLV = random.randint(randMinLV, randMaxLV)
|
matchPlayer.tagScore = random.randint(randMinScore, randMaxScore)
|
GameWorld.DebugLog(" %s Æ¥Åä·Ç°ñµ¥ÉϵÄ: tagPlayerID=%s,tagLV=%s,tagScore=%s"
|
% (i + 1,matchPlayer.tagPlayerID, matchPlayer.tagLV, matchPlayer.tagScore), playerID)
|
|
PyGameData.g_arenaPlayerMatchDict[playerID] = matchList
|
#GameWorld.DebugLog(" ¸üÐÂÆ¥Å仺´æ: %s" % PyGameData.g_arenaPlayerMatchDict, playerID)
|
__SyncMatchList(curPlayer, matchList)
|
return
|
|
def __SyncMatchList(curPlayer, matchList):
|
## ͬ²½Æ¥ÅäÁбí
|
clientPack = ChPyNetSendPack.tagGCArenaMatchList()
|
clientPack.MatchList = []
|
for matchPlayer in matchList:
|
matchInfo = ChPyNetSendPack.tagGCArenaMatchInfo()
|
matchInfo.PlayerID = matchPlayer.tagPlayerID
|
matchInfo.Job = matchPlayer.tagJob
|
matchInfo.LV = matchPlayer.tagLV
|
matchInfo.Score = matchPlayer.tagScore
|
|
# Íæ¼Ò¶ÁÈ¡¶îÍâÐÅÏ¢£¬ »úÆ÷ÈËÆäËûÐÅÏ¢²»´¦Àí£¬ÕâÀïÖ±½Ó¶Á×îеIJ鿴»º´æ£¬·Àֹˢв»¼°Ê±£¨²¢²»ÊÇʵʱÊý¾Ý£¬Ö»ÊÇÏà¶Ôʵʱ£¬Ç°¶Ë¿É×ÔÐпØÖÆË¢ÐÂƵÂÊ£©
|
if matchInfo.PlayerID > MaxRobotID:
|
curCache = PlayerViewCache.FindViewCache(matchInfo.PlayerID)
|
if curCache:
|
cacheDict = PlayerViewCache.GetCachePropDataDict(curCache)
|
fightPower = cacheDict["FightPower"]
|
matchInfo.LV = cacheDict["LV"]
|
matchInfo.PlayerName = cacheDict["Name"]
|
matchInfo.RealmLV = cacheDict["RealmLV"]
|
matchInfo.FightPower = fightPower % ShareDefine.Def_PerPointValue
|
matchInfo.FightPowerEx = fightPower / ShareDefine.Def_PerPointValue
|
else:
|
# ´Ë´¦»úÆ÷È˵ÄÔݺöÂԵȼ¶±ä»¯µÄͬ²½£¬½öÔÚˢС¢¸üлý·Öʱͬ²½£¬´Ë´¦Ê¡ÂÔ²éѯ»úÆ÷ÈËËùÊô°ñµ¥ÅÅÃû
|
pass
|
|
clientPack.MatchList.append(matchInfo)
|
clientPack.MatchCount = len(clientPack.MatchList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
def __DoArenaBattleResult(curPlayer, cmdDict):
|
## µØͼÍæ¼Òͬ²½Õ½¶·½á¹û
|
|
retDict = {}
|
retDict.update(cmdDict)
|
|
accID = curPlayer.GetAccID()
|
playerID = curPlayer.GetPlayerID()
|
GameWorld.DebugLog("¾º¼¼³¡Íæ¼ÒÕ½¶·½á¹û: %s" % str(cmdDict), playerID)
|
|
tagPlayerID = cmdDict["tagPlayerID"]
|
isWin = cmdDict["isWin"]
|
playerLV = cmdDict["playerLV"]
|
playerScore = cmdDict["playerScore"]
|
|
if not tagPlayerID:
|
return retDict
|
|
''' ¹ØÓÚ¶ÔÊÖ
|
À´Ô´£º
|
1. Æ¥ÅäÁбíÖÐ
|
2. ¶ÔÕ½¼Ç¼ÖÐÖ±½Ó·¢ÆðµÄÌôÕ½
|
˵Ã÷£º
|
1. ¿ÉÄÜÊÇ»úÆ÷ÈË£¬ÇÒ»úÆ÷ÈË»ý·Ö²»»á±ä»¯
|
2. ²»Ò»¶¨ÔÚ°ñÉÏ£¬ÒòΪ¿ÉÄÜÔÚ°ñÉϵÄʱºò±»Æ¥Åä×ßÁË£¬µ«ÊǺóÀ´±»¼·³ö°ñµ¥£¬È»ºóÊܵ½Íæ¼ÒÌôÕ½
|
3. Èç¹ûÊÇÍæ¼Ò£¬ÀíÂÛÉ϶¼ÓжÔÕ½¼Ç¼£¬ÒòΪÔÚ°ñÉϵÄÍæ¼Ò²Å»á±»Æ¥Åä×ߣ¬¶øÖ»ÓÐÖ÷¶¯¶ÔÕ½¹ý²ÅÓпÉÄÜÉÏ°ñ
|
'''
|
|
curScore = playerScore
|
isFindTag = False
|
tagLV, tagJob, tagScore = 0, 0, 0
|
tagRealmLV, tagFightPower, tagAccID = 0, 0, "" # »úÆ÷ÈËÎÞÖµ
|
|
# ÏÈÕÒÆ¥ÅäÁбí
|
matchList = PyGameData.g_arenaPlayerMatchDict.get(playerID, [])
|
for matchPlayer in matchList:
|
if matchPlayer.tagPlayerID == tagPlayerID:
|
isFindTag = True
|
tagLV, tagJob, tagScore = matchPlayer.tagLV, matchPlayer.tagJob, matchPlayer.tagScore
|
GameWorld.DebugLog(" ¶ÔÊÖÔÚÆ¥ÅäÁбíÖÐ! tagLV=%s, tagJob=%s, tagScore=%s" % (tagLV, tagJob, tagScore), playerID)
|
break
|
|
# ÔÚÕÒ¶ÔÕ½¼Ç¼Áбí
|
curBattleRecList = GetPlayerArenaBattleRecList(playerID)
|
if not isFindTag:
|
for battleRec in curBattleRecList:
|
if battleRec.tagPlayerID == tagPlayerID:
|
isFindTag = True
|
tagLV, tagJob, tagScore = battleRec.tagLV, battleRec.tagJob, battleRec.tagScore
|
GameWorld.DebugLog(" ¶ÔÊÖÔÚ¶ÔÕ½¼Ç¼ÖÐ! tagLV=%s, tagJob=%s, tagScore=%s" % (tagLV, tagJob, tagScore), playerID)
|
break
|
|
if not isFindTag:
|
GameWorld.ErrLog("ÕÒ²»µ½¶ÔÕ½¶ÔÊÖ£¬²»ÔÚÆ¥ÅäÁбí»ò¶ÔÕ½¼Ç¼À²»´¦Àí½áË㣡tagPlayerID=%s" % tagPlayerID, playerID)
|
return retDict
|
|
billBoard = GameWorld.GetBillboard().FindBillboard(ShareDefine.Def_BT_Arena)
|
if not billBoard:
|
return retDict
|
|
if tagPlayerID > MaxRobotID:
|
tagPlayer = GameWorld.GetPlayerManager().FindPlayerByID(tagPlayerID)
|
tagOnline = 1 if (tagPlayer and not PlayerControl.GetIsTJG(tagPlayer)) else 0 # Ä¿±êÍæ¼ÒÊÇ·ñÔÚÏß
|
|
tagBattleRecList = GetPlayerArenaBattleRecList(tagPlayerID)
|
# Ëä˵ÀíÂÛÉ϶¼ÓмǼ£¬µ«ÊÇ´úÂë²ãÃ滹ÊÇ×öºÃΪNoneʱµÄ·À·¶
|
tagBattleRec = tagBattleRecList[-1] if len(tagBattleRecList) > 0 else None
|
if tagBattleRec:
|
tagScore = tagBattleRec.updScore
|
GameWorld.DebugLog(" ¶ÔÊÖÊÇÍæ¼Ò£¬´Ó¶ÔÊÖ×îжÔÕ½¼Ç¼ÖлñµÃ¶ÔÊÖ×îлý·Ö! tagScore=%s" % tagScore, playerID)
|
|
playerJob = curPlayer.GetJob()
|
playerName = curPlayer.GetName()
|
realmLV = cmdDict["realmLV"]
|
fightPower = cmdDict["fightPower"]
|
|
opInfo = ""
|
# ½áËã×Ô¼º
|
addScore = __CalcBattleAddScore(playerID, curScore, tagScore, isWin)
|
updScore = max(0, playerScore + addScore)
|
|
curOrder = billBoard.IndexOfByID(playerID) + 1 # ¸üÐÂÇ°»ñÈ¡Ãû´Î
|
cmpValue2 = fightPower / ShareDefine.Def_PerPointValue
|
cmpValue3 = fightPower % ShareDefine.Def_PerPointValue
|
PlayerBillboard.UpdatePlayerBillboard(playerID, playerName, opInfo, ShareDefine.Def_BT_Arena, playerJob,
|
realmLV, playerLV, updScore, autoSort=False, cmpValue2=cmpValue2, cmpValue3=cmpValue3)
|
|
awardItemList = []
|
if isWin:
|
randItemList = IpyGameDataPY.GetFuncEvalCfg("ArenaBattleAward", 3)
|
awardItemInfo = GameWorld.GetResultByRandomList(randItemList)
|
if awardItemInfo:
|
awardItemList.append(awardItemInfo[:3])
|
isWorldNotify = awardItemInfo[3] if len(awardItemInfo) > 3 else 0
|
if isWorldNotify:
|
PlayerControl.WorldNotify(0, "ArenaWinerItem", [curPlayer.GetName(), awardItemInfo[0], "", awardItemInfo[1]])
|
|
tagAddScore = __CalcBattleAddScore(tagPlayerID, tagScore, curScore, not isWin)
|
updTagScore = max(0, tagScore + tagAddScore)
|
# ½áËã¶ÔÊÖ£¬½öÍæ¼Òʱ½áË㣬»úÆ÷È˲»´¦Àí
|
if tagPlayerID > MaxRobotID:
|
tagCache = PlayerViewCache.FindViewCache(tagPlayerID)
|
if tagCache:
|
cacheDict = PlayerViewCache.GetCachePropDataDict(tagCache)
|
tagOpInfo = ""
|
tagLV = cacheDict["LV"]
|
tagPlayerName = cacheDict["Name"]
|
tagRealmLV = cacheDict["RealmLV"]
|
tagFightPower = cacheDict["FightPower"]
|
tagAccID = cacheDict["AccID"]
|
tagCmpValue2 = tagFightPower / ShareDefine.Def_PerPointValue
|
tagCmpValue3 = tagFightPower % ShareDefine.Def_PerPointValue
|
PlayerBillboard.UpdatePlayerBillboard(tagPlayerID, tagPlayerName, tagOpInfo, ShareDefine.Def_BT_Arena, tagJob,
|
tagRealmLV, tagLV, updTagScore, autoSort=False, cmpValue2=tagCmpValue2, cmpValue3=tagCmpValue3)
|
else:
|
robotBillboardData = billBoard.FindByID(tagPlayerID)
|
if robotBillboardData:
|
SetArenaBillScore(robotBillboardData, updTagScore)
|
|
# ¶¼¸üÐÂÍêºóÅÅÐòÒ»´Î
|
billBoard.Sort()
|
updOrder = billBoard.IndexOfByID(playerID) + 1 # È¡×îÐÂÃû´Î
|
GameWorld.DebugLog(" ¸üÐÂ×ÔÉí»ý·Ö: addScore=%s,updScore=%s,curOrder=%s,updOrder=%s" % (addScore, updScore, curOrder, updOrder), playerID)
|
GameWorld.DebugLog(" ¸üжÔÊÖ»ý·Ö: tagPlayerID=%s,tagAddScore=%s,updTagScore=%s" % (tagPlayerID, tagAddScore, updTagScore), playerID)
|
retDict.update({"addScore":addScore, "updScore":updScore, "curOrder":curOrder, "updOrder":updOrder,
|
"awardItemList":awardItemList, "isOK":True})
|
|
if tagPlayerID <= MaxRobotID:
|
tagUpdOrder = billBoard.IndexOfByID(tagPlayerID) + 1 # È¡×îÐÂÃû´Î
|
tagOrderIndex = tagUpdOrder - 1
|
if tagUpdOrder >= 1 and tagOrderIndex < len(PyGameData.g_arenaRobotLVList) and tagOrderIndex < billBoard.GetCount():
|
GameWorld.DebugLog(" PyGameData.g_arenaRobotLVList=%s" % PyGameData.g_arenaRobotLVList, playerID)
|
updRobotLV = PyGameData.g_arenaRobotLVList[tagOrderIndex]
|
robotBillboardData = billBoard.At(tagOrderIndex)
|
SetArenaBillLV(robotBillboardData, updRobotLV)
|
GameWorld.DebugLog(" »úÆ÷ÈËÔÚ°ñÉÏ£¬¸üеȼ¶ÐÅÏ¢! tagPlayerID=%s,tagUpdOrder=%s,updRobotLV=%s" % (tagPlayerID, tagUpdOrder, updRobotLV), playerID)
|
else:
|
GameWorld.DebugLog(" »úÆ÷È˲»ÔÚ°ñÉÏ£¬²»¸üеȼ¶ÐÅÏ¢! tagPlayerID=%s" % tagPlayerID, playerID)
|
|
battleRecMaxCount = min(MaxBattleRecCount, IpyGameDataPY.GetFuncCfg("ArenaSet", 4))
|
|
# ²åÈë¶ÔÕ½¼Ç¼
|
battleTime = int(time.time())
|
battleRec = ArenaBattleRec(playerID)
|
battleRec.battleTime = battleTime
|
battleRec.tagPlayerID = tagPlayerID
|
battleRec.tagLV = tagLV
|
battleRec.tagJob = tagJob
|
battleRec.tagScore = updTagScore
|
battleRec.isWin = int(isWin)
|
battleRec.addScore = addScore
|
battleRec.isDispose = 1
|
battleRec.updScore = updScore
|
curBattleRecList.append(battleRec)
|
if len(curBattleRecList) > battleRecMaxCount:
|
curBattleRecList = curBattleRecList[len(curBattleRecList) - battleRecMaxCount:]
|
PyGameData.g_arenaPlayerBattleRecDict[playerID] = curBattleRecList
|
__SyncArenaBattleRecord(curPlayer, [battleRec])
|
|
if tagPlayerID > MaxRobotID:
|
# ¶ÔÊÖÍæ¼Ò·´ÏòÔö¼Ó¶ÔÕ½¼Ç¼
|
tagBattleRec = ArenaBattleRec(tagPlayerID)
|
tagBattleRec.battleTime = battleTime
|
tagBattleRec.tagPlayerID = playerID
|
tagBattleRec.tagLV = playerLV
|
tagBattleRec.tagJob = playerJob
|
tagBattleRec.tagScore = updScore
|
tagBattleRec.isWin = int(not isWin)
|
tagBattleRec.addScore = tagAddScore
|
tagBattleRec.isDispose = 1 if tagOnline else 0
|
tagBattleRec.updScore = updTagScore
|
tagBattleRecList.append(tagBattleRec)
|
if len(tagBattleRecList) > battleRecMaxCount:
|
tagBattleRecList = tagBattleRecList[len(tagBattleRecList) - battleRecMaxCount:]
|
PyGameData.g_arenaPlayerBattleRecDict[tagPlayerID] = tagBattleRecList
|
if tagOnline:
|
__SyncArenaBattleRecord(tagPlayer, [tagBattleRec])
|
__SyncPlayerBechallengedUpdScore(tagPlayer, updTagScore)
|
|
GameWorld.DebugLog(" ×îÐÂËùÓжÔÕ½¼Ç¼»º´æ! %s" % PyGameData.g_arenaPlayerBattleRecDict)
|
GameWorld.DebugLog(" retDict=%s" % retDict, playerID)
|
|
# ¶ÔÕ½½áÊø£¬×îºóÃâ·ÑË¢ÐÂÒ»´ÎÆ¥ÅäÁбí
|
__DoArenaMatchRefresh(curPlayer, True, playerLV, updScore)
|
|
drDict = {"AccID":accID, "PlayerID":playerID, "playerLV":playerLV, "realmLV":realmLV, "fightPower":fightPower, "curScore":[curScore, addScore, updScore],
|
"TagAccID":tagAccID, "TagPlayerID":tagPlayerID, "tagLV":tagLV, "tagRealmLV":tagRealmLV, "tagFightPower":tagFightPower,
|
"tagScore":[tagScore, tagAddScore, updTagScore], "isWin":isWin}
|
DataRecordPack.SendEventPack("ArenaBattleResult", drDict)
|
return retDict
|
|
def __SyncPlayerBechallengedUpdScore(curPlayer, updScore):
|
## ֪ͨµØͼÍæ¼Ò±»ÌôÕ½¸üлý·Ö£¬ÔÚÏß±»ÌôÕ½ »ò ÀëÏß/ÍÑ»ú±»ÌôÕ½ÉÏÏߺóͬ²½
|
|
playerID = curPlayer.GetPlayerID()
|
tagMapID = curPlayer.GetRealMapID()
|
cmdStr = str(["UpdScore", {"updScore":updScore}])
|
GameWorld.GetPlayerManager().MapServer_QueryPlayer(0, 0, playerID, tagMapID, "Arena",
|
cmdStr, len(cmdStr), curPlayer.GetRouteServerIndex())
|
return
|
|
def __CalcBattleAddScore(playerID, curScore, tagScore, isWin):
|
## ¼ÆËã¶ÔÕ½Ôö¼Ó»ý·Ö
|
diffScore = curScore - tagScore # »ý·Ö²î£¬ÓÐÕý¸º
|
calcScoreFormatDict = IpyGameDataPY.GetFuncEvalCfg("ArenaBattleAward", 1) if isWin else IpyGameDataPY.GetFuncEvalCfg("ArenaBattleAward", 2)
|
scoreKeyList = calcScoreFormatDict.keys()
|
scoreKeyList.sort()
|
calcKey = None
|
for scoreKey in scoreKeyList:
|
if diffScore <= scoreKey:
|
calcKey = scoreKey
|
break
|
|
if calcKey == None:
|
GameWorld.ErrLog(" ¼ÆËãµÃ·Ö¹«Ê½: playerID=%s,diffScore=%s,scoreKeyList=%s,isWin=%s ÕÒ²»µ½¶ÔÓ¦key¹«Ê½"
|
% (playerID, diffScore, scoreKeyList, isWin))
|
return 0
|
|
compileKey = "ArenaBattleScore_%s_%s" % (int(isWin), str(calcKey))
|
formatStr = calcScoreFormatDict[calcKey]
|
addScore = eval(FormulaControl.GetCompileFormula(compileKey, formatStr))
|
GameWorld.DebugLog(" ¼ÆËãµÃ·Ö¹«Ê½: playerID=%s,diffScore=%s,scoreKeyList=%s,isWin=%s,compileKey=%s,formatStr=%s,addScore=%s"
|
% (playerID, diffScore, scoreKeyList, isWin, compileKey, formatStr, addScore))
|
return addScore
|
|
#// A9 A8 ²é¿´¾º¼¼³¡¶ÔÕ½¼Ç¼ #tagCGQueryArenaBattleRecord
|
#
|
#struct tagCGQueryArenaBattleRecord
|
#{
|
# tagHead Head;
|
#};
|
def OnQueryArenaBattleRecord(index, clientData, tick):
|
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
if not curPlayer:
|
return
|
__SyncArenaBattleRecord(curPlayer, [])
|
return
|
|
def __SyncArenaBattleRecord(curPlayer, battleRecList):
|
## ͬ²½¶ÔÕ½¼Ç¼
|
if not battleRecList:
|
playerID = curPlayer.GetPlayerID()
|
battleRecList = GetPlayerArenaBattleRecList(playerID)
|
|
clientPack = ChPyNetSendPack.tagGCArenaBattleRecordList()
|
clientPack.BattleRecordList = []
|
for battleRec in battleRecList:
|
recInfo = ChPyNetSendPack.tagGCArenaBattleRecord()
|
recInfo.PlayerID = battleRec.tagPlayerID
|
recInfo.Job = battleRec.tagJob
|
recInfo.LV = battleRec.tagLV
|
recInfo.Score = battleRec.tagScore
|
recInfo.AddScore = str(battleRec.addScore)
|
recInfo.AddScoreLen = len(recInfo.AddScore)
|
recInfo.IsWin = battleRec.isWin
|
recInfo.Time = battleRec.battleTime
|
|
if recInfo.PlayerID > MaxRobotID:
|
curCache = PlayerViewCache.FindViewCache(recInfo.PlayerID)
|
if curCache:
|
cacheDict = PlayerViewCache.GetCachePropDataDict(curCache)
|
fightPower = cacheDict["FightPower"]
|
recInfo.LV = cacheDict["LV"]
|
recInfo.PlayerName = cacheDict["Name"]
|
recInfo.RealmLV = cacheDict["RealmLV"]
|
recInfo.FightPower = fightPower % ShareDefine.Def_PerPointValue
|
recInfo.FightPowerEx = fightPower / ShareDefine.Def_PerPointValue
|
|
clientPack.BattleRecordList.append(recInfo)
|
|
clientPack.RecordCount = len(clientPack.BattleRecordList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
#// A9 A5 ²é¿´¾º¼¼³¡¶ÔÕ½Íæ¼Ò×îÐÂÐÅÏ¢ #tagCGQueryArenaBattlePlayer
|
#
|
#struct tagCGQueryArenaBattlePlayer
|
#{
|
# tagHead Head;
|
# DWORD PlayerID; //Ä¿±êÍæ¼ÒID£¬½öÖ§³Ö²éÕæʵÍæ¼Ò
|
#};
|
def OnQueryArenaBattlePlayer(index, clientData, tick):
|
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
if not curPlayer:
|
return
|
|
tagPlayerID = clientData.PlayerID
|
tagBattleRecList = GetPlayerArenaBattleRecList(tagPlayerID)
|
if not tagBattleRecList:
|
GameWorld.ErrLog("¾º¼¼³¡Íæ¼ÒÎÞ¶ÔÕ½¼Ç¼£¬ÎÞ·¨²éѯ×îÐÂÊý¾Ý! tagPlayerID=%s" % tagPlayerID, curPlayer.GetPlayerID())
|
return
|
tagBattleRec = tagBattleRecList[-1] # È¡×îºóÒ»ÌõΪ×îÐÂÊý¾Ý
|
tagScore = tagBattleRec.updScore
|
|
clientPack = ChPyNetSendPack.tagGCArenaBattlePlayerInfo()
|
clientPack.PlayerID = tagPlayerID
|
clientPack.Score = tagScore
|
|
curCache = PlayerViewCache.FindViewCache(tagPlayerID)
|
if curCache:
|
cacheDict = PlayerViewCache.GetCachePropDataDict(curCache)
|
fightPower = cacheDict["FightPower"]
|
clientPack.LV = cacheDict["LV"]
|
clientPack.Job = cacheDict["Job"]
|
clientPack.PlayerName = cacheDict["Name"]
|
clientPack.RealmLV = cacheDict["RealmLV"]
|
clientPack.FightPower = fightPower % ShareDefine.Def_PerPointValue
|
clientPack.FightPowerEx = fightPower / ShareDefine.Def_PerPointValue
|
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
