6077 【后端】【1.5.200】新增一个仙界盛典（特殊版本）活动

xdh

2019-01-28 8305e47be942c376430044332780e6e69a3c7a7f

 ServerPython/CoreServerGroup/GameServer/Script/GameWorldLogic/GameWorldActionControl.py

@@ -25,14 +25,11 @@
import ShareDefine

#import PlayerExam

import PlayerDBGSEvent

import MergeBroadcast

#import PlayerManorWar

#import GameWorldShopItem

#import GameWorldActionTeHui

import GameWorldAverageLv

#import GameWorldMergeBoss

#import GameWorldMergeKing

#import GameWorldMergePK

import CrossRealmPK

import GameWorldFamilyWar

import PlayerFamilyParty

import IpyGameDataPY

@@ -40,8 +37,11 @@
import PlayerFamilySWRH

import GameWorldBoss

import PlayerFairyCeremony

import PlayerNewFairyCeremony

import GameWorldProcess

import ChPyNetSendPack

import NetPackCommon

import PlayerStore



from types import IntType

import time

@@ -53,7 +53,7 @@
ATTR_CALL_TIME = ['weekday', 'year', 'month', 'day', 'hour', 'minute']



(

OperationAction_OpenServerDay, # 信息所属开服天

OperationAction_ReloadSign, # 信息重载标记

OperationAction_TodayInfo, # 当日的活动信息

OperationAction_MapServerInfo, # 同步地图的活动信息

) = range(3)

@@ -71,17 +71,17 @@
        ipyData = operationActionDict[ShareDefine.OperationActionName_ExpRate][0]

        if ipyData:

            Sync_OperationAction_ExpRate(ipyData, curPlayer)

    # BOSS复活活动进行中

    if ShareDefine.OperationActionName_BossReborn in operationActionDict:

        ipyData = operationActionDict[ShareDefine.OperationActionName_BossReborn][0]

        if ipyData:

            GameWorldBoss.Sync_OperationAction_BossReborn(ipyData, curPlayer)



    # 仙界盛典活动进行中

    if ShareDefine.OperationActionName_FairyCeremony in operationActionDict:

        ipyData = operationActionDict[ShareDefine.OperationActionName_FairyCeremony][0]

        if ipyData:

            PlayerFairyCeremony.Sync_OperationAction_FairyCeremony(ipyData, curPlayer)

        
    # 新仙界盛典活动进行中

    if ShareDefine.OperationActionName_NewFairyCeremony in operationActionDict:

        ipyData = operationActionDict[ShareDefine.OperationActionName_NewFairyCeremony][0]

        if ipyData:

            PlayerNewFairyCeremony.Sync_OperationAction_NewFairyCeremony(ipyData, curPlayer)

    # 多倍修行点活动进行中

    if ShareDefine.OperationActionName_RealmPoint in operationActionDict:

        ipyData = operationActionDict[ShareDefine.OperationActionName_RealmPoint][0]

@@ -104,7 +104,7 @@
        dictName = ChConfig.Def_WorldKey_OperationActionState % actName

        state = gameWorld.GetDictByKey(dictName)

        

        sendMapServerMsgDict = mapServerInfoDict.get(actName, {}) if state else {}

        sendMapServerMsgDict = mapServerInfoDict.get(actName, {})

        sendMapServerMsgDict[ShareDefine.ActKey_State] = state

        GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_OperationActionInfo % actName, sendMapServerMsgDict)

        

@@ -116,26 +116,32 @@
    key = "OperationActionInfo"

    openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1

    OperationActionInfo = IpyGameDataPY.GetConfigEx(key)

    if OperationActionInfo and OperationActionInfo[OperationAction_OpenServerDay] == openServerDay:

    serverTime = GameWorld.GetServerTime()

    curHour = serverTime.hour

    reloadSignHour = 0 if curHour < 5 else 5

    reloadSign = "%s_%s" % (openServerDay, reloadSignHour)

    if OperationActionInfo and OperationActionInfo[OperationAction_ReloadSign] == reloadSign:

        #GameWorld.DebugLog("已经加载过本日运营活动处理信息！openServerDay=%s" % openServerDay)

        return False, OperationActionInfo

    

    # 因为后面的时间判断都是精确到分的，而处理此逻辑的时候可能不是0秒，所以这里的datetime取当前时间精确到分的

    serverTime = GameWorld.GetServerTime()

    curDateTimeStr = "%d-%d-%d %02d:%02d:00" % (serverTime.year, serverTime.month, serverTime.day, serverTime.hour, serverTime.minute)

    curDateTime = datetime.datetime.strptime(curDateTimeStr, ChConfig.TYPE_Time_Format)

    GameWorld.Log("加载本日运营活动信息: %s, openServerDay=%s" % (curDateTime, openServerDay))

    

    customMaxServerDay = IpyGameDataPY.GetFuncCfg("OperationAction", 1) # 定制运营活动最大开服天

    operationActionDict = {}

    mapServerOperationActionDict = {}

    serverID = GameWorld.GetServerID()

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    

    GameWorld.Log("===== 加载本日运营活动信息: %s, serverID=%s,openServerDay=%s,customMaxServerDay=%s,reloadSign=%s =====" 
                  % (curDateTime, serverID, openServerDay, customMaxServerDay, reloadSign))

    
    for actName in ShareDefine.OperationActionNameList:

        

        # 取出本活动所属本服ID的所有配置

        curServerActIpyDataList = __GetOperationActionServerIpyDataList(ipyDataMgr, serverID, actName)

        
        GameWorld.Log("加载运营活动: actName=%s,可处理条数=%s" % (actName, len(curServerActIpyDataList)))

        needStartList = [] # [startDateTime, ...]

        needEndList = [] # [endDateTime, ...]

        needNotifyDict = {} # {notifyDateTime:[notifyKey, [参数]], ...}

@@ -143,9 +149,34 @@
        # 注意：每个活动配置会有多个活动时间点，但是有且只能生效一条活动配置，换句话说就是每个活动配置时间不允许交叉

        for ipyData in curServerActIpyDataList:

            

            cfgID = ipyData.GetCfgID()

            startDateStr = ipyData.GetStartDate()

            endDateStr = ipyData.GetEndDate()

            
            GameWorld.Log("    cfgID=%s,mark=%s,serverIDList=%s,startDateStr=%s,endDateStr=%s,openServerDay=%s,curDateTime=%s" 
                          % (cfgID, ipyData.GetActMark(), ipyData.GetServerIDList(), startDateStr, endDateStr, openServerDay, curDateTime))

            # 按开服天开的

            if startDateStr.isdigit() and endDateStr.isdigit():

                startServerDay, endServerDay = int(startDateStr), int(endDateStr)

                #结束日可能还需要处理广播之类，所以这里需要+1

                if openServerDay > endServerDay + 1:

                    GameWorld.Log("        当前开服天超过活动结束开服天，不处理! cfgID=%s,%s ~ %s < openServerDay(%s)" % (cfgID, startDateStr, endDateStr, openServerDay))

                    continue

                openServerDateTime = curDateTime + datetime.timedelta(days=(startServerDay-openServerDay))

                endServerDateTime = curDateTime + datetime.timedelta(days=(endServerDay-openServerDay))

                startDateStr = "%d-%d-%d" % (openServerDateTime.year, openServerDateTime.month, openServerDateTime.day)

                endDateStr = "%d-%d-%d" % (endServerDateTime.year, endServerDateTime.month, endServerDateTime.day)

                GameWorld.Log("        开服天转化为日期: %s ~ %s" % (startDateStr, endDateStr))

            elif actName not in ShareDefine.FeastOperationActionNameList:

                if openServerDay <= customMaxServerDay:

                    GameWorld.Log("        按日期开的在开服定制限制天内，不处理! cfgID=%s,%s ~ %s,openServerDay=%s" % (cfgID, startDateStr, endDateStr, openServerDay))

                    continue

                customMaxServerDateTime = curDateTime + datetime.timedelta(days=(customMaxServerDay-openServerDay))

                curStartDateTime = datetime.datetime.strptime("%s %02d:%02d:%02d" % (startDateStr, customMaxServerDateTime.hour, customMaxServerDateTime.minute, 
                                                                                     customMaxServerDateTime.second), ChConfig.TYPE_Time_Format)

                if curStartDateTime <= customMaxServerDateTime:

                    GameWorld.Log("        按日期开的开始日期在开服定制限制天内，不处理! cfgID=%s,curStartDateTime=%s,customMaxServerDateTime=%s" % (cfgID, curStartDateTime, customMaxServerDateTime))

                    continue

                
            if hasattr(ipyData, "GetStartTimeList") and hasattr(ipyData, "GetEndTimeList"):

                startHMStrList = ipyData.GetStartTimeList()

                endHMStrList = ipyData.GetEndTimeList()

@@ -155,33 +186,55 @@
                

            notifyInfoDictStart = ipyData.GetNotifyInfoStart() if hasattr(ipyData, "GetNotifyInfoStart") else {}

            notifyInfoDictEnd = ipyData.GetNotifyInfoEnd() if hasattr(ipyData, "GetNotifyInfoEnd") else {}

            notifyInfoLoopInfo = ipyData.GetNotifyInfoLoop() if hasattr(ipyData, "GetNotifyInfoLoop") else {} # [循环分钟, 广播key, [广播参数列表可选]]

            

            if len(startHMStrList) != len(endHMStrList):

                GameWorld.ErrLog("活动配置开始及结束时间个数不匹配! actName=%s,cfgID=%s" % (actName, ipyData.GetCfgID()))

                GameWorld.ErrLog("        活动配置开始及结束时间个数不匹配! actName=%s,cfgID=%s,startHMStrList=%s,endHMStrList=%s" 
                                 % (actName, cfgID, startHMStrList, endHMStrList))

                continue

            
            resetType = 0 if not hasattr(ipyData, "GetResetType") else ipyData.GetResetType() # 重置类型，0-0点重置；1-5点重置

            if resetType == 1:

                startDayDate = datetime.datetime.strptime("%s 05:00:00" % (startDateStr), ChConfig.TYPE_Time_Format)

                endDayDate = datetime.datetime.strptime("%s 05:00:00" % (endDateStr), ChConfig.TYPE_Time_Format) # 结束日期5点

            elif resetType == 2:

                startDayDate = datetime.datetime.strptime("%s 05:00:00" % (startDateStr), ChConfig.TYPE_Time_Format)       
                endDayDate = datetime.datetime.strptime("%s 00:00:00" % (endDateStr), ChConfig.TYPE_Time_Format) + datetime.timedelta(days=1) # 结束日期隔天0点

            else:

                startDayDate = datetime.datetime.strptime("%s 00:00:00" % (startDateStr), ChConfig.TYPE_Time_Format)

                endDayDate = datetime.datetime.strptime("%s 00:00:00" % (endDateStr), ChConfig.TYPE_Time_Format) + datetime.timedelta(days=1) # 结束日期隔天0点

                
            advanceMinutes = 0 if not hasattr(ipyData, "GetAdvanceMinutes") else ipyData.GetAdvanceMinutes() # 提前通知时间，分钟，暂只支持按天的

            GameWorld.Log("        resetType=%s,startDayDate=%s,endDayDate=%s,startHMStrList=%s,endHMStrList=%s,advanceMinutes=%s" 
                          % (resetType, startDayDate, endDayDate, startHMStrList, endHMStrList, advanceMinutes))

            

            startList = [] # [startDateTime, ...]

            endList = [] # [endDateTime, ...]

            startNotifyDict = {} # {notifyDateTime:notifyInfo, ...}

            endNotifyDict = {} # {notifyDateTime:notifyInfo, ...}

            loopNotifyDict = {} # {notifyDateTime:notifyInfo, ...}

            isActivity = False # 有需要处理开关时间的（开始、结束）

            isNotify = False

            isAdvanceNotice = False

            isEnd = False

            # 没配置时分的代表全天, 只要开始或结束时分没配都算

            if not startHMStrList or not endHMStrList:

                startDayDate = datetime.datetime.strptime("%s 00:00:00" % (startDateStr), ChConfig.TYPE_Time_Format) # 开始天0点

                endDayDate = datetime.datetime.strptime("%s 00:00:00" % (endDateStr), ChConfig.TYPE_Time_Format) + datetime.timedelta(days=1) # 结束天隔天0点

                startDateTime = startDayDate

                endDateTime = endDayDate

                startList.append(startDateTime)

                endList.append(endDateTime)

                # 同一个活动类型是不允许时间上配置有重叠的，所以一个活动类型满足活动中的时间的有且仅有一条配置

                # 策划可能同时配置多个时间，但是活动中的有且仅有一条配置

                if startDayDate <= curDateTime <= endDayDate:

                    needStartList.append(startDateTime)

                    needEndList.append(endDateTime)

                    isActivity = True

                    isEnd = (curDateTime == endDayDate)

                    

            # 每天按时段开启的，支持多时段

            else:

                startDayDate = datetime.datetime.strptime("%s 00:00:00" % (startDateStr), ChConfig.TYPE_Time_Format) # 开始天0点

                endDayDate = datetime.datetime.strptime("%s 23:59:59" % (endDateStr), ChConfig.TYPE_Time_Format) # 结束天23点59分59秒

                if startDayDate <= curDateTime <= endDayDate:

                    isEnd = (curDateTime == endDayDate)

                    for hmIndex, startHMStr in enumerate(startHMStrList):

                        endHMStr = endHMStrList[hmIndex]

                        # 每天开的, 实际开关时间只取今天的日期； 这里有个问题，全服广播的时间不是今天的, 暂不做支持，之后真有这种需求再说

@@ -197,42 +250,94 @@
                        needEndList.append(endDateTime)

                        isActivity = True

                        

            if advanceMinutes and startDayDate:

                advanceNoticeDateTime = startDayDate + datetime.timedelta(minutes=-advanceMinutes)

                if advanceNoticeDateTime.year == curDateTime.year and advanceNoticeDateTime.month == curDateTime.month and advanceNoticeDateTime.day == curDateTime.day:

                    isAdvanceNotice = True

                GameWorld.Log("        advanceNoticeDateTime=%s,isAdvanceNotice=%s" % (advanceNoticeDateTime, isAdvanceNotice))

            GameWorld.Log("        startList=%s" % (startList))

            GameWorld.Log("        end  List=%s" % (endList))

            GameWorld.Log("        needStartList=%s" % (needStartList))

            GameWorld.Log("        need  EndList=%s" % (needEndList))

            
            for dtIndex, startDateTime in enumerate(startList):

                endDateTime = endList[dtIndex]

                # 广播 - 相对实际开始时间

                for notifyMinute, notifyInfo in notifyInfoDictStart.items():

                    notifyDateTime = startDateTime + datetime.timedelta(minutes=notifyMinute)

                    if notifyDateTime.year == curDateTime.year and notifyDateTime.month == curDateTime.month and notifyDateTime.day == curDateTime.day:

                        needNotifyDict[notifyDateTime] = notifyInfo

                        startNotifyDict[notifyDateTime] = notifyInfo

                        isNotify = True

                    

                # 广播 - 相对实际结束时间

                for notifyMinute, notifyInfo in notifyInfoDictEnd.items():

                    notifyDateTime = endDateTime + datetime.timedelta(minutes=notifyMinute)

                    if notifyDateTime.year == curDateTime.year and notifyDateTime.month == curDateTime.month and notifyDateTime.day == curDateTime.day:

                        needNotifyDict[notifyDateTime] = notifyInfo

                        endNotifyDict[notifyDateTime] = notifyInfo

                        isNotify = True

                       
            if not isActivity and not isNotify:

                        
                # 广播 - 循环广播

                if notifyInfoLoopInfo and len(notifyInfoLoopInfo) >= 2:

                    loopMinutes, loopNotifyKey = notifyInfoLoopInfo[:2]

                    loopNotifyParamList = notifyInfoLoopInfo[2] if len(notifyInfoLoopInfo) > 2 else []

                    notifyInfo = [loopNotifyKey, loopNotifyParamList] # 循环广播的默认无参数

                    loopCount, loopMaxCount = 0, 100

                    while loopMinutes and loopNotifyKey and loopCount < loopMaxCount:

                        loopCount += 1

                        notifyDateTime = startDateTime + datetime.timedelta(minutes=loopMinutes*loopCount)

                        if notifyDateTime >= endDateTime:

                            break

                        if notifyDateTime.year == curDateTime.year and notifyDateTime.month == curDateTime.month and notifyDateTime.day == curDateTime.day:

                            loopNotifyDict[notifyDateTime] = notifyInfo

                            isNotify = True

                            
            if startNotifyDict or endNotifyDict or loopNotifyDict:

                GameWorld.Log("        startNotifyDict: minutes=%s, %s" % (notifyInfoDictStart.keys(), startNotifyDict))

                GameWorld.Log("        end  NotifyDict: minutes=%s, %s" % (notifyInfoDictEnd.keys(), endNotifyDict))

                GameWorld.Log("        loop NotifyDict: lopInfo=%s, %s" % (notifyInfoLoopInfo, loopNotifyDict.keys()))

                needNotifyDict.update(startNotifyDict)

                needNotifyDict.update(endNotifyDict)

                needNotifyDict.update(loopNotifyDict)

                
            if not isActivity and not isNotify and not isAdvanceNotice:

                continue

            

            GameWorld.Log("    本日需要处理的运营活动信息: actName=%s,cfgID=%s,actMark=%s" % (actName, ipyData.GetCfgID(), ipyData.GetActMark()))

            if isActivity:

                if not activityIpyData or activityIpyData.GetStartDate() < ipyData.GetStartDate():

            GameWorld.Log("        需要处理的运营活动信息: cfgID=%s,isAdvanceNotice=%s,isActivity=%s,isEnd=%s,isNotify=%s" % (cfgID, isAdvanceNotice, isActivity, isEnd, isNotify))

            # 当天有需要激活活动或者提前预告活动的取非结束的为准，如果有多个非结束的一般就是策划在活动时间上配置交叉，这种是不允许的

            if isActivity or isAdvanceNotice:

                if not activityIpyData or (isActivity and not isEnd):

                    activityIpyData = ipyData

                    activityInfoDict = {ShareDefine.ActKey_CfgID:cfgID}

                    
                    if startDayDate <= curDateTime < endDayDate:

                        dayIndex = 0

                        actIDDateTime = startDayDate

                        isDayRest = 0 if not hasattr(ipyData, "GetIsDayReset") else ipyData.GetIsDayReset()

                        # 按时段开的默认每天重置

                        if isDayRest or (startHMStrList and endHMStrList):

                            dayIndex = (curDateTime - startDayDate).days

                            actIDDateTime += datetime.timedelta(days=dayIndex)

                        actID = int(time.mktime(actIDDateTime.timetuple())) # 默认取开始时间点的time值作为活动ID

                        activityInfoDict[ShareDefine.ActKey_DayIndex] = dayIndex

                        activityInfoDict[ShareDefine.ActKey_ID] = actID

                        GameWorld.Log("        isDayRest=%s,actIDDateTime=%s,actID=%s" % (isDayRest, actIDDateTime, actID))

                        
                    needStartList.sort()

                    needEndList.sort()

                    
                    mapServerOperationActionDict[actName] = activityInfoDict

                    GameWorld.Log("        activityInfoDict=%s" % (activityInfoDict))

                    

        if activityIpyData or needStartList or needEndList or needNotifyDict:

            # activityIpyData 可能为None

            operationActionDict[actName] = [activityIpyData, needStartList, needEndList, needNotifyDict]

            # 新增运营活动只要在此处添加同步MapServer所需要的数据字典即可，其他逻辑均为公共逻辑

            mapServerOperationActionDict[actName] = __GetOperationActionMapServerInfoDict(curDateTime, actName, activityIpyData)

            

    OperationActionInfo = IpyGameDataPY.SetConfigEx(key, [openServerDay, operationActionDict, mapServerOperationActionDict])

    OperationActionInfo = IpyGameDataPY.SetConfigEx(key, [reloadSign, operationActionDict, mapServerOperationActionDict])

    

    GameWorld.Log("本日运营活动信息加载完毕!isRefreshState=%s" % isRefreshState)

    GameWorld.Log("本日运营活动信息加载完毕!reloadSign=%s,isRefreshState=%s" % (reloadSign, isRefreshState))

    GameWorld.Log("    operationActionDict=%s" % operationActionDict)

    GameWorld.Log("    mapServerOperationActionDict=%s" % mapServerOperationActionDict)

    
    GameWorld.Log("=============================================================")

    if isRefreshState:

        Dispose_OperationActionState(True)

        

@@ -241,12 +346,21 @@
def __GetOperationActionServerIpyDataList(ipyDataMgr, serverID, actName):

    ## 获取运营活动本服务器对应的配置数据列表

    

    if not hasattr(ipyDataMgr, "Get%sCount" % actName):

        GameWorld.ErrLog("没有该运营活动类型对应活动时间表! actName=%s" % actName)

        return []

    
    # 所有配置先按活动标识归组

    platform = GameWorld.GetPlatform()

    actGroupDict = {} # {ActMark:{ServerIDTuple:[ipyData, ...], ...}, ...}

    actCfgCount = getattr(ipyDataMgr, "Get%sCount" % actName)()

    for cfgIndex in xrange(actCfgCount):

        ipyData = getattr(ipyDataMgr, "Get%sByIndex" % actName)(cfgIndex)

        actMark = ipyData.GetActMark()

        platformList = [] if not hasattr(ipyData, "GetPlatformList") else ipyData.GetPlatformList()

        if platformList and platform not in platformList:

            GameWorld.Log("非本平台活动，不取！platform=%s,platformList=%s,actName=%s,cfgID=%s" % (platform, platformList, actName, ipyData.GetCfgID()))

            continue

        serverIDTuple = tuple(ipyData.GetServerIDList())

        

        serverIpyDataDict = actGroupDict.get(actMark, {})

@@ -274,81 +388,6 @@
        if isGeneral:

            curServerActIpyDataList += generalIpyDataList

    return curServerActIpyDataList



def __GetOperationActionMapServerInfoDict(curDateTime, actName, ipyData):

    ## 获取运营活动同步到地图服务器的信息字典    
    if not ipyData:

        return {}

    
    startDateStr = ipyData.GetStartDate()

    startDayDate = datetime.datetime.strptime("%s 00:00:00" % (startDateStr), ChConfig.TYPE_Time_Format) # 开始天0点

    dayIndex = (curDateTime - startDayDate).days # 当前日期在活动期间的天索引

    if dayIndex < 0:

        GameWorld.DebugLog("        不处理运营地图数据: startDateStr=%s,curDateTime=%s,startDayDate=%s,dayIndex=%s" 
                           % (startDateStr, curDateTime, startDayDate, dayIndex))

        return {}

    
    actID = int(time.mktime(startDayDate.timetuple()))

    
    mapServerInfoDict = {}

    # 多倍经验活动

    if actName == ShareDefine.OperationActionName_ExpRate:

        mapServerInfoDict = {ShareDefine.ActKey_LVLimit:ipyData.GetLVLimit(),

                             ShareDefine.ActKey_AddExpRate:ipyData.GetAddExpRate()}

    # 消费返利活动

    elif actName == ShareDefine.OperationActionName_CostRebate:

        isDayReset = ipyData.GetIsDayReset()

        if isDayReset:

            # 每天重置的活动ID取当天的time值

            actIDDateStr = "%d-%d-%d 00:00:00" % (curDateTime.year, curDateTime.month, curDateTime.day)

            actIDDateTime = datetime.datetime.strptime(actIDDateStr, ChConfig.TYPE_Time_Format)

            actID = int(time.mktime(actIDDateTime.timetuple()))

        templateIDList = ipyData.GetTemplateIDList()

        templateID = templateIDList[-1] if dayIndex >= len(templateIDList) else templateIDList[dayIndex]

        mapServerInfoDict = {ShareDefine.ActKey_ID:actID,

                             ShareDefine.ActKey_StartDate:ipyData.GetStartDate(),

                             ShareDefine.ActKey_EndDate:ipyData.GetEndDate(),

                             ShareDefine.ActKey_LVLimit:ipyData.GetLVLimit(),

                             ShareDefine.ActKey_IsDayReset:ipyData.GetIsDayReset(),

                             ShareDefine.ActKey_TemplateID:templateID,

                             ShareDefine.ActKey_TemplateIDList:templateIDList}

    # 限时特惠活动

    elif actName == ShareDefine.OperationActionName_SpringSale:

        isDayReset = ipyData.GetIsDayReset()

        if isDayReset:

            # 每天重置的活动ID取当天的time值

            actIDDateStr = "%d-%d-%d 00:00:00" % (curDateTime.year, curDateTime.month, curDateTime.day)

            actIDDateTime = datetime.datetime.strptime(actIDDateStr, ChConfig.TYPE_Time_Format)

            actID = int(time.mktime(actIDDateTime.timetuple()))

        shopTypeList = ipyData.GetShopTypeList()

        todayShopType = shopTypeList[-1] if dayIndex >= len(shopTypeList) else shopTypeList[dayIndex]

        mapServerInfoDict = {ShareDefine.ActKey_ID:actID,

                             ShareDefine.ActKey_CfgID:ipyData.GetCfgID(), 
                             ShareDefine.ActKey_ShopTypeList:todayShopType}

    # Boss复活活动

    elif actName == ShareDefine.OperationActionName_BossReborn:

        mapServerInfoDict = {ShareDefine.ActKey_ID:actID}

    # 限时礼包活动

    elif actName == ShareDefine.OperationActionName_FlashGiftbag:

        isDayReset = ipyData.GetIsDayReset()

        if isDayReset:

            # 每天重置的活动ID取当天的time值

            actIDDateStr = "%d-%d-%d 00:00:00" % (curDateTime.year, curDateTime.month, curDateTime.day)

            actIDDateTime = datetime.datetime.strptime(actIDDateStr, ChConfig.TYPE_Time_Format)

            actID = int(time.mktime(actIDDateTime.timetuple()))

        giftbagTypeList = ipyData.GetGiftbagTypeList()

        todayGiftbag = giftbagTypeList[-1] if dayIndex >= len(giftbagTypeList) else giftbagTypeList[dayIndex]

        mapServerInfoDict = {ShareDefine.ActKey_ID:actID,

                             ShareDefine.ActKey_CfgID:ipyData.GetCfgID(), 
                             ShareDefine.ActKey_GiftbagTypeList:todayGiftbag}

    # 仙界盛典活动

    elif actName == ShareDefine.OperationActionName_FairyCeremony:

        mapServerInfoDict = {ShareDefine.ActKey_ID:actID}

    # 多倍修行点活动

    if actName == ShareDefine.OperationActionName_RealmPoint:

        mapServerInfoDict = {ShareDefine.ActKey_LVLimit:ipyData.GetLVLimit(),

                             ShareDefine.ActKey_RealmPointMulti:ipyData.GetMultiple()}

    return mapServerInfoDict



def Dispose_OperationActionState(reloadRefresh=False):

    # 运营活动状态处理, 每天0点会强制同步当天的运营活动详情到地图服务器

@@ -397,17 +436,23 @@
                PlayerControl.WorldNotify(0, notifyKey, paramList)

                

        dictName = ChConfig.Def_WorldKey_OperationActionState % actName

        if not isReload and gameWorld.GetDictByKey(dictName) == state:

        preState = gameWorld.GetDictByKey(dictName)

        if not isReload and preState == state:

            #已经是这个状态了

            continue

        #更新字典值

        gameWorld.SetDict(dictName, state)

        sendMapServerMsgDict = mapServerInfoDict.get(actName, {}) if state else {}

        sendMapServerMsgDict = mapServerInfoDict.get(actName, {})

        

        dbOperationActIDKey = PlayerDBGSEvent.Def_OperationActID % actName

        curActID = sendMapServerMsgDict.get(ShareDefine.ActKey_ID)

        if state >= 1 and curActID and PlayerDBGSEvent.GetDBGSTrig_ByKey(dbOperationActIDKey) != curActID:

            PlayerDBGSEvent.SetDBGSTrig_ByKey(dbOperationActIDKey, curActID)

            if actName in ShareDefine.NeedWorldLVOperationActNameList:

                #记录开启时世界等级

                worldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)

                PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_OActWorldLV % actName, worldLV)

                
            #此处为活动开启时

            if actName == ShareDefine.OperationActionName_BossReborn:

                #重置BOSS复活点

@@ -415,13 +460,12 @@
            elif actName == ShareDefine.OperationActionName_FairyCeremony:

                #重置仙界盛典

                PlayerFairyCeremony.ResetFairyCeremony()

            elif actName == ShareDefine.OperationActionName_NewFairyCeremony:

                #重置仙界盛典

                PlayerNewFairyCeremony.ResetNewFairyCeremony()

            

            if actName in ShareDefine.NeedWorldLVOperationActNameList:

                #记录开启时世界等级

                worldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)

                PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_OActWorldLV % actName, worldLV)

                

        if state == 1 and actName in ShareDefine.NeedWorldLVOperationActNameList:

        if state >= 1 and actName in ShareDefine.NeedWorldLVOperationActNameList:

            actWorldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_OActWorldLV % actName)

            sendMapServerMsgDict[ShareDefine.ActKey_WorldLV] = actWorldLV

        

@@ -434,22 +478,34 @@
                pass

        elif actName == ShareDefine.OperationActionName_BossReborn:

            if isReload and ipyData:

                GameWorldBoss.Sync_OperationAction_BossReborn(ipyData)

                GameWorldBoss.SetBossRebornNeedPoint(True)



        elif actName == ShareDefine.OperationActionName_FairyCeremony:

            if isReload and ipyData:

                PlayerFairyCeremony.Sync_OperationAction_FairyCeremony(ipyData)

            if state == 0:

            if preState != state and state == 0:

                PlayerFairyCeremony.OnFairyCeremonyEnd()

        elif actName == ShareDefine.OperationActionName_NewFairyCeremony:

            if isReload and ipyData:

                PlayerNewFairyCeremony.Sync_OperationAction_NewFairyCeremony(ipyData)

            if preState != state and state == 0:

                PlayerNewFairyCeremony.OnNewFairyCeremonyEnd()

        
        elif actName == ShareDefine.OperationActionName_RealmPoint:

            if isReload and ipyData:

                Sync_OperationAction_RealmPoint(ipyData)

        elif actName == ShareDefine.OperationActionName_FlashSale:

            if ipyData and preState != state:

                dayIndex = sendMapServerMsgDict.get(ShareDefine.ActKey_DayIndex, 0)

                PlayerStore.ResetFlashSaleBuyCnt(ipyData, dayIndex, state)

                
        #通知Mapserver,设置字典

        #GameWorld.SendMapServerMsgEx(dictName, state) # 运营活动不单独通知活动状态，需与活动信息整合后一起通知

        

        sendMapServerMsgDict[ShareDefine.ActKey_State] = state

        GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_OperationActionInfo % actName, sendMapServerMsgDict)

        

        GameWorld.Log("运营活动变更: actName=%s,state=%s,dictName=%s, %s" % (actName, state, dictName, sendMapServerMsgDict))

        GameWorld.Log("运营活动变更: actName=%s,preState=%s,state=%s,dictName=%s, %s" % (actName, preState, state, dictName, sendMapServerMsgDict))

    return



def Sync_OperationAction_ExpRate(ipyData, curPlayer=None):

@@ -457,10 +513,11 @@
        return

    if len(ipyData.GetStartTimeList()) != len(ipyData.GetEndTimeList()):

        return

    openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1

    multiExpRateInfo = ChPyNetSendPack.tagGCMultiExpRateInfo()

    multiExpRateInfo.Clear()

    multiExpRateInfo.StartDate = ipyData.GetStartDate()

    multiExpRateInfo.EndtDate = ipyData.GetEndDate()

    multiExpRateInfo.StartDate = GameWorld.GetOperationActionDateStr(ipyData.GetStartDate(), openServerDay)

    multiExpRateInfo.EndtDate = GameWorld.GetOperationActionDateStr(ipyData.GetEndDate(), openServerDay)

    multiExpRateInfo.ActivityTime = []

    for i, startTime in enumerate(ipyData.GetStartTimeList()):

        endTime = ipyData.GetEndTimeList()[i]

@@ -489,12 +546,14 @@
    ##多倍修行点活动信息通知

    if not ipyData:

        return

    openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1

    multiRealmPointInfo = ChPyNetSendPack.tagGCMultiRealmPointInfo()

    multiRealmPointInfo.Clear()

    multiRealmPointInfo.StartDate = ipyData.GetStartDate()

    multiRealmPointInfo.EndtDate = ipyData.GetEndDate()

    multiRealmPointInfo.StartDate = GameWorld.GetOperationActionDateStr(ipyData.GetStartDate(), openServerDay)

    multiRealmPointInfo.EndtDate = GameWorld.GetOperationActionDateStr(ipyData.GetEndDate(), openServerDay)

    multiRealmPointInfo.Multiple = ipyData.GetMultiple()

    multiRealmPointInfo.LimitLV = ipyData.GetLVLimit()

    multiRealmPointInfo.LimitPoint = ipyData.GetPointLimit()

    if not curPlayer:

        # 全服广播在线玩家

        playerManager = GameWorld.GetPlayerManager()

@@ -526,32 +585,67 @@
    curTime = int(time.time())

    curDateStr = GameWorld.ChangeTimeNumToStr(curTime, ChConfig.TYPE_Time_YmdFormat) # 当天日期

    

    GameWorld.Log("加载本日日常活动信息: %s, weekDay=%s,openServerDay=%s" % (curDateStr, weekDay, openServerDay))

    openServerWeekday = GameWorldProcess.GetOpenServerWeekday() # 服务器开服时是星期几

    curMaxCustomServerDay = IpyGameDataPY.GetFuncCfg("OperationAction", 1) - openServerWeekday + 1 # 最大有效定制开服天

    GameWorld.Log("===== 加载今天日常活动信息 =====")

    GameWorld.Log("    开服是星期%s, 开服第%s天, 当前星期%s" % (openServerWeekday, openServerDay, weekDay))

    GameWorld.Log("    最大有效定制开服天: %s" % (curMaxCustomServerDay))

    

    customDailyIDList = []

    dailyTimeInfoList = []

    # 暂固定前2周定制有效, 为方便GM命令测试，这里用开服天做判断，不用开服周

    if openServerDay <= curMaxCustomServerDay:

        customIpyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("DailyActionCustom", openServerWeekday)

        GameWorld.Log("    本周定制的日常活动条数: %s" % len(customIpyDataList))

        customIDList = []

        todayCustomIDList = []

        for customIpyData in customIpyDataList:

            dataID = customIpyData.GetID()

            dailyID = customIpyData.GetDailyID()

            if dailyID not in customDailyIDList:

                customDailyIDList.append(dailyID)

            customIDList.append(dataID)

            if customIpyData.GetOpenServerDay() == openServerDay:

                todayCustomIDList.append(dataID)

                isCustom = True

                dailyTimeInfoList.append([isCustom, customIpyData.GetOpenTimeList(), customIpyData])

                GameWorld.Log("    增加本日日常活动信息: isCustom=%s,dailyID=%s,dataID=%s" % (isCustom, dailyID, dataID))

        GameWorld.Log("    本周定制的日常配置表ID列表: %s" % (customIDList))

        GameWorld.Log("    本周定制的日常活动ID列表: %s" % (customDailyIDList))

        GameWorld.Log("    今天定制的日常表ID列表=%s" % (todayCustomIDList))

    else:

        GameWorld.Log("    超过最大定制开服天，不定制，走常规日常配置！")

    
    GameWorld.Log("    处理常规日常活动配置")

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    dailyActionCount = ipyDataMgr.GetDailyActionCount()

    for i in xrange(dailyActionCount):

        dailyIpyData = ipyDataMgr.GetDailyActionByIndex(i)

        dailyID = dailyIpyData.GetDailyID()

        openServerDayLimit = dailyIpyData.GetOpenServerDay()

        

        if openServerDay < openServerDayLimit:

            GameWorld.Log("    不是日常活动开启天数: dailyID=%s,openServerDayLimit=%s" % (dailyID, openServerDayLimit))

        # 是当天开服天定制活动的不处理常规活动

        if dailyID in customDailyIDList:

            GameWorld.Log("    常规活动ID配置是今天的定制活动ID，不处理！: dailyID=%s" % dailyID)

            continue

        

        openTimeDict = eval(dailyIpyData.GetOpenTime())

        openTimeDict = dailyIpyData.GetOpenTimeDict()

        # 没有时间控制的，代表永久开放

        if not openTimeDict:

            todayActionInfo.append([dailyID])

            GameWorld.Log("    增加本日日常活动信息: dailyID=%s" % dailyID)

            GameWorld.Log("    增加本日常开日常活动信息: dailyID=%s" % dailyID)

            continue

        

        #如果星期key中存在 "0" 代表每日都开启

        if "0" not in openTimeDict and weekDay not in openTimeDict:

            GameWorld.Log("    不是日常活动开启星期: dailyID=%s,openWeekLimit=%s" % (dailyID, openTimeDict.keys()))

            continue

        openTimeList = openTimeDict["0"] if "0" in openTimeDict else openTimeDict[weekDay]

        dailyTimeInfoList.append([False, openTimeList, dailyIpyData])

        

        notifyInfoDict = dailyIpyData.GetNotifyInfo()

    GameWorld.Log("    -----------------------")

    for isCustom, openTimeList, ipyData in dailyTimeInfoList:

        dailyID = ipyData.GetDailyID()

        notifyInfoDict = ipyData.GetNotifyInfo()

        

        openList = [] # [(时,分), ...]

        overList = [] # [(时,分), ...]

@@ -559,7 +653,6 @@
        notifyDict = {} # {(时,分):[notifyKey, [参数]], ...}

        OpenState = 1 # 定义开启状态为1

        

        openTimeList = openTimeDict["0"] if "0" in openTimeDict else openTimeDict[weekDay]

        for hour, minute in openTimeList:  

            openTimeStr = "%s %02d:%02d:%02d" % (curDateStr, hour, minute, 0)

            

@@ -568,7 +661,7 @@
            openList.append((openDateTime.hour, openDateTime.minute))

            

            # 精确关闭时间

            overDateTime = openDateTime + datetime.timedelta(minutes=dailyIpyData.GetDuration())

            overDateTime = openDateTime + datetime.timedelta(minutes=ipyData.GetDuration())

            overList.append((overDateTime.hour, overDateTime.minute))

            

            # goon 开启状态

@@ -585,11 +678,12 @@
                notifyDict[(notifyDateTime.hour, notifyDateTime.minute)] = notifyInfo

                

        todayActionInfo.append([dailyID, openList, overList, goonStateDict, notifyDict])

        GameWorld.Log("    增加本日日常活动信息: dailyID=%s,openList=%s,overList=%s,goonStateDict=%s,notifyDict=%s" 
                      % (dailyID, openList, overList, goonStateDict, notifyDict))

        GameWorld.Log("    增加本日日常活动信息: isCustom=%s,dailyID=%s,openList=%s,overList=%s,goonStateDict=%s,notifyDict=%s" 
                      % (int(isCustom), dailyID, openList, overList, goonStateDict, notifyDict))

        

    TodayDailyActionInfo = IpyGameDataPY.SetConfigEx(key, [openServerDay, todayActionInfo])

    GameWorld.Log("本日日常活动信息加载完毕!")

    GameWorld.Log("=============================================================")

    return TodayDailyActionInfo[1]



def Dispose_DailyActionState():

@@ -641,6 +735,11 @@
            #已经是这个状态了

            continue

        

        if state:

            # 骑宠争夺活动开始前同步有效人数到地图

            if dailyActionID == ShareDefine.DailyActionID_FamilyRobBoss:

                GameWorldBoss.SyncMapServer_HorsePetRobBossPlayerCount()

                
        #通知Mapserver,设置字典

        GameWorld.SendMapServerMsgEx(dictName, state)

        #更新字典值

@@ -669,8 +768,8 @@
## -------------------------------------------------------------------------------------------------

def __GetFBStateEndTimeNotResetIDList():

    key = "FBStateEndTimeNotReset" # 结束时间状态不重置为0的数据ID

    FBStateEndTimeNotResetIDList = IpyGameDataPY.GetConfigEx(key)

    if FBStateEndTimeNotResetIDList == None:

    notResetIDList = IpyGameDataPY.GetConfigEx(key)

    if notResetIDList == None:

        mapStateTimeDict = {}

        ipyDataMgr = IpyGameDataPY.IPY_Data()

        for i in xrange(ipyDataMgr.GetFBStateTimeCount()):

@@ -678,7 +777,7 @@
            dataID = fbStateTimeIpyData.GetID()

            dataMapID = fbStateTimeIpyData.GetDataMapID()

            startWeekDay, startHour, startMinute = fbStateTimeIpyData.GetStartWeekday(), fbStateTimeIpyData.GetStartHour(), fbStateTimeIpyData.GetStartMinute()

            endWeekDay, endHour, endMinute = fbStateTimeIpyData.GetEndWeekday(), fbStateTimeIpyData.GetEndHour(), fbStateTimeIpyData.GetEndMinute()

            endWeekDay, endHour, endMinute = startWeekDay, fbStateTimeIpyData.GetEndHour(), fbStateTimeIpyData.GetEndMinute()

            startTimeList, endTimeDict = mapStateTimeDict.get(dataMapID, [[], {}])

            startTimeList.append([startWeekDay, startHour, startMinute])

            endTimeDict[dataID] = [endWeekDay, endHour, endMinute]

@@ -691,42 +790,135 @@
                # 结束时间属于某一条的开启时间，则不重置，具体状态由另一条决定

                if endTime in startTimeList:

                    FBStateEndTimeNotResetIDList.append(dataID)

        FBStateEndTimeNotResetIDList = IpyGameDataPY.SetConfigEx(key, FBStateEndTimeNotResetIDList)

        GameWorld.Log("加载副本状态结束时间不需要重置状态值的数据ID列表: %s" % FBStateEndTimeNotResetIDList)

    return FBStateEndTimeNotResetIDList

        FBStateEndTimeNotResetIDList.sort()

        
        # 加载定制表

        customStateTimeDict = {}

        for i in xrange(ipyDataMgr.GetFBStateTimeCustomCount()):

            customIpyData = ipyDataMgr.GetFBStateTimeCustomByIndex(i)

            dataID = customIpyData.GetID()

            dataMapID = customIpyData.GetDataMapID()

            openWeek, openDay = customIpyData.GetOpenServerWeek(), customIpyData.GetOpenServerDay()

            startHour, startMinute = customIpyData.GetStartHour(), customIpyData.GetStartMinute()

            endHour, endMinute = customIpyData.GetEndHour(), customIpyData.GetEndMinute()

            startTimeList, endTimeDict = customStateTimeDict.get(dataMapID, [[], {}])

            startTimeList.append([openWeek, openDay, startHour, startMinute])

            endTimeDict[dataID] = [openWeek, openDay, endHour, endMinute]

            customStateTimeDict[dataMapID] = [startTimeList, endTimeDict]

            
        FBStateEndTimeNotResetCustomIDList = []

        for dataMapID, timeInfo in customStateTimeDict.items():

            startTimeList, endTimeDict = timeInfo

            for dataID, endTime in endTimeDict.items():

                # 结束时间属于某一条的开启时间，则不重置，具体状态由另一条决定

                if endTime in startTimeList:

                    FBStateEndTimeNotResetCustomIDList.append(dataID)

        FBStateEndTimeNotResetCustomIDList.sort()

        
        notResetIDList = IpyGameDataPY.SetConfigEx(key, [FBStateEndTimeNotResetIDList, FBStateEndTimeNotResetCustomIDList])

        GameWorld.Log("加载副本状态结束时间不需要重置状态值的数据ID列表:")

        GameWorld.Log("    不需要重置的常规ID: %s" % FBStateEndTimeNotResetIDList)

        GameWorld.Log("    不需要重置的定制ID: %s" % FBStateEndTimeNotResetCustomIDList)

    return notResetIDList



def __GetTodayFBStateTimeInfo():

    key = "TodayFBStateTimeInfo"

    openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1

    TodayFBStateTimeInfo = IpyGameDataPY.GetConfigEx(key)

    if TodayFBStateTimeInfo and TodayFBStateTimeInfo[0] == openServerDay:

        #GameWorld.DebugLog("已经加载过本日副本状态处理信息！openServerDay=%s" % openServerDay)

        return TodayFBStateTimeInfo[1]

    
    openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1

    curDateTime = GameWorld.GetServerTime()

    curWeekDay, curHour, curMinute = curDateTime.weekday() + 1, curDateTime.hour, curDateTime.minute

    
    openServerWeekday = GameWorldProcess.GetOpenServerWeekday() # 服务器开服时是星期几

    if openServerWeekday <= 0:

        GameWorld.ErrLog("获取开服是星期几数据错误！openServerWeekday=%s" % openServerWeekday)

        return []

    
    curMaxCustomServerDay = IpyGameDataPY.GetFuncCfg("OperationAction", 1) - openServerWeekday + 1 # 最大有效定制开服天

    GameWorld.Log("===== 加载今天副本状态时间表 =====")

    GameWorld.Log("    开服是星期%s, 开服第%s天, 当前星期%s,%s点%s分 ！" % (openServerWeekday, openServerDay, curWeekDay, curHour, curMinute))

    GameWorld.Log("    最大有效定制开服天: %s" % (curMaxCustomServerDay))

    
    ipyDataMgr = IpyGameDataPY.IPY_Data()

    
    customMapIDList = [] # 本周有定制的副本数据地图ID列表

    fbStateTimeInfoList = []

    # 暂固定前2周定制有效, 为方便GM命令测试，这里用开服天做判断，不用开服周

    if openServerDay <= curMaxCustomServerDay:

        customIpyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("FBStateTimeCustom", openServerWeekday)

        GameWorld.Log("    本周定制的副本活动条数: %s" % len(customIpyDataList))

        customIDList = [] # 本周定制的数据表ID

        todayCustomIDList = [] # 今天定制的数据表ID

        for customIpyData in customIpyDataList:

            dataID = customIpyData.GetID()

            dataMapID = customIpyData.GetDataMapID()

            if dataMapID not in customMapIDList:

                customMapIDList.append(dataMapID)

            customIDList.append(dataID)

            if customIpyData.GetOpenServerDay() == openServerDay:

                todayCustomIDList.append(dataID)

                isCustom, startWeekDay, endWeekDay = True, curWeekDay, curWeekDay

                fbStateTimeInfoList.append([isCustom, startWeekDay, endWeekDay, customIpyData])

                GameWorld.Log("    今天要处理的副本状态配置: 是否定制=%s,dataID=%s" % (isCustom, dataID))

        GameWorld.Log("    本周定制的配置表ID列表: %s" % (customIDList))

        GameWorld.Log("    本周定制的副本地图列表: %s" % (customMapIDList))

        GameWorld.Log("    今天定制的表ID列表=%s" % (todayCustomIDList))

    else:

        GameWorld.Log("    超过最大定制开服天，不定制，走常规副本状态时间！")

        
    GameWorld.Log("    处理常规副本状态时间配置")

    for i in xrange(ipyDataMgr.GetFBStateTimeCount()):

        fbStateTimeIpyData = ipyDataMgr.GetFBStateTimeByIndex(i)

        dataID = fbStateTimeIpyData.GetID()

        dataMapID = fbStateTimeIpyData.GetDataMapID()

        # 是当天开服天定制活动的不处理常规活动

        if dataMapID in customMapIDList:

            GameWorld.Log("    dataID=%s,dataMapID=%s, 在本周定制的副本地图列表里,不处理！" % (dataID, dataMapID))

            continue

        # 暂不支持跨天的活动

        isCustom, startWeekDay, endWeekDay = False, fbStateTimeIpyData.GetStartWeekday(), fbStateTimeIpyData.GetStartWeekday()

        if curWeekDay != startWeekDay:

            GameWorld.Log("    dataID=%s,dataMapID=%s, 不是本天的副本活动,不处理！curWeekDay=%s,startWeekDay=%s" 
                          % (dataID, dataMapID, curWeekDay, startWeekDay))

            continue 
        fbStateTimeInfoList.append([isCustom, startWeekDay, endWeekDay, fbStateTimeIpyData])

        GameWorld.Log("    今天要处理的副本状态配置: 是否定制=%s,dataID=%s" % (isCustom, dataID))

        
    TodayFBStateTimeInfo = IpyGameDataPY.SetConfigEx(key, [openServerDay, fbStateTimeInfoList])

    GameWorld.Log("本日副本活动状态信息加载完毕!")

    GameWorld.Log("=============================================================")

    return TodayFBStateTimeInfo[1]



def Dispose_FBStateTime():

    ## 副本状态时间表状态处理, 支持 goon作用，开关服状态不受影响，服务器重新启动会自动变更为所有时间段的状态值

    

    FBStateEndTimeNotResetIDList = __GetFBStateEndTimeNotResetIDList()

    openServerWeek = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerWeek) + 1



    FBStateEndTimeNotResetIDList, FBStateEndTimeNotResetCustomIDList = __GetFBStateEndTimeNotResetIDList()

    openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1

    curDateTime = GameWorld.GetServerTime()

    curWeekDay, curHour, curMinute = curDateTime.weekday() + 1, curDateTime.hour, curDateTime.minute

    

    curTimeWHM = curWeekDay * 10000 + curHour * 100 + curMinute

    GameWorld.DebugLog("副本状态时间表状态处理...openServerWeek=%s,openServerDay=%s,curWeekDay=%s,curHour=%s,curMinute=%s,FBStateEndTimeNotResetIDList=%s" 
                       % (openServerWeek, openServerDay, curWeekDay, curHour, curMinute, FBStateEndTimeNotResetIDList))

    
    openServerWeekday = GameWorldProcess.GetOpenServerWeekday() # 服务器开服时是星期几

    GameWorld.DebugLog("副本状态时间表状态处理...开服是星期%s, 开服第%s天, 当前星期%s,%s点%s分" 
                       % (openServerWeekday, openServerDay, curWeekDay, curHour, curMinute))

    GameWorld.DebugLog("    FBStateEndTimeNotResetIDList=%s" % (FBStateEndTimeNotResetIDList))

    GameWorld.DebugLog("    FBStateEndTimeNotResetCustomIDList=%s" % (FBStateEndTimeNotResetCustomIDList))

    

    gameWorld = GameWorld.GetGameWorld()

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    for i in xrange(ipyDataMgr.GetFBStateTimeCount()):

        fbStateTimeIpyData = ipyDataMgr.GetFBStateTimeByIndex(i)

        dataID = fbStateTimeIpyData.GetID()

        dataMapID = fbStateTimeIpyData.GetDataMapID()

        openServerWeekLimit = fbStateTimeIpyData.GetOpenServerWeek()

        openServerDayLimit = fbStateTimeIpyData.GetOpenServerDay()

        
        if openServerWeek <= openServerWeekLimit:

            #GameWorld.DebugLog("    不是副本状态开启周: i=%s,dataMapID=%s,openServerWeekLimit=%s" % (i, dataMapID, openServerWeekLimit))

            continue

        
        if openServerDay <= openServerDayLimit:

            #GameWorld.DebugLog("    不是副本状态开启天数: i=%s,dataMapID=%s,openServerDayLimit=%s" % (i, dataMapID, openServerDayLimit))

            continue

        
        startWeekDay, startHour, startMinute = fbStateTimeIpyData.GetStartWeekday(), fbStateTimeIpyData.GetStartHour(), fbStateTimeIpyData.GetStartMinute()

        endWeekDay, endHour, endMinute = fbStateTimeIpyData.GetEndWeekday(), fbStateTimeIpyData.GetEndHour(), fbStateTimeIpyData.GetEndMinute()

    fbStateTimeInfoList = __GetTodayFBStateTimeInfo()

    
    for isCustom, startWeekDay, endWeekDay, ipyData in fbStateTimeInfoList:

        dataID = ipyData.GetID()

        dataMapID = ipyData.GetDataMapID()

        GameWorld.DebugLog("    isCustom=%s,dataID=%s,dataMapID=%s" % (isCustom, dataID, dataMapID))

        startHour, startMinute = ipyData.GetStartHour(), ipyData.GetStartMinute()

        endHour, endMinute = ipyData.GetEndHour(), ipyData.GetEndMinute()

        # 星期配置0代表每天

        if startWeekDay == 0:

            startWeekDay = curWeekDay

@@ -737,7 +929,7 @@
        #GameWorld.DebugLog("    ID=%s,dataMapID=%s,curTimeWHM=%s,startTimeWHM=%s,endTimeWHM=%s" % (dataID, dataMapID, curTimeWHM, startTimeWHM, endTimeWHM))

        

        # 全服广播key分钟差值对比时间为开始时间, 支持正负时间差

        notifyInfoDict = fbStateTimeIpyData.GetNotifyInfoDict()

        notifyInfoDict = ipyData.GetNotifyInfoDict()

        if notifyInfoDict:

            startDateTime = curDateTime + datetime.timedelta(days=(startWeekDay - curWeekDay))

            startDateTime = datetime.datetime(startDateTime.year, startDateTime.month, startDateTime.day, startHour, startMinute, 0)

@@ -757,7 +949,8 @@
            #GameWorld.DebugLog("        当前是开始时间!")

        # 是结束时间

        elif curTimeWHM == endTimeWHM:

            isReset = dataID not in FBStateEndTimeNotResetIDList

            if (isCustom and dataID not in FBStateEndTimeNotResetCustomIDList) or (not isCustom and dataID not in FBStateEndTimeNotResetIDList):

                isReset = True

            #GameWorld.DebugLog("        当前是结束时间! isReset=%s,FBStateEndTimeNotResetIDList=%s" % (isReset, FBStateEndTimeNotResetIDList))

        # 结束时间是下周

        elif endTimeWHM and endTimeWHM <= startTimeWHM:

@@ -771,8 +964,8 @@
            updCanEnter = 0

            updStateValue = 0

        elif isUpdate:

            updCanEnter = fbStateTimeIpyData.GetCanEnter()

            updStateValue = fbStateTimeIpyData.GetStateValue()

            updCanEnter = ipyData.GetCanEnter()

            updStateValue = ipyData.GetStateValue()

        else:

            #GameWorld.DebugLog("        当前时间副本状态不变！")

            continue

@@ -890,77 +1083,11 @@
    #    #间隔未到

    #    return

    

    if GameWorld.IsMergeServer():

    if GameWorld.IsCrossServer():

        return

    

    Dispose_ActionGoOnByDayKey()

    return





## 设定上次开启活动时间距离现在天数事件

#  @param None: 
#  @return: None

def DoLogic_ServerLastOpenActionDay():

    
    #是跨服服务器

    if GameWorld.IsMergeServer():

        if not PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_MergeServerOpenActionDay):

            return

        
        PlayerDBGSEvent.SetDBGSTrig_ServerTime(PlayerDBGSEvent.Def_MergeServerOpenActionDay)

        
        #通知子服务器天数

        SendBroadcastMergeOpenActionDay()

        return

    
    DoLogic_ActionByDayKeyOnDay()

    
    #上次开启活动时间距离现在天数

    lastOpenActionDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerLastOpenActionDay)

    openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay)

    initDayList = ReadChConfig.GetEvalChConfig('ActionControlByDayInitOpenServerDay')

    if openServerDay < initDayList[0]:

        #开服时间未超过30天

        return

    
    #新一轮活动从头开始

    if lastOpenActionDay >= initDayList[1] or openServerDay == initDayList[2]:

        NewRingOpenActionDay()

        return



    PlayerDBGSEvent.SetDBGSTrig_ServerTime(PlayerDBGSEvent.Def_ServerLastOpenActionDay)

    return

            


## 新一轮活动开始

#  @param None: 
#  @return: 
def NewRingOpenActionDay():

    
    #设置字典值从1开始, 跟SetDBGSTrig_ServerTime接口同步

    PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerLastOpenActionDay, 1)

    
    # 活动天数重设

    OpenActionDay_Reset()      
    return

      
#------------------------------------------------------------------------------

## 活动天数重设

#  @param None

#  @return None

def OpenActionDay_Reset():    
    # 设置国王战开始

    #PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_MergeWarStart, 1)

    return



### 检查key是否处理

#def __CheckIsProcessDictName(dictName):

#    
#    # 非跨服服务器不处理某些key

#    if dictName in [ShareDefine.Def_Notify_WorldKey_Merge_King] and not GameWorld.IsMergeServer():

#        return False

#    
#    return True



## 当前时间与指定时间比较

#  @param curTime 当前服务器时间 

@@ -1026,15 +1153,6 @@
    # #领地争夺战

    # if dictName == ShareDefine.Def_Notify_WorldKey_ManorWar:

    #    PlayerManorWar.ManorWar_ChangeState(isOpen)

    # #跨服boss

    # elif dictName == ShareDefine.Def_Notify_WorldKey_MergeBoss:

    #    GameWorldMergeBoss.MergeBoss_ChangeState(isOpen)

    # #跨服PK

    # elif dictName == ShareDefine.Def_Notify_WorldKey_Merge_PK:

    #    GameWorldMergePK.OnMergePKMatchStateChange(isOpen)

    # #跨服王者争霸

    # elif dictName == ShareDefine.Def_Notify_WorldKey_Merge_King:

    #    GameWorldMergeKing.OnMergeKingStateChange(isOpen)

    # #答题活动

    # elif dictName == ShareDefine.Def_Notify_WorldKey_Game_EXAM:

    #    PlayerExam.Exam_ChangeState(isOpen)

@@ -1058,15 +1176,12 @@
    #守卫人皇

    elif dictName == ShareDefine.Def_Notify_WorldKey_FBFuncState % ChConfig.Def_FBMapID_FamilyInvade:

        PlayerFamilySWRH.OnSWRHStateChange(dictName, isOpen)

    return



#------------------------------------------------------------------------------ 
## 通知子服务器天数

#  @param param: None

#  @return: None

def SendBroadcastMergeOpenActionDay():

    mergeServerOpenActionDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_MergeServerOpenActionDay)

    MergeBroadcast.SendBroadcastMerge(ChConfig.Def_MergeServerOpenActionDay, 0, {"Day":mergeServerOpenActionDay})

    #骑宠争夺

    elif dictName == ShareDefine.Def_Notify_WorldKey_DailyActionState % ShareDefine.DailyActionID_FamilyRobBoss:

        GameWorldBoss.OnHorsePetRobBossActionChange(isOpen)

    #跨服PK

    elif dictName == ShareDefine.Def_Notify_WorldKey_DailyActionState % ShareDefine.DailyActionID_CrossReamPK:

        CrossRealmPK.OnCrossRealmPKDailyActionStateChange(isOpen)

    return



#-------------------------------------------------------------------------------

@@ -1173,7 +1288,7 @@
#  @param None

#  @return None

def Dispose_ActionGoOnByDayKey():

    if GameWorld.IsMergeServer():

    if GameWorld.IsCrossServer():

        return

    GameWorld.DebugLog("处理特惠状态信息...")

    openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay)