Du skal designe og programmere en digital udgave af spillet Hangman i Processing. Spillet skal vælge et ord, som spilleren skal gætte, ét bogstav ad gangen. For hver forkerte gæt skal en del af galgen/figuren tegnes, indtil spillet er vundet eller tabt.

Formålet med opgaven er, at du skal bruge arrays til at holde styr på data (bogstaver, gæt osv.), og strukturerer din kode i funktioner/metoder, så programmet bliver overskueligt og fleksibelt.

Efter denne opgave skal du kunne:

• Brug af arrays
  • Gemme og arbejde med flere værdier i et array (f.eks. bogstaver i ordet og forkerte gæt).
• Planlægning og datastrukturering
  • Udvikle en strategi for, hvordan data (ord, gæt, visning) skal organiseres.
• Metoder i Processing
  • Dele koden op i funktioner/metoder, der har tydelige ansvarsområder (f.eks. tegne hangman, vise ordet, håndtere input).
• Grafisk programmering
  • Bruge Processing til at vise spillets status og feedback til spilleren.

Programmet skal indeholde et ord, der skal gættes.

• Du kan selv vælge ordet eller gemme flere mulige ord i et array og vælge ét tilfældigt.
• Spilleren skal kunne indtaste et bogstav (f.eks. med `keyPressed()`).
• Programmet skal kunne:
  1. Tjekke, om bogstavet findes i ordet.
  2. Opdatere visningen (vise de korrekte bogstaver og streger for resten).
  3. Gem forkert gæt i et array.
  4. Tegne galgen/hangman alt efter hvor mange fejl spilleren har lavet.
• Spillet skal kunne afgøre, om spilleren har vundet eller tabt.

Tænk over, hvordan du organiserer din kode. Her er nogle idéer og hints – men du skal selv finde din egen løsning:

• Repræsentation af ordet:
  • Brug et `char[]` array eller et `String`, som du konverterer til et array med `toCharArray()`.
  • Brug et andet array (f.eks. et `boolean[]`) til at holde styr på, hvilke bogstaver der er gættet.
• Forkerte gæt:
  • Brug et `char[]` til at gemme forkerte bogstaver. Du kan holde styr på, hvor mange fejl der er lavet, med en tæller-variabel.
• Grafik:
  • Lav en metode, fx `void drawHangman(int fejl)` som tegner galgen og figuren afhængigt af antallet af forkerte gæt.
• Vis ordet:
  • Lav en metode, fx `void drawWord()`, der viser de bogstaver, spilleren har gættet, og understreger de manglende.
• Input:
  • Brug `void keyPressed()` til at registrere, hvilket bogstav brugeren gætter.
• Kontrol af spilstatus:
  • Lav evt. en metode, fx `boolean isWordGuessed()`, som tjekker, om alle bogstaver er gættet.

Hint: Template med metode-struktur

// ===============================
// Hangman - template struktur
// ===============================
 
// Globale variabler
String ord = "processing";
char[] bogstaver;         // bogstaverne i ordet
boolean[] gættet;         // true/false for hvert bogstav
char[] forkerteGæt;       // gem forkerte bogstaver
int fejl = 0;             // antal forkerte gæt
 
void setup() {
  size(600, 400);
  // initialiser arrays her
}
 
void draw() {
  background(255);
  drawWord();        // vis ordet
  drawHangman(fejl); // tegn galgen
  drawWrongGuesses(); // vis forkerte gæt
  checkGameOver();   // tjek om spillet er slut
}
 
void keyPressed() {
  // håndter spillerens bogstavgæt
  // opdater arrays og fejl
}
 
void drawWord() {
  // tegn de gættede bogstaver og understreg de manglende
}
 
void drawHangman(int fejl) {
  // tegn galge + figur afhængigt af fejl
}
 
void drawWrongGuesses() {
  // vis forkerte gæt på skærmen
}
 
void checkGameOver() {
  // tjek om ordet er gættet eller hvis man har tabt
}
 
boolean isWordGuessed() {
  // returner true hvis alle bogstaver i gættet[] er true
  return false;
}

Hint: Konverting mellem String og array

// Et ord som String
String ord = "processing";
 
// Konverter String til et char-array:
char[] bogstaver = ord.toCharArray();
 
// Eksempel: udskriv første bogstav
println(bogstaver[0]);  // viser 'p'
 
// Hvis du vil bygge en String igen ud fra et char-array:
String nyTekst = new String(bogstaver);
println(nyTekst); // viser "processing"

Hvis du bliver hurtigt færdig, kan du udvide spillet med fx:

• En liste af ord, hvor programmet vælger ét tilfældigt.
• Mulighed for at starte en ny runde, når spillet er slut.
• Et simpelt pointsystem.