Meine To-Do Liste für die Osterferien sieht so aus:

1. Ein kleines PHP-OOP-System basteln, mit dem ich z.B. MySQL-Befehle und Designangaben effektiver programmieren kann

2. Endlich die Version 2.0 des TI-BASIC Tutorials beginnen. Mein Ziel ist es diese bis zum Ende der Ferien in zwei Wochen fertig gestellt zu haben.

Ansonsten nehme ich mit einigen Freunden an der Intel-Leibniz-Challenge (schon wieder so ein Wettbewerb -.- ^^) 2009 teil, bei der wir (wie immer) die Aufgaben rund um Programmierung und Physik wie immer am letzten Tag bearbeiten.

Um es zu spielen benötigt man 2 Personen. Man legt den Taschenrechner zwischen sich.
Der eine kontrolliert seine Wand mit der 9 und 3, der andere mit der 7 und der 1.

PROGRAM:PINGO
ClrHome
Disp "Pingo"
Disp "CODE BY DUBBEL"
ClrHome
[hier evt. noch weitere Informationen und Anleitung ausgeben lassen]
0->A [Geschwindigkeit mit der sich der Ball nach oben/unten bewegt]
1->B [Geschwindigkeit mit der sich der Ball nach rechts/links bewegt]
5->C [Position des Balles auf der Y-Achse]
8->D [Position des Balles auf der X-Achse]
4->E [Position der oberen Wand auf der Y-Achse]
5->F [Position der unteren Wand auf der Y-Achse]
Pause

Lbl A
If (B=1):Then [wenn der rechte Spieler dran ist (Ball bewegt sich nach rechts)]
If (G=74):Then [wenn die 9 gedrückt wurde]
If (E > 1):Then [Kollisionsabfrage]
E-1->E:F-1->F
End
End
If (G=94):Then [wenn die 3 gedrückt wurde]
If (F < 8):Then [Kollisionsabfrage]
E+1->E:F+1->F
End
End
End
If (B=-1):Then [Wiederholung nur eben für die beiden anderen Tasten]
If (G=72):Then
If (E>2):Then
E-1->E:F-1->F
End
End
If (G=92):Then
If (F<7):Then
E+1->E:F+1->F
End
End
End
ClrHome
Output(E,16,"O") [Rechte Wände]
Output(F,16,"O")
Output(E,1,"O")
Output(F,1,"O")
Output(1,1,"----------------") [Begrenzung oben/unten]
Output(8,1,"----------------")
If (C=E and (D=15 or D=2)):Then
B*-1->B:1->A [kollision mit Wänden]
End
If (C=F and (D=15 or D=2)):Then
B*-1->B:1->A
End
If (C=2 or C=7):Then
A*-1->A [Kollision mit Wänden oben/unten]
[A*-1->A stand hier nocheinmal - muss entfernt werden]
End

If (D=16 or D=1):Then
Output(4,4,"GAME OVER")
If(D=16):Then
Output(6,7,"LINKS")
Else
Output(6,6,"RECHTS")
End
Output(7,3,"HAT GEWONNEN")
PAUSE
prgmPINGO
End
Output(1,D,"I")
Output(1,D,"I")
Output(C,D,"+")
C+A->C:D+B->D [Update Positionen - hier vor vorher ein Fehler]
Output(C,D,"*")
getKey->G [Tastendrücke werden abgefangen]
Goto A

In der Theorie sieht die so aus:

Input "Eingabe:",A

In diesem Beispiel würde nun das, was der User eingibt, in der Variable A gespeichert. Mit dieser Variable kann man dann machen was man will, zum Beispiel sie ausgeben.

Wir werden nun mal einen kleinen Additionierer schreiben, also ein Taschenrechner, der nur Plus rechnen kann.

ClrHome
Disp "ADDITIONIERER"
Input "VARIABLE A:",A
Input "VARIABLE B:",B
Disp "SUMME:"
Disp A+B

Doch hier muss der User seine Eingabe ja immer mit ENTER bestätigen: Für ein actionreiches Spiel reicht es also nicht.

Dafür gibts die Funktion

getKey->A

(A ist natürlich nur eine Variable)
Wenn wir nun schreiben:

Lbl A:
getKey->A
If (A > 0)
Disp A
Goto A

Die if-Verzweigung muss hier rein, da sonst die ganze Zeit 0 ausgegeben würde, denn wenn keine Taste gedrückt wurde, ist der Wert von getKey 0.

Wenn man nun verschiedene Tasten drückt kann man die Zahlencodes für sie sehen.
Die Pfeiltasten haben z.B. für oben 25, für rechts 26, für links 24 und für unten 34. 34?
Ja richtig gelesen, denn der Code für die Tasten berechnet sich folgendermaßen:
Die erste Zahl ist die Zeile und die zweite ist die Spalte in der die Taste steht.
Y= ist ja die erste Taste ganz oben. Logischerweise hat sie den Code 11. WINDOW 12, 2nd 21 usw.
Da die Unten-Pfeiltaste zur dritten Zeile gerechnet wird, hat sie den Wert 34.
Diese Eingabemöglichkeit wird auch in dem Spiel von mir ganz unten verwendet.

Noch was zum Schluss:
Wenn ihr, während ihr im Editor seid, auf
PRGM->EXEC geht, eins auswählt und ENTER drückt, wird dieses Programm dann gestartet, wenn euer Programm bei diesem Befehl (prgmNAMEDESPRGMS) ankommt. Natürlich nur wenn dieses Programm auf dem Taschenrechner auch existiert.

Ganz zum Schluss veröffentliche ich hier nochmal den Quellcode für eines meiner Spiele: ein kleiner Snake Klon, mit KI und ohne Schwanz:

ClrHome
Output(3,5,"SNAKE")
Output(4,3,"PRESS ENTER")
Output(8,2,"CODE BY DUBBEL")
6->X
5->Y
5->B
7->D
15->E
0->P
7->N
5->O
P ause
Output(1,1,"++++++++++++++++")
Output(2,1,"+              +")
Output(3,1,"+              +")
Output(4,1,"+              +")
Output(5,1,"+              +")
Output(6,1,"+              +")
Output(7,1,"+              +")
Output(8,1,"++++++++++++++++")
Output(N,O,"*")

Lbl A:
0->C
0->G
getKey->A
If(A=26)
Then
Output(Y,X," ")
1->B
X+1->X
1->C
End
If(A=24)
Then
Output(Y,X," ")
2->B
X-1->X
1->C
End
If(A=25)
Then
Output(Y,X," ")
3->B
Y-1->Y
1->C
End
If(A=34)
Then
Output(Y,X," ")
4->B
Y+1->Y
1->C
End

If(C=0):Then
Output(Y,X, " ")

If(B=1):Then
X+1->X:End
If(B=2):Then
X-1->X:End
If(B=3):Then
Y-1->Y:End
If(B=4):Then
Y+1->Y:End
End

Output(D,E," ")
If(Q=1):Then
If(Y>D):Then
D +1->D:1->G:End
If(Y>D):Then
D -1->D:1->G:End
If (G=0):Then
If(X>E):Then
E+1->E:End
If(X<E):Then
E-1->E:End
End:0->Q
Else
1->Q:End
Output(D,E,"+")
If((Y=D and X=E) or (Y<2) or (Y>7) or (X<2) or (x>15)):Then
ClrHome
Output(1,5,"GAME OVER!")
Output(2,9,P)
Output(3,7,"PUNKTE");
Output(4,4,"PRESS ENTER")
Output(6,5,"VISIT:")
Output(7,7,"WWW.")
Output(8,1,"HAUKELUEBBERS.DE")
Pause
prgmSNAKE
Else
Output(Y,X,"O")
End
P +1->P
If(N=Y and 0=X):Then
P +100->P
randInt(2,7)->N
randInt(2,14)->O
End
Output(N,O,"*")

Output(1,7,P)
Wurzel_aus(113.1337^5)
453.45/45.5^2
66/66^5*3
Goto A

Hier nun erstmal der Programmcode:

ClrHome
0->B
Input "BASIS:",A
Input "ERGEBNIS:",C
Disp "BERECHNE..."
A^B->B
While (C != [bzw. ist nicht gleich] D)
B+0.1->B
A^B->D
Output(6,1,D);
If(D>C):Then
Disp "X KLEINER ALS"
Disp B
PAUSE
prgmMATHHELP
END [Ende der if Verzweigung]
END [Ende der While Schleife]
Disp "Ergebnis:"
Disp B 

EDIT: Einige Tage später hat uns unser damaliger Mathelehrer (http://matthias-mergner.de/) verraten, wie man das auch einfacher ausrechnen kann (log10 a / log10 b = x) – Na Toll ^^

Bisher können wir zwar Texte ausgeben, aber mehr auch nicht.

Nun kommen wir zu den Variablen.

Die kennst du ja wahrscheinlich schon aus dem Matheunterricht (wenn du nicht die ganze Zeit mit deinem TR rumspielst ): Variablen sind eine Art Minispeicherplätze für Zahlen.

Zuerst müssen wir der Variable einen Namen geben. Leider kann man nicht mehrere Buchstaben aneinanderreihen, sondern muss Namen wie x,y oder a und b nehmen.

ACHTUNG: Wenn man größere Projekte programmiert, sollte man sich unbedingt die Bedeutungen der Variablen aufschreiben, da man sonst nach einem Wochenende nix mehr versteht!

Wie kann man denn nun den Variablen Zahlen zuweisen?

5->X
3->Y
X+Y->A

A wäre in diesem Fall 8.

(Den Pfeil kann man schreiben, indem man die Taste STO-> drückt)

Eine Variable ausgeben, ist auch nicht weiter schwer:

8->A
Output(1,1,A)
Disp A

Zu beachten ist, dass Disp das Ergebnis am rechten Bildschirmrand anzeigt.

Doch wie kann man Variablen vom User einlesen lassen?

Input "Variable:",A
Disp A

Nun kann man jede Zahl eingeben und wieder auslesen lassen.

Zeit für ein kleines Experiment:

Rufe dieses Programm auf, und gebe dort z.B. 19 ein, und lass die Variable auslesen.

Schalte dann den TR aus.

Starte ihn erneut, ruf das Programm auf, und gebe jetzt A ein. Der Taschenrechner gibt wieder 19 aus. Er hat sich also die Zahl gemerkt, und behält sie auch ausgeschaltet.

Die if-Verzweigung

Zeit für ein kleines “Spiel” ^^:

Lbl A   (Der Sprungpunkt)
ClrHome       (Löscht alles auf dem Display)
randInt(1,9)->A  (A ist nun eine Zufallszahl zwischen 1 und 9)
randInt(1,9)->B
A+B->C       ( C ist nun die Summe von A und B)
Output(1,1,A)
Output(1,2,"+")
Output(1,3,B)
Disp""           (Muss ausgegeben werden, damit Input nicht die Rechnung überschreibt)
Input "Ergebnis:",D  (D ist die Eingabe des Users)
IF (D=C)    (Wenn D den gleichen Wert wie C hat)
THEN    (Dann mache)
Disp "Richtig!"   (Richtig ausgeben)
END  (Wenn das nicht so ist (D nicht gleich C ist))
IF (C	≠ D) (Wenn C nicht gleich D ist)
THEN
Disp "Falsch!"  (Falsch ausgeben)
END   (Die if Schleife beenden)
PAUSE   (aus ENTER warten)
Goto A  (Wieder zum Anfang (Sprungpunkt A) gehen

In diesem Code sind zwei neue Sachen:

- randInt

Zu finden mit 2nd + 0 und dann x bzw. R drücken. Dies ist der Katalog. Hier findet man alles, was der TR kann. Wenn man den Anfangsbuchstaben des benötigten Befehls drückt, gelangt man direkt zu ihm.

-  GOTO A:

Wenn man dieses Goto z.B. in Zeile 3 einbaut, und Lbl A: in Zeile 1 stehen hat, würde er den Befehl in Zeile 2 ewig wiederholen. Anstatt a kann man natürlich auch jeden anderen Buchstaben nehmen, und auch mehrere Gotos in ein Programm einbauen.

- IF (Bedingung):THEN:Tu dies und das:END

Wenn die Bedingung in den Klammern stimmt (das = Zeichen findet man bei 2nd + Math), wird die Aktion, die zwischen Then und End steht ausgeführt.

Wenn sie nicht wahr ist, passiert nix.

Wenn doch etwas passieren soll, wenn die Bedingung unwahr ist, dann hilft:

ELSE

Die Syntax sieht dann so aus:

: IF (Bedingung)
: THEN
: Tu irgendwas
: Else
: Tu irgendwas anderes
: END

Mit der Disp "..." Funktion kann man schon eine Menge machen.
Doch es gibt eine andere Ausgabe-Funktion, die Vor- und Nachteile hat.
Nämlich Output.
Zu finden: Prgm - I/0 - 6: Output
Vorteil von Output:
- Genaue Positionierung des Textes möglich.
Nachteil von Output:
- Man darf nicht “über dem Displayrand” schreiben. Dies erzeugt den Fehler
ERR:DOMAIN
1:Quit (um das Programm zu Beenden)
2:Goto (um den Editor zu öffnen, und den Fehler zu bearbeiten)
Doch wie funktioniert dieses Output nun?
Die Syntax (eng. für “Satzbau, hier für die Schreibweise des Befehls):

Output(2,3,"Hallo Welt")

Dieser Befehl würde nun in Zeile 2 in Spalte 3 Hallo Welt ausgeben.
Man muss allerdings wie gesagt darauf achten nicht über den Displayrand hinaus zu schreiben.

Wenn sie das Beispiel oben genauso abgetippt haben, werden sie bemerkt haben, dass die Ausgabe so aussieht:

prgmTUT
HALLO WELT

Nun soll dieses prgmPROGRAMMNAME weg.
Da hilft uns der Befehl ClearHome.
Wenn wir diesen Befehl einfügen (zu finden zwei Zeilen unter dem Output Befehl), wird alles auf dem Bildschirm gelöscht.
Der neue Code sieht also so aus:

ClrHome
:Output(2,3,"HALLO WELT")

Nun wird zunächst alles gelöscht und dann Hallo Welt ausgegeben.
Doch was wenn wir nun mehrere Sachen ausgeben wollen?

Output(2,3,"HALLO IHR!")
Output(2,3,"HALLO WELT")

Dies funktioniert nicht, da die erste Ausgabe von der zweiten überschrieben wird.
Nun könnte man den Befehl PAUSE, der die Programmausführung stoppt, und erst weitermacht, wenn der Nutzer ENTER drückt.
Zu finden ist Pause:
Prgm - CTL - 8:Pause

Output(2,3,"HALLO IHR!")
Pause
ClrHome
Output(2,3,"HALLO WELT")

Was man brauch: Einen TI-Taschenrechner, ich nutze den TI-83 Plus. Ältere Taschenrechner haben manchmal Probleme mit diesem Code, da sie eine andere Version von TI-BASIC benutzen.

Inhalt:
1. Beginn und Hallo Welt
2. Andere Möglichkeiten der Ausgabe + ClearHome
3. If-Verzweigung + Variablen
4. Input
5. Label (Goto)
6. Erstes kleines Spiel

ACHTUNG: Ich habe mir diese Sprache im Selbststudium in langweiligen Mathestunden beigebracht! Möglicherweise ist nicht alles korrekt. Wenn sie einen Fehler entdecken wäre ich dankbar über eine Mail.

Um selber ein Programm zu schreiben, muss man natürlich erstmal eins anlegen:

Klicken sie:

PRGM->NEW->ENTER

und geben sie einen Namen ein.

Direkt danach befinden sie sich im Editor.
Das erste Programm von uns wird “Hallo Welt!” ausgeben.
Eine Besonderheit ist, dass wir die Code-Befehle nicht direkt reinschreiben, sondern aus Listen auswählen.
Dies geht so:

PRGM

Nun sehen sie eine Menge Befehle.
Gehen sie nun einmal nach Rechts, und wählen sie dort

3: Disp

aus.
Sie befinden sich jetzt wieder im Editor.
Der Befehl Disp gibt eine Zeichenkette aus. Doch im Moment weiß der Befehl noch nicht, was er ausgeben soll.
Wir müssen nun in den ALPHA-Mode wechseln (2nd + ALPHA drücken).
Klicken sie nun auf ” beziehungsweise +.

Geben sie nun ihren Text ein, und schließen sie die Anführungszeichen wieder.

Der Code sieht nun so aus:

Disp "Ihr Text"

Um den Code auszuführen, müssen sie den Editor verlassen (2nd + MODE (bzw. Quit)), die Programmübersicht aufrufen (PRGM) und ihr Programm auswählen.

Sie sehen, der Taschenrechner gibt ihren Text aus. Um ihren Programmcode erneut zu bearbeiten, rufen sie erneut die Programmliste aus, gehen nach Rechts auf EDIT und wählen sie erneut ihr Programm aus.