812 lines
20 KiB
Go
812 lines
20 KiB
Go
package main
|
||
|
||
import (
|
||
"slices"
|
||
"sort"
|
||
"time"
|
||
|
||
"mongo.games.com/goserver/core/logger"
|
||
"mongo.games.com/goserver/core/netlib"
|
||
|
||
"mongo.games.com/game/common"
|
||
"mongo.games.com/game/model"
|
||
"mongo.games.com/game/protocol/activity"
|
||
"mongo.games.com/game/protocol/webapi"
|
||
"mongo.games.com/game/srvdata"
|
||
)
|
||
|
||
const (
|
||
PowerMax = 134000
|
||
PowerInit = 400000
|
||
)
|
||
|
||
var PushCoinItemValue = map[int32]int64{
|
||
common.ItemIDBigCoin: 50000,
|
||
common.ItemIDVCard: 10000,
|
||
common.ItemIDPlum: 30000,
|
||
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 || len(p.WelfData.PushCoin.Turn) == 0 {
|
||
InitPlayerPushCoin(p)
|
||
}
|
||
if p.WelfData.PushCoin.Turn[2] > 3 || p.WelfData.PushCoin.Turn[4] > 3 || p.WelfData.PushCoin.Turn[6] > 6 {
|
||
InitPlayerPushCoin(p)
|
||
}
|
||
|
||
pack := &activity.SCPushCoinInfo{
|
||
PowerLine: p.WelfData.PushCoin.Power,
|
||
PowerLineMax: PowerMax,
|
||
}
|
||
|
||
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)
|
||
}
|
||
}
|
||
|
||
pack.DrawList = make([]*activity.DrawInfo, len(p.WelfData.PushCoin.Turn))
|
||
|
||
for k, v := range p.WelfData.PushCoin.Turn {
|
||
info := &activity.DrawInfo{
|
||
Id: int32(k),
|
||
}
|
||
|
||
// 默认奖励
|
||
if slices.Contains(NormaIndex, k) {
|
||
d := srvdata.PBDB_ACTPushCoinMgr.GetData(v)
|
||
if d != nil {
|
||
for kk, vv := range d.GetGain() {
|
||
info.ItemId = int32(kk)
|
||
info.ItemNum = vv
|
||
break
|
||
}
|
||
pack.DrawList[k] = info
|
||
}
|
||
continue
|
||
}
|
||
// 奖池
|
||
if slices.Contains(PoolIndex, k) {
|
||
ii := slices.Index(PoolIndex, k)
|
||
if v == -1 {
|
||
// 从奖池中随机
|
||
var element *webapi.PushCoinPoolElement
|
||
var index int32
|
||
cfg := WelfareMgrSington.GetConfig(p.Platform).PushCoinConfig
|
||
if ii == 0 {
|
||
element, index = PushCoinPoolRandom(cfg.GetPool1().GetPool())
|
||
} else if ii == 1 {
|
||
element, index = PushCoinPoolRandom(cfg.GetPool2().GetPool())
|
||
} else if ii == 2 {
|
||
element, index = PushCoinPoolRandom(cfg.GetPool3().GetPool())
|
||
}
|
||
if index >= 0 && element != nil {
|
||
p.WelfData.PushCoin.Turn[k] = index
|
||
for _, v := range element.GetAward() {
|
||
info.ItemId = v.GetItemId()
|
||
info.ItemNum = v.GetItemNum()
|
||
break
|
||
}
|
||
pack.DrawList[k] = info
|
||
}
|
||
} else {
|
||
// 随机过了
|
||
f := func(index int, pool []*webapi.PushCoinPoolElement) {
|
||
if index < len(pool) {
|
||
for _, v := range pool[index].GetAward() {
|
||
info.ItemId = v.GetItemId()
|
||
info.ItemNum = v.GetItemNum()
|
||
break
|
||
}
|
||
pack.DrawList[k] = info
|
||
}
|
||
}
|
||
cfg := WelfareMgrSington.GetConfig(p.Platform).PushCoinConfig
|
||
if cfg != nil {
|
||
if ii == 0 {
|
||
f(int(v), cfg.GetPool1().GetPool())
|
||
} else if ii == 1 {
|
||
f(int(v), cfg.GetPool2().GetPool())
|
||
} else if ii == 2 {
|
||
f(int(v), cfg.GetPool3().GetPool())
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
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.scene != nil {
|
||
logger.Logger.Warn("CSPushCoinPlayerOp p.scene != 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
|
||
}
|
||
|
||
// 活动时间检测
|
||
now := time.Now()
|
||
cfg := WelfareMgrSington.GetConfig(p.Platform).PushCoinConfig
|
||
if cfg == nil {
|
||
logger.Logger.Warn("CSPushCoinPlayerOp cfg == nil")
|
||
return nil
|
||
}
|
||
if cfg.GetOn() != common.On || now.Unix() < common.StrTimeToTs(cfg.GetStartTime()) || now.Unix() >= common.StrTimeToTs(cfg.GetEndTime()) {
|
||
logger.Logger.Warn("CSPushCoinPlayerOp cfg.GetOn() == common.Off or end")
|
||
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(), 0, common.GainWayPushCoinCost, "system", "推币机下注")
|
||
// 增加桌面道具
|
||
PushCoinAddValue(p, map[int32]int64{
|
||
int32(msg.GetOpParam()): 1,
|
||
})
|
||
// 增加水池
|
||
PushCoinPoolMangerInstance.Add(p.Platform, item.GetNum())
|
||
|
||
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() {
|
||
id := v.GetItemId()
|
||
val := v.GetItemNum()
|
||
|
||
if p.WelfData.PushCoin.Items[id] < val {
|
||
logger.Logger.Errorf("获得道具太多,无效区: %d, %d", p.WelfData.PushCoin.Items[id], val)
|
||
goto here
|
||
}
|
||
}
|
||
}
|
||
|
||
for _, v := range msg.GetOpItem() {
|
||
// 增加能量条
|
||
val := GetPushCoinValue(p.Platform, v.GetItemId())
|
||
if val <= 0 {
|
||
logger.Logger.Errorf("推币机价值查询bug itemId:%v", v.GetItemId())
|
||
}
|
||
if msg.GetOpParam() != 1 {
|
||
PushCoinAddPower(p, val*v.GetItemNum())
|
||
}
|
||
logger.Logger.Debugf("推币机,掉落 ItemId:%v ItemNum:%v Value:%v", v.GetItemId(), v.GetItemNum(), val)
|
||
|
||
// 减少桌面道具
|
||
PushCoinAddValue(p, map[int32]int64{v.GetItemId(): -v.GetItemNum()})
|
||
}
|
||
|
||
case activity.OpCodes_OP_Shake:
|
||
item := BagMgrSingleton.GetItem(p.SnId, common.ItemIDPlum)
|
||
if item == nil || item.ItemNum < msg.GetOpParam() {
|
||
pack.OpRetCode = activity.OpResultPushCoinCode_OPRC_PushCoin_ShakeNotEnough
|
||
goto here
|
||
}
|
||
|
||
BagMgrSingleton.AddItems(&model.AddItemParam{
|
||
Platform: p.Platform,
|
||
SnId: p.SnId,
|
||
Change: []*model.Item{{ItemId: common.ItemIDPlum, ItemNum: -msg.GetOpParam()}},
|
||
GainWay: common.GainWayPushCoinExchangeCost,
|
||
Operator: "system",
|
||
Remark: "推币机兑换消耗",
|
||
})
|
||
BagMgrSingleton.AddItems(&model.AddItemParam{
|
||
Platform: p.Platform,
|
||
SnId: p.SnId,
|
||
Change: []*model.Item{{ItemId: common.ItemIDShake, ItemNum: msg.GetOpParam()}},
|
||
GainWay: common.GainWatPushCoinExchangeGain,
|
||
Operator: "system",
|
||
Remark: "推币机兑换获得",
|
||
})
|
||
|
||
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,
|
||
})
|
||
gain = append(gain, &model.Item{
|
||
ItemId: int32(k),
|
||
ItemNum: v,
|
||
})
|
||
}
|
||
for _, v := range cost {
|
||
if v.ItemNum < 0 {
|
||
v.ItemNum = -v.ItemNum
|
||
}
|
||
}
|
||
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: 32,
|
||
common.ItemIDPlum: 1,
|
||
},
|
||
Turn: []int32{ // 转盘表数据id
|
||
1, 2, -1,
|
||
3, -1, 4,
|
||
-1, 5, 9,
|
||
},
|
||
Next: -1,
|
||
PoolV: []int64{-1, -1, -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
|
||
}
|
||
|
||
pack := &activity.NotifyPowerLine{
|
||
PowerLine: p.WelfData.PushCoin.Power,
|
||
PowerLineMax: PowerMax,
|
||
}
|
||
|
||
p.SendToClient(int(activity.PushCoinPacketID_PACKET_NotifyPowerLine), pack)
|
||
logger.Logger.Tracef("刷新能量条: %v", pack)
|
||
if value <= 0 {
|
||
return
|
||
}
|
||
// 抽奖
|
||
PushCoinDraw(p)
|
||
}
|
||
|
||
// PushCoinDraw 抽奖
|
||
func PushCoinDraw(p *Player) {
|
||
if p.WelfData.PushCoin.Power < PowerMax {
|
||
return
|
||
}
|
||
p.WelfData.PushCoin.Power = 0
|
||
|
||
var draw *activity.DrawInfo
|
||
var draw1 []*activity.DrawInfo
|
||
// 奖池返奖
|
||
f1 := func() bool {
|
||
pool := PushCoinPoolMangerInstance.PlatformConfig[p.Platform]
|
||
if pool == nil {
|
||
return false
|
||
}
|
||
|
||
// fp 奖池返奖，返回是否成功
|
||
fp := func(i int, poolInfo *model.PushCoinPoolInfo) bool {
|
||
// 是否返奖
|
||
if poolInfo == nil || poolInfo.Remain <= 0 {
|
||
return false
|
||
}
|
||
// 玩家奖池没有返过奖
|
||
if len(p.WelfData.PushCoin.PoolV) > i && p.WelfData.PushCoin.PoolV[i] < poolInfo.Version {
|
||
cfg := WelfareMgrSington.GetConfig(p.Platform).PushCoinConfig
|
||
poolIndex := p.WelfData.PushCoin.Turn[PoolIndex[i]]
|
||
value := int64(0) // 奖品价值
|
||
if int(poolIndex) < len(cfg.GetPool1().GetPool()) {
|
||
e := cfg.GetPool1().GetPool()[poolIndex]
|
||
if e != nil {
|
||
for _, v := range e.GetAward() {
|
||
iv, ok := PushCoinItemValue[v.GetItemId()]
|
||
if ok {
|
||
value = v.GetItemNum() * iv
|
||
} else {
|
||
value = v.GetItemNum() * e.GetValue() // 目前只有实物是自定义的价值
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
if value > 0 {
|
||
// 价值是否足够
|
||
if poolInfo.Remain-value < 0 {
|
||
return false
|
||
}
|
||
// 扣除价值
|
||
poolInfo.Remain -= value
|
||
// 刷新玩家奖池版本
|
||
p.WelfData.PushCoin.PoolV[i] = poolInfo.Version
|
||
// 下次中奖位置
|
||
p.WelfData.PushCoin.Next = int32(PoolIndex[i])
|
||
logger.Logger.Tracef("下次中奖池：%+v", p.WelfData.PushCoin)
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// 奖池1
|
||
if fp(0, pool.Pool1) {
|
||
return true
|
||
}
|
||
// 奖池2
|
||
if fp(1, pool.Pool2) {
|
||
return true
|
||
}
|
||
// 奖池3
|
||
if fp(2, pool.Pool3) {
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
switch p.WelfData.PushCoin.Dram {
|
||
case 0:
|
||
// 必中大金币
|
||
draw = PushCoinNormalRandom(common.ItemIDBigCoin)
|
||
draw.Id = 0 // 查表
|
||
// 下次必中v卡
|
||
p.WelfData.PushCoin.Next = 5 // 查表
|
||
|
||
default:
|
||
// 使用预生成结果
|
||
if p.WelfData.PushCoin.Next >= 0 {
|
||
k := p.WelfData.PushCoin.Next
|
||
val := p.WelfData.PushCoin.Turn[p.WelfData.PushCoin.Next]
|
||
if slices.Contains(NormaIndex, int(k)) {
|
||
// 普通奖品
|
||
for kk, vv := range srvdata.PBDB_ACTPushCoinMgr.GetData(val).GetGain() {
|
||
draw = &activity.DrawInfo{
|
||
Id: k,
|
||
ItemId: int32(kk),
|
||
ItemNum: vv,
|
||
}
|
||
logger.Logger.Tracef("中奖普通奖品：%v", draw)
|
||
}
|
||
}
|
||
if slices.Contains(PoolIndex, int(k)) {
|
||
f := func(i int, list []*webapi.PushCoinPoolElement) {
|
||
// 本次奖品
|
||
if i < len(list) {
|
||
for _, v := range list[i].GetAward() {
|
||
draw = &activity.DrawInfo{
|
||
Id: k,
|
||
ItemId: v.GetItemId(),
|
||
ItemNum: v.GetItemNum(),
|
||
}
|
||
logger.Logger.Tracef("中奖奖池奖品：%v", draw)
|
||
break
|
||
}
|
||
} else {
|
||
logger.Logger.Errorf("奖池抽奖bug: %d, %d, %d", k, i, len(list))
|
||
}
|
||
// 刷新奖池
|
||
e, index := PushCoinPoolRandom(list)
|
||
if e != nil {
|
||
p.WelfData.PushCoin.Turn[k] = index
|
||
for _, v := range e.GetAward() {
|
||
draw1 = append(draw1, &activity.DrawInfo{
|
||
Id: k,
|
||
ItemId: v.GetItemId(),
|
||
ItemNum: v.GetItemNum(),
|
||
})
|
||
logger.Logger.Tracef("刷新奖池奖品：%v", draw1)
|
||
break
|
||
}
|
||
} else {
|
||
logger.Logger.Errorf("奖池刷新bug: %d, %d, %d", k, i, len(list))
|
||
}
|
||
}
|
||
// 水池奖品
|
||
var poolElements []*webapi.PushCoinPoolElement
|
||
switch slices.Index(PoolIndex, int(k)) {
|
||
case 0:
|
||
poolElements = WelfareMgrSington.GetConfig(p.Platform).PushCoinConfig.GetPool1().GetPool()
|
||
case 1:
|
||
poolElements = WelfareMgrSington.GetConfig(p.Platform).PushCoinConfig.GetPool2().GetPool()
|
||
case 2:
|
||
poolElements = WelfareMgrSington.GetConfig(p.Platform).PushCoinConfig.GetPool3().GetPool()
|
||
}
|
||
f(int(val), poolElements)
|
||
}
|
||
}
|
||
|
||
// 下次中奖位置
|
||
// 奖池返奖 或 普通抽奖
|
||
if !f1() {
|
||
// 普通抽奖
|
||
curIndex := p.WelfData.PushCoin.Next
|
||
index := int(p.WelfData.PushCoin.Next) // 奖品位置
|
||
e := PushCoinNormalRandom(0)
|
||
e1 := PushCoinNormalRandom(0)
|
||
if e != nil {
|
||
var has bool
|
||
for k, v := range p.WelfData.PushCoin.Turn {
|
||
if slices.Contains(NormaIndex, k) && v == e.GetId() {
|
||
has = true
|
||
index = k
|
||
break
|
||
}
|
||
}
|
||
if has && index == int(curIndex) {
|
||
// 重复
|
||
has = false
|
||
}
|
||
|
||
if !has {
|
||
// 替换
|
||
if slices.Contains(PoolIndex, index) {
|
||
// 找一个普通奖品位置
|
||
index = NormaIndex[common.RandInt(len(NormaIndex[:len(NormaIndex)-1]))]
|
||
}
|
||
draw1 = append(draw1, &activity.DrawInfo{
|
||
Id: int32(index),
|
||
ItemId: e.GetItemId(),
|
||
ItemNum: e.GetItemNum(),
|
||
})
|
||
p.WelfData.PushCoin.Turn[index] = e.GetId()
|
||
} else {
|
||
if !slices.Contains(PoolIndex, int(curIndex)) {
|
||
p.WelfData.PushCoin.Turn[curIndex] = e1.GetId()
|
||
draw1 = append(draw1, &activity.DrawInfo{
|
||
Id: curIndex,
|
||
ItemId: e1.GetItemId(),
|
||
ItemNum: e1.GetItemNum(),
|
||
})
|
||
}
|
||
}
|
||
p.WelfData.PushCoin.Next = int32(index)
|
||
logger.Logger.Tracef("下次中普通奖品：index:%v ItemId:%v Num:%v", index, e.GetItemId(), e.GetItemNum())
|
||
}
|
||
}
|
||
}
|
||
|
||
p.WelfData.PushCoin.Dram++
|
||
|
||
if draw != nil {
|
||
pack := &activity.NotifyDrawInfo{
|
||
Draw: draw,
|
||
}
|
||
if len(draw1) > 0 {
|
||
pack.Info = draw1
|
||
}
|
||
|
||
PushCoinAddValue(p, map[int32]int64{draw.GetItemId(): draw.GetItemNum()})
|
||
|
||
p.SendToClient(int(activity.PushCoinPacketID_PACKET_NotifyDrawInfo), pack)
|
||
logger.Logger.Trace("NotifyDrawInfo: ", pack)
|
||
|
||
if slices.Contains(PoolIndex, int(draw.GetId())) {
|
||
pk := &activity.NotifyAward{
|
||
Draw: draw,
|
||
Name: p.GetName(),
|
||
}
|
||
// 广播抽奖信息
|
||
PlatformMgrSingleton.Broadcast(int(activity.PushCoinPacketID_PACKET_NotifyAward), pk, nil, 0)
|
||
logger.Logger.Trace("Broadcast NotifyAward: ", pk)
|
||
}
|
||
|
||
// 刷新能量条
|
||
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 {
|
||
p.WelfData.PushCoin.Items[k] += v
|
||
logger.Logger.Tracef("桌面数据 ItemId:%v Change:%v Num:%v", k, v, p.WelfData.PushCoin.Items[k])
|
||
}
|
||
}
|
||
}
|
||
|
||
func PushCoinPoolRandom(pool []*webapi.PushCoinPoolElement) (*webapi.PushCoinPoolElement, int32) {
|
||
var total int32
|
||
for _, v := range pool {
|
||
if v.GetOn() == common.On {
|
||
total += v.GetWeight()
|
||
}
|
||
}
|
||
if total <= 0 {
|
||
return nil, -1
|
||
}
|
||
var n int32
|
||
rn := int32(common.RandInt(int(total)))
|
||
for k, v := range pool {
|
||
if v.GetOn() == common.On {
|
||
n += v.GetWeight()
|
||
if rn < n {
|
||
return v, int32(k)
|
||
}
|
||
}
|
||
}
|
||
return nil, -1
|
||
}
|
||
|
||
func PushCoinNormalRandom(itemId int64) *activity.DrawInfo {
|
||
var total int32
|
||
var index = int32(-1) // 随机id
|
||
var n int32
|
||
if itemId == 0 {
|
||
// 随机抽奖
|
||
for _, vv := range srvdata.PBDB_ACTPushCoinMgr.Datas.GetArr() {
|
||
total += vv.GetRate()
|
||
}
|
||
|
||
rn := int32(common.RandInt(int(total)))
|
||
for _, vv := range srvdata.PBDB_ACTPushCoinMgr.Datas.GetArr() {
|
||
n += vv.GetRate()
|
||
if rn < n {
|
||
index = vv.GetId()
|
||
break
|
||
}
|
||
}
|
||
if index >= 0 {
|
||
for kk, vv := range srvdata.PBDB_ACTPushCoinMgr.GetData(index).GetGain() {
|
||
draw := &activity.DrawInfo{
|
||
Id: index,
|
||
ItemId: int32(kk),
|
||
ItemNum: vv,
|
||
}
|
||
return draw
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
// 前两次必中
|
||
for _, v := range srvdata.PBDB_ACTPushCoinMgr.Datas.GetArr() {
|
||
for kk, vv := range v.GetGain() {
|
||
if kk == itemId {
|
||
draw := &activity.DrawInfo{
|
||
ItemId: int32(kk),
|
||
ItemNum: vv,
|
||
}
|
||
return draw
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// GetPushCoinValue 查询物品价值,没有的是后台配置的价值
|
||
func GetPushCoinValue(plt string, itemId int32) int64 {
|
||
val, ok := PushCoinItemValue[itemId]
|
||
if ok {
|
||
return val
|
||
}
|
||
cfg := WelfareMgrSington.GetConfig(plt).PushCoinConfig
|
||
if cfg != nil {
|
||
f := func(list []*webapi.PushCoinPoolElement) bool {
|
||
for _, vv := range list {
|
||
for _, vvv := range vv.GetAward() {
|
||
if vvv.GetItemId() == itemId {
|
||
val = vv.GetValue()
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
for {
|
||
if f(cfg.GetPool1().GetPool()) {
|
||
break
|
||
}
|
||
if f(cfg.GetPool2().GetPool()) {
|
||
break
|
||
}
|
||
if f(cfg.GetPool3().GetPool()) {
|
||
break
|
||
}
|
||
break
|
||
}
|
||
}
|
||
return val
|
||
}
|