SardJump un DoodleJump en python

Gameplay SardJump Projets

DoodleJump est un jeu intemporel datant d’une dizaine d’années. Sardoche est un streamer professionnel. On a décidé de relier les deux en un seul et unique jeu extraordinaire.

Introduction

La création du jeu se fait en trois grandes étapes :

  1. Création de la fenêtre
  2. Création des objets
  3. Lancement du jeu

Création de la fenêtre

Initialisation des modules et du jeu

import pygame
from pygame.locals import *
import sys
import random

WHITE = (255, 255, 255)

class SardJump (object):
    def __init__(self):
      return

On importe le module pygame ainsi que d’autres modules basiques tels que random et sys, puis on défini la class SardJump dans laquelle on définira les fonctions.

Création de la fenêtre et choix des dimensions. 

 def __init__(self):
        self.screen = pygame.display.set_mode((800, 600))
 def run(self):
        global score
        clock = pygame.time.Clock()
        self.generatePlatforms()
        while True:
            self.screen.fill(WHITE)
            self.screen.blit(self.background,(0,0))
            FONT = pygame.font.Font('assets/fonts/Optimus.otf', 30)
            text = FONT.render("Score : " + str(score),False,(255,255,255)).convert_alpha()
            clock.tick(60)

            for event in pygame.event.get():
                if event.type == QUIT:
                    sys.exit()

On gère l’affichage et la taille de l’écran avec « self.screen = pygame.display.set_mode((800, 600)) », on gère ce qui est affiché tant que l’écran et actif et on utilise la fonction « pygame.event.get() » pour fermer l’écran.

Création des objets

Charger les images dans le jeu

def __init__(self):
        pygame.font.init()
        self.screen = pygame.display.set_mode((800, 600))
        self.playerRight_1 = pygame.image.load("assets/right_1.png").convert_alpha()
        self.playerRight = pygame.image.load("assets/right.png").convert_alpha()
        self.playerLeft = pygame.image.load("assets/left.png").convert_alpha()
        self.playerLeft_1 = pygame.image.load("assets/left_1.png").convert_alpha()
        self.plateform = pygame.image.load("assets/plateform.png").convert_alpha()
        self.background = pygame.image.load("assets/bg.png").convert()

Tout d’abord, pour commencer on importe les images en indiquant leur chemin d’accès.

Définition des variables nécessaires au bon fonctionnement du jeu

        self.cameray = 0
        self.playerx = 400
        self.playery = 400
        self.xmovement = 0
        self.jump = 0
        self.direction = 0
        self.gravity = 0
        
        self.platforms = [[400, 500]]
        self.score = 0

On crée dans la fonction __init__ les variables nécessaires au fonctionnement du jeu, donc, le suivi de la caméra, les positions du joueur, les sauts automatiques, la gravité, la position des plateformes et enfin le score.

Système de mouvement.

def updatePlayer(self):
        global score
        if self.playerx > 850:
            self.playerx = -50
        elif self.playerx < -50:
            self.playerx = 850
        self.playerx += self.xmovement
        if self.playery - self.cameray <= 200:
            self.cameray -= 10

On crée la fonction « updatePlayer(self) » dans laquelle seront mises toutes les modifications sur le personnage comme la téléportation de droite à gauche.

key = pygame.key.get_pressed()
        if key[K_RIGHT]:
            if self.xmovement < 10:
                self.xmovement += 1
                self.direction = 0
        elif key[K_LEFT]:
            if self.xmovement > -10:
                self.xmovement -= 1
                self.direction = 1

On attribue les touches droite et gauche aux mouvements du personnage.

if not self.jump:
            self.playery += self.gravity
            self.gravity += 1
        elif self.jump:
            self.playery -= self.jump
            self.jump -= 1

Cette partie de la fonction updatePlayer(self) permet de créer une gravité donc lorsque le personnage ne saute pas il tombe, mais le problème et qu’il faut qu’il y ai un point de collision pour sauter dessus. C’est la qu’on va créer les fonctions en lien avec les plateformes.

Création des plateformes

def generatePlatforms(self):
y = 700
        while y > -100:
            x = random.randint(0, 900)
            self.platforms.append((x, y))
            y -= 50

def drawPlatforms(self):
        for plat in self.platforms:
            regenerate = self.platforms[1][1] - self.cameray
            if regenerate > 600:
                self.platforms.append(
                    (random.randint(0, 700), self.platforms[-1][1] - 50))
                self.platforms.pop(0)
            self.screen.blit(
                    self.plateform, (plat[0], plat[1] - self.cameray))

On génère aléatoirement les plateformes avant de les afficher.

def updatePlatforms(self):
        for p in self.platforms:
            rect = pygame.Rect( p[0], p[1], self.plateform.get_width() - 10, self.plateform.get_height())
            player = pygame.Rect(self.playerx, self.playery, self.playerRight.get_width() - 10, self.playerRight.get_height())
            if rect.colliderect(player) and self.gravity and self.playery < (p[1] - self . cameray):
                self.jump = 15
                self.gravity = 0

On crée un effet collision avec le personnage et les plateformes qui lui permettra de sauter dessus sans tomber.

Système de score et mort

        if self.playery - self.cameray <= 200:
            self.cameray -= 10
            score += 1

Le score est calculé en fonction de l’avancement dans la partie. Lorsque la caméra monte, le score augmente également.

            FONT = pygame.font.Font('assets/fonts/Optimus.otf', 30)
            text = FONT.render("Score : " + str(score),False,(255,255,255)).convert_alpha()
    		
      		self.screen.blit(text, (550, 50))

On crée le texte du score dans la boucle du jeu et on ne l’affiche qu’après la création et l’affichage des autres éléments (fond, plateformes et personnage) afin que celui-ci soit au premier plan.

Lancement du jeu

self.drawPlatforms()
self.updatePlatforms()
self.updatePlayer()
self.screen.blit(text, (550, 50))
pygame.display.flip()
pygame.display.set_caption("SardJump")

On appelle toutes les fonctions dans la fonction run puis on lance le jeu avec SardJump().run().

Conclusion 

Pour pouvoir jouer à cette version du jeu SardJump, téléchargez le code par l’intermédiaire du lien ci-dessous. Les commandes sont assez intuitives : les flèches gauche/droite pour se déplacer, et les flèches haut/bas pour changer de skin de plateforme. Les paliers de skins de personnage sont à 1.000 et 10.000 points.
Amusez-vous bien !

SardJumpTélécharger SardJump 1.0 Alpha