Code viewer for World: Complex_World_AStar_Part_1
AB.clockTick = 100, AB.maxSteps = 1000, AB.screenshotStep = 50;
const show3d = true;
const TEXTURE_WALL = '/uploads/chinya07/BUSH.png';      // https://www.pinclipart.com/downpngs/xbb_transparent-background-tree-clipart-png-download/
const TEXTURE_MAZE = '/uploads/chinya07/grass.png';      // https://www.nicepng.com/downpng/u2q8a9q8i1t4o0a9_man-walking-his-dog-dog-and-man-png/
const TEXTURE_AGENT = '/uploads/chinya07/Dog.png';      // https://www.pngitem.com/middle/bbbmR_shrubs-bush-png-image-transparent-background-bush-png/
const TEXTURE_ENEMY = '/uploads/chinya07/Man.png';      // https://www.pngfind.com/download/ixTJhJo_cute-hypoallergenic-dogs-bichon-frise-png-transparent-png/
const MUSIC_BACK = '/uploads/chinya07/song.mp3';        //https://www.youtube.com/watch?v=o1iUYc1Y_fk
const SOUND_ALARM = '/uploads/chinya07/Dog_bark.mp3';   //https://orangefreesounds.com/sound-effects/animal-sounds/dog-sounds/
const GRID_SIZE = 50;
const NUMBER_OF_OBSTACLES = Math.trunc((GRID_SIZE * GRID_SIZE) / 3);
const SQUARE_SIZE = 100;
const MAXPOS = GRID_SIZE * SQUARE_SIZE;
const SKYCOLOR = 0xddffdd;
const startRadiusConst = MAXPOS * 0.8;
const maxRadiusConst = MAXPOS * 10;
ABHandler.MAXCAMERAPOS = maxRadiusConst;
ABHandler.GROUNDZERO = true;
const SKYBOX_ARRAY = ["/uploads/starter/posx.jpg", "/uploads/starter/negx.jpg", "/uploads/starter/posy.jpg", "/uploads/starter/negy.jpg", "/uploads/starter/posz.jpg", "/uploads/starter/negz.jpg"];
const ACTION_LEFT = 0;
const ACTION_RIGHT = 1;
const ACTION_UP = 2;
const ACTION_DOWN = 3;
const ACTION_STAYSTILL = 4;
const GRID_BLANK = 0;
const GRID_WALL = 1;
const GRID_MAZE = 2;
var BOXHEIGHT;
var GRID = new Array(GRID_SIZE);
var AGENT, ENEMY;
var wall_texture, agent_texture, enemy_texture, maze_texture;
var ei, ej, ai, aj;
var badsteps;
var goodsteps;
var openNodeSet = [];
var closedNodeSet = [];
var start;
var end;
var takeEuclideanDist = true;


function loadResources() // asynchronous file loads - call initScene() when all finished 
{
    var loader1 = new THREE.TextureLoader();
    var loader2 = new THREE.TextureLoader();
    var loader3 = new THREE.TextureLoader();
    var loader4 = new THREE.TextureLoader();

    loader1.load(TEXTURE_WALL, function (thetexture) {
        thetexture.minFilter = THREE.LinearFilter;
        wall_texture = thetexture;
        if (asynchFinished()) loadScene(); // if all file loads have returned 
    });

    loader2.load(TEXTURE_AGENT, function (thetexture) {
        thetexture.minFilter = THREE.LinearFilter;
        agent_texture = thetexture;
        if (asynchFinished()) loadScene();
    });

    loader3.load(TEXTURE_ENEMY, function (thetexture) {
        thetexture.minFilter = THREE.LinearFilter;
        enemy_texture = thetexture;
        if (asynchFinished()) loadScene();
    });

    loader4.load(TEXTURE_MAZE, function (thetexture) {
        thetexture.minFilter = THREE.LinearFilter;
        maze_texture = thetexture;
        if (asynchFinished()) loadScene();
    });

}

/**
 * 
 * @returns Checks if everything is properly loaded or not:Boolean
 */
function asynchFinished() {
    if (wall_texture && agent_texture && enemy_texture && maze_texture) return true;
    else return false;
}




//--- grid system -------------------------------------------------------------------------------
// my numbering is 0 to gridsize-1

/**
 *
 * @param {row position} i
 * @param {*column position} j
 * @returns Checks if the particular location is occupied or not by any component like wall, obstacle, agent or enemy:Boolean
 */
function occupied(i, j) {
    if ((ei == i) && (ej == j)) return true;
    if ((ai == i) && (aj == j)) return true;

    if (GRID[i][j].wall == true) return true; // fixed objects

    return false;
}


// translate my (i,j) grid coordinates to three.js (x,y,z) coordinates
// logically, coordinates are: y=0, x and z all positive (no negative)    
// logically my dimensions are all positive 0 to MAXPOS
// to centre everything on origin, subtract (MAXPOS/2) from all dimensions 

function translate(i, j) {
    var v = new THREE.Vector3();

    v.y = 0;
    v.x = (i * SQUARE_SIZE) - (MAXPOS / 2);
    v.z = (j * SQUARE_SIZE) - (MAXPOS / 2);

    return v;
}


function loadScene() {
    var i, j, shape, thecube;

    // set up GRID as 2D array

    for (i = 0; i < GRID_SIZE; i++)
        GRID[i] = new Array(GRID_SIZE);


    // set up walls
    /**
     * Initialsed GRID as a Spot() object
     * Spot contains detailed information about a particular location in the grid
     */

    for (i = 0; i < GRID_SIZE; i++)
        for (j = 0; j < GRID_SIZE; j++)
            if ((i == 0) || (i == GRID_SIZE - 1) || (j == 0) || (j == GRID_SIZE - 1)) {
                GRID[i][j] = new Spot(i, j, true);
                shape = new THREE.BoxGeometry(SQUARE_SIZE, BOXHEIGHT, SQUARE_SIZE);
                thecube = new THREE.Mesh(shape);
                thecube.material = new THREE.MeshBasicMaterial({
                    map: wall_texture
                });

                thecube.position.copy(translate(i, j));
                ABWorld.scene.add(thecube);
            }
    else
        GRID[i][j] = new Spot(i, j);

    // set up maze 

    for (var c = 1; c <= NUMBER_OF_OBSTACLES; c++) {
        i = AB.randomIntAtoB(1, GRID_SIZE - 2); // inner squares are 1 to gridsize-2
        j = AB.randomIntAtoB(1, GRID_SIZE - 2);


        GRID[i][j] = new Spot(i, j, true);

        shape = new THREE.BoxGeometry(SQUARE_SIZE, BOXHEIGHT, SQUARE_SIZE);
        thecube = new THREE.Mesh(shape);
        thecube.material = new THREE.MeshBasicMaterial({
            map: maze_texture
        });

        thecube.position.copy(translate(i, j)); // translate my (i,j) grid coordinates to three.js (x,y,z) coordinates 
        ABWorld.scene.add(thecube);

    }

    for (i = 0; i < GRID_SIZE; i++)
        for (j = 0; j < GRID_SIZE; j++)
            GRID[i][j].addNeighbors(GRID);


    // set up enemy 
    // start in random location

    do {
        i = AB.randomIntAtoB(1, GRID_SIZE - 2);
        j = AB.randomIntAtoB(1, GRID_SIZE - 2);
    }
    while (occupied(i, j)); // search for empty square 

    ei = i;
    ej = j;

    shape = new THREE.BoxGeometry(SQUARE_SIZE, BOXHEIGHT, SQUARE_SIZE);
    ENEMY = new THREE.Mesh(shape);
    ENEMY.material = new THREE.MeshBasicMaterial({
        map: enemy_texture
    });
    ABWorld.scene.add(ENEMY);
    drawEnemy();



    // set up agent 
    // start in random location

    do {
        i = AB.randomIntAtoB(1, GRID_SIZE - 2);
        j = AB.randomIntAtoB(1, GRID_SIZE - 2);
    }
    while (occupied(i, j)); // search for empty square 

    ai = i;
    aj = j;

    shape = new THREE.BoxGeometry(SQUARE_SIZE, BOXHEIGHT, SQUARE_SIZE);
    AGENT = new THREE.Mesh(shape);
    AGENT.material = new THREE.MeshBasicMaterial({
        map: agent_texture
    });
    ABWorld.scene.add(AGENT);
    drawAgent();


    // finally skybox 
    // setting up skybox is simple 
    // just pass it array of 6 URLs and it does the asych load 

    ABWorld.scene.background = new THREE.CubeTextureLoader().load(SKYBOX_ARRAY, function () {
        ABWorld.render();

        AB.removeLoading();

        AB.runReady = true; // start the run loop
        AB.msg("Enemy: <button class='altbutton' onclick='calcEuclideanDist()'>Euclidean Distance</button>");
    });

}

function calcEuclideanDist() {
    if (takeEuclideanDist)
        takeEuclideanDist = false;
    else
        takeEuclideanDist = true;
}



// --- draw moving objects -----------------------------------


function drawEnemy() // given ei, ej, draw it 
{
    ENEMY.position.copy(translate(ei, ej)); // translate my (i,j) grid coordinates to three.js (x,y,z) coordinates 

    ABWorld.lookat.copy(ENEMY.position); // if camera moving, look back at where the enemy is  
}


function drawAgent() // given ai, aj, draw it 
{
    AGENT.position.copy(translate(ai, aj)); // translate my (i,j) grid coordinates to three.js (x,y,z) coordinates 

    ABWorld.follow.copy(AGENT.position); // follow vector = agent position (for camera following agent)
}




// --- take actions -----------------------------------

function heuristic(a, b) {
    // if ( takeEuclideanDist === true){
    //     AB.msg( " <br> <font color=red> <B> ED! </B> </font>   ", 5  );
    //     return (Math.sqrt((a.i - b.i)*(a.i - b.i) + (a.j - b.j)*(a.j - b.j)));

    // }  
    // else{
    //     AB.msg( " <br> <font color=red> <B> ED! </B> </font>   ", 5  );
        return( Math.abs(a.i - b.i) + Math.abs(a.j - b.j) );   //Manhattan Distance

    // } 
    // return ((a.i - b.i) * (a.i - b.i) + (a.j - b.j) * (a.j - b.j));
    // return Math.hypot(a.i - b.i, a.j - b.j)รท //Euclidean Distance
    // return 0;    //Dkstras Algorithm
    // var sqsum = Math.pow(a.i - b.i, 2) + Math.pow(a.j - b.j, 2);
    return Math.sqrt(sqsum); //Distance Formula
}

function moveLogicalEnemy() {
    let path = aStar(GRID[ei][ej], GRID[ai][aj]);
    if (path.length < 10) {
        AB.msg(" <br> <font color=red> <B> DANGER! </B> </font>   ", 5);

    }
    for (var x = 0; x < path.length; x++) {

        path[x].show()

    }


    i = path[path.length - 2].i
    j = path[path.length - 2].j



    if (!occupied(i, j)) // if no obstacle then move, else just miss a turn
    {
        ei = i;
        ej = j;
    }
    console.log("PATH ", path);


}


function moveLogicalAgent(a) // this is called by the infrastructure that gets action a from the Mind 
{
    var i = ai;
    var j = aj;

    if (a == ACTION_LEFT) i--;
    else if (a == ACTION_RIGHT) i++;
    else if (a == ACTION_UP) j++;
    else if (a == ACTION_DOWN) j--;

    if (!occupied(i, j)) {
        ai = i;
        aj = j;
    }
}


// #################################################################### key handling ###############################################################################

// This is hard to see while the Mind is also moving the agent:
// AB.mind.getAction() and AB.world.takeAction() are constantly running in a loop at the same time 
// have to turn off Mind actions to really see user key control 

// we will handle these keys: 

// var OURKEYS = [ 37, 38, 39, 40 ];

// function ourKeys ( event ) { return ( OURKEYS.includes ( event.keyCode ) ); }


// function keyHandler ( event )		
// {
// 	if ( ! AB.runReady ) return true; 		// not ready yet 

// 	 // if not one of our special keys, send it to default key handling:

// 	if ( ! ourKeys ( event ) ) return true;

// 	// else handle key and prevent default handling:

// 	if ( event.keyCode == 37 )   moveLogicalAgent ( ACTION_LEFT 	);   
// 		if ( event.keyCode == 38 )   moveLogicalAgent ( ACTION_DOWN  	); 	 
// 		if ( event.keyCode == 39 )   moveLogicalAgent ( ACTION_RIGHT 	); 	 
// 		if ( event.keyCode == 40 )   moveLogicalAgent ( ACTION_UP		);   

// 	// when the World is embedded in an iframe in a page, we want arrow key events handled by World and not passed up to parent 

// 	event.stopPropagation(); event.preventDefault(); return false;
// }


//#################################################################### score ###############################################################################


function badstep() // is the enemy within one square of the agent
{
    if ((Math.abs(ei - ai) < 2) && (Math.abs(ej - aj) < 2)) return true;
    else return false;
}


function agentBlocked() // agent is blocked on all sides, run over
{
    return (occupied(ai - 1, aj) &&
        occupied(ai + 1, aj) &&
        occupied(ai, aj + 1) &&
        occupied(ai, aj - 1));
}




function updateStatusBefore(a)
// this is called before anyone has moved on this step, agent has just proposed an action
// update status to show old state and proposed move 
{
    var x = AB.world.getState();
    AB.msg(" Step: " + AB.step + " &nbsp; x = (" + x.toString() + ") &nbsp; a = (" + a + ") ");
}


function updateStatusAfter() // agent and enemy have moved, can calculate score
{
    // new state after both have moved

    var y = AB.world.getState();
    var score = (goodsteps / AB.step) * 100;

    AB.msg(" &nbsp; y = (" + y.toString() + ") <br>" +
        " Bad steps: " + badsteps +
        " &nbsp; Good steps: " + goodsteps +
        " &nbsp; Score: " + score.toFixed(2) + "% ", 2);
}





AB.world.newRun = function () {
    AB.loadingScreen();

    AB.runReady = false;

    badsteps = 0;
    goodsteps = 0;


    if (show3d) {
        BOXHEIGHT = SQUARE_SIZE;
        ABWorld.init3d(startRadiusConst, maxRadiusConst, SKYCOLOR);
    } else {
        BOXHEIGHT = 1;
        ABWorld.init2d(startRadiusConst, maxRadiusConst, SKYCOLOR);
    }


    loadResources(); // aynch file loads		
    // calls initScene() when it returns 

    // 	document.onkeydown = keyHandler;	

};



AB.world.getState = function () {
    var x = [ai, aj, ei, ej];
    return (x);
};



AB.world.takeAction = function (a) {

    updateStatusBefore(a); // show status line before moves 

    moveLogicalAgent(a);

    if (AB.step % 2 == 0) // slow the enemy down to every nth step
        moveLogicalEnemy();


    if (badstep()) badsteps++;
    else goodsteps++;

    drawAgent();
    drawEnemy();
    updateStatusAfter(); // show status line after moves  

    if (agentBlocked()) // if agent blocked in, run over 
    {
        AB.abortRun = true;
        goodsteps = 0; // you score zero as far as database is concerned 			 
        musicPause();
        soundAlarm();
    }

};



AB.world.endRun = function () {
    musicPause();
    if (AB.abortRun) AB.msg(" <br> <font color=red> <B> Agent trapped. Final score zero. </B> </font>   ", 3);
    else AB.msg(" <br> <font color=green> <B> Run over. </B> </font>   ", 3);
};


AB.world.getScore = function () {
    // only called at end - do not use AB.step because it may have just incremented past AB.maxSteps

    var s = (goodsteps / AB.maxSteps) * 100; // float like 93.4372778 
    var x = Math.round(s * 100); // 9344
    return (x / 100); // 93.44
};







// --- music and sound effects ----------------------------------------

var backmusic = AB.backgroundMusic(MUSIC_BACK);

function musicPlay() {
    backmusic.play();
}

function musicPause() {
    backmusic.pause();
}


function soundAlarm() {
    var alarm = new Audio(SOUND_ALARM);
    alarm.play(); // play once, no loop 
}

function Spot(i, j, wall) {

    // Location
    this.i = i;
    this.j = j;
    this.wall = wall || false;


    // f, g, and h values for A*
    this.f = 0;
    this.g = 0;
    this.h = 0;

    // Neighbors
    this.neighbors = [];

    // Where did I come from?
    this.previous = undefined;

    this.show = function () {
        this.tempShape = new THREE.BoxGeometry(30, 30, 30);
        this.tempCube = new THREE.Mesh(this.tempShape);

        this.tempCube.material = new THREE.MeshBasicMaterial();

        this.tempCube.position.copy(translate(this.i, this.j)); // translate my (i,j) grid coordinates to three.js (x,y,z) coordinates
        this.tempCube.material.color.setColorName("blue");
        this.tempCube.material.opacity = 0.25;
        ABWorld.scene.add(this.tempCube);

    }
    this.hide = function () {
        ABWorld.scene.remove(this.tempCube);
    }


    // Figure out who my neighbors are
    this.addNeighbors = function (grid) {
        var i = this.i;
        var j = this.j;

        if (i < GRID_SIZE - 1 && !grid[i + 1][j].wall) this.neighbors.push(grid[i + 1][j]);
        if (i > 0 && !grid[i - 1][j].wall) this.neighbors.push(grid[i - 1][j]);
        if (j < GRID_SIZE - 1 && !grid[i][j + 1].wall) this.neighbors.push(grid[i][j + 1]);
        if (j > 0 && !grid[i][j - 1].wall) this.neighbors.push(grid[i][j - 1]);
    }
}

function removeFromArray(arr, elt) {
    for (var i = arr.length - 1; i >= 0; i--)
        if (arr[i] == elt)
            arr.splice(i, 1);
}

function aStar(start, end) {
/**
 * Reseting location and f,g,h values for each new iteration
 */
    resetParam();

    let openNodeSet = [start];
    let current;
    let closedNodeSet = [];
    while (openNodeSet.length > 0) {

        var winner = 0;

        for (var i = 0; i < openNodeSet.length; i++)
            if (openNodeSet[i].f < openNodeSet[winner].f)
                winner = i;
        current = openNodeSet[winner];

        // Did I catch my Dog?
        if (current === end) {
            console.log("success - found path");
            break;
        }
        removeFromArray(openNodeSet, current);
        closedNodeSet.push(current);

        // Check all the neighbors
        var neighbors = current.neighbors;

        for (var i = 0; i < neighbors.length; i++) {
            var neighbor = neighbors[i];

            // Valid next spot?
            if (!closedNodeSet.includes(neighbor) && !neighbor.wall) {
                var tempG = current.g + heuristic(neighbor, current);

                // Better path than previous ?
                var newPath = false;
                if (openNodeSet.includes(neighbor)) {
                    if (tempG < neighbor.g) {
                        neighbor.g = tempG;
                        newPath = true;
                    }
                } else {
                    neighbor.g = tempG;
                    newPath = true;
                    openNodeSet.push(neighbor);
                }

                // To search if there is a better path
                if (newPath) {
                    neighbor.h = heuristic(neighbor, end);
                    neighbor.f = neighbor.g + neighbor.h;
                    neighbor.previous = current;
                }
            }
        }

    }

    let path = [];

    var temp = current;

    path.push(temp);

    console.log("previous path: " + temp.previous);
    while (temp.previous) {
        path.push(temp.previous);
        temp = temp.previous;

    }
    return path;
}

function resetParam() {
    for (i = 0; i < GRID_SIZE; i++)
        for (j = 0; j < GRID_SIZE; j++)
            //if (!( ( i==0 ) || ( i==gridsize-1 ) || ( j==0 ) || ( j==gridsize-1 )) )
            if ((GRID[i][j] && !GRID[i][j].wall)) {
                GRID[i][j].previous = null;
                GRID[i][j].g = 0;
                GRID[i][j].h = 0;
                GRID[i][j].f = 0;
                GRID[i][j].hide();

            }
}