SnxxServerCode.git

			@@ -55,37 +55,40 @@
			import PlayerWing
			import PlayerExpandPackCfgMgr
			import PlayerWorldAverageLv
			import GameLogic_ManorWar
			import PlayerActivity
			import HighLadderTube
			import FBCommon
			import PlayerViewCacheTube
			import PassiveBuffEffMng
			import PlayerGameEvent
			import EventReport
			import PlayerTeHui
			import PlayerGatherSoul
			import PlayerSuccess
			import PlayerPet
			import PlayerGreatMaster
			import ItemControler
			import GameFuncComm
			import PlayerMergeEvent
			import IpyGameDataPY
			import PlayerRune
			import GameLogic_DuJie
			import PyGameData
			import PlayerMagicWeapon
			import GameLogic_SealDemon
			import GameLogic_ZhuXianBoss
			import PlayerTJG
			import PlayerVip
			import PlayerRefineStove
			import PlayerFamilyTech
			import PlayerCostRebate
			import GY_Query_CrossRealmReg
			import PlayerFairyCeremony
			import PlayerNewFairyCeremony
			import PlayerCrossRealmPK
			import FunctionNPCCommon
			import CrossRealmPlayer
			import CrossPlayerData
			import ChNetSendPack
			#import EquipZhuXian
			import PlayerCoat
			import PlayerState
			import QuestCommon
			import PlayerDogz
			@@ -116,6 +119,7 @@
			Def_Max_Move_Tick = 5000

			if abs(gameWorldTick - clientWorldTick) >= Def_Max_Move_Tick:
			curPlayer.Sync_ClientTick()
			#时间相差过大，可能因网络引起，拉回
			GameWorld.DebugLog("PlayerMoveCheckClientWorldTick -- 服务器tick %s-客户端%s时间相差过大，可能因网络引起，拉回" % (
			gameWorldTick, clientWorldTick), curPlayer.GetID())
			@@ -230,15 +234,22 @@
			# @param mergeMapInfo 该提示所属的跨服活动地图信息, 主要用于不同子服对应所跨的活动地图ID
			# @return 无返回值
			def WorldNotify(country, msgMark, msgParamList=[], lineID=0, mergeMinOSD=-1, mergeMaxOSD=-1, mergeMapInfo=[]):
			# 如果是跨服服务器，则广播子服
			if GameWorld.IsMergeServer():
			sendMsg = str([country, msgMark, msgParamList, lineID, mergeMinOSD, mergeMaxOSD, mergeMapInfo])
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, 'MergeWorldNotify',
			sendMsg, len(sendMsg))
			FBNotify(msgMark, msgParamList) # 跨服中的全服广播只在地图中做广播即可，防止不同跨服分区的地图会相互看到广播，体验不好
			else:
			GameWorld.GetPlayerManager().BroadcastCountry_NotifyCode(country, 0, msgMark,
			__GetNotifyCodeList(msgParamList), lineID)
			GameWorld.GetPlayerManager().BroadcastCountry_NotifyCode(country, 0, msgMark, __GetNotifyCodeList(msgParamList), lineID)
			return

			def GetCrossWorldNotifyInfo(country, msgMark, msgParamList=[]):
			return {"Type":ShareDefine.CrossNotify_World, "Params":[country, msgMark, msgParamList]}

			def GetCrossFamilyNotifyInfo(familyID, msgMark, msgParamList=[]):
			return {"Type":ShareDefine.CrossNotify_Family, "Params":[familyID, msgMark, msgParamList]}

			def CrossNotify(serverGroupIDList, crossNotifyList):
			''' 跨服广播信息提示，支持同步多条，同时也建议多条一起同步
			@param serverGroupIDList: 需要同步到的目标服务器组ID列表
			@param crossNotifyList: 信息提示列表，通过 GetCrossWorldNotifyInfo GetCrossFamilyNotifyInfo 函数获得返回值添加到列表
			'''
			sendMsg = str([serverGroupIDList, crossNotifyList])
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "CrossNotify", sendMsg, len(sendMsg))
			return

			#---------------------------------------------------------------------
			@@ -311,7 +322,7 @@
			return

			#---------------------------------------------------------------------
			def SendMailBatch(mailTypeKey, batchPlayerIDList, batchAddItemList=[], batchParamList=[], batchGold=[], batchGoldPaper=[], batchSilver=[], batchDetail=[]):
			def SendMailBatch(mailTypeKey, batchPlayerIDList, batchAddItemList=[], batchParamList=[], batchGold=[], batchGoldPaper=[], batchSilver=[], batchDetail=[], moneySource=ChConfig.Def_GiveMoney_Mail):
			'''批量发送邮件, 用于瞬间需要发送多封（大量）邮件的，比如一些公共副本活动等结算时
			@param mailTypeKey: 邮件模板key
			@param batchPlayerIDList: [playerIDList, playerIDList, ...]
			@@ -321,14 +332,15 @@
			@param batchGoldPaper: [batchGoldPaper, batchGoldPaper, ...]
			@param batchSilver: [batchSilver, batchSilver, ...]
			@param batchDetail: [记录邮件流向用, ...]
			@param moneySource: 货币来源
			'''
			msgInfo = str([mailTypeKey, batchPlayerIDList, batchAddItemList, batchParamList, batchGold, batchGoldPaper, batchSilver, batchDetail])
			msgInfo = str([mailTypeKey, batchPlayerIDList, batchAddItemList, batchParamList, batchGold, batchGoldPaper, batchSilver, batchDetail, moneySource])
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "SendMailBatch", msgInfo, len(msgInfo))
			GameWorld.Log("SendMailBatch %s, batchPlayerIDList=%s, batchAddItemList=%s, batchParamList=%s, batchGold=%s, batchGoldPaper=%s, batchSilver=%s"
			% (mailTypeKey, batchPlayerIDList, batchAddItemList, batchParamList, batchGold, batchGoldPaper, batchSilver))
			return

			def SendMailByKey(mailTypeKey, playerIDList, addItemList, paramList=[], gold=0, goldPaper=0, silver=0, detail=""):
			def SendMailByKey(mailTypeKey, playerIDList, addItemList, paramList=[], gold=0, goldPaper=0, silver=0, detail="", moneySource=ChConfig.Def_GiveMoney_Mail):
			'''
			@param detail: 记录邮件流向用
			'''
			@@ -336,13 +348,13 @@
			mailTypeKey = ShareDefine.DefaultLackSpaceMailType

			content = "<MailTemplate>%s</MailTemplate>%s" % (mailTypeKey, json.dumps(paramList, ensure_ascii=False))
			SendMail("", content, 30, playerIDList, addItemList, gold, goldPaper, silver, detail)
			SendMail("", content, 30, playerIDList, addItemList, gold, goldPaper, silver, detail, moneySource)
			return

			## 功能发放物品补偿/奖励邮件
			# @param addItemList [(itemID, itemCnt, isBind), {或物品信息字典}, ...]
			# @param addItemList [(itemID, itemCnt, 是否拍品), {或物品信息字典}, ...]
			# @return
			def SendMail(title, content, getDays, playerIDList, addItemList, gold=0, goldPaper=0, silver=0, detail=""):
			def SendMail(title, content, getDays, playerIDList, addItemList, gold=0, goldPaper=0, silver=0, detail="", moneySource=ChConfig.Def_GiveMoney_Mail):
			if not playerIDList:
			return

			@@ -354,7 +366,7 @@
			return

			# 跨服服务器不允许发送邮件
			if GameWorld.IsMergeServer():
			if GameWorld.IsCrossServer():
			return

			itemCountDict = {}
			@@ -367,24 +379,26 @@
			if len(mailItem) != 3:
			continue

			itemID, itemCnt, isBind = mailItem
			itemID, itemCnt, isAuctionItem = mailItem

			if ItemControler.GetAppointItemRealID(itemID):
			# 定制物品转化为物品信息字典
			appointItemObj = ItemControler.GetItemByData(ItemControler.GetAppointItemDictData(itemID, isBind))
			appointItemObj = ItemControler.GetItemByData(ItemControler.GetAppointItemDictData(itemID, isAuctionItem))
			if not appointItemObj:
			GameWorld.ErrLog("邮件定制物品转化失败！itemID, itemCnt, isBind" % (itemID, itemCnt, isBind))
			GameWorld.ErrLog("邮件定制物品转化失败！itemID, itemCnt, isAuctionItem" % (itemID, itemCnt, isAuctionItem))
			continue
			combineItemList.append(ItemCommon.GetMailItemDict(appointItemObj))
			appointItemObj.Clear()
			elif isAuctionItem:
			combineItemList.append((itemID, itemCnt, isAuctionItem))
			else:
			key = (itemID, isBind)
			key = (itemID, isAuctionItem)
			itemCountDict[key] = itemCountDict.get(key, 0) + itemCnt

			for key, itemCnt in itemCountDict.items():
			itemID, isBind = key
			combineItemList.append((itemID, itemCnt, isBind))
			cmdList = [title, content, getDays, playerIDList, combineItemList, gold, goldPaper, silver, detail]
			itemID, isAuctionItem = key
			combineItemList.append((itemID, itemCnt, isAuctionItem))
			cmdList = [title, content, getDays, playerIDList, combineItemList, gold, goldPaper, silver, detail, moneySource]
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "SendMail", '%s' % (cmdList), len(str(cmdList)))
			return True

			@@ -514,6 +528,14 @@
			if GameWorld.GetMap().GetMapID() not in IpyGameDataPY.GetFuncEvalCfg('DungeonDeliver', 1):
			NotifyCode(curPlayer, "Carry_lhs_844170")
			return False

			if not GameWorld.IsCrossServer() and GetCrossMapID(curPlayer):
			NotifyCode(curPlayer, "CrossMap10")
			return False

			if curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ClientCustomScene):
			GameWorld.Log("客户端自定义场景下无法传送!", curPlayer.GetPlayerID())
			return False

			return True

			@@ -1156,10 +1178,6 @@
			NPCCommon.ClearCollectNPC(curPlayer)
			#结束事件
			EventShell.DoExitEvent(curPlayer)

			# 结束摆摊/查看摆摊
			EventShell.ExitShopItem(curPlayer)
			EventShell.ExitWatchShopItem(curPlayer)

			#设置玩家的地图位置, 如果是副本, 离开副本
			# 副本规则:
			@@ -1173,8 +1191,6 @@
			PyGameData.g_lastExitFBType[fbIndex] = [exitFBType, tick]
			#GameWorld.DebugLog("玩家离开副本：fbIndex=%s,exitFBType=%s, %s" % (fbIndex, exitFBType, PyGameData.g_lastExitFBType), curPlayer.GetPlayerID())
			FBLogic.DoExitFBLogic(curPlayer, tick)

			GameLogic_ManorWar.DoExitFB(curPlayer, tick)

			#清空所有不属于自己的光环
			#__ClearNoMeAuraBuff(curPlayer)
			@@ -1194,6 +1210,16 @@
			PyGameData.g_needRefreshMapServerState = True # 有玩家离开地图设置需要刷新

			PlayerSuccess.FinishDelayAddSuccessProgress(curPlayer, tick)

			if not isDisconnect:
			CrossPlayerData.ClearCrossSyncDataCache(curPlayer)

			#清除地图玩家缓存
			playerID = curPlayer.GetPlayerID()
			PyGameData.g_zhuXianSkillAddPerDict.pop(playerID, None)
			PyGameData.g_zhuXianSkillReducePerDict.pop(playerID, None)
			PyGameData.g_playerFuncAttrDict.pop(playerID, None)
			PyGameData.g_playerEquipPartAttrDict.pop(playerID, None)
			return

			##更新保存玩家在线时间
			@@ -1417,11 +1443,6 @@

			curPlayer.SetChangeMapTakeTruck(takeTruck)

			# 如果在摆摊中，提示摆摊关闭
			playerShop = curPlayer.GetPlayerShop()
			if playerShop.GetIsStartShop():
			NotifyCode(curPlayer, "GeRen_admin_70569")

			#离开地图服务器
			__PlayerLeaveServerLogic(curPlayer, tick, False)

			@@ -1565,71 +1586,35 @@

			#---------------------------------------------------------------------

			def ResetMergeFBPlayerCntInfo(resetMapID):
			# 重置跨服活动副本地图人数分配情况信息
			mapID = GameWorld.GetMap().GetMapID()
			if mapID != ChConfig.Def_MergeTransMapID:
			return
			GameWorld.Log("重置跨服活动副本地图人数分配情况信息: resetMapID=%s" % resetMapID)
			gameWorld = GameWorld.GetGameWorld()
			mergeFBPlayerCntDict = ReadChConfig.GetEvalChConfig("MergeFBPlayerCount")
			for reqMapID, mapInfo in mergeFBPlayerCntDict.items():
			if resetMapID and resetMapID != reqMapID:
			continue
			for playerMapID in mapInfo[1]:
			playerCnt = gameWorld.GetGameWorldDictByKey(ChConfig.Map_WorldKey_MergeFBMapPlayerCnt % playerMapID)
			for num in xrange(1, 1 + playerCnt):
			playerID = gameWorld.GetGameWorldDictByKey(ChConfig.Map_WorldKey_MergeFBMapPlayerID % (playerMapID, num))
			gameWorld.SetGameWorldDict(ChConfig.Map_WorldKey_MergeFBMapPlayerID % (playerMapID, num), 0) # 重置对应的玩家ID
			gameWorld.SetGameWorldDict(ChConfig.Map_WorldKey_MergeFBPlayerMapID % (reqMapID, playerID), 0) # 重置玩家ID对应的地图
			gameWorld.SetGameWorldDict(ChConfig.Map_WorldKey_MergeFBMapPlayerCnt % playerMapID, 0) # 重置地图人数
			return

			def __GetMergeFBPlayerMapID(curPlayer, reqMapID):
			# 获取玩家所分配的跨服活动地图ID
			# @param reqMapID: 可以是本服活动的地图ID标识；也可以是指定的跨服活动地图ID, 如果是指定的地图ID也是直接返回

			mergeFBPlayerCntDict = ReadChConfig.GetEvalChConfig("MergeFBPlayerCount")
			if reqMapID not in mergeFBPlayerCntDict:
			return reqMapID

			def PlayerEnterCrossServer(curPlayer, mapID):
			playerID = curPlayer.GetPlayerID()
			gameWorld = GameWorld.GetGameWorld()
			GameWorld.Log("玩家请求进入跨服地图: mapID=%s" % (mapID), playerID)
			if GameWorld.IsCrossServer():
			GameWorld.DebugLog("跨服服务器不允许该操作!")
			return

			playerMapID = gameWorld.GetGameWorldDictByKey(ChConfig.Map_WorldKey_MergeFBPlayerMapID % (reqMapID, playerID))
			if playerMapID:
			GameWorld.DebugLog("已经有分配跨服活动地图，直接返回！playerMapID=%s" % (playerMapID), playerID)
			return playerMapID
			if GetCrossMapID(curPlayer):
			GameWorld.ErrLog("玩家当前为跨服状态，不允许再次请求进入跨服!", curPlayer.GetPlayerID())
			return

			# 还没分配该玩家，则开始选择分配的地图ID
			maxPlayerCnt, mapIDList = mergeFBPlayerCntDict[reqMapID]
			minPlayerCount = 0 # 最少的地图玩家人数
			minPlayerMapID = 0 # 最少人数的地图ID
			for mID in mapIDList:
			curMapPlayerCnt = gameWorld.GetGameWorldDictByKey(ChConfig.Map_WorldKey_MergeFBMapPlayerCnt % mID)
			if curMapPlayerCnt < maxPlayerCnt:
			playerMapID = mID
			break

			# 保存最少人数的地图ID信息
			if not minPlayerCount or (minPlayerCount and curMapPlayerCnt < minPlayerCount):
			minPlayerCount = curMapPlayerCnt
			minPlayerMapID = mID
			if not CrossRealmPlayer.IsCrossServerOpen():
			NotifyCode(curPlayer, "CrossMatching18")
			return

			# 如果没有人数未满的活动地图，则分配到人数较少的地图
			if not playerMapID:
			playerMapID = minPlayerMapID

			# 更新分配信息
			if playerMapID:
			mapPlayerCnt = gameWorld.GetGameWorldDictByKey(ChConfig.Map_WorldKey_MergeFBMapPlayerCnt % playerMapID) + 1
			gameWorld.SetGameWorldDict(ChConfig.Map_WorldKey_MergeFBMapPlayerCnt % playerMapID, mapPlayerCnt)
			gameWorld.SetGameWorldDict(ChConfig.Map_WorldKey_MergeFBMapPlayerID % (playerMapID, mapPlayerCnt), playerID)
			gameWorld.SetGameWorldDict(ChConfig.Map_WorldKey_MergeFBPlayerMapID % (reqMapID, playerID), playerMapID)
			GameWorld.Log("分配跨服活动玩家所属地图: plaeyrID=%s,reqMapID=%s,分配MapID=%s,mapPlayerCnt=%s"
			% (playerID, reqMapID, playerMapID, mapPlayerCnt))

			return playerMapID
			if curPlayer.GetHP() <= 0:
			NotifyCode(curPlayer, "CrossMap4")
			return

			if PlayerCrossRealmPK.GetIsCrossPKMatching(curPlayer):
			NotifyCode(curPlayer, "CrossMap3")
			return

			if PlayerState.IsInPKState(curPlayer):
			NotifyCode(curPlayer, "SingleEnterPK", [mapID])
			return

			GY_Query_CrossRealmReg.RegisterEnterCrossServer(curPlayer, mapID)
			return

			##玩家进入副本
			# @param curPlayer 玩家实例
			@@ -1649,13 +1634,13 @@
			# NotifyCode(curPlayer, 'jiazu_xyj_671654')
			# return

			#跨服活动人数分流处理
			if GameWorld.IsMergeServer():
			reqMapID = mapID
			mapID = __GetMergeFBPlayerMapID(curPlayer, reqMapID)
			if not mapID:
			GameWorld.ErrLog("找不到可分配进入的跨服活动地图ID! reqMapID=%s" % reqMapID)
			return
			# #跨服活动人数分流处理
			# if GameWorld.IsCrossServer():
			# reqMapID = mapID
			# mapID = __GetMergeFBPlayerMapID(curPlayer, reqMapID)
			# if not mapID:
			# GameWorld.ErrLog("找不到可分配进入的跨服活动地图ID! reqMapID=%s" % reqMapID)
			# return

			#过滤封包地图ID
			if not GameWorld.GetMap().IsMapIDExist(mapID):
			@@ -1717,6 +1702,14 @@
			else:
			bossID = GameLogic_SealDemon.CurFBLineBOSSID(lineID)
			extendParamList = [bossID]
			elif mapID == ChConfig.Def_FBMapID_ZhuXianBoss:
			bossID = GameLogic_ZhuXianBoss.CurFBLineBOSSID(lineID)
			extendParamList = [bossID, -1]
			enterCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_EnterFbCntDay % ChConfig.Def_FBMapID_ZhuXianBoss)
			if enterCnt >= FBCommon.GetEnterFBMaxCnt(curPlayer, ChConfig.Def_FBMapID_ZhuXianBoss):
			if curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ZhuXianBossHelpCnt):
			extendParamList = [bossID, curPlayer.GetFamilyID()]

			SendToGameServerEnterFB(curPlayer, mapID, lineID, tick, extendParamList)
			return

			@@ -1781,6 +1774,18 @@
			NotifyCode(curPlayer, "SingleEnterPK", [mapID])
			return ShareDefine.EntFBAskRet_PKState

			## 跨服PK匹配中
			if PlayerCrossRealmPK.GetIsCrossPKMatching(curPlayer):
			if isNotify:
			NotifyCode(curPlayer, "CrossMatching8", [mapID])
			return ShareDefine.EntFBAskRet_CrossPKMatching

			## 跨服地图中
			if GetCrossMapID(curPlayer) and mapID not in ChConfig.Def_CrossMapIDList:
			if isNotify:
			NotifyCode(curPlayer, "CrossMap5", [mapID])
			return ShareDefine.EntFBAskRet_InCrossMap

			#===============================================================================================
			# # 这里不做状态限制，由前端处理，因为策划要根据界面来处理，同一传送功能有可能在不同界面
			# # PK状态检查
			@@ -1806,6 +1811,12 @@
			if isNotify:
			NotifyCode(curPlayer, "Carry_lhs_697674")
			return ShareDefine.EntFBAskRet_Sit

			if curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ClientCustomScene):
			if isNotify:
			NotifyCode(curPlayer, "Carry_lhs_697674")
			GameWorld.Log("客户端自定义场景下无法进入副本!", curPlayer.GetPlayerID())
			return ShareDefine.EntFBAskRet_Other

			if playerAction in ChConfig.Def_Player_Cannot_TransState:
			#Carry_lhs_697674：您当前所处的状态不能进行传送!
			@@ -2004,16 +2015,18 @@
			sendPack.FuncLineID = funcLineID

			NetPackCommon.SendFakePack(curPlayer, sendPack)
			GameWorld.Log("准备切换地图", curPlayer.GetID())
			return

			# 通知开始切换地图
			def NotifyStartChangeMap(curPlayer):
			GameWorld.DebugLog("通知开始切换地图, NotifyStartChangeMap")
			sendPack = ChPyNetSendPack.tagMCStartChangeMap()
			sendPack.Clear()
			sendPack.MapID = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ChangeMapID)
			sendPack.FuncLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_ReqFBFuncLine)
			NetPackCommon.SendFakePack(curPlayer, sendPack)

			GameWorld.Log("通知开始切换地图", curPlayer.GetID())
			return

			#---------------------------------------------------------------------
			@@ -2113,7 +2126,8 @@
			if PlayerTJG.GetIsTJG(curPlayer):
			GameWorld.DebugLog("脱机的玩家不处理分流！", curPlayer.GetPlayerID())
			return tagLineID

			if GameWorld.IsCrossServer():
			return tagLineID
			# 非常规地图之间的切换不处理
			if curMapID not in PyGameData.g_commMapLinePlayerCountDict or tagMapID not in PyGameData.g_commMapLinePlayerCountDict:
			return tagLineID
			@@ -2749,7 +2763,9 @@
			def HaveMoneyEx(curPlayer, TYPE_Price, Price, needNotify=True):
			if Price < 0:
			return []

			if TYPE_Price == ShareDefine.TYPE_Price_Gold_Paper_Money:
			TYPE_Price = IPY_GameWorld.TYPE_Price_Gold_Money #新版无绑玉，原先绑玉再仙玉的扣法改成扣仙玉 2019/3/26

			if TYPE_Price in [IPY_GameWorld.TYPE_Price_Gold_Money, IPY_GameWorld.TYPE_Price_Gold_Paper,
			IPY_GameWorld.TYPE_Price_Silver_Money, IPY_GameWorld.TYPE_Price_Silver_Paper]:
			if HaveMoney(curPlayer, TYPE_Price, Price, needNotify):
			@@ -2852,12 +2868,7 @@
			SetPlayerCurrency(curPlayer, type_Price, curCurrency - price)
			else:
			GameWorld.Log("付费金钱异常 type_Price = %s" % (type_Price), curPlayer.GetPlayerID())
			return False

			#添加跨服操作事件
			if costType in ChConfig.MergeServerCanCostType:
			eventInfo = [type_Price, price, costType, infoDict, quantity, costVIPGold]
			PlayerMergeEvent.AddMSPlayerEvent(curPlayer.GetPlayerID(), PlayerMergeEvent.Def_MSPEvent_PayMoney, eventInfo)
			return False

			#付款以后后续操作
			__PayMoneyAfter(curPlayer, type_Price, price, costType, infoDict, quantity, costVIPGold)
			@@ -2964,10 +2975,7 @@
			PlayerCostRebate.AddCostRebateGold(curPlayer, costType, price, infoDict)
			# 绝版降临
			PlayerFairyCeremony.AddFCCostGold(curPlayer, costType, price)
			# 消费VIP
			# if costVIPGold < 0:
			# costVIPGold = price
			#PlayerCostVIP.AddCostVIPExp(curPlayer, costType, costVIPGold)
			PlayerNewFairyCeremony.AddFCCostGold(curPlayer, costType, price)

			# 事件汇报
			#===========================================================================
			@@ -3054,6 +3062,12 @@
			if value < 0:
			GameWorld.Log('玩家获得金钱异常， value = %s , priceType = %s ,' % (value, priceType))
			return

			if GameWorld.IsCrossServer():
			serverGroupID = GetPlayerServerGroupID(curPlayer)
			msgInfo = {"PlayerID":curPlayer.GetPlayerID(), "MoneyType":priceType, "Value":value, "GiveType":giveType, "AddDataDict":addDataDict}
			GameWorld.SendMsgToClientServer(ShareDefine.CrossServerMsg_GiveMoney, msgInfo, [serverGroupID])
			return True

			if priceType == IPY_GameWorld.TYPE_Price_Gold_Money:
			if curPlayer.GetGold() + value > ChConfig.Def_PlayerTotalMoney_Gold:
			@@ -3378,22 +3392,33 @@

			return int(addPoint)

			def GetAllPointByLV(curPlayer):
			##获取当前等级可得到属性点数
			openLV = GameFuncComm.GetFuncLimitLV(ShareDefine.GameFuncID_AddPoint)
			curLV = curPlayer.GetLV()
			if curLV < openLV:
			return 0
			addPointDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAddPoint", 1, {})
			initFreePoint = IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 2)
			setFreePoint = initFreePoint
			for lv in xrange(openLV, curLV+1):
			setFreePoint += GameWorld.GetDictValueByRangeKey(addPointDict, lv, 0)
			return setFreePoint

			def DoAddPointOpen(curPlayer):
			'''加点功能开启处理给自由属性点及老号处理
			清除老服玩家未加点的点数（清零），以前加的加点属性不清除，属性不变，战力不减，根据最新的加点开启等级和老服玩家的当前等级，相差的差值给予玩家对应的加点点数'''
			beforeFreePoint = curPlayer.GetFreePoint()
			addPointDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAddPoint", 1, {})
			initFreePoint = IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 2)
			openLV = GameFuncComm.GetFuncLimitLV(ShareDefine.GameFuncID_AddPoint)
			setFreePoint = initFreePoint

			setFreePoint = GetAllPointByLV(curPlayer)
			curLV = curPlayer.GetLV()
			for lv in xrange(openLV, curLV+1):
			setFreePoint += GameWorld.GetDictValueByRangeKey(addPointDict, lv, 0)
			addDataDict = {'beforeFreePoint':beforeFreePoint}
			DataRecordPack.DR_Freepoint(curPlayer, "AddPointOpen", setFreePoint, addDataDict)
			curPlayer.SetFreePoint(setFreePoint)
			DataRecordPack.DR_Freepoint(curPlayer, "AddPointOpen", setFreePoint, addDataDict)
			GameWorld.DebugLog(' 加点功能开启处理 beforeFreePoint=%s,curLV=%s, setFreePoint=%s'%(beforeFreePoint, curLV, setFreePoint), curPlayer.GetID())
			return


			#---------------------------------------------------------------------

			## 功能模块战斗力类
			@@ -3499,6 +3524,13 @@
			FinalHurtReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FinalHurtReduce) # 最终固定伤害减少
			DamagePerPVP = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_DamagePerPVP) * fpParam.GetCftDamagePerPVP() # 伤害输出计算百分比PVP
			DamagePerPVPReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_DamagePerPVPReduce) * fpParam.GetCftDamagePerPVPReduce() # 伤害输出计算百分比PVP减少
			JobAHurtAddPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobAHurtAddPer) * fpParam.GetCftJobAHurtAddPer() # 对目标战士伤害加成
			JobBHurtAddPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobBHurtAddPer) * fpParam.GetCftJobBHurtAddPer() # 对目标法师伤害加成
			JobCHurtAddPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobCHurtAddPer) * fpParam.GetCftJobCHurtAddPer() # 对目标弓箭伤害加成
			JobAAtkReducePer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobAAtkReducePer) * fpParam.GetCftJobAAtkReducePer() # 战士攻击伤害减免
			JobBAtkReducePer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobBAtkReducePer) * fpParam.GetCftJobBAtkReducePer() # 法师攻击伤害减免
			JobCAtkReducePer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobCAtkReducePer) * fpParam.GetCftJobCAtkReducePer() # 弓箭攻击伤害减免

			ComboRate = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_ComboRate) # 连击几率
			ComboDamPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_ComboDamPer) # 连击伤害
			#MaxProDef = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_MaxProDef) # 最大防护值
			@@ -3626,15 +3658,6 @@
			return True

			#---------------------------------------------------------------------
			## 获取下一次转生所需等级
			def GetNextReincarnationLV(self, curPlayer):
			Reincarnation_ConditionDict = ReadChConfig.GetEvalChConfig("Reincarnation_Condition")
			curReinCnt = curPlayer.GetReincarnationLv() # 当前转生次数
			nextReinCnt = curReinCnt + 1
			nextReinLV = IpyGameDataPY.GetFuncCfg("PlayerMaxLV")
			if nextReinCnt in Reincarnation_ConditionDict:
			nextReinLV = Reincarnation_ConditionDict[nextReinCnt][0]
			return nextReinLV

			## 加经验值
			# @param self 类实例
			@@ -3658,10 +3681,6 @@
			#副本获得经验, 无论获得多少经验均需通知, 有些副本逻辑需要通过获得经验时机处理
			if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
			FBLogic.OnGetExp(curPlayer, finalAddExp, expViewType)

			# 跨服中获得经验
			if finalAddExp and GameWorld.IsMergeServer():
			PlayerMergeEvent.AddMSPlayerEvent(curPlayer.GetPlayerID(), PlayerMergeEvent.Def_MSPEvent_AddExp, finalAddExp)

			return finalAddExp

			@@ -3669,7 +3688,6 @@
			if addExp == 0:
			# 不进入计算
			return addExp, expViewType
			#nextReinLV = self.GetNextReincarnationLV(curPlayer)

			#取得人物当前经验
			#curTotalExp = GetPlayerTotalExp(curPlayer)
			@@ -3688,7 +3706,7 @@
			# 检查最大等级
			if curLV >= maxLV and curTotalExp >= maxLVExpStore:
			self.__NotifyExpFull(curPlayer, "GeRen_admin_825676")
			GameWorld.DebugLog("经验已满！已满级！curLV=%s" % (curLV), curPlayer.GetPlayerID())
			#GameWorld.DebugLog("经验已满！已满级！curLV=%s" % (curLV), curPlayer.GetPlayerID())
			return 0, expViewType

			# 杀怪
			@@ -3715,7 +3733,7 @@
			# if expViewType == ShareDefine.Def_ViewExpType_KillNPC:
			# #mapID = GameWorld.GetMap().GetMapID()
			# #if mapID in ChConfig.Def_FBMapID_BZZDAll:
			# # nobleVIPOuterRate = PlayerCostVIP.GetBZZDExpAddRate(curPlayer)
			# # nobleVIPOuterRate = ...
			# # #nobleVIPAddExp += 0 if not nobleVIPOuterRate else int(addExp * nobleVIPOuterRate / float(ChConfig.Def_MaxRateValue))
			# # nobleVIPAddExp += nobleVIPOuterRate
			#
			@@ -3923,7 +3941,7 @@
			PlayerGreatMaster.Sync_GreatMasterFreeSkillPoint(curPlayer)
			# 升级需要执行的游戏功能处理
			GameFuncComm.DoFuncOpenLogic(curPlayer)
			ChEquip.CalcEquips_OutOfPrint(curPlayer) # 缓存绝版属性
			#ChEquip.CalcEquips_OutOfPrint(curPlayer) # 缓存绝版属性
			if aftLV%10 == 0:
			# 控制下刷新次数
			PlayerPet.CalcPetItemAddPlayerAttr(curPlayer) # 宠物有随等级变化的技能
			@@ -3940,7 +3958,7 @@
			# 记录开服活动冲级数据
			OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_LV, curPlayer.GetLV())
			#神秘限购
			FunctionNPCCommon.MysticalShopOpen(curPlayer, befLV, aftLV)
			FunctionNPCCommon.MysticalLimitShopOpen(curPlayer, befLV, aftLV)
			#不需要做升级任务, 设置玩家经验
			SetPlayerTotalExp(curPlayer, curTotalExp)
			return
			@@ -3954,51 +3972,72 @@
			job = curPlayer.GetJob()

			lvAttrDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAttr%s" % job, 1)
			pointAttrDict = IpyGameDataPY.GetFuncEvalCfg("PointAttr%s" % job, 1)

			if not lvAttrDict:
			GameWorld.ErrLog('无此职业等级刷属性配置!job=%s' % (job), curPlayerID)
			return

			if not pointAttrDict:
			GameWorld.ErrLog('无此职业属性点刷属性配置!job=%s' % (job), curPlayerID)
			return

			#参与计算的玩家基础属性
			LV = curPlayer.GetLV()
			STR = curPlayer.GetSTR()
			PNE = curPlayer.GetPNE()
			PHY = curPlayer.GetPHY()
			CON = curPlayer.GetCON()
			baseSTR = curPlayer.GetBaseSTR()
			basePNE = curPlayer.GetBasePNE()
			basePHY = curPlayer.GetBasePHY()
			baseCON = curPlayer.GetBaseCON()
			GameWorld.DebugLog("CalcRoleBaseAttr LV=%s,STR=(%s~%s),PNE=(%s~%s),PHY=(%s~%s),CON=(%s~%s)"
			% (LV, baseSTR, STR, basePNE, PNE, basePHY, PHY, baseCON, CON))

			allAttrList = [{} for _ in range(4)]

			# 职业初始属性
			roleBaseAttrDict = IpyGameDataPY.GetFuncEvalCfg("CreatRoleBaseAttr", 1)
			if job in roleBaseAttrDict:
			for attrEffID, value in roleBaseAttrDict[job].items():
			CalcAttrDict_Type(attrEffID, value, allAttrList)
			for roleBaseAttrID, value in roleBaseAttrDict[job].items():
			CalcAttrDict_Type(roleBaseAttrID, value, allAttrList)
			#GameWorld.DebugLog("初始加属性: %s" % allAttrList)

			for attrEffID, formula in lvAttrDict.items():
			calcValue = eval(FormulaControl.GetCompileFormula("LVUPAttr%s_%s" % (job, attrEffID), formula))
			CalcAttrDict_Type(attrEffID, calcValue, allAttrList)
			#GameWorld.DebugLog(" attrEffID=%s,value=%s" % (attrEffID, calcValue))

			# 等级成长属性
			LV = curPlayer.GetLV()
			for lvAttrID, formula in lvAttrDict.items():
			calcValue = eval(FormulaControl.GetCompileFormula("LVUPAttr%s_%s" % (job, lvAttrID), formula))
			CalcAttrDict_Type(lvAttrID, calcValue, allAttrList)
			#GameWorld.DebugLog(" lvAttrID=%s,calcValue=%s" % (lvAttrID, calcValue))
			#GameWorld.DebugLog("等级加属性: %s" % allAttrList)

			for attrEffID, formula in pointAttrDict.items():
			calcValue = eval(FormulaControl.GetCompileFormula("PointAttr%s_%s" % (job, attrEffID), formula))
			CalcAttrDict_Type(attrEffID, calcValue, allAttrList)
			#GameWorld.DebugLog(" attrEffID=%s,value=%s" % (attrEffID, calcValue))
			# 属性点属性
			pointValueInfo = {ShareDefine.Def_Effect_Metal:[lambda curObj:GetMetal(curObj), lambda curObj, value:SetMetalQualityLV(curObj, value)],
			ShareDefine.Def_Effect_Wood:[lambda curObj:GetWood(curObj), lambda curObj, value:SetWoodQualityLV(curObj, value)],
			ShareDefine.Def_Effect_Water:[lambda curObj:GetWater(curObj), lambda curObj, value:SetWaterQualityLV(curObj, value)],
			ShareDefine.Def_Effect_Fire:[lambda curObj:GetFire(curObj), lambda curObj, value:SetFireQualityLV(curObj, value)],
			ShareDefine.Def_Effect_Earth:[lambda curObj:GetEarth(curObj), lambda curObj, value:SetEarthQualityLV(curObj, value)],
			}
			lingGenQualityAttrList = [{} for _ in range(4)]
			for pointAttrID, pointFuncInfo in pointValueInfo.items():
			pointValue = pointFuncInfo[0](curPlayer)
			pointFuncInfo[1](curPlayer, 0)
			if not pointValue:
			continue
			ipyData = IpyGameDataPY.GetIpyGameData("RolePoint", pointAttrID)
			if not ipyData:
			continue
			# 每点属性
			perPointAddAttrDict = ipyData.GetAddAttrInfoPerPoint()
			for perPointAttrID, perPointAttrValue in perPointAddAttrDict.items():
			pointAddValue = perPointAttrValue * pointValue
			CalcAttrDict_Type(perPointAttrID, pointAddValue, allAttrList)
			#GameWorld.DebugLog(" 属性点(%s)加属性: pointValue=%s,perPointAttrID=%s,pointAddValue=%s" % (pointAttrID, pointValue, perPointAttrID, pointAddValue))

			# 点数品质属性
			curPQLV = 0
			pqIntervalList = ipyData.GetPointQualityIntervalList()
			for pqLV, pqValue in enumerate(pqIntervalList, 1):
			if pointValue >= pqValue:
			curPQLV = pqLV
			else:
			break
			pointFuncInfo[1](curPlayer, curPQLV)
			if not curPQLV:
			continue
			pqAttrID = ipyData.GetPointQualityAttrID()
			pqAttrValueList = ipyData.GetPointQualityAttrValueList()
			pqAttrValue = 0 if curPQLV > len(pqAttrValueList) else pqAttrValueList[curPQLV - 1]
			CalcAttrDict_Type(pqAttrID, pqAttrValue, lingGenQualityAttrList)
			#GameWorld.DebugLog(" 属性点(%s)品阶等级属性: curPQLV=%s,pqAttrID=%s,pqAttrValue=%s" % (pointAttrID, curPQLV, pqAttrID, pqAttrValue))

			#GameWorld.DebugLog("等级属性点加属性: %s" % allAttrList)

			SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_RoleBase, allAttrList)
			#GameWorld.DebugLog("灵根品阶等级属性: %s" % lingGenQualityAttrList)
			SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_RoleBase, allAttrList)
			SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_LingGenQuailty, lingGenQualityAttrList)
			return

			#---------------------------------------------------------------------
			@@ -4088,14 +4127,15 @@
			PlayerPet.CalcPetItemAddPlayerAttr(curPlayer)
			PlayerRune.RefreshRuneAttr(curPlayer)
			PlayerMagicWeapon.CalcMagicWeaponAttr(curPlayer)
			PlayerMagicWeapon.CalcMagicWeaponSoulAttr(curPlayer)
			PlayerSuccess.CalcSuccessAttr(curPlayer)
			PlayerVip.CalcVIPAttr(curPlayer)
			PlayerRefineStove.CalcStoveAttr(curPlayer)
			PlayerFamilyTech.CalcFamilyTechAttr(curPlayer)
			PlayerEquipDecompose.RefreshEDAttr(curPlayer)
			PlayerDogz.RefreshDogzAttr(curPlayer)
			#EquipZhuXian.CalcZhuXianAttr(curPlayer)
			PlayerGatherSoul.RefreshGatherSoulAttr(curPlayer)
			PlayerCoat.CalcClothesCoatSkinAttr(curPlayer)
			self.RefreshAllState(isForce=True)
			GameWorld.DebugLog("End ReCalcAllState!!!")
			return
			@@ -4174,40 +4214,34 @@

			def RefreshPlayerAttrStateEx(self):
			''' 本项目刷属性规则
			功能属性层级一(线性层级、非线性层级)
			功能属性层级二(线性层级、非线性层级)
			...
			固定属性层级
			buff层级

			1. 初始化
			属性：
			1.固定属性：如攻击+100
			2.百分比属性：如攻击+5%，百分比加成基值仅为固定属性，百分比加成属性值不被除buff百分比外的任何百分比属性二次加成

			功能属性层级一、
			2.基础属性计算
			3.战斗属性计算
			线性层级属性: 基础层级属性 + 功能层级属性
			基础层级属性：角色基础属性（等级提升 + 属性点提升） + 装备物品表基础属性 + 部位强化基础属性
			功能层级属性：神兵 + 坐骑 + 全身部位强化星级累加 + 珍品 + 时装 + 套装 + 宝石 + 战盟科技 + 符文 + 守护等
			层级：
			1.属性层级：所有功能同一层级
			2.buff层级：百分比可对功能百分比加成的属性进行二次加成

			功能模块：定义一个功能，比如灵根模块，一个模块可能包含多个功能点
			功能点：某个模块下的各个属性功能点，如灵根模块可能包含灵根基础、灵根品质两个功能点属性

			百分比加成值：百分比加成属性值不被除buff百分比外的任何百分比属性2次加成
			1.功能内部属性百分比加成：功能百分比属性对自己功能固定值加成
			2.功能交叉属性百分比加成：功能百分比属性对其他功能固定值加成
			3.功能固定属性百分比加成：功能百分比属性对所有功能固定值加成
			4.buff层级百分比：对所有属性进行二次加成

			技能属性：固定值不享受固定百分比加成

			注意：该层中还包含针对基础属性或功能属性的数值百分比提升，此提升值也是累加到线性层级属性
			如: 【基础攻击百分比】即对基础属性中攻击属性百分比提升
			【神兵生命属性百分比】即对神兵功能属性中生命属性百分比提升
			类似此类属性并不是真正意义上的非线性属性，仅是对某个功能或功能组的对应属性进行百分比提升，最终的提升值还是算如线性属性层

			非线性层级属性: 即整体层级百分比增加属性
			直接以当前属性为基值进行属性百分比提升
			功能属性层级二、
			...

			4.固定属性:
			附加的固定值属性，该属性在非线性计算之后，直接累加，不算入非线性属性的基值
			buff层级：
			1.不算战力
			2.先算百分比加成再加固定值

			5.计算以上所有属性的战斗力

			6.buff层级：
			固定值buff，直接累加数值
			百分比buff：真正的最最最外层，直接按百分比提升对应的属性值
			注：该层提升的属性不算战斗力
			属性算法：
			模块固定属性 = 功能点A固定值 + 功能点B固定值 + ...
			固定总属性 = 模块A固定值 + 模块B固定值 + ...
			无buff总属性 = 固定总属性 + 内部百分比加成值 + 交叉百分比加成 + 固定总属性百分比加成 + 技能百分比对固定属性加成 + 技能固定值
			含buff总属性 = 无buff总属性 * buff百分比加成 + buff固定值
			'''
			curPlayer = self.__Player

			@@ -4230,9 +4264,10 @@
			curPlayer.BeginRefreshState()
			self.ResetFightPowerObj()
			#self.PrintAttr(curPlayer, "重置后")
			notAttrList = [{} for _ in range(4)]

			# 1.初始化人物各项状态及属性
			self.InitPlayerState()
			self.InitPlayerState()
			#self.PrintAttr(curPlayer, "初始化")

			# 功能属性层级一...
			@@ -4240,21 +4275,19 @@
			# 2.1 获取所有功能计算点计算的属性值, 统计基础属性累加
			baseAttrDict = {}
			baseAttrNolineDict = {}
			roleBaseAttrInfo = [{} for _ in range(4)]
			funcAttrInfoList = []
			funcAttrLen = len(ChConfig.CalcAttrFuncList)
			funcAttrInfoList = [[{} for _ in range(4)]] * funcAttrLen
			funcInsidePerAttrList = [{}] * funcAttrLen # 功能内部百分比附加属性
			for funcIndex in ChConfig.CalcAttrFuncList:
			if funcIndex in ChConfig.CalcAttrExFuncListNoFightPower:
			# 此类功能不算战斗力
			funcAttrInfoList.append([{} for _ in range(4)]) # 只为防止后面访问列表元素时不越界, 功能点分类可无视编号顺序
			continue

			# 基础属性等功能汇总完后统一刷新，因为各功能可能会加属性点数
			if funcIndex == ChConfig.Def_CalcAttrFunc_RoleBase:
			funcAttrInfoList.append(roleBaseAttrInfo)
			if funcIndex in [ChConfig.Def_CalcAttrFunc_RoleBase, ChConfig.Def_CalcAttrFunc_LingGenQuailty]:
			continue
			attrInfo = GetCalcAttrListValue(curPlayer, funcIndex)
			GameWorld.DebugLog("功能点属性: %s, %s" % (funcIndex, attrInfo))
			funcAttrInfoList.append(attrInfo)
			attrInfo, insidePerAttrDict = GetCalcAttrListValue(curPlayer, funcIndex)
			if attrInfo == notAttrList and not insidePerAttrDict:
			continue
			GameWorld.DebugLog("功能点属性: %s, %s, 内层百分比附加: %s" % (funcIndex, attrInfo, insidePerAttrDict))
			funcAttrInfoList[funcIndex] = attrInfo
			funcInsidePerAttrList[funcIndex] = insidePerAttrDict
			# 不同功能点间的数值累加，需使用支持衰减递增的计算方式
			AddAttrDictValue(baseAttrDict, attrInfo[ChConfig.CalcAttr_Base])
			AddAttrDictValue(baseAttrNolineDict, attrInfo[ChConfig.CalcAttr_BaseNoline])
			@@ -4268,25 +4301,21 @@

			# 功能有加基础属性值，这里再重新刷新一下基础属性, 基础属性会影响战斗属性, 每次都刷新角色基础属性
			self.CalcRoleBaseAttr(curPlayer)
			roleBaseAttrInfo = GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_RoleBase)
			roleBaseAttrInfo, roleInsidePerAttrDict = GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_RoleBase)
			lingGenQualityAttrList, lingGenQualityInsidePerAttrDict = GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_LingGenQuailty)
			funcAttrInfoList[ChConfig.Def_CalcAttrFunc_RoleBase] = roleBaseAttrInfo
			GameWorld.DebugLog("功能点属性: %s, %s" % (ChConfig.Def_CalcAttrFunc_RoleBase, roleBaseAttrInfo))
			funcInsidePerAttrList[ChConfig.Def_CalcAttrFunc_RoleBase] = roleInsidePerAttrDict
			funcAttrInfoList[ChConfig.Def_CalcAttrFunc_LingGenQuailty] = lingGenQualityAttrList
			funcInsidePerAttrList[ChConfig.Def_CalcAttrFunc_LingGenQuailty] = lingGenQualityInsidePerAttrDict
			GameWorld.DebugLog("功能点属性: %s, %s, 内层百分比附加: %s" % (ChConfig.Def_CalcAttrFunc_RoleBase, roleBaseAttrInfo, roleInsidePerAttrDict))
			GameWorld.DebugLog("功能点属性: %s, %s, 内层百分比附加: %s" % (ChConfig.Def_CalcAttrFunc_LingGenQuailty, lingGenQualityAttrList, lingGenQualityInsidePerAttrDict))

			#self.PrintAttr(curPlayer, "基础后")

			# 3.计算战斗属性
			# 3.1 战斗属性层级交叉影响基值数值汇总
			# 装备基础
			equipBaseAttrList = AddAttrListValue([funcAttrInfoList[ChConfig.Def_CalcAttrFunc_EquipBaseWeapon],
			funcAttrInfoList[ChConfig.Def_CalcAttrFunc_EquipBaseArmor],
			funcAttrInfoList[ChConfig.Def_CalcAttrFunc_EquipBaseRelics],
			])
			#GameWorld.DebugLog("装备基础: %s" % equipBaseAttrList)

			# 基础层级(角色基础属性、装备基础属性、强化基础属性)
			# 基础层级(角色基础属性)
			baseAttrList = AddAttrListValue([funcAttrInfoList[ChConfig.Def_CalcAttrFunc_RoleBase],
			equipBaseAttrList,
			funcAttrInfoList[ChConfig.Def_CalcAttrFunc_PlusBase],
			])
			#GameWorld.DebugLog("基础层级: %s" % baseAttrList)

			@@ -4296,11 +4325,6 @@
			ChConfig.TYPE_Calc_BaseDefAddPer:baseAttrList,
			ChConfig.TYPE_Calc_BaseHitAddPer:baseAttrList,
			ChConfig.TYPE_Calc_BaseMissAddPer:baseAttrList,
			ChConfig.TYPE_Calc_EquipBaseAddPer:equipBaseAttrList,
			ChConfig.TYPE_Calc_WeaponAtkAddPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_EquipBaseWeapon],
			ChConfig.TYPE_Calc_RelicsAtkAddPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_EquipBaseRelics],
			ChConfig.TYPE_Calc_ArmorMaxHPAddPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_EquipBaseArmor],
			ChConfig.TYPE_Calc_ArmorDefAddPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_EquipBaseArmor],
			ChConfig.TYPE_Calc_GodWeaponMaxHPPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_GodWeapon],
			ChConfig.TYPE_Calc_GodWeaponAtkPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_GodWeapon],
			ChConfig.TYPE_Calc_StoneMaxHPPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Stone],
			@@ -4308,13 +4332,10 @@
			ChConfig.TYPE_Calc_StoneBasePer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Stone],
			ChConfig.TYPE_Calc_RealmBasePer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Prestige],
			ChConfig.TYPE_Calc_HorseAtkPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Horse],
			ChConfig.TYPE_Calc_HorcruxBasePer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Horcrux],
			ChConfig.TYPE_Calc_WingHPPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Wing],
			ChConfig.TYPE_Calc_SuiteBasePer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Suit],
			ChConfig.TYPE_Calc_PlusBaseAtkPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_PlusBase],
			}
			# 3.2 统计各功能之间非线性属性交叉影响累加
			funcAddAttrPerInfoDict = {} # 百分比交叉影响所提升的属性值 {功能属性编号:{提升的属性类型:数值, ...}, ...}
			funcCrossAttrPerInfoDict = {} # 百分比交叉影响所提升的属性值 {功能属性编号:{提升的属性类型:数值, ...}, ...}
			for i, funcAttrList in enumerate(funcAttrInfoList):
			battleNoLineAttrDict = funcAttrList[ChConfig.CalcAttr_BattleNoline] # 暂写死只取战斗非线性的
			if not battleNoLineAttrDict:
			@@ -4340,79 +4361,90 @@
			if addAttrDict:
			# 增加的数值统计到百分比属性所属功能点
			# 如符文有个武器攻击百分比增加属性，增加的数值属于符文功能，不属于武器功能点的，只是基值使用了武器攻击
			funcAddAttrPerInfoDict[i] = addAttrDict # 先都统计完后再累加到对应功能属性里，不然可能会导致功能基值变更
			funcCrossAttrPerInfoDict[i] = addAttrDict # 先都统计完后再累加到对应功能属性里，不然可能会导致功能基值变更

			GameWorld.DebugLog("交叉影响属性: %s" % funcAddAttrPerInfoDict)
			# 交叉提升的属性值累加到对应功能上
			for i, addAttrDict in funcAddAttrPerInfoDict.items():
			# 这里累加的是到相同的功能点，直接累加，不做衰减处理
			GameWorld.AddDictValue(funcAttrInfoList[i][ChConfig.CalcAttr_Battle], addAttrDict)
			GameWorld.DebugLog("交叉影响属性: %s" % funcCrossAttrPerInfoDict)

			# 3.3 统计所有功能固定属性影响累加
			allFixAttrDict = {} # 固定属性层级总属性基值
			for funcIndex, funcAttrList in enumerate(funcAttrInfoList):
			# 技能模块不算计入功能固定属性、不计战力
			if funcIndex in ChConfig.CalcAttrFuncSkillList:
			continue
			AddAttrDictValue(allFixAttrDict, funcAttrList[ChConfig.CalcAttr_Battle])

			# 3.3 累加以上已统计的所有属性（视为整体层级，即非线性属性所需要的基值）
			allFuncAttrIndexList = []
			allFuncAttrInfoList, attrInfoExList = [], [] # 整理功能层级属性信息列表, 额外附加固定值属性信息列表
			for funcIndex, attrInfo in enumerate(funcAttrInfoList):
			if funcIndex not in ChConfig.CalcAttrExFuncList:
			allFuncAttrIndexList.append(funcIndex)
			allFuncAttrInfoList.append(attrInfo)
			else:
			attrInfoExList.append(attrInfo)
			allAttrList = AddAttrListValue(allFuncAttrInfoList) # 不同功能点间的数值累加，需使用支持衰减递增的计算方式
			GameWorld.DebugLog("整体层级功能点: %s" % allFuncAttrIndexList)
			GameWorld.DebugLog("整体层级线性属性: %s" % allAttrList)

			# 第二层级属性
			allAttrExList = AddAttrListValue(attrInfoExList)
			GameWorld.DebugLog("附加层级功能点: %s" % ChConfig.CalcAttrExFuncList)
			GameWorld.DebugLog("附加层级线性属性: %s" % allAttrExList)

			# 初始化各功能点战斗力计算模块
			mfpObjAttrDict = {}
			for mfpType, attrFuncIndexList in ChConfig.MFPTypeAttrFuncIndexDict.items():
			if len(attrFuncIndexList) == 1:
			mfpAttrList = funcAttrInfoList[attrFuncIndexList[0]]
			else:
			mfpAttrList = AddAttrListValue([funcAttrInfoList[i] for i in attrFuncIndexList])
			fixAttrPerAddExDict = {} # 固定总属性百分比影响所提升的属性值 {功能属性编号:{提升的属性类型:数值, ...}, ...}
			for funcIndex, funcAttrList in enumerate(funcAttrInfoList):
			fixAddPerDict = funcAttrList[ChConfig.CalcAttr_BattleNoline]
			if not fixAddPerDict:
			continue
			addValueExDict = {}
			for fixAttrType, addPer in fixAddPerDict.items():
			if fixAttrType not in allFixAttrDict:
			continue
			curFixValue = allFixAttrDict[fixAttrType]
			addValueEx = int(curFixValue * addPer / 10000.0)
			addValueExDict[fixAttrType] = addValueEx
			fixAttrPerAddExDict[funcIndex] = addValueExDict

			#GameWorld.DebugLog("模块线性属性: mfpType=%s,%s" % (mfpType, mfpAttrList))
			mfpObj = self.GetModuleFightPowerObj(mfpType)
			mfpObj.SetCalcMFPBattleAttr(mfpAttrList)
			mfpObjAttrDict[mfpObj] = mfpAttrList[ChConfig.CalcAttr_BattleNoline]

			# 不加战力，但是有算属性的功能属性，如一些被动技能（战力在技能表里配置）
			skillNoFightPowerAttrList = [{} for _ in range(4)]
			SkillShell.CalcPassiveAttr_Effect(curPlayer, skillNoFightPowerAttrList) # 属性类技能与buff同层
			for funcIndex in ChConfig.CalcAttrExFuncListNoFightPower:
			skillNoFightPowerAttrList = AddAttrListValue([skillNoFightPowerAttrList, GetCalcAttrListValue(curPlayer, funcIndex)])
			GameWorld.DebugLog("无战力被动属性: %s" % skillNoFightPowerAttrList)
			GameWorld.DebugLog("固定属性总和: %s" % allFixAttrDict)
			GameWorld.DebugLog("固定百分比附加属性: %s" % fixAttrPerAddExDict)

			# 总属性 = 整体功能层级固定值*(1+功能层级百分比+特殊固定层级百分比+永久技能层级百分比)+特殊固定层级固定值+永久技能层级固定值
			allNoLineAttrDict = {}
			AddAttrDictValue(allNoLineAttrDict, allAttrList[ChConfig.CalcAttr_BattleNoline])
			AddAttrDictValue(allNoLineAttrDict, allAttrExList[ChConfig.CalcAttr_BattleNoline])
			AddAttrDictValue(allNoLineAttrDict, skillNoFightPowerAttrList[ChConfig.CalcAttr_BattleNoline])
			GameWorld.DebugLog("最终非线性属性: %s" % allNoLineAttrDict)

			# 整体层级属性增加到玩家身上
			CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, allAttrList[ChConfig.CalcAttr_Battle])
			#self.PrintAttr(curPlayer, "整体线")
			CalcNoLineEffect.ChangePlayerAttrInNoLineEffectList(curPlayer, allNoLineAttrDict, mfpObjAttrDict)
			#self.PrintAttr(curPlayer, "整非线")


			# 4.计算战力, 需在计算buff层之前计算
			# 4. 计算属性及战力, 需在计算buff层之前计算
			curLV = curPlayer.GetLV()
			fpParam = IpyGameDataPY.GetIpyGameData("FightPowerParam", curLV)
			mfpDict = {} # 模块战斗力
			for mfpObj in mfpObjAttrDict.keys():
			mfpDict[mfpObj.mfpType] = 0 if not fpParam else mfpObj.GetModuleFightPower(fpParam)
			mfpDict[mfpObj.mfpType] = mfpDict[mfpObj.mfpType] + curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPSkill % mfpObj.mfpType)
			mfpDict[mfpObj.mfpType] = mfpDict[mfpObj.mfpType] + curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPEx % mfpObj.mfpType)
			for mfpType, attrFuncIndexList in ChConfig.MFPTypeAttrFuncIndexDict.items():
			mfpAttrList = [{} for _ in range(4)]
			mfpAttrExDict = {}
			for funcIndex in attrFuncIndexList:
			funcAttrList = funcAttrInfoList[funcIndex]
			funcInsidePerAttrDict = funcInsidePerAttrList[funcIndex] # 功能点内部百分比加成属性
			funcCrossPerAttrDict = funcCrossAttrPerInfoDict.get(funcIndex, {}) # 功能点交叉百分比加成属性
			fixPerAttrDict = fixAttrPerAddExDict.get(funcIndex, {}) # 功能总固定属性百分比加成属性

			CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, funcAttrList[ChConfig.CalcAttr_Battle])
			CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, funcInsidePerAttrDict)
			CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, funcCrossPerAttrDict)
			CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, fixPerAttrDict)
			# 不算战力的
			if funcIndex in ChConfig.CalcAttrFuncNoFightPowerList or funcIndex in ChConfig.CalcAttrFuncSkillList:
			continue
			mfpAttrList = AddAttrListValue([mfpAttrList, funcAttrList])
			AddAttrDictValue(mfpAttrExDict, funcInsidePerAttrDict)
			AddAttrDictValue(mfpAttrExDict, funcCrossPerAttrDict)
			AddAttrDictValue(mfpAttrExDict, fixPerAttrDict)

			mfpObj = self.GetModuleFightPowerObj(mfpType)
			mfpObj.SetCalcMFPBattleAttr(mfpAttrList)
			for attrIndex, value in mfpAttrExDict.items():
			mfpObj.AddCalcMFPAttr(attrIndex, value)

			mfpValue = 0 if not fpParam else mfpObj.GetModuleFightPower(fpParam)
			mfpSkill = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPSkill % mfpObj.mfpType)
			mfpEx = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPEx % mfpObj.mfpType)
			mfpTotal = mfpValue + mfpSkill + mfpEx
			mfpDict[mfpObj.mfpType] = mfpTotal

			# 最后在附加上特殊附加层级线性属性、永久技能层级固定值
			CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, allAttrExList[ChConfig.CalcAttr_Battle])
			CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, skillNoFightPowerAttrList[ChConfig.CalcAttr_Battle])
			#self.PrintAttr(curPlayer, "固定层级")
			#GameWorld.DebugLog("整体层级线性属性: %s" % allAttrList)

			# 5.被动技能附加属性，不算战力
			passiveSkillAttrList = [{} for _ in range(4)]
			SkillShell.CalcPassiveAttr_Effect(curPlayer, passiveSkillAttrList) # 属性类技能与buff同层
			for funcIndex in ChConfig.CalcAttrFuncSkillList:
			passiveSkillAttrList = AddAttrListValue([passiveSkillAttrList, funcAttrInfoList[funcIndex]])
			GameWorld.DebugLog("无战力被动属性: %s" % passiveSkillAttrList)

			skillFixAttrExDict = {}
			skillFixAddPerDict = passiveSkillAttrList[ChConfig.CalcAttr_BattleNoline]
			for fixAttrType, addPer in skillFixAddPerDict.items():
			if fixAttrType not in allFixAttrDict:
			continue
			curFixValue = allFixAttrDict[fixAttrType]
			addValueEx = int(curFixValue * addPer / 10000.0)
			skillFixAttrExDict[fixAttrType] = addValueEx
			CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, passiveSkillAttrList[ChConfig.CalcAttr_Battle])
			CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, skillFixAttrExDict)

			#护盾值刷新
			self.__RefreshMaxProDef(beforeMaxProDef)
			@@ -4761,6 +4793,8 @@
			PlayerBillboard.UpdatePlayerFPTotalBillboard(curPlayer)
			# 记录开服活动数据
			OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_FightPower, totalFightPower)
			if beforeFightPower != totalFightPower:
			CrossPlayerData.OnPlayerFightPowerChange(curPlayer)
			return

			def __RefreshMoveSpeed(self, allAttrListBuffs):
			@@ -4835,33 +4869,6 @@

			#再根据BUFF 加上状态
			SkillShell.CalcBuffer_ActionState(curPlayer)
			#---------------------------------------------------------------------

			#---------------------------------------------------------------------
			## 存入数据库玩家基本属性
			# @param self 类实例
			# @return 返回值无意义
			# @remarks 存入数据库玩家基本属性
			def __SetPlayerStateInDB(self):
			curPlayer = self.__Player
			#力量
			curPlayerSTR = curPlayer.GetSTR()
			if curPlayer.GetTotalSTR() != curPlayerSTR:
			curPlayer.SetTotalSTR(curPlayerSTR)
			#真元
			curPlayerPNE = curPlayer.GetPNE()
			if curPlayer.GetTotalPNE() != curPlayerPNE:
			curPlayer.SetTotalPNE(curPlayerPNE)
			#筋骨
			curPlayerPHY = curPlayer.GetPHY()
			if curPlayer.GetTotalPHY() != curPlayerPHY:
			curPlayer.SetTotalPHY(curPlayerPHY)
			#体魄
			curPlayerCON = curPlayer.GetCON()
			if curPlayer.GetTotalCON() != curPlayerCON:
			curPlayer.SetTotalCON(curPlayerCON)

			return

			#---------------------------------------------------------------------
			## 刷新血量和魔
			@@ -4902,10 +4909,10 @@
			curPlayer.ClearBattleEffect()

			initAttrDict = {
			ChConfig.TYPE_Calc_AttrCurSTR:curPlayer.GetBaseSTR(),
			ChConfig.TYPE_Calc_AttrCurPNE:curPlayer.GetBasePNE(),
			ChConfig.TYPE_Calc_AttrCurPHY:curPlayer.GetBasePHY(),
			ChConfig.TYPE_Calc_AttrCurCON:curPlayer.GetBaseCON(),
			#ChConfig.TYPE_Calc_AttrCurSTR:curPlayer.GetBaseSTR(),
			#ChConfig.TYPE_Calc_AttrCurPNE:curPlayer.GetBasePNE(),
			#ChConfig.TYPE_Calc_AttrCurPHY:curPlayer.GetBasePHY(),
			#ChConfig.TYPE_Calc_AttrCurCON:curPlayer.GetBaseCON(),
			#ChConfig.TYPE_Calc_AttrSpeed:curPlayer.GetBaseSpeed(),
			ChConfig.TYPE_Calc_AttrAtkSpeed:ChConfig.Def_BaseAtkSpeed,
			ChConfig.TYPE_Calc_AttrFightExpRate:GameWorld.GetGameWorld().GetExpRate(),
			@@ -4933,6 +4940,12 @@
			if not curPlayer.GetCanAttack():
			curPlayer.SetCanAttack(True)

			#初始化灵根
			SetMetal(curPlayer, curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % ShareDefine.Def_Effect_Metal))
			SetWood(curPlayer, curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % ShareDefine.Def_Effect_Wood))
			SetWater(curPlayer, curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % ShareDefine.Def_Effect_Water))
			SetFire(curPlayer, curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % ShareDefine.Def_Effect_Fire))
			SetEarth(curPlayer, curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % ShareDefine.Def_Effect_Earth))
			return True

			#---------------------------------------------------------------------
			@@ -5347,35 +5360,6 @@
			if BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_SkillID_LimitSuperBuff, tick):

			PlayerControl(curPlayer).RefreshPlayerAttrByBuff()

			#---------------------------------------------------------------------
			##清除生产采集BUF
			# @param curPlayer 玩家实例
			# @param tick 时间戳
			# @param isLeaveServer 玩家是否离开服务器
			# @return 返回值无意义
			# @remarks 清除生产采集BUF
			def DelProduceBuff(curPlayer, tick, isLeaveServer=False):

			if not isLeaveServer:
			if curPlayer.GetPlayerAction() != IPY_GameWorld.paProduce:
			#玩家当前状态不在生产采集，不处理
			return

			#清除生产buff(ID20021)
			BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_ProduceBuffID, tick)

			#清除活动无敌Buff
			BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_SkillID_ActionWuDi, tick)

			if not isLeaveServer:
			#设置玩家空闲状态
			ChangePlayerAction(curPlayer, IPY_GameWorld.paNull)
			#通知客户端
			curPlayer.Notify_ProductionState(ChConfig.Def_EndProduction)

			#PlayerControl(curPlayer).RefreshAllState()
			return

			#---------------------------------------------------------------------
			##特殊状态处理
			@@ -5622,43 +5606,6 @@

			return totalExpRate

			#---------------------------------------------------------------------

			## 获取玩家基础属性点
			# @param job 职业类型
			# @return baseSTR, basePNE, basePHY, baseCON
			def GetPlayerBasePoint(job):
			baseSTR, basePNE, basePHY, baseCON = (0, 0, 0, 0)

			jobDict = IpyGameDataPY.GetFuncEvalCfg("CreatRolePoint%s" % job, 1)

			if not jobDict:
			GameWorld.ErrLog('CreatRolePoint, job = %s' % (job))
			return baseSTR, basePNE, basePHY, baseCON

			for key, value in jobDict.items():

			if type(key) == str:
			key = key.upper()

			if key in ['STR', ShareDefine.Def_Effect_STR]:
			baseSTR = value

			elif key in ['PNE', ShareDefine.Def_Effect_PNE]:
			basePNE = value

			elif key in ['PHY', ShareDefine.Def_Effect_PHY]:
			basePHY = value

			elif key in ['CON', ShareDefine.Def_Effect_CON]:
			baseCON = value

			else:
			GameWorld.ErrLog('CreatRolePoint, key = %s' % (key))

			return baseSTR, basePNE, basePHY, baseCON


			##记录玩家失去金钱的流向记录，消息中会记录玩家拥有的金钱信息
			# @param curPlayer 玩家实例
			# @param moneyType 金钱类型
			@@ -5689,7 +5636,6 @@
			# ֪ͨGsmeServer;
			# SendGameServerRefreshState(int inputType, int inputValue)

			# SetExAttr15 ~ 18 对应神兵类型等级，场景特效用

			# 禁言通知gameServer
			def SetGMForbidenTalk(curPlayer, value):
			@@ -5697,13 +5643,6 @@
			curPlayer.SendGameServerRefreshState(ShareDefine.CDBPlayerRefresh_ForbidenTalk, value)
			curPlayer.SendPropertyRefresh(ShareDefine.CDBPlayerRefresh_ForbidenTalk, value, False)
			return


			## 职业阶数
			def GetJobRank(curPlayer): return curPlayer.GetExAttr1()
			def SetJobRank(curPlayer, jobRank):
			curPlayer.SendGameServerRefreshState(IPY_GameWorld.CDBPlayerRefresh_ExAttr1, jobRank)
			return curPlayer.SetExAttr1(jobRank)

			## 队伍相关审核开关状态, joinReqCheck-入队申请是否需要审核; inviteCheck-组队邀请是否需要审核;
			def SetTeamCheckStateEx(curPlayer, joinReqCheck, inviteCheck): return SetTeamCheckState(curPlayer, joinReqCheck * 10 + inviteCheck)
			@@ -5714,9 +5653,13 @@
			def SetFBFuncLineID(curPlayer, funcLineID): return curPlayer.SetExAttr3(funcLineID, False, False)
			def GetFBFuncLineID(curPlayer): return curPlayer.GetExAttr3()

			## 跨服状态: 0-非跨服状态，1-跨服状态
			def GetCrossRealmState(curPlayer): return curPlayer.GetExAttr5()
			def SetCrossRealmState(curPlayer, value): curPlayer.SetExAttr5(value, False, True)
			## 跨服状态所在地图ID: 0-非跨服状态，非0-跨服状态对应的地图ID
			def GetCrossMapID(curPlayer): return curPlayer.GetExAttr5()
			def SetCrossMapID(curPlayer, value):
			curPlayer.SetExAttr5(value, False, True)
			if not value:
			CrossPlayerData.ClearCrossSyncDataCache(curPlayer)
			return

			## 铜钱点, 支持铜钱超20亿
			def GetSilver(curPlayer): return curPlayer.GetExAttr6() * ChConfig.Def_PerPointValue + curPlayer.GetSilver()
			@@ -5741,6 +5684,27 @@
			##聊天气泡框
			def GetChatBubbleBox(curPlayer): return curPlayer.GetExAttr10()
			def SetChatBubbleBox(curPlayer, value): return curPlayer.SetExAttr10(value, False, True)

			## 玩家所属服务器组ID
			def GetPlayerServerGroupID(curPlayer): return curPlayer.GetExAttr13()
			def UpdPlayerServerGroupID(curPlayer):
			# 更新自己的服务器组ID, 跨服服务器不处理
			if GameWorld.IsCrossServer():
			return
			serverGroupID = GameWorld.GetServerGroupID()
			if not serverGroupID:
			return
			playerServerGroupID = curPlayer.GetExAttr13()
			if playerServerGroupID != serverGroupID:
			curPlayer.SetExAttr13(serverGroupID, False, True)
			GameWorld.DebugLog("更新玩家所属服务器组ID: serverGroupID=%s" % serverGroupID)
			return

			##影响外观的3部位索引记录 123456789 123:武器格子索引 456：副手 789：衣服
			def GetFaceEquipIndexList(curPlayer):
			attr15 = curPlayer.GetExAttr15()
			return [attr15%1000, attr15/1000%1000, attr15/1000000]
			def SetFaceEquipIndex(curPlayer, value): return curPlayer.SetExAttr15(value)

			##获得玩家威望值
			def GetPrestige(curPlayer): return 0
			@@ -5837,10 +5801,6 @@

			SetZhenQi(curPlayer, value)
			#EventReport.WriteEvent_add_zhenqi(curPlayer, eventName, eventData, addValue, value)

			if GameWorld.IsMergeServer():
			eventInfo = [addValue, eventName, eventData]
			PlayerMergeEvent.AddMSPlayerEvent(curPlayer.GetPlayerID(), PlayerMergeEvent.Def_MSPEvent_AddZhenQi, eventInfo)
			return True


			@@ -5932,19 +5892,6 @@
			def SetLongMaiLV(curPlayer, value):
			return
			#---------------------------------------------------------------------------
			## 设置玩家跨服预赛排位
			# @param curPlayer: 玩家实例
			# @param value: 威望值
			# @return:
			def SetMergeWarRank(curPlayer, value):
			return


			## 获取玩家跨服预赛排位
			# @param curPlayer: 玩家实例
			# @return: 威望值
			def GetMergeWarRank(curPlayer):
			return 0

			##获取可免费开启的格子数
			# @param curPlayer 玩家对象
			@@ -6140,6 +6087,19 @@
			GameWorld.AddDictValue(attrDict, {i:value})
			return

			def CalcAttrDict_TypeEx(attrType, value, allAttrDict):
			## 统计玩家属性，累加
			if value == 0:
			return

			#[属性索引, 是否基础属性，(非)线性]
			attrInfo = ChConfig.ItemEffect_AttrDict.get(attrType, [])
			if attrInfo == []:
			return
			for i in attrInfo[0]:
			GameWorld.AddDictValue(allAttrDict, {i:value})
			return

			#===============================================================================
			# CalcAttr_Base,
			# CalcAttr_BaseNoline,
			@@ -6171,6 +6131,29 @@
			# return addAttrList
			#===============================================================================


			# 灵根 - 金木水火土
			def GetMetal(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Metal)
			def SetMetal(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_Metal, value)
			def GetWood(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Wood)
			def SetWood(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_Wood, value)
			def GetWater(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Water)
			def SetWater(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_Water, value)
			def GetFire(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Fire)
			def SetFire(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_Fire, value)
			def GetEarth(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Earth)
			def SetEarth(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_Earth, value)
			# 灵根品级 - 金木水火土
			def GetMetalQualityLV(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MetalQualityLV)
			def SetMetalQualityLV(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_MetalQualityLV, value)
			def GetWoodQualityLV(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_WoodQualityLV)
			def SetWoodQualityLV(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_WoodQualityLV, value)
			def GetWaterQualityLV(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_WaterQualityLV)
			def SetWaterQualityLV(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_WaterQualityLV, value)
			def GetFireQualityLV(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FireQualityLV)
			def SetFireQualityLV(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FireQualityLV, value)
			def GetEarthQualityLV(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_EarthQualityLV)
			def SetEarthQualityLV(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_EarthQualityLV, value)

			#---玩家扩展接口, 战斗属性，不存数据库，只通知本人---

			@@ -6346,24 +6329,6 @@
			# 基础闪避百分比
			def GetBaseMissAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BaseMissAddPer)
			def SetBaseMissAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BaseMissAddPer, value)
			# 魂器基础百分比
			def GetHorcruxBasePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_HorcruxBasePer)
			def SetHorcruxBasePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_HorcruxBasePer, value)
			# 装备基础百分比
			def GetEquipBaseAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_EquipBaseAddPer)
			def SetEquipBaseAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_EquipBaseAddPer, value)
			# 武器基础攻击百分比
			def GetWeaponAtkAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_WeaponAtkAddPer)
			def SetWeaponAtkAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_WeaponAtkAddPer, value)
			# 圣器基础攻击百分比
			def GetRelicsAtkAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_RelicsAtkAddPer)
			def SetRelicsAtkAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_RelicsAtkAddPer, value)
			# 防具基础生命百分比
			def GetArmorMaxHPAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ArmorMaxHPAddPer)
			def SetArmorMaxHPAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_ArmorMaxHPAddPer, value)
			# 防具基础防御百分比
			def GetArmorDefAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ArmorDefAddPer)
			def SetArmorDefAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_ArmorDefAddPer, value)
			# 神兵生命百分比
			def GetGodWeaponMaxHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_GodWeaponMaxHPPer)
			def SetGodWeaponMaxHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_GodWeaponMaxHPPer, value)
			@@ -6530,7 +6495,12 @@

			#---当前防护值，需存DB----
			def GetProDef(curPlayer): return curPlayer.GetExAttr4()
			def SetProDef(curPlayer, value): curPlayer.SetExAttr4(value)
			def SetProDef(curPlayer, value):
			if GameWorld.IsCrossServer():
			curPlayer.SetExAttr4(value, True) # 跨服服务器需要广播周围玩家
			else:
			curPlayer.SetExAttr4(value)

			#---最大防护值----
			def GetMaxProDef(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrMaxProDef)
			def SetMaxProDef(curPlayer, value):
			@@ -6579,41 +6549,6 @@
			def GetFuncDef(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CopyFuncAttr % (ChConfig.TYPE_Calc_AttrDEF - 1))
			def SetFuncDef(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_CopyFuncAttr % (ChConfig.TYPE_Calc_AttrDEF - 1), value)


			## 增加天梯竞技场积分
			# @param curPlayer 玩家实例
			# @return
			def AddHighLadderCurrency(curPlayer, addCount, isSysMsg=True, isRefresh=True):
			curCurrency = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_Currency)
			curCurrency += addCount
			NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_Currency, curCurrency)

			if isSysMsg:
			#通知客户端得到金钱
			NotifyCode(curPlayer, "GetMoney", [ShareDefine.TYPE_Price_HighLadder_Currency, addCount])
			if isRefresh:
			tick = GameWorld.GetGameWorld().GetTick()
			HighLadderTube.SendHighLadderState(curPlayer, tick)
			return


			## 用天梯竞技场积分付费
			# @param curPlayer 玩家实例
			# @return
			def PayHighLadderCurrency(curPlayer, payCount, isSysMsg=True, isRefresh=True):
			curCurrency = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_Currency)
			if (curCurrency < payCount) or (payCount < 0):
			return False, curCurrency, curCurrency
			updCurrency = max(0, curCurrency - payCount)
			NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_Currency, updCurrency)
			if isSysMsg:
			#通知客户端失去点数
			NotifyCode(curPlayer, "LostMoney", [ShareDefine.TYPE_Price_HighLadder_Currency, payCount])
			if isRefresh:
			tick = GameWorld.GetGameWorld().GetTick()
			HighLadderTube.SendHighLadderState(curPlayer, tick)
			return True, curCurrency, updCurrency

			## 计算功能背包物品属性
			# @param curPlayer 当前玩家
			# @param packType 背包类型
			@@ -6654,15 +6589,9 @@
			return

			#-------------------------------------------------------------------------------
			# 每个功能最多加几个属性
			# 即以这种方式优化刷属性效率，一个功能需要额外占用Def_MaxAddAttrTypeCnt*2个临时字典缓存(一个存类型，一个存值)
			Def_MaxAddAttrTypeCnt = 15

			# 通过SetCalcAttrListValue先缓存功能计算增加的属性值，仅在变更时重新计算设置
			# 通过AddCalcAttrListValue取出缓存中已经算好的属性值，在刷属性中进行累加，从而减少每次重新计算功能增加的属性

			## 设置保存功能事先计算好的属性值
			def SetCalcAttrListValue(curPlayer, funcIndex, allAttrList):
			def SetCalcAttrListValue(curPlayer, funcIndex, allAttrList, insidePerAttrDict={}):
			# 设置值之前先清空重置
			ClearCalcAttrListValue(curPlayer, funcIndex)

			@@ -6678,69 +6607,46 @@
			addMaxHP = curPlayer.GetLV() * battleAttrDict[ChConfig.TYPE_Calc_PerLVMaxHP]
			battleAttrDict[ChConfig.TYPE_Calc_AttrMaxHP] = battleAttrDict.get(ChConfig.TYPE_Calc_AttrMaxHP, 0) + addMaxHP

			for attrIndex, addAttrDict in enumerate(allAttrList):
			findIndex = -1
			for attrType, attrValue in addAttrDict.items():
			if not isinstance(attrValue, int):
			GameWorld.ErrLog("SetCalcAttrListValue funcIndex=%s,attrType=%s,Value=%s is not int!"
			% (funcIndex, attrType, attrValue), curPlayer.GetPlayerID())
			continue
			for i in xrange(findIndex + 1, Def_MaxAddAttrTypeCnt):
			addAttrTypeKey = ChConfig.Def_PlayerKey_CalcAddAttrType % (funcIndex, attrIndex, i)
			addAttrValueKey = ChConfig.Def_PlayerKey_CalcAddAttrValue % (funcIndex, attrIndex, i)
			if curPlayer.GetDictByKey(addAttrTypeKey) == 0:
			findIndex = i
			curPlayer.SetDict(addAttrTypeKey, attrType)
			curPlayer.SetDict(addAttrValueKey, attrValue)
			break
			playerID = curPlayer.GetPlayerID()
			if playerID not in PyGameData.g_playerFuncAttrDict:
			PyGameData.g_playerFuncAttrDict[playerID] = {}
			funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]
			funcAttrDict[funcIndex] = [allAttrList, insidePerAttrDict]
			#GameWorld.DebugLog("保存功能点属性: funcIndex=%s, %s, %s" % (funcIndex, allAttrList, insidePerAttrDict))
			return

			def GetCalcAttrListValue(curPlayer, funcIndex):
			## 获取功能点预先计算的所加属性值
			attrList = [{} for _ in range(4)]
			insidePerAttrDict = {}
			if isinstance(funcIndex, int):
			funcIndexList = [funcIndex]
			elif isinstance(funcIndex, list):
			funcIndexList = funcIndex
			else:
			return attrList
			return attrList, insidePerAttrDict

			playerID = curPlayer.GetPlayerID()
			if playerID not in PyGameData.g_playerFuncAttrDict:
			return attrList, insidePerAttrDict
			funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]
			for funcIndex in funcIndexList:
			for attrIndex, attrDict in enumerate(attrList):
			for i in xrange(Def_MaxAddAttrTypeCnt):
			attrType = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CalcAddAttrType % (funcIndex, attrIndex, i))
			if attrType == 0:
			break
			attrValue = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CalcAddAttrValue % (funcIndex, attrIndex, i))
			if attrType in attrDict:
			attrDict[attrType] = attrValue + attrDict[attrType]
			else:
			attrDict[attrType] = attrValue
			return attrList

			## 刷属性时累加功能事先计算好的属性值
			def AddCalcAttrListValue(curPlayer, funcIndex, allAttrList):
			for attrIndex in ChConfig.CalcAttrIndexList:
			for i in xrange(Def_MaxAddAttrTypeCnt):
			curAddAttrType = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CalcAddAttrType % (funcIndex, attrIndex, i))
			if curAddAttrType == 0:
			break
			curAddAttrValue = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CalcAddAttrValue % (funcIndex, attrIndex, i))
			addAttrDict = allAttrList[attrIndex]
			AddAttrDictValue(addAttrDict, {curAddAttrType:curAddAttrValue})

			return allAttrList
			if funcIndex not in funcAttrDict:
			continue
			funcAttrList, funcInsidePerAttrDict = funcAttrDict[funcIndex]
			for i, attrDict in enumerate(attrList):
			curAttrDict = funcAttrList[i]
			AddAttrDictValue(attrDict, curAttrDict)
			AddAttrDictValue(insidePerAttrDict, funcInsidePerAttrDict)
			return attrList, insidePerAttrDict

			## 重置缓存
			def ClearCalcAttrListValue(curPlayer, funcIndex):
			for attrIndex in ChConfig.CalcAttrIndexList:
			for i in xrange(Def_MaxAddAttrTypeCnt):
			addAttrTypeKey = ChConfig.Def_PlayerKey_CalcAddAttrType % (funcIndex, attrIndex, i)
			attrType = curPlayer.GetDictByKey(addAttrTypeKey)
			if not attrType:
			break
			curPlayer.SetDict(addAttrTypeKey, 0)
			curPlayer.SetDict(ChConfig.Def_PlayerKey_CalcAddAttrValue % (funcIndex, attrIndex, i), 0)
			playerID = curPlayer.GetPlayerID()
			if playerID not in PyGameData.g_playerFuncAttrDict:
			return
			funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]
			funcAttrDict.pop(funcIndex, None)
			return

			def AddAttrListValue(attrList):
			@@ -6767,6 +6673,13 @@
			#-------------------------------------------------------------------------------
			## 设置玩家字典值, 存库
			def NomalDictSetProperty(curPlayer, key, value, dType=0):
			if CrossPlayerData.IsNeedProcessCrossPlayer(curPlayer) and key not in \
			[ChConfig.Def_PDict_FightPower_Total, ChConfig.Def_PlayerKey_CrossRegisterMap]:
			playerID = curPlayer.GetPlayerID()
			changeDict = PyGameData.g_crossPlayerDictChangeInfo.get(playerID, {})
			changeDict[(key, dType)] = value
			PyGameData.g_crossPlayerDictChangeInfo[playerID] = changeDict

			if value == 0:
			curPlayer.NomalDictDelProperty(key, dType)
			return