1111 优化开服副本状态时间定制、日常活动定制逻辑；

hxp

2024-11-18 1029b172223ee7a30bda1b4dc64829b011fe2ff2

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

@@ -33,6 +33,12 @@
import PlayerFamilyRedPacket

import PlayerFairyCeremony

import PlayerNewFairyCeremony

import PlayerActFamilyCTGAssist

import PlayerActGarbageSorting

import PlayerActBossTrial

import PlayerActXianXiaMJ

import PlayerActGubao

import PlayerActHorsePetTrain

import PlayerUniversalGameRec

import GameWorldAverageLv

import PlayerFamilyBoss

@@ -64,7 +70,10 @@
        # 跨服不处理运营活动

        return

    

    isReload, OperationActionInfo = __GetOperationActionInfo()

    # 玩家登录的不触发重载活动，不然刚好在0点服务器处理OnDay之前登录的时候会有问题

    isReload, OperationActionInfo = __GetOperationActionInfo(needReload=False)

    if not OperationActionInfo:

        return

    operationActionDict = OperationActionInfo[OperationAction_TodayInfo]

    

    if isReload:

@@ -104,10 +113,11 @@
def SendMapServerOperationActionState():

    # 地图启动成功时通知本日运行活动相关状态

    

    CrossActionControl.SendMapServerCrossActionState()

    
    if GameWorld.IsCrossServer():

        # 跨服不处理运营活动

        return

    CrossActionControl.SendMapServerCrossActionState()

    

    isReload, OperationActionInfo = __GetOperationActionInfo()

    mapServerInfoDict = OperationActionInfo[OperationAction_MapServerInfo]

@@ -137,7 +147,7 @@
        

        活动分组编号 = 活动类型 * 10 + 不同界面编号

    '''

    if ipyData and hasattr(ipyData, "ActNum"):

    if ipyData and hasattr(ipyData, "GetActNum"):

        return ipyData.GetActNum()

    

    # 原节日活动的还是默认节日活动

@@ -151,7 +161,44 @@
    ## 运营活动类型

    return actNum / 10



def __GetOperationActionInfo(isRefreshState=True):

def __SaveActWorldLVLimitInfo(actWorldLVLimitInfo):

    GameWorld.GetUniversalRecMgr().Delete(ShareDefine.Def_UniversalGameRecType_ActWorldLVLimitInfo)

    recDataList = GameWorld.GetUniversalRecMgr().GetTypeList(ShareDefine.Def_UniversalGameRecType_ActWorldLVLimitInfo)

    GameWorld.Log("保存运营活动世界等级限制开启信息: %s" % len(actWorldLVLimitInfo))

    for actName, cfgLimitInfoDict in actWorldLVLimitInfo.items():

        for cfgID, limitInfo in cfgLimitInfoDict.items():

            recStartDateStr, recEndDateStr, recLimitWorldLV, recWorldLV = limitInfo

            recData = recDataList.AddRec()

            recData.SetStrValue1(recStartDateStr)

            recData.SetStrValue2(recEndDateStr)

            recData.SetStrValue3(actName)

            recData.SetValue1(cfgID)

            recData.SetValue2(recLimitWorldLV)

            recData.SetValue3(recWorldLV)

            GameWorld.Log("    actName=%s,cfgID=%s,recStartDateStr=%s,recEndDateStr=%s,recLimitWorldLV=%s,recWorldLV=%s" 
                          % (actName, cfgID, recStartDateStr, recEndDateStr, recLimitWorldLV, recWorldLV))

    return



def __GetActWorldLVLimitInfo():

    actWorldLVLimitInfo = {}

    recDataList = GameWorld.GetUniversalRecMgr().GetTypeList(ShareDefine.Def_UniversalGameRecType_ActWorldLVLimitInfo)

    GameWorld.Log("加载运营活动世界等级限制开启信息: %s" % recDataList.Count())

    for index in xrange(recDataList.Count()):

        recData = recDataList.At(index)

        recStartDateStr = recData.GetStrValue1()

        recEndDateStr = recData.GetStrValue2()

        actName = recData.GetStrValue3()

        cfgID = recData.GetValue1()

        recLimitWorldLV = recData.GetValue2()

        recWorldLV = recData.GetValue3()

        if actName not in actWorldLVLimitInfo:

            actWorldLVLimitInfo[actName] = {}

        actWorldLVLimitInfo[actName][cfgID] = [recStartDateStr, recEndDateStr, recLimitWorldLV, recWorldLV]

        GameWorld.Log("    actName=%s,cfgID=%s,recStartDateStr=%s,recEndDateStr=%s,recLimitWorldLV=%s,recWorldLV=%s" 
                      % (actName, cfgID, recStartDateStr, recEndDateStr, recLimitWorldLV, recWorldLV))

    return actWorldLVLimitInfo



def __GetOperationActionInfo(isRefreshState=True, needReload=True):

    # @return: isReload, OperationActionInfo

    

    key = "OperationActionInfo"

@@ -167,6 +214,9 @@
        #GameWorld.DebugLog("已经加载过本日运营活动处理信息！openServerDay=%s" % openServerDay)

        return False, OperationActionInfo

    

    if not needReload:

        return False, OperationActionInfo

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

    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)

@@ -180,10 +230,13 @@
    serverGroupID = GameWorld.GetServerGroupID()

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    curWeekday = curDateTime.weekday() + 1 # 今天星期几, 1代表星期1

    curWorldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)

    actWorldLVLimitInfoOld = __GetActWorldLVLimitInfo()

    actWorldLVLimitInfoNew = {}

    

    GameWorld.Log("===== 加载本日运营活动信息: %s, serverGroupID=%s,openServerDay=%s,customMaxServerDay=%s,isMixServer=%s,mixServerDay=%s,maxCustomServerDayMix=%s,reloadSign=%s =====" 

                  % (curDateTime, serverGroupID, openServerDay, customMaxServerDay, isMixServer, mixServerDay, maxCustomServerDayMix, reloadSign))

    GameWorld.Log("    今日周%s" % (curWeekday))

    GameWorld.Log("    今日周%s, curWorldLV=%s" % (curWeekday, curWorldLV))

    

    for actName in ShareDefine.OperationActionNameList:

        

@@ -194,13 +247,14 @@
        GameWorld.Log("加载运营活动: actName=%s,platform=%s,serverGroupID=%s" % (actName, platform, serverGroupID))

        curServerActIpyDataList = __GetOperationActionServerIpyDataList(ipyDataMgr, platform, serverGroupID, actName)

        GameWorld.Log("    可处理条数=%s" % (len(curServerActIpyDataList)))

        actNumDisableWeekIpyDataInfo = __GetOperationActionDisableWeekIpyDataInfo(actName, curDateTime, curServerActIpyDataList)

        
        coverDisableLoopIpyDataInfo, disableLoopCfgIDDict, otherLoopCfgIDDict, coverDisableWeekIpyDataInfo, disableWeekCfgIDDict = \

            __GetOperationActionDisableIpyDataInfo(actName, curDateTime, curServerActIpyDataList)

            
        for ipyData in curServerActIpyDataList:

            

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

            serverGroupIDList = [] if not hasattr(ipyData, "ServerGroupIDList") else ipyData.GetServerGroupIDList()

            serverGroupIDListExcept = [] if not hasattr(ipyData, "ServerGroupIDListExcept") else ipyData.GetServerGroupIDListExcept()

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

            serverGroupIDList = [] if not hasattr(ipyData, "GetServerGroupIDList") else ipyData.GetServerGroupIDList()

            serverGroupIDListExcept = [] if not hasattr(ipyData, "GetServerGroupIDListExcept") else ipyData.GetServerGroupIDListExcept()

            cfgID = ipyData.GetCfgID()

            startDateStr = ipyData.GetStartDate()

            endDateStr = ipyData.GetEndDate()

@@ -209,6 +263,8 @@
            GameWorld.Log("    cfgID=%s,actNum=%s,startDateStr=%s,endDateStr=%s,openServerDay=%s,isMixServer=%s,mixServerDay=%s,curDateTime=%s,platformList=%s,serverGroupIDList=%s,Except=%s" 

                          % (cfgID, actNum, startDateStr, endDateStr, openServerDay, isMixServer, mixServerDay, curDateTime, platformList, serverGroupIDList, serverGroupIDListExcept))

            

            actIDDateTimeSpec = None # 特殊指定的活动ID日期

            startDateSync = None # 特殊同步前端显示用的开始日期，一般用于与开服前X天交叉的活动

            if actName in ShareDefine.MultiActNumOperationActNameList:

                # 多活动分组编号的需要把所有配置的 actNum 都登记进来，以确保地图能正确进行逻辑

                if actNum not in mapServerOperationActionDict[actName]:

@@ -225,10 +281,30 @@
                endDateStr = "%d-%d-%d" % (serverTime.year, serverTime.month, serverTime.day)

                GameWorld.Log("        结束日期为空，默认每天，今日为: endDateStr=%s" % endDateStr)

                

            # 开服常规：  开服天 > 日期 > 周x   （不受合服天影响，合服活动新增一套独立的活动，还是走运营活动配置）

            actByLoopYmd = startDateStr.startswith("L") # 按日期循环

            # 根据日期循环的通用

            if actByLoopYmd:

                if cfgID in coverDisableLoopIpyDataInfo:

                    loopStartDate, loopEndDate, ymdCfgID, ymdStartDate, ymdEndDate = coverDisableLoopIpyDataInfo[cfgID]

                    GameWorld.Log("        按日期循环的在按日期开启的时间内，不处理! cfgID=%s,%s(%s) ~ %s(%s) in ymdCfgID=%s,%s ~ %s" 
                                  % (cfgID, loopStartDate, startDateStr, loopEndDate, endDateStr, ymdCfgID, ymdStartDate, ymdEndDate))

                    continue

                
                if cfgID in disableLoopCfgIDDict:

                    GameWorld.Log("        按日期循环的未到开启循环日期或已结束循环日期，不处理! cfgID=%s,startDateStr=%s,endDateStr=%s" % (cfgID, startDateStr, endDateStr))

                    continue

                
                if cfgID in otherLoopCfgIDDict:

                    loopCfgIDList, startDateStr, endDateStr, loopIndex, loopTimes = otherLoopCfgIDDict[cfgID]

                    GameWorld.Log("        按日期循环的还未循环到当前配置，不处理! cfgID=%s,startDateStr=%s,endDateStr=%s,loopCfgIDList=%s,loopIndex=%s,loopTimes=%s" 
                                  % (cfgID, startDateStr, endDateStr, loopCfgIDList, loopIndex, loopTimes))

                    continue

                startDateStr, endDateStr = GameWorld.GetOperationActionDateStr(ipyData)

                
            # 开服常规：  开服天 > 日期 > 周x=日期循环   （不受合服天影响，合服活动新增一套独立的活动，还是走运营活动配置）

            if actType == ShareDefine.ActType_OpenComm:

                actByWeek = (startDateStr.startswith("W") and endDateStr.startswith("W")) # 按周x开

                actByDate = (startDateStr.count("-") == 2 and endDateStr.count("-") == 2) # 按日期开

                actByDate = (not actByLoopYmd and not actByWeek and startDateStr.count("-") == 2 and endDateStr.count("-") == 2) # 按日期开

                

                # 开服天的

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

@@ -244,25 +320,24 @@
                    GameWorld.Log("        开服天转化为日期: %s ~ %s" % (startDateStr, endDateStr))

                    

                # 常规配置: 开服前X天不开，不受合服影响，功能配置表可配置 开服前X天后交叉可开，每日重置的活动默认可开

                elif actByWeek or actByDate:

                elif actByWeek or actByDate or actByLoopYmd:

                    if openServerDay <= customMaxServerDay:

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

                        continue

                    

                    disableWeekIpyDataInfo = actNumDisableWeekIpyDataInfo.get(actNum, {})

                    if cfgID in disableWeekIpyDataInfo:

                        startWeekDate, endWeekDate, ymdCfgID, ymdStartDate, ymdEndDate = disableWeekIpyDataInfo[cfgID]

                    if cfgID in coverDisableWeekIpyDataInfo:

                        startWeekDate, endWeekDate, ymdCfgID, ymdStartDate, ymdEndDate = coverDisableWeekIpyDataInfo[cfgID]

                        GameWorld.Log("        常规活动，按星期开启的在按日期开启的时间内，不处理! cfgID=%s,%s(%s) ~ %s(%s) in ymdCfgID=%s,%s ~ %s" 

                                      % (cfgID, startWeekDate, startDateStr, endWeekDate, endDateStr, ymdCfgID, ymdStartDate, ymdEndDate))

                        continue

                    

                    if cfgID in disableWeekCfgIDDict:

                        GameWorld.Log("        常规活动，按星期开启的未到开启循环日期或已结束循环日期，不处理! cfgID=%s,startDateStr=%s,endDateStr=%s, %s" 
                                      % (cfgID, startDateStr, endDateStr, str(disableWeekCfgIDDict[cfgID])))

                        continue

                    
                    if actByWeek:

                        startWeekday = int(startDateStr[1:])

                        endWeekday = int(endDateStr[1:])

                        startWeekDate = curDateTime + datetime.timedelta(days=(startWeekday - curWeekday))

                        endWeekDate = curDateTime + datetime.timedelta(days=(endWeekday - curWeekday))

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

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

                        startDateStr, endDateStr = GameWorld.GetOperationActionDateStr(ipyData)

                        GameWorld.Log("        星期X转化为日期: %s ~ %s" % (startDateStr, endDateStr))

                        

                    curServerOpenDateTime = curDateTime + datetime.timedelta(days=(1 - openServerDay)) # 开服第一天的日期

@@ -275,6 +350,22 @@
                        if not isDayRest and actName not in startDateInCustomCanOpenList:

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

                            continue

                        
                        # 非每日重置的 且 开始天在定制天内在定制天结束后可继续开启的活动

                        # 注： 为防止开始日期与开服天内的活动开始天对应日期刚好同一天导致活动ID一样，所以这里默认将开始日期改为定制天后一天

                        if not isDayRest and actName in startDateInCustomCanOpenList:

                            actIDDateTimeSpec = datetime.datetime.strptime("%d-%d-%d 00:00:00" 
                                                                           % (customMaxServerDateTime.year, customMaxServerDateTime.month, customMaxServerDateTime.day), 
                                                                           ChConfig.TYPE_Time_Format) + datetime.timedelta(days=1)

                            GameWorld.Log("        开服天后可开启的非每日重置活动! 活动ID日期特殊设置为开服定制天结束后一天! cfgID=%s,actIDDateTimeSpec=%s" % (cfgID, actIDDateTimeSpec))

                            
                        # 特殊同步的开始日期，无视是否每日重置

                        if actName in startDateInCustomCanOpenList:

                            startDateSync = datetime.datetime.strptime("%d-%d-%d 00:00:00" 
                                                                       % (customMaxServerDateTime.year, customMaxServerDateTime.month, customMaxServerDateTime.day), 
                                                                       ChConfig.TYPE_Time_Format) + datetime.timedelta(days=1)

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

                            
                else:

                    GameWorld.Log("        开服常规活动，配置时间格式不支持，不处理! cfgID=%s,startDateStr=%s,endDateStr=%s" % (cfgID, startDateStr, endDateStr))

                    continue

@@ -308,6 +399,13 @@
                GameWorld.Log("        非法配置，未知活动类型，不处理! cfgID=%s,actNum=%s" % (cfgID, actNum))

                continue

            

            if hasattr(ipyData, "GetJoinStartTime") and hasattr(ipyData, "GetJoinEndTime"):

                joinStartTimeStr = ipyData.GetJoinStartTime()

                joinEndTimeStr = ipyData.GetJoinEndTime()

            else:

                joinStartTimeStr = ""

                joinEndTimeStr = ""

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

                startHMStrList = ipyData.GetStartTimeList()

                endHMStrList = ipyData.GetEndTimeList()

@@ -324,6 +422,7 @@
                                 % (actName, cfgID, startHMStrList, endHMStrList))

                continue

            

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

            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)

@@ -338,7 +437,7 @@
            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))

            
                
            advanceNoticeDateTime = None

            startDayDateJudge = startDayDate # 用于判断是否需要处理的起始时间，一般是活动开始时间，如果有提前广播或预告则时间会提前

            # 提前预告

@@ -363,6 +462,35 @@
                              % (activityIpyData.GetCfgID(), cfgID, advanceMinutes, minNotifyStartMinute, startDayDateJudge))

                continue

            

            #注：刚好是结束的时间点，防范已经有需要处理的配置被覆盖

            if curActTodayInfo and curDateTime == endDayDate:

                activityIpyData = curActTodayInfo[0]

                GameWorld.Log("        已经存在需要处理的配置ID(%s)！ 当前刚好结束的时间点，不处理！cfgID=%s" % (activityIpyData.GetCfgID(), cfgID))

                continue

            
            # 在需要处理的时间内附加世界等级开启限制，未达到最低世界等级要求的不开，活动时间从未达到到达到也不开

            limitWorldLV = 0 if not hasattr(ipyData, "GetLimitWorldLV") else ipyData.GetLimitWorldLV() # 限制开启世界等级

            if limitWorldLV:

                GameWorld.Log("        limitWorldLV=%s,curWorldLV=%s" % (limitWorldLV, curWorldLV))

                recInfoType = ""

                worldLVLimitInfo = actWorldLVLimitInfoOld.get(actName, {})

                # 注： 该逻辑是在活动时间内的额外处理，所以需要判断此逻辑的前提理论上都在活动时间内，故只要有记录则以当时的记录为准

                if cfgID in worldLVLimitInfo:

                    recInfoType = "Old"

                    recStartDateStr, recEndDateStr, recLimitWorldLV, recWorldLV = worldLVLimitInfo[cfgID]

                else:

                    recInfoType = "New"

                    recStartDateStr, recEndDateStr, recLimitWorldLV, recWorldLV = startDateStr, endDateStr, limitWorldLV, curWorldLV

                    
                if actName not in actWorldLVLimitInfoNew:

                    actWorldLVLimitInfoNew[actName] = {}

                actWorldLVLimitInfoNew[actName][cfgID] = [recStartDateStr, recEndDateStr, recLimitWorldLV, recWorldLV]

                
                if recLimitWorldLV > recWorldLV:

                    GameWorld.Log("        活动时间内，但服务器世界等级未达到开启活动世界等级，不处理！recLimitWorldLV=%s > recWorldLV=%s %s" 
                                  % (recLimitWorldLV, recWorldLV, recInfoType))

                    continue

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

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

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

@@ -401,6 +529,17 @@
                GameWorld.Log("        advanceNoticeDateTime=%s,isAdvanceNotice=%s" % (advanceNoticeDateTime, isAdvanceNotice))

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

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

            
            joinStartTimeList, joinEndTimeList = [], [] # 可指定活动可参与的时间点，不影响活动状态，只影响活动某些功能的参与时机，如上榜类

            if joinStartTimeStr:

                if isDayRest:

                    joinStartTimeList.append(datetime.datetime.strptime("%d-%d-%d %s:00" % (curDateTime.year, curDateTime.month, curDateTime.day, joinStartTimeStr), ChConfig.TYPE_Time_Format))

                    joinEndTimeList.append(datetime.datetime.strptime("%d-%d-%d %s:00" % (curDateTime.year, curDateTime.month, curDateTime.day, joinEndTimeStr), ChConfig.TYPE_Time_Format))

                else:

                    joinStartTimeList.append(datetime.datetime.strptime("%s %s:00" % (startDateStr, joinStartTimeStr), ChConfig.TYPE_Time_Format))

                    joinEndTimeList.append(datetime.datetime.strptime("%s %s:00" % (endDateStr, joinEndTimeStr), ChConfig.TYPE_Time_Format))                    
            GameWorld.Log("        joinStartTimeList=%s" % (joinStartTimeList))

            GameWorld.Log("        joinEndTime  List=%s" % (joinEndTimeList))

            

            for dtIndex, startDateTime in enumerate(startList):

                endDateTime = endList[dtIndex]

@@ -447,9 +586,9 @@
            if actName in ShareDefine.MultiActNumOperationActNameList:

                if actName not in operationTodayActionDict:

                    operationTodayActionDict[actName] = {} # 今日有需要处理的才初始化

                operationTodayActionDict[actName][actNum] = [ipyData, startList, endList, notifyDict]

                operationTodayActionDict[actName][actNum] = [ipyData, startList, endList, notifyDict, joinStartTimeList, joinEndTimeList]

            else:

                operationTodayActionDict[actName] = [ipyData, startList, endList, notifyDict]

                operationTodayActionDict[actName] = [ipyData, startList, endList, notifyDict, joinStartTimeList, joinEndTimeList]

                

            if isActTime:

                activityInfoDict = {ShareDefine.ActKey_CfgID:cfgID, ShareDefine.ActKey_ActNum:actNum}

@@ -457,12 +596,17 @@
                    #活动每天的世界等级

                    activityInfoDict[ShareDefine.ActKey_WorldLVList] = GameWorldAverageLv.GetWorldLVListByTime(startDayDate, (endDayDate - startDayDate).days)

                    

                if startDateSync:

                    activityInfoDict[ShareDefine.ActKey_StartDateSync] = startDateSync

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

                    
                dayIndex = (curDateTime - startDayDate).days

                actIDDateTime = startDayDate

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

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

                if isDayRest or (startHMStrList and endHMStrList):

                    actIDDateTime += datetime.timedelta(days=dayIndex)

                if actIDDateTimeSpec:

                    actIDDateTime = actIDDateTimeSpec

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

                activityInfoDict[ShareDefine.ActKey_DayIndex] = dayIndex

                activityInfoDict[ShareDefine.ActKey_ID] = actID

@@ -476,6 +620,7 @@
                    mapServerOperationActionDict[actName] = activityInfoDict

                    

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

    __SaveActWorldLVLimitInfo(actWorldLVLimitInfoNew)

    

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

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

@@ -497,9 +642,9 @@
    actCfgCount = getattr(ipyDataMgr, "Get%sCount" % actName)()

    for cfgIndex in xrange(actCfgCount):

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

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

        serverGroupIDList = [] if not hasattr(ipyData, "ServerGroupIDList") else ipyData.GetServerGroupIDList()

        serverGroupIDListExcept = [] if not hasattr(ipyData, "ServerGroupIDListExcept") else ipyData.GetServerGroupIDListExcept()

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

        serverGroupIDList = [] if not hasattr(ipyData, "GetServerGroupIDList") else ipyData.GetServerGroupIDList()

        serverGroupIDListExcept = [] if not hasattr(ipyData, "GetServerGroupIDListExcept") else ipyData.GetServerGroupIDListExcept()

        

        if platformList and platform not in platformList:

            continue

@@ -528,138 +673,109 @@
                

    return curServerActIpyDataList



def __GetOperationActionDisableWeekIpyDataInfo(actName, curDateTime, curServerActIpyDataList):

def __GetOperationActionDisableIpyDataInfo(actName, curDateTime, curServerActIpyDataList):

    ## 获取不可用的按星期X开启的配置数据信息，按星期X开启的 活动优先级小于按日期的，当有重叠时以日期的为准

    curWeekday = curDateTime.weekday() + 1 # 今天星期几, 1代表星期1

    actNumWeekYMDIpyDataInfo = {} # {actNum:[weekIpyDataList, ymdIpyDatList], ...}

    # 优先级 日期 > 按日期循环 > 按星期循环

    
    actNumYMDIpyDataInfo = {} # {actNum:ymdIpyDataList, ...} # 配置日期的

    actNumLoopIpyDataInfo = {} # {actNum:{loopKey:[loopCfgIDList, loopDateInfo]}, ...} # 按日期循环的

    actNumWeekIpyDataInfo = {} # {actNum:weekIpyDataList, ...} # 按星期循环的

    
    disableWeekCfgIDDict = {} # {cfgID:[startDateStr, endDateStr], ...} # 未开始循环的星期

    disableLoopCfgIDDict = {} # {cfgID:[startDateStr, endDateStr], ...} # 未开始循环的日期

    
    curDateTimeYmdStr = "%d-%d-%d" % (curDateTime.year, curDateTime.month, curDateTime.day)

    curDateTimeYmd = GameWorld.ChangeStrToDatetime(curDateTimeYmdStr, ChConfig.TYPE_Time_YmdFormat)

    

    for ipyData in curServerActIpyDataList:

        cfgID = ipyData.GetCfgID()

        startDateStr = ipyData.GetStartDate()

        endDateStr = ipyData.GetEndDate()

        actNum = GetOperationActNum(actName, ipyData)

        actType = GetOperationActType(actNum)

        # 这里只处理常规运营活动，日期优先级大于周

        if actType != ShareDefine.ActType_OpenComm:

            continue

        
        if actNum not in actNumWeekYMDIpyDataInfo:

            weekIpyDataList, ymdIpyDatList = [], []

            actNumWeekYMDIpyDataInfo[actNum] = [weekIpyDataList, ymdIpyDatList]

        weekIpyDataList, ymdIpyDatList = actNumWeekYMDIpyDataInfo[actNum]

        

        # 按星期X的

        if startDateStr.startswith("W"):

            startWeekday = int(startDateStr[1:])

            endWeekday = int(endDateStr[1:])

            startWeekDate = curDateTime + datetime.timedelta(days=(startWeekday - curWeekday))

            endWeekDate = curDateTime + datetime.timedelta(days=(endWeekday - curWeekday))

            weekIpyDataList.append([ipyData, startWeekDate, endWeekDate])

            if actNum not in actNumWeekIpyDataInfo:

                actNumWeekIpyDataInfo[actNum] = []

            weekIpyDataList = actNumWeekIpyDataInfo[actNum]

            startDateStr, endDateStr = GameWorld.GetOperationActionDateStr(ipyData)

            startWeekDate = GameWorld.ChangeStrToDatetime(startDateStr, ChConfig.TYPE_Time_YmdFormat)

            endWeekDate = GameWorld.ChangeStrToDatetime(endDateStr, ChConfig.TYPE_Time_YmdFormat)

            if startWeekDate > curDateTimeYmd or curDateTimeYmd > endWeekDate: # 还未开始的循环 or 已经强制结束的循环

                disableWeekCfgIDDict[cfgID] = [startDateStr, endDateStr]

            else:

                weekIpyDataList.append([cfgID, startWeekDate, endWeekDate])

            
        # 按日期循环

        elif startDateStr.startswith("L"):

            loopStartDate, loopEndDate, loopTimes = GameWorld.GetOperationActionLoopDate(startDateStr, endDateStr, curDateTime)

            if loopStartDate > curDateTimeYmd or curDateTimeYmd > loopEndDate: # 还未开始的循环 or 已经强制结束的循环

                disableLoopCfgIDDict[cfgID] = [startDateStr, endDateStr]

            else:

                loopKey = (startDateStr, endDateStr) # 同个循环周期的视为同一组

                if actNum not in actNumLoopIpyDataInfo:

                    actNumLoopIpyDataInfo[actNum] = {}

                loopIpyDataDict = actNumLoopIpyDataInfo[actNum]

                if loopKey not in loopIpyDataDict:

                    loopCfgIDList, loopDateInfo = [], [loopStartDate, loopEndDate, loopTimes]

                    loopIpyDataDict[loopKey] = [loopCfgIDList, loopDateInfo]

                loopCfgIDList, loopDateInfo = loopIpyDataDict[loopKey]

                loopCfgIDList.append(cfgID)

                
        # 按日期的

        elif startDateStr.count("-") == 2:

            ymdIpyData = ipyData

            ymdStartDate = datetime.datetime.strptime("%s %02d:%02d:00" % (startDateStr, curDateTime.hour, curDateTime.minute), ChConfig.TYPE_Time_Format)

            ymdEndDate = datetime.datetime.strptime("%s %02d:%02d:00" % (endDateStr, curDateTime.hour, curDateTime.minute), ChConfig.TYPE_Time_Format)

            ymdIpyDatList.append([ymdIpyData, ymdStartDate, ymdEndDate])

            if actNum not in actNumYMDIpyDataInfo:

                actNumYMDIpyDataInfo[actNum] = []

            ymdIpyDataList = actNumYMDIpyDataInfo[actNum]

            ymdStartDate = GameWorld.ChangeStrToDatetime(startDateStr, ChConfig.TYPE_Time_YmdFormat)

            ymdEndDate = GameWorld.ChangeStrToDatetime(endDateStr, ChConfig.TYPE_Time_YmdFormat)

            ymdIpyDataList.append([cfgID, ymdStartDate, ymdEndDate])

            

        else:

            # 只处理按星期、按日期的，其他的不处理

            # 其他的不处理

            pass

        

    actNumDisableWeekIpyDataInfo = {} # {actNum:{cfgID:[info], ...}, ...}

    for actNum, weekYMDIpyDataInfo in actNumWeekYMDIpyDataInfo.items():

        weekIpyDataList, ymdIpyDatList = weekYMDIpyDataInfo

        for ipyData, startWeekDate, endWeekDate in weekIpyDataList:

            cfgID = ipyData.GetCfgID()

            for ymdIpyData, ymdStartDate, ymdEndDate in ymdIpyDatList:

                if ymdStartDate <= startWeekDate <= ymdEndDate or ymdStartDate <= endWeekDate <= ymdEndDate:

                    if actNum not in actNumDisableWeekIpyDataInfo:

                        actNumDisableWeekIpyDataInfo[actNum] = {}

                    ymdCfgID = ymdIpyData.GetCfgID()

                    actNumDisableWeekIpyDataInfo[actNum][cfgID] = [startWeekDate, endWeekDate, ymdCfgID, ymdStartDate, ymdEndDate]

    nowLoopYMDIpyDataInfo = {} # {actNum:loopIpyDataList, ...} # # 日期循环中当前在循环的

    otherLoopCfgIDDict = {} # {cfgID:[info], ...} # 日期循环中不是当前循环的其他循环

    coverDisableLoopIpyDataInfo = {} # {cfgID:[info], ...} # 被日期覆盖的日期循环

    for actNum, loopIpyDataDict in actNumLoopIpyDataInfo.items():

        ymdIpyDataList = actNumYMDIpyDataInfo.get(actNum, [])

        if actNum not in nowLoopYMDIpyDataInfo:

            nowLoopYMDIpyDataInfo[actNum] = []

        loopIpyDataList = nowLoopYMDIpyDataInfo[actNum]

        for loopKey, loopInfo in loopIpyDataDict.items():

            startDateStr, endDateStr = loopKey

            loopCfgIDList, loopDateInfo = loopInfo

            loopStartDate, loopEndDate, loopTimes = loopDateInfo

            loopIndex = (loopTimes - 1) % len(loopCfgIDList) # 当前循环次数对应的循环索引

            curLoopCfgID = 0

            for index, loopCfgID in enumerate(loopCfgIDList):

                if index == loopIndex: # 当前循环的

                    curLoopCfgID = loopCfgID

                    loopIpyDataList.append([loopCfgID, loopStartDate, loopEndDate])

                else:

                    otherLoopCfgIDDict[loopCfgID] = [loopCfgIDList, startDateStr, endDateStr, loopIndex, loopTimes]

                    

    return actNumDisableWeekIpyDataInfo



def TransferOperationActDBKeyValue():

    '''  服务器启动时调用

            支持多活动的数据转移，旧版本db活动数据转移到新版本，分两种情况

    1. 原已支持多活动的：  手动根据原编号规则进行指定转移，这个维护一次后代码可删除

    2. 原不支持多活动的，自动根据原活动类型进行适配转移即可，由于合服相关的独立出来了，所以只需要处理常规的及节日类型

                           这个代码可以一直放着，后续增加支持多活动类型的配置到  MultiActNumOperationActNameList 即可

                           
           注：不支持多活动的，暂还是用旧的key记录数据

    '''

    GameWorld.Log("=== 转移运营活动旧版本数据到新版本 ===")

    
    # 1. 原已支持的  - 维护后过一次后可删除或注释掉，目前只有累计充值、集字，线上版本分支 gt_1.100.4

    transferDict = {

                    ShareDefine.OperationActionName_TotalRecharge:[

                            # 原常规每日累充  转移 到 10

                            [PlayerDBGSEvent.Def_OperationActID % ShareDefine.OperationActionName_TotalRecharge,

                             PlayerDBGSEvent.Def_OperationActID % ShareDefine.OperationActionName_TotalRecharge + "_%s" % 10,

                             ],

                            [PlayerDBGSEvent.Def_OActWorldLV % ShareDefine.OperationActionName_TotalRecharge,

                             PlayerDBGSEvent.Def_OActWorldLV % ShareDefine.OperationActionName_TotalRecharge + "_%s" % 10,

                             ],

                                                                                          
                            # 原常规多日累充2  转移 到 11

                            [PlayerDBGSEvent.Def_OperationActID % (ShareDefine.OperationActionName_TotalRecharge + "2"),

                             PlayerDBGSEvent.Def_OperationActID % ShareDefine.OperationActionName_TotalRecharge + "_%s" % 11,

                             ],

                            [PlayerDBGSEvent.Def_OActWorldLV % (ShareDefine.OperationActionName_TotalRecharge + "2"),

                             PlayerDBGSEvent.Def_OActWorldLV % ShareDefine.OperationActionName_TotalRecharge + "_%s" % 11,

                             ],

                                                                                                  
                            # 原节日多日累充3  转移 到 31

                            [PlayerDBGSEvent.Def_OperationActID % (ShareDefine.OperationActionName_TotalRecharge + "3"),

                             PlayerDBGSEvent.Def_OperationActID % ShareDefine.OperationActionName_TotalRecharge + "_%s" % 31,

                             ],

                            [PlayerDBGSEvent.Def_OActWorldLV % (ShareDefine.OperationActionName_TotalRecharge + "3"),

                             PlayerDBGSEvent.Def_OActWorldLV % ShareDefine.OperationActionName_TotalRecharge + "_%s" % 31,

                             ],

                                                                   ],

                    ShareDefine.OperationActionName_CollectWords:[

                            # 只配置了常规日期的，可不处理

                                                                  ],

                    }

    for actName, transferKeyList in transferDict.items():

        for oldKey, newKey in transferKeyList:

            value = PlayerDBGSEvent.GetDBGSTrig_ByKey(oldKey)

            if not value:

                continue

            GameWorld.Log("    转移旧运营活动dbKey值到新key: actName=%s,oldKey=%s,newKey=%s,value=%s" % (actName, oldKey, newKey, value))

            PlayerDBGSEvent.SetDBGSTrig_ByKey(newKey, value)

            PlayerDBGSEvent.DelDBGSTrig_ByKey(oldKey)

            
    # 2. 新增支持的 - 可当做常规代码一直留着

    for actName in ShareDefine.MultiActNumOperationActNameList:

        if actName in transferDict:

            # 特殊处理转化的活动不进行常规处理

            continue

        
        actIDKeyOld = PlayerDBGSEvent.Def_OperationActID % actName

        worldLVKeyOld = PlayerDBGSEvent.Def_OActWorldLV % actName

        
        actNum = GetOperationActNum(actName)

        actIDKeyNew = actIDKeyOld + "_%s" % actNum

        worldLVKeyNew = worldLVKeyOld + "_%s" % actNum

        
        dbActID = PlayerDBGSEvent.GetDBGSTrig_ByKey(actIDKeyOld)

        dbWorldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(worldLVKeyOld)

        if not dbActID:

            continue

        
        GameWorld.Log("    转移旧运营活动dbKey值到新key: actName=%s" % actName)

        PlayerDBGSEvent.SetDBGSTrig_ByKey(actIDKeyNew, dbActID)

        PlayerDBGSEvent.DelDBGSTrig_ByKey(actIDKeyOld)

        GameWorld.Log("        actIDKeyOld=%s,actIDKeyNew=%s,dbActID=%s" % (actIDKeyOld, actIDKeyNew, dbActID))

        
        if dbWorldLV:

            PlayerDBGSEvent.SetDBGSTrig_ByKey(worldLVKeyNew, dbWorldLV)

            PlayerDBGSEvent.DelDBGSTrig_ByKey(worldLVKeyOld)

            GameWorld.Log("        worldLVKeyOld=%s,worldLVKeyNew=%s,dbWorldLV=%s" % (worldLVKeyOld, worldLVKeyNew, dbWorldLV))

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

    return

            for ymdCfgID, ymdStartDate, ymdEndDate in ymdIpyDataList:

                if ymdStartDate <= loopStartDate <= ymdEndDate or ymdStartDate <= loopEndDate <= ymdEndDate:

                    coverDisableLoopIpyDataInfo[curLoopCfgID] = [loopStartDate, loopEndDate, ymdCfgID, ymdStartDate, ymdEndDate]

                    
    coverDisableWeekIpyDataInfo = {} # {cfgID:[info], ...} # 被日期覆盖的星期循环

    for actNum, weekIpyDataList in actNumWeekIpyDataInfo.items():

        ymdIpyDataList = actNumYMDIpyDataInfo.get(actNum, [])

        loopIpyDatList = nowLoopYMDIpyDataInfo.get(actNum, [])

        for weekCfgID, startWeekDate, endWeekDate in weekIpyDataList:

            # 被常规日期覆盖的

            for ymdCfgID, ymdStartDate, ymdEndDate in ymdIpyDataList:

                if ymdStartDate <= startWeekDate <= ymdEndDate or ymdStartDate <= endWeekDate <= ymdEndDate:

                    coverDisableWeekIpyDataInfo[weekCfgID] = [startWeekDate, endWeekDate, ymdCfgID, ymdStartDate, ymdEndDate]

                    
            # 被循环日期覆盖的

            for loopCfgID, loopStartDate, loopEndDate in loopIpyDatList:

                if loopStartDate <= startWeekDate <= loopEndDate or loopStartDate <= endWeekDate <= loopEndDate:

                    coverDisableWeekIpyDataInfo[weekCfgID] = [startWeekDate, endWeekDate, loopCfgID, loopStartDate, loopEndDate]

                    
    return coverDisableLoopIpyDataInfo, disableLoopCfgIDDict, otherLoopCfgIDDict, coverDisableWeekIpyDataInfo, disableWeekCfgIDDict



def Dispose_OperationActionState(reloadRefresh=False):

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

@@ -694,6 +810,7 @@
        for sendMapServerMsgDict in curActMapInfoDictList:

            

            state = 0 # 默认关闭

            stateJoin = ShareDefine.ActStateJoin_None # 可参与状态，0-参与前；1-可参与；2-参与结束

            ipyData = None

            

            actNum = sendMapServerMsgDict.get(ShareDefine.ActKey_ActNum, 0)

@@ -706,12 +823,12 @@
                else:

                    todayActInfoList = operationTodayActionDict[actName]

                    

                if isinstance(todayActInfoList, list) and len(todayActInfoList) == 4:

                if isinstance(todayActInfoList, list) and len(todayActInfoList) == 6:

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

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

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

                    #ipyData 可能为 None

                    ipyData, startList, endList, notifyDict = todayActInfoList

                    ipyData, startList, endList, notifyDict, joinStartTimeList, joinEndTimeList = todayActInfoList

                    

                    # ״̬

                    for dIndex, startDateTime in enumerate(startList):

@@ -720,21 +837,39 @@
                            state = dIndex + 1 # 代表第几个时间段

                            break

                        

                    if joinStartTimeList:

                        for jIndex, joinStartDateTime in enumerate(joinStartTimeList):

                            endJoinDateTime = joinEndTimeList[jIndex]

                            if joinStartDateTime <= curDateTime < endJoinDateTime:

                                stateJoin = ShareDefine.ActStateJoin_Start

                                break

                            elif curDateTime >= endJoinDateTime:

                                stateJoin = ShareDefine.ActStateJoin_End

                    else:

                        stateJoin = ShareDefine.ActStateJoin_Start if state else ShareDefine.ActStateJoin_None

                        
                    # 全服广播提示信息

                    if curDateTime in notifyDict:

                        notifyKey, paramList = notifyDict[curDateTime]

                        PlayerControl.WorldNotify(0, notifyKey, paramList)

                        

            dictName = ChConfig.Def_WorldKey_OperationActionState % actName

            if actName in ShareDefine.MultiActNumOperationActNameList:         
            if actName in ShareDefine.MultiActNumOperationActNameList:

                dictName += "_%s" % actNum

            preState = gameWorld.GetDictByKey(dictName)

            if not isReload and preState == state:

            
            dictNameJoin = ChConfig.Def_WorldKey_OperationActionStateJoin % actName

            if actName in ShareDefine.MultiActNumOperationActNameList:

                dictNameJoin += "_%s" % actNum

            preStateJoin = gameWorld.GetDictByKey(dictNameJoin)

            
            if not isReload and preState == state and preStateJoin == stateJoin:

                #已经是这个状态了

                continue

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

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

            #更新字典值

            gameWorld.SetDict(dictName, state)

            gameWorld.SetDict(dictNameJoin, stateJoin)

            

            dbOperationActIDKey = PlayerDBGSEvent.Def_OperationActID % actName

            dbOperationActWorldLVKey = PlayerDBGSEvent.Def_OActWorldLV % actName

@@ -749,6 +884,17 @@
                GameWorld.Log("    dbActID变更: dbActID=%s,curActID=%s" % (dbActID, curActID))

                PlayerDBGSEvent.SetDBGSTrig_ByKey(dbOperationActIDKey, curActID)

                

                # 结束旧的

                if dbActID:

                    if actName == ShareDefine.OperationActionName_BossTrial:

                        PlayerActBossTrial.OnActEnd(actNum, ipyData, dayIndex)

                    elif actName == ShareDefine.OperationActionName_XianXiaMJ:

                        PlayerActXianXiaMJ.OnActEnd(actNum, ipyData, dayIndex)

                    elif actName == ShareDefine.OperationActionName_Gubao:

                        PlayerActGubao.OnActEnd(actNum, ipyData, dayIndex)

                    elif actName == ShareDefine.OperationActionName_HorsePetTrain:

                        PlayerActHorsePetTrain.OnActEnd(actNum, ipyData, dayIndex)

                        
                if curActID:

                    if actName in ShareDefine.NeedWorldLVOperationActNameList:

                        #记录开启时世界等级

@@ -774,10 +920,54 @@
                        #限时抢购重置购买次数 本次活动每场不能重复

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

                        PlayerStore.ResetFlashSaleBuyCnt(ipyData)

                    elif actName == ShareDefine.OperationActionName_GarbageSorting:

                        PlayerActGarbageSorting.OnActStart(actNum)

                    elif actName == ShareDefine.OperationActionName_BossTrial:

                        PlayerActBossTrial.OnActStart(actNum)

                    elif actName == ShareDefine.OperationActionName_XianXiaMJ:

                        PlayerActXianXiaMJ.OnActStart(actNum, ipyData)

                    elif actName == ShareDefine.OperationActionName_Gubao:

                        PlayerActGubao.OnActStart(actNum, ipyData)

                    elif actName == ShareDefine.OperationActionName_HorsePetTrain:

                        PlayerActHorsePetTrain.OnActStart(actNum, ipyData)

                    elif actName == ShareDefine.OperationActionName_FamilyCTGAssist:

                        PlayerActFamilyCTGAssist.OnActStart(actNum)

                else:

                    if actName == ShareDefine.OperationActionName_GarbageSorting:

                        PlayerActGarbageSorting.OnActEnd(actNum)

                        
            else:

                GameWorld.Log("    dbActID不变: dbActID=%s,curActID=%s" % (dbActID, curActID))

                

            if state and actName in ShareDefine.NeedWorldLVOperationActNameList:

            # 活动中刷新，每次都需要刷新的逻辑，包含重读配置等

            if state:

                if actName == ShareDefine.OperationActionName_BossTrial:

                    PlayerActBossTrial.OnActInStateRefresh(actNum, ipyData, dayIndex)

                elif actName == ShareDefine.OperationActionName_XianXiaMJ:

                    PlayerActXianXiaMJ.OnActInStateRefresh(actNum, ipyData)

                elif actName == ShareDefine.OperationActionName_Gubao:

                    PlayerActGubao.OnActInStateRefresh(actNum, ipyData)

                elif actName == ShareDefine.OperationActionName_HorsePetTrain:

                    PlayerActHorsePetTrain.OnActInStateRefresh(actNum, ipyData)

                    
            # 仅活动有配置参与时间段的会触发

            if curActID and dbActID == curActID and preStateJoin != stateJoin:

                GameWorld.Log("    参与状态变更: preStateJoin=%s,stateJoin=%s" % (preStateJoin, stateJoin))

                # 参与开始

                if stateJoin == ShareDefine.ActStateJoin_Start:

                    pass

                # 参与结束

                elif stateJoin == ShareDefine.ActStateJoin_End:

                    if actName == ShareDefine.OperationActionName_BossTrial:

                        PlayerActBossTrial.OnActJoinEnd(actNum, ipyData, dayIndex)

                    elif actName == ShareDefine.OperationActionName_XianXiaMJ:

                        PlayerActXianXiaMJ.OnActJoinEnd(actNum, ipyData, dayIndex)

                    elif actName == ShareDefine.OperationActionName_Gubao:

                        PlayerActGubao.OnActJoinEnd(actNum, ipyData, dayIndex)

                    elif actName == ShareDefine.OperationActionName_HorsePetTrain:

                        PlayerActHorsePetTrain.OnActJoinEnd(actNum, ipyData, dayIndex)

                        
            if ipyData and actName in ShareDefine.NeedWorldLVOperationActNameList:

                actWorldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(dbOperationActWorldLVKey)

                sendMapServerMsgDict[ShareDefine.ActKey_WorldLV] = actWorldLV

                GameWorld.Log("    活动世界等级: actWorldLV=%s" % (actWorldLV))

@@ -786,13 +976,16 @@
                if isReload and ipyData:

                    Sync_OperationAction_ExpRate(ipyData)

                    

            elif actName == ShareDefine.OperationActionName_CostRebate:

                if isReload and ipyData:

                    pass

            elif actName == ShareDefine.OperationActionName_BossReborn:

                if isReload and ipyData:

                    GameWorldBoss.SetBossRebornNeedPoint(True)

    
                    
            elif actName == ShareDefine.OperationActionName_HorsePetFeast:

                if preState != state and state:

                    relatedID = "%s|%s" % (actName, actNum)

                    GameWorld.Log("    骑宠盛宴开始: relatedID=%s" % (relatedID))

                    GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_ActionBossRebornSign % relatedID, int(time.time()))

                    
            elif actName == ShareDefine.OperationActionName_FairyCeremony:

                if isReload and ipyData:

                    PlayerFairyCeremony.Sync_OperationAction_FairyCeremony(ipyData)

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

            

            sendMapServerMsgDict[ShareDefine.ActKey_State] = state

            sendMapServerMsgDict[ShareDefine.ActKey_StateJoin] = stateJoin

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

            

            GameWorld.Log("    sendMapServerMsgDict: %s" % (sendMapServerMsgDict))

@@ -830,11 +1024,11 @@
        return

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

        return

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

    startDateStr, endDateStr = GameWorld.GetOperationActionDateStr(ipyData)

    multiExpRateInfo = ChPyNetSendPack.tagGCMultiExpRateInfo()

    multiExpRateInfo.Clear()

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

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

    multiExpRateInfo.StartDate = startDateStr

    multiExpRateInfo.EndtDate = endDateStr

    multiExpRateInfo.ActivityTime = []

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

        endTime = ipyData.GetEndTimeList()[i]

@@ -863,11 +1057,11 @@
    ##多倍修行点活动信息通知

    if not ipyData:

        return

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

    startDateStr, endDateStr = GameWorld.GetOperationActionDateStr(ipyData)

    multiRealmPointInfo = ChPyNetSendPack.tagGCMultiRealmPointInfo()

    multiRealmPointInfo.Clear()

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

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

    multiRealmPointInfo.StartDate = startDateStr

    multiRealmPointInfo.EndtDate = endDateStr

    multiRealmPointInfo.Multiple = ipyData.GetMultiple()

    multiRealmPointInfo.LimitLV = ipyData.GetLVLimit()

    multiRealmPointInfo.LimitPoint = ipyData.GetPointLimit()

@@ -906,7 +1100,7 @@
    curDateStr = GameWorld.ChangeTimeNumToStr(curTime, ChConfig.TYPE_Time_YmdFormat) # 当天日期

    

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

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

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

    maxCustomServerDayMix = IpyGameDataPY.GetFuncCfg("MixServer", 1)

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

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

@@ -920,7 +1114,7 @@
        customIpyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("DailyActionCustom", openServerWeekday)

        if not customIpyDataList:

            customIpyDataList = []

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

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

        customIDList = []

        todayCustomIDList = []

        for customIpyData in customIpyDataList:

@@ -934,8 +1128,8 @@
                customType = 1

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

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

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

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

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

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

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

    elif isMixServer and mixServerDay <= maxCustomServerDayMix:

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

@@ -962,6 +1156,10 @@
    for i in xrange(dailyActionCount):

        dailyIpyData = ipyDataMgr.GetDailyActionByIndex(i)

        dailyID = dailyIpyData.GetDailyID()

        
        if dailyID in [ShareDefine.DailyActionID_CrossBattlefield]:

            GameWorld.Log("    不需要处理的日常活动! dailyID=%s" % dailyID)

            continue

        

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

        if dailyID in customDailyIDList:

@@ -1030,6 +1228,9 @@
def Dispose_DailyActionState():

    # 日常活动状态变更检查处理

    

    if GameWorld.IsCrossServer():

        CrossActionControl.Dispose_CrossDailyActionState()

    
    todayDailyActionInfo = __GetTodayDailyActionInfo()

    if not todayDailyActionInfo:

        return

@@ -1095,11 +1296,20 @@
def SendMapServerDailyActionState():

    # 地图启动成功时通知本日进行中的日常活动状态

    

    gameWorld = GameWorld.GetGameWorld()

    if GameWorld.IsCrossServer():

        CrossActionControl.SendMapServerCrossDailyActionState()

    else:

        for dailyActionID in ShareDefine.CrossDailyActionIDList:

            dictName = ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % dailyActionID 
            state = gameWorld.GetDictByKey(dictName)

            if state:

                GameWorld.SendMapServerMsgEx(dictName, state)

            
    todayDailyActionInfo = __GetTodayDailyActionInfo()

    if not todayDailyActionInfo:

        return

    

    gameWorld = GameWorld.GetGameWorld()

    for actionInfo in todayDailyActionInfo:

        dailyActionID = actionInfo[0]

        dictName = ShareDefine.Def_Notify_WorldKey_DailyActionState % dailyActionID 

@@ -1208,7 +1418,7 @@
        GameWorld.ErrLog("获取开服是星期几数据错误！openServerWeekday=%s" % openServerWeekday)

        return []

    

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

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

    maxCustomServerDayMix = IpyGameDataPY.GetFuncCfg("MixServer", 1)

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

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

@@ -1217,15 +1427,15 @@
    

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    

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

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

    fbStateTimeInfoList = []

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

    if openServerDay <= curMaxCustomServerDay:

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

        if not customIpyDataList:

            customIpyDataList = []

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

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

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

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

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

        for customIpyData in customIpyDataList:

            dataID = customIpyData.GetID()

@@ -1238,8 +1448,8 @@
                customType, startWeekDay, endWeekDay = 1, curWeekDay, curWeekDay

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

                GameWorld.Log("    今天要处理的开服副本状态配置: customType=%s,dataID=%s" % (customType, dataID))

        GameWorld.Log("    本周定制的开服副本表ID列表: %s" % (customIDList))

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

        GameWorld.Log("    定制的开服副本表ID列表: %s" % (customIDList))

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

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

    elif isMixServer and mixServerDay <= maxCustomServerDayMix:

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

@@ -1267,7 +1477,7 @@
        dataMapID = fbStateTimeIpyData.GetDataMapID()

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

        if dataMapID in customMapIDList:

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

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

            continue

        # 暂不支持跨天的活动

        customType, startWeekDay, endWeekDay = 0, fbStateTimeIpyData.GetStartWeekday(), fbStateTimeIpyData.GetStartWeekday()