 |
|
| Startseite : Mobility : OPL Kurs |
 | ||
 |
OPL Kurs, Teil 4 | Aktualisierung 2007-03-01 |
| ||
| 01: Einführung
02: Menüs und mehr 03: Basics, Zufall & Mathetrainer 04: Spielend lernen - Würfel, Bandit & Lotto 05: Datenbanken - Neu/Ändern/Löschen |
06: Datenbanken - Suchen/Gehen Zu
07: Gezielte Textausgabe 08: Fensterl'n mit dem Psion 09: Zeichnen mit Grips |
| |
| |
| Spielend lernen - Würfel, Bandit & Lotto |
| In dieser Folge werden wir das Beispielprogramm, das sich den Zufallsgenerator zunutze macht, mit drei weiteren Unterprogrammen komplettieren. Das gibt Ihnen die Möglichkeit, weiter OPL-Befehle und -Funktionen kennenzulernen.
Rücken Sie also Ihren Psion zurecht, und öffnen Sie den OPL-Editor. Sie können sich etwas Schreibarbeit sparen, wenn Sie die Datei vom letzten Mal hernehmen und sie unter einem neuen Namen abspeichern, denn ein Teil der Module (synonym: Prozeduren, Unterprogramme, Programmteil, Programm-Modul) werden wir wiederverwenden. Unseren Werte-Generator (PROC zufall:) hatten wir ja gleich auf Zuwachs angelegt, er wird unverändert vom letzten Mal übernommen. Wir wollen ihn nun für weitere Programmteile nutzbar machen. So werden wir das Programm um die Komponenten "Würfel", "Slotmaschine" (oder auch als "Einarmiger Bandit" bekannt) und "Lottoziehung" erweitern. Diese werden (wie bereits der Mathe-Trainer PROC mathe:) in jeweils einer eigenen Prozedur untergebracht. Die neuen Module sollen (wie zuvor der Mathe-Trainer auch) vom Hauptprogramm PROC main: aufgerufen werden. Wir werden es daher modifizieren müssen. Bevor wir uns jedoch an diese Aufgabe machen, spendieren wir statt fertiger Unterprogramme zuerst einmal nur die Rahmen der neuen Module. Schließlich soll der Aufruf dieser Modul nicht ins Leere laufen und eine Fehlermeldung produzieren. |
| Pro 1 |
PROC wuerfel: ENDP PROC bandit: ENDP PROC lotto: ENDP |
Aufgerufen wird... |
| Jetzt sorgen wir dafür, daß die einzelnen Programmteile gezielt aufgerufen werden können. Dazu erhält unsere gute alte PROC main: eine Schleife, in der ein Menü gezeigt wird, mit dem man einerseits die Auswahl treffen, andererseits das Programm sauber beenden kann. |
| Pro 2 |
PROC main:
global zahl%(7)
local taste%
font 268436068,1
randomize minute + second
do
cls
print : print
print "Wähle aus:"
print "1 - Mathe"
print "2 - Würfel"
print "3 - Bandit"
print "4 - Lotto"
print "0 - Ende"
taste% = GET
IF taste% = %1
mathe:
elseif taste% = %2
wuerfel:
elseif taste% = %3
bandit:
elseif taste% = %4
lotto:
endif
until taste% = %0
endp |
| Wenn Sie den Text abtippen und an die Spitze vor allen anderen Modulen anordnen, haben Sie bereits das lauffähige Kern-Programm vor sich. Nach dem Übersetzen und Starten wird das Menü dargestellt. Jede Punkt ist eine Ziffer zugeordnet. Drückt man auf eine der Ziffern auf der Tastatur, wird der Tastendruck in der Variablen taste% abgelegt und in der folgenden IF/ELSE/ENDIF - Konstruktion ausgewertet. Als Folge der Auswertung wird zu dem jeweils angegebenen Modul verzweigt. Dieses wird abgearbeitet und gibt die Kontrolle an PROC main: zurück, wo der DO/UNTIL Kreislauf solange fortgesetzt wird, bis jemand auf die "Null"-Taste drückt. Dadurch wird die Bedingung "UNTIL taste%=%0" erfüllt und das Programm in den verdienten Ruhestand geschickt.
Sie finden im Programmtext einige neue Dinge vor, über die es sich lohnt, ausführlich zu sprechen - Sie werden ihnen immer wieder begegnen. |
Eingaben mit GET |
| Auch im Menü müssen wir wieder dem Computer über die Tastatur mitteilen, was wir eigentlich von ihm wollen. Eine Methode dazu ist uns beim Mathe-Trainer über den Weg gelaufen: INPUT. Die hat jedoch neben ihren zugestandenen Vorteilen einen gravierenden Nachteil: Nach Eingabeende muß jedesmal noch die [ENTER] betätigt werden. Bei PROC main: greifen wir daher lieber auf eine Lösung mit GET zurück. GET - bisher nur als "Programmstopper" kennengelernt - ist recht flexibel gerade für Eingaben von nur einem Zeichen zu gebrauchen. Dahinter verbirgt sich nämlich eine Funktion, die den Tastaturcode der gedrückten Taste zurückliefert, man muß nur danach fragen ... In der Praxis kann man den zurückgelieferten Wert einer Variablen zuordnen und so der Weiterverwendung zuführen (taste%=GET).
Um mit dem Tastaturcode etwas anfangen zu können, sollte man ihn schon kennen. Aber woher nehmen, ohne zu stehlen und wenn das Handbuch nicht in der Nähe ist? Ganz einfach: Man ermittelt ihn selber. |
Heran "tasten" |
| In Ihrer Programmierpraxis sollen Sie zu dieser Arbeitsweise ausdrücklich aufgefordert sein. Benutzen Sie einfache und übersichtliche Programmstückchen, um sich einen Überblick über die Arbeitsweise von Befehlen und Funktionen zu verschaffen. Sie müssen nicht immer "aus dem Ei gepellt" sein, sondern lediglich funktionieren. Wir führen Ihnen das hier am Beispiel GET vor. So ganz nebenher erfahren Sie etwas über das Thema "Werteumwandlung". |
| Pro 3 |
PROC get1:
local taste%
do
taste% = GET
print taste%, "=", chr$(taste%)
until taste% = %q rem "q"-Taste
endp |
| In einer DO/UNTIL - Schleife wird auf die Tastatureingabe gewartet. Nach jedem Tastendruck wird auf dem Bildschirm der Tastaturcode ausgegeben. "CHR$(taste%)" bewirkt, daß auch das gedruckte Zeichen ("character") dargestellt wird, da diese Funktion eben die Umwandlung des Tastaturcodes (Integerzahlen) in einen einstelligen String ("Buchstabe") vornimmt. Der ließe sich auch einer Variablen zuweisen (z.B.: zeichen$=CHR$(65), das ist ein "A"), was aber in PROC get1: nicht erforderlich ist, da nur dargestellt und nicht verarbeitet werden soll.
Wenn Sie mit der Tastatureingabe experimentieren, stellen Sie fest, daß Werte unter 33 gar nicht auf dem Bildschirm ausgegeben werden. Ursache ist der ASCII-Zeichensatz, der neben Buchstaben, Zahlen usw. in dem reservierten Wertebereich 1..32 sogenannte Steuerzeichen enthält. Probieren Sie einmal die Eingabe von [Strg+G] - ein Pieps ertönt, weil der Wert "7" das Steuerzeichen "BELL" darstellt. In der Praxis ließe sich das nutzen, indem man für einen kurzen Piepser schreibt: print chr$(7) (OPL stellt hier jedoch eine bessere Variante mit BEEP (dauer%, frequenz%) zur Verfügung |
der %-Effekt |
| Nun muß man aber nicht jedem Fall den Tastaturcode kennen, denn OPL hat uns ein prima Hilfsmittel in die Hand gegeben, das wir in PROC get1: auch gleich benutzt haben: eine vordefinierte Festwertzahl (Konstante), der Bezeichner festgeschrieben ist. Die Kombination von Prozentzeichen ("%"), gefolgt von einem Zeichen, das auch die Tastatur erzeugt werden kann ist in OPL eine solche Konstante, die auch gleich den Tastaturcode enthält. Beispiel: %A repräsentiert den Wert 65. Will man also Vergleiche anstellen, kann man diese Konstanten benutzen. In PROC get1: haben wir so die Abbruchbedingung definiert: "Beende das Programm, wenn die Taste 'q' gedrückt wurde" oder eben "UNTIL taste% = %q"
Will man aber auf die "nichtdruckenden" Tasten [ESC] und [ENTER] reagieren, sollte man sich die Werte einfach merken: 27 bzw. 13. |
String gehen auch |
| Das Programm PROC get2: soll zeigen, daß auch Buchstaben direkt zurückgegeben werden können, wenn GET in der Form GET$ eingesetzt wird. Der Wert muß dann natürlich einem einstelligen String zugeordnet werden! |
| Pro 2 |
PROC get2:
local taste$(1)
do
taste$ = GET$
print taste$,"=", ASC(taste$)
until lower$(taste$) = "q" rem "quit"
ENDP |
| Den zugehörigen Integerwert errechnet die Funktion ASC(taste$). Diese Funktion arbeitet auch mit längeren Strings im Argument, berücksichtigt aber grundsätzlich nur das allererste Zeichen.
GET$ ist hervorragend für Abfragen geeignet, die geradezu nach Buchstabennutzung schreien: J/N für ja/nein etc. Doch was wird der Benutzer dann wirklich eingeben? Einen Groß- oder einen Kleinbuchstaben? Am besten, wir sorgen dafür, daß das am Ende keine Rolle spielt. Zu diesem Zweck lassen wir den String einfach in ein bestimmtes Format umwandeln sagen wir in "Buchstabenzwerge". OPL bietet uns dazu LOWER$(taste$) an. Alles was in taste$ steht, wird als kleingeschrieben interpretiert, der String selber aber nicht verändert. Man ist so in der Lage, die Abbruchbedingung in PROC get2: mit "q" zu vergleichen, egal ob "q" oder "Q" getippt wurde. Das Gegenstück zu LOWER$() ist UPPER$(). Probieren Sie es selber! |
Hier geht's raus |
| Sollte Sie sich bei solchen Gelegenheiten einmal vertun und der Psion kommt aus einer unendlichen Schleife nicht mehr heraus, d.h. er reagiert auf keine Eingabe mehr - keine Panik. Drücken Sie auf die Systemtaste, um in den Systembildschirm zu kommen und beenden Sie das laufende OPO-Programm in der gerätespezifischen Art. Beim Psion Serie 5: [Umschalt+Strg+G] drücken, damit alle laufenden Programme gelistet werden und das Programm schließen.
Nach dieser Erläuterungen finden sie sich auf Anhieb in PROC main: zurecht. So wenden wir uns nun dem nächsten Schritt zu. |
Der Würfel rollt |
| PROC würfel: bietet nichts, was Sie mit dem bisher erworbenen Wissen nicht abdecken könnten. |
| Pro 5 |
PROC würfel:
local taste%
do
zufall:(1,6)
cls
print : print
print " würfel" : print
print " -->", zahl%,(1)
print
print "Enter = noch einmal, ESC = Ende"
taste% = get
until taste% = 27
endp |
| Lediglich eine einzige Zufallszahl wird benötigt, deren Maximalwert 6 sein soll. |
Bandit zieht drei |
| Auch PROC bandit: - die Simulation eines einarmigen Banditen, der Gewinn verkündet, wenn alle drei Zufallszahlen den gleichen Wert besitzen - bietet keine programmtechnischen Höhepunkte mehr. Variieren Sie ein wenig den Maximalwert. Je größer der Wert ist, desto bessere "Karten" hat die Bank und Sie verlieren! Erinnert Sie das nicht irgendwie an das "richtige" Leben? |
| Pro 6 |
PROC bandit:
LOCAL taste%
do
zufall:(3,4)
CLS
PRINT : PRINT
PRINT " Gewinnspiel Bandit"
PRINT " Drei gleiche Ziffern gewinnen!"
PRINT
PRINT " --> ", zahl%(1),"-", zahl%(2),"-", zahl%(3),"-"
PRINT
IF zahl%(1) = zahl%(2) AND zahl%(1) = zahl%(3)
PRINT "Gewonnen! Drei gleiche Zahlen!"
ELSE
PRINT "Verloren! Pechvogel!"
ENDIF
PRINT
PRINT "Enter = noch einmal, ESC = Ende"
taste% = GET
UNTIL taste% = 27
ENDP |
| Die Meldung "Gewonnen" bekommen Sie immer dann, wenn die zweite der ersten Zahl gleicht UND das ebenso für den Vergleich der dritten mit der ersten gilt. Programmtechnisch verknüpft man folgerichtig diese beiden Bedingungen bei IF-Abfrage mit dem logischen Operator AND. D.h., nur wenn beide Teilbedingungen richtig sind, wird in diesen Programmzweig eingebogen.
Wenn mehrere Bedingungen zutreffen dürfen, damit ein bestimmter Programmteil abgearbeitet wird, benutzt man den logischen Operator OR (ODER). Etwa so: WENN es Äpfel sind ODER Birnen ODER Pflaumen, DANN handelt es sich um Obst, ANSONSTEN ist es irgendetwas anderes. |
So nicht! |
| Widmen wir uns nun dem, was Mittwochs und Sonntags die halbe Nation um den Verstand bringt: Lotto. Wir kreieren hier einmal unser eigenes Lotto "6 aus 45". Dazu simulieren wir im folgenden die Ziehungsmaschine, indem wir von unserem Zufallsgenerator 7 Zahlen (6 + Zusatzzahl) abfordern, dessen Maximalwert 45 betragen soll. Das folgende Programm erledigt das so: |
| Pro 7 |
PROC lotto1:
local n%
cls
zufall:(7,45)
n% = 1
do
print zahl%(n%),
n% = n% + 1
until n% > 7
get
endp |
| Wir haben es ein bischen schlicht gehalten, denn nach wenigen Ziehungsversuchen merken Sie bereits: es treten Zahlen doppelt auf. Was uns beim "Banditen" noch willkommen war, führt hier zum Chaos! Es sieht ganz danach aus, als müßten wir unsere Anstrengungen vergrößern. Und wenn wir uns einmal dazu durchgedrungen haben, sortieren wir die Zahlen am Ende auch gleich noch in einer aufsteigenden Reihenfolge... |
Einer wird gewinnen |
| Sehen Sie sich das Modul zuerst als Ganzes an, wir untergliedern es dann Stück für Stück. Sie können am Ende dieses "Lotto" nach Ihrem Geschmack abändern. |
| Pro 8 |
PROC lotto:
local lottoz%(7), taste%, aktpos%, suchpos%, max%
local links%, rechts%, temp%, endwert%
do
cls
aktpos% = 1
max% = 45
while aktpos% <= 7
lottoz%(aktpos%) = 1 + int (rnd * max%)
suchpos% = 1
while suchpos% < aktpos%
if lottoz%(suchpos%) = lottoz%(aktpos%)
break
else
suchpos% = suchpos% +1
endif
endwh
if suchpos% = aktpos%
aktpos% = aktpos% + 1
endif
endwh
links% = 1
endwert% = 6
do
rechts% = rechts% + 1
do
if lottoz%(rechts) < lottoz%(links)
temp% = lottoz%(links)
lottoz%(links%) = lottoz%(rechts%)
lottoz%(rechts%) = temp%
endif
rechts% = rechts% + 1
until rechts% > endwert%
links% = links% + 1
until links% = endwert%
print
print"lotto - diese zahlen werden gezogen:"
print
aktpos% = 1
do
if lottoz%(aktpos%) < 10
print " ";
endif
print lottoz%(aktpos%),
until aktpos% > 6
print "zusatzzahl", lottoz%(aktpos%)
print
print "Enter = noch einmal, ESC = Ende"
taste% = get
until taste% = 27
endp |
| Das Modul unterteilt sich in drei wesentliche Abschnitte: Zahlen holen und miteinander vergleichen, sortieren und schließlich ausgeben.
An der Deklaration der Variablen erkennen Sie, daß wir uns (der Übersicht halber) ein neues Variablenfeld für die Lotto-Zahlenreihe genehmigt haben. Den Variablen haben wir etwas (hoffentlich) verständlichere Namen gegeben. Weiterhin benutzen könnten wir den Zufallswert-Generator PROC zufall:, in diesem Falle wäre es aber eher umständlich und unübersichtlich, denn wir benötigen jeweils nur einen einzelnen Wert. Deshalb beschaffen wir ihn uns unmittelbar durch die unspektakuläre Programmzeile lottoz%(aktpos%) = 1 + INT (RND * max%). |
Auf keinen Fall doppelt! |
| Was sich nun im Programm abspielt, funktioniert genau so, als würden Sie es selber tun:
Stellen Sie sich vor, Sie haben 7 von links nach rechts durchnumerierte Fächer wie sie auf alten Postämtern noch heute zum Sortieren verwendet werden. Daneben steht ein Hut mit einer großen Anzahl von auf Zetteln notierten zufälligen Nummern von 1 bis 45 darin - es kommen also mit Sicherheit alle Werte mehrfach vor! Aus diesem ziehen Sie nun die erste Zahl. Sie muß nicht verglichen werden, sie ist im Moment ja die einzige. Legen Sie sie einfach in das Fach 1 ab. Bereits die Zweite gezogene Zahl muß einem Vergleich unterzogen werden. Sie greifen sie sich also und sehen nach, ob sie mit der Zahl in Fach eins identisch ist. Ist das der Fall, wird einfach eine neue Zahl gezogen und der Vergleich beginnt von vorn. Sowie beide Zahlen unterschiedlich sind, wird die zuletzt gezogenen in Fach zwei abgelegt. Wir stellen uns vor Fach drei und greifen erneut in den Hut. Der Vergleich beginnt wieder mit Fach eins. Bereits hier besteht die Möglichkeit, daß die Zahlen übereinstimmen. In diesem Fall müßte Fach zwei gar nicht erst geprüft werden, wir holen uns sofort eine neue Zahl. Sind aber die neue und die Zahl in Fach eins nicht identisch, wird mit Fach zwei verglichen. Bei Identität wird eine neue Zahl gebraucht, ansonsten kommt die zuletzt gezogenen Zahl in Fach drei. |
Verschachtelt |
| Zur Realisierung dieser Strategie haben wir in unserem Programm zwei ineinander verschachtelte Schleifen angewandt. Die äußere sorgt dafür, daß am Ende sieben Zahlen im Feld lottoz%() stehen. Daß sie untereinander verschieden sind, organisiert die innere Schleife. Die Zählvariable für die Außenschleife ist aktpos% (aktuelle Position, Feldnummer). Es ist die Fachnummer, vor der wir stehen bleiben, wenn wir eine neue Nummer ziehen und begutachten.
In der Innenschleife dient uns suchpos% als Zähler. Er steuert, in welches Fach wir sehen sollen, um den Vergleich durchzuführen. Da wir immer wieder mit Fach eins beginnen müssen, wird der suchpos% - Wert eben auch vor dem Schleifeneintritt auf eins gesetzt und im Fortschreiten immer weiter erhöht. Bei positivem Verlauf (keine doppelte Zahl) stoppt das Hochzählen erst, wenn der Zählerwert suchpos% den Wert von aktpos% erreicht. In diesem Falle wird auch die Schleife abgebrochen, denn die neu gezogene Zahl mit sich selber zu vergleichen wäre einfach sinnlos. Wird eine identische Zahl bemerkt, kommt der Vergleichsprozeß sofort zum Stillstand - die Schleife wird durch die Anweisung BREAK sofort verlassen. Das Programm setzt seine Arbeit dann erst hinter ENDWH fort. Da die Bedingung "IF suchpos%=aktpos%" nicht stimmt, wird lediglich ein neuer Wert "gezogen", während der äußere Zähler an seiner Position - quasi vor dem Fach - verharrt. Ist der äußere Zähler durchgelaufen, haben wir erst einmal einen Zahlensalat, aber immerhin alles Unikate und das Zwischenziel erreicht. |
Sortierte Blasen |
| Sortieren. Ein nicht ganz einfaches Thema, denn es gibt diverse Verfahren, die der Fachmann je nach Einsatzzweck auswählt. Da wir es hier nicht mit einem Riesenberg von Zahlen zu tun haben, sind wir in der Auswahl nicht begrenzt und greifen aus dem Angebot die Bubble Sort Methode heraus. Hier werden systematisch Werte verglichen und die jeweils kleineren und größeren in entgegengesetzte Positionen verschoben. Die großen steigen dabei quasi wie Blasen nach oben auf, was der Methode den anschaulichen Namen gegeben hat.
Greifen wir wieder unser Beispiel mit den Fächern auf. Wir wollen erreichen, daß im Fach mit der kleinsten Nummer auch die kleinste Zahl liegt. Fach sieben wird ausgeklammert - das ist die Zusatzzahl. Das Prinzip geht so: Nimm aus dem ersten Fach den Zettel mit der gezogenen Zahl. Vergleiche sie mit der in Fach zwei. Ist die Zahl aus Fach zwei kleiner, lege sie ins Fach eins, die andere in Fach zwei. Nimm wieder die Zahl aus Fach eins und vergleiche sie diesmal mit der in Fach drei. Ein Austausch ist nur erforderlich, wenn die Zahl in Fach drei kleiner ist. So vergleicht man nach und nach die aktuelle Zahl in Fach eins mit den Werten in den andren Fächern. Nach Vergleich mit Fach sechs endet die erste Runde. Im Ergebnis hat man nun mit Sicherheit im Fach eins die kleinste Zahl! Daher kann man diese Fach nun auch getrost vergessen. Gedanklich stellt man sich nun Fach zwei, vergleicht Zug um Zug mit den weiter rechts liegenden Zahlen und tauscht nach obigen Prinzip die Plätze, wenn erforderlich. Nach diesem Durchgang liegt nun die zweitkleinste Zahl in Fach zwei. Wir liegen also richtig mit unserer Methode. Setzen Sie das Gedankenspiel selbst weiter fort - Sie wissen alles, was man dazu braucht. |
Verschleif noch mal |
| Im Programmtext finden sich alle beschriebenen Tätigkeiten wieder. Wie bereits beim Ziehen der Zahlen läßt sich das Problem sehr schön mit einer verschachtelten Schleife bearbeiten. Für die Fachnummer, aus der wir die Zahl holen, die mit allen anderen verglichen wird, steht die Variable links%. Sie wird immer dann um eine weitergezählt, wenn die Vergleichsreihe mit Fach sechs fertig ist ("äußere Schleife").
Das kleinste Fach, mit dem verglichen werden kann, befindet sich eine Position nach rechts. Wenn also in die Vergleichsrunde eingetreten wird, wird der Zähler für die innere Schleife (rechts%) auf einen um eins höheren Wert als links% gesetzt: rechts% = links% + 1 Trifft die Bedingung zu, daß der rechte Wert größer ist, wird ein Tausch der Werte vorgenommen. Der ist nur mit Hilfe einer zusätzlichen Variablen zu bewerkstelligen - ein direkter Austausch funktioniert nicht! Sie können das gern in einem separaten Programm erproben. Ist die innere Schleife beim Fach sechs angelangt, wird der Zähler rechts% noch einmal erhöht (Wert=7) und erfüllt so die Abbruchbedingung (rechts% ist größer als endwert%, der ja anfangs den Wert 6 bekommen hat). Weiter geht's mit der äußeren Schleife im Sinne der prinzipiellen Erläuterungen... |
Die Zahlen lauten... |
| Daß nun die Zahlen wirklich sortiert vorliegen, beweisen wir jetzt mit dem Teil 3 dieses Moduls. Die Ausgabe der Zahlen dürfte Sie als frisch gebackener Schleifenexperte nicht mehr in Verlegenheit bringen. Zwei Kleinigkeiten sind noch zu erwähnen. Wir haben den Zahlen, die kleiner als zehn sind, noch eine Leerstelle vor der "richtigen" Zahl spendiert, damit die Abstände gleichmäßiger erscheinen. Außerdem lassen wir die Zahlen nacheinander (und nicht Zeile um Zeile) ausgeben. Das Geheimnis ist ein Komma oder ein Semikolon, das am Ende der PRINT - Zeile stehen muß, damit der sonst übliche Zeilenumbruch verhindert wird. Verwenden Sie ein Semikolon, wenn der folgende PRINT-Befehl keine Lücke lassen soll und ein Komma, wenn eine Lücke (ein Leerzeichen breit) eingeschoben werden soll. Das funktioniert auch innerhalb einer PRINT - Zeile:
Wenn anzahl% den Wert "3" hätte, ergäbe print "Der Baum trägt", anzahl%, "Birnen." den Bildschirmausdruck: Der Baum trägt 3 Birnen. Unser Programm ist nun vollständig. Insgesamt gehören diese Module dazu: main:, zufall:, mathe:, würfel:, bandit: und lotto:. Stellen Sie PROC main: an die Spitze aller Module, lassen Sie es übersetzen und erfreuen sich am Ergebnis. Leider sind nicht alle Unterprogramme lauffähig. |
| Pro 9 |
PROC main:
GLOBAL zahl%(7)
LOCAL taste%
FONT 268436068,1
RANDOMIZE MINUTE + SECOND
DO
CLS
PRINT : PRINT
PRINT "Wähle aus:"
PRINT "1 - Mathe"
PRINT "2 - Würfel"
PRINT "3 - Bandit"
PRINT "4 - Lotto"
PRINT "0 - Ende"
taste% = GET
IF taste% = %1
mathe:
ELSEIF taste% = %2
würfel:
ELSEIF taste% = %3
bandit:
ELSEIF taste% = %4
lotto:
ENDIF
UNTIL taste% = %0
ENDP
proc zufall:(anzahl%,max%)
local n%
n%=1
while n%<= anzahl%
zahl%(n%)=1+int(rnd * max%)
n%=n%+1
endwh
endp
PROC mathe:
LOCAL eingabe%
DO
CLS
zufall: (2,10)
PRINT : PRINT
PRINT "Berechne:",zahl%(1),"*",zahl%(2)
PRINT "Gib das Ergebnis ein!"
PRINT "(Null beendet das Programm)"
INPUT eingabe%
IF eingabe% = zahl%(1) * zahl%(2)
PRINT "Ja!. Das ist richtig!"
ELSE
PRINT "Nee! Das stimmt leider nicht!"
ENDIF
rem IF eingabe% <>
PRINT "Beliebige Taste drücken"
GET
rem ENDIF
UNTIL eingabe%=0
ENDP
PROC würfel:
LOCAL taste%
DO
zufall:(1,6)
CLS
PRINT : PRINT
PRINT " würfel" : PRINT
PRINT " -------> ", zahl%(1)
PRINT
PRINT "Enter = noch einmal, ESC = Ende"
taste% = GET
UNTIL taste% = 27
ENDP
PROC bandit:
LOCAL taste%
DO
zufall:(3,4)
CLS
PRINT : PRINT
PRINT " Gewinnspiel Bandit"
PRINT " Drei gleiche Ziffern gewinnen!"
PRINT
PRINT " -----> ", zahl%(1),"-", zahl%(2),"-", zahl%(3),"-"
PRINT
IF zahl%(1) = zahl%(2) AND zahl%(1) = zahl%(3)
PRINT "Gewonnen! Drei gleiche Zahlen!"
ELSE
PRINT "Verloren! Pechvogel!"
ENDIF
PRINT
PRINT "Enter = noch einmal, ESC = Ende"
taste% = GET
UNTIL taste% = 27
ENDP
PROC lotto:
LOCAL lottoz%(7), taste%, aktpos%, suchpos%, max%
LOCAL links%, rechts%, temp%, endwert%
DO
CLS
aktpos% = 1
max% = 45
WHILE aktpos% <= 7
lottoz%(aktpos%) = 1 + INT (RND * max%)
suchpos% = 1
WHILE suchpos% < aktpos%
IF lottoz%(suchpos%) = lottoz%(aktpos%)
BREAK
ELSE
suchpos% = suchpos% +1
ENDIF
ENDWH
IF suchpos% = aktpos%
aktpos% = aktpos% + 1
ENDIF
ENDWH
links% = 1
endwert% = 6
DO
rechts% = rechts% + 1
DO
rem IF lottoz%(rechts%) < lottoz%(links%)
rem temp% = lottoz%(links%)
rem lottoz%(links%) = lottoz%(rechts%)
rem lottoz%(rechts%) = temp%
rem ENDIF
rechts% = rechts% + 1
UNTIL rechts% > endwert%
links% = links% + 1
UNTIL links% = endwert%
PRINT
PRINT "Lotto - diese Zahlen werden gezogen:"
PRINT
aktpos% = 1
DO
IF lottoz%(aktpos%) < 10
PRINT " ";
ENDIF
PRINT lottoz%(aktpos%),
aktpos% = aktpos% + 1
UNTIL aktpos% > 6
PRINT "Zusatzzahl ", lottoz%(aktpos%)
PRINT
PRINT "Enter = noch einmal, ESC = Ende"
taste% = GET
UNTIL taste% = 27
ENDP |
|
| OPL am Psion von Rudolf Pöchacker (http://members.xoom.com/poechacker/) |
Copyright © 2002-2007 Mobile Times Business Club
Zurück zum Menü Nach Oben |