X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=plomrogue-server.py;h=25e2ce41d7f1147c00fb2df46a02a545d2457d3f;hb=4be8ae687c8adf786c6099c8b8beedf15425a488;hp=8c926526df5dcbc2d1d53b34ab40647a27d31272;hpb=f216ec2fd2f4e826e1318691686131afcb5b0c09;p=plomrogue diff --git a/plomrogue-server.py b/plomrogue-server.py index 8c92652..25e2ce4 100755 --- a/plomrogue-server.py +++ b/plomrogue-server.py @@ -56,10 +56,10 @@ def obey(command, prefix, replay=False, do_record=False): The command string is tokenized by shlex.split(comments=True). If replay is set, a non-meta command from the commands_db merely triggers obey() on the - next command from the records file. Non-meta commands are recorded in - non-replay mode if do_record is set. The prefix string is inserted into the - server's input message between its beginning 'input ' and ':'. All activity - is preceded by a call to server_test(). + next command from the records file. If not, and do do_record is set, + non-meta commands are recorded via record(), and save_world() is called. + The prefix string is inserted into the server's input message between its + beginning 'input ' & ':'. All activity is preceded by a server_test() call. """ server_test() print("input " + prefix + ": " + command) @@ -69,7 +69,7 @@ def obey(command, prefix, replay=False, do_record=False): print("Can't tokenize command string: " + str(err) + ".") return if len(tokens) > 0 and tokens[0] in commands_db \ - and len(tokens) >= commands_db[tokens[0]][0] + 1: + and len(tokens) == commands_db[tokens[0]][0] + 1: if commands_db[tokens[0]][1]: commands_db[tokens[0]][2]() elif replay: @@ -82,29 +82,47 @@ def obey(command, prefix, replay=False, do_record=False): else: print("Reached end of record file.") else: - commands_db[tokens[0]][2]() + commands_db[tokens[0]][2](*tokens[1:]) if do_record: record(command) + save_world() else: print("Invalid command/argument, or bad number of tokens.") +def atomic_write(path, text, do_append=False): + """Atomic write of text to file at path, appended if do_append is set.""" + path_tmp = path + io_db["tmp_suffix"] + mode = "w" + if do_append: + mode = "a" + if os.access(path, os.F_OK): + shutil.copyfile(path, path_tmp) + file = open(path_tmp, mode) + file.write(text) + file.flush() + os.fsync(file.fileno()) + file.close() + if os.access(path, os.F_OK): + os.remove(path) + os.rename(path_tmp, path) + + def record(command): """Append command string plus newline to record file. (Atomic.)""" # This misses some optimizations from the original record(), namely only # finishing the atomic write with expensive flush() and fsync() every 15 # seconds unless explicitely forced. Implement as needed. - path_tmp = io_db["path_record"] + io_db["tmp_suffix"] - if os.access(io_db["path_record"], os.F_OK): - shutil.copyfile(io_db["path_record"], path_tmp) - file = open(path_tmp, "a") - file.write(command + "\n") - file.flush() - os.fsync(file.fileno()) - file.close() - if os.access(io_db["path_record"], os.F_OK): - os.remove(io_db["path_record"]) - os.rename(path_tmp, io_db["path_record"]) + atomic_write(io_db["path_record"], command + "\n", do_append=True) + + +def save_world(): + # Dummy for saving all commands to reconstruct current world state. + # Misses same optimizations as record() from the original record(). + atomic_write(io_db["path_save"], + "TURN " + str(world_db["TURN"]) + "\n" + + "SEED_RANDOMNESS " + str(world_db["SEED_RANDOMNESS"]) + "\n" + + "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n") def obey_lines_in_file(path, name, do_record=False): @@ -186,9 +204,9 @@ def replay_game(): if not os.access(io_db["path_record"], os.F_OK): raise SystemExit("No record file found to replay.") io_db["file_record"] = open(io_db["path_record"], "r") - io_db["file_record"].prefix = "recod file line " + io_db["file_record"].prefix = "record file line " io_db["file_record"].line_n = 1 - while world_db["turn"] < opts.replay: + while world_db["TURN"] < opts.replay: line = io_db["file_record"].readline() if "" == line: break @@ -219,11 +237,6 @@ def play_game(): obey(read_command(), "in file", do_record=True) -def command_makeworld(): - """Mere dummy so far.""" - print("I would build a whole world now if only I knew how.") - - def command_ping(): """Send PONG line to server output file.""" io_db["file_out"].write("PONG\n") @@ -235,6 +248,35 @@ def command_quit(): raise SystemExit("received QUIT command") +def command_turn(turn_string): + """Set turn to what's described in turn_string.""" + min = 0 + max = 65535 + try: + turn = int(turn_string) + if turn < min or turn > max: + raise ValueError + world_db["TURN"] = turn + except ValueError: + print("Ignoring: Please use integer >= " + str(min) + " and <= " + + "str(max)+ '.") + + +def command_makeworld(seed_string): + # Mere dummy so far. + min = 0 + max = 4294967295 + try: + seed = int(seed_string) + if seed < min or seed > max: + raise ValueError + world_db["SEED_RANDOMNESS"] = seed + world_db["SEED_MAP"] = seed + except ValueError: + print("Ignoring: Please use integer >= " + str(min) + " and <= " + + "str(max) '.") + + """Commands database. Map command start tokens to ([0]) minimum number of expected command arguments, @@ -245,13 +287,16 @@ function to be called on it. commands_db = { "QUIT": (0, True, command_quit), "PING": (0, True, command_ping), - "MAKE_WORLD": (1, False, command_makeworld) + "MAKE_WORLD": (1, False, command_makeworld), + "TURN": (1, False, command_turn) } """World state database,""" world_db = { - "turn": 0 + "TURN": 0, + "SEED_MAP": 0, + "SEED_RANDOMNESS": 0 }