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"
	"sort"
	"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,
		pb.RolePropertyType_ChatBubble,
		pb.RolePropertyType_NamePrefix,
		pb.RolePropertyType_NameTitle,
		pb.RolePropertyType_RoleTitle:
		player.ChangeProperty(util.NewPair(req.Property.Type, req.Property.Value))
	default:
		this.logger.Error("Parameter error, req.Property.Type: ", req.Property.Type)
		_ = player.TipNotice(proto.TipParameterError)
	}
	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.LineupUid == 0 {
		this.logger.Error("Parameter error, req.LineupUid: ", req.LineupUid)
		_ = player.TipNotice(proto.TipParameterError)
		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(pb.ModId_ModuleRole, pb.FuncType_FuncLineupHeroes, int(req.Index)) {
		_ = player.TipNotice(proto.TipFunctionNotUnlocked)
		return
	}

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

	var hero = player.Hero[req.HeroUid]
	if hero == nil {
		this.logger.Error("Parameter error, lineup not found, req.LineupUid: ", req.LineupUid)
		_ = player.TipNotice(proto.TipHeroNotFound)
		return
	}

	var setups [7]bool
	for i := 0; i < 8; i++ {
		if lineup.Heroes[i] == nil {
			continue
		}

		if hero.Uid == lineup.Heroes[i].HeroUid {
			this.logger.Errorf("The hero has set into the lineup, hero.Uid: %d, index: %d", hero.Uid, i)
			_ = player.TipNotice(proto.TipLineupHeroHasSet)
			return
		}

		if i < 6 {
			if lineup.Heroes[i].Position > 0 {
				setups[lineup.Heroes[i].Position] = true
			}
		}
	}

	var heroChangeList []*pb.HeroChange
	var lineupHero = lineup.Heroes[req.Index]
	if lineupHero == nil {
		lineupHero = &logic.PlayerLineupHero{
			HeroUid: hero.Uid,
		}

		for position := 1; position < 7; position++ {
			if !setups[position] {
				lineupHero.Position = uint32(position)
			}
		}

		lineup.Heroes[req.Index] = lineupHero
	} else {
		var preHero = player.Hero[lineupHero.HeroUid]
		if preHero != nil {
			preHero.InLineup = false
			player.SaveModel(preHero)
			player.UpdateHeroAttrs(preHero)
			heroChangeList = append(heroChangeList, &pb.HeroChange{ChangeType: pb.ChangeType_Changed, Hero: preHero.BuildMsgHero()})
		}
		lineupHero.HeroUid = hero.Uid
	}

	player.SaveArray("lineup.heroes", int(req.Index), lineupHero)

	hero.InLineup = true
	player.SaveModel(hero)
	player.UpdateHeroAttrs(hero)
	heroChangeList = append(heroChangeList, &pb.HeroChange{ChangeType: pb.ChangeType_Changed, Hero: hero.BuildMsgHero()})

	//TODO lineup hero capacity

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

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.PositionList) != 6 {
		this.logger.Errorf("Parameter error, len(req.IndexList) != 6, len(req.IndexList) = %d", len(req.PositionList))
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

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

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

		if setups[req.PositionList[i]] {
			this.logger.Errorf("Parameter error, repeated hero battle position, position: %d, index: %d", req.PositionList[i], i)
			_ = player.TipNotice(proto.TipParameterError)
			return
		}

		setups[req.PositionList[i]] = true
	}

	for i := range 6 {
		if lineup.Heroes[i] != nil {
			lineup.Heroes[i].Position = req.PositionList[i]
		}
	}

	player.SaveField("lineup.heroes", lineup.Heroes)

	_ = 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) 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.LineupUid == 0 {
		this.logger.Error("Parameter error, req.LineupUid: ", req.LineupUid)
		_ = player.TipNotice(proto.TipParameterError)
		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(pb.ModId_ModuleRole, 1, int(req.Index)) {
		_ = player.TipNotice(proto.TipFunctionNotUnlocked)
		return
	}

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

	var lineupHero = lineup.Heroes[req.Index]
	if lineupHero == nil {
		_ = player.TipNotice(proto.TipLineupHeroNotSet)
		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.Find1(int(equip.Id))
		if equipTable == nil {
			_ = player.TipNotice(proto.TipDataTablesError)
			return
		}

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

	var lineupHeroList []*pb.LineupHero
	var heroChangeList []*pb.HeroChange
	var equipChangeList []*pb.EquipChange

	if lineupHero.Equip[req.EquipType] != 0 {
		var preEquip = player.Equip[lineupHero.Equip[req.EquipType]]
		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[req.EquipType] = req.EquipUid
	player.SaveArray("lineup.heroes", int(req.Index), lineupHero)
	lineupHeroList = append(lineupHeroList, lineupHero.BuildMsgLineupHero(req.Index))

	if hero, ok := player.Hero[lineupHero.HeroUid]; ok {
		if player.UpdateHeroAttrs(hero) {
			heroChangeList = append(heroChangeList, &pb.HeroChange{ChangeType: pb.ChangeType_Changed, Hero: hero.BuildMsgHero()})
		}
	}

	if equip != nil {
		if equip.HeroUid != 0 {
			util.SliceFindValue(lineup.Heroes[:], func(i int) bool {
				if lineup.Heroes[i] == nil {
					return false
				}

				if lineup.Heroes[i].HeroUid == equip.HeroUid {
					var preLineupHero = lineup.Heroes[i]
					if preLineupHero.Equip[req.EquipType] != 0 {
						preLineupHero.Equip[req.EquipType] = 0
						player.SaveArray("lineup.heroes", i, preLineupHero)
						lineupHeroList = append(lineupHeroList, preLineupHero.BuildMsgLineupHero(uint32(i)))
						if preHero, ok := player.Hero[preLineupHero.HeroUid]; ok {
							if player.UpdateHeroAttrs(preHero) {
								heroChangeList = append(heroChangeList, &pb.HeroChange{ChangeType: pb.ChangeType_Changed, Hero: preHero.BuildMsgHero()})
							}
						}
					}
					return true
				}
				return false
			})
		}

		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_ModRoleLineupChange), &pb.LineupChangeListAck{
		ChangeList: []*pb.LineupChange{{ChangeType: pb.ChangeType_Changed, Lineup: lineup.BuildMsgLineup()}},
	})
	_ = player.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemEquipChange), &pb.EquipChangeListAck{ChangeList: equipChangeList})
	_ = player.Send(uint16(pb.ModId_ModuleHero), uint16(pb.MsgId_ModHeroChange), &pb.HeroChangeListAck{ChangeList: heroChangeList})
	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.LineupUid == 0 {
		this.logger.Error("Parameter error, req.LineupUid: ", req.LineupUid)
		_ = player.TipNotice(proto.TipParameterError)
		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(pb.ModId_ModuleRole, pb.FuncType_FuncLineupHeroes, int(req.Index)) {
		_ = player.TipNotice(proto.TipFunctionNotUnlocked)
		return
	}

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

	var lineupHero = lineup.Heroes[req.Index]
	if lineupHero == nil {
		_ = player.TipNotice(proto.TipLineupHeroNotSet)
		return
	}

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

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

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

	var lineupHeroList []*pb.LineupHero
	var heroChangeList []*pb.HeroChange
	var equipChangeList []*pb.TreasureChange

	if lineupHero.Treasure[req.TreasureType] != 0 {
		var preTreasure = player.Treasure[lineupHero.Treasure[req.TreasureType]]
		if preTreasure != nil && preTreasure.HeroUid != 0 {
			preTreasure.HeroUid = 0
			player.SaveModel(preTreasure)
			equipChangeList = append(equipChangeList, &pb.TreasureChange{
				ChangeType: pb.ChangeType_Changed,
				Treasure:   preTreasure.BuildMsgTreasure(),
			})
		}
	}

	lineupHero.Treasure[req.TreasureType] = req.TreasureUid
	player.SaveArray("lineup.heroes", int(req.Index), lineupHero)
	lineupHeroList = append(lineupHeroList, lineupHero.BuildMsgLineupHero(req.Index))

	if hero, ok := player.Hero[lineupHero.HeroUid]; ok {
		if player.UpdateHeroAttrs(hero) {
			heroChangeList = append(heroChangeList, &pb.HeroChange{ChangeType: pb.ChangeType_Changed, Hero: hero.BuildMsgHero()})
		}
	}

	if treasure != nil {
		if treasure.HeroUid != 0 {
			util.SliceFindValue(lineup.Heroes[:], func(i int) bool {
				if lineup.Heroes[i] == nil {
					return false
				}

				if lineup.Heroes[i].HeroUid == treasure.HeroUid {
					var preLineupHero = lineup.Heroes[i]
					if preLineupHero.Treasure[req.TreasureType] != 0 {
						preLineupHero.Treasure[req.TreasureType] = 0
						player.SaveArray("lineup.heroes", i, preLineupHero)
						lineupHeroList = append(lineupHeroList, preLineupHero.BuildMsgLineupHero(uint32(i)))

						if preHero, ok := player.Hero[preLineupHero.HeroUid]; ok {
							if player.UpdateHeroAttrs(preHero) {
								heroChangeList = append(heroChangeList, &pb.HeroChange{ChangeType: pb.ChangeType_Changed, Hero: preHero.BuildMsgHero()})
							}
						}
					}
					return true
				}
				return false
			})
		}

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

	_ = player.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleLineupChange), &pb.LineupChangeListAck{
		ChangeList: []*pb.LineupChange{{ChangeType: pb.ChangeType_Changed, Lineup: lineup.BuildMsgLineup()}},
	})
	_ = player.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemTreasureChange), &pb.TreasureChangeListAck{ChangeList: equipChangeList})
	_ = player.Send(uint16(pb.ModId_ModuleHero), uint16(pb.MsgId_ModHeroChange), &pb.HeroChangeListAck{ChangeList: heroChangeList})
	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) LineupHelperChange(player *logic.Player, msg *net.Message) {
	var req = new(pb.LineupHelperChangeReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

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

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

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

	var hero = player.Hero[req.HeroUid]
	if hero == nil {
		this.logger.Error("Parameter error, hero was not found, req.HeroUid: ", req.HeroUid)
		_ = player.TipNotice(proto.TipHeroNotFound)
		return
	}

	lineup.Helper[req.Index] = hero.Uid

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

	player.SendLineupHeroChange(lineup)
	return
}

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

}

func (this *PlayerHandler) LineupTreasureInlay(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 = util.MapFindValue(player.Lineup, func(v *logic.PlayerLineup) bool {
		return v.Active
	})
	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_Add, 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
	}

	if lineup.Active {
		return
	}

	var lineupChangeList []*pb.LineupChange

	var preLineup *logic.PlayerLineup
	for _, v := range player.Lineup {
		if v.Active {
			preLineup = v
		}
	}

	if preLineup != nil {
		preLineup.Active = false
		player.SaveModel(lineup)
		lineupChangeList = append(lineupChangeList, &pb.LineupChange{ChangeType: pb.ChangeType_Changed, Lineup: preLineup.BuildMsgLineup()})
	}

	lineup.Active = true
	player.SaveModel(lineup)
	lineupChangeList = append(lineupChangeList, &pb.LineupChange{ChangeType: pb.ChangeType_Changed, Lineup: lineup.BuildMsgLineup()})

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

	player.SendLineupHeroChange(preLineup, lineup)
	return
}

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 delLineup = player.Lineup[req.Uid]
	if delLineup == nil {
		this.logger.Error("Player lineup not found, req.Uid: ", req.Uid)
		_ = player.TipNotice(proto.TipLineupNotFound)
		return
	}

	if len(player.Lineup) == 1 {
		this.logger.Error("Player lineup can not delete, len(player.Lineup) == 1")
		_ = player.TipNotice(proto.TipLineupCanNotDelete)
		return
	}

	var lineupChangeList []*pb.LineupChange

	delLineup.Active = false
	delete(player.Lineup, delLineup.Uid)
	player.WipeModel(delLineup)
	lineupChangeList = append(lineupChangeList, &pb.LineupChange{ChangeType: pb.ChangeType_Delete, Lineup: delLineup.BuildMsgLineup()})

	var lineupList = make([]*logic.PlayerLineup, 0, len(player.Lineup))
	for _, v := range player.Lineup {
		lineupList = append(lineupList, v)
	}

	sort.Slice(lineupList, func(i, j int) bool {
		return lineupList[i].Uid < lineupList[j].Uid
	})

	var lineup = lineupList[0]
	lineup.Active = true
	player.WipeModel(lineup)
	lineupChangeList = append(lineupChangeList, &pb.LineupChange{ChangeType: pb.ChangeType_Changed, Lineup: lineup.BuildMsgLineup()})

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

	player.SendLineupHeroChange(delLineup, lineup)
}

//
//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
//}