samples/pop_pop_win: now based on StageXL

samples/pop_pop_win/lib/src/game/game.dart

 part of pop_pop_win.game;
 
 class Game {
   final Field field;
   final Array2d<SquareState> _states;
-  final EventHandle<EventArgs> _updatedEvent = new EventHandle<EventArgs>();
-  final EventHandle<GameState> _gameStateEvent = new EventHandle<GameState>();
+  final StreamController _updatedEvent = new StreamController();
+  final StreamController<GameState> _gameStateEvent =
+      new StreamController<GameState>();
 
   GameState _state;
   int _bombsLeft;
   int _revealsLeft;
   DateTime _startTime;
   DateTime _endTime;
 
-  Game(Field field) :
-    this.field = field,
-    _state = GameState.reset,
-    _states = new Array2d<SquareState>(field.width, field.height, SquareState.hidden) {
+  Game(Field field)
+      : this.field = field,
+        _state = GameState.reset,
+        _states = new Array2d<SquareState>(field.width, field.height,
+          SquareState.hidden) {
     assert(field != null);
     _bombsLeft = field.bombCount;
     _revealsLeft = field.length - field.bombCount;
   }
 
   int get bombsLeft => _bombsLeft;
 
   int get revealsLeft => _revealsLeft;
 
   GameState get state => _state;
@@ skipping 42 matching lines @@
   bool canReveal(int x, int y) {
     final currentSS = _states.get(x, y);
     if (currentSS == SquareState.hidden) {
       return true;
     } else if (_canChord(x, y)) {
       return true;
     }
     return false;
   }
 
-  List<Coordinate> reveal(int x, int y) {
+  List<Point> reveal(int x, int y) {
     _ensureStarted();
     require(canReveal(x, y), "Item cannot be revealed.");
     final currentSS = _states.get(x, y);
 
-    List<Coordinate> reveals;
+    List<Point> reveals;
 
     // normal reveal
     if (currentSS == SquareState.hidden) {
       if (field.get(x, y)) {
         _setLost();
-        reveals = <Coordinate>[];
+        reveals = <Point>[];
       } else {
         reveals = _doReveal(x, y);
       }
     } else if (_canChord(x, y)) {
       reveals = _doChord(x, y);
     }
     _update();
 
     if (_state == GameState.lost) {
       return null;
@@ skipping 62 matching lines @@
           final adjFlags = _getAdjacentCount(x, y, SquareState.flagged);
           if (adjFlags == adjCount) {
             return true;
           }
         }
       }
     }
     return false;
   }
 
-  List<Coordinate> _doChord(int x, int y) {
+  List<Point> _doChord(int x, int y) {
     // this does not repeat a bunch of validations that have already happened
     // be careful
     final currentSS = _states.get(x, y);
     assert(currentSS == SquareState.revealed);
 
     final flagged = new List<int>();
     final hidden = new List<int>();
     final adjCount = field.getAdjacentCount(x, y);
     assert(adjCount > 0);
 
     bool failed = false;
 
     for (final i in field.getAdjacentIndices(x, y)) {
       if (_states[i] == SquareState.hidden) {
         hidden.add(i);
         if (field[i]) {
           failed = true;
         }
       } else if (_states[i] == SquareState.flagged) {
         flagged.add(i);
       }
     }
 
     // for now we assume counts have been checked
     assert(flagged.length == adjCount);
 
-    var reveals = <Coordinate>[];
+    var reveals = <Point>[];
 
     // if any of the hidden are bombs, we've failed
     if (failed) {
-      // TODO: assert one of the flags must be wrong, right?
       _setLost();
     } else {
       for (final i in hidden) {
         final c = field.getCoordinate(i);
         if (canReveal(c.item1, c.item2)) {
           reveals.addAll(reveal(c.item1, c.item2));
         }
       }
     }
 
     return reveals;
   }
 
-  List<Coordinate> _doReveal(int x, int y) {
+  List<Point> _doReveal(int x, int y) {
     assert(_states.get(x, y) == SquareState.hidden);
     _states.set(x, y, SquareState.revealed);
     _revealsLeft--;
     assert(_revealsLeft >= 0);
-    var reveals = [new Coordinate(x, y)];
+    var reveals = [new Point(x, y)];
     if (_revealsLeft == 0) {
       _setWon();
     } else if (field.getAdjacentCount(x, y) == 0) {
       for (final i in field.getAdjacentIndices(x, y)) {
         if (_states[i] == SquareState.hidden) {
           final c = field.getCoordinate(i);
           reveals.addAll(_doReveal(c.item1, c.item2));
           assert(state == GameState.started || state == GameState.won);
         }
       }
@@ skipping 14 matching lines @@
   void _setLost() {
     assert(state == GameState.started);
     for (int i = 0; i < field.length; i++) {
       if (field[i]) {
         _states[i] = SquareState.bomb;
       }
     }
     _setState(GameState.lost);
   }
 
-  void _update() => _updatedEvent.add(EventArgs.empty);
+  void _update() => _updatedEvent.add(null);
 
   void _setState(GameState value) {
     assert(value != null);
     assert(_state != null);
     assert((_state == GameState.reset) == (_startTime == null));
     if (_state != value) {
       _state = value;
       if (_state == GameState.started) {
         _startTime = new DateTime.now();
       } else if (gameEnded) {
@@ skipping 15 matching lines @@
   int _getAdjacentCount(int x, int y, SquareState state) {
     int val = 0;
     for (final i in field.getAdjacentIndices(x, y)) {
       if (_states[i] == state) {
         val++;
       }
     }
     return val;
   }
 }