#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
#-------------------------------------------------------------------------------
##@package ChEquip
# ×°±¸Âß¼­´¦Àí
#
# @author alee
# @date 2017-07-29 00:30
# @version 1.0
#
# ÐÞ¸Äʱ¼ä ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
#------------------------------------------------------------------------------ 
#"""Version = 2017-07-29 00:30"""
#------------------------------------------------------------------------------ 
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 ShareDefine
import ChPyNetSendPack
import NetPackCommon
import EventShell
import IpyGameDataPY
import PlayerWing
import Operate_EquipStone
import OpenServerCampaign
import PassiveBuffEffMng
import time
import json
import FormulaControl
import PyGameData
#---------------------------------------------------------------------


##¼ì²éÍæ¼ÒÊÇ·ñ¿ÉÒÔ»»×°
# @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 not endureReduceType:
        EventShell.EventRespons_EquipByPlace(curPlayer, itemClassLV, equipPlace)
    #¼Ç¼³È×°¡¢ºì×°
    #===========================================================================
    # if itemQuality in [ChConfig.Def_Quality_Orange, ChConfig.Def_Quality_Red]:
    #    classLV = ItemCommon.GetItemClassLV(curItem)
    #    EventReport.WriteEvent_orange_equip(curPlayer, changeItemEquipPlace, classLV, itemQuality)
    #===========================================================================
        
    #ÌØÊâ×°±¸, ²»ÐèҪˢÊôÐÔ
    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)
    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)
    #֪ͨÌ××°ÐÅÏ¢
    #ChEquip.SyncAllEquipAttrActiveInfo(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)
        
    # ¸üÐÂͳ¼Æ»ã×ÜÖµ
    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)
    return

## Ë¢ÐÂËùÓÐ×°±¸¶ÔÈËÎïÊôÐԵĸıä
#  @param self ÀàʵÀý
#  @return ·µ»ØÖµÎÞÒâÒå
#  @remarks Ë¢ÐÂ×°±¸¶ÔÈËÎïÊôÐԵĸıä
#===============================================================================
# def __RefreshPlayerAllEquipBuff(curPlayer):
#    #³õʼ»¯ÈËÎï×°±¸buff
#    curPlayer.GetEquipBuff().Clear()
# 
#    packType = IPY_GameWorld.rptEquip
#        
#    equipPackList = [IPY_GameWorld.rptEquip, IPY_GameWorld.rptHorseEquip]
#    
#    #stoneLVCntList = []
#    #===========================================================================
#    orangeQualityCnt = 0 #³Èɫװ±¸ÊýÁ¿(°üº¬³ÈÉ«Æ·ÖÊÒÔÉϵÄ×°±¸ÊýÁ¿)
#    for packIndex in equipPackList:
#        equipPack = curPlayer.GetItemManager().GetPack(packIndex)
#    
#        for equipIndex in range(0, equipPack.GetCount()):
#            
#            #±¸ÓÃ×°±¸À¸²»´¦Àí
#            if packIndex == IPY_GameWorld.rptEquip and equipIndex not in ShareDefine.RoleEquipType:
#                continue
#            
#            curEquip = equipPack.GetAt(equipIndex)
#            
#            if curEquip.IsEmpty():
#                continue
# 
#            if not ItemCommon.CheckItemCanUseByExpireTime(curEquip):
#                # ¹ýÆÚ
#                continue
#            
#            #×°±¸´¥·¢µÄ¼¼ÄÜ £¨È«Éí£©
#            CalcCurEquip_SkillBuff(curPlayer, curEquip)
#            
#            
#            
#            # ºóÃæµÄΪ½Çɫװ±¸×¨Óô¦Àí
#            #===================================================================
#            # if packIndex != IPY_GameWorld.rptEquip:
#            #    continue
#            # 
#            # if isSuite or curEquip.GetItemTypeID() in ReadChConfig.GetEvalChConfig("AddSuiteNumEquitList"):
#            #    suiteEquipCnt += 1
#            #===================================================================
#            
#    #Ì××°¼Óbuff ¸ù¾Ý×°±¸ÏÖÓеÄÌ××°µÄ¸öÊý×Öµä 
# #===============================================================================
# #    #È«Éí³Èɫװ±¸ÊýÁ¿´¥·¢Ïà¹Ø
# #    OnOrangeQualityCntChange(curPlayer, orangeQualityCnt)
# #    
# #    # ÖØÖü¤»îÌáʾÀàÐÍΪNone
# #    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrActivatyNotify, ChConfig.Def_AttrActivatyNotify_None)
# #===============================================================================
#    
#    # ×°±¸ÄÚ²ãbuff
#    allAttrListEquip = [{} for i in range(4)] # ²»°üº¬³á°ò¼°×°±¸ÉÏÏâǶµÄ±¦Ê¯
#    SkillShell.CalcCurBuffer_Effect(curPlayer.GetEquipBuff(), curPlayer, allAttrListEquip)
#    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_EquipBuff, allAttrListEquip)
#    
#    # ×°±¸Íâ²ãbuffÊôÐÔ£¬´ËbuffËãÕ½Á¦
#    allAttrListEquptBuffs = [{} for i in range(4)]
#    SkillShell.CalcCurBuffer_Effect(curPlayer.GetEquipBuff(), curPlayer, 
#                                    allAttrListEquptBuffs, [], ChConfig.CalcBuffLevel_1)
#    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_EquipBuff1, allAttrListEquptBuffs)
#    
#    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
#
#struct    tagCMLingQiEquipBreak
#{
#    tagHead        Head;
#    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

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)
                
        #ÁéÆ÷¸÷²¿Î»ÆäËûÊôÐÔ
        if equipPlace == ShareDefine.retWing:
            PlayerWing.CalcWingAttrEx(curPlayer, curEquip, allAttrList)
        
    lqFightPowerEx = eval(IpyGameDataPY.GetFuncCompileCfg("FightpowerFormula", 2))
    curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPEx % 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, ...}, ...}
    
    allAttrListEquip = [{} for _ in range(4)]  # ×°±¸ÊôÐÔ
    equip_addEquipBaseAttrPerList = [{}, {}, {}] # ×°±¸¹¦Äܵã¶Ô×°±¸»ù´¡µÄ¼Ó³ÉÐÅÏ¢ [ËùÓв¿Î», »ù´¡²¿Î», Ö¸¶¨²¿Î»]
    allAttrListStar = [{} for _ in range(4)]  # ÉýÐÇÊôÐÔ
    star_addEquipBaseAttrPerList = [{}, {}, {}] # ÉýÐǹ¦Äܵã¶Ô×°±¸»ù´¡µÄ¼Ó³ÉÐÅÏ¢ [ËùÓв¿Î», »ù´¡²¿Î», Ö¸¶¨²¿Î»]
    allAttrListPlus = [{} for _ in range(4)]  # Ç¿»¯ÊôÐÔ
    plus_addEquipBaseAttrPerList = [{}, {}, {}] # Ç¿»¯¹¦Äܵã¶Ô×°±¸»ù´¡µÄ¼Ó³ÉÐÅÏ¢ [ËùÓв¿Î», »ù´¡²¿Î», Ö¸¶¨²¿Î»]
    allAttrListStone = [{} for _ in range(4)]  # ±¦Ê¯ÊôÐÔ
    #stone_addEquipBaseAttrPerList = [{}, {}, {}] # ±¦Ê¯¹¦Äܵã¶Ô×°±¸»ù´¡µÄ¼Ó³ÉÐÅÏ¢ [ËùÓв¿Î», »ù´¡²¿Î», Ö¸¶¨²¿Î»]
    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  #Ϊ½â¾ö×°±¸ÆÀ·Ö¡¢Õ½Á¦²»Ò»ÖµÄÇé¿ö£¬×°±¸Õ½Á¦¸ÄΪÓÉÆÀ·Ö×÷Ϊ²ÎÊý¼ÆËãÕ½Á¦
    
    # 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)
        
        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:
            #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
                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)
        
        #ÎïÆ·Ç¿»¯ÊôÐÔ
        __CalcAttr_ItemPlus(curPlayer, curEquip, packType, equipIndex, allAttrListPlus, plus_addEquipBaseAttrPerList)
        
        #¼ÆËã×°±¸±¦Ê¯¼Ó³É
        CalcEquipStone_Effect(curPlayer, equipIndex, allAttrListStone)
        
        #Ï´Á·ÊôÐÔ
        Operate_EquipWash.CalcAttr_EquipWash(curPlayer, equipIndex, equipPlace, allAttrListWash)
    
#    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)
    
#    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, allAttrListStar, insideAttrDictStar,
                                  allAttrListPlus, insideAttrDictPlus, allAttrListStone, insideAttrDictStone, allAttrListWash, insideAttrDictWash]
    
#    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 = [{} for _ in range(4)], {}
    allClassAttrListStar, allClassInsideAttrDictStar = [{} for _ in range(4)], {}
    allClassAttrListPlus, allClassInsideAttrDictPlus = [{} for _ in range(4)], {}
    allClassAttrListStone, allClassInsideAttrDictStone = [{} for _ in range(4)], {}
    allClassAttrListWash, allClassInsideAttrDictWash = [{} for _ in range(4)], {}
    for classLV, attrList in equipPartAttrDict.items():
        equipFightPowerEx, allAttrListEquip, insideAttrDictEquip, allAttrListStar, insideAttrDictStar, \
            allAttrListPlus, insideAttrDictPlus, allAttrListStone, insideAttrDictStone, allAttrListWash, insideAttrDictWash = 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)
        
#    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))
    curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPEx % ShareDefine.Def_MFPType_Equip, allClassEquipFightPowerEx)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Equip, allClassAttrListEquip, allClassInsideAttrDictEquip)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Star, allClassAttrListStar, allClassInsideAttrDictStar)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Plus, allClassAttrListPlus, allClassInsideAttrDictPlus)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Stone, allClassAttrListStone, allClassInsideAttrDictStone)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Wash, allClassAttrListWash, allClassInsideAttrDictWash)
    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 and equipPlace in ChConfig.EquipPlace_Base:
        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, allAttrList, plus_addEquipBaseAttrPerList):
    ## ¼ÆËã×°±¸Ç¿»¯ºóµÄÊôÐÔ
    equipPartPlusLV = GetEquipPartPlusLVByRank(curPlayer, packType, equipIndex, curEquip)
    equipPartPlusEvolveLV = GetEquipPartPlusEvolveLVByEquip(curPlayer, packType, equipIndex, curEquip)
    
    if not equipPartPlusLV:
        return
    plusType = GetEquipPlusType(curEquip)
    if plusType is None:
        return
    
    #GameWorld.DebugLog("    Ç¿»¯ÊôÐÔ: plusType=%s,equipPartPlusLV=%s,equipPartPlusEvolveLV=%s" % (plusType, equipPartPlusLV, equipPartPlusEvolveLV))
    ipyData = IpyGameDataPY.GetIpyGameData("ItemPlus", plusType, equipPartPlusLV)
    if not ipyData:
        return
    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)
    
    if not equipPartPlusEvolveLV:
        return
    #½ø»¯ÊôÐÔ
    equipPlace = curEquip.GetEquipPlace()
    ipyData = IpyGameDataPY.GetIpyGameData('EquipPlusEvolve', equipPlace, equipPartPlusEvolveLV)
    if not ipyData:
        return
    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

## ×°±¸Ì××°ÊôÐÔ¼ÆËã
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @return None
def CalcEquipSuiteAttr(curPlayer, suitCntDict, allAttrListSuit):
    if not suitCntDict:
        return
    #GameWorld.DebugLog('    suitCntDict=%s'%suitCntDict)
    learnSkillList = []
    delSkillID = []
    skillManager = curPlayer.GetSkillManager()
    playerName = curPlayer.GetName()
    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)
            #GameWorld.DebugLog("suiteID=%s,suiteCnt=%s,needStar=%s,isActivate=%s" % (suiteID, suiteCnt, needStar, isActivate))
            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 skillID and not skillManager.FindSkillBySkillTypeID(skillID):
                    learnSkillList.append(skillID)
#                #¹ã²¥£¬¸ÄΪ¼¤»îʱ¹ã²¥¼´¿É
#                notifyMark = ipyData.GetIsNotify()
#                if notifyMark and not GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_EquipPartSuiteNotify, notifyMark):
#                    PlayerControl.WorldNotify(0, 'AllStarLevelUp' if needStar else 'AllStarLevelUp2', [playerName, suiteID, suiteCnt, needStar])
#                    GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_EquipPartSuiteNotify, notifyMark, 1)

            else:
                if skillID and skillManager.FindSkillBySkillTypeID(skillID):
                    delSkillID.append(skillID)
                    skillManager.DeleteSkillBySkillTypeID(skillID)
                            
            
    for skillID in learnSkillList:
        GameWorld.DebugLog('    ¼¤»îÌ××°¼¼ÄÜ skillResID=%s' % (skillID))
        skillData = GameWorld.GetGameData().FindSkillByType(skillID, 1)
        if not skillData:
            continue
        skillManager.LVUpSkillBySkillTypeID(skillID)   
        PlayerControl.PlayerControl(curPlayer).RefreshSkillFightPowerEx(skillID, 0)
    if learnSkillList or delSkillID:
        # ÖØË¢±»¶¯¼¼ÄÜ
        PassiveBuffEffMng.GetPassiveEffManager().RegistPassiveEff(curPlayer)    
    return

#// A5 C6 ×°±¸²¿Î»ÐǼ¶Ì××°¼¤»î #tagCMEquipPartSuiteActivate
#
#struct    tagCMEquipPartSuiteActivate
#{
#    tagHead        Head;
#    BYTE    ClassLV;    // ËùÊô×°±¸½×
#    WORD    SuiteID;    // Ì××°ID
#    BYTE    SuiteCount;    // ¼þÊý
#    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
    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

##È«Éí³Èɫװ±¸ÊýÁ¿´¥·¢Ïà¹Ø(°üº¬³ÈÉ«Æ·ÖÊÒÔÉϵÄ×°±¸ÊýÁ¿)
def OnOrangeQualityCntChange(curPlayer, orangeQualityCnt):
    notifyType = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrActivatyNotify)
    if notifyType == ChConfig.Def_AttrActivatyNotify_Equip:
        EventShell.EventRespons_OrangeQualityCnt(curPlayer, orangeQualityCnt)
    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, 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)
        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):

    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)
    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 ChangeEquipfacadeByHorsePetSkin(curPlayer, skinType, skinIndex):
    ##Æï³è¾õÐÑÍâ¹Û±ä¸ü  Áé³èÍâ¹ÛË÷Òý*10000000+×øÆïÍâ¹ÛË÷Òý*1000000+Áé¸ùÌØЧ±íkey * 1000+µÚ¼¸Ì×*10+ÊÇ·ñÓÐÌ××°
    oldEquipShowSwitch = curPlayer.GetEquipShowSwitch()
    if skinType == 1:
        updEquipShowSwitch = GameWorld.ChangeDataByDigitPlace(oldEquipShowSwitch, 7, skinIndex)
    else:
        updEquipShowSwitch = GameWorld.ChangeDataByDigitPlace(oldEquipShowSwitch, 8, skinIndex)
        
    if oldEquipShowSwitch == updEquipShowSwitch:
        return
    curPlayer.SetEquipShowSwitch(updEquipShowSwitch)
    return

#»ñÈ¡µ±Ç°Êǵڼ¸Ì××°±¸Íâ¹Û
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)


## »ñÈ¡¹«¹²²¿Î»Ç¿»¯ÐǼ¶, Òò×°±¸µÄ×î¸ß¿ÉÇ¿»¯ÐǼ¶Ó°Ï죬ÓÃÓÚË㵱ǰװ±¸ÊôÐÔʹÓ㬠²»Ó°ÏìÈ«ÉíÐǼ¶
def GetEquipPartPlusLVByRank(curPlayer, packType, index, curEquip):
    maxStarLV = ItemCommon.GetItemMaxPlusLV(curPlayer, index, curEquip)
    return min(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartPlusLV % (packType, index)), maxStarLV)


## »ñÈ¡¹«¹²²¿Î»Ç¿»¯µÈ¼¶
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 GetEquipPartPlusEvolveLVByEquip(curPlayer, packType, index, curEquip):
    maxEvolveLV = ItemCommon.GetItemMaxPlusEvolveLV(curPlayer, index, curEquip)
    return min(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartPlusEvolveLV % (packType, index)), maxEvolveLV)


## »ñÈ¡¹«¹²²¿Î»Ç¿»¯½ø»¯µÈ¼¶
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


#// A5 03 È«ÉíÊôÐÔ¼¤»î #tagCMActiveAllEquipAttr
#
#struct    tagCMActiveAllEquipAttr
#
#{
#    tagHead        Head;
#    BYTE        Type;        //0Ç¿»¯ 1ÐÇÊý
#    DWORD        Cnt;        //¼¤»îÊýÁ¿
#};
def OnActiveAllEquipAttr(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    activeType = clientData.Type
    activeCnt = clientData.Cnt
    if activeType == 0:
        key = ChConfig.Def_PDict_EquipActiveStarLV
#    elif activeType == 1:
#        key = ChConfig.Def_PDict_EquipActiveStars
    else:
        return
    curCnt = curPlayer.NomalDictGetProperty(key)
    if activeCnt <= curCnt:
        GameWorld.Log('    È«ÉíÊôÐÔ¼¤»î ¸ÃÊýÁ¿ÒѼ¤»î¹ý£¡ activeType=%s,activeCnt=%s,curCnt=%s' % (activeType, activeCnt, curCnt))
        return
    
    PlayerControl.NomalDictSetProperty(curPlayer, key, activeCnt)
    
    SyncAllEquipAttrActiveInfo(curPlayer, activeType)
    
    #×¢Òâ: ÐèÒª´«×°±¸½×´¥·¢Ë¢ÊôÐÔ£¬ÔÝÆÁ±Î£¬¹¦ÄÜÐÞ¸ÄʱÔÙ´¦Àí
    #else:
    #    RefreshPlayerEquipAttribute(curPlayer)
    
    #Ë¢ÐÂËùÓÐÊôÐÔ
    playControl = PlayerControl.PlayerControl(curPlayer)
    playControl.RefreshPlayerAttrState()
    return


def SyncAllEquipAttrActiveInfo(curPlayer, activeType=-1):
    ## ֪ͨȫÉíÊôÐÔ¼¤»îÊýÁ¿
    packData = ChPyNetSendPack.tagMCAllEquipAttrActiveInfo()
    packData.ActiveInfo = []
    for aType in [0, 1]:
        if activeType != -1 and activeType != aType:
            continue
        if aType == 0:
            key = ChConfig.Def_PDict_EquipActiveStarLV
#        elif aType == 1:
#            key = ChConfig.Def_PDict_EquipActiveStars
        else:
            return
        curCnt = curPlayer.NomalDictGetProperty(key)
        activeInfo = ChPyNetSendPack.tagMCEquipActiveInfo()
        activeInfo.Type = aType
        activeInfo.Cnt = curCnt
        packData.ActiveInfo.append(activeInfo)
    
    packData.Count = len(packData.ActiveInfo)
    NetPackCommon.SendFakePack(curPlayer, packData)
    return