diff --git a/centipede/.DS_Store b/centipede/.DS_Store
new file mode 100644
index 0000000..0342a22
Binary files /dev/null and b/centipede/.DS_Store differ
diff --git a/centipede/assets/.DS_Store b/centipede/assets/.DS_Store
new file mode 100644
index 0000000..12856bc
Binary files /dev/null and b/centipede/assets/.DS_Store differ
diff --git a/centipede/assets/images/.DS_Store b/centipede/assets/images/.DS_Store
new file mode 100644
index 0000000..b7bf291
Binary files /dev/null and b/centipede/assets/images/.DS_Store differ
diff --git a/centipede/assets/images/centipede-assets.png b/centipede/assets/images/centipede-assets.png
new file mode 100644
index 0000000..20b9eac
Binary files /dev/null and b/centipede/assets/images/centipede-assets.png differ
diff --git a/centipede/assets/sounds/.DS_Store b/centipede/assets/sounds/.DS_Store
new file mode 100644
index 0000000..34bc351
Binary files /dev/null and b/centipede/assets/sounds/.DS_Store differ
diff --git a/centipede/assets/sounds/enemy_hit.wav b/centipede/assets/sounds/enemy_hit.wav
new file mode 100644
index 0000000..1b9c53f
Binary files /dev/null and b/centipede/assets/sounds/enemy_hit.wav differ
diff --git a/centipede/assets/sounds/laser.wav b/centipede/assets/sounds/laser.wav
new file mode 100644
index 0000000..16159a4
Binary files /dev/null and b/centipede/assets/sounds/laser.wav differ
diff --git a/centipede/assets/sounds/mushroom_hit.wav b/centipede/assets/sounds/mushroom_hit.wav
new file mode 100644
index 0000000..ef26432
Binary files /dev/null and b/centipede/assets/sounds/mushroom_hit.wav differ
diff --git a/centipede/css/style.css b/centipede/css/style.css
new file mode 100644
index 0000000..7142e28
--- /dev/null
+++ b/centipede/css/style.css
@@ -0,0 +1,63 @@
+body {
+ margin: 0;
+ font-family: Lucida Sans Typewriter,Lucida Console,monaco,Bitstream Vera Sans Mono,monospace;
+}
+
+.canvas-holder canvas {
+ padding: 0;
+ margin: auto;
+ display: block;
+ height: 100vh;
+ width: auto;
+ max-width: 100%;
+ background-color: black;
+}
+
+.game-hud {
+ position: absolute;
+ top: 0;
+ left: 50%;
+ transform: translate(-50%, -5px);
+ z-index: 1;
+
+ background-color: rgba(255,255,255,0.5);
+ padding-left: 10px;
+ padding-right: 10px;
+ padding-top: 3px;
+ border: 1px solid white;
+ border-radius: 5px;
+}
+
+.game-hud p {
+ margin: 0;
+ padding: 0;
+ font-size: 3vh;
+ text-align: center;
+}
+
+.menu {
+ text-align:center;
+ left: 50%;
+ top: 50%;
+ -webkit-transform: translate(-50%, -50%);
+ transform: translate(-50%, -50%);
+ position:absolute;
+
+ background-color: rgba(255,255,255,0.75);
+ border: 1px solid #fff;
+ border-radius: 5px;
+ padding: 12px;
+ min-width: 400px;
+}
+
+.menu-button {
+ background-color: #fff;
+ border-radius: 5px;
+ padding: 12px;
+ margin-bottom: 8px;
+ cursor: pointer;
+}
+
+.menu-button:hover {
+ background-color: #d0d0d0;
+}
\ No newline at end of file
diff --git a/centipede/index.html b/centipede/index.html
new file mode 100644
index 0000000..3d73470
--- /dev/null
+++ b/centipede/index.html
@@ -0,0 +1,38 @@
+
+
+
+ Centipede
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/centipede/js/game/game.js b/centipede/js/game/game.js
new file mode 100644
index 0000000..30454f9
--- /dev/null
+++ b/centipede/js/game/game.js
@@ -0,0 +1,39 @@
+const game = {
+ stopped: false,
+ width: document.getElementById('game-canvas').width,
+ height: document.getElementById('game-canvas').height,
+ level: 1,
+};
+
+game.resume = () => {
+ game.stopped = false;
+ game.lastTimeStamp = performance.now();
+ menu.reRegisterKeys();
+ requestAnimationFrame(gameLoop);
+}
+
+game.resetObjects = () => {
+ game.player.x = game.width/2;
+ game.player.y = game.height/2;
+ game.bullets = [];
+ game.explosions = [];
+ game.mushroomDims = {width: 40, height: 40};
+ game.mushrooms = game.Mushroom.generateMushrooms(game.mushroomDims);
+ game.centipede = game.Centipede({segments: Math.min(game.level*5 + 5, 15), startX: game.width/2, startY: 0, rot: 180, width: 40, height: 40, dx: 0.2, dy: 0});
+ game.spiders = [];
+ game.fleas = [];
+ game.scorpions = [];
+}
+
+game.gameOver = () => {
+ menu.showMenu();
+ menu.setState('game-over');
+ menu.addScore(game.score);
+
+ menu.onHide = initialize;
+}
+
+game.getObjects = () => [game.player, ...game.bullets, ...game.mushrooms, ...game.spiders, ...game.fleas, ...game.scorpions, game.centipede, ...game.explosions];
+game.getBulletCollidableObjects = () => [...game.mushrooms, ...game.spiders, ...game.fleas, ...game.scorpions, game.centipede];
+game.getMushroomCollidableObjects = () => [game.player, ...game.scorpions, game.centipede];
+game.getPlayerCollidableObjects = () => [...game.spiders, ...game.fleas, ...game.scorpions, game.centipede]
\ No newline at end of file
diff --git a/centipede/js/game/graphics.js b/centipede/js/game/graphics.js
new file mode 100644
index 0000000..3a0d7f9
--- /dev/null
+++ b/centipede/js/game/graphics.js
@@ -0,0 +1,55 @@
+game.graphics = (
+ (context) => {
+ context.imageSmoothingEnabled = false;
+ const clear = () => {
+ context.clearRect(0, 0, game.width, game.height);
+ };
+
+ const Sprite = ({sheetSrc, spriteX, spriteY, spriteWidth, spriteHeight, timePerFrame, cols, rows, numFrames, drawFunction}) => {
+ timePerFrame = timePerFrame ?? 100;
+ numFrames = numFrames ?? 1;
+ cols = cols ?? numFrames;
+ rows = rows ?? 1;
+
+ let ready = false;
+
+ let image;
+ if (sheetSrc) {
+ image = new Image();
+ image.src = sheetSrc;
+ image.onload = () => { ready = true; };
+ }
+
+ let currentFrame = 0;
+ let lastTime = performance.now();
+
+ let draw;
+ if (!drawFunction) {
+ draw = (_elapsedTime, {x, y, rot, width, height}) => {
+
+ if (ready) {
+ if (numFrames > 1) {
+ if (performance.now()-lastTime > timePerFrame) {
+ lastTime = performance.now();
+ currentFrame = (currentFrame + 1) % numFrames;
+ }
+ }
+ context.save();
+ context.translate(x+width/2, y+height/2);
+ context.rotate(rot * Math.PI / 180);
+ context.translate(-x-width/2, -y-height/2);
+ const row = currentFrame % rows;
+ const col = Math.floor(currentFrame / rows);
+ context.drawImage(image, spriteX+col*spriteWidth, spriteY+row*spriteHeight, spriteWidth, spriteHeight, x, y, width, height);
+ context.restore();
+ }
+ };
+ } else {
+ draw = (elapsedTime, drawSpec) => drawFunction(elapsedTime, drawSpec, context);
+ }
+ return { draw, timePerFrame, numFrames };
+ }
+
+ return { clear, Sprite };
+ }
+)(document.getElementById("game-canvas").getContext("2d"));
\ No newline at end of file
diff --git a/centipede/js/game/input.js b/centipede/js/game/input.js
new file mode 100644
index 0000000..6ceff13
--- /dev/null
+++ b/centipede/js/game/input.js
@@ -0,0 +1,32 @@
+game.input = (() => {
+ "use strict";
+ const Keyboard = () => {
+ const keys = {};
+ const handlers = {};
+ const keyPress = (event) => {
+ keys[event.key] = event.timeStamp;
+ };
+ const keyRelease = (event) => {
+ delete keys[event.key];
+ };
+ const registerCommand = (key, handler) => {
+ handlers[key] = handler;
+ };
+ const unregisterCommand = (key) => {
+ delete handlers[key];
+ }
+ const update = (elapsedTime) => {
+ for (let key in keys) {
+ if (keys.hasOwnProperty(key)) {
+ if (handlers[key]) {
+ handlers[key](elapsedTime);
+ }
+ }
+ }
+ };
+ window.addEventListener("keydown", keyPress);
+ window.addEventListener("keyup", keyRelease);
+ return {keys, handlers, registerCommand, unregisterCommand, update};
+ }
+ return { Keyboard };
+})();
\ No newline at end of file
diff --git a/centipede/js/game/menu.js b/centipede/js/game/menu.js
new file mode 100644
index 0000000..d4a7fe9
--- /dev/null
+++ b/centipede/js/game/menu.js
@@ -0,0 +1,143 @@
+const menu = {};
+menu.initialize = () => {
+ menu.scores = localStorage.getItem("scores") ? JSON.parse(localStorage.getItem("scores")) : [];
+ menu.state = "main";
+
+ menu.controls = localStorage.getItem("controls") ? JSON.parse(localStorage.getItem("controls")) : {
+ "moveUp": "ArrowUp",
+ "moveDown": "ArrowDown",
+ "moveLeft": "ArrowLeft",
+ "moveRight": "ArrowRight",
+ "shoot": " ",
+ };
+}
+
+menu.setState = (state) => {
+ menu.state = state;
+ menu.draw();
+}
+
+menu.escapeEventListener = (e) => {
+ if (e.key == "Escape") {
+ menu.setState('main');
+ menu.draw();
+ }
+}
+
+menu.showMenu = () => {
+ menu.draw();
+ game.stopped = true;
+ window.addEventListener("keydown", menu.escapeEventListener);
+}
+
+menu.reRegisterKeys = () => {
+ Object.keys(game.keyboard.handlers).map(key => game.keyboard.unregisterCommand(key));
+ game.keyboard.registerCommand(menu.controls.moveUp, game.player.moveUp);
+ game.keyboard.registerCommand(menu.controls.moveDown, game.player.moveDown);
+ game.keyboard.registerCommand(menu.controls.moveLeft, game.player.moveLeft);
+ game.keyboard.registerCommand(menu.controls.moveRight, game.player.moveRight);
+ game.keyboard.registerCommand(menu.controls.shoot, game.player.shoot);
+ game.keyboard.registerCommand("Escape", menu.showMenu);
+ localStorage.setItem("controls", JSON.stringify(menu.controls));
+}
+
+menu.addScore = (score) => {
+ menu.scores.push(score);
+ menu.scores.sort((a, b) => b - a);
+ localStorage.setItem("scores", JSON.stringify(menu.scores));
+}
+
+menu.hide = () => {
+ const menuElement = document.getElementById("menu");
+ menuElement.style.display = "none";
+ menu.reRegisterKeys();
+ window.removeEventListener("keydown", menu.escapeEventListener);
+ if (menu.onHide) {
+ menu.onHide();
+ menu.onHide = null;
+ }
+ game.resume();
+}
+
+menu.listenFor = (action, elementId) => {
+ const element = document.getElementById(elementId);
+ element.innerHTML = "Listening...";
+ const handleKey = (event) => {
+ window.removeEventListener("keydown", handleKey);
+ if (event.key == "Escape") {
+ element.innerHTML = menu.controls[action];
+ return;
+ }
+ menu.controls[action] = event.key;
+ element.innerHTML = event.key;
+ }
+ window.addEventListener("keydown", handleKey);
+}
+
+menu.draw = () => {
+ const menuElement = document.getElementById("menu");
+ menuElement.style.display = "block";
+ menuElement.innerHTML = `Centipede
`;
+ if (menu.state == "main") {
+ menuElement.innerHTML += `
+
+
+
+ `;
+ }
+ else if (menu.state == "controls") {
+ menuElement.innerHTML += `
+
+
+ Move left:
+
+ Move right:
+
+ Move up:
+
+ Move down:
+
+ Shoot:
+
+
+
+ ${menu.scores.map((score, index) => `${index + 1}: ${score}
`).join("")}
+
+
+
+ Game Over
+
+ Your final score was: ${game.score}
+
+
+
+
+
+
+ -
+ Move with arrow keys, WASD, or IJKL
+
+ -
+ h to toggle a hint
+
+ -
+ p to toggle the shortest path
+
+ -
+ b to toggle breadcrumbs
+
+
+
+
+
+
+
+
The A-maze-ing Maize Maze!
+
Get to the fire to make popcorn! Current Time: seconds
+
+
+
+
+ 5x5
+ 10x10
+ 15x15
+ 20x20
+
+
+
+
+
+
+ "Low" scores (player path length - shortest path length):
+
+
');
+ document.getElementById('scores').innerHTML = html;
+}
+
+function render_time(total_time) {
+ document.getElementById('elapsed-time').innerHTML = total_time;
+}
+
+function render_goal(x, y, dx, dy) {
+ context.drawImage(GOAL, x*dx, y*dy, dx, dy);
+}
+
+function render_background(n, dx, dy) {
+ for (let x = 0; x < WIDTH; x += WIDTH/n) {
+ for (let y = 0; y < HEIGHT; y += HEIGHT/n) {
+ context.drawImage(BACKGROUND, x, y, dx, dy);
+ }
+ }
+}
+
+function render_circle(x,y,r,color) {
+ context.beginPath();
+ context.fillStyle = color;
+ context.arc(x, y, r, 0, 2*Math.PI);
+ context.fill();
+ context.stroke();
+}
+
+function render_path(path, dx, dy, color) {
+ path.map((coord) => {
+ render_circle(coord[0]*dx + dx/2, coord[1]*dy + dy/2, Math.min(dx/4, dy/4), color);
+ });
+}
+
+function render(elapsed) {
+ const dx = WIDTH / n;
+ const dy = HEIGHT / n;
+
+ context.fillStyle = 'rgba(255,255,255,255)';
+ context.fillRect(0, 0, canvas.width, canvas.height);
+ context.rect(0, 0, canvas.width, canvas.height);
+ context.stroke();
+
+ render_background(n, dx, dy);
+ render_maze(maze, n, dx, dy);
+
+ if (show_player_path) {
+ render_path(player_path, dx, dy, 'rgba(255, 0, 0, 255)');
+ }
+
+ if (show_shortest_path) {
+ render_path(shortest_path, dx, dy, 'rgba(255, 255, 0, 255)');
+ }
+
+ if (show_next_move && shortest_path.length>1) {
+ render_path([shortest_path[1]], dx, dy, 'rgba(255, 255, 0, 255)');
+ }
+
+ if (do_score_update) {
+ render_scores(scores);
+ }
+ if (do_time_update) {
+ render_time(dom_time);
+ }
+
+ render_player(Math.floor(player_pos[0]), Math.floor(player_pos[1]), dx, dy);
+ render_goal(goal_pos[0], goal_pos[1], dx, dy);
+}
+
+let key_actions_down = {};
+let key_actions = {
+ "move_up": ['ArrowUp', 'i', 'w'],
+ "move_right": ['ArrowRight', 'l', 'd'],
+ "move_down": ['ArrowDown', 'k', 's'],
+ "move_left": ['ArrowLeft', 'j', 'a'],
+ "breadcrumbs": ['b'],
+ "shortest_path": ['p'],
+ "hint": ['h']
+};
+function handle_input(input) {
+ if (input) {
+ if (any(key_actions['move_up'].map((x) => input.keys[x])) && !key_actions_down['move_up'] && player_pos[1] > 0) {
+ key_actions_down['move_up'] = true;
+ if (!maze[player_pos[1]][player_pos[0]].top) {
+ player_pos[1] -= 1;
+ }
+ }
+ if (any(key_actions['move_right'].map((x) => input.keys[x])) && !key_actions_down['move_right'] && player_pos[0] < n-1) {
+ key_actions_down['move_right'] = true;
+ if (!maze[player_pos[1]][player_pos[0]].right) {
+ player_pos[0] += 1;
+ }
+ }
+ if (any(key_actions['move_down'].map((x) => input.keys[x])) && !key_actions_down['move_down'] && player_pos[1] < n-1) {
+ key_actions_down['move_down'] = true;
+ if (!maze[player_pos[1]][player_pos[0]].bottom) {
+ player_pos[1] += 1;
+ }
+ }
+ if (any(key_actions['move_left'].map((x) => input.keys[x])) && !key_actions_down['move_left'] && player_pos[0] > 0) {
+ key_actions_down['move_left'] = true;
+ if (!maze[player_pos[1]][player_pos[0]].left) {
+ player_pos[0] -= 1;
+ }
+ }
+ if (input.keys['b'] && !key_actions_down['breadcrumbs']) {
+ key_actions_down['breadcrumbs'] = true;
+ show_player_path = !show_player_path;
+ }
+ if (input.keys['p'] && !key_actions_down['shortest_path']) {
+ key_actions_down['shortest_path'] = true;
+ show_shortest_path = !show_shortest_path;
+ }
+ if (input.keys['h'] && !key_actions_down['hint']) {
+ key_actions_down['hint'] = true;
+ show_next_move = !show_next_move;
+ }
+ Object.keys(key_actions).map((x) => {
+ if (key_actions_down[x] && !any(key_actions[x].map((y) => input.keys[y]))) {
+ key_actions_down[x] = false;
+ }
+ });
+ }
+}
+
+function update(elapsed) {
+ total_time += elapsed;
+
+ if (do_score_update) {
+ do_score_update = false;
+ }
+ if (do_time_update) {
+ do_time_update = false;
+ }
+
+ if (JSON.stringify(player_pos) !== JSON.stringify(player_path[player_path.length-1])) {
+ player_path.push([player_pos[0], player_pos[1]]);
+ shortest_path = solve_maze(maze, player_pos[0], player_pos[1], goal_pos[0], goal_pos[1]);
+ }
+
+ if (total_time / 1000 > dom_time) {
+ dom_time = Math.floor(total_time/1000);
+ }
+ do_time_update = true;
+
+ if (player_pos[0] == goal_pos[0] && player_pos[1] == goal_pos[1]) {
+ current_score = player_path.length - initial_shortest_path_length;
+ scores.push(current_score);
+ initialize();
+ do_score_update = true;
+ }
+}
+
+function initialize(new_n) {
+ if (new_n) {
+ n = new_n;
+ }
+ maze = generate_maze(n);
+ player_pos = [random_in_range(0, 2), random_in_range(0, 2)];
+ goal_pos = [random_in_range(n-2, n), random_in_range(n-2, n)];
+ player_path = [];
+ shortest_path = solve_maze(maze, player_pos[0], player_pos[1], goal_pos[0], goal_pos[1]);
+ initial_shortest_path_length = shortest_path.length;
+ total_time = 0;
+ current_score = 0;
+ dom_time = 0;
+ last_time = performance.now();
+}
+
+function game_loop(time_stamp) {
+ elapsed_time = time_stamp - last_time;
+ last_time = time_stamp;
+ handle_input(myInput);
+ update(elapsed_time);
+ render(elapsed_time);
+
+ // Wow! Tail call recursion! /sarcasm
+ requestAnimationFrame(game_loop);
+}
+
+window.onload = function() {
+ initialize();
+ canvas = document.getElementById('canvas');
+ context = canvas.getContext('2d');
+
+ game_loop(performance.now());
+}
diff --git a/maize-maze/js/helpers.js b/maize-maze/js/helpers.js
new file mode 100644
index 0000000..1bc6579
--- /dev/null
+++ b/maize-maze/js/helpers.js
@@ -0,0 +1,18 @@
+function random_in_range(a,z) {
+ return Math.floor(Math.random() * (z - a) + a);
+}
+
+function shuffle_array(a) {
+ for (let i = 0; i < a.length; i++) {
+ let j = random_in_range(0, i+1);
+ temp = a[i]; a[i] = a[j]; a[j] = temp;
+ }
+}
+
+function sub(p1, p2) {
+ return [p1[0] - p2[0], p1[1] - p2[1]];
+}
+
+function any(l) {
+ return l.filter((x) => x).length > 0;
+}
\ No newline at end of file
diff --git a/maize-maze/js/json-ds.js b/maize-maze/js/json-ds.js
new file mode 100644
index 0000000..feb0622
--- /dev/null
+++ b/maize-maze/js/json-ds.js
@@ -0,0 +1,30 @@
+// If I were to rewrite this, I would use IEFE's - Dean was right about OO in JS
+class JSONSet {
+ items = new Set();
+ constructor(initial){
+ if (initial) {
+ this.apply_set_function('add', initial);
+ }
+ }
+ apply_set_function(f_name, x) {
+ return this.items[f_name](JSON.stringify(x));
+ }
+}
+
+class JSONHash {
+ items = {};
+ constructor(initial_key, initial_value){
+ if (initial_key && initial_value) {
+ this.items[JSON.stringify(initial)] = initial_value;
+ }
+ }
+ set_value(key, value) {
+ this.items[JSON.stringify(key)] = value;
+ }
+ get_value(key) {
+ return this.items[JSON.stringify(key)];
+ }
+ delete_value(key) {
+ delete this.items[JSON.stringify(key)];
+ }
+}
\ No newline at end of file
diff --git a/maize-maze/js/keyboard.js b/maize-maze/js/keyboard.js
new file mode 100644
index 0000000..2196834
--- /dev/null
+++ b/maize-maze/js/keyboard.js
@@ -0,0 +1,22 @@
+// Shameless stolen code from "Process the Input" presentation
+let input = (function() {
+ function Keyboard() {
+ let that = {
+ keys : {}
+ };
+ function keyPress(e) {
+ that.keys[e.key] = e.timeStamp;
+ }
+ function keyRelease(e) {
+ delete that.keys[e.key];
+ }
+ window.addEventListener('keydown', keyPress);
+ window.addEventListener('keyup', keyRelease);
+
+ return that;
+ }
+
+ return {
+ Keyboard : Keyboard
+ };
+}());
\ No newline at end of file
diff --git a/maize-maze/js/maze.js b/maize-maze/js/maze.js
new file mode 100644
index 0000000..8bede6b
--- /dev/null
+++ b/maize-maze/js/maze.js
@@ -0,0 +1,104 @@
+function get_neighbors(maze, x, y) {
+ let neighbor_indices = [];
+ if (!maze[y][x].left && x > 0) {
+ neighbor_indices.push([x-1,y]);
+ }
+ if (!maze[y][x].right && x < maze[0].length-1) {
+ neighbor_indices.push([x+1,y]);
+ }
+ if (!maze[y][x].top && y > 0) {
+ neighbor_indices.push([x,y-1]);
+ }
+ if (!maze[y][x].bottom && y < maze.length-1) {
+ neighbor_indices.push([x,y+1]);
+ }
+ return neighbor_indices;
+}
+
+function new_cell() {
+ return {
+ left: false,
+ right: false,
+ top: false,
+ bottom: false
+ }
+}
+
+function generate_maze(n) {
+ let grid = new Array(n).fill().map((x) => (new Array(n).fill().map(new_cell)));
+
+ let point_sets = [];
+ for (let i = 0; i < n; i++) {
+ for (let j = 0; j < n; j++) {
+ point_sets.push(new JSONSet([j,i]))
+ }
+ }
+
+ let edges = [];
+ for (let i = 0; i < n; i++) {
+ for (let j = 0; j < n; j++) {
+ if (i !== n-1) {
+ edges.push([[i,j],[i+1,j]])
+ }
+ if (j !== n-1) {
+ edges.push([[i,j],[i,j+1]])
+ }
+ }
+ }
+ shuffle_array(edges);
+
+ let maze_edges = edges.map((x) => x);
+
+ while (edges.length) {
+ let edge = edges.pop();
+
+ let set_inds = edge.map((i) => point_sets.findIndex((x) => x.apply_set_function('has', i)));
+ if (set_inds[0] == -1 || set_inds[1] == -1) {
+ throw new Error("Could not find correct index");
+ }
+ if (set_inds[0] == set_inds[1]) {
+ continue;
+ }
+
+ // Perform the union of the sets
+ for (let i of point_sets[set_inds[1]].items) {
+ point_sets[set_inds[0]].items.add(i);
+ }
+
+ point_sets.splice(set_inds[1], 1);
+ maze_edges = maze_edges.filter((x) => x !== edge);
+ }
+ maze_edges.forEach((edge) => {
+ let direction = sub(edge[0], edge[1]);
+ if (direction[0] == -1) {
+ grid[edge[0][1]][edge[0][0]].right = grid[edge[1][1]][edge[1][0]].left = true;
+ }
+ else if (direction[1] == -1) {
+ grid[edge[0][1]][edge[0][0]].bottom = grid[edge[1][1]][edge[1][0]].top = true;
+ }
+ })
+ return grid;
+}
+
+function solve_maze(maze, x, y, end_x, end_y) {
+ let path = new JSONHash();
+ let visited = new JSONSet();
+ let queue = [[x,y]];
+ while (queue.length) {
+ let cell = queue.shift();
+ visited.apply_set_function('add', cell);
+ if (cell[0] == end_x && cell[1] == end_y) {
+ let sol_path = [[end_x, end_y]];
+ while (sol_path[0][0] != x || sol_path[0][1] != y) {
+ sol_path.unshift(path.get_value(sol_path[0]));
+ }
+ return sol_path;
+ }
+ for (let i of get_neighbors(maze, cell[0], cell[1])) {
+ if (!visited.apply_set_function('has', i)) {
+ queue.push(i);
+ path.set_value(i, cell);
+ }
+ }
+ }
+}
diff --git a/maize-maze/screenshot.png b/maize-maze/screenshot.png
new file mode 100644
index 0000000..965eb61
Binary files /dev/null and b/maize-maze/screenshot.png differ