cellular-automata/lib/src/Grid.dart

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

import 'package:rules_of_living/src/Cell.dart';
import 'package:rules_of_living/src/Rule.dart';

enum Pattern { SpaceShip, Blinker }

class Grid {
  final int w;
  final int h;
  final List<List<Cell>> map;

  bool _dirty = true;
  bool _renderEdges = true;

  int _startingSeed;
  int _x;
  int _y;
  int _amount;
  int _dispersal;
  Pattern _pattern;

  Grid(int w, int h)
      : this.w = w,
        this.h = h,
        this.map = new List() {
    map.addAll(_buildGrid(w, h));

    print("Grid creation finished");
  }

  void reset() {
    map.setAll(0, _buildGrid(w, h));
    if (_startingSeed != null)
      addPattern(
          pattern: _pattern,
          dispersal: _dispersal,
          amount: _amount,
          seed: _startingSeed,
          x: _x,
          y: _y);
    _dirty = true;
  }

  void addPattern(
      {Pattern 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;
    _pattern = pattern;
    int cx = x ?? rng.nextInt(w ~/ 3) + (w ~/ 3);
    int cy = y ?? rng.nextInt(h ~/ 3) + (h ~/ 3);
    switch (pattern) {
      // Two blocks, offset
      // ##
      //   ##
      case Pattern.Blinker:
        setCellState(cx, cy, true);
        setCellState(cx + 1, cy, true);
        setCellState(cx, cy + 1, true);
        setCellState(cx + 1, cy + 1, true);

        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 Pattern.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.length && x < map[y].length) map[y][x].state = state;
  }

  bool getCellState(int x, int y) {
    if (y < map.length && x < map[y].length) return map[y][x].state;
    return null;
  }

  List<List<Cell>> _buildGrid(int w, int h) {
    print("grid being created");
    List<List<Cell>> grid = new List(h);
    // GENERAL RULE LAYOUT
    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;
    });

    // DEBUG RULE TESTING FOR PATTERNS
    Rule coagSurvive = new Rule((int n) {
      if (n == 1) return true;
      return false;
    });
    Rule coagBirth = new Rule((int n) {
      if (n == 1) return true;
      return false;
    });

    for (int y = 0; y < h; y++) {
      grid[y] = new List(w);
      for (int x = 0; x < w; x++) {
        // GIVES RULES FOR CONWAY GAME OF LIFE BY DEFAULT S23/B3
        Cell cell = new Cell();
//        cell.surviveRules.add(twoTrue);
        cell.surviveRules.add(threeTrue);
        cell.surviveRules.add(twoTrue);
        cell.birthRules.add(threeTrue);

        grid[y][x] = cell;
      }
    }
    return grid;
  }

  bool update() {
    bool stateChanges = false;
    for (int y = 0; y < h; y++) {
      for (int x = 0; x < w; x++) {
        // DEFAULTS TO CONWAY GAME OF LIFE RANGE OF ONE
        map[y][x].update(getSurroundingNeighbors(x, y, 1));
      }
    }
    for (int y = 0; y < h; y++) {
      for (int x = 0; x < w; x++) {
        Cell c = map[y][x];
        if(c.state != c.nextState) stateChanges = true;
        c.advanceState();

        if (!_dirty && map[y][x].dirty) _dirty = true;
      }
    }
    return stateChanges;
  }

  int getSurroundingNeighbors(int x, int y, int range) {
    int count = 0;
    for (int iy = y - range; iy <= y + range; iy++) {
      for (int ix = x - range; ix <= x + range; ix++) {
        if (ix > 0 &&
            iy > 0 &&
            iy < map.length &&
            ix < map[iy].length &&
            map[iy][ix].state == true &&
            !(x == ix && y == iy)) {
          count++;
        }
      }
    }
    return count;
  }

  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[0].length);
    int brickH = (canvas.height ~/ map.length);
    ctx.clearRect(0, 0, canvas.width, canvas.height);

    for (int y = 0; y < map.length; y++) {
      for (int x = 0; x < map[y].length; x++) {
        if (_renderEdges) {
          ctx.setStrokeColorRgb(100, 100, 100);
          ctx.strokeRect(x * brickW, y * brickH, brickW, brickH);
        }

        Cell c = map[y][x];
        if (c.state == true)
          ctx.setFillColorRgb(155, 155, 255);
        else
          ctx.setFillColorRgb(0, 0, 0);
        ctx.fillRect(x * brickW, y * brickH, brickW, brickH);
      }
    }

    _dirty = false;
  }

  void switchEdgeRendering([bool on]) {
    _renderEdges = on ?? !_renderEdges;
  void set renderEdges(bool on) {
    _renderEdges = on;
    _dirty = true;
  }
  bool get renderEdges => _renderEdges;
}