6087 【后端】【1.5.200】春节红包雨活动（初版）

hxp

2019-01-29 5300950136a7d0556945fbd0cb953b331ee79f2c

6087 【后端】【1.5.200】春节红包雨活动（初版）

 ServerPython/CoreServerGroup/GameServer/Script/GM/Commands/SetRedPacket.py

New file
@@ -0,0 +1,49 @@
#!/usr/bin/python

# -*- coding: GBK -*-

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

#

##@package GM.Commands.SetRedPacket

#

# @todo:设置红包

# @author hxp

# @date 2019-01-29

# @version 1.0

#

# 详细描述: 设置红包

#

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

#"""Version = 2019-01-29 16:00"""

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



import PlayerFamilyRedPacket

import ShareDefine

import GameWorld





## GM命令执行入口

#  @param curPlayer 当前玩家

#  @param paramList 参数列表

#  @return None or True

#  @remarks 函数详细说明.

def OnExec(curPlayer, paramList):

    if not paramList:

        return

    
    # 重置所有红包数据

    if len(paramList) == 1 and paramList[0] == 0:

        GameWorld.DebugAnswer(curPlayer, "清除所有红包领取记录")

        PlayerFamilyRedPacket.g_allRecordDict = {}

        PlayerFamilyRedPacket.g_grabDataDict = {}

        PlayerFamilyRedPacket.g_redPackCountDict = {}

        
        recordType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord

        universalRecMgr = GameWorld.GetUniversalRecMgr()

        universalRecMgr.Delete(recordType)

        PlayerFamilyRedPacket.NotifyRedPacketInfo(curPlayer)

        return

    
    
    return








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

@@ -36,6 +36,7 @@
import PlayerXMZZ

import PlayerFamilySWRH

import GameWorldBoss

import PlayerFamilyRedPacket

import PlayerFairyCeremony

import PlayerNewFairyCeremony

import GameWorldProcess

@@ -87,6 +88,12 @@
        ipyData = operationActionDict[ShareDefine.OperationActionName_RealmPoint][0]

        if ipyData:

            Sync_OperationAction_RealmPoint(ipyData, curPlayer)

    # 节日红包活动进行中

    if ShareDefine.OperationActionName_FeastRedPacket in operationActionDict:

        ipyData = operationActionDict[ShareDefine.OperationActionName_FeastRedPacket][0]

        if ipyData:

            PlayerFamilyRedPacket.Sync_FeastRedPacket(ipyData, curPlayer)

            
    return



def SendMapServerOperationActionState():

@@ -446,6 +453,7 @@
        

        dbOperationActIDKey = PlayerDBGSEvent.Def_OperationActID % actName

        curActID = sendMapServerMsgDict.get(ShareDefine.ActKey_ID)

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

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

            PlayerDBGSEvent.SetDBGSTrig_ByKey(dbOperationActIDKey, curActID)

            if actName in ShareDefine.NeedWorldLVOperationActNameList:

@@ -463,6 +471,10 @@
            elif actName == ShareDefine.OperationActionName_NewFairyCeremony:

                #重置仙界盛典

                PlayerNewFairyCeremony.ResetNewFairyCeremony()

            elif actName == ShareDefine.OperationActionName_FeastRedPacket:

                #重置节日红包

                if ipyData and dayIndex == 0:

                    PlayerFamilyRedPacket.OnResetFeastRedPacket(ipyData)

            elif actName == ShareDefine.OperationActionName_FlashSale:

                #限时抢购重置购买次数 本次活动每场不能重复

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

@@ -497,7 +509,9 @@
        elif actName == ShareDefine.OperationActionName_RealmPoint:

            if isReload and ipyData:

                Sync_OperationAction_RealmPoint(ipyData)

        
        elif actName == ShareDefine.OperationActionName_FeastRedPacket:

            if isReload and ipyData:

                PlayerFamilyRedPacket.Sync_FeastRedPacket(ipyData)

                

        #通知Mapserver,设置字典

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


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

@@ -357,6 +357,8 @@
    PlayerTeam.DoCountdownLeaveTeamLogic(tick)

    #副本助战

    PlayerFBHelpBattle.OnMinuteProcess()

    #红包

    PlayerFamilyRedPacket.OnRedPacketMinuteProcess()

    #每5分钟触发一次仙盟总战力更新

    if curMinute % 5 == 0:

        PlayerFamily.UpdFamilyTotalFightPower()


 ServerPython/CoreServerGroup/GameServer/Script/Player/PlayerFamilyRedPacket.py

@@ -31,16 +31,22 @@


import time

import random

import datetime



'''

红包暂定有效期24小时，过天清除过期的红包，如果是玩家发放的返还未领取的货币

上线同步所有红包信息，红包变化实时广播全服在线玩家

'''

#Def_UniversalGameRecType_FamilyRedPacketAllRecord

#value1    红包唯一ID

#value2    家族ID

#Time      创建红包时间，非红包实际开放领取时间，如果红包表有配置系统发放时间，则该时间存配表时间，没有的话存创建时的服务器时间

#value1    红包唯一ID，该ID为实例ID，非配表的红包ID

#value2    家族ID，0代表全服红包

#value3    总额度*10+金钱类型

#value4    ״̬

#value5    时间，用来判断是否过期删除的

#strValue1 创建者ID|创建者名字|创建者职业|获得途径

#value5    时间，用来判断是否过期删除的，实际开放该红包领取的时间

#strValue1 创建者ID|创建者名字|创建者职业|获得途径（红包类型）

#strValue2 可抢总个数

#strValue3 祝福语

#strValue3 祝福语，玩家自己编辑的内容



#Def_UniversalGameRecType_FamilyRedPacketGrabRecord

#value1    红包唯一ID

@@ -59,7 +65,10 @@


g_allRecordDict = {} #{红包ID:recData, ...}

g_grabDataDict = {} #{红包ID:{playerid:[抢到的钱,名字,job]}, ...}

g_osRedCnt = 0 #开服红包个数

g_redPackCountDict = {} #有限制最大红包个数的类型对应当前红包数 {类型组对应记录编号:当前个数, ...}



DBKey_RedPacketSend = "RedPacketSend_%s" # 系统定时红包是否已发放， 参数红包ID



## 玩家登录

#  @param None

#  @return None

@@ -76,14 +85,157 @@
    

    return



##---------------------------------------- 节日红包 -----------------------------------------------



def OnResetFeastRedPacket(ipyData):

    ## 重置节日红包状态

    
    if not ipyData:

        return

    
    dayRedPackIDList = ipyData.GetRedPacketIDList()

    GameWorld.DebugLog("重置红包发放状态: dayRedPackIDList=%s" % dayRedPackIDList)

    for redPackIDList in dayRedPackIDList:

        for redPackID in redPackIDList:

            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():

    ## 每分钟处理，定时发放系统红包

    
    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

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

    feastPack = ChPyNetSendPack.tagGCFeastRedPacketInfo()

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

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

    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 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

    
    state = State_NoGot # 暂直接设定已发放

    if ipyData.GetPacketOpenTime():

        PlayerDBGSEvent.SetDBGSTrig_ByKey(DBKey_RedPacketSend % redPackID, 1)

        GameWorld.DebugLog("定时发放的红包，设置已发放! redPackID=%s" % redPackID)

        
    job = 0

    jobRank = 0

    playerName = ""

    playerID = 0

    familyID = 0

    family = None

    
    redPacketRecData = __SaveNewRedRecord(familyID, playerID, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt, state, sysCreateTime=sysCreateTime)

    #֪ͨ

    __NotifyFamilyRedPacketInfo(family, redPacketRecData, [])

    return



## 生成新红包

def CreatFamilyRedPacket(msgList):

    playerID, getType, packetCnt, moneyType, outputNum, wishStr, state, data = msgList

def MapServer_CreatRedPacket(msgList):

    playerID, getType, packetCnt, moneyType, outputNum, wishStr, state, data, isFamilyRedPacket = msgList

    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)

    if not curPlayer:

        return

    if getType == IpyGameDataPY.GetFuncCfg('OpenServerRedPacketType'):

    if not isFamilyRedPacket:

        familyID = 0

        family = None

    else:

@@ -113,7 +265,10 @@
            elif data in IpyGameDataPY.GetFuncEvalCfg('OSRSuccess'):

                PlayerControl.WorldNotify(0, 'OpenRedBag3', [playerName, data, outputNum])

            #大于200额度的红包

            if outputNum >= IpyGameDataPY.GetFuncCfg('OpenServerRedPacketRain'):

            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')

    return



@@ -144,19 +299,21 @@
    return



## 记录新红包数据

def __SaveNewRedRecord(familyID, ownerid, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt,state=State_NoSend, wishStr=''):

def __SaveNewRedRecord(familyID, ownerid, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt,state=State_NoSend, wishStr='', sysCreateTime=None):

    global g_allRecordDict

    global g_osRedCnt

    global g_redPackCountDict

    job = job + jobRank * 10   #个位是job 十位百位是jobrank

    recordType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord

    universalRecMgr = GameWorld.GetUniversalRecMgr()

    recordList = universalRecMgr.GetTypeList(recordType)

    if getType == IpyGameDataPY.GetFuncCfg('OpenServerRedPacketType'):

        if not __CheckOSRedPacketCnt(recordList):

            return

        if g_osRedCnt:

            g_osRedCnt += 1

    
    for maxCountKeyNum, getTypeList in ShareDefine.RedPackMaxCountDict.items():

        if getType in getTypeList:

            if not __CheckOSRedPacketCnt(recordList, maxCountKeyNum, getTypeList):

                return

            g_redPackCountDict[maxCountKeyNum] = g_redPackCountDict.get(maxCountKeyNum, 0) + 1

            GameWorld.DebugLog("当前红包数: g_redPackCountDict=%s" % g_redPackCountDict)

            break

        
    recData = recordList.AddRec()

    

    

@@ -169,29 +326,29 @@
    PlayerDBGSEvent.SetDBGSTrig_ByKey(DB_RedPacketID, redPacketID)

    

    curTimeNum = int(time.time())

    recData.SetTime(curTimeNum)

    recData.SetTime(sysCreateTime if sysCreateTime else curTimeNum) # 为方便前端对比配表设置的发放红包时间，如果有配置的时间，则创建时间默认取配表的

    recData.SetValue1(redPacketID) #红包唯一ID

    recData.SetValue2(familyID)  #家族ID   

    recData.SetValue3(moneyType + outputNum * 10) #总额度*10+金钱类型

    recData.SetValue4(state) #是否已发

    recData.SetValue5(curTimeNum) 
    recData.SetValue5(curTimeNum) #该时间为开放领取的时间，不一定等于创建时间

    recData.SetStrValue1('%s|%s|%s|%s'%(ownerid,playerName,job,getType)) #创建者ID|创建者名字|创建者职业|途径

    recData.SetStrValue2(str(packetCnt))#可抢总个数

    recData.SetStrValue3(wishStr)#祝福语

    g_allRecordDict[redPacketID] = recData

    GameWorld.Log("    生成新的红包familyID=%s, redPacketID =%s！ownerid=%s, ownername=%s,getType=%s,moneyType=%s,outputNum=%s,packetCnt=%s" % (familyID, redPacketID, ownerid, playerName, getType, moneyType, outputNum, packetCnt))

    GameWorld.Log("生成新的红包: familyID=%s,redPacketID=%s,ownerid=%s,ownername=%s,getType=%s,moneyType=%s,outputNum=%s,packetCnt=%s" % (familyID, redPacketID, ownerid, playerName, getType, moneyType, outputNum, packetCnt))

    return recData





def __CheckOSRedPacketCnt(recordList):

def __CheckOSRedPacketCnt(recordList, maxCountKeyNum, getTypeList):

    global g_grabDataDict

    global g_allRecordDict

    global g_osRedCnt

    global g_redPackCountDict

    ##开服红包个数是否达上限

    openServerRedPacketCnt = IpyGameDataPY.GetFuncCfg('OpenServerRedPacketCnt')

    if g_osRedCnt and g_osRedCnt < openServerRedPacketCnt + 10:

    curRedCnt = g_redPackCountDict.get(maxCountKeyNum, 0)

    openServerRedPacketCnt = IpyGameDataPY.GetFuncCfg('OpenServerRedPacketCnt', 1) # 直接用开服红包这个配置作为通用配置

    if curRedCnt and curRedCnt < openServerRedPacketCnt + 10:

        return True

    OpenServerRedPacketType = IpyGameDataPY.GetFuncCfg('OpenServerRedPacketType')

    allCnt = recordList.Count()



    curCnt = 0

@@ -201,20 +358,20 @@
        strValue1 = universalRecData.GetStrValue1()

        strValue1List = strValue1.split('|')

        getWay = int(strValue1List[3])

        if getWay != OpenServerRedPacketType:

        if getWay not in getTypeList:

            continue

        redPacketID = universalRecData.GetValue1()

        curCnt += 1

        if len(delRedPacketIDList) < 10:

            delRedPacketIDList.append(redPacketID)

        elif g_osRedCnt:

        elif curRedCnt:

            break

    if not delRedPacketIDList:

        return True

    if not g_osRedCnt:

        g_osRedCnt = curCnt

    if not curRedCnt:

        curRedCnt = curCnt



    if g_osRedCnt < openServerRedPacketCnt + 10:

    if curRedCnt < openServerRedPacketCnt + 10:

        return True



    delCnt = 0

@@ -227,7 +384,7 @@
            delCnt +=1

            g_grabDataDict.pop(delRedPacketID, 0)

            g_allRecordDict.pop(delRedPacketID, 0)

    g_osRedCnt -= delCnt

    curRedCnt -= delCnt

    

        

    recordType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord

@@ -276,7 +433,7 @@




def SendFamilyRedPacket(msgList):

    '''发系统赠送的红包'''

    '''发系统赠送的红包，该红包已存在，只是状态未发放，由归属玩家自由选择发放时机'''

    playerID, redPacketID, packetCnt = msgList

    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)

    if not curPlayer:

@@ -326,7 +483,7 @@
## 抢红包

def DoGrabFamilyRedPacket(curPlayer, msgList):

    global g_grabDataDict

    redPacketID, OSCanGrabCnt = msgList

    redPacketID, reqGetWay, canGrabCnt = msgList

    

    playerID= curPlayer.GetPlayerID()

    job = curPlayer.GetJob()

@@ -374,15 +531,19 @@
    getWay = int(strValue1List[3])

    owerID = int(strValue1List[0])

    isSelf = owerID == playerID

    if getWay == IpyGameDataPY.GetFuncCfg('OpenServerRedPacketType'):

        #开服红包需要判断次数

        if not isSelf and OSCanGrabCnt <= 0:

            GameWorld.DebugLog('    抢开服红包，次数不足！！')

            return

    if not isSelf and canGrabCnt != -1 and canGrabCnt <= 0:

        GameWorld.DebugLog('    抢开服红包，次数不足！！')

        return

    if reqGetWay != getWay:

        GameWorld.ErrLog("领取的红包类型不一致，无法领取! reqGetWay=%s,getWay=%s" % (reqGetWay, getWay))

        return

    if getWay == ShareDefine.RedPackType_OpenServer:

        getNumformula = IpyGameDataPY.GetFuncCompileCfg('OpenRedRacketOutNum')

    elif getWay in ShareDefine.FeastRedPackType:

        getNumformula = IpyGameDataPY.GetFuncCompileCfg('FeastRedPacket', 2)

    else:

        getNumformula = IpyGameDataPY.GetFuncCompileCfg('FamilyRedRacketOutNum')

    
        
    getMoney = eval(getNumformula) if remainPacketCnt > 1 else remainNum

    GameWorld.DebugLog("    该玩家抢到红包=%s！"%getMoney, playerID)

    grabRecordDict[playerID] = [getMoney, playerName, job]

@@ -451,8 +612,8 @@
def __CheckGrabRecData():

    global g_grabDataDict

    global g_allRecordDict

    global g_osRedCnt

    g_osRedCnt = 0

    global g_redPackCountDict

    g_redPackCountDict = {}

    universalRecMgr = GameWorld.GetUniversalRecMgr()

    allRecordList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord)

    allCnt = allRecordList.Count()


 ServerPython/CoreServerGroup/GameServer/Script/Player/PlayerQuery.py

@@ -748,8 +748,8 @@
        return

    

    #生成仙盟红包

    if callName == 'CreatFamilyRedPacket':

        PlayerFamilyRedPacket.CreatFamilyRedPacket(eval(resultName))

    if callName == "MapServer_CreatRedPacket":

        PlayerFamilyRedPacket.MapServer_CreatRedPacket(eval(resultName))

        return

    #发仙盟红包

    if callName == 'SendFamilyRedPacket':


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Event/EventSrc/Operate_PlayerBuyZhenQi.py

@@ -163,6 +163,8 @@
        return

    #成就

    PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_Pray, 1, [buyType])

    PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_Pray, 1)

    
    # 每日活动

    PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_Pray)

    PlayerFairyCeremony.AddFCPartyActionCnt(curPlayer, ChConfig.Def_PPAct_Pray, 1)


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Event/EventSrc/QuestRunner.py

@@ -5239,6 +5239,7 @@
    GameWorld.Log('    跑环完成触发活跃度 missionType=%s'%missionType, curPlayer.GetPlayerID())

    if missionType == QuestCommon.Def_Mission_Type_RunDaily:

        PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_DailyRunMission, addCnt)

        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_TaskCRun, addCnt)

        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_TaskCRun, addCnt)

        PlayerBossReborn.AddBossRebornActionCnt(curPlayer, ChConfig.Def_BRAct_RunTask, addCnt)

        PlayerFairyCeremony.AddFCPartyActionCnt(curPlayer, ChConfig.Def_PPAct_RunTask, addCnt)


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/GM/Commands/SetRedPacket.py

New file
@@ -0,0 +1,91 @@
#!/usr/bin/python

# -*- coding: GBK -*-

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

#

##@package GM.Commands.SetRedPacket

#

# @todo:设置红包

# @author hxp

# @date 2019-01-29

# @version 1.0

#

# 详细描述: 设置红包

#

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

#"""Version = 2019-01-29 16:00"""

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



import GameWorld

import PlayerControl

import ChConfig

import PlayerFamilyRedPacket

import IpyGameDataPY

import PlayerSuccess



## GM命令执行入口

#  @param curPlayer 当前玩家

#  @param paramList 参数列表

#  @return None or True

#  @remarks 函数详细说明.

def OnExec(curPlayer, paramList):

    if not paramList:

        GameWorld.DebugAnswer(curPlayer, "重置红包:SetRedPacket 0")

        GameWorld.DebugAnswer(curPlayer, "SetRedPacket 红包功能  可抢个数 已抢额度")

        GameWorld.DebugAnswer(curPlayer, "红包功能: 1-开服红包；2-节日红包")

        return

    
    # 重置所有红包数据

    if len(paramList) == 1 and paramList[0] == 0:

        __DOResetSuccRedPack(curPlayer)

        __DoResetRedPackFunc(curPlayer, 1, None, 0)

        __DoResetRedPackFunc(curPlayer, 2, None, 0)

        curPlayer.GameServer_GMCmd("SetRedPacket 0") # 发送到GameServer清除红包

        return

    
    if len(paramList) == 3:

        redPackFuncType, grabCount, grabMoney = paramList

        __DoResetRedPackFunc(curPlayer, redPackFuncType, grabCount, grabMoney)

        return

    
    return



def __DOResetSuccRedPack(curPlayer):

    ## 重置红包成就发放记录，不重置进度

    resetList = []

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    for index in xrange(ipyDataMgr.GetSuccessCount()):

        succData = ipyDataMgr.GetSuccessByIndex(index)

        succID = succData.ID

        succType = succData.Type

        condition = succData.Condition

        if not succData.RedPacketID:

            continue

        if not PlayerSuccess.GetSuccFinishValue(curPlayer, succType, condition):

            continue

        #SetSuccFinishValue(curPlayer, succType, condition, 0)

        if PlayerSuccess.GetSuccHasGot(curPlayer, succID):

            PlayerSuccess.SetSuccFinish(curPlayer, succID, True)

            PlayerSuccess.SetSuccHasGot(curPlayer, succID, False)

            resetList.append(succID)

            
    if resetList:

        PlayerSuccess.Sync_SuccTypeIndexAwardRecord(curPlayer, resetList, True)

        PlayerSuccess.Sync_SuccessInfo(curPlayer, resetList, True)

        
    return



def __DoResetRedPackFunc(curPlayer, redPackFuncType, grabCount, grabMoney):

    if redPackFuncType == 1:

        if not isinstance(grabCount, int):

            grabCount = IpyGameDataPY.GetFuncCfg('OpenServerRedPacketCfg', 5)

        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_OSRedPacketCanGrabCnt, grabCount)

        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_OSRedPacketGrabMoney, grabMoney)

        PlayerFamilyRedPacket.NotifyOSRedPacket(curPlayer)

    elif redPackFuncType == 2:

        if not isinstance(grabCount, int):

            grabCount = IpyGameDataPY.GetFuncCfg('FeastRedPacket', 1)

        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_OSRedPacketCanGrabCnt, grabCount)

        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_OSRedPacketGrabMoney, grabMoney)

    return






 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/GameWorldLogic/FBLogic.py

@@ -18,6 +18,7 @@
import IPY_GameWorld

import PlayerControl

import GameWorldProcess

import PlayerSuccess

import ReadChConfig

import ShareDefine

import FBCommon

@@ -522,6 +523,8 @@
    

    #注册进入这个副本的玩家

    gameFBMgr.AddFBPlayer(curPlayerID)

    
    PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_EnterMap, 1, [gameMapID])

    return



def DoEnterFB(curPlayer, tick):


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/NPC/NPCCommon.py

@@ -2153,6 +2153,7 @@
        dataDict = {"objID":npcID, "bossID":npcID, "touchCnt":newCnt,

                    "AccID":curPlayer.GetAccID(), "PlayerID":curPlayer.GetPlayerID()}

        DataRecordPack.SendEventPack("AddKillBossCnt", dataDict, curPlayer)

        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_KillBoss, 1, [limitIndex])

        

    if isCrossServer:

        return

@@ -5038,6 +5039,7 @@
        else:

            if curNPC.GetLV()>=curPlayer.GetLV() - IpyGameDataPY.GetFuncCfg('DailyQuestKillMonster'):

                PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_KillNPC)

            PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_KillSpecificNPC, 1, [npcID])

            

        if ChConfig.IsGameBoss(curNPC):

            OnPlayerKillBoss(curPlayer, npcID, mapID, False)


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/ChPlayer.py

@@ -104,6 +104,7 @@
import PlayerSpringSale

import PlayerFairyCeremony

import PlayerNewFairyCeremony

import PlayerFeastRedPacket

import CrossRealmPlayer

import ChNetSendPack

import FamilyRobBoss

@@ -682,6 +683,7 @@
    PlayerRune.PlayerRuneLogin(curPlayer)

    # 仙盟红包登录通知

    PlayerFamilyRedPacket.OnPlayerLogin(curPlayer)

    PlayerFeastRedPacket.DoPlayerOnLogin(curPlayer)

    # 法宝登录通知

    PlayerMagicWeapon.PlayerMagicWeaponLogin(curPlayer)

    # 商店物品购买次数登录通知


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerCrossRealmPK.py

@@ -27,6 +27,7 @@
import PlayerWeekParty

import IPY_GameWorld

import ItemControler

import PlayerSuccess

import ItemCommon

import GameWorld

import ChConfig

@@ -314,6 +315,7 @@
            GameWorld.Log("    增加今日已获胜次数: todayWinCount=%s" % todayWinCount, playerID)

        PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_CrossReamPK)

        PlayerWeekParty.AddWeekPartyActionCnt(curPlayer, ChConfig.Def_WPAct_CrossPK, 1)

        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_CrossPK, 1)

    else:

        GameWorld.Log("    不同天的PK结算不增加今日PK次数! ", playerID)

        


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerDiceEx.py

@@ -13,7 +13,8 @@
#

# 详细描述: 我要太极

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

"""Version = 2016-09-26 20:00"""

#"""Version = 2016-09-26 20:00"""

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



import GameWorld

import IPY_GameWorld

@@ -25,6 +26,7 @@
import ChConfig

import IpyGameDataPY

import PlayerActivity

import PlayerSuccess

import ItemCommon





@@ -70,6 +72,7 @@
            return

        if not __DoDicelogic(curPlayer):

            return

        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_Dice, 1)

        

    elif diceType == 1:

        if not diceResult:


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerEventCounter.py

@@ -85,6 +85,7 @@
import PlayerFlashGiftbag

import PlayerFairyCeremony

import PlayerNewFairyCeremony

import PlayerFeastRedPacket

import PlayerRefineStove

import PlayerFlashSale

import PlayerWishingWell

@@ -1316,7 +1317,10 @@
                

            elif actionName == ShareDefine.OperationActionName_FeastWeekParty:

                PlayerFeastWeekParty.RefreshOperationAction_FeastWeekParty()

            
                
            elif actionName == ShareDefine.OperationActionName_FeastRedPacket:

                PlayerFeastRedPacket.RefreshOperationAction_FeastRedPacket()

                
            return

        

        if msgValue.isdigit():


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerFB.py

@@ -32,6 +32,7 @@
import FBLogic

import ChPyNetSendPack

import NetPackCommon

import PlayerSuccess

import ItemCommon

import IpyGameDataPY

import ShareDefine

@@ -332,6 +333,8 @@
    if not FBLogic.OnPlayerFBSweepAsk(curPlayer, mapID, lineID, cnt, isFinish, dataEx):

        return

    

    PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_FBSweep, 1, [mapID])

    
    #扣除扫荡道具

    if sweepCostindexList and sweepCostCnt:

        ItemCommon.ReduceItem(curPlayer, itemPack, sweepCostindexList, sweepCostCnt, False, 'FBSweepCostItem')


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerFamilyRedPacket.py

@@ -19,15 +19,13 @@
import IpyGameDataPY

import IPY_GameWorld

import ChPyNetSendPack

import PlayerFeastRedPacket

import NetPackCommon

import PlayerVip

import ShareDefine



import time

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



Def_GoldPacket = 0 #主动发钻石红包





(

State_NoSend, #未发

@@ -73,36 +71,47 @@
    return





def CreatRedPacketByID(curPlayer, redPacketID, state=State_NoSend, data=0):

    #根据红包ID生成红包

def CreatRedPacketByID(curPlayer, redPacketID, state=State_NoSend, data=0, wishInfo=""):

    '''根据红包ID生成红包 - 外部功能调用接口

    '''

    ipyData = IpyGameDataPY.GetIpyGameData('FamilyRedPack', redPacketID)

    if not ipyData:

        return

    getType = ipyData.GetGetType()

    if getType == IpyGameDataPY.GetFuncCfg('OpenServerRedPacketType'):

    if not getType:

        return

    if getType == ShareDefine.RedPackType_OpenServer:

        oscDay = IpyGameDataPY.GetFuncCfg('OpenServerRedPacketCfg')

        openServerDay = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_ServerDay)

        if openServerDay >= oscDay:

            GameWorld.DebugLog('    发开服红包,活动已过，不可发送！')

            return

        isFamilyRedPacket = False

    elif getType == ShareDefine.RedPackType_FeastSucc:

        if not PlayerFeastRedPacket.GetFeastRedPacketState():

            GameWorld.DebugLog('    非节日红包活动中，不可发送！')

            return

        isFamilyRedPacket = False

    else:

        if not curPlayer.GetFamilyID():

            #没家族 先存起来，等进仙盟时再补发

            GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_FamilyRedPacketCache, redPacketID, 1)

            return

    
    DoCreatFamilyRedPacket(curPlayer, getType, ipyData.GetMoneyType(), ipyData.GetMoneyNum(), ipyData.GetPacketCnt(), state, '', data)

        isFamilyRedPacket = True

        
    __DoCreatRedPacket(curPlayer, getType, ipyData.GetMoneyType(), ipyData.GetMoneyNum(), ipyData.GetPacketCnt(), state, wishInfo, data, isFamilyRedPacket)

    return



## 生成红包

def DoCreatFamilyRedPacket(curPlayer, getType, moneyType=2, awardNum=100, packetCnt=10, state=State_NoSend, wishInfo='', data=0):



        
    
## 生成红包，注意外部不可直接调用该函数

def __DoCreatRedPacket(curPlayer, getType, moneyType=2, awardNum=100, packetCnt=10, state=State_NoSend, wishInfo='', data=0, isFamilyRedPacket=True):

    playerID = curPlayer.GetPlayerID()

    packetCnt = min(packetCnt, awardNum)

    

    if getType == Def_GoldPacket:

    if isFamilyRedPacket and not curPlayer.GetFamilyID():

        GameWorld.DebugLog("玩家无仙盟，无法发放归属仙盟的红包!getType=%s" % (getType), playerID)

        return

    
    if getType == ShareDefine.RedPackType_GoldPacket:

        goldLimit = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FamilyRedPacketGoldLimit, 0)

        familyRedPacketGoldLimit = IpyGameDataPY.GetFuncCfg('FamilyRedPacketGoldLimit')

        if awardNum + goldLimit > familyRedPacketGoldLimit:

@@ -126,9 +135,9 @@
#            return

        

    #通知Gameserver生成红包

    msg = str([playerID, getType, packetCnt, moneyType, awardNum, wishInfo, state, data])

    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(curPlayer.GetID(), 0, 0, "CreatFamilyRedPacket", msg, len(msg))

    GameWorld.DebugLog('    DoCreatFamilyRedPacket 通知Gameserver生成红包 msg=%s' % msg)

    msg = str([playerID, getType, packetCnt, moneyType, awardNum, wishInfo, state, data, isFamilyRedPacket])

    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(curPlayer.GetID(), 0, 0, "MapServer_CreatRedPacket", msg, len(msg))

    GameWorld.DebugLog('    通知Gameserver生成红包 msg=%s' % msg)

    return





@@ -155,8 +164,9 @@
        if not PlayerVip.GetPrivilegeValue(curPlayer, ChConfig.VIPPrivilege_FamilyGoldPack):

            GameWorld.DebugLog("主动发的钻石红包 VIP权限不足")

            return

        DoCreatFamilyRedPacket(curPlayer, Def_GoldPacket, IPY_GameWorld.TYPE_Price_Gold_Money, moneyNum, packetCnt, State_NoGot, wishInfo)

        __DoCreatRedPacket(curPlayer, ShareDefine.RedPackType_GoldPacket, IPY_GameWorld.TYPE_Price_Gold_Money, moneyNum, packetCnt, State_NoGot, wishInfo)

    else:

        # 注意：该函数发放的是已创建的红包，该操作只是把该红包开放给玩家可抢

        msg = str([curPlayer.GetPlayerID(), redPacketID, packetCnt])

        GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(curPlayer.GetID(), 0, 0, "SendFamilyRedPacket", msg, len(msg))

    return

@@ -187,21 +197,27 @@
    return





#// A4 04 抢家族红包 #tagCGGrabFamilyRedPacket

#// AB 12 抢红包 #tagCMGrabFamilyRedPacket

#

#struct    tagCGGrabFamilyRedPacket

#struct    tagCMGrabFamilyRedPacket

#{

#    tagHead        Head;

#    DWORD        RedPaketID;         // 红包ID

#    BYTE        GetWay;            //获得途径

#};

## 抢红包

def OnGrabFamilyRedPacket(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    redPacketID = clientData.RedPaketID

    OSCanGrabCnt = GetOSCanGrabCnt(curPlayer)

    msg = str([redPacketID, OSCanGrabCnt])

    reqGetWay = clientData.GetWay

    if reqGetWay == ShareDefine.RedPackType_OpenServer:

        canGrabCnt = GetOSCanGrabCnt(curPlayer)

    elif reqGetWay == ShareDefine.RedPackType_FeastSucc:

        canGrabCnt = PlayerFeastRedPacket.GetFeastSuccRedPacketCanGrabCnt(curPlayer)

    else:

        canGrabCnt = -1

    msg = str([redPacketID, reqGetWay, canGrabCnt])

    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(curPlayer.GetID(), 0, 0, "GrabFamilyRedPacket", msg, len(msg))

    GameWorld.DebugLog('    抢红包 OSCanGrabCnt=%s'%OSCanGrabCnt)

    GameWorld.DebugLog('    抢红包 getWay=%s,canGrabCnt=%s' % (reqGetWay, canGrabCnt))

    return






 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerFeastRedPacket.py

New file
@@ -0,0 +1,157 @@
#!/usr/bin/python

# -*- coding: GBK -*-

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

#

##@package Player.PlayerFeastRedPacket

#

# @todo:节日红包

# @author hxp

# @date 2019-01-29

# @version 1.0

#

# 详细描述: 节日红包

#

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

#"""Version = 2019-01-29 16:00"""

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



import GameWorld

import PyGameData

import PlayerControl

import IpyGameDataPY

import PlayerSuccess

import ChPyNetSendPack

import NetPackCommon

import ShareDefine

import ChConfig



def DoPlayerOnLogin(curPlayer):

    if not GetFeastRedPacketState():

        return

    isReset = __CheckPlayerFeastRedPacketAction(curPlayer)

    if not isReset:

        Sync_FeastRedPackInfo(curPlayer)

    return



def RefreshOperationAction_FeastRedPacket():

    __UpdTodayFeastSuccIDList()

    
    playerManager = GameWorld.GetPlayerManager()

    for i in xrange(playerManager.OnlineCount()):

        curPlayer = playerManager.OnlineAt(i)

        if curPlayer == None or not curPlayer.GetInitOK():

            continue

        __CheckPlayerFeastRedPacketAction(curPlayer)

        
    return



def __UpdTodayFeastSuccIDList():

    feastRedPacketInfo = PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_FeastRedPacket, {})

    state = feastRedPacketInfo.get(ShareDefine.ActKey_State, 0)

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

    if not state:

        return

    
    feastDay = dayIndex + 1

    feastIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActFeastRedPacketSucc", feastDay)

    if not feastIpyDataList:

        return

    
    succIDList = []

    for feastIpyData in feastIpyDataList:

        succIDList += list(feastIpyData.GetFeastSuccIDList())

        
    GameWorld.DebugLog("    更新今日节日红包成就ID列表: %s" % succIDList)

    IpyGameDataPY.SetConfigEx("TodayFeastSuccIDList", succIDList)

    return

def GetTodayFeastSuccIDList(): return IpyGameDataPY.GetConfigEx("TodayFeastSuccIDList")



def __CheckPlayerFeastRedPacketAction(curPlayer):

    ## 检查玩家节日红包活动数据信息

    
    playerID = curPlayer.GetPlayerID()

    
    feastRedPacketInfo = PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_FeastRedPacket, {})

    curActID = feastRedPacketInfo.get(ShareDefine.ActKey_ID, 0)

    state = feastRedPacketInfo.get(ShareDefine.ActKey_State, 0)

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

    
    playerActID = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FeastRedPacketActID) # 玩家身上的活动ID

    
    # 活动ID 相同的话不处理

    if curActID == playerActID:

        GameWorld.DebugLog("红包节日活动ID不变，不处理！", playerID)

        return

    GameWorld.DebugLog("重置玩家红包节日活动! curActID=%s,playerActID=%s,state=%s,dayIndex=%s" % (curActID, playerActID, state, dayIndex), playerID)

    
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FeastRedPacketActID, curActID)

    dayCanGrabCount = IpyGameDataPY.GetFuncCfg('FeastRedPacket', 1)

    # 非第一天只重置每日次数，且次数可以累加

    if dayIndex == 0:

        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FeastRedPacketGrabMoney, 0)

        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FeastRedPacketCanGrabCnt, dayCanGrabCount)

        GameWorld.DebugLog("    首日重置次数及金额!", playerID)

    else:

        remainGrabCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FeastRedPacketCanGrabCnt)

        setTotalCanGrabCnt = remainGrabCnt + dayCanGrabCount

        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FeastRedPacketCanGrabCnt, setTotalCanGrabCnt)

        GameWorld.DebugLog("    非首日重置次数! remainGrabCnt=%s,setTotalCanGrabCnt=%s" % (remainGrabCnt, setTotalCanGrabCnt), playerID)

        
    # 重置相关成就

    resetSuccIDList = []

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    for index in xrange(ipyDataMgr.GetActFeastRedPacketSuccCount()):

        ipyData = ipyDataMgr.GetActFeastRedPacketSuccByIndex(index)

        feastDay = ipyData.GetFeastDay()

        feastDayIndex = feastDay - 1

        if feastDayIndex == 0 or feastDayIndex == dayIndex:

            for succID in ipyData.GetFeastSuccIDList():

                if succID not in resetSuccIDList:

                    resetSuccIDList.append(succID)

    PlayerSuccess.DoResetSuccessIDList(curPlayer, resetSuccIDList)

    
    Sync_FeastRedPackInfo(curPlayer)

    return True



def GetFeastRedPacketState():

    ## 节日红包活动状态

    feastRedPacketInfo = PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_FeastRedPacket, {})

    return feastRedPacketInfo.get(ShareDefine.ActKey_State, 0)



def GetFeastSuccRedPacketCanGrabCnt(curPlayer):

    ## 节日成就红包可领取次数

    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FeastRedPacketCanGrabCnt)



def GrabFeastRedPacketResult(curPlayer, moneyNum, getWay, isSelf):

    ##抢节日红包结果

    grabNum = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FeastRedPacketGrabMoney)

    newGrabNum = grabNum + moneyNum

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FeastRedPacketGrabMoney, newGrabNum)

    
    #广播

    needSysOSRAllMoneyList = IpyGameDataPY.GetFuncEvalCfg('FeastRedPacket', 3)

    lastIndex = -1

    newIndex = -1

    for i, num in enumerate(needSysOSRAllMoneyList):

        if grabNum >= num:

            lastIndex = i

        if newGrabNum >= num:

            newIndex = i

    if newIndex != -1 and newIndex > lastIndex:

        PlayerControl.WorldNotify(0, 'ActivityOpenRedBag1', [curPlayer.GetName(), newGrabNum])

        
    if not isSelf and getWay == ShareDefine.RedPackType_FeastSucc: #抢自己的红包不扣次数

        grabCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FeastRedPacketCanGrabCnt)

        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FeastRedPacketCanGrabCnt, max(0, grabCnt - 1))

        
    Sync_FeastRedPackInfo(curPlayer)

    return



def Sync_FeastRedPackInfo(curPlayer):

    #// AB 25 节日红包信息 #tagMCFeastRedPackInfo

    pack = ChPyNetSendPack.tagMCFeastRedPackInfo()

    pack.MoneyNum = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FeastRedPacketGrabMoney)

    pack.GrabCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FeastRedPacketCanGrabCnt)

    NetPackCommon.SendFakePack(curPlayer, pack)

    return




 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerSuccess.py

@@ -43,6 +43,7 @@
import Operate_EquipStone

import Operate_EquipWash

import Operate_EquipSuitCompose

import PlayerFeastRedPacket

import PlayerDogz

import QuestCommon

import DataRecordPack

@@ -440,6 +441,29 @@
        Sync_SuccessInfo(curPlayer, resetList, True)

    return



def DoResetSuccessIDList(curPlayer, resetSuccIDList):

    ## 重置成就相关数据

    if not resetSuccIDList:

        return

    resetList = []

    for succID in resetSuccIDList:

        succData = GetSuccDataMng().GetSuccessData(succID)

        if not succData:

            continue

        succType = succData.succType

        condition = succData.condition

        if not GetSuccFinishValue(curPlayer, succType, condition):

            continue

        SetSuccFinishValue(curPlayer, succType, condition, 0)

        SetSuccFinish(curPlayer, succID, False)

        SetSuccHasGot(curPlayer, succID, False)

        resetList.append(succID)

        GameWorld.DebugLog("    重置成就类型: succType=%s,succID=%s" % (succType, succID))

    if resetList:

        Sync_SuccTypeIndexAwardRecord(curPlayer, resetList, True)

        Sync_SuccessInfo(curPlayer, resetList, True)

    return



## 成就OnDay

#  @param curPlayer

#  @return

@@ -559,6 +583,9 @@
def UptateSuccessProgress(curPlayer, successType, newCnt, condition=[]):

    if successType not in ShareDefine.SuccessTypeList:

        return

    if successType in ShareDefine.FeastRedPackSuccessTypeList:

        if not PlayerFeastRedPacket.GetFeastRedPacketState():

            return

    succInfoList = GetSuccDataMng().GetSuccDataByType(successType)

    if not succInfoList:

        return

@@ -580,6 +607,11 @@
    succID = succDataObj.succID

    cond = succDataObj.condition

    

    if successType in ShareDefine.FeastRedPackSuccessTypeList:

        todayFeastSuccIDList = PlayerFeastRedPacket.GetTodayFeastSuccIDList()

        if not todayFeastSuccIDList or succID not in todayFeastSuccIDList:

            #GameWorld.DebugLog("    非今日节日红包成就，不增加进度! succID=%s,todayFeastSuccIDList=%s" % (succID, todayFeastSuccIDList))

            return

    isUnDownCheck = successType in ShareDefine.UnDownCheckSuccessTypeList

    isContain = successType in ShareDefine.ContainSuccessTypeList

    # 已完成的不再检查

@@ -650,7 +682,14 @@
def DoAddSuccessProgress(curPlayer, successType, addCnt, condition=[], delayCalc=True):

    #GameWorld.DebugLog("DoAddSuccessProgress type=%s,addCnt=%s,condition=%s" 

    #                   % (successType, addCnt, condition), curPlayer.GetPlayerID())



    if GameWorld.IsCrossServer():

        return

    
    if successType in ShareDefine.FeastRedPackSuccessTypeList:

        if not PlayerFeastRedPacket.GetFeastRedPacketState():

            #GameWorld.DebugLog("非节日红包活动时间，不增加成就！successType=%s" % successType)

            return

        
    playerID = curPlayer.GetID()

    if delayCalc and successType not in ShareDefine.NeedResetSuccessTypeList:

        if playerID not in PyGameData.g_delaySuccessDict:


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerTalk.py

@@ -105,7 +105,8 @@
    extras = GetTalkExtraValue(curPlayer)

    curPlayer.ChatGong(content, 0, extras)

    #世界频道发言成就

    PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_TalkWorld, 1)

    #PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_TalkWorld, 1)

    PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_TalkWorld, 1)

    return



## 国家频道(封包参数)


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/RemoteQuery/GY_Query_GrabFamilyRedPacketResult.py

@@ -17,8 +17,10 @@


import ChConfig

import PlayerControl

import IpyGameDataPY

import PlayerFamilyRedPacket

import PlayerFeastRedPacket

import ShareDefine

import GameWorld

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





@@ -44,12 +46,14 @@
#  @return None

#  @remarks 函数详细说明.

def DoResult(curPlayer, callFunName, funResult, tick):

    #GameWorld.DebugLog("GY_Query_GrabFamilyRedPacketResult funResult=%s" % funResult)

    moneyType, moneyNum, getWay, isSelf = eval(funResult)

    #GameWorld.DebugLog("GY_Query_GrabFamilyRedPacketResult moneyType=%s, moneyNum=%s, getWay=%s, isSelf=%s" % (moneyType, moneyNum, getWay, isSelf))

    if moneyNum:

        PlayerControl.GiveMoney(curPlayer, moneyType, moneyNum, ChConfig.Def_GiveMoney_RedPacket)

        if getWay == IpyGameDataPY.GetFuncCfg('OpenServerRedPacketType'):

        if getWay == ShareDefine.RedPackType_OpenServer:

            PlayerFamilyRedPacket.GrabOSRedPacketResult(curPlayer, moneyNum, isSelf)

        elif getWay in ShareDefine.FeastRedPackType:

            PlayerFeastRedPacket.GrabFeastRedPacketResult(curPlayer, moneyNum, getWay, isSelf)

            

    return