#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
#-------------------------------------------------------------------------------
#
##@package Player.PlayerRune
#
# @todo:Íæ¼Ò·ûÓ¡
# @author xdh
# @date 2017-08-04
# @version 1.0
#
# ÏêϸÃèÊö: Íæ¼Ò·ûÓ¡
#---------------------------------------------------------------------
#"""Version = 2017-08-04 12:00"""
#---------------------------------------------------------------------

import GameWorld
import ShareDefine
import ChConfig
import ItemCommon
import ItemControler
import PlayerControl
import ChPyNetSendPack
import NetPackCommon
import IpyGameDataPY
import PlayerSuccess
import PlayerMagicWeapon
import IPY_GameWorld
import OpenServerCampaign
import DataRecordPack
import PlayerWeekParty

g_runeLVExpDict = {}

##µÇ¼´¦Àí
# @param curPlayer Íæ¼Ò
# @return None
def PlayerRuneLogin(curPlayer):
    DoUnlockRuneHole(curPlayer, False)
    Sync_RuneInfo(curPlayer)
    return


## »ñÈ¡·ûÓ¡ipyÊý¾Ý
def GetRuneIpyData(itemID):return IpyGameDataPY.GetIpyGameData("Rune", itemID)

## »ñÈ¡·ûÓ¡Éý¼¶ÐèÒª¾­Ñé
def GetRuneNeedExp(itemID, lv):
    global g_runeLVExpDict
    itemData = GameWorld.GetGameData().GetItemByTypeID(itemID)
    if not itemData:
        return 0
    ipyData = GetRuneIpyData(itemID)
    if not ipyData:
        return 0
    itemColor = itemData.GetItemColor()
    if lv == 0: #³õʼ¾­Ñé
        expDict = IpyGameDataPY.GetFuncEvalCfg('RuneExp', 4, {})
        exp = expDict.get(itemColor, 0)
    else:
        if lv in g_runeLVExpDict:
            exp = g_runeLVExpDict[lv]
        else:
            level = lv + 1 #¹«Ê½´Ó1¿ªÊ¼
            exp = eval(IpyGameDataPY.GetFuncCompileCfg('RuneExp'))
            g_runeLVExpDict[lv] = exp
            
        qualityPerDict = IpyGameDataPY.GetFuncEvalCfg('RuneExp', 2, {})
        if itemColor in qualityPerDict:
            exp *= float(qualityPerDict[itemColor])
        if len(ipyData.GetAttrType()) > 1: #¶àÊôÐÔ
            specialPer = IpyGameDataPY.GetFuncCfg('RuneExp', 3)
            exp *= specialPer
    return exp

## »ñÈ¡·ûÓ¡ÊôÐÔÊýÖµ
def GetRuneAttrValue(itemID, lv):
    itemData = GameWorld.GetGameData().GetItemByTypeID(itemID)
    if not itemData:
        return {}
    ipyData = GetRuneIpyData(itemID)
    if not ipyData:
        return {}
    level = lv + 1 #¹«Ê½´Ó1¿ªÊ¼
    
    attrTypeList = ipyData.GetAttrType()
    isSpecial = len(attrTypeList) > 1 #ÊÇ·ñ¶àÊôÐÔ
    itemColor = itemData.GetItemColor()
    attrDict = {}
    for attrType in attrTypeList:
        keyStr = 'RuneAttr%s' % attrType
        attrFormula = IpyGameDataPY.GetFuncCompileCfg(keyStr)
        if not attrFormula:
            continue
        
        value = eval(attrFormula)
        qualityPerDict = IpyGameDataPY.GetFuncEvalCfg(keyStr, 2, {})
        if itemColor in qualityPerDict:
            value *= float(qualityPerDict[itemColor])
        extraValueDict = IpyGameDataPY.GetFuncEvalCfg(keyStr, 4, {})
        value += extraValueDict.get(itemColor, 0)
        
        if isSpecial:
            specialPer = IpyGameDataPY.GetFuncCfg(keyStr, 3)
            if specialPer:
                value *= specialPer
            else:
                GameWorld.ErrLog(' itemID=%s   ¹¦ÄÜÅäÖñíkeyStr=%s, ÊýÖµ3δÅäÖÃ' % (itemID, keyStr))
        attrDict[int(attrType)] = int(value)
    return attrDict

def GetRuneMaxLV(itemID):
    # »ñÈ¡·ûÓ¡×î´óµÈ¼¶
    itemData = GameWorld.GetGameData().GetItemByTypeID(itemID)
    if not itemData:
        return 0
    runeMaxLVDict = IpyGameDataPY.GetFuncEvalCfg('RuneMaxLV', 1, {})
    itemColor = itemData.GetItemColor()
    runeMaxLV = runeMaxLVDict.get(itemColor, 0)
    return runeMaxLV

#// A5 13 ½âËø·ûÓ¡¿× #tagCMUnlockRuneHole
#
#struct    tagCMUnlockRuneHole
#{
#    tagHead        Head;
#    BYTE        HoleIndex; // ¿×Ë÷Òý
#};
def OnUnlockRuneHole(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    holeIndex = clientData.HoleIndex
    runeUnlockDict = IpyGameDataPY.GetFuncEvalCfg("RuneUnlock", 2, {})
    if holeIndex not in runeUnlockDict:
        return
    runeOpenState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_HoleOpenState, 0)
    if runeOpenState & pow(2, holeIndex):
        return
    if curPlayer.GetLV() < IpyGameDataPY.GetFuncEvalCfg("RuneUnlock", 3, {}).get(holeIndex, 0):
        return
    costMoney = runeUnlockDict[holeIndex]
    if not PlayerControl.PayMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Money, costMoney, ChConfig.Def_Cost_RuneHole, {'holeIndex':holeIndex}):
        return
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_Rune_HoleOpenState, runeOpenState |pow(2, holeIndex))
    Sync_RuneInfo(curPlayer)
    PlayerControl.WorldNotify(0, 'RuneSpecialHoleGet', [curPlayer.GetName(), costMoney])
    return

def DoUnlockRuneHole(curPlayer, isSycn=True):
    # ½âËø·ûÓ¡¿×, ·ûÓ¡Ëþ¹ý¹Øʱµ÷ÓÃ
    runeUnlockList = IpyGameDataPY.GetFuncEvalCfg("RuneUnlock")
    
    runeOpenState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_HoleOpenState, 0)
    trialTowerPassLV = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_TrialTower_PassLV) # ·ûÓ¡ËþÒѹý¹Ø²ãÊý
    updOpenState = runeOpenState
    for holeNum, needTowerPassLV in enumerate(runeUnlockList):
        if runeOpenState & pow(2, holeNum):
            continue
        
        if trialTowerPassLV < needTowerPassLV:
            continue
        updOpenState |= pow(2, holeNum)
        GameWorld.DebugLog('    ½âËø·ûÓ¡¿× holeNum=%s,trialTowerPassLV=%s' % (holeNum, trialTowerPassLV))
    if updOpenState != runeOpenState:
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_Rune_HoleOpenState, updOpenState)
        if isSycn:
            Sync_RuneInfo(curPlayer)
    return

## »ñÈ¡·ûÓ¡ÊÇ·ñÒѽâËø
def GetIsOpenByRuneID(curPlayer, itemid):
    ipyData = GetRuneIpyData(itemid)
    if ipyData:
        curPassLV = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_TrialTower_PassLV)
        return curPassLV >= ipyData.GetTowerID()
    # ûÅäÖÃÏÞÖƲãÊý½âËøµÄĬÈϽâËø
    return True

def SwitchRune(curPlayer, srcBackpack, desBackPack, srcIndex, destIndex):
    # ÏâǶ/ժϷûÓ¡
    if not ((desBackPack == ShareDefine.rptRune and srcBackpack == ShareDefine.rptTempSwap) \
            or (srcBackpack == ShareDefine.rptRune and desBackPack == ShareDefine.rptTempSwap)):
        return False
    

    maxRuneHole = IpyGameDataPY.GetFuncCfg("RuneUnlock", 4)
    # ´©
    if desBackPack == ShareDefine.rptTempSwap:
        desRuneNum = destIndex + 1
        if desRuneNum < 1 or desRuneNum > maxRuneHole:
            GameWorld.DebugLog("²»´æÔڸ÷ûÓ¡¿×! desRuneNum=%s" % desRuneNum, curPlayer.GetPlayerID())
            return True
        
        runeOpenState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_HoleOpenState, 0)
        if not runeOpenState & pow(2, destIndex):
            GameWorld.DebugLog("¸Ã·ûÓ¡¿×δ½âËø! desRuneNum=%s,state=%s" % (desRuneNum, runeOpenState), curPlayer.GetPlayerID())
            return True
        
        srcRuneData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_VPackItem 
                                                     % (ShareDefine.rptRune, srcIndex)) # ·ûÓ¡±³°üÖеÄÖµ
        if not srcRuneData:
            GameWorld.DebugLog("·ûÓ¡±³°ü¸ÃλÖÃûÓзûÓ¡! srcIndex=%s" % srcIndex, curPlayer.GetPlayerID())
            return True
        srcRuneItemID = ItemControler.GetRuneItemID(srcRuneData)
        
        srcIpyData = GetRuneIpyData(srcRuneItemID)
        
        if not srcIpyData:
            GameWorld.DebugLog("¸Ã·ûӡûÓÐÅäÖÃÊôÐÔ! ÎÞ·¨ÏâǶ! itemID=%s" % srcRuneItemID, curPlayer.GetPlayerID())
            return True
        srcRuneAttrTypeList = srcIpyData.GetAttrType()
        srcRuneAttrTypeCntDict = {attrType:1 for attrType in srcRuneAttrTypeList}
        maxSameAttrRuneCnt = IpyGameDataPY.GetFuncCfg('RuneUnlock', 5)
        # ÅжÏÊÇ·ñÒÑÓÐÏâǶ¸ÃÊôÐÔÀàÐÍ
        doubleCnt = 0 #Ë«ÊôÐÔ·ûÓ¡¸öÊý
        for RuneNum in xrange(1, maxRuneHole + 1):
            if RuneNum == desRuneNum: # Ä¿±ê¿×²»ÅжÏ
                continue
            RuneData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_Data % RuneNum, 0)
            if not RuneData:
                continue
            RuneItemID = ItemControler.GetRuneItemID(RuneData)
            ipyData = GetRuneIpyData(RuneItemID)
            if not ipyData:
                continue
            attrTypeList = ipyData.GetAttrType()
            for attrType in attrTypeList:
                if attrType in srcRuneAttrTypeCntDict:
                    srcRuneAttrTypeCntDict[attrType] += 1
                    if srcRuneAttrTypeCntDict[attrType] > maxSameAttrRuneCnt:
                        GameWorld.DebugLog(
                            "¸ÃÊôÐÔÀàÐÍÒÑÏâǶÊýÁ¿³¬¹ý%s! ÎÞ·¨ÏâǶ! ,attrType=%s" % (maxSameAttrRuneCnt, attrType),
                            curPlayer.GetPlayerID())
                        return

            if len(attrTypeList) > 1:
                doubleCnt +=1
        
        if len(srcRuneAttrTypeList) > 1 and doubleCnt >= __GetCanInlayDoubleAttrRuneCnt(curPlayer):
            GameWorld.DebugLog("µ±Ç°¿ÉÏâǶ˫ÊôÐÔ·ûÓ¡¸öÊýÒÑ´ïÉÏÏÞ%s! ÎÞ·¨ÏâǶ! itemID=%s" % (doubleCnt, srcRuneItemID), curPlayer.GetPlayerID())
            return True
        
        desRuneData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_Data % desRuneNum, 0) # ¿×ÉϵÄÖµ
        
        # ÉèÖ÷ûÓ¡¿×Êý¾Ý
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_Rune_Data % desRuneNum, srcRuneData)
        # Ô­À´µÄ¿×Êý¾Ý£¬Ôò·ÅÈë·ûÓ¡±³°üÖÐ
        ItemControler.SetVPackItemKeyData(curPlayer, ShareDefine.rptRune, srcIndex, desRuneData)
        #·ûÓ¡³É¾Í
        DoRuneSuccessLogic(curPlayer)
    else:
        srcRuneNum = srcIndex + 1
        srcRuneData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_Data % srcRuneNum, 0)
        if not srcRuneData:
            GameWorld.DebugLog("¸Ã·ûÓ¡¿×ûÓÐÏâǶ·ûÓ¡! srcRuneNum=%s, srcRuneData=%s" % (srcRuneNum, srcRuneData), curPlayer.GetPlayerID())
            return True
        
        emptyIndex = ItemCommon.GetEmptyIndexInPack(curPlayer, ShareDefine.rptRune)
        if emptyIndex == -1:
            GameWorld.DebugLog("·ûÓ¡±³°üÒÑÂú£¬ÎÞ·¨ÕªÏÂ! ", curPlayer.GetPlayerID())
            return True
        desRuneData = 0
        # ÕªÏÂÉèÖÿ×Êý¾ÝΪ0
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_Rune_Data % srcRuneNum, 0)
        ItemControler.SetVPackItemKeyData(curPlayer, ShareDefine.rptRune, emptyIndex, srcRuneData)
    dataDict = {'desBackPack':desBackPack, 'srcRuneData':srcRuneData, 'desRuneData':desRuneData}
    DataRecordPack.Cache_FightPowerChangeInfo(curPlayer, ChConfig.PowerDownType_Rune, dataDict)
    RefreshRuneAttr(curPlayer)
    PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState()
    Sync_RuneInfo(curPlayer)
    return True

def __GetCanInlayDoubleAttrRuneCnt(curPlayer):
    ##µ±Ç°¿ÉÏâǶ¼¸¸öË«ÊôÐÔ·ûÓ¡
    runeDoubleInlayCntDict = IpyGameDataPY.GetFuncEvalCfg('RuneDoubleInlayCnt', 1, {})
    trialTowerPassLV = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_TrialTower_PassLV) # ·ûÓ¡ËþÒѹý¹Ø²ãÊý
    sortLVList = sorted(runeDoubleInlayCntDict.keys())
    findLV = 0
    for plv in sortLVList:
        if trialTowerPassLV < plv:
            break
        findLV = plv
    return runeDoubleInlayCntDict.get(findLV, 0)

#// A5 65 ·ûÓ¡Éý¼¶ #tagCMRuneUp
#
#struct    tagCMRuneUp
#{
#    tagHead        Head;
#    BYTE        PlaceType;    // λÖÃÀàÐÍ£»0-·ûÓ¡±³°ü£¬1-·ûÓ¡¿×
#    WORD        PlaceIndex;    // λÖÃË÷Òý
#};
def OnRuneUp(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    placeType = clientData.PlaceType
    placeIndex = clientData.PlaceIndex
    
    if placeType == 0:
        RuneData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_VPackItem % (ShareDefine.rptRune, placeIndex))
    elif placeType == 1:
        RuneData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_Data % (placeIndex + 1), 0)
    else:
        return
    
    playerID = curPlayer.GetPlayerID()
    if not RuneData:
        GameWorld.DebugLog("¸ÃλÖò»´æÔÚ·ûÓ¡, ÎÞ·¨Éý¼¶! placeType=%s,placeIndex=%s" % (placeType, placeIndex), playerID)
        return
    
    RuneItemID = ItemControler.GetRuneItemID(RuneData)
    RuneItemPlusLV = ItemControler.GetRuneItemPlusLV(RuneData)
    RuneIsLock = ItemControler.GetRuneItemIsLock(RuneData)
    RuneSource = ItemControler.GetRuneItemSource(RuneData)
    itemData = GameWorld.GetGameData().GetItemByTypeID(RuneItemID)
    if not itemData:
        return
    
    runeMaxLV = GetRuneMaxLV(RuneItemID)
    if RuneItemPlusLV + 1 >= runeMaxLV:
        GameWorld.DebugLog('¸Ã·ûÓ¡ÒÑÂú¼¶£¬ÎÞ·¨Éý¼¶£¡runeMaxLV=%s' % runeMaxLV)
        return
    
    plusCost = GetRuneNeedExp(RuneItemID, RuneItemPlusLV + 1)
    plusCost = int(plusCost)
    if not plusCost:
        GameWorld.DebugLog("¸Ã·ûÓ¡ÎÞ·¨Éý¼¶!  placeType=%s,placeIndex=%s,itemID=%s,plusLV=%s" 
                           % (placeType, placeIndex, RuneItemID, RuneItemPlusLV), playerID)
        return

    
    updRuneData = ItemControler.GetRuneItemKeyData(RuneItemID, RuneItemPlusLV + 1, RuneIsLock, RuneSource)
    if not PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_Rune, plusCost):
        curRuneMoney = PlayerControl.GetMoney(curPlayer, ShareDefine.TYPE_Price_Rune)
        GameWorld.DebugLog("·ûÓ¡¾«»ªµã²»×㣬ÎÞ·¨Éý¼¶!placeType=%s,placeIndex=%s,itemID=%s,plusLV=%s,plusCost=%s,curRuneMoney=%s" 
                           % (placeType, placeIndex, RuneItemID, RuneItemPlusLV, plusCost, curRuneMoney), playerID)
        return
    
    if placeType == 0:
        ItemControler.SetVPackItemKeyData(curPlayer, ShareDefine.rptRune, placeIndex, updRuneData)
    elif placeType == 1:
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_Rune_Data % (placeIndex + 1), updRuneData)
        RefreshRuneAttr(curPlayer)
        PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState()
        Sync_RuneInfo(curPlayer)
        DoRuneSuccessLogic(curPlayer)
        
    #itemData = GameWorld.GetGameData().GetItemByTypeID(RuneItemID)
    #RuneName = RuneItemID if not itemData else "%s(%s)" % (itemData.GetName(), RuneItemID)
    #aftRuneMoney = PlayerControl.GetMoney(curPlayer, ShareDefine.TYPE_Price_Rune)
    #EventReport.WriteEvent_rune_lv(curPlayer, RuneName, plusCost, RuneItemPlusLV + 1, aftRuneMoney)
    GameWorld.DebugLog("·ûÓ¡Éý¼¶!placeType=%s,placeIndex=%s,RuneData=%s,updRuneData=%s" 
                       % (placeType, placeIndex, RuneData, updRuneData), playerID)
    return


def DoRuneSuccessLogic(curPlayer):
    #·ûÓ¡³É¾Í´¦Àí
    #Çåµô#ÏâǶXöXÆ·ÖÊ·ûÓ¡µÄ³É¾ÍÐÅÏ¢
    PlayerSuccess.ResetSuccessByType(curPlayer, ShareDefine.SuccType_InlayRune)
    totalLV = 0
    runeHoleCnt = IpyGameDataPY.GetFuncCfg("RuneUnlock", 4)
    for holeNum in xrange(1, runeHoleCnt + 1):
        runeData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_Data % holeNum, 0)
        if not runeData:
            continue
        runeItemID = ItemControler.GetRuneItemID(runeData)
        itemData = GameWorld.GetGameData().GetItemByTypeID(runeItemID)
        if not itemData:
            continue
        itemColor = itemData.GetItemColor()
        runeItemPlusLV = ItemControler.GetRuneItemPlusLV(runeData) + 1 #¿Í»§¶Ë1¿ªÊ¼
        totalLV += runeItemPlusLV
        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_InlayRune, 1, [itemColor])
        PlayerWeekParty.AddWeekPartyActionCnt(curPlayer, ChConfig.Def_WPAct_Rune, itemColor, False)
    PlayerSuccess.UptateSuccessProgress(curPlayer, ShareDefine.SuccType_RuneLvUp, totalLV)
    # ¿ª·þ»î¶¯Êý¾Ý
    #OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_RuneLV, totalLV)
    return

#// A5 66 ·ûÓ¡·Ö½â #tagCMRuneDecompose
#
#struct    tagCMRuneDecompose
#{
#    tagHead        Head;
#    BYTE        IsAll;    // ÊÇ·ñÈ«²¿·Ö½â£¬ÓÅÏȼ¶×î¸ß£¬Ëø¶¨³ýÍâ
#    BYTE        QualityCnt;    // °´È«²¿·Ö½âÆ·ÖÊÊý
#    BYTE        QualityList[QualityCnt];    // È«²¿·Ö½âµÄÆ·ÖÊÁÐ±í£¬·¢Ë͵ÄÆ·ÖÊ»áÈ«²¿·Ö½â£¬Ëø¶¨³ýÍâ
#    BYTE        Count;    // Ö¸¶¨ÅúÁ¿·Ö½âÊý£¬×î´ó²»³¬¹ý50¸ö
#    WORD        PlaceIndexList[Count];    // ÅúÁ¿·Ö½âλÖÃË÷ÒýÁбí
#};
def OnRuneDecompose(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    isAll = clientData.IsAll
    qualityList = clientData.QualityList
    GameWorld.DebugLog("·ûÓ¡·Ö½â: isAll=%s,qualityList=%s,PlaceIndexList=%s" % (isAll, qualityList, clientData.PlaceIndexList))
    
    delPlaceDict = {}
    totalDecompose = 0
    totalMJ = 0
    packIndex = ShareDefine.rptRune
    placeList = xrange(ItemCommon.GetVPackCnt(packIndex)) if (isAll or clientData.QualityCnt > 0) else clientData.PlaceIndexList
    addPer = 0
    for place in placeList:
        RuneData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_VPackItem % (packIndex, place))
        if not RuneData:
            continue
        # Ëø¶¨µÄ²»¿É·Ö½â
        RuneIsLock = ItemControler.GetRuneItemIsLock(RuneData)
        if RuneIsLock:
            continue
        RuneItemID = ItemControler.GetRuneItemID(RuneData)
        RuneItemPlusLV = ItemControler.GetRuneItemPlusLV(RuneData)
        itemData = GameWorld.GetGameData().GetItemByTypeID(RuneItemID)
        if not itemData:
            continue
        
        quality = itemData.GetItemColor()
        
        if not (isAll or quality in qualityList or place in clientData.PlaceIndexList):
            continue
        
        if itemData.GetType() == ChConfig.Def_ItemType_RuneExp: #¾«»ªÎïÆ·¶ÁЧ¹ûÖµ
            curEff = itemData.GetEffectByIndex(0)
            decompose = curEff.GetEffectValue(0)
            decompose += decompose * addPer / ShareDefine.Def_MaxRateValue
        else:
            decompose = 0
            for lv in range(RuneItemPlusLV + 1):
                decompose += GetRuneNeedExp(RuneItemID, lv)
                if lv == 0:
                    decompose += decompose * addPer / ShareDefine.Def_MaxRateValue
                    
            ipyData = IpyGameDataPY.GetIpyGameDataNotLog('RuneCompound', RuneItemID)
            if ipyData and ItemControler.GetRuneItemSource(RuneData) in [ChConfig.Rune_Source_Unkown,ChConfig.Item_Source_Compound]:
                totalMJ += ipyData.GetNeedMJ()
            

        totalDecompose += decompose
        delPlaceDict[place] = [RuneData, int(decompose)]
        
    if delPlaceDict:
        ItemCommon.DelVPackItem(curPlayer, packIndex, delPlaceDict.keys(), ChConfig.ItemDel_Rune)
    
    totalDecompose = int(totalDecompose)
    if totalDecompose:
        addDataDict = {"delPlaceDict":delPlaceDict, "totalDecompose":totalDecompose}
        PlayerControl.GiveMoney(curPlayer, ShareDefine.TYPE_Price_Rune, totalDecompose, 
                                ChConfig.Def_GiveMoney_RuneDecompose, addDataDict, False)
        PlayerControl.NotifyCode(curPlayer, 'hwj_20170807_1', [totalDecompose, ShareDefine.TYPE_Price_Rune])
    if totalMJ:
        addDataDict = {"delPlaceDict":delPlaceDict, "totalMJ":totalMJ}
        PlayerControl.GiveMoney(curPlayer, ShareDefine.TYPE_Price_Ysog, totalMJ, 
                                ChConfig.Def_GiveMoney_RuneDecompose, addDataDict, False)
        PlayerControl.NotifyCode(curPlayer, 'hwj_20170807_1', [totalMJ, ShareDefine.TYPE_Price_Ysog])
    return

#// A5 67 ·ûÓ¡Ëø¶¨×´Ì¬±ä¸ü #tagCMRuneLock
#
#struct    tagCMRuneLock
#{
#    tagHead        Head;
#    BYTE        LockState;    // Ëø¶¨×´Ì¬£¬ 0-Ëø¶¨£¬1-½âËø
#    BYTE        Count;    // ÅúÁ¿²Ù×÷Êý£¬×î´ó²»³¬¹ý50¸ö
#    WORD        PlaceIndexList[Count];    // ÅúÁ¿²Ù×÷λÖÃË÷ÒýÁбí
#};
def OnRuneLock(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    packIndex = ShareDefine.rptRune
    changeLockState = clientData.LockState # Ëø¶¨×´Ì¬£¬ 1-Ëø¶¨£¬0-½âËø
    
    changePlaceList = []
    for place in clientData.PlaceIndexList:
        RuneData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_VPackItem % (packIndex, place))
        if not RuneData:
            continue
        RuneIsLock = ItemControler.GetRuneItemIsLock(RuneData)
        if changeLockState == RuneIsLock:
            continue
        RuneItemID = ItemControler.GetRuneItemID(RuneData)
        RuneItemPlusLV = ItemControler.GetRuneItemPlusLV(RuneData)
        updRuneData = ItemControler.GetRuneItemKeyData(RuneItemID, RuneItemPlusLV, changeLockState)
        ItemControler.SetVPackItemKeyData(curPlayer, packIndex, place, updRuneData, False)
        changePlaceList.append(place)
        
    if changePlaceList:
        ItemControler.Sync_VPackItem_Refresh(curPlayer, packIndex, changePlaceList)
        GameWorld.DebugLog("Ð޸ķûÓ¡Ëø¶¨×´Ì¬: changeLockState=%s, %s" % (changeLockState, changePlaceList))
    return

#// A5 78 ·ûÓ¡ºÏ³É #tagCMRuneCompound
#
#struct    tagCMRuneCompound
#
#{
#    tagHead        Head;
#    BYTE        Cnt;
#    BYTE        PackList[Cnt];    //ËùÔÚλÖà 0-±³°ü 1-·ûÓ¡¿×
#    BYTE        IndexList[Cnt];    //ÎïÆ·Ë÷Òý
#    DWORD        TagItemID;    //ºÏ³ÉÄ¿±êÎïÆ·ID
#};
def OnRuneCompound(index, clientData, tick):
    ##·ûÓ¡ºÏ³É
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    tagItemID = clientData.TagItemID
    packList = clientData.PackList
    indexList = clientData.IndexList
    GameWorld.DebugLog('    ·ûÓ¡ºÏ³É tagItemID=%s'%tagItemID)
    ipyData = IpyGameDataPY.GetIpyGameData('RuneCompound', tagItemID)
    if not ipyData:
        return
    materialsIDList = []
    materialsLVDict = {}
    indexList1 = [] #±³°üµÄ·ûÓ¡Ë÷Òý
    indexList2 = [] #¿×Ë÷Òý
    for i, placeType in enumerate(packList):
        index = indexList[i]
        if placeType == 0:
            runeData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_VPackItem % (ShareDefine.rptRune, index)) # ·ûÓ¡±³°üÖеÄÖµ
            indexList1.append(index)
        else:
            runeData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_Data % (index+1), 0)
            indexList2.append(index+1)
        if not runeData:
            continue
        runeItemID = ItemControler.GetRuneItemID(runeData)
        runeItemPlusLV = ItemControler.GetRuneItemPlusLV(runeData)
        materialsIDList.append(runeItemID) 
        materialsLVDict[runeItemID] = runeItemPlusLV
        
    
    needItemIDList = ipyData.GetNeedItem()
    if sorted(materialsIDList) != sorted(needItemIDList):
        GameWorld.DebugLog('    ·ûÓ¡ºÏ³É ²ÄÁϲ»¶Ô tagItemID=%s, materialsIDList=%s, needItemIDList=%s'%(tagItemID,materialsIDList,needItemIDList))
        return
    
    if 0 not in packList:
        #Èç¹ûûÓб³°üµÄ²ÄÁÏÒªÅжϸñ×ÓÊý
        emptySpace = ItemCommon.GetItemPackSpace(curPlayer, ShareDefine.rptRune, 1)
        if emptySpace < 1:
            PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_676165", [ShareDefine.rptRune])
            GameWorld.DebugLog('    ·ûÓ¡ºÏ³É ±³°ü¸ñ×ÓÊýÁ¿²»×ã1¸ö')
            return 
        
    needMJ = ipyData.GetNeedMJ()
    infoDict = {"TagItemID":tagItemID}
    if not PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_Ysog, needMJ, ChConfig.Def_Cost_ItemProduce, infoDict):
        return
     
    totalPoint = 0
    for itemID in materialsIDList:
        decompose = 0
        RuneItemPlusLV = materialsLVDict.get(itemID,0)
        for lv in range(1, RuneItemPlusLV + 1):
            decompose += GetRuneNeedExp(itemID, lv)
        totalPoint += decompose
    totalPoint = int(totalPoint)
    tagItemLV = 0

    runeMaxLV = GetRuneMaxLV(tagItemID)
    for lv in xrange(1, runeMaxLV):
        needExp = GetRuneNeedExp(tagItemID, lv)
        if totalPoint < needExp:
            break
        tagItemLV = lv
        totalPoint -= needExp
    
    #ɾ³ý²ÄÁÏÎïÆ·
    if indexList1:
        ItemCommon.DelVPackItem(curPlayer, ShareDefine.rptRune, indexList1, ChConfig.ItemDel_Rune)
    if indexList2:
        for index in indexList2:
            srcRuneData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_Data % index, 0)
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_Rune_Data % index, 0)
            dataDict = {'doType':'RuneCompound', 'srcRuneData':srcRuneData, 'desRuneData':0}
            DataRecordPack.Cache_FightPowerChangeInfo(curPlayer, ChConfig.PowerDownType_Rune, dataDict)
            
        Sync_RuneInfo(curPlayer)
        RefreshRuneAttr(curPlayer)
        PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState()
        
    #¸øÐÂÎïÆ·
    curItem = ItemControler.GetOutPutItemObj(tagItemID)
    curItem.SetUserAttr(ShareDefine.Def_IudetRuneLV, tagItemLV)
    curItem.SetUserAttr(ShareDefine.Def_IudetRuneSource, ChConfig.Item_Source_Compound)
    PlayerItemControler = ItemControler.PlayerItemControler(curPlayer)
    PlayerItemControler.PutInItem(ShareDefine.rptRune, curItem, event=[ChConfig.ItemGive_RuneCompound, False, {'indexList1':indexList1,'indexList2':indexList2}])
    curPlayer.Sync_MakeItemAnswer(ShareDefine.Def_mitRuneCompound, 1)
    return


## Ë¢·ûÓ¡ÊôÐÔ
def RefreshRuneAttr(curPlayer):
    allAttrList = [{} for _ in range(4)]
    runeHoleCnt = IpyGameDataPY.GetFuncCfg("RuneUnlock", 4)
    for holeNum in xrange(1, runeHoleCnt + 1):
        runeData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_Data % holeNum, 0)
        if not runeData:
            continue
        runeItemID = ItemControler.GetRuneItemID(runeData)
        runeItemPlusLV = ItemControler.GetRuneItemPlusLV(runeData)
        
        attrDict = GetRuneAttrValue(runeItemID, runeItemPlusLV)
        
        if not attrDict:
            continue
        GameWorld.DebugLog('    Ë¢·ûÓ¡ÊôÐÔ holeNum=%s, attrDict=%s' % (holeNum, attrDict))
        for attrID, attrValue in attrDict.items():
            PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrList)
        
    # ±£´æ¼ÆËãÖµ
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Rune, allAttrList)
    return



## ͬ²½¿Í»§¶Ë
def Sync_RuneInfo(curPlayer):
    runeHoleCnt = IpyGameDataPY.GetFuncCfg("RuneUnlock", 4)
    if not runeHoleCnt:
        return
    RuneInfoPack = ChPyNetSendPack.tagMCRuneInfo()
    RuneInfoPack.Clear()
    RuneInfoPack.RuneHoleOpenState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_HoleOpenState, 0)
    RuneInfoPack.RuneDataList = []
    for RuneNum in xrange(1, runeHoleCnt + 1):
        RuneData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Rune_Data % RuneNum, 0)
        RuneInfoPack.RuneDataList.append(RuneData)
    RuneInfoPack.Count = len(RuneInfoPack.RuneDataList)
    NetPackCommon.SendFakePack(curPlayer, RuneInfoPack)
    return