#!/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 GameWorldAction
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()) # ·Åµ½¼ÓÔØÊý¾ÝÖ®ºó
    
    # ¼ì²é¿ç·þÖÐÐÄΨһÐÔ
    GameWorld.CheckCrossCenterUniquenessErr()
    
    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)
    GameWorldAction.OnProcessGameAction(curTime)
    
    #ÿ5·ÖÖÓ
    if curMinute % 5 == 0:
        OnMinute_5(curTime, tick)
        
    #ÆäËû¹¦ÄÜÂß¼­
    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 OnGM_CrossCenterEvent(gmEvent):
    if not GameWorld.IsCrossCenter():
        return
    serverEventValue = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_CrossCenterEvent)
    if DoLogic_CrossCenterEvent(serverEventValue, gmEvent=gmEvent):
        CrossMgr.SendCrossServerEvent(gmEvent=gmEvent)
    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, gmEvent=""):
    ## ÊÕµ½¿ç·þÖÐÐÄʼþͬ²½£¬ÈçOnDayµÈ
    serverEventValue = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_CrossCenterEvent)
    if not serverEventValue:
        serverEventValue = centerEventValue
        DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_CrossCenterEvent, centerEventValue)
        
    if serverEventValue == centerEventValue and not gmEvent:
        if centerServerID:
            GameWorld.Log("±¾·þÓë¿ç·þÖÐÐÄʼþÖµÏàͬ²»´¦Àí! serverEventValue=%s,centerEventValue=%s,centerServerID=%s" % (serverEventValue, centerEventValue, centerServerID))
        return
    
    if centerServerID:
        GameWorld.Log("±¾·þÓë¿ç·þÖÐÐÄʼþÖµ±ä»¯! serverEventValue=%s,centerEventValue=%s,centerServerID=%s,gmEvent=%s" % (serverEventValue, centerEventValue, centerServerID, gmEvent))
    else:
        GameWorld.Log("¿ç·þÖÐÐÄ·þÎñÆ÷ʼþÖµ±ä»¯! serverEventValue=%s,centerEventValue=%s,gmEvent=%s" % (serverEventValue, centerEventValue, gmEvent))
        
    serverEventTime = GameWorld.ChangeStrToDatetime("%s" % serverEventValue, ChConfig.TYPE_Time_Format_YmdH)
    centerEventTime = GameWorld.ChangeStrToDatetime("%s" % centerEventValue, ChConfig.TYPE_Time_Format_YmdH)
    
    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 or gmEvent == "GMOnHour"):
        isEvent = True
        PlayerEventCounter.DoLogic_CrossCenterOnHour(centerEventValue)
        
    #OnDayʼþ
    if (serverDay != centerDay or serverMonth != centerMonth or serverYear != centerYear or gmEvent == "GMOnDay"):
        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)
    
    # ÓÎÏ··þ¶îÍâ´¦ÀíÍæ¼Ò
    if GameWorld.IsMainServer():
        playerManager = GameWorld.GetPlayerManager()
        for i in xrange(playerManager.OnlineCount()):
            curPlayer = playerManager.OnlineAt(i)
            if not GameWorld.IsNormalPlayer(curPlayer):
                continue
            PlayerEventCounter.PlayerOnCrossCenterEvent(curPlayer, centerEventValue, gmEvent=gmEvent)
            
    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