Quelltext der Seite Pong/Modellierung

==Kurzbeschreibung==
[[Datei:Pong.png|mini|300px|rechts|gerahmt|ohne|PONG aus der Spielesammlung „Atari Arcade Hits #1“, herausgegeben von Hasbro Interactive – ein Remake des Orginals das Atari in den 70er-Jahren herausgebracht hat]]
[[Pong]] wird von zwei Spielern gespielt.
Ein Spieler kann das Spiel starten (Startknopf) und vorzeitig 
beenden (Stopp-Knopf). Nach Spielstart können die beiden Spieler jeweils einen Schläger
am linken bzw. rechten Rand des Spielfeldes mit Hilfe der Richtungstasten des 
Keyboards nach oben und unten bewegen. Wenn ein Schläger mit einer Seitenwand kollidiert stoppt er.
Er kann vom zugehörigen Spieler nur noch in Gegenrichtung bewegt werden.

Nachdem das Spiel gestartet wurde, bewegt sich
der Ball geradlinig im Spielfeld, wobei die Startrichtung zufällig
gewählt wird. Kollisionen mit der oberen oder 
unteren Wand haben eine Richtungsänderung des Balls
zur Folge (Einfallswinkel = Ausfallwinkel). 

Eine Kollision eines Schlägers mit dem Ball hat ebenfalls eine Richtungsänderung des Balls zu Folge. 
Wird der Schläger im Moment der Kollision bewegt, so wird der Ball abhängig von der 
Bewegungsrichtung und Geschwindigkeit des Schlägers abgelenkt.

Mit den Wänden hinter den Schlägern kollidiert der Ball nicht. 
Passiert der Ball einen Schläger, verlässt er die Bühne durch Wand hinter dem Schläger
und der der Gegner, {{dh}} der
Akteur, der den anderen Schläger bedient, erhält einen Punkt.

Ziel des Spiels ist es, den Ball möglichst lange im Spiel zu halten. 
Der aktuelle Punktestand (Score) wird den beiden Spielern jederzeit angezeigt.

== Use Cases (Anwendungfälle)==
[[Datei:WK Pong01 UseCases 2018.png|mini|600px|gerahmt|ohne|Use Cases des Spiels <code>Pong</code>]]
{{collapsible
|id=UseCases
|open=true
|head=<h3>Details</h3>
|body=Im Spiel Pong gibt es zwei Akteure, die Spieler. Innerhalb des Spiels werden sie durch ihre Avatare, jeweils ein Schläger, vertreten.
(Formal gibt es in UML keine Akteure innerhalb eines Systems. Da aber die spielentscheidenden Aktionen nicht durch die
Spieler selbst, die nur die Schläger nach links oder rechts steuern können, sondern durch ihre Avatare ausgeführt werden,
setze ich mich hier über den UML-Standard hinweg.) 
====Zustände des Spiels====
[[Datei:WK Pong01 Automaton01 2018.png|mini|400px|gerahmt|ohne|Zustände des Spiels <code>Pong</code>]]

Das Spiel kennt zwei Zustände:  
* <code>stopped</code> (das Spiel läuft nicht, die Game Loop ist im Zustand <code>stopped</code>)
* <code>running</code> (das Spiel läuft, die Game Loop ist im Zustand <code>running</code>)

Ein Zustandswechsel wird mittels der Aktion <code>toggleStartStop</code> erzielt. Das heißt, es gibt einen [[Toggle-Button]] (Flip-Flop-Schalter) zum Wechseln zwischen dem Start- und dem Stoppzustand. 

Der Zustandswechsel vom Zustand <code>running</code>  in den Zustand <code>stopped</code> kann allerdings nicht nur durch den Start-/Stopp-Button, sondern auch durch die Spiellogik mittels der Aktion <code>gameOver</code> erzwungen werden. Dies geschieht, sobald ein Spieler das Spiel gewonnen hat. 

====Use Cases für Spieler====
{{Use case
| name = Spiel starten
| akteure = Spieler
| vorbedingungen = Spiel wurde noch nicht gestartet; aktueller Zustand: <code>stopped</code>
| nachbedingungen = Spiel läuft; aktueller Zustand (mittels Aktion <code>toggleStartStop</code>): <code>running</code>
| beschreibung = Einer der beiden Spieler startet das Spiel, indem er den Startknopf drückt. Daraufhin wird das Spiel gestartet und der Startknopf wandelt sich in einen Stoppknopf.
Der aktuelle Punktestand wird zurückgesetzt.  Danach wird vom Mittelpunkt des Spielfeldes ein Ball in zufälliger Richtung mit zufälliger Geschwindigkeit gestartet. Die Richtung und die Geschwindigkeit müssen allerdings so gewählt werden, dass das Spiel nicht zu einfach, zu schwierig oder gar unmöglich zu spielen ist. (Letzteres wäre der Fall, wenn sich der Ball genau entlang der Mittellinie bewegen würde.) Der Ball prallt von den oberen und unteren Seitenwänden sowie von den Schlägern ab. Die linken und rechten Seitenwände passiert er dagegen, wenn er nicht vorher von dem davor platzierten Schläger abprallt.
}}

{{Use case
| name = Schläger bewegen
| akteure = Spieler, Avatare (Schläger)
| vorbedingungen = Spiel läuft; aktueller Zustand: <code>running</code>
| beschreibung = Jeder der beiden Spieler steuert einen eigenen Schläger mittels geeigneter Tasten auf der Tastatur. Der Schläger von Spieler 1 befindet sich an der linken Seite des Spielfeldes, der von Spieler 2 an der rechten. Der jeweilige Schläger bewegt sich entlang der Wand solange nach oben bzw. unten, so lange der zugehörige Spieler die entsprechende Taste drückt. Während eine Richtungstaste gedrückt ist, wird der Schläger immer schneller. Bei Kollision mit einer Wand stoppt er sofort. Er kann vom Spieler dann nur noch in Gegenrichtung bewegt werden.
}}

{{Use case
| name = Score betrachten
| akteure = Spieler
| beschreibung = Die Spieler können jederzeit während des Spiels und auch nach Spielende den Punktestand einsehen. Angezeigt wird, wie viele Punkte jeder Spieler bislang erzielt hat, {{dh}}, wie viele Bälle der Gegner hat passieren lassen. 
}}

{{Use case
| name = Spiel abbrechen
| akteure = Spieler
| vorbedingungen = Spiel läuft; aktueller Zustand: <code>running</code>
| nachbedingungen = Spiel wurde beendet; aktueller Zustand (mittels Aktion <code>toggleStartStop</code>): <code>stopped</code>
| beschreibung = Einer der beiden Spieler bricht das laufende Spiel ab, indem er den Stoppknopf drückt. Daraufhin wird das Spiel ohne weitere Warnung beendet und der Startknopf wandelt sich in einen Startknopf. Der aktuelle Punktestand ist noch zu erkennen.
}}

==== Use Cases für Avatare (Schläger)  ====
{{Use case
| name = mit Ball kollidieren
| akteure = Avatare (Schläger)
| vorbedingungen = Spiel läuft; aktueller Zustand: <code>running</code>
| beschreibung = Sobald der Ball mit einem Schläger kollidiert, prallt er (nach Möglichkeit physikalisch korrekt) von diesem ab. Sollte sich der Schläger zum Zeitpunkt der Kollision bewegen, so wird eine Reibung zwischen Ball und Schläger simuliert. Das heißt, der Ball wird ein wenig in die Bewegungsrichtung des Schlägers abgelenkt. Die Ablenkung ist proportional zur Geschwindigkeit des Schlägers zum Kollisionszeitpunkt.  
}}
{{Use case
| name = stoppen
| akteure = Avatare (Schläger)
| vorbedingungen = Spiel läuft; aktueller Zustand: <code>running</code>
| beschreibung = Wenn der Schläger mit der oberen oder unteren Seitenwand des Spielfeldes kollidiert bleibt er schlagartig stehen.
}}
{{Use case
| name = Ball passieren lassen
| akteure = Avatare (Schläger)
| vorbedingungen = Spiel läuft; aktueller Zustand: <code>running</code>
| beschreibung = Wenn sich ein Ball auf die Wand hinter einem Schläger zubewegt und nicht mit dem Schläger kollidiert, verschwindet er hinter dem Schläger und der Spielpartner erhält einen Punkt. Danach wird vom Mittelpunkt des Spielfeldes ein neuer Ball in zufälliger Richtung mit zufälliger Geschwindigkeit gestartet.
}}
{{Use case
| name = Spiel beenden
| akteure = Avatare (Schläger)
| bedingte erweiterung 01 von  = Ball passieren lassen
| bedingung 01 = Einer der beiden Spieler (bzw. dessen Schläger) kann zum zehnten Mal einen Ball nicht zurückschlagen, sondern lässt ihn passieren.
| vorbedingungen = Spiel läuft; aktueller Zustand: <code>running</code>
| nachbedingungen = Spiel wurde beendet; aktueller Zustand  (mittels Aktion <code>gameOver</code>): <code>stopped</code>
| beschreibung = Sobald ein Spieler 10 Punkte gesammelt hat, weil sein Gegner 10 Bälle hat passieren lassen, ist er der Gewinner und das Spiel wird beendet. Der aktuelle Punktestand wird noch angezeigt. Der Schläger wandelt sich in eine Startknopf. Das heißt, einer der Spieler kann jederzeit ein neues Spiel starten.
}}

}}

==Modellierung==
[[Datei:WK Pong01 ClassModel01 2018.png|mini|460px|gerahmt|ohne|Eine erste Version eines Klassendiagramms <code>Pong</code>]]
{{collapsible
|id=DataModel
|open=true
|head=<h3>Details</h3>
|body=  
====Objekte, Funktionen und Module ====
Die Analyse der Use Cases zeigt auf, welche Objekte, Funktionen und Module benötigt werden:

''Model und View'' (Objekte)
* Eine Bühne (das Spielfeld) auf der das Spiel stattfindet (unveränderlich, ohne visuelle Darstellung)
* Ein Ball, der bei Start einer neuen Spielrunde oder eines neuen Spiels wiederverwendet wird (beweglich, mit visueller Darstellung)
* Zwei Schläger (beweglich, mit visueller Darstellung)
* Zwei Textfelder zur Anzeige des Spielstands/Scores (unbeweglich, aber veränderlich, mit visueller Darstellung)
* Ein Start/Stopp-Knopf, mit der das Spiel gestartet bzw. abgebrochen werden kann (unbeweglich, aber veränderlich, mit visueller Darstellung; evtl. mittels HTML außerhalb des Spielfelds)
Für jedes dieser Objekte müssen sowohl die Model-Eigenschaften (Größe, Position, Geschwindigkeit etc.)
als auch – sofern sie eine visuelle Darstellung haben –  die View-Eigenschaften (Aussehen) definiert werden. In jedem Fall könnte '''ein''' JavaScript-Objekt definiert werden, 
das sowohl die Model-, als auch die View-Eigenschaften festlegt.  Es wird jedoch festgelegt, dass jeweils zwei Objekte definiert werden, eines mit den Model-Eigenschaften und eines mit den View-Eigenschaften (sofer es eine View gibt). 

''Kollisionserkennung- und Behandlung'' (Funktionen):
* Kollision von Ball und Wand (Rand des Spielfeldes): oberer/unterer Rand → Ball prallt ab, linker/rechter Rand →Ball verlässt die Bühne, die Spiellogik wird informiert
* Kollision von Ball und Schläger. Ball prallt ab
* Kollision von Wand und Schläger: Schläger bewegt sich nicht weiter

''Controller'' (Funktionen)
* Tastatursteuerung (je Schläger eine eigene Steuerung)
* Button-Controller (Start/Abbruch): Bei jedem Klick wird die Logik informiert, dass der Spielzustand (<code>stopped</code>/<code>running</code>) geändert werden muss

Die Steuerung der Schläger erfolgt über die Tastatur. Für jeden Tastendruck muss analysiert werden, welche der Tasten gedrückt (keydown) oder losgelassen (keyup) wurde. Wenn es sich um eine Taste handelt, die einem Spieler zugeordnet ist, muss der zugehörige Schläger informiert werden, damit er die gewünschte Aktion (Bewegung nach oben starten, Bewegung nach unten starten, Bewegung stoppen) durchführt. Der Schläger wird direkt informiert. Die Alternative, zunächst die Spiellogik zu informieren, damit sie den Schläger stoppt, wäre zu umständlich. Die Tatsache, dass ein Schläger mit einer Wand kollidiert, hat keinerlei Auswirkung auf den Punktestand oder den Zustand des Spiels.

''Spiellogik'':

Die Spiellogik ist für die Verwaltung aller Spielzustände zuständig:
* Starten und stoppen der Game Loop, die mittels einer geeignete Model- und einer View-Update-Funktion die Models und die Views aktualisiert.
* Positionieren und zufälliges Starten des Balls in der Mitte des Spielfelds zu Beginn einer jeden Runde.
* Aktualisieren des Spielstandes und Start einer neuen Runde bzw. Beendigung des Spiels, sobald der Ball die Bühne verlässt.
}}

==Quellen==
<references/>
<ol>
<li value="1"> {{Quelle|Kowarschick, W.: Multimedia-Programmierung}}</li>
</ol>

==Siehe auch==
* [[Pong]]