1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public static boolean emptySpaceExists(Board b) {
    int n = b.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (b.tile(i,j) == null) {
                return true;
            }
        }
    }
    return false;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public static boolean maxTileExists(Board b) {
    int n = b.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (b.tile(i,j) == null) {
                continue;
            }
            if (b.tile(i,j).value() == MAX_PIECE) {
                return true;
            }
        }
    }
    return false;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public static boolean atLeastOneMoveExists(Board b) {
    if (emptySpaceExists(b)) {
        return true;
    }
    int n = b.size();
    // check whether horizontal adjacent tiles exists
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n; j++) {
            if (b.tile(i,j) == null || b.tile(i+1,j) == null) {
                continue;
            }
            if (b.tile(i,j).value() == b.tile(i+1,j).value()) {
                return true;
            }
        }
    }
    // check whether vertical adjacent tiles exists
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n-1; j++) {
            if (b.tile(i,j) == null || b.tile(i,j+1) == null) {
                continue;
            }
            if (b.tile(i,j).value() == b.tile(i,j+1).value()) {
                return true;
            }
        }
    }
    return false;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

/** Tilt the board toward SIDE. Return true iff this changes the board.
 *
 * 1. If two Tile objects are adjacent in the direction of motion and have
 *    the same value, they are merged into one Tile of twice the original
 *    value and that new value is added to the score instance variable
 * 2. A tile that is the result of a merge will not merge again on that
 *    tilt. So each move, every tile will only ever be part of at most one
 *    merge (perhaps zero).
 * 3. When three adjacent tiles in the direction of motion have the same
 *    value, then the leading two tiles in the direction of motion merge,
 *    and the trailing tile does not.
 * */
public boolean tilt(Side side) {
    boolean changed;
    changed = false;

    // TODO: Modify this.board (and perhaps this.score) to account
    // for the tilt to the Side SIDE. If the board changed, set the
    // changed local variable to true.
    board.setViewingPerspective(side);
    int n = board.size();
    for (int col = 0; col < n; col++) {
        if(tiltColumnNorth(col)) {
            changed = true;
        }
    }
    board.setViewingPerspective(Side.NORTH);

    checkGameOver();
    if (changed) {
        setChanged();
    }
    return changed;
}

/** Tilt a certain column towards NORTH,
 * if changed, return true;
 * else, return false */
public boolean tiltColumnNorth(int col) {
    int n = board.size();
    int lastTileRow = n;
    boolean changed = false;
    boolean isLastMerged = false;
    int lastValue = -1;
    for (int row = n-1; row >= 0; row--) {
        Tile t = board.tile(col, row);
        if (t == null) {
            continue;
        }
        int val = t.value();
        switch (calculateState(lastTileRow, isLastMerged,
                lastValue,val,row)) {
            // don't move
            case 0:
                lastTileRow--;
                isLastMerged = false;
                lastValue = val;
                break;
            // move, don't merge
            case 1:
                board.move(col, lastTileRow-1, t);
                changed = true;
                isLastMerged = false;
                lastTileRow--;
                lastValue = val;
                break;
            //move and merge
            case 2:
                board.move(col, lastTileRow, t);
                changed = true;
                isLastMerged = true;
                score += 2*val;
                lastValue = 2*val;
                break;
        }
    }
    return changed;
}

/** Calculate state.
 * if return 0, don't move
 * if return 1, move but don't merge
 * if return 2, move and merge
 */
public int calculateState(int lastTileRow, boolean isLastMerged, int lastValue, int val, int row) {
    if (row == lastTileRow-1 && lastValue != val) {
        return 0;
    } else if (val != lastValue || isLastMerged) {
        return 1;
    } else {
        return 2;
    }
}