Project_SG_ServerCode.git

			@@ -17,438 +17,66 @@
			import IPY_GameWorld
			import GameWorld
			import ItemControler
			import SkillShell
			import PlayerControl
			import ChConfig
			import ChItem
			import ItemCommon
			import FBLogic
			import OperControlManager
			import Operate_EquipWash
			import Operate_EquipPlus
			import ShareDefine
			import ChPyNetSendPack
			import NetPackCommon
			import IpyGameDataPY
			import Operate_EquipStone
			import OpenServerCampaign
			import PassiveBuffEffMng
			import time
			import json
			import FormulaControl
			import PyGameData
			#---------------------------------------------------------------------
			import PlayerOnline

			def RefreshRoleEquipAttr(curPlayer):
			## 刷新主公装备属性
			CalcRoleEquipAttr(curPlayer)
			PlayerOnline.GetOnlinePlayer(curPlayer).RefreshRoleAttr()
			return

			##检查玩家是否可以换装
			# @param curPlayer 玩家实例
			# @return 返回值, 是否通过检查
			# @remarks 检查玩家是否可以换装
			def CheckPlayerCanEquipItem(curPlayer):
			if curPlayer.GetPlayerAction() not in ChConfig.Def_Player_DoEquip_State:
			#InsteadEquip 对不起,当前状态无法更换装备
			#InsteadEquip替换为GeRen_chenxin_436832
			PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_436832")
			return False
			def CalcRoleEquipAttr(curPlayer):
			## 计算主公装备属性
			playerID = curPlayer.GetPlayerID()
			mainEquipAttrDict = {}

			return True
			packType = IPY_GameWorld.rptEquip
			equipPack = curPlayer.GetItemManager().GetPack(packType)

			# 主装备
			for equipPlace in ChConfig.Def_MainEquipPlaces:
			equipIndex = equipPlace - 1
			if equipIndex < 0 or equipIndex >= equipPack.GetCount():
			continue
			curEquip = equipPack.GetAt(equipIndex)
			if not curEquip or curEquip.IsEmpty():
			continue
			#itemColor = curEquip.GetItemColor()

			## 执行玩家换装逻辑
			# @param curPlayer 当前玩家
			# @param curItem 物品实例
			# @param equipPackIndex 装备背包索引
			# @param tick 当前时间
			# @return 布尔值
			# @remarks 执行玩家换装逻辑
			def DoPlayerEquipItem(curPlayer, curItem, equipPackIndex, tick):
			if equipPackIndex < 0:
			return False
			playerItemControl = ItemControler.PlayerItemControler(curPlayer)
			baseAttrIDCnt = curEquip.GetUserAttrCount(ShareDefine.Def_IudetBaseAttrID)
			baseAttrValueCnt = curEquip.GetUserAttrCount(ShareDefine.Def_IudetBaseAttrValue)
			if baseAttrIDCnt == baseAttrValueCnt:
			for i in xrange(baseAttrIDCnt):
			attrID = curEquip.GetUserAttrByIndex(ShareDefine.Def_IudetBaseAttrID, i)
			attrValue = curEquip.GetUserAttrByIndex(ShareDefine.Def_IudetBaseAttrValue, i)
			mainEquipAttrDict[attrID] = mainEquipAttrDict.get(attrID, 0) + attrValue

			#---验证是否可以换这件装备---
			if not ItemCommon.CheckItemCanUse(curItem):
			return False
			legendAttrIDCnt = curEquip.GetUserAttrCount(ShareDefine.Def_IudetLegendAttrID)
			legendAttrValueCnt = curEquip.GetUserAttrCount(ShareDefine.Def_IudetLegendAttrValue)
			if legendAttrIDCnt == legendAttrValueCnt:
			for i in xrange(legendAttrIDCnt):
			attrID = curEquip.GetUserAttrByIndex(ShareDefine.Def_IudetLegendAttrID, i)
			attrValue = curEquip.GetUserAttrByIndex(ShareDefine.Def_IudetLegendAttrValue, i)
			mainEquipAttrDict[attrID] = mainEquipAttrDict.get(attrID, 0) + attrValue

			if not ItemCommon.CheckItemCanUseByExpireTime(curItem):
			# 过期
			GameWorld.DebugLog("装备已过期!")
			return False

			changeItemEquipPlace = curItem.GetEquipPlace()
			if changeItemEquipPlace not in ShareDefine.RoleEquipType:
			return False

			if ItemCommon.GetEquipPackIndex(curItem) != equipPackIndex:
			#检查装备位置和填表是否一致
			return False

			#--设置穿上物品星级--
			#===========================================================================
			# if changeItemEquipPlace in ShareDefine.RoleEquipType:
			# equipPartStar = GetEquipPartPlusLV(curPlayer, IPY_GameWorld.rptEquip, changeItemEquipPlace)
			# if equipPartStar != curItem.GetItemStarLV():
			# curItem.SetItemStarLV(equipPartStar)
			#===========================================================================
			#GameWorld.DebugLog("穿上的装备设置星级: index=%s,star=%s" % (changeItemEquipPlace, equipPartStar))

			#---开始换装逻辑---

			#记录换装物品信息
			itemClassLV = ItemCommon.GetItemClassLV(curItem)
			changeItemID = curItem.GetItemTypeID()
			changeItemStarLV = 0 #curItem.GetItemStarLV()
			changeItemStoneCnt = 0 #curItem.GetUseStoneCount()
			changeItemHoleCnt = 0 #curItem.GetCanPlaceStoneCount()
			changeItemUseData = curItem.GetUserData()
			suiteID = curItem.GetSuiteID()
			endureReduceType = curItem.GetEndureReduceType()
			#changeItemIsHorse = (curItem.GetType() == ChConfig.Def_Item_Type_Horse)

			#执行换装动作
			equipPlace = playerItemControl.EquipItem(curItem, equipPackIndex)

			if equipPlace == -1:
			return False

			equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
			curEquip = equipPack.GetAt(equipPackIndex)

			if curEquip.GetUserAttr(ShareDefine.Def_IudetCreateTime) == 0:
			curEquip.SetUserAttr(ShareDefine.Def_IudetCreateTime, int(time.time()))
			#---换装成功---
			if equipPackIndex in PlayerControl.GetFaceEquipIndexList(curPlayer) or equipPlace in ChConfig.Def_SyncEquipStateByIndex:
			#通知客户端交换物品
			curPlayer.ChangeEquip(changeItemID, equipPackIndex, changeItemStarLV, changeItemHoleCnt, changeItemStoneCnt, changeItemUseData)
			if itemClassLV == GetEquipFacadeClassLV(curPlayer):
			#穿当前外观阶的套装
			ChangeEquipfacadeByClassLV(curPlayer, itemClassLV)

			#特殊装备, 不需要刷属性
			if changeItemEquipPlace in ChConfig.EquipItemNoRefreshState:
			return True

			curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrActivatyNotify, ChConfig.Def_AttrActivatyNotify_Equip)

			#先刷装备BUFF 再计算属性
			if changeItemEquipPlace in ChConfig.EquipPlace_LingQi:
			RefreshPlayerLingQiEquipAttr(curPlayer)
			elif itemClassLV:
			RefreshPlayerEquipAttribute(curPlayer, itemClassLV)

			#刷新所有属性
			playControl = PlayerControl.PlayerControl(curPlayer)
			playControl.RefreshPlayerAttrState()

			#装备的被动触发类技能
			PassiveBuffEffMng.GetPassiveEffManager().RegistSuperEquipSkillDict(curPlayer)
			return True

			GameWorld.DebugLog("主线装备属性: %s" % mainEquipAttrDict, playerID)
			PlayerOnline.GetOnlinePlayer(curPlayer).SetCalcAttr(ChConfig.Def_CalcAttr_MainEquip, mainEquipAttrDict)
			return

			## 刷新装备对人物属性的改变
			# @param self 类实例
			# @return 返回值无意义
			# @remarks 刷新装备对人物属性的改变
			def RefreshPlayerEquipAttribute(curPlayer, classLV=0):
			GameWorld.DebugLog("Start RefreshPlayerEquipAttribute classLV=%s!!!" % classLV, curPlayer.GetPlayerID())
			classlvList = xrange(1, IpyGameDataPY.GetFuncCfg('EquipMaxClasslv') + 1) if classLV == 0 else [classLV]
			for rclasslv in classlvList:
			__CalcEquips_Effect(curPlayer, rclasslv)

			#if isRefreshEquipBuff:
			# __RefreshPlayerAllEquipBuff(curPlayer)

			if classLV:
			playerID = curPlayer.GetPlayerID()
			if playerID not in PyGameData.g_equipChangeClassLVInfo:
			PyGameData.g_equipChangeClassLVInfo[playerID] = []
			classLVList = PyGameData.g_equipChangeClassLVInfo[playerID]
			if classLV not in classLVList:
			classLVList.append(classLV)
			#GameWorld.DebugLog("添加装备缓存变更阶: classLV=%s, %s" % (classLV, classLVList), playerID)
			return

			def OnPlayerEquipLoginLogic(curPlayer):
			''' 玩家登录统一处理装备，只遍历一次装备背包，通知信息、更新一次数据，防止总等级统计异常
			装备品质橙装及以上数量、装备总星数、强化总等级、进化总等级、洗练总等级、宝石总等级
			'''

			#NotifyEquipPartPlusLV(curPlayer)
			#NotifyEquipPartStar(curPlayer)
			#Operate_EquipWash.OnEquipWashLogin(curPlayer)
			#装备位宝石镶嵌通知
			#Operate_EquipStone.OnLogin(curPlayer)
			# if not GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_Player_Dict_VersionFix, ChConfig.Def_VerFix_LingGenShow):
			# GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_Player_Dict_VersionFix, ChConfig.Def_VerFix_LingGenShow, 1)
			# ChangeEquipfacadeByLingGen(curPlayer)

			ePartStarLVPack = ChPyNetSendPack.tagMCEquipPartStarInfo() # A3 B1 装备部位星数信息 #tagMCEquipPartStarInfo
			ePartPlusLVPack = ChPyNetSendPack.tagMCEquipPartPlusInfo() # A3 B3 装备部位强化信息 #tagMCEquipPartPlusInfo
			ePartXLPack = ChPyNetSendPack.tagMCEquipPartXLAttrInfo() # A3 BB 装备位洗练属性信息 #tagMCEquipPartXLAttrInfo
			ePartStonePack = ChPyNetSendPack.tagMCStoneInfo() # A3 BC 通知装备位孔位宝石ID #tagMCStoneInfo

			orangeEquipCount = 0
			totalStar = 0
			totalPlusLV = 0
			totalEvolveLV = 0
			totalWashLV = 0
			totalStoneLV = 0
			holeIndexList = Operate_EquipStone.GetAllEquipPlaceHoleIndex()

			gameData = GameWorld.GetGameData()
			packType = IPY_GameWorld.rptEquip
			equipPack = curPlayer.GetItemManager().GetPack(packType)
			for index in xrange(equipPack.GetCount()):
			ipyData = IpyGameDataPY.GetIpyGameDataByCondition('EquipPlaceIndexMap', {'GridIndex':index}, isLogNone=False)
			if not ipyData:
			continue
			# 只计算有阶的境界装备
			if not ipyData.GetClassLV():
			continue

			curEquip = equipPack.GetAt(index)
			if not curEquip.IsEmpty():
			if curEquip.GetItemColor() >= ShareDefine.Def_Item_Color_Orange:
			orangeEquipCount += 1

			# 星级
			starLV = GetEquipPartStar(curPlayer, index)
			totalStar += starLV

			# 强化等级
			plusProficiency = GetEquipPartProficiency(curPlayer, packType, index)
			plusLV = GetEquipPartPlusLV(curPlayer, packType, index)
			totalPlusLV += plusLV

			# 进化等级
			evolveLV = GetEquipPartPlusEvolveLV(curPlayer, packType, index)
			totalEvolveLV += evolveLV

			# 洗练等级
			washLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipWashLV % index)
			totalWashLV += washLV

			# 宝石等级
			stoneIDList, stoneIsBindList = [], []
			for holeIndex in holeIndexList:
			stoneID, stoneIsBind = Operate_EquipStone.GetEquipIndexStoneIDAndIsBand(curPlayer, index, holeIndex)
			stoneIDList.append(stoneID)
			stoneIsBindList.append(stoneIsBind)
			if stoneID == 0:
			continue
			curStone = gameData.GetItemByTypeID(stoneID)
			stoneLV = 0 if not curStone else curStone.GetEffectByIndex(0).GetEffectValue(1)
			totalStoneLV += stoneLV

			# 星级信息包
			if starLV:
			ePartStarLV = ChPyNetSendPack.tagMCEquipPartStar()
			ePartStarLV.Clear()
			ePartStarLV.EquipPackIndex = index
			ePartStarLV.Star = starLV
			ePartStarLVPack.InfoList.append(ePartStarLV)

			# 强化、进化信息包
			if plusLV or plusProficiency or evolveLV:
			ePartPlusLV = ChPyNetSendPack.tagMCEquipPartPlusLV()
			ePartPlusLV.Clear()
			ePartPlusLV.PackType = packType
			ePartPlusLV.EquipIndex = index
			ePartPlusLV.EquipPartStarLV = plusLV
			ePartPlusLV.Proficiency = plusProficiency
			ePartPlusLV.EvolveLV = evolveLV
			ePartPlusLVPack.InfoList.append(ePartPlusLV)

			# 洗练信息包
			hasXLValue = False
			xlAttrList = []
			for attrNum in xrange(1, Operate_EquipWash.Def_EquipWashMaxAttrCount + 1):
			washValue = ChPyNetSendPack.tagMCEquipPartXLAttrValue()
			washValue.XLAttrValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipWashValue % (index, attrNum))
			washValue.XLAttrChange = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipWashValueTemp % (index, attrNum))
			xlAttrList.append(washValue)
			if washValue.XLAttrValue or washValue.XLAttrChange:
			hasXLValue = True
			if hasXLValue or washLV:
			ePartXLAttr = ChPyNetSendPack.tagMCEquipPartXLAttr()
			ePartXLAttr.EquipPlace = index
			ePartXLAttr.XLAttrLV = washLV
			ePartXLAttr.XLAttrList = xlAttrList
			ePartXLAttr.XLAttrCnt = len(ePartXLAttr.XLAttrList)
			ePartXLPack.InfoList.append(ePartXLAttr)

			# 宝石信息包
			stoneCount = len(stoneIDList)
			if stoneIDList.count(0) != stoneCount:
			stoneMsg = ChPyNetSendPack.tagMCStoneMsg()
			stoneMsg.EquipPlace = index
			stoneMsg.MaxStoneCount = stoneCount
			stoneMsg.StoneInfo = stoneIDList
			stoneMsg.StoneBind = stoneIsBindList
			ePartStonePack.InfoList.append(stoneMsg)

			# 通知封包，有值时才通知
			if ePartStarLVPack.InfoList:
			ePartStarLVPack.Count = len(ePartStarLVPack.InfoList)
			NetPackCommon.SendFakePack(curPlayer, ePartStarLVPack)

			if ePartPlusLVPack.InfoList:
			ePartPlusLVPack.Count = len(ePartPlusLVPack.InfoList)
			NetPackCommon.SendFakePack(curPlayer, ePartPlusLVPack)

			if ePartXLPack.InfoList:
			ePartXLPack.Count = len(ePartXLPack.InfoList)
			NetPackCommon.SendFakePack(curPlayer, ePartXLPack)

			if ePartStonePack.InfoList:
			ePartStonePack.EquipCount = len(ePartStonePack.InfoList)
			NetPackCommon.SendFakePack(curPlayer, ePartStonePack)

			Operate_EquipPlus.SyncEquipMasterPlusLVInfo(curPlayer)

			# 更新统计汇总值
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PlayerKey_EquipOrangeCount, orangeEquipCount)
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TotalEquipStar, totalStar)
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TotalPlusLV, totalPlusLV)
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TotalPlusEvolveLV, totalEvolveLV)
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TotalEquipWashLV, totalWashLV)
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TotalStoneLV, totalStoneLV)
			GameWorld.DebugLog("登录更新装备相关值汇总: orangeEquipCount=%s,totalStar=%s,totalPlusLV=%s,totalEvolveLV=%s,totalWashLV=%s,totalStoneLV=%s"
			% (orangeEquipCount, totalStar, totalPlusLV, totalEvolveLV, totalWashLV, totalStoneLV))
			Sync_EquipPartSuiteActivateInfo(curPlayer)

			for equipPlace in ChConfig.EquipPlace_LingQi:
			Sync_LingQiTrainData(curPlayer, equipPlace)

			return

			#===============================================================================
			# #//07 03 人物装备物品#tagCEquipItem
			# //角色装备类型
			# int GetRoleEquipType();
			# //物品在物品背包的索引
			# int GetItemIndex();
			#===============================================================================
			## 人物装备物品
			# @param index 背包索引
			# @param tick 当前时间
			# @return None
			# @remarks 客户端封包响应 //07 03 人物装备物品#tagCEquipItem
			def PlayerEquipItem(index, tick):
			GameWorld.GetPsycoFunc(__Func_PlayerEquipItem)(index, tick)
			return


			## 人物装备物品
			# @param index 背包索引
			# @param tick 当前时间
			# @return None
			# @remarks 客户端封包响应 //07 03 人物装备物品#tagCEquipItem
			def __Func_PlayerEquipItem(index, tick):
			curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
			sendPack = IPY_GameWorld.IPY_CEquipItem()
			#物品在物品背包的索引
			packItemIndex = sendPack.GetItemIndex()
			#角色装备部位
			equipPackIndex = sendPack.GetRoleEquipType()

			#检查玩家状态是否可以换装
			if not CheckPlayerCanEquipItem(curPlayer):
			return

			#检查换装间隔
			#===========================================================================
			# if tick - curPlayer.GetLastChangeEquipTick() <= ChConfig.Def_MinChangeEquipTime:
			# #GameWorld.Log("更换装备时间过短! %d"%(tick - curPlayer.GetLastChangeEquipTick()))
			# return
			#
			# curPlayer.SetLastChangeEquipTick(tick)
			#===========================================================================

			#---获取封包需要装备的物品---
			rolePack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
			curItem = rolePack.GetAt(packItemIndex)
			#---执行玩家换装逻辑---
			if DoPlayerEquipItem(curPlayer, curItem, equipPackIndex, tick):
			return

			#换装失败通知客户端信息
			curPlayer.Notify_ItemPutFail(IPY_GameWorld.rptItem, packItemIndex, IPY_GameWorld.rptEquip, 0)
			return


			#---------------------------------------------------------------------
			## 一键换装（封包）
			# @param index 玩家索引
			# @param tick 当前时间
			# @return None
			# @remarks 函数详细说明.
			def OneKeyChangeEquip(index, tick):
			return


			## 玩家卸下装备(封包参数)
			# @param index 玩家索引
			# @param tick 当前时间
			# @return None
			# @remarks 函数详细说明.
			def PlayerUnEquip(index, tick):
			GameWorld.GetPsycoFunc(__Func_PlayerUnEquip)(index, tick)
			return


			#---------------------------------------------------------------------
			## 玩家卸下装备(封包参数)
			# @param index 玩家索引
			# @param tick 当前时间
			# @return None
			# @remarks 函数详细说明.
			def __Func_PlayerUnEquip(index, tick):
			sendPack = IPY_GameWorld.IPY_CUnEquipItem()
			curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

			if not CheckPlayerCanEquipItem(curPlayer):
			return

			equipPackIndex = sendPack.GetEquipIndex()

			#如果卸下的是马匹，需要判定如果马匹装备背包有物品，不让放下
			#===========================================================================
			# if equipIndex == IPY_GameWorld.rptHorse :
			# itemEquipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptHorseEquip)
			#
			# if not ItemControler.GetPackIsEmpty(itemEquipPack):
			# PlayerControl.NotifyCode(curPlayer, "7E355D97-520A-4A8C-8BC993AAEAF6071F")
			# return
			#===========================================================================

			playerItemControl = ItemControler.PlayerItemControler(curPlayer)
			result = playerItemControl.UnEquipItem(equipPackIndex, sendPack.GetPackIndex())

			if not result:
			#卸下装备失败
			return

			equipID = result[0]
			equipPlace = result[1]
			itemClassLV = result[2]

			##特殊装备 , 不需要冲刷属性
			if equipPlace in ChConfig.EquipItemNoRefreshState:
			return

			#先刷装备BUFF 再计算属性
			if equipPlace in ChConfig.EquipPlace_LingQi:
			RefreshPlayerLingQiEquipAttr(curPlayer)
			elif itemClassLV:
			RefreshPlayerEquipAttribute(curPlayer, itemClassLV)

			#刷新所有属性
			playControl = PlayerControl.PlayerControl(curPlayer)
			playControl.RefreshPlayerAttrState()

			#装备的被动触发类技能
			PassiveBuffEffMng.GetPassiveEffManager().RegistSuperEquipSkillDict(curPlayer)
			return

			#// A3 18 灵器突破 #tagCMLingQiEquipBreak
			@@ -634,7 +262,7 @@
			def RefreshPlayerLingQiEquipAttr(curPlayer):
			''' 刷新玩家灵器装备属性
			'''

			return
			classLV = 0 # 灵器阶默认为0
			allAttrList = [{} for _ in range(4)]
			lingQiAttrList = [{} for _ in range(4)]
			@@ -752,503 +380,8 @@
			PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_LingQiAttr, lingQiAttrList)
			return

			def __CalcEquips_Effect(curPlayer, classLV):
			''' 境界装备系统属性
			1. 装备模块，每个境界阶独立，每个境界战力独立模块计算
			1.1 装备本身属性: 不能有影响其他境界装备的属性
			基础属性: 物品表中的配置
			传奇属性:

			2.装备位星级模块
			2.1 装备位升星属性：不能有影响其他境界装备的属性
			升星基础属性，属性属于装备基础
			升星等级属性，会影响本阶装备基础
			星级套装属性，详见套装属性

			2.2 装备位套装属性：不能有影响其他境界装备的属性
			由装备位是否套装及星级数决定套装属性

			3.装备位强化模块：战力为所有境界装备位强化属性总和战力
			强化等级属性
			进化等级属性，影响本部位本境界装备基础

			4.装备位宝石属性：战力为所有境界装备位宝石属性总和战力
			宝石等级属性
			宝石觉醒属性，会影响本阶装备基础

			5.装备位洗练属性：战力为所有境界装备位洗练属性总和战力
			洗练等级属性
			洗练套装属性，会影响本阶装备基础
			'''

			if classLV < 1:
			GameWorld.ErrLog("刷境界装备属性阶错误!当前不支持该阶模块: classLV=%s" % classLV)
			return
			#GameWorld.DebugLog("----- 刷境界装备战力: classLV=%s" % (classLV))

			allEquipBaseAttrDict = {} # 所有装备基础属性 {attrID:value, ...}
			baseEquipBaseAttrDict = {} # 基础装备基础属性{attrID:value, ...}
			equipBaseAttrDict = {} # 装备基础属性 {装备位:{attrID:value, ...}, ...}

			equipColorDict = {} # 装备品质信息 {装备位:itemColor, ...}
			allAttrListEquip = [{} for _ in range(4)] # 装备属性
			equip_addEquipBaseAttrPerList = [{}, {}, {}] # 装备功能点对装备基础的加成信息 [所有部位, 基础部位, 指定部位]
			baseAttrDictStar, totalStarLV = {}, 0
			allAttrListStar = [{} for _ in range(4)] # 升星属性
			star_addEquipBaseAttrPerList = [{}, {}, {}] # 升星功能点对装备基础的加成信息 [所有部位, 基础部位, 指定部位]
			baseAttrDictPlus, totalPlusLV = {}, 0
			allAttrListPlus = [{} for _ in range(4)] # 强化属性
			plus_addEquipBaseAttrPerList = [{}, {}, {}] # 强化功能点对装备基础的加成信息 [所有部位, 基础部位, 指定部位]
			baseAttrDictStone, totalStoneLV = {}, 0
			allAttrListStone = [{} for _ in range(4)] # 宝石属性
			#stone_addEquipBaseAttrPerList = [{}, {}, {}] # 宝石功能点对装备基础的加成信息 [所有部位, 基础部位, 指定部位]
			baseAttrDictWash, totalWashLV = {}, 0
			allAttrListWash = [{} for _ in range(4)] # 洗练属性
			#wash_addEquipBaseAttrPerList = [{}, {}, {}] # 洗练功能点对装备基础的加成信息 [所有部位, 基础部位, 指定部位]

			packType = IPY_GameWorld.rptEquip
			playerEquip = curPlayer.GetItemManager().GetPack(packType)
			equipPartStarIndexList = ChConfig.Pack_EquipPart_CanPlusStar.get(packType, [])
			#maxSuiteType = IpyGameDataPY.GetFuncCfg('EquipSuitColorStar', 2) #最大套装类型
			#equipPlaceList = [] # 有穿戴装备的装备位列表
			suitCntDict = {} #套装数量字典
			#legendAttrDict = {} #所有传奇属性
			equipScoreTotal = 0 #为解决装备评分、战力不一致的情况，装备战力改为由评分作为参数计算战力

			basePlusLVMin = None # 基础装备最小强化等级，计算大师强化属性用

			# 1. 循环遍历本阶装备
			for equipPlace in equipPartStarIndexList:
			ipyData = IpyGameDataPY.GetIpyGameData('EquipPlaceIndexMap', classLV, equipPlace)
			if not ipyData:
			continue
			equipIndex = ipyData.GetGridIndex()
			curEquip = playerEquip.GetAt(equipIndex)
			if not curEquip or curEquip.IsEmpty():
			continue

			#if not ItemCommon.CheckItemCanUseByExpireTime(curEquip):
			# # 过期，暂不判断，以后境界装备有时效装备再开启
			# continue

			#equipPlaceList.append(equipIndex)
			equipScoreTotal += ItemCommon.GetEquipGearScore(curEquip)

			itemColor = curEquip.GetItemColor()
			equipColorDict[equipPlace] = itemColor

			baseAttrDict = {} # 装备位基础属性: 物品表 + 星级基础
			isBaseEquip = equipPlace in ChConfig.EquipPlace_Base

			#GameWorld.DebugLog("装备位 %s: itemID=%s,isBaseEquip=%s,equipScoreTotal=%s" % (equipPlace, curEquip.GetItemTypeID(), isBaseEquip, equipScoreTotal))

			#基础属性效果
			for i in xrange(curEquip.GetEffectCount()):
			curEffect = curEquip.GetEffectByIndex(i)
			if not curEffect:
			break
			effectID = curEffect.GetEffectID()
			if effectID == 0:
			#最后一个
			break
			effectValue = curEffect.GetEffectValue(0)
			if not effectValue:
			continue
			PlayerControl.CalcAttrDict_Type(effectID, effectValue, allAttrListEquip)
			baseAttrDict[effectID] = baseAttrDict.get(effectID, 0) + effectValue
			allEquipBaseAttrDict[effectID] = allEquipBaseAttrDict.get(effectID, 0) + effectValue
			if isBaseEquip:
			baseEquipBaseAttrDict[effectID] = baseEquipBaseAttrDict.get(effectID, 0) + effectValue
			#GameWorld.DebugLog(" 物品表属性: ID=%s +%s" % (effectID, effectValue))

			#星数属性
			equipPartStar = GetEquipPartStarByRank(curPlayer, equipIndex, curEquip) # 生效的星数
			if equipPartStar:
			totalStarLV += equipPartStar
			#GameWorld.DebugLog(" 星级属性: classLV=%s, equipPlace=%s, equipPartStar=%s" % (classLV, equipPlace, equipPartStar))
			ipyData = IpyGameDataPY.GetIpyGameData('EquipStarUp', classLV, equipPlace, equipPartStar)
			starBaseAttrDict = {} if not ipyData else ipyData.GetBaseAttrInfo() # 星级基础
			for starBaseAttrID, starBaseAttrValue in starBaseAttrDict.items():
			PlayerControl.CalcAttrDict_Type(starBaseAttrID, starBaseAttrValue, allAttrListStar)
			baseAttrDict[starBaseAttrID] = baseAttrDict.get(starBaseAttrID, 0) + starBaseAttrValue
			baseAttrDictStar[starBaseAttrID] = baseAttrDictStar.get(starBaseAttrID, 0) + starBaseAttrValue
			allEquipBaseAttrDict[starBaseAttrID] = allEquipBaseAttrDict.get(starBaseAttrID, 0) + starBaseAttrValue
			if isBaseEquip:
			baseEquipBaseAttrDict[starBaseAttrID] = baseEquipBaseAttrDict.get(starBaseAttrID, 0) + starBaseAttrValue
			#GameWorld.DebugLog(" 星级基础属性: ID=%s +%s" % (starBaseAttrID, starBaseAttrValue))

			starAttrDict = {} if not ipyData else ipyData.GetStarAttrInfo() # 星级附加
			for starAttrID, starAttrValue in starAttrDict.items():
			PlayerControl.CalcAttrDict_Type(starAttrID, starAttrValue, allAttrListStar)
			#GameWorld.DebugLog(" 星级附加属性: ID=%s +%s" % (starAttrID, starAttrValue))
			__CalcFuncAddEquipAttrPer(equipPlace, starAttrID, starAttrValue, star_addEquipBaseAttrPerList)

			equipBaseAttrDict[equipPlace] = baseAttrDict

			#套装计数
			suiteID = curEquip.GetSuiteID()
			if suiteID:
			if suiteID not in suitCntDict:
			suitCntDict[suiteID] = []
			suitCntDict[suiteID].append(equipPartStar)

			#传奇属性
			legAttrIDList, legAttrValueList = ItemControler.GetEquipLegendAttrAll(curEquip)
			for i, legendAttrID in enumerate(legAttrIDList):
			legendAttrValue = legAttrValueList[i]
			PlayerControl.CalcAttrDict_Type(legendAttrID, legendAttrValue, allAttrListEquip)
			#GameWorld.DebugLog(" 传奇属性: ID=%s +%s" % (legendAttrID, legendAttrValue))
			__CalcFuncAddEquipAttrPer(equipPlace, legendAttrID, legendAttrValue, equip_addEquipBaseAttrPerList)

			#物品强化属性
			plusLV = __CalcAttr_ItemPlus(curPlayer, curEquip, packType, equipIndex, baseAttrDictPlus, allAttrListPlus, plus_addEquipBaseAttrPerList)
			totalPlusLV += plusLV
			if isBaseEquip:
			basePlusLVMin = plusLV if basePlusLVMin == None else min(basePlusLVMin, plusLV)

			#计算装备宝石加成
			gemLVList = CalcEquipStone_Effect(curPlayer, equipIndex, baseAttrDictStone, allAttrListStone)
			totalStoneLV += (sum(gemLVList) if gemLVList else 0)

			#洗练属性
			washLV = Operate_EquipWash.CalcAttr_EquipWash(curPlayer, equipIndex, equipPlace, baseAttrDictWash, allAttrListWash)
			totalWashLV += washLV

			# GameWorld.DebugLog(" 装备循环属性: %s" % (allAttrListEquip))
			# GameWorld.DebugLog(" 升星循环属性: %s" % (allAttrListStar))
			# GameWorld.DebugLog(" 强化循环属性: %s" % (allAttrListPlus))
			# GameWorld.DebugLog(" 宝石循环属性: %s" % (allAttrListStone))
			# GameWorld.DebugLog(" 洗练循环属性: %s" % (allAttrListWash))
			# GameWorld.DebugLog(" -----" )
			# 2. 计算遍历后的附加属性
			#套装属性，暂归为星级套装属性
			CalcEquipSuiteAttr(curPlayer, suitCntDict, allAttrListStar)
			#大师
			__CalcMasterPlusLVAttr(curPlayer, classLV, basePlusLVMin, allAttrListPlus, plus_addEquipBaseAttrPerList)

			# GameWorld.DebugLog(" 升星属性套装: %s" % (allAttrListEquip))

			# 3. 计算对装备基础的附加加成
			# GameWorld.DebugLog(" -----" )
			# GameWorld.DebugLog(" 所有装备基础属性: %s" % (allEquipBaseAttrDict))
			# GameWorld.DebugLog(" 基础装备基础属性: %s" % (baseEquipBaseAttrDict))
			# GameWorld.DebugLog(" 单件装备基础属性: %s" % (equipBaseAttrDict))
			# GameWorld.DebugLog(" -----" )
			#计算功能点对装备基础的加成
			insideAttrDictEquip, insideAttrDictStar, insideAttrDictPlus, insideAttrDictStone, insideAttrDictWash = {}, {}, {}, {}, {}
			__CalcFuncAddEquipAttrValue(allEquipBaseAttrDict, baseEquipBaseAttrDict, equipBaseAttrDict, equip_addEquipBaseAttrPerList, insideAttrDictEquip, "Equip")
			__CalcFuncAddEquipAttrValue(allEquipBaseAttrDict, baseEquipBaseAttrDict, equipBaseAttrDict, star_addEquipBaseAttrPerList, insideAttrDictStar, "Star")
			__CalcFuncAddEquipAttrValue(allEquipBaseAttrDict, baseEquipBaseAttrDict, equipBaseAttrDict, plus_addEquipBaseAttrPerList, insideAttrDictPlus, "Plus")
			#__CalcFuncAddEquipAttrValue(allEquipBaseAttrDict, baseEquipBaseAttrDict, equipBaseAttrDict, stone_addEquipBaseAttrPerList, insideAttrDictStone, "Stone")
			#__CalcFuncAddEquipAttrValue(allEquipBaseAttrDict, baseEquipBaseAttrDict, equipBaseAttrDict, wash_addEquipBaseAttrPerList, insideAttrDictWash, "Wash")

			#计算装备基础属性附加战力 (目前组成: 评分战力 + ...)
			equipFightPowerEx = eval(IpyGameDataPY.GetFuncCompileCfg("FightpowerFormula", 2))

			# 4. 累加所有阶装备位属性
			playerID = curPlayer.GetPlayerID()
			if playerID not in PyGameData.g_playerEquipPartAttrDict:
			PyGameData.g_playerEquipPartAttrDict[playerID] = {}
			equipPartAttrDict = PyGameData.g_playerEquipPartAttrDict[playerID]
			equipPartAttrDict[classLV] = [equipFightPowerEx,
			allAttrListEquip, insideAttrDictEquip, equipColorDict,
			baseAttrDictStar, allAttrListStar, insideAttrDictStar, totalStarLV,
			baseAttrDictPlus, allAttrListPlus, insideAttrDictPlus, totalPlusLV,
			baseAttrDictStone, allAttrListStone, insideAttrDictStone, totalStoneLV,
			baseAttrDictWash, allAttrListWash, insideAttrDictWash, totalWashLV,
			]

			# GameWorld.DebugLog(" ----- 累加所有阶装备位养成属性")
			# GameWorld.DebugLog(" 本阶装备战力: equipScoreTotal=%s,equipFightPowerEx=%s" % (equipScoreTotal, equipFightPowerEx))
			# GameWorld.DebugLog(" 本阶装备属性: %s, 内部加成=%s" % (allAttrListEquip, insideAttrDictEquip))
			# GameWorld.DebugLog(" 本阶升星属性: %s, 内部加成=%s" % (allAttrListStar, insideAttrDictStar))
			# GameWorld.DebugLog(" 本阶强化属性: %s, 内部加成=%s" % (allAttrListPlus, insideAttrDictPlus))
			# GameWorld.DebugLog(" 本阶宝石属性: %s, 内部加成=%s" % (allAttrListStone, insideAttrDictStone))
			# GameWorld.DebugLog(" 本阶洗练属性: %s, 内部加成=%s" % (allAttrListWash, insideAttrDictWash))

			allClassEquipFightPowerEx = 0
			allClassAttrListEquip, allClassInsideAttrDictEquip, classEquipColorDict = [{} for _ in range(4)], {}, {}
			allClassAttrListStar, allClassInsideAttrDictStar, classBaseAttrDictStar, classStarLVDict = [{} for _ in range(4)], {}, {}, {}
			allClassAttrListPlus, allClassInsideAttrDictPlus, classBaseAttrDictPlus, classPlusLVDict = [{} for _ in range(4)], {}, {}, {}
			allClassAttrListStone, allClassInsideAttrDictStone, classBaseAttrDictStone, classStoneLVDict = [{} for _ in range(4)], {}, {}, {}
			allClassAttrListWash, allClassInsideAttrDictWash, classBaseAttrDictWash, classWashLVDict = [{} for _ in range(4)], {}, {}, {}
			for classLV, attrList in equipPartAttrDict.items():
			equipFightPowerEx, \
			allAttrListEquip, insideAttrDictEquip, equipColorDict, \
			baseAttrDictStar, allAttrListStar, insideAttrDictStar, totalStarLV, \
			baseAttrDictPlus, allAttrListPlus, insideAttrDictPlus, totalPlusLV, \
			baseAttrDictStone, allAttrListStone, insideAttrDictStone, totalStoneLV, \
			baseAttrDictWash, allAttrListWash, insideAttrDictWash, totalWashLV = attrList
			#GameWorld.DebugLog(" classLV=%s, %s" % (classLV, attrList))
			allClassEquipFightPowerEx += equipFightPowerEx
			for i in xrange(4):
			PlayerControl.AddAttrDictValue(allClassAttrListEquip[i], allAttrListEquip[i])
			PlayerControl.AddAttrDictValue(allClassAttrListStar[i], allAttrListStar[i])
			PlayerControl.AddAttrDictValue(allClassAttrListPlus[i], allAttrListPlus[i])
			PlayerControl.AddAttrDictValue(allClassAttrListStone[i], allAttrListStone[i])
			PlayerControl.AddAttrDictValue(allClassAttrListWash[i], allAttrListWash[i])
			PlayerControl.AddAttrDictValue(allClassInsideAttrDictEquip, insideAttrDictEquip)
			PlayerControl.AddAttrDictValue(allClassInsideAttrDictStar, insideAttrDictStar)
			PlayerControl.AddAttrDictValue(allClassInsideAttrDictPlus, insideAttrDictPlus)
			PlayerControl.AddAttrDictValue(allClassInsideAttrDictStone, insideAttrDictStone)
			PlayerControl.AddAttrDictValue(allClassInsideAttrDictWash, insideAttrDictWash)

			classEquipColorDict[classLV] = equipColorDict
			classBaseAttrDictStar[classLV] = baseAttrDictStar
			classBaseAttrDictPlus[classLV] = baseAttrDictPlus
			classBaseAttrDictStone[classLV] = baseAttrDictStone
			classBaseAttrDictWash[classLV] = baseAttrDictWash
			classStarLVDict[classLV] = totalStarLV
			classPlusLVDict[classLV] = totalPlusLV
			classStoneLVDict[classLV] = totalStoneLV
			classWashLVDict[classLV] = totalWashLV

			customAttrDictEquip = {"classEquipColorDict":classEquipColorDict}
			customAttrDictStar = {"classBaseAttrDictStar":classBaseAttrDictStar, "classStarLVDict":classStarLVDict}
			customAttrDictPlus = {"classBaseAttrDictPlus":classBaseAttrDictPlus, "classPlusLVDict":classPlusLVDict}
			customAttrDictStone = {"classBaseAttrDictStone":classBaseAttrDictStone, "classStoneLVDict":classStoneLVDict}
			customAttrDictWash = {"classBaseAttrDictWash":classBaseAttrDictWash, "classWashLVDict":classWashLVDict}

			# GameWorld.DebugLog(" 所有阶装备战力: %s" % (allClassEquipFightPowerEx))
			# GameWorld.DebugLog(" 所有阶装备属性: %s, 内部加成=%s" % (allClassAttrListEquip, allClassInsideAttrDictEquip))
			# GameWorld.DebugLog(" 所有阶升星属性: %s, 内部加成=%s" % (allClassAttrListStar, allClassInsideAttrDictStar))
			# GameWorld.DebugLog(" 所有阶强化属性: %s, 内部加成=%s" % (allClassAttrListPlus, allClassInsideAttrDictPlus))
			# GameWorld.DebugLog(" 所有阶宝石属性: %s, 内部加成=%s" % (allClassAttrListStone, allClassInsideAttrDictStone))
			# GameWorld.DebugLog(" 所有阶洗练属性: %s, 内部加成=%s" % (allClassAttrListWash, allClassInsideAttrDictWash))
			PlayerControl.SetMFPExFightPower(curPlayer, ShareDefine.Def_MFPType_Equip, allClassEquipFightPowerEx)
			PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Equip, allClassAttrListEquip, allClassInsideAttrDictEquip, customAttrDict=customAttrDictEquip)
			PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Star, allClassAttrListStar, allClassInsideAttrDictStar, customAttrDict=customAttrDictStar)
			PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Plus, allClassAttrListPlus, allClassInsideAttrDictPlus, customAttrDict=customAttrDictPlus)
			PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Stone, allClassAttrListStone, allClassInsideAttrDictStone, customAttrDict=customAttrDictStone)
			PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Wash, allClassAttrListWash, allClassInsideAttrDictWash, customAttrDict=customAttrDictWash)
			return

			def __CalcFuncAddEquipAttrPer(equipPlace, attrID, attrValue, addPerInfoList):
			## 计算其他功能属性对装备基础属性的加成

			if attrID not in ChConfig.EquipBassAttrAddInfoSet:
			return
			effPlace, calcAttrList = ChConfig.EquipBassAttrAddInfoSet[attrID]
			#GameWorld.DebugLog(" 装备基础加成信息: ID=%s,effPlace=%s,calcAttrList=%s" % (attrID, effPlace, calcAttrList))
			# 所有部位
			if effPlace == -1:
			allPlaceAddPerDict = addPerInfoList[0]
			for calcAttrIndex in calcAttrList:
			allPlaceAddPerDict[calcAttrIndex] = allPlaceAddPerDict.get(calcAttrIndex, 0) + attrValue
			#GameWorld.DebugLog(" 当前加成信息=%s" % (addPerInfoList))
			return

			# 基础部位
			if effPlace == -2:
			basePlaceAddPerDict = addPerInfoList[1]
			for calcAttrIndex in calcAttrList:
			basePlaceAddPerDict[calcAttrIndex] = basePlaceAddPerDict.get(calcAttrIndex, 0) + attrValue
			#GameWorld.DebugLog(" 当前加成信息=%s" % (addPerInfoList))
			return

			# 指定部位
			elif effPlace > 0 and equipPlace == effPlace:
			assignPlaceAddPerDict = addPerInfoList[2]
			if equipPlace not in assignPlaceAddPerDict:
			assignPlaceAddPerDict[equipPlace] = {}
			curPlaceAddPerDict = assignPlaceAddPerDict[equipPlace]
			for calcAttrIndex in calcAttrList:
			curPlaceAddPerDict[calcAttrIndex] = curPlaceAddPerDict.get(calcAttrIndex, 0) + attrValue
			#GameWorld.DebugLog(" 当前加成信息=%s" % (addPerInfoList))
			return

			return

			def __CalcFuncAddEquipAttrValue(allEquipBaseAttrDict, baseEquipBaseAttrDict, equipBaseAttrDict, addEquipBaseAttrPerList, allAttrDict, sign=""):
			## 计算其他功能属性对装备基础属性加成的属性具体值
			allPlaceAddPerDict, basePlaceAddPerDict, assignPlaceAddPerDict = addEquipBaseAttrPerList
			#GameWorld.DebugLog(" 计算功能点对装备基础属性加成: %s" % sign)
			#GameWorld.DebugLog(" 全部装备属性: %s, 加成%s" % (allEquipBaseAttrDict, allPlaceAddPerDict))
			for attrID, addPer in allPlaceAddPerDict.items():
			if attrID not in allEquipBaseAttrDict:
			continue
			baseValue = allEquipBaseAttrDict[attrID]
			addValue = int(baseValue * addPer / 10000.0)
			PlayerControl.CalcAttrDict_TypeEx(attrID, addValue, allAttrDict)
			#GameWorld.DebugLog(" 加成: ID=%s +%s %s" % (attrID, addValue, addPer))

			#GameWorld.DebugLog(" 基础装备属性: %s, 加成%s" % (baseEquipBaseAttrDict, basePlaceAddPerDict))
			for attrID, addPer in basePlaceAddPerDict.items():
			if attrID not in baseEquipBaseAttrDict:
			continue
			baseValue = baseEquipBaseAttrDict[attrID]
			addValue = int(baseValue * addPer / 10000.0)
			PlayerControl.CalcAttrDict_TypeEx(attrID, addValue, allAttrDict)
			#GameWorld.DebugLog(" 加成: ID=%s +%s %s" % (attrID, addValue, addPer))

			#GameWorld.DebugLog(" 指定装备属性: %s, 加成%s" % (equipBaseAttrDict, assignPlaceAddPerDict))
			for equipPlace, addPerDict in assignPlaceAddPerDict.items():
			if equipPlace not in equipBaseAttrDict:
			continue
			baseAttrDict = equipBaseAttrDict[equipPlace]
			for attrID, addPer in addPerDict.items():
			if attrID not in baseAttrDict:
			continue
			baseValue = baseAttrDict[attrID]
			addValue = int(baseValue * addPer / 10000.0)
			PlayerControl.CalcAttrDict_TypeEx(attrID, addValue, allAttrDict)
			#GameWorld.DebugLog(" 加成: ID=%s +%s %s" % (attrID, addValue, addPer))
			return

			def CalcAttr_LegendAttr(curPlayer, curEquip, allAttrListEquip, legendAttrDict={}):
			## 计算传奇属性

			legAttrIDList, legAttrValueList = ItemControler.GetEquipLegendAttrAll(curEquip)
			if not legAttrIDList:
			#GameWorld.DebugLog("没有传奇属性！")
			return
			#GameWorld.DebugLog("传奇属性: place=%s,IDList=%s, v=%s" % (curEquip.GetEquipPlace(), legAttrIDList, legAttrValueList))

			for i, legendAttrID in enumerate(legAttrIDList):
			legendAttrValue = legAttrValueList[i]
			#GameWorld.DebugLog("加传奇属性: %s +%s" % (legendAttrID, legendAttrValue))
			PlayerControl.CalcAttrDict_Type(legendAttrID, legendAttrValue, allAttrListEquip)
			#legendAttrDict[attrID] = legendAttrDict.get(attrID, 0) + value

			return

			def __CalcAttr_ItemPlus(curPlayer, curEquip, packType, equipIndex, baseAttrDictPlus, allAttrList, plus_addEquipBaseAttrPerList):
			## 计算装备强化后的属性
			equipPartPlusLV = GetEquipPartPlusLV(curPlayer, packType, equipIndex)
			equipPartPlusEvolveLV = GetEquipPartPlusEvolveLV(curPlayer, packType, equipIndex)

			if not equipPartPlusLV:
			return equipPartPlusLV
			plusType = GetEquipPlusType(curEquip)
			if plusType is None:
			return equipPartPlusLV

			#GameWorld.DebugLog(" 强化属性: plusType=%s,equipPartPlusLV=%s,equipPartPlusEvolveLV=%s" % (plusType, equipPartPlusLV, equipPartPlusEvolveLV))
			ipyData = IpyGameDataPY.GetIpyGameData("ItemPlus", plusType, equipPartPlusLV)
			if not ipyData:
			return equipPartPlusLV
			attrTypeList, attrValueList = ipyData.GetAttrType(), ipyData.GetAttrValue()
			for i, attrID in enumerate(attrTypeList):
			#GameWorld.DebugLog(" 强化基础属性: ID=%s +%s" % (attrID, attrValueList[i]))
			PlayerControl.CalcAttrDict_Type(attrID, attrValueList[i], allAttrList)
			baseAttrDictPlus[attrID] = baseAttrDictPlus.get(attrID, 0) + attrValueList[i]

			if not equipPartPlusEvolveLV:
			return equipPartPlusLV
			#进化属性
			equipPlace = curEquip.GetEquipPlace()
			ipyData = IpyGameDataPY.GetIpyGameData('EquipPlusEvolve', equipPlace, equipPartPlusEvolveLV)
			if not ipyData:
			return equipPartPlusLV
			for attrID, attrValue in ipyData.GetAttr().items():
			#GameWorld.DebugLog(" 强化进阶属性: ID=%s +%s" % (attrID, attrValue))
			PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrList)
			__CalcFuncAddEquipAttrPer(equipPlace, attrID, attrValue, plus_addEquipBaseAttrPerList)

			return equipPartPlusLV

			def __CalcMasterPlusLVAttr(curPlayer, classLV, basePlusLVMin, allAttrListPlus, plus_addEquipBaseAttrPerList):
			## 计算装备大师强化属性

			ipyDataList = IpyGameDataPY.GetIpyGameDataList("ItemPlusMaster", classLV)
			if not ipyDataList:
			return

			actMasterPlusLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartMasterPlusLV % classLV) # 已激活的最大大师等级

			for ipyData in ipyDataList:
			needMasterPlusLV = ipyData.GetMasterPlusLV()
			if basePlusLVMin < needMasterPlusLV:
			#GameWorld.DebugLog(" 未达到大师强化等级! classLV=%s,basePlusLVMin=%s < needMasterPlusLV=%s" % (classLV, basePlusLVMin, needMasterPlusLV))
			continue
			if actMasterPlusLV < needMasterPlusLV:
			#GameWorld.DebugLog(" 未激活大师强化等级! classLV=%s,actMasterPlusLV=%s < needMasterPlusLV=%s" % (classLV, actMasterPlusLV, needMasterPlusLV))
			continue

			attrIDList = ipyData.GetMasterPlusAttrIDList()
			attrValueList = ipyData.GetMasterPlusAttrValueList()
			for i, attrID in enumerate(attrIDList):
			attrValue = attrValueList[i]
			PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListPlus)
			__CalcFuncAddEquipAttrPer(None, attrID, attrValue, plus_addEquipBaseAttrPerList)
			#GameWorld.DebugLog(" 强化大师属性! needMasterPlusLV=%s, attrID=%s + %s" % (needMasterPlusLV, attrID, attrValue))

			return

			## 装备套装属性计算
			# @param curPlayer 当前玩家
			# @return None
			def CalcEquipSuiteAttr(curPlayer, suitCntDict, allAttrListSuit):
			if not suitCntDict:
			return
			#GameWorld.DebugLog(' suitCntDict=%s'%suitCntDict)
			learnSkillInfo = {}
			suiteSkillTypeIDList = []
			skillManager = curPlayer.GetSkillManager()
			for suiteID, starList in suitCntDict.items():
			ipyDataList = IpyGameDataPY.GetIpyGameDataList('EquipSuitAttr', suiteID)
			if not ipyDataList:
			continue
			for ipyData in ipyDataList:
			suiteCnt = ipyData.GetSuiteCnt()
			needStar = ipyData.GetStar()
			skillID = ipyData.GetSkillID()
			activateIndex = ipyData.GetActivateIndex()
			isActivate = GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_EquipPartSuiteActivate, activateIndex)
			skillData = None if not skillID else GameWorld.GetGameData().GetSkillBySkillID(skillID)
			skillTypeID = 0 if not skillData else skillData.GetSkillTypeID()
			skillLV = 0 if not skillData else skillData.GetSkillLV()
			#GameWorld.DebugLog("suiteID=%s,suiteCnt=%s,needStar=%s,isActivate=%s,skillID=%s,skillTypeID=%s,skillLV=%s" % (suiteID, suiteCnt, needStar, isActivate, skillID, skillTypeID, skillLV))
			if skillTypeID and skillTypeID not in suiteSkillTypeIDList:
			suiteSkillTypeIDList.append(skillTypeID)
			if isActivate and [1 if star >= needStar else 0 for star in starList].count(1) >= suiteCnt:
			#GameWorld.DebugLog(" 套装: suiteID=%s,suiteCnt=%s,needStar=%s" % (suiteID, suiteCnt, needStar))
			for attrID, attrValue in ipyData.GetAttrInfo().items():
			PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListSuit)
			#GameWorld.DebugLog(" 属性: ID=%s +%s" % (attrID, attrValue))
			#技能
			if skillTypeID and skillLV and skillLV > learnSkillInfo.get(skillTypeID, 0):
			learnSkillInfo[skillTypeID] = skillLV

			#GameWorld.DebugLog("suiteSkillTypeIDList:%s" % suiteSkillTypeIDList)
			#GameWorld.DebugLog("learnSkillInfo:%s" % learnSkillInfo)
			skillChange = False
			playerCtl = PlayerControl.PlayerControl(curPlayer)
			for skillTypeID in suiteSkillTypeIDList:
			if skillTypeID in learnSkillInfo:
			#需要学习的不处理
			continue
			curSkill = skillManager.FindSkillBySkillTypeID(skillTypeID)
			if not curSkill:
			continue
			skillChange = True
			skillID = curSkill.GetSkillID()
			GameWorld.DebugLog(" 删除套装技能: skillID=%s" % skillID)
			skillManager.DeleteSkillBySkillID(skillID)
			playerCtl.RefreshSkillFightPowerByDel(skillID)

			for skillTypeID, skillLV in learnSkillInfo.items():
			skillData = GameWorld.GetGameData().FindSkillByType(skillTypeID, skillLV)
			if not skillData:
			continue
			skillID = skillData.GetSkillID()
			curSkill = skillManager.FindSkillBySkillTypeID(skillTypeID)
			if curSkill:
			if skillLV == curSkill.GetSkillLV():
			continue
			delSkillID = curSkill.GetSkillID()
			GameWorld.DebugLog(" 删除套装技能等级: skillTypeID=%s,skillLV=%s,skillID=%s,delSkillID=%s" % (skillTypeID, skillLV, skillID, delSkillID))
			skillManager.DeleteSkillBySkillID(delSkillID)
			playerCtl.RefreshSkillFightPowerByDel(delSkillID)

			GameWorld.DebugLog(" 激活套装技能等级: skillTypeID=%s,skillLV=%s,skillID=%s" % (skillTypeID, skillLV, skillID))
			skillManager.LVUPSkillByID(skillID)
			playerCtl.RefreshSkillFightPowerEx(skillID, 0)
			skillChange = True

			if skillChange:
			# 重刷被动技能
			PassiveBuffEffMng.GetPassiveEffManager().RegistPassiveEff(curPlayer)
			return

			#// A5 C6 装备部位星级套装激活 #tagCMEquipPartSuiteActivate
			@@ -1322,193 +455,6 @@
			NetPackCommon.SendFakePack(curPlayer, activateInfo)
			return


			## 1算装备触发的技能（全身）
			# @param curPlayer 当前玩家
			# @param curEquip 当前装备
			# @return None
			# @remarks 函数详细说明.
			def CalcCurEquip_SkillBuff(curPlayer, curEquip):
			SkillShell.RefreshSkillBuffByEquip(curPlayer, curEquip)
			return


			## 计算装备镶嵌宝石附加效果->基本属性 (宝石)
			# @param curPlayer 当前玩家
			# @param curEquip 当前装备
			# @param allAttrList 属性信息
			# @return 无返回值
			def CalcEquipStone_Effect(curPlayer, equipIndex, baseAttrDictStone, allAttrList):
			gameData = GameWorld.GetGameData()

			effIndexList = [1, 2, 3, 4] # 第一个效果值是类型等级效果值，非属性效果值
			gemLVList = []
			for holeIndex in Operate_EquipStone.GetAllEquipPlaceHoleIndex():

			curGemID = Operate_EquipStone.GetEquipIndexStoneIDAndIsBand(curPlayer, equipIndex, holeIndex)[0]
			if curGemID == 0:
			continue
			curGem = gameData.GetItemByTypeID(curGemID)
			if not curGem:
			GameWorld.ErrLog('equip stone id:%s not in item table' % (curGemID))
			continue
			for effIndex in effIndexList:
			curGemEffect = curGem.GetEffectByIndex(effIndex)
			effectID, effectValue = curGemEffect.GetEffectID(), curGemEffect.GetEffectValue(0)
			if effectID and effectValue:
			PlayerControl.CalcAttrDict_Type(effectID, effectValue, allAttrList)
			baseAttrDictStone[effectID] = baseAttrDictStone.get(effectID, 0) + effectValue
			gemEffect = curGem.GetEffectByIndex(0)
			gemLV = gemEffect.GetEffectValue(1)
			gemLVList.append(gemLV)
			return gemLVList

			#---------------------------------------------------------------------
			## 装备添加Buff
			# @param curPlayer 当前玩家
			# @param addSkillID 技能ID
			# @return None
			# @remarks 函数详细说明.
			def EquipAddBuff(curPlayer, addSkillID, value=0):

			value = min(value, ChConfig.Def_UpperLimit_DWord)
			curBuff = curPlayer.GetEquipBuff().AddBuff(addSkillID, 0, False)
			curBuff.SetOwnerID(curPlayer.GetID())
			curBuff.SetOwnerType(curPlayer.GetGameObjType())
			if value > 0:
			curBuff.SetValue(value)
			return


			#---------------------------------------------------------------------
			#===============================================================================
			# #//03 2F 请求装备显隐#tagRequestEquipShowHide
			# //装备显示开关
			# int GetEquipShowSwitch(); 灵宠外观索引10000000+坐骑外观索引1000000+灵根特效表key * 1000+第几套*10+是否有套装
			#===============================================================================
			##请求装备显隐. （设置显示哪套装备外观）
			# @param index 玩家索引
			# @param tick 时间戳
			# @return 返回值无意义
			# @remarks 客户端封包响应 //03 2F 请求装备显隐#tagRequestEquipShowHide
			def RequestEquipShowHide(index, tick):
			curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

			#---检查刷新间隔--
			interval = ChConfig.TYPE_Player_Tick_Time[ChConfig.TYPE_Player_Tick_RequestEquipShowHide]

			if tick - curPlayer.GetTickByType(ChConfig.TYPE_Player_Tick_RequestEquipShowHide) < interval:
			#没有到刷新间隔，54外挂，不给提示
			# GameWorld.ErrLog('请求装备显隐, 没有到刷新间隔')
			return
			curPlayer.SetTickByType(ChConfig.TYPE_Player_Tick_RequestEquipShowHide, tick)
			sendPack = IPY_GameWorld.IPY_CRequestEquipShowHide()
			classLV = sendPack.GetEquipShowSwitch()
			oldClassLV = GetEquipFacadeClassLV(curPlayer)
			if oldClassLV == classLV:
			return
			if not ChangeEquipfacadeByClassLV(curPlayer, classLV):
			return

			#通知外观装备
			updFaceEquipIndex = 0
			equipIndexList = []

			for equipPlace in [ShareDefine.retWeapon, ShareDefine.retWeapon2, ShareDefine.retClothes]:
			ipyData = IpyGameDataPY.GetIpyGameData('EquipPlaceIndexMap', classLV, equipPlace)
			if not ipyData:
			continue
			gridIndex = ipyData.GetGridIndex()
			updFaceEquipIndex = updFaceEquipIndex * 1000 + gridIndex
			equipIndexList.append(gridIndex)

			PlayerControl.SetFaceEquipIndex(curPlayer, updFaceEquipIndex)
			equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
			for equipPackIndex in equipIndexList:
			curEquip = equipPack.GetAt(equipPackIndex)
			if not ItemCommon.CheckItemCanUse(curEquip):
			continue
			changeItemID = curEquip.GetItemTypeID()
			changeItemStarLV = 0 #curItem.GetItemStarLV()
			changeItemStoneCnt = 0 #curItem.GetUseStoneCount()
			changeItemHoleCnt = 0 #curItem.GetCanPlaceStoneCount()
			changeItemUseData = curEquip.GetUserData()
			curPlayer.ChangeEquip(changeItemID, equipPackIndex, changeItemStarLV, changeItemHoleCnt, changeItemStoneCnt, changeItemUseData)

			return

			def ChangeEquipfacadeByClassLV(curPlayer, classLV):
			##变更第X套装备外观灵根特效表key * 1000+第几套*10+是否有套装
			oldEquipShowSwitch = curPlayer.GetEquipShowSwitch()
			realSuit=1
			equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
			for place in ChConfig.EquipPlace_Base:
			ipyData = IpyGameDataPY.GetIpyGameData('EquipPlaceIndexMap', classLV, place)
			if not ipyData:
			realSuit = 0
			break
			gridIndex = ipyData.GetGridIndex()
			curEquip = equipPack.GetAt(gridIndex)
			if not ItemCommon.CheckItemCanUse(curEquip):
			realSuit = 0
			break
			if not curEquip.GetSuiteID():
			realSuit = 0
			break
			updEquipShowSwitch = oldEquipShowSwitch /10001000+ classLV10+realSuit
			if oldEquipShowSwitch == updEquipShowSwitch:
			return
			curPlayer.SetEquipShowSwitch(updEquipShowSwitch)
			ChangeEquipEffectByPlusMaster(curPlayer, classLV)
			return True

			#!!! 特效根据灵根品级变化改成根据强化大师变化
			def ChangeEquipfacadeByLingGen(curPlayer):
			# ## 灵根品级变化影响角色外观显示灵根特效表key * 1000+第几套*10+是否有套装
			# pointValueInfo = [[ShareDefine.Def_Effect_Metal,PlayerControl.GetMetalQualityLV(curPlayer)],
			# [ShareDefine.Def_Effect_Wood,PlayerControl.GetWoodQualityLV(curPlayer)],
			# [ShareDefine.Def_Effect_Water,PlayerControl.GetWaterQualityLV(curPlayer)],
			# [ShareDefine.Def_Effect_Fire,PlayerControl.GetFireQualityLV(curPlayer)],
			# [ShareDefine.Def_Effect_Earth,PlayerControl.GetEarthQualityLV(curPlayer)],
			# ]
			# g_skillElementCntDict = {} #灵根对应使用专精技能数量
			# skillManager = curPlayer.GetSkillManager()
			# gameData = GameWorld.GetGameData()
			# for i in xrange(skillManager.GetSkillCount()):
			# curSkill = skillManager.GetSkillByIndex(i)
			# skillID = curSkill.GetSkillTypeID()
			# curSelectSkillID = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_SkillElementID % skillID)
			# if not curSelectSkillID:
			# continue
			# elementSkillData = gameData.GetSkillBySkillID(curSelectSkillID)
			# if not elementSkillData:
			# continue
			# skillElementType = SkillShell.GetSkillElementType(elementSkillData)
			# g_skillElementCntDict[skillElementType] = g_skillElementCntDict.get(skillElementType, 0) + 1
			#
			# showPointID, showQualityLV = 0, 0
			# for pointID, qualityLV in pointValueInfo:
			# if qualityLV > showQualityLV:
			# showQualityLV = qualityLV
			# showPointID = pointID
			# elif showQualityLV and qualityLV == showQualityLV:
			# #比谁的专精技能数量多
			# if g_skillElementCntDict.get(pointID, 0) > g_skillElementCntDict.get(showPointID, 0):
			# showQualityLV = qualityLV
			# showPointID = pointID
			# effectID = 0
			# if showPointID:
			# ipyData = IpyGameDataPY.GetIpyGameData('LingGenEffect', showPointID, showQualityLV)
			# if not ipyData:
			# return
			# effectID = ipyData.GetID()
			# oldEquipShowSwitch = curPlayer.GetEquipShowSwitch()
			# updEquipShowSwitch = oldEquipShowSwitch % 1000 + oldEquipShowSwitch / 1000000 * 1000000+ 1000 * effectID
			# GameWorld.DebugLog('灵根品级变化影响角色外观显示g_skillElementCntDict=%s,oldEquipShowSwitch=%s,updEquipShowSwitch=%s'%
			# (g_skillElementCntDict, oldEquipShowSwitch, updEquipShowSwitch))
			# if oldEquipShowSwitch != updEquipShowSwitch:
			# curPlayer.SetEquipShowSwitch(updEquipShowSwitch)
			return
			def ChangeEquipEffectByPlusMaster(curPlayer, classLV):
			# 强化大师特效
			if (classLV != GetEquipFacadeClassLV(curPlayer)):