娃娃机

common/constant.go

@@ -86,6 +86,7 @@ const (
 	GameId_CaoThap                        = 605 //CaoThap
 	GameId_AngerUncle                     = 606 // 愤怒大叔
 	GameId_SmallRoket                     = 607 // 小火箭
+	GameId_Clawdoll                       = 608 // 娃娃机
 	__GameId_ThrGame_Min__                = 700 //################三方类################
 	GameId_Thr_Dg                         = 701 //DG Game
 	GameId_Thr_XHJ                        = 901 //DG Game
@@ -104,6 +105,7 @@ const (
 	GameDifTamQuoc     = "305" // 百战成神
 	GameDifFruits      = "306" // 水果机
 	GameDifRichblessed = "307" // 多彩多福
+	GameDifClawdoll    = "608" // 娃娃机
 )
 
 // IsTienLenYuLe TienLen娱乐

data/gameconfig/machine.json

@@ -0,0 +1,19 @@
+{
+	"GameName":"娃娃机",
+	"GameId":608,
+	"GameMode":[0],
+	"SceneType":[1],
+	"CanForceStart":false,
+	"MinPlayerCnt":1,
+	"DefaultPlayerCnt":1,
+	"MaxIndex":0,
+	"TimeFreeStart":0,
+	"TimeFreeEnd":0,
+	"DependentPlayerCnt":true,
+	"EnterAfterStart":false,
+	"PerGameTakeCard":100,
+	"ViewLogCnt":-1,
+	"BetState":0,
+	"Params":[
+	]
+}

gamerule/clawdoll/constants.go

@@ -0,0 +1,25 @@
+package clawdoll
+
+import "time"
+
+// 场景状态
+const (
+	ClawDollSceneStateWait     int = iota //等待状态
+	ClawDollSceneStateStart               //开始倒计时
+	ClawDollSceneStatePlayGame            //游戏中
+	ClawDollSceneStateBilled              //结算
+	ClawDollSceneStateMax
+)
+
+const (
+	ClawDollSceneWaitTimeout   = time.Second * 2 //等待倒计时
+	ClawDollSceneStartTimeout  = time.Second * 6 //开始倒计时
+	ClawDollSceneBilledTimeout = time.Second * 2 //结算
+)
+
+// 玩家操作
+const (
+	ClawDollPlayerOpScore = iota + 1 // 上分
+	ClawDollPlayerOpGo               // 下抓
+	ClawDollPlayerOpMove             // 移动方向
+)

gamerule/clawdoll/logic.go

@@ -0,0 +1,4 @@
+package clawdoll
+
+type Logic struct {
+}

gamesrv/action/action_machine.go

@@ -6,8 +6,17 @@ import (
 	"mongo.games.com/goserver/core/netlib"
 )
 
+var MachineMap = make(map[int]string)
+
 func MSDollMachineList(session *netlib.Session, packetId int, data interface{}) error {
 	logger.Logger.Tracef("TestHandler %v", data)
+	MachineMap = make(map[int]string)
+	if msg, ok := data.(*machine.MSDollMachineList); ok {
+		for i, info := range msg.Data {
+			MachineMap[i+1] = info.VideoAddr
+			logger.Logger.Tracef("MachineMap[%v] = %v", i, info.VideoAddr)
+		}
+	}
 	return nil
 }
 

gamesrv/base/srvdatamgrex.go

@@ -171,7 +171,7 @@ type DB_FishOutMgrEx struct {
 func (this *DB_FishOutMgrEx) InitFishAppear() {
 	this.FishOutPool = make(map[int32]*AppearFish)
 	for _, v := range srvdata.PBDB_FishOutMgr.Datas.Arr {
-		logger.Logger.Tracef("初始化房间出鱼列表 fishId = %v", v.Id)
+		//logger.Logger.Tracef("初始化房间出鱼列表 fishId = %v", v.Id)
 		this.FishOutPool[v.Id] = &AppearFish{
 			FishId:    v.Id,
 			Exp:       v.Exp,

gamesrv/clawdoll/action_clawdoll.go

@@ -0,0 +1,55 @@
+package clawdoll
+
+import (
+	"mongo.games.com/game/common"
+	"mongo.games.com/game/gamesrv/base"
+	"mongo.games.com/game/protocol/clawdoll"
+	"mongo.games.com/goserver/core/logger"
+	"mongo.games.com/goserver/core/netlib"
+)
+
+type CSPlayerOpPacketFactory struct {
+}
+
+type CSPlayerOpHandler struct {
+}
+
+func (f *CSPlayerOpPacketFactory) CreatePacket() interface{} {
+	pack := &clawdoll.CSCLAWDOLLOp{}
+	return pack
+}
+
+func (h *CSPlayerOpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
+	logger.Logger.Trace("CSPlayerOpHandler Process recv ", data)
+	if msg, ok := data.(*clawdoll.CSCLAWDOLLOp); ok {
+		p := base.PlayerMgrSington.GetPlayer(sid)
+		if p == nil {
+			logger.Logger.Warn("CSPlayerOpHandler p == nil")
+			return nil
+		}
+		scene := p.GetScene()
+		if scene == nil {
+			logger.Logger.Warn("CSPlayerOpHandler p.scene == nil")
+			return nil
+		}
+
+		if scene.KeyGameDif != common.GameDifClawdoll {
+			logger.Logger.Error("CSPlayerOpHandler gameId Error ", scene.GameId)
+			return nil
+		}
+		if !scene.HasPlayer(p) {
+			return nil
+		}
+		sp := scene.GetScenePolicy()
+		if sp != nil {
+			sp.OnPlayerOp(scene, p, int(msg.GetOpCode()), msg.GetParams())
+		}
+		return nil
+	}
+	return nil
+}
+
+func init() {
+	common.RegisterHandler(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_CLAWDOLL_PLAYEROP), &CSPlayerOpHandler{})
+	netlib.RegisterFactory(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_CLAWDOLL_PLAYEROP), &CSPlayerOpPacketFactory{})
+}

gamesrv/clawdoll/player_clawdoll.go

@@ -0,0 +1,71 @@
+package clawdoll
+
+import (
+	"mongo.games.com/game/gamesrv/base"
+	"mongo.games.com/goserver/core/logger"
+)
+
+type PlayerEx struct {
+	*base.Player //玩家信息
+
+	gainCoin int64 // 本局赢的金币
+	taxCoin  int64 // 本局税收
+	odds     int32
+}
+
+func (this *PlayerEx) Clear(baseScore int32) {
+	this.UnmarkFlag(base.PlayerState_WaitNext)
+	this.UnmarkFlag(base.PlayerState_GameBreak)
+	this.MarkFlag(base.PlayerState_Ready)
+
+	this.gainCoin = 0
+	this.taxCoin = 0
+	this.odds = 0
+}
+
+func (this *PlayerEx) CanOp(sceneEx *SceneEx) bool {
+	if !this.IsGameing() {
+		logger.Logger.Trace("(this *PlayerEx) CanOp return false ", this.SnId)
+		return false
+	}
+	return true
+}
+
+func (this *PlayerEx) CanPayCoinByPos() bool {
+
+	return false
+}
+
+// 游戏新一局 设置数据
+func (this *PlayerEx) ReStartGame() {
+	this.ReDataStartGame()
+	this.gainCoin = 0
+	this.taxCoin = 0
+	this.odds = 0
+}
+
+// 初始化
+func (this *PlayerEx) InitData(baseScore int32) {
+
+}
+
+// 重置下注数据
+func (this *PlayerEx) ResetData() {
+
+}
+
+// 游戏新一局 设置数据
+func (this *PlayerEx) ReDataStartGame() {
+
+}
+
+func (this *PlayerEx) CanPlayerOpInState(sceneState int) bool {
+
+	return false
+}
+
+// 能否退出游戏
+func (this *PlayerEx) CanLeaveScene(sceneState int) bool {
+
+	return true
+}

gamesrv/clawdoll/scene_clawdoll.go

@@ -0,0 +1,205 @@
+package clawdoll
+
+import (
+	"mongo.games.com/game/protocol/clawdoll"
+	"mongo.games.com/goserver/core/logger"
+
+	"mongo.games.com/game/common"
+	rule "mongo.games.com/game/gamerule/clawdoll"
+	"mongo.games.com/game/gamesrv/base"
+	"mongo.games.com/game/proto"
+)
+
+type PlayerData struct {
+	SnId  int32
+	Head  int32  //头像框
+	VIP   int32  //VIP帐号 等级
+	Name  string //名字
+	Sex   int32  //性别
+	IsRob bool
+
+	Coin     int64
+	gainCoin int64 //本局赢的金币
+	taxCoin  int64 //本局税收
+	isBilled bool  //是否结算
+	CurIsWin int64 //当局输赢   负数：输  正数：赢
+
+	InviterId        int32  //邀请人Id
+	BeUnderAgentCode string //隶属经销商（推广人）
+	IsPlayerFirst    bool
+
+	Platform  string //平台
+	Channel   string //渠道信息
+	PackageID string //推广包标识 对应客户端的packagetag
+	flag      int
+}
+
+type SceneEx struct {
+	*base.Scene                        // 场景
+	logic        *rule.Logic           //
+	players      map[int32]*PlayerEx   // 玩家信息
+	PlayerBackup map[int32]*PlayerData // 本局离场玩家数据备份
+	seats        []*PlayerEx           // 本局游戏中的玩家状态数据
+
+	RoundId  int // 局数，第几局
+	robotNum int // 参与游戏的机器人数量
+	logid    string
+}
+
+// 游戏是否能开始
+func (this *SceneEx) CanStart() bool {
+	//人数>=1自动开始
+	if len(this.players) >= 0 && (this.GetRealPlayerNum() >= 0 || this.IsPreCreateScene()) {
+		return true
+	}
+	return false
+}
+
+// 从房间删除玩家
+func (this *SceneEx) delPlayer(p *base.Player) {
+	if p, exist := this.players[p.SnId]; exist {
+		this.seats[p.GetPos()] = nil
+		delete(this.players, p.SnId)
+	}
+}
+
+// 广播玩家离开
+func (this *SceneEx) BroadcastPlayerLeave(p *base.Player, reason int) {
+	scLeavePack := &clawdoll.SCCLAWDOLLPlayerLeave{
+		Pos: proto.Int(p.GetPos()),
+	}
+	proto.SetDefaults(scLeavePack)
+
+	this.Broadcast(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_CLAWDOLL_PlayerLeave), scLeavePack, p.GetSid())
+}
+
+// 玩家离开事件
+func (this *SceneEx) OnPlayerLeave(p *base.Player, reason int) {
+	this.delPlayer(p)
+	this.BroadcastPlayerLeave(p, reason)
+}
+func (this *SceneEx) SceneDestroy(force bool) {
+	//销毁房间
+	this.Scene.Destroy(force)
+}
+
+func (e *SceneEx) playerOpPack(snId int32, opcode int, opRetCode clawdoll.OpResultCode, params []int64) *clawdoll.SCCLAWDOLLOp {
+	pack := &clawdoll.SCCLAWDOLLOp{
+		SnId:      proto.Int32(snId),
+		OpCode:    proto.Int32(int32(opcode)),
+		Params:    params,
+		OpRetCode: clawdoll.OpResultCode_OPRC_Success,
+	}
+
+	proto.SetDefaults(pack)
+	return pack
+}
+
+// OnPlayerSCOp 发送玩家操作情况
+func (e *SceneEx) OnPlayerSCOp(p *base.Player, opcode int, opRetCode clawdoll.OpResultCode, params []int64) {
+	pack := e.playerOpPack(p.SnId, opcode, opRetCode, params)
+	p.SendToClient(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_CLAWDOLL_PLAYEROP), pack)
+	logger.Logger.Tracef("OnPlayerSCOp %s", pack)
+}
+
+// 房间信息打包
+func (this *SceneEx) ClawdollCreateRoomInfoPacket(s *base.Scene, p *base.Player) interface{} {
+	pack := &clawdoll.SCCLAWDOLLRoomInfo{
+		RoomId:      proto.Int(s.GetSceneId()),
+		GameId:      proto.Int(s.GetGameId()),
+		RoomMode:    proto.Int(s.GetSceneMode()),
+		Params:      common.CopySliceInt64ToInt32(s.Params),
+		State:       proto.Int(s.GetSceneState().GetState()),
+		TimeOut:     proto.Int(s.GetSceneState().GetTimeout(s)),
+		TotalPlayer: proto.Int(len(this.players)),
+		RoundId:     proto.Int(this.RoundId),
+		ParamsEx:    nil,
+		GameFreeId:  0,
+		BaseScore:   proto.Int32(this.GetBaseScore()),
+	}
+
+	// 玩家信息
+	for _, playerEx := range this.players {
+
+		if p.SnId == playerEx.SnId {
+			pd := &clawdoll.CLAWDOLLPlayerData{
+				SnId:        proto.Int32(playerEx.SnId),
+				Name:        proto.String(playerEx.Name),
+				Head:        proto.Int32(playerEx.Head),
+				Sex:         proto.Int32(playerEx.Sex),
+				Coin:        proto.Int64(playerEx.Coin),
+				Flag:        proto.Int(playerEx.GetFlag()),
+				HeadOutLine: proto.Int32(playerEx.HeadOutLine),
+				VIP:         proto.Int32(playerEx.VIP),
+
+				WinCoin: proto.Int64(playerEx.gainCoin),
+			}
+
+			pack.Players = append(pack.Players, pd)
+		}
+	}
+
+	proto.SetDefaults(pack)
+	if p != nil {
+		p.SyncFlag()
+	}
+
+	return pack
+}
+
+func NewClawdollSceneData(s *base.Scene) *SceneEx {
+	sceneEx := &SceneEx{
+		Scene:        s,
+		logic:        new(rule.Logic),
+		players:      make(map[int32]*PlayerEx),
+		seats:        make([]*PlayerEx, s.GetPlayerNum()),
+		PlayerBackup: make(map[int32]*PlayerData),
+	}
+
+	return sceneEx
+}
+
+func (this *SceneEx) init() bool {
+	this.Clear()
+	return true
+}
+
+// 检查上分是否合法
+func (this *SceneEx) CheckPayOp(betVal int64, takeMul int64) bool { //游戏底分
+	return true
+}
+
+func (this *SceneEx) Clear() {
+	this.robotNum = 0
+	this.PlayerBackup = make(map[int32]*PlayerData)
+	this.RoundId = 0
+
+	for i := 0; i < this.GetPlayerNum(); i++ {
+		if this.seats[i] != nil {
+			this.seats[i].Clear(this.GetBaseScore())
+		}
+	}
+}
+
+func (this *SceneEx) BackupPlayer(p *PlayerEx, isBilled bool) {
+	this.PlayerBackup[p.SnId] = &PlayerData{
+		SnId:             p.SnId,
+		gainCoin:         p.gainCoin,
+		taxCoin:          p.taxCoin,
+		isBilled:         isBilled,
+		IsRob:            p.IsRob,
+		Coin:             p.Coin,
+		Head:             p.Head,
+		flag:             p.GetFlag(),
+		Platform:         p.Platform,
+		Channel:          p.Channel,
+		PackageID:        p.PackageID,
+		CurIsWin:         p.CurIsWin,
+		Name:             p.Name,
+		Sex:              p.Sex,
+		VIP:              p.VIP,
+		InviterId:        p.InviterId,
+		IsPlayerFirst:    this.IsPlayerFirst(p.Player),
+		BeUnderAgentCode: p.BeUnderAgentCode,
+	}
+}

gamesrv/clawdoll/scenepolicy_clawdoll.go

@@ -0,0 +1,576 @@
+package clawdoll
+
+import (
+	"mongo.games.com/game/protocol/clawdoll"
+	"time"
+
+	"mongo.games.com/goserver/core"
+	"mongo.games.com/goserver/core/logger"
+
+	"mongo.games.com/game/common"
+	rule "mongo.games.com/game/gamerule/clawdoll"
+	"mongo.games.com/game/gamesrv/base"
+	"mongo.games.com/game/proto"
+)
+
+var PolicyClawdollSingleton = &PolicyClawdoll{}
+
+type PolicyClawdoll struct {
+	base.BaseScenePolicy
+	states [rule.ClawDollSceneStateMax]base.SceneState
+}
+
+func (this *PolicyClawdoll) CreateSceneExData(s *base.Scene) interface{} {
+	sceneEx := NewClawdollSceneData(s)
+	if sceneEx != nil {
+		if sceneEx.init() {
+			s.ExtraData = sceneEx
+		}
+	}
+	return sceneEx
+}
+
+func (this *PolicyClawdoll) CreatePlayerExData(s *base.Scene, p *base.Player) interface{} {
+	playerEx := &PlayerEx{Player: p}
+	if playerEx != nil {
+		p.ExtraData = playerEx
+	}
+	return playerEx
+}
+
+func (this *PolicyClawdoll) OnStart(s *base.Scene) {
+	logger.Logger.Trace("(this *PolicyClawdoll) OnStart, sceneId=", s.GetSceneId())
+
+	sceneEx := NewClawdollSceneData(s)
+	if sceneEx != nil {
+		if sceneEx.init() {
+			s.ExtraData = sceneEx
+			s.ChangeSceneState(rule.ClawDollSceneStateWait)
+		}
+	}
+}
+
+func (this *PolicyClawdoll) OnStop(s *base.Scene) {
+	logger.Logger.Trace("(this *PolicyClawdoll) OnStop , sceneId=", s.GetSceneId())
+}
+
+func (this *PolicyClawdoll) OnTick(s *base.Scene) {
+	if s == nil {
+		return
+	}
+	if s.SceneState != nil {
+		s.SceneState.OnTick(s)
+	}
+}
+
+func (this *PolicyClawdoll) OnPlayerEnter(s *base.Scene, p *base.Player) {
+	if s == nil || p == nil {
+		return
+	}
+
+	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerEnter, sceneId=", s.GetSceneId(), " player=", p.SnId)
+
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		pos := -1
+		for i := 0; i < sceneEx.GetPlayerNum(); i++ {
+			if sceneEx.seats[i] == nil {
+				pos = i
+				break
+			}
+		}
+		if pos != -1 {
+			playerEx := &PlayerEx{Player: p}
+			sceneEx.seats[pos] = playerEx
+			sceneEx.players[p.SnId] = playerEx
+
+			baseScore := sceneEx.GetBaseScore()
+
+			p.Pos = pos
+			p.ExtraData = playerEx
+			playerEx.Clear(baseScore)
+
+			if sceneEx.Gaming {
+				p.MarkFlag(base.PlayerState_WaitNext)
+				p.UnmarkFlag(base.PlayerState_Ready)
+			}
+
+			//给自己发送房间信息
+			this.SendRoomInfo(s, p, sceneEx)
+			s.FirePlayerEvent(p, base.PlayerEventEnter, nil)
+		}
+	}
+}
+
+func (this *PolicyClawdoll) OnPlayerLeave(s *base.Scene, p *base.Player, reason int) {
+	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerLeave, sceneId=", s.GetSceneId(), " player=", p.SnId)
+	if s == nil || p == nil {
+		return
+	}
+	if !this.CanChangeCoinScene(s, p) {
+		return
+	}
+
+	sceneEx, ok := s.ExtraData.(*SceneEx)
+	if !ok {
+		return
+	}
+	playerEx, ok := p.ExtraData.(*PlayerEx)
+	if !ok {
+		return
+	}
+
+	isBilled := false
+
+	// 游戏已开始，玩家离开，备份玩家数据
+	if sceneEx.Gaming {
+		sceneEx.BackupPlayer(playerEx, isBilled)
+	}
+
+	// 清理玩家数据
+	sceneEx.OnPlayerLeave(p, reason)
+	s.FirePlayerEvent(p, base.PlayerEventLeave, nil)
+}
+
+func (this *PolicyClawdoll) OnPlayerDropLine(s *base.Scene, p *base.Player) {
+	if s == nil || p == nil {
+		return
+	}
+	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerDropLine, sceneId=", s.GetSceneId(), " player=", p.SnId)
+	s.FirePlayerEvent(p, base.PlayerEventDropLine, nil)
+}
+
+func (this *PolicyClawdoll) OnPlayerRehold(s *base.Scene, p *base.Player) {
+	if s == nil || p == nil {
+		return
+	}
+	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerRehold, sceneId=", s.GetSceneId(), " player=", p.SnId)
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		if _, ok := p.ExtraData.(*PlayerEx); ok {
+			//发送房间信息给自己
+			if p.IsGameing() {
+				p.MarkFlag(base.PlayerState_Ready)
+			}
+			this.SendRoomInfo(s, p, sceneEx)
+			s.FirePlayerEvent(p, base.PlayerEventRehold, nil)
+		}
+	}
+}
+
+func (this *PolicyClawdoll) OnPlayerReturn(s *base.Scene, p *base.Player) {
+	if s == nil || p == nil {
+		return
+	}
+	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerRehold, sceneId=", s.GetSceneId(), " player=", p.SnId)
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		if _, ok := p.ExtraData.(*PlayerEx); ok {
+			//发送房间信息给自己
+			if p.IsGameing() {
+				p.MarkFlag(base.PlayerState_Ready)
+			}
+			this.SendRoomInfo(s, p, sceneEx)
+			s.FirePlayerEvent(p, base.PlayerEventReturn, nil)
+		}
+	}
+}
+
+func (this *PolicyClawdoll) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
+	if s == nil || p == nil {
+		return false
+	}
+	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerOp, sceneId=", s.GetSceneId(), " player=", p.SnId, " opcode=", opcode, " params=", params)
+	if s.SceneState != nil {
+		p.LastOPTimer = time.Now()
+		p.Trusteeship = 0
+		return s.SceneState.OnPlayerOp(s, p, opcode, params)
+	}
+	return true
+}
+
+func (this *PolicyClawdoll) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
+	if s == nil || p == nil {
+		return
+	}
+	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " eventcode=", evtcode, " params=", params)
+	if s.SceneState != nil {
+		s.SceneState.OnPlayerEvent(s, p, evtcode, params)
+	}
+}
+
+func (this *PolicyClawdoll) IsCompleted(s *base.Scene) bool {
+	if s == nil {
+		return false
+	}
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		return !sceneEx.Gaming
+	}
+	return false
+}
+
+func (this *PolicyClawdoll) IsCanForceStart(s *base.Scene) bool {
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		return len(s.Players) >= 2 && !sceneEx.Gaming
+	}
+	return false
+}
+
+func (this *PolicyClawdoll) ForceStart(s *base.Scene) {
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		if sceneEx.SceneState.GetState() == rule.ClawDollSceneStateWait {
+			s.ChangeSceneState(rule.ClawDollSceneStateStart)
+		}
+	}
+}
+
+// 当前状态能否退出游戏
+func (this *PolicyClawdoll) CanChangeCoinScene(s *base.Scene, p *base.Player) bool {
+	if s == nil || p == nil {
+		return false
+	}
+	if s.GetSceneState() != nil {
+		return s.GetSceneState().CanChangeCoinScene(s, p)
+	}
+
+	return true
+}
+
+func (this *PolicyClawdoll) SendRoomInfo(s *base.Scene, p *base.Player, sceneEx *SceneEx) {
+	pack := sceneEx.ClawdollCreateRoomInfoPacket(s, p)
+	p.SendToClient(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_CLAWDOLL_ROOMINFO), pack)
+}
+
+// 广播房间状态
+func ClawdollBroadcastRoomState(s *base.Scene, params ...float32) {
+	pack := &clawdoll.SCCLAWDOLLRoomState{
+		State:  proto.Int(s.SceneState.GetState()),
+		Params: params,
+	}
+	s.Broadcast(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_CLAWDOLL_ROOMSTATE), pack, 0)
+}
+
+//=====================================
+// BaseState 状态基类
+//=====================================
+
+type BaseState struct {
+}
+
+func (this *BaseState) GetTimeout(s *base.Scene) int {
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		return int(time.Now().Sub(sceneEx.StateStartTime) / time.Second)
+	}
+	return 0
+}
+
+func (this *BaseState) CanChangeTo(s base.SceneState) bool {
+	return true
+}
+
+func (this *BaseState) CanChangeCoinScene(s *base.Scene, p *base.Player) bool {
+
+	//playerEx, ok := p.ExtraData.(*PlayerEx)
+	//if !ok {
+	//	return false
+	//}
+	//
+	//if !playerEx.CanLeaveScene(s.GetSceneState().GetState()) {
+	//	return false
+	//}
+
+	return true
+}
+
+func (this *BaseState) OnEnter(s *base.Scene) {
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		sceneEx.StateStartTime = time.Now()
+	}
+}
+
+func (this *BaseState) OnLeave(s *base.Scene) {}
+
+func (this *BaseState) OnTick(s *base.Scene) {
+}
+
+func (this *BaseState) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
+
+	return false
+}
+
+func (this *BaseState) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
+}
+
+//=====================================
+// StateWait 等待中
+//=====================================
+
+type StateWait struct {
+	BaseState
+}
+
+func (this *StateWait) GetState() int {
+	return rule.ClawDollSceneStateWait
+}
+
+func (this *StateWait) CanChangeTo(s base.SceneState) bool {
+	if s.GetState() == rule.ClawDollSceneStateStart {
+		return true
+	}
+	return false
+}
+
+func (this *StateWait) GetTimeout(s *base.Scene) int {
+
+	return this.BaseState.GetTimeout(s)
+}
+
+func (this *StateWait) OnEnter(s *base.Scene) {
+	this.BaseState.OnEnter(s)
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		if s.Gaming {
+			s.NotifySceneRoundPause()
+		}
+		s.Gaming = false
+
+		ClawdollBroadcastRoomState(s, float32(0), float32(0))
+
+		if sceneEx.CanStart() {
+			s.ChangeSceneState(rule.ClawDollSceneStateStart)
+		}
+	}
+}
+
+// 玩家事件
+func (this *StateWait) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
+	logger.Logger.Trace("(this *StateWait) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " evtcode=", evtcode)
+	this.BaseState.OnPlayerEvent(s, p, evtcode, params)
+	if _, ok := s.ExtraData.(*SceneEx); ok {
+		switch evtcode {
+		case base.PlayerEventLeave:
+		case base.PlayerEventEnter:
+			if !p.IsReady() {
+				p.MarkFlag(base.PlayerState_Ready)
+				p.SyncFlag()
+			}
+		}
+	}
+}
+
+func (this *StateWait) OnTick(s *base.Scene) {
+	this.BaseState.OnTick(s)
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		if s.CheckNeedDestroy() {
+			sceneEx.SceneDestroy(true)
+			return
+		}
+		if time.Now().Sub(sceneEx.StateStartTime) > rule.ClawDollSceneWaitTimeout {
+			//切换到准备开局状态
+			if sceneEx.CanStart() {
+				s.ChangeSceneState(rule.ClawDollSceneStateStart)
+			}
+		}
+	}
+}
+
+//=====================================
+// StateStart 开始倒计时
+//=====================================
+
+type StateStart struct {
+	BaseState
+}
+
+func (this *StateStart) GetState() int {
+	return rule.ClawDollSceneStateStart
+}
+
+func (this *StateStart) CanChangeTo(s base.SceneState) bool {
+	switch s.GetState() {
+	case rule.ClawDollSceneStatePlayGame:
+		return true
+	}
+	return false
+}
+
+func (this *StateStart) OnEnter(s *base.Scene) {
+	this.BaseState.OnEnter(s)
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		ClawdollBroadcastRoomState(s, float32(0), float32(0))
+		s.Gaming = false
+		sceneEx.GameNowTime = time.Now()
+		sceneEx.NumOfGames++
+
+	}
+}
+
+func (this *StateStart) OnTick(s *base.Scene) {
+	this.BaseState.OnTick(s)
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		if time.Now().Sub(sceneEx.StateStartTime) > rule.ClawDollSceneStartTimeout {
+			//切换到等待操作状态
+			if sceneEx.CanStart() {
+				s.ChangeSceneState(rule.ClawDollSceneStatePlayGame)
+			} else {
+				s.ChangeSceneState(rule.ClawDollSceneStateWait)
+			}
+		}
+	}
+}
+
+func (this *StateStart) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
+	if this.BaseState.OnPlayerOp(s, p, opcode, params) {
+		return true
+	}
+
+	return false
+}
+
+func (this *StateStart) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
+	logger.Logger.Trace("(this *StateStart) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " evtcode=", evtcode)
+	this.BaseState.OnPlayerEvent(s, p, evtcode, params)
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		switch evtcode {
+		case base.PlayerEventLeave:
+			if !sceneEx.CanStart() {
+				s.ChangeSceneState(rule.ClawDollSceneStateWait)
+			}
+		case base.PlayerEventEnter:
+			if !p.IsReady() {
+				p.MarkFlag(base.PlayerState_Ready)
+				p.SyncFlag()
+			}
+		}
+	}
+}
+
+// =====================================
+// PlayGame 游戏中
+// =====================================
+type PlayGame struct {
+	BaseState
+}
+
+func (this *PlayGame) GetState() int {
+	return rule.ClawDollSceneStatePlayGame
+}
+
+func (this *PlayGame) CanChangeTo(s base.SceneState) bool {
+	switch s.GetState() {
+	case rule.ClawDollSceneStateBilled:
+		return true
+	}
+	return false
+}
+
+func (this *PlayGame) OnEnter(s *base.Scene) {
+	logger.Logger.Trace("(this *PlayGame) OnEnter, sceneid=", s.GetSceneId())
+
+	this.BaseState.OnEnter(s)
+
+	s.Gaming = true
+
+	ClawdollBroadcastRoomState(s, float32(0), float32(0))
+
+}
+
+func (this *PlayGame) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
+
+	logger.Logger.Trace("StatePlayGame OnPlayerOp-----SnId:", p.SnId, " opcode: ", opcode, " params:", params)
+
+	if this.BaseState.OnPlayerOp(s, p, opcode, params) {
+		return true
+	}
+
+	return false
+}
+
+func (this *PlayGame) OnTick(s *base.Scene) {
+	this.BaseState.OnTick(s)
+}
+
+//=====================================
+// StateBilled 结算
+//=====================================
+
+type StateBilled struct {
+	BaseState
+}
+
+func (this *StateBilled) GetState() int {
+	return rule.ClawDollSceneStateBilled
+}
+
+func (this *StateBilled) CanChangeTo(s base.SceneState) bool {
+	switch s.GetState() {
+	case rule.ClawDollSceneStateStart:
+		return true
+	}
+	return false
+}
+
+func (this *StateBilled) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
+	return false
+}
+
+func (this *StateBilled) OnEnter(s *base.Scene) {
+	logger.Logger.Trace("(this *StateBilled) OnEnter, sceneid=", s.GetSceneId())
+	this.BaseState.OnEnter(s)
+}
+
+func (this *StateBilled) OnLeave(s *base.Scene) {
+	logger.Logger.Trace("(this *StateBilled) OnLeave, sceneid=", s.GetSceneId())
+	this.BaseState.OnLeave(s)
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+
+		sceneEx.PlayerBackup = make(map[int32]*PlayerData)
+
+		if s.CheckNeedDestroy() {
+			sceneEx.SceneDestroy(true)
+		}
+	}
+}
+
+func (this *StateBilled) OnTick(s *base.Scene) {
+	this.BaseState.OnTick(s)
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		if time.Now().Sub(sceneEx.StateStartTime) > rule.ClawDollSceneBilledTimeout {
+			if sceneEx.CanStart() {
+				s.ChangeSceneState(rule.ClawDollSceneStateStart)
+			} else {
+				s.ChangeSceneState(rule.ClawDollSceneStateWait)
+			}
+			return
+		}
+	}
+}
+
+// // //////////////////////////////////////////////////////////////////////////////
+func (this *PolicyClawdoll) RegisteSceneState(state base.SceneState) {
+	if state == nil {
+		return
+	}
+	stateid := state.GetState()
+
+	if stateid < 0 || stateid >= rule.ClawDollSceneStateMax {
+		return
+	}
+	this.states[stateid] = state
+}
+
+func (this *PolicyClawdoll) GetSceneState(s *base.Scene, stateid int) base.SceneState {
+	if stateid >= 0 && stateid < rule.ClawDollSceneStateMax {
+		return this.states[stateid]
+	}
+	return nil
+}
+
+func init() {
+	PolicyClawdollSingleton.RegisteSceneState(&StateWait{})
+	PolicyClawdollSingleton.RegisteSceneState(&StateStart{})
+	PolicyClawdollSingleton.RegisteSceneState(&PlayGame{})
+	PolicyClawdollSingleton.RegisteSceneState(&StateBilled{})
+
+	core.RegisteHook(core.HOOK_BEFORE_START, func() error {
+		base.RegisteScenePolicy(common.GameId_Clawdoll, 0, PolicyClawdollSingleton)
+
+		return nil
+	})
+}

gamesrv/machine/action_machine.go

@@ -1,14 +0,0 @@
-package machine
-
-import (
-	"mongo.games.com/game/protocol/machine"
-	"mongo.games.com/goserver/core/netlib"
-)
-
-func MSDollMachineListHandler(session *netlib.Session, packetId int, data interface{}) error {
-
-	return nil
-}
-func init() {
-	netlib.Register(int(machine.DollMachinePacketID_PACKET_MSDollMachineList), &machine.MSDollMachineList{}, MSDollMachineListHandler)
-}

machine/action/action_server.go

@@ -68,6 +68,8 @@ func SMDollMachineGrabHandler(session *netlib.Session, packetId int, data interf
 		machinedoll.Grab(conn)
 	} else if typeId == 3 {
 		//必中抓
+		machinedoll.SetPower(conn)
+		time.Sleep(200 * time.Millisecond)
 		machinedoll.Grab(conn)
 	}
 	//返回消息
@@ -92,7 +94,7 @@ func SMGameLinkSucceedHandler(session *netlib.Session, packetId int, data interf
 		msg.Data = append(msg.Data, info)
 	}
 	session.Send(int(machine.DollMachinePacketID_PACKET_MSDollMachineList), msg)
-	fmt.Printf("开始向游戏服务器发送娃娃机连接信息！\n")
+	fmt.Printf("开始向游戏服务器发送娃娃机连接信息！\n", msg)
 	return nil
 }
 func init() {

machine/machinedoll/command.go

@@ -103,6 +103,13 @@ func Grab(conn net.Conn) {
 		fmt.Println("Failed to send command to server:", err)
 		return
 	}
+	// 读取服务端的响应
+	buf := make([]byte, 1024)
+	_, err = conn.Read(buf)
+	if err != nil {
+		fmt.Println("Failed to read response from server:", err)
+		return
+	}
 }
 
 // 弱抓aa 05 01 50 06 00 52 dd

machine/machinedoll/machinemgr.go

@@ -37,16 +37,13 @@ const heartbeatInterval = 1
 
 func (this *MachineManager) Init() {
 	var serverAddrs []string
-	// 获取程序所在的绝对路径
 	programDir, err := os.Getwd()
 	if err != nil {
 		fmt.Println("Error getting working directory:", err)
 		return
 	}
-
-	// 构建配置文件的绝对路径
 	configFile := filepath.Join(programDir, "machineIPConfig.json")
-
+	fmt.Println("构建配置文件的路径", configFile)
 	fileData, err := os.ReadFile(configFile)
 	if err != nil {
 		logger.Logger.Error("Read robot account file error:", err)
@@ -72,10 +69,10 @@ func (this *MachineManager) Init() {
 	fmt.Println("投币请按Q！！！！")
 	fmt.Println("w向前s向后a向左d向右 j强力抓取k弱力抓取！")
 	// 监听 WASD 按键事件
-	//go listenKeyboardEvents(ConnMap[1])
+	/*	go listenKeyboardEvents(ConnMap[1])
 
 		// 监听中断信号,等待用户退出
-	//waitForUserExit()
+		waitForUserExit()*/
 }
 func (this *MachineManager) StartHeartbeat(id int, conn *net.Conn, addr string) {
 	// 定期发送心跳包
@@ -195,6 +192,8 @@ func listenKeyboardEvents(conn net.Conn) {
 		case "j":
 			Grab(conn)
 		case "J":
+			SetPower(conn)
+			time.Sleep(200 * time.Millisecond)
 			Grab(conn)
 
 		case "k":
@@ -209,7 +208,6 @@ func listenKeyboardEvents(conn net.Conn) {
 			BackwardStop(conn)
 		case "Q":
 			Coin(conn)
-
 			Backward(conn)
 			time.Sleep(150 * time.Millisecond)
 			BackwardStop(conn)

protocol/clawdoll/clawdoll.proto

@@ -0,0 +1,103 @@
+syntax = "proto3";
+package clawdoll;
+option go_package = "mongo.games.com/game/protocol/clawdoll";
+
+//娃娃机
+enum CLAWDOLLPacketID {
+    PACKET_CLAWDOLL_ZERO = 0;              //弃用消息号
+    PACKET_SC_CLAWDOLL_ROOMINFO = 5601;    //房间信息
+    PACKET_CS_CLAWDOLL_PLAYEROP = 5602;    //玩家操作（客户->服务）
+    PACKET_SC_CLAWDOLL_PLAYEROP = 5603;    //玩家操作（服务->客户）
+    PACKET_SC_CLAWDOLL_ROOMSTATE = 5604;   //房间状态
+    PACKET_SC_CLAWDOLL_GAMEBILLED = 5605;  //游戏结算
+    PACKET_SC_CLAWDOLL_PlayerEnter = 5606; // 玩家进入
+    PACKET_SC_CLAWDOLL_PlayerLeave = 5607; // 玩家离开
+    PACKET_SC_CLAWDOLL_PLAYERINFO = 5608; // 玩家状态信息变化
+}
+
+//操作结果
+enum OpResultCode {
+    OPRC_Success = 0; //成功
+    OPRC_Error = 1; //失败
+    OPRC_CoinNotEnough = 2; //钱不够
+    OPRC_PosAlReadyPlaying = 3; //本局位置已存在玩家
+}
+
+message CLAWDOLLPlayerData {
+    string Name = 1;       //名字
+    int32 SnId = 2;        //账号
+    int32 Head = 3;        //头像
+    int32 Sex = 4;         //性别
+    int64 Coin = 5;        //金币
+    int32 HeadOutLine = 6; //头像框
+    int32 VIP = 7;
+    int32 Flag = 8;         //二进制标记 第一位:是否掉线(0:在线 1:掉线) 第二位:是否准备(0:未准备 1:已准备)
+
+    int64 WinCoin = 9;     // 本局赢分
+
+}
+
+//房间信息
+message SCCLAWDOLLRoomInfo {
+    int32 RoomId = 1;                 //房间id
+    int32 GameId = 2;                 //游戏id
+    int32 RoomMode = 3;               //游戏模式
+    repeated int32 Params = 4;        //规则参数
+    int32 State = 5;                  //房间当前状态
+    int32 TimeOut = 6;	              //该状态已经历时间 单位:秒
+    repeated CLAWDOLLPlayerData Players = 7;   //房间内的玩家信息
+    int32 TotalPlayer = 8;           //房间总人数
+	  int32 RoundId = 9;                //当前局数ID
+	  repeated int32 ParamsEx = 10;     //其他参数
+
+    int32 GameFreeId = 15;
+    int32 BaseScore = 16; //基础分
+}
+
+//玩家操作
+message CSCLAWDOLLOp {
+    int32 OpCode = 1;
+    repeated int64 Params = 2;
+}
+
+//玩家操作返回
+message SCCLAWDOLLOp {
+    int32 SnId = 1;                //玩家ID
+    int32 OpCode = 2;              //操作码
+    repeated int64 Params = 3;     //操作参数 同上 CSCLAWDOLLOp
+    OpResultCode OpRetCode = 4;    //操作结果
+}
+
+//发送给客户端的数据 单局结算
+message SCCLAWDOLLRoundGameBilled {
+	  int32 RoundId = 1;              //牌局ID
+    int32 ClowResult = 2;           //抓取结果
+    int64 Award = 3;                //获奖金额
+	  int64 Balance = 4;              //玩家余额
+}
+
+//房间状态
+message SCCLAWDOLLRoomState {
+    int32 State = 1; //房间当前状态
+    repeated float Params = 2;
+}
+
+//玩家信息
+message SCCLAWDOLLPlayerInfo {
+    int32 SnId = 1;                //玩家ID
+    int64 gainCoin = 2;             //本局赢取
+    int64 Coin = 3;                 // 玩家
+}
+
+
+//玩家进入
+//PACKET_SCCLAWDOLLPlayerEnter
+message SCCLAWDOLLPlayerEnter {
+    CLAWDOLLPlayerData Data = 1;
+}
+
+//玩家离开
+//PACKET_SCCLAWDOLLPlayerLeave
+message SCCLAWDOLLPlayerLeave {
+    int32 Pos = 1; //玩家位置
+}

protocol/dollmachine/dollmachine.pb.go

@@ -0,0 +1,537 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.1-devel
+// 	protoc        v3.19.4
+// source: dollmachine.proto
+
+package dollmachine
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+//S-GAME M-娃娃机主机
+//娃娃机协议
+type DollMachinePacketID int32
+
+const (
+	DollMachinePacketID_PACKET_SMDollMachineZero DollMachinePacketID = 0
+	DollMachinePacketID_PACKET_SMDollMachineMove DollMachinePacketID = 3001
+	DollMachinePacketID_PACKET_SMDollMachineGrab DollMachinePacketID = 3002
+	DollMachinePacketID_PACKET_MSDollMachineGrab DollMachinePacketID = 3003
+	DollMachinePacketID_PACKET_MSDollMachineList DollMachinePacketID = 3004
+)
+
+// Enum value maps for DollMachinePacketID.
+var (
+	DollMachinePacketID_name = map[int32]string{
+		0:    "PACKET_SMDollMachineZero",
+		3001: "PACKET_SMDollMachineMove",
+		3002: "PACKET_SMDollMachineGrab",
+		3003: "PACKET_MSDollMachineGrab",
+		3004: "PACKET_MSDollMachineList",
+	}
+	DollMachinePacketID_value = map[string]int32{
+		"PACKET_SMDollMachineZero": 0,
+		"PACKET_SMDollMachineMove": 3001,
+		"PACKET_SMDollMachineGrab": 3002,
+		"PACKET_MSDollMachineGrab": 3003,
+		"PACKET_MSDollMachineList": 3004,
+	}
+)
+
+func (x DollMachinePacketID) Enum() *DollMachinePacketID {
+	p := new(DollMachinePacketID)
+	*p = x
+	return p
+}
+
+func (x DollMachinePacketID) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (DollMachinePacketID) Descriptor() protoreflect.EnumDescriptor {
+	return file_dollmachine_proto_enumTypes[0].Descriptor()
+}
+
+func (DollMachinePacketID) Type() protoreflect.EnumType {
+	return &file_dollmachine_proto_enumTypes[0]
+}
+
+func (x DollMachinePacketID) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use DollMachinePacketID.Descriptor instead.
+func (DollMachinePacketID) EnumDescriptor() ([]byte, []int) {
+	return file_dollmachine_proto_rawDescGZIP(), []int{0}
+}
+
+//移动
+type SMDollMachineMove struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Snid      int32 `protobuf:"varint,1,opt,name=Snid,proto3" json:"Snid,omitempty"`
+	Id        int32 `protobuf:"varint,2,opt,name=Id,proto3" json:"Id,omitempty"`               //娃娃机标识
+	Direction int32 `protobuf:"varint,3,opt,name=Direction,proto3" json:"Direction,omitempty"` // 1-前 2-后 3-左 4-右
+}
+
+func (x *SMDollMachineMove) Reset() {
+	*x = SMDollMachineMove{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_dollmachine_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SMDollMachineMove) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SMDollMachineMove) ProtoMessage() {}
+
+func (x *SMDollMachineMove) ProtoReflect() protoreflect.Message {
+	mi := &file_dollmachine_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SMDollMachineMove.ProtoReflect.Descriptor instead.
+func (*SMDollMachineMove) Descriptor() ([]byte, []int) {
+	return file_dollmachine_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *SMDollMachineMove) GetSnid() int32 {
+	if x != nil {
+		return x.Snid
+	}
+	return 0
+}
+
+func (x *SMDollMachineMove) GetId() int32 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+func (x *SMDollMachineMove) GetDirection() int32 {
+	if x != nil {
+		return x.Direction
+	}
+	return 0
+}
+
+//下抓
+type SMDollMachineGrab struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	TypeId int32 `protobuf:"varint,1,opt,name=TypeId,proto3" json:"TypeId,omitempty"` //1-弱力抓 2 -强力抓 3-必出抓
+	Id     int32 `protobuf:"varint,2,opt,name=Id,proto3" json:"Id,omitempty"`         //娃娃机标识
+	Snid   int32 `protobuf:"varint,3,opt,name=Snid,proto3" json:"Snid,omitempty"`
+}
+
+func (x *SMDollMachineGrab) Reset() {
+	*x = SMDollMachineGrab{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_dollmachine_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SMDollMachineGrab) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SMDollMachineGrab) ProtoMessage() {}
+
+func (x *SMDollMachineGrab) ProtoReflect() protoreflect.Message {
+	mi := &file_dollmachine_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SMDollMachineGrab.ProtoReflect.Descriptor instead.
+func (*SMDollMachineGrab) Descriptor() ([]byte, []int) {
+	return file_dollmachine_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *SMDollMachineGrab) GetTypeId() int32 {
+	if x != nil {
+		return x.TypeId
+	}
+	return 0
+}
+
+func (x *SMDollMachineGrab) GetId() int32 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+func (x *SMDollMachineGrab) GetSnid() int32 {
+	if x != nil {
+		return x.Snid
+	}
+	return 0
+}
+
+//返回下抓结果
+type MSDollMachineGrab struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Snid   int32 `protobuf:"varint,1,opt,name=Snid,proto3" json:"Snid,omitempty"`
+	Id     int32 `protobuf:"varint,2,opt,name=Id,proto3" json:"Id,omitempty"`         //娃娃机标识
+	Result int32 `protobuf:"varint,3,opt,name=Result,proto3" json:"Result,omitempty"` //1-中奖 其他未中奖
+}
+
+func (x *MSDollMachineGrab) Reset() {
+	*x = MSDollMachineGrab{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_dollmachine_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MSDollMachineGrab) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MSDollMachineGrab) ProtoMessage() {}
+
+func (x *MSDollMachineGrab) ProtoReflect() protoreflect.Message {
+	mi := &file_dollmachine_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MSDollMachineGrab.ProtoReflect.Descriptor instead.
+func (*MSDollMachineGrab) Descriptor() ([]byte, []int) {
+	return file_dollmachine_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *MSDollMachineGrab) GetSnid() int32 {
+	if x != nil {
+		return x.Snid
+	}
+	return 0
+}
+
+func (x *MSDollMachineGrab) GetId() int32 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+func (x *MSDollMachineGrab) GetResult() int32 {
+	if x != nil {
+		return x.Result
+	}
+	return 0
+}
+
+//返回所有娃娃机连接
+type MSDollMachineList struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Data []*DollMachine `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
+}
+
+func (x *MSDollMachineList) Reset() {
+	*x = MSDollMachineList{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_dollmachine_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MSDollMachineList) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MSDollMachineList) ProtoMessage() {}
+
+func (x *MSDollMachineList) ProtoReflect() protoreflect.Message {
+	mi := &file_dollmachine_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MSDollMachineList.ProtoReflect.Descriptor instead.
+func (*MSDollMachineList) Descriptor() ([]byte, []int) {
+	return file_dollmachine_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *MSDollMachineList) GetData() []*DollMachine {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
+type DollMachine struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id     int32 `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"`
+	Status int32 `protobuf:"varint,2,opt,name=Status,proto3" json:"Status,omitempty"` //1-空闲 2-无法使用
+}
+
+func (x *DollMachine) Reset() {
+	*x = DollMachine{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_dollmachine_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DollMachine) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DollMachine) ProtoMessage() {}
+
+func (x *DollMachine) ProtoReflect() protoreflect.Message {
+	mi := &file_dollmachine_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DollMachine.ProtoReflect.Descriptor instead.
+func (*DollMachine) Descriptor() ([]byte, []int) {
+	return file_dollmachine_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *DollMachine) GetId() int32 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+func (x *DollMachine) GetStatus() int32 {
+	if x != nil {
+		return x.Status
+	}
+	return 0
+}
+
+var File_dollmachine_proto protoreflect.FileDescriptor
+
+var file_dollmachine_proto_rawDesc = []byte{
+	0x0a, 0x11, 0x64, 0x6f, 0x6c, 0x6c, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x12, 0x0b, 0x64, 0x6f, 0x6c, 0x6c, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
+	0x22, 0x55, 0x0a, 0x11, 0x53, 0x4d, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e,
+	0x65, 0x4d, 0x6f, 0x76, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x53, 0x6e, 0x69, 0x64, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x04, 0x53, 0x6e, 0x69, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x44, 0x69, 0x72,
+	0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x44, 0x69,
+	0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x4f, 0x0a, 0x11, 0x53, 0x4d, 0x44, 0x6f, 0x6c,
+	0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x47, 0x72, 0x61, 0x62, 0x12, 0x16, 0x0a, 0x06,
+	0x54, 0x79, 0x70, 0x65, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x54, 0x79,
+	0x70, 0x65, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x02, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x53, 0x6e, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x04, 0x53, 0x6e, 0x69, 0x64, 0x22, 0x4f, 0x0a, 0x11, 0x4d, 0x53, 0x44, 0x6f,
+	0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x47, 0x72, 0x61, 0x62, 0x12, 0x12, 0x0a,
+	0x04, 0x53, 0x6e, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x53, 0x6e, 0x69,
+	0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49,
+	0x64, 0x12, 0x16, 0x0a, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x41, 0x0a, 0x11, 0x4d, 0x53, 0x44,
+	0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x2c,
+	0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x64,
+	0x6f, 0x6c, 0x6c, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2e, 0x44, 0x6f, 0x6c, 0x6c, 0x4d,
+	0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x35, 0x0a, 0x0b,
+	0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x49,
+	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x53,
+	0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x53, 0x74, 0x61,
+	0x74, 0x75, 0x73, 0x2a, 0xaf, 0x01, 0x0a, 0x13, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68,
+	0x69, 0x6e, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x18, 0x50,
+	0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f, 0x53, 0x4d, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68,
+	0x69, 0x6e, 0x65, 0x5a, 0x65, 0x72, 0x6f, 0x10, 0x00, 0x12, 0x1d, 0x0a, 0x18, 0x50, 0x41, 0x43,
+	0x4b, 0x45, 0x54, 0x5f, 0x53, 0x4d, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e,
+	0x65, 0x4d, 0x6f, 0x76, 0x65, 0x10, 0xb9, 0x17, 0x12, 0x1d, 0x0a, 0x18, 0x50, 0x41, 0x43, 0x4b,
+	0x45, 0x54, 0x5f, 0x53, 0x4d, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
+	0x47, 0x72, 0x61, 0x62, 0x10, 0xba, 0x17, 0x12, 0x1d, 0x0a, 0x18, 0x50, 0x41, 0x43, 0x4b, 0x45,
+	0x54, 0x5f, 0x4d, 0x53, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x47,
+	0x72, 0x61, 0x62, 0x10, 0xbb, 0x17, 0x12, 0x1d, 0x0a, 0x18, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54,
+	0x5f, 0x4d, 0x53, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x4c, 0x69,
+	0x73, 0x74, 0x10, 0xbc, 0x17, 0x42, 0x2b, 0x5a, 0x29, 0x6d, 0x6f, 0x6e, 0x67, 0x6f, 0x2e, 0x67,
+	0x61, 0x6d, 0x65, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x61, 0x6d, 0x65, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x64, 0x6f, 0x6c, 0x6c, 0x6d, 0x61, 0x63, 0x68, 0x69,
+	0x6e, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_dollmachine_proto_rawDescOnce sync.Once
+	file_dollmachine_proto_rawDescData = file_dollmachine_proto_rawDesc
+)
+
+func file_dollmachine_proto_rawDescGZIP() []byte {
+	file_dollmachine_proto_rawDescOnce.Do(func() {
+		file_dollmachine_proto_rawDescData = protoimpl.X.CompressGZIP(file_dollmachine_proto_rawDescData)
+	})
+	return file_dollmachine_proto_rawDescData
+}
+
+var file_dollmachine_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_dollmachine_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_dollmachine_proto_goTypes = []interface{}{
+	(DollMachinePacketID)(0),  // 0: dollmachine.DollMachinePacketID
+	(*SMDollMachineMove)(nil), // 1: dollmachine.SMDollMachineMove
+	(*SMDollMachineGrab)(nil), // 2: dollmachine.SMDollMachineGrab
+	(*MSDollMachineGrab)(nil), // 3: dollmachine.MSDollMachineGrab
+	(*MSDollMachineList)(nil), // 4: dollmachine.MSDollMachineList
+	(*DollMachine)(nil),       // 5: dollmachine.DollMachine
+}
+var file_dollmachine_proto_depIdxs = []int32{
+	5, // 0: dollmachine.MSDollMachineList.data:type_name -> dollmachine.DollMachine
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_dollmachine_proto_init() }
+func file_dollmachine_proto_init() {
+	if File_dollmachine_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_dollmachine_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SMDollMachineMove); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_dollmachine_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SMDollMachineGrab); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_dollmachine_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MSDollMachineGrab); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_dollmachine_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MSDollMachineList); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_dollmachine_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DollMachine); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_dollmachine_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   5,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_dollmachine_proto_goTypes,
+		DependencyIndexes: file_dollmachine_proto_depIdxs,
+		EnumInfos:         file_dollmachine_proto_enumTypes,
+		MessageInfos:      file_dollmachine_proto_msgTypes,
+	}.Build()
+	File_dollmachine_proto = out.File
+	file_dollmachine_proto_rawDesc = nil
+	file_dollmachine_proto_goTypes = nil
+	file_dollmachine_proto_depIdxs = nil
+}

protocol/dollmachine/dollmachine.proto

@@ -1,27 +1,22 @@
 syntax = "proto3";
-package machine;
+package dollmachine;
-option go_package = "mongo.games.com/game/protocol/machine";
+option go_package = "mongo.games.com/game/protocol/dollmachine";
 
 //S-GAME M-娃娃机主机
-
 //娃娃机协议
 enum DollMachinePacketID {
 	PACKET_SMDollMachineZero = 0; 
-	PACKET_SMGameLinkSucceed = 20000;
+	PACKET_SMDollMachineMove  = 3001;
-	PACKET_SMDollMachinePerate  = 20001;
+	PACKET_SMDollMachineGrab = 3002;
-	PACKET_SMDollMachineGrab = 20002;
+	PACKET_MSDollMachineGrab = 3003;
-	PACKET_MSDollMachineGrab = 20003;
+	PACKET_MSDollMachineList = 3004;
-	PACKET_MSDollMachineList = 20004;
-}
-//通知链接成功
-message SMGameLinkSucceed{
 }
 
-//操作
+//移动
-message SMDollMachineoPerate{
+message SMDollMachineMove{
 	int32 Snid = 1;
 	int32 Id = 2;	//娃娃机标识
-	int32 Perate = 3; // 1-前 2-后 3-左 4-右 5-投币
+	int32 Direction = 3; // 1-前 2-后 3-左 4-右
 }
 
 //下抓
@@ -44,5 +39,5 @@ message MSDollMachineList{
 }
 message DollMachine{
 	int32 Id = 1;
-	string VideoAddr = 2;
+	int32 Status = 2;	//1-空闲 2-无法使用
 }

protocol/gameMachine/machine.pb.go

@@ -1,594 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.27.1-devel
-// 	protoc        v3.19.4
-// source: machine.proto
-
-package machine
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-//娃娃机协议
-type DollMachinePacketID int32
-
-const (
-	DollMachinePacketID_PACKET_SMDollMachineZero   DollMachinePacketID = 0
-	DollMachinePacketID_PACKET_SMGameLinkSucceed   DollMachinePacketID = 20000
-	DollMachinePacketID_PACKET_SMDollMachinePerate DollMachinePacketID = 20001
-	DollMachinePacketID_PACKET_SMDollMachineGrab   DollMachinePacketID = 20002
-	DollMachinePacketID_PACKET_MSDollMachineGrab   DollMachinePacketID = 20003
-	DollMachinePacketID_PACKET_MSDollMachineList   DollMachinePacketID = 20004
-)
-
-// Enum value maps for DollMachinePacketID.
-var (
-	DollMachinePacketID_name = map[int32]string{
-		0:     "PACKET_SMDollMachineZero",
-		20000: "PACKET_SMGameLinkSucceed",
-		20001: "PACKET_SMDollMachinePerate",
-		20002: "PACKET_SMDollMachineGrab",
-		20003: "PACKET_MSDollMachineGrab",
-		20004: "PACKET_MSDollMachineList",
-	}
-	DollMachinePacketID_value = map[string]int32{
-		"PACKET_SMDollMachineZero":   0,
-		"PACKET_SMGameLinkSucceed":   20000,
-		"PACKET_SMDollMachinePerate": 20001,
-		"PACKET_SMDollMachineGrab":   20002,
-		"PACKET_MSDollMachineGrab":   20003,
-		"PACKET_MSDollMachineList":   20004,
-	}
-)
-
-func (x DollMachinePacketID) Enum() *DollMachinePacketID {
-	p := new(DollMachinePacketID)
-	*p = x
-	return p
-}
-
-func (x DollMachinePacketID) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (DollMachinePacketID) Descriptor() protoreflect.EnumDescriptor {
-	return file_machine_proto_enumTypes[0].Descriptor()
-}
-
-func (DollMachinePacketID) Type() protoreflect.EnumType {
-	return &file_machine_proto_enumTypes[0]
-}
-
-func (x DollMachinePacketID) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Use DollMachinePacketID.Descriptor instead.
-func (DollMachinePacketID) EnumDescriptor() ([]byte, []int) {
-	return file_machine_proto_rawDescGZIP(), []int{0}
-}
-
-//通知链接成功
-type SMGameLinkSucceed struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-}
-
-func (x *SMGameLinkSucceed) Reset() {
-	*x = SMGameLinkSucceed{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_machine_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *SMGameLinkSucceed) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SMGameLinkSucceed) ProtoMessage() {}
-
-func (x *SMGameLinkSucceed) ProtoReflect() protoreflect.Message {
-	mi := &file_machine_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use SMGameLinkSucceed.ProtoReflect.Descriptor instead.
-func (*SMGameLinkSucceed) Descriptor() ([]byte, []int) {
-	return file_machine_proto_rawDescGZIP(), []int{0}
-}
-
-//操作
-type SMDollMachineoPerate struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Snid   int32 `protobuf:"varint,1,opt,name=Snid,proto3" json:"Snid,omitempty"`
-	Id     int32 `protobuf:"varint,2,opt,name=Id,proto3" json:"Id,omitempty"`         //娃娃机标识
-	Perate int32 `protobuf:"varint,3,opt,name=Perate,proto3" json:"Perate,omitempty"` // 1-前 2-后 3-左 4-右 5-投币
-}
-
-func (x *SMDollMachineoPerate) Reset() {
-	*x = SMDollMachineoPerate{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_machine_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *SMDollMachineoPerate) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SMDollMachineoPerate) ProtoMessage() {}
-
-func (x *SMDollMachineoPerate) ProtoReflect() protoreflect.Message {
-	mi := &file_machine_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use SMDollMachineoPerate.ProtoReflect.Descriptor instead.
-func (*SMDollMachineoPerate) Descriptor() ([]byte, []int) {
-	return file_machine_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *SMDollMachineoPerate) GetSnid() int32 {
-	if x != nil {
-		return x.Snid
-	}
-	return 0
-}
-
-func (x *SMDollMachineoPerate) GetId() int32 {
-	if x != nil {
-		return x.Id
-	}
-	return 0
-}
-
-func (x *SMDollMachineoPerate) GetPerate() int32 {
-	if x != nil {
-		return x.Perate
-	}
-	return 0
-}
-
-//下抓
-type SMDollMachineGrab struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	TypeId int32 `protobuf:"varint,1,opt,name=TypeId,proto3" json:"TypeId,omitempty"` //1-弱力抓 2 -强力抓 3-必出抓
-	Id     int32 `protobuf:"varint,2,opt,name=Id,proto3" json:"Id,omitempty"`         //娃娃机标识
-	Snid   int32 `protobuf:"varint,3,opt,name=Snid,proto3" json:"Snid,omitempty"`
-}
-
-func (x *SMDollMachineGrab) Reset() {
-	*x = SMDollMachineGrab{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_machine_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *SMDollMachineGrab) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SMDollMachineGrab) ProtoMessage() {}
-
-func (x *SMDollMachineGrab) ProtoReflect() protoreflect.Message {
-	mi := &file_machine_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use SMDollMachineGrab.ProtoReflect.Descriptor instead.
-func (*SMDollMachineGrab) Descriptor() ([]byte, []int) {
-	return file_machine_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *SMDollMachineGrab) GetTypeId() int32 {
-	if x != nil {
-		return x.TypeId
-	}
-	return 0
-}
-
-func (x *SMDollMachineGrab) GetId() int32 {
-	if x != nil {
-		return x.Id
-	}
-	return 0
-}
-
-func (x *SMDollMachineGrab) GetSnid() int32 {
-	if x != nil {
-		return x.Snid
-	}
-	return 0
-}
-
-//返回下抓结果
-type MSDollMachineGrab struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Snid   int32 `protobuf:"varint,1,opt,name=Snid,proto3" json:"Snid,omitempty"`
-	Id     int32 `protobuf:"varint,2,opt,name=Id,proto3" json:"Id,omitempty"`         //娃娃机标识
-	Result int32 `protobuf:"varint,3,opt,name=Result,proto3" json:"Result,omitempty"` //1-中奖 其他未中奖
-}
-
-func (x *MSDollMachineGrab) Reset() {
-	*x = MSDollMachineGrab{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_machine_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *MSDollMachineGrab) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MSDollMachineGrab) ProtoMessage() {}
-
-func (x *MSDollMachineGrab) ProtoReflect() protoreflect.Message {
-	mi := &file_machine_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use MSDollMachineGrab.ProtoReflect.Descriptor instead.
-func (*MSDollMachineGrab) Descriptor() ([]byte, []int) {
-	return file_machine_proto_rawDescGZIP(), []int{3}
-}
-
-func (x *MSDollMachineGrab) GetSnid() int32 {
-	if x != nil {
-		return x.Snid
-	}
-	return 0
-}
-
-func (x *MSDollMachineGrab) GetId() int32 {
-	if x != nil {
-		return x.Id
-	}
-	return 0
-}
-
-func (x *MSDollMachineGrab) GetResult() int32 {
-	if x != nil {
-		return x.Result
-	}
-	return 0
-}
-
-//返回所有娃娃机连接
-type MSDollMachineList struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Data []*DollMachine `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
-}
-
-func (x *MSDollMachineList) Reset() {
-	*x = MSDollMachineList{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_machine_proto_msgTypes[4]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *MSDollMachineList) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MSDollMachineList) ProtoMessage() {}
-
-func (x *MSDollMachineList) ProtoReflect() protoreflect.Message {
-	mi := &file_machine_proto_msgTypes[4]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use MSDollMachineList.ProtoReflect.Descriptor instead.
-func (*MSDollMachineList) Descriptor() ([]byte, []int) {
-	return file_machine_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *MSDollMachineList) GetData() []*DollMachine {
-	if x != nil {
-		return x.Data
-	}
-	return nil
-}
-
-type DollMachine struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Id        int32  `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"`
-	VideoAddr string `protobuf:"bytes,2,opt,name=VideoAddr,proto3" json:"VideoAddr,omitempty"`
-}
-
-func (x *DollMachine) Reset() {
-	*x = DollMachine{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_machine_proto_msgTypes[5]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DollMachine) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DollMachine) ProtoMessage() {}
-
-func (x *DollMachine) ProtoReflect() protoreflect.Message {
-	mi := &file_machine_proto_msgTypes[5]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DollMachine.ProtoReflect.Descriptor instead.
-func (*DollMachine) Descriptor() ([]byte, []int) {
-	return file_machine_proto_rawDescGZIP(), []int{5}
-}
-
-func (x *DollMachine) GetId() int32 {
-	if x != nil {
-		return x.Id
-	}
-	return 0
-}
-
-func (x *DollMachine) GetVideoAddr() string {
-	if x != nil {
-		return x.VideoAddr
-	}
-	return ""
-}
-
-var File_machine_proto protoreflect.FileDescriptor
-
-var file_machine_proto_rawDesc = []byte{
-	0x0a, 0x0d, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
-	0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x22, 0x13, 0x0a, 0x11, 0x53, 0x4d, 0x47, 0x61,
-	0x6d, 0x65, 0x4c, 0x69, 0x6e, 0x6b, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x22, 0x52, 0x0a,
-	0x14, 0x53, 0x4d, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x6f, 0x50,
-	0x65, 0x72, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x53, 0x6e, 0x69, 0x64, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x05, 0x52, 0x04, 0x53, 0x6e, 0x69, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x50, 0x65, 0x72,
-	0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x50, 0x65, 0x72, 0x61, 0x74,
-	0x65, 0x22, 0x4f, 0x0a, 0x11, 0x53, 0x4d, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69,
-	0x6e, 0x65, 0x47, 0x72, 0x61, 0x62, 0x12, 0x16, 0x0a, 0x06, 0x54, 0x79, 0x70, 0x65, 0x49, 0x64,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x54, 0x79, 0x70, 0x65, 0x49, 0x64, 0x12, 0x0e,
-	0x0a, 0x02, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x12,
-	0x0a, 0x04, 0x53, 0x6e, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x53, 0x6e,
-	0x69, 0x64, 0x22, 0x4f, 0x0a, 0x11, 0x4d, 0x53, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68,
-	0x69, 0x6e, 0x65, 0x47, 0x72, 0x61, 0x62, 0x12, 0x12, 0x0a, 0x04, 0x53, 0x6e, 0x69, 0x64, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x53, 0x6e, 0x69, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49,
-	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x52,
-	0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x52, 0x65, 0x73,
-	0x75, 0x6c, 0x74, 0x22, 0x3d, 0x0a, 0x11, 0x4d, 0x53, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63,
-	0x68, 0x69, 0x6e, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61,
-	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
-	0x2e, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x04, 0x64, 0x61,
-	0x74, 0x61, 0x22, 0x3b, 0x0a, 0x0b, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e,
-	0x65, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49,
-	0x64, 0x12, 0x1c, 0x0a, 0x09, 0x56, 0x69, 0x64, 0x65, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x56, 0x69, 0x64, 0x65, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x2a,
-	0xd5, 0x01, 0x0a, 0x13, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x50,
-	0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x18, 0x50, 0x41, 0x43, 0x4b, 0x45,
-	0x54, 0x5f, 0x53, 0x4d, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5a,
-	0x65, 0x72, 0x6f, 0x10, 0x00, 0x12, 0x1e, 0x0a, 0x18, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f,
-	0x53, 0x4d, 0x47, 0x61, 0x6d, 0x65, 0x4c, 0x69, 0x6e, 0x6b, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65,
-	0x64, 0x10, 0xa0, 0x9c, 0x01, 0x12, 0x20, 0x0a, 0x1a, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f,
-	0x53, 0x4d, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x50, 0x65, 0x72,
-	0x61, 0x74, 0x65, 0x10, 0xa1, 0x9c, 0x01, 0x12, 0x1e, 0x0a, 0x18, 0x50, 0x41, 0x43, 0x4b, 0x45,
-	0x54, 0x5f, 0x53, 0x4d, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x47,
-	0x72, 0x61, 0x62, 0x10, 0xa2, 0x9c, 0x01, 0x12, 0x1e, 0x0a, 0x18, 0x50, 0x41, 0x43, 0x4b, 0x45,
-	0x54, 0x5f, 0x4d, 0x53, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x47,
-	0x72, 0x61, 0x62, 0x10, 0xa3, 0x9c, 0x01, 0x12, 0x1e, 0x0a, 0x18, 0x50, 0x41, 0x43, 0x4b, 0x45,
-	0x54, 0x5f, 0x4d, 0x53, 0x44, 0x6f, 0x6c, 0x6c, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x4c,
-	0x69, 0x73, 0x74, 0x10, 0xa4, 0x9c, 0x01, 0x42, 0x27, 0x5a, 0x25, 0x6d, 0x6f, 0x6e, 0x67, 0x6f,
-	0x2e, 0x67, 0x61, 0x6d, 0x65, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x61, 0x6d, 0x65, 0x2f,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
-	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_machine_proto_rawDescOnce sync.Once
-	file_machine_proto_rawDescData = file_machine_proto_rawDesc
-)
-
-func file_machine_proto_rawDescGZIP() []byte {
-	file_machine_proto_rawDescOnce.Do(func() {
-		file_machine_proto_rawDescData = protoimpl.X.CompressGZIP(file_machine_proto_rawDescData)
-	})
-	return file_machine_proto_rawDescData
-}
-
-var file_machine_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_machine_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
-var file_machine_proto_goTypes = []interface{}{
-	(DollMachinePacketID)(0),     // 0: machine.DollMachinePacketID
-	(*SMGameLinkSucceed)(nil),    // 1: machine.SMGameLinkSucceed
-	(*SMDollMachineoPerate)(nil), // 2: machine.SMDollMachineoPerate
-	(*SMDollMachineGrab)(nil),    // 3: machine.SMDollMachineGrab
-	(*MSDollMachineGrab)(nil),    // 4: machine.MSDollMachineGrab
-	(*MSDollMachineList)(nil),    // 5: machine.MSDollMachineList
-	(*DollMachine)(nil),          // 6: machine.DollMachine
-}
-var file_machine_proto_depIdxs = []int32{
-	6, // 0: machine.MSDollMachineList.data:type_name -> machine.DollMachine
-	1, // [1:1] is the sub-list for method output_type
-	1, // [1:1] is the sub-list for method input_type
-	1, // [1:1] is the sub-list for extension type_name
-	1, // [1:1] is the sub-list for extension extendee
-	0, // [0:1] is the sub-list for field type_name
-}
-
-func init() { file_machine_proto_init() }
-func file_machine_proto_init() {
-	if File_machine_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_machine_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SMGameLinkSucceed); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_machine_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SMDollMachineoPerate); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_machine_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SMDollMachineGrab); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_machine_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MSDollMachineGrab); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_machine_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MSDollMachineList); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_machine_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DollMachine); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_machine_proto_rawDesc,
-			NumEnums:      1,
-			NumMessages:   6,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_machine_proto_goTypes,
-		DependencyIndexes: file_machine_proto_depIdxs,
-		EnumInfos:         file_machine_proto_enumTypes,
-		MessageInfos:      file_machine_proto_msgTypes,
-	}.Build()
-	File_machine_proto = out.File
-	file_machine_proto_rawDesc = nil
-	file_machine_proto_goTypes = nil
-	file_machine_proto_depIdxs = nil
-}