Added preloader to avoid network calls and computationally expensive scaling between scenes

src/index.js

@@ -14,8 +14,19 @@ import canvasManager from './objects/canvasManager.js';
  */
 window.setup = function()
 {
-    canvasManager.createCanvas();
-    sceneManager.setCurrentScene(MAIN_MENU);
+	let promises = [];
+	for (let i of sceneManager
+			.getScenes()
+			.sceneIter())
+	{
+		promises = [...promises, ...i.preload()];
+	}
+	Promise
+		.all(promises)
+		.then(() => {
+		    canvasManager.createCanvas();
+		    sceneManager.setCurrentScene(MAIN_MENU);	
+		});
 }
 
 /**
@@ -25,4 +36,4 @@ window.setup = function()
 window.draw = function()
 {
     sceneManager.getCurrentScene().draw();
-}
+}

src/objects/andGate.js

@@ -0,0 +1,14 @@
+import TwoInputGate from "./twoInputGate.js";
+
+export default class AndGate extends TwoInputGate
+{
+	constructor(input1, input2, img)
+	{
+		super(input1, input2, img);
+	}
+
+	answer()
+	{
+		return this.input1.answer() & this.input2.answer();
+	}
+}

src/objects/constantGate.js

@@ -0,0 +1,15 @@
+import Gate from "./gate.js";
+
+export default class ConstantGate extends Gate
+{
+	constructor(value, img)
+	{
+		super(img);
+		this.value = value;
+	}
+
+	answer()
+	{
+		return this.value;
+	}
+}

src/objects/gate.js

@@ -0,0 +1,36 @@
+import { scaleNearestNeighbor } from "../helperFunctions/imageFunctions.js";
+
+export default class Gate
+{
+	constructor(img)
+	{
+		if (this.constructor === Gate)
+		{
+			throw new TypeError("Abstract class \"Gate\" cannot be instantiated directly.");
+		}
+		this.img = img;
+	}
+
+	answer()
+	{
+		if (this.schema === undefined)
+		{
+			throw new TypeError("Classes extending \"Gate\" must implement \"answer()\"");
+		}
+	}
+
+	show(x, y)
+	{
+		if (this.answer())
+			tint("#ffff00");
+		image(this.img, x, y);
+		noTint();
+	}
+
+	// This function should be used only occasionally
+	// Scaling apparently is very intensive on
+	showScaled(x, y, width, height)
+	{
+		image(scaleNearestNeighbor(this.img, width, height), x, y);
+	}
+}

src/objects/nandGate.js

@@ -0,0 +1,14 @@
+import { AndGate } from "andGate.js";
+
+export class NandGate extends AndGate
+{
+	constructor(input1, input2, img)
+	{
+		super(input1, input2, img);
+	}
+
+	answer()
+	{
+		return !super.answer();
+	}
+}

src/objects/norGate.js

@@ -0,0 +1,14 @@
+import { OrGate } from "orGate.js";
+
+export class NorGate extends OrGate
+{
+	constructor(input1, input2, img)
+	{
+		super(input1, input2, img);
+	}
+
+	answer()
+	{
+		return !super.answer();
+	}
+}

src/objects/notGate.js

@@ -0,0 +1,14 @@
+import { OneInputGate } from "OneInputGate.js";
+
+export class NotGate extends OneInputGate
+{
+	constructor(input, img)
+	{
+		super(input, img);
+	}
+
+	answer()
+	{
+		return !this.input1.answer();
+	}
+}

src/objects/oneInputGate.js

@@ -0,0 +1,14 @@
+import Gate from "./gate.js";
+
+export default class OneInputGate extends Gate
+{
+	constructor(input, img)
+	{
+		super(img);
+		if (this.constructor === OneInputGate)
+		{
+			throw new TypeError("Abstract class \"OneInputGate\" cannot be instantiated directly.");
+		}
+		this.input1 = input;
+	}
+}

src/objects/orGate.js

@@ -0,0 +1,14 @@
+import { TwoInputGate } from "twoInputGate.js";
+
+export class OrGate extends TwoInputGate
+{
+	constructor(input1, input2, img)
+	{
+		super(input1, input2, img);
+	}
+
+	answer()
+	{
+		return this.input1.answer() | this.input2.answer();
+	}
+}

src/objects/scene.js

@@ -4,8 +4,11 @@
  * we never want to instantiate this class directly.
  */
 export default class Scene {
+	preload() {
+		return [];
+	}
     setup() {}
     draw() {
         background(0, 0, 0);
     }
-}
+}

src/objects/sceneManager.js

@@ -27,7 +27,14 @@ class SceneManager {
         [GAME_OVER]: new GameOver(),
         [INSTRUCTIONS]: new Instructions(),
         [PRACTICE_MODE]: new PracticeMode(),
-        [SETTINGS]: new Settings()
+        [SETTINGS]: new Settings(),
+        sceneIter: function* ()
+        {
+        	for (let i of sceneManager.getValidScenes())
+        	{
+				yield this[i];
+           	}
+        }
     };
 
     #valid_scenes = [
@@ -60,9 +67,19 @@ class SceneManager {
         this.#current_scene = sceneName;
         this.getCurrentScene().setup();
     }
+
+    getScenes()
+    {
+    	return this.#scenes;
+    }
+
+    getValidScenes()
+    {
+    	return this.#valid_scenes;
+    }
 }
 
 // We only ever want one instance of this class (a singleton), so we will instantiate it here and then export that single instantiation.
 const sceneManager = new SceneManager();
 
-export default sceneManager;
+export default sceneManager;

src/objects/twoInputGate.js

@@ -0,0 +1,16 @@
+import OneInputGate from "./oneInputGate.js";
+
+export default class TwoInputGate extends OneInputGate
+{
+	input2;
+
+	constructor(input1, input2, img)
+	{
+		super(input1, img);
+		if (this.constructor === TwoInputGate)
+		{
+			throw new TypeError("Abstract class \"TwoInputGate\" cannot be instantiated directly.");
+		}
+		this.input2 = input2;
+	}
+}

src/objects/xnorGate.js

@@ -0,0 +1,14 @@
+import { XorGate } from "xorGate.js";
+
+export class XnorGate extends XorGate
+{
+	constructor(input1, input2, img)
+	{
+		super(input1, input2, img);
+	}
+
+	answer()
+	{
+		return !super.answer();
+	}
+}

src/objects/xorGate.js

@@ -0,0 +1,14 @@
+import { TwoInputGate } from "twoInputGate.js";
+
+export class XorGate extends TwoInputGate
+{
+	constructor(input1, input2, img)
+	{
+		super(input1, input2, img);
+	}
+
+	answer()
+	{
+		return this.input1.answer() ^ this.input2.answer();
+	}
+}

src/scenes/challengeMode.js

@@ -1,15 +1,75 @@
 import Scene from "../objects/scene.js";
+import ConstantGate from "../objects/constantGate.js";
+import AndGate from "../objects/andGate.js";
 
 /**
  * This scene will manage the game's challenge mode.
  */
 export default class ChallengeMode extends Scene {
     constructor() {
         super();
+        this.bufferImg = null;
+        this.notImg = null;
+        this.andImg = null;
+        this.orImg = null;
+        this.xorImg = null;
+        this.nandImg = null;
+        this.norImg = null;
+        this.xnorImg = null;
+    	this.constant1 = null;
+    	this.constant2 = null;
+    	this.gate = null;
     }
 
-    setup() {}
+    preload()
+    {
+    	let promises = [
+    		new Promise((resolve, reject) => {
+		    	this.bufferImg = loadImage("assets/textures/gates/No Input Buffer.png");
+		    	resolve(true);
+    		}),
+    		new Promise((resolve, reject) => {
+		    	this.notImg = loadImage("assets/textures/gates/NOT Gate.png");
+		    	resolve(true);
+    		}),
+    		new Promise((resolve, reject) => {
+		    	this.andImg = loadImage("assets/textures/gates/AND Gate.png");
+		    	resolve(true);
+    		}),
+    		new Promise((resolve, reject) => {
+		    	this.orImg = loadImage("assets/textures/gates/OR Gate.png");
+		    	resolve(true);
+    		}),
+    		new Promise((resolve, reject) => {
+		    	this.xorImg = loadImage("assets/textures/gates/XOR Gate.png");
+		    	resolve(true);
+    		}),
+    		new Promise((resolve, reject) => {
+		    	this.nandImg = loadImage("assets/textures/gates/NAND Gate.png");
+		    	resolve(true);
+    		}),
+    		new Promise((resolve, reject) => {
+		    	this.norImg = loadImage("assets/textures/gates/NOR Gate.png");
+		    	resolve(true);
+    		}),
+    		new Promise((resolve, reject) => {
+		    	this.xnorImg = loadImage("assets/textures/gates/XNOR Gate.png");
+		    	resolve(true);
+    		})
+   		];
+   		return promises;
+    }
+
+    setup() {
+   		this.constant1 = new ConstantGate(1, this.bufferImg);
+   		this.constant2 = new ConstantGate(1, this.bufferImg);
+  		this.gate = new AndGate(this.constant1, this.constant2, this.andImg);
+    }
+
     draw() {
         background(0, 0, 255);
+        this.constant1.show(100, 100);
+        this.constant2.show(100, 200);
+        this.gate.show(150, 150);
     }
-}
+}