TI Coding mit TI-84 Plus CE-T

Ein einfaches Ratespiel

Das Ratespiel besteht aus mehreren Teilen:

1. Einer Variable N, die den durch zufInt() als Zufallszahl bestimmten Wert enthält, den es zu raten gilt.
2. Einer Repeat – Schleife, in der N erraten werden soll, indem man eine Zahl G eingibt, und die solange durchgeführt wird, bis die richtige Zahl G (G=N) eingegeben wurde.
3. Dem Befehl Prompt, mit dem die Zahl eingegeben wird.

4. If – Befehlen in Kombination mit Disp, um dem Spieler mitzuteilen, ob seine eingegebene Zahl zu groß oder zu klein ist.
5. Einer Variablen M und Disp, um die Anzahl der Versuche zu zählen und anschließend mitzuteilen.

Mit diesen Angaben sollte es möglich sein, das einfache Ratespiel zu programmieren. Mit Ausnahme von zufInt() (Menü WAHRS im Menü [MATH]) findet man alle Befehle in den Menüs, die im Editiermodus zur Verfügung stehen.

Der Programmablaufplan

Der Programmablaufplan ist oben abgebildet. Um ihn zu lesen, muss man lediglich den Pfeilen, ausgehend von START, bis Stopp folgen. Wenn man sich ein wenig vorstellt, wie der Programmcode aussehen müsste, so wird man feststellen, dass jeder Block nur aus 1 bis 3 Programmzeilen bestehen wird.

Das Programm

:zufInt(1,50)→N
Erzeugt eine ganzzahlige Zufallszahl zwischen 1 und 50 und speichert sie in N ab. Jede Eingabe G des Spielers wird mit N verglichen und es wird überprüft, ob G und N übereinstimmen.

:0→M
In der Variablen M wird die Anzahl der Versuche gespeichert. Bei jedem neuen Versuch wird M um 1 erhöht. Am Ende des Spiels wird M dann angezeigt. Natürlich muss am Anfang des Spiels M auf 0 gesetzt werden.

:Repeat G=N
Wiederholt die Programmzeilen bis zum dazugehörigen End solange bis G und N übereinstimmen. Diese Überprüfung findet allerdings erst dann statt, wenn die gesamte Schleife einmal durchlaufen wurde. Deshalb muss man für G auch keinen Anfangswert vorgeben, da ja in jedem Fall ein Wert für G eingegeben werden muss. Würde man eine While-Schleife verwenden, so müsste für G ein Anfangswert vorgegeben werden, da hier die Bedingung am Anfang der Schleife überprüft wird.

:Prompt G
Verlangt die Eingabe eines Wertes, der dann in G abgespeichert wird.

:If G>N
:Disp "ZU GROSS"
Ist die eingegebene Zahl G größer als die zu erratende N, so wird ZU GROSS auf dem Display dargestellt, so dass man weiß, dass man beim nächsten Mal eine kleinere Zahl nehmen muss. Beim Befehl If wird die unmittelbar nächste Zeile ausgeführt, wenn die Bedingung wahr ist; andernfalls wird sie übersprungen.

:If G<N
:Disp "ZU KLEIN"
Auch bei zu kleiner Zahl G erfolgt eine entsprechende Meldung.

:M+1→M
Erhöht den Versuchszähler M um 1.

:End
Ende der Schleife. Jetzt wird die Bedingung überprüft. Sollten N und G nicht übereinstimmen, wird die Schleife erneut durchlaufen. Bei Übereinstimmung sind alle If-Bedingungen falsch, die Repeat-Bedingung ist jedoch wahr und die Schleife wird verlassen und das Programm macht mit den Befehlen nach dem End weiter.

:Disp "RICHTIG NACH"
:Disp M
:Disp "VERSUCHEN."
Die Anzeige erfolgt auf drei Zeilen. Sie kann noch so verbessert werden, dass man nur eine Zeile benötigt.

Erweiterungen

• Man kann die Grenzen, innerhalb derer die zu erratende Zahl liegen soll, durch den Spieler vorgeben lassen. Im Programmierbeispiel ist sie fest auf 1 bis 50 eingestellt.
• Zur Information kann man diesen Bereich auch anzeigen.
• Man kann den High Score (also die geringste Anzahl bei den Versuchen) ebenso wie die mittlere Anzahl aller Versuche abspeichern, allerdings muss man dazu Variablen verwenden, die dauerhafter sind als die nummerischen Variablen A-Z. Informationen dazu gibt es in den entsprechenden Publikationen.
• Man kann Prompt durch Input ersetzen.
• Das Display sollte gelöscht werden, bevor das Spiel beginnt.

Man kann noch mehr Erweiterungen finden – der Phantasie sind da keine Grenzen gesetzt!

Einen Buchstaben auf dem HOME-Bildschirm bewegen
Das Programm, das in dieser Übung erstellt werden soll, ist zwar kurz, beinhaltet aber eine ganze Reihe wichtiger Programmelemente. Es wird ein Programm mit dem zentralen Element einer Warteschleife. Das ist ein Befehlsblock, der permanent ausgeführt wird, dabei aber auf eine Eingabe wartet und darauf reagiert. In unserem Beispiel geht es darum, dass Tasten gedrückt werden müssen, und die Antwort wird die Bewegung eines Buchstabens über den HOME-Bildschirm sein. Warteschleifen in einem Programm warten z.B. auf die Eingabe von Daten, einen Mausklick, einen Tastendruck auf der Tastatur oder auf Datenpakete aus dem Netzwerk.

Warteschleifen und der Befehl getKey
Das Bild zeigt den grundsätzlichen Aufbau eines Programmes mit einer Warteschleife. Darin wird ein Code ausgeführt, der die Schleife mit den initialisierenden Variablen umfasst, die solange ausgeführt wird, bis eine Abbruchbedingung erfüllt ist.

Die Warteschleife hat drei Hauptbestandteile:

1. Eine Abbruchbedingung die festlegt, bei welcher Bedingung die Schleife verlassen wird. Das kann z.B. ein Programmausstieg wie das Drücken von [ESC] sein. In unserem Fall ist es das Drücken der Taste [CLEAR].
2. Befehle, die innerhalb der Schleife sich befinden und unabhängig sind.
3. Befehle, mit denen Ereignisse überprüfen werden können, so dass darauf reagiert werden kann. Im Beispiel sind dies Tasten, die gedrückt werden.

Zur Konstruktion der Warteschleife werden Bedingungen und der Befehl getkey benötigt.
getKey ist ein TI-BASIC – Befehl, mit dem festgestellt werden kann, ob eine Taste gedrückt wurde. getKey liefert eine Zahl zwischen 11 und 105, wenn vorher eine Taste gedrückt wurde; andernfalls ist die Zahl 0. getKey hält das Programm nicht an wie z.B. Input. Die Zahl hängt ab von der jeweiligen Taste: [y=] erzeugt die Zahl 11, [graph] die Zahl 14, [enter] die Zahl 105, denn es gibt auf der Tastatur 10 Zeilen zu je 5 Tasten.

Befehle mit Bedingungen ermöglichen es, die Teile des Programmcodes auszuwählen, die ausgeführt werden sollen, je nachdem ob die Bedingung wahr oder falsch ist. Solche Befehle können z.B. sein If A>1 oder If K=24 oder If K=25 und B>1. Glücklicherweise sind sie genauso formuliert wie sie wirken: Die Bedingung im ersten Fall ist wahr, wenn die Variable A>1 ist, im zweiten Fall wenn K=25 ist und im dritten wenn sowohl k=25 und B>1 erfüllt sind. Die einfachste Form des Befehls If besteht aus der Bedingung, der in der nächsten Zeile ein Befehl folgt, der bei wahr ausgeführt wird. Mit den umfangreicheren Befehlen If/Then/End und If/Then/Else/End lassen sich komplexere Strukturen aufbauen.

Bewegung eines Buchstabens auf dem HOME-Bildschirm
Das Programm BEWEGE ist eines der einfachsten Beispiele für die Verwendung einer Warteschleife, bei der auf das Drücken von Tasten gewartet und darauf reagiert wird. Im Flussdiagramm ist das Programm dargestellt. Die Warteschleife selbst enthält die Teile „Zeichne M“, „Tastendruck?“ und zurück zu „Zeichne M“. Die Abbruchbedingung sorgt dafür, dass die Warteschleife verlassen wird; man kann im Flussdiagramm gut sehen, dass man die Schleife nur durch Drücken von [CLEAR] verlassen kann.

Bei der Verwendung eines TI-84 Plus ändern sich die Werte für die Grenzen des HOME-Bildschirms und den Startpunkt wegen der unterschiedlichen Auflösungen der Displays.

Erläuterungen zum Programm:

     :13→A
     :5→B
Anfangswerte für die Koordinaten des Buchstabens, der gezeichnet werden soll. Da die Variablennamen X und Y durch andere Programme des Taschenrechners beeinflusst werden können, sind hier als Koordinaten A (x-Achse) und B (y-Achse) gewählt worden. Die Koordinaten geben ungefähr die Mitte des HOME-Bildschirmes beim TI-84 Plus CE-T an.

     :ClrHome
Löscht den HOME- Bildschirm.

     :Repeat K=45
Beginn der Warteschleife. Alle bis End folgenden Befehle werden solange wiederholt, bis K=45 ist, der Tastaturcode für [CLEAR].

     :Output(B,A,“M”)
Schreibt den Buchstaben „M“ in Reihe B Spalte A des HOME-Bildschirmes. Befindet sich schon ein „M“ an dieser Stelle, wird es einfach überschrieben.

     :getKey→K
Speichert den Tastaturcode seit dem letzten Aufruf von getKey in der Variablen K. Es wird nicht auf einen Tastendruck gewartet; wurde keine Taste gedrückt ist K=0.

     : If K≠0
Wurde eine Taste gedrückt, so soll der Buchstabe gelöscht werden, da er ja wahrscheinlich bewegt wird. Würde er nicht gelöscht, so würde man den Weg des Buchstabens über den HOME-Bildschirm sehen.

     :Output(B,A," ”)
Schreibt ein Leerzeichen über das zuletzt geschriebene M, wodurch es ausgelöscht wird. Dieser Befehl soll nur ausgeführt werden, wenn K ungleich Null ist.

     :If K=24 und A>1
     :A-1→A
Der Links-Pfeil [←] hat den Tastencode 24. Wurde er gedrückt, so wird die x-Koordinate um 1 verringert, so dass sich M um 1 weiter nach links bewegt. Der Buchstabe soll aber nicht nach links aus dem Bildschirm wandern; deshalb wird dieser Befehl nur ausgeführt, wenn A>1 ist.

     :If K=26 and A<26
     :A+1→A
     :If K=25 and B>1
     :B-1→B
     :If K=34 and B<10
     :B+1→B
Ähnliche Befehle gelten für die übrigen Richtungen. Immer wird auch vermieden, dass der Buchstabe das Display verlässt.

     :End
Das Ende der Warteschleife. Der Rücksprung zum Anfang wird nur durchgeführt, solange der Tastencode nicht 45 ist. Ist er 45, so endet das Programm.

Erweiterungen

Mit diesem einfachen Programm lassen sich viele schöne Programme und sogar Spiele programmieren:

• Zunächst einmal könnte man das M durch einen anderen Buchstaben oder vielleicht sogar durch eine Buchstabengruppe ersetzen.
• Man kann diagonale Bewegungen einführen. Da getKey nur auf einzelne Tasten reagiert, kann man die Bewegung mit den Zifferntasten steuern.
• Man kann das Programm auf den Grafik-Bildschirm übertragen. Welche Befehle müssen dann verändert werden, welche bleiben gleich? Was ist mit den Grenzen?
• Schließlich kann man das Programm so verändern, dass der Buchstabe ein Raumschiff ist, mit dem man auf Asteroiden schießt, bevor sie das Raumschiff treffen. Wie kann man eine Waffe einbauen, wie die beweglichen Asteroiden und was ist mit dem Spielstand?
• Und darüber hinaus sind der eigenen Phantasie natürlich keine Grenzen gesetzt!

Das Spiel “SNAKE”

Das Spiel ist eine Schlange aus 10 Elementen, die mit den Pfeiltasten gesteuert werden kann. Es handelt sich um die Grundform des Spiels – Erweiterungen werden am Schluss vorgestellt. Das Programm bezieht sich auf einen TI-84 Plus CE-T; beim TI-84 Plus muss man ein paar Veränderungen vornehmen, da der HOME-Bildschirm kleiner ist.

Das Programm

     :ClrHome
Löscht den HOME-Bildschirm.

     :13→A
     :5→B
     :10→X
     :1→P
     :26→D
Anfangswerte der verwendeten Variablen:

• A ist die x-Koordinate des Schlangenkopfes und B die y-Koordinate. Zeile 5 Spalte 13 ist etwa die Mitte des HOME-Bildschirms bei den Farb-Taschenrechnern.
• X ist die Länge der Schlange. Sie ist im Beispiel fest auf 10 Elemente eingestellt. Beim richtigen Spiel SNAKE würde man mit einem kleinen X starten und es immer größer machen, wenn die Schlange „Futter“ zu sich nimmt.
• P ist ein Zeiger auf das letzte Element der Schlange, also den „Schwanz“. L₁(P) ist die y-Koordinate des Schwanzes, L₂(P) die x-Koordinate. Wenn sich die Schlange bewegt, bewegt sich auch P, so dass er immer auf das Ende der Schlange zeigt, ohne dass die Daten in L₁ und L₂ verschoben werden.
• D ist die Richtung, in die sich die Schlange bewegt. Die Richtung wird über die Pfeiltasten und ihre Codes (hoch 25, runter 34, links 24 und rechts 26) bestimmt.

     :X→dim(L1)
     :X→dim(L2)
Die Länge der beiden Listen wird auf die Länge X der Schlange eingestellt.

:Fülle(B,L1)
:Fülle(A,L2)
Dadurch werden die beiden Listen mit den Startkoordinaten gefüllt – alle Segmente haben also am Anfang dieselben Koordinaten. Startet man das Spiel, so sieht es so aus, als würde die Schlange aus einem „Loch“ kriechen, dem Startpunkt, und sich dann zu voller Länge entwickeln. Das ist wesentlich einfacher als wenn man mit einer Schlange voller Länge beginnen würde.

:Repeat K=45
Die Schleife, die das eigentliche Spiel enthält, wird solange ausgeführt, bis die Taste [CLEAR] gedrückt wird (vergl. Lektion 2).

:Output(L1(P),L2(P)," ”)
Löscht das letzte Element der Schlange, den „Schwanz“. Da ein Ringspeicher verwendet wird, wird P stets so verändert, dass er immer auf die Elemente der Listen zeigt, die die Koordinaten des Schwanzes enthalten. L1(P) ist die y-Koordinate (Reihe) und L2(P) die x-Koordnate des Schwanzes.

:Output(B,A,"0”)
Zeichnet den neuen „Kopf“ der Schlange mit den Koordinaten A und B. Das Zeichen „0“ eignet sich gut als Schlangensegment, aber natürlich kann man auch irgendein anderes Zeichen nehmen.

:B→L1(P)
:A→L2(P)
Speichert die aktuellen Daten des Kopfes im Ringspeicher. Da P+1 im nächsten Iterationsschritt auf den Schwanz zeigen wird, zeigt P auf den Kopf, also werden die alten Schwanzkoordinaten mit den neuen Kopfkoordinaten überschrieben.

:P+1-X(P=X)→P
Sorgt dafür, dass P auf das nächste Element der Liste zeigt. Ist P kleiner als X, dann ist P=X falsch (0) und der Befehl vereinfacht sich zu P+1→P. Zeigt P aber bereits auf das letzte Element der Liste, dann ist P=X wahr (1) und man erhält P+1-X→P und damit X+1-X→P oder kurz 1→P. Hat P also das Ende der Liste erreicht, so beginnt im nächsten Schritt alles wieder von vorn.

:getKey→K
:If max(K={24,25,26,34})
:K→D
Wie üblich wird der Tastaturcode in K abgespeichert, so dass überprüft werden kann, ob [CLEAR] gedrückt wurde (K=45), so dass die Repeat-Schleife abgebrochen wird. Die If-Bedingung ist eine Kurzfassung für If K=24 oder K=25 oder K=26 oder K=34. K={24,25,26,34} erzeugt eine Liste mit 4 Elementen, nämlich {K=24,K=25,K=26,K=34}, die nur aus 0 und 1 besteht. Der Befehl max() liefert den größten Wert dieser Liste. Wurde z.B. „nach oben“ gedrückt, so lautet die Liste {0,1,0,0} und es ist max({0,1,0,0})=1 und die Bedingung ist wahr, die Variable D erhält den Wert von K und die Schlange eine neue Richtung. Wurde keine der Tasten gedrückt, so ist max({0,0,0,0})=0 und die Bedingung falsch und die Richtung D der Schlange bleibt unverändert, da dieser Befehl nun übersprungen wird.

     :A+(D=26)-(D=24)→A
     :B+(D=34)-(D=25)→B
Mit der Richtungsvariablen D werden nun die neuen Koordinaten des “Kopfes” bestimmt. Ist D=26 (nach rechts) oder D=24 (nach links), so bewegt sich die Schlange in x-Richtung. Bei D=34 (nach unten) oder D=25 (nach oben) bewegt sich die Schlange in y-Richtung. Terme wie z.B. D=24 sind als logische Terme entweder wahr (1) oder falsch (0).

     :A+26((A=0)-(A=27))→A
     :B+10((B=0)-(B=11))→B
Mit diesen beiden Anweisungen wird eine Fehlermeldung vermieden, die entsteht, wenn man ein Zeichen außerhalb des Bildschirmes setzen will. Stattdessen verschwindet die Schlange scheinbar hinter dem Bildschirm und taucht an der anderen Seite wieder auf.

     :End
Beendet die Repeat-Schleife. Bei K=45 würde die Schleife hier enden, und da es die letzte Anweisung des Programmes ist, endet das Programm hier dann auch.

Ergänzungen

SNAKE stellt die Grundform des Spieles dar. Die wichtigsten Dinge, die noch fehlen, sind: (1) das Anwachsen der Schlange, (2) ein Zähler (Score) für die Länge der Schlange und (3) Futter. Hier sind ein paar Anregungen, wie man das Spiel SNAKE vervollständigen könnte:

1. Zunächst benötigt man eine weitere Variable als Zeiger für den Kopf der Schlange. Bislang wurde P sowohl für den Kopf als auch den Schwanz benutzt, denn es wurde immer ein vollständig gefüllter Ringspeicher benutzt.
2. Dann benötigt man Speicher, die größer sind als die anfängliche Länge der Schlange, denn die Schlange soll ja wachsen. Das wirft eine interessante Frage auf: soll man von Anfang an mit einem Speicher starten, der die maximale Länge der Schlange hat? Oder soll man die Listen verlängern, wenn die Schlange größer wird?
3. Als nächstes kommt nun das Futter. Wie kann man dabei sicher sein, dass man das Futter nicht auf der Schlange platziert? Dazu könnte man den Inhalt des HOME-Bildschirms in einer Matrix speichern, so dass man testen kann, welche Stellen belegt sind.
4. Man muss herausfinden, ob die Schlange gerade Futter frisst oder gefressen hat, sodass man die Länge der Schlange und damit den Score vergrößern sowie neues Futter platzieren kann.
5. Ferner kann man Hindernisse auf dem Schirm einbauen und feststellen, ob die Schlange gegen ein solches stößt, oder ob sie sich gar selber beißt! Hier bietet sich sicher die Verwendung einer Matrix an.

Und natürlich sind der Phantasie keine Grenzen gesetzt!