Programmazione del gioco ai: ridimensionamento dei muri per trovare un giocatore?

Question

Ho lavorato a questo metodo di intelligenza artificiale per un po '. Fondamentalmente ha un int per ogni direzione in cui il nemico potrebbe andare se un muro blocca il suo percorso verso il giocatore. Questo non funziona nella maggior parte dei casi. A volte il nemico passa attraverso fessure che non riesce a superare. Altre volte sarà bloccato su muri che presentano evidenti vuoti in essi. Allegherò il mio codice, ma se sembra troppo inefficiente o semplicemente non è il modo di risolverlo, non sono contrario a cambiare completamente il mio approccio. Vorrei solo sapere come sono fatte queste cose normalmente, così da poterle implementare in un modo migliore (e funzionante!).

Il mio codice:

public void update(ArrayList<Wall> walls, Player p){ 

    findPlayer(p.getX(), p.getY()); 

    boolean isCollision = false; 
    System.out.println(isCollision); 
    //if movement straight towards the player is blocked, move along the walls 
    for(Wall w : walls){ 
     if(Helper.isBoundingBoxCollision((int)(x + vectorToPlayer.getDX() * SPEED), (int)(y + vectorToPlayer.getDY() * SPEED), width, height, w.getX(), w.getY(), w.width, w.height)){ 
      isCollision = true; 

      if(Math.abs(vectorToPlayer.getDX()) > Math.abs(vectorToPlayer.getDY())){ 
       if(vectorToPlayer.getDX() > 0) 
        WALL_COLLISION = 3; 
       else 
        WALL_COLLISION = 1; 
      } 
      else if(Math.abs(vectorToPlayer.getDX()) <  Math.abs(vectorToPlayer.getDY())){ 
       if(vectorToPlayer.getDY() > 0) 
        WALL_COLLISION = 0; 
       else 
        WALL_COLLISION = 2; 
      } 

     } 
    } 
    //System.out.println(isCollision); 
    //set the direction to the straight on vector, to be reset if there is a collision on this path 
    direction = vectorToPlayer; 

    if(isCollision){ 
     //reset the variable, don't mind that what this is named is completely opposite = PIMPIN' 
     isCollision = false; 

     //scale dem walls son, and see when the path is clear 
     for(Wall w : walls){ 
      if(WALL_COLLISION == 0 && !Helper.isBoundingBoxCollision(x + SPEED, y, width, height, w.getX(), w.getY(), w.width, w.height)){ 
       WALL_COLLISION = 3; 
       isCollision = true; 
      } 
      else if(WALL_COLLISION == 1 && !Helper.isBoundingBoxCollision(x, y + SPEED, width, height, w.getX(), w.getY(), w.width, w.height)){ 
       WALL_COLLISION--; 
       isCollision = true; 
      } 
      else if(WALL_COLLISION == 2 && !Helper.isBoundingBoxCollision(x - SPEED, y, width, height, w.getX(), w.getY(), w.width, w.height)){ 
       WALL_COLLISION--; 
       isCollision = true; 
      } 
      else if(WALL_COLLISION == 3 && !Helper.isBoundingBoxCollision(x, y - SPEED, width, height, w.getX(), w.getY(), w.width, w.height)){ 
       WALL_COLLISION--; 
       isCollision = true; 
      } 
     } 

     //if there is NOT a wall on the designated side, set the vector accoridingly 
     if(isCollision){ 
      if(WALL_COLLISION == 0) 
       direction = new NVector(0, 1); 
      else if(WALL_COLLISION == 1) 
       direction = new NVector(1, 0); 
      else if(WALL_COLLISION == 2) 
       direction = new NVector(0, -1); 
      else if(WALL_COLLISION == 3) 
       direction = new NVector(-1, 0); 
     } 
    } 
    x += Math.round(direction.getDX()*SPEED); 
    y += Math.round(direction.getDY()*SPEED); 
} 

Answer 1

Sembra che quello che si sta cercando di attuare è conosciuto come sterzo, ma il modo in cui queste cose vengono fatte normalmente sarebbe Pathfinding. Quale decidi di utilizzare dipende dalla tua applicazione. Lo sterzo viene fatto spostandosi verso il bersaglio ma cambiando direzione se c'è un ostacolo e non è garantito il raggiungimento della sua destinazione. La ricerca del percorso viene solitamente eseguita costruendo un grafico di waypoint o aree "percorribili" e quindi utilizzando an algorithm such as Dijkstra's per attraversarlo.