774 lines
21 KiB
Go
774 lines
21 KiB
Go
package battle
|
|
|
|
import (
|
|
"context"
|
|
"go_dreamfactory/comm"
|
|
"go_dreamfactory/lego/base"
|
|
"go_dreamfactory/lego/core"
|
|
"go_dreamfactory/lego/sys/log"
|
|
"go_dreamfactory/modules"
|
|
"go_dreamfactory/pb"
|
|
cfg "go_dreamfactory/sys/configure/structs"
|
|
"go_dreamfactory/sys/db"
|
|
"time"
|
|
)
|
|
|
|
/*
|
|
模块名:战斗模块
|
|
描述:处理游侠战斗相关业务
|
|
开发:李伟
|
|
*/
|
|
func NewModule() core.IModule {
|
|
m := new(Battle)
|
|
return m
|
|
}
|
|
|
|
type Battle struct {
|
|
modules.ModuleBase
|
|
service base.IRPCXService
|
|
options *Options
|
|
friend comm.IFriend //好友系统
|
|
moonfantasy comm.IMoonFantasy //月之秘境模块
|
|
pvp comm.IPvp //实时pvp
|
|
api_comp *apiComp
|
|
configure *configureComp
|
|
modelBattle *modelBattleComp
|
|
clientmgr *battleClientMgrComp //c#战斗客户端端管理
|
|
}
|
|
|
|
// 模块名
|
|
func (this *Battle) GetType() core.M_Modules {
|
|
return comm.ModuleBattle
|
|
}
|
|
|
|
func (this *Battle) NewOptions() (options core.IModuleOptions) {
|
|
return new(Options)
|
|
}
|
|
|
|
// 模块初始化接口 注册用户创建角色事件
|
|
func (this *Battle) Init(service core.IService, module core.IModule, options core.IModuleOptions) (err error) {
|
|
if err = this.ModuleBase.Init(service, module, options); err != nil {
|
|
return
|
|
}
|
|
this.service = service.(base.IRPCXService)
|
|
this.options = options.(*Options)
|
|
return
|
|
}
|
|
func (this *Battle) Start() (err error) {
|
|
if err = this.ModuleBase.Start(); err != nil {
|
|
return
|
|
}
|
|
var module core.IModule
|
|
if module, err = this.service.GetModule(comm.ModuleFriend); err != nil {
|
|
return
|
|
}
|
|
this.friend = module.(comm.IFriend)
|
|
if module, err = this.service.GetModule(comm.ModuleMoonfantasy); err != nil {
|
|
return
|
|
}
|
|
this.moonfantasy = module.(comm.IMoonFantasy)
|
|
if module, err = this.service.GetModule(comm.ModulePvp); err != nil {
|
|
return
|
|
}
|
|
this.pvp = module.(comm.IPvp)
|
|
return
|
|
}
|
|
|
|
// 装备组件
|
|
func (this *Battle) OnInstallComp() {
|
|
this.ModuleBase.OnInstallComp()
|
|
this.api_comp = this.RegisterComp(new(apiComp)).(*apiComp)
|
|
this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
|
|
this.modelBattle = this.RegisterComp(new(modelBattleComp)).(*modelBattleComp)
|
|
this.clientmgr = this.RegisterComp(new(battleClientMgrComp)).(*battleClientMgrComp)
|
|
}
|
|
|
|
// 创建pve战斗
|
|
func (this *Battle) CreateEveBattle(session comm.IUserSession, req *pb.BattleEVEReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
|
|
var (
|
|
conf *cfg.GameBattleReadyData
|
|
conn *db.DBConn
|
|
stag string
|
|
err error
|
|
)
|
|
if !this.IsCross() {
|
|
conn, err = db.Local()
|
|
stag = this.service.GetTag()
|
|
} else {
|
|
conn, err = db.ServerDBConn(session.GetServiecTag())
|
|
stag = session.GetServiecTag()
|
|
}
|
|
if err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
this.Errorf("session:%v err:", session, err)
|
|
return
|
|
}
|
|
|
|
if conf, err = this.configure.GetBattleReady(req.Rulesid); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
|
|
if record, errdata = this.modelBattle.createeve(session, stag, conn, pb.BattleType_eve, req, conf); errdata != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// 创建pve战斗
|
|
func (this *Battle) CreatePveBattle(session comm.IUserSession, req *pb.BattlePVEReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
|
|
var (
|
|
conf *cfg.GameBattleReadyData
|
|
conn *db.DBConn
|
|
stag string
|
|
err error
|
|
tasks []*pb.BuriedParam
|
|
)
|
|
if !this.IsCross() {
|
|
conn, err = db.Local()
|
|
stag = this.service.GetTag()
|
|
} else {
|
|
conn, err = db.ServerDBConn(session.GetServiecTag())
|
|
stag = session.GetServiecTag()
|
|
}
|
|
if err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
this.Errorf("session:%v err:", session, err)
|
|
return
|
|
}
|
|
if conf, err = this.configure.GetBattleReady(req.Rulesid); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
if req.Format == nil || req.Format.Format == nil || len(req.Format.Format) != 5 {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ReqParameterError,
|
|
Title: pb.ErrorCode_ReqParameterError.ToString(),
|
|
Message: "Format data err!",
|
|
}
|
|
return
|
|
}
|
|
if req.Format.Friendformat != nil && len(req.Format.Friendformat) != 5 {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ReqParameterError,
|
|
Title: pb.ErrorCode_ReqParameterError.ToString(),
|
|
}
|
|
}
|
|
var flag bool
|
|
for _, v := range req.Format.Friendformat {
|
|
if v != "" {
|
|
flag = true
|
|
tasks = append(tasks, comm.GetBuriedParam(comm.Rtype108, 1))
|
|
break
|
|
}
|
|
}
|
|
|
|
if record, errdata = this.modelBattle.createpve(session, stag, conn, pb.BattleType_pve, req, conf); errdata != nil {
|
|
return
|
|
}
|
|
if flag {
|
|
tasks = append(tasks, comm.GetBuriedParam(comm.Rtype12, 1))
|
|
|
|
}
|
|
if len(tasks) > 0 {
|
|
go this.AsynHandleSession(session.Clone(), func(session comm.IUserSession) {
|
|
this.ModuleBuried.TriggerBuried(session, tasks...)
|
|
})
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建连续战斗
|
|
func (this *Battle) CreateHeroPveBattle(session comm.IUserSession, req *pb.BattleHeroPVEReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
|
|
var (
|
|
conf *cfg.GameBattleReadyData
|
|
conn *db.DBConn
|
|
|
|
err error
|
|
)
|
|
if !this.IsCross() {
|
|
conn, err = db.Local()
|
|
} else {
|
|
conn, err = db.ServerDBConn(session.GetServiecTag())
|
|
}
|
|
if err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
this.Errorf("session:%v err:", session, err)
|
|
return
|
|
}
|
|
if req.Redformat == nil || req.Redformat.Format == nil || len(req.Redformat.Format) != 5 {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ReqParameterError,
|
|
Title: pb.ErrorCode_ReqParameterError.ToString(),
|
|
}
|
|
return
|
|
}
|
|
|
|
if conf, err = this.configure.GetBattleReady(req.Rulesid); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
if record, errdata = this.modelBattle.createheropve(session, conn, pb.BattleType_lpev, req, conf); errdata != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建pve战斗
|
|
func (this *Battle) CreatePvbBattle(session comm.IUserSession, req *pb.BattlePVBReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
|
|
var (
|
|
conf *cfg.GameBattleReadyData
|
|
conn *db.DBConn
|
|
stag string
|
|
err error
|
|
)
|
|
if !this.IsCross() {
|
|
conn, err = db.Local()
|
|
stag = this.service.GetTag()
|
|
} else {
|
|
conn, err = db.ServerDBConn(session.GetServiecTag())
|
|
stag = session.GetServiecTag()
|
|
}
|
|
if err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
this.Errorf("session:%v err:", session, err)
|
|
return
|
|
}
|
|
if req.Format == nil || len(req.Format) == 0 {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ReqParameterError,
|
|
Title: pb.ErrorCode_ReqParameterError.ToString(),
|
|
}
|
|
return
|
|
}
|
|
if conf, err = this.configure.GetBattleReady(req.Rulesid); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
if record, errdata = this.modelBattle.createpvb(session, stag, conn, pb.BattleType_pvb, req, conf); errdata != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// 创建pve战斗
|
|
func (this *Battle) CreatePvpBattle(session comm.IUserSession, req *pb.BattlePVPReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
|
|
var (
|
|
conf *cfg.GameBattleReadyData
|
|
conn *db.DBConn
|
|
err error
|
|
)
|
|
if !this.IsCross() {
|
|
conn, err = db.Local()
|
|
} else {
|
|
conn, err = db.ServerDBConn(session.GetServiecTag())
|
|
}
|
|
if err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
this.Errorf("session:%v err:", session, err)
|
|
return
|
|
}
|
|
if conf, err = this.configure.GetBattleReady(req.Rulesid); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
if record, errdata = this.modelBattle.createpvp(session, conn, pb.BattleType_pvp, req, conf); errdata != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// 只有跨服环境下才可使用
|
|
func (this *Battle) CreateRtPvpBattle(req *pb.BattleRTPVPReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
|
|
var (
|
|
conf *cfg.GameBattleReadyData
|
|
redmodel *db.DBModel
|
|
bluemodel *db.DBModel
|
|
err error
|
|
)
|
|
if !this.IsCross() {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_Exception,
|
|
Title: pb.ErrorCode_Exception.ToString(),
|
|
}
|
|
return
|
|
}
|
|
if redmodel, err = this.GetDBModelByUid(req.RedCompId, comm.TableHero); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
if bluemodel, err = this.GetDBModelByUid(req.BlueCompId, comm.TableHero); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
if conf, err = this.configure.GetBattleReady(req.Rulesid); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
if record, errdata = this.modelBattle.creatertpvp(redmodel, bluemodel, pb.BattleType_rtpvp, req, conf); errdata != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// 创建连续战斗
|
|
func (this *Battle) CreateLPVEBattle(session comm.IUserSession, req *pb.BattleLPVEReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
|
|
var (
|
|
conf *cfg.GameBattleReadyData
|
|
conn *db.DBConn
|
|
stag string
|
|
err error
|
|
tasks []*pb.BuriedParam
|
|
)
|
|
if !this.IsCross() {
|
|
conn, err = db.Local()
|
|
stag = this.service.GetTag()
|
|
} else {
|
|
conn, err = db.ServerDBConn(session.GetServiecTag())
|
|
stag = session.GetServiecTag()
|
|
}
|
|
if err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
this.Errorf("session:%v err:", session, err)
|
|
return
|
|
}
|
|
if req.Format == nil || req.Format.Format == nil || len(req.Format.Format) != 5 {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ReqParameterError,
|
|
Title: pb.ErrorCode_ReqParameterError.ToString(),
|
|
}
|
|
return
|
|
}
|
|
if req.Format.Friendformat != nil && len(req.Format.Friendformat) != 5 {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ReqParameterError,
|
|
Title: pb.ErrorCode_ReqParameterError.ToString(),
|
|
}
|
|
}
|
|
var flag bool
|
|
for _, v := range req.Format.Friendformat {
|
|
if v != "" {
|
|
flag = true
|
|
// this.ModuleBuried.SendToRtask(session, comm.Rtype108, 1)
|
|
tasks = append(tasks, comm.GetBuriedParam(comm.Rtype108, 1))
|
|
break
|
|
}
|
|
}
|
|
if conf, err = this.configure.GetBattleReady(req.Rulesid); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
if record, errdata = this.modelBattle.createlpve(session, stag, conn, pb.BattleType_lpev, req, conf); errdata != nil {
|
|
return
|
|
}
|
|
if flag {
|
|
tasks = append(tasks, comm.GetBuriedParam(comm.Rtype12, 1))
|
|
|
|
}
|
|
|
|
if len(tasks) > 0 {
|
|
go this.AsynHandleSession(session.Clone(), func(session comm.IUserSession) {
|
|
this.ModuleBuried.TriggerBuried(session, tasks...)
|
|
})
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// /创建角色列表 更具Format表格
|
|
func (this *Battle) CreateRolesByFormat(fid int32) (captain int32, roles []*pb.BattleRole, errdata *pb.ErrorData) {
|
|
captain, roles, errdata = this.modelBattle.createMasterRoles(2, 0, fid)
|
|
return
|
|
}
|
|
|
|
// /创建角色列表 更具英雄列表
|
|
func (this *Battle) CreateRolesByHeros(heros []*pb.DBHero) (roles []*pb.BattleRole, errdata *pb.ErrorData) {
|
|
roles = make([]*pb.BattleRole, len(heros))
|
|
for i, v := range heros {
|
|
if v != nil {
|
|
if roles[i], errdata = this.modelBattle.createBattleRole(v, 0, 200+i, i+1); errdata != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// /获取战斗详情
|
|
func (this *Battle) GetBattleInfo(req *pb.BattleGetInfoReq) (errdata *pb.ErrorData, resp *pb.BattleGetInfoResp) {
|
|
this.Debug("GetBattleInfo", log.Field{Key: "req", Value: req})
|
|
var (
|
|
ctx context.Context
|
|
err error
|
|
)
|
|
ctx, _ = context.WithTimeout(context.Background(), time.Second*5)
|
|
if resp, err = this.clientmgr.GetInfo(ctx, req); err != nil {
|
|
this.Errorln(err)
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_RpcFuncExecutionError,
|
|
Title: pb.ErrorCode_RpcFuncExecutionError.ToString(),
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// 创建战斗服务
|
|
func (this *Battle) CreateBattleServer(req *pb.BattleInfo) (errdata *pb.ErrorData) {
|
|
this.Debug("CreateBattleServer", log.Field{Key: "req", Value: req})
|
|
var (
|
|
resp *pb.BattleCreateServerResp
|
|
ctx context.Context
|
|
err error
|
|
)
|
|
ctx, _ = context.WithTimeout(context.Background(), time.Second*5)
|
|
if resp, err = this.clientmgr.CreateBattle(ctx, &pb.BattleCreateServerReq{Info: req}); err != nil {
|
|
this.Errorln(err)
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_RpcFuncExecutionError,
|
|
Title: pb.ErrorCode_RpcFuncExecutionError.ToString(),
|
|
}
|
|
}
|
|
if !resp.Issucc {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_BattleCreateFailed,
|
|
Title: pb.ErrorCode_BattleCreateFailed.ToString(),
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (this *Battle) InCmdBattle(req *pb.BattleInCmdReq) (errdata *pb.ErrorData) {
|
|
var (
|
|
resp *pb.BattleInCmdResp
|
|
ctx context.Context
|
|
err error
|
|
)
|
|
ctx, _ = context.WithTimeout(context.Background(), time.Second*5)
|
|
if resp, err = this.clientmgr.InCmdBattle(ctx, req); err != nil {
|
|
this.Errorln(err)
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_RpcFuncExecutionError,
|
|
Title: pb.ErrorCode_RpcFuncExecutionError.ToString(),
|
|
}
|
|
}
|
|
if !resp.Issucc {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_BattleInCmdFailed,
|
|
Title: pb.ErrorCode_BattleInCmdFailed.ToString(),
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// pvp认输
|
|
func (this *Battle) ConcedeBattle(req *pb.BattleConcedeReq) (errdata *pb.ErrorData) {
|
|
var (
|
|
resp *pb.BattleConcedeResp
|
|
err error
|
|
)
|
|
if resp, err = this.clientmgr.ConcedeBattle(context.Background(), req); err != nil {
|
|
this.Errorln(err)
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_RpcFuncExecutionError,
|
|
Title: pb.ErrorCode_RpcFuncExecutionError.ToString(),
|
|
}
|
|
}
|
|
if !resp.Issucc {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_BattleInCmdFailed,
|
|
Title: pb.ErrorCode_BattleInCmdFailed.ToString(),
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// 校验战报是否成功
|
|
func (this *Battle) CheckBattleReport(session comm.IUserSession, report *pb.BattleReport) (errdata *pb.ErrorData, iswin bool) {
|
|
var (
|
|
reply *pb.BattleCheckResults
|
|
ctx context.Context
|
|
err error
|
|
tasks []*pb.BuriedParam
|
|
)
|
|
if report == nil {
|
|
iswin = false
|
|
return
|
|
}
|
|
|
|
if this.options.OpenCheck {
|
|
stime := time.Now()
|
|
ctx, _ = context.WithTimeout(context.Background(), time.Second*5)
|
|
if reply, err = this.clientmgr.CheckBattle(ctx, report); err != nil || !reply.Ischeck {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_BattleValidationFailed,
|
|
Title: pb.ErrorCode_BattleValidationFailed.ToString(),
|
|
}
|
|
this.Error("[Battle Check]",
|
|
log.Field{Key: "t", Value: time.Since(stime).Milliseconds()},
|
|
log.Field{Key: "reply", Value: reply.String()},
|
|
log.Field{Key: "err", Value: err.Error()},
|
|
)
|
|
return
|
|
}
|
|
this.Debug("[Battle Check]",
|
|
log.Field{Key: "t", Value: time.Since(stime).Milliseconds()},
|
|
log.Field{Key: "reply", Value: reply.String()},
|
|
)
|
|
}
|
|
this.moonfantasy.Trigger(session, report)
|
|
for _, v := range report.Completetask {
|
|
tasks = append(tasks, comm.GetBuriedParam(comm.Rtype157, int32(report.Info.Ptype), v))
|
|
}
|
|
|
|
if len(tasks) > 0 {
|
|
go this.AsynHandleSession(session.Clone(), func(session comm.IUserSession) {
|
|
this.ModuleBuried.TriggerBuried(session, tasks...)
|
|
})
|
|
}
|
|
|
|
if (report.WinSide == 1 && report.Info.RedCompId == session.GetUserId()) || (report.WinSide == 2 && report.Info.BlueCompId == session.GetUserId()) {
|
|
return nil, true
|
|
} else {
|
|
return nil, false
|
|
}
|
|
}
|
|
|
|
// 校验战报是否成功
|
|
func (this *Battle) CheckBattleReportByTest(report *pb.BattleReport) (err error) {
|
|
var (
|
|
reply *pb.BattleCheckResults
|
|
ctx context.Context
|
|
)
|
|
|
|
if this.options.OpenCheck {
|
|
stime := time.Now()
|
|
ctx, _ = context.WithTimeout(context.Background(), time.Second*5)
|
|
if reply, err = this.clientmgr.CheckBattle(ctx, report); err != nil || !reply.Ischeck {
|
|
return
|
|
}
|
|
this.Debug("[Battle Check]",
|
|
log.Field{Key: "t", Value: time.Since(stime).Milliseconds()},
|
|
log.Field{Key: "reply", Value: reply.String()},
|
|
)
|
|
}
|
|
return
|
|
}
|
|
|
|
// 创建石阵秘境战斗
|
|
func (this *Battle) CreateStoneBattle(session comm.IUserSession, stoneBattle *pb.StroneBattleReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
|
|
|
|
if record, errdata = this.modelBattle.creatStoneBattle(session, stoneBattle); errdata != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建pve战斗
|
|
func (this *Battle) CreateDebuffBattle(session comm.IUserSession, req *pb.BattlePVEReq, webuff []int32, dibuff []int32) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
|
|
var (
|
|
conf *cfg.GameBattleReadyData
|
|
conn *db.DBConn
|
|
stag string
|
|
err error
|
|
tasks []*pb.BuriedParam
|
|
)
|
|
if !this.IsCross() {
|
|
conn, err = db.Local()
|
|
stag = this.service.GetTag()
|
|
} else {
|
|
conn, err = db.ServerDBConn(session.GetServiecTag())
|
|
stag = session.GetServiecTag()
|
|
}
|
|
if err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
this.Errorf("session:%v err:", session, err)
|
|
return
|
|
}
|
|
if conf, err = this.configure.GetBattleReady(req.Rulesid); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
if req.Format == nil || req.Format.Format == nil || len(req.Format.Format) != 5 {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ReqParameterError,
|
|
Title: pb.ErrorCode_ReqParameterError.ToString(),
|
|
Message: "Format data err!",
|
|
}
|
|
return
|
|
}
|
|
if req.Format.Friendformat != nil && len(req.Format.Friendformat) != 5 {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ReqParameterError,
|
|
Title: pb.ErrorCode_ReqParameterError.ToString(),
|
|
}
|
|
}
|
|
var flag bool
|
|
for _, v := range req.Format.Friendformat {
|
|
if v != "" {
|
|
flag = true
|
|
tasks = append(tasks, comm.GetBuriedParam(comm.Rtype108, 1))
|
|
break
|
|
}
|
|
}
|
|
|
|
if record, errdata = this.modelBattle.createAddDebuffPve(session, stag, conn, pb.BattleType_pve, req, conf, webuff, dibuff); errdata != nil {
|
|
return
|
|
}
|
|
if flag {
|
|
tasks = append(tasks, comm.GetBuriedParam(comm.Rtype12, 1))
|
|
|
|
}
|
|
if len(tasks) > 0 {
|
|
go this.AsynHandleSession(session.Clone(), func(session comm.IUserSession) {
|
|
this.ModuleBuried.TriggerBuried(session, tasks...)
|
|
})
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 炮服务端战斗
|
|
func (this *Battle) RunServerBattle(session comm.IUserSession, req *pb.BattleRunReq) (errdata *pb.ErrorData, reply *pb.BattleRunResp) {
|
|
var (
|
|
ctx context.Context
|
|
err error
|
|
)
|
|
if this.options.OpenCheck {
|
|
stime := time.Now()
|
|
ctx, _ = context.WithTimeout(context.Background(), time.Second*5)
|
|
if reply, err = this.clientmgr.RunBattle(ctx, req); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_BattleValidationFailed,
|
|
Title: pb.ErrorCode_BattleValidationFailed.ToString(),
|
|
}
|
|
this.Error("[Battle Run]",
|
|
log.Field{Key: "t", Value: time.Since(stime).Milliseconds()},
|
|
log.Field{Key: "reply", Value: reply.String()},
|
|
log.Field{Key: "err", Value: err.Error()},
|
|
)
|
|
return
|
|
}
|
|
this.Debug("[Battle Check]",
|
|
log.Field{Key: "t", Value: time.Since(stime).Milliseconds()},
|
|
log.Field{Key: "reply", Value: reply.String()},
|
|
)
|
|
} else {
|
|
reply = &pb.BattleRunResp{
|
|
Reports: make([]*pb.BattleReport, 0),
|
|
}
|
|
for _, v := range req.Info {
|
|
reply.Reports = append(reply.Reports, &pb.BattleReport{
|
|
Info: v,
|
|
Costtime: 10,
|
|
WinSide: 1,
|
|
Round: 10,
|
|
})
|
|
}
|
|
}
|
|
return
|
|
}
|
|
func (this *Battle) CreatePlunderPvpBattle(session comm.IUserSession, req *pb.BattlePVEPlunderReq) (errdata *pb.ErrorData, record *pb.DBBattleRecord) {
|
|
var (
|
|
conf *cfg.GameBattleReadyData
|
|
conn *db.DBConn
|
|
err error
|
|
)
|
|
if !this.IsCross() {
|
|
conn, err = db.Local()
|
|
} else {
|
|
conn, err = db.ServerDBConn(session.GetServiecTag())
|
|
}
|
|
if err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
this.Errorf("session:%v err:", session, err)
|
|
return
|
|
}
|
|
if conf, err = this.configure.GetBattleReady(req.Rulesid); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
if record, errdata = this.modelBattle.createPlunderpvp(session, conn, pb.BattleType_pvp, req, conf); errdata != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|