s_cherry_e/sr/nodes/map/internal/call/logic.go

package mapCall

import (
	capp "f1-game/internal/cherry_app"
	"f1-game/internal/code"
	"f1-game/internal/enum"
	nameActor "f1-game/internal/name/actor"
	nameRemote "f1-game/internal/name/remote"
	"f1-game/internal/pb"
	"f1-game/internal/types"
	mapTypes "f1-game/nodes/map/internal/types"

	cfacade "github.com/cherry-game/cherry/facade"
)

var (
	Logic = &logicCall{
		logicPath: cfacade.NewPath("", nameActor.Map_Logic),
	}
)

type logicCall struct {
	logicPath string
}

func (p *logicCall) ResArmies(req *pb.I64) (*pb.I32List, int32) {
	rsp := &pb.I32List{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_ResArmies, req, rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return rsp, code.OK
}

func (p *logicCall) Reinforce(playerID int64) int32 {
	req := &pb.I64{Value: playerID}
	return capp.CallWait(p.logicPath, nameRemote.MapLogic_Reinforce, req, nil)
}

func (p *logicCall) ReinforceCancel(playerID int64) int32 {
	req := &pb.I64{Value: playerID}
	return capp.CallWait(p.logicPath, nameRemote.MapLogic_ReinforceCancel, req, nil)
}

func (p *logicCall) BornStateInfo() (*pb.I32I32List, int32) {
	rsp := &pb.I32I32List{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_BornStateInfo, nil, rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return rsp, code.OK
}

func (p *logicCall) Enter(playerID int64) int32 {
	return capp.CallWait(p.logicPath, nameRemote.MapLogic_Enter, &pb.I64{Value: playerID}, nil)
}

// Reborn 玩家重新出生
func (p *logicCall) Reborn(playerID int64, stateID int32) (*pb.Point, int32) {
	req := &pb.I64I32{
		Key:   playerID,
		Value: stateID,
	}
	rsp := &pb.Point{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_Reborn, req, rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return rsp, code.OK
}

// 调用 logic 选择出生州
func (p *logicCall) SelectState(arg *pb.SelectStateRequest) (*pb.SelectStateResponse, int32) {
	rsp := &pb.SelectStateResponse{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_SelectState, arg, rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return rsp, code.OK
}

// Comeback 玩家再起
func (p *logicCall) Comeback(playerID int64, rechoose bool, stateID int32) (*pb.Point, int32) {
	req := &pb.PlayerComeback{
		PlayerID: playerID,
		Rechoose: rechoose,
		StateID:  stateID,
	}
	rsp := pb.Point{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_Comeback, req, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

func (p *logicCall) SiegeRank(buildObjectID int64) (*pb.SiegeRank, int32) {
	req := &pb.I64{Value: buildObjectID}
	rsp := &pb.SiegeRank{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_SiegeRank, req, rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return rsp, code.OK
}

func (p *logicCall) AutoOutsideTroopsNotify(playerID int64, teamID int32, conscripEndTime int64) {
	req := &pb.TeamOutsideTroopsUpdate{
		PlayerID:         playerID,
		TeamID:           teamID,
		ConscriptEndTime: conscripEndTime,
	}

	capp.Call(p.logicPath, nameRemote.MapLogic_OutsideAutoTroopsNotify, req)
}

// 发起集结
func (p *logicCall) Assemble(req *pb.AssembleRequest) (*pb.I64I32, int32) {
	rsp := pb.I64I32{}
	err := capp.CallWait(p.logicPath, nameRemote.MapLogic_Assemble, req, &rsp)
	if code.IsFail(err) {
		return nil, err
	}

	return &rsp, code.OK
}

// 加入集结
func (p *logicCall) AssembleJoin(req *pb.MarchRequest) (*pb.I64I32, int32) {
	rsp := pb.I64I32{}
	err := capp.CallWait(p.logicPath, nameRemote.MapLogic_AssembleJoin, req, &rsp)
	if code.IsFail(err) {
		return nil, err
	}

	return &rsp, code.OK
}

// 集结取消
func (p *logicCall) AssembleStop(leadMarchObjectID int64) int32 {
	return capp.CallWait(p.logicPath, nameRemote.MapLogic_AssembleStop, &pb.I64{Value: leadMarchObjectID}, nil)
}

// 踢出集结队伍
func (p *logicCall) AssembleQuit(assembleID int64, marchObjectID int64) int32 {
	arg := pb.I64I64{
		Key:   assembleID,
		Value: marchObjectID,
	}

	return capp.CallWait(p.logicPath, nameRemote.MapLogic_AssembleQuit, &arg, nil)
}

func (p *logicCall) AssembleDepart(assembleID int64) int32 {
	return capp.CallWait(p.logicPath, nameRemote.MapLogic_AssembleDepart, &pb.I64{Value: assembleID}, nil)
}

// 获取对象坐标
func (p *logicCall) GetObject1Point(objectID int64, objectType enum.ObjectType, point *types.Point) int32 {
	points, errCode := p.GetObjectPoints(&pb.I64I32{
		Key:   objectID,
		Value: int32(objectType),
	})

	if code.IsFail(errCode) {
		return errCode
	}

	if point != nil {
		point.X = points.List[0].X
		point.Y = points.List[0].Y
	}

	return code.OK
}

func (p *logicCall) GetObject2Point(object1, object2 *pb.I64I32, start, end *types.Point) int32 {
	points, errCode := p.GetObjectPoints(object1, object2)
	if code.IsFail(errCode) {
		return errCode
	}

	if len(points.List) != 2 {
		return code.MapGetPointFail
	}

	if start != nil {
		start.SetValue(points.List[0].X, points.List[0].Y)
	}

	if end != nil {
		end.SetValue(points.List[1].X, points.List[1].Y)
	}

	return code.OK
}

// 获取对象坐标
func (p *logicCall) GetObjectPoints(req ...*pb.I64I32) (*pb.Points, int32) {
	arg := pb.I64I32List{
		List: req,
	}

	rsp := pb.Points{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_GetObjectPoints, &arg, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

func (p *logicCall) March(req *pb.MarchRequest) (*pb.I64I32, int32) {
	rsp := pb.I64I32{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_March, req, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

// 攻城集结
func (p *logicCall) SiegeAssemble(req *pb.MarchRequest) (*pb.I64I32, int32) {
	rsp := pb.I64I32{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_SiegeAssemble, req, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

func (p *logicCall) Retreat(req *pb.MarchRequest) (*pb.I32, int32) {
	rsp := pb.I32{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_Retreat, req, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

func (p *logicCall) MarchStop(marchObjectID int64) int32 {
	arg := pb.I64{Value: marchObjectID}
	return capp.CallWait(p.logicPath, nameRemote.MapLogic_MarchStop, &arg, nil)
}

func (p *logicCall) ResDiscard(playerID, resObjectID int64) int32 {
	arg := pb.I64I64{Key: playerID, Value: resObjectID}
	return capp.CallWait(p.logicPath, nameRemote.MapLogic_ResDiscard, &arg, nil)
}

func (p *logicCall) BuildDiscard(playerID, buildObjectID int64) (int64, int32) {
	var (
		arg = pb.I64I64{Key: playerID, Value: buildObjectID}
		rsp = pb.I64{}
	)

	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_BuildDiscard, &arg, &rsp)
	return rsp.Value, errCode
}

// DiscardCancelPlayer 玩家取消放弃对象
func (p *logicCall) DiscardCancelPlayer(playerID, objectID int64, objectType int32) int32 {
	req := &pb.I64I64I32{
		Key1: playerID,
		Key2: objectID,
		Key3: objectType,
	}

	return capp.CallWait(p.logicPath, nameRemote.MapLogic_DiscardCancelPlayer, req, nil)
}

// DiscardCancelLeague 联盟取消放弃对象
func (p *logicCall) DiscardCancelLeague(leagueID, objectID int64, objectType int32) int32 {
	req := &pb.I64I64I32{
		Key1: leagueID,
		Key2: objectID,
		Key3: objectType,
	}

	return capp.CallWait(p.logicPath, nameRemote.MapLogic_DiscardCancelLeague, req, nil)
}

// func (p *logicCall) LeagueBuildDiscard(leagueID, buildObjectID int64) int32 {
// 	arg := pb.I64I64{Key: leagueID, Value: buildObjectID}
// 	return capp.CallWait(p.logicPath, nameRemote.MapLogic_LeagueBuildDiscard, &arg, nil)
// }

func (p *logicCall) Relocate(playerID, cityBaseObjectID int64) (*pb.Point, int32) {
	arg := pb.I64I64{Key: playerID, Value: cityBaseObjectID}
	rsp := pb.Point{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_Relocate, &arg, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

// 迁回驻地
func (p *logicCall) RelocateBack(playerID, leagueID int64) (*pb.Point, int32) {
	arg := pb.I64I64{Key: playerID, Value: leagueID}
	rsp := pb.Point{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_RelocateBack, &arg, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

func (p *logicCall) AutoDefend(req *pb.AutoDefend) (*pb.I64I32List, int32) {
	rsp := pb.I64I32List{}
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_AutoDefend, req, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

func (p *logicCall) MarchSyncTroops(teamID int32, marchObjectID int64, troops []*pb.MarchTroops) int32 {
	req := &pb.MarchSyncTroops{
		TeamID:   teamID,
		ObjectID: marchObjectID,
		Troops:   troops,
	}
	return capp.CallWait(p.logicPath, nameRemote.MapLogic_MarchSyncTroops, req, nil)
}

func (p *logicCall) MarchSyncInjure(marchObjectID, injureTime int64) int32 {
	req := &pb.I64I64{
		Key:   marchObjectID,
		Value: injureTime,
	}
	return capp.CallWait(p.logicPath, nameRemote.MapLogic_MarchSyncInjure, req, nil)
}

func (p *logicCall) BattleEnd(battleResult *pb.BattleRsp) {
	capp.Call(p.logicPath, nameRemote.MapLogic_BattleEnd, battleResult)
}

func (p *logicCall) Build(req *pb.BuildRequest) (*pb.I64I64, int32) {
	var rsp pb.I64I64
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_Build, req, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

func (p *logicCall) BuildLeague(req *pb.BuildLeagueRequest) (*pb.I64I64, int32) {
	var rsp pb.I64I64
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_BuildLeague, req, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

func (p *logicCall) BuildUpgrade(req *pb.BuildUpgradeRequest) int32 {
	return capp.CallWait(p.logicPath, nameRemote.MapLogic_BuildUpgrade, req, nil)
}

// 宣战
func (p *logicCall) StartWar(req *mapTypes.StartWar) (*pb.War, int32) {
	var rsp pb.War
	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_StartWar, req, &rsp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return &rsp, code.OK
}

// 取消宣泄
func (p *logicCall) StopWar(leagueID, castleObjectID int64) int32 {
	arg := pb.I64I64{
		Key:   leagueID,
		Value: castleObjectID,
	}

	return capp.CallWait(p.logicPath, nameRemote.MapLogic_StopWar, &arg, nil)
}

// 获取被攻占城池列表
func (p *logicCall) OccupyCastleList() (*pb.OccupyCastleList, int32) {
	var (
		req  = &pb.None{}
		resp = &pb.OccupyCastleList{}
	)

	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_OccupyCastleList, req, resp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return resp, code.OK
}

func (p *logicCall) SetSiegePath(req *mapTypes.SiegePathRsp) {
	capp.Call(p.logicPath, nameRemote.MapLogic_SetSiegePath, req)
}

func (p *logicCall) AOIUpdate(funcName string, req *mapTypes.AOIMarkerUpdate) {
	capp.Call(p.logicPath, funcName, req)
}

func (p *logicCall) AOIMarkerEnter(req *mapTypes.AOIMarkerEnter) {
	capp.Call(p.logicPath, nameRemote.MapLogic_AOIMarkerEnter, req)
}

func (p *logicCall) AOIMarkerLeave(req *mapTypes.AOIMakerLeave) {
	capp.Call(p.logicPath, nameRemote.MapLogic_AOIMarkerLeave, req)
}

func (p *logicCall) ScoutCheck(playerID, objectID int64) (*pb.CheckScoutResult, int32) {
	var (
		req = &pb.I64I64{
			Key:   playerID,
			Value: objectID,
		}
		resp = &pb.CheckScoutResult{}
	)

	errCode := capp.CallWait(p.logicPath, nameRemote.MapLogic_ScoutCheck, req, resp)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	return resp, code.OK
}