497 lines
14 KiB
Go
497 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"fmt"
|
|
|
|
"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/protocol/welfare"
|
|
"mongo.games.com/game/srvdata"
|
|
)
|
|
|
|
// 救济金
|
|
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 p.SnId = %v", p.SnId)
|
|
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 p.SnId = %v", p.SnId)
|
|
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())
|
|
}
|
|
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 p.SnId = %v", p.SnId)
|
|
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 p.SnId = %v", p.SnId)
|
|
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 p.SnId = %v", p.SnId)
|
|
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 p.SnId = %v", p.SnId)
|
|
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 p.SnId = %v", p.SnId)
|
|
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 p.SnId = %v", p.SnId)
|
|
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 p.SnId = %v", p.SnId)
|
|
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
|
|
}
|
|
|
|
ul := fmt.Sprintf("%s?user=%s", model.GameParamData.InviteUrl, base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s|%d", p.Platform, p.SnId))))
|
|
|
|
ret := &welfare.SCInviteInfo{
|
|
Num: p.InviteNum,
|
|
Code: p.InviteCode,
|
|
InviteUrl: ul,
|
|
Score: p.InviteScore,
|
|
OtherCode: p.OtherCode,
|
|
}
|
|
|
|
p.SendToClient(int(welfare.SPacketID_PACKET_SCInviteInfo), ret)
|
|
logger.Logger.Tracef("SCInviteInfo %v", ret)
|
|
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
|
|
}
|
|
ret := &welfare.SCBindInvite{
|
|
OpRetCode: welfare.OpResultCode_OPRC_Error,
|
|
}
|
|
|
|
var inviteSnId int32
|
|
var err error
|
|
|
|
send := func() {
|
|
p.SendToClient(int(welfare.SPacketID_PACKET_SCBindInvite), ret)
|
|
logger.Logger.Tracef("SCBindInvite %v", ret)
|
|
|
|
if ret.OpRetCode == welfare.OpResultCode_OPRC_Sucess {
|
|
// 更新绑定关系
|
|
LogChannelSingleton.WriteLog(&model.BindInvite{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
InviteSnId: inviteSnId,
|
|
})
|
|
|
|
TaskSubjectSingleton.Touch(common.TaskTypeBindInviter, &TaskData{SnId: p.SnId, Num: 1})
|
|
p.InviteTask(common.InviteScoreTypeLogin, 0, 1)
|
|
}
|
|
}
|
|
|
|
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.Errorf("GetSnIdByCode err %v %v", err, inviteSnId)
|
|
ret.OpRetCode = welfare.OpResultCode_OPRC_NotExist
|
|
send()
|
|
return
|
|
}
|
|
|
|
if p.InviteSnId != 0 {
|
|
ret.OpRetCode = welfare.OpResultCode_OPRC_AlreadyBind
|
|
send()
|
|
return
|
|
}
|
|
if inviteSnId == p.SnId {
|
|
ret.OpRetCode = welfare.OpResultCode_OPRC_BindSelf
|
|
send()
|
|
return
|
|
}
|
|
pp := PlayerMgrSington.GetPlayerBySnId(inviteSnId)
|
|
if pp != nil {
|
|
if pp.Platform != p.Platform {
|
|
send()
|
|
return
|
|
}
|
|
if pp.InviteSnId == p.SnId {
|
|
ret.OpRetCode = welfare.OpResultCode_OPRC_MyInvite
|
|
send()
|
|
return
|
|
}
|
|
p.InviteSnId = pp.SnId
|
|
p.OtherCode = pp.InviteCode
|
|
ret.OpRetCode = welfare.OpResultCode_OPRC_Sucess
|
|
send()
|
|
return
|
|
}
|
|
|
|
inviteSnId2 := int32(0)
|
|
var err error
|
|
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
|
inviteSnId2, err = model.GetPlayerInviteSnid(p.Platform, inviteSnId)
|
|
return nil
|
|
}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
|
|
if err != nil {
|
|
send()
|
|
return
|
|
}
|
|
if inviteSnId2 == p.SnId {
|
|
ret.OpRetCode = welfare.OpResultCode_OPRC_MyInvite
|
|
send()
|
|
return
|
|
}
|
|
p.InviteSnId = inviteSnId
|
|
p.OtherCode = msg.GetCode()
|
|
ret.OpRetCode = welfare.OpResultCode_OPRC_Sucess
|
|
send()
|
|
})).Start()
|
|
})).Start()
|
|
return nil
|
|
}
|
|
|
|
// ------------------------------------------------
|
|
type CSPigBankGetInfoPacketFactory struct {
|
|
}
|
|
|
|
type CSPigBankGetInfoHandler struct {
|
|
}
|
|
|
|
func (this *CSPigBankGetInfoPacketFactory) CreatePacket() interface{} {
|
|
|
|
return nil
|
|
}
|
|
|
|
func (this *CSPigBankGetInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
|
|
return nil
|
|
}
|
|
|
|
// ------------------------------------------------
|
|
type CSPigBankTakeCoinPacketFactory struct {
|
|
}
|
|
|
|
type CSPigBankTakeCoinHandler struct {
|
|
}
|
|
|
|
func (this *CSPigBankTakeCoinPacketFactory) CreatePacket() interface{} {
|
|
|
|
return nil
|
|
}
|
|
|
|
func (this *CSPigBankTakeCoinHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
|
|
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{})
|
|
}
|