ProgrammingBird wrote:

Dreche wrote:

Edit von Dreche: Verschiedene kleine Fehler im Originalpost behoben und den Blöcken Farben zugewiesen

Wie kann man Blöcken Farben zuweisen?

[scratchblocks]
() - ()::#0000ff reporter
[/scratchblocks]

() - ()::#0000ff reporter

[scratchblocks]
() - ()::motion reporter
[/scratchblocks]

() - ()::motion reporter

Dreche wrote:

mra26b25c2 wrote:

Ich fände eine solche Schleife gut:

wiederhole () mal und ändere bei jedem Durchlauf (lokaleVariable) um 1

Wenn die Variable nicht lokal sein soll, dann sind 2 Blöcke ein Ersatz:

wiederhole (...) mal
  ändere [... v] um (1)
  ...
end

Wenn die Variable lokal sein soll, dann wird es komplizierter, aber es ist möglich.
Man benötigt die sogenannte Rekursion. Das ist ein Konzept, dass ein Block sich selbst aufruft.

Allgemein braucht man mindestens eine Abbruchbedingung, sodass der Block sich nicht wie in folgendem Skript endlos erneut aufruft:

Definiere a
a

Ich nehme mal das Beispiel Fakultät: Die Fakultät von 5 ist 5*4*3*2*1. Der folgende Block sagt das Ergebnis von 5! (Fakultät von 5):

Definiere sage Fakultät von (Zahl) (Temporäres Ergebnis)
falls <(Temporäres Ergebnis) = []> dann
  sage Fakultät von (Zahl) (1) // Standardwert für die lokale Variable
sonst
  falls <(Zahl) = [1]> dann
    sage (Temporäres Ergebnis) // Abbruchbedingung
  sonst
    sage Fakultät von ((Zahl) - (1)) ((Temporäres Ergebnis) * (Zahl)) // Rekursion
  end
end

Wenn die Variable nicht lokal wäre, kann man das gut mit folgendem vergleichen:

Definiere sage Fakultät von (Zahl)
setze [Temporäres Ergebnis v] auf [1] // oben Standardwert für die „lokale“ Variable
setze [Zahl v] auf (Zahl) // Eine andere „versteckte“ lokale Variable oben
wiederhole bis <(Zahl::variables) = [1]>
  setze [Temporäres Ergebnis v] auf ((Temporäres Ergebnis) * (Zahl::variables)) // oben Rekursion
  ändere [Zahl v] um (-1)
end
sage (Temporäres Ergebnis) // oben Abbruchbedingung

Das Konzept der Rekursion stammt aus der funktionalen Programmierung, in der man teilweise Programmiersprachen hat, die nur globale Konstanten haben, aber keine Variable überhaupt. Es ersetzt in der funktionalen Programmierung alle Schleifen.

Für weitergehende Ressourcen:
Snap! ist wie ein altes Scratch, hat aber deutlich mehr Blöcke, falls das interessant ist.
Viele text-basierte Programmiersprachen unterstützen lokale Variablen. Eine, die allgemein als einfach gilt, ist Python.
Es gibt auch rein funktionale Programmiersprachen. Diese haben keine Variablen, sondern nur globale Konstanten. Eine davon ist Haskell. Dennoch kann man mit Haskell alles berechnen, was man berechnen will (Länge von Listen, …).

SD-Studios wrote:

Vielleicht wäre es cool, wenn man mehr mit online Date arbeiten könnte.
Zum einen könnte man dann z. B. irgendwie backend implementieren, also Server.

(Also ich denke, man macht dann ein 2. Projekt(der Server), in dem man mehr extra Funktionen hat, z. B.:

Wenn Client verbindet::#880088

(client nr::#880088)

Führe auf Client [client] funktion [funktions name] aus mit Input ()::#880088

Andere Möglichkeiten/Idee:
Zugriff auf GitHub

Edit von Dreche: Verschiedene kleine Fehler im Originalpost behoben und den Blöcken Farben zugewiesen

Eine eigentlich gute Idee, aber das hat einige Probleme:

1. Wie und wann wird der Server gestoppt? (Es kann nicht für jedes Projekt rund um die Uhr ein anderes Projekt auf einem Scratch Server am Laufen sein)
   
2. Ein Server braucht keine grafische Oberfläche; Bewegungs- und Aussehensblöcke machen bei einem Server keinen Sinn.
   
3. Was ist das echte Interface? Wie sollen die Blöcke am Schluss wirklich lauten?
   
4. Ist es nicht besser, ein dezentrales System zu fördern? Damit meine ich, dass man jetzt bereits Skripte wie ein Server ausführen kann, indem man die Arbeit des Servers auf jeden Scratcher, der das Projekt offen hat, aufteilt.
   Falls es unmöglich ist, die Arbeit aufzuteilen, sodass jeder seinen Teil erledigt, dann kann man immer noch einen zum Server ernennen und der führt dann die Skripte des Servers aus. Sollte er das Projekt schließen, können die anderen den Posten übernehmen.
   

Ein Interface, was ich mir eher vorstellen könnte:

// Server
Wenn Ereignis von Client ankommt::#880088 hat

(Nummer von Client::#880088)

(Element (1) der Übertragung::#880088)

Übertrage [Liste v] an Client Nummer ()::#880088

<ist Client Nummer () noch online?::#880088> // Kann ersetzt werden durch das Senden eines Pings an den Client, der den beantworten muss.

// Client
Wenn Ereignis von Server ankommt::#880088 hat

(Element (1) der Übertragung::#880088)

Übertrage [Liste v] an Server::#880088

Bei der Umsetzung wäre der Server eine andere Figur wie die Bühne. Mit dem Interface wird auch festgesetzt, dass nur ein Server existieren kann.

Es werden immer ganze Listen übertragen, damit man Daten zwischen Server und Client austauschen kann. Sollten mehrere Listen zur gleichen Zeit eintreffen, wird eine nach der anderen bearbeitet. Eine Liste gilt als bearbeitet, wenn kein Skript nach dem „Wenn Ereignis von Client/Server ankommt“ mehr aktiv ist. Dann kann erst die nächste bearbeitet werden.

Und noch ein Problem: Scratch soll einfach bleiben. Wie schafft man es, diese Funktion anzubieten, ohne vorauszusetzen, dass jeder neue Scratcher weiß, was ein Server ist?

Zu GitHub: Was will man damit anfangen? Will man den Quellcode von Scratch mit Scratch analysieren oder was kann man somit erreichen?

SD-Studios wrote:

Mir ist noch eingefallen, ich programmieren (nicht viel) auch JavaScript. Vielleicht wären noch generell Funktionen cool, die es schon so in js gibt.Also z.B.: file Input/Output

Ich kenne JavaScript nur sehr minimal. Kann man vom Browser einfach Dateien lesen/schreiben? Wenn, dann braucht man doch bestimmt irgendeine Berechtigung vom Benutzer, sonst wäre das eine große Sicherheitslücke.
(Ich meine, du kannst eine Aufforderung(also so ein Datei öffne Menu) anfordern und dann kann der User was hochladen.Alles andere wäre hacking(denke ich mal).Umd Dateien kann man ja Download.

Wenn man es aber so gestaltet, dass der Benutzer die Datei auswählen muss, dann ist das schon völlig anders. Ich denke, dass dann das größere Problem ist, wie das Interface in Scratch aussehen soll: Soll eine Datei in eine Liste geladen werden, um Zeilenumbrüche zu speichern? Was ist, wenn der Benutzer eine Binärdatei auswählt? (An sich kommt Scratch damit klar, weil nichts auf Binärdateien prüft. Dennoch sollte Scratch eher einfach bleiben.)

SD-Studios wrote:

Ich glaub das es bei „Snap“ (so ähnlich wie scratch) einen block gibt, in dem man JavaScript ausführen kann.Wo bei Ich das nicht unbedingt so in scratch einführen würde.

Wenn man das hätte, könnte man auch gleich eine ScratchJS Library schreiben, und dann alles in JS erledigen (und die Library verwenden).

SD-Studios wrote:

Und noch ein großer Wunsch von mir:
Ich weiß nicht ob das schon geht, aber in scratch(vanilla) also nicht TurboWarp custom Blöcke einfügen(also halt schon über mod, aber halt ohne das man eine Mod braucht um diese mods einzuführen)

Diesen Vorschlag kann ich nicht verstehen. Benutzerdefinierte Blöcke gibt es, und man kann die Blöcke auch aus der Randspalte in den Schriftbereich ziehen. Oder ist eine Funktion gemeint, wie, dass man mit einem Mausradklick ein Popup öffnet, in dem man nach Blöcken suchen kann, was oft schneller geht?

SD-Studios wrote:

Mit dem Vorschlag von mods meine ich mods von z.B.: scratchX
Also dann kann man z.B. mods von scratchX importieren oder selbst welche machen…(ich glaube das geht in der offline Version)
Vermutlich sollte man nur ausgewählte mods nehmen können.Mit mods meine ich so etwas wie extensions.

((1001101) xor (011010010))

likrakete wrote:

Neuer Operator:

((1001101) xor (011010010))

(Falls ihr euch fragt was xor für ein operator sein soll, dann fragt einfach.)

SD-Studios wrote:

likrakete wrote:

Neuer Operator:

((1001101) xor (011010010))

(Falls ihr euch fragt was xor für ein operator sein soll, dann fragt einfach.)

Ist xor nicht das, wo nur eins von beidem WAHR ist?

((011) xor (101))

likrakete wrote:

SD-Studios wrote:

likrakete wrote:

Neuer Operator:

((1001101) xor (011010010))

(Falls ihr euch fragt was xor für ein operator sein soll, dann fragt einfach.)

Ist xor nicht das, wo nur eins von beidem WAHR ist?

Xor ist ein Operator der, soweit ich weiß, nur auf Zahlen in Binärschreibweise angewendet werden kann. Man rechnet dann das ganze von hinten nach vorne durch, wobei man für zwei nullen eine 0, für zwei einsen eine 0, für eine 1 und eine 0 eine 1, und für eine 0 und eine 1 ebenfalls eine 1 notiert.

Beispiel:

((011) xor (101))

    0     1     1
xor 1     0     1
––––––––––––––—–––
  = 1    1    0 ⬅ 1 & 1 = 0
    ⬆      ↖
0 & 1 = 1    1 & 0 = 1

Das Ergebnis wäre also 110.

Wenn du es nicht ganz verstanden hast, dann ist es auch nicht so schlimm, denn vermutlich wird es so einen Block nie geben.

Edit von Dreche: Monospace-Schrift mit [code]-Tag erzwungen

// Ich verwende zur Demonstration folgende 2 Blöcke
<false::grey>
<true::grey>

<<false::grey> xor <false::grey>::operators> // false
<<false::grey> xor <true::grey>::operators> // true
<<true::grey> xor <false::grey>::operators> // true
<<true::grey> xor <true::grey>::operators> // false

// Ich verwende die C-Syntax
([] \<\< ()::operators) // Bitshift left
([] \>\> ()::operators) // Bitshift right
([] | []::operators) // Bitwise or
([] & []::operators) // Bitwise and
([] ^ []::operators) // Bitwise xor
(~[]::operators) // Bitwise not

printf("%i", 10 & 6); // 0b1010 & 0b0110 = 0b0010 = 2
// 10 & 6 ist also 2

Wenn <                           >

likrakete wrote:

Eine super Ereignis wäre:

Wenn <>::#ffbf00

(Habe die Farbe geändert)

(i::operators)

((i::operators) * (i::operators)) // -1
([Wurzel v] von (-1)) // i

([x] ^ [y]::operators)
([x]-te Wurzel aus [y]::operators)
(log [x] [y]::operators)
([x]!::operators)

KROKOBIL wrote:

Tomino2 wrote:

Ich fände den Block wechsle zum vorherigen Kostüm sehr praktisch.

vorheriges Kostüm

wechsle zu Kostüm ((Kostümnummer) - (1))

MasterCodiererNeil wrote:

Mal eine etwas kompliziertere Idee:
Komplexe Zahlen.
Wie:

(i::operators)

Und:

((i::operators) * (i::operators)) // -1
([Wurzel v] von (-1)) // i

Oder mehr Operatoren generell!
Mir fehlen diese hier:

([x] ^ [y]::operators)
([x]-te Wurzel aus [y]::operators)
(log [x] [y]::operators)
([x]!::operators)

Tomino2 wrote:

KROKOBIL wrote:

Tomino2 wrote:

Ich fände den Block wechsle zum vorherigen Kostüm sehr praktisch.

vorheriges Kostüm

wechsle zu Kostüm ((Kostümnummer) - (1))

Und wenn die Kostümnummer 1 ist?

Definiere vorheriges Kostüm
falls <(Kostümnummer) =[1]> dann
  wechsle zu Kostüm [letztes v]
sonst
  wechsle zu Kostüm ((Kostümnummer) - (1))
end

wechsle zu Kostüm (verbinde [Z] (Zufallszahl von (1) bis (10)))

Dreche wrote:

MasterCodiererNeil wrote:

Mal eine etwas kompliziertere Idee:
Komplexe Zahlen.
Wie:

(i::operators)

Und:

((i::operators) * (i::operators)) // -1
([Wurzel v] von (-1)) // i

Oder mehr Operatoren generell!
Mir fehlen diese hier:

([x] ^ [y]::operators)
([x]-te Wurzel aus [y]::operators)
(log [x] [y]::operators)
([x]!::operators)

Also:

√(-1)
Die Wurzel von -1 muss selbst in den komplexen Zahlen nicht i sein. Was ist mit -i? (-i)² = (-1) * i * (-1) * i = (-1)² * i² = 1*i²=-1
In den Komplexen Zahlen gilt, dass jede Zahl n n-te Wurzeln hat (für n∈ℕ). Hier ist das eben die zweite Wurzel. Der Betrag aller n-ten Wurzeln ist aber immer gleich.
Komplexe Zahlen sind aber schlussendlich nur ein Konstrukt der Mathematik, um mehr Informationen in eine Zahl zu bekommen. In Scratch funktionieren auch Listen oder 2 Variablen.

(x)√(y)
Manchmal, also wenn x eine Zweierpotenz ist, geht das ja. √(√(x)) = (4)√(x)
Mir fehlt das aber auch. Und wenn das zu kompliziert aussehen sollte, dann kann man es ja in x^y einbauen: x^½ = √(x); x^⅓ = ∛(x); …

Hier ein Grund:
Potenzgesetz: (x^a)^b = x^(a*b)
Hier: (x^2)^y = x = x¹ = x^(2*y) ⇒ 1 = 2y ⇒ y=½

log x y
Frühere Taschenrechner konnten auch nur lg(x) = log₁₀(x). Es existiert aber eine Umrechnungsformel:
log(a; u) = lg(u) / lg(a)
Beweis: (alle folgenden Aussagen sind für alle a und u wahr)
a^(log(a; u)) = u
⇒ (10 ^ (lg a)) ^ log(a; u) = 10 ^ (lg u)
⇒ 10^((lg a) * log(a; u)) = 10^(lg u)
⇒ (lg a) * log(a; u) = lg u | : (lg a)
⇒ log(a; u) = (lg u) / (lg a)

( (...) ^ (...)::operators )

likrakete wrote:

Ein praktischer Operator wäre:

( (...) ^ (...)::operators )

setze [x v] auf [...]
setze [y v] auf (x)
wiederhole ((x) - (1)) mal
setze [y v] auf ((x) * (y))
end
sage (x)

setze [x v] auf [...]
setze [z v] auf [1]
wiederhole bis <((x) gerundet) = (x)>
setze [x v] auf ((x) * (10))
setze [z v] auf ((z) * (10))
end
setze [y v] auf (x)
wiederhole ((x) - (1)) mal
setze [y v] auf ((x) * (y))
setze [x v] auf ((x) / (z))
end
sage (x)

debiankaios wrote:

likrakete wrote:

Ein praktischer Operator wäre:

( (...) ^ (...)::operators )

setze [x v] auf [...]
setze [y v] auf (x)
wiederhole ((x) - (1)) mal
setze [y v] auf ((x) * (y))
end
sage (x)

Es geht auch mit einer definition/funktion, dafür sind mein scratch-erfahrungen aber nicht mehr hoch genug.
Übrigens wenn du ungerade Zahlen hochnehmen möchtest

setze [x v] auf [...]
setze [z v] auf [1]
wiederhole bis <((x) gerundet) = (x)>
setze [x v] auf ((x) * (10))
setze [z v] auf ((z) * (10))
end
setze [y v] auf (x)
wiederhole ((x) - (1)) mal
setze [y v] auf ((x) * (y))
setze [x v] auf ((x) / (z))
end
sage (x)

Ungetestet!

setze [Potenz v] auf [1]
wiederhole (Exponent) mal
  setze [Potenz v] auf ((Potenz) * (Basis))
end

debiankaios wrote:

likrakete wrote:

Ein praktischer Operator wäre:

( (...) ^ (...)::operators )

setze [x v] auf [...]
setze [y v] auf (x)
wiederhole ((x) - (1)) mal
setze [y v] auf ((x) * (y))
end
sage (x)

Es geht auch mit einer definition/funktion, dafür sind mein scratch-erfahrungen aber nicht mehr hoch genug.
Übrigens wenn du Komma-Zahlen hochnehmen möchtest

setze [x v] auf [...]
setze [z v] auf [1]
wiederhole bis <((x) gerundet) = (x)>
setze [x v] auf ((x) * (10))
setze [z v] auf ((z) * (10))
end
setze [y v] auf (x)
wiederhole ((x) - (1)) mal
setze [y v] auf ((x) * (y))
setze [x v] auf ((x) / (z))
end
sage (x)

Ungetestet!

Definiere var Ergebnis = (x)^(y)
/*Dein Code*/
setze [Ergebnis v] auf [y]