Création d'une ArrayList d'objets avec une boucle, vérification des objets qui se chevauchent

Question

Je crée un jeu pour une classe et un élément du jeu affiche un certain nombre de choux, qui sont stockés dans une ArrayList. Cette ArrayList doit être un nombre fixe de 20, 10 de bons choux et 10 de mauvais chou. Comme les choux sont créés, je veux m'assurer qu'ils ne se chevauchent pas lorsqu'ils sont affichés. Là où j'ai des ennuis avec ça, c'est que quand je trouve un chou qui se chevauche, je ne sais pas trop comment revenir en arrière et créer un nouveau chou à sa place. Jusqu'à présent, lorsque le code trouve un chevauchement, il arrête simplement la boucle. Je suppose que j'ai du mal à sortir correctement d'une boucle et à redémarrer à l'index qui n'est pas rempli.

Voici ce que j'ai jusqu'à présent pour cela. Toutes les suggestions seraient très appréciées.

 // Initialize the elements of the ArrayList = cabbages 
    // (they should not overlap and be in the garden) .... 
    int minX = 170 ; 
    int maxX = 480; 
    int minY = 15; 
    int maxY = 480; 
    boolean r = false; 
    Cabbage cabbage; 
    for (int i = 0; i < N_GOOD_CABBAGES + N_BAD_CABBAGES; i++){ 
     if (i % 2 == 0){ 
     cabbage = new GoodCabbage((int)(Math.random()* (maxX-minX + 1))+ minX, 
       (int)(Math.random()*(maxY-minY + 1))+ minY,window); 
     } 
     else { 
      cabbage = new BadCabbage((int)(Math.random()* (maxX-minX + 1))+ minX, 
        (int)(Math.random()*(maxY-minY + 1))+ minY,window); 
      } 
     if (i >= cabbages.size()){ 
     // compares the distance between two cabbages 
      for (int j = 0; j < cabbages.size(); j++){ 
       Point c1 = cabbage.getLocation(); 
       Cabbage y = (Cabbage) cabbages.get(j); 
       Point c2 = y.getLocation(); 
       int distance = (int) Math.sqrt((Math.pow((c1.x - c2.x), 2) + Math.pow((c1.y - c2.y),2))); 
       if (distance <= (CABBAGE_RADIUS*2) && !(i == j)){ 
        r = true; 
       } 
      } 
     if (r){ 
      break; 
      } 
     cabbage.draw(); 
     cabbages.add(i, cabbage); 
     }  
    } 

Answer 1

On dirait que vous faites des objets de chou, puis de les jeter, ce qui est un (trivial) déchets. Pourquoi ne pas choisir le X et le Y aléatoires, vérifier s'il y a de la place à cet endroit, puis faire le chou quand vous avez un bon endroit? Vous ne ferez que déplacer des chiffres, plutôt que de fabriquer et de jeter des objets entiers. De plus, vous n'aurez pas à répéter le code de localisation aléatoire pour les bons et les mauvais choux.

int x, y do {// ramasser x et y } while (cabbageOverlaps (x, y, liste)

// créer un chou à cette x, y, et l'ajouter à la liste

boolean cabbageOverlaps (entier x, int y, ArrayList existantCabbages)

Answer 2

La méthode la plus simple consiste probablement à ajouter une autre boucle.

A boucle do ... while est adapté aux cas où vous avez besoin toujours au moins une itération. Quelque chose comme:

boolean overlapped; 
    do { 
     // create your new cabbage here 

     overlapped = /* check whether it overlaps another cabbage here */; 
    } while (overlapped); 

    cabbage.draw(); 
    cabbages.add(i, cabbage);