969 lines
29 KiB
Go
969 lines
29 KiB
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(pb.ModId_ModuleRole, 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(pb.ModId_ModuleRole, 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 = 0
|
|
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 = 2
|
|
player.SaveModel(hero)
|
|
player.UpdateHeroAttrs(hero)
|
|
heroChangeList = append(heroChangeList, &pb.HeroChange{ChangeType: pb.ChangeType_Changed, Hero: hero.BuildMsgHero()})
|
|
|
|
//TODO lineup hero capacity
|
|
|
|
_ = player.Send(pb.ModId_ModuleRole, pb.MsgId_ModRoleLineupChange, &pb.LineupChangeListAck{
|
|
ChangeList: []*pb.LineupChange{{ChangeType: pb.ChangeType_Changed, Lineup: lineup.BuildMsgLineup()}},
|
|
})
|
|
_ = player.Send(pb.ModId_ModuleHero, 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] == 0 {
|
|
continue
|
|
}
|
|
|
|
if 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
|
|
}
|
|
|
|
var ack = &pb.LineupHeroPositionAck{LineupUid: lineup.Uid, PositionList: make([]uint32, 6)}
|
|
for i := range 6 {
|
|
if lineup.Heroes[i] != nil {
|
|
lineup.Heroes[i].Position = req.PositionList[i]
|
|
ack.PositionList[i] = lineup.Heroes[i].Position
|
|
}
|
|
}
|
|
|
|
player.SaveModelField(lineup, "heroes", lineup.Heroes)
|
|
|
|
_ = player.Send(pb.ModId_ModuleRole, pb.MsgId_ModRoleLineupHeroPosition, ack)
|
|
|
|
_ = player.Send(pb.ModId_ModuleRole, 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(pb.ModId_ModuleRole, pb.MsgId_ModRoleLineupChange, &pb.LineupChangeListAck{
|
|
ChangeList: []*pb.LineupChange{{ChangeType: pb.ChangeType_Changed, Lineup: lineup.BuildMsgLineup()}},
|
|
})
|
|
_ = player.Send(pb.ModId_ModuleItem, pb.MsgId_ModItemEquipChange, &pb.EquipChangeListAck{ChangeList: equipChangeList})
|
|
_ = player.Send(pb.ModId_ModuleHero, 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(pb.ModId_ModuleRole, pb.MsgId_ModRoleLineupChange, &pb.LineupChangeListAck{
|
|
ChangeList: []*pb.LineupChange{{ChangeType: pb.ChangeType_Changed, Lineup: lineup.BuildMsgLineup()}},
|
|
})
|
|
_ = player.Send(pb.ModId_ModuleItem, pb.MsgId_ModItemTreasureChange, &pb.TreasureChangeListAck{ChangeList: equipChangeList})
|
|
_ = player.Send(pb.ModId_ModuleHero, 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 *logic.PlayerHero
|
|
if req.HeroUid != 0 {
|
|
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
|
|
}
|
|
}
|
|
|
|
var heroChangeList []*pb.HeroChange
|
|
if lineup.Helper[req.Index] != 0 {
|
|
if preHero, ok := player.Hero[lineup.Helper[req.Index]]; ok {
|
|
preHero.InLineup = 0
|
|
player.SaveModel(preHero)
|
|
|
|
heroChangeList = append(heroChangeList, &pb.HeroChange{ChangeType: pb.ChangeType_Changed, Hero: preHero.BuildMsgHero()})
|
|
}
|
|
}
|
|
|
|
if hero != nil {
|
|
hero.InLineup = 1
|
|
player.SaveModel(hero)
|
|
|
|
heroChangeList = append(heroChangeList, &pb.HeroChange{ChangeType: pb.ChangeType_Changed, Hero: hero.BuildMsgHero()})
|
|
|
|
lineup.Helper[req.Index] = hero.Uid
|
|
} else {
|
|
lineup.Helper[req.Index] = 0
|
|
}
|
|
|
|
player.SaveModel(lineup)
|
|
|
|
_ = player.Send(pb.ModId_ModuleRole, pb.MsgId_ModRoleLineupChange, &pb.LineupChangeListAck{
|
|
ChangeList: []*pb.LineupChange{{ChangeType: pb.ChangeType_Changed, Lineup: lineup.BuildMsgLineup()}},
|
|
})
|
|
_ = player.Send(pb.ModId_ModuleHero, pb.MsgId_ModHeroChange, &pb.HeroChangeListAck{
|
|
ChangeList: heroChangeList,
|
|
})
|
|
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 = player.CurrentLineup()
|
|
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(pb.ModId_ModuleRole, 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(pb.ModId_ModuleRole, 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(pb.ModId_ModuleRole, 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(pb.ModId_ModuleRole, 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
|
|
//}
|