bl/logic/service/fight/new.go

package fight

import (
	"blazing/common/socket/errorcode"
	"blazing/cool"
	"blazing/logic/service/common"
	"blazing/logic/service/fight/action"
	"blazing/logic/service/fight/info"
	"blazing/logic/service/fight/input"
	"blazing/logic/service/player"
	"blazing/modules/player/model"
	"time"
)

// 创建新战斗,邀请方和被邀请方,或者玩家和野怪方
func NewFight(p1, p2 common.PlayerI, b1, b2 []model.PetInfo, fn func(model.FightOverInfo)) (*FightC, errorcode.ErrorCode) {
	return NewFightWithOptions(
		WithFightPlayers(p1, p2),
		WithFightPets(b1, b2),
		WithFightCallback(fn),
	)
}

func buildFight(opts *fightBuildOptions) (*FightC, errorcode.ErrorCode) {
	if opts == nil || opts.owner == nil || opts.opponent == nil {
		return nil, errorcode.ErrorCodes.ErrSystemBusyTryLater
	}
	opts.normalizePlayers()

	f := &FightC{}
	f.ownerID = opts.owner.GetInfo().UserID
	f.OurPlayers = opts.ourPlayers
	f.OppPlayers = opts.oppPlayers
	f.Switch = make(map[actionSlotKey]*action.ActiveSwitchAction)
	f.callback = opts.callback
	f.quit = make(chan struct{})
	f.over = make(chan struct{})
	f.actionNotify = make(chan struct{}, 1)
	f.pendingActions = make([]action.BattleActionI, 0, 4)
	f.StartTime = opts.startTime
	if opts.fightInfo != nil {
		f.Info = *opts.fightInfo
	} else {
		f.Info = opts.owner.Getfightinfo()
	}
	f.ReadyInfo.Status = f.Info.Status

	var err errorcode.ErrorCode
	f.Our, err = f.buildFightInputs(opts.owner, opts.ourPets, opts.ourInputs)
	if err > 0 {
		return nil, err
	}
	f.Opp, err = f.buildFightInputs(opts.opponent, opts.oppPets, opts.oppInputs)
	if err > 0 {
		return nil, err
	}
	f.bindInputFightContext(f.Our)
	f.bindInputFightContext(f.Opp)
	f.linkOppInputs()

	f.ReadyInfo.OurInfo, f.ReadyInfo.OurPetList = initfightready(f.primaryOur())
	f.ReadyInfo.OpponentInfo, f.ReadyInfo.OpponentPetList = initfightready(f.primaryOpp())

	loadtime := 120 * time.Second
	if f.Info.Status == info.BattleMode.FIGHT_WITH_NPC {
		if opp := f.primaryOpp(); opp != nil {
			opp.Finished = true
			loadtime = 60 * time.Second
			if ai, ok := opp.Player.(*player.AI_player); ok {
				if ai.CanCapture > 0 {
					opp.CanCapture = ai.CanCapture
				}
				opp.AttackValue.Prop = ai.Prop
			}
		}
	}
	f.FightStartOutboundInfo = f.buildFightStartInfo()

	f.Broadcast(func(ff *input.Input) {
		ff.Player.SendPackCmd(2503, &f.ReadyInfo)
	})

	cool.Cron.AfterFunc(loadtime, func() {
		our := f.primaryOur()
		opp := f.primaryOpp()
		if our == nil || opp == nil {
			return
		}
		if !our.Finished || !opp.Finished {
			f.closefight = true
			f.Reason = model.BattleOverReason.PlayerOffline
			switch {
			case !opp.Finished:
				f.WinnerId = our.Player.GetInfo().UserID
			case !our.Finished:
				f.WinnerId = opp.Player.GetInfo().UserID
			}
			f.Broadcast(func(ff *input.Input) {
				ff.Player.SendPackCmd(2506, &f.FightOverInfo)
				ff.Player.QuitFight()
			})
		}
	})

	return f, 0
}

func (f *FightC) buildFightInputs(defaultPlayer common.PlayerI, pets []model.PetInfo, existing []*input.Input) ([]*input.Input, errorcode.ErrorCode) {
	if len(existing) > 0 {
		return existing, 0
	}
	in, err := f.initplayer(defaultPlayer, pets)
	if err > 0 {
		return nil, err
	}
	return []*input.Input{in}, 0
}