Salut à tous ! Je suis actuellement entrain de coder un jeu pour une petite console portable. Malheureusement, elle est assez limitée en puissance, et je suis assez désolé de voir que mes jeux créés sur pc (qui sont assez simplistes) ralentissent fortement lors du passage sur la console.
Je créé donc ce topic pour savoir si vous n'aviez pas des astuces pour améliorer la vitesse du jeu par je ne sais quel moyen ?
Au cas ou, voici mon code:
main_menu:
#!/usr/bin/python3.1
# -*-coding:utf-8 -*
import pygame
from pygame.locals import *
import os
import pickle
from menu_level import *
from time import*
pygame.init()
#Ouverture de la fenêtre Pygame
screen = pygame.display.set_mode((320, 240))
#Disable the cursor (1 = on) and (0 = off)
pygame.mouse.set_visible(0)
pygame.display.set_caption('Chicken Mole')
fond = pygame.image.load("images/title_final.png").convert()
curseur = pygame.image.load("images/cursor.png").convert_alpha()
reset_img = pygame.image.load("images/reset.png").convert_alpha()
reset_done = pygame.image.load("images/reset_done.png").convert_alpha()
curseur_pos = 0
screen.blit(fond, (0,0))
screen.blit(curseur, (110, 132))
sauvegarde = 0
if os.path.exists("fichiers/sauvegarde"): # le fichier existe
# On le récupère
fichier_ouvert = open("fichiers/sauvegarde", "rb")
mon_depickler = pickle.Unpickler(fichier_ouvert)
sauvegarde = mon_depickler.load()
fichier_ouvert.close()
else: # le fichier n'existe pas
pass
continuer_menu = 1
stop = 0
while continuer_menu:
pygame.time.Clock().tick(30)
for event in pygame.event.get(): #Attente des événements
if event.type == QUIT:
continuer_menu = 0
if event.type == KEYDOWN:
if event.key == K_DOWN and curseur_pos < 3: #Si "flèche bas"
curseur_pos +=1
elif event.key == K_UP and curseur_pos > 0: #Si "flèche haut"
curseur_pos -=1
elif event.key == K_SPACE:
if curseur_pos == 0:
menu_level(sauvegarde, fond, curseur, screen)
if curseur_pos == 1:
screen.blit(reset_img, (0,0))
pygame.display.flip()
stop = 1
pygame.event.clear()
while stop:
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == K_SPACE:
stop = 0
reset()
screen.blit(reset_done, (0,0))
pygame.display.flip()
sleep(2)
if os.path.exists("fichiers/sauvegarde"): # le fichier existe
# On le récupère
fichier_ouvert = open("fichiers/sauvegarde", "rb")
mon_depickler = pickle.Unpickler(fichier_ouvert)
sauvegarde = mon_depickler.load()
fichier_ouvert.close()
else: # le fichier n'existe pas
pass
elif event.key == K_m:
stop = 0
if curseur_pos == 3:
continuer_menu = 0
if curseur_pos == 0:
screen.blit(fond, (0,0))
screen.blit(curseur,(110,132))
if curseur_pos == 1:
screen.blit(fond, (0,0))
screen.blit(curseur,(89,152))
if curseur_pos == 2:
screen.blit(fond, (0,0))
screen.blit(curseur,(104,172))
if curseur_pos == 3:
screen.blit(fond, (0,0))
screen.blit(curseur,(113, 192))
pygame.display.flip()
menu_level:
#!/usr/bin/python3.1
# -*-coding:utf-8 -*
import pygame
from pygame.locals import *
from fonctions import *
from game import *
pygame.init()
def menu_level(sauvegarde, fond, curseur, screen):
fond_level = pygame.image.load("images/map.png").convert()
chicken = pygame.image.load("images/down.png").convert_alpha()
vert = pygame.image.load("images/vert.png").convert_alpha()
refresh(sauvegarde, screen, fond_level, chicken, vert)
continuer_menu = 1
while continuer_menu:
pygame.time.Clock().tick(30)
for event in pygame.event.get(): #Attente des événements
if event.type == QUIT:
continuer_menu = 0
screen.blit(fond, (0,0))
screen.blit(curseur,(110,132))
if event.type == KEYDOWN:
if event.key == K_RIGHT:
if (sauvegarde[4][1] == 0 or sauvegarde[4][1] == 2) and sauvegarde[sauvegarde[4][1]][sauvegarde[4][0]] == 1 and sauvegarde[4][0] < 2:
sauvegarde[4][0] += 1
elif sauvegarde[4][1] == 1 and sauvegarde[4][0] < 2:
sauvegarde[4][0] += 1
elif event.key == K_LEFT:
if sauvegarde[4][1] == 1 and sauvegarde[sauvegarde[4][1]][sauvegarde[4][0]] == 1 and sauvegarde[4][0] > 0:
sauvegarde[4][0] -= 1
elif (sauvegarde[4][1] == 0 or sauvegarde[4][1] == 2) and sauvegarde[4][0] > 0:
sauvegarde[4][0] -= 1
elif event.key == K_DOWN:
if ((sauvegarde[4][0] == 2 and sauvegarde[4][1] == 0) or (sauvegarde[4][0] == 0 and sauvegarde[4][1] == 1)) and sauvegarde[sauvegarde[4][1]][sauvegarde[4][0]] == 1:
sauvegarde[4][1] += 1
elif sauvegarde[4][0] == 2 and sauvegarde[4][1] == 2:
sauvegarde[4][1] = 3
sauvegarde[4][0] = 1
elif event.key == K_UP and ((sauvegarde[4][0] == 1 and sauvegarde[4][1] == 3) or (sauvegarde[4][0] == 0 and sauvegarde[4][1] == 2) or (sauvegarde[4][0] == 2 and sauvegarde[4][1] == 1)):
sauvegarde[4][1] -= 1
elif event.key == K_SPACE:
fichier_level = test_level(sauvegarde)
game(fichier_level, sauvegarde)
elif event.key == K_m:
continuer_menu = 0
refresh(sauvegarde, screen, fond_level, chicken, vert)
pygame.display.flip()
game:
#!/usr/bin/python3.1
# -*-coding:utf-8 -*
import pygame
from pygame.locals import *
from classes import *
from fonctions import *
pygame.init()
def game(fichier_level, sauvegarde):
font = pygame.font.Font("game_over.ttf", 48)
#Ouverture de la fenêtre Pygame
screen = pygame.display.set_mode((320, 240))
#Disable the cursor (1 = on) and (0 = off)
pygame.mouse.set_visible(0)
pygame.display.set_caption('Chicken Mole')
#Rafraîchissement de l'écran
pygame.display.flip()
pygame.key.set_repeat(90, 0)
level = Niveau(fichier_level, font)
temps = font.render(str(level.temps),1,(255,255,255))
x=0
stop = 0
chicken = Perso(level)
chicken = positionner(chicken, level)
fond = pygame.image.load("images/fond.png").convert()
pause = pygame.image.load("images/pause.png").convert()
screen.blit(chicken.display, (chicken.x, chicken.y))
refresh_level(level, chicken, screen)
#BOUCLE INFINIE
continuer = 1
while continuer:
#Limitation de vitesse de la boucle
#30 frames par secondes suffisent
pygame.time.Clock().tick(30)
for event in pygame.event.get(): #Attente des événements
if event.type == QUIT:
continuer = 0
if event.type == KEYDOWN:
if event.key == K_DOWN: #Si "flèche bas"
chicken.dir = "bas"
#On bouge le perso vers le bas
level, continuer = chicken.deplacer(level, sauvegarde)
elif event.key == K_UP: #Si "flèche haut"
chicken.dir ="haut"
#On bouge le perso vers le haut
level, continuer = chicken.deplacer(level, sauvegarde)
elif event.key == K_LEFT: #Si "flèche gauche"
#On bouge le perso à gauche
chicken.dir = "gauche"
level, continuer = chicken.deplacer(level, sauvegarde)
elif event.key == K_RIGHT: #Si "flèche droite"
chicken.dir = "droite"
#On bouge le perso à droite
level, continuer = chicken.deplacer(level, sauvegarde)
elif event.key == K_SPACE:
level = action(chicken, level)
elif event.key == K_c and level.inventaire[4]>0:
level.inventaire[4] -=1
elif event.key == K_v and level.inventaire[4]<3:
level.inventaire[4] +=1
elif event.key == K_p:
screen.blit(pause, (0,0))
pygame.display.flip()
stop = 1
pygame.event.clear()
while stop:
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == K_p:
stop = 0
elif event.key == K_m:
stop = 0
continuer = 0
refresh_level(level, chicken, screen)
x+=1
if x == 30:
x = 0
level.temps = test_temps(level.temps)
temps = font.render(str(level.temps),1,(255,255,255))
refresh_temps(screen, temps)
#Rafraichissement
pygame.display.flip()
classes:
#!/usr/bin/python3.1
# -*-coding:utf-8 -*
import pygame
from pygame.locals import *
import os
import pickle
from fonctions import *
class Niveau:
"""Classe définissant le niveau du jeu
"""
def __init__(self, fichier_map, font):
if os.path.exists("fichiers/"+fichier_map): # si le fichier existe
# On l'ouvre
fichier = open("fichiers/"+fichier_map, "rb")
mon_depickler = pickle.Unpickler(fichier)
contenu_fichier = mon_depickler.load() #on récupère le contenu
fichier.close()
self.case_x = 20 #nombre de case de large du niveau
self.case_y = 12 #nombre de case de haut du niveau
self.niveau = font.render(str(contenu_fichier[0]),1,(255,255,255)) #numéro du niveau (1, 2, 3...)
self.niveau_x = contenu_fichier[9]
self.niveau_y = contenu_fichier[10]
self.temps = contenu_fichier[1]
self.perso_case_x = int(contenu_fichier[2])
self.perso_case_y = int(contenu_fichier[3])
self.maps = contenu_fichier[5] #matrices des maps
self.map = self.maps[0][0] #matrice de la map utilisée
self.inventaire = contenu_fichier[6]
self.pos_map_x = contenu_fichier[7]
self.pos_map_y = contenu_fichier[8]
class Perso(): #Définit notre classe perso
"""Classe définissant notre personnage par:
- ses images dans différentes position.
"""
def __init__(self, level): #notre méthode constructeur
"""les images"""
self.dir = "bas"
self.up = pygame.image.load("images/up.png").convert_alpha()
self.down = pygame.image.load("images/down.png").convert_alpha()
self.right = pygame.image.load("images/right.png").convert_alpha()
self.left = pygame.image.load("images/left.png").convert_alpha()
self.case_x = level.perso_case_x
self.case_y = level.perso_case_y
self.x = 16*self.case_x
self.y = 16*self.case_y - 4
self.display = self.down
def deplacer(self, level, sauvegarde):
continuer = 1
if self.dir == 'droite':
self.display = self.right
if self.case_x == 19:
level, self.case_y, self.case_x = change_map(level, self.case_x, self.case_y)
self.x = self.case_x*16
self.y = self.case_y*16-4
else:
case_visee = level.map[self.case_y][self.case_x+1]
if case_visee != 1 and case_visee != 2 and case_visee != 3 and case_visee != 4 and case_visee != 5 and case_visee != 7 and case_visee != 8 and case_visee != 11 and case_visee != 12 and case_visee != 17: #Si la case vidée n'est pas occupée par un obstacle, on bouge
self.case_x += 1 #La position est modifiée (unité de case)
self.x = self.case_x*16 #la position est modifiée (unité de pixel)
level, continuer = test_case(case_visee, level, self, sauvegarde)
elif self.dir == 'gauche':
self.display = self.left
if self.case_x == 0:
level, self.case_y, self.case_x = change_map(level, self.case_x, self.case_y)
self.x = self.case_x*16
self.y = self.case_y*16-4
else:
case_visee = level.map[self.case_y][self.case_x-1]
if case_visee != 1 and case_visee != 2 and case_visee != 3 and case_visee != 4 and case_visee != 5 and case_visee != 7 and case_visee != 8 and case_visee != 11 and case_visee != 12 and case_visee != 17: #Si la case vidée n'est pas occupée par un obstacle, on bouge
self.case_x -= 1#La position est modifiée (unité de case)
self.x = self.case_x*16 #la position est modifiée (unité de pixel)
level, continuer = test_case(case_visee, level, self, sauvegarde)
elif self.dir == 'haut':
self.display = self.up
if self.case_y == 0:
level, self.case_y, self.case_x = change_map(level, self.case_x, self.case_y)
self.x = self.case_x*16
self.y = self.case_y*16-4
else:
case_visee = level.map[self.case_y-1][self.case_x]
if case_visee != 1 and case_visee != 2 and case_visee != 3 and case_visee != 4 and case_visee != 5 and case_visee != 7 and case_visee != 8 and case_visee != 11 and case_visee != 12 and case_visee != 17: #Si la case vidée n'est pas occupée par un obstacle, on bouge
self.case_y -= 1#La position est modifiée (unité de case)
self.y = self.case_y*16 - 4 #la position est modifiée (unité de pixel)
level, continuer = test_case(case_visee, level, self, sauvegarde)
elif self.dir == 'bas':
self.display = self.down
if self.case_y == 11:
level, self.case_y, self.case_x = change_map(level, self.case_x, self.case_y)
self.x = self.case_x*16
self.y = self.case_y*16-4
else:
case_visee = level.map[self.case_y+1][self.case_x]
if case_visee != 1 and case_visee != 2 and case_visee != 3 and case_visee != 4 and case_visee != 5 and case_visee != 7 and case_visee != 8 and case_visee != 11 and case_visee != 12 and case_visee != 17: #Si la case vidée n'est pas occupée par un obstacle, on bouge
self.case_y += 1#La position est modifiée (unité de case)
self.y = self.case_y*16 - 4 #la position est modifiée (unité de pixel)
level, continuer = test_case(case_visee, level, self, sauvegarde)
return level, continuer
fonctions:
#!/usr/bin/python3.1
# -*-coding:utf-8 -*
import pygame
from pygame.locals import *
import pickle
import time
import os
def open_file(nom_fichier):
#Ouvre un fichier de niveau et retourne son contenu
if os.path.exists(nom_fichier): # le fichier existe
# On le récupère
fichier_ouvert = open(nom_fichier_scores, "rb")
mon_depickler = pickle.Unpickler(fichier_ouvert)
contenu = mon_depickler.load()
fichier_ouvert.close()
else: # le fichier n'existe pas
print("Erreur, le fichier spécifié n'existe pas !")
contenu = 0
return contenu
def refresh_level(level, chicken, screen):
y = 0
x = 0
#chargement des sprites
mur = pygame.image.load("images/blocks/mur.png").convert()
bombe = pygame.image.load("images/blocks/bomb.png").convert_alpha()
trou = pygame.image.load("images/blocks/trou.png").convert_alpha()
piques = pygame.image.load("images/blocks/pics_on.png").convert_alpha()
piques_rentres = pygame.image.load("images/blocks/pics_off.png").convert_alpha()
interrupteur_r = pygame.image.load("images/blocks/off.png").convert_alpha()
interrupteur_v = pygame.image.load("images/blocks/on.png").convert_alpha()
cle = pygame.image.load("images/blocks/key.png").convert_alpha()
planche = pygame.image.load("images/blocks/planche.png").convert_alpha()
sceau = pygame.image.load("images/blocks/sceau.png").convert_alpha()
carte_r = pygame.image.load("images/blocks/passcard_red.png").convert_alpha()
carte_v = pygame.image.load("images/blocks/passcard_green.png").convert_alpha()
feu = pygame.image.load("images/blocks/fire2.png").convert_alpha()
block = pygame.image.load("images/blocks/block.png").convert_alpha()
lecteur_r = pygame.image.load("images/blocks/passreader_red.png").convert_alpha()
lecteur_v = pygame.image.load("images/blocks/passreader_green.png").convert_alpha()
porte = pygame.image.load("images/blocks/door.png").convert_alpha()
fond = pygame.image.load("images/fond.png").convert()
selecteur = pygame.image.load("images/selecteur.png").convert_alpha()
end = pygame.image.load("images/blocks/end.png").convert_alpha()
screen.blit(fond, (0,0))
while y < level.case_y:
while x < level.case_x:
if level.map[y][x] == 1:
screen.blit(block, (16*x, 16*y))
elif level.map[y][x] == 2:
screen.blit(porte, (16*x, 16*y))
elif level.map[y][x] == 3:
screen.blit(trou, (16*x, 16*y))
elif level.map[y][x] == 4:
screen.blit(mur, (16*x, 16*y))
elif level.map[y][x] == 5:
screen.blit(piques, (16*x, 16*y))
elif level.map[y][x] == 6:
screen.blit(piques_rentres, (16*x, 16*y))
elif level.map[y][x] == 7:
screen.blit(lecteur_v, (16*x, 16*y))
elif level.map[y][x] == 8:
screen.blit(lecteur_r, (16*x, 16*y))
elif level.map[y][x] == 9:
screen.blit(carte_v, (16*x, 16*y))
elif level.map[y][x] == 10:
screen.blit(carte_r, (16*x, 16*y))
elif level.map[y][x] == 11:
screen.blit(interrupteur_v, (16*x, 16*y))
elif level.map[y][x] == 12:
screen.blit(interrupteur_r, (16*x, 16*y))
elif level.map[y][x] == 13:
screen.blit(planche, (16*x, 16*y))
elif level.map[y][x] == 14:
screen.blit(sceau, (16*x, 16*y))
elif level.map[y][x] == 15:
screen.blit(bombe, (16*x, 16*y))
elif level.map[y][x] == 16:
screen.blit(cle, (16*x, 16*y))
elif level.map[y][x] == 17:
screen.blit(feu, (16*x, 16*y))
elif level.map[y][x] == 18:
screen.blit(end, (16*x, 16*y))
if y == chicken.case_y and x == chicken.case_x:
screen.blit(chicken.display, (chicken.x, chicken.y))
x += 1
x = 0
y += 1
screen.blit(level.niveau, (280,189))
# Partie de l'inventaire:
x = 0
while x < 4:
if level.inventaire[x] == 9:
screen.blit(pygame.transform.scale(carte_v, (32, 32)), (16+x*48, 200))
if level.inventaire[x] == 10:
screen.blit(pygame.transform.scale(carte_r, (32, 32)), (16+x*48, 200))
if level.inventaire[x] == 13:
screen.blit(pygame.transform.scale(planche, (32, 32)), (16+x*48, 200))
if level.inventaire[x] == 14:
screen.blit(pygame.transform.scale(sceau, (32, 32)), (16+x*48, 200))
if level.inventaire[x] == 15:
screen.blit(pygame.transform.scale(bombe, (32, 32)), (16+x*48, 200))
if level.inventaire[x] == 16:
screen.blit(pygame.transform.scale(cle, (32, 32)), (16+x*48, 200))
x += 1
screen.blit(selecteur, (13+level.inventaire[4]*48, 197))
def ajoute_inventaire(objet, inventaire):
x = 0
while x < 4:
if inventaire[x] == 0:
inventaire[x] = objet
x = 10
x += 1
if x > 8:
objet = 0
return objet, inventaire
def action(chicken, level):
if chicken.dir == "haut":
x = 0
y = 1
if chicken.dir == "bas":
x = 0
y = -1
if chicken.dir == "gauche":
x = 1
y = 0
if chicken.dir == "droite":
x = -1
y = 0
if level.map[chicken.case_y-y][chicken.case_x-x] == 1 and level.inventaire[level.inventaire[4]] == 15:
level.map[chicken.case_y-y][chicken.case_x-x] = 0
level.inventaire[level.inventaire[4]] = 0
if level.map[chicken.case_y-y][chicken.case_x-x] == 2 and level.inventaire[level.inventaire[4]] == 16:
level.map[chicken.case_y-y][chicken.case_x-x] = 0
level.inventaire[level.inventaire[4]] = 0
if level.map[chicken.case_y-y][chicken.case_x-x] == 3 and level.inventaire[level.inventaire[4]] == 13:
level.map[chicken.case_y-y][chicken.case_x-x] = 0
level.inventaire[level.inventaire[4]] = 0
if level.map[chicken.case_y-y][chicken.case_x-x] == 7 and level.inventaire[level.inventaire[4]] == 9:
level.map[chicken.case_y-y][chicken.case_x-x] = 0
level.inventaire[level.inventaire[4]] = 0
if level.map[chicken.case_y-y][chicken.case_x-x] == 8 and level.inventaire[level.inventaire[4]] == 10:
level.map[chicken.case_y-y][chicken.case_x-x] = 0
level.inventaire[level.inventaire[4]] = 0
if level.map[chicken.case_y-y][chicken.case_x-x] == 17 and level.inventaire[level.inventaire[4]] == 14:
level.map[chicken.case_y-y][chicken.case_x-x] = 0
level.inventaire[level.inventaire[4]] = 0
if level.map[chicken.case_y-y][chicken.case_x-x] == 11 or level.map[chicken.case_y-y][chicken.case_x-x] == 12:
change_piques(level)
return level
def refresh_temps(screen,temps):
fond_temps = pygame.image.load("images/fond_temps.png").convert_alpha()
screen.blit(fond_temps,(265,217))
screen.blit(temps, (280, 210))
def change_piques(level):
x = 0
y = 0
pique = 0
while y < level.case_y:
while x < level.case_x:
if level.map[y][x] == 11:
level.map[y][x] = 12
pique = 1
if level.map[y][x] == 12 and pique == 0:
level.map[y][x] = 11
if level.map[y][x] == 5:
level.map[y][x] = 6
pique = 1
if level.map[y][x] == 6 and pique == 0:
level.map[y][x] = 5
x += 1
pique = 0
x = 0
y += 1
return level
def positionner(perso, level):
perso.case_x = level.perso_case_x
perso.case_y = level.perso_case_y
perso.x = perso.case_x*16
perso.y = perso.case_y*16 - 4
return perso
def test_temps(temps):
temps-=1
if temps <= 0:
print("perdu")
return temps
def change_map(level, perso_x, perso_y):
if perso_x == 0:
perso_x = 19
level.pos_map_x -= 1
elif perso_x == 19:
perso_x = 0
level.pos_map_x += 1
if perso_y == 0:
perso_y = 11
level.pos_map_y -= 1
elif perso_y == 11:
perso_y = 0
level.pos_map_y += 1
level.map = level.maps[level.pos_map_y][level.pos_map_x]
return level, perso_y, perso_x
def refresh(sauvegarde, screen, fond_level, chicken, vert):
screen.blit(fond_level,(0,0))
i = 0
j = 0
while i < 4:
while j < 3:
if sauvegarde[i][j] == 1:
screen.blit(vert,(j*96+53, i*33+68))
j+=1
j = 0
i += 1
screen.blit(chicken,(sauvegarde[4][0]*96+55,sauvegarde[4][1]*33+68))
def test_level(sauvegarde):
if sauvegarde[4][0] == 0 and sauvegarde[4][1] == 0:
fichier_level = "fichier_level_1"
if sauvegarde[4][0] == 1 and sauvegarde[4][1] == 0:
fichier_level = "fichier_level_2"
if sauvegarde[4][0] == 2 and sauvegarde[4][1] == 0:
fichier_level = "fichier_level_3"
if sauvegarde[4][0] == 0 and sauvegarde[4][1] == 1:
fichier_level = "fichier_level_4"
if sauvegarde[4][0] == 1 and sauvegarde[4][1] == 1:
fichier_level = "fichier_level_5"
if sauvegarde[4][0] == 2 and sauvegarde[4][1] == 1:
fichier_level = "fichier_level_6"
if sauvegarde[4][0] == 0 and sauvegarde[4][1] == 2:
fichier_level = "fichier_level_7"
if sauvegarde[4][0] == 1 and sauvegarde[4][1] == 2:
fichier_level = "fichier_level_8"
if sauvegarde[4][0] == 2 and sauvegarde[4][1] == 2:
fichier_level = "fichier_level_9"
if sauvegarde[4][0] == 1 and sauvegarde[4][1] == 3:
fichier_level = "fichier_level_10"
return fichier_level
def reset():
#niveau 1
level1 = [1,110,8,5,1,[[[[4,4,4,4,0,0,4,4,4,4,4,4,4,4,0,0,0,0,0,0],[4,0,0,15,4,4,0,0,15,0,0,3,0,0,4,4,4,4,4,4],[4,0,4,4,4,0,0,4,4,4,0,0,4,0,0,0,0,0,18,4],[4,0,0,4,0,0,4,0,5,0,4,0,0,4,4,4,4,4,4,4],[4,4,0,4,0,4,6,0,11,0,0,4,0,1,0,4,0,0,0,4],[4,0,0,4,0,4,0,1,0,4,0,4,0,4,0,0,0,4,9,4],[4,0,4,4,0,4,0,4,0,0,0,4,0,4,4,4,4,4,4,4],[4,0,0,1,0,4,0,4,0,0,4,0,0,4,0,0,0,0,0,0],[4,4,0,4,5,4,0,4,4,4,0,0,4,4,4,4,4,4,4,4],[4,0,0,4,2,4,0,0,0,0,0,0,4,0,7,0,4,0,16,4],[4,15,4,4,13,4,4,4,4,4,4,0,0,0,4,0,0,0,4,4],[4,4,4,4,4,4,0,0,0,0,0,4,4,4,4,4,4,4,4,4]],0,0],[0,0,0],[0,0,0]],[0,0,0,0,0],0,0,0,0]
#niveau 2
level2 = [2,110,1,1,2,[[[[4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4],[4,0,4,16,4,4,0,0,0,0,0,0,0,0,0,0,1,0,11,4],[4,0,4,0,0,4,0,4,4,4,4,4,4,4,4,4,4,4,4,4], [4,0,4,4,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4],[4,0,0,4,0,6,0,4,14,4,15,4,4,4,4,4,4,4,0,4],[4,4,6,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,0,4],[18,5,0,5,2,2,2,2,0,0,0,1,0,0,0,0,0,0,0,4], [4,4,6,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,0,4],[4,13,0,5,0,0,0,6,0,0,0,5,0,0,0,0,0,0,0,4],[4,13,0,4,4,13,0,4,4,13,0,4,4,4,4,4,4,4,3,4],[4,12,0,4,4,11,0,4,4,12,0,4,4,15,0,0,0,0,0,4],[4,4,0,4,4,4,0,4,4,4,0,4,4,4,4,4,4,4,4,4]],0,0],[[[4,4,0,4,4,4,0,4,4,4,0,4,4,4,4,4,4,4,4,4],[4,0,0,11,4,0,0,0,4,0,0,0,4,0,0,0,0,0,0,4],[4,0,0,0,4,0,0,0,4,0,0,0,4,0,0,0,0,0,0,4],[4,4,4,0,4,0,4,4,4,4,4,0,4,0,0,0,0,0,0,4],[4,0,0,0,4,0,0,0,4,0,0,0,4,0,0,0,0,0,0,4],[4,0,4,4,4,4,4,0,4,0,4,4,4,4,4,4,4,4,4,4],[4,0,0,0,4,0,0,0,4,0,0,0,0,0,0,0,17,0,16,4],[4,4,4,0,4,0,4,4,4,4,4,4,4,4,4,4,4,4,4,4],[4,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,6,0,16,4],[4,0,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4],[4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,16,4],[4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4]],0,0],[0,0,0]],[0,0,0,0,0],0,0,1,0]
#infos sur la liste "niveau": [numéro du niveau, temps, position x initiale du perso, position y initiale du perso, nombre de map, map 1, map 2,..., inventaire(objet, objet, objet, objet, position du curseur), position de la map de départ x, // // y, niveau_x, niveau_y]
nom_fichier = "fichier_level_1"
fichier = open("fichiers/"+nom_fichier, "wb") # on écrase les anciens scores
mon_pickler = pickle.Pickler(fichier)
mon_pickler.dump(level1)
fichier.close()
nom_fichier = "fichier_level_2"
fichier = open("fichiers/"+nom_fichier, "wb") # on écrase les anciens scores
mon_pickler = pickle.Pickler(fichier)
mon_pickler.dump(level2)
fichier.close()
#Fichier de sauvegarde de la progression.
save = [[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0]]
nom_fichier = "sauvegarde"
fichier = open("fichiers/"+nom_fichier, "wb") # on écrase les anciens scores
mon_pickler = pickle.Pickler(fichier)
mon_pickler.dump(save)
fichier.close()
def test_case(case_visee, level, chicken, sauvegarde):
continuer = 1
if case_visee == 9:
level.map[chicken.case_y][chicken.case_x], level.inventaire = ajoute_inventaire(9, level.inventaire)
elif case_visee == 10 :
level.map[chicken.case_y][chicken.case_x], level.inventaire = ajoute_inventaire(10, level.inventaire)
elif case_visee == 13 :
level.map[chicken.case_y][chicken.case_x], level.inventaire = ajoute_inventaire(13, level.inventaire)
elif case_visee == 14 :
level.map[chicken.case_y][chicken.case_x], level.inventaire = ajoute_inventaire(14, level.inventaire)
elif case_visee == 15 :
level.map[chicken.case_y][chicken.case_x], level.inventaire = ajoute_inventaire(15, level.inventaire)
elif case_visee == 16 :
level.map[chicken.case_y][chicken.case_x], level.inventaire = ajoute_inventaire(16, level.inventaire)
elif case_visee == 18 :
continuer = win(level, sauvegarde)
return level, continuer
def win(level, sauvegarde):
print("niveau_y",level.niveau_y, "niveau x", level.niveau_x)
sauvegarde[level.niveau_y][level.niveau_x] = 1
fichier = open("fichiers/sauvegarde", "wb") # on écrase les anciens scores
mon_pickler = pickle.Pickler(fichier)
mon_pickler.dump(sauvegarde)
fichier.close()
continuer = 0
return continuer
Merci à vous, A+
ps: @ceux qui me "connaissent": je préfère créer un topic par problème histoire que ceux qui ont besoin des mêmes infos que moi puissent les retrouver facilement.
tu peux nous zipper un code fonctionnel? en voyant comment se déroule le jeu, on verra vers où orienter l'optimisation.
par exemple, s'il n'y a pas de sprites animés, on peut optimiser la boucle des évènements; etc ...
pour commencer, il semble que fonctions.refresh_level() recharge 19 images à chaque cycle ...
ça, ça le fait pas trop hein
Et pour les 19images, ce ne sont que des petits tiles, sauf l'image de fond qui fait la taille de l'écran de la console.
1) les 19 images sont rechargées et converties à chaque évènement clavier, càd tout le temps; je pense donc que ce n'est pas rien ...
2) tu redessinnes la totalités des tiles alors qu'ils sont tous statiques ...
tes speudos sprites(puisqu'ils ne bougent pas) prennent ont au max 2 états. Tu as donc un fond statique, et des zones qui changent d'image dans ton mainloop(même pas besoin de gérer des animations).
dessines-les qu'au chargement/changement de tableau et modifies que les zones nécessaires.
en plus le fond est de la même taille que la surface de rendu, alors c'est encore plus facile ...
scr = display.set_mode(size)
scr.blit(fond,(0,0)) # blit le fond en entier qu'une seule fois
scr.blit(tile,tile_rect) # blit un tile
scr.blit(fond,tile_rect,tile_rect) # efface le tile en le remplaçant par le fond
display.update(tile_rect) # actualise qu'une ou plusieurs parties du display
J'avais mit les images dans une classe pour éviter de les charger à chaque fois qu'on bouge, ça a déjà vachement améliorer la vitesse, j'imagine pas avec cette technique
Sinon, un bug que je viens de voir: quand je reste appuyé sur une touche (sur la console), la boucle tourne moins vite: le temps passe moins vite.
Une idée d'où cela provient ?
Sinon, un bug que je viens de voir: quand je reste appuyé sur une touche (sur la console), la boucle tourne moins vite: le temps passe moins vite.
Une idée d'où cela provient ?
ceci dit, si la console est trop lente, la technique que je t'ai exposée ne fonctionnera pas non plus.
ton système pause l' exécution de façon à ce que chaque cycle ne soit pas inférieur à 1/30s, mais ça ne l'empêche pas de durer plus longtemps.
la console est lente et le code pas optimisé; lorsque tu gardes une touche enfonçée, tu charges la file d'évènement plus vite qu'elle ne se vide. Et temps que la file n'est pas vide, l' update du timing de ne fait pas. Je te conseille dans ce profil de jeu, d'utiliser event.poll() à la place de event.get().
ça n'empêchera pas la file de saturer, mais en attendant l'optimisation, le timing devrait être juste.
Pour event.poll(), je le met juste à la place de event.get(), pour le reste rien à changer ?
si pour le moment si tu ne veux pas trop modifier ton code et surtout l'indentation, remplaces juste:
for event in pygame.event.get():
par une combine:
for event in [pygame.event.poll()]:
Python c'est bon, mangez-en.
Comment optimiser un programme python/pygame ?
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Python c'est bon, mangez-en.
Python c'est bon, mangez-en.
Python c'est bon, mangez-en.
Python c'est bon, mangez-en.
Python c'est bon, mangez-en.
Python c'est bon, mangez-en.