在Python中为基于文本的游戏制作保存文件

Question

tl;dr in bold below

I'm currently developing a text-based adventure game, and I've implemented a basic saving system.

The process takes advantage of the 'pickle' module. It generates or appends to a file with a custom extension (when it is, in reality, a text file). The engine pickles the player's location, their inventory, and, well, the last part is where it gets a little weird.

The game loads dialog from a specially formatted script (Here I mean as in an actor's script). Some dialog changes based on certain conditions (already spoken to them before, new event, etc.). So, for that third object the engine saves, it saves ALL dialog trees in their current positions. As in, it saves the literal script in its current state.

Here is the saving routine:

with open('save.devl','wb') as file:
    pickle.dump((current_pos,player_inv,dia_dict),file)
    for room in save_map:
        pickle.dump(room,file)
    file.close()

My problem is, this process makes a very ugly, very verbose, super large text file. Now I know that text files are basically the smallest files I can generate, but I was wondering if there was any way to compress or otherwise make more efficient the process of recording the state of everything in the game. Or, less preferably but better in the long run, just a smarter way to save the player's data.

The format of dialog was requested. Here is a sample:

[Isaac]
a: Hello.|1. I'm Evan.|b|
b: Nice to meet you.|1. Where are you going?\2.Goodbye.|c,closer|
c: My cousin's wedding.|1. Interesting. Where are you from?\2. What do you know about the ship?\3. Goodbye.|e,closer|
closer: See you later.||break|
e: It's the WPT Magnus. Cruise-class zeppelin. Been in service for about three years, I believe.||c|
standing: Hello, again.|1. What do you know about the ship?\2.Goodbye.|e,closer|

The name in brackets is how the program identifies which tree to call. Each letter is a separate branch in the tree. The bars separate the branch into three parts: 1. What the character says 2. The responses you are allowed 3. Where each response goes, or if the player doesn't respond, where the player is directed afterwards.

In this example, after the player has talked to Isaac, the 'a' branch is erased from the copy of the tree that the game stores in memory. It then permanently uses the 'standing' branch.

Answer 1

Pickle itself has other protocols that are all more compact than the default protocol (protocol 0) - which is the only one "text based" - the others are binary protocols.

But them, you hardly would get more than 50% of the file size - to be able to enhance the answer, we need to know better what you are saving, and if there are smarter ways to save your data - for example, by avoiding repeating the same sub-data structure if it is present in several of your rooms. (Although if you are using object identity inside your game, Pickle should take care of that).

That said, just change your pickle.dump calls to include the protocol parameter - the -1 value is equivalent to "HIGHEST_PROTOCOL", which is usually the most efficient:

pickle.dump(room,file, protocol=-1)

(loading the pickles do not require that the protocol is passed at all)

Aditionally, you might want to use Python's zlib interface to compress pickle data. That could give you another 20-30% file size reduction - you have to chain the calls to file.write, zlib.compress and pickle.dumps, so you will be easier with a little helper code - also you need to control file offsets, as zlib is not like pickle which advances the file pointer:

import pickle, zlib 

def store_obj(file_, obj):
    compressed = zlib.compress(pickle.dumps(obj, protocol=-1), level=9)
    file_.write(len(compressed).to_bytes(4, "little"))
    file_.write(compressed)

def get_obj(file_):

     obj_size = int.from_bytes(file_.read(4), "little")
     if obj_size == 0:
         return None
     data = zlib.decompress(self.file_.read(obj_size))
     return pickle.loads(data)