Auf dem CAS Spiele programmieren

Kennt ihr diese riesigen, grafikfähigen Taschenrechner? In vielen Schulen gehören sie in der Oberstufe im Matheunterricht einfach dazu und werden leihweise an die Schüler vergeben. Damit kann man ganz interessante Dinge machen, nicht nur aus Sicht der Mathematik. Man kann damit ohne große Probleme auch eigene Spiele programmieren und dann unauffällig den Unterricht ein wenig auflockern.

Eigentlich ist der Programmeditor ja dazu da, Programme für kompliziertere Berechnungen oder Aufgaben zu schreiben. Aber ich dachte mir, warum nicht ein wenig Spaß damit haben, wenn man das Teil schon hat?

Ich will hier einmal versuchen, euch die Programmierung dieser Geräte näherzubringen. Dazu gibt es zwei Beispielrogramme, eines davon werde ich erklären, das andere nur aufschreiben. Wenn ihr wollt, könnt ihr sie natürlich einfach abtippen.

Für Kenner: Der CAS verwender eine leicht abgewandelte Version der Programmiersprache Pascal.

Es empfiehlt sich, den Rechner auf Englisch umzustellen. Die meisten Programmiersprachen sind in englisch und wer schon ein wenig Erfahrung hat, wird dann hier leichter reinfinden. Außerdem sind meine Beispiele auch so programmiert, dass sie in der englischen Spracheinstellung funktionieren. Für die deutsche Version müssten einige Befehle anders heißen. Zum Umstellen: „mode“-Taste und dann „F3″…dann sollte man es schon sehen.

Also erster Schritt: Wir gehen in den Programmeditor. Sollte kein Problem sein. Es erscheint eine Frage, bei der wir „New“ auswählen. Hier wird man nun gebeten, drei Dinge festzulegen. Für „Type“ und „Folder“ sind schon die richtigen Angaben ausgewählt, die können so bleiben. Bei „Variable“ geben wird nun einen Namen für das Programm ein. Dieser darf maximal 8 Buchstaben lang sein und nicht mit einer Zahl anfangen. Für das Beispiel wählen wir „wuerfeln“ und drücken „Enter“.

Das sieht jetzt erstmal so aus: (Die Zahlen und die grünen Balken könnt ihr ignorieren, die kommen von der Code-Darstellung. Im CAS haben die Zeilennummern nicht zu suchen. )

:wuerfeln()
:Prgm
:
:EndPrgm

Für Kenner: In den Klammern hinter dem Namen können Parameter definiert werden. Dazu sind nur Variablennamen nötig, keinerlei Datentypen.

Zwischen Prgm und EndPrgm kommt das eigentliche Programm. Alles, was davor oder dahinter ist, funktioniert nicht. Wir wollen ein kleines Würfelspiel schreiben. Dieses soll so ablaufen, dass es zwei Spieler gibt, einer davon der Computer. Der menschliche Spieler soll eingeben, was er gewürfelt hat, dann vergleicht der Taschenrechner mit seinem Wert und entscheidet, wer die Runde gewonnen hat. Zum Schluss besteht noch die Möglichkeit, zu entscheiden, ob man weiterspielen möchte oder nicht. Klingt kompliziert? Keine Sorge, das ist nicht sonderlich schwer.

Was brauchen wir denn überhaupt?
Erstmal eine Möglichkeit, mit dem Rechner zu würfeln. Dazu gibt es den Befehl „rand()“. Wir gehen mal davon aus, dass nur mit einem einzigen Standard-Würfel gespielt wird. Also einem mit den Zahlen von eins bis sechs. Dementsprechend können wir rand(6) aufrufen. Damit wird zufällig eine Zahl zwischen 1 und 6 ermittelt. Ganz einfach also.

Dann brauchen wir ein paar Werte. Wie beim Programmieren üblich, werden diese in Variablen gespeichert. Beim CAS wird eine Varible erzeugt, indem man „Local xyz“ schreibt. Also statt „xyz“ den Namen der Variable (Achtung: Auch hier maximal 8 Zeichen und keine Zahl am Anfang.)

Wir definieren also eine Variable, die speichert, was der menschliche Spieler gewürfelt hat, eine für das Ergebnis des Rechners und noch eine dafür, ob weitergespielt werden soll oder nicht.

:Local mensch
:Local rechner
:Local weiter

Für Kenner: Im Gegensatz zu vielen anderen Programmiersprachen muss nicht mit einem ; abgeschlossen werden. Jede Zeile steht für einen Befehl. Wenn man mehrere Befehle in eine Zeile schreiben möchte, kann man diese durch einen : trennen.

So, jetzt speichern wir als erstes die Zufallszahl des Rechners.

:rand(6) -> rechner

Das wars schon. Der Pfeil (STO> (zwischen 2nd und Leertaste)) weist den linken Wert der Variablen zu, die rechts steht.

Für Kenner: Das ist eine Besonderheit dieser „Sprache“ und sehr gewöhnungsbedürfig. In dem meisten Programmiersprachen wird der Ausdruck der rechten Seite in der Variable gespeichert, die links vom „=“ oder „:=“ steht. Hier ist es andersherum.

Als nächstes brauchen wir die Zahl, die der menschliche Spieler gewürfelt hat. Dazu gibt es den Befehl „Input“

:Input "Was haben Sie gewürfelt?", mensch

Dadurch wird erst der Text ausgegeben und dann eine Abfrage verlang. Die Eingabe wird in „mensch“ gespeichert.

Am besten lassen wir nun einmal ausgeben, was der Rechner denn nun „gewüfelt“ hat.

:Disp ["Ich hab eine ", rechner, " gewuerfelt!"]

Die eckigen Klammern sind notwendig, wenn eine Variable mit im Text stehen soll. Für reinen Text reichen die „, wie gleich zu sehen ist.

Nun müssen wir etwas tiefer in die Programmierung eintauchen. Wir brauchen eine Möglichkeit, festzustellen, wer denn nun gewonnen hat.
Dazu dienen die If-Else-Bedingungen. Wir schreiben:

:if rechner > mensch then
:  Disp "Ich habe gewonnen. Pech gehabt!"
:elseIf rechner < mensch then
:  Disp "Glückwunsch, Sie haben gewonnen!"
:else
:  Disp "Tja, Gleichstand"
:EndIf

Dabei steht zwischen if und then die Bedingung. Else tritt ein, wenn die Bedingung nicht erfüllt ist. Hier wird also erst getestet, ob der Wert des Rechners größer ist als der des menschlichen Spieler, dann ob er kleiner ist. Tritt beides nicht ein, muss es ein Unentschieden sein.

Für Kenner: Hier sieht man die Unterschiede zu Pascal: Es gibt keine Begin-End-Blöcke. Alles, was zwischen if und ElseIf steht, gehört in den Block. Gleiches auch bei der folgenden While-Schleife. Hier gibt es nicht einmal das Schlüsselwort „do“

Das wärs dann schon. An sich könnten wir das Programm so starten. Wir hätten aber kaum Freude daran, weil wir es ständig neu aufrufen müssten. Deshalb zum Schluss noch eine Möglichkeit, eine neue Runde zu beginnen. Dazu dienen Schleifen, in diesem Fall eine „while“-Schleife.
Als erstes weisen wir der Varibale „weiter“ den Wert 1 zu.

:1->weiter

Nun sagen wir, dass die Schleife solange ausgeführt werden soll, wie in „weiter“ der Wert 1 gespeichert ist.

:while weiter = 1
:   .... Anweisungen ....
:endWhile

Ganz am Ende, aber noch vor das „EndWhile“ kommt nun die Frage, ob man das Spiel beenden oder fortsetzen möchte:

:Pause
:PopUp {"Neue Runde","Ende"}, weiter

Der Befehl „Pause“ dient nur dazu, dem Spieler ein bisschen Zeit zu lassen, das Ergebnis zu betrachten, bevor die Abfrage kommt (Ihr könnt es ja mal weglassen und gucken, was passiert). „PopUp“ erzeugt ein Auswahlfenster. Wenn „Neue Runde“ gewählt wird, wird in „weiter“ wieder der Wert 1 gespeichert, bei „Ende“ der Wert 2.

So, jetzt nochmal im Ganzen:

:wuerfeln()
:Prgm
:  Local mensch
:  Local rechner
:  Local weiter
:  1->weiter
:  while weiter=1
:     rand(6) -> rechner
:     Input "Was haben Sie gewürfelt?", mensch
:     Disp ["Ich hab eine ", rechner, " gewuerfelt!"]
:     if rechner > mensch then
:       Disp "Ich habe gewonnen! Pech gehabt!"
:     elseIf rechner < mensch then
:       Disp "Glückwunsch, Sie haben gewonnen!"
:     else
:       Disp "Tja, Gleichstand!"
:     EndIf
:     Pause
:     PopUp {"Neue Runde","Ende"}, weiter
:  EndWhile
:EndPrgm

Aufgerufen wird das Programm, indem man im Home-Modus (also da, wo man sonst alles Mögliche rechnet) einfach „wuerfeln()“ eingibt und „Enter“ drückt. Schon gehts los.

Das Programm hat einen kleinen Fehler: Es verlässt sich darauf, dass der menschliche Spieler auch wirklich das eingibt, was er gewürfelt hat. Theoretisch kann hier auch -0.5 eingegeben werden, was in der Realität natürlich niemals gewürfelt werden kann.

So, nun noch ein wesentlich interessanteres Programm, allerdings ohne Erklärungen. Wenn ihr Lust habt, tippt es ab und probiert es aus. Hier spielt der Rechner allerdings nicht mit, ihr braucht schon einen menschlichen Gegenspieler…
Achtung: Die Ladezeiten sind ziemlich groß und es wird die Batterie sehr stark in Anspruch nehmen. Also übertreibt es nicht.

Anmerkungen: Ich hab an einigen Stellen Kommentare rangeschrieben (//[2]) zum Beispiel. In diesem Fällen will ich euch darauf hinweisen, dass man es besser anders schreiben sollte als im Code-Feld, das manche Zeichen nicht darstellen kann.. Diese Kommentare sollen nicht mit übernommen werden.
[1] Hier würde ich empfehlen, das > durch ein ≠ zu ersetzen.
[2] Das <= bzw. >= soll ein Ersatz für ≤ bzw. ≥ sein. Mit dem CAS kann man diese Zeichen ja mit „grüne-Raute-Taste“ + „=“ bzw. + „0“ bzw. + „1“ darstellen lassen.

:vierwin()
:Prgm
:Lbl start
:Local feld
:newMat(7,10)->feld
:Local spalte
:Local zeile
:Local anzahl
:Local spieler: 1->spieler
:While true
:PopUp{"Spalte1","Spalte2","Spalte3","Spalte4","Spalte5","Spalte5","Spalte7","Spalte8","Spalte9","Spalte10"},spalte
:  7->zeile
:  While feld[zeile, spalte] > 0    //Siehe Anmerkung [1] oben....
:    zeile-1 -> zeile
:  EndWhile
:  spieler->feld[zeile,spalte]
:  Disp feld
:  0->anzahl
:  If zeile <= 4 Then     //Siehe Anmerkung [2] oben  ...
:    For i,0,3,1
:      If feld[zeile + i, spalte] = spieler Then
:        anzahl+1 -> anzahl
:      EndIf
:    EndFor
:    If anzahl >= 4 Then       //Siehe Anmerkung [2] oben...
:      Goto gewinn
:    EndIf
:    0->anzahl
:  EndIf
:  For i,-3,0,1
:    For j,0,3,1
:      If spalte + i + j > 0 and spalte + i + j <= 10 Then  //[2]
:        If feld[zeile, spalte + i + j] = spieler Then
:          anzahl + 1 -> anzahl
:        EndIf
:      EndIf
:    EndFor
:    If anzahl >= 4 Then
:       Goto gewinn
:    EndIf
:    0->anzahl
:  EndFor

:  For i, -3, 0, 1
:    For j, 0, 3, 1
:      If spalte + i + j > 0 and spalte + i + j <= 10 and zeile + i + j > 0 and zeile + i + j <= 7 Then   //[2]
:        If feld[zeile+i+j, spalte+i+j] = spieler Then
:          anzahl + 1 -> anzahl
:        EndIf
:      EndIf
:    EndFor
:    If anzahl >= 4 Then
:      Goto gewinn
:    EndIf
:    0->anzahl
:  EndFor

:  For i, -3, 0, 1
:    For j, 0, 3, 1
:      If spalte + i + j > 0 and spalte + i + j <= 10 and zeile - i - j > 0 and zeile - i - j <= 7 Then          //[2]
:        If feld[zeile-i-j, spalte+i+j] = spieler Then
:          anzahl + 1 -> anzahl
:        EndIf
:     EndIf
:    EndFor
:    If anzahl >= 4 Then
:      Goto gewinn
:    EndIf
:    0->anzahl
:  EndFor

: mod(spieler, 2) + 1 -> spieler
:  Pause
:EndWhile
:Lbl gewinn
:  Disp ["Spieler ", spieler, " hat gewonnen!"]
:  PopUp{"Neues Spiel", "Ende"},weiter
:  If weiter = 1 Then
:    Goto start
:  EndIf
:EndPrgm