Coding für Einsteiger: Wie Sie mit Tigerjython Ihr eigenes Bubble Shooter Spiel entwickeln

Willkommen in der faszinierenden Welt des Programmierens! Hast du dich jemals gefragt, wie beliebte Spiele wie Bubble Shooter entstehen? In diesem Artikel zeigen wir dir, wie du mit der kinderfreundlichen Programmiersprache TigerJython dein eigenes Bubble Shooter Spiel entwickeln kannst. Keine Sorge, du brauchst keine Vorkenntnisse! Wir führen dich Schritt für Schritt durch den Prozess, sodass du am Ende stolz dein eigenes Spiel präsentieren kannst.

Was ist TigerJython?

TigerJython ist eine speziell für den Einstieg in die Programmierung entwickelte Version von Python. Sie zeichnet sich durch eine einfache Syntax, eine übersichtliche Benutzeroberfläche und eine umfassende Bibliothek mit Grafikfunktionen aus. Das macht TigerJython ideal für Kinder und Jugendliche, aber auch für Erwachsene, die die Grundlagen des Programmierens erlernen möchten.

Vorbereitung: TigerJython installieren und einrichten

Bevor wir loslegen, musst du TigerJython installieren. Du kannst es kostenlos von der offiziellen Webseite herunterladen: [Link zur TigerJython Webseite einfügen]. Die Installation ist denkbar einfach und selbsterklärend. Nach der Installation öffne TigerJython, und du bist bereit für dein erstes Bubble Shooter Spiel!

Grundlagen für unser Bubble Shooter Spiel

Bevor wir uns in den Code stürzen, ist es wichtig, die grundlegenden Konzepte unseres Spiels zu verstehen. Unser Bubble Shooter wird aus folgenden Elementen bestehen:

• Blasen (Bubbles): Die farbigen Kugeln, die wir abschießen und anordnen.
• Abschussvorrichtung: Der Mechanismus, mit dem wir die Blasen abfeuern.
• Spielfeld: Der Bereich, in dem die Blasen angeordnet sind.
• Kollisionserkennung: Die Logik, die erkennt, wenn eine Blase eine andere berührt.
• Punktzahl: Eine Variable, die unsere Leistung im Spiel festhält.

Schritt 1: Das Spielfeld erstellen

Beginnen wir mit dem Spielfeld. Wir definieren die Größe des Fensters und zeichnen einen einfachen Hintergrund.

„`python
from tjmodules import *

# Fenstergröße definieren
width = 800
height = 600
make(„Bubble Shooter”, width, height)
background(„light blue”)

# Spielfeld zeichnen (optional)
# Könnte z.B. ein Rechteck sein
# rect(0, 0, width, height, „dark blue”)
„`

Dieser Code importiert zunächst die notwendigen Funktionen aus der TigerJython Bibliothek (tjmodules). Dann definieren wir die Breite und Höhe unseres Fensters. Mit der Funktion make() erstellen wir das Fenster und geben ihm einen Titel. Schließlich färben wir den Hintergrund mit background("light blue").

Schritt 2: Die Blasen (Bubbles) erstellen

Nun erstellen wir die Blasen. Jede Blase hat eine Farbe, eine Position (x, y) und einen Radius.

„`python
# Blasen-Klasse definieren
class Bubble:
def __init__(self, x, y, color, radius):
self.x = x
self.y = y
self.color = color
self.radius = radius

def draw(self):
fillCircle(self.x, self.y, self.radius, self.color)

# Eine Liste von Blasen erstellen
bubbles = []

# Beispiel: Erstelle 5 Blasen
for i in range(5):
x = 100 + i * 120
y = 100
color = choice([„red”, „green”, „blue”, „yellow”])
radius = 30
bubble = Bubble(x, y, color, radius)
bubbles.append(bubble)

# Blasen zeichnen
def drawBubbles():
for bubble in bubbles:
bubble.draw()

drawBubbles() # Blasen beim Start zeichnen
„`

Dieser Code definiert eine Klasse Bubble, die die Attribute und die Zeichenfunktion einer Blase kapselt. Wir erstellen eine Liste namens bubbles und fügen ihr einige zufällige Blasen hinzu. Die Funktion choice() wählt zufällig eine Farbe aus einer Liste aus. Schließlich definieren wir die Funktion drawBubbles(), die alle Blasen in der Liste zeichnet.

Schritt 3: Die Abschussvorrichtung implementieren

Die Abschussvorrichtung ist der Mechanismus, mit dem wir die Blasen abfeuern. Wir verwenden die Mausposition, um die Richtung zu bestimmen.

„`python
# Abschussblase erstellen
shooter_bubble = Bubble(width // 2, height – 100, „red”, 30)
shooter_bubble.draw()

# Funktion zum Abschießen der Blase
def shootBubble(x, y):
global shooter_bubble # Auf globale Variable zugreifen
# Bewegung der Blase basierend auf der Mausposition berechnen
dx = x – shooter_bubble.x
dy = y – shooter_bubble.y
# Normalisieren der Bewegung (Geschwindigkeit beibehalten)
length = sqrt(dx**2 + dy**2)
dx /= length
dy /= length
speed = 5 # Geschwindigkeit der Blase
dx *= speed
dy *= speed

# Funktion zum Bewegen der Blase
def moveBubble():
nonlocal shooter_bubble # Zugriff auf Variable im äußeren Scope
shooter_bubble.x += dx
shooter_bubble.y += dy
clearCanvas() # Canvas leeren
background(„light blue”) # Hintergrund neu zeichnen
drawBubbles() # Bestehende Blasen neu zeichnen
shooter_bubble.draw() # Abschussblase neu zeichnen
refresh() # Bildschirm aktualisieren

if shooter_bubble.x < 0 or shooter_bubble.x > width or shooter_bubble.y < 0: # Blase außerhalb des Bildschirms -> Schleife beenden
return

# Kollisionserkennung mit anderen Blasen (später implementieren)

delay(10) # Kurze Pause
moveBubble() # Rekursiver Aufruf

moveBubble() # Start der Bewegung

# Auf Mausklick reagieren
def onMousePressed(x, y, button):
if button == LEFT:
shootBubble(x, y)

onMousePressed = onMousePressed # Zuweisung der Funktion

„`

Dieser Code erstellt zunächst die shooter_bubble am unteren Rand des Bildschirms. Die Funktion shootBubble(x, y) berechnet die Richtung der Blase basierend auf der Mausposition (x, y). Wir verwenden Trigonometrie (implizit durch die Normalisierung des Vektors), um sicherzustellen, dass die Blase in die richtige Richtung fliegt. Die Funktion moveBubble() bewegt die Blase in kleinen Schritten und zeichnet alles neu, um die Animation zu erzeugen. Wir verwenden Rekursion, um die Bewegung zu simulieren. Schließlich definieren wir die Funktion onMousePressed(), die auf Mausklicks reagiert und die shootBubble() Funktion aufruft.

Schritt 4: Kollisionserkennung implementieren (Erweiterung)

Dieser Schritt ist etwas komplexer, aber entscheidend für das Gameplay. Wir müssen erkennen, wenn eine Blase mit einer anderen kollidiert. Hier ist ein Ansatz:

„`python
# Funktion zur Kollisionserkennung
def checkCollision(bubble1, bubble2):
distance = sqrt((bubble1.x – bubble2.x)**2 + (bubble1.y – bubble2.y)**2)
return distance < bubble1.radius + bubble2.radius ```

Diese Funktion berechnet den Abstand zwischen zwei Blasen und prüft, ob dieser kleiner ist als die Summe ihrer Radien. Wenn ja, liegt eine Kollision vor. Diese Funktion muss in der moveBubble() Funktion aufgerufen werden, um zu überprüfen, ob die shooter_bubble eine andere Blase trifft.

Schritt 5: Das Spiel verbessern (Erweiterungen)

Hier sind einige Ideen, wie du dein Bubble Shooter Spiel verbessern kannst:

• Punktzahl: Füge eine Punktzahl hinzu und erhöhe sie bei erfolgreichen Treffern.
• Verschiedene Level: Erstelle verschiedene Level mit unterschiedlichen Anordnungen der Blasen.
• Spezialblasen: Füge spezielle Blasen mit besonderen Fähigkeiten hinzu (z.B. Bombenblasen).
• Soundeffekte: Integriere Soundeffekte, um das Spielerlebnis zu verbessern.
• Grafiken: Verwende ansprechendere Grafiken für die Blasen und den Hintergrund.

Fazit

Herzlichen Glückwunsch! Du hast die Grundlagen für dein eigenes Bubble Shooter Spiel mit TigerJython gelernt. Dies ist nur der Anfang. Experimentiere mit dem Code, probiere neue Ideen aus und erweitere dein Spiel. Das Programmieren soll Spaß machen! Mit TigerJython hast du eine tolle Plattform, um deine kreativen Ideen umzusetzen und deine eigenen Spiele zu entwickeln. Viel Spaß beim Codieren!