300 lines
9.8 KiB
Go
300 lines
9.8 KiB
Go
package thirteen
|
|
|
|
import (
|
|
"mongo.games.com/game/proto"
|
|
"mongo.games.com/game/robot/base"
|
|
|
|
"mongo.games.com/game/common"
|
|
rule "mongo.games.com/game/gamerule/thirteen"
|
|
"mongo.games.com/game/protocol/thirteen"
|
|
|
|
"mongo.games.com/goserver/core/logger"
|
|
"mongo.games.com/goserver/core/netlib"
|
|
)
|
|
|
|
type SCThirteenWaterRoomInfoPacketFactory struct {
|
|
}
|
|
|
|
type SCThirteenWaterRoomInfoHandler struct {
|
|
}
|
|
|
|
func (this *SCThirteenWaterRoomInfoPacketFactory) CreatePacket() interface{} {
|
|
pack := &thirteen.SCThirteenRoomInfo{}
|
|
return pack
|
|
}
|
|
|
|
func (this *SCThirteenWaterRoomInfoHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
|
me := base.GetUser(s)
|
|
logger.Logger.Tracef("(this *SCThirteenWaterRoomInfoHandler) Process [%v].", me.GetData().GetSnId())
|
|
if msg, ok := pack.(*thirteen.SCThirteenRoomInfo); ok {
|
|
scene, ok := base.SceneMgrSingleton.GetScene(msg.GetRoomId()).(*ThirteenWaterScene)
|
|
if scene == nil || ok == false {
|
|
scene = NewThirteenWaterScene(msg)
|
|
base.SceneMgrSingleton.AddScene(scene)
|
|
}
|
|
if scene != nil {
|
|
for _, pd := range msg.GetPlayers() {
|
|
if scene.GetPlayerBySnid(pd.GetSnId()) == nil {
|
|
p := NewThirteenWaterPlayer(pd)
|
|
if p != nil {
|
|
scene.AddPlayer(p)
|
|
}
|
|
}
|
|
}
|
|
switch int(msg.GetState()) {
|
|
case rule.ThirteenWaterSceneStateWait, rule.ThirteenWaterSceneStateStart:
|
|
}
|
|
}
|
|
|
|
} else {
|
|
logger.Logger.Error("SCThirteenWaterRoomInfo package data error.")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SCThirteenWaterRoomStatePacketFactory struct {
|
|
}
|
|
|
|
type SCThirteenWaterRoomStateHandler struct {
|
|
}
|
|
|
|
func (this *SCThirteenWaterRoomStatePacketFactory) CreatePacket() interface{} {
|
|
pack := &thirteen.SCThirteenRoomState{}
|
|
return pack
|
|
}
|
|
|
|
func (this *SCThirteenWaterRoomStateHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
|
me := base.GetUser(s)
|
|
logger.Logger.Tracef("(this *SCThirteenWaterRoomStateHandler) Process [%v].", me.GetData().GetSnId())
|
|
if msg, ok := pack.(*thirteen.SCThirteenRoomState); ok {
|
|
if scene, ok := base.GetScene(s).(*ThirteenWaterScene); ok {
|
|
|
|
p := scene.GetMe(s)
|
|
if p == base.NilPlayer {
|
|
return nil
|
|
}
|
|
if me, ok := p.(*ThirteenWaterPlayer); ok && me != nil {
|
|
//logger.Logger.Trace(msg)
|
|
switch int(msg.GetState()) {
|
|
case rule.ThirteenWaterSceneStateOptCard:
|
|
//十三水选牌
|
|
player := p.(*ThirteenWaterPlayer)
|
|
if player == nil {
|
|
return nil
|
|
}
|
|
n := int32(0)
|
|
if len(player.allcardsO) != 0 {
|
|
//rands := rand.Intn(len(player.allcardsO))
|
|
//n = player.allcardsO[rands]
|
|
player.GetMaxCardsO()
|
|
n = player.maxcardsO
|
|
}
|
|
if n == 0 {
|
|
n = -1
|
|
}
|
|
pack := &thirteen.CSThirteenPlayerOp{
|
|
OpCode: proto.Int32(int32(rule.ThirteenWaterPlayerOpMS)),
|
|
OpParam: []int64{int64(n), -2},
|
|
}
|
|
proto.SetDefaults(pack)
|
|
base.DelaySendSecond(s, int(thirteen.TWMmoPacketID_PACKET_CSThirteenPlayerOp), pack, 5, 10)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
logger.Logger.Error("SCThirteenWaterRoomState package data error.")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SCThirteenWaterPlayerEnterPacketFactory struct {
|
|
}
|
|
|
|
type SCThirteenWaterPlayerEnterHandler struct {
|
|
}
|
|
|
|
func (this *SCThirteenWaterPlayerEnterPacketFactory) CreatePacket() interface{} {
|
|
pack := &thirteen.SCThirteenPlayerEnter{}
|
|
return pack
|
|
}
|
|
|
|
func (this *SCThirteenWaterPlayerEnterHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
|
me := base.GetUser(s)
|
|
logger.Logger.Tracef("(this *SCThirteenWaterPlayerEnterHandler) Process [%v].", me.GetData().GetSnId())
|
|
if msg, ok := pack.(*thirteen.SCThirteenPlayerEnter); ok {
|
|
if scene, ok := base.GetScene(s).(base.IScene); ok && scene != nil {
|
|
//logger.Logger.Trace(msg)
|
|
player := NewThirteenWaterPlayer(msg.GetData())
|
|
if player != nil {
|
|
scene.AddPlayer(player)
|
|
}
|
|
}
|
|
} else {
|
|
logger.Logger.Error("SCThirteenWaterPlayerEnter package data error.")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SCThirteenWaterPlayerLeavePacketFactory struct {
|
|
}
|
|
|
|
type SCThirteenWaterPlayerLeaveHandler struct {
|
|
}
|
|
|
|
func (this *SCThirteenWaterPlayerLeavePacketFactory) CreatePacket() interface{} {
|
|
pack := &thirteen.SCThirteenPlayerLeave{}
|
|
return pack
|
|
}
|
|
|
|
func (this *SCThirteenWaterPlayerLeaveHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
|
me := base.GetUser(s)
|
|
logger.Logger.Tracef("(this *SCThirteenWaterPlayerLeaveHandler) Process [%v].", me.GetData().GetSnId())
|
|
if msg, ok := pack.(*thirteen.SCThirteenPlayerLeave); ok {
|
|
if scene, ok := base.GetScene(s).(*ThirteenWaterScene); ok && scene != nil {
|
|
//logger.Logger.Trace(msg)
|
|
p := scene.GetPlayerByPos(msg.GetPos())
|
|
if p != nil {
|
|
if player, ok := p.(*ThirteenWaterPlayer); ok && player != nil {
|
|
scene.DelPlayer(player.GetSnId())
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
logger.Logger.Error("SCThirteenWaterPlayerLeave package data error.")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SCThirteenWaterBilledPacketFactory struct {
|
|
}
|
|
|
|
type SCThirteenWaterBilledHandler struct {
|
|
}
|
|
|
|
func (this *SCThirteenWaterBilledPacketFactory) CreatePacket() interface{} {
|
|
pack := &thirteen.SCThirteenBilled{}
|
|
return pack
|
|
}
|
|
|
|
func (this *SCThirteenWaterBilledHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
|
me := base.GetUser(s)
|
|
logger.Logger.Tracef("(this *SCThirteenWaterBilledHandler) Process [%v].", me.GetData().GetSnId())
|
|
if msg, ok := pack.(*thirteen.SCThirteenBilled); ok {
|
|
if scene, ok := base.GetScene(s).(*ThirteenWaterScene); ok && scene != nil {
|
|
for _, v := range msg.GetAllBilled() {
|
|
p := scene.GetPlayerByPos(v.GetPos())
|
|
if player, ok := p.(*ThirteenWaterPlayer); ok && player != nil {
|
|
player.Coin = v.GetCoin()
|
|
}
|
|
}
|
|
scene.Clear()
|
|
}
|
|
} else {
|
|
logger.Logger.Error("SCThirteenWaterBilled package data error.")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SCThirteenWaterPlayerOpPacketFactory struct {
|
|
}
|
|
|
|
type SCThirteenWaterPlayerOpHandler struct {
|
|
}
|
|
|
|
func (this *SCThirteenWaterPlayerOpPacketFactory) CreatePacket() interface{} {
|
|
pack := &thirteen.SCThirteenPlayerOp{}
|
|
return pack
|
|
}
|
|
|
|
func (this *SCThirteenWaterPlayerOpHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
|
me := base.GetUser(s)
|
|
logger.Logger.Tracef("(this *SCThirteenWaterPlayerOpHandler) Process [%v].", me.GetData().GetSnId())
|
|
if msg, ok := pack.(*thirteen.SCThirteenPlayerOp); ok {
|
|
if scene, ok := base.GetScene(s).(*ThirteenWaterScene); ok && scene != nil {
|
|
p := scene.GetMe(s)
|
|
if p == base.NilPlayer {
|
|
return nil
|
|
}
|
|
player := p.(*ThirteenWaterPlayer)
|
|
if me, ok := p.(*ThirteenWaterPlayer); ok && me != nil {
|
|
if me.Pos == msg.Pos {
|
|
if player.cardsO.PokerType == -1 {
|
|
copy(common.CopySliceIntToInt32(player.cardsO.Head[:]), msg.GetCards().GetHead())
|
|
copy(common.CopySliceIntToInt32(player.cardsO.Mid[:]), msg.GetCards().GetMid())
|
|
copy(common.CopySliceIntToInt32(player.cardsO.End[:]), msg.GetCards().GetEnd())
|
|
player.cardsO.PokerType = int(msg.GetCards().GetIndexType())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
logger.Logger.Error("SCThirteenWaterPokerType package data error.")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SCThirteenWaterPlayerCardsPacketFactory struct {
|
|
}
|
|
|
|
type SCThirteenWaterPlayerCardsHandler struct {
|
|
}
|
|
|
|
func (this *SCThirteenWaterPlayerCardsPacketFactory) CreatePacket() interface{} {
|
|
pack := &thirteen.SCThirteenPlayerCards{}
|
|
return pack
|
|
}
|
|
|
|
func (this *SCThirteenWaterPlayerCardsHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
|
me := base.GetUser(s)
|
|
logger.Logger.Tracef("(this *SCThirteenWaterPlayerOpHandler) Process [%v].", me.GetData().GetSnId())
|
|
if msg, ok := pack.(*thirteen.SCThirteenPlayerCards); ok {
|
|
if scene, ok := base.GetScene(s).(*ThirteenWaterScene); ok && scene != nil {
|
|
//logger.Logger.Trace(msg)
|
|
p := scene.GetPlayerByPos(msg.GetPos())
|
|
if p != nil {
|
|
if player, ok := p.(*ThirteenWaterPlayer); ok && player != nil {
|
|
if player.GetSnId() == me.GetData().GetSnId() {
|
|
player.Cards = msg.GetCards()
|
|
for k, v := range msg.GetAllCardsO() {
|
|
player.allcardsO[k] = v.GetIndexType()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
logger.Logger.Error("SCThirteenWaterPlayerCards package data error.")
|
|
}
|
|
return nil
|
|
}
|
|
func init() {
|
|
//SCThirteenWaterRoomInfo
|
|
netlib.RegisterHandler(int(thirteen.TWMmoPacketID_PACKET_SCThirteenRoomInfo), &SCThirteenWaterRoomInfoHandler{})
|
|
netlib.RegisterFactory(int(thirteen.TWMmoPacketID_PACKET_SCThirteenRoomInfo), &SCThirteenWaterRoomInfoPacketFactory{})
|
|
|
|
//SCThirteenWaterRoomState
|
|
netlib.RegisterHandler(int(thirteen.TWMmoPacketID_PACKET_SCThirteenRoomState), &SCThirteenWaterRoomStateHandler{})
|
|
netlib.RegisterFactory(int(thirteen.TWMmoPacketID_PACKET_SCThirteenRoomState), &SCThirteenWaterRoomStatePacketFactory{})
|
|
|
|
//SCThirteenWaterPlayerEnter
|
|
netlib.RegisterHandler(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerEnter), &SCThirteenWaterPlayerEnterHandler{})
|
|
netlib.RegisterFactory(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerEnter), &SCThirteenWaterPlayerEnterPacketFactory{})
|
|
|
|
//SCThirteenWaterPlayerLeave
|
|
netlib.RegisterHandler(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerLeave), &SCThirteenWaterPlayerLeaveHandler{})
|
|
netlib.RegisterFactory(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerLeave), &SCThirteenWaterPlayerLeavePacketFactory{})
|
|
|
|
//SCThirteenWaterBilled
|
|
netlib.RegisterHandler(int(thirteen.TWMmoPacketID_PACKET_SCThirteenBilled), &SCThirteenWaterBilledHandler{})
|
|
netlib.RegisterFactory(int(thirteen.TWMmoPacketID_PACKET_SCThirteenBilled), &SCThirteenWaterBilledPacketFactory{})
|
|
|
|
//SCThirteenPlayerOp
|
|
netlib.RegisterHandler(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerOp), &SCThirteenWaterPlayerOpHandler{})
|
|
netlib.RegisterFactory(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerOp), &SCThirteenWaterPlayerOpPacketFactory{})
|
|
|
|
//SCThirteenWaterPlayerCards
|
|
netlib.RegisterHandler(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerCards), &SCThirteenWaterPlayerCardsHandler{})
|
|
netlib.RegisterFactory(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerCards), &SCThirteenWaterPlayerCardsPacketFactory{})
|
|
|
|
}
|