# Tennis- Spielstand- Zähler für Schule programmieren



## primavelle (3. Mrz 2018)

Hallo zusammen,

Ich muss für die Schule eine Art Anzeigetafel für ein Tennismatch programmieren. Der User kickt entweder auf den Button Spieler 1 oder Spieler 2 (je nach dem wer der Punkt gemacht hat) und dann soll sich der Spielstand verändern.

*Aktueller Stand:* Ich habe eine GUI mit den Buttons und den relevanten Textfeldern erstellt.
D.h: btnSpieler1, btnSpieler2, txtPunkte1, txtPunkte2

*Hauptfrage: * 
- Durch lange Recherche weiß ich mittlerweile, dass ich einen klick- Zähler benötige, also wie oft auf welchen Button geklickt wurde. Allerdings bin ich völlig ahnungslos wie... 

*Nebenfrage: *Nun zählt man beim Tennis ja nicht 1,2,3,... sondern 15, 30, 40, Spiel.
- Ist das eine gute Idee, dieses "Problem" mit if- else zu lösen? 
Also z.B: 
if ("Anzahl klick auf Button1" = 1)
txtPunkte1.setText("15");
else if ...

Schonmal vielen Dank im Voraus
und liebe Grüße
Linda


----------



## Robat (3. Mrz 2018)

Hauptfrage:
- Instanzvariable anlegen (für beide Spieler) die jeweils bei Buttonklick hochgezählt wird.

Nebenfrage:
Ich würde 15,30,40,Spiel in eine Map packen wo 1,2,3,4 jeweils der Key ist. Dann kannst du über den Counter (aus deiner Hauptfrage) jeweils den Text holen der ausgegeben  werden soll.


----------



## Xyz1 (3. Mrz 2018)

primavelle hat gesagt.:


> - Ist das eine gute Idee, dieses "Problem" mit if- else zu lösen?


Nein, du solltest 15, 30, 40, usw. speichern, und einen gespeicherten Wert nicht immer umrechnen, und einen switch auf den gespeicherten Wert legen.



Robat hat gesagt.:


> Instanzvariable anlegen


Nein, nich zwei Instanzen



Robat hat gesagt.:


> in eine Map


Nein


----------



## Robat (3. Mrz 2018)

DerWissende hat gesagt.:


> Nein, nich zwei Instanzen


Jetzt zeig du mir mal die Stelle wo ich gesagt habe er soll 2 Instanzen anlegen 



DerWissende hat gesagt.:


> Nein


Kannst du das auch irgendwie begründen?


----------



## Xyz1 (3. Mrz 2018)

Robat hat gesagt.:


> irgendwie begründen


muss ich das? Ich denke Teile meiner Antwort würdn Dich nur beunruhigen.


----------



## Robat (3. Mrz 2018)

Mach dir mal keine Sorgen um mich 
Auf die Begründung bin ich mal gespannt


----------



## eno_x3 (14. Mrz 2018)

Da ich selbst Tennis spiele und programmieren üben will, habe ich mich daran mal versucht. Es war zwar etwas komplizierter als erwartet, aber es ging.


```
package zaehlen;

import javafx.beans.property.BooleanProperty;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;

public class TennisCount {
    public StringProperty scoreboardProperty = new SimpleStringProperty("");
    public StringProperty playersProperty = new SimpleStringProperty("");
    public StringProperty scoreProperty = new SimpleStringProperty("");
    public StringProperty serviceProperty = new SimpleStringProperty("");
    public BooleanProperty finishedProperty = new SimpleBooleanProperty(false);
    public Spieler winner;
    protected int aktuellerSatz = 0;
    protected boolean bestOf5;
    protected String spielName;
    boolean matchTieBreak;
    private boolean finished = false;
    Spieler spieler1 = Spieler.SPIELER1;
    Spieler spieler2 = Spieler.SPIELER2;
    Spieler server;
  
    protected enum Punkte{    P0("0"),P15("15"),P30("30"),P40("40"), PAD("AD");
                            String wert;
                            Punkte(String wert){
                            this.wert = wert;
                            }
    }
    protected enum Spieler{     SPIELER1 , SPIELER2;
                    String name;
                    protected int[] punkteSatz = {0,0,0,0,0};
                    Punkte punkteSpiel = Punkte.P0;
                    Spieler getOpponent() {
                        if( this.equals(SPIELER1)) {
                            return SPIELER2;
                        }
                        else if (this.equals(SPIELER2)) {
                            return SPIELER1;
                        }
                        else {
                            throw new IllegalArgumentException("Ungültiger Spieler");
                        }
                    }
                    }
    TennisCount(String spielName, String spieler1, String spieler2, boolean bestOf5, Spieler server){
        setSpielName(spielName);
        if (spieler1 != null && spieler2 != null) {
            Spieler.SPIELER1.name = spieler1;
            Spieler.SPIELER2.name = spieler2;
        }
        this.server = server;
        this.bestOf5 = bestOf5;

        scoreboardProperty.set(this.toString());
    }
    public boolean isFinished() {
        return finished;
    }
    public int getAktuellerSatz() {
        return aktuellerSatz;
    }
    public void setAktuellerSatz(int aktuellerSatz) {
        this.aktuellerSatz = aktuellerSatz;
    }
    public String getSpielName() {
        return spielName;
    }
    public void setSpielName(String spielName) {
        this.spielName = spielName;
    }
    public boolean isMatchTieBreak() {
        return matchTieBreak;
    }
    public void setMatchTieBreak(boolean matchTieBreak) {
        this.matchTieBreak = matchTieBreak;
    }
    public void setPunkte(Spieler spieler, Punkte p) {
        if (!finished) {
            spieler.punkteSpiel = p;
        }
    }
    public void addPunkt(Spieler spieler) {
        if (finished) {
            return;
        }
        if (isGame(spieler)) {
            addSpiel(spieler);
        }
        else {
            switch(spieler.punkteSpiel) {
            case P0:     setPunkte(spieler, Punkte.P15); break;
            case P15:     setPunkte(spieler, Punkte.P30); break;
            case P30:     setPunkte(spieler, Punkte.P40); break;
            case P40:     setPunkte(spieler, Punkte.PAD); if (spieler.getOpponent().punkteSpiel.equals(Punkte.PAD)){
                                                            setPunkte(spieler.getOpponent(),Punkte.P40);
                                                        }
                                                        break;
            default: throw new IllegalArgumentException("Ungültiger Spielstand");
            }
        }
        scoreboardProperty.set(this.toString());
    }
    protected void addSpiel(Spieler spieler) {
        server = server.getOpponent();
        if(isSet(spieler)) {
            if (isMatch(spieler)) {
                spieler.punkteSatz[aktuellerSatz] += 1;
                finished = true;
                winner = spieler;
                finishedProperty.set(finished);
            }
            else {
                spieler.punkteSatz[aktuellerSatz] += 1;
                newSet();
            }
            spieler.punkteSpiel = Punkte.P0;
            spieler.getOpponent().punkteSpiel = Punkte.P0;
        }
        else {
            spieler.punkteSatz[aktuellerSatz] += 1;
            setPunkte(spieler1, Punkte.P0);
            setPunkte(spieler2, Punkte.P0);
        }
    }
  
    private void newSet() {
        aktuellerSatz += 1;  
    }

    protected boolean isGame(Spieler spieler) {
        if ((spieler.punkteSpiel.equals(Punkte.PAD)) || ((spieler.punkteSpiel.equals(Punkte.P40))&& !(spieler.getOpponent().punkteSpiel.equals(Punkte.PAD)||spieler.getOpponent().punkteSpiel.equals(Punkte.P40)))){
            return true;
        }
        return false;
    }
    protected boolean isSet(Spieler spieler) {
        if((spieler.punkteSatz[aktuellerSatz] == 6) || (spieler.punkteSatz[aktuellerSatz] == 5 && !((spieler.getOpponent().punkteSatz[aktuellerSatz] == 5) || spieler.getOpponent().punkteSatz[aktuellerSatz] == 6))){
            return true;
        }
        return false;
    }
    protected boolean isMatch(Spieler spieler) {
        if (bestOf5) {
            //TODO
        }
        else {
            if ((aktuellerSatz == 2) || (aktuellerSatz == 1 && getWinnerSet(0).equals(getWinnerSet(1)))) {
                return true;
            }
        }
        return false;
    }
    private Spieler getWinnerSet(int set) {
        if(Spieler.SPIELER1.punkteSatz[set] > Spieler.SPIELER2.punkteSatz[set]) {
            return Spieler.SPIELER1;
        }
        else if(Spieler.SPIELER1.punkteSatz[set] < Spieler.SPIELER2.punkteSatz[set]) {
            return Spieler.SPIELER2;
        }
        else {
            throw new IllegalArgumentException("Es gibt noch keinen Gewinner in diesem Satz.");
        }
    }
    @Override
    public String toString() {
        String s1 = " ",s2 = " ";
        if (server.equals(Spieler.SPIELER1)) {
            s1 = "\u2022";
        }
        else {
            s2 = "\u2022";
        }
        String result = String.format("%s\n%-12s %s%5d %d %d\t\t%s\n", spielName,    Spieler.SPIELER1.name, s1, Spieler.SPIELER1.punkteSatz[0],Spieler.SPIELER1.punkteSatz[1],Spieler.SPIELER1.punkteSatz[2],Spieler.SPIELER1.punkteSpiel.wert);
        result +=         String.format("%-12s %s%5d %d %d\t\t%s\n",                     Spieler.SPIELER2.name, s2, Spieler.SPIELER2.punkteSatz[0],Spieler.SPIELER2.punkteSatz[1],Spieler.SPIELER2.punkteSatz[2],Spieler.SPIELER2.punkteSpiel.wert);
        System.out.println(result);
        playersProperty.set(String.format("%s\n%s", Spieler.SPIELER1.name,Spieler.SPIELER2.name));
        serviceProperty.set(String.format("%s\n%s", s1,s2));
        scoreProperty.set(String.format("%d %d %d   %s\n%d %d %d   %s\n", Spieler.SPIELER1.punkteSatz[0],Spieler.SPIELER1.punkteSatz[1],Spieler.SPIELER1.punkteSatz[2],Spieler.SPIELER1.punkteSpiel.wert,Spieler.SPIELER2.punkteSatz[0],Spieler.SPIELER2.punkteSatz[1],Spieler.SPIELER2.punkteSatz[2],Spieler.SPIELER2.punkteSpiel.wert));
        return result;
    }

}
```

Da ich Java und das Programmieren erst lerne, freue ich mich über sämtliche Kritik und Verbesserungen.

Gruß enox


----------

