Ma logique de programmation est-elle correcte ici?

Question

const char IsPressed = 1; // 1 
const char WasHeldDown = 2; // 10 
const char IsFirstPress = 4; // 100 

char* keystates[256]; 

Class::CalculateKeyStates() 
{ 
    for(int i = 0; i < 256; ++i) 
    { 
     if(this->IsDown(i)) 
     { 
      keystates[i] |= IsPressed; // turn on 
      if(keystates[i] & WasHeldDown) 
      { 
       //keystates[i] |= IsFirstPress; 
       keystates[i] &= ~IsFirstPress; // turn off 
      } 
      else 
      { 
       keystates[i] |= WasHeldDown + IsFirstPress; // Turn on 
      } 
     } 
     else 
     { 
      keystates[i] = 0; // Turn ALL off 
     } 
    } 
} 

Cette fonction serait une fonction membre d'une classe, classe. L'autre fonction membre, IsDown, renvoie une valeur true si la clé en question est en panne et false si elle ne l'est pas.

Pouvez-vous envisager une amélioration supplémentaire de cette fonction?

Merci

EDIT:

Je vais développer un peu à ce qui se fait pourquoi. C'est une modification d'un bit de code qui fonctionne à travers un tableau keyStates (qui était une structure de trois booléens) en définissant IsPressed sur false pour toutes les clés. puis, à nouveau, la valeur Ispressed est attribuée à la valeur de this-> IsDown, puis une troisième fois en vérifiant si la clé a été maintenue, si elle n'a plus la première pression, définissez-la sur false. si elle n'était pas maintenue enfoncée, appuyez d'abord sur pour confirmer et elle était également vraie, donc la prochaine fois, elle est signalée comme ayant été tenue.

EDIT2:

a ajouté quelques commentaires à code et corriger une ligne

Answer 1

Personnellement, je définirais les principaux états comme des états disjoints et écrire un simple machine d'état, ainsi:

enum keystate 
{ 
    inactive, 
    firstPress, 
    active 
}; 

keystate keystates[256]; 

Class::CalculateKeyStates() 
{ 
    for (int i = 0; i < 256; ++i) 
    { 
     keystate &k = keystates[i]; 

     switch (k) 
     { 
     inactive: 
      k = (isDown(i)) ? firstPress : inactive; 
      break; 
     firstPress: 
      k = (isDown(i)) ? active : inactive; 
      break; 
     active: 
      k = (isDown(i)) ? active : inactive; 
      break; 
     } 
    } 
} 

Il est plus facile d'étendre, et plus facile à lire si elle devient plus complexe.

Answer 2

Vous définissez toujours IsFirstPress si la clé est en baisse, ce qui pourrait ne pas être ce que vous voulez.

Answer 3

Je ne suis pas sûr de ce que vous voulez atteindre avec IsFirstPress, car le keystate ne peut pas se souvenir des presses précédentes de toute façon. Si vous voulez marquer avec ce bit, que c'est la première fois que vous reconnaissez la clé en panne, alors votre logique est fausse dans l'instruction if correspondante.

keystates[i] & WasHeldDown est évalué à true si vous avez déjà défini le bit WasHeldDown précédemment pour ce keystate. Dans ce cas, ce que vous voulez faire est en fait de supprimer le bit IsFirstPress par xor-it: keystates[i] ^= IsFirstPress