Zählsystem für Tennis entwickeln

[torud]

Hallo Wissende,

da ich derzeit ein manuelle Backup für einen Tennis-Counter erstelle, würde vorher gern wissen, wie Ihr an die Sache rangehen würdet. Also zum einen würde mich dabei dabei interessieren, wie man so eine Routine logisch aufbaut.

Für die jenigen unter Euch hier mal die Regeln:

Dabei wäre folgendes zu wissen. Beim Tennis gibt es Punkte, Spiele und Sätze.

Die Punkte gehen von:
0
15
30
40
und wenn es 40 beide steht, bekommt der nächste Punktgewinner einen sogenannten VOrteil = A

Macht er danach wieder einen Punkt hat er das Spiel gewonnen.

Spielpunkte gibt es, wenn ein Spieler in einem Spiel als erster einen Punkt nach dem Erreichen der 40 gemacht hat, wenn es keinen Einstand gab (40 40).

Wer als erster 6 Spiele gewonnen hat, hat den jeweiligen Satz gewonnen. Dies gilt aber auch nur dann, wenn es einen Mindestabstand von 2 Spielpunkten gibt. Also mit 6-5 gewinnt man keinen Satz. 6-1 bis 6-4 ist korrekt. steht es aber z.b. 5-5 und anschliessend 6-5, gehts weiter. Der Satz würde mit 7-5 enden. Steht es 6-6 ginge es in den sogenannten Tiebreak.

Dort fängt das Zählen dann bei 0-0 an und die Punkte gehen hier in Einerschritten voran, bis einer zuerst 7 Punkte hat. Er gewinnt aber den Tiebreak auch nur dann, wenn es wieder mind. 2 Punkte Abstand gibt. Also 7-6 würde nicht gehen. 8-6 wäre der Regel entsprechend. Für den gewonnenen Tiebrakt gibts dann einen Spielpunkt. Damit würde aus dem 6-6 ein 7-6 werden, wobei man sich auch merken muss, wie der Tiebreak ausgegangen ist, da dies in der Regel angezeigt wird.

Bei den Sätzen ist es so, dass es Best of 3 oder Best of 5 gibt. Wer also als erster 2 oder 3 Sätze gewonnen hat, hat das Match gewonnen.

Nun frage ich mich, wie ich dies elegant und übersichtlich programmieren kann, ohne dafür 1000 Zeilen Code schreiben zu müssen und alles mit if...then...else zu erledigen. ich würde mir also eine Klasse dafür schreiben, die das übernimmt. Wer hat eine Idee, wie ich das Zählen erledigen kann?

Ein weiteres Problem, welches sich mir stellt ist, dass ich auch nachträglich in das Zählen einsteigen können muss, da das manuelle Zählen nur ein Backup ist. Normalerweise kommen die Punkte über ein externes System per UDP. Fällt dies aus, müsste man manuell weiterzählen können. Wenn alles reinkommt, wir eigentlich immer alles sofort in die Controls übergeben. Vielleicht sollte man aber lieber alles in Variablen übergeben!?

Ich wäre für Anregungen und Ideen zur Umsetzung dankbar.

[cruiser]

für die Punkte würde ich eine Enumeration nehmen..

  type TPoints = (tp0, tp15, tp30, tp40, tp40A); afaik müssten die sich mit Inc() und Dec() wie jeder ordinale Typ behandeln lassen.

Die Punkte würde ich innerhalb eines Spiels für beide Seiten verwalten.. am besten in einer Klasse mit eigener Steuerung.

Die Spiele dann wiederum in einem Satz, wobei dort dann auch das mit dem Tiebreak einfliessen kann.

Die Sätze schliesslich in einem Match.

Macht also ein Spieler einen "Treffer", gibt man die Info an das Match, das gibt es an den akt. Satz weiter und von da in das akt. Spiel wo dann entschieden wird ob, bzw. wer einen Punkt bekommt. Wenn das Spiel sich als "gewonnen erklärt", muss dann der Satz entscheiden, wie es weiter geht, das selbe bei gewonnenem Satz in Richtung Match.

Das ganze in Code fassen ist mir aber ein bisschen zu viel auf die Schnelle

[torud]

Danke fuer die nicht erwartet doch recht ausfuehrliche Antwort. Das sollte mir scon weiterhelfen. Koennte sein, dass ich nochmal wegen des Inc(TPointsA) nachfragen muss, da ich sowas noch nicht gemacht habe.

Ich habe auch nicht erwartet, hier eine sofortige Komplettloesung zu erhalten. Ich melde mich dann einfach wieder, wenn ich die ersten Schritte getan habe. So wie es verstanden habe, sollte es reichen, wenn die Klasse einfach nur erfahrt, ob es einen neuen Pluspunkt oder auch Minuspunkt(wenn man sich verzaehlt hat) fuer Spieler A oder B gibt. Der Rest laeuft dann intern ab.

Wie wuerdest Du/Ihr denn die Functionen sinnvoll benennen?

[cruiser]

Ich würd eine Funktion in jeweils der Match, Satz und Spielklasse machen...

sowas wie:

Delphi-Quellcode:

{...}
  function TMatch.SetPoint(player,point: integer);
  begin
    actSet.SetPoint(player,point);
    // wenn Satz beendet eröffne neues Match bzw. beende Match
  end;

  function TSet.SetPoint(player,point: integer);
  begin
    actGame.SetPoint(player,point);
    // wenn Spiel beendet eröffne neues Spiel, beende Satz oder gehe in den Tiebreak-Modus
  end;


  function TGame.SetPoint(player,point: integer)
  begin
    // wenn player = 1
      // wenn point > 0 erhoehe Spieler1
      // wenn point < 0 senke Spieler1
    // sonst  
      // wenn point > 0 erhoehe Spieler2
      // wenn point < 0 senke Spieler2

    // evtl. umstellen wer gerade Vorteil hat
  end;

{...}

Edit: evtl. Lohnt es sich von TPersistent abzuleiten... damit könntest du die einzelnen Sachen für Undo's in Streams ablegen...

[torud]

Hello again,

also ich bin nun an folgendem Punkt angelangt. Ich habe die Klassen te_game, te_set und te_init erstellt mit folgendem Inhalt:

Delphi-Quellcode:

unit te_init;

interface

uses te_game;

  procedure InitVariables;

implementation

procedure InitVariables;
begin
   akt_points_a := 0;
   akt_points_b := 0;
end;

end.

Delphi-Quellcode:

unit te_game;

interface

uses Dialogs,SysUtils;

var
  akt_points_a,akt_points_b:integer;


  function SetPoint(player,point: integer):boolean;

implementation

function SetPoint(player,point: integer):boolean;
begin
  // wenn player = 1
  case player of
    1 : begin
          // wenn point > 0 erhoehe Spieler1
          if point > 0 then inc(akt_points_a);
          // wenn point < 0 senke Spieler1
          if point < 0 then dec(akt_points_a);
        end;
    2 : begin
          // wenn point > 0 erhoehe Spieler2
          if point > 0 then inc(akt_points_b);
          // wenn point < 0 senke Spieler2
          if point < 0 then dec(akt_points_b);
        end;
  end;
  showmessage(inttostr(akt_points_a));
end;
end.

Im FormCreate meiner Applikation rufe ich auf:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
begin
  InitVariables;
end;

und wenn ich mal einen Testbutton für plus A drücke, passiert folgendes:
SetPoint(1,1); Also Spieler 1 oder A erhält einen Pluspunkt.

Nun stehe ich vor dem Problem mit dem Zählen in der richtigen Reihenfolge => 0, 15, 30, 40 und wenn akt_points_a schon 40 hat und einer dazukommt, würde ich dann akt_games_a "inc"en...aber wie?

[torud]

Ok, ich habe mir noch ein paar Gedanken gemacht und die SetPoint erweitert, nachdem ich mir in der Hilfe inc/dec nochmals angesehen habe. Das ist zwar jetzt noch nicht die Endversion, aber ein Zählen von 0 -40 und andersrum ist nun drin. 4 Probleme/Fragen habe ich derzeit. Sicher nicht die letzten.

1. Ich habe noch nicht herausgefunden, wie ich das mit dem Vorteil lösen soll, da ja die Punkte in den Variablen akt_point_a und akt_point_b, welche vom Typ her integer sind, geschrieben und auch hochgezählt werden. Also wie soll ich da ein A für Vorteil reinschreiben, bzw. wie kann ich das händeln?

2. Den Code finde ich schon jetzt ziemlich aufgebläht. Geht das auch anders? Ich denke meist nach Schema F und würde gern über den Tellerrand hinausblicken.

3. Ich würde gern das Befüllen der Controls, den die Inhalte sollen ja dann dem Programm auch sichtbar zugeführt werden, bzw. rausgeschickt werden, extra abhandeln. Anwelcher Stelle würdet Ihr das zentral lösen? Zur Zeit tue ich dies per DUmmy mit dem Showmessage am Ende von SetPoint, aber eigentlich kanns das nicht sein, weil ich diese Routine auch in Richtung SetGame verlassen muss, wenn ein Spieler mit dem aktuell gewonnenen Punkt ein Spiel gewonnen hat.

4. Desweiteren müsste ich dann nachdem ich ein gewonnenes Spiel erkannt habe akt_point_a und akt_point_b wieder auf 0 zurücksetzen. Sollte das in Setpoint geschehen oder besser in SetGame, respektive SetSetWin (gibts noch nicht)...

Hier mein Code von SetPoint:

Delphi-Quellcode:

function SetPoint(player,point: integer):boolean;
var
  n : integer;
begin
  // wenn player = 1
  case player of
    1 : begin
          // wenn point > 0 erhoehe Spieler1
          if point > 0 then
            begin
              //festlegen, um wieviel ge-inc-t wird
              case akt_points_a of
                0,15  : n := 15;
                30,40 : n := 10;
                else  exit;
              end;
              inc(akt_points_a,n);
            end;
          // wenn point < 0 senke Spieler1
          if point < 1 then
            begin
              //festlegen, um wieviel ge-dec-t wird
              case akt_points_a of
                15,30  : n := 15;
                40     : n := 10;
                else  exit;
              end;
              dec(akt_points_a,n);
            end;
        end;
    2 : begin
          // wenn point > 0 erhoehe Spieler2
          if point > 0 then
            begin
              //festlegen, um wieviel ge-inc-t wird
              case akt_points_b of
                0,15  : n := 15;
                30,40 : n := 10;
                else  exit;
              end;
              inc(akt_points_b,n);
            end;
          // wenn point < 0 senke Spieler2
          if point < 1 then
            begin
              //festlegen, um wieviel ge-dec-t wird
              case akt_points_b of
                15,30  : n := 15;
                40     : n := 10;
                else  exit;
              end;
              dec(akt_points_b,n);
            end;
        end;
  end;
  showmessage(inttostr(akt_points_a));
end;

[cruiser]

Vieles würde sich erschlagen, wenn du wie ich oben schon schrieb, eine Enumeration nimmst:

Delphi-Quellcode:

type
  Te_points = (tp0, tp15, tp30, tp40, tp40a);

{...}

var
  pnt_a: Te_points; // kein integer... dadurch bläht es so auf!

{...}

pnt_a := tp0; // initialisieren

Inc(pnt_a); // pnt_a hat jetzt den Status tp15

pnt_a := tp40a; // initialisieren

Dec(pnt_a); // pnt_a hat jetzt den Status tp40

Was das A angeht, würde ich ein constantes Array mit den Ausgabewerten definieren:

Delphi-Quellcode:

const
  _tearr_points : array of string = ('0', '15', '30', '40', 'A');

{...}

Zugriff über z.B.:
string_a := _tearr_points[ord(pnt_a)];

zu 4.: Wenn ein Spieler bei tp40a oder tp40 steht und einen Punkt bekommt ist das Spiel abgeschlossen. Entsprechend kannst du guten gewissens die werte wieder auf tp0 setzen und der in der Logik nächst höheren Klasse (Satz) mitteilen, wer denn denn das Spiel gutgeschrieben bekommt. Wichtig ist, dass du dir merkst, wer im Ballbesitz ist!

zu 3.: Ich würde eine Zeichenklasse baun, die das auf ein Canvas(oder was auch immer) ausgibt. Diese Klasse kannst du ja beim erzeugen der Instanzen an jene jeweils immer weiter geben. Somit gibt jede Logik-Klasse der Zeichenklasse die Infos, was sich denn geändert hat.

Edit: mh... ich hab mal den Anfang gemacht und das ein wenig strukturiert... mit bisschen Struktur wird es immer weniger aufgebläht Siehe Anhang. Evtl. kannst du darauf ja aufbaun

[alzaimar]

Das stimmt aber so nicht, denn wenn ein Spieler 'tp40a' Punkte hat, under andere auch, dann ist bei dem Gewinn eines weiteren Punktes ja noch lange nicht schluss. Ich würde die Punkte einfach addieren (Punkte = Integer, wieso nicht?), und nur die Ausgabe (Visualisierung) dem im Tennis üblichen Gehopse von 0 auf 15 auf 30 auf 40 etc. anpassen, etwa so:

Delphi-Quellcode:

Function ShowPoints (aPointsA, aPointsB : Integer) : String;
Var
  sScoreA, sScoreB : String;

  Function Score (aPoints : Integer) : String;
  Begin
    Case aPoints Of
      0 : Result := '0';
      1 : Result := '15';
      2 : Result := '30';
      3 : Result := '40';
      else Result :='Advantage'
    End;
  End;

Begin
  sScoreA := Score (aPointsA);
  sScoreB := Score (aPointsB);
  Case max (aPointsA, aPointsB) Of
    0,1,2,3 : 
      Result sScoreA+':'sScoreB         
    Else 
      If Abs (aPointsA-aPointsB)>1 Then // Jemand gewinnt
        If aPointsA>aPointsB Then
          Result := 'Spieler A gewinnt'
        else
          Result := 'Spieler B gewinnt'
      else If aPointsA>aPointsB Then
        Result := sScoreA+' A'
     else
        Result := sScoreA+' B'
   End
End;

Function IsAWin (aPointsA, aPointsB : Integer) : Boolean;
Begin
  Result := (Max (aPointsA, aPointsB)>3) And (Abs (aPointsA-aPointsB)>1)
End;

Gewonnen hat der, der zuerst mehr als 3 Punkte gemacht und dabei mindestens 2 Punkte mehr als der Gegner hat.

Der Nachteil einer Enumeration ist ja der, das man beim Stand von 'tp45A' nicht weiter erhöhen kann. Das muss aber möglich sein, denn viele Spiele sind hart umkämpft...

[torud]

Hier ist noch ein kleiner Fehler drin, denn in Deinem Code - lieber alzaimar, wird noch nicht so recht berücksichtigt, was denn passiert, wenn nach einem A:40 wieder ein 40:40 wird. Das steht dann naemlich leider immernoch Advantage...Habe ich nur gerade beim Testen festgestellt. Also ich will nicht übertreiben, aber einfach ist es nicht wirklich...

Hier nochmal ein eventuelles Szenario:

30:40
40:40 ((oder deuce) dies wird optional sein, da es da diverse vorlieben gibt)
A:40 (Spieler A hat Vorteil)
40:40 (üblicherweise wird hier sogar folgendes gezeigt => "#2 Deuce") damit wissen alle, wie umkämpft dieses Spiel ist
40:B (Spieler B hat Vorteil)
40:40 (oder Deuce oder #3 Deuce)
40:B (Spieler B hat wieder Vorteil)
Pluspunkt B

Spieler B hat nun dieses Spiel gewonnen. Sein Punktestand im aktuellen Satz wird um 1 erhöht.

[cruiser]

@Alzaimar
nuja... bei A:40 und B macht einen Punkt muss man ja nich B weiter erhöhen sondern kann entsprechend A niedriger setzen.

In meinem Code ist sicher nicht alles berücksichtigt. Wollt halt aufzeigen, dass es auch ohne Bläh-Code mit x cases und Ifs geht