# data[].attributes.headline
Etat d'avancement en block du projet (import du projet disponible dans le post précédent)

# data[].attributes.subject
Etat d'avancement en block du projet (import du projet disponible dans le post précédent)

# data[].attributes.headline
Me 19/06 : Rattrapage Alban (click bouton son + couleur)

# data[].attributes.subject
Me 19/06 : Rattrapage Alban (click bouton son + couleur)

# data[].attributes.headline
Me 12/06 : Animation des boutons du Simon

# data[].attributes.subject
Me 12/06 : Animation des boutons du Simon

# data[].attributes.body
Les assets pour le jeu peuvent être télécharger au lien suivant : https://drive.google.com/drive/folders/1HHSy4peTJTwg9Zm0qa5TKAPu82HCJAC_?usp=drive_link

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
from random import randint
import math

WIDTH = 800
HEIGHT = 650


bouttons = [Actor('redunlit', bottomright=(400,300)),Actor('greenunlit', bottomleft=(400,300)),
           Actor('blueunlit', topright=(400,300)),Actor('yellowunlit', topleft=(400,300))]

for boutton in bouttons:
    boutton.state = False

imagesAllumees = ['redlit','greenlit','bluelit','yellowlit']
imagesEteintes = ['redunlit','greenunlit','blueunlit','yellowunlit']

sequenceBoutons = []
entreesJoueur = []
DELAI_BOUCLE = 80
score = 0
jeuCommence = False
signalScore = False
animationEnCours = False
positionJeu = 0
delaiJeu = -1

def draw():
    screen.clear()
    screen.fill((30, 10, 30))
    for boutton in bouttons:
        boutton.draw()
    afficher_statut_jeu()
    affiche_score_final()



boutonPlay = Actor("play", (400,580))

def afficher_statut_jeu():
    if jeuCommence:
        screen.draw.text("Score : "+str(score), (325, 510), owidth=0.5, ocolor=(255,255,255), color=(255,128,0), fontsize=45)
    else:
        boutonPlay.draw()
        screen.draw.text("Click",(365, 565), owidth=0.5, ocolor=(255,255,255), color=(255,128,0), fontsize=40)

def affiche_score_final():
    if score > 0 :
        screen.draw.text("Score : "+str(score) (250, 20), owidth=0.5, ocolor=(255,255,255), color=(255,128,0), fontsize=60)
    else :
        screen.draw.text("Appuyez sur Jouer pour commencer", (170, 30), owidth=0.5, ocolor=(255,255,255), color=(255,128,0), fontsize=45)


def update():
    pass

# data[].attributes.headline
Me 24/04 : Intro à App inventor avec l'exo du Piano (ci-dessous fichier .IAI pour ceux qui voudraient tester l'exo fait sur App inventor)

# data[].attributes.subject
Me 24/04 : Intro à App inventor avec l'exo du Piano (ci-dessous fichier .IAI pour ceux qui voudraient tester l'exo fait sur App inventor)

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
import random

carte_trouve = Actor("checkmark")
carte_nontrouve = Actor("card_back",(50,50))
carte_nontrouve.topleft = (0,0)

colonnes = 4
rangees = 3
taille_image = 200

IMAGES = ["im"+str(i+1) for i in range(6)]*2
random.shuffle(IMAGES)


#2 listes

# liste_carte_trouvees => contient les coordonnes des cartes trouv��es
liste_carte_trouvees = []

# liste_carte_selectionne => contient les coords des cartes liste_carte_selectionneionn��es(revel��s)
liste_carte_selectionne = []


#contient les cartes 1 �� 6
board = []
for x in range(rangees):
    new_row = []
    for y in range(colonnes):
        image_name = IMAGES.pop()
        temp = Actor(image_name, (y*taille_image, x*taille_image))
        temp.image_name = image_name
        temp.topleft = (y*taille_image, x*taille_image)
        new_row.append(temp)
    board.append(new_row)


def draw():
    screen.clear()
    for x in range(rangees):
        for y in range(colonnes):
            if (x,y) in liste_carte_trouvees:
                carte_trouve.topleft = (y*taille_image, x*taille_image)
                carte_trouve.draw()
            elif (x,y) in liste_carte_selectionne :
                board[x][y].draw()
            else:
                carte_nontrouve.topleft = (y*taille_image,x*taille_image)
                carte_nontrouve.draw()

def find_position(pos):
    y, x = pos
    result = x // taille_image, y // taille_image
    return result


def on_mouse_down(pos, button):
    if len(liste_carte_selectionne) <3:
        if button == button.LEFT:
            coords = find_position(pos)
            if coords not in liste_carte_selectionne:
                liste_carte_selectionne.append(coords)
            print(liste_carte_selectionne)
            if len(liste_carte_selectionne)== 2:
                (x1 , y1) , (x2, y2) = liste_carte_selectionne
                if  board[x1][y1].image_name == board[x2][y2].image_name :
                    liste_carte_trouvees.extend(liste_carte_selectionne)
                    print(liste_carte_trouvees)
                else:
                    clock.schedule_unique(next_turn,1)
                    print(liste_carte_selectionne)
    else:
        liste_carte_selectionne.clear()

def next_turn():
    liste_carte_selectionne.clear()

# data[].attributes.headline
Me 10/04 : Memory Game pt4 (beug x,y corrigé)

# data[].attributes.subject
Me 10/04 : Memory Game pt4 (beug x,y corrigé)

# data[].attributes.attachment_link.readable_text
import random

carte_trouve = Actor("checkmark")
carte_nontrouve = Actor("card_back",(50,50))
carte_nontrouve.topleft = (0,0)

colonnes = 4
rangees = 3
taille_image = 200

IMAGES = ["im"+str(i+1) for i in range(6)]*2
random.shuffle(IMAGES)

print(IMAGES)


#2 listes

# ignores => contient les coordonnes des cartes trouv��es
ignores = []

# select => contient les coords des cartes selectionn��es(revel��s)
select = []


#contient les cartes 1 �� 6
board = []

for x in range(rangees):
    new_row = []
    for y in range(colonnes):
        image_name = IMAGES.pop()
        temp = Actor(image_name, (y*taille_image, x*taille_image))
        temp.image_name = image_name
        temp.topleft = (y*taille_image, x*taille_image)
        new_row.append(temp)
    board.append(new_row)


def draw():
    screen.clear()
    for x in range(rangees):
        for y in range(colonnes):
            if (x,y) in ignores:
                carte_trouve.topleft = (y*taille_image, x*taille_image)
                carte_trouve.draw()
            elif (x,y) in select :
                board[x][y].draw()
            else:
                carte_nontrouve.topleft = (y*taille_image,x*taille_image)
                carte_nontrouve.draw()
'''
inverser le x et y

'''

def find_position(pos):
    y, x = pos
    result = x // taille_image, y // taille_image
    return result


def on_mouse_down(pos, button):
    #Clique sur une carte , elle se releve (numero) => mettre ces coordonnes dans select
    #Empecher + de 2 cartes par tour => Taille de select > 2 , alors pas de click possible
    #Pas clickable si la carte est dans la liste ignores

    if button == button.LEFT:
        coords = find_position(pos)
        select.append(coords)
    else :
        pass

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
import random

carte_trouve = Actor("checkmark")
carte_trouve.topleft = (0,0)
carte_nontrouve = Actor("card_back")
carte_nontrouve.topleft = (0,0)

colonnes = 4
rangees = 3
taille_image = 200

images = ["im"+str(i+1) for i in range(6)]*2
random.shuffle(images)

ignores = [(1,2)]
select = [(2,0)]

print(images)

board = []
for x in range(rangees):
    new_row = []
    for y in range(colonnes):
        image_name = images.pop()
        temp = Actor(image_name, (y*taille_image, x*taille_image))
        temp.image_name = image_name
        temp.topleft = (y*taille_image, x*taille_image)
        new_row.append(temp)
    board.append(new_row)


def draw():
    screen.clear()
    for x in range(rangees):
        for y in range(colonnes):
            if (x,y) in ignores:
                carte_trouve.top_left = (y*taille_image, x*taille_image)
                carte_trouve.draw()
            elif (x,y) in select :
                board[x][y].draw()
            else:
                carte_nontrouve.topleft = (y*taille_image,x*taille_image)
                carte_nontrouve.draw()


def find_position(maposition):
    print(maposition)


def on_mouse_down(pos, button):
    if button == button.LEFT:
        print('click droit')
        find_position(pos)
    else :
        print('click gauche')


def update():
    pass

# data[].attributes.attachment_link.readable_text
# Ecrit ton programme ici ;-)
# Write your code here :-)
import random

carte_trouve = Actor("checkmark")
carte_nontrouve = Actor("card_back",(50,50))
carte_nontrouve.topleft = (0,0)

colonnes = 4
rangees = 3
taille_image = 200

images = ["im"+str(i+1) for i in range(6)]*2
random.shuffle(images)

ignores = [(0,0),(1,0)]


board = []
for x in range(rangees):
    new_row = []
    for y in range(colonnes):
        image_name = images.pop()
        temp = Actor(image_name, (y*taille_image, x*taille_image))
        temp.image_name = image_name
        temp.topleft = (y*taille_image, x*taille_image)
        new_row.append(temp)
    board.append(new_row)


def draw():
    for x in range(rangees):
        for y in range(colonnes):
            if (x,y) in ignores:
                carte_nontrouve.topleft = (x*taille_image,y*taille_image)
                carte_nontrouve.draw()
            else:
                board[x][y].draw()




def update():
    pass

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
import random

carte_trouve = Actor("checkmark")
carte_nontrouve = Actor("card_back",(50,50))
carte_nontrouve.topleft = (0,0)

colonne = 4
rangee = 3
taille_image = 200

images = ["im"+str(i+1) for i in range(6)]*2
print(images)
random.shuffle(images)
print(images)



def draw():
    carte_trouve.draw()

# data[].attributes.headline
Me 13/03 : Rappel + ajout module supplémentaire ancien code

# data[].attributes.subject
Me 13/03 : Rappel + ajout module supplémentaire ancien code

# data[].attributes.headline
Me 21/02 : Fin survive Dino (code avec qlq petits ajouts de ma part)

# data[].attributes.subject
Me 21/02 : Fin survive Dino (code avec qlq petits ajouts de ma part)

# data[].attributes.attachment_link.readable_text
import random

WIDTH = 1066
HEIGHT = 600

vitesse = 3

dino = Actor('dino',(WIDTH/2,HEIGHT-50))

dino.alive = True

dino.score = 0


mt1 = Actor('meteore',(WIDTH/2, 50))
mt1.angle = 45

mt2 = Actor('meteore',(360, 50))
mt2.y = -100
mt2.angle = 45

def affichageRestart():
    screen.clear()
    screen.blit('prehistoire',(0,0))
    screen.blit('lose',(425,200))

    dino.draw()
    mt1.draw()
    mt2.draw()

    screen.draw.text("Score : "+
        str(dino.score), (425,190),
        color='orange',
        fontsize=40,
        shadow=(1, 1))
    screen.draw.text("To restart the game, press letter a on keyboard !",
        (160,325),
        color='white',
        fontsize=40,
        shadow=(1, 1))


def draw():

    if dino.alive:
        screen.clear()
        screen.blit('prehistoire',(0,0))
        screen.draw.text(
        str(dino.score),
        color='orange',
        midtop=(WIDTH // 2, 10),
        fontsize=70,
        shadow=(1, 1))
        dino.draw()
        mt1.draw()
        mt2.draw()
    else:
        affichageRestart()





def update():
    global vitesse

    if dino.alive and dino.score < 2:
        mt1.y += vitesse + dino.score/8
    elif dino.alive and dino.score >= 2:
        mt1.y += vitesse + dino.score/8
        mt2.y += vitesse + dino.score/5

    if mt1.y > HEIGHT :
        mt1.y = random.randint(-200,-100)
        mt1.x = random.randint(10,WIDTH-10)
        dino.score += 1

    if mt2.y > HEIGHT :
        mt2.y = random.randint(-200,-100)
        mt2.x = random.randint(10,WIDTH-10)
        dino.score += 1

    if mt1.colliderect(dino) or mt2.colliderect(dino):
        dino.image = 'dino_death'
        dino.alive = False

###### rajouter par le prof apres le cours, j'expliquerais la prochaine fois4
    if not dino.alive and keyboard.a :
        reset()



def reset():
    global vitesse

    dino.score = 0
    dino.image = 'dino'
    dino.pos = (WIDTH/2,HEIGHT-50)
    vitesse = 3
    mt1.y = -100
    mt2.y = -100
    dino.alive = True



def on_mouse_move(pos):
    if dino.alive:
        dino.x = pos[0]

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
import random

WIDTH = 1066
HEIGHT = 600

vitesse = 4

dino = Actor('dino',(WIDTH/2,HEIGHT-50))
dino.alive = True
dino.score = 0

mt = Actor('meteore',(WIDTH/2, 50))

mt2 = Actor('meteore',(WIDTH/2, 50))


def draw():
    screen.clear()
    screen.blit('prehistoire',(0,0))
    dino.draw()

###== meteore 1 =====
    mt.draw()
    mt.angle = 45

###== meteore 2 =====
    mt2.draw()
    mt2.y = -100
    mt2.angle = 45

    screen.draw.text(
        str(dino.score),
        color='orange',
        midtop=(WIDTH // 2, 10),
        fontsize=70,
        shadow=(1, 1))


def update():
    global vitesse

    if dino.alive:
        mt.y += vitesse

    if mt.y > HEIGHT :
        mt.y = -100
        mt.x = random.randint(10,WIDTH-10)
        dino.score += 1

    if mt.colliderect(dino):
        dino.image = 'dino_death'
        dino.alive = False


def on_mouse_move(pos):
    if dino.alive:
        dino.x = pos[0]

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
import random

WIDTH = 1066 #950
HEIGHT = 600 #535

dino = Actor('dino',(WIDTH/2,HEIGHT-50))
mt = Actor('meteore',(WIDTH/2, 50))
vitesse = 4
dino.score = 0

def draw():
    screen.clear()
    screen.blit('prehistoire',(0,0))
    dino.draw()
    mt.draw()
    mt.angle = 45
    screen.draw.text(
        str(dino.score),
        color='white',
        midtop=(WIDTH // 2, 10),
        fontsize=70,
        shadow=(1, 1))

def update():
    global vitesse

    mt.y += vitesse

    if mt.y > HEIGHT:
        mt.y = -100
        mt.x = random.randint(10,WIDTH-10)
        dino.score += 1


def on_mouse_move(pos):
    dino.x = pos[0]

# data[].attributes.headline
Me 27/01 : Snake pt3 : nourriture + grandir du serpent

# data[].attributes.subject
Me 27/01 : Snake pt3 : nourriture + grandir du serpent

# data[].attributes.attachment_link.readable_text
import random

cell_size = 15
grid_x_count = 20
grid_y_count = 15

WIDTH = cell_size * 20
HEIGHT = cell_size * 15

snake_segments = [{'x':2,'y':0},{'x':1,'y':0},{'x':0,'y':0}]


foods = [{'x':random.randint(0,grid_x_count-1),'y':random.randint(0,grid_y_count-1)}]

timer = 0

direction_queue = ['right']

def draw():
    screen.fill((0,0,0))

    screen.draw.filled_rect(Rect(0,0,grid_x_count*cell_size,
    grid_y_count *cell_size),color=("green"))

    for segment in snake_segments:
        screen.draw.filled_rect(Rect(segment['x']*cell_size,
        segment['y']*cell_size,cell_size-1,cell_size-1),color=("red"))

    screen.draw.filled_rect(Rect(foods[0]['x']*cell_size,foods[0]['y']*cell_size,
    cell_size-1,cell_size-1),color=("blue"))

def move_food():
    global foods
    foods = [{'x':random.randint(0,grid_x_count-1),'y':random.randint(0,grid_y_count-1)}]

def update():
    global timer,foods

    timer += 0.02

    if len(direction_queue) > 1:
        direction_queue.pop(0)

    if timer > 0.15:
        timer = 0

        next_x_position = snake_segments[0]['x']
        next_y_position = snake_segments[0]['y']

        if direction_queue[0] == 'right':
            next_x_position += 1
            if next_x_position >= grid_x_count:
                next_x_position = 0

        elif direction_queue[0] == 'left':
            next_x_position -= 1
            if next_x_position < 0:
                next_x_position = grid_x_count-1

        elif direction_queue[0] == 'down':
            next_y_position += 1
            if next_y_position >= grid_y_count:
                next_y_position = 0

        elif direction_queue[0] == 'up':
            next_y_position -= 1
            if next_y_position < 0 :
                next_y_position = grid_y_count-1

        snake_segments.insert(0, {'x': next_x_position, 'y': next_y_position})


        if snake_segments[0]['x']==foods[0]['x'] and snake_segments[0]['y']==foods[0]['y']:
            move_food()
            #rien
        else:
            snake_segments.pop()





def on_key_down(key):
    if (key == keys.RIGHT
    and direction_queue[-1] != 'right'
    and direction_queue[-1] != 'left'):
        direction_queue.append('right')

    elif (key == keys.LEFT
    and direction_queue[-1] != 'left'
    and direction_queue[-1] != 'right'):
        direction_queue.append('left')

    elif (key == keys.DOWN
    and direction_queue[-1] != 'down'
    and direction_queue[-1] != 'up'):
        direction_queue.append('down')

    elif (key == keys.UP
    and direction_queue[-1] != 'up'
    and direction_queue[-1] != 'down'):
        direction_queue.append('up')

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
cell_size = 15

WIDTH = cell_size * 20
HEIGHT = cell_size * 15

snake_segments = [{'x':2,'y':0},{'x':1,'y':0},{'x':0,'y':0}]

timer = 0

direction = "bas"

def draw():
    screen.fill((0,0,0))
    grid_x_count = 20
    grid_y_count = 15

    screen.draw.filled_rect(Rect(0,0,grid_x_count*cell_size,grid_y_count *cell_size),color=("green"))

    for segment in snake_segments:
        screen.draw.filled_rect(Rect(segment['x']*cell_size,segment['y']*cell_size,cell_size-1,cell_size-1),color=("red"))


def update(tempsEcoule):
    global timer

    timer += tempsEcoule

    if timer > 0.999:
        timer = 0
        next_x_position = snake_segments[0]['x']
        next_y_position = snake_segments[0]['y']

        if direction == "droite":
            next_x_position += 1
        elif direction == "gauche":
            next_x_position -= 1
        elif direction == "haut":
            next_y_position -= 1
        elif direction == "bas":
            next_y_position += 1

        snake_segments.insert(0,{'x':next_x_position , 'y':next_y_position})
        snake_segments.pop()

def on_key_down(key):
    global direction

    if key == keys.LEFT and direction != "droite" :
        direction = "gauche"
    elif key == keys.RIGHT and direction != "gauche":
        direction = "droite"
    elif key == keys.UP and direction != "bas":
        direction = "haut"
    elif key == keys.DOWN and direction != "haut":
        direction = "bas"

# data[].attributes.headline
Me 10/01 : Snake pt1 : Dessin de la scene et du corps du serpent

# data[].attributes.subject
Me 10/01 : Snake pt1 : Dessin de la scene et du corps du serpent

# data[].attributes.attachment_link.readable_text
# Write your code here :-

cell_size = 15
WIDTH = cell_size * 20
HEIGHT = cell_size * 15

def draw():

    screen.fill((0,0,0))
    grid_x_count = 20
    grid_y_count = 15

    screen.draw.filled_rect(Rect(0,0,grid_x_count*cell_size,grid_y_count *cell_size),color=("green"))

    snake_segments = [{'x':2,'y':0},
                    {'x':1,'y':0},
                    {'x':0,'y':0}]


    for segment in snake_segments:
        screen.draw.filled_rect(Rect(segment['x']*cell_size,segment['y']*cell_size,cell_size-1,cell_size-1),color=("red"))

# data[].attributes.headline
Me 20/12 : ajout d'options dans un jeu précédement créer (son, difficulté, ect)

# data[].attributes.subject
Me 20/12 : ajout d'options dans un jeu précédement créer (son, difficulté, ect)

# data[].attributes.attachment_link.readable_text
import random
from pygame import time as T

WIDTH = 400
HEIGHT = 708

bird = Actor("bird1", (80, 300))
bird.alive = True
bird.score = 0

background = Actor("ville", (201, 355))
gravity = 3.5
speed = 1
fly = 10
top_pipe = Actor("top", (300, 0))
bottom_pipe = Actor("bottom", (300, top_pipe.height + 160))
death_time = 0
last_score = 0

def draw():
    screen.clear()
    background.draw()
    bird.draw()
    top_pipe.draw()
    bottom_pipe.draw()
    screen.draw.text(
        str(bird.score),
        color='white',
        midtop=(WIDTH // 2, 10),
        fontsize=70,
        shadow=(1, 1))


def update_bird():
    global death_time

    if keyboard.space and bird.alive:
        if not bird.y < 20:
            bird.y -= fly

    if bird.alive:
        bird.y += gravity

    if bird.colliderect(top_pipe) or bird.colliderect(bottom_pipe):
        sounds.hit.play()
        bird.alive = False
        bird.x -= 1.5
        death_time = T.get_ticks()

    if bird.y > HEIGHT - 15:
        sounds.splat.play()
        bird.alive = False
        bird.y -= 2
        death_time = T.get_ticks()

def update():
    global death_time

    update_bird()
    update_pipe()

    if not bird.alive:
        if T.get_ticks() - death_time < 2500:
            death()
        else:
            reset()


def reset():
    bird.pos = (80, 300)
    initPipe()
    bird.alive = True
    bird.image = 'bird1'
    background.image = 'ville'
    bird.score = 0



def update_pipe():
    global speed

    if bird.alive:
        top_pipe.x -= speed
        bottom_pipe.x -= speed

    if top_pipe.right < 0:
        initPipe()
        bird.score += 1
        sounds.point.play()
        update_speed()


def update_speed():
    global speed, last_score

    if bird.score > last_score +4:
        speed += 0.6
        last_score = bird.score




def death():
    bird.alive = False
    bird.image = "birddead"
    background.image = "backgrounddead"

def initPipe():
    top_pipe.x = WIDTH
    bottom_pipe.x = WIDTH

    ecart = random.randint(1, 4)

    if ecart == 1:
        top_pipe.pos = (400, -100)
        bottom_pipe.pos = (400, 600)
    elif ecart == 2:
        top_pipe.pos = (400, 100)
        bottom_pipe.pos = (400, 800)
    elif ecart == 3:
        top_pipe.pos = (400, 200)
        bottom_pipe.pos = (400, 900)
    else:
        top_pipe.pos = (400, -50)
        bottom_pipe.pos = (400, 660)

# data[].attributes.headline
Me 13/12 : Gestion du temps dans un jeu (exemple avec flappy bird)

# data[].attributes.subject
Me 13/12 : Gestion du temps dans un jeu (exemple avec flappy bird)

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
import random
from pygame import time as T

WIDTH = 400
HEIGHT = 708

bird = Actor("bird1", (80, 300))
bird.alive = True
bird.score = 0

background = Actor("ville", (201, 355))
gravity = 3.5
speed = 1
fly = 10
top_pipe = Actor("top", (300, 0))
bottom_pipe = Actor("bottom", (300, top_pipe.height + 160))
death_time = 0

def draw():
    screen.clear()
    background.draw()
    bird.draw()
    top_pipe.draw()
    bottom_pipe.draw()
    screen.draw.text(
        str(bird.score),
        color='white',
        midtop=(WIDTH // 2, 10),
        fontsize=70,
        shadow=(1, 1))


def update_bird():
    global death_time

    if keyboard.space and bird.alive:
        if not bird.y < 20:
            bird.y -= fly
    if bird.alive:
        bird.y += gravity
    if bird.colliderect(top_pipe) or bird.colliderect(bottom_pipe):
        bird.alive = False
        bird.x -= 1.5
        death_time = T.get_ticks()

    if bird.y > HEIGHT - 15:
        bird.alive = False
        bird.y -= 2
        death_time = T.get_ticks()

def update():
    global death_time

    update_bird()
    update_pipe()

    if not bird.alive:
        if T.get_ticks() - death_time < 2500:
            death()
        else:
            reset()


def reset():
    bird.pos = (80, 300)
    initPipe()
    bird.alive = True
    bird.image = 'bird1'
    background.image = 'ville'
    bird.score = 0



def update_pipe():
    if bird.alive:
        top_pipe.x -= speed
        bottom_pipe.x -= speed

    if top_pipe.right < 0:
        initPipe()
        bird.score += 1


def death():
    bird.alive = False
    bird.image = "birddead"
    background.image = "backgrounddead"

def initPipe():
    top_pipe.x = WIDTH
    bottom_pipe.x = WIDTH

    ecart = random.randint(1, 4)

    if ecart == 1:
        top_pipe.pos = (400, -100)
        bottom_pipe.pos = (400, 600)
    elif ecart == 2:
        top_pipe.pos = (400, 100)
        bottom_pipe.pos = (400, 800)
    elif ecart == 3:
        top_pipe.pos = (400, 200)
        bottom_pipe.pos = (400, 900)
    else:
        top_pipe.pos = (400, -50)
        bottom_pipe.pos = (400, 660)

# data[].attributes.headline
Me 06/12 : Flappy : cycle de jeu complet terminé

# data[].attributes.subject
Me 06/12 : Flappy : cycle de jeu complet terminé

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
import random, pygame

WIDTH = 400
HEIGHT = 708

bird = Actor("bird1", (80, 300))
bird.alive = True
bird.score = 0

background = Actor("ville", (201, 355))
gravity = 3.5
speed = 1.20
fly = 10
top_pipe = Actor("top", (300, 0))
bottom_pipe = Actor("bottom", (300, top_pipe.height + 160))

def draw():
    screen.clear()
    background.draw()
    bird.draw()
    top_pipe.draw()
    bottom_pipe.draw()
    screen.draw.text(
        str(bird.score),
        color='white',
        midtop=(WIDTH // 2, 10),
        fontsize=70,
        shadow=(1, 1))


def update_bird():
    if keyboard.space and bird.alive:
        if not bird.y < 20:
            bird.y -= fly
    if bird.alive:
        bird.y += gravity
    if bird.colliderect(top_pipe) or bird.colliderect(bottom_pipe):
        death()
        reset()
    if bird.y > HEIGHT - 15:
        death()
        reset()

def reset():
    bird.pos = (80, 300)
    initPipe()
    bird.alive = True
    bird.image = 'bird1'
    background.image = 'ville'
    bird.score = 0


def update():
    update_bird()
    update_pipe()

def update_pipe():
    if bird.alive:
        top_pipe.x -= speed
        bottom_pipe.x -= speed

    if top_pipe.right < 0:
        initPipe()
        bird.score += 1

def death():
    bird.alive = False
    bird.image = "birddead"
    background.image = "backgrounddead"

def initPipe():
    top_pipe.x = WIDTH
    bottom_pipe.x = WIDTH

    ecart = random.randint(1, 4)

    if ecart == 1:
        top_pipe.pos = (400, -100)
        bottom_pipe.pos = (400, 600)
    elif ecart == 2:
        top_pipe.pos = (400, 100)
        bottom_pipe.pos = (400, 800)
    elif ecart == 3:
        top_pipe.pos = (400, 200)
        bottom_pipe.pos = (400, 900)
    else:
        top_pipe.pos = (400, -50)
        bottom_pipe.pos = (400, 660)


"""
        #collision oiseau -> presque ok (restart)
"""

# data[].attributes.headline
Me 29/11 : Gestion des effets de transitions : mort / en vie 

# data[].attributes.subject
Me 29/11 : Gestion des effets de transitions : mort / en vie 

# data[].attributes.attachment_link.readable_text
import random

WIDTH = 400
HEIGHT = 708

bird = Actor("bird1", (80,300))
bird.alive = True
bird.score = 0


background = Actor("ville",(201,355))

gravity = 2
speed = 1


top_pipe = Actor("top",(300,0))
bottom_pipe = Actor("bottom",(300,top_pipe.height+160))

def draw():
    screen.clear()
    background.draw()
    bird.draw()
    top_pipe.draw()
    bottom_pipe.draw()


def update_bird():

    if keyboard.space and bird.alive:
        if not bird.y < 20:
            bird.y -= 10

    if bird.alive:
        bird.y += gravity

    if bird.colliderect(top_pipe) or bird.colliderect(bottom_pipe) :
        death()

    if bird.y > HEIGHT -15:
        death()



def death():
    bird.alive = False
    bird.image = 'birddead'
    background.image = 'backgrounddead'



'''
        #collision oiseau -> presque ok (restart)
'''

def update():
    update_bird()
    if top_pipe.right < 0:
        initPipe()
    top_pipe.x -= speed
    bottom_pipe.x -= speed

   #update_bird()
        #envol (anti gravit������)
        #chute oiseau (gravit������)
        #collision oiseau

def initPipe():
    top_pipe.x = WIDTH
    bottom_pipe.x = WIDTH

    ecart = random.randint(1,4)

    if ecart == 1 :
        top_pipe.pos = (400,-100)
        bottom_pipe.pos = (400,500)
    elif ecart == 2:
        top_pipe.pos = (400,100)
        bottom_pipe.pos = (400,700)
    elif ecart == 3:
        top_pipe.pos = (400,200)
        bottom_pipe.pos = (400,800)
    else:
        top_pipe.pos = (400,-50)
        bottom_pipe.pos = (400,560)


    #update_bird()
        #envol (anti gravit������)
        #chute oiseau (gravit������)
        #collision oiseau


    #update_pipe()
        #Avancement des tuyaux
        #incrementer le score

    #restart
        #changement fond ecran (backgrounddead)
        #changement oiseau
        #score reset
        #oiseau position

# data[].attributes.headline
Me 22/11 : Amelioration du code + Collision tuyaux

# data[].attributes.subject
Me 22/11 : Amelioration du code + Collision tuyaux

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
import random

WIDTH = 400
HEIGHT = 708

bird = Actor("bird1", (80,300))
bird.alive = True
bird.score = 0

gravity = 3.5
speed = 1


top_pipe = Actor("top",(300,0))
bottom_pipe = Actor("bottom",(300,top_pipe.height+160))

def draw():
    screen.blit("background",(0,0))
    bird.draw()
    top_pipe.draw()
    bottom_pipe.draw()


def update_bird():

    if keyboard.space and bird.alive :
        bird.y -= 10

    if bird.alive:
        bird.y += gravity

    if bird.colliderect(top_pipe) or bird.colliderect(bottom_pipe) :
        print("collision tuyau")


def update():
    update_bird()
    if top_pipe.right < 0:
        initPipe()
    top_pipe.x -= speed
    bottom_pipe.x -= speed


   #update_bird()
        #envol (anti gravit��)
        #chute oiseau (gravit��)
        #collision oiseau



def initPipe():
    top_pipe.x = WIDTH
    bottom_pipe.x = WIDTH

    ecart = random.randint(1,4)

    if ecart == 1 :
        top_pipe.pos = (400,-100)
        bottom_pipe.pos = (400,500)
    elif ecart == 2:
        top_pipe.pos = (400,100)
        bottom_pipe.pos = (400,700)
    elif ecart == 3:
        top_pipe.pos = (400,200)
        bottom_pipe.pos = (400,800)
    else:
        top_pipe.pos = (400,-50)
        bottom_pipe.pos = (400,560)


    #update_bird()
        #envol (anti gravit��)
        #chute oiseau (gravit��)
        #collision oiseau


    #update_pipe()
        #Avancement des tuyaux
        #incrementer le score

    #restart
        #changement fond ecran (backgrounddead)
        #changement oiseau
        #score reset
        #oiseau position

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
import random

WIDTH = 400
HEIGHT = 708

bird_1 = Actor("bird1", (80,300))
gravity = 3
speed = 3


top_pipe = Actor("top",(300,0))
bottom_pipe = Actor("bottom",(300,top_pipe.height+160))

def draw():
    screen.blit("background",(0,0))
    bird_1.draw()
    top_pipe.draw()
    bottom_pipe.draw()

def update():
    global gravity,speed

    if top_pipe.right < 0:
        initPipe()
    bird_1.y += gravity

    if keyboard.space:
        bird_1.y -= 6.5

    top_pipe.x -= speed
    bottom_pipe.x -= speed

def initPipe():
    top_pipe.x = WIDTH
    bottom_pipe.x = WIDTH

    ecart = random.randint(1,4)

    if ecart == 1 :
        top_pipe.pos = (400,-100)
        bottom_pipe.pos = (400,500)
    elif ecart == 2:
        top_pipe.pos = (400,100)
        bottom_pipe.pos = (400,700)
    elif ecart == 3:
        top_pipe.pos = (400,200)
        bottom_pipe.pos = (400,800)
    else:
        top_pipe.pos = (400,-50)
        bottom_pipe.pos = (400,560)

# data[].attributes.headline
Pong fin :  Ajout du reboot du jeu apres une défaite 

# data[].attributes.subject
Pong fin :  Ajout du reboot du jeu apres une défaite 

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
import random

WIDTH = 500
HEIGHT = 400

vie = 3
score = 0

ball = Rect((random.randint(20,475),random.randint(20,150)),(15,15))

bat1 = Rect((200,380),(100,15))



dx = 2
dy = 3


def draw():

    if vie < 0:
        screen.fill("black")
        screen.blit("resize_gameover" , (0,30))
        screen.draw.text("(y)",(222,290))
        screen.draw.text("(n)",(275,290))
        screen.draw.text("or",(250,290))
        screen.draw.text("press key :",(130,290))
    else:
        screen.clear()
        screen.draw.text("Life : "+str(vie),(20,30))
        screen.draw.text("Score : "+str(score),(400,30))
        screen.draw.filled_rect(ball,"blue")
        screen.draw.filled_rect(bat1,(243, 123, 40))


def update():

    global dx,dy,vie,score

    ball.x += dx
    ball.y += dy


    if ball.x > WIDTH-20 or ball.x < 0:
        dx = -dx

    if ball.y < 0 :
        dy = -dy

    if ball.y > HEIGHT:
        vie -= 1
        ball.y = random.randint(20,150)
        ball.x = random.randint(20,475)


    if keyboard.right:
        if bat1.x +100 < WIDTH :
            bat1.x += 5

    if keyboard.left:
        if bat1.x > 0:
            bat1.x -= 5

    if ball.colliderect(bat1):
        dy = -dy
        score +=1

    if keyboard.a:
        print("bonjour")

    if vie < 0:
        if keyboard.y:
            vie = 3
            score = 0
            ball.y = random.randint(20,150)
            ball.x = random.randint(20,475)
        elif keyboard.n:
            exit()

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
# Write your code here :-)
import random

WIDTH = 500
HEIGHT = 400

vie = 50
score = 0

ball = Rect((random.randint(20,475),random.randint(20,150)),(15,15))

bat1 = Rect((200,380),(100,15))



#bat2 = Rect((200,20),(100,15))

dx = 2
dy = 3


def draw():
    screen.clear()
    screen.draw.text("Life : "+str(vie),(20,30))
    screen.draw.text("Score : "+str(score),(400,30))
    screen.draw.filled_rect(ball,"blue")
    screen.draw.filled_rect(bat1,(243, 123, 40))
    #screen.draw.filled_rect(bat2,"green")

def update():

    global dx,dy,vie,score,

    ball.x += dx
    ball.y += dy


    if ball.x > WIDTH-20 or ball.x < 0:
        dx = -dx

    if ball.y < 0 :
        dy = -dy

    if ball.y > HEIGHT:
        vie -= 1
        ball.y = random.randint(20,150)
        ball.x = random.randint(20,475)

    if vie < 1:
        exit()

    if keyboard.right:
        if bat1.x +100 < WIDTH :
            bat1.x += 5

    if keyboard.left:
        if bat1.x > 0:
            bat1.x -= 5

    if ball.colliderect(bat1):
        dy = -dy
        score +=1
        #print(random.randint(0,20))
        #clock.schedule(fonctionGoal,2)


def fonctionGoal():
    global score
    score += 1

# data[].attributes.attachment_link.readable_text
All the features in Mu can be accessed via keyboard shortcuts. Windows and Linux users should use the Control key as shown below. macOS users should replace Control with Command.

Here's how they work!

Common Buttons

CTRL SHIFT M

Change mode (the same as clicking "Modes").

CTRL N

Create a new empty tab (the same as clicking "New").

CTRL O

Open a new file (the same as clicking "Open").

CTRL S

Save a file (the same as clicking "Save").

CTRL +

Zoom in (the same as clicking "Zoom In").

CTRL -

Zoom out (the same as clicking "Zoom Out").

F1

Toggle themes (the same as clicking "Theme").

F2

Check code (the same as clicking "Check").

CTRL H

Display help (the same as clicking "Help").

CTRL Q

Quit Mu (the same as clicking "Quit").

Python 3

F5

Run / Stop your code (the same as clicking "Run" or "Stop").

F6

Debug your code (the same as clicking "Debug").

CTRL SHIFT I

Toggle the REPL (the same as clicking "REPL").

CTRL SHIFT P

Toggle the Plotter (the same as clicking "Plotter").

Debugger

SHIFT F5

Stop debugger (the same as clicking "Stop").

F5

Continue running code (the same as clicking "Continue").

F10

Step over a line of code (the same as clicking "Step Over").

F11

Step into a block of code (the same as clicking "Step In").

SHIFT F11

Step out of a block of code (the same as clicking "Step Out").

PyGame Zero

F5

Play or stop your game (the same as clicking "Play" or "Stop").

CTRL SHIFT I

Show image asset directory (the same as clicking "Images").

CTRL SHIFT F

Show font asset directory (the same as clicking "Fonts").

CTRL SHIFT N

Show the sound/noise asset directory (the same as clicking "Sounds").

CTRL SHIFT M

Show the music asset directory (the same as clicking "Music").

Adafruit

CTRL SHIFT U

Toggle the USB serial connection (the same as clicking "Serial").

CTRL SHIFT P

Toggle the Plotter (the same as clicking "Plotter").

The following key combinations work in the serial pane:

CTRL SHIFT C

Copy highlighted text into the clipboard.

CTRL SHIFT V

Paste text into the REPL from the clipboard.

Microbit

F3

Flash code onto device (the same as clicking "Flash").

F4

Toggle the filesystem (the same as clicking "Files").

CTRL SHIFT I

Toggle the REPL (the same as clicking "REPL").

CTRL SHIFT P

Toggle the Plotter (the same as clicking "Plotter").

The micro:bit's REPL pane understands the following key combinations:

CTRL SHIFT C

Copy highlighted text into the clipboard.

CTRL SHIFT V

Paste text into the REPL from the clipboard.

Text Editing

CTRL F

Show the find and replace dialog.

CTRL K

Toggle comments for the current or selected lines of code.

TAB

Indent the current or selected lines by four spaces.

SHIFT TAB

Unindent the current or selected lines by four spaces.

CTRL Z

Undo (keep pressing to keep undoing).

CTRL Y

Redo (keep pressing to keep redoing).

CTRL A

Select all

CTRL X

Cut selected text into the clipboard.

CTRL C

Copy selected text into the clipboard.

CTRL V

Paste text from the clipboard.

UP, DOWN, LEFT, RIGHT (arrows)

Move the cursor one character in the specified direction.

CTRL LEFT / CTRL RIGHT

Move the cursor one word in the specified direction.

SHIFT UP / SHIFT DOWN / SHIFT LEFT / SHIFT RIGHT

Select text in the specified direction.

CTRL SHIFT LEFT / CTRL SHIFT RIGHT

Select text one word in the specified direction.

Miscellaneous Others

CTRL SHIFT S

Save the current tab with a new name (the same as double clicking the tab's name).

CTRL SHIFT D

Show the admin dialog (the same as clicking the cog in the bottom right of Mu's window).

CTRL ALT S

Take a screenshot of the current source code file (great for embedding pictures of code in presentations, websites or educational resources).

# data[].attributes.attachment_link.description
All the features in Mu can be accessed via keyboard shortcuts. Windows and Linux users should use the Control key as shown below. macOS users should replace Control with Command. Here's how they work! CTRL SHIFT M Change mode (the same as clicking "Modes"). CTRL N Create a new empty tab (the same as clicking "New").

# data[].attributes.body
Traduire la page si pas à l'aise avec l'anglais

# data[].attributes.attachment_link.readable_text
Tip

If you're ready to try writing a full game, an event to look out for is PyWeek, which happens twice a year at https://pyweek.org/.

It's an online game programming challenge: you have a week to write a game in Python, using Pygame Zero or other libraries. Lots of other people will be writing games too, and you can watch their progress and play and rate the finished results after the competition.

# data[].attributes.attachment_link.description
Tip If you're ready to try writing a full game, an event to look out for is PyWeek, which happens twice a year at https://pyweek.org/. It's an online game programming challenge: you have a week to write a game in Python, using Pygame Zero or other libraries.

# data[].attributes.headline
Site web qui vous permez de changer la taille de vos images

# data[].attributes.subject
Site web qui vous permez de changer la taille de vos images

# data[].attributes.attachment_link.description
World’s simplest online utility that resizes a PNG image. Free, quick, and powerful. Import PNG, resize PNG.

# data[].attributes.attachment_link.description
Piskel, free online sprite editor. A simple web-based tool for Spriting and Pixel art. Create pixel art, game sprites and animated GIFs. Free and open-source.

# data[].attributes.body
Ceci est ton espace qui reprend les codes des cours ainsi que de la documentation pour tes apprentissages. Tu y retrouveras les codes des projets passés et en cours.

# data[].attributes.attachment_link.readable_text
Png transparency creator tool What is a png transparency creator?

This tool replaces any solid color and its close color tones in a Portable Network Graphics (PNG) photo or picture with transparent pixels. To match similar color tones, enter the similarity percentage in the settings. By default, 30% similar color tones are matched but you can change it as you see fit. For example, if the color that you're removing is red, then it will also remove cherry-red, rose-red, wine-red, and similar shades of red. Simple and powerful!

# data[].attributes.attachment_link.description
Png transparency creator tool What is a png transparency creator? This tool replaces any solid color and its close color tones in a Portable Network Graphics (PNG) photo or picture with transparent pixels. To match similar color tones, enter the similarity percentage in the settings.

# data[].attributes.attachment_link.readable_text
Each tutorial is like a self-contained lesson, explaining a specific aspect of Mu so you have the skills needed to achieve your learning and coding goals. Most of all, they're written to be both educational and entertaining.

# data[].attributes.attachment_link.description
Each tutorial is like a self-contained lesson, explaining a specific aspect of Mu so you have the skills needed to achieve your learning and coding goals. Most of all, they're written to be both educational and entertaining.

# data[].attributes.attachment_link.title
Built-in Objects — Pygame Zero 1.2.1 documentation

# data[].attributes.attachment_link.description
Pygame Zero provides useful built-in objects to help you make games easily.

# data[].attributes.attachment_link.title
2D Game Assets Store & Free - CraftPix.net

# data[].attributes.attachment_link.description
Craftpix offers high-quality 2D game assets for your project. Here you will find game icons, sprites, tilesets, gui, characters and more. All graphics are at a very affordable price. There is also a section with free game assets.

# data[].attributes.attachment_link.description
Free vector graphics editor. A simple yet powerful web and desktop cross-platform tool for everyone.

# data[].attributes.attachment_link.readable_text
Si ce bandeau n'est plus pertinent, retirez-le. Cliquez ici pour en savoir plus.

Un genre de jeu vidéo (ou type de jeu vidéo) est un ensemble de jeux vidéo caractérisés par un similaire. L'absence de consensus sur la normalisation des critères qui définissent les genres se traduit parfois par une incohérence de la classification des jeux. Elle n'est pas toujours systématique et peut varier radicalement selon les sources.

Les termes retenus ici sont, de manière générale, les plus souvent employés ; également, la présente liste n'est pas exhaustive. Chaque terme est suivi d'une brève description et d'exemples de jeux. De plus amples informations au sujet des genres vidéoludiques sont fournies dans les articles qui leur sont respectivement consacrés.

En raison de la part de subjectivité que requiert la classification des genres de jeu vidéo, il arrive fréquemment que plusieurs d'entre eux caractérisent un même jeu ; on parle alors de chevauchement. Par exemple, les jeux de la série comportent des éléments à la fois d'action, d'aventure et de jeu de rôle. Le célèbre , ainsi que et Baldur's Gate: Dark Alliance , sont des jeux de rôle et d'action. Les sont des jeux de rôle et d'action mais apportent quelque chose en plus, si bien qu'on utilise des termes plus spécifiques comme " ". Enfin, les tels que et ses suites amalgament le jeu de rôle et le jeu de tir à la troisième personne. Ce chevauchement est chose commune dans le monde du jeu vidéo et les exemples sont nombreux, en particulier au fur et à mesure que celui-ci se diversifie et mute à travers le temps.

Tout jeu vidéo faisant appel de la part du joueur à une mise à l'épreuve de ses réflexes et de son habileté à diriger l'avancement de la partie à travers le temps et l'espace du jeu correspond à un jeu d'action. Ce genre de jeu est très ancien, le tout premier exemple datant de 1947, appelé Cathode-ray tube amusement device . Les jeux d'actions constituent une très vaste catégorie du jeu vidéo qui regroupe des titres variés, eux-mêmes classés en plusieurs sous-catégories.

Les jeux de combat regroupent l'ensemble des jeux d'action dans lesquels le joueur incarne un combattant disposant de multiples prises et coups. Pour maîtriser le jeu, celui-ci doit les apprendre et être capable de les produire au sein d'enchaînements de techniques dans le but de vaincre les ennemis rencontrés et a contrario d'éviter, esquiver, parer et bloquer les attaques que ceux-ci utilisent contre lui.

Les jeux de combat, également appelés " jeux de baston " ou " versus fighting " dans le jargon des joueurs francophones, mettent en scène des confrontations entre au minimum deux personnages dans un espace fermé (ring, arène, etc.). L'adversaire peut être contrôlé par un autre joueur ou par l'intelligence artificielle de l'ordinateur. Chaque personnage possède ses caractéristiques propres : style de combat, armes, points faibles, points forts, vitesse de déplacement et d'enchaînement des coups, résistances aux coups, etc. Les arts martiaux, qu'ils soient réels ou fictifs, sont omniprésents dans les jeux de combat.

Dans la majorité des cas, les protagonistes joués disposent d'une barre de vie qui diminue en fonction de la puissance des coups et prises reçus. Le combat prend fin soit lorsque la barre d'un des combattants est nulle, soit lorsque le compteur à rebours de temps (pour les jeux dont les combats sont chronométrés) atteint 0. Dans ce cas de figure, le vainqueur décrété est le joueur dont le combattant aura la barre de vie la plus haute. Un des exploits visé dans le jeu de combat est le " ", qui consiste à remporter une manche de combat en réduisant à 0 la barre de vie de son adversaire, tout en maintenant la sienne intacte. Néanmoins, il est à noter que ce système de barre de vies, même s'il reste majoritaire, n'est pas nécessairement l'unique manière de départager les joueurs au sein de ce genre de jeux. La série en particulier est une exception notable pour imposer un système de compteur de dégâts reçus qui, plus il est élevé, plus les coups portés projettent au loin l'adversaire ; le but étant de l'expulser des limites de l'écran. Cette série, non contente de modifier uniquement le principe de gestion des coups, chevauche très fortement sur les jeux de plateformes, au point de faire du choix des niveaux non plus un simple élément de décors et de musique, mais une véritable zone stratégique à exploiter pour les déplacements. L'avenir dira si cette série inaugure un nouveau sous-genre du jeu de combat, où s'il s'agit juste d'une exception au sein de cet ensemble.

Ordinairement, les confrontations se déroulent de profil et malgré l'avènement de la 3D et du pas latéral, le style de jeu est demeuré sensiblement le même avec des combats se déroulant sur un même plan, même s'il existe des jeux de combat en 3D intégrale ou les combattants sont libres de se mouvoir dans tout l'espace alloué (, ...). Les enchaînements de coups ou combos, effectués par la pression dans un ordre précis des boutons de la commande de contrôle par le joueur, est un élément caractéristique du jeu de combat. Ils permettent de mettre en place des prises, coups spéciaux ou techniques imparables. Ceux-ci peuvent aussi bien être des prises réalistes que physiquement impossible, recourant souvent à des exagérations dans la force appliquée aux coups, la vitesse des mouvements, la hauteur des sauts et jusqu'à l'utilisation de forces magiques ou psychiques (télékinésie, projection de flammes, d'onde d'énergie, etc.). Il est également à noter que le réalisme des jeux de combats est également peu de mise en ce qui concerne l'impact que devraient avoir les coups sur les combattants. C'est en particulier notable pour les jeux dont les adversaires utilisent des armes blanches ou contondantes qui normalement devraient trancher dans les chairs ou broyer les membres de l'adversaire. Or dans la majorité des cas, les coups portés ne provoquent aucun dégât visible, ni blessure, détérioration des vêtements portés, fractures, coupures, amputation ou autres blessures notables (bien qu'il existe des jeux opérant dans ce registre). Les coups portés et, quelle que soit leur dangerosité réelle se traduisent le plus souvent par un bruit caractéristique d'un choc brutal, un éventuel cri de douleur de celui qui le reçoit, et une projection momentanée en arrière de ce dernier. Certains jeux de combats peuvent également mettre momentanément hors conscience un personnage ayant reçu trop de coups. Celui-ci devient incontrôlable par le joueur durant un court laps de temps.

Il est à noter que d'un point de vue strict les simulations de combats sportifs comme la boxe, le catch ou l' UFC sont normalement des jeux de combat, mais ont tendance à être classés parmi les jeux de simulation sportive.

Le jeu de combat apparaît pour la première fois en 1976 lorsque Sega commercialise Heavyweight Champ [réf. nécessaire], qui sera suivi dans les années 1980 par d'autres titres du même genre (International Karate, , , etc.). , sorti en 1984 sur borne d'arcade sera le premier jeu à introduire le moderne du jeu de combat, mais la popularité de ce style de jeu croît de manière vertigineuse avec la sortie de au début des années 1990, un jeu qui a massivement popularisé les jeux de combat dans le monde entier. Depuis, ce genre vidéo-ludique suscite toujours l'intérêt chez de nombreux joueurs, et des sorties régulières de nouveaux titres se poursuivent encore à ce jour. Ce genre de jeux représente l'une des disciplines phare des compétitions du jeu vidéo.

Liste de séries de jeux de combats emblématiques :

Les (ou encore ou jeux de combat à progression) sont un sous-genre des jeux de combat. À la différence de ceux-ci, le joueur doit combattre de nombreux ennemis répertoriés en différentes catégories et classes, tout en progressant à l'intérieur de niveaux non fermés et à la difficulté croissante, généralement ponctués par un combat contre un final. La coopération à deux joueurs (ou plus) est fréquente, chacun contrôlant un personnage. Parsemés à divers endroits sur le sol, nombre d'objets et bonus sont récupérables afin de faciliter la progression. Les techniques et combos sont également nettement moins présents que dans le jeu de combat classique, et lorsqu'ils existent, ces derniers sont en petit nombre et en général beaucoup plus simples à produire. Ce genre vidéo-ludique, dont le premier représentant connu fut de Irem sur borne d'arcade en 1984, a été popularisé en 1987 par la sortie de Double Dragon, menant à une plus vaste commercialisation de jeux au semblable.

Les années 1980 et la première moitié des années 1990 (ère des consoles de et génération) représentent l'âge d'or du genre, où les licences se multiplient, de même que leurs suites. La majorité des jeux ont alors tendance à situer l'action dans un environnement urbain, où les protagonistes incarnés par le joueur sont des justiciers qui doivent affronter des légions de gangs, punks, voyous, prostituées et trafiquants qui infestent les niveaux, les joueurs ne pouvant continuer à progresser tant qu'il ne les ont pas tous éliminés. Toutefois certains beat them all de cette époque se déroulent dans d'autres univers, comme c'est le cas avec , dont l'action est située dans un monde d'. Le terme de " jeu de baston " est régulièrement employé dès les années 1980 par le public francophone pour désigner ce genre de jeu, alors nettement plus populaire que le jeu de combat au sens strict qui lui ne connaîtra ses heures de gloire qu'au début des années 1990. C'est pour cette raison que le terme générique de " jeux de baston " fut employé pour désigner également les jeux tels que qui, bien que n'étant pas des beat them all, répondaient à l'image que les joueurs francophones se faisaient du jeu de combat en général.

Des critiques apparaissent dans le courant des années 1990, dénonçant les beat them all alors accusés d'être répétitifs, ennuyeux et se ressemblant tous. Ces accusations sont en partie vérifiables auprès des marchés, car dans la seconde moitié des années 1990 (ère des consoles de génération), les beat them all se font plus rares, et suscitent beaucoup moins l'attention des joueurs, la transition de la 2D à la 3D ayant du mal à prendre auprès du marché pour ce genre de jeu. Il faut attendre le début des années 2000 pour voir revenir sur le devant de la scène les beat them all , non sans quelques modifications par rapport à leurs aînés. Les beat them all en effet se sont vus largement intégrés aux jeux d'action-aventure où les niveaux en 3D supplantent les niveaux à progression en 2D, avec un scénario beaucoup plus travaillé sous forme d'une large quête ponctuée de cinématiques. Le combat rapproché coexiste maintenant avec les puzzles, labyrinthes, coups de feu et missions, et l'univers est beaucoup plus orienté vers la qu'il ne l'était à l'époque.

Si aujourd'hui le beat them all est devenu une sous catégorie chevauchant le jeu d'action-aventure, il n'en reste pas moins qu'à la fin des années 2000 ont commencé à émerger quelques jeux issus de la mouvance du beat them all traditionnel remis au goût du jour, et qui laissent entrevoir un retour du genre dans les productions modernes. C'est par exemple le cas de Scott Pilgrim contre le Monde : Le Jeu.

Liste de séries de Beat them all classiques emblématiques :

Liste de séries d'action-aventure de genreZ Beat them all emblématiques :

SuperTux, un clone de Super Mario Bros.

Les jeux de plateformes sont des jeux d'action dans lesquels le joueur contrôle un personnage évoluant dans des niveaux où une part prépondérante du déplacement s'effectue par la maîtrise de sauts d'une platforme suspendue à une autre, mais aussi pour franchir des obstacles, des fosses, ainsi que divers " pièges " tendus et d'éventuels ennemis. Dans certains jeux de plateformes, le personnage peut disposer en complément d'actions supplémentaires, le plus souvent d'une ou plusieurs de fonctions d'attaques visant à se débarrasser des ennemis qui parsèment les niveaux. Il peut très occasionnellement exister des jeux de plateformes ou le personnage ne peut pas sauter, mais plutôt nager ou rebondir à travers le niveau par exemple. Néanmoins les niveaux comporteront des plateformes quoi qu'il arrive, afin de délimiter un espace de mobilité du personnage joué, ou de faire office de support pour celui-ci, ses ennemis ou objets éventuels. Au fil de leur évolution dans le temps, un certain nombre de jeux de plateformes ont chevauché avec d'autres genres tels que les jeux de tir, les RPGs ou les jeux d'action aventure au point de constituer aujourd'hui un genre parfaitement hybride.

Plusieurs phases historiques marquent le développement des jeux de plateformes :

Première époque : L'ère des jeux préscrolling (1980-1984)

Les jeux de plateformes apparaissent en 1980 avec le jeu d'arcade , dans lequel un personnage qui ne peut pas sauter (mais peut chuter), doit évoluer via des échelles entre différentes plateformes sur lesquelles rodent des monstres. La particularité dont disposait ce jeu était de ne présenter ses différents niveaux que sur un seul et unique écran. Le jeu qui popularisera définitivement le genre sera en 1981 qui introduira pour la première fois une technique de qui deviendra quasi systématique pour le genre : la commande de saut. S'ensuit une vague de jeux dans lequel le du niveau est absent (, , , ...). Une autre tentative d'avancée dans ce secteur sera la mise en place de niveaux s'étalant sur plusieurs écrans via une transition entre chacun d'entre eux : à chaque fois que le personnage joué sort des limites de l'écran, un nouvel écran s'affiche contenant une autre zone du niveau. sorti sur en 1982 sera le premier jeu de plates-formes à introduire ce genre d'affichage. Avec l'apparition des jeux à scrolling ce genre primitif de jeux de plates-formes, n'affichant qu'un niveau par écran ou alors un niveau divisé entre de multiples écrans transitionnels, tendront à disparaître. Mais certaines licences continueront de les mettre malgré tout et avec succès au goût du jour, comme Bubble Bobble où .

Seconde époque : Le scrolling et le succès international des jeux de plateformes (1984-1989)

Le scrolling, ou défilement parallaxe fait sa première apparition dans les jeux de plateformes en 1981 sur borne d'arcade avec le titre , un jeu empruntant également des éléments au . Ce jeu, bien qu'utilisant la commande de saut, ne rencontrera pas un immense succès, le public lui préférant largement le célèbre qui pourtant n'a pas de scrolling. En 1982, Taito et Irem rééditent cette nouveauté avec leurs titres respectifs et sur arcade, et l'année suivante voit la sortie de sur Colecovision. Le scrolling étant alors essentiellement utilisé pour des jeux de tir, où des jeux de course, le succès de ces titres est plutôt mitigé, d'autant plus que les commandes de sauts ne sont pas des plus précises et fluides.

C'est en 1984 que commence réellement la vague des jeux de plateformes à scrolling avec des jeux tels que , ou . Mais c'est 1985 qui est l'année où le jeu de plateformes à va réaliser une très puissante percée sur le marché avec la sortie de sur Famicom. Le titre va définir pour les années à suivre la fluidité des contrôles et le du genre. Ce jeu ouvre une période d'environ 10 ans où les jeux de plates-formes compteront parmi les meilleurs succès du marché du jeu vidéo. culminera d'ailleurs très longtemps au sommet des classements des ventes avec plus de 40 millions de copies vendues dans le monde. À la suite de ce titre phare, de très nombreux jeux reprenant ses mécanismes de base se multiplieront dans les années qui suivent. Des titres tels , , Alex Kidd in Miracle World , , ou inaugurent le début de séries légendaires dans le monde du jeu de plates-formes, et particulièrement sur les consoles de salon.

Troisième époque : L'âge d'or des jeux de plateformes 2D (1989-1995)

L'avènement des consoles 16-bit marque l'âge d'or des jeux de plateformes, même si ordinateurs et bornes d'arcades seront eux aussi le support de certains titres remarquables. Les personnages et les ennemis voient la qualité de leurs graphismes, détails et animations grandement poussés. Les décors s'enrichissent et les sons deviennent de plus en plus subtils. Le level design est de plus en plus minutieusement calculé, avec une difficulté globalement revue à la baisse du fait du développement de bêta-tests au sein des studios de développement, et l'aventure est de plus en plus scénarisée pour certaines licences où des dialogues et des interruptions animées font leur apparition en cours de jeu. La plupart des titres ayant particulièrement plus au public sur les précédents supports voient leur succès confirmé sur ces nouvelles plateformes, et s'installent dans le paysage vidéo ludique comme des titres incontournables (cette dernière remarque n'est pas uniquement valable que pour les jeux de plates-formes, mais pour un grand nombre de jeux étant parus sur cette période). Parmi les titres les plus notables de cette époque, on distinguera , , , , Prince of Persia, Flashback: The Quest for Identity , , , , , , , , Rocket Knight Adventures , , , , ou pour ne citer que ces derniers.

Quatrième époque : L'avènement de la 3D et le déclin de la 2D (1996-2000)

L'introduction de la 3D dans le monde vidéo-ludique ne démarre pas en 1996, mais elle aura eu du mal à s'adapter au monde des jeux de plateformes auparavant. Les premières tentatives remontent aux années 1980 avec la mise en place de la perspective isométrique dans certains jeux de plateformes, dont le plus ancien connu est Congo Bongo de Sega en 1983. La même année, Konami sort le jeu Antarctic Adventure qui pour la première fois autorise une perspective en pseudo 3D pour un jeu de plateformes. Ces deux styles de perspectives introduites dans le monde de la platforme resteront les références et plusieurs autres jeux sortiront dans les années 1980 et début des années 1990 basés sur ces styles (, ...).

En ce qui concerne le développement des jeux de plateformes en 3D véritable, c'est sur la période des années 1990 qu'il faut se pencher. Certes, en 1983, le jeu d' Atari I, Robot sur borne d'arcade était entièrement modélisé en 3D et combinait un oscillant à la fois entre le et la platforme. Cet ovni vidéo-ludique mis à part, le premier jeu de plateformes exclusif entièrement en 3D est dû à Infogrames, qui en 1990 sortent le jeu . Les graphismes très sommaires du jeu et très polygonaux, couplé à un peu précis et l'absence de positionnement de la caméra ont fait que ce jeu est passé à côté du grand public alors que les grosses productions en 2D explosaient à cette époque.

L'avènement de la 3D a quelque peu diminué l'intérêt des joueurs pour le jeu de plateformes, initialement très marqué jusqu'à présent par le monde de la 2D, mais le genre est malgré tout resté toujours commercialement viable : l'arrivée en 1996 de Super Mario 64 sur la Nintendo 64 aura conquis le public et prouvé que le jeu de plates-formes restait tout à fait viable sur les nouveaux supports. Le jeu de plates-formes 3D continuera à fortement laisser sa trace durant la seconde moitié des années 1990 et la première moitié des années 2000, mais subira un déclin relatif par la suite. La cause en est essentiellement la montée en popularité des jeux d'action-aventure, dont le haut rendu graphique que pouvaient désormais produire les supports de l'époque, combinés à un scénario et une mise en scène désormais digne des productions cinématographiques, tendait à remiser au loin ce type de jeux de plates-formes 3D classiques dont la finalité essentielle reste avant tout de franchir des obstacles à travers un niveau prédéfini. Néanmoins, la seconde moitié des années 2000 verra paradoxalement le retour en grâce du jeu de plates-formes 2D, qui avait toujours gardé sa niche de fans malgré l'avènement de la 3D, et ceci via des séries clés (, , , ...). Le jeu sur Nintendo DS en 2006 marque cette remise au goût du jour de la 2D auprès d'un plus grand public, qui depuis n'a cessé de plébisciter le genre à travers de multiples séries (, , ...).

Traditionnellement, les jeux de plates-formes étaient en deux dimensions et l'environnement était vu de profil. Le personnage contrôlé par le joueur devait simplement atteindre la fin du niveau en bravant tous les dangers. L'environnement en 3D des jeux de plateformes récents accroît la liberté de mouvement et rend plus difficile la perception des distances. Aujourd'hui, les jeux de plateformes en défilement subsistent encore sur les consoles portables tels que pour la Nintendo DS et Ultimate Ghosts'n Goblins pour la PSP.

Un jeu de tir est un jeu d'action qui demande au joueur d'être capable, à partir du personnage/véhicule qu'il contrôle, de tirer sur les adversaires qui parsèment les niveaux avec sa ou ses armes/pouvoirs/projectiles pour les neutraliser. Le joueur devra également veiller à se déplacer suffisamment rapidement pour se mettre à couvert ou éviter les tirs ou attaques au corps à corps de ses ennemis.

Dans certains cas, le jeu de tir ne doit pas être confondu avec les jeux de plateformes dont le personnage attaque en tirant (par exemple : ) ni avec un jeu d'action aventure dont le personnage peut tirer (par exemple : ).

Ce qui différencie le jeu de tir de ces autres genres, c'est que dans ces derniers, le fait d'avoir à tirer pour attaquer n'est qu'un des aspects secondaires du jeu : dans un jeu de plateformes, le point central du jeu est de se déplacer de plateformes en plateformes et de progresser vers la fin du niveau ; dans un jeu d'action aventure, l'aspect central du jeu est d'explorer des niveaux tout en faisant avancer le scenario. On peut être amené à tirer sur des ennemis dans ces jeux, mais ce sera à chaque fois dans l'optique de remplir les objectifs centraux. Dans un jeu de tir, au contraire, l'aspect central est et restera toujours de se mouvoir le plus rapidement possible tout en abattant le plus possible d'ennemis avant qu'ils ne vous abattent.

Nexuiz, un jeu de tir à la première personne utilisant un moteur de jeu dérivé de celui de Quake.

Les jeux de tir à la première personne (ou FPS pour First-Person Shooter ) sont basés sur une visée et des déplacements à la première personne. Cette perspective a pour but de donner l'impression au joueur " d'être là ", à la place du personnage tenant l'arme et voyant exactement ce qu'il voit, générant ainsi une forte identification accentuée par des graphismes en trois dimensions. Le est de manière générale rapide et requiert de bons réflexes. Si les FPS sont des jeux de tir, il est à noter que toutes les armes utilisées ne le sont pas forcément : il peut s'agir d'armes de corps à corps telles que des couteaux, des pieds de biche ou des sabres lasers, bien que ces derniers ne constituent qu'une petite partie de l'arsenal qui lui est très souvent plus orienté vers les armes de tirs.

Le genre est apparu tardivement, par nécessité de la 3D en vue en temps réel. Le premier FPS connu du grand public, Wolfenstein 3D est l'initiateur du genre, mais c'est le jeu , qui en son temps a marqué mondialement le genre par ses graphismes et son ambiance. Nombre de techniques astucieuses ont été utilisées afin que le jeu puisse être joué à une vitesse appréciable sur un ordinateur standard. Depuis , les FPS proposent majoritairement un mode multijoueur.

Ce genre vidéoludique a longtemps été l'apanage du PC, du fait de la puissance des cartes vidéo permettant de jouer avec les meilleures configurations graphiques possibles et de l'utilisation de la souris, qui permet plus facilement des mouvements fluides et précis en trois dimensions. Toutefois, avec la sortie de sur la Nintendo 64, qui proposait pour l'époque des effets 3D et un mode multijoueur innovant, la console de salon a su prouver qu'elle pouvait être un support tout à fait acceptable. Les puristes restent toutefois, faute de maniabilité, attachés au jeu de tir sur PC, la souris restant malgré tout plus précise et maniable que les manettes des consoles qui donnent un moins précis et plus saccadé.

Longtemps, le scénario des jeux de tir à la première personne était secondaire et c'étaient la jouabilité, la violence du jeu et la beauté des graphismes qui primaient. Puis, vers la seconde moitié des années 1990, le mode solo de quelques jeux de tir commença à intégrer une scénarisation plus poussée : un briefing manuscrit au début des missions, des informations à lire dans des éléments du jeu, des dialogues textuels durant les missions, puis des cinématiques entre les missions puis des dialogues sonores durant le jeu.

Mais le véritable tournant dans le genre reste en 1998, qui le premier a fait d'un jeu de tir à la première personne une véritable aventure ininterrompue du début à la fin, où le héros devait en plus de se battre, interagir avec des personnages du jeu, assister à des événements clé, déclencher des opérations techniques. Depuis de très nombreux développeurs ont fait chacun à leur tour des jeux très scénarisés, faisant d'eux des jeux pouvant s'apparenter de plus en plus à de véritable jeux d'action-aventure.

Chaque nouvelle génération de FPS repousse sans cesse la limite du réalisme visuel frisant parfois le photoréalisme et les réactions physiques réelles.

À noter que certains jeux de tir à la première personne ne sont jouables qu'en multijoueur (en réseau ou sur Internet) tels que Wolfenstein: Enemy Territory ou .

Chromium BSU, un shoot them up à défilement vertical.

Les shoot them up sont parmi les plus anciens jeux de tirs créés dans l'histoire du jeu vidéo. Caractérisés par une vue objective du vaisseau ou du personnage contrôlé par le joueur. Le but du jeu est de détruire les ennemis tout en esquivant leurs tirs. Le requiert une bonne dose de réflexes, et beaucoup de licences sont réputées pour être d'une difficulté extrême, obligeant le joueur à connaître parfaitement les vagues d'ennemis et d'enchaînement d'obstacles qui se présentent à lui, et à positionner son vaisseau/personnage au pixel près.

De façon générale, ce genre de jeu se découpe en plusieurs niveaux à la difficulté croissante, chacun se terminant par l'affrontement avec un . Très souvent le vaisseau/personnage peut être amélioré en cours de jeu en ramassant des objets (" " dans le jargon des joueurs) qui améliore les capacités (puissance de feu, portée des lasers, nombre de tirs à la seconde, etc.).

Depuis l'entrée dans le siècle, la plupart des sont passés à la troisième dimension, mais le demeure le même : les décors sont modélisés en 3D et leur défilement donne l'impression qu'on se déplace dans un environnement 3D alors que le véhicule/personnage ne fait qu'évoluer sur un plan (par exemple : ). Le genre reste toutefois intimement lié à la période des premières consoles jusqu'à la quatrième génération et connaît une perte de vitesse sur le marché du jeu vidéo depuis l'avènement de la 3D.

La est une console de jeu réputée pour avoir disposée d'une très grande ludothèque de shoot'em up.

Le rail shooter est une forme dérivée de shoot them up mais dont le but est cette fois-ci de détruire les ennemis en suivant un parcours prédéfini modélisé par un couloir virtuel qui avance au sein des décors et dont le joueur ne peut s'échapper. Ce genre de jeu, bien que découlant directement du Shoot'em up en a perdu toutefois le caractère propre puisqu'il s'agit d'un genre hybride entre deux types de jeux. On distingue ainsi deux grandes catégories de rail shooters :

Les rails shooters à la première personne : genre hybride entre un FPS et un Shoot'em up, ce type de rail shooter nous met en même condition visuelle que dans un FPS. On ne contrôle toutefois pas son personnage, mais uniquement le réticule de visée de l'arme, grâce auquel on tire sur les ennemis qui apparaissent à l'écran. Il est toutefois possible en cours d'aventure de choisir un parcours particulier parmi un autre lorsque cela se présente. Il n'est pas également impossible qu'en cours de progression dans le couloir virtuel, à certains moments, le jeu ait été programmé pour vous faire tourner brusquement la tête vers le haut, ou vous retourner tout en continuant à avancer le long du couloir virtuel : ces événements combinés à l'apparition brusque d'ennemis à l'endroit où vous regardez contribue à amplifier l'action et l'impression d'être attaqué de toutes parts. Populaire sur arcade et sur les premières consoles 3D, ce genre a eu tendance à s'essouffler lors du passage à l'an 2000, avant de revenir au goût du jour en particulier avec la Wiimote de la Wii, particulièrement adaptée à ce genre de jeux. ou en sont les exemples les plus réputés.

Les rails shooters volants : genre hybride entre un shoot'em up et un simulateur de vol, on avance toujours le long d'un couloir virtuel aux commandes d'un vaisseau spatial (, ), d'un chasseur de combat (), ou d'un personnage en Jet pack (, ) mais cette fois-ci, on peut contrôler le décalage de haut en bas et de droite à gauche au sein du scrolling 3D. Ce type de rail shooter vous autorise donc à faire des manœuvres d'évitements de tirs ou d'obstacle, tout en vous obligeant à vous positionner convenablement pour aligner votre tir.

Tir en vue objective

Représentation de dos commune aux jeux de tir à la troisième personne.

Les jeux de tir à la troisième personne, ou tir objectif (ou TPS pour Third-Person Shooter ) sont similaires aux jeux de tir à la première personne à la différence que le personnage est vu de dos et parfois avec une perspective isométrique. Le joueur a une vision élargie de l'environnement et sa liberté de mouvement est accrue. et sont des mélanges de TPS et de Survival-Horror

La cité des eaux, un jeu d'aventure textuel récent issu de scène indépendante.

Le jeu d'aventure textuel (ou fiction interactive) est l'un des premiers genres vidéoludiques à être commercialisés à la fin des années 1970, et le précurseur est Colossal Cave Adventure . Ce genre de jeu s'est fait connaître avec la série et a joui d'une certaine popularité dans les années 1980. Le joueur incarne un protagoniste du récit et doit généralement résoudre une série d'énigmes et de casse-têtes à l'aide d'objets ou bien en interagissant avec d'autres personnages.

Les premiers jeux d'aventure étaient proposés sous forme textuelle. Le joueur utilisait le clavier pour saisir des commandes telles que " prendre la corde " ou " aller à l'ouest " et l'ordinateur lui décrivait ce qui se passait.

Quand l'utilisation de graphismes s'est répandu, les jeux d'aventure textuelle ont été peu à peu supplantés par des jeux d'aventure illustrée où les descriptions textuelles étaient moins utiles. Ces jeux d'aventure avec des graphismes requéraient encore la saisie de textes. Aujourd'hui, il existe toujours une communauté d'auteurs et de joueurs actifs de fiction interactive, mais la présence de grandes compagnies sur ce marché est fort rare.

L'utilisation croissante de la souris d'ordinateur est à l'origine des jeux d'aventure du type " pointer-et-cliquer " qui ne nécessitent plus la saisie de commandes. Par exemple, le joueur peut cliquer à l'aide du pointeur sur une corde afin de la ramasser.

À la fin des années 1990, ce type vidéoludique a souffert d'une baisse importante de popularité et les gros titres se sont raréfiés, à un point tel que plusieurs personnes annoncèrent la mort du jeu d'aventure. Cependant, depuis 2005, le jeu d'aventure semblent renaître de ses cendres avec le lancement de jeux tels que Trace Memory , Fahrenheit, Phoenix Wright: Ace Attorney et .

Les jeux de simulation de drague ou sont des jeux essentiellement japonais, très rarement exportés en Occident.

L'objectif le plus courant est de sortir avec une femme (il y a généralement plusieurs choix) et de parvenir à un haut niveau relationnel dans un temps limité. Le joueur doit souvent aussi gagner de l'argent, soit en travaillant, soit par d'autres activités. Les attributs du joueur (caractéristiques physiques ou mentales, etc.) ont aussi un rôle important et peuvent être améliorés de diverses façons. Toutes ces activités prennent du temps, qui est en fait perdu pour atteindre l'objectif principal mais peut aider ensuite à aller plus vite. Les durées de ces activités sont censées représenter des durées réelles.

Le visual novel (littéralement " roman visuel ") est un type de jeu d'aventure dans lequel les interactions du joueur sont extrêmement restreintes. Le plus souvent, il suffit de faire défiler les textes en appuyant sur une touche. À certaines occasions, le joueur peut choisir entre plusieurs choix sous forme textuelle.

Le est apparu et s'est presque exclusivement développé au Japon. Les exportations de ce type de jeu en Occident restent encore aujourd'hui du domaine de l'anecdote. Le genre a souvent été utilisé pour scénariser des jeux à caractère érotique ou pornographique ( eroge), cela renforçant probablement les difficultés d'exportations.

Le (littéralement " roman sonore ") est un type de jeu d'aventure assez populaire au Japon qui est une continuation du genre du jeu d'aventure. La caractéristique principale de ce genre de jeu est de mettre l'accent sur la lecture plutôt que sur la résolution de problèmes, le texte couvrant généralement la totalité de l'écran et les autres éléments visuels étant souvent relégués au second plan ou de style minimaliste. Le son et la musique sont fortement utilisés pour immerger le joueur dans l'histoire. Les interactions se limitent à faire des choix qui ramènent l'histoire à un certain nombre de fins différentes, bien que certains titres aient des récits linéaires sans aucun gameplay qu'on qualifiera de kinetic novel.

Le sound novel est apparu et s'est presque exclusivement développé au Japon. Les exportations de ce type de jeu en Occident restent encore aujourd'hui du domaine de l'anecdote.

Ils sont souvent confondus par les fans à l'international avec les visual novels , genre très similaire qui met en avant les graphismes plutôt que le son et la musique.

Exemples de jeux : La série Sound Novel de Chunsoft (Kamaitachi no Yoru (Banshee's Last Cry)...), la série des When They Cry de 07th Expansion (Higurashi no naku koro ni, Umineko no Naku Koro ni et Kikonia no Naku Koro ni)...

Le jeu d'infiltration est une variante du jeu de tir à la première ou troisième personne où la ruse, la précision et la discrétion se substituent à l'utilisation massive d' armes à feu. Dans ces jeux le personnage contrôlé par le joueur doit se faire discret (en se cachant, en empruntant des passages secrets, en surprenant ses ennemis...) pour remplir les missions qui lui sont confiées. La plupart du temps, les ennemis sont mieux armés que le personnage du joueur ce qui équivaut le plus souvent à la mort de ce dernier s'il y a combat frontal. Exemples de jeux : Dark Project : La Guilde des voleurs, , Hitman : Tueur à gages, , ou Assassin's Creed.

Les placent le joueur dans un univers menaçant et dans lequel il doit survivre. Ces jeux utilisent des éléments traditionnels du film d'horreur pour créer un climat de danger permanent, tels que des monstres ( vampires, zombies, dinosaures ...), des perturbations atmosphériques et autres éléments morbides. Un des principaux éléments de est le nombre limité de munitions.

Les principes fondamentaux du genre ont été introduits par le jeu , mais le survival horror doit sa popularité à la série , qui met le joueur aux mains de protagonistes luttant contre une organisation pharmaceutique, Umbrella, responsable d'un virus qui transforme les gens en zombies.

Représentation répandue parmi les jeux vidéo de rôle occidentaux sur micro-ordinateur dans les années 1990.

Les jeux vidéo de rôle (ou RPG pour Role Playing Game ) s'inspirent des jeux de rôle sur table tel que Donjons & Dragons. La majorité d'entre eux invite le joueur à incarner un ou plusieurs " aventuriers " qui se spécialisent dans un domaine spécifique (combat, magie, etc.) et à les faire progresser à l'intérieur d'une intrigue linéaire. Cependant, des jeux tels que ceux de la série offrent une liberté quasi totale. L'environnement varie beaucoup d'un jeu à l'autre, mais un des thèmes les plus fréquents est le médiéval fantastique. À mesure que progresse l'histoire, les personnages développent leurs compétences grâce à l'expérience acquise au cours des combats (une caractéristique essentielle des jeux de rôle). Le joueur peut équiper les personnages avec des armes, armures, casques, etc., trouvés ou achetés dans des échoppes.

Les , ancêtres des RPG modernes, sont apparus dans les années 1980. Graphiquement simples, ils s'inspirent du jeu . Au tournant de cette décennie, les jeux et sont à l'origine d'une vague de jeux de rôle populaires qui perdurent encore aujourd'hui.

Au fil des ans, les sous-genres jeu de rôle d'action () et jeu de rôle tactique () apparaissent. Le premier amalgame jeu d'aventure et jeu de rôle comme dans la série Seiken densetsu dans lequel les combats sont en temps réels. Le second se caractérise par des déplacements de type jeu d'échecs et un fortement axé sur la stratégie. , , , Disgaea: Hour of Darkness et en sont des exemples.

Il y a bien d'autres sous-genres au jeu de rôle dont le Dungeon crawler qui se déroule dans des donjons à niveaux où la difficulté est croissante.

À la fin des années 1990, alors qu'Internet est en pleine expansion, un nouveau type de jeu de rôle apparaît, le jeu de rôle en ligne massivement multijoueur (MMORPG). Ce type de jeu exclusivement multijoueur innove, notamment, par la mise en place d'univers fonctionnant sur 24 appelés " mondes persistants ". et sont deux exemples très connus.

Enfin, de manière générale, on distingue deux grands groupes de RPG :

Le RPG " japonais " : fortement inspiré par la culture manga ou japonaise, le RPG japonais (Dragon Quest, , , etc.) présente généralement un aspect graphique assez coloré et plutôt joyeux. Très linéaire, il accorde une grande importance aux sentiments, au scénario, à la musique et à la personnalité des personnages. Un genre particulier, appelé eroge (pour Erotic Game), regroupe tous les jeux de rôle ayant un thème ou des scènes à connotation érotique.

Le RPG " occidental " : beaucoup plus proche du jeu de rôle sur table, les RPG occidentaux (, , , , etc.) offrent au joueur une totale liberté dans l'univers du jeu. En revanche, la personnalité des personnages et le scénario sont souvent plus effacés.

Le jeu de rôle d'action (ou Action-RPG ) est un jeu de rôle incorporant des concepts de jeu d'action. Les combats se déroulent généralement directement dans les niveaux sans entrer dans une arène de combat et les coups sont portés en temps réel en appuyant sur un bouton.

Les ( Tailler et trancher) utilisent un principe très simple : le joueur doit mener une quête à bien en allant dans des donjons, où il trouvera des objets et en revenant chercher son butin. Le plus grand exemple de Hack'n'slash le plus célèbre à nos jours est . Le Hack'n'slash est dérivé du A-RPG mais se présente plus brièvement et son résulte de plus de simplicité.

NetHack , un rogue-like .

Les sont des jeux vidéo de rôle inspirés par le jeu , sorti en 1980. Traditionnellement, le joueur y explore un ou plusieurs souterrains générés aléatoirement et représenté en caractères ASCII.

Par extension, on parle parfois de rogue-like pour des jeux de rôle se déroulant principalement dans un ou plusieurs souterrains ou donjons.

EVE Online , un MMORPG à environnement futuriste.

Les jeux de rôle en ligne massivement multijoueur sont des mondes virtuels dans lesquels des centaines ou des milliers de joueurs peuvent interagir ensemble et en même temps par le biais d'un réseau comme Internet. La plupart de ces jeux fonctionnent sur le principe de l' abonnement.

Les jeux de rôle en ligne massivement multijoueur (abrégé en MMORPG ( Massively Multiplayer Online Role-Playing Game)) sont apparus dans la seconde moitié des années 1990, comme une variante commerciale et graphique des (abrégé en MUD) qui existaient depuis 1979. Le concept massivement multijoueur a été rapidement implanté pour d'autres types vidéoludiques :

Les jeux de rôle en ligne massivement multijoueur à univers médiéval-fantastique (fantasy MMORPG) sont actuellement les jeux de rôle en ligne les plus répandus.

Les jeux de rôle de science-fiction en ligne massivement multijoueur (sci-fi MMORPG) représentent une plus petite partie du marché des jeux de rôle en ligne. L'un des premiers est .

Le jeu de rôle tactique (ou Tactical-RPG ) est un genre dérivé du jeu de rôle empruntant au jeu de tactique au tour par tour. La particularité de ce type de jeu de rôle vient du système de combat. Le joueur contrôle son équipe et doit souvent faire face à une équipe de force équivalente ou supérieur. La réussite des combats réside principalement dans le bon placement des unités en fonction de leurs spécialisations et des caractéristiques du terrain.

Un jeu de Mah-jong.

Les jeux vidéo de réflexion amènent le joueur à résoudre des casse-têtes, des énigmes, des dédales, etc. De manière générale, ce type vidéoludique fait appel à la capacité de réflexion du joueur. Il emprunte souvent des éléments provenant du jeu d'aventure (par exemple : , Katamari Damacy, etc.).

Nombre de jeux de réflexion traditionnels ont été portés sur ordinateur notamment le jeu d'échecs, le jeu de dames, le , les jeux de cartes, etc. Les adversaires contrôlés par l'ordinateur offrent habituellement un bon niveau de défi.

Dans les jeux de labyrinthe, le joueur incarne un héros prisonnier d'un labyrinthe. Suivant le jeu, le but du joueur peut être d'échapper à des ennemis, eux aussi prisonnier du labyrinthe, tout en essayant de parcourir tout le labyrinthe ou de collecter des objets disséminés dans le labyrinthe. Bien souvent, le labyrinthe est de type rhizome.

Frozen Bubble , un jeu liant puzzle et rapidité.

Le jeu de puzzle est un jeu de réflexion dans lequel le joueur doit assembler des pièces ou explorer des lieux complexes tel qu'un dédale. Ce genre flirte fréquemment avec le jeu d'aventure et le jeu éducationnel. Quelques jeux d'arcade, en particulier et ses variantes, sont couramment décrits comme étant des jeux de type puzzle en dépit du fait que le repose sur la coordination œil-main et les réflexes plutôt que sur la réflexion et la logique.

Le jeu de puzzle est une expression vague souvent employée par défaut pour catégoriser des jeux " inclassables ", notamment les jeux aux concepts abstraits. Par exemple, avant d'être catégorisés en tant que tel, les " jeux de rythme et de musique " étaient parfois appelés jeux de puzzle.

Dans les jeux de gestion, le joueur endosse le rôle d'un planificateur ou d'un patron devant construire et gérer un espace de vie (une ville), de loisir (un parc d'attraction) ou même tout un peuple, par exemple, en fournissant de la nourriture, un abri, des soins médicaux, un ressourcement spirituel, des loisirs, une croissance économique, etc. à ses administrés ou à ses sujets. Le succès de cette entreprise est étroitement lié à son talent de gestionnaire évalué selon la fluctuation des profits et du degré de satisfaction des individus. Dans le cas d'un jeu de gestion urbaine, lorsqu'il y a une hausse des capitaux et que les individus jouissent d'un style de vie amélioré (logement, santé, biens), cela signifie qu'il a atteint son objectif de mener à bien le destin de sa ville. Bien que le but principal soit d'avoir une économie forte, il incombe également au joueur d'assurer un certain développement militaire afin que sa ville puisse être un lieu de sécurité et de paix.

L'un des sous-genre du jeu de simulation est le " jeu de simulation divine " (ou God Game ) dans lequel le joueur, incarnant une divinité, doit faire croître et prospérer un peuple au moyen d'immenses pouvoirs

Les jeux de simulation de véhicule visent à reproduire de manière réaliste les sensations ressenties aux commandes d'une voiture, d'un avion, d'un tank, d'un train, etc. Ils tiennent compte des lois de la physique, des limites de la réalité et d'un certain nombre de paramètres du comportement propre aux engins pilotées.

Les jeux de stratégie nécessitent une réflexion habile et prudente et un bon sens de la planification en vue d'obtenir la victoire. Il y a deux types de jeux de stratégie : le jeu de stratégie au tour par tour et le jeu de stratégie en temps réel. Ceux-ci sont soit " stratégiques " (accumulation de ressources et combat) soit " tactiques " (axé seulement sur le combat). La plupart des jeux de stratégie donnent au joueur le contrôle d'une région spécifique ou d'une armée. Le commerce, la construction et la gestion des affaires diplomatiques sont divers facteurs parmi tant d'autres que le joueur peut influencer. Certains jeux, tel ceux de la série , simulent plusieurs périodes historiques.

De façon générale, le joueur incarne un personnage puissant, parfois même Dieu, commandant à l'ensemble de ses unités, qu'il perçoit d'en haut, comme vues depuis le ciel. Il peut lancer la production de nouvelles unités pour renforcer son armée ou renouveler les unités perdues au combat. Pour cela, il doit accumuler des ressources (nourriture, bois, pierre, or, etc.) afin de construire des bâtiments, produire (des biens, des armes, etc.) ou encore améliorer les connaissances technologiques.

Les jeux de stratégie au tour par tour sont les premiers jeux de stratégie à avoir été développés. Comme pour le jeu d'échecs et les jeux de cartes, chaque joueur joue son tour selon un ordre déterminé. Ainsi, les parties peuvent être très longues.

Warzone 2100 , un des premiers jeux de stratégie en temps réel en trois dimensions.

Les jeux de stratégie en temps réel (aussi appelés RTS pour Real Time Strategy ) permettent aux joueurs de jouer simultanément. L'habileté et la vitesse sont importantes, et les parties sont plus rapides qu'en " tour par tour ". Ce type de jeu est apparu dans les années 1990 avec le développement de l'informatique. en fut le premier représentant.

La grande stratégie est un type de jeu de stratégie qui se distingue des deux types précédents car les jeux de grande stratégie sont généralement en temps réel et placent le joueur à la tête de toute une nation. Bien que ces jeux soient en temps réel, ils ne sont pas appelés comme tel car ils sont nettement différents des jeux reconnus comme étant des jeux de stratégie en temps réel. Leur couvre donc de nombreux domaines de la géopolitique tel que la politique, l'économie, la religion, la diplomatie et la guerre. Certains de ces jeux sont axés sur la guerre, la logistique et la stratégie militaire, tandis que d'autres se concentrent sur d'autres éléments de la géopolitique comme la politique et la diplomatie avant la guerre. Dans de nombreux cas, les jeux de grande stratégie peuvent être considérés comme une sous-catégorie des .

Exemples de jeux : Hearts of Iron 3 , , , , , .

Freeciv, un jeu 4X largement inspiré de Civilization.

Le jeu 4X est un genre au confluent du jeu de stratégie et du jeu de gestion. Les jeux 4X sont réputés pour leur profondeur et leur système de jeu complexe. L'accent est mis sur le développement économique et technologique d'un empire virtuel que le joueur doit mener à la suprématie. Jouer une partie complète dure en général très longtemps car la gestion d'un empire étendu demande beaucoup de micromanagement.

Les jeux 4X se distinguent des jeux de stratégie classiques notamment par un système d'évolution des unités et des bâtiments via la progression dans un arbre des technologies, par des combats qui se déroulent dans une interface séparée de l'interface de gestion de l'empire et par une complexité des mécanismes de jeu plus importante.

Le terme "Wargame" peut englober presque toutes les formes de jeux de stratégie guerrier, mais son acceptation par le public met l'accent sur la volonté de simulation. Inspiré du Kreigspiel a destination des officiers en apprentissage, le Wargame vidéoludique souhaite offrir une vision plus réaliste de la gestion d'une guerre ou d'une bataille. La plupart se concentre sur une approche purement tactique (déroulement d'une bataille) et d'autre offrent également quelques mécaniques de gestion tout en restant orienté guerre pure, comme la série des Total War.

Les jeux de sport regroupent de nombreuses disciplines tels que le golf, tennis, football, hockey sur glace, équitation, etc. Une grande majorité d'entre eux, notamment , permettent au joueur de contrôler non pas un personnage fictif, mais un athlète réel. Il participe directement à l'action. D'autres, tel que dans L'Entraîneur, proposent au joueur de diriger un entraîneur dont le but évident est de mener son équipe à la victoire. L'objectif n'est plus d'enfiler les buts ou les points, mais de gérer l'alimentation et l'entraînement physique des joueurs, la mise au point de tactiques, etc.

Ce type vidéoludique est l'un des plus anciens de l'histoire des jeux vidéo et demeure aujourd'hui populaire.

Vroom, un jeu de course de Formule 1 de 1991.

Les jeux de course placent le joueur aux commandes d'un véhicule et celui-ci doit effectuer un nombre déterminé de tours de piste et lutter contre d'autres pilotes, en vue d'obtenir une place sur un podium. D'autres fois, il faut simplement atteindre la ligne d'arrivée ou réaliser le meilleur temps. Ce type vidéoludique s'inspire directement des sports automobiles réels qu'il simule ou non.

Apparu au tournant des années 1970, ce type de jeu demeure très populaire aujourd'hui et continue de pousser toujours plus loin le réalisme visuel et physique. On distingue deux sous-genres distincts : le jeu de course d'arcade et le jeu de course de simulation. Le premier tend à exagérer la conduite automobile et à s'éloigner fortement de la réalité (exemples : passer une épingle à 200 km/h en dérapant, tirer un missile, moteur surpuissant, etc.). A contrario, le jeu de course de type simulation essaie autant que possible de respecter la réalité et les caractéristiques de véhicules réels. Certains jeux appartenant à ce sous-genre permettent au joueur de participer à des évènements de course automobile réels tels que l' rallye Dakar. Indianapolis 500 ou le

Une variante des jeux de course d'arcade est le jeu de course de combat qui introduit divers obstacles et la possibilité d'utiliser des armes pour se défendre et/ou attaquer. La série et celle de en sont des exemples.

Exemples de jeux :

StepMania , un jeu de rythme.

Les jeux vidéo de rythme sont habituellement des jeux d'arcade dont le but est de suivre une séquence de mouvements ou maintenir un rythme particulier. Les jeux se jouent à l'aide du clavier ou d'une manette de jeu. D'autres requièrent un tapis de danse ou une réplique d'un instrument de musique.

Ce type vidéoludique apparaît à la fin des années 1990 en même temps que la popularité grandissante du rap et le succès de Dance Dance Revolution . La série des , dont le premier opus est sorti en 2005, a grandement popularisé le genre. La musique JOUE également un rôle important dans un jeu de combat, , dans lequel les coups sont portés au rythme de la musique.

Occasionnellement, la musique fait partie intégrante du . C'est notamment le cas des jeux , et .

# data[].attributes.attachment_link.description
Un genre de jeu vidéo (ou type de jeu vidéo) est un ensemble de jeux vidéo caractérisés par un similaire. L'absence de consensus sur la normalisation des critères qui définissent les genres se traduit parfois par une incohérence de la classification des jeux. Elle n'est pas toujours systématique et peut varier radicalement selon les sources.

# data[].attributes.attachment_link.description
W3Schools offers free online tutorials, references and exercises in all the major languages of the web. Covering popular subjects like HTML, CSS, JavaScript, Python, SQL, Java, and many, many more.

# data[].attributes.body
https://cainos.itch.io/

# data[].attributes.attachment_link.description
Find game assets like Ninja Adventure - Asset Pack, Monsters Creatures Fantasy, Sprout Lands - Asset Pack, Free Pixelart Tileset - Cute Forest, Modern interiors - RPG Tileset [16X16] on itch.io, the indie game hosting marketplace

# data[].attributes.attachment_link.readable_text
Free and Open Source

Blender is a public project hosted on blender.org, licensed as GNU GPL, owned by its contributors.

For that reason Blender is Free and Open Source software, forever. Learn more

Part of the industry

Blender is a member of ASWF, Khronos, Linux Foundation and OIN. It's also well supported by major hardware vendors such as AMD, Apple, Intel, and NVIDIA.

It's about people.

Designers, developers, engineers, artists. All driven by passion. All using Blender to make an impact.

The Ecosystem

Countless communities and thriving businesses are built around Blender.

Together, these tutorial makers and content creators, add-on developers and global marketplaces form an ever-expanding ecosystem.
Find Blender Communities
Everything You Need

Cycles is Blender's built-in powerful unbiased path-tracer engine that offers stunning ultra-realistic rendering.

· Real-time viewport preview

· CPU & GPU rendering

· PBR shaders & HDR lighting support

· VR rendering support

Blender's comprehensive array of modeling tools make creating, transforming and editing your models a breeze.

· Full N-Gon support

· Edge slide, inset, grid and bridge fill, and more

· Advanced sculpting tools and brushes

· Multi-resolution and Dynamic subdivision

· 3D painting with textured brushes and masking

· Python scripting for custom tools and add-ons

VFX professionals say: "Probably the best tracker in the market". Blender includes production ready camera and object tracking. Allowing you to import raw footage, track the footage, mask areas and see the camera movements live in your 3D scene. Eliminating the need to switch between programs.

· Auto and Manual tracking

· Powerful camera reconstruction

· Real-time preview of your tracked footage and 3D scene

· Support for Planar tracking and Tripod solvers

Thanks to the high quality rigging and animation tools, Blender is being used for numerous short films, advertisements, TV series and feature films now.

· Envelope, skeleton and automatic skinning

· B-spline interpolated bones

· Curve editor and dope sheets

· Custom bone shapes for fast input

· Sound synchronization

Story Art, Drawing 2D in 3D

Really! Drawing directly in a 3D viewport makes a lot of sense. It opens unsurpassed workflow freedom for story-boarders and 2D artists.

· Combine 2D with 3D right in the viewport

· Full Animation Support with Onion Skinning

· Layers & Colors for Stroke and Fill

· Sculpt brush strokes & Parent to 3D objects

Blender has a flexible Python controlled interface. Layout, colors, size and even fonts can be adjusted. Use hundreds of add-ons by the community or create your own using Blender's accessible Python API.

· Customize the interface layout and colors

· Hi-res/Retina screen support

· Create your own tools and add-ons

· Draw over the OpenGL viewport

· Connect with Blender's Render API

# data[].attributes.attachment_link.title
blender.org - Home of the Blender project - Free and Open 3D Creation Software

# data[].attributes.headline
Setction : builds-in Objects (rect, line, text, ect)

# data[].attributes.subject
Setction : builds-in Objects (rect, line, text, ect)

# data[].attributes.body
N'hésitez pas à cliquez sur chaque une pour voir plus en profondeur ce chaque méthode fait

# data[].attributes.attachment_link.title
Built-in Objects — Pygame Zero 1.2.1 documentation

# data[].attributes.attachment_link.description
Pygame Zero provides useful built-in objects to help you make games easily.

# data[].attributes.attachment_link.description
Pixilart, free online drawing editor and social platform for everyone. Create game sprites, make pixel art, animated GIFs, share artwork and socialize online.

# data[].attributes.body
La libraire pygame zero étant basé sur la libraire Py game, la documentation de cette derniere peut être utile pour mieux comprendre pygame zero

# data[].attributes.attachment_link.readable_text
pygame.draw

pygame module for drawing shapes

Draw several simple shapes to a surface. These functions will work for rendering to any format of surface.

Most of the functions take a width argument to represent the size of stroke (thickness) around the edge of the shape. If a width of 0 is passed the shape will be filled (solid).

All the drawing functions respect the clip area for the surface and will be constrained to that area. The functions return a rectangle representing the bounding area of changed pixels. This bounding rectangle is the 'minimum' bounding box that encloses the affected area.

All the drawing functions accept a color argument that can be one of the following formats:

A color's alpha value will be written directly into the surface (if the surface contains pixel alphas), but the draw function will not draw transparently.

These functions temporarily lock the surface they are operating on. Many sequential drawing calls can be sped up by locking and unlocking the surface object around the draw calls (see pygame.Surface.lock() lock the Surface memory for pixel access andpygame.Surface.unlock() unlock the Surface memory from pixel access ).

¶

import pygame
from math import pi

# Initialize pygame
pygame . init ()

# Set the height and width of the screen
size = [ 400 , 300 ]
screen = pygame . display . set_mode ( size )

pygame . display . set_caption ( "Example code for the draw module" )

# Loop until the user clicks the close button.
done = False
clock = pygame . time . Clock ()

while not done :
    # This limits the while loop to a max of 60 times per second.
    # Leave this out and we will use all CPU we can.
    clock . tick ( 60 )

    for event in pygame . event . get ():  # User did something
        if event . type == pygame . QUIT :  # If user clicked close
            done = True  # Flag that we are done so we exit this loop

    # Clear the screen and set the screen background
    screen . fill ( "white" )

    # Draw on the screen a green line from (0, 0) to (50, 30)
    # 5 pixels wide. Uses (r, g, b) color - medium sea green.
    pygame . draw . line ( screen , ( 60 , 179 , 113 ), [ 0 , 0 ], [ 50 , 30 ], 5 )

    # Draw on the screen a green line from (0, 50) to (50, 80)
    # Because it is an antialiased line, it is 1 pixel wide.
    # Uses (r, g, b) color - medium sea green.
    pygame . draw . aaline ( screen , ( 60 , 179 , 113 ), [ 0 , 50 ], [ 50 , 80 ], True )

    # Draw on the screen 3 black lines, each 5 pixels wide.
    # The 'False' means the first and last points are not connected.
    pygame . draw . lines (
        screen , "black" , False , [[ 0 , 80 ], [ 50 , 90 ], [ 200 , 80 ], [ 220 , 30 ]], 5
    )

    # Draw a rectangle outline
    pygame . draw . rect ( screen , "black" , [ 75 , 10 , 50 , 20 ], 2 )

    # Draw a solid rectangle. Same color as "black" above, specified in a new way
    pygame . draw . rect ( screen , ( 0 , 0 , 0 ), [ 150 , 10 , 50 , 20 ])

    # Draw a rectangle with rounded corners
    pygame . draw . rect ( screen , "green" , [ 115 , 210 , 70 , 40 ], 10 , border_radius = 15 )
    pygame . draw . rect (
        screen ,
        "red" ,
        [ 135 , 260 , 50 , 30 ],
        0 ,
        border_radius = 10 ,
        border_top_left_radius = 0 ,
        border_bottom_right_radius = 15 ,
    )

    # Draw an ellipse outline, using a rectangle as the outside boundaries
    pygame . draw . ellipse ( screen , "red" , [ 225 , 10 , 50 , 20 ], 2 )

    # Draw an solid ellipse, using a rectangle as the outside boundaries
    pygame . draw . ellipse ( screen , "red" , [ 300 , 10 , 50 , 20 ])

    # This draws a triangle using the polygon command
    pygame . draw . polygon ( screen , "black" , [[ 100 , 100 ], [ 0 , 200 ], [ 200 , 200 ]], 5 )

    # Draw an arc as part of an ellipse.
    # Use radians to determine what angle to draw.
    pygame . draw . arc ( screen , "black" , [ 210 , 75 , 150 , 125 ], 0 , pi / 2 , 2 )
    pygame . draw . arc ( screen , "green" , [ 210 , 75 , 150 , 125 ], pi / 2 , pi , 2 )
    pygame . draw . arc ( screen , "blue" , [ 210 , 75 , 150 , 125 ], pi , 3 * pi / 2 , 2 )
    pygame . draw . arc ( screen , "red" , [ 210 , 75 , 150 , 125 ], 3 * pi / 2 , 2 * pi , 2 )

    # Draw a circle
    pygame . draw . circle ( screen , "blue" , [ 60 , 250 ], 40 )

    # Draw only one circle quadrant
    pygame . draw . circle ( screen , "blue" , [ 250 , 250 ], 40 , 0 , draw_top_right = True )
    pygame . draw . circle ( screen , "red" , [ 250 , 250 ], 40 , 30 , draw_top_left = True )
    pygame . draw . circle ( screen , "green" , [ 250 , 250 ], 40 , 20 , draw_bottom_left = True )
    pygame . draw . circle ( screen , "black" , [ 250 , 250 ], 40 , 10 , draw_bottom_right = True )

    # Go ahead and update the screen with what we've drawn.
    # This MUST happen after all the other drawing commands.
    pygame . display . flip ()

# Be IDLE friendly
pygame . quit ()

Edit on GitHub

# data[].attributes.attachment_link.title
pygame.draw - pygame v2.1.3 documentation

# data[].attributes.attachment_link.description
pygame.draw pygame module for drawing shapes Draw several simple shapes to a surface. These functions will work for rendering to any format of surface. Most of the functions take a width argument to represent the size of stroke (thickness) around the edge of the shape.

# data[].attributes.attachment_link.description
I'm a full-time software developer from germany that enjoys creating pixel art and games.

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
WIDTH = 500
HEIGHT = 400

vie = 3
score = 0

ball = Rect((250,300),(15,15))
bat1 = Rect((200,380),(100,15))

bat2 = Rect((200,20),(100,15))

dx = 2
dy = 3


def draw():
    screen.clear()
    screen.draw.text("Life : "+str(vie),(20,30))
    screen.draw.text("Score : "+str(score),(400,30))
    screen.draw.filled_rect(ball,"blue")
    screen.draw.filled_rect(bat1,(243, 123, 40))
    screen.draw.filled_rect(bat2,"green")

def update():
    global dx,dy

    ball.x += dx
    ball.y += dy

    if ball.x > WIDTH-20 or ball.x < 0:
        dx = -dx

    if ball.y < 0 or ball.y > HEIGHT-15  :
        dy = -dy

    if keyboard.right:
        if bat1.x +100 < WIDTH :
            bat1.x += 4

    if keyboard.left:
        if bat1.x > 0:
            bat1.x -= 4

    if ball.colliderect(bat1):
        dy = -dy
        clock.schedule(fonctionGoal,3)


def fonctionGoal():
    global score
    score += 1

# data[].attributes.attachment_link.readable_text
# Write your code here :-)
WIDTH = 500
HEIGHT = 400

vie = 3
score = 0
ball = Rect((250,300),(15,15))
bat1 = Rect((200,380),(100,15))
dx = 1
dy = 1


def draw():
    screen.clear()
    screen.draw.text("Life : "+str(vie),(20,30))
    screen.draw.text("Score : "+str(score),(400,30))
    screen.draw.filled_rect(bat1,(243, 123, 40))
    screen.draw.filled_rect(ball,"blue")

def update():
    global dx,dy

    ball.x += dx
    ball.y += dy

    if ball.x > WIDTH-20 or ball.x < 0:
        dx = -dx

    if ball.y < 0 or ball.y > HEIGHT-15  :
        dy = -dy