1354 lines
38 KiB
Go
1354 lines
38 KiB
Go
package main
|
||
|
||
import (
|
||
"errors"
|
||
"fmt"
|
||
"time"
|
||
|
||
"mongo.games.com/goserver/core/basic"
|
||
"mongo.games.com/goserver/core/logger"
|
||
"mongo.games.com/goserver/core/netlib"
|
||
"mongo.games.com/goserver/core/task"
|
||
|
||
"mongo.games.com/game/common"
|
||
"mongo.games.com/game/model"
|
||
"mongo.games.com/game/proto"
|
||
webapiproto "mongo.games.com/game/protocol/webapi"
|
||
"mongo.games.com/game/protocol/welfare"
|
||
"mongo.games.com/game/srvdata"
|
||
"mongo.games.com/game/webapi"
|
||
)
|
||
|
||
// 救济金
|
||
type CSGetReliefFundPacketFactory struct {
|
||
}
|
||
|
||
type CSGetReliefFundHandler struct {
|
||
}
|
||
|
||
func (this *CSGetReliefFundPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSGetReliefFund{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSGetReliefFundHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSGetReliefFund Process recv ", data)
|
||
if msg, ok := data.(*welfare.CSGetReliefFund); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSGetReliefFundHandler p == nil")
|
||
return nil
|
||
}
|
||
WelfareMgrSington.GetReliefFund(p, msg.GetIsVideo())
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 转动转盘
|
||
type CSGetTurnplatePacketFactory struct {
|
||
}
|
||
|
||
type CSGetTurnplateHandler struct {
|
||
}
|
||
|
||
func (this *CSGetTurnplatePacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSGetTurnplate{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSGetTurnplateHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSGetTurnplate Process recv ", data)
|
||
if msg, ok := data.(*welfare.CSGetTurnplate); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSGetTurnplateHandler p == nil")
|
||
return nil
|
||
}
|
||
if msg.GetIsVideo() {
|
||
// 看视频可以再领一次
|
||
WelfareMgrSington.GetTurnplteVideo(p)
|
||
return nil
|
||
}
|
||
WelfareMgrSington.GetTurnplate(p)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 累计签到
|
||
type CSGetAddupSignPacketFactory struct {
|
||
}
|
||
|
||
type CSGetAddupSignHandler struct {
|
||
}
|
||
|
||
func (this *CSGetAddupSignPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSGetAddupSign{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSGetAddupSignHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSGetAddupSign Process recv ", data)
|
||
if msg, ok := data.(*welfare.CSGetAddupSign); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSGetAddupSignHandler p == nil")
|
||
return nil
|
||
}
|
||
|
||
WelfareMgrSington.GetAddupSign(p, msg.GetAddUpDay())
|
||
WelfareMgrSington.UpdateAddUp2Date(p, 0, msg.GetAddUpDay(), time.Now().Unix()+3600)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 福利信息
|
||
type CSWelfaredInfoPacketFactory struct {
|
||
}
|
||
|
||
type CSWelfaredInfoHandler struct {
|
||
}
|
||
|
||
func (this *CSWelfaredInfoPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSWelfaredInfo{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSWelfaredInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSWelfaredInfo Process recv ", data)
|
||
if _, ok := data.(*welfare.CSWelfaredInfo); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSWelfaredInfoHandler p == nil")
|
||
return nil
|
||
}
|
||
WelfareMgrSington.WelfaredInfo(p)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 查看盲盒
|
||
type CSBlindBoxInfoPacketFactory struct {
|
||
}
|
||
|
||
type CSBlindBoxInfoHandler struct {
|
||
}
|
||
|
||
func (this *CSBlindBoxInfoPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSBlindBoxInfo{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSBlindBoxInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSBlindBoxInfo Process recv ", data)
|
||
if msg, ok := data.(*welfare.CSBlindBoxInfo); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSBlindBoxInfoHandler p == nil")
|
||
return nil
|
||
}
|
||
WelfareMgrSington.BlindBoxInfo(p, msg.GetId())
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 购买盲盒
|
||
type CSBuyBlindBoxPacketFactory struct {
|
||
}
|
||
|
||
type CSBuyBlindBoxHandler struct {
|
||
}
|
||
|
||
func (this *CSBuyBlindBoxPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSGetBlindBox{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSBuyBlindBoxHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSGetBlindBox Process recv ", data)
|
||
if _, ok := data.(*welfare.CSGetBlindBox); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSBuyBlindBoxHandler p == nil")
|
||
return nil
|
||
}
|
||
//WelfareMgrSington.BuyBlindBox(p, msg.GetId(), msg.ConfigPayId)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 查看首充
|
||
type CSFirstPayInfoPacketFactory struct {
|
||
}
|
||
|
||
type CSFirstPayInfoHandler struct {
|
||
}
|
||
|
||
func (this *CSFirstPayInfoPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSWelfareFirstPayData{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSFirstPayInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSWelfareFirstPayData Process recv ", data)
|
||
if _, ok := data.(*welfare.CSWelfareFirstPayData); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSFirstPayInfoHandler p == nil")
|
||
return nil
|
||
}
|
||
WelfareMgrSington.FirstPayInfo(p)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 领取首充
|
||
type CSBuyFirstPayPacketFactory struct {
|
||
}
|
||
|
||
type CSBuyFirstPayHandler struct {
|
||
}
|
||
|
||
func (this *CSBuyFirstPayPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSWelfareFirstPay{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSBuyFirstPayHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSWelfareFirstPay Process recv ", data)
|
||
if _, ok := data.(*welfare.CSWelfareFirstPay); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSBuyFirstPayHandler p == nil")
|
||
return nil
|
||
}
|
||
//WelfareMgrSington.BuyFirstPay(p, msg.ConfigPayId)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 查看连续充值
|
||
type CSContinuousPayInfoPacketFactory struct {
|
||
}
|
||
|
||
type CSContinuousPayInfoHandler struct {
|
||
}
|
||
|
||
func (this *CSContinuousPayInfoPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSWelfareContinuousPayData{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSContinuousPayInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSWelfareContinuousPayData Process recv ", data)
|
||
if _, ok := data.(*welfare.CSWelfareContinuousPayData); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSContinuousPayInfoHandler p == nil")
|
||
return nil
|
||
}
|
||
WelfareMgrSington.ContinuousPayInfo(p)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 领取连续充值
|
||
type CSBuyContinuousPayPacketFactory struct {
|
||
}
|
||
|
||
type CSBuyContinuousPayHandler struct {
|
||
}
|
||
|
||
func (this *CSBuyContinuousPayPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSWelfareContinuousPay{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSBuyContinuousPayHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSWelfareContinuousPay Process recv ", data)
|
||
if _, ok := data.(*welfare.CSWelfareContinuousPay); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSBuyContinuousPayHandler p == nil")
|
||
return nil
|
||
}
|
||
//WelfareMgrSington.BuyContinuousPay(p, msg.ConfigPayId)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func CSWelfRelief(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Tracef("CSWelfRelief Process recv %v", data)
|
||
_, ok := data.(*welfare.CSWelfareRelief)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
return nil
|
||
}
|
||
|
||
conf := srvdata.PBDB_GameSubsidyMgr.GetData(GameSubsidyid)
|
||
|
||
ret := &welfare.SCWelfareRelief{
|
||
LimitNum: conf.GetLimitNum(),
|
||
Get: conf.GetGet(),
|
||
Times: conf.GetTimes(),
|
||
}
|
||
|
||
p.SendToClient(int(welfare.SPacketID_PACKET_SCWelfRelief), ret)
|
||
logger.Logger.Tracef("SCWelfRelief %v", ret)
|
||
return nil
|
||
}
|
||
|
||
func CSInviteInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Tracef("CSInviteInfo Process recv %v", data)
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
return nil
|
||
}
|
||
link := model.GameParamData.InviteUrl
|
||
f := func() string {
|
||
return fmt.Sprintf("%s?user=%s", link, p.ICode)
|
||
}
|
||
|
||
var res []byte
|
||
var err error
|
||
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
||
req := &webapiproto.ASPlayerInviteLink{
|
||
Platform: p.Platform,
|
||
SnId: p.SnId,
|
||
}
|
||
res, err = webapi.ApiGetInviteLink(common.GetAppId(), req)
|
||
return nil
|
||
}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
|
||
info := webapiproto.SAPlayerInviteLink{}
|
||
if err != nil || res == nil {
|
||
logger.Logger.Errorf("ApiGetInviteLink err %v or not return", err)
|
||
} else {
|
||
proto.Unmarshal(res, &info)
|
||
logger.Logger.Infof("ApiGetInviteLink info %v", info.String())
|
||
link = info.Link
|
||
}
|
||
|
||
ret := &welfare.SCInviteInfo{
|
||
Num: int32(p.INum),
|
||
Code: p.ICode,
|
||
InviteUrl: f(),
|
||
Score: p.IScore,
|
||
OtherCode: p.PCode,
|
||
}
|
||
|
||
cfg := PlatformMgrSingleton.GetConfig(p.Platform).ActInviteConfig
|
||
if cfg != nil {
|
||
ret.BindScore = cfg.GetBindScore()
|
||
ret.RechargeScore = cfg.GetRechargeScore()
|
||
ret.PayScore = cfg.GetPayScore()
|
||
for _, v := range cfg.GetAwards1() {
|
||
ret.Awards1 = append(ret.Awards1, &welfare.RankAward{
|
||
Start: v.GetStart(),
|
||
End: v.GetEnd(),
|
||
Num: v.GetNum(),
|
||
})
|
||
}
|
||
for _, v := range cfg.GetAwards2() {
|
||
ret.Awards2 = append(ret.Awards2, &welfare.RankAward{
|
||
Start: v.GetStart(),
|
||
End: v.GetEnd(),
|
||
Num: v.GetNum(),
|
||
})
|
||
}
|
||
for _, v := range cfg.GetAwards3() {
|
||
ret.Awards3 = append(ret.Awards3, &welfare.RankAward{
|
||
Start: v.GetStart(),
|
||
End: v.GetEnd(),
|
||
Num: v.GetNum(),
|
||
})
|
||
}
|
||
ret.Rates = cfg.GetRates()
|
||
}
|
||
|
||
p.SendToClient(int(welfare.SPacketID_PACKET_SCInviteInfo), ret)
|
||
logger.Logger.Tracef("SCInviteInfo %v", ret)
|
||
})).Start()
|
||
return nil
|
||
}
|
||
|
||
func CSBindInvite(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Tracef("CSBindInvite Process recv %v", data)
|
||
msg, ok := data.(*welfare.CSBindInvite)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
return nil
|
||
}
|
||
|
||
if !PlatformMgrSingleton.IsOn(p.Platform, common.ChannelSwitchInvite, p.LastChannel) {
|
||
return nil
|
||
}
|
||
|
||
ret := &welfare.SCBindInvite{
|
||
OpRetCode: welfare.OpResultCode_OPRC_Error,
|
||
}
|
||
|
||
var inviteSnId int32
|
||
var err error
|
||
now := time.Now()
|
||
cfg := PlatformMgrSingleton.GetConfig(p.Platform).ActInviteConfig
|
||
|
||
send := func() {
|
||
p.SendToClient(int(welfare.SPacketID_PACKET_SCBindInvite), ret)
|
||
logger.Logger.Tracef("SCBindInvite %v", ret)
|
||
|
||
if ret.OpRetCode == welfare.OpResultCode_OPRC_Sucess {
|
||
// 玩家自己的绑定任务
|
||
TaskSubjectSingleton.Touch(common.TaskTypeBindInviter, &TaskData{SnId: p.SnId, Num: 1})
|
||
}
|
||
}
|
||
|
||
if p.PSnId != 0 {
|
||
ret.OpRetCode = welfare.OpResultCode_OPRC_AlreadyBind
|
||
send()
|
||
return nil
|
||
}
|
||
|
||
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
||
inviteSnId, err = model.GetSnIdByCode(p.Platform, msg.GetCode())
|
||
return nil
|
||
}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
|
||
if err != nil || inviteSnId == 0 {
|
||
logger.Logger.Tracef("GetSnIdByCode not found %v %v", err, msg.GetCode())
|
||
ret.OpRetCode = welfare.OpResultCode_OPRC_NotExist
|
||
send()
|
||
return
|
||
}
|
||
|
||
// 3级父级不能是自己
|
||
var err error
|
||
tmpSnId := inviteSnId
|
||
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
||
// todo 优化查找顶级代理
|
||
for i := 0; i < 10000; i++ {
|
||
if tmpSnId == p.SnId {
|
||
ret.OpRetCode = welfare.OpResultCode_OPRC_BindSelf
|
||
err = errors.New("bind error")
|
||
return nil
|
||
}
|
||
tmpSnId, err = model.GetPlayerInviteSnid(p.Platform, tmpSnId)
|
||
if err != nil {
|
||
ret.OpRetCode = welfare.OpResultCode_OPRC_Error
|
||
return nil
|
||
}
|
||
if tmpSnId == 0 {
|
||
break
|
||
}
|
||
}
|
||
if err == nil {
|
||
err = model.BindInviteSnId(p.Platform, p.SnId, inviteSnId, msg.Code)
|
||
}
|
||
if err == nil {
|
||
SaveInviteScore(&model.InviteScore{
|
||
Platform: p.Platform,
|
||
SnId: p.SnId,
|
||
InviteSnId: inviteSnId,
|
||
Tp: common.InviteScoreTypeBind,
|
||
Score: cfg.GetBindScore(),
|
||
Ts: now.Unix(),
|
||
Money: 0,
|
||
})
|
||
}
|
||
return nil
|
||
}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
|
||
if err != nil {
|
||
send()
|
||
return
|
||
}
|
||
p.PSnId = inviteSnId
|
||
p.PCode = msg.GetCode()
|
||
ret.OpRetCode = welfare.OpResultCode_OPRC_Sucess
|
||
send()
|
||
})).StartByFixExecutor("invite_score")
|
||
})).Start()
|
||
return nil
|
||
}
|
||
|
||
// IsPermitReward 是否已经领取
|
||
func IsPermitReward(p *Player, id int32) bool {
|
||
channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
|
||
if channelConfig == nil {
|
||
return true
|
||
}
|
||
|
||
startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
|
||
endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
|
||
|
||
if p.WelfData != nil && p.WelfData.Task != nil {
|
||
ts := p.WelfData.PermitAward[id]
|
||
if ts == 0 {
|
||
return false
|
||
}
|
||
if ts >= startTs && ts < endTs {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// IsPermitCanReward 是否可以领取
|
||
func IsPermitCanReward(p *Player, id int32) bool {
|
||
if IsPermitReward(p, id) {
|
||
return false
|
||
}
|
||
|
||
channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
|
||
if channelConfig == nil {
|
||
return false
|
||
}
|
||
|
||
exp := int64(0)
|
||
item := BagMgrSingleton.GetItem(p.SnId, common.ItemIDPermit)
|
||
if item != nil {
|
||
exp = item.ItemNum
|
||
}
|
||
level := PlatformMgrSingleton.GetPermitLevel(p.Platform, p.LastChannel, exp)
|
||
|
||
for _, v := range channelConfig.GetLevelConfig() {
|
||
if v.GetRank() == id || v.GetRank()*1000 == id {
|
||
if v.GetRank() == id {
|
||
return level >= int64(v.GetRank())
|
||
} else {
|
||
return p.GetIsPermit() && level >= int64(v.GetRank())
|
||
}
|
||
}
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
// SendPermitReward 发赛季通行证奖励
|
||
// tp 1普通，2典藏
|
||
func SendPermitReward(p *Player, m map[int64]int64, tp int32) {
|
||
var items []*Item
|
||
for k, v := range m {
|
||
items = append(items, &Item{
|
||
ItemId: int32(k),
|
||
ItemNum: v,
|
||
})
|
||
}
|
||
gain := int32(0)
|
||
giveType := int32(-1)
|
||
switch tp {
|
||
case 1:
|
||
gain = common.GainWayPermitAward
|
||
giveType = model.SystemFreeGive_GiveType_PermitAward
|
||
case 2:
|
||
gain = common.GainWayPermitAward
|
||
giveType = model.SystemFreeGive_GiveType_PermitAward
|
||
}
|
||
BagMgrSingleton.AddItems(p, items, 0, gain, "system", "通行证奖励", 0, 0, false)
|
||
for _, v := range items {
|
||
tp1 := int32(-1)
|
||
if v.ItemId == common.ItemIDCoin {
|
||
tp1 = model.SystemFreeGive_CoinType_Coin
|
||
} else if v.ItemId == common.ItemIDDiamond {
|
||
tp1 = model.SystemFreeGive_CoinType_Diamond
|
||
}
|
||
if !p.IsRob && tp1 >= 0 && giveType >= 0 {
|
||
LogChannelSingleton.WriteMQData(
|
||
model.GenerateSystemFreeGive(p.SnId, p.Name, p.Platform, p.Channel, giveType, tp1, v.ItemNum))
|
||
}
|
||
}
|
||
}
|
||
|
||
func CSPermitInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Tracef("CSPermitInfo Process recv %v", data)
|
||
_, ok := data.(*welfare.CSPermitInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
return nil
|
||
}
|
||
if p.LastChannel == "" {
|
||
logger.Logger.Errorf("CSPermitInfo not channel %v", p.SnId)
|
||
return nil
|
||
}
|
||
|
||
channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
|
||
if channelConfig == nil {
|
||
logger.Logger.Errorf("CSPermitInfo not channelConfig %v", p.SnId)
|
||
return nil
|
||
}
|
||
startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
|
||
endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
|
||
if startTs == 0 || endTs == 0 {
|
||
logger.Logger.Errorf("CSPermitInfo not startTs %v", p.SnId)
|
||
return nil
|
||
}
|
||
// 赛季积分
|
||
exp := int64(0)
|
||
item := BagMgrSingleton.GetItem(p.SnId, common.ItemIDPermit)
|
||
if item != nil {
|
||
exp = item.ItemNum
|
||
}
|
||
// 等级
|
||
level := PlatformMgrSingleton.GetPermitLevel(p.Platform, p.LastChannel, exp)
|
||
|
||
pack := &welfare.SCPermitInfo{
|
||
Exp: exp,
|
||
Level: level,
|
||
Timestamp: []int64{startTs, endTs - 1},
|
||
IsPermit: p.GetIsPermit(),
|
||
RefreshTs: common.GetDayNextStartTs(time.Now().Unix()),
|
||
}
|
||
// 等级奖励
|
||
for _, v := range channelConfig.GetLevelConfig() {
|
||
var a1, a2 []*welfare.PropInfo
|
||
for _, vv := range v.GetAward1() {
|
||
a1 = append(a1, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
for _, vv := range v.GetAward2() {
|
||
a2 = append(a2, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
|
||
status1 := 0
|
||
if IsPermitReward(p, v.GetRank()) {
|
||
status1 = 2
|
||
} else {
|
||
if IsPermitCanReward(p, v.GetRank()) {
|
||
status1 = 1
|
||
}
|
||
}
|
||
|
||
status2 := 0
|
||
if IsPermitReward(p, v.GetRank()*1000) {
|
||
status2 = 2
|
||
} else {
|
||
if IsPermitCanReward(p, v.GetRank()*1000) {
|
||
status2 = 1
|
||
}
|
||
}
|
||
|
||
pack.Award = append(pack.Award, &welfare.PermitAward{
|
||
Exp: v.GetScore(),
|
||
Level: int64(v.GetRank()),
|
||
Award1: &welfare.PropItem{
|
||
Award: a1,
|
||
Status: int64(status1),
|
||
Id: v.GetRank(),
|
||
},
|
||
Award2: &welfare.PropItem{
|
||
Award: a2,
|
||
Status: int64(status2),
|
||
Id: v.GetRank() * 1000,
|
||
},
|
||
})
|
||
}
|
||
// 排行奖励
|
||
for _, v := range channelConfig.GetRankConfig() {
|
||
var items []*welfare.PropInfo
|
||
for _, vv := range v.GetItemId() {
|
||
items = append(items, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
pack.RankAward = append(pack.RankAward, &welfare.PermitRankAward{
|
||
Start: v.GetStart(),
|
||
End: v.GetEnd(),
|
||
ItemId: items,
|
||
})
|
||
}
|
||
// 客户端轮播配置
|
||
for _, v := range srvdata.PBDB_PassShowMgr.Datas.GetArr() {
|
||
pack.ShowList = append(pack.ShowList, &welfare.PermitShow{
|
||
ShowType: v.GetShowType(),
|
||
ShowVolume: v.GetShowVolume(),
|
||
Location: v.GetLocation(),
|
||
})
|
||
}
|
||
p.SendToClient(int(welfare.SPacketID_PACKET_SCPermitInfo), pack)
|
||
logger.Logger.Tracef("SCPermitInfo: %v", pack)
|
||
return nil
|
||
}
|
||
|
||
func CSPermitAward(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Tracef("CSPermitAward Process recv %v", data)
|
||
msg, ok := data.(*welfare.CSPermitAward)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
return nil
|
||
}
|
||
if p.LastChannel == "" {
|
||
logger.Logger.Errorf("CSPermitAward not channel %v", p.SnId)
|
||
return nil
|
||
}
|
||
|
||
if !PlatformMgrSingleton.IsOn(p.Platform, common.ChannelSwitchPermit, p.LastChannel) {
|
||
return nil
|
||
}
|
||
|
||
channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
|
||
if channelConfig == nil {
|
||
logger.Logger.Errorf("CSPermitAward not channelConfig %v", p.SnId)
|
||
return nil
|
||
}
|
||
startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
|
||
endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
|
||
now := time.Now()
|
||
if startTs == 0 || endTs == 0 || now.Unix() < startTs || now.Unix() >= endTs {
|
||
logger.Logger.Errorf("CSPermitAward not startTs %v", p.SnId)
|
||
return nil
|
||
}
|
||
|
||
pack := &welfare.SCPermitAward{
|
||
OpRetCode: welfare.OpResultCode_OPRC_Sucess,
|
||
Tp: msg.GetTp(),
|
||
Id: msg.GetId(),
|
||
}
|
||
|
||
switch msg.GetTp() {
|
||
case 0: // 所有
|
||
for _, v := range channelConfig.GetLevelConfig() {
|
||
if IsPermitCanReward(p, v.GetRank()) {
|
||
for _, vv := range v.GetAward1() {
|
||
pack.Award1 = append(pack.Award1, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
p.WelfData.PermitAward[v.GetRank()] = now.Unix()
|
||
}
|
||
if IsPermitCanReward(p, v.GetRank()*1000) {
|
||
for _, vv := range v.GetAward2() {
|
||
pack.Award2 = append(pack.Award2, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
p.WelfData.PermitAward[v.GetRank()*1000] = now.Unix()
|
||
}
|
||
}
|
||
|
||
case 1: // 普通
|
||
for _, v := range channelConfig.GetLevelConfig() {
|
||
if msg.GetId() == 0 {
|
||
if IsPermitCanReward(p, v.GetRank()) {
|
||
for _, vv := range v.GetAward1() {
|
||
pack.Award1 = append(pack.Award1, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
p.WelfData.PermitAward[v.GetRank()] = now.Unix()
|
||
}
|
||
} else {
|
||
if v.GetRank() == msg.GetId() {
|
||
if IsPermitCanReward(p, v.GetRank()) {
|
||
for _, vv := range v.GetAward1() {
|
||
pack.Award1 = append(pack.Award1, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
p.WelfData.PermitAward[v.GetRank()] = now.Unix()
|
||
} else {
|
||
pack.OpRetCode = welfare.OpResultCode_OPRC_NoTimes
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
case 2: // 典藏
|
||
for _, v := range channelConfig.GetLevelConfig() {
|
||
if msg.GetId() == 0 {
|
||
if IsPermitCanReward(p, v.GetRank()*1000) {
|
||
for _, vv := range v.GetAward2() {
|
||
pack.Award2 = append(pack.Award2, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
p.WelfData.PermitAward[v.GetRank()*1000] = now.Unix()
|
||
}
|
||
} else {
|
||
if v.GetRank()*1000 == msg.GetId() {
|
||
if IsPermitCanReward(p, msg.GetId()) {
|
||
for _, vv := range v.GetAward2() {
|
||
pack.Award2 = append(pack.Award2, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
p.WelfData.PermitAward[v.GetRank()*1000] = now.Unix()
|
||
} else {
|
||
pack.OpRetCode = welfare.OpResultCode_OPRC_NoTimes
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 奖励合并
|
||
var award1 = map[int32]*welfare.PropInfo{}
|
||
var award2 = map[int32]*welfare.PropInfo{}
|
||
var awards1 = map[int64]int64{}
|
||
var awards2 = map[int64]int64{}
|
||
for _, v := range pack.GetAward1() {
|
||
e, ok := award1[v.GetItemId()]
|
||
if !ok {
|
||
e = &welfare.PropInfo{
|
||
ItemId: v.GetItemId(),
|
||
ItemNum: v.GetItemNum(),
|
||
}
|
||
award1[v.GetItemId()] = e
|
||
} else {
|
||
e.ItemNum = e.GetItemNum() + v.GetItemNum()
|
||
}
|
||
awards1[int64(v.GetItemId())] = awards1[int64(v.GetItemId())] + v.GetItemNum()
|
||
}
|
||
for _, v := range pack.GetAward2() {
|
||
e, ok := award2[v.GetItemId()]
|
||
if !ok {
|
||
e = &welfare.PropInfo{
|
||
ItemId: v.GetItemId(),
|
||
ItemNum: v.GetItemNum(),
|
||
}
|
||
award2[v.GetItemId()] = e
|
||
} else {
|
||
e.ItemNum = e.GetItemNum() + v.GetItemNum()
|
||
}
|
||
awards2[int64(v.GetItemId())] = awards2[int64(v.GetItemId())] + v.GetItemNum()
|
||
}
|
||
// 发奖
|
||
SendPermitReward(p, awards1, 1)
|
||
SendPermitReward(p, awards2, 2)
|
||
pack.Award1 = nil
|
||
pack.Award2 = nil
|
||
for _, v := range award1 {
|
||
pack.Award1 = append(pack.Award1, &welfare.PropInfo{
|
||
ItemId: v.GetItemId(),
|
||
ItemNum: v.GetItemNum(),
|
||
})
|
||
}
|
||
for _, v := range award2 {
|
||
pack.Award2 = append(pack.Award2, &welfare.PropInfo{
|
||
ItemId: v.GetItemId(),
|
||
ItemNum: v.GetItemNum(),
|
||
})
|
||
}
|
||
p.SendToClient(int(welfare.SPacketID_PACKET_SCPermitAward), pack)
|
||
logger.Logger.Tracef("SCPermitAward: %v", pack)
|
||
return nil
|
||
}
|
||
|
||
// GetPermitExchangeNum 获取已兑换次数
|
||
func GetPermitExchangeNum(p *Player, id int32) int {
|
||
channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
|
||
if channelConfig == nil {
|
||
return 0
|
||
}
|
||
|
||
return len(p.WelfData.PermitExchange[id])
|
||
}
|
||
|
||
// GetPermitCanExchange 是否可以兑换
|
||
// 1等级不足 2需要典藏通行证 3兑换次数不足 4商品不存在
|
||
func GetPermitCanExchange(p *Player, id int32) (bool, int) {
|
||
channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
|
||
if channelConfig == nil {
|
||
return false, 0
|
||
}
|
||
|
||
times := GetPermitExchangeNum(p, id)
|
||
exp := int64(0)
|
||
item := BagMgrSingleton.GetItem(p.SnId, common.ItemIDPermit)
|
||
if item != nil {
|
||
exp = item.ItemNum
|
||
}
|
||
level := PlatformMgrSingleton.GetPermitLevel(p.Platform, p.LastChannel, exp)
|
||
|
||
for _, v := range channelConfig.GetExchangeConfig() {
|
||
if v.GetId() == id {
|
||
if !v.GetIsShow() {
|
||
return false, 3
|
||
}
|
||
// 等级
|
||
if level < v.GetLevel() {
|
||
return false, 1
|
||
}
|
||
// 通行证
|
||
if v.GetIsPermit() && !p.GetIsPermit() {
|
||
return false, 2
|
||
}
|
||
// 剩余兑换次数
|
||
if v.GetTimes() > 0 && int64(times) >= v.GetTimes() {
|
||
return false, 3
|
||
}
|
||
return true, 0
|
||
}
|
||
}
|
||
|
||
return false, 4
|
||
}
|
||
|
||
func CSPermitExchangeList(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Tracef("CSPermitExchangeList Process recv %v", data)
|
||
_, ok := data.(*welfare.CSPermitExchangeList)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
return nil
|
||
}
|
||
if p.LastChannel == "" {
|
||
logger.Logger.Errorf("CSPermitExchangeList not channel %v", p.SnId)
|
||
return nil
|
||
}
|
||
|
||
channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
|
||
if channelConfig == nil {
|
||
logger.Logger.Errorf("CSPermitExchangeList not channelConfig %v", p.SnId)
|
||
return nil
|
||
}
|
||
startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
|
||
endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
|
||
if startTs == 0 || endTs == 0 {
|
||
logger.Logger.Errorf("CSPermitExchangeList not startTs %v", p.SnId)
|
||
return nil
|
||
}
|
||
|
||
pack := &welfare.SCPermitExchangeList{}
|
||
|
||
for _, v := range channelConfig.GetExchangeConfig() {
|
||
if !v.GetIsShow() {
|
||
continue
|
||
}
|
||
var gain, cost []*welfare.PropInfo
|
||
for _, vv := range v.GetGain() {
|
||
gain = append(gain, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
for _, vv := range v.GetCost() {
|
||
cost = append(cost, &welfare.PropInfo{
|
||
ItemId: vv.GetItemId(),
|
||
ItemNum: vv.GetItemNum(),
|
||
})
|
||
}
|
||
|
||
times := int32(v.GetTimes()) - int32(GetPermitExchangeNum(p, v.GetId()))
|
||
|
||
exchangeTimes := v.GetTimes()
|
||
if exchangeTimes == 0 {
|
||
exchangeTimes = -1
|
||
}
|
||
pack.List = append(pack.List, &welfare.ShopInfo{
|
||
Id: v.GetId(),
|
||
Gain: gain,
|
||
Cost: cost,
|
||
ExchangeTimes: int32(exchangeTimes),
|
||
RemainTimes: times,
|
||
Level: v.GetLevel(),
|
||
NeedPermit: v.GetIsPermit(),
|
||
SortId: v.GetSortId(),
|
||
})
|
||
}
|
||
p.SendToClient(int(welfare.SPacketID_PACKET_SCPermitExchangeList), pack)
|
||
logger.Logger.Tracef("SCPermitExchangeList: %v", pack)
|
||
return nil
|
||
}
|
||
|
||
func CSPermitExchange(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Tracef("CSPermitExchange Process recv %v", data)
|
||
msg, ok := data.(*welfare.CSPermitExchange)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
return nil
|
||
}
|
||
if p.LastChannel == "" {
|
||
logger.Logger.Errorf("CSPermitExchange not channel %v", p.SnId)
|
||
return nil
|
||
}
|
||
if !PlatformMgrSingleton.IsOn(p.Platform, common.ChannelSwitchPermit, p.LastChannel) {
|
||
return nil
|
||
}
|
||
channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
|
||
if channelConfig == nil {
|
||
logger.Logger.Errorf("CSPermitExchange not channelConfig %v", p.SnId)
|
||
return nil
|
||
}
|
||
startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
|
||
endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
|
||
now := time.Now()
|
||
if startTs == 0 || endTs == 0 || now.Unix() < startTs || now.Unix() >= endTs {
|
||
logger.Logger.Errorf("CSPermitExchange not startTs %v", p.SnId)
|
||
return nil
|
||
}
|
||
|
||
isExchange, code := GetPermitCanExchange(p, msg.GetId())
|
||
pack := &welfare.SCPermitExchange{
|
||
OpRetCode: welfare.OpResultCode_OPRC_Sucess,
|
||
}
|
||
send := func(d welfare.OpResultCode) {
|
||
// 1等级不足 2需要典藏通行证 3兑换次数不足 4商品不存在
|
||
switch code {
|
||
case 1:
|
||
pack.OpRetCode = welfare.OpResultCode_OPRC_ExchangeLevelLimit
|
||
case 2:
|
||
pack.OpRetCode = welfare.OpResultCode_OPRC_NeedPermit
|
||
case 3:
|
||
pack.OpRetCode = welfare.OpResultCode_OPRC_ExchangeLimit
|
||
case 4:
|
||
pack.OpRetCode = welfare.OpResultCode_OPRC_NotFound
|
||
}
|
||
if code == 0 {
|
||
pack.OpRetCode = d
|
||
}
|
||
p.SendToClient(int(welfare.SPacketID_PACKET_SCPermitExchange), pack)
|
||
logger.Logger.Tracef("SCPermitExchange: %v", pack)
|
||
}
|
||
|
||
if isExchange {
|
||
var exchangeConfig *webapiproto.PermitExchangeConfig
|
||
for _, v := range channelConfig.GetExchangeConfig() {
|
||
if v.GetId() == msg.GetId() {
|
||
exchangeConfig = v
|
||
break
|
||
}
|
||
}
|
||
if exchangeConfig != nil {
|
||
// 检查背包是否足够
|
||
var items []*model.Item
|
||
var costItems []*Item
|
||
var cost, gain []model.AwardItem
|
||
var cost1 []*model.Item
|
||
for _, v := range exchangeConfig.GetCost() {
|
||
item := BagMgrSingleton.GetItem(p.SnId, v.GetItemId())
|
||
if item == nil || item.ItemNum < v.GetItemNum() {
|
||
send(welfare.OpResultCode_OPRC_ErrCost)
|
||
return nil
|
||
}
|
||
info := srvdata.GameItemMgr.Get(p.Platform, v.GetItemId())
|
||
if info != nil {
|
||
costItems = append(costItems, &Item{
|
||
ItemId: v.GetItemId(),
|
||
ItemNum: v.GetItemNum(),
|
||
Name: info.Name,
|
||
})
|
||
cost = append(cost, model.AwardItem{
|
||
Id: v.GetItemId(),
|
||
Num: v.GetItemNum(),
|
||
})
|
||
cost1 = append(cost1, &model.Item{
|
||
ItemId: v.GetItemId(),
|
||
ItemNum: v.GetItemNum(),
|
||
})
|
||
}
|
||
}
|
||
for _, v := range exchangeConfig.GetGain() {
|
||
info := srvdata.GameItemMgr.Get(p.Platform, v.GetItemId())
|
||
if info != nil {
|
||
items = append(items, &model.Item{
|
||
ItemId: v.GetItemId(),
|
||
ItemNum: v.GetItemNum(),
|
||
})
|
||
gain = append(gain, model.AwardItem{
|
||
Id: v.GetItemId(),
|
||
Num: v.GetItemNum(),
|
||
})
|
||
}
|
||
}
|
||
// 扣除背包物品
|
||
for _, item := range costItems {
|
||
BagMgrSingleton.AddItem(p, int64(item.ItemId), -item.ItemNum, 0,
|
||
common.GainWayPermitExchangeCost, "system", "赛季通行证兑换消耗", 0, 0, false)
|
||
}
|
||
// 增加背包物品
|
||
BagMgrSingleton.AddItemsV2(&model.AddItemParam{
|
||
P: p.PlayerData,
|
||
Change: items,
|
||
Cost: cost1,
|
||
Add: 0,
|
||
GainWay: common.GainWayPermitExchangeGain,
|
||
Operator: "system",
|
||
Remark: "赛季通行证兑换获得",
|
||
GameId: 0,
|
||
GameFreeId: 0,
|
||
NoLog: false,
|
||
})
|
||
p.WelfData.PermitExchange[msg.GetId()] = append(p.WelfData.PermitExchange[msg.GetId()], now.Unix())
|
||
// 兑换记录
|
||
LogChannelSingleton.WriteLog(&model.BackendPermitExchange{
|
||
Platform: p.Platform,
|
||
StartTs: startTs,
|
||
SnId: p.SnId,
|
||
Id: exchangeConfig.Id,
|
||
Cost: cost,
|
||
Gain: gain,
|
||
Ts: now.Unix(),
|
||
})
|
||
}
|
||
}
|
||
|
||
send(welfare.OpResultCode_OPRC_Sucess)
|
||
return nil
|
||
}
|
||
|
||
func CSPermitShop(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Tracef("CSPermitShop Process recv %v", data)
|
||
_, ok := data.(*welfare.CSPermitShop)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
return nil
|
||
}
|
||
if p.LastChannel == "" {
|
||
logger.Logger.Errorf("CSPermitShop not channel %v", p.SnId)
|
||
return nil
|
||
}
|
||
channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
|
||
if channelConfig == nil {
|
||
logger.Logger.Errorf("CSPermitShop not channelConfig %v", p.SnId)
|
||
return nil
|
||
}
|
||
startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
|
||
endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
|
||
if startTs == 0 || endTs == 0 {
|
||
logger.Logger.Errorf("CSPermitShop not startTs %v", p.SnId)
|
||
return nil
|
||
}
|
||
|
||
shopInfo := ShopMgrSington.GetShopInfo(common.ShopIdPermit, p)
|
||
if shopInfo == nil {
|
||
logger.Logger.Errorf("CSPermitShop is null %v", p.SnId)
|
||
return nil
|
||
}
|
||
price := int64(0)
|
||
if len(shopInfo.CostArea) > 0 {
|
||
price = int64(shopInfo.CostArea[0])
|
||
}
|
||
|
||
pack := &welfare.SCPermitShop{
|
||
Id: shopInfo.Id,
|
||
Name: shopInfo.Name,
|
||
Consume: shopInfo.ConstType,
|
||
Price: price,
|
||
}
|
||
p.SendToClient(int(welfare.SPacketID_PACKET_SCPermitShop), pack)
|
||
logger.Logger.Tracef("SCPermitShop: %v", pack)
|
||
return nil
|
||
}
|
||
|
||
// ------------------------------------------------
|
||
type CSPigBankGetInfoPacketFactory struct {
|
||
}
|
||
|
||
type CSPigBankGetInfoHandler struct {
|
||
}
|
||
|
||
func (this *CSPigBankGetInfoPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSPigbankGetInfo{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSPigBankGetInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSPigbankGetInfo Process recv ", data)
|
||
if _, ok := data.(*welfare.CSPigbankGetInfo); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSPigBankGetInfoHandler p == nil")
|
||
return nil
|
||
}
|
||
WelfareMgrSington.PigbankGetInfo(p)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// ------------------------------------------------
|
||
type CSPigBankTakeCoinPacketFactory struct {
|
||
}
|
||
|
||
type CSPigBankTakeCoinHandler struct {
|
||
}
|
||
|
||
func (this *CSPigBankTakeCoinPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSPigbankTakeCoin{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSPigBankTakeCoinHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSPigbankTakeCoin Process recv ", data)
|
||
if _, ok := data.(*welfare.CSPigbankTakeCoin); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSPigBankTakeCoinHandler p == nil")
|
||
return nil
|
||
}
|
||
WelfareMgrSington.PigbankTakeCoin(p)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// GetAddUp2Award
|
||
type CSSignDayAddup2AwardPacketFactory struct {
|
||
}
|
||
|
||
type CSSignDayAddup2AwardHandler struct {
|
||
}
|
||
|
||
func (this *CSSignDayAddup2AwardPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSSignDayAddup2Award{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSSignDayAddup2AwardHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSSignDayAddup2Award Process recv ", data)
|
||
if msg, ok := data.(*welfare.CSSignDayAddup2Award); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSPigBankTakeCoinHandler p == nil")
|
||
return nil
|
||
}
|
||
WelfareMgrSington.GetAddUp2Award(p, msg.Day)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type CSDiamondBankGetInfoPacketFactory struct {
|
||
}
|
||
|
||
type CSDiamondBankGetInfoHandler struct {
|
||
}
|
||
|
||
func (this *CSDiamondBankGetInfoPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSDiamondBankGetInfo{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSDiamondBankGetInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSDiamondBankGetInfo Process recv ", data)
|
||
if _, ok := data.(*welfare.CSDiamondBankGetInfo); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSPigBankTakeCoinHandler p == nil")
|
||
return nil
|
||
}
|
||
WelfareMgrSington.DiamondBankGetInfo(p)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
/*// 钻石储存罐
|
||
type CSDiamondBankTakeDiamondPacketFactory struct {
|
||
}
|
||
|
||
type CSDiamondBankTakeDiamondHandler struct {
|
||
}
|
||
|
||
func (this *CSDiamondBankTakeDiamondPacketFactory) CreatePacket() interface{} {
|
||
pack := &welfare.CSDiamondBankTakeDiamond{}
|
||
return pack
|
||
}
|
||
|
||
func (this *CSDiamondBankTakeDiamondHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
||
logger.Logger.Trace("CSDiamondBankGetInfo Process recv ", data)
|
||
if _, ok := data.(*welfare.CSDiamondBankTakeDiamond); ok {
|
||
p := PlayerMgrSington.GetPlayer(sid)
|
||
if p == nil {
|
||
logger.Logger.Warnf("CSPigBankTakeCoinHandler p == nil")
|
||
return nil
|
||
}
|
||
WelfareMgrSington.DiamondBankTakeCoin(p)
|
||
}
|
||
return nil
|
||
}*/
|
||
|
||
func init() {
|
||
// 领取救济金
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_GETRELIEFFUND), &CSGetReliefFundHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_GETRELIEFFUND), &CSGetReliefFundPacketFactory{})
|
||
//转动转盘
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_GETTURNPLATE), &CSGetTurnplateHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_GETTURNPLATE), &CSGetTurnplatePacketFactory{})
|
||
//累计签到
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_GETADDUPSIGN), &CSGetAddupSignHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_GETADDUPSIGN), &CSGetAddupSignPacketFactory{})
|
||
//福利信息
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_WELFAREINFO), &CSWelfaredInfoHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_WELFAREINFO), &CSWelfaredInfoPacketFactory{})
|
||
//查看盲盒
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_BLINBOXINFO), &CSBlindBoxInfoHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_BLINBOXINFO), &CSBlindBoxInfoPacketFactory{})
|
||
//购买盲盒
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_GETBLINBOX), &CSBuyBlindBoxHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_GETBLINBOX), &CSBuyBlindBoxPacketFactory{})
|
||
//查看首充
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_FIRSTPAYINFO), &CSFirstPayInfoHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_FIRSTPAYINFO), &CSFirstPayInfoPacketFactory{})
|
||
//领取首充
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_FIRSTPAY), &CSBuyFirstPayHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_FIRSTPAY), &CSBuyFirstPayPacketFactory{})
|
||
//查看连续充值
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_CONTINPAYINFO), &CSContinuousPayInfoHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_CONTINPAYINFO), &CSContinuousPayInfoPacketFactory{})
|
||
//领取连续充值
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_CONTINPAY), &CSBuyContinuousPayHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_CONTINPAY), &CSBuyContinuousPayPacketFactory{})
|
||
// 破产补助信息
|
||
common.Register(int(welfare.SPacketID_PACKET_CSWelfRelief), welfare.CSWelfareRelief{}, CSWelfRelief)
|
||
// 邀请信息
|
||
common.Register(int(welfare.SPacketID_PACKET_CSInviteInfo), welfare.CSInviteInfo{}, CSInviteInfo)
|
||
// 绑定信息
|
||
common.Register(int(welfare.SPacketID_PACKET_CSBindInvite), welfare.CSBindInvite{}, CSBindInvite)
|
||
|
||
//获取存钱罐数据
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CSPigbankGetInfo), &CSPigBankGetInfoHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CSPigbankGetInfo), &CSPigBankGetInfoPacketFactory{})
|
||
//领取存钱罐金币
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CSPigbankTakeCoin), &CSPigBankTakeCoinHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CSPigbankTakeCoin), &CSPigBankTakeCoinPacketFactory{})
|
||
//领取七日签到进阶奖励
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_SignDay_Addup2Award), &CSSignDayAddup2AwardHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_SignDay_Addup2Award), &CSSignDayAddup2AwardPacketFactory{})
|
||
//钻石储存罐信息
|
||
common.RegisterHandler(int(welfare.SPacketID_PACKET_CSDiamondBankGetInfo), &CSDiamondBankGetInfoHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CSDiamondBankGetInfo), &CSDiamondBankGetInfoPacketFactory{})
|
||
|
||
//领取钻石储存罐
|
||
/* common.RegisterHandler(int(welfare.SPacketID_PACKET_CSDiamondBankTakeDiamond), &CSDiamondBankTakeDiamondHandler{})
|
||
netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CSDiamondBankTakeDiamond), &CSDiamondBankTakeDiamondPacketFactory{})*/
|
||
|
||
// 赛季通行证信息
|
||
common.Register(int(welfare.SPacketID_PACKET_CSPermitInfo), welfare.CSPermitInfo{}, CSPermitInfo)
|
||
// 赛季通行证奖励领取
|
||
common.Register(int(welfare.SPacketID_PACKET_CSPermitAward), welfare.CSPermitAward{}, CSPermitAward)
|
||
// 赛季通行证兑换列表
|
||
common.Register(int(welfare.SPacketID_PACKET_CSPermitExchangeList), welfare.CSPermitExchangeList{}, CSPermitExchangeList)
|
||
// 赛季通行证兑换
|
||
common.Register(int(welfare.SPacketID_PACKET_CSPermitExchange), welfare.CSPermitExchange{}, CSPermitExchange)
|
||
// 赛季典藏通行证商品信息
|
||
common.Register(int(welfare.SPacketID_PACKET_CSPermitShop), welfare.CSPermitShop{}, CSPermitShop)
|
||
}
|