482 lines
17 KiB
Go
482 lines
17 KiB
Go
package chess
|
||
|
||
import (
|
||
"math/rand"
|
||
"time"
|
||
|
||
"mongo.games.com/goserver/core/basic"
|
||
"mongo.games.com/goserver/core/logger"
|
||
"mongo.games.com/goserver/core/netlib"
|
||
"mongo.games.com/goserver/core/task"
|
||
"mongo.games.com/goserver/core/timer"
|
||
|
||
rule "mongo.games.com/game/gamerule/chess"
|
||
"mongo.games.com/game/proto"
|
||
proto_chesstitians "mongo.games.com/game/protocol/chesstitians"
|
||
"mongo.games.com/game/robot/base"
|
||
)
|
||
|
||
type SCChesstitiansRoomInfoPacketFactory struct {
|
||
}
|
||
|
||
type SCChesstitiansRoomInfoHandler struct {
|
||
}
|
||
|
||
func (this *SCChesstitiansRoomInfoPacketFactory) CreatePacket() interface{} {
|
||
pack := &proto_chesstitians.SCChesstitiansRoomInfo{}
|
||
return pack
|
||
}
|
||
|
||
func (this *SCChesstitiansRoomInfoHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
||
logger.Logger.Tracef("(this *SCChesstitiansRoomInfoHandler) Process [%v].", s.GetSessionConfig().Id)
|
||
if msg, ok := pack.(*proto_chesstitians.SCChesstitiansRoomInfo); ok {
|
||
scene := base.SceneMgrSingleton.GetScene(msg.GetRoomId())
|
||
if scene == nil {
|
||
scene = NewChesstitiansScene(msg)
|
||
base.SceneMgrSingleton.AddScene(scene)
|
||
}
|
||
if scene != nil {
|
||
for _, pd := range msg.GetPlayers() {
|
||
if scene.GetPlayerBySnid(pd.GetSnId()) == nil {
|
||
p := NewChesstitiansPlayer(pd)
|
||
if p != nil {
|
||
scene.AddPlayer(p)
|
||
}
|
||
}
|
||
}
|
||
//logger.Logger.Infof("(this *SCChesstitiansRoomInfoHandler) SetAttribute(base.SessionAttributeSceneId) %v %v", scene.GetRoomId(), msg)
|
||
operateTask(s, 3)
|
||
}
|
||
} else {
|
||
logger.Logger.Error("SCChesstitiansRoomInfo package data error.")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type SCChesstitiansPlayerOpPacketFactory struct {
|
||
}
|
||
|
||
type SCChesstitiansPlayerOpHandler struct {
|
||
}
|
||
|
||
func (this *SCChesstitiansPlayerOpPacketFactory) CreatePacket() interface{} {
|
||
pack := &proto_chesstitians.SCChesstitiansPlayerOp{}
|
||
return pack
|
||
}
|
||
|
||
func (this *SCChesstitiansPlayerOpHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
||
logger.Logger.Tracef("(this *SCChesstitiansPlayerOpHandler) Process [%v].", s.GetSessionConfig().Id)
|
||
if scChesstitiansOp, ok := pack.(*proto_chesstitians.SCChesstitiansPlayerOp); ok {
|
||
if scene, ok := base.GetScene(s).(*ChesstitiansScene); ok {
|
||
player := scene.GetMe(s)
|
||
|
||
if player == base.NilPlayer {
|
||
//logger.Logger.Errorf("(this *SCChesstitiansPlayerOpHandler) nilPlayer")
|
||
return nil
|
||
}
|
||
me, ok2 := player.(*ChesstitiansPlayer)
|
||
//logger.Logger.Infof("(this *SCChesstitiansPlayerOpHandler) player ok:%v me:%v", ok2, me)
|
||
if ok2 && me != ChesstitiansNilPlayer {
|
||
//logger.Logger.Tracef("SCChesstitiansPlayerOpHandler msg:%v", scChesstitiansOp)
|
||
isMeOp := me.GetSnId() == scChesstitiansOp.GetSnId()
|
||
if isMeOp {
|
||
if int(scChesstitiansOp.GetOpRetCode()) == 0 {
|
||
switch scChesstitiansOp.GetOpCode() {
|
||
case rule.PlayerOpPlay:
|
||
}
|
||
} else { //操作失败
|
||
logger.Logger.Infof("TODO: 如果操作失败，应改为操作")
|
||
switch scChesstitiansOp.GetOpCode() {
|
||
case rule.PlayerOpPlay:
|
||
// ai请求失败，随便走一步
|
||
AiRandom(s)
|
||
}
|
||
}
|
||
}
|
||
|
||
if scChesstitiansOp.GetOpCode() == rule.PlayerOpPlay && scChesstitiansOp.GetOpRetCode() == 0 {
|
||
param := scChesstitiansOp.GetOpParam()
|
||
//scene.chess.PlayOp(int(param[0]), int(param[1]))
|
||
//scene.chess.NextAct()
|
||
scene.PlayOp(int(param[0]), int(param[1]))
|
||
}
|
||
|
||
if !isMeOp {
|
||
//todo 对方求和，机器人暂时都同意求和
|
||
// 机器人模拟真人，求和，认输，悔棋等操作
|
||
switch scChesstitiansOp.GetOpCode() {
|
||
case rule.PlayerOpDraw:
|
||
pack := &proto_chesstitians.SCChesstitiansPlayerOp{
|
||
OpCode: proto.Int32(rule.PlayerOpPlay),
|
||
}
|
||
if rand.Int31n(100) < 80 {
|
||
pack.OpParam = []int64{rule.RefuseDraw}
|
||
} else {
|
||
pack.OpParam = []int64{rule.AgreeDraw}
|
||
}
|
||
base.DelaySendSecond(s, int(proto_chesstitians.ChesstitiansPacketID_PACKET_CSChesstitiansPlayerOp),
|
||
pack, []int{2, 5}...)
|
||
}
|
||
|
||
operateTask(s, 3)
|
||
}
|
||
|
||
} else {
|
||
logger.Logger.Errorf("(this *SCChesstitiansPlayerOpHandler) nilPlayer")
|
||
}
|
||
} else {
|
||
logger.Logger.Error("SCChesstitiansPlayerOp base.GetScene(s).(*ChesstitiansScene) error")
|
||
}
|
||
} else {
|
||
logger.Logger.Error("SCChesstitiansPlayerOp package data error.")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type SCChesstitiansRoomStatePacketFactory struct {
|
||
}
|
||
|
||
type SCChesstitiansRoomStateHandler struct {
|
||
}
|
||
|
||
func (this *SCChesstitiansRoomStatePacketFactory) CreatePacket() interface{} {
|
||
pack := &proto_chesstitians.SCChesstitiansRoomState{}
|
||
return pack
|
||
}
|
||
|
||
func (this *SCChesstitiansRoomStateHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
||
logger.Logger.Infof("(this *SCChesstitiansRoomStateHandler) Process [%v].", s.GetSessionConfig().Id)
|
||
if scChesstitiansRoomState, ok := pack.(*proto_chesstitians.SCChesstitiansRoomState); ok {
|
||
//logger.Logger.Infof("(this *SCChesstitiansRoomStateHandler) base.GetScene(s).(*ChesstitiansScene)")
|
||
if scene, ok := base.GetScene(s).(*ChesstitiansScene); ok {
|
||
scene.State = scChesstitiansRoomState.State
|
||
p := scene.GetMe(s)
|
||
me, ok := p.(*ChesstitiansPlayer)
|
||
//logger.Logger.Infof("(this *SCChesstitiansRoomStateHandler) get player snId:%v ok:%v me:%v", p.GetSnId(), ok, me)
|
||
if ok && me != ChesstitiansNilPlayer {
|
||
//logger.Logger.Infof("(this *SCChesstitiansRoomStateHandler) to roomState state:%v", scChesstitiansRoomState.GetState())
|
||
switch scChesstitiansRoomState.GetState() {
|
||
case int32(rule.SceneStateWaitPlayer):
|
||
scene.Clear()
|
||
case int32(rule.SceneStateWaitStart): //等待开始
|
||
scene.Clear()
|
||
if me.GetSnId() == scene.GetMasterSnid() {
|
||
packOp := &proto_chesstitians.CSChesstitiansPlayerOp{
|
||
OpCode: proto.Int32(3),
|
||
}
|
||
proto.SetDefaults(packOp)
|
||
//if scene.GetIsAllAi() {
|
||
// base.DelayAISend(s, int(proto_chesstitians.ChesstitiansPacketID_PACKET_CSChesstitiansPlayerOp), packOp)
|
||
//} else {
|
||
// base.DelaySendSecond(s, int(proto_chesstitians.ChesstitiansPacketID_PACKET_CSChesstitiansPlayerOp), packOp, []int{3, 7}...)
|
||
//}
|
||
base.DelaySendSecond(s, int(proto_chesstitians.ChesstitiansPacketID_PACKET_CSChesstitiansPlayerOp), packOp, []int{2, 5}...)
|
||
}
|
||
case int32(rule.SceneStatePlayerOp):
|
||
logger.Logger.Infof("检查是否机器人先开始 %d", scene.CurOpIdx)
|
||
operateTask(s, 3)
|
||
case int32(rule.SceneStateBilled):
|
||
scene.Clear()
|
||
me.Clear()
|
||
}
|
||
} else {
|
||
logger.Logger.Errorf("(this *SCChesstitiansRoomStateHandler) get player snId:%v", me.GetSnId())
|
||
}
|
||
} else {
|
||
logger.Logger.Errorf("(this *SCChesstitiansRoomStateHandler) base.GetScene(s).(*ChesstitiansScene)")
|
||
}
|
||
} else {
|
||
logger.Logger.Error("SCChesstitiansRoomState package data error.")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func operateTask(s *netlib.Session, times int) {
|
||
logger.Logger.Info("@@CallableWrapper")
|
||
var array []int64
|
||
var code int
|
||
|
||
if s == nil {
|
||
return
|
||
}
|
||
|
||
scene, ok := base.GetScene(s).(*ChesstitiansScene)
|
||
if !ok {
|
||
return
|
||
}
|
||
|
||
p := scene.GetMe(s)
|
||
me, ok := p.(*ChesstitiansPlayer)
|
||
if !ok || me == ChesstitiansNilPlayer || me == nil {
|
||
return
|
||
}
|
||
|
||
if scene.State != int32(rule.SceneStatePlayerOp) {
|
||
return
|
||
}
|
||
|
||
if me.IsBlack == 1 && scene.GetAct() == "b" || me.IsBlack != 1 && scene.GetAct() == "w" {
|
||
// 轮到当前行棋方
|
||
chess := scene.chess
|
||
fen := chess.GenFen()
|
||
logger.Logger.Infof("fen: %s", fen)
|
||
|
||
skillLevel := 20
|
||
switch scene.SceneType {
|
||
case 1:
|
||
skillLevel = -6
|
||
case 2:
|
||
skillLevel = -3
|
||
case 3:
|
||
skillLevel = 0
|
||
case 4:
|
||
skillLevel = 3
|
||
case 5:
|
||
skillLevel = 6
|
||
}
|
||
|
||
var resp StockfishResp
|
||
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
||
if scene.GetVariant() == int32(rule.ChessVarChess) {
|
||
resp = UCIPost(fen, 500)
|
||
} else if scene.GetVariant() == int32(rule.ChessVarMakruk) {
|
||
resp = MakrukPost(fen, 500)
|
||
} else if scene.GetVariant() == int32(rule.ChessVarCambodian) {
|
||
resp = CambodianPost(fen, 500, skillLevel)
|
||
}
|
||
return nil
|
||
}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
|
||
if resp.Error == 0 && len(resp.Bestmove) >= 4 {
|
||
array = chess.UciTwoPosToIdxList(resp.Bestmove)
|
||
logger.Logger.Infof("fen: %v, Bestmove: %v, Ponder: %v", fen, resp.Bestmove, resp.Ponder)
|
||
packOp := &proto_chesstitians.SCChesstitiansPlayerOp{
|
||
OpCode: proto.Int32(rule.PlayerOpPlay),
|
||
OpParam: array,
|
||
}
|
||
base.DelaySendSecond(s, int(proto_chesstitians.ChesstitiansPacketID_PACKET_CSChesstitiansPlayerOp), packOp, []int{1, 2}...)
|
||
//logger.Logger.Infof("CSChesstitiansPlayerOp %v", packOp.String())
|
||
} else {
|
||
logger.Logger.Errorf("AI错误 %v", code)
|
||
if times > 0 {
|
||
timer.StartTimer(timer.TimerActionWrapper(func(h timer.TimerHandle, ud interface{}) bool {
|
||
operateTask(s, times-1)
|
||
return true
|
||
}), nil, time.Second*5, 1)
|
||
} else {
|
||
// ai请求失败，随便走一步
|
||
AiRandom(s)
|
||
}
|
||
}
|
||
}), "UCI_Action").Start()
|
||
}
|
||
}
|
||
|
||
type SCChesstitiansGameBilledPacketFactory struct {
|
||
}
|
||
|
||
type SCChesstitiansGameBilledHandler struct {
|
||
}
|
||
|
||
func (this *SCChesstitiansGameBilledPacketFactory) CreatePacket() interface{} {
|
||
pack := &proto_chesstitians.SCChesstitiansGameBilled{}
|
||
return pack
|
||
}
|
||
|
||
func (this *SCChesstitiansGameBilledHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
||
logger.Logger.Tracef("(this *SCChesstitiansGameBilledHandler) Process [%v].", s.GetSessionConfig().Id)
|
||
if scChesstitiansBilled, ok := pack.(*proto_chesstitians.SCChesstitiansGameBilled); ok {
|
||
if scene, ok := base.GetScene(s).(*ChesstitiansScene); ok {
|
||
//logger.Logger.Trace(scChesstitiansBilled)
|
||
billData := scChesstitiansBilled.GetDatas()
|
||
for _, data := range billData {
|
||
p := scene.GetMe(s)
|
||
if p == base.NilPlayer {
|
||
continue
|
||
}
|
||
if me, ok2 := p.(*ChesstitiansPlayer); ok2 && me != ChesstitiansNilPlayer {
|
||
if data.GetSnId() == me.GetSnId() { //自己的数据
|
||
me.Coin = proto.Int64(data.GetGameCoin())
|
||
me.IsWin = data.GetIsWin()
|
||
me.ChessGrade = int64(data.Score)
|
||
me.WinTimes = data.WinTimes
|
||
me.WinScore = data.WinScore
|
||
me.OtherScore = data.OtherScore
|
||
me.NextRank = data.NextRank
|
||
me.WinCoin = data.WinCoin
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
logger.Logger.Error("SCChesstitiansGameBilled package data error.")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type SCChesstitiansCardPacketFactory struct {
|
||
}
|
||
|
||
type SCChesstitiansCardHandler struct {
|
||
}
|
||
|
||
func (this *SCChesstitiansCardPacketFactory) CreatePacket() interface{} {
|
||
pack := &proto_chesstitians.SCChesstitiansCard{}
|
||
return pack
|
||
}
|
||
|
||
func (this *SCChesstitiansCardHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
||
logger.Logger.Tracef("(this *SCChesstitiansCardHandler) Process [%v].", s.GetSessionConfig().Id)
|
||
if scChesstitiansCard, ok := pack.(*proto_chesstitians.SCChesstitiansCard); ok {
|
||
if scene, ok := base.GetScene(s).(*ChesstitiansScene); ok {
|
||
scene.Chess = scChesstitiansCard.GetChess()
|
||
scene.Act = scChesstitiansCard.GetAct()
|
||
scene.Castling = scChesstitiansCard.GetCastling()
|
||
scene.Enpassant = scChesstitiansCard.GetEnpassant()
|
||
scene.ChessRound = scChesstitiansCard.GetChessRound()
|
||
cards := scChesstitiansCard.GetCards()
|
||
p := scene.GetMe(s)
|
||
if me, ok2 := p.(*ChesstitiansPlayer); ok2 && me != ChesstitiansNilPlayer {
|
||
if scene.GetState() == int32(rule.SceneStateChessInit) {
|
||
op := scene.GetOp(s).(*ChesstitiansPlayer) // TODO:
|
||
if cards[0] == 1 {
|
||
me.IsBlack = 1
|
||
op.IsBlack = 0
|
||
} else {
|
||
me.IsBlack = 0
|
||
op.IsBlack = 1
|
||
}
|
||
scene.makeChessStruct(scene.chess)
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
logger.Logger.Error("SCChesstitiansCardHandler package SCChesstitiansCard error.")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type SCChesstitiansUpdateMasterSnidPacketFactory struct {
|
||
}
|
||
|
||
type SCChesstitiansUpdateMasterSnidHandler struct {
|
||
}
|
||
|
||
func (this *SCChesstitiansUpdateMasterSnidPacketFactory) CreatePacket() interface{} {
|
||
pack := &proto_chesstitians.SCChesstitiansUpdateMasterSnid{}
|
||
return pack
|
||
}
|
||
|
||
func (this *SCChesstitiansUpdateMasterSnidHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
||
logger.Logger.Tracef("(this *SCChesstitiansUpdateMasterSnidHandler) Process [%v].", s.GetSessionConfig().Id)
|
||
if scChesstitiansUpdateMasterSnid, ok := pack.(*proto_chesstitians.SCChesstitiansUpdateMasterSnid); ok {
|
||
if scene, ok := base.GetScene(s).(*ChesstitiansScene); ok {
|
||
masterSnid := scChesstitiansUpdateMasterSnid.GetMasterSnid()
|
||
scene.MasterSnid = masterSnid //更新房主
|
||
}
|
||
} else {
|
||
logger.Logger.Error("SCChesstitiansUpdateMasterSnidHandler package SCChesstitiansUpdateMasterSnid error.")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 玩家进入
|
||
|
||
type SCChesstitiansPlayerEnterFactory struct {
|
||
}
|
||
|
||
func (this *SCChesstitiansPlayerEnterFactory) CreatePacket() interface{} {
|
||
pack := &proto_chesstitians.SCChesstitiansPlayerEnter{}
|
||
return pack
|
||
}
|
||
|
||
type SCChesstitiansPlayerEnterHandler struct {
|
||
}
|
||
|
||
func (this *SCChesstitiansPlayerEnterHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
||
msg, ok := pack.(*proto_chesstitians.SCChesstitiansPlayerEnter)
|
||
if !ok {
|
||
logger.Logger.Error("SCChesstitiansPlayerEnterHandler error")
|
||
return nil
|
||
}
|
||
logger.Logger.Trace("Recover SCChesstitiansPlayerEnterHandler ", msg.String())
|
||
scene, ok := base.GetScene(s).(*ChesstitiansScene)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
if scene == nil {
|
||
return nil
|
||
}
|
||
if player := NewChesstitiansPlayer(msg.GetData()); player != nil {
|
||
scene.AddPlayer(player)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 玩家离开
|
||
|
||
type SCChesstitiansPlayerLeaveFactory struct {
|
||
}
|
||
|
||
func (this *SCChesstitiansPlayerLeaveFactory) CreatePacket() interface{} {
|
||
pack := &proto_chesstitians.SCChesstitiansPlayerLeave{}
|
||
return pack
|
||
}
|
||
|
||
type SCChesstitiansPlayerLeaveHandler struct {
|
||
}
|
||
|
||
func (this *SCChesstitiansPlayerLeaveHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
|
||
msg, ok := pack.(*proto_chesstitians.SCChesstitiansPlayerLeave)
|
||
if !ok {
|
||
logger.Logger.Error("SCChesstitiansPlayerLeaveHandler error")
|
||
return nil
|
||
}
|
||
logger.Logger.Trace("Recover SCChesstitiansPlayerLeaveHandler ", msg.String())
|
||
scene, ok := base.GetScene(s).(*ChesstitiansScene)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
if scene == nil {
|
||
return nil
|
||
}
|
||
if player, ok := scene.GetPlayerByPos(msg.GetPos()).(*ChesstitiansPlayer); ok && player != nil {
|
||
scene.DelPlayer(player.GetSnId())
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func init() {
|
||
//SCChesstitiansRoomInfo
|
||
netlib.RegisterHandler(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansRoomInfo), &SCChesstitiansRoomInfoHandler{})
|
||
netlib.RegisterFactory(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansRoomInfo), &SCChesstitiansRoomInfoPacketFactory{})
|
||
//SCChesstitiansPlayerOp
|
||
netlib.RegisterHandler(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansPlayerOp), &SCChesstitiansPlayerOpHandler{})
|
||
netlib.RegisterFactory(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansPlayerOp), &SCChesstitiansPlayerOpPacketFactory{})
|
||
//SCChesstitiansRoomState
|
||
netlib.RegisterHandler(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansRoomState), &SCChesstitiansRoomStateHandler{})
|
||
netlib.RegisterFactory(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansRoomState), &SCChesstitiansRoomStatePacketFactory{})
|
||
//SCChesstitiansFinalBilled
|
||
netlib.RegisterHandler(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansGameBilled), &SCChesstitiansGameBilledHandler{})
|
||
netlib.RegisterFactory(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansGameBilled), &SCChesstitiansGameBilledPacketFactory{})
|
||
//SCChesstitiansCard
|
||
netlib.RegisterHandler(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansCard), &SCChesstitiansCardHandler{})
|
||
netlib.RegisterFactory(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansCard), &SCChesstitiansCardPacketFactory{})
|
||
//SCChesstitiansUpdateMasterSnid
|
||
netlib.RegisterHandler(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansUpdateMasterSnid), &SCChesstitiansUpdateMasterSnidHandler{})
|
||
netlib.RegisterFactory(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansUpdateMasterSnid), &SCChesstitiansUpdateMasterSnidPacketFactory{})
|
||
//ChesstitiansPacketID_PACKET_SCChesstitiansPlayerEnter
|
||
netlib.RegisterHandler(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansPlayerEnter), &SCChesstitiansPlayerEnterHandler{})
|
||
netlib.RegisterFactory(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansPlayerEnter), &SCChesstitiansPlayerEnterFactory{})
|
||
//ChesstitiansPacketID_PACKET_SCChesstitiansPlayerLeave
|
||
netlib.RegisterHandler(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansPlayerLeave), &SCChesstitiansPlayerLeaveHandler{})
|
||
netlib.RegisterFactory(int(proto_chesstitians.ChesstitiansPacketID_PACKET_SCChesstitiansPlayerLeave), &SCChesstitiansPlayerLeaveFactory{})
|
||
|
||
////Testjson()
|
||
//task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
||
// logger.Logger.Info("@@CallableWrapper")
|
||
// stockfishResp := UCIPost("fen rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", 500)
|
||
// logger.Logger.Infof("stockfishResp %v", stockfishResp)
|
||
// return nil
|
||
//}), nil, "UCIPost_Action").Start()
|
||
}
|