#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Player.PlayerTreasure
#
# @todo:Ñ°±¦
# @author hxp
# @date 2018-04-28
# @version 1.0
#
# ÏêϸÃèÊö: ÊÖÓÎÑ°±¦, Ö§³Öµ¥³é¡¢Á¬³é
#
#-------------------------------------------------------------------------------
#"""Version = 2018-04-28 16:00"""
#-------------------------------------------------------------------------------

import GameWorld
import PlayerRune
import IpyGameDataPY
import FormulaControl
import ChPyNetSendPack
import PlayerControl
import ItemControler
import NetPackCommon
import PlayerActLunhuidian
import PlayerActYunshi
import PlayerActivity
import PlayerSuccess
import PlayerGoldInvest
import OpenServerActivity
import PlayerBillboard
import ShareDefine
import ItemCommon
import PlayerHero
import PyGameData
import ChConfig

import random

(
CostType_Money, # ÏûºÄ»õ±Ò 0
CostType_DayFree, # ÿÈÕÃâ·Ñ 1
CostType_Item, # ÏûºÄµÀ¾ß 2
CostType_ADFree, # ¹ã¸æÃâ·Ñ 3
) = range(4)
CostFreeTypes = [CostType_DayFree, CostType_ADFree]

# Ñ°±¦ÀàÐÍ£º >=100µÄΪ²ß»®×ÔÐÐÅäÖõÄ×Ô¶¨ÒåÑ°±¦ÀàÐÍ£¬<100µÄÓÃÓÚÖ¸¶¨ÏµÍ³Ñ°±¦¹¦ÄÜ
TreasureTypeList = (
TreasureType_Jipin, # ¼«Æ·Ñ°±¦ 1
TreasureType_Rune, # ·ûÓ¡Ñ°±¦ 2
TreasureType_Jueshi, # ¾øÊÀÑ°±¦ 3
TreasureType_GatherTheSoul, # ¾Û»êÁÔħ 4
TreasureType_Gubao, # ¹Å±¦Ñ°±¦ 5
) = range(1, 1 + 5)

TreasureType_HeroComm = 11 # Ó¢ÐÛÕÐļ - ÆÕͨ
TreasureType_HeroHigh = 12 # Ó¢ÐÛÕÐļ - ¸ß¼¶
TreasureType_HeroScore = 13 # Ó¢ÐÛÕÐļ - »ý·Ö
#Î佫ÕÐļµÄËùÓÐÀàÐÍ
TreasureType_HeroCallList = [TreasureType_HeroComm, TreasureType_HeroHigh, TreasureType_HeroScore]

def OnTreasureLogin(curPlayer):
    Sync_TreasureInfo(curPlayer)
    return

def OnDay(curPlayer):
    syncTypeList = []
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for i in xrange(ipyDataMgr.GetTreasureSetCount()):
        ipyData = ipyDataMgr.GetTreasureSetByIndex(i)
        treasureType = ipyData.GetTreasureType()
        if not curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureCountToday % (treasureType)) and \
            not curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureFreeCount % (treasureType)):
            continue
        syncTypeList.append(treasureType)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureCountToday % (treasureType), 0)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureFreeCount % (treasureType), 0)
        
        # ÿÈÕÐÄÔ¸ÖØÖÃ
        wishLibSelect = ipyData.GetWishLibSelect()
        wishReset = ipyData.GetWishReset()
        if wishReset == 1:
            for libIDStr, wishCnt in wishLibSelect.items():
                for wishIndex in range(wishCnt):
                    wishID, outCnt = GetWishInfo(curPlayer, treasureType, libIDStr, wishIndex)
                    SetWishInfo(curPlayer, treasureType, libIDStr, wishIndex, wishID, 0)
                    GameWorld.DebugLog("Ñ°±¦Ã¿ÈÕÐÄÔ¸ÖØÖÃ: treasureType=%s,libID=%s,wishIndex=%s,wishID=%s,×òÈÕÐÄÔ¸²ú³ö´ÎÊý=%s" 
                                       % (treasureType, libIDStr, wishIndex, wishID, outCnt))
                    
    if syncTypeList:
        Sync_TreasureInfo(curPlayer, syncTypeList)
    return

def ResetTreasureType(curPlayer, treasureTypeList):
    ## ÖØÖÃÑ°±¦ÀàÐÍÊý
    for treasureType in treasureTypeList:
        setIpyData = IpyGameDataPY.GetIpyGameData("TreasureSet", treasureType)
        if not setIpyData:
            continue
        recycleItemMail = setIpyData.GetRecycleItemMail()
        costItemID = setIpyData.GetCostItemID()
        if recycleItemMail and costItemID:
            ItemControler.RecycleItem(curPlayer, costItemID, recycleItemMail)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureFreeCount % (treasureType), 0)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureCount % (treasureType), 0)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureCountEx % (treasureType), 0)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureCountToday % (treasureType), 0)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureLuck % (treasureType), 0)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureCntAward % (treasureType), 0)
        
        gridNumMaxLimitInfo = setIpyData.GetGridNumMaxLimitInfo()
        for gridNumStr in gridNumMaxLimitInfo.keys():
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureGridCnt % (treasureType, int(gridNumStr)), 0)
            
    Sync_TreasureInfo(curPlayer, treasureTypeList)
    return

def IsActTreasureType(curPlayer, treasureType):
    ## ÊÇ·ñ»î¶¯ÖеÄÑ°±¦ÀàÐÍ
    if PlayerActYunshi.IsActTreasureType(curPlayer, treasureType):
        return True
    return False

def GetWishInfo(curPlayer, treasureType, libID, wishIndex):
    ## ÐÄÔ¸ÐÅÏ¢
    # @return: ÐÄÔ¸ID, ÒѲú³ö´ÎÊý
    info = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureWish % (treasureType, libID, wishIndex))
    wishID, outCnt = info / 100, info % 100
    return wishID, outCnt
def SetWishInfo(curPlayer, treasureType, libID, wishIndex, wishID, outCnt):
    info = wishID * 100 + min(outCnt, 99)
    info = PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureWish % (treasureType, libID, wishIndex), info)
    return info

#// A5 69 Ñ°±¦ÐÄÔ¸ÎïÆ·Ñ¡Ôñ #tagCSTreasureWishSelect
#
#struct tagCSTreasureWishSelect
#{
#    tagHead        Head;
#    BYTE        TreasureType;    //Ñ°±¦ÀàÐÍ
#    BYTE        WishCnt;
#    WORD        WishIDList[WishCnt];    // Ñ¡ÔñµÄÑ°±¦ÎïÆ·¿âÖеÄÊý¾ÝID£¬×¢Òâ²»ÊÇ¿âID
#};
def OnTreasureWishSelect(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    treasureType = clientData.TreasureType
    reqSelectWishIDList = clientData.WishIDList
    
    setIpyData = IpyGameDataPY.GetIpyGameData("TreasureSet", treasureType)
    if not setIpyData:
        return
    wishLibSelect = setIpyData.GetWishLibSelect()    
    if not wishLibSelect:
        GameWorld.DebugLog("¸ÃÑ°±¦ÀàÐÍûÓÐÐÄÔ¸ÎïÆ·¹¦ÄÜ! treasureType=%s" % (treasureType))
        return
    
    GameWorld.DebugLog("Ñ°±¦Ñ¡ÔñÐÄÔ¸ÎïÆ·: treasureType=%s,reqSelectWishIDList=%s" % (treasureType, reqSelectWishIDList))
    
    selectLibItemDict = {} # ÖØÐÂÑ¡ÔñµÄÐÄÔ¸ÎïÆ·»ã×Ü {libID:[wishID, ...], ...}
    for wishID in reqSelectWishIDList:
        libItemIpyData = IpyGameDataPY.GetIpyGameDataByCondition("TreasureItemLib", {"ID":wishID}, False)
        if not libItemIpyData:
            return
        
        itemID = libItemIpyData.GetItemID()
        if not libItemIpyData.GetWishOutCnt():
            GameWorld.DebugLog("·ÇÐÄÔ¸ÎïÆ·£¬²»¿ÉÑ¡Ôñ! wishID=%s" % (wishID))
            return
        
        # °´ËùÊô¿â¹éÀà»ã×Ü
        libID = libItemIpyData.GetLibID()
        if libID not in selectLibItemDict:
            selectLibItemDict[libID] = []
        selectLibWishIDList = selectLibItemDict[libID]
        if wishID not in selectLibWishIDList:
            selectLibWishIDList.append(wishID)
            
        # Î佫ÕÐļ£¬¶îÍâÏÞÖÆ
        if treasureType in TreasureType_HeroCallList:
            heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", itemID)
            if not heroIpyData:
                return
            if heroIpyData.GetRecruitBySelf() and not PlayerHero.GetHeroActivite(curPlayer, itemID):
                GameWorld.DebugLog("ÐèÒª¼¤»î±¾ÌåµÄÎ佫δ¼¤»î²»¿ÉÑ¡Ôñ£¡itemID=%s" % itemID)
                return
            
    hisOutDict = {} # ÀúÊ·Ñ¡ÔñÒѲú³ö¹ýµÄÐÄÔ¸ÎïÆ·¼Ç¼ {wishID:outCnt, ...}
    for libIDStr, wishCnt in wishLibSelect.items():
        libID = int(libIDStr)
        selectLibWishIDList = selectLibItemDict.get(libID, [])
        if len(selectLibWishIDList) != wishCnt:
            GameWorld.DebugLog("Ñ¡ÔñÐÄÔ¸¿âµÄÎïÆ·ÊýÁ¿ÓëÉ趨µÄÐÄÔ¸ÎïÆ·ÊýÁ¿²»Ò»Ö£¡libID=%s,wishCnt=%s,selectCnt=%s,%s" 
                               % (libID, wishCnt, len(selectLibWishIDList), selectLibWishIDList))
            return
        
        for wishIndex in range(wishCnt):
            wishID, outCnt = GetWishInfo(curPlayer, treasureType, libID, wishIndex)
            if not outCnt:
                continue
            if wishID not in selectLibWishIDList:
                GameWorld.DebugLogEx("ÒѾ­²ú³ö¹ýµÄÐÄÔ¸ÎïÆ·²»¿É´ÓÑ¡ÔñÖÐÈ¥³ý! outCnt=%s,wishID=%s not in %s", outCnt, wishID, selectLibWishIDList)
                return
            hisOutDict[wishID] = outCnt
            
    # Ñé֤ͨ¹ý£¬±£´æ
    for libID, wishIDList in selectLibItemDict.items():
        for wishIndex, wishID in enumerate(wishIDList):
            outCnt = hisOutDict.get(wishID, 0)
            SetWishInfo(curPlayer, treasureType, libID, wishIndex, wishID, outCnt)
            GameWorld.DebugLog("±£´æÐÄԸѡÔñ: libID=%s,wishIndex=%s,wishID=%s,outCnt=%s" % (libID, wishIndex, wishID, outCnt))
            
    Sync_TreasureInfo(curPlayer, [treasureType])
    return

                
#// A5 68 ÇëÇóÑ°±¦ #tagCMRequestTreasure
#
#struct tagCMRequestTreasure
#{
#    tagHead        Head;
#    BYTE        TreasureType;    //Ñ°±¦ÀàÐÍ
#    BYTE        TreasureIndex;       //Ñ°±¦Ë÷Òý
#    BYTE        CostType;    //ÏûºÄÀàÐÍ£º0-ĬÈÏÏÉÓñ£»1-Ãâ·Ñ´ÎÊý£»2-Ñ°±¦µÀ¾ß
#};
def OnRequestTreasure(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    treasureType = clientData.TreasureType
    treasureIndex = clientData.TreasureIndex
    costType = clientData.CostType
    DoTreasure(curPlayer, treasureType, costType, treasureIndex)
    return

def DoTreasure(curPlayer, treasureType, costType, treasureIndex=0):
    playerLV = curPlayer.GetLV()
    playerID = curPlayer.GetPlayerID()
    GameWorld.DebugLog("Íæ¼ÒÑ°±¦: treasureType=%s,treasureIndex=%s,costType=%s,playerLV=%s" 
                       % (treasureType, treasureIndex, costType, playerLV), playerID)
    
    setIpyData = IpyGameDataPY.GetIpyGameData("TreasureSet", treasureType)
    if not setIpyData:
        return
    if setIpyData.GetIsActType():
        if not IsActTreasureType(curPlayer, treasureType):
            GameWorld.ErrLog("¸ÃÑ°±¦ÀàÐͷǻÖУ¬ÎÞ·¨Ñ°±¦! treasureType=%s" % (treasureType), playerID)
            return
    treasureCountList = setIpyData.GetTreasureCountList() # Ñ°±¦»ñµÃ¸öÊýÁбí
    if not treasureCountList:
        GameWorld.DebugLog("ûÓÐÑ°±¦´ÎÊýÁбíÅäÖÃ!", playerID)
        return
    if costType == CostType_ADFree:
        treasureIndex = 0
        GameWorld.DebugLog("¹ã¸æÑ°±¦Ç¿ÖÆÉèÖÃ: treasureIndex=%s" % treasureIndex, playerID)
    if treasureIndex < 0 or treasureIndex >= len(treasureCountList):
        GameWorld.ErrLog("Ñ°±¦´ÎÊýË÷Òý²»´æÔÚ!treasureType=%s,treasureIndex=%s" % (treasureType, treasureIndex), playerID)
        return
    treasureCount = treasureCountList[treasureIndex]
    if not treasureCount:
        GameWorld.DebugLog("ûÓÐÑ°±¦´ÎÊýÅäÖÃ!", playerID)
        return
    dailyMaxCount = setIpyData.GetDailyMaxCount()
    curTreasureCountToday = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureCountToday % (treasureType)) # ½ñÈÕÒÑÑ°±¦´ÎÊý
    updTreasureCountToday = curTreasureCountToday + treasureCount
    if dailyMaxCount and updTreasureCountToday > dailyMaxCount:
        GameWorld.DebugLog("Ñ°±¦ºó½«³¬¹ýÿÈÕ×î´ó´ÎÊý£¬ÎÞ·¨Ñ°±¦! treasureCount(%s) + curTreasureCountToday(%s) = %s > %s" 
                           % (treasureCount, curTreasureCountToday, updTreasureCountToday, dailyMaxCount), playerID)
        return
    
    packType = setIpyData.GetPackType()
    if setIpyData.GetCheckPack():
        if not ItemCommon.CheckPackHasSpace(curPlayer, packType, True):
            GameWorld.DebugLog("¶ÔӦѰ±¦±³°üûÓпոñ×Ó!packType=%s" % packType, playerID)
            return
        
    # Ãâ·Ñ´ÎÊý
    if costType == CostType_DayFree:
        dailyFreeCount = setIpyData.GetDailyFreeCount()
        if not dailyFreeCount:
            GameWorld.ErrLog("¸ÃÑ°±¦ÀàÐÍË÷Òý²»Ö§³ÖÃâ·Ñ´ÎÊýÑ°±¦!treasureType=%s,treasureIndex=%s" % (treasureType, treasureIndex), playerID)
            return
        freeCountToday = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureFreeCount % (treasureType))
        updFreeCountToday = freeCountToday + treasureCount
        if updFreeCountToday > dailyFreeCount:
            GameWorld.DebugLog("½ñÈÕÃâ·Ñ´ÎÊý²»×㣬ÎÞ·¨Ê¹ÓÃÃâ·ÑÑ°±¦! freeCountToday=%s + %s > %s" % (freeCountToday, treasureCount, dailyFreeCount), playerID)
            return
    # ¹ã¸æÃâ·Ñ
    elif costType == CostType_ADFree:
        pass
    # Ñ°±¦µÀ¾ß, ĿǰĬÈÏÏûºÄ1¸ö
    elif costType == CostType_Item:
        costItemID = setIpyData.GetCostItemID()
        costItemList = setIpyData.GetCostItemCountList() # ÏûºÄµÀ¾ßÎïÆ·IDÁбí
        if not costItemID or not costItemList or treasureIndex >= len(costItemList):
            GameWorld.ErrLog("¸ÃÑ°±¦ÀàÐÍË÷Òý²»Ö§³ÖÏûºÄµÀ¾ßÑ°±¦!treasureType=%s,treasureIndex=%s" % (treasureType, treasureIndex), playerID)
            return
        costItemNeedCount = costItemList[treasureIndex]
        if not costItemID or not costItemNeedCount:
            return
        costItemIndexList, bindCnt, unBindCnt = ItemCommon.GetPackItemBindStateIndexInfo(curPlayer, costItemID)
        lackCount = max(0, costItemNeedCount - bindCnt - unBindCnt)
        delCostItemCount = costItemNeedCount - lackCount
        lackCountCostMoney = 0
        if lackCount > 0:
            costGoldList = setIpyData.GetCostMoneyList() # ÏûºÄ»õ±ÒÁбí
            costGoldType = setIpyData.GetCostMoneyType() # ÏûºÄ»õ±ÒÀàÐÍ
            if not costGoldType or not costGoldList or treasureIndex >= len(costGoldList) or not costGoldList[treasureIndex]:
                GameWorld.ErrLog("Ñ°±¦µÀ¾ß²»×㣬¸ÃÑ°±¦ÀàÐͲ»Ö§³ÖÏûºÄ»õ±ÒÑ°±¦! treasureType=%s,treasureIndex=%s" % (treasureType, treasureIndex), playerID)
                return
            costGold = costGoldList[treasureIndex]
            perItemGold = int(costGold / costItemNeedCount) # µÀ¾ßµ¥¼Û
            lackCountCostMoney = perItemGold * lackCount
            GameWorld.DebugLog("Ñ°±¦µÀ¾ß²»×㣬ʹÓöÔÓ¦»õ±Ò¿Û³ý: costItemID=%s,perItemGold=%s,lackCount=%s,lackCountCostMoney=%s,costGoldType=%s" 
                               % (costItemID, perItemGold, lackCount, lackCountCostMoney, costGoldType), playerID)
            if lackCountCostMoney:
                moneyType = costGoldType
                infoDict = {ChConfig.Def_Cost_Reason_SonKey:costItemID}
                if not PlayerControl.HaveMoney(curPlayer, moneyType, lackCountCostMoney):
                    return
            else:
                GameWorld.DebugLog("Ñ°±¦ÏûºÄµÀ¾ß²»×ã!costItemID=%s,costItemNeedCount=%s,bindCnt=%s,unBindCnt=%s" 
                                   % (costItemID, costItemNeedCount, bindCnt, unBindCnt), playerID)
                return
        
    # ÏÉÓñÑ°±¦
    else:
        costGoldList = setIpyData.GetCostMoneyList() # ÏûºÄ»õ±ÒÁбí
        costGoldType = setIpyData.GetCostMoneyType() # ÏûºÄ»õ±ÒÀàÐÍ
        if not costGoldType or not costGoldList or treasureIndex >= len(costGoldList):
            GameWorld.ErrLog("¸ÃÑ°±¦ÀàÐÍË÷Òý²»Ö§³ÖÏûºÄ»õ±ÒÑ°±¦!treasureType=%s,treasureIndex=%s" % (treasureType, treasureIndex), playerID)
            return
        costGold = costGoldList[treasureIndex]
        if not costGold:
            return
        
        if not PlayerControl.HaveMoney(curPlayer, costGoldType, costGold):
            return
        
    ipyData = IpyGameDataPY.InterpolationSearch("TreasureHouse", "MinLV", playerLV, {"TreasureType":treasureType})
    if not ipyData:
        GameWorld.ErrLog("ÕÒ²»µ½¸ÃµÈ¼¶¶ÔӦѰ±¦¿âÅäÖÃ!treasureType=%s,curLV=%s" % (treasureType, curPlayer.GetLV()), playerID)
        return
    
    setLuckyGridNum = setIpyData.GetLuckyGridNum() # ±êµÄ¸ñ×Ó
    luckyItemRateInfo = ipyData.GetLuckyItemRateInfo()
    luckyItemRateDict = {int(k):v for k, v in luckyItemRateInfo.items()}
    luckyValueList = sorted(luckyItemRateDict.keys())
    luckyGridNumList = [] # ÐÒÔ˸ñ×Ó±àºÅÁбí
    luckFormula = setIpyData.GetLuckyRateFormat() # ÐÒÔËÎïÆ·¸ÅÂʹ«Ê½
    addLuck = setIpyData.GetOnceLucky() # Ôö¼ÓÐÒÔËÖµ
    maxLuck = max(luckyValueList) if luckyValueList else 0 # ÂúÐÒÔËÖµ
    updLuck = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureLuck % (treasureType)) # µ±Ç°ÐÒÔËÖµ
    GameWorld.DebugLog("updLuck=%s,maxLuck=%s,setLuckyGridNum=%s,luckyItemRateDict=%s" % (updLuck, maxLuck, setLuckyGridNum, luckyItemRateDict), playerID)
    
    curTreasureCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureCount % (treasureType)) # µ±Ç°ÒÑÑ°±¦´ÎÊý
    updTreasureCount = curTreasureCount
    
    beSureCountDict = ipyData.GetGridItemRateList3() # µÚx´Î±Ø³ö²ú³ö¸ñ×Ó±àºÅ±ýͼ
    ensureCount = setIpyData.GetEnsureCount() # ÿ¶àÉٴδ¥·¢±£µ×²ú³ö¿â
    ensureRateList = ipyData.GetGridItemRateList2()
    GameWorld.DebugLog("beSureCountDict=%s" % beSureCountDict, playerID)
    GameWorld.DebugLog("ensureCount=%s, %s" % (ensureCount, ensureRateList), playerID)
    notifyGridNumList = setIpyData.GetNotifyGridNumList() # ¶îÍâÐèÒª¹ã²¥µÄ¸ñ×Ó£¬ÐÒÔ˱سö¡¢´ÎÊý±Ø³ö¿É²»ÅäÖÃ
    notifyKeyDict = setIpyData.GetNotifyKeyDict()
    gridNumMaxLimitInfo = setIpyData.GetGridNumMaxLimitInfo() # {"¸ñ×Ó":×î´ó¿É²ú³ö´ÎÊý, ...}
    gridNumCountInfo = {} # ÓÐÏÞÖƲú³ö´ÎÊýµÄ¸ñ×ÓÒѾ­²ú³öÊý
    for gridNumStr in gridNumMaxLimitInfo.keys():
        gridNumCountInfo[int(gridNumStr)] = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureGridCnt % (treasureType, gridNumStr))
    GameWorld.DebugLog("gridNumMaxLimitInfo=%s,gridNumCountInfo=%s" % (gridNumMaxLimitInfo, gridNumCountInfo), playerID)
    
    treasureCountEx = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureCountEx % (treasureType)) # µ±Ç°µÚx´Îµ¥³é¡¢x³é
    curIndexCount, maxIndexCount = 0, 0
    beSureCountByIndexDict = {}
    beSureCountByIndexList = ipyData.GetGridItemRateList4() # µÚx´Îx³é±Ø³ö£¬×î¶àÖ§³Ö¶¨ÖƵ½9´Î
    if beSureCountByIndexList and treasureIndex < len(beSureCountByIndexList):
        beSureCountByIndexDict = beSureCountByIndexList[treasureIndex]
        maxIndexCount = min(9, max(beSureCountByIndexDict))
        curIndexCount = GameWorld.GetDataByDigitPlace(treasureCountEx, treasureIndex) + 1
    beSureCountByIndexCfg = []
    if curIndexCount <= maxIndexCount and curIndexCount in beSureCountByIndexDict:
        beSureCountByIndexCfg = beSureCountByIndexDict[curIndexCount]
        
    gridItemInfoDict = ipyData.GetGridItemInfo() # ¸ñ×Ó¶ÔÓ¦ÎïÆ·ÐÅÏ¢ {"¸ñ×Ó±àºÅ":[ÎïÆ·ID, ÊýÁ¿], ...}
    gridLibInfoDict = ipyData.GetGridLibInfo() # ¸ñ×Ó±àºÅ¶ÔÓ¦¿âID {"±àºÅ":ÎïÆ·¿âID, ...}
    
    # ÐÄÔ¸
    wishSelectState = False # ÐÄÔ¸ÎïÆ·ÊÇ·ñÒÑÑ¡Ôñ
    canOutWishDict = {} # »¹¿É²ú³öµÄÐÄÔ¸ÎïÆ· {libID:{wishID:[wishIndex, canOut], ...}, ...}
    wishOutputRule = setIpyData.GetWishOutput() # ÐÄÔ¸²ú³ö¹æÔò£ºÐÄÔ¸²ú³öÍê±Ïºó£º  0 - ¿É¼ÌÐø²ú³ö¸Ã¿âÎïÆ·£» 1 - ²»¿ÉÔÙ²ú³ö¸Ã¿âÎïÆ·
    wishLibSelect = setIpyData.GetWishLibSelect()
    for libIDStr, selectCnt in wishLibSelect.items():
        libID = int(libIDStr)
        if libID not in canOutWishDict:
            canOutWishDict[libID] = {}
        for wishIndex in range(selectCnt):
            wishID, outCnt = GetWishInfo(curPlayer, treasureType, libID, wishIndex)
            if not wishID:
                continue
            wishSelectState = True
            libItemIpyData = IpyGameDataPY.GetIpyGameDataByCondition("TreasureItemLib", {"ID":wishID}, False)
            if not libItemIpyData:
                continue
            outCntLimit = libItemIpyData.GetWishOutCnt()
            if not outCntLimit:
                # ·ÇÐÄÔ¸ÎïÆ·
                continue
            if outCnt >= outCntLimit:
                # ¸ÃÐÄÔ¸ÎïÆ·²ú³ö´ÎÊýÒÑÓÃÍê
                continue
            libWishCanOutDict = canOutWishDict[libID]
            canOut = outCntLimit - outCnt
            libWishCanOutDict[wishID] = [wishIndex, canOut]
    if canOutWishDict:
        if not wishSelectState:
            GameWorld.DebugLog("ÐÄÔ¸ÎïÆ·»¹Î´Ñ¡Ôñ!", playerID)
        else:
            GameWorld.DebugLog("»¹¿É²ú³öµÄÐÄÔ¸¿â¶ÔÓ¦WishID»¹¿É²ú³ö´ÎÊý: %s" % canOutWishDict, playerID)
            
    # µ¥³é²ú³öÓÅÏȼ¶£º ÐÒÔËÎïÆ· > ±Ø³ö > ±£µ× > ÆÕͨ
    # Á¬³éûÓÐÓÅÏȼ¶ÏÞÖÆ£¬Ö»ÒªÂú×ãÌõ¼þ¼´¿É²ú³ö
    luckyOut = False # ÐÒÔËÎïÆ·ÀíÂÛ²ú³ö״̬£¬²»Ò»¶¨ÊÇÕæʵ²ú³ö£¬¿ÉÄÜÊÜÖÕÉí¿¨ÏÞÖÆ
    getGridResult = []
    for tIndex in range(treasureCount):
        updLuck = min(updLuck + addLuck, maxLuck)
        stageLuck, luckItemRateList = __getLuckyRateInfo(updLuck, luckyItemRateDict, luckyValueList)
        luckyGridNumList = []
        for _, gridNum in luckItemRateList:
            luckyGridNumList.append(gridNum)
            
        updTreasureCount += 1
        GameWorld.DebugLog("%s,ÀۼƴÎÊý=%s,ÐÒÔË=%s,½×¶ÎÐÒÔË=%s,ÐÒÔ˱ýͼ=%s" % (tIndex + 1, updTreasureCount, updLuck, stageLuck, luckItemRateList), playerID)
        if gridNumMaxLimitInfo:
            GameWorld.DebugLog("    gridNumMaxLimitInfo=%s,gridNumCountInfo=%s" % (gridNumMaxLimitInfo, gridNumCountInfo), playerID)
        baseRateList, commItemRateList = GetUpdLuckyItemRateList(ipyData, luckyGridNumList, updLuck, luckFormula, costType) # ³£¹æ²ú³öÎïÆ·¸ñ×Ó±ýͼ£¬ÐÒÔËÎïÆ·¸ÅÂÊÒѱä¸ü
        commItemRateList = GetRemoveLimitGridRateList(commItemRateList, gridNumCountInfo, gridNumMaxLimitInfo)        
        GameWorld.DebugLog("    »ù´¡²ú³ö±ýͼ=%s" % baseRateList, playerID)
        
        curRateList = [] # ¿ÉÄÜ»á¸Ä±ä±ýͼ£¬Ã¿´Î³é½±Ê¹ÓÃеıýͼ¶ÔÏ󣬲»Òª¸Ä±äÅäÖõıýͼ¸ÅÂÊ
        
        # µÚx´Îx³é±Ø³ö£¬ÓÅÏȼ¶×î¸ß£¬ÎÞÊÓÆäËû
        if not curRateList and beSureCountByIndexCfg:
            if tIndex == 0:
                curRateList = [[10000, beSureCountByIndexCfg[0]]]
            else:
                curRateList = beSureCountByIndexCfg[1]
            GameWorld.DebugLog("    ¡¾µÚx´Îx³é±Ø³ö¡¿: treasureIndex=%s,curIndexCount=%s,%s" 
                               % (treasureIndex, curIndexCount, curRateList), playerID)
            
        # ÂúÐÒÔ˱سö
        if not curRateList and stageLuck and updLuck >= stageLuck and luckItemRateList:
            luckyOut = True
            if treasureType in TreasureType_HeroCallList and not PlayerGoldInvest.GetInvestState(curPlayer, ChConfig.InvestType_Life):
                GameWorld.DebugLog("    ¡¾ÂúÐÒÔ˱سö±ýͼ¡¿: ÖÕÉí¿¨Î´¿ªÍ¨£¬Î佫ÕÐļÐÒÔ˲»²ú³ö", playerID)
            else:
                curRateList = GetRemoveLimitGridRateList(luckItemRateList, gridNumCountInfo, gridNumMaxLimitInfo)
                GameWorld.DebugLog("    ¡¾ÂúÐÒÔ˱سö±ýͼ¡¿: %s" % curRateList, playerID)
                
        # ´ÎÊý±Ø³ö
        if not curRateList and updTreasureCount in beSureCountDict:
            besureGridRateList = beSureCountDict[updTreasureCount]
            curRateList = GetRemoveLimitGridRateList(besureGridRateList, gridNumCountInfo, gridNumMaxLimitInfo)
            GameWorld.DebugLog("    ¡¾µÚ%s´ÎÊý±Ø³ö±ýͼ¡¿: %s" % (updTreasureCount, curRateList), playerID)
            
        # Âú´ÎÊý±Ø³ö
        if not curRateList and ensureCount and updTreasureCount % ensureCount == 0 and ensureRateList:
            curRateList = GetRemoveLimitGridRateList(ensureRateList, gridNumCountInfo, gridNumMaxLimitInfo)
            GameWorld.DebugLog("    ¡¾Âú%s´ÎÊý±Ø³ö±ýͼ¡¿: %s" % (ensureCount, curRateList), playerID)
            
        doCount = 0
        while doCount <= 50: # ÏÞÖÆ×î´ó´ÎÊý
            doCount += 1
            if doCount > 1 or not curRateList: # ÖØÐÂËæ»úµÄĬÈÏʹÓó£¹æ±ýͼ
                curRateList = commItemRateList
                GameWorld.DebugLog("    ʹÓó£¹æ±ýͼ=%s" % curRateList, playerID)
                
            gridNum = GameWorld.GetResultByRandomList(curRateList)
            if gridNum in luckyGridNumList and gridNum in getGridResult:
                GameWorld.DebugLog("    ÐÒÔËÎïÆ·ÒѾ­³ö¹ý£¬²»ÔÙÖظ´²ú³ö£¡ gridNum=%s in %s" % (gridNum, getGridResult))
                continue
            
            # ÐÄÔ¸²ú³öÏÞÖÆ
            gridNumStr = str(gridNum)
            wishLibID = 0
            if wishLibSelect and gridNumStr in gridLibInfoDict and gridLibInfoDict[gridNumStr] in canOutWishDict:
                wishLibID = gridLibInfoDict[gridNumStr]
                if wishOutputRule == 1: # ÐÄÔ¸ÎïÆ·²ú³öÍê±Ïºó£¬²»¿ÉÔÙ²ú³ö¸Ã¿âÎïÆ·£¬¸ÃģʽÏ£¬Î´Ñ¡ÔñÐÄÔ¸µÄ£¬Ò²ÊÓΪÎ޿ɲú³öµÄÐÄÔ¸ÎïÆ·
                    if not canOutWishDict[wishLibID]:
                        GameWorld.DebugLog("    ûÓпɲú³öµÄÐÄÔ¸ÎïÆ·£¬²»²ú³ö£¡ gridNum=%s,wishLibID=%s" % (gridNum, wishLibID), playerID)
                        continue
                    
            if not gridNum:
                continue
            
            getGridResult.append(gridNum)
            GameWorld.DebugLog("    ±¾´Î²ú³ö: gridNum=%s, %s, doCount=%s" % (gridNum, getGridResult, doCount), playerID)
            if gridNum in luckyGridNumList or luckyOut:
                luckyOut = False
                if gridNum == setLuckyGridNum or updLuck >= maxLuck:
                    updLuck = 0
                else:
                    updLuck = stageLuck # Ö±½ÓÇл»µ½ÏÂÒ»½×¶ÎÐÒÔË
                if gridNum in luckyGridNumList:
                    GameWorld.DebugLog("    ¡¾²ú³öÐÒÔ˸ñ×Ó¡¿: gridNum=%s,updLuck=%s" % (gridNum, updLuck), playerID)
                else:
                    GameWorld.DebugLog("    ¡¾ÀíÂÛ²ú³öÐÒÔ˸ñ×Ó£¬Êµ¼ÊûÓвú³ö¡¿: gridNum=%s,updLuck=%s,luckyGridNumList=%s" % (gridNum, updLuck, luckyGridNumList), playerID)
            if wishLibID:
                GameWorld.DebugLog("    ¡¾²ú³öµÄÊÇÐÄÔ¸¿âÎïÆ·¡¿: gridNum=%s,wishLibID=%s" % (gridNum, wishLibID), playerID)
                
            if gridNum in gridNumCountInfo:
                gridNumCountInfo[gridNum] = gridNumCountInfo[gridNum] + 1
                GameWorld.DebugLog("    ¡¾¸üвú³ö´ÎÊý¡¿: gridNum=%s, %s" % (gridNum, gridNumCountInfo), playerID)
            break
        
    GameWorld.DebugLog("Ñ°±¦¸ñ×Ó½á¹û: getGridResult=%s" % getGridResult, playerID)
    if len(getGridResult) != treasureCount:
        GameWorld.ErrLog("Ñ°±¦Òì³££¬Êµ¼Ê»ñµÃÊýÁ¿ÓëÑ°±¦ÇëÇóÊý²»Í¬£¡treasureType=%s,treasureIndex=%s" % (treasureType, treasureIndex), playerID)
        return
    
    isBind = 0 # ÔÝʱĬÈϲ»°ó¶¨
    job = curPlayer.GetJob()
    jobItemList = ipyData.GetJobItemList()
    treasureResult = []
    randItemIDDict = IpyGameDataPY.GetFuncEvalCfg("TreasureSet", 2)
    
    wishAddOutDict = {} # ±¾´ÎÐÄÔ¸ÎïÆ·Ô¤¼ÆÔö¼Ó²ú³ö {wishID:addOut, ...}
    for gridNum in getGridResult:
        gridNum = str(gridNum)
        if gridNum in gridItemInfoDict:
            itemID, itemCount = gridItemInfoDict[gridNum]
            itemID = GetJobItem(job, itemID, jobItemList)
            if not itemID:
                GameWorld.ErrLog("Ñ°±¦¸ñ×ÓÎïÆ·IDÒì³£!treasureType=%s,gridNum=%s" % (treasureType, gridNum), playerID)
                return
            
            # Ëæ»ú²ú³öÎïÆ·
            if itemID in randItemIDDict:
                canRandItemList = []
                randItemIDList = randItemIDDict[itemID]
                for randItemID in randItemIDList:
                    if not __checkItemCanTreasure(curPlayer, treasureType, randItemID):
                        continue
                    canRandItemList.append(randItemID)
                if not canRandItemList:
                    GameWorld.ErrLog("Ñ°±¦Ëæ»ú¸ñ×ÓûÓпÉËæ»úµÄÎïÆ·!treasureType=%s,treasureIndex=%s,gridNum=%s,itemID=%s" 
                                     % (treasureType, treasureIndex, gridNum, itemID), playerID)
                    return
                itemID = random.choice(canRandItemList)
        # ¸ù¾ÝÎïÆ·¿âÀ´Ëæ»ú
        elif gridNum in gridLibInfoDict:
            libID = gridLibInfoDict[gridNum]
            libItemList = IpyGameDataPY.GetIpyGameDataList("TreasureItemLib", libID)
            if not libItemList:
                return
            
            libWishCanOutDict = canOutWishDict.get(libID, {})
            wishWeightList = [] # ÐÄÔ¸ÎïƷȨÖØ
            itemWeightList = []
            for libItem in libItemList:
                curID = libItem.GetID()
                itemWeight, itemID, itemCount = libItem.GetItemWeight(), libItem.GetItemID(), libItem.GetItemCount()
                if not itemWeight:
                    continue
                if not __checkItemCanTreasure(curPlayer, treasureType, itemID):
                    continue
                itemWeightList.append([itemWeight, [itemID, itemCount]])
                if curID in libWishCanOutDict:
                    _, canOut = libWishCanOutDict[curID]
                    if canOut - wishAddOutDict.get(curID, 0) > 0:
                        wishWeightList.append([itemWeight, [itemID, itemCount, curID]])
                        
            if not itemWeightList:
                GameWorld.ErrLog("Ñ°±¦Ëæ»ú¸ñ×ÓûÓпÉËæ»úµÄÎïÆ·!treasureType=%s,treasureIndex=%s,gridNum=%s,libID=%s" 
                                 % (treasureType, treasureIndex, gridNum, libID), playerID)
                return
            # ÓÅÏȲú³öÑ¡ÔñµÄÐÄÔ¸ÎïÆ·
            if wishWeightList:
                itemID, itemCount, curID = GameWorld.GetResultByWeightList(wishWeightList)
                wishAddOutDict[curID] = wishAddOutDict.get(curID, 0) + 1
                GameWorld.DebugLog("ÓÅÏȲú³öÐÄÔ¸ÎïÆ·: gridNum=%s,libID=%s,wishID=%s,itemID=%s" % (gridNum, libID, curID, itemID), playerID)
            else:
                itemID, itemCount = GameWorld.GetResultByWeightList(itemWeightList)
        else:
            GameWorld.ErrLog("Ñ°±¦¸ñ×Ó²»´æÔÚ!treasureType=%s,gridNum=%s" % (treasureType, gridNum), playerID)
            return
        
        isTrans = 0 # ÊÇ·ñת»¯
        treasureResult.append([gridNum, itemID, itemCount, isTrans])
        
    # ¿ÛÏûºÄ
    if costType == CostType_DayFree:
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureFreeCount % (treasureType), updFreeCountToday)
        GameWorld.DebugLog("ÏûºÄÃâ·Ñ´ÎÊý£¬¸üнñÈÕÒÑʹÓÃÃâ·Ñ´ÎÊý: %s" % updFreeCountToday, playerID)
    elif costType == CostType_ADFree:
        GameWorld.DebugLog("¹ã¸æÑ°±¦Ãâ·Ñ", playerID)
    elif costType == CostType_Item:
        ItemCommon.DelCostItemByBind(curPlayer, costItemIndexList, bindCnt, unBindCnt, delCostItemCount, ChConfig.ItemDel_Treasure)
        GameWorld.DebugLog("¿Û³ýÑ°±¦µÀ¾ß,costItemID=%s,delCostItemCount=%s" % (costItemID, delCostItemCount), playerID)
        if lackCountCostMoney:
            infoDict = {"TreasureType":treasureType, "TreasureIndex":treasureIndex, "CostItemID":costItemID, "LackCount":lackCount}
            PlayerControl.PayMoney(curPlayer, moneyType, lackCountCostMoney, ChConfig.Def_Cost_Treasure, infoDict, lackCount)
    else:
        infoDict = {"TreasureType":treasureType, "TreasureIndex":treasureIndex}
        PlayerControl.PayMoney(curPlayer, costGoldType, costGold, ChConfig.Def_Cost_Treasure, infoDict)
        GameWorld.DebugLog("¿Û³ý»õ±Ò,costGoldType=%s,costGold=%s" % (costGoldType, costGold), playerID)
        
    # ¼ÓÊý¾Ý
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureCountToday % (treasureType), updTreasureCountToday)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureCount % (treasureType), updTreasureCount)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureLuck % (treasureType), updLuck)
    for gridNum, updCount in gridNumCountInfo.items():
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureGridCnt % (treasureType, gridNum), updCount)
    if curIndexCount <= maxIndexCount:
        treasureCountEx = GameWorld.ChangeDataByDigitPlace(treasureCountEx, treasureIndex, curIndexCount)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureCountEx % (treasureType), treasureCountEx)
        GameWorld.DebugLog("¸üеÚx´Îx³é´ÎÊý: treasureIndex=%s,curIndexCount=%s,maxIndexCount=%s,treasureCountEx=%s" % (treasureIndex, curIndexCount, maxIndexCount, treasureCountEx), playerID)
    # ÐÄÔ¸²ú³ö´ÎÊý
    for curID, addOut in wishAddOutDict.items():
        for libID, libWishCanOutDict in canOutWishDict.items():
            if curID not in libWishCanOutDict:
                continue
            wishIndex, canOut = libWishCanOutDict[curID]
            wishID, outCnt = GetWishInfo(curPlayer, treasureType, libID, wishIndex)
            updOut = outCnt + addOut
            SetWishInfo(curPlayer, treasureType, libID, wishIndex, wishID, updOut)
            GameWorld.DebugLog("¸üÐÂÐÄÔ¸ÎïÆ·ÒѲú³ö´ÎÊý: libID=%s,wishIndex=%s,wishID=%s,updOut=%s" % (libID, wishIndex, wishID, updOut), playerID)
            
    addScoreType = setIpyData.GetAwardMoneyType() # ¶îÍâ½±Àø»õ±ÒÀàÐÍ
    addScore = setIpyData.GetAwardMoneyValue() # µ¥´Î½±Àø»õ±ÒÊý
    if addScoreType and addScore:
        PlayerControl.GiveMoney(curPlayer, addScoreType, addScore * treasureCount)
        
    if treasureType in TreasureType_HeroCallList:
        PlayerActivity.AddDailyTaskValue(curPlayer, ChConfig.DailyTask_HeroCall, treasureCount)
        heroCallCnt = GetHeroCallCnt(curPlayer)
        if OpenServerActivity.GetOSAState(curPlayer, ShareDefine.Def_BT_OSA_HeroCall) == 1:
            PlayerBillboard.UpdatePlayerBillboard(curPlayer, ShareDefine.Def_BT_OSA_HeroCall, heroCallCnt)
        PlayerSuccess.UptateSuccessProgress(curPlayer, ShareDefine.SuccType_OSAHeroCall, heroCallCnt)
        
    PlayerActLunhuidian.AddLunhuidianValue(curPlayer, PlayerActLunhuidian.AwardType_Treasure, treasureType, treasureCount)
    
    # ¸øÎïÆ·
    mailItemList = []
    itemControl = ItemControler.PlayerItemControler(curPlayer)
    for tResult in treasureResult:
        gridNum, itemID, itemCount = tResult[:3]
        PyGameData.g_transItemSign = 0
        itemObj = ItemControler.GetOutPutItemObj(itemID, itemCount, isBind, curPlayer=curPlayer)
        mailItemDict = ItemCommon.GetMailItemDict(itemObj)
        
        if int(gridNum) in notifyGridNumList and notifyKeyDict:
            notifyKey = notifyKeyDict.get(int(gridNum), notifyKeyDict.get(0, ""))
            if treasureType in TreasureType_HeroCallList:
                if PlayerHero.GetHeroActivite(curPlayer, itemID):
                    notifyKey = ""
                    GameWorld.DebugLog("ÕÐļÎ佫·ÇÊ״λñµÃµÄ²»¹ã²¥ÁË! itemID=%s" % itemID, playerID)
                elif notifyKey:
                    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", itemID)
                    if heroIpyData:
                        heroQuality = heroIpyData.GetQuality()
                        PlayerControl.WorldNotify(0, notifyKey, [curPlayer.GetPlayerName(), heroQuality, itemID])
            elif notifyKey:
                PlayerControl.WorldNotify(0, notifyKey, [curPlayer.GetPlayerName(), itemID, itemObj.GetUserData(), itemCount])
            
        if mailItemList or not itemControl.PutInItem(packType, itemObj, event=[ChConfig.ItemGive_Treasure, False, {}]):
            mailItemList.append(mailItemDict)
            itemObj.Clear()
            
        # ¼ì²éÎïƷת»¯
        if PyGameData.g_transItemSign:
            tResult[3] = 1 # ÓÐת»¯ÎïƷʱÉèÖÃת»¯±ê¼Ç
            
    if mailItemList:
        PlayerControl.SendMailByKey("HappyXBUnEnough", [playerID], mailItemList)
        
    GameWorld.DebugLog("Ñ°±¦³É¹¦: treasureType=%s,updTreasureCount=%s(%s),updLuck=%s,addScoreType=%s,addScore=%s,gridNumCountInfo=%s,treasureCountEx=%s" 
                       % (treasureType, updTreasureCount, updTreasureCountToday, updLuck, addScoreType, addScore, gridNumCountInfo, treasureCountEx), playerID)
    GameWorld.DebugLog("    treasureResult=%s" % (treasureResult), playerID)
    GameWorld.DebugLog("    mailItemList=%s" % (mailItemList), playerID)
    
    # ֪ͨǰ¶Ë
    sendPack = ChPyNetSendPack.tagMCTreasureResult()
    sendPack.Clear()
    sendPack.AddMoneyType = addScoreType
    sendPack.AddMoneyValue = addScore
    sendPack.AddTreasureLuck = addLuck
    sendPack.TreasureResult = str(treasureResult)
    sendPack.TreasureResultLen = len(sendPack.TreasureResult)
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    
    Sync_TreasureInfo(curPlayer, [treasureType])
    return

def GetHeroCallCnt(curPlayer):
    ## »ñÈ¡Î佫ÕÐļ×Ü´ÎÊý
    callCount = 0
    for treasureType in TreasureType_HeroCallList:
        callCount += curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureCount % (treasureType))
    return callCount

def __getLuckyRateInfo(curLuck, luckyItemRateDict, luckyValueList):
    if not luckyItemRateDict or not luckyValueList:
        return 0, []
    for luck in luckyValueList:
        if curLuck <= luck:
            return luck, luckyItemRateDict[luck]
    lastLuck = luckyValueList[-1]
    return lastLuck, luckyItemRateDict[lastLuck]

def __checkItemCanTreasure(curPlayer, treasureType, itemID):
    ## ¼ì²éÎïÆ·IDÊÇ·ñ¿ÉÑ°±¦²ú³ö
    itemData = GameWorld.GetGameData().GetItemByTypeID(itemID)
    if not itemData:
        return
    
    playerID = curPlayer.GetPlayerID()
    if itemData.GetType() == ChConfig.Def_ItemType_Hero:
        heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", itemID)
        if not heroIpyData:
            return
        if heroIpyData.GetRecruitBySelf() and not PlayerHero.GetHeroActivite(curPlayer, itemID):
            GameWorld.DebugLog("Î佫δ¼¤»î²»²ú³ö£¡ itemID=%s" % itemID, playerID)
            return
        
    elif itemData.GetType() == ChConfig.Def_ItemType_Rune:
        if not PlayerRune.GetIsOpenByRuneID(curPlayer, itemID):
            GameWorld.DebugLog("δ½âËøµÄ·ûÓ¡²»²ú³ö£¡ itemID=%s" % itemID, playerID)
            return
        
    return True

def GetRemoveLimitGridRateList(srcGridNumRateList, gridNumCountInfo, gridNumMaxLimitInfo):
    ## »ñÈ¡ÒƳýÏÞÖƲú³öµÄ¸ñ×ÓºóµÄ±ýͼÁбí
    # @param srcGridNumRateList: ԭʼ¸ÅÂÊ [(¸ÅÂÊ, ¸ñ×Ó±àºÅ), ...]
    # @param gridNumCountInfo: ÓÐÏÞÖƲú³öÊýµÄ¸ñ×ÓÒѾ­²ú³öÊýÁ¿ÐÅÏ¢ {gridNum:count, ...}
    # @param gridNumMaxLimitInfo: ÓÐÏÞÖƲú³öÊýµÄ¸ñ×Ó×î´ó²ú³öÊýÁ¿ÐÅÏ¢ {"gridNum":countLimit, ...}
    newRateList = []
    if not gridNumMaxLimitInfo:
        return newRateList + srcGridNumRateList # ²»Ê¹ÓÃÔ­ÅäÖñýͼ£¬²»È»¿ÉÄܵ¼ÖÂÐ޸ĵôԭʼÅäÖñýͼµ¼ÖÂbug
    for i, rateInfo in enumerate(srcGridNumRateList):
        rate, gridNum = rateInfo
        if str(gridNum) in gridNumMaxLimitInfo:
            limitCount = gridNumMaxLimitInfo[str(gridNum)]
            if limitCount and gridNumCountInfo.get(gridNum, 0) >= limitCount:
                # ÒÑ´ïµ½ÏÞÖƲú³öÊý£¬²»ÔÙ²ú³ö
                continue
        srcRate = rate if i == 0 else (rate - srcGridNumRateList[i - 1][0]) # Ô­¸ÅÂÊ
        newRate = srcRate if not newRateList else (newRateList[-1][0] + srcRate)
        newRateList.append((newRate, gridNum))
    return newRateList

def GetUpdLuckyItemRateList(ipyData, luckyGridNumList, curLuck, luckFormula, costType):
    # »ñÈ¡ÐÒÔËÎïÆ·ÌáÉý¸ÅÂʺóµÄ±ýͼ
    treasureType = ipyData.GetTreasureType()
    srcPieList = ipyData.GetGridItemRateListFree() if costType in CostFreeTypes else ipyData.GetGridItemRateList1()
    if not srcPieList:
        srcPieList = ipyData.GetGridItemRateList1()
        
    updRateList = []
    for i, rateInfo in enumerate(srcPieList):
        rate, gridNum = rateInfo
        baseRate = rate if i == 0 else (rate - srcPieList[i - 1][0]) # Ô­¸ÅÂÊ
        
        if gridNum in luckyGridNumList:
            newRate = eval(FormulaControl.GetCompileFormula("TreasureLuckyRate%s" % treasureType, luckFormula))
        else:
            newRate = baseRate
            
        specRate = newRate if not updRateList else (updRateList[-1][0] + newRate) # ÌáÉýºó¶ÔÓ¦±ýͼ¸ÅÂÊ
        updRateList.append((specRate, gridNum))
        
    return srcPieList, updRateList

def GetJobItem(job, itemID, jobItemList):
    ## »ñÈ¡±¦ÏäÎïÆ·½±Àø¶ÔÓ¦µÄÖ°ÒµÎïÆ·£¬ Ö°Òµ´Ó1¿ªÊ¼
    for jobItemIDList in jobItemList:
        if type(jobItemIDList) not in [list, tuple]:
            GameWorld.ErrLog("Ö°ÒµÎïÆ·×é¸ñʽ´íÎó!jobItemList=%s" % (jobItemList))
            return 0
        if itemID in jobItemIDList:
            if job <= 0 or job > len(jobItemIDList):
                GameWorld.ErrLog("Ö°ÒµÎïÆ·ÅäÖôíÎó,ûÓиÃÖ°Òµ¶ÔÓ¦ÎïÆ·ID!job=%s,itemID=%s" % (job, itemID))
                return 0
            return jobItemIDList[job - 1]
    return itemID

def GetTreasureCntAward(curPlayer, treasureType, needTreasureCnt):
    ## ÁìÈ¡Ñ°±¦ÀۼƴÎÊý½±Àø
    needTreasureCnt = GameWorld.ToIntDef(needTreasureCnt, 0)
    playerID = curPlayer.GetPlayerID()
    ipyData = IpyGameDataPY.GetIpyGameData("TreasureCntAward", treasureType, needTreasureCnt)
    if not ipyData:
        return
    awardIndex = ipyData.GetAwardIndex()
    awardItemList = ipyData.GetAwardItemList()
    
    awardState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureCntAward % (treasureType))
    if awardState&pow(2, awardIndex):
        GameWorld.DebugLog("¸ÃÑ°±¦´ÎÊý½±ÀøÒÑÁì½±! treasureType=%s,needTreasureCnt=%s,awardIndex=%s" 
                           % (treasureType, needTreasureCnt, awardIndex), playerID)
        return
    
    treasureCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureCount % (treasureType))
    if treasureCount < needTreasureCnt:
        GameWorld.DebugLog("¸ÃÑ°±¦´ÎÊý²»×㣬ÎÞ·¨Áì½±! treasureType=%s,treasureCount=%s < %s" 
                           % (treasureType, treasureCount, needTreasureCnt), playerID)
        return
    
    updState = awardState|pow(2, awardIndex)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TreasureCntAward % (treasureType), updState)
    GameWorld.DebugLog("ÁìÈ¡Ñ°±¦´ÎÊý½±Àø! treasureType=%s,needTreasureCnt=%s,awardIndex=%s,awardState=%s,updState=%s" 
                       % (treasureType, needTreasureCnt, awardIndex, awardState, updState), playerID)
    
    ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["TreasureCntAward", False, {}])
    Sync_TreasureInfo(curPlayer, [treasureType])
    return

def Sync_TreasureInfo(curPlayer, syncTypeList=None):
    if syncTypeList == None:
        syncTypeList = []
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        for i in xrange(ipyDataMgr.GetTreasureSetCount()):
            ipyData = ipyDataMgr.GetTreasureSetByIndex(i)
            syncTypeList.append(ipyData.GetTreasureType())
            
    treasureInfoPack = ChPyNetSendPack.tagMCTreasureInfo()
    treasureInfoPack.Clear()
    treasureInfoPack.TreasuerInfoList = []
    for tType in syncTypeList:
        setIpyData = IpyGameDataPY.GetIpyGameData("TreasureSet", tType)
        if not setIpyData:
            continue
        if setIpyData.GetIsActType():
            if not IsActTreasureType(curPlayer, tType):
                continue
        gridNumMaxLimitInfo = setIpyData.GetGridNumMaxLimitInfo()
        tTypeInfo = ChPyNetSendPack.tagMCTreasureTypeInfo()
        tTypeInfo.Clear()
        tTypeInfo.TreasureType = tType
        tTypeInfo.LuckValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureLuck % (tType))
        tTypeInfo.TreasureCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureCount % (tType))
        tTypeInfo.TreasureCountToday = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureCountToday % (tType))
        tTypeInfo.FreeCountToday = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureFreeCount % (tType))
        tTypeInfo.TreasureCntAward = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureCntAward % (tType))
        for gridNumStr in gridNumMaxLimitInfo.keys():
            gridNum = int(gridNumStr)
            gridLimit = ChPyNetSendPack.tagMCTreasureGridLimit()
            gridLimit.GridNum = gridNum
            gridLimit.GridCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreasureGridCnt % (tType, gridNum))
            tTypeInfo.GridLimitCntList.append(gridLimit)
        tTypeInfo.GridLimitCnt = len(tTypeInfo.GridLimitCntList)
        
        wishLibSelect = setIpyData.GetWishLibSelect()
        for libIDStr, wishCnt in wishLibSelect.items():
            libID = int(libIDStr)
            for wishIndex in range(wishCnt):
                wishID, outCnt = GetWishInfo(curPlayer, tType, libID, wishIndex)
                wish = ChPyNetSendPack.tagMCTreasureWish()
                wish.WishID = wishID
                wish.OutCnt = outCnt
                tTypeInfo.WishList.append(wish)
        tTypeInfo.WishCnt = len(tTypeInfo.WishList)
        
        treasureInfoPack.TreasuerInfoList.append(tTypeInfo)
    treasureInfoPack.InfoCount = len(treasureInfoPack.TreasuerInfoList)
    NetPackCommon.SendFakePack(curPlayer, treasureInfoPack)
    return