186 lines
4.9 KiB
Dart
186 lines
4.9 KiB
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/Grid.dart';
|
|
import 'package:rules_of_living/src/Rule.dart';
|
|
|
|
enum CellPattern { SpaceShip, Blinker }
|
|
|
|
class Simulation {
|
|
final Grid<Cell> map;
|
|
|
|
bool _dirty = true;
|
|
bool _renderEdges = true;
|
|
|
|
int _startingSeed;
|
|
int _x;
|
|
int _y;
|
|
int _amount;
|
|
int _dispersal;
|
|
CellPattern _pattern;
|
|
|
|
Simulation(int w, int h) : this.map = new Grid.fill(w, h, _getGOLCell()) {
|
|
print("Grid creation finished");
|
|
}
|
|
|
|
static 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)..add(threeTrue);
|
|
cell.birthRules.add(twoTrue);
|
|
return cell;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
_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);
|
|
|
|
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) map.get(x, y).state = state;
|
|
}
|
|
|
|
bool getCellState(int x, int y) {
|
|
if (y < map.height && x < map.width) return map.get(x, y).state;
|
|
return null;
|
|
}
|
|
|
|
bool update() {
|
|
bool stateChanges = false;
|
|
|
|
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();
|
|
});
|
|
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.height &&
|
|
ix < map.width &&
|
|
map.get(x, y).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.width);
|
|
int brickH = (canvas.height ~/ map.height);
|
|
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
|
|
|
for (int i; 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].state == 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;
|
|
}
|
|
|
|
bool get renderEdges => _renderEdges;
|
|
}
|