fdkk_meta/src/main/java/com/fdkk/fdkkmeta/grpcService/sceneGrpcServer.java

package com.fdkk.fdkkmeta.grpcService;

import cn.hutool.core.util.ArrayUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fdkk.fdkkmeta.config.MetaConfig;
import com.fdkk.fdkkmeta.domain.dto.RouteDto;
import com.fdkk.fdkkmeta.domain.entity.mysql.BreakpointsEntity;
import com.fdkk.fdkkmeta.domain.entity.mysql.MoveFrameEntity;
import com.fdkk.fdkkmeta.domain.entity.mysql.RotateFrameEntity;
import com.fdkk.fdkkmeta.domain.entity.mysql.UserEntity;
import com.fdkk.fdkkmeta.domain.po.*;
import com.fdkk.fdkkmeta.grpc.*;
import com.fdkk.fdkkmeta.redis.RedisCache;
import com.fdkk.fdkkmeta.service.BreakpointsService;
import com.fdkk.fdkkmeta.service.MoveFrameService;
import com.fdkk.fdkkmeta.service.RotateFrameService;
import com.fdkk.fdkkmeta.service.UserService;
import com.fdkk.fdkkmeta.util.ProtoJsonUtils;
import com.fdkk.fdkkmeta.util.kesar.GetRoute;
import io.grpc.stub.StreamObserver;
import lombok.extern.slf4j.Slf4j;
import net.devh.boot.grpc.server.service.GrpcService;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.File;
import java.util.Arrays;
import java.util.List;

/**
 * @author Xiewj
 * @date 2022/5/9
 */
@GrpcService
@Slf4j
public class sceneGrpcServer extends SceneGrpcServiceGrpc.SceneGrpcServiceImplBase {
    @Autowired
    MetaConfig metaConfig;

    @Autowired
    UserService userService;

    @Autowired
    BreakpointsService breakpointsService;
    @Autowired
    RotateFrameService rotateFrameService;

    @Autowired
    MoveFrameService moveFrameService;

    @Autowired
    RedisCache redisCache;

	@Autowired
	SceneGrpcService sceneGrpcService;
    /***
     *     回复 案例
     *    SceneReply res = SceneReply.newBuilder().setRes(id+","+name).build();
     *         responseObserver.onNext(res);
     */
    /*
    @Override
    public void testMethod(SceneRequest request, StreamObserver<SceneReply> responseObserver) {
        // grpc服务端获取调用端请求参数
        String id = request.getId();
        String name = request.getName();
        // 这里可以有自己的业务代码，只需要按照porto中的返回类型返回参数即可
        SceneReply res = SceneReply.newBuilder().setRes(id+","+name).build();
        responseObserver.onNext(res);
        responseObserver.onCompleted();
        log.info("回复{}",res);

    }
    */
    @Override
    public void getRoute(RouteRequest request, StreamObserver<RouteReply> responseObserver)   {
        // grpc服务端获取调用端请求参数
        String sceneCode = request.getSceneCode();
        Point sLocation = request.getSLocation();
        Point eLocation = request.getELocation();
        RouteDto po=new RouteDto();
        PointPO s=new PointPO();
        s.setX(Double.parseDouble(sLocation.getX()));
        s.setY(Double.parseDouble(sLocation.getY()));
        s.setZ(Double.parseDouble(sLocation.getY()));
        PointPO e=new PointPO();
        e.setX(Double.parseDouble(eLocation.getX()));
        e.setY(Double.parseDouble(eLocation.getY()));
        e.setZ(Double.parseDouble(eLocation.getY()));
        po.setE_location(e);
        po.setS_location(s);
        po.setSceneCode(sceneCode);
        JSONArray maps = GetRoute.getRoute(metaConfig.getFreespacePath()+ File.separator +"target_freespace.json", po);
        // 这里可以有自己的业务代码，只需要按照porto中的返回类型返回参数即可
        RouteReply.Builder builder = RouteReply.newBuilder();
        if (ArrayUtil.isNotEmpty(maps)) {
            for (int i = 0; i < maps.size(); i++) {
                RouteArray.Builder addInBuilder = builder.addInBuilder();
                ProtoJsonUtils.toProtoBean(addInBuilder, maps.get(i).toString());
            }

        }
        responseObserver.onNext(builder.build());
        responseObserver.onCompleted();
    }

    @Override
    public void init(InitRequest request, StreamObserver<NormalReply> responseObserver)   {

    	try {
    		String user_id = request.getUserId();
    		String nick_name = request.getNickName();
    		String skin_id = request.getSkinId();
    		String avatar_id = request.getAvatarId();
    		String room_id = request.getRoomId();
    		String app_id = request.getAppId();
			Space player =request.getPlayer();
            //保存user
            UserEntity userEntity=new UserEntity();

            userEntity.setAppId(app_id);
			userEntity.setUserId(user_id);
            userEntity.setAvatarId(avatar_id);
            userEntity.setNickName(nick_name);
            userEntity.setRoomId(room_id);
            userEntity.setSkinId(skin_id);
			userEntity.setFrameId(1L);
			userEntity.setBreakPointId(1L);
			userEntity.setOnline(true);

			Point playerPoint = player.getPosition();
			AngleUe4 playerAngle = player.getAngle();
			//初始化的时候可以写死
            AnglePO player_angle = new AnglePO();
            player_angle.setPitch(playerAngle.getPitch());
            player_angle.setYaw(playerAngle.getYaw());
            player_angle.setRoll(playerAngle.getRoll());
            userEntity.setPlayerAngle(player_angle);

			PointPO player_position = new PointPO();
			player_position.setX(Double.parseDouble(playerPoint.getX()));
			player_position.setY(Double.parseDouble(playerPoint.getY()));
			player_position.setZ(Double.parseDouble(playerPoint.getZ()));
			userEntity.setPlayerPosition(player_position);
            //数据库user表中创建用户记录
            userService.save(userEntity);

			JSONObject myState = new JSONObject();
			myState.put("isMoving",0);
			//redis中写入用户状态信息
			redisCache.setCacheObject("UserState:"+userEntity.getUserId(),myState);

			//返回
			NormalReply.Builder builder = NormalReply.newBuilder();
			builder.setCode(1);
			responseObserver.onNext(builder.build());
			responseObserver.onCompleted();
		}
    	catch(Exception e) {
    		e.printStackTrace();
			//builder.setCode(0);
    	}
    }

    @Override
    public void rotate(RotateRequest request, StreamObserver<NormalReply> responseObserver)   {
    	try {
			ActionPO rotateRequestPO = new ActionPO();

    		int action_type = request.getActionType();
    		String trace_id = request.getTraceId();
    		String user_id = request.getUserId();
    		RotationAction rotationAction = request.getRotationAction();

			UserEntity user = userService.findUserId(user_id);
			RotateFrameEntity rotateFrameEntity = rotateFrameService.findById(user.getFrameId());

			rotateRequestPO.setAction_type(action_type);
			rotateRequestPO.setTrace_id(trace_id);
			rotateRequestPO.setUser_id(user_id);

			double hAngle = rotationAction.getHorizontalMove() * 90;
			int offFrameIndex = (int)Math.ceil(hAngle);
			int currentFrame = rotateFrameEntity.getFrameIndex();      //从数据库里读取
			currentFrame +=offFrameIndex;
			if(currentFrame<0){
				currentFrame+=360;
			}
			else{
				currentFrame = currentFrame % 359;
			}

			rotateFrameEntity = rotateFrameService.findByAppIdAndBreakPointIdAndFrameIndex(user_id,user.getBreakPointId(),currentFrame);
			rotateRequestPO.setFrameId(rotateFrameEntity.getId());
			//每次存一帧
			redisCache.setCacheList("setCacheRequest:"+user_id, Arrays.asList(rotateRequestPO));
			//没有更新user表中的frame_id，因为这样太慢了，后续再处理
			NormalReply.Builder builder = NormalReply.newBuilder();
			builder.setCode(1);
			responseObserver.onNext(builder.build());
			responseObserver.onCompleted();
    	}
    	catch(Exception e) {
    		e.printStackTrace();
			//builder.setCode(0);
    	}
    }
	@Override
	public void echo(EchoRequest request, StreamObserver<EchoReply> responseObserver){

		try{
			int action_type = request.getActionType();
			String trace_id = request.getTraceId();

			EchoReply.Builder builder = EchoReply.newBuilder();
			builder.setActionType(action_type);
			builder.setPointType(100);
			builder.setExtra("");
			builder.setTraceId(trace_id);
			builder.setPacketId("");
			//builder.setNps(nps);
			builder.setPeopleNum(0);
			builder.setZoneId("");
			builder.setEchoMsg("");
			builder.setReserveDetail(null);
			//builder.setUserWithAvatarList();
			//builder.setNewUserStates();
			builder.setCode(0);
			builder.setMsg("");

			responseObserver.onNext(builder.build());
			responseObserver.onCompleted();
		}
		catch(Exception e) {
			e.printStackTrace();
		}
	}
	@Override
	public void usersState(GetNewUserStateRequest request, StreamObserver<GetNewUserStateReply> responseObserver){

		try{
			int action_type = request.getActionType();
			String trace_id = request.getTraceId();
			String user_id = request.getUserId();

			//从数据库中取全部在线的user表
			List<UserEntity> list =  userService.findUserOnline(true);

			GetNewUserStateReply.Builder builder = GetNewUserStateReply.newBuilder();
			builder.setActionType(action_type);
			builder.setPointType(100);
			builder.setExtra("");
			builder.setTraceId(trace_id);
			builder.setPacketId("");
			//builder.setNps(nps);
			builder.setPeopleNum(0);
			builder.setZoneId("");
			builder.setEchoMsg("");
			builder.setReserveDetail(null);
			//builder.setUserWithAvatarList();
			if(list.size()>0){
				for(int i=0;i<list.size();++i){
					UserEntity user = list.get(i);
					JSONObject userInfo = new JSONObject();
					userInfo.put("roomTypeId","");
					userInfo.put("person",0);
					userInfo.put("avatarId",user.getAvatarId());
					userInfo.put("skinId",user.getSkinId());
					userInfo.put("roomId",user.getRoomId());
					userInfo.put("isHost",false);
					userInfo.put("isFollowHost",false);
					userInfo.put("skinDataVersion",user.getSkinDataVersion());
					userInfo.put("avatarComponents","");
					userInfo.put("nickName",user.getNickName());
					userInfo.put("movingMode",0);                                      //后续会修改
					userInfo.put("attitude","walk");
					userInfo.put("areaName","");
					userInfo.put("pathName","");
					userInfo.put("pathId","thirdwalk");
					userInfo.put("avatarSize",1);
					Extra extra = Extra.newBuilder().setRemoveWhenDisconnected(true).build();
					userInfo.put("extra",extra);
					userInfo.put("prioritySync",false);

					Space.Builder player = Space.newBuilder();
					PointPO playerPosition = user.getPlayerPosition();
					Point playerPt = Point.newBuilder().setX(String.valueOf(playerPosition.getX())).setY(String.valueOf(playerPosition.getY())).setZ(String.valueOf(playerPosition.getZ())).build();
					player.setPosition(playerPt);
					AnglePO playerAngle = user.getPlayerAngle();
					AngleUe4 playerAg =AngleUe4.newBuilder().setPitch(playerAngle.getPitch()).setYaw(playerAngle.getYaw()).setRoll(playerAngle.getRoll()).build();
					player.setAngle(playerAg);
					userInfo.put("player",player);
					userInfo.put("camera",null);
					userInfo.put("cameraCenter",null);

					State playerState = sceneGrpcService.createPlayerState(userInfo);
					RenderInfo renderInfo = sceneGrpcService.createRenderInfo();
					Event event = sceneGrpcService.createEvent();

					UserState userState = sceneGrpcService.createUserState( user.getUserId(), playerState, renderInfo, event);
					builder.addNewUserStates(userState);
				}
			}
			//builder.setNewUserStates();
			builder.setCode(0);
			builder.setMsg("");

			responseObserver.onNext(builder.build());
			responseObserver.onCompleted();
		}
		catch (Exception e){
			e.printStackTrace();
		}
	}
	@Override
	public void move(MoveRequest request, StreamObserver<NormalReply> responseObserver){
		try{
			//int action_type= request.getActionType();
			ClickingAction clicking_action = request.getClickingAction();
			//State clicking_state = request.getClickingState();
			String trace_id = request.getTraceId();
			String user_id = request.getUserId();

			UserEntity user = userService.findUserId(user_id);
			String appId = user.getAppId();
			Long breakPointId = user.getBreakPointId();
			BreakpointsEntity currentBreakpointsEntity = breakpointsService.getById(breakPointId);
			Point end = clicking_action.getClickingPoint();
			RotateFrameEntity rotateFrameEntity = rotateFrameService.findById(user.getFrameId());
			//计算路径
			RouteDto po=new RouteDto();
			PointPO s= user.getPlayerPosition();
			PointPO e=new PointPO();
			e.setX(Double.parseDouble(end.getX()));
			e.setY(Double.parseDouble(end.getY()));
			e.setZ(Double.parseDouble(end.getZ()));
			po.setE_location(e);
			po.setS_location(s);
			po.setSceneCode(appId);
			JSONArray path = new JSONArray();
			JSONArray maps = GetRoute.getRoute(metaConfig.getFreespacePath()+ File.separator +appId+"_target_freespace.json", po);

			ActionPO movePO = new ActionPO();
			if (maps!=null&&maps.size()>=2){
				for(int i=0;i< maps.size();++i){
					Long _breakPointId = JSON.parseObject(JSONObject.toJSON(maps.get(i)).toString()).getLong("id");
					path.add(_breakPointId);
					//旋转矫正
					if(i == 1){
						AnglePO cameraAnglePO = rotateFrameEntity.getCameraAngle();
						//旋转矫正：不仅存入redis，而且返回矫正后的角度
						cameraAnglePO = setRotateForMove( user, trace_id, cameraAnglePO);
						movePO.setCameraAngle(cameraAnglePO);
					}
				}
				movePO.setAction_type(1);
				movePO.setTrace_id(trace_id);
				movePO.setUser_id(user_id);
				movePO.setPath(path);

				Long lastBreakPointId = JSON.parseObject(JSONObject.toJSON(maps.get(maps.size() -1)).toString()).getLong("id");
				BreakpointsEntity breakpointsEntity = breakpointsService.findByAppIdAndBreakPointId(appId,lastBreakPointId);
				int playerAngleYaw = sceneGrpcService.calAngleForBreakPointId(currentBreakpointsEntity,breakpointsEntity);
				AnglePO playerAngle = user.getPlayerAngle();
				playerAngle.setYaw(playerAngleYaw);
				movePO.setPlayerAngle(playerAngle);

				int subFrameIndex = moveFrameService.getCountByAppIAndStartBreakPointIdAndEndBreakPointIdAndAngle( user.getAppId(),path.getLongValue(0),path.getLongValue(1), movePO.getCameraAngle().getYaw()%45);
				movePO.setSubFrameIndex(subFrameIndex);
				redisCache.setCacheList("setCacheRequest:"+user_id, Arrays.asList(movePO));
			}

			NormalReply.Builder builder = NormalReply.newBuilder();
			builder.setCode(1);
			responseObserver.onNext(builder.build());
			responseObserver.onCompleted();
		}
		catch (Exception e){
			e.printStackTrace();
			//builder.setCode(0);
		}
	}

	private AnglePO setRotateForMove(UserEntity user,String trace_id,AnglePO cameraAngle){
		int angle = cameraAngle.getYaw();
		int offAngle = 0;
		offAngle = angle%45;

		//先简单来，就累加。后续要再调试
		//存储矫正的一组帧
		offAngle = Math.abs(45 - offAngle);
		RotateFrameEntity _rotateFrameEntity = null;
		for(int j=0;j<offAngle;++j){
			ActionPO rotateRequestPO = new ActionPO();
			rotateRequestPO.setAction_type(1014);
			rotateRequestPO.setTrace_id(trace_id);
			rotateRequestPO.setUser_id(user.getUserId());
			_rotateFrameEntity = rotateFrameService.findByAppIdAndBreakPointIdAndFrameIndex(user.getAppId(),user.getBreakPointId(),angle+j);
			rotateRequestPO.setFrameId(_rotateFrameEntity.getId());
			redisCache.setCacheList("setCacheRequest:"+user.getUserId(), Arrays.asList(rotateRequestPO));
		}
		if(_rotateFrameEntity == null){
			AnglePO cameraAnglePO = new AnglePO();
			cameraAnglePO.setPitch(0);
			cameraAnglePO.setYaw(angle);
			cameraAnglePO.setRoll(0);
			return cameraAnglePO;
		}
		else{
			return _rotateFrameEntity.getCameraAngle();
		}
	}

    @Override
    public void getBreakPoint(BreakPointRequest request, StreamObserver<BreakPointReply> responseObserver)   {
     	try {
            log.info("进入{}",request);

            int action_type = request.getActionType();
            NeighborPointsAction get_neighbor_points_action = request.getGetNeighborPointsAction();
     		String trace_id = request.getTraceId();
     		String user_id = request.getUserId();

     		//从表breakpoints里获取所有的呼吸点，并且是数组
            //TODO 根据查询所有
            UserEntity userEntity = userService.findUserId(user_id);
            List<BreakpointsEntity> allList = breakpointsService.findByAppId(userEntity.getAppId());

            Point[] nps=null;
            BreakPointReply res = BreakPointReply.newBuilder()
     				.setActionType(action_type)
     				.setPointType(100)
     				.setExtra("")
     				.setTraceId(trace_id)
     				.setPacketId("")
     				//.setNps(nps)
     				.setPeopleNum(0)
     				.setZoneId("")
     				.setEchoMsg("")
     				.setReserveDetail(null)
     				//.setUserWithAvatarList()
     				//.setNewUserStates()
     				.setCode(0)
     				.setMsg("")
     				.build();
            responseObserver.onNext(res);
            responseObserver.onCompleted();
            log.info("回复{}",res);
    	}
    	catch(Exception e) {
    		e.printStackTrace();
    	}
    }

    //操作杆
    @Override
    public void joystick(JoystickRequest request, StreamObserver<NormalReply> responseObserver)   {
     	try {
            log.info("进入{}",request);
            int actionType = request.getActionType();
            DirAction dirAction = request.getDirAction();
     		String trace_id = request.getTraceId();
     		String user_id = request.getUserId();
     		String packet_id = request.getPacketId();

			ActionPO joystickPO = new ActionPO();
			joystickPO.setAction_type(actionType);
			joystickPO.setTrace_id(trace_id);
			joystickPO.setUser_id(user_id);
			joystickPO.setPacket_id(packet_id);
			AnglePO playerAngle = joystickPO.getPlayerAngle();
			playerAngle.setYaw(dirAction.getMoveAngle());
			joystickPO.setPlayerAngle(playerAngle);
			redisCache.setCacheList("setCacheRequest:"+user_id, Arrays.asList(joystickPO));
			//速度不够，只是让人旋转
			if(dirAction.getSpeedLevel()<7){
				return;
			}

			UserEntity user = userService.findUserId(user_id);
			//邻居点里找角度最合适的点
			BreakpointsEntity breakpointsEntity = breakpointsService.findByAppIdAndBreakPointId(user.getAppId(), user.getBreakPointId());
			BreakpointsEntity targetBreakpointsEntity = null;
			List<Integer> neighBreakPointIds = breakpointsEntity.getContact();

			double offAngle = 1000;
			double moveAngle = dirAction.getMoveAngle();
			int playerAngleYaw = 0;

			if(neighBreakPointIds.size()>0){
				for(int j=0;j<neighBreakPointIds.size();++j){
					BreakpointsEntity _breakpointsEntity = breakpointsService.findByAppIdAndBreakPointId(user.getAppId(), (long)neighBreakPointIds.get(j));
					playerAngleYaw = sceneGrpcService.calAngleForBreakPointId(breakpointsEntity,_breakpointsEntity);
					if(Math.abs(playerAngleYaw - moveAngle)<offAngle){
						offAngle = Math.abs(playerAngleYaw - moveAngle);
						targetBreakpointsEntity = _breakpointsEntity;
					}
				}
				RotateFrameEntity rotateFrameEntity = rotateFrameService.findById(user.getFrameId());
				AnglePO cameraAnglePO = rotateFrameEntity.getCameraAngle();
				cameraAnglePO = setRotateForMove( user, trace_id,cameraAnglePO);
				JSONArray path = new JSONArray();
				path.add(user.getBreakPointId());
				path.add(targetBreakpointsEntity.getBreakPointId());

				ActionPO movePO = new ActionPO();
				movePO.setAction_type(1);
				movePO.setTrace_id(trace_id);
				movePO.setUser_id(user_id);
				movePO.setPath(path);

				playerAngle.setYaw(playerAngleYaw);
				movePO.setPlayerAngle(playerAngle);

				movePO.setCameraAngle(cameraAnglePO);

				int subFrameIndex = moveFrameService.getCountByAppIAndStartBreakPointIdAndEndBreakPointIdAndAngle( user.getAppId(),user.getBreakPointId(),targetBreakpointsEntity.getBreakPointId(), cameraAnglePO.getYaw()%45);
				movePO.setSubFrameIndex(subFrameIndex);

				redisCache.setCacheList("setCacheRequest:"+user_id, Arrays.asList(movePO));
			}
			//找到与角度move_angle最近的邻居点
     		//移动player，并且更新相机角度
			NormalReply.Builder builder = NormalReply.newBuilder();
			builder.setCode(1);
			responseObserver.onNext(builder.build());
			responseObserver.onCompleted();
    	}
    	catch(Exception e) {
    		e.printStackTrace();
    	}
    }

    @Override
	public void exit(ExitRequest request, StreamObserver<NormalReply> responseObserver){
        try{

            //删除redis:"setCacheRequest:"+user_id
            //删除redis:"UserState:"+user.getUserId()
            //删除redis:"updateFrameMetadata:"+user.getUserId()
            //删除user表的记录

            NormalReply.Builder builder = NormalReply.newBuilder();
            builder.setCode(1);
            responseObserver.onNext(builder.build());
            responseObserver.onCompleted();
        }
        catch(Exception e){

        }
    }
}