Mijn zoon speelt altijd diverse games. In deze digitale wereld waarin we leven, zijn spellen zoals Minecraft, Fortnite en Among Us nu een vast onderdeel van de jeugdcultuur. Maar mijn zoon, hij is altijd geïntrigeerd geweest door de klassiekers. En een van zijn favorieten is ongetwijfeld het klassieke Snake-spel.

In plaats van hem gewoon het spel te laten spelen, dacht ik: waarom maken we het niet zelf? Dus ik dook in de magische wereld van Python-programmering, en met behulp van een paar bibliotheken zoals pygame, time en random, hebben we onze eigen versie van het spel gecreëerd. Hier is ons verhaal.

Python is een van de meest toegankelijke programmeertalen die er zijn. Het is gemakkelijk te leren, leesbaar en heeft een schat aan bibliotheken die het mogelijk maken om vrijwel alles te doen wat je maar kunt bedenken. Een van de dingen die Python zo geweldig maakt voor beginners en jonge programmeurs, is de mogelijkheid om interactieve spelletjes te maken.

Het creëren van het Snake-spel was een spannend proces, vol met uitdagingen, maar ook vol met plezier. We gebruikten Pygame, een set van Python modules die ontworpen zijn voor het schrijven van videospellen. Pygame voegt functionaliteit bovenop de uitstekende SDL-bibliotheek door game-gerelateerde taken te automatiseren, en stelt ons in staat om spellen te maken met uitstekende graphics en geluidseffecten.

De time bibliotheek is gebruikt om de controle over tijd in Python te hebben. We hebben het gebruikt om de snelheid van de slang te beheren en om het spel te vertragen wanneer nodig. Zoals de naam al doet vermoeden, stelt de random bibliotheek ons in staat om willekeurige getallen te genereren. In het Snake-spel gebruiken we dit om het voedsel voor de slang willekeurig op het scherm te plaatsen.

Het was een hele leuk ervaring om samen met hem dit spel te creëren. Niet alleen was het een plezier om te zien hoe onze eigen versie van Snake tot leven kwam op het scherm, maar het was ook een geweldige manier om mijn zoon de basis van programmeren te leren. De vreugde op zijn gezicht toen hij voor het eerst de door ons gecreëerde slang zag bewegen en groeien, is onbetaalbaar.

Het leren van programmeren kan een intimiderende taak zijn, maar projecten zoals deze maken het proces leuk en lonend. Mijn zoon en ik kijken al uit naar ons volgende project!

In de wereld van vandaag, waar technologie in elk aspect van ons leven is doorgedrongen, is het leren van vaardigheden zoals programmeren steeds belangrijker. En als je deze vaardigheden op een leuke en interactieve manier kunt leren, zoals het maken van je eigen spel, waarom zou je dat dan niet doen?

Ik hoop dat ons verhaal andere ouders en kinderen zal inspireren om het programmeren te ontdekken en hun eigen projecten te starten. Wie weet, misschien creëer je wel het volgende grote computerspel!

import pygame
import time
import random

pygame.init()

# Kleuren
wit = (255, 255, 255)
zwart = (0, 0, 0)
rood = (213, 50, 80)
groen = (0, 255, 0)
blauw = (50, 153, 213)

# Breedte en hoogte van het scherm
scherm_breedte = 800
scherm_hoogte = 600

# Maak het scherm aan
scherm = pygame.display.set_mode((scherm_breedte, scherm_hoogte))
pygame.display.set_caption('Snake')

kloksnelheid = pygame.time.Clock()

blok_grootte = 10
snelheid = 15

font = pygame.font.SysFont(None, 25)

def bericht(msg, kleur):
    tekst = font.render(msg, True, kleur)
    scherm.blit(tekst, [scherm_breedte / 6, scherm_hoogte / 3])


def snake(blok_grootte, lijst):
    for x in lijst:
        pygame.draw.rect(scherm, groen, [x[0], x[1], blok_grootte, blok_grootte])

def gameLoop():
    game_over = False
    game_sluit = False

    # Startpositie van de slang
    x1 = scherm_breedte / 2
    y1 = scherm_hoogte / 2

    # Verandering van positie
    x1_verandering = 0
    y1_verandering = 0

    # Lijst met alle blokken van de slang
    slang_lijst = []
    lengte_van_slang = 1

    # Startpositie van het voedsel
    voedsel_x = round(random.randrange(0, scherm_breedte - blok_grootte) / 10.0) * 10.0
    voedsel_y = round(random.randrange(0, scherm_hoogte - blok_grootte) / 10.0) * 10.0

    while not game_over:

        while game_sluit == True:
            scherm.fill(zwart)
            bericht("Je hebt verloren! Druk Q om af te sluiten of C om opnieuw te spelen", rood)
            pygame.display.update()

            for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_q:
                        game_over = True
                        game_sluit = False
                    if event.key == pygame.K_c:
                        gameLoop()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                game_over = True
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    x1_verandering = -blok_grootte
                    y1_verandering = 0
                elif event.key == pygame.K_RIGHT:
                    x1_verandering = blok_grootte
                    y1_verandering = 0
                elif event.key == pygame.K_UP:
                    y1_verandering = -blok_grootte
                    x1_verandering = 0
                elif event.key == pygame.K_DOWN:
                    y1_verandering = blok_grootte
                    x1_verandering = 0

        # Controleer of de slang buiten het scherm gaat
        if x1 >= scherm_breedte or x1 < 0 or y1 >= scherm_hoogte or y1 < 0:
            game_sluit = True

        # Update de positie van de slang
        x1 += x1_verandering
        y1 += y1_verandering

        scherm.fill(zwart)
        pygame.draw.rect(scherm, rood, [voedsel_x, voedsel_y, blok_grootte, blok_grootte])

        slang_kop = []
        slang_kop.append(x1)
        slang_kop.append(y1)
        slang_lijst.append(slang_kop)

        # Verwijder de oudste blok als de lengte van de slang groter is dan de opgegeven lengte
        if len(slang_lijst) > lengte_van_slang:
            del slang_lijst[0]

        for x in slang_lijst[:-1]:
            if x == slang_kop:
                game_sluit = True

        snake(blok_grootte, slang_lijst)
        pygame.display.update()

        # Controleer of de slang het voedsel heeft gegeten
        if x1 == voedsel_x and y1 == voedsel_y:
            voedsel_x = round(random.randrange(0, scherm_breedte - blok_grootte) / 10.0) * 10.0
            voedsel_y = round(random.randrange(0, scherm_hoogte - blok_grootte) / 10.0) * 10.0
            lengte_van_slang += 1

        kloksnelheid.tick(snelheid)

    pygame.quit()
    quit()

gameLoop()