@database "Mancala" @author Oliver Gr @(c) " 1994-96 Oliver Gr @$VER: Mancala.guide 3.47 ## 1. Oktober 1996 @node Main "Mancala" MANCALA --------- AmigaGuide f r Mancala Mancala ist 1994-95 Oliver Gr Mancala ist Freeware @{" Rechtliches " link Rechtliches} @{" Spielregeln " link Regeln} @{" Installation " link Installation} @{" Bedienung " link Bedienung} @{" - Optionsfenster " link Optionen} @{" - Spielertypen " link Typ} @{" Partie-Editor " link PEd} @{" ARexx-Befehle " link ARexx} @{" Synchronisierung " link Synchron} @{" Externe Spieler " link Extern} @{" - Variablen " link Vars} @{" - Befehle " link Bef} @{" - Beispiel " link Beispiel} @{" Das Executer-Utility " link Exec} Mancala wurde mit CanDo programmiert. CanDo ist Copyright Inovatronics Workbench ist Commodore Business Machines ARexx ist Bill Hawes (Thank you ! Great !!!) @endnode ## *** Spielregeln ********************************************* @node Rechtliches "Rechtliches" Das Rechtliche ---------------- Dieses Programm und alle mitgelieferten Dateien sind Freeware mit den folgenden Einschr nkungen: - Das Programmpaket darf immer nur komplett mit allen dazugeh rigen Dateien kopiert werden. - An keiner der Dateien d rfen ohne meine vorherige Erlaubnis Ver nderungen vorgenommen werden. - Wer Verbesserungsvorschl ge hat oder es endlich geschafft hat, einen starken Computerspieler zu programmieren, soll sich bei mir unter der unten genannten Adresse melden. Sollte seine Arbeit Verwendung finden, wird er selbstverst ndlich als Co-Autor genannt. - Wenn dieses Paket auf Disketten weitergegeben wird, darf nur eine Aufwandsentsch digung verlangt werden. Auf keinen Fall darf dieses Paket auf Disketten weitergegeben werden, die mehr als DM 3,-- oder den entsprechenden Betrag in einer anderen W hrung kosten. - Wird dieses Paket auf CD-ROM weitergegeben, darf der Preis der CD den Betrag von DM 40,-- oder den entsprechenden Betrag in einer anderen W hrung nicht bersteigen. - Dieses Paket, auch nicht Teile daraus, d rfen nicht im Rahmen einer kommerziellen Ver ffentlichung erscheinen, da dies die Nutzungsbestimmungen von CanDo ( Inovatronics) verbieten ! Daran soll der folgende Text erinnern, der mit jedem CanDo-Programm ausgeliefert werden mu This program was designed and written with CanDo v3.0 1995. Inovatronics, Inc. 8499 Greenville Ave. #209B Dallas, TX 75231 USA (214)340-4991, FAX 340-8514 CanDo, Deckbrowser and their support libraries are the copyrighted sole property of Inovatronics, Inc. Reproduction and distribution for any use other than non-commercial applications is strictly prohibited. r weitere Fragen wenden Sie sich bitte an: Oliver Gr Stemmering 46 45259 Essen Sorry, nur snail-mail, hab' noch kein Modem ! @endnode @node Regeln "Spielregeln" Die Spielregeln ----------------- Mancala spielt man zu zweit auf einem Brett mit 12 Mulden und 2 Zielfeldern. Dem ersten Spieler geh ren die oberen 6 Mulden und das linke Zielfeld, dem zweiten geh ren die unteren 6 Mulden und das rechte Zielfeld. @{" Illustration des Spielfeldes " link Mancala.guide.Bild1/main} (F r Kickstart/Workbench 3.0) @{" Illustration des Spielfeldes " system "SYS:Utilities/WDisplay Mancala.guide.Bild1"} (F r Kick/WB 2.0 mit WDisplay) Zu Beginn des Spiels liegen in jeder der 12 Mulden 4 Spielsteine. Beide Spieler versuchen nun, im Verlauf des Spiels m glichst viele Spielsteine in das eigene Zielfeld zu bringen, denn wer am Ende mehr hat, hat gewonnen. Das Spiel beginnt, wenn der Spieler 1 eine der 12 Mulden mit der Maus anklickt. Diese Mulde wird nun geleert und alle darin enthaltenen Spielsteine werden gegen den Uhrzeigersinn in die anderen Mulden verteilt. Gelangt man dabei an das eigene Zielfeld, wird der Spielstein hineingelegt und man hat einen Punkt. Das Zielfeld des anderen Spielers wird beim Verteilen einfach bersprungen. tzlich zu diesem normalen Zugschema gibt es einige Sonderregeln. Sollte der letzte Spielstein eines Zuges in das eigene Zielfeld fallen, so ist der Spieler, der den Zug ausgef hrt hat, nochmal dran. llt der letzte Spielstein eines Zuges in eine leere Mulde, so wird automatisch die dar ber- bzw. darunterliegende Mulde ebenfalls ausgeleert und f r denselben Spieler gespielt. Landet der letzte wieder in einer leeren Mulde, so wird auch diese gespielt und so weiter. Ist der Zug beendet, ist der andere Spieler dran. Das geht solange, bis oben oder unten alle Mulden leer sind. Sind also zum Beispiel die oberen 6 Mulden leer (also die von Spieler 1), so erh lt Spieler 2 automatisch alle in den unteren Mulden briggebliebenen Spielsteine und das Spiel ist beendet. Man mu also aufpassen, seine eigenen Mulden nicht zu leer werden zu lassen, denn auch der andere Spieler kann diese leeren und so eventuell das Spiel zu seinen Gunsten beenden. @endnode ## *** Installation ******************************************** @node Installation "Installation" Die Installation ------------------ Die Installation braucht man nicht gro erkl Schublade auf die Festplatte ziehen, fertig ! Es gibt zwei Versionen des Programms. Welche sie benutzen sollten und warum, lesen sie weiter unten. Viel umfangreicher sind die Vorraussetzungen zum Start: chst einmal eine schlechte Nachricht : Mancala braucht viel RAM. Mindestens 1,5 MB davon mu man in seinem Rechner haben, beser 2 MB. Jetzt eine noch schlechtere Nachricht: Die voll funktionsf hige Version von Mancala ben tigt die Libraries von CanDo ! Diese haben immer noch keine wirklich eindeutigen Weitergabebestimmungen, weshalb sie in dieser Ver ffentlichung nicht beiliegen. Da aber neben den Besitzern der Vollversion von CanDo und der Versionen von den AmigaPlus-Coverdisks und CDs wahrscheinlich auch noch viele die Dateien als Raubkopie auf ihrem Rechner haben, d rfte die Library-Version von Mancala dennoch ihre Zielgruppe finden ;-) r diejenigen, die leider nicht die Library-Version verwenden k nnen, gibt es noch das Programm "MancalaNoLib", bei dem dann leider keine externen Spieler verwendet werden k nnen. Um diese Version zu verwenden, schen Sie bitte die Datei "Mancala" und benennen dann "MancalaNoLib" um in "Mancala". Desweiteren k nnen Sie die Programme "Partie-Editor" und "Executer" sowie die Schublade "Spieler" samt Inhalt l schen, denn diese Dateien ben tigen ebenfalls die Library-Version. Alle Benutzer der Library-Version k nnen "MancalaNoLib" l schen. Sehr wichtig : Die Dateien "Mancala.info" und "Partie-Editor.info" d rfen nicht umbenannt werden !!! Wenn man die Online-Hilfe nutzen m chte, mu mlich der Pfad r die Datei "Mancala.guide", also diese Datei, bei den ToolTypes der beiden Icons unter "HilfsPfad=" eingetragen werden. Dazu klickt man das jeweilige Icon an und w hlt "Informationen" aus dem "Piktogramm"-Men der Workbench aus. Im erscheinenden Fenster klickt man auf "Neu" bzw. "New" und tr gt dann "HilfsPfad=" gefolgt vom Pfad ein. Anschlie end auf "Speichern" bzw. "Save" klicken. Fertig ! Beispiel : "RAM:Texte/Mancala.guide" + Return + Speichern Im Icon des Hauptprogrammes kann man au erdem noch das ToolType "SynchronBefehl=" eintragen. Es definiert den Pfad f r das Programm, das von der @{" Synchron-Funktion " link Synchron} aufgerufen wird. erdem sind f r ein einwandfreies Arbeiten mit Mancala einige Dateien der Workbench n - Der Font "Courier" sollte in Gr e 13 installiert sein. - In ENVARC: bzw. ENV: sollte die Datei "palette.ilbm" stehen, die die Farben der Workbench definiert. Bei meiner Workbench macht das das "Palette" Programm aus der Prefs-Schublade. erdem mu , wenn Mancala auf der Workbench laufen soll, die Workbench mindestens 3 Bitplanes (8 Farben) haben und der Screen mu mindestens eine Gr e von 640*400 Punkten haben. Es kann z.B. auch ein Screen mit dem Screenmode Hires-NonInterlaced sein, der autoscrollend ist. So kann man den Flimmerbildschirm umgehen. Erf llt die Workbench diese Vorraussetzungen nicht, so wird ein Hires-Interlaced Screen mit 640*400 Punkten und 8 Farben ge ffnet. Sind alle diese Vorkehrungen getroffen, kann Mancala problemlos per Doppelklick von der Workbench oder per Aufruf aus dem CLI gestartet werden. r den Partie-Editor sollten exakt die gleichen Dateien verf gbar sein. Ach ja, Workbench 2.0 braucht man nat rlich auch :-) @endnode ## *** Men Bedienung ****************************************** @node Bedienung "Bedienung" Die Bedienung --------------- Nachdem Mancala gestartet wurde, werden die gespeicherten Voreinstellungen geladen. Beim ersten Starten des Programmes wird sich der Screen in Rott einf rben. Mancala ver ndert die Farben des Workbenchscreens, allerdings werden diese beim Programmende wiederhergestellt. In der Mitte des Fensters ist das @{" Spielbrett " link Brett} zu sehen. Am unteren Rand des Fensters sind 6 Gadgets zu sehen : @{" NEUES SPIEL " link Neu} @{" SPIELREGELN " link CallRegeln} @{" ZUR CKNEHMEN " link Undo} @{" SPIEL BEENDEN " link Spielende} @{" OPTIONEN " link Optionen} @{" PROGRAMMENDE " link ProgEnde} erdem besitzt das Fenster noch 2 Men Projekt Utilities ---------- ---------- @{" Neues Spiel " link Neu} @{" Partie-Editor " link CallPEd} @{" Spiel beenden " link Spielende} @{" Hilfsmodus " link CallHelp} @{" Programminfo " link Info} @{" Zug r ngig machen " link Undo} @{" Greetings " link Greet} @{" Programmende " link ProgEnde} @endnode @node Brett "Das Spielbrett" @toc Bedienung Das Spielbrett ---------------- Das Spielbrett besteht aus 12 runden Mulden und 2 eckigen Mulden. Die 2 eckigen sind die Zielfelder der beiden Spieler. Das linke geh rt Spieler 1 und das rechte Spieler 2. Spielen kann man nur mit den 12 runden Mulden. Um eine Mulde zu spielen, wird sie einfach angeklickt. @endnode @node Neu "Neues Spiel" @toc Bedienung Neues Spiel ------------- -Aufruf : Rechte Amiga-Taste + n ARexx-Befehl : CallNeu Das Spielbrett wird gel scht und dann neu aufgebaut. Dann ist der linke Spieler am Zug (Spieler 1). Hiermit kann man nicht nur ein Neues Spiel beginnen, nachdem man das vorige beendet hat, sondern man kann ein laufendes Spiel abbrechen und sofort ein neues beginnen. @endnode @node Spielende "Spielende" @toc Bedienung Spiel beenden --------------- -Aufruf : Rechte Amiga-Taste + e ARexx-Befehl : CallSpielende Hiermit kann man ein bereits laufendes Spiel vorzeitig beenden. Die Steine in den beiden Zielmulden werden gez hlt und ein Requester erscheint, in dem der Sieger bekanntgegeben wird. Wenn ein Mensch gegen den Computer gespielt hat, gibt der Computer in diesem Requester seinen Kommentar zur Partie. @endnode @node CallRegeln "Spielregeln" @toc Bedienung Spielregeln ------------- Hiermit wird, falls Mancala richtig @{" installiert " link Installation} wurde, der AmigaGuide von Mancala an der Stelle ge ffnet, an der die @{" Spielregeln " link Regeln} f r Mancala nachgelesen werden k nnen. @endnode @node Info "Programminfo" @toc Bedienung Programminfo -------------- -Aufruf : Rechte Amiga-Taste + i ARexx-Befehl : CallAbout Hiermit wird ein Fenster mit Namen und Adresse des Programmautors ge ffnet. tzlich ist hier auch die Version des Programmes, das Datum der Fertigstellung dieser Version und der Name des ARexx-Ports abzulesen. Bugreports und Vorschl ge bitte mit der Versionsnummer und dem Datum an die angegebene Adresse schicken. @endnode @node Undo "Zug r ngig machen" @toc Bedienung Zug r ngig machen ----------------------- -Aufruf : Rechte Amiga-Taste + u ARexx-Befehl : CallUndo Diese Funktion macht nicht nur einfach den letzten Zug r ngig. Vielmehr verh lt sie sich in gewisser Weise intelligent. Wenn zwei Menschen gegeneinander spielen, so wird einfach nur der letzte Zug r ngig gemacht. Jeder der beiden Spieler kann also auch zum Beispiel eine Zugserie im Nachhinein anders gestalten. Spielt ein Mensch gegen den Computer, so werden so viele ngig gemacht, wie der menschliche Spieler braucht, um SEINEN letzten Zug zu korrigieren. rde man einfach nur den letzten Zug r machen und der Computer hatte gerade eine Serie, so ist nach dem R ngigmachen der Computer dran und der wird wahrscheinlich genau seinen Zug wiederholen. Spielen zwei Computerspieler gegeneinader, so bewirkt das Aufrufen dieser Funktion gar nichts. Man kann durch mehrmaliges Aufrufen dieser Funktion das Brett in den Anfangszustand zur cksezten. @endnode @node ProgEnde "Programmende" @toc Bedienung Programmende -------------- -Aufruf : Rechte Amiga-Taste + q Es wird eine Sicherheitsabfrage ge ffnet, in der sich der Benutzer seine Entscheidung nochmal gr ndlich berlegen kann. Best tigt er sein Entscheidung, wird das Mancala-Fenster bzw. der Mancala-Screen wieder geschlossen und die Originalfarben der Workbench werden wiederhergestellt. @endnode @node Greet "Greetings" @toc Bedienung Greetings ----------- -Aufruf : Rechte Amiga-Taste + g ARexx-Befehl : CallGreetings Es erscheint ein Requester, in dem der Autor diversen Leuten f r ihre Mithilfe oder ihre Ideen dankt. @endnode @node CallPEd "Partie-Editor" @toc Bedienung Partie-Editor --------------- -Aufruf : Rechte Amiga-Taste + p Hiermit kann der @{" Partie-Editor " link PEd} aus Mancala heraus aufgerufen werden. Dazu mu die separate Datei "Partie-Editor" nicht vorhanden sein. Der Editor ist ins Hauptprogramm integriert. @endnode @node CallHelp "Hilfsmodus" @toc Bedienung Hilfsmodus ------------ -Aufruf : Rechte Amiga-Taste + h oder auch einfach die Help-Taste Hiermit wird in allen aktiven Fenstern von Mancala der Hilfsmodus aktiviert. Damit man das auch merkt, wird in allen Fenstern an den Fenstertitel die Bemerkung "(Hilfsmodus)" geh Wenn man jetzt auf einen beliebigen Knopf in einem der Fenster klickt, erscheint der AmigaGuide (TM) von Mancala und zeigt die passende Information zum angeklickten Objekt an. Das funktioniert mit fast allen Objekten des gesamten Spiels. rlich bekommt man keine Hilfe zum Men punkt Hilfsmodus selbst !!! Achtung !!! Diese Funktion ist nur dann verf gbar, wenn in den ToolTypes ein korrekter Pfad f r die Guide-Datei eingetragen ist !! here Informationen siehe @{" Installation " link Installation}. @endnode ## *** Men Optionen ******************************************* @node Optionen "Optionen" @toc Bedienung Optionen ---------- Hiermit wird das Optionsfenster aufgerufen, in dem man zahlreiche Parameter des Programms ver ndern kann. @{" Illustration des Optionsfensters " link Mancala.guide.Bild3/main} (F r Kickstart/Workbench 3.0+) @{" Illustration des Optionsfensters " system "SYS:Utilities/WDisplay Mancala.guide.Bild3"} (F r Kick/WB 2.0 mit WDisplay) Rechts neben "Spieler 1 :" und "Spieler 2 :" sind zwei Stringgadgets, in die man Die Namen der beiden Spieler eintragen kann. Rechts daneben sind zwei sogenannte Cycle-Gadgets, mit denen man den @{" Typ " link Typ} des jeweiligen Spielers ausw hlen kann. Darunter steht bei "Extern 1:" bzw. "Extern 2:" jeweils ein Gadget : @{" LADEN " link LoadEx} erdem gibt es hier noch einige Gadgets : @{" Punktzahlen anzeigen " link ShowPunkte} @{" Muldenbeschriftung " link Beschriftung} @{" Zugverz gerung " link Verz gerung} @{" Synchronisierung " link Synchron} @{" EINSTELLUNGEN SPEICHERN " link Speichern} @{" BEENDEN " link QuitOpt} Ganz unten links ist noch ein Cycle Gadget zu sehen : @{" Farben " link Farben} @endnode ## *** Men Spielst rken *************************************** @node Typ "Spielertypen" @toc Optionen Spielertypen -------------- Neben dem menschlichen Spieler gibt es noch Computerspieler. Der Computer kennt drei interne Spielst rken, au erdem gibt es noch die M glichkeit, externe Spieler zu laden. Menschliche Spieler @{" Mensch " link Mensch} Interne Computerspieler @{" Computer (Normal) " link Normal} @{" Computer (Gemein) " link Gemein} @{" Computer (Taktik) " link Taktik} Externe Computerspieler @{" Computer (Extern 1) " link ExP} @{" Computer (Extern 2) " link ExP} @endnode @node Mensch "Menschlicher Spieler" @toc Optionen Mensch -------- Der menschliche Spieler wird selbstverst ndlich von einer der Personen bernommen, die VOR dem Computer sind und nicht darin. Stellt man beide Spieler auf Mensch, so verh lt sich Mancala wie ein einfaches Spielbrett. Es f hrt nur die Z ge durch. @endnode @node Normal "Computerspieler : Normal" @toc St Normal -------- In dieser Einstellung spielt der Computer noch sehr dumm. Er kann zwar in begrenztem Umfang schon einsammeln, hat aber noch arge Probleme, Taktiken zu erkennen oder gar zu durchkreuzen. @endnode @node Gemein "Computerspieler : Gemein" @toc St Gemein -------- Dies ist die Weiterentwicklung von @{" Normal " link Normal}. Der Computerspieler kann jetzt sehr gut einsammeln. Er ist taktisch zwar immer noch sehr dumm, aber er versucht bereits rabiat, Einsammelm glichkeiten des anderen Spielers zu verhindern. @endnode @node Taktik "Computerspieler : Taktik" @toc St Taktik -------- Dieser Spieler ist nicht unbedingt immer besser als @{" Gemein " link Gemein}, er ist vollkommen anders konzipiert. Der Computerspieler kann hier am besten einsammeln. Er hat dann aber nachher eine vollkommen andere Taktik, den Zug zu beenden. @endnode @node ExP "Computerspieler : Extern" @toc St Externer Spieler ------------------ Man kann bis zu zwei externe Spieler einladen, die durch eine Textdatei definiert sind. Es gibt die M glichkeit, zwei verschiedene externe Spieler einzuladen, damit auch ein Turnier zwischen verschiedenen selbstprogrammierten Spielern m glich ist. @endnode ## *** Unterpunkte Optionen ************************************ @node LoadEx "Externen Spieler laden" @toc Optionen Laden ------- Mit diesem Knopf kann ein Filerequester ge ffnet werden. In diesem kann man dann eine Datei ausw hlen, die einen externen Spieler darstellt. Ist es tats chlich ein externer Spieler, so wird die Datei geladen und es erscheint ein Kommentar neben dem Gadget. Mit dem oberen Knopf kann die Datei f r den ersten externen Spieler ausgew hlt werden, mit dem unteren die f r den zweiten. Eine Anleitung, wie man einen externen Spieler programmiert, ist im Abschnitt @{" Externe Spieler " link Extern} zu finden. @endnode @node ShowPunkte "Punktzahlen anzeigen" @toc Optionen Punktzahlen anzeigen ---------------------- Mit diesem Gadget kann die Anzeige der Punktzahlen der beiden Spieler w hrend des Spiels abgeschaltet werden. Einige haben es gerne spannend bis zum Schlu andere hingegen wollen immer voll im Bilde sein. Ist ein H kchen zu sehen, so werden die Punkte angezeigt. @endnode @node Beschriftung "Muldenbeschriftung" @toc Optionen Muldenbeschriftung -------------------- Hiermit kann man w hlen, ob an den Mulden die jeweilige Nummer der Mulde stehen soll. Dies ist sehr hilfreich, wenn man eine Analyse aus dem Partie-Editor nachvollziehen will oder aber z.B. durchs Telefon spielt. Ist ein H kchen zu sehen, dann ist die Beschriftung an. @endnode @node Verz gerung "Zugverz gerung" @toc Optionen Zugverz gerung ---------------- Wenn ein Zug ausgef hrt wird, so gibt es beim Verteilen der Spielsteine auf die anderen Mulden jeweils eine Pause von etwa einer Zwanzigstel-Sekunde. Das soll helfen, bei einer Turbokarte die Z ge noch verfolgbar zu machen. Hiermit kann man sie deaktivieren. Ist ein H kchen zu sehen, so ist die Verz gerung eingeschaltet. @endnode @node Synchron "Synchronisierung" @toc Optionen Synchronisierung ------------------ Diese Funktion kann eigentlich f r fast alles benutzt werden. Das Wort Synchronisierung hei t, da Mancala synchron zu allen Aktionen des Spiels ein vom Benutzer definiertes Programm startet und diesem die Aktionen bermittelt. Weitere Informationen @{" Anwendungsbeispiele " link SynM @{" Installation " link SynInst} @{" Format der Parameter " link SynFormat} @{" Wann erfolgt der Aufruf ? " link SynWann} Hier sind die Parameter, die Mancala dem Programm bergeben kann : @{" Undo " link SynUndo} @{" Neu " link SynNeu} @{" Spielende " link SynSpielende} @{" Zug " link SynZug} @endnode @node Speichern "Einstellungen speichern" @toc Optionen Einstellungen speichern ------------------------- Mit diesem Knopf werden alle Einstellungen abgespeichert, die im Optionsfenster eingestellt werden k nnen: - Die Spielernamen - Die Spielst rken der beiden Spieler - Die Definitionen f r die externen Spieler - Die Wahl, ob die Punkte gezeigt werden sollen - Die gew hlten Farben @endnode @node Farben "Farben" @toc Optionen Farben -------- Mit diesem Cycle-Gadget kann man diverse Farbeinstellungen ausw hlen : Rott ne - Alles in rot ne - In gr n und orange Blaut ne - Alles in blau Graurot - Workbench-Grau mit rot Braunt ne - Dunkle Braunt Workbench - Original-Workbenchfarben Der Punkt Workbench setzt voraus, da die Datei "ENV:sys/palette.ilbm" existiert. Ich arbeite mit Workbench 2.1, und da speichert das Programm "Palette" aus der Prefs-Schublade diese Datei ab. Ich wei allerdings nicht, wie dies bei anderen Workbenchversionen geht. Existiert die Datei nicht, so werden h ufig verwendete Workbench-Farben angezeigt, die hoffentlich ebenfalls den gew nschten Effekt erzielen. @endnode @node QuitOpt "Optionen Beenden" @toc Optionen Beenden --------- Hiermit wird das Optionsfenster wieder geschlossen. Der Knopf hat die gleiche Funktion wie das Close-Gadget des Fensters. @endnode ## *** Synchron-Unterpunkte ************************************ @node SynM g "Anwendungsbeispiele" @toc Synchron Was geht ? ------------ Hier nur einige der vielen Anwendungsm glichkeiten : - Man l t ein ARexx-Skript automatisch ein Protokoll aller Aktionen anfertigen. - Man kann per ARexx-Skript ber Netzwek oder Nullmodem an zwei verschiedenen Computern Mancala gegeneinander spielen. - Man kann per Zufall Bilder, Samples oder hnliches in die Partie einblenden und sie so auflockern. Wahrscheinlich gibt es eine Menge M glichkeiten, die mir jetzt auf Anhieb gar nicht einfallen ! @endnode @node SynInst "Installation" @toc Synchron Installation der Synchron-Funktion ------------------------------------ Um die Synchron-Funktion zu nutzen, mu im Icon von Mancala das ToolType "SynchronBefehl" eingetragen werden. Dieser Befehl wird dann mit den jeweiligen Parametern aufgerufen. Am sinnvollsten ist es, hier ein DOS-Skript oder ein ARexx-Skript aufzurufen. Beispiele : SynchronBefehl=C:Execute S:Synchron.bat SynchronBefehl=RX Rexx:Synchron.rexx SynchronBefehl=SYS:System/Format drive DH0: name "Leer" noicons ffs ?????) @endnode @node SynFormat "Format der Parameter" @toc Synchron Das Format ------------ Dem vom Benutzer im Icon festgelegten Programm, welches selbstverst ndlich auch ein ARexx-Skript sein kann, werden Parameter in einem festgelegten Format bergeben. Zuerst kommt immer die Nummer des ARexx-Ports des aufrufenden Mancalas. Wenn also auf einem Computer mehrere Mancalas laufen und auf dem zweiten wird ein Zug durchgef hrt, so wird als erster Parameter eine 2 bergeben. Es folgt das Parameterwort, das die Art der Aktion auf dem aufrufenden Mancala erkl rt. Wurde ein neues Spiel gestartet, so steht hier "Neu". Danach kommen je nach Aktion noch diverse weitere Parameter. Beispiel: Die Parameter sehen so aus : "1 Zug 2 8" Man interpretiert das dann w rtlich zum Beispiel so : "Das 1. Mancala meldet Zug von Spieler 2 auf Feld 8" Man trennt die Ergebnisse mit ARexx genauso wie die Antworten auf eine "Get..." Anfrage. Siehe : @{" Wie kommt man an die Ergebnisse ? " link AErgs} @endnode @node SynWann "Wann erfolgt der Aufruf ?" @toc Synchron Wann erfolgt der Aufruf ? --------------------------- Das definierte Programm wird aufgerufen, BEVOR die gemeldete Aktion tats chlich stattfindet. Dies ist bei einer Neztwerkverbindung vorteilhaft, da man so keine Zeit verliert, bis die Information ihr Ziel erreicht. Laufen allerdings zwei miteinander verbundene Mancalas auf EINEM Rechner (mit ARexx-Skript verbunden), so f hrt ein sofortiges Durchf hren der gemeldeten Aktion auf dem zweiten Mancala nur zu einem totalen Zusammenbruch der Systemperformance, da Mancala sehr rechenintensiv sein kann. erdem werden per ARexx aufgerufene Aktionen NICHT ckgemeldet, um eine Endlosschleife zu vermeiden : Auf Mancala.1 wird auf "Neu" geklickt, Meldung kommt, ARexx sendet, Mancala.2 f hrt auch Neu aus, Meldung kommt, ARexx sendet, Mancala.1 f hrt wieder Neu aus, Meldung kommt, und so weiter. Dies w rde zum Endlosaufruf von Neu f hren. @endnode @node SynUndo "Undo" @toc Synchron Undo ------ Komplett : Undo Es wurde die Funktion @{" Undo " link Undo} aufgerufen. @endnode @node SynNeu "Neu" @toc Synchron Neu ----- Komplett : Neu Es wurde die Funktion @{" Neues Spiel " link Neu} aufgerufen. @endnode @node SynSpielende "Spielende" @toc Synchron Spielende ----------- Komplett : Spielende Das Spiel wurde beendet und der Sieger ermittelt. @endnode @node SynZug "Zug" @toc Synchron Zug ----- Komplett : Zug Einer der Spieler hat einen Zug gemacht. Es folgt die Nummer des Spielers, der den Zug gemacht hat. Steht hier eine 1, so war es der linke Spieler, bei einer 2 der rechte. Zuletzt kommt schlie lich das Feld, das gezogen wurde. Hinweis : Mit Zug sind nur solche Z ge gemeint, bei denen einer der Spieler eine der 12 Mulden gew hlt hat. Eventuell automatisch nachfolgende ge werden nicht gemeldet, da sie selbstverst ndlich sind. Auch ein eventuell per Netz empfangendes Mancala w re wohl kaum der Meinung, ein automatisch nachfolgender Zug im Stil "Letztes Feld leer, also gegen ber" mu im noch extra gesagt werden; es ist schlie lich nicht dumm ! @endnode ## *** Partie-Editor Hauptmen ********************************* @node PEd "Partie-Editor" Der Partie-Editor ------------------- Der Partie-Editor kann sowohl aus Mancala heraus als auch seperat gestartet werden. In beiden F llen erscheint das gleiche Fenster. @{" Illustration des Partie-Editors " link Mancala.guide.Bild2/main} (F r Kickstart/Workbench 3.0) @{" Illustration des Partie-Editors " system "SYS:Utilities/WDisplay Mancala.guide.Bild2"} (F r Kick/WB 2.0 mit WDisplay) Links ist eine @{" Liste " link PListe} zu sehen, die eventuell auch leer sein kann. Rechts neben dieser Liste ist eine Reihe von Gadgets zu sehen : @{" EDITOR BEENDEN " link QuitPEd} @{" POSITION HERSTELLEN " link Herstellen} @{" PARTIE LADEN " link PLaden} @{" AB HIER WEITERSPIELEN " link AbHier} @{" PARTIE SPEICHERN " link PSpeichern} @{" Partie abh ren " link H Darunter gibt es noch ein Gadget : @{" ZUGLISTE AUSGEBEN NACH >>> " link PAusgabe} Rechts daneben ist ein Cycle-Gadget zu sehen. Es wechselt zwischen "Drucker" und "Datei" und ist wichtig f r das linke Gadget. Unten rechts ist eine @{" Miniaturausgabe des Spielfelds " link PMini} zu sehen. Das Gadget "Partie abh ren" ist nur anw hlbar, wenn der Partie-Editor aus Mancala heraus aufgerufen wurde. @endnode @node PMini "Miniaturausgabe des Spielfelds" @toc PEd Spielfeld ----------- In diesem kleinen Spielfeld werden Positionen einer Partie dargestellt, wenn man auf den Knopf @{" POSITION HERSTELLEN " link Herstellen} klickt. Zur besseren bersicht sind hier statt der entsprechenden Zahl Spielsteinen Zahlen zu sehen. Eine 8 hei t also, da hier acht Spielsteine liegen. Damit man nicht w hrend eines Spiels schummelt, ist die Herstellen-Funktion w hrend eines Spiels gesperrt. @endnode @node PListe "Liste" @toc PEd Liste ------- In der Liste werden die Z ge einer Partie dargestellt. Ein Zug wird in der folgenden Form dargestellt : Zugnummer : Spieler - Feld Also z.B. "34:2-9", was bedeutet, im 34. Zug Spieler 2 Feld 9 gespielt hat. Ein Doppelklick auf die Liste bewirkt dasselbe wie ein Anklicken des Knopfes @{" POSITION HERSTELLEN " link Herstellen}. @endnode @node QuitPEd "Editor beenden" @toc PEd Editor beenden ---------------- Hiermit kann der Partie-Editor wieder verlassen werden. Der Knopf hat die gleiche Funktion wie das Close-Gadget des Fensters. @endnode @node PLaden "Partie laden" @toc PEd Partie laden -------------- Es wird ein Filerequester ge ffnet, in dem eine Partie-Datei ausgew werden kann. Diese Datei wird geladen und falls es sich tats chlich um eine Partie-Datei handelt, wird die Zugliste der Partie in die Liste geschrieben. Gleichzeitig wird der Abh rmodus abgeschaltet. @endnode @node PSpeichern "Partie speichern" @toc PEd Partie speichern ------------------ Es wird ein Filerequester ge ffnet, in dem ein Dateiname ausgew werden kann. Der Inhalt der Liste und alle Brettpositionen der Partie werden in diese Datei abgespeichert. @endnode @node PAusgabe "Zugliste ausgeben nach >>>" @toc PEd Zugliste ausgeben nach >>> ---------------------------- Wenn das Cycle-Gadget auf "Drucker" steht, wird der Inhalt der Liste nach "PRT:", also auf den Drucker ausgegeben. Steht das Cycle-Gadget auf "Datei", erscheint ein Filerequester, in dem ein Dateiname ausgew hlt werden kann. In diese Datei wird dann der Inhalt der Liste als ASCII-Text ausgegeben. @endnode @node Herstellen "Position Herstellen" @toc PEd Position Herstellen --------------------- Dieses Gadget ist nur anw hlbar, wenn der Abh rmodus ausgeschaltet ist oder aber momentan keine Partie l uft. Es ist also immer anw hlbar, wenn der Partie-Editor ohne Mancala gestartet wurde. Klickt man auf dieses Gadget und ist in der Liste am linken Fensterrand ein g ltiger Zug angew hlt, so wird das Miniatur-Spielbrett am unteren Fensterrand auf den Status des echten Spielbrettes dieser Partie NACH dem angew hlten Zug gebracht. Wenn es nicht anw hlbar ist, l uft gerade eine Partie, und wir wollen ja nicht, da jemand sich die Anzahl der Steine in den Mulden im Klartext ansieht und daraus einen Vorteil hat. Die gleiche Funktion wie dieser Knopf hat auch ein Doppelklick auf eine Zeile der @{" Liste " link PListe} auf der linken Seite des Fensters. @endnode @node AbHier "Ab hier weiterspielen" @toc PEd Ab hier weiterspielen ----------------------- Dieses Gadget hat eigentlich zwei Funktionen. In jedem Fall mu man zun chst aus der Liste einen Zug ausw hlen. tigt man dann das Gadget, folgt eine Sicherheitsabfrage, nach der dann, falls man bejaht, folgendes passiert : Ist @{" Partie abh ren " link H ren} eingeschaltet, so wird die Partie auf die Brettposition nach dem gew hlten Zug zur ckgesetzt. Hiermit kann man mehrere Aufrufe von @{" Zur cknehmen " link Undo} ersetzen. Ist "Partie abh ren" aber ausgeschaltet, und das ist das eigentliche Highlight dieser Funktion, so stellt Mancala das Spielbrett so wieder her, wie es nach dem gew hlten Zug aussah und man kann weiterspielen. So kann man alte abgespeicherte Partien auch nach Jahren noch "wiederbeleben" und zu Ende spielen oder anders enden lassen. ACHTUNG : Bei einigen lteren abgespeicherten Partien wurde eine wichtige Information noch nicht mit abgespeichert. Bei diesen Partien funktioniert die Funktion leider nicht ordnungsgem @endnode @node H ren "Partie abh @toc PEd Partie abh ---------------- Dieses Gadget ist nur anw hlbar, wenn der Partie-Editor aus Mancala heraus aufgerufen wurde. Ist hier ein H kchen zu sehen, ist das Gadget also angew so wird die momentan laufende Mancala-Partie abgeh Das hei t folgendes: Nach jedem Zug merkt sich der Partie-Editor, welches Feld gespielt wurde, und wie das Spielbrett nach dem Zug aussah. Der Zug wird im Format "Zugnummer : Spieler - Feld" in die Liste getippt. Nach dem Ende der Partie kann man diese Daten dann abspeichern. @endnode ## *** ARexx Hauptmen ***************************************** @node ARexx "Der ARexx-Port" Der ARexx-Port ---------------- Mancala bietet dem Benutzer einen ARexx-Port. Der Name des Ports ist normalerweise "Mancala.1". Startet man mehr als ein Mancala auf einmal, so hei der Port des zweiten Mancala's "Mancala.2" und so weiter. Die zur Verf gung gestellten Befehle unterteilen sich in zwei Gruppen : 1. Information @{" GetSpielStatus " link AGetSpielStatus} @{" GetSpielertypen " link AGetSpielertypen} @{" GetBrett " link AGetBrett} @{" GetPunkte " link AGetPunkte} @{" GetSummen " link AGetSummen} @{" GetAmZug " link AGetAmZug} @{" GetAufBrett " link AGetAufBrett} @{" GetEvenPoint " link AGetEvenPoint} 2. Aktionen @{" CallZug " link ACallZug} @{" CallUndo " link ACallUndo} @{" CallSpielende " link ACallSpielende} @{" CallNeu " link ACallNeu} @{" CallAbout " link ACallAbout} @{" CallGreetings " link ACallGreetings} @{" CallPause " link ACallPause} tzlich f r ARexx-Anf nger einige kurze Informationen : @{" Wie kommt man an die Ergebnisse ? " link AErgs} @endnode @node AErgs "Wie kommt man an die Ergebnisse ?" @toc ARexx Ergebnisse ------------ Wenn man Mancala mit einem der "Get..." Befehle anspricht, bekommt man die einzelnen Ergebnisse nicht getrennt, sondern auf einem Haufen zur ck. Man mu sie dann erst noch trennen. Wie man das anstellt, ist in folgendem Beispiel zu sehen : /* Ein Beispiel */ address 'Mancala.1' <-- Mancala ansprechen options results <-- Ergebnisse einschalten getpunkte <-- Befehl abschicken parse var result punkte1 punkte2 <-- Ergebnis trennen say "Spieler 1 hat "punkte1" Punkte." <-- Ausgabe say "Spieler 2 hat "punkte2" Punkte." <-- Ausgabe Die Zeile "parse..." geht so : "parse" ist der Befehl zum Trennen eines Textes. "var" bedeutet, da man eine Variable trennen will. "result" ist der Name der Variable. "punkte1" und "punkte2" sind die Namen der beiden Ergebnisvariablen. @endnode @node AGetSpielStatus "ARexx - GetSpielStatus" @toc ARexx GetSpielStatus ---------------- Aufruf : GetSpielStatus Ergebnis : Status Funktion : Hiermit kann man feststellen, ob gerade ein Spiel l Ist Status 0, so l uft kein Spiel, bei 1 l uft ein Spiel. @endnode @node AGetSpielertypen "ARexx - GetSpielertypen" @toc ARexx GetSpielertypen ----------------- Aufruf : GetSpielertypen Ergebnis : Typ1 Typ2 Funktion : Es werden die Typen der beiden Spieler zur ckgegeben. gliche Ergebnisse f r jede der R ckgabevariablen sind "Mensch" und "Computer". @endnode @node AGetBrett "ARexx - GetBrett" @toc ARexx GetBrett ---------- Aufruf : GetBrett Ergebnis : Feld1 Feld2 [...] Feld11 Feld12 Funktion : Als Ergebnis werden 12 Zahlenwerte zur ckgegeben, welche die Anzahl der Spielsteine in den 12 Mulden darstellen. Feld 1 ist oben links, Feld 6 oben rechts, Feld 7 unten links und Feld 12 unten rechts. @endnode @node AGetPunkte "ARexx - GetPunkte" @toc ARexx GetPunkte ----------- Aufruf : GetPunkte Ergebnis : PunkteSpieler1 PunkteSpieler2 Funktion : Es werden zwei Zahlenwerte zur ckgegeben, wobei der erste die Punktzahl von Spieler 1 und der zweite die von Spieler 2 ist. @endnode @node AGetSummen "ARexx - GetSummen" @toc ARexx GetSummen ----------- Aufruf : GetSummen Ergebnis : SummeOben SummeUnten Funktion : Ergibt die Anzahl aller Steine in den sechs oberen bzw. unteren Mulden. @endnode @node AGetAmZug "ARexx - GetAmZug" @toc ARexx GetAmZug ---------- Aufruf : GetAmZug Ergebnis : AmZug Funktion : Hiermit kann man feststellen, welcher Spieler gerade dran ist. Ist AmZug 1, so ist der linke Spieler dran, bei 2 der rechte. @endnode @node AGetAufBrett "ARexx - GetAufBrett" @toc ARexx GetAufBrett ------------- Aufruf : GetAufBrett Ergebnis : AnzahlSteine Funktion : Ergibt die momentane Anzahl aller Steine in den 12 Mulden. @endnode @node AGetEvenPoint "ARexx - GetEvenPoint" @toc ARexx GetEvenPoint -------------- Aufruf : GetEvenPoint Ergebnis : EvenPoint Funktion : Ergibt die Anzahl Punkte, die man f r ein Unentschieden ben tigt. Normalerweise ist sie 24, da bei 4 Steinen pro Mulde und 12 Mulden maximal 48 zu holen sind. Also ist bei 24 Punkten das Unentschieden sicher. Das mu aber in sp teren Versionen von Mancala nicht zwingend so sein, also ist das Benutzen dieses Befehls zu empfehlen. @endnode @node ACallZug "ARexx - CallZug" @toc ARexx CallZug --------- Aufruf : CallZug Beispiel : CallZug 4 Funktion : Mit Feld wird eine Zahl von 1 bis 12 bergeben. Sollte in der angegebenen Mulde mindestens ein Stein liegen, so wird der Zug ausgef Wurde kein Feld bergeben oder ist die Mulde leer, so wird per Zufall ein Feld ausgew hlt und gezogen. @endnode @node ACallUndo "ARexx - CallUndo" @toc ARexx CallUndo ---------- Aufruf : CallUndo Funktion : Es wird die @{" Undo-Funktion " link Undo} aufgerufen. @endnode @node ACallSpielende "ARexx - CallSpielende" @toc ARexx CallSpielende -------------- Aufruf : CallSpielende Funktion : Das Spiel wird beendet und der Gewinner bekanntgegeben. @endnode @node ACallNeu "ARexx - CallNeu" @toc ARexx CallNeu --------- Aufruf : CallNeu Funktion : Es wird die Funktion @{" Neues Spiel " link Neu} aufgerufen. @endnode @node ACallAbout "ARexx - CallAbout" @toc ARexx CallAbout ----------- Aufruf : CallAbout Funktion : Das @{" Programminfo-Fenster " link Info} wird angezeigt. @endnode @node ACallGreetings "ARexx - CallGreetings" @toc ARexx CallGreetings --------------- Aufruf : CallGreetings Funktion : Das @{" Greetings-Fenster " link Greet} wird angezeigt. @endnode @node ACallPause "ARexx - CallPause" @toc ARexx CallPause ----------- Aufruf : CallPause Beispiel : CallPause 0 5 0 Funktion : Veranla t das ARexx-Skript und das angesprochene Mancala, die angegebene Zeit zu warten und nichts zu tun. Dies ist sehr n tzlich, wenn man zwei synchrone Mancalas auf einem Rechner laufen hat. Da Mancala sehr CPU-intensiv sein kann, mu verhindern, da beide Mancalas gleichzeitig zu rechnen versuchen, und so den Rechner total lahmlegen. Die Zeit ist in Minuten, Sekunden und Jiffies anzugeben. Ein Jiffy ist 1/Bildfrequenz Sekunden lang, also bei PAL 1/50 Sekunde und bei NTSC 1/60 Sekunde. @endnode ## *** Externer Spieler Hauptmen ****************************** @node Extern "Externe Spieler" Externe Spieler ----------------- Im @{" Options-Fenster " link Optionen} gibt es die M glichkeit, sogenannte externe Spieler zu laden. Dies sind Textdateien, die ein kleines St ck Programm enthalten. Dieses St ck Programm ermittelt, welches Feld der externe Spieler spielt. Hier alles ber die Erstellung eines externen Spielers : @{" Was braucht man ? " link N @{" Das Format der Datei " link Format} @{" Programmaufbau " link Aufbau} @{" Die Variablen " link Vars} @{" Die wichtigsten Befehle " link Bef} @{" Ein Mini-Beispiel " link Beispiel} @endnode ## *** Externer Spieler Unterpunkte **************************** @node N tig "Was braucht man ?" @toc Extern Was braucht man ? ------------------- Um einen externen Spieler zu programmieren, braucht man all das NICHT : - eine Programmiersprache - Assemblerkenntnisse - 4 Megabyte RAM - Dampfwalze Stattdessen reicht schon folgende Ausstattung : - ein Texteditor - Basic-Kenntnisse - 512 Kilobyte RAM - Tastatur Genauer gesagt, wenn man ein Programm hat, mit dem man Texte schreiben kann und mit dem man diese Texte dann auch noch im ASCII-Format abspeichern kann, ist man schon einen Schritt weiter. Wenn man irgendwann einmal mit Basic in Kontakt kam und damit ein vielleicht nur klitzekleines Programm geschrieben hat, und wenn dieses Programm dann auch noch funktioniert hat, hat man gute Chancen, auch die zweite Vorraussetzung zu erf llen. Die restlichen Vorraussetzungen sollen nur zeigen, da man auch auf solchen Computern einen Spieler programmieren kann, auf denen Mancala selbst berhaupt nicht l Alle Vorraussetzungen erf llt ? Na dann ran ans Programmieren !!! @endnode @node Format "Externe Spieler - Dateiformat" @toc Extern Format der Datei eines externen Spielers ------------------------------------------ Das Format der Textdatei, mit der der Spieler definiert wird, ist denkbar einfach. Die ersten zwei Zeilen m ssen bestimmte Kommentare enthalten, danach folgt der Programmtext : Nop; Mancala.Extern Nop; ... Die erste Zeile ist n tig, um Mancala mitzuteilen, das die Datei tats chlich einen Computerspieler enth lt. Sie mu genauso am Anfang stehen. Die zweite Zeile enth lt nach dem Leerzeichen einen Kommentar von bis zu 43 Zeichen L nge. Dieser erscheint im @{" Optionsfenster " link Optionen} rechts neben dem Gadget @{" LADEN " link LoadEx}. Hier kann man dem Computerspieler einen Namen geben und noch eine kurze Beschreibung oder den Namen des Autors anh ngen. Ab der dritten Zeile folgt der Programmtext. Wie dieser aufgebaut sein mu , steht bei @{" Programmaufbau " link Aufbau}. @endnode @node Aufbau "Programmaufbau" @toc Extern Aufbau des Programms ---------------------- Das Programm stellt einen basic- hnlichen Text dar, an desse Ende in der Variable F eine Zahl von 1 bis 12 stehen mu , die definiert, welches Feld der Computerspieler spielen will. Dabei sind die Mulden auf dem Spielfeld wie folgt numeriert : 1 2 3 4 5 6 7 8 9 10 11 12 Die Mulde oben links ist also Mulde 1, die unten rechts Mulde 12. Typischerweise wird w hrend des Programmablaufs in Schleifen gepr wieviele Steine in einem bestimmten Feld liegen oder mit hnlichen Methoden ein virtueller Zug durchgef hrt. Man pr ft vielleicht auch noch, ob man dem Gegner keine gute Zugm glichkeit gibt, wenn man einen bestimmten Zug durchf Ein Problem gibt es f r den Programmierer momentan noch : Es ist nicht ohne weiteres m glich, Unterroutinen zu erstellen. Daher mu der gesamte Spieler am St ck programmiert werden. Sorry :-( Sollte einer der CanDo-Programierer dies lesen : Bitte schick mir Infos zum internen Aufbau der undokumentierten Befehle. berhaupt einen berblick ber das momentane Spielfeld zu haben, man nat rlich diverse Werte in vordefinierten Variablen vorfinden. Wie diese Variablen hei en und was drinsteht, ist unter @{" Die Variablen " link Vars} nachzulesen. @endnode @node Vars "Die Variablen" @toc Extern Die Variablen --------------- Um sich auf dem momentanen Spielbrett zurechtzufinden, mu man nat rlich wissen, wieviele Spielsteine in jeder einzelnen Mulde liegen usw. Dazu stehen diverse Variablen zur Verf gung, in denen diese Werte stehen. Ich bitte jeden Programmierer eines externen Spielers, diese Variablen nur zu LESEN. Wenn man sie einfach ver ndert, entsteht ein nicht kalkulierbares Chaos auf dem Spielbrett und ein normales Spielen wird unm glich. Hier die einzelnen Variablen : @{" AmZug " link vAmZug} @{" AufBrett " link vAufBrett} @{" EvenPoint " link vEven} @{" Brett[] " link vBrett} @{" Summe[] " link vSumme} @{" Spieler[].Punkte " link vPunkte} @endnode @node vAmZug "AmZug" @toc Vars AmZug ------- Format : Let =AmZug Beispiel : Let X=AmZug Ergibt 1, wenn der erste und 2, wenn der zweite Spieler dran ist. @endnode @node vAufBrett "AufBrett" @toc Vars AufBrett ---------- Format : Let =AufBrett Beispiel : Let X=AufBrett Ergibt eine Zahl zwischen 1 und 48, die angibt, wieviele Spielsteine sich momentan noch auf dem Brett befinden. @endnode @node vEven "EvenPoint" @toc Vars EvenPoint ----------- Format : Let =EvenPoint Beispiel : Let X=EvenPoint Ergibt beim Standardspiel (in jeder Mulde liegen zu Beginn 4 Steine) immer den Wert 24. Man sollte sich aber nicht darauf verlassen, denn es k nnten in einer der n chsten Versionen auch mehr oder weniger Steine pro Mulde sein. Die Variable hei t EvenPoint, weil man beim Erreichen dieser Punktzahl ein Unentschieden sicher hat, bei mehr Punkten hat man gewonnen. @endnode @node vBrett "Brett[]" @toc Vars Brett[] --------- Format : Let =Brett[<1 bis 12>] Beispiel : Let X=Brett[3] Ergibt je nach der Zahl zwischen 1 und 12 die Anzahl der Spielsteine in der jeweiligen Mulde. Die Mulde oben links ist Mulde 1, die oben rechts Mulde 6, die unten links Mulde 7 und die unten rechts Mulde 12. Sollte eine andere Zahl au er denen von 1 bis 12 angegeben werden, erzeugt dies eine Fehlermeldung. @endnode @node vSumme "Summe[]" @toc Vars Summe[] --------- Format : Let =Summe[<1 oder 2>] Beispiel : Let X=Summe[1] Summe[1] ergibt die Anzahl aller Spielsteine in den oberen und Summe[2] die aller Spielsteine in den unteren 6 Mulden. Sollte eine andere Zahl au er 1 oder 2 angegeben werden, erzeugt dies eine Fehlermeldung. @endnode @node vPunkte "Spieler[].Punkte" @toc Vars Spieler[].Punkte ------------------ Format : Let =Spieler[<1 oder 2>].Punkte Beispiel : Let X=Spieler[1].Punkte Spieler[1].Punkte ergibt die Punkte des ersten (linken) Spielers und Spieler[2].Punkte ergibt die Punkte des zweiten (rechten) Spielers. Bei 24 Punkten ist ein Unentschieden sicher, bei 25 oder mehr hat man schon gewonnen. Danach kann man taktieren (27 ? Dann ist sowieso alles egal !). Sollte eine andere Zahl au er 1 oder 2 angegeben werden, erzeugt dies eine Fehlermeldung. @endnode @node Bef "Die wichtigsten Befehle" @toc Extern Die wichtigsten Befehle ------------------------- Das Programm wird in der internen CanDo-Sprache geschrieben. Diese Sprache ist dem normalen Basic sehr hnlich, trotzdem gibt es kleine Abweichungen. Deshalb hier eine Erkl rung der aller wichtigsten Befehle f r die Programmierung eines externen Spielers : @{" Nop " link bNop} @{" Let " link bLet} @{" =IfThen() " link bIfThen} @{" =Random() " link bRandom} @{" If..ElseIf..Else..EndIf " link bIf} @{" Loop..Until " link bLoop} @{" ExitLoop " link bExitLoop} @{" ExitScript " link bExitScript} @endnode @node bNop "Nop" @toc Bef Nop ----- Format : Nop ; Beispiel : Nop ; Dies ist ein Kommentar ! Der Befehl Nop ist der Nichts-Befehl. Hiermit kann man Kommentarzeilen erzeugen. Kommentarzeilen sollte jeder Programmierer verwenden, um sein eigenes Programm auch noch nach mehr als einer Woche zu kapieren und ndern zu k nnen. @endnode @node bLet "Let" @toc Bef Let ----- Format : Let = Beispiel : Let X=Brett[3]+4 Mit Let kann einer Variablen ein Wert zugewiesen werden. Dabei kann man nat rlich f r nicht nur Zahlen einsetzen, sondern man kann eine komplexe Formel verwenden, in der andere Variablen und auch Funktionsaufrufe stattfinden k nnen. Beispiele f r Funktionsaufrufe sind @{" =IfThen() " link bIfThen} und @{" =Random() " link bRandom}. @endnode @node bIfThen "=IfThen()" @toc Bef =IfThen() ----------- Format : Let =IfThen(,,} Beispiel : Let X=IfThen(AmZug=1,1,12) IfThen ist eine vereinfachte einzeilige Variante der Konstruktion "If..ElseIf..Else..EndIf". Man kann einer Variable einen von zwei Werten zuweisen. Ist die Bedingung erf llt (z.B. 3=2+1), so wird der Variable der Wahr-Wert zugewiesen, ansonsten der Falsch-Wert. Dabei kann man nat rlich f r bzw. nicht nur Zahlen einsetzen, sondern man kann eine komplexe Formel verwenden, in der andere Variablen und auch Funktionsaufrufe stattfinden k nnen. Man kann sogar als Wert eine erneute IfThen-Funktion benutzen. Man kann das ganze nahezu unbegrenzt verschachteln (Spaghetti-Code l en !!!). @endnode @node bRandom "=Random()" @toc Bef =Random() ----------- Format : Let =Random(,) Beispiel : Let X=Random(1,12) Hiermit kann man der Variablen eine Zufallszahl im Bereich von bis zuweisen. (Schlauer Satz !?!!??!?) r und kann man nat rlich wieder Formeln verwenden wie bei @{" Let " link bLet}. @endnode @node bIf "If..ElseIf..Else..EndIf" @toc Bef If..ElseIf..Else..EndIf ------------------------- Format : If Beispiel : If AmZug=1 Let Y=Random(1,6) ElseIf Else Let Y=Random(7,12) Else EndIf EndIf Eine Bedingung ist ein Vergleich von zwei Werten. So ist zum Beispiel 3=2+1 wahr und 5=6+4 unwahr. Die beiden Werte k nnen nat rlich wieder so aussehen wie bei @{" Let " link bLet}. Ist die Bedingung bei If erf llt, so werden die nachfolgenden Befehle abgearbeitet. Ansonsten wird die Bedingung bei ElseIf berpr Ist diese erf llt, so werden die dort folgenden Befehle abgearbeitet. Es k nnen beliebig viele ElseIf's folgen. Trifft keine aller Bedingungen zu, so werden die Befehle hinter Else abgearbeitet. Man kann nat rlich ElseIf, Else oder beides auch weglassen. @endnode @node bLoop "Loop..Until" @toc Bef Loop..Until ------------- Format : Loop Beispiel : Let Z=1 Loop Until Let F=Random(1,12) Let Z=Z+1 Until Z=11 Mit Loop lassen sich Schleifen erzeugen. Mit dem obigen Beispiel werden nacheinander zehn Zufallszahlen zwischen 1 und 12 gezogen und der Variablen F zugewiesen. Das ist zawr unsinnig aber ein gutes Beispiel 8-D. Nach dem Loop folgen die Befehle innerhalb der Schleife. Immer, wenn das Until erreicht wird, wird berpr ob die Bedingung wahr ist (Bedingung siehe @{" If " link bIf}). Ist sie wahr, so wird die Schleife verlassen. Um ein For...Next wie in Basic zu realisieren, mu wie im Beispiel eine Z hlvariable (hier Z) verwenden und diese bei jedem Schleifendurchlauf erh Es gibt noch mehr Schleifenkonstrukte. So wird bei While..EndLoop am Anfang eine Bedingung berpr und nur wenn diese wahr ist, wird die Schleife berhaupt betreten. Mit While..Until lassen sich ganz exotische Schleifen programmieren. Ein Sonderfall ist Loop..EndLoop. Diese Endlosschleife l t sich nur mit @{" ExitLoop " link bExitLoop} verlassen. Es geht nat rlich auch @{" ExitScript " link bExitScript}. @endnode @node bExitLoop "ExitLoop" @toc Bef ExitLoop ---------- Format : ExitLoop Hiermit wird eine momentan laufende Schleife verlassen und die Abarbeitung des Programms am ersten Befehl nach dem Schleifenende (z.B. nach dem Until) fortgesetzt. @endnode @node bExitScript "ExitScript" @toc Bef ExitScript ------------ Format : ExitScript Hiermit wird das Programm verlassen. llt einem vielleicht berhaupt kein guter Zug ein, so kann man hiermit einfach aus dem Programm springen. Mancala berechnet dann einen zuf lligen Zug. @endnode @node Beispiel "Ein Mini-Beispiel" @toc Extern Beispiel eines externen Spielers ---------------------------------- Zum Abschlu des Kurses "Wie programmiert man einen externen Spieler ?" ist an dieser Stelle das Listing eines externen Spielers abgedruckt, der fr her einmal in Mancala integriert war. Der Spieler ist zwar nicht besonders spielstark, aber ein gutes Beispiel zur Programmierung. Die Zeilennummern dienen nur der Orientierung in der Erkl rung : 1 Nop; Mancala.Extern 2 Nop; Anf nger (von Oliver Gr 3 Let Z=IfThen(AmZug=1,1,12) 4 Loop 5 If Brett[Z]=IfThen(AmZug=1,Z,13-Z) 6 Let F=Z 7 ExitLoop 8 EndIf 9 Let Z=Z+IfThen(AmZug=1,1,-1) 10 Until Z=IfThen(AmZug=1,7,6) 11 If F=0 12 Loop 13 Let F=Random(1,12) 14 Until Brett[F]>0 15 EndIf Zeile 1 mu genauso sein. Zeile 2 enth lt einen kurzen Kommentar. Zeile 3 setzt den Anfangsz hler der Schleife, je nachdem, welcher Spieler dran ist, auf 1 oder 12. Bei Spieler 1 f ngt man mit Feld 1 an, bei Spieler 2 mit Feld 12. In Zeile 4 beginnt die Schleife. In Zeile 5 wird berpr ft, ob im Feld Z genausoviele Steine liegen, wie das Feld vom eigenen Zielfeld entfernt ist, was ja dazu f rde, da man nochmal dran ist. Erkl rung der berpr fung : Ist z.B. Spieler 2 dran, dann ist Z beim ersten Mal ja gleich 12. Feld 12 (unten rechts) ist genau 1 Feld vom Zielfeld von Spieler 2 entfernt. Also m ssen In Brett[12] genau 13-12 (13-Z), also 1 Stein liegen. Stimmt der Vergleich aus dem If-Befehl, so wird das zu ziehende Feld F in Zeile 6 auf den aktuellen Schleifenz hler gesetzt und in Zeile 7 die Schleife verlassen, da man ja das richtige gefunden hat. Zeile 8 ist das Ende der If-Abfrage. In Zeile 9 wird Z je nach Spieler um eins erh ht oder erniedrigt. Bei Spieler 2 wurde mit 12 angefangen, also mu man um eins senken, um sich vom eigenen Zielfeld zu entfernen. In Zeile 10 ist das Schleifenende. Hier wird berpr ft, ob die Schleife schon sechsmal durchlaufen wurde. Diese Schleife wird nur sechsmal durchlaufen, weil nach dem Feld, das sechs Felder vom eigenen Zielfeld entfernt ist, das gegnerische Zielfeld kommt, und sich dann auch die Feldnummer wieder ndern. Bei Spieler 2 ist Feld 7 sechs Felder entfernt, Feld 1 ist 7 Felder entfernt. Wollte man die Schleife also noch erweitern, so w rde sich die Schleife noch komplizierter gestalten. Nach der Schleife wird in Zeile 11 berpr ft, ob die Schleife berhaupt ein g nstiges Feld ergeben hat. Ist aber F immer noch gleich 0, war die Suche erfolglos. In diesem Falle wird in den Zeilen 12 bis 14 solange ein Feld per Zufall ausgew hlt, bis in der ausgew hlten Mulde mindestens ein Spielstein liegt, denn leere Felder kann man nicht spielen. In Zeile 15 endet diese If-Abfrage. Die Zeilen 11 bis 15 k nnte man sich sparen, denn ergibt der externe Spieler einen ung ltigen Zug (z.B. F=13 oder F=3 und Brett[3]=0), so wird sowieso per Zufall ein Feld ausgew @endnode @node Exec "Das Executer-Utility" Das Zuastzprogramm "Executer" ------------------------------- Das Programm Executer ist f r die Synchron-Funktion von Mancala im speziellen und f r AmigaDOS allgemein n tzlich. Systemvoraussetzungen: Dieses Programm ben tigt OS 2.0 oder h her, da es die Notify()-Funktion des neuen Betriebssytems nutzt. erdem mu die CanDo-Library installiert sein. Starten: Einfach aufrufen oder doppelklicken. Nach dem Start wird ein kleines Fenster ge ffnet. Ab jetzt wird das Verzeichnis RAM: berwacht. Sobald dort eine Datei namens "Executer.skript" hinkopiert wird, wird der Execute-Befehl auf die Datei angewandt und die Datei danach sofort wieder gel scht. Man kann damit also ein Programm starten, indem man eine Datei kopiert. Diese Datei kann leicht ber ein Netzwerk geschickt werden, wo es doch oft so schwer ist, am anderen Netzende AUF dem anderen Rechner ein Programm zu starten. Es gibt zwar viele andere L sungen hierf aber dieses Programm l st das Problem sehr elegant und ist noch dazu nur 904 Bytes gro @endnode