D'enregistrer le meilleur score pour un jeu python

Vous pouvez utiliser le pickle module d'enregistrement des variables sur le disque, puis de les recharger.

Exemple:

import pickle

# load the previous score if it exists
try:
    with open('score.dat', 'rb') as file:
        score = pickle.load(file)
except:
    score = 0

print "High score: %d" % score

# your game code goes here
# let's say the user scores a new high-score of 10
score = 10;

# save the score
with open('score.dat', 'wb') as file:
    pickle.dump(score, file)

Cela permet d'économiser une seule partition sur le disque. La bonne chose à propos de cornichon, c'est que vous pouvez facilement étendre à enregistrer plusieurs partitions il suffit de changer scores être un tableau au lieu d'une valeur unique. pickle permettra d'économiser assez bien n'importe quel type de variable que vous lui lancez.

OriginalL'auteur Blorgbeard

Vous pouvez utiliser une dict à tenir votre highscore et il suffit d'écrire dans un fichier:

def store_highscore_in_file(dictionary, fn = "./high.txt", top_n=0):
    """Store the dict into a file, only store top_n highest values."""
    with open(fn,"w") as f:
        for idx,(name,pts) in enumerate(sorted(dictionary.items(), key= lambda x:-x[1])):
            f.write(f"{name}:{pts}\n")
            if top_n and idx == top_n-1:
                break

def load_highscore_from_file(fn = "./high.txt"):
    """Retrieve dict from file"""
    hs = {}
    try:
        with open(fn,"r") as f:
            for line in f:
                name,_,points = line.partition(":")
                if name and points:
                    hs[name]=int(points)
    except FileNotFoundError:
        return {}
    return hs

Utilisation:

# file does not exist
k = load_highscore_from_file()
print(k)

# add some highscores to dict
k["p"]=10
k["a"]=110
k["k"]=1110
k["l"]=1022 
print(k)

# store file, only top 3
store_highscore_in_file(k, top_n=3)

# load back into new dict
kk = load_highscore_from_file()
print(kk)

De sortie:

{} # no file
{'p': 10, 'a': 110, 'k': 1110, 'l': 1022} # before storing top 3 
{'k': 1110, 'l': 1022, 'a': 110} # after loading the top 3 file again

OriginalL'auteur Patrick Artner

J'ai l'habitude de stocker les noms des joueurs et les high scores comme une liste de listes (par exemple [['Joe', 50], ['Sarah', 230], ['Carl', 120]]), parce que vous pouvez les trier et les couper en tranches (par exemple, si il devrait y avoir un maximum de 10 entrées). Vous pouvez sauvegarder et charger la liste avec le json module (json.dump et json.load) ou avec de la saumure.

import json
from operator import itemgetter
import pygame as pg
from pygame import freetype
pg.init()
BG_COLOR = pg.Color('gray12')
BLUE = pg.Color('dodgerblue')
FONT = freetype.Font(None, 24)
def save(highscores):
with open('highscores.json', 'w') as file:
json.dump(highscores, file)  # Write the list to the json file.
def load():
try:
with open('highscores.json', 'r') as file:
highscores = json.load(file)  # Read the json file.
except FileNotFoundError:
return []  # Return an empty list if the file doesn't exist.
# Sorted by the score.
return sorted(highscores, key=itemgetter(1), reverse=True)
def main():
screen = pg.display.set_mode((640, 480))
clock = pg.time.Clock()
highscores = load()  # Load the json file.
while True:
for event in pg.event.get():
if event.type == pg.QUIT:
return
elif event.type == pg.KEYDOWN:
if event.key == pg.K_s:
# Save the sorted the list when 's' is pressed.
# Append a new high-score (omitted in this example).
# highscores.append([name, score])
save(sorted(highscores, key=itemgetter(1), reverse=True))
screen.fill((30, 30, 50))
# Display the high-scores.
for y, (hi_name, hi_score) in enumerate(highscores):
FONT.render_to(screen, (100, y*30+40), f'{hi_name} {hi_score}', BLUE)
pg.display.flip()
clock.tick(60)
if __name__ == '__main__':
main()
pg.quit()

La highscores.json fichier serait alors ressembler à ceci:

[["Sarah", 230], ["Carl", 120], ["Joe", 50]]

OriginalL'auteur skrx