ecs/servers/game/handler/player_role.go

package handler

import (
	"ecs/proto"
	"ecs/proto/pb"
	"ecs/servers/game/logic"
	"github.com/oylshe1314/framework/net"
	"github.com/oylshe1314/framework/util"
	"strings"
)

func (this *PlayerHandler) RoleChangeLanguage(player *logic.Player, msg *net.Message) {
	var req = new(pb.RoleChangeLanguageReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if player.Language != req.Language {
		player.Language = req.Language
		player.SaveField("language", player.Language)
	}

	_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleChangeLanguage), &pb.RoleChangeLanguageAck{Language: player.Language})
	return
}

func (this *PlayerHandler) RoleChangeName(player *logic.Player, msg *net.Message) {
	var req = new(pb.RoleChangeRoleNameReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	var roleName = strings.TrimSpace(req.RoleName)

	if roleName == "" {
		this.logger.Error("Parameter error, req.Name == \"\"")
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	if roleName != player.RoleName {
		//if !this.tables.WordBanExtend.Check(roleName) {
		//	this.logger.Error("Illegal role name, roleName: ", roleName)
		//	_ = player.TipNotice(proto.ErrIllegalRoleName)
		//	return
		//}

		existing, err := this.playerManager.ExistsRoleName(roleName)
		if err != nil {
			this.logger.Error("Check role name exist failed, ", err)
			_ = player.TipNotice(proto.TipServerError)
			return
		}

		if existing {
			this.logger.Error("Role name already exists, roleName: ", roleName)
			_ = player.TipNotice(proto.TipExistedRoleName)
			return
		}

		player.RoleName = roleName
		player.SaveField("role_name", player.RoleName)
	}

	_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleChangeRoleName), &pb.RoleChangeRoleNameAck{RoleName: player.RoleName})
	return
}

func (this *PlayerHandler) RolePropertyChange(player *logic.Player, msg *net.Message) {
	var req = new(pb.RolePropertyChangeReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	switch req.Property.Type {
	case pb.RolePropertyType_AvatarFrame:
		player.AvatarFrame = uint32(req.Property.Value)
	case pb.RolePropertyType_ChatBubble:
		player.ChatBubble = uint32(req.Property.Value)
	case pb.RolePropertyType_NamePrefix:
		player.NamePrefix = uint32(req.Property.Value)
	case pb.RolePropertyType_NameTitle:
		player.NameTitle = uint32(req.Property.Value)
	case pb.RolePropertyType_RoleTitle:
		player.RoleTitle = uint32(req.Property.Value)
	default:
		_ = player.TipNotice(proto.TipParameterError)
	}

	_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRolePropertyChange), &pb.RolePropertyChangeAck{
		PropertyList: []*pb.RoleProperty{req.Property},
	})
	return
}

func (this *PlayerHandler) LineupHeroChange(player *logic.Player, msg *net.Message) {
	var req = new(pb.LineupHeroChangeReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.Index >= 8 {
		this.logger.Error("Parameter error, req.Index: ", req.Index)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	if req.HeroUid == 0 {
		this.logger.Error("Parameter error, req.HeroUid: ", req.HeroUid)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	if !player.CheckFunctionOpen(int(pb.ModId_ModuleRole), 1, int(req.Index)) {
		_ = player.TipNotice(proto.TipFunctionNotUnlocked)
		return
	}

	var hero = player.Hero[req.HeroUid]
	if hero == nil {
		_ = player.TipNotice(proto.TipHeroNotFound)
		return
	}

	var LineupHero = player.LineupHeroes[req.Index]
	if LineupHero == nil {
		LineupHero = &logic.PlayerLineupHero{
			HeroUid: hero.Uid,
		}
		player.LineupHeroes[req.Index] = LineupHero
	} else {
		LineupHero.HeroUid = hero.Uid
	}

	player.SaveArray("lineup_heroes", int(req.Index), LineupHero)

	player.UpdateHeroAttrs(hero)
	//TODO lineup hero capacity

	//_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleLineupHeroChange), &pb.LineupHeroListAck{
	//	HeroList: []*pb.LineupHero{LineupHero.BuildMsgLineupHero(req.Index)},
	//})
}

func (this *PlayerHandler) LineupHeroPosition(player *logic.Player, msg *net.Message) {
	var req = new(pb.LineupHeroPositionReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if len(req.IndexList) != len(req.PositionList) {
		this.logger.Errorf("Read message failed, len(req.IndexList) = %d, len(req.PositionList) = %d", len(req.IndexList), len(req.PositionList))
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	for i := range req.IndexList {
		if req.IndexList[i] >= 6 {
			this.logger.Errorf("Parameter error, req.IndexList[%d]: %d", i, req.IndexList[i])
			_ = player.TipNotice(proto.TipParameterError)
			return
		}
		if req.PositionList[i] > 6 {
			this.logger.Errorf("Parameter error, req.PositionList[%d]: %d", i, req.PositionList[i])
			_ = player.TipNotice(proto.TipParameterError)
			return
		}
	}

	var lineupHeroList []*pb.LineupHero
	for i := range req.IndexList {
		var lineupHero = player.LineupHeroes[req.IndexList[i]]
		if lineupHero != nil {
			if lineupHero.Position != req.PositionList[i] {
				lineupHero.Position = req.PositionList[i]
				player.SaveArray("lineup_heroes", int(req.IndexList[i]), lineupHero)
				lineupHeroList = append(lineupHeroList, lineupHero.BuildMsgLineupHero(req.IndexList[i]))
			}
		}
	}

	if len(lineupHeroList) > 0 {
		//_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleLineupHeroChange), &pb.LineupHeroListAck{HeroList: lineupHeroList})
	}
}

func (this *PlayerHandler) LineupHeroEquip(player *logic.Player, msg *net.Message) {
	var req = new(pb.LineupHeroEquipReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.Index >= 8 {
		this.logger.Error("Parameter error, req.Index: ", req.Index)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	if req.EquipType < pb.EquipType_Weapon || req.EquipType > pb.EquipType_Shoe {
		this.logger.Error("Parameter error, req.EquipType: ", req.EquipType)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	if !player.CheckFunctionOpen(int(pb.ModId_ModuleRole), 1, int(req.Index)) {
		_ = player.TipNotice(proto.TipFunctionNotUnlocked)
		return
	}

	var LineupHero = player.LineupHeroes[req.Index]
	if LineupHero == nil {
		_ = player.TipNotice(proto.TipLineupHeroNotSet)
		return
	}

	var hero = player.Hero[LineupHero.HeroUid]
	if hero == nil {
		_ = player.TipNotice(proto.TipHeroNotFound)
		return
	}

	var equip *logic.PlayerEquip
	if req.EquipUid != 0 {
		equip = player.Equip[req.EquipUid]
		if equip == nil {
			_ = player.TipNotice(proto.TipEquipNotFound)
			return
		}

		var equipTable = this.tables.Equip.Find(int(equip.Id))
		if equipTable == nil {
			_ = player.TipNotice(proto.TipDataTablesError)
			return
		}

		if req.EquipType != pb.EquipType(equipTable.Type) {
			_ = player.TipNotice(proto.TipParameterError)
			return
		}
	}

	var equipIndex = int(req.EquipType)

	var LineupHeroList []*pb.LineupHero
	var equipChangeList []*pb.EquipChange

	if LineupHero.Equip[equipIndex] != 0 {
		var preEquip = player.Equip[LineupHero.Equip[equipIndex]]
		if preEquip != nil && preEquip.HeroUid != 0 {
			preEquip.HeroUid = 0
			player.SaveModel(preEquip)
			equipChangeList = append(equipChangeList, &pb.EquipChange{
				ChangeType: pb.ChangeType_Changed,
				Equip:      preEquip.BuildMsgEquip(),
			})
		}
	}

	LineupHero.Equip[equipIndex] = req.EquipUid
	player.SaveArray("lineup_heroes", int(req.Index), LineupHero)
	LineupHeroList = append(LineupHeroList, LineupHero.BuildMsgLineupHero(req.Index))

	if equip != nil {
		if equip.HeroUid != 0 {
			for i := range player.LineupHeroes {
				if player.LineupHeroes[i].HeroUid == equip.HeroUid {
					var preLineupHero = player.LineupHeroes[i]
					if preLineupHero.Equip[equipIndex] != 0 {
						preLineupHero.Equip[equipIndex] = 0
						player.SaveArray("lineup_heroes", i, preLineupHero)
						LineupHeroList = append(LineupHeroList, preLineupHero.BuildMsgLineupHero(uint32(i)))
					}
				}
			}
		}

		equip.HeroUid = LineupHero.HeroUid
		player.SaveModel(equip)
		equipChangeList = append(equipChangeList, &pb.EquipChange{
			ChangeType: pb.ChangeType_Changed,
			Equip:      equip.BuildMsgEquip(),
		})
	}

	//_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleLineupHeroChange), &pb.LineupHeroListAck{HeroList: LineupHeroList})
	_ = player.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemEquipChange), &pb.EquipChangeListAck{ChangeList: equipChangeList})
	return
}

func (this *PlayerHandler) LineupHeroTreasure(player *logic.Player, msg *net.Message) {
	var req = new(pb.LineupHeroTreasureReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.Index >= 8 {
		this.logger.Error("Parameter error, req.Index: ", req.Index)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	if req.TreasureType < pb.TreasureType_WarBook || req.TreasureType > pb.TreasureType_WarToken {
		this.logger.Error("Parameter error, req.TreasureType: ", req.TreasureType)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	if !player.CheckFunctionOpen(int(pb.ModId_ModuleRole), 1, int(req.Index)) {
		_ = player.TipNotice(proto.TipFunctionNotUnlocked)
		return
	}

	var LineupHero = player.LineupHeroes[req.Index]
	if LineupHero == nil {
		_ = player.TipNotice(proto.TipLineupHeroNotSet)
		return
	}

	var hero = player.Hero[LineupHero.HeroUid]
	if hero == nil {
		_ = player.TipNotice(proto.TipHeroNotFound)
		return
	}

	var treasure *logic.PlayerTreasure
	if req.TreasureUid != 0 {
		treasure = player.Treasure[req.TreasureUid]
		if treasure == nil {
			_ = player.TipNotice(proto.TipTreasureNotFound)
			return
		}

		var treasureTable = this.tables.Treasure.Find(int(treasure.Id))
		if treasureTable == nil {
			_ = player.TipNotice(proto.TipDataTablesError)
			return
		}

		if req.TreasureType != pb.TreasureType(treasureTable.Type) {
			_ = player.TipNotice(proto.TipParameterError)
			return
		}
	}

	var treasureIndex = int(req.TreasureType)

	var LineupHeroList []*pb.LineupHero
	var treasureChangeList []*pb.TreasureChange

	if LineupHero.Treasure[treasureIndex] != 0 {
		var preTreasure = player.Treasure[LineupHero.Treasure[treasureIndex]]
		if preTreasure != nil && preTreasure.HeroUid != 0 {
			preTreasure.HeroUid = 0
			player.SaveModel(preTreasure)
			treasureChangeList = append(treasureChangeList, &pb.TreasureChange{
				ChangeType: pb.ChangeType_Changed,
				Treasure:   preTreasure.BuildMsgTreasure(),
			})
		}
	}

	LineupHero.Treasure[treasureIndex] = req.TreasureUid
	player.SaveArray("lineup_heroes", int(req.Index), LineupHero)
	LineupHeroList = append(LineupHeroList, LineupHero.BuildMsgLineupHero(req.Index))

	if treasure != nil {
		if treasure.HeroUid != 0 {
			for i := range player.LineupHeroes {
				if player.LineupHeroes[i].HeroUid == treasure.HeroUid {
					var preLineupHero = player.LineupHeroes[i]
					if preLineupHero.Treasure[treasureIndex] != 0 {
						preLineupHero.Treasure[treasureIndex] = 0
						player.SaveArray("lineup_heroes", i, preLineupHero)
						LineupHeroList = append(LineupHeroList, preLineupHero.BuildMsgLineupHero(uint32(i)))
					}
				}
			}
		}

		treasure.HeroUid = LineupHero.HeroUid
		player.SaveModel(treasure)
		treasureChangeList = append(treasureChangeList, &pb.TreasureChange{
			ChangeType: pb.ChangeType_Changed,
			Treasure:   treasure.BuildMsgTreasure(),
		})
	}

	//_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleLineupHeroChange), &pb.LineupHeroListAck{HeroList: LineupHeroList})
	_ = player.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemTreasureChange), &pb.TreasureChangeListAck{ChangeList: treasureChangeList})
	return
}

func (this *PlayerHandler) LineupHeroArtifact(player *logic.Player, msg *net.Message) {}

func (this *PlayerHandler) LineupHeroMounts(player *logic.Player, msg *net.Message) {}

func (this *PlayerHandler) LineupHeroGeneral(player *logic.Player, msg *net.Message) {}

func (this *PlayerHandler) LineupHeroOrnament(player *logic.Player, msg *net.Message) {}

func (this *PlayerHandler) LineupCreate(player *logic.Player, msg *net.Message) {
	var req = new(pb.LineupCreateReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if len(req.Name) == 0 {
		this.logger.Error("Parameter error, name is empty")
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	if len(player.Lineup) > 5 {
		_ = player.TipNotice(proto.TipLineupsAlreadyMax)
		return
	}

	var previous *logic.PlayerLineup
	for _, lineup := range player.Lineup {
		if lineup.Active {
			previous = lineup
			break
		}
	}

	if previous == nil {
		_ = player.TipNotice(proto.TipServerError)
		return
	}

	var newLineup = &logic.PlayerLineup{
		Uid:    util.RandomUid(),
		Name:   req.Name,
		Active: true,
	}

	for i, hero := range previous.Heroes {
		newLineup.Heroes[i] = new(logic.PlayerLineupHero)
		if hero != nil {
			*newLineup.Heroes[i] = *hero
		}
	}

	var changeList []*pb.LineupChange

	previous.Active = false
	player.SaveModel(previous)

	changeList = append(changeList, &pb.LineupChange{ChangeType: pb.ChangeType_Changed, Lineup: previous.BuildMsgLineup()})

	player.Lineup[newLineup.Uid] = newLineup
	player.SaveModel(newLineup)

	changeList = append(changeList, &pb.LineupChange{ChangeType: pb.ChangeType_Add, Lineup: newLineup.BuildMsgLineup()})

	_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleLineupChange), &pb.LineupChangeListAck{ChangeList: changeList})
}

func (this *PlayerHandler) LineupChangeName(player *logic.Player, msg *net.Message) {
	var req = new(pb.LineupChangeNameReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.Uid == 0 {
		this.logger.Error("Parameter error, req.Uid: ", req.Uid)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	if len(req.Name) == 0 {
		this.logger.Error("Parameter error, name is empty")
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	var lineup = player.Lineup[req.Uid]
	if lineup == nil {
		this.logger.Error("Player lineup not found, req.Uid: ", req.Uid)
		_ = player.TipNotice(proto.TipLineupNotFound)
		return
	}

	lineup.Name = req.Name

	player.SaveModel(lineup)

	_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleLineupChange), &pb.LineupChangeListAck{
		ChangeList: []*pb.LineupChange{{ChangeType: pb.ChangeType_Changed, Lineup: lineup.BuildMsgLineup()}},
	})
}

func (this *PlayerHandler) LineupActivate(player *logic.Player, msg *net.Message) {
	var req = new(pb.LineupActivateReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.Uid == 0 {
		this.logger.Error("Parameter error, req.Uid: ", req.Uid)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	var lineup = player.Lineup[req.Uid]
	if lineup == nil {
		this.logger.Error("Player lineup not found, req.Uid: ", req.Uid)
		_ = player.TipNotice(proto.TipLineupNotFound)
		return
	}

	lineup.Active = true

	player.SaveModel(lineup)

	_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleLineupChange), &pb.LineupChangeListAck{
		ChangeList: []*pb.LineupChange{{ChangeType: pb.ChangeType_Changed, Lineup: lineup.BuildMsgLineup()}},
	})
}

func (this *PlayerHandler) LineupDelete(player *logic.Player, msg *net.Message) {
	var req = new(pb.LineupDeleteReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.Uid == 0 {
		this.logger.Error("Parameter error, req.Uid: ", req.Uid)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	var lineup = player.Lineup[req.Uid]
	if lineup == nil {
		this.logger.Error("Player lineup not found, req.Uid: ", req.Uid)
		_ = player.TipNotice(proto.TipLineupNotFound)
		return
	}

	delete(player.Lineup, req.Uid)

	player.WipeModel(lineup)

	_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleLineupChange), &pb.LineupChangeListAck{
		ChangeList: []*pb.LineupChange{{ChangeType: pb.ChangeType_Delete, Lineup: lineup.BuildMsgLineup()}},
	})
}

//
//func (this *PlayerHandler) RoleTalentUpgrade(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRoleTalentUpgradeReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Id == 0 {
//		this.logger.Error("Parameter error, req.Id == 0")
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var talent = player.RoleTalent[req.Id]
//
//	var nextLevelTable *data.TalentLevel
//	if talent != nil {
//		var talentTreeTable = this.tables.TalentTree.Get(int(talent.Id))
//		if talentTreeTable == nil {
//			this.logger.Error("Data error, TalentTree not found, id: ", talent.Id)
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//		var talentLevelTable = this.tables.TalentLevel.Get(int(talent.LevelId))
//		if talentLevelTable == nil {
//			this.logger.Error("Data error, TalentLevel not found, levelId: ", talent.LevelId)
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//		if talentLevelTable.Level >= talentTreeTable.MaxLevel {
//			this.logger.Errorf("Talent level alreay max, level: %d, maxLevel: %d", talentLevelTable.Level, talentTreeTable.MaxLevel)
//			_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//			return
//		}
//
//		nextLevelTable = this.tables.TalentLevelExtend.Get(talentTreeTable.Id, talentLevelTable.Level+1)
//		if talentLevelTable == nil {
//			this.logger.Errorf("Data error, TalentLevel not found, treeId: %d, nextLevel: %d", talentTreeTable.Id, talentLevelTable.Level+1)
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//	} else {
//		var talentTreeTable = this.tables.TalentTree.Get(int(req.Id))
//		if talentTreeTable == nil {
//			this.logger.Error("Data error, TalentTree not found, id: ", req.Id)
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//		if len(talentTreeTable.Parents) > 0 {
//			for _, parentId := range talentTreeTable.Parents {
//				if parentId == 0 {
//					continue
//				}
//
//				var parent = player.RoleTalent[uint32(parentId)]
//				if parent == nil {
//					this.logger.Error("Parent not found, parentId: ", parentId)
//					_ = player.TipNotice(proto.ErrTalentNeedParentMax)
//					return
//				}
//
//				var parentTreeTable = this.tables.TalentTree.Get(int(parent.Id))
//				if parentTreeTable == nil {
//					this.logger.Error("Data error, TalentTree not found, parentId: ", parent.Id)
//					_ = player.TipNotice(proto.ErrDataTablesError)
//					return
//				}
//
//				var parentLevelTable = this.tables.TalentLevel.Get(int(parent.LevelId))
//				if parentLevelTable == nil {
//					this.logger.Error("Data error, TalentLevel not found, parentLevelId: ", parent.LevelId)
//					_ = player.TipNotice(proto.ErrDataTablesError)
//					return
//				}
//
//				if parentLevelTable.Level < parentTreeTable.MaxLevel {
//					this.logger.Errorf("Parent not level max, parentLevel: %d, maxLevel: %d", parentLevelTable.Level, parentTreeTable.MaxLevel)
//					_ = player.TipNotice(proto.ErrTalentNeedParentMax)
//					return
//				}
//			}
//		}
//
//		nextLevelTable = this.tables.TalentLevelExtend.Get(talentTreeTable.Id, 1)
//		if nextLevelTable == nil {
//			this.logger.Errorf("Data error, TalentLevel not found, treeId: %d, nextLevel: %d", talentTreeTable.Id, 1)
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//		talent = &logic.PlayerRoleTalent{Id: uint32(talentTreeTable.Id)}
//	}
//
//	err = player.CheckMoney(proto.MoneyType(nextLevelTable.MoneyType), uint32(nextLevelTable.MoneyNum))
//	if err != nil {
//		this.logger.Errorf("%s, moneyType: %d, moneyNum: %d", err.Error(), nextLevelTable.MoneyType, nextLevelTable.MoneyNum)
//		_ = player.TipNotice(err)
//		return
//	}
//
//	player.ReduceMoney(proto.MoneyType(nextLevelTable.MoneyType), uint32(nextLevelTable.MoneyNum), logic.LogTypeItemConsumeByTalentUpgrade)
//
//	talent.LevelId = uint32(nextLevelTable.Id)
//
//	player.RoleTalent[talent.Id] = talent
//	player.SaveModel(talent)
//
//	_ = player.Send(proto.ModIdRole, proto.MsgIdRoleTalentUpgrade, &proto.MsgRoleTalentUpgradeAck{RoleTalent: talent.BuildMsgRoleTalent()})
//
//	player.UpdateRigAttrs()
//	return
//}
//
//func (this *PlayerHandler) RoleTalentReset(player *logic.Player, _ *net.Message) {
//	var monies = map[uint32]uint32{}
//	for _, talent := range player.RoleTalent {
//		var level = 0
//		for {
//			level++
//			var talentLevelTable = this.tables.TalentLevelExtend.Get(int(talent.Id), level)
//			if talentLevelTable == nil {
//				continue
//			}
//
//			monies[uint32(talentLevelTable.MoneyType)] += uint32(talentLevelTable.MoneyNum)
//
//			if uint32(talentLevelTable.Id) == talent.LevelId {
//				break
//			}
//		}
//	}
//
//	player.RoleTalent = map[uint32]*logic.PlayerRoleTalent{}
//	player.SaveField("role_talent", player.RoleTalent)
//
//	for moneyType, moneyNum := range monies {
//		player.AddMoney(proto.MoneyType(moneyType), moneyNum, logic.LogTypeItemObtainByTalentReturn)
//	}
//
//	_ = player.Send(proto.ModIdRole, proto.MsgIdRoleTalentReset, nil)
//
//	player.UpdateRigAttrs()
//	return
//}