SnxxServerCode.git

			@@ -55,15 +55,12 @@
			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
			@@ -76,16 +73,23 @@
			import PyGameData
			import PlayerMagicWeapon
			import GameLogic_SealDemon
			import GameLogic_ZhuXianBoss
			import GameLogic_CrossDemonKing
			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 +120,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 +235,22 @@
			# @param mergeMapInfo 该提示所属的跨服活动地图信息, 主要用于不同子服对应所跨的活动地图ID
			# @return 无返回值
			def WorldNotify(country, msgMark, msgParamList=[], lineID=0, mergeMinOSD=-1, mergeMaxOSD=-1, mergeMapInfo=[]):
			# 如果是跨服服务器，则广播子服
			if GameWorld.IsCrossServer():
			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 +323,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 +333,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 +349,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

			@@ -367,24 +380,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 +529,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 +1179,6 @@
			NPCCommon.ClearCollectNPC(curPlayer)
			#结束事件
			EventShell.DoExitEvent(curPlayer)

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

			#设置玩家的地图位置, 如果是副本, 离开副本
			# 副本规则:
			@@ -1173,8 +1192,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 +1211,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 +1444,6 @@

			curPlayer.SetChangeMapTakeTruck(takeTruck)

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

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

			@@ -1565,6 +1587,63 @@

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

			def PlayerEnterCrossServer(curPlayer, mapID, lineID):
			playerID = curPlayer.GetPlayerID()
			GameWorld.Log("玩家请求进入跨服地图: mapID=%s,lineID=%s" % (mapID, lineID), playerID)
			if mapID not in ChConfig.Def_CrossMapIDList:
			return

			if GameWorld.IsCrossServer():
			GameWorld.DebugLog("跨服服务器不允许该操作!")
			return

			if GetCrossMapID(curPlayer):
			GameWorld.ErrLog("玩家当前为跨服状态，不允许再次请求进入跨服!", curPlayer.GetPlayerID())
			return

			if not CrossRealmPlayer.IsCrossServerOpen():
			NotifyCode(curPlayer, "CrossMatching18")
			return

			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

			tick = GameWorld.GetGameWorld().GetTick()
			for mapIDList in ChConfig.Def_FB_MapID.values():
			if mapID not in mapIDList:
			continue
			if not FBLogic.OnEnterFBEvent(curPlayer, mapID, lineID, tick):
			NotifyCode(curPlayer, "SingleEnterDefaul")
			return
			break

			# 需要动态分布线路的地图，发送到跨服服务器进行分配
			if mapID in ChConfig.Def_CrossDynamicLineMap:
			extendInfo = {}
			if mapID == ChConfig.Def_FBMapID_CrossDemonKing:
			bossID = GameLogic_CrossDemonKing.GetCurFBLineBOSSID(lineID)
			if not bossID:
			return
			extendInfo["BossID"] = bossID

			msgDict = {"PlayerID":curPlayer.GetPlayerID(), "DataMapID":mapID, "FuncLineID":lineID}
			if extendInfo:
			msgDict.update(extendInfo)
			GameWorld.SendMsgToCrossServer(ShareDefine.ClientServerMsg_EnterFB, msgDict)
			return

			GY_Query_CrossRealmReg.RegisterEnterCrossServer(curPlayer, mapID)
			return

			##玩家进入副本
			# @param curPlayer 玩家实例
			# @param mapID 地图ID
			@@ -1651,6 +1730,17 @@
			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()]
			elif mapID == ChConfig.Def_FBMapID_DemonKing:
			bossID = GameLogic_CrossDemonKing.GetCurFBLineBOSSID(lineID)
			extendParamList = [bossID]

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

			@@ -1721,6 +1811,12 @@
			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状态检查
			@@ -1746,6 +1842,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：您当前所处的状态不能进行传送!
			@@ -1944,16 +2046,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

			#---------------------------------------------------------------------
			@@ -2053,7 +2157,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
			@@ -2689,7 +2794,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):
			@@ -2899,10 +3006,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)

			# 事件汇报
			#===========================================================================
			@@ -2989,6 +3093,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:
			@@ -3313,22 +3423,38 @@

			return int(addPoint)

			def DoAddPointOpen(curPlayer):
			'''加点功能开启处理给自由属性点及老号处理
			清除老服玩家未加点的点数（清零），以前加的加点属性不清除，属性不变，战力不减，根据最新的加点开启等级和老服玩家的当前等级，相差的差值给予玩家对应的加点点数'''
			beforeFreePoint = curPlayer.GetFreePoint()
			addPointDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAddPoint", 1, {})
			initFreePoint = IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 2)
			def GetAllPointByLV(curPlayer):
			##获取当前等级可得到属性点数
			openLV = GameFuncComm.GetFuncLimitLV(ShareDefine.GameFuncID_AddPoint)
			setFreePoint = initFreePoint
			curLV = curPlayer.GetLV()
			for lv in xrange(openLV, curLV+1):
			setFreePoint += GameWorld.GetDictValueByRangeKey(addPointDict, lv, 0)
			if curLV < openLV:
			return 0
			# 初始点+升级点+境界点
			setFreePoint = IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 2)

			addPointDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAddPoint", 1, {})
			for rangLVs, point in addPointDict.items():
			if curLV < rangLVs[0]:
			continue
			setFreePoint += point * (min(curLV, rangLVs[1]) - rangLVs[0] + 1)

			#境界提升点数
			setFreePoint += curPlayer.GetOfficialRank() * IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 3)
			return setFreePoint

			def DoAddPointOpen(curPlayer):
			'''加点功能开启'''
			beforeFreePoint = curPlayer.GetFreePoint()

			setFreePoint = GetAllPointByLV(curPlayer)
			curLV = curPlayer.GetLV()
			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


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

			## 功能模块战斗力类
			@@ -3434,6 +3560,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) # 最大防护值
			@@ -3520,6 +3653,9 @@
			# @remarks 玩家升级加点 2010-05-26 adaws修改原来有加技能点现将升级加技能提出
			def __DoLVUPAddPoint(self):
			curPlayer = self.__Player
			if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_AddPoint):
			# 未开启前不可加点，因为DoAddPointOpen会一次性补齐，避免意外情况多加了点数
			return

			curFreePoint = curPlayer.GetFreePoint()
			addPoint = GetLvUp_AddPoint(curPlayer)
			@@ -3561,15 +3697,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 类实例
			@@ -3600,7 +3727,6 @@
			if addExp == 0:
			# 不进入计算
			return addExp, expViewType
			#nextReinLV = self.GetNextReincarnationLV(curPlayer)

			#取得人物当前经验
			#curTotalExp = GetPlayerTotalExp(curPlayer)
			@@ -3619,7 +3745,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

			# 杀怪
			@@ -3646,7 +3772,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
			#
			@@ -3854,7 +3980,7 @@
			PlayerGreatMaster.Sync_GreatMasterFreeSkillPoint(curPlayer)
			# 升级需要执行的游戏功能处理
			GameFuncComm.DoFuncOpenLogic(curPlayer)
			ChEquip.CalcEquips_OutOfPrint(curPlayer) # 缓存绝版属性
			#ChEquip.CalcEquips_OutOfPrint(curPlayer) # 缓存绝版属性
			if aftLV%10 == 0:
			# 控制下刷新次数
			PlayerPet.CalcPetItemAddPlayerAttr(curPlayer) # 宠物有随等级变化的技能
			@@ -3871,7 +3997,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
			@@ -3885,51 +4011,74 @@
			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
			pqAttrIDDict = ipyData.GetPointQualityAttrIDDict()
			pqAttrID = pqAttrIDDict[curPlayer.GetJob()]
			pqAttrValueDict = ipyData.GetPointQualityAttrValueDict()
			pqAttrValueList = pqAttrValueDict[str(curPlayer.GetJob())]
			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

			#---------------------------------------------------------------------
			@@ -4019,14 +4168,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
			@@ -4105,40 +4255,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

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

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

			# 功能属性层级一...
			@@ -4171,21 +4316,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])
			@@ -4199,25 +4342,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)

			@@ -4227,11 +4366,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],
			@@ -4239,13 +4373,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:
			@@ -4271,79 +4402,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)
			@@ -4692,6 +4834,8 @@
			PlayerBillboard.UpdatePlayerFPTotalBillboard(curPlayer)
			# 记录开服活动数据
			OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_FightPower, totalFightPower)
			if beforeFightPower != totalFightPower:
			CrossPlayerData.OnPlayerFightPowerChange(curPlayer)
			return

			def __RefreshMoveSpeed(self, allAttrListBuffs):
			@@ -4766,33 +4910,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

			#---------------------------------------------------------------------
			## 刷新血量和魔
			@@ -4833,10 +4950,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(),
			@@ -4864,6 +4981,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

			#---------------------------------------------------------------------
			@@ -5278,35 +5401,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

			#---------------------------------------------------------------------
			##特殊状态处理
			@@ -5553,43 +5647,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 金钱类型
			@@ -5620,7 +5677,6 @@
			# ֪ͨGsmeServer;
			# SendGameServerRefreshState(int inputType, int inputValue)

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

			# 禁言通知gameServer
			def SetGMForbidenTalk(curPlayer, value):
			@@ -5628,13 +5684,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)
			@@ -5645,9 +5694,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()
			@@ -5687,6 +5740,12 @@
			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
			@@ -6069,6 +6128,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,
			@@ -6100,6 +6172,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)

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

			@@ -6275,24 +6370,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)
			@@ -6459,7 +6536,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):
			@@ -6508,40 +6590,18 @@
			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
			#普通攻击增伤：普通攻击附加的固定值伤害
			def GetNormalHurt(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_NormalHurt)
			def SetNormalHurt(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_NormalHurt, value)
			#普通攻击加成：普通攻击附加的伤害百分比
			def GetNormalHurtPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_NormalHurtPer)
			def SetNormalHurtPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_NormalHurtPer, value)
			#法宝技能增伤：法宝技能攻击附加的固定值伤害
			def GetFabaoHurt(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FabaoHurt)
			def SetFabaoHurt(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FabaoHurt, value)
			#法宝技能加成：法宝技能攻击附加的伤害百分比
			def GetFabaoHurtPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FabaoHurtPer)
			def SetFabaoHurtPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FabaoHurtPer, value)

			## 计算功能背包物品属性
			# @param curPlayer 当前玩家
			@@ -6583,15 +6643,9 @@
			return

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

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

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

			@@ -6607,69 +6661,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):
			@@ -6696,6 +6727,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