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

Compare commits

base: tl_server_2:58c22f09cedb86814e5ba4a526446d28fb233f0e
Branches Tags
tl_server_2:main
tl_server_2:dev_login
tl_server_2:develop
tl_server_2:dev_slots
tl_server_2:release
tl_server_2:dev_third
tl_server_2:dev_expireitem
tl_server_2:ma
tl_server_2:machine
..
compare: tl_server_2:8471e1ef6b739dd3df0821765e49c986d1986c7a
Branches Tags
tl_server_2:dev_login
tl_server_2:develop
tl_server_2:dev_slots
tl_server_2:release
tl_server_2:dev_third
tl_server_2:dev_expireitem
tl_server_2:ma
tl_server_2:machine
tl_server_2:main

No commits in common. "58c22f09cedb86814e5ba4a526446d28fb233f0e" and "8471e1ef6b739dd3df0821765e49c986d1986c7a" have entirely different histories.
58c22f09ce ... 8471e1ef6b

20 changed files with 38 additions and 847 deletions
Show Stats Expand all files Collapse all files

22
gamerule/cashmania/constants.go
View File

@ -1,22 +0,0 @@
package cashmania
// 房间类型
const (
RoomMode_Classic int = iota //经典
RoomMode_Max
)
// 场景状态
const (
CashManiaStateStart int = iota //默认状态
CashManiaStateMax
)
// 玩家操作
const (
CashManiaPlayerOpStart int = iota
CashManiaPlayerOpSwitch
)
const NowByte int64 = 10000
const GameDataKey = "CashManiaData"

47
gamesrv/cashmania/action_cashmania.go
View File

@ -1,47 +0,0 @@
package cashmania
import (
"mongo.games.com/game/protocol/cashmania"
"mongo.games.com/goserver/core/logger"
"mongo.games.com/goserver/core/netlib"
"mongo.games.com/game/common"
"mongo.games.com/game/gamesrv/base"
)
type CSCashManiaOpPacketFactory struct {
}
type CSCashManiaOpHandler struct {
}
func (this *CSCashManiaOpPacketFactory) CreatePacket() interface{} {
pack := &cashmania.CSCashManiaOp{}
return pack
}
func (this *CSCashManiaOpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
if op, ok := data.(*cashmania.CSCashManiaOp); ok {
p := base.PlayerMgrSington.GetPlayer(sid)
if p == nil {
logger.Logger.Warn("CSCashManiaOpHandler p == nil")
return nil
}
scene := p.GetScene()
if scene == nil {
logger.Logger.Warn("CSCashManiaOpHandler 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() {
common.RegisterHandler(int(cashmania.CashManiaPID_PACKET_CASHMANIA_CSCASHMANIAOP), &CSCashManiaOpHandler{})
netlib.RegisterFactory(int(cashmania.CashManiaPID_PACKET_CASHMANIA_CSCASHMANIAOP), &CSCashManiaOpPacketFactory{})
}

47
gamesrv/cashmania/playerdata_cashmania.go
View File

@ -1,47 +0,0 @@
package cashmania
import (
gamerule "mongo.games.com/game/gamerule/fortunedragon"
"mongo.games.com/game/gamesrv/base"
"mongo.games.com/game/gamesrv/slotspkg/slots"
)
type CashManiaPlayerData struct {
*base.Player
base.LabaLog
leaveTime int32 //离开时间
SlotsSession *base.SlotsSession
BetSizeIndex int64 `json:"bsi"` //选中的单注下标
BetLevelIndex int64 `json:"bli"` //选中的等级下标
BetLineIndex int64 `json:"bii"` //选中的线数下标
BetMode int64 `json:"bm,optional"` //0.常规 1.必中
taxCoin int64
winCoin int64
currentLogId string
totalBet int64
isFree bool //只用于判断是否可以离开
}
func (p *CashManiaPlayerData) init() {
p.SlotsSession = base.NewSession(uint64(p.SnId), p.Coin*gamerule.NowByte)
}
func (p *CashManiaPlayerData) Clear() {
p.taxCoin = 0
p.winCoin = 0
p.currentLogId = ""
p.LabaLog.Clear()
}
// 需要带到world上进行数据处理
func (p *CashManiaPlayerData) PushPlayer() map[string]string {
cache := slots.SlotsMgrSington.PushPlayer(p.SlotsSession)
return cache
}
// 进房的时候需要带进来
func (p *CashManiaPlayerData) PullPlayer(data map[string]string) {
slots.SlotsMgrSington.PullPlayer(p.SlotsSession, data)
}

45
gamesrv/cashmania/scenedata_cashmania.go
View File

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

585
gamesrv/cashmania/scenepolicy_cashmania.go
View File

@ -1,585 +0,0 @@
package cashmania
import (
"encoding/json"
"mongo.games.com/game/common"
"mongo.games.com/game/gamerule/cashmania"
"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/cashmania"
"mongo.games.com/game/protocol/server"
"mongo.games.com/goserver/core"
"mongo.games.com/goserver/core/logger"
"time"
)
// ////////////////////////////////////////////////////////////
var ScenePolicyCashManiaSington = &ScenePolicyCashMania{}
type ScenePolicyCashMania struct {
base.BaseScenePolicy
states [cashmania.CashManiaStateMax]base.SceneState
}
// 创建场景扩展数据
func (this *ScenePolicyCashMania) CreateSceneExData(s *base.Scene) interface{} {
sceneEx := NewCashManiaSceneData(s)
if sceneEx != nil {
if sceneEx.GetInit() {
s.SetExtraData(sceneEx)
}
}
return sceneEx
}
// 创建玩家扩展数据
func (this *ScenePolicyCashMania) CreatePlayerExData(s *base.Scene, p *base.Player) interface{} {
playerEx := &CashManiaPlayerData{Player: p}
p.SetExtraData(playerEx)
return playerEx
}
// 场景开启事件
func (this *ScenePolicyCashMania) OnStart(s *base.Scene) {
logger.Logger.Trace("(this *ScenePolicyCashMania) OnStart, sceneId=", s.GetSceneId())
sceneEx := NewCashManiaSceneData(s)
if sceneEx != nil {
if sceneEx.GetInit() {
s.SetExtraData(sceneEx)
s.ChangeSceneState(cashmania.CashManiaStateStart)
}
}
}
// 场景关闭事件
func (this *ScenePolicyCashMania) OnStop(s *base.Scene) {
logger.Logger.Trace("(this *ScenePolicyCashMania) OnStop , sceneId=", s.GetSceneId())
}
// 场景心跳事件
func (this *ScenePolicyCashMania) OnTick(s *base.Scene) {
if s == nil {
return
}
if s.GetSceneState() != nil {
s.GetSceneState().OnTick(s)
}
}
// 玩家进入事件
func (this *ScenePolicyCashMania) OnPlayerEnter(s *base.Scene, p *base.Player) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyCashMania) OnPlayerEnter, sceneId=", s.GetSceneId(), " player=", p.Name)
if sceneEx, ok := s.GetExtraData().(*CashManiaSceneData); ok {
playerEx := &CashManiaPlayerData{Player: p}
playerEx.init()
d := p.GameData[cashmania.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.SlotsSession.SetCoin(playerEx.Coin * cashmania.NowByte)
playerEx.Clear()
sceneEx.players[p.SnId] = playerEx
p.SetExtraData(playerEx)
CashManiaSendRoomInfo(s, sceneEx, playerEx)
s.FirePlayerEvent(p, base.PlayerEventEnter, nil)
}
}
// 玩家离开事件
func (this *ScenePolicyCashMania) OnPlayerLeave(s *base.Scene, p *base.Player, reason int) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyCashMania) OnPlayerLeave, sceneId=", s.GetSceneId(), " player=", p.SnId)
if playerEx, ok := p.ExtraData.(*CashManiaPlayerData); ok {
playerEx.Save(2)
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[cashmania.GameDataKey] = &model.PlayerGameData{
Platform: p.Platform,
SnId: p.SnId,
Id: cashmania.GameDataKey,
Data: b,
}
}
}
}
if sceneEx, ok := s.ExtraData.(*CashManiaSceneData); ok {
s.FirePlayerEvent(p, base.PlayerEventLeave, nil)
sceneEx.OnPlayerLeave(p, reason)
}
}
// 玩家掉线
func (this *ScenePolicyCashMania) OnPlayerDropLine(s *base.Scene, p *base.Player) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyCashMania) OnPlayerDropLine, sceneId=", s.GetSceneId(), " player=", p.SnId)
s.FirePlayerEvent(p, base.PlayerEventDropLine, nil)
}
// 玩家重连
func (this *ScenePolicyCashMania) OnPlayerRehold(s *base.Scene, p *base.Player) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyCashMania) OnPlayerRehold, sceneId=", s.GetSceneId(), " player=", p.SnId)
if sceneEx, ok := s.GetExtraData().(*CashManiaSceneData); ok {
if playerEx, ok := p.GetExtraData().(*CashManiaPlayerData); ok {
CashManiaSendRoomInfo(s, sceneEx, playerEx)
}
}
}
// 返回房间
func (this *ScenePolicyCashMania) OnPlayerReturn(s *base.Scene, p *base.Player) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyCashMania) OnPlayerReturn, GetSceneId()=", s.GetSceneId(), " player=", p.Name)
if sceneEx, ok := s.GetExtraData().(*CashManiaSceneData); ok {
if playerEx, ok := p.GetExtraData().(*CashManiaPlayerData); ok {
//if p.IsMarkFlag(base.PlayerState_Auto) {
// p.UnmarkFlag(base.PlayerState_Auto)
// p.SyncFlag()
//}
//发送房间信息给自己
CashManiaSendRoomInfo(s, sceneEx, playerEx)
s.FirePlayerEvent(p, base.PlayerEventReturn, nil)
}
}
}
func CashManiaSendRoomInfo(s *base.Scene, sceneEx *CashManiaSceneData, playerEx *CashManiaPlayerData) {
pack := CashManiaCreateRoomInfoPacket(s, sceneEx, playerEx)
logger.Logger.Trace("RoomInfo: ", pack)
playerEx.SendToClient(int(protocol.CashManiaPID_PACKET_CASHMANIA_SCCASHMANIAROOMINFO), pack)
}
func CashManiaCreateRoomInfoPacket(s *base.Scene, sceneEx *CashManiaSceneData, playerEx *CashManiaPlayerData) interface{} {
//房间信息
pack := &protocol.SCCashManiaRoomInfo{
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.CashManiaPlayerData{
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)
if sceneEx.BetConfig == nil {
sceneEx.BetConfig = &data.BetConfig
}
} else {
logger.Logger.Error("slots enter err:", err)
}
proto.SetDefaults(pack)
return pack
}
func (this *ScenePolicyCashMania) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
if s == nil || p == nil {
return false
}
logger.Logger.Trace("(this *ScenePolicyCashMania) 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 *ScenePolicyCashMania) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
if s == nil || p == nil {
return
}
logger.Logger.Trace("(this *ScenePolicyCashMania) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " eventcode=", evtcode, " params=", params)
if s.GetSceneState() != nil {
s.GetSceneState().OnPlayerEvent(s, p, evtcode, params)
}
}
// 当前状态能否换桌
func (this *ScenePolicyCashMania) 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 SceneBaseStateCashMania struct {
}
func (this *SceneBaseStateCashMania) GetTimeout(s *base.Scene) int {
if sceneEx, ok := s.GetExtraData().(*CashManiaSceneData); ok {
return int(time.Now().Sub(sceneEx.GetStateStartTime()) / time.Second)
}
return 0
}
func (this *SceneBaseStateCashMania) CanChangeTo(s base.SceneState) bool {
return true
}
// 当前状态能否换桌
func (this *SceneBaseStateCashMania) CanChangeCoinScene(s *base.Scene, p *base.Player) bool {
return true
}
func (this *SceneBaseStateCashMania) OnEnter(s *base.Scene) {
if sceneEx, ok := s.GetExtraData().(*CashManiaSceneData); ok {
sceneEx.SetStateStartTime(time.Now())
}
}
func (this *SceneBaseStateCashMania) OnLeave(s *base.Scene) {}
func (this *SceneBaseStateCashMania) OnTick(s *base.Scene) {
if time.Now().Sub(s.GameStartTime) > time.Second*3 {
if sceneEx, ok := s.ExtraData.(*CashManiaSceneData); 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 *SceneBaseStateCashMania) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
return false
}
func (this *SceneBaseStateCashMania) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
}
// ////////////////////////////////////////////////////////////
// 开始状态
// ////////////////////////////////////////////////////////////
type SceneStateStartCashMania struct {
SceneBaseStateCashMania
}
func (this *SceneStateStartCashMania) GetState() int {
return cashmania.CashManiaStateStart
}
func (this *SceneStateStartCashMania) CanChangeTo(s base.SceneState) bool {
return false
}
// 当前状态能否换桌
func (this *SceneStateStartCashMania) CanChangeCoinScene(s *base.Scene, p *base.Player) bool {
if playerEx, ok := p.GetExtraData().(*CashManiaPlayerData); ok {
if playerEx.isFree {
return false
}
}
return true
}
func (this *SceneStateStartCashMania) GetTimeout(s *base.Scene) int {
return 0
}
func (this *SceneStateStartCashMania) OnEnter(s *base.Scene) {
this.SceneBaseStateCashMania.OnEnter(s)
if sceneEx, ok := s.GetExtraData().(*CashManiaSceneData); ok {
sceneEx.SetGameNowTime(time.Now())
}
}
// 状态离开时
func (this *SceneStateStartCashMania) OnLeave(s *base.Scene) {
this.SceneBaseStateCashMania.OnLeave(s)
logger.Logger.Tracef("(this *SceneStateStartCashMania) OnLeave, sceneid=%v", s.GetSceneId())
}
// 玩家操作
func (this *SceneStateStartCashMania) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
logger.Logger.Tracef("(this *SceneStateStartCashMania) OnPlayerOp, sceneid=%v params=%v", s.GetSceneId(), params)
if this.SceneBaseStateCashMania.OnPlayerOp(s, p, opcode, params) {
return true
}
if sceneEx, ok := s.GetExtraData().(*CashManiaSceneData); ok {
if playerEx, ok := p.GetExtraData().(*CashManiaPlayerData); ok {
switch opcode {
case cashmania.CashManiaPlayerOpStart:
playerEx.Clear()
if len(params) < 4 {
pack := &protocol.SCCashManiaBilled{
OpRetCode: proto.Int32(1),
}
proto.SetDefaults(pack)
logger.Logger.Trace("SCCashManiaBilled", pack.String())
playerEx.SendToClient(int(protocol.CashManiaPID_PACKET_CASHMANIA_SCCASHMANIABILLED), pack)
return true
}
playerEx.BetSizeIndex = params[0]
playerEx.BetLevelIndex = params[1]
playerEx.BetLineIndex = params[2]
needCoin := sceneEx.BetConfig.BetSize[params[0]] * float64(sceneEx.BetConfig.BetLevel[params[1]]) *
float64(sceneEx.BetConfig.BetLines[params[2]])
if needCoin > float64(playerEx.Coin) && !playerEx.isFree {
pack := &protocol.SCCashManiaBilled{
OpRetCode: proto.Int32(1),
}
proto.SetDefaults(pack)
logger.Logger.Trace("SCCashManiaBilled:", pack.String())
playerEx.SendToClient(int(protocol.CashManiaPID_PACKET_CASHMANIA_SCCASHMANIABILLED), pack)
return true
}
playerEx.BetMode = params[3]
//playerEx.SlotsSession.SetCoin(playerEx.Coin * cashmania.NowByte)
//logger.Logger.Trace("=====================init===== playerEx.Coin===", playerEx.Coin)
//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
var data assemble.GameEnd
if err == nil {
s.SetGameNowTime(time.Now())
data = assemble.DataToCli(Response).(assemble.GameEnd)
data.BetSizeIndex = playerEx.BetSizeIndex
data.BetLevelIndex = playerEx.BetLevelIndex
data.LinesIndex = playerEx.BetLineIndex
//data.BaseBetIndex = 1
data.Results[0].BetMode = playerEx.BetMode
if data.Results[0].FreeStatus == 1 || data.Results[0].FreeNumMax == 0 {
//logger.Logger.Trace("=====================AddCoin=====TotalBet===", -data.TotalBet)
//第一次触发或者正常模式
playerEx.AddCoin(int64(-data.TotalBet), common.GainWay_HundredSceneLost, base.SyncFlag_ToClient, "system", s.GetSceneName())
playerEx.totalBet = int64(data.TotalBet)
}
var taxCoin float64
if data.RoundReward > 0 {
//税收比例
taxRate := sceneEx.GetDBGameFree().GetTaxRate()
if taxRate < 0 || taxRate > 10000 {
taxRate = 500
}
taxCoin = data.RoundReward * float64(taxRate) / 10000
data.RoundReward = data.RoundReward - taxCoin
playerEx.AddServiceFee(int64(taxCoin))
playerEx.taxCoin = int64(taxCoin)
playerEx.winCoin = int64(data.RoundReward)
}
pi, _ := json.Marshal(data)
gameEndStr = string(pi)
if data.Results[0].FreeStatus == 3 || data.Results[0].FreeNumMax == 0 {
//logger.Logger.Trace("=====================AddCoin=====RoundReward===", data.RoundReward)
playerEx.AddCoin(int64(data.RoundReward), common.GainWay_HundredSceneWin, 0, "system", s.GetSceneName())
//免费游戏结束或者正常模式
sceneEx.StaticsLaba(&base.StaticLabaParam{
SnId: playerEx.SnId,
Gain: int64(data.RoundReward - data.TotalBet),
GainTax: int64(taxCoin),
IsAddTimes: true,
})
}
if data.Results[0].FreeNum > 0 {
playerEx.isFree = true
} else {
playerEx.isFree = false
}
} else {
logger.Logger.Error("slots Play err:", err)
}
playerEx.SlotsSession.SetCoin(int64(data.FinalCoin) * cashmania.NowByte)
//logger.Logger.Trace("=====================end===== playerEx.Coin===", playerEx.Coin)
//logger.Logger.Trace("=====================end===== data.FinalCoin===", data.FinalCoin)
pack := &protocol.SCCashManiaBilled{
OpRetCode: proto.Int32(0),
GameEndStr: proto.String(gameEndStr),
}
proto.SetDefaults(pack)
logger.Logger.Trace("SCCashManiaBilled", pack.String())
playerEx.SendToClient(int(protocol.CashManiaPID_PACKET_CASHMANIA_SCCASHMANIABILLED), pack)
if playerEx.Coin != int64(data.FinalCoin) {
logger.Logger.Error("==========playerEx.Coin != Response.Coin==============", playerEx.Coin, data.FinalCoin)
}
// 记录本次操作
CashManiaAndSaveLog(sceneEx, playerEx, data)
case 1000:
playerEx.Save(0)
}
}
}
return true
}
// 玩家事件
func (this *SceneStateStartCashMania) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
logger.Logger.Trace("(this *SceneStateStartCashMania) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " evtcode=", evtcode)
this.SceneBaseStateCashMania.OnPlayerEvent(s, p, evtcode, params)
}
func (this *SceneStateStartCashMania) OnTick(s *base.Scene) {
this.SceneBaseStateCashMania.OnTick(s)
}
// //////////////////////////////////////////////////////////////////////////////
func (this *ScenePolicyCashMania) RegisteSceneState(state base.SceneState) {
if state == nil {
return
}
stateid := state.GetState()
if stateid < 0 || stateid >= cashmania.CashManiaStateMax {
return
}
this.states[stateid] = state
}
func (this *ScenePolicyCashMania) GetSceneState(s *base.Scene, stateid int) base.SceneState {
if stateid >= 0 && stateid < cashmania.CashManiaStateMax {
return this.states[stateid]
}
return nil
}
func CashManiaAndSaveLog(sceneEx *CashManiaSceneData, playerEx *CashManiaPlayerData, data assemble.GameEnd) {
if !playerEx.IsRob {
data.SnId = playerEx.SnId
if data.Results[0].FreeStatus != 1 && data.Results[0].FreeNumMax != 0 {
data.TotalBet = 0
}
info, err := model.MarshalGameNoteByROLL(data)
if err == nil {
logid, _ := model.AutoIncGameLogId()
playerEx.currentLogId = logid
var totalin, totalout int64
if data.Results[0].FreeStatus == 1 || data.Results[0].FreeNumMax == 0 {
totalin = playerEx.totalBet
}
if data.Results[0].FreeStatus == 3 || data.Results[0].FreeNumMax == 0 {
totalout = int64(data.RoundReward) + playerEx.taxCoin
}
playerEx.Cache(sceneEx.Scene, &base.SaveGameDetailedParam{
LogId: logid,
Detail: info,
}, &base.SaveGamePlayerListLogParam{
LogId: logid,
Platform: playerEx.Platform,
Snid: playerEx.SnId,
PlayerName: playerEx.Name,
TotalIn: totalin,
TotalOut: totalout,
TaxCoin: playerEx.taxCoin,
BetAmount: totalin,
WinAmountNoAnyTax: totalout - totalin - playerEx.taxCoin,
IsFirstGame: sceneEx.IsPlayerFirst(playerEx.Player),
IsFree: playerEx.isFree,
})
}
}
//统计输下注金币数
if !sceneEx.Testing && !playerEx.IsRob {
playerBet := &server.PlayerData{
SnId: proto.Int32(playerEx.SnId),
Bet: proto.Int64(playerEx.CurrentBet),
Gain: proto.Int64(int64(data.RoundReward) + playerEx.taxCoin),
Tax: proto.Int64(playerEx.taxCoin),
Coin: proto.Int64(playerEx.GetCoin()),
GameCoinTs: proto.Int64(playerEx.GameCoinTs),
}
gwPlayerBet := &server.GWPlayerData{
SceneId: sceneEx.SceneId,
GameFreeId: proto.Int32(sceneEx.GetDBGameFree().GetId()),
}
gwPlayerBet.Datas = append(gwPlayerBet.Datas, playerBet)
sceneEx.SyncPlayerDatas(&base.PlayerDataParam{
HasRobotGaming: false,
Data: gwPlayerBet,
})
}
playerEx.taxCoin = 0
playerEx.winCoin = 0
if sceneEx.CheckNeedDestroy() && data.Results[0].FreeNum <= 0 {
sceneEx.SceneDestroy(true)
}
}
func init() {
//主状态
ScenePolicyCashManiaSington.RegisteSceneState(&SceneStateStartCashMania{})
core.RegisteHook(core.HOOK_BEFORE_START, func() error {
base.RegisteScenePolicy(common.GameId_CashMania, cashmania.RoomMode_Classic, ScenePolicyCashManiaSington)
return nil
})
}

1
gamesrv/main.go
View File

@ -29,7 +29,6 @@ import (
// 拉霸 // 拉霸
_ "mongo.games.com/game/gamesrv/avengers" _ "mongo.games.com/game/gamesrv/avengers"
_ "mongo.games.com/game/gamesrv/caishen" _ "mongo.games.com/game/gamesrv/caishen"
_ "mongo.games.com/game/gamesrv/cashmania"
_ "mongo.games.com/game/gamesrv/easterisland" _ "mongo.games.com/game/gamesrv/easterisland"
_ "mongo.games.com/game/gamesrv/fortunedragon" _ "mongo.games.com/game/gamesrv/fortunedragon"
_ "mongo.games.com/game/gamesrv/fortunemouse" _ "mongo.games.com/game/gamesrv/fortunemouse"

BIN
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Bet.xlsx vendored
View File

Binary file not shown.

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Feature/S_ItemInfo.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Feature/S_MidItemInfo.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Feature/S_Others.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Feature/S_RandomItem.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Feature/S_RandomMid.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Feature/S_WinItem.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Feature/S_WinMid.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Generic/Formation.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Generic/ReelBaseSpin.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Generic/S_Map.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Generic/Symbol.xlsx vendored Executable file → Normal file
View File

0
gamesrv/slotspkg/external/excel/Base/Slots/CashMania/Settings.xlsx vendored Executable file → Normal file
View File

138
gamesrv/slotspkg/internal/exported/excel2go/base/cash_mania.go
View File

@ -10,146 +10,80 @@ func init() {
CashManiaBetBetChangeList = map[int64]*structs.CashManiaBetBetChangeList{ CashManiaBetBetChangeList = map[int64]*structs.CashManiaBetBetChangeList{
0: { 0: {
Index: 0, Index: 0,
BetChangeList: 5000, BetChangeList: 0.3,
BetSizeIndex: 0, BetSizeIndex: 0,
BetLevelIndex: 0, BetLevelIndex: 0,
}, },
1: { 1: {
Index: 1, Index: 1,
BetChangeList: 10000, BetChangeList: 0.6,
BetSizeIndex: 0, BetSizeIndex: 0,
BetLevelIndex: 1, BetLevelIndex: 1,
}, },
2: { 2: {
Index: 2, Index: 2,
BetChangeList: 15000, BetChangeList: 0.9,
BetSizeIndex: 0, BetSizeIndex: 0,
BetLevelIndex: 2, BetLevelIndex: 2,
}, },
3: { 3: {
Index: 3, Index: 3,
BetChangeList: 20000, BetChangeList: 1,
BetSizeIndex: 0, BetSizeIndex: 1,
BetLevelIndex: 3, BetLevelIndex: 0,
}, },
4: { 4: {
Index: 4, Index: 4,
BetChangeList: 25000, BetChangeList: 1.5,
BetSizeIndex: 0, BetSizeIndex: 0,
BetLevelIndex: 4, BetLevelIndex: 4,
}, },
5: { 5: {
Index: 5, Index: 5,
BetChangeList: 30000, BetChangeList: 3,
BetSizeIndex: 0, BetSizeIndex: 0,
BetLevelIndex: 5, BetLevelIndex: 9,
}, },
6: { 6: {
Index: 6, Index: 6,
BetChangeList: 35000, BetChangeList: 5,
BetSizeIndex: 0, BetSizeIndex: 1,
BetLevelIndex: 6, BetLevelIndex: 4,
}, },
7: { 7: {
Index: 7, Index: 7,
BetChangeList: 40000, BetChangeList: 9,
BetSizeIndex: 0, BetSizeIndex: 3,
BetLevelIndex: 7, BetLevelIndex: 0,
}, },
8: { 8: {
Index: 8, Index: 8,
BetChangeList: 45000, BetChangeList: 10,
BetSizeIndex: 0, BetSizeIndex: 1,
BetLevelIndex: 8, BetLevelIndex: 9,
}, },
9: { 9: {
Index: 9, Index: 9,
BetChangeList: 50000, BetChangeList: 15,
BetSizeIndex: 0, BetSizeIndex: 2,
BetLevelIndex: 9, BetLevelIndex: 4,
}, },
10: { 10: {
Index: 10, Index: 10,
BetChangeList: 100000, BetChangeList: 30,
BetSizeIndex: 1, BetSizeIndex: 2,
BetLevelIndex: 1, BetLevelIndex: 9,
}, },
11: { 11: {
Index: 11, Index: 11,
BetChangeList: 150000, BetChangeList: 45,
BetSizeIndex: 1, BetSizeIndex: 3,
BetLevelIndex: 2, BetLevelIndex: 4,
}, },
12: { 12: {
Index: 12, Index: 12,
BetChangeList: 200000, BetChangeList: 90,
BetSizeIndex: 1, BetSizeIndex: 3,
BetLevelIndex: 3,
},
13: {
Index: 13,
BetChangeList: 250000,
BetSizeIndex: 1,
BetLevelIndex: 4,
},
14: {
Index: 14,
BetChangeList: 300000,
BetSizeIndex: 1,
BetLevelIndex: 5,
},
15: {
Index: 15,
BetChangeList: 350000,
BetSizeIndex: 1,
BetLevelIndex: 6,
},
16: {
Index: 16,
BetChangeList: 400000,
BetSizeIndex: 1,
BetLevelIndex: 7,
},
17: {
Index: 17,
BetChangeList: 450000,
BetSizeIndex: 1,
BetLevelIndex: 8,
},
18: {
Index: 18,
BetChangeList: 500000,
BetSizeIndex: 1,
BetLevelIndex: 9,
},
19: {
Index: 19,
BetChangeList: 800000,
BetSizeIndex: 2,
BetLevelIndex: 1,
},
20: {
Index: 20,
BetChangeList: 1200000,
BetSizeIndex: 2,
BetLevelIndex: 2,
},
21: {
Index: 21,
BetChangeList: 2000000,
BetSizeIndex: 2,
BetLevelIndex: 4,
},
22: {
Index: 22,
BetChangeList: 3200000,
BetSizeIndex: 2,
BetLevelIndex: 7,
},
23: {
Index: 23,
BetChangeList: 4000000,
BetSizeIndex: 2,
BetLevelIndex: 9, BetLevelIndex: 9,
}, },
} }
@ -208,23 +142,27 @@ func init() {
CashManiaBetBetSize = map[int64]*structs.CashManiaBetBetSize{ CashManiaBetBetSize = map[int64]*structs.CashManiaBetBetSize{
0: { 0: {
Index: 0, Index: 0,
BetSize: 5000000, BetSize: 300,
}, },
1: { 1: {
Index: 1, Index: 1,
BetSize: 50000000, BetSize: 1000,
}, },
2: { 2: {
Index: 2, Index: 2,
BetSize: 400000000, BetSize: 3000,
},
3: {
Index: 3,
BetSize: 9000,
}, },
} }
CashManiaBetFirstBet = map[int64]*structs.CashManiaBetFirstBet{ CashManiaBetFirstBet = map[int64]*structs.CashManiaBetFirstBet{
1: { 1: {
Index: 1, Index: 1,
BetSizeIndex: 0, BetSizeIndex: 1,
BetLevelIndex: 9, BetLevelIndex: 0,
}, },
} }