#!/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 ReadChConfig
import OperControlManager
import Operate_EquipWash
import ShareDefine
import PyMapTable
import ChPyNetSendPack
import NetPackCommon
import EventShell
import IpyGameDataPY
import PlayerWing
import Operate_EquipStone
import Operate_EquipSuitCompose
import PlayerMagicWeapon
import time
import json
#---------------------------------------------------------------------

##¼ì²éÍæ¼ÒÊÇ·ñ¿ÉÒÔ»»×°
# @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 packEquipIndex ×°±¸²¿Î»
#  @param tick µ±Ç°Ê±¼ä
#  @return ²¼¶ûÖµ
#  @remarks Ö´ÐÐÍæ¼Ò»»×°Âß¼­
def DoPlayerEquipItem(curPlayer, curItem, packEquipIndex, tick): 
    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 changeItemEquipPlace in ChConfig.Type_Equip_CanTake:
    #    equipPartStar = GetEquipPartStarLV(curPlayer, IPY_GameWorld.rptEquip, changeItemEquipPlace)
    #    if equipPartStar != curItem.GetItemStarLV():
    #        curItem.SetItemStarLV(equipPartStar)
    #===========================================================================
            #GameWorld.DebugLog("´©ÉϵÄ×°±¸ÉèÖÃÐǼ¶: index=%s,star=%s" % (changeItemEquipPlace, equipPartStar))
    
    #---¿ªÊ¼»»×°Âß¼­---
    
    #¼Ç¼»»×°ÎïÆ·ÐÅÏ¢
    changeItemID = curItem.GetItemTypeID()
    changeItemStarLV = 0#curItem.GetItemStarLV()
    changeItemStoneCnt = 0#curItem.GetUseStoneCount()
    changeItemHoleCnt = 0#curItem.GetCanPlaceStoneCount()
    changeItemUseData = curItem.GetUserData()
    itemQuality = curItem.GetItemQuality()
    endureReduceType = curItem.GetEndureReduceType()
    #changeItemIsHorse = (curItem.GetType() == ChConfig.Def_Item_Type_Horse)
    
    #Ö´Ðл»×°¶¯×÷
    equipPlace = playerItemControl.EquipItem(curItem, packEquipIndex)
    
    if equipPlace == -1:
        return False
    
    equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
    curEquip = equipPack.GetAt(equipPlace)
    SetEquipItemSuiteLVInfo(curPlayer, packEquipIndex, curEquip)
    if curEquip.GetUserAttr(ShareDefine.Def_IudetCreateTime) == 0:
        curEquip.SetUserAttr(ShareDefine.Def_IudetCreateTime, int(time.time()))
    #---»»×°³É¹¦---
    if equipPlace in ChConfig.Def_SyncEquipStateByIndex:
        #֪ͨ¿Í»§¶Ë½»»»ÎïÆ·
        curPlayer.ChangeEquip(changeItemID, equipPlace, changeItemStarLV, changeItemHoleCnt, changeItemStoneCnt, changeItemUseData)
        
    if not endureReduceType:
        EventShell.EventRespons_EquipByPlace(curPlayer, 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 == ShareDefine.retWing:
        PlayerWing.CalcWingAttr(curPlayer)
    else:
        RefreshPlayerEquipAttribute(curPlayer)
    
    #Ë¢ÐÂËùÓÐÊôÐÔ
    playControl = PlayerControl.PlayerControl(curPlayer)
    playControl.RefreshPlayerAttrState()
    return True

def SetEquipItemSuiteLVInfo(curPlayer, equipIndex, curItem):
    # ÉèÖò¿Î»Ì××°ÐÅÏ¢
    if not curItem or curItem.IsEmpty():
        return
    
    isSuitePart = False
    equipSuitTypeDict = IpyGameDataPY.GetFuncEvalCfg('EquipSuitType')
    for equipIndexList in equipSuitTypeDict.values():
        if equipIndex in equipIndexList:
            isSuitePart = True
            break
        
    if not isSuitePart:
        return
          
    suiteLVList = GetEquipPartSuiteLVList(curPlayer, equipIndex, curItem)
    attrCount = curItem.GetUserAttrCount(ShareDefine.Def_IudetPartSuiteLV)
    
    if suiteLVList and len(suiteLVList) == attrCount:
        for i, suiteLV in enumerate(suiteLVList):
            if curItem.GetUserAttrByIndex(ShareDefine.Def_IudetPartSuiteLV, i) != suiteLV:
                curItem.UpdataUserAttrByIndex(ShareDefine.Def_IudetPartSuiteLV, i, suiteLV)
    else:
        if attrCount:
            curItem.ClearUserAttr(ShareDefine.Def_IudetPartSuiteLV)
        for suiteLV in suiteLVList:
            curItem.AddUserAttr(ShareDefine.Def_IudetPartSuiteLV, suiteLV)
    return
    
## Ë¢ÐÂ×°±¸¶ÔÈËÎïÊôÐԵĸıä
#  @param self ÀàʵÀý
#  @return ·µ»ØÖµÎÞÒâÒå
#  @remarks Ë¢ÐÂ×°±¸¶ÔÈËÎïÊôÐԵĸıä
def RefreshPlayerEquipAttribute(curPlayer, isRefreshEquipBuff=True):
    GameWorld.DebugLog("Start RefreshPlayerEquipAttribute!!!")

    __CalcEquips_Effect(curPlayer)
    
    #CalcAllEquipAllPlusLVAttr(curPlayer)
    
    CalcAllEquipStarsAttr(curPlayer)
    
    #if isRefreshEquipBuff:
    #    __RefreshPlayerAllEquipBuff(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 ChConfig.Type_Equip_CanTake :
#                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()
    #½Çɫװ±¸²¿Î»
    packEquipIndex = 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, packEquipIndex, 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
    
    equipIndex = 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(equipIndex, sendPack.GetPackIndex())
    
    if not result:
        #жÏÂ×°±¸Ê§°Ü
        return
    
    equipID = result[0]
    equipPlace = result[1]
    
    ##ÌØÊâ×°±¸ , ²»ÐèÒª³åË¢ÊôÐÔ
    if equipPlace in ChConfig.EquipItemNoRefreshState:
        curPlayer.Sync_UnEquipItem(equipID, equipPlace)
        return
    
    #ÏÈË¢×°±¸BUFF ÔÙ¼ÆËãÊôÐÔ
    if equipIndex == ShareDefine.retWing:
        PlayerWing.CalcWingAttr(curPlayer)
    else:
        RefreshPlayerEquipAttribute(curPlayer)
    
    #Ë¢ÐÂËùÓÐÊôÐÔ
    playControl = PlayerControl.PlayerControl(curPlayer)
    playControl.RefreshPlayerAttrState()
    
    if equipPlace in ChConfig.Def_SyncEquipStateByIndex:
        curPlayer.Sync_UnEquipItem(equipID, equipPlace)
    return


#---------------------------------------------------------------------
## Íæ¼ÒʹÓÃ×°±¸(ÔÚ×°±¸À¸ÉϵÄÌØÊâÎïÆ·:Èçµ°°×)(·â°ü²ÎÊý)
#  @param index Íæ¼ÒË÷Òý
#  @param tick µ±Ç°Ê±¼ä
#  @return None
#  @remarks º¯ÊýÏêϸ˵Ã÷.
def __Func_PlayerUseEquipSelf(index, tick):
    sendPack = IPY_GameWorld.IPY_CUseEquip()
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    
    #ʹÓÃÎïÆ·ÐÐΪ״̬, ÅжϿͻ§¶ËÏÞÖÆ
    if not OperControlManager.IsObjCanDoAction(
                                        curPlayer,
                                        ChConfig.Def_Obj_ActState_ClientAct,
                                        IPY_GameWorld.oalUseItem
                                        ):
        return
    
    
    #¼ì²éʹÓÃÎïÆ·µÄÍæ¼ÒÊôÐÔ
    if not ChItem.CheckUseItemSelf_Player(curPlayer):
        return
    
    roleEquipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
    #»ñµÃËùҪʹÓõÄ×°±¸
    equipIndex = sendPack.GetEquipIndex()
    curEquip = roleEquipPack.GetAt(equipIndex)
    
    if not ItemCommon.CheckItemCanUse(curEquip):
        return
    
    #FB½ûֹʹÓÃÎïÆ·
    if FBLogic.DoFBForbidUseItem(curPlayer, curEquip):
        return
    
    if ItemControler.IsEventItem(curEquip):
        PlayerControl.NotifyCode(curPlayer, "TaskRes")
        return
    
    else:
        PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_774045")
        return
    
    return


## ¼ÆËã×°±¸¶Ô»ù±¾ÊôÐԵĸıä 
#  @return None
def __CalcEquips_Effect(curPlayer):
    baseEquipAttrDict = {}
    baseEquipAttr_Weapon = [{} for _ in range(4)] # ÎäÆ÷»ù´¡, ÎïÆ·±í×°±¸»ù´¡Ð§¹ûÊôÐÔ
    baseEquipAttr_Armor = [{} for _ in range(4)] # ·À¾ß»ù´¡, ÎïÆ·±í×°±¸»ù´¡Ð§¹ûÊôÐÔ
    baseEquipAttr_Relics = [{} for _ in range(4)] # Ê¥Æ÷»ù´¡, ÎïÆ·±í×°±¸»ù´¡Ð§¹ûÊôÐÔ
    
    allAttrListEquip = [{} for _ in range(4)] # ×°±¸ÆäËû
    allAttrListPlusBase = [{} for _ in range(4)] # »ù´¡Ç¿»¯ÊôÐÔ
    allAttrListStone = [{} for _ in range(4)] # ±¦Ê¯ÊôÐÔ
    allAttrListSuit = [{} for _ in range(4)] # Ì××°ÊôÐÔ
    allAttrListWash = [{} for _ in range(4)] # Ï´Á·ÊôÐÔ
    allAttrListOutOfPrintEquip = [{} for _ in range(4)] # ¾ø°æ×°±¸ÊôÐÔ ÐèÔڵȼ¶±ä»¯¶ÀÁ¢¼ÆËã
    
    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 #Ϊ½â¾ö×°±¸ÆÀ·Ö¡¢Õ½Á¦²»Ò»ÖµÄÇé¿ö£¬×°±¸Õ½Á¦¸ÄΪÓÉÆÀ·Ö×÷Ϊ²ÎÊý¼ÆËãÕ½Á¦
    
    #Íæ¼Òµ±Ç°¿É×°±¸µÄ×°±¸ÀàÐÍ
    for equipIndex in xrange(playerEquip.GetCount()):
        if equipIndex not in ShareDefine.RoleEquipType :
            continue
        
        # ³á°òÊôÐÔÔÚ³á°ò¹¦Äܵ¥¶ÀË¢ÐÂ
        if equipIndex == ShareDefine.retWing:
            continue
        
        curEquip = playerEquip.GetAt(equipIndex)
        if curEquip.IsEmpty():
            continue
            
        if not ItemCommon.CheckItemCanUseByExpireTime(curEquip):
            # ¹ýÆÚ
            continue
        
        equipPlaceList.append(equipIndex)
        equipScoreTotal += ItemCommon.GetEquipGearScore(curEquip)
        
        #»ù´¡ÊôÐÔЧ¹û
        for i in range(0, 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
            
            #Ìí¼ÓÎïƷЧ¹ûµÄÊôÐÔÖµ
#            if equipIndex == ShareDefine.retWing:
#                PlayerControl.CalcAttrDict_Type(effectID, effectValue, allAttrListWing)
            if equipIndex in ChConfig.BaseEquipPlace_Weapon:
                PlayerControl.CalcAttrDict_Type(effectID, effectValue, baseEquipAttr_Weapon)
            elif equipIndex in ChConfig.BaseEquipPlace_Armor:
                PlayerControl.CalcAttrDict_Type(effectID, effectValue, baseEquipAttr_Armor)
            elif equipIndex in ChConfig.BaseEquipPlace_Relics:
                PlayerControl.CalcAttrDict_Type(effectID, effectValue, baseEquipAttr_Relics)
            #ÆäËû·Ç»ù´¡²¿Î»µÄ
            else:
                PlayerControl.CalcAttrDict_Type(effectID, effectValue, allAttrListEquip)
            baseEquipAttrDict[effectID] = baseEquipAttrDict.get(effectID, 0) + effectValue
            
        groupType = GetEquipPartSuiteGroupType(curPlayer, equipIndex)
        for suiteType in range(1, maxSuiteType+1):
            suitelv = GetEquipPartSuiteLV(curPlayer, equipIndex, suiteType)
            if suitelv:
                maxSuiteLV = Operate_EquipSuitCompose.GetEquipCanDoMaxSuiteLV(curPlayer, curEquip, suiteType, groupType)
                suiteLV = min(suitelv, maxSuiteLV)
                if suiteLV:
                    suiteKey = '%s_%s_%s'%(groupType,suiteType,suitelv)
                    suitCntDict[suiteKey] = suitCntDict.get(suiteKey, 0) + 1
        
        #¼ÆËã×°±¸±¦Ê¯¼Ó³É
        CalcEquipStone_Effect(curPlayer, equipIndex, allAttrListStone)
        
        #ÎïÆ·Ç¿»¯ÊôÐÔ£¬ÅåÊÎÇ¿»¯²»Í¬ÒªÇø·Ö
        if equipIndex in equipPartStarIndexList:
            equipPartStarLV = GetEquipPartStarLVByRank(curPlayer, packType, equipIndex, curEquip)
            CalcAttr_ItemPlus(curPlayer, curEquip, allAttrListPlusBase, equipPartStarLV)
        
        #´«ÆæÊôÐÔ
        CalcAttr_LegendAttr(curPlayer, curEquip, allAttrListEquip, legendAttrDict)            
        #¾øÊÀÊôÐÔ
        CalcAttr_OutOfPrintAttr(curPlayer, curEquip, allAttrListOutOfPrintEquip)
        #Ï´Á·ÊôÐÔ
        Operate_EquipWash.CalcAttr_EquipWash(curPlayer, equipIndex, allAttrListWash)
    
    #Ï´Á·Ì××°ÊôÐÔ
    Operate_EquipWash.CalcAttr_EquipWashSpec(curPlayer, equipPlaceList, allAttrListWash)
    #Ì××°ÊôÐÔ
    CalcEquipSuiteAttr(curPlayer, suitCntDict, allAttrListSuit)
    #GameWorld.DebugLog("ËùÓд«ÆæÊôÐÔ: %s" % legendAttrDict)
    #±£´æ¼ÆËãÖµ
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_EquipBaseWeapon, baseEquipAttr_Weapon)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_EquipBaseArmor, baseEquipAttr_Armor)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_EquipBaseRelics, baseEquipAttr_Relics)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Equip, allAttrListEquip)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PlusBase, allAttrListPlusBase)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Stone, allAttrListStone)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Suit, allAttrListSuit)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Wash, allAttrListWash)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_EquipOutOfPrint, allAttrListOutOfPrintEquip)
    
    #¼ÆËã×°±¸»ù´¡ÊôÐÔ¸½¼ÓÕ½Á¦ (Ä¿Ç°×é³É: ÆÀ·ÖÕ½Á¦ + ...)
    equipFightPowerEx = eval(IpyGameDataPY.GetFuncCompileCfg("FightpowerFormula", 2))
    #GameWorld.DebugLog("×°±¸ÆÀ·ÖÕ½Á¦: equipScoreTotal=%s,equipFightPowerEx=%s" % (equipScoreTotal, equipFightPowerEx))
    curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPEx % ShareDefine.Def_MFPType_Equip, equipFightPowerEx)
    return


def CalcAttr_LegendAttr(curPlayer, curEquip, allAttrListEquip, legendAttrDict={}):
    ## ¼ÆËã´«ÆæÊôÐÔ
    
    # ´«ÆæÊôÐÔIDÁбí
    legendAttrIDList = [curEquip.GetUserAttrByIndex(ShareDefine.Def_IudetLegendAttrID, i) \
                        for i in range(curEquip.GetUserAttrCount(ShareDefine.Def_IudetLegendAttrID))]
    # ´«ÆæÊôÐÔÖµÁбí
    legendAttrValueList = [curEquip.GetUserAttrByIndex(ShareDefine.Def_IudetLegendAttrValue, i) \
                           for i in range(curEquip.GetUserAttrCount(ShareDefine.Def_IudetLegendAttrValue))]
    if not legendAttrIDList or len(legendAttrIDList) != len(legendAttrValueList):
        #GameWorld.DebugLog("ûÓд«ÆæÊôÐÔ£¡")
        return
    #GameWorld.DebugLog("´«ÆæÊôÐÔ: place=%s,IDList=%s, v=%s" % (curEquip.GetEquipPlace(), legendAttrIDList, legendAttrValueList))
    
    for i, attrID in enumerate(legendAttrIDList):
        value = legendAttrValueList[i]
        #GameWorld.DebugLog("¼Ó´«ÆæÊôÐÔ: %s +%s" % (attrID, value))
        PlayerControl.CalcAttrDict_Type(attrID, value, allAttrListEquip)
        #legendAttrDict[attrID] = legendAttrDict.get(attrID, 0) + value
        
    return

# ×°±¸¾ø°æÊôÐÔ£¬ËæµÈ¼¶±ä»¯ÐèÔÚÉý¼¶ÔÙ´¦Àí
def CalcAttr_OutOfPrintAttr(curPlayer, curEquip, allAttrListOutOfPrintEquip):
    ## ¼ÆËã¾ø°æÊôÐÔ
    
    # ¾ø°æÊôÐÔIDÁбí
    OutOfPrintAttrIDList = [curEquip.GetUserAttrByIndex(ShareDefine.Def_IudetOutOfPrintAttrID, i) \
                        for i in range(curEquip.GetUserAttrCount(ShareDefine.Def_IudetOutOfPrintAttrID))]
    # ¾ø°æÊôÐÔÖµÁбí
    OutOfPrintAttrValueList = [curEquip.GetUserAttrByIndex(ShareDefine.Def_IudetOutOfPrintAttrValue, i) \
                           for i in range(curEquip.GetUserAttrCount(ShareDefine.Def_IudetOutOfPrintAttrValue))]
    if not OutOfPrintAttrIDList or len(OutOfPrintAttrIDList) != len(OutOfPrintAttrValueList):
        return
    
    lv = curPlayer.GetLV()
    for i, attrID in enumerate(OutOfPrintAttrIDList):
        maxOOPValue = OutOfPrintAttrValueList[i]
        value = eval(IpyGameDataPY.GetFuncCompileCfg("OutOfPrintValue", 1))
        GameWorld.DebugLog("¼Ó¾ø°æÊôÐÔ: %s +%s" % (attrID, value))
        PlayerControl.CalcAttrDict_Type(attrID, value, allAttrListOutOfPrintEquip)
        
    return


## ¼ÆËã×°±¸¶Ô»ù±¾ÊôÐԵĸıä 
#  @return None
def CalcEquips_OutOfPrint(curPlayer):
    allAttrListOutOfPrintEquip = [{} for _ in range(4)] # ¾ø°æ×°±¸ÊôÐÔ ÐèÔڵȼ¶±ä»¯¶ÀÁ¢¼ÆËã
    
    packType = IPY_GameWorld.rptEquip
    playerEquip = curPlayer.GetItemManager().GetPack(packType)

    #Íæ¼Òµ±Ç°¿É×°±¸µÄ×°±¸ÀàÐÍ
    for equipIndex in xrange(playerEquip.GetCount()):
        if equipIndex not in ShareDefine.RoleEquipType :
            continue
        
        # ³á°òÊôÐÔÔÚ³á°ò¹¦Äܵ¥¶ÀË¢ÐÂ
        if equipIndex == ShareDefine.retWing:
            continue
        
        curEquip = playerEquip.GetAt(equipIndex)
        if curEquip.IsEmpty():
            continue
            
        if not ItemCommon.CheckItemCanUseByExpireTime(curEquip):
            # ¹ýÆÚ
            continue
          
        #¾øÊÀÊôÐÔ
        CalcAttr_OutOfPrintAttr(curPlayer, curEquip, allAttrListOutOfPrintEquip)


    #±£´æ¼ÆËãÖµ
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_EquipOutOfPrint, allAttrListOutOfPrintEquip)
    return

## ¼ÆËã×°±¸Ç¿»¯ºóµÄÊôÐÔ
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @param curPlayer allAttrList ÊôÐÔ»º´æ
#  @return None
def CalcAttr_ItemPlus(curPlayer, curEquip, allAttrList, equipPartStarLV=None):
    if not equipPartStarLV:
        return
    plusType = GetEquipPlusType(curEquip)
    if plusType is None:
        return
    
    ipyData = IpyGameDataPY.GetIpyGameData("ItemPlus", plusType, equipPartStarLV)
    if not ipyData:
        return
    attrTypeList, attrValueList =  ipyData.GetAttrType(), ipyData.GetAttrValue()
    for i, attrID in enumerate(attrTypeList):
        PlayerControl.CalcAttrDict_Type(attrID, attrValueList[i], allAttrList)
    return


## Ìí¼ÓÈ«Éí×°±¸Æ·ÖʶÔÓ¦BUFF
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @return None
def AddEquipsQualityBuff(curPlayer, qualityEquipCnt, suiteEquipCnt):
    suiteCntRecord = 0
    notifySuiteCnt = 0
    notifyType = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrActivatyNotify)
    isAll, addAttrList = ReadChConfig.GetEvalChConfig('EquipQualityAddAttr')
    for confInfo in addAttrList:
        confQuality = confInfo[1] # ÅäÖÃÆ·Öʱêʶ 1-׿Խ£¬2-Ì××°
        cnt = 0 
        if confQuality == 1:
            cnt = qualityEquipCnt
        elif confQuality == 2:
            cnt = suiteEquipCnt
        
        confCnt = confInfo[0]
        if cnt >= confCnt: # Èç¹û¼þÊýÂú×ã
            EquipAddBuff(curPlayer, confInfo[2])
            
            if confQuality == 2 and confCnt > notifySuiteCnt and notifyType == \
                                            ChConfig.Def_AttrActivatyNotify_Equip:
                notifySuiteCnt = confCnt
                
            if confQuality == 2 and confCnt > suiteCntRecord:
                suiteCntRecord = confCnt
                
            if not isAll:
                break
            
    lastSuiteCntRecord = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrActivatyRecordSuiteCnt) 
    if notifySuiteCnt > 0 and notifySuiteCnt > lastSuiteCntRecord:
        PlayerControl.NotifyCode(curPlayer, "GeRen_hgg_917284", [curPlayer.GetPlayerName(), 
                                                                 notifySuiteCnt])
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrActivatyRecordSuiteCnt, suiteCntRecord)
    #GameWorld.DebugLog("Ì××°¼þÊý  ÉϴμǼ=%s,¸üмǼ=%s" % (lastSuiteCntRecord, suiteCntRecord))
    return

## Ìí¼Ó×°±¸È«ÉíÇ¿»¯µÈ¼¶¶ÔÓ¦ÊôÐÔ
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @return None
def CalcAllEquipAllPlusLVAttr(curPlayer):
    totalLV = GetTotalPlusLV(curPlayer, False)
    activeLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipActiveStarLV)
    totalLV = min(totalLV, activeLV)
    ipyData = IpyGameDataPY.InterpolationSearch("ItemPlusSumAttr", "PlusCntNeed", totalLV)
    if not ipyData:
        return {}
    
    attrTypeList = ipyData.GetAttrType()
    attrValueList = ipyData.GetAttrValue()
    #allAttrList = [{} for i in range(4)]
    attrDict = {}
    for i, attrID in enumerate(attrTypeList):
        value = attrValueList[i]
        attrDict[attrID] = attrDict.get(attrID, 0) + value
        #PlayerControl.CalcAttrDict_Type(attrID, value, allAttrList)
        
    #PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PlusEx, allAttrList)
    
    return attrDict

## Ìí¼Ó×°±¸È«ÉíÐÇÊý¶ÔÓ¦ÊôÐÔ
def CalcAllEquipStarsAttr(curPlayer):
    allAttrList = [{} for i in range(4)]
    totalStars = GetTotalEquipStars(curPlayer)
    activeStars = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipActiveStars)
    totalStars = min(totalStars, activeStars)
    if totalStars:
        ipyData = IpyGameDataPY.InterpolationSearch("RoleEquipStars", "StarsNeed", totalStars)
        if ipyData:
            attrTypeList = ipyData.GetAttrType()
            attrValueList = ipyData.GetAttrValue()
            
            for i, attrID in enumerate(attrTypeList):
                PlayerControl.CalcAttrDict_Type(attrID, attrValueList[i], allAttrList)
    #GameWorld.DebugLog("×°±¸È«ÉíÐÇÊýÊôÐÔ: totalStars=%s,allAttrList=%s" % (totalStars, allAttrList), curPlayer.GetPlayerID())
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_EquipAllStars, allAttrList)
    return

## ×°±¸Ì××°ÊôÐÔ¼ÆËã
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @return None
def CalcEquipSuiteAttr(curPlayer, suitCntDict, allAttrListEquip):
    Def_EquipSuitMaxCount = 3 #Ì××°×î´ó½×¶Î
    myjob = curPlayer.GetJob()
    name = curPlayer.GetName()
    
    for suiteKey, cnt in suitCntDict.items():
        groupType,suiteType,suiteLV = suiteKey.split('_')
        suiteLV = int(suiteLV)
        job = 0 if groupType == ChConfig.EquipGroupType_Relics else myjob #ÏÉÆ÷×éºÏĬÈÏÖ°Òµ0
        ipyData = IpyGameDataPY.GetIpyGameData('EquipSuitAttr', int(groupType), int(suiteType), int(suiteLV), job)
        if not ipyData:
            continue
        
        for i in range(1, Def_EquipSuitMaxCount+1):
            countKeyName = 'GetCount%d'%i
            attrTypeKeyName = 'GetAttrType%d'%i
            attrValueKeyName = 'GetAttrValue%d'%i
            needCnt = getattr(ipyData, countKeyName)()
            if cnt >= needCnt:
                attrTypeList = getattr(ipyData, attrTypeKeyName)()
                attrValueList = getattr(ipyData, attrValueKeyName)()
                for j, attrID in enumerate(attrTypeList):
                    value = attrValueList[j]
                    PlayerControl.CalcAttrDict_Type(attrID, value, allAttrListEquip)
                    
        #Ì××°¼¤»îÌáʾ(Ö»Ìáʾ1´Î)
        paramList= [name, cnt, suiteLV, groupType, suiteType]
        notifyRecord = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartSuiteNotify % (groupType, suiteType, cnt))
        if not notifyRecord & pow(2, suiteLV):
            if groupType == ChConfig.EquipGroupType_Armor:
                if cnt >=5:
                    PlayerControl.WorldNotify(0, 'EquipSuit5', paramList)
                    notifyRecord |= pow(2, suiteLV)
            else:
                PlayerControl.WorldNotify(0, 'EquipSuit5', paramList)
                notifyRecord |= pow(2, suiteLV)
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_EquipPartSuiteNotify % (groupType, suiteType, cnt), notifyRecord)
    
    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] # µÚÒ»¸öЧ¹ûÖµÊÇÀàÐ͵ȼ¶Ð§¹ûÖµ£¬·ÇÊôÐÔЧ¹ûÖµ
  
    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)

    return

#---------------------------------------------------------------------
## ×°±¸Ìí¼Ó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();
#===============================================================================
##ÇëÇó×°±¸ÏÔÒþ.
# @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
    
    sendPack = IPY_GameWorld.IPY_CRequestEquipShowHide()
    #´Ë¹¦ÄÜÎÞÐèÑéÖ¤
    curPlayer.SetEquipShowSwitch(sendPack.GetEquipShowSwitch())
    curPlayer.SetTickByType(ChConfig.TYPE_Player_Tick_RequestEquipShowHide, tick)
    return

## »ñÈ¡¹«¹²²¿Î»Ç¿»¯ÊìÁ·¶È
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 GetEquipPartStarLVByRank(curPlayer, packType, index, curEquip):
    maxStarLV = ItemCommon.GetItemMaxStarLV(curEquip)
    return min(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartStarLV % (packType, index)), maxStarLV)


## »ñÈ¡¹«¹²²¿Î»Ç¿»¯ÐǼ¶
def GetEquipPartStarLV(curPlayer, packType, index):
    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartStarLV % (packType, index))


## ÉèÖù«¹²²¿Î»Ç¿»¯ÐǼ¶
def SetEquipPartStarLV(curPlayer, packType, index, curEquip, starLV):
    if GetEquipPartStarLV(curPlayer, packType, index) == starLV:
        return
    
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_EquipPartStarLV % (packType, index), starLV)
    #===========================================================================
    # if curEquip and not curEquip.IsEmpty():
    #    curEquip.SetItemStarLV(starLV)
    #===========================================================================

    return

## ֪ͨ¹«¹²²¿Î»Ç¿»¯ÐǼ¶
def NotifyEquipPartStarLV(curPlayer, packType=None, index=None):
    ePartStarLVPack = ChPyNetSendPack.tagMCEquipPartStarLVInfo()
    ePartStarLVPack.Clear()
    ePartStarLVPack.InfoList = []
    
    for pType, indexList in ChConfig.Pack_EquipPart_CanPlusStar.items():
        
        if packType != None and packType != pType:
            continue
        
        for i in indexList:
            if packType != None:
                if index != None and index != i:
                    continue
            
            ePartStarLV = ChPyNetSendPack.tagMCEquipPartStarLV()
            ePartStarLV.Clear()
            ePartStarLV.PackType = pType
            ePartStarLV.EquipIndex = i
            ePartStarLV.EquipPartStarLV = GetEquipPartStarLV(curPlayer, pType, i)
            ePartStarLV.Proficiency = GetEquipPartProficiency(curPlayer, pType, i)
            ePartStarLVPack.InfoList.append(ePartStarLV)
            
    ePartStarLVPack.Count = len(ePartStarLVPack.InfoList)
    NetPackCommon.SendFakePack(curPlayer, ePartStarLVPack)
    return


## È«ÉíÇ¿»¯µÈ¼¶
def GetTotalPlusLV(curPlayer, isActive=True):
    totalPlusLV = 0
    equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
    equipPartIndexList = ChConfig.Pack_EquipPart_CanPlusStar[IPY_GameWorld.rptEquip]
    for i in equipPartIndexList:
        if isActive:
            curEquip = equipPack.GetAt(i)
            if not curEquip  or curEquip.IsEmpty():
                continue
            
        partStarLV = GetEquipPartStarLV(curPlayer, IPY_GameWorld.rptEquip, i)
        totalPlusLV += partStarLV
    return totalPlusLV

## È«Éí×°±¸ÐÇÊý
def GetTotalEquipStars(curPlayer):
    totalEquipStars = 0
    equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
    for i in ChConfig.BaseEquipPlaceList:
        curEquip = equipPack.GetAt(i)
        if not curEquip or curEquip.IsEmpty():
            continue
        totalEquipStars += curEquip.GetItemQuality()
    return totalEquipStars

# »ñȡװ±¸µÄÇ¿»¯ÀàÐÍ
def GetEquipPlusType(curEquip):
    equipPlace = curEquip.GetEquipPlace()
    plusTypeDict = IpyGameDataPY.GetFuncEvalCfg("StrengthenLevelLimit", 2)
    if not plusTypeDict:
        GameWorld.ErrLog("ûÓÐÇ¿»¯ÀàÐÍÓ³Éä±í")
        return -1
    
    return plusTypeDict.get(equipPlace, -1)

def SetEquipPartSuiteLV(curPlayer, index, suiteType, suiteLV):
    #ÉèÖù«¹²²¿Î»Ì××°µÈ¼¶
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_EquipPartSuiteLV % (index, suiteType), suiteLV)
    equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
    SetEquipItemSuiteLVInfo(curPlayer, index, equipPack.GetAt(index))
    return

def GetEquipPartSuiteLV(curPlayer, index, suiteType):
    #»ñÈ¡¹«¹²²¿Î»Ì××°µÈ¼¶
    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_EquipPartSuiteLV % (index, suiteType))

def GetEquipPartSuiteGroupType(curPlayer, equipIndex):
    #»ñÈ¡¹«¹²²¿Î»Ì××°×éºÏÀàÐÍ
    findGroupType = 0
    equipSuitTypeDict = IpyGameDataPY.GetFuncEvalCfg('EquipSuitType')
    for groupType, indexList in equipSuitTypeDict.items():
        if equipIndex in indexList:
            findGroupType = int(groupType)
            break
    return findGroupType

#  »ñÈ¡ÂúÌ××°»¯µÄ×îµÍ½×Êý£¬Èç5¼þÌ×£¬4¼þ5¼¶£¬1¼þ3¼¶£¬Ôò·µ»Ø3
def GetEquipSuitsLVByType(curPlayer, suitType, groupType):
    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 NotifyEquipPartSuiteLV(curPlayer, index=None):
    ePartSuitePack = ChPyNetSendPack.tagMCEquipPartSuiteLVInfo()
    ePartSuitePack.Clear()
    ePartSuitePack.InfoList = []
    
    equipSuitTypeDict = IpyGameDataPY.GetFuncEvalCfg('EquipSuitType')
    for equipIndexList in equipSuitTypeDict.values():
        for i in equipIndexList:
            if index != None and index != i:
                continue
            ePartSuiteInfo = ChPyNetSendPack.tagMCEquipPartSuiteLV()
            ePartSuiteInfo.Clear()
            ePartSuiteInfo.EquipIndex = i
            suiteInfo = GetSuiteInfoByPlace(curPlayer, i)
            ePartSuiteInfo.SuiteLVInfo = json.dumps(suiteInfo, ensure_ascii=False)
            ePartSuiteInfo.Len = len(ePartSuiteInfo.SuiteLVInfo)
            ePartSuitePack.InfoList.append(ePartSuiteInfo)
            
    ePartSuitePack.Count = len(ePartSuitePack.InfoList)
    NetPackCommon.SendFakePack(curPlayer, ePartSuitePack)
    return

def GetSuiteInfoByPlace(curPlayer, equipPlace, curEquip=None):
    suiteInfo = {} #{Ì××°ÀàÐÍ:µÈ¼¶}
    groupType = GetEquipPartSuiteGroupType(curPlayer, equipPlace)
    maxSuiteType = IpyGameDataPY.GetFuncCfg('EquipSuitColorStar', 2)
    for suiteType in range(1, maxSuiteType+1):
        suiteLV = GetEquipPartSuiteLV(curPlayer, equipPlace, suiteType)
        if suiteLV:
            if curEquip:
                maxSuiteLV = Operate_EquipSuitCompose.GetEquipCanDoMaxSuiteLV(curPlayer, curEquip, suiteType, groupType)
                suiteLV = min(suiteLV, maxSuiteLV)
            suiteInfo[suiteType] = suiteLV
    return suiteInfo

def GetEquipPartSuiteLVList(curPlayer, equipPlace, curEquip=None):
    ## ²¿Î»Ì××°µÈ¼¶Áбí
    groupType = GetEquipPartSuiteGroupType(curPlayer, equipPlace)
              
    suiteLVList = []
    maxSuiteType = IpyGameDataPY.GetFuncCfg('EquipSuitColorStar', 2)
    for suiteType in xrange(1, maxSuiteType+1):
        suiteLV = GetEquipPartSuiteLV(curPlayer, equipPlace, suiteType)
        if curEquip and suiteLV:
            maxSuiteLV = Operate_EquipSuitCompose.GetEquipCanDoMaxSuiteLV(curPlayer, curEquip, suiteType, groupType)
            suiteLV = min(suiteLV, maxSuiteLV)
        
        suiteLVList.append(suiteLV)
    return suiteLVList

## »ñÈ¡Íæ¼Ò×°±¸Ô¤ÀÀÐÅÏ¢
def GetPlayerEquipView(curPlayer):
    if not curPlayer:
        return []
    
    playerID = curPlayer.GetPlayerID()
    playerEquipList = []
    
    playerEquip = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
    #Íæ¼Òµ±Ç°¿É×°±¸µÄ×°±¸ÀàÐÍ
    for equipIndex in xrange(0, playerEquip.GetCount()):
        
        if equipIndex not in ShareDefine.RoleEquipType:
            continue
        
        curEquip = playerEquip.GetAt(equipIndex)
        if curEquip.IsEmpty():
            continue
        
        playerEquipList.append([curEquip.GetItemTypeID(), equipIndex, 0, 0])
                                #curEquip.GetItemStarLV(), 0])
    
    #GameWorld.DebugLog("Íæ¼Ò×°±¸ÐÅÏ¢£º%s" % str(playerEquipList), playerID)
    return playerEquipList


#// 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)
    if activeType == 0:
        PlayerMagicWeapon.CalcMagicWeaponSoulAttr(curPlayer)
    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