#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
#-------------------------------------------------------------------------------
#
##@package Player.PlayerActivity
#
# @todo:Íæ¼ÒÿÈÕ»îÔ¾¶È
# @author xdh
# @date 2014-07-14
# @version 1.0
#
# ÏêϸÃèÊö: Íæ¼ÒÿÈÕ»îÔ¾¶È¡¢Ã¿Èջ
#---------------------------------------------------------------------
#"""Version = 2017-02-25 11:30"""
#---------------------------------------------------------------------

import ChConfig
import ChPyNetSendPack
import NetPackCommon
import ShareDefine
import GameWorld
import ItemCommon
import IPY_GameWorld
import PlayerControl
import ItemControler
import IpyGameDataPY
import PyGameData
import GameFuncComm


#¹ØÁªÀàÐÍ
(
RelatedType_1, # 1¹ØÁªÈÕ³£»î¶¯±í
RelatedType_2, # 2¹ØÁª¸±±¾×ܱí
) = range(1, 3)



def OnWeek(curPlayer, onWeekType):
    actionIDInfo = []
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for i in xrange(ipyDataMgr.GetDailyActionCount()):
        ipyData = ipyDataMgr.GetDailyActionByIndex(i)
        weekTimesLimit = ipyData.GetWeekTimes()
        if not weekTimesLimit:
            continue
        # ÖØÖÃÀàÐͲ»Í¬µÄ²»´¦Àí
        if ipyData.GetWeekResetType() != onWeekType:
            continue
        key = ChConfig.Def_PDict_DailyActionWeekTimes%ipyData.GetDailyID()
        __SetPDictValue(curPlayer, key, 0)
    
        actionIDInfo.append(ipyData.GetDailyID())
            
    if actionIDInfo:
        SyncDailyActionInfo(curPlayer, actionIDInfo)
        
    return


## OnDay
#  @param curPlayer Íæ¼ÒʵÀý
#  @return
def OnDay(curPlayer, onEventType):
    
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    if onEventType == ShareDefine.Def_OnEventTypeEx:
        # ÖØÖÃÍê³É´ÎÊý
        for i in xrange(ipyDataMgr.GetDailyQuestCount()):
            ipyData = ipyDataMgr.GetDailyQuestByIndex(i)
            
            key = ChConfig.Def_PDict_Activity_FinishCnt % ipyData.GetID()
            curPBCnt = __GetPDictValue(curPlayer, key) #µ¥´Î½ø¶ÈÖµ
            if curPBCnt:
                __SetPDictValue(curPlayer, key, 0)
        #×Ü»îÔ¾¶ÈÖØÖÃ
        __SetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_TotalPoint, 0)
        # ÖØÖÃÁì½±¼Ç¼
        __SetPDictValue(curPlayer, ChConfig.Def_PDict_ActivityAwardRecord, 0)
        #ÖØÖöîÍâ»ñµÃÐÞÐеãÊý
        __SetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_ExtraRealmPoint, 0)
        #ÖØмÆËã½±Àø½×¶Î
        __CalcAwardStage(curPlayer)
        #ÖØÖÿÉÁìÈ¡ÐÞÐе㣬δÁìÈ¡µÄ·¢Óʼþ
        realmPoint = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_RealmPoint)
        if realmPoint and GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Official):
            if GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_DailyQuest):
                PlayerControl.SendMailByKey('XXDForgetToPick', [curPlayer.GetID()], [(ChConfig.Def_ItemID_RealmPoint, realmPoint, 1)], [realmPoint])
            __SetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_RealmPoint, 0)
        
        SyncDailyActivityInfo(curPlayer)
    else:
        SendDayActionMail(curPlayer)
    
    #ÈÕ³£»î¶¯ÖØÖÃ
    actionIDInfo = []
    for i in xrange(ipyDataMgr.GetDailyActionCount()):
        ipyData = ipyDataMgr.GetDailyActionByIndex(i)
        dayTimesLimit = GetMaxDayTimes(ipyData)#ipyData.GetDayTimes()
        if not dayTimesLimit:
            continue
        # ÖØÖÃÀàÐͲ»Í¬µÄ²»´¦Àí
        if ipyData.GetDayResetType() != onEventType:
            continue
        key = ChConfig.Def_PDict_DailyActionDayTimes%ipyData.GetDailyID()
        __SetPDictValue(curPlayer, key, 0)
        actionIDInfo.append(ipyData.GetDailyID())
    if actionIDInfo:
        SyncDailyActionInfo(curPlayer, actionIDInfo)
    return

def SendDayActionMail(curPlayer):
    ##·¢ËÍÿÈջÓʼþ
    if curPlayer.GetLV()>= IpyGameDataPY.GetFuncCfg('DailyQuestMailLvLimit'):
        PlayerControl.SendMailByKey('TodayDailyTask', [curPlayer.GetID()], [])
    return


#ÖØмÆËã½±Àø½×¶Î
def __CalcAwardStage(curPlayer):
    realmLV= curPlayer.GetOfficialRank()
    ipyData = IpyGameDataPY.IPY_Data().GetDailyLivenessRewardByIndex(0)
    if not ipyData:
        return
    stageLVList = ipyData.GetStageLV()
    curStage = 0
    for i, lv in enumerate(stageLVList):
        if realmLV <lv:
            break
        if realmLV >= lv:
            curStage = i
    __SetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_AwardStage, curStage)
    GameWorld.DebugLog('    ÖØмÆËã»îÔ¾½±Àø½×¶Î curStage=%s,realmLV=%s'%(curStage, realmLV))
    return

## OnLogin
#  @param curPlayer Íæ¼ÒʵÀý
#  @return
def OnLogin(curPlayer):
    # ͬ²½Íê³É¶È¼°Áì½±¼Ç¼
    SyncDailyActivityInfo(curPlayer)
    #ͬ²½ÈÕ³£»î¶¯´ÎÊý
    SyncDailyActionInfo(curPlayer)
    return


## »ñÈ¡»îÔ¾¶ÈÍæ¼ÒÊý¾Ý¿â×ÖµäÐÅÏ¢Öµ
#  @param curPlayer Íæ¼ÒʵÀý
#  @param key ×Öµäkey
#  @param defaultValue ĬÈÏÖµ
#  @return
def __GetPDictValue(curPlayer, key, defaultValue=0):
    return curPlayer.NomalDictGetProperty(key, defaultValue)

## ÉèÖûîÔ¾¶ÈÍæ¼ÒÊý¾Ý¿â×ÖµäÐÅÏ¢Öµ
#  @param curPlayer Íæ¼ÒʵÀý
#  @param key ×Öµäkey
#  @param value ÉèÖõÄÖµ
#  @return
def __SetPDictValue(curPlayer, key, value):
    PlayerControl.NomalDictSetProperty(curPlayer, key, value)
    return


## ¿Û³ý»õ±Ò»ñµÃ»îÔ¾¶È
#  @param curPlayer Íæ¼ÒʵÀý
#  @param type_Price 
#  @param price 
#  @return
def OnPayMoneyActivity(curPlayer, type_Price, price):
    #½ð×ÓÖ§¸¶
#    if type_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
#        AddActivityFinishCnt(curPlayer, ShareDefine.ActivityNum_UseGoldCnt)
#    #½ðƱ֧¸¶
#    elif type_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
#        AddActivityFinishCnt(curPlayer, ShareDefine.ActivityNum_UseGoldPaperCnt)
        
    return



## ÃþNPC»ñµÃ»îÔ¾¶È
#  @param atkObj
#  @param curNPC 
#  @return
def OnAttackNPCActivity(atkObj, curNPC):
    atkObjType = atkObj.GetGameObjType()
    
    # ²»ÊÇÍæ¼ÒÔݲ»´¦Àí
    if atkObjType != IPY_GameWorld.gotPlayer:
        return
                
    # »÷ɱboss
#    if curNPC.GetIsBoss():
#        canAddBossIDList = ReadChConfig.GetEvalChConfig("Activity_BossID")
#        
#        if curNPC.GetNPCID() in canAddBossIDList:
#            AddActivityFinishCnt(atkObj, ShareDefine.ActivityNum_KillBoss)
        
    return

## Ôö¼ÓÍê³É»îÔ¾¶È´ÎÊý
#  @param curPlayer Íæ¼ÒʵÀý
#  @param activityNum »îÔ¾¶È±àºÅ 
#  @param finishCnt ÒÑÍê³É´ÎÊý
#  @param addCnt Ôö¼Ó´ÎÊý£¬Ä¬ÈÏ1 
#  @return
def AddActivityFinishCnt(curPlayer, activityNum, finishCnt, addCnt):
    
    dailyQuestData = IpyGameDataPY.GetIpyGameDataNotLog('DailyQuest', activityNum)
    if not dailyQuestData:
        return
    
    maxActiveValue = dailyQuestData.GetTotalActiveValue()
    onceActivity = dailyQuestData.GetOnceActivity()
    onceActivityTime = dailyQuestData.GetOnceActivityTime()
    if not onceActivity:
        return
    if maxActiveValue and finishCnt > maxActiveValue/onceActivity*onceActivityTime:
        #GameWorld.DebugLog("»îÔ¾¶È¿ÉÍê³É´ÎÊýÒÑ´ïµ½ÉÏÏÞ,activityNum=%s" % (activityNum))
        return
    
    key = ChConfig.Def_PDict_Activity_FinishCnt % activityNum
    curPBCnt = __GetPDictValue(curPlayer, key) #µ¥´Î½ø¶ÈÖµ
    
    addValue = (addCnt+curPBCnt)/onceActivityTime * onceActivity #Ôö¼ÓµÄ»îÔ¾¶È
    addPbCnt = (addCnt+curPBCnt) % onceActivityTime
    
    __SetPDictValue(curPlayer, key, addPbCnt)
    
    #curTotalPoint = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_TotalPoint)
    multiple = 1
    if addValue:
        #__SetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_TotalPoint, nuwTotalPoint)
        multiple, extraPointLimit = __GetActionAddPer(curPlayer)
        curExtraPoint = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_ExtraRealmPoint)
        addExtraPoint = max(0, min(addValue*(multiple-1),extraPointLimit-curExtraPoint)) if extraPointLimit else addValue*(multiple-1)
        __SetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_ExtraRealmPoint, curExtraPoint+addExtraPoint)
        addValue = addValue + addExtraPoint
        
        realmPoint = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_RealmPoint)
        __SetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_RealmPoint, realmPoint+addValue)
        SyncDailyActivityInfo(curPlayer)
        
        GameWorld.DebugLog("Ôö¼Ó»îÔ¾¶ÈÈÎÎñ´ÎÊý£¬activityNum=%s,addPbCnt=%s,addValue=%s, multiple=%s, addExtraPoint=%s,curExtraPoint=%s"  
                           % (activityNum, addPbCnt, addValue, multiple, addExtraPoint, curExtraPoint), curPlayer.GetPlayerID())
    return

def __GetActionAddPer(curPlayer):
    multiple, extraPointLimit = 1, 0 #±¶Êý¡¢¶îÍâ¿É»ñµÃÐÞÐеãÉÏÏÞ
    actRealmPointInfo = PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_RealmPoint, {})# ¶à±¶ÐÞÐеã»î¶¯
    if not actRealmPointInfo:
        return multiple, extraPointLimit
    if not actRealmPointInfo.get(ShareDefine.ActKey_State):
        return multiple, extraPointLimit
    actRealmPointIpyData = IpyGameDataPY.GetIpyGameData("ActRealmPoint", actRealmPointInfo.get(ShareDefine.ActKey_CfgID, 0))
    if not actRealmPointIpyData:
        return multiple, extraPointLimit
    if curPlayer.GetLV() < actRealmPointIpyData.GetLVLimit():
        return multiple, extraPointLimit
    return actRealmPointIpyData.GetMultiple(), actRealmPointIpyData.GetPointLimit()

## ͬ²½»îÔ¾¶ÈÐÅÏ¢
#  @param curPlayer
#  @param syncNum ĬÈÏ-1ʱȫ²¿Í¬²½
#  @return None
def SyncDailyActivityInfo(curPlayer):
    sendPack = ChPyNetSendPack.tagMCDailyActivityInfoList()
    sendPack.Clear()
    sendPack.CurValue = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_TotalPoint)
    sendPack.StageIndex = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_AwardStage)
    sendPack.AwardRecord = __GetPDictValue(curPlayer, ChConfig.Def_PDict_ActivityAwardRecord)
    sendPack.RealmPoint = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_RealmPoint)
    sendPack.ExtraPoint = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_ExtraRealmPoint)
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    return



## ÁìÈ¡»îÔ¾¶È½±Àø
#  @param curPlayer
#  @param awardIndex
#  @return None
def GetActivityAward(curPlayer, awardIndex):
    rewardCount = IpyGameDataPY.IPY_Data().GetDailyLivenessRewardCount()
 
    if awardIndex < 0 or awardIndex >= rewardCount:
        GameWorld.ErrLog("»îÔ¾¶È½±ÀøË÷Òý²»ºÏ·¨,index=%s,Len=%s" % (awardIndex, rewardCount))
        return
    
    # ÅжÏÊÇ·ñÒÑÁìÈ¡
    getAwardRecord = __GetPDictValue(curPlayer, ChConfig.Def_PDict_ActivityAwardRecord)
    if getAwardRecord & pow(2, awardIndex):
        GameWorld.Log("ÒѾ­ÁìÈ¡¹ý¸Ã»îÔ¾¶È½±Àø,index=%s" % (awardIndex))
        return
    
    ipyData = IpyGameDataPY.IPY_Data().GetDailyLivenessRewardByIndex(awardIndex)
    
    needActivity = ipyData.GetLiveness()
    totalActivity = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_TotalPoint)
    
    # ÅжϻîÔ¾¶È
    if totalActivity < needActivity:
        GameWorld.Log("Áì½±»îÔ¾¶È²»×ã,index=%s,needActivity=%s,totalActivity=%s" 
                      % (awardIndex, needActivity, totalActivity))
        return
    
    awardStage = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_AwardStage)
   
    itemIDList = ipyData.GetItemID()
    itemCntList = ipyData.GetItemCount()
    itemIsBindList = ipyData.GetItemBind()
    if awardStage >=len(itemIDList) or awardStage >= len(itemCntList) or awardStage >= len(itemIsBindList):
        return

    itemID = itemIDList[awardStage]
    itemCnt = itemCntList[awardStage]
    isBind = itemIsBindList[awardStage]
    # ¼ì²é±³°ü
    packSpace = ItemCommon.GetItemPackSpace(curPlayer, IPY_GameWorld.rptItem)
    if 1 > packSpace:
        PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_998371")
        return
    
    # ¸øÎïÆ·
    ItemControler.GivePlayerItem(curPlayer, itemID, itemCnt, isBind, [IPY_GameWorld.rptItem], True)

    # ¸üÐÂÒÑÁìÈ¡³É¹¦±ê¼Ç
    updAwardRecord = getAwardRecord | (1 << awardIndex)
    __SetPDictValue(curPlayer, ChConfig.Def_PDict_ActivityAwardRecord, updAwardRecord)
    SyncDailyActivityInfo(curPlayer)
    GameWorld.DebugLog("ÁìÈ¡»îÔ¾¶È½±ÀøOK£¡awardStage=%s, index=%s,needActivity=%s,totalActivity=%s,awardRecord=%s" 
                       % (awardStage, awardIndex, needActivity, totalActivity, updAwardRecord))

    
    
    return

def GetRealmPointAward(curPlayer):
    #ÁìÈ¡»îÔ¾ÐÞÐеã
    realmPoint = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_RealmPoint)
    if not realmPoint:
        return
    PlayerControl.GiveMoney(curPlayer, ShareDefine.TYPE_Price_RealmPoint, realmPoint)
    __SetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_RealmPoint, 0)
    #totalPoint = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_TotalPoint)
    #__SetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_TotalPoint, totalPoint+realmPoint)
    SyncDailyActivityInfo(curPlayer)
    return

def GetActivityNum(relatedType, relatedID):
    ## »ñÈ¡ÈÕ³£ÈÎÎñID£¨»îÔ¾ID£©
    ipyData = IpyGameDataPY.GetIpyGameDataByCondition('DailyQuest', {"RelatedID":relatedID,"RelatedType":relatedType}, False, False)
    if not ipyData:
        return 0
    return ipyData.GetID()

#########################################ÈÕ³£»î¶¯###########################################

def AddDailyActionFinishCnt(curPlayer, dailyID, addCnt=1):
    ##Ôö¼ÓÈÕ³£»î¶¯Íê³É´ÎÊý
    ipyData = IpyGameDataPY.GetIpyGameData('DailyAction', dailyID)
    if not ipyData:
        return
#    if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_DailyQuest):
#        #GameWorld.DebugLog("ÈÕ³£ÈÎÎñ¹¦ÄÜ먦Æô£¡dailyID=%s" % dailyID)
#        return
    
    # ÓÉGameServer¾ö¶¨
    # Ä¿Ç°¿ç·þPKÔݲ»ÐèÒªÅжϣ¬ÒòΪ¿ç·þPK´ÎÊý½áËãÔÚ±¾·þ£¬Íæ¼Ò¿ÉÄÜÉÏ´Îδ½áËãÀëÏߣ¬µÈ·ÇÆ¥ÅäÆÚ¼äÉÏÏߣ¬Ò²ÐèÒª¼ÓÉÏ£¬ËùÒÔÔݲ»ÅжÏ
    if dailyID not in [ShareDefine.DailyActionID_CrossReamPK]:
        if not GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_DailyActionState % dailyID):
            GameWorld.DebugLog("ÈÕ³£»î¶¯Î´¿ªÆô£¡dailyID=%s" % dailyID)
            return
    
    dayTimesLimit = GetMaxDayTimes(ipyData)#ipyData.GetDayTimes()
    weekTimesLimit = ipyData.GetWeekTimes()
    if not dayTimesLimit and not weekTimesLimit:
        return
    #¶ÔÓ¦µÄÈÕ³£ÈÎÎñ±íID
    activityNum = GetActivityNum(RelatedType_1, dailyID)
    dailyQuestData = IpyGameDataPY.GetIpyGameDataNotLog('DailyQuest', activityNum)
    unLimitCnt = dailyQuestData and not dailyQuestData.GetTotalActiveValue()
    funcID = dailyQuestData.GetUnLockFuncID() if dailyQuestData else 0
    if funcID and not GameFuncComm.GetFuncCanUse(curPlayer, funcID):
        return
        
    updDayTimes = 0
    if dayTimesLimit:
        key = ChConfig.Def_PDict_DailyActionDayTimes%dailyID
        curDayTimes = curPlayer.NomalDictGetProperty(key)
        if not unLimitCnt and curDayTimes >= dayTimesLimit:
            return
        updDayTimes =  curDayTimes+addCnt if unLimitCnt else min(dayTimesLimit, curDayTimes+addCnt)
        addCnt = updDayTimes - curDayTimes
        PlayerControl.NomalDictSetProperty(curPlayer, key, updDayTimes)
        GameWorld.DebugLog('Ôö¼ÓÈÕ³£»î¶¯Íê³É´ÎÊý dailyID=%s, curDayTimes=%s, updDayTimes=%s'%(dailyID, curDayTimes, updDayTimes))
    updWeekTimes = 0
    if weekTimesLimit:
        key = ChConfig.Def_PDict_DailyActionWeekTimes%dailyID
        curWeekTimes = curPlayer.NomalDictGetProperty(key)
        if not unLimitCnt and curWeekTimes >= weekTimesLimit:
            return
        updWeekTimes =  curWeekTimes+addCnt if unLimitCnt else min(weekTimesLimit, curWeekTimes+addCnt)
        addCnt = updWeekTimes - curWeekTimes
        PlayerControl.NomalDictSetProperty(curPlayer, key, updWeekTimes)
        GameWorld.DebugLog('Ôö¼ÓÈÕ³£»î¶¯Íê³É´ÎÊý dailyID=%s, curWeekTimes=%s, updWeekTimes=%s'%(dailyID, curWeekTimes, updWeekTimes))

    SyncDailyActionInfo(curPlayer, [dailyID])
    
    #¶ÔÓ¦µÄÈÕ³£ÈÎÎñ±íID
    updTimes = updDayTimes or updWeekTimes
    if addCnt and updTimes and dailyQuestData:
        AddActivityFinishCnt(curPlayer, activityNum, updTimes, addCnt)
    return True

def GetDailyActionFinishCnt(curPlayer, dailyID):
    key = ChConfig.Def_PDict_DailyActionDayTimes%dailyID
    curDayTimes = __GetPDictValue(curPlayer, key)
    ipyData = IpyGameDataPY.GetIpyGameData('DailyAction', dailyID)
    if not ipyData:
        return 0, 0
    dayTimesLimit = GetMaxDayTimes(ipyData)#ipyData.GetDayTimes()
    return curDayTimes, dayTimesLimit

def GetMaxDayTimes(ipyData):
    dayTimesLimit = ipyData.GetDayTimes()
    if ipyData.GetDailyID() == ShareDefine.DailyActionID_TowerSD:
        dayTimesLimit += IpyGameDataPY.GetFuncCfg('RuneTowerSweepBuy')
    return dayTimesLimit

## ͬ²½»îÔ¾¶ÈÐÅÏ¢
#  @param curPlayer
#  @param syncNum ĬÈÏ-1ʱȫ²¿Í¬²½
#  @return None
def SyncDailyActionInfo(curPlayer, syncNumList= []):
    sendPack = ChPyNetSendPack.tagMCDailyActionCnt()
    sendPack.Clear()
    sendPack.ActionInfo = []
    syncNumList = syncNumList if syncNumList else ShareDefine.DailyActionIDList

    for activityNum in syncNumList:
        activityInfo = ChPyNetSendPack.tagMCDailyActionInfo()
        activityInfo.Clear()
        activityInfo.ActionID = activityNum
        activityInfo.DayFinishCnt = __GetPDictValue(curPlayer, ChConfig.Def_PDict_DailyActionDayTimes % activityNum)
        activityInfo.WeekFinishCnt = __GetPDictValue(curPlayer, ChConfig.Def_PDict_DailyActionWeekTimes % activityNum)
        sendPack.ActionInfo.append(activityInfo)
    
    sendPack.Count = len(sendPack.ActionInfo)
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    return

##################################¸±±¾ÀàÔö¼Ó»îÔ¾##########################################
## ²Î¼Ó¸±±¾»ñµÃ»îÔ¾¶È
#  @param curPlayer Íæ¼ÒʵÀý
#  @param tick 
#  @return
def OnEnterFBActivity(curPlayer, mapID, curDayTimes, addCount):
    activityNum = GetActivityNum(RelatedType_2, mapID)
    if activityNum: 
        AddActivityFinishCnt(curPlayer, activityNum, curDayTimes, addCount)
    return