Flora and Fauna about minekhan HOT 14 OPEN

 this.speed = 0.1
        if (this.x > p.x - (this.height / 2)) {

            this.x -= this.speed / 4
;
        }
        if (this.x < p.x - (this.height / 2)) {
            this.x += this.speed / 4;
        }
        if (this.z > p.z - (this.height / 2)) {

        
            this.z -= this.speed / 4; 
        }
        if (this.z < p.z - (this.height / 2)) {

            this.z += this.speed / 4;
        }
        if (this.y > p.y+0.1 - (this.height / 2)) {

            this.y += this.speed / 4; 
        }
        if (this.y < p.y+0.1 - (this.height / 2)) {

            this.y += this.speed / 4;
        }

        this.updateVelocity(now)

  function angleToPointDegrees(point1, point2) {
    return (angleToPointRadians(point1, point2) * 180 / Math.PI);
  }
  
  function getPos(canvas, evt) {
    var rect = canvas.getBoundingClientRect();
    return {
      x: evt.clientX - rect.left,
      y: evt.clientY - rect.top
    };
  }
    var playerPos = {x: p.x, z: p.z};
			let now = performance.now()
        let d = p.direction
        this.yaw = -angleToPointRadians(playerPos, this) + 110;

	var path = [];				// Array of path branch checks
	var path_switch = false;	// Triggered when the generated path is switched to use
	var path_i = 0;				// Number of branch check iterations
	var path_count = 0;			// Number of path branches made
	var path_end = false;		// If the path has found its destination
	var path_loopcount = 0;		// Number of path entries to check
	var path_target_x = 0;		// Target X co-ordinate
	var path_target_y = 0;		// Target Y co-ordinate
	var path_start_x = 0;		// Starting X co-ordinate
	var path_start_y = 0;		// Starting Y co-ordinate
	var path_parent_x = 0;		// Stored parent X co-ordinate for building final path
	var path_parent_y = 0;		// Stored parent Y co-ordinate for building final path
	var path_done = [];			// Final path
	var path_done_count = 0;	// Final path count
	var path_coords = [];		// Recorded co-ordinates of each move for mapping best path when a proper one isn't possible
	var path_coords_count = 0;	// Number of recorded co-ordinates
	var path_store_x = 0;		// Closest possible co-ordinate if the path isn't possible
	var path_store_y = 0;		// Closest possible co-ordinate if the path isn't possible
	var path_store_n = 0;		// How close a set of co-ordinates is to the target
	var path_limit = 3000;		// Number of steps in the pathfinder
	
	function calcPath(x1,y1) {

		// Set target location
		path_target_x = Math.floor((Math.abs(screen_x)+x1-(bound_x*0.2))/gridsize);
		path_target_y = Math.floor((Math.abs(screen_y)+y1-(bound_y*0.2))/gridsize);
		
		// Set current location
		path_start_x = Math.floor(((spawn_x*gridsize)+xoffset)/gridsize);
		path_start_y = Math.floor(((spawn_y*gridsize)+yoffset)/gridsize);
		
		// Build array of landscape for pathbuilding
		path = [];
		for (y=0; y<ls.length; y++) {
			path[y] = [];
			for (x=0; x<ls[0].length; x++) {
				path[y][x] = '';
			}
		}
		
		// Set initial variables
		path_i = 0;
		path_end = false;
		path[path_start_y][path_start_x] = 'start';
		path[(path_start_y-1)][(path_start_x)] = 'up';
		path[(path_start_y+1)][(path_start_x)] = 'down';
		path[(path_start_y)][(path_start_x-1)] = 'left';
		path[(path_start_y)][(path_start_x+1)] = 'right';
		path_coords = [];
		path_coords_count = 0;
		
		cx = path_start_x;
		cy = path_start_y;
		p_dir = 'right';
		p_num = 1;
		p_count = 0;

		// Main checker
		while (path_i<path_limit&&!path_end) {

			//alert(p_num+' - '+p_count+' - '+p_dir)
			cancel = false;
		
			// Spiral outwards from starting position to check tiles
			if (p_dir=='right') {
				if (p_count<=p_num) {
					p_count++;
					cx += 1;
					if (p_count==p_num) {
						p_dir = 'down';
						p_count = 0;
					}
				}
			}
			else if (p_dir=='down') {
				if (p_count<=p_num) {
					p_count++;
					cy += 1;
					if (p_count==p_num) {
						p_dir = 'left';
						p_count = 0;
						p_num++;
					}
				}
			}
			else if (p_dir=='left') {
				if (p_count<=p_num) {
					p_count++;
					cx -= 1;
					if (p_count==p_num) {
						p_dir = 'up';
						p_count = 0;
					}
				}
			}
			else if (p_dir=='up') {
				if (p_count<=p_num) {
					p_count++;
					cy -= 1;
					if (p_count==p_num) {
						p_dir = 'right';
						p_count = 0;
						p_num++;
					}
				}
			}
			
			// Limit spiral to within the area
			if (cy<1) { cancel = true; }
			if (cx<1) { cancel = true; }
			if ((ls.length-2)<cy) { cancel = true; }
			if ((ls[0].length-2)<cx) { cancel = true; }
			
			// Check current tile
			if (!cancel&&path[cy][cx]!=''&&path[cy][cx]!='start') {
	
				// If down is free
				if (!calcPathTiles(cx,cy+1)&&path[(cy+1)][(cx)]=='') {
					path_coords[path_coords_count] = [cx,cy+1];
					path_coords_count++;
					path[(cy+1)][(cx)] = 'down';
				}
				// If right is free
				if (!calcPathTiles(cx+1,cy)&&path[(cy)][(cx+1)]=='') {
					path_coords[path_coords_count] = [cx+1,cy];
					path_coords_count++;
					path[(cy)][(cx+1)] = 'right';
				}
				// If up is free
				if (!calcPathTiles(cx,cy-1)&&path[(cy-1)][(cx)]=='') {
					path_coords[path_coords_count] = [cx,cy-1];
					path_coords_count++;
					path[(cy-1)][(cx)] = 'up';
				}
				// If left is free
				if (!calcPathTiles(cx-1,cy)&&path[(cy)][(cx-1)]=='') {
					path_coords[path_coords_count] = [cx-1,cy];
					path_coords_count++;
					path[(cy)][(cx-1)] = 'left';
				}
	
			}

			if (path[path_target_y][path_target_x]!='') {
				path_end = true;
			}
			path_i++;	// Count iterations
		}
		
		// If we didn't find the destination get the closest co-ordinate
		if (!path_end) {
		
			path_store_x = 0;		// Closest X co-ordinate
			path_store_y = 0;		// Closest Y co-ordinate
			path_store_n = 100000;	// Number value of how close it is
		
			// Loop through all recorded co-ordinates
			for (i=0; i<path_coords_count; i++) {
				nx = Math.abs(path_target_x-path_coords[i][0]);
				ny = Math.abs(path_target_y-path_coords[i][1]);
				
				// If current co-ordinate is closer to the target than the current closest
				if ((nx+ny)<path_store_n) {
					path_store_x = path_coords[i][0];	// Set current closest X co-ordinate
					path_store_y = path_coords[i][1];	// Set current closest Y co-ordinate
					path_store_n = nx+ny;				// Set current close value to check by
				}
			}
			px1 = path_store_x;	// Set the starting X co-ordinate to the closest co-ordinate
			py1 = path_store_y;	// Set the starting Y co-ordinate to the closest co-ordinate
			
		// If we did find the destination
		} else {
			px1 = path_target_x;	// Set the starting X co-ordinate to the destination
			py1 = path_target_y;	// Set the starting Y co-ordinate to the destination
		}
		

		// Reset the finished path map vars
		path_done = [];
		path_done_count = 0;
		path_mapped = false;
		path_mapped_i = 0;
		direction1 = '';
		direction2 = '';
		direction3 = '';
		px2 = 0;				// One step forward X
		py2 = 0;				// One step forward Y
		px3 = 0;				// Two steps forward X
		py3 = 0;				// Two steps forward Y
		diagonal = false;

		// Calculate the route from the spidered array
		while(!path_mapped&&(path_done_count<path_limit+20)) {
		
			// Move co-ordinates forward a step
			direction3 = direction2;
			px3 = px2;
			py3 = py2;				
			direction2 = direction1;
			px2 = px1;
			py2 = py1;

			// Head backwards from the direction to trace the route back
			direction1 = path[py1][px1];
			
			if (direction1=='up') {
				py1 = py2+1;
				px1 = px2; 
			}
			else if (direction1=='down') {
				py1 = py2-1;
				px1 = px2; 
			}
			else if (direction1=='left') {
				py1 = py2;
				px1 = px2+1; 
			}
			else if (direction1=='right') {
				py1 = py2;
				px1 = px2-1;
			}
			
			// Overwrite diagonal tiles
			var overwrite = false;
			
			if (direction1=='up') {
				if (direction2=='left') {
					overwrite = true;
					direction1 = 'upleft';
				}
				if (direction2=='right') {
					overwrite = true;
					direction1 = 'upright';
				}
			}
			if (direction1=='down') {
				if (direction2=='left') {
					overwrite = true;
					direction1 = 'downleft';
				}
				if (direction2=='right') {
					overwrite = true;
					direction1 = 'downright';
				}
			}
			if (direction1=='left') {
				if (direction2=='up') {
					overwrite = true;
					direction1 = 'upleft';
				}
				if (direction2=='down') {
					overwrite = true;
					direction1 = 'downleft';
				}
			}
			if (direction1=='right') {
				if (direction2=='up') {
					overwrite = true;
					direction1 = 'upright';
				}
				if (direction2=='down') {
					overwrite = true;
					direction1 = 'downright';
				}
			}
			if (overwrite) {
				if (diagonal) {
					diagonal = false;
				} else {
					path_done_count -= 1;
					diagonal = true;
				}
			} else {
				diagonal = false;
			}

			// Add to the route array the direction and co-ordinates
			path_done[path_done_count] = [direction1,px1,py1];

			// Count the backwards steps in the route
			path_done_count++;
			
			// If we have reached the start
			if (px1==path_start_x&&py1==path_start_y) {
				path_mapped = true;
			}
		}
		

	}