Wie überprüft man, ob eine Tastenfolge gedrückt wird?

Question

Ich möchte überprüfen, ob eine Tastenfolge gedrückt wird. Wie ein Passwort, ich möchte, dass das Meldungsfeld Sie müssen "bcqwl" in richtigen sequenze eingeben. Ich versuchte

#include <iostream> 

#include <windows.h> 

using namespace std; 

int main() 
{ 
    while(true) 
    { 
     if(GetKeyState('B') & 0x8000) 
     { 
      cout<<"b has been press"<<endl; 
       if(GetKeyState('C') & 0x8000) 
       { 
        cout<<"c has been press"<<endl; 
        if(GetKeyState('Q') & 0x8000) 
        { 
         cout<<"Q has been press"<<endl; 
         if(GetKeyState('W') & 0x8000) 
         { 
          cout<<"W has been press"<<endl; 
          if(GetKeyState('L') & 0x8000) 
          { 
           MessageBox(NULL,"YES","YES",MB_OK); 
          } 
          else 
          { 
           continue; 
          } 
         } 
         else 
         { 
          continue; 
         } 
        } 
        else 
        { 
         continue; 
        } 
       } 
       else 
       { 
        continue; 
       } 
     } 
     else 
     { 
      continue; 
     } 
    } 
} 

Aber es funktioniert nicht. Er druckt "B wurde gedrückt", oft aber nicht unendlich oft, wenn b gedrückt wird. Wenn nach dem Drücken von b drücke ich c nichts passiert. So ich müde:

step: 
     if(GetKeyState('B') & 0x8000) 
     { 
      cout<<"B has been press"<<endl; 
      goto step1; 
     } 
     else 
     { 
      goto step; 
     } 
     step1: 
     if(GetKeyState('C') & 0x8000) 
     { 
       MessageBox(NULL,"WORK","yes",MB_OK); 
     } 
     else 
     { 
      goto step; 
     } 

aber nicht funktioniert. ich auch müde:

#include <iostream> 

#include <windows.h> 

int main() 
{ 
int progress = 0; 
    while(progress<=4) 
    { 
     if(GetKeyState('B') & 0x8000) 
     { 
      std::cout<<"b has been press"<<std::endl; 
      progress=1; 
     } 
     else 
     { 
      progress=0; 
     } 
     if(progress==1) 
     { 
      if(GetKeyState('C') & 0x8000) 
      { 
       std::cout<<"c has been press"<<std::endl; 
       progress=2; 
      } 
      else 
      { 
       progress=0; 
      } 
     } 
     if(progress==2) 
     { 
      if(GetKeyState('Q') & 0x8000) 
      { 
       std::cout<<"q has been press"<<std::endl; 
       progress=3; 
      } 
      else 
      { 
       progress=0; 
      } 
     } 
     if(progress==3) 
     { 
      if(GetKeyState('W') & 0x8000) 
      { 
       std::cout<<"w has been press"<<std::endl; 
       progress=4; 
      } 
      else 
      { 
       progress=0; 
      } 
     } 
     if(progress==4) 
     { 
      if(GetKeyState('L') & 0x8000) 
      { 
       std::cout<<"l has been press"<<std::endl; 
       progress=5; 
      } 
      else 
      { 
       progress=0; 
      } 
     } 

} 
return 0; 
} 

Aber das Ausgangs für viele Male „b hat Presse gewesen“, aber nicht unendlich, wenn ich drücken b und nach, wenn ich drücken c nichts geschieht, praticaly nach drücken b und das Programm gehen in if(process==1), aber wenn ich drücke c nichts passiert

PS Entschuldigung für mein schlechtes Englisch.

Answer 1

Das Problem, das Sie immer noch haben, kommt von der Tatsache, dass Sie in keiner Weise den Fortschritt in Ihrer Tastenfolge speichern.

Angenommen, Ihr Passwort in einem char Array gespeichert ist (für einen leichteren Zugang zu den einzelnen Zeichen später):

#define PWD_LEN 6 // bcqwl has a length of 5 characters but you need +1 for the '\0' (terminating character) at the end of your string 
// ... 
char password[PWD_LEN] = "bcqwl"; 

Zusätzlich benötigen Sie einen Zähler:

#define PWD_LEN 5 
// ... 
char password[PWD_LEN] = "bcqwl"; 
int progress = 0; 

while(true) { ... } 

Beide brauchen vor und außerhalb der Schleife while gespeichert werden, da beide Daten speichern, die nicht in jedem Iterationsschritt in der Schleife zurückgesetzt werden sollen.

Der Zähler wird verwendet, um den Fortschritt des Benutzers in Richtung auf die Schlüsselsequenz zu verfolgen, die Ihr Kennwort darstellt.

Jedes Mal, wenn der Benutzer eine Taste drückt, müssen Sie die folgenden Prüfungen tun:

• ist der Schlüssel erlaubt? - Wenn Sie ein Passwort haben abc aber der Benutzer drückt y oder !, oder etwas anderes als a, b oder c der Schlüssel ist nicht erlaubt.

• Wenn der Schlüssel darf nehmen den Charakter es darstellt und überprüfen, ob es das gleiche wie die Zeichen in Ihrem password bei Index ist progress:

  if (key allowed) 
  { 
      if (password[progress] == '<your key character here>') 
      { 
      ++progress; 
      } 
      else 
      { 
      // Handle incorrect key stroke relative to key sequence 
      } 
  } 
  

Um nun die Zähler gehen Bananen zu verhindern I würde vorschlagen, die Überprüfung auf Schlüssel freigegeben, die im Gegensatz zu Taste gedrückt ist ein einmaliges Ereignis. Eine Taste, die gedrückt wird, kann auch Teil von Schlüssel halten sein, in diesem Fall landen Sie in der else (aus dem Codeausschnitt oben) viele Male, die nicht so eine gute Idee sein könnte.

Wenn der Schlüssel in Ordnung ist und der Reihenfolge nach Ihr Passwort passt, dann erhöhen Sie den Fortschritt, so dass Sie im nächsten Iterationsschritt die gleiche Überprüfung mit einem neuen freigegebenen Schlüsselereignis und einem neuen Indexwert für Ihren Zugriff durchführen können Passwort-Array.

Wenn Ihr progress den erforderlichen Wert erreicht, der anzeigt, dass die Tastenfolge abgeschlossen ist und alle Zeichen, aus denen Ihr Passwort besteht, "eingefügt" wurden, können Sie die Schleife unterbrechen.

Dies ist sehr einfach, so hoffe ich, dass die Anweisungen klar genug für Sie zu implementieren sind.

---

vorherige Antwort (jetzt veraltet aufgrund der Frage zu ändern)

Sofern keine andere Out-of-the-Box-Art und Weise zur Verfügung, das zu tun (ich habe nicht verwendet GetKeyState() oder irgendetwas anderes von windows.h) ist die allgemeine Praxis, einfach den pressed Zustand jedes Knopfes zu speichern (in einem Array, einem struct etc.).

In Ihrer Schleife können Sie eine einfache Kette von if Anweisungen verwenden (aber nicht verschachtelt, wie Sie es tun!), Um zu prüfen, welche Taste während des aktuellen Iterationsschritts gedrückt wird. Jedes Mal, wenn ein bekannter Schlüssel (eine, die Sie Anwendung verarbeiten will) gedrückt wird, müssen Sie nur den jeweiligen Zustand dieser Taste im Array wechseln, struct oder was auch immer andere Behälter Sie diese Informationen zu speichern, verwenden:

while(true) 
{ 
    // Check state of supported buttons 
    if(GetKeyState('A') & 0x8000) 
    { 
    // store change of state of key A 
    } 
    if(GetKeyState('B') & 0x8000) 
    { 
    // store change of state of key B 
    } 
    if (...) 
    { 
    // ... 
    } 
} 

am Ende oder Anfang Ihrer while ‚s Körper können Sie dann für den Zustand jeder Taste stellen und auch kombinierte Abfragen machen:

while(true) 
{ 
    // Check state of supported buttons 
    if(GetKeyState('A') & 0x8000) 
    { 
    // store change of state of key A 
    } 
    if(GetKeyState('B') & 0x8000) 
    { 
    // store change of state of key B 
    } 
    if (...) 
    { 
    // ... 
    } 


    // Do something 


    // Check for states of buttons 
    // ... 
} 

zum Beispiel lassen Sie uns sagen, dass Sie die folgende Struktur verwenden den Schlüssel des Staates zu speichern:

wenn Ihre bestimmte Schaltfläche

typedef struct Key 
{ 
    char keyCode; 
    bool pressed; 
} Key; 

Key keyA; 
keyA.pressed = false; 

können Sie einfach

if (keyA.pressed) 
{ 
    // Trigger some change that key 'A' controls 
} 

tun, um zu prüfen zur Zeit gedrückt wird, und jeweils eine Aktion auslösen.

Für Tastenkombinationen sind die Dinge nicht viel anders. Sie müssen nur einfach Boolesche Logik verwenden, um es zu handhaben:

if (keyA.pressed && keyB.pressed) 
{ 
    // Both key 'A' and 'B' are pressed - we have a key combo! 
} 

Sie können die Lesbarkeit des Codes verbessern, indem alle unterstützten Tasten in einem Array zu speichern und sogar ein schöne enum Hinzufügen einfachen Zugang zu jeder Taste bieten:

enum KeyCode 
{ 
    A, 
    B, 
    ... 
}; 

Key keys[n]; //with n being the number of keys you want to support and also the number of elements your enum has 

// Access with an improved readability 
if (keys[A].pressed && keys[B].pressed) 
{ 
    // ... 
} 

Wenn Sie keinen Code für GetKeyState() insbesondere finden (sehr unwahrscheinlich) Sie bei SDL zum Beispiel aussehen kann.