Examples with NormalOrder common.datastore.order.NormalOrder used on opensource projects

Example 1 with NormalOrder

use of common.datastore.order.NormalOrder in project solution-finder by knewjade.

the class CheckmateUsingHoldReuse method search.

@Override
public List<Result> search(Field initFieldOrigin, Piece[] pieces, Candidate<T> candidate, int maxClearLine, int maxDepth) {
    Field initField = initFieldOrigin.freeze(maxClearLine);
    int deleteLine = initField.clearLine();
    int height = maxClearLine - deleteLine;
    TreeSet<Order> orders = new TreeSet<>();
    // 最初の探索開始depthとordersを調整
    int startDepth;
    if (!equalsField(lastField, initField) || lastPieces == null) {
        // mementoの初期化
        // 初めから
        memento = new ArrayList<>();
        orders.add(new NormalOrder(initField, pieces[0], height, maxDepth));
        startDepth = 1;
        memento.add(new TreeSet<>(orders));
    } else {
        int reuseIndex = -1;
        int minLength = lastPieces.length < pieces.length ? lastPieces.length : pieces.length;
        int max = maxDepth + 1 < minLength ? maxDepth + 1 : minLength;
        for (int index = 0; index < max; index++) {
            if (lastPieces[index] == pieces[index])
                reuseIndex = index;
            else
                break;
        }
        if (reuseIndex < 0) {
            memento = new ArrayList<>();
            orders.add(new NormalOrder(initField, pieces[0], height, maxDepth));
            startDepth = 1;
            memento.add(new TreeSet<>(orders));
        } else if (reuseIndex == maxDepth) {
            return dataPool.getResults();
        } else {
            orders.addAll(memento.get(reuseIndex));
            startDepth = reuseIndex + 1;
            memento = memento.subList(0, reuseIndex + 1);
        }
    }
    dataPool.resetResults();
    for (int depth = startDepth; depth <= maxDepth; depth++) {
        dataPool.initEachDepth();
        boolean isLast = depth == maxDepth;
        if (depth < pieces.length) {
            Piece drawn = pieces[depth];
            for (int count = 0, size = orders.size(); count < size; count++) {
                Order order = orders.pollFirst();
                searcherCore.stepWithNext(candidate, drawn, order, isLast);
            }
        } else {
            for (int count = 0, size = orders.size(); count < size; count++) {
                Order order = orders.pollFirst();
                searcherCore.stepWhenNoNext(candidate, order, isLast);
            }
        }
        orders = dataPool.getNexts();
        memento.add(new TreeSet<>(orders));
    }
    lastPieces = pieces;
    lastField = initField;
    return dataPool.getResults();
}

Example 2 with NormalOrder

use of common.datastore.order.NormalOrder in project solution-finder by knewjade.

the class SimpleSearcherCore method step.

private void step(Candidate<T> candidate, Piece drawn, Piece nextHold, Order order, boolean isLast) {
    Field currentField = order.getField();
    int max = order.getMaxClearLine();
    Set<T> candidateList = candidate.search(currentField, drawn, max);
    OperationHistory history = order.getHistory();
    for (T action : candidateList) {
        Field field = currentField.freeze(max);
        Mino mino = minoFactory.create(drawn, action.getRotate());
        field.put(mino, action.getX(), action.getY());
        int clearLine = field.clearLine();
        int maxClearLine = max - clearLine;
        if (!validator.validate(field, maxClearLine))
            continue;
        if (validator.satisfies(field, maxClearLine)) {
            Result result = new Result(order, drawn, action, nextHold);
            dataPool.addResult(result);
            continue;
        }
        if (isLast)
            continue;
        OperationHistory nextHistory = history.recordAndReturnNew(drawn, action);
        Order nextOrder = new NormalOrder(field, nextHold, maxClearLine, nextHistory);
        dataPool.addOrder(nextOrder);
    }
}

Example 3 with NormalOrder

use of common.datastore.order.NormalOrder in project solution-finder by knewjade.

the class PutterNoHold method first.

public TreeSet<Order> first(Field initField, Piece[] headPieces, Candidate<T> candidate, int maxClearLine, int maxDepth) {
    Field freeze = initField.freeze(maxClearLine);
    int deleteLine = freeze.clearLine();
    dataPool.initFirst(new NormalOrder(freeze, null, maxClearLine - deleteLine, maxDepth));
    for (int depth = 0; depth < headPieces.length; depth++) {
        TreeSet<Order> orders = dataPool.getNexts();
        dataPool.initEachDepth();
        boolean isLast = depth == maxDepth - 1;
        for (int count = 0, size = orders.size(); count < size; count++) {
            Order order = orders.pollFirst();
            searcherCore.stepWithNextNoHold(candidate, headPieces[depth], order, isLast);
        }
    }
    return dataPool.getNexts();
}

Example 4 with NormalOrder

use of common.datastore.order.NormalOrder in project solution-finder by knewjade.

the class CheckmateUsingHold method search.

@Override
public List<Result> search(Field initField, Piece[] pieces, Candidate<T> candidate, int maxClearLine, int maxDepth) {
    Field freeze = initField.freeze(maxClearLine);
    int deleteLine = freeze.clearLine();
    dataPool.initFirst(new NormalOrder(freeze, pieces[0], maxClearLine - deleteLine, maxDepth));
    for (int depth = 1; depth <= maxDepth; depth++) {
        TreeSet<Order> orders = dataPool.getNexts();
        dataPool.initEachDepth();
        boolean isLast = depth == maxDepth;
        if (depth < pieces.length) {
            Piece drawn = pieces[depth];
            for (int count = 0, size = orders.size(); count < size; count++) {
                Order order = orders.pollFirst();
                searcherCore.stepWithNext(candidate, drawn, order, isLast);
            }
        } else {
            for (int count = 0, size = orders.size(); count < size; count++) {
                Order order = orders.pollFirst();
                searcherCore.stepWhenNoNext(candidate, order, isLast);
            }
        }
    }
    return dataPool.getResults();
}

Example 5 with NormalOrder

use of common.datastore.order.NormalOrder in project solution-finder by knewjade.

the class PutterUsingHold method first.

public TreeSet<Order> first(Field initField, Piece[] headPieces, Candidate<T> candidate, int maxClearLine, int maxDepth) {
    Field freeze = initField.freeze(maxClearLine);
    int deleteLine = freeze.clearLine();
    dataPool.initFirst(new NormalOrder(freeze, headPieces[0], maxClearLine - deleteLine, maxDepth));
    int firstMaxDepth = headPieces.length;
    for (int depth = 1; depth <= firstMaxDepth; depth++) {
        TreeSet<Order> orders = dataPool.getNexts();
        dataPool.initEachDepth();
        boolean isLast = depth == maxDepth;
        if (depth < headPieces.length) {
            Piece drawn = headPieces[depth];
            for (int count = 0, size = orders.size(); count < size; count++) {
                Order order = orders.pollFirst();
                searcherCore.stepWithNext(candidate, drawn, order, isLast);
            }
        } else {
            for (int count = 0, size = orders.size(); count < size; count++) {
                Order order = orders.pollFirst();
                searcherCore.stepWhenNoNext(candidate, order, isLast);
            }
        }
    }
    return dataPool.getNexts();
}