Flora and Fauna

[ghost]

Live animals and Live plants.

An ECO system in minekhan...

[SnehasishCodez]

hmm AI would be a huge thing to figure out first.

[ghost]

hmm AI would be a huge thing to figure out first.

I'm unaware of whether Minecraft uses genuine A.I. or not, but it's no necessary, we just need a way to measure the shortest path from one block to another, and to make the mob follow it.

Mobs don't learn, they aren't smart.

[SnehasishCodez]

hmm AI would be a huge thing to figure out first.

I'm unaware of whether Minecraft uses genuine A.I. or not, but it's no necessary, we just need a way to measure the shortest path from one block to another, and to make the mob follow it.

Mobs don't learn, they aren't smart.

Let me rephrase my sentence how bout we need to just code a simple bot/AI for mobs that tell them not to fall off a cliff or not to go into a cave which would require tons more of work

Maybe There could be a different word instead of AI but 🤷

[SnehasishCodez]

Guys do you guys sometimes get the chills playing minekhan like you arent alone there is someone else playing in the emty world of minekhan ???

(It would be funny if willard added herbrine for fun after basic mobs get added lol).

[Hacker1254]

These will be Very Hard, near to impossible but only near, most likely will make the project incompable with Khan

[InterestingBrainPoops]

hmm AI would be a huge thing to figure out first.

I'm unaware of whether Minecraft uses genuine A.I. or not, but it's no necessary, we just need a way to measure the shortest path from one block to another, and to make the mob follow it.

Mobs don't learn, they aren't smart. its possible for us to implement A* or some other form of naïve path finding.

[ghost]

I just used:

 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;
        }

and

        this.updateVelocity(now)

dumbest AI ever. If you want it to rotate towards you,

  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;

[ghost]

Edit: this is in the modded ver. I dunno if it works on the real thing.

[ghost]

    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;
            }
        }

    }

nailed it!

[ghost]

Took longer than expected, but I now have a fully functioning AI!

[ghost]

Actually.... I don't. errors... errors... more errors... I managed to do it in p5.js.... but not in js...

[harsha7addanki]

hmm AI would be a huge thing to figure out first.

I'm unaware of whether Minecraft uses genuine A.I. or not, but it's no necessary, we just need a way to measure the shortest path from one block to another, and to make the mob follow it.

Mobs don't learn, they aren't smart.

it dosent its just path find and if else

[Willard21]

AI doesn't imply neural networks when referring to game entities, so learning has nothing to do with it. AI just refers to the logic used to control them. If you call entities pets, allies, enemies, mobs, or NPCs, you're attributing some level of intelligence to them, and that intelligence is artificial, making it AI. Even if it's stupid AI, it's still AI.

[harsha7addanki]

yeah i figured when he said genuine ai i thought he meant like ML/DL