Na het geweldige avontuur van het creëren van ons eigen Snake-spel, besloten mijn zoon en ik om nog een stap verder te gaan. Onze volgende uitdaging? Het klassieke arcade-spel, Pong. Net als Snake is Pong een van die tijdloze klassiekers die eenvoudig maar ongelooflijk verslavend zijn. En deze keer hebben we een nieuwe Python-bibliotheek verkend: Turtle.

Pong, uitgebracht door Atari in 1972, wordt vaak beschouwd als het eerste commercieel succesvolle videogame. Het spel is een simpele simulatie van tafeltennis. Spelers besturen peddels (verticale balken) die ze op en neer kunnen bewegen aan de zijkanten van het scherm om een bal terug te kaatsen. Het doel is simpel: stuiter de bal naar de tegenstander zonder dat hij hem kan terugkaatsen. Als de bal jouw kant van het scherm raakt, krijgt de tegenstander een punt.

Voor dit project hebben we gebruik gemaakt van de Turtle-bibliotheek in Python. Turtle is een ingebouwde grafische module in Python. Het gebruikt een paneel en pen om beelden te creëren. Wat Turtle zo bijzonder maakt, is dat het in staat is om complexe beelden te creëren met behulp van een paar simpele bewerkingen. Dit maakt het een perfecte keuze voor het creëren van Pong.

In ons Pong-spel hebben we de Turtle-bibliotheek gebruikt om de peddels en de bal te tekenen, en om ze te laten bewegen. Met slechts een paar regels code konden we de beweging van de bal en de peddels simuleren, en de bal laten stuiteren wanneer hij een peddel raakt.

Het hele proces was een geweldige ervaring. Het was zowel een les in programmeervaardigheden als een reis naar de vroege dagen van videogames. Mijn zoon was enthousiast om een spel te spelen dat hij zelf had gemaakt, en ik was blij om hem nog een aspect van programmeren te leren.

Programmeren is niet alleen een nuttige vaardigheid, maar kan ook een bron van plezier en creativiteit zijn. Door games zoals Snake en Pong te creëren, kunnen kinderen en volwassenen de wereld van programmeren op een leuke en interactieve manier verkennen. En wie weet, misschien is het volgende project wel een geheel nieuwe game die de wereld zal veroveren!

import turtle

# het opzetten van het venster
wn = turtle.Screen()
wn.title("Pong")
wn.bgcolor("black")
wn.setup(width=600, height=400)

# opzetten van de paddle A
paddle_a = turtle.Turtle()
paddle_a.speed(0)
paddle_a.shape("square")
paddle_a.color("white")
paddle_a.shapesize(stretch_wid=5, stretch_len=1)
paddle_a.penup()
paddle_a.goto(-250, 0)

# opzetten van de paddle B
paddle_b = turtle.Turtle()
paddle_b.speed(0)
paddle_b.shape("square")
paddle_b.color("white")
paddle_b.shapesize(stretch_wid=5, stretch_len=1)
paddle_b.penup()
paddle_b.goto(250, 0)

# opzetten van de bal
ball = turtle.Turtle()
ball.speed(40)
ball.shape("circle")
ball.color("white")
ball.penup()
ball.goto(0, 0)
ball.dx = 2
ball.dy = -2

# scoreboard
score_a = 0
score_b = 0
scoreboard = turtle.Turtle()
scoreboard.speed(0)
scoreboard.color("white")
scoreboard.penup()
scoreboard.hideturtle()
scoreboard.goto(0, 170)
scoreboard.write("Speler A: {}  Speler B: {}".format(score_a, score_b), align="center", font=("Courier", 16, "normal"))

# bewegen van paddle A
def paddle_a_up():
    y = paddle_a.ycor()
    y += 20
    paddle_a.sety(y)

def paddle_a_down():
    y = paddle_a.ycor()
    y -= 20
    paddle_a.sety(y)

# bewegen van paddle B
def paddle_b_up():
    y = paddle_b.ycor()
    y += 20
    paddle_b.sety(y)

def paddle_b_down():
    y = paddle_b.ycor()
    y -= 20
    paddle_b.sety(y)

# toetsenbord bindings
wn.listen()
wn.onkeypress(paddle_a_up, "w")
wn.onkeypress(paddle_a_down, "s")
wn.onkeypress(paddle_b_up, "Up")
wn.onkeypress(paddle_b_down, "Down")

# main game loop
while True:
    wn.update()

    # beweeg de bal
    ball.setx(ball.xcor() + ball.dx)
    ball.sety(ball.ycor() + ball.dy)

    # grenzen controleren
    if ball.ycor() > 190 or ball.ycor() < -190:
        ball.dy *= -1

    # controleer of de bal de paddle raakt
    if ball.xcor() < -240 and ball.ycor() < paddle_a.ycor() + 50 and ball.ycor() > paddle_a.ycor() - 50:
        ball.dx *= -1
        score_a += 1
        scoreboard.clear()
        scoreboard.write("Speler A: {}  Speler B: {}".format(score_a, score_b), align="center", font=("Courier", 16, "normal"))

    if ball.xcor() > 240 and ball.ycor() < paddle_b.ycor() + 50 and ball.ycor() > paddle_b.ycor() - 50:
        ball.dx *= -1
        score_b += 1
        scoreboard.clear()
        scoreboard.write("Speler A: {}  Speler B: {}".format(score_a, score_b), align="center", font=("Courier", 16, "normal"))

    # controleer of een speler heeft gewonnen
    if score_a == 5:
        scoreboard.clear()
        scoreboard.write("Speler A wint!", align="center", font=("Courier", 16, "normal"))
        break

    if score_b == 5:
        scoreboard.clear()
        scoreboard.write("Speler B wint!", align="center", font=("Courier", 16, "normal"))
        break