package.json

@@ -7,7 +7,9 @@
     "build": "vite build",
     "serve": "vite preview",
     "lint": "eslint --ext .js,.vue --ignore-path .gitignore --fix src",
-    "format": "prettier .  --write"
+    "format": "prettier .  --write",
+    "coverage": "vitest run --coverage",
+    "test": "vitest"
   },
   "dependencies": {
     "@vitejs/plugin-vue": "^3.2.0",
@@ -17,10 +19,13 @@
     "vue": "3.2"
   },
   "devDependencies": {
+    "@testing-library/vue": "^6.6.1",
     "eslint": "^8.28.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-vue": "^9.8.0",
-    "prettier": "2.8.0"
+    "happy-dom": "^8.1.1",
+    "prettier": "2.8.0",
+    "vitest": "^0.26.2"
   },
   "eslintConfig": {
     "root": true,

src/modules/core.js

@@ -0,0 +1,217 @@
+// core functions to generate initial states and evolve them
+
+// handles negative index and index bigger than its array length
+function guard(index, arrayLength) {
+  if (index > arrayLength - 1) return 0;
+  if (index < 0) return arrayLength - 1;
+  return index;
+}
+
+// get the next evolution of a 1D CA initial state
+function evolve1d(state, rules) {
+  function getCell(index) {
+    const safeIndex = guard(index, state.length);
+    return state[safeIndex];
+  }
+  const newState = state.map((_, x) => {
+    const cells = [getCell(x - 1), getCell(x), getCell(x + 1)];
+    return rules[cells.join("")];
+  });
+
+  return newState.map(Number);
+}
+
+// create a 2D board from a 1D CA initial state
+// function createBoard(state, rules, height) {
+//   function createBoardAcc(s, h, acc) {
+//     if (h === 0) return acc;
+//     const newState = evolve1d(s, rules);
+//     const newAcc = acc.concat([s]);
+//     return createBoardAcc(newState, h - 1, newAcc);
+//   }
+//   return createBoardAcc(state, height, []);
+// }
+
+// performance "choke point" in full imperative
+function createBoard(state, rules, max) {
+  var board = [];
+  let prevState = [];
+  for (let i = 0; i < max; i++) {
+    let nextState = [];
+    // use the passed initial step during first iteration
+    if (i == 0) {
+      nextState = evolve1d(state, rules);
+    } else {
+      nextState = evolve1d(prevState, rules);
+    }
+    board = board.concat([nextState]);
+    prevState = nextState;
+  }
+  return board;
+}
+
+// Find the neighbor of a given cell in a 2D CA board
+function getCellNeighbors(board, cellCoordinates) {
+  const [x, y] = cellCoordinates;
+  const rowLength = board[0].length; // caca?
+
+  // handles board edges where the cell is missing neighbors
+  function getCell(xx, yy) {
+    const safeX = guard(xx, board.length);
+    const safeY = guard(yy, rowLength.length);
+    return board[safeX][safeY];
+  }
+
+  // the current cell is not included in the result
+  return [
+    getCell(x - 1, y - 1),
+    getCell(x, y - 1),
+    getCell(x + 1, y - 1),
+    getCell(x - 1, y),
+    getCell(x + 1, y),
+    getCell(x - 1, y + 1),
+    getCell(x, y + 1),
+    getCell(x + 1, y - 1),
+  ];
+}
+
+// Sums the value of a cell's neighbors
+function getNeighborsSum(cells) {
+  return cells.reduce((cell, acc) => cell + acc, 0);
+}
+
+// Get the next evolution of a cell according to
+// Conway's game of life rules
+function conwayRules(cell, neighbors) {
+  // loneliness rule
+  if (cell === 1 && neighbors < 2) return 0;
+  // overpopulation rule
+  if (cell === 1 && neighbors > 3) return 0;
+  // born when three live neighbors rule
+  if (cell === 0 && neighbors === 3) return 1;
+  // the cell remains the same if none apply
+  return cell;
+}
+
+// Get the next evolution of a cell according to
+// Conway's game of life rules
+function servietteRules(cell, neighbors) {
+  // loneliness rule
+  if (cell === 0 && [2, 3, 4].find((x) => x == neighbors)) return 1;
+  // the cell remains the same if none apply
+  return 0;
+}
+
+// variation of the game of life where a
+// cell comes to live if 6 neigbor cells are alive
+function highLifeRules(cell, neighbors) {
+  // loneliness rule
+  if (cell === 1 && neighbors < 2) return 0;
+  // overpopulation rule
+  if (cell === 1 && neighbors > 3) return 0;
+  // born when three live neighbors rule
+  if (cell === 0 && neighbors === 2) return 1;
+  // highlife rules
+  if ((cell === 0 && neighbors === 3) || neighbors === 6) return 1;
+  // the cell remains the same if none apply
+  return cell;
+}
+
+// variation on the game of life's rules,
+// where the "three live neighbors" rule is ignored
+function threebornRules(cell, neighbors) {
+  // loneliness rule
+  if (cell === 1 && neighbors < 2) return 0;
+  // overpopulation rule
+  if (cell === 1 && neighbors > 3) return 0;
+  // born when three live neighbors rule
+  return cell;
+}
+
+// variation on the game of life's rules,
+// where the loneliness rule is ignored
+function lonelinessRules(cell, neighbors) {
+  // overpopulation rule
+  if (cell === 1 && neighbors > 3) return 0;
+  // born when three live neighbors rule
+  if (cell === 0 && neighbors === 3) return 1;
+  // the cell remains the same if none apply
+  return cell;
+}
+
+// variation on the game of life's rules,
+// where the overpopulation rule is ignored
+function overpopulationRules(cell, neighbors) {
+  // loneliness rule
+  if (cell === 1 && neighbors < 2) return 0;
+  // born when three live neighbors rule
+  if (cell === 0 && neighbors === 3) return 1;
+  // the cell remains the same if none apply
+  return cell;
+}
+
+// get the next evolution of a 2D CA initial state
+// Rules : Moore neighborhood
+function evolve2d(board, rulesFn) {
+  return board.map((row, x) =>
+    row.map((cell, y) => {
+      const neighbors = getCellNeighbors(board, [x, y]);
+      const sum = getNeighborsSum(neighbors);
+      return rulesFn(cell, sum);
+    })
+  );
+}
+
+function getDrawingValues(state, acc, cell) {
+  const d = cell.dimension;
+  return Object.keys(state).map((key) => {
+    const fillStyle = (() => {
+      if (state[key] === "1") return cell.liveColor;
+      return cell.deadColor;
+    })();
+
+    return {
+      move: [key * d, acc * d],
+      fill: [key * d, acc * d, d, d],
+      fillStyle,
+    };
+  });
+}
+
+// Populates the first state with a single living cell in the center
+function create1dStateOneCell(width) {
+  return [...Array(width)].map((cell, index) => {
+    if (index === Math.floor(width / 2)) return 1;
+    return 0;
+  });
+}
+
+// Populates the first state of a 1D CA with cells returned
+// by initFn
+function create1dState(width, initFn, args) {
+  return [...Array(width)].map(() => initFn(...args));
+}
+
+// Populates the first state of a 2D CA with cells returned
+// by initFn
+function create2dState(width, height, initFn, args) {
+  return [...Array(height)].map(() =>
+    [...Array(width)].map(() => initFn(...args))
+  );
+}
+
+export {
+  getDrawingValues,
+  create1dState,
+  create2dState,
+  createBoard,
+  create1dStateOneCell,
+  conwayRules,
+  overpopulationRules,
+  lonelinessRules,
+  threebornRules,
+  highLifeRules,
+  servietteRules,
+  evolve1d,
+  evolve2d,
+};

vite.config.js

@@ -13,4 +13,11 @@ export default defineConfig({
       "@": path.resolve(__dirname, "./src"),
     },
   },
+  test: {
+    // enable jest-like global test APIs
+    globals: true,
+    // simulate DOM with happy-dom
+    // (requires installing happy-dom as a peer dependency)
+    environment: "happy-dom",
+  },
 });