Das gesamte Prinzip lässt sich auf eine, vielleicht zwei Seiten erklären. Da ich grad nichts Besseres zu tun habe, mache ich das mal^^ (falls die Beschreibung jemandem hilft: Darf gerne weiterkopiert werden). Dabei gilt:
Jede Information hier ist wichtig^^.
Ausgangssituation:
Du hast "Nodes" (stelle dir sie wie PCs vor) in einem 4x3-Feld großen Raster (macht insgesamt 12 Nodes). Jede Node kann seinen unmittelbaren Nachbarn (also die Nodes über, unter, links und rechts davon) Zahlenwerte geben und auch von ihnen Zahlenwerte empfangen. Allgemein gesagt, in diesen Nodes gehört der Quelltext rein - pro Node gibts ein Limit von 15 Zeilen Quelltext; natürlich müssen nicht alle Nodes genutzt werden und nur in den späteren Aufgaben kommt man an die 15 Zeilen-Beschränkung überhaupt hin. Je nach Level sind auch "zufällig" Nodes auch überhaupt nicht verfügbar, was eine gewisse Planung zum Weiterreichen der Daten erfordert (dazu später mehr).
Hier ein Bild in ASCII-Zeichen, um sich das ein wenig vorstellen zu können:
Code: Alles auswählen
+-------------+ +-------------+ +-------------+ +-------------+
| Node 1 | | Node 2 | | Node 3 | | Node 4 |
|-------------| |-------------| |-------------| |-------------|
| <Quelltext> | | <Quelltext> | | <Quelltext> | | <Quelltext> |
+-------------+ +-------------+ +-------------+ +-------------+
+-------------+ +-------------+ +-------------+ +-------------+
| Node 5 | | Node 6 | | Node 7 | | Node 8 |
|-------------| |-------------| |-------------| |-------------|
| <Quelltext> | | <Quelltext> | | <Quelltext> | | <Quelltext> |
+-------------+ +-------------+ +-------------+ +-------------+
+-------------+ +-------------+ +-------------+ +-------------+
| Node 9 | | Node 10 | | Node 11 | | Node 12 |
|-------------| |-------------| |-------------| |-------------|
| <Quelltext> | | <Quelltext> | | <Quelltext> | | <Quelltext> |
+-------------+ +-------------+ +-------------+ +-------------+
Die "Levels" (Aufgabenstellungen) sehen so aus, dass eine oder mehrere Nodes zufällige Zahlenwerte bekommt. Diese Zahlenwerte müssen in einer bestimmten Form bearbeitet werden, was dir vom Spiel vorgeschrieben wird (Beispiel: Addiere immer die erste Zahl mit der zweiten Zahl). Wieder eine oder mehrere Nodes dienen als "Ziel", dort muss dann das Ergebnis landen. Das verlangte Ergebnis wird sogar angezeigt -
wie du allerdings die Zahlen bearbeitest, dass das verlangte Ergebnis rauskommt, bleibt dann deiner Kreativität überlassen und ist die eigentliche Essenz des Spiels. (Spätestens hier sollten sich Parallelen zu SpaceChem und Infinifactory finden lassen, wer diese Spiele mal gespielt hat)
Beispiel: In einem Level ist vorgegeben, dass "Node 1" die Zahlen 3 und 4 bekommt. "Node 12" ist als "Ziel-Node" vorgegeben - dort wird verlangt, dass das Ziel das Ergebnis "7" weiterleitet.
Alles klar? Gut, dann weiter.
Jede Node hat fast nur eine Speichereinheit, die genutzt werden kann: ACC. Hier können die angesprochenen Zahlenwerte gespeichert und besagte Werte an andere Nodes weitergeleitet und/oder manipuliert (z.B. addiert oder subtrahiert) werden. Moment, ich schrieb "fast nur eine Speichereinheit": Jede Node hat auch ein BAK, in dem ebenfalls Zahlenwerte drinstehen dürfen. Allerdings darf nicht direkt auf BAK zugegriffen werden; es gibt nur zwei Befehle, die BAK betreffen: Entweder, um die Zahlenwerte von ACC auch im BAK zu speichern, oder um die Zahlenwerte ACC und BAK direkt gegenseitig auszutauschen. (Für Programmierer: Natürlich ist die Einschränkungen von BAK aus Programmiersicht völliger Humbug - aus Sicht eines Spiels fügt diese Komponente aber interessante Variationen ein)
Zuerst zum vermutlich "schwierigsten" aber unverzichtbaren Befehl:
MOV. Der Befehl verlangt immer zwei Parameter, nämlich
Quelle und
Ziel. Ein Komma dient der Trennung:
Ich schrieb vorhin, dass die Nodes ihren unmittelbaren Nachbarn Zahlenwerte schicken und auch empfangen dürfen. Mit
MOV geht das:
Code: Alles auswählen
+--------------+ +--------------+
| Node 1 | | Node 2 |
|--------------| |--------------|
| | | MOV LEFT,ACC |
+--------------+ +--------------+
sieht hier zugegeben ziemlich merkwürdig aus - vielleicht hilft es, wenn man sich das bildlich vorstellt, was der Befehl "MOV LEFT, ACC" macht: Er "nimmt" sich den Zahlenwert aus der Node, die links von ihm ist, und kopiert besagten Zahlenwert in den ACC hinein.
Achtung Falle: Kann ein
MOV also jederzeit den Zahlenwert eines Nachbarn auslesen? Nein, denn die "sendende" Node (also die Node, die links von der aktuellen Node steht) muss vorher angeben, welchen Wert sie senden will. Erweitertes Beispiel:
Code: Alles auswählen
+--------------+ +--------------+
| Node 1 | | Node 2 |
|--------------| |--------------|
| MOV 6,RIGHT | | MOV LEFT,ACC |
+--------------+ +--------------+
Wieder hilft es, sich bildlich vorzustellen, was der Befehl "MOV 6,RIGHT" bei Node Nummer 1 macht: Er kopiert den Zahlenwert 6 direkt nach Rechts. Node Nummer 2 schnappt sich den Zahlenwert und kopiert sie in den Speicher (ACC).
Kleiner Tipp, der auch direkt im ersten Level des Spiels angewendet wird: Zahlenwerte müssen nicht zwingend in den ACC-Speicher kopiert werden, als Quelle UND Ziel sind Richtungsangaben gleichzeitig möglich:
Dreimal darf geraten werden, was dieser Befehl macht: Er schnappt sich den Wert der Node links von ihm (wenn es von links eine bekommt) und leitet es ohne Umschweife zur rechten Node weiter.
Achtung, sehr wichtig: Bei
MOV wartet das Programm an der Stelle solange, bis es Daten empfangen oder gesendet hat! Angenommen, im obigen Beispiel würde "Node 2" garkeine Daten von links empfangen, wartet die Node solange darauf, bis es endlich Daten von links bekommt! Dasselbe gilt auch umgekehrt: "Node 1" sendet solange nach Rechts, bis von dort jemand die angegebene Quelle (also 6 im Beispiel) liest. Solange niemand liest, solange führt das besagte "Node 1" keine weiteren Befehle mehr aus.
---
Noch da? Irgendwer gelesen? Falls ja: Wenn für dich das Herausfinden und Nachvollziehen dieser kleinen Anleitung Spaß gemacht hat, dürfte TIS-100 ein Spiel sein, was dir auch Spaß machen wird^^. Ich schreibe jetzt einfach noch die restlichen Befehle auf, die wohl jeder verstehen soll, wenn er diese Anleitung auch verstanden hat:
Code: Alles auswählen
NOP Kein Befehl (No Operation; absichtliche Wartezeiten?)
SWP ACC und BAK vertauschen
SAV ACC in BAK sichern
ADD <Quelle> <Quelle> zu ACC addieren
SUB <Quelle> <Quelle> zu ACC subtrahieren
NEG ACC negieren
<LABEL>: Label definieren; Name kann frei gewählt werden
JMP <LABEL> Springt zu einem Label
JEZ <LABEL> Springt zu einem Label, wenn ACC "0" ist
JNZ <LABEL> Springt zu einem Label, wenn ACC nicht "0" ist
JGZ <LABEL> Springt zu einem Label, wenn ACC größer als "0" ist
JLZ <LABEL> Springt zu einem Label, wenn ACC kleiner als "0" ist
+--------------+
| Profi-Befehl |
+--------------+
JRO <Quelle>
Springt zur Zeile weg, relativ vom Befehl. Beispiele:
JRO -2 Springt zwei Zeilen vor diesem Befehl zurück
JRO 0 Springt wieder zur JRO; hält effektiv das Programm an (nutzlos)
JRO 1 Springt direkt eine Zeile unter JRO; effektiv nutzlos
JRO LEFT Springt immer dahin, was von der linken Node reinflattert
Ein paar Besonderheiten gibts auch noch, z.B. können als Quelle und Ziel
ANY,
LAST und
NIL definiert werden - da ich sie bisher nicht brauchte, werde ich darauf nicht eingehen.
Etwas später kommen auch noch Rätsel mit Bildern und erweiterte Nodes (Speichernodes?) dazu; aber bis die kommen, hat man die vorigen Befehle schon so oft angewendet und verinnerlicht, dass das Aneignen dieser zusätzlichen Informationen wirklich Peanuts sind^^.
Much TL; Sorry, ich werd meine Zeit künftig sinnvoller einteilen^^...
). Als Simulator, damit du den Code auch ausführen kannst, nimmste "SPIM", und 