tl_server_2
/
game_sync
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'develop' of https://git.pogorockgames.com/mango-games/server/game into develop

This commit is contained in:
tomas 2024-12-23 13:23:41 +08:00
parent 4b8093d09e 292a5ea563
commit f15ce4ef8f
9 changed files with 272 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gamesrv/tienlen/scenedata_tienlen.go
View File

@ -174,6 +174,10 @@ func (this *TienLenSceneData) CanStart() bool {
return false
}
func (this *TienLenSceneData) IsFirst(pos int) bool {
return int32(pos) == this.lastOpPos || this.lastOpPos == rule.InvalidePos
}
func (this *TienLenSceneData) GetPlayerCnt() int {
var cnt int
for i := 0; i < this.GetPlayerNum(); i++ {

424
gamesrv/tienlen/scenepolicy_tienlen.go
View File

@ -1160,208 +1160,24 @@ func (this *ScenePlayerOpStateTienLen) OnPlayerOp(s *base.Scene, p *base.Player,
return true
}
sceneEx, _ := s.GetExtraData().(*TienLenSceneData)
if sceneEx != nil {
playerEx, _ := p.GetExtraData().(*TienLenPlayerData)
if playerEx != nil {
sceneEx, ok := s.GetExtraData().(*TienLenSceneData)
if !ok {
return false
}
playerEx, ok := p.GetExtraData().(*TienLenPlayerData)
if !ok {
return false
}
if sceneEx.GetCurOpPos() != int32(playerEx.GetPos()) {
return false
}
opRetCode := tienlen.OpResultCode_OPRC_Error
switch int32(opcode) {
case rule.TienLenPlayerOpPlay: //出牌
delCards := []int32{}
for _, card := range params {
isHave := false
for _, hcard := range playerEx.cards { //去手牌里找找看有没有
if int32(card) == hcard && hcard != rule.InvalideCard {
isHave = true
}
}
if isHave {
delCards = append(delCards, int32(card))
} else {
opRetCode = tienlen.OpResultCode_OPRC_Error
break
}
}
if len(delCards) == len(params) && len(delCards) > 0 {
isRule, _ := rule.RulePopEnable(delCards)
ruleType := rule.Tienlen_Pass
if sceneEx.IsTienLenYule() {
isRule, ruleType = rule.RulePopEnable_yl(delCards)
}
//logger.Logger.Trace("ScenePlayerOpStateTienLen,2params:", params, " isRule:", isRule)
if isRule { //符合出牌规则
if int32(playerEx.GetPos()) == sceneEx.lastOpPos || sceneEx.lastOpPos == rule.InvalidePos { //当前操作者和上一个操作者是同一个人，必出牌
if ruleType == rule.Plane_Single { //飞机带单只能最后一手出
haveCardNum := 0
for _, hcard := range playerEx.cards {
if hcard != rule.InvalideCard {
haveCardNum++
}
}
if len(delCards) != haveCardNum {
isRule = false
opRetCode = tienlen.OpResultCode_OPRC_Error
logger.Logger.Trace("Plane_Single, delCards:", delCards, " haveCardNum:", haveCardNum)
}
}
if isRule {
if sceneEx.lastOpPos == rule.InvalidePos { //首出玩家
//有赢家，赢家先出，出牌不受限制
//无赢家，手持最小牌先出，最小牌必先出
winPos := sceneEx.FindWinPos()
//logger.Logger.Trace("ScenePlayerOpStateTienLen,8params:", params, " winPos:", winPos)
if winPos == -1 { //无赢家
haveMinCard := false
for _, card := range delCards {
if card == sceneEx.curMinCard { //最小牌必先出
haveMinCard = true
}
}
//logger.Logger.Trace("ScenePlayerOpStateTienLen,9params:", params, " curMinCard:", sceneEx.curMinCard, " haveMinCard", haveMinCard)
if haveMinCard {
isDel := sceneEx.DelCards(playerEx, delCards)
//logger.Logger.Trace("ScenePlayerOpStateTienLen,3params:", params, " isDel:", isDel)
if isDel {
playerEx.RefreshThinkLongCnt(time.Now().Sub(sceneEx.StateStartTime), false)
sceneEx.DoNext(int32(playerEx.GetPos()))
opRetCode = tienlen.OpResultCode_OPRC_Sucess
sceneEx.SetLastOpPos(int32(playerEx.GetPos()))
sceneEx.RefreshPlayerHandLimitTimeOut()
}
}
} else {
isDel := sceneEx.DelCards(playerEx, delCards)
//logger.Logger.Trace("ScenePlayerOpStateTienLen,10params:", params, " isDel:", isDel)
if isDel {
playerEx.RefreshThinkLongCnt(time.Now().Sub(sceneEx.StateStartTime), false)
sceneEx.DoNext(int32(playerEx.GetPos()))
opRetCode = tienlen.OpResultCode_OPRC_Sucess
sceneEx.SetLastOpPos(int32(playerEx.GetPos()))
sceneEx.RefreshPlayerHandLimitTimeOut()
}
}
} else {
isDel := sceneEx.DelCards(playerEx, delCards)
//logger.Logger.Trace("ScenePlayerOpStateTienLen,4params:", params, " isDel:", isDel)
if isDel {
playerEx.RefreshThinkLongCnt(time.Now().Sub(sceneEx.StateStartTime), false)
nextPos := sceneEx.DoNext(int32(playerEx.GetPos()))
//logger.Logger.Trace("ScenePlayerOpStateTienLen,4paramssss:", params, " nextPos:", nextPos)
if sceneEx.IsTienLenToEnd() && nextPos == rule.InvalidePos {
sceneEx.UnmarkPass()
nextPos = sceneEx.DoNext(int32(playerEx.GetPos()))
//logger.Logger.Trace("ScenePlayerOpStateTienLen,4paramssss:", params, " nextPos:", nextPos)
}
opRetCode = tienlen.OpResultCode_OPRC_Sucess
sceneEx.SetLastOpPos(int32(playerEx.GetPos()))
sceneEx.RefreshPlayerHandLimitTimeOut()
}
}
if opRetCode == tienlen.OpResultCode_OPRC_Sucess {
isBomb := rule.IsFourBomb(delCards)
if isBomb {
sceneEx.isKongBomb = true
}
}
sceneEx.UnmarkPass()
}
} else { //当前操作者和上一个操作者不是同一个人，必压制
if !playerEx.isPass {
lastOpPlayer := sceneEx.GetLastOpPlayer()
//logger.Logger.Trace("ScenePlayerOpStateTienLen,5params:", params, " lastOpPlayer:", lastOpPlayer)
if lastOpPlayer != nil && len(lastOpPlayer.delCards) != 0 {
lastDelCards := lastOpPlayer.delCards[len(lastOpPlayer.delCards)-1]
canDel, isBomb, bombScore := rule.CanDel(lastDelCards, delCards, sceneEx.IsTienLenToEnd())
if sceneEx.IsTienLenYule() {
canDel, isBomb, bombScore = rule.CanDel_yl(lastDelCards, delCards, sceneEx.IsTienLenToEnd())
}
//logger.Logger.Trace("ScenePlayerOpStateTienLen,6params:", params, " canDel:", canDel, " lastDelCards:", lastDelCards)
if canDel {
if isBomb {
sceneEx.curBombPos = int32(playerEx.GetPos())
sceneEx.lastBombPos = sceneEx.lastOpPos
sceneEx.roundScore += bombScore
} else {
sceneEx.curBombPos = rule.InvalidePos
sceneEx.lastBombPos = rule.InvalidePos
sceneEx.roundScore = 0
}
isDel := sceneEx.DelCards(playerEx, delCards)
//logger.Logger.Trace("ScenePlayerOpStateTienLen,7params:", params, " isDel:", isDel)
if isDel {
playerEx.RefreshThinkLongCnt(time.Now().Sub(sceneEx.StateStartTime), false)
nextPos := sceneEx.DoNext(int32(playerEx.GetPos()))
if sceneEx.IsTienLenToEnd() && nextPos == rule.InvalidePos {
sceneEx.UnmarkPass()
sceneEx.DoNext(int32(playerEx.GetPos()))
}
sceneEx.SetLastOpPos(int32(playerEx.GetPos()))
sceneEx.RefreshPlayerHandLimitTimeOut()
opRetCode = tienlen.OpResultCode_OPRC_Sucess
sceneEx.isKongBomb = false
}
}
}
}
}
}
}
case rule.TienLenPlayerOpPass: //过牌
if int32(playerEx.GetPos()) == sceneEx.lastOpPos { //当前操作者和上一个操作者是同一个人，必出牌，不能过牌
opRetCode = tienlen.OpResultCode_OPRC_Error
} else {
if sceneEx.lastOpPos != rule.InvalidePos {
playerEx.RefreshThinkLongCnt(time.Now().Sub(sceneEx.StateStartTime), false)
sceneEx.card_play_action_seq = append(sceneEx.card_play_action_seq, fmt.Sprintf("%v-过", playerEx.GetPos()))
sceneEx.card_play_action_seq_int32 = append(sceneEx.card_play_action_seq_int32, []int32{-1})
nextPos := sceneEx.DoNext(int32(playerEx.GetPos()))
if sceneEx.IsTienLenToEnd() && nextPos == rule.InvalidePos {
sceneEx.UnmarkPass()
nextPos = sceneEx.DoNext(int32(playerEx.GetPos()))
sceneEx.SetLastOpPos(int32(nextPos))
}
sceneEx.RefreshPlayerHandLimitTimeOut()
opRetCode = tienlen.OpResultCode_OPRC_Sucess
playerEx.isPass = true
if nextPos == sceneEx.lastOpPos { //一轮都不出牌
sceneEx.TrySmallGameBilled()
}
}
}
case rule.TienLenPlayerClientHintCards:
if int32(playerEx.GetPos()) == sceneEx.lastOpPos || sceneEx.lastOpPos == rule.InvalidePos {
logger.Logger.Trace("ScenePlayerOpStateTienLen,107 OPRC_Error:", params, " opcode:", opcode, " snid:", p.SnId, " pos:", playerEx.GetPos())
} else {
if len(params) > 0 {
sceneEx.cHintCards = make([]int32, len(params)+1)
sceneEx.cHintCards[0] = p.SnId
copy(sceneEx.cHintCards[1:], common.Int64ToInt32(params))
opRetCode = tienlen.OpResultCode_OPRC_Hint
}
}
default:
opRetCode = tienlen.OpResultCode_OPRC_Error
}
//next
if opRetCode == tienlen.OpResultCode_OPRC_Sucess {
finishFunc := func() {
switch opRetCode {
case tienlen.OpResultCode_OPRC_Sucess:
this.BroadcastPlayerSToCOp(s, playerEx.SnId, playerEx.GetPos(), opcode, opRetCode, params)
delCardNum := 0
@ -1388,13 +1204,225 @@ func (this *ScenePlayerOpStateTienLen) OnPlayerOp(s *base.Scene, p *base.Player,
} else {
sceneEx.BroadcastOpPos()
}
} else if opRetCode == tienlen.OpResultCode_OPRC_Error {
case tienlen.OpResultCode_OPRC_Error:
this.OnPlayerSToCOp(s, p, playerEx.GetPos(), opcode, opRetCode, params)
logger.Logger.Trace("ScenePlayerOpStateTienLen,100 OPRC_Error:", params, " opcode:", opcode, " snid:", p.SnId, " pos:", playerEx.GetPos())
}
}
switch int32(opcode) {
case rule.TienLenPlayerOpPlay: //出牌
var delCards []int32
checkCardsFunc := func() bool {
for _, card := range params {
isHave := false
for _, card := range playerEx.cards { //去手牌里找找看有没有
if card == card && card != rule.InvalideCard {
isHave = true
}
}
if isHave {
delCards = append(delCards, int32(card))
} else {
return false
}
}
return len(delCards) == len(params) && len(delCards) > 0
}
if !checkCardsFunc() {
logger.Logger.Errorf("出牌错误 snid:%v, pos:%v, cards:%v", p.SnId, playerEx.GetPos(), params)
finishFunc()
return true
}
isRule, _ := rule.RulePopEnable(delCards)
ruleType := rule.Tienlen_Pass
if sceneEx.IsTienLenYule() {
isRule, ruleType = rule.RulePopEnable_yl(delCards)
}
if !isRule {
logger.Logger.Errorf("出牌牌型错误 snid:%v, pos:%v, cards:%v", p.SnId, playerEx.GetPos(), params)
finishFunc()
return true
}
switch {
case sceneEx.IsFirst(playerEx.GetPos()):
//当前操作者和上一个操作者是同一个人，必出牌
if ruleType == rule.Plane_Single { //飞机带单只能最后一手出
haveCardNum := 0
for _, card := range playerEx.cards {
if card != rule.InvalideCard {
haveCardNum++
}
}
if len(delCards) != haveCardNum {
logger.Logger.Trace("飞机带单只能最后一手出 Plane_Single, delCards:", delCards, " haveCardNum:", haveCardNum)
finishFunc()
return true
}
}
if sceneEx.lastOpPos == rule.InvalidePos { //首出玩家
//有赢家，赢家先出，出牌不受限制
//无赢家，手持最小牌先出，最小牌必先出
winPos := sceneEx.FindWinPos()
//logger.Logger.Trace("ScenePlayerOpStateTienLen,8params:", params, " winPos:", winPos)
if winPos == -1 { //无赢家
haveMinCard := false
for _, card := range delCards {
if card == sceneEx.curMinCard { //最小牌必先出
haveMinCard = true
}
}
//logger.Logger.Trace("ScenePlayerOpStateTienLen,9params:", params, " curMinCard:", sceneEx.curMinCard, " haveMinCard", haveMinCard)
if !haveMinCard {
finishFunc()
return true
}
}
isDel := sceneEx.DelCards(playerEx, delCards)
//logger.Logger.Trace("ScenePlayerOpStateTienLen,3params:", params, " isDel:", isDel)
if isDel {
playerEx.RefreshThinkLongCnt(time.Now().Sub(sceneEx.StateStartTime), false)
sceneEx.DoNext(int32(playerEx.GetPos()))
opRetCode = tienlen.OpResultCode_OPRC_Sucess
sceneEx.SetLastOpPos(int32(playerEx.GetPos()))
sceneEx.RefreshPlayerHandLimitTimeOut()
}
} else {
isDel := sceneEx.DelCards(playerEx, delCards)
//logger.Logger.Trace("ScenePlayerOpStateTienLen,4params:", params, " isDel:", isDel)
if isDel {
playerEx.RefreshThinkLongCnt(time.Now().Sub(sceneEx.StateStartTime), false)
nextPos := sceneEx.DoNext(int32(playerEx.GetPos()))
//logger.Logger.Trace("ScenePlayerOpStateTienLen,4paramssss:", params, " nextPos:", nextPos)
if sceneEx.IsTienLenToEnd() && nextPos == rule.InvalidePos {
// 新一轮
sceneEx.UnmarkPass()
nextPos = sceneEx.DoNext(int32(playerEx.GetPos()))
//logger.Logger.Trace("ScenePlayerOpStateTienLen,4paramssss:", params, " nextPos:", nextPos)
}
opRetCode = tienlen.OpResultCode_OPRC_Sucess
sceneEx.SetLastOpPos(int32(playerEx.GetPos()))
sceneEx.RefreshPlayerHandLimitTimeOut()
}
}
if opRetCode == tienlen.OpResultCode_OPRC_Sucess {
isBomb := rule.IsFourBomb(delCards)
if isBomb {
sceneEx.isKongBomb = true
}
}
sceneEx.UnmarkPass()
default:
//当前操作者和上一个操作者不是同一个人，必压制
if playerEx.isPass {
finishFunc()
return true
}
lastOpPlayer := sceneEx.GetLastOpPlayer()
//logger.Logger.Trace("ScenePlayerOpStateTienLen,5params:", params, " lastOpPlayer:", lastOpPlayer)
if lastOpPlayer == nil || len(lastOpPlayer.delCards) == 0 {
finishFunc()
return true
}
lastDelCards := lastOpPlayer.delCards[len(lastOpPlayer.delCards)-1]
canDel, isBomb, bombScore := rule.CanDel(lastDelCards, delCards, sceneEx.IsTienLenToEnd())
if sceneEx.IsTienLenYule() {
canDel, isBomb, bombScore = rule.CanDel_yl(lastDelCards, delCards, sceneEx.IsTienLenToEnd())
}
//logger.Logger.Trace("ScenePlayerOpStateTienLen,6params:", params, " canDel:", canDel, " lastDelCards:", lastDelCards)
if !canDel {
finishFunc()
return true
}
if isBomb {
sceneEx.curBombPos = int32(playerEx.GetPos())
sceneEx.lastBombPos = sceneEx.lastOpPos
sceneEx.roundScore += bombScore
} else {
sceneEx.curBombPos = rule.InvalidePos
sceneEx.lastBombPos = rule.InvalidePos
sceneEx.roundScore = 0
}
isDel := sceneEx.DelCards(playerEx, delCards)
//logger.Logger.Trace("ScenePlayerOpStateTienLen,7params:", params, " isDel:", isDel)
if !isDel {
finishFunc()
return true
}
playerEx.RefreshThinkLongCnt(time.Now().Sub(sceneEx.StateStartTime), false)
nextPos := sceneEx.DoNext(int32(playerEx.GetPos()))
if sceneEx.IsTienLenToEnd() && nextPos == rule.InvalidePos {
sceneEx.UnmarkPass()
sceneEx.DoNext(int32(playerEx.GetPos()))
}
sceneEx.SetLastOpPos(int32(playerEx.GetPos()))
opRetCode = tienlen.OpResultCode_OPRC_Sucess
sceneEx.isKongBomb = false
sceneEx.RefreshPlayerHandLimitTimeOut()
}
case rule.TienLenPlayerOpPass: //过牌
//当前操作者和上一个操作者是同一个人，必出牌，不能过牌
if int32(playerEx.GetPos()) == sceneEx.lastOpPos || sceneEx.lastOpPos != rule.InvalidePos {
finishFunc()
return true
}
playerEx.RefreshThinkLongCnt(time.Now().Sub(sceneEx.StateStartTime), false)
sceneEx.card_play_action_seq = append(sceneEx.card_play_action_seq, fmt.Sprintf("%v-过", playerEx.GetPos()))
sceneEx.card_play_action_seq_int32 = append(sceneEx.card_play_action_seq_int32, []int32{-1})
nextPos := sceneEx.DoNext(int32(playerEx.GetPos()))
if sceneEx.IsTienLenToEnd() && nextPos == rule.InvalidePos {
sceneEx.UnmarkPass()
nextPos = sceneEx.DoNext(int32(playerEx.GetPos()))
sceneEx.SetLastOpPos(nextPos)
}
sceneEx.RefreshPlayerHandLimitTimeOut()
opRetCode = tienlen.OpResultCode_OPRC_Sucess
playerEx.isPass = true
if nextPos == sceneEx.lastOpPos { //一轮都不出牌
sceneEx.TrySmallGameBilled()
}
case rule.TienLenPlayerClientHintCards:
if int32(playerEx.GetPos()) == sceneEx.lastOpPos || sceneEx.lastOpPos == rule.InvalidePos {
logger.Logger.Trace("ScenePlayerOpStateTienLen,107 OPRC_Error:", params, " opcode:", opcode, " snid:", p.SnId, " pos:", playerEx.GetPos())
} else {
if len(params) > 0 {
sceneEx.cHintCards = make([]int32, len(params)+1)
sceneEx.cHintCards[0] = p.SnId
copy(sceneEx.cHintCards[1:], common.Int64ToInt32(params))
opRetCode = tienlen.OpResultCode_OPRC_Hint
}
}
default:
opRetCode = tienlen.OpResultCode_OPRC_Error
}
finishFunc()
return true
}

6
worldsrv/action_friend.go
View File

@ -301,11 +301,13 @@ func (this *CSInviteFriendHandler) Process(s *netlib.Session, packetid int, data
SrcHead: proto.Int32(p.Head),
SrcHeadUrl: proto.String(p.HeadUrl),
OpRetCode: opRetCode,
GameId: proto.Int(p.scene.gameId),
RoomId: proto.Int(p.scene.sceneId),
Pos: proto.Int32(msg.GetPos()),
RoleId: int32(roleId),
}
if p.scene != nil {
pack.GameId = int32(p.scene.gameId)
pack.RoomId = int32(p.scene.sceneId)
}
proto.SetDefaults(pack)
player.SendToClient(int(friend.FriendPacketID_PACKET_SCInviteFriend), pack)
logger.Logger.Trace("SCInviteFriendHandler: ", pack)

2
worldsrv/coinscenemgr.go
View File

@ -330,7 +330,7 @@ func (m *CoinSceneMgr) TouchCreateRoom(platform string, gameFreeId int32) {
return
}
gf := PlatformMgrSingleton.GetGameFree(platform, gameFreeId)
if gf.Status && gf.DbGameFree.GetCreateRoomNum() > 0 {
if gf != nil && gf.GetDbGameFree().GetCreateRoomNum() > 0 {
logger.Logger.Tracef("TouchCreateRoom platform:%v gameFreeId:%v", platform, gameFreeId)
m.delayCache = append(m.delayCache, &CreateRoomCache{
platformName: platform,

2
worldsrv/coinscenepool.go
View File

@ -270,7 +270,7 @@ func (csp *CoinScenePool) playerEnter(p *Player, roomId int32, exclude []int32,
logger.Logger.Infof("(csp *CoinScenePool) PlayerEnter create new scene:%v snid:%v gamefreeid:%v", scene.sceneId, p.SnId, csp.ID())
csp.AddScene(scene)
} else {
logger.Logger.Errorf("Create %v scene failed.", csp.ID())
logger.Logger.Warnf("Create %v scene failed.", csp.ID())
}
}

4
worldsrv/coinscenepool_local.go
View File

@ -212,14 +212,14 @@ func (l *CoinScenePoolLocal) NewScene(pool *CoinScenePool, p *Player) *Scene {
}
}
if dbCreateRoom == nil {
logger.Logger.Tracef("CoinScenePool CreateLocalGameNewScene failed! playerTakeCoin:%v ", playerTakeCoin)
logger.Logger.Errorf("CoinScenePool CreateLocalGameNewScene failed! playerTakeCoin:%v ", playerTakeCoin)
return nil
}
if len(dbCreateRoom.GetBetRange()) != 0 && dbCreateRoom.GetBetRange()[0] != 0 {
baseScore = common.RandInt32Slice(dbCreateRoom.GetBetRange())
}
if baseScore == 0 {
logger.Logger.Tracef("CoinScenePool CreateLocalGameNewScene failed! BaseScore==0")
logger.Logger.Errorf("CoinScenePool CreateLocalGameNewScene failed! BaseScore==0")
return nil
}
scene := SceneMgrSingleton.CreateScene(&CreateSceneParam{

2
worldsrv/friendmgr.go
View File

@ -779,7 +779,7 @@ func (this *FriendMgr) FriendRefuse(p *Player, destP *model.BindFriend) {
}), task.CompleteNotifyWrapper(func(data interface{}, tt task.Task) {
//拒绝了不提醒
if data != nil {
logger.Logger.Error("FriendRefuse data:", data)
logger.Logger.Warn("FriendRefuse data:", data)
SendToClick(friend.OpResultCode_OPRC_Error)
return
}

4
worldsrv/scenemgr.go
View File

@ -507,21 +507,25 @@ type CreateSceneParam struct {
func (m *SceneMgr) CreateScene(args *CreateSceneParam) *Scene {
logger.Logger.Tracef("SceneMgr NewScene %v", args)
if args.GF == nil {
logger.Logger.Errorf("SceneMgr NewScene GameFree is nil")
return nil
}
if args.Platform == nil {
logger.Logger.Errorf("SceneMgr NewScene Platform is nil")
return nil
}
if args.GS == nil {
args.GS = GameSessMgrSington.GetMinLoadSess(int(args.GF.GetGameId()))
}
if args.GS == nil {
logger.Logger.Errorf("SceneMgr NewScene GameServer is nil")
return nil
}
// 创建房间
s := NewScene(args)
if s == nil {
logger.Logger.Errorf("SceneMgr NewScene Scene is nil")
return nil
}
m.scenes[args.RoomId] = s

2
worldsrv/tournament.go
View File

@ -1578,7 +1578,7 @@ func (this *Tournament) sendPromotionInfo(mc *PlayerMatchContext, sortId int64,
}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
defer wg.Done()
if err != nil || res.GetCode() == "" || res.GetTag() != webapiproto.TagCode_SUCCESS {
logger.Logger.Errorf("获取兑换码失败 snid:%v itemID:%v res:%v err:%v", mc.p.SnId, data.Id, res, err)
logger.Logger.Warnf("获取兑换码失败 snid:%v itemID:%v res:%v err:%v", mc.p.SnId, data.Id, res, err)
return
}
item.Code = res.GetCode()