#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Player.PlayerGubao
#
# @todo:¹Å±¦ÏµÍ³
# @author hxp
# @date 2023-01-05
# @version 1.0
#
# ÏêϸÃèÊö: ¹Å±¦ÏµÍ³
#
#-------------------------------------------------------------------------------
#"""Version = 2023-01-05 15:30"""
#-------------------------------------------------------------------------------

import GameWorld
import PlayerRune
import ItemCommon
import PlayerControl
import IpyGameDataPY
import ChPyNetSendPack
import PlayerGatherSoul
import NetPackCommon
import IPY_GameWorld
import PlayerHorse
import PlayerDogz
import PlayerPet
import ChConfig
import ItemControler
import PlayerDienstgrad
import PlayerGatherTheSoul
import PlayerActGubao
import PlayerActTask
import PlayerCoat

GubaoEffType_FamilyWar = 48 # ²ÎÓëÏÉÃËÁªÈüÿX´Î+XXXÊôÐÔ    x´Î
GubaoEffType_ElderBattlefield = 49 # ²ÎÓëÉϹÅÕ½³¡Ã¿X´Î+XXXÊôÐÔ    x´Î
GubaoEffType_CrossBattlefield = 50 # ²ÎÓë¹ÅÉñÕ½³¡Ã¿X´Î+XXXÊôÐÔ    x´Î
GubaoEffType_CrossYaomoBoss = 51 # ²ÎÓëħÍõÈëÇÖÿX´Î+XXXÊôÐÔ    x´Î
GubaoEffType_CrossFamilyFlagwar = 52 # ²ÎÓëÖð¹Íò½çÿX´Î+XXXÊôÐÔ    x´Î

GubaoEffAttrIypeList = [GubaoEffType_FamilyWar, GubaoEffType_ElderBattlefield, GubaoEffType_CrossBattlefield, 
                        GubaoEffType_CrossYaomoBoss, GubaoEffType_CrossFamilyFlagwar]

GubaoEffType_ActivityPlace = 33 # »îÔ¾ÐÞÁ¶x´Î¿ÉÁìÈ¡ÎïÆ·    x´Î
GubaoEffType_Arena = 34 # ¾º¼¼³¡ÌôÕ½x´Î¿ÉÁìÈ¡ÎïÆ·    x´Î
GubaoEffType_KillWorldBoss = 35 # »÷ɱÊÀ½çbossx´Î¿ÉÁìÈ¡ÎïÆ·    x´Î
GubaoEffType_KillBossHome = 36 # »÷ɱbossÖ®¼Òbossx´Î¿ÉÁìÈ¡ÎïÆ·    x´Î
GubaoEffType_KillCrossPenglaiBoss = 37 # »÷ɱÅîÀ³Ïɾ³bossx´Î¿ÉÁìÈ¡ÎïÆ·    x´Î
GubaoEffType_KillCrossDemonLandBoss = 38 # »÷ɱħ»¯Ö®µØbossx´Î¿ÉÁìÈ¡ÎïÆ·    x´Î
GubaoEffType_KillSealDemonBoss = 39 # »÷ɱ·âħ̳bossx´Î¿ÉÁìÈ¡ÎïÆ·    x´Î
GubaoEffType_CrossRealmPK = 40 # ²ÎÓë¿ç·þÌìÌÝÈüx´Î¿ÉÁìÈ¡ÎïÆ·    x´Î

# ¹Å±¦ÁìÈ¡ÎïÆ·ÌØÊâЧ¹ûÁбí
GubaoEffTtemIypeList = [GubaoEffType_ActivityPlace, GubaoEffType_Arena, GubaoEffType_KillWorldBoss, GubaoEffType_KillBossHome,
                        GubaoEffType_KillCrossPenglaiBoss, GubaoEffType_KillCrossDemonLandBoss, GubaoEffType_KillSealDemonBoss,
                        GubaoEffType_CrossRealmPK,
                        ]

# ¹Å±¦Áé¸ùµãÌØÊâЧ¹ûÁбí
GubaoEffType_RealmLVAddLinggen = 55 # ¾³½çÿ¼¶Ôö¼ÓXµãÁé¸ù
GubaoEffFreePointTypeList = [54, 55, 56]

# ÐèÒª¼Ç¼EffValueµÄEffTypeÁбí
NeedGubaoItemEffValueTypeList = GubaoEffAttrIypeList + GubaoEffTtemIypeList + GubaoEffFreePointTypeList

def GetGubaoLVInfo(curPlayer, gubaoID):
    lvInfo = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoLVInfo % gubaoID)
    lv = lvInfo / 100
    star = lvInfo % 100
    return lv, star
def SetGubaoLVInfo(curPlayer, gubaoID, lv, star):
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GubaoLVInfo % gubaoID, lv * 100 + star)
    return

def OnPlayerLogin(curPlayer):
    DoGubaoAddFreePoint(curPlayer) # ÉÏÏß¼ì²éһϣ¬ÐÞ¸ÄÅäÖÿÉÉúЧ
    Sync_GubaoInfo(curPlayer)
    Sync_GubaoItemEffInfo(curPlayer)
    Sync_GubaoPieceInfo(curPlayer)
    return

def AddGubaoPiece(curPlayer, gubaoID, addCount, useItemID):
    curCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoPiece % gubaoID)
    updCount = min(curCount + addCount, ChConfig.Def_UpperLimit_DWord)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GubaoPiece % gubaoID, updCount)
    Sync_GubaoPieceInfo(curPlayer, [gubaoID])
    GameWorld.Log("Ôö¼Ó¹Å±¦ËéƬ: gubaoID=%s,curCount=%s,addCount=%s,updCount=%s,useItemID=%s" 
                  % (gubaoID, curCount, addCount, updCount, useItemID), curPlayer.GetPlayerID())
    return curCount, updCount

def DelGubaoPiece(curPlayer, gubaoID, delCount, delName):
    curCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoPiece % gubaoID)
    if curCount < delCount:
        return False
    updCount = curCount - delCount
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GubaoPiece % gubaoID, updCount)
    Sync_GubaoPieceInfo(curPlayer, [gubaoID])
    GameWorld.Log("¿Û³ý¹Å±¦ËéƬ: gubaoID=%s,curCount=%s,delCount=%s,updCount=%s,delName=%s" 
                  % (gubaoID, curCount, delCount, updCount, delName), curPlayer.GetPlayerID())
    return True

def ParseGubaoNeedItem(curPlayer, needItemList):
    ## ½âÎö¹Å±¦¹¦ÄÜËùÐèÎïÆ·£¬×ª»¯Îª¹Å±¦ËéƬ+ÎïÆ·
    needPieceInfo, realNeedItemList = {}, []
    for itemID, itemCount in needItemList:
        itemData = GameWorld.GetGameData().GetItemByTypeID(itemID)
        if not itemData:
            continue
        curEff = itemData.GetEffectByIndex(0)
        effID = curEff.GetEffectID()
        if effID != ChConfig.Def_Effect_GubaoPiece:
            realNeedItemList.append([itemID, itemCount])
            continue
        gubaoID = curEff.GetEffectValue(0)
        needPieceInfo[gubaoID] = needPieceInfo.get(gubaoID, 0) + itemCount
    GameWorld.DebugLog("ת»¯¹Å±¦¹¦ÄÜËùÐèÎïÆ·: needItemList=%s,realNeedItemList=%s,needPieceInfo=%s" 
                       % (needItemList, realNeedItemList, needPieceInfo), curPlayer.GetPlayerID())
    return needPieceInfo, realNeedItemList

#// B2 16 ¹Å±¦¼¤»î #tagCMGubaoActivate
#
#struct    tagCMGubaoActivate
#{
#    tagHead         Head;
#    WORD        GubaoID;    
#};
def OnGubaoActivate(index, curPackData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    gubaoID = curPackData.GubaoID
    ipyData = IpyGameDataPY.GetIpyGameData("Gubao", gubaoID)
    if not ipyData:
        return
    needItemID = ipyData.GetUnlockItemID()
    needItemCnt = ipyData.GetUnlockItemCnt()
    if not needItemID or not needItemCnt:
        return
    
    lv, star = GetGubaoLVInfo(curPlayer, gubaoID)
    if lv or star:
        GameWorld.DebugLog("¹Å±¦ÒѾ­¼¤»î¹ý£¡ gubaoID=%s" % gubaoID, playerID)
        return
    
    needPieceInfo, realNeedItemList = ParseGubaoNeedItem(curPlayer, [[needItemID, needItemCnt]])
    if realNeedItemList:
        itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
        hasEnough, itemList = ItemCommon.GetItem_FromPack_ByID(needItemID, itemPack, needItemCnt)
        if not hasEnough:
            GameWorld.DebugLog("¼¤»î¹Å±¦µÀ¾ß²»×ã! needItemID=%s,needItemCnt=%s" % (needItemID, needItemCnt), playerID)
            return
    for gID, needPieceCount in needPieceInfo.items():
        curCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoPiece % gID)
        if curCount < needPieceCount:
            GameWorld.DebugLog("¼¤»î¹Å±¦ËéƬ²»×ã! gubaoID=%s,curCount=%s < needPieceCount=%s" % (gubaoID, curCount, needPieceCount), playerID)
            return
        
    for gID, needPieceCount in needPieceInfo.items():
        DelGubaoPiece(curPlayer, gID, needPieceCount, "Activate")
    if realNeedItemList:
        ItemCommon.ReduceItem(curPlayer, itemPack, itemList, needItemCnt, False, "Gubao")
        
    lv, star = 1, 1
    SetGubaoLVInfo(curPlayer, gubaoID, lv, star)
    GameWorld.Log("¹Å±¦¼¤»î³É¹¦£¡ gubaoID=%s" % gubaoID, playerID)
    DoGubaoAddFreePoint(curPlayer, gubaoID)
    
    RefreshGubaoAttr(curPlayer)
    Sync_GubaoInfo(curPlayer, [gubaoID])
    
    PlayerActGubao.OnGubaoCost(curPlayer, needPieceInfo, realNeedItemList)
    return

#// B2 17 ¹Å±¦ÉýÐÇ #tagCMGubaoStarUp
#
#struct    tagCMGubaoPieceUse
#{
#    WORD        GubaoID;        // ͨÓÃËéƬ¹Å±¦ID
#    WORD        PieceCount;    // ʹÓÃËéƬ¸öÊý
#};
#
#struct    tagCMGubaoStarUp
#{
#    tagHead         Head;
#    WORD        GubaoID;    
#    BYTE        PieceSelectCount;
#    tagCMGubaoPieceUse    CommPieceUseList[PieceSelectCount];    // ͨÓùű¦ËéƬʹÓÃÁбí
#};
def OnGubaoStarUp(index, curPackData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    gubaoID = curPackData.GubaoID
    
    lv, star = GetGubaoLVInfo(curPlayer, gubaoID)
    if not star:
        GameWorld.DebugLog("¹Å±¦Î´¼¤»î£¬ÎÞ·¨ÉýÐÇ£¡ gubaoID=%s" % gubaoID, playerID)
        return
    
    if not IpyGameDataPY.GetIpyGameDataNotLog("GubaoStar", gubaoID, star + 1):
        GameWorld.DebugLog("¹Å±¦ÒÑÂúÐÇ£¡ gubaoID=%s,star=%s" % (gubaoID, star), playerID)
        return
    
    ipyData = IpyGameDataPY.GetIpyGameData("GubaoStar", gubaoID, star)
    if not ipyData:
        return
    needItemList = ipyData.GetStarUPNeedItemInfo()
    needQualityPiece = ipyData.GetStarUPNeedQualityPiece()
    if not needItemList and not needQualityPiece:
        return
    
    needPieceInfo, realNeedItemList = ParseGubaoNeedItem(curPlayer, needItemList)
    if realNeedItemList:
        itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
        lackItemDict, delInfoDict = ItemCommon.GetCostItemIndexList(realNeedItemList, itemPack)
        if lackItemDict:
            GameWorld.DebugLog("¹Å±¦ÉýÐÇËùÐèÎïÆ·²»×㣡 star=%s,realNeedItemList=%s,lackItemDict=%s" % (star, realNeedItemList, lackItemDict), playerID)
            return
        
    if needQualityPiece:
        commPieceUseLimitInfo = IpyGameDataPY.GetFuncEvalCfg("GubaoPiece", 1, {})
        selectPieceDict = {}
        for pieceUse in curPackData.CommPieceUseList:
            useGubaoID = pieceUse.GubaoID
            usePieceCnt = pieceUse.PieceCount
            useIpyData = IpyGameDataPY.GetIpyGameData("Gubao", useGubaoID)
            if not useIpyData:
                return
            quality = useIpyData.GetGubaoQuality()
            if str(quality) not in commPieceUseLimitInfo:
                GameWorld.DebugLog("¸Ã¹Å±¦Æ·ÖÊûÓÐÅäÖÿÉ×÷ΪͨÓÃËéƬʹÓõÄ×îµÍÐǼ¶! useGubaoID=%s" % (useGubaoID), playerID)
                return
            needStar = commPieceUseLimitInfo[str(quality)]
            _, usePieceStar = GetGubaoLVInfo(curPlayer, useGubaoID)
            if usePieceStar < needStar:
                GameWorld.DebugLog("¸Ã¹Å±¦Æ·ÖÊÐǼ¶²»×㣬ÎÞ·¨×÷ΪͨÓÃËéƬ! useGubaoID=%s,usePieceStar=%s < %s" % (useGubaoID, usePieceStar, needStar), playerID)
                return
            selectPieceDict[quality] = selectPieceDict.get(quality, 0) + usePieceCnt
            needPieceInfo[useGubaoID] = needPieceInfo.get(useGubaoID, 0) + usePieceCnt
            
        for quality, needCount in needQualityPiece:
            selectCount = selectPieceDict.get(quality, 0)
            if selectCount != needCount: # Ð辫ȷƥÅä¸öÊý£¬¶à»òÉÙ¶¼²»ÔÊÐíÉýÐÇ£¬·ÀÖ¹¶à¿Û»òÕßÉÙ¿Û
                GameWorld.ErrLog("Ñ¡ÔñʹÓõÄÆ·ÖÊͨÓÃËéƬ¸öÊý²»Æ¥Å䣬ÎÞ·¨ÉýÐÇ!  gubaoID=%s,star=%s,quality=%s,selectCount=%s != %s" 
                                 % (gubaoID, star, quality, selectCount, needCount), playerID)
                return
            
        GameWorld.DebugLog("ËùÐè¹Å±¦ËéƬ»ã×Ü: %s" % needPieceInfo, playerID)
        
    for costGubaoID, needPieceCount in needPieceInfo.items():
        curCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoPiece % costGubaoID)
        if curCount < needPieceCount:
            GameWorld.DebugLog("¹Å±¦ÉýÐÇËùÐè¹Å±¦ËéƬ²»×ã! gubaoID=%s,costGubaoID=%s,curCount=%s < needPieceCount=%s" % (gubaoID, costGubaoID, curCount, needPieceCount), playerID)
            return
        
    #¿ÛÏûºÄ
    for costGubaoID, needPieceCount in needPieceInfo.items():
        DelGubaoPiece(curPlayer, costGubaoID, needPieceCount, "StarUp")
    if realNeedItemList:
        ItemCommon.DelCostItem(curPlayer, itemPack, delInfoDict, "Gubao")
        
    updStar = star + 1
    SetGubaoLVInfo(curPlayer, gubaoID, lv, updStar)
    GameWorld.Log("¹Å±¦ÉýÐÇ: gubaoID=%s,updStar=%s" % (gubaoID, updStar), playerID)
    DoGubaoAddFreePoint(curPlayer, gubaoID)
    RefreshGubaoAttr(curPlayer)
    Sync_GubaoInfo(curPlayer, [gubaoID])
    
    PlayerActGubao.OnGubaoCost(curPlayer, needPieceInfo, realNeedItemList)
    PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_GubaoStarUp)
    return

def DoGubaoAddFreePoint(curPlayer, gubaoID=0):
    playerID = curPlayer.GetPlayerID()
    effPointDict = {}
    if gubaoID:
        __calcStarEffAddFreePoint(curPlayer, gubaoID, effPointDict)
    else:
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        for index in xrange(ipyDataMgr.GetGubaoCount()):
            ipyData = ipyDataMgr.GetGubaoByIndex(index)
            gubaoID = ipyData.GetGubaoID()
            __calcStarEffAddFreePoint(curPlayer, gubaoID, effPointDict)
            
    if not effPointDict:
        return
    
    unAddFreePointTotal = 0
    for effKey, addFreePointTotal in effPointDict.items():
        gubaoID, star, effType = effKey 
        # ÒÑÔö¼ÓµÄµãÊý
        addFreePointAlready = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoItemEffValue % (gubaoID, effType))
        unAddFreePoint = max(0, addFreePointTotal - addFreePointAlready)
        unAddFreePointTotal += unAddFreePoint
        GameWorld.DebugLog("¹Å±¦ÐǼ¶Ôö¼ÓÁé¸ùµã: gubaoID=%s,star=%s,effType=%s,addFreePointTotal=%s,addFreePointAlready=%s,unAddFreePoint=%s,total=%s" 
                           % (gubaoID, star, effType, addFreePointTotal, addFreePointAlready, unAddFreePoint, unAddFreePointTotal), playerID)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GubaoItemEffValue % (gubaoID, effType), addFreePointTotal)
        if unAddFreePoint:
            Sync_GubaoItemEffInfo(curPlayer, gubaoID, effType, True)
            
    if unAddFreePointTotal <= 0:
        return
    freePoint = curPlayer.GetFreePoint()
    updFreePoint = freePoint + unAddFreePointTotal
    curPlayer.SetFreePoint(updFreePoint)
    GameWorld.DebugLog("¹Å±¦¼Óµã: freePoint=%s,freePoint=%s,freePoint=%s" % (freePoint, unAddFreePointTotal, updFreePoint), playerID)
    return

def __calcStarEffAddFreePoint(curPlayer, gubaoID, effPointDict):
    _, star = GetGubaoLVInfo(curPlayer, gubaoID)
    if not star:
        return
    starIpyData = IpyGameDataPY.GetIpyGameData("GubaoStar", gubaoID, star)
    if not starIpyData:
        return
    starEffIDList = starIpyData.GetStarEffIDList()
    for effID in starEffIDList:
        effIpyData = IpyGameDataPY.GetIpyGameData("GubaoEffAttr", effID)
        if not effIpyData:
            continue
        effType = effIpyData.GetGubaoEffType()
        effCond = effIpyData.GetEffCond()
        effAttrValue = effIpyData.GetEffAttrValue()
        
        effKey = (gubaoID, star, effType)
        if effType == 54: # Ôö¼ÓxµãÁé¸ù
            addFreePointTotal = effIpyData.GetEffAttrValue()
            effPointDict[effKey] = effPointDict.get(effKey, 0) + addFreePointTotal
        elif effType == 55: # ¾³½çÿ¼¶Ôö¼ÓXµãÁé¸ù
            realmLV = curPlayer.GetOfficialRank()
            addFreePointTotal = int(realmLV / effCond * effAttrValue)
            effPointDict[effKey] = effPointDict.get(effKey, 0) + addFreePointTotal
        elif effType == 56: # µÈ¼¶Ã¿¼¶Ôö¼ÓXµãÁé¸ù
            playerLV = curPlayer.GetLV()
            addFreePointTotal = int(playerLV / effCond * effAttrValue)
            effPointDict[effKey] = effPointDict.get(effKey, 0) + addFreePointTotal
            
    return


#// B2 18 ¹Å±¦Éý¼¶ #tagCMGubaoLVUp
#
#struct    tagCMGubaoLVUp
#{
#    tagHead         Head;
#    WORD        GubaoID;    
#};
def OnGubaoLVUp(index, curPackData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    gubaoID = curPackData.GubaoID
    
    lv, star = GetGubaoLVInfo(curPlayer, gubaoID)
    if not star:
        GameWorld.DebugLog("¹Å±¦Î´¼¤»î£¬ÎÞ·¨Éý¼¶£¡ gubaoID=%s" % gubaoID, playerID)
        return
    
    ipyData = IpyGameDataPY.GetIpyGameData("Gubao", gubaoID)
    if not ipyData:
        return
    gubaoType = ipyData.GetGubaoType()
    quality = ipyData.GetGubaoQuality()
    
    if not IpyGameDataPY.GetIpyGameDataNotLog("GubaoLV", gubaoType, quality, lv + 1):
        GameWorld.DebugLog("¹Å±¦ÒÑÂú¼¶£¡ gubaoID=%s,quality=%s,lv=%s" % (gubaoID, quality, lv), playerID)
        return
    
    lvIpyData = IpyGameDataPY.GetIpyGameData("GubaoLV", gubaoType, quality, lv)
    if not lvIpyData:
        return
    needItemList = lvIpyData.GetLVUPNeedItemInfo()
    if not needItemList:
        return
    
    needPieceInfo, realNeedItemList = ParseGubaoNeedItem(curPlayer, needItemList)
    if realNeedItemList:
        itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
        lackItemDict, delInfoDict = ItemCommon.GetCostItemIndexList(realNeedItemList, itemPack)
        if lackItemDict:
            GameWorld.DebugLog("¹Å±¦Éý¼¶ËùÐèÎïÆ·²»×㣡 quality=%s,lv=%s,realNeedItemList=%s,lackItemDict=%s" 
                               % (quality, lv, realNeedItemList, lackItemDict), playerID)
            return
    for gID, needPieceCount in needPieceInfo.items():
        curCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoPiece % gID)
        if curCount < needPieceCount:
            GameWorld.DebugLog("¹Å±¦Éý¼¶ËùÐè¹Å±¦ËéƬ²»×ã! gubaoID=%s,curCount=%s < needPieceCount=%s" % (gubaoID, curCount, needPieceCount), playerID)
            return
        
    #¿ÛÏûºÄ
    for gID, needPieceCount in needPieceInfo.items():
        DelGubaoPiece(curPlayer, gID, needPieceCount, "LVUp")
    if realNeedItemList:
        ItemCommon.DelCostItem(curPlayer, itemPack, delInfoDict, "Gubao")
    
    updLV = lv + 1
    SetGubaoLVInfo(curPlayer, gubaoID, updLV, star)
    GameWorld.Log("¹Å±¦Éý¼¶: gubaoID=%s,gubaoType=%s,quality=%s,updLV=%s" % (gubaoID, gubaoType, quality, updLV), playerID)
    RefreshGubaoAttr(curPlayer)
    Sync_GubaoInfo(curPlayer, [gubaoID])
    
    PlayerActGubao.OnGubaoCost(curPlayer, needPieceInfo, realNeedItemList)
    PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_GubaoLVUp)
    return

def GetGubaoTotalLVStar(curPlayer):
    ## »ñÈ¡¹Å±¦×ܵȼ¶£¬ÐÇÊý
    totalLV, totalStar =  0, 0
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in xrange(ipyDataMgr.GetGubaoCount()):
        ipyData = ipyDataMgr.GetGubaoByIndex(index)
        gubaoID = ipyData.GetGubaoID()
        lv, star = GetGubaoLVInfo(curPlayer, gubaoID)
        totalLV += lv
        totalStar += star
    return totalLV, totalStar

def RefreshGubaoAttr(curPlayer):
    #CalcGubaoAttr(curPlayer)
    PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState()
    return

def CalcGubaoAttr(curPlayer):
    
    allAttrList = [{} for _ in range(4)]
    allAttrListResonance = [{} for _ in range(4)]
    
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in xrange(ipyDataMgr.GetGubaoCount()):
        ipyData = ipyDataMgr.GetGubaoByIndex(index)
        gubaoID = ipyData.GetGubaoID()
        lv, star = GetGubaoLVInfo(curPlayer, gubaoID)
        if not star:
            continue
        
        gubaoType = ipyData.GetGubaoType()
        quality = ipyData.GetGubaoQuality()
        lvIpyData = IpyGameDataPY.GetIpyGameData("GubaoLV", gubaoType, quality, lv)
        if lvIpyData:
            lvAttrTypeList = lvIpyData.GetLVAttrTypeList()
            lvAttrValueList = lvIpyData.GetLVAttrValueList()
            for i, attrID in enumerate(lvAttrTypeList):
                attrValue = lvAttrValueList[i]
                PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrList)
                
        starIpyData = IpyGameDataPY.GetIpyGameData("GubaoStar", gubaoID, star)
        if starIpyData:
            starAttrIDList = starIpyData.GetStarAttrIDList()
            starAttrValueList = starIpyData.GetStarAttrValueList()
            for i, attrID in enumerate(starAttrIDList):
                attrValue = starAttrValueList[i]
                PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrList)
                
            starEffIDList = starIpyData.GetStarEffIDList()
            effAttrInfo = {}
            #GameWorld.DebugLog("GubaoStarÊôÐÔ: gubaoID=%s,star=%s,starEffIDList=%s" % (gubaoID, star, starEffIDList))
            for effID in starEffIDList:
                __calcStarEffAttrByID(curPlayer, gubaoID, effID, effAttrInfo)
                #GameWorld.DebugLog("    effID=%s,effAttrInfo=%s" % (effID, effAttrInfo))
            for attrID, attrValue in effAttrInfo.items():
                PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrList)
                
    # ¹²Ãù
    for index in range(ipyDataMgr.GetGubaoResonanceCount()):
        ipyData = ipyDataMgr.GetGubaoResonanceByIndex(index)
        resonanceID = ipyData.GetResonanceID()
        gubaoIDList = ipyData.GetGubaoIDList()
        if not gubaoIDList:
            continue
        
        gubaoStarDict = {}
        for gubaoID in gubaoIDList:
            _, star = GetGubaoLVInfo(curPlayer, gubaoID)
            gubaoStarDict[gubaoID] = star
        minStar = min(gubaoStarDict.values()) # ¹²ÃùÐǼ¶£¬È¡×éºÏÖÐ×îµÍ¹Å±¦ÐǼ¶
        if not minStar:
            #GameWorld.DebugLog("¹²Ãù×éºÏ´æÔڹű¦Î´¼¤»î! resonanceID=%s,gubaoStarDict=%s" % (resonanceID, gubaoStarDict))
            continue
        
        attrIpyDataList = IpyGameDataPY.GetIpyGameDataList("GubaoResonanceAttr", resonanceID)
        if not attrIpyDataList:
            continue
        
        resonanceAttrIpyData = None
        for attrIpyData in attrIpyDataList:
            resonanceStar = attrIpyData.GetResonanceStar()
            if resonanceStar > minStar:
                break
            resonanceAttrIpyData = attrIpyData
            
        if not resonanceAttrIpyData:
            #GameWorld.DebugLog("ûÓйű¦¹²ÃùÊôÐÔ! resonanceID=%s,minStar=%s" % (resonanceID, minStar))
            continue
        
        #GameWorld.DebugLog("¹Å±¦¹²Ãù: resonanceID=%s,resonanceStar=%s,gubaoStarDict=%s" % (resonanceID, resonanceAttrIpyData.GetResonanceStar(), gubaoStarDict))
        resonanceAttrIDList = resonanceAttrIpyData.GetResonanceAttrIDList()
        resonanceAttrValueList = resonanceAttrIpyData.GetResonanceAttrValueList()
        for i, attrID in enumerate(resonanceAttrIDList):
            attrValue = resonanceAttrValueList[i]
            PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListResonance)
            
    # ±£´æ¼ÆËãÖµ
    #GameWorld.DebugLog("¹Å±¦ÊôÐÔ: %s" % allAttrList)
    #GameWorld.DebugLog("¹Å±¦¹²ÃùÊôÐÔ: %s" % allAttrListResonance)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Gubao, allAttrList)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_GubaoResonance, allAttrListResonance)
    return

def __calcStarEffAttrByID(curPlayer, gubaoID, effID, effAttrInfo):
    ''' ¼ÆËã¹Å±¦ÌØÊâЧ¹ûID¶ÔÓ¦ÌáÉýÊôÐÔ
    '''
    ipyData = IpyGameDataPY.GetIpyGameData("GubaoEffAttr", effID)
    if not ipyData:
        return
    effType = ipyData.GetGubaoEffType()
    effCond = ipyData.GetEffCond()
    effCond2 = ipyData.GetEffCond2()
    effCond3 = ipyData.GetEffCond3()
    attrID = ipyData.GetEffAttrID()
    effAttrValue = ipyData.GetEffAttrValue()
    if effAttrValue <= 0:
        return
    #Ч¹ûÀàÐÍ    ÀàÐÍ˵Ã÷                                                    Ìõ¼þ
    # 10    xÆ·ÖÊÁé³è¹¥»÷ÊôÐÔÌáÉýx%      xÆ·ÖÊ
    if effType == 10:
        customAttrDictPet = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Pet)[2]
        petQualityAttrInfo = customAttrDictPet.get("petQualityAttrInfo", {})
        quality = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,quality=%s,petQualityAttrInfo=%s" % (effID, effType, quality, petQualityAttrInfo))
        if quality not in petQualityAttrInfo:
            return
        __addStarEffFuncAttr(ipyData, effAttrInfo, petQualityAttrInfo[quality], effAttrValue)
        
    # 11    Áé³è×ܵȼ¶Ã¿x¼¶+xxÊôÐÔ                   x¼¶
    elif effType == 11:
        totalPetLV = PlayerPet.GetTotalPetLV(curPlayer)
        addAttrValue = int(totalPetLV / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,totalPetLV=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, totalPetLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    # 12    Áé³èÿ¼¤»îxÖ»+xxÊôÐÔ                        xÖ»
    elif effType == 12:
        totalPetCount = PlayerPet.GetTotalPetCount(curPlayer)
        addAttrValue = int(totalPetCount / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,totalPetCount=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, totalPetCount, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    # 13    xÆ·ÖÊ×øÆï»Ã»¯ÊôÐÔÌáÉýx%      xÆ·ÖÊ
    elif effType == 13:
        customAttrDictSkin = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_HorseSkin)[2]
        horseSkinQualityAttrInfo = customAttrDictSkin.get("horseSkinQualityAttrInfo", {})
        quality = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,quality=%s,horseSkinQualityAttrInfo=%s" % (effID, effType, quality, horseSkinQualityAttrInfo))
        if quality not in horseSkinQualityAttrInfo:
            return
        __addStarEffFuncAttr(ipyData, effAttrInfo, horseSkinQualityAttrInfo[quality], effAttrValue)
        
    # 14    ×øÆï»Ã»¯¼¤»îxÖ»+xxÊôÐÔ                   xÖ»
    elif effType == 14:
        horseSkinActCount = PlayerHorse.GetHorseSkinActCount(curPlayer)
        addAttrValue = int(horseSkinActCount / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,horseSkinActCount=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, horseSkinActCount, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    # 15    ÿÅàÑø×øÆïx´Î+xxÊôÐÔ                        x´Î
    elif effType == 15:
        pass
    
    #16    x½××°±¸Ç¿»¯ÊôÐÔÌáÉýx%        x½×
    elif effType == 16:
        customAttrDictPlus = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Plus)[2]
        classBaseAttrDictPlus = customAttrDictPlus.get("classBaseAttrDictPlus", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classBaseAttrDictPlus=%s" % (effID, effType, classLV, classBaseAttrDictPlus))
        if classLV not in classBaseAttrDictPlus:
            return
        __addStarEffFuncAttr(ipyData, effAttrInfo, classBaseAttrDictPlus[classLV], effAttrValue)
        
    #17    x½××°±¸±¦Ê¯ÊôÐÔÌáÉýx%        x½×
    elif effType == 17:
        customAttrDictStone = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Stone)[2]
        classBaseAttrDictStone = customAttrDictStone.get("classBaseAttrDictStone", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classBaseAttrDictStone=%s" % (effID, effType, classLV, classBaseAttrDictStone))
        if classLV not in classBaseAttrDictStone:
            return
        __addStarEffFuncAttr(ipyData, effAttrInfo, classBaseAttrDictStone[classLV], effAttrValue)
        
    #18    x½××°±¸ÉýÐÇÊôÐÔÌáÉýx%        x½×
    elif effType == 18:
        customAttrDictStar = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Star)[2]
        classBaseAttrDictStar = customAttrDictStar.get("classBaseAttrDictStar", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classBaseAttrDictStar=%s" % (effID, effType, classLV, classBaseAttrDictStar))
        if classLV not in classBaseAttrDictStar:
            return
        __addStarEffFuncAttr(ipyData, effAttrInfo, classBaseAttrDictStar[classLV], effAttrValue)
        
    #19    x½××°±¸Ï´Á¶ÊôÐÔÌáÉýx%        x½×
    elif effType == 19:
        customAttrDictWash = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Wash)[2]
        classBaseAttrDictWash = customAttrDictWash.get("classBaseAttrDictWash", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classBaseAttrDictWash=%s" % (effID, effType, classLV, classBaseAttrDictWash))
        if classLV not in classBaseAttrDictWash:
            return
        __addStarEffFuncAttr(ipyData, effAttrInfo, classBaseAttrDictWash[classLV], effAttrValue)
        
    #20    x½××°±¸¸½Ä§ÊôÐÔÌáÉýx%        x½×
    elif effType == 20:
        customAttrDictEnchant = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Enchant)[2]
        classBaseAttrDictEnchant = customAttrDictEnchant.get("classBaseAttrDictEnchant", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classBaseAttrDictEnchant=%s" % (effID, effType, classLV, classBaseAttrDictEnchant))
        if classLV not in classBaseAttrDictEnchant:
            return
        __addStarEffFuncAttr(ipyData, effAttrInfo, classBaseAttrDictEnchant[classLV], effAttrValue)
        
    #21    ³öÕ½ÉñÊÞ×°±¸Ç¿»¯Ã¿x¼¶+xxÊôÐÔ    x¼¶
    elif effType == 21:
        fightDogzTotalPlusLv = PlayerDogz.GetFightDogzTotalPlusLv(curPlayer)
        addAttrValue = int(fightDogzTotalPlusLv / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,fightDogzTotalPlusLv=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, fightDogzTotalPlusLv, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #22    ÌìÐÇËþÿͨ¹Øx²ã+xxÊôÐÔ                    x²ã
    elif effType == 22:
        skyTowerFloor = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_SkyTowerFloor)
        addAttrValue = int(skyTowerFloor / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,skyTowerFloor=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, skyTowerFloor, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #23    ·ûÓ¡Ëþÿͨ¹Øx²ã+xxÊôÐÔ                    x²ã
    elif effType == 23:
        trialTowerPassLV = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_TrialTower_PassLV)
        addAttrValue = int(trialTowerPassLV / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,trialTowerPassLV=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, trialTowerPassLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #24    ·ûÓ¡µÈ¼¶Ã¿Ã¿x¼¶+xxÊôÐÔ                   x¼¶
    elif effType == 24:
        runeTotalLV = PlayerRune.GetRuneTotalLV(curPlayer)
        addAttrValue = int(runeTotalLV / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,runeTotalLV=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, runeTotalLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #25    ¾Û»êµÈ¼¶Ã¿Ã¿x¼¶+xxÊôÐÔ                   x¼¶
    elif effType == 25:
        soulTotalLV = PlayerGatherSoul.GetGatherSoulTotalLV(curPlayer)
        addAttrValue = int(soulTotalLV / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,soulTotalLV=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, soulTotalLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #26    x½××°±¸Ç¿»¯Ã¿x¼¶+xxÊôÐÔ                x½×        x¼¶
    elif effType == 26:
        customAttrDictPlus = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Plus)[2]
        classPlusLVDict = customAttrDictPlus.get("classPlusLVDict", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classPlusLVDict=%s" % (effID, effType, classLV, classPlusLVDict))
        if classLV not in classPlusLVDict:
            return
        totalPlusLV = classPlusLVDict[classLV]
        addAttrValue = int(totalPlusLV / effCond2 * effAttrValue)
        #GameWorld.DebugLog("        effCond=%s,effCond2=%s,totalPlusLV=%s,attrID=%s,addAttrValue=%s" % (effCond, effCond2, totalPlusLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #27    x½××°±¸±¦Ê¯Ã¿x¼¶+xxÊôÐÔ                x½×        x¼¶
    elif effType == 27:
        customAttrDictStone = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Stone)[2]
        classStoneLVDict = customAttrDictStone.get("classStoneLVDict", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classStoneLVDict=%s" % (effID, effType, classLV, classStoneLVDict))
        if classLV not in classStoneLVDict:
            return
        totalStoneLV = classStoneLVDict[classLV]
        addAttrValue = int(totalStoneLV / effCond2 * effAttrValue)
        #GameWorld.DebugLog("        effCond=%s,effCond2=%s,totalStoneLV=%s,attrID=%s,addAttrValue=%s" % (effCond, effCond2, totalStoneLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #28    x½××°±¸ÉýÐÇÿxÐÇ+xxÊôÐÔ                x½×        xÐÇ
    elif effType == 28:
        customAttrDictStar = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Star)[2]
        classStarLVDict = customAttrDictStar.get("classStarLVDict", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classStarLVDict=%s" % (effID, effType, classLV, classStarLVDict))
        if classLV not in classStarLVDict:
            return
        totalStarLV = classStarLVDict[classLV]
        addAttrValue = int(totalStarLV / effCond2 * effAttrValue)
        #GameWorld.DebugLog("        effCond=%s,effCond2=%s,totalStarLV=%s,attrID=%s,addAttrValue=%s" % (effCond, effCond2, totalStarLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #29    x½××°±¸Ï´Á·Ã¿x¼¶+xxÊôÐÔ                x½×        x¼¶
    elif effType == 29:
        customAttrDictWash = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Wash)[2]
        classWashLVDict = customAttrDictWash.get("classWashLVDict", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classWashLVDict=%s" % (effID, effType, classLV, classWashLVDict))
        if classLV not in classWashLVDict:
            return
        totalWashLV = classWashLVDict[classLV]
        addAttrValue = int(totalWashLV / effCond2 * effAttrValue)
        #GameWorld.DebugLog("        effCond=%s,effCond2=%s,totalWashLV=%s,attrID=%s,addAttrValue=%s" % (effCond, effCond2, totalWashLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #30    x½××°±¸¸½Ä§Ã¿x¼¶+xxÊôÐÔ                x½×        x¼¶
    elif effType == 30:
        customAttrDictEnchant = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Enchant)[2]
        classEnchantLVDict = customAttrDictEnchant.get("classEnchantLVDict", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classEnchantLVDict=%s" % (effID, effType, classLV, classEnchantLVDict))
        if classLV not in classEnchantLVDict:
            return
        totalEnchantLV = classEnchantLVDict[classLV]
        addAttrValue = int(totalEnchantLV / effCond2 * effAttrValue)
        #GameWorld.DebugLog("        effCond=%s,effCond2=%s,totalEnchantLV=%s,attrID=%s,addAttrValue=%s" % (effCond, effCond2, totalEnchantLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #31    x½××°±¸x¼þxÆ·ÖÊ×°±¸+xxÊôÐÔ            x½×        x¼þ        xÆ·ÖÊ
    elif effType == 31:
        customAttrDictEquip = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Equip)[2]
        classEquipColorDict = customAttrDictEquip.get("classEquipColorDict", {})
        classLV = effCond
        #GameWorld.DebugLog("    effID=%s,effType=%s,classLV=%s,classEquipColorDict=%s" % (effID, effType, classLV, classEquipColorDict))
        if classLV not in classEquipColorDict:
            return
        equipColorDict = classEquipColorDict[classLV]
        equipColorCnt = 0
        for itemColor in equipColorDict.values():
            if itemColor >= effCond3:
                equipColorCnt += 1
        addAttrValue = int(equipColorCnt / effCond2 * effAttrValue)
        #GameWorld.DebugLog("        effCond=%s,effCond2=%s,effCond3=%s,equipColorCnt=%s,attrID=%s,addAttrValue=%s" % (effCond, effCond2, effCond3, equipColorCnt, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #32    »ñµÃxµãÁé¸ùµã+xxÊôÐÔ                        xµã
    elif effType == 32:
        totalLingGenPoint = PlayerControl.GetTotalLingGenPoint(curPlayer)
        addAttrValue = int(totalLingGenPoint / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,totalLingGenPoint=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, totalLingGenPoint, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #41    xÀàÐÍÉñ±øÿX¼¶+XÊôÐÔ    xÀàÐÍ    x¼¶
    elif effType == 41:
        gwType = effCond
        gwLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GodWeaponLV % gwType)
        addAttrValue = int(gwLV / effCond2 * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,gwType=%s,gwLV=%s,effCond2=%s,attrID=%s,addAttrValue=%s" % (effID, effType, gwType, gwLV, effCond2, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
        
    #42    ·¨Æ÷ÿX½×+X%·¨Æ÷×ÜÊôÐÔ    x½×
    elif effType == 42:
        customAttrDictFaQi = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_FaQi)[2]
        faQiAllAttrInfo = customAttrDictFaQi.get("faQiAllAttrInfo", {})
        faQiLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FaQiLV)
        addPer = int(faQiLV / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,faQiLV=%s,addPer=%s,faQiAllAttrInfo=%s" % (effID, effType, faQiLV, addPer, faQiAllAttrInfo))
        __addStarEffFuncAttr(ipyData, effAttrInfo, faQiAllAttrInfo, addPer)
            
    #43    ÿӵÓÐX¸öXÀàÐ͵ijƺÅ+XÊôÐÔ    xÀàÐÍ    x¸ö
    elif effType == 43:
        activeTypeCountDict = PlayerDienstgrad.GetDienstgradActiveTypeCountInfo(curPlayer)
        dType = effCond
        activeCount = activeTypeCountDict.get(dType, 0)
        addAttrValue = int(activeCount / effCond2 * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,dType=%s,activeTypeCountDict=%s,effCond2=%s,attrID=%s,addAttrValue=%s" % (effID, effType, dType, activeTypeCountDict, effCond2, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
            
    #44    XÆ·ÖÊʱװ×ÜÐÇÊýÿXÐÇ+XÊôÐÔ    xÀàÐÍ    xÐÇ
    elif effType == 44:
        costQualityLVDict = PlayerCoat.GetCoatQualityLVInfo(curPlayer)
        quality = effCond
        lvTotal = costQualityLVDict.get(quality, 0)
        addAttrValue = int(lvTotal / effCond2 * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,quality=%s,costQualityLVDict=%s,effCond2=%s,attrID=%s,addAttrValue=%s" % (effID, effType, quality, costQualityLVDict, effCond2, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #45    ÿX¼¶÷ÈÁ¦µÈ¼¶+XÊôÐÔ    x¼¶
    elif effType == 45:
        charmLV = PlayerControl.GetCharmLV(curPlayer)
        addAttrValue = int(charmLV / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,charmLV=%s,effCond=%s,attrID=%s,addAttrValue=%s" % (effID, effType, charmLV, effCond, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #46    ÿӵÓÐX¸öÉñͨ¼¼ÄÜ+XÊôÐÔ    x¸ö
    elif effType == 46:
        customAttrDictShentong = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Shentong)[2]
        shentongSkillInfo = customAttrDictShentong.get("shentongSkillInfo", {})
        skillCount = len(shentongSkillInfo)
        addAttrValue = int(skillCount / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,skillCount=%s,effCond=%s,attrID=%s,addAttrValue=%s,shentongSkillInfo=%s" % (effID, effType, skillCount, effCond, attrID, addAttrValue, shentongSkillInfo))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #47    Éñͨ¼¼ÄÜ×ܵȼ¶Ã¿X¼¶+XÊôÐÔ    x¼¶
    elif effType == 47:
        customAttrDictShentong = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Shentong)[2]
        shentongSkillInfo = customAttrDictShentong.get("shentongSkillInfo", {})
        skillLVTotal = sum(shentongSkillInfo.values())
        addAttrValue = int(skillLVTotal / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,skillLVTotal=%s,effCond=%s,attrID=%s,addAttrValue=%s,shentongSkillInfo=%s" % (effID, effType, skillLVTotal, effCond, attrID, addAttrValue, shentongSkillInfo))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #48    ²ÎÓëÏÉÃËÁªÈüÿX´Î+XXXÊôÐÔ    x´Î
    #49    ²ÎÓëÉϹÅÕ½³¡Ã¿X´Î+XXXÊôÐÔ    x´Î
    #50    ²ÎÓë¹ÅÉñÕ½³¡Ã¿X´Î+XXXÊôÐÔ    x´Î
    #51    ²ÎÓëħÍõÈëÇÖÿX´Î+XXXÊôÐÔ    x´Î
    #52    ²ÎÓëÖð¹Íò½çÿX´Î+XXXÊôÐÔ    x´Î
    elif effType in GubaoEffAttrIypeList:
        effValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoItemEffValue % (gubaoID, effType))
        addAttrValue = int(effValue / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effValue=%s,effCond=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effValue, effCond, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #53    ÏâǶxÆ·Öʾۻêÿx¸ö+xxÊôÐÔ    xÆ·ÖÊ    x¸ö
    elif effType == 53:
        soulColor = effCond
        colorCount = PlayerGatherTheSoul.GetHoleSoulColorCount(curPlayer, soulColor, True)
        addAttrValue = int(colorCount / effCond2 * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,soulColor=%s,colorCount=%s,effCond2=%s,attrID=%s,addAttrValue=%s" % (effID, effType, soulColor, colorCount, effCond2, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #57    ×øÆï»ù´¡ÊôÐÔÌáÉýx%
    elif effType == 57:
        customAttrDict = PlayerControl.GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Horse)[2]
        horseBaseAttrInfo = customAttrDict.get("horseBaseAttrInfo", {})
        #GameWorld.DebugLog("    effID=%s,effType=%s,horseBaseAttrInfo=%s,effAttrInfo=%s" % (effID, effType, horseBaseAttrInfo, effAttrInfo))
        __addStarEffFuncAttr(ipyData, effAttrInfo, horseBaseAttrInfo, effAttrValue)
       
    #58    ×øÆïÿx¼¶+xxÊôÐÔ                   x¼¶
    elif effType == 58:
        horseLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserLV)
        addAttrValue = int(horseLV / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,horseLV=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, horseLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    #59    ·¨Æ÷ÿX½×+xxÊôÐÔ    x½×
    elif effType == 59:
        faQiLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FaQiLV)
        addAttrValue = int(faQiLV / effCond * effAttrValue)
        #GameWorld.DebugLog("    effID=%s,effType=%s,effCond=%s,faQiLV=%s,attrID=%s,addAttrValue=%s" % (effID, effType, effCond, faQiLV, attrID, addAttrValue))
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
            
    return

def __addStarEffFuncAttr(ipyData, effAttrInfo, funcAttrInfo, effAttrValue):
    if not funcAttrInfo or effAttrValue <= 0:
        return
    isPer = ipyData.GetIsPer()
    effAttrIDList = ipyData.GetEffFuncAttrIDList() # ÌáÉýÖ¸¶¨¹¦ÄÜÊôÐÔIDÁбí
    for attrID, attrValue in funcAttrInfo.items():
        if effAttrIDList and attrID not in effAttrIDList:
            continue
        if isPer:
            addAttrValue = int(attrValue * effAttrValue / 100.0)
        else:
            addAttrValue = effAttrValue
        if attrID > 0 and addAttrValue > 0:
            effAttrInfo[attrID] = effAttrInfo.get(attrID, 0) + addAttrValue
    return

def AddGubaoItemEffValue(curPlayer, effType, addCnt):
    if effType not in GubaoEffTtemIypeList and effType not in GubaoEffAttrIypeList:
        return
    isAttr = False
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in xrange(ipyDataMgr.GetGubaoCount()):
        ipyData = ipyDataMgr.GetGubaoByIndex(index)
        gubaoID = ipyData.GetGubaoID()
        _, star = GetGubaoLVInfo(curPlayer, gubaoID)
        if not star:
            continue
        starIpyData = IpyGameDataPY.GetIpyGameData("GubaoStar", gubaoID, star)
        if not starIpyData:
            continue
        starEffIDList = starIpyData.GetStarEffIDList()
        for effID in starEffIDList:
            effIpyData = IpyGameDataPY.GetIpyGameData("GubaoEffAttr", effID)
            if not effIpyData:
                continue
            if effType != effIpyData.GetGubaoEffType():
                continue
            effValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoItemEffValue % (gubaoID, effType))
            updValue = min(effValue + addCnt, ChConfig.Def_UpperLimit_DWord)
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GubaoItemEffValue % (gubaoID, effType), updValue)
            GameWorld.DebugLog("¸üйű¦ÎïƷЧ¹ûÀàÐͽø¶ÈÖµ: gubaoID=%s,effID=%s,effType=%s,effValue=%s,addCnt=%s,updValue=%s" 
                               % (gubaoID, effID, effType, effValue, addCnt, updValue), curPlayer.GetPlayerID())
            Sync_GubaoItemEffInfo(curPlayer, gubaoID, effType, True)
            if effType in GubaoEffAttrIypeList:
                isAttr = True
                
    if isAttr:
        RefreshGubaoAttr(curPlayer)
    return

def GetGubaoItemEffAward(curPlayer, gubaoID, effIDStr):
    _, star = GetGubaoLVInfo(curPlayer, gubaoID)
    if not star:
        #GameWorld.DebugLog("¹Å±¦ÎïƷЧ¹ûÁì½±! ûÓÐÐǼ¶! gubaoID=%s" % (gubaoID), curPlayer.GetPlayerID())
        return
    starIpyData = IpyGameDataPY.GetIpyGameData("GubaoStar", gubaoID, star)
    if not starIpyData:
        return
    starEffIDList = starIpyData.GetStarEffIDList()
    effID = GameWorld.ToIntDef(effIDStr)
    if not effID or effID not in starEffIDList:
        GameWorld.DebugLog("¹Å±¦ÎïƷЧ¹ûÁì½±! ¸ÃÐǼ¶²»´æÔÚ¸ÃЧ¹ûID! gubaoID=%s,star=%s,effID=%s" 
                           % (gubaoID, star, effID), curPlayer.GetPlayerID())
        return
    effIpyData = IpyGameDataPY.GetIpyGameData("GubaoEffAttr", effID)
    if not effIpyData:
        return
    effType = effIpyData.GetGubaoEffType()
    if effType not in GubaoEffTtemIypeList:
        GameWorld.DebugLog("¹Å±¦ÎïƷЧ¹ûÁì½±! ·ÇÎïƷЧ¹ûÀàÐÍ! gubaoID=%s,star=%s,effID=%s,effType=%s" 
                           % (gubaoID, star, effID, effType), curPlayer.GetPlayerID())
        return
    condValue = effIpyData.GetEffCond()
    awardItemList = effIpyData.GetEffItemAwardList()
    if not condValue or not awardItemList:
        return
    effValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoItemEffValue % (gubaoID, effType))
    getTimes = effValue / condValue
    if getTimes <= 0:
        GameWorld.DebugLog("¹Å±¦ÎïƷЧ¹ûÁì½±! δ´ïµ½Áì½±Ìõ¼þ! gubaoID=%s,star=%s,effID=%s,effType=%s,effValue=%s,condValue=%s" 
                           % (gubaoID, star, effID, effType, effValue, condValue), curPlayer.GetPlayerID())
        return
    awardItemTotalList = []
    if getTimes > 1:
        for itemID, itemCount, isAuctionItem in awardItemList:
            awardItemTotalList.append([itemID, int(itemCount * getTimes), isAuctionItem])
    else:
        awardItemTotalList = awardItemList
    updValue = effValue % condValue
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GubaoItemEffValue % (gubaoID, effType), updValue)
    Sync_GubaoItemEffInfo(curPlayer, gubaoID, effType, True)
    GameWorld.DebugLog("¹Å±¦ÎïƷЧ¹ûÁì½±: gubaoID=%s,star=%s,effID=%s,effType=%s,effValue=%s,condValue=%s,getTimes=%s,updValue=%s,awardItemTotalList=%s" 
                       % (gubaoID, star, effID, effType, effValue, condValue, getTimes, updValue, awardItemTotalList), curPlayer.GetPlayerID())
    ItemControler.GivePlayerItemOrMail(curPlayer, awardItemTotalList, event=["Gubao", False, {}])
    return

def Sync_GubaoInfo(curPlayer, gubaoIDList=None):
    if gubaoIDList == None:
        syncIDList = []
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        for index in range(ipyDataMgr.GetGubaoCount()):
            ipyData = ipyDataMgr.GetGubaoByIndex(index)
            syncIDList.append(ipyData.GetGubaoID())
    else:
        syncIDList = gubaoIDList
        
    gubaoInfoList = []
    for gubaoID in syncIDList:
        lv, star = GetGubaoLVInfo(curPlayer, gubaoID)
        if not lv and not star and gubaoIDList == None:
            # ûÓÐÖ¸¶¨Ê±Ö»Í¬²½¼¤»îµÄ
            continue
        gubao = ChPyNetSendPack.tagMCGubao()
        gubao.GubaoID = gubaoID
        gubao.GubaoLV = lv
        gubao.GubaoStar = star
        gubaoInfoList.append(gubao)
        
    if not gubaoInfoList:
        return
    
    clientPack = ChPyNetSendPack.tagMCGubaoInfo()
    clientPack.GubaoInfoList = gubaoInfoList
    clientPack.Count = len(clientPack.GubaoInfoList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return

def Sync_GubaoItemEffInfo(curPlayer, gubaoID=0, effType=0, force=False):
    syncIDList = []
    if not gubaoID:
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        for index in range(ipyDataMgr.GetGubaoCount()):
            ipyData = ipyDataMgr.GetGubaoByIndex(index)
            syncIDList.append(ipyData.GetGubaoID())
    else:
        syncIDList = [gubaoID]
        
    syncEffTypeList = [effType] if effType else NeedGubaoItemEffValueTypeList
    
    itemEffInfoList = []
    for gubaoID in syncIDList:
        for effType in syncEffTypeList:
            effValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoItemEffValue % (gubaoID, effType))
            if not effValue and not force:
                # ·ÇÇ¿ÖÆͬ²½Çé¿öÏÂֻͬ²½ÓÐÖµµÄ
                continue
            eff = ChPyNetSendPack.tagMCGubaoItemEff()
            eff.GubaoID = gubaoID
            eff.EffType = effType
            eff.EffValue = effValue
            itemEffInfoList.append(eff)
            
    if not itemEffInfoList:
        return
    
    clientPack = ChPyNetSendPack.tagMCGubaoItemEffInfo()
    clientPack.ItemEffInfoList = itemEffInfoList
    clientPack.Count = len(clientPack.ItemEffInfoList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return

def Sync_GubaoPieceInfo(curPlayer, gubaoIDList=None):
    if gubaoIDList == None:
        syncIDList = []
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        for index in range(ipyDataMgr.GetGubaoCount()):
            ipyData = ipyDataMgr.GetGubaoByIndex(index)
            syncIDList.append(ipyData.GetGubaoID())
    else:
        syncIDList = gubaoIDList
        
    pieceInfoList = []
    for gubaoID in syncIDList:
        curCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GubaoPiece % gubaoID)
        if not curCount and gubaoIDList == None:
            # ûÓÐÖ¸¶¨Ê±Ö»Í¬²½ÓÐÊýÁ¿µÄ
            continue
        gubao = ChPyNetSendPack.tagMCGubaoPiece()
        gubao.GubaoID = gubaoID
        gubao.PieceCount = curCount
        pieceInfoList.append(gubao)
        
    if not pieceInfoList:
        return
    
    clientPack = ChPyNetSendPack.tagMCGubaoPieceInfo()
    clientPack.PieceInfoList = pieceInfoList
    clientPack.Count = len(clientPack.PieceInfoList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return