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;

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

    // BLINKER
//    map[5][5].state = true;
//    map[5][6].state = true;
//    map[6][5].state = true;
//    map[6][6].state = true;
//
//    map[7][7].state = true;
//    map[7][8].state = true;
//    map[8][7].state = true;
//    map[8][8].state = true;

    // SPACESHIP
//    setCellState(1 + 5, 0 + 5, true);
//    setCellState(2 + 5, 1 + 5, true);
//    setCellState(2 + 5, 2 + 5, true);
//    setCellState(1 + 5, 2 + 5, true);
//    setCellState(0 + 5, 2 + 5, true);
    startingPattern();

    print("Grid creation finished");
  }

  void startingPattern([Pattern pattern]) {
    math.Random rng = new math.Random();
    var x = rng.nextInt(w~/3) + (w~/3);
    var y = rng.nextInt(h~/3) + (h~/3);
    switch (pattern) {
      // Two blocks, offset
      // ##
      //   ##
      case Pattern.Blinker:
        setCellState(x, y, true);
        setCellState(x+1, y, true);
        setCellState(x, y+1, true);
        setCellState(x+1, y+1, true);

        setCellState(x+2, y+2, true);
        setCellState(x+3, y+2, true);
        setCellState(x+2, y+3, true);
        setCellState(x+3, y+3, true);
        break;
      // A 'gliding' Spaceship
      //   #
      //    #
      //  ###
      case Pattern.SpaceShip:
        setCellState(1 + x, 0 + y, true);
        setCellState(2 + x, 1 + y, true);
        setCellState(2 + x, 2 + y, true);
        setCellState(1 + x, 2 + y, true);
        setCellState(0 + x, 2 + y, true);
        break;
      default:
        for (var i = 0; i < rng.nextInt(20); i++) {
          setCellState(x + rng.nextInt(10), y + rng.nextInt(10), true);
        }
        break;
    }
  }
  void setCellState(int x, int y, bool state) {
    if (y < map.length && x < map[y].length) map[y][x].state = state;
  }

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

  void update() {
    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));
        if (!_dirty && map[y][x].dirty) _dirty = true;
      }
    }
    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].advanceState();
      }
    }
  }

  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++) {
        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;
  }
}