HomeTurtlegrafikGPanelRobotikGameGrid WebTigerPython
 Python - Online
mausevents

10. PIXELKOLLISIONEN

 

 

DU LERNST HIER...

 

präzise Kollisionserkennung mit Hilfe von sogenannten Pixelkollisionen. Im Unterschied zu den Gitterkollisionen, bei welchen sich zwei Actors in der gleichen Zelle befinden, kollidieren hier zwei Actors, wenn sich mindestens zwei Pixel ihrer Figuren überlappen. Das Modul GameGrid stellt die notwendigen Funktionen bereit, die solchen Kollisionen erkennen.

 

 

MUSTERBEISPIELE

 

 

 Beispiel 1: Zwei rechteckige Figuren bewegen sich frei im Spielfenster und reflektieren dabei am Fensterrand. Wenn sie zusammenstossen, ertönt ein Ton und die beiden Stäbe ändern ihre Bewegungsrichtung um 180°.
 

Die Kollisionen werden als Events erfasst. Dabei wird die Methode collide() aufgerufen.

Mit stick1.addCollisionActor(stick2) wird dem Stick1 mitgeteilt, dass er auf Kollisionen mit stick2 reagieren soll. Selbst wenn sich die beiden Figuren mit Eckpunkten berühren, wird ein Kollisionsevent ausgelöst.
Mit return 10 legst die Anzahl der Simulationszyklen fest, bis der Kollisionevent wieder aktiviert ist. Hier muss man ein weinig warten, bis sich die Sticks nicht mehr berühren.

  

Programm: 

from gamegrid import *
from soundsystem import *

# --------------------- class Stick ----------------------------------
class Stick(Actor):
    def __init__(self):
        Actor.__init__(self, True, "sprites/stick.gif", 2)  
   
    def act(self):
        step = 1
        loc = self.getLocation()
        dir = (self.getDirection() + step) % 360;
        if loc.x < 50:
            dir = 180 - dir
            self.setLocation(Location(55, loc.y))
        if loc.x > 450:
            dir = 180 - dir
            self.setLocation(Location(445, loc.y))
        if loc.y < 50:
            dir = 360 - dir
            self.setLocation(Location(loc.x, 55))
        if loc.y > 450:
            dir = 360 - dir
            self.setLocation(Location(loc.x, 445))
        self.setDirection(dir)
        self.move()

    def collide(self, actor1, actor2):
        actor1.setDirection(actor1.getDirection() + 180)
        actor2.setDirection(actor2.getDirection() + 180)
        play()
        return 10

# --------------------- main -----------------------------------------
makeGameGrid(500, 500, 1, False)
setSimulationPeriod(10)
stick1 = Stick()
addActor(stick1, Location(200, 200), 30)
stick2 = Stick()
addActor(stick2, Location(400, 400), 30)
stick2.show(1)
stick1.addCollisionActor(stick2)
show()
doRun()
openSoundPlayer("wav/ping.wav")
► In Zwischenablage kopieren

 

Beispiel 2: Fünf farbige Kugeln bewegen sich frei im Spielfeld und reflektieren am Rand. Sobald eine Kugel eine andere berührt, wird eine Kollision ausgelöst. Dabei prallt jede Kugel unter dem gleichen Winkel zurück, wie sie angerollt ist, und es wird ein Ton abgespielt.

Die Methode collide() definiert das Verhalten der beiden kollidierten Kugeln. Mit balls[i].addCollisionActor(balls[k]) bei jeder Kugel die Kollision mit allen übrigen Kugeln aktiviert.

  

Programm: 

from gamegrid import *
from soundsystem import *
from random import randint

# --------------------- class Ball ----------------------------------
class Ball(Actor):

   def __init__(self):
      Actor.__init__(self, True, "sprites/peg.png", 5)  
      
   def act(self):
      step = 1
      loc = self.getLocation()
      dir = (self.getDirection() + step) % 360;

      if loc.x < 20:
         dir = 180 - dir
         self.setLocation(Location(20, loc.y))
      if loc.x > 480:
         dir = 180 - dir
         self.setLocation(Location(478, loc.y))
      if loc.y < 20:
         dir = 360 - dir
         self.setLocation(Location(loc.x, 22))
      if loc.y > 480:
         dir = 360 - dir
         self.setLocation(Location(loc.x, 478))
      self.setDirection(dir)
      self.move()

   def collide(self, actor1, actor2):
      actor1.setDirection(actor1.getDirection() + 180)
      actor2.setDirection(actor2.getDirection() + 180)
      play()
      return 10

# --------------------- main -----------------------------------------
makeGameGrid(500, 500, 1, False)
setSimulationPeriod(10)
balls = []
for i in range(5):
   ball = Ball()
   ball.show(i)
   addActor(ball, Location(randint(30, 470), randint(30, 470)))
   balls.append(ball)

for i in range(5):
   for k in range(i + 1, 5):
      balls[i].addCollisionActor(balls[k])

openSoundPlayer("wav/ping.wav")  
show()
doRun()
► In Zwischenablage kopieren

 

Beispiel 3: Ein mausgesteuerter Pfeil kann Ballone zerplatzen.
20 Ballons werden an zufällig gewählten Positionen erzeugt. Den Pfeil kannst du mit gedrückten Maustaste bewegen. Wenn du mit der Pfeilspitze einen Ballon berührst, platzt er und es wird ein Ton abgespielt.

Mit dart.addCollisionActor(ballon) wird jeder Ballon ein Kollisionspartner des Pfeils.
actor2.removeSelf() lässt den getroffenen Ballon verschwinden.

  

Programm: 

from gamegrid import *
from soundsystem import *
from random import randint

# --------------------- class Dart --------------------------
class Dart(Actor, GGMouseListener):
    def __init__(self):
        Actor.__init__(self, True, "sprites/dart.gif") 
        self.oldLocation = Location()
    
    def mouseEvent(self, e):
        location = toLocationInGrid(e.getX(),e.getY())
        self.setLocation(location)
        self.oldLocation.x = location.x
        self.oldLocation.y = location.y

    def collide(self, actor1, actor2):
        play()
        actor2.removeSelf()
        return 5

# --------------------- main -----------------------------------
makeGameGrid(600, 600, 1, None, "sprites/town.jpg", False)
setTitle("Move dart with mouse to pick the balloon")
setSimulationPeriod(50)
dart = Dart()
addActor(dart, Location(100, 300))
addMouseListener(dart, GGMouse.lDrag)
for i in range(20):
    balloon = Actor("sprites/balloon.gif")
    addActor(balloon, Location(randint(50,550),randint(50,550)))
    dart.addCollisionActor(balloon)
show()
openSoundPlayer("wav/explode.wav")
doRun()
► In Zwischenablage kopieren

 

 

MERKE DIR...
 

Kollisionen werden als Events erfasst. Dabei wird die Methode collide(self, actor1, actor2) aufgerufen, in welcher definiert wird, was geschehen soll, wenn die beiden Actors kollidieren.
actor1.addCollisionActor(actor2) teilt dem actor1 mit, dass er auf Kollisionen mit actor2 reagieren soll.

 

 

ZUM SELBST LÖSEN
 

1.

Zwei Aliens bewegen sich frei im Spielfenster und reflektieren dabei am Fensterrand. Wenn sie zusammenstossen, ertönt ein Ton und die beiden Aliens ändern ihre Bewegungsrichtung um 180°.
Für die Aliens verwendest du die Sprites alien_0.gif und alien_1.gif, für den Hintergrund das Bild "sprites/town.jpg" aus der GameGrid-Bildbibliothek.		  
 

2.

60 Aliens bewegen sich frei im Spielfeld und reflektieren am Rand. Sobald ein Alien einen andere berührt, wird eine Kollision ausgelöst. Dabei prallt der erste Alien unter dem gleichen Winkel zurück, wie er angerollt ist und der zweite Alien verschwindet vom Spielfenster. Lasse das Programm so langen laufen, bis nur ein einziger Alien vorhanden ist.

Für die Aliens verwendest du das Sprite alien.png.

  
 

 
3.

Nemo beseitigt Quallen.
an zufällig gewählten Positionen werden 30 Quallen erzeugt. Wenn der mausgesteuerte Nemo eine Qualle berührt, wird diese vernichtet.

Für die Quallen verwendest du das Bild
"sprites/jellyfisch.gif" für den Nemo das Bild
"sprites/nemo.gif".