minesweeper/src/main/java/org/apidesign/demo/minesweeper/MinesModel.java
author Jaroslav Tulach <jaroslav.tulach@apidesign.org>
Fri, 27 Jun 2014 16:14:57 +0200
changeset 166 e6667c8206fc
parent 165 276db4d4d795
child 174 a57b2414b855
permissions -rw-r--r--
Indicate the mine selection mode by blinking the danger sign on all undiscovered squares
jtulach@63
     1
/**
jtulach@63
     2
 * The MIT License (MIT)
jtulach@63
     3
 *
jtulach@63
     4
 * Copyright (C) 2013 Jaroslav Tulach <jaroslav.tulach@apidesign.org>
jtulach@63
     5
 *
jtulach@63
     6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
jtulach@63
     7
 * of this software and associated documentation files (the "Software"), to deal
jtulach@63
     8
 * in the Software without restriction, including without limitation the rights
jtulach@63
     9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
jtulach@63
    10
 * copies of the Software, and to permit persons to whom the Software is
jtulach@63
    11
 * furnished to do so, subject to the following conditions:
jtulach@63
    12
 *
jtulach@63
    13
 * The above copyright notice and this permission notice shall be included in
jtulach@63
    14
 * all copies or substantial portions of the Software.
jtulach@63
    15
 *
jtulach@63
    16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
jtulach@63
    17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
jtulach@63
    18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
jtulach@63
    19
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
jtulach@63
    20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
jtulach@63
    21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
jtulach@63
    22
 * THE SOFTWARE.
jtulach@63
    23
 */
jtulach@63
    24
package org.apidesign.demo.minesweeper;
jtulach@63
    25
jtulach@63
    26
import java.util.ArrayList;
jtulach@63
    27
import java.util.List;
jtulach@63
    28
import java.util.Random;
jtulach@63
    29
import net.java.html.json.ComputedProperty;
jtulach@63
    30
import net.java.html.json.Function;
jtulach@63
    31
import net.java.html.json.Model;
jtulach@63
    32
import net.java.html.json.ModelOperation;
jtulach@63
    33
import net.java.html.json.Property;
jtulach@79
    34
import net.java.html.sound.AudioClip;
jtulach@63
    35
jtulach@63
    36
/** Model of the mine field.
jtulach@63
    37
 */
jtulach@63
    38
@Model(className = "Mines", properties = {
jtulach@63
    39
    @Property(name = "state", type = MinesModel.GameState.class),
jtulach@63
    40
    @Property(name = "rows", type = Row.class, array = true),
jtulach@63
    41
})
jtulach@90
    42
public final class MinesModel {
jtulach@63
    43
    enum GameState {
jaroslav@164
    44
        IN_PROGRESS, MARKING_MINE, WON, LOST;
jtulach@63
    45
    }
jtulach@63
    46
    
jaroslav@166
    47
    @ComputedProperty static String gameStyle(GameState state) {
jaroslav@166
    48
        return state == GameState.MARKING_MINE ? "MARKING" : null;
jaroslav@166
    49
    }
jaroslav@166
    50
    
jtulach@63
    51
    @Model(className = "Row", properties = {
jtulach@63
    52
        @Property(name = "columns", type = Square.class, array = true)
jtulach@63
    53
    })
jtulach@63
    54
    static class RowModel {
jtulach@63
    55
    }
jtulach@63
    56
jtulach@63
    57
    @Model(className = "Square", properties = {
jtulach@63
    58
        @Property(name = "state", type = SquareType.class),
jtulach@63
    59
        @Property(name = "mine", type = boolean.class)
jtulach@63
    60
    })
jtulach@63
    61
    static class SquareModel {
jtulach@65
    62
        @ComputedProperty static String style(SquareType state) {
jtulach@65
    63
            return state == null ? null : state.toString();
jtulach@65
    64
        }
jtulach@63
    65
    }
jtulach@63
    66
    
jtulach@63
    67
    enum SquareType {
jtulach@63
    68
        N_0, N_1, N_2, N_3, N_4, N_5, N_6, N_7, N_8,
jaroslav@164
    69
        UNKNOWN, EXPLOSION, DISCOVERED, MARKED;
jtulach@64
    70
        
jtulach@64
    71
        final boolean isVisible() {
jtulach@64
    72
            return name().startsWith("N_");
jtulach@64
    73
        }
jtulach@64
    74
jtulach@69
    75
        final SquareType moreBombsAround() {
jtulach@68
    76
            switch (this) {
jtulach@68
    77
                case EXPLOSION:
jtulach@68
    78
                case UNKNOWN:
jtulach@68
    79
                case DISCOVERED:
jtulach@68
    80
                case N_8:
jtulach@68
    81
                    return this;
jtulach@64
    82
            }
jtulach@64
    83
            return values()[ordinal() + 1];
jtulach@64
    84
        }
jtulach@63
    85
    }
jtulach@63
    86
    
jtulach@76
    87
    @ComputedProperty static boolean fieldShowing(GameState state) {
jtulach@76
    88
        return state != null;
jtulach@76
    89
    }
jtulach@76
    90
    
jtulach@76
    91
    @Function static void showHelp(Mines model) {
jtulach@76
    92
        model.setState(null);
jtulach@76
    93
    }
jtulach@76
    94
    
jtulach@70
    95
    @Function static void smallGame(Mines model) {
jtulach@70
    96
        model.init(5, 5, 5);
jtulach@70
    97
    }
jtulach@70
    98
    @Function static void normalGame(Mines model) {
jtulach@70
    99
        model.init(10, 10, 10);
jtulach@70
   100
    }
jtulach@70
   101
    
jtulach@72
   102
    @Function static void giveUp(Mines model) {
jtulach@72
   103
        showAllBombs(model, SquareType.EXPLOSION);
jaroslav@152
   104
        model.setState(GameState.LOST);
jtulach@72
   105
    }
jtulach@72
   106
    
jaroslav@164
   107
    @Function static void markMine(Mines model) {
jaroslav@164
   108
        if (model.getState() == GameState.IN_PROGRESS) {
jaroslav@164
   109
            model.setState(GameState.MARKING_MINE);
jaroslav@164
   110
        }
jaroslav@164
   111
    }
jaroslav@164
   112
    
jtulach@63
   113
    @ModelOperation static void init(Mines model, int width, int height, int mines) {
jtulach@107
   114
        List<Row> rows = model.getRows();
jtulach@107
   115
        if (rows.size() != height || rows.get(0).getColumns().size() != width) {
jtulach@107
   116
            rows = new ArrayList<Row>(height);
jtulach@107
   117
            for (int y = 0; y < height; y++) {
jtulach@107
   118
                Square[] columns = new Square[width];
jtulach@107
   119
                for (int x = 0; x < width; x++) {
jtulach@107
   120
                    columns[x] = new Square(SquareType.UNKNOWN, false);
jtulach@107
   121
                }
jtulach@107
   122
                rows.add(new Row(columns));
jtulach@63
   123
            }
jtulach@107
   124
        } else {
jtulach@107
   125
            for (Row row : rows) {
jtulach@107
   126
                for (Square sq : row.getColumns()) {
jtulach@107
   127
                    sq.setState(SquareType.UNKNOWN);
jtulach@107
   128
                    sq.setMine(false);
jtulach@107
   129
                }
jtulach@107
   130
            }
jtulach@63
   131
        }
jtulach@63
   132
        
jtulach@63
   133
        Random r = new Random();
jtulach@63
   134
        while (mines > 0) {
jtulach@63
   135
            int x = r.nextInt(width);
jtulach@63
   136
            int y = r.nextInt(height);
jtulach@63
   137
            final Square s = rows.get(y).getColumns().get(x);
jtulach@63
   138
            if (s.isMine()) {
jtulach@63
   139
                continue;
jtulach@63
   140
            }
jtulach@63
   141
            s.setMine(true);
jtulach@63
   142
            mines--;
jtulach@63
   143
        }
jtulach@63
   144
jtulach@63
   145
        model.setState(GameState.IN_PROGRESS);
jtulach@107
   146
        if (rows != model.getRows()) {
jtulach@107
   147
            model.getRows().clear();
jtulach@107
   148
            model.getRows().addAll(rows);
jtulach@107
   149
        }
jtulach@63
   150
    }
jtulach@63
   151
    
jtulach@64
   152
    @ModelOperation static void computeMines(Mines model) {
jtulach@64
   153
        List<Integer> xBombs = new ArrayList<Integer>();
jtulach@64
   154
        List<Integer> yBombs = new ArrayList<Integer>();
jtulach@64
   155
        final List<Row> rows = model.getRows();
jtulach@66
   156
        boolean emptyHidden = false;
jtulach@69
   157
        SquareType[][] arr = new SquareType[rows.size()][];
jtulach@64
   158
        for (int y = 0; y < rows.size(); y++) {
jtulach@64
   159
            final List<Square> columns = rows.get(y).getColumns();
jtulach@69
   160
            arr[y] = new SquareType[columns.size()];
jtulach@64
   161
            for (int x = 0; x < columns.size(); x++) {
jtulach@64
   162
                Square sq = columns.get(x);
jtulach@64
   163
                if (sq.isMine()) {
jtulach@64
   164
                    xBombs.add(x);
jtulach@64
   165
                    yBombs.add(y);
jtulach@64
   166
                }
jtulach@64
   167
                if (sq.getState().isVisible()) {
jtulach@69
   168
                    arr[y][x] = SquareType.N_0;
jtulach@66
   169
                } else {
jtulach@66
   170
                    if (!sq.isMine()) {
jtulach@66
   171
                        emptyHidden = true;
jtulach@66
   172
                    }
jtulach@64
   173
                }
jtulach@64
   174
            }
jtulach@64
   175
        }
jtulach@64
   176
        for (int i = 0; i < xBombs.size(); i++) {
jtulach@64
   177
            int x = xBombs.get(i);
jtulach@64
   178
            int y = yBombs.get(i);
jtulach@64
   179
            
jtulach@69
   180
            incrementAround(arr, x, y);
jtulach@69
   181
        }
jtulach@69
   182
        for (int y = 0; y < rows.size(); y++) {
jtulach@69
   183
            final List<Square> columns = rows.get(y).getColumns();
jtulach@69
   184
            for (int x = 0; x < columns.size(); x++) {
jtulach@69
   185
                Square sq = columns.get(x);
jtulach@69
   186
                final SquareType newState = arr[y][x];
jtulach@69
   187
                if (newState != null && newState != sq.getState()) {
jtulach@69
   188
                    sq.setState(newState);
jtulach@69
   189
                }
jtulach@69
   190
            }
jtulach@64
   191
        }
jtulach@66
   192
        
jtulach@66
   193
        if (!emptyHidden) {
jtulach@66
   194
            model.setState(GameState.WON);
jtulach@68
   195
            showAllBombs(model, SquareType.DISCOVERED);
jtulach@153
   196
            AudioClip applause = AudioClip.create("applause.mp3");
jaroslav@136
   197
            applause.play();
jtulach@66
   198
        }
jtulach@64
   199
    }
jtulach@64
   200
    
jtulach@69
   201
    private static void incrementAround(SquareType[][] arr, int x, int y) {
jtulach@69
   202
        incrementAt(arr, x - 1, y - 1);
jtulach@69
   203
        incrementAt(arr, x - 1, y);
jtulach@69
   204
        incrementAt(arr, x - 1, y + 1);
jtulach@64
   205
jtulach@69
   206
        incrementAt(arr, x + 1, y - 1);
jtulach@69
   207
        incrementAt(arr, x + 1, y);
jtulach@69
   208
        incrementAt(arr, x + 1, y + 1);
jtulach@64
   209
        
jtulach@69
   210
        incrementAt(arr, x, y - 1);
jtulach@69
   211
        incrementAt(arr, x, y + 1);
jtulach@64
   212
    }
jtulach@64
   213
    
jtulach@69
   214
    private static void incrementAt(SquareType[][] arr, int x, int y) {
jtulach@69
   215
        if (y >= 0 && y < arr.length) {
jtulach@69
   216
            SquareType[] r = arr[y];
jtulach@69
   217
            if (x >= 0 && x < r.length) {
jtulach@69
   218
                SquareType sq = r[x];
jtulach@69
   219
                if (sq != null) {
jtulach@69
   220
                    r[x] = sq.moreBombsAround();
jtulach@69
   221
                }
jtulach@64
   222
            }
jtulach@64
   223
        }
jtulach@64
   224
    }
jtulach@64
   225
    
jtulach@68
   226
    static void showAllBombs(Mines model, SquareType state) {
jtulach@63
   227
        for (Row row : model.getRows()) {
jtulach@63
   228
            for (Square square : row.getColumns()) {
jtulach@63
   229
                if (square.isMine()) {
jtulach@68
   230
                    square.setState(state);
jtulach@63
   231
                }
jtulach@63
   232
            }
jtulach@63
   233
        }
jtulach@63
   234
    }
jtulach@63
   235
    
jtulach@63
   236
    @Function static void click(Mines model, Square data) {
jaroslav@164
   237
        if (model.getState() == GameState.MARKING_MINE) {
jaroslav@164
   238
            if (data.getState() == SquareType.UNKNOWN) {
jaroslav@164
   239
                data.setState(SquareType.MARKED);
jaroslav@165
   240
                if (allMarked(model)) {
jaroslav@165
   241
                    model.setState(GameState.WON);
jaroslav@165
   242
                    return;
jaroslav@165
   243
                }
jaroslav@164
   244
            }
jaroslav@164
   245
            model.setState(GameState.IN_PROGRESS);
jaroslav@164
   246
            return;
jaroslav@164
   247
        }
jtulach@63
   248
        if (model.getState() != GameState.IN_PROGRESS) {
jtulach@63
   249
            return;
jtulach@63
   250
        }
jaroslav@164
   251
        if (data.getState() == SquareType.MARKED) {
jaroslav@164
   252
            data.setState(SquareType.UNKNOWN);
jaroslav@164
   253
            return;
jaroslav@164
   254
        }
jaroslav@152
   255
        if (data.getState() != SquareType.UNKNOWN) {
jaroslav@152
   256
            return;
jaroslav@152
   257
        }
jaroslav@152
   258
        if (data.isMine()) {
jaroslav@152
   259
            Square fair = atLeastOnePlaceWhereBombCantBe(model);
jaroslav@152
   260
            if (fair == null) {
jaroslav@152
   261
                if (placeBombElseWhere(model, data)) {
jaroslav@152
   262
                    cleanedUp(model, data);
jaroslav@152
   263
                    return;
jtulach@63
   264
                }
jaroslav@152
   265
            }
jaroslav@152
   266
            explosion(model);
jaroslav@152
   267
        } else {
jaroslav@152
   268
            Square takeFrom = tryStealBomb(model, data);
jaroslav@152
   269
            if (takeFrom != null) {
jaroslav@152
   270
                final Square fair = atLeastOnePlaceWhereBombCantBe(model);
jaroslav@152
   271
                if (fair != null) {
jaroslav@152
   272
                    takeFrom.setMine(false);
jaroslav@152
   273
                    data.setMine(true);
jaroslav@152
   274
                    explosion(model);
jaroslav@152
   275
                    return;
jaroslav@152
   276
                }
jaroslav@152
   277
            }
jaroslav@152
   278
            cleanedUp(model, data);
jtulach@63
   279
        }
jtulach@63
   280
    }
jaroslav@152
   281
jaroslav@152
   282
    private static void cleanedUp(Mines model, Square data) {
jaroslav@152
   283
        AudioClip touch = AudioClip.create("move.mp3");
jaroslav@152
   284
        touch.play();
jaroslav@152
   285
        expandKnown(model, data);
jaroslav@152
   286
        model.computeMines();
jaroslav@152
   287
    }
jaroslav@152
   288
jaroslav@152
   289
    private static void explosion(Mines model) {
jaroslav@152
   290
        showAllBombs(model, SquareType.EXPLOSION);
jaroslav@152
   291
        model.setState(GameState.LOST);
jtulach@153
   292
        AudioClip oops = AudioClip.create("oops.mp3");
jaroslav@152
   293
        oops.play();
jaroslav@152
   294
    }
jaroslav@152
   295
    
jaroslav@152
   296
    private static Square tryStealBomb(Mines model, Square data) {
jaroslav@152
   297
        data.setMine(true);
jaroslav@152
   298
        final List<Row> rows = model.getRows();
jaroslav@152
   299
        for (int y = 0; y < rows.size(); y++) {
jaroslav@152
   300
            final List<Square> columns = rows.get(y).getColumns();
jaroslav@152
   301
            for (int x = 0; x < columns.size(); x++) {
jaroslav@152
   302
                Square sq = columns.get(x);
jaroslav@152
   303
                if (sq == data) {
jaroslav@152
   304
                    continue;
jaroslav@152
   305
                }
jaroslav@152
   306
                if (sq.isMine()) {
jaroslav@152
   307
                    sq.setMine(false);
jaroslav@152
   308
                    final boolean ok = isConsistent(model);
jaroslav@152
   309
                    sq.setMine(true);
jaroslav@152
   310
                    if (ok) {
jaroslav@152
   311
                        data.setMine(false);
jaroslav@152
   312
                        return sq;
jaroslav@152
   313
                    }
jaroslav@152
   314
                }
jaroslav@152
   315
            }
jaroslav@152
   316
        }
jaroslav@152
   317
        data.setMine(false);        
jaroslav@152
   318
        return null;
jaroslav@152
   319
    }
jaroslav@152
   320
    
jaroslav@152
   321
    private static Square atLeastOnePlaceWhereBombCantBe(Mines model) {
jaroslav@152
   322
        final List<Row> rows = model.getRows();
jaroslav@152
   323
        Square cantBe = null;
jaroslav@152
   324
        int discovered = 0;
jaroslav@152
   325
        for (int y = 0; y < rows.size(); y++) {
jaroslav@152
   326
            final List<Square> columns = rows.get(y).getColumns();
jaroslav@152
   327
            for (int x = 0; x < columns.size(); x++) {
jaroslav@152
   328
                Square sq = columns.get(x);
jaroslav@152
   329
                if (sq.getState() == SquareType.UNKNOWN) {
jaroslav@152
   330
                    if (!sq.isMine()) {
jaroslav@152
   331
                        if (tryStealBomb(model, sq) == null) {
jaroslav@152
   332
                            cantBe = sq;
jaroslav@152
   333
                        }
jaroslav@152
   334
                    }
jaroslav@152
   335
                } else {
jaroslav@152
   336
                    discovered++;
jaroslav@152
   337
                }
jaroslav@152
   338
            }
jaroslav@152
   339
        }
jaroslav@152
   340
        
jaroslav@152
   341
        if (discovered > 5) {
jaroslav@152
   342
            return cantBe;
jaroslav@152
   343
        }
jaroslav@152
   344
        
jaroslav@152
   345
        return null;
jaroslav@152
   346
    }
jaroslav@152
   347
    
jaroslav@152
   348
    private static boolean placeBombElseWhere(Mines model, Square moveBomb) {
jaroslav@152
   349
        List<Square> ok = new ArrayList<Square>();
jaroslav@152
   350
        moveBomb.setMine(false);
jaroslav@152
   351
        final List<Row> rows = model.getRows();
jaroslav@152
   352
        for (int y = 0; y < rows.size(); y++) {
jaroslav@152
   353
            final List<Square> columns = rows.get(y).getColumns();
jaroslav@152
   354
            for (int x = 0; x < columns.size(); x++) {
jaroslav@152
   355
                Square sq = columns.get(x);
jaroslav@152
   356
                if (sq == moveBomb || sq.isMine() || sq.getState().isVisible()) {
jaroslav@152
   357
                    continue;
jaroslav@152
   358
                }
jaroslav@152
   359
                sq.setMine(true);
jaroslav@152
   360
                if (isConsistent(model)) {
jaroslav@152
   361
                    ok.add(sq);
jaroslav@152
   362
                }
jaroslav@152
   363
                sq.setMine(false);
jaroslav@152
   364
            }
jaroslav@152
   365
        }
jaroslav@152
   366
        if (ok.isEmpty()) {
jaroslav@152
   367
            moveBomb.setMine(true);
jaroslav@152
   368
            return false;
jaroslav@152
   369
        } else {
jaroslav@152
   370
            int r = new Random().nextInt(ok.size());
jaroslav@152
   371
            ok.get(r).setMine(true);
jaroslav@152
   372
            return true;
jaroslav@152
   373
        }
jaroslav@152
   374
    }
jaroslav@152
   375
    
jtulach@68
   376
    private static void expandKnown(Mines model, Square data) {
jtulach@68
   377
        final List<Row> rows = model.getRows();
jtulach@68
   378
        for (int y = 0; y < rows.size(); y++) {
jtulach@68
   379
            final List<Square> columns = rows.get(y).getColumns();
jtulach@68
   380
            for (int x = 0; x < columns.size(); x++) {
jtulach@68
   381
                Square sq = columns.get(x);
jtulach@68
   382
                if (sq == data) {
jtulach@68
   383
                    expandKnown(model, x, y);
jtulach@68
   384
                    return;
jtulach@68
   385
                }
jtulach@68
   386
            }
jtulach@68
   387
        }
jtulach@68
   388
    }
jtulach@68
   389
    private static void expandKnown(Mines model, int x , int y) {
jtulach@68
   390
        if (y < 0 || y >= model.getRows().size()) {
jtulach@68
   391
            return;
jtulach@68
   392
        }
jtulach@68
   393
        final List<Square> columns = model.getRows().get(y).getColumns();
jtulach@68
   394
        if (x < 0 || x >= columns.size()) {
jtulach@68
   395
            return;
jtulach@68
   396
        }
jtulach@68
   397
        final Square sq = columns.get(x);
jtulach@68
   398
        if (sq.getState() == SquareType.UNKNOWN) {
jaroslav@152
   399
            int around = around(model, x, y);
jtulach@107
   400
            final SquareType t = SquareType.valueOf("N_" + around);
jtulach@107
   401
            sq.setState(t);
jtulach@107
   402
            if (t == SquareType.N_0) {
jtulach@68
   403
                expandKnown(model, x - 1, y - 1);
jtulach@68
   404
                expandKnown(model, x - 1, y);
jtulach@68
   405
                expandKnown(model, x - 1, y + 1);
jtulach@68
   406
                expandKnown(model, x , y - 1);
jtulach@68
   407
                expandKnown(model, x, y + 1);
jtulach@68
   408
                expandKnown(model, x + 1, y - 1);
jtulach@68
   409
                expandKnown(model, x + 1, y);
jtulach@68
   410
                expandKnown(model, x + 1, y + 1);
jtulach@68
   411
            }
jtulach@68
   412
        }
jtulach@68
   413
    }
jaroslav@152
   414
jaroslav@152
   415
    private static int around(Mines model, int x, int y) {
jaroslav@152
   416
        return 
jaroslav@152
   417
            minesAt(model, x - 1, y - 1) +
jaroslav@152
   418
            minesAt(model, x - 1, y) +
jaroslav@152
   419
            minesAt(model, x - 1, y + 1) +
jaroslav@152
   420
            minesAt(model, x , y - 1) +
jaroslav@152
   421
            minesAt(model, x, y + 1) +
jaroslav@152
   422
            minesAt(model, x + 1, y - 1) +
jaroslav@152
   423
            minesAt(model, x + 1, y) +
jaroslav@152
   424
            minesAt(model, x + 1, y + 1);
jaroslav@152
   425
    }
jtulach@90
   426
    
jtulach@107
   427
    private static int minesAt(Mines model, int x, int y) {
jtulach@107
   428
        if (y < 0 || y >= model.getRows().size()) {
jtulach@107
   429
            return 0;
jtulach@107
   430
        }
jtulach@107
   431
        final List<Square> columns = model.getRows().get(y).getColumns();
jtulach@107
   432
        if (x < 0 || x >= columns.size()) {
jtulach@107
   433
            return 0;
jtulach@107
   434
        }
jtulach@107
   435
        Square sq = columns.get(x);
jtulach@107
   436
        return sq.isMine() ? 1 : 0;
jtulach@107
   437
    }
jaroslav@152
   438
    
jaroslav@152
   439
    private static boolean isConsistent(Mines m) {
jaroslav@152
   440
        for (int row = 0; row < m.getRows().size(); row++) {
jaroslav@152
   441
            Row r = m.getRows().get(row);
jaroslav@152
   442
            for (int col = 0; col < r.getColumns().size(); col++) {
jaroslav@152
   443
                Square sq = r.getColumns().get(col);
jaroslav@152
   444
                if (sq.getState().isVisible()) {
jaroslav@152
   445
                    int around = around(m, col, row);
jaroslav@152
   446
                    if (around != sq.getState().ordinal()) {
jaroslav@152
   447
                        return false;
jaroslav@152
   448
                    }
jaroslav@152
   449
                }
jaroslav@152
   450
            }
jaroslav@152
   451
        }
jaroslav@152
   452
        return true;
jaroslav@152
   453
    }
jaroslav@165
   454
    
jaroslav@165
   455
    private static boolean allMarked(Mines m) {
jaroslav@165
   456
        for (Row r : m.getRows()) {
jaroslav@165
   457
            for (Square sq : r.getColumns()) {
jaroslav@165
   458
                if (sq.isMine() && sq.getState() != SquareType.MARKED) {
jaroslav@165
   459
                    return false;
jaroslav@165
   460
                }
jaroslav@165
   461
            }
jaroslav@165
   462
        }
jaroslav@165
   463
        for (Row r : m.getRows()) {
jaroslav@165
   464
            for (Square sq : r.getColumns()) {
jaroslav@165
   465
                if (sq.isMine()) {
jaroslav@165
   466
                    sq.setState(SquareType.DISCOVERED);
jaroslav@165
   467
                } else {
jaroslav@165
   468
                    sq.setState(SquareType.N_0);
jaroslav@165
   469
                }
jaroslav@165
   470
            }
jaroslav@165
   471
        }
jaroslav@165
   472
        computeMines(m);
jaroslav@165
   473
        return true;
jaroslav@165
   474
    }
jtulach@116
   475
jtulach@90
   476
    /**
jtulach@90
   477
     * Called when page is ready
jtulach@90
   478
     */
jtulach@90
   479
    public static void main(String... args) throws Exception {
jtulach@90
   480
        Mines m = new Mines();
jtulach@90
   481
        m.applyBindings();
jtulach@90
   482
    }
jtulach@63
   483
}