mirror of
https://github.com/flutter/flutter.git
synced 2025-06-03 00:51:18 +00:00
366 lines
9.9 KiB
Dart
366 lines
9.9 KiB
Dart
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
import 'dart:sky' as sky;
|
|
import 'dart:math';
|
|
|
|
import 'package:sky/painting/text_style.dart';
|
|
import 'package:sky/rendering/flex.dart';
|
|
import 'package:sky/theme/colors.dart' as colors;
|
|
import 'package:sky/widgets.dart';
|
|
|
|
// Classic minesweeper-inspired game. The mouse controls are standard
|
|
// except for left + right combo which is not implemented. For touch,
|
|
// the duration of the pointer determines probing versus flagging.
|
|
//
|
|
// There are only 3 classes to understand. MineDiggerApp, which is
|
|
// contains all the logic and two classes that describe the mines:
|
|
// CoveredMineNode and ExposedMineNode, none of them holding state.
|
|
|
|
// Colors for each mine count (0-8):
|
|
const List<TextStyle> textStyles = const <TextStyle>[
|
|
const TextStyle(color: const Color(0xFF555555), fontWeight: bold),
|
|
const TextStyle(color: const Color(0xFF0094FF), fontWeight: bold), // blue
|
|
const TextStyle(color: const Color(0xFF13A023), fontWeight: bold), // green
|
|
const TextStyle(color: const Color(0xFFDA1414), fontWeight: bold), // red
|
|
const TextStyle(color: const Color(0xFF1E2347), fontWeight: bold), // black
|
|
const TextStyle(color: const Color(0xFF7F0037), fontWeight: bold), // dark red
|
|
const TextStyle(color: const Color(0xFF000000), fontWeight: bold),
|
|
const TextStyle(color: const Color(0xFF000000), fontWeight: bold),
|
|
const TextStyle(color: const Color(0xFF000000), fontWeight: bold),
|
|
];
|
|
|
|
enum CellState { covered, exploded, cleared, flagged, shown }
|
|
|
|
class MineDiggerApp extends App {
|
|
static const int rows = 9;
|
|
static const int cols = 9;
|
|
static const int totalMineCount = 11;
|
|
|
|
bool alive;
|
|
bool hasWon;
|
|
int detectedCount;
|
|
|
|
// |cells| keeps track of the positions of the mines.
|
|
List<List<bool>> cells;
|
|
// |uiState| keeps track of the visible player progess.
|
|
List<List<CellState>> uiState;
|
|
|
|
void initState() {
|
|
resetGame();
|
|
}
|
|
|
|
void resetGame() {
|
|
alive = true;
|
|
hasWon = false;
|
|
detectedCount = 0;
|
|
// Build the arrays.
|
|
cells = new List<List<bool>>();
|
|
uiState = new List<List<CellState>>();
|
|
for (int iy = 0; iy != rows; iy++) {
|
|
cells.add(new List<bool>());
|
|
uiState.add(new List<CellState>());
|
|
for (int ix = 0; ix != cols; ix++) {
|
|
cells[iy].add(false);
|
|
uiState[iy].add(CellState.covered);
|
|
}
|
|
}
|
|
// Place the mines.
|
|
Random random = new Random();
|
|
int cellsRemaining = rows * cols;
|
|
int minesRemaining = totalMineCount;
|
|
for (int x = 0; x < cols; x += 1) {
|
|
for (int y = 0; y < rows; y += 1) {
|
|
if (random.nextInt(cellsRemaining) < minesRemaining) {
|
|
cells[y][x] = true;
|
|
minesRemaining -= 1;
|
|
if (minesRemaining <= 0)
|
|
return;
|
|
}
|
|
cellsRemaining -= 1;
|
|
}
|
|
}
|
|
assert(false);
|
|
}
|
|
|
|
Stopwatch longPressStopwatch;
|
|
|
|
PointerEventListener _pointerDownHandlerFor(int posX, int posY) {
|
|
return (sky.PointerEvent event) {
|
|
if (event.buttons == 1) {
|
|
probe(posX, posY);
|
|
} else if (event.buttons == 2) {
|
|
flag(posX, posY);
|
|
} else {
|
|
// Touch event.
|
|
longPressStopwatch = new Stopwatch()..start();
|
|
}
|
|
};
|
|
}
|
|
|
|
PointerEventListener _pointerUpHandlerFor(int posX, int posY) {
|
|
return (sky.PointerEvent event) {
|
|
if (longPressStopwatch == null)
|
|
return;
|
|
// Pointer down was a touch event.
|
|
if (longPressStopwatch.elapsedMilliseconds < 250) {
|
|
probe(posX, posY);
|
|
} else {
|
|
// Long press flags.
|
|
flag(posX, posY);
|
|
}
|
|
longPressStopwatch = null;
|
|
};
|
|
}
|
|
|
|
Widget buildBoard() {
|
|
bool hasCoveredCell = false;
|
|
List<Flex> flexRows = <Flex>[];
|
|
for (int iy = 0; iy != 9; iy++) {
|
|
List<Widget> row = <Widget>[];
|
|
for (int ix = 0; ix != 9; ix++) {
|
|
CellState state = uiState[iy][ix];
|
|
int count = mineCount(ix, iy);
|
|
if (!alive) {
|
|
if (state != CellState.exploded)
|
|
state = cells[iy][ix] ? CellState.shown : state;
|
|
}
|
|
if (state == CellState.covered) {
|
|
row.add(new Listener(
|
|
onPointerDown: _pointerDownHandlerFor(ix, iy),
|
|
onPointerUp: _pointerUpHandlerFor(ix, iy),
|
|
child: new CoveredMineNode(
|
|
flagged: false,
|
|
posX: ix,
|
|
posY: iy
|
|
)
|
|
));
|
|
// Mutating |hasCoveredCell| here is hacky, but convenient, same
|
|
// goes for mutating |hasWon| below.
|
|
hasCoveredCell = true;
|
|
} else if (state == CellState.flagged) {
|
|
row.add(new CoveredMineNode(
|
|
flagged: true,
|
|
posX: ix,
|
|
posY: iy
|
|
));
|
|
} else {
|
|
row.add(new ExposedMineNode(
|
|
state: state,
|
|
count: count
|
|
));
|
|
}
|
|
}
|
|
flexRows.add(
|
|
new Flex(
|
|
row,
|
|
direction: FlexDirection.horizontal,
|
|
justifyContent: FlexJustifyContent.center,
|
|
key: new Key.stringify(iy)
|
|
)
|
|
);
|
|
}
|
|
|
|
if (!hasCoveredCell) {
|
|
// all cells uncovered. Are all mines flagged?
|
|
if ((detectedCount == totalMineCount) && alive) {
|
|
hasWon = true;
|
|
}
|
|
}
|
|
|
|
return new Container(
|
|
padding: new EdgeDims.all(10.0),
|
|
margin: new EdgeDims.all(10.0),
|
|
decoration: new BoxDecoration(backgroundColor: const Color(0xFF6B6B6B)),
|
|
child: new Flex(
|
|
flexRows,
|
|
direction: FlexDirection.vertical
|
|
)
|
|
);
|
|
}
|
|
|
|
Widget buildToolBar() {
|
|
String toolbarCaption = hasWon ?
|
|
'Awesome!!' : alive ?
|
|
'Mine Digger [$detectedCount-$totalMineCount]': 'Kaboom! [press here]';
|
|
|
|
return new ToolBar(
|
|
// FIXME: Strange to have the toolbar be tapable.
|
|
center: new Listener(
|
|
onPointerDown: handleToolbarPointerDown,
|
|
child: new Text(toolbarCaption, style: Theme.of(this).text.title)
|
|
)
|
|
);
|
|
}
|
|
|
|
Widget build() {
|
|
// We build the board before we build the toolbar because we compute the win state during build step.
|
|
Widget board = buildBoard();
|
|
return new TaskDescription(
|
|
label: 'Mine Digger',
|
|
child: new Scaffold(
|
|
toolbar: buildToolBar(),
|
|
body: new Container(
|
|
child: new Center(child: board),
|
|
decoration: new BoxDecoration(backgroundColor: colors.Grey[50])
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
EventDisposition handleToolbarPointerDown(sky.PointerEvent event) {
|
|
setState(() {
|
|
resetGame();
|
|
});
|
|
return EventDisposition.processed;
|
|
}
|
|
|
|
// User action. The user uncovers the cell which can cause losing the game.
|
|
void probe(int x, int y) {
|
|
if (!alive)
|
|
return;
|
|
if (uiState[y][x] == CellState.flagged)
|
|
return;
|
|
setState(() {
|
|
// Allowed to probe.
|
|
if (cells[y][x]) {
|
|
// Probed on a mine --> dead!!
|
|
uiState[y][x] = CellState.exploded;
|
|
alive = false;
|
|
} else {
|
|
// No mine, uncover nearby if possible.
|
|
cull(x, y);
|
|
}
|
|
});
|
|
}
|
|
|
|
// User action. The user is sure a mine is at this location.
|
|
void flag(int x, int y) {
|
|
setState(() {
|
|
if (uiState[y][x] == CellState.flagged) {
|
|
uiState[y][x] = CellState.covered;
|
|
--detectedCount;
|
|
} else {
|
|
uiState[y][x] = CellState.flagged;
|
|
++detectedCount;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Recursively uncovers cells whose totalMineCount is zero.
|
|
void cull(int x, int y) {
|
|
if ((x < 0) || (x > rows - 1))
|
|
return;
|
|
if ((y < 0) || (y > cols - 1))
|
|
return;
|
|
|
|
if (uiState[y][x] == CellState.cleared)
|
|
return;
|
|
uiState[y][x] = CellState.cleared;
|
|
|
|
if (mineCount(x, y) > 0)
|
|
return;
|
|
|
|
cull(x - 1, y);
|
|
cull(x + 1, y);
|
|
cull(x, y - 1);
|
|
cull(x, y + 1 );
|
|
cull(x - 1, y - 1);
|
|
cull(x + 1, y + 1);
|
|
cull(x + 1, y - 1);
|
|
cull(x - 1, y + 1);
|
|
}
|
|
|
|
int mineCount(int x, int y) {
|
|
int count = 0;
|
|
int my = cols - 1;
|
|
int mx = rows - 1;
|
|
|
|
count += x > 0 ? bombs(x - 1, y) : 0;
|
|
count += x < mx ? bombs(x + 1, y) : 0;
|
|
count += y > 0 ? bombs(x, y - 1) : 0;
|
|
count += y < my ? bombs(x, y + 1 ) : 0;
|
|
|
|
count += (x > 0) && (y > 0) ? bombs(x - 1, y - 1) : 0;
|
|
count += (x < mx) && (y < my) ? bombs(x + 1, y + 1) : 0;
|
|
count += (x < mx) && (y > 0) ? bombs(x + 1, y - 1) : 0;
|
|
count += (x > 0) && (y < my) ? bombs(x - 1, y + 1) : 0;
|
|
|
|
return count;
|
|
}
|
|
|
|
int bombs(int x, int y) {
|
|
return cells[y][x] ? 1 : 0;
|
|
}
|
|
}
|
|
|
|
Widget buildCell(Widget child) {
|
|
return new Container(
|
|
padding: new EdgeDims.all(1.0),
|
|
height: 27.0, width: 27.0,
|
|
decoration: new BoxDecoration(backgroundColor: const Color(0xFFC0C0C0)),
|
|
margin: new EdgeDims.all(2.0),
|
|
child: child
|
|
);
|
|
}
|
|
|
|
Widget buildInnerCell(Widget child) {
|
|
return new Container(
|
|
padding: new EdgeDims.all(1.0),
|
|
margin: new EdgeDims.all(3.0),
|
|
height: 17.0, width: 17.0,
|
|
child: child
|
|
);
|
|
}
|
|
|
|
class CoveredMineNode extends Component {
|
|
|
|
CoveredMineNode({ this.flagged, this.posX, this.posY });
|
|
|
|
final bool flagged;
|
|
final int posX;
|
|
final int posY;
|
|
|
|
Widget build() {
|
|
Widget text;
|
|
if (flagged)
|
|
text = buildInnerCell(new StyledText(elements : [textStyles[5], '\u2691']));
|
|
|
|
Container inner = new Container(
|
|
margin: new EdgeDims.all(2.0),
|
|
height: 17.0, width: 17.0,
|
|
decoration: new BoxDecoration(backgroundColor: const Color(0xFFD9D9D9)),
|
|
child: text
|
|
);
|
|
|
|
return buildCell(inner);
|
|
}
|
|
}
|
|
|
|
class ExposedMineNode extends Component {
|
|
|
|
ExposedMineNode({ this.state, this.count });
|
|
|
|
final CellState state;
|
|
final int count;
|
|
|
|
Widget build() {
|
|
StyledText text;
|
|
if (state == CellState.cleared) {
|
|
// Uncovered cell with nearby mine count.
|
|
if (count != 0)
|
|
text = new StyledText(elements : [textStyles[count], '$count']);
|
|
} else {
|
|
// Exploded mine or shown mine for 'game over'.
|
|
int color = state == CellState.exploded ? 3 : 0;
|
|
text = new StyledText(elements : [textStyles[color], '\u2600']);
|
|
}
|
|
return buildCell(buildInnerCell(text));
|
|
}
|
|
|
|
}
|
|
|
|
void main() {
|
|
runApp(new MineDiggerApp());
|
|
}
|