Package com.barrybecker4.puzzle.tantrix.solver.path

Examples of com.barrybecker4.puzzle.tantrix.solver.path.TantrixPath

46
47
48
49
50
51
52
53
54
55
56
57
     * @return list of moves to a solution.
     */
    @Override
    public TilePlacementList solve()  {

        ParameterArray initialGuess = new TantrixPath(board);
        assert(initialGuess.size() > 0) : "The random path should have some tiles!";
        long startTime = System.currentTimeMillis();

        Optimizer optimizer = new Optimizer(this);
        optimizer.setListener(this);

View Full Code Here
112
113
114
115
116
117
118
119
120
     * We show the current status.
     * @param params
     */
    public void optimizerChanged(ParameterArray params) {
        // update our current best guess at the solution.
        TantrixPath path = (TantrixPath)params;
        solution_ = new TantrixBoard(path.getTilePlacements(), path.getPrimaryPathColor());
        puzzlePanel_.refresh(solution_, numTries_++);
    }
View Full Code Here
34
35
36
37
38
39
40
            //if (placement == null) {
            //    currentBoard.undoLastPlaced();
            //}
            currentBoard = currentBoard.placeTile(placement);
        }
        return new TantrixPath(currentBoard.getTantrix(), initialBoard.getPrimaryColor());
    }
View Full Code Here
65
66
67
68
69
70
71
            tiles.add(currentTilePlacement);
            origLocation = previousTilePlacement.getLocation(); //currentTilePlacement.getLocation();
            previousTilePlacement = currentTilePlacement;
        }

        return new TantrixPath(tiles, primaryColor);
    }
View Full Code Here
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
        this.originalPath = path;
        this.color = path.getPrimaryPathColor();
    }

    public TantrixPath permute(List<Integer> oldIndices, List<Integer> newIndices) {
        TantrixPath permutedPath = originalPath.copy();

        TilePlacementList auxList = new TilePlacementList();

        //System.out.println("new indices = " + newIndices);
        //System.out.println("old indices = " + oldIndices);

        for (int i=0; i<oldIndices.size(); i++) {
           auxList.set(i, permutedPath.getTilePlacements().get(newIndices.get(i)));
        }

        PrimaryPathFitter fitter =
                new PrimaryPathFitter(permutedPath.getTilePlacements(), color);

        TilePlacementList origPlacements = permutedPath.getTilePlacements();
        for (int i=0; i<newIndices.size(); i++) {

            int oldIndex = oldIndices.get(i);
            TilePlacement oldPlacement = auxList.get(i);
            TilePlacement newPlacement =
View Full Code Here
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
        PathTilePermuter permuter = new PathTilePermuter(originalPath);

        if (indices.size() == 2) {
            List<Integer> newOrder = new ArrayList<Integer>(indices);
            Collections.reverse(newOrder);
            TantrixPath permutedPath = permuter.permute(newOrder, indices);
            permutedPaths.add(permutedPath);
        }
        else if (indices.size() > 2) {
            // add the original originalPath for now, to be sure we do not duplicated it, but return at end.
            permutedPaths.add(originalPath);

            int numIter = Math.min(originalPath.size() + 1, MAX_ITER);

            for (int i = 0; i < numIter; i++) {
                List<Integer> newOrder = new ArrayList<Integer>(indices);
                Collections.shuffle(newOrder, MathUtil.RANDOM);
                TantrixPath permutedPath = permuter.permute(newOrder, indices);
                if (!permutedPaths.contains(permutedPath)) {
                    permutedPaths.add(permutedPath);
                }
            }
            permutedPaths.remove(0);
View Full Code Here
61
62
63
64
65
66
67
             tiles.add(currentTilePlacement);
             origLocation = previousTilePlacement.getLocation();
             previousTilePlacement = currentTilePlacement;
         }

         return new TantrixPath(tiles, primaryColor);
    }
View Full Code Here
48
49
50
51
52
53
54
55
56
57
58
59
60
        int lowerIndexStart = 1;
        int upperIndexStop = path_.size() - 2;

        for (int i=lowerIndexStart; i<upperIndexStop; i++) {
            for (int j=upperIndexStop; j>=i; j--) {
                TantrixPath subPath1 = path_.subPath(i - 1, 0);
                pivotPath = path_.subPath(i, j);
                TantrixPath subPath2 =  path_.subPath(j + 1, path_.size() - 1);
                pathPermutations.addAll( createPermutedPathList(subPath1, subPath2));
            }
        }

        return pathPermutations;
View Full Code Here
67
68
69
70
71
72
73
74
75
76
77
    public List<TantrixPath> findPermutedPaths(int pivotIndex1, int pivotIndex2) {

        int lowerIndex = Math.min(pivotIndex1, pivotIndex2);
        int upperIndex = Math.max(pivotIndex1, pivotIndex2);

        TantrixPath subPath1 = path_.subPath(lowerIndex - 1, 0);
        pivotPath = path_.subPath(lowerIndex, upperIndex);
        TantrixPath subPath2 =  path_.subPath(upperIndex + 1, path_.size() - 1);

        return createPermutedPathList(subPath1, subPath2);
    }
View Full Code Here
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
        SubPathMutator swapper = new SubPathSwapper(primaryColor);
        SubPathMutator reverser = new SubPathReverser(primaryColor);
        TilePlacement firstPivot = pivotPath.getFirst();
        TilePlacement lastPivot = pivotPath.getLast();

        TantrixPath subPath1Reversed = reverser.mutate(firstPivot, subPath1);
        TantrixPath subPath2Reversed = reverser.mutate(lastPivot, subPath2);
        TantrixPath subPath1Swapped = swapper.mutate(firstPivot, subPath1);
        TantrixPath subPath2Swapped = swapper.mutate(lastPivot, subPath2);
        TantrixPath subPath1RevSwapped = swapper.mutate(firstPivot, subPath1Reversed);
        TantrixPath subPath2RevSwapped = swapper.mutate(lastPivot, subPath2Reversed);

        List<TantrixPath> pathPermutations = new ArrayList<TantrixPath>();

        addIfNotNull(createPermutedPath(subPath1, subPath2Reversed), pathPermutations);
        addIfNotNull(createPermutedPath(subPath1Reversed, subPath2), pathPermutations);
View Full Code Here
TOP

Related Classes of com.barrybecker4.puzzle.tantrix.solver.path.TantrixPath

  • com.barrybecker4.common.app.CommandLineOptions
  • com.barrybecker4.common.concurrency.Worker
  • com.barrybecker4.common.expression.mathexpression.MathExpressionParser
  • com.barrybecker4.common.expression.TreeNode
  • com.barrybecker4.common.geometry.ByteLocation
  • com.barrybecker4.common.geometry.Location
  • com.barrybecker4.common.i18n.LocaleType
  • com.barrybecker4.common.math.cutpoints.AbstractCutPointFinder
  • com.barrybecker4.common.math.function.ArrayFunction
  • com.barrybecker4.common.math.function.CountFunction
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.