Merge branch '54-as-a-user-i-want-to-save-and-load-cell-configurations' into 'master'

Resolve "As a user, I want to save and load cell configurations."

Closes #54

See merge request marty.oehme/cellular-automata!17

analysis_options.yaml

@@ -1,6 +1,6 @@
 analyzer:
   exclude: [build/**]
-  strong-mode: true
+
   errors:
     uri_has_not_been_generated: ignore
   plugins:

lib/app_component.dart

@@ -4,9 +4,8 @@ import 'package:rules_of_living/components/configuration_component.dart';
 import 'package:rules_of_living/components/controls_component.dart';
 import 'package:rules_of_living/components/header_component.dart';
 import 'package:rules_of_living/components/simulation_component.dart';
-import 'package:rules_of_living/service/configuration_service.dart';
-import 'package:rules_of_living/service/control_service.dart';
 import 'package:rules_of_living/service/engine_service.dart';
+import 'package:rules_of_living/service/simulation_service.dart';
 
 @Component(
   selector: 'my-app',
@@ -24,8 +23,7 @@ import 'package:rules_of_living/service/engine_service.dart';
   providers: [
     materialProviders,
     ClassProvider(EngineService),
-    ClassProvider(ConfigurationService),
-    ClassProvider(ControlService)
+    ClassProvider(SimulationService)
   ],
   styleUrls: const [
     'package:angular_components/app_layout/layout.scss.css',

lib/components/configuration_component.dart

@@ -1,3 +1,5 @@
+import 'dart:math';
+
 import 'package:angular/angular.dart';
 import 'package:angular_components/material_button/material_button.dart';
 import 'package:angular_components/material_icon/material_icon.dart';
@@ -5,7 +7,8 @@ import 'package:angular_components/material_input/material_input.dart';
 import 'package:angular_components/material_input/material_number_accessor.dart';
 import 'package:angular_components/material_slider/material_slider.dart';
 import 'package:angular_components/material_tooltip/material_tooltip.dart';
-import 'package:rules_of_living/service/configuration_service.dart';
+import 'package:rules_of_living/service/engine_service.dart';
+import 'package:rules_of_living/service/simulation_service.dart';
 
 @Component(
     selector: "configuration",
@@ -23,28 +26,29 @@ import 'package:rules_of_living/service/configuration_service.dart';
       NgModel
     ])
 class ConfigurationComponent {
-  final ConfigurationService config;
+  final EngineService engine;
+  final SimulationService sim;
 
-  int get width => config.gridSize.x;
+  int get width => sim.gridSize.x;
   void set width(num value) {
     if (value == null || value <= 0) return;
-    config.setGridSize(x: value.toInt());
+    sim.gridSize = Point(value, sim.gridSize.y);
   }
 
-  int get height => config.gridSize.y;
+  int get height => sim.gridSize.y;
   void set height(num value) {
     if (value == null || value <= 0) return;
-    config.setGridSize(y: value.toInt());
+    sim.gridSize = Point(sim.gridSize.x, value);
   }
 
-  int get simSpeed => config.simSpeed;
-  void set simSpeed(int value) => config.simSpeed = value;
+  int get simSpeed => engine.simSpeed;
+  void set simSpeed(int value) => engine.simSpeed = value;
 
   String get speedSliderTooltip => "Simulation Speed: $simSpeed";
 
-  ConfigurationComponent(this.config);
+  ConfigurationComponent(this.engine, this.sim);
 
   void onEdgesClicked() {
-    config.toggleGrid();
+    sim.toggleGrid();
   }
 }

lib/components/controls_component.dart

@@ -1,6 +1,7 @@
 import 'package:angular/angular.dart';
 import 'package:angular_components/angular_components.dart';
-import 'package:rules_of_living/service/control_service.dart';
+import 'package:rules_of_living/service/engine_service.dart';
+import 'package:rules_of_living/service/simulation_service.dart';
 
 @Component(
   selector: 'sim-controls',
@@ -15,27 +16,33 @@ import 'package:rules_of_living/service/control_service.dart';
   styleUrls: const ["controls_component.css"],
 )
 class ControlsComponent {
-  final ControlService ctrl;
+  final EngineService engine;
+  final SimulationService sim;
 
-  ControlsComponent(this.ctrl);
+  ControlsComponent(this.engine, this.sim);
 
   void onStartClicked() {
-    ctrl.toggleRunning();
+    engine.toggleRunning();
   }
 
   void onStepClicked() {
-    ctrl.step();
+    engine.step();
   }
 
-  void onResetClicked() {
-    ctrl.reset();
+  void onSaveClicked() {
+    sim.save();
+  }
+
+  void onLoadClicked() {
+    sim.load();
   }
 
   void onRandomClicked() {
-    ctrl.addRandomPattern();
+    sim.addRandomPattern();
+    engine.stop();
   }
 
   void onClearClicked() {
-    ctrl.clear();
+    sim.reset();
   }
 }

lib/components/controls_component.html

@@ -1,7 +1,8 @@
 <div id="controls">
-    <material-button id="reset" (click)="onResetClicked()"><material-icon icon="replay" baseline></material-icon></material-button>
+    <material-button id="save" (click)="onSaveClicked()"><material-icon icon="save" baseline></material-icon></material-button>
+    <material-button id="load" (click)="onLoadClicked()"><material-icon icon="history" baseline></material-icon></material-button>
     <material-button id="run" (click)="onStartClicked()">
-        <span [ngSwitch]="ctrl.isRunning">
+        <span [ngSwitch]="engine.isRunning">
             <material-icon *ngSwitchCase="false" icon="play_arrow" baseline></material-icon>
             <material-icon *ngSwitchCase="true" icon="pause" baseline></material-icon>
         </span>

lib/components/simulation_component.dart

@@ -1,7 +1,8 @@
 import 'dart:html' as html;
 
 import 'package:angular/angular.dart';
-import 'package:rules_of_living/service/configuration_service.dart';
+import 'package:rules_of_living/service/engine_service.dart';
+import 'package:rules_of_living/service/simulation_service.dart';
 
 @Component(
   selector: 'gol-simulation',
@@ -10,9 +11,10 @@ import 'package:rules_of_living/service/configuration_service.dart';
   providers: [],
 )
 class SimulationComponent implements OnInit {
-  final ConfigurationService config;
+  final EngineService engine;
+  final SimulationService sim;
 
-  SimulationComponent(this.config);
+  SimulationComponent(this.engine, this.sim);
 
   @override
   void ngOnInit() {
@@ -29,6 +31,6 @@ class SimulationComponent implements OnInit {
     
     the canvas did not load correctly :(
     ''', canvas.width / 2 - 50, canvas.height / 2);
-    config.canvas = canvas;
+    sim.canvas = canvas;
   }
 }

lib/service/configuration_service.dart

@@ -1,43 +0,0 @@
-import 'dart:html' as html;
-import 'dart:math';
-
-import 'package:rules_of_living/service/engine_service.dart';
-
-class ConfigurationService {
-  final EngineService _es;
-
-  bool showGrid;
-
-  int _simSpeed;
-
-  ConfigurationService(this._es) {
-    showGrid = false;
-    simSpeed = 5;
-  }
-
-  /// Simulation Speed
-  ///
-  /// Sets the number of updates the simulation takes per second. Can range from
-  /// 1 to arbitrarily high numbers (though setting it too high can potentially
-  /// make the app brittle).
-  int get simSpeed => _simSpeed;
-  void set simSpeed(int val) {
-    _simSpeed = val;
-    _es.engine.stepsPerSecond = simSpeed;
-  }
-
-  void set canvas(html.CanvasElement canvas) => _es.engine.canvas = canvas;
-  html.CanvasElement get canvas => _es.engine.canvas;
-
-  void toggleGrid() {
-    showGrid = !showGrid;
-  }
-
-  void setGridSize({int x, int y}) {
-    x = x ?? _es.engine.gridSize.x;
-    y = y ?? _es.engine.gridSize.y;
-    _es.engine.gridSize = Point(x, y);
-  }
-
-  Point<int> get gridSize => _es.engine.gridSize;
-}

lib/service/control_service.dart

@@ -1,38 +0,0 @@
-import 'package:rules_of_living/service/engine_service.dart';
-
-class ControlService {
-  EngineService _es;
-
-  ControlService(this._es);
-
-  void run() {
-    _es.engine.running = true;
-  }
-
-  void stop() {
-    _es.engine.running = false;
-  }
-
-  void toggleRunning() {
-    _es.engine.running = !_es.engine.running;
-  }
-
-  void step() {
-    _es.engine.step();
-  }
-
-  void reset() {
-    _es.engine.reset();
-  }
-
-  void addRandomPattern() {
-    _es.engine.running = false;
-    _es.engine.addPattern();
-  }
-
-  void clear() {
-    _es.engine.clear();
-  }
-
-  bool get isRunning => _es.engine.running;
-}

lib/service/engine_service.dart

@@ -1,8 +1,13 @@
 import 'package:rules_of_living/src/Engine.dart';
+import 'package:rules_of_living/src/Simulation.dart';
 
 class EngineService {
   Engine _uncachedEngineAccess;
 
+  EngineService() {
+    simSpeed = 5;
+  }
+
   Engine get engine => _uncachedEngineAccess ?? _setCachedAndReturn(Engine());
   void set engine(Engine newEngine) {
     _uncachedEngineAccess = newEngine;
@@ -12,4 +17,32 @@ class EngineService {
     engine = newEngine;
     return newEngine;
   }
+
+  void run() {
+    engine.running = true;
+  }
+
+  void stop() {
+    engine.running = false;
+  }
+
+  void toggleRunning() {
+    engine.running = !engine.running;
+  }
+
+  void step() {
+    engine.step();
+  }
+
+  /// Simulation Speed
+  ///
+  /// Sets the number of updates the simulation takes per second. Can range from
+  /// 1 to arbitrarily high numbers (though setting it too high can potentially
+  /// make the app brittle).
+  int get simSpeed => engine.stepsPerSecond;
+  void set simSpeed(int val) => engine.stepsPerSecond = val;
+
+  bool get isRunning => engine.running;
+
+  void set simulation(Simulation value) => engine.simulation = value;
 }

lib/service/simulation_service.dart

@@ -0,0 +1,43 @@
+import 'dart:html' as html;
+import 'dart:math';
+
+import 'package:rules_of_living/service/engine_service.dart';
+import 'package:rules_of_living/src/Simulation.dart';
+
+class SimulationService {
+  // DEFAULT VALUES
+  static final int DEFAULT_GRID_SIZE = 50;
+
+  final EngineService _engine;
+  final Simulation _sim;
+
+  SimulationService(this._engine, [Simulation sim])
+      : this._sim = sim ?? Simulation(DEFAULT_GRID_SIZE, DEFAULT_GRID_SIZE) {
+    _engine.simulation = _sim;
+    _sim.addRandomPattern(amount: 15, dispersal: 5);
+  }
+
+  void reset() {
+    _sim.reset();
+  }
+
+  void addRandomPattern() {
+    _sim.addRandomPattern();
+  }
+
+  Point<int> get gridSize => _sim.gridSize;
+  void set gridSize(Point<int> size) {
+    _sim.gridSize = size;
+  }
+
+  //TODO split into RenderService when rendering is decoupled from engine.
+  html.CanvasElement get canvas => _engine.engine.canvas;
+  void set canvas(html.CanvasElement canvas) => _engine.engine.canvas = canvas;
+
+  void toggleGrid() {
+    _sim.renderEdges = !_sim.renderEdges;
+  }
+
+  void save() => _sim.saveSnapshot();
+  void load() => _sim.loadSnapshot();
+}

lib/src/Cell.dart

@@ -1,36 +0,0 @@
-import 'package:rules_of_living/src/Rule.dart';
-
-class Cell {
-  bool state;
-  bool nextState = false;
-  List<Rule> surviveRules = new List<Rule>();
-  List<Rule> birthRules = new List<Rule>();
-
-  /// For determining if render updates are necessary in [Grid].render() function
-  bool dirty = false;
-
-  Cell([bool state = false]) : this.state = state;
-
-  // Sets the actual state to what it should be next update
-  // Returns the newly assumed actual state of the cell.
-  bool advanceState() {
-    this.state = this.nextState;
-    this.nextState = false;
-
-    this.dirty = true;
-
-    return this.state;
-  }
-
-  void update(int neighbors) {
-    if (state == true) {
-      surviveRules.forEach((Rule rule) {
-        if (rule.evaluate(neighbors) == true) this.nextState = true;
-      });
-    } else {
-      birthRules.forEach((Rule rule) {
-        if (rule.evaluate(neighbors) == true) this.nextState = true;
-      });
-    }
-  }
-}

lib/src/Engine.dart

@@ -1,5 +1,4 @@
 import 'dart:html' as html;
-import 'dart:math';
 
 import 'package:rules_of_living/src/Simulation.dart';
 
@@ -29,16 +28,6 @@ class Engine {
   // ms stuck in updateloop after which game will declare itself unresponsive
   final int SAFETY_TIMEOUT = 2000;
 
-  /// Grid Size
-  ///
-  /// Number of cells on x coordinate and y coordinate. Can be set individually.
-  Point get gridSize => Point<int>(_grid.w, _grid.h);
-  void set gridSize(Point<int> value) {
-    if (value.x <= 0 || value.y <= 0)
-      throw ArgumentError("grid size must not be smaller than 1");
-    _grid = Simulation(value.x, value.y);
-  }
-
   num _updateLag = 0.0;
   num _drawLag = 0.0;
 
@@ -48,60 +37,58 @@ class Engine {
   /// be used if no canvas was defined at engine creation and it should be
   /// rendered later.
   html.CanvasElement canvas;
-  Simulation _grid;
+  Simulation _simulation;
   bool running = false;
 
-  Engine([x = 100, y = 100, this.canvas]) {
-    _grid = Simulation(x, y);
-
+  Engine() {
     _elapsed.start();
-    _grid.addPattern(amount: 15, dispersal: 5);
     html.window.animationFrame.then(animFrame);
   }
 
   void animFrame(num now) {
-    process(now);
+    int elapsed = _elapsed.elapsedMilliseconds;
+    _elapsed.reset();
+    process(elapsed, SAFETY_TIMEOUT, update: this.update, render: this.render);
     html.window.animationFrame.then(animFrame);
   }
 
-  void reset() {
-    _grid.reset();
-    running = false;
-  }
+  void process(int elapsed, int timeOut, {Function update, Function render}) {
+    _drawLag += elapsed;
+    _updateLag += elapsed;
 
-  void clear() {
-    _grid = new Simulation(gridSize.x, gridSize.y);
-    running = false;
-  }
-
-  void process(num now) {
-    _drawLag += _elapsed.elapsedMilliseconds;
-    _updateLag += _elapsed.elapsedMilliseconds;
-    _elapsed.reset();
-
-    while (_updateLag >= _MS_PER_STEP) {
-      if (_elapsed.elapsedMilliseconds > SAFETY_TIMEOUT) {
-        // TODO stub - give warning etc when this occurs
-        print("ERROR STUCK IN UPDATE LOOP");
-        break;
-      }
-      if (running == true) update();
+    while (running == true &&
+        _shouldUpdate(_updateLag, elapsed, timeOut) == true) {
       _updateLag -= _MS_PER_STEP;
+      if (update == null) break;
+      update();
     }
 
     if (_drawLag >= _MS_PER_FRAME) {
-      render(_updateLag / _MS_PER_STEP);
       _drawLag = 0;
+      if (render == null) return;
+      render(_updateLag / _MS_PER_STEP);
     }
   }
 
+  bool _shouldUpdate(int updateLag, int elapsed, int timeOut) {
+    if (updateLag < _MS_PER_STEP) return false;
+    if (elapsed > timeOut) throw StackOverflowError;
+
+    return true;
+  }
+
   /// Update Engine Logic
   ///
   /// Updates the logic of the engine by one tick. Should usually not be called
   /// directly, since it is automatically taken care of by the processing function.
   /// If simulation should be advanced manually one time, prefer using step().
   void update() {
-    if (!_grid.update()) running = false;
+    if (_simulation == null) return;
+
+    Map<int, bool> simulationUpdate = _simulation.update();
+    _simulation.mergeStateChanges(simulationUpdate);
+
+    if (simulationUpdate.length == 0) running = false;
   }
 
   /// Advances Logic One Update
@@ -110,8 +97,8 @@ class Engine {
   /// simulation. Does not automatically re-render the new state
   /// (though this should usually not pose a problem).
   void step() {
+    update();
     running = false;
-    _grid.update();
   }
 
   /// Renders the Current Simulation State
@@ -120,26 +107,10 @@ class Engine {
   /// the internal engine processing. Does not do anything if no canvas is
   /// defined.
   void render([num interp]) {
-    if (canvas != null) _grid.render(canvas, interp);
+    if (canvas == null || _simulation == null) return;
+
+    _simulation.render(canvas, interp);
   }
 
-  void addPattern(
-      {CellPattern pattern,
-      int x,
-      int y,
-      int amount,
-      int dispersal,
-      int seed}) {
-    _grid.addPattern(
-        pattern: pattern,
-        x: x,
-        y: y,
-        amount: amount,
-        dispersal: dispersal,
-        seed: seed);
-  }
-
-  void toggleEdgeRendering() {
-    _grid.renderEdges = !_grid.renderEdges;
-  }
+  void set simulation(Simulation value) => _simulation = value;
 }

lib/src/Rule.dart

@@ -1,5 +0,0 @@
-class Rule {
-  final Function evaluate;
-
-  Rule(this.evaluate);
-}

lib/src/Simulation.dart

@@ -1,147 +1,116 @@
 import 'dart:html' as html;
 import 'dart:math' as math;
+import 'dart:math';
 
-import 'package:rules_of_living/src/Cell.dart';
 import 'package:rules_of_living/src/Grid.dart';
-import 'package:rules_of_living/src/Rule.dart';
+import 'package:rules_of_living/src/rules/GameOfLife.dart';
+import 'package:rules_of_living/src/rules/RuleSet.dart';
 
 enum CellPattern { SpaceShip, Blinker }
 
 class Simulation {
-  final Grid<Cell> map;
+  Grid<bool> map;
+  Grid<bool> _snapshot;
+
+  RuleSet rules = GameOfLife();
 
   bool _dirty = true;
-  bool _renderEdges = true;
+  bool get dirty => _dirty;
+
+  bool _renderEdges = true;
+  bool get renderEdges => _renderEdges;
 
-  int _startingSeed;
-  int _x;
-  int _y;
   int _amount;
   int _dispersal;
-  CellPattern _pattern;
 
-  int get w => map.width;
-  int get h => map.height;
+  Point get gridSize => Point<int>(map.width, map.height);
+  void set gridSize(Point<int> value) {
+    if (value.x <= 0 || value.y <= 0)
+      throw ArgumentError("grid size must not be smaller than 1");
+    map = Grid(value.x, value.y);
+  }
 
   Simulation(int w, int h) : this.map = new Grid(w, h) {
-    for (int i = 0; i < map.length; i++) {
-      map[i] = _getGOLCell();
-    }
-    print("Grid creation finished");
+    this.map = reset();
   }
 
-  Cell _getGOLCell([bool defaultState = false]) {
-    Cell cell = Cell(defaultState);
-    Rule threeTrue = new Rule((int n) {
-      if (n == 3) return true;
-      return false;
-    });
-    Rule twoTrue = new Rule((int n) {
-      if (n == 2) return true;
-      return false;
-    });
-    cell.surviveRules.add(twoTrue);
-    cell.surviveRules.add(threeTrue);
-    cell.birthRules.add(threeTrue);
-    return cell;
-  }
+  Simulation.fromGrid(Grid<bool> map) : this.map = map;
 
-  void reset() {
-    map.setAll(0, List.filled(map.length, _getGOLCell()));
-    if (_startingSeed != null)
-      addPattern(
-          pattern: _pattern,
-          dispersal: _dispersal,
-          amount: _amount,
-          seed: _startingSeed,
-          x: _x,
-          y: _y);
+  Grid<bool> reset([Grid<bool> map]) {
+    map ??= this.map;
     _dirty = true;
+    map.setAll(0, List.filled(map.length, false));
+    return map;
   }
 
-  void addPattern(
-      {CellPattern pattern,
-      int x,
-      int y,
-      int amount,
-      int dispersal,
-      int seed}) {
-    _startingSeed = seed ?? DateTime.now().millisecondsSinceEpoch;
+  void addRandomPattern({int amount, int dispersal}) {
+    int _startingSeed = DateTime.now().millisecondsSinceEpoch;
     math.Random rng = new math.Random(_startingSeed);
-    _x = x;
-    _y = y;
     _amount = amount ?? rng.nextInt(20);
     _dispersal = dispersal ?? 10;
-    _pattern = pattern;
-    int cx = x ?? rng.nextInt(map.width ~/ 3) + (map.width ~/ 3);
-    int cy = y ?? rng.nextInt(map.height ~/ 3) + (map.height ~/ 3);
-    switch (pattern) {
-      // Two blocks, offset
-      // ##
-      //   ##
-      case CellPattern.Blinker:
-        setCellState(cx, cy, true);
-        setCellState(cx + 1, cy, true);
-        setCellState(cx, cy + 1, true);
-        setCellState(cx + 1, cy + 1, true);
+    int cx = rng.nextInt(map.width ~/ 3) + (map.width ~/ 3);
+    int cy = rng.nextInt(map.height ~/ 3) + (map.height ~/ 3);
 
-        setCellState(cx + 2, cy + 2, true);
-        setCellState(cx + 3, cy + 2, true);
-        setCellState(cx + 2, cy + 3, true);
-        setCellState(cx + 3, cy + 3, true);
-        break;
-      // A 'gliding' Spaceship
-      //   #
-      //    #
-      //  ###
-      case CellPattern.SpaceShip:
-        setCellState(1 + cx, 0 + cy, true);
-        setCellState(2 + cx, 1 + cy, true);
-        setCellState(2 + cx, 2 + cy, true);
-        setCellState(1 + cx, 2 + cy, true);
-        setCellState(0 + cx, 2 + cy, true);
-        break;
-      default:
-        int sanityCheck = 0;
-        for (var i = 0; i < (_amount); i++) {
-          sanityCheck++;
-          getCellState(cx, cy)
-              ? i--
-              : setCellState(cx + rng.nextInt(_dispersal),
-                  cy + rng.nextInt(_dispersal), true);
-          if (sanityCheck > 100 && sanityCheck > i * 3) break;
-        }
-        break;
+    int sanityCheck = 0;
+    for (var i = 0; i < (_amount); i++) {
+      sanityCheck++;
+      getCellState(cx, cy)
+          ? i--
+          : setCellState(
+              cx + rng.nextInt(_dispersal), cy + rng.nextInt(_dispersal), true);
+      if (sanityCheck > 100 && sanityCheck > i * 3) break;
     }
+
     _dirty = true;
   }
 
   void setCellState(int x, int y, bool state) {
-    if (y < map.height && x < map.width) map.get(x, y).state = state;
+    if (y >= map.height || x >= map.width) return null;
+
+    state ? map.set(x, y, true) : map.set(x, y, false);
   }
 
   bool getCellState(int x, int y) {
-    if (y < map.height && x < map.width) return map.get(x, y).state;
-    return null;
+    if (y >= map.height || x >= map.width) return null;
+
+    return map.get(x, y);
   }
 
-  bool update() {
-    bool stateChanges = false;
+  void toggleCellState(int x, int y) {
+    if (y >= map.height || x >= map.width) return null;
 
-    for (int i = 0; i < map.length; i++) {
-      math.Point p = map.toCoordinates(i);
-      map[i].update(getSurroundingNeighbors(p.x, p.y, 1));
-    }
-    // TODO when implementing changeSet we can remove this second loop and add to changeSet in the first
-    map.forEach((Cell el) {
-      if (el.state != el.nextState) stateChanges = true;
-      el.advanceState();
-    });
-    stateChanges ? _dirty = true : false;
+    getCellState(x, y) == null
+        ? setCellState(x, y, true)
+        : setCellState(x, y, false);
+  }
+
+  Map<int, bool> update() {
+    Map<int, bool> stateChanges = calculateNextState(map);
     return stateChanges;
   }
 
-  int getSurroundingNeighbors(int x, int y, int range) {
+  void mergeStateChanges(Map<int, bool> stateChanges) {
+    stateChanges.forEach((i, el) => map[i] = el);
+    if (stateChanges.length != 0) _dirty = true;
+  }
+
+  Map<int, bool> calculateNextState(Grid<bool> oldState) {
+    Map<int, bool> stateChanges = Map();
+
+    for (int i = 0; i < map.length; i++) {
+      math.Point p = map.toCoordinates(i);
+      bool cell = map[i];
+      int neighbors = getNeighbors(p.x, p.y, rules.range);
+      if (cell == false && rules.checkBirth(neighbors) == true) {
+        stateChanges[i] = true;
+      } else if (cell == true && rules.checkSurvival(neighbors) == false) {
+        stateChanges[i] = false;
+      }
+    }
+    return stateChanges;
+  }
+
+  int getNeighbors(int x, int y, int range) {
     int count = 0;
     for (int ix = -range + x; ix <= range + x; ix++) {
       for (int iy = -range + y; iy <= range + y; iy++) {
@@ -149,7 +118,7 @@ class Simulation {
             iy >= 0 &&
             ix < map.width &&
             iy < map.height &&
-            map.get(ix, iy).state == true &&
+            getCellState(ix, iy) == true &&
             !(x == ix && y == iy)) count++;
       }
     }
@@ -171,7 +140,7 @@ class Simulation {
         ctx.strokeRect(p.x * brickW, p.y * brickH, brickW, brickH);
       }
 
-      if (map[i].state == true)
+      if (map[i] == true)
         ctx.setFillColorRgb(155, 155, 255);
       else
         ctx.setFillColorRgb(0, 0, 0);
@@ -185,5 +154,10 @@ class Simulation {
     _dirty = true;
   }
 
-  bool get renderEdges => _renderEdges;
+  void saveSnapshot() => _snapshot = Grid.from(map);
+  Grid<bool> loadSnapshot() {
+    map = Grid.from(_snapshot);
+    _dirty = true;
+    return map;
+  }
 }

lib/src/rules/CellPattern.dart

@@ -0,0 +1,17 @@
+import 'dart:math';
+
+import 'package:collection/collection.dart';
+
+class CellPattern extends DelegatingList<Point> {
+  final String _name;
+  CellPattern(String name, List<Point> base)
+      : _name = name,
+        super(base);
+
+  String get name => _name;
+
+  @override
+  String toString() {
+    return "$name: ${super.toString()}";
+  }
+}

lib/src/rules/GameOfLife.dart

@@ -0,0 +1,38 @@
+import 'dart:math';
+
+import 'package:rules_of_living/src/rules/RuleSet.dart';
+import 'package:rules_of_living/src/rules/CellPattern.dart';
+
+class GameOfLife implements RuleSet {
+  int range = 1;
+  List<CellPattern> patterns = <CellPattern>[
+    // Two blocks, offset
+    // ##
+    //   ##
+    CellPattern("Blinker", [
+      Point(0, 0),
+      Point(1, 0),
+      Point(0, 1),
+      Point(1, 1),
+      Point(2, 2),
+      Point(3, 2),
+      Point(2, 3),
+      Point(3, 3)
+    ]),
+    // A 'gliding' Spaceship
+    //   #
+    //    #
+    //  ###
+    CellPattern("SpaceShip", [
+      Point(1, 0),
+      Point(2, 1),
+      Point(2, 2),
+      Point(1, 2),
+      Point(0, 2),
+    ])
+  ];
+
+  bool checkSurvival(int neighbors) =>
+      neighbors == 2 || neighbors == 3 ? true : false;
+  bool checkBirth(int neighbors) => neighbors == 3 ? true : false;
+}

lib/src/rules/RuleSet.dart

@@ -0,0 +1,9 @@
+import 'package:rules_of_living/src/rules/CellPattern.dart';
+
+abstract class RuleSet {
+  int range;
+  List<CellPattern> patterns;
+
+  bool checkSurvival(int neighbors);
+  bool checkBirth(int neighbors);
+}

test/service/configuration_service_test.dart

@@ -1,46 +0,0 @@
-import 'dart:math';
-
-import 'package:mockito/mockito.dart';
-import 'package:rules_of_living/service/configuration_service.dart';
-import 'package:rules_of_living/service/engine_service.dart';
-import 'package:rules_of_living/src/Engine.dart';
-@TestOn('browser')
-import 'package:test/test.dart';
-
-class MockEngine extends Mock implements Engine {}
-
-void main() {
-  ConfigurationService sut;
-  EngineService engineService;
-  MockEngine me;
-  setUp(() {
-    me = MockEngine();
-    engineService = EngineService();
-    engineService.engine = me;
-    sut = ConfigurationService(engineService);
-  });
-
-  group("simulation speed", () {
-    test("speed changes propagate to engine", () {
-      sut.simSpeed = 312;
-      verify(me.stepsPerSecond = 312);
-    });
-  });
-
-  group("grid size", () {
-    test("grid changes are sent to engine", () {
-      sut.setGridSize(x: 512, y: 388);
-      verify(me.gridSize = Point(512, 388));
-    });
-    test("grid can be changed solely on x axis", () {
-      when(me.gridSize).thenReturn(Point(100, 100));
-      sut.setGridSize(x: 555);
-      verify(me.gridSize = Point(555, 100));
-    });
-    test("grid can be changed solely on y axis", () {
-      when(me.gridSize).thenReturn(Point(100, 100));
-      sut.setGridSize(y: 556);
-      verify(me.gridSize = Point(100, 556));
-    });
-  });
-}

test/service/simulation_service_test.dart

@@ -0,0 +1,23 @@
+import 'package:rules_of_living/service/engine_service.dart';
+import 'package:rules_of_living/service/simulation_service.dart';
+import 'package:rules_of_living/src/Simulation.dart';
+import 'package:test/test.dart';
+import 'package:mockito/mockito.dart';
+
+class MockSimulation extends Mock implements Simulation {}
+
+class MockEngineService extends Mock implements EngineService {}
+
+void main() {
+  SimulationService sut;
+  MockSimulation mockSim = MockSimulation();
+  setUp(() => sut = SimulationService(MockEngineService(), mockSim));
+  test("calling save calls through to Simulation.saveSnapshot", () {
+    sut.save();
+    verify(mockSim.saveSnapshot());
+  });
+  test("calling load calls through to Simulation.loadSnapshot", () {
+    sut.load();
+    verify(mockSim.loadSnapshot());
+  });
+}

test/simulation_test.dart

@@ -0,0 +1,50 @@
+import 'dart:math';
+import 'package:mockito/mockito.dart';
+import 'package:rules_of_living/src/Grid.dart';
+import 'package:test/test.dart';
+
+import 'package:rules_of_living/src/Simulation.dart';
+
+class MockGrid extends Mock implements Grid<bool> {}
+
+void main() {
+  Simulation sut;
+  setUp(() {
+    sut = Simulation(10, 10);
+  });
+  group("gridSize", () {
+    test(
+        "returns the width and height of the underlying grid",
+        () => expect(
+            sut.gridSize, equals(Point<int>(sut.map.width, sut.map.height))));
+    test("sets the underlying grid width and height", () {
+      sut.gridSize = Point(2, 3);
+      expect(sut.gridSize, equals(Point(2, 3)));
+    });
+    test("creates a new underlying grid on resizing", () {
+      var oldMap = sut.map;
+      sut.gridSize = Point(10, 10);
+      expect(sut.map, isNot(oldMap));
+    });
+  });
+  group("reset", () {
+    test("returns a map filled with 'false' ", () {
+      expect(sut.reset(), allOf(TypeMatcher<Grid>(), isNot(contains(true))));
+    });
+    test("sets the simulation to need re-rendering", () {
+      sut.reset();
+      expect(sut.dirty, true);
+    }, skip: "can not find a way to set dirty to true first yet");
+  });
+  group("save&load", () {
+    test(
+        "saves a copy of the map which does not change when the actual map changes",
+        () {
+      sut.saveSnapshot();
+      sut.mergeStateChanges({1: true, 2: true});
+      var snapshot = Grid.from(sut.map);
+
+      expect(sut.loadSnapshot(), isNot(equals(snapshot)));
+    });
+  });
+}

test/src/engine_test.dart

@@ -1,15 +1,106 @@
 import 'dart:html' as html;
-import 'dart:math';
+import 'package:rules_of_living/src/Simulation.dart';
+import 'package:test/test.dart';
+import 'package:mockito/mockito.dart';
 
 @TestOn('browser')
 import 'package:rules_of_living/src/Engine.dart';
-import 'package:test/test.dart';
+
+class MockSimulation extends Mock implements Simulation {
+  int updateNum = 0;
+  bool hasChanges = false;
+
+  @override
+  Map<int, bool> update() {
+    updateNum++;
+    return hasChanges ? {1: true, 2: false} : {};
+  }
+}
 
 void main() {
   Engine sut;
   setUp(() {
     sut = Engine();
   });
+  group("process", () {
+    setUp(() => sut.running = true);
+    test("errors out if updating takes too long",
+        () => expect(() => sut.process(5000, 10), throwsA(StackOverflowError)));
+    test("does not update if not enough time elapsed to pass ms per step", () {
+      bool result = false;
+      sut.stepsPerSecond = 1000;
+
+      sut.process(999, 2000,
+          update: () => result = true, render: (double interp) => null);
+
+      expect(result, true);
+    });
+    test("updates only when the ms per step threshold is crossed", () {
+      int updateNum = 0;
+      sut.stepsPerSecond = 1;
+
+      sut.process(1001, 2000, update: () => updateNum++);
+      expect(updateNum, equals(1));
+    });
+    test("updates until updateLag has been resolved", () {
+      int updateNum = 0;
+      sut.stepsPerSecond = 1;
+
+      sut.process(2999, 5000, update: () => updateNum++);
+      expect(updateNum, equals(2));
+    });
+    test("works without passing in update or render function arguments", () {
+      sut.stepsPerSecond = 1000;
+      expect(() => sut.process(500, 5000), isNot(throwsA(anything)));
+    });
+  });
+  group("update", () {
+    MockSimulation mockSim;
+    setUp(() {
+      mockSim = MockSimulation();
+      sut.simulation = mockSim;
+    });
+    test("does not error out if no simulation variable is set", () {
+      sut.simulation = null;
+      expect(() => sut.update(), isNot(throwsA(anything)));
+    });
+    test("updates simulation one tick for every time it is called", () {
+      sut.update();
+      sut.update();
+      sut.update();
+      expect(mockSim.updateNum, equals(3));
+    });
+    test("sets running to false when simulation returns no changes", () {
+      sut.running = true;
+      sut.update();
+      expect(sut.running, equals(false));
+    });
+    test("keeps running when simulation returns changes", () {
+      sut.running = true;
+      mockSim.hasChanges = true;
+
+      sut.update();
+
+      expect(sut.running, equals(true));
+    });
+  });
+  group("step", () {
+    MockSimulation mockSim;
+    setUp(() {
+      mockSim = MockSimulation();
+      sut.simulation = mockSim;
+    });
+    test("advances the simulation by one update", () {
+      sut.step();
+      expect(mockSim.updateNum, equals(1));
+    });
+    test("turns off continuous engine updates", () {
+      sut.running = true;
+      sut.step();
+
+      expect(sut.running, equals(false));
+    });
+  });
   group("canvas", () {
     test("Engine can be instantiated without canvas", () {
       expect(sut, isNot(throwsNoSuchMethodError));
@@ -31,12 +122,4 @@ void main() {
       expect(sut.canvas, isNotNull);
     });
   });
-  group("gridSize", () {
-    test("zero gridSizes throw ArgumentErrors", () {
-      expect(() => sut.gridSize = Point(0, 5), throwsArgumentError);
-    });
-    test("negative gridSizes throw ArgumentErrors", () {
-      expect(() => sut.gridSize = Point(1, -5), throwsArgumentError);
-    });
-  });
 }

test/src/rules/cellpattern_test.dart

@@ -0,0 +1,19 @@
+import 'dart:math';
+
+import 'package:rules_of_living/src/rules/CellPattern.dart';
+import 'package:test/test.dart';
+
+void main() {
+  CellPattern sut;
+  setUp(() {
+    sut = CellPattern("testPattern", [Point(1, 1), Point(0, 0), Point(-1, -1)]);
+  });
+  group("Naming", () {
+    test("contains the name passed in for name variable",
+        () => expect(sut.name, "testPattern"));
+    test(
+        "Contains the name passed in on being formatted as String",
+        () => expect(sut.toString(),
+            "testPattern: [Point(1, 1), Point(0, 0), Point(-1, -1)]"));
+  });
+}

test/src/rules/gameoflife_test.dart

@@ -0,0 +1,27 @@
+import 'package:rules_of_living/src/rules/GameOfLife.dart';
+import 'package:test/test.dart';
+
+void main() {
+  GameOfLife sut;
+  setUp(() {
+    sut = GameOfLife();
+  });
+  group("BirthRules", () {
+    test("will return true when being passed three neighbors",
+        () => expect(sut.checkBirth(3), true));
+    test("will return false when being passed zero neighbors",
+        () => expect(sut.checkBirth(0), false));
+    test("will return false when being passed two neighbors",
+        () => expect(sut.checkBirth(2), false));
+  });
+  group("SurviveRules", () {
+    test("will return true when being passed two neighbors",
+        () => expect(sut.checkSurvival(2), true));
+    test("will return true when being passed three neighbors",
+        () => expect(sut.checkSurvival(3), true));
+    test("will return false when being passed 0 neighbors",
+        () => expect(sut.checkSurvival(0), false));
+    test("will return false when being passed more than 3 neighbors",
+        () => expect(sut.checkSurvival(4), false));
+  });
+}