333 lines
8.1 KiB
Go
333 lines
8.1 KiB
Go
package thirteen
|
|
|
|
import (
|
|
"encoding/json"
|
|
"time"
|
|
|
|
"mongo.games.com/goserver/core"
|
|
"mongo.games.com/goserver/core/logger"
|
|
|
|
"mongo.games.com/game/common"
|
|
rule "mongo.games.com/game/gamerule/pushcoin"
|
|
"mongo.games.com/game/gamesrv/base"
|
|
"mongo.games.com/game/model"
|
|
"mongo.games.com/game/protocol/pushcoin"
|
|
)
|
|
|
|
var PolicySingleton = &Policy{}
|
|
|
|
type Policy struct {
|
|
base.BaseScenePolicy
|
|
states [rule.GameStateMax]base.SceneState
|
|
}
|
|
|
|
func (this *Policy) OnStart(s *base.Scene) {
|
|
logger.Logger.Trace("(this *PushCoinPolicy) OnStart, sceneId=", s.GetSceneId())
|
|
sceneEx := NewPushCoinSceneData(s)
|
|
if sceneEx != nil {
|
|
s.ExtraData = sceneEx
|
|
s.ChangeSceneState(rule.GameStatePlay)
|
|
}
|
|
}
|
|
|
|
func (this *Policy) OnStop(s *base.Scene) {
|
|
logger.Logger.Trace("(this *Policy) OnStop , sceneId=", s.GetSceneId())
|
|
}
|
|
|
|
func (this *Policy) OnTick(s *base.Scene) {
|
|
if s == nil {
|
|
return
|
|
}
|
|
if s.SceneState != nil {
|
|
s.SceneState.OnTick(s)
|
|
}
|
|
}
|
|
|
|
func (this *Policy) OnPlayerEnter(s *base.Scene, p *base.Player) {
|
|
if s == nil || p == nil {
|
|
return
|
|
}
|
|
logger.Logger.Trace("(this *Policy) OnPlayerEnter, sceneId=", s.GetSceneId(), " player=", p.SnId)
|
|
sceneEx, ok := s.ExtraData.(*SceneEx)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
data := p.GDatas[s.KeyGamefreeId]
|
|
if data == nil {
|
|
data = &model.PlayerGameInfo{}
|
|
p.GDatas[s.KeyGamefreeId] = data
|
|
}
|
|
|
|
gamedata := &GameData{}
|
|
if data.DataEx != nil {
|
|
err := json.Unmarshal(data.DataEx, gamedata)
|
|
if err != nil {
|
|
logger.Logger.Error("OnPlayerEnter, json.Unmarshal error, err=", err)
|
|
return
|
|
}
|
|
} else {
|
|
// 底注
|
|
baseCoins := s.GetDBGameFree().GetOtherIntParams()
|
|
if len(baseCoins) > 0 {
|
|
gamedata.Base = baseCoins[0]
|
|
} else {
|
|
gamedata.Base = 5000
|
|
}
|
|
gamedata.Power = rule.PowerInit
|
|
}
|
|
|
|
p.ExtraData = NewPushCoinPlayerData(p, gamedata)
|
|
//给自己发送房间信息
|
|
this.SendRoomInfo(s, p, sceneEx)
|
|
s.FirePlayerEvent(p, base.PlayerEventEnter, nil)
|
|
}
|
|
|
|
func (this *Policy) OnPlayerLeave(s *base.Scene, p *base.Player, reason int) {
|
|
if s == nil || p == nil {
|
|
return
|
|
}
|
|
logger.Logger.Trace("(this *Policy) OnPlayerLeave, sceneId=", s.GetSceneId(), " player=", p.SnId)
|
|
|
|
playerEx, ok := p.ExtraData.(*PlayerEx)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
data := p.GDatas[s.KeyGamefreeId]
|
|
if data == nil {
|
|
data = &model.PlayerGameInfo{}
|
|
p.GDatas[s.KeyGamefreeId] = data
|
|
}
|
|
|
|
b, err := json.Marshal(playerEx.GameData)
|
|
if err != nil {
|
|
logger.Logger.Error("OnPlayerLeave, json.Marshal error, err=", err)
|
|
return
|
|
}
|
|
data.DataEx = b
|
|
|
|
s.FirePlayerEvent(p, base.PlayerEventLeave, nil)
|
|
}
|
|
|
|
func (this *Policy) OnPlayerDropLine(s *base.Scene, p *base.Player) {
|
|
if s == nil || p == nil {
|
|
return
|
|
}
|
|
logger.Logger.Trace("(this *Policy) OnPlayerDropLine, sceneId=", s.GetSceneId(), " player=", p.SnId)
|
|
s.FirePlayerEvent(p, base.PlayerEventDropLine, nil)
|
|
}
|
|
|
|
func (this *Policy) OnPlayerRehold(s *base.Scene, p *base.Player) {
|
|
if s == nil || p == nil {
|
|
return
|
|
}
|
|
logger.Logger.Trace("(this *Policy) OnPlayerRehold, sceneId=", s.GetSceneId(), " player=", p.SnId)
|
|
sceneEx, ok := s.ExtraData.(*SceneEx)
|
|
if !ok {
|
|
return
|
|
}
|
|
this.SendRoomInfo(s, p, sceneEx)
|
|
s.FirePlayerEvent(p, base.PlayerEventRehold, nil)
|
|
}
|
|
|
|
func (this *Policy) OnPlayerReturn(s *base.Scene, p *base.Player) {
|
|
if s == nil || p == nil {
|
|
return
|
|
}
|
|
logger.Logger.Trace("(this *Policy) OnPlayerRehold, sceneId=", s.GetSceneId(), " player=", p.SnId)
|
|
sceneEx, ok := s.ExtraData.(*SceneEx)
|
|
if !ok {
|
|
return
|
|
}
|
|
this.SendRoomInfo(s, p, sceneEx)
|
|
s.FirePlayerEvent(p, base.PlayerEventReturn, nil)
|
|
}
|
|
|
|
func (this *Policy) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
|
|
if s == nil || p == nil {
|
|
return false
|
|
}
|
|
logger.Logger.Trace("(this *Policy) OnPlayerOp, sceneId=", s.GetSceneId(), " player=", p.SnId, " opcode=", opcode, " params=", params)
|
|
if s.SceneState != nil {
|
|
p.LastOPTimer = time.Now()
|
|
return s.SceneState.OnPlayerOp(s, p, opcode, params)
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (this *Policy) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
|
|
if s == nil || p == nil {
|
|
return
|
|
}
|
|
logger.Logger.Trace("(this *Policy) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " eventcode=", evtcode, " params=", params)
|
|
if s.SceneState != nil {
|
|
s.SceneState.OnPlayerEvent(s, p, evtcode, params)
|
|
}
|
|
}
|
|
|
|
func (this *Policy) OnAudienceEnter(s *base.Scene, p *base.Player) {
|
|
if s == nil || p == nil {
|
|
return
|
|
}
|
|
logger.Logger.Trace("(this *Policy) OnAudienceEnter, sceneId=", s.GetSceneId(), " player=", p.SnId)
|
|
if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
|
|
//给自己发送房间信息
|
|
this.SendRoomInfo(s, p, sceneEx)
|
|
s.FirePlayerEvent(p, base.AudienceEventEnter, nil)
|
|
}
|
|
}
|
|
|
|
func (this *Policy) OnAudienceLeave(s *base.Scene, p *base.Player, reason int) {
|
|
if s == nil || p == nil {
|
|
return
|
|
}
|
|
logger.Logger.Trace("(this *Policy) OnAudienceLeave, sceneId=", s.GetSceneId(), " player=", p.SnId)
|
|
s.FirePlayerEvent(p, base.AudienceEventLeave, nil)
|
|
}
|
|
|
|
func (this *Policy) OnAudienceDropLine(s *base.Scene, p *base.Player) {
|
|
if s == nil || p == nil {
|
|
return
|
|
}
|
|
logger.Logger.Trace("(this *Policy) OnAudienceDropLine, sceneId=", s.GetSceneId(), " player=", p.SnId)
|
|
s.AudienceLeave(p, common.PlayerLeaveReason_DropLine)
|
|
s.FirePlayerEvent(p, base.AudienceEventDropLine, nil)
|
|
}
|
|
|
|
func (this *Policy) OnAudienceSit(s *base.Scene, p *base.Player) {
|
|
|
|
}
|
|
|
|
func (this *Policy) IsCompleted(s *base.Scene) bool {
|
|
return true
|
|
}
|
|
|
|
func (this *Policy) IsCanForceStart(s *base.Scene) bool {
|
|
return true
|
|
}
|
|
|
|
func (this *Policy) ForceStart(s *base.Scene) {
|
|
|
|
}
|
|
|
|
func (this *Policy) CanChangeCoinScene(s *base.Scene, p *base.Player) bool {
|
|
if s == nil || p == nil {
|
|
return false
|
|
}
|
|
if s.SceneState != nil {
|
|
return s.SceneState.CanChangeCoinScene(s, p)
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (this *Policy) SendRoomInfo(s *base.Scene, p *base.Player, sceneEx *SceneEx) {
|
|
pack := sceneEx.CreateRoomInfoPacket(s, p)
|
|
p.SendToClient(int(pushcoin.PushCoinPacketID_PACKET_SCPushCoinRoomInfo), pack)
|
|
}
|
|
|
|
//=====================================
|
|
// StateGaming 游戏中
|
|
//=====================================
|
|
|
|
type StateGaming struct {
|
|
}
|
|
|
|
func (this *StateGaming) CanChangeCoinScene(s *base.Scene, p *base.Player) bool {
|
|
return true
|
|
}
|
|
|
|
func (this *StateGaming) OnLeave(s *base.Scene) {
|
|
|
|
}
|
|
|
|
func (this *StateGaming) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
|
|
|
|
}
|
|
|
|
func (this *StateGaming) GetState() int {
|
|
return rule.GameStatePlay
|
|
}
|
|
|
|
func (this *StateGaming) CanChangeTo(s base.SceneState) bool {
|
|
return true
|
|
}
|
|
|
|
func (this *StateGaming) GetTimeout(s *base.Scene) int {
|
|
if sceneEx, ok := s.GetExtraData().(*SceneEx); ok {
|
|
return int(time.Now().Sub(sceneEx.StateStartTime) / time.Second)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (this *StateGaming) OnEnter(s *base.Scene) {
|
|
|
|
}
|
|
|
|
func (this *StateGaming) OnTick(s *base.Scene) {
|
|
|
|
}
|
|
|
|
func (this *StateGaming) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
|
|
logger.Logger.Trace("(this *StateGaming) OnPlayerOp, sceneId=", s.GetSceneId(), " player=", p.SnId, " opcode=", opcode, " params=", params)
|
|
_, ok := s.ExtraData.(*SceneEx)
|
|
if !ok {
|
|
return false
|
|
}
|
|
_, ok = p.ExtraData.(*PlayerEx)
|
|
if !ok {
|
|
return false
|
|
}
|
|
|
|
pack := &pushcoin.SCPushCoinPlayerOp{
|
|
OpRetCode: pushcoin.OpResultCode_OPRC_Error,
|
|
OpCode: pushcoin.OpCodes(opcode),
|
|
}
|
|
|
|
switch pushcoin.OpCodes(opcode) {
|
|
case pushcoin.OpCodes_OP_Bet:
|
|
|
|
case pushcoin.OpCodes_OP_Gain:
|
|
|
|
case pushcoin.OpCodes_OP_Shake:
|
|
|
|
case pushcoin.OpCodes_OP_Refresh:
|
|
|
|
case pushcoin.OpCodes_OP_Exchange:
|
|
|
|
case pushcoin.OpCodes_OP_Draw:
|
|
|
|
default:
|
|
return true
|
|
}
|
|
|
|
p.SendToClient(int(pushcoin.PushCoinPacketID_PACKET_SCPushCoinPlayerOp), pack)
|
|
return true
|
|
}
|
|
|
|
func (this *Policy) RegisteSceneState(state base.SceneState) {
|
|
if state == nil {
|
|
return
|
|
}
|
|
id := state.GetState()
|
|
if id < 0 || id >= rule.GameStateMax {
|
|
return
|
|
}
|
|
this.states[id] = state
|
|
}
|
|
|
|
func (this *Policy) GetSceneState(s *base.Scene, stateid int) base.SceneState {
|
|
if stateid >= 0 && stateid < rule.GameStateMax {
|
|
return this.states[stateid]
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
PolicySingleton.RegisteSceneState(&StateGaming{})
|
|
core.RegisteHook(core.HOOK_BEFORE_START, func() error {
|
|
base.RegisteScenePolicy(common.GameId_PushCoin, 0, PolicySingleton)
|
|
return nil
|
|
})
|
|
}
|