#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package GameWorldLogic.GameWorldEvent
#
# @todo:·þÎñÆ÷ÊÀ½çʼþ
# @author hxp
# @date 2025-05-15
# @version 1.0
#
# ÏêϸÃèÊö: ·þÎñÆ÷ÊÀ½çʼþ
#
#-------------------------------------------------------------------------------
#"""Version = 2025-05-15 10:35"""
#-------------------------------------------------------------------------------

import CrossMgr
import ChConfig
import DBDataMgr
import GameWorld
import PyMongoMain
import PlayerFamily
import IpyGameDataPY
import IPY_GameWorld
import DataRecordPack
import PlayerEventCounter
import PlayerViewCache
import PlayerControl
import NetPackCommon
import PlayerOnline
import ShareDefine
import PyGameData
import BattleObj
import ChPlayer
import ObjPool

import datetime
import time

def Get_Server_Year(): return DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_Server_Year)
def Set_Server_Year():
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_Server_Year, datetime.datetime.today().year)
    return
def Get_Server_Month(): return DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_Server_Month)
def Set_Server_Month():
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_Server_Month, datetime.datetime.today().month)
    return
def Get_Server_Week(): return DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_Server_Week)
def Set_Server_Week():
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_Server_Week, datetime.datetime.isocalendar(datetime.datetime.today())[1])
    return
def Get_Server_Day(): return DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_Server_Day)
def Set_Server_Day():
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_Server_Day, datetime.datetime.today().day)
    return
def Get_Server_Hour(): return DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_Server_Hour)
def Set_Server_Hour():
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_Server_Hour, datetime.datetime.today().hour)
    return

def InitServerTime():
    ## ³õʼ»¯·þÎñÆ÷ʱ¼ä
    if not Get_Server_Year():
        Set_Server_Hour()
        Set_Server_Day()
        Set_Server_Week()
        Set_Server_Month()
        Set_Server_Year()
        GameWorld.Log('###·þÎñÆ÷пª, ³õʼ»¯·þÎñÆ÷ʱ¼ä !')
    
    return Get_Server_Hour(), Get_Server_Day(), Get_Server_Week(), Get_Server_Month(), Get_Server_Year()

#µ÷Óøú¯Êýʱ£¬C++ÒѾ­ÉèÖúÃÇø·þ£¬Èç¹û¸Ä±äÇø·þÐèÖØÆô
def StartDB(tick):
    #³õʼ»¯Êý¾Ý¿â, »Ö¸´±¸µµ£¨°´Çø·þ¼Ç¼£©£¬ ¼ÓÔؾ²Ì¬±í
    #from PyMongoDB import PyMongoMain
    PyMongoMain.StartDB()
    InitGameWorld(tick)
    return

def InitGameWorld(tick):
    ## GameWorld³õʼ»¯
    if PyGameData.g_initGameWorldOK:
        return
    serverID = GameWorld.GetGameWorld().GetServerID()
    serverType = GameWorld.GetServerType()
    GameWorld.Log("·þÎñÆ÷Æô¶¯³õʼ»¯InitGameWorld: serverID=%s,serverType=%s" % (serverID, serverType))
    DBDataMgr.OnServerStart() # ÓÅÏȼÓÔع«¹²Êý¾Ý
    #ItemCommon.InitPyItem() # ¸ÄΪ·Å InitItem ¼ÓÔØ
    LoadDBPlayer()
    PlayerViewCache.LoadRobot()
    PyGameData.g_initGameTime = int(time.time()) # ·Åµ½¼ÓÔØÊý¾ÝÖ®ºó
    
    if DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_FamilyTransDataTime):
        DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_FamilyTransDataTime, 0)
        GameWorld.Log("Æô¶¯·þÎñÆ÷ʱÖØÖÿç·þ¹«»á´«ÊäÊý¾Ý״̬!")
        
    #³õʼ»°¿ª·þʱ¼ä¡¢ÐÇÆÚ¼¸
    initOpenServerTime = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_InitOpenServerTime)
    openServerWeekday = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_OpenServerWeekday)
    if initOpenServerTime <= 0 or openServerWeekday <= 0:
        #¼Ç¼Ê״οª·¢Ê±¼ä(ÏÖʵʱ¼ä´Á)
        SetInitOpenServerTime(initOpenServerTime if initOpenServerTime else int(time.time()))
        
    #ºÏ·þÊ×´ÎÆô¶¯¼ÓÔØ´¦Àí
    __DoMixServerInit()
    
    # ÆäËû¹¦Äܳõʼ»¯
    
    
    # ×îºó´¥·¢¼ì²éÊÇ·ñÍêÈ«Æô¶¯³É¹¦
    PyGameData.g_initGameWorldOK = True
    OnServerInitOK()
    return

def OnServerInitOK():
    '''·þÎñÆ÷ÍêÈ«Æô¶¯³õʼ»¯³É¹¦ºóµÄ´¦Àí£¬ÈçdbÊý¾Ý¼ÓÔؼ°¾²Ì¬ÎïÆ·Êý¾ÝµÈ¶¼¼ÓÔØÍê±ÏÁË
    Èç¿ç·þ¼äÏà¹ØÂß¼­Í¨Ñ¶ÐèÒªµÈ·þÎñÆ÷ÍêÈ«Æô¶¯Íê±Ïºó²Å¿É½øÐÐ
    '''
    if not PyGameData.g_initGameWorldOK or not PyGameData.g_initPyItem:
        return
    if PyGameData.g_serverInitOK:
        return
    PyGameData.g_serverInitOK = True
    
    tick = GameWorld.GetGameWorld().GetTick()
    serverID = GameWorld.GetGameWorld().GetServerID()
    
    OnHighProcess(tick) # Ö÷¶¯´¥·¢Ò»´Î¸ß¾«¶ÈµÄµ÷Óã¬È·±£·þÎñÆ÷Æô¶¯ºóһЩ¹¦ÄܻµÈµÄÊý¾Ý»á±»¼ÓÔØ
    OnMinute(tick)
    
    GameWorld.Log("=============================== ·þÎñÆ÷Æô¶¯³É¹¦ ===================================")
    serverType = GameWorld.GetServerType()
    isCrossServer = GameWorld.IsCrossServer()
    if isCrossServer:
        GameWorld.Log("¿ç·þ·þÎñÆ÷Æô¶¯³É¹¦: serverType=%s,serverID=%s" % (serverType, serverID))
    else:
        serverDay = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_ServerDay) + 1
        isMixServer = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_IsMixServer)
        mixServerDay = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_MixServerDay) + 1
        GameWorld.Log("ÓÎÏ··þÎñÆ÷Æô¶¯³É¹¦: serverType=%s,serverID=%s,serverDay=%s,isMixServer=%s,mixServerDay=%s" 
                      % (serverType, serverID, serverDay, isMixServer, mixServerDay))
        
    DataRecordPack.DR_Reload("restart")
    
    # ---------- ÒÔÏ´¦Àí·þÎñÆ÷ÍêÈ«Æô¶¯ºÃºóµÄÂß¼­ ----------
    
    return

def AllMapServerInitOK(tick):
    return

def LoadDBPlayer():
    if GameWorld.IsCrossServer():
        return
    #PlayerDBOper.FindDBOper(PlayerDBOper.Table_DBPlayer, {}, {"PlayerID":1, "AccID":1, "_id":0}, LoadDBPlayerRet)
    return

def GMSetOpenServerTime(openServerTime):
    '''GMÉèÖÿª·þʱ¼ä
    @param openServerTime: ¿ª·þʱ¼ä´Á
    @return: 1-³É¹¦£»-1-ÉèÖõÄʱ¼äÒì³££»-2-ÒѾ­ÉèÖùýÇÒ¿ª·þÁË£¬²»ÄÜÖظ´ÉèÖÃ
    '''
    serverID = GameWorld.GetGameWorld().GetServerID()
    curTime = int(time.time())
    if openServerTime < curTime:
        GameWorld.ErrLog("µ±Ç°Ê±¼äÒѾ­³¬¹ýÉèÖõĿª·þʱ¼ä£¬²»ÄÜÉèÖÃ! serverID=%s" % serverID)
        #GMCommon.GMCommandResult(orderId, gmCmdDict, GMCommon.Def_InvalidTime, "The set time is less than the current time.")
        return -1
    setOpenServerTime = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_SetOpenServerTime)
    if setOpenServerTime and curTime > setOpenServerTime:
        GameWorld.ErrLog("ÒѾ­ÉèÖùýÇÒ¿ª·þÁË£¬²»ÄÜÖظ´ÉèÖÃ! serverID=%s" % serverID)
        #GMCommon.GMCommandResult(orderId, gmCmdDict, GMCommon.Def_ServerAlreadyOpen, "The server has been opened.")
        return -2
    
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_SetOpenServerTime, openServerTime)
    GameWorld.Log("GMÉèÖÿª·þʱ¼ä£º serverID=%s,%s,%s" % (serverID, GameWorld.ChangeTimeNumToStr(openServerTime), openServerTime))
    if openServerTime == curTime:
        OnNewServerOpen(GameWorld.GetGameWorld().GetTick())
        
    return 1

def DoCheckNewServerOpen(tick):
    setOpenServerTime = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_SetOpenServerTime)
    if not setOpenServerTime:
        #GameWorld.DebugLog("ûÓÐÖ¸¶¨¿ª·þʱ¼ä£¡")
        return
    curOpenServerTime = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_InitOpenServerTime)
    if curOpenServerTime == setOpenServerTime:
        #GameWorld.DebugLog("ÒѾ­Õýʽ¿ª·þ¹ýÁË£¡")
        return
    curTime = int(time.time())
    if curTime < setOpenServerTime:
        #GameWorld.DebugLog("»¹Î´µ½Õýʽ¿ª·þʱ¼ä£¡")
        return
    OnNewServerOpen(tick)
    return
    
def OnNewServerOpen(tick):
    '''зþ¿ªÆôÐèÒª´¦ÀíµÄÂß¼­'''
    
    serverID = GameWorld.GetGameWorld().GetServerID()
    GameWorld.Log("Ö´ÐÐÕýʽ¿ª·þÖØÖÃÂß¼­... serverID=%s" % serverID)
    
    setOpenServerTime = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_SetOpenServerTime)
    if not setOpenServerTime:
        return
    
    #ÇåDBGSTrig
    excludeList = [ShareDefine.Def_InitOpenServerTime, ShareDefine.Def_SetOpenServerTime]
    DBDataMgr.GetEventTrigMgr().DelAllKey(excludeList)
    #Çå¼Ò×å
    DBDataMgr.GetFamilyMgr().DelAllFamily()
    #ÇåÓʼþ
    DBDataMgr.GetMailMgr().DelAllMail()
    DBDataMgr.GetPlayerViewCacheMgr().DelAllCache()
    
    SetInitOpenServerTime(setOpenServerTime)
    AllMapServerInitOK(tick)
    
    GameWorld.GetGameWorld().SaveGameServerData()
    GameWorld.SendGameError("ClearOpenServerOK")
    return

def SetInitOpenServerTime(initTime):
    openDatetime = GameWorld.ChangeTimeNumToDatetime(initTime)
    openServerWeekday = openDatetime.weekday() + 1
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_InitOpenServerTime, initTime)
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_OpenServerWeekday, openServerWeekday)
    GameWorld.Log("ÉèÖÿª·þʱ¼ä: %s(%s), ÖÜ%s" % (openDatetime, initTime, openServerWeekday))
    # ÐèÒªÕâ¸ö²ÎÊýÖ÷ÒªÊÇGM¹¤¾ß»áÅжÏÊÇ·ñÓÐÉèÖùý£¬ËùÒÔ¸ÃÖµÒ»°ãÖ»ÓÐGMÃüÁî»ò¹¤¾ß²ÅÄÜÉèÖÃ
    setOpenServerTime = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_SetOpenServerTime)
    if setOpenServerTime and setOpenServerTime != initTime:
        DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_SetOpenServerTime, initTime)
        GameWorld.Log("    ͬ²½¸üРDef_SetOpenServerTime=%s" % initTime)
    return

def __DoMixServerInit():
    isMixServer = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_IsMixServer)
    if not isMixServer:
        GameWorld.DebugLog("·ÇºÏ·þ£¬²»´¦ÀíºÏ·þÊ×´ÎÆô¶¯Êý¾Ý¼ÓÔØ£¡")
        return
    
    isMixServerInitOK = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_IsMixServerInitOK)
    if isMixServerInitOK:
        GameWorld.DebugLog("ºÏ·þÊ×´ÎÆô¶¯¼ÓÔØÒѾ­´¦Àí¹ý£¡")
        return
    
    GameWorld.Log("ºÏ·þÊ×´ÎÆô¶¯¼ÓÔØ´¦Àí...")
    
    # Çå³ýÖ¸¶¨Í¨ÓÃÊý¾Ý£¬Ò»°ãÊǺϷþ¹¤¾ßɾ£¬ÕâÀï¿ÉÒÔÔÙ×ö¸ö²¹³ä
    #universalRecMgr = GameWorld.GetUniversalRecMgr()
    #delRecTypeList = []
    #GameWorld.Log("Çå³ýÖ¸¶¨Í¨ÓÃÊý¾Ý delRecTypeList=%s" % str(delRecTypeList))
    #for delRecType in delRecTypeList:
    #    universalRecMgr.Delete(delRecType)
        
    # ɾ³ý¹ýÆÚµÄͨÓÃÊý¾Ý
    #__DelOutofdayRecData(universalRecMgr)
    
    # ÉèÖúϷþÊ×´ÎÆô¶¯¼ÓÔسɹ¦
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_IsMixServerInitOK, 1)
    
    # ÉèÖñ¾´ÎºÏ·þʱµÄ¿ª·þÌìÊý¡¢ÊÀ½çµÈ¼¶
    serverDay = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_ServerDay)
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_LastMixServerDay, serverDay)
    GameWorld.Log("    ºÏ·þÊ×´ÎÆô¶¯¼ÓÔسɹ¦! serverDay=%s" % (serverDay))
    return

def OnHighProcess(tick):
    ## ÿÃë·ÖÖÓÖ´ÐÐÒ»´Î
    if not PyGameData.g_serverInitOK:
        return
    curTime = int(time.time())
    if not PyGameData.g_highProcessTime:
        PyGameData.g_highProcessTime = curTime
        
    if curTime < PyGameData.g_highProcessTime:
        GameWorld.Log("ʱ¼ä»Øµ÷ÁË: lastProcessTime=%s" % (GameWorld.ChangeTimeNumToStr(PyGameData.g_highProcessTime)))
        PyGameData.g_highProcessTime = curTime
        OnFixServerTimeProcess()
        
    passSeconds = curTime - PyGameData.g_highProcessTime
    if passSeconds < 1:
        return
    if passSeconds > 10:
        GameWorld.Log("ʱ¼äÎó²î¹ý´ó: passSeconds=%s,lastProcessTime=%s" % (passSeconds, GameWorld.ChangeTimeNumToStr(PyGameData.g_highProcessTime)))
        OnFixServerTimeProcess()
        
    PyGameData.g_highProcessTime = curTime
    
    if PyGameData.g_serverClosing:
        CheckCloseMapOK()
        return
    
    PyMongoMain.GetUserCtrlDB().onSecondProcess()
    CrossMgr.OnSecondProcess(tick, curTime)
    
    OnMinute(tick)
    
    # ÆäËûÂß¼­
    
    
    
    return

def OnFixServerTimeProcess():
    
    # ²¹Í¬²½Ò»´Î·þÎñÆ÷ʱ¼ä¸øÇ°¶Ë
    playerManager = GameWorld.GetPlayerManager()
    for i in xrange(playerManager.GetPlayerCount()):
        curPlayer = playerManager.GetPlayerByIndex(i)
        
        if not GameWorld.IsNormalPlayer(curPlayer):
            continue
        
        ChPlayer.Sync_PyServerDataTimeToClient(curPlayer)
        ChPlayer.Sync_OpenServerDay(curPlayer)
        
    return
        
def OnMinute(tick):
    ## ÿÕû·ÖÖÓÖ´ÐÐÒ»´Î
    curTime = GameWorld.GetCurrentTime()
    curMinute = curTime.minute
    if curMinute == PyGameData.g_minuteProcess:
        return
    PyGameData.g_minuteProcess = curMinute
    
    #¼ì²é·þÎñÆ÷Õýʽ¿ª·þ
    DoCheckNewServerOpen(tick)
    DBDataMgr.OnMinute(curTime)
    DoLogic_GameWorldEvenByTime(tick)
    
    #ÿ5·ÖÖÓ
    if curMinute % 5 == 0:
        OnMinute_5(curTime, tick)
        
    #ÆäËû¹¦ÄÜÂß¼­
    #GameWorldActionControl.Dispose_OperationActionState()
    #GameWorldActionControl.Dispose_DailyActionState()
    #GameWorldActionControl.Dispose_FBStateTime()
    PlayerControl.OnMinute(curTime)
    PlayerFamily.OnMinute()
    PlayerOnline.OnMinute()
    BattleObj.OnMinute()
    ObjPool.OnMinute(curTime)
    
    __CheckIpyDataRecycle(curTime)
    return
    
def OnMinute_5(curTime, tick):
    ## ÿ5·ÖÖÓ
    DisposeGameActivePlayer(curTime, tick)
    return

def DisposeGameActivePlayer(curTime, tick):
    curMinute = curTime.minute
    gameWorld = GameWorld.GetGameWorld()
    noteData = gameWorld.GetGameWorldDictByKey("OnlineCntM")
    if noteData == curMinute:
        # ͬһ·ÖÖÓÖ»´¦Àí1´Î
        return
    gameWorld.SetGameWorldDict("OnlineCntM", curMinute)
    activePlayerCount = GameWorld.GetPlayerManager().OnlineCount()
    DataRecordPack.DR_OnLinePlayerCount(activePlayerCount) # ×ÜÔÚÏß
    return

def DoLogic_GameWorldEvenByTime(tick):
    '''¿ç·þʼþÓÉ¿ç·þÖÐÐÄ·þÎñÆ÷Çý¶¯£¬ÓÎÏ··þʹÓÃÔ­·½Ê½
    ¿ç·þÖÐÐÄOnEvent -> ÆäËû·þÎñÆ÷OnEvent (°üº¬¸ö³£¹æ¿ç·þ·þÎñÆ÷¼°ÓÎÏ··þ£¬²»±£Ö¤Ë­ÏÈÖ´ÐÐ)
        ¸ö±ð¹¦ÄÜÈç¹ûÐèҪȷ±£¿ç·þÏÈÖ´ÐÐEvent£¬ÔÙ´¦ÀíÓÎÏ··þEvent£¬¿ÉÒÔÓɹ¦ÄÜÇý¶¯¿ç·þÏÈÖ´ÐУ¬ÔÙͬ²½ÓÎÏ··þÖ´ÐÐ
    '''
    if GameWorld.IsCrossServer():
        if not GameWorld.IsCrossCenter():
            return
        eventValue = GameWorld.ToIntDef(GameWorld.ChangeTimeNumToStr(int(time.time()), ChConfig.TYPE_Time_Format_YmdH))
        if DoLogic_CrossCenterEvent(eventValue):
            CrossMgr.SendCrossServerEvent()
        return  
      
    #-----------·þÎñÆ÷µ±Ç°Ê±¼ä
    curTime = datetime.datetime.today()
    curTimeHour = curTime.hour
    curTimeDay = curTime.day
    curTimeWeek = datetime.datetime.isocalendar(curTime)[1]
    curTimeMonth = curTime.month
    curTimeYear = curTime.year
    
    #-----------·þÎñÆ÷¼Ç¼µÄʱ¼ä
    serverHour , serverDay , serverWeek , serverMonth , serverYear = InitServerTime()
    
    #-----------¿ªÊ¼±È¶Ôʱ¼ä
    #OnHourʼþ
    if (serverHour != curTimeHour or serverDay != curTimeDay or serverMonth != curTimeMonth or serverYear != curTimeYear):
        Set_Server_Hour()
        OnHour(tick)
        
    #OnDayʼþ
    if (serverDay != curTimeDay or serverMonth != curTimeMonth or serverYear != curTimeYear):
        Set_Server_Day()
        OnDay(tick)
        
    #OnWeekʼþ
    #²»¿¼ÂǸôÄêÇé¿ö£¬Èç2009,12,31Èչطþ->2010,12,31ÈÕ¿ª·þ(²»´¥·¢OnWeek)
    if (serverWeek != curTimeWeek):
        Set_Server_Week()
        OnWeek(tick)
        
    #OnMonthʼþ
    if (serverMonth != curTimeMonth or serverYear != curTimeYear):
        Set_Server_Month()
        OnMonth(tick)
        
    #OnYearʼþ
    if serverYear != curTimeYear:
        Set_Server_Year()
        OnYear(tick)
        
    return

def OnHour(tick):
    GameWorld.Log("Server -> OnHour!")
    PlayerEventCounter.DoLogic_OnHour(tick)
    return

def OnDay(tick):
    GameWorld.Log("Server -> OnDay!")
    #É趨·þÎñÆ÷µ±Ç°Ììʼþ
    eventMgr = DBDataMgr.GetEventTrigMgr()
    serverDay = eventMgr.SetValueIncrement(ShareDefine.Def_ServerDay)
    isMixServer = eventMgr.GetValue(ShareDefine.Def_IsMixServer)
    mixServerDay = 0
    if isMixServer:
        mixServerDay = eventMgr.SetValueIncrement(ShareDefine.Def_MixServerDay)
    GameWorld.Log("OnDay -> serverDay=%s,isMixServer=%s,mixServerDay=%s" % (serverDay + 1, isMixServer, mixServerDay + 1))
    
    PlayerEventCounter.DoLogic_OnDay(tick)
    return

def OnWeek(tick):
    GameWorld.Log("Server -> OnWeek!")
    eventMgr = DBDataMgr.GetEventTrigMgr()
    eventMgr.SetValueIncrement(ShareDefine.Def_ServerWeek)
    
    PlayerEventCounter.DoLogic_OnWeek(tick)
    return

def OnMonth(tick):
    GameWorld.Log("Server -> OnMonth!")
    PlayerEventCounter.DoLogic_OnMonth(tick)
    return

def OnYear(tick):
    GameWorld.Log("Server -> OnYear!")
    PlayerEventCounter.DoLogic_OnYear(tick)
    return

def DoLogic_CrossCenterEvent(centerEventValue, centerServerID=0):
    ## ÊÕµ½¿ç·þÖÐÐÄʼþͬ²½£¬ÈçOnDayµÈ
    serverEventValue = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_CrossCenterEvent)
    if not serverEventValue:
        serverEventValue = centerEventValue
        DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_CrossCenterEvent, centerEventValue)
        
    if centerServerID:
        GameWorld.Log("´¦Àí¿ç·þÖÐÐÄʼþÖµ! serverEventValue=%s,centerEventValue=%s,centerServerID=%s" % (serverEventValue, centerEventValue, centerServerID))
        
    if serverEventValue == centerEventValue:
        GameWorld.DebugLog("¿ç·þÖÐÐÄʼþÖµ²»±ä! serverEventValue=%s,centerEventValue=%s,centerServerID=%s" % (serverEventValue, centerEventValue, centerServerID))
        return
    
    serverEventTime = GameWorld.ChangeStrToDatetime("%s:%02d:%02d" % serverEventValue, ChConfig.TYPE_Time_Format_YmdHMS)
    centerEventTime = GameWorld.ChangeStrToDatetime("%s:%02d:%02d" % centerEventValue, ChConfig.TYPE_Time_Format_YmdHMS)
    
    serverHour = serverEventTime.hour
    serverDay = serverEventTime.day
    #serverWeek = datetime.datetime.isocalendar(serverEventTime)[1]
    serverMonth = serverEventTime.month
    serverYear = serverEventTime.year
    
    centerHour = centerEventTime.hour
    centerDay = centerEventTime.day
    #centerWeek = datetime.datetime.isocalendar(centerEventTime)[1]
    centerMonth = centerEventTime.month
    centerYear = centerEventTime.year
    
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_CrossCenterEvent, centerEventValue)
    
    isEvent = False
    
    #OnHourʼþ
    if (serverHour != centerHour or serverDay != centerDay or serverMonth != centerMonth or serverYear != centerYear):
        isEvent = True
        PlayerEventCounter.DoLogic_CrossCenterOnHour(centerEventValue)
        
    #OnDayʼþ
    if (serverDay != centerDay or serverMonth != centerMonth or serverYear != centerYear):
        isEvent = True
        PlayerEventCounter.DoLogic_CrossCenterOnDay(centerEventValue)
        
    #OnWeekʼþ
    #if (serverWeek != curTimeWeek):
    #    OnWeek(tick)
        
    #OnMonthʼþ
    #if (serverMonth != curTimeMonth or serverYear != curTimeYear):
    #    OnMonth(tick)
        
    #OnYearʼþ
    #if serverYear != curTimeYear:
    #    OnYear(tick)
    
    return isEvent

def __CheckIpyDataRecycle(timeNow):
    ## ¼ì²éIpyDataÊý¾Ý»ØÊÕ
    playerCount = GameWorld.GetPlayerManager().OnlineCount()
    if playerCount:
        PyGameData.g_ipyDataRecycleCheckTime = 0
        #GameWorld.DebugLog("µØͼ»¹ÓÐÍæ¼ÒÔÚÏß! playerCount=%s" % playerCount)
        return
    
    curTime = GameWorld.ChangeDatetimeToNum(timeNow)
    if not PyGameData.g_ipyDataRecycleCheckTime:
        PyGameData.g_ipyDataRecycleCheckTime = curTime
        #GameWorld.DebugLog("µØͼûÓÐÍæ¼ÒÔÚÏß")
        return
    
    if PyGameData.g_ipyDataRecycleCheckTime == 1:
        # ÒѾ­»ØÊÕÁË
        #GameWorld.DebugLog("±¾´ÎÒѾ­»ØÊÕ¹ýÁË")
        return
    
    if curTime - PyGameData.g_ipyDataRecycleCheckTime < 24 * 3600:
        #GameWorld.DebugLog("»¹Î´µ½´ï»ØÊÕʱ¼ä, passSeconds=%s" % (curTime - PyGameData.g_ipyDataRecycleCheckTime))
        return
    PyGameData.g_ipyDataRecycleCheckTime = 1    
    IpyGameDataPY.IPYData.Recycle()
    return


# ¹Ø±ÕµØͼ֪ͨpy´¦Àí
def CloseMap(tick):
    serverID = GameWorld.GetGameWorld().GetServerID()
    GameWorld.Log("µØͼ·þÎñÆ÷¹Ø±Õ¿ªÊ¼±£´æÊý¾Ý! serverID=%s" % serverID)
    PyGameData.g_serverClosing = 1
    
    playerManager = GameWorld.GetPlayerManager()
    for i in xrange(playerManager.GetPlayerCount()):
        curPlayer = playerManager.GetPlayerByIndex(i)
        if not curPlayer or curPlayer.GetID() == 0 or curPlayer.IsEmpty():
            continue
        
        #¾µÏñÍæ¼Ò»ØÊÕ¡¢ÕæʵÍæ¼ÒÌßÏÂÏß
        if GameWorld.IsMirrorPlayer(curPlayer):
            PlayerControl.DeleteMirror(curPlayer)
        else:
            curPlayer.Kick(IPY_GameWorld.disMapServerClose)
            
    DBDataMgr.OnServerClose()
    return

def CheckCloseMapOK():
    '''¼ì²éµÈ´ý¹Ø·þÊý¾Ý´¦ÀíÍê±Ï
    ûÓÐÍæ¼ÒÁË£¬ÇÒ¹«¹²Êý¾ÝÒÑÈë¿âÍê±Ï
    '''
    if PyGameData.g_serverClosing != 1:
        return
    if not PyGameData.g_closeSaveDataOK:
        return
    if GameWorld.GetPlayerManager().OnlineCount():
        return
    DBDataMgr.ClearBackupFile() # Õý³£¹Ø·þÊý¾Ý´¦ÀíÍê±Ï¿ÉÖ±½Óɾ³ý±¸µµ
    
    from PyMongoDB.DBCommon import CommonDefine
    from PyMongoDB.Common import CommFunc
    data = ''
    data = CommFunc.WriteBYTE(data, CommonDefine.dgPlayerSaveGameServerData)  
    NetPackCommon.SendPyPackToMapServerSelf(data, len(data))
    GameWorld.Log("python ÒÑ´¦ÀíµØͼ¹Ø±ÕÂß¼­")
    PyGameData.g_serverClosing = 2
    return