Spielprogrammierung ai: Wände skalieren, um einen Spieler zu finden?

Question

Ich arbeite seit einiger Zeit an dieser künstlichen Intelligenz-Methode. Es hat grundsätzlich eine int für jede Richtung, in die der Feind gehen könnte, wenn eine Mauer seinen Weg zum Spieler blockiert. Dies funktioniert in den meisten Fällen nicht. Manchmal wird der Feind durch Risse gehen, durch die er nicht passt. Andere Male wird es an Wänden hängen, die offensichtliche Lücken in ihnen haben. Ich werde meinen Code anhängen, aber wenn es zu ineffizient aussieht oder einfach nicht den Weg, es zu lösen, bin ich nicht dagegen, meinen Ansatz insgesamt zu ändern. Ich würde einfach gerne wissen, wie diese Dinge normal gemacht werden, damit ich sie besser (und funktionierend!) Umsetzen kann.

Mein Code:

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

Es scheint, dass das, was Sie gerade versuchen, als Lenkung bekannt zu implementieren, aber die Art, wie diese Dinge sind in der Regel wäre Pathfinding getan. Welche Sie verwenden, hängt von Ihrer Anwendung ab. Die Lenkung erfolgt, indem Sie sich auf Ihr Ziel zubewegen, aber die Richtung ändern, wenn ein Hindernis vorhanden ist, und es ist nicht garantiert, dass das Ziel erreicht wird. Die Pfadfindung wird in der Regel durch Erstellen eines Diagramms von Wegpunkten oder Bereichen durchgeführt, die "begehbar" sind und dann an algorithm such as Dijkstra's zum Durchlaufen verwenden.