#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
#-------------------------------------------------------------------------------
|
#
|
##@package PlayerXMZZ
|
#
|
# @todo:ÏÉħ֮Õù
|
# @author xdh
|
# @date 2017-12-07
|
# @version 1.1
|
#
|
#
|
# ÏêϸÃèÊö: ÏÉħ֮Õù
|
# @change: "2018-07-09 14:30" xdh ÿ³¡ÌØÊâ´ÎÊý°´ÊÀ½çµÈ¼¶¶ÔÓ¦Õ½Á¦·¶Î§À´Ëæ»ú¶ÔÊÖ
|
#---------------------------------------------------------------------
|
"""Version = 2018-07-09 14:30"""
|
|
import GameWorld
|
import ShareDefine
|
import IpyGameDataPY
|
import PlayerDBGSEvent
|
import PlayerCompensation
|
import ChPyNetSendPack
|
import NetPackCommon
|
import ChConfig
|
import PyGameDataStruct
|
import CommFunc
|
import PyDataManager
|
import PlayerControl
|
import PlayerViewCache
|
import FormulaControl
|
import PlayerUniversalGameRec
|
|
import random
|
import json
|
import math
|
|
RecType = ShareDefine.Def_UniversalGameRecType_XMZZStageRecord
|
RecType1 = ShareDefine.Def_UniversalGameRecType_XMZZPKInfoRecord
|
#strValue3 {ͶעË÷Òý:½á¹û,..}
|
g_playerPowerDict = {} #Íæ¼ÒÕ½Á¦»º´æ
|
g_historyPKDict = {} #ÀúÊ·¶ÔÊÖID»º´æ
|
|
(
|
Bet_StartTime, #Ͷע¿ªÊ¼Ê±¼ä
|
Bet_EndTime, #Ͷע½áÊøʱ¼ä
|
Bet_ResultTime, #Ͷע½áËãʱ¼ä
|
Bet_NeedMoney, #ͶעÐèҪǮ
|
) = range(4)
|
|
(
|
Faction_0, #δ·ÖÅä
|
Faction_1, #ÏÉ×å
|
Faction_2, #ħ×å
|
) = range(0, 3)
|
|
(
|
Def_Faction1Win, #ÏÉ×åʤÀû
|
Def_Faction2Win, #ħ×åʤÀû
|
Def_Dogfall #ƽ¾Ö
|
) = range(1, 4)
|
|
|
## ·þÎñÆ÷¿ªÆôʱ¼ì²é
|
def OnGameServerInitOK():
|
fbFuncStateKey = ShareDefine.Def_Notify_WorldKey_FBFuncState % ChConfig.Def_FBMapID_XMZZ
|
gameWorld = GameWorld.GetGameWorld()
|
isAtCPing = gameWorld.GetDictByKey(fbFuncStateKey) != 0
|
|
|
hasSendAward = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_XMZZIsOver) #ÊÇ·ñ½áËã¹ý
|
|
if not isAtCPing and not hasSendAward: #»î¶¯Î´¿ªÆô²¢ÇÒδ½áËã
|
PyDataManager.GetXMZZManager().GiveXMZZAward()
|
|
return
|
|
def OnXMZZOnLogin(curPlayer):
|
#Íæ¼ÒµÇ¼
|
PyDataManager.GetXMZZManager().NotifyXMZZInfo(curPlayer)
|
PyDataManager.GetXMZZManager().NotifyXMZZSelfInfo(curPlayer)
|
PlayerUniversalGameRec.SendUniversalGameRecInfo(curPlayer, RecType1)
|
|
if curPlayer.GetMapID() == ChConfig.Def_FBMapID_XMZZ:
|
PyDataManager.GetXMZZManager().SyncXMZZFightInfo(curPlayer)
|
return
|
|
def XMZZOndayEx():
|
#¹ýÌì
|
global g_playerPowerDict
|
global g_historyPKDict
|
PyDataManager.GetXMZZManager().ResetXMZZ()
|
g_playerPowerDict = {} #Íæ¼ÒÕ½Á¦»º´æ
|
g_historyPKDict = {} #ÀúÊ·¶ÔÊÖID»º´æ
|
return
|
|
## ÏÉħ֮Õù»î¶¯×´Ì¬±ä¸ü
|
# @param curPlayer
|
# @param isOpen
|
# @return
|
def OnXMZZStateChange(dictName, value):
|
|
DoBetResultSaveLogic()
|
|
if value == 0: #»î¶¯½áÊø
|
PyDataManager.GetXMZZManager().GiveXMZZAward()
|
|
|
#hasSendAward = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_XMZZIsOver) #ÊÇ·ñ½áËã¹ý
|
# if value == 1 and hasSendAward:
|
# PyDataManager.GetXMZZManager().ResetXMZZ()
|
return
|
|
|
def OnXMZZBet(curPlayer, msgInfo):
|
## ÏÉħ֮ÕùͶע
|
betIndex, betResult, needMoney = msgInfo
|
fbFuncStateKey = ShareDefine.Def_Notify_WorldKey_FBFuncState % ChConfig.Def_FBMapID_XMZZ
|
gameWorld = GameWorld.GetGameWorld()
|
if gameWorld.GetDictByKey(fbFuncStateKey) == 0:
|
return
|
|
#¼Ç¼Ͷע
|
result = PyDataManager.GetXMZZManager().AddBetRecord(curPlayer, betIndex, betResult, needMoney)
|
if result:
|
return [needMoney]
|
|
def DoBetResultSaveLogic():
|
#ÏÉħ֮ÕùѺע½áËã
|
betTimeDict = IpyGameDataPY.GetFuncEvalCfg('XMZZBetCfg')
|
if not betTimeDict:
|
return
|
curResult = PyDataManager.GetXMZZManager().GetXMZZCurResult()
|
#curTime = str(GameWorld.GetServerTime())[11:16]
|
curTime = GameWorld.GetServerTime()
|
curHour, curMinute = curTime.hour, curTime.minute
|
GameWorld.DebugLog(' ÏÉħ֮ÕùѺע½áËã curTime=%s, curResult=%s' % (curTime, curResult))
|
|
universalRecMgr = GameWorld.GetUniversalRecMgr()
|
recordList = universalRecMgr.GetTypeList(RecType)
|
if recordList.Count() <= 0:
|
recData = recordList.AddRec()
|
resutlDict = {}
|
recData.SetStrValue3(str(resutlDict))
|
else:
|
recData = recordList.At(0)
|
resutlDict = eval(recData.GetStrValue3())
|
|
|
for betIndex, info in betTimeDict.items():
|
hour, minute = info[Bet_ResultTime].split(':')
|
if abs(curHour*60+curMinute - (int(hour)*60+int(minute))) <= 1:
|
if betIndex not in resutlDict:
|
resutlDict[betIndex] = curResult
|
recData.SetStrValue3(str(resutlDict))
|
GameWorld.DebugLog(' ÏÉħ֮Õù½×¶Î³É¼¨¼Ç¼£¡ betIndex=%s'%betIndex)
|
if int(betIndex) in [1,2,3]:
|
if curResult == Def_Dogfall:
|
SavePKRecord('XMZZ_DrawStage', [betIndex], True)
|
else:
|
SavePKRecord('XMZZ_LeadingStage', [betIndex, curResult], True)
|
# else:
|
# if curResult != Def_Dogfall:
|
# PyDataManager.GetXMZZManager().SavePKRecord('XMZZ_Victory', [curResult], True)
|
# else:
|
# PyDataManager.GetXMZZManager().SavePKRecord('XMZZ_Draw', [], True)
|
PyDataManager.GetXMZZManager().NotifyXMZZInfo()
|
return
|
|
|
#// AC 01 ÏÉħ֮Õù±¨Ãû #tagCGJoinXMZZ
|
#
|
#struct tagCGJoinXMZZ
|
#{
|
# tagHead Head;
|
#};
|
## ·ÖÅäÕóÓª
|
def OnJoinXMZZ(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
PyDataManager.GetXMZZManager().DoAllocationFaction(curPlayer)
|
return
|
|
#// AC 02 ÏÉħ֮ÕùÕ½¶·½áÊø #tagCGXMZZOver
|
#
|
#struct tagCGXMZZOver
|
#{
|
# tagHead Head;
|
# BYTE IsWin; //ÊÇ·ñʤÀû
|
# BYTE HPPer; //Ê£ÓàѪÁ¿°Ù·Ö±È
|
#};
|
def OnXMZZPKOver(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
isWin = clientData.IsWin
|
isEnd = clientData.IsEnd
|
HPPer = clientData.HPPer
|
vsName = clientData.VSName
|
#¼ÆËãÔö¼Ó»ý·Ö
|
XMZZPKOver(curPlayer, vsName, isWin, isEnd, HPPer)
|
return
|
|
def XMZZStartFight(curPlayer, msgInfo):
|
##¿ªÊ¼Õ½¶·
|
isStart = msgInfo[0]
|
if isStart:#±¾¾Ö¸Õ¿ªÊ¼ÔòÇå³ýÁ¬Ê¤¼Ç¼
|
PyDataManager.GetXMZZManager().ResetConWinRecord(curPlayer)
|
|
#ɸѡ¶ÔÊÖ
|
isOK = RandomBattler(curPlayer)
|
if isOK and isStart:
|
return True
|
return
|
|
|
|
|
def OnGetXMZZWinPrize(curPlayer, msgList):
|
##ÁìÈ¡ÏÉħ֮ÕùʤÀû³¡Êý½±Àø
|
prizeEx = msgList[0]
|
result = PyDataManager.GetXMZZManager().GetWinCntPrize(curPlayer, prizeEx)
|
if not result:
|
return
|
return [prizeEx]
|
|
|
# ÏÉħ֮Õù¹ÜÀí
|
class XMZZManager(object):
|
|
def __init__(self):
|
self.XMZZPlayerDict = {} # {playerid:data, ...} PyGameDataStruct.tagDBPySealDemonRecord
|
self.XMZZFactionDict = {Faction_1:[0, 0], Faction_2:[0, 0]} # {faction:[»ý·Ö, ÈËÊý]}
|
self.XMZZTopScore = 0 #»ý·ÖÍõ»ý·Ö
|
self.XMZZTopPlayerName = '' #»ý·ÖÍõÃû
|
self.vsPlayerIDDict = {} #µ±Ç°¶ÔÊÖID
|
return
|
|
def ResetConWinRecord(self, curPlayer):
|
##ÖØÖÃÁ¬Ê¤
|
playerID = curPlayer.GetID()
|
if playerID not in self.XMZZPlayerDict:
|
return
|
self.XMZZPlayerDict[playerID].ConWinCnt = 0
|
return
|
|
def GetXMZZPKCnt(self, curPlayer):
|
##»ñÈ¡ÒÑPK³¡´Î
|
playerID = curPlayer.GetID()
|
if playerID not in self.XMZZPlayerDict:
|
return 0
|
return self.XMZZPlayerDict[playerID].WinCnt + self.XMZZPlayerDict[playerID].LoseCnt
|
|
def GetPlayerXMZZFaction(self, playerID):
|
##»ñÈ¡Íæ¼ÒËùÊôÕóÓª
|
if playerID not in self.XMZZPlayerDict:
|
return Faction_0
|
return self.XMZZPlayerDict[playerID].Faction
|
|
|
def SyncXMZZFightInfo(self, curPlayer):
|
playerID = curPlayer.GetPlayerID()
|
if playerID not in self.vsPlayerIDDict:
|
return
|
pkPlayerID = self.vsPlayerIDDict[playerID]
|
curCache = PlayerViewCache.ViewCacheMgr.FindCache(pkPlayerID)
|
if not curCache:
|
return
|
PropData, ItemData = curCache.GetPropData(), curCache.GetItemData()
|
|
packData = ChPyNetSendPack.tagGCXMZZFightInfo()
|
packData.Clear()
|
packData.PlayerID = pkPlayerID
|
packData.PropData = PropData
|
packData.PropDataSize = len(packData.PropData)
|
packData.ItemData = ItemData
|
packData.ItemDataSize = len(packData.ItemData)
|
NetPackCommon.SendFakePack(curPlayer, packData)
|
return
|
|
def MapServer_XMZZPKInfo(self, curPlayer, overInfo, vsPlayerInfo):
|
# ֪ͨMapServer PKÐÅÏ¢
|
result = str([overInfo, vsPlayerInfo])
|
curPlayer.MapServer_QueryPlayerResult(0, 0, "XMZZPKInfo", result, len(result))
|
return
|
|
def AddBetRecord(self, curPlayer, betIndex, betResult, needMoney):
|
##ÐÂÔöѺע¼Ç¼
|
playerID = curPlayer.GetID()
|
if playerID not in self.XMZZPlayerDict:
|
GameWorld.DebugLog(' ÏÉħ֮Õùδ·ÖÅäÕóÓªµÄ²»ÄÜѺע', playerID)
|
return
|
betInfoDict = eval(self.XMZZPlayerDict[playerID].BetRecord) #{¾º²ÂË÷Òý:[ѺעÄÄ·½Ê¤,ѺÁ˶àÉÙÇ®]}
|
|
if betIndex in betInfoDict:
|
GameWorld.DebugLog(' ÏÉħ֮ÕùÒÑѺע¹ý¸ÃÂÖ´ÎbetIndex=%s' % betIndex, playerID)
|
#ÒÑѺע¹ý¸ÃÂÖ´Î
|
return
|
GameWorld.DebugLog(' ÏÉħ֮ÕùѺע³É¹¦betIndex=%s,betResult=%s' % (betIndex, betResult), playerID)
|
betInfoDict[betIndex] = [betResult, needMoney]
|
self.XMZZPlayerDict[playerID].BetRecord = str(betInfoDict)
|
self.XMZZPlayerDict[playerID].Len = len(str(betInfoDict))
|
self.NotifyXMZZSelfInfo(curPlayer)
|
return 1
|
|
def GetStageResultRecord(self):
|
#»ñÈ¡½×¶Î±È·ÖÇé¿ö
|
universalRecMgr = GameWorld.GetUniversalRecMgr()
|
recordList = universalRecMgr.GetTypeList(RecType)
|
if recordList.Count() <= 0:
|
resutlDict = {}
|
else:
|
recData = recordList.At(0)
|
resutlDict = eval(recData.GetStrValue3())
|
return resutlDict
|
|
def BetOverLogic(self):
|
#Ѻע½áËã
|
resutlDict = self.GetStageResultRecord()
|
|
betTimeDict = IpyGameDataPY.GetFuncEvalCfg('XMZZBetCfg')
|
|
for playerID, XMZZData in self.XMZZPlayerDict.items():
|
betInfoDict = eval(XMZZData.BetRecord)
|
if not betInfoDict:
|
continue
|
paramList = [] #Óʼþ²ÎÊý
|
totalGiveMoney = 0 #ÍÇ®
|
for betID in [0]: #ÔÝдËÀ˳Ðò
|
if str(betID) not in betTimeDict:
|
GameWorld.ErrLog('XMZZBetCfg ѺעË÷ÒýÅäÖÃÒì³££¡')
|
return
|
if betID not in betInfoDict:
|
#δͶע
|
paramList += [0, 0]
|
else:
|
betSide, needMoney = betInfoDict[betID]
|
|
if str(betID) in resutlDict: #¸ÃÂÖ´ÎÓÐʤ¸º¼Ç¼ÔòÕý³£½áËã,·ñÔòÍË»ØѺעǮ
|
curResult = resutlDict[str(betID)]
|
|
isRight = int(betSide == curResult) #ÊÇ·ñѺע¶ÔÁË
|
getMoney = needMoney * 2 if isRight else needMoney / 2
|
totalGiveMoney += getMoney
|
paramList += [isRight + 1, getMoney]
|
else:
|
totalGiveMoney += needMoney
|
paramList += [3, needMoney]
|
|
PlayerCompensation.SendMailByKey('XMZZBet', [playerID], [], paramList, silver=totalGiveMoney)
|
GameWorld.DebugLog(' ÏÉħ֮ÕùѺע½áËã paramList=%s,totalGiveMoney=%s' % (paramList, totalGiveMoney), playerID)
|
return
|
|
def GetXMZZCurResult(self):
|
#»ñÈ¡µ±Ç°±È·ÖÇé¿ö
|
faction_1_Score = self.XMZZFactionDict.get(Faction_1, [0, 0])[0]
|
faction_2_Score = self.XMZZFactionDict.get(Faction_2, [0, 0])[0]
|
if faction_1_Score > faction_2_Score:
|
result = Def_Faction1Win
|
elif faction_1_Score == faction_2_Score:
|
result = Def_Dogfall
|
else:
|
result = Def_Faction2Win
|
return result
|
|
def DoAllocationFaction(self, curPlayer):
|
#·ÖÅäÕóÓª
|
fbFuncStateKey = ShareDefine.Def_Notify_WorldKey_FBFuncState % ChConfig.Def_FBMapID_XMZZ
|
if GameWorld.GetGameWorld().GetDictByKey(fbFuncStateKey) == 0:
|
GameWorld.DebugLog('ÏÉħ֮Õù±¨Ãû »î¶¯Î´¿ªÆô£¡')
|
return
|
|
curPlayerID = curPlayer.GetID()
|
if curPlayerID in self.XMZZPlayerDict:
|
GameWorld.DebugLog('·ÖÅäÏÉħ֮ÕùÕóÓª ÒÑ·ÖÅä¹ý£¡', curPlayerID)
|
#ÒÑ·ÖÅä¹ý
|
return True
|
Faction_1_Cnt = self.XMZZFactionDict.get(Faction_1, [0, 0])[1]
|
Faction_2_Cnt = self.XMZZFactionDict.get(Faction_2, [0, 0])[1]
|
if Faction_1_Cnt < Faction_2_Cnt:
|
result = Faction_1
|
else:
|
result = Faction_2
|
self.XMZZFactionDict[result][1] += 1
|
|
GameWorld.DebugLog('·ÖÅäÏÉħ֮ÕùÕóÓª result=%s' % result, curPlayerID)
|
|
record = PyGameDataStruct.tagDBPyXMZZ()
|
record.clear()
|
record.PlayerID = curPlayerID
|
record.Name = curPlayer.GetName()
|
record.Faction = result
|
record.BetRecord = '{}'
|
record.Len = len(record.BetRecord)
|
self.XMZZPlayerDict[curPlayerID] = record
|
|
|
#֪ͨ¿Í»§¶Ë
|
self.NotifyXMZZSelfInfo(curPlayer)
|
self.NotifyXMZZInfo(curPlayer)
|
return True
|
|
def GetWinCntPrize(self, curPlayer, getWinCnt):
|
#ÁìȡʤÀû³¡´Î½±Àø
|
playerID = curPlayer.GetID()
|
if playerID not in self.XMZZPlayerDict:
|
GameWorld.DebugLog('ÏÉħ֮ÕùÁìȡʤÀû³¡´Î½±Àø 䱨Ãû²Î¼Ó£¡', playerID)
|
return
|
if getWinCnt > self.XMZZPlayerDict[playerID].WinCnt:
|
GameWorld.DebugLog('ÏÉħ֮ÕùÁìȡʤÀû³¡´Î½±Àø ʤ³¡Êý²»×ã getWinCnt=%s£¡' % getWinCnt, playerID)
|
return
|
winCntAwardDict = IpyGameDataPY.GetFuncEvalCfg('XMZZAward', 1, {})
|
if str(getWinCnt) not in winCntAwardDict:
|
GameWorld.DebugLog('ÏÉħ֮ÕùÁìȡʤÀû³¡´Î½±Àø δÅäÖøó¡´Î½±Àø getWinCnt=%s£¡' % getWinCnt, playerID)
|
return
|
keyList = [int(cnt) for cnt in winCntAwardDict.keys()]
|
keyList.sort()
|
index = keyList.index(getWinCnt)
|
#ÊÇ·ñÒÑÁìÈ¡
|
awardRecord = self.XMZZPlayerDict[playerID].WinAwardRecord
|
|
if awardRecord & pow(2, index):
|
GameWorld.DebugLog('ÏÉħ֮ÕùÁìȡʤÀû³¡´Î½±Àø ÒÑÁìÈ¡¸Ã½±Àø getWinCnt=%s£¡' % getWinCnt, playerID)
|
#ÒÑÁìÈ¡¸Ã½±Àø
|
return
|
self.XMZZPlayerDict[playerID].WinAwardRecord = awardRecord | pow(2, index)
|
self.NotifyXMZZSelfInfo(curPlayer)
|
return 1
|
|
def GiveXMZZAward(self):
|
##»î¶¯½áÊø¸ø½±Àø
|
if not self.XMZZPlayerDict:
|
return
|
hasSendAward = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_XMZZIsOver) #ÊÇ·ñ½áËã¹ý
|
if hasSendAward:
|
GameWorld.DebugLog(' GiveXMZZAward ÒѾ½áËã¹ý£¡')
|
return
|
|
winCntAwardDict = IpyGameDataPY.GetFuncEvalCfg('XMZZAward', 1, {})
|
winCntList = [int(cnt) for cnt in winCntAwardDict.keys()]
|
winCntList.sort()
|
topScorePlayerID = 0
|
topScore = 0
|
Faction_1_IDList = [] #ÏÉ×åÕóÓªÍæ¼Ò
|
Faction_2_IDList = [] #ħ×åÕóÓªÍæ¼Ò
|
for playerID, XMZZData in self.XMZZPlayerDict.items():
|
curWinCnt = XMZZData.WinCnt
|
winCntAwardRecord = XMZZData.WinAwardRecord
|
score = XMZZData.Score
|
faction = XMZZData.Faction
|
#ʤÀû³¡´Î½±ÀøÓʼþ²¹·¢
|
if curWinCnt >= winCntList[0]:
|
winCntAwardList = []
|
for i, winCnt in enumerate(winCntList):
|
if curWinCnt < winCnt:
|
break
|
if winCntAwardRecord & pow(2, i):
|
continue
|
winCntAwardRecord |= pow(2, i)
|
winCntAwardList += winCntAwardDict[str(winCnt)]
|
if winCntAwardList:
|
XMZZData.WinAwardRecord = winCntAwardRecord #¸üмǼ
|
PlayerCompensation.SendMailByKey('XMZZWinCnt', [playerID], winCntAwardList, [curWinCnt])
|
if score > topScore:
|
topScorePlayerID = playerID
|
topScore = score
|
if faction == Faction_1:
|
Faction_1_IDList.append(playerID)
|
else:
|
Faction_2_IDList.append(playerID)
|
|
|
|
#µÚÒ»»ý·Ö½±Àø
|
if topScorePlayerID:
|
topScoreAward = IpyGameDataPY.GetFuncEvalCfg('XMZZAward', 2)
|
if topScoreAward:
|
PlayerCompensation.SendMailByKey('XMZZTopScore', [topScorePlayerID], topScoreAward, [topScore])
|
SavePKRecord('XMZZ_FirstPlace', [self.XMZZTopPlayerName, self.XMZZTopScore], False)
|
|
#Ѻע½±Àø
|
self.BetOverLogic()
|
|
#ÕóÓª½±Àø
|
winAward = IpyGameDataPY.GetFuncEvalCfg('XMZZAward', 3)
|
LoseAward = IpyGameDataPY.GetFuncEvalCfg('XMZZAward', 4)
|
dogfallAward = IpyGameDataPY.GetFuncEvalCfg('XMZZAward', 5)
|
result = self.GetXMZZCurResult()
|
if result == Faction_1:
|
SavePKRecord('XMZZ_Victory', [result], True)
|
PlayerCompensation.SendMailByKey('XMZZWin', Faction_1_IDList, winAward)
|
PlayerCompensation.SendMailByKey('XMZZLose', Faction_2_IDList, LoseAward)
|
elif result == Faction_2:
|
SavePKRecord('XMZZ_Victory', [result], True)
|
PlayerCompensation.SendMailByKey('XMZZWin', Faction_2_IDList, winAward)
|
PlayerCompensation.SendMailByKey('XMZZLose', Faction_1_IDList, LoseAward)
|
else: #ƽ¾Ö Ë«·½ÕóÓª»ý·Ö´ïµ½1000»ý·ÖʱÉúЧ
|
XMZZDogFallLimit = IpyGameDataPY.GetFuncCfg('XMZZDogFallLimit')
|
faction_1_Score = self.XMZZFactionDict.get(Faction_1, [0, 0])[0]
|
faction_2_Score = self.XMZZFactionDict.get(Faction_2, [0, 0])[0]
|
if faction_1_Score + faction_2_Score >= XMZZDogFallLimit:
|
SavePKRecord('XMZZ_Draw', [], True)
|
|
PlayerCompensation.SendMailByKey('XMZZDogfall', Faction_2_IDList + Faction_1_IDList, [], goldPaper=dogfallAward)
|
#PlayerControl.MergeWorldNotify(0, '', [])
|
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_XMZZIsOver, 1)
|
self.NotifyXMZZInfo()
|
return
|
|
def ResetXMZZ(self):
|
#ÖØÖÃ
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_XMZZIsOver, 0)
|
self.XMZZPlayerDict = {}
|
self.XMZZFactionDict = {Faction_1:[0, 0], Faction_2:[0, 0]}
|
self.XMZZTopPlayerName = ''
|
self.XMZZTopScore = 0
|
self.vsPlayerIDDict = {}
|
GameWorld.GetUniversalRecMgr().Delete(RecType)
|
GameWorld.GetUniversalRecMgr().Delete(RecType1)
|
PlayerUniversalGameRec.SendUniversalGameRecInfo(None, RecType1)
|
playerManager = GameWorld.GetPlayerManager()
|
for i in range(0, playerManager.GetPlayerCount()):
|
curPlayer = playerManager.GetPlayerByIndex(i)
|
if curPlayer == None or not curPlayer.GetInitOK():
|
continue
|
self.NotifyXMZZSelfInfo(curPlayer, True)
|
self.NotifyXMZZInfo()
|
return
|
|
def NotifyXMZZSelfInfo(self, curPlayer, isReset=False):
|
##×Ô¼ºÏà¹ØÊý¾Ý
|
playerID = curPlayer.GetID()
|
if not isReset and playerID not in self.XMZZPlayerDict:
|
return
|
xmzzData = self.XMZZPlayerDict.get(playerID)
|
packData = ChPyNetSendPack.tagGCXMZZSelfInfo()
|
packData.Clear()
|
if xmzzData:
|
packData.Faction = xmzzData.Faction
|
packData.Score = xmzzData.Score
|
packData.WinCnt = xmzzData.WinCnt
|
packData.WinCntAwardRecord = xmzzData.WinAwardRecord
|
betInfoDict = eval(xmzzData.BetRecord) #{¾º²ÂË÷Òý:[ѺעÄÄ·½Ê¤,ѺÁ˶àÉÙÇ®]}
|
packData.BetRecord = json.dumps(betInfoDict, ensure_ascii=False)
|
packData.Len = len(packData.BetRecord)
|
NetPackCommon.SendFakePack(curPlayer, packData)
|
return
|
|
def NotifyXMZZInfo(self, curPlayer=None):
|
#»î¶¯Ïà¹ØÊý¾Ý
|
packData = ChPyNetSendPack.tagGCXMZZInfo()
|
packData.Clear()
|
#resutlDict = self.GetStageResultRecord()
|
#packData.StageRecord = json.dumps(resutlDict, ensure_ascii=False)
|
#packData.Len = len(packData.StageRecord)
|
packData.Score1 = self.XMZZFactionDict[Faction_1][0]
|
packData.Score2 = self.XMZZFactionDict[Faction_2][0]
|
packData.TopScore = self.XMZZTopScore
|
packData.TopName = self.XMZZTopPlayerName
|
|
if curPlayer:
|
NetPackCommon.SendFakePack(curPlayer, packData)
|
else:
|
playerManager = GameWorld.GetPlayerManager()
|
for playerID in self.XMZZPlayerDict.keys():
|
notifyPlayer = playerManager.FindPlayerByID(playerID)
|
if notifyPlayer == None:
|
continue
|
if PlayerControl.GetIsTJG(notifyPlayer):
|
continue
|
|
NetPackCommon.SendFakePack(notifyPlayer, packData)
|
return
|
|
# ±£´æÊý¾Ý ´æÊý¾Ý¿âºÍrealtimebackup
|
def GetSaveData(self):
|
savaData = ""
|
cntData = ""
|
cnt = 0
|
for XMZZData in self.XMZZPlayerDict.values():
|
cnt += 1
|
savaData += XMZZData.getBuffer()
|
|
GameWorld.Log("SaveXMZZ cnt :%s" % cnt)
|
return CommFunc.WriteDWORD(cntData, cnt) + savaData
|
|
# ´ÓÊý¾Ý¿âÔØÈëÊý¾Ý
|
def LoadPyGameData(self, datas, pos, dataslen):
|
cnt, pos = CommFunc.ReadDWORD(datas, pos)
|
GameWorld.Log("LoadXMZZ cnt :%s" % cnt)
|
|
self.XMZZPlayerDict = {}
|
self.XMZZFactionDict = {Faction_1:[0, 0], Faction_2:[0, 0]}
|
self.XMZZTopScore = 0
|
self.XMZZTopPlayerName = ''
|
for _ in xrange(cnt):
|
data = PyGameDataStruct.tagDBPyXMZZ()
|
data.clear()
|
pos += data.readData(datas, pos, dataslen)
|
playerID = data.PlayerID
|
self.XMZZPlayerDict[playerID] = data
|
faction = data.Faction
|
score = data.Score
|
self.XMZZFactionDict[faction][0] += score
|
self.XMZZFactionDict[faction][1] += 1
|
if score > self.XMZZTopScore:
|
self.XMZZTopScore = score
|
self.XMZZTopPlayerName = data.Name
|
return pos
|
|
|
def RandomBattler(curPlayer, overInfo=[]):
|
#ɸѡ¶ÔÊÖ ¸ù¾ÝÁ¬Ê¤´ÎÊýÒ»¶¨¼¸ÂÊËæ»úµ½¸ß¼¶»úÆ÷ÈË£¬·ñÔòÿ5¸öµÄµÚ1¸öµÍÓÚ×Ô¼ºÕ½Á¦ ÏÈ´ÓС·¶Î§Ëæ»ú£¬ÔÙ´ó·¶Î§Ëæ»ú£¬Ã»ÓÐÔòÓÃNPC
|
global g_playerPowerDict
|
global g_historyPKDict
|
myPlayerID = curPlayer.GetID()
|
GameWorld.DebugLog(' ÏÉħ֮Õù¿ªÊ¼É¸Ñ¡¶ÔÊÖ', myPlayerID)
|
XMZZManager = PyDataManager.GetXMZZManager()
|
XMZZPlayerDict = XMZZManager.XMZZPlayerDict
|
|
if myPlayerID not in XMZZPlayerDict:
|
GameWorld.DebugLog(" ÏÉħ֮Õùϵͳ×Ô¶¯±¨Ãû!", myPlayerID)
|
if not XMZZManager.DoAllocationFaction(curPlayer):
|
GameWorld.DebugLog(' ÏÉħ֮Õùɸѡ¶ÔÊÖ, ϵͳ×Ô¶¯±¨Ãûʧ°Ü£¡£¡', myPlayerID)
|
return
|
|
pkPlayerID = 0 # ĬÈϵͼ¶»úÆ÷ÈË
|
isRobotNPC = True
|
pkDataDict = {}
|
conWinCnt = XMZZPlayerDict[myPlayerID].ConWinCnt #²ÎÊý
|
XMZZSpecialNPCRate = eval(IpyGameDataPY.GetFuncCfg('XMZZSpecialNPCRate'))
|
XMZZNPCByLVPowerList = IpyGameDataPY.GetFuncEvalCfg('XMZZPKPowerRange', 2)
|
isByLVPower = conWinCnt + 1 in XMZZNPCByLVPowerList #ÊÇ·ñ°´µÈ¼¶±íÕ½Á¦À´Ëæ»ú·¶Î§
|
|
if not isByLVPower and GameWorld.CanHappen(XMZZSpecialNPCRate):
|
GameWorld.DebugLog(' ɸѡ¶ÔÊÖ ¸ß¼¶»úÆ÷ÈË XMZZSpecialNPCRate=%s' % (XMZZSpecialNPCRate))
|
#»úÆ÷ÈËID¹æÔò: ID´Ó0~n, n²»´óÓÚ»úÆ÷ÈËIDÁÐ±í³¤¶È, IDÔ½´ó»úÆ÷ÈËÔ½¸ß¼¶£¬¸ù¾Ý²ß»®ÐèÇó×ÔÔö
|
#¸ß¼¶»úÆ÷ÈË
|
pkPlayerID = 1
|
else:
|
historyPKList = g_historyPKDict.get(myPlayerID, [])
|
myFaction = XMZZManager.GetPlayerXMZZFaction(myPlayerID)
|
if isByLVPower:
|
worldLv = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)
|
ipyData = IpyGameDataPY.GetIpyGameData('PlayerLV', worldLv)
|
myPower = ipyData.GetReFightPower() if ipyData else curPlayer.GetFightPower()
|
else:
|
myPower = curPlayer.GetFightPower()
|
XMZZPKPowerRange = IpyGameDataPY.GetFuncEvalCfg('XMZZPKPowerRange')
|
minPower1, maxPower1 = myPower * (100 - XMZZPKPowerRange[0][0]) / 100, myPower * (100 + XMZZPKPowerRange[0][1]) / 100
|
minPower2, maxPower2 = myPower * (100 - XMZZPKPowerRange[1][0]) / 100, myPower * (100 + XMZZPKPowerRange[1][1]) / 100
|
underList1, aboveList1 = [], [] #С·¶Î§
|
underList2, aboveList2 = [], [] #´ó·¶Î§
|
|
ViewCacheMgr = GameWorld.GameWorldData.GetPlayerViewCacheMgr()
|
for i in xrange(ViewCacheMgr.GetCount()):
|
curCache = ViewCacheMgr.At(i)
|
itemData = PlayerViewCache.GetItemData(curCache)
|
if not itemData:
|
#ûÓÐ×°±¸ÐÅÏ¢
|
continue
|
playerID = curCache.GetPlayerID()
|
|
if myPlayerID == playerID:
|
#²»ºÍ×Ô¼ºpk
|
continue
|
if XMZZManager.GetPlayerXMZZFaction(playerID) == myFaction:
|
#ͬÕóÓªµÄ²»PK
|
continue
|
if playerID in historyPKList:
|
#ÒÑÆ¥Åä¹ýµÄÌø¹ý
|
continue
|
|
if playerID in g_playerPowerDict:
|
power = g_playerPowerDict[playerID]
|
else:
|
propDataDict = eval(curCache.GetPropData())
|
power = propDataDict.get('FightPower', 0)
|
g_playerPowerDict[playerID] = power
|
|
pkDataDict[playerID] = [curCache.GetPropData(), curCache.GetItemData()]
|
#GameWorld.DebugLog(' ɸѡ¶ÔÊÖ playerID=%s,power=%s' % (playerID, power))
|
if minPower1 < power < myPower:
|
underList1.append(playerID)
|
if myPower < power < maxPower1:
|
aboveList1.append(playerID)
|
if minPower2 < power < myPower:
|
underList2.append(playerID)
|
if myPower < power < maxPower2:
|
aboveList2.append(playerID)
|
GameWorld.DebugLog(' ɸѡ¶ÔÊÖ myPower=%s,underList1=%s, aboveList1=%s,underList2=%s, aboveList2=%s' % (myPower, underList1, aboveList1, underList2, aboveList2), myPlayerID)
|
|
if conWinCnt % 5 == 0: #ÿ5¸öÆ¥ÅäÕ½Á¦µÍµÄ¶ÔÊÖ
|
if underList1:
|
pkPlayerID = underList1[0]
|
elif underList2:
|
pkPlayerID = underList2[0]
|
|
else:
|
if underList1 + aboveList1:
|
pkPlayerID = random.choice(underList1 + aboveList1)
|
elif underList2 + aboveList2:
|
pkPlayerID = random.choice(underList2 + aboveList2)
|
elif historyPKList:
|
pkPlayerID = random.choice(historyPKList)
|
#ÖØÖÃÀúÊ·PK¶ÔÊÖ
|
g_historyPKDict[myPlayerID] = []
|
|
if pkPlayerID:
|
isRobotNPC = False
|
|
if isRobotNPC:
|
#»úÆ÷ÈË, Ö°ÒµËæ»ú
|
openJob = IpyGameDataPY.GetFuncEvalCfg("OpenJob")
|
PropData = str({"Job":random.choice(openJob), "LV":curPlayer.GetLV()})
|
ItemData = "" # Ç°¶Ë×Ô¼º¸ù¾ÝÖ°Òµ¼°NPCµÈ¼¶´¦Àí
|
else:
|
if myPlayerID in g_historyPKDict:
|
g_historyPKDict[myPlayerID].append(pkPlayerID)
|
else:
|
g_historyPKDict[myPlayerID] = [pkPlayerID]
|
|
PropData, ItemData = pkDataDict.get(pkPlayerID, ["", ""])
|
XMZZManager.vsPlayerIDDict[myPlayerID] = pkPlayerID
|
|
GameWorld.DebugLog(' ÏÉħ֮ÕùÆ¥Åä¶ÔÊÖÐÅÏ¢ pkPlayerID=%s, PropData=%s, overInfo=%s' % (pkPlayerID, PropData, overInfo), myPlayerID)
|
|
#֪ͨǰ¶Ë
|
packData = ChPyNetSendPack.tagGCXMZZFightInfo()
|
packData.Clear()
|
packData.PlayerID = pkPlayerID
|
packData.PropData = PropData
|
packData.PropDataSize = len(packData.PropData)
|
packData.ItemData = ItemData
|
packData.ItemDataSize = len(packData.ItemData)
|
NetPackCommon.SendFakePack(curPlayer, packData)
|
|
#֪ͨµØͼ
|
pkPlayerPropData = {}
|
if PropData:
|
pkPlayerPropData = eval(PropData)
|
else:
|
GameWorld.ErrLog("ÏÉħ֮ÕùûÓÐÆ¥Åäµ½¶ÔÊÖÐÅÏ¢£¡fightPower=%s" % curPlayer.GetFightPower(), myPlayerID)
|
vsPlayerInfo = [pkPlayerID, pkPlayerPropData]
|
XMZZManager.MapServer_XMZZPKInfo(curPlayer, overInfo, vsPlayerInfo)
|
return True
|
|
|
def SavePKRecord(sysMark,paramList=[], isSys=False):
|
#PKÐÅÏ¢¼Ç¼
|
if isSys:
|
PlayerControl.WorldNotify(0, sysMark, paramList)
|
maxCnt = IpyGameDataPY.GetFuncCfg('XMZZPKRecord', 2)
|
universalRecMgr = GameWorld.GetUniversalRecMgr()
|
recordList = universalRecMgr.GetTypeList(RecType1)
|
if recordList.Count() >= maxCnt:
|
recordList.Delete(0)
|
|
|
paramList = [str(param) for param in paramList]
|
strValue3 = '|'.join(paramList)
|
|
recData = recordList.AddRec()
|
recData.SetStrValue1(sysMark)
|
recData.SetStrValue3(strValue3)
|
#֪ͨ
|
#PlayerUniversalGameRec.SendUniversalGameRecInfo(None, RecType1)
|
return
|
|
def XMZZPKOver(curPlayer, vsName, isWin=True, isEnd=False, HPPer=100):
|
#PK½áÊø£¬¸üнá¹û»ý·Ö
|
playerID = curPlayer.GetID()
|
XMZZManager = PyDataManager.GetXMZZManager()
|
if playerID not in XMZZManager.XMZZPlayerDict:
|
return False
|
|
hasSendAward = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_XMZZIsOver) #ÊÇ·ñ½áËã¹ý
|
if hasSendAward:
|
GameWorld.DebugLog(' XMZZPKOver ÒѾ½áËã¹ý£¡')
|
result = [isWin, True, 0, 0, XMZZManager.XMZZPlayerDict[playerID].ConWinCnt]
|
XMZZManager.MapServer_XMZZPKInfo(curPlayer, result, [])
|
return False
|
|
if playerID not in XMZZManager.vsPlayerIDDict:
|
GameWorld.DebugLog(' XMZZPKOver ûÓжÔÊÖ self.vsPlayerIDDict=%s'%XMZZManager.vsPlayerIDDict, playerID)
|
return False
|
XMZZManager.vsPlayerIDDict.pop(playerID)
|
|
oldConWinCnt = XMZZManager.XMZZPlayerDict[playerID].ConWinCnt
|
needRecordConCntList = IpyGameDataPY.GetFuncEvalCfg('XMZZPKRecord')
|
if isWin:
|
XMZZManager.XMZZPlayerDict[playerID].WinCnt += 1
|
XMZZManager.XMZZPlayerDict[playerID].ConWinCnt += 1
|
else:
|
XMZZManager.XMZZPlayerDict[playerID].LoseCnt += 1
|
#self.XMZZPlayerDict[playerID].ConWinCnt = 0 ÊäÁËÖ±½Ó½áËãÍ˳ö£¬ËùÒÔ´Ë´¦²»ÖØÖÃ
|
|
|
conWinCnt = XMZZManager.XMZZPlayerDict[playerID].ConWinCnt
|
addPerList = IpyGameDataPY.GetFuncEvalCfg('XMZZPKAward')
|
addPerIndex = min(max(0, conWinCnt - 1), len(addPerList)-1)
|
addPer = addPerList[addPerIndex] #Á¬Ê¤Ôö¼ÓµÄ°Ù·Ö±È
|
if isWin:
|
winAddScoreFormula = IpyGameDataPY.GetFuncCompileCfg('XMZZPKAward', 2)
|
addScore = eval(winAddScoreFormula)
|
#Á¬Ê¤¼Ç¼
|
if conWinCnt in needRecordConCntList:
|
SavePKRecord('XMZZ_Streak', [curPlayer.GetName(), vsName, conWinCnt, addScore])
|
#Á¬Ê¤³É¾Í
|
PlayerControl.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_XMZZConWin, 1, [conWinCnt])
|
else:
|
failAddScoreFormula = IpyGameDataPY.GetFuncCompileCfg('XMZZPKAward', 3)
|
addScore = eval(failAddScoreFormula)
|
if oldConWinCnt in needRecordConCntList:
|
SavePKRecord('XMZZ_ShutDown', [vsName, curPlayer.GetName(), oldConWinCnt])
|
|
#·¢ÖÁµØͼ½áËã
|
result = [isWin, isEnd, addScore, addPer, conWinCnt]
|
|
XMZZManager.XMZZPlayerDict[playerID].Score += addScore
|
if XMZZManager.XMZZPlayerDict[playerID].Score > XMZZManager.XMZZTopScore:
|
#»ý·ÖÍõ±ä¸ü
|
XMZZManager.XMZZTopScore = XMZZManager.XMZZPlayerDict[playerID].Score
|
XMZZManager.XMZZTopPlayerName = XMZZManager.XMZZPlayerDict[playerID].Name
|
|
faction = XMZZManager.XMZZPlayerDict[playerID].Faction
|
XMZZManager.XMZZFactionDict[faction][0] += addScore
|
|
#֪ͨ
|
XMZZManager.NotifyXMZZInfo()
|
XMZZManager.NotifyXMZZSelfInfo(curPlayer)
|
|
if not isEnd:
|
#Æ¥ÅäÏÂÒ»¸ö¶ÔÊÖ
|
RandomBattler(curPlayer, result)
|
else:
|
XMZZManager.MapServer_XMZZPKInfo(curPlayer, result, [])
|
GameWorld.DebugLog("¸üÐÂÏÉħ֮Õù»ý·Ö playerID=%s,addScore=%s,addPer=%s,faction=%s,isWin=%s,conWin=%s" %
|
(playerID, addScore,addPer, faction, isWin, XMZZManager.XMZZPlayerDict[playerID].ConWinCnt))
|
return True
|
|
#// AC 03 ÏÉħ֮ÕùÐÅÏ¢²éѯ #tagCGXMZZInfoQuery
|
#
|
#struct tagCGXMZZInfoQuery
|
#{
|
# tagHead Head;
|
#};
|
def OnQueryXMZZInfo(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
PyDataManager.GetXMZZManager().NotifyXMZZInfo(curPlayer)
|
return
|
