Code viewer for World: Complex World 2 Moving Wal...

// Cloned by Nithish kumar  from World "Complex World" by Starter user 
// Please leave this clone trail here.

//Assignmenet 1: Complex World 2 Moving Walls
//Name: Nithish Kumar Elancheralathan
//Student no.: 22260496


// ==== Starter World =======================================A==========================================================
// This code is designed for use on the Ancient Brain site.
// This code may be freely copied and edited by anyone on the Ancient Brain site.
// To include a working run of this program on another site, see the "Embed code" links provided on Ancient Brain.
// ====================================================================================================================

// =============================================================================================
// More complex starter World
// 3d-effect Maze World (really a 2-D problem)
// Movement is on a semi-visible grid of squares
//
// This more complex World shows:
// - Skybox
// - Internal maze (randomly drawn each time)
// - Enemy actively chases agent
// - Music/audio
// - 2D world (clone this and set show3d = false)
// - User keyboard control (clone this and comment out Mind actions to see)
// =============================================================================================

// =============================================================================================
// Scoring:
// Bad steps = steps where enemy is within one step of agent.
// Good steps = steps where enemy is further away.
// Score = good steps as percentage of all steps.
//
// There are situations where agent is trapped and cannot move.
// If this happens, you score zero.
// =============================================================================================

// ===================================================================================================================
// === Start of tweaker's box ========================================================================================
// ===================================================================================================================

// The easiest things to modify are in this box.
// You should be able to change things in this box without being a JavaScript programmer.
// Go ahead and change some of these. What's the worst that could happen?

AB.clockTick = 300; // Speed of run: Step every n milliseconds. Default 100.
AB.maxSteps = 1000; // Length of run: Maximum length of run in steps. Default 1000.
AB.screenshotStep = 50; // Take screenshot on this step. (All resources should have finished loading.) Default 50.

//---- global constants: -------------------------------------------------------

const show3d = true; // Switch between 3d and 2d view (both using Three.js)
const TEXTURE_WALL = "/uploads/nk0509/open-gate-.jpg";
const TEXTURE_MAZE = "/uploads/nk0509/png-clipart-batman-gotham-city-skyline-silhouette-wall-decal-city-building-text.png";
const TEXTURE_AGENT = "/uploads/nk0509/joker-logo-vector-34916658.jpg";
const TEXTURE_ENEMY = "/uploads/nk0509/Batman-Logo.png";



const MUSIC_BACK = "/uploads/nk0509/batman_2.mp3";
const SOUND_ALARM = "/uploads/nk0509/26f8b9_sonic_ring_sound_effect.mp3";


const gridsize = 30;  // 30  // number of squares along side of world

const NOBOXES = Math.trunc((gridsize * gridsize) / 10  ); // 10
// density of maze - number of internal boxes
// (bug) use trunc or can get a non-integer

const squaresize = 100; // size of square in pixels

const MAXPOS = gridsize * squaresize; // length of one side in pixels

const SKYCOLOR = 0xddffdd; // a number, not a string

const startRadiusConst = MAXPOS * 0.8; // distance from centre to start the camera at
const maxRadiusConst = MAXPOS * 10; // maximum distance from camera we will render things

let initialGrid = [];
//--- change ABWorld defaults: -------------------------------

ABHandler.MAXCAMERAPOS = maxRadiusConst;

ABHandler.GROUNDZERO = true; // "ground" exists at altitude zero

//--- skybox: -------------------------------
// skybox is a collection of 6 files
// x,y,z positive and negative faces have to be in certain order in the array
//This work is licensed under a Creative Commons Attribution 3.0 Unported License.
//http://creativecommons.org/licenses/by/3.0/


const SKYBOX_ARRAY = [
  "/uploads/nk0509/posxx.jpg",
  "/uploads/nk0509/negxx.jpg",
  "/uploads/nk0509/posyy.jpg",
  "/uploads/nk0509/negyy.jpg",
  "/uploads/nk0509/poszz.jpg",
  "/uploads/nk0509/negzz.jpg",
  ];

// space skybox, credit:
// http://en.spaceengine.org/forum/21-514-1
// x,y,z labelled differently

/*
 const SKYBOX_ARRAY = [										 
				"/uploads/starter/sky_pos_z.jpg",
				"/uploads/starter/sky_neg_z.jpg",
				"/uploads/starter/sky_pos_y.jpg",
				"/uploads/starter/sky_neg_y.jpg",
				"/uploads/starter/sky_pos_x.jpg",
				"/uploads/starter/sky_neg_x.jpg"
				];
*/
// urban photographic skyboxes, credit:
// http://opengameart.org/content/urban-skyboxes

/*
 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"
				];
*/

// ===================================================================================================================
// === End of tweaker's box ==========================================================================================
// ===================================================================================================================





//--- Mind can pick one of these actions -----------------
const ACTION_LEFT = 0;
const ACTION_RIGHT = 1;
const ACTION_UP = 2;
const ACTION_DOWN = 3;
const ACTION_STAYSTILL = 4;

// in initial view, (smaller-larger) on i axis is aligned with (left-right)
// in initial view, (smaller-larger) on j axis is aligned with (away from you - towards you)

// contents of a grid square
const GRID_BLANK = 0;
const GRID_WALL = 1;
const GRID_MAZE = 4;

var BOXHEIGHT; // 3d or 2d box height
var GRID = new Array(gridsize); // can query GRID about whether squares are occupied, will in fact be initialised as a 2D array
var theagent, theenemy;
var wall_texture, agent_texture, enemy_texture, maze_texture;

// enemy and agent position on squares
var ei, ej, ai, aj;

var badsteps;
var goodsteps;

var WALLMOVENO=5
var WALLMOVETICK= 1



// record path
var path = []
var oldPath = []
// Euclidean distance
function distance(x1, y1, x2, y2) {
  
  return Math.sqrt(((x2-x1)*(x2-x1))+((y2-y1)*(y2-y1)));
}


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

//Define grid object marking all pointers
function mark(i, j, type = GRID_BLANK) {
                                                              // objects
                                                              // Pointer Location
  this.i = i;
  this.j = j;

                                                              //values of f,g,h .
  this.f = 0;
  this.g = 0;
  this.h = 0;
                                                              // Neighbors
  this.neighbors = [];
  this.wall = false;
  this.maze = false;
  
  this.previous = undefined;
  if (type == GRID_WALL) this.wall = true;
  if (type == GRID_MAZE) this.maze = true;
  
  this.addNeighbors = function (grid) {                       //finding the neighbors
    var i = this.i;
    var j = this.j;
    if (i < gridsize - 1) 
       this.neighbors.push(grid[i + 1][j]);
    if (i > 0) 
       this.neighbors.push(grid[i - 1][j]);
    if (j < gridsize - 1) 
       this.neighbors.push(grid[i][j + 1]);
    if (j > 0) 
    this.neighbors.push(grid[i][j - 1]);
   
   };
}

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()) initScene(); // if all file loads have returned
  });

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

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

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

function asynchFinished() {
  // all file loads returned
  if (wall_texture && agent_texture && enemy_texture && maze_texture)
    return true;
  else return false;
}

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

function occupied(i, j) {
  // is this square occupied
  if (ei == i && ej == j) return true; // variable objects
  if (ai == i && aj == j) return true;
  if (GRID[i][j].wall || GRID[i][j].maze) 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 * squaresize - MAXPOS / 2;
  v.z = j * squaresize - MAXPOS / 2;

  return v;
}

puzzle=[]
function initScene() {
  // all file loads have returned
  var i, j, shape, thecube;
  // set up GRID as 2D array
  for (i = 0; i < gridsize; i++) GRID[i] = new Array(gridsize);
  // set up walls
  for (i = 0; i < gridsize; i++)
    for (j = 0; j < gridsize; j++)
      if (i == 0 || i == gridsize - 1 || j == 0 || j == gridsize - 1) {
        GRID[i][j] = new mark(i, j, GRID_WALL);            //wall grid
        shape = new THREE.BoxGeometry(squaresize, BOXHEIGHT, squaresize);
        thecube = new THREE.Mesh(shape);
        thecube.material = new THREE.MeshBasicMaterial({ map: wall_texture });
        thecube.position.copy(translate(i, j)); // translate my (i,j) grid coordinates to three.js (x,y,z) coordinates
        ABWorld.scene.add(thecube);
      } else {
        GRID[i][j] = new mark(i, j, GRID_BLANK);
      }

      // set up maze
      for (var c = 1; c <= NOBOXES; c++) {
        i = AB.randomIntAtoB(1, gridsize - 2); // inner squares are 1 to gridsize-2
        j = AB.randomIntAtoB(1, gridsize - 2);
    
        GRID[i][j] = new mark(i, j, GRID_MAZE);           //maze grid   
        puzzle.push(GRID[i][j])
        shape = new THREE.BoxGeometry(squaresize, BOXHEIGHT, squaresize);
        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 < gridsize; i++)
    for (j = 0; j < gridsize; j++) GRID[i][j].addNeighbors(GRID);

  initialGrid = [...GRID]; // Store a copy of the inital grid

  // set up enemy
  // start in random location

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

  ei = i;
  ej = j;

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

  // set up agent
  // start in random location

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

  ai = i;
  aj = j;
  console.log("Start Position", ai, aj);
  shape = new THREE.BoxGeometry(squaresize, BOXHEIGHT, squaresize);
  theagent = new THREE.Mesh(shape);
  theagent.material = new THREE.MeshBasicMaterial({ map: agent_texture });
  ABWorld.scene.add(theagent);
  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
    }
  );
}

// Need to remove previouse information
function resetSearch() {
    for (i = 0; i < gridsize; i++)
        for (j = 0; j < gridsize; j++) GRID[i][j].previous = undefined;
}

// --- draw moving objects -----------------------------------
function drawEnemy() {
  // given ei, ej, draw it
  theenemy.position.copy(translate(ei, ej)); // translate my (i,j) grid coordinates to three.js (x,y,z) coordinates
  ABWorld.lookat.copy(theenemy.position); // if camera moving, look back at where the enemy is
}

function drawAgent() {
  // given ai, aj, draw it
  theagent.position.copy(translate(ai, aj)); // translate my (i,j) grid coordinates to three.js (x,y,z) coordinates
  ABWorld.follow.copy(theagent.position); // follow vector = agent position (for camera following agent)
}

// draw path 
function drawPath() {
    for (let object of oldPath ) {
        var delpath = ABWorld.scene.getObjectByName("Path Object"+object.i+object.j);
        ABWorld.scene.remove(delpath)                    //removing the old path
    }
    for(let pathBlock of path ) {
        var shape = new THREE.BoxGeometry(30,30,30)                         //size
        var type = new THREE.MeshBasicMaterial({ color: "#FF0000"});  //color
        
        type.transparent = true; 
        type.opacity = 0.5;      
        
        var crpath = new THREE.Mesh( shape, type );    // creating a new path
        crpath.name = "Path Object"+pathBlock.i+pathBlock.j;
        crpath.position.copy(translate(pathBlock.i, pathBlock.j));
        ABWorld.scene.add(crpath);
    }
}
 


function movewalls(){ 
       if(WALLMOVENO>NOBOXES)
        {
            WALLMOVENO=0
        }
        
        for (var c = 1; c <=WALLMOVENO; c++) {
            x = AB.randomIntAtoB(1,puzzle.length+1);
            object=puzzle[x-1]
            var oldMaze = ABWorld.scene.getObjectByName("Maze"+object.i+object.j);
            ABWorld.scene.remove( oldMaze )
            object.maze=false
           
            var p1=puzzle.slice(0,x-1)
            var p2=puzzle.slice(x,puzzle.lenght)
            puzzle=p1.concat(p2)
            
            do {
            i = AB.randomIntAtoB(1, gridsize - 2);
            j = AB.randomIntAtoB(1, gridsize - 2);
          } while (occupied(i, j))
          
            
            GRID[i][j].maze=true
            puzzle.push(GRID[i][j])
            shape = new THREE.BoxGeometry(squaresize, BOXHEIGHT, squaresize);
            
            thecube = new THREE.Mesh(shape);
            thecube.material = new THREE.MeshBasicMaterial({ map: maze_texture });
            
            thecube.name = "Maze"+i+j;
            thecube.position.copy(translate(i, j)); // translate my (i,j) grid coordinates to three.js (x,y,z) coordinates
            ABWorld.scene.add(thecube);
          
        }
    }    



function heuristic(a, b) {
  return Math.abs(a.i - b.i) + Math.abs(a.j - b.j);
}


// Open and closed set for a*
var openSet = [];
var closedSet = [];
var start;
var end;

// --- take actions -----------------------------------
function moveLogicalEnemy() {
  // clearOldPath()
  closedSet = [];
  openSet = [];
  start = GRID[ei][ej];
  end = GRID[ai][aj];
  console.log(GRID[ei][ej], GRID[ai][aj], ai,aj,ei,ej)
  //pushing the values in start
  openSet.push(start);

  var optimalPathFound = false;
  var current = null;
  while (true) {
    if (openSet.length > 0) {
      console.log("open set -", openSet);
      // Best next option
      var cpoint = 0;
      for (var i = 0; i < openSet.length; i++)
        if (openSet[i].f < openSet[cpoint].f) cpoint = i;
            current = openSet[cpoint];

      
      if (current === end) {
        optimalPathFound = true;
        break;
      }
      // openSet to closedSet
      removeFromArray(openSet, current);
      closedSet.push(current);

      
      var neighbors = current.neighbors;

      //--- start of for loop -----------
      for (var i = 0; i < neighbors.length; i++) {
        var neighbor = neighbors[i];

        
        if (!closedSet.includes(neighbor) && !neighbor.wall && !neighbor.maze) {
          var g = current.g + 1; // add up g values in cumulative way

          // Is this a better path than before?
          var temp = false;
          if (openSet.includes(neighbor)) {
            if (g < neighbor.g) {
              neighbor.g = g;
              temp = true;
            }
          } else {
            neighbor.g = g;
            temp = true;
            openSet.push(neighbor);
          }

          // Found a neighbor
          if (temp) {
            neighbor.h = heuristic(neighbor, end);
            neighbor.f = neighbor.g + neighbor.h;
            neighbor.previous = current;
          }
        }
      }
      //--- end of for loop -----------
    } else {
        console.log("No Route found");
        break;
    }
  }

  if( path.length > 0 ) {
    oldPath = [...path]    
  }
  
  path = [];
  var temp = current;
  path.push(temp);
  while (temp.previous) {
    if( !( temp.previous == start || temp.previous == end ) ) {
        path.push(temp.previous);
    }   
    temp = temp.previous;
  }
if(AB.step%WALLMOVETICK===0){
    movewalls()
}
  console.log("Path Found ", path);
  ei = path[path.length - 1].i;
  ej = path[path.length - 1].j;
  resetSearch();
}

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 = squaresize;
    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();
  drawPath();
  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> Joker Caught. Batman WINS </B> </font>   ",
      3
    );
  else AB.msg(" <br> <font color=green> <B> Run over Try Again. </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
}