#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
#-------------------------------------------------------------------------------
#
##@package Player.PlayerSuccess
#
# @todo:³É¾Íϵͳ
# @author xdh
# @date 2018-04-23
# @version 1.0
#
#
# ÏêϸÃèÊö: ³É¾Íϵͳ
#
#---------------------------------------------------------------------
#"""Version = 2018-04-23 11:00"""
#---------------------------------------------------------------------

import ShareDefine
import ChConfig
import GameWorld
import ChPyNetSendPack
import NetPackCommon
import ItemCommon
import IPY_GameWorld
import PlayerControl
import ItemControler
import PlayerMagicWeapon
import PlayerFamilyRedPacket
import PlayerGatherSoul
import IpyGameDataPY
import EventShell
import PyGameData
import EventReport

import datetime
import time
import math
import ChEquip
import PlayerRune
import Operate_EquipStone
import Operate_EquipWash
import Operate_EquipSuitCompose
import PlayerDogz
import QuestCommon
import DataRecordPack


## »ñÈ¡³É¾Í×ÖµäÐÅÏ¢Öµ
#  @param curPlayer Íæ¼ÒʵÀý
#  @return
def GetPDictValue(curPlayer, key, defaultValue=0):
    return curPlayer.NomalDictGetProperty(key, defaultValue, ChConfig.Def_PDictType_Success)


## ÉèÖóɾÍ×ÖµäÐÅÏ¢Öµ
#  @param curPlayer Íæ¼ÒʵÀý
#  @return
def SetPDictValue(curPlayer, key, value):
    PlayerControl.NomalDictSetProperty(curPlayer, key, value, ChConfig.Def_PDictType_Success)
    return

def GetSuccIsFinish(curPlayer, succID):
    #»ñÈ¡³É¾ÍÊÇ·ñÒÑÍê³É
    return GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_Success_FinishTime, succID)

def SetSuccFinish(curPlayer, succID, finish=True):
    #ÉèÖóɾÍÊÇ·ñÍê³É
    return GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_Success_FinishTime, succID, finish)

def GetSuccHasGot(curPlayer, succID):
    #»ñÈ¡³É¾Í½±ÀøÊÇ·ñÒÑÁìÈ¡
    return GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_Success_AwardRecord, succID)

def SetSuccHasGot(curPlayer, succID, hasGot=True):
    #ÉèÖóɾͽ±ÀøÁìȡ״̬
    if GetSuccHasGot(curPlayer, succID) == hasGot:
        return
    GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_Success_AwardRecord, succID, hasGot)
    
    if hasGot:
        #ÒÑÁìÈ¡µÄ¿ÉÉèÖÃÊÇ·ñÒÑÍê³ÉΪ0
        SetSuccFinish(curPlayer, succID, 0)
        
        Sync_SuccTypeIndexAwardRecord(curPlayer, [succID], True) #ÉèÖóÉδÁìÈ¡µÄÔÚÍâ²ãͬ²½
        PlayerMagicWeapon.ActiveMagicWeapon(curPlayer, succID)
        EventShell.EventRespons_SuccessFinish(curPlayer, succID)
        
    return 

def SetSuccFinishValue(curPlayer, succType, condition, value):
    #ÉèÖóɾÍÍê³É¶È
    key = ChConfig.Def_PDict_Success_CntValue % (succType, condition)
    SetPDictValue(curPlayer, key, value)
    return

def GetSuccFinishValue(curPlayer, succType, condition):
    #»ñÈ¡Íê³É¶È
    key = ChConfig.Def_PDict_Success_CntValue % (succType, condition)
    return GetPDictValue(curPlayer, key)



## ³É¾ÍÅä±íÊý¾ÝÀà
class SuccessData():
    
    def __init__(self):
        self.succID = 0  #³É¾ÍID
        self.succType = 0 # ³É¾ÍÀàÐÍ
        self.needCnt = 0 # ËùÒÔ¼ÆÊýÊýÁ¿
        self.preSuccIDList = [] # Ç°ÖóɾÍID
        self.condition = [] # ¸¨ÖúÌõ¼þ(¸ù¾ÝÀàÐÍ×Ô¶¨ÒåÅäÖÃ)
        self.awardItemDict = {} # Íê³É³É¾Í¿ÉÁìÈ¡µÄ½±ÀøÎïÆ·{itemid:itemcnt}
        self.moneyDict = {} # Íê³É³É¾Í»ñµÃµÄ½ðÇ® {moneyType:money}
        self.exp = 0 # Íê³É³É¾Í»ñµÃµÄ¾­Ñé
        self.attrDict = {} # Íê³É³É¾Í»ñµÃµÄÊôÐÔ {attrid:attrvalue}
        self.hasAward = True #ÊÇ·ñÓн±Àø
        self.redPacketID = 0 # ºì°üID
        self.magicWeaponExp = {} # ·¨±¦Éý¼¶¾­Ñé{id:exp}
        return


## ³É¾ÍÊý¾Ý¹ÜÀíÀà
class SuccessDataMng():

    ## ¹¹Ô캯Êý
    #  @param None
    #  @return
    def __init__(self):
        self.succTypeConditionDict = {} #{succType:[condition,..]}
        self.successDataDict = {} # {succType:{index:SuccessData(),...}, ...}
        return

    ## ¼ÓÔسɾÍÊý¾Ý
    #  @param succType: ³É¾ÍÀàÐÍ
    #  @return
    def __LoadSuccessData(self, succType):
        if succType in self.successDataDict:
            return
        successDataList = IpyGameDataPY.GetIpyGameDataByCondition('Success', {'Type':succType}, True, False)
          
        if not successDataList:
            return
        
        successDataObjDict = {}
        conditionDict = {}
        for successIpyData in successDataList:
            succData = SuccessData()
            succData.succID = successIpyData.GetID()
            succData.succType = succType
            succData.needCnt = successIpyData.GetNeedCnt()
            succData.preSuccIDList = list(successIpyData.GetPreSuccess())
            succData.condition = list(successIpyData.GetCondition())
            succData.awardItemDict = successIpyData.GetAwardItem()
            succData.moneyDict = successIpyData.GetMoney()
            succData.exp = successIpyData.GetExp()
            succData.attrDict = successIpyData.GetAwardAttr()
            succData.redPacketID = successIpyData.GetRedPacketID()
            magicWeaponID = successIpyData.GetMagicWeaponID()
            magicWeaponExp = successIpyData.GetMagicWeaponExp()
            if magicWeaponID and magicWeaponExp:
                succData.magicWeaponExp[magicWeaponID] = magicWeaponExp
            succData.hasAward = bool(succData.awardItemDict or succData.moneyDict or succData.exp or succData.attrDict or succData.redPacketID or succData.magicWeaponExp)
            successDataObjDict[succData.succID]=succData
            if tuple(succData.condition) not in conditionDict:
                conditionDict[tuple(succData.condition)] = [succData.succID]
            else:
                conditionDict[tuple(succData.condition)].append(succData.succID)
            
        self.successDataDict[succType] = successDataObjDict
        #self.succTypeConditionDict[succType] = conditionDict
        return
    
    ## ¸ù¾Ý³É¾ÍÀàÐÍ»ñÈ¡¸ÃÀàÐÍËùÓгɾÍ
    #  @param succType: ³É¾ÍÀàÐÍ
    #  @return: {index:SuccessData(), ...}
    def GetSuccDataByType(self, succType):
        if succType not in self.successDataDict:
            self.__LoadSuccessData(succType)
        return self.successDataDict.get(succType, {}).values()
    
    ## ¸ù¾Ý³É¾ÍÀàÐÍ»ñÈ¡¸ÃÀàÐÍËùÓÐÌõ¼þ
    #  @param succType: ³É¾ÍÀàÐÍ
    #  @return: {index:SuccessData(), ...}
#    def GetConditionDictByType(self, succType):
#        if succType not in self.succTypeConditionDict:
#            self.__LoadSuccessData(succType)
#        return self.succTypeConditionDict.get(succType, {})

    ## ¸ù¾Ý³É¾ÍÀàÐÍË÷Òý»ñȡij¸ö³É¾ÍÊý¾Ý
    #  @param succType: ³É¾ÍÀàÐÍ
    #  @param index: ³É¾ÍË÷Òý
    #  @return: SuccessData() or None
    def GetSuccessData(self, succID):
        succIpyData = IpyGameDataPY.GetIpyGameDataNotLog('Success', succID)
        if not succIpyData:
            return
        succType = succIpyData.GetType()
        if succType not in self.successDataDict:
            self.__LoadSuccessData(succType)
        return self.successDataDict.get(succType, {}).get(succID)
       
    
    

g_succDataMng = SuccessDataMng()


## »ñÈ¡³É¾ÍÊý¾Ý¹ÜÀíÆ÷
#  @param None
#  @return
def GetSuccDataMng():
    return g_succDataMng

## ³É¾ÍOnLogin
#  @param curPlayer
#  @return
def SuccOnLogin(curPlayer):
    # ͬ²½³É¾ÍÐÅÏ¢
    Sync_SuccessInfo(curPlayer)
    # ͬ²½³É¾ÍÁì½±¼Ç¼
    Sync_SuccTypeIndexAwardRecord(curPlayer)
  
    
    # ¼ì²éÀÏÍæ¼Ò
    __CheckOldPlayerSuccess(curPlayer)
    
    # ¼ì²é´ï³ÉÓë·ñ(ÓÐЩ¿ÉÄܸĹýÉÏÏÞ£¬È»ºóÍæ¼Ò¿ÉÒÔÍê³É£¬ÉÏÏßͳһ×öÒ»´Î¼ì²é)
    for succType in ShareDefine.SuccessTypeList:
        succInfoList = GetSuccDataMng().GetSuccDataByType(succType)
        if not succInfoList:
            continue
        __DoCheckSuccessFinish(curPlayer, succType, succInfoList)
    return

## ¼ì²éÀÏÍæ¼Ò³É¾Í¼¤»îÇé¿ö
#  @param None
#  @return
def __CheckOldPlayerSuccess(curPlayer):
    ''' ³É¾Í°æ±¾¸üÐÂÀÏÍæ¼Ò¼ì²é  ÿ´ÎÆô¶¯·þÎñºó Íæ¼ÒµÚÒ»´ÎÉÏÏß¼ì²é³É¾ÍÍê³ÉÇé¿ö
    '''
    #Versions = 2 #°æ±¾ºÅ,ÍùÉÏÔö¼Ó
    initGameWorldTime = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_InitGameWorldTime)
    # ÉÏÏßÐèÒª¼ì²éÀÏÍæ¼Ò³É¾ÍÍê³ÉÇé¿öÀàÐÍ{³É¾ÍÀàÐÍ:ά»¤°æ±¾ºÅ, ...}
    NeedCheckSuccTypeList = [
                            ShareDefine.SuccType_GetMagicWeapon,
                            ShareDefine.SuccType_PassRuneTower,
                            ShareDefine.SuccType_GodWeapon,
                            ShareDefine.SuccType_HorseAllLV,
                            #ShareDefine.SuccType_EquipPlusLV,
                            ShareDefine.SuccType_EquipColorItem,
                            ShareDefine.SuccType_EquipArmor,
                            ShareDefine.SuccType_EquipWeapon,
                            ShareDefine.SuccType_InlayRune,
                            ShareDefine.SuccType_RuneLvUp,
                            ShareDefine.SuccType_RealmlvUp,
                            ShareDefine.SuccType_PetClassLV,
                            ShareDefine.SuccType_InlayStone1,
                            ShareDefine.SuccType_InlayStone2,
                            ShareDefine.SuccType_XJMJGetExp,
                            ShareDefine.SuccType_EquipWashLV1,
                            ShareDefine.SuccType_EquipWashLV2,
                            ShareDefine.SuccType_EquipWashLV3,
                            ShareDefine.SuccType_EquipWing,
                            ShareDefine.SuccType_MWSkillUp,
                            ShareDefine.SuccType_EquipSuit,
                            ShareDefine.SuccType_FamilyTechLV,
                            ShareDefine.SuccType_AlchemyLV,
                            ShareDefine.SuccType_VIPLV,
                            ShareDefine.SuccType_StoneTotalLV,
                            ShareDefine.SuccType_XBXZ,
                            ShareDefine.SuccType_DogzBattle,
                            ShareDefine.SuccType_DogzEquipPlus,
                            ShareDefine.SuccType_MainTaskNode,
                            ShareDefine.SuccType_InlayGatherSoul,
                            ShareDefine.SuccType_GatherSoulLvUp,
                            ShareDefine.SuccType_UseStoveBylv,
                             ]
    
    curCheckVersion = GetPDictValue(curPlayer, ChConfig.Def_PDict_Success_CheckVersion)
    if curCheckVersion == initGameWorldTime:
        GameWorld.DebugLog('    ±¾´Î¿ªÆô·þÎñÆ÷´¦Àí¹ý³É¾Í¼ì²é,²»ÔÙ´¦Àí ', curPlayer.GetID())
        return
    GameWorld.DebugLog("¸üÐÂÀÏÍæ¼ÒÉÏÏß¼ì²é³É¾ÍcurCheckVersion=%s" % (curCheckVersion))
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for succType in NeedCheckSuccTypeList:
        if succType == ShareDefine.SuccType_GetMagicWeapon:
            
            for i in xrange(ipyDataMgr.GetTreasureCount()):
                treasureIpyData = ipyDataMgr.GetTreasureByIndex(i)
                magicWeaponID = treasureIpyData.GetID()
                isActive = PlayerMagicWeapon.GetIsActiveMagicWeapon(curPlayer, magicWeaponID)
                if not isActive:
                    continue
                curMWLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_MagicWeaponLV % magicWeaponID)
                for lv in xrange(curMWLV+1):
                    DoAddSuccessProgress(curPlayer, succType, 1, [magicWeaponID, lv])
        elif succType == ShareDefine.SuccType_PassRuneTower:
            passlv = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_TrialTower_PassLV)
            DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_PassRuneTower, 1, [passlv])
        elif succType == ShareDefine.SuccType_GodWeapon:
            maxType = ipyDataMgr.GetGodWeaponByIndex(ipyDataMgr.GetGodWeaponCount()-1).GetType()
            for i in xrange(1, maxType + 1):
                weaponLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GodWeaponLV % i)
                UptateSuccessProgress(curPlayer, succType, weaponLV, [i])
        elif succType == ShareDefine.SuccType_HorseAllLV:
            ResetSuccessByType(curPlayer, succType)
            for i in xrange(ipyDataMgr.GetHorseCount()):
                ipyData = ipyDataMgr.GetHorseByIndex(i)
                index = ipyData.GetHorseID()
                lv = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Horser_LV % index, 0, ChConfig.Def_PDictType_Horse)
                if not lv:
                    continue
                for rlv in xrange(1, lv+1):
                    DoAddSuccessProgress(curPlayer, succType, 1, [index, rlv])
        elif succType == ShareDefine.SuccType_EquipPlusLV:
            ResetSuccessByType(curPlayer, succType)
            for pType, indexList in ChConfig.Pack_EquipPart_CanPlusStar.items():
                for i in indexList:
                    equipPartStarLV = ChEquip.GetEquipPartStarLV(curPlayer, pType, i)
                    for pluslv in xrange(1, equipPartStarLV+1):
                        DoAddSuccessProgress(curPlayer, succType, 1, [pluslv])
                    
        elif succType in [ShareDefine.SuccType_EquipColorItem, ShareDefine.SuccType_EquipArmor, ShareDefine.SuccType_EquipWeapon, ShareDefine.SuccType_EquipWing]:
            DoEquipSuccessLogic(curPlayer)
        elif succType in [ShareDefine.SuccType_InlayRune, ShareDefine.SuccType_RuneLvUp]:
            PlayerRune.DoRuneSuccessLogic(curPlayer)
        elif succType in [ShareDefine.SuccType_InlayGatherSoul, ShareDefine.SuccType_GatherSoulLvUp]:
            PlayerGatherSoul.DoGatherSoulSuccessLogic(curPlayer)
        elif succType == ShareDefine.SuccType_RealmlvUp:
            UptateSuccessProgress(curPlayer, succType, curPlayer.GetOfficialRank())
        elif succType == ShareDefine.SuccType_PetClassLV:
            ResetSuccessByType(curPlayer, succType)
            petDataPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptPet)
            for petDataIndex in range(petDataPack.GetCount()):
                petItem = petDataPack.GetAt(petDataIndex)
                if petItem.IsEmpty():
                    continue
                petNPCID = petItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
                classLV = petItem.GetUserAttr(ShareDefine.Def_IudetPet_ClassLV)
                for lv in xrange(classLV+1):
                    DoAddSuccessProgress(curPlayer, succType, 1, [petNPCID, lv+1])
                    
        elif succType in [ShareDefine.SuccType_InlayStone1, ShareDefine.SuccType_InlayStone2, ShareDefine.SuccType_StoneTotalLV]:
            Operate_EquipStone.DoStoneSuccess(curPlayer)
        elif succType == ShareDefine.SuccType_XJMJGetExp:
            expPointRecord = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_BZZD_TotalFightExpPoint)
            DoAddSuccessProgress(curPlayer, succType, 1, [expPointRecord])
        elif succType in [ShareDefine.SuccType_EquipWashLV1,ShareDefine.SuccType_EquipWashLV2,ShareDefine.SuccType_EquipWashLV3]:
            Operate_EquipWash.EquipWashSuccess(curPlayer)
        elif succType == ShareDefine.SuccType_MWSkillUp:
            skillManager = curPlayer.GetSkillManager()
            for i in range(0, skillManager.GetSkillCount()):
                curSkill = skillManager.GetSkillByIndex(i)
                if curSkill.GetFuncType() in [ChConfig.Def_SkillFuncType_FbSkill,ChConfig.Def_SkillFuncType_FbSPSkill]:
                    curSkillLV = curSkill.GetSkillLV()
                    UptateSuccessProgress(curPlayer, succType, curSkillLV, [curSkill.GetSkillTypeID()])
            
        elif succType == ShareDefine.SuccType_EquipSuit:
            Operate_EquipSuitCompose.DoSuiteSuccess(curPlayer)
        elif succType == ShareDefine.SuccType_FamilyTechLV:
            techNeedLVDict = IpyGameDataPY.GetFuncEvalCfg('FamilyTechNeedLV', 1, {})
            techIDList = techNeedLVDict.keys()
            for techID in techIDList:
                techLV = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTechLV % techID)
                UptateSuccessProgress(curPlayer, succType, techLV, [techID])
        elif succType == ShareDefine.SuccType_AlchemyLV:
            alchemyLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyLV)
            UptateSuccessProgress(curPlayer, succType, alchemyLV)
        elif succType == ShareDefine.SuccType_VIPLV:
            DoAddSuccessProgress(curPlayer, succType, 1, [curPlayer.GetVIPLv()])
        elif succType == ShareDefine.SuccType_XBXZ:
            ResetSuccessByType(curPlayer, succType)
            for i in xrange(ipyDataMgr.GetXBXZCount()):
                ipyData = ipyDataMgr.GetXBXZByIndex(i)
                if GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_XBXZAwardRecord, ipyData.GetID()):
                    DoAddSuccessProgress(curPlayer, succType, 1, [ipyData.GetMWID()])

        elif succType == ShareDefine.SuccType_DogzBattle:
            for i in xrange(ipyDataMgr.GetDogzCount()):
                ipyData = ipyDataMgr.GetDogzByIndex(i)
                if GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_DogzFightState, i):
                    DoAddSuccessProgress(curPlayer, succType, 1, [ipyData.GetDogzID()])
                    
        elif succType == ShareDefine.SuccType_DogzEquipPlus:
            ResetSuccessByType(curPlayer, succType)
            DoAddSuccessProgress(curPlayer, succType, PlayerDogz.GetFightDogzTotalPlusLv(curPlayer))
        elif succType == ShareDefine.SuccType_MainTaskNode: #Ö»ÄÜ´¦ÀíÖ÷ÏßÈÎÎñ
            succInfoList = GetSuccDataMng().GetSuccDataByType(succType)
            for succData in succInfoList:
                missionID = succData.condition[0]
                if QuestCommon.GetHadFinishMainMission(curPlayer, missionID):
                    DoAddSuccessProgress(curPlayer, succType, 1, [missionID])
        elif succType == ShareDefine.SuccType_UseStoveBylv:
            ResetSuccessByType(curPlayer, succType)
            for i in xrange(ipyDataMgr.GetAttrFruitCount()):
                ipyData = ipyDataMgr.GetAttrFruitByIndex(i)
                fruitItemID = ipyData.GetID()
                hasUseCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AttrFruitEatCnt % fruitItemID)
                if ipyData.GetFuncID() == ShareDefine.Def_AttrFruitFunc_Stove:
                    itemData = GameWorld.GetGameData().GetItemByTypeID(fruitItemID)
                    if not itemData:
                        continue
                    DoAddSuccessProgress(curPlayer, succType, hasUseCnt, [itemData.GetLV()])
                    
    DataRecordPack.DR_CheckOldPlayerSuccess(curPlayer)
    SetPDictValue(curPlayer, ChConfig.Def_PDict_Success_CheckVersion, initGameWorldTime)
    GameWorld.DebugLog("¸üÐÂÀÏÍæ¼ÒÉÏÏß¼ì²é³É¾ÍupdCheckVersions=%s" % (initGameWorldTime), curPlayer.GetID())
    return

## ³É¾ÍOnWeek
#  @param curPlayer
#  @return
def OnWeek(curPlayer):
    resetList = []
    weekResetSuccTypeList = IpyGameDataPY.GetFuncEvalCfg('WeekResetSuccType')
    for succType in weekResetSuccTypeList:
        succInfoList = GetSuccDataMng().GetSuccDataByType(succType)
        if not succInfoList:
            continue
        for succDataObj in succInfoList:
            succID = succDataObj.succID
            condition = succDataObj.condition
            if not GetSuccFinishValue(curPlayer, succType, condition):
                continue
            SetSuccFinishValue(curPlayer, succType, condition, 0)
            SetSuccFinish(curPlayer, succID, False)
            SetSuccHasGot(curPlayer, succID, False)
            resetList.append(succID)
            GameWorld.DebugLog("    OnWeek ÖØÖóɾÍÀàÐÍ: succID=%s" % (succID))
    if resetList:
        Sync_SuccTypeIndexAwardRecord(curPlayer, resetList, True)
        Sync_SuccessInfo(curPlayer, resetList, True)
    return

## ³É¾ÍOnDay
#  @param curPlayer
#  @return
def SuccOnDay(curPlayer):
    resetList = []
    # ÖØÖÃÁ¬ÐøÀàÐͶϵôµÄÊý¾Ý
    serverDay = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_ServerDay)
    GameWorld.DebugLog("Á¬ÐøÀàÐͳɾ͹ýÌì...serverDay=%s" % serverDay)
    for succType in ShareDefine.ContinueSuccessTypeList:
        
        succInfoList = GetSuccDataMng().GetSuccDataByType(succType)
        
        if not succInfoList:
            continue
       
        for succDataObj in succInfoList:
            succID = succDataObj.succID
            condition = succDataObj.condition
            #GameWorld.DebugLog("    succID=%s" % (succID))
            
            finishTime = GetSuccIsFinish(curPlayer, succID)
            
            # ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é
            if finishTime > 0 or GetSuccHasGot(curPlayer, succID):
                GameWorld.DebugLog("        ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é")
                continue
            
            if __DoCheckResetContinue(curPlayer, serverDay, succID):
                SetSuccFinishValue(curPlayer, succType, condition, 0)
                resetList.append(succID)
                
    if resetList:
        Sync_SuccessInfo(curPlayer, resetList, True)
    return

## ¼ì²é³É¾ÍÁ¬ÐøÌìÇé¿ö
#  @param curPlayer
#  @return True-Á¬ÐøÒÑÖжÏ
def __DoCheckResetContinue(curPlayer, serverDay, succID):
    lastDayKey = ChConfig.Def_PDict_Success_LastDay % (succID)
    lastDay = GetPDictValue(curPlayer, lastDayKey)
    
    # ¼Ç¼ʱ¼ä´Ó¿ª·þÌìÊý¸Ä³É time.time()
    if lastDay <= 1000:
        #GameWorld.DebugLog("        lastDay <= 0")
        return
    
    tick = int(time.time())
    serverDay = GameWorld.ChangeTimeNumToDatetime(tick, ChConfig.TYPE_Time_Format_Day)
    lastDay = GameWorld.ChangeTimeNumToDatetime(lastDay, ChConfig.TYPE_Time_Format_Day)
    # ×òÌìÓиüеIJ»´¦Àí£¬Ö¤Ã÷»¹ÊÇÁ¬Ðø״̬
    if lastDay == serverDay - datetime.timedelta(1):
        GameWorld.DebugLog("        ×òÌìÓиüеIJ»´¦Àí£¬Ö¤Ã÷»¹ÊÇÁ¬Ðø״̬")
        return
    
    
    SetPDictValue(curPlayer, lastDayKey, 0)
    GameWorld.DebugLog("    ÖØÖóɾÍÁ¬ÐøÀàÐÍ: succID=%s" % (succID))
    return True

def ResetSuccessByType(curPlayer, succType):
    #ÖØÖÃijÀàÐͳɾͽø¶È£¨ÒÑÍê³ÉµÄ²»ÖØÖã©
    succInfoList = GetSuccDataMng().GetSuccDataByType(succType)
    if not succInfoList:
        return
    #ÏÈÖØÖôÎÊýÔÙÖØмÆÊý
    for succDataObj in succInfoList:
        succID = succDataObj.succID
        condition = succDataObj.condition
        #GameWorld.DebugLog("    succID=%s" % (succID))
        finishTime = GetSuccIsFinish(curPlayer, succID)
        # ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é
        if finishTime > 0 or GetSuccHasGot(curPlayer, succID):
            continue
        SetSuccFinishValue(curPlayer, succType, condition, 0)
    return

def DoEquipSuccessLogic(curPlayer):
    #Íæ¼Òµ±Ç°¿É×°±¸µÄ×°±¸ÀàÐÍ
    ResetSuccessByType(curPlayer, ShareDefine.SuccType_EquipColorItem)
    ResetSuccessByType(curPlayer, ShareDefine.SuccType_EquipArmor)
    ResetSuccessByType(curPlayer, ShareDefine.SuccType_EquipWeapon)
    
    packType = IPY_GameWorld.rptEquip
    
    playerEquip = curPlayer.GetItemManager().GetPack(packType)
    for equipIndex in xrange(playerEquip.GetCount()):
        if equipIndex not in ShareDefine.RoleEquipType :
            continue
       
        curEquip = playerEquip.GetAt(equipIndex)
        if curEquip.IsEmpty():
            continue
        itemColor = curEquip.GetUserAttr(ShareDefine.Def_IudetItemColor)
        if not itemColor:
            itemColor = curEquip.GetItemColor()
        
        itemQuality = curEquip.GetItemQuality()
        classLV = ItemCommon.GetItemClassLV(curEquip)
        if equipIndex not in [ShareDefine.retWing,ShareDefine.retGuard,ShareDefine.retHorse]:
            DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_EquipColorItem, 1, [classLV, itemColor])
        if equipIndex in ChConfig.BaseEquipPlace_Weapon:
            DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_EquipWeapon, 1, [itemColor, itemQuality, classLV])
        elif equipIndex in ChConfig.BaseEquipPlace_Armor:
            DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_EquipArmor, 1, [itemColor, itemQuality, classLV])
        
        elif equipIndex == ShareDefine.retWing:
            DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_EquipWing, 1, [classLV, itemColor])
    return


## ¸üгɾÍÍê³É½ø¶ÈÂß¼­(Íⲿ¹¦Äܵ÷Óã¬Ö»ÊÊÓÃÓÚ²»ÖØÖõijɾÍÀàÐÍ)
#  @param curPlayer
#  @param successType: ³É¾ÍÀàÐÍ
#  @param newCnt: нø¶ÈÖµ
#  @return
def UptateSuccessProgress(curPlayer, successType, newCnt, condition=[]):
    if successType not in ShareDefine.SuccessTypeList:
        return
    succInfoList = GetSuccDataMng().GetSuccDataByType(successType)
    if not succInfoList:
        return
    curCnt = -1
    for succData in succInfoList:
        if not __CheckCanAddSuccess(curPlayer, succData, condition):
            continue
        curCnt = GetSuccFinishValue(curPlayer, successType, succData.condition)
        break
  
    if curCnt == -1:
        return
    if newCnt > curCnt: #ÕâÀïÐèÒªÁ¢¼´¸üУ¡£¡
        DoAddSuccessProgress(curPlayer, successType, newCnt - curCnt, condition, False)
    return

def __CheckCanAddSuccess(curPlayer, succDataObj, condition):
    successType = succDataObj.succType
    succID = succDataObj.succID
    cond = succDataObj.condition
    
    isUnDownCheck = successType in ShareDefine.UnDownCheckSuccessTypeList
    isContain = successType in ShareDefine.ContainSuccessTypeList
    # ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é
    if GetSuccIsFinish(curPlayer, succID) or GetSuccHasGot(curPlayer, succID):
        return
    #Ç°ÖóɾÍÅжÏ
    preSuccIDList = succDataObj.preSuccIDList
    for preSuccID in preSuccIDList:
        if not GetSuccIsFinish(curPlayer, preSuccID) and not GetSuccHasGot(curPlayer, preSuccID):
            return
    
    # Óи¨ÖúÌõ¼þµÄ, ÐèÅжÏÊÇ·ñÏòϼì²é
    if len(cond) > 0:
        if isContain:
            if condition[0] not in cond:
                return
        elif successType in ShareDefine.MultipleSuccessTypeList:
            if not (condition[0]/cond[0] and condition[0]%cond[0] == 0):
                #±ØÐëÊÇÌõ¼þµÄ±¶Êý
                return
        else:
            if len(cond) != len(condition):
                return
            # ²»Ïòϼì²éÔö¼Ó½ø¶ÈµÄ, ½öÅäÖÃÖµµÈÓÚ¸ÃÖµµÄ¿ÉÔö¼Ó½ø¶È
            if isUnDownCheck and cond != condition:
                return
            # ¿ÉÏòÏÂÔö¼Ó½ø¶ÈµÄ, ½öÅäÖÃÖµ <= ¸ÃÖµµÄ¿ÉÔö¼Ó½ø¶È
            if not isUnDownCheck:
                isbreak = False
                for i, num in enumerate(cond):
                    if num > condition[i]:
                        isbreak = True
                        break
                if isbreak:
                    return
    return True


# ½«¹¥»÷ÀàµÄ³É¾ÍÒ»´ÎÖ´ÐУ¬¼õÉÙÔËÐÐÁ¿
def FinishDelayAddSuccessProgress(curPlayer, tick, isFinish=True):

    if not isFinish:
        # ¶þ´ÎÑÓ³Ù´¦Àí
        if tick - curPlayer.GetTickByType(ChConfig.TYPE_Player_Tick_Success) \
           < ChConfig.TYPE_Player_Tick_Time[ChConfig.TYPE_Player_Tick_Success]:
            return
        
        curPlayer.SetTickByType(ChConfig.TYPE_Player_Tick_Success, tick) 
    
    playerID = curPlayer.GetID()
    if playerID not in PyGameData.g_delaySuccessDict:
        return
    
    successDict = PyGameData.g_delaySuccessDict.pop(playerID)
    for sucessInfo, cnt in successDict.items():

        DoAddSuccessProgress(curPlayer, sucessInfo[0], cnt, list(sucessInfo[1]), False)

    return


## Ôö¼Ó³É¾ÍÍê³É½ø¶ÈÂß¼­(Íⲿ¹¦Äܵ÷ÓÃ)
#  @param curPlayer
#  @param successType: ³É¾ÍÀàÐÍ
#  @param addCnt: Ôö¼Ó½ø¶ÈÖµ
#  @param condition: À©Õ¹Ìõ¼þ
#  @return
def DoAddSuccessProgress(curPlayer, successType, addCnt, condition=[], delayCalc=True):
    #GameWorld.DebugLog("DoAddSuccessProgress type=%s,addCnt=%s,condition=%s" 
    #                   % (successType, addCnt, condition), curPlayer.GetPlayerID())

    playerID = curPlayer.GetID()
    if delayCalc and successType not in ShareDefine.NeedResetSuccessTypeList:
        if playerID not in PyGameData.g_delaySuccessDict:
            PyGameData.g_delaySuccessDict[playerID] = {}
            
        # ×îÖÕ´¦Àí¼õÉÙ¼ÆËãÁ¿
        successTuple = (successType, tuple(condition))
        if successTuple not in PyGameData.g_delaySuccessDict[playerID]:
            PyGameData.g_delaySuccessDict[playerID][successTuple] = addCnt
        else:
            PyGameData.g_delaySuccessDict[playerID][successTuple] = PyGameData.g_delaySuccessDict[playerID][successTuple] + addCnt
        
        return


    if condition and type(condition) != type([]):
        GameWorld.ErrLog('DoAddSuccessProgress type=%s, condition=%s ´íÎó£¡'%(type, condition))
        return
    if successType not in ShareDefine.SuccessTypeList:
        return
    
    succInfoList = GetSuccDataMng().GetSuccDataByType(successType)
    if not succInfoList:
        GameWorld.DebugLog("    ÕÒ²»µ½³É¾ÍÊý¾ÝsuccessType=%s" % successType)
        return
    
    maxCnt = 0 # ±¾´Î¿ÉÒÔ¸üе½µÄ×î´óÖµ
    updConditionList = [] # Ðè¸üнø¶ÈÖµµÄkey±àºÅÁбí
    updIDList = []
    updsuccDataList = []
    tick = int(time.time())
    for succDataObj in succInfoList:
        succID = succDataObj.succID
        needCnt = succDataObj.needCnt
        
        if not __CheckCanAddSuccess(curPlayer, succDataObj, condition):
            continue
        updIDList.append(succID)
        updsuccDataList.append(succDataObj)
        curCondition = succDataObj.condition
        if curCondition not in updConditionList:
            updConditionList.append(curCondition)
            
        if maxCnt < needCnt:
            maxCnt = needCnt
            
        # Á¬ÐøÀàÐ͵Ä, ¸üÐÂÁ¬ÐøʱµÄ¿ª·þÌìÊý
        if successType in ShareDefine.ContinueSuccessTypeList:
            lastDayKey = ChConfig.Def_PDict_Success_LastDay % (succID)
            SetPDictValue(curPlayer, lastDayKey, tick)
            
        
                
    #GameWorld.DebugLog("    updConditionList=%s,maxCnt=%s" % (str(updConditionList), maxCnt))
    
    # ûÓÐÕÒµ½¸üÐÂÄ¿±ê²»´¦Àí
    if not updConditionList or maxCnt <= 0:
        return
    
    # ÏȸüгɾͼǼֵºóÔÙÅжÏÍê³ÉÓë·ñ
    for condition in updConditionList:
        curCnt = GetSuccFinishValue(curPlayer, successType, condition)
        updCnt = min(maxCnt, curCnt + addCnt)
        SetSuccFinishValue(curPlayer, successType, condition, updCnt)
#        GameWorld.DebugLog("    successType=%s,condition=%s,curCnt=%s,addCnt=%s,updCnt=%s" 
#                           % (successType,condition, curCnt, addCnt, updCnt))
        
    
    # ͬ²½¸üÐÂÐÅÏ¢
    Sync_SuccessInfo(curPlayer, updIDList, False)
    
    # ¸üÐÂÖµºó¼ì²é³É¾ÍÍê³ÉÇé¿ö
    __DoCheckSuccessFinish(curPlayer, successType, updsuccDataList)
    return


## ¼ì²é³É¾ÍÍê³ÉÇé¿ö
#  @param curPlayer
#  @param successType: ³É¾ÍÀàÐÍ
#  @param succInfoDict: ¸ÃÀàÐÍËùÓгɾÍÐÅÏ¢×Öµä
#  @param isPub: ½ø¶ÈÖµÊÇ·ñ¹«¹²
#  @param updNumList: Óиüнø¶ÈµÄ±àºÅÁбí
#  @return
def __DoCheckSuccessFinish(curPlayer, successType, succInfoList):
    
    isNeedSys = successType in [ShareDefine.SuccType_ElderBattlefieldKill, ShareDefine.SuccType_ElderBattlefieldConKill]
    curTime = GameWorld.ChangeTimeStrToNum(GameWorld.GetCurrentDataTimeStr())
    playerName = curPlayer.GetName()

    for succDataObj in succInfoList:
        succID = succDataObj.succID
        needCnt = succDataObj.needCnt
 
        finishTime = GetSuccIsFinish(curPlayer, succID)
        
        # ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é
        if finishTime > 0 or GetSuccHasGot(curPlayer, succID):
            continue
        
        curCnt = GetSuccFinishValue(curPlayer, successType, succDataObj.condition)
        
        # Íê³É³É¾Í
        if curCnt >= needCnt:
            # ÉèÖÃÍê³Éʱ¼ä
            SetSuccFinish(curPlayer, succID)
            # ûÓн±ÀøµÄÖ±½ÓÉèÖÃÒÑÁìÈ¡
            if not succDataObj.hasAward:
                SetSuccHasGot(curPlayer, succID)
                
            # ֪ͨ¿Í»§¶ËÍê³É³É¾Í
            Notify_FinishSuccess(curPlayer, succID, curTime)
            
            if isNeedSys:
                PlayerControl.WorldNotify(0, 'AncientBattlefield_1', [playerName, succID])
            
            for mwID in succDataObj.magicWeaponExp.keys():
                EventReport.WriteEvent_MWSuccess(curPlayer, mwID, succID, ChConfig.CME_Log_Start)
            GameWorld.DebugLog("    Íê³É³É¾ÍsuccID=%s, type=%s,time=%s" 
                               % (succID, successType, curTime))
            
            
    
    return


## ¼ÆËã³É¾ÍÊôÐÔ
#  @param curPlayer Íæ¼Ò
#  @param allAttrList ÊôÐÔÁбí
#  @return None
def CalcSuccessAttr(curPlayer):
    allAttrList = [{} for _ in range(4)]
    attrDict = {}
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for i in xrange(ipyDataMgr.GetSuccessCount()):
        ipyData = ipyDataMgr.GetSuccessByIndex(i)
        succID = ipyData.GetID()
        attrAwardDict = ipyData.GetAwardAttr()
        if not attrAwardDict:
            continue
        if not GetSuccHasGot(curPlayer, succID):
            continue
        for attrID, attrValue in attrAwardDict.items():
            attrDict[attrID] = attrDict.get(attrID, 0) + attrValue
            
    GameWorld.DebugLog("    ³É¾ÍÔö¼ÓÊôÐÔ attrDict=%s" % (attrDict))        
    for attrID, attrValue in attrDict.items():
        PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrList)
        
    PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Success, allAttrList)
    return

## ˢгɾÍÊôÐÔ
def RefreshSuccessAttr(curPlayer):
    CalcSuccessAttr(curPlayer)
    # ²»Á¢¼´Ë¢ÐÂ
    PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState()
    return

## ͬ²½³É¾ÍÐÅÏ¢
#  @param curPlayer: 
#  @param syncDict: Ö¸¶¨Í¬²½×Öµä
#  @param isSendZero: ÊÇ·ñͬ²½¿ÕÊý¾Ý(ÈçÁ¬ÐøÀàÐͽø¶ÈÖµ±»Çå¿Õʱ or GMÃüÁî²âÊÔ), Êý¾Ý±È½Ï¶à£¬¿ÕÊý¾ÝĬÈϾͲ»Í¬²½ÁË
#  @return
def Sync_SuccessInfo(curPlayer, succIdList=[], isSendZero=False):
    succInfoListPack = ChPyNetSendPack.tagMCSuccessInfoList()
    succInfoListPack.Clear()
    succInfoListPack.SuccessInfoList = []
    if succIdList:
        syncIdList = succIdList
    else:
        syncIdList = []
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        for i in xrange(ipyDataMgr.GetSuccessCount()):
            ipyData = ipyDataMgr.GetSuccessByIndex(i)
            succID = ipyData.GetID()
            syncIdList.append(succID)
            
    syncTypeDict = {}
    for succID in syncIdList:
        succData = GetSuccDataMng().GetSuccessData(succID)
        if not succData:
            continue
        succType = succData.succType
        condition = succData.condition

        CntValue = GetSuccFinishValue(curPlayer, succType, condition)
        isfinish = GetSuccIsFinish(curPlayer, succID)
        # ²»·¢ËÍΪ0µÄÊý¾Ý
        if not isSendZero and CntValue <= 0 and not isfinish:
            continue
        # ÒÑÁìÈ¡µÄ²»·¢ 
        if GetSuccHasGot(curPlayer, succID):
            continue
            
        if succType not in syncTypeDict:
            syncTypeDict[succType] = [[condition, CntValue]]
        elif [condition, CntValue] not in syncTypeDict[succType]:
            syncTypeDict[succType].append([condition, CntValue])
        
    if not syncTypeDict:
        return
    
    for sType, conditionList in syncTypeDict.items():
        for condition, cntValue in conditionList:
            succInfo = ChPyNetSendPack.tagMCSuccessInfo()
            succInfo.Clear()
            succInfo.SuccType = sType
            succInfo.Condition = str(condition) if condition else '[0]'
            succInfo.Len = len(succInfo.Condition)
            succInfo.CntValue = cntValue
            succInfoListPack.SuccessInfoList.append(succInfo)
        
    succInfoListPack.count = len(succInfoListPack.SuccessInfoList)
    NetPackCommon.SendFakePack(curPlayer, succInfoListPack)
    return


## ֪ͨÍê³É³É¾Í
#  @param None
#  @return
def Notify_FinishSuccess(curPlayer, succID, finishTime):
    succFinishPack = ChPyNetSendPack.tagMCSuccessFinish()
    succFinishPack.Clear()
    succFinishPack.SuccID = succID
    #succFinishPack.FinishTime = finishTime    
    NetPackCommon.SendFakePack(curPlayer, succFinishPack)
    return


def GetCanGetAwardSuccByType(curPlayer, successTypeList):
    ##¸ù¾ÝÀàÐÍ»ñÈ¡¿ÉÁìÈ¡µÄ³É¾Í
    succList = []
    for successType in successTypeList:
        succInfoList = GetSuccDataMng().GetSuccDataByType(successType)
        for succDataObj in succInfoList:
            succID = succDataObj.succID
            if GetSuccIsFinish(curPlayer, succID) and not GetSuccHasGot(curPlayer, succID):
                succList.append(succID)
    return succList

def GiveSuccAward(curPlayer, succIDList, isGiveItem=True):
    #¸ø³É¾Í½±Àø
    awardDict = {}
    for succID in succIDList:
        awardItemDict = __DoGetSuccTypeIndexAward(curPlayer, succID, isGiveItem)
        if not awardItemDict:
            continue
        for itemID,itemCnt in awardItemDict.items():
            awardDict[itemID] = awardDict.get(itemID, 0)+itemCnt
    return awardDict

#// A5 42 ÁìÈ¡³É¾Í½±Àø #tagMCGetSuccessAward
#
#struct    tagMCGetSuccessAward
#{
#    tagHead        Head;
#    DWORD        SuccID;    //³É¾ÍID
#};
## ÁìÈ¡³É¾Í½±Àø
#  @param None
#  @return
def OnGetSuccessAward(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    succID = clientData.SuccID
    __DoGetSuccTypeIndexAward(curPlayer, succID)
    return

## Áìȡij¸ö³É¾Í½±Àø
#  @param None
#  @return
def __DoGetSuccTypeIndexAward(curPlayer, succID, isGiveItem=True):
    GameWorld.DebugLog("ÁìÈ¡³É¾Í½±ÀøsuccID=%s" % (succID))
   
    succData = GetSuccDataMng().GetSuccessData(succID)
    if not succData:
        GameWorld.DebugLog("    ³É¾ÍÊý¾Ý²»´æÔÚ£¡succID=%s" % (succID))
        return
    
    finishTime = GetSuccIsFinish(curPlayer, succID)
    if finishTime <= 0:
        GameWorld.DebugLog("    ¸Ã³É¾ÍδÍê³É£¡")
        return
    
    if GetSuccHasGot(curPlayer, succID):
        GameWorld.DebugLog("    ¸Ã³É¾Í½±ÀøÒѾ­ÁìÈ¡¹ý£¡")
        return
    
    if not succData.hasAward:
        GameWorld.DebugLog("    ¸Ã³É¾ÍûÓÐÅäÖý±Àø£¡")
        return
    
    itemDict = succData.awardItemDict
#    if awardItemDict and '[' in str(awardItemDict):
#        #ÐÞÐгɾͽ±Àø¸ù¾Ý¾³½çµÈ¼¶±ä
#        curRealmLV = curPlayer.GetOfficialRank()
#        sortLVList=sorted(awardItemDict.keys())
#        findLV = sortLVList[0]
#        for realmlv in sortLVList:
#            if curRealmLV <= int(realmlv):
#                findLV = realmlv
#                break
#        itemDict = dict(awardItemDict[findLV])
#    else:
#        itemDict = awardItemDict
        
            
        
        
    # ¼ì²é±³°ü
    if isGiveItem:
        packSpace = ItemCommon.GetItemPackSpace(curPlayer, IPY_GameWorld.rptItem)
        needSpace = len(itemDict)
        if needSpace > packSpace:
            PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_998371")
            return

    # ¸üÐÂÁì½±¼Ç¼
    SetSuccHasGot(curPlayer, succID)
    
    # ¸øÎïÆ·
    if isGiveItem:
        for itemID, itemCnt in itemDict.items():
            isPutIn = ItemControler.GivePlayerItem(curPlayer, itemID, itemCnt, 1,
                                                   [IPY_GameWorld.rptItem, IPY_GameWorld.rptAnyWhere], True)
       
    #¸øÇ®
    for moneyType, value in succData.moneyDict.items():
        PlayerControl.GiveMoney(curPlayer, moneyType, value)
        
    #¸ø¾­Ñé
    if succData.exp:
        PlayerControl.PlayerControl(curPlayer).AddExp(succData.exp)
    #ÊôÐÔ
    if succData.attrDict:
        RefreshSuccessAttr(curPlayer)
    #·¢ºì°ü
    if succData.redPacketID:
        PlayerFamilyRedPacket.CreatRedPacketByID(curPlayer, succData.redPacketID, PlayerFamilyRedPacket.State_NoGot, succID)
    #·¨±¦¾­Ñé
    if succData.magicWeaponExp:
        for mwID, addExp in succData.magicWeaponExp.items():
            PlayerMagicWeapon.AddMagicWeaponUpExp(curPlayer, mwID, addExp)
            EventReport.WriteEvent_MWSuccess(curPlayer, mwID, succID, ChConfig.CME_Log_End, 1)
    GameWorld.DebugLog("    OK! awardItemDict=%s moneyDict=%s" % (itemDict, succData.moneyDict))
    return itemDict



## ֪ͨ³É¾Í¶ÔÓ¦½±ÀøÁì½±¼Ç¼
#  @param None
#  @return
def Sync_SuccTypeIndexAwardRecord(curPlayer, succIDList=[], isSyncZero=False):
    if succIDList:
        recordIndexList = []
        for succID in succIDList:
            recordIndexList.append(succID / 31)
    else:
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        succCnt = ipyDataMgr.GetSuccessCount()
        if not succCnt:
            return
        maxSuccid = ipyDataMgr.GetSuccessByIndex(succCnt-1).GetID()
        recordIndexList = range(maxSuccid / 31+1)
            
    succFARPack = ChPyNetSendPack.tagMCSuccessFinishAwardRecordList()
    succFARPack.Clear()
    succFARPack.RecordList = []
    for i in recordIndexList:
        awardRecord=curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Success_AwardRecord%i)
        if not isSyncZero and not awardRecord:
            continue
        recordInfo = ChPyNetSendPack.tagMCSuccessFinishAwardRecord()
        recordInfo.RecordIndex = i
        recordInfo.Record = awardRecord
        succFARPack.RecordList.append(recordInfo)
   
    succFARPack.RecordCnt = len(succFARPack.RecordList)
    NetPackCommon.SendFakePack(curPlayer, succFARPack)
    return


def AddEnterFBSuccess(curPlayer, mapID, addCount):
    #½øÈ븱±¾³É¾ÍÏà¹Ø
    
    if mapID == ChConfig.Def_FBMapID_BZZD:
        #ÏɽçÃؾ³
        DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_BZZD, addCount)
    elif mapID == ChConfig.Def_FBMapID_IceLode:
        #±ù¾§¿óÂö
        DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_IceLode, addCount)
    return