game_sync/gamesrv/slotspkg/slots/handler.go

package slots

import (
	"mongo.games.com/game/gamesrv/base"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/errors"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/global"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/key"
	"mongo.games.com/game/gamesrv/slotspkg/internal/module/player"
	"mongo.games.com/game/gamesrv/slotspkg/internal/module/shared"
	"mongo.games.com/game/gamesrv/slotspkg/slots/machine"
	"mongo.games.com/game/gamesrv/slotspkg/slots/types/cli"
	"mongo.games.com/goserver/core/logger"
)

func (sm *SlotsMgr) Enter(s *base.SlotsSession, gameId int64) (*cli.SlotsEnterResponse, error) {
	if gid, ok := key.GameKeyMap[gameId]; ok {
		gameId = int64(gid)
	} else {
		logger.Logger.Error("[slotsMgr.Enter] gameId not exist")
		return nil, errors.New("gameId not exist")
	}

	player.Get(s).Book.Coin.Set(s.Coin())

	player.Init(s)

	theme := key.GameMap[uint(gameId)]

	m := machine.NewMachine(s, theme, DataSet(s).Shell, false)
	if m == nil {
		logger.Logger.Error("[slotsMgr.enter] module is nil")
		return nil, errors.New("module is nil")
	}
	defer func() {
		if m.Next().GetType() == key.BaseSpin {
			DataSet(s).Update()
		}
	}()
	Response := &cli.SlotsEnterResponse{
		Code:          errors.Nil.Code(),
		NodeTree:      m.PlayLiteClose(),
		Coin:          player.CoinCenter.Get(s).GetCoin(),
		BetSizeIndex:  m.BetSizeIndex(),
		BetLevelIndex: m.BetLevelIndex(),
		BetLineIndex:  m.BetLineIndex(),
		BetSizes:      m.BetSizes(),
		BetLevels:     m.BetLevels(),
		BetLines:      m.BetLines(),
		BaseBets:      m.BaseBets(),
		BetChangeList: m.BetChangeList(),
	}

	player.PushPlayer(s)

	return Response, nil
}

func (sm *SlotsMgr) Play(s *base.SlotsSession, req *base.SpinReq) (*cli.SlotsPlayResponse, error) {
	if gameId, ok := key.GameKeyMap[req.GameId]; ok {
		req.GameId = int64(gameId)
	} else {
		logger.Logger.Error("[slotsMgr.play] gameId not exist")
		return nil, errors.New("gameId not exist")
	}
	//s := sm.GetSession(uid)
	if s == nil {
		logger.Logger.Error("[slotsMgr.play] session is nil")
		return nil, errors.New("session is nil")
	}

	if req.BetSizeIndex < 0 {
		logger.Logger.Error("[slotsMgr.play] msg.BetSizeIndex < 0")
		return nil, errors.New("msg.BetSizeIndex < 0")
	}

	if req.BetLevelIndex < 0 {
		logger.Logger.Error("[slotsMgr.play] msg.BetLevelIndex < 0")
		return nil, errors.New("msg.BetLevelIndex < 0")
	}

	player.Get(s).Book.Coin.Set(s.Coin())

	theme := key.GameMap[uint(req.GameId)]
	m := machine.NewMachine(s, theme, DataSet(s).Shell, false)
	if m == nil {
		logger.Logger.Error("[slotsMgr.play] module is nil")
		return nil, errors.New("module is nil")
	}

	defer func() {
		if m.Next().GetType() == key.BaseSpin {
			DataSet(s).Update()
		}
	}()

	var recorderResult = &shared.RecorderResult{}
	if m.Next().GetType() == key.BaseSpin {
		recorderResult = NewPlayAsRecorder(s)
		m.Play(&shared.Act{
			BetSizeIndex:  req.BetSizeIndex,
			BetLevelIndex: req.BetLevelIndex,
			BetLineIndex:  req.BetLineIndex,
			Ratio:         1,
			Mode:          key.MachineModePlayer,
			Vector:        recorderResult.Vector,
			//ExpectedWinCoin: recorderResult.ExpectedWinCoin,
			Choice:   req.BetMode,
			PlayMode: recorderResult.PlayMode,
		})
	} else {
		m.Play(&shared.Act{
			BetSizeIndex:  req.BetSizeIndex,
			BetLevelIndex: req.BetLevelIndex,
			BetLineIndex:  req.BetLineIndex,
			Ratio:         1,
			Mode:          key.MachineModePlayer,
			Choice:        req.BetMode,
		})
	}
	res := &cli.SlotsPlayResponse{
		Code:      errors.Nil.Code(),
		NodeTree:  m.PlayLiteClose(),
		ActualBet: m.ActualBet(),
		ActualWin: m.ActualWin(),
		Coin:      player.CoinCenter.Get(s).GetCoin(),
		IsEnd:     m.Next().GetType() == key.BaseSpin,
	}
	if !global.Mock {
		defer player.PushPlayer(s)
	}
	return res, nil
}
func (*SlotsMgr) PushPlayer(s *base.SlotsSession) map[string]string {
	return player.PushPlayer(s)
}
func (*SlotsMgr) PullPlayer(s *base.SlotsSession, data map[string]string) {
	player.PullPlayer(s, data)
}
func (*SlotsMgr) SetSessionContext(s *base.SlotsSession) {
	sessionContext := &shared.SessionContext{
		UID: int64(s.UID()),
	}
	s.Set(key.SessionContext, sessionContext)
}
func (*SlotsMgr) Leave(s *base.SlotsSession) (*cli.SlotsLeaveResponse, error) {

	m := machine.NewMachine(s, "s.Theme", DataSet(s).Shell, false)

	defer func() {
		if m.Next().GetType() == key.BaseSpin {
			DataSet(s).Update()
		}
	}()

	m.QuitLiteClose()
	Response := &cli.SlotsLeaveResponse{
		Code: errors.Nil.Code(),
		Coin: player.CoinCenter.Get(s).GetCoin(),
	}
	if !global.Mock {
		defer player.PushPlayer(s)
	}
	return Response, nil
}