129 【战斗】战斗系统-服务端（王元姬技能，弹射待处理；支持被动变更伤害倍值；）

hxp

8 天以前 63f6f44ec2a38eaec9f39bbe26edb07daed49b49

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Item/ChEquip.py

@@ -16,439 +16,53 @@
#------------------------------------------------------------------------------ 

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





##检查玩家是否可以换装

# @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

    
    return True





## 执行玩家换装逻辑

#  @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)

    
    #---验证是否可以换这件装备---

    if not ItemCommon.CheckItemCanUse(curItem):

        return False

    
    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





## 刷新装备对人物属性的改变

#  @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)

def RefreshRoleEquipAttr(curPlayer):

    ## 刷新主公装备属性

    CalcRoleEquipAttr(curPlayer)

    PlayerOnline.GetOnlinePlayer(curPlayer).RefreshRoleAttr()

    return



def OnPlayerEquipLoginLogic(curPlayer):

    ''' 玩家登录统一处理装备，只遍历一次装备背包，通知信息、更新一次数据，防止总等级统计异常

                    装备品质橙装及以上数量、装备总星数、强化总等级、进化总等级、洗练总等级、宝石总等级

    '''

def CalcRoleEquipAttr(curPlayer):

    ## 计算主公装备属性

    playerID = curPlayer.GetPlayerID()

    mainEquipAttrDict = {}

    

    #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:

    
    # 主装备

    for equipPlace in ChConfig.Def_MainEquipPlaces:

        equipIndex = equipPlace - 1

        if equipIndex < 0 or equipIndex >= equipPack.GetCount():

            continue

        # 只计算有阶的境界装备

        if not ipyData.GetClassLV():

        curEquip = equipPack.GetAt(equipIndex)

        if not curEquip or curEquip.IsEmpty():

            continue

        #itemColor = curEquip.GetItemColor()

        

        curEquip = equipPack.GetAt(index)

        if not curEquip.IsEmpty():

            if curEquip.GetItemColor() >= ShareDefine.Def_Item_Color_Orange:

                orangeEquipCount += 1

        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

                

        # 星级

        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)

        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

                
    GameWorld.DebugLog("主线装备属性: %s" % mainEquipAttrDict, playerID)

    PlayerOnline.GetOnlinePlayer(curPlayer).SetCalcAttr(ChConfig.Def_CalcAttr_MainEquip, mainEquipAttrDict)

    return



#// A3 18 灵器突破 #tagCMLingQiEquipBreak

@@ -459,71 +73,6 @@
#    DWORD        ItemID;  //突破的物品ID

#}; 

def OnLingQiEquipBreak(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    breakItemID = clientData.ItemID

    ipyData = IpyGameDataPY.GetIpyGameData('LingQiAttr', breakItemID)

    if not ipyData:

        return

    nextItemID = ipyData.GetNextItemID() #突破后的物品ID

    if not IpyGameDataPY.GetIpyGameData('LingQiAttr', nextItemID):

        return

    breakItemData = GameWorld.GetGameData().GetItemByTypeID(breakItemID)

    nextItemData = GameWorld.GetGameData().GetItemByTypeID(nextItemID)

    if not breakItemData or not nextItemData:

        return

    equipIndex = ItemCommon.GetEquipPackIndex(breakItemData)

    if equipIndex != ItemCommon.GetEquipPackIndex(nextItemData):

        GameWorld.DebugLog("突破的物品和突破后的物品不是同个装备位！breakItemID=%s,nextItemID=%s" 
                           % (breakItemID, nextItemID))

        return

    equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)

    curEquip = equipPack.GetAt(equipIndex)

    if not curEquip or curEquip.IsEmpty():

        GameWorld.DebugLog("突破的物品未穿戴！breakItemID=%s" 
                           % (breakItemID))

        return

    if curEquip.GetEndureReduceType():

        GameWorld.DebugLog("突破的物品是时效物品！breakItemID=%s" 
                           % (breakItemID))

        return

    if curEquip.GetItemTypeID() != breakItemID:

        GameWorld.DebugLog("突破的物品未穿戴！breakItemID=%s" 
                           % (breakItemID))

        return

        
        
    costItemDict = ipyData.GetUpCostItem()

    itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)

    lackItemDict, delInfoDict = ItemCommon.GetCostItemIndexList(costItemDict, itemPack)

    if lackItemDict:

        GameWorld.DebugLog("突破消耗物品不足！breakItemID=%s,costItemDict=%s,lackItemDict=%s" 
                           % (breakItemID, costItemDict, lackItemDict))

        return

    
    #扣消耗

    ItemCommon.DelCostItem(curPlayer, itemPack, delInfoDict, 'LingQiEquipBreak')

    ItemCommon.DelItem(curPlayer, curEquip, 1, False, ChConfig.ItemDel_LingQiEquipBreak, {}, True)

    #给突破后灵器

    if not ItemControler.PutItemInTempSwap(curPlayer, nextItemID):

        GameWorld.Log("灵器突破后ID(%s)放入临时交换背包失败!" % (nextItemID), curPlayer.GetID())

        return

    ItemCommon.DoLogicSwitchItemEx(curPlayer, ShareDefine.rptTempSwap, IPY_GameWorld.rptEquip, 0, equipIndex)



    changeItemStarLV = 0  #curItem.GetItemStarLV()

    changeItemStoneCnt = 0  #curItem.GetUseStoneCount()

    changeItemHoleCnt = 0  #curItem.GetCanPlaceStoneCount()

    changeItemUseData = ''

    curPlayer.ChangeEquip(nextItemID, equipIndex, changeItemStarLV, changeItemHoleCnt, changeItemStoneCnt, changeItemUseData)

    #刷属性

    RefreshPlayerLingQiEquipAttr(curPlayer)

    playControl = PlayerControl.PlayerControl(curPlayer)

    playControl.RefreshPlayerAttrState()

    #通知结果

    resultPack = ChPyNetSendPack.tagMCLingQiEquipBreakResult()

    resultPack.Clear()

    resultPack.MakeItemID = nextItemID

    NetPackCommon.SendFakePack(curPlayer, resultPack)

    PlayerControl.WorldNotify(0, 'SpiritOrgan', [curPlayer.GetName(), breakItemID, nextItemID])

    return



#// A3 27 灵器培养 #tagCMLingQiTrain

@@ -536,719 +85,15 @@
#    WORD        UseItemCnt;        //消耗材料个数

#};

def OnLingQiTrain(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    
    equipPlace = clientData.EquipPlace # 灵器装备位

    trainType = clientData.TrainType # 培养类型

    costItemCount = clientData.UseItemCnt # 消耗材料个数

    
    trainLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_LingQiTrainLV % (equipPlace, trainType))

    curEatItemCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_LingQiTrainItemCount % (equipPlace, trainType))

    GameWorld.DebugLog("灵器培养: equipPlace=%s,trainType=%s,trainLV=%s,costItemCount=%s,curEatItemCount=%s" 
                       % (equipPlace, trainType, trainLV, costItemCount, curEatItemCount))

    
    if equipPlace not in ChConfig.EquipPlace_LingQi:

        return

    
    if trainType <= 0 or trainType > GetLingQiTrainTypes(equipPlace):

        return

    
    if trainLV <= 0:

        GameWorld.DebugLog("    培养未激活  trainType=%s" % trainType)

        return

    
    trainIpyData = IpyGameDataPY.GetIpyGameData("LingQiTrain", equipPlace, trainType, trainLV)

    if not trainIpyData:

        return

    
    needRealmLV = trainIpyData.GetNeedRealmLV()

    curRealmLV = PlayerControl.GetTrainRealmLVReal(curPlayer, 3)

    if curRealmLV < needRealmLV:

        GameWorld.DebugLog("    境界不足，无法培养！  curRealmLV(%s) < needRealmLV(%s)" % (curRealmLV, needRealmLV))

        return

    
    needEatCountTotal = trainIpyData.GetEatCntTotal()

    if not needEatCountTotal:

        GameWorld.DebugLog("    该培养已满级！")

        return

    
    costItemIDList = IpyGameDataPY.GetFuncEvalCfg("LingQiTrain", 1, {}).get(str(equipPlace), [])

    costItemID = costItemIDList[trainType - 1]

    if not costItemID or not costItemCount:

        return

    
    costItemIndexList, bindCnt, unBindCnt = ItemCommon.GetPackItemBindStateIndexInfo(curPlayer, costItemID, costItemCount)

    lackCnt = costItemCount - bindCnt - unBindCnt

    if lackCnt > 0:

        GameWorld.DebugLog("    消耗道具不足，无法培养!costItemID=%s,costItemCount=%s,bindCnt=%s,unBindCnt=%s,lackCnt=%s" 
                           % (costItemID, costItemCount, bindCnt, unBindCnt, lackCnt))

        return

    
    delCnt = costItemCount

    
    # 扣除消耗

    if delCnt:

        ItemCommon.DelCostItemByBind(curPlayer, costItemIndexList, bindCnt, unBindCnt, delCnt, "LingQiTrain")

        
    updClassLV = trainLV

    updEatItemCount = curEatItemCount + costItemCount

    GameWorld.DebugLog("    updEatItemCount=%s,needEatCountTotal=%s" % (updEatItemCount, needEatCountTotal))

    
    if updEatItemCount >= needEatCountTotal:

        updClassLV += 1

        updEatItemCount -= needEatCountTotal

        GameWorld.DebugLog("    进阶: updClassLV=%s,updEatItemCount=%s" % (updClassLV, updEatItemCount))

        
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_LingQiTrainLV % (equipPlace, trainType), updClassLV)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_LingQiTrainItemCount % (equipPlace, trainType), updEatItemCount)

    
    # 升阶

    if updClassLV > trainLV:

        pass

    
    Sync_LingQiTrainData(curPlayer, equipPlace)

    # 刷属性

    RefreshPlayerLingQiEquipAttr(curPlayer)

    PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState()

    return



def GetLingQiTrainTypes(equipPlace):

    return len(IpyGameDataPY.GetFuncEvalCfg("LingQiTrain", 1, {}).get(str(equipPlace), []))



def Sync_LingQiTrainData(curPlayer, equipPlace):

    clientPack = ChPyNetSendPack.tagMCLingQiTrainInfo()

    clientPack.EquipPlace = equipPlace

    clientPack.TrainLVList = []

    clientPack.TrainItemCountList = []

    for trainType in xrange(1, GetLingQiTrainTypes(equipPlace) + 1):

        trainLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_LingQiTrainLV % (equipPlace, trainType))

        if trainLV == 0:

            trainLV = 1

            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_LingQiTrainLV % (equipPlace, trainType), trainLV)

        clientPack.TrainLVList.append(trainLV)

        clientPack.TrainItemCountList.append(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_LingQiTrainItemCount % (equipPlace, trainType)))

    clientPack.TrainTypes = len(clientPack.TrainLVList)

    NetPackCommon.SendFakePack(curPlayer, clientPack)

    return



def RefreshPlayerLingQiEquipAttr(curPlayer):

    ''' 刷新玩家灵器装备属性

    '''

    
    classLV = 0 # 灵器阶默认为0

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

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

    equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)

    equipScoreTotal = 0

    lv = curPlayer.GetLV()

    lqAttrFormatDict = IpyGameDataPY.GetFuncEvalCfg("OutOfPrintValue", 2, {})

    
    for equipPlace in ChConfig.EquipPlace_LingQi:

        
        ipyData = IpyGameDataPY.GetIpyGameData('EquipPlaceIndexMap', classLV, equipPlace)

        if not ipyData:

            continue

        
        equipIndex = ipyData.GetGridIndex()

        curEquip = equipPack.GetAt(equipIndex)

        if not curEquip or curEquip.IsEmpty():

            continue

        
        if not ItemCommon.CheckItemCanUseByExpireTime(curEquip):

            # 过期

            continue

        
        equipScoreTotal += ItemCommon.GetEquipGearScore(curEquip)

        
        itemID = curEquip.GetItemTypeID()

        #基础属性效果

        for effIndex in xrange(curEquip.GetEffectCount()):

            curEff = curEquip.GetEffectByIndex(effIndex)

            effID = curEff.GetEffectID()

            if effID == 0:

                break

            PlayerControl.CalcAttrDict_Type(effID, curEff.GetEffectValue(0), lingQiAttrList)

            
        #灵器属性

        lingQiIpyData = IpyGameDataPY.GetIpyGameDataNotLog("LingQiAttr", itemID)

        if lingQiIpyData:

            lingQiAttrIDList = lingQiIpyData.GetLingQiAttrID()

            lingQiAttrValueList = lingQiIpyData.GetLingQiAttrValue()

            for lqIndex, lqAttrID in enumerate(lingQiAttrIDList):

                if str(lqAttrID) in lqAttrFormatDict:

                    attrFormat = lqAttrFormatDict[str(lqAttrID)]

                    maxOOPValue = lingQiAttrValueList[lqIndex]

                    lqAttrValue = eval(FormulaControl.GetCompileFormula("LingQiAttrFormat_%s" % lqAttrID, attrFormat))

                else:

                    lqAttrValue = lingQiAttrValueList[lqIndex]

                    
                PlayerControl.CalcAttrDict_Type(lqAttrID, lqAttrValue, lingQiAttrList)

            
    # 新培养属性

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

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

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

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

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    for index in xrange(ipyDataMgr.GetLingQiTrainCount()):

        trainIpyData = ipyDataMgr.GetLingQiTrainByIndex(index)

        equipPlace = trainIpyData.GetEquipPlace()

        trainType = trainIpyData.GetTrainType()

        dataTrainLV = trainIpyData.GetTrainLV()

        
        if equipPlace == ShareDefine.retGuard1:

            lingQiTrainAttrList = guardTrainAttrList

        elif equipPlace == ShareDefine.retWing:

            lingQiTrainAttrList = wingTrainAttrList

        elif equipPlace == ShareDefine.retPeerlessWeapon:

            lingQiTrainAttrList = peerlessWeaponTrainAttrList

        elif equipPlace == ShareDefine.retPeerlessWeapon2:

            lingQiTrainAttrList = peerlessWeapon2TrainAttrList

        else:

            continue

        
        trainLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_LingQiTrainLV % (equipPlace, trainType))

        
        if dataTrainLV > trainLV:

            continue

        elif dataTrainLV == trainLV:

            trainItemCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_LingQiTrainItemCount % (equipPlace, trainType))

        else:

            trainItemCount = trainIpyData.GetEatCntTotal()

            
        # 等阶额外属性

        lvAttrTypeList = trainIpyData.GetLVAttrTypeList()

        lvAttrValueList = trainIpyData.GetLVAttrValueList()

        for i, attrID in enumerate(lvAttrTypeList):

            attrValue = lvAttrValueList[i]

            PlayerControl.CalcAttrDict_Type(attrID, attrValue, lingQiTrainAttrList)

            
        # 培养丹增加属性

        eatCntEverytime = trainIpyData.GetEatCntEverytime()

        if trainItemCount and eatCntEverytime:

            eatItemAttrTypeList = trainIpyData.GetEatItemAttrTypeList()

            eatItemAttrValueList = trainIpyData.GetEatItemAttrValueList()

            attrMultiple = trainItemCount / eatCntEverytime

            for i, attrID in enumerate(eatItemAttrTypeList):

                attrValue = eatItemAttrValueList[i]

                PlayerControl.CalcAttrDict_Type(attrID, attrValue * attrMultiple, lingQiTrainAttrList)

                
    #GameWorld.DebugLog("守护培养属性: %s" % guardTrainAttrList)

    #GameWorld.DebugLog("翅膀培养属性: %s" % wingTrainAttrList)

    #GameWorld.DebugLog("灭世培养属性: %s" % peerlessWeaponTrainAttrList)

    #GameWorld.DebugLog("噬魂培养属性: %s" % peerlessWeapon2TrainAttrList)

    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_GuardTarin, guardTrainAttrList)

    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_WingTarin, wingTrainAttrList)

    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PeerlessWeaponTrain, peerlessWeaponTrainAttrList)

    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PeerlessWeapon2Train, peerlessWeapon2TrainAttrList)

    
    lqFightPowerEx = eval(IpyGameDataPY.GetFuncCompileCfg("FightpowerFormula", 2))

    PlayerControl.SetMFPExFightPower(curPlayer, ShareDefine.Def_MFPType_LingQi, lqFightPowerEx)

    
    #GameWorld.DebugLog("灵器属性1: %s" % allAttrList)

    #GameWorld.DebugLog("灵器属性2: %s" % lingQiAttrList)

    #GameWorld.DebugLog("灵器评分战力: equipScoreTotal=%s, %s" % (equipScoreTotal, lqFightPowerEx))

    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_LingQi, allAttrList)

    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

@@ -1262,268 +107,7 @@
#    BYTE    Star;    // 星数

#};

def OnEquipPartSuiteActivate(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    classLV = clientData.ClassLV

    suiteID = clientData.SuiteID

    suiteCount = clientData.SuiteCount

    star = clientData.Star

    ipyDataList = IpyGameDataPY.GetIpyGameDataList('EquipSuitAttr', suiteID)

    if not ipyDataList:

        return

    
    actIpyData = None

    for ipyData in ipyDataList:

        needCount = ipyData.GetSuiteCnt()

        needStar = ipyData.GetStar()

        if suiteCount == needCount and star == needStar:

            actIpyData = ipyData

            break

        
    if not actIpyData:

        return

    activateIndex = actIpyData.GetActivateIndex()

    # 这里就不判断是否满足件数、星数条件了，算属性的时候本身也是条件之一，是否激活只是附加条件，这里只处理激活状态变更，能否激活前端判断即可

    isActivate = GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_EquipPartSuiteActivate, activateIndex)

    if isActivate:

        return

    GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_EquipPartSuiteActivate, activateIndex, 1)

    Sync_EquipPartSuiteActivateInfo(curPlayer)

    
    #广播

    notifyMark = actIpyData.GetIsNotify()

    if notifyMark:

        PlayerControl.WorldNotify(0, 'AllStarLevelUp' if needStar else 'AllStarLevelUp2', [curPlayer.GetPlayerName(), suiteID, suiteCount, star])

        
    RefreshPlayerEquipAttribute(curPlayer, classLV)

    #刷新所有属性

    playControl = PlayerControl.PlayerControl(curPlayer)

    playControl.RefreshPlayerAttrState()

    return



def Sync_EquipPartSuiteActivateInfo(curPlayer):

    ## 同步装备位星级套装激活状态信息

    #keyCount = 10

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    dataCount = ipyDataMgr.GetEquipSuitAttrCount()

    if not dataCount:

        return

    lastIpyData = ipyDataMgr.GetEquipSuitAttrByIndex(dataCount - 1)

    if not lastIpyData:

        return

    keyCount = 1 + lastIpyData.GetActivateIndex() / 31

    activateStateList = []

    for i in xrange(keyCount):

        activateStateList.append(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartSuiteActivate % i))

    if activateStateList.count(0) == keyCount:

        return

    activateInfo = ChPyNetSendPack.tagMCEquipPartSuiteActivateInfo()

    activateInfo.SuiteActivateStateInfo = activateStateList

    activateInfo.Count = len(activateInfo.SuiteActivateStateInfo)

    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 /1000*1000+ classLV*10+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)):

        return

    
    masterPlusLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartMasterPlusLV % classLV)

    ## 强化大师影响角色外观显示 强化大师等级 * 1000+第几套*10+是否有套装

    oldEquipShowSwitch = curPlayer.GetEquipShowSwitch()

    updEquipShowSwitch = oldEquipShowSwitch % 1000 + oldEquipShowSwitch / 1000000 * 1000000+ 1000 * masterPlusLV

    GameWorld.DebugLog('强化大师影变化影响角色外观显示,oldEquipShowSwitch=%s,updEquipShowSwitch=%s'%

                       (oldEquipShowSwitch, updEquipShowSwitch))

    if oldEquipShowSwitch != updEquipShowSwitch:

        curPlayer.SetEquipShowSwitch(updEquipShowSwitch)

    return





def ChangeEquipfacadeByHorsePetSkin(curPlayer, skinType, skinIndex):

    ##骑宠觉醒外观变更  灵宠外观索引*10000000+坐骑外观索引*1000000+灵根特效表key * 1000+第几套*10+是否有套装

@@ -1575,198 +159,7 @@
    

    return 0



#获取当前是第几套装备外观

def GetEquipFacadeClassLV(curPlayer):return curPlayer.GetEquipShowSwitch()%1000/10



## 获取公共部位强化熟练度

def GetEquipPartProficiency(curPlayer, packType, index):

    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartProficiency % (packType, index))



## 设置公共部位强化熟练度

def SetEquipPartProficiency(curPlayer, packType, index, value):

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_EquipPartProficiency % (packType, index), value)

    return



## 获取公共部位强化等级

def GetEquipPartPlusLV(curPlayer, packType, index):

    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartPlusLV % (packType, index))



## 设置公共部位强化等级

def SetEquipPartPlusLV(curPlayer, packType, index, curEquip, setPlusLV):

    befPlusLV = GetEquipPartPlusLV(curPlayer, packType, index)

    if befPlusLV == setPlusLV:

        return

    
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_EquipPartPlusLV % (packType, index), setPlusLV)

    #===========================================================================

    # if curEquip and not curEquip.IsEmpty():

    #    curEquip.SetItemStarLV(starLV)

    #===========================================================================

    
    # 同步更新强化总等级

    befTotalPlusLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TotalPlusLV)

    updTotalPlusLV = max(0, befTotalPlusLV + setPlusLV - befPlusLV)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TotalPlusLV, updTotalPlusLV)

    GameWorld.DebugLog("设置强化等级: index=%s,befPlusLV=%s,setPlusLV=%s,befTotalPlusLV=%s,updTotalPlusLV=%s" 
                       % (index, befPlusLV, setPlusLV, befTotalPlusLV, updTotalPlusLV))

    return



## 获取公共部位强化进化等级

def GetEquipPartPlusEvolveLV(curPlayer, packType, index):

    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartPlusEvolveLV % (packType, index))





## 设置公共部位强化进化等级

def SetEquipPartPlusEvolveLV(curPlayer, packType, index, setEvolveLV):

    befEvolveLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartPlusEvolveLV % (packType, index))

    if befEvolveLV == setEvolveLV:

        return

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_EquipPartPlusEvolveLV % (packType, index), setEvolveLV)

    
    # 同步更新进化总等级

    befTotalPlusEvolveLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TotalPlusEvolveLV)

    updTotalPlusEvolveLV = max(0, befTotalPlusEvolveLV + setEvolveLV - befEvolveLV)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TotalPlusEvolveLV, updTotalPlusEvolveLV)

    GameWorld.DebugLog("设置进化等级: index=%s,befEvolveLV=%s,setEvolveLV=%s,befTotalPlusEvolveLV=%s,updTotalPlusEvolveLV=%s" 
                       % (index, befEvolveLV, setEvolveLV, befTotalPlusEvolveLV, updTotalPlusEvolveLV))

    return



## 通知公共部位强化等级

def NotifyEquipPartPlusLV(curPlayer, packType=IPY_GameWorld.rptEquip, index=None):

    ePartStarLVPack = ChPyNetSendPack.tagMCEquipPartPlusInfo()

    ePartStarLVPack.Clear()

    ePartStarLVPack.InfoList = []

    
    syncIndexList = []

    if index == None:

        equipMaxClasslv = IpyGameDataPY.GetFuncCfg('EquipMaxClasslv')

        for equipPlace in ChConfig.Pack_EquipPart_CanPlusStar.get(packType, []):

            for classlv in xrange(1, equipMaxClasslv+1):

                ipyData = IpyGameDataPY.GetIpyGameData('EquipPlaceIndexMap', classlv, equipPlace)

                if not ipyData:

                    continue 
                syncIndexList.append(ipyData.GetGridIndex())

    else:

        syncIndexList = [index]

        
    for i in syncIndexList:

        ePartStarLV = ChPyNetSendPack.tagMCEquipPartPlusLV()

        ePartStarLV.Clear()

        ePartStarLV.PackType = packType

        ePartStarLV.EquipIndex = i

        ePartStarLV.EquipPartStarLV = GetEquipPartPlusLV(curPlayer, packType, i)

        ePartStarLV.Proficiency = GetEquipPartProficiency(curPlayer, packType, i)

        ePartStarLV.EvolveLV = GetEquipPartPlusEvolveLV(curPlayer, packType, i)

        ePartStarLVPack.InfoList.append(ePartStarLV)

            
    ePartStarLVPack.Count = len(ePartStarLVPack.InfoList)

    NetPackCommon.SendFakePack(curPlayer, ePartStarLVPack)

    return





## 全身强化等级

def GetTotalPlusLV(curPlayer, isActive=True):

    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TotalPlusLV)



## 全身进化等级

def GetTotalPlusEvolveLV(curPlayer):

    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TotalPlusEvolveLV)



## 全身橙装及以上装备数

def GetEquipOrangeCount(curPlayer):

    return curPlayer.NomalDictGetProperty(ChConfig.Def_PlayerKey_EquipOrangeCount)





# 获取装备的强化类型

def GetEquipPlusType(curEquip):

    equipPlace = curEquip.GetEquipPlace()

    plusTypeDict = IpyGameDataPY.GetFuncEvalCfg("StrengthenLevelLimit", 1)

    if not plusTypeDict:

        GameWorld.ErrLog("没有强化类型映射表")

        return

    
    return plusTypeDict.get(equipPlace)





#  获取满套装化的最低阶数，如5件套，4件5级，1件3级，则返回3

def GetEquipSuitsLVByType(curPlayer, suitType, groupType):

    return 0

#    suiteLV = 999

#    equipSuitTypeDict = IpyGameDataPY.GetFuncEvalCfg('EquipSuitType')

#    if groupType not in equipSuitTypeDict:

#        return 0

#    maxCnt = len(equipSuitTypeDict[groupType])

#    cnt = 0

#    for equipPlace in equipSuitTypeDict[groupType]:

#        curSuiteLV = GetEquipPartSuiteLV(curPlayer, equipPlace, suitType)

#        if curSuiteLV > 0:

#            cnt += 1

#        suiteLV = min(curSuiteLV, suiteLV)

#        
#    if cnt != maxCnt:

#        return 0

#    return 0 if suiteLV == 999 else suiteLV







def SetEquipPartStar(curPlayer, index, setStarLV):

    #设置公共部位星数

    
    befStarLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartStar % index)

    if befStarLV == setStarLV:

        return    
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_EquipPartStar % index, setStarLV)

    
    # 同步更新星级总等级

    befTotalStarLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TotalEquipStar)

    updTotalStarLV = max(0, befTotalStarLV + setStarLV - befStarLV)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TotalEquipStar, updTotalStarLV)

    # 开服活动数据

    OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_StarLV, updTotalStarLV)

    GameWorld.DebugLog("设置部位星级: index=%s,befStarLV=%s,setStarLV=%s,befTotalStarLV=%s,updTotalStarLV=%s" 
                       % (index, befStarLV, setStarLV, befTotalStarLV, updTotalStarLV))

    return





def GetEquipPartStar(curPlayer, equipPackindex):

    #获取公共部位星数

    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartStar % equipPackindex)





## 获取公共部位生效的星数, 因装备的最高可到星数影响，用于算当前装备属性使用， 不影响全身星级

def GetEquipPartStarByRank(curPlayer, equipPackindex, curEquip):

    maxStarLV = ItemCommon.GetItemMaxStar(curEquip)

    return min(GetEquipPartStar(curPlayer, equipPackindex), maxStarLV)



def GetTotalEquipStars(curPlayer):

    ##获取部位总星数

    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TotalEquipStar)



## 通知公共部位星数

def NotifyEquipPartStar(curPlayer, index=None):

    ePartStarLVPack = ChPyNetSendPack.tagMCEquipPartStarInfo()

    ePartStarLVPack.Clear()

    ePartStarLVPack.InfoList = []

    syncIndexList = []

    if index == None:

        equipMaxClasslv = IpyGameDataPY.GetFuncCfg('EquipMaxClasslv')

        for equipPlace in ChConfig.Pack_EquipPart_CanPlusStar.get(IPY_GameWorld.rptEquip, []):

            for classlv in xrange(1, equipMaxClasslv+1):

                ipyData = IpyGameDataPY.GetIpyGameData('EquipPlaceIndexMap', classlv, equipPlace)

                if not ipyData:

                    continue 
                syncIndexList.append(ipyData.GetGridIndex())

    else:

        syncIndexList = [index]

    
    for index in syncIndexList:

        ePartStarLV = ChPyNetSendPack.tagMCEquipPartStar()

        ePartStarLV.Clear()

        ePartStarLV.EquipPackIndex = index

        ePartStarLV.Star = GetEquipPartStar(curPlayer, index)

        ePartStarLVPack.InfoList.append(ePartStarLV)

            
    ePartStarLVPack.Count = len(ePartStarLVPack.InfoList)

    NetPackCommon.SendFakePack(curPlayer, ePartStarLVPack)

    return