Merge branch 'ausführlicher' into 'master'

Cheat-Sheet ausführlicher gemacht

See merge request i4g/i4g-workshops-python-und-pew-pew!1

i4g_pewpew_basics.adoc → i4g_pewpew_cheatsheet_v1.adoc

+= Python & Pew Pew
+
+==== Die Programmiersprache Python
+
 ===== Zuweisungen & Variablen
 [source,python]
 ----
@@ -51,9 +55,7 @@ while bedingung:  # <1><2>
 <2> Der Doppelpunkt (`:`) ist wichtig und darf nicht weggelassen werden.
 <3> Die Einrückung (4 Leerschläge auf der linken Seite) ist auch hier wichtig.
 
-<<<
-
-===== PewPew-Programme
+==== PewPew-Programme
 
 .Struktur eines PewPew-Programms
 [source,python]
@@ -62,13 +64,15 @@ import pew  # <1>
 
 pew.init()  # <2>
 
-# ... # <3>
+screen = pew.Pix() <3>
+# ...# <4>
 # ...
 
-while True:  # <4>
-    # ... # <5>
+while True:  # <5>
+    # ... # <6>
     # ...
-    pew.tick(1/12)  # <6>
+    pew.show(screen)<7>
+    pew.tick(1/12)  # <8>
 ----
 <1> Macht das Python-Modul `pew` verfügbar.
     Jedes PewPew-Programm sollte hiermit beginnen.
@@ -77,14 +81,18 @@ while True:  # <4>
     Diese Funktion sollte
     vor allen anderen der Form `pew._funktionsname_()`
     aufgerufen werden.
-<3> Vor der `while`-Schleife können Vorbereitungen gemacht werden,
-    die nach Programmstart nur einmal stattfinden müssen.
-<4> So macht man in Python eine Endlos-Schleife.
+<3> Hier wird eine neue Variable `screen` definiert, die den Wert `pew.Pix()` hat. `pew.Pix()` ist die Zeichenfläche, auf der man dann nach Belieben 
+    einzelne Pixel oder Elemente mit mehreren Pixeln erscheinen lassen kann. 
+<4> Vor der `while`-Schleife können Vorbereitungen gemacht werden,
+    die bei Programmstart nur einmal stattfinden müssen.
+<5> So macht man in Python eine Endlos-Schleife.
     Der eingerückte Code darunter wird wiederholt ausgeführt,
     bis das Programm beendet wird oder sich selbst beendet.
-<5> Hier kommt der Code hin, der ständig wiederholt werden soll.
-<6> Hiermit begrenzen wir die Geschwindigkeit der Schleife
-    auf 12 Durchgänge pro Sekunde.
+<6> Hier kommt der Code hin, der ständig wiederholt werden soll.
+<7> Mit diesem Aufruf wird alles, was wir auf die Zeichenfläche `screen` gezeichnet haben, auf dem PewPew-Bildschirm angezeigt.
+<8> Hiermit begrenzen wir die Geschwindigkeit der Schleife
+    auf 12 Durchgänge pro Sekunde. (Bewegungen verlangsamt oder beschleunigt?)
+    
 
 .Beispiel: einen Pixel einmal pro Sekunde blinken lassen
 [source,python]
@@ -108,4 +116,97 @@ while True:
     screen.pixel(x, y, helligkeit)
     pew.show(screen)
     pew.tick(1/2)
+
+----
+
+==== Tipps und Tricks
+
+===== Elemente aus mehreren Pixeln
+
+Es können Elemente aus mehreren Pixeln gezeichnet werden:
+
+[source,python]
+----
+element = pew.Pix.from_iter((
+    (0, 1, 0 ,1),
+    (0, 1, 0, 1),
+))
 ----
+
+Dieser Code muss _vor_ die `while`-Schleife hin und kann dann in der `while`-Schleife mit `screen.blit(element, _<X-Koordinate>_, _<Y-Koordinate>_, _<Helligkeit (0-3)>_)` gezeichnet werden.
+
+===== Pixel und Elemente auf die Zeichenfläche zeichnen
+
+Dafür nutzt man in der `while`-Schleife die Zeile `screen._<funktionsname>_()`.
+
+.Optionen:
+* `screen.pixel(x, y, _<Helligkeit (0-3)>_)`
++
+Beispiel: `screen.pixel(5, 3, 3)` zeichnet einen Pixel an der Koordinate (5, 3) mit der höchsten Helligkeitsstufe.
+* `screen.blit(element, x=_<x>_, y=_<y>_)`
++
+Beispiel: `screen.blit(ball, x=1, y=2)` zeichnet das Element namens `ball` auf die Zeichenfläche `screen` an der Koordinate (1, 2). 
+
+===== Ein Pixel oder Element auf dem Bildschirm bewegen lassen
+
+Damit sich ein Pixel oder Element auf dem Bildschirm bewegen kann, müssen sich die Koordinaten des jeweiligen Pixels nach jedem Schleifen-Durchlauf verändern.
+Am besten definiert man _vor_ der `while`-Schleife zwei Variablen jeweils für die X- und Y-Koordinate <1> und verändert diese nach Belieben _innerhalb_ der `while`-Schleife <2>.
+Der Wert der Variablen `x` und `y` wird hier nach jedem Durchlauf um 1 erhöht. 
+
+[source,python]
+----
+#...
+x = 0 <1>
+y = 0
+
+while True:
+    x += 1 <2>
+    y += 1
+    #...
+    #...
+----
+
+===== Spielknöpfe
+
+Ziel ist es, dass das PewPew bei Knopfdruck eine bestimmte Aktion ausführt. 
+Hierfür schaltet man innerhalb der while-Schleife die Knöpfe frei <1>, damit dann das PewPew kontrollieren kann, ob ein bestimmer Knopf gedrückt wurde <2>.
+
+[source,python]
+----
+#...
+while True:
+    keys = pew.keys() <1>
+    if keys & pew.K_UP: <2>
+        #...# <3>
+----
+
+Falls `keys & pew.K_UP` wahr ist, wurde der Knopf UP (oben) gedrückt und der Code im Bereich <3> wird ausgeführt.
+
+.Übersicht aller Knöpfe: 
+* `pew.K_UP` = Knopf oben
+* `pew.K_DOWN` = Knopf unten
+* `pew.K_LEFT` = Knopf links
+* `pew.K_RIGHT` = Knopf rechts
+* `pew.K_O` = Knopf "O"
+* `pew.K_X` = Knopf "X"
+
+===== Text nach Abbruch der while-Schleife ausgeben
+
+Wenn beispielsweise ein Spiel gewonnen wurde, kann auch ein Text eingeblendet werden. In diesem Fall kommt der folgende
+Code _nach_ der `while`-Schleife:
+
+[source,python]
+----
+text = pew.Pix.from_text("Du hast gewonnen!") <1>
+for dx in range(-8, text.width): <2>
+    screen.blit(text, -dx, 1)
+    pew.show(screen)
+    pew.tick(1/12)
+----
+    
+<1> Hier wird ein Textelement definiert.
+<2> Nun wird das Textelement als Ganzes innerhalb der for-Schleife nach links bewegt (X-Koordinaten ändern sich nach jedem Durchlauf) bis der ganze Text angezeigt wurde.
+
+
+
+