Models code complete. Added factors, addition, and subtraction.

controllers/board/grid.controller.js

@@ -1,5 +1,5 @@
 import * as GridActions from '../../actions/board/grid.actions';
-import MultiplesModel from '../../models/multiples.model';
+import SubtractionModel from '../../models/subtraction.model';
 import SETTINGS from '../../AppSettings';
 
 let values;
@@ -10,12 +10,12 @@ const GridCtrl = {
     getValues: () => values,
 
     generateValues: (level) => {
-        values = MultiplesModel.generate(SETTINGS.GRID_WIDTH * SETTINGS.GRID_HEIGHT, level);
+        values = SubtractionModel.generate(SETTINGS.GRID_WIDTH * SETTINGS.GRID_HEIGHT, level);
         dispatch(GridActions.update(values));
     },
 
     isCompleted: (level) => {
-        return MultiplesModel.checkComplete(values, level)
+        return SubtractionModel.checkComplete(values, level)
     },
 
     hideValue: (index) => {

controllers/board/titlebar.controller.js

@@ -1,5 +1,5 @@
 import * as TitlebarActions from '../../actions/board/titlebar.actions';
-import MultiplesModel from '../../models/multiples.model';
+import SubtractionModel from '../../models/subtraction.model';
 
 let dispatch;
 
@@ -7,7 +7,7 @@ const TitlebarCtrl = {
     setDispatch: d => dispatch = d,
 
     setTitle: (level) => {
-        const title = MultiplesModel.getTitle(level);
+        const title = SubtractionModel.getTitle(level);
         dispatch(TitlebarActions.update(title));
     }
 };

controllers/board/troggle.controller.js

@@ -45,11 +45,14 @@ const TroggleCtrl = {
 
     createTroggles(level) {
         const count = Math.min(Math.ceil((level + 1) / 2), 5);
+        let wait = 0;
 
         for (let index = 0; index < count; index++) {
             const ref = this.createTroggle.bind(this, index);
+            wait = wait + Math.random() * 10000;
+
             // troggleCreateTimers[index] = setTimeout(ref, 1000);
-            troggleCreateTimers[index] = setTimeout(ref, (index + 1) * Math.random() * 10000);
+            troggleCreateTimers[index] = setTimeout(ref, wait);
         }
     },
 

controllers/options/options.controller.js

@@ -2,7 +2,7 @@ import * as OptionsActions from '../../actions/options/options.actions';
 import ModeCtrl from '../mode.controller';
 
 let dispatch;
-const values = ['Multiples', 'Factors', 'Equality', 'Inequality'];
+const values = ['Multiples', 'Factors', 'Addition', 'Subtraction'];
 let selected = 0;
 
 const OptionsCtrl = {

models/addition.model.js

@@ -0,0 +1,38 @@
+import BaseModel from './base.model';
+
+const AdditionModel = Object.create(BaseModel);
+
+AdditionModel.generate = function(n, level) {
+    const equals = [];
+    const notequals = [];
+    const target = level + 5;
+    const midpoint = Math.ceil(target / 2);
+
+    let g1, g2, b1, b2;
+
+    for (let i = 1; i < midpoint; i++) {
+        g1 = i;
+        g2 = target - i;
+
+        b1 = Math.max(1, i - Math.ceil(Math.random() * 3));
+        b2 = Math.max(1, target - i - Math.ceil(Math.random() * 3));
+
+        equals.push(`${g2}+${g1}`);
+        equals.push(`${g1}+${g2}`);
+
+        notequals.push(`${b2}+${b1}`);
+        notequals.push(`${b1}+${b2}`);
+    }
+
+    return this.buildResults(equals, notequals, n);
+};
+
+AdditionModel.getTitle = (level) => {
+    return `Equals ${level + 5}`;
+};
+
+AdditionModel.getError = (value, level) => {
+    return `Oops! ${value} does not equal ${level + 5}.`;
+};
+
+export default AdditionModel;

models/base.model.js

@@ -0,0 +1,39 @@
+const BaseModel = {
+    buildResults(validResults, invalidResults, length) {
+        let valid;
+        const results = [];
+
+        for (let i = 0; i < length; i++) {
+            valid = Math.random() < 0.5;
+
+            if (valid === true) {
+                results.push({
+                    value: validResults[Math.floor(Math.random() * validResults.length)],
+                    show: true,
+                    valid: true
+                });
+            }
+            else {
+                results.push({
+                    value: invalidResults[Math.floor(Math.random() * invalidResults.length)],
+                    show: true,
+                    valid: false
+                });
+            }
+        }
+
+        return results;
+    },
+
+    checkComplete(values, level) {
+        for (let i = 0; i < values.length; i++) {
+            if (values[i].valid === true && values[i].show === true) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+export default BaseModel;

models/equality.model.js

@@ -1,42 +0,0 @@
-const MultiplesModel = {
-    // Anagrams, multiples, equality
-    generate(n, level) {
-        const values = [];
-        let v;
-
-        for (let i = 0; i < n; i++) {
-            v = Math.ceil(Math.random() * 1000);
-            values.push({
-                value: v,
-                show: true,
-                valid: this.validate(v, level)
-            });
-        };
-
-        return values;
-    },
-
-    getTitle(level) {
-        return `Multiples of ${level + 2}`;
-    },
-
-    getError(value, level) {
-        return `Oops! ${value} is not a multiple of ${level + 2}.`;
-    },
-
-    checkComplete(values, level) {
-        for (let i = 0; i < values.length; i++) {
-            if (values[i].valid === true && values[i].show === true) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    validate(value, level) {
-        return ((value || -1) % (level + 2) === 0);
-    };
-};
-
-export default MultiplesModel;

models/factors.model.js

@@ -1,42 +1,30 @@
-const MultiplesModel = {
-    // Anagrams, multiples, equality
-    generate(n, level) {
-        const values = [];
-        let v;
+import BaseModel from './base.model';
 
-        for (let i = 0; i < n; i++) {
-            v = Math.ceil(Math.random() * 1000);
-            values.push({
-                value: v,
-                show: true,
-                valid: this.validate(v, level)
-            });
-        };
+const FactorsModel = Object.create(BaseModel);
 
-        return values;
-    },
+FactorsModel.generate = function(n, level) {
+    const target = level + 3;
+    const factors = [];
+    const nonfactors = [];
 
-    getTitle(level) {
-        return `Multiples of ${level + 2}`;
-    },
-
-    getError(value, level) {
-        return `Oops! ${value} is not a multiple of ${level + 2}.`;
-    },
-
-    checkComplete(values, level) {
-        for (let i = 0; i < values.length; i++) {
-            if (values[i].valid === true && values[i].show === true) {
-                return false;
-            }
+    for (let i = 1; i <= target; i++) {
+        if (target % i === 0) {
+            factors.push(i);
         }
+        else {
+            nonfactors.push(i);
+        }
+    }
 
-        return true;
-    },
+    return this.buildResults(factors, nonfactors, n);
+};
 
-    validate(value, level) {
-        return ((value || -1) % (level + 2) === 0);
-    }
+FactorsModel.getTitle = (level) => {
+    return `Factors of ${level + 3}`;
+};
+
+FactorsModel.getError = (value, level) => {
+    return `Oops! ${value} is not a factor of ${level + 2}.`;
 };
 
-export default MultiplesModel;
+export default FactorsModel;

models/inequality.model.js

@@ -1,42 +0,0 @@
-const MultiplesModel = {
-    // Anagrams, multiples, equality
-    generate(n, level) {
-        const values = [];
-        let v;
-
-        for (let i = 0; i < n; i++) {
-            v = Math.ceil(Math.random() * 1000);
-            values.push({
-                value: v,
-                show: true,
-                valid: this.validate(v, level)
-            });
-        };
-
-        return values;
-    },
-
-    getTitle(level) {
-        return `Multiples of ${level + 2}`;
-    },
-
-    getError(value, level) {
-        return `Oops! ${value} is not a multiple of ${level + 2}.`;
-    },
-
-    checkComplete(values, level) {
-        for (let i = 0; i < values.length; i++) {
-            if (values[i].valid === true && values[i].show === true) {
-                return false;
-            }
-        }
-
-        return true;
-    },
-
-    validate(value, level) {
-        return ((value || -1) % (level + 2) === 0);
-    }
-};
-
-export default MultiplesModel;

models/multiples.model.js

@@ -1,42 +1,37 @@
-const MultiplesModel = {
-    // Anagrams, multiples, equality
-    generate(n, level) {
-        const values = [];
-        let v;
-
-        for (let i = 0; i < n; i++) {
-            v = Math.ceil(Math.random() * 1000);
-            values.push({
-                value: v,
-                show: true,
-                valid: this.validate(v, level)
-            });
-        };
-
-        return values;
-    },
-
-    getTitle(level) {
-        return `Multiples of ${level + 2}`;
-    },
-
-    getError(value, level) {
-        return `Oops! ${value} is not a multiple of ${level + 2}.`;
-    },
-
-    checkComplete(values, level) {
-        for (let i = 0; i < values.length; i++) {
-            if (values[i].valid === true && values[i].show === true) {
-                return false;
-            }
-        }
+import BaseModel from './base.model';
+
+const MultiplesModel = Object.create(BaseModel);
+
+MultiplesModel.generate = function(n, level) {
+    const multiples = [];
+    const nonmultiples = [];
+    const target = 19//level + 2;
+    const upperLimit = target * 150;
 
-        return true;
-    },
+    let tmp;
+    while (multiples.length < Math.ceil(n * 4)) {
+        tmp = Math.ceil(Math.random() * upperLimit);
+        if (tmp % target === 0) {
+            multiples.push(tmp);
+        }
+    }
 
-    validate(value, level) {
-        return ((value || -1) % (level + 2) === 0);
+    while (nonmultiples.length < Math.floor(n * 4)) {
+        tmp = Math.ceil(Math.random() * upperLimit);
+        if (tmp % target !== 0) {
+            nonmultiples.push(tmp);
+        }
     }
+
+    return this.buildResults(multiples, nonmultiples, n);
+};
+
+MultiplesModel.getTitle = (level) => {
+    return `Multiples of ${level + 2}`;
+};
+
+MultiplesModel.getError = (value, level) => {
+    return `Oops! ${value} is not a multiple of ${level + 2}.`;
 };
 
 export default MultiplesModel;

models/subtraction.model.js

@@ -0,0 +1,41 @@
+import BaseModel from './base.model';
+
+const SubtractionModel = Object.create(BaseModel);
+
+SubtractionModel.generate = function(n, level) {
+    const equals = [];
+    const notequals = [];
+    const target = level + 2;
+    const upperLimit = target * 10;
+
+    let g1, g2, b1, b2, b3;
+
+    for (let i = target + 1; i < upperLimit; i++) {
+        g1 = i;
+        g2 = i - target;
+
+        b1 = i + Math.ceil(Math.random() * 3);
+        b2 = Math.max(1, i - Math.ceil(Math.random() * 3));
+        b3 = i - target;
+
+        // console.log(`(${i}) ${g1} - ${g2} = ${g1 - g2}`);
+        // console.error(`(${i}) ${b1} - ${b3} = ${b1 - b3}`);
+        // console.error(`(${i}) ${b2} - ${b3} = ${b2 - b3}`);
+
+        equals.push(`${g1}-${g2}`);
+        notequals.push(`${b1}-${b3}`);
+        notequals.push(`${b2}-${b3}`);
+    }
+
+    return this.buildResults(equals, notequals, n);
+};
+
+SubtractionModel.getTitle = (level) => {
+    return `Equals ${level + 2}`;
+};
+
+SubtractionModel.getError = (value, level) => {
+    return `Oops! ${value} does not equal ${level + 2}.`;
+};
+
+export default SubtractionModel;

sass/board/grid.scss

@@ -7,6 +7,7 @@
 
     .cell {
         border:1px solid purple;
+        font-size:12px;
         height:100px;
         line-height:100px;
         position:absolute;

sass/options/options.scss

@@ -1,6 +1,8 @@
 .options {
     $w: 600px;
 
+    padding:50px;
+
     .line {
         line-height:50px;
         margin:5px auto;
@@ -11,7 +13,7 @@
     hr {
         border:0;
         border-top:1px #ccc solid;
-        margin:50px auto;
+        margin:40px auto;
         width:$w;
     }