cellular-automata/lib/src/Simulation.dart

import 'dart:html' as html;
import 'dart:math' as math;

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';

class Simulation {
  Grid<bool> map;
  Grid<bool> _snapshot;

  final int _RANDOM_PATTERN_AMOUNT = 20;
  final double _RANDOM_PATTERN_SPREAD_FROM_CENTER = 1 / 3;

  RuleSet rules = GameOfLife();

  bool dirty = true;

  bool _renderEdges = true;
  bool get renderEdges => _renderEdges;

  math.Point get gridSize => math.Point<int>(map.width, map.height);
  void set gridSize(math.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) {
    this.map = clearMap();
  }

  Simulation.fromGrid(Grid<bool> map) : this.map = map;

  Grid<bool> clearMap() {
    dirty = true;
    map.setAll(0, List.filled(map.length, false));
    return map;
  }

  void toggleCell(int x, int y) {
    map.set(x, y, !map.get(x, y));
  }

  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;
      }
    }
    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++) {
        if (ix >= 0 &&
            iy >= 0 &&
            ix < map.width &&
            iy < map.height &&
            map.get(ix, iy) == true &&
            !(x == ix && y == iy)) count++;
      }
    }
    return count;
  }

  void addRandomPattern({int seed, int amount, num spreadFromCenter}) {
    math.Random rng = _getRNG(seed ?? DateTime.now().millisecondsSinceEpoch);
    amount ??= rng.nextInt(_RANDOM_PATTERN_AMOUNT);
    spreadFromCenter ??= _RANDOM_PATTERN_SPREAD_FROM_CENTER;

    int sanityCheck = 0;
    Map<int, bool> changeSet = {};
    for (var i = 0; i < (amount); i++) {
      sanityCheck++;
      math.Point cell = _getRandomPoint(rng, spreadFromCenter);
      map.get(cell.x, cell.y)
          ? i--
          : changeSet[map.toIndex(cell.x, cell.y)] = true;
      if (sanityCheck > 100 && sanityCheck > i * 3) break;
    }
    mergeStateChanges(changeSet);
  }

  math.Random _getRNG(int seed) {
    math.Random rng = new math.Random(seed);
    return rng;
  }

  math.Point<int> _getRandomPoint(math.Random rng, num spreadFromCenter) {
    math.Point absoluteSpread =
        math.Point(map.width * spreadFromCenter, map.height * spreadFromCenter);
    math.Point center = math.Point(map.width / 2, map.height / 2);
    num cx = rng.nextInt(absoluteSpread.x.toInt()) +
        (center.x - absoluteSpread.x / 2);
    num cy = rng.nextInt(absoluteSpread.y.toInt()) +
        (center.y - absoluteSpread.y / 2);
    return math.Point<int>(cx.toInt(), cy.toInt());
  }

  void render(html.CanvasElement canvas, [num interp]) {
    // only renders if any cells changed between renders
    if (!dirty) return;

    html.CanvasRenderingContext2D ctx = canvas.getContext('2d');
    int brickW = (canvas.width ~/ map.width);
    int brickH = (canvas.height ~/ map.height);
    ctx.clearRect(0, 0, canvas.width, canvas.height);
    for (int i = 0; i < map.length; i++) {
      math.Point p = map.toCoordinates(i);
      if (_renderEdges) {
        ctx.setStrokeColorRgb(100, 100, 100);
        ctx.strokeRect(p.x * brickW, p.y * brickH, brickW, brickH);
      }

      if (map[i] == true)
        ctx.setFillColorRgb(155, 155, 255);
      else
        ctx.setFillColorRgb(0, 0, 0);
      ctx.fillRect(p.x * brickW, p.y * brickH, brickW, brickH);
    }
    dirty = false;
  }

  void set renderEdges(bool on) {
    _renderEdges = on;
    dirty = true;
  }

  void saveSnapshot() => _snapshot = Grid.from(map);
  Grid<bool> loadSnapshot() {
    map = Grid.from(_snapshot);
    dirty = true;
    return map;
  }
}