cmd/gameserver/action/RoleAction.go

// 游戏服角色相关操作
package action
import (
	"fmt"
	"github.com/golang/protobuf/proto"
	"go.mongodb.org/mongo-driver/bson"
	"pro2d/common"
	"pro2d/common/components"
	"pro2d/common/db/mongoproxy"
	"pro2d/common/db/redisproxy"
	"pro2d/common/logger"
	"pro2d/csvdata"
	"pro2d/models"
	"pro2d/pb"
)
// HeartRpc 心跳请求
func HeartRpc(role *models.RoleModel, msg components.IMessage) (int32, interface{}) {
	//msg.Conn.SetLastHeartCheckTime()
	return 0, nil
}
// getRandomName 随机名字
func getRandomName() string {
	name := ""
	for {
		name = common.RandomName(common.DefaultName)
		if name == "" {
			continue
		}
		relay, err := redisproxy.SETNX(fmt.Sprintf(common.NickNames, name), "1")
		if err != nil {
			continue
		}
		if relay.(int64) == 1 {
			break
		}
	}
	return name
}
/*
CreateRpc 创建角色请求
 1: proto解析错误
 2: 角色不存在
*/
func CreateRpc(role1 *models.RoleModel, msg components.IMessage) (int32, interface{}) {
	req := pb.CreateReq{}
	if err := proto.Unmarshal(msg.GetData(), &req); err != nil {
		logger.Error("CreateRpc err: %v", err)
		return 1, err
	}
	role := models.RoleExistByUid(req.Token)
	if role != nil {
		return 2, "role exists"
	}
	roleId, err := common.GetNextRoleId()
	if err != nil {
		return 3, err
	}
	role = models.NewRole(roleId)
	role.Role.Uid = req.Token
	role.Role.Level = 1
	role.Role.Nick = getRandomName()
	if err := role.Create(); err != nil {
		logger.Error("CreateRpc role create err: %v", err)
		return 4, nil
	}
	role.InitRole()
	return 0, nil
}
// ChangeTeamRpc 阵容变换
func ChangeTeamRpc(role *models.RoleModel, msg components.IMessage) (int32, interface{}) {
	req := pb.ChangeTeamReq{}
	if err := proto.Unmarshal(msg.GetData(), &req); err != nil {
		logger.Error("loginRpc err: %v", err)
		return 1, nil
	}
	role.UpdateTeam(req.Team)
	return 0, nil
}
/*
HeroEquipReferRpc 穿戴/脱 装备
 2: 装备不存在
*/
func HeroEquipReferRpc(role *models.RoleModel, msg components.IMessage) (int32, interface{}) {
	req := pb.HeroEquipReferReq{}
	if err := proto.Unmarshal(msg.GetData(), &req); err != nil {
		logger.Error("loginRpc err: %v", err)
		return 1, nil
	}
	e, ok := role.Equipments[req.EquipId]
	if !ok {
		return 2, nil
	}
	equip := e.(*models.EquipModel)
	// 1 脱
	// 1.1 装备直接脱掉
	// 2 戴
	// 2.1装备未被其他英雄穿戴直接穿, 如果其他英雄已经被穿戴，则脱了再穿
	// 2.2同类型装备是否穿戴, 已经被穿戴，则脱了再穿
	h1 := role.Heros[req.HeroId]
	h2 := role.Heros[equip.Equip.HeroId]
	var outHero, inHero *models.HeroModel
	inEquip := csvdata.Get().TbEquipmentData.Get(equip.Equip.GetTbId())
	if !req.Refer {
		if h1 != nil {
			outHero = h1.(*models.HeroModel)
			outHero.UpdateEquipment(equip.Equip.Id, 0)
		}
		if h2 != nil {
			outHero = h2.(*models.HeroModel)
			outHero.UpdateEquipment(equip.Equip.Id, 0)
		}
		equip.SetProperty("heroid", "")
	} else {
		if h1 == nil {
			return 3, nil
		}
		inHero = h1.(*models.HeroModel)
		if equip.Equip.HeroId == "" {
			var outEquipID string
			for id, tbId := range inHero.Equipments {
				tmpEquip := csvdata.Get().TbEquipmentData.Get(tbId)
				if tmpEquip.EquipType == inEquip.EquipType {
					outEquipID = id
					break
				}
			}
			if outEquipID != "" {
				tmpEuqip, ok := role.Equipments[outEquipID]
				if ok {
					outEquip := tmpEuqip.(*models.EquipModel)
					outEquip.SetProperty("heroid", "")
					inHero.UpdateEquipment(outEquipID, 0)
				}
			}
			inHero.UpdateEquipment(equip.Equip.Id, inEquip.EquipID)
			equip.SetProperty("heroid", inHero.Hero.Id)
		} else if equip.Equip.HeroId != req.HeroId {
			if h2 == nil {
				return 4, nil
			}
			outHero = h2.(*models.HeroModel)
			var outEquipID string
			for id, tbId := range inHero.Equipments {
				tmpEquip := csvdata.Get().TbEquipmentData.Get(tbId)
				if tmpEquip.EquipType == inEquip.EquipType {
					outEquipID = id
					break
				}
			}
			if outEquipID != "" {
				tmpEquip, ok := role.Equipments[outEquipID]
				if ok {
					outEquip := tmpEquip.(*models.EquipModel)
					outEquip.SetProperty("heroid", "")
					inHero.UpdateEquipment(outEquipID, 0)
				}
			}
			outHero.UpdateEquipment(equip.Equip.Id, 0)
			inHero.UpdateEquipment(equip.Equip.Id, inEquip.EquipType)
			equip.SetProperty("heroid", inHero.Hero.Id)
		}
	}
	return 0, nil
}
/*
RoleClearItemsRpc 删除物品
 2 删除失败
*/
func RoleClearItemsRpc(role *models.RoleModel, msg components.IMessage) (int32, interface{}) {
	req := pb.RoleClearItemsReq{}
	if err := proto.Unmarshal(msg.GetData(), &req); err != nil {
		logger.Error("proto rpc err: %v", err)
		return 1, nil
	}
	bkup := make(common.IMapStringNum)
	for _, item := range req.Items {
		for k, v := range common.StringToMapNum(item) {
			tmp, ok := bkup[k]
			if !ok {
				tmp = 0
			}
			bkup[k] = v + tmp
		}
	}
	if !role.CostItems(bkup) {
		logger.Error("cost err: %s", common.MapNumToString(bkup))
		return 2, nil
	}
	return 0, nil
}
/*
EquipmentDelRpc 删除装备
 2 删除失败
*/
func EquipmentDelRpc(role *models.RoleModel, msg components.IMessage) (int32, interface{}) {
	req := pb.EquipmentDelReq{}
	if err := proto.Unmarshal(msg.GetData(), &req); err != nil {
		logger.Error("loginRpc err: %v", err)
		return 1, nil
	}
	filter := bson.D{{"id", bson.D{{"$in", req.Id}}}}
	if err := mongoproxy.DelMany("equipment", filter); err != nil {
		logger.Error(err.Error())
		return 2, nil
	}
	for _, id := range req.Id {
		delete(role.Equipments, id)
	}
	return 0, nil
}
/*
RoleStartBattleRpc 开始战斗
*/
func RoleStartBattleRpc(role *models.RoleModel, msg components.IMessage) (int32, interface{}) {
	req := pb.RoleStartBattleReq{}
	if err := proto.Unmarshal(msg.GetData(), &req); err != nil {
		logger.Error("loginRpc err: %v", err)
		return 1, nil
	}
	//TODO 消耗体力
	return 0, nil
}
/*
RoleEndBattleRpc 结束战斗
 2 关卡不存在
 RoleEndBattleRsp 返回值
*/
func RoleEndBattleRpc(role *models.RoleModel, msg components.IMessage) (int32, interface{}) {
	req := pb.RoleEndBattleReq{}
	if err := proto.Unmarshal(msg.GetData(), &req); err != nil {
		logger.Error("loginRpc err: %v", err)
		return 1, nil
	}
	chapterInfo := csvdata.Get().TbRogueChapter.Get(req.ChapterId)
	chapterCount, first := role.Role.PassChapters[req.ChapterId]
	carbonInfo, ok := chapterInfo.Carbons[req.CarbonId]
	if !ok {
		logger.Error("carbonInfo not exists")
		return 2, nil
	}
	//team
	team, ok := role.Teams[req.TeamId]
	if !ok {
		logger.Error("team not exists")
		return 3, nil
	}
	reward := make(common.IMapStringNum)
	if !first {
		role.Role.PassChapters[req.ChapterId] = 1
		for k, v := range common.StringToMapNum(carbonInfo.FirstAward) {
			reward[k] = v
		}
	} else {
		role.Role.PassChapters[req.ChapterId] = chapterCount + 1
	}
	for k, v := range common.StringToMapNum(carbonInfo.NormalAward) {
		rv, ok := reward[k]
		if !ok {
			reward[k] = v
		} else {
			reward[k] = rv + v
		}
	}
	//award
	reward = role.Award(reward)
	//exp
	var amount int32
	if req.Pass {
		amount = carbonInfo.CarbonExp
	} else {
		amount = carbonInfo.CarbonFailExp
	}
	level, exp := role.UpLevel(amount)
	role.UpdateProperties(map[string]interface{}{"level": level, "exp": exp}, true)
	//team exp
	heros := make([]*pb.Hero, 4)
	t := team.(*models.TeamModel).Team
	h1, ok := role.Heros[t.HeroId1]
	if ok {
		level, exp := h1.(*models.HeroModel).UpLevel(amount)
		h1.SetProperty("level", level)
		h1.SetProperty("exp", exp)
		heros = append(heros, h1.(*models.HeroModel).Hero)
	}
	h2, ok := role.Heros[t.HeroId2]
	if ok {
		level, exp := h2.(*models.HeroModel).UpLevel(amount)
		h2.SetProperty("level", level)
		h2.SetProperty("exp", exp)
		heros = append(heros, h2.(*models.HeroModel).Hero)
	}
	h3, ok := role.Heros[t.HeroId3]
	if ok {
		level, exp := h3.(*models.HeroModel).UpLevel(amount)
		h3.SetProperty("level", level)
		h3.SetProperty("exp", exp)
		heros = append(heros, h3.(*models.HeroModel).Hero)
	}
	rsp := &pb.RoleEndBattleRsp{
		RoleLevel:     level,
		RoleExp:       exp,
		RoleExpamount: amount,
		Pass:          req.Pass,
		Reward:        common.MapNumToString(reward),
		Hero:          heros,
	}
	return 0, rsp
}