#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package PlayerFuncTeam
|
#
|
# @todo:¹¦ÄܶÓÎé±í
|
# @author hxp
|
# @date 2024-08-02
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: ¹¦ÄܶÓÎé±í£¬Ö§³Ö¿ç·þ
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2024-08-02 16:30"""
|
#-------------------------------------------------------------------------------
|
|
import CommFunc
|
import GameWorld
|
import ShareDefine
|
import IpyGameDataPY
|
import PyDataManager
|
import PyGameDataStruct
|
import CrossBattlefield
|
import CrossRealmPlayer
|
import PlayerViewCache
|
import ChPyNetSendPack
|
import CrossRealmMsg
|
import PlayerControl
|
import NetPackCommon
|
import DirtyList
|
import ChConfig
|
|
import time
|
|
# ¶ÓÎé²Ù×÷
|
Def_FuncTeamOPList = (
|
Def_FuncTeamOP_JoinApply, # ÉêÇë¼ÓÈë 1
|
Def_FuncTeamOP_JoinCancel, # ÉêÇëÈ¡Ïû 2
|
Def_FuncTeamOP_JoinAgree, # ͬÒâÈë¶Ó 3
|
Def_FuncTeamOP_JoinRefuse, # ¾Ü¾øÈë¶Ó 4
|
Def_FuncTeamOP_Exit, # Í˳ö¶ÓÎé 5
|
Def_FuncTeamOP_Kick, # Ìß³ö¶ÓÎé 6
|
Def_FuncTeamOP_Transfer, # תÈöӳ¤ 7
|
Def_FuncTeamOP_Dissolve, # ½âÉ¢¶ÓÎé 8
|
) = range(1, 1 + 8)
|
|
class PyFuncTeamMem():
|
|
def __init__(self, dbMemData=None):
|
self.dbMemData = dbMemData
|
return
|
def GetTeamID(self): return self.dbMemData.TeamID
|
def GetPlayerID(self): return self.dbMemData.PlayerID
|
def GetValue1(self): return self.dbMemData.Value1
|
def SetValue1(self, value1): self.dbMemData.Value1 = value1
|
def GetValue2(self): return self.dbMemData.Value2
|
def SetValue2(self, value2): self.dbMemData.Value2 = value2
|
def GetValue3(self): return self.dbMemData.Value3
|
def SetValue3(self, value3): self.dbMemData.Value3 = value3
|
def GetValue4(self): return self.dbMemData.Value4
|
def SetValue4(self, value4): self.dbMemData.Value4 = value4
|
def GetValue5(self): return self.dbMemData.Value5
|
def SetValue5(self, value5): self.dbMemData.Value5 = value5
|
|
def GetFightPower(self):
|
cacheDict = PlayerViewCache.GetCachePropDataDict(PlayerViewCache.FindViewCache(self.GetPlayerID()))
|
return cacheDict.get("FightPower", 0)
|
|
def GetSyncDict(self):
|
# Value ÔÝʱֻͬ²½1~2
|
syncDict = {"PlayerID":self.GetPlayerID(), "Value1":self.GetValue1(), "Value2":self.GetValue2()}
|
syncDict.update(PlayerViewCache.GetShotCacheDict(self.GetPlayerID(), "PlayerID", "FightPower", "ServerID", "OfflineValue", "Face", "FacePic"))
|
return syncDict
|
|
class PyFuncTeam():
|
|
def __init__(self, dbTeamData=None):
|
self.dbTeamData = dbTeamData
|
self.memberList = []
|
self.applyIDList = []
|
try:
|
self.applyIDList = eval(self.dbTeamData.ApplyIDList)
|
except:
|
self.applyIDList = []
|
return
|
|
def getBuffer(self):
|
self.dbTeamData.ApplyIDList = str(self.applyIDList).replace(" ", "")
|
self.dbTeamData.ApplyIDLen = len(self.dbTeamData.ApplyIDList)
|
return self.dbTeamData.getBuffer()
|
|
def GetTeamID(self): return self.dbTeamData.TeamID
|
def GetTeamName(self): return self.dbTeamData.TeamName
|
def GetZoneID(self): return self.dbTeamData.ZoneID
|
def GetFuncMapID(self): return self.dbTeamData.FuncMapID
|
def GetFuncMapEx(self): return self.dbTeamData.FuncMapEx
|
def GetCreateTime(self): return self.dbTeamData.CreateTime
|
def GetCaptainID(self): return self.dbTeamData.CaptainID
|
def SetCaptainID(self, captainID): self.dbTeamData.CaptainID = captainID
|
def GetMinLV(self): return self.dbTeamData.MinLV
|
def SetMinLV(self, minLV): self.dbTeamData.MinLV = minLV
|
def GetMinFightPower(self):
|
return self.dbTeamData.MinFightPower + self.dbTeamData.MinFightPowerEx * ChConfig.Def_PerPointValue
|
def SetMinFightPower(self, minFightPower):
|
self.dbTeamData.MinFightPower = minFightPower % ChConfig.Def_PerPointValue
|
self.dbTeamData.MinFightPowerEx = minFightPower / ChConfig.Def_PerPointValue
|
return
|
def GetServerOnly(self): return self.dbTeamData.ServerOnly
|
def SetServerOnly(self, serverOnly): self.dbTeamData.ServerOnly = serverOnly
|
def GetNeedCheck(self): return self.dbTeamData.NeedCheck
|
def SetNeedCheck(self, needCheck): self.dbTeamData.NeedCheck = needCheck
|
def GetValue1(self): return self.dbTeamData.Value1
|
def SetValue1(self, value1): self.dbTeamData.Value1 = value1
|
def GetValue2(self): return self.dbTeamData.Value2
|
def SetValue2(self, value2): self.dbTeamData.Value2 = value2
|
def GetValue3(self): return self.dbTeamData.Value3
|
def SetValue3(self, value3): self.dbTeamData.Value3 = value3
|
def GetValue4(self): return self.dbTeamData.Value4
|
def SetValue4(self, value4): self.dbTeamData.Value4 = value4
|
def GetValue5(self): return self.dbTeamData.Value5
|
def SetValue5(self, value5): self.dbTeamData.Value5 = value5
|
|
def GetSyncDict(self, applyDetail=False):
|
MemberList = [mem.GetSyncDict() for mem in self.memberList]
|
ApplyIDList = self.applyIDList
|
ApplyList = []
|
if applyDetail:
|
for applyID in ApplyIDList[::-1]:
|
applyPlayerDict = PlayerViewCache.GetShotCacheDict(applyID, "PlayerID", "FightPower", "ServerID", "Face", "FacePic")
|
if not applyPlayerDict:
|
ApplyIDList.remove(applyID)
|
else:
|
ApplyList.insert(0, applyPlayerDict)
|
# Value ÔÝʱֻͬ²½1~2
|
syncDict = {"TeamID":self.GetTeamID(), "TeamName":self.GetTeamName(), "ZoneID":self.GetZoneID(), "FuncMapID":self.GetFuncMapID(), "FuncMapEx":self.GetFuncMapEx(),
|
"CreateTime":self.GetCreateTime(), "CaptainID":self.GetCaptainID(), "MinLV":self.GetMinLV(), "MinFightPower":self.GetMinFightPower(),
|
"ServerOnly":self.GetServerOnly(), "NeedCheck":self.GetNeedCheck(), "MemberList":MemberList, "ApplyIDList":ApplyIDList, "ApplyList":ApplyList,
|
"Value1":self.GetValue1(), "Value2":self.GetValue2()}
|
return syncDict
|
|
def GetSyncPlayerIDList(self):
|
## »ñÈ¡¶ÓÎéÐÅÏ¢ÐèҪͬ²½µÄÍæ¼ÒIDÁÐ±í ¶ÓÔ± + ÉêÇëÍæ¼Ò
|
syncPlayerIDList = []
|
syncPlayerIDList += self.GetMemberIDList()
|
syncPlayerIDList += self.GetApplyIDList()
|
return syncPlayerIDList
|
|
def AddTeamMember(self, playerID):
|
teamMem = None
|
self.DelApplyID(playerID) # ¼ÓÈëµÄͬʱ´ÓÉêÇëÁбíÖÐÒƳý
|
mem = self.GetMemberByID(playerID)
|
if mem:
|
teamMem = mem
|
return teamMem
|
dbTeamMemData = PyGameDataStruct.tagDBPyFuncTeamMem()
|
dbTeamMemData.clear()
|
dbTeamMemData.TeamID = self.GetTeamID()
|
dbTeamMemData.PlayerID = playerID
|
teamMem = PyFuncTeamMem(dbTeamMemData)
|
self.AddTeamMemToList(teamMem)
|
return teamMem
|
|
def AddTeamMemToList(self, teamMem):
|
if teamMem not in self.memberList:
|
self.memberList.append(teamMem)
|
|
zoneID = self.GetZoneID()
|
teamID = self.GetTeamID()
|
funcMapID = self.GetFuncMapID()
|
teamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
teamMgr.OnTeamMemTeamIDChange(zoneID, funcMapID, teamID, teamMem.GetPlayerID(), teamID)
|
return
|
|
def GetMemberList(self): return self.memberList
|
def GetMemberIDList(self): return [mem.GetPlayerID() for mem in self.memberList]
|
def GetMemberByID(self, playerID):
|
for mem in self.memberList:
|
if mem.GetPlayerID() == playerID:
|
return mem
|
return
|
|
def GetMemFightPowerTotal(self):
|
## ¶ÓÔ±×ÜÕ½Á¦
|
totalFightPower = 0
|
for mem in self.memberList:
|
totalFightPower += mem.GetFightPower()
|
return totalFightPower
|
|
def DelTeamMember(self, playerID):
|
for mem in self.memberList[::-1]:
|
if mem.GetPlayerID() == playerID:
|
self.memberList.remove(mem)
|
|
zoneID = self.GetZoneID()
|
teamID = self.GetTeamID()
|
funcMapID = self.GetFuncMapID()
|
teamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
teamMgr.OnTeamMemTeamIDChange(zoneID, funcMapID, teamID, playerID, 0)
|
break
|
return
|
|
def OnDel(self):
|
self.memberList = []
|
self.applyIDList = []
|
return
|
|
def GetApplyIDList(self): return self.applyIDList
|
|
def AddApplyID(self, playerID):
|
if playerID not in self.applyIDList:
|
self.applyIDList.append(playerID)
|
return
|
|
def DelApplyID(self, playerID):
|
if playerID in self.applyIDList:
|
self.applyIDList.remove(playerID)
|
return
|
|
def DelApplyIDAll(self):
|
self.applyIDList = []
|
return
|
|
class DBPyFuncTeamMemManager():
|
## ¹¦ÄܶÓÎé³ÉÔ±¹ÜÀí
|
|
def __init__(self):
|
return
|
|
# ±£´æÊý¾Ý ´æÊý¾Ý¿âºÍrealtimebackup
|
def GetSaveData(self):
|
savaData = ""
|
cntData = ""
|
cnt = 0
|
|
teamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
for teamList in teamMgr.funcTeamListDict.values():
|
for funcTeam in teamList:
|
for mem in funcTeam.GetMemberList():
|
cnt += 1
|
savaData += mem.dbMemData.getBuffer()
|
|
GameWorld.Log("Save DBPyFuncTeamMem count :%s len=%s" % (cnt, len(savaData)))
|
return CommFunc.WriteDWORD(cntData, cnt) + savaData
|
|
# ´ÓÊý¾Ý¿âÔØÈëÊý¾Ý
|
def LoadPyGameData(self, datas, pos, dataslen):
|
cnt, pos = CommFunc.ReadDWORD(datas, pos)
|
GameWorld.Log("Load DBPyFuncTeamMem count :%s" % cnt)
|
|
teamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
for _ in xrange(cnt):
|
memData = PyGameDataStruct.tagDBPyFuncTeamMem()
|
memData.clear()
|
pos += memData.readData(datas, pos, dataslen)
|
|
teamID = memData.TeamID
|
funcTeam = teamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
continue
|
funcTeam.AddTeamMemToList(PyFuncTeamMem(memData))
|
|
return pos
|
|
class DBPyFuncTeamManager():
|
## ¹¦ÄܶÓÎé¹ÜÀí
|
|
def __init__(self):
|
self.Clear()
|
self.teamIDMax = 99999
|
return
|
|
def Clear(self):
|
self.funcTeamDict = {} # {teamID:PyFuncTeam, ...}
|
self.playerFuncTeamIDDict = {} # {playerID:{funcMapID:teamID, ...}, ...}
|
self.funcTeamListDict = {} # {(zoneID, funcMapID):[PyFuncTeam, ...], ...}
|
self.loopTeamID = 0 # µÝÔö£¬Ö±µ½³¬¹ýÉÏÏÞºó£¬ÔÙ´ÓÍ·¿ªÊ¼
|
self.__loadOK = False # ¶ÓÎé·Ö¶àÕűí¼ÓÔØ£¬¶ÓÎé±í¡¢³ÉÔ±±íµÈ£¬ÓÉ×îºóÒ»Õűí¼ÓÔØÍê±ÏºóÉèÖÃΪTrue
|
self.__lockBatch = False # Ëø¶¨ÅÅÐò£¬¼´ÔÝʱ²»ÅÅÐò£¬ÓÉÇ¿ÖÆÅÅÐòºó½âËø
|
return
|
|
def __GetNewTeamID(self):
|
## »ñȡжÓÎéID
|
idMin, idMax = 100, 9999 # ·Ç¿ç·þ¶ÓÎéID·¶Î§£¬´æ´¢±¾·þ£¬ºÏ·þÇå¿Õ
|
if GameWorld.IsCrossServer():
|
idMin, idMax = 10000, self.teamIDMax # ¿ç·þ¶ÓÎéID·¶Î§£¬´æ´¢¿ç·þ£¬ºÏ·þ²»Ó°Ïì
|
|
teamMax = idMax - idMin + 1
|
if len(self.funcTeamDict) >= teamMax:
|
GameWorld.ErrLog("¹¦ÄܶÓÎéIDÒÑÂú!")
|
return
|
|
if not self.loopTeamID and self.funcTeamDict:
|
self.loopTeamID = max(self.funcTeamDict)
|
|
newTeamID = 0
|
doCount = 0
|
while doCount < teamMax:
|
doCount += 1
|
if not self.loopTeamID or self.loopTeamID >= idMax or self.loopTeamID < idMin:
|
self.loopTeamID = idMin - 1
|
self.loopTeamID += 1
|
if self.loopTeamID not in self.funcTeamDict:
|
newTeamID = self.loopTeamID
|
break
|
return newTeamID
|
|
def CreateFuncTeam(self, playerID, teamInfo, zoneID=0):
|
funcTeam = None
|
teamID = self.__GetNewTeamID()
|
if not teamID:
|
return funcTeam
|
|
funcMapID = teamInfo["funcMapID"]
|
funcMapEx = teamInfo["funcMapEx"]
|
dbTeamData = PyGameDataStruct.tagDBPyFuncTeam()
|
dbTeamData.clear()
|
dbTeamData.TeamID = teamID
|
dbTeamData.TeamName = teamInfo["teamName"]
|
dbTeamData.ZoneID = zoneID
|
dbTeamData.FuncMapID = funcMapID
|
dbTeamData.FuncMapEx = funcMapEx
|
dbTeamData.CreateTime = int(time.time())
|
dbTeamData.CaptainID = playerID
|
dbTeamData.MinLV = teamInfo["minLV"]
|
dbTeamData.MinFightPower = teamInfo["minFightPower"]
|
dbTeamData.MinFightPowerEx = teamInfo["minFightPowerEx"]
|
dbTeamData.ServerOnly = teamInfo["serverOnly"]
|
dbTeamData.NeedCheck = teamInfo["needCheck"]
|
dbTeamData.Value1 = teamInfo.get("Value1", 0)
|
dbTeamData.Value2 = teamInfo.get("Value2", 0)
|
dbTeamData.Value3 = teamInfo.get("Value3", 0)
|
dbTeamData.Value4 = teamInfo.get("Value4", 0)
|
dbTeamData.Value5 = teamInfo.get("Value5", 0)
|
|
funcTeam = PyFuncTeam(dbTeamData)
|
self.__AddFuncTeam(funcTeam)
|
funcTeam.AddTeamMember(playerID)
|
return funcTeam
|
|
def __AddFuncTeam(self, funcTeam):
|
teamID = funcTeam.GetTeamID()
|
zoneID = funcTeam.GetZoneID()
|
funcMapID = funcTeam.GetFuncMapID()
|
#funcMapEx = teafuncTeammData.GetFuncMapEx()
|
|
key = (zoneID, funcMapID)
|
if key not in self.funcTeamListDict:
|
self.funcTeamListDict[key] = []
|
funcTeamList = self.funcTeamListDict[key]
|
if funcTeam not in funcTeamList:
|
funcTeamList.append(funcTeam)
|
|
self.funcTeamDict[teamID] = funcTeam
|
self.SortTeam(zoneID, funcMapID, "create")
|
return
|
|
def SortTeam(self, zoneID, funcMapID, sortReason=""):
|
if not self.__loadOK:
|
#GameWorld.DebugLog("¶ÓÎéδ¼ÓÔØÍê±Ï£¬²»ÅÅÐò")
|
return
|
if self.__lockBatch:
|
#GameWorld.DebugLog("¶ÓÎéÅÅÐòËø¶¨ÖÐ")
|
return
|
|
teamList = self.GetFuncTeamList(zoneID, funcMapID)
|
if not teamList:
|
return
|
ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)
|
if not ipyData:
|
return
|
sortType = ipyData.GetSortType()
|
sortReverse = ipyData.GetSortReverse()
|
# °´´´½¨Ê±¼ä
|
if sortType == 0:
|
if not sortReason or sortReason == "create":
|
teamList.sort(key=lambda t: (t.GetCreateTime()), reverse=sortReverse)
|
#GameWorld.DebugLog("°´Ê±¼äÅÅÐò: zoneID=%s,funcMapID=%s,sortReason=%s" % (zoneID, funcMapID, sortReason))
|
# °´¶ÓÔ±×ÜÕ½Á¦
|
elif sortType == 1:
|
if not sortReason or sortReason == "member":
|
teamList.sort(key=lambda t: (t.GetMemFightPowerTotal()), reverse=sortReverse)
|
#GameWorld.DebugLog("°´Õ½Á¦ÅÅÐò: zoneID=%s,funcMapID=%s,sortReason=%s" % (zoneID, funcMapID, sortReason))
|
return
|
|
def SyncMapFuncTeamMemIDInfo(self, teamIDList=None):
|
## ͬ²½µØͼ¶ÓÎé³ÉÔ±ÐÅÏ¢
|
if not self.__loadOK:
|
return
|
|
if self.__lockBatch:
|
return
|
|
teamMemIDInfoDict = {}
|
delTeamIDList = []
|
if not teamIDList:
|
for teamList in self.funcTeamListDict.values():
|
for funcTeam in teamList:
|
self.__updSyncMapInfo(funcTeam, teamMemIDInfoDict)
|
else:
|
for teamID in teamIDList:
|
funcTeam = self.GetFuncTeam(teamID)
|
if not funcTeam:
|
delTeamIDList.append(teamID)
|
continue
|
self.__updSyncMapInfo(funcTeam, teamMemIDInfoDict)
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_FuncTeamMemIDInfo, [teamIDList, delTeamIDList, teamMemIDInfoDict])
|
return
|
|
def __updSyncMapInfo(self, funcTeam, teamMemIDInfoDict):
|
if not funcTeam:
|
return
|
zoneID = funcTeam.GetZoneID()
|
teamID = funcTeam.GetTeamID()
|
funcMapID = funcTeam.GetFuncMapID()
|
key = (zoneID, funcMapID)
|
if key not in teamMemIDInfoDict:
|
teamMemIDInfoDict[key] = {}
|
infoDict = teamMemIDInfoDict[key]
|
infoDict[teamID] = funcTeam.GetMemberIDList()
|
return
|
|
def LockBatch(self): self.__lockBatch = True
|
def UnLockBatch(self): self.__lockBatch = False
|
def IsLockBatch(self): return self.__lockBatch
|
|
def GetFuncTeam(self, teamID):
|
funcTeam = None
|
if teamID in self.funcTeamDict:
|
funcTeam = self.funcTeamDict[teamID]
|
if not funcTeam and False:
|
# ²»»áÖ´ÐУ¬½öΪÁË.Ìáʾ´úÂëÓÃ
|
funcTeam = PyFuncTeam()
|
return funcTeam
|
|
def GetFuncTeamList(self, zoneID, funcMapID):
|
key = (zoneID, funcMapID)
|
if key not in self.funcTeamListDict:
|
return []
|
return self.funcTeamListDict[key]
|
|
def DelTeam(self, teamID):
|
## ɾ³ý¶ÓÎé
|
funcTeam = self.GetFuncTeam(teamID)
|
if not funcTeam:
|
return
|
|
zoneID = funcTeam.GetZoneID()
|
funcMapID = funcTeam.GetFuncMapID()
|
for mem in funcTeam.GetMemberList():
|
self.__UpdPlayerTeamID(mem.GetPlayerID(), funcMapID, 0)
|
funcTeam.OnDel()
|
self.SyncMapFuncTeamMemIDInfo([teamID])
|
|
# ÒƳýʵÀý
|
key = (zoneID, funcMapID)
|
if key in self.funcTeamListDict:
|
funcTeamList = self.funcTeamListDict[key]
|
if funcTeam in funcTeamList:
|
funcTeamList.remove(funcTeam)
|
|
self.funcTeamDict.pop(teamID, None)
|
return
|
|
def OnTeamMemTeamIDChange(self, zoneID, funcMapID, teamID, playerID, updTeamID):
|
self.__UpdPlayerTeamID(playerID, funcMapID, updTeamID)
|
self.SyncMapFuncTeamMemIDInfo([teamID])
|
self.SortTeam(zoneID, funcMapID, "member")
|
return
|
|
def __UpdPlayerTeamID(self, playerID, funcMapID, teamID):
|
if playerID not in self.playerFuncTeamIDDict:
|
self.playerFuncTeamIDDict[playerID] = {}
|
teamIDDict = self.playerFuncTeamIDDict[playerID]
|
if not teamID:
|
teamIDDict.pop(funcMapID, 0)
|
if not teamIDDict:
|
self.playerFuncTeamIDDict.pop(playerID, None)
|
else:
|
teamIDDict[funcMapID] = teamID
|
return
|
|
def GetPlayerTeamID(self, playerID, funcMapID):
|
if playerID not in self.playerFuncTeamIDDict:
|
return 0
|
teamIDDict = self.playerFuncTeamIDDict[playerID]
|
return teamIDDict.get(funcMapID, 0)
|
def GetPlayerTeamIDDict(self, playerID): return self.playerFuncTeamIDDict.get(playerID, {})
|
|
def IsTeamPlayer(self, playerID):
|
if playerID in self.playerFuncTeamIDDict:
|
return True
|
for teamList in self.funcTeamListDict.values():
|
for funcTeam in teamList:
|
if playerID in funcTeam.GetApplyIDList():
|
return True
|
return False
|
|
# ±£´æÊý¾Ý ´æÊý¾Ý¿âºÍrealtimebackup
|
def GetSaveData(self):
|
savaData = ""
|
cntData = ""
|
cnt = 0
|
|
for teamList in self.funcTeamListDict.values():
|
for funcTeam in teamList: # °´ÅźõĶÓÎé˳Ðò±£´æ
|
cnt += 1
|
savaData += funcTeam.getBuffer()
|
|
GameWorld.Log("Save DBPyFuncTeam count :%s len=%s" % (cnt, len(savaData)))
|
return CommFunc.WriteDWORD(cntData, cnt) + savaData
|
|
# ´ÓÊý¾Ý¿âÔØÈëÊý¾Ý
|
def LoadPyGameData(self, datas, pos, dataslen):
|
cnt, pos = CommFunc.ReadDWORD(datas, pos)
|
GameWorld.Log("Load DBPyFuncTeam count :%s" % cnt)
|
|
self.Clear()
|
|
for _ in xrange(cnt):
|
dbTeamData = PyGameDataStruct.tagDBPyFuncTeam()
|
dbTeamData.clear()
|
pos += dbTeamData.readData(datas, pos, dataslen)
|
|
self.__AddFuncTeam(PyFuncTeam(dbTeamData))
|
|
return pos
|
|
def OnTeamLoadOK(self):
|
GameWorld.DebugLog("¹¦ÄܶÓÎé¼ÓÔØÍê±Ï")
|
self.__loadOK = True
|
for key in self.funcTeamListDict.keys():
|
zoneID, funcMapID = key
|
self.SortTeam(zoneID, funcMapID)
|
return
|
|
def OnGameServerInitOK():
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeamMgr.OnTeamLoadOK()
|
return
|
|
def OnMapServerInitOK():
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeamMgr.SyncMapFuncTeamMemIDInfo()
|
return
|
|
def IsOPLimitInAct(curPlayer, funcMapID):
|
## »î¶¯ÆÚ¼äÊÇ·ñÏÞÖƶÓÎé²Ù×÷
|
ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)
|
if not ipyData:
|
return
|
if not ipyData.GetOPLimitInAct():
|
return
|
isInAct = False
|
if funcMapID == ChConfig.Def_FBMapID_CrossBattlefield:
|
isInAct = CrossBattlefield.GetCrossBattlefieldState()
|
if isInAct:
|
GameWorld.ErrLog("»î¶¯ÆÚ¼äÎÞ·¨²Ù×÷¶ÓÎé! funcMapID=%s" % funcMapID, curPlayer.GetPlayerID())
|
return isInAct
|
|
def GetFuncTeamZoneID(funcMapID):
|
zoneID = 0
|
if funcMapID == ChConfig.Def_FBMapID_CrossBattlefield:
|
zoneID = CrossBattlefield.GetCrossBattlefieldZoneID(GameWorld.GetServerGroupID())
|
return zoneID
|
|
#// B9 20 ´´½¨¹¦ÄܶÓÎé #tagCGCreateFuncTeam
|
#
|
#struct tagCGCreateFuncTeam
|
#{
|
# tagHead Head;
|
# DWORD FuncMapID; // ¹¦ÄܵØͼID»ò×Ô¶¨ÒåµÄ»î¶¯¹¦ÄÜID
|
# DWORD FuncMapEx; // ¹¦ÄܵØͼÀ©Õ¹£¬È粻ͬµÄ²ã¼¶
|
# BYTE NameLen;
|
# char TeamName[NameLen]; // ¶ÓÎéÃû³Æ£¬¿ÉΪ¿Õ
|
# WORD MinLV; //×îµÍµÈ¼¶ÏÞÖÆ
|
# DWORD MinFightPower; //×îµÍÕ½Á¦ÏÞÖÆ£¬ÇóÓàÒÚ
|
# DWORD MinFightPowerEx; //×îµÍÕ½Á¦ÏÞÖÆ£¬Õû³ýÒÚ
|
# BYTE ServerOnly; //ÊÇ·ñ½ö±¾·þÍæ¼Ò¿É¼ÓÈ룬0-·ñ£¬1-ÊÇ
|
# BYTE NeedCheck; //ÊÇ·ñÐèÒªÉóºË
|
#};
|
def OnCreateFuncTeam(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
funcMapID = clientData.FuncMapID
|
funcMapEx = clientData.FuncMapEx
|
teamName = clientData.TeamName
|
minLV = clientData.MinLV
|
minFightPower = clientData.MinFightPower
|
minFightPowerEx = clientData.MinFightPowerEx
|
serverOnly = clientData.ServerOnly
|
needCheck = clientData.NeedCheck
|
|
if IsOPLimitInAct(curPlayer, funcMapID):
|
return
|
|
zoneID = GetFuncTeamZoneID(funcMapID)
|
if not zoneID:
|
return
|
|
teamInfo = {"funcMapID":funcMapID, "funcMapEx":funcMapEx, "teamName":teamName, "minLV":minLV,
|
"minFightPower":minFightPower, "minFightPowerEx":minFightPowerEx,
|
"serverOnly":serverOnly, "needCheck":needCheck}
|
dataMsg = {"zoneID":zoneID, "playerID":playerID, "teamInfo":teamInfo, "cacheBase":PlayerViewCache.GetSyncCrossCacheBase(curPlayer)}
|
CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_CreateFuncTeam, dataMsg)
|
return
|
|
#// B9 21 Ð޸ŦÄܶÓÎé #tagCGChangeFuncTeam
|
#
|
#struct tagCGChangeFuncTeam
|
#{
|
# tagHead Head;
|
# DWORD TeamID;
|
# DWORD FuncMapID; // ¹¦ÄܵØͼID»ò×Ô¶¨ÒåµÄ»î¶¯¹¦ÄÜID
|
# WORD MinLV; //×îµÍµÈ¼¶ÏÞÖÆ
|
# DWORD MinFightPower; //×îµÍÕ½Á¦ÏÞÖÆ£¬ÇóÓàÒÚ
|
# DWORD MinFightPowerEx; //×îµÍÕ½Á¦ÏÞÖÆ£¬Õû³ýÒÚ
|
# BYTE ServerOnly; //ÊÇ·ñ½ö±¾·þÍæ¼Ò¿É¼ÓÈ룬0-·ñ£¬1-ÊÇ
|
# BYTE NeedCheck; //ÊÇ·ñÐèÒªÉóºË
|
#};
|
def OnChangeFuncTeam(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
teamID = clientData.TeamID
|
funcMapID = clientData.FuncMapID
|
minLV = clientData.MinLV
|
minFightPower = clientData.MinFightPower
|
minFightPowerEx = clientData.MinFightPowerEx
|
serverOnly = clientData.ServerOnly
|
needCheck = clientData.NeedCheck
|
|
if IsOPLimitInAct(curPlayer, funcMapID):
|
return
|
|
zoneID = GetFuncTeamZoneID(funcMapID)
|
if not zoneID:
|
return
|
|
teamInfo = {"teamID":teamID, "funcMapID":funcMapID, "minLV":minLV,
|
"minFightPower":minFightPower, "minFightPowerEx":minFightPowerEx,
|
"serverOnly":serverOnly, "needCheck":needCheck}
|
dataMsg = {"zoneID":zoneID, "playerID":playerID, "teamInfo":teamInfo, "cacheBase":PlayerViewCache.GetSyncCrossCacheBase(curPlayer)}
|
CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_ChangeFuncTeam, dataMsg)
|
return
|
|
#// B9 22 ¹¦ÄܶÓÎé³ÉÔ±²Ù×÷ #tagCGFuncTeamMemOP
|
#
|
#struct tagCGFuncTeamMemOP
|
#{
|
# tagHead Head;
|
# DWORD TeamID;
|
# DWORD FuncMapID; // ¹¦ÄܵØͼID»ò×Ô¶¨ÒåµÄ»î¶¯¹¦ÄÜID
|
# BYTE OPType; // 1-ÉêÇë¼ÓÈ룻2-ÉêÇëÈ¡Ïû£»3-ͬÒâÈë¶Ó£»4-¾Ü¾øÈë¶Ó£»5-Í˳ö¶ÓÎ飻6-Ìß³ö¶ÓÎ飻7-תÈöӳ¤£»8-½âÉ¢¶ÓÎ飻
|
# DWORD OPData; // ¿ÉÑ¡
|
#};
|
def OnFuncTeamMemOP(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
teamID = clientData.TeamID
|
funcMapID = clientData.FuncMapID
|
opType = clientData.OPType
|
opData = clientData.OPData
|
|
if opType not in Def_FuncTeamOPList:
|
return
|
|
if IsOPLimitInAct(curPlayer, funcMapID):
|
return
|
|
zoneID = GetFuncTeamZoneID(funcMapID)
|
if not zoneID:
|
return
|
|
dataMsg = {"zoneID":zoneID, "playerID":playerID, "teamID":teamID, "funcMapID":funcMapID,
|
"opType":opType, "opData":opData}
|
dataMsg["cacheBase"] = PlayerViewCache.GetSyncCrossCacheBase(curPlayer)
|
CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_FuncTeamMemOP, dataMsg)
|
return
|
|
#// B9 23 ²éÕÒ¹¦ÄܶÓÎéÁбí #tagCGQueryFuncTeam
|
#
|
#struct tagCGQueryFuncTeam
|
#{
|
# tagHead Head;
|
# DWORD FuncMapID; // ¹¦ÄܵØͼID»ò×Ô¶¨ÒåµÄ»î¶¯¹¦ÄÜID
|
# DWORD FuncMapEx; // ¹¦ÄܵØͼÀ©Õ¹£¬È粻ͬµÄ²ã¼¶£¬0´ú±íËùÓÐ
|
# DWORD StartIndex; // ²é¿´µÄÆðʼË÷Òý£¬ ĬÈÏ0
|
# BYTE QueryCnt; // ²é¿´ÌõÊý£¬Ä¬ÈÏ20£¬×î´ó²»³¬¹ý100
|
# BYTE HaveSpace; // ÊÇ·ñÖ»²é¿´ÓпÕλÖõĶÓÎé
|
# BYTE IDLimitType; // IDÏÞÖÆÀàÐÍ£º1-ͬÏÉÃ˶ӳ¤£»2-ͬServerGroupID¶Ó³¤£»3-ͬServerID¶Ó³¤
|
# BYTE SearchLen;
|
# char SearchMsg[SearchLen]; // Ö¸¶¨ËÑË÷ʱÓÐÓ㬿ÉËÑË÷Ö¸¶¨¶ÓÎéID»òÄ£ºýËÑË÷¶ÓÎéÃû³Æ£¬ËÑË÷ʱ·µ»Ø×î¶àQueryCnt¸öÊýµÄ¶ÓÎé
|
#};
|
def OnQueryFuncTeam(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
funcMapID = clientData.FuncMapID
|
funcMapEx = clientData.FuncMapEx
|
startIndex = clientData.StartIndex
|
queryCnt = clientData.QueryCnt
|
haveSpace = clientData.HaveSpace
|
idLimitType = clientData.IDLimitType
|
searchMsg = clientData.SearchMsg
|
|
zoneID = GetFuncTeamZoneID(funcMapID)
|
if not zoneID:
|
return
|
|
dataMsg = {"zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID, "funcMapEx":funcMapEx,
|
"startIndex":startIndex, "queryCnt":queryCnt, "haveSpace":haveSpace, "idLimitType":idLimitType,
|
"searchMsg":searchMsg}
|
dataMsg["cacheBase"] = PlayerViewCache.GetSyncCrossCacheBase(curPlayer)
|
CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_QueryFuncTeam, dataMsg)
|
return
|
|
#// B9 24 ²éÕÒÍæ¼Ò¹¦ÄܶÓÎé #tagCGQueryPlayerFuncTeam
|
#
|
#struct tagCGQueryPlayerFuncTeam
|
#{
|
# tagHead Head;
|
# DWORD FuncMapID; // ¹¦ÄܵØͼID»ò×Ô¶¨ÒåµÄ»î¶¯¹¦ÄÜID
|
#};
|
def OnQueryPlayerFuncTeam(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
funcMapID = clientData.FuncMapID
|
|
zoneID = GetFuncTeamZoneID(funcMapID)
|
if not zoneID:
|
return
|
|
dataMsg = {"zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID}
|
dataMsg["cacheBase"] = PlayerViewCache.GetSyncCrossCacheBase(curPlayer)
|
CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_QueryFuncTeam, dataMsg)
|
return
|
|
def CrossServerMsg_FuncTeamInfo(msgData):
|
## ×Ó·þÊÕµ½¿ç·þÐÅÏ¢ - ¶ÓÎéË¢ÐÂÐÅÏ¢
|
infoType = msgData["infoType"]
|
playerID = msgData["playerID"]
|
funcMapID = msgData["funcMapID"]
|
teamInfo = msgData["teamInfo"]
|
teamID = msgData.get("teamID", 0)
|
syncPlayerIDList = msgData.get("syncPlayerIDList", [])
|
notifyMark = msgData.get("notifyMark", "")
|
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if curPlayer:
|
if notifyMark:
|
PlayerControl.NotifyCode(curPlayer, notifyMark)
|
|
if infoType == "QueryPlayerFuncTeam":
|
if curPlayer:
|
if teamInfo:
|
Sync_FuncTeamRefresh(teamInfo, [playerID])
|
else:
|
clientPack = ChPyNetSendPack.tagGCQueryPlayerFuncTeamRet()
|
clientPack.FuncMapID = funcMapID
|
clientPack.TeamID = 0
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
if not teamInfo:
|
# ²Ù×÷ºóûÓжÓÎéÐÅÏ¢ÁË£¬½âÉ¢
|
if infoType == "FuncTeamMemOP":
|
Sync_FuncTeamDissolve(teamID, syncPlayerIDList)
|
return
|
|
Sync_FuncTeamRefresh(teamInfo, syncPlayerIDList)
|
return
|
|
def CrossServerMsg_FuncTeamDel(msgData):
|
## ×Ó·þÊÕµ½¿ç·þÐÅÏ¢ - ¶ÓÎéɾ³ý
|
#"zoneID":zoneID, "funcMapID":funcMapID, "delTeamDict":delTeamDict
|
#zoneID = msgData["zoneID"]
|
#funcMapID = msgData["funcMapID"]
|
delTeamDict = msgData["delTeamDict"]
|
for teamID, syncPlayerIDList in delTeamDict.items():
|
Sync_FuncTeamDissolve(teamID, syncPlayerIDList)
|
return
|
|
def CrossServerMsg_FuncTeamList(msgData):
|
## ×Ó·þÊÕµ½¿ç·þÐÅÏ¢ - ¶ÓÎéÁбí
|
queryInfo = msgData["queryInfo"]
|
loopIndex = msgData["loopIndex"]
|
teamInfoList = msgData["teamInfoList"]
|
|
playerID = queryInfo["playerID"]
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not curPlayer:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCFuncTeamList()
|
clientPack.FuncMapID = queryInfo["funcMapID"]
|
clientPack.FuncMapEx = queryInfo["funcMapEx"]
|
clientPack.StartIndex = queryInfo["startIndex"]
|
clientPack.QueryCnt = queryInfo["queryCnt"]
|
clientPack.HaveSpace = queryInfo["haveSpace"]
|
clientPack.IDLimitType = queryInfo["idLimitType"]
|
clientPack.SearchMsg = queryInfo["searchMsg"]
|
clientPack.SearchLen = len(clientPack.SearchMsg)
|
clientPack.LoopIndex = loopIndex
|
|
for teamInfo in teamInfoList:
|
team = ChPyNetSendPack.tagGCFuncTeam()
|
team.TeamID = teamInfo["TeamID"]
|
team.CreateTime = teamInfo["CreateTime"]
|
team.FuncMapEx = teamInfo["FuncMapEx"]
|
team.TeamName = teamInfo["TeamName"]
|
team.NameLen = len(team.TeamName)
|
team.CaptainID = teamInfo["CaptainID"]
|
team.MinLV = teamInfo["MinLV"]
|
team.MinFightPower = teamInfo["MinFightPower"] % ChConfig.Def_PerPointValue
|
team.MinFightPowerEx = teamInfo["MinFightPower"] / ChConfig.Def_PerPointValue
|
team.ServerOnly = teamInfo["ServerOnly"]
|
team.NeedCheck = teamInfo["NeedCheck"]
|
team.Value1 = teamInfo["Value1"]
|
team.Value2 = teamInfo["Value2"]
|
|
memberList = []
|
for memberInfo in teamInfo["MemberList"]:
|
mem = ChPyNetSendPack.tagGCFuncTeamMem()
|
mem.ServerID = memberInfo.get("ServerID", 0)
|
mem.PlayerID = memberInfo["PlayerID"]
|
mem.Name = memberInfo.get("Name", "")
|
mem.NameLen = len(mem.Name)
|
mem.LV = memberInfo.get("LV", 0)
|
mem.Job = memberInfo.get("Job", 0)
|
mem.RealmLV = memberInfo.get("RealmLV", 0)
|
mem.Face = memberInfo.get("Face", 0)
|
mem.FacePic = memberInfo.get("FacePic", 0)
|
mem.FightPower = memberInfo.get("FightPower", 0) % ChConfig.Def_PerPointValue
|
mem.FightPowerEx = memberInfo.get("FightPower", 0) / ChConfig.Def_PerPointValue
|
mem.Value1 = memberInfo["Value1"]
|
mem.Value2 = memberInfo["Value2"]
|
memberList.append(mem)
|
|
team.MemberList = memberList
|
team.MemberCount = len(team.MemberList)
|
team.ApplyIDList = teamInfo["ApplyIDList"]
|
team.ApplyCount = len(team.ApplyIDList)
|
|
clientPack.TeamList.append(team)
|
clientPack.TeamCount = len(clientPack.TeamList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
def Sync_FuncTeamRefresh(teamInfo, syncPlayerIDList):
|
## ¹¦ÄܶÓÎéË¢ÐÂ
|
if not teamInfo or not syncPlayerIDList:
|
return
|
|
syncPlayerList = []
|
playerManager = GameWorld.GetPlayerManager()
|
for playerID in syncPlayerIDList:
|
player = playerManager.FindPlayerByID(playerID)
|
if player == None or not player.GetInitOK():
|
continue
|
syncPlayerList.append(player)
|
|
if not syncPlayerList:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCFuncTeamRefresh()
|
clientPack.TeamID = teamInfo["TeamID"]
|
clientPack.CreateTime = teamInfo["CreateTime"]
|
clientPack.FuncMapID = teamInfo["FuncMapID"]
|
clientPack.FuncMapEx = teamInfo["FuncMapEx"]
|
clientPack.TeamName = teamInfo["TeamName"]
|
clientPack.NameLen = len(clientPack.TeamName)
|
clientPack.CaptainID = teamInfo["CaptainID"]
|
clientPack.MinLV = teamInfo["MinLV"]
|
clientPack.MinFightPower = teamInfo["MinFightPower"] % ChConfig.Def_PerPointValue
|
clientPack.MinFightPowerEx = teamInfo["MinFightPower"] / ChConfig.Def_PerPointValue
|
clientPack.ServerOnly = teamInfo["ServerOnly"]
|
clientPack.NeedCheck = teamInfo["NeedCheck"]
|
clientPack.Value1 = teamInfo["Value1"]
|
clientPack.Value2 = teamInfo["Value2"]
|
|
memberInfoList = teamInfo["MemberList"]
|
applyInfoList = teamInfo["ApplyList"]
|
|
memberList = []
|
for memberInfo in memberInfoList:
|
mem = ChPyNetSendPack.tagGCFuncTeamRefreshMem()
|
mem.ServerID = memberInfo.get("ServerID", 0)
|
mem.PlayerID = memberInfo["PlayerID"]
|
mem.Name = memberInfo.get("Name", "")
|
mem.NameLen = len(mem.Name)
|
mem.LV = memberInfo.get("LV", 0)
|
mem.Job = memberInfo.get("Job", 0)
|
mem.RealmLV = memberInfo.get("RealmLV", 0)
|
mem.Face = memberInfo.get("Face", 0)
|
mem.FacePic = memberInfo.get("FacePic", 0)
|
mem.FightPower = memberInfo.get("FightPower", 0) % ChConfig.Def_PerPointValue
|
mem.FightPowerEx = memberInfo.get("FightPower", 0) / ChConfig.Def_PerPointValue
|
mem.OfflineValue = memberInfo.get("OfflineValue", 0)
|
mem.Value1 = memberInfo["Value1"]
|
mem.Value2 = memberInfo["Value2"]
|
memberList.append(mem)
|
|
applyList, applyIDList = [], []
|
for applyInfo in applyInfoList:
|
applyP = ChPyNetSendPack.tagGCFuncTeamRefreshApply()
|
applyP.ServerID = applyInfo["ServerID"]
|
applyP.PlayerID = applyInfo["PlayerID"]
|
applyP.Name = applyInfo["Name"]
|
applyP.NameLen = len(applyP.Name)
|
applyP.LV = applyInfo["LV"]
|
applyP.Job = applyInfo["Job"]
|
applyP.RealmLV = applyInfo["RealmLV"]
|
applyP.Face = applyInfo.get("Face", 0)
|
applyP.FacePic = applyInfo.get("FacePic", 0)
|
applyP.FightPower = applyInfo["FightPower"] % ChConfig.Def_PerPointValue
|
applyP.FightPowerEx = applyInfo["FightPower"] / ChConfig.Def_PerPointValue
|
applyList.append(applyP)
|
applyIDList.append(applyInfo["PlayerID"])
|
|
clientPack.MemberList = memberList
|
clientPack.MemberCount = len(clientPack.MemberList)
|
clientPack.ApplyIDList = applyIDList
|
clientPack.ApplyInfoList = applyList
|
clientPack.ApplyCount = len(clientPack.ApplyInfoList)
|
|
for player in syncPlayerList:
|
NetPackCommon.SendFakePack(player, clientPack)
|
return
|
|
def Sync_FuncTeamDissolve(teamID, syncPlayerIDList):
|
## ¹¦ÄܶÓÎé½âÉ¢
|
if not teamID or not syncPlayerIDList:
|
return
|
|
syncPlayerList = []
|
playerManager = GameWorld.GetPlayerManager()
|
for playerID in syncPlayerIDList:
|
player = playerManager.FindPlayerByID(playerID)
|
if player == None or not player.GetInitOK():
|
continue
|
syncPlayerList.append(player)
|
|
if not syncPlayerList:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCFuncTeamDissolve()
|
clientPack.TeamID = teamID
|
for player in syncPlayerList:
|
NetPackCommon.SendFakePack(player, clientPack)
|
return
|
|
##--------------------------------------------------------------------------------------------------
|
|
def GetFuncTeamMapIDZoneInfo(funcMapID, serverGroupID):
|
## »ñÈ¡¹¦ÄܶÓÎé·ÖÇøÐÅÏ¢
|
|
funcZoneID = 0
|
serverGroupList = []
|
|
if funcMapID == ChConfig.Def_FBMapID_CrossBattlefield:
|
zoneIpyData = CrossBattlefield.GetCrossBattlefieldZoneIpyData(serverGroupID)
|
if not zoneIpyData:
|
return
|
funcZoneID = zoneIpyData.GetZoneID()
|
serverGroupList = zoneIpyData.GetServerGroupIDList() # ֻ֪ͨ¸Ã·ÖÇø·þÎñÆ÷
|
|
return funcZoneID, serverGroupList
|
|
def ClientServerMsg_CreateFuncTeam(serverGroupID, msgData):
|
## ÊÕµ½×Ó·þ - ¹¦ÄܶÓÎé´´½¨
|
|
zoneID = msgData["zoneID"]
|
playerID = msgData["playerID"]
|
teamInfo = msgData["teamInfo"]
|
cacheBase = msgData["cacheBase"]
|
|
funcMapID = teamInfo["funcMapID"]
|
|
zoneInfo = GetFuncTeamMapIDZoneInfo(funcMapID, serverGroupID)
|
if not zoneInfo:
|
return
|
funcZoneID, _ = zoneInfo
|
|
if zoneID != funcZoneID:
|
GameWorld.ErrLog("¹¦ÄܶÓÎé·ÖÇø²»Ò»Ö£¬ÎÞ·¨´´½¨! funcMapID=%s,zoneID=%s != %s" % (funcMapID, zoneID, funcZoneID), playerID)
|
return
|
|
canCreate, notifyMark = CheckCanCreateFuncTeam(playerID, teamInfo, zoneID)
|
|
# ijЩ¹¦ÄÜ´´½¨Ç°¼ì²é
|
if funcMapID == ChConfig.Def_FBMapID_CrossBattlefield:
|
pass
|
|
newTeam = None
|
teamID = 0
|
newTeamInfo = {}
|
if canCreate:
|
PlayerViewCache.UpdCrossCacheBase(playerID, cacheBase)
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
newTeam = funcTeamMgr.CreateFuncTeam(playerID, teamInfo, zoneID)
|
|
if newTeam:
|
teamID = newTeam.GetTeamID()
|
newTeamInfo = newTeam.GetSyncDict(True)
|
|
# ijЩ¹¦ÄÜ´´½¨ºó´¦Àí
|
if funcMapID == ChConfig.Def_FBMapID_CrossBattlefield:
|
pass
|
|
else:
|
if not notifyMark:
|
notifyMark = "CreatTeamFail"
|
|
serverGroupList = [serverGroupID] # ´´½¨½öָ֪ͨ¶¨·þ¼´¿É
|
syncPlayerIDList = [playerID]
|
sendMsg = {"infoType":"CreateFuncTeam", "zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID,
|
"teamInfo":newTeamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList, "notifyMark":notifyMark}
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg, serverGroupList)
|
return
|
|
def CheckCanCreateFuncTeam(playerID, teamInfo, zoneID=0, checkInTeam=True):
|
## ¼ì²é¿É·ñ´´½¨¹¦ÄܶÓÎé - ±¾·þ¿ç·þͨÓÃ
|
# @param checkInTeam: ÊÇ·ñ¼ì²éÒѾÔÚ¶ÓÎéÖУ¬Èç¹û¹¦ÄÜÖ»ÔÊÐíµ¥¸ö¶ÓÎ飬ÔòÐèÒª¼ì²é£¬·´Ö®¿ÉÉèÖÃΪ²»¼ì²é
|
# @return: ÊÇ·ñ¿É´´½¨, ²»¿É´´½¨ÌáʾÐÅÏ¢
|
|
funcMapID = teamInfo["funcMapID"]
|
ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)
|
if not ipyData:
|
return False, ""
|
|
needName = ipyData.GetNeedName()
|
if needName:
|
teamName = teamInfo["teamName"]
|
if not teamName or len(teamName) > 33:
|
# ¶ÓÎéÃû²»ºÏ·¨
|
return False, "TeamNameLenError"
|
|
if DirtyList.IsWordForbidden(teamName):
|
return False, "TeamNameUnallow"
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
teamList = funcTeamMgr.GetFuncTeamList(zoneID, funcMapID)
|
for funcTeam in teamList:
|
if needName:
|
if teamName == funcTeam.GetTeamName():
|
# ¶ÓÎéÃûÒÑ´æÔÚ
|
return False, "TeamNameExist"
|
|
if checkInTeam:
|
if funcTeam.GetMemberByID(playerID):
|
# ÒѾÔÚ¶ÓÎéÖÐ
|
return False, "AlreadyHaveTeam"
|
|
return True, ""
|
|
def ClientServerMsg_ChangeFuncTeam(serverGroupID, msgData):
|
## ÊÕµ½×Ó·þ - ¹¦ÄܶÓÎéÐÞ¸Ä
|
|
zoneID = msgData["zoneID"]
|
playerID = msgData["playerID"]
|
teamInfo = msgData["teamInfo"]
|
cacheBase = msgData.get("cacheBase", {})
|
|
teamID = teamInfo["teamID"]
|
funcMapID = teamInfo["funcMapID"]
|
|
zoneInfo = GetFuncTeamMapIDZoneInfo(funcMapID, serverGroupID)
|
if not zoneInfo:
|
return
|
funcZoneID, serverGroupList = zoneInfo
|
|
if zoneID != funcZoneID:
|
GameWorld.ErrLog("¹¦ÄܶÓÎé·ÖÇø²»Ò»Ö£¬ÎÞ·¨ÐÞ¸Ä! funcMapID=%s,zoneID=%s != %s" % (funcMapID, zoneID, funcZoneID), playerID)
|
return
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
GameWorld.ErrLog("¹¦ÄܶÓÎé²»´æÔÚ! funcMapID=%s,teamID=%s" % (funcMapID, teamID), playerID)
|
return
|
|
if playerID != funcTeam.GetCaptainID():
|
GameWorld.DebugLog("·Ç¹¦ÄܶÓÎé¶Ó³¤£¬ÎÞ·¨ÐÞ¸Ä! funcMapID=%s,teamID=%s,CaptainID=%s" % (funcMapID, teamID, funcTeam.GetCaptainID()), playerID)
|
return
|
|
if cacheBase:
|
PlayerViewCache.UpdCrossCacheBase(playerID, cacheBase)
|
|
funcTeam.SetMinFightPower(teamInfo["minFightPower"] + teamInfo["minFightPowerEx"] * ChConfig.Def_PerPointValue)
|
funcTeam.SetMinLV(teamInfo["minLV"])
|
funcTeam.SetServerOnly(teamInfo["serverOnly"])
|
funcTeam.SetNeedCheck(teamInfo["needCheck"])
|
|
if not funcTeam.GetNeedCheck():
|
pass
|
|
teamID = funcTeam.GetTeamID()
|
teamInfo = funcTeam.GetSyncDict(True)
|
syncPlayerIDList = funcTeam.GetSyncPlayerIDList()
|
sendMsg = {"infoType":"ChangeFuncTeam", "zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID,
|
"teamInfo":teamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList}
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg, serverGroupList)
|
return
|
|
def ClientServerMsg_FuncTeamMemOP(serverGroupID, msgData):
|
## ÊÕµ½×Ó·þ - ¹¦ÄܶÓÎé²Ù×÷
|
|
zoneID = msgData["zoneID"]
|
playerID = msgData["playerID"] # ²Ù×÷µÄÍæ¼ÒID
|
teamID = msgData["teamID"]
|
funcMapID = msgData["funcMapID"]
|
opType = msgData["opType"]
|
opData = msgData["opData"]
|
cacheBase = msgData.get("cacheBase", {})
|
|
zoneInfo = GetFuncTeamMapIDZoneInfo(funcMapID, serverGroupID)
|
if not zoneInfo:
|
return
|
funcZoneID, serverGroupList = zoneInfo
|
|
if zoneID != funcZoneID:
|
GameWorld.ErrLog("¹¦ÄܶÓÎé·ÖÇø²»Ò»Ö£¬ÎÞ·¨²Ù×÷! funcMapID=%s,zoneID=%s != %s" % (funcMapID, zoneID, funcZoneID), playerID)
|
return
|
|
if cacheBase:
|
PlayerViewCache.UpdCrossCacheBase(playerID, cacheBase)
|
|
isOK = False
|
syncDict = {}
|
teamInfo = {}
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
GameWorld.ErrLog("¹¦ÄܶÓÎé²»´æÔÚ! funcMapID=%s,teamID=%s,opType=%s" % (funcMapID, teamID, opType), playerID)
|
syncDict["notifyMark"] = "TeamNotExist"
|
syncPlayerIDList = [playerID]
|
else:
|
# ½ö¶Ó³¤¿É²Ù×÷
|
if opType in [Def_FuncTeamOP_JoinAgree, Def_FuncTeamOP_JoinRefuse, Def_FuncTeamOP_Kick,
|
Def_FuncTeamOP_Transfer, Def_FuncTeamOP_Dissolve]:
|
if playerID != funcTeam.GetCaptainID():
|
GameWorld.ErrLog("½ö¶Ó³¤¿É²Ù×÷! funcMapID=%s,teamID=%s,opType=%s,CaptainID=%s"
|
% (funcMapID, teamID, opType, funcTeam.GetCaptainID()), playerID)
|
return
|
|
syncPlayerIDList = funcTeam.GetSyncPlayerIDList()
|
|
# ÉêÇë¼ÓÈë
|
if opType == Def_FuncTeamOP_JoinApply:
|
isOK = __DoFuncTeamOP_JoinApply(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)
|
if playerID not in syncPlayerIDList:
|
syncPlayerIDList.append(playerID)
|
|
# ÉêÇëÈ¡Ïû
|
elif opType == Def_FuncTeamOP_JoinCancel:
|
isOK = __DoFuncTeamOP_JoinCancel(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)
|
if playerID not in syncPlayerIDList:
|
syncPlayerIDList.append(playerID)
|
|
# ͬÒâÈë¶Ó
|
elif opType == Def_FuncTeamOP_JoinAgree:
|
isOK = __DoFuncTeamOP_JoinAgree(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)
|
|
# ¾Ü¾øÈë¶Ó
|
elif opType == Def_FuncTeamOP_JoinRefuse:
|
isOK = __DoFuncTeamOP_JoinRefuse(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)
|
|
# Í˳ö¶ÓÎé
|
elif opType == Def_FuncTeamOP_Exit:
|
isOK = __DoFuncTeamOP_Exit(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)
|
|
# Ìß³ö¶ÓÎé
|
elif opType == Def_FuncTeamOP_Kick:
|
isOK = __DoFuncTeamOP_Kick(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)
|
|
# תÈöӳ¤
|
elif opType == Def_FuncTeamOP_Transfer:
|
isOK = __DoFuncTeamOP_Transfer(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)
|
|
# ½âÉ¢¶ÓÎé
|
elif opType == Def_FuncTeamOP_Dissolve:
|
isOK = __DoFuncTeamOP_Dissolve(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)
|
|
if not isOK and not syncDict:
|
# ûÓÐÖ´Ðгɹ¦ ÇÒ Ã»ÓÐÐèÒª»Ø¸´µÄÐÅÏ¢£¬Ôò²»ÐèÒª»Ø·¢×Ó·þ
|
return
|
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if funcTeam:
|
teamInfo = funcTeam.GetSyncDict(True)
|
|
sendMsg = {"infoType":"FuncTeamMemOP", "zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID,
|
"teamInfo":teamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList, "opType":opType}
|
sendMsg.update(syncDict)
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg, serverGroupList)
|
return
|
|
def DelTeam(teamID):
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
GameWorld.ErrLog("ɾ³ý¹¦ÄܶÓÎéʱ²»´æÔÚ! teamID=%s" % teamID)
|
return
|
zoneID = funcTeam.GetZoneID()
|
funcMapID = funcTeam.GetFuncMapID()
|
syncPlayerIDList = funcTeam.GetSyncPlayerIDList()
|
|
funcTeamMgr.DelTeam(teamID)
|
|
if not funcTeamMgr.IsLockBatch():
|
sendMsg = {"zoneID":zoneID, "funcMapID":funcMapID, "delTeamDict":{teamID:syncPlayerIDList}}
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamDel, sendMsg)
|
|
return syncPlayerIDList
|
|
def DelTeamByFunc(delFuncMapID):
|
GameWorld.Log("Çå¿Õ¹¦ÄܶÓÎé! delFuncMapID=%s" % delFuncMapID)
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeamMgr.LockBatch()
|
delTeamIDList = []
|
for key, teamList in funcTeamMgr.funcTeamListDict.items():
|
zoneID, funcMapID = key
|
if funcMapID != delFuncMapID:
|
continue
|
delTeamDict = {}
|
for funcTeam in teamList[::-1]:
|
teamID = funcTeam.GetTeamID()
|
syncPlayerIDList = DelTeam(teamID)
|
if syncPlayerIDList:
|
delTeamDict[teamID] = syncPlayerIDList
|
delTeamIDList.append(teamID)
|
|
# °´·ÖÇø´¦ÀíºóÒ»´ÎÐÔͬ²½×Ó·þ
|
zoneIpyData = CrossRealmPlayer.GetCrossZoneIpyDataByZoneID(funcMapID, zoneID)
|
serverGroupIDList = zoneIpyData.GetServerGroupIDList() if zoneIpyData else []
|
sendMsg = {"zoneID":zoneID, "funcMapID":funcMapID, "delTeamDict":delTeamDict}
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamDel, sendMsg, serverGroupIDList)
|
funcTeamMgr.UnLockBatch()
|
|
delCount = len(delTeamIDList)
|
funcTeamMgr.SyncMapFuncTeamMemIDInfo(delTeamIDList)
|
return delCount
|
|
def DelTealAll():
|
delCount = 0
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in range(ipyDataMgr.GetFuncTeamSetCount()):
|
ipyData = ipyDataMgr.GetFuncTeamSetByIndex(index)
|
delCount += DelTeamByFunc(ipyData.GetFuncMapID())
|
return delCount
|
|
def SendFuncTeamToClientServer(teamID):
|
## ͬ²½¶ÓÎéÃ÷ϸµ½×Ó·þ
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
return
|
funcMapID = funcTeam.GetFuncMapID()
|
teamInfo = funcTeam.GetSyncDict(True)
|
syncPlayerIDList = funcTeam.GetSyncPlayerIDList()
|
|
sendMsg = {"infoType":"", "playerID":0, "funcMapID":funcMapID,
|
"teamInfo":teamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList}
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg)
|
return
|
|
def __DoFuncTeamOP_JoinApply(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):
|
## ÉêÇë¼ÓÈë
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
playerTeamID = funcTeamMgr.GetPlayerTeamID(playerID, funcMapID)
|
if playerTeamID:
|
GameWorld.Log("ÒѾÓй¦ÄܶÓÎéÁË£¬²»ÄÜÔÙÉêÇë! funcMapID=%s,playerTeamID=%s" % (funcMapID, playerTeamID), playerID)
|
return
|
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
return
|
|
if funcTeam.GetMemberByID(playerID):
|
GameWorld.Log("ÒÑÔÚ¹¦ÄܶÓÎéÖÐ! funcMapID=%s,teamID=%s" % (funcMapID, teamID), playerID)
|
return
|
|
if playerID in funcTeam.GetApplyIDList():
|
GameWorld.Log("ÒÑÔÚ¹¦ÄܶÓÎéÉêÇëÁбíÖÐ! funcMapID=%s,teamID=%s" % (funcMapID, teamID), playerID)
|
return
|
|
ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)
|
if not ipyData:
|
return
|
|
memberMax = ipyData.GetMemberMax()
|
applyMax = ipyData.GetApplyMax()
|
reqApplyMax = ipyData.GetReqApplyMax()
|
|
if len(funcTeam.GetMemberList()) >= memberMax:
|
GameWorld.DebugLog("¹¦ÄܶÓÎé³ÉÔ±ÒÑÂú! funcMapID=%s,teamID=%s,memberMax=%s" % (funcMapID, teamID, memberMax), playerID)
|
syncDict["notifyMark"] = "TeamMemFull"
|
return
|
|
if applyMax and len(funcTeam.GetApplyIDList()) >= applyMax:
|
GameWorld.DebugLog("¹¦ÄܶÓÎéÉêÇë¶ÓÁÐÒÑÂú! funcMapID=%s,teamID=%s,applyMax=%s" % (funcMapID, teamID, applyMax), playerID)
|
syncDict["notifyMark"] = "TeamApplyFull"
|
return
|
|
minLV = funcTeam.GetMinLV()
|
if minLV and minLV > cacheBase.get("LV", 0):
|
GameWorld.DebugLog("¹¦ÄܶÓÎé×îµÍµÈ¼¶ÏÞÖÆ£¬ÎÞ·¨ÉêÇë! funcMapID=%s,teamID=%s,minLV=%s" % (funcMapID, teamID, minLV), playerID)
|
syncDict["notifyMark"] = "TeamLVLimit"
|
return
|
|
minFightPower = funcTeam.GetMinFightPower()
|
if minFightPower and minFightPower > cacheBase.get("FightPower", 0):
|
GameWorld.DebugLog("¹¦ÄܶÓÎé×îµÍÕ½Á¦ÏÞÖÆ£¬ÎÞ·¨ÉêÇë! funcMapID=%s,teamID=%s,minFightPower=%s" % (funcMapID, teamID, minFightPower), playerID)
|
syncDict["notifyMark"] = "TeamFightPowerLimit"
|
return
|
|
minServerOnly = funcTeam.GetServerOnly()
|
if minServerOnly:
|
# ´ýÀ©Õ¹£¬¿´ÊÇÈ¡ServerID£¬»¹ÊÇ ServerGroupID£¬Ðè×¢ÒâGroupIDºÏ·þºó¿ÉÄܲ»Ò»ÖµÄÎÊÌâ
|
pass
|
|
if reqApplyMax:
|
applyTeamIDList = []
|
teamList = funcTeamMgr.GetFuncTeamList(zoneID, funcMapID)
|
for fTeam in teamList:
|
if playerID in fTeam.GetApplyIDList():
|
applyTeamIDList.append(fTeam.GetTeamID())
|
if len(applyTeamIDList) >= reqApplyMax:
|
GameWorld.DebugLog("Íæ¼ÒÉêÇë¼ÓÈë¶ÓÎéÊýÒÑÂú£¬ÎÞ·¨ÉêÇë! funcMapID=%s,applyTeamCount=%s, %s"
|
% (funcMapID, len(applyTeamIDList), applyTeamIDList), playerID)
|
syncDict["notifyMark"] = "TeamReqJoinApplyFull"
|
return
|
|
if funcTeam.GetNeedCheck():
|
syncDict["notifyMark"] = "TeamReqJoinApplyOK"
|
funcTeam.AddApplyID(playerID)
|
else:
|
funcTeam.AddTeamMember(playerID)
|
|
return True
|
|
def __DoFuncTeamOP_JoinCancel(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):
|
## ÉêÇëÈ¡Ïû
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
return
|
|
funcTeam.DelApplyID(playerID)
|
|
return True
|
|
def __DoFuncTeamOP_JoinAgree(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):
|
## ͬÒâÈë¶Ó
|
# @param opData: Ä¿±êÍæ¼ÒID£¬Îª0ʱһ¼üͬÒâ
|
|
ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)
|
if not ipyData:
|
return
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
return
|
|
applyIDList = funcTeam.GetApplyIDList()
|
if not applyIDList:
|
return
|
|
memberMax = ipyData.GetMemberMax()
|
joinPlayerIDList = []
|
tagPlayerID = opData
|
if tagPlayerID:
|
if tagPlayerID not in applyIDList:
|
GameWorld.Log("Ä¿±êÍæ¼Ò²»ÔÚ¹¦ÄܶÓÎéÉêÇëÁбíÖÐ! funcMapID=%s,teamID=%s,tagPlayerID=%s not in applyIDList=%s"
|
% (funcMapID, teamID, tagPlayerID, applyIDList), playerID)
|
return
|
|
tagPlayerTeamID = funcTeamMgr.GetPlayerTeamID(tagPlayerID, funcMapID)
|
if tagPlayerTeamID:
|
GameWorld.DebugLog("Ä¿±êÍæ¼ÒÒѼÓÈëÆäËû¹¦ÄܶÓÎé! funcMapID=%s,tagPlayerID=%s,tagPlayerTeamID=%s"
|
% (funcMapID, tagPlayerID, tagPlayerTeamID), playerID)
|
syncDict["notifyMark"] = "PlayerInOtherTeam"
|
else:
|
joinPlayerIDList = [tagPlayerID]
|
else:
|
joinPlayerIDList = [] + applyIDList # Ò»¼üͬÒâ°´ÉêÇë˳Ðò£¬ÈçÐè°´Õ½Á¦ÔÙ×öÓÅ»¯
|
|
for joinPlayerID in joinPlayerIDList:
|
if len(funcTeam.GetMemberList()) >= memberMax:
|
GameWorld.DebugLog("¹¦ÄܶÓÎé³ÉÔ±ÒÑÂú! funcMapID=%s,teamID=%s,memberMax=%s" % (funcMapID, teamID, memberMax), playerID)
|
break
|
tagPlayerTeamID = funcTeamMgr.GetPlayerTeamID(joinPlayerID, funcMapID)
|
if tagPlayerTeamID:
|
GameWorld.DebugLog("Ä¿±êÍæ¼ÒÒѼÓÈëÆäËû¹¦ÄܶÓÎé! funcMapID=%s,joinPlayerID=%s,tagPlayerTeamID=%s"
|
% (funcMapID, joinPlayerID, tagPlayerTeamID), playerID)
|
continue
|
funcTeam.AddTeamMember(joinPlayerID)
|
|
return True
|
|
def __DoFuncTeamOP_JoinRefuse(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):
|
## ¾Ü¾øÈë¶Ó
|
# @param opData: Ä¿±êÍæ¼ÒID£¬Îª0ʱһ¼ü¾Ü¾ø
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
return
|
|
tagPlayerID = opData
|
if tagPlayerID:
|
funcTeam.DelApplyID(tagPlayerID)
|
else:
|
funcTeam.DelApplyIDAll() # Ò»¼ü¾Ü¾ø
|
|
return True
|
|
def __DoFuncTeamOP_Exit(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):
|
## Í˳ö¶ÓÎé
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
return
|
|
# ¶Ó³¤Í˳ö£¬Ö±½Ó½âÉ¢
|
if playerID == funcTeam.GetCaptainID():
|
return __DoFuncTeamOP_Dissolve(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)
|
|
funcTeam.DelTeamMember(playerID)
|
|
return True
|
|
def __DoFuncTeamOP_Kick(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):
|
## Ìß³ö¶ÓÎé
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
return
|
|
tagPlayerID = opData
|
if not tagPlayerID:
|
GameWorld.DebugLog("ÐèÖ¸¶¨Ìß³ö¶ÓÎéÄ¿±ê¶ÓÔ±! opData=%s" % opData, playerID)
|
return
|
|
if tagPlayerID == funcTeam.GetCaptainID():
|
GameWorld.DebugLog("²»ÄÜÌ߶ӳ¤! opData=%s" % opData, playerID)
|
return
|
|
funcTeam.DelTeamMember(tagPlayerID)
|
|
return True
|
|
def __DoFuncTeamOP_Transfer(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):
|
## תÈöӳ¤
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
if not funcTeam:
|
return
|
|
memberIDList = funcTeam.GetMemberIDList()
|
tagPlayerID = opData
|
if tagPlayerID not in memberIDList:
|
GameWorld.Log("Ä¿±êÍæ¼Ò²»ÊǶÓÔ±£¬ÎÞ·¨×ªÈöӳ¤! funcMapID=%s,teamID=%s,tagPlayerID=%s not in %s"
|
% (funcMapID, teamID, tagPlayerID, memberIDList), playerID)
|
return
|
|
funcTeam.SetCaptainID(tagPlayerID)
|
|
return True
|
|
def __DoFuncTeamOP_Dissolve(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):
|
## ½âÉ¢¶ÓÎé
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
funcTeamMgr.DelTeam(teamID)
|
return True
|
|
def ClientServerMsg_QueryFuncTeam(serverGroupID, msgData):
|
## ÊÕµ½×Ó·þ - ²éÕÒ¶ÓÎéÁбí
|
|
zoneID = msgData["zoneID"]
|
playerID = msgData["playerID"]
|
funcMapID = msgData["funcMapID"]
|
cacheBase = msgData.get("cacheBase", {})
|
|
zoneInfo = GetFuncTeamMapIDZoneInfo(funcMapID, serverGroupID)
|
if not zoneInfo:
|
return
|
funcZoneID, _ = zoneInfo
|
|
if zoneID != funcZoneID:
|
GameWorld.ErrLog("¹¦ÄܶÓÎé·ÖÇø²»Ò»Ö£¬ÎÞ·¨²éѯ! funcMapID=%s,zoneID=%s != %s" % (funcMapID, zoneID, funcZoneID), playerID)
|
return
|
|
if cacheBase:
|
PlayerViewCache.UpdCrossCacheBase(playerID, cacheBase)
|
|
# ·ÇÁбí²éѯ£¬·µ»ØÍæ¼ÒÏà¹Ø¶ÓÎé
|
if "startIndex" not in msgData:
|
syncPlayerIDList = [playerID]
|
serverGroupList = [serverGroupID]
|
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
# ÉêÇëµÄ¶ÓÎé
|
funcTeamList = funcTeamMgr.GetFuncTeamList(zoneID, funcMapID)
|
for funcTeam in funcTeamList:
|
if playerID not in funcTeam.GetApplyIDList():
|
continue
|
teamID = funcTeam.GetTeamID()
|
teamInfo = funcTeam.GetSyncDict(True)
|
sendMsg = {"infoType":"QueryPlayerFuncTeam", "zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID,
|
"teamInfo":teamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList}
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg, serverGroupList)
|
|
# Íæ¼ÒËùÊô¶ÓÎé
|
teamID = funcTeamMgr.GetPlayerTeamID(playerID, funcMapID)
|
funcTeam = funcTeamMgr.GetFuncTeam(teamID)
|
teamInfo = funcTeam.GetSyncDict(True) if funcTeam else {}
|
sendMsg = {"infoType":"QueryPlayerFuncTeam", "zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID,
|
"teamInfo":teamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList}
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg, serverGroupList)
|
return
|
|
# Áбí²éѯ
|
funcMapEx = msgData["funcMapEx"]
|
startIndex = msgData["startIndex"]
|
queryCnt = msgData["queryCnt"]
|
haveSpace = msgData["haveSpace"]
|
idLimitType = msgData["idLimitType"]
|
searchMsg = msgData["searchMsg"]
|
if queryCnt <= 0:
|
queryCnt = 20
|
queryCnt = min(100, queryCnt) # ĬÈÏ20£¬×î´ó100
|
|
ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)
|
if not ipyData:
|
return
|
memberMax = ipyData.GetMemberMax()
|
|
idLimitTypeDict = {1:"FamilyID", 2:"ServerGroupID", 3:"AccID"}
|
loopIndex = startIndex
|
teamInfoList = []
|
funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()
|
teamList = funcTeamMgr.GetFuncTeamList(zoneID, funcMapID)
|
for index in xrange(startIndex, len(teamList)):
|
loopIndex = index + 1
|
funcTeam = teamList[index]
|
if searchMsg:
|
# ¾«È·Æ¥Åä¶ÓÎéÃû¡¢¶ÓÎéIDµÄ²åÈëÔÚ×îÇ°Ãæ
|
if searchMsg == funcTeam.GetTeamName() or searchMsg == str(funcTeam.GetTeamID()):
|
teamInfoList.insert(0, funcTeam.GetSyncDict(False))
|
elif searchMsg in funcTeam.GetTeamName():
|
teamInfoList.append(funcTeam.GetSyncDict(False))
|
else:
|
continue
|
else:
|
if funcMapEx != 0 and funcMapEx != funcTeam.GetFuncMapEx():
|
continue
|
if haveSpace and len(funcTeam.GetMemberList()) >= memberMax:
|
#GameWorld.DebugLog("ÒÑÂúÔ±£¬²»¼ÓÈëÁбí²é¿´ teamID=%s" % funcTeam.GetTeamID())
|
continue
|
if idLimitType in idLimitTypeDict:
|
limitAttrName = idLimitTypeDict[idLimitType]
|
curIDValue = cacheBase.get(limitAttrName, 0)
|
captainID = funcTeam.GetCaptainID()
|
cacheDict = PlayerViewCache.GetCachePropDataDict(PlayerViewCache.FindViewCache(captainID))
|
teamIDValue = cacheDict.get(limitAttrName, 0)
|
if limitAttrName == "AccID":
|
curIDValue = GameWorld.GetAccIDServerID(str(curIDValue))
|
teamIDValue = GameWorld.GetAccIDServerID(str(teamIDValue))
|
|
if not curIDValue or curIDValue != teamIDValue:
|
#GameWorld.DebugLog("ûÓлò²»Í¬IDÏÞÖÆ£¬²»¼ÓÈëÁбí²é¿´! idLimitType=%s,curIDValue=%s != %s, teamID=%s, captainID=%s"
|
# % (idLimitType, curIDValue, teamIDValue, funcTeam.GetTeamID(), captainID))
|
continue
|
teamInfoList.append(funcTeam.GetSyncDict(False))
|
|
if len(teamInfoList) >= queryCnt:
|
break
|
|
serverGroupList = [serverGroupID] # ½ö֪ͨ²éѯ·þ¼´¿É
|
sendMsg = {"teamInfoList":teamInfoList, "loopIndex":loopIndex, "queryInfo":msgData}
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamList, sendMsg, serverGroupList)
|
return
|
|
