104 lines
2.9 KiB
Go
104 lines
2.9 KiB
Go
package gameserver
|
|
|
|
import (
|
|
"gac-hkrpg-go/internal/common"
|
|
goproto "gac-hkrpg-go/protocol/proto"
|
|
)
|
|
|
|
func presetLineup(p *common.FreesrData, index uint32) *goproto.LineupInfo {
|
|
saved := p.TeamPreset(index)
|
|
lineup := common.ToLineupInfo(saved.Avatars)
|
|
tmp := *p
|
|
tmp.Lineups = saved.Avatars
|
|
lineup.AvatarList = common.ToLineupAvatars(&tmp)
|
|
lineup.Index = index
|
|
lineup.Name = saved.Name
|
|
lineup.LeaderSlot = saved.LeaderSlot
|
|
lineup.PlaneId = p.Scene.PlaneID
|
|
lineup.IECKKCHJMLP = saved.Favourite && len(lineup.AvatarList) > 0
|
|
if saved.Avatars[lineup.LeaderSlot] == 0 {
|
|
for _, a := range lineup.AvatarList {
|
|
lineup.LeaderSlot = a.Slot
|
|
break
|
|
}
|
|
}
|
|
return lineup
|
|
}
|
|
func allPresetLineups(s *Session) ([]*goproto.LineupInfo, error) {
|
|
rules, err := common.LoadTeamPresetRules()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p := s.JSON()
|
|
if p == nil {
|
|
return nil, nil
|
|
}
|
|
var out []*goproto.LineupInfo
|
|
for index := uint32(0); index < rules.Count; index++ {
|
|
out = append(out, presetLineup(p, index))
|
|
}
|
|
return out, nil
|
|
}
|
|
func (s *Session) presetEditCode(index uint32, extra goproto.ExtraLineupType, virtual bool) (uint32, error) {
|
|
rules, err := common.LoadTeamPresetRules()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if s.JSON() == nil {
|
|
return uint32(goproto.Retcode_RET_LINEUP_NOT_EXIST), nil
|
|
}
|
|
if index >= rules.Count {
|
|
return uint32(goproto.Retcode_RET_LINEUP_INVALID_INDEX), nil
|
|
}
|
|
if extra != goproto.ExtraLineupType_ExtraLineupType_LineupNone || virtual {
|
|
return uint32(goproto.Retcode_RET_LINEUP_TYPE_NOT_MATCH), nil
|
|
}
|
|
if _, active := CURRENT_BATTLE.Load(s.Token); active {
|
|
return uint32(goproto.Retcode_RET_LINEUP_NOT_ALLOW_EDIT), nil
|
|
}
|
|
return 0, nil
|
|
}
|
|
func (s *Session) savePreset(index uint32, saved *common.TeamPreset) error {
|
|
if err := s.JSON().SaveTeamPreset(index, saved); err != nil {
|
|
return err
|
|
}
|
|
return s.publishPreset(index, saved)
|
|
}
|
|
func (s *Session) publishPreset(index uint32, saved *common.TeamPreset) error {
|
|
if index == s.JSON().ActiveTeamPreset && s.ChallengeRun == nil {
|
|
s.leaderSlot = saved.LeaderSlot
|
|
if err := refreshLineup(s); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
lineups, err := allPresetLineups(s)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
SceneDebugLog("[TEAM PRESET] saved index=%d name=%q team=%v", index, saved.Name, saved.Avatars)
|
|
return s.Send(&goproto.SyncAllPresetLineupNotify{CurIndex: s.JSON().ActiveTeamPreset, LineupList: lineups})
|
|
}
|
|
func validatePresetMembers(p *common.FreesrData, avatars map[uint32]uint32) uint32 {
|
|
rules, err := common.LoadTeamPresetRules()
|
|
if err != nil {
|
|
return uint32(goproto.Retcode_RET_LINEUP_NOT_EXIST)
|
|
}
|
|
seen := map[uint32]bool{}
|
|
for slot, id := range avatars {
|
|
if slot >= rules.MaxMembers {
|
|
return uint32(goproto.Retcode_RET_LINEUP_INVALID_MEMBER_POS)
|
|
}
|
|
if id == 0 {
|
|
continue
|
|
}
|
|
if p.Avatars[id] == nil {
|
|
return uint32(goproto.Retcode_RET_LINEUP_AVATAR_NOT_EXIST)
|
|
}
|
|
if seen[id] {
|
|
return uint32(goproto.Retcode_RET_LINEUP_AVATAR_ALREADY_IN)
|
|
}
|
|
seen[id] = true
|
|
}
|
|
return 0
|
|
}
|