#!/usr/bin/python
# -*- coding: GBK -*-
#---------------------------------------------------------------------
#
#---------------------------------------------------------------------
##@package PlayerRefineStove
# @todo: Íæ¼ÒÁ¶µ¤Â¯
#
# @author: sgj
# @date 2017-11-07
# @version 1.0
#
# @note: 
#---------------------------------------------------------------------
#"""Version = 2017-11-07 16:40"""
#---------------------------------------------------------------------
import ChConfig
import GameWorld
import IPY_GameWorld
import ItemControler
import PlayerControl
import ChPyNetSendPack
import NetPackCommon
import GameFuncComm
import ShareDefine
import ItemCommon
import PlayerSuccess
import PlayerAttrFruit
import IpyGameDataPY
import EventShell
import PlayerActivity
import PlayerFairyCeremony
import PlayerVip

import copy


##¹¦ÄÜ¿ªÆô
def DoRefineStoveOpen(curPlayer):
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_AlchemyLV, 1)
    PlayerSuccess.UptateSuccessProgress(curPlayer, ShareDefine.SuccType_AlchemyLV, 1)
    Sycn_AlchemyMsg(curPlayer)
    return True

##µÇ¼´¦Àí
def DoOnLogin(curPlayer, tick):
    Sycn_AlchemyMsg(curPlayer)
    Sycn_AlchemyPrayMsg(curPlayer)
    return

def OnDay(curPlayer):
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_AlchemyPrayCnt, 0)
    Sycn_AlchemyPrayMsg(curPlayer)
    return

#// A5 76 Íæ¼ÒÁ¶µ¤ #tagCMPlayerRefine
#
#struct tagCMPlayerRefine
#{
#    tagHead    Head;
#    WORD    RefineNum;    // Åä·½±àºÅ
#    DWORD   UseRateItem;  // ¸½¼Ó²ÄÁÏID
#};
def PlayerRefineItem(index, clientPack, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_RefineStove):
        GameWorld.DebugLog("Á¶µ¤Â¯¹¦ÄÜ먦Æô£¡", playerID)
        return
    
    alchemyID = clientPack.RefineNum
    specID = clientPack.UseRateItem # ÌØÊâÁ¶µ¤ID
    GameWorld.DebugLog("Íæ¼ÒÁ¶µ¤: alchemyID=%s,specID=%s" % (alchemyID, specID), playerID)
    alchemyIpyData = IpyGameDataPY.GetIpyGameData("Alchemy", alchemyID)
    if not alchemyIpyData:
        GameWorld.DebugLog("Åä·½²»´æÔÚ£¡alchemyID=%s" % alchemyID, playerID)
        return
    
    specAlchemyIpyData = None
    if specID:
        specAlchemyIDList = alchemyIpyData.GetSpecAlchemyID()
        if specID not in specAlchemyIDList:
            GameWorld.DebugLog("·Ç·¨ÌØÊâÅä·½£¡alchemyID=%s,specID=%s" % (alchemyID, specID), playerID)
            return
        specAlchemyIpyData = IpyGameDataPY.GetIpyGameData("AlchemySpec", specID)
        if not specAlchemyIpyData:
            GameWorld.DebugLog("ÌØÊâÅä·½²»´æÔÚ£¡alchemyID=%s,specID=%s" % (alchemyID, specID), playerID)
            return
        
    # µÈ¼¶ÅжÏ
    alchemyLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyLV)
    if alchemyLV < alchemyIpyData.GetNeedAlchemyLV():        
        GameWorld.DebugLog("Å䷽먦Æô£¡alchemyID=%s,needAlchemyLV=%s,curAlchemyLV=%s" 
                           % (alchemyID, alchemyIpyData.GetNeedAlchemyLV(), alchemyLV), playerID)
        return
    if specAlchemyIpyData:
        if alchemyLV < specAlchemyIpyData.GetNeedAlchemyLV():        
            GameWorld.DebugLog("ÌØÊâÅ䷽먦Æô£¡alchemyID=%s,specID=%s,needAlchemyLV=%s,curAlchemyLV=%s" 
                               % (alchemyID, specID, specAlchemyIpyData.GetNeedAlchemyLV(), alchemyLV), playerID)
            return
        
        alchemyItemList = specAlchemyIpyData.GetAlchemyItem()
        alchemyCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyCountSpec % specID)
        SpecialAlchemyDict = IpyGameDataPY.GetFuncEvalCfg("SpecialAlchemy", 2)
        SpecialAlchemyCountItemDict = SpecialAlchemyDict.get(specID, {})
    else:
        alchemyItemList = alchemyIpyData.GetAlchemyItem()
        alchemyCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyCount % alchemyID)
        SpecialAlchemyDict = IpyGameDataPY.GetFuncEvalCfg("SpecialAlchemy", 1)
        SpecialAlchemyCountItemDict = SpecialAlchemyDict.get(alchemyID, {})
        
    updAlchemyCount = 0
    if SpecialAlchemyCountItemDict:
        nextAlchemyCount = alchemyCount + 1
        if nextAlchemyCount <= max(SpecialAlchemyCountItemDict):
            updAlchemyCount = nextAlchemyCount # Ö»Òª»¹Ã»´ïµ½×î´óÏ´Á·´ÎÊýÌØÊâ²ú³ö£¬Ôòÿ´ÎÀÛ¼Ó´ÎÊý
            # ·ÇÌØÊâ²ÄÁÏÅä·½µÄÇé¿öÏ£¬´ïµ½Ö¸¶¨´ÎÊýÔòʹÓÃÌØÊâ´ÎÊýÖ¸¶¨²ú³ö¿â
            if nextAlchemyCount in SpecialAlchemyCountItemDict:
                alchemyItemList = SpecialAlchemyCountItemDict[nextAlchemyCount]
                GameWorld.DebugLog("Á¶µ¤´ÎÊýÌØÊâ²ú³ö¿â: Á¶µ¤±àºÅ=%s,ÌØÊâID=%s,´ÎÊý=%s,ÌØÊâ²ú³ö¿â=%s" 
                                   % (alchemyID, specID, nextAlchemyCount, alchemyItemList), playerID)
                
    # È¥³ýÏÞÖƲú³öµÄÎïÆ·
    outPutCountLimitDict = IpyGameDataPY.GetFuncEvalCfg("SpecialAlchemy", 3)
    if outPutCountLimitDict:
        limitItemInfoList = []
        alchemyItemList = copy.copy(alchemyItemList)
        for itemInfo in alchemyItemList:
            itemID = itemInfo[1]
            if itemID not in outPutCountLimitDict:
                continue
            limitCount = outPutCountLimitDict[itemID]
            outputCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyOutputCount % itemID)
            if outputCount >= limitCount:
                limitItemInfoList.append(itemInfo)
                GameWorld.DebugLog("ÒÑ´ïµ½×î´ó²ú³ö´ÎÊý£¬´Ó²ú³ö¿âÖÐÒƳý! alchemyItemList=%s,itemID=%s,outputCount=%s,limitCount=%s" 
                                   % (alchemyItemList, itemID, outputCount, limitCount), playerID)
                
        for limitItemInfo in limitItemInfoList:
            alchemyItemList.remove(limitItemInfo)
            
    if not alchemyItemList:
        GameWorld.DebugLog("Åä·½²ú³öÎïÆ·ÅäÖôíÎó!alchemyID=%s,specID=%s" % (alchemyID, specID), playerID)
        return
        
    packSpace = ItemCommon.GetItemPackSpace(curPlayer, IPY_GameWorld.rptItem, 1) 
    if not packSpace:
        PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_998371")
        return
    
    # »ù´¡¹Ì¶¨ÏûºÄ
    needMaterialDict = alchemyIpyData.GetMaterial()
    # ÌØÊâÅä·½¶îÍâÏûºÄ
    if specAlchemyIpyData:
        needMaterialDict = copy.deepcopy(needMaterialDict)
        needMaterialDict[specAlchemyIpyData.GetMaterialID()] = specAlchemyIpyData.GetMaterialCnt()
        
    itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
    lackItemDict, delInfoDict = ItemCommon.GetCostItemIndexList(needMaterialDict, itemPack, False)
    if lackItemDict:
        GameWorld.DebugLog("Åä·½²ÄÁϲ»×㣡alchemyID=%s,specID=%s,needMaterialDict=%s,lackItemDict=%s,hasItemDict=%s" 
                           % (alchemyID, specID, needMaterialDict, lackItemDict, delInfoDict), playerID)
        return
    
    makeItemInfo = GameWorld.GetResultByWeightList(alchemyItemList)
    if not makeItemInfo:
        GameWorld.ErrLog("Åä·½ºÏ³É½á¹û´íÎó£¡alchemyID=%s,specID=%s" % (alchemyID, specID), playerID)
        return
    makeItemID, itemCount = makeItemInfo
    GameWorld.DebugLog("ºÏ³ÉÅä·½: alchemyID=%s,specID=%s,makeItemID=%s,itemCount=%s,alchemyItemList=%s" 
                       % (alchemyID, specID, makeItemID, itemCount, alchemyItemList), playerID)
    #¼ì²é°´µ¤Â¯µÈ¼¶½ø½×µÄµ¤Ò©
    makeItemID = __GetAlchemyUpItemID(makeItemID, alchemyLV, alchemyIpyData.GetAlchemyUp())
    makeItemData = GameWorld.GetGameData().GetItemByTypeID(makeItemID)
    if not makeItemData:
        return
    
    if updAlchemyCount:
        if specID:
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_AlchemyCountSpec % specID, updAlchemyCount)
        else:
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_AlchemyCount % alchemyID, updAlchemyCount)
        GameWorld.DebugLog("¸üÐÂÁ¶µ¤´ÎÊýÀÛ¼Æ: alchemyID=%s,ÌØÊâID=%s,´ÎÊý=%s" % (alchemyID, specID, updAlchemyCount), playerID)
        
    #¿ÛÏûºÄ
    delItemHasBind = ItemCommon.DelCostItem(curPlayer, itemPack, delInfoDict, ChConfig.ItemDel_Alchemy)
    
    #¼Ó¾­Ñé
    addExp = alchemyIpyData.GetAlchemyExp()
    if specAlchemyIpyData:
        addExp += specAlchemyIpyData.GetAlchemyExp()
    AddRefineExp(curPlayer, addExp)
    
    #¼Ó²ú³ö´ÎÊý
    if makeItemID in outPutCountLimitDict:
        outputCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyOutputCount % makeItemID) + 1
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_AlchemyOutputCount % makeItemID, outputCount)
        GameWorld.DebugLog("¸üÐÂÁ¶µ¤²ú³öÌØÊâÎïÆ·´ÎÊý: makeItemID=%s,outputCount=%s" % (makeItemID, outputCount), playerID)
        
    #¸øÎïÆ·
    notBindItemList = IpyGameDataPY.GetFuncEvalCfg("SpecialAlchemy", 4) # ¹Ì¶¨²»°ó¶¨µÄÎïÆ·
    if makeItemID in notBindItemList:
        makeItemBind = False
    else:
        makeItemBind = delItemHasBind
    ItemControler.GivePlayerItem(curPlayer, makeItemID, itemCount, makeItemBind, [IPY_GameWorld.rptItem], 
                                 event=[ChConfig.ItemGive_Refine, False, {}])
    
    Sycn_AlchemyMsg(curPlayer, makeItemID)
    
    #×ÏÉ«¼°ÒÔÉÏÈ«·þ¹ã²¥
    notifyColor = IpyGameDataPY.GetFuncCfg("AlchemyNotify", 1)
    needNotifyItemIDList = IpyGameDataPY.GetFuncEvalCfg("AlchemyNotify", 2)
    notNotifyItemIDList = IpyGameDataPY.GetFuncEvalCfg("AlchemyNotify", 3)
    if makeItemID not in notNotifyItemIDList and (makeItemID in needNotifyItemIDList or makeItemData.GetItemColor() >= notifyColor):
        PlayerControl.WorldNotify(0, "AchemyGreatSuccess", [curPlayer.GetPlayerName(), makeItemID])
        
    #Íê³É1´ÎÁ¶µ¤³É¾Í
    PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_RefineItem, 1)
    #Íê³É1´ÎXÆ·ÖÊÎïÆ·Á¶µ¤³É¾Í
    PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_RefineStoveColor, 1, [makeItemData.GetItemColor()])
    #ÈÎÎñ
    EventShell.EventRespons_RefineItem(curPlayer, alchemyIpyData.GetNeedAlchemyLV())
    #ÈÕ³£ÈÎÎñ
    costItemCnt = sum(needMaterialDict.values())
    PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_RefineStove, costItemCnt)
    PlayerFairyCeremony.AddFCPartyActionCnt(curPlayer, ChConfig.Def_PPAct_RefineStove, 1)
    return 

def __GetAlchemyUpItemID(itemID, alchemyLV, alchemyUpCfg):
    #»ñÈ¡°´µ¤Â¯µÈ¼¶½ø½×µÄµ¤Ò©ID
    if not alchemyUpCfg:
        return itemID
    itemIDStr = str(itemID)
    upItemList = []
    for alchemyUpItemDict in alchemyUpCfg:
        if itemIDStr in alchemyUpItemDict:
            for upID, upLV in alchemyUpItemDict.items():
                upItemList.append([upLV, int(upID)])
                
    if not upItemList:
        return itemID
    upItemList.sort(reverse=True)
    for upLV, makeItemID in upItemList:
        if alchemyLV >= upLV:
            GameWorld.DebugLog("    »ñµÃ½ø½×µ¤Ò©: itemID=%s to upItemID=%s" % (itemID, makeItemID))
            return makeItemID
    return itemID

def AddRefineExp(curPlayer, addExp):
    #Ôö¼ÓÁ¶µ¤Â¯¾­Ñé
    if addExp <= 0:
        return
    
    alchemyLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyLV)
    alchemyExp = min(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyExp) + addExp, ShareDefine.Def_UpperLimit_DWord)
    GameWorld.DebugLog("Ôö¼ÓÁ¶µ¤¾­Ñé: alchemyLV=%s,addExp=%s,alchemyExp=%s" % (alchemyLV, addExp, alchemyExp), curPlayer.GetPlayerID())
    
    isLVUp = False
    stoveIpyData = IpyGameDataPY.GetIpyGameDataNotLog("RefineStove", alchemyLV)
    while stoveIpyData and stoveIpyData.GetUpNeedExp() and alchemyExp >= stoveIpyData.GetUpNeedExp():
        needExp = stoveIpyData.GetUpNeedExp()
        nextLV = alchemyLV + 1
        stoveIpyData = IpyGameDataPY.GetIpyGameDataNotLog("RefineStove", nextLV)
        if not stoveIpyData:
            GameWorld.DebugLog("ûÓÐÏÂÒ»¼¶Êý¾ÝÁË£¬ÒÑÂú¼¶£¡²»¿ÉÉý¼¶£¡", curPlayer.GetPlayerID())
            break
        
        alchemyExp -= needExp
        alchemyLV += 1
        GameWorld.DebugLog("    Á¶µ¤Éý¼¶: alchemyLV=%s,alchemyExp=%s" % (alchemyLV, alchemyExp), curPlayer.GetPlayerID())
        isLVUp = True
        EventShell.EventRespons_RefineStoveUp(curPlayer, alchemyLV)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_AlchemyExp, alchemyExp)
    if not isLVUp:
        return False
    
    GameWorld.DebugLog("Éý¼¶ºóÊ£ÓྭÑ飺 %s" % alchemyExp, curPlayer.GetPlayerID())
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_AlchemyLV, alchemyLV)
    PlayerSuccess.UptateSuccessProgress(curPlayer, ShareDefine.SuccType_AlchemyLV, alchemyLV)
    
    RefreshStoveAttr(curPlayer)
    
    # ½âËø¹ã²¥
    ipyGameData = IpyGameDataPY.IPY_Data()
    for i in xrange(ipyGameData.GetAlchemyCount()):
        ipyData = ipyGameData.GetAlchemyByIndex(i)
        if alchemyLV == ipyData.GetNeedAlchemyLV():
            PlayerControl.WorldNotify(0, "FurnaceLVUp", [curPlayer.GetPlayerName(), alchemyLV, ipyData.GetAlchemyID()])
            break
        
    return True

def Sycn_AlchemyMsg(curPlayer, itemID=0):
    # ֪ͨ¿Í»§¶ËÁ¶µ¤Â¯ÐÅÏ¢
    if not itemID and not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_RefineStove):
        return
    pack = ChPyNetSendPack.tagMCPlayerStoveMsg()
    pack.StoveExp = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyExp)
    pack.StoveLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyLV)
    pack.ItemID = itemID
    NetPackCommon.SendFakePack(curPlayer, pack)
    return

def RefreshStoveAttr(curPlayer):
    CalcStoveAttr(curPlayer)
    PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState()
    return

def CalcStoveAttr(curPlayer):
    # ¹ûʵ¼Ó³É
    allAttrYaoList = [{} for _ in range(4)]
    fightPowerEx = PlayerAttrFruit.CalcAttrFruitAddAtrr(curPlayer, allAttrYaoList, ShareDefine.Def_AttrFruitFunc_Stove)
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_StoveYao, allAttrYaoList)
    curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPEx % ShareDefine.Def_MFPType_StoveYao, fightPowerEx)
    
    allAttrList = [{} for _ in range(4)]
    alchemyLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyLV)
    stoveIpyData = IpyGameDataPY.GetIpyGameData("RefineStove", alchemyLV)
    if stoveIpyData:
        attrTypeList = stoveIpyData.GetAddAttrType()
        attrValueList = stoveIpyData.GetAddAttrNum()
        for i, attrID in enumerate(attrTypeList):
            PlayerControl.CalcAttrDict_Type(attrID, attrValueList[i], allAttrList)
    
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Stove, allAttrList)
    return

g_needAlchemyLVDict = {}
def GetIsCanOutByAlchemyLV(curPlayer, itemID):
    #Åжϵ±Ç°µ¤Â¯µÈ¼¶ÊÇ·ñ¿É²ú³ö¸Ãµ¤Ò©
    global g_needAlchemyLVDict
    if not g_needAlchemyLVDict:
        ipyMgr = IpyGameDataPY.IPY_Data()
        for i in xrange(ipyMgr.GetAlchemyCount()):
            ipyData = ipyMgr.GetAlchemyByIndex(i)
            needAlchemyLV = ipyData.GetNeedAlchemyLV()
            itemList = ipyData.GetAlchemyItem()
            for itemInfo in itemList:
                g_needAlchemyLVDict[itemInfo[1]] = needAlchemyLV
        for i in xrange(ipyMgr.GetAlchemySpecCount()):
            ipyData = ipyMgr.GetAlchemySpecByIndex(i)
            needAlchemyLV = ipyData.GetNeedAlchemyLV()
            itemList = ipyData.GetAlchemyItem()
            for itemInfo in itemList:
                g_needAlchemyLVDict[itemInfo[1]] = needAlchemyLV
    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyLV) >= g_needAlchemyLVDict.get(itemID, 0)


#// A5 14 Æí¸£µ¤Ò© #tagCMPrayElixir
#
#struct    tagCMPrayElixir
#
#{
#    tagHead        Head;
#};
def PlayerPrayElixir(index, clientPack, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    prayCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyPrayCnt)
    limitCnt = PlayerVip.GetPrivilegeValue(curPlayer, ChConfig.VIPPrivilege_PrayElixir)
    if prayCnt >= limitCnt:
        GameWorld.DebugLog('½ñÈÕÆí¸£µ¤Ò©´ÎÊýÒÑÂú£¡prayCnt=%s'%prayCnt)
        return
    packSpace = ItemCommon.GetItemPackSpace(curPlayer, IPY_GameWorld.rptItem, 1) 
    if not packSpace:
        PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_998371")
        return
    
    alchemyItemList = IpyGameDataPY.GetFuncEvalCfg('GodAlchemy')
    
    newItemInfoList = []
    for itemInfo in alchemyItemList:
        itemID = itemInfo[1]
        if not GetIsCanOutByAlchemyLV(curPlayer, itemID):
            #GameWorld.DebugLog('Æí¸£µ¤Ò©,Á¶µ¤µÈ¼¶Î´´ïµ½£¬ÒƳý²ú³ö¿â£¡itemID=%s'%itemID)
            continue
        if PlayerAttrFruit.IsFruitEatFull(curPlayer, itemID):
            #GameWorld.DebugLog('Æí¸£µ¤Ò©,ʹÓôÎÊýÒÑÂú£¬ÒƳý²ú³ö¿â£¡itemID=%s'%itemID)
            continue
        newItemInfoList.append(itemInfo)
    if not newItemInfoList:
        GameWorld.DebugLog('Æí¸£µ¤Ò©,ûÓе¤Ò©¿É²ú³ö£¡£¡')
        return
    
    makeItemInfo = GameWorld.GetResultByWeightList(newItemInfoList)
    if not makeItemInfo:
        GameWorld.DebugLog("Æí¸£µ¤Ò©£¬ ½á¹û´íÎó£¡")
        return
    
    makeItemID, itemCount = makeItemInfo
    makeItemData = GameWorld.GetGameData().GetItemByTypeID(makeItemID)
    if not makeItemData:
        return
    
    costMoney = IpyGameDataPY.GetFuncCfg('GodAlchemy', 2)
    if not PlayerControl.PayMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Money, costMoney, ChConfig.Def_Cost_AlchemyPray):
        return
    #¸øÎïÆ·
    ItemControler.GivePlayerItem(curPlayer, makeItemID, itemCount, True, [IPY_GameWorld.rptItem], 
                                 event=[ChConfig.ItemGive_Refine, False, {}])
    #GameWorld.DebugLog('makeItemID=%s,newItemInfoList=%s'%(makeItemID, newItemInfoList))
    
    
    #×ÏÉ«¼°ÒÔÉÏÈ«·þ¹ã²¥
    notifyColor = IpyGameDataPY.GetFuncCfg("AlchemyNotify", 1)
    needNotifyItemIDList = IpyGameDataPY.GetFuncEvalCfg("AlchemyNotify", 2)
    notNotifyItemIDList = IpyGameDataPY.GetFuncEvalCfg("AlchemyNotify", 3)
    if makeItemID not in notNotifyItemIDList and (makeItemID in needNotifyItemIDList or makeItemData.GetItemColor() >= notifyColor):
        PlayerControl.WorldNotify(0, "BlastfurnaceBlessing", [curPlayer.GetPlayerName(), makeItemID])
        
    #¸üдÎÊý
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_AlchemyPrayCnt, prayCnt+1)
    Sycn_AlchemyPrayMsg(curPlayer, makeItemID)
    return

def Sycn_AlchemyPrayMsg(curPlayer, itemID=0):
    #Æí¸£µ¤Ò©½á¹û
    if not itemID and not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_RefineStove):
        return
    pack = ChPyNetSendPack.tagMCPrayElixirResult()
    pack.PrayCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyPrayCnt)
    pack.ItemID = itemID
    NetPackCommon.SendFakePack(curPlayer, pack)
    return