Jeu de la vie en cours de traitement

Question

Je veux coder ma propre version de "jeu de la vie", dans le traitement 3, mais j'ai rencontré une erreur que je ne semble pas comprendre. Chaque fois que le code est exécuté, l'écran continue de fonctionner en noir et blanc avec quelques pixels qui changent, mais cela ne ressemble pas à un jeu de la vie.

Une aide?

int windowW, windowH, percentAlive, gen; 
//windowW is the width of the window, windowH is the height 
//percentVlive is the initial percent of alive pixel 
//gen is the counter for the generation 
color alive, dead;//alive is white and dead is black to represent their respective colors 
boolean[][] cells0, cells1;//two arrays for the state of the cells, either alive or dead 
boolean zeroOrOne = true;//this is to check which array should be iterated over 

void setup() { 
    size(700, 700); 

    int width = 700; 
    int height = 700; 

    windowW = width; 
    windowH = height; 

    percentAlive = 15; 

    alive = color(255, 255, 255); 
    dead = color(0, 0, 0); 

    cells0 = new boolean[width][height]; 
    cells1 = new boolean[width][height]; 

    frameRate(2); 

    background(alive); 

    for (int x=0; x<width; x++) {//set the percent of live pixels according to the precentAlive varriable 
    for (int y=0; y<height; y++) { 
     int state = (int)random (100); 
     if (state > percentAlive) 
     cells0[x][y] = true; 
     else 
     cells0[x][y] = false; 
    } 
    } 
} 



void draw() { 
    gen += 1;//increases the generation every time it draws 
    drawLoop(zeroOrOne); 
    WriteGeneration(gen); 

    if(zeroOrOne){//changes the zeroOrOne value to change the array being iterated over 
    zeroOrOne = false; 
    } 
    else { 
    zeroOrOne = true; 
    } 
} 

void WriteGeneration(int number) {//changes the label on top 
    fill(0); 
    rect(0, 0, windowW, 100); 
    fill(255); 
    textFont(loadFont("BerlinSansFB-Reg-100.vlw")); 
    text("Generation " + number, 10, 90); 
} 

void drawLoop(boolean check) { 
    loadPixels(); 
    if (check) {//checks which array to iterate thrgough 

    for (int x = 0; x < windowW; x++) {//iterates through the array 
     for (int y = 0; y < windowH; y++) { 
     if (cells0[x][y]) {//checks wether the pixel is alive or dead 
      pixels[x * 700 + y] = alive;//gets the current pixel 
      int lives = lives(x, y, check);//checks how many cells are alive around the current cell 

      if (lives<2) {//these are supposed to put in place the game of life rules 
      cells1[x][y] = false; 
      } else if (lives>4) { 
      cells1[x][y] = false; 
      } else { 
      cells1[x][y] = true; 
      } 
     } else { 
      pixels[x * 700 + y] = dead;//gets the current pixel 
      int lives = lives(x, y, check);//checks how many cells are alive around the current cell 
      if (lives == 3) {//turns the pixel alive if the condition is met 
      cells1[x][y] = true; 
      } 
     } 
     } 
    } 
    } else {//the same as the top but instead the arrays being updated and read are switched 

    for (int x = 0; x < windowW; x++) { 
     for (int y = 0; y < windowH; y++) { 
     if (cells1[x][y]) { 
      pixels[x * 700 + y] = alive; 
      int lives = lives(x, y, check); 
      if (lives<2) { 
      cells0[x][y] = false; 
      } else if (lives>4) { 
      cells0[x][y] = false; 
      } else { 
      cells0[x][y] = true; 
      } 
     } else { 
      pixels[x * 700 + y] = dead; 
      int lives = lives(x, y, check); 
      if (lives == 3) { 
      cells0[x][y] = true; 
      } 
     } 
     } 
    } 
    } 
    updatePixels(); 
} 

int lives(int x, int y, boolean check) {//this just checks how many live pixels are around a given pixel 
    int lives = 0; 
    if (x > 1 && y >1 && x < 699 && y < 699) { 
    if (check) { 
     if (cells0[x-1][y-1]) 
     lives++; 
     if (cells0[x][y-1]) 
     lives++; 
     if (cells0[x+1][y-1]) 
     lives++; 
     if (cells0[x-1][y]) 
     lives++; 
     if (cells0[x+1][y]) 
     lives++; 
     if (cells0[x-1][y+1]) 
     lives++; 
     if (cells0[x][y+1]) 
     lives++; 
     if (cells0[x+1][y+1]) 
     lives++; 
    } else { 
     if (cells1[x-1][y-1]) 
     lives++; 
     if (cells1[x][y-1]) 
     lives++; 
     if (cells1[x+1][y-1]) 
     lives++; 
     if (cells1[x-1][y]) 
     lives++; 
     if (cells1[x+1][y]) 
     lives++; 
     if (cells1[x-1][y+1]) 
     lives++; 
     if (cells1[x][y+1]) 
     lives++; 
     if (cells1[x+1][y+1]) 
     lives++; 
    } 
    } 
    return lives; 
} 

Answer 1

Veuillez poster votre code en tant que MCVE. Lorsque j'essaie d'exécuter votre code, j'obtiens une erreur parce que je n'ai pas le fichier de police que vous essayez de charger à la ligne 59. Cette police n'a rien à voir avec votre problème, vous devriez donc vous en débarrasser poster une question

Vous avez beaucoup de choses dans ce code. Je comprends pourquoi vous avez deux tableaux, mais les avoir tous les deux au niveau de l'esquisse ne fait que compliquer votre code. Vous ne devriez pas avoir besoin de changer constamment entre les tableaux comme ça. Au lieu de cela, j'organiserais votre code comme ceci:

• Vous ne devriez avoir qu'un seul tableau au niveau de l'esquisse. Vous pouvez également vous débarrasser de la variable zeroOrOne.
• Initialisez ce tableau comme vous le souhaitez. Créez un nextGeneration() qui renvoie un nouveau tableau basé sur le tableau actuel. Cela appellera probablement d'autres fonctions pour compter les voisins et autres joyeusetés. Mais le fait est que vous pouvez simplement créer un nouveau tableau à chaque fois au lieu de basculer entre deux tableaux globaux.
• Cela supprime toute votre logique dupliquée.

Remarques générales:

• Avoir 8 if déclarations pour vérifier les voisins est un peu exagéré. Pourquoi ne pas simplement utiliser une boucle imbriquée for?
• Vous devriez prendre l'habitude de suivre les conventions de nommage appropriées. Les fonctions devraient commencer par une lettre minuscule, et les variables devraient être descriptives - nommer quelque chose check ne dit rien au lecteur.

Si vous n'arrivez toujours pas à le faire fonctionner, alors vous allez devoir faire du débogage. Ajoutez des instructions print() ou utilisez le débogueur de l'éditeur de traitement pour parcourir le code. Quelle ligne se comporte différemment de ce que vous attendez? Ensuite, vous pouvez poster un MCVE de cette ligne (et toutes les variables codées en dur dont il a besoin pour montrer le comportement) et nous allons partir de là. Bonne chance.

Answer 2

Les problèmes que vous rencontrez sont de deux ordres:

1. Les deux tableaux de cellules que vous avez et faire deux interférer jeux séparés, quand vous voulez qu'un seul.

2. Vous mettez à jour les cellules de vos baies avant d'avoir terminé la vérification de celles qui doivent être modifiées.

La façon de résoudre les deux problèmes à la fois est de réutiliser le réseau cells1. Au lieu de le vérifier toutes les deux fois, faites-en un tableau entièrement faux.Ensuite, chaque fois que vous voulez modifier un carré dans cells0, définissez cet emplacement dans cells1 sur true, et après avoir créé un marqueur de chaque cellule que vous voulez changer, changez-les tous en même temps avec une boucle for distincte à la fin du drawLoop() méthode. Cela résout les deux problèmes d'un seul coup. Une fois que vous avez fait cela, vous pouvez supprimer les variables check et zeroAndOne, car vous n'en aurez plus besoin. Voilà ce que je suis arrivé pour la méthode drawLoop() après avoir fait les modifications que je recommande:

void drawLoop() { 
    loadPixels(); 
    for (int x = 0; x < windowW; x++) { 
    for (int y = 0; y < windowH; y++) { 
     if (cells0[x][y]) { 
     pixels[x * 700 + y] = alive; 
     int lives = lives(x, y); 
     if (lives<2) { 
      cells1[x][y] = true; 
     } else if (lives>4) { 
      cells1[x][y] = true; 
     } 
     } else { 
     pixels[x * 700 + y] = dead; 
     int lives = lives(x, y); 
     if (lives == 3) { 
      cells1[x][y] = true; 
     } 
     } 
    } 
    } 
    for (int x = 0; x < windowW; x++) { 
    for (int y = 0; y < windowH; y++) { 
     if (cells1[x][y]) { 
     cells0[x][y] = !cells0[x][y]; 
     cells1[x][y] = false; 
     } 
    } 
    } 
    updatePixels(); 
} 

Je suis sûr que vous pouvez trouver le reste. Bonne chance!