#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package CrossFamilyGCZ
|
#
|
# @todo:ÏÉÃ˹¥³ÇÕ½
|
# @author hxp
|
# @date 2025-04-09
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: ÏÉÃ˹¥³ÇÕ½
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2025-04-09 16:00"""
|
#-------------------------------------------------------------------------------
|
|
import GameWorld
|
import ShareDefine
|
import PlayerFamily
|
import IpyGameDataPY
|
import CrossRealmMsg
|
import CrossBillboard
|
import PlayerViewCache
|
import CrossActionControl
|
import PlayerCompensation
|
import ChPyNetSendPack
|
import NetPackCommon
|
import PyDataManager
|
import PlayerControl
|
import GameXiangong
|
import PyGameData
|
import ChConfig
|
import ChPlayer
|
|
import random
|
import copy
|
import time
|
|
|
## 1-¹«Ê¾ÆÚ£»99-Áì½±ÆÚ£»ÂÖ´Î״̬=ÂÖ´Î*10+Âִν׶Σ»Âִν׶Σº1-·Ö×éÕ½±¸£»2-Õ½¶·£»3-ÐÝÕ½
|
FamilyGCZState_Publicity = 1 # ¹«Ê¾ÆÚ
|
FamilyGCZState_Award = 99 # ½áÊøÁì½±ÆÚ
|
|
# ÂÖ´Î״̬ÐÅÏ¢
|
FamilyGCZRoundState_Group = 1 # ·Ö×é+Õ½±¸
|
FamilyGCZRoundState_Fight = 2 # Õ½¶·
|
FamilyGCZRoundState_Over = 3 # ÐÝÕ½£¬¸Ã½×¶Î¿ÉÓпÉÎÞ£¬Óɲ߻®ÅäÖþö¶¨£¬³ÌÐò½áËãÂß¼²»ÒÀÀµÓë´Ë״̬
|
|
# Õ½³¡ÀàÐÍ
|
BatTypeList = (
|
BatType_Junior, # ³õ¼¶ 1
|
BatType_Middle, # Öм¶ 2
|
BatType_High, # ¸ß¼¶ 3
|
) = range(1, 1 + 3)
|
|
BatType_Min = BatType_Junior
|
BatType_Max = BatType_High
|
|
# ½ú½µ¼¶ÀàÐÍ
|
(
|
UpdownState_None, # δ´¦Àí 0
|
UpdownState_Down, # ½µ¼¶ 1
|
UpdownState_Keep, # ±£¼¶ 2
|
UpdownState_Up, # ½ú¼¶ 3
|
) = range(4)
|
|
# ÿ×é¹Ì¶¨ÏÉÃËÊý
|
Def_PerGroupFamilyCnt = 12
|
|
# ¹¥»÷ÀàÐÍ
|
(
|
AtkType_Normal, # ÆÕͨµ¥¹¥ 1
|
AtkType_SkillSingle, # ¼¼Äܵ¥¹¥ 2
|
AtkType_SkillArea, # ¼¼ÄÜȺ¹¥ 3
|
) = range(1, 1 + 3)
|
|
# ¹¥»÷½á¹û
|
(
|
AtkRet_OK, # ³É¹¦ 0
|
AtkRet_TagDead, # Ä¿±êÒѱ»»÷ɱ 1
|
AtkRet_TagBroken, # ³Ç³ØÒѱ»´Ý»Ù 3
|
AtkRet_Other, # ÆäËû 3
|
) = range(4)
|
|
# ÐÞÂ޳dzØID£¬Ã¿¸ö·Ö×鶼ÔÊÐíÓи÷×ÔµÄÐÞÂ޳ǣ¬ID¿ÉÒÔÒ»Ñù
|
XiuluoCityID = 2000000000
|
|
# ½±ÀøÀàÐÍ
|
(
|
AwwardType_Guess, # ¾º²Â
|
AwwardType_PlayerHurt, # ¸öÈËÉ˺¦ÅÅÐÐ
|
AwwardType_FamilyScore, # ÏÉÃË»ý·ÖÅÅÐÐ
|
AwwardType_Like, # µãÔÞ
|
) = range(4)
|
|
|
class FamilyGCZFighter(object):
|
## ³Ç³ØÕ½¶··ÀÊØÈËÔ± - Íæ¼Ò¡¢ÊØÎÀÕ½¶·Àà
|
|
def __init__(self):
|
self.fighterID = 0
|
self.hp = 0 # µ±Ç°ÑªÁ¿
|
self.hpMax = 0 # ×î´óѪÁ¿
|
self.hpBase = 0 # »ù´¡ÑªÁ¿£¬²»Ëã¼Ó³É
|
self.fightPower = 0 # Õ½¶·Á¦
|
return
|
|
def IsDead(self): return self.hp <= 0
|
|
def RefreshFighterAttr(self, hpFightPowerMulti, addHPPer):
|
self.hpBase = self.fightPower * hpFightPowerMulti
|
self.hpMax = int(self.hpBase * (100 + addHPPer) / 100.0)
|
self.hp = self.hpMax # ֻҪˢÊôÐԾͻØÂúѪ£¬Õ½¶·½×¶Î»áËøס²»ÔÊÐíË¢ÊôÐÔ
|
return
|
|
class FamilyGCZCityWall():
|
## ³Ç³Ø
|
|
def __init__(self, zoneID=0, cityID=0, cityLV=0, familyID=0):
|
self.zoneID = zoneID
|
self.batType = 0
|
self.groupNum = 0
|
self.cityID = cityID # ³Ç³ØID
|
self.cityLV = cityLV # ³Ç³ØµÈ¼¶£¬Ò»°ãΪËø¶¨Ê±µÄ´ó±¾ÓªµÈ¼¶£¬»òÖ¸¶¨µÄµÈ¼¶£¬Õ½¶·ÊôÐÔ¼Ó³ÉÓɸõȼ¶¾ö¶¨
|
self.familyID = familyID # ËùÊôÏÉÃËID£¬¿ÉÄÜÎÞ¹éÊô£¬ÈçÐÞÂÞ³Ç
|
self.guardMemIDList = [] # ·ÀÊØÕ½¶·ÈËÔ±IDÁÐ±í£¬±»»÷ɱ²»±ä
|
self.fighterIDList = [] # ·ÀÊØÕ½¶·ÈËÔ±IDÁÐ±í£¬°´³ÉÔ±Õ½Á¦ÉýÐòÅÅ£¬NPCÊØÎÀ + ³ÉÔ±£¬±»»÷ɱÒƳý
|
|
self.guardNPCCount = 0 # ÊØÎÀNPCÊý£¬ÕâÀïÖ¸µÄÊÇ·ÇÍæ¼ÒµÄϵͳÊØÎÀ
|
self.guardNPC = FamilyGCZFighter() # µ±Ç°NPCÊØÎÀ£¬Ä¿Ç°½öÐÞÂÞ³ÉÓÐÓÃ
|
|
self.attrLock = 0 # ÊÇ·ñËø¶¨ÊôÐÔ
|
self.hp = 0 # µ±Ç°ÑªÁ¿£¬ËùÓзÀÊØÕ½¶·ÈËÔ±hp Ö®ºÍ
|
self.hpMax = 0 # ×î´óѪÁ¿£¬ËùÓзÀÊØÕ½¶·ÈËÔ±hp hpMax Ö®ºÍ
|
self.hpBase = 0 # »ù´¡ÑªÁ¿£¬²»Ëã¼Ó³É£¬ËùÓзÀÊØÕ½¶·ÈËÔ±hp hpBase Ö®ºÍ
|
self.fightPowerTotal = 0 # ×ÜÕ½Á¦
|
|
self.atkedTime = 0 # ×îºóÒ»´Î±»¹¥»÷ʱ¼ä´Á
|
self.atkReportDict = {} # ¹¥»÷Õ½±¨ {tagFamilyID:totalHurt, ...}
|
self.defReportDict = {} # ·ÀÊØÕ½±¨ {tagFamilyID:totalHurt, ...}
|
self.fighterHurtDict = {} # Õ½¶·³ÉÔ±¹±Ï×É˺¦£¬±»»÷»Ùºó²»»áÔÙÀÛ¼Ó {playerID:hurtValue, ...}
|
self.inCityPlayerIDList = [] # ÔÚÕ½¶·³Ç³ØÀïµÄÍæ¼ÒIDÁбí
|
return
|
|
def ResetDefense(self, cityLV, guardMemIDList=None, guardNPCCount=0):
|
## ³Ç³ØÖØÖ÷ÀÓù
|
self.attrLock = 0
|
self.cityLV = cityLV
|
self.guardMemIDList = []
|
self.guardNPCCount = guardNPCCount
|
if self.guardNPCCount:
|
self.guardMemIDList += range(1, 1 + self.guardNPCCount)
|
if guardMemIDList:
|
self.guardMemIDList += guardMemIDList
|
self.atkedTime = 0
|
self.atkReportDict = {}
|
self.defReportDict = {}
|
self.fighterHurtDict = {}
|
self.inCityPlayerIDList = []
|
self.RefreshCityAttr()
|
return
|
|
def OnFightStart(self):
|
## Õ½¶·¿ªÊ¼ - Ëø¶¨
|
self.RefreshCityAttr()
|
self.attrLock = 1 # Ë¢ÍêÊôÐÔºóËøס
|
return
|
|
def IsBroken(self):
|
## ÊÇ·ñ±»»÷»Ù
|
if self.hp <= 0 or not self.fighterIDList:
|
return True
|
return False
|
|
def GetCurGuardID(self):
|
## µ±Ç°ÊØÎÀID
|
if not self.fighterIDList:
|
return 0
|
return self.fighterIDList[0]
|
|
def NextGuard(self):
|
## »»ÏÂÒ»¸öÊØÎÀ
|
if not self.fighterIDList:
|
return 0
|
self.fighterIDList.pop(0)
|
if not self.fighterIDList:
|
return 0
|
nextGuardID = self.fighterIDList
|
if self.IsGuardNPC(nextGuardID):
|
self.guardNPC.hp = self.guardNPC.hpMax
|
GameWorld.DebugLog(" Çл»ÏÂÒ»¸öNPCÊØÎÀ: %s, %s/%s" % (nextGuardID, self.guardNPC.hp, self.guardNPC.hpMax))
|
else:
|
GameWorld.DebugLog(" Çл»ÏÂÒ»¸ö·ÀÊØÈËÔ±: %s" % nextGuardID)
|
return nextGuardID
|
|
def IsGuardNPC(self, fighterID):
|
## ÊÇ·ñϵͳNPCÊØÎÀ£¬¼ÓÉÏϵͳNPCÊýÑéÖ¤£¬¼æÈÝÄÚÍø¼ÙÏÉÃ˳ÉÔ±²âÊÔ
|
return self.guardNPCCount > 0 and fighterID < 10000
|
|
def RefreshCityAttr(self, cityLV=None):
|
# @return: ÊÇ·ñ³É¹¦Ë¢ÐÂÊôÐÔ£¬Õ½¶·Ëø¶¨Ê±ÎÞ·¨Ë¢ÊôÐÔ
|
if self.attrLock:
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½ÒѾËø¶¨Õ½¶·ÊôÐÔ²»ÄÜË¢ÐÂ! cityID=%s,familyID=%s" % (self.cityID, self.familyID))
|
return
|
if cityLV != None:
|
self.cityLV = cityLV
|
cityID = self.cityID
|
cityLV = self.cityLV
|
addHPPer = 0
|
campIpyData = IpyGameDataPY.GetIpyGameData("CrossActFamilyGCZCampLV", cityLV)
|
if campIpyData:
|
addHPPer = campIpyData.GetAddHPPer()
|
|
hpFightPowerMulti = IpyGameDataPY.GetFuncCfg("FamilyGCZCity", 1) # ³ÉÔ±ÉúÃüÊÇÕ½Á¦µÄx±¶
|
GameWorld.DebugLog("ÏÉÃ˹¥³ÇսˢгdzØÊôÐÔ: cityID=%s,cityLV=%s,addHPPer=%s,hpFightPowerMulti=%s" % (cityID, cityLV, addHPPer, hpFightPowerMulti))
|
|
zone = GetFamilyGCZMgr().GetActZone(self.zoneID)
|
|
self.hpBase = 0
|
self.hpMax = 0
|
self.fightPowerTotal = 0
|
sortFighterIDList = []
|
for fighterID in self.guardMemIDList:
|
if self.IsGuardNPC(fighterID):
|
fighter = self.guardNPC
|
fighter.fightPower = IpyGameDataPY.GetFuncCfg("FamilyGCZXiuluo", 1)
|
else:
|
fighter = zone.GetZoneJoinMember(fighterID)
|
|
fighter.RefreshFighterAttr(hpFightPowerMulti, addHPPer)
|
|
self.hpBase += fighter.hpBase
|
self.hpMax += fighter.hpMax
|
self.fightPowerTotal += fighter.fightPower
|
|
sortFighterIDList.append([fighter.fightPower, fighterID])
|
GameWorld.DebugLog(" ³ÉÔ±ÊôÐÔ: cityID=%s,fighterID=%s,fightPower=%s,hpBase=%s,hpMax=%s,cityHPMax=%s"
|
% (cityID, fighterID, fighter.fightPower, fighter.hpBase, fighter.hpMax, self.hpMax))
|
|
sortFighterIDList.sort() # °´Õ½Á¦ÉýÐò
|
self.fighterIDList = [f[1] for f in sortFighterIDList]
|
|
self.hp = self.hpMax # ֻҪˢÊôÐԾͻØÂúѪ£¬Õ½¶·½×¶Î»áËøס²»ÔÊÐíË¢ÊôÐÔ
|
|
GameWorld.DebugLog(" ³Ç³ØÊôÐÔ: cityID=%s,cityLV=%s,fightPowerTotal=%s,hpBase=%s,hpMax=%s" % (cityID, cityLV, self.fightPowerTotal, self.hpBase, self.hpMax))
|
GameWorld.DebugLog(" ·ÀÊØÈËÔ±Õ½Á¦IDÅÅÐò=%s" % sortFighterIDList)
|
GameWorld.DebugLog(" ·ÀÊØÈËÔ±IDÅÅÐò˳Ðò=%s" % self.fighterIDList)
|
return True
|
|
def SetPlayerInCity(self, playerID, serverGroupID):
|
if playerID not in self.inCityPlayerIDList:
|
self.inCityPlayerIDList.append(playerID)
|
Sync_FamilyGCZBatCityInfo(self.zoneID, self.batType, self.groupNum, self.cityID, toPlayerServerDict={playerID:serverGroupID})
|
return
|
|
def SetPlayerOutCity(self, playerID):
|
if playerID in self.inCityPlayerIDList:
|
self.inCityPlayerIDList.remove(playerID)
|
return
|
|
class FamilyGCZMember(FamilyGCZFighter):
|
## ²ÎÓëµÄ³ÉÔ±
|
|
def __init__(self, zoneID=0, familyID=0, playerID=0):
|
super(FamilyGCZMember, self).__init__()
|
self.zoneID = zoneID
|
self.batType = 0
|
self.groupNum = 0
|
self.playerID = playerID
|
self.familyID = familyID # ²ÎÓëʱµÄÏÉÃËID
|
self.fighterID = playerID
|
self.fmLV = 0 # ²ÎÓëʱµÄÏÉÃËְλµÈ¼¶
|
self.playerName = ""
|
self.job = 0
|
self.realmLV = 0
|
self.face = 0
|
self.facePic = 0
|
self.lv = 0
|
self.totalHurtValue = 0 # »î¶¯×ÜÉ˺¦£¬¿ÉÄÜÎÞ·¨ÉÏ°ñ£¬¼Ç¼ÓÃ
|
self.awardState = 0 # »î¶¯·¢½±Í¬²½¼Ç¼£¬Óë×Ó·þµÄÍæ¼Ò¸öÈ˼Ǽ¶ÔÓ¦£¬¸Ã¼Ç¼½öÓÃÓÚ²¹·¢½±ÀøÓÃ
|
return
|
|
class FamilyGCZFamily():
|
## ²ÎÓëµÄÏÉÃË
|
|
def __init__(self, zoneID=0, familyID=0):
|
self.zoneID = zoneID
|
self.familyID = familyID
|
self.batType = 0
|
self.groupNum = 0
|
self.campLV = 1 # ´ó±¾ÓªµÈ¼¶
|
self.campExp = 0
|
self.roundInfoDict = {} # ÏÉÃËÂÖ´ÎÐÅÏ¢»ã×Ü {ÂÖ´Î:{k:v, ...}, ...} k-batType,groupNum,rank,score,updownState
|
self.sortWeight = 0 # °ñµ¥±È½ÏȨֵ£¬ÓÃÓÚƽ·Ö»òÉ˺¦ÏàͬʱµÄ±È½ÏȨֵ
|
|
self.familyName = ""
|
self.lv = 0
|
self.leaderID = 0
|
self.leaderName = ""
|
self.emblemID = 0
|
self.serverID = 0
|
self.fightPowerTotal = 0
|
|
self.joinMemberIDList = [] # ²ÎÓëµÄ³ÉÔ±IDÁбí [playerID, ...]
|
self.memAddCampExpInfo = {} # ³ÉÔ±¹±Ï×´ó±¾Óª¾ÑéÐÅÏ¢ {playerID:addExp, ...}
|
self.cityWall = FamilyGCZCityWall(zoneID, familyID, self.campLV, familyID) # ÿ¸öÃË×Ô´øÒ»¸ö³Ç³Ø
|
return
|
|
def OnRoundFamilyReset(self):
|
## ÂÖ´ÎÖØÖô¦Àí
|
self.batType = 0
|
self.groupNum = 0
|
self.cityWall.ResetDefense(self.campLV, self.joinMemberIDList)
|
self.fightPowerTotal = self.cityWall.fightPowerTotal
|
Sync_FamilyGCZCampInfo(self.zoneID, self.familyID)
|
return
|
|
def OnRoundFamilyFightStart(self):
|
## ÂִοªÕ½
|
self.cityWall.OnFightStart()
|
self.fightPowerTotal = self.cityWall.fightPowerTotal
|
Sync_FamilyGCZCampInfo(self.zoneID, self.familyID)
|
return
|
|
def RefreshFamilyAttr(self, isNotify=True):
|
## Ë¢ÐÂÏÉÃËÕ½¶·ÊôÐÔ
|
isOK = self.cityWall.RefreshCityAttr(self.campLV)
|
self.fightPowerTotal = self.cityWall.fightPowerTotal
|
if isNotify:
|
Sync_FamilyGCZCampInfo(self.zoneID, self.familyID)
|
return isOK
|
|
def GetTotalScore(self):
|
## »ñÈ¡ÏÉÃ˵±Ç°×Ü»ý·Ö£¬ËùÓÐÂִλý·ÖµÄ×ܺÍ
|
totalScore = 0
|
for info in self.roundInfoDict.values():
|
totalScore += info.get("score", 0)
|
return totalScore
|
|
def AddCampExp(self, playerID, addCampExp, isNotify=True):
|
## ´ó±¾Óª¼Ó¾Ñé
|
# @return: ÊÇ·ñÉý¼¶
|
if playerID not in self.joinMemberIDList:
|
# ·Ç±¾ÃËËø¶¨³ÉÔ±²»ÄܼӾÑé
|
GameWorld.ErrLog("·ÇÏÉÃ˹¥³ÇÕ½Ëø¶¨³ÉÔ±ÎÞ·¨¼Ó´ó±¾Óª¾Ñé! familyID=%s,playerID=%s not in %s" % (self.familyID, playerID, self.joinMemberIDList))
|
return
|
|
campLV = self.campLV
|
campExp = self.campExp
|
updCampExp = min(campExp + addCampExp, ChConfig.Def_UpperLimit_DWord)
|
updCampLV = campLV
|
|
# Âú¼¶ÁËÒ²²»ÏÞÖƾèÏ×£¬ÈÃÍæ¼Ò¿ÉÒÔ¼ÌÐøÏûºÄ¶àÓàµÄµÀ¾ß
|
campIpyData = IpyGameDataPY.GetIpyGameData("CrossActFamilyGCZCampLV", campLV)
|
if campIpyData and campIpyData.GetLVUPNeedExp():
|
lvupNeedExp = campIpyData.GetLVUPNeedExp()
|
if updCampExp >= lvupNeedExp and IpyGameDataPY.GetIpyGameDataNotLog("CrossActFamilyGCZCampLV", campLV + 1):
|
updCampExp -= lvupNeedExp
|
updCampLV = campLV + 1
|
|
self.campLV = updCampLV
|
self.campExp = updCampExp
|
self.memAddCampExpInfo[playerID] = self.memAddCampExpInfo.get(playerID, 0) + addCampExp
|
|
GameWorld.DebugLog("Ôö¼Ó´ó±¾Óª¾Ñé: familyID=%s,playerID=%s,addCampExp=%s,campLV-Exp=%s-%s,updLV-Exp=%s-%s,playerAddExpTotal=%s"
|
% (self.familyID, playerID, addCampExp, campLV, campExp, updCampLV, updCampExp, self.memAddCampExpInfo[playerID]))
|
|
# Éý¼¶ÁË
|
defMemIDList = [] # ¼Ó¾ÑéĬÈϲ»Í¨Öª·ÀÊسÉÔ±ÊôÐÔ
|
isLVUP = False
|
if campLV != updCampLV:
|
isLVUP = True
|
GameWorld.DebugLog("´ó±¾ÓªÉý¼¶ÁË! familyID=%s,campLV=%s to %s" % (self.familyID, campLV, updCampLV))
|
if self.RefreshFamilyAttr(False):
|
defMemIDList = None # Éý¼¶ºó³É¹¦Ë¢³ÉÔ±ÊôÐԺ󣬶îÍ⸽´øËùÓзÀÊسÉÔ±ÐÅÏ¢£¬Õ½¶·½×¶ÎÊôÐÔÊÇËø¶¨µÄ
|
|
if isNotify:
|
Sync_FamilyGCZCampInfo(self.zoneID, self.familyID, defMemIDList=defMemIDList)
|
|
return isLVUP
|
|
def GetOLMemServerGroupIDDict(self):
|
## »ñÈ¡±¾ÃËÔÚÏß²ÎÓë³ÉÔ±ÐÅÏ¢
|
olDict = {}
|
onlineMgr = ChPlayer.GetOnlinePlayerMgr()
|
for playerID in self.joinMemberIDList:
|
serverGroupID = onlineMgr.GetOLPlayerServerGroupID(playerID)
|
if serverGroupID:
|
olDict[playerID] = serverGroupID
|
return olDict
|
|
class FamilyGCZBatGroup():
|
## Õ½¶··Ö×é
|
|
def __init__(self, zoneID, batType, groupNum):
|
self.zoneID = zoneID
|
self.batType = batType
|
self.groupNum = groupNum
|
|
# ³Ç³Ø²¢²»Ò»¶¨¹éÊôÓÚij¸öÏÉÃËËùÒÔÓÉ·Ö×é×ÔÐйÜÀí
|
self.cityWallDict = {} # ³Ç³Ø¶ÔÏóÐÅÏ¢ {cityID:FamilyGCZCityWall, ...}
|
self.__cityIDList = [] # ³Ç³ØIDÁÐ±í£¬°´Ìí¼Ó˳ÐòµÄÁбí
|
self.__topHurtPlayerID = 0 # ±¾×éÉ˺¦µÚÒ»Íæ¼ÒID
|
self.__topHurtPlayerValue = 0 # ±¾×éÉ˺¦µÚÒ»Íæ¼ÒÉ˺¦
|
self.inBatScenePlayerIDList = [] # ÔÚÕ½¶·³¡¾°ÖеÄÍæ¼ÒIDÁбí [playerID, ...]
|
return
|
|
def GetTopHurtPlayerIDValue(self):
|
## »ñÈ¡±¾×éÓÐЧÉ˺¦µÚÒ»Íæ¼Ò£¬½öËã³Ç³Øδ±»´Ý»ÙÇ°µÄÀÛ¼ÆÉ˺¦
|
if self.__topHurtPlayerID and self.__topHurtPlayerValue:
|
return self.__topHurtPlayerID, self.__topHurtPlayerValue
|
|
for cityID in self.cityWallDict.keys():
|
cityWall = self.GetCityWall(cityID)
|
if not cityWall:
|
continue
|
for playerID, hurtTotal in cityWall.fighterHurtDict.items():
|
if hurtTotal > self.__topHurtPlayerValue:
|
self.__topHurtPlayerID = playerID
|
|
return self.__topHurtPlayerID, self.__topHurtPlayerValue
|
def UpdTopHurtPlayerIDValue(self, topPlayerID, topHurtValue):
|
self.__topHurtPlayerID, self.__topHurtPlayerValue = topPlayerID, topHurtValue
|
return
|
|
def GetCityIDList(self):
|
if not self.__cityIDList:
|
self.__cityIDList = self.cityWallDict.keys()
|
return self.__cityIDList
|
|
def GetCityWall(self, cityID):
|
## »ñȡij¸ö³Ç³Ø£¬¿ÉÄÜΪNone
|
cityWall = None
|
if cityID in self.cityWallDict:
|
cityWall = self.cityWallDict[cityID]
|
elif False: # ²»¿ÉÄÜÖ´ÐУ¬Ìáʾ´úÂëÓÃ
|
cityWall = FamilyGCZCityWall()
|
return cityWall
|
|
def GetGroupFamilyIDList(self):
|
familyIDList = []
|
for cityID in self.GetCityIDList():
|
city = self.GetCityWall(cityID)
|
if not city:
|
continue
|
familyID = city.familyID
|
if familyID not in familyIDList:
|
familyIDList.append(familyID)
|
return familyIDList
|
|
def AddGroupFamily(self, familyID):
|
## ½«ÏÉÃË·ÖÅäµ½¸Ã·Ö×é
|
zone = GetFamilyGCZMgr().GetActZone(self.zoneID)
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
return
|
joinFamily.batType = self.batType
|
joinFamily.groupNum = self.groupNum
|
for playerID in joinFamily.joinMemberIDList:
|
joinMember = zone.GetZoneJoinMember(playerID)
|
if not joinMember:
|
continue
|
joinMember.batType = self.batType
|
joinMember.groupNum = self.groupNum
|
|
joinFamily.cityWall.batType = self.batType
|
joinFamily.cityWall.groupNum = self.groupNum
|
cityID = joinFamily.cityWall.cityID
|
self.cityWallDict[cityID] = joinFamily.cityWall
|
if cityID not in self.__cityIDList:
|
self.__cityIDList.append(cityID)
|
return joinFamily
|
|
def CreateCityWall(self, cityID, cityLV, guardMemIDList=None, guardNPCCount=0, isAttrLock=False):
|
'''´´½¨×Ô¶¨Òå³Ç³Ø£¬ÈçÐÞÂÞ³Ç
|
@param cityID: ×Ô¶¨Òå³Ç³ØID
|
@param cityLV: ³Ç³ØµÈ¼¶
|
@param guardMemIDList: ²¼·ÀÍæ¼ÒIDÁбí
|
@param guardNPCCount: ²¼·ÀϵͳNPCÊýÁ¿
|
³Ç³Ø×ÜÊôÐÔ£º (²¼·ÀµÄÍæ¼Ò + ²¼·ÀϵͳNPC)ÊôÐÔ×ܺÍ
|
'''
|
guardNPCCount = min(guardNPCCount, 100)
|
newCity = FamilyGCZCityWall(self.zoneID, cityID, cityLV)
|
newCity.batType = self.batType
|
newCity.groupNum = self.groupNum
|
newCity.ResetDefense(cityLV, guardNPCCount=guardNPCCount)
|
if isAttrLock:
|
newCity.attrLock = 1
|
self.cityWallDict[cityID] = newCity
|
if cityID not in self.__cityIDList:
|
self.__cityIDList.append(cityID)
|
return newCity
|
|
def SetPlayerInScene(self, playerID, serverGroupID):
|
if playerID not in self.inBatScenePlayerIDList:
|
self.inBatScenePlayerIDList.append(playerID)
|
Sync_FamilyGCZBatSceneInfo(self.zoneID, self.batType, self.groupNum, toPlayerServerDict={playerID:serverGroupID})
|
return
|
|
def SetPlayerOutScene(self, playerID):
|
if playerID in self.inBatScenePlayerIDList:
|
self.inBatScenePlayerIDList.remove(playerID)
|
return
|
|
class FamilyGCZZone():
|
## ¹¥³ÇÕ½·ÖÇø
|
|
def __init__(self, zoneID):
|
self.zoneID = zoneID
|
self.joinFamilyCnt = 0
|
self.lockFamilyIDList = [] # Ëø¶¨µÄÏÉÃËIDÁбí
|
self.joinFamilyDict = {} # ²ÎÓëÏÉÃ˶ÔÏóÐÅÏ¢ {familyID:FamilyGCZFamily, ...}
|
self.joinMemberDict = {} # ²ÎÓëÍæ¼Ò¶ÔÏóÐÅÏ¢ {playerID:FamilyGCZMember, ...}
|
self.roundGroupDict = {} # µ±Ç°ÂִηÖ×éÐÅÏ¢ {batType:{groupNum:FamilyGCZBatGroup, ...}, ...}
|
self.roundNum = 0 # roundGroupDict Êý¾Ý¶ÔÓ¦µÄÂÖ´Î
|
self.roundOver = 0 # roundNumÂÖ´ÎÊÇ·ñÒѽáËãÁË
|
self.familyGuessDict = {} # ÏÉÃ˾º²ÂÈȶÈÐÅÏ¢ {familyID:value, ...}
|
self.playerGuessDict = {} # Íæ¼Ò¾º²Â¼Ç¼ {playerID:[familyID, ...], ...}
|
|
self.statGuessRetDict = None # ͳ¼Æ¾º²Â½á¹û {awardID:[²ÂÖÐÍæ¼ÒID, ...], ...}
|
self.guessFinalFamilyIDList = [] # ¾º²Â×îÖÕÅÅÃûÏÉÃËIDÁбí
|
self.inBatScenePlayerIDDict = {} # ÔÚÕ½¶·³¡¾°ÖеÄÍæ¼ÒID {(batType, groupNum):[playerID, ...], ...}
|
self.inBatCityPlayerIDDict = {} # ÔÚÕ½¶·³Ç³ØÖеÄÍæ¼ÒID {(batType, groupNum, cityID):[playerID, ...], ...}
|
return
|
|
def OnRoundReset(self, roundNum):
|
## ·ÖÇøÂÖ´ÎÖØÖÃ
|
self.roundNum = roundNum
|
self.roundOver = 0
|
self.roundGroupDict = {}
|
self.inBatScenePlayerIDDict = {}
|
self.inBatCityPlayerIDDict = {}
|
for familyID in self.lockFamilyIDList:
|
joinFamily = self.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
continue
|
joinFamily.OnRoundFamilyReset()
|
return
|
|
def OnRoundFightStart(self):
|
## ·ÖÇøÂִοªÊ¼
|
for familyID in self.lockFamilyIDList:
|
joinFamily = self.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
continue
|
joinFamily.OnRoundFamilyFightStart()
|
return
|
|
def AddBatGroup(self, batType, groupNum):
|
if batType not in self.roundGroupDict:
|
self.roundGroupDict[batType] = {}
|
groupNumDict = self.roundGroupDict[batType]
|
batGroup = FamilyGCZBatGroup(self.zoneID, batType, groupNum)
|
groupNumDict[groupNum] = batGroup
|
return batGroup
|
|
def GetBatGroup(self, batType, groupNum):
|
## »ñȡij¸ö·Ö×飬¿ÉÄÜΪNone
|
if batType not in self.roundGroupDict:
|
self.roundGroupDict[batType] = {}
|
groupNumDict = self.roundGroupDict[batType]
|
batGroup = groupNumDict.get(groupNum, None)
|
if batGroup == None and False: # ²»¿ÉÄÜÖ´ÐУ¬Ìáʾ´úÂëÓÃ
|
batGroup = FamilyGCZBatGroup()
|
return batGroup
|
|
## »ñÈ¡±¾·ÖÇø²ÎÓëµÄÏÉÃËIDÁÐ±í£¬°´Ëø¶¨Ë³ÐòµÄ
|
def GetZoneLockFamilyIDList(self): return self.lockFamilyIDList
|
def GetZoneJoinFamily(self, familyID):
|
## »ñÈ¡±¾·ÖÇø²ÎÓëµÄÏÉÃË£¬¿ÉÄÜΪNone
|
joinFamily = None
|
if familyID in self.joinFamilyDict:
|
joinFamily = self.joinFamilyDict[familyID]
|
elif False: # ²»¿ÉÄÜÖ´ÐУ¬Ìáʾ´úÂëÓÃ
|
joinFamily = FamilyGCZFamily()
|
return joinFamily
|
|
def AddZoneJoinFamily(self, familyID):
|
## Ìí¼Ó²ÎÓëÏÉÃË
|
joinFamily = None
|
if familyID in self.joinFamilyDict:
|
joinFamily = self.joinFamilyDict[familyID]
|
else:
|
joinFamily = FamilyGCZFamily(self.zoneID, familyID)
|
self.joinFamilyDict[familyID] = joinFamily
|
if familyID not in self.lockFamilyIDList:
|
self.lockFamilyIDList.append(familyID)
|
GetFamilyGCZMgr().SetFamilyIDZoneID(familyID, self.zoneID)
|
return joinFamily
|
|
def GetZoneJoinMember(self, playerID):
|
## »ñÈ¡±¾·ÖÇø²ÎÓëµÄÍæ¼Ò£¬¿ÉÄÜΪNone
|
joinMember = None
|
if playerID in self.joinMemberDict:
|
joinMember = self.joinMemberDict[playerID]
|
elif False: # ²»¿ÉÄÜÖ´ÐУ¬Ìáʾ´úÂëÓÃ
|
joinMember = FamilyGCZMember()
|
return joinMember
|
|
def AddZoneJoinMember(self, playerID, familyID):
|
## Ìí¼Ó²ÎÓë³ÉÔ±
|
joinMember = None
|
if playerID in self.joinMemberDict:
|
joinMember = self.joinMemberDict[playerID]
|
else:
|
joinMember = FamilyGCZMember(self.zoneID, familyID, playerID)
|
self.joinMemberDict[playerID] = joinMember
|
GetFamilyGCZMgr().SetPlayerIDZoneID(playerID, self.zoneID)
|
return joinMember
|
|
def GetOLServerGroupIDDict(self):
|
## »ñÈ¡±¾·ÖÇøÔÚÏß²ÎÓë³ÉÔ±ÐÅÏ¢
|
olDict = {}
|
for joinFamily in self.joinFamilyDict.values():
|
olDict.update(joinFamily.GetOLMemServerGroupIDDict())
|
return olDict
|
|
def SetPlayerInBatScene(self, playerID, batType=0, groupNum=0, serverGroupID=0):
|
## ÉèÖÃÍæ¼ÒÔÚij¸öÕ½¶·³¡¾°£¬²ÎÊýĬÈÏ0ΪÍ˳ö
|
for bType, groupDict in self.roundGroupDict.items():
|
for gNum in groupDict.keys():
|
batGroup = self.GetBatGroup(bType, gNum)
|
if not batGroup:
|
continue
|
if batType != bType or groupNum != gNum:
|
batGroup.SetPlayerOutScene(playerID)
|
else:
|
batGroup.SetPlayerInScene(playerID, serverGroupID)
|
return
|
|
def SetPlayerInBatCity(self, playerID, batType=0, groupNum=0, cityID=0, serverGroupID=0):
|
## ÉèÖÃÍæ¼ÒÔÚij¸öÕ½¶·³Ç³Ø£¬²ÎÊýĬÈÏ0ΪÍ˳ö
|
for bType, groupDict in self.roundGroupDict.items():
|
for gNum in groupDict.keys():
|
batGroup = self.GetBatGroup(bType, gNum)
|
if not batGroup:
|
continue
|
for cID in batGroup.GetCityIDList():
|
cityWall = batGroup.GetCityWall(cID)
|
if not cityWall:
|
continue
|
if batType != bType or groupNum != gNum or cityID != cID:
|
cityWall.SetPlayerOutCity(playerID)
|
else:
|
cityWall.SetPlayerInCity(playerID, serverGroupID)
|
return
|
|
class FamilyGCZMgr():
|
## ÏÉÃ˹¥³ÇÕ½¹ÜÀí
|
|
def __init__(self):
|
self.zoneDict = {} # ·ÖÇøÐÅÏ¢ {zone:FamilyGCZZone, ...}
|
self.familyIDZoneIDDict = {} # ÏÉÃËIDËùÔÚ·ÖÇø {familyID:zoneID, ...}
|
self.playerIDZoneIDDict = {} # Íæ¼ÒIDËùÔÚ·ÖÇø {playerID:zoneID, ...}
|
return
|
|
def SetFamilyIDZoneID(self, familyID, zoneID):
|
self.familyIDZoneIDDict[familyID] = zoneID
|
return
|
|
def SetPlayerIDZoneID(self, playerID, zoneID):
|
self.playerIDZoneIDDict[playerID] = zoneID
|
return
|
|
def ClearGCZZone(self, zoneID):
|
self.zoneDict.pop(zoneID, None)
|
for familyID, fZoneID in self.familyIDZoneIDDict.items():
|
if fZoneID == zoneID:
|
self.familyIDZoneIDDict.pop(familyID)
|
for playerID, pZoneID in self.playerIDZoneIDDict.items():
|
if pZoneID == zoneID:
|
self.playerIDZoneIDDict.pop(playerID)
|
return
|
|
def GetActZone(self, zoneID):
|
## »ñÈ¡·ÖÇø¹ÜÀí
|
zone = None
|
if zoneID in self.zoneDict:
|
zone = self.zoneDict[zoneID]
|
else:
|
zone = FamilyGCZZone(zoneID)
|
self.zoneDict[zoneID] = zone
|
return zone
|
|
def GetJoinFamily(self, familyID):
|
## Ö±½Ó»ñȡij¸ö²ÎÓëÏÉÃËÐÅÏ¢
|
joinFamily = None
|
if familyID in self.familyIDZoneIDDict:
|
zoneID = self.familyIDZoneIDDict[familyID]
|
zone = self.GetActZone(zoneID)
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
elif False: # ²»¿ÉÄÜÖ´ÐУ¬Ìáʾ´úÂëÓÃ
|
joinFamily = FamilyGCZFamily()
|
return joinFamily
|
|
def GetJoinFamilyByPlayerID(self, playerID):
|
## Ö±½Ó»ñȡij¸ö²ÎÓëÏÉÃËÐÅÏ¢ - ¸ù¾Ý³ÉÔ±Íæ¼ÒID
|
joinFamily = None
|
if playerID in self.playerIDZoneIDDict:
|
zoneID = self.playerIDZoneIDDict[playerID]
|
zone = self.GetActZone(zoneID)
|
joinMember = zone.GetZoneJoinMember(playerID)
|
if joinMember:
|
joinFamily = zone.GetZoneJoinFamily(joinMember.familyID)
|
elif False: # ²»¿ÉÄÜÖ´ÐУ¬Ìáʾ´úÂëÓÃ
|
joinFamily = FamilyGCZFamily()
|
return joinFamily
|
|
def GetJoinMember(self, playerID):
|
## Ö±½Ó»ñȡij¸ö²ÎÓëÍæ¼ÒÐÅÏ¢
|
joinMember = None
|
if playerID in self.playerIDZoneIDDict:
|
zoneID = self.playerIDZoneIDDict[playerID]
|
zone = self.GetActZone(zoneID)
|
joinMember = zone.GetZoneJoinMember(playerID)
|
elif False: # ²»¿ÉÄÜÖ´ÐУ¬Ìáʾ´úÂëÓÃ
|
joinMember = FamilyGCZMember()
|
return joinMember
|
|
def GetFamilyGCZMgr():
|
mgr = PyGameData.g_familyGCZMgr
|
if not mgr:
|
mgr = FamilyGCZMgr()
|
PyGameData.g_familyGCZMgr = mgr
|
return mgr
|
|
def OnLoadPyData():
|
|
if not GameWorld.IsCrossServer():
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
gameRecMgr = PyDataManager.GetDBGameRecDataManager()
|
|
recDataDict = gameRecMgr.GetGameRecDataDict(ShareDefine.Def_GameRecType_FamilyGCZMgr)
|
for zoneID, zoneRecDataList in recDataDict.items():
|
if not zoneRecDataList:
|
continue
|
zoneRecData = zoneRecDataList[0] # ·ÖÇø¹ÜÀí£¬Ã¿¸ö·ÖÇøÖ»ÒªÒ»Ìõ¼Ç¼
|
joinFamilyCnt = zoneRecData.GetValue1()
|
zoneDataDict = zoneRecData.GetUserDataDict()
|
|
gczMgr.ClearGCZZone(zoneID)
|
|
zone = gczMgr.GetActZone(zoneID)
|
zone.joinFamilyCnt = joinFamilyCnt
|
zone.lockFamilyIDList = zoneDataDict.get("lockFamilyIDList", [])
|
zone.familyGuessDict = zoneDataDict.get("familyGuessDict", {})
|
zone.playerGuessDict = zoneDataDict.get("playerGuessDict", {})
|
zone.roundNum = zoneDataDict.get("roundNum", 0)
|
zone.roundOver = zoneDataDict.get("roundOver", 0)
|
GameWorld.Log("¼ÓÔØ·ÖÇø¼Ç¼! zoneID=%s,joinFamilyCnt=%s,lockCnt=%s,%s" % (zoneID, zone.joinFamilyCnt, len(zone.lockFamilyIDList), zone.lockFamilyIDList))
|
|
familyRecList = gameRecMgr.GetGameRecDataList(ShareDefine.Def_GameRecType_FamilyGCZJoinFamily, zoneID)
|
for fNum, familyRecData in enumerate(familyRecList, 1):
|
familyID = familyRecData.GetValue1()
|
batType = familyRecData.GetValue2()
|
groupNum = familyRecData.GetValue3()
|
campLV = familyRecData.GetValue4()
|
campExp = familyRecData.GetValue5()
|
familyDataDict = familyRecData.GetUserDataDict()
|
|
joinFamily = zone.AddZoneJoinFamily(familyID)
|
joinFamily.batType = batType
|
joinFamily.groupNum = groupNum
|
joinFamily.campLV = campLV
|
joinFamily.campExp = campExp
|
joinFamily.familyName = familyDataDict.get("familyName", "")
|
joinFamily.leaderID = familyDataDict.get("leaderID", 0)
|
joinFamily.leaderName = familyDataDict.get("leaderName", "")
|
joinFamily.lv = familyDataDict.get("lv", 0)
|
joinFamily.emblemID = familyDataDict.get("emblemID", 0)
|
joinFamily.serverID = familyDataDict.get("serverID", 0)
|
joinFamily.fightPowerTotal = familyDataDict.get("fightPowerTotal", 0)
|
joinFamily.joinMemberIDList = familyDataDict.get("joinMemberIDList", [])
|
joinFamily.memAddCampExpInfo = familyDataDict.get("memAddCampExpInfo", {})
|
joinFamily.roundInfoDict = familyDataDict.get("roundInfoDict", {})
|
joinFamily.sortWeight = familyDataDict.get("sortWeight", 0)
|
|
GameWorld.Log(" ¼ÓÔØ·ÖÇøÏÉÃË zoneID=%s,%s,familyID=%s,campLV=%s-%s,roundInfoDict=%s"
|
% (zoneID, fNum, familyID, joinFamily.campLV, joinFamily.campExp, joinFamily.roundInfoDict))
|
|
memberRecList = gameRecMgr.GetGameRecDataList(ShareDefine.Def_GameRecType_FamilyGCZJoinMember, zoneID)
|
for pNum, memberRecData in enumerate(memberRecList, 1):
|
playerID = memberRecData.GetValue1()
|
familyID = memberRecData.GetValue2()
|
batType = memberRecData.GetValue3()
|
groupNum = memberRecData.GetValue4()
|
fmLV = memberRecData.GetValue5()
|
playerDataDict = memberRecData.GetUserDataDict()
|
|
joinMember = zone.AddZoneJoinMember(playerID, familyID)
|
joinMember.batType = batType
|
joinMember.groupNum = groupNum
|
joinMember.fmLV = fmLV
|
joinMember.playerName = playerDataDict.get("playerName", "")
|
joinMember.job = playerDataDict.get("job", 1)
|
joinMember.realmLV = playerDataDict.get("realmLV", 1)
|
joinMember.face = playerDataDict.get("face", 0)
|
joinMember.facePic = playerDataDict.get("facePic", 0)
|
joinMember.lv = playerDataDict.get("lv", 1)
|
joinMember.totalHurtValue = playerDataDict.get("totalHurtValue", 0)
|
joinMember.awardState = playerDataDict.get("awardState", 0)
|
joinMember.hp = playerDataDict.get("hp", 0)
|
joinMember.hpMax = playerDataDict.get("hpMax", 0)
|
joinMember.hpBase = playerDataDict.get("hpBase", 0)
|
joinMember.fightPower = playerDataDict.get("fightPower", 0)
|
|
GameWorld.Log(" ¼ÓÔØ·ÖÇø³ÉÔ± zoneID=%s,familyID=%s,%s,playerID=%s,hp=%s/%s,totalHurtValue=%s"
|
% (zoneID, familyID, pNum, playerID, joinMember.hp, joinMember.hpMax, joinMember.totalHurtValue))
|
|
cityWallRecList = gameRecMgr.GetGameRecDataList(ShareDefine.Def_GameRecType_FamilyGCZCityWall, zoneID)
|
for cNum, cityRecData in enumerate(cityWallRecList, 1):
|
cityID = cityRecData.GetValue1()
|
batType = cityRecData.GetValue2()
|
groupNum = cityRecData.GetValue3()
|
cityLV = cityRecData.GetValue4()
|
familyID = cityRecData.GetValue5()
|
attrLock = cityRecData.GetValue6()
|
cityDataDict = cityRecData.GetUserDataDict()
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
batGroup = zone.AddBatGroup(batType, groupNum)
|
if not batGroup:
|
continue
|
if familyID:
|
batGroup.AddGroupFamily(familyID)
|
else:
|
batGroup.CreateCityWall(cityID, cityLV)
|
|
city = batGroup.GetCityWall(cityID)
|
if not city:
|
continue
|
|
city.cityLV = cityLV
|
city.attrLock = attrLock
|
city.guardMemIDList = cityDataDict.get("guardMemIDList", [])
|
city.fighterIDList = cityDataDict.get("fighterIDList", [])
|
city.guardNPCCount = cityDataDict.get("guardNPCCount", 0)
|
city.hp = cityDataDict.get("hp", 0)
|
city.hpMax = cityDataDict.get("hpMax", 0)
|
city.hpBase = cityDataDict.get("hpBase", 0)
|
city.fightPowerTotal = cityDataDict.get("fightPowerTotal", 0)
|
city.atkReportDict = cityDataDict.get("atkReportDict", {})
|
city.fighterHurtDict = cityDataDict.get("fighterHurtDict", {})
|
|
GameWorld.Log(" ¼ÓÔØ·ÖÇø³Ç³Ø zoneID=%s,batType=%s,batType=%s,%s,cityID=%s,familyID=%s,hp=%s/%s,fighterIDList=%s,%s"
|
% (zoneID, batType, groupNum, cNum, cityID, city.familyID, city.hp, city.hpMax, len(city.fighterIDList), city.fighterIDList))
|
|
return
|
|
def OnSavePyData():
|
if not GameWorld.IsCrossServer():
|
return
|
|
gameRecMgr = PyDataManager.GetDBGameRecDataManager()
|
gameRecMgr.DelGameRecDataByType(ShareDefine.Def_GameRecType_FamilyGCZMgr)
|
gameRecMgr.DelGameRecDataByType(ShareDefine.Def_GameRecType_FamilyGCZJoinFamily)
|
gameRecMgr.DelGameRecDataByType(ShareDefine.Def_GameRecType_FamilyGCZJoinMember)
|
gameRecMgr.DelGameRecDataByType(ShareDefine.Def_GameRecType_FamilyGCZCityWall)
|
|
gczMgr = GetFamilyGCZMgr()
|
zoneIDList = gczMgr.zoneDict.keys()
|
GameWorld.Log("±£´æÏÉÃ˹¥³ÇÕ½·ÖÇø¼Ç¼! zoneIDList=%s" % zoneIDList)
|
for zoneID in zoneIDList:
|
if not zoneID:
|
continue
|
zone = gczMgr.GetActZone(zoneID)
|
zoneRecData = gameRecMgr.AddGameRecData(ShareDefine.Def_GameRecType_FamilyGCZMgr, zoneID)
|
zoneRecData.SetValue1(zone.joinFamilyCnt)
|
lockFamilyIDList = zone.GetZoneLockFamilyIDList()
|
zoneData = {"lockFamilyIDList":lockFamilyIDList, "familyGuessDict":zone.familyGuessDict, "playerGuessDict":zone.playerGuessDict,
|
"roundNum":zone.roundNum, "roundOver":zone.roundOver}
|
zoneRecData.SetUserData(zoneData)
|
|
GameWorld.Log("----- zoneID=%s,joinFamilyCnt=%s,lockFamilyIDList=%s,%s" % (zoneID, zone.joinFamilyCnt, len(lockFamilyIDList), lockFamilyIDList))
|
|
for batType, groupDict in zone.roundGroupDict.items():
|
for groupNum in groupDict.keys():
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
continue
|
cityIDList = batGroup.GetCityIDList()
|
for cNum, cityID in enumerate(cityIDList, 1):
|
city = batGroup.GetCityWall(cityID)
|
if not city:
|
continue
|
cityRecData = gameRecMgr.AddGameRecData(ShareDefine.Def_GameRecType_FamilyGCZCityWall, zoneID)
|
cityRecData.SetValue1(cityID)
|
cityRecData.SetValue2(city.batType)
|
cityRecData.SetValue3(city.groupNum)
|
cityRecData.SetValue4(city.cityLV)
|
cityRecData.SetValue5(city.familyID)
|
cityRecData.SetValue6(city.attrLock)
|
cityData = {"guardMemIDList":city.guardMemIDList, "fighterIDList":city.fighterIDList, "guardNPCCount":city.guardNPCCount,
|
"hp":city.hp, "hpMax":city.hpMax, "hpBase":city.hpBase, "fightPowerTotal":city.fightPowerTotal,
|
"atkReportDict":city.atkReportDict, "defReportDict":city.defReportDict, "fighterHurtDict":city.fighterHurtDict}
|
cityRecData.SetUserData(cityData)
|
GameWorld.Log(" ±£´æ·ÖÇø³Ç³Ø zoneID=%s,batType=%s,groupNum=%s,%s,cityID=%s,familyID=%s,attrLock=%s,hp=%s/%s,fighterIDList=%s,%s"
|
% (zoneID, batType, groupNum, cNum, cityID, city.familyID, city.attrLock, city.hp, city.hpMax, len(city.fighterIDList), city.fighterIDList))
|
|
for fNum, familyID in enumerate(lockFamilyIDList, 1):
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
continue
|
familyRecData = gameRecMgr.AddGameRecData(ShareDefine.Def_GameRecType_FamilyGCZJoinFamily, zoneID)
|
familyRecData.SetValue1(familyID)
|
familyRecData.SetValue2(joinFamily.batType)
|
familyRecData.SetValue3(joinFamily.groupNum)
|
familyRecData.SetValue4(joinFamily.campLV)
|
familyRecData.SetValue5(joinFamily.campExp)
|
|
familyData = {"familyName":joinFamily.familyName, "leaderID":joinFamily.leaderID, "leaderName":joinFamily.leaderName,
|
"lv":joinFamily.lv, "emblemID":joinFamily.emblemID, "serverID":joinFamily.serverID, "fightPowerTotal":joinFamily.fightPowerTotal,
|
"joinMemberIDList":joinFamily.joinMemberIDList, "memAddCampExpInfo":joinFamily.memAddCampExpInfo,
|
"roundInfoDict":joinFamily.roundInfoDict, "sortWeight":joinFamily.sortWeight
|
}
|
familyRecData.SetUserData(familyData)
|
GameWorld.Log(" ±£´æ·ÖÇøÏÉÃË zoneID=%s,%s,familyID=%s,campLV=%s-%s,roundInfoDict=%s" % (zoneID, fNum, familyID, joinFamily.campLV, joinFamily.campExp, joinFamily.roundInfoDict))
|
|
for pNum, playerID in enumerate(joinFamily.joinMemberIDList, 1):
|
joinMember = zone.GetZoneJoinMember(playerID)
|
if not joinMember:
|
continue
|
memberRecData = gameRecMgr.AddGameRecData(ShareDefine.Def_GameRecType_FamilyGCZJoinMember, zoneID)
|
memberRecData.SetValue1(playerID)
|
memberRecData.SetValue2(familyID)
|
memberRecData.SetValue3(joinMember.batType)
|
memberRecData.SetValue4(joinMember.groupNum)
|
memberRecData.SetValue5(joinMember.fmLV)
|
|
memberData = {"playerName":joinMember.playerName, "job":joinMember.job, "realmLV":joinMember.realmLV,
|
"face":joinMember.face, "facePic":joinMember.facePic, "lv":joinMember.lv, "totalHurtValue":joinMember.totalHurtValue,
|
"awardState":joinMember.awardState,
|
"hp":joinMember.hp, "hpMax":joinMember.hpMax, "hpBase":joinMember.hpBase, "fightPower":joinMember.fightPower}
|
memberRecData.SetUserData(memberData)
|
GameWorld.Log(" ±£´æ·ÖÇø³ÉÔ± zoneID=%s,familyID=%s,%s,playerID=%s,hp=%s/%s,totalHurtValue=%s"
|
% (zoneID, familyID, pNum, playerID, joinMember.hp, joinMember.hpMax, joinMember.totalHurtValue))
|
|
return
|
|
def OnPlayerLogin_CrossLogic(serverGroupID, serverID, playerID):
|
## ±¾·þµÇ¼ʱ¿ç·þ·þÎñÆ÷ÐèÒª´¦ÀíµÄÂß¼
|
|
zoneID, familyID = GetPlayerActJoinInfo(playerID)
|
if not zoneID:
|
return
|
|
Sync_FamilyGCZActInfo(zoneID, playerID)
|
Sync_FamilyGCZBatGroupInfo(zoneID, {playerID:serverGroupID})
|
Sync_FamilyGCZCampInfo(zoneID, familyID, {playerID:serverGroupID})
|
Sync_FamilyGCZGuessInfo(zoneID, playerID, playerID)
|
return
|
|
def GetRoundState(state):
|
## »ñÈ¡ÂִΡ¢×´Ì¬ÐÅÏ¢
|
if state < 10 or state == FamilyGCZState_Award:
|
return 0, state
|
return state / 10, state % 10
|
|
def OnCrossActIDChange(cfgID, zoneID, ipyData, state):
|
## ¿ç·þ»î¶¯ID±ä¸ü
|
DoMailReissueAward(zoneID, ipyData)
|
DelFamilyGCZZone(zoneID)
|
return
|
|
def DelFamilyGCZZone(zoneID):
|
# Çå¿Õ»î¶¯Ïà¹ØÊý¾Ý
|
gameRecMgr = PyDataManager.GetDBGameRecDataManager()
|
gameRecMgr.DelGameRecDataByTypeID(ShareDefine.Def_GameRecType_FamilyGCZMgr, zoneID)
|
gameRecMgr.DelGameRecDataByTypeID(ShareDefine.Def_GameRecType_FamilyGCZJoinFamily, zoneID)
|
gameRecMgr.DelGameRecDataByTypeID(ShareDefine.Def_GameRecType_FamilyGCZJoinMember, zoneID)
|
gameRecMgr.DelGameRecDataByTypeID(ShareDefine.Def_GameRecType_FamilyGCZCityWall, zoneID)
|
|
# Çå¿Õ»î¶¯Ïà¹Ø°ñµ¥
|
billboardMgr = PyDataManager.GetCrossBillboardManager()
|
billboardMgr.ClearBillboard(ShareDefine.Def_CBT_FamilyGCZScore, zoneID)
|
billboardMgr.ClearBillboard(ShareDefine.Def_CBT_FamilyGCZPlayerHurt, zoneID)
|
billboardMgr.ClearBillboard(ShareDefine.Def_CBT_FamilyGCZRoundHurt, zoneID)
|
|
GetFamilyGCZMgr().ClearGCZZone(zoneID)
|
return
|
|
def OnCrossActStateChange(ipyData, actID, dbState, state):
|
## ¿ç·þ»î¶¯×´Ì¬±ä¸ü
|
|
zoneID = ipyData.GetZoneID()
|
if CrossActionControl.IsActFlowStateError(ShareDefine.CrossActName_FamilyGCZ, zoneID):
|
Sync_FamilyGCZActInfo(zoneID)
|
return
|
|
if state == FamilyGCZState_Publicity:
|
Sync_FamilyGCZActInfo(zoneID)
|
return
|
|
if state == FamilyGCZState_Award:
|
DoStartAward(zoneID)
|
return
|
|
curRound, roundState = GetRoundState(state)
|
if curRound > 0:
|
# ·Ö×é
|
if roundState == FamilyGCZRoundState_Group:
|
if curRound == 1: # µÚÒ»ÂÖ·Ö×éÇ°Ëø¶¨Ãûµ¥
|
DoLockActFamily(actID, ipyData)
|
DoRoundGroup(curRound, zoneID, ipyData.GetJoinFamilyCnt())
|
|
# ¿ªÊ¼Õ½¶·
|
elif roundState == FamilyGCZRoundState_Fight:
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
zone.OnRoundFightStart()
|
|
# ½áË㣬ע£º³ÌÐòµÄ½áËãÁ÷³Ì²»ÒÀÀµÓë´Ë״̬£¬Èç¹û²ß»®ÓÐÅäÖã¬ÔòÖ±½ÓÔڸý׶νáË㣬Èç¹ûûÓÐÅäÖÃÔòÔÚ·Ö×éʱ¡¢»î¶¯Á콱ʱ֮ǰУÑéÉÏÒ»ÂÖ½áËã
|
elif roundState == FamilyGCZRoundState_Over:
|
DoRoundOver(zoneID)
|
|
else:
|
pass
|
|
# ¾º²Â
|
DoGenerateGuess(zoneID, state)
|
return
|
|
def GetPlayerActJoinInfo(playerID):
|
'''»ñÈ¡Íæ¼Ò²ÎÓëµÄ»î¶¯ÐÅÏ¢£¬Èç¹û·µ»ØµÄÓзÖÇøID¼°»î¶¯ID£¬´ú±íÒ»¶¨ÊǻÖеÄ
|
±ØÐëÊÇzoneID¡¢actID¶¼Ò»Ö±²ÅÄÜÊÓΪͬһ¸ö»î¶¯£¬ÇÒactState·Ç0
|
@return: [zoneID, familyID]
|
'''
|
|
zoneID, familyID = 0, 0
|
defaultRet = (zoneID, familyID)
|
|
gczMgr = GetFamilyGCZMgr()
|
joinMember = gczMgr.GetJoinMember(playerID)
|
# ÓÐÔÚ²ÎÈü×ʸñÃûµ¥Àï
|
if joinMember:
|
zoneID, familyID = joinMember.zoneID, joinMember.familyID
|
return zoneID, familyID
|
|
# ×¢£º ¹«Ê¾ÆÚÆÚ¼äÒ²ÊÇûÓÐÔÚ×ʸñÀïµÄ£¬Ã»ÓвÎÓë×ʸñµÄ£¬ÔÝʱ¶¼ÊÓΪÆÕͨ³ÉÔ±
|
# ûÓÐÔڻÖвÎÓë×ʸñÀïµÄ£¬ÔÙ°´ËùÔÚ·þIDÅжÏ×ʸñ: µ±Ç°ËùÔÚÃË·þID > Íæ¼ÒËùÔÚ·þID
|
#
|
# ²ÎÓë×ʸñµÄÏà¹Ø¿ç·þ»î¶¯±¾Éí¾ßÓÐÒ»¶¨µÄÊý¾ÝÑÓ³ÙÈÝ´í¿Õ¼ä£¬Â߼ͳһÓÉ¿ç·þ·þÎñÆ÷´¦Àí
|
# ¹ÊûÓÐÔÚËø¶¨×ʸñÀïµÄÍæ¼Ò¿ÉÄÜ´æÔÚÒÔÏÂÇé¿ö
|
# 1. ûÓпç·þ²é¿´»º´æ£¬Ò»°ãΪδ´ïµ½¿ç·þÌõ¼þµÄºÅ»òÒÑÁ÷ʧ7ÌìµÄºÅ£¬¿ÉÊÓΪ²»²ÎÓë»î¶¯
|
# 2. Íæ¼Ò»º´æÖеÄÏÉÃËIDÔÚ¿ç·þ·þÎñÆ÷»¹ÔÚ£¬µ«×Ó·þÒѾ½âÉ¢ÁË£¬Ò»Ñù»¹ÊÇÓõĻº´æÖеÄÏÉÃËID£¬ÒòΪ»î¶¯±¾Éí¾ßÓÐÒ»¶¨µÄʱ¼ä²îÈÝ´í¿Õ¼ä£¬ËùÒÔ²»Ó°Ïì
|
cacheDict = PlayerViewCache.GetCachePropDataDict(PlayerViewCache.FindViewCache(playerID))
|
if not cacheDict:
|
return defaultRet
|
|
joinServerID = 0
|
familyIDNow = cacheDict.get("FamilyID", 0)
|
if familyIDNow:
|
curFamily = GameWorld.GetFamilyManager().FindFamily(familyIDNow)
|
if curFamily:
|
familyID = familyIDNow
|
joinServerID = curFamily.GetServerID()
|
|
if not joinServerID:
|
joinServerID = GameWorld.GetAccIDServerID(cacheDict.get("AccID", ""))
|
|
actInfo = CrossActionControl.GetCrossActInfoByServerGroupID(ShareDefine.CrossActName_FamilyGCZ, joinServerID)
|
if not actInfo or not actInfo.get(ShareDefine.ActKey_State):
|
# ·Ç»î¶¯ÖÐÖ±½Ó·µ»Ø
|
return defaultRet
|
ipyDataInfo = actInfo.get(ShareDefine.ActKey_IpyDataInfo)
|
if ipyDataInfo:
|
zoneID = ipyDataInfo.get("ZoneID", 0)
|
return zoneID, familyID
|
|
def OnCrossJoinFamilyMemberUpd(curFamily, updMemIDList):
|
## ±¾»î¶¯Ö»¸üвÎÓë»î¶¯³ÉÔ±Õ½Á¦£¬»»ÏÉÃ˵ijÉÔ±²»¸üÐÂÁË£¬ÒÔ×îºóÒ»´Î¸üÐÂΪ׼
|
if not curFamily:
|
return
|
|
familyID = curFamily.GetID()
|
gczMgr = GetFamilyGCZMgr()
|
joinFamily = gczMgr.GetJoinFamily(familyID)
|
if not joinFamily:
|
# ·ÇËø¶¨µÄÏÉÃ˲»¸üУ¬¿ÉÄÜûÓвÎÓë×ʸñ»òδËø¶¨
|
return
|
zoneID = joinFamily.zoneID
|
actInfo = CrossActionControl.GetCrossActInfoByZoneID(ShareDefine.CrossActName_FamilyGCZ, zoneID)
|
if not actInfo:
|
# ·Ç»î¶¯Öв»¸üÐÂ
|
return
|
state = actInfo.get(ShareDefine.ActKey_State)
|
if not state:
|
return
|
curRound, roundState = GetRoundState(state)
|
GameWorld.DebugLog("¸üÐÂÏÉÃ˹¥³ÇÕ½ÏÉÃ˳ÉÔ±: familyID=%s,zoneID=%s,state=%s,curRound=%s,roundState=%s"
|
% (familyID, zoneID, state, curRound, roundState))
|
|
zone = gczMgr.GetActZone(zoneID)
|
for playerID in updMemIDList:
|
joinMember = zone.GetZoneJoinMember(playerID)
|
if not joinMember:
|
continue
|
curMember = curFamily.FindMember(playerID)
|
if not curMember:
|
continue
|
joinMember.fightPower = max(joinMember.fightPower, PlayerFamily.GetMemberFightPower(curMember)) # ÒԽϴóÕ½Á¦Îª×¼
|
GameWorld.DebugLog(" playerID=%s,joinFamilyID=%s,updFightPower=%s" % (playerID, joinMember.familyID, joinMember.fightPower))
|
|
return
|
|
def DoLockActFamily(actID, ipyData):
|
## Ëø¶¨²ÎÓëÏÉÃËÃûµ¥
|
|
zoneID = ipyData.GetZoneID()
|
serverIDList = ipyData.GetServerIDRangeList()
|
joinFamilyCnt = ipyData.GetJoinFamilyCnt()
|
GameWorld.Log("ÏÉÃ˹¥³ÇÕ½Ëø¶¨²ÎÓëÏÉÃËÃûµ¥: zoneID=%s,serverIDList=%s,joinFamilyCnt=%s" % (zoneID, serverIDList, joinFamilyCnt))
|
sortFamilyList = PlayerFamily.SortCrossFamily(serverIDList, joinFamilyCnt)[0]
|
|
DelFamilyGCZZone(zoneID)
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
zone.joinFamilyCnt = joinFamilyCnt
|
|
for num, family in enumerate(sortFamilyList, 1):
|
familyID = family.GetID()
|
serverID = family.GetServerID()
|
|
joinFamily = zone.AddZoneJoinFamily(familyID)
|
familyBaseInfo = PlayerFamily.GetCrossFamilyBaseInfo(family)
|
joinFamily.familyName = familyBaseInfo.get("Name", "")
|
joinFamily.lv = familyBaseInfo.get("LV", 0)
|
joinFamily.leaderID = familyBaseInfo.get("LeaderID", 0)
|
joinFamily.leaderName = familyBaseInfo.get("LeaderName", "")
|
joinFamily.emblemID = familyBaseInfo.get("EmblemID", 0)
|
joinFamily.serverID = familyBaseInfo.get("ServerID", 0)
|
joinFamily.fightPowerTotal = familyBaseInfo.get("FightPower", 0)
|
joinFamily.campLV = 1
|
fightPowerTotal = joinFamily.fightPowerTotal
|
|
for i in range(0, family.GetCount()):
|
member = family.GetAt(i)
|
playerID = member.GetPlayerID()
|
if not playerID:
|
continue
|
|
memBaseInfo = PlayerFamily.GetCrossFamilyMemInfo(member)
|
joinMember = zone.AddZoneJoinMember(playerID, familyID)
|
joinMember.playerName = memBaseInfo.get("Name", "")
|
joinMember.lv = memBaseInfo.get("LV", 0)
|
joinMember.job = memBaseInfo.get("Job", 0)
|
joinMember.realmLV = memBaseInfo.get("OfficialRank", 0)
|
joinMember.face = memBaseInfo.get("Face", 0)
|
joinMember.facePic = memBaseInfo.get("FacePic", 0)
|
joinMember.fightPower = memBaseInfo.get("FightPower", 0)
|
joinMember.fmLV = memBaseInfo.get("FamilyLV", 0)
|
|
joinFamily.joinMemberIDList.append(playerID)
|
|
GameWorld.Log(" %s,familyID=%s,serverID=%s,fightPowerTotal=%s,memCnt=%s,%s"
|
% (num, familyID, serverID, fightPowerTotal, len(joinFamily.joinMemberIDList), joinFamily.joinMemberIDList))
|
|
Sync_FamilyGCZActInfo(zoneID)
|
return
|
|
def DoRoundGroup(curRound, zoneID, joinFamilyCnt):
|
## Ö´ÐÐÂִηÖ×é
|
|
GameWorld.Log("========== ÏÉÃ˹¥³ÇÕ½ÂִηÖ×é: zoneID=%s,curRound=%s,joinFamilyCnt=%s" % (zoneID, curRound, joinFamilyCnt))
|
DoRoundOver(zoneID)
|
# ²ÎÓëÏÉÃËÊý¶ÔÓ¦·Ö×é¼°½ú¼¶¹æÔò {²ÎÓëÏÉÃËÊý:{ÂÖ´Î:{Õ½³¡ÀàÐÍ:[×éÊý, Ç°xÃû½ú¼¶, ºóxÃû½µ¼¶], ...}, ...}, ...}
|
FamilyGCZGroupSet = IpyGameDataPY.GetFuncEvalCfg("FamilyGCZGroupSet", 1, {})
|
if str(joinFamilyCnt) not in FamilyGCZGroupSet:
|
return
|
roundSetDict = FamilyGCZGroupSet[str(joinFamilyCnt)]
|
if str(curRound) not in roundSetDict:
|
return
|
batTypeDict = roundSetDict[str(curRound)]
|
|
groupValue1 = zoneID
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
|
#»ã×ÜÉÏÒ»ÂÖÉý½µ¼¶Ã÷ϸ
|
nextBatTypeFamilyInfo = {} # ¸ù¾ÝÉÏÒ»ÂÖ½áËãµÄÉý½µ¼¶×´Ì¬»ã×ܳöµÄ±¾ÂÖÏÉÃËIDÕ½³¡¹é×é
|
if curRound > 1:
|
preRound = curRound - 1
|
lockFamilyIDList = zone.GetZoneLockFamilyIDList()
|
for familyID in lockFamilyIDList:
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
continue
|
roundInfo = joinFamily.roundInfoDict.get(preRound, {})
|
batType = roundInfo.get("batType", BatType_Min) # ĬÈÏ×îµÍ¼¶
|
updownState = roundInfo.get("updownState", UpdownState_Keep) # ĬÈϱ£¼¶
|
if updownState == UpdownState_Up:
|
nextBatType = min(batType + 1, BatType_Max)
|
elif updownState == UpdownState_Down:
|
nextBatType = max(batType - 1, BatType_Min)
|
else:
|
nextBatType = batType
|
if nextBatType not in nextBatTypeFamilyInfo:
|
nextBatTypeFamilyInfo[nextBatType] = []
|
batFamilyIDList = nextBatTypeFamilyInfo[nextBatType]
|
if familyID not in batFamilyIDList:
|
batFamilyIDList.append(familyID)
|
GameWorld.Log("ÉÏÒ»ÂÖÉý½µ¼¶½áËã»ã×Ü: %s" % nextBatTypeFamilyInfo)
|
|
#ÿÂÖÖØзÖ×éʱ£¬ÖØÖø÷ÖÇøϵÄÂÖ´ÎÉ˺¦Ïà¹Ø°ñµ¥
|
billboardMgr = PyDataManager.GetCrossBillboardManager()
|
billboardMgr.ClearBillboard(ShareDefine.Def_CBT_FamilyGCZRoundHurt, groupValue1)
|
zone.OnRoundReset(curRound)
|
|
for batType in BatTypeList: # °´Õ½³¡ÀàÐÍ˳Ðò±éÀú´¦Àí
|
if str(batType) not in batTypeDict:
|
# ±¾ÂÖ²»ÐèÒª´ËÕ½³¡ÀàÐÍ·Ö×é
|
continue
|
groupCnt = batTypeDict[str(batType)][0] # ±¾ÂÖ¸ÃÕ½³¡ÀàÐÍ·Ö×é
|
if not groupCnt:
|
GameWorld.Log("±¾ÂÖÕ½³¡²»ÐèÒª·Ö×é: zoneID=%s,curRound=%s,batType=%s" % (zoneID, curRound, batType))
|
continue
|
|
batFamilyIDList = [] # ¸ÃÕ½³¡µÄÏÉÃËIDÁбí
|
if curRound == 1:
|
# Ê×ÂÖ·Ö×éĬÈÏÈ¡Ëø¶¨Ãûµ¥
|
batFamilyIDList = zone.GetZoneLockFamilyIDList()
|
GameWorld.Log("Ê×ÂÖÕ½³¡·Ö×éÖ±½ÓÈ¡·ÖÇøËø¶¨ÏÉÃËÃûµ¥: zoneID=%s,curRound=%s,batType=%s,%s,%s" % (zoneID, curRound, batType, len(batFamilyIDList), batFamilyIDList))
|
|
# ÉÏÒ»ÂÖ¸ÃÕ½³¡ÀàÐÍÓбÈÈüµÄ
|
elif batType in nextBatTypeFamilyInfo:
|
batFamilyIDList = nextBatTypeFamilyInfo[batType]
|
GameWorld.Log("·ÇÊ×ÂÖ·Ö×éÖ±½ÓÈ¡ÉÏÂÖ½ú±£½µÏÉÃËÃûµ¥: zoneID=%s,curRound=%s,batType=%s,%s,%s" % (zoneID, curRound, batType, len(batFamilyIDList), batFamilyIDList))
|
|
else:
|
GameWorld.ErrLog("±¾ÂÖ·Ö×é¿ÉÄÜûÓÐÏÉÃËÃûµ¥: zoneID=%s,curRound=%s,batType=%s,%s,%s" % (zoneID, curRound, batType, len(batFamilyIDList), batFamilyIDList))
|
|
# Éú³É¿Õ·Ö×飬ȷ±£¼´Ê¹Ã»ÓÐÏÉÃËÒ²ÓжÔÓ¦·Ö×é
|
for groupNum in range(1, 1 + groupCnt):
|
zone.AddBatGroup(batType, groupNum)
|
|
# ÏÈ°´·Ö×é¹æÔòÅÅÐò
|
groupFamilyDict = {}
|
groupFamilySortList = []
|
for familyID in batFamilyIDList:
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
continue
|
groupFamilySortList.append(joinFamily)
|
groupFamilyDict[familyID] = [joinFamily.fightPowerTotal, joinFamily.GetTotalScore()]
|
|
# ÏÈ°´×ÜÕ½Á¦µ¹Ðò£¬¿ÉÀ©Õ¹»ý·ÖµÈ
|
groupFamilySortList.sort(key=lambda f: (f.fightPowerTotal, f.GetTotalScore()), reverse=True)
|
groupFamilyIDSortList = [f.familyID for f in groupFamilySortList]
|
groupFamilyIDCnt = len(groupFamilyIDSortList)
|
GameWorld.Log("¿ªÊ¼·Ö×é°´ÅÅÐòºóµÄ˳ÐòÑ»·²åÈëÿ×é! ÏÉÃËÊý:%s, %s, %s" % (groupFamilyIDCnt, groupFamilyIDSortList, groupFamilyDict))
|
|
groupNum = 0
|
for index, familyID in enumerate(groupFamilyIDSortList):
|
groupNum += 1
|
if groupNum > groupCnt:
|
groupNum = 1
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
GameWorld.ErrLog("ÏÉÃË·Ö×éʱս¶··Ö×é²»´æÔÚ! zoneID=%s,batType=%s,groupNum=%s,familyID=%s" % (zoneID, batType, groupNum, familyID))
|
continue
|
joinFamily = batGroup.AddGroupFamily(familyID)
|
if not joinFamily:
|
GameWorld.ErrLog("ÏÉÃË·ÖÅäµ½Õ½¶··Ö×éʧ°Ü! zoneID=%s,batType=%s,groupNum=%s,familyID=%s" % (zoneID, batType, groupNum, familyID))
|
continue
|
joinFamily.sortWeight = batType * 10000 + (100 - groupNum) * 100 + (groupFamilyIDCnt - index)
|
UndFamilyRoundHurtBillboard(joinFamily)
|
GameWorld.Log(" ÏÉÃËID·Ö×é: zoneID=%s,curRound=%s,batType=%s,groupNum=%s,familyID=%s,%s" % (zoneID, curRound, batType, groupNum, familyID, groupFamilyDict[familyID]))
|
|
Sync_FamilyGCZBatGroupInfo(zoneID)
|
RefreshFamilyGCZBillboard(zoneID, True) # ·Ö×éÍê±Ïºó£¬ÓÐÐÂÂÖ´ÎÊý¾ÝÁË£¬Ç¿ÖÆË¢ÐÂÒ»´Î°ñµ¥£¬¸üÐÂÐÂÒ»ÂֵĻý·Ö
|
return
|
|
def UndFamilyRoundHurtBillboard(joinFamily):
|
## ¸üÐÂÏÉÃËÂÖ´ÎÉ˺¦°ñµ¥
|
if not joinFamily:
|
return
|
dataID = joinFamily.familyID
|
name1 = joinFamily.familyName
|
id2 = joinFamily.leaderID
|
name2 = joinFamily.leaderName
|
type2, value1, value2 = 0, 0, 0
|
value3 = joinFamily.emblemID
|
value5 = joinFamily.serverID
|
groupValue1 = joinFamily.zoneID
|
groupValue2 = GetRoundHurtGroupID(joinFamily.batType, joinFamily.groupNum)
|
memHurtTotal = sum(joinFamily.cityWall.fighterHurtDict.values())
|
cityRemainHPPer = 0
|
if joinFamily.cityWall.hpMax:
|
cityRemainHPPer = joinFamily.cityWall.hp / float(joinFamily.cityWall.hpMax)
|
familyRoundHurt = eval(IpyGameDataPY.GetFuncCompileCfg("FamilyGCZCity", 3))
|
GameWorld.DebugLog("¼ÆËãÏÉÃËÂÖ´ÎÉ˺¦°ñÖµ: familyID=%s,familyRoundHurt=%s,memHurtTotal=%s,cityRemainHPPer=%s, %s/%s"
|
% (dataID, familyRoundHurt, memHurtTotal, cityRemainHPPer, joinFamily.cityWall.hp, joinFamily.cityWall.hpMax))
|
cmpValue = familyRoundHurt / ChConfig.Def_PerPointValue
|
cmpValue2 = familyRoundHurt % ChConfig.Def_PerPointValue
|
cmpValue3 = joinFamily.sortWeight
|
CrossBillboard.UpdCrossBillboard(ShareDefine.Def_CBT_FamilyGCZRoundHurt, groupValue1, dataID, name1, name2, type2, value1, value2,
|
cmpValue, cmpValue2, cmpValue3, groupValue2=groupValue2, id2=id2, autoSort=True, value3=value3, value5=value5)
|
return
|
|
def OnMinuteProcess(curMinute):
|
## ÿ·ÖÖÓ´¦Àí
|
if not GameWorld.IsCrossServer():
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
zoneIDList = gczMgr.zoneDict.keys()
|
if not zoneIDList:
|
return
|
|
for zoneID in zoneIDList:
|
if not zoneID:
|
continue
|
RefreshFamilyGCZBillboard(zoneID)
|
|
return
|
|
def RefreshFamilyGCZBillboard(zoneID, force=False):
|
## ˢв¢ÅÅÐòµ±Ç°»î¶¯Ïà¹Ø°ñµ¥
|
|
# ·ÇÇ¿ÖÆˢеģ¬½öÕ½¶·½×¶Î¶¨Ê±Ë¢ÐÂ
|
if not force:
|
actInfo = CrossActionControl.GetCrossActInfoByZoneID(ShareDefine.CrossActName_FamilyGCZ, zoneID)
|
if not actInfo:
|
return
|
state = actInfo.get(ShareDefine.ActKey_State)
|
if not state:
|
return
|
curRound, roundState = GetRoundState(state)
|
# ½öÂÖ´ÎÕ½¶·½×¶ÎÐèÒª¶¨Ê±Ë¢ÐÂ
|
if not curRound or roundState != FamilyGCZRoundState_Fight:
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
if zone.roundOver:
|
# ÂÖ´ÎÊý¾ÝÒѾ½áËã¹ýÁË£¬²»ÐèÒªÔÙ´¦Àí
|
return
|
roundNum = zone.roundNum
|
if not roundNum:
|
return
|
GameWorld.DebugLog("ÏÉÃ˹¥³ÇÕ½°ñµ¥ÅÅÐò! zoneID=%s,roundNum=%s,force=%s" % (zoneID, roundNum, force))
|
|
billboardMgr = PyDataManager.GetCrossBillboardManager()
|
playerHurtBillObj = billboardMgr.GetCrossBillboard(ShareDefine.Def_CBT_FamilyGCZPlayerHurt, zoneID)
|
playerHurtBillObj.SortData()
|
|
batTypeScoreInfo = IpyGameDataPY.GetFuncEvalCfg("FamilyGCZGroupSet", 2, {}) # ²»Í¬Õ½³¡ÀàÐÍÏÉÃËÅÅÃû¶ÔÓ¦»ý·Ö {"Õ½³¡ÀàÐÍ":{"Ãû´Î":»ý·Ö, ...}, ...}
|
for batType, groupDict in zone.roundGroupDict.items():
|
rankScoreInfo = batTypeScoreInfo.get(str(batType), {})
|
if not rankScoreInfo:
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½Õ½³¡ÀàÐÍûÓÐÅäÖÃÃû´Î»ý·Ö! batType=%s" % batType)
|
rankScoreDict = {int(k):v for k, v in rankScoreInfo.items()}
|
groupNumList = groupDict.keys()
|
for groupNum in groupNumList:
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
continue
|
groupValue2 = GetRoundHurtGroupID(batType, groupNum)
|
roundBillboardObj = billboardMgr.GetCrossBillboard(ShareDefine.Def_CBT_FamilyGCZRoundHurt, zoneID, groupValue2)
|
roundBillboardObj.SortData()
|
for bIndex in range(roundBillboardObj.GetCount()):
|
billData = roundBillboardObj.At(bIndex)
|
familyID = billData.ID
|
rank = bIndex + 1
|
score = GameWorld.GetOrderValueByDict(rankScoreDict, rank, False, 0)
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
continue
|
roundInfo = joinFamily.roundInfoDict.get(roundNum, {})
|
roundInfo.update({"batType":batType, "groupNum":groupNum, "rank":rank, "score":score})
|
joinFamily.roundInfoDict[roundNum] = roundInfo
|
|
lockFamilyIDList = zone.GetZoneLockFamilyIDList()
|
for familyID in lockFamilyIDList:
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
continue
|
dataID = joinFamily.familyID
|
name1 = joinFamily.familyName
|
id2 = joinFamily.leaderID
|
name2 = joinFamily.leaderName
|
type2, value1, value2 = 0, 0, 0
|
value3 = joinFamily.emblemID
|
value5 = joinFamily.serverID
|
cmpValue = joinFamily.GetTotalScore()
|
cmpValue2 = joinFamily.sortWeight
|
CrossBillboard.UpdCrossBillboard(ShareDefine.Def_CBT_FamilyGCZScore, zoneID, dataID, name1, name2, type2, value1, value2,
|
cmpValue, cmpValue2=cmpValue2, id2=id2, autoSort=False, value3=value3, value5=value5, userData=joinFamily.roundInfoDict)
|
|
familyScoreBillObj = billboardMgr.GetCrossBillboard(ShareDefine.Def_CBT_FamilyGCZScore, zoneID)
|
familyScoreBillObj.SortData()
|
return
|
|
def DoRoundOver(zoneID):
|
## Ö´ÐÐÂִνáË㣬ÕâÀï¿ÉÒÔ²»ÓùÜÊǵڼ¸ÂÖ£¬¶ÔÓÚ½áËãÀ´ËµÖ»¶Ôµ±Ç°µÄÂÖ´ÎÊý¾Ý×ö½áËã
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
if zone.roundOver:
|
# ÒѾ½áËã¹ýÁË£¬²»Öظ´½áËã
|
return
|
roundNum = zone.roundNum
|
if not roundNum:
|
# »¹Ã»ÓÐÂִβ»´¦Àí
|
return
|
RefreshFamilyGCZBillboard(zoneID, True) # Ç¿ÖÆË¢ÐÂÒ»´Î°ñµ¥
|
|
joinFamilyCnt = zone.joinFamilyCnt
|
# ²ÎÓëÏÉÃËÊý¶ÔÓ¦·Ö×é¼°½ú¼¶¹æÔò {²ÎÓëÏÉÃËÊý:{ÂÖ´Î:{Õ½³¡ÀàÐÍ:[×éÊý, Ç°xÃû½ú¼¶, ºóxÃû½µ¼¶], ...}, ...}, ...}
|
FamilyGCZGroupSet = IpyGameDataPY.GetFuncEvalCfg("FamilyGCZGroupSet", 1, {})
|
if str(joinFamilyCnt) not in FamilyGCZGroupSet:
|
return
|
roundSetDict = FamilyGCZGroupSet[str(joinFamilyCnt)]
|
if str(roundNum) not in roundSetDict:
|
return
|
batTypeDict = roundSetDict[str(roundNum)]
|
|
billboardMgr = PyDataManager.GetCrossBillboardManager()
|
GameWorld.Log("========== ÏÉÃ˹¥³ÇÕ½ÂִνáËã: zoneID=%s,roundNum=%s" % (zoneID, roundNum))
|
for batType, groupDict in zone.roundGroupDict.items():
|
if str(batType) not in batTypeDict:
|
continue
|
batTypeSet = batTypeDict[str(batType)]
|
upRank = batTypeSet[1] # Ç°x½ú¼¶
|
downRank = batTypeSet[2] if len(batTypeSet) > 2 else 0 # ºóxÃû½µ¼¶£¬Îª0ʱ²»½µ¼¶
|
groupNumList = groupDict.keys()
|
GameWorld.Log("zoneID=%s,batType=%s,upRank=%s,downRank=%s,groupNumList=%s" % (zoneID, batType, upRank, downRank, groupNumList))
|
for groupNum in groupNumList:
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
continue
|
|
groupValue2 = GetRoundHurtGroupID(batType, groupNum)
|
billboardObj = billboardMgr.GetCrossBillboard(ShareDefine.Def_CBT_FamilyGCZRoundHurt, zoneID, groupValue2)
|
GameWorld.Log("zoneID=%s,batType=%s,groupNum=%s,groupFamilyCnt=%s" % (zoneID, batType, groupNum, billboardObj.GetCount()))
|
for bIndex in range(billboardObj.GetCount()):
|
billData = billboardObj.At(bIndex)
|
familyID = billData.ID
|
cmpValue = billData.CmpValue
|
cmpValue2 = billData.CmpValue2
|
hurtValueTotal = cmpValue * ChConfig.Def_PerPointValue + cmpValue2
|
rank = bIndex + 1
|
updownState = UpdownState_Keep # ±¾ÂÖ½áËã½ú¼¶½µ¼¶×´Ì¬£º0-δ´¦Àí£¬1-½µ¼¶£»2-±£¼¶£»3-½ú¼¶£¬¼´±¾ÂֵĽú½µ¼¶×´Ì¬¾ö¶¨ÏÂÒ»ÂÖµÄÕ½³¡ÀàÐÍ
|
if rank <= upRank and batType < BatType_Max:
|
updownState = UpdownState_Up
|
elif downRank and rank > (Def_PerGroupFamilyCnt - downRank) and batType > BatType_Min:
|
updownState = UpdownState_Down
|
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
continue
|
roundInfo = joinFamily.roundInfoDict.get(roundNum, {})
|
roundInfo.update({"updownState":updownState})
|
joinFamily.roundInfoDict[roundNum] = roundInfo
|
|
GameWorld.Log(" Éý±£½µ¼¶zoneID=%s,batType=%s,groupNum=%s,rank=%s,familyID=%s,updownState=%s,hurtValueTotal=%s"
|
% (zoneID, batType, groupNum, rank, familyID, updownState, hurtValueTotal))
|
Sync_FamilyGCZCampInfo(zoneID, familyID)
|
|
zone.roundOver = 1 # ±ê¼ÇÒѽáËã
|
return
|
|
def DoGenerateGuess(zoneID, state):
|
## Éú³É¾º²ÂÊý¾Ý
|
if state not in IpyGameDataPY.GetFuncEvalCfg("FamilyGCZGuess", 1):
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
|
guessRankMax = IpyGameDataPY.GetFuncCfg("FamilyGCZGuess", 2)
|
billboardMgr = PyDataManager.GetCrossBillboardManager()
|
scoreBillObj = billboardMgr.GetCrossBillboard(ShareDefine.Def_CBT_FamilyGCZScore, zoneID)
|
guessCnt = min(scoreBillObj.GetCount(), guessRankMax)
|
for index in range(guessCnt):
|
billData = scoreBillObj.At(index)
|
familyID = billData.ID
|
if familyID not in zone.familyGuessDict:
|
zone.familyGuessDict[familyID] = 0
|
GameWorld.Log("ÏÉÃ˹¥³ÇÕ½Éú³É¾º²Â±¸Ñ¡Ãûµ¥: zoneID=%s,index=%s,familyID=%s" % (zoneID, index, familyID))
|
|
Sync_FamilyGCZGuessInfo(zoneID)
|
return
|
|
def DoStartAward(zoneID):
|
## ¿ªÊ¼Áì½±
|
|
DoRoundOver(zoneID)
|
|
# Ï·¢¾º²Âͳ¼Æ½á¹û
|
Sync_FamilyGCZGuessInfo(zoneID)
|
return
|
|
def GetRoundHurtGroupID(batType, groupNum): return batType * 100 + groupNum
|
def GetRoundHurtGroupIDInfo(groupValue2):
|
batType = groupValue2 / 100
|
groupNum = groupValue2 % 100
|
return batType, groupNum
|
|
def Send_CrossServerMsg_FamilyGCZ(actMsgType, msgInfo, serverGroupIDList=None):
|
msgInfo["ActMsgType"] = actMsgType
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FamilyGCZ, msgInfo, serverGroupIDList)
|
return
|
|
def ClientServerMsg_FamilyGCZ(serverGroupID, msgData):
|
ActMsgType = msgData["ActMsgType"]
|
|
# ¼Ó¾Ñé
|
if ActMsgType == "AddCampExp":
|
__clientServer_AddCampExp(msgData)
|
|
elif ActMsgType == "Query":
|
# ²éѯÀàÐÍ£º1-³ÉÔ±¾èÏ×Öµ£»2-½øÈë³Ç³Ø³¡¾°£»3-Í˳ö³Ç³Ø³¡¾°£»4-½øÈë³Ç³Ø£»5-Í˳ö³Ç³Ø£»6-Õ½±¨£»7-·Ö×éÏÉÃ˳ÉÔ±É˺¦
|
# "ActMsgType":"Query", "playerID":playerID, "queryType":queryType, "batType":batType, "groupNum":groupNum, "familyID":familyID
|
queryType = msgData["queryType"]
|
playerID = msgData["playerID"]
|
batType = msgData["batType"]
|
groupNum = msgData["groupNum"]
|
tagFamilyID = msgData["familyID"]
|
gczMgr = GetFamilyGCZMgr()
|
joinMember = gczMgr.GetJoinMember(playerID)
|
if not joinMember:
|
return
|
zoneID = joinMember.zoneID
|
zone = gczMgr.GetActZone(zoneID)
|
|
if queryType == 1: # ³ÉÔ±¾èÏ×Öµ
|
__clientServer_QueryContributionInfo(playerID, serverGroupID, msgData)
|
elif queryType == 2: # ½øÈë³Ç³Ø³¡¾°
|
zone.SetPlayerInBatScene(playerID, batType, groupNum, serverGroupID)
|
elif queryType == 3: # Í˳ö³Ç³Ø³¡¾°
|
zone.SetPlayerInBatScene(playerID)
|
elif queryType == 4: # ½øÈë³Ç³Ø
|
zone.SetPlayerInBatCity(playerID, batType, groupNum, tagFamilyID, serverGroupID)
|
elif queryType == 5: # Í˳ö³Ç³Ø
|
zone.SetPlayerInBatCity(playerID)
|
elif queryType == 6: # Õ½±¨
|
repFamilyID = tagFamilyID if tagFamilyID else joinMember.familyID
|
__clientServer_QueryBatReport(playerID, serverGroupID, repFamilyID)
|
elif queryType == 7: # ·Ö×éÏÉÃ˳ÉÔ±É˺¦
|
repFamilyID = tagFamilyID if tagFamilyID else joinMember.familyID
|
__clientServer_QueryGroupFamilyMemHurt(playerID, serverGroupID, zoneID, repFamilyID)
|
|
elif ActMsgType == "GCZAtk":
|
__clientServer_Atk(serverGroupID, msgData)
|
|
elif ActMsgType == "Guess":
|
__clientServer_Guess(serverGroupID, msgData)
|
|
elif ActMsgType == "GetAward":
|
__clientServer_GetAward(serverGroupID, msgData)
|
|
elif ActMsgType == "GMCMD":
|
__clientServer_GMCMD(serverGroupID, msgData)
|
|
return
|
|
def __clientServer_AddCampExp(msgData):
|
playerID = msgData["playerID"]
|
addCampExp = msgData["addCampExp"]
|
|
gczMgr = GetFamilyGCZMgr()
|
joinMember = gczMgr.GetJoinMember(playerID)
|
if not joinMember:
|
GameWorld.ErrLog("·ÇÏÉÃ˹¥³ÇÕ½²ÎÈü³ÉÔ±ÎÞ·¨¼Ó¾Ñé!", playerID)
|
return
|
familyID = joinMember.familyID
|
joinFamily = gczMgr.GetJoinFamily(familyID)
|
if not joinFamily:
|
GameWorld.ErrLog("·ÇÏÉÃ˹¥³ÇÕ½²ÎÈüÏÉÃËÎÞ·¨¼Ó¾Ñé! familyID=%s" % familyID, playerID)
|
return
|
joinFamily.AddCampExp(playerID, addCampExp)
|
return
|
|
def __clientServer_GMCMD(serverGroupID, msgData):
|
''' GMÃüÁ·½±ã¿ª·¢²âÊÔÓÃ
|
'''
|
playerID = msgData["playerID"]
|
msgList = msgData["msgList"]
|
|
gczMgr = GetFamilyGCZMgr()
|
joinMember = gczMgr.GetJoinMember(playerID)
|
if not joinMember:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "·ÇÏÉÃ˹¥³ÇÕ½²ÎÈü³ÉÔ±:%s" % playerID)
|
return
|
zoneID = joinMember.zoneID
|
familyID = joinMember.familyID
|
zone = gczMgr.GetActZone(zoneID)
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "·ÇÏÉÃ˹¥³ÇÕ½²ÎÈüÏÉÃË:%s" % familyID)
|
return
|
batType, groupNum = joinMember.batType, joinMember.groupNum
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "ûÓÐÕ½¶··Ö×é:batType-group:%s-%s" % (batType, groupNum))
|
return
|
|
actInfo = CrossActionControl.GetCrossActInfoByZoneID(ShareDefine.CrossActName_FamilyGCZ, zoneID)
|
if not actInfo:
|
return
|
state = actInfo.get(ShareDefine.ActKey_State)
|
if not state:
|
return
|
curRound, roundState = GetRoundState(state)
|
|
value0 = msgList[0]
|
if value0 in ["a", "h", "k", "s"]:
|
if not curRound or (curRound and roundState != FamilyGCZRoundState_Fight):
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "·ÇÕ½¶·½×¶Î!state=%s" % (state))
|
return
|
|
#¹¥»÷³Ç³Ø: FamilyGCZ a ³Ç³ØID [¹¥»÷´ÎÊý ÏÉÃËID]
|
if value0 == "a":
|
tagCityID = msgList[1] if len(msgList) > 1 else 0
|
atkCntTotal = msgList[2] if len(msgList) > 2 else 1
|
atkFamilyID = msgList[3] if len(msgList) > 3 else familyID
|
atkMemberID = 0
|
if atkFamilyID == familyID:
|
atkJoinFamily = joinFamily
|
if atkCntTotal == 1:
|
atkMemberID = playerID
|
else:
|
atkJoinFamily = zone.GetZoneJoinFamily(atkFamilyID)
|
if not atkJoinFamily:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "¹¥»÷·½²»´æÔÚ:%s" % atkFamilyID)
|
return
|
curCityID = atkJoinFamily.cityWall.cityID
|
tagCity = batGroup.GetCityWall(tagCityID)
|
if not tagCity:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "Ä¿±ê³Ç³Ø²»´æÔÚ:%s" % (tagCityID))
|
return
|
atkOK = __DoGMAtkCity(playerID, serverGroupID, zoneID, curRound, batType, groupNum, curCityID, tagCityID, atkCntTotal, 0, atkMemberID)
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "atkOK:%s,remainHP:%s" % (atkOK != None, tagCity.hp))
|
|
#¹¥»÷³Ç³Ø: FamilyGCZ a ³Ç³ØID Ê£ÓàѪÁ¿ [¹¥»÷·½ÈËÊý ÏÉÃËID]
|
elif value0 == "h":
|
tagCityID = msgList[1] if len(msgList) > 1 else 0
|
remainHP = msgList[2] if len(msgList) > 2 else 0
|
atkCntTotal = msgList[3] if len(msgList) > 3 else 0
|
atkFamilyID = msgList[4] if len(msgList) > 4 else familyID
|
atkMemberID = 0
|
if atkFamilyID == familyID:
|
atkJoinFamily = joinFamily
|
if atkCntTotal == 1:
|
atkMemberID = playerID
|
else:
|
atkJoinFamily = zone.GetZoneJoinFamily(atkFamilyID)
|
if not atkJoinFamily:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "¹¥»÷·½²»´æÔÚ:%s" % atkFamilyID)
|
return
|
curCityID = atkJoinFamily.cityWall.cityID
|
tagCity = batGroup.GetCityWall(tagCityID)
|
if not tagCity:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "Ä¿±ê³Ç³Ø²»´æÔÚ:%s" % (tagCityID))
|
return
|
if tagCity.hp <= remainHP:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "Ê£ÓàѪÁ¿²»Äܳ¬¹ýµ±Ç°ÑªÁ¿:%s" % (tagCity.hp))
|
return
|
hurtValueTotal = tagCity.hp - remainHP
|
atkOK = __DoGMAtkCity(playerID, serverGroupID, zoneID, curRound, batType, groupNum, curCityID, tagCityID, 0, hurtValueTotal, atkMemberID)
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "atkOK:%s,remainHP:%s" % (atkOK != None, tagCity.hp))
|
|
#¼¼Äܹ¥»÷: FamilyGCZ s ¼¼ÄÜÀàÐÍ [³Ç³ØID ¹¥»÷·½ID]
|
elif value0 == "s":
|
atkType = msgList[1] if len(msgList) > 1 else 0
|
tagCityID = msgList[2] if len(msgList) > 2 else 0
|
atkMemberID = msgList[3] if len(msgList) > 3 else playerID
|
hurtMulti = msgList[4] if len(msgList) > 4 else 2
|
hurtFamilyCnt = msgList[5] if len(msgList) > 5 else 10
|
atkJoinMember = zone.GetZoneJoinMember(atkMemberID)
|
if not atkJoinMember:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "¹¥»÷·½²»´æÔÚ:%s" % atkMemberID)
|
return
|
atkFamilyID = atkJoinMember.familyID
|
atkJoinFamily = zone.GetZoneJoinFamily(atkFamilyID)
|
curCityID = atkJoinFamily.cityWall.cityID
|
|
batFightPower = atkJoinMember.fightPower
|
hurtValueTotal = batFightPower * hurtMulti # ×ÜÉ˺¦
|
|
canAtkedCityList = []
|
# ¼¼Äܵ¥Ìå
|
if atkType == AtkType_SkillSingle:
|
tagCity = batGroup.GetCityWall(tagCityID)
|
if not tagCity:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "Ä¿±ê³Ç³Ø²»´æÔÚ:%s" % (tagCityID))
|
return
|
if atkFamilyID == tagCity.familyID:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "²»Äܹ¥»÷×Ô¼ºÏÉÃË")
|
return
|
canAtkedCityList.append(tagCity)
|
|
# ¼¼ÄÜȺÌå
|
elif atkType == AtkType_SkillArea:
|
for tagCityID in batGroup.cityWallDict.keys(): # ±éÀúͬ×é³Ç³Ø
|
if tagCityID == curCityID:
|
#²»´ò×Ô¼º
|
continue
|
tagCity = batGroup.GetCityWall(tagCityID)
|
if not tagCity or tagCity.IsBroken():
|
# Òѱ»´Ý»ÙµÄ
|
continue
|
canAtkedCityList.append(tagCity)
|
if len(canAtkedCityList) > hurtFamilyCnt:
|
random.shuffle(canAtkedCityList)
|
canAtkedCityList = canAtkedCityList[:hurtFamilyCnt]
|
|
else:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "·Ç¼¼Äܹ¥»÷ÀàÐÍ(%s)" % atkType)
|
return
|
|
oneHurtTotal = hurtValueTotal / len(canAtkedCityList) # ËùÓпɹ¥»÷µÄÄ¿±êÏÉÃËƽ̯É˺¦
|
hurtDict = {}
|
killCntTotal = 0
|
for tagCity in canAtkedCityList:
|
tagCityID = tagCity.cityID
|
atkOK = __DoGMAtkCity(playerID, serverGroupID, zoneID, curRound, batType, groupNum, curCityID, tagCityID, 0, oneHurtTotal, atkMemberID, atkType)
|
if atkOK != None:
|
hurtDict[tagCityID] = oneHurtTotal
|
killCntTotal += atkOK
|
Sync_FamilyGCZBatSceneInfo(zoneID, batType, groupNum, atkMemberID, atkType, hurtDict, killCntTotal)
|
|
#»÷»Ù³Ç³Ø: FamilyGCZ k [³Ç³ØID ¹¥»÷·½ÏÉÃËID]
|
elif value0 == "k":
|
tagCityID = msgList[1] if len(msgList) > 1 else 0
|
atkFamilyID = msgList[2] if len(msgList) > 2 else familyID
|
atkJoinFamily = zone.GetZoneJoinFamily(atkFamilyID)
|
if not atkJoinFamily:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "¹¥»÷·½²»´æÔÚ:%s" % atkFamilyID)
|
return
|
curCityID = atkJoinFamily.cityWall.cityID
|
#Ëæ»úÒ»¸ö³Ç³Ø»÷»Ù
|
if not tagCityID:
|
cityIDList = batGroup.GetCityIDList()
|
else:
|
cityIDList = [tagCityID]
|
tagCity = None
|
for cityID in cityIDList[::-1]:
|
city = batGroup.GetCityWall(cityID)
|
if not city:
|
continue
|
if city.IsBroken() or cityID in [XiuluoCityID, atkFamilyID]:
|
continue
|
tagCity = city
|
break
|
if not tagCity:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "ûÓпɻ÷»ÙµÄ³Ç³ØÁË!")
|
return
|
tagCityID = tagCity.cityID
|
hurtValueTotal = tagCity.hp
|
atkOK = __DoGMAtkCity(playerID, serverGroupID, zoneID, curRound, batType, groupNum, curCityID, tagCityID, 0, hurtValueTotal)
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "killOK:%s,Ä¿±ê:%s,¹¥»÷·½:%s" % (atkOK != None, tagCityID, curCityID))
|
|
#Êä³ö³Ç³Ø: FamilyGCZ p [Õ½³¡ÀàÐÍ ·Ö×é±àºÅ]
|
elif value0 == "p":
|
bType = msgList[1] if len(msgList) > 1 else batType
|
gNum = msgList[2] if len(msgList) > 2 else groupNum
|
__GMPrintGroupCity(zoneID, bType, gNum, playerID, serverGroupID)
|
|
#ɽկ¾º²Â: FamilyGCZ g ÈËÊý [¾º²ÂID1 ID2 ID3]
|
elif value0 == "g":
|
guessCnt = msgList[1] if len(msgList) > 1 else 1
|
guessFamilyIDList = msgList[2:]
|
__DoGMGuess(zoneID, state, guessCnt, guessFamilyIDList, playerID, serverGroupID)
|
|
#³ÉÔ±¾èÏ×: FamilyGCZ x ¾Ñé [³ÉÔ±Êý]
|
elif value0 == "x":
|
addCampExp = msgList[1] if len(msgList) > 1 else 1
|
memCnt = msgList[2] if len(msgList) > 2 else 1
|
if memCnt > 1:
|
memIDList = copy.deepcopy(joinFamily.joinMemberIDList)
|
random.shuffle(memIDList)
|
playerIDList = memIDList[:memCnt]
|
else:
|
playerIDList = [playerID]
|
|
for memID in playerIDList:
|
joinFamily.AddCampExp(memID, addCampExp, False)
|
|
Sync_FamilyGCZCampInfo(joinFamily.zoneID, joinFamily.familyID)
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "³ÉÔ±¾èÏ×:ÈËÊý(%s)x%s:campLV(%s),Exp(%s)" % (len(playerIDList), addCampExp, joinFamily.campLV, joinFamily.campExp))
|
|
#Éè´ó±¾Óª: FamilyGCZ c µÈ¼¶ [¾Ñé]
|
elif value0 == "c":
|
campLV = msgList[1] if len(msgList) > 1 else joinFamily.campLV
|
campExp = msgList[2] if len(msgList) > 2 else joinFamily.campExp
|
if campLV and not IpyGameDataPY.GetIpyGameData("CrossActFamilyGCZCampLV", campLV):
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "´ó±¾ÓªÃ»Óиõȼ¶:%s" % campExp)
|
return
|
joinFamily.campLV = campLV
|
joinFamily.campExp = campExp
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "ÉèÖôó±¾ÓªµÈ¼¶:%s,Exp:%s" % (campLV, campExp))
|
joinFamily.RefreshFamilyAttr()
|
|
return
|
|
def __GMPrintGroupCity(zoneID, batType, groupNum, playerID, serverGroupID):
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
cityIDList = batGroup.GetCityIDList()
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "---·ÖÇø(%s)·Ö×éÀàÐÍ(%s)×é(%s)³Ç³ØÊý(%s)" % (zoneID, batType, groupNum, len(cityIDList)))
|
for cNum, cityID in enumerate(cityIDList, 1):
|
city = batGroup.GetCityWall(cityID)
|
if not city:
|
continue
|
broken = "ÒÑ»÷»Ù" if city.IsBroken() else ""
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "³Ç³Ø%02d:%s,·ÀÊØÈËÔ±ID:%s,ÈËÊý:%s/%s"
|
% (cNum, cityID, city.GetCurGuardID(), len(city.fighterIDList), len(city.guardMemIDList)))
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, " HP: %s/%s %s" % (city.hp, city.hpMax, broken))
|
return
|
|
def __DoGMAtkCity(gmPlayerID, serverGroupID, zoneID, curRound, batType, groupNum, curCityID, tagCityID, atkCntTotal=0, hurtValueTotal=0, atkMemberID=0, atkType=AtkType_Normal):
|
'''GM¹¥»÷³Ç³Ø
|
@param curCityID: ¹¥»÷·½³Ç³ØID
|
@param tagCityID: ·ÀÊØ·½³Ç³ØID
|
@param atkCntTotal: ´óÓÚ0ʱָ¶¨×ܹ¥»÷´ÎÊý
|
@param hurtValueTotal: ´óÓÚ0ʱָ¶¨×ÜÉ˺¦
|
@param atkMemberID: ·¢Æð¹¥»÷µÄ³ÉÔ±ID£¬Èç¹ûΪ0ÔòËùÓгÉԱƽ̯¹¥»÷
|
'''
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
if curCityID == tagCityID:
|
GameWorld.DebugAnswerCross(gmPlayerID, serverGroupID, "²»Äܹ¥»÷×Ô¼ºµÄ³Ç³Ø")
|
return
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
return
|
curCity = batGroup.GetCityWall(curCityID)
|
tagCity = batGroup.GetCityWall(tagCityID)
|
if not curCity:
|
GameWorld.DebugAnswerCross(gmPlayerID, serverGroupID, "¹¥»÷·½²»´æÔÚ:%s" % curCityID)
|
return
|
if not tagCity:
|
GameWorld.DebugAnswerCross(gmPlayerID, serverGroupID, "±»¹¥»÷·½²»´æÔÚ:%s" % tagCityID)
|
return
|
curFamilyID = curCity.familyID
|
tagFamilyID = tagCity.familyID
|
curJoinFamily = zone.GetZoneJoinFamily(curFamilyID)
|
if not curJoinFamily:
|
GameWorld.DebugAnswerCross(gmPlayerID, serverGroupID, "ÎÞ¹éÊôÏÉÃ˳dzز»ÄÜ·¢Æð¹¥»÷")
|
return
|
|
GameWorld.DebugLog("GM¹¥»÷³Ç³Ø: zoneID=%s,batType=%s,groupNum=%s,curCityID=%s,tagCityID=%s,atkCntTotal=%s,hurtValueTotal=%s,atkMemberID=%s"
|
% (zoneID, batType, groupNum, curCityID, tagCityID, atkCntTotal, hurtValueTotal, atkMemberID))
|
|
remainHurtTotal = 0
|
memHurtDict = {}
|
atkMemIDList = [atkMemberID] if (atkMemberID and atkMemberID in curJoinFamily.joinMemberIDList) else curJoinFamily.joinMemberIDList
|
# °´´ÎÊýÊä³ö
|
if atkCntTotal:
|
remainAtkCnt = atkCntTotal
|
while remainAtkCnt > 0 and atkMemIDList:
|
remainAtkCnt -= 1
|
atkMemID = atkMemIDList.pop(0)
|
atkMemIDList.append(atkMemID)
|
atkMember = zone.GetZoneJoinMember(atkMemID)
|
memHurt = atkMember.fightPower
|
remainHurtTotal += atkMember.fightPower
|
memHurtDict[atkMemID] = memHurtDict.get(atkMemID, 0) + memHurt
|
GameWorld.DebugLog("°´×Ü´ÎÊý¹¥»÷: atkCntTotal=%s,remainHurtTotal=%s,atkMem=%s,%s" % (atkCntTotal, remainHurtTotal, len(memHurtDict), memHurtDict))
|
|
# °´×ÜÉ˺¦Êä³ö
|
elif hurtValueTotal:
|
remainHurtTotal = hurtValueTotal
|
while hurtValueTotal > 0 and atkMemIDList:
|
atkMemID = atkMemIDList.pop(0)
|
atkMemIDList.append(atkMemID)
|
atkMember = zone.GetZoneJoinMember(atkMemID)
|
memHurt = atkMember.fightPower
|
hurtValueTotal -= memHurt
|
memHurtDict[atkMemID] = memHurtDict.get(atkMemID, 0) + memHurt
|
GameWorld.DebugLog("°´×ÜÉ˺¦¹¥»÷: remainHurtTotal=%s,atkMem=%s,%s" % (remainHurtTotal, len(memHurtDict), memHurtDict))
|
|
killCnt = 0
|
curTime = int(time.time())
|
atkedGuardIDList = [] # ±»¹¥»÷µÄÈËÔ±IDÁбí
|
# GM¹¥»÷²»ÏÞÖÆ·ÀÊØÈËÔ±»÷ɱÉÏÏÞ£¬Ö±µ½É˺¦ÓÃÍêΪֹ
|
GameWorld.DebugLog("¼ÆËãGM¹¥»÷³Ç³Ø: tagCityID=%s,cityHP=%s/%s,remainHurtTotal=%s" % (tagCityID, tagCity.hp, tagCity.hpMax, remainHurtTotal))
|
while not tagCity.IsBroken() and remainHurtTotal > 0:
|
fighterID = tagCity.fighterIDList[0]
|
if tagCity.IsGuardNPC(fighterID):
|
tagGuard = tagCity.guardNPC
|
else:
|
tagGuard = zone.GetZoneJoinMember(fighterID)
|
if not tagGuard or tagGuard.IsDead():
|
tagCity.NextGuard()
|
continue
|
atkedGuardIDList.append(fighterID)
|
tagCity.atkedTime = curTime
|
|
hpBef = tagGuard.hp
|
tagGuard.hp = max(0, hpBef - remainHurtTotal)
|
lostHP = hpBef - tagGuard.hp # ¸Ã·ÀÊضÓԱʵ¼ÊµôѪ
|
tagCity.hp = max(0, tagCity.hp - lostHP) # ³Ç³Øͬ²½¿ÛѪ
|
|
# ÐÞÂ޳ǷÀ±¬
|
if tagCityID == XiuluoCityID and tagCity.hp <= 0:
|
tagCity.hp = 1
|
tagGuard.hp = 1
|
lostHP = remainHurtTotal
|
GameWorld.Log(" GM¹¥»÷ÐÞÂ޳ǷÀ±¬: zoneID=%s,tagCityID=%s" % (zoneID, tagCityID))
|
|
GameWorld.DebugLog(" tagGuardID=%s,remainHurtTotal=%s,lostHP=%s,hpBef=%s/%s,hpUpd=%s,cityHP=%s"
|
% (fighterID, remainHurtTotal, lostHP, hpBef, tagGuard.hpMax, tagGuard.hp, tagCity.hp))
|
|
remainHurtTotal -= lostHP # Ê£ÓàÉ˺¦Öµ
|
|
# Õ½±¨ÒÔʵ¼ÊµôѪ¼ÆË㣬×ÜÁ¿Îª100%
|
curCity.atkReportDict[tagCityID] = curCity.atkReportDict.get(tagCityID, 0) + lostHP
|
tagCity.defReportDict[curCityID] = tagCity.defReportDict.get(curCityID, 0) + lostHP
|
|
if tagGuard.IsDead():
|
killCnt += 1
|
tagCity.NextGuard()
|
|
GameWorld.DebugLog(" remainHurtTotal=%s,killCnt=%s,atkReportDict=%s,defReportDict=%s"
|
% (remainHurtTotal, killCnt, curCity.atkReportDict, tagCity.defReportDict))
|
|
GameWorld.DebugLog("cityHP=%s/%s,atkedGuardIDList=%s" % (tagCity.hp, tagCity.hpMax, atkedGuardIDList))
|
if tagFamilyID:
|
tagJoinFamily = zone.GetZoneJoinFamily(tagFamilyID)
|
if tagJoinFamily:
|
UndFamilyRoundHurtBillboard(tagJoinFamily) # °ñµ¥É˺¦ÊܳdzØѪÁ¿Ó°Ï죬ËùÒÔ±»¹¥»÷·½Ò²Òª¸üаñµ¥
|
|
for memID, memHurt in memHurtDict.items():
|
GameWorld.DebugLog("¹¥»÷·½³ÉÔ±Êä³ö: memID=%s,%s" % (memID, memHurt))
|
joinMember = zone.GetZoneJoinMember(memID)
|
if not joinMember:
|
continue
|
joinMember.totalHurtValue += memHurt
|
cmpValue = joinMember.totalHurtValue / ChConfig.Def_PerPointValue
|
cmpValue2 = joinMember.totalHurtValue % ChConfig.Def_PerPointValue
|
CrossBillboard.UpdCrossBillboardPlayer(ShareDefine.Def_CBT_FamilyGCZPlayerHurt, memID, zoneID, cmpValue, cmpValue2, autoSort=False)
|
if curCity.IsBroken():
|
continue
|
curCity.fighterHurtDict[memID] = curCity.fighterHurtDict.get(memID, 0) + memHurt
|
playerRoundHurtTotal = curCity.fighterHurtDict[memID] # Ö»ËãÉú´æÉ˺¦
|
_, topHurtPlayerValue = batGroup.GetTopHurtPlayerIDValue()
|
if playerRoundHurtTotal > topHurtPlayerValue:
|
batGroup.UpdTopHurtPlayerIDValue(memID, playerRoundHurtTotal)
|
|
if not curCity.IsBroken():
|
UndFamilyRoundHurtBillboard(curJoinFamily)
|
else:
|
GameWorld.DebugLog(" ¹¥»÷·½ÏÉÃ˳dzØÒѱ»´Ý»Ù£¬²»ÔÙÀÛ¼Ó±¾ÂÖÏÉÃËÉ˺¦°ñÖµ! familyID=%s" % curFamilyID)
|
|
if not CheckXiuluoCity(zoneID, curRound, batType, groupNum, gmPlayerID):
|
if atkType == AtkType_Normal: # ¼¼Äܹ¥»÷Íâ²ãͳһ֪ͨ
|
Sync_FamilyGCZBatSceneInfo(zoneID, batType, groupNum)
|
Sync_FamilyGCZBatCityInfo(zoneID, batType, groupNum, tagCityID)
|
if tagFamilyID:
|
Sync_FamilyGCZCampInfo(zoneID, tagFamilyID, defMemIDList=atkedGuardIDList)
|
|
return killCnt
|
|
def __clientServer_Atk(serverGroupID, msgData):
|
## ¹¥»÷
|
zoneID = msgData["zoneID"]
|
playerID = msgData["playerID"]
|
atkType = msgData["atkType"] # ¹¥»÷ÀàÐÍ£º 1-ÆÕͨµ¥¹¥£»2-¼¼Äܵ¥¹¥£»3-¼¼ÄÜȺ¹¥£»
|
tagCityID = msgData["tagCityID"] # Ä¿±ê³Ç³ØID£¬Ò»°ãÊÇÏÉÃËID»òÕßÌØÊâ³Ç³ØIDÈçÐÞÂ޳dzdzأ¬ÆÕ¹¥µ¥¹¥ÐèÖ¸¶¨Ä¿±ê£¬Èº¹¥¼¼ÄÜ·¢0
|
tagGuardID = msgData["tagGuardID"] # Ä¿±êÊØÎÀID£¬Ò»°ãÊÇÍæ¼ÒID»òÕßÌØÊâÊØÎÀIDÈçÐÞÂÞ³ÇÊØÎÀ£¬ÆÕ¹¥µ¥¹¥ÐèÖ¸¶¨Ä¿±ê£¬¼¼Äܹ¥»÷·¢0
|
hurtMulti = msgData["hurtMulti"]
|
#useItemID = msgData["useItemID"]
|
hurtFamilyCnt = msgData["hurtFamilyCnt"]
|
|
GameWorld.DebugLog("ÏÉÃ˹¥³ÇÕ½¹¥»÷: zoneID=%s,atkType=%s,tagCityID=%s,tagGuardID=%s,hurtMulti=%s,hurtFamilyCnt=%s"
|
% (zoneID, atkType, tagCityID, tagGuardID, hurtMulti, hurtFamilyCnt), playerID)
|
|
actInfo = CrossActionControl.GetCrossActInfoByZoneID(ShareDefine.CrossActName_FamilyGCZ, zoneID)
|
if not actInfo:
|
return
|
state = actInfo.get(ShareDefine.ActKey_State)
|
if not state:
|
return
|
curRound, roundState = GetRoundState(state)
|
if not curRound or (curRound and roundState != FamilyGCZRoundState_Fight):
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½·Ç¹¥»÷½×¶Î: state=%s,curRound=%s,roundState=%s" % (state, curRound, roundState), playerID)
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
joinMember = gczMgr.GetJoinMember(playerID)
|
if not joinMember:
|
GameWorld.ErrLog("·ÇÏÉÃ˹¥³ÇÕ½²ÎÈü³ÉÔ±!", playerID)
|
return
|
if zoneID != joinMember.zoneID:
|
GameWorld.ErrLog("·ÇÏÉÃ˹¥³ÇÕ½²ÎÈü³ÉÔ±! zoneID=%s" % joinMember.zoneID, playerID)
|
return
|
zone = gczMgr.GetActZone(zoneID)
|
familyID = joinMember.familyID
|
batType, groupNum = joinMember.batType, joinMember.groupNum
|
curJoinFamily = zone.GetZoneJoinFamily(familyID)
|
if not curJoinFamily:
|
GameWorld.ErrLog("·ÇÏÉÃ˹¥³ÇÕ½²ÎÈüÏÉÃË! familyID=%s" % familyID, playerID)
|
return
|
curCity = curJoinFamily.cityWall
|
curCityID = curCity.cityID
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½·Ö×é²»´æÔÚ! batType=%s,groupNum=%s" % (batType, groupNum), playerID)
|
return
|
|
canAtkedCityList = [] # ¿É±»¹¥»÷µÄ³Ç³ØÁбí
|
# Ⱥ¹¥¼¼ÄÜ
|
if atkType == AtkType_SkillArea:
|
# Ⱥ¹¥Ê±Ç¿ÖÆÄ¿±êΪ0
|
tagCityID, tagGuardID = 0, 0
|
for tagCID in batGroup.cityWallDict.keys(): # ±éÀúͬ×é³Ç³Ø
|
if tagCID == curCityID:
|
#²»´ò×Ô¼º
|
continue
|
tagCity = batGroup.GetCityWall(tagCID)
|
if not tagCity or tagCity.IsBroken():
|
# Òѱ»´Ý»ÙµÄ
|
continue
|
canAtkedCityList.append(tagCity)
|
if len(canAtkedCityList) > hurtFamilyCnt:
|
random.shuffle(canAtkedCityList)
|
canAtkedCityList = canAtkedCityList[:hurtFamilyCnt]
|
|
# µ¥¹¥¼¼ÄÜ
|
elif atkType == AtkType_SkillSingle:
|
if not tagCityID or tagCityID == curCityID:
|
SendFamilyGCZAtkResult(AtkRet_Other, "TagIDError-tagCityID", msgData, serverGroupID, zoneID, curRound, batType, groupNum)
|
return
|
tagCity = batGroup.GetCityWall(tagCityID)
|
if not tagCity:
|
SendFamilyGCZAtkResult(AtkRet_Other, "GroupNoTagCity", msgData, serverGroupID, zoneID, curRound, batType, groupNum)
|
return
|
if tagCity.IsBroken():
|
SendFamilyGCZAtkResult(AtkRet_TagBroken, "TagBroken", msgData, serverGroupID, zoneID, curRound, batType, groupNum)
|
return
|
tagGuardID = 0 # µ¥¹¥¼¼ÄÜÖ¸¶¨³Ç³Ø£¬²»Ö¸¶¨Ä¿±ê
|
canAtkedCityList.append(tagCity)
|
|
# ÆÕͨµ¥¹¥
|
else:
|
if not tagCityID or not tagGuardID or tagCityID == curCityID:
|
SendFamilyGCZAtkResult(AtkRet_Other, "TagIDError-tagCityID-GuardID", msgData, serverGroupID, zoneID, curRound, batType, groupNum)
|
return
|
tagCity = batGroup.GetCityWall(tagCityID)
|
if not tagCity:
|
SendFamilyGCZAtkResult(AtkRet_Other, "GroupNoTagCity", msgData, serverGroupID, zoneID, curRound, batType, groupNum)
|
return
|
if tagCity.IsBroken():
|
SendFamilyGCZAtkResult(AtkRet_TagBroken, "TagBroken", msgData, serverGroupID, zoneID, curRound, batType, groupNum)
|
return
|
if tagCity.GetCurGuardID() != tagGuardID:
|
GameWorld.DebugLog("CurGuardID=%s,fighterIDList=%s" % (tagCity.GetCurGuardID(), tagCity.fighterIDList))
|
SendFamilyGCZAtkResult(AtkRet_TagDead, "TagDead", msgData, serverGroupID, zoneID, curRound, batType, groupNum)
|
return
|
canAtkedCityList.append(tagCity)
|
|
if not canAtkedCityList:
|
SendFamilyGCZAtkResult(AtkRet_Other, "NoAtkedTag", msgData, serverGroupID, zoneID, curRound, batType, groupNum)
|
return
|
|
batFightPower = joinMember.fightPower
|
oneHurtTotal = totalHurtValue = batFightPower * hurtMulti # ×ÜÉ˺¦
|
if len(canAtkedCityList) > 1 :
|
oneHurtTotal = totalHurtValue / len(canAtkedCityList) # ËùÓпɹ¥»÷µÄÄ¿±êÏÉÃËƽ̯É˺¦
|
GameWorld.DebugLog("batFightPower=%s,totalHurtValue=%s,oneHurtTotal=%s" % (batFightPower, totalHurtValue, oneHurtTotal), playerID)
|
|
curTime = int(time.time())
|
oneCanAtkDefMax = IpyGameDataPY.GetFuncCfg("FamilyGCZCity", 2) # µ¥ÃË×î´ó¿É¹¥»÷x¸ö·ÀÊØÈËÔ±
|
hurtDict = {} # ×îÖÕÉËѪÐÅÏ¢
|
killCntTotal = 0 # ±¾´Î¹¥»÷»÷ɱÊý
|
|
for tagCity in canAtkedCityList:
|
if not tagCity or tagCity.IsBroken():
|
continue
|
killCnt = 0
|
tagCityID = tagCity.cityID
|
remainHurtTotal = oneHurtTotal
|
atkedGuardIDList = [] # ±»¹¥»÷µÄÈËÔ±IDÁбí
|
GameWorld.DebugLog("¼ÆËã¹¥»÷³Ç³Ø: tagCityID=%s,cityHP=%s/%s,oneHurtTotal=%s,oneCanAtkDefMax=%s,fighterIDList=%s"
|
% (tagCityID, tagCity.hp, tagCity.hpMax, oneHurtTotal, oneCanAtkDefMax, tagCity.fighterIDList), playerID)
|
while not tagCity.IsBroken() and len(atkedGuardIDList) < oneCanAtkDefMax and remainHurtTotal > 0:
|
fighterID = tagCity.fighterIDList[0]
|
if tagCity.IsGuardNPC(fighterID):
|
tagGuard = tagCity.guardNPC
|
else:
|
tagGuard = zone.GetZoneJoinMember(fighterID)
|
if not tagGuard or tagGuard.IsDead():
|
tagCity.NextGuard()
|
continue
|
atkedGuardIDList.append(fighterID)
|
tagCity.atkedTime = curTime
|
|
hpBef = tagGuard.hp
|
tagGuard.hp = max(0, hpBef - remainHurtTotal)
|
lostHP = hpBef - tagGuard.hp # ¸Ã·ÀÊضÓԱʵ¼ÊµôѪ
|
tagCity.hp = max(0, tagCity.hp - lostHP) # ³Ç³Øͬ²½¿ÛѪ
|
|
# ÐÞÂ޳ǷÀ±¬
|
if tagCityID == XiuluoCityID and tagCity.hp <= 0:
|
tagCity.hp = 1
|
tagGuard.hp = 1
|
lostHP = remainHurtTotal
|
GameWorld.Log(" ÐÞÂ޳ǷÀ±¬: zoneID=%s,familyID=%s" % (zoneID, familyID), playerID)
|
|
GameWorld.DebugLog(" tagGuardID=%s,remainHurtTotal=%s,lostHP=%s,hpBef=%s/%s,hpUpd=%s,cityHPUpd=%s"
|
% (fighterID, remainHurtTotal, lostHP, hpBef, tagGuard.hpMax, tagGuard.hp, tagCity.hp), playerID)
|
|
remainHurtTotal -= lostHP # Ê£ÓàÉ˺¦Öµ
|
|
# Õ½±¨ÒÔʵ¼ÊµôѪ¼ÆË㣬×ÜÁ¿Îª100%
|
curCity.atkReportDict[tagCityID] = curCity.atkReportDict.get(tagCityID, 0) + lostHP
|
tagCity.defReportDict[curCityID] = tagCity.defReportDict.get(curCityID, 0) + lostHP
|
|
if tagGuard.IsDead():
|
killCnt += 1
|
killCntTotal += 1
|
tagCity.NextGuard()
|
|
GameWorld.DebugLog(" remainHurtTotal=%s,killCnt=%s,atkReportDict=%s,defReportDict=%s"
|
% (remainHurtTotal, killCnt, curCity.atkReportDict, tagCity.defReportDict), playerID)
|
|
if not atkedGuardIDList:
|
continue
|
|
hurtDict[tagCityID] = oneHurtTotal # ƮѪ°´É˺¦
|
# ֪ͨ±»¹¥»÷Ã˳ÉÔ±´ó±¾Óª³Ç³ØÐÅÏ¢
|
if tagCity.familyID:
|
tagJoinFamily = zone.GetZoneJoinFamily(tagCity.familyID)
|
if tagJoinFamily:
|
UndFamilyRoundHurtBillboard(tagJoinFamily) # °ñµ¥É˺¦ÊܳdzØѪÁ¿Ó°Ï죬ËùÒÔ±»¹¥»÷·½Ò²Òª¸üаñµ¥
|
Sync_FamilyGCZCampInfo(zoneID, tagCity.familyID, defMemIDList=atkedGuardIDList)
|
Sync_FamilyGCZBatCityInfo(zoneID, batType, groupNum, tagCityID, AtkRet_OK, playerID, oneHurtTotal, killCnt)
|
|
if not hurtDict:
|
SendFamilyGCZAtkResult(AtkRet_Other, "NoHurt", msgData, serverGroupID, zoneID, curRound, batType, groupNum)
|
return
|
|
# ¸üиöÈ˻×ÜÉ˺¦
|
joinMember.totalHurtValue += totalHurtValue
|
GameWorld.DebugLog(" ¸üÐÂÍæ¼Ò»î¶¯×ÜÉ˺¦°ñÖµ! memTotalHurt=%s" % (joinMember.totalHurtValue), playerID)
|
cmpValue = joinMember.totalHurtValue / ChConfig.Def_PerPointValue
|
cmpValue2 = joinMember.totalHurtValue % ChConfig.Def_PerPointValue
|
CrossBillboard.UpdCrossBillboardPlayer(ShareDefine.Def_CBT_FamilyGCZPlayerHurt, playerID, zoneID, cmpValue, cmpValue2, autoSort=False)
|
|
# ±¾ÃË»¹Î´±»´Ý»Ù£¬¿É¼ÆËãÂÖ´ÎÉ˺¦
|
if not curCity.IsBroken():
|
# ±¾ÂÖ³ÉÔ±¹±Ï×É˺¦
|
curCity.fighterHurtDict[playerID] = curCity.fighterHurtDict.get(playerID, 0) + totalHurtValue
|
GameWorld.DebugLog(" ¸üб¾ÂÖÏÉÃ˳ÉÔ±¹±Ï×É˺¦! familyID=%s,playerID=%s,addHurtValue=%s,%s"
|
% (familyID, playerID, totalHurtValue, curCity.fighterHurtDict), playerID)
|
UndFamilyRoundHurtBillboard(curJoinFamily)
|
|
playerRoundHurtTotal = curCity.fighterHurtDict[playerID] # Ö»ËãÉú´æÉ˺¦
|
topHurtPlayerID, topHurtPlayerValue = batGroup.GetTopHurtPlayerIDValue()
|
if playerRoundHurtTotal > topHurtPlayerValue:
|
batGroup.UpdTopHurtPlayerIDValue(playerID, playerRoundHurtTotal)
|
GameWorld.DebugLog(" ¸üÐÂΪ±¾×éÉ˺¦µÚÒ»Íæ¼Ò: playerRoundHurtTotal=%s > %s" % (playerRoundHurtTotal, topHurtPlayerValue), playerID)
|
else:
|
GameWorld.DebugLog(" 䳬¹ý±¾×éÉ˺¦µÚÒ»Íæ¼Ò: playerRoundHurtTotal=%s <= %s,topPlayerHurtID=%s"
|
% (playerRoundHurtTotal, topHurtPlayerValue, topHurtPlayerID), playerID)
|
else:
|
GameWorld.DebugLog(" ×Ô¼ºÏÉÃ˳dzØÒѱ»´Ý»Ù£¬²»ÔÙÀÛ¼Ó±¾ÂÖÏÉÃËÉ˺¦°ñÖµ! familyID=%s" % familyID, playerID)
|
|
SendFamilyGCZAtkResult(AtkRet_OK, "OK", msgData, serverGroupID, zoneID, curRound, batType, groupNum, hurtDict, killCntTotal)
|
return
|
|
def CheckXiuluoCity(zoneID, curRound, batType, groupNum, playerID=0):
|
## ¼ì²éÊÇ·ñË¢ÐÂÐÞÂÞ³Ç
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
#maxRound = GetMaxRound(zone.joinFamilyCnt)
|
appearRoundList = IpyGameDataPY.GetFuncEvalCfg("FamilyGCZXiuluo", 4)
|
if curRound not in appearRoundList:
|
return
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
return
|
xiuluoCity = batGroup.GetCityWall(XiuluoCityID)
|
if xiuluoCity:
|
return
|
aliveFamilyCnt = 0
|
for tagCity in batGroup.cityWallDict.values():
|
if tagCity.IsBroken():
|
continue
|
aliveFamilyCnt += 1
|
if aliveFamilyCnt > 1:
|
return
|
GameWorld.Log("Ê£ÏÂÒ»¸öÏÉÃËδ±»´Ý»Ù£¬Ë¢ÐÂÐÞÂÞ³Ç! zoneID=%s,curRound=%s,batType=%s,groupNum=%s" % (zoneID, curRound, batType, groupNum), playerID)
|
xiuluoCityLV = IpyGameDataPY.GetFuncCfg("FamilyGCZXiuluo", 3)
|
guardNPCCount = IpyGameDataPY.GetFuncCfg("FamilyGCZXiuluo", 2)
|
batGroup.CreateCityWall(XiuluoCityID, xiuluoCityLV, guardNPCCount=guardNPCCount, isAttrLock=True)
|
Sync_FamilyGCZBatSceneInfo(zoneID, batType, groupNum)
|
return True
|
|
def SendFamilyGCZAtkResult(atkRet, errMsg, msgData, serverGroupID, zoneID, curRound, batType, groupNum, hurtDict={}, killCntTotal=0):
|
atkPlayerID = msgData["playerID"]
|
atkType = msgData["atkType"]
|
tagCityID = msgData["tagCityID"]
|
|
if atkPlayerID and atkRet != AtkRet_OK:
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½¹¥»÷ʧ°Ü: atkRet=%s:%s,atkType=%s,%s" % (atkRet, errMsg, atkType, msgData), atkPlayerID)
|
# ʧ°Üʱ½ö֪ͨ·¢Æð¹¥»÷Íæ¼ÒË¢ÐÂ×îÐÂÐÅÏ¢¼´¿É
|
if atkType == AtkType_Normal:
|
Sync_FamilyGCZBatCityInfo(zoneID, batType, groupNum, tagCityID, atkRet, atkPlayerID, toPlayerServerDict={atkPlayerID:serverGroupID})
|
else:
|
Sync_FamilyGCZBatSceneInfo(zoneID, batType, groupNum, atkPlayerID, atkType, toPlayerServerDict={atkPlayerID:serverGroupID})
|
|
# ÓÐÍæ¼Ò¹¥»÷³É¹¦£¬ÐèҪͬ²½Í¨ÖªÔڳdzس¡¾°ÄÚ¼°³Ç³ØÄÚµÄÍæ¼Ò£¬ÒòΪÎÞÂÛÔÚÄÄÀï¹¥»÷¶¼»á´¥·¢³Ç³ØÄڳdzØÍâË«·½ÐÅÏ¢µÄ±ä»¯
|
if atkPlayerID and atkRet == AtkRet_OK:
|
#Sync_FamilyGCZBatCityInfo Õâ¸öÔÚ¹¥»÷±éÀúÖÐÒÑ֪ͨ£¬½ö֪ͨ±»¹¥»÷µÄ³Ç³Ø
|
Sync_FamilyGCZBatSceneInfo(zoneID, batType, groupNum, atkPlayerID, atkType, hurtDict, killCntTotal)
|
|
msgInfo = {"atkRet":atkRet, "errMsg":errMsg, "reqMsg":msgData, "hurtDict":hurtDict, "killCntTotal":killCntTotal}
|
Send_CrossServerMsg_FamilyGCZ("FamilyGCZAtkResult", msgInfo, [serverGroupID])
|
|
CheckXiuluoCity(zoneID, curRound, batType, groupNum, atkPlayerID)
|
return
|
|
def Sync_FamilyGCZBatSceneInfo(zoneID, batType, groupNum, atkPlayerID=0, atkType=0, hurtDict={}, killCntTotal=0, toPlayerServerDict=None):
|
## ֪ͨ³Ç³Ø³¡¾°ÐÅÏ¢
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
return
|
|
onlinePlayerIDDict = {}
|
if toPlayerServerDict != None:
|
onlinePlayerIDDict = toPlayerServerDict
|
else:
|
onlineMgr = ChPlayer.GetOnlinePlayerMgr()
|
notifyPlayerIDList = batGroup.inBatScenePlayerIDList # + [atkPlayerID]
|
for playerID in notifyPlayerIDList:
|
if not playerID or playerID in onlinePlayerIDDict:
|
continue
|
serverGroupID = onlineMgr.GetOLPlayerServerGroupID(playerID)
|
if serverGroupID:
|
onlinePlayerIDDict[playerID] = serverGroupID
|
GameWorld.DebugLog("Sync_FamilyGCZBatSceneInfo zoneID=%s,batType=%s,groupNum=%s,%s,%s"
|
% (zoneID, batType, groupNum, notifyPlayerIDList, onlinePlayerIDDict), atkPlayerID)
|
|
if not onlinePlayerIDDict:
|
return
|
|
sceneShowPlayerIDList = [] # ³¡¾°ÖÐÐèҪչʾµÄÍæ¼ÒIDÁбí
|
topFamilyID, topLeaderID = 0, 0
|
|
groupValue2 = GetRoundHurtGroupID(batType, groupNum)
|
billboardMgr = PyDataManager.GetCrossBillboardManager()
|
roundHurtBillboard = billboardMgr.GetCrossBillboard(ShareDefine.Def_CBT_FamilyGCZRoundHurt, zoneID, groupValue2)
|
idOrderDict = roundHurtBillboard.GetIDOrderDict()
|
if roundHurtBillboard.GetCount():
|
topFamilyBillboard = roundHurtBillboard.At(0)
|
topFamilyID = topFamilyBillboard.ID
|
topFamily = zone.GetZoneJoinFamily(topFamilyID)
|
if topFamily:
|
topLeaderID = topFamily.leaderID
|
if topLeaderID not in sceneShowPlayerIDList:
|
sceneShowPlayerIDList.append(topLeaderID)
|
|
topPlayerID = batGroup.GetTopHurtPlayerIDValue()[0]
|
topPlayerFamilyID = 0
|
if topPlayerID:
|
if topPlayerID not in sceneShowPlayerIDList:
|
sceneShowPlayerIDList.append(topPlayerID)
|
topMember = zone.GetZoneJoinMember(topPlayerID)
|
if topMember:
|
topPlayerFamilyID = topMember.familyID
|
|
clientPack = ChPyNetSendPack.tagGCFamilyGCZBatSceneInfo()
|
clientPack.BatType = batType
|
clientPack.GroupNum = groupNum
|
clientPack.TopFamilyID = topFamilyID
|
clientPack.TopLeaderID = topLeaderID
|
clientPack.TopPlayerID = topPlayerID
|
clientPack.TopPlayerFamilyID = topPlayerFamilyID
|
# ³¡¾°ÐÅϢֻ֪ͨ¼¼Äܹ¥»÷
|
if atkType != AtkType_Normal and hurtDict:
|
if atkPlayerID not in sceneShowPlayerIDList:
|
sceneShowPlayerIDList.append(atkPlayerID)
|
clientPack.AtkPlayerID = atkPlayerID
|
clientPack.AtkType = atkType
|
clientPack.KillCnt = killCntTotal
|
clientPack.HurtList = []
|
for cityID, hurtTotal in hurtDict.items():
|
hurt = ChPyNetSendPack.tagGCFamilyGCZBatSceneHurt()
|
hurt.CityID = cityID
|
hurt.HurtValue = hurtTotal % ChConfig.Def_PerPointValue
|
hurt.HurtValueEx = hurtTotal / ChConfig.Def_PerPointValue
|
clientPack.HurtList.append(hurt)
|
clientPack.HurtCnt = len(clientPack.HurtList)
|
|
# ³¡¾°Óб仯µÄ³Ç³Ø£¬ÔÝʱ¶¼Í¬²½£¬²»È»¿ÉÄÜÃû´ÎÏÔʾÓÐÎÊÌâ
|
#if hurtDict:
|
# syncCityIDList = hurtDict.keys()
|
#else:
|
syncCityIDList = batGroup.GetCityIDList()
|
clientPack.CityList = []
|
for cityID in syncCityIDList:
|
cityWall = batGroup.GetCityWall(cityID)
|
if not cityWall:
|
continue
|
city = ChPyNetSendPack.tagGCFamilyGCZBatSceneCity()
|
city.CityID = cityID
|
city.CityLV = cityWall.cityLV
|
city.FamilyID = cityWall.familyID
|
city.Rank = idOrderDict.get(cityWall.familyID, 0)
|
city.HP = cityWall.hp % ChConfig.Def_PerPointValue
|
city.HPEx = cityWall.hp / ChConfig.Def_PerPointValue
|
city.HPMax = cityWall.hpMax % ChConfig.Def_PerPointValue
|
city.HPMaxEx = cityWall.hpMax / ChConfig.Def_PerPointValue
|
city.LastAtkedTime = cityWall.atkedTime
|
clientPack.CityList.append(city)
|
clientPack.CityCnt = len(clientPack.CityList)
|
|
# ³¡¾°ÐèÒªÓõ½µÄÍæ¼ÒÐÅÏ¢
|
clientPack.PlayerInfoList = []
|
for playerID in sceneShowPlayerIDList:
|
joinMember = zone.GetZoneJoinMember(playerID)
|
if not joinMember:
|
continue
|
scenePlayer = ChPyNetSendPack.tagGCFamilyGCZBatScenePlayer()
|
scenePlayer.PlayerID = playerID
|
scenePlayer.Name = joinMember.playerName
|
scenePlayer.Job = joinMember.job
|
scenePlayer.Face = joinMember.face
|
scenePlayer.FacePic = joinMember.facePic
|
scenePlayer.FamilyID = joinMember.familyID
|
clientPack.PlayerInfoList.append(scenePlayer)
|
clientPack.PlayerCnt = len(clientPack.PlayerInfoList)
|
|
NetPackCommon.SendFakePackByCross(onlinePlayerIDDict, clientPack)
|
return
|
|
def Sync_FamilyGCZBatCityInfo(zoneID, batType, groupNum, cityID, atkRet=0, atkPlayerID=0, hurtValue=0, killCnt=0, toPlayerServerDict=None):
|
## ֪ͨ³Ç³ØÐÅÏ¢
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
return
|
cityWall = batGroup.GetCityWall(cityID)
|
if not cityWall:
|
return
|
|
onlinePlayerIDDict = {}
|
if toPlayerServerDict != None:
|
onlinePlayerIDDict = toPlayerServerDict
|
else:
|
onlineMgr = ChPlayer.GetOnlinePlayerMgr()
|
notifyPlayerIDList = cityWall.inCityPlayerIDList # + [atkPlayerID]
|
for playerID in notifyPlayerIDList:
|
if not playerID or playerID in onlinePlayerIDDict:
|
continue
|
serverGroupID = onlineMgr.GetOLPlayerServerGroupID(playerID)
|
if serverGroupID:
|
onlinePlayerIDDict[playerID] = serverGroupID
|
GameWorld.DebugLog("Sync_FamilyGCZBatCityInfo zoneID=%s,batType=%s,groupNum=%s,cityID=%s,%s,%s"
|
% (zoneID, batType, groupNum, cityID, notifyPlayerIDList, onlinePlayerIDDict), atkPlayerID)
|
|
if not onlinePlayerIDDict:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCFamilyGCZBatCityInfo()
|
clientPack.CityID = cityID
|
clientPack.CityLV = cityWall.cityLV
|
clientPack.FamilyID = cityWall.familyID
|
clientPack.GuardID = cityWall.GetCurGuardID()
|
clientPack.HP = cityWall.hp % ChConfig.Def_PerPointValue
|
clientPack.HPEx = cityWall.hp / ChConfig.Def_PerPointValue
|
clientPack.HPMax = cityWall.hpMax % ChConfig.Def_PerPointValue
|
clientPack.HPMaxEx = cityWall.hpMax / ChConfig.Def_PerPointValue
|
clientPack.AtkPlayerID = atkPlayerID
|
clientPack.AtkRet = atkRet
|
clientPack.KillCnt = killCnt
|
clientPack.HurtValue = hurtValue % ChConfig.Def_PerPointValue
|
clientPack.HurtValueEx = hurtValue / ChConfig.Def_PerPointValue
|
NetPackCommon.SendFakePackByCross(onlinePlayerIDDict, clientPack)
|
return
|
|
def __clientServer_QueryContributionInfo(playerID, serverGroupID, msgData):
|
## ²éѯ¹±Ï×ÖµÐÅÏ¢
|
gczMgr = GetFamilyGCZMgr()
|
joinFamily = gczMgr.GetJoinFamilyByPlayerID(playerID)
|
if not joinFamily:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCFamilyGCZContributionInfo()
|
clientPack.ContriList = []
|
for memID, value in joinFamily.memAddCampExpInfo.items():
|
contri = ChPyNetSendPack.tagGCFamilyGCZContribution()
|
contri.PlayerID = memID
|
contri.ContributionValue = value
|
clientPack.ContriList.append(contri)
|
clientPack.ContriCnt = len(clientPack.ContriList)
|
NetPackCommon.SendFakePackByCross({playerID:serverGroupID}, clientPack)
|
return
|
|
def __clientServer_QueryBatReport(playerID, serverGroupID, repFamilyID):
|
## ²éѯս±¨
|
|
gczMgr = GetFamilyGCZMgr()
|
repFamily = gczMgr.GetJoinFamily(repFamilyID)
|
if not repFamily:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCFamilyGCZBatReport()
|
clientPack.FamilyID = repFamilyID
|
clientPack.DefRepList = []
|
for tagFamilyID, hurtValue in repFamily.cityWall.defReportDict.items():
|
defRep = ChPyNetSendPack.tagGCFamilyGCZBatRepHurt()
|
defRep.TagFamilyID = tagFamilyID
|
defRep.HurtValue = hurtValue % ChConfig.Def_PerPointValue
|
defRep.HurtValueEx = hurtValue / ChConfig.Def_PerPointValue
|
clientPack.DefRepList.append(defRep)
|
clientPack.DefRepCnt = len(clientPack.DefRepList)
|
|
clientPack.AtkRepList = []
|
for tagFamilyID, hurtValue in repFamily.cityWall.atkReportDict.items():
|
atkRep = ChPyNetSendPack.tagGCFamilyGCZBatRepHurt()
|
atkRep.TagFamilyID = tagFamilyID
|
atkRep.HurtValue = hurtValue % ChConfig.Def_PerPointValue
|
atkRep.HurtValueEx = hurtValue / ChConfig.Def_PerPointValue
|
clientPack.AtkRepList.append(atkRep)
|
clientPack.AtkRepCnt = len(clientPack.AtkRepList)
|
|
NetPackCommon.SendFakePackByCross({playerID:serverGroupID}, clientPack)
|
return
|
|
def __clientServer_QueryGroupFamilyMemHurt(playerID, serverGroupID, zoneID, tagFamilyID):
|
## ²éѯ·Ö×éÏÉÃ˳ÉÔ±É˺¦ÐÅÏ¢
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
joinFamily = zone.GetZoneJoinFamily(tagFamilyID)
|
if not joinFamily:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCFamilyGCZGroupFamilyMemHurtInfo()
|
clientPack.FamilyID = tagFamilyID
|
clientPack.HurtMemList = []
|
for memID, value in joinFamily.cityWall.fighterHurtDict.items():
|
joinMember = zone.GetZoneJoinMember(memID)
|
memHurt = ChPyNetSendPack.tagGCFamilyGCZGroupFamilyMemHurt()
|
memHurt.PlayerID = memID
|
memHurt.Name = joinMember.playerName if joinMember else ""
|
memHurt.HurtValue = value % ChConfig.Def_PerPointValue
|
memHurt.HurtValueEx = value / ChConfig.Def_PerPointValue
|
clientPack.HurtMemList.append(memHurt)
|
clientPack.HurtMemCnt = len(clientPack.HurtMemList)
|
NetPackCommon.SendFakePackByCross({playerID:serverGroupID}, clientPack)
|
return
|
|
def __clientServer_Guess(serverGroupID, msgData):
|
## ¾º²Â - ÎÞ²ÎÓë×ʸñµÄÒ²¿ÉÒÔ¾º²Â
|
|
playerID = msgData["playerID"]
|
selectFamilyIDList = msgData["selectFamilyIDList"]
|
|
zoneID = GetPlayerActJoinInfo(playerID)[0]
|
actInfo = CrossActionControl.GetCrossActInfoByZoneID(ShareDefine.CrossActName_FamilyGCZ, zoneID)
|
if not actInfo:
|
return
|
state = actInfo.get(ShareDefine.ActKey_State)
|
if not state:
|
return
|
canGuessStateList = IpyGameDataPY.GetFuncEvalCfg("FamilyGCZGuess", 1)
|
if state not in canGuessStateList:
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½·Ç¾º²Â½×¶Î: zoneID=%s,state=%s not in %s" % (zoneID, state, canGuessStateList), playerID)
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
guessCountMax = IpyGameDataPY.GetFuncCfg("FamilyGCZGuess", 3)
|
selectFamilyIDList = selectFamilyIDList[:guessCountMax]
|
for familyID in selectFamilyIDList:
|
if familyID not in zone.familyGuessDict:
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½¸ÃÏÉÃËID²»¿É¾º²Â! zoneID=%s,selectFamilyIDList=%s,familyID=%s not in %s"
|
% (zoneID, selectFamilyIDList, familyID, zone.familyGuessDict.keys()), playerID)
|
return
|
|
for familyID in selectFamilyIDList:
|
zone.familyGuessDict[familyID] = zone.familyGuessDict.get(familyID, 0) + 1
|
|
zone.playerGuessDict[playerID] = selectFamilyIDList
|
GameWorld.DebugLog("ÏÉÃ˹¥³ÇÕ½¾º²Â: %s,familyGuessDict=%s" % (selectFamilyIDList, zone.familyGuessDict), playerID)
|
|
Sync_FamilyGCZGuessInfo(zoneID, selectPlayerID=playerID)
|
return
|
|
def __DoGMGuess(zoneID, state, guessCnt, selectFamilyIDList, playerID, serverGroupID):
|
## GMɽկ¾º²ÂÊý¾Ý
|
|
canGuessStateList = IpyGameDataPY.GetFuncEvalCfg("FamilyGCZGuess", 1)
|
if state not in canGuessStateList:
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "·Ç¾º²Â½×¶Î!state=%s" % (state))
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
guessCountMax = IpyGameDataPY.GetFuncCfg("FamilyGCZGuess", 3)
|
selectFamilyIDList = selectFamilyIDList[:guessCountMax]
|
|
# ûÓÐÖ¸¶¨¾º²Â£¬ÔòËæ»ú
|
if not selectFamilyIDList:
|
familyIDList = zone.familyGuessDict.keys()
|
random.shuffle(familyIDList)
|
selectFamilyIDList = familyIDList[:guessCountMax]
|
|
for familyID in selectFamilyIDList:
|
zone.familyGuessDict[familyID] = zone.familyGuessDict.get(familyID, 0) + guessCnt
|
|
maxFackID = 0
|
for pID in zone.playerGuessDict.keys():
|
if pID < 10000 and pID > maxFackID:
|
maxFackID = pID
|
|
for pID in range(maxFackID + 1, maxFackID + 1 + guessCnt + 1):
|
zone.playerGuessDict[pID] = selectFamilyIDList
|
|
GameWorld.DebugAnswerCross(playerID, serverGroupID, "ÐÂÔö¾º²ÂÈËÊý:%s, ×Ü:%s" % (guessCnt, len(zone.playerGuessDict)))
|
Sync_FamilyGCZGuessInfo(zoneID)
|
return
|
|
def __clientServer_GetAward(serverGroupID, msgData):
|
## Áì½±
|
playerID = msgData["playerID"]
|
awardType = msgData["awardType"]
|
|
zoneID = GetPlayerActJoinInfo(playerID)[0]
|
actInfo = CrossActionControl.GetCrossActInfoByZoneID(ShareDefine.CrossActName_FamilyGCZ, zoneID)
|
if not actInfo:
|
return
|
actID = actInfo.get(ShareDefine.ActKey_ID)
|
state = actInfo.get(ShareDefine.ActKey_State)
|
if not state or state != FamilyGCZState_Award:
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½·ÇÁì½±½×¶Î: zoneID=%s,state=%s" % (zoneID, state), playerID)
|
return
|
|
ipyDataInfo = actInfo.get(ShareDefine.ActKey_IpyDataInfo)
|
if not ipyDataInfo:
|
return
|
|
# ¿ç·þÁì½±²»ÑéÖ¤Á콱״̬£¬Á콱״ֻ̬±ê¼ÇÒÑÍÆËÍ£¬Êµ¼ÊÁì½±ÓÉ×Ó·þµØͼÍæ¼Ò×ÔÐÐÑéÖ¤
|
|
# ¾º²Â
|
if awardType == AwwardType_Guess:
|
awardTemplateID = ipyDataInfo.get("GuessTemplateID", 0)
|
playerAwardID, awardItemList = GetGuessAwardInfo(zoneID, state, awardTemplateID, playerID)
|
if not awardItemList:
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½Íæ¼ÒûÓоº²Â½±Àø! zoneID=%s" % (zoneID), playerID)
|
return
|
__clientServer_GetAward_Ret(zoneID, playerID, serverGroupID, actID, awardType, playerAwardID, awardItemList)
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
joinMember = zone.GetZoneJoinMember(playerID)
|
if not joinMember:
|
GameWorld.ErrLog("·ÇÏÉÃ˹¥³ÇÕ½²ÎÈü³ÉÔ±!", playerID)
|
return
|
zoneID = joinMember.zoneID
|
familyID = joinMember.familyID
|
fmLV = joinMember.fmLV
|
|
billID = playerID
|
billboardType = 0
|
awardTemplateID = 0
|
billValue = None
|
|
# ¸öÈËÅÅÐÐ
|
if awardType == AwwardType_PlayerHurt:
|
billID = playerID
|
billboardType = ShareDefine.Def_CBT_FamilyGCZPlayerHurt
|
awardTemplateID = ipyDataInfo.get("PersonalTemplateID", 0)
|
|
# ÏÉÃËÅÅÐÐ
|
elif awardType == AwwardType_FamilyScore:
|
billID = familyID
|
billboardType = ShareDefine.Def_CBT_FamilyGCZScore
|
awardTemplateID = ipyDataInfo.get("FamilyTemplateID", 0)
|
|
# µãÔÞ½±Àø
|
elif awardType == AwwardType_Like:
|
awardItemList = IpyGameDataPY.GetFuncEvalCfg("FamilyGCZGuess", 4)
|
__clientServer_GetAward_Ret(zoneID, playerID, serverGroupID, actID, awardType, 0, awardItemList)
|
return
|
|
else:
|
return
|
|
if not awardTemplateID:
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½Á콱ʱûÓÐÅÅÐн±ÀøÄ£°æ! zoneID=%s,awardType=%s" % (zoneID, awardType), playerID)
|
return
|
|
billboardMgr = PyDataManager.GetCrossBillboardManager()
|
billObj = billboardMgr.GetCrossBillboard(billboardType, zoneID)
|
idRankDict = billObj.GetIDOrderDict()
|
billRank = idRankDict.get(billID, 0)
|
|
if not billRank:
|
GameWorld.ErrLog("ÏÉÃ˹¥³ÇÕ½Á콱ʱûÓÐÉÏ°ñ! zoneID=%s,awardType=%s,billboardType=%s,billID=%s"
|
% (zoneID, awardType, billboardType, billID), playerID)
|
return
|
|
playerAwardItemList = GameWorld.GetActBillboardTempAward(playerID, billID, billRank, awardTemplateID, billValue, fmLV)
|
if not playerAwardItemList:
|
return
|
|
__clientServer_GetAward_Ret(zoneID, playerID, serverGroupID, actID, awardType, billRank, playerAwardItemList)
|
|
serverIDList = actInfo.get(ShareDefine.ActKey_ServerIDRangeList, [])
|
GameXiangong.AddXiangongPlayerByItem(playerAwardItemList, playerID, serverIDList, billRank)
|
return
|
|
def __clientServer_GetAward_Ret(zoneID, playerID, serverGroupID, actID, awardType, awardValue, awardItemList):
|
## ͬ²½×Ó·þÁì½±½á¹û
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
joinMember = zone.GetZoneJoinMember(playerID)
|
fmLV = 0
|
if joinMember:
|
fmLV = joinMember.fmLV
|
joinMember.awardState = joinMember.awardState | pow(2, awardType) # ±ê¼ÇÒÑÍÆËÍ
|
GameWorld.Log("ÏÉÃ˹¥³ÇÕ½Íæ¼ÒÇëÇóÁìÈ¡½±Àø! zoneID=%s,awardType=%s,awardValue=%s,awardItemList=%s"
|
% (zoneID, awardType, awardValue, awardItemList), playerID)
|
msgInfo = {"zoneID":zoneID, "playerID":playerID, "actID":actID, "awardType":awardType, "awardValue":awardValue,
|
"awardItemList":awardItemList, "fmLV":fmLV}
|
Send_CrossServerMsg_FamilyGCZ("FamilyGCZAward", msgInfo, [serverGroupID])
|
return
|
|
def GetGuessAwardInfo(zoneID, state, guessTemplateID, playerID):
|
## »ñÈ¡¾º²Â½±Àø
|
playerAwardID = 0
|
awardItemList = []
|
_, statGuessRetDict = __statGuessFinal(zoneID, state, guessTemplateID)
|
for awardID, rightPlayerIDList in statGuessRetDict.items():
|
if playerID in rightPlayerIDList:
|
playerAwardID = awardID
|
break
|
|
if playerAwardID:
|
ipyData = IpyGameDataPY.GetIpyGameDataByCondition("ActGuess", {"TemplateID":guessTemplateID, "AwardID":playerAwardID}, False)
|
if ipyData:
|
awardItemList = ipyData.GetAwardItemList()
|
|
return playerAwardID, awardItemList
|
|
def DoMailReissueAward(zoneID, ipyData):
|
## Óʼþ²¹·¢½±Àø - ½öÕë¶ÔÓвÎÓë×ʸñµÄ£¬ÎÞ²ÎÓë×ʸñµÄÍæ¼Ò½±ÀøÔݲ»²¹·¢£¬È羺²Â½±Àø
|
|
if not ipyData:
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
if not zone.joinMemberDict:
|
return
|
|
GameWorld.Log("ÏÉÃ˹¥³ÇÕ½Óʼþ²¹·¢Î´ÁìÈ¡½±Àø: zoneID=%s" % zoneID)
|
|
billboardMgr = PyDataManager.GetCrossBillboardManager()
|
for playerID in zone.joinMemberDict.keys():
|
if playerID < 10000:
|
continue
|
joinMember = zone.GetZoneJoinMember(playerID)
|
if not joinMember:
|
continue
|
familyID = joinMember.familyID
|
fmLV = joinMember.fmLV
|
|
# ¸öÈËÉ˺¦Ãû´Î½±Àø
|
if not joinMember.awardState&pow(2, AwwardType_PlayerHurt):
|
joinMember.awardState = joinMember.awardState | pow(2, AwwardType_PlayerHurt)
|
billObj = billboardMgr.GetCrossBillboard(ShareDefine.Def_CBT_FamilyGCZPlayerHurt, zoneID)
|
idRankDict = billObj.GetIDOrderDict()
|
billRank = idRankDict.get(playerID, 0)
|
billValue = None
|
awardTemplateID = ipyData.GetPersonalTemplateID()
|
playerAwardItemList = GameWorld.GetActBillboardTempAward(playerID, playerID, billRank, awardTemplateID, billValue, fmLV)
|
if playerAwardItemList:
|
paramList = [billRank]
|
PlayerCompensation.SendMailByKey("FamilyGCZAwardHurt", [playerID], playerAwardItemList, paramList, crossMail=True)
|
|
serverIDList = ipyData.GetServerIDRangeList()
|
GameXiangong.AddXiangongPlayerByItem(playerAwardItemList, playerID, serverIDList, billRank)
|
|
# ÏÉÃË»ý·ÖÃû´Î½±Àø
|
if not joinMember.awardState&pow(2, AwwardType_FamilyScore):
|
joinMember.awardState = joinMember.awardState | pow(2, AwwardType_FamilyScore)
|
billObj = billboardMgr.GetCrossBillboard(ShareDefine.Def_CBT_FamilyGCZScore, zoneID)
|
idRankDict = billObj.GetIDOrderDict()
|
billRank = idRankDict.get(familyID, 0)
|
billValue = None
|
awardTemplateID = ipyData.GetFamilyTemplateID()
|
playerAwardItemList = GameWorld.GetActBillboardTempAward(playerID, familyID, billRank, awardTemplateID, billValue, fmLV)
|
if playerAwardItemList:
|
paramList = [billRank]
|
PlayerCompensation.SendMailByKey("FamilyGCZAwardScore", [playerID], playerAwardItemList, paramList, crossMail=True)
|
|
serverIDList = ipyData.GetServerIDRangeList()
|
GameXiangong.AddXiangongPlayerByItem(playerAwardItemList, playerID, serverIDList, billRank)
|
|
# ¾º²Â½±Àø
|
if not joinMember.awardState&pow(2, AwwardType_Guess):
|
joinMember.awardState = joinMember.awardState | pow(2, AwwardType_Guess)
|
awardTemplateID = ipyData.GetGuessTemplateID()
|
_, awardItemList = GetGuessAwardInfo(zoneID, None, awardTemplateID, playerID)
|
if awardItemList:
|
paramList = []
|
PlayerCompensation.SendMailByKey("FamilyGCZAwardGuess", [playerID], awardItemList, paramList, crossMail=True)
|
|
return
|
|
def Sync_FamilyGCZGuessInfo(zoneID, playerID=0, selectPlayerID=0):
|
## ͬ²½¾º²ÂÐÅÏ¢ - Ðèͬ²½È«·þÍæ¼Ò£¬°üº¬Ã»ÓвÎÓë×ʸñµÄ
|
# @param selectPlayerID: ͬ²½¾º²ÂÍæ¼ÒID¾º²Â¼Ç¼
|
actInfo = CrossActionControl.GetCrossActInfoByZoneID(ShareDefine.CrossActName_FamilyGCZ, zoneID)
|
if not actInfo:
|
return
|
state = actInfo.get(ShareDefine.ActKey_State)
|
if not state:
|
return
|
ipyDataInfo = actInfo.get(ShareDefine.ActKey_IpyDataInfo)
|
if not ipyDataInfo:
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
if not zone.familyGuessDict:
|
# ÔÝÎÞ¾º²ÂÃûµ¥
|
return
|
|
onlinePlayerIDDict = {}
|
onlineMgr = ChPlayer.GetOnlinePlayerMgr()
|
if not playerID:
|
for playerID, serverGroupID in onlineMgr.onlinePlayerDict.items():
|
pActInfo = GetPlayerActJoinInfo(playerID)
|
if zoneID != pActInfo[0]:
|
continue
|
onlinePlayerIDDict[playerID] = serverGroupID
|
else:
|
onlinePlayerIDDict = {playerID:onlineMgr.GetOLPlayerServerGroupID(playerID)}
|
|
if not onlinePlayerIDDict:
|
return
|
|
selectFamilyIDList = []
|
if selectPlayerID:
|
selectFamilyIDList = zone.playerGuessDict.get(selectPlayerID, [])
|
|
guessTemplateID = ipyDataInfo.get("GuessTemplateID", 0)
|
finalFamilyIDList, statGuessRetDict = __statGuessFinal(zoneID, state, guessTemplateID)
|
|
clientPack = ChPyNetSendPack.tagGCFamilyGCZGuessInfo()
|
clientPack.PlayerID = selectPlayerID
|
clientPack.SelectFamilyIDList = selectFamilyIDList
|
clientPack.SelectCnt = len(clientPack.SelectFamilyIDList)
|
|
clientPack.FinalFamilyIDList = finalFamilyIDList
|
clientPack.FinalCnt = len(clientPack.FinalFamilyIDList)
|
|
clientPack.RightInfoList = []
|
for awardID, rightPlayerIDList in statGuessRetDict.items():
|
right = ChPyNetSendPack.tagGCFamilyGCZGuessRight()
|
right.AwardID = awardID
|
right.RightPlayerCnt = len(rightPlayerIDList)
|
clientPack.RightInfoList.append(right)
|
clientPack.RightCnt = len(clientPack.RightInfoList)
|
|
clientPack.GuessFamilyList = []
|
for familyID, guessValue in zone.familyGuessDict.items():
|
familyGuess = ChPyNetSendPack.tagGCFamilyGCZGuessFamily()
|
familyGuess.FamilyID = familyID
|
familyGuess.GuessValue = guessValue
|
clientPack.GuessFamilyList.append(familyGuess)
|
clientPack.FamilyCnt = len(clientPack.GuessFamilyList)
|
|
NetPackCommon.SendFakePackByCross(onlinePlayerIDDict, clientPack)
|
return
|
|
def __statGuessFinal(zoneID, state, guessTemplateID):
|
## ͳ¼Æ¾º²Â×îÖÕ½á¹û
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
if zone.statGuessRetDict != None:
|
statGuessRetDict = zone.statGuessRetDict
|
finalFamilyIDList = zone.guessFinalFamilyIDList
|
return finalFamilyIDList, statGuessRetDict
|
|
finalFamilyIDList = []
|
statGuessRetDict = {}
|
if state != None and state != FamilyGCZState_Award:
|
return finalFamilyIDList, statGuessRetDict
|
|
guessCountMax = IpyGameDataPY.GetFuncCfg("FamilyGCZGuess", 3)
|
billboardMgr = PyDataManager.GetCrossBillboardManager()
|
scoreBillObj = billboardMgr.GetCrossBillboard(ShareDefine.Def_CBT_FamilyGCZScore, zoneID)
|
for index in range(scoreBillObj.GetCount()):
|
billData = scoreBillObj.At(index)
|
finalFamilyIDList.append(billData.ID)
|
if len(finalFamilyIDList) >= guessCountMax:
|
break
|
|
# ͳ¼Æ¾º²Â½á¹û
|
rightRankAwardIDDict = GameWorld.GetActGuessRightRankAwardIDDict(guessTemplateID)
|
GameWorld.Log("ÏÉÃ˹¥³Çսͳ¼Æ¾º²Â½á¹û: zoneID=%s,guessTemplateID=%s,finalFamilyIDList=%s,%s" % (zoneID, guessTemplateID, finalFamilyIDList, rightRankAwardIDDict))
|
|
statGuessRetDict = {}
|
for playerID, guessFamilyIDList in zone.playerGuessDict.items():
|
GameWorld.StatActGuessRet(playerID, guessFamilyIDList, finalFamilyIDList, rightRankAwardIDDict, statGuessRetDict, "FamilyGCZ")
|
|
GameWorld.Log(" zoneID=%s,statGuessRetDict=%s" % (zoneID, statGuessRetDict))
|
zone.statGuessRetDict = statGuessRetDict
|
zone.guessFinalFamilyIDList = finalFamilyIDList
|
return finalFamilyIDList, statGuessRetDict
|
|
def Sync_FamilyGCZActInfo(zoneID, playerID=0):
|
## ͬ²½»î¶¯Ê±¼äÐÅÏ¢ - Ðèͬ²½È«·þÍæ¼Ò£¬°üº¬Ã»ÓвÎÓë×ʸñµÄ
|
actInfo = CrossActionControl.GetCrossActInfoByZoneID(ShareDefine.CrossActName_FamilyGCZ, zoneID)
|
if not actInfo:
|
return
|
if not actInfo.get(ShareDefine.ActKey_State):
|
return
|
ipyDataInfo = actInfo.get(ShareDefine.ActKey_IpyDataInfo)
|
if not ipyDataInfo:
|
return
|
|
playerActInfo = {}
|
onlinePlayerIDDict = {}
|
onlineMgr = ChPlayer.GetOnlinePlayerMgr()
|
if not playerID:
|
for playerID, serverGroupID in onlineMgr.onlinePlayerDict.items():
|
pActInfo = GetPlayerActJoinInfo(playerID)
|
if zoneID != pActInfo[0]:
|
continue
|
playerActInfo[playerID] = pActInfo
|
onlinePlayerIDDict[playerID] = serverGroupID
|
else:
|
playerActInfo[playerID] = GetPlayerActJoinInfo(playerID)
|
onlinePlayerIDDict = {playerID:onlineMgr.GetOLPlayerServerGroupID(playerID)}
|
|
if not onlinePlayerIDDict:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCFamilyGCZActInfo()
|
clientPack.Clear()
|
clientPack.ServerIDRangeInfo = str(actInfo.get(ShareDefine.ActKey_ServerIDRangeList, []))
|
clientPack.ServerInfoLen = len(clientPack.ServerIDRangeInfo)
|
clientPack.ZoneID = zoneID
|
clientPack.ActID = actInfo.get(ShareDefine.ActKey_ID, 0)
|
clientPack.StartDate = ipyDataInfo.get("StartDate", "")
|
clientPack.EndtDate = ipyDataInfo.get("EndDate", "")
|
clientPack.JoinFamilyCnt = ipyDataInfo.get("JoinFamilyCnt", 0)
|
clientPack.ActFlowID = ipyDataInfo.get("ActFlowID", 0)
|
clientPack.GuessTemplateID = ipyDataInfo.get("GuessTemplateID", 0)
|
clientPack.PersonalTemplateID = ipyDataInfo.get("PersonalTemplateID", 0)
|
clientPack.FamilyTemplateID = ipyDataInfo.get("FamilyTemplateID", 0)
|
clientPack.StateError = actInfo.get(ShareDefine.ActKey_StateError, 0)
|
|
clientPack.ActFamilyList = []
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
for familyID in zone.GetZoneLockFamilyIDList():
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
continue
|
|
actFamily = ChPyNetSendPack.tagGCFamilyGCZActFamily()
|
actFamily.FamilyID = familyID
|
actFamily.Name = joinFamily.familyName
|
actFamily.LV = joinFamily.lv
|
actFamily.ServerID = joinFamily.serverID
|
actFamily.EmblemID = joinFamily.emblemID
|
actFamily.FightPower = joinFamily.fightPowerTotal % ChConfig.Def_PerPointValue
|
actFamily.FightPowerEx = joinFamily.fightPowerTotal / ChConfig.Def_PerPointValue
|
actFamily.LeaderID = joinFamily.leaderID
|
actFamily.LeaderName = joinFamily.leaderName
|
|
leaderMem = zone.GetZoneJoinMember(actFamily.LeaderID)
|
if leaderMem:
|
actFamily.LeaderFace = leaderMem.face
|
actFamily.LeaderFacePic = leaderMem.facePic
|
|
clientPack.ActFamilyList.append(actFamily)
|
clientPack.FamilyCount = len(clientPack.ActFamilyList)
|
NetPackCommon.SendFakePackByCross(onlinePlayerIDDict, clientPack)
|
|
#ͬ²½³¡¾°¡¢Í¬²½Íæ¼Ò¹¥»÷½á¹û
|
#Ï·¢·ÖÇø»î¶¯µÄʱºò£¬Ë³±ãÏ·¢Íæ¼Ò»î¶¯ÐÅÏ¢
|
msgInfo = {"zoneID":zoneID, "playerActInfo":playerActInfo}
|
Send_CrossServerMsg_FamilyGCZ("FamilyGCZPlayerActInfo", msgInfo, onlinePlayerIDDict.values())
|
return
|
|
def Sync_FamilyGCZBatGroupInfo(zoneID, onlinePlayerIDDict=None):
|
## ͬ²½Õ½³¡ÀàÐÍ·Ö×éÐÅÏ¢ - ֻͬ²½ÓвÎÓë×ʸñµÄ¼´¿É
|
|
actInfo = CrossActionControl.GetCrossActInfoByZoneID(ShareDefine.CrossActName_FamilyGCZ, zoneID)
|
if not actInfo:
|
return
|
state = actInfo.get(ShareDefine.ActKey_State)
|
if not state:
|
return
|
curRound, _ = GetRoundState(state)
|
if not curRound:
|
return
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
if onlinePlayerIDDict == None:
|
onlinePlayerIDDict = zone.GetOLServerGroupIDDict()
|
|
if not onlinePlayerIDDict:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCFamilyGCZBatGroupInfo()
|
clientPack.RoundNum = zone.roundNum
|
clientPack.BatList = []
|
for batType, groupNumDict in zone.roundGroupDict.items():
|
batInfo = ChPyNetSendPack.tagGCFamilyGCZBat()
|
batInfo.BatType = batType
|
batInfo.GroupList = []
|
for groupNum in groupNumDict.keys():
|
batGroup = zone.GetBatGroup(batType, groupNum)
|
if not batGroup:
|
continue
|
group = ChPyNetSendPack.tagGCFamilyGCZBatGroup()
|
group.GroupNum = groupNum
|
group.FamilyIDList = batGroup.GetGroupFamilyIDList()
|
group.FamilyIDCnt = len(group.FamilyIDList)
|
batInfo.GroupList.append(group)
|
batInfo.GroupCnt = len(batInfo.GroupList)
|
|
clientPack.BatList.append(batInfo)
|
clientPack.BatTypeCnt = len(clientPack.BatList)
|
NetPackCommon.SendFakePackByCross(onlinePlayerIDDict, clientPack)
|
return
|
|
def Sync_FamilyGCZCampInfo(zoneID, familyID, onlinePlayerIDDict=None, defMemIDList=None):
|
## ͬ²½ÏÉÃË´ó±¾ÓªÐÅÏ¢ - ֻͬ²½Ä³¸öËø¶¨Ã˵ÄËø¶¨³ÉÔ±¼´¿É
|
|
gczMgr = GetFamilyGCZMgr()
|
zone = gczMgr.GetActZone(zoneID)
|
joinFamily = zone.GetZoneJoinFamily(familyID)
|
if not joinFamily:
|
return
|
|
if onlinePlayerIDDict == None:
|
onlinePlayerIDDict = joinFamily.GetOLMemServerGroupIDDict()
|
|
#GameWorld.DebugLog("Sync_FamilyGCZCampInfo zoneID=%s,familyID=%s,%s,defMemIDList=%s" % (zoneID, familyID, onlinePlayerIDDict, defMemIDList))
|
if not onlinePlayerIDDict:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCFamilyGCZCampInfo()
|
clientPack.Clear()
|
clientPack.FamilyID = familyID
|
clientPack.CampLV = joinFamily.campLV
|
clientPack.CampExp = joinFamily.campExp
|
clientPack.CityLV = joinFamily.cityWall.cityLV
|
clientPack.HPBase = joinFamily.cityWall.hpBase % ChConfig.Def_PerPointValue
|
clientPack.HPBaseEx = joinFamily.cityWall.hpBase / ChConfig.Def_PerPointValue
|
clientPack.HPMax = joinFamily.cityWall.hpMax % ChConfig.Def_PerPointValue
|
clientPack.HPMaxEx = joinFamily.cityWall.hpMax / ChConfig.Def_PerPointValue
|
clientPack.HP = joinFamily.cityWall.hp % ChConfig.Def_PerPointValue
|
clientPack.HPEx = joinFamily.cityWall.hp / ChConfig.Def_PerPointValue
|
clientPack.RoundInfoList = []
|
for roundNum, info in joinFamily.roundInfoDict.items():
|
roundObj = ChPyNetSendPack.tagGCFamilyGCZCampRound()
|
roundObj.RoundNum = roundNum
|
roundObj.BatType = info.get("batType", 0)
|
roundObj.GroupNum = info.get("groupNum", 0)
|
roundObj.Rank = info.get("rank", 0)
|
roundObj.Score = info.get("score", 0)
|
roundObj.UpdownState = info.get("updownState", 0)
|
clientPack.RoundInfoList.append(roundObj)
|
clientPack.RoundCnt = len(clientPack.RoundInfoList)
|
clientPack.DefMemList = []
|
for playerID in joinFamily.joinMemberIDList:
|
if defMemIDList != None and playerID not in defMemIDList:
|
continue
|
joinMember = zone.GetZoneJoinMember(playerID)
|
if not joinMember:
|
continue
|
|
defMem = ChPyNetSendPack.tagGCFamilyGCZCampMem()
|
defMem.PlayerID = playerID
|
defMem.Name = joinMember.playerName
|
defMem.FamilyLV = joinMember.fmLV
|
defMem.Job = joinMember.job
|
defMem.Face = joinMember.face
|
defMem.FacePic = joinMember.facePic
|
defMem.FightPower = joinMember.fightPower % ChConfig.Def_PerPointValue
|
defMem.FightPowerEx = joinMember.fightPower / ChConfig.Def_PerPointValue
|
defMem.HP = joinMember.hp % ChConfig.Def_PerPointValue
|
defMem.HPEx = joinMember.hp / ChConfig.Def_PerPointValue
|
defMem.HPMax = joinMember.hpMax % ChConfig.Def_PerPointValue
|
defMem.HPMaxEx = joinMember.hpMax / ChConfig.Def_PerPointValue
|
defMem.TotalHurt = joinMember.totalHurtValue % ChConfig.Def_PerPointValue
|
defMem.TotalHurtEx = joinMember.totalHurtValue / ChConfig.Def_PerPointValue
|
clientPack.DefMemList.append(defMem)
|
|
clientPack.DefMemCnt = len(clientPack.DefMemList)
|
NetPackCommon.SendFakePackByCross(onlinePlayerIDDict, clientPack)
|
return
|
|
## -------------------------------------------------------------------------------------------------
|
def OnPlayerLogin(curPlayer):
|
PlayerControl.DoOfflineUnprocessed(curPlayer, "FamilyGCZAtkResult", __DoOfflineFamilyGCZAtkResult)
|
PlayerControl.DoOfflineUnprocessed(curPlayer, "FamilyGCZAward", __DoOfflineFamilyGCZAward)
|
return
|
|
def ClientServer_CrossActInfo():
|
## ×Ó·þ´¦Àí - »î¶¯×´Ì¬ÐÅÏ¢
|
return
|
|
def MapServer_FamilyGCZ(curPlayer, msgList):
|
mapID = curPlayer.GetRealMapID()
|
playerID = curPlayer.GetPlayerID()
|
GameWorld.DebugLog("MapServer_FamilyGCZ mapID=%s,msgList=%s" % (mapID, msgList), playerID)
|
if not msgList:
|
return
|
|
#msgType, dataMsg = msgList
|
ret = None
|
|
if ret == None:
|
return
|
return msgList + (ret if isinstance(ret, list) else [ret])
|
|
def MapServer_QueryPlayerResult(curPlayer, msgType, dataMsg=[]):
|
ret = 1
|
msgInfo = str([msgType, dataMsg, ret])
|
curPlayer.MapServer_QueryPlayerResult(0, 0, "FamilyGCZ", msgInfo, len(msgInfo))
|
return
|
|
#// C0 26 ÏÉÃ˹¥³ÇÕ½²éѯ #tagCGFamilyGCZQuery
|
#
|
#struct tagCGFamilyGCZQuery
|
#{
|
# tagHead Head;
|
# BYTE QueryType; //²éѯÀàÐÍ£º1-³ÉÔ±¾èÏ×Öµ£»2-½øÈë³Ç³Ø³¡¾°£»3-Í˳ö³Ç³Ø³¡¾°£»4-½øÈë³Ç³Ø£»5-Í˳ö³Ç³Ø£»6-Õ½±¨£»7-·Ö×éÏÉÃ˳ÉÔ±É˺¦£»
|
# BYTE BatType; //Ö¸¶¨Õ½³¡ÀàÐÍ£¬ÐèÒª·¢Ë͵IJéѯÀàÐÍ£º 2¡¢4
|
# BYTE GroupNum; //Ö¸¶¨·Ö×é±àºÅ£¬ÐèÒª·¢Ë͵IJéѯÀàÐÍ£º 2¡¢4
|
# DWORD FamilyID; //Ö¸¶¨ÏÉÃËID»ò³Ç³ØID£¬²é×Ô¼ºÃ˵Ŀɲ»·¢£¬ÐèÒª·¢µÄÀàÐÍ£º2¡¢4¡¢6¡¢7
|
#};
|
def OnFamilyGCZQuery(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
queryType = clientData.QueryType
|
batType = clientData.BatType
|
groupNum = clientData.GroupNum
|
familyID = clientData.FamilyID
|
|
playerID = curPlayer.GetPlayerID()
|
dataMsg = {"ActMsgType":"Query", "playerID":playerID, "queryType":queryType, "batType":batType, "groupNum":groupNum, "familyID":familyID}
|
CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_FamilyGCZ, dataMsg)
|
return
|
return
|
|
def CrossServerMsg_FamilyGCZ(dataMsg):
|
## ÊÕµ½¿ç·þ·þÎñÆ÷ͬ²½µÄ¿ç·þÔËÓª»î¶¯×´Ì¬
|
|
actMsgType = dataMsg["ActMsgType"]
|
if actMsgType == "FamilyGCZPlayerActInfo":
|
__clientServer_FamilyGCZPlayerActInfo(dataMsg)
|
|
elif actMsgType == "FamilyGCZAtkResult":
|
atkRet = dataMsg["atkRet"]
|
playerID = dataMsg["reqMsg"]["playerID"]
|
if not PlayerControl.GetDBPlayerAccIDByID(playerID):
|
return
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not curPlayer:
|
if atkRet != AtkRet_OK:
|
# ²»Êǹ¥»÷³É¹¦µÄ£¬Íæ¼Ò²»ÔÚÏß¿ÉÒÔ²»´¦Àí
|
return
|
PlayerControl.AddOfflineUnprocessed(playerID, "FamilyGCZAtkResult", dataMsg)
|
return
|
MapServer_QueryPlayerResult(curPlayer, "FamilyGCZAtkResult", dataMsg)
|
|
elif actMsgType == "FamilyGCZAward":
|
playerID = dataMsg["playerID"]
|
if not PlayerControl.GetDBPlayerAccIDByID(playerID):
|
return
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not curPlayer:
|
PlayerControl.AddOfflineUnprocessed(playerID, "FamilyGCZAward", dataMsg)
|
return
|
MapServer_QueryPlayerResult(curPlayer, "FamilyGCZAward", dataMsg)
|
|
return
|
|
def __DoOfflineFamilyGCZAtkResult(curPlayer, recData, eventName, eventData):
|
## Ö´ÐÐÀëÏßδ´¦ÀíµÄÕ½¶·½á¹û
|
MapServer_QueryPlayerResult(curPlayer, "FamilyGCZAtkResult", eventData)
|
return
|
|
def __DoOfflineFamilyGCZAward(curPlayer, recData, eventName, eventData):
|
## Ö´ÐÐÀëÏßδ´¦ÀíµÄ
|
MapServer_QueryPlayerResult(curPlayer, "FamilyGCZAward", eventData)
|
return
|
|
def __clientServer_FamilyGCZPlayerActInfo(dataMsg):
|
playerActInfo = dataMsg["playerActInfo"]
|
|
playerManager = GameWorld.GetPlayerManager()
|
for playerID, pActInfo in playerActInfo.items():
|
if not PlayerControl.GetDBPlayerAccIDByID(playerID):
|
# ·Ç±¾·þÍæ¼Ò
|
return
|
curPlayer = playerManager.FindPlayerByID(playerID)
|
if curPlayer:
|
MapServer_QueryPlayerResult(curPlayer, "FamilyGCZPlayerActInfo", pActInfo)
|
|
return
|
