344 lines
9.0 KiB
Go
344 lines
9.0 KiB
Go
package robot
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"go_dreamfactory/comm"
|
|
"go_dreamfactory/pb"
|
|
"go_dreamfactory/sys/configure"
|
|
cfg "go_dreamfactory/sys/configure/structs"
|
|
"sort"
|
|
|
|
"google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
//用户模块 机器人
|
|
type ModuleRobot_Hero struct {
|
|
heros map[string]*pb.DBHero
|
|
talent []*pb.DBHeroTalent // 天赋数据
|
|
}
|
|
|
|
func (this *ModuleRobot_Hero) Init() (err error) {
|
|
this.heros = make(map[string]*pb.DBHero)
|
|
return
|
|
}
|
|
|
|
//接收到消息
|
|
func (this *ModuleRobot_Hero) Receive(robot IRobot, stype string, message proto.Message) (err error) {
|
|
switch stype {
|
|
case "list":
|
|
resp := message.(*pb.HeroListResp)
|
|
for _, v := range resp.List {
|
|
this.heros[v.Id] = v
|
|
}
|
|
break
|
|
case "change":
|
|
resp := message.(*pb.HeroChangePush)
|
|
for _, v := range resp.List {
|
|
this.heros[v.Id] = v
|
|
}
|
|
break
|
|
case "talentlist": // 获取天赋数据
|
|
resp := message.(*pb.HeroTalentListResp)
|
|
this.talent = resp.Telnet
|
|
break
|
|
}
|
|
return
|
|
}
|
|
|
|
func (this *ModuleRobot_Hero) OncePipeline(robot IRobot) (err error) {
|
|
var (
|
|
errdata *pb.ErrorData
|
|
)
|
|
if _, errdata = robot.SendMessage("hero", "list", &pb.HeroListReq{}); errdata != nil {
|
|
err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
|
|
return
|
|
}
|
|
if _, errdata = robot.SendMessage("hero", "talentlist", &pb.HeroTalentListReq{}); errdata != nil {
|
|
err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
//机器人执行流
|
|
func (this *ModuleRobot_Hero) DoPipeline(robot IRobot) (err error) {
|
|
if _, errdata := robot.SendMessage("hero", "drawcard", &pb.HeroDrawCardReq{DrawType: 2, DrawCount: 10, Consume: 1}); errdata != nil {
|
|
err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
//做任务
|
|
func (this *ModuleRobot_Hero) DoTask(robot IRobot, taskconf *cfg.GameWorldTaskData, condconf *cfg.GameBuriedCondiData) (err error) {
|
|
var (
|
|
errdata *pb.ErrorData
|
|
)
|
|
switch comm.TaskType(condconf.Type) {
|
|
case comm.Rtype14:
|
|
if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "drawcard", &pb.HeroDrawCardReq{DrawType: 2, DrawCount: 1, Consume: 0}); errdata != nil {
|
|
err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
|
|
return
|
|
}
|
|
|
|
case comm.Rtype199, comm.Rtype39, comm.Rtype40:
|
|
req := &pb.HeroTalentLearnReq{
|
|
TalentID: 0,
|
|
ObjId: "",
|
|
Heroid: "",
|
|
}
|
|
// check 该英雄天赋满级
|
|
bMax := false
|
|
// 获取英雄数据
|
|
for _, v := range this.heros {
|
|
if c, err := this.GMGetTalentByHeroId(v.HeroID); err == nil {
|
|
if this.talent == nil {
|
|
req.TalentID = c[0].Skillid
|
|
req.Heroid = v.HeroID
|
|
} else {
|
|
for _, v1 := range this.talent {
|
|
if len(v1.Talent) == len(c) {
|
|
bMax = true
|
|
break
|
|
}
|
|
if v1.HeroId == v.HeroID {
|
|
req.ObjId = v1.Id
|
|
req.Heroid = v.HeroID
|
|
// 依次往后学
|
|
if len(v1.Talent) < len(c) {
|
|
req.TalentID = c[len(v1.Talent)].Skillid
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if !bMax { // 当前英雄全满共鸣后 继续找下一个英雄
|
|
continue
|
|
}
|
|
break
|
|
}
|
|
|
|
if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "talentlearn", req); errdata != nil {
|
|
err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
|
|
return
|
|
}
|
|
case comm.Rtype6: // 升星
|
|
req := &pb.HeroStrengthenUpStarReq{}
|
|
for _, v := range this.heros {
|
|
req.HeroObjID = v.Id
|
|
break
|
|
}
|
|
|
|
if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "strengthenupstar", req); errdata != nil {
|
|
err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
|
|
return
|
|
}
|
|
case comm.Rtype24: // 升级
|
|
var (
|
|
itemmodule *ModuleRobot_Item
|
|
items map[string]*pb.DB_UserItemData
|
|
use map[string]int32
|
|
heroMaxLv int32 // 当前英雄最大等级
|
|
)
|
|
use = make(map[string]int32)
|
|
req := &pb.HeroStrengthenUplvReq{
|
|
HeroObjID: "",
|
|
Item: map[string]int32{},
|
|
}
|
|
// 取任务等级
|
|
usermodule := robot.GetModule(comm.ModuleUser).(*ModuleRobot_User)
|
|
|
|
if c := this.GetPlayerlvConf(usermodule.user.Lv); c != nil {
|
|
heroMaxLv = c.HeroLv
|
|
}
|
|
// 找最大等级的英雄
|
|
for _, v := range this.heros {
|
|
if v.Lv > 1 && v.Lv < heroMaxLv {
|
|
req.HeroObjID = v.Id
|
|
}
|
|
break
|
|
}
|
|
if req.HeroObjID == "" { // 随机找一个1级的英雄进行升级
|
|
for _, v := range this.heros {
|
|
if v.Lv == 1 {
|
|
req.HeroObjID = v.Id
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
itemmodule = robot.GetModule(comm.ModuleItems).(*ModuleRobot_Item)
|
|
items = itemmodule.items
|
|
if _, ok := items["10000008"]; ok {
|
|
use["10000008"] = 1
|
|
}
|
|
if _, ok := items["10000009"]; ok && len(use) == 0 {
|
|
use["10000009"] = 1
|
|
}
|
|
if _, ok := items["10000010"]; ok && len(use) == 0 {
|
|
use["10000010"] = 1
|
|
}
|
|
if len(use) > 0 {
|
|
req.Item = use
|
|
}
|
|
if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "strengthenuplv", req); errdata != nil {
|
|
err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
|
|
return
|
|
}
|
|
case comm.Rtype25: // 升星
|
|
req := &pb.HeroStrengthenUpStarReq{}
|
|
for _, v := range this.heros {
|
|
if v.HeroID == string(condconf.Filter[0]) { // 找到指定英雄ID
|
|
req.HeroObjID = v.Id
|
|
}
|
|
break
|
|
}
|
|
|
|
if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "strengthenupstar", req); errdata != nil {
|
|
err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
|
|
return
|
|
}
|
|
case comm.Rtype34: // 觉醒
|
|
|
|
req := &pb.HeroAwakenReq{}
|
|
for _, v := range this.heros {
|
|
if int(v.JuexingLv) > 1 && int(v.JuexingLv) < len(this.GetHeroAwalenConf(v.HeroID)) { // 优先找觉醒大于1 并且没有满觉醒的英雄
|
|
req.HeroObjID = v.Id
|
|
break
|
|
}
|
|
if len(this.GetHeroAwalenConf(v.HeroID)) == int(v.JuexingLv) { // 满觉醒了就找下一个
|
|
continue
|
|
}
|
|
|
|
req.HeroObjID = v.Id
|
|
break
|
|
}
|
|
if req.HeroObjID == "" {
|
|
err = errors.New(fmt.Sprintf("code:%d message:not found hero", errdata.Code))
|
|
return
|
|
}
|
|
if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "awaken", req); errdata != nil {
|
|
err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
|
|
return
|
|
}
|
|
case comm.Rtype33:
|
|
req := &pb.HeroAwakenReq{}
|
|
for _, v := range this.heros {
|
|
data, _ := this.GMGetTalentByHeroId(v.HeroID)
|
|
if int(v.JuexingLv) > 1 && 0 < len(data) {
|
|
req.HeroObjID = v.Id
|
|
break
|
|
}
|
|
if this.GetHeroTalentMaxLv(v.HeroID) > 10 {
|
|
continue
|
|
}
|
|
|
|
req.HeroObjID = v.Id
|
|
break
|
|
}
|
|
if req.HeroObjID == "" {
|
|
err = errors.New(fmt.Sprintf("code:%d message:not found hero", errdata.Code))
|
|
return
|
|
}
|
|
if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "awaken", req); errdata != nil {
|
|
err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//获取战斗英雄
|
|
func (this *ModuleRobot_Hero) getbattlehero() (bheros []string) {
|
|
var (
|
|
heros []*pb.DBHero = make([]*pb.DBHero, 0, len(this.heros))
|
|
)
|
|
bheros = make([]string, 5)
|
|
for _, v := range this.heros {
|
|
heros = append(heros, v)
|
|
}
|
|
// 使用sort.Slice进行排序
|
|
sort.Slice(heros, func(i, j int) bool {
|
|
return heros[i].Lv > heros[j].Lv
|
|
})
|
|
|
|
for i, v := range heros {
|
|
if i < 5 {
|
|
bheros[i] = v.Id
|
|
} else {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//获取武官训练英雄英雄
|
|
func (this *ModuleRobot_Hero) getpracticehero() (bheros string) {
|
|
for _, v := range this.heros {
|
|
if v.Status != pb.HeroType_HeroTypeKongFu {
|
|
return v.Id
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (this *ModuleRobot_Hero) GMGetTalentByHeroId(hid string) (data []*cfg.GameHeroTalentData, err error) {
|
|
var (
|
|
v interface{}
|
|
)
|
|
if v, err = configure.GetConfigure(hero_talent); err == nil {
|
|
if configure, ok := v.(*cfg.GameHeroTalent); ok {
|
|
for _, v1 := range configure.GetDataList() {
|
|
if v1.Hid == hid {
|
|
data = append(data, v1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if len(data) == 0 {
|
|
err = comm.NewNotFoundConfErr("robot", hero_talent, hid)
|
|
}
|
|
return
|
|
}
|
|
|
|
// 玩家等级经验配置表
|
|
func (this *ModuleRobot_Hero) GetPlayerlvConf(lv int32) (data *cfg.GamePlayerlvData) {
|
|
if v, err := configure.GetConfigure(game_playerlv); err != nil {
|
|
return
|
|
} else {
|
|
if configure, ok := v.(*cfg.GamePlayerlv); !ok {
|
|
err = fmt.Errorf("%T no is *cfg.Game_playerlv", v)
|
|
return
|
|
} else {
|
|
if configure != nil {
|
|
data = configure.GetDataMap()[lv]
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
func (this *ModuleRobot_Hero) GetHeroAwalenConf(hid string) (data []*cfg.GameHeroAwakenData) {
|
|
data = make([]*cfg.GameHeroAwakenData, 0)
|
|
if v, err := configure.GetConfigure(hero_awaken); err == nil {
|
|
if _configure, ok := v.(*cfg.GameHeroAwaken); ok {
|
|
for _, v := range _configure.GetDataList() {
|
|
if v.Hid == hid {
|
|
data = append(data, v)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
func (this *ModuleRobot_Hero) GetHeroTalentMaxLv(heroid string) (maxlv int32) {
|
|
if v, err := configure.GetConfigure(hero_talentbox); err == nil {
|
|
if configure, ok := v.(*cfg.GameTalentBox); ok {
|
|
return int32(len(configure.GetDataList()))
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|