Traitement, exécution si déclaration deux fois au lieu d'une fois

Question

Je fais un jeu vraiment simple, mais je suis coincé avec un problème étrange; Je veux que le zombie frappe le personnage quand il le peut mais il me frappe deux fois au lieu d'une fois.

void zombieAttack(float distance){ 
if(zombieCanAttack && (distance < charSizeX/2+zombieSize/2)){ 
    charApplyDamage(5); 
    zombieAttackCounter_obj.counter(0); 
    zombieAttackCounter = 0; 
    println("second " + zombieCanAttack); 
    zombieCanAttack = false; 
} 

}

J'ai même supprimé le code qui rend zombieCanAttack vrai lorsque la minuterie le dit, donc il n'y a rien qui fait zombieCanAttack vrai, mais même si le programme me donne cette sortie deux fois: « seconde vrai ". Cela provoque zombie à frapper le personnage deux fois au lieu d'une fois. Pourquoi entre-t-il deux fois une instruction?

Edit: Voici la classe complète zombie:

class Zombie { 
    float zombieX, zombieY, zombieSizeX, zombieSizeY, zombieSize, zombieHp, zombieDamage, 
    zombieSpeed, zombieThresholdX, zombieThresholdY, zombieAttackCounter; 
    boolean zombieFlip, zombieCanAttack = true; 
    Counter zombieAttackCounter_obj = new Counter(); 

    void instantiateZombie(float x, float y, float sizeX, float sizeY, float hp, 
    float damage, float speed, int thresholdX, int thresholdY){ 
    zombieX = x; 
    zombieY = y; 
    zombieSizeX = sizeX; 
    zombieSizeY = sizeY; 
    zombieSize = (sizeX+sizeY)/4; 
    zombieHp = hp; 
    zombieDamage = damage; 
    zombieSpeed = speed; 
    zombieThresholdX = thresholdX; 
    zombieThresholdY = thresholdY; 
    } 
    void zombieAI(){ 
    zombieAttackCounter = zombieAttackCounter_obj.counter(-1); 
    noStroke(); 
    fill(255, 0, 0); 
    rect(zombieX, zombieY, zombieSizeX, zombieSizeY); 
    float distance = dist(charX, charY, zombieX, zombieY); 
    if(distance+zombieSizeX/2 > charSizeX/2+zombieSizeX/2){ 
     zombieWalk(); 
    } else { 
     zombieAttack(distance); 
    } 
    //println("first " + zombieCanAttack); 
    if(zombieAttackCounter > 1.5){ /*zombieCanAttack = true; */} 
    } 
    void zombieWalk(){ 
    if(zombieX-charX < zombieThresholdX && zombieX-charX > -zombieThresholdX){ } 
    else if(zombieX-charX < 0){ 
     zombieX+=zombieSpeed; zombieFlip = true; 
    } 
    else{ 
     zombieX-=zombieSpeed; zombieFlip = false; 
    } 
    if(zombieY-charY < zombieThresholdY && zombieY-charY > -zombieThresholdY){ } 
    else if(zombieY-charY < 0){ 
     zombieY+=zombieSpeed; 
    } 
    else{ 
     zombieY-=zombieSpeed; 
    } 
    } 
    void zombieAttack(float distance){ 
    if((zombieCanAttack) && (distance < charSizeX/2+zombieSize/2)){ 
     charApplyDamage(5); 
     zombieAttackCounter_obj.counter(0); 
     zombieAttackCounter = 0; 
     println("second " + zombieCanAttack); 
     zombieCanAttack = false; 
    } 
    } 
} 

est complet ici .pde dans tous les cas: http://paste.ubuntu.com/7824949/

Answer 1

@HotLicks bon point ... il y a deux zombies à cause de l'utilisation de cette déclaration à ajouter un zombie

for(int i = 0; i < zombieNumber+1; i++){ 
    zombieHolder.add(new Zombie()); 
} 

où la valeur de zombieNumber est 1 et selon la mise en œuvre de Zombie c Lass ils sont avec les mêmes paramètres (pourquoi les instanciez-vous comme ceci?) et se déplacent comme un afin qu'ils vous frappent deux fois ... essayez d'augmenter le zombieNumber pour voir si ce problème est vraiment là.