pokerbull添加play交易执行

plugin/dapp/pokerbull/commands/game.go

@@ -28,6 +28,7 @@ func PokerBullCmd() *cobra.Command {
 		PokerBullContinueRawTxCmd(),
 		PokerBullQuitRawTxCmd(),
 		PokerBullQueryResultRawTxCmd(),
+		PokerBullPlayRawTxCmd(),
 	)
 
 	return cmd
@@ -45,7 +46,7 @@ func PokerBullStartRawTxCmd() *cobra.Command {
 }
 
 func addPokerbullStartFlags(cmd *cobra.Command) {
-	cmd.Flags().Uint64P("value", "a", 0, "value")
+	cmd.Flags().Uint64P("value", "v", 0, "value")
 	cmd.MarkFlagRequired("value")
 
 	cmd.Flags().Uint32P("playerCount", "p", 0, "player count")
@@ -121,7 +122,7 @@ func pokerbullQuit(cmd *cobra.Command, args []string) {
 
 	params := &rpctypes.CreateTxIn{
 		Execer:     types.ExecName(pkt.PokerBullX),
-		ActionName: pkt.CreatequitTx,
+		ActionName: pkt.CreateQuitTx,
 		Payload:    []byte(fmt.Sprintf("{\"gameId\":\"%s\"}", gameID)),
 	}
 
@@ -130,6 +131,54 @@ func pokerbullQuit(cmd *cobra.Command, args []string) {
 	ctx.RunWithoutMarshal()
 }
 
+// PokerBullPlayRawTxCmd 生成已匹配玩家游戏命令行
+func PokerBullPlayRawTxCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "play",
+		Short: "Play game",
+		Run:   pokerbullPlay,
+	}
+	addPokerbullPlayFlags(cmd)
+	return cmd
+}
+
+func addPokerbullPlayFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("gameID", "g", "", "game ID")
+	cmd.MarkFlagRequired("gameID")
+	cmd.Flags().Uint32P("round", "r", 0, "round")
+	cmd.MarkFlagRequired("round")
+	cmd.Flags().Uint64P("value", "v", 0, "value")
+	cmd.MarkFlagRequired("value")
+	cmd.Flags().StringArrayP("address", "a", nil, "address")
+	cmd.MarkFlagRequired("address")
+}
+
+func pokerbullPlay(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	gameID, _ := cmd.Flags().GetString("gameID")
+	round, _ := cmd.Flags().GetUint32("round")
+	value, _ := cmd.Flags().GetUint64("value")
+	address, _ := cmd.Flags().GetStringArray("address")
+
+	payload := &pkt.PBGamePlay{
+		GameId: gameID,
+		Value:  int64(value)*types.Coin,
+		Round:  int32(round),
+	}
+	payload.Address = make([]string, len(address))
+	copy(payload.Address, address)
+
+	params := &rpctypes.CreateTxIn{
+		Execer:     types.ExecName(pkt.PokerBullX),
+		ActionName: pkt.CreatePlayTx,
+		Payload:    types.MustPBToJSON(payload),
+	}
+
+	var res string
+	ctx := jsonrpc.NewRPCCtx(rpcLaddr, "Chain33.CreateTransaction", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
 // PokerBullQueryResultRawTxCmd 查询命令行
 func PokerBullQueryResultRawTxCmd() *cobra.Command {
 	cmd := &cobra.Command{

plugin/dapp/pokerbull/executor/exec.go

@@ -26,3 +26,9 @@ func (c *PokerBull) Exec_Quit(payload *pkt.PBGameQuit, tx *types.Transaction, in
 	action := NewAction(c, tx, index)
 	return action.GameQuit(payload)
 }
+
+// Exec_Play 已匹配玩家直接开始游戏
+func (c *PokerBull) Exec_Play(payload *pkt.PBGamePlay, tx *types.Transaction, index int) (*types.Receipt, error) {
+	action := NewAction(c, tx, index)
+	return action.GamePlay(payload)
+}

plugin/dapp/pokerbull/executor/exec_local.go

@@ -57,7 +57,7 @@ func (c *PokerBull) execLocal(receipt *types.ReceiptData) (*types.LocalDBSet, er
 	dbSet := &types.LocalDBSet{}
 	for i := 0; i < len(receipt.Logs); i++ {
 		item := receipt.Logs[i]
-		if item.Ty == pkt.TyLogPBGameStart || item.Ty == pkt.TyLogPBGameContinue || item.Ty == pkt.TyLogPBGameQuit {
+		if item.Ty == pkt.TyLogPBGameStart || item.Ty == pkt.TyLogPBGameContinue || item.Ty == pkt.TyLogPBGameQuit || item.Ty == pkt.TyLogPBGamePlay {
 			var Gamelog pkt.ReceiptPBGame
 			err := types.Decode(item.Log, &Gamelog)
 			if err != nil {
@@ -84,3 +84,8 @@ func (c *PokerBull) ExecLocal_Continue(payload *pkt.PBGameContinue, tx *types.Tr
 func (c *PokerBull) ExecLocal_Quit(payload *pkt.PBGameQuit, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
 	return c.execLocal(receiptData)
 }
+
+// ExecLocal_Play 已匹配游戏交易local执行
+func (c *PokerBull) ExecLocal_Play(payload *pkt.PBGamePlay, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	return c.execLocal(receiptData)
+}
\ No newline at end of file

plugin/dapp/pokerbull/executor/pokerbulldb.go

@@ -5,7 +5,6 @@
 package executor
 
 import (
-	"errors"
 	"fmt"
 	"sort"
 	"strconv"
@@ -17,6 +16,7 @@ import (
 	"github.com/33cn/chain33/types"
 	pkt "github.com/33cn/plugin/plugin/dapp/pokerbull/types"
 	"time"
+	"strings"
 )
 
 // Action 斗牛action结构
@@ -184,6 +184,8 @@ func (action *Action) GetReceiptLog(game *pkt.PokerBull) *types.ReceiptLog {
 		log.Ty = pkt.TyLogPBGameContinue
 	} else if game.Status == pkt.PBGameActionQuit {
 		log.Ty = pkt.TyLogPBGameQuit
+	} else if game.Status == pkt.PBGameActionPlay {
+		log.Ty = pkt.TyLogPBGamePlay
 	}
 
 	r.GameId = game.GameId
@@ -328,11 +330,11 @@ func (action *Action) settleDealerAccount(lastAddress string, game *pkt.PokerBul
 	result := action.calculateDealer(game)
 	for _, hand := range result.Hands {
 		// 最后一名玩家没有冻结
-		if hand.Address != lastAddress {
+		if lastAddress != "" && hand.Address != lastAddress {
 			receipt, err := action.coinsAccount.ExecActive(hand.Address, action.execaddr, game.GetValue()*PokerbullLeverageMax)
 			if err != nil {
-				logger.Error("GameSettleDealer.ExecActive", "addr", hand.Address, "execaddr", action.execaddr, "amount", game.GetValue(),
-					"err", err)
+				logger.Error("GameSettleDealer.ExecActive", "GameID", game.GetGameId(), "addr", hand.Address,
+					"execaddr", action.execaddr, "amount", game.GetValue(), "err", err)
 				return nil, nil, err
 			}
 			logs = append(logs, receipt.Logs...)
@@ -347,16 +349,16 @@ func (action *Action) settleDealerAccount(lastAddress string, game *pkt.PokerBul
 				receipt, err = action.coinsAccount.ExecTransfer(result.Dealer, hand.Address, action.execaddr, game.GetValue()*int64(hand.Leverage))
 				if err != nil {
 					action.coinsAccount.ExecFrozen(hand.Address, action.execaddr, game.GetValue()) // rollback
-					logger.Error("GameSettleDealer.ExecTransfer", "addr", hand.Address, "execaddr", action.execaddr,
-						"amount", game.GetValue()*int64(hand.Leverage), "err", err)
+					logger.Error("GameSettleDealer.ExecTransfer", "GameID", game.GetGameId(), "addr", hand.Address,
+						"execaddr", action.execaddr, "amount", game.GetValue()*int64(hand.Leverage), "err", err)
 					return nil, nil, err
 				}
 			} else {
 				receipt, err = action.coinsAccount.ExecTransfer(hand.Address, result.Dealer, action.execaddr, game.GetValue()*int64(result.DealerLeverage))
 				if err != nil {
 					action.coinsAccount.ExecFrozen(hand.Address, action.execaddr, game.GetValue()) // rollback
-					logger.Error("GameSettleDealer.ExecTransfer", "addr", hand.Address, "execaddr", action.execaddr,
-						"amount", game.GetValue()*int64(result.DealerLeverage), "err", err)
+					logger.Error("GameSettleDealer.ExecTransfer", "GameID", game.GetGameId(), "addr", hand.Address,
+						"execaddr", action.execaddr, "amount", game.GetValue()*int64(result.DealerLeverage), "err", err)
 					return nil, nil, err
 				}
 			}
@@ -376,11 +378,11 @@ func (action *Action) settleDefaultAccount(lastAddress string, game *pkt.PokerBu
 
 	for _, player := range game.Players {
 		// 最后一名玩家没有冻结
-		if player.Address != lastAddress {
+		if lastAddress != "" && player.Address != lastAddress {
 			receipt, err := action.coinsAccount.ExecActive(player.GetAddress(), action.execaddr, game.GetValue()*PokerbullLeverageMax)
 			if err != nil {
-				logger.Error("GameSettleDefault.ExecActive", "addr", player.GetAddress(), "execaddr", action.execaddr,
-					"amount", game.GetValue()*PokerbullLeverageMax, "err", err)
+				logger.Error("GameSettleDefault.ExecActive", "GameID", game.GetGameId(), "addr", player.GetAddress(),
+					"execaddr", action.execaddr, "amount", game.GetValue()*PokerbullLeverageMax, "err", err)
 				return nil, nil, err
 			}
 			logs = append(logs, receipt.Logs...)
@@ -392,8 +394,8 @@ func (action *Action) settleDefaultAccount(lastAddress string, game *pkt.PokerBu
 			receipt, err := action.coinsAccount.ExecTransfer(player.Address, result.Winner, action.execaddr, game.GetValue() /**int64(result.Leverage)*/) //TODO Dealer:暂时不支持倍数
 			if err != nil {
 				action.coinsAccount.ExecFrozen(result.Winner, action.execaddr, game.GetValue()) // rollback
-				logger.Error("GameSettleDefault.ExecTransfer", "addr", result.Winner, "execaddr", action.execaddr,
-					"amount", game.GetValue() /**int64(result.Leverage)*/, "err", err) //TODO Dealer:暂时不支持倍数
+				logger.Error("GameSettleDefault.ExecTransfer", "GameID", game.GetGameId(), "addr", result.Winner,
+					"execaddr", action.execaddr, "amount", game.GetValue() /**int64(result.Leverage)*/, "err", err) //TODO Dealer:暂时不支持倍数
 				return nil, nil, err
 			}
 			logs = append(logs, receipt.Logs...)
@@ -439,8 +441,8 @@ func (action *Action) settleAccount(lastAddress string, game *pkt.PokerBull) ([]
 }
 
 func (action *Action) genTxRnd(txhash []byte) (int64, error) {
-	randbyte := make([]byte, 7)
-	for i := 0; i < 7; i++ {
+	randbyte := make([]byte, 6)
+	for i := 0; i < 6; i++ {
 		randbyte[i] = txhash[i]
 	}
 
@@ -453,15 +455,35 @@ func (action *Action) genTxRnd(txhash []byte) (int64, error) {
 	return randint, nil
 }
 
-func (action *Action) checkDupPlayerAddress(id string, pbPlayers []*pkt.PBPlayer) error {
+func (action *Action) genTxRnds(txhash []byte, playnum int32) ([]int64, error) {
+	rands := make([]int64, playnum)
+
+	for i := 0; i < int(playnum); i++ {
+		randbyte := make([]byte, 6)
+		for j := 0; j < 6; j++ {
+			randbyte[j] = txhash[i*6+j]
+		}
+
+		randstr := common.ToHex(randbyte)
+		randint, err := strconv.ParseInt(randstr, 0, 64)
+		if err != nil {
+			return nil, err
+		}
+
+		rands[i] = randint
+	}
+
+	return rands, nil
+}
+
+func (action *Action) checkPlayerAddressExist(pbPlayers []*pkt.PBPlayer) bool {
 	for _, player := range pbPlayers {
 		if action.fromaddr == player.Address {
-			logger.Error("Poker bull game start", "addr", action.fromaddr, "execaddr", action.execaddr, "Already in a game", id)
-			return errors.New("Address is already in a game")
+			return true
 		}
 	}
 
-	return nil
+	return false
 }
 
 // 新建一局游戏
@@ -476,8 +498,7 @@ func (action *Action) newGame(gameID string, start *pkt.PBGameStart) (*pkt.Poker
 	//TODO 庄家检查闲家数量倍数的资金
 	if pkt.DefaultStyle == pkt.PlayStyleDealer {
 		if !action.CheckExecAccountBalance(action.fromaddr, start.GetValue()*PokerbullLeverageMax*int64(start.PlayerNum-1), 0) {
-			logger.Error("GameStart", "addr", action.fromaddr, "execaddr", action.execaddr, "id",
-				gameID, "err", types.ErrNoBalance)
+			logger.Error("GameStart", "GameID", gameID, "addr", action.fromaddr, "execaddr", action.execaddr, "err", types.ErrNoBalance)
 			return nil, types.ErrNoBalance
 		}
 	}
@@ -510,7 +531,8 @@ func (action *Action) selectGameFromIds(ids []string, value int64) *pkt.PokerBul
 		id := ids[num]
 		game, err := action.readGame(id)
 		if err != nil {
-			logger.Error("Poker bull game start", "addr", action.fromaddr, "execaddr", action.execaddr, "get game failed", id, "err", err)
+			logger.Error("Poker bull game start", "GameID", id,  "addr", action.fromaddr, "execaddr", action.execaddr,
+				"get game failed", "err", err)
 			continue
 		}
 
@@ -520,19 +542,22 @@ func (action *Action) selectGameFromIds(ids []string, value int64) *pkt.PokerBul
 		}
 
 		//不能自己和自己玩
-		if action.checkDupPlayerAddress(id, game.Players) != nil {
+		if action.checkPlayerAddressExist(game.Players) {
+			logger.Info(fmt.Sprintf("Player %s already exist in game %s", action.fromaddr, id))
 			continue
 		}
 
 		//选择合适赌注的游戏
 		if value == 0 && game.GetValue() != pkt.MinPlayValue {
 			if !action.CheckExecAccountBalance(action.fromaddr, game.GetValue(), 0) {
-				logger.Error("GameStart", "addr", action.fromaddr, "execaddr", action.execaddr, "id", id, "err", types.ErrNoBalance)
+				logger.Error("GameStart", "GameID", id, "addr", action.fromaddr, "execaddr", action.execaddr,
+					"err", types.ErrNoBalance)
 				continue
 			}
 		}
 
 		gameRet = game
+		logger.Info(fmt.Sprintf("Match a new game %s for player %s", id, action.fromaddr))
 		break
 	}
 	return gameRet
@@ -570,7 +595,7 @@ func (action *Action) GameStart(start *pkt.PBGameStart) (*types.Receipt, error)
 
 	gameID := common.ToHex(action.txhash)
 	if !action.CheckExecAccountBalance(action.fromaddr, start.GetValue()*PokerbullLeverageMax, 0) {
-		logger.Error("GameStart", "addr", action.fromaddr, "execaddr", action.execaddr, "id", gameID, "err", types.ErrNoBalance)
+		logger.Error("GameStart", "GameID", gameID, "addr", action.fromaddr, "execaddr", action.execaddr, "err", types.ErrNoBalance)
 		return nil, types.ErrNoBalance
 	}
 
@@ -600,7 +625,6 @@ func (action *Action) GameStart(start *pkt.PBGameStart) (*types.Receipt, error)
 				return nil, err
 			}
 		}
-		logger.Info(fmt.Sprintf("Match a new game %s for player %s", game.GameId, action.fromaddr))
 	}
 
 	//发牌随机数取txhash
@@ -636,7 +660,8 @@ func (action *Action) GameStart(start *pkt.PBGameStart) (*types.Receipt, error)
 		logger.Info(fmt.Sprintf("Game waiting: %s round: %d", game.GameId, game.Round))
 		receipt, err := action.coinsAccount.ExecFrozen(action.fromaddr, action.execaddr, start.GetValue()*PokerbullLeverageMax) //冻结子账户资金, 最后一位玩家不需要冻结
 		if err != nil {
-			logger.Error("GameCreate.ExecFrozen", "addr", action.fromaddr, "execaddr", action.execaddr, "amount", start.GetValue(), "err", err.Error())
+			logger.Error("GameCreate.ExecFrozen", "GameID", gameID, "addr", action.fromaddr, "execaddr", action.execaddr,
+				"amount", start.GetValue(), "err", err.Error())
 			return nil, err
 		}
 		logs = append(logs, receipt.Logs...)
@@ -675,14 +700,14 @@ func (action *Action) GameContinue(pbcontinue *pkt.PBGameContinue) (*types.Recei
 
 	game, err := action.readGame(pbcontinue.GetGameId())
 	if err != nil {
-		logger.Error("GameContinue", "addr", action.fromaddr, "execaddr", action.execaddr, "get game failed, gameID",
-			pbcontinue.GetGameId(), "err", err)
+		logger.Error("GameContinue", "GameID", pbcontinue.GetGameId(), "addr", action.fromaddr, "execaddr",
+			action.execaddr, "get game failed", "err", err)
 		return nil, err
 	}
 
 	if game.Status != pkt.PBGameActionContinue {
-		logger.Error("GameContinue", "addr", action.fromaddr, "execaddr", action.execaddr, "Status error, gameID",
-			pbcontinue.GetGameId())
+		logger.Error("GameContinue", "GameID", pbcontinue.GetGameId(), "addr", action.fromaddr, "execaddr",
+			action.execaddr, "Status error")
 		return nil, err
 	}
 	logger.Info(fmt.Sprintf("Continue pokerbull game %s from %s", game.GameId, action.fromaddr))
@@ -693,21 +718,21 @@ func (action *Action) GameContinue(pbcontinue *pkt.PBGameContinue) (*types.Recei
 		checkValue = checkValue * int64(game.PlayerNum-1)
 	}
 	if !action.CheckExecAccountBalance(action.fromaddr, checkValue, 0) {
-		logger.Error("GameContinue", "addr", action.fromaddr, "execaddr", action.execaddr, "id",
-			pbcontinue.GetGameId(), "err", types.ErrNoBalance)
+		logger.Error("GameContinue", "GameID", pbcontinue.GetGameId(), "addr", action.fromaddr, "execaddr",
+			action.execaddr, "err", types.ErrNoBalance)
 		return nil, types.ErrNoBalance
 	}
 
 	// 寻找对应玩家
 	pbplayer := getPlayerFromAddress(game.Players, action.fromaddr)
 	if pbplayer == nil {
-		logger.Error("GameContinue", "addr", action.fromaddr, "execaddr", action.execaddr, "get game player failed",
-			pbcontinue.GetGameId(), "err", types.ErrNotFound)
+		logger.Error("GameContinue", "GameID", pbcontinue.GetGameId(), "addr", action.fromaddr, "execaddr",
+			action.execaddr, "get game player failed", "err", types.ErrNotFound)
 		return nil, types.ErrNotFound
 	}
 	if pbplayer.Ready {
-		logger.Error("GameContinue", "addr", action.fromaddr, "execaddr", action.execaddr, "player has been ready",
-			pbcontinue.GetGameId(), "player", pbplayer.Address)
+		logger.Error("GameContinue", "GameID", pbcontinue.GetGameId(), "addr", action.fromaddr, "execaddr",
+			action.execaddr, "player has been ready")
 		return nil, fmt.Errorf("player %s has been ready", pbplayer.Address)
 	}
 
@@ -733,14 +758,15 @@ func (action *Action) GameContinue(pbcontinue *pkt.PBGameContinue) (*types.Recei
 		game.IsWaiting = false
 		game.PreStatus = pkt.PBGameActionContinue
 	} else {
-		logger.Info(fmt.Sprintf("Game waiting: %s round: %d", game.GameId))
+		logger.Info(fmt.Sprintf("Game waiting: %s round: %d", game.GameId, game.Round))
 		// 回合数加一次
 		if !game.IsWaiting {
 			game.Round++
 		}
 		receipt, err := action.coinsAccount.ExecFrozen(action.fromaddr, action.execaddr, game.GetValue()*PokerbullLeverageMax) //冻结子账户资金,最后一位玩家不需要冻结
 		if err != nil {
-			logger.Error("GameCreate.ExecFrozen", "addr", action.fromaddr, "execaddr", action.execaddr, "amount", game.GetValue(), "err", err.Error())
+			logger.Error("GameCreate.ExecFrozen", "GameID", pbcontinue.GetGameId(), "addr", action.fromaddr,
+				"execaddr", action.execaddr, "amount", game.GetValue(), "err", err.Error())
 			return nil, err
 		}
 		logs = append(logs, receipt.Logs...)
@@ -760,21 +786,30 @@ func (action *Action) GameQuit(pbend *pkt.PBGameQuit) (*types.Receipt, error) {
 	var logs []*types.ReceiptLog
 	var kv []*types.KeyValue
 
+	logger.Info(fmt.Sprintf("Quit pokerbull game %s", pbend.GameId))
 	game, err := action.readGame(pbend.GetGameId())
 	if err != nil {
-		logger.Error("GameEnd", "addr", action.fromaddr, "execaddr", action.execaddr, "get game failed",
-			pbend.GetGameId(), "err", err)
+		logger.Error("GameEnd", "GameID", pbend.GetGameId(), "addr", action.fromaddr, "execaddr",
+			action.execaddr, "get game failed", "err", err)
 		return nil, err
 	}
 
+	if !action.checkPlayerAddressExist(game.Players) {
+		if action.fromaddr != pkt.PlatformSignAddress {
+			logger.Error("GameEnd", "GameID", pbend.GetGameId(), "addr", action.fromaddr, "execaddr",
+				action.execaddr, "err", "permission denied")
+			return nil, fmt.Errorf("permission denied")
+		}
+	}
+
 	// 如果游戏没有开始，激活冻结账户
 	if game.IsWaiting {
 		if game.Status == pkt.PBGameActionStart {
 			for _, player := range game.Players {
 				receipt, err := action.coinsAccount.ExecActive(player.Address, action.execaddr, game.GetValue()*PokerbullLeverageMax)
 				if err != nil {
-					logger.Error("GameSettleDealer.ExecActive", "addr", player.Address, "execaddr", action.execaddr, "amount", game.GetValue(),
-						"err", err)
+					logger.Error("GameSettleDealer.ExecActive", "GameID", pbend.GetGameId(), "addr", player.Address,
+						"execaddr", action.execaddr, "amount", game.GetValue(), "err", err)
 					continue
 				}
 				logs = append(logs, receipt.Logs...)
@@ -788,8 +823,8 @@ func (action *Action) GameQuit(pbend *pkt.PBGameQuit) (*types.Receipt, error) {
 
 				receipt, err := action.coinsAccount.ExecActive(player.Address, action.execaddr, game.GetValue()*PokerbullLeverageMax)
 				if err != nil {
-					logger.Error("GameSettleDealer.ExecActive", "addr", player.Address, "execaddr", action.execaddr, "amount", game.GetValue(),
-						"err", err)
+					logger.Error("GameSettleDealer.ExecActive", "GameID", pbend.GetGameId(), "addr", player.Address,
+						"execaddr", action.execaddr, "amount", game.GetValue(), "err", err)
 					continue
 				}
 				logs = append(logs, receipt.Logs...)
@@ -811,6 +846,121 @@ func (action *Action) GameQuit(pbend *pkt.PBGameQuit) (*types.Receipt, error) {
 	return &types.Receipt{Ty: types.ExecOk, KV: kv, Logs: logs}, nil
 }
 
+// GamePlay 已匹配玩家直接游戏
+func (action *Action) GamePlay(pbplay *pkt.PBGamePlay) (*types.Receipt, error) {
+	var logs []*types.ReceiptLog
+	var kv []*types.KeyValue
+
+	logger.Info(fmt.Sprintf("Play pokerbull game %s, player:%s", pbplay.GameId, strings.Join(pbplay.Address, ",")))
+	// 校验签名地址
+	if action.fromaddr != pkt.PlatformSignAddress {
+		logger.Error("Pokerbull game play","GameID", pbplay.GetGameId(), "round", pbplay.Round, "value",
+			pbplay.Value, "players", strings.Join(pbplay.Address, ","),"err", "permission denied")
+		return nil, fmt.Errorf("game signing address not support")
+	}
+
+    // 检查玩家人数
+	if len(pbplay.Address) < pkt.MinPlayerNum || len(pbplay.Address) > pkt.MaxPlayerNum {
+		logger.Error("Pokerbull game play","GameID", pbplay.GetGameId(), "round", pbplay.Round, "value",
+			pbplay.Value, "players", strings.Join(pbplay.Address, ","),"err", "invalid player number")
+		return nil, fmt.Errorf("Invalid player number")
+	}
+
+	// 检查玩家地址余额
+	for _, addr := range pbplay.Address {
+		if !action.CheckExecAccountBalance(addr, pbplay.GetValue()*PokerbullLeverageMax, 0) {
+			logger.Error("GamePlay", "addr", addr, "execaddr", action.execaddr, "id", pbplay.GetGameId(), "err", types.ErrNoBalance)
+			return nil, types.ErrNoBalance
+		}
+	}
+
+	// 游戏存在则校验游戏状态，不存在则创建游戏
+	game,_ := action.readGame(pbplay.GetGameId())
+	if game != nil {
+		if game.Status == pkt.PBGameActionQuit {
+			logger.Error("Pokerbull game play","GameID", pbplay.GetGameId(), "round", pbplay.Round, "value",
+				pbplay.Value, "players", strings.Join(pbplay.Address, ","),"err", "already game over")
+			return nil, fmt.Errorf("already game over")
+		}
+
+		if game.Round + 1 != pbplay.Round {
+			logger.Error("Pokerbull game play","GameID", pbplay.GetGameId(), "round", pbplay.Round, "value",
+				pbplay.Value, "players", strings.Join(pbplay.Address, ","),"err", "game round error")
+		    return nil, fmt.Errorf("game round error")
+		}
+
+		if game.Value != pbplay.Value {
+			logger.Error("Pokerbull game play","GameID", pbplay.GetGameId(), "round", pbplay.Round, "value",
+				pbplay.Value, "players", strings.Join(pbplay.Address, ","),"err", "game value error")
+			return nil, fmt.Errorf("game value error")
+		}
+
+		// 获取发牌随机数
+		rands, err := action.genTxRnds(action.txhash, game.PlayerNum)
+		if err != nil {
+			logger.Error("Pokerbull game play", "GameID", pbplay.GetGameId(), "round", pbplay.Round, "value",
+				pbplay.Value, "players", strings.Join(pbplay.Address, ","), "err", err)
+			return nil, err
+		}
+
+		// 更新玩家信息
+		for i,player := range game.Players {
+			player.TxHash = rands[i]
+			player.MatchTime = time.Unix(action.blocktime, 0).Format("2006-01-02 15:04:05")
+		}
+
+		game.Round++
+		game.Status = pkt.PBGameActionContinue // 更新游戏状态
+		game.PreStatus = pkt.PBGameActionContinue
+	} else {
+		gameNew, err := action.newGame(pbplay.GameId, &pkt.PBGameStart{Value: pbplay.Value, PlayerNum: int32(len(pbplay.Address))})
+		if err != nil {
+			logger.Error("Pokerbull game play", "GameID", pbplay.GetGameId(), "round", pbplay.Round, "value",
+				pbplay.Value, "players", strings.Join(pbplay.Address, ","), "err", err)
+			return nil, err
+		}
+		game = gameNew
+
+		// 获取发牌随机数
+		rands, err := action.genTxRnds(action.txhash, game.PlayerNum)
+		if err != nil {
+			logger.Error("Pokerbull game play", "GameID", pbplay.GetGameId(), "round", pbplay.Round, "value",
+				pbplay.Value, "players", strings.Join(pbplay.Address, ","), "err", err)
+			return nil, err
+		}
+
+		// 创建玩家信息
+		for i, addr := range pbplay.Address {
+			player := &pkt.PBPlayer{
+				Address:   addr,
+				TxHash:    rands[i],
+				MatchTime: time.Unix(action.blocktime, 0).Format("2006-01-02 15:04:05"),
+			}
+			game.Players = append(game.Players, player)
+		}
+
+		game.Status = pkt.PBGameActionContinue // 更新游戏状态
+		game.PreStatus = pkt.PBGameActionStart
+	}
+
+	logger.Info(fmt.Sprintf("Game starting: %s round: %d", game.GameId, game.Round))
+	logsH, kvH, err := action.settleAccount("", game)
+	if err != nil {
+		return nil, err
+	}
+	logs = append(logs, logsH...)
+	kv = append(kv, kvH...)
+	game.PrevIndex = game.Index
+	game.Index = action.getIndex(game)
+	game.IsWaiting = false
+
+	receiptLog := action.GetReceiptLog(game)
+	logs = append(logs, receiptLog)
+	kv = append(kv, action.saveGame(game)...)
+
+	return &types.Receipt{Ty: types.ExecOk, KV: kv, Logs: logs}, nil
+}
+
 // HandSlice 一手牌
 type HandSlice []*pkt.PBHand
 

plugin/dapp/pokerbull/proto/pokerbull.proto

@@ -60,10 +60,11 @@ message PBPoker {
 //游戏状态
 message PBGameAction {
     oneof value {
-        PBGameStart start       = 1;
+        PBGameStart    start    = 1;
         PBGameContinue continue = 2;
-        PBGameQuit  quit        = 3;
-        PBGameQuery query       = 4;
+        PBGameQuit     quit     = 3;
+        PBGameQuery    query    = 4;
+        PBGamePlay     play     = 5;
     }
     int32 ty = 10;
 }
@@ -89,6 +90,14 @@ message PBGameQuery {
     string gameId = 1;
 }
 
+//已匹配玩家直接游戏
+message PBGamePlay {
+    string          gameId  = 1; //游戏id
+    int32           round   = 2; //当前游戏回合数
+    int64           value   = 3; //当前游戏赌注
+    repeated string address = 4; //玩家地址
+}
+
 //根据状态和游戏人数查找
 message QueryPBGameListByStatusAndPlayerNum {
     int32 status    = 1;

plugin/dapp/pokerbull/rpc/jrpc_channel_test.go

@@ -97,7 +97,7 @@ func testQuitRawTxCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
 	payload := &pty.PBGameQuit{GameId: "123"}
 	params := &rpctypes.CreateTxIn{
 		Execer:     types.ExecName(pty.PokerBullX),
-		ActionName: pty.CreatequitTx,
+		ActionName: pty.CreateQuitTx,
 		Payload:    types.MustPBToJSON(payload),
 	}
 	var res string

plugin/dapp/pokerbull/types/const.go

@@ -12,6 +12,7 @@ const (
 	PBGameActionContinue
 	PBGameActionQuit
 	PBGameActionQuery
+	PBGameActionPlay
 )
 
 const (
@@ -30,6 +31,8 @@ const (
 	TyLogPBGameQuit = 723
 	// TyLogPBGameQuery log for query PBgame
 	TyLogPBGameQuery = 724
+	// TyLogPBGamePlay log for play PBgame
+	TyLogPBGamePlay = 725
 )
 
 //包的名字可以通过配置文件来配置
@@ -56,8 +59,10 @@ const (
 	CreateStartTx = "Start"
 	// CreateContinueTx 创建继续交易
 	CreateContinueTx = "Continue"
-	// CreatequitTx 创建退出交易
-	CreatequitTx = "Quit"
+	// CreateQuitTx 创建退出交易
+	CreateQuitTx = "Quit"
+	// CreatePlayTx 创建已匹配玩家交易
+	CreatePlayTx = "Play"
 )
 
 const (
@@ -67,6 +72,8 @@ const (
 	DefaultCount = int32(20)
 	// MaxPlayerNum 最大玩家数
 	MaxPlayerNum = 5
+	// MinPlayerNum 最小玩家数
+	MinPlayerNum = 2
 	// MinPlayValue 最小赌注
 	MinPlayValue = 10 * types.Coin
 	// DefaultStyle 默认游戏类型
@@ -81,4 +88,6 @@ const (
 	DeveloperFee = int64(0.005 * float64(types.Coin))
 	// WinnerReturn 赢家回报率
 	WinnerReturn = types.Coin - DeveloperFee
+	// PlatformSignAddress 平台签名地址
+	PlatformSignAddress = "1Geb4ppNiAwMKKyrJgcis3JA57FkqsXvdR"
 )

plugin/dapp/pokerbull/types/pokerbull.pb.go

@@ -467,6 +467,7 @@ type PBGameAction struct {
 	//	*PBGameAction_Continue
 	//	*PBGameAction_Quit
 	//	*PBGameAction_Query
+	//	*PBGameAction_Play
 	Value                isPBGameAction_Value `protobuf_oneof:"value"`
 	Ty                   int32                `protobuf:"varint,10,opt,name=ty,proto3" json:"ty,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
@@ -519,6 +520,10 @@ type PBGameAction_Query struct {
 	Query *PBGameQuery `protobuf:"bytes,4,opt,name=query,proto3,oneof"`
 }
 
+type PBGameAction_Play struct {
+	Play *PBGamePlay `protobuf:"bytes,5,opt,name=play,proto3,oneof"`
+}
+
 func (*PBGameAction_Start) isPBGameAction_Value() {}
 
 func (*PBGameAction_Continue) isPBGameAction_Value() {}
@@ -527,6 +532,8 @@ func (*PBGameAction_Quit) isPBGameAction_Value() {}
 
 func (*PBGameAction_Query) isPBGameAction_Value() {}
 
+func (*PBGameAction_Play) isPBGameAction_Value() {}
+
 func (m *PBGameAction) GetValue() isPBGameAction_Value {
 	if m != nil {
 		return m.Value
@@ -562,6 +569,13 @@ func (m *PBGameAction) GetQuery() *PBGameQuery {
 	return nil
 }
 
+func (m *PBGameAction) GetPlay() *PBGamePlay {
+	if x, ok := m.GetValue().(*PBGameAction_Play); ok {
+		return x.Play
+	}
+	return nil
+}
+
 func (m *PBGameAction) GetTy() int32 {
 	if m != nil {
 		return m.Ty
@@ -576,6 +590,7 @@ func (*PBGameAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer)
 		(*PBGameAction_Continue)(nil),
 		(*PBGameAction_Quit)(nil),
 		(*PBGameAction_Query)(nil),
+		(*PBGameAction_Play)(nil),
 	}
 }
 
@@ -603,6 +618,11 @@ func _PBGameAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 		if err := b.EncodeMessage(x.Query); err != nil {
 			return err
 		}
+	case *PBGameAction_Play:
+		b.EncodeVarint(5<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Play); err != nil {
+			return err
+		}
 	case nil:
 	default:
 		return fmt.Errorf("PBGameAction.Value has unexpected type %T", x)
@@ -645,6 +665,14 @@ func _PBGameAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.B
 		err := b.DecodeMessage(msg)
 		m.Value = &PBGameAction_Query{msg}
 		return true, err
+	case 5: // value.play
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(PBGamePlay)
+		err := b.DecodeMessage(msg)
+		m.Value = &PBGameAction_Play{msg}
+		return true, err
 	default:
 		return false, nil
 	}
@@ -674,6 +702,11 @@ func _PBGameAction_OneofSizer(msg proto.Message) (n int) {
 		n += 1 // tag and wire
 		n += proto.SizeVarint(uint64(s))
 		n += s
+	case *PBGameAction_Play:
+		s := proto.Size(x.Play)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
 	case nil:
 	default:
 		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
@@ -849,6 +882,70 @@ func (m *PBGameQuery) GetGameId() string {
 	return ""
 }
 
+//已匹配玩家直接游戏
+type PBGamePlay struct {
+	GameId               string   `protobuf:"bytes,1,opt,name=gameId,proto3" json:"gameId,omitempty"`
+	Round                int32    `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
+	Value                int64    `protobuf:"varint,3,opt,name=value,proto3" json:"value,omitempty"`
+	Address              []string `protobuf:"bytes,4,rep,name=address,proto3" json:"address,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PBGamePlay) Reset()         { *m = PBGamePlay{} }
+func (m *PBGamePlay) String() string { return proto.CompactTextString(m) }
+func (*PBGamePlay) ProtoMessage()    {}
+func (*PBGamePlay) Descriptor() ([]byte, []int) {
+	return fileDescriptor_8d22e4ee2313e311, []int{10}
+}
+
+func (m *PBGamePlay) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PBGamePlay.Unmarshal(m, b)
+}
+func (m *PBGamePlay) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PBGamePlay.Marshal(b, m, deterministic)
+}
+func (m *PBGamePlay) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PBGamePlay.Merge(m, src)
+}
+func (m *PBGamePlay) XXX_Size() int {
+	return xxx_messageInfo_PBGamePlay.Size(m)
+}
+func (m *PBGamePlay) XXX_DiscardUnknown() {
+	xxx_messageInfo_PBGamePlay.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PBGamePlay proto.InternalMessageInfo
+
+func (m *PBGamePlay) GetGameId() string {
+	if m != nil {
+		return m.GameId
+	}
+	return ""
+}
+
+func (m *PBGamePlay) GetRound() int32 {
+	if m != nil {
+		return m.Round
+	}
+	return 0
+}
+
+func (m *PBGamePlay) GetValue() int64 {
+	if m != nil {
+		return m.Value
+	}
+	return 0
+}
+
+func (m *PBGamePlay) GetAddress() []string {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
 //根据状态和游戏人数查找
 type QueryPBGameListByStatusAndPlayerNum struct {
 	Status               int32    `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
@@ -863,7 +960,7 @@ func (m *QueryPBGameListByStatusAndPlayerNum) Reset()         { *m = QueryPBGame
 func (m *QueryPBGameListByStatusAndPlayerNum) String() string { return proto.CompactTextString(m) }
 func (*QueryPBGameListByStatusAndPlayerNum) ProtoMessage()    {}
 func (*QueryPBGameListByStatusAndPlayerNum) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{10}
+	return fileDescriptor_8d22e4ee2313e311, []int{11}
 }
 
 func (m *QueryPBGameListByStatusAndPlayerNum) XXX_Unmarshal(b []byte) error {
@@ -919,7 +1016,7 @@ func (m *PBGameRecord) Reset()         { *m = PBGameRecord{} }
 func (m *PBGameRecord) String() string { return proto.CompactTextString(m) }
 func (*PBGameRecord) ProtoMessage()    {}
 func (*PBGameRecord) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{11}
+	return fileDescriptor_8d22e4ee2313e311, []int{12}
 }
 
 func (m *PBGameRecord) XXX_Unmarshal(b []byte) error {
@@ -973,7 +1070,7 @@ func (m *PBGameIndexRecord) Reset()         { *m = PBGameIndexRecord{} }
 func (m *PBGameIndexRecord) String() string { return proto.CompactTextString(m) }
 func (*PBGameIndexRecord) ProtoMessage()    {}
 func (*PBGameIndexRecord) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{12}
+	return fileDescriptor_8d22e4ee2313e311, []int{13}
 }
 
 func (m *PBGameIndexRecord) XXX_Unmarshal(b []byte) error {
@@ -1019,7 +1116,7 @@ func (m *PBGameRecords) Reset()         { *m = PBGameRecords{} }
 func (m *PBGameRecords) String() string { return proto.CompactTextString(m) }
 func (*PBGameRecords) ProtoMessage()    {}
 func (*PBGameRecords) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{13}
+	return fileDescriptor_8d22e4ee2313e311, []int{14}
 }
 
 func (m *PBGameRecords) XXX_Unmarshal(b []byte) error {
@@ -1058,7 +1155,7 @@ func (m *PBGameIndexRecords) Reset()         { *m = PBGameIndexRecords{} }
 func (m *PBGameIndexRecords) String() string { return proto.CompactTextString(m) }
 func (*PBGameIndexRecords) ProtoMessage()    {}
 func (*PBGameIndexRecords) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{14}
+	return fileDescriptor_8d22e4ee2313e311, []int{15}
 }
 
 func (m *PBGameIndexRecords) XXX_Unmarshal(b []byte) error {
@@ -1100,7 +1197,7 @@ func (m *QueryPBGameInfo) Reset()         { *m = QueryPBGameInfo{} }
 func (m *QueryPBGameInfo) String() string { return proto.CompactTextString(m) }
 func (*QueryPBGameInfo) ProtoMessage()    {}
 func (*QueryPBGameInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{15}
+	return fileDescriptor_8d22e4ee2313e311, []int{16}
 }
 
 func (m *QueryPBGameInfo) XXX_Unmarshal(b []byte) error {
@@ -1160,7 +1257,7 @@ func (m *ReplyPBGame) Reset()         { *m = ReplyPBGame{} }
 func (m *ReplyPBGame) String() string { return proto.CompactTextString(m) }
 func (*ReplyPBGame) ProtoMessage()    {}
 func (*ReplyPBGame) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{16}
+	return fileDescriptor_8d22e4ee2313e311, []int{17}
 }
 
 func (m *ReplyPBGame) XXX_Unmarshal(b []byte) error {
@@ -1199,7 +1296,7 @@ func (m *QueryPBGameInfos) Reset()         { *m = QueryPBGameInfos{} }
 func (m *QueryPBGameInfos) String() string { return proto.CompactTextString(m) }
 func (*QueryPBGameInfos) ProtoMessage()    {}
 func (*QueryPBGameInfos) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{17}
+	return fileDescriptor_8d22e4ee2313e311, []int{18}
 }
 
 func (m *QueryPBGameInfos) XXX_Unmarshal(b []byte) error {
@@ -1238,7 +1335,7 @@ func (m *ReplyPBGameList) Reset()         { *m = ReplyPBGameList{} }
 func (m *ReplyPBGameList) String() string { return proto.CompactTextString(m) }
 func (*ReplyPBGameList) ProtoMessage()    {}
 func (*ReplyPBGameList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{18}
+	return fileDescriptor_8d22e4ee2313e311, []int{19}
 }
 
 func (m *ReplyPBGameList) XXX_Unmarshal(b []byte) error {
@@ -1279,7 +1376,7 @@ func (m *QueryPBGameByRound) Reset()         { *m = QueryPBGameByRound{} }
 func (m *QueryPBGameByRound) String() string { return proto.CompactTextString(m) }
 func (*QueryPBGameByRound) ProtoMessage()    {}
 func (*QueryPBGameByRound) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{19}
+	return fileDescriptor_8d22e4ee2313e311, []int{20}
 }
 
 func (m *QueryPBGameByRound) XXX_Unmarshal(b []byte) error {
@@ -1332,7 +1429,7 @@ func (m *ReplyPBGameByRound) Reset()         { *m = ReplyPBGameByRound{} }
 func (m *ReplyPBGameByRound) String() string { return proto.CompactTextString(m) }
 func (*ReplyPBGameByRound) ProtoMessage()    {}
 func (*ReplyPBGameByRound) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{20}
+	return fileDescriptor_8d22e4ee2313e311, []int{21}
 }
 
 func (m *ReplyPBGameByRound) XXX_Unmarshal(b []byte) error {
@@ -1423,7 +1520,7 @@ func (m *ReceiptPBGame) Reset()         { *m = ReceiptPBGame{} }
 func (m *ReceiptPBGame) String() string { return proto.CompactTextString(m) }
 func (*ReceiptPBGame) ProtoMessage()    {}
 func (*ReceiptPBGame) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{21}
+	return fileDescriptor_8d22e4ee2313e311, []int{22}
 }
 
 func (m *ReceiptPBGame) XXX_Unmarshal(b []byte) error {
@@ -1534,7 +1631,7 @@ func (m *PBStartTxReq) Reset()         { *m = PBStartTxReq{} }
 func (m *PBStartTxReq) String() string { return proto.CompactTextString(m) }
 func (*PBStartTxReq) ProtoMessage()    {}
 func (*PBStartTxReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{22}
+	return fileDescriptor_8d22e4ee2313e311, []int{23}
 }
 
 func (m *PBStartTxReq) XXX_Unmarshal(b []byte) error {
@@ -1588,7 +1685,7 @@ func (m *PBContinueTxReq) Reset()         { *m = PBContinueTxReq{} }
 func (m *PBContinueTxReq) String() string { return proto.CompactTextString(m) }
 func (*PBContinueTxReq) ProtoMessage()    {}
 func (*PBContinueTxReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{23}
+	return fileDescriptor_8d22e4ee2313e311, []int{24}
 }
 
 func (m *PBContinueTxReq) XXX_Unmarshal(b []byte) error {
@@ -1635,7 +1732,7 @@ func (m *PBQuitTxReq) Reset()         { *m = PBQuitTxReq{} }
 func (m *PBQuitTxReq) String() string { return proto.CompactTextString(m) }
 func (*PBQuitTxReq) ProtoMessage()    {}
 func (*PBQuitTxReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{24}
+	return fileDescriptor_8d22e4ee2313e311, []int{25}
 }
 
 func (m *PBQuitTxReq) XXX_Unmarshal(b []byte) error {
@@ -1682,7 +1779,7 @@ func (m *PBQueryReq) Reset()         { *m = PBQueryReq{} }
 func (m *PBQueryReq) String() string { return proto.CompactTextString(m) }
 func (*PBQueryReq) ProtoMessage()    {}
 func (*PBQueryReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8d22e4ee2313e311, []int{25}
+	return fileDescriptor_8d22e4ee2313e311, []int{26}
 }
 
 func (m *PBQueryReq) XXX_Unmarshal(b []byte) error {
@@ -1728,6 +1825,7 @@ func init() {
 	proto.RegisterType((*PBGameContinue)(nil), "types.PBGameContinue")
 	proto.RegisterType((*PBGameQuit)(nil), "types.PBGameQuit")
 	proto.RegisterType((*PBGameQuery)(nil), "types.PBGameQuery")
+	proto.RegisterType((*PBGamePlay)(nil), "types.PBGamePlay")
 	proto.RegisterType((*QueryPBGameListByStatusAndPlayerNum)(nil), "types.QueryPBGameListByStatusAndPlayerNum")
 	proto.RegisterType((*PBGameRecord)(nil), "types.PBGameRecord")
 	proto.RegisterType((*PBGameIndexRecord)(nil), "types.PBGameIndexRecord")
@@ -1749,71 +1847,73 @@ func init() {
 func init() { proto.RegisterFile("pokerbull.proto", fileDescriptor_8d22e4ee2313e311) }
 
 var fileDescriptor_8d22e4ee2313e311 = []byte{
-	// 1045 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0x5f, 0x6f, 0xe3, 0x44,
-	0x10, 0x3f, 0xc7, 0xb1, 0x93, 0x8c, 0xaf, 0x4d, 0xbb, 0x40, 0xb5, 0x42, 0x08, 0x45, 0xbe, 0x72,
-	0x17, 0x10, 0xf4, 0x21, 0x95, 0x40, 0x27, 0x24, 0xa4, 0x84, 0x07, 0x52, 0xe9, 0x84, 0xd2, 0xed,
-	0x49, 0xf7, 0xec, 0x8b, 0xf7, 0x5a, 0xeb, 0x1c, 0x27, 0xf5, 0x9f, 0x72, 0xf9, 0x10, 0x3c, 0xf2,
-	0x8e, 0xc4, 0x03, 0x9f, 0x8a, 0x37, 0x3e, 0x08, 0xda, 0x99, 0xb5, 0xbd, 0x76, 0x13, 0x4a, 0x79,
-	0xdb, 0xf9, 0xb3, 0xb3, 0xbf, 0x99, 0x9d, 0xfd, 0xcd, 0xc2, 0x70, 0xb3, 0x7e, 0x2f, 0xd3, 0xb7,
-	0x45, 0x1c, 0x9f, 0x6d, 0xd2, 0x75, 0xbe, 0x66, 0x4e, 0xbe, 0xdd, 0xc8, 0xcc, 0xff, 0xb5, 0x0b,
-	0x83, 0x85, 0x32, 0xcd, 0x8a, 0x38, 0x66, 0x27, 0xe0, 0x5e, 0x07, 0x2b, 0x79, 0x11, 0x72, 0x6b,
-	0x64, 0x8d, 0x07, 0x42, 0x4b, 0x4a, 0x9f, 0xe5, 0x41, 0x5e, 0x64, 0xbc, 0x33, 0xb2, 0xc6, 0x8e,
-	0xd0, 0x12, 0xfb, 0x0c, 0x06, 0x59, 0x1e, 0xa4, 0xf9, 0xeb, 0x68, 0x25, 0xb9, 0x8d, 0x5b, 0x6a,
-	0x05, 0x1b, 0x81, 0x47, 0xc2, 0x87, 0x79, 0x90, 0xdd, 0xf0, 0x2e, 0xda, 0x4d, 0x15, 0xfb, 0x18,
-	0x9c, 0xbb, 0x20, 0x2e, 0x24, 0x77, 0x46, 0xd6, 0xd8, 0x16, 0x24, 0xb0, 0x53, 0x70, 0x10, 0x2d,
-	0x77, 0x47, 0xd6, 0xd8, 0x9b, 0x1c, 0x9e, 0x21, 0xd4, 0xb3, 0xc5, 0x0c, 0x81, 0x0a, 0x32, 0xb2,
-	0x2f, 0xa1, 0xb7, 0x89, 0x83, 0xad, 0x4c, 0x33, 0xde, 0x1b, 0xd9, 0x63, 0x6f, 0x32, 0xac, 0xfd,
-	0x50, 0x2f, 0x4a, 0xbb, 0x82, 0x49, 0xcb, 0x9f, 0x8b, 0x15, 0xef, 0x63, 0x06, 0xb5, 0x42, 0x05,
-	0x4a, 0x65, 0x56, 0xc4, 0x79, 0xc6, 0x07, 0xad, 0x40, 0x02, 0xf5, 0xa2, 0xb4, 0x2b, 0xbc, 0x51,
-	0x12, 0xca, 0x0f, 0x1c, 0x08, 0x2f, 0x0a, 0x18, 0x3e, 0x95, 0x77, 0x17, 0x68, 0xf1, 0xd0, 0x52,
-	0x2b, 0xd8, 0xa7, 0xd0, 0xbf, 0x2d, 0x22, 0x2a, 0xd1, 0x53, 0x2c, 0x41, 0x25, 0xb3, 0xcf, 0x01,
-	0x70, 0x4d, 0x05, 0x3a, 0x40, 0xab, 0xa1, 0x51, 0xf6, 0x50, 0x06, 0xb1, 0x4c, 0xa7, 0x61, 0x98,
-	0xf2, 0x43, 0xb2, 0xd7, 0x1a, 0x75, 0x72, 0x94, 0xbd, 0x09, 0xa2, 0x3c, 0x4a, 0xae, 0xf9, 0x70,
-	0x64, 0x8d, 0xfb, 0xa2, 0x56, 0x68, 0x5c, 0x57, 0x74, 0x71, 0x47, 0x3a, 0xed, 0x52, 0xa1, 0x72,
-	0x49, 0xd7, 0x45, 0x12, 0xf2, 0x63, 0xb4, 0x90, 0xe0, 0xff, 0x6e, 0x81, 0xbb, 0x98, 0xcd, 0x83,
-	0x24, 0x54, 0x0e, 0xcb, 0x20, 0x0d, 0x33, 0x6e, 0x8d, 0x6c, 0xe5, 0x80, 0x82, 0x6a, 0x05, 0xaa,
-	0x46, 0xd9, 0x0a, 0x24, 0x31, 0x0e, 0xbd, 0x20, 0x0c, 0x53, 0x99, 0x65, 0xba, 0x11, 0x4a, 0x11,
-	0x8b, 0x96, 0xbd, 0x89, 0x12, 0x6c, 0x80, 0xbe, 0x20, 0x41, 0x95, 0x25, 0x96, 0x77, 0x32, 0x0d,
-	0xae, 0xe9, 0xf6, 0x1d, 0x51, 0xc9, 0x0a, 0x38, 0xa2, 0xc1, 0x9a, 0xb9, 0xd4, 0x56, 0x95, 0xc2,
-	0xff, 0xcd, 0x82, 0x7e, 0x79, 0xc7, 0xec, 0x19, 0x38, 0x37, 0x41, 0xa2, 0x41, 0x7a, 0x93, 0x83,
-	0xea, 0xea, 0x54, 0x0a, 0x82, 0x6c, 0x26, 0xb6, 0x4e, 0x13, 0xdb, 0x09, 0xb8, 0x39, 0x15, 0xdf,
-	0xc6, 0x7b, 0xd3, 0x12, 0x16, 0x47, 0x06, 0xe1, 0xb6, 0xc4, 0x8c, 0x82, 0xc2, 0xb5, 0x0a, 0xf2,
-	0xe5, 0x0d, 0xe2, 0x72, 0x08, 0x57, 0xa5, 0xf0, 0xff, 0x40, 0x5c, 0xd4, 0x32, 0xff, 0x0d, 0xd7,
-	0x09, 0xb8, 0xbf, 0x44, 0x49, 0x22, 0x53, 0x0d, 0x4b, 0x4b, 0x8d, 0xda, 0xd8, 0xad, 0xda, 0x9c,
-	0x80, 0x4b, 0x0d, 0xa0, 0xdf, 0x93, 0x96, 0xd8, 0x73, 0x38, 0xa4, 0xd5, 0xab, 0x66, 0x55, 0x5b,
-	0x5a, 0xff, 0x25, 0xf4, 0xf4, 0x43, 0xda, 0x73, 0xc1, 0x1c, 0x7a, 0x9b, 0x75, 0x94, 0xe4, 0x1a,
-	0x95, 0x23, 0x4a, 0xd1, 0xff, 0xcb, 0x82, 0xa7, 0x8b, 0xd9, 0x4f, 0xc1, 0x4a, 0x4e, 0x97, 0x79,
-	0xb4, 0x4e, 0xd8, 0x57, 0xe0, 0xe0, 0x6b, 0x46, 0xb6, 0xf0, 0x26, 0xac, 0x4a, 0x52, 0xf9, 0x5c,
-	0x29, 0xcb, 0xfc, 0x89, 0x20, 0x17, 0x76, 0x0e, 0xfd, 0xe5, 0x3a, 0xc9, 0xa3, 0xa4, 0x90, 0x18,
-	0xd7, 0x9b, 0x7c, 0xd2, 0x70, 0xff, 0x51, 0x1b, 0xe7, 0x4f, 0x44, 0xe5, 0xc8, 0x5e, 0x40, 0x57,
-	0xbd, 0x06, 0x2c, 0x82, 0x37, 0x39, 0x6e, 0x6c, 0xb8, 0x2c, 0x22, 0x15, 0x1e, 0x1d, 0x14, 0x92,
-	0xdb, 0x42, 0xa6, 0x74, 0x5f, 0x6d, 0x24, 0x97, 0xca, 0xa2, 0x90, 0xa0, 0x0b, 0x3b, 0x84, 0x4e,
-	0xbe, 0xc5, 0x17, 0xec, 0x88, 0x4e, 0xbe, 0x9d, 0xf5, 0x34, 0x09, 0xf9, 0x53, 0xf0, 0x0c, 0xe8,
-	0x35, 0x39, 0x59, 0x26, 0x39, 0x35, 0xb8, 0xa4, 0xd3, 0xe2, 0x12, 0x7f, 0x0c, 0x87, 0xcd, 0x74,
-	0xf6, 0x51, 0xaa, 0x7f, 0x0a, 0x50, 0xe7, 0xb1, 0xd7, 0xeb, 0x8b, 0x12, 0x12, 0xe6, 0xb0, 0xd7,
-	0xed, 0x16, 0x9e, 0xa1, 0x03, 0xf9, 0xbe, 0x8a, 0xb2, 0x7c, 0xb6, 0xa5, 0x67, 0x3e, 0x4d, 0xc2,
-	0x45, 0xc5, 0x74, 0x35, 0x8d, 0x5b, 0x6d, 0x1a, 0xdf, 0x9f, 0x53, 0x4d, 0x7a, 0xb6, 0x41, 0x7a,
-	0xfe, 0xeb, 0xb2, 0x17, 0x84, 0x5c, 0xae, 0xd3, 0xf0, 0xd1, 0xa3, 0x63, 0x77, 0xd4, 0x29, 0x1c,
-	0x53, 0x54, 0xe4, 0xce, 0x07, 0x42, 0x57, 0x21, 0x3a, 0x66, 0x88, 0x1f, 0xe0, 0xc0, 0x04, 0x96,
-	0xb1, 0x6f, 0x14, 0xbf, 0xe3, 0x52, 0x3f, 0xc6, 0x8f, 0x1a, 0xdd, 0x41, 0x6e, 0xa2, 0xf4, 0xf1,
-	0xe7, 0xc0, 0xee, 0x41, 0xc8, 0xd8, 0xa4, 0x1d, 0x84, 0x37, 0x82, 0x18, 0xbe, 0x75, 0xa4, 0xf7,
-	0x30, 0x34, 0x6e, 0xe5, 0x22, 0x79, 0xb7, 0xde, 0x9b, 0x0a, 0x83, 0xae, 0xa2, 0x24, 0xcd, 0x03,
-	0xb8, 0x36, 0x2a, 0x67, 0xef, 0xae, 0x5c, 0xd7, 0x4c, 0xfb, 0x1c, 0x3c, 0x21, 0x37, 0xb1, 0x3e,
-	0x8c, 0x9d, 0x42, 0x57, 0x85, 0xd6, 0x2f, 0xf3, 0xa8, 0x04, 0x5b, 0x4e, 0x7a, 0x81, 0x56, 0xff,
-	0x6b, 0x38, 0x6a, 0x21, 0xc4, 0xf7, 0x4f, 0xa0, 0x28, 0xd3, 0x81, 0x28, 0x45, 0xff, 0x25, 0x0c,
-	0x8d, 0x23, 0x54, 0x97, 0xb1, 0xe7, 0xe0, 0x28, 0x6b, 0x59, 0x94, 0xfb, 0xe7, 0x90, 0xd9, 0x9f,
-	0x01, 0x33, 0x0e, 0x9a, 0x6d, 0x85, 0x62, 0xf3, 0x7f, 0xbb, 0x58, 0x1a, 0x4d, 0x1d, 0x73, 0x34,
-	0xfd, 0x6d, 0x01, 0x33, 0xce, 0x7f, 0x28, 0xc8, 0xbe, 0xc6, 0x7b, 0x51, 0x0d, 0x30, 0x62, 0x95,
-	0x7b, 0xd3, 0xbe, 0x9c, 0x68, 0x8d, 0xe1, 0xda, 0x6d, 0x0f, 0xd7, 0xdd, 0x5f, 0x17, 0xe3, 0x53,
-	0xe2, 0x3e, 0xf0, 0x29, 0xc1, 0x41, 0x9a, 0x17, 0x69, 0xc2, 0x7b, 0x34, 0x7a, 0x48, 0xf2, 0xff,
-	0xec, 0xc0, 0x81, 0x90, 0x4b, 0x19, 0x6d, 0x72, 0x7d, 0x97, 0x8f, 0xcd, 0xb0, 0x6c, 0x26, 0xdb,
-	0x68, 0xa6, 0x9d, 0x4d, 0xd3, 0xfc, 0xb9, 0x38, 0xed, 0x9f, 0x4b, 0x83, 0x16, 0xdc, 0x1d, 0xb4,
-	0x40, 0x05, 0xe8, 0xb5, 0xe8, 0xb1, 0x2e, 0x5a, 0xbf, 0x5d, 0x34, 0x5e, 0x97, 0x67, 0x40, 0xbd,
-	0x65, 0x7e, 0xd1, 0xaa, 0xbf, 0x0a, 0xec, 0xfd, 0xab, 0x78, 0x66, 0x43, 0x20, 0x05, 0x5d, 0xd1,
-	0x77, 0x52, 0xc8, 0xdb, 0xff, 0x43, 0xd8, 0xec, 0x08, 0xec, 0x77, 0x52, 0x6a, 0x12, 0x52, 0x4b,
-	0xff, 0x7b, 0x18, 0x2e, 0x66, 0x25, 0x7d, 0x53, 0xe0, 0x7d, 0x17, 0xa0, 0x37, 0x77, 0xea, 0xcd,
-	0xdf, 0x29, 0xbe, 0xbe, 0xc4, 0x0f, 0xdc, 0xe3, 0x36, 0x7e, 0xab, 0xc6, 0x01, 0x3e, 0x91, 0x47,
-	0xed, 0x7b, 0xeb, 0xe2, 0x6f, 0xfe, 0xfc, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe7, 0x08, 0xea,
-	0x50, 0xe0, 0x0b, 0x00, 0x00,
+	// 1081 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x4f, 0x6f, 0xe3, 0x44,
+	0x14, 0x5f, 0xdb, 0xb1, 0x93, 0x3c, 0x6f, 0x9b, 0x76, 0x80, 0x6a, 0x84, 0x10, 0x8a, 0xbc, 0x65,
+	0x37, 0x20, 0xe8, 0x21, 0x95, 0x40, 0x2b, 0x24, 0xa4, 0x86, 0x03, 0xa9, 0xb4, 0x42, 0xe9, 0x74,
+	0xa5, 0x3d, 0x7b, 0xe3, 0xd9, 0xd6, 0xac, 0xe3, 0xa4, 0xfe, 0x53, 0x36, 0x5f, 0x80, 0x1b, 0x47,
+	0xee, 0x48, 0x1c, 0xf8, 0x62, 0x7c, 0x10, 0x34, 0x6f, 0x66, 0xec, 0xb1, 0x1b, 0xab, 0x84, 0x9b,
+	0xdf, 0x9f, 0x79, 0xf3, 0x7b, 0x6f, 0xde, 0xfc, 0xde, 0x18, 0x46, 0x9b, 0xf5, 0x7b, 0x9e, 0xbd,
+	0x2d, 0x93, 0xe4, 0x6c, 0x93, 0xad, 0x8b, 0x35, 0x71, 0x8b, 0xed, 0x86, 0xe7, 0xc1, 0xef, 0x3d,
+	0x18, 0x2e, 0x84, 0x69, 0x56, 0x26, 0x09, 0x39, 0x01, 0xef, 0x26, 0x5c, 0xf1, 0xcb, 0x88, 0x5a,
+	0x63, 0x6b, 0x32, 0x64, 0x4a, 0x12, 0xfa, 0xbc, 0x08, 0x8b, 0x32, 0xa7, 0xf6, 0xd8, 0x9a, 0xb8,
+	0x4c, 0x49, 0xe4, 0x33, 0x18, 0xe6, 0x45, 0x98, 0x15, 0xaf, 0xe3, 0x15, 0xa7, 0x0e, 0x2e, 0xa9,
+	0x15, 0x64, 0x0c, 0xbe, 0x14, 0x3e, 0xcc, 0xc3, 0xfc, 0x96, 0xf6, 0xd0, 0x6e, 0xaa, 0xc8, 0xc7,
+	0xe0, 0xde, 0x87, 0x49, 0xc9, 0xa9, 0x3b, 0xb6, 0x26, 0x0e, 0x93, 0x02, 0x39, 0x05, 0x17, 0xd1,
+	0x52, 0x6f, 0x6c, 0x4d, 0xfc, 0xe9, 0xe1, 0x19, 0x42, 0x3d, 0x5b, 0xcc, 0x10, 0x28, 0x93, 0x46,
+	0xf2, 0x25, 0xf4, 0x37, 0x49, 0xb8, 0xe5, 0x59, 0x4e, 0xfb, 0x63, 0x67, 0xe2, 0x4f, 0x47, 0xb5,
+	0x1f, 0xea, 0x99, 0xb6, 0x0b, 0x98, 0xf2, 0xf3, 0xe7, 0x72, 0x45, 0x07, 0x98, 0x41, 0xad, 0x10,
+	0x81, 0x32, 0x9e, 0x97, 0x49, 0x91, 0xd3, 0x61, 0x2b, 0x10, 0x43, 0x3d, 0xd3, 0x76, 0x81, 0x37,
+	0x4e, 0x23, 0xfe, 0x81, 0x82, 0xc4, 0x8b, 0x02, 0x86, 0xcf, 0xf8, 0xfd, 0x25, 0x5a, 0x7c, 0xb4,
+	0xd4, 0x0a, 0xf2, 0x29, 0x0c, 0xee, 0xca, 0x58, 0x96, 0xe8, 0x29, 0x96, 0xa0, 0x92, 0xc9, 0xe7,
+	0x00, 0xf8, 0x2d, 0x0b, 0x74, 0x80, 0x56, 0x43, 0x23, 0xec, 0x11, 0x0f, 0x13, 0x9e, 0x5d, 0x44,
+	0x51, 0x46, 0x0f, 0xa5, 0xbd, 0xd6, 0x88, 0x9d, 0xe3, 0xfc, 0x4d, 0x18, 0x17, 0x71, 0x7a, 0x43,
+	0x47, 0x63, 0x6b, 0x32, 0x60, 0xb5, 0x42, 0xe1, 0xba, 0x96, 0x07, 0x77, 0xa4, 0xd2, 0xd6, 0x0a,
+	0x91, 0x4b, 0xb6, 0x2e, 0xd3, 0x88, 0x1e, 0xa3, 0x45, 0x0a, 0xc1, 0x9f, 0x16, 0x78, 0x8b, 0xd9,
+	0x3c, 0x4c, 0x23, 0xe1, 0xb0, 0x0c, 0xb3, 0x28, 0xa7, 0xd6, 0xd8, 0x11, 0x0e, 0x28, 0x88, 0x56,
+	0x90, 0xd5, 0xd0, 0xad, 0x20, 0x25, 0x42, 0xa1, 0x1f, 0x46, 0x51, 0xc6, 0xf3, 0x5c, 0x35, 0x82,
+	0x16, 0xb1, 0x68, 0xf9, 0x9b, 0x38, 0xc5, 0x06, 0x18, 0x30, 0x29, 0x88, 0xb2, 0x24, 0xfc, 0x9e,
+	0x67, 0xe1, 0x8d, 0x3c, 0x7d, 0x97, 0x55, 0xb2, 0x00, 0x8e, 0x68, 0xb0, 0x66, 0x9e, 0x6c, 0xab,
+	0x4a, 0x11, 0xfc, 0x61, 0xc1, 0x40, 0x9f, 0x31, 0x79, 0x06, 0xee, 0x6d, 0x98, 0x2a, 0x90, 0xfe,
+	0xf4, 0xa0, 0x3a, 0x3a, 0x91, 0x02, 0x93, 0x36, 0x13, 0x9b, 0xdd, 0xc4, 0x76, 0x02, 0x5e, 0x21,
+	0x8b, 0xef, 0xe0, 0xb9, 0x29, 0x09, 0x8b, 0xc3, 0xc3, 0x68, 0xab, 0x31, 0xa3, 0x20, 0x70, 0xad,
+	0xc2, 0x62, 0x79, 0x8b, 0xb8, 0x5c, 0x89, 0xab, 0x52, 0x04, 0x7f, 0x21, 0x2e, 0xd9, 0x32, 0xff,
+	0x0d, 0xd7, 0x09, 0x78, 0xbf, 0xc6, 0x69, 0xca, 0x33, 0x05, 0x4b, 0x49, 0x8d, 0xda, 0x38, 0xad,
+	0xda, 0x9c, 0x80, 0x27, 0x1b, 0x40, 0xdd, 0x27, 0x25, 0x91, 0xe7, 0x70, 0x28, 0xbf, 0x5e, 0x35,
+	0xab, 0xda, 0xd2, 0x06, 0x2f, 0xa1, 0xaf, 0x2e, 0x52, 0xc7, 0x01, 0x53, 0xe8, 0x6f, 0xd6, 0x71,
+	0x5a, 0x28, 0x54, 0x2e, 0xd3, 0x62, 0xf0, 0x9b, 0x0d, 0x4f, 0x17, 0xb3, 0x9f, 0xc2, 0x15, 0xbf,
+	0x58, 0x16, 0xf1, 0x3a, 0x25, 0x5f, 0x81, 0x8b, 0xb7, 0x19, 0xd9, 0xc2, 0x9f, 0x92, 0x2a, 0x49,
+	0xe1, 0x73, 0x2d, 0x2c, 0xf3, 0x27, 0x4c, 0xba, 0x90, 0x73, 0x18, 0x2c, 0xd7, 0x69, 0x11, 0xa7,
+	0x25, 0xc7, 0xb8, 0xfe, 0xf4, 0x93, 0x86, 0xfb, 0x8f, 0xca, 0x38, 0x7f, 0xc2, 0x2a, 0x47, 0xf2,
+	0x02, 0x7a, 0xe2, 0x36, 0x60, 0x11, 0xfc, 0xe9, 0x71, 0x63, 0xc1, 0x55, 0x19, 0x8b, 0xf0, 0xe8,
+	0x20, 0x90, 0xdc, 0x95, 0x3c, 0x93, 0xe7, 0xd5, 0x46, 0x72, 0x25, 0x2c, 0x02, 0x09, 0xba, 0x88,
+	0xa0, 0xe2, 0xf2, 0x63, 0x7d, 0xda, 0x41, 0x45, 0x57, 0x89, 0xa0, 0xc2, 0x81, 0x1c, 0x82, 0x5d,
+	0x6c, 0xf1, 0xaa, 0xbb, 0xcc, 0x2e, 0xb6, 0xb3, 0xbe, 0x62, 0xab, 0xe0, 0x02, 0x7c, 0x23, 0xc7,
+	0x9a, 0xc5, 0x2c, 0x93, 0xc5, 0x1a, 0xa4, 0x63, 0xb7, 0x48, 0x27, 0x98, 0xc0, 0x61, 0x33, 0xef,
+	0x2e, 0xee, 0x0d, 0x4e, 0x01, 0xea, 0x84, 0x3b, 0xbd, 0xbe, 0xd0, 0x90, 0x30, 0xd9, 0x4e, 0xb7,
+	0x5f, 0x74, 0x30, 0x91, 0x68, 0x27, 0xdd, 0x57, 0xd4, 0x60, 0x1b, 0xd4, 0x50, 0xa7, 0xe9, 0x98,
+	0x69, 0x1a, 0x77, 0xab, 0x37, 0x76, 0x8c, 0xbb, 0x15, 0xdc, 0xc1, 0x33, 0x04, 0x23, 0x37, 0x7c,
+	0x15, 0xe7, 0xc5, 0x6c, 0x2b, 0xb9, 0xe7, 0x22, 0x8d, 0x16, 0x15, 0xfd, 0xd6, 0xb3, 0xc5, 0x6a,
+	0xcf, 0x96, 0xee, 0xfa, 0xd5, 0x4c, 0xec, 0x18, 0x4c, 0x1c, 0xbc, 0xd6, 0x0d, 0xca, 0xf8, 0x72,
+	0x9d, 0x45, 0x7b, 0xcf, 0xb3, 0xdd, 0x51, 0x2f, 0xe0, 0x58, 0x46, 0x45, 0x42, 0x7f, 0x24, 0x74,
+	0x15, 0xc2, 0x36, 0x43, 0xfc, 0x00, 0x07, 0x26, 0xb0, 0x9c, 0x7c, 0x23, 0x86, 0x0e, 0x7e, 0x2a,
+	0x86, 0xf8, 0xa8, 0xd1, 0x87, 0xd2, 0x8d, 0x69, 0x9f, 0x60, 0x0e, 0xe4, 0x01, 0x84, 0x9c, 0x4c,
+	0xdb, 0x41, 0x68, 0x23, 0x88, 0xe1, 0x5b, 0x47, 0x7a, 0x0f, 0x23, 0xe3, 0x54, 0x2e, 0xd3, 0x77,
+	0xeb, 0xce, 0x54, 0x08, 0xf4, 0xc4, 0x59, 0x2a, 0x72, 0xc2, 0x6f, 0xa3, 0x72, 0xce, 0xee, 0xca,
+	0xf5, 0xcc, 0xb4, 0xcf, 0xc1, 0x67, 0x7c, 0x93, 0xa8, 0xcd, 0xc8, 0x29, 0xf4, 0x44, 0x68, 0x45,
+	0x17, 0x47, 0x1a, 0xac, 0x7e, 0x7e, 0x30, 0xb4, 0x06, 0x5f, 0xc3, 0x51, 0x0b, 0x21, 0x92, 0x92,
+	0x04, 0x25, 0x33, 0x1d, 0x32, 0x2d, 0x06, 0x2f, 0x61, 0x64, 0x6c, 0x21, 0xba, 0x8c, 0x3c, 0x07,
+	0x57, 0x58, 0x75, 0x51, 0x1e, 0xee, 0x23, 0xcd, 0xc1, 0x0c, 0x88, 0xb1, 0xd1, 0x6c, 0xcb, 0xb0,
+	0xcd, 0xf7, 0xba, 0x14, 0xc1, 0x3f, 0x16, 0x10, 0x63, 0xff, 0xc7, 0x82, 0x74, 0x35, 0xde, 0x8b,
+	0x6a, 0xaa, 0x4a, 0xaa, 0x7b, 0xf0, 0x04, 0xd1, 0x63, 0xb6, 0x31, 0xf1, 0x7b, 0xed, 0x89, 0xbf,
+	0xfb, 0x3d, 0x65, 0xbc, 0x94, 0xbc, 0x47, 0x5e, 0x4a, 0x38, 0xdd, 0x8b, 0x32, 0x4b, 0x69, 0x5f,
+	0xce, 0x43, 0x29, 0x05, 0x7f, 0xdb, 0x70, 0xc0, 0xf8, 0x92, 0xc7, 0x9b, 0x42, 0x9d, 0xe5, 0xbe,
+	0x19, 0xea, 0x66, 0x72, 0x8c, 0x66, 0xda, 0xd9, 0x34, 0xcd, 0xe7, 0x94, 0xdb, 0x7e, 0x4e, 0x35,
+	0x68, 0xc1, 0xdb, 0x41, 0x0b, 0xb2, 0x00, 0xfd, 0x16, 0x15, 0xd7, 0x45, 0x1b, 0xb4, 0x8b, 0x46,
+	0xeb, 0xf2, 0x0c, 0x65, 0x6f, 0x99, 0xef, 0xc6, 0xea, 0x01, 0x05, 0x9d, 0x0f, 0x28, 0xdf, 0x6c,
+	0x08, 0xa4, 0xa0, 0x6b, 0xf9, 0xc6, 0x65, 0xfc, 0xee, 0xff, 0x0c, 0x07, 0x72, 0x04, 0xce, 0x3b,
+	0xae, 0x79, 0x56, 0x7c, 0x06, 0xdf, 0xc3, 0x68, 0x31, 0xd3, 0xa3, 0x42, 0x06, 0xee, 0x3a, 0x00,
+	0xb5, 0xd8, 0xae, 0x17, 0x7f, 0x27, 0x66, 0xc3, 0x15, 0xbe, 0x2a, 0xf7, 0x5b, 0xf8, 0xad, 0x98,
+	0x16, 0x78, 0x45, 0xf6, 0x5a, 0xf7, 0xd6, 0xc3, 0x5f, 0x8c, 0xf3, 0x7f, 0x03, 0x00, 0x00, 0xff,
+	0xff, 0xb4, 0x58, 0xec, 0xbf, 0x75, 0x0c, 0x00, 0x00,
 }

plugin/dapp/pokerbull/types/types.go

@@ -46,6 +46,7 @@ func (t *PokerBullType) GetTypeMap() map[string]int32 {
 		"Continue": PBGameActionContinue,
 		"Quit":     PBGameActionQuit,
 		"Query":    PBGameActionQuery,
+		"Play":     PBGameActionPlay,
 	}
 }
 
@@ -56,5 +57,6 @@ func (t *PokerBullType) GetLogMap() map[int64]*types.LogInfo {
 		TyLogPBGameContinue: {Ty: reflect.TypeOf(ReceiptPBGame{}), Name: "TyLogPBGameContinue"},
 		TyLogPBGameQuit:     {Ty: reflect.TypeOf(ReceiptPBGame{}), Name: "TyLogPBGameQuit"},
 		TyLogPBGameQuery:    {Ty: reflect.TypeOf(ReceiptPBGame{}), Name: "TyLogPBGameQuery"},
+		TyLogPBGamePlay:     {Ty: reflect.TypeOf(ReceiptPBGame{}), Name: "TyLogPBGamePlay"},
 	}
 }