tl_server_2
/
game_sync
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add rabbit

This commit is contained in:
tomas 2024-09-19 19:06:46 +08:00
parent a3741fd685
commit d62a57375e
5 changed files with 589 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
gamerule/fortunerabbit/constants.go Normal file
View File

@ -0,0 +1,22 @@
package fortunerabbit
// 房间类型
const (
RoomMode_Classic int = iota //经典
RoomMode_Max
)
// 场景状态
const (
FortuneRabbitStateStart int = iota //默认状态
FortuneRabbitStateMax
)
// 玩家操作
const (
FortuneRabbitPlayerOpStart int = iota
FortuneRabbitPlayerOpSwitch
)
const NowByte int64 = 10000
const GameDataKey = "FortuneData"

48
gamesrv/fortunerabbit/action_fortunerabbit.go Normal file
View File

@ -0,0 +1,48 @@
package fortunerabbit
import (
"mongo.games.com/game/protocol/fortunedragon"
"mongo.games.com/goserver/core/logger"
"mongo.games.com/goserver/core/netlib"
"mongo.games.com/game/common"
"mongo.games.com/game/gamesrv/base"
)
type CSFortuneDragonOpPacketFactory struct {
}
type CSFortuneDragonOpHandler struct {
}
func (this *CSFortuneDragonOpPacketFactory) CreatePacket() interface{} {
pack := &fortunedragon.CSFortuneDragonOp{}
return pack
}
func (this *CSFortuneDragonOpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
if op, ok := data.(*fortunedragon.CSFortuneDragonOp); ok {
p := base.PlayerMgrSington.GetPlayer(sid)
if p == nil {
logger.Logger.Warn("CSFortuneDragonOpHandler p == nil")
return nil
}
scene := p.GetScene()
if scene == nil {
logger.Logger.Warn("CSFortuneDragonOpHandler p.scene == nil")
return nil
}
if !scene.HasPlayer(p) {
return nil
}
if scene.GetScenePolicy() != nil {
scene.GetScenePolicy().OnPlayerOp(scene, p, int(op.GetOpCode()), op.GetParams())
}
return nil
}
return nil
}
func init() {
//fortunedragon
common.RegisterHandler(int(fortunedragon.FortuneDragonPID_PACKET_FORTUNEDRAGON_CSFORTUNEDRAGONOP), &CSFortuneDragonOpHandler{})
netlib.RegisterFactory(int(fortunedragon.FortuneDragonPID_PACKET_FORTUNEDRAGON_CSFORTUNEDRAGONOP), &CSFortuneDragonOpPacketFactory{})
}

35
gamesrv/fortunerabbit/playerdata_fortunerabbit.go Normal file
View File

@ -0,0 +1,35 @@
package fortunerabbit
import (
"mongo.games.com/game/gamesrv/base"
"mongo.games.com/game/gamesrv/slotspkg/slots"
)
type FortuneRabbitPlayerData struct {
*base.Player
leaveTime int32 //离开时间
SlotsSession *base.SlotsSession
BetSizeIndex int64 `json:"bsi"` //选中的单注下标
BetLevelIndex int64 `json:"bli"` //选中的等级下标
BetLineIndex int64 `json:"bii"` //选中的线数下标
BetMode int64 `json:"bm,optional"` //0.常规 1.必中
}
func (p *FortuneRabbitPlayerData) init() {
p.SlotsSession = base.NewSession(uint64(p.SnId), p.Coin)
}
func (p *FortuneRabbitPlayerData) Clear() {
}
// 需要带到world上进行数据处理
func (p *FortuneRabbitPlayerData) PushPlayer() map[string]string {
cache := slots.SlotsMgrSington.PushPlayer(p.SlotsSession)
return cache
}
// 进房的时候需要带进来
func (p *FortuneRabbitPlayerData) PullPlayer(data map[string]string) {
slots.SlotsMgrSington.PullPlayer(p.SlotsSession, data)
}

41
gamesrv/fortunerabbit/scenedata_fortunerabbit.go Normal file
View File

@ -0,0 +1,41 @@
package fortunerabbit
import "mongo.games.com/game/gamesrv/base"
type FortuneRabbitSceneData struct {
*base.Scene //场景
players map[int32]*FortuneRabbitPlayerData //玩家信息
}
func NewFortuneRabbitSceneData(s *base.Scene) *FortuneRabbitSceneData {
sceneEx := &FortuneRabbitSceneData{
Scene: s,
players: make(map[int32]*FortuneRabbitPlayerData),
}
sceneEx.Init()
return sceneEx
}
func (s *FortuneRabbitSceneData) Init() {
}
func (s *FortuneRabbitSceneData) Clear() {
//应该是水池变一次就判断修改一次
//s.slotRateWeight = s.slotRateWeightTotal[0]
}
func (s *FortuneRabbitSceneData) SceneDestroy(force bool) {
//销毁房间
s.Scene.Destroy(force)
}
func (s *FortuneRabbitSceneData) delPlayer(SnId int32) {
if _, exist := s.players[SnId]; exist {
delete(s.players, SnId)
}
}
func (s *FortuneRabbitSceneData) OnPlayerLeave(p *base.Player, reason int) {
if /*playerEx*/ _, ok := p.ExtraData.(*FortuneRabbitPlayerData); ok {
}
s.delPlayer(p.SnId)
}

443
gamesrv/fortunerabbit/scenepolicy_fortunerabbit.go Normal file
View File

@ -0,0 +1,443 @@
package fortunerabbit
import (
"encoding/json"
"mongo.games.com/game/common"
"mongo.games.com/game/gamerule/fortunerabbit"
"mongo.games.com/game/gamesrv/base"
"mongo.games.com/game/gamesrv/slotspkg/assemble"
"mongo.games.com/game/gamesrv/slotspkg/slots"
"mongo.games.com/game/model"
"mongo.games.com/game/proto"
protocol "mongo.games.com/game/protocol/fortunerabbit"
"mongo.games.com/goserver/core"
"mongo.games.com/goserver/core/logger"
"time"
)
// ////////////////////////////////////////////////////////////
var ScenePolicyFortuneRabbitSington = &ScenePolicyFortuneRabbit{}
type ScenePolicyFortuneRabbit struct {
base.BaseScenePolicy
states [fortunerabbit.FortuneRabbitStateMax]base.SceneState
}
// 创建场景扩展数据
func (this *ScenePolicyFortuneRabbit) CreateSceneExData(s *base.Scene) interface{} {
sceneEx := NewFortuneRabbitSceneData(s)
if sceneEx != nil {
if sceneEx.GetInit() {
s.SetExtraData(sceneEx)
}
}
return sceneEx
}
// 创建玩家扩展数据
func (this *ScenePolicyFortuneRabbit) CreatePlayerExData(s *base.Scene, p *base.Player) interface{} {
playerEx := &FortuneRabbitPlayerData{Player: p}
p.SetExtraData(playerEx)
return playerEx
}
// 场景开启事件
func (this *ScenePolicyFortuneRabbit) OnStart(s *base.Scene) {
logger.Logger.Trace("(this *ScenePolicyFortuneRabbit) OnStart, sceneId=", s.GetSceneId())
sceneEx := NewFortuneRabbitSceneData(s)
if sceneEx != nil {
if sceneEx.GetInit() {
s.SetExtraData(sceneEx)
s.ChangeSceneState(fortunerabbit.FortuneRabbitStateStart)
}
}
}
// 场景关闭事件
func (this *ScenePolicyFortuneRabbit) OnStop(s *base.Scene) {
logger.Logger.Trace("(this *ScenePolicyFortuneRabbit) OnStop , sceneId=", s.GetSceneId())
}
// 场景心跳事件
func (this *ScenePolicyFortuneRabbit) OnTick(s *base.Scene) {
if s == nil {
return
}
if s.GetSceneState() != nil {
s.GetSceneState().OnTick(s)
}
}
// 玩家进入事件
func (this *ScenePolicyFortuneRabbit) OnPlayerEnter(s *base.Scene, p *base.Player) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyFortuneRabbit) OnPlayerEnter, sceneId=", s.GetSceneId(), " player=", p.Name)
if sceneEx, ok := s.GetExtraData().(*FortuneRabbitSceneData); ok {
playerEx := &FortuneRabbitPlayerData{Player: p}
playerEx.init()
d := p.GameData[fortunerabbit.GameDataKey]
if d != nil {
m := make(map[string]string)
json.Unmarshal(d.Data.([]byte), &m)
playerEx.PullPlayer(m)
} else {
m := make(map[string]string)
//json.Unmarshal(d.Data.([]byte), &m)
playerEx.PullPlayer(m)
}
playerEx.Clear()
sceneEx.players[p.SnId] = playerEx
p.SetExtraData(playerEx)
FortuneRabbitSendRoomInfo(s, sceneEx, playerEx)
s.FirePlayerEvent(p, base.PlayerEventEnter, nil)
}
}
// 玩家离开事件
func (this *ScenePolicyFortuneRabbit) OnPlayerLeave(s *base.Scene, p *base.Player, reason int) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyFortuneRabbit) OnPlayerLeave, sceneId=", s.GetSceneId(), " player=", p.SnId)
if sceneEx, ok := s.ExtraData.(*FortuneRabbitSceneData); ok {
s.FirePlayerEvent(p, base.PlayerEventLeave, nil)
sceneEx.OnPlayerLeave(p, reason)
}
if playerEx, ok := p.ExtraData.(*FortuneRabbitPlayerData); ok {
m := playerEx.PushPlayer()
if m != nil && len(m) > 0 {
b, err := json.Marshal(m)
if err != nil {
logger.Logger.Error("OnPlayerLeave, json.Marshal error:", err)
} else {
p.GameData[fortunerabbit.GameDataKey] = &model.PlayerGameData{
Platform: p.Platform,
SnId: p.SnId,
Id: fortunerabbit.GameDataKey,
Data: b,
}
}
}
}
}
// 玩家掉线
func (this *ScenePolicyFortuneRabbit) OnPlayerDropLine(s *base.Scene, p *base.Player) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyFortuneRabbit) OnPlayerDropLine, sceneId=", s.GetSceneId(), " player=", p.SnId)
s.FirePlayerEvent(p, base.PlayerEventDropLine, nil)
}
// 玩家重连
func (this *ScenePolicyFortuneRabbit) OnPlayerRehold(s *base.Scene, p *base.Player) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyFortuneRabbit) OnPlayerRehold, sceneId=", s.GetSceneId(), " player=", p.SnId)
if sceneEx, ok := s.GetExtraData().(*FortuneRabbitSceneData); ok {
if playerEx, ok := p.GetExtraData().(*FortuneRabbitPlayerData); ok {
FortuneRabbitSendRoomInfo(s, sceneEx, playerEx)
}
}
}
// 返回房间
func (this *ScenePolicyFortuneRabbit) OnPlayerReturn(s *base.Scene, p *base.Player) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyFortuneRabbit) OnPlayerReturn, GetSceneId()=", s.GetSceneId(), " player=", p.Name)
if sceneEx, ok := s.GetExtraData().(*FortuneRabbitSceneData); ok {
if playerEx, ok := p.GetExtraData().(*FortuneRabbitPlayerData); ok {
//if p.IsMarkFlag(base.PlayerState_Auto) {
// p.UnmarkFlag(base.PlayerState_Auto)
// p.SyncFlag()
//}
//发送房间信息给自己
FortuneRabbitSendRoomInfo(s, sceneEx, playerEx)
s.FirePlayerEvent(p, base.PlayerEventReturn, nil)
}
}
}
func FortuneRabbitSendRoomInfo(s *base.Scene, sceneEx *FortuneRabbitSceneData, playerEx *FortuneRabbitPlayerData) {
pack := FortuneRabbitCreateRoomInfoPacket(s, sceneEx, playerEx)
logger.Logger.Trace("RoomInfo: ", pack)
playerEx.SendToClient(int(protocol.FortuneRabbitPID_PACKET_FORTUNERABBIT_SCFORTUNERABBITROOMINFO), pack)
}
func FortuneRabbitCreateRoomInfoPacket(s *base.Scene, sceneEx *FortuneRabbitSceneData, playerEx *FortuneRabbitPlayerData) interface{} {
//房间信息
pack := &protocol.SCFortuneRabbitRoomInfo{
RoomId: s.SceneId,
GameId: s.GameId,
RoomMode: s.SceneMode,
SceneType: s.GetSceneType(),
Params: common.CopySliceInt64ToInt32(s.Params),
NumOfGames: proto.Int(sceneEx.NumOfGames),
State: proto.Int(s.SceneState.GetState()),
ParamsEx: s.GetDBGameFree().OtherIntParams,
GameFreeId: proto.Int32(s.GetDBGameFree().Id),
//BetLimit: s.GetDBGameFree().BetLimit,
}
//自己的信息
if playerEx != nil {
pd := &protocol.FortuneRabbitPlayerData{
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),
Pos: proto.Int(playerEx.Pos),
Flag: proto.Int(playerEx.GetFlag()),
City: proto.String(playerEx.City),
HeadOutLine: proto.Int32(playerEx.HeadOutLine),
VIP: proto.Int32(playerEx.VIP),
}
pack.Player = pd
}
//get data
Response, err := slots.SlotsMgrSington.Enter(playerEx.SlotsSession, int64(s.GameId))
if err == nil {
data := assemble.DataToCli(Response).(assemble.TableInfo)
pi, _ := json.Marshal(data)
pack.PlayerInfo = string(pi)
} else {
logger.Logger.Error("slots enter err:", err)
}
proto.SetDefaults(pack)
return pack
}
func (this *ScenePolicyFortuneRabbit) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
if s == nil || p == nil {
return false
}
logger.Logger.Trace("(this *ScenePolicyFortuneRabbit) OnPlayerOp, sceneId=", s.GetSceneId(), " player=", p.SnId, " opcode=", opcode, " params=", params)
if s.GetSceneState() != nil {
if s.GetSceneState().OnPlayerOp(s, p, opcode, params) {
p.SetLastOPTimer(time.Now())
return true
}
return false
}
return true
}
func (this *ScenePolicyFortuneRabbit) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyFortuneRabbit) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " eventcode=", evtcode, " params=", params)
if s.GetSceneState() != nil {
s.GetSceneState().OnPlayerEvent(s, p, evtcode, params)
}
}
// 当前状态能否换桌
func (this *ScenePolicyFortuneRabbit) 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 false
}
// 状态基类
type SceneBaseStateFortuneRabbit struct {
}
func (this *SceneBaseStateFortuneRabbit) GetTimeout(s *base.Scene) int {
if sceneEx, ok := s.GetExtraData().(*FortuneRabbitSceneData); ok {
return int(time.Now().Sub(sceneEx.GetStateStartTime()) / time.Second)
}
return 0
}
func (this *SceneBaseStateFortuneRabbit) CanChangeTo(s base.SceneState) bool {
return true
}
// 当前状态能否换桌
func (this *SceneBaseStateFortuneRabbit) CanChangeCoinScene(s *base.Scene, p *base.Player) bool {
return true
}
func (this *SceneBaseStateFortuneRabbit) OnEnter(s *base.Scene) {
if sceneEx, ok := s.GetExtraData().(*FortuneRabbitSceneData); ok {
sceneEx.SetStateStartTime(time.Now())
}
}
func (this *SceneBaseStateFortuneRabbit) OnLeave(s *base.Scene) {}
func (this *SceneBaseStateFortuneRabbit) OnTick(s *base.Scene) {
if time.Now().Sub(s.GameStartTime) > time.Second*3 {
if sceneEx, ok := s.ExtraData.(*FortuneRabbitSceneData); ok {
for _, p := range sceneEx.players {
if p.IsOnLine() {
p.leaveTime = 0
continue
}
p.leaveTime++
if p.leaveTime < 60*2 {
continue
}
//踢出玩家
sceneEx.PlayerLeave(p.Player, common.PlayerLeaveReason_LongTimeNoOp, true)
}
}
s.GameStartTime = time.Now()
}
}
func (this *SceneBaseStateFortuneRabbit) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
return false
}
func (this *SceneBaseStateFortuneRabbit) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
}
// ////////////////////////////////////////////////////////////
// 开始状态
// ////////////////////////////////////////////////////////////
type SceneStateStartFortuneRabbit struct {
SceneBaseStateFortuneRabbit
}
func (this *SceneStateStartFortuneRabbit) GetState() int {
return fortunerabbit.FortuneRabbitStateStart
}
func (this *SceneStateStartFortuneRabbit) CanChangeTo(s base.SceneState) bool {
return false
}
// 当前状态能否换桌
func (this *SceneStateStartFortuneRabbit) CanChangeCoinScene(s *base.Scene, p *base.Player) bool {
if playerEx, ok := p.GetExtraData().(*FortuneRabbitPlayerData); ok {
if playerEx.IsOnLine() {
return false
}
}
return true
}
func (this *SceneStateStartFortuneRabbit) GetTimeout(s *base.Scene) int {
return 0
}
func (this *SceneStateStartFortuneRabbit) OnEnter(s *base.Scene) {
this.SceneBaseStateFortuneRabbit.OnEnter(s)
if sceneEx, ok := s.GetExtraData().(*FortuneRabbitSceneData); ok {
sceneEx.SetGameNowTime(time.Now())
}
}
// 状态离开时
func (this *SceneStateStartFortuneRabbit) OnLeave(s *base.Scene) {
this.SceneBaseStateFortuneRabbit.OnLeave(s)
logger.Logger.Tracef("(this *SceneStateStartFortuneRabbit) OnLeave, sceneid=%v", s.GetSceneId())
}
// 玩家操作
func (this *SceneStateStartFortuneRabbit) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
logger.Logger.Tracef("(this *SceneStateStartFortuneRabbit) OnPlayerOp, sceneid=%v params=%v", s.GetSceneId(), params)
if this.SceneBaseStateFortuneRabbit.OnPlayerOp(s, p, opcode, params) {
return true
}
if sceneEx, ok := s.GetExtraData().(*FortuneRabbitSceneData); ok {
if playerEx, ok := p.GetExtraData().(*FortuneRabbitPlayerData); ok {
switch opcode {
case fortunerabbit.FortuneRabbitPlayerOpStart:
playerEx.Clear()
if len(params) < 4 {
pack := &protocol.SCFortuneRabbitBilled{
OpRetCode: proto.Int32(1),
}
proto.SetDefaults(pack)
logger.Logger.Trace("SCFortuneRabbitBilled", pack.String())
playerEx.SendToClient(int(protocol.FortuneRabbitPID_PACKET_FORTUNERABBIT_SCFORTUNERABBITBILLED), pack)
return true
}
playerEx.BetSizeIndex = params[0]
playerEx.BetLevelIndex = params[1]
playerEx.BetLineIndex = params[2]
playerEx.BetMode = params[3]
//get data
Response, err := slots.SlotsMgrSington.Play(playerEx.SlotsSession, &base.SpinReq{
GameId: int64(sceneEx.GameId),
BetSizeIndex: playerEx.BetSizeIndex,
BetLevelIndex: playerEx.BetLevelIndex,
BetLineIndex: playerEx.BetLineIndex,
BetMode: playerEx.BetMode,
Ts: time.Now().Unix(),
})
var gameEndStr string
if err == nil {
data := assemble.DataToCli(Response).(assemble.GameEnd)
pi, _ := json.Marshal(data)
gameEndStr = string(pi)
playerEx.Coin = Response.Coin
} else {
logger.Logger.Error("slots enter err:", err)
}
pack := &protocol.SCFortuneRabbitBilled{
OpRetCode: proto.Int32(0),
GameEndStr: proto.String(gameEndStr),
}
proto.SetDefaults(pack)
logger.Logger.Trace("SCFortuneRabbitBilled", pack.String())
playerEx.SendToClient(int(protocol.FortuneRabbitPID_PACKET_FORTUNERABBIT_SCFORTUNERABBITBILLED), pack)
}
}
}
return true
}
// 玩家事件
func (this *SceneStateStartFortuneRabbit) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
logger.Logger.Trace("(this *SceneStateStartFortuneRabbit) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " evtcode=", evtcode)
this.SceneBaseStateFortuneRabbit.OnPlayerEvent(s, p, evtcode, params)
}
func (this *SceneStateStartFortuneRabbit) OnTick(s *base.Scene) {
this.SceneBaseStateFortuneRabbit.OnTick(s)
}
// //////////////////////////////////////////////////////////////////////////////
func (this *ScenePolicyFortuneRabbit) RegisteSceneState(state base.SceneState) {
if state == nil {
return
}
stateid := state.GetState()
if stateid < 0 || stateid >= fortunerabbit.FortuneRabbitStateMax {
return
}
this.states[stateid] = state
}
func (this *ScenePolicyFortuneRabbit) GetSceneState(s *base.Scene, stateid int) base.SceneState {
if stateid >= 0 && stateid < fortunerabbit.FortuneRabbitStateMax {
return this.states[stateid]
}
return nil
}
func init() {
//主状态
ScenePolicyFortuneRabbitSington.RegisteSceneState(&SceneStateStartFortuneRabbit{})
core.RegisteHook(core.HOOK_BEFORE_START, func() error {
base.RegisteScenePolicy(common.GameId_FortuneRabbit, fortunerabbit.RoomMode_Classic, ScenePolicyFortuneRabbitSington)
return nil
})
}