lint, merge package.json from examples

Author: GrosSacASac

js/ai/qlearn/examples/dodgeShoot/dodgeShoot.js

@@ -1,13 +1,13 @@
 export { start };
 
 import { deepCopy } from "../node_modules/utilsac/utility.js";
-import { randomDecide } from "../../source/randomDecide.js"
+import { randomDecide } from "../../source/randomDecide.js";
 import { createIntelligence, decide } from "../../source/qlearn.js";
-import { draw, report } from "./draw.js";
+import { draw } from "./draw.js";
 import { initialState } from "./initialState.js";
 import { scheduleNext } from "../scheduleNext.js";
 
-
+const framesASecond = 60;
 const isValidPosition = (w, max) => {
     return w >= 0 && w <= max;
 };
@@ -43,19 +43,19 @@ const updateGame = (action, state, reward) => {
             state.score += reward;
         }
     });
-    state.missiles = state.missiles.filter(([dangerX, dangerY]) => {
+    state.missiles = state.missiles.filter(([, dangerY]) => {
         return isValidPosition(dangerY, state.maxY);
     });
     state.missiles.forEach(missile => {
-        missile[1] -= 1
+        missile[1] -= 1;
     });
 
     // the enemy emits a missile every n frames
     if (state.frame % 4 === 0) {
         state.missiles.push(state.positionEnemy.slice());
     }
     // move enemy from left to right periodically
-    if (state.frame % 60 > 30) {
+    if (state.frame % framesASecond > (framesASecond / 2)) {
         actions.moveLeft(state, state.positionEnemy);
     } else {
         actions.moveRight(state, state.positionEnemy);
@@ -67,15 +67,15 @@ const start = (options) => {
         reduceStateAndAction,
         learn,
         useIntelligence = true,
-        MAX_FRAMES = 20000,
+        MAX_FRAMES = 2 * 10 ** 4,
         display = false,
         reward = -1,
     } = options;
 
     const state = deepCopy(initialState);
     const intelligence = createIntelligence();
 
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
         const step = () => {
             const scoreBefore = state.score;
             let stateActions;
@@ -99,7 +99,7 @@ const start = (options) => {
                 const scoreDifference = scoreAfter - scoreBefore;
                 learn(intelligence, previousStateActions, stateActions, actionName, actionNames, scoreDifference);
             }
-            state.frame++;
+            state.frame += 1;
             if (state.frame < MAX_FRAMES) {
                 scheduleNext(step);
             } else {

js/ai/qlearn/examples/dodgeShoot/draw.js

@@ -3,9 +3,9 @@ export { draw, report, compactReport };
 
 const draw = (state) => {
     console.log(`-------- ${state.frame} -------- `);
-    for (let y = state.maxY; y >= 0; y--) {
-        let line = [`|`];
-        for (let x = 0; x <= state.maxX; x++) {
+    for (let y = state.maxY; y >= 0; y -= 1) {
+        const line = [`|`];
+        for (let x = 0; x <= state.maxX; x += 1) {
             if (state.position[0] === x && state.position[1] === y) {
                 line.push(`*`);
             } else if (state.positionEnemy[0] === x && state.positionEnemy[1] === y) {
@@ -33,7 +33,7 @@ const report = ({ state, qualityMap }) => {
 
 const compactReport = ({
     state,
-    qualityMap,
+    /*qualityMap,*/
     reduceStateAndAction,
     useIntelligence,
     reward,

js/ai/qlearn/examples/dodgeShoot/reduceState.js

@@ -2,15 +2,15 @@ export {
     reduceStateAndActionSeeAll,
     reduceStateAndActionSeeNearestOnly,
     reduceStateAndActionSeeAllDistance,
-}
+};
 
 const distanceFromVector = (x, y) => {
-    return (x ** 2 + y ** 2) ** 0.5;
+    return (x ** 2 + y ** 2) ** (1 / 2);
 };
 
 const reduceStateAndActionSeeNearestOnly = (state) => {
     // we omit actions because they are always the same 
-    let missileInformation = state.missiles[0][1];
+    const missileInformation = state.missiles[0][1];
 
     return `${state.position}${missileInformation}`;
 };
@@ -20,7 +20,7 @@ const reduceStateAndActionSeeAll = (state) => {
 };
 
 const reduceStateAndActionSeeAllDistance = (state) => {
-    const [x, y] = state.position
+    const [x, y] = state.position;
     const distances = state.missiles.map(([xm, ym]) => {
         return distanceFromVector(xm - x, ym - y);
     });

js/ai/qlearn/examples/dodgeShoot/start.js

@@ -3,15 +3,19 @@ import {
     reduceStateAndActionSeeNearestOnly,
     reduceStateAndActionSeeAllDistance,
 } from "./reduceState.js";
-import { report, compactReport } from "./draw.js";
+import { compactReport } from "./draw.js";
 import { start } from "./dodgeShoot.js";
 import { learn, learnWithAverage } from "../../source/qlearn.js";
 
 
 const display = false;
 
 const rewardsTrials = [1, -1];
-const framesTrials = [2000, 20000, 200000];
+const framesTrials = [
+    2 * 10 ** 3,
+    2 * 10 ** 4,
+    2 * 10 ** 5,
+];
 // debugging 
 learn.xname = `learn`;
 learnWithAverage.xname = `learnWithAverage`;
@@ -24,20 +28,22 @@ const reduceStateTrials = [
 
 framesTrials.forEach(frames => {
     rewardsTrials.forEach(reward => {
-        const options = {
+        // do not include random in the big loop 
+        // as it will not change based on the algorithm
+        const randomOptions = {
             reduceStateAndAction: undefined,
             learn: undefined,
             MAX_FRAMES: frames,
             useIntelligence: false,
             display,
             reward,
         };
-        start(options).then(compactReport);
+        start(randomOptions).then(compactReport);
         reduceStateTrials.forEach(reduceStateAction => {
-            learnTrials.forEach(learn => {
+            learnTrials.forEach(learnAlgorithm => {
                 const options = {
                     reduceStateAndAction: reduceStateAction,
-                    learn,
+                    learn: learnAlgorithm,
                     MAX_FRAMES: frames,
                     useIntelligence: true,
                     display,

js/ai/qlearn/examples/dodgeShoot/visualDemo.js

@@ -1,7 +1,7 @@
 import {
     reduceStateAndActionSeeAll,
 } from "./reduceState.js";
-import { report, compactReport } from "./draw.js";
+import { report } from "./draw.js";
 import { start } from "./dodgeShoot.js";
 import { learn, learnWithAverage } from "../../source/qlearn.js";
 

js/ai/qlearn/examples/eatFoodAvoidDanger/draw.js

@@ -3,9 +3,9 @@ export { draw, report };
 
 const draw = (state, frame) => {
     console.log(`----- ${frame} ------ `);
-    for (let y = state.maxY; y >= 0; y--) {
-        let line = [`|`];
-        for (let x = 0; x <= state.maxX; x++) {
+    for (let y = state.maxY; y >= 0; y -= 1) {
+        const line = [`|`];
+        for (let x = 0; x <= state.maxX; x += 1) {
             if (state.position[0] === x && state.position[1] === y) {
                 line.push(`*`);
             } else if (state.dangers.some(([dx, dy]) => {

js/ai/qlearn/examples/eatFoodAvoidDanger/eatFoodAvoidDanger.js

@@ -37,15 +37,15 @@ const actions = {
         state.position[0] = futureX;
     },
     moveUp: (state) => {
-        const [x, y] = state.position;
+        const [, y] = state.position;
         const futureY = y + 1;
         if (!isValidPosition(futureY, state.maxY)) {
             return;
         }
         state.position[1] = futureY;
     },
     moveDown: (state) => {
-        const [x, y] = state.position;
+        const [, y] = state.position;
         const futureY = y - 1;
         if (!isValidPosition(futureY, state.maxY)) {
             return;
@@ -61,7 +61,7 @@ const updateGame = (action, state) => {
         if (x === dangerX && y === dangerY) {
             state.score -= 1;
             state.position = [0, 0];
-            state.dangersTouched.push(frame)
+            state.dangersTouched.push(frame);
         }
     });
     state.rewards.forEach(([X, Y]) => {
@@ -74,9 +74,9 @@ const updateGame = (action, state) => {
 };
 
 
-const state = initialState;
 const actionNames = Object.keys(actions);
 const step = () => {
+    const state = initialState;
     const stateActions = reduceStateAndAction(state);
     const scoreBefore = state.score;
     const actionName = decide(intelligence, stateActions, actionNames);
@@ -89,7 +89,7 @@ const step = () => {
     const scoreAfter = state.score;
     const reward = scoreAfter - scoreBefore;
     learn(intelligence, stateActions, stateActionsAfter, actionName, actionNames, reward);
-    frame++;
+    frame += 1;
     if (frame < MAX_FRAMES) {
         scheduleNext(step);
     } else {