gamerule/clawdoll/constants.go

@@ -8,17 +8,13 @@ const (
 	ClawDollSceneStateStart               //开始倒计时
 	ClawDollSceneStatePlayGame            //游戏中
 	ClawDollSceneStateBilled              //结算
-	ClawDollSceneWaitPayCoin              //等待下一局投币
 	ClawDollSceneStateMax
 )
 
 const (
 	ClawDollSceneWaitTimeout   = time.Second * 6  //等待倒计时
-	ClawDollSceneStartTimeout      = time.Second * 5  //开始倒计时
+	ClawDollSceneStartTimeout  = time.Second * 15 //开始倒计时
-	ClawDollScenePlayTimeout       = time.Second * 30 //娃娃机下抓倒计时
 	ClawDollSceneBilledTimeout = time.Second * 2  //结算
-	ClawDollSceneWaitPayCoinimeout = time.Second * 10 //等待下一局投币
-
 )
 
 // 玩家操作
@@ -28,13 +24,11 @@ const (
 	ClawDollPlayerOpMove               // 玩家操控动作 // 1-前 2-后 3-左 4-右
 )
 
-// 1-前 2-后 3-左 4-右 5-投币
 const (
 	ButtonFront = iota + 1 /*前*/
 	ButtonBack             /*后*/
 	ButtonLeft             /*左*/
 	ButtonRight            /*右*/
-	ButtonPayCoin            /*投币*/
 )
 
 const (

gamerule/clawdoll/queue.go

@@ -1,221 +0,0 @@
-package clawdoll
-
-//		queue队列容器包
-//		以动态数组的形式实现
-//		该容器可以在尾部实现线性增加元素,在首部实现线性减少元素
-//		队列的扩容和缩容同vector一样,即数组小采用翻倍扩缩容/折半缩容,数组大时采用固定扩/缩容
-//		该容器满足FIFO的先进先出模式
-//		可接纳不同类型的元素
-
-// queue队列结构体
-// 包含泛型切片和该切片的首尾位的下标
-// 当删除节点时仅仅需要后移首位一位即可
-// 当剩余长度较小时采用缩容策略进行缩容以释放空间
-// 当添加节点时若未占满全部已分配空间则尾指针后移一位同时进行覆盖存放
-// 当添加节点时尾指针大于已分配空间长度,则先去掉首部多出来的空间,如果还不足则进行扩容
-// 首节点指针始终不能超过尾节点指针
-type Queue struct {
-	data  []interface{} //泛型切片
-	begin uint64        //首节点下标
-	end   uint64        //尾节点下标
-	cap   uint64        //容量
-}
-
-//queue队列容器接口
-//存放了queue容器可使用的函数
-//对应函数介绍见下方
-
-type queuer interface {
-	Size() (size uint64)    //返回该队列中元素的使用空间大小
-	Clear()                 //清空该队列
-	Empty() (b bool)        //判断该队列是否为空
-	Push(e interface{})     //将元素e添加到该队列末尾
-	Pop() (e interface{})   //将该队列首元素弹出并返回
-	Front() (e interface{}) //获取该队列首元素
-	Back() (e interface{})  //获取该队列尾元素
-}
-
-//	新建一个queue队列容器并返回
-//	初始queue的切片数组为空
-//	初始queue的首尾指针均置零
-//
-// @receiver		nil
-// @param    	nil
-// @return    	q        	*Queue					新建的queue指针
-func New() (q *Queue) {
-	return &Queue{
-		data:  make([]interface{}, 1, 1),
-		begin: 0,
-		end:   0,
-		cap:   1,
-	}
-}
-
-//	返回该容器当前含有元素的数量
-//	该长度并非实际占用空间数量
-//	若容器为空则返回0
-//
-// @receiver		q			*Queue					接受者queue的指针
-// @param    	nil
-// @return    	size        uint64						容器中实际使用元素所占空间大小
-func (q *Queue) Size() (size uint64) {
-	if q == nil {
-		q = New()
-	}
-	return q.end - q.begin
-}
-
-//	以queue队列容器做接收者
-//	将该容器中所承载的元素清空
-//	将该容器的首尾指针均置0,容量设为1
-//
-// @receiver		q			*Queue					接受者queue的指针
-// @param    	nil
-// @return    	nil
-func (q *Queue) Clear() {
-	if q == nil {
-		q = New()
-	}
-
-	q.data = make([]interface{}, 1, 1)
-	q.begin = 0
-	q.end = 0
-	q.cap = 1
-}
-
-//	判断该queue队列容器是否含有元素
-//	如果含有元素则不为空,返回false
-//	如果不含有元素则说明为空,返回true
-//	如果容器不存在,返回true
-//	该判断过程通过首尾指针数值进行判断
-//	当尾指针数值等于首指针时说明不含有元素
-//	当尾指针数值大于首指针时说明含有元素
-//
-// @receiver		q			*Queue					接受者queue的指针
-// @param    	nil
-// @return    	b			bool					该容器是空的吗?
-func (q *Queue) Empty() (b bool) {
-	if q == nil {
-		q = New()
-	}
-	return q.Size() <= 0
-}
-
-//	在容器尾部插入元素
-//	若尾指针小于切片实际使用长度,则对当前指针位置进行覆盖,同时尾下标后移一位
-//	若尾指针等于切片实际使用长度,则对实际使用量和实际占用量进行判断
-//	当首部还有冗余时则删将实际使用整体前移到首部,否则对尾部进行扩容即可
-//
-// @receiver		q			*Queue					接受者queue的指针
-// @param    	e			interface{}				待插入元素
-// @return    	nil
-func (q *Queue) Push(e interface{}) {
-	if q == nil {
-		q = New()
-	}
-
-	if q.end < q.cap {
-		//不需要扩容
-		q.data[q.end] = e
-	} else {
-		//需要扩容
-		if q.begin > 0 {
-			//首部有冗余,整体前移
-			for i := uint64(0); i < q.end-q.begin; i++ {
-				q.data[i] = q.data[i+q.begin]
-			}
-			q.end -= q.begin
-			q.begin = 0
-		} else {
-			//冗余不足,需要扩容
-			if q.cap <= 65536 {
-				//容量翻倍
-				if q.cap == 0 {
-					q.cap = 1
-				}
-				q.cap *= 2
-			} else {
-				//容量增加2^16
-				q.cap += 2 ^ 16
-			}
-			//复制扩容前的元素
-			tmp := make([]interface{}, q.cap, q.cap)
-			copy(tmp, q.data)
-			q.data = tmp
-		}
-		q.data[q.end] = e
-	}
-	q.end++
-}
-
-//	弹出容器第一个元素,同时首下标后移一位
-//	若容器为空,则不进行弹出
-//	弹出结束后,进行缩容判断,考虑到queue的冗余会存在于前后两个方向
-//	所以需要对前后两方分别做判断, 但由于首部主要是减少,并不会增加,所以不需要太多冗余量,而尾部只做添加,所以需要更多的冗余
-//	所以可以对首部预留2^10的冗余,当超过时直接对首部冗余清除即可,释放首部空间时尾部空间仍然保留不变
-//	当首部冗余不足2^10时,但冗余超过实际使用空间,也会对首部进行缩容,尾部不变
-//	同时返回队首元素
-//
-// @receiver		q			*Queue					接受者queue的指针
-// @param    	nil
-// @return    	e 			interface{}				队首元素
-func (q *Queue) Pop() (e interface{}) {
-	if q == nil {
-		q = New()
-		return nil
-	}
-	if q.Empty() {
-		q.Clear()
-		return nil
-	}
-
-	e = q.data[q.begin]
-	q.begin++
-	if q.begin >= 1024 || q.begin*2 > q.end {
-		//首部冗余超过2^10或首部冗余超过实际使用
-		q.cap -= q.begin
-		q.end -= q.begin
-		tmp := make([]interface{}, q.cap, q.cap)
-		copy(tmp, q.data[q.begin:])
-		q.data = tmp
-		q.begin = 0
-	}
-
-	return e
-}
-
-//	返回该容器的第一个元素
-//	若该容器当前为空,则返回nil
-//
-// @receiver		q			*Queue					接受者queue的指针
-// @param    	nil
-// @return    	e			interface{}				容器的第一个元素
-func (q *Queue) Front() (e interface{}) {
-	if q == nil {
-		q = New()
-		return nil
-	}
-	if q.Empty() {
-		q.Clear()
-		return nil
-	}
-	return q.data[q.begin]
-}
-
-//	返回该容器的最后一个元素
-//	若该容器当前为空,则返回nil
-//
-// @receiver		q			*Queue					接受者queue的指针
-// @param    	nil
-// @return    	e			interface{}				容器的最后一个元素
-func (q *Queue) Back() (e interface{}) {
-	if q == nil {
-		q = New()
-		return nil
-	}
-	if q.Empty() {
-		q.Clear()
-		return nil
-	}
-	return q.data[q.end-1]
-}

gamesrv/clawdoll/player_clawdoll.go

@@ -8,8 +8,6 @@ import (
 type PlayerEx struct {
 	*base.Player //玩家信息
 
-	dollCardsCnt int32 // 娃娃卡数量
-
 	gainCoin int64 // 本局赢的金币
 	taxCoin  int64 // 本局税收
 	odds     int32
@@ -35,6 +33,7 @@ func (this *PlayerEx) CanOp(sceneEx *SceneEx) bool {
 
 // 能否投币
 func (this *PlayerEx) CanPayCoin() bool {
+
 	return true
 }
 
@@ -63,7 +62,7 @@ func (this *PlayerEx) InitData(baseScore int32) {
 
 }
 
-// 重置数据
+// 重置下注数据
 func (this *PlayerEx) ResetData() {
 
 }

gamesrv/clawdoll/scene_clawdoll.go

@@ -1,7 +1,6 @@
 package clawdoll
 
 import (
-	"container/list"
 	"mongo.games.com/game/common"
 	rule "mongo.games.com/game/gamerule/clawdoll"
 	"mongo.games.com/game/gamesrv/base"
@@ -44,9 +43,6 @@ type SceneEx struct {
 	PlayerBackup map[int32]*PlayerData // 本局离场玩家数据备份
 	seats        []*PlayerEx           // 本局游戏中的玩家状态数据
 
-	waitPlayers *list.List
-	playingSnid int32 // 正在玩的玩家snid
-
 	RoundId       int // 局数，第几局
 	robotNum      int // 参与游戏的机器人数量
 	logid         string
@@ -69,7 +65,6 @@ 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)
-		this.RemoveWaitPlayer(p.SnId)
 	}
 }
 
@@ -164,7 +159,6 @@ func NewClawdollSceneData(s *base.Scene) *SceneEx {
 		players:      make(map[int32]*PlayerEx),
 		seats:        make([]*PlayerEx, s.GetPlayerNum()),
 		PlayerBackup: make(map[int32]*PlayerData),
-		waitPlayers:  list.New(),
 	}
 
 	return sceneEx
@@ -185,34 +179,11 @@ func (this *SceneEx) Clear() {
 	this.PlayerBackup = make(map[int32]*PlayerData)
 	this.RoundId = 0
 
-	for e := this.waitPlayers.Front(); e != nil; e = e.Next() {
-		if e != nil {
-			p := e.Value.(*PlayerEx)
-			p.Clear(0)
-		}
-	}
-
 	for i := 0; i < this.GetPlayerNum(); i++ {
 		if this.seats[i] != nil {
 			this.seats[i].Clear(this.GetBaseScore())
 		}
 	}
-
-}
-
-// 是否有玩家正在玩
-func (this *SceneEx) IsHasPlaying() bool {
-	if this.playingSnid == 0 {
-		return false
-	}
-
-	return true
-}
-
-// 等待下一个玩家
-func (this *SceneEx) WaitNextPlayer() {
-	this.playingSnid = 0
-
 }
 
 func (this *SceneEx) BackupPlayer(p *PlayerEx, isBilled bool) {
@@ -238,46 +209,6 @@ func (this *SceneEx) BackupPlayer(p *PlayerEx, isBilled bool) {
 	}
 }
 
-func (this *SceneEx) GetPlayGrabType(player *PlayerEx) int32 {
-	if player == nil {
-		return rule.ClawWeak
-	}
-
-	if this.RoundId%100 == 0 && this.RoundId != 0 {
-		return rule.ClawStrong
-	}
-
-	return rule.ClawWeak
-}
-
-func (this *SceneEx) AddWaitPlayer(player *PlayerEx) {
-	if player == nil {
-		return
-	}
-
-	this.waitPlayers.PushBack(player)
-}
-
-func (this *SceneEx) RemoveWaitPlayer(SnId int32) bool {
-	l := this.waitPlayers
-	for e := l.Front(); e != nil; e = e.Next() {
-		if p := e.Value.(*PlayerEx); p.SnId == SnId {
-			this.waitPlayers.Remove(e)
-			return true
-		}
-	}
-
-	return false
-}
-
-// 时间到 系统开始下抓
-func (this *SceneEx) TimeOutPlayGrab() bool {
-
-	this.OnPlayerSMGrabOp(this.playingSnid, int32(this.machineId), rule.ClawWeak)
-
-	return true
-}
-
 // OnPlayerSMGrabOp  下抓   //1-弱力抓 2 -强力抓 3-必出抓
 func (this *SceneEx) OnPlayerSMGrabOp(SnId, Id, GrabType int32) {
 

gamesrv/clawdoll/scenepolicy_clawdoll.go

@@ -93,27 +93,36 @@ 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.playingSnid == 0 {
+			if sceneEx.Gaming {
 				p.MarkFlag(base.PlayerState_WaitNext)
 				p.UnmarkFlag(base.PlayerState_Ready)
-			sceneEx.playingSnid = p.GetSnId()
 			}
 
-		sceneEx.AddWaitPlayer(playerEx)
-
 			//给自己发送房间信息
 			this.SendRoomInfo(s, p, sceneEx)
 			s.FirePlayerEvent(p, base.PlayerEventEnter, nil)
 		}
+	}
 }
 
 func (this *PolicyClawdoll) OnPlayerLeave(s *base.Scene, p *base.Player, reason int) {
@@ -222,6 +231,9 @@ func (this *PolicyClawdoll) IsCompleted(s *base.Scene) bool {
 }
 
 func (this *PolicyClawdoll) IsCanForceStart(s *base.Scene) bool {
+	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
+		return len(s.Players) >= 2 && !sceneEx.Gaming
+	}
 	return false
 }
 
@@ -330,6 +342,7 @@ func (this *StateWait) CanChangeTo(s base.SceneState) bool {
 }
 
 func (this *StateWait) GetTimeout(s *base.Scene) int {
+
 	return this.BaseState.GetTimeout(s)
 }
 
@@ -341,7 +354,7 @@ func (this *StateWait) OnEnter(s *base.Scene) {
 		}
 		s.Gaming = false
 
-		ClawdollBroadcastRoomState(s, float32(0))
+		ClawdollBroadcastRoomState(s, float32(0), float32(0))
 
 		if sceneEx.CanStart() {
 			s.ChangeSceneState(rule.ClawDollSceneStateStart)
@@ -372,42 +385,13 @@ func (this *StateWait) OnTick(s *base.Scene) {
 			sceneEx.SceneDestroy(true)
 			return
 		}
-	}
+		if time.Now().Sub(sceneEx.StateStartTime) > rule.ClawDollSceneWaitTimeout {
-}
+			//切换到准备开局状态
-
-func (this *StateWait) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
-	if this.BaseState.OnPlayerOp(s, p, opcode, params) {
-		return true
-	}
-
-	sceneEx, ok := s.ExtraData.(*SceneEx)
-	if !ok {
-		return false
-	}
-	playerEx, ok := p.ExtraData.(*PlayerEx)
-	if !ok {
-		return false
-	}
-
-	switch opcode {
-	case rule.ClawDollPlayerOpPayCoin:
-		if sceneEx.IsHasPlaying() {
-			return false
-		}
-
-		if !playerEx.CanPayCoin() {
-			return false
-		}
-
-		// 1-前 2-后 3-左 4-右 5-投币
-		sceneEx.OnPlayerSMPerateOp(p.SnId, int32(sceneEx.machineId), rule.ButtonPayCoin)
-
 			if sceneEx.CanStart() {
 				s.ChangeSceneState(rule.ClawDollSceneStateStart)
 			}
 		}
-
+	}
-	return false
 }
 
 //=====================================
@@ -425,7 +409,6 @@ func (this *StateStart) GetState() int {
 func (this *StateStart) CanChangeTo(s base.SceneState) bool {
 	switch s.GetState() {
 	case rule.ClawDollSceneStatePlayGame:
-	case rule.ClawDollSceneStateWait:
 		return true
 	}
 	return false
@@ -434,10 +417,11 @@ func (this *StateStart) CanChangeTo(s base.SceneState) bool {
 func (this *StateStart) OnEnter(s *base.Scene) {
 	this.BaseState.OnEnter(s)
 	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
-		ClawdollBroadcastRoomState(s)
+		ClawdollBroadcastRoomState(s, float32(0), float32(0))
 		s.Gaming = false
 		sceneEx.GameNowTime = time.Now()
 		sceneEx.NumOfGames++
+
 	}
 }
 
@@ -456,6 +440,29 @@ func (this *StateStart) OnTick(s *base.Scene) {
 }
 
 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
+	}
+
+	sceneEx, ok := s.ExtraData.(*SceneEx)
+	if !ok {
+		return false
+	}
+	playerEx, ok := p.ExtraData.(*PlayerEx)
+	if !ok {
+		return false
+	}
+
+	switch opcode {
+	case rule.ClawDollPlayerOpPayCoin:
+		if !playerEx.CanPayCoin() {
+			return false
+		}
+
+		// 1-前 2-后 3-左 4-右 5-投币
+		sceneEx.OnPlayerSMPerateOp(p.SnId, int32(sceneEx.machineId), int32(5))
+	}
+
 	return false
 }
 
@@ -525,26 +532,27 @@ func (this *PlayGame) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, para
 	}
 
 	switch opcode {
+	case rule.ClawDollPlayerOpPayCoin:
+		// 投币检测
+		if !playerEx.CanPayCoin() {
+			return false
+		}
+
+		// 1-前 2-后 3-左 4-右 5-投币
+		sceneEx.OnPlayerSMPerateOp(p.SnId, int32(sceneEx.machineId), int32(5))
+		//sceneEx.OnPlayerSCOp(p, opcode, clawdoll.OpResultCode_OPRC_Success, params)
 	case rule.ClawDollPlayerOpGo:
 		if !playerEx.CanGrab() {
 			return false
 		}
 
-		grapType := sceneEx.GetPlayGrabType(playerEx)
-
-		logger.Logger.Trace("StatePlayGame OnPlayerOp-----SnId:", p.SnId, " grapType: ", grapType)
 		//1-弱力抓 2 -强力抓
-		sceneEx.OnPlayerSMGrabOp(p.SnId, int32(sceneEx.machineId), grapType)
+		sceneEx.OnPlayerSMGrabOp(p.SnId, int32(sceneEx.machineId), int32(2))
-
 	case rule.ClawDollPlayerOpMove:
 		if !playerEx.CanMove() {
 			return false
 		}
 
-		if params[0] < rule.ButtonFront || params[0] > rule.ButtonRight {
-			logger.Logger.Trace("StatePlayGame OnPlayerOp-----SnId:", p.SnId, " opcode: ", opcode, " params:", params)
-			return false
-		}
 		// 1-前 2-后 3-左 4-右 5-投币
 		sceneEx.OnPlayerSMPerateOp(p.SnId, int32(sceneEx.machineId), int32(params[0]))
 	}
@@ -554,17 +562,6 @@ func (this *PlayGame) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, para
 
 func (this *PlayGame) OnTick(s *base.Scene) {
 	this.BaseState.OnTick(s)
-	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
-		if time.Now().Sub(sceneEx.StateStartTime) > rule.ClawDollScenePlayTimeout {
-
-			if sceneEx.TimeOutPlayGrab() {
-
-			}
-
-			s.ChangeSceneState(rule.ClawDollSceneStateBilled)
-			return
-		}
-	}
 }
 
 //=====================================
@@ -613,100 +610,11 @@ 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.ClawDollSceneWaitPayCoin)
-
-			return
-		}
-	}
-}
-
-//=====================================
-// StateWaitPayCoin 等待下一局投币
-//=====================================
-
-type StateWaitPayCoin struct {
-	BaseState
-}
-
-func (this *StateWaitPayCoin) GetState() int {
-	return rule.ClawDollSceneWaitPayCoin
-}
-
-func (this *StateWaitPayCoin) CanChangeTo(s base.SceneState) bool {
-	switch s.GetState() {
-	case rule.ClawDollSceneStateStart:
-	case rule.ClawDollSceneStateWait:
-		return true
-	}
-	return false
-}
-
-func (this *StateWaitPayCoin) 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
-	}
-
-	sceneEx, ok := s.ExtraData.(*SceneEx)
-	if !ok {
-		return false
-	}
-	playerEx, ok := p.ExtraData.(*PlayerEx)
-	if !ok {
-		return false
-	}
-
-	switch opcode {
-	case rule.ClawDollPlayerOpPayCoin:
-
-		if sceneEx.playingSnid != playerEx.SnId {
-			logger.Logger.Trace("StateWaitPayCoin OnPlayerOp-----sceneEx.playingSnid:", sceneEx.playingSnid, " playerEx.SnId: ", playerEx.SnId)
-			return false
-		}
-
-		// 投币检测
-		if !playerEx.CanPayCoin() {
-			logger.Logger.Trace("StateWaitPayCoin OnPlayerOp-----CanPayCoin: false")
-			return false
-		}
-
-		sceneEx.OnPlayerSMPerateOp(p.SnId, int32(sceneEx.machineId), rule.ButtonPayCoin)
-
 				s.ChangeSceneState(rule.ClawDollSceneStateStart)
-		//sceneEx.OnPlayerSCOp(p, opcode, clawdoll.OpResultCode_OPRC_Success, params)
+			} else {
-	}
-	return false
-}
-
-func (this *StateWaitPayCoin) OnEnter(s *base.Scene) {
-	logger.Logger.Trace("(this *StateWaitPayCoin) OnEnter, sceneid=", s.GetSceneId())
-	this.BaseState.OnEnter(s)
-}
-
-func (this *StateWaitPayCoin) OnLeave(s *base.Scene) {
-	logger.Logger.Trace("(this *StateWaitPayCoin) 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 *StateWaitPayCoin) OnTick(s *base.Scene) {
-	this.BaseState.OnTick(s)
-	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
-		if time.Now().Sub(sceneEx.StateStartTime) > rule.ClawDollSceneWaitPayCoinimeout {
-
-			// 时间到，重置scene数据
-			sceneEx.WaitNextPlayer()
-
 				s.ChangeSceneState(rule.ClawDollSceneStateWait)
+			}
 			return
 		}
 	}
@@ -737,7 +645,6 @@ func init() {
 	PolicyClawdollSingleton.RegisteSceneState(&StateStart{})
 	PolicyClawdollSingleton.RegisteSceneState(&PlayGame{})
 	PolicyClawdollSingleton.RegisteSceneState(&StateBilled{})
-	PolicyClawdollSingleton.RegisteSceneState(&StateWaitPayCoin{})
 
 	core.RegisteHook(core.HOOK_BEFORE_START, func() error {
 		base.RegisteScenePolicy(common.GameId_Clawdoll, 0, PolicyClawdollSingleton)