Flucht und Verfolgung in Processing.py (ohne OOP)

Mit diesem Beitrag möchte ich zum einen das Projekt »The Nature of Code in Python« wieder aufnehmen und zum anderen meine Idee, »Methoden der Künstlichen Intelligenz für Spiele (-programmierer)« realisieren. Ich beginne da mit einem einfachen Beispiel, das zeigt, wie man Flucht und Verfolgung per Programm so realisieren kann, daß es für den Spieler wenigstens wie ein halbwegs intelligentes Verhalten der Opponenten aussieht.

In dem Sketch wird der Spieler als roter Kreis dargestellt, der von einem grünen Kreis verfolgt wird, während ein violetter Kreis vor dem Spieler flieht, aber nur, wenn dieser ihm zu nahe kommt. Die Idee habe ich dem Video »Chase and Flee« von Jeff Thompson entnommen, der sie dort in Processing (Java) realisiert hatte und die ich für meinen ersten Ansatz nahezu 1:1 nach Processing.py portiert habe:

WIDTH, HEIGHT = 640, 480
dia           = 30
chaserSpeed   = 2.0
fleeSpeed     = -2.0

player = PVector(0, 0)
chaser = PVector(WIDTH/2, HEIGHT/2)
flee   = PVector(WIDTH/2, 3*HEIGHT/4)

def setup():
    size(WIDTH, HEIGHT)
    this.windowTitle("Flucht und Verfolgung (ohne OOP)")
    cursor(CROSS)
    
def draw():
    background(248, 158, 80)
    
    # Player Update
    player.x = mouseX
    player.y = mouseY
    
    # Chaser Update
    dir = PVector.sub(player, chaser)
    dir.normalize().mult(chaserSpeed)
    chaser.add(dir)
    
    # Flee Update
    distBetween = player.dist(flee)
    if distBetween < 100:
        dir = PVector.sub(player, flee)
        dir.normalize().mult(fleeSpeed)
        flee.add(dir)
    # Emergency Exit
    if flee.x > width - dia/2 or flee.x < dia/2:
        flee.x = width/2
    if flee.y > height - dia/2 or flee.y < dia/2:
        flee.y = 3*height/4

    stroke(0)
    strokeWeight(1)
    # Player Show
    fill(240, 80, 37)
    circle(player.x, player.y, dia)
    
    # Chaser Show
    fill(98, 199, 119)
    circle(chaser.x, chaser.y, dia)
    
    # Flee Show
    fill(240, 99, 164)
    circle(flee.x, flee.y, dia)
    
# Programm für Screenshot anhalten
def keyPressed():
    noLoop()

Eine Besonderheit ist der »Notausgang«. Es kann nämlich durchaus vorkommen, daß der fliehende Kreis den sichtbaren Bereich des Fensters verläßt und dann ist er nicht mehr zurückzuholen. Daher wird er in diesen Fällen einfach per Programm auf das Spielfeld zurück katapultiert. Und mit den letzten beiden Zeilen kann ich das Programm einfach anhalten, um einen Screenshot zu erstellen.

Jeff Thompson schlägt als vertiefende Lektüre neben dem 6. Kapitel von Daniel Shiffmans« »The Nature of Code« die Reihe »Understanding Steering Behaviors« von Fernando Bevilacqua (neun Beiträge) und den Aufsatz »Introduction to Steering Behaviours« von Juan Belon Perez vor. Beide führen auch tiefer in das Thema »Spieleprogrammierung und Künstliche Intelligenz« ein.

Ich werde später darauf zurückkommen. Aber erst einmal werde ich in einem nächsten Beitrag das Beispielprogramm auf ein solides, obhektorientiertes Fundament stellen. Dazu möchte ich – in Anlehnung an TigerJythons GameGrid-Bibliothek und an Pygame Zero – eine Klasse Actor implementieren, von der sowohl der Spieler wie auch die anderen Spielelemente (NPCs: non playable characters) erben. Still digging!

(Kommentieren)