samba/server/truco/cmd/robot_test.go

package cmd

import (
	"fmt"
	"os"
	"os/signal"
	"samba/pkg/log"
	"samba/proto"
	. "samba/server/game/baseroom"
	"samba/server/game/player"
	"samba/server/truco/handler"
	. "samba/server/truco/room"
	. "samba/server/truco/service"
	"samba/stub"
	"samba/util/config"
	"samba/util/model"
	"syscall"
	"testing"
	"time"
)

func initEnv() {
	config.Cmd = config.Command{
		LogLevel: int(log.InfoLevel),
		//ConfigPath: "D:\\work\\samba\\samba\\bin\\config\\truco_dev.xml",
		ConfigPath: "./config/truco.xml",
		LogPath:    "./log/test",
		MinRoomId:  100000,
		MaxRoomId:  120000,
	}
	initLog(&config.Cmd)
	var err = config.Load(config.Cmd.ConfigPath)
	if err != nil {
		log.Error(fmt.Sprintf("load config err: %v", err))
	}
	initRepo()

	handler.InitService()
}

func releaseEnv() {
	c := make(chan os.Signal, 1)
	signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
	sig := <-c
	handler.StopService()
	log.Info(fmt.Sprintf("received %s, initiating shutdown...\n", sig))
}

func copyRobotUserInfo(ui *model.UserInfo) *model.UserInfo {
	return &model.UserInfo{
		UID:         ui.UID,
		UType:       ui.UType,
		API:         ui.API,
		SItemID:     ui.SItemID,
		Device:      ui.Device,
		MNick:       ui.MNick,
		Sex:         ui.Sex,
		HeadURL:     ui.HeadURL,
		IconId:      ui.IconId,
		MTime:       ui.MTime,
		Phone:       ui.Phone,
		Address:     ui.Address,
		MStatus:     ui.MStatus,
		UTMSource:   ui.UTMSource,
		AvatarFrame: ui.AvatarFrame,
		TakeCoin:    0,
	}
}

func TemperVsAnotherTemper(rt1, rt2 stub.RobotTemper) {
	roomType := 0
	var roomCnf *stub.Room
	log.Info(fmt.Sprintf("stub.Rooms size:%v", len(stub.Rooms)))
	for _, cnf := range stub.Rooms {
		if cnf.MinPlayers == 2 {
			roomCnf = cnf
			roomType = cnf.Id
			break
		}
	}
	robot1 := player.RobotMgr.Pop(roomCnf)
	robot2 := player.RobotMgr.Pop(roomCnf)
	log.Info(fmt.Sprintf("测试robot:%v temper:%v vs another:%v temper:%v roomType:%v", robot1.UID, rt1.String(), robot2.UID, rt2.String(), roomType))
	TrucoService.ProcFuncOnce(func() {
		for i := 0; i < 6000; i++ {
			iRm, ok := RoomMgr.CreateRoom(roomType, 0, NewTrucoRoom)
			if ok != proto.Ok {
				log.Error(fmt.Sprintf("err:%v", ok.Error()))
			}
			room := iRm.(*TrucoRoom)
			// 不能共用同一个userinfo，因为userinfo包含了携带金币字段，会造成携带金币混乱
			rob1 := &player.Player{UserInfo: copyRobotUserInfo(robot1.UserInfo), Continue: 0, Robot: nil}
			rob2 := &player.Player{UserInfo: copyRobotUserInfo(robot2.UserInfo), Continue: 0, Robot: nil}
			room.OnEnterRoom(rob1)
			room.OnEnterRoom(rob2)
			room.SetRobotTemper(0, rt1)
			room.SetRobotTemper(1, rt2)
		}
	})

}

func AplombVsNormal() {
	TemperVsAnotherTemper(stub.RteAplomb, stub.RteNormal)
}

func AplombVsRadical() {
	TemperVsAnotherTemper(stub.RteAplomb, stub.RteRadical)
}

func AplombVsEvaluation() {
	TemperVsAnotherTemper(stub.RteAplomb, stub.RteEvaluation)
}

func AplombVsRotten() {
	TemperVsAnotherTemper(stub.RteAplomb, stub.RteRotten)
}

// ------------------------------------------------------------------
func NormalVsRadical() {
	TemperVsAnotherTemper(stub.RteNormal, stub.RteRadical)
}

func NormalVsEvaluation() {
	TemperVsAnotherTemper(stub.RteNormal, stub.RteEvaluation)
}

func NormalVsRotten() {
	TemperVsAnotherTemper(stub.RteNormal, stub.RteRotten)
}

// ------------------------------------------------------------------
func RadicalVsEvaluation() {
	TemperVsAnotherTemper(stub.RteRadical, stub.RteEvaluation)
}

func RadicalVsRotten() {
	TemperVsAnotherTemper(stub.RteRadical, stub.RteRotten)
}

// ------------------------------------------------------------------
func EvaluationVsRotten() {
	TemperVsAnotherTemper(stub.RteEvaluation, stub.RteRotten)
}

func TestRobotWinRate(t *testing.T) {
	initEnv()
	//stub.GGlobal.TrucoWinPoint = 2

	//AplombVsRadical()
	//time.Sleep(time.Minute * 30)

	//AplombVsEvaluation()
	//time.Sleep(time.Minute * 30)

	//AplombVsRotten()
	//time.Sleep(time.Minute * 30)

	//NormalVsRadical()
	//time.Sleep(time.Minute * 30)

	NormalVsEvaluation()
	time.Sleep(time.Minute * 30)

	//NormalVsRotten()
	//time.Sleep(time.Minute * 30)

	//RadicalVsEvaluation()
	//time.Sleep(time.Minute * 30)
	//
	//RadicalVsRotten()
	//time.Sleep(time.Minute * 30)
	//
	//EvaluationVsRotten()
	//time.Sleep(time.Minute * 30)

	releaseEnv()
}