Ich würde gerne Pygame genauer kennen lernen. Ich habe schon ein bisschen bei dem Workshop von @codecraft und @lukasw bei den GLT gelernt. Ich würde gerne lernen wie ich machen kann das der Player fliegen und mich einfach eine Zeit lang mit anderen Pygame programmieren.
Mein Vorschlag wäre das wir uns ein mal in der Woche Online treffen.
Ich könnte pixel Grafiken erstellen, sonst kenne ich mich mit Pygame nicht aus 
Wie geht es hier weiter? Ich hab jedenfalls Interesse
Beim ersten Treffen bin ich dabei. Bei allen anderen weiß ich noch nicht, ob mir das passt, weil ich noch nicht weiß, wie meine Arbeitswoche aussehen wird.
Ich weiß noch nicht, ob 15:30h für mich passt, das kann ich leider erst sagen wenn es soweit ist
Hier ist der Link zum BBB.
Könnte man vieleicht machen das wenn man auf die bombe springt und in weniger als 200ms wieder springt man dann statt zu explodieren höher springt?
machen das die bomben weder im Boden, noch in anderen Gegnern noch in einem selbst dh min 3(hier die Einheit vom Spiel einfügen) entfernt spawnen, noch hinter dem Ziel spawnen.
machen das die Bomben nur alle keine ahnung? 3sek spawnen
einen hardkohr mode in dem wir viele gliches nicht gefixt haben
interesirt das noch jemanden?
Das Online-Treffen findet jede Woche Mittwochs um 15:30 Uhr per BBB statt.
Ich muss dann von Woche zu Woche schauen, ob ich kommen kann, da ich zu der Zeit “Bereitschaft” habe. Interesse hab ich aber.
ich habe genau da erst schuhl frei ich könte so um halb 5
wie siht es denn hier dann aus
@mli2013 hatte eine Idee für ein kleines Spiel, das sie gerne (mit meiner Unterstützung) entwickeln würde. Da sie Python schon lernt, wäre pygame naheliegend. Welches Pygame wird dann verwendet? (pygame vs pygame-ce)
Damit es hier bald weitergeht, schlage ich einen regelmäßigen Termin dienstags um 17:30 Uhr vor.
Erster Termin wäre dann nächste Woche Dienstag, der 3. Februar. Falls ihr weitere Hilfe beim Organisieren braucht, meldet euch einfach bei mir.
Zunächst haben wir die Grundbausteine von 2D-Spielen dekonstruiert, d.h., unser Spiel besteht aus einem Fenster, welches der Nutzer/Spieler sieht und auf welchem man Dinge zeigen kann. Generell zeichnet man Rechtecke auf denen man z. B. Motive wie das Bild eines Fisches platzieren kann, damit der Nutzer lustige Figuren sieht.
Diese Rechtecke kann man über Koordinaten in einem Koordinatensystem des Fensters darstellen, wobei z. B. die obere linke Ecke des Rechtecks eine x,y-Koordinate zugewiesen wird und der rest durch eine Höhe und Breite dargestellt ist. In dem Rechteck können wir dann unser Fischbild auflegen.
Zur einführung in diese grundliegenden Ideen haben wir damit angefangen ein “Pong”-Spiel zu programmieren, dabei haben wir drei Rechtecke: Das Paddel des linken Spielers, das Paddel des rechten Spielers und den Ball. Zusätzlich müssen wir auf Nutzereingaben reagieren.
Um auf Nutzereingaben reagieren zu können, und überhaupt die Positionen unserer Objekte zu aktualisieren müssen wir regelmäßig Einen Code ausführen diese Funktionalitäten bearbeitet: Die sogenannte Game-Loop. Diese hohlt sich die Eingaben des Nutzers und aktualisiert alle Objekte, bzw. den Zustand des Spiels.
Zuletzt haben wir in der Session die Implementierung angefangen, welche aktuell die Paddel und den Ball zeichnet und z. B. so aussieht
import pygame
size = width, height = 1280, 920 # größe des Bildschirms
screen = pygame.display.set_mode(size) # Bildschirm mit der Größe erstellen
pong_ball = pygame.Rect((width / 2 - 15, height / 2 - 15), (30, 30)) # Pong-Ball-Rechtecke in der Mitte des Bildschirms platzieren
player_1 = pygame.Rect((50, height / 2 - 50), (10, 100)) # Paddel 1 links platzieren
player_2 = pygame.Rect((1280 - 50 - 10, height / 2 - 50), (10, 100)) # Paddel 2 rechts platzieren
while True:
events = pygame.event.get() # Alle Nutzereingaben abholen
for event in events: # ... und durchlaufen
if event.type == pygame.QUIT: # der Nutzer möchte das Spiel beenden.
exit(0)
# weiße rechtecke zeichnen
pygame.draw.rect(screen, (255,255,255), pong_ball)
pygame.draw.rect(screen, (255,255,255), player_1)
pygame.draw.rect(screen, (255,255,255), player_2)
# gezeichnetes anzeigen lassen
pygame.display.flip()
Auf der Grundlage vom letzten Mal haben wir das
Pong-Spiel um einfache Nutzer-Eingaben erweitert.
Zunächst haben wir Tastatureingaben aus events, gelesen.
pygame.events.get() holt sich eine Liste an allen Ereignissen
die seit dem letzten Aufruf geschehen sind, in der Reihenfolge in
welche diese Passiert sind. Wenn nun ein Ereignis vom Typen
KEYUP oder KEYDOWN ist, bedeutet es jeweils, dass eine Taste
losgelassen oder gedrückt wurde (event.type). Die konkrete Taste
lässt sich durch die Variable event.key herausfinden. Eine Liste
der möglichen Tasten findet sich in der PyGame-Dokumentation von
pygame.key.
Wir speichern den aktuellen Bewegungszustand eines Paddels in einer Variable,
welche genau drei Zustände ausdrücken kann:
Dazu verwenden wir eine Ganzzahl, wenn das Paddel sich nach oben Bewegt ist der
Wert -1, nach unten 1 und gar nicht 0.
Diesen Wert können wir abhängig von den Tastaturereignissen setzen, wenn also z.B.
die W-Taste gedrückt ist, würden wir den Bewegungszustand auf -1 setzen, falls die dieselbe losgelassen wird, setzen wir die Bewegung auf 0.
Diese Bewegungsvariable lässt sich auf die aktuelle Koordinaten des Paddels
in unserer Schleife addieren, sodass sich der Spieler immer weiter in eine
Richtung bewegt. Wenn der Spieler z.B. eine Bewegungsgeschwindigkeit v hat, dann
könnte das so aussehen
player.y += bewegung * v
wobei bewegung der aktuelle Bewegungszustand und player.y die y-Koordinate des Spielers ist.
Diese naive Bewegungsimplementierung hat ein Problem, die Bewegungsgeschwindigkeit
des Spielers ist abhängig von der Leistung des Rechners, je öfter die Schleife in
einem Zeitinterval (z.B. einer Sekunde) ausgeführt wird, desto schneller
bewegt sich der Spieler, unabhängig von v. Die Lösung dazu ist Delta-Zeit.
Delta-Zeit beschreibt die Zeit, welche der letzte durchaluf der Spielschleife
gebraucht hat und kann auf Bewegung hinzumultipliziert werden. Die aktuelle
Deltazeit in Sekunden lässt sich einfach durch die tick()-Methode einer pygame.time.Clock ermitteln.
import pygame
size = width, height = 1280, 920
screen = pygame.display.set_mode(size)
time = pygame.time.Clock() # initialisiere eine Uhr
pong_ball_size = 30
screen_middle = width / 2, height / 2
pong_ball = pygame.Rect((
screen_middle[0] - (pong_ball_size / 2),
screen_middle[1] - (pong_ball_size / 2)),
(pong_ball_size, pong_ball_size)
)
player_1 = pygame.Rect((50, height / 2 - 50), (10, 100))
player_2 = pygame.Rect((1280 - 50 - 10, height / 2 - 50), (10, 100))
bewegung_player_1 = 0
while True:
dt = time.tick() # hole die Delta-Zeit
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
exit(0)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_w: # registriere Bewegungstasten
bewegung_player_1 = -1
if event.key == pygame.K_s:
bewegung_player_1 = 1
if event.type == pygame.KEYUP:
if event.key == pygame.K_w or event.key == pygame.K_s: # Keine weitere
# Bewegung
bewegung_player_1 = 0
player_1.y += bewegung_player_1 * 1 * dt # Bewegungsberechnung
screen.fill((0, 0, 0))
pygame.draw.rect(screen, (255,255,255), pong_ball)
pygame.draw.rect(screen, (255,255,255), player_1)
pygame.draw.rect(screen, (255,255,255), player_2)
pygame.display.flip()
Eine kleine Übungsaufgabe ist nun, die Bewegung von player_2 zu implementieren.
Die Session am kommenden Dienstag (10.03.2026) entfällt.