Question

All-Time High Score: The high score is reset every time a player closes and restarts Alien Invasion. Fix this by writing the high score to a file before calling sys.exit() and reading the high score in when initializing its value in GameStats.

Short answer

Save the high score to a file before exiting and read it during game initialization to retain it between sessions.

Step-by-step solution

Identify the Problem

The game currently resets the high score each time it restarts. To fix this, we need to store the high score in a file before the game exits and then read it when the game starts.

Write the High Score to a File

Locate the section of the code where the game is about to exit and add code to save the high score to a file. Use the file handling methods in Python to open a file in write mode, save the high score, and then close the file. For example: ```python with open('high_score.txt', 'w') as file: file.write(str(high_score)) ```.

Read the High Score from the File

When initializing the high score in GameStats, use file handling to open the file containing the high score, read its value, and set it to the high score variable. Handle any potential exceptions (e.g., if the file does not exist). Example code might be: ```python try: with open('high_score.txt', 'r') as file: high_score = int(file.read()) except FileNotFoundError: high_score = 0 ```.

Integrate File Operations into the Game

Ensure that the write operation is called right before the game exits and that the read operation is correctly placed where the game initializes its stats. Adjust the placement within your overall game logic to ensure the high score is maintained between game sessions.

Key concepts

Reading and Writing Files

In Python, reading and writing files is an essential skill for working with data storage. These operations allow you to persistently keep data, such as high scores or user settings, between program execution sessions. To write to a file, you typically open it in write mode. This is done with the `open()` function, where you specify the file's name and the mode ('w' for writing). For instance:

• `with open('high_score.txt', 'w') as file:`
• `file.write(str(high_score))`

The `with` keyword ensures that the file is properly closed after writing, even if an error occurs during the process.
If you want to read data from a file, you open it in read mode ('r'). The content can then be read using methods like `read()`, `readline()`, or `readlines()`, depending on whether you need the entire file, a single line, or all lines in a list. It’s always good practice to handle situations where the file might not be found or is empty, using exception handling techniques.

Exception Handling

Exception handling is a technique used to manage errors gracefully in a program, preventing it from crashing unexpectedly. In Python, this is done using the `try-except` block.
When dealing with files, such as reading a high score from a file, several issues might arise—like the file not existing. You can handle this situation with:

• `try:`
•  `with open('high_score.txt', 'r') as file:`
•   `high_score = int(file.read())`
• `except FileNotFoundError:`
•  `high_score = 0`

In this structure, the `try` block contains code that might result in an error (like reading a file), while the `except` block outlines what to do if an error occurs. Using `FileNotFoundError`, we catch the specific error of a missing file, safely setting the high score to zero instead of crashing the program. This method makes our code robust and more user-friendly.

Persistent Data Storage

Persistent data storage is a concept where data remains accessible even after a program exits or the system restarts. This is crucial for games or applications where we want to maintain a user's progress or settings over time.
Using files is a simple way to achieve persistent storage in Python. By saving the high score to a file before the game exits, and reloading it when the game starts, users can continue from where they left off. Here’s a brief rundown of implementing this:

• Before exiting the game, write the high score to a file to save it.
• Upon starting, read the high score from the file to retrieve the saved data.
• Utilize exception handling to manage cases where the file might be missing or corrupted.

This method ensures the data is not volatile and is one of several strategies for persistent data storage, which also includes databases and cloud storage solutions. But for straightforward applications or small datasets, file storage is often sufficient and easy to implement.