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

primavelle

Neues Mitglied
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

Top Contributor
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.
 

eno_x3

Mitglied
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.

Java:
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
 

Ähnliche Java Themen

Neue Themen


Oben