435 lines
10 KiB
Go
435 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"sort"
|
|
|
|
"mongo.games.com/goserver/core/logger"
|
|
"mongo.games.com/goserver/core/netlib"
|
|
|
|
"mongo.games.com/game/common"
|
|
"mongo.games.com/game/gamesrv/base"
|
|
"mongo.games.com/game/model"
|
|
"mongo.games.com/game/protocol/activity"
|
|
"mongo.games.com/game/srvdata"
|
|
)
|
|
|
|
const (
|
|
PowerMax = 700000
|
|
PowerInit = 400000
|
|
)
|
|
|
|
var PushCoinItemValue = map[int32]int64{
|
|
common.ItemIDBigCoin: 50000,
|
|
common.ItemIDVCard: 10000,
|
|
common.ItemIDPlum: 30000,
|
|
30011: 100000000, // 话费卡
|
|
common.ItemIDCoin1: 5000,
|
|
common.ItemIDCoin2: 10000,
|
|
common.ItemIDCoin3: 15000,
|
|
common.ItemIDDiamond: 100000,
|
|
}
|
|
|
|
func init() {
|
|
// 推币机活动信息
|
|
common.Register(int(activity.PushCoinPacketID_PACKET_CSPushCoinInfo), activity.CSPushCoinInfo{}, CSPushCoinInfo)
|
|
// 推币机玩家操作
|
|
common.Register(int(activity.PushCoinPacketID_PACKET_CSPushCoinPlayerOp), activity.CSPushCoinPlayerOp{}, CSPushCoinPlayerOp)
|
|
}
|
|
|
|
func CSPushCoinInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
_, ok := data.(*activity.CSPushCoinInfo)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
p := PlayerMgrSington.GetOnlinePlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSPushCoinInfo p == nil")
|
|
return nil
|
|
}
|
|
|
|
if p.WelfData == nil {
|
|
logger.Logger.Warn("CSPushCoinInfo p.WelfData == nil")
|
|
return nil
|
|
}
|
|
|
|
if p.WelfData.PushCoin == nil {
|
|
InitPlayerPushCoin(p)
|
|
}
|
|
|
|
pack := &activity.SCPushCoinInfo{
|
|
ShakeTimes: p.WelfData.PushCoin.Shake,
|
|
PowerLine: p.WelfData.PushCoin.Power,
|
|
PowerLineMax: PowerMax,
|
|
RefreshTimes: p.WelfData.PushCoin.Refresh,
|
|
}
|
|
|
|
for k, v := range p.WelfData.PushCoin.Items {
|
|
pack.Items = append(pack.Items, &activity.ItemInfo{
|
|
ItemId: k,
|
|
ItemNum: v,
|
|
})
|
|
}
|
|
|
|
for _, v := range srvdata.PBDB_PropExchangeMgr.Datas.Arr {
|
|
if v.GetGroup() == 2 {
|
|
info := &activity.ExchangeInfo{
|
|
Id: v.GetId(),
|
|
TotalTimes: int64(v.GetTimes()),
|
|
}
|
|
for kk, vv := range v.GetCost() {
|
|
info.Cost = append(info.Cost, &activity.ItemInfo{
|
|
ItemId: int32(kk),
|
|
ItemNum: vv,
|
|
})
|
|
}
|
|
sort.Slice(info.Cost, func(i, j int) bool {
|
|
return info.Cost[i].ItemId < info.Cost[j].ItemId
|
|
})
|
|
for kk, vv := range v.GetGain() {
|
|
info.Gain = append(info.Gain, &activity.ItemInfo{
|
|
ItemId: int32(kk),
|
|
ItemNum: vv,
|
|
})
|
|
}
|
|
sort.Slice(info.Gain, func(i, j int) bool {
|
|
return info.Gain[i].ItemId < info.Gain[j].ItemId
|
|
})
|
|
|
|
info.Times = int64(v.GetTimes() - p.WelfData.PushCoin.Exchange[v.Id])
|
|
if v.GetTimes() == 0 {
|
|
info.Times = -1
|
|
info.TotalTimes = -1
|
|
}
|
|
|
|
pack.ExchangeList = append(pack.ExchangeList, info)
|
|
}
|
|
}
|
|
|
|
// 转盘
|
|
for _, v := range srvdata.PBDB_ACTPushCoinMgr.Datas.Arr {
|
|
for kk, vv := range v.GetGain() {
|
|
pack.DrawList = append(pack.DrawList, &activity.DrawInfo{
|
|
Id: v.GetId(),
|
|
ItemId: int32(kk),
|
|
ItemNum: int32(vv),
|
|
Coin: v.GetValue(),
|
|
})
|
|
}
|
|
}
|
|
|
|
p.SendToClient(int(activity.PushCoinPacketID_PACKET_SCPushCoinInfo), pack)
|
|
logger.Logger.Trace("SCPushCoinInfo: ", pack)
|
|
return nil
|
|
}
|
|
|
|
func CSPushCoinPlayerOp(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSPushCoinPlayerOpHandler Process recv ", data)
|
|
msg, ok := data.(*activity.CSPushCoinPlayerOp)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
p := PlayerMgrSington.GetOnlinePlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSPushCoinPlayerOp p == nil")
|
|
return nil
|
|
}
|
|
|
|
if p.WelfData == nil {
|
|
logger.Logger.Warn("CSPushCoinPlayerOp p.WelfData == nil")
|
|
return nil
|
|
}
|
|
|
|
if p.WelfData.PushCoin == nil {
|
|
logger.Logger.Warn("CSPushCoinPlayerOp p.WelfData.PushCoin == nil")
|
|
return nil
|
|
}
|
|
|
|
pack := &activity.SCPushCoinPlayerOp{
|
|
OpRetCode: activity.OpResultPushCoinCode_OPRC_PushCoin_Error,
|
|
OpCode: msg.GetOpCode(),
|
|
}
|
|
|
|
switch msg.GetOpCode() {
|
|
case activity.OpCodes_OP_Bet:
|
|
if msg.GetOpParam() != common.ItemIDCoin1 && msg.GetOpParam() != common.ItemIDCoin2 && msg.GetOpParam() != common.ItemIDCoin3 {
|
|
goto here
|
|
}
|
|
|
|
item := srvdata.GameItemMgr.Get(p.Platform, int32(msg.GetOpParam()))
|
|
if item == nil {
|
|
goto here
|
|
}
|
|
|
|
if p.GetCoin() < item.GetNum() {
|
|
pack.OpRetCode = activity.OpResultPushCoinCode_OPRC_PushCoin_BetNotEnough
|
|
goto here
|
|
}
|
|
pack.BetId = int32(msg.GetOpParam())
|
|
|
|
p.AddCoin(-item.GetNum(), common.GainWayPushCoinCost, base.SyncFlag_ToClient, "system", "推币机下注")
|
|
// 增加桌面道具
|
|
PushCoinAddValue(p, map[int32]int64{
|
|
int32(msg.GetOpParam()): 1,
|
|
})
|
|
|
|
case activity.OpCodes_OP_Gain:
|
|
|
|
if msg.GetOpParam() == 1 {
|
|
// 有效区
|
|
for _, v := range msg.GetOpItem() {
|
|
id := v.GetItemId()
|
|
val := v.GetItemNum()
|
|
|
|
if p.WelfData.PushCoin.Items[id] < val {
|
|
logger.Logger.Errorf("获得道具太多: %d, %d", p.WelfData.PushCoin.Items[id], val)
|
|
// 刷新桌面余额
|
|
//UpdatePlayerPushCoin(p)
|
|
goto here
|
|
}
|
|
|
|
switch v.GetItemId() {
|
|
case common.ItemIDBigCoin, common.ItemIDCoin1, common.ItemIDCoin2, common.ItemIDCoin3:
|
|
val *= srvdata.GameItemMgr.Get(p.Platform, id).GetNum()
|
|
id = common.ItemIDCoin
|
|
}
|
|
|
|
BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: []*model.Item{{ItemId: id, ItemNum: val}},
|
|
GainWay: common.GainWayPushCoinGain,
|
|
Operator: "system",
|
|
Remark: "推币机掉落获得",
|
|
})
|
|
}
|
|
} else {
|
|
// 无效区
|
|
|
|
}
|
|
|
|
for _, v := range msg.GetOpItem() {
|
|
// 增加能量条
|
|
PushCoinAddPower(p, PushCoinItemValue[v.GetItemId()]*v.GetItemNum())
|
|
// 减少桌面道具
|
|
PushCoinAddValue(p, map[int32]int64{v.GetItemId(): -v.GetItemNum()})
|
|
}
|
|
|
|
case activity.OpCodes_OP_Shake:
|
|
if p.WelfData.PushCoin.Shake < int32(msg.GetOpParam()) {
|
|
pack.OpRetCode = activity.OpResultPushCoinCode_OPRC_PushCoin_ShakeNotEnough
|
|
goto here
|
|
}
|
|
p.WelfData.PushCoin.Shake -= int32(msg.GetOpParam())
|
|
|
|
case activity.OpCodes_OP_Refresh:
|
|
//if p.WelfData.PushCoin.Refresh <= 0 {
|
|
// InitPlayerPushCoin(p)
|
|
//} else {
|
|
// UpdatePlayerPushCoin(p)
|
|
//}
|
|
|
|
case activity.OpCodes_OP_Exchange:
|
|
d := srvdata.PBDB_PropExchangeMgr.GetData(int32(msg.GetOpParam()))
|
|
if d == nil {
|
|
goto here
|
|
}
|
|
// 兑换次数
|
|
if d.GetTimes() > 0 && p.WelfData.PushCoin.Exchange[d.Id] >= d.GetTimes() {
|
|
pack.OpRetCode = activity.OpResultPushCoinCode_OPRC_PushCoin_ExchangeNotEnough
|
|
goto here
|
|
}
|
|
|
|
pack.Exchange = &activity.ExchangeInfo{
|
|
Id: d.Id,
|
|
}
|
|
var cost, gain []*model.Item
|
|
for k, v := range d.GetCost() {
|
|
pack.Exchange.Cost = append(pack.Exchange.Cost, &activity.ItemInfo{
|
|
ItemId: int32(k),
|
|
ItemNum: v,
|
|
})
|
|
if k == common.ItemIDCoin && p.GetCoin() < v {
|
|
pack.OpRetCode = activity.OpResultPushCoinCode_OPRC_PushCoin_ItemNotEnough
|
|
goto here
|
|
}
|
|
cost = append(cost, &model.Item{
|
|
ItemId: int32(k),
|
|
ItemNum: -v,
|
|
})
|
|
}
|
|
|
|
_, _, ok := BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: cost,
|
|
Add: 0,
|
|
GainWay: common.GainWayPushCoinExchangeCost,
|
|
Operator: "system",
|
|
Remark: "推币机活动兑换消耗",
|
|
})
|
|
if !ok {
|
|
pack.OpRetCode = activity.OpResultPushCoinCode_OPRC_PushCoin_ItemNotEnough
|
|
goto here
|
|
}
|
|
|
|
for k, v := range d.GetGain() {
|
|
pack.Exchange.Gain = append(pack.Exchange.Gain, &activity.ItemInfo{
|
|
ItemId: int32(k),
|
|
ItemNum: v,
|
|
})
|
|
if k == common.ItemIDShake {
|
|
p.WelfData.PushCoin.Shake += int32(v)
|
|
continue
|
|
}
|
|
gain = append(gain, &model.Item{
|
|
ItemId: int32(k),
|
|
ItemNum: v,
|
|
})
|
|
}
|
|
BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: gain,
|
|
Cost: cost,
|
|
Add: 0,
|
|
GainWay: common.GainWatPushCoinExchangeGain,
|
|
Operator: "system",
|
|
Remark: "推币机活动兑换获得",
|
|
})
|
|
if p.WelfData.PushCoin.Exchange == nil {
|
|
p.WelfData.PushCoin.Exchange = make(map[int32]int32)
|
|
}
|
|
p.WelfData.PushCoin.Exchange[d.Id]++
|
|
|
|
default:
|
|
return nil
|
|
}
|
|
|
|
pack.OpRetCode = activity.OpResultPushCoinCode_OPRC_PushCoin_Success
|
|
|
|
here:
|
|
p.SendToClient(int(activity.PushCoinPacketID_PACKET_SCPushCoinPlayerOp), pack)
|
|
logger.Logger.Trace("SCPushCoinPlayerOp: ", pack)
|
|
|
|
return nil
|
|
}
|
|
|
|
func InitPlayerPushCoin(p *Player) {
|
|
// 初始化
|
|
p.WelfData.PushCoin = &model.PushCoinData{
|
|
Power: PowerInit,
|
|
Exchange: make(map[int32]int32),
|
|
Items: map[int32]int64{
|
|
common.ItemIDVCard: 1,
|
|
common.ItemIDCoin1: 50,
|
|
common.ItemIDPlum: 1,
|
|
},
|
|
}
|
|
}
|
|
|
|
// PushCoinAddPower 增加能量条
|
|
func PushCoinAddPower(p *Player, value int64) {
|
|
if value < 0 {
|
|
return
|
|
}
|
|
p.WelfData.PushCoin.Power += value
|
|
if p.WelfData.PushCoin.Power > PowerMax {
|
|
p.WelfData.PushCoin.Power = PowerMax
|
|
}
|
|
p.SendToClient(int(activity.PushCoinPacketID_PACKET_NotifyPowerLine), &activity.NotifyPowerLine{
|
|
PowerLine: p.WelfData.PushCoin.Power,
|
|
PowerLineMax: PowerMax,
|
|
})
|
|
if value <= 0 {
|
|
return
|
|
}
|
|
// 抽奖
|
|
PushCoinDraw(p)
|
|
}
|
|
|
|
// PushCoinDraw 抽奖
|
|
func PushCoinDraw(p *Player) {
|
|
if p.WelfData.PushCoin.Power < PowerMax {
|
|
return
|
|
}
|
|
p.WelfData.PushCoin.Power = 0
|
|
var index int32 = -1
|
|
switch p.WelfData.PushCoin.Dram {
|
|
case 0:
|
|
// 必中大金币
|
|
for _, v := range srvdata.PBDB_ACTPushCoinMgr.Datas.Arr {
|
|
for kk := range v.GetGain() {
|
|
if kk == common.ItemIDBigCoin {
|
|
index = v.GetId()
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
case 1:
|
|
// 必中v卡
|
|
for _, v := range srvdata.PBDB_ACTPushCoinMgr.Datas.Arr {
|
|
for kk := range v.GetGain() {
|
|
if kk == common.ItemIDVCard {
|
|
index = v.GetId()
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
default:
|
|
var n int32
|
|
rand := common.RandInt(10000)
|
|
for _, v := range srvdata.PBDB_ACTPushCoinMgr.Datas.Arr {
|
|
if rand < int(n+v.GetRate()) {
|
|
index = v.GetId()
|
|
break
|
|
}
|
|
n += v.GetRate()
|
|
}
|
|
}
|
|
p.WelfData.PushCoin.Dram++
|
|
|
|
if index >= 0 {
|
|
d := srvdata.PBDB_ACTPushCoinMgr.GetData(index)
|
|
if d != nil {
|
|
pack := &activity.DrawInfo{
|
|
Id: d.GetId(),
|
|
Coin: d.GetValue(),
|
|
}
|
|
for k, v := range d.GetGain() {
|
|
pack.ItemId = int32(k)
|
|
pack.ItemNum = int32(v)
|
|
PushCoinAddValue(p, map[int32]int64{pack.ItemId: int64(pack.ItemNum)})
|
|
}
|
|
if pack.Coin > 0 || pack.ItemId > 0 {
|
|
p.SendToClient(int(activity.PushCoinPacketID_PACKET_NotifyDrawInfo), pack)
|
|
// 增加能量条
|
|
PushCoinAddPower(p, 0)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// PushCoinAddValue 增加桌面道具
|
|
func PushCoinAddValue(p *Player, item map[int32]int64) {
|
|
if item == nil {
|
|
return
|
|
}
|
|
if p.WelfData != nil && p.WelfData.PushCoin != nil {
|
|
if p.WelfData.PushCoin.Items == nil {
|
|
p.WelfData.PushCoin.Items = make(map[int32]int64)
|
|
}
|
|
for k, v := range item {
|
|
if v > 0 {
|
|
switch k {
|
|
default:
|
|
p.WelfData.PushCoin.Items[k] += v
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|