home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 8 / amigaformatcd08.iso / screenplay / shareware / mancala / mancala.guide (.txt) < prev    next >
Amigaguide Document  |  1996-09-30  |  57KB  |  1,705 lines
  1. @database "Mancala"
  2. @author Oliver Gr
  3. @(c) "
  4. 1994-96 Oliver Gr
  5. @$VER: Mancala.guide 3.47
  6. ## 1. Oktober 1996
  7. @node Main "Mancala"
  8.               MANCALA
  9.              ---------
  10.        AmigaGuide f
  11. r Mancala
  12.   Mancala ist 
  13. 1994-95 Oliver Gr
  14.         Mancala ist Freeware
  15.         @{" Rechtliches          " link Rechtliches}
  16.         @{" Spielregeln          " link Regeln}
  17.         @{" Installation         " link Installation}
  18.         @{" Bedienung            " link Bedienung}
  19.          @{" - Optionsfenster    " link Optionen}
  20.          @{" - Spielertypen      " link Typ}
  21.         @{" Partie-Editor        " link PEd}
  22.         @{" ARexx-Befehle        " link ARexx}
  23.         @{" Synchronisierung     " link Synchron}
  24.         @{" Externe Spieler      " link Extern}
  25.          @{" - Variablen         " link Vars}
  26.          @{" - Befehle           " link Bef}
  27.          @{" - Beispiel          " link Beispiel}
  28.         @{" Das Executer-Utility " link Exec}
  29.   Mancala wurde mit CanDo programmiert.
  30.   CanDo ist 
  31.  Copyright Inovatronics
  32.   Workbench ist 
  33.  Commodore Business Machines
  34.   ARexx ist 
  35.  Bill Hawes (Thank you ! Great !!!)
  36. @endnode
  37. ## *** Spielregeln *********************************************
  38. @node Rechtliches "Rechtliches"
  39.   Das Rechtliche
  40.  ----------------
  41.  Dieses Programm und alle mitgelieferten Dateien
  42.  sind Freeware mit den folgenden Einschr
  43. nkungen:
  44.  - Das Programmpaket darf immer nur komplett mit
  45.    allen dazugeh
  46. rigen Dateien kopiert werden.
  47.  - An keiner der Dateien d
  48. rfen ohne meine vorherige
  49.    Erlaubnis Ver
  50. nderungen vorgenommen werden.
  51.  - Wer Verbesserungsvorschl
  52. ge hat oder es endlich geschafft hat,
  53.    einen starken Computerspieler zu programmieren, soll sich bei mir
  54.    unter der unten genannten Adresse melden. Sollte seine Arbeit
  55.    Verwendung finden, wird er selbstverst
  56. ndlich als Co-Autor
  57.    genannt.
  58.  - Wenn dieses Paket auf Disketten weitergegeben wird, darf nur eine
  59.    Aufwandsentsch
  60. digung verlangt werden. Auf keinen Fall darf dieses
  61.    Paket auf Disketten weitergegeben werden, die mehr als DM 3,-- oder
  62.    den entsprechenden Betrag in einer anderen W
  63. hrung kosten.
  64.  - Wird dieses Paket auf CD-ROM weitergegeben, darf der Preis
  65.    der CD den Betrag von DM 40,-- oder den entsprechenden Betrag
  66.    in einer anderen W
  67. hrung nicht 
  68. bersteigen.
  69.  - Dieses Paket, auch nicht Teile daraus, d
  70. rfen nicht im Rahmen
  71.    einer kommerziellen Ver
  72. ffentlichung erscheinen, da dies die
  73.    Nutzungsbestimmungen von CanDo (
  74.  Inovatronics) verbieten !
  75.    Daran soll der folgende Text erinnern, der mit jedem
  76.    CanDo-Programm ausgeliefert werden mu
  77.     This program was designed and written with CanDo v3.0 
  78. 1995.
  79.     Inovatronics, Inc.
  80.     8499 Greenville Ave. #209B
  81.     Dallas, TX  75231  USA
  82.     (214)340-4991, FAX 340-8514
  83.     CanDo, Deckbrowser and their support libraries are
  84.     the copyrighted sole property of Inovatronics, Inc.
  85.     Reproduction and distribution for any use other than
  86.     non-commercial applications is strictly prohibited.
  87. r weitere Fragen wenden Sie sich bitte an:
  88.   Oliver Gr
  89.   Stemmering 46
  90.   45259 Essen
  91.   Sorry, nur snail-mail, hab' noch kein Modem !
  92. @endnode
  93. @node Regeln      "Spielregeln"
  94.   Die Spielregeln
  95.  -----------------
  96. Mancala spielt man zu zweit auf einem Brett mit 12 Mulden und 2 Zielfeldern.
  97. Dem ersten Spieler geh
  98. ren die oberen 6 Mulden und das linke Zielfeld,
  99. dem zweiten geh
  100. ren die unteren 6 Mulden und das rechte Zielfeld.
  101.   @{" Illustration des Spielfeldes " link Mancala.guide.Bild1/main} (F
  102. r Kickstart/Workbench 3.0)
  103.   @{" Illustration des Spielfeldes " system "SYS:Utilities/WDisplay Mancala.guide.Bild1"} (F
  104. r Kick/WB 2.0 mit WDisplay)
  105. Zu Beginn des Spiels liegen in jeder der 12 Mulden 4 Spielsteine.
  106. Beide Spieler versuchen nun, im Verlauf des Spiels m
  107. glichst viele Spielsteine
  108. in das eigene Zielfeld zu bringen, denn wer am Ende mehr hat, hat gewonnen.
  109. Das Spiel beginnt, wenn der Spieler 1 eine der 12 Mulden mit der Maus anklickt.
  110. Diese Mulde wird nun geleert und alle darin enthaltenen Spielsteine werden
  111. gegen den Uhrzeigersinn in die anderen Mulden verteilt. Gelangt man dabei an
  112. das eigene Zielfeld, wird der Spielstein hineingelegt und man hat einen Punkt.
  113. Das Zielfeld des anderen Spielers wird beim Verteilen einfach 
  114. bersprungen.
  115. tzlich zu diesem normalen Zugschema gibt es einige Sonderregeln.
  116. Sollte der letzte Spielstein eines Zuges in das eigene Zielfeld fallen,
  117. so ist der Spieler, der den Zug ausgef
  118. hrt hat, nochmal dran.
  119. llt der letzte Spielstein eines Zuges in eine leere Mulde, so wird
  120. automatisch die dar
  121. ber- bzw. darunterliegende Mulde ebenfalls ausgeleert
  122. und f
  123. r denselben Spieler gespielt. Landet der letzte wieder in einer
  124. leeren Mulde, so wird auch diese gespielt und so weiter.
  125. Ist der Zug beendet, ist der andere Spieler dran.
  126. Das geht solange, bis oben oder unten alle Mulden leer sind.
  127. Sind also zum Beispiel die oberen 6 Mulden leer (also die von Spieler 1),
  128. so erh
  129. lt Spieler 2 automatisch alle in den unteren Mulden 
  130. briggebliebenen
  131. Spielsteine und das Spiel ist beendet. Man mu
  132.  also aufpassen, seine eigenen
  133. Mulden nicht zu leer werden zu lassen, denn auch der andere Spieler kann
  134. diese leeren und so eventuell das Spiel zu seinen Gunsten beenden.
  135. @endnode
  136. ## *** Installation ********************************************
  137. @node Installation "Installation"
  138.   Die Installation
  139.  ------------------ 
  140.  Die Installation braucht man nicht gro
  141.  erkl
  142.  Schublade auf die Festplatte ziehen, fertig !
  143.  Es gibt zwei Versionen des Programms.
  144.  Welche sie benutzen sollten und warum, lesen sie weiter unten.
  145.  Viel umfangreicher sind die Vorraussetzungen zum Start:
  146. chst einmal eine schlechte Nachricht : Mancala braucht viel RAM.
  147.  Mindestens 1,5 MB davon mu
  148.  man in seinem Rechner haben, beser 2 MB.
  149.  Jetzt eine noch schlechtere Nachricht: Die voll funktionsf
  150. hige Version
  151.  von Mancala ben
  152. tigt die Libraries von CanDo ! Diese haben immer noch
  153.  keine wirklich eindeutigen Weitergabebestimmungen, weshalb sie in
  154.  dieser Ver
  155. ffentlichung nicht beiliegen.
  156.  Da aber neben den Besitzern der Vollversion von CanDo und der Versionen
  157.  von den AmigaPlus-Coverdisks und CDs wahrscheinlich auch noch viele die
  158.  Dateien als Raubkopie auf ihrem Rechner haben, d
  159. rfte die Library-Version
  160.  von Mancala dennoch ihre Zielgruppe finden ;-)
  161. r diejenigen, die leider nicht die Library-Version verwenden k
  162. nnen,
  163.  gibt es noch das Programm "MancalaNoLib", bei dem dann leider keine
  164.  externen Spieler verwendet werden k
  165. nnen. Um diese Version zu verwenden,
  166. schen Sie bitte die Datei "Mancala" und benennen dann "MancalaNoLib"
  167.  um in "Mancala". Desweiteren k
  168. nnen Sie die Programme "Partie-Editor"
  169.  und "Executer" sowie die Schublade "Spieler" samt Inhalt l
  170. schen,
  171.  denn diese Dateien ben
  172. tigen ebenfalls die Library-Version.
  173.  Alle Benutzer der Library-Version k
  174. nnen "MancalaNoLib" l
  175. schen.
  176.  Sehr wichtig :
  177.  Die Dateien "Mancala.info" und "Partie-Editor.info" d
  178. rfen nicht umbenannt
  179.  werden !!! Wenn man die Online-Hilfe nutzen m
  180. chte, mu
  181. mlich der Pfad
  182. r die Datei "Mancala.guide", also diese Datei, bei den ToolTypes der
  183.  beiden Icons unter "HilfsPfad=" eingetragen werden.
  184.  Dazu klickt man das jeweilige Icon an und w
  185. hlt "Informationen" aus dem
  186.  "Piktogramm"-Men
  187.  der Workbench aus. Im erscheinenden Fenster klickt man
  188.  auf "Neu" bzw. "New" und tr
  189. gt dann "HilfsPfad=" gefolgt vom Pfad ein.
  190.  Anschlie
  191. end auf "Speichern" bzw. "Save" klicken. Fertig !
  192.  Beispiel : "RAM:Texte/Mancala.guide" + Return + Speichern
  193.  Im Icon des Hauptprogrammes kann man au
  194. erdem noch das ToolType
  195.  "SynchronBefehl=" eintragen. Es definiert den Pfad f
  196. r das
  197.  Programm, das von der @{" Synchron-Funktion " link Synchron} aufgerufen wird.
  198. erdem sind f
  199. r ein einwandfreies Arbeiten mit Mancala einige
  200.  Dateien der Workbench n
  201.  - Der Font "Courier" sollte in Gr
  202. e 13 installiert sein.
  203.  - In ENVARC: bzw. ENV: sollte die Datei "palette.ilbm" stehen,
  204.    die die Farben der Workbench definiert. Bei meiner Workbench
  205.    macht das das "Palette" Programm aus der Prefs-Schublade.
  206. erdem mu
  207. , wenn Mancala auf der Workbench laufen soll, die Workbench
  208.  mindestens 3 Bitplanes (8 Farben) haben und der Screen mu
  209.  mindestens
  210.  eine Gr
  211. e von 640*400 Punkten haben. Es kann z.B. auch ein Screen
  212.  mit dem Screenmode Hires-NonInterlaced sein, der autoscrollend ist.
  213.  So kann man den Flimmerbildschirm umgehen. Erf
  214. llt die Workbench
  215.  diese Vorraussetzungen nicht, so wird ein Hires-Interlaced Screen
  216.  mit 640*400 Punkten und 8 Farben ge
  217. ffnet.
  218.  Sind alle diese Vorkehrungen getroffen, kann Mancala problemlos per
  219.  Doppelklick von der Workbench oder per Aufruf aus dem CLI gestartet werden.
  220. r den Partie-Editor sollten exakt die gleichen Dateien verf
  221. gbar sein.
  222.  Ach ja, Workbench 2.0 braucht man nat
  223. rlich auch :-)
  224. @endnode
  225. ## *** Men
  226.  Bedienung ******************************************
  227. @node Bedienung "Bedienung"
  228.   Die Bedienung
  229.  ---------------
  230.  Nachdem Mancala gestartet wurde, werden die gespeicherten Voreinstellungen
  231.  geladen. Beim ersten Starten des Programmes wird sich der Screen in Rott
  232.  einf
  233. rben. Mancala ver
  234. ndert die Farben des Workbenchscreens, allerdings
  235.  werden diese beim Programmende wiederhergestellt.
  236.  In der Mitte des Fensters ist das @{" Spielbrett " link Brett} zu sehen.
  237.  Am unteren Rand des Fensters sind 6 Gadgets zu sehen :
  238.  @{" NEUES SPIEL   " link Neu}    @{" SPIELREGELN   " link CallRegeln}    @{" ZUR
  239. CKNEHMEN  " link Undo}
  240.  @{" SPIEL BEENDEN " link Spielende}    @{" OPTIONEN      " link Optionen}    @{" PROGRAMMENDE  " link ProgEnde}
  241. erdem besitzt das Fenster noch 2 Men
  242.  Projekt                 Utilities
  243.  ----------              ----------
  244.  @{" Neues Spiel   " link Neu}         @{" Partie-Editor         " link CallPEd}
  245.  @{" Spiel beenden " link Spielende}         @{" Hilfsmodus            " link CallHelp}
  246.  @{" Programminfo  " link Info}         @{" Zug r
  247. ngig machen " link Undo}
  248.  @{" Greetings     " link Greet}
  249.  @{" Programmende  " link ProgEnde}
  250. @endnode
  251. @node Brett      "Das Spielbrett"
  252. @toc Bedienung
  253.   Das Spielbrett
  254.  ----------------
  255.  Das Spielbrett besteht aus 12 runden Mulden und 2 eckigen Mulden.
  256.  Die 2 eckigen sind die Zielfelder der beiden Spieler.
  257.  Das linke geh
  258. rt Spieler 1 und das rechte Spieler 2.
  259.  Spielen kann man nur mit den 12 runden Mulden.
  260.  Um eine Mulde zu spielen, wird sie einfach angeklickt.
  261. @endnode
  262. @node Neu        "Neues Spiel"
  263. @toc Bedienung
  264.   Neues Spiel
  265.  -------------
  266. -Aufruf  : Rechte Amiga-Taste + n
  267.  ARexx-Befehl : CallNeu
  268.  Das Spielbrett wird gel
  269. scht und dann neu aufgebaut.
  270.  Dann ist der linke Spieler am Zug (Spieler 1).
  271.  Hiermit kann man nicht nur ein Neues Spiel beginnen, nachdem
  272.  man das vorige beendet hat, sondern man kann ein laufendes
  273.  Spiel abbrechen und sofort ein neues beginnen.
  274. @endnode
  275. @node Spielende  "Spielende"
  276. @toc Bedienung
  277.   Spiel beenden
  278.  ---------------
  279. -Aufruf  : Rechte Amiga-Taste + e
  280.  ARexx-Befehl : CallSpielende
  281.  Hiermit kann man ein bereits laufendes Spiel vorzeitig beenden.
  282.  Die Steine in den beiden Zielmulden werden gez
  283. hlt und ein
  284.  Requester erscheint, in dem der Sieger bekanntgegeben wird.
  285.  Wenn ein Mensch gegen den Computer gespielt hat, gibt der
  286.  Computer in diesem Requester seinen Kommentar zur Partie.
  287. @endnode
  288. @node CallRegeln "Spielregeln"
  289. @toc Bedienung
  290.   Spielregeln
  291.  -------------
  292.  Hiermit wird, falls Mancala richtig @{" installiert " link Installation} wurde, der
  293.  AmigaGuide von Mancala an der Stelle ge
  294. ffnet, an der die
  295.  @{" Spielregeln " link Regeln} f
  296. r Mancala nachgelesen werden k
  297. nnen.
  298. @endnode
  299. @node Info       "Programminfo"
  300. @toc Bedienung
  301.   Programminfo
  302.  --------------
  303. -Aufruf  : Rechte Amiga-Taste + i
  304.  ARexx-Befehl : CallAbout
  305.  Hiermit wird ein Fenster mit Namen und Adresse des Programmautors ge
  306. ffnet.
  307. tzlich ist hier auch die Version des Programmes, das Datum der
  308.  Fertigstellung dieser Version und der Name des ARexx-Ports abzulesen.
  309.  Bugreports und Vorschl
  310. ge bitte mit der Versionsnummer
  311.  und dem Datum an die angegebene Adresse schicken.
  312. @endnode
  313. @node Undo       "Zug r
  314. ngig machen"
  315. @toc Bedienung
  316.   Zug r
  317. ngig machen
  318.  -----------------------
  319. -Aufruf  : Rechte Amiga-Taste + u
  320.  ARexx-Befehl : CallUndo
  321.  Diese Funktion macht nicht nur einfach den letzten Zug r
  322. ngig.
  323.  Vielmehr verh
  324. lt sie sich in gewisser Weise intelligent.
  325.  Wenn zwei Menschen gegeneinander spielen,
  326.  so wird einfach nur der letzte Zug r
  327. ngig gemacht.
  328.  Jeder der beiden Spieler kann also auch zum Beispiel
  329.  eine Zugserie im Nachhinein anders gestalten.
  330.  Spielt ein Mensch gegen den Computer, so werden so viele
  331. ngig gemacht, wie der menschliche Spieler
  332.  braucht, um SEINEN letzten Zug zu korrigieren.
  333. rde man einfach nur den letzten Zug r
  334.  machen und der Computer hatte gerade eine Serie, so
  335.  ist nach dem R
  336. ngigmachen der Computer dran und
  337.  der wird wahrscheinlich genau seinen Zug wiederholen.
  338.  Spielen zwei Computerspieler gegeneinader, so
  339.  bewirkt das Aufrufen dieser Funktion gar nichts.
  340.  Man kann durch mehrmaliges Aufrufen dieser Funktion
  341.  das Brett in den Anfangszustand zur
  342. cksezten.
  343. @endnode
  344. @node ProgEnde   "Programmende"
  345. @toc Bedienung
  346.   Programmende
  347.  --------------
  348. -Aufruf : Rechte Amiga-Taste + q
  349.  Es wird eine Sicherheitsabfrage ge
  350. ffnet, in der sich der
  351.  Benutzer seine Entscheidung nochmal gr
  352. ndlich 
  353. berlegen kann.
  354.  Best
  355. tigt er sein Entscheidung, wird das Mancala-Fenster bzw.
  356.  der Mancala-Screen wieder geschlossen und die Originalfarben
  357.  der Workbench werden wiederhergestellt.
  358. @endnode
  359. @node Greet      "Greetings"
  360. @toc Bedienung
  361.   Greetings
  362.  -----------
  363. -Aufruf  : Rechte Amiga-Taste + g
  364.  ARexx-Befehl : CallGreetings
  365.  Es erscheint ein Requester, in dem der Autor diversen
  366.  Leuten f
  367. r ihre Mithilfe oder ihre Ideen dankt.
  368. @endnode
  369. @node CallPEd    "Partie-Editor"
  370. @toc Bedienung
  371.   Partie-Editor
  372.  ---------------
  373. -Aufruf : Rechte Amiga-Taste + p
  374.  Hiermit kann der @{" Partie-Editor " link PEd} aus Mancala heraus aufgerufen werden.
  375.  Dazu mu
  376.  die separate Datei "Partie-Editor" nicht vorhanden sein.
  377.  Der Editor ist ins Hauptprogramm integriert.
  378. @endnode
  379. @node CallHelp   "Hilfsmodus"
  380. @toc Bedienung
  381.   Hilfsmodus
  382.  ------------
  383. -Aufruf : Rechte Amiga-Taste + h oder auch einfach die Help-Taste
  384.  Hiermit wird in allen aktiven Fenstern von Mancala der Hilfsmodus
  385.  aktiviert. Damit man das auch merkt, wird in allen Fenstern an
  386.  den Fenstertitel die Bemerkung "(Hilfsmodus)" geh
  387.  Wenn man jetzt auf einen beliebigen Knopf in einem der Fenster klickt,
  388.  erscheint der AmigaGuide (TM) von Mancala und zeigt die passende
  389.  Information zum angeklickten Objekt an. Das funktioniert mit fast
  390.  allen Objekten des gesamten Spiels.
  391. rlich bekommt man keine Hilfe zum Men
  392. punkt Hilfsmodus selbst !!!
  393.  Achtung !!!
  394.  Diese Funktion ist nur dann verf
  395. gbar, wenn in den ToolTypes
  396.  ein korrekter Pfad f
  397. r die Guide-Datei eingetragen ist !!
  398. here Informationen siehe @{" Installation " link Installation}.
  399. @endnode
  400. ## *** Men
  401.  Optionen *******************************************
  402. @node Optionen "Optionen"
  403. @toc Bedienung
  404.   Optionen
  405.  ----------
  406.  Hiermit wird das Optionsfenster aufgerufen, in dem man zahlreiche
  407.  Parameter des Programms ver
  408. ndern kann.
  409.   @{" Illustration des Optionsfensters " link Mancala.guide.Bild3/main} (F
  410. r Kickstart/Workbench 3.0+)
  411.   @{" Illustration des Optionsfensters " system "SYS:Utilities/WDisplay Mancala.guide.Bild3"} (F
  412. r Kick/WB 2.0 mit WDisplay)
  413.  Rechts neben "Spieler 1 :" und "Spieler 2 :" sind zwei Stringgadgets,
  414.  in die man Die Namen der beiden Spieler eintragen kann.
  415.  Rechts daneben sind zwei sogenannte Cycle-Gadgets, mit denen
  416.  man den @{" Typ " link Typ} des jeweiligen Spielers ausw
  417. hlen kann.
  418.  Darunter steht bei "Extern 1:" bzw. "Extern 2:" jeweils ein Gadget :
  419.  @{" LADEN                   " link LoadEx}
  420. erdem gibt es hier noch einige Gadgets :
  421.  @{" Punktzahlen anzeigen    " link ShowPunkte}
  422.  @{" Muldenbeschriftung      " link Beschriftung}
  423.  @{" Zugverz
  424. gerung          " link Verz
  425. gerung}
  426.  @{" Synchronisierung        " link Synchron}
  427.  @{" EINSTELLUNGEN SPEICHERN " link Speichern}
  428.  @{" BEENDEN                 " link QuitOpt}
  429.  Ganz unten links ist noch ein Cycle Gadget zu sehen :
  430.  @{" Farben                  " link Farben}
  431. @endnode
  432. ## *** Men
  433.  Spielst
  434. rken ***************************************
  435. @node Typ    "Spielertypen"
  436. @toc Optionen
  437.   Spielertypen
  438.  --------------
  439.  Neben dem menschlichen Spieler gibt es noch Computerspieler.
  440.  Der Computer kennt drei interne Spielst
  441. rken, au
  442. erdem gibt
  443.  es noch die M
  444. glichkeit, externe Spieler zu laden.
  445.  Menschliche Spieler
  446.  @{" Mensch               " link Mensch}
  447.  Interne Computerspieler
  448.  @{" Computer (Normal)    " link Normal}
  449.  @{" Computer (Gemein)    " link Gemein}
  450.  @{" Computer (Taktik)    " link Taktik}
  451.  Externe Computerspieler
  452.  @{" Computer (Extern 1)  " link ExP}
  453.  @{" Computer (Extern 2)  " link ExP}
  454. @endnode
  455. @node Mensch "Menschlicher Spieler"
  456. @toc Optionen
  457.   Mensch
  458.  --------
  459.  Der menschliche Spieler wird selbstverst
  460. ndlich von einer der
  461.  Personen 
  462. bernommen, die VOR dem Computer sind und nicht darin.
  463.  Stellt man beide Spieler auf Mensch, so verh
  464. lt sich Mancala
  465.  wie ein einfaches Spielbrett. Es f
  466. hrt nur die Z
  467. ge durch.
  468. @endnode
  469. @node Normal "Computerspieler : Normal"
  470. @toc St
  471.   Normal
  472.  --------
  473.  In dieser Einstellung spielt der Computer noch sehr dumm.
  474.  Er kann zwar in begrenztem Umfang schon einsammeln, hat
  475.  aber noch arge Probleme, Taktiken zu erkennen oder gar
  476.  zu durchkreuzen.
  477. @endnode
  478. @node Gemein "Computerspieler : Gemein"
  479. @toc St
  480.   Gemein
  481.  --------
  482.  Dies ist die Weiterentwicklung von @{" Normal " link Normal}.
  483.  Der Computerspieler kann jetzt sehr gut einsammeln.
  484.  Er ist taktisch zwar immer noch sehr dumm, aber er versucht
  485.  bereits rabiat, Einsammelm
  486. glichkeiten des anderen Spielers
  487.  zu verhindern.
  488. @endnode
  489. @node Taktik "Computerspieler : Taktik"
  490. @toc St
  491.   Taktik
  492.  --------
  493.  Dieser Spieler ist nicht unbedingt immer besser
  494.  als @{" Gemein " link Gemein}, er ist vollkommen anders konzipiert.
  495.  Der Computerspieler kann hier am besten einsammeln.
  496.  Er hat dann aber nachher eine vollkommen andere
  497.  Taktik, den Zug zu beenden.
  498. @endnode
  499. @node ExP    "Computerspieler : Extern"
  500. @toc St
  501.   Externer Spieler
  502.  ------------------
  503.  Man kann bis zu zwei externe Spieler einladen, die durch
  504.  eine Textdatei definiert sind. Es gibt die M
  505. glichkeit,
  506.  zwei verschiedene externe Spieler einzuladen, damit auch
  507.  ein Turnier zwischen verschiedenen selbstprogrammierten
  508.  Spielern m
  509. glich ist.
  510. @endnode
  511. ## *** Unterpunkte Optionen ************************************
  512. @node LoadEx       "Externen Spieler laden"
  513. @toc Optionen
  514.   Laden
  515.  -------
  516.  Mit diesem Knopf kann ein Filerequester ge
  517. ffnet werden.
  518.  In diesem kann man dann eine Datei ausw
  519. hlen, die einen
  520.  externen Spieler darstellt. Ist es tats
  521. chlich ein
  522.  externer Spieler, so wird die Datei geladen und es
  523.  erscheint ein Kommentar neben dem Gadget.
  524.  Mit dem oberen Knopf kann die Datei f
  525. r den ersten externen
  526.  Spieler ausgew
  527. hlt werden, mit dem unteren die f
  528. r den zweiten.
  529.  Eine Anleitung, wie man einen externen Spieler programmiert,
  530.  ist im Abschnitt @{" Externe Spieler " link Extern} zu finden.
  531. @endnode
  532. @node ShowPunkte   "Punktzahlen anzeigen"
  533. @toc Optionen
  534.   Punktzahlen anzeigen
  535.  ----------------------
  536.  Mit diesem Gadget kann die Anzeige der Punktzahlen der
  537.  beiden Spieler w
  538. hrend des Spiels abgeschaltet werden.
  539.  Einige haben es gerne spannend bis zum Schlu
  540.  andere hingegen wollen immer voll im Bilde sein.
  541.  Ist ein H
  542. kchen zu sehen, so werden die Punkte angezeigt.
  543. @endnode
  544. @node Beschriftung "Muldenbeschriftung"
  545. @toc Optionen
  546.   Muldenbeschriftung
  547.  --------------------
  548.  Hiermit kann man w
  549. hlen, ob an den Mulden die jeweilige
  550.  Nummer der Mulde stehen soll. Dies ist sehr hilfreich,
  551.  wenn man eine Analyse aus dem Partie-Editor nachvollziehen
  552.  will oder aber z.B. durchs Telefon spielt.
  553.  Ist ein H
  554. kchen zu sehen, dann ist die Beschriftung an.
  555. @endnode
  556. @node Verz
  557. gerung  "Zugverz
  558. gerung"
  559. @toc Optionen
  560.   Zugverz
  561. gerung
  562.  ----------------
  563.  Wenn ein Zug ausgef
  564. hrt wird, so gibt es beim Verteilen
  565.  der Spielsteine auf die anderen Mulden jeweils eine Pause
  566.  von etwa einer Zwanzigstel-Sekunde. Das soll helfen, bei
  567.  einer Turbokarte die Z
  568. ge noch verfolgbar zu machen.
  569.  Hiermit kann man sie deaktivieren.
  570.  Ist ein H
  571. kchen zu sehen, so ist die Verz
  572. gerung eingeschaltet.
  573. @endnode
  574. @node Synchron     "Synchronisierung"
  575. @toc Optionen
  576.   Synchronisierung
  577.  ------------------
  578.  Diese Funktion kann eigentlich f
  579. r fast alles benutzt werden.
  580.  Das Wort Synchronisierung hei
  581. t, da
  582.  Mancala synchron zu
  583.  allen Aktionen des Spiels ein vom Benutzer definiertes
  584.  Programm startet und diesem die Aktionen 
  585. bermittelt.
  586.   Weitere Informationen
  587.   @{" Anwendungsbeispiele       " link SynM
  588.   @{" Installation              " link SynInst}
  589.   @{" Format der Parameter      " link SynFormat}
  590.   @{" Wann erfolgt der Aufruf ? " link SynWann}
  591.  Hier sind die Parameter, die Mancala dem Programm 
  592. bergeben kann :
  593.   @{" Undo      " link SynUndo}
  594.   @{" Neu       " link SynNeu}
  595.   @{" Spielende " link SynSpielende}
  596.   @{" Zug       " link SynZug}
  597. @endnode
  598. @node Speichern    "Einstellungen speichern"
  599. @toc Optionen
  600.   Einstellungen speichern
  601.  -------------------------
  602.  Mit diesem Knopf werden alle Einstellungen abgespeichert,
  603.  die im Optionsfenster eingestellt werden k
  604. nnen:
  605.   - Die Spielernamen
  606.   - Die Spielst
  607. rken der beiden Spieler
  608.   - Die Definitionen f
  609. r die externen Spieler
  610.   - Die Wahl, ob die Punkte gezeigt werden sollen
  611.   - Die gew
  612. hlten Farben
  613. @endnode
  614. @node Farben       "Farben"
  615. @toc Optionen
  616.   Farben
  617.  --------
  618.  Mit diesem Cycle-Gadget kann man diverse Farbeinstellungen ausw
  619. hlen :
  620.   Rott
  621. ne    - Alles in rot
  622. ne   - In gr
  623. n und orange
  624.   Blaut
  625. ne   - Alles in blau
  626.   Graurot    - Workbench-Grau mit rot
  627.   Braunt
  628. ne  - Dunkle Braunt
  629.   Workbench  - Original-Workbenchfarben
  630.  Der Punkt Workbench setzt voraus, da
  631.  die Datei "ENV:sys/palette.ilbm"
  632.  existiert. Ich arbeite mit Workbench 2.1, und da speichert das Programm
  633.  "Palette" aus der Prefs-Schublade diese Datei ab. Ich wei
  634.  allerdings
  635.  nicht, wie dies bei anderen Workbenchversionen geht.
  636.  Existiert die Datei nicht, so werden h
  637. ufig verwendete Workbench-Farben
  638.  angezeigt, die hoffentlich ebenfalls den gew
  639. nschten Effekt erzielen.
  640. @endnode
  641. @node QuitOpt      "Optionen Beenden"
  642. @toc Optionen
  643.   Beenden
  644.  ---------
  645.  Hiermit wird das Optionsfenster wieder geschlossen.
  646.  Der Knopf hat die gleiche Funktion wie das Close-Gadget des Fensters.
  647. @endnode
  648. ## *** Synchron-Unterpunkte ************************************
  649. @node SynM
  650. g       "Anwendungsbeispiele"
  651. @toc Synchron
  652.   Was geht ?
  653.  ------------
  654.  Hier nur einige der vielen Anwendungsm
  655. glichkeiten :
  656.  - Man l
  657. t ein ARexx-Skript automatisch ein
  658.    Protokoll aller Aktionen anfertigen.
  659.  - Man kann per ARexx-Skript 
  660. ber Netzwek oder Nullmodem an
  661.    zwei verschiedenen Computern Mancala gegeneinander spielen.
  662.  - Man kann per Zufall Bilder, Samples oder 
  663. hnliches
  664.    in die Partie einblenden und sie so auflockern.
  665.  Wahrscheinlich gibt es eine Menge M
  666. glichkeiten,
  667.  die mir jetzt auf Anhieb gar nicht einfallen !
  668. @endnode
  669. @node SynInst      "Installation"
  670. @toc Synchron
  671.   Installation der Synchron-Funktion
  672.  ------------------------------------
  673.  Um die Synchron-Funktion zu nutzen, mu
  674.  im Icon von
  675.  Mancala das ToolType "SynchronBefehl" eingetragen werden.
  676.  Dieser Befehl wird dann mit den jeweiligen Parametern
  677.  aufgerufen. Am sinnvollsten ist es, hier ein DOS-Skript
  678.  oder ein ARexx-Skript aufzurufen.
  679.  Beispiele :
  680.   SynchronBefehl=C:Execute S:Synchron.bat
  681.   SynchronBefehl=RX Rexx:Synchron.rexx
  682.   SynchronBefehl=SYS:System/Format drive DH0: name "Leer" noicons ffs
  683.  ?????)
  684. @endnode
  685. @node SynFormat    "Format der Parameter"
  686. @toc Synchron
  687.   Das Format
  688.  ------------
  689.  Dem vom Benutzer im Icon festgelegten Programm, welches
  690.  selbstverst
  691. ndlich auch ein ARexx-Skript sein kann, werden
  692.  Parameter in einem festgelegten Format 
  693. bergeben.
  694.  Zuerst kommt immer die Nummer des ARexx-Ports des aufrufenden Mancalas.
  695.  Wenn also auf einem Computer mehrere Mancalas laufen und auf
  696.  dem zweiten wird ein Zug durchgef
  697. hrt, so wird als erster
  698.  Parameter eine 2 
  699. bergeben.
  700.  Es folgt das Parameterwort, das die Art der Aktion auf dem aufrufenden
  701.  Mancala erkl
  702. rt. Wurde ein neues Spiel gestartet, so steht hier "Neu".
  703.  Danach kommen je nach Aktion noch diverse weitere Parameter.
  704.  Beispiel:
  705.  Die Parameter sehen so aus : "1 Zug 2 8"
  706.  Man interpretiert das dann w
  707. rtlich zum Beispiel so :
  708.  "Das 1. Mancala meldet Zug von Spieler 2 auf Feld 8"
  709.  Man trennt die Ergebnisse mit ARexx genauso
  710.  wie die Antworten auf eine "Get..." Anfrage.
  711.  Siehe : @{" Wie kommt man an die Ergebnisse ? " link AErgs}
  712. @endnode
  713. @node SynWann      "Wann erfolgt der Aufruf ?"
  714. @toc Synchron
  715.   Wann erfolgt der Aufruf ?
  716.  ---------------------------
  717.  Das definierte Programm wird aufgerufen,
  718.  BEVOR die gemeldete Aktion tats
  719. chlich stattfindet.
  720.  Dies ist bei einer Neztwerkverbindung vorteilhaft, da man so
  721.  keine Zeit verliert, bis die Information ihr Ziel erreicht.
  722.  Laufen allerdings zwei miteinander verbundene Mancalas auf EINEM
  723.  Rechner (mit ARexx-Skript verbunden), so f
  724. hrt ein sofortiges
  725.  Durchf
  726. hren der gemeldeten Aktion auf dem zweiten Mancala nur
  727.  zu einem totalen Zusammenbruch der Systemperformance, da
  728.  Mancala sehr rechenintensiv sein kann.
  729. erdem werden per ARexx aufgerufene Aktionen NICHT
  730. ckgemeldet, um eine Endlosschleife zu vermeiden :
  731.  Auf Mancala.1 wird auf "Neu" geklickt, Meldung kommt, ARexx sendet,
  732.  Mancala.2 f
  733. hrt auch Neu aus, Meldung kommt, ARexx sendet,
  734.  Mancala.1 f
  735. hrt wieder Neu aus, Meldung kommt, und so weiter.
  736.  Dies w
  737. rde zum Endlosaufruf von Neu f
  738. hren.
  739. @endnode
  740. @node SynUndo      "Undo"
  741. @toc Synchron
  742.   Undo
  743.  ------
  744.  Komplett : <Portnummer> Undo
  745.  Es wurde die Funktion @{" Undo " link Undo} aufgerufen.
  746. @endnode
  747. @node SynNeu       "Neu"
  748. @toc Synchron
  749.   Neu
  750.  -----
  751.  Komplett : <Portnummer> Neu
  752.  Es wurde die Funktion @{" Neues Spiel " link Neu} aufgerufen.
  753. @endnode
  754. @node SynSpielende "Spielende"
  755. @toc Synchron
  756.   Spielende
  757.  -----------
  758.  Komplett : <Portnummer> Spielende
  759.  Das Spiel wurde beendet und der Sieger ermittelt.
  760. @endnode
  761. @node SynZug       "Zug"
  762. @toc Synchron
  763.   Zug
  764.  -----
  765.  Komplett : <Portnummer> Zug <Spieler> <Feld>
  766.  Einer der Spieler hat einen Zug gemacht.
  767.  Es folgt die Nummer des Spielers, der den Zug gemacht hat.
  768.  Steht hier eine 1, so war es der linke Spieler, bei einer 2 der rechte.
  769.  Zuletzt kommt schlie
  770. lich das Feld, das gezogen wurde.
  771.  Hinweis :
  772.  Mit Zug sind nur solche Z
  773. ge gemeint, bei denen einer der Spieler
  774.  eine der 12 Mulden gew
  775. hlt hat. Eventuell automatisch nachfolgende
  776. ge werden nicht gemeldet, da sie selbstverst
  777. ndlich sind.
  778.  Auch ein eventuell per Netz empfangendes Mancala w
  779. re wohl
  780.  kaum der Meinung, ein automatisch nachfolgender Zug im Stil
  781.  "Letztes Feld leer, also gegen
  782. ber" mu
  783.  im noch extra gesagt
  784.  werden; es ist schlie
  785. lich nicht dumm !
  786. @endnode
  787. ## *** Partie-Editor Hauptmen
  788.  *********************************
  789. @node PEd        "Partie-Editor"
  790.   Der Partie-Editor
  791.  -------------------
  792.  Der Partie-Editor kann sowohl aus Mancala heraus als auch seperat
  793.  gestartet werden. In beiden F
  794. llen erscheint das gleiche Fenster.
  795.   @{" Illustration des Partie-Editors " link Mancala.guide.Bild2/main} (F
  796. r Kickstart/Workbench 3.0)
  797.   @{" Illustration des Partie-Editors " system "SYS:Utilities/WDisplay Mancala.guide.Bild2"} (F
  798. r Kick/WB 2.0 mit WDisplay)
  799.  Links ist eine @{" Liste " link PListe} zu sehen, die eventuell auch leer sein kann.
  800.  Rechts neben dieser Liste ist eine Reihe von Gadgets zu sehen :
  801.  @{" EDITOR BEENDEN        " link QuitPEd}   @{" POSITION HERSTELLEN   " link Herstellen}
  802.  @{" PARTIE LADEN          " link PLaden}   @{" AB HIER WEITERSPIELEN " link AbHier}
  803.  @{" PARTIE SPEICHERN      " link PSpeichern}   @{" Partie abh
  804. ren        " link H
  805.  Darunter gibt es noch ein Gadget :
  806.  @{" ZUGLISTE AUSGEBEN NACH >>> " link PAusgabe}
  807.  Rechts daneben ist ein Cycle-Gadget zu sehen. Es wechselt zwischen
  808.  "Drucker" und "Datei" und ist wichtig f
  809. r das linke Gadget.
  810.  Unten rechts ist eine @{" Miniaturausgabe des Spielfelds " link PMini} zu sehen.
  811.  Das Gadget "Partie abh
  812. ren" ist nur anw
  813. hlbar, wenn
  814.  der Partie-Editor aus Mancala heraus aufgerufen wurde.
  815. @endnode
  816. @node PMini      "Miniaturausgabe des Spielfelds"
  817. @toc PEd
  818.   Spielfeld
  819.  -----------
  820.  In diesem kleinen Spielfeld werden Positionen einer Partie dargestellt,
  821.  wenn man auf den Knopf @{" POSITION HERSTELLEN " link Herstellen} klickt.
  822.  Zur besseren 
  823. bersicht sind hier statt der entsprechenden Zahl
  824.  Spielsteinen Zahlen zu sehen. Eine 8 hei
  825. t also, da
  826.  hier acht
  827.  Spielsteine liegen.
  828.  Damit man nicht w
  829. hrend eines Spiels schummelt, ist die
  830.  Herstellen-Funktion w
  831. hrend eines Spiels gesperrt.
  832. @endnode
  833. @node PListe     "Liste"
  834. @toc PEd
  835.   Liste
  836.  -------
  837.  In der Liste werden die Z
  838. ge einer Partie dargestellt.
  839.  Ein Zug wird in der folgenden Form dargestellt :
  840.   Zugnummer : Spieler - Feld
  841.  Also z.B. "34:2-9", was bedeutet,
  842.  im 34. Zug Spieler 2 Feld 9 gespielt hat.
  843.  Ein Doppelklick auf die Liste bewirkt dasselbe wie ein
  844.  Anklicken des Knopfes @{" POSITION HERSTELLEN " link Herstellen}.
  845. @endnode
  846. @node QuitPEd    "Editor beenden"
  847. @toc PEd
  848.   Editor beenden
  849.  ----------------
  850.  Hiermit kann der Partie-Editor wieder verlassen werden.
  851.  Der Knopf hat die gleiche Funktion wie das Close-Gadget des Fensters.
  852. @endnode
  853. @node PLaden     "Partie laden"
  854. @toc PEd
  855.   Partie laden
  856.  --------------
  857.  Es wird ein Filerequester ge
  858. ffnet, in dem eine Partie-Datei ausgew
  859.  werden kann. Diese Datei wird geladen und falls es sich tats
  860. chlich um
  861.  eine Partie-Datei handelt, wird die Zugliste der Partie in die Liste
  862.  geschrieben. Gleichzeitig wird der Abh
  863. rmodus abgeschaltet.
  864. @endnode
  865. @node PSpeichern "Partie speichern"
  866. @toc PEd
  867.   Partie speichern
  868.  ------------------
  869.  Es wird ein Filerequester ge
  870. ffnet, in dem ein Dateiname ausgew
  871.  werden kann. Der Inhalt der Liste und alle Brettpositionen der Partie
  872.  werden in diese Datei abgespeichert.
  873. @endnode
  874. @node PAusgabe   "Zugliste ausgeben nach >>>"
  875. @toc PEd
  876.   Zugliste ausgeben nach >>>
  877.  ----------------------------
  878.  Wenn das Cycle-Gadget auf "Drucker" steht, wird der Inhalt
  879.  der Liste nach "PRT:", also auf den Drucker ausgegeben.
  880.  Steht das Cycle-Gadget auf "Datei", erscheint ein Filerequester,
  881.  in dem ein Dateiname ausgew
  882. hlt werden kann.
  883.  In diese Datei wird dann der Inhalt der Liste als ASCII-Text ausgegeben.
  884. @endnode
  885. @node Herstellen "Position Herstellen"
  886. @toc PEd
  887.   Position Herstellen
  888.  ---------------------
  889.  Dieses Gadget ist nur anw
  890. hlbar, wenn der Abh
  891. rmodus ausgeschaltet ist
  892.  oder aber momentan keine Partie l
  893. uft. Es ist also immer anw
  894. hlbar,
  895.  wenn der Partie-Editor ohne Mancala gestartet wurde.
  896.  Klickt man auf dieses Gadget und ist in der Liste am linken Fensterrand
  897.  ein g
  898. ltiger Zug angew
  899. hlt, so wird das Miniatur-Spielbrett am unteren
  900.  Fensterrand auf den Status des echten Spielbrettes dieser Partie NACH
  901.  dem angew
  902. hlten Zug gebracht.
  903.  Wenn es nicht anw
  904. hlbar ist, l
  905. uft gerade eine Partie, und wir wollen ja
  906.  nicht, da
  907.  jemand sich die Anzahl der Steine in den Mulden im Klartext
  908.  ansieht und daraus einen Vorteil hat.
  909.  Die gleiche Funktion wie dieser Knopf hat auch ein Doppelklick
  910.  auf eine Zeile der @{" Liste " link PListe} auf der linken Seite des Fensters.
  911. @endnode
  912. @node AbHier     "Ab hier weiterspielen"
  913. @toc PEd
  914.   Ab hier weiterspielen
  915.  -----------------------
  916.  Dieses Gadget hat eigentlich zwei Funktionen.
  917.  In jedem Fall mu
  918.  man zun
  919. chst aus der Liste einen Zug ausw
  920. hlen.
  921. tigt man dann das Gadget, folgt eine Sicherheitsabfrage, nach
  922.  der dann, falls man bejaht, folgendes passiert :
  923.  Ist @{" Partie abh
  924. ren " link H
  925. ren} eingeschaltet, so wird die Partie auf die
  926.  Brettposition nach dem gew
  927. hlten Zug zur
  928. ckgesetzt. Hiermit
  929.  kann man mehrere Aufrufe von @{" Zur
  930. cknehmen " link Undo} ersetzen.
  931.  Ist "Partie abh
  932. ren" aber ausgeschaltet, und das ist das eigentliche
  933.  Highlight dieser Funktion, so stellt Mancala das Spielbrett so wieder
  934.  her, wie es nach dem gew
  935. hlten Zug aussah und man kann weiterspielen.
  936.  So kann man alte abgespeicherte Partien auch nach Jahren noch
  937.  "wiederbeleben" und zu Ende spielen oder anders enden lassen.
  938.  ACHTUNG :
  939.  Bei einigen 
  940. lteren abgespeicherten Partien wurde eine wichtige
  941.  Information noch nicht mit abgespeichert. Bei diesen Partien
  942.  funktioniert die Funktion leider nicht ordnungsgem
  943. @endnode
  944. @node H
  945. ren      "Partie abh
  946. @toc PEd
  947.   Partie abh
  948.  ----------------
  949.  Dieses Gadget ist nur anw
  950. hlbar, wenn der Partie-Editor
  951.  aus Mancala heraus aufgerufen wurde.
  952.  Ist hier ein H
  953. kchen zu sehen, ist das Gadget also angew
  954.  so wird die momentan laufende Mancala-Partie abgeh
  955.  Das hei
  956. t folgendes:
  957.  Nach jedem Zug merkt sich der Partie-Editor, welches Feld
  958.  gespielt wurde, und wie das Spielbrett nach dem Zug aussah.
  959.  Der Zug wird im Format "Zugnummer : Spieler - Feld" in
  960.  die Liste getippt.
  961.  Nach dem Ende der Partie kann man diese Daten dann abspeichern.
  962. @endnode
  963. ## *** ARexx Hauptmen
  964.  *****************************************
  965. @node ARexx            "Der ARexx-Port"
  966.   Der ARexx-Port
  967.  ----------------
  968.  Mancala bietet dem Benutzer einen ARexx-Port.
  969.  Der Name des Ports ist normalerweise "Mancala.1".
  970.  Startet man mehr als ein Mancala auf einmal, so hei
  971.  der Port des zweiten Mancala's "Mancala.2" und so weiter.
  972.  Die zur Verf
  973. gung gestellten Befehle unterteilen sich in zwei Gruppen :
  974.   1. Information
  975.   @{" GetSpielStatus  " link AGetSpielStatus}
  976.   @{" GetSpielertypen " link AGetSpielertypen}
  977.   @{" GetBrett        " link AGetBrett}
  978.   @{" GetPunkte       " link AGetPunkte}
  979.   @{" GetSummen       " link AGetSummen}
  980.   @{" GetAmZug        " link AGetAmZug}
  981.   @{" GetAufBrett     " link AGetAufBrett}
  982.   @{" GetEvenPoint    " link AGetEvenPoint}
  983.   2. Aktionen
  984.   @{" CallZug         " link ACallZug}
  985.   @{" CallUndo        " link ACallUndo}
  986.   @{" CallSpielende   " link ACallSpielende}
  987.   @{" CallNeu         " link ACallNeu}
  988.   @{" CallAbout       " link ACallAbout}
  989.   @{" CallGreetings   " link ACallGreetings}
  990.   @{" CallPause       " link ACallPause}
  991. tzlich f
  992. r ARexx-Anf
  993. nger einige kurze Informationen :
  994.  @{" Wie kommt man an die Ergebnisse ? " link AErgs}
  995. @endnode
  996. @node AErgs            "Wie kommt man an die Ergebnisse ?"
  997. @toc ARexx
  998.   Ergebnisse
  999.  ------------
  1000.  Wenn man Mancala mit einem der "Get..." Befehle anspricht,
  1001.  bekommt man die einzelnen Ergebnisse nicht getrennt, sondern
  1002.  auf einem Haufen zur
  1003. ck. Man mu
  1004.  sie dann erst noch trennen.
  1005.  Wie man das anstellt, ist in folgendem Beispiel zu sehen :
  1006.   /* Ein Beispiel */
  1007.   address 'Mancala.1'                     <-- Mancala ansprechen
  1008.   options results                         <-- Ergebnisse einschalten
  1009.   getpunkte                               <-- Befehl abschicken
  1010.   parse var result punkte1 punkte2        <-- Ergebnis trennen
  1011.   say "Spieler 1 hat "punkte1" Punkte."   <-- Ausgabe
  1012.   say "Spieler 2 hat "punkte2" Punkte."   <-- Ausgabe
  1013.   Die Zeile "parse..." geht so :
  1014.   "parse" ist der Befehl zum Trennen eines Textes.
  1015.   "var" bedeutet, da
  1016.  man eine Variable trennen will.
  1017.   "result" ist der Name der Variable.
  1018.   "punkte1" und "punkte2" sind die Namen der beiden Ergebnisvariablen.
  1019. @endnode
  1020. @node AGetSpielStatus  "ARexx - GetSpielStatus"
  1021. @toc ARexx
  1022.   GetSpielStatus
  1023.  ----------------
  1024.  Aufruf   : GetSpielStatus
  1025.  Ergebnis : Status 
  1026.  Funktion :
  1027.  Hiermit kann man feststellen, ob gerade ein Spiel l
  1028.  Ist Status 0, so l
  1029. uft kein Spiel, bei 1 l
  1030. uft ein Spiel.
  1031. @endnode
  1032. @node AGetSpielertypen "ARexx - GetSpielertypen"
  1033. @toc ARexx
  1034.   GetSpielertypen
  1035.  -----------------
  1036.  Aufruf   : GetSpielertypen
  1037.  Ergebnis : Typ1 Typ2
  1038.  Funktion :
  1039.  Es werden die Typen der beiden Spieler zur
  1040. ckgegeben.
  1041. gliche Ergebnisse f
  1042. r jede der R
  1043. ckgabevariablen
  1044.  sind "Mensch" und "Computer".
  1045. @endnode
  1046. @node AGetBrett        "ARexx - GetBrett"
  1047. @toc ARexx
  1048.   GetBrett
  1049.  ----------
  1050.  Aufruf   : GetBrett
  1051.  Ergebnis : Feld1 Feld2 [...] Feld11 Feld12
  1052.  Funktion :
  1053.  Als Ergebnis werden 12 Zahlenwerte zur
  1054. ckgegeben, welche
  1055.  die Anzahl der Spielsteine in den 12 Mulden darstellen.
  1056.  Feld 1 ist oben links, Feld 6 oben rechts,
  1057.  Feld 7 unten links und Feld 12 unten rechts.
  1058. @endnode
  1059. @node AGetPunkte       "ARexx - GetPunkte"
  1060. @toc ARexx
  1061.   GetPunkte
  1062.  -----------
  1063.  Aufruf   : GetPunkte
  1064.  Ergebnis : PunkteSpieler1 PunkteSpieler2
  1065.  Funktion :
  1066.  Es werden zwei Zahlenwerte zur
  1067. ckgegeben, wobei der erste die
  1068.  Punktzahl von Spieler 1 und der zweite die von Spieler 2 ist.
  1069. @endnode
  1070. @node AGetSummen       "ARexx - GetSummen"
  1071. @toc ARexx
  1072.   GetSummen
  1073.  -----------
  1074.  Aufruf   : GetSummen
  1075.  Ergebnis : SummeOben SummeUnten
  1076.  Funktion :
  1077.  Ergibt die Anzahl aller Steine in den sechs oberen bzw. unteren Mulden.
  1078. @endnode
  1079. @node AGetAmZug        "ARexx - GetAmZug"
  1080. @toc ARexx
  1081.   GetAmZug
  1082.  ----------
  1083.  Aufruf   : GetAmZug
  1084.  Ergebnis : AmZug
  1085.  Funktion :
  1086.  Hiermit kann man feststellen, welcher Spieler gerade dran ist.
  1087.  Ist AmZug 1, so ist der linke Spieler dran, bei 2 der rechte.
  1088. @endnode
  1089. @node AGetAufBrett     "ARexx - GetAufBrett"
  1090. @toc ARexx
  1091.   GetAufBrett
  1092.  -------------
  1093.  Aufruf   : GetAufBrett
  1094.  Ergebnis : AnzahlSteine
  1095.  Funktion :
  1096.  Ergibt die momentane Anzahl aller Steine in den 12 Mulden.
  1097. @endnode
  1098. @node AGetEvenPoint    "ARexx - GetEvenPoint"
  1099. @toc ARexx
  1100.   GetEvenPoint
  1101.  --------------
  1102.  Aufruf   : GetEvenPoint
  1103.  Ergebnis : EvenPoint
  1104.  Funktion :
  1105.  Ergibt die Anzahl Punkte, die man f
  1106. r ein Unentschieden ben
  1107. tigt.
  1108.  Normalerweise ist sie 24, da bei 4 Steinen pro Mulde und 12 Mulden
  1109.  maximal 48 zu holen sind. Also ist bei 24 Punkten das Unentschieden
  1110.  sicher. Das mu
  1111.  aber in sp
  1112. teren Versionen von Mancala nicht zwingend
  1113.  so sein, also ist das Benutzen dieses Befehls zu empfehlen.
  1114. @endnode
  1115. @node ACallZug         "ARexx - CallZug"
  1116. @toc ARexx
  1117.   CallZug
  1118.  ---------
  1119.  Aufruf   : CallZug <Feld>
  1120.  Beispiel : CallZug 4
  1121.  Funktion :
  1122.  Mit Feld wird eine Zahl von 1 bis 12 
  1123. bergeben.
  1124.  Sollte in der angegebenen Mulde mindestens ein
  1125.  Stein liegen, so wird der Zug ausgef
  1126.  Wurde kein Feld 
  1127. bergeben oder ist die Mulde leer,
  1128.  so wird per Zufall ein Feld ausgew
  1129. hlt und gezogen.
  1130. @endnode
  1131. @node ACallUndo        "ARexx - CallUndo"
  1132. @toc ARexx
  1133.   CallUndo
  1134.  ----------
  1135.  Aufruf   : CallUndo
  1136.  Funktion :
  1137.  Es wird die @{" Undo-Funktion " link Undo} aufgerufen.
  1138. @endnode
  1139. @node ACallSpielende   "ARexx - CallSpielende"
  1140. @toc ARexx
  1141.   CallSpielende
  1142.  --------------
  1143.  Aufruf   : CallSpielende
  1144.  Funktion :
  1145.  Das Spiel wird beendet und der Gewinner bekanntgegeben.
  1146. @endnode
  1147. @node ACallNeu         "ARexx - CallNeu"
  1148. @toc ARexx
  1149.   CallNeu
  1150.  ---------
  1151.  Aufruf   : CallNeu
  1152.  Funktion :
  1153.  Es wird die Funktion @{" Neues Spiel " link Neu} aufgerufen.
  1154. @endnode
  1155. @node ACallAbout       "ARexx - CallAbout"
  1156. @toc ARexx
  1157.   CallAbout
  1158.  -----------
  1159.  Aufruf   : CallAbout
  1160.  Funktion :
  1161.  Das @{" Programminfo-Fenster " link Info} wird angezeigt.
  1162. @endnode
  1163. @node ACallGreetings   "ARexx - CallGreetings"
  1164. @toc ARexx
  1165.   CallGreetings
  1166.  ---------------
  1167.  Aufruf   : CallGreetings
  1168.  Funktion :
  1169.  Das @{" Greetings-Fenster " link Greet} wird angezeigt.
  1170. @endnode
  1171. @node ACallPause       "ARexx - CallPause"
  1172. @toc ARexx
  1173.   CallPause
  1174.  -----------
  1175.  Aufruf   : CallPause <Minuten> <Sekunden> <Jiffies>
  1176.  Beispiel : CallPause 0 5 0
  1177.  Funktion :
  1178.  Veranla
  1179. t das ARexx-Skript und das angesprochene Mancala,
  1180.  die angegebene Zeit zu warten und nichts zu tun.
  1181.  Dies ist sehr n
  1182. tzlich, wenn man zwei synchrone Mancalas auf einem
  1183.  Rechner laufen hat. Da Mancala sehr CPU-intensiv sein kann, mu
  1184.  verhindern, da
  1185.  beide Mancalas gleichzeitig zu rechnen versuchen,
  1186.  und so den Rechner total lahmlegen.
  1187.  Die Zeit ist in Minuten, Sekunden und Jiffies anzugeben.
  1188.  Ein Jiffy ist 1/Bildfrequenz Sekunden lang, also
  1189.  bei PAL 1/50 Sekunde und bei NTSC 1/60 Sekunde.
  1190. @endnode
  1191. ## *** Externer Spieler Hauptmen
  1192.  ******************************
  1193. @node Extern    "Externe Spieler"
  1194.   Externe Spieler
  1195.  -----------------
  1196.  Im @{" Options-Fenster " link Optionen} gibt es die M
  1197. glichkeit, sogenannte externe Spieler zu
  1198.  laden. Dies sind Textdateien, die ein kleines St
  1199. ck Programm enthalten.
  1200.  Dieses St
  1201. ck Programm ermittelt, welches Feld der externe Spieler spielt.
  1202.  Hier alles 
  1203. ber die Erstellung eines externen Spielers :
  1204.    @{" Was braucht man ?       " link N
  1205.    @{" Das Format der Datei    " link Format}
  1206.    @{" Programmaufbau          " link Aufbau}
  1207.    @{" Die Variablen           " link Vars}
  1208.    @{" Die wichtigsten Befehle " link Bef}
  1209.    @{" Ein Mini-Beispiel       " link Beispiel}
  1210. @endnode
  1211. ## *** Externer Spieler Unterpunkte ****************************
  1212. @node N
  1213. tig     "Was braucht man ?"
  1214. @toc Extern
  1215.   Was braucht man ?
  1216.  -------------------
  1217.  Um einen externen Spieler zu programmieren, braucht man all das NICHT :
  1218.   - eine Programmiersprache
  1219.   - Assemblerkenntnisse
  1220.   - 4 Megabyte RAM
  1221.   - Dampfwalze
  1222.  Stattdessen reicht schon folgende Ausstattung :
  1223.   - ein Texteditor
  1224.   - Basic-Kenntnisse
  1225.   - 512 Kilobyte RAM
  1226.   - Tastatur
  1227.  Genauer gesagt, wenn man ein Programm hat, mit dem man Texte schreiben
  1228.  kann und mit dem man diese Texte dann auch noch im ASCII-Format
  1229.  abspeichern kann, ist man schon einen Schritt weiter.
  1230.  Wenn man irgendwann einmal mit Basic in Kontakt kam und damit ein
  1231.  vielleicht nur klitzekleines Programm geschrieben hat, und wenn dieses
  1232.  Programm dann auch noch funktioniert hat, hat man gute Chancen, auch
  1233.  die zweite Vorraussetzung zu erf
  1234. llen.
  1235.  Die restlichen Vorraussetzungen sollen nur zeigen, da
  1236.  man auch auf
  1237.  solchen Computern einen Spieler programmieren kann, auf denen Mancala
  1238.  selbst 
  1239. berhaupt nicht l
  1240.  Alle Vorraussetzungen erf
  1241. llt ? Na dann ran ans Programmieren !!!
  1242. @endnode
  1243. @node Format    "Externe Spieler - Dateiformat"
  1244. @toc Extern
  1245.   Format der Datei eines externen Spielers
  1246.  ------------------------------------------
  1247.  Das Format der Textdatei, mit der der Spieler definiert wird,
  1248.  ist denkbar einfach. Die ersten zwei Zeilen m
  1249. ssen bestimmte
  1250.  Kommentare enthalten, danach folgt der Programmtext :
  1251.      Nop; Mancala.Extern
  1252.      Nop; <Kommentar>
  1253.      <Befehle>
  1254.       ...
  1255.  Die erste Zeile ist n
  1256. tig, um Mancala mitzuteilen, das die Datei
  1257.  tats
  1258. chlich einen Computerspieler enth
  1259. lt. Sie mu
  1260.  genauso am
  1261.  Anfang stehen.
  1262.  Die zweite Zeile enth
  1263. lt nach dem Leerzeichen einen Kommentar von
  1264.  bis zu 43 Zeichen L
  1265. nge. Dieser erscheint im @{" Optionsfenster " link Optionen} rechts
  1266.  neben dem Gadget @{" LADEN " link LoadEx}. Hier kann man dem Computerspieler einen
  1267.  Namen geben und noch eine kurze Beschreibung oder den Namen des
  1268.  Autors anh
  1269. ngen.
  1270.  Ab der dritten Zeile folgt der Programmtext.
  1271.  Wie dieser aufgebaut sein mu
  1272. , steht bei @{" Programmaufbau " link Aufbau}.
  1273. @endnode
  1274. @node Aufbau    "Programmaufbau"
  1275. @toc Extern
  1276.   Aufbau des Programms
  1277.  ----------------------
  1278.  Das Programm stellt einen basic-
  1279. hnlichen Text dar, an desse Ende in
  1280.  der Variable F eine Zahl von 1 bis 12 stehen mu
  1281.  , die definiert,
  1282.  welches Feld der Computerspieler spielen will.
  1283.  Dabei sind die Mulden auf dem Spielfeld wie folgt numeriert :
  1284.       1   2   3   4   5   6
  1285.       7   8   9  10  11  12
  1286.  Die Mulde oben links ist also Mulde 1, die unten rechts Mulde 12.
  1287.  Typischerweise wird w
  1288. hrend des Programmablaufs in Schleifen gepr
  1289.  wieviele Steine in einem bestimmten Feld liegen oder mit 
  1290. hnlichen
  1291.  Methoden ein virtueller Zug durchgef
  1292. hrt. Man pr
  1293. ft vielleicht auch
  1294.  noch, ob man dem Gegner keine gute Zugm
  1295. glichkeit gibt, wenn man einen
  1296.  bestimmten Zug durchf
  1297.  Ein Problem gibt es f
  1298. r den Programmierer momentan noch :
  1299.  Es ist nicht ohne weiteres m
  1300. glich, Unterroutinen zu erstellen.
  1301.  Daher mu
  1302.  der gesamte Spieler am St
  1303. ck programmiert werden. Sorry :-(
  1304.  Sollte einer der CanDo-Programierer dies lesen :
  1305.  Bitte schick mir Infos zum internen Aufbau der undokumentierten Befehle.
  1306. berhaupt einen 
  1307. berblick 
  1308. ber das momentane Spielfeld zu haben,
  1309.  man nat
  1310. rlich diverse Werte in vordefinierten Variablen vorfinden.
  1311.  Wie diese Variablen hei
  1312. en und was drinsteht, ist unter @{" Die Variablen " link Vars}
  1313.  nachzulesen.
  1314. @endnode
  1315. @node Vars      "Die Variablen"
  1316. @toc Extern
  1317.   Die Variablen
  1318.  ---------------
  1319.  Um sich auf dem momentanen Spielbrett zurechtzufinden, mu
  1320.  man nat
  1321. rlich
  1322.  wissen, wieviele Spielsteine in jeder einzelnen Mulde liegen usw.
  1323.  Dazu stehen diverse Variablen zur Verf
  1324. gung, in denen diese Werte stehen.
  1325.  Ich bitte jeden Programmierer eines externen Spielers, diese Variablen nur
  1326.  zu LESEN. Wenn man sie einfach ver
  1327. ndert, entsteht ein nicht kalkulierbares
  1328.  Chaos auf dem Spielbrett und ein normales Spielen wird unm
  1329. glich.
  1330.  Hier die einzelnen Variablen :
  1331.    @{" AmZug            " link vAmZug}
  1332.    @{" AufBrett         " link vAufBrett}
  1333.    @{" EvenPoint        " link vEven}
  1334.    @{" Brett[]          " link vBrett}
  1335.    @{" Summe[]          " link vSumme}
  1336.    @{" Spieler[].Punkte " link vPunkte}
  1337. @endnode
  1338. @node vAmZug    "AmZug"
  1339. @toc Vars
  1340.   AmZug
  1341.  -------
  1342.  Format   : Let <Var>=AmZug
  1343.  Beispiel : Let X=AmZug
  1344.  Ergibt 1, wenn der erste und 2, wenn der zweite Spieler dran ist.
  1345. @endnode
  1346. @node vAufBrett "AufBrett"
  1347. @toc Vars
  1348.   AufBrett
  1349.  ----------
  1350.  Format   : Let <Var>=AufBrett
  1351.  Beispiel : Let X=AufBrett
  1352.  Ergibt eine Zahl zwischen 1 und 48, die angibt, wieviele
  1353.  Spielsteine sich momentan noch auf dem Brett befinden.
  1354. @endnode
  1355. @node vEven     "EvenPoint"
  1356. @toc Vars
  1357.   EvenPoint
  1358.  -----------
  1359.  Format   : Let <Var>=EvenPoint
  1360.  Beispiel : Let X=EvenPoint
  1361.  Ergibt beim Standardspiel (in jeder Mulde liegen zu Beginn 4 Steine)
  1362.  immer den Wert 24. Man sollte sich aber nicht darauf verlassen, denn
  1363.  es k
  1364. nnten in einer der n
  1365. chsten Versionen auch mehr oder weniger
  1366.  Steine pro Mulde sein.
  1367.  Die Variable hei
  1368. t EvenPoint, weil man beim Erreichen dieser Punktzahl
  1369.  ein Unentschieden sicher hat, bei mehr Punkten hat man gewonnen.
  1370. @endnode
  1371. @node vBrett    "Brett[]"
  1372. @toc Vars
  1373.   Brett[]
  1374.  ---------
  1375.  Format   : Let <Var>=Brett[<1 bis 12>]
  1376.  Beispiel : Let X=Brett[3]
  1377.  Ergibt je nach der Zahl zwischen 1 und 12 die Anzahl der
  1378.  Spielsteine in der jeweiligen Mulde. Die Mulde oben links
  1379.  ist Mulde 1, die oben rechts Mulde 6, die unten links
  1380.  Mulde 7 und die unten rechts Mulde 12.
  1381.  Sollte eine andere Zahl au
  1382. er denen von 1 bis 12
  1383.  angegeben werden, erzeugt dies eine Fehlermeldung.
  1384. @endnode
  1385. @node vSumme    "Summe[]"
  1386. @toc Vars
  1387.   Summe[]
  1388.  ---------
  1389.  Format   : Let <Var>=Summe[<1 oder 2>]
  1390.  Beispiel : Let X=Summe[1]
  1391.  Summe[1] ergibt die Anzahl aller Spielsteine in den oberen
  1392.  und Summe[2] die aller Spielsteine in den unteren 6 Mulden.
  1393.  Sollte eine andere Zahl au
  1394. er 1 oder 2 angegeben werden,
  1395.  erzeugt dies eine Fehlermeldung.
  1396. @endnode
  1397. @node vPunkte   "Spieler[].Punkte"
  1398. @toc Vars
  1399.   Spieler[].Punkte
  1400.  ------------------
  1401.  Format   : Let <Var>=Spieler[<1 oder 2>].Punkte
  1402.  Beispiel : Let X=Spieler[1].Punkte
  1403.  Spieler[1].Punkte ergibt die Punkte des ersten (linken) Spielers und
  1404.  Spieler[2].Punkte ergibt die Punkte des zweiten (rechten) Spielers.
  1405.  Bei 24 Punkten ist ein Unentschieden sicher,
  1406.  bei 25 oder mehr hat man schon gewonnen.
  1407.  Danach kann man taktieren (27 ? Dann ist sowieso alles egal !).
  1408.  Sollte eine andere Zahl au
  1409. er 1 oder 2 angegeben werden,
  1410.  erzeugt dies eine Fehlermeldung.
  1411. @endnode
  1412. @node Bef         "Die wichtigsten Befehle"
  1413. @toc Extern
  1414.   Die wichtigsten Befehle
  1415.  -------------------------
  1416.  Das Programm wird in der internen CanDo-Sprache geschrieben.
  1417.  Diese Sprache ist dem normalen Basic sehr 
  1418. hnlich, trotzdem
  1419.  gibt es kleine Abweichungen. Deshalb hier eine Erkl
  1420. rung der
  1421.  aller wichtigsten Befehle f
  1422. r die Programmierung eines
  1423.  externen Spielers :
  1424.    @{" Nop                     " link bNop}
  1425.    @{" Let                     " link bLet}
  1426.    @{" =IfThen()               " link bIfThen}
  1427.    @{" =Random()               " link bRandom}
  1428.    @{" If..ElseIf..Else..EndIf " link bIf}
  1429.    @{" Loop..Until             " link bLoop}
  1430.    @{" ExitLoop                " link bExitLoop}
  1431.    @{" ExitScript              " link bExitScript}
  1432. @endnode
  1433. @node bNop        "Nop"
  1434. @toc Bef
  1435.   Nop
  1436.  -----
  1437.  Format   : Nop ; <Kommentar>
  1438.  Beispiel : Nop ; Dies ist ein Kommentar !
  1439.  Der Befehl Nop ist der Nichts-Befehl.
  1440.  Hiermit kann man Kommentarzeilen erzeugen.
  1441.  Kommentarzeilen sollte jeder Programmierer verwenden,
  1442.  um sein eigenes Programm auch noch nach mehr als einer
  1443.  Woche zu kapieren und 
  1444. ndern zu k
  1445. nnen.
  1446. @endnode
  1447. @node bLet        "Let"
  1448. @toc Bef
  1449.   Let
  1450.  -----
  1451.  Format   : Let <Var>=<Wert>
  1452.  Beispiel : Let X=Brett[3]+4
  1453.  Mit Let kann einer Variablen ein Wert zugewiesen werden.
  1454.  Dabei kann man nat
  1455. rlich f
  1456. r <Wert> nicht nur Zahlen
  1457.  einsetzen, sondern man kann eine komplexe Formel
  1458.  verwenden, in der andere Variablen und auch
  1459.  Funktionsaufrufe stattfinden k
  1460. nnen.
  1461.  Beispiele f
  1462. r Funktionsaufrufe sind @{" =IfThen() " link bIfThen} und @{" =Random() " link bRandom}.
  1463. @endnode
  1464. @node bIfThen     "=IfThen()"
  1465. @toc Bef
  1466.   =IfThen()
  1467.  -----------
  1468.  Format   : Let <Variable>=IfThen(<Bedingung>,<Wahr-Wert>,<Falsch-Wert>}
  1469.  Beispiel : Let X=IfThen(AmZug=1,1,12)
  1470.  IfThen ist eine vereinfachte einzeilige Variante der Konstruktion
  1471.  "If..ElseIf..Else..EndIf". Man kann einer Variable einen von zwei
  1472.  Werten zuweisen. Ist die Bedingung erf
  1473. llt (z.B. 3=2+1), so wird
  1474.  der Variable der Wahr-Wert zugewiesen, ansonsten der Falsch-Wert.
  1475.  Dabei kann man nat
  1476. rlich f
  1477. r <Wahr-Wert> bzw. <Falsch-Wert> nicht
  1478.  nur Zahlen einsetzen, sondern man kann eine komplexe Formel verwenden,
  1479.  in der andere Variablen und auch Funktionsaufrufe stattfinden k
  1480. nnen.
  1481.  Man kann sogar als Wert eine erneute IfThen-Funktion benutzen.
  1482.  Man kann das ganze nahezu unbegrenzt verschachteln
  1483.  (Spaghetti-Code l
  1484. en !!!).
  1485. @endnode
  1486. @node bRandom     "=Random()"
  1487. @toc Bef
  1488.   =Random()
  1489.  -----------
  1490.  Format   : Let <Variable>=Random(<Von>,<Bis>)
  1491.  Beispiel : Let X=Random(1,12)
  1492.  Hiermit kann man der Variablen eine Zufallszahl im Bereich
  1493.  von <Von> bis <Bis> zuweisen. (Schlauer Satz !?!!??!?)
  1494. r <Von> und <Bis> kann man nat
  1495. rlich wieder Formeln
  1496.  verwenden wie bei @{" Let " link bLet}.
  1497. @endnode
  1498. @node bIf         "If..ElseIf..Else..EndIf"
  1499. @toc Bef
  1500.   If..ElseIf..Else..EndIf
  1501.  -------------------------
  1502.  Format : If <Bedingung>        Beispiel : If AmZug=1
  1503.            <Befehle>                        Let Y=Random(1,6)
  1504.           ElseIf <Bedingung>               Else
  1505.            <Befehle>                        Let Y=Random(7,12)
  1506.           Else                             EndIf
  1507.            <Befehle>
  1508.           EndIf
  1509.  Eine Bedingung ist ein Vergleich von zwei Werten.
  1510.  So ist zum Beispiel 3=2+1 wahr und 5=6+4 unwahr.
  1511.  Die beiden Werte k
  1512. nnen nat
  1513. rlich wieder so aussehen wie bei @{" Let " link bLet}.
  1514.  Ist die Bedingung bei If erf
  1515. llt, so werden die
  1516.  nachfolgenden Befehle abgearbeitet.
  1517.  Ansonsten wird die Bedingung bei ElseIf 
  1518. berpr
  1519.  Ist diese erf
  1520. llt, so werden die dort folgenden Befehle abgearbeitet.
  1521.  Es k
  1522. nnen beliebig viele ElseIf's folgen.
  1523.  Trifft keine aller Bedingungen zu, so werden die
  1524.  Befehle hinter Else abgearbeitet.
  1525.  Man kann nat
  1526. rlich ElseIf, Else oder beides auch weglassen.
  1527. @endnode
  1528. @node bLoop       "Loop..Until"
  1529. @toc Bef
  1530.   Loop..Until
  1531.  -------------
  1532.  Format : Loop                Beispiel : Let Z=1
  1533.            <Befehle>                     Loop
  1534.           Until <Bedingung>               Let F=Random(1,12)
  1535.                                           Let Z=Z+1
  1536.                                          Until Z=11
  1537.  Mit Loop lassen sich Schleifen erzeugen.
  1538.  Mit dem obigen Beispiel werden nacheinander zehn Zufallszahlen
  1539.  zwischen 1 und 12 gezogen und der Variablen F zugewiesen.
  1540.  Das ist zawr unsinnig aber ein gutes Beispiel 8-D.
  1541.  Nach dem Loop folgen die Befehle innerhalb der Schleife.
  1542.  Immer, wenn das Until erreicht wird, wird 
  1543. berpr
  1544.  ob die Bedingung wahr ist (Bedingung siehe @{" If " link bIf}).
  1545.  Ist sie wahr, so wird die Schleife verlassen.
  1546.  Um ein For...Next wie in Basic zu realisieren, mu
  1547.  wie im Beispiel eine Z
  1548. hlvariable (hier Z) verwenden
  1549.  und diese bei jedem Schleifendurchlauf erh
  1550.  Es gibt noch mehr Schleifenkonstrukte.
  1551.  So wird bei While..EndLoop am Anfang eine Bedingung 
  1552. berpr
  1553.  und nur wenn diese wahr ist, wird die Schleife 
  1554. berhaupt betreten.
  1555.  Mit While..Until lassen sich ganz exotische Schleifen programmieren.
  1556.  Ein Sonderfall ist Loop..EndLoop.
  1557.  Diese Endlosschleife l
  1558. t sich nur mit @{" ExitLoop " link bExitLoop} verlassen.
  1559.  Es geht nat
  1560. rlich auch @{" ExitScript " link bExitScript}.
  1561. @endnode
  1562. @node bExitLoop   "ExitLoop"
  1563. @toc Bef
  1564.   ExitLoop
  1565.  ----------
  1566.  Format : ExitLoop
  1567.  Hiermit wird eine momentan laufende Schleife verlassen
  1568.  und die Abarbeitung des Programms am ersten Befehl nach
  1569.  dem Schleifenende (z.B. nach dem Until) fortgesetzt.
  1570. @endnode
  1571. @node bExitScript "ExitScript"
  1572. @toc Bef
  1573.   ExitScript
  1574.  ------------
  1575.  Format : ExitScript
  1576.  Hiermit wird das Programm verlassen.
  1577. llt einem vielleicht 
  1578. berhaupt kein guter Zug ein,
  1579.  so kann man hiermit einfach aus dem Programm springen.
  1580.  Mancala berechnet dann einen zuf
  1581. lligen Zug.
  1582. @endnode
  1583. @node Beispiel "Ein Mini-Beispiel"
  1584. @toc Extern
  1585.   Beispiel eines externen Spielers
  1586.  ----------------------------------
  1587.  Zum Abschlu
  1588.  des Kurses "Wie programmiert man einen externen Spieler ?"
  1589.  ist an dieser Stelle das Listing eines externen Spielers abgedruckt,
  1590.  der fr
  1591. her einmal in Mancala integriert war. Der Spieler ist zwar nicht
  1592.  besonders spielstark, aber ein gutes Beispiel zur Programmierung.
  1593.  Die Zeilennummern dienen nur der Orientierung in der Erkl
  1594. rung :
  1595.   1    Nop; Mancala.Extern
  1596.   2    Nop; Anf
  1597. nger (von Oliver Gr
  1598.   3    Let Z=IfThen(AmZug=1,1,12)
  1599.   4    Loop
  1600.   5      If Brett[Z]=IfThen(AmZug=1,Z,13-Z)
  1601.   6        Let F=Z
  1602.   7        ExitLoop
  1603.   8      EndIf
  1604.   9      Let Z=Z+IfThen(AmZug=1,1,-1)
  1605.  10    Until Z=IfThen(AmZug=1,7,6)
  1606.  11    If F=0
  1607.  12      Loop
  1608.  13        Let F=Random(1,12)
  1609.  14      Until Brett[F]>0
  1610.  15    EndIf
  1611.  Zeile 1 mu
  1612.  genauso sein. Zeile 2 enth
  1613. lt einen kurzen Kommentar.
  1614.  Zeile 3 setzt den Anfangsz
  1615. hler der Schleife, je nachdem, welcher
  1616.  Spieler dran ist, auf 1 oder 12. Bei Spieler 1 f
  1617. ngt man mit Feld 1
  1618.  an, bei Spieler 2 mit Feld 12. In Zeile 4 beginnt die Schleife.
  1619.  In Zeile 5 wird 
  1620. berpr
  1621. ft, ob im Feld Z genausoviele Steine liegen,
  1622.  wie das Feld vom eigenen Zielfeld entfernt ist, was ja dazu f
  1623. rde, da
  1624.  man nochmal dran ist. Erkl
  1625. rung der 
  1626. berpr
  1627. fung :
  1628.  Ist z.B. Spieler 2 dran, dann ist Z beim ersten Mal ja gleich 12.
  1629.  Feld 12 (unten rechts) ist genau 1 Feld vom Zielfeld von Spieler 2
  1630.  entfernt. Also m
  1631. ssen In Brett[12] genau 13-12 (13-Z), also 1 Stein
  1632.  liegen. Stimmt der Vergleich aus dem If-Befehl, so wird das zu ziehende
  1633.  Feld F in Zeile 6 auf den aktuellen Schleifenz
  1634. hler gesetzt und in
  1635.  Zeile 7 die Schleife verlassen, da man ja das richtige gefunden hat.
  1636.  Zeile 8 ist das Ende der If-Abfrage. In Zeile 9 wird Z je nach Spieler
  1637.  um eins erh
  1638. ht oder erniedrigt. Bei Spieler 2 wurde mit 12 angefangen,
  1639.  also mu
  1640.  man um eins senken, um sich vom eigenen Zielfeld zu entfernen.
  1641.  In Zeile 10 ist das Schleifenende. Hier wird 
  1642. berpr
  1643. ft, ob die Schleife
  1644.  schon sechsmal durchlaufen wurde. Diese Schleife wird nur sechsmal
  1645.  durchlaufen, weil nach dem Feld, das sechs Felder vom eigenen Zielfeld
  1646.  entfernt ist, das gegnerische Zielfeld kommt, und sich dann auch die
  1647.  Feldnummer wieder 
  1648. ndern. Bei Spieler 2 ist Feld 7 sechs Felder entfernt,
  1649.  Feld 1 ist 7 Felder entfernt. Wollte man die Schleife also noch erweitern,
  1650.  so w
  1651. rde sich die Schleife noch komplizierter gestalten.
  1652.  Nach der Schleife wird in Zeile 11 
  1653. berpr
  1654. ft, ob die Schleife 
  1655. berhaupt
  1656.  ein g
  1657. nstiges Feld ergeben hat. Ist aber F immer noch gleich 0, war die
  1658.  Suche erfolglos. In diesem Falle wird in den Zeilen 12 bis 14 solange
  1659.  ein Feld per Zufall ausgew
  1660. hlt, bis in der ausgew
  1661. hlten Mulde mindestens
  1662.  ein Spielstein liegt, denn leere Felder kann man nicht spielen.
  1663.  In Zeile 15 endet diese If-Abfrage.
  1664.  Die Zeilen 11 bis 15 k
  1665. nnte man sich sparen, denn ergibt der externe
  1666.  Spieler einen ung
  1667. ltigen Zug (z.B. F=13 oder F=3 und Brett[3]=0), so
  1668.  wird sowieso per Zufall ein Feld ausgew
  1669. @endnode
  1670. @node Exec     "Das Executer-Utility"
  1671.   Das Zuastzprogramm "Executer"
  1672.  -------------------------------
  1673.  Das Programm Executer ist f
  1674. r die Synchron-Funktion von
  1675.  Mancala im speziellen und f
  1676. r AmigaDOS allgemein n
  1677. tzlich.
  1678.  Systemvoraussetzungen:
  1679.   Dieses Programm ben
  1680. tigt OS 2.0 oder h
  1681. her, da es die
  1682.   Notify()-Funktion des neuen Betriebssytems nutzt.
  1683. erdem mu
  1684.  die CanDo-Library installiert sein.
  1685.  Starten:
  1686.   Einfach aufrufen oder doppelklicken.
  1687.  Nach dem Start wird ein kleines Fenster ge
  1688. ffnet.
  1689.  Ab jetzt wird das Verzeichnis RAM: 
  1690. berwacht.
  1691.  Sobald dort eine Datei namens "Executer.skript"
  1692.  hinkopiert wird, wird der Execute-Befehl auf die Datei
  1693.  angewandt und die Datei danach sofort wieder gel
  1694. scht.
  1695.  Man kann damit also ein Programm starten, indem man eine Datei kopiert.
  1696.  Diese Datei kann leicht 
  1697. ber ein Netzwerk geschickt werden, wo es doch
  1698.  oft so schwer ist, am anderen Netzende AUF dem anderen Rechner ein
  1699.  Programm zu starten. Es gibt zwar viele andere L
  1700. sungen hierf
  1701.  aber dieses Programm l
  1702. st das Problem sehr elegant und ist noch
  1703.  dazu nur 904 Bytes gro
  1704. @endnode
  1705.