// Cloned by Khizer Ahmed on 23 Jul 2022 from World "Resit_Assignement 1: Khizer Ahmed Biyabani" by Khizer Ahmed
// Please leave this clone trail here.
// Cloned by Khizer Ahmed on 17 Nov 2021 from World "Complex World" by Starter user
// Please leave this clone trail here.
// Resit Assignement 1 : World 2 'Trapping the Agent'
// ==== Starter World =================================================================================================
// 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 = 100;
// 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/khizer2599/upside_down.jpg' ;
const TEXTURE_MAZE = '/uploads/khizer2599/1658586769.png' ;
const TEXTURE_AGENT = '/uploads/khizer2599/1658586837.png' ;
const TEXTURE_ENEMY = '/uploads/khizer2599/1658586413.png' ;
// credits:
// http://commons.wikimedia.org/wiki/File:Old_door_handles.jpg
// https://commons.wikimedia.org/wiki/Category:Pac-Man_icons
// https://commons.wikimedia.org/wiki/Category:Skull_and_crossbone_icons
// http://en.wikipedia.org/wiki/File:Inscription_displaying_apices_(from_the_shrine_of_the_Augustales_at_Herculaneum).jpg
const MUSIC_BACK = '/uploads/khizer2599/stranger-things-theme-song.mp3' ;
const SOUND_ALARM = '/uploads/khizer2599/jumpscare.mp3' ;
// credits:
// http://www.dl-sounds.com/royalty-free/defense-line/
// http://soundbible.com/1542-Air-Horn.html
const gridsize = 50; // number of squares along side of world
const NOBOXES = Math.trunc ( (gridsize * gridsize) / 3 );
// 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
//--- 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
// https://threejs.org/docs/#api/en/loaders/CubeTextureLoader
// mountain skybox, credit:
// http://stemkoski.github.io/Three.js/Skybox.html
/* const SKYBOX_ARRAY = [
"/uploads/starter/dawnmountain-xpos.png",
"/uploads/starter/dawnmountain-xneg.png",
"/uploads/starter/dawnmountain-ypos.png",
"/uploads/starter/dawnmountain-yneg.png",
"/uploads/starter/dawnmountain-zpos.png",
"/uploads/starter/dawnmountain-zneg.png"
];
*/
// 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 ==========================================================================================
// ===================================================================================================================
// You will need to be some sort of JavaScript programmer to change things below the 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 = 2;
var diagonal = false;
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 path = []; // For path track.
var previousMove = []; // Position Tracking of the moving objects.
var line = null;
var trap_path;
var previoustrap = []; //Storing the previous trap.
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
{
return !!(wall_texture && agent_texture && enemy_texture && maze_texture);
}
//--- grid system -------------------------------------------------------------------------------
// my numbering is 0 to gridsize-1
function occupied(x, y) {
return ei == x && ej == y || ai == x && aj == y || GRID[x][y].type == GRID_WALL || GRID[x][y].type == GRID_MAZE;
}
// 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(e, o)
{
var globalBonePosition = new THREE.Vector3();
return globalBonePosition.y = 0, globalBonePosition.x = e * squaresize - MAXPOS / 2, globalBonePosition.z = o * squaresize - MAXPOS / 2, globalBonePosition;
}
// Drawing a path-line from the enemy(Vecna) to agent(Maxine)
function drawLine()
{
if (line !== null)
{
ABWorld.scene.remove(line);
}
var connects = [];
var material = new THREE.LineDashedMaterial( {
color: '#FF0000',
linewidth: 1,
scale: 1,
dashSize: 1,
gapSize: 100,
} );
//console.log(path);
var i = 0;
for (; i < this.path.length; i++)
{
connects.push(translate(this.path[i].i, this.path[i].j));
}
var a = (new THREE.BufferGeometry()).setFromPoints(connects);
line = new THREE.Line(a, material);
ABWorld.scene.add(line);
}
// Calculating the Distance between the enemy(Vecna) and the agent(Maxine).
function calculateDistance(loc1, loc2)
{
return Math.abs(loc1 - loc2);
}
function grid_arrangement(type, i, j)
{
this.i = i;
this.j = j;
this.type = type;
this.f = 0;
this.g = 0;
this.h = 0;
this.neighbors = [];
this.previous = null;
this.addNeighbors = function()
{
this.neighbors = [];
var j = this.i;
var i = this.j;
if (j < gridsize - 1)
{
this.neighbors.push(GRID[j + 1][i]);
}
if (j - 1 > 0)
{
this.neighbors.push(GRID[j - 1][i]);
}
if (i + 1 < gridsize)
{
this.neighbors.push(GRID[j][i + 1]);
}
if (i - 1 > 0)
{
this.neighbors.push(GRID[j][i - 1]);
}
};
}
function initScene()
{
var x;
var y;
var enemy_position;
var light;
x = 0;
for (; x < gridsize; x++)
{
GRID[x] = new Array(gridsize);
}
x = 0;
for (; x < gridsize; x++)
{
y = 0;
for (; y < gridsize; y++)
{
if (0 === x || x == gridsize - 1 || 0 === y || y == gridsize - 1)
{
GRID[x][y] = new grid_arrangement(GRID_WALL, x, y);
sphere = new THREE.BoxGeometry(squaresize, BOXHEIGHT, squaresize);
(light = new THREE.Mesh(sphere)).material = new THREE.MeshBasicMaterial({
map : wall_texture
});
light.position.copy(translate(x, y));
ABWorld.scene.add(light);
}
else
{
GRID[x][y] = new grid_arrangement(GRID_BLANK, x, y);
}
}
}
var i = 1;
for (; i <= NOBOXES; i++)
{
x = AB.randomIntAtoB(1, gridsize - 2);
y = AB.randomIntAtoB(1, gridsize - 2);
GRID[x][y] = new grid_arrangement(GRID_MAZE, x, y);
sphere = new THREE.BoxGeometry(squaresize, BOXHEIGHT, squaresize);
(light = new THREE.Mesh(sphere)).material = new THREE.MeshBasicMaterial({
map : maze_texture
});
light.position.copy(translate(x, y));
ABWorld.scene.add(light);
}
do {
x = AB.randomIntAtoB(1, gridsize - 2);
y = AB.randomIntAtoB(1, gridsize - 2);
} while (occupied(x, y));
ei = x;
ej = y;
enemy_position = new THREE.BoxGeometry(squaresize, BOXHEIGHT, squaresize);
(theenemy = new THREE.Mesh(enemy_position)).material = new THREE.MeshBasicMaterial({
map : enemy_texture
});
ABWorld.scene.add(theenemy);
var container = new THREE.BoxGeometry(100, 100, 100);
var material = new THREE.MeshBasicMaterial({
color : 0
});
var result = new THREE.Mesh(container, material);
ABWorld.scene.add(result);
result.position.copy(translate(ei, ej));
ABWorld.lookat.copy(result.position);
do
{
x = AB.randomIntAtoB(1, gridsize - 2);
y = AB.randomIntAtoB(1, gridsize - 2);
} while (occupied(x, y));
ai = x;
aj = y;
enemy_position = new THREE.BoxGeometry(squaresize, BOXHEIGHT, squaresize);
(theagent = new THREE.Mesh(enemy_position)).material = new THREE.MeshBasicMaterial({
map : agent_texture
});
ABWorld.scene.add(theagent);
ABWorld.scene.background = (new THREE.CubeTextureLoader()).load(SKYBOX_ARRAY, function() {
ABWorld.render();
AB.removeLoading();
AB.runReady = true;
});
}
// --- 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)
}
// Function to delete element from the array the openSet and closedSet
function removeFromArray(arr, elt)
{
// Could use indexOf here instead to be more efficient
for (var i = arr.length - 1; i >= 0; i--)
if (arr[i] == elt)
arr.splice(i, 1);
}
// Heuristic function
function heuristic(n, position)
{
var last = new THREE.Vector3(n.i, 0, n.j);
var current = new THREE.Vector3(position.i, 0, position.j);
return last.distanceTo(current);
}
// --- take actions -----------------------------------
// A star logic to catch Maxine (Agent) by enemy. To find the closest possible path.
function aStar_implemented()
{
var e = false;
openSet = [];
closedSet = [];
path = [];
var i = 0;
for (; i < gridsize; i++) {
var id = 0;
for (; id < gridsize; id++)
{
GRID[i][id].f = 0;
GRID[i][id].h = 0;
GRID[i][id].g = 0;
GRID[i][id].previous = null;
GRID[i][id].addNeighbors();
}
}
openSet.push(GRID[ei][ej]);
var current = null;
for (; 0 == e;)
{
var w = 0;
if (0 != openSet.length)
{
i = 0;
for (; i < openSet.length; i++)
{
if (openSet[i].f < openSet[w].f)
{
w = i;
}
}
if ((current = openSet[w]) !== GRID[ai][aj])
{
removeFromArray(openSet, current);
closedSet.push(current);
var neighbors = current.neighbors;
i = 0;
for (; i < neighbors.length; i++) {
var neighbor = neighbors[i];
if (neighbor.type != GRID_WALL && neighbor.type != GRID_MAZE && !closedSet.includes(neighbor))
{
var ng = current.g + heuristic(neighbor, current);
var d = false;
if (openSet.includes(neighbor))
{
if (ng < neighbor.g)
{
neighbor.g = ng;
d = true;
}
}
else
{
neighbor.g = ng;
d = true;
openSet.push(neighbor);
}
if (d)
{
neighbor.h = heuristic(neighbor, GRID[ai][aj]);
neighbor.f = neighbor.g + neighbor.h;
neighbor.previous = current;
}
}
}
}
else
{
console.log("Success - enemy found path to agent");
e = true;
}
}
else
{
e = true;
}
}
var next = current;
(path = []).push(next);
for (; next.previous;)
{
path.push(next.previous);
next = next.previous;
}
path = path.reverse();
drawLine();
trapfinder();
}
var is_trap = [];
function checkIf_trap(s) // Function for Checking the trap
{
var neighbors = s.neighbors;
var o = 0;
var i = 0;
for (; i < neighbors.length; i++)
{
if (neighbors[i].type == GRID_BLANK)
{
o++;
}
}
return 1 === o ? 1 : 0;
}
function trapfinder() // Grid Trap Locator
{
if (this.is_trap.length > 50)
{
this.is_trap = [];
}
var val = 0;
for (; val < gridsize; val++)
{
var n = 0;
for (; n < gridsize; n++)
{
if (GRID[val][n].type == GRID_BLANK && checkIf_trap(GRID[val][n]))
{
this.is_trap.push(GRID[val][n]);
}
}
}
}
function enemytoagent_distance() // distance from enemy to the agent.
{
if (this.previoustrap.length > 0)
{
i = 0;
for (; i < this.previoustrap.length; i++)
{
var c = this.previoustrap[i];
ABWorld.scene.remove(c);
}
}
var i = 0;
for (; i < this.is_trap.length; i++)
{
this.is_trap[i].distance = heuristic(GRID[ai][aj], this.is_trap[i]);
}
this.is_trap.sort(function(a, b)
{
return a.distance - b.distance;
});
// The trap mark. Cylindrical
var body_g = new THREE.CylinderGeometry(10, 10, 20, 32);
var body_m = new THREE.MeshBasicMaterial({
color : '#FFFFFF'
});
var body = new THREE.Mesh(body_g, body_m);
ABWorld.scene.add(body);
this.previoustrap.push(body);
body.position.copy(translate(this.is_trap[0].i, this.is_trap[0].j));
ABWorld.lookat.copy(body.position);
this.marked;
}
/// Agent (Maxine) and Enemy (Vecna) Moves.
function moveLogicalEnemy()
{
if (aStar_implemented(), enemytoagent_distance(), !(path.length <= 1))
{
var v1 = path[1];
if (!occupied(v1.i, v1.j))
{
ei = v1.i;
ej = v1.j;
previousMove.push(GRID[ei][ej]);
}
}
}
function moveLogicalAgent(defaction)
{
var i = ai;
var charsetBitSize = aj;
if (defaction == ACTION_LEFT)
{
i--;
}
else
{
if (defaction == ACTION_RIGHT)
{
i++;
}
else
{
if (defaction == ACTION_UP)
{
charsetBitSize++;
}
else
{
if (defaction == ACTION_DOWN)
{
charsetBitSize--;
}
}
}
}
if (!occupied(i, charsetBitSize))
{
ai = i;
aj = charsetBitSize;
}
}
// --- 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()
{
return Math.abs(ei - ai) < 2 && Math.abs(ej - aj) < 2;
}
function agentBlocked()
{
return occupied(ai - 1, aj) && occupied(ai + 1, aj) && occupied(ai, aj + 1) && occupied(ai, aj - 1);
}
// Updating the status before and after the moves.
function updateStatusBefore_moves(s)
{
var default_favicon = AB.world.getState();
AB.msg(" Step: " + AB.step + " x = (" + default_favicon.toString() + ") a = (" + s + ") ");
ABWorld.scene.remove(ABWorld.scene.getObjectByName("astarpath"));
}
function updateStatusAfter_moves()
{
var default_favicon = AB.world.getState();
var e_total = goodsteps / AB.step * 100;
AB.msg(" y = (" + default_favicon.toString() + ") <br> Bad steps: " + badsteps + " Good steps: " + goodsteps + " Score: " + e_total.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_moves(a);
// show status line before moves
var t = [ai,aj];
moveLogicalAgent(a);
if ( ( AB.step % 2 ) === 0 ) // slow the enemy down to every nth step
moveLogicalEnemy();
if ( badstep() )
{
badsteps++;
}
else
{
goodsteps++;
}
drawAgent();
drawEnemy();
updateStatusAfter_moves(); // 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();
console.log('Agent Trapped in the Nearest Trap.')
}
};
AB.world.endRun = function()
{
musicPause();
if ( AB.abortRun ) AB.msg ( " <br> <font color=red> <B> Vecna Cursed Maxine. 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
}