#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
#-------------------------------------------------------------------------------
|
#
|
##@package PlayerFamilyRedPacket
|
#
|
# @todo:¼Ò×åºì°ü
|
# @author xdh
|
# @date 2017-08-29
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: ¼Ò×åºì°ü
|
#
|
#---------------------------------------------------------------------
|
#"""Version = 2017-08-29 18:00"""
|
#---------------------------------------------------------------------
|
|
import GameWorld
|
import ShareDefine
|
import NetPackCommon
|
import IpyGameDataPY
|
import ChPyNetSendPack
|
import PlayerCompensation
|
import PlayerDBGSEvent
|
import PlayerControl
|
import PlayerFamily
|
import PyGameData
|
import ChConfig
|
|
import datetime
|
import random
|
import time
|
|
(
|
State_NoSend, #δ·¢
|
State_NoGot, #δÁìÈ¡
|
State_HasGot, #ÒÑÁìÈ¡
|
State_HasAllGot, #È«²¿ÁìÍê
|
) = range(4)
|
|
DBKey_RedPacketSend = "RedPacketSend_%s" # ϵͳ¶¨Ê±ºì°üÊÇ·ñÒÑ·¢·Å£¬ ²ÎÊýºì°üID
|
DBKey_RedPacketSystemDayCount = "RedPacketSystemDayCount" # È«·þϵͳºì°üÒÑ·¢·Å¸öÊý
|
|
def __SaveRedpacketRecData(recData, redPacketObj):
|
''' ºì°üÔݶ¨ÓÐЧÆÚ24Сʱ£¬¹ýÌìÇå³ý¹ýÆڵĺì°ü£¬Èç¹ûÊÇÍæ¼Ò·¢·ÅµÄ·µ»¹Î´ÁìÈ¡µÄ»õ±Ò
|
ÉÏÏßͬ²½ËùÓкì°üÐÅÏ¢£¬ºì°ü±ä»¯ÊµÊ±¹ã²¥È«·þÔÚÏßÍæ¼Ò
|
'''
|
#ºì°üÊý¾Ý Def_UniversalGameRecType_FamilyRedPacketAllRecord
|
#Time ´´½¨ºì°üʱ¼ä£¬·Çºì°üʵ¼Ê¿ª·ÅÁìȡʱ¼ä£¬Èç¹ûºì°ü±íÓÐÅäÖÃϵͳ·¢·Åʱ¼ä£¬Ôò¸Ãʱ¼ä´æÅä±íʱ¼ä£¬Ã»ÓеĻ°´æ´´½¨Ê±µÄ·þÎñÆ÷ʱ¼ä
|
#value1 ºì°üΨһID£¬¸ÃIDΪʵÀýID£¬·ÇÅä±íµÄºì°üID
|
#value2 ¼Ò×åID£¬0´ú±íÈ«·þºì°ü
|
#value3 ×ܶî¶È*10+½ðÇ®ÀàÐÍ
|
#value4 ״̬
|
#value5 ʱ¼ä£¬ÓÃÀ´ÅжÏÊÇ·ñ¹ýÆÚɾ³ýµÄ£¬Êµ¼Ê¿ª·Å¸Ãºì°üÁìÈ¡µÄʱ¼ä
|
#strValue1 ´´½¨ÕßID|´´½¨ÕßÃû×Ö|´´½¨ÕßÖ°Òµ|»ñµÃ;¾¶£¨ºì°üÀàÐÍ£©
|
#strValue2 ¿ÉÇÀ×ܸöÊý|ÊÇ·ñÄäÃû(ĬÈϲ»ÄäÃû¼æÈÝÀÏÊý¾Ý)
|
#strValue3 ×£¸£ÓÍæ¼Ò×Ô¼º±à¼µÄÄÚÈÝ
|
|
recData.SetTime(redPacketObj.createTime)
|
recData.SetValue1(redPacketObj.redPacketID)
|
recData.SetValue2(redPacketObj.familyID)
|
recData.SetValue3(redPacketObj.moneyType + redPacketObj.moneyValue * 10)
|
recData.SetValue4(redPacketObj.state)
|
recData.SetValue5(redPacketObj.calcTime)
|
strValue1 = '%s|%s|%s|%s' % (redPacketObj.playerID, redPacketObj.playerName, redPacketObj.playerJob, redPacketObj.getWay)
|
recData.SetStrValue1(strValue1)
|
recData.SetStrValue2('%s|%s' % (redPacketObj.packetCnt, int(redPacketObj.isAnonymous)))
|
recData.SetStrValue3(redPacketObj.wish)
|
return
|
|
def __SaveRedpacketRecGrabData(recData, grabObj):
|
#ÇÀºì°ü¼Ç¼ Def_UniversalGameRecType_FamilyRedPacketGrabRecord
|
#value1 ºì°üΨһID
|
#value2 playerID
|
#value3 job
|
#value4 moneyType
|
#value5 getMoney
|
#strValue1 Ãû×Ö
|
|
recData.SetValue1(grabObj.redPacketID)
|
recData.SetValue2(grabObj.playerID)
|
recData.SetValue3(grabObj.playerJob)
|
recData.SetValue4(grabObj.moneyType)
|
recData.SetValue5(grabObj.getMoney)
|
recData.SetStrValue1(grabObj.playerName)
|
return
|
|
class RedPacketGrab():
|
## ºì°üÇÀ¼Ç¼Êý¾Ý
|
|
def __init__(self, redPacketID, playerID):
|
self.redPacketID = redPacketID
|
self.playerID = playerID
|
self.playerJob = 0
|
self.playerName = ""
|
self.moneyType = 0
|
self.getMoney = 0
|
return
|
|
class RedPacketData():
|
## ºì°üÊý¾Ý
|
|
def __init__(self, redPacketID):
|
self.redPacketID = redPacketID
|
self.familyID = 0
|
self.moneyType = 0
|
self.moneyValue = 0
|
self.state = 0
|
self.createTime = 0
|
self.calcTime = 0
|
self.playerID = 0
|
self.playerName = ""
|
self.playerJob = 0
|
self.getWay = 0
|
self.packetCnt = 0
|
self.isAnonymous = 0 # ÊÇ·ñÄäÃû
|
self.wish = ""
|
|
self.grabDict = {} # ÇÀºì°ü¼Ç¼ {playerID:RedPacketGrab, ...}
|
return
|
|
class RedPacketMgr():
|
''' ºì°ü»º´æ¹ÜÀíµÈ
|
֪ͨÍæ¼Òºì°üÂß¼:
|
ÓÉÓÚ¸Õ¿ª·þʱºì°ü´ó¸ÅÂÊ»á±È½Ï¶à£¬ºì°üµÄ½»»¥¼°½»²æ֪ͨҲÏà¶Ô±È½ÏÃܼ¯£¬ËùÒÔ×öЩÓÅ»¯£¬²»¶ÔËùÓкì°ü´¦Àí
|
½«ºì°ü·ÖΪºì°ü×ܿ⼰֪ͨ¸øÍæ¼ÒµÄ²¿·Öºì°ü£¬¼ÙÉ赱ǰËùÓкì°ü×ÜÊýΪ500¸ö£¬±ê¼ÇΪ T ¸ö
|
¿ÉÅäÖÃÏÞÖÆ֪ͨ¸øÍæ¼Ò¿É²Ù×÷µÄºì°ü¸öÊýÈçֻ֪ͨ20¸ö£¬±ê¼ÇΪ M ¸ö£¬¿ÉÊÓΪÈȺì°ü£¬µ± M Ïû»¯Íêºó¿É¸½¼Ó֪ͨ N ¸ö
|
|
֪ͨÍæ¼ÒµÄºì°ü×é³É£º
|
·ÇÏÉÃ˺ì°ü£º ¹éÊôÍæ¼ÒµÄ먦·Åºì°üA + ²»ÏÞÖÆ֪ͨ¸öÊýµÄºì°üB + ÏÞÖÆ֪ͨ¸öÊýµÄºì°üC£» ²»°üº¬ÆäËûÍæ¼Ò먦·ÅµÄ
|
ÏÉÃ˺ì°ü£º ËùÓÐÍæ¼ÒδÁìÈ¡¹ýµÄÇÒδȫ²¿ÁìÍêµÄºì°ü£¬°üº¬ÆäËûÍæ¼Ò먦·ÅµÄ
|
|
Èç¹û (A + B) >= M ÁË£¬Ôò²»ÐèÒªÔÙ¸½¼Ó֪ͨ C
|
'''
|
def __init__(self):
|
self.allRedPacketDict = {} # ËùÓкì°üÐÅÏ¢ {ºì°üID:RedPacketData, ...}
|
|
self.familyRedPacketDict = {} # ÏÉÃ˺ì°üÐÅÏ¢£¬È«²¿Í¬²½ {familyID:[ºì°üID, ...], ...}
|
|
# --- ÒÔϽöÕë¶Ô·ÇÏÉÃ˺ì°ü ---
|
# Õë¶Ôºì°üÁ¿±È½Ï´óµÄºì°üÀàÐÍ£¬ÓÐÏÞÖÆͬ²½¸öÊý£¬°´ÀàÐÍ·Ö×飬ÿ×é°´¹æÔò¶ÀÁ¢Í¬²½£»Èç ¿ª·þ³É¾Íºì°ü¡¢½ÚÈճɾͺì°ü¡¢È«·þºì°ü
|
# ͬ²½¹æÔò£º
|
# ±ÈÈçÏÈͬ²½20¸ö£¬È»ºó¼õÒ»¸öÔòÔÙ´ÓÒÑ¿ª·ÅµÄ¿âÖв¹³ä£»
|
# ÐÂÔöÒ»¸ö¿ª·ÅÁìÈ¡µÄºì°üʱ£¬Èç¹ûÍæ¼ÒÓпÉÁìÈ¡µÄÔò²»ÐèҪͬ²½£¬Ã»ÓпÉÁìÈ¡µÄÔòÐèҪͬ²½¸øËû
|
# ×¢£º È«·þºì°üÖУ¬Î´¿ª·ÅµÄºì°ü½öÍæ¼Ò×Ô¼º¿É¼û
|
self.playerNosendRedPacketIDInfo = {} # Íæ¼Ò먦·ÅµÄºì°üIDÐÅÏ¢£¬Õë¶ÔÓÐͬ²½¸öÊýÏÞÖƵÄÀàÐÍ {playerID:{ºì°üÀàÐÍ:[ºì°üID, ...], ...}, ...}
|
|
# playerCanGetRedPacketIDInfo µÄplayerID°üº¬ËùÓÐÔÚÏßÍæ¼Ò£¬²»º¬ÍÑ»ú¹Ò
|
self.playerCanGetRedPacketIDInfo = {} # Íæ¼Ò¿ÉÁìÈ¡µÄºì°üIDÐÅÏ¢£¬Õë¶ÔÓÐͬ²½¸öÊýÏÞÖƵÄÀàÐÍ {playerID:{ºì°üÀàÐÍ:[ºì°üID, ...], ...}, ...}
|
self.activeRedPacketIDInfo = {} # ÒÑ¿ª·ÅÁìÈ¡µÄºì°üIDÁÐ±í£¬Õë¶ÔÓÐͬ²½¸öÊýÏÞÖƵÄÀàÐÍ {ºì°üÀàÐÍ:[ºì°üID, ...], ...}
|
|
# ÆäËûÈ«·þºì°ü£¬Ò»°ãÁ¿±È½ÏÉٵģ¬Ïà¶Ô¹Ì¶¨µÄ£¬È«²¿Í¬²½£¬Èç½ÚÈÕ¶¨Ê±·¢Ë͵ĺì°ü
|
self.notifyAllServerRedPacketIDList = [] # ÆäËûûÓÐÏÞÖÆÏ·¢Í¬²½¸öÊýµÄÈ«·þºì°üID [ºì°üID, ...]
|
return
|
|
def GetRedPacketObj(self, redPacketID, createNew):
|
## »ñÈ¡ºì°üʵÀý
|
redPacketObj = None
|
if redPacketID in self.allRedPacketDict:
|
redPacketObj = self.allRedPacketDict[redPacketID]
|
elif createNew:
|
redPacketObj = RedPacketData(redPacketID)
|
self.allRedPacketDict[redPacketID] = redPacketObj
|
return redPacketObj
|
|
def AddFamilyRedPacketID(self, familyID, redPacketID):
|
## Ìí¼Óºì°üID½øÈëÏÉÃ˺ì°üID»º´æ
|
if familyID not in self.familyRedPacketDict:
|
self.familyRedPacketDict[familyID] = []
|
familyRedpacketIDList = self.familyRedPacketDict[familyID]
|
if redPacketID not in familyRedpacketIDList:
|
familyRedpacketIDList.append(redPacketID)
|
return
|
|
def DelFamilyRedPacketID(self, familyID, redPacketID):
|
## ɾ³ýÏÉÃ˺ì°üID»º´æ
|
if familyID not in self.familyRedPacketDict:
|
return
|
familyRedpacketIDList = self.familyRedPacketDict[familyID]
|
if redPacketID not in familyRedpacketIDList:
|
return
|
familyRedpacketIDList.remove(redPacketID)
|
return True
|
|
def AddPlayerNosendRedPacketID(self, playerID, getWay, redPacketID):
|
## Ìí¼ÓÍæ¼Ò먦·ÅµÄºì°üID»º´æ
|
if playerID not in self.playerNosendRedPacketIDInfo:
|
self.playerNosendRedPacketIDInfo[playerID] = {}
|
playerNosendRedPacketTypeIDInfo = self.playerNosendRedPacketIDInfo[playerID]
|
if getWay not in playerNosendRedPacketTypeIDInfo:
|
playerNosendRedPacketTypeIDInfo[getWay] = []
|
playerNosendRedPacketTypeIDList = playerNosendRedPacketTypeIDInfo[getWay]
|
if redPacketID not in playerNosendRedPacketTypeIDList:
|
playerNosendRedPacketTypeIDList.append(redPacketID)
|
return
|
|
def DelPlayerNosendRedPacketID(self, playerID, getWay, redPacketID):
|
## ɾ³ýÍæ¼Ò먦·ÅµÄºì°üID»º´æ
|
if playerID not in self.playerNosendRedPacketIDInfo:
|
return
|
playerNosendRedPacketTypeIDInfo = self.playerNosendRedPacketIDInfo[playerID]
|
if getWay not in playerNosendRedPacketTypeIDInfo:
|
return
|
playerNosendRedPacketTypeIDList = playerNosendRedPacketTypeIDInfo[getWay]
|
if redPacketID not in playerNosendRedPacketTypeIDList:
|
return
|
playerNosendRedPacketTypeIDList.remove(redPacketID)
|
return True
|
|
def AddActiveRedPacketID(self, getWay, redPacketID):
|
## Ìí¼ÓÒÑ¿ª·ÅµÄÈ«·þºì°üID»º´æ
|
if getWay not in self.activeRedPacketIDInfo:
|
self.activeRedPacketIDInfo[getWay] = []
|
redPacketIDList = self.activeRedPacketIDInfo[getWay]
|
if redPacketID not in redPacketIDList:
|
redPacketIDList.append(redPacketID)
|
return
|
|
def DelActiveRedPacketID(self, getWay, redPacketID):
|
## ɾ³ýÒÑ¿ª·ÅµÄÈ«·þºì°üID»º´æ
|
if getWay not in self.activeRedPacketIDInfo:
|
return
|
redPacketIDList = self.activeRedPacketIDInfo[getWay]
|
if redPacketID not in redPacketIDList:
|
return
|
redPacketIDList.remove(redPacketID)
|
return True
|
|
def AddPlayerCanGetRedPacketID(self, playerID, getWay, redPacketID):
|
## Ìí¼ÓÍæ¼Ò¿ÉÁìÈ¡µÄºì°üID»º´æ
|
if not playerID:
|
return
|
if playerID not in self.playerCanGetRedPacketIDInfo:
|
self.playerCanGetRedPacketIDInfo[playerID] = {}
|
redPacketTypeIDInfo = self.playerCanGetRedPacketIDInfo[playerID]
|
if getWay not in redPacketTypeIDInfo:
|
redPacketTypeIDInfo[getWay] = []
|
redPacketIDList = redPacketTypeIDInfo[getWay]
|
if redPacketID not in redPacketIDList:
|
redPacketIDList.append(redPacketID)
|
return redPacketIDList
|
return
|
|
def DelPlayerCanGetRedPacketID(self, playerID, getWay, redPacketID):
|
## ɾ³ýÍæ¼Ò¿ÉÁìÈ¡µÄºì°üID»º´æ
|
if playerID not in self.playerCanGetRedPacketIDInfo:
|
return
|
redPacketTypeIDInfo = self.playerCanGetRedPacketIDInfo[playerID]
|
if getWay not in redPacketTypeIDInfo:
|
return
|
redPacketIDList = redPacketTypeIDInfo[getWay]
|
if redPacketID not in redPacketIDList:
|
return
|
redPacketIDList.remove(redPacketID)
|
# ·µ»Øµ±Ç°ÀàÐÍ¿ÉÓúì°üIDÁбí
|
return redPacketIDList
|
|
def PrintRedPacketData(sign=""):
|
redPacketMgr = GetRedpacketMgr()
|
if sign:
|
GameWorld.DebugLog(" === %s ===" % sign)
|
GameWorld.DebugLog(" ËùÓкì°ü:count=%s,=%s" % (len(redPacketMgr.allRedPacketDict), redPacketMgr.allRedPacketDict.keys()))
|
for familyID, redIDList in redPacketMgr.familyRedPacketDict.items():
|
GameWorld.DebugLog(" ÏÉÃ˺ì°ü:familyID=%s,count=%s,%s" % (familyID, len(redIDList), redIDList))
|
GameWorld.DebugLog(" È«·þÈ«²¿Ï·¢ºì°ü=%s" % redPacketMgr.notifyAllServerRedPacketIDList)
|
for getWay, redIDList in redPacketMgr.activeRedPacketIDInfo.items():
|
GameWorld.DebugLog(" È«·þ¹«¹²»îÔ¾ºì°ü:getWay=%s,count=%s,%s" % (getWay, len(redIDList), redIDList))
|
for playerID, redIDInfo in redPacketMgr.playerNosendRedPacketIDInfo.items():
|
for getWay, redIDList in redIDInfo.items():
|
GameWorld.DebugLog(" È«·þ¸öÈË먦·Åºì°ü:playerID=%s,getWay=%s,count=%s,%s" % (playerID, getWay, len(redIDList), redIDList))
|
for playerID, redIDInfo in redPacketMgr.playerCanGetRedPacketIDInfo.items():
|
for getWay, redIDList in redIDInfo.items():
|
GameWorld.DebugLog(" È«·þ¸öÈË¿ÉÁìÈ¡ºì°ü:playerID=%s,getWay=%s,count=%s,%s" % (playerID, getWay, len(redIDList), redIDList))
|
return
|
|
def GetRedpacketMgr():
|
redPacketMgr = PyGameData.g_redPacketMgr
|
if redPacketMgr == None:
|
redPacketMgr = RedPacketMgr()
|
PyGameData.g_redPacketMgr = redPacketMgr
|
return redPacketMgr
|
|
def OnServerStart():
|
redPacketMgr = GetRedpacketMgr()
|
|
universalRecMgr = GameWorld.GetUniversalRecMgr()
|
|
# ºì°üÊý¾Ý
|
notifyLimitTypeList = IpyGameDataPY.GetFuncEvalCfg("RedPacketSys", 1)
|
recordList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord)
|
GameWorld.Log("¼ÓÔغì°üÐÅϢͨÓüǼ: count=%s" % recordList.Count())
|
for index in xrange(recordList.Count()):
|
recData = recordList.At(index)
|
state = recData.GetValue4()
|
if state == State_HasAllGot:
|
# ÒÑÈ«²¿ÁìÍêµÄ²»´¦Àí
|
continue
|
redPacketID = recData.GetValue1()
|
familyID = recData.GetValue2()
|
|
redPacketObj = redPacketMgr.GetRedPacketObj(redPacketID, True)
|
redPacketObj.familyID = familyID
|
redPacketObj.createTime = recData.GetTime()
|
redPacketObj.moneyType = recData.GetValue3() % 10
|
redPacketObj.moneyValue = recData.GetValue3() / 10
|
redPacketObj.state = recData.GetValue4()
|
redPacketObj.calcTime = recData.GetValue5()
|
|
strValue1List = recData.GetStrValue1().split('|')
|
playerID, playerName, job, getWay = strValue1List
|
redPacketObj.playerID = GameWorld.ToIntDef(playerID)
|
redPacketObj.playerName = playerName
|
redPacketObj.playerJob = GameWorld.ToIntDef(job)
|
redPacketObj.getWay = GameWorld.ToIntDef(getWay)
|
|
strValue2List = recData.GetStrValue2().split('|')
|
redPacketObj.packetCnt = GameWorld.ToIntDef(strValue2List[0])
|
redPacketObj.isAnonymous = GameWorld.ToIntDef(strValue2List[1]) if len(strValue2List) > 1 else 0
|
|
redPacketObj.wish = recData.GetStrValue3()
|
|
playerID = redPacketObj.playerID
|
getWay = redPacketObj.getWay
|
|
# 1. ÏÉÃ˵ĺì°ü
|
if familyID:
|
redPacketMgr.AddFamilyRedPacketID(familyID, redPacketID)
|
continue
|
|
# ÒÔÏÂÊÇÃæÏòÈ«·þµÄºì°ü
|
# 2. È«·þ먦·Åºì°ü
|
if state == State_NoSend:
|
# δ·¢·ÅµÄÌí¼Ó½øID»º´æ
|
redPacketMgr.AddPlayerNosendRedPacketID(playerID, getWay, redPacketID)
|
continue
|
|
# 3. È«·þ²»ÏÞÖÆÏ·¢¸öÊýµÄ
|
if getWay not in notifyLimitTypeList:
|
redPacketMgr.notifyAllServerRedPacketIDList.append(redPacketID)
|
continue
|
|
# 4. ÓÐÏÞÖÆ֪ͨ¸öÊýµÄ
|
if state == State_NoGot:
|
redPacketMgr.AddActiveRedPacketID(getWay, redPacketID)
|
|
# ÇÀºì°ü¼Ç¼
|
grabRecordList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord)
|
GameWorld.Log("¼ÓÔغì°üÇÀ¼Ç¼ÐÅϢͨÓüǼ: count=%s" % grabRecordList.Count())
|
for index in xrange(grabRecordList.Count()):
|
recData = grabRecordList.At(index)
|
redPacketID = recData.GetValue1()
|
playerID = recData.GetValue2()
|
redPacketObj = redPacketMgr.GetRedPacketObj(redPacketID, False)
|
if not redPacketObj:
|
continue
|
|
grabObj = RedPacketGrab(redPacketID, playerID)
|
grabObj.playerJob = recData.GetValue3()
|
grabObj.playerName = recData.GetStrValue1()
|
grabObj.moneyType = recData.GetValue4()
|
grabObj.getMoney = recData.GetValue5()
|
|
redPacketObj.grabDict[playerID] = grabObj
|
|
#PrintRedPacketData("OnServerStart")
|
return
|
|
def OnServerClose():
|
|
redPacketMgr = GetRedpacketMgr()
|
|
recMgr = GameWorld.GetUniversalRecMgr()
|
recMgr.Delete(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord)
|
recDataList = recMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord)
|
|
recMgr.Delete(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord)
|
grabRecDataList = recMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord)
|
|
redPacketCount = 0
|
grabRecCount = 0
|
for redPacketObj in redPacketMgr.allRedPacketDict.values():
|
if redPacketObj.state == State_HasAllGot:
|
# ÒÑÈ«²¿ÇÀÍêµÄ²»±£´æ
|
continue
|
recData = recDataList.AddRec()
|
__SaveRedpacketRecData(recData, redPacketObj)
|
redPacketCount += 1
|
|
for grabObj in redPacketObj.grabDict.values():
|
grabRecData = grabRecDataList.AddRec()
|
__SaveRedpacketRecGrabData(grabRecData, grabObj)
|
grabRecCount += 1
|
|
GameWorld.Log("±£´æºì°üÐÅϢͨÓüǼ: count=%s" % redPacketCount)
|
GameWorld.Log("±£´æºì°üÇÀ¼Ç¼ÐÅϢͨÓüǼ: count=%s" % grabRecCount)
|
return
|
|
def OnPlayerLogin(curPlayer):
|
|
if not PlayerControl.GetIsTJG(curPlayer):
|
|
redPacketMgr = GetRedpacketMgr()
|
playerID = curPlayer.GetPlayerID()
|
redPacketMgr.playerCanGetRedPacketIDInfo[playerID] = {}
|
|
notifyLimitTypeList = IpyGameDataPY.GetFuncEvalCfg("RedPacketSys", 1)
|
maxNotifyCount = IpyGameDataPY.GetFuncCfg("RedPacketSys", 2)
|
|
for getWay in notifyLimitTypeList:
|
redPacketMgr.playerCanGetRedPacketIDInfo[playerID][getWay] = [] # È·±£ getWay key Ò»¶¨´æÔÚ
|
|
nowActiveRedPacketIDList = redPacketMgr.activeRedPacketIDInfo.get(getWay, []) # µ±Ç°´ËÀàÐÍ»¹¿ÉÓõĹ«¹²ÒÑ¿ª·Åºì°üÁбí
|
if not nowActiveRedPacketIDList:
|
continue
|
nosendIDList = redPacketMgr.playerNosendRedPacketIDInfo.get(playerID, {}).get(getWay, [])
|
addCount = maxNotifyCount - len(nosendIDList)
|
if addCount <= 0:
|
continue
|
|
playerCanGetIDList = []
|
for redPacketID in nowActiveRedPacketIDList:
|
redPacketObj = redPacketMgr.GetRedPacketObj(redPacketID, False)
|
if not redPacketObj:
|
continue
|
if playerID in redPacketObj.grabDict:
|
continue
|
playerCanGetIDList.append(redPacketID)
|
addCount -= 1
|
if addCount <= 0:
|
break
|
redPacketMgr.playerCanGetRedPacketIDInfo[playerID][getWay] = playerCanGetIDList
|
|
#PrintRedPacketData("OnPlayerLogin %s" % playerID)
|
|
NotifyRedPacketInfo(curPlayer, isLogin=True)
|
return
|
|
def OnLeaveServer(curPlayer):
|
playerID = curPlayer.GetPlayerID()
|
redPacketMgr = GetRedpacketMgr()
|
redPacketMgr.playerCanGetRedPacketIDInfo.pop(playerID, None)
|
return
|
|
## ¸ôÌì¸üÐÂ
|
def DoOnDay():
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(DBKey_RedPacketSystemDayCount, 0) # ÖØÖÃÿÈÕÈ«·þϵͳºì°ü·¢·Å¸öÊý
|
RandTodayServerSystemRedPacketSendTime()
|
return
|
|
def GetRedPackGetWayType(getWay):
|
## »ñÈ¡ºì°ügetWayËùÊôºì°ü·ÖÀà
|
getWayTypeDict = IpyGameDataPY.GetFuncEvalCfg("RedPacketClassify", 1, {})
|
for getWayType, getWayList in getWayTypeDict.items():
|
if getWay in getWayList:
|
return getWayType
|
return ShareDefine.RedPackWayType_Family
|
|
def CheckDelRedpacketData():
|
## ¼ì²éºì°üɾ³ýºì°ü£¬5·ÖÖÓÒ»´Î£º 1-ɾ³ý¹ýÆÚºì°ü£¬2-ɾ³ýÒÑÈ«²¿ÇÀÍêµÄºì°ü
|
|
curTimeNum = int(time.time())
|
rangeTime = IpyGameDataPY.GetFuncCfg("RedPacketSys", 3) * 3600
|
|
backMoneyDict = {}
|
delRedPacketIDList = [] # ɾ³ýµÄÈ«·þºì°ü [ºì°üID, ...]
|
delFamilyRedPacketInfo = {} # ɾ³ýµÄÏÉÃ˺ì°ü {familyID:[ºì°üID, ...], ...}
|
delNosendRedPacketInfo = {} # Ҫ֪ͨ¸øÍæ¼Òɾ³ýµÄºì°ü {playerID:[ºì°üID, ...], ...}
|
|
redPacketMgr = GetRedpacketMgr()
|
|
for redPacketObj in redPacketMgr.allRedPacketDict.values():
|
|
state = redPacketObj.state
|
if state == State_HasAllGot:
|
pass
|
elif curTimeNum - redPacketObj.calcTime < rangeTime:
|
continue
|
|
redPacketID = redPacketObj.redPacketID
|
playerID = redPacketObj.playerID
|
familyID = redPacketObj.familyID
|
getWay = redPacketObj.getWay
|
|
if redPacketID in redPacketMgr.allRedPacketDict:
|
redPacketMgr.allRedPacketDict.pop(redPacketID)
|
|
# ·µ»¹Î´ÁìÍêµÄÍæ¼ÒÖ÷¶¯·¢·ÅµÄÏÉÓñºì°ü
|
if state != State_HasAllGot and playerID and getWay == ShareDefine.RedPackType_GoldPacket:
|
outNum = sum([grabObj.getMoney for grabObj in redPacketObj.grabDict.values()]) #Òѱ»ÇÀµÄÇ®
|
moneyType = redPacketObj.moneyType
|
totalMoney = redPacketObj.moneyValue
|
remainMoney = totalMoney - outNum #Ê£ÓàµÄÇ®
|
if moneyType == 1 and remainMoney:
|
backMoneyDict[playerID] = backMoneyDict.get(playerID, 0) + remainMoney
|
|
# 1. ÏÉÃ˺ì°ü
|
if familyID:
|
redPacketMgr.DelFamilyRedPacketID(familyID, redPacketID)
|
|
if familyID not in delFamilyRedPacketInfo:
|
delFamilyRedPacketInfo[familyID] = []
|
defFamilyRedPacketIDList = delFamilyRedPacketInfo[familyID]
|
defFamilyRedPacketIDList.append(redPacketID)
|
continue
|
|
# 2. È«·þºì°ü
|
|
# 2.1 ÊÇ·ñÍæ¼Ò˽ÓÐ먦·ÅµÄÈ«·þºì°ü
|
if state == State_NoSend:
|
redPacketMgr.DelPlayerNosendRedPacketID(playerID, getWay, redPacketID)
|
|
if playerID not in delNosendRedPacketInfo:
|
delNosendRedPacketInfo[playerID] = []
|
playerNosendRedPacketIDList = delNosendRedPacketInfo[playerID]
|
playerNosendRedPacketIDList.append(redPacketID)
|
continue
|
|
# 2.2 ÒÑ¿ª·ÅµÄÈ«·þºì°ü
|
redPacketMgr.DelActiveRedPacketID(getWay, redPacketID)
|
|
if redPacketID in redPacketMgr.notifyAllServerRedPacketIDList:
|
redPacketMgr.notifyAllServerRedPacketIDList.remove(redPacketID)
|
|
# Õâ¸öÍæ¼Ò¿ÉÁìÈ¡µÄ¿ÉÄÜ°üº¬·ÇÍæ¼Ò×Ô¼º·¢µÄºì°ü
|
for typeIDDict in redPacketMgr.playerCanGetRedPacketIDInfo.values():
|
if getWay not in typeIDDict:
|
continue
|
redpacketIDList = typeIDDict[getWay]
|
if redPacketID not in redpacketIDList:
|
continue
|
redpacketIDList.remove(redPacketID)
|
|
delRedPacketIDList.append(redPacketID)
|
|
#·µ»ØÍæ¼Òδ±»ÁìÈ¡µÄÏÉÓñ
|
if backMoneyDict:
|
for playerID, moneyNum in backMoneyDict.items():
|
PlayerCompensation.SendMailByKey('RedPackBack', [playerID], [], [], moneyNum)
|
|
playerManager = GameWorld.GetPlayerManager()
|
|
# ͬ²½É¾³ýµÄÏÉÃ˺ì°ü
|
#GameWorld.DebugLog("ͬ²½É¾³ýµÄÏÉÃ˺ì°ü: %s" % delFamilyRedPacketInfo)
|
for familyID, delIDList in delFamilyRedPacketInfo.items():
|
family = GameWorld.GetFamilyManager().FindFamily(familyID)
|
if not family:
|
return
|
|
sendPack = ChPyNetSendPack.tagGCRedPacketDel()
|
sendPack.DelRedPacketID = delIDList
|
sendPack.Cnt = len(delIDList)
|
|
for i in xrange(family.GetCount()):
|
notifyMember = family.GetAt(i)
|
curPlayer = playerManager.FindPlayerByID(notifyMember.GetPlayerID())
|
if curPlayer == None or not curPlayer.GetInitOK() or PlayerControl.GetIsTJG(curPlayer):
|
continue
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
|
# ͬ²½É¾³ý¸öÈË먦·ÅµÄÈ«·þºì°ü
|
#GameWorld.DebugLog("ͬ²½É¾³ý¸öÈË먦·ÅµÄÈ«·þºì°ü: %s" % delNosendRedPacketInfo)
|
for playerID, nosendIDList in delNosendRedPacketInfo.items():
|
curPlayer = playerManager.FindPlayerByID(playerID)
|
if curPlayer == None or not curPlayer.GetInitOK() or PlayerControl.GetIsTJG(curPlayer):
|
continue
|
sendPack = ChPyNetSendPack.tagGCRedPacketDel()
|
sendPack.DelRedPacketID = nosendIDList
|
sendPack.Cnt = len(nosendIDList)
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
|
# ͬ²½É¾³ýÒÑ¿ª·ÅµÄÈ«·þºì°ü
|
#GameWorld.DebugLog("ͬ²½É¾³ýÒÑ¿ª·ÅµÄÈ«·þºì°ü: %s" % delRedPacketIDList)
|
if delRedPacketIDList:
|
sendPack = ChPyNetSendPack.tagGCRedPacketDel()
|
sendPack.Clear()
|
sendPack.DelRedPacketID = delRedPacketIDList
|
sendPack.Cnt = len(delRedPacketIDList)
|
for i in xrange(playerManager.GetActivePlayerCount()):
|
curPlayer = playerManager.GetActivePlayerAt(i)
|
if curPlayer == None or not curPlayer.GetInitOK() or PlayerControl.GetIsTJG(curPlayer):
|
continue
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
|
return
|
|
def OnChangeRedPacketState(family, redPacketObj, beforeState=None):
|
## ºì°ü״̬±ä¸ü´¦Àí
|
state = redPacketObj.state
|
if state == beforeState:
|
return
|
|
redPacketMgr = GetRedpacketMgr()
|
redPacketID = redPacketObj.redPacketID
|
familyID = redPacketObj.familyID
|
ownerID = redPacketObj.playerID
|
getWay = redPacketObj.getWay
|
|
GameWorld.DebugLog("ºì°ü״̬±ä¸ü´¦Àí: redPacketID=%s,ownerID=%s,familyID=%s,beforeState=%s,state=%s"
|
% (redPacketID, ownerID, familyID, beforeState, state))
|
|
notifyPlayerDict = {ownerID:[redPacketID]} # ֪ͨ¸øÖ¸¶¨Íæ¼ÒµÄÐÅÏ¢£¬Ã¿¸öÍæ¼Ò¿ÉÄܲ»Ò»Ñù
|
|
# 1. ÏÉÃ˺ì°üÖ±½Ó֪ͨ¸ÃÏÉÃËËùÓгÉÔ±
|
if family:
|
if state in [State_NoSend, State_NoGot]:
|
redPacketMgr.AddFamilyRedPacketID(family.GetID(), redPacketID)
|
elif state == State_HasAllGot:
|
redPacketMgr.DelFamilyRedPacketID(familyID, redPacketID)
|
|
# ³ýÏÉÃ˺ì°üÍ⣬ÒÔÏÂÊÇÈ«·þºì°üµÄÏà¹Ø´¦Àí
|
|
# 2. È«·þ먦·Åºì°üĬÈÏÖ»·¢¸ø¸öÈË
|
elif state == State_NoSend:
|
if not ownerID:
|
return
|
if beforeState == None:
|
redPacketMgr.AddPlayerNosendRedPacketID(ownerID, getWay, redPacketID)
|
|
# 3. È«·þ²»ÏÞÖÆÏ·¢¸öÊýµÄͬ²½È«·þÍæ¼Ò
|
elif getWay not in IpyGameDataPY.GetFuncEvalCfg("RedPacketSys", 1):
|
notifyPlayerDict = None
|
if state == State_HasAllGot:
|
if redPacketID in redPacketMgr.notifyAllServerRedPacketIDList:
|
redPacketMgr.notifyAllServerRedPacketIDList.remove(redPacketID)
|
else:
|
if redPacketID not in redPacketMgr.notifyAllServerRedPacketIDList:
|
redPacketMgr.notifyAllServerRedPacketIDList.append(redPacketID)
|
|
# 4. ÆäËûµÄÒªÏÞÖÆÏ·¢¸öÊýµÄ¼ì²éÐèҪͬ²½µÄÍæ¼Ò¼´¿É
|
# 4.1 ±äΪ ¿ª·ÅÁìȡ״̬
|
elif state == State_NoGot:
|
if beforeState != State_NoGot:
|
redPacketMgr.DelPlayerNosendRedPacketID(ownerID, getWay, redPacketID) # ÒƳöÓµÓÐÕß˽ÓÐ먦·Åºì°ü¶ÓÁÐ
|
redPacketMgr.AddPlayerCanGetRedPacketID(ownerID, getWay, redPacketID) # Ìí¼ÓÓµÓÐÕß˽ÓÐÒÑ¿ª·Åºì°ü¶ÓÁÐ
|
redPacketMgr.AddActiveRedPacketID(getWay, redPacketID) # Ìí¼Ó¹«¹²ÒÑ¿ª·Åºì°ü¶ÓÁÐ
|
|
maxNotifyCount = IpyGameDataPY.GetFuncCfg("RedPacketSys", 2)
|
# ¼ì²é×·¼Ó¸Ãºì°ü¼Ç¼µÄÍæ¼Ò
|
for playerID, typeRedIDDict in redPacketMgr.playerCanGetRedPacketIDInfo.items():
|
if playerID == ownerID:
|
continue
|
redIDList = typeRedIDDict.get(getWay, [])
|
if redPacketID in redIDList:
|
continue
|
nosendTypeRedIDDict = redPacketMgr.playerNosendRedPacketIDInfo.get(playerID, {})
|
nosendRedIDList = nosendTypeRedIDDict.get(getWay, [])
|
totalCount = len(nosendRedIDList) + len(redIDList) # Íæ¼Òµ±Ç°»¹¿É²Ù×÷ÁìÈ¡µÄºì°üÊý
|
if totalCount >= maxNotifyCount:
|
continue
|
redPacketMgr.AddPlayerCanGetRedPacketID(playerID, getWay, redPacketID) # Ìí¼ÓÄ¿±êÍæ¼Ò˽ÓÐÒÑ¿ª·Åºì°ü¶ÓÁÐ
|
notifyPlayerDict[playerID] = [redPacketID]
|
|
# 4.1 ±äΪ È«²¿ÁìÈ¡Íê±Ï
|
elif state == State_HasAllGot:
|
if beforeState != State_HasAllGot:
|
redPacketMgr.DelActiveRedPacketID(getWay, redPacketID) # ÒƳý¹«¹²ÒÑ¿ª·Åºì°ü¶ÓÁÐ
|
|
nowActiveRedPacketIDList = redPacketMgr.activeRedPacketIDInfo.get(getWay, []) # µ±Ç°´ËÀàÐÍ»¹¿ÉÓõĹ«¹²ÒÑ¿ª·Åºì°üÁбí
|
|
# ¼ì²éÐèÒª²¹³äºì°ü¼Ç¼µÄÍæ¼Ò£¬²ÉÓà ¼õÈ¥1 ²¹³ä1 µÄģʽ
|
for playerID in redPacketMgr.playerCanGetRedPacketIDInfo.keys():
|
notifyRedIDList = DoPlayerReductCanGetRedPacket(playerID, redPacketObj, nowActiveRedPacketIDList)
|
if notifyRedIDList:
|
notifyPlayerDict[playerID] = notifyRedIDList
|
else:
|
return
|
|
#PrintRedPacketData("StateChange")
|
|
syncRedPacketList = [redPacketID]
|
playerManager = GameWorld.GetPlayerManager()
|
|
# ÏÉÃ˵ÄÖ±½Óͬ²½¸ÃÏÉÃËËùÓÐÍæ¼Ò
|
if family:
|
for i in xrange(family.GetCount()):
|
notifyMember = family.GetAt(i)
|
player = playerManager.FindPlayerByID(notifyMember.GetPlayerID())
|
if player == None or not player.GetInitOK() or PlayerControl.GetIsTJG(player):
|
continue
|
NotifyRedPacketInfo(player, syncRedPacketList)
|
|
# ûÓÐÖ¸¶¨Íæ¼Ò£¬Ôò֪ͨȫ·þÍæ¼Ò
|
elif notifyPlayerDict == None:
|
for i in xrange(playerManager.GetActivePlayerCount()):
|
player = playerManager.GetActivePlayerAt(i)
|
if player == None or not player.GetInitOK() or PlayerControl.GetIsTJG(player):
|
continue
|
NotifyRedPacketInfo(player, syncRedPacketList)
|
|
# ָ֪ͨ¶¨Íæ¼Ò
|
else:
|
for playerID, syncRedPacketList in notifyPlayerDict.items():
|
if not playerID:
|
continue
|
player = playerManager.FindPlayerByID(playerID)
|
if player == None or not player.GetInitOK() or PlayerControl.GetIsTJG(player):
|
continue
|
NotifyRedPacketInfo(player, syncRedPacketList)
|
return
|
|
def DoPlayerReductCanGetRedPacket(playerID, redPacketObj, nowActiveRedPacketIDList=None):
|
## Íæ¼Ò¼õÉÙÈ«·þÏÞÖÆÏ·¢ºì°ü¿ÉÁìÈ¡¸öÊý´¦Àí
|
## @return: ÐèҪ֪ͨµÄºì°üIDÁбí
|
|
getWay = redPacketObj.getWay
|
redPacketID = redPacketObj.redPacketID
|
|
redPacketMgr = GetRedpacketMgr()
|
if nowActiveRedPacketIDList == None:
|
nowActiveRedPacketIDList = redPacketMgr.activeRedPacketIDInfo.get(getWay, []) # µ±Ç°´ËÀàÐÍ»¹¿ÉÓõĹ«¹²ÒÑ¿ª·Åºì°üÁбí
|
|
# ¼ì²éÐèÒª²¹³äºì°ü¼Ç¼µÄÍæ¼Ò£¬²ÉÓà ¼õÈ¥1 ²¹³ä1 µÄģʽ
|
canGetIDList = redPacketMgr.DelPlayerCanGetRedPacketID(playerID, getWay, redPacketID) # ÒƳö˽ÓÐÒÑ¿ª·Åºì°ü¶ÓÁÐ
|
if canGetIDList == None:
|
return
|
|
lastCanGetID = 0 if not canGetIDList else canGetIDList[-1]
|
checkIndex = nowActiveRedPacketIDList.index(lastCanGetID) if lastCanGetID in nowActiveRedPacketIDList else 0
|
for i in xrange(checkIndex + 1, len(nowActiveRedPacketIDList)):
|
newCanGetRedID = nowActiveRedPacketIDList[i]
|
newRedPacketObj = redPacketMgr.GetRedPacketObj(newCanGetRedID, False)
|
if not newRedPacketObj:
|
continue
|
if playerID in newRedPacketObj.grabDict:
|
continue
|
if newCanGetRedID not in canGetIDList:
|
if redPacketMgr.AddPlayerCanGetRedPacketID(playerID, getWay, newCanGetRedID): # Ìí¼ÓÄ¿±êÍæ¼Ò˽ÓÐÒÑ¿ª·Åºì°ü¶ÓÁÐ
|
return [redPacketID, newCanGetRedID]
|
return [redPacketID]
|
|
def DelRedPackByFamilyID(delfamilyID):
|
## ɾ³ýÏÉÃ˵Äʱºò²ÅÐèҪɾ³ýºì°ü£¬ËùÒÔÕâÀï²»×ö֪ͨ£¬ÖØмÓÈëÏÉÃËʱ»áÖØÐÂͬ²½Ò»´Î isAll µÄÇé¿ö
|
|
familyID = delfamilyID
|
redPacketMgr = GetRedpacketMgr()
|
if familyID not in redPacketMgr.familyRedPacketDict:
|
return
|
familyRedpacketIDList = redPacketMgr.familyRedPacketDict.pop(familyID)
|
|
for redPacketID in familyRedpacketIDList:
|
if redPacketID in redPacketMgr.allRedPacketDict:
|
redPacketMgr.allRedPacketDict.pop(redPacketID)
|
|
GameWorld.DebugLog("½âÉ¢ÏÉÃËɾ³ýÏÉÃ˺ì°ü! familyID=%s, %s" % (familyID, familyRedpacketIDList))
|
return
|
|
##---------------------------------------- ½ÚÈÕºì°ü -----------------------------------------------
|
|
def OnResetFeastRedPacket(ipyData, dayIndex):
|
## ÖØÖýÚÈÕºì°ü״̬
|
|
if not ipyData:
|
return
|
|
dayRedPackIDList = ipyData.GetRedPacketIDList()
|
GameWorld.Log("ÖØÖýÚÈÕºì°ü·¢·Å״̬: dayRedPackIDList=%s, dayIndex=%s" % (dayRedPackIDList, dayIndex))
|
if dayIndex < 0 or dayIndex >= len(dayRedPackIDList):
|
GameWorld.ErrLog("µ±Ç°½ÚÈÕÌìË÷ÒýûÓÐÅäÅäÖÃϵͳºì°üID! dayRedPackIDList=%s, dayIndex=%s" % (dayRedPackIDList, dayIndex))
|
return
|
|
for redPackID in dayRedPackIDList[dayIndex]:
|
GameWorld.Log(" ÖØÖýÚÈÕºì°ü·¢·Å״̬: redPackID=%s" % redPackID)
|
if PlayerDBGSEvent.GetDBGSTrig_ByKey(DBKey_RedPacketSend % redPackID):
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(DBKey_RedPacketSend % redPackID, 0)
|
|
return
|
|
def __GetTodayRedPacketByTimeList():
|
key = "TodayRedPacketByTime"
|
openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1
|
TodayRedPacketByTimeInfo = IpyGameDataPY.GetConfigEx(key)
|
if TodayRedPacketByTimeInfo and TodayRedPacketByTimeInfo[0] == openServerDay:
|
#GameWorld.DebugLog("ÒѾ¼ÓÔعý±¾ÈÕϵͳ¶¨Ê±·¢·ÅµÄºì°ü! openServerDay=%s" % openServerDay)
|
return TodayRedPacketByTimeInfo[1]
|
|
redPacketByTimeList = []
|
serverTime = GameWorld.GetServerTime()
|
|
GameWorld.Log("===== ¼ÓÔؽñÌìϵͳ¶¨Ê±·¢·Åºì°üÐÅÏ¢ ===== openServerDay=%s" % openServerDay)
|
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in xrange(ipyDataMgr.GetFamilyRedPackCount()):
|
ipyData = ipyDataMgr.GetFamilyRedPackByIndex(index)
|
redPackID = ipyData.GetID()
|
openTimeStr = ipyData.GetPacketOpenTime()
|
if not openTimeStr:
|
#GameWorld.DebugLog("·Ç¶¨Ê±·¢·ÅµÄºì°ü!redPackID=%s" % (redPackID))
|
continue
|
|
openDateTime = datetime.datetime.strptime("%s:00" % openTimeStr, ChConfig.TYPE_Time_Format)
|
if openDateTime.year != serverTime.year or openDateTime.month != serverTime.month or openDateTime.day != serverTime.day:
|
#GameWorld.DebugLog("·Ç½ñÈÕ¶¨Ê±·¢·ÅµÄºì°ü!redPackID=%s" % (redPackID))
|
continue
|
|
endDateTime = None
|
validMinutes = ipyData.GetValidMinutes()
|
if validMinutes:
|
endDateTime = openDateTime + +datetime.timedelta(minutes=validMinutes)
|
|
redPacketByTimeList.append([redPackID, openDateTime, endDateTime])
|
|
GameWorld.Log(" Ôö¼Ó±¾ÈÕ¶¨Ê±·¢·Åϵͳºì°üÐÅÏ¢: redPackID=%s, %s" % (redPackID, openTimeStr))
|
|
TodayRedPacketByTimeInfo = IpyGameDataPY.SetConfigEx(key, [openServerDay, redPacketByTimeList])
|
GameWorld.Log("±¾ÈÕϵͳ¶¨Ê±·¢·ÅµÄºì°ü¼ÓÔØÍê±Ï!")
|
GameWorld.Log("=============================================================")
|
return TodayRedPacketByTimeInfo[1]
|
|
def OnRedPacketMinuteProcess():
|
## ÿ·ÖÖÓ´¦Àí£¬¶¨Ê±·¢·Åϵͳºì°ü
|
|
CheckSendServerSystemRedPacket()
|
|
todayRedPacketByTimeList = __GetTodayRedPacketByTimeList()
|
if not todayRedPacketByTimeList:
|
return
|
|
serverTime = GameWorld.GetServerTime()
|
|
for redPacketOpenInfo in todayRedPacketByTimeList:
|
redPackID, openDateTime, endDateTime = redPacketOpenInfo
|
|
if serverTime < openDateTime or (endDateTime and serverTime >= endDateTime):
|
#GameWorld.DebugLog("·Çºì°ü·¢·Åʱ¶Î! redPackID=%s, openDateTime=%s, endDateTime=%s" % (redPackID, openDateTime, endDateTime))
|
continue
|
|
if PlayerDBGSEvent.GetDBGSTrig_ByKey(DBKey_RedPacketSend % redPackID):
|
#GameWorld.DebugLog("ºì°üÒÑ·¢·Å¹ý! redPackID=%s" % (redPackID))
|
continue
|
CreateSystemRedPacket(redPackID)
|
|
return
|
|
def Sync_FeastRedPacket(ipyData, curPlayer=None):
|
## ͬ²½½ÚÈÕºì°ü»î¶¯ÐÅÏ¢
|
|
if not ipyData:
|
return
|
|
startDateStr, endDateStr = GameWorld.GetOperationActionDateStr(ipyData)
|
feastPack = ChPyNetSendPack.tagGCFeastRedPacketInfo()
|
feastPack.StartDate = startDateStr
|
feastPack.EndtDate = endDateStr
|
feastPack.LimitLV = ipyData.GetLVLimit()
|
feastPack.ResetType = ipyData.GetResetType()
|
feastPack.RedPacketDayList = []
|
for redPacketIDList in ipyData.GetRedPacketIDList():
|
dayInfo = ChPyNetSendPack.tagGCFeastRedPacketDay()
|
dayInfo.RedPacketIDList = redPacketIDList
|
dayInfo.RedPacketCount = len(dayInfo.RedPacketIDList)
|
feastPack.RedPacketDayList.append(dayInfo)
|
feastPack.RedPacketDays = len(feastPack.RedPacketDayList)
|
|
if not curPlayer:
|
# È«·þ¹ã²¥ÔÚÏßÍæ¼Ò
|
playerManager = GameWorld.GetPlayerManager()
|
for i in xrange(playerManager.GetActivePlayerCount()):
|
curPlayer = playerManager.GetActivePlayerAt(i)
|
if curPlayer == None or not curPlayer.GetInitOK():
|
continue
|
NetPackCommon.SendFakePack(curPlayer, feastPack)
|
else:
|
NetPackCommon.SendFakePack(curPlayer, feastPack)
|
return
|
|
##--------------------------------------------------------------------------------------------------
|
##---------------------------------------- È«·þϵͳºì°ü ---------------------------------------------
|
|
def RandTodayServerSystemRedPacketSendTime():
|
## Ëæ»úÉú³É½ñÈÕÈ«·þϵͳºì°ü·¢·Åʱ¼äµã
|
sendTimeList = []
|
sysRedPackketSendCountToday = PlayerDBGSEvent.GetDBGSTrig_ByKey(DBKey_RedPacketSystemDayCount)
|
maxCount = IpyGameDataPY.GetFuncCfg("ServerSysRedPacket", 1)
|
if not maxCount:
|
return
|
needSendCount = max(0, maxCount - sysRedPackketSendCountToday)
|
|
GameWorld.Log("Ëæ»úÉú³É·¢·ÅÈ«·þϵͳºì°üʱ¼ä! maxCount=%s,sysRedPackketSendCountToday=%s,needSendCount=%s"
|
% (maxCount, sysRedPackketSendCountToday, needSendCount))
|
if needSendCount > 0:
|
startHour, endHour = IpyGameDataPY.GetFuncEvalCfg("ServerSysRedPacket", 3)
|
serverTime = GameWorld.GetServerTime()
|
year, month, day = serverTime.year, serverTime.month, serverTime.day
|
startDateTime = datetime.datetime(year, month, day, startHour)
|
if endHour == 0:
|
endDateTime = datetime.datetime(year, month, day) + datetime.timedelta(days=1)
|
else:
|
endDateTime = datetime.datetime(year, month, day, endHour)
|
|
totalSeconds = (endDateTime - startDateTime).seconds # ¿É´¦ÀíµÄ×ÜÃëÊý
|
aveSeconds = totalSeconds / maxCount # ƽ¾ù¼ä¸ô
|
GameWorld.Log(" startDateTime=%s" % startDateTime)
|
GameWorld.Log(" endDateTime=%s" % endDateTime)
|
GameWorld.Log(" totalSeconds=%s,aveSeconds=%s" % (totalSeconds, aveSeconds))
|
|
nextStartDateTime = startDateTime
|
for _ in xrange(maxCount):
|
randSeconds = random.randint(60, aveSeconds - 60) # Ç°ºó¿Ûµô1·ÖÖÓ£¬·ÀÖ¹Ëæ»úµ½Í¬·ÖÖÓ
|
randSendDateTime = nextStartDateTime + datetime.timedelta(seconds=randSeconds)
|
if randSendDateTime > serverTime:
|
sendTimeList.append(randSendDateTime)
|
GameWorld.Log(" Ëæ»úÆðʼʱ¼ä=%s,randSeconds=%s,Ëæ»ú·¢·Åʱ¼ä=%s" % (nextStartDateTime, randSeconds, randSendDateTime))
|
|
nextStartDateTime += datetime.timedelta(seconds=aveSeconds)
|
|
GameWorld.Log(" sendTimeList=%s" % sendTimeList)
|
IpyGameDataPY.SetConfigEx("ServerSystemRedPacketSendTime", sendTimeList)
|
return sendTimeList
|
|
def CheckSendServerSystemRedPacket():
|
## ¼ì²é·¢ËͽñÈÕÈ«·þϵͳºì°ü
|
|
sendTimeList = IpyGameDataPY.GetConfigEx("ServerSystemRedPacketSendTime")
|
if sendTimeList == None:
|
sendTimeList = RandTodayServerSystemRedPacketSendTime()
|
|
if not sendTimeList:
|
#GameWorld.DebugLog("ûÓÐËæ»ú·¢·Åϵͳºì°üʱ¼äÁË£¡")
|
return
|
|
serverTime = GameWorld.GetServerTime()
|
nextSendTime = sendTimeList[0]
|
if serverTime.hour == nextSendTime.hour and serverTime.minute == nextSendTime.minute:
|
sendTimeList.pop(0)
|
|
randSysRedPacketList = IpyGameDataPY.GetFuncEvalCfg("ServerSysRedPacket", 2)
|
redPackID = GameWorld.GetResultByRandomList(randSysRedPacketList)
|
if not redPackID:
|
return
|
|
CreateSystemRedPacket(redPackID)
|
|
sysRedPackketSendCountToday = PlayerDBGSEvent.GetDBGSTrig_ByKey(DBKey_RedPacketSystemDayCount) + 1
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(DBKey_RedPacketSystemDayCount, sysRedPackketSendCountToday)
|
GameWorld.Log("·¢·ÅÈ«·þϵͳºì°ü: redPackID=%s, sysRedPackketSendCountToday=%s" % (redPackID, sysRedPackketSendCountToday))
|
|
maxCount = IpyGameDataPY.GetFuncCfg("ServerSysRedPacket", 1)
|
if sysRedPackketSendCountToday >= maxCount:
|
IpyGameDataPY.SetConfigEx("ServerSystemRedPacketSendTime", [])
|
GameWorld.Log(" ½ñÈÕÈ«·þϵͳºì°üÒѾȫ²¿·¢ÍêÁË£¡ maxCount=%s" % maxCount)
|
|
elif nextSendTime < serverTime:
|
sendTimeList.pop(0)
|
#GameWorld.DebugLog("·¢·Åϵͳºì°üʱ¼ä¹ýÆÚÁË£¡serverTime=%s, nextSendTime=%s" % (serverTime, nextSendTime))
|
#else:
|
# GameWorld.DebugLog("·Ç·¢·Åϵͳºì°üʱ¼ä£¡serverTime=%s, nextSendTime=%s" % (serverTime, nextSendTime))
|
|
return
|
|
##--------------------------------------------------------------------------------------------------
|
|
def CreateSystemRedPacket(redPackID):
|
## ·¢·Åϵͳºì°ü
|
ipyData = IpyGameDataPY.GetIpyGameData('FamilyRedPack', redPackID)
|
if not ipyData:
|
return
|
getType = ipyData.GetGetType()
|
moneyType = ipyData.GetMoneyType()
|
outputNum = ipyData.GetMoneyNum()
|
packetCnt = ipyData.GetPacketCnt()
|
openTime = ipyData.GetPacketOpenTime() # Èç¹ûÓÐÖ¸¶¨·¢·Åʱ¼äµÄ
|
sysCreateTime = GameWorld.ChangeTimeStrToNum("%s:00" % openTime) if openTime else None
|
|
isAnonymous = 0
|
state = State_NoGot # ÔÝÖ±½ÓÉ趨ÒÑ·¢·Å
|
if ipyData.GetPacketOpenTime():
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(DBKey_RedPacketSend % redPackID, 1)
|
GameWorld.DebugLog("¶¨Ê±·¢·ÅµÄºì°ü£¬ÉèÖÃÒÑ·¢·Å! redPackID=%s" % redPackID)
|
|
getWayType = GetRedPackGetWayType(getType)
|
if getWayType == ShareDefine.RedPackWayType_Server:
|
isAnonymous = 1
|
|
job = 0
|
jobRank = 0
|
playerName = ""
|
playerID = 0
|
family = None
|
|
__SaveNewRedRecord(family, playerID, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt, state, sysCreateTime=sysCreateTime, isAnonymous=isAnonymous)
|
return
|
|
## Éú³Éкì°ü
|
def MapServer_CreatRedPacket(msgList):
|
playerID, getType, packetCnt, moneyType, outputNum, wishStr, state, data, isFamilyRedPacket = msgList
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not curPlayer:
|
return
|
if not isFamilyRedPacket:
|
familyID = 0
|
family = None
|
else:
|
familyID = curPlayer.GetFamilyID()
|
family = GameWorld.GetFamilyManager().FindFamily(familyID)
|
if not family:
|
return
|
|
if outputNum < packetCnt:
|
GameWorld.DebugLog(" Éú³ÉÐÂÏÉÃ˺ì°ü ºì°ü¶î¶È²»Äܵ͸úì°ü¸öÊý£¡outputNum=%s,redCnt=%s" % (outputNum, packetCnt))
|
return
|
job = curPlayer.GetJob()
|
jobRank = 0
|
playerName = curPlayer.GetName()
|
__SaveNewRedRecord(family, playerID, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt, state, wishStr, data=data)
|
return
|
|
def CreatNewFamilyRedPacket(family, playerID, redPackID):
|
'''Íⲿ½Ó¿Ú£¬Éú³ÉÏÉÃËкì°ü'''
|
if not family or not playerID or not redPackID:
|
return
|
ipyData = IpyGameDataPY.GetIpyGameData('FamilyRedPack', redPackID)
|
if not ipyData:
|
return
|
getType = ipyData.GetGetType()
|
moneyType = ipyData.GetMoneyType()
|
outputNum = ipyData.GetMoneyNum()
|
|
familyID = family.GetID()
|
member = family.FindMember(playerID)
|
if not member:
|
GameWorld.ErrLog("ÏÉÃËûÓиóÉÔ±, ÎÞ·¨·¢·ÅÏÉÃ˺ì°ü!familyID=%s,playerID=%s,redPackID=%s" % (familyID, playerID, redPackID))
|
return
|
|
job = member.GetJob()
|
jobRank = 0
|
playerName = member.GetName()
|
|
__SaveNewRedRecord(family, playerID, playerName, job, jobRank, getType, moneyType, outputNum, 0)
|
return
|
|
## ¼Ç¼Ðºì°üÊý¾Ý
|
def __SaveNewRedRecord(family, ownerID, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt, state=State_NoSend, wishStr='', sysCreateTime=None, data=0, isAnonymous=0):
|
|
#ºì°üΨһID ´Ó1¿ªÊ¼ÀÛ¼Æ ³¬¹ý20ÒÚÔòÖØпªÊ¼
|
# ºì°üΨһID
|
DB_RedPacketID = "FamilyRedPacketID"
|
redPacketID = PlayerDBGSEvent.GetDBGSTrig_ByKey(DB_RedPacketID) + 1
|
if redPacketID >= ChConfig.Def_UpperLimit_DWord:
|
redPacketID = 1
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(DB_RedPacketID, redPacketID)
|
|
familyID = family.GetID() if family else 0
|
|
curTimeNum = int(time.time())
|
|
redPacketMgr = GetRedpacketMgr()
|
redPacketObj = redPacketMgr.GetRedPacketObj(redPacketID, True)
|
redPacketObj.redPacketID = redPacketID
|
redPacketObj.familyID = familyID
|
redPacketObj.moneyType = moneyType
|
redPacketObj.moneyValue = outputNum
|
redPacketObj.state = state
|
redPacketObj.createTime = sysCreateTime if sysCreateTime else curTimeNum
|
redPacketObj.calcTime = curTimeNum
|
redPacketObj.playerID = ownerID
|
redPacketObj.playerName = playerName
|
redPacketObj.playerJob = job
|
redPacketObj.getWay = getType
|
redPacketObj.packetCnt = packetCnt
|
redPacketObj.isAnonymous = isAnonymous # ÊÇ·ñÄäÃû
|
redPacketObj.wish = wishStr
|
redPacketObj.grabDict = {}
|
|
GameWorld.Log("Éú³Éеĺì°ü: familyID=%s,redPacketID=%s,ownerID=%s,getType=%s,moneyType=%s,outputNum=%s,packetCnt=%s,state=%s,isAnonymous=%s"
|
% (familyID, redPacketID, ownerID, getType, moneyType, outputNum, packetCnt, state, isAnonymous))
|
|
#֪ͨ
|
OnChangeRedPacketState(family, redPacketObj, None)
|
|
if not familyID:
|
#´óÓÚ200¶î¶ÈµÄºì°ü
|
getTypeRainDict = IpyGameDataPY.GetFuncEvalCfg('OpenServerRedPacketRain', 2, {})
|
if str(getType) in getTypeRainDict:
|
PlayerControl.WorldNotify(0, getTypeRainDict[str(getType)])
|
elif outputNum >= IpyGameDataPY.GetFuncCfg('OpenServerRedPacketRain'):
|
PlayerControl.WorldNotify(0, 'OSRedpackSfx', [getType])
|
|
return redPacketObj
|
|
def SendFamilyRedPacket(msgList):
|
'''¿ª·Åºì°ü¿ÉÁìÈ¡£¬¸Ãºì°üÒÑ´æÔÚ£¬Ö»ÊÇ״̬δ·¢·Å£¬ÓɹéÊôÍæ¼Ò×ÔÓÉÑ¡Ôñ·¢·Åʱ»ú'''
|
playerID, redPacketID, packetCnt, isAnonymous = msgList
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not curPlayer:
|
return
|
|
redPacketMgr = GetRedpacketMgr()
|
redPacketObj = redPacketMgr.GetRedPacketObj(redPacketID, False)
|
if not redPacketObj:
|
return
|
|
ownID = redPacketObj.playerID
|
getWay = redPacketObj.getWay
|
|
ipyData = IpyGameDataPY.GetIpyGameDataByCondition('FamilyRedPack', {'GetType':getWay})
|
if not ipyData:
|
return
|
if ipyData.GetLeaderOwn():
|
if not PlayerFamily.GetPlayerHasFamilyPow(curPlayer, ChConfig.Def_PurviewDictKey_CanSendRedPacket):
|
GameWorld.DebugLog(' ·¢ÏµÍ³ÔùË͵ĺì°ü ȨÏÞ²»×㣡', playerID)
|
return
|
if playerID != ownID:
|
redPacketObj.playerID = playerID
|
|
elif playerID != ownID:
|
GameWorld.DebugLog(' ·¢ÏµÍ³ÔùË͵ĺì°ü ²»ÊDZ¾ÈË£¡', playerID)
|
return
|
|
beforeState = redPacketObj.state
|
redPacketObj.state = State_NoGot
|
redPacketObj.packetCnt = packetCnt
|
redPacketObj.isAnonymous = int(isAnonymous)
|
redPacketObj.calcTime = int(time.time())
|
|
if redPacketObj.familyID == 0:
|
family = None
|
else:
|
family = curPlayer.GetFamily()
|
if family == None:
|
return
|
|
OnChangeRedPacketState(family, redPacketObj, beforeState)
|
return
|
|
def DoGrabFamilyRedPacket(curPlayer, msgList):
|
## ÇÀºì°ü
|
redPacketID, reqGetWay, canGrabCnt = msgList
|
|
redPacketMgr = GetRedpacketMgr()
|
redPacketObj = redPacketMgr.GetRedPacketObj(redPacketID, False)
|
if not redPacketObj:
|
GameWorld.ErrLog("ºì°ü²»´æÔÚ£¡")
|
return
|
|
playerID = curPlayer.GetPlayerID()
|
|
state = redPacketObj.state
|
beforeState = state
|
if state in [State_NoSend]:
|
GameWorld.DebugLog(" ¸Ãºì°ü»¹Î´·¢ËÍ£¡", playerID)
|
return
|
|
familyID = redPacketObj.familyID
|
if familyID:
|
curFamily = curPlayer.GetFamily()
|
if curFamily == None:
|
return
|
else:
|
curFamily = None
|
|
moneyType = redPacketObj.moneyType
|
totalMoney = redPacketObj.moneyValue
|
packetCnt = redPacketObj.packetCnt
|
|
#ÕҸúì°üµÄÇÀÐÅÏ¢
|
grabRecordDict = redPacketObj.grabDict
|
if playerID in grabRecordDict:
|
GameWorld.DebugLog(" ¸ÃÍæ¼ÒÒÑÇÀ¹ý´Ëºì°ü£¡", playerID)
|
__NotifyGrabRedPacketInfo(curPlayer, redPacketID, grabRecordDict)
|
return
|
|
outNum = sum([grabObj.getMoney for grabObj in grabRecordDict.values()]) #Òѱ»ÇÀµÄÇ®
|
remainNum = totalMoney - outNum #Ê£ÓàµÄÇ®
|
|
if len(grabRecordDict) >= packetCnt or remainNum <= 0:
|
GameWorld.DebugLog(" ºì°üÒѱ»ÇÀÍ꣡", playerID)
|
if state != State_HasAllGot:
|
redPacketObj.state = State_HasAllGot
|
#GameWorld.DebugLog(" ¾ÀÕýºì°üÒÑÇÀÍê״̬! state=%s,updState=%s" % (state, State_HasAllGot))
|
OnChangeRedPacketState(curFamily, redPacketObj, beforeState)
|
__NotifyGrabRedPacketInfo(curPlayer, redPacketID, grabRecordDict)
|
return
|
|
remainPacketCnt = packetCnt - len(grabRecordDict)
|
|
getWay = redPacketObj.getWay
|
owerID = redPacketObj.playerID
|
isSelf = owerID == playerID
|
if not isSelf and canGrabCnt != -1 and canGrabCnt <= 0:
|
GameWorld.DebugLog(' ÇÀ¿ª·þºì°ü£¬´ÎÊý²»×㣡£¡')
|
return
|
if reqGetWay != getWay:
|
GameWorld.ErrLog("ÁìÈ¡µÄºì°üÀàÐͲ»Ò»Ö£¬ÎÞ·¨ÁìÈ¡! reqGetWay=%s,getWay=%s" % (reqGetWay, getWay))
|
return
|
|
getWayType = GetRedPackGetWayType(getWay)
|
if getWayType == ShareDefine.RedPackWayType_Server:
|
getNumformula = IpyGameDataPY.GetFuncCompileCfg('OpenRedRacketOutNum')
|
elif getWayType == ShareDefine.RedPackWayType_Feast:
|
getNumformula = IpyGameDataPY.GetFuncCompileCfg('FeastRedPacket', 2)
|
else:
|
getNumformula = IpyGameDataPY.GetFuncCompileCfg('FamilyRedRacketOutNum')
|
|
getMoney = eval(getNumformula) if remainPacketCnt > 1 else remainNum
|
getMoney = min(getMoney, remainNum)
|
remainNum -= getMoney
|
GameWorld.DebugLog(" ¸ÃÍæ¼ÒÇÀµ½ºì°ü: redPacketID=%s,getWay=%s,getMoney=%s,remainNum=%s"
|
% (redPacketID, getWay, getMoney, remainNum), playerID)
|
|
# ÐÂÔöÇÀµÄ¼Ç¼
|
grabObj = RedPacketGrab(redPacketID, playerID)
|
grabObj.playerJob = curPlayer.GetJob()
|
grabObj.playerName = curPlayer.GetName()
|
grabObj.moneyType = moneyType
|
grabObj.getMoney = getMoney
|
grabRecordDict[playerID] = grabObj
|
|
if len(grabRecordDict) >= packetCnt or remainNum <= 0:
|
redPacketObj.state = State_HasAllGot
|
OnChangeRedPacketState(curFamily, redPacketObj, beforeState)
|
else:
|
if getWay in IpyGameDataPY.GetFuncEvalCfg("RedPacketSys", 1):
|
#PrintRedPacketData("GrabBefore")
|
notifyRedIDList = DoPlayerReductCanGetRedPacket(playerID, redPacketObj)
|
if notifyRedIDList:
|
NotifyRedPacketInfo(curPlayer, notifyRedIDList)
|
#PrintRedPacketData("GrabAfter")
|
else:
|
NotifyRedPacketInfo(curPlayer, [redPacketID])
|
|
__NotifyGrabRedPacketInfo(curPlayer, redPacketID, grabRecordDict)
|
|
#¸øÇ®
|
result = str([moneyType, getMoney, getWay, isSelf])
|
curPlayer.MapServer_QueryPlayerResult(0, 0, "GrabFamilyRedPacketResult", result, len(result))
|
return getMoney
|
|
def __NotifyGrabRedPacketInfo(curPlayer, redPacketID, grabRecordDict):
|
'''֪ͨÇÀºì°üÐÅÏ¢'''
|
sendPack = ChPyNetSendPack.tagGCFamilyRedPacketGrabInfo()
|
sendPack.Clear()
|
sendPack.RedPacketID = redPacketID
|
sendPack.GrabInfo = []
|
for grabObj in grabRecordDict.values():
|
grabInfo = ChPyNetSendPack.tagFGrabRedPacketInfo()
|
grabInfo.Name = grabObj.playerName
|
grabInfo.NameLen = len(grabInfo.Name)
|
grabInfo.PlayeJob = grabObj.playerJob
|
grabInfo.MoneyNum = grabObj.getMoney
|
sendPack.GrabInfo.append(grabInfo)
|
sendPack.Count = len(sendPack.GrabInfo)
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
return
|
|
def NotifyRedPacketInfo(curPlayer, syncRedPacketIDList=None, isLogin=False):
|
## ֪ͨºì°üÐÅÏ¢
|
if PlayerControl.GetIsTJG(curPlayer):
|
return
|
|
redPacketMgr = GetRedpacketMgr()
|
isAll = int(syncRedPacketIDList == None)
|
if syncRedPacketIDList == None:
|
syncRedPacketIDList = []
|
|
playerID = curPlayer.GetPlayerID()
|
family = curPlayer.GetFamily()
|
familyID = family.GetID() if family else 0
|
|
syncRedPacketIDList += redPacketMgr.familyRedPacketDict.get(familyID, []) # 1. ÏÉÃËËùÓУ¨º¬Î´¿ª·ÅµÄ£©
|
|
syncRedPacketIDList += redPacketMgr.notifyAllServerRedPacketIDList # 2. È«·þ²»ÏÞÖÆÏ·¢¸öÊý
|
|
# 3. È«·þ˽ÓÐ먦·Å
|
for redIDList in redPacketMgr.playerNosendRedPacketIDInfo.get(playerID, {}).values():
|
syncRedPacketIDList += redIDList
|
|
# 4. È«·þÏÞÖÆÏ·¢¸öÊý·ÖÅä¸ø¸öÈË¿ÉÁìÈ¡µÄºì°ü
|
for redIDList in redPacketMgr.playerCanGetRedPacketIDInfo.get(playerID, {}).values():
|
syncRedPacketIDList += redIDList
|
|
if not syncRedPacketIDList and isLogin:
|
return
|
|
redPacketInfo = []
|
playerID = curPlayer.GetPlayerID()
|
joinFamilyTime = PlayerFamily.GetPlayerJoinFamilyTime(curPlayer)
|
#GameWorld.DebugLog("֪ͨºì°üÐÅÏ¢: isLogin=%s,isAll=%s,syncRedPacketIDList=%s" % (isLogin, isAll, syncRedPacketIDList), playerID)
|
|
for redPacketID in syncRedPacketIDList:
|
redPacketObj = redPacketMgr.GetRedPacketObj(redPacketID, False)
|
if not redPacketObj:
|
continue
|
|
#ÏÉÃ˺ì°üֻ֪ͨÍæ¼Ò½øÈëÏÉÃ˺óÉú³ÉµÄºì°ü
|
if redPacketObj.familyID:
|
if joinFamilyTime and redPacketObj.calcTime < joinFamilyTime:
|
#GameWorld.DebugLog(" ¼ÓÈëÏÉÃË֮ǰµÄºì°ü²»·¢: redPacketID=%s,joinFamilyTime=%s > %s" % (redPacketID, joinFamilyTime, redPacketObj.calcTime))
|
continue
|
|
state = redPacketObj.state
|
if playerID in redPacketObj.grabDict:
|
state = State_HasGot
|
if isAll and state in [State_HasGot, State_HasAllGot]:
|
#GameWorld.DebugLog(" ÒÑÇÀ»òÇÀÍêµÄ²»·¢: redPacketID=%s,state=%s" % (redPacketID, state))
|
continue
|
|
packetInfo = ChPyNetSendPack.tagFRedPacketInfo()
|
packetInfo.Clear()
|
packetInfo.RedPacketID = redPacketObj.redPacketID
|
packetInfo.PlayerID = redPacketObj.playerID
|
packetInfo.Name = "" if redPacketObj.isAnonymous else redPacketObj.playerName
|
packetInfo.NameLen = len(packetInfo.Name)
|
packetInfo.Time = redPacketObj.createTime
|
packetInfo.PlayeJob = redPacketObj.playerJob
|
packetInfo.MoneyType = redPacketObj.moneyType
|
packetInfo.MoneyNum = redPacketObj.moneyValue
|
packetInfo.GetWay = redPacketObj.getWay
|
packetInfo.State = state
|
packetInfo.PacketCnt = redPacketObj.packetCnt
|
packetInfo.IsAnonymous = int(redPacketObj.isAnonymous)
|
packetInfo.Wish = redPacketObj.wish
|
packetInfo.WishLen = len(packetInfo.Wish)
|
redPacketInfo.append(packetInfo)
|
if len(redPacketInfo) > 250:
|
#GameWorld.DebugLog("ºì°üÌ«¶àÁË!")
|
break
|
|
if not redPacketInfo:
|
return
|
|
sendPack = ChPyNetSendPack.tagGCFamilyRedPacketInfo()
|
sendPack.Clear()
|
sendPack.IsAll = isAll
|
sendPack.RedPacketInfo = redPacketInfo
|
sendPack.Count = len(sendPack.RedPacketInfo)
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
return
|
