#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Player.PlayerHero
#
# @todo:Î佫ӢÐÛ
# @author hxp
# @date 2025-06-11
# @version 1.0
#
# ÏêϸÃèÊö: Î佫ӢÐÛ
#
#-------------------------------------------------------------------------------
#"""Version = 2025-06-11 11:00"""
#-------------------------------------------------------------------------------

import ItemCommon
import ShareDefine
import IpyGameDataPY
import IPY_GameWorld
import ItemControler
import ChPyNetSendPack
import NetPackCommon
import PlayerControl
import GameWorld
import ChConfig

import random

def OnPlayerLogin(curPlayer):
    Sync_HeroInfo(curPlayer)
    return

def InitHeroItem(singleItem):
    ## Î佫¿¨ÅƳõʼ»¯£º³õʼµÈ¼¶1£» ÐǼ¶¡¢Í»ÆƵȼ¶¡¢¾õÐѵȼ¶¾ùΪ0
    singleItem.SetUserAttr(ShareDefine.Def_IudetHeroLV, 1)
    if singleItem.GetUserAttr(ShareDefine.Def_IudetHeroStar):
        singleItem.SetUserAttr(ShareDefine.Def_IudetHeroStar, 0)
    if singleItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV):
        singleItem.SetUserAttr(ShareDefine.Def_IudetHeroBreakLV, 0)
    if singleItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV):
        singleItem.SetUserAttr(ShareDefine.Def_IudetHeroAwakeLV, 0)
    if singleItem.GetUserAttr(ShareDefine.Def_IudetHeroSkin):
        singleItem.SetUserAttr(ShareDefine.Def_IudetHeroSkin, 0)
    if singleItem.GetUserAttr(ShareDefine.Def_IudetHeroPosNum):
        singleItem.SetUserAttr(ShareDefine.Def_IudetHeroPosNum, 0)
        
    if singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID):
        singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentID)
    if singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDLV):
        singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDLV)
    if singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentWashLock):
        singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashLock)
    if singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentWashID):
        singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashID)
    if singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDAwakeRand):
        singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
        
    InitHeroTalent(singleItem)
    return

def InitHeroTalent(singleItem):
    '''³õʼ»¯²ÛλÌ츳£¬²»Í¬²ÛλÌ츳ID²»ÄÜÒ»Ñù
    '''
    heroID = singleItem.GetItemTypeID()
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return
    quality = heroIpyData.GetQuality()
    qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
    if not qualityIpyData:
        return
    
    initTalentCnt = 1
    initTalentWeight = qualityIpyData.GetInitTalentWeight() # ³õʼÌ츳ÊýȨÖØ
    if initTalentWeight:
        initTalentCnt = GameWorld.GetResultByWeightList(initTalentWeight, 1)
        
    talentIDDict = {}
    talentWeightList = []
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in range(ipyDataMgr.GetHeroTalentCount()):
        talentIpyData = ipyDataMgr.GetHeroTalentByIndex(index)
        talentID = talentIpyData.GetTalentID()
        initWeight = talentIpyData.GetInitWeight()
        talentWeightList.append([initWeight, talentID])
        talentIDDict[talentID] = initWeight
        
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentID)
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDLV)
    for _ in range(initTalentCnt):
        randTalentID = GameWorld.GetResultByWeightList(talentWeightList)
        if not randTalentID:
            continue
        
        # ÒƳýÈ·±£²»Öظ´
        randWeightID = [talentIDDict.get(randTalentID, 0), randTalentID]
        if randWeightID in talentWeightList:
            talentWeightList.remove(randWeightID)
            
        singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentID, randTalentID)
        singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentIDLV, 1)
        
    return

def OnGiveHeroItem(curPlayer, heroItem):
    ## »ñµÃij¸öÎ佫
    heroID = heroItem.GetItemTypeID()
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return
    
    if not GetHeroActivite(curPlayer, heroID):
        SetHeroActivite(curPlayer, heroID, 1)
        GameWorld.DebugLog("Ê״줻îÎ佫: heroID=%s" % (heroID), curPlayer.GetPlayerID())
        #Ê״λñµÃͼ¼ø¶îÍâÂß¼­ ...
        Sync_HeroInfo(curPlayer, [heroID])
        
    return

def GetHeroActivite(curPlayer, heroID):
    ## Î佫״̬
    # @return: 0-δ¼¤»î£»1-Î佫ÒÑ»ñµÃ,¿É¼¤»î£»2-ͼ¼øÒѼ¤»î
    actState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID) % 10
    return actState

def SetHeroActivite(curPlayer, heroID, isAct=1):
    ## ÉèÖÃÎ佫ÒÑ»ñµÃ£¬¿É¼¤»î״̬
    bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
    actState = bookState % 10
    if isAct:
        if actState:
            return
        actState = 1
    else:
        actState = 0
    updBookState = GameWorld.SetValue(bookState, 1, 1, actState)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroBook % heroID, updBookState)
    GameWorld.DebugLog("ÉèÖÃÎ佫¼¤»î״̬:%s,bookState=%s,updBookState=%s" % (isAct, bookState, updBookState), curPlayer.GetPlayerID())
    return

def GetHeroBookInitState(curPlayer, heroID):
    ## Î佫ͼ¼ø¼¤»î״̬
    initState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID) % 10
    return initState > 1
def SetHeroBookInitState(curPlayer, heroID, isAct=1):
    ## ÉèÖÃÎ佫ͼ¼ø¼¤»î״̬
    bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
    actState = bookState % 10
    if isAct:
        actState = 2
    else:
        actState = 1 if actState else 0
    updBookState = GameWorld.SetValue(bookState, 1, 1, actState)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroBook % heroID, updBookState)
    GameWorld.DebugLog("ÉèÖÃÎ佫ͼ¼ø¼¤»î״̬:%s,bookState=%s,updBookState=%s" % (isAct, bookState, updBookState), curPlayer.GetPlayerID())
    return

def GetHeroBookStarLV(curPlayer, heroID):
    ## Î佫ͼ¼øÐǼ¶µÈ¼¶
    bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
    return GameWorld.GetValue(bookState, 4, 3)
def SetHeroBookStarLV(curPlayer, heroID, starLV):
    ## ÉèÖÃÎ佫ͼ¼øÐǼ¶µÈ¼¶£¬Ö§³ÖÈýλÊý 0~999 ¼¶
    bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
    updBookState = GameWorld.SetValue(bookState, 4, 3, starLV)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroBook % heroID, updBookState)
    GameWorld.DebugLog("ÉèÖÃÎ佫ͼ¼øÐǼ¶µÈ¼¶:%s,bookState=%s,updBookState=%s" % (starLV, bookState, updBookState), curPlayer.GetPlayerID())
    return

def GetHeroBookBreakLV(curPlayer, heroID):
    ## Î佫ͼ¼øÍ»ÆƵȼ¶
    bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
    return GameWorld.GetValue(bookState, 7, 3)
def SetHeroBookBreakLV(curPlayer, heroID, breakLV):
    ## ÉèÖÃÎ佫ͼ¼øÍ»ÆƵȼ¶£¬Ö§³ÖÈýλÊý 0~999 ¼¶
    bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
    updBookState = GameWorld.SetValue(bookState, 7, 3, breakLV)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroBook % heroID, updBookState)
    GameWorld.DebugLog("ÉèÖÃÎ佫ͼ¼øÍ»ÆƵȼ¶:%s,bookState=%s,updBookState=%s" % (breakLV, bookState, updBookState), curPlayer.GetPlayerID())
    return

def GetHeroItem(curPlayer, itemIndex):
    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
    if itemIndex < 0 or itemIndex >= curPack.GetCount():
        return
    heroItem = curPack.GetAt(itemIndex)
    if not heroItem or heroItem.IsEmpty():
        return
    if heroItem.GetType() != ChConfig.Def_ItemType_Hero:
        return
    return heroItem

#// B2 30 Î佫Éý¼¶ #tagCSHeroLVUP
#
#struct    tagCSHeroLVUP
#{
#    tagHead        Head;
#    WORD        ItemIndex;    //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
#};
def OnHeroLVUP(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    itemIndex = clientData.ItemIndex
    heroItem = GetHeroItem(curPlayer, itemIndex)
    if not heroItem:
        return
    heroID = heroItem.GetItemTypeID()
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return
    quality = heroIpyData.GetQuality()
    breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
    heroLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroLV)
    LVMax = GetHeroLVMax(heroItem)
    GameWorld.DebugLog("ÇëÇóÎ佫Éý¼¶: itemIndex=%s,heroID=%s,heroLV=%s,quality=%s,breakLV=%s,LVMax=%s" 
                       % (itemIndex, heroID, heroLV, quality, breakLV, LVMax), playerID)
    if heroLV >= LVMax:
        GameWorld.DebugLog("¸ÃÎ佫ÒÑÂú¼¶£¡LVMax=%s" % (LVMax), playerID)
        return
    qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
    if not qualityIpyData:
        return
    costItemInfo = qualityIpyData.GetUPCostItem()
    if not costItemInfo:
        return
    costItemID, costItemCount = costItemInfo
    if not costItemID or not costItemCount:
        return
    itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
    hasEnough, itemIndexList = ItemCommon.GetItem_FromPack_ByID(costItemID, itemPack, costItemCount)
    if not hasEnough:
        GameWorld.DebugLog("²ÄÁϲ»×㣬Î佫ÎÞ·¨Éý¼¶! costItemID=%s, costItemCount=%s" % (costItemID, costItemCount))
        return
    ItemCommon.ReduceItem(curPlayer, itemPack, itemIndexList, costItemCount, True, "HeroLVUP")
    
    updHeroLV = heroLV + 1
    GameWorld.DebugLog("Î佫Éý¼¶: itemIndex=%s,heroID=%s,updHeroLV=%s" % (itemIndex, heroID, updHeroLV), playerID)
    heroItem.SetUserAttr(ShareDefine.Def_IudetHeroLV, updHeroLV)
    
    # Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
    
    return

def GetHeroLVMax(heroItem):
    ## »ñÈ¡Î佫µ±Ç°×î´óµÈ¼¶
    heroID = heroItem.GetItemTypeID()
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return 0
    quality = heroIpyData.GetQuality()
    breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
    qualityBreakIpyData = IpyGameDataPY.GetIpyGameData("HeroQualityBreak", quality, breakLV)
    if not qualityBreakIpyData:
        return 0
    LVMax = qualityBreakIpyData.GetLVMax()
    return LVMax

#// B2 31 Î佫ÉýÐÇ #tagCSHeroStarUP
#
#struct    tagCSHeroStarUP
#{
#    tagHead        Head;
#    WORD        ItemIndex;    //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
#    WORD        UseItemIndex;    //ʹÓÃÎ佫²ÄÁÏÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
#};
def OnHeroStarUP(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    itemIndex = clientData.ItemIndex
    useItemIndex = clientData.UseItemIndex
    heroItem = GetHeroItem(curPlayer, itemIndex)
    useItem = GetHeroItem(curPlayer, useItemIndex)
    if not heroItem or not useItem or itemIndex == useItemIndex:
        return
    heroID = heroItem.GetItemTypeID()
    useHeroID = useItem.GetItemTypeID()
    GameWorld.DebugLog("ÇëÇóÎ佫ÉýÐÇ: itemIndex=%s,heroID=%s,useItemIndex=%s,useHeroID=%s" 
                       % (itemIndex, heroID, useItemIndex, useHeroID), playerID)
    if heroID != useHeroID:
        GameWorld.DebugLog("Î佫²ÄÁϷDZ¾Ì壬ÎÞ·¨ÉýÐÇ!", playerID)
        return
    washIDCnt = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentWashID)
    if washIDCnt:
        GameWorld.ErrLog("Î佫ϴÁ¶½á¹ûδ´¦Àí£¬ÎÞ·¨ÉýÐÇ! itemIndex=%s,heroID=%s" % (itemIndex, heroID), playerID)
        return
    awakeRandCnt = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
    if awakeRandCnt:
        GameWorld.ErrLog("Î佫¾õÐѽâËøÌ츳δѡÔñ£¬ÎÞ·¨ÉýÐÇ! itemIndex=%s,heroID=%s" % (itemIndex, heroID), playerID)
        return
    useBreakLV = useItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
    useAwakeLV = useItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
    if useBreakLV or useAwakeLV:
        GameWorld.DebugLog("²ÄÁÏ¿¨Í»ÆÆ»ò¾õÐѵȼ¶²»Îª0ÔÝʱÎÞ·¨ÉýÐÇ£¡useBreakLV=%s,useAwakeLV=%s" % (useBreakLV, useAwakeLV), playerID)
        return
    
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return
    quality = heroIpyData.GetQuality()
    star = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
    awakeLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
    starMax = GetHeroStarMax(heroItem)
    GameWorld.DebugLog("heroID=%s,star=%s,quality=%s,awakeLV=%s,starMax=%s" % (heroID, star, quality, awakeLV, starMax), playerID)
    if star >= starMax:
        GameWorld.DebugLog("¸ÃÎ佫ÒÑÂúÐÇ£¡starMax=%s" % (starMax), playerID)
        return
    useStar = useItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
    addStar = useStar + 1
    updStar = star + addStar
    GameWorld.DebugLog("Î佫ÉýÐÇ: itemIndex=%s,heroID=%s,star=%s,useStar=%s,addStar=%s,updStar=%s" 
                       % (itemIndex, heroID, star, useStar, addStar, updStar), playerID)
    ItemCommon.DelItem(curPlayer, useItem, useItem.GetCount(), False, "HeroStarUP")
    DoHeroUpdStar(curPlayer, heroItem, updStar)
    return

def GetHeroStarMax(heroItem):
    ## »ñÈ¡Î佫µ±Ç°×î´óÐǼ¶
    heroID = heroItem.GetItemTypeID()
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return 0
    quality = heroIpyData.GetQuality()
    qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
    if not qualityIpyData:
        return 0
    InitStarUpper = qualityIpyData.GetInitStarUpper()
    
    addStarUpper = 0
    heroAwakeIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroAwake", heroID)
    if heroAwakeIpyDataList:
        awakeLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
        for ipyData in heroAwakeIpyDataList:
            if ipyData.GetAwakeLV() > awakeLV:
                break
            #ipyData.GetUnlockTalentSlot()
            addStarUpper += ipyData.GetAddStarUpper()
            
    starMax = InitStarUpper + addStarUpper
    return starMax

def DoHeroUpdStar(curPlayer, heroItem, updStar):
    ## Ö´ÐÐÎ佫ÐǼ¶¸üÐÂ
    curStar = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
    addStar = updStar - curStar
    item = heroItem.GetItem()
    item.SetUserAttr(ShareDefine.Def_IudetHeroStar, updStar)
    if addStar > 0:
        __DoHeroStarTalentUp(item, addStar)
    heroItem.Sync_Item()
    
    # Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
    
    return

def __DoHeroStarTalentUp(singleItem, addLV):
    ## Ö´ÐÐÎ佫ÐǼ¶Ì츳µÈ¼¶ÌáÉý
    
    commTalentSlot = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 1) # ³£¹æÌ츳²Û¸öÊý
    talentMaxLV = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 2) # ÿ¸öÌ츳×î´óµÈ¼¶
    idCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
    lvCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDLV)
    idList, lvList = [], [] # ¼Ç¼ÔÚÎïÆ·ÉϵÄÖµ£¬ÓÐ˳Ðò
    unfullLVIDList = [] # δÂú¼¶µÄÌ츳ID
    haveUp = False
    for index in range(min(idCount, lvCount)):
        talentID = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentID, index)
        talentLV = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentIDLV, index)
        idList.append(talentID)
        lvList.append(talentLV)
        if talentLV < talentMaxLV:
            unfullLVIDList.append(talentID)
            
    if len(idList) < commTalentSlot:
        idList += [0] * (commTalentSlot - len(idList))
        lvList += [0] * (commTalentSlot - len(lvList))
        
    GameWorld.DebugLog("Ö´ÐÐÎ佫ÐǼ¶Ì츳µÈ¼¶ÌáÉý: addLV=%s" % addLV)
    GameWorld.DebugLog("µ±Ç°ÐǼ¶Ì츳: idList=%s,lvList=%s" % (idList, lvList))
    GameWorld.DebugLog("δÂú¼¶ÐǼ¶Ì츳ID: %s" % unfullLVIDList)
    
    # ÓпÕÓà²Û룬ÓÅÏȸø¿ÕÓà²ÛλÌ츳£¬¶îÍâ½âËøµÄ²ÛλÊÇÐèÒªÏÈÑ¡ÔñµÄ£¬ËùÒÔÒ»¶¨²»Îª¿Õ£¬¹ÊÕâÀïÖ»Åжϳ£¹æ²Ûλ¼´¿É
    if 0 in idList:
        idWeightDict = {}
        talentWeightList = []
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        for index in range(ipyDataMgr.GetHeroTalentCount()):
            talentIpyData = ipyDataMgr.GetHeroTalentByIndex(index)
            talentID = talentIpyData.GetTalentID()
            if talentID in idList:
                # Ì츳ID²»¿ÉÖظ´
                continue
            weight = talentIpyData.GetWashWeight()
            talentWeightList.append([weight, talentID])
            idWeightDict[talentID] = weight
            
        GameWorld.DebugLog("³£¹æ¿Õ²ÛλÔö¼ÓÌ츳Êý£º%s" % addLV)
        for _ in range(addLV):
            if 0 not in idList:
                break
            randTalentID = GameWorld.GetResultByWeightList(talentWeightList)
            if not randTalentID:
                continue
            # ÒƳýÈ·±£²»Öظ´
            randWeightID = [idWeightDict.get(randTalentID, 0), randTalentID]
            if randWeightID in talentWeightList:
                talentWeightList.remove(randWeightID)
            zeroIndex = idList.index(0)
            idList[zeroIndex] = randTalentID
            lvList[zeroIndex] = 1
            unfullLVIDList.append(randTalentID)
            GameWorld.DebugLog("ÐÂÔöÐǼ¶Ì츳ID: %s" % (randTalentID))
            addLV -= 1
            haveUp = True
            
    # ʣϵĵȼ¶´ÎÊý¶ÔÒÑÓÐÌ츳½øÐÐÉý¼¶
    if addLV > 0:
        for _ in range(addLV):
            if not unfullLVIDList:
                break
            randID = random.choice(unfullLVIDList)
            if randID not in idList:
                unfullLVIDList.remove(randID)
                continue
            randIndex = idList.index(randID)
            idLV = lvList[randIndex]
            
            if idLV < talentMaxLV:
                idLV += 1
                lvList[randIndex] = idLV
                GameWorld.DebugLog("Éý¼¶ÐǼ¶Ì츳ID: %s,idLV=%s,index=%s" % (randID, idLV, randIndex))
                
            if idLV >= talentMaxLV:
                unfullLVIDList.remove(randID)
                GameWorld.DebugLog("    ÒƳýδÂú¼¶ID: %s,unfullLVIDList=%s" % (randID, unfullLVIDList))
                
            haveUp = True
            
    if not haveUp:
        return
    GameWorld.DebugLog("¸üÐÂÐǼ¶Ì츳: idList=%s,lvList=%s" % (idList, lvList))
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentID)
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDLV)
    for index, talentID in enumerate(idList):
        if not talentID:
            break
        singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentID, talentID)
        singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentIDLV, lvList[index])
    return

#// B2 32 Î佫ͻÆÆ #tagCSHeroBreak
#
#struct    tagCSHeroBreak
#{
#    tagHead        Head;
#    WORD        ItemIndex;    //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
#};
def OnHeroBreak(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    itemIndex = clientData.ItemIndex
    heroItem = GetHeroItem(curPlayer, itemIndex)
    if not heroItem:
        return
    heroID = heroItem.GetItemTypeID()
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return
    quality = heroIpyData.GetQuality()
    breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
    GameWorld.DebugLog("ÇëÇóÎ佫ͻÆÆ: itemIndex=%s,heroID=%s,quality=%s,breakLV=%s" 
                       % (itemIndex, heroID, quality, breakLV), playerID)
    ipyData = IpyGameDataPY.GetIpyGameData("HeroQualityBreak", quality, breakLV)
    if not ipyData:
        return
    nextBreakLV = breakLV + 1
    if not IpyGameDataPY.GetIpyGameData("HeroQualityBreak", quality, nextBreakLV):
        GameWorld.DebugLog("Í»ÆƵȼ¶ÒÑÂú¼¶: quality=%s,breakLV=%s" % (quality, breakLV), playerID)
        return
    costItemInfo = ipyData.GetUPCostItem()
    if not costItemInfo:
        return
    costItemID, costItemCount = costItemInfo
    if not costItemID or not costItemCount:
        return
    itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
    hasEnough, itemIndexList = ItemCommon.GetItem_FromPack_ByID(costItemID, itemPack, costItemCount)
    if not hasEnough:
        GameWorld.DebugLog("²ÄÁϲ»×㣬Î佫ÎÞ·¨Í»ÆÆ! costItemID=%s, costItemCount=%s" % (costItemID, costItemCount))
        return
    ItemCommon.ReduceItem(curPlayer, itemPack, itemIndexList, costItemCount, True, "HeroBreak")
    GameWorld.DebugLog("Î佫ͻÆÆ: itemIndex=%s,heroID=%s,nextBreakLV=%s" % (itemIndex, heroID, nextBreakLV), playerID)
    SetHeroBreakLV(heroItem, nextBreakLV)
    
    # Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
    
    return

def SetHeroBreakLV(heroItem, breakLV):
    ## ÉèÖÃÎ佫ͻÆƵȼ¶
    heroItem.SetUserAttr(ShareDefine.Def_IudetHeroBreakLV, breakLV)
    return

#// B2 33 Î佫¾õÐÑ #tagCSHeroAwake
#
#struct    tagCSHeroAwake
#{
#    tagHead        Head;
#    WORD        ItemIndex;    //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
#};
def OnHeroAwake(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    itemIndex = clientData.ItemIndex
    heroItem = GetHeroItem(curPlayer, itemIndex)
    if not heroItem:
        return
    heroID = heroItem.GetItemTypeID()
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return
    quality = heroIpyData.GetQuality()
    starLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
    awakeLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
    GameWorld.DebugLog("ÇëÇóÎ佫¾õÐÑ: itemIndex=%s,heroID=%s,quality=%s,awakeLV=%s,starLV=%s" 
                       % (itemIndex, heroID, quality, awakeLV, starLV), playerID)
    awakeLimitStar = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 4)
    commTalentSlot = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 1) # ³£¹æÌ츳²Û¸öÊý
    if starLV < awakeLimitStar or starLV < commTalentSlot:
        GameWorld.DebugLog("µ±Ç°ÐǼ¶²»¿É¾õÐÑ: starLV=%s < %s, %s" % (starLV, awakeLimitStar, commTalentSlot), playerID)
        return
    ipyData = IpyGameDataPY.GetIpyGameData("HeroQualityAwake", quality, awakeLV)
    if not ipyData:
        return
    nextAwakeLV = awakeLV + 1
    if not IpyGameDataPY.GetIpyGameData("HeroQualityAwake", quality, nextAwakeLV):
        GameWorld.DebugLog("¾õÐѵȼ¶ÒÑÂú¼¶: quality=%s,awakeLV=%s" % (quality, awakeLV), playerID)
        return
    costItemInfo = ipyData.GetUPCostItem()
    if not costItemInfo:
        return
    costItemID, costItemCount = costItemInfo
    if not costItemID or not costItemCount:
        return
    itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
    hasEnough, itemIndexList = ItemCommon.GetItem_FromPack_ByID(costItemID, itemPack, costItemCount)
    if not hasEnough:
        GameWorld.DebugLog("²ÄÁϲ»×㣬Î佫ÎÞ·¨¾õÐÑ! costItemID=%s, costItemCount=%s" % (costItemID, costItemCount))
        return
    ItemCommon.ReduceItem(curPlayer, itemPack, itemIndexList, costItemCount, True, "HeroAwake")
    GameWorld.DebugLog("Î佫¾õÐÑ: itemIndex=%s,heroID=%s,nextBreakLV=%s" % (itemIndex, heroID, nextAwakeLV), playerID)
    SetHeroAwakeLV(heroItem, nextAwakeLV)
    
    # Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
    
    return

def SetHeroAwakeLV(heroItem, awakeLV):
    ## ÉèÖÃÎ佫¾õÐѵȼ¶
    item = heroItem.GetItem()
    item.SetUserAttr(ShareDefine.Def_IudetHeroAwakeLV, awakeLV)
    unlockTalentSlotByAwake(item)
    heroItem.Sync_Item()
    return

def unlockTalentSlotByAwake(singleItem):
    ## ¾õÐѽâËøÌ츳²Û
    heroID = singleItem.GetItemTypeID()
    awakeLV = singleItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
    awakeIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroAwake", heroID)
    if not awakeIpyDataList:
        return
    maxUnlockSlot = 0
    for ipyData in awakeIpyDataList[:awakeLV][::-1]: # µ¹Ðò±éÀú£¬µÚÒ»¸öÃüÖеľÍÊÇ×î´óµÄ
        unlockTalentSlot = ipyData.GetUnlockTalentSlot()
        if unlockTalentSlot:
            maxUnlockSlot = unlockTalentSlot
            break
    if not maxUnlockSlot:
        return
    idCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
    if idCount >= maxUnlockSlot:
        return
    commTalentSlot = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 1) # ³£¹æÌ츳²Û¸öÊý
    if maxUnlockSlot <= commTalentSlot:
        return
    awakeRandCnt = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
    if awakeRandCnt:
        # ÒѾ­´æÔÚ¾õÐÑÌ츳Ëæ»úÑ¡ÏÐèÒªÏÈÑ¡Ôñºó²ÅÄܼÌÐø
        return
    
    # Ëæ»ú¾õÐÑÌ츳ѡÏî
    idList = []
    for index in range(idCount):
        talentID = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentID, index)
        idList.append(talentID)
        
    GameWorld.DebugLog("¾õÐѽâËøÌ츳²Û: awakeLV=%s,maxUnlockSlot=%s,idList=%s" % (awakeLV, maxUnlockSlot, idList))
    
    idWeightDict = {}
    talentWeightList = []
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in range(ipyDataMgr.GetHeroTalentCount()):
        talentIpyData = ipyDataMgr.GetHeroTalentByIndex(index)
        talentID = talentIpyData.GetTalentID()
        if talentID in idList:
            # Ì츳ID²»¿ÉÖظ´
            continue
        weight = talentIpyData.GetAweakWeight()
        talentWeightList.append([weight, talentID])
        idWeightDict[talentID] = weight
        
    randTalentCnt = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 3)
    for _ in range(randTalentCnt):
        randTalentID = GameWorld.GetResultByWeightList(talentWeightList)
        if not randTalentID:
            continue
        # ÒƳýÈ·±£²»Öظ´
        randWeightID = [idWeightDict.get(randTalentID, 0), randTalentID]
        if randWeightID in talentWeightList:
            talentWeightList.remove(randWeightID)
        singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentIDAwakeRand, randTalentID)
        GameWorld.DebugLog("Ëæ»ú¾õÐÑÌ츳ѡÏî: randTalentID=%s" % (randTalentID))
        
    return

#// B2 34 Î佫¾õÐÑÑ¡ÔñÌ츳 #tagCSHeroAwakeSelectTalent
#
#struct    tagCSHeroAwakeSelectTalent
#{
#    tagHead        Head;
#    WORD        ItemIndex;    //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
#    BYTE        SelectIndex;    //Ñ¡ÔñнâËø²ÛλµÄÌ츳Ë÷Òý
#};
def OnHeroAwakeSelectTalent(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    itemIndex = clientData.ItemIndex
    selectIndex = clientData.SelectIndex
    heroItem = GetHeroItem(curPlayer, itemIndex)
    if not heroItem:
        return
    heroID = heroItem.GetItemTypeID()
    awakeRandCnt = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
    if not awakeRandCnt or selectIndex >= awakeRandCnt:
        GameWorld.DebugLog("²»´æÔڸþõÐÑÌ츳Ëæ»úÑ¡Ïî! heroID=%s,selectIndex=%s,awakeRandCnt=%s" % (heroID, selectIndex, awakeRandCnt), playerID)
        return
    selectTalentID = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentIDAwakeRand, selectIndex)
    if not selectTalentID:
        return
    
    singleItem = heroItem.GetItem()
    idCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
    lvCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDLV)
    idList, lvList = [], [] # ¼Ç¼ÔÚÎïÆ·ÉϵÄÖµ£¬ÓÐ˳Ðò
    for index in range(min(idCount, lvCount)):
        talentID = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentID, index)
        talentLV = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentIDLV, index)
        idList.append(talentID)
        lvList.append(talentLV)
        
    commTalentSlot = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 1) # ³£¹æÌ츳²Û¸öÊý
    if idCount < commTalentSlot:
        idList += [0] * (commTalentSlot - idCount)
        lvList += [0] * (commTalentSlot - idCount)
        
    if selectTalentID in idList:
        GameWorld.ErrLog("Ñ¡ÔñÌ츳ID²»ÄÜÖظ´! heroID=%s,selectIndex=%s,selectTalentID=%s in %s" 
                         % (heroID, selectIndex, selectTalentID, idList), playerID)
        return
    
    idList.append(selectTalentID)
    lvList.append(1)
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
    
    GameWorld.DebugLog("¸üÐÂÑ¡ÔñÌ츳: selectTalentID=%s,idList=%s,lvList=%s" % (selectTalentID, idList, lvList))
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentID)
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDLV)
    for index, talentID in enumerate(idList):
        singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentID, talentID)
        singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentIDLV, lvList[index])
            
    unlockTalentSlotByAwake(singleItem)
    
    heroItem.Sync_Item()
    
    # Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
    
    return

#// B2 35 Î佫ϴÁ¶ #tagCSHeroWash
#
#struct    tagCSHeroWash
#{
#    tagHead        Head;
#    WORD        ItemIndex;    //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
#    BYTE        LockCnt;
#    BYTE        LockTalentIndexs[LockCnt];    //Ëø¶¨Ì츳Ë÷ÒýÁбí
#    BYTE        OPType;    // ²Ù×÷ÀàÐÍ£º0-Ö´ÐÐÏ´Á¶£»1-Ìæ»»Ô­Ì츳£»2-±£ÁôÔ­Ì츳
#};
def OnHeroWash(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    itemIndex = clientData.ItemIndex
    lockTalentIndexs = clientData.LockTalentIndexs
    opType = clientData.OPType
    
    heroItem = GetHeroItem(curPlayer, itemIndex)
    if not heroItem:
        return
    
    if opType == 1:
        HeroTalentWashReplace(curPlayer, itemIndex, heroItem)
    elif opType == 2:
        heroItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashID)
    else:
        HeroTalentWash(curPlayer, itemIndex, heroItem, lockTalentIndexs)
        
    return

def HeroTalentWash(curPlayer, itemIndex, heroItem, lockTalentIndexs):
    ## Î佫ϴÁ¶
    
    heroID = heroItem.GetItemTypeID()
    GameWorld.DebugLog("Î佫ϴÁ¶: itemIndex=%s,heroID=%s,lockTalentIndexs=%s" % (itemIndex, heroID, lockTalentIndexs))
    washIDCnt = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentWashID)
    if washIDCnt:
        GameWorld.ErrLog("Î佫ϴÁ¶½á¹ûδ´¦Àí£¬ÎÞ·¨Ï´Á¶! washIDCnt=%s" % washIDCnt)
        return
    
    washCostItemInfo = IpyGameDataPY.GetFuncEvalCfg("HeroWash", 1)
    lockCostItemInfo = IpyGameDataPY.GetFuncEvalCfg("HeroWash", 2)
    if not washCostItemInfo or not lockCostItemInfo:
        return
    washItemID, washCostItemCount = washCostItemInfo
    lockItemID, lockCostItemCount = lockCostItemInfo
    
    itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
    hasEnough, washItemIndexList = ItemCommon.GetItem_FromPack_ByID(washItemID, itemPack, washCostItemCount)
    if not hasEnough:
        GameWorld.DebugLog("Ï´Á¶²ÄÁϲ»×㣬Î佫ÎÞ·¨Ï´Á¶! washItemID=%s,washCostItemCount=%s" % (washItemID, washCostItemCount))
        return
    lockItemIndexList = []
    lockCostItemCountTotal = 0
    if lockTalentIndexs:
        lockCostItemCountTotal = len(lockTalentIndexs) * lockCostItemCount
        hasEnough, lockItemIndexList = ItemCommon.GetItem_FromPack_ByID(lockItemID, itemPack, lockCostItemCountTotal)
        if not hasEnough:
            GameWorld.DebugLog("Ëø¶¨²ÄÁϲ»×㣬Î佫ÎÞ·¨Ï´Á¶! lockItemID=%s,lockCostItemCount=%s,lockCostItemCountTotal=%s" 
                               % (lockItemID, lockCostItemCount, lockCostItemCountTotal))
            return
    
    ItemCommon.ReduceItem(curPlayer, itemPack, washItemIndexList, washCostItemCount, True, "HeroTalentWash")
    ItemCommon.ReduceItem(curPlayer, itemPack, lockItemIndexList, lockCostItemCountTotal, True, "HeroTalentWash")
    
    singleItem = heroItem.GetItem()
    idCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
    washIDList = []
    for index in range(idCount):
        if index in lockTalentIndexs:
            talentID = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentID, index)
            washIDList.append(talentID)
        else:
            washIDList.append(0)
            
    GameWorld.DebugLog("Ï´Á¶Ç°: %s" % (washIDList))
    
    idWeightDict = {}
    talentWeightList = []
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in range(ipyDataMgr.GetHeroTalentCount()):
        talentIpyData = ipyDataMgr.GetHeroTalentByIndex(index)
        talentID = talentIpyData.GetTalentID()
        if talentID in washIDList:
            # Ì츳ID²»¿ÉÖظ´
            continue
        weight = talentIpyData.GetWashWeight()
        talentWeightList.append([weight, talentID])
        idWeightDict[talentID] = weight
        
    for index, talentID in enumerate(washIDList):
        if talentID:
            continue
        randTalentID = GameWorld.GetResultByWeightList(talentWeightList)
        if not randTalentID:
            continue
        # ÒƳýÈ·±£²»Öظ´
        randWeightID = [idWeightDict.get(randTalentID, 0), randTalentID]
        if randWeightID in talentWeightList:
            talentWeightList.remove(randWeightID)
        washIDList[index] = randTalentID
    GameWorld.DebugLog("Ï´Á¶ºó: %s" % (washIDList))
    
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashID)
    for talentID in washIDList:
        singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentWashID, talentID)
        
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashLock)
    for index in lockTalentIndexs:
        singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentWashLock, index)
        
    heroItem.Sync_Item()
    GameWorld.DebugLog("Î佫ϴÁ¶½á¹û! itemIndex=%s,heroID=%s,washIDList=%s,lockTalentIndexs=%s" 
                       % (itemIndex, heroID, washIDList, lockTalentIndexs))
    return

def HeroTalentWashReplace(curPlayer, itemIndex, heroItem):
    ## Î佫ϴÁ¶Ìæ»»
    heroID = heroItem.GetItemTypeID()
    singleItem = heroItem.GetItem()
    
    washIDList = []
    idCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentWashID)
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentID)
    for index in range(idCount):
        talentID = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentWashID, index)
        washIDList.append(talentID)
        singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentID, talentID)
        
    singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashID)
    
    heroItem.Sync_Item()
    GameWorld.DebugLog("Î佫ϴÁ¶Ìæ»»! itemIndex=%s,heroID=%s,washIDList=%s" % (itemIndex, heroID, washIDList))
    
    # Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
    
    return

#// B2 36 Î佫»»·ô #tagCSHeroWearSkin
#
#struct    tagCSHeroWearSkin
#{
#    tagHead        Head;
#    WORD        ItemIndex;    //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
#    BYTE        SkinIndex;    //Ƥ·ôË÷Òý
#};
def OnHeroWearSkin(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    itemIndex = clientData.ItemIndex
    skinIndex = clientData.SkinIndex
    heroItem = GetHeroItem(curPlayer, itemIndex)
    if not heroItem:
        return
    heroID = heroItem.GetItemTypeID()
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return
    skinNPCIDList = heroIpyData.GetSkinNPCIDList()
    if skinIndex > 0: # 0µÄΪĬÈÏƤ·ô£¬²»×öÏÞÖÆ
        if skinIndex >= len(skinNPCIDList):
            GameWorld.DebugLog("¸ÃÎ佫²»´æÔÚ¸ÃƤ·ô! heroID=%s,skinIndex=%s" % (heroID, skinIndex))
            return
        skinState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroSkin % heroID)
        if not skinState & pow(2, skinIndex):
            GameWorld.DebugLog("¸ÃÎ佫Ƥ·ôδ½âËø! heroID=%s,skinIndex=%s,skinState=%s" % (heroID, skinIndex, skinState))
            return
    heroItem.SetUserAttr(ShareDefine.Def_IudetHeroSkin, skinIndex)
    
    # Ë¢ÊôÐÔ
    
    return

def ActiveHeroSkin(curPlayer, heroID, skinIndex, isActive=True):
    skinState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroSkin % heroID)
    if isActive:
        updState = skinState | pow(2, skinIndex)
        GameWorld.DebugLog("¼¤»îÎ佫Ƥ·ô: heroID=%s,skinIndex=%s,skinState=%s,updState=%s" 
                           % (heroID, skinIndex, skinState, updState), curPlayer.GetPlayerID())
    else:
        updState = GameWorld.SetBitValue(skinState, skinIndex, 0)
        GameWorld.DebugLog("ʧЧÎ佫Ƥ·ô: heroID=%s,skinIndex=%s,skinState=%s,updState=%s" 
                           % (heroID, skinIndex, skinState, updState), curPlayer.GetPlayerID())
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroSkin % heroID, updState)
    Sync_HeroInfo(curPlayer, [heroID])
    return

#// B2 37 Î佫ͼ¼ø¼¤»îÉý¼¶ #tagCSHeroBookUP
#
#struct    tagCSHeroBookUP
#{
#    tagHead        Head;
#    DWORD        HeroID;        //Î佫ID
#    WORD        ItemIndex;    //¹ØÁªÎ佫ÎïÆ·ËùÔÚÎ佫±³°üË÷Òý£¬¼¤»îʱ¿É²»Ó÷¢
#    BYTE        BookType;    //ͼ¼ø¼¤»îÀàÐÍ£º 0-³õʼ¼¤»î£»1-ÐǼ¶Éý¼¶£»2-Í»ÆƵȼ¶Éý¼¶
#};
def OnHeroBookUP(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    heroID = clientData.HeroID
    itemIndex = clientData.ItemIndex
    bookType = clientData.BookType
    
    if bookType == 1:
        __doHeroBookStarLVUP(curPlayer, heroID, itemIndex)
    elif bookType == 2:
        __doHeroBookBreakLVUP(curPlayer, heroID, itemIndex)
    else:
        __doHeroBookAct(curPlayer, heroID)
    return

def __doHeroBookAct(curPlayer, heroID):
    ## ͼ¼ø¼¤»î
    playerID = curPlayer.GetPlayerID()
    if GetHeroBookInitState(curPlayer, heroID):
        GameWorld.DebugLog("¸ÃÎ佫ͼ¼øÒѼ¤»î! heroID=%s" % heroID, playerID)
        return
    GameWorld.DebugLog("Î佫ͼ¼ø¼¤»î! heroID=%s" % heroID, playerID)
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return
    quality = heroIpyData.GetQuality()
    qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
    if not qualityIpyData:
        return
    if GetHeroActivite(curPlayer, heroID) != 1:
        GameWorld.DebugLog("Î佫δ»ñµÃ¹ý£¬²»¿É¼¤»îͼ¼ø! heroID=%s" % (heroID), playerID)
        return
    SetHeroBookInitState(curPlayer, heroID, 1)
    
    awardMoneyInfo = qualityIpyData.GetBookActAwardMoney()
    if awardMoneyInfo and len(awardMoneyInfo) == 2:
        moneyType, moneyValue = awardMoneyInfo
        if moneyType and moneyValue:
            PlayerControl.GiveMoney(curPlayer, moneyType, moneyValue, "HeroBookAct")
                    
    Sync_HeroInfo(curPlayer, [heroID])
    return

def __doHeroBookStarLVUP(curPlayer, heroID, itemIndex):
    ## ͼ¼øÐǼ¶Éý¼¶
    playerID = curPlayer.GetPlayerID()
    heroItem = GetHeroItem(curPlayer, itemIndex)
    if not heroItem:
        return
    if heroItem.GetItemTypeID() != heroID:
        GameWorld.DebugLog("·Ç¸ÃÎ佫ͼ¼ø¹ØÁªÎïÆ·! heroID=%s,itemID=%s" % (heroID, heroItem.GetItemTypeID()), playerID)
        return
    heroStar = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
    bookStar = GetHeroBookStarLV(curPlayer, heroID)
    if bookStar >= heroStar:
        GameWorld.DebugLog("¸ÃÎ佫ͼ¼øÐǼ¶ÒѴﵱǰӢÐÛÐǼ¶! heroID=%s,bookStar=%s,heroStar=%s" % (heroID, bookStar, heroStar), playerID)
        return
    GameWorld.DebugLog("Î佫ͼ¼øÐǼ¶Éý¼¶! heroID=%s,bookStar=%s,heroStar=%s" % (heroID, bookStar, heroStar), playerID)
    SetHeroBookStarLV(curPlayer, heroID, bookStar + 1)
    Sync_HeroInfo(curPlayer, [heroID])
    
    # Ë¢ÊôÐÔ
    
    return

def __doHeroBookBreakLVUP(curPlayer, heroID, itemIndex):
    ## ͼ¼øÍ»ÆÆÉý¼¶
    playerID = curPlayer.GetPlayerID()
    heroItem = GetHeroItem(curPlayer, itemIndex)
    if not heroItem:
        return
    if heroItem.GetItemTypeID() != heroID:
        GameWorld.DebugLog("·Ç¸ÃÎ佫ͼ¼ø¹ØÁªÎïÆ·! heroID=%s,itemID=%s" % (heroID, heroItem.GetItemTypeID()), playerID)
        return
    heroBreakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
    bookBreakLV = GetHeroBookBreakLV(curPlayer, heroID)
    if bookBreakLV >= heroBreakLV:
        GameWorld.DebugLog("¸ÃÎ佫ͼ¼øÍ»ÆƵȼ¶ÒѴﵱǰӢÐÛÍ»ÆƵȼ¶! heroID=%s,bookBreakLV=%s,heroBreakLV=%s" % (heroID, bookBreakLV, heroBreakLV), playerID)
        return
    GameWorld.DebugLog("Î佫ͼ¼øÍ»ÆÆÉý¼¶! heroID=%s,bookBreakLV=%s,heroBreakLV=%s" % (heroID, bookBreakLV, heroBreakLV), playerID)
    SetHeroBookBreakLV(curPlayer, heroID, bookBreakLV + 1)
    Sync_HeroInfo(curPlayer, [heroID])
    
    # Ë¢ÊôÐÔ
    
    return

#// B4 12 Õ½¶·ÕóÐͱ£´æ #tagCSHeroBattlePosSave
#
#struct    tagCSHeroBattlePos
#{
#    WORD        ItemIndex;    //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
#    BYTE        PosNum;        //1~nÉÏÕóλÖñàºÅ  
#};
#
#struct    tagCSHeroBattlePosSave
#{
#    tagHead        Head;
#    BYTE        FuncType;    //²¼Õó¹¦ÄÜÀàÐÍ£º0-ĬÈÏÖ÷ÕóÐÍ£»ÆäËû´ýÀ©Õ¹£¬Èçij¸ö»î¶¯µÄ·ÀÊØÕóÐÍ
#    BYTE        PosCnt;
#    tagCSHeroBattlePos    HeroPosList[PosCnt];    // ±£´æµÄÕóÐÍ£¬Ö»Òª·¢ËÍ×îÖÕµÄÕóÐÍÎ佫λÖü´¿É
#};
def OnHeroBattlePosSave(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    funcType = clientData.FuncType
    heroPosList = clientData.HeroPosList
    
    heroPosDict = {}
    indexList = []
    for posInfo in heroPosList:
        posNum = posInfo.PosNum
        itemIndex = posInfo.ItemIndex
        if itemIndex in indexList:
            # µ¥Î佫ֻÄÜÒ»¸öλÖã¬Ò»¸öλÖÃÖ»ÄܶÔӦΨһÎ佫µ¥Î»
            continue
        indexList.append(itemIndex)
        heroPosDict[posNum] = itemIndex
        
    # Ö÷ÕóÐÍ
    if funcType == 0:
        MainBattlePosSave(curPlayer, heroPosDict)
        
    # ÆäËû´ýÀ©Õ¹
    elif funcType == 1:
        pass
    
    return

def MainBattlePosSave(curPlayer, heroPosDict):
    GameWorld.DebugLog("±£ÁôÖ÷Õ½¶·ÕóÐÍ: %s" % heroPosDict, curPlayer.GetPlayerID())
    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
    # Ö±½ÓÖØÖþÉÕóÐÍ
    for index in range(curPack.GetCount()):
        heroItem = curPack.GetAt(index)
        if not heroItem or heroItem.IsEmpty():
            continue
        if not heroItem.GetUserAttr(ShareDefine.Def_IudetHeroPosNum):
            continue
        item = heroItem.GetItem()
        item.ClearUserAttr(ShareDefine.Def_IudetHeroPosNum)
        
    # ¸üÐÂÐÂÕóÐÍ
    for posNum, itemIndex in heroPosDict.items():
        if itemIndex < 0 or itemIndex >= curPack.GetCount():
            continue
        heroItem = curPack.GetAt(itemIndex)
        if not heroItem or heroItem.IsEmpty():
            continue
        item = heroItem.GetItem()
        item.SetUserAttr(ShareDefine.Def_IudetHeroPosNum, posNum)
        
    ResetHeroPack(curPlayer)
    return

def ResetHeroPack(curPlayer):
    tick = GameWorld.GetGameWorld().GetTick()
    curPlayer.SetResetItemTick(0)
    ItemControler.ResetItem(curPlayer, ShareDefine.rptHero, 0, 0, tick)
    return
    
def Sync_HeroInfo(curPlayer, heroIDList=None):
    if heroIDList != None:
        syncHeroIDList = heroIDList
    else:
        syncHeroIDList = []
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        for index in range(ipyDataMgr.GetHeroCount()):
            ipyData = ipyDataMgr.GetHeroByIndex(index)
            syncHeroIDList.append(ipyData.GetHeroID())
    
    if not syncHeroIDList:
        return
    
    syncInfoList = []
    for heroID in syncHeroIDList:
        heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
        if not heroIpyData:
            continue
        if heroIDList == None and not curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID):
            continue
        
        hero = ChPyNetSendPack.tagSCHero()
        hero.HeroID = heroID
        hero.SkinState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroSkin % heroID)
        hero.BookInitState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID) % 10
        hero.BookStarLV = GetHeroBookStarLV(curPlayer, heroID)
        hero.BookBreakLV = GetHeroBookBreakLV(curPlayer, heroID)
        syncInfoList.append(hero)
        
    if not syncInfoList:
        return
    
    clientPack = ChPyNetSendPack.tagSCHeroInfo()
    clientPack.HeroInfoList = syncInfoList
    clientPack.HeroCnt = len(clientPack.HeroInfoList)    
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return