735 lines
20 KiB
Go
735 lines
20 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"math/rand"
|
|
"strconv"
|
|
"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/mq"
|
|
"mongo.games.com/game/proto"
|
|
"mongo.games.com/game/protocol/bag"
|
|
webapiproto "mongo.games.com/game/protocol/webapi"
|
|
"mongo.games.com/game/srvdata"
|
|
"mongo.games.com/game/webapi"
|
|
)
|
|
|
|
func CSBagInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSBagInfoHandler Process recv ", data)
|
|
if msg, ok := data.(*bag.CSBagInfo); ok {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSBagInfoHandler p == nil")
|
|
return nil
|
|
}
|
|
platform := p.GetPlatform()
|
|
if platform == nil {
|
|
return nil
|
|
}
|
|
//nowLocation := int(msg.NowLocation - 1)
|
|
tp := msg.GetTp() // 道具类型
|
|
bagInfo := BagMgrSingleton.GetBagInfo(p.SnId)
|
|
pack := &bag.SCBagInfo{RetCode: bag.OpResultCode_OPRC_Sucess, BagNumMax: BagItemMax}
|
|
if bagInfo != nil {
|
|
for _, v := range bagInfo.BagItem {
|
|
item := srvdata.GameItemMgr.Get(p.Platform, v.ItemId)
|
|
if item != nil && v.ItemNum > 0 && (tp <= 0 || item.GetType() == tp) /*&& (nowLocation == -1 || (nowLocation < len(item.ShowLocation) && item.ShowLocation[nowLocation] == 1))*/ {
|
|
pack.Infos = append(pack.Infos, &bag.ItemInfo{
|
|
ItemId: v.ItemId,
|
|
ItemNum: v.ItemNum,
|
|
ObtainTime: v.ObtainTime,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
logger.Logger.Trace("SCBagInfo:", pack)
|
|
p.SendToClient(int(bag.SPacketID_PACKET_ALL_BAG_INFO), pack)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func CSUpBagInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSUpBagInfoHandler Process recv ", data)
|
|
msg, ok := data.(*bag.CSUpBagInfo)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSUpBagInfoHandler p == nil")
|
|
return nil
|
|
}
|
|
|
|
platform := p.GetPlatform()
|
|
if platform == nil {
|
|
return nil
|
|
}
|
|
|
|
if common.Config.IsDevMode {
|
|
if msg.GetOpt() == -1 {
|
|
items := []*model.Item{{
|
|
ItemId: msg.ItemId,
|
|
ItemNum: int64(msg.ItemNum),
|
|
}}
|
|
BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: items,
|
|
GainWay: common.GainWay_ItemUse,
|
|
Operator: "system",
|
|
Remark: "测试",
|
|
})
|
|
for _, v := range items {
|
|
if v.ItemId == common.ItemIDRoomCard && v.ItemNum < 0 {
|
|
LotteryMgrInst.AddCostRoomCard(p.Platform, p.SnId, -v.ItemNum)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
pack := &bag.SCUpBagInfo{RetCode: bag.OpResultCode_OPRC_Error, Opt: msg.GetOpt()}
|
|
send := func() {
|
|
p.SendToClient(int(bag.SPacketID_PACKET_ALL_BAG_USE), pack)
|
|
logger.Logger.Tracef("SCUpBagInfo: %v", pack)
|
|
}
|
|
|
|
item := BagMgrSingleton.GetItem(p.SnId, msg.ItemId)
|
|
if item == nil || msg.ItemNum <= 0 || item.ItemNum < int64(msg.ItemNum) || len(item.Effect) != ItemMax || p.SnId == msg.AcceptSnId {
|
|
send()
|
|
return nil
|
|
}
|
|
|
|
var isCanOp int32
|
|
if msg.NowEffect == 0 { //竖版
|
|
isCanOp = item.Effect0[msg.Opt]
|
|
} else if msg.NowEffect == 1 { //横版
|
|
isCanOp = item.Effect[msg.Opt]
|
|
}
|
|
|
|
if isCanOp == 0 {
|
|
logger.Logger.Trace("道具没有操作权限", msg.ItemId)
|
|
send()
|
|
return nil
|
|
}
|
|
|
|
ts := time.Now().Unix()
|
|
|
|
switch msg.Opt {
|
|
case ItemCanUse:
|
|
logger.Logger.Trace("道具使用", msg.ItemId)
|
|
|
|
items := map[int32]*model.Item{}
|
|
var useFunc func()
|
|
saleFunc := func(gainWay int32, oper, remark string) {
|
|
if gainWay == 0 {
|
|
gainWay = common.GainWay_ItemUse
|
|
}
|
|
if oper == "" {
|
|
oper = "player"
|
|
}
|
|
if remark == "" {
|
|
remark = "道具使用"
|
|
}
|
|
// 使用道具，减少道具
|
|
BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: []*model.Item{
|
|
{
|
|
ItemId: item.ItemId,
|
|
ItemNum: int64(-msg.ItemNum),
|
|
},
|
|
},
|
|
GainWay: gainWay,
|
|
Operator: oper,
|
|
Remark: remark,
|
|
})
|
|
pack.RetCode = bag.OpResultCode_OPRC_Sucess
|
|
pack.NowItemId = item.ItemId
|
|
pack.NowItemNum = item.ItemNum
|
|
}
|
|
gainFunc := func(gainWay int32, oper, remark string) {
|
|
for i := 0; i < int(msg.ItemNum); i++ {
|
|
useFunc()
|
|
}
|
|
if gainWay == 0 {
|
|
gainWay = common.GainWay_ItemUse
|
|
}
|
|
if oper == "" {
|
|
oper = "player"
|
|
}
|
|
if remark == "" {
|
|
remark = "道具使用"
|
|
}
|
|
if len(items) > 0 {
|
|
var itemArr []*model.Item
|
|
for _, v := range items {
|
|
itemArr = append(itemArr, v)
|
|
}
|
|
BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: itemArr,
|
|
GainWay: gainWay,
|
|
Operator: oper,
|
|
Remark: remark,
|
|
})
|
|
for _, v := range itemArr {
|
|
pack.Infos = append(pack.Infos, &bag.ItemInfo{
|
|
ItemId: v.ItemId,
|
|
ItemNum: v.ItemNum,
|
|
ObtainTime: v.ObtainTime,
|
|
})
|
|
}
|
|
if gainWay == common.GainWay_Collect {
|
|
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 {
|
|
mq.Write(model.GenerateSystemFreeGive(p.SnId, p.Name, p.Platform, p.Channel, model.SystemFreeGive_CollectBox, tp1, v.ItemNum))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
switch item.ItemId {
|
|
case common.ItemIDGiftBox:
|
|
saleFunc(0, "", "")
|
|
useFunc = func() {
|
|
sum := 0
|
|
for _, v := range srvdata.PBDB_GiftBoxMgr.Datas.GetArr() {
|
|
sum += int(v.GetRate())
|
|
}
|
|
if sum > 0 {
|
|
n := 0
|
|
i := rand.Intn(sum)
|
|
for _, v := range srvdata.PBDB_GiftBoxMgr.Datas.GetArr() {
|
|
n += int(v.GetRate())
|
|
if i < n {
|
|
for k, vv := range v.ItemID {
|
|
if vv > 0 {
|
|
item, ok := items[int32(k)]
|
|
if !ok {
|
|
items[int32(k)] = &model.Item{
|
|
ItemId: int32(k),
|
|
ItemNum: vv,
|
|
ObtainTime: ts,
|
|
}
|
|
} else {
|
|
item.ItemNum += vv
|
|
}
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
gainFunc(0, "", "")
|
|
|
|
case common.ItemIDCollectBox:
|
|
saleFunc(0, "", "")
|
|
useFunc = func() {
|
|
sum := 0
|
|
for _, v := range srvdata.PBDB_CollectBoxMgr.Datas.GetArr() {
|
|
sum += int(v.GetRate())
|
|
}
|
|
if sum > 0 {
|
|
n := 0
|
|
i := rand.Intn(sum)
|
|
for _, v := range srvdata.PBDB_CollectBoxMgr.Datas.GetArr() {
|
|
n += int(v.GetRate())
|
|
if i < n {
|
|
for k, vv := range v.ItemID {
|
|
if vv > 0 {
|
|
item, ok := items[int32(k)]
|
|
if !ok {
|
|
items[int32(k)] = &model.Item{
|
|
ItemId: int32(k),
|
|
ItemNum: vv,
|
|
ObtainTime: ts,
|
|
}
|
|
} else {
|
|
item.ItemNum += vv
|
|
}
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
gainFunc(common.GainWay_Collect, "player", "集卡活动")
|
|
mq.Write(model.GenerateActivityLog(p.SnId, p.Platform, model.ActivityLog_CollectBox, 1))
|
|
|
|
default:
|
|
logger.Logger.Warnf("道具使用未定义", msg.ItemId)
|
|
}
|
|
|
|
case ItemCanGive:
|
|
logger.Logger.Trace("道具赠送", msg.ItemId)
|
|
acceptPlayer := PlayerMgrSington.GetPlatformPlayerBySnId(p.Platform, msg.AcceptSnId)
|
|
if acceptPlayer != nil {
|
|
logger.Logger.Trace("道具赠送成功", msg.ItemId)
|
|
remark := fmt.Sprintf("赠送给玩家(%v)", msg.AcceptSnId)
|
|
AddMailByItem(p.Platform, p.SnId, p.Name, msg.AcceptSnId, msg.ShowId, []*model.Item{{
|
|
ItemId: msg.GetItemId(),
|
|
ItemNum: int64(msg.GetItemNum()),
|
|
}})
|
|
BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: []*model.Item{
|
|
{
|
|
ItemId: item.ItemId,
|
|
ItemNum: int64(-msg.ItemNum),
|
|
},
|
|
},
|
|
GainWay: common.GainWay_ItemMove,
|
|
Operator: "player",
|
|
Remark: remark,
|
|
})
|
|
pack.RetCode = bag.OpResultCode_OPRC_Sucess
|
|
pack.NowItemId = msg.ItemId
|
|
pack.NowItemNum = item.ItemNum
|
|
} else {
|
|
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
|
return model.GetPlayerBaseInfo(p.Platform, msg.AcceptSnId)
|
|
}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
|
|
aPlayer := data.(*model.PlayerBaseInfo)
|
|
if data != nil && aPlayer != nil {
|
|
logger.Logger.Trace("道具赠送成功", msg.ItemId)
|
|
remark := fmt.Sprintf("赠送给玩家(%v)", msg.AcceptSnId)
|
|
AddMailByItem(p.Platform, p.SnId, p.Name, msg.AcceptSnId, msg.ShowId, []*model.Item{{
|
|
ItemId: msg.GetItemId(),
|
|
ItemNum: int64(msg.GetItemNum()),
|
|
}})
|
|
BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: []*model.Item{
|
|
{
|
|
ItemId: item.ItemId,
|
|
ItemNum: int64(-msg.ItemNum),
|
|
},
|
|
},
|
|
GainWay: common.GainWay_ItemMove,
|
|
Operator: "player",
|
|
Remark: remark,
|
|
})
|
|
pack.RetCode = bag.OpResultCode_OPRC_Sucess
|
|
pack.NowItemId = msg.ItemId
|
|
pack.NowItemNum = item.ItemNum
|
|
} else {
|
|
pack.RetCode = bag.OpResultCode_OPRC_NotPlayer
|
|
}
|
|
send()
|
|
}), "GetPlayerBaseInfo").Start()
|
|
return nil
|
|
}
|
|
|
|
case ItemCanSell:
|
|
logger.Logger.Trace("道具出售", msg.ItemId)
|
|
if msg.ItemNum > 0 {
|
|
remark := "道具出售" + fmt.Sprintf("%v-%v", msg.ItemId, msg.ItemNum)
|
|
_, _, isF := BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: []*model.Item{
|
|
{
|
|
ItemId: item.ItemId,
|
|
ItemNum: int64(-msg.ItemNum),
|
|
},
|
|
},
|
|
GainWay: common.GainWay_Item_Sale,
|
|
Operator: "player",
|
|
Remark: remark,
|
|
})
|
|
if isF {
|
|
pack.RetCode = bag.OpResultCode_OPRC_Sucess
|
|
if item.SaleGold > 0 {
|
|
n := int64(item.SaleGold) * int64(msg.ItemNum)
|
|
if item.SaleType == 1 {
|
|
p.AddCoin(n, 0, common.GainWay_Item_Sale, "sys", remark)
|
|
pack.Coin = n
|
|
} else if item.SaleType == 2 {
|
|
p.AddDiamond(n, 0, common.GainWay_Item_Sale, "sys", remark)
|
|
pack.Diamond = n
|
|
}
|
|
}
|
|
pack.NowItemId = item.ItemId
|
|
pack.NowItemNum = item.ItemNum
|
|
}
|
|
}
|
|
|
|
case ItemCanExchange:
|
|
logger.Logger.Trace("道具兑换", msg.ItemId)
|
|
itemInfo := srvdata.GameItemMgr.Get(p.Platform, msg.ItemId)
|
|
if itemInfo == nil || itemInfo.Type != common.ItemTypeChange {
|
|
pack.RetCode = bag.OpResultCode_OPRC_NotChange
|
|
send()
|
|
return nil
|
|
}
|
|
bagInfo, _, isF := BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: []*model.Item{
|
|
{
|
|
ItemId: msg.GetItemId(),
|
|
ItemNum: -1,
|
|
},
|
|
},
|
|
GainWay: common.GainWayItemChange,
|
|
Operator: "system",
|
|
Remark: "背包内使用兑换",
|
|
})
|
|
if isF {
|
|
pack.RetCode = bag.OpResultCode_OPRC_Sucess
|
|
pack.NowItemId = item.ItemId
|
|
pack.NowItemNum = item.ItemNum
|
|
//获取兑换码
|
|
BagMgrSingleton.ItemExchangeCard(p, msg.ItemId, int32(itemInfo.Num), msg.CardType, bagInfo.LogId)
|
|
}
|
|
|
|
case ItemCanFen:
|
|
logger.Logger.Trace("道具分解", msg.ItemId)
|
|
itemInfo := srvdata.GameItemMgr.Get(p.Platform, msg.ItemId)
|
|
if msg.ItemNum > 0 && itemInfo != nil {
|
|
_, _, isF := BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: []*model.Item{
|
|
{
|
|
ItemId: msg.GetItemId(),
|
|
ItemNum: int64(-msg.GetItemNum()),
|
|
},
|
|
},
|
|
GainWay: common.GainWayItemFen,
|
|
Operator: "system",
|
|
Remark: fmt.Sprintf("道具分解%v", msg.GetItemId()),
|
|
})
|
|
if isF {
|
|
pack.RetCode = bag.OpResultCode_OPRC_Sucess
|
|
var changeItems []*model.Item
|
|
for k, v := range itemInfo.GetGain() {
|
|
if v > 0 {
|
|
changeItems = append(changeItems, &model.Item{
|
|
ItemId: int32(k),
|
|
ItemNum: v * int64(msg.GetItemNum()),
|
|
})
|
|
}
|
|
}
|
|
BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: changeItems,
|
|
Cost: []*model.Item{
|
|
{
|
|
ItemId: msg.GetItemId(),
|
|
ItemNum: int64(msg.GetItemNum()),
|
|
},
|
|
},
|
|
GainWay: common.GainWayItemFenGain,
|
|
Operator: "system",
|
|
Remark: "道具分解获得",
|
|
})
|
|
pack.NowItemId = item.ItemId
|
|
pack.NowItemNum = item.ItemNum
|
|
}
|
|
}
|
|
}
|
|
send()
|
|
return nil
|
|
}
|
|
|
|
func CSExchangeList(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSExchangeList", data)
|
|
msg, ok := data.(*bag.CSExchangeList)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
|
|
pack := &bag.SCExchangeList{
|
|
Tp: msg.Tp,
|
|
}
|
|
|
|
for _, v := range srvdata.PBDB_PropExchangeMgr.Datas.GetArr() {
|
|
if v.GetGroup() != msg.Tp {
|
|
continue
|
|
}
|
|
var costItems, gainItems []*bag.PropInfo
|
|
for k, v := range v.GetCost() {
|
|
costItems = append(costItems, &bag.PropInfo{
|
|
ItemId: int32(k),
|
|
ItemNum: v,
|
|
})
|
|
}
|
|
for k, v := range v.GetGain() {
|
|
gainItems = append(gainItems, &bag.PropInfo{
|
|
ItemId: int32(k),
|
|
ItemNum: v,
|
|
})
|
|
}
|
|
pack.Infos = append(pack.Infos, &bag.ExchangeInfo{
|
|
Id: v.Id,
|
|
CostItems: costItems,
|
|
GainItems: gainItems,
|
|
})
|
|
}
|
|
|
|
p.SendToClient(packetid, pack)
|
|
logger.Logger.Tracef("SCExchangeList:%v", pack)
|
|
return nil
|
|
}
|
|
|
|
func CSPropExchange(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSPropExchange", data)
|
|
msg, ok := data.(*bag.CSPropExchange)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
|
|
pack := &bag.SCPropExchange{
|
|
RetCode: bag.OpResultCode_OPRC_Error,
|
|
}
|
|
send := func(code bag.OpResultCode) {
|
|
pack.RetCode = code
|
|
p.SendToClient(packetid, pack)
|
|
logger.Logger.Tracef("SCPropExchange:%v", pack)
|
|
}
|
|
|
|
info := srvdata.PBDB_PropExchangeMgr.GetData(msg.Id)
|
|
if info == nil {
|
|
send(bag.OpResultCode_OPRC_IdErr)
|
|
return nil
|
|
}
|
|
// 检查背包是否足够
|
|
var items []*model.Item
|
|
var costItems []*model.Item
|
|
for k, v := range info.GetCost() {
|
|
item := BagMgrSingleton.GetItem(p.SnId, int32(k))
|
|
if item == nil || item.ItemNum < v {
|
|
send(bag.OpResultCode_OPRC_UseUp)
|
|
return nil
|
|
}
|
|
info := srvdata.GameItemMgr.Get(p.Platform, int32(k))
|
|
if info != nil {
|
|
costItems = append(costItems, &model.Item{
|
|
ItemId: int32(k),
|
|
ItemNum: v,
|
|
})
|
|
}
|
|
}
|
|
for k, v := range info.GetGain() {
|
|
info := srvdata.GameItemMgr.Get(p.Platform, int32(k))
|
|
if info != nil {
|
|
items = append(items, &model.Item{
|
|
ItemId: int32(k),
|
|
ItemNum: v,
|
|
})
|
|
}
|
|
}
|
|
// 扣除背包物品
|
|
for _, item := range costItems {
|
|
BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: []*model.Item{
|
|
{
|
|
ItemId: item.ItemId,
|
|
ItemNum: -item.ItemNum,
|
|
},
|
|
},
|
|
GainWay: common.GainWayItemCollectExchange,
|
|
Operator: "system",
|
|
Remark: "集卡活动兑换",
|
|
})
|
|
}
|
|
// 增加背包物品
|
|
BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: items,
|
|
GainWay: common.GainWayItemCollectExchange,
|
|
Operator: "system",
|
|
Remark: "集卡活动兑换",
|
|
})
|
|
for _, v := range items {
|
|
pack.Items = append(pack.Items, &bag.PropInfo{
|
|
ItemId: v.ItemId,
|
|
ItemNum: v.ItemNum,
|
|
})
|
|
|
|
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 {
|
|
mq.Write(model.GenerateSystemFreeGive(p.SnId, p.Name, p.Platform, p.Channel, model.SystemFreeGive_CollectBoxSwap, tp1, v.ItemNum))
|
|
}
|
|
}
|
|
|
|
send(bag.OpResultCode_OPRC_Sucess)
|
|
return nil
|
|
}
|
|
|
|
// 兑换娃娃
|
|
func CSDollChange(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
msg, ok := data.(*bag.CSDollChange)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
pack := &bag.SCDollChange{}
|
|
for _, item := range msg.Items {
|
|
if item.ItemId == 0 {
|
|
return nil
|
|
}
|
|
info := srvdata.GameItemMgr.Get(p.Platform, item.ItemId)
|
|
if info == nil {
|
|
return nil
|
|
}
|
|
if info.Type != common.ItemTypeDoll {
|
|
return nil
|
|
}
|
|
|
|
bagInfo, rest, isF := BagMgrSingleton.AddItems(&model.AddItemParam{
|
|
Platform: p.Platform,
|
|
SnId: p.SnId,
|
|
Change: []*model.Item{
|
|
{
|
|
ItemId: item.GetItemId(),
|
|
ItemNum: -1,
|
|
},
|
|
},
|
|
GainWay: common.GainWayItemBagChangeDoll,
|
|
Operator: "system",
|
|
Remark: "背包内使用兑换娃娃卡",
|
|
})
|
|
logger.Logger.Trace("背包内使用兑换娃娃卡 bagInfo = ", bagInfo)
|
|
pack.RetCode = rest
|
|
|
|
if isF {
|
|
itemId := item.ItemId
|
|
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
|
dollLog := model.NewDbBagChangeDoll(p.Platform, p.SnId, itemId, 1, 0, "", msg.Addr, msg.UserName, msg.UserTel)
|
|
return model.InsertDbBagChangeDollLog(dollLog)
|
|
}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
|
|
}), "CSDollChange").Start()
|
|
|
|
}
|
|
}
|
|
p.SendToClient(int(bag.SPacketID_PACKET_SC_DollChange), pack)
|
|
return nil
|
|
}
|
|
|
|
// 兑换娃娃记录
|
|
func CSDollChangeLog(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
|
return model.GetDbBagChangeDollLog(p.Platform, p.SnId)
|
|
}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
|
|
pack := &bag.SCDillChangeLog{}
|
|
if data != nil {
|
|
for _, log := range data.([]*model.BagChangeDollLog) {
|
|
info := &bag.DillChangeLogInfo{}
|
|
info.ItemId = log.ItemId
|
|
info.ItemNum = log.ItemNum
|
|
info.State = log.State
|
|
info.UserName = log.UserName
|
|
info.UserTel = log.UserTel
|
|
info.Addr = log.Addr
|
|
info.CreateTs = strconv.FormatInt(log.CreateTs, 10)
|
|
info.OpTs = strconv.FormatInt(log.OpTs, 10)
|
|
info.Remark = log.Remark
|
|
info.TypeId = 1
|
|
pack.Info = append(pack.Info, info)
|
|
}
|
|
}
|
|
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
|
msg := &webapiproto.ASGetDollExchangeOrder{
|
|
Snid: p.SnId,
|
|
Platform: p.Platform,
|
|
}
|
|
buff, err := webapi.API_DollExchangeRecord(common.GetAppId(), msg)
|
|
|
|
as := &webapiproto.SAGetDollExchangeOrder{}
|
|
if err != nil {
|
|
logger.Logger.Error("API_DollExchangeRecord error:", err)
|
|
return nil
|
|
} else if err := proto.Unmarshal(buff, as); err != nil { // 有订单
|
|
logger.Logger.Errorf("DollExchangeRecord: %v", err)
|
|
return nil
|
|
|
|
}
|
|
return as
|
|
}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
|
|
if data != nil {
|
|
if as := data.(*webapiproto.SAGetDollExchangeOrder); as != nil {
|
|
for _, v := range as.OrderList {
|
|
cdata := ShopMgrSington.GetExchangeData(p.Platform, v.GoodsId)
|
|
record := &bag.DillChangeLogInfo{
|
|
CreateTs: strconv.FormatInt(v.CreateTime, 10),
|
|
State: v.Status,
|
|
Remark: v.Remark,
|
|
ItemId: cdata.ItemId,
|
|
ItemNum: v.ExchangeNum,
|
|
TypeId: 2,
|
|
}
|
|
pack.Info = append(pack.Info, record)
|
|
}
|
|
}
|
|
}
|
|
p.SendToClient(int(bag.SPacketID_PACKET_SC_DollChangeLog), pack)
|
|
}), "DollExchangeRecord").Start()
|
|
}), "CSDollChangeLog").Start()
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
// 查看背包
|
|
common.Register(int(bag.SPacketID_PACKET_ALL_BAG_INFO), &bag.CSBagInfo{}, CSBagInfo)
|
|
// 道具操作
|
|
common.Register(int(bag.SPacketID_PACKET_ALL_BAG_USE), &bag.CSUpBagInfo{}, CSUpBagInfo)
|
|
// 兑换列表
|
|
common.Register(int(bag.SPacketID_PACKET_ExchangeList), &bag.CSExchangeList{}, CSExchangeList)
|
|
// 道具兑换
|
|
common.Register(int(bag.SPacketID_PACKET_PropExchange), &bag.CSPropExchange{}, CSPropExchange)
|
|
//兑换娃娃
|
|
common.Register(int(bag.SPacketID_PACKET_CS_DollChange), &bag.CSDollChange{}, CSDollChange)
|
|
//兑换娃娃记录
|
|
common.Register(int(bag.SPacketID_PACKET_CS_DollChangeLog), &bag.CSDollChangeLog{}, CSDollChangeLog)
|
|
}
|