Aus Das deutschsprachige Scratch-Wiki

Stub.png Dieser Artikel (oder Abschnitt) ist noch sehr kurz (oder unvollständig!). Hilf mit, ihn ausführlicher zu gestalten, indem du Informationen, Bildmaterial oder Texte hinzufügst.


Baustelle.png Dieser Artikel ist gerade in Arbeit. Bitte wundere dich nicht, wenn der Wiki-Artikel nach einer Aktualisierung der Seite anders aussieht als vorher.


Eine Cloud-Engine ist sehr nützlich, wenn man zum Beispiel mithilfe der Cloud-Daten einen Chatroom programmieren möchte. Im Grunde genommen ist das einfach, man muss nur wissen, wie und einige Grundkentnisse über Cloud-Daten haben.

Grundkenntnisse

Um dieses Projekt durchzuführen, solltest Du Grundkentnisse von den folgenden Dingen besitzen:

Das Grundprinzip

Da wir mit Cloud-Variablen keine Wörter speichern können, muss jeder Buchstabe in einen Zahlencode umgewandelt werden. Das funktioniert wie bei einer normalen Codierung oder Geheimschrift : Wir ordnen jedem Buchstaben (in diesem Fall jedem Zeichen) ein anderes Zeichen zu. Hier nutzen wir statt irgendwelchen Zeichen Zahlen, da Zahlen die einzigen Zeichen sind, die in Cloud-Variablen gespeichert werden können.

Da die Länge von Cloud-Variablen begrenzt ist, müssen wir so kurze Codes wie nur möglich nutzen. Da wir später eine Liste zum Anzeigen nutzen werden, muss es noch ein Sonderzeichen für die Trennung von einzelnen Elementen geben. Wir nehmen dafür 99. Unsere Grundlänge wäre damit zwei Zeichen lang. Mit 00-99 Zeichen haben wir 100 verschiedene Zeichen zur Auswahl. 26 Buchstaben plus 10 Ziffern macht 36, wir haben also noch 64 Zeichen für Sonderzeichen frei. Zunächst beginnen wir mit dem Anlegen von zwei Listen mit folgenden Namen:

  • Codes (für die einzelnen Zeichencodes)
  • Zeichen (für die Zeichen in Klartext)

Füge nun in die Liste Codes die Zahlen von 00 bis 99 (00, 01, 02, 03, ...99) ein. In das entsprechende Element der Liste Zeichen kommen nun die dazugehörigen Zeichen, also die Zeichen, die später den einzelnen Codes zugeordnet werden. Wir nehmen für 00 die 0, für 01 die 1 und so weiter bis zur 09, dann haben wir alle Ziffern, aus denen man nun alle Zahlen bilden kann. Die 10 wird dem Leerzeichen zugeordnet, die 11 dem a, die 12 dem b und so weiter. Du kannst auch noch Umlaute einfügen, die Reihenfolge ist belanglos.

Der Zeichen - Code-Umwandler

Hast Du nun die Listen ganz ausgefüllt, beginnen wir mit der Programmierung des Skripts, das Zeichen in Codes umwandelt. Zu dem Zweck brauchen wir ein Skript, das ein bestimmtes Zeichen aus der Liste heraussucht und den entsprechenden Code findet. Wir programmieren folgendes:

Definiere wandle [Zeichen] in Code um
setze [Schritte v] auf (0) //fängt beim ersten Element der Liste an, zu suchen
wiederhole bis <(Element (Schritte) von [Zeichen v])=(Zeichen::custom)> //sucht das Zeichen
ändere [Schritte v] um (1)
end
setze [Code v] auf (Element (Schritte) von [Codes v]) //speichert den entsprechenden Code in der Variable 'Code'

Nun haben wir den Code für das Zeichen aus der Lise herausgesucht, indem wir das Zeichen, das wir umwandeln wollen, in der Zeichen-Liste gesucht und das entsprechende Element in der Code-Liste genommen haben. Diesen Code haben wir danach in der Variable Code gespeichert. Dann speichern wir diesen in die Cloud-Variable, die jedoch ihren vorherigen Inhalt behalten soll:

Definiere wandle [Zeichen] in Code um ::grey
setze [Schritte v] auf (0)::grey
wiederhole bis <(Element (Schritte::grey) von [Zeichen v]::grey)=(Zeichen::grey)::grey>::grey
ändere [Schritte v] um (1)::grey
end
setze [Code v] auf (Element (Schritte::grey) von [Codes v]::grey)::grey
setze [☁ Cloud-Variable v] auf (verbinde (☁ Cloud-Variable)(Code)) //fügt hinter der Cloud-Variable den Code ein

Wir wollen jedoch noch eine Unterscheidung von einzelnen Elementen haben, damit der ganze Chat später nicht einfach in einem Listenelement angezeigt wird. Wir fügen also jedem fertigen Element eine 99 hinzu, die signalisiert, dass ein Element zu Ende ist.

Definiere wandle [Zeichen] in Code um ::grey
setze [Schritte v] auf (0)::grey
wiederhole bis <(Element (Schritte::grey) von [Zeichen v]::grey)=(Zeichen::grey)::grey>::grey
ändere [Schritte v] um (1)::grey
end
setze [Code v] auf (Element (Schritte::grey) von [Codes v]::grey)::grey
setze [☁ Cloud-Variable v] auf (verbinde (☁ Cloud-Variable::grey)(verbinde(Code::grey)[99])::grey)::grey

Wir wollen aber auch ganze Wörter und Sätze speichern und nicht nur einzelne Zeichen, wir setzen also die einzelnen Codes zusammen und speichern die sich daraus ergebene Zeichenfolge in die Cloud-Variable. Das geht eigentlich ganz einfach, Du nutzt statt der Cloud-Variable oben im vorletzten Beispiel eine normale, wiederholst das Skript so oft, bis alle Zeichen umgewandelt wurden und fügst am Ende den großen Code in die Cloud ein, wie im letzten Beispiel.

Der Code - Zeichen-Umwandler

Der Code - Zeichen-Umwandler funktioniert wie der oben beschriebene Zeichen - Code-Umwandler, nur umgekehrt, Du nutzt also statt der Liste Code die Liste Zeichen und umgekehrt, nur dass Du hier immer zwei Zeichen gleichzeitig scannen musst, das machst Du mit dem verbinde () ()-Block. Das Ergebnis wird dann nur nicht in die Cloud, sondern in eine Liste geladen. Das Zeichen 99 dient zur Trennung von Elementen, wird ein solches Zeichen erkannt, wird also ein neues Element erzeugt, in das die späteren Zeichen eingefügt werden. Unser Programm sieht am Ende also so aus (noch nicht der ganze Code ist enthalten):

Definiere codiere [Satz]
setze [Schritte1 v] auf (0)
wiederhole bis <(Schritte1) > (Länge von (Satz::custom))>
ändere [Schritte1 v] um (1)
wandle (Zeichen (Schritte1) von (Satz::custom)) in Code um::custom
end
setze [☁ Cloud-Variable v] auf (verbinde (☁ Cloud-Variable)[99])

Definiere wandle [Zeichen] in Code um
setze [Schritte v] auf (0)
wiederhole bis <(Element (Schritte) von [Zeichen v])=(Zeichen::custom)>
ändere [Schritte v] um (1)
end
setze [Code v] auf (Element (Schritte) von [Codes v])
setze [☁ Cloud-Variable v] auf (verbinde (☁ Cloud-Variable)(Code))