#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Player.PlayerPet
#
# @todo:³èÎï/ÁéÊÞ
# @author xdh
# @date 2018-7-20
# @version 1.0
#
# ÏêϸÃèÊö: ³èÎï
#
#-------------------------------------------------------------------------------
#"""Version = 2018-7-20 15:30"""
#-------------------------------------------------------------------------------

#µ¼Èë
import ChConfig
import NPCCommon
import ItemCommon
import IPY_GameWorld
import DataRecordPack
import PlayerBillboard
import SkillShell
import ItemControler
import PlayerControl
import PlayerSuccess
import GameFuncComm
import ShareDefine
import SkillCommon
import PetControl
import EventShell
import GameWorld
import IpyGameDataPY
import PlayerAttrFruit
import OpenServerCampaign
import PlayerWeekParty
import CalcNoLineEffect
import CalcLineEffect
import PlayerActivity
import ChPyNetSendPack
import NetPackCommon
import PlayerActLunhuidian
import PlayerActHorsePetTrain
import PlayerActTask

import random
import math


def DoLogic_PetInfo_OnDay(curPlayer):
    return

def OnPlayerPetLogin(curPlayer):
    ## µÇ¼´¦Àí
    if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Pet):
        return
    
    # ÅàÑøÊǺóÃæ¼ÓµÄ¹¦ÄÜ£¬Ã¿´ÎµÇ¼²¹¼ì²éһϹ¦ÄÜ¿ªÊ¼Ê±ÉèÖÃΪÅàÑø1¼¶
    for trainType in xrange(1, GetPetTrainTypes() + 1):
        if curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_PetTrainLV % trainType) == 0:
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_PetTrainLV % trainType, 1)
            
    Sync_PetTrainData(curPlayer)
    return

def DoPetOpen(curPlayer):
    GameWorld.DebugLog("DoPetOpen...", curPlayer.GetPlayerID())
    
    for trainType in xrange(1, GetPetTrainTypes() + 1):
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_PetTrainLV % trainType, 1)
    Sync_PetTrainData(curPlayer)
    return True

## ¹¦ÄÜ¿ªÆôºó, ½ÇÉ«Éý¼¶ÐèÒªµÄ´¦Àí
def DoLVUPLogic_Pet(curPlayer):
    #GameWorld.DebugLog("DoLVUPLogic_Pet")
    return

def GetPetIpydata(petNPCID):return IpyGameDataPY.GetIpyGameData("PetInfo", petNPCID)

## »ñȡгèÎïÊý¾ÝÎïÆ·
def GetNewPetDataItem(curPlayer, petNPCID, classlv= -1):

    gameData = GameWorld.GetGameData()
    petNpcData = gameData.FindNPCDataByID(petNPCID)
    if not petNpcData:
        GameWorld.ErrLog("FindNPCDataByID can not find npcData petNPCID=%s" % (petNPCID))
        return
    petIpyData = GetPetIpydata(petNPCID)
    if not petIpyData:
        GameWorld.ErrLog("tagPetInfo.txt can not find petData petNPCID=%s" % (petNPCID))
        return
    
    newPetItem = ItemCommon.CreateSingleItem(ChConfig.Def_ItemID_PetData)
    if not newPetItem:
        return
    
    newPetItem.SetUserAttr(ShareDefine.Def_IudetPet_NPCID, petNPCID)
    newPetItem.SetUserAttr(ShareDefine.Def_IudetPet_State, 0)
    
    initClass = petIpyData.GetInitRank() if classlv == -1 else classlv#³õʼ½×¼¶
    newPetItem.SetUserAttr(ShareDefine.Def_IudetPet_ClassLV, max(0, initClass - 1)) #´úÂëÀï´Ó0¿ªÊ¼
    newPetItem.SetUserAttr(ShareDefine.Def_IudetPet_QualityLV, petIpyData.GetQuality()) # ³èÎïÆ·ÖÊ
    
    __UpdPetItemSkillByClass(curPlayer, newPetItem, False)    
    return newPetItem

## »ñÈ¡³èÎïʵÀý¶ÔÓ¦µÄ³èÎïÊý¾ÝÎïÆ·
def GetPetDataItem(curPetOwner, rolePet):
    if not curPetOwner:
        return
    packItemIndex = GetPetDataItemByNPCID(curPetOwner, rolePet.GetNPCID())
    return GetPetDataItemByIndex(curPetOwner, packItemIndex)

## »ñÈ¡³èÎïÊý¾ÝÎïÆ·
def GetPetDataItemByIndex(curPlayer, petItemIndex):
    
    petDataPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptPet)
    if petItemIndex < 0 or petItemIndex >= petDataPack.GetCount():
        return
    petDataItem = petDataPack.GetAt(petItemIndex)
    if not ItemCommon.CheckItemCanUse(petDataItem):
        GameWorld.DebugLog("PetDataItem is none! PetItemIndex=%s" % petItemIndex, curPlayer.GetPlayerID())
        return
    
    return petDataItem

## »ñÈ¡³èÎïÊý¾ÝÎïÆ·
def GetPetDataItemByNPCID(curPlayer, petNPCID):
    petDataPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptPet)
    for petDataIndex in range(petDataPack.GetCount()):
        petItem = petDataPack.GetAt(petDataIndex)
        if petItem.IsEmpty():
            continue
        if petNPCID == petItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID):
            return petItem
    return

## ¸ù¾Ý³èÎïNPCID»ñÈ¡³èÎïÊý¾ÝÎïÆ·ÔÚ±³°üÖеÄË÷Òý
def GetPetDataItemIndexByNPCID(curPlayer, petNPCID):
    petDataPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptPet)
    for petDataIndex in range(petDataPack.GetCount()):
        petItem = petDataPack.GetAt(petDataIndex)
        if petItem.IsEmpty():
            continue
        if petNPCID == petItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID):
            return petDataIndex
        
    return -1

def GetPetItemCacheDict(petItem):
    ## µ¥¸öÁé³èÎïÆ·»º´æÐÅÏ¢
    npcID = petItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
    state = petItem.GetUserAttr(ShareDefine.Def_IudetPet_State)
    classLV = petItem.GetUserAttr(ShareDefine.Def_IudetPet_ClassLV)
    quality = petItem.GetUserAttr(ShareDefine.Def_IudetPet_QualityLV)
    star = petItem.GetUserAttr(ShareDefine.Def_IudetPet_Star)
    skills = [petItem.GetUserAttrByIndex(ShareDefine.Def_IudetPet_Skill, i) for i in xrange(petItem.GetUserAttrCount(ShareDefine.Def_IudetPet_Skill))]
    cacheDict = {"npcID":npcID}
    state and cacheDict.update({"state":state})
    classLV and cacheDict.update({"classLV":classLV})
    quality and cacheDict.update({"quality":quality})
    star and cacheDict.update({"star":star})
    skills and cacheDict.update({"skills":skills})
    return cacheDict

def GetPetCacheInfo(curPlayer):
    ## »ñÈ¡Áé³è¹¦ÄÜ»º´æÐÅÏ¢£¬ÔÝʱ»º´æÈ«²¿£¬Èç¹ûÓÐÐèÒª¸ÄΪ½ö»º´æÉÏÕóµÄ
    itemCacheList = []
    petDataPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptPet)
    for petDataIndex in range(petDataPack.GetCount()):
        petItem = petDataPack.GetAt(petDataIndex)
        if petItem.IsEmpty():
            continue
        itemCacheList.append(GetPetItemCacheDict(petItem))
    return itemCacheList

# //16 03 ³èÎï³öÕ½/ÕÙ»Ø#tagCPetStateChange
# tagCPetStateChange       *   GettagCPetStateChange();
# 
# class   IPY_CPetStateChange
# {
# public:
# 
#    int      GetPetID();
#    // ״̬.0-ÕÙ»Ø;1-³öÕ½;2xx-ÊØ»¤(ÊØ»¤+Ä¿±êÊØ»¤Î»)
#    int      GetState(); 0~255
# };
def PetStateChange(index, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    pack = IPY_GameWorld.IPY_CPetStateChange()
    petItemIndex = pack.GetPetID()
    state = pack.GetState()
    DoChangePetState(curPlayer, petItemIndex, state)
    return

## ³èÎïÕ½¶·×´Ì¬±ä¸ü; 0-Êջأ»1-³öÕ½  (ÊÖÓΰ汾ֻÄܳöÕ½)
def DoChangePetState(curPlayer, petItemIndex, tagState):
    # @param tagState: 0-Êջأ»>=1-³öÕ½ÔÚµÚ¼¸¸öλÖÃ
    
    petItem = GetPetDataItemByIndex(curPlayer, petItemIndex)
    if not petItem:
        return
    
    playerID = curPlayer.GetPlayerID()
    petNPCID = petItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
    curState = petItem.GetUserAttr(ShareDefine.Def_IudetPet_State)
    GameWorld.DebugLog("³èÎï״̬±ä¸ü! petItemIndex=%s,petNPCID=%s,curState=%s,tagState=%s" 
                       % (petItemIndex, petNPCID, curState, tagState), playerID)
    # ÊÕ»Ø
    if tagState <= 0:
        SetPetState(curPlayer, petItem, tagState)
        return
    
    gooutFightRealmList = IpyGameDataPY.GetFuncEvalCfg("PetGoOutFight", 1)
    if tagState > len(gooutFightRealmList):
        GameWorld.DebugLog("    ²»´æÔÚ¸ÃÁé³èÉÏÕóλÖÃ! tagState=%s" % tagState, playerID)
        return
    needRealmLV = gooutFightRealmList[tagState - 1]
    curRealmLV = curPlayer.GetOfficialRank()
    if curRealmLV < needRealmLV:
        GameWorld.DebugLog("    ¾³½ç²»×㣬ÎÞ·¨ÉÏÕóÁéÊÞ! curRealmLV=%s < %s, tagState=%s" % (curRealmLV, curRealmLV, tagState), playerID)
        return
    
    #ÅжÏÊÇ·ñ´ïµ½¿ÉÇл»µÄ½×Êý
    curClasslv = petItem.GetUserAttr(ShareDefine.Def_IudetPet_ClassLV)
    ipyData = GetPetIpydata(petNPCID)
    if not ipyData:
        return
    needClasslv = ipyData.GetUseNeedRank()
    if curClasslv < needClasslv - 1: #ÅäÖõĽ׼¶´Ó1¿ªÊ¼
        GameWorld.DebugLog('    ÁéÊÞÇл»Íâ¹Û,½×¼¶²»×ã%s,²»¿ÉÇл»£¡' % needClasslv, playerID)
        return
    SetPetState(curPlayer, petItem, tagState)
    return

def SetPetState(curPlayer, petItem, tagState):
    ## ÉèÖÃÁé³è³öս״̬
    # @param tagState: 0-Êջأ»>=1-³öÕ½ÔÚµÚ¼¸¸öλÖÃ
    npcID = petItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
    if tagState <= 0:
        GameWorld.DebugLog("    Áé³èÏÂÕó: npcID=%s" % npcID, curPlayer.GetPlayerID())
    else:
        petDataPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptPet)
        for index in range(petDataPack.GetCount()):
            item = petDataPack.GetAt(index)
            if item.IsEmpty():
                continue
            if item.GetUserAttr(ShareDefine.Def_IudetPet_State) == tagState:
                SetPetState(curPlayer, item, 0)
        GameWorld.DebugLog("    Áé³èÉÏÕó: npcID=%s,tagState=%s" % (npcID, tagState), curPlayer.GetPlayerID())
    petItem.SetUserAttr(ShareDefine.Def_IudetPet_State, tagState)
    return

def CrossServer_DoChangePetState(curPlayer, dataList):
    ## ¿ç·þ´¦Àí ³èÎïÕ½¶·×´Ì¬±ä¸ü
    return

def AutoSummonPet(curPlayer):
    return

## »ñÈ¡³öÕ½³èÎïҪѧµÄ¼¼ÄÜ
def GetPetLearnSkill(curPlayer):
    learnSkillDict = {}
    passiveSkillList = []
    petPackIndex = ShareDefine.rptPet
    petPack = curPlayer.GetItemManager().GetPack(petPackIndex)
    for i in range(petPack.GetCount()):
        petItem = petPack.GetAt(i)
        if petItem.IsEmpty():
            continue
        for i in range(petItem.GetUserAttrCount(ShareDefine.Def_IudetPet_Skill)):
            skillID = petItem.GetUserAttrByIndex(ShareDefine.Def_IudetPet_Skill, i)
            curSkilData = GameWorld.GetGameData().GetSkillBySkillID(skillID)
            if not curSkilData:
                continue
            if SkillCommon.isPassiveAttr(curSkilData):
                #±»¶¯¼¼ÄÜÊôÐÔ²»Ñ§
                passiveSkillList.append(skillID)
                continue
            skillTypeID = curSkilData.GetSkillTypeID()
            if skillTypeID in learnSkillDict:
                learnSkillDict[skillTypeID].append(skillID)
            else:
                learnSkillDict[skillTypeID] = [skillID]
            
    learnSkillIDList = [max(a) for a in learnSkillDict.values()]
    return learnSkillIDList, passiveSkillList
    
#===============================================================================
#// A7 02 ³èÎＤ»î #tagCMActivatePet
#
#struct    tagCMActivatePet
#{
#    tagHead        Head;
#    DWORD        PetNPCID; // ³èÎïNPCID
#    BYTE        IsUseGold; // ÊÇ·ñʹÓÃ×êʯֱ½Ó¹ºÂò¼¤»î
#};
def OnActivatePet(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    petNPCID = clientData.PetNPCID
    isUseGold = clientData.IsUseGold
    DoActivatePet(curPlayer, petNPCID, isUseGold, True)
    return

def DoActivatePet(curPlayer, petNPCID, isUseGold=False, isUseItem=False):
    if not isUseItem:
        #Ä¿Ç°Ö»ÄÜÎïÆ·¼¤»î
        return
    
    hasSpace = False
    petPackIndex = ShareDefine.rptPet
    petPack = curPlayer.GetItemManager().GetPack(petPackIndex)
    for i in range(petPack.GetCount()):
        packItem = petPack.GetAt(i)
        if packItem.IsEmpty():
            hasSpace = True
            continue
        
        petItemNPCID = packItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
        if petItemNPCID == petNPCID:
            GameWorld.DebugLog("ÒѾ­ÓµÓиóèÎ i=%s,petItemNPCID=%s,petNPCID=%s" % (i, petItemNPCID, petNPCID))
            return
    
    if not hasSpace:
        PlayerControl.NotifyCode(curPlayer, "Pet_liubo_76326") # ³èÎïÊýÁ¿´ïµ½ÉÏÏÞ
        return
    ipyData = GetPetIpydata(petNPCID)
    if not ipyData:
        return
    
    needItemID = ipyData.GetUnLockNeedItemID()
    needItemCnt = ipyData.GetUnLockNeedItemCnt()
    itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
    hasEnough, itemList = ItemCommon.GetItem_FromPack_ByID(needItemID, itemPack, needItemCnt)
    if not hasEnough:
        GameWorld.DebugLog("DoActivatePet() item(%s[%s]) isn't enough" % (needItemID, needItemCnt))
        return
    
    newPetItem = GetNewPetDataItem(curPlayer, petNPCID)
    if not newPetItem:
        return
    
    if not ItemControler.PlayerItemControler(curPlayer).PutInItem(petPackIndex, newPetItem):
        return
    
    ItemCommon.ReduceItem(curPlayer, itemPack, itemList, needItemCnt, False, ChConfig.ItemDel_Pet)
        
    EventShell.EventRespons_OnActivatePet(curPlayer, petNPCID)
    sysMark = ipyData.GetUnlockSys() or 'GetPet'
    PlayerControl.WorldNotify(0, sysMark, [curPlayer.GetName(), petNPCID])
    
    RefreshPetItemAddAttr(curPlayer, True)
    
    # ¿ª·þ»î¶¯Êý¾Ý
    OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_PetLV, GetTotalPetLV(curPlayer))
    PlayerWeekParty.AddWeekPartyActionCnt(curPlayer, ChConfig.Def_WPAct_Pet, petNPCID, False)
    return True


def DoPetActivate(curPlayer, index, classlv=None, refresh=True):
    ##Ö±½Ó¼¤»î Íⲿµ÷ÓÃGM²âÊÔÓÃ
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    petInfoCount = ipyDataMgr.GetPetInfoCount()
    if petInfoCount <= 0 or index > petInfoCount:
        GameWorld.ErrLog("¼¤»î³èÎﳬ¹ý³èÎï±íÊý¾ÝÊý: index=%s,petInfoCount=%s" % (index, petInfoCount))
        return
    petIpyData = ipyDataMgr.GetPetInfoByIndex(index - 1)
    petNPCID = petIpyData.GetID()
    quality = petIpyData.GetQuality()
    maxClassLV = petIpyData.GetMaxRank()
    
    petPackIndex = ShareDefine.rptPet
    petPack = curPlayer.GetItemManager().GetPack(petPackIndex)
    for i in range(petPack.GetCount()):
        packItem = petPack.GetAt(i)
        if packItem.IsEmpty():
            continue
        petItemNPCID = packItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
        if petItemNPCID == petNPCID:
            if classlv:
                packItem.SetUserAttr(ShareDefine.Def_IudetPet_ClassLV, max(0, min(classlv, maxClassLV) - 1))
            packItem.SetUserAttr(ShareDefine.Def_IudetPet_QualityLV, quality) # ³èÎïÆ·ÖÊ
            GameWorld.DebugLog("ÒѾ­ÓµÓиóèÎ i=%s,petItemNPCID=%s,petNPCID=%s" % (i, petItemNPCID, petNPCID))
            __UpdPetItemSkillByClass(curPlayer, packItem, True)
            return True
        
    if classlv == None:
        classlv = 1
    classlv = min(classlv, maxClassLV)
    newPetItem = GetNewPetDataItem(curPlayer, petNPCID, classlv)
    if not newPetItem:
        return
    petPackIndex = ShareDefine.rptPet
    
    if not ItemControler.PlayerItemControler(curPlayer).PutInItem(petPackIndex, newPetItem):
        return
    if not refresh:
        return True
    RefreshPetItemAddAttr(curPlayer, True)
    return True

#// A7 04 ³èÎïÉý½× #tagCMPetClassUP
#
#struct    tagCMPetClassUP
#{
#    tagHead        Head;
#    BYTE        PetItemIndex;    //³èÎïÊý¾Ý±³°üË÷Òý
#};
def PetClassUp(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Pet):
        GameWorld.DebugLog(' ³èÎ﹦ÄÜ먦Æô')
        return
    playerID = curPlayer.GetPlayerID()
    PetItemIndex = clientData.PetItemIndex
    costItemCount = clientData.UseItemCnt # ÏûºÄ²ÄÁϸöÊý
    isAutoBuy = 0 #clientData.IsAutoBuy # ÊÇ·ñ×Ô¶¯¹ºÂò
    petDataItem = GetPetDataItemByIndex(curPlayer, PetItemIndex)
    if not petDataItem:
        return
    
    petNPCID = petDataItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)

    petNpcData = GameWorld.GetGameData().FindNPCDataByID(petNPCID)
    if not petNpcData:
        GameWorld.ErrLog("can not found pet npcID = %s" % (petNPCID))
        return
    
    classLV = petDataItem.GetUserAttr(ShareDefine.Def_IudetPet_ClassLV)
    petIpyData = GetPetIpydata(petNPCID)
    if not petIpyData:
        return
    maxClassLV = petIpyData.GetMaxRank()
    if classLV + 2 > maxClassLV:
        GameWorld.DebugLog("³èÎïÉý½× ÒÑÂú¼¶¡£¡£¡£classLV=%s" % classLV, playerID)
        return
    
    ipyData = IpyGameDataPY.GetIpyGameData("PetClassCost", petNPCID, classLV + 1)
    if not ipyData:
        return
    
    needExp = ipyData.GetUpNeedExp()
    if not needExp:
        return
    
    curPetClassExp = petDataItem.GetUserAttr(ShareDefine.Def_IudetPet_Exp)
    
    
    curItemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
    
    itemIndexList = []
    costItemIDList = []
    specCostItemInfo = IpyGameDataPY.GetFuncEvalCfg('PetUpItem', 4)
    for strItemID, petNPCIDList in specCostItemInfo.items():
        if petNPCID in petNPCIDList:
            costItemIDList = [int(strItemID)]
            break
    if not costItemIDList:
        costItemIDList = IpyGameDataPY.GetFuncEvalCfg('PetUpItem')
    if not costItemIDList:
        return
    
    #¿Û²ÄÁÏ
    nowCnt = 0
    for itemID in costItemIDList:
        hasEnough, indexList, findItemIsBind, lackCnt = ItemCommon.GetItem_FromPack_ByID_ExEx(itemID, curItemPack, costItemCount - nowCnt)
        itemIndexList.extend(indexList)
        if hasEnough:
            #×ã¹»Í˳ö
            break
        if itemIndexList:
            nowCnt = 0
            for itemIndex in itemIndexList:
                curItem = curItemPack.GetAt(itemIndex)
                #¼ì²éÎïÆ·
                if not ItemCommon.CheckItemCanUse(curItem):
                    continue
                itemCnt = curItem.GetCount()
                nowCnt += itemCnt
    if not hasEnough and not isAutoBuy:
        GameWorld.DebugLog("PetClassUp Éý½×µÀ¾ß²»×ã! petNPCID=%s,costItemIDList=%s" % (petNPCID, costItemIDList))
        return
    
    autoBuyItemID = costItemIDList[0]
    if itemIndexList:
        curItem = curItemPack.GetAt(itemIndexList[0])
    else:
        curItem = GameWorld.GetGameData().GetItemByTypeID(autoBuyItemID)
    if not curItem:
        return
    
    if lackCnt > 0:
        return
    
    playerName = curPlayer.GetName()
   
    curEff = curItem.GetEffectByIndex(0)
    addExp = curEff.GetEffectValue(0) * costItemCount
    updExp = curPetClassExp + addExp
    updClassLV = classLV
    for lv in xrange(classLV, maxClassLV - 1):
        ipyData = IpyGameDataPY.GetIpyGameData("PetClassCost", petNPCID, lv + 1)
        if not ipyData:
            break
        upNeedExp = ipyData.GetUpNeedExp()
        if updExp < upNeedExp:
            break
        updExp -= upNeedExp
        updClassLV += 1
        
    
    #¿Û³ýÎïÆ·
    delCnt = max(0, costItemCount - lackCnt) # ʵ¼Ê¿Û³ýµÄ¸öÊý
    if itemIndexList:
        ItemCommon.ReduceItem(curPlayer, curItemPack, itemIndexList, delCnt, True, ChConfig.ItemDel_Pet)
        
    # ¸üо­ÑéÖµ
    if updClassLV + 1 >= maxClassLV:
        updExp = 0
    petDataItem.SetUserAttr(ShareDefine.Def_IudetPet_Exp, updExp)
    if updClassLV > classLV:
        petDataItem.SetUserAttr(ShareDefine.Def_IudetPet_ClassLV, updClassLV)
        
        learnSkillList = __UpdPetItemSkillByClass(curPlayer, petDataItem, True)
        
        if not learnSkillList and updClassLV + 1 == maxClassLV:
            PlayerControl.WorldNotify(0, 'PetUpLvMax', [playerName, petNPCID])
        # Èç¹ûÊǵ±Ç°³öÕ½µÄ³èÎï, Ôò¸Ã³èÎïѧϰ¼¼ÄÜ
        fightPet = curPlayer.GetPetMgr().GetFightPet()
        if learnSkillList and fightPet:
            PetControl.DoLogic_PlayerPetLearnSkillList(fightPet, learnSkillList)
            
        RefreshPetItemAddAttr(curPlayer, True)
        
        # ¿ª·þ»î¶¯Êý¾Ý
        OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_PetLV, GetTotalPetLV(curPlayer))
        
    PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_PetClassLV, 1, [petNPCID, updClassLV + 1])
    extraInfoDict = {"petItemIndex":PetItemIndex, "petNPCID":petNPCID}
    extraInfoDict.update(eval(petDataItem.GetUserData()))
    DataRecordPack.DR_ClassUpSystem(curPlayer, "PetClassUp", updClassLV, extraInfoDict)
        
    #EventReport.WriteEvent_pet_class(curPlayer, petNpcData.GetName(), classLV, petClassExp, updClassLV, newClassExp)
    
    PlayerActHorsePetTrain.OnHorsePetTrainCost(curPlayer, {autoBuyItemID:costItemCount})
    PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_PetUpItem, costItemCount)
    PlayerActLunhuidian.AddLunhuidianValue(curPlayer, PlayerActLunhuidian.AwardType_UseItem, autoBuyItemID, costItemCount)
    return

def __UpdPetItemSkillByClass(curPlayer, petDataItem, isNotify=False):
    # Éý½×¸üÐÂÁé³è¼¼ÄÜ£¬Ö§³ÖͬskillTypeID¼¼ÄÜÉý¼¶
    playerName = curPlayer.GetName()
    petNPCID = petDataItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
    classLV = petDataItem.GetUserAttr(ShareDefine.Def_IudetPet_ClassLV) + 1
    itemSkillList = []
    itemSkillCount = petDataItem.GetUserAttrCount(ShareDefine.Def_IudetPet_Skill)
    for i in xrange(itemSkillCount):
        skillID = petDataItem.GetUserAttrByIndex(ShareDefine.Def_IudetPet_Skill, i)
        skillData = GameWorld.GetGameData().GetSkillBySkillID(skillID)
        if not skillData:
            continue
        skillTypeID = skillData.GetSkillTypeID()
        itemSkillList.append([skillTypeID, skillID])
    #GameWorld.DebugLog("¿ªÊ¼¸üÐÂÁé³è¼¼ÄÜ: petNPCID=%s,classLV=%s,itemSkillList=%s" % (petNPCID, classLV, itemSkillList))
    
    petIpyData = GetPetIpydata(petNPCID)
    petSkillList = petIpyData.GetSkillID()
    petSkillUnLockList = petIpyData.GetSkillUnLock()
    sysMarkList = petIpyData.GetSkillUnLockSys()
    learnSkillList = []
    skillChange = False
    for i, skillID in enumerate(petSkillList):
        limitPetClassLV = petSkillUnLockList[i] # ѧϰ´Ë¼¼ÄÜËùÐè³èÎï½×¼¶
        if classLV < limitPetClassLV:
            GameWorld.DebugLog("    δÂú×ãѧϰ½×¼¶: i=%s,skillID=%s,limitPetClassLV=%s" % (i, skillID, limitPetClassLV))
            break
        skillData = GameWorld.GetGameData().GetSkillBySkillID(skillID)
        if not skillData:
            continue
        skillTypeID = skillData.GetSkillTypeID()
        alreadyLearnSkillID, alreadyLearnIndex = 0, -1
        for skillIndex, skillInfo in enumerate(itemSkillList):
            itemSkillTypeID, itemSkillID = skillInfo
            if itemSkillTypeID == skillTypeID:
                alreadyLearnSkillID = itemSkillID
                alreadyLearnIndex = skillIndex
                break
        if skillID <= alreadyLearnSkillID:
            #GameWorld.DebugLog("    ¼¼ÄÜÒѾ­Ñ§Ï°¹ý: i=%s,skillID=%s <= alreadyLearnSkillID=%s" % (i, skillID, alreadyLearnSkillID))
            continue
        if skillData.GetFuncType() == ChConfig.Def_SkillFuncType_PetOwnerSkill:
            #GameWorld.DebugLog("    Ö÷ÈËѧϰ¼¼ÄÜ: i=%s,skillID=%s" % (i, skillID))
            SkillCommon.GivePlayerSkillByJobSkill(curPlayer, [skillID])
            continue
        skillChange = True
        if not alreadyLearnSkillID:
            itemSkillList.append([skillTypeID, skillID])
        else:
            itemSkillList[alreadyLearnIndex] = [skillTypeID, skillID]
        if not SkillCommon.isPassiveAttr(skillData):
            #±»¶¯¼¼Äܲ»Ñ§
            learnSkillList.append(skillID)
        #¹ã²¥
        sysMark = sysMarkList[i] if i < len(sysMarkList) else 'PetUpLv'
        if isNotify and sysMark:
            PlayerControl.WorldNotify(0, sysMark, [playerName, petNPCID, limitPetClassLV, skillID])
        #Ôö¼ÓÉý¼¶»îÔ¾µãЧ¹û
        PlayerActivity.AddActivityByLVOnLearnSkill(curPlayer, skillID)
        
    if not skillChange:
        return learnSkillList
    
    for skillIndex, skillInfo in enumerate(itemSkillList):
        skillID = skillInfo[1]
        if skillIndex < itemSkillCount:
            itemSkillID = petDataItem.GetUserAttrByIndex(ShareDefine.Def_IudetPet_Skill, skillIndex)
            if itemSkillID != skillID:
                #GameWorld.DebugLog("    ѧϰÉý¼¶¼¼ÄÜ: itemSkillID=%s -> skillID=%s,skillIndex=%s" % (itemSkillID, skillID, skillIndex))
                petDataItem.UpdataUserAttrByIndex(ShareDefine.Def_IudetPet_Skill, skillIndex, skillID)
        else:
            #GameWorld.DebugLog("    ѧϰеļ¼ÄÜ: skillID=%s,skillIndex=%s" % (skillID, skillIndex))
            petDataItem.AddUserAttr(ShareDefine.Def_IudetPet_Skill, skillID)
            
    nowSkillIDList = []
    for i in xrange(petDataItem.GetUserAttrCount(ShareDefine.Def_IudetPet_Skill)):
        nowSkillIDList.append(petDataItem.GetUserAttrByIndex(ShareDefine.Def_IudetPet_Skill, i))
    GameWorld.DebugLog("Áé³è×îм¼ÄÜ: nowSkillIDList=%s" % nowSkillIDList)
    return learnSkillList

def GetTotalPetLV(curPlayer):
    totalPetLV = 0
    petPackIndex = ShareDefine.rptPet
    petPack = curPlayer.GetItemManager().GetPack(petPackIndex)
    for i in range(petPack.GetCount()):
        petItem = petPack.GetAt(i)
        if petItem.IsEmpty():
            continue 
        petItemNPCID = petItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
        classLV = petItem.GetUserAttr(ShareDefine.Def_IudetPet_ClassLV) + 1
        petIpyData = GetPetIpydata(petItemNPCID)
        if not petIpyData:
            continue
        totalPetLV += classLV
    return totalPetLV

def GetTotalPetCount(curPlayer):
    totalPetCount = 0
    petPackIndex = ShareDefine.rptPet
    petPack = curPlayer.GetItemManager().GetPack(petPackIndex)
    for i in range(petPack.GetCount()):
        petItem = petPack.GetAt(i)
        if petItem.IsEmpty():
            continue 
        petItemNPCID = petItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
        petIpyData = GetPetIpydata(petItemNPCID)
        if not petIpyData:
            continue
        totalPetCount += 1
    return totalPetCount

## ˢгèÎïÊý¾ÝÎïÆ·Ôö¼ÓµÄÊôÐÔ
def RefreshPetItemAddAttr(curPlayer, isUpdBillboard):
    CalcPetItemAddPlayerAttr(curPlayer)
    
    if isUpdBillboard:
        PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState(billboardFunc=PlayerBillboard.UpdatePyPetBillboard, isForce=True)
        #PlayerBillboard.UpdatePyPetBillboard(curPlayer, True)
    else:
        PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState(isForce=True)
        
    #fightPet = curPlayer.GetPetMgr().GetFightPet()
    #if fightPet:
    #    PetControl.RefurbishPetAttr(fightPet)
    return

def CalcSkill_PetBattleEffect(curPlayer, rolePet, allAttrListPet):
    #ÁéÊÞ¼¼ÄܸøÁéÊÞ¼ÓµÄÊôÐÔ£¬²»¸øÈËÎï¼ÓµÄÊôÐÔ
    learnSkillList, passiveSkillList = GetPetLearnSkill(curPlayer)
    #GameWorld.DebugLog("1Ë¢¼¼ÄÜÊôÐÔ: %s" % allAttrList)
    for skillID in passiveSkillList:
        curSkill = GameWorld.GetGameData().GetSkillBySkillID(skillID)
        if not curSkill:
            continue
        for effectIndex in xrange(curSkill.GetEffectCount()):
            curEffect = curSkill.GetEffect(effectIndex)
            if curEffect.GetEffectID() not in ChConfig.Def_SkillEffs_Pet:
                # ²»¸ø³èÎï¼ÓµÄ²»´¦Àí
                continue
            SkillShell.CalcBuffEffAttr(rolePet, curEffect, allAttrListPet)


##¼ÆËãNPCÕ½¶·ÊôÐÔ
# @param curNPC NPCʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ¼ÆËãNPCÕ½¶·ÊôÐÔ
def CalcBuffer_PetBattleEffect(rolePet, allAttrListPet):
    #@warning:Õ½¶·ÊôÐÔÏÈËã·ÇÏßÐÔÔÚËãÏßÐÔ
    buffRefreshList = NPCCommon.GetNPCBuffRefreshList(rolePet)
    
    for buffState, canPileup in buffRefreshList:
        SkillShell.CalcCurBuffer_Effect(buffState, rolePet, allAttrListPet)
    
    #·ÇÏßÐÔ
    CalcNoLineEffect.ChangeNPCAttrInNoLineEffectList(rolePet, allAttrListPet[ChConfig.CalcAttr_BattleNoline])
    #ÏßÐÔ
    CalcLineEffect.ChangeNPCAttrInLineEffectList(rolePet, allAttrListPet[ChConfig.CalcAttr_Battle])
    return


## ¼ÆËã³èÎïÔö¼ÓµÄÍæ¼ÒÊôÐÔ
#  @param curPlayer Íæ¼Ò
#  @return None
def CalcPetItemAddPlayerAttr(curPlayer):
    allAttrListPet = [{} for _ in range(4)]
    allAttrListPetSign = [{} for _ in range(4)] # ÊôÐÔº¬ ÌØÊâµÄ¼¼ÄÜÊôÐÔ(ÒòΪǩµ½¼¼ÄÜÊôÐԳɳ¤£¬Õ½Á¦Ò²Êdzɳ¤µÄ£¬ËùÒÔ²»Äܷż¼ÄÜÖÐËãÕ½Á¦£¬ÔÝʱ·Å»êʯÖÐ)
    allAttrListPetSoul = [{} for _ in range(4)]
    skillAttrList = [{} for _ in range(4)]
    allAttrListPetSkin = [{} for _ in range(4)]
    allAttrListTrain = [{} for _ in range(4)]
    allAttrListStar = [{} for _ in range(4)]
    customAttrDictPet = {}
    totalMinAtk, totalMaxAtk, qualityAttrInfo = GetPetAtkValue(curPlayer)
    customAttrDictPet["petQualityAttrInfo"] = qualityAttrInfo
    PlayerControl.CalcAttrDict_Type(ShareDefine.Def_Effect_PetMinAtk, totalMinAtk, allAttrListPet)
    PlayerControl.CalcAttrDict_Type(ShareDefine.Def_Effect_PetMaxAtk, totalMaxAtk, allAttrListPet)
    totalSignNum = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TotalSignNum) # ×ÜÇ©µ½ÌìÊý
    # ¹ûʵ¸øÈËÎï¼ÓÊôÐÔ, »êʯ¹ûʵË㸽¼ÓÊôÐԲ㣬µ¥¶À¼ÆËã
    fightPowerEx = PlayerAttrFruit.CalcAttrFruitAddAtrr(curPlayer, allAttrListPetSoul, ShareDefine.Def_AttrFruitFunc_Pet)
    PlayerControl.SetMFPExFightPower(curPlayer, ShareDefine.Def_MFPType_PetSoul, fightPowerEx)
    
    #ÁéÊÞ¼¼ÄܸøÈËÎï¼ÓµÄÊôÐÔ
    learnSkillList, passiveSkillList = GetPetLearnSkill(curPlayer)
    #GameWorld.DebugLog("1Ë¢¼¼ÄÜÊôÐÔ: %s" % allAttrList)
    for skillID in passiveSkillList:
        curSkill = GameWorld.GetGameData().GetSkillBySkillID(skillID)
        if not curSkill:
            continue
        # Áé³èÇ©µ½¼¼ÄÜÌØÊâ´¦Àí
        if curSkill.GetSkillTypeID() == ChConfig.Def_SkillID_PetSignDay:
            for effectIndex in xrange(curSkill.GetEffectCount()):
                curEffect = curSkill.GetEffect(effectIndex)
                effID = curEffect.GetEffectID()
                effValue = curEffect.GetEffectValue(0)
                PlayerControl.CalcAttrDict_Type(effID, effValue * totalSignNum, allAttrListPetSign)
            
            continue
        for effectIndex in xrange(curSkill.GetEffectCount()):
            curEffect = curSkill.GetEffect(effectIndex)
            if curEffect.GetEffectID() in ChConfig.Def_SkillEffs_Pet:
                # ¸ø³èÎï¼ÓµÄ²»´¦Àí
                continue
            SkillShell.CalcBuffEffAttr(curPlayer, curEffect, skillAttrList)
    
    # ÐÂÅàÑøÊôÐÔ
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in xrange(ipyDataMgr.GetPetTrainCount()):
        trainIpyData = ipyDataMgr.GetPetTrainByIndex(index)
        trainType = trainIpyData.GetTrainType()
        dataTrainLV = trainIpyData.GetTrainLV()
        trainLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_PetTrainLV % trainType)
        
        if dataTrainLV > trainLV:
            continue
        elif dataTrainLV == trainLV:
            trainItemCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_PetTrainItemCount % trainType)
        else:
            trainItemCount = trainIpyData.GetEatCntTotal()
            
        # µÈ½×¶îÍâÊôÐÔ
        lvAttrTypeList = trainIpyData.GetLVAttrTypeList()
        lvAttrValueList = trainIpyData.GetLVAttrValueList()
        for i, attrID in enumerate(lvAttrTypeList):
            attrValue = lvAttrValueList[i]
            PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListTrain)
            
        # ÅàÑøµ¤Ôö¼ÓÊôÐÔ
        eatCntEverytime = trainIpyData.GetEatCntEverytime()
        if trainItemCount and eatCntEverytime:
            eatItemAttrTypeList = trainIpyData.GetEatItemAttrTypeList()
            eatItemAttrValueList = trainIpyData.GetEatItemAttrValueList()
            attrMultiple = trainItemCount / eatCntEverytime
            for i, attrID in enumerate(eatItemAttrTypeList):
                attrValue = eatItemAttrValueList[i]
                PlayerControl.CalcAttrDict_Type(attrID, attrValue * attrMultiple, allAttrListTrain)
                
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PetTarin, allAttrListTrain)
    
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Pet, allAttrListPet, customAttrDict=customAttrDictPet)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PetSoul, allAttrListPetSoul)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PetSign, allAttrListPetSign)
    
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PetSkill, skillAttrList)
    
    #³õʼսÁ¦
    fpExTotal = 0
    petPackIndex = ShareDefine.rptPet
    petPack = curPlayer.GetItemManager().GetPack(petPackIndex)
    for i in range(petPack.GetCount()):
        petItem = petPack.GetAt(i)
        if petItem.IsEmpty():
            continue
        # ÎïÆ·Éϵļ¼ÄÜÕ½Á¦£¬Ö÷ÈËÉϵÄÁíËã
        for i in range(petItem.GetUserAttrCount(ShareDefine.Def_IudetPet_Skill)):
            skillID = petItem.GetUserAttrByIndex(ShareDefine.Def_IudetPet_Skill, i)
            curSkilData = GameWorld.GetGameData().GetSkillBySkillID(skillID)
            if not curSkilData:
                continue
            fpExTotal += curSkilData.GetFightPower()
        petItemNPCID = petItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
        petIpyData = GetPetIpydata(petItemNPCID)
        if not petIpyData:
            continue
        fpExTotal += petIpyData.GetInitFightPower() # ³õʼսÁ¦
        #¾õÐÑÕ½Á¦
        skinData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorsePetSkinData % (2, petItemNPCID), 0)
        skinIpyData = IpyGameDataPY.GetIpyGameDataNotLog('HorsePetSkin', 2, petItemNPCID, skinData / 100)
        if skinIpyData:
            for attrID, attrValue in skinIpyData.GetAttrInfo().items():
                PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListPetSkin)
                
        #ÐǼ¶
        curStar = petItem.GetUserAttr(ShareDefine.Def_IudetPet_Star)
        starIpyData = IpyGameDataPY.GetIpyGameDataNotLog("PetStarUp", petItemNPCID, curStar)
        if starIpyData:
            starAttrType = starIpyData.GetStarAttrType()
            starAttrValue = starIpyData.GetStarAttrValue()
            for i, attrID in enumerate(starAttrType):
                attrValue = starAttrValue[i]
                PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListStar)
                
        #Éý½×
        classlv = petItem.GetUserAttr(ShareDefine.Def_IudetPet_ClassLV) + 1
        classIpyData = IpyGameDataPY.GetIpyGameDataNotLog("PetClassCost", petItemNPCID, classlv)
        if classIpyData:
            attrTypeList = classIpyData.GetAttrType()
            attrValueList = classIpyData.GetAttrValue()
            for i, attrID in enumerate(attrTypeList):
                attrValue = attrValueList[i]
                PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListStar)
                
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PetSkin, allAttrListPetSkin)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PetStar, allAttrListStar)
    PlayerControl.SetMFPExFightPower(curPlayer, ShareDefine.Def_MFPType_Pet, fpExTotal)
#    GameWorld.DebugLog("³èÎï°ñNPCID: %s, petDict=%s" % (billPetNPCID, str(billPetDict)))
    return

## »ñÈ¡ÁéÊÞ³öսʱµÄ¹¥»÷Á¦
def GetPetAtkValue(curPlayer):
    qualityAttrInfo = {}
    if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Pet):
        #GameWorld.DebugLog(' ³èÎ﹦ÄÜ먦Æô')
        return 0, 0, qualityAttrInfo
    
    classAddAtk = 0
    petPackIndex = ShareDefine.rptPet
    petPack = curPlayer.GetItemManager().GetPack(petPackIndex)
    for i in range(petPack.GetCount()):
        packItem = petPack.GetAt(i)
        if packItem.IsEmpty():
            continue
        petItemNPCID = packItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
        classlv = packItem.GetUserAttr(ShareDefine.Def_IudetPet_ClassLV)
        classIpyData = IpyGameDataPY.GetIpyGameData("PetClassCost", petItemNPCID, classlv + 1)
        atkAdd = classIpyData.GetAtkAdd() if classIpyData else 0
        classAddAtk += atkAdd
        
        petIpyData = GetPetIpydata(petItemNPCID)
        if petIpyData:
            quality = petIpyData.GetQuality()
            if quality not in qualityAttrInfo:
                qualityAttrInfo[quality] = {}
            qualityAttrDict = qualityAttrInfo[quality]
            qualityAttrDict[ShareDefine.Def_Effect_PetAtk] = qualityAttrDict.get(ShareDefine.Def_Effect_PetAtk, 0) + atkAdd
            
    totalMinAtk = classAddAtk
    totalMaxAtk = classAddAtk
    return totalMinAtk, totalMaxAtk, qualityAttrInfo

def GetPetTrainTypes():
    return len(IpyGameDataPY.GetFuncEvalCfg("PetUpItem", 3))

#// A7 05 ³èÎïÅàÑø #tagCMPetTrain
#
#struct    tagCMPetTrain
#{
#    tagHead        Head;
#    BYTE        TrainType;        //ÅàÑøÀàÐÍ£º 1-»ù´¡ÅàÑø£¬2-ÌØÊâÅàÑø£¬3-°Ù·Ö±ÈÅàÑø
#    WORD        UseItemCnt;        //ÏûºÄ²ÄÁϸöÊý
#};
def OnPetTrain(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    trainType = clientData.TrainType # ÅàÑøÀàÐÍ
    costItemCount = clientData.UseItemCnt # ÏûºÄ²ÄÁϸöÊý
    
    trainLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_PetTrainLV % trainType)
    curEatItemCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_PetTrainItemCount % trainType)
    GameWorld.DebugLog("Áé³èÅàÑø: trainType=%s,trainLV=%s,costItemCount=%s,curEatItemCount=%s" 
                       % (trainType, trainLV, costItemCount, curEatItemCount))
    
    if trainType <= 0 or trainType > GetPetTrainTypes():
        return
    
    if trainLV <= 0:
        GameWorld.DebugLog("    ÅàÑøδ¼¤»î  trainType=%s" % trainType)
        return
    
    trainIpyData = IpyGameDataPY.GetIpyGameData("PetTrain", trainType, trainLV)
    if not trainIpyData:
        return
    
    needRealmLV = trainIpyData.GetNeedRealmLV()
    curRealmLV = PlayerControl.GetTrainRealmLVReal(curPlayer, 2)
    if curRealmLV < needRealmLV:
        GameWorld.DebugLog("    ¾³½ç²»×㣬ÎÞ·¨ÅàÑø£¡  curRealmLV(%s) < needRealmLV(%s)" % (curRealmLV, needRealmLV))
        return
    
    needEatCountTotal = trainIpyData.GetEatCntTotal()
    if not needEatCountTotal:
        GameWorld.DebugLog("    ¸ÃÅàÑøÒÑÂú¼¶£¡")
        return
    
    costItemIDList = IpyGameDataPY.GetFuncEvalCfg("PetUpItem", 3)
    costItemID = costItemIDList[trainType - 1]
    if not costItemID or not costItemCount:
        return
    
    costItemIndexList, bindCnt, unBindCnt = ItemCommon.GetPackItemBindStateIndexInfo(curPlayer, costItemID, costItemCount)
    lackCnt = costItemCount - bindCnt - unBindCnt
    if lackCnt > 0:
        GameWorld.DebugLog("    ÏûºÄµÀ¾ß²»×㣬ÎÞ·¨ÅàÑø!costItemID=%s,costItemCount=%s,bindCnt=%s,unBindCnt=%s,lackCnt=%s" 
                           % (costItemID, costItemCount, bindCnt, unBindCnt, lackCnt))
        return
    
    delCnt = costItemCount
    
    # ¿Û³ýÏûºÄ
    if delCnt:
        ItemCommon.DelCostItemByBind(curPlayer, costItemIndexList, bindCnt, unBindCnt, delCnt, ChConfig.ItemDel_Pet)
        
    updClassLV = trainLV
    updEatItemCount = curEatItemCount + costItemCount
    GameWorld.DebugLog("    updEatItemCount=%s,needEatCountTotal=%s" % (updEatItemCount, needEatCountTotal))
    
    if updEatItemCount >= needEatCountTotal:
        updClassLV += 1
        updEatItemCount -= needEatCountTotal
        GameWorld.DebugLog("    ½ø½×: updClassLV=%s,updEatItemCount=%s" % (updClassLV, updEatItemCount))
        
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_PetTrainLV % trainType, updClassLV)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_PetTrainItemCount % trainType, updEatItemCount)
    
    # Éý½×
    if updClassLV > trainLV:
        pass
    
    Sync_PetTrainData(curPlayer)
    # Ë¢ÊôÐÔ£¬¸üÐÂÅÅÐаñ
    RefreshPetItemAddAttr(curPlayer, True)
    
    PlayerActHorsePetTrain.OnHorsePetTrainCost(curPlayer, {costItemID:costItemCount})
    if trainType == 2:
        PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_PetTrainItem2, costItemCount)
    elif trainType == 3:
        PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_PetTrainItem3, costItemCount)
    elif trainType == 1:
        PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_PetTrainItem1, costItemCount)
    return

#// A7 06 ³èÎïÉýÐÇ #tagCMPetStarUp
#
#struct    tagCMPetStarUp
#{
#    tagHead        Head;
#    BYTE        PetItemIndex;    //³èÎïÊý¾Ý±³°üË÷Òý
#};
def OnPetStarUp(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    PetItemIndex = clientData.PetItemIndex
    petDataItem = GetPetDataItemByIndex(curPlayer, PetItemIndex)
    if not petDataItem:
        return
    petNPCID = petDataItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
    curStar = petDataItem.GetUserAttr(ShareDefine.Def_IudetPet_Star)
    nextStar = curStar + 1
    nextIpyData = IpyGameDataPY.GetIpyGameDataNotLog("PetStarUp", petNPCID, nextStar)
    if not nextIpyData:
        GameWorld.DebugLog("Áé³è²»´æÔÚ¸ÃÐǼ¶£¬ÎÞ·¨ÉýÐÇ. petNPCID=%s,curStar=%s" % (petNPCID, curStar), playerID)
        return
    needItemList = nextIpyData.GetStarUpNeedItemList()
    if not needItemList:
        return
    itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
    lackItemDict, delInfoDict = ItemCommon.GetCostItemIndexList(needItemList, itemPack)
    if lackItemDict:
        GameWorld.DebugLog("Áé³èÉýÐÇËùÐèÎïÆ·²»×㣡 petNPCID=%s,nextStar=%s,needItemList=%s,lackItemDict=%s" 
                           % (petNPCID, nextStar, needItemList, lackItemDict), playerID)
        return
    
    ItemCommon.DelCostItem(curPlayer, itemPack, delInfoDict, "PetStarUp")    
    petDataItem.SetUserAttr(ShareDefine.Def_IudetPet_Star, nextStar)
    GameWorld.DebugLog("Áé³èÉýÐÇ. petNPCID=%s,curStar=%s,nextStar=%s" % (petNPCID, curStar, nextStar), playerID)
    
    RefreshPetItemAddAttr(curPlayer, True)    
    return

def Sync_PetTrainData(curPlayer):
    clientPack = ChPyNetSendPack.tagMCPetTrainInfo()
    clientPack.TrainLVList = []
    clientPack.TrainItemCountList = []
    for trainType in xrange(1, GetPetTrainTypes() + 1):
        clientPack.TrainLVList.append(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_PetTrainLV % trainType))
        clientPack.TrainItemCountList.append(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_PetTrainItemCount % trainType))
    clientPack.TrainTypes = len(clientPack.TrainLVList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return