Merge remote-tracking branch 'origin/42-switch-rendering-to-stagexl' into 42-switch-rendering-to-stagexl

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,8 +4,9 @@ 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',
@@ -23,7 +24,8 @@ import 'package:rules_of_living/service/simulation_service.dart';
   providers: [
     materialProviders,
     ClassProvider(EngineService),
-    ClassProvider(SimulationService)
+    ClassProvider(ConfigurationService),
+    ClassProvider(ControlService)
   ],
   styleUrls: const [
     'package:angular_components/app_layout/layout.scss.css',

lib/components/configuration_component.dart

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

lib/components/controls_component.dart

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

lib/components/controls_component.html

@@ -1,8 +1,7 @@
 <div id="controls">
-    <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="reset" (click)="onResetClicked()"><material-icon icon="replay" baseline></material-icon></material-button>
     <material-button id="run" (click)="onStartClicked()">
-        <span [ngSwitch]="engine.isRunning">
+        <span [ngSwitch]="ctrl.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,8 +1,7 @@
 import 'dart:html' as html;
 
 import 'package:angular/angular.dart';
-import 'package:rules_of_living/service/engine_service.dart';
-import 'package:rules_of_living/service/simulation_service.dart';
+import 'package:rules_of_living/service/configuration_service.dart';
 
 @Component(
   selector: 'gol-simulation',
@@ -11,10 +10,9 @@ import 'package:rules_of_living/service/simulation_service.dart';
   providers: [],
 )
 class SimulationComponent implements OnInit {
-  final EngineService engine;
-  final SimulationService sim;
+  final ConfigurationService config;
 
-  SimulationComponent(this.engine, this.sim);
+  SimulationComponent(this.config);
 
   @override
   void ngOnInit() {
@@ -31,6 +29,6 @@ class SimulationComponent implements OnInit {
     
     the canvas did not load correctly :(
     ''', canvas.width / 2 - 50, canvas.height / 2);
-    sim.canvas = canvas;
+    config.canvas = canvas;
   }
 }

lib/service/configuration_service.dart

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,38 @@
+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,13 +1,8 @@
 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;
@@ -17,32 +12,4 @@ 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

@@ -1,43 +0,0 @@
-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

@@ -0,0 +1,36 @@
+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,7 @@
 import 'dart:html' as html;
+import 'dart:math';
 
+import 'package:rules_of_living/src/Render.dart';
 import 'package:rules_of_living/src/Simulation.dart';
 
 class Engine {
@@ -28,67 +30,104 @@ class Engine {
   // ms stuck in updateloop after which game will declare itself unresponsive
   final int SAFETY_TIMEOUT = 2000;
 
+  bool running = false;
+  Render _render;
+
+  /// Grid Size
+  ///
+  /// Number of cells on x coordinate and y coordinate. Can be set individually.
+  Point get gridSize => Point<int>(_simulation.w, _simulation.h);
+  void set gridSize(Point<int> value) {
+    if (value.x <= 0 || value.y <= 0)
+      throw ArgumentError("grid size must not be smaller than 1");
+    _simulation = Simulation(value.x, value.y);
+  }
+
   num _updateLag = 0.0;
   num _drawLag = 0.0;
 
+  Simulation __simulation;
+  Simulation get _simulation => __simulation;
+  void set _simulation(Simulation value) {
+    __simulation = value;
+    _resetRenderer();
+  }
+
   /// The Canvas to Paint on
   ///
   /// Manually define or change the canvas the engine should render to. Should
   /// be used if no canvas was defined at engine creation and it should be
   /// rendered later.
-  html.CanvasElement canvas;
-  Simulation _simulation;
-  bool running = false;
+  html.CanvasElement _canvas;
+  html.CanvasElement get canvas => _canvas;
+  void set canvas(html.CanvasElement canvas) {
+    _canvas = canvas;
+    _resetRenderer();
+  }
+
+  void _resetRenderer() {
+    if (this.canvas == null || _simulation == null) return;
+    _render = Render(canvas, gridSize);
+  }
+
+  Engine([x = 100, y = 100, canvas]) {
+    this.canvas = canvas;
+    _simulation = Simulation(x, y);
 
-  Engine() {
     _elapsed.start();
+    _simulation.addPattern(amount: 15, dispersal: 5);
     html.window.animationFrame.then(animFrame);
   }
 
   void animFrame(num now) {
-    int elapsed = _elapsed.elapsedMilliseconds;
-    _elapsed.reset();
-    process(elapsed, SAFETY_TIMEOUT, update: this.update, render: this.render);
+    process(now);
     html.window.animationFrame.then(animFrame);
   }
 
-  void process(int elapsed, int timeOut, {Function update, Function render}) {
-    _drawLag += elapsed;
-    _updateLag += elapsed;
+  void reset() {
+    _simulation.reset();
+    running = false;
+  }
 
-    while (running == true &&
-        _shouldUpdate(_updateLag, elapsed, timeOut) == true) {
+  void clear() {
+    _simulation = 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();
       _updateLag -= _MS_PER_STEP;
-      if (update == null) break;
-      update();
     }
 
     if (_drawLag >= _MS_PER_FRAME) {
-      _drawLag = 0;
-      if (render == null) return;
       render(_updateLag / _MS_PER_STEP);
+      _drawLag = 0;
     }
   }
 
-  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 (_simulation == null) return;
-
-    Map<int, bool> simulationUpdate = _simulation.update();
-    _simulation.mergeStateChanges(simulationUpdate);
-
-    if (simulationUpdate.length == 0) running = false;
+    Map<int, bool> stateChanges = _simulation.update();
+    if (stateChanges.length == 0) {
+      running = false;
+      return;
+    } else {
+      _render.mergeChanges(stateChanges);
+    }
   }
 
   /// Advances Logic One Update
@@ -97,8 +136,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;
+    _simulation.update();
   }
 
   /// Renders the Current Simulation State
@@ -106,11 +145,25 @@ class Engine {
   /// Renders the simulation once. Will usually automatically be called by
   /// the internal engine processing. Does not do anything if no canvas is
   /// defined.
-  void render([num interp]) {
-    if (canvas == null || _simulation == null) return;
+  void render([num interp]) {}
 
-    _simulation.render(canvas, interp);
+  void addPattern(
+      {CellPattern pattern,
+      int x,
+      int y,
+      int amount,
+      int dispersal,
+      int seed}) {
+    _simulation.addPattern(
+        pattern: pattern,
+        x: x,
+        y: y,
+        amount: amount,
+        dispersal: dispersal,
+        seed: seed);
   }
 
-  void set simulation(Simulation value) => _simulation = value;
+  void toggleEdgeRendering() {
+//    _grid.renderEdges = !_grid.renderEdges;
+  }
 }

lib/src/Render.dart

@@ -0,0 +1,121 @@
+import 'dart:html' as html;
+import 'dart:math';
+import 'package:stagexl/stagexl.dart' as sxl;
+
+class ColorScheme {
+  //TODO make iterable (perhaps through backing list which gets accesses by the variables)
+  final int ON;
+  final int EXPANSION;
+  final int CORE;
+  final int OFF;
+
+  const ColorScheme(this.ON, this.EXPANSION, this.CORE,
+      [this.OFF = sxl.Color.Transparent]);
+}
+
+class Render {
+  final sxl.Stage _stage;
+  final sxl.RenderLoop _renderLoop = sxl.RenderLoop();
+  Map<int, sxl.BitmapData> _colorMap;
+  final sxl.BitmapContainer _renderContainer = sxl.BitmapContainer();
+
+  bool transparentBG = false;
+  bool _renderEdges = false;
+  bool get renderEdges => _renderEdges;
+  void set renderEdges(bool value) {
+    _renderEdges = value;
+    _colorMap = _getColorMap(_cellSize, _colorScheme);
+  }
+
+  Point<int> _gridSize;
+  Point<int> get _cellSize => Point(
+      _stage.stageWidth ~/ _gridSize.x, _stage.stageHeight ~/ _gridSize.y);
+
+  final ColorScheme _colorScheme;
+  //TODO replace with scheme data structure to enable different color scheme injection
+  static const defaultScheme =
+      ColorScheme(sxl.Color.Blue, 1, 1, sxl.Color.Black);
+
+  // TODO gridSize rendering can only be scaled uniformly currently - switch to Point(w,h)?
+  Render(html.CanvasElement canvas, Point<int> gridSize,
+      [ColorScheme colorScheme = defaultScheme])
+      : _stage = _createStage(canvas),
+        _colorScheme = colorScheme,
+        _gridSize = gridSize {
+    _colorMap = _getColorMap(_cellSize, colorScheme);
+    _initRenderGrid(_cellSize, gridSize).forEach((sxl.Bitmap bm) {
+      _renderContainer.addChild(bm);
+    });
+    _renderLoop.addStage(_stage);
+    _stage.addChild(_renderContainer);
+    setDirty();
+  }
+
+  static sxl.Stage _createStage(html.CanvasElement canvas) {
+    sxl.StageXL.stageOptions.renderEngine = sxl.RenderEngine.WebGL;
+    sxl.StageXL.stageOptions.stageRenderMode = sxl.StageRenderMode.AUTO_INVALID;
+//    sxl.StageXL.stageOptions.backgroundColor = sxl.Color.Yellow;
+    return sxl.Stage(canvas);
+  }
+
+  Map<int, sxl.BitmapData> _getColorMap(Point<int> size, ColorScheme scheme) {
+    print("${size.toString()}, ${scheme.toString()}");
+
+    // Creates a shape with color of each quad in scheme
+    sxl.Shape shape = sxl.Shape();
+    // ON
+    shape.graphics.beginPath();
+    shape.graphics.rect(0 * size.x, 0, size.x, size.y);
+    shape.graphics.fillColor(scheme.ON ?? sxl.Color.Transparent);
+    shape.graphics
+        .strokeColor(renderEdges ? sxl.Color.DarkGray : sxl.Color.Transparent);
+    shape.graphics.closePath();
+    // OFF
+    shape.graphics.beginPath();
+    shape.graphics.rect(1 * size.x, 0, size.x, size.y);
+    shape.graphics.fillColor(scheme.OFF ?? sxl.Color.Transparent);
+    shape.graphics
+        .strokeColor(renderEdges ? sxl.Color.DarkGray : sxl.Color.Transparent);
+    shape.graphics.closePath();
+
+    // creates one texture out of shape
+    sxl.BitmapData texture = sxl.BitmapData(2 * size.x, size.y);
+    texture.draw(shape);
+    // re-slice texture into individual BitmapDatas
+    Map<int, sxl.BitmapData> colorMap = Map();
+    List<sxl.BitmapData> colorBitmaps = texture.sliceIntoFrames(size.x, size.y);
+    print("Found ${colorBitmaps.length} colors.");
+    // TODO more elegant way through iterables etc; also include EXPANSION, CORE functionality
+    colorMap[scheme.ON] = colorBitmaps[0];
+    colorMap[scheme.OFF] = colorBitmaps[1];
+
+    return colorMap;
+  }
+
+  List<sxl.Bitmap> _initRenderGrid(Point<int> cellSize, Point<int> gridSize) {
+    List<sxl.Bitmap> grid = List();
+    for (int y = 0; y < gridSize.y; y++) {
+      for (int x = 0; x < gridSize.x; x++) {
+        sxl.Bitmap bm = sxl.Bitmap();
+
+        bm.bitmapData = _colorMap[_colorScheme.OFF];
+        bm.x = x * cellSize.x;
+        bm.y = y * cellSize.y;
+        grid.add(bm);
+      }
+    }
+
+    return grid;
+  }
+
+  void setDirty() => _stage.invalidate();
+
+  void mergeChanges(Map<int, bool> stateChanges) {
+    if (stateChanges.length == 0) return;
+    stateChanges.forEach((int i, bool state) {
+      _renderContainer.getChildAt(i).bitmapData =
+          (state ? _colorMap[_colorScheme.ON] : _colorMap[_colorScheme.OFF]);
+    });
+    setDirty();
+  }
+}

lib/src/Rule.dart

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

lib/src/Simulation.dart

@@ -1,116 +1,148 @@
 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/rules/GameOfLife.dart';
-import 'package:rules_of_living/src/rules/RuleSet.dart';
+import 'package:rules_of_living/src/Rule.dart';
 
 enum CellPattern { SpaceShip, Blinker }
 
 class Simulation {
-  Grid<bool> map;
-  Grid<bool> _snapshot;
-
-  RuleSet rules = GameOfLife();
+  final Grid<Cell> map;
 
   bool _dirty = true;
-  bool get dirty => _dirty;
-
   bool _renderEdges = true;
-  bool get renderEdges => _renderEdges;
 
+  int _startingSeed;
+  int _x;
+  int _y;
   int _amount;
   int _dispersal;
+  CellPattern _pattern;
 
-  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);
-  }
+  int get w => map.width;
+  int get h => map.height;
 
   Simulation(int w, int h) : this.map = new Grid(w, h) {
-    this.map = reset();
+    for (int i = 0; i < map.length; i++) {
+      map[i] = _getGOLCell();
+    }
+    print("Grid creation finished");
   }
 
-  Simulation.fromGrid(Grid<bool> map) : this.map = map;
+  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;
+  }
 
-  Grid<bool> reset([Grid<bool> map]) {
-    map ??= this.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);
     _dirty = true;
-    map.setAll(0, List.filled(map.length, false));
-    return map;
   }
 
-  void addRandomPattern({int amount, int dispersal}) {
-    int _startingSeed = DateTime.now().millisecondsSinceEpoch;
+  void addPattern(
+      {CellPattern pattern,
+      int x,
+      int y,
+      int amount,
+      int dispersal,
+      int seed}) {
+    _startingSeed = seed ?? DateTime.now().millisecondsSinceEpoch;
     math.Random rng = new math.Random(_startingSeed);
+    _x = x;
+    _y = y;
     _amount = amount ?? rng.nextInt(20);
     _dispersal = dispersal ?? 10;
-    int cx = rng.nextInt(map.width ~/ 3) + (map.width ~/ 3);
-    int cy = rng.nextInt(map.height ~/ 3) + (map.height ~/ 3);
+    _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 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;
+        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;
     }
-
     _dirty = true;
   }
 
   void setCellState(int x, int y, bool state) {
-    if (y >= map.height || x >= map.width) return null;
-
-    state ? map.set(x, y, true) : map.set(x, y, false);
+    if (y < map.height && x < map.width) map.get(x, y).state = state;
   }
 
   bool getCellState(int x, int y) {
-    if (y >= map.height || x >= map.width) return null;
-
-    return map.get(x, y);
-  }
-
-  void toggleCellState(int x, int y) {
-    if (y >= map.height || x >= map.width) return null;
-
-    getCellState(x, y) == null
-        ? setCellState(x, y, true)
-        : setCellState(x, y, false);
+    if (y < map.height && x < map.width) return map.get(x, y).state;
+    return null;
   }
 
   Map<int, bool> update() {
-    Map<int, bool> stateChanges = calculateNextState(map);
-    return stateChanges;
-  }
-
-  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;
-      }
+      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
+    for (int i = 0; i < map.length; i++) {
+      Cell el = map[i];
+      if (el.state != el.nextState) stateChanges[i] = el.nextState;
+      el.advanceState();
+    }
+    (stateChanges.length > 0) ? _dirty = true : false;
     return stateChanges;
   }
 
-  int getNeighbors(int x, int y, int range) {
+  int getSurroundingNeighbors(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++) {
@@ -118,7 +150,7 @@ class Simulation {
             iy >= 0 &&
             ix < map.width &&
             iy < map.height &&
-            getCellState(ix, iy) == true &&
+            map.get(ix, iy).state == true &&
             !(x == ix && y == iy)) count++;
       }
     }
@@ -140,7 +172,7 @@ class Simulation {
         ctx.strokeRect(p.x * brickW, p.y * brickH, brickW, brickH);
       }
 
-      if (map[i] == true)
+      if (map[i].state == true)
         ctx.setFillColorRgb(155, 155, 255);
       else
         ctx.setFillColorRgb(0, 0, 0);
@@ -154,10 +186,5 @@ class Simulation {
     _dirty = true;
   }
 
-  void saveSnapshot() => _snapshot = Grid.from(map);
-  Grid<bool> loadSnapshot() {
-    map = Grid.from(_snapshot);
-    _dirty = true;
-    return map;
-  }
+  bool get renderEdges => _renderEdges;
 }

lib/src/rules/CellPattern.dart

@@ -1,17 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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);
-}

pubspec.yaml

@@ -10,6 +10,7 @@ environment:
 dependencies:
   angular: ^5.0.0-beta
   angular_components: ^0.9.0-beta
+  stagexl: ^1.4.0+1
 
 dev_dependencies:
   angular_test: ^2.0.0-beta

test/service/configuration_service_test.dart

@@ -0,0 +1,46 @@
+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

@@ -1,23 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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,106 +1,15 @@
 import 'dart:html' as html;
-import 'package:rules_of_living/src/Simulation.dart';
-import 'package:test/test.dart';
-import 'package:mockito/mockito.dart';
+import 'dart:math';
 
 @TestOn('browser')
 import 'package:rules_of_living/src/Engine.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} : {};
-  }
-}
+import 'package:test/test.dart';
 
 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));
@@ -122,4 +31,12 @@ 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/render_test.dart

@@ -0,0 +1,15 @@
+import 'dart:html' as html;
+import 'dart:math';
+
+@TestOn('browser')
+import 'package:rules_of_living/src/Render.dart';
+import 'package:test/test.dart';
+
+void main() {
+  Render sut;
+  setUp(() {
+    html.CanvasElement canvas = html.CanvasElement();
+    sut = Render(canvas, 8);
+  });
+  group("colorMap", () {});
+}

test/src/rules/cellpattern_test.dart

@@ -1,19 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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));
-  });
-}