#

Junjie

1 天以前 d07e0c1a8961b61557de3812450ddfd227f773de

 src/main/java/com/zy/core/utils/StationOperateProcessUtils.java

@@ -834,7 +834,7 @@
            Integer circleTarget = resolveNextCircleOrderTarget(
                    currentStationId,
                    outOrderStationIds,
                    loopEvaluation.isLargeLoopTriggered()
                    loopEvaluation.getExpectedLoopIssueCount()
            );
            if (circleTarget == null) {
                News.taskInfo(wrkMast.getWrkNo(), "目标站当前不可进，且未找到可执行的下一排序检测点，当前站点={}", currentStationId);
@@ -851,7 +851,7 @@
        Integer circleTarget = resolveNextCircleOrderTarget(
                currentStationId,
                outOrderStationIds,
                loopEvaluation.isLargeLoopTriggered()
                loopEvaluation.getExpectedLoopIssueCount()
        );
        if (circleTarget == null) {
            News.taskInfo(wrkMast.getWrkNo(), "未找到可执行的下一排序检测点，当前站点={}", currentStationId);
@@ -1018,16 +1018,14 @@

    private Integer resolveNextCircleOrderTarget(Integer currentStationId,
                                                 List<Integer> orderedOutStationList,
                                                 boolean preferLargeCircle) {
                                                 Integer expectedLoopIssueCount) {
        if (currentStationId == null || orderedOutStationList == null || orderedOutStationList.size() <= 1) {
            return null;
        }

        int startIndex = orderedOutStationList.indexOf(currentStationId);
        int total = orderedOutStationList.size();
        Integer bestStationId = null;
        int bestPathLength = -1;
        int bestOffset = -1;
        List<CircleTargetCandidate> candidateList = new ArrayList<>();
        for (int offset = 1; offset < total; offset++) {
            int candidateIndex = (startIndex + offset + total) % total;
            Integer candidateStationId = orderedOutStationList.get(candidateIndex);
@@ -1037,19 +1035,60 @@
            try {
                List<NavigateNode> path = navigateUtils.calcByStationId(currentStationId, candidateStationId);
                if (path != null && !path.isEmpty()) {
                    if (!preferLargeCircle) {
                        return candidateStationId;
                    }
                    int pathLength = path.size();
                    if (pathLength > bestPathLength || (pathLength == bestPathLength && offset > bestOffset)) {
                        bestStationId = candidateStationId;
                        bestPathLength = pathLength;
                        bestOffset = offset;
                    }
                    candidateList.add(new CircleTargetCandidate(candidateStationId, path.size(), offset));
                }
            } catch (Exception ignore) {}
        }
        return bestStationId;
        if (candidateList.isEmpty()) {
            return null;
        }
        candidateList.sort(new Comparator<CircleTargetCandidate>() {
            @Override
            public int compare(CircleTargetCandidate left, CircleTargetCandidate right) {
                if (left == right) {
                    return 0;
                }
                if (left == null) {
                    return 1;
                }
                if (right == null) {
                    return -1;
                }
                int pathCompare = Integer.compare(left.getPathLength(), right.getPathLength());
                if (pathCompare != 0) {
                    return pathCompare;
                }
                return Integer.compare(left.getOffset(), right.getOffset());
            }
        });
        return resolveGradualCircleTargetByPathLength(expectedLoopIssueCount, candidateList);
    }

    private Integer resolveGradualCircleTargetByPathLength(Integer expectedLoopIssueCount,
                                                           List<CircleTargetCandidate> candidateList) {
        if (candidateList == null || candidateList.isEmpty()) {
            return null;
        }
        if (expectedLoopIssueCount == null || expectedLoopIssueCount <= 2) {
            return candidateList.get(0).getStationId();
        }

        List<CircleTargetCandidate> tierList = new ArrayList<>();
        Integer lastPathLength = null;
        for (CircleTargetCandidate candidate : candidateList) {
            if (candidate == null) {
                continue;
            }
            if (lastPathLength == null || !Objects.equals(lastPathLength, candidate.getPathLength())) {
                tierList.add(candidate);
                lastPathLength = candidate.getPathLength();
            }
        }
        if (tierList.isEmpty()) {
            return candidateList.get(0).getStationId();
        }
        int tierIndex = Math.min(expectedLoopIssueCount - 2, tierList.size() - 1);
        return tierList.get(tierIndex).getStationId();
    }

    private boolean tryAcquireOutOrderDispatchLock(Integer wrkNo, Integer stationId) {
@@ -1518,6 +1557,30 @@
        }
    }

    private static class CircleTargetCandidate {
        private final Integer stationId;
        private final Integer pathLength;
        private final Integer offset;

        private CircleTargetCandidate(Integer stationId, Integer pathLength, Integer offset) {
            this.stationId = stationId;
            this.pathLength = pathLength == null ? 0 : pathLength;
            this.offset = offset == null ? 0 : offset;
        }

        private Integer getStationId() {
            return stationId;
        }

        private Integer getPathLength() {
            return pathLength;
        }

        private Integer getOffset() {
            return offset;
        }
    }

    private void saveLoopLoadReserve(Integer wrkNo, LoopHitResult loopHitResult) {
        if (wrkNo == null || wrkNo <= 0 || loopHitResult == null || !loopHitResult.isThroughLoop()) {
            return;