Traitement: collisions avec des traînées

Question

Le traitement des collisions dans le traitement est simple. Cependant, comment puis-je identifier les collisions avec les sentiers? Exemple: imaginez les cycles de lumière dans Tron, si vous le souhaitez, avec l'altération que les traînées de cycles de lumière décomposés ne disparaissent pas. Dans Tron, si un cycle intersecte un point, un autre cycle, lui-même inclus, a déjà été, il «meurt». Comment trouver efficacement cet événement dans Processing?

Answer 1

Une solution de contournement est de dessiner la ligne dans un PImage et de vérifier si la couleur à un emplacement est la même que l'arrière-plan ou non (par exemple une ligne préexistante, donc une collision).

est ici une preuve de concept rugueux (et un peu inefficace (en raison de get()/set() appels):

PImage buffer; 

//how mutch we scale down = how pixely this will look 
int multiplier = 8; 
//scaled down width/height 
int w,h; 
//cursor position 
int px,py; 
//cursor velocity; 
int vx,vy; 


void setup(){ 
    size(400,400); 
    noSmooth(); 

    w = width/multiplier; 
    h = height/multiplier; 

    buffer = createImage(w,h,RGB); 
    clear(); 
} 
void clear(){ 
    java.util.Arrays.fill(buffer.pixels,color(0)); 
    buffer.updatePixels(); 
} 
void draw(){ 
    //update cursor 
    px += vx; 
    py += vy; 
    //check edges 
    if(px < 0){ 
    px = w-1; 
    } 
    if(px > w){ 
    px = 0; 
    } 
    if(py < 0){ 
    py = h-1; 
    } 
    if(py > h){ 
    py = 0; 
    } 
    //check collision 
    if(keyPressed){ 
    if(keyCode == UP || keyCode == DOWN || keyCode == LEFT || keyCode == RIGHT){ 
     checkSelfIntersection(); 
    } 
    } 
    //paint cursor 
    buffer.set(px,py,color(0,192,0)); 

    //render on screen 
    image(buffer,0,0,width,height); 
} 
void checkSelfIntersection(){ 
    //if the pixel ahead is not the same colour as the background 
    if(buffer.get(px+vx,py+vy) > color(0)){ 
    clear(); 
    println("Cycle go BOOM!"); 
    } 
} 
void keyPressed(){ 
    if(keyCode == UP){ 
    vy = -1; 
    } 
    if(keyCode == DOWN){ 
    vy = +1; 
    } 
    if(keyCode == LEFT){ 
    vx = -1; 
    } 
    if(keyCode == RIGHT){ 
    vx = +1; 
    } 
} 
void keyReleased(){ 
    vx = vy = 0; 
} 

Un concept similaire peut être fait soit garder la trace des points dans une liste et vérifier si un nouveau point fait déjà partie de cette liste (collision) ou non:

ArrayList<PVector> path = new ArrayList<PVector>(); 


//cursor position 
int px,py; 
//cursor velocity; 
int vx,vy; 

void setup(){ 
    size(400,400); 
    noFill(); 
    strokeWeight(10); 
} 
void draw(){ 
    //update cursor 
    px += vx; 
    py += vy; 
    //check edges 
    if(px < 0){ 
    px = 0; 
    } 
    if(px > width){ 
    px = width; 
    } 
    if(py < 0){ 
    py = 0; 
    } 
    if(py > height){ 
    py = height; 
    } 
    //check collision 
    if(keyPressed){ 
    if(keyCode == UP || keyCode == DOWN || keyCode == LEFT || keyCode == RIGHT){ 
     checkSelfIntersection(); 
    } 
    } 

    background(255); 
    beginShape(); 
    for(int i = 0 ; i < path.size(); i++){ 
    PVector p = path.get(i); 
    vertex(p.x,p.y); 
    } 
    endShape(); 
} 
void checkSelfIntersection(){ 
    PVector cursor = new PVector(px,py); 
    if(path.contains(cursor)){ 
    path.clear(); 
    println("Cycle go BOOM!"); 
    }else{ 
    path.add(cursor); 
    } 
} 
void keyPressed(){ 
    if(keyCode == UP){ 
    vy = -5; 
    } 
    if(keyCode == DOWN){ 
    vy = +5; 
    } 
    if(keyCode == LEFT){ 
    vx = -5; 
    } 
    if(keyCode == RIGHT){ 
    vx = +5; 
    } 
} 
void keyReleased(){ 
    vx = vy = 0; 
} 

Le concept est pas si différent de la façon dont les jeux comme un serpent/Volfied/etc vérifier auto intersections

..

Note Je triche un peu en mettant à jour un "curseur" sur les touches avec une petite vélocité: ceci évite les écarts dans les lignes. Si vous essayez de remplacer avec la souris, vous remarquerez que la vérification de collision peut échouer si la souris se déplace rapidement car elle vérifie un point par rapport à une liste de points enregistrés. Une alternative pourrait être de diviser la liste de points en paires de lignes et de vérifier si le nouveau point croise l'un d'entre eux.

Vous pouvez également vérifier ceci similar question

Answer 2

Le dépassement de pile n'est pas vraiment conçu pour les questions de type «comment faire cela? C'est pour des questions spécifiques "J'ai essayé X, j'ai attendu Y, mais j'ai obtenu Z à la place". Cela étant dit, je vais essayer d'aider dans un sens général.

Vous pouvez probablement garder une trace des lignes formées par les cycles, sous la forme d'un ArrayList de tous les points où un joueur a tourné. Ensuite, à chaque étape, vous pouvez vérifier si le joueur est en intersection avec l'une de ces lignes. Plus spécifiquement, vous voudriez probablement former une autre ligne entre la coordonnée précédente du joueur et la prochaine coordonnée du joueur. Ensuite, vérifiez si cette ligne croise l'une des autres lignes en utilisant des formules que je suis sûr que vous pouvez trouver à travers une recherche google ou deux.

Vous n'avez probablement pas à faire quoi que ce soit de plus intelligent à moins que vous ne parliez de très grands champs de jeu (comme, en millions de lignes). Il est donc un peu tôt pour poser des questions sur l'efficacité.

Il existe bien sûr de nombreuses autres façons d'aborder le problème. Vous pouvez également utiliser un tableau 2D qui garde une trace des traces, ou vous pouvez utiliser une collision basée sur les pixels, ou probablement un certain nombre d'autres solutions. Le point est que vous devez essayer quelque chose et poster un MCVE avec une question spécifique si vous êtes coincé, et nous irons à partir de là. Bonne chance.