X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=plomrogue-server.py;h=82e2cbc87c2823f4ce3bc1164a4b74fdc64bc4e8;hb=2ad562cb7cdf2dc2cf93c5e8996209884a2e02d9;hp=cb7f9b0cbb31b81d006330528971d99ec56a7151;hpb=21873292b1a80e842bdb7b9ac8ee763d9ab2ead5;p=plomrogue diff --git a/plomrogue-server.py b/plomrogue-server.py index cb7f9b0..82e2cbc 100755 --- a/plomrogue-server.py +++ b/plomrogue-server.py @@ -4,6 +4,45 @@ import os import shlex import shutil import time +import ctypes + + +class RandomnessIO: + """"Interface to libplomrogue's pseudo-randomness generator.""" + + def set_seed(self, seed): + libpr.seed_rrand(1, seed) + + def get_seed(self): + return libpr.seed_rrand(0, 0) + + def next(self): + return libpr.rrand() + + seed = property(get_seed, set_seed) + + +def prep_library(): + """Prepare ctypes library at ./libplomrogue.so""" + libpath = ("./libplomrogue.so") + if not os.access(libpath, os.F_OK): + raise SystemExit("No library " + libpath + ", run ./compile.sh first?") + libpr = ctypes.cdll.LoadLibrary(libpath) + libpr.seed_rrand.argtypes = [ctypes.c_uint8, ctypes.c_uint32] + libpr.seed_rrand.restype = ctypes.c_uint32 + libpr.rrand.argtypes = [] + libpr.rrand.restype = ctypes.c_uint16 + libpr.set_maplength.argtypes = [ctypes.c_uint16] + libpr.mv_yx_in_dir_legal_wrap.argtypes = [ctypes.c_char, ctypes.c_uint8, + ctypes.c_uint8] + libpr.mv_yx_in_dir_legal_wrap.restype = ctypes.c_uint8 + libpr.result_y.restype = ctypes.c_uint8 + libpr.result_x.restype = ctypes.c_uint8 + libpr.set_maplength(world_db["MAP_LENGTH"]) + libpr.build_fov_map.argtypes = [ctypes.c_uint8, ctypes.c_uint8, + ctypes.c_char_p, ctypes.c_char_p] + libpr.build_fov_map.restype = ctypes.c_uint8 + return libpr def strong_write(file, string): @@ -182,7 +221,8 @@ def save_world(): string = string + "T_ID " + str(id) + "\n" for carried_id in world_db["Things"][id]["T_CARRIES"]: string = string + "T_CARRIES " + str(carried_id) + "\n" - string = string + "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"]) + string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \ + "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"]) atomic_write(io_db["path_save"], string) @@ -232,7 +272,7 @@ def read_command(): Keep building return string until a newline is encountered. Pause between unsuccessful reads, and after too much waiting, run server_test(). """ - wait_on_fail = 1 + wait_on_fail = 0.03333 max_wait = 5 now = time.time() command = "" @@ -301,12 +341,11 @@ def try_worldstate_update(): string = write_map(string, fov) mem = world_db["Things"][0]["T_MEMMAP"][:] for i in range(2): - for memthing in world_db["Things"][0]["T_MEMTHING"]: - type = world_db["Things"][memthing[0]]["T_TYPE"] - consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"] + for mt in world_db["Things"][0]["T_MEMTHING"]: + consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"] if (i == 0 and not consumable) or (i == 1 and consumable): - c = world_db["ThingTypes"][type]["TT_SYMBOL"] - mem[(memthing[1] * length) + memthing[2]] = ord(c) + c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"] + mem[(mt[1] * length) + mt[2]] = ord(c) string = write_map(string, mem) atomic_write(io_db["path_worldstate"], string) strong_write(io_db["file_out"], "WORLD_UPDATED\n") @@ -365,8 +404,62 @@ def play_game(): def remake_map(): - # DUMMY map creator. - world_db["MAP"] = bytearray(b'.' * (world_db["MAP_LENGTH"] ** 2)) + """(Re-)make island map. + + Let "~" represent water, "." land, "X" trees: Build island shape randomly, + start with one land cell in the middle, then go into cycle of repeatedly + selecting a random sea cell and transforming it into land if it is neighbor + to land. The cycle ends when a land cell is due to be created at the map's + border. Then put some trees on the map (TODO: more precise algorithm desc). + """ + def is_neighbor(coordinates, type): + y = coordinates[0] + x = coordinates[1] + length = world_db["MAP_LENGTH"] + ind = y % 2 + diag_west = x + (ind > 0) + diag_east = x + (ind < (length - 1)) + pos = (y * length) + x + if (y > 0 and diag_east + and type == chr(world_db["MAP"][pos - length + ind])) \ + or (x < (length - 1) + and type == chr(world_db["MAP"][pos + 1])) \ + or (y < (length - 1) and diag_east + and type == chr(world_db["MAP"][pos + length + ind])) \ + or (y > 0 and diag_west + and type == chr(world_db["MAP"][pos - length - (not ind)])) \ + or (x > 0 + and type == chr(world_db["MAP"][pos - 1])) \ + or (y < (length - 1) and diag_west + and type == chr(world_db["MAP"][pos + length - (not ind)])): + return True + return False + store_seed = rand.seed + world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2)) + length = world_db["MAP_LENGTH"] + add_half_width = (not (length % 2)) * int(length / 2) + world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".") + while (1): + y = rand.next() % length + x = rand.next() % length + pos = (y * length) + x + if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."): + if y == 0 or y == (length - 1) or x == 0 or x == (length - 1): + break + world_db["MAP"][pos] = ord(".") + n_trees = int((length ** 2) / 16) + i_trees = 0 + while (i_trees <= n_trees): + single_allowed = rand.next() % 32 + y = rand.next() % length + x = rand.next() % length + pos = (y * length) + x + if "." == chr(world_db["MAP"][pos]) \ + and ((not single_allowed) or is_neighbor((y, x), "X")): + world_db["MAP"][pos] = ord("X") + i_trees += 1 + rand.seed = store_seed + # This all-too-precise replica of the original C code misses iter_limit(). def update_map_memory(t): @@ -381,17 +474,19 @@ def update_map_memory(t): if " " == chr(t["T_MEMMAP"][pos]): t["T_MEMMAP"][pos] = world_db["MAP"][pos] continue - # TODO: Aging of MEMDEPTHMAP. - for memthing in t["T_MEMTHING"]: - y = world_db["Things"][memthing[0]]["T_POSY"] - x = world_db["Things"][memthing[1]]["T_POSY"] - if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]): - t["T_MEMTHING"].remove(memthing) + if ord('0') <= t["T_MEMDEPTHMAP"][pos] \ + and ord('9') >= t["T_MEMDEPTHMAP"][pos] \ + and not rand.next() % (2 ** (t["T_MEMDEPTHMAP"][pos] - 48)): + t["T_MEMDEPTHMAP"][pos] += 1 + for mt in [mt for mt in t["T_MEMTHING"] + if "v" == chr(t["fovmap"][(mt[1] * world_db["MAP_LENGTH"]) + + mt[2]])]: + t["T_MEMTHING"].remove(mt) for id in world_db["Things"]: type = world_db["Things"][id]["T_TYPE"] if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]: y = world_db["Things"][id]["T_POSY"] - x = world_db["Things"][id]["T_POSY"] + x = world_db["Things"][id]["T_POSX"] if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]): t["T_MEMTHING"].append((type, y, x)) @@ -446,7 +541,41 @@ def setter(category, key, min, max): def build_fov_map(t): """Build Thing's FOV map.""" t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2)) - # DUMMY so far. Just builds an all-visible map. + maptype = ctypes.c_char * len(world_db["MAP"]) + test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"], + maptype.from_buffer(t["fovmap"]), + maptype.from_buffer(world_db["MAP"])) + if test: + raise RuntimeError("Malloc error in build_fov_Map().") + + +def decrement_lifepoints(t): + """Decrement t's lifepoints by 1, and if to zero, corpse it. + + If t is the player avatar, only blank its fovmap, so that the client may + still display memory data. On non-player things, erase fovmap and memory. + """ + t["T_LIFEPOINTS"] -= 1 + if 0 == t["T_LIFEPOINTS"]: + t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"] + if world_db["Things"][0] == t: + t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2)) + strong_write(io_db["file_out"], "LOG You die.\n") + else: + t["fovmap"] = False + t["T_MEMMAP"] = False + t["T_MEMDEPTHMAP"] = False + t["T_MEMTHING"] = [] + strong_write(io_db["file_out"], "LOG It dies.\n") + + +def mv_yx_in_dir_legal(dir, y, x): + """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use.""" + dir_c = dir.encode("ascii")[0] + test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x) + if -1 == test: + raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!") + return (test, libpr.result_y(), libpr.result_x()) def actor_wait(t): @@ -455,8 +584,42 @@ def actor_wait(t): strong_write(io_db["file_out"], "LOG You wait.\n") -def actor_move(Thing): - pass +def actor_move(t): + """If passable, move/collide(=attack) thing into T_ARGUMENT's direction.""" + passable = False + move_result = mv_yx_in_dir_legal(t["T_ARGUMENT"], t["T_POSY"], t["T_POSX"]) + if 1 == move_result[0]: + pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2] + passable = "." == chr(world_db["MAP"][pos]) + hitted = [id for id in world_db["Things"] + if world_db["Things"][id] != t + if world_db["Things"][id]["T_LIFEPOINTS"] + if world_db["Things"][id]["T_POSY"] == move_result[1] + if world_db["Things"][id]["T_POSX"] == move_result[2]] + if len(hitted): + hit_id = hitted[0] + hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"] + hitter = "You" if t == world_db["Things"][0] else hitter_name + hitted_type = world_db["Things"][hit_id]["T_TYPE"] + hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"] + hitted = "you" if hit_id == 0 else hitted_name + verb = " wound " if hitter == "You" else " wounds " + strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted + \ + ".\n") + decrement_lifepoints(world_db["Things"][hit_id]) + return + dir = [dir for dir in directions_db + if directions_db[dir] == t["T_ARGUMENT"]][0] + if passable: + t["T_POSY"] = move_result[1] + t["T_POSX"] = move_result[2] + for id in t["T_CARRIES"]: + world_db["Things"][id]["T_POSY"] = move_result[1] + world_db["Things"][id]["T_POSX"] = move_result[2] + build_fov_map(t) + strong_write(io_db["file_out"], "LOG You move " + dir + ".\n") + else: + strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n") def actor_pick_up(t): @@ -484,13 +647,102 @@ def actor_drop(t): t["T_CARRIES"].remove(id) world_db["Things"][id]["carried"] = False if t == world_db["Things"][0]: - print("You drop an object.") + strong_write(io_db["file_out"], "LOG You drop an object.\n") elif t == world_db["Things"][0]: - print("You try to drop an object, but you own none.") + err = "You try to drop an object, but you own none." + strong_write(io_db["file_out"], "LOG " + err + "\n") + + +def actor_use(t): + """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory.""" + # Original wrongly featured lifepoints increase through consumable! + # TODO: Handle case where T_ARGUMENT matches nothing. + if len(t["T_CARRIES"]): + id = t["T_CARRIES"][t["T_ARGUMENT"]] + type = world_db["Things"][id]["T_TYPE"] + if world_db["ThingTypes"][type]["TT_CONSUMABLE"]: + t["T_CARRIES"].remove(id) + del world_db["Things"][id] + t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"] + strong_write(io_db["file_out"], "LOG You consume this object.\n") + else: + strong_write(io_db["file_out"], "LOG You try to use this object," + + "but fail.\n") + else: + strong_write(io_db["file_out"], "LOG You try to use an object, but " + + "you own none.\n") + +def thingproliferation(t): + """To chance of 1/TT_PROLIFERATE, create t offspring in neighbor cell. -def actor_use(Thing): - pass + Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be + passable and not be inhabited by a Thing of the same type, or, if Thing is + animate, any other animate Thing. If there are several map cell candidates, + one is selected randomly. + """ + def test_cell(t, y, x): + if "." == chr(world_db["MAP"][(y * world_db["MAP_LENGTH"]) + x]): + for id in [id for id in world_db["Things"] + if y == world_db["Things"][id]["T_POSY"] + if x == world_db["Things"][id]["T_POSX"] + if (t["T_TYPE"] == world_db["Things"][id]["T_TYPE"]) + or (t["T_LIFEPOINTS"] and + world_db["Things"][id]["T_LIFEPOINTS"])]: + return False + return True + return False + prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"] + if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)): + candidates = [] + for dir in [directions_db[key] for key in directions_db]: + mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"]) + if mv_result[0] and test_cell(t, mv_result[1], mv_result[2]): + candidates.append((mv_result[1], mv_result[2])) + if len(candidates): + i = rand.next() % len(candidates) + id = id_setter(-1, "Things") + newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1])) + world_db["Things"][id] = newT + + +def try_healing(t): + """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting. + + On success, decrease satiation score by 32. + """ + if t["T_SATIATION"] > 0 \ + and t["T_LIFEPOINTS"] < \ + world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \ + and 0 == (rand.next() % 31) \ + and t["T_COMMAND"] == [id for id in world_db["ThingActions"] + if world_db["ThingActions"][id]["TA_NAME"] == + "wait"][0]: + t["T_LIFEPOINTS"] += 1 + t["T_SATIATION"] -= 32 + if t == world_db["Things"][0]: + strong_write(io_db["file_out"], "LOG You heal.\n") + else: + name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"] + strong_write(io_db["file_out"], "LOG " + name + "heals.\n") + + +def hunger(t): + """Decrement t's satiation, dependent on it trigger lifepoint dec chance.""" + if t["T_SATIATION"] > -32768: + t["T_SATIATION"] -= 1 + testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"] + if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]: + raise RuntimeError("A thing that should not hunger is hungering.") + stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]) + if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)): + if t == world_db["Things"][0]: + strong_write(io_db["file_out"], "LOG You suffer from hunger.\n") + else: + name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"] + strong_write(io_db["file_out"], "LOG " + name + \ + " suffers from hunger.\n") + decrement_lifepoints(t) def turn_over(): @@ -498,8 +750,7 @@ def turn_over(): id = 0 whilebreaker = False while world_db["Things"][0]["T_LIFEPOINTS"]: - for id in [id for id in world_db["Things"] - if world_db["Things"][id]["T_LIFEPOINTS"]]: + for id in [id for id in world_db["Things"]]: Thing = world_db["Things"][id] if Thing["T_LIFEPOINTS"]: if not Thing["T_COMMAND"]: @@ -509,7 +760,7 @@ def turn_over(): break # DUMMY: ai(thing) Thing["T_COMMAND"] = 1 - # DUMMY: try_healing + try_healing(Thing) Thing["T_PROGRESS"] += 1 taid = [a for a in world_db["ThingActions"] if a == Thing["T_COMMAND"]][0] @@ -518,14 +769,14 @@ def turn_over(): eval("actor_" + ThingAction["TA_NAME"])(Thing) Thing["T_COMMAND"] = 0 Thing["T_PROGRESS"] = 0 - # DUMMY: hunger - # DUMMY: thingproliferation + hunger(Thing) + thingproliferation(Thing) if whilebreaker: break world_db["TURN"] += 1 -def new_Thing(type): +def new_Thing(type, pos=(0,0)): """Return Thing of type T_TYPE, with fovmap if alive and world active.""" thing = { "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"], @@ -534,8 +785,8 @@ def new_Thing(type): "T_SATIATION": 0, "T_COMMAND": 0, "T_TYPE": type, - "T_POSY": 0, - "T_POSX": 0, + "T_POSY": pos[0], + "T_POSX": pos[1], "T_CARRIES": [], "carried": False, "T_MEMTHING": [], @@ -613,7 +864,7 @@ def command_thingshere(str_y, str_x): for id in world_db["Things"]: write_thing_if_here() else: - for id in world_db["Things"]["T_MEMTHING"]: + for id in world_db["Things"][0]["T_MEMTHING"]: write_thing_if_here() strong_write(io_db["file_out"], "THINGS_HERE END\n") else: @@ -633,21 +884,16 @@ def play_commander(action, args=False): if world_db["ThingActions"][x]["TA_NAME"] == action][0] world_db["Things"][0]["T_COMMAND"] = id turn_over() - # TODO: call turn_over() def set_command_and_argument_int(str_arg): val = integer_test(str_arg, 0, 255) if None != val: world_db["Things"][0]["T_ARGUMENT"] = val set_command() - else: - print("Ignoring: Argument must be integer >= 0 <=255.") def set_command_and_argument_movestring(str_arg): - dirs = {"east": "d", "south-east": "c", "south-west": "x", - "west": "s", "north-west": "w", "north-east": "e"} - if str_arg in dirs: - world_db["Things"][0]["T_ARGUMENT"] = dirs[str_arg] + if str_arg in directions_db: + world_db["Things"][0]["T_ARGUMENT"] = directions_db[str_arg] set_command() else: print("Ignoring: Argument must be valid direction string.") @@ -660,6 +906,13 @@ def play_commander(action, args=False): return set_command +def command_seedrandomness(seed_string): + """Set rand seed to int(seed_string).""" + val = integer_test(seed_string, 0, 4294967295) + if None != val: + rand.seed = val + + def command_seedmap(seed_string): """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map.""" setter(None, "SEED_MAP", 0, 4294967295)(seed_string) @@ -669,16 +922,41 @@ def command_seedmap(seed_string): def command_makeworld(seed_string): """(Re-)build game world, i.e. map, things, to a new turn 1 from seed. - Make seed world_db["SEED_RANDOMNESS"] and world_db["SEED_MAP"]. Do more - only with a "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType - of TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map() + Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a + "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of + TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map() and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each other. Init player's memory map. Write "NEW_WORLD" line to out file. """ - setter(None, "SEED_RANDOMNESS", 0, 4294967295)(seed_string) - setter(None, "SEED_MAP", 0, 4294967295)(seed_string) + + def free_pos(): + i = 0 + while 1: + err = "Space to put thing on too hard to find. Map too small?" + while 1: + y = rand.next() % world_db["MAP_LENGTH"] + x = rand.next() % world_db["MAP_LENGTH"] + if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]): + break + i += 1 + if i == 65535: + raise SystemExit(err) + # Replica of C code, wrongly ignores animatedness of new Thing. + pos_clear = (0 == len([id for id in world_db["Things"] + if world_db["Things"][id]["T_LIFEPOINTS"] + if world_db["Things"][id]["T_POSY"] == y + if world_db["Things"][id]["T_POSX"] == x])) + if pos_clear: + break + return (y, x) + + val = integer_test(seed_string, 0, 4294967295) + if None == val: + return + rand.seed = val + world_db["SEED_MAP"] = val player_will_be_generated = False playertype = world_db["PLAYER_TYPE"] for ThingType in world_db["ThingTypes"]: @@ -704,23 +982,24 @@ def command_makeworld(seed_string): world_db["TURN"] = 1 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]): id = id_setter(-1, "Things") - world_db["Things"][id] = new_Thing(playertype) - # TODO: Positioning. + world_db["Things"][id] = new_Thing(playertype, free_pos()) update_map_memory(world_db["Things"][0]) for type in world_db["ThingTypes"]: for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]): if type != playertype: id = id_setter(-1, "Things") - world_db["Things"][id] = new_Thing(type) - # TODO: Positioning. + world_db["Things"][id] = new_Thing(type, free_pos()) strong_write(io_db["file_out"], "NEW_WORLD\n") def command_maplength(maplength_string): """Redefine map length. Invalidate map, therefore lose all things on it.""" - set_world_inactive() - world_db["Things"] = {} - setter(None, "MAP_LENGTH", 1, 256)(maplength_string) + val = integer_test(maplength_string, 1, 256) + if None != val: + world_db["MAP_LENGTH"] = val + set_world_inactive() + world_db["Things"] = {} + libpr.set_maplength(val) def command_worldactive(worldactive_string): @@ -995,8 +1274,7 @@ commands_db = { "THINGS_HERE": (2, True, command_thingshere), "MAKE_WORLD": (1, False, command_makeworld), "SEED_MAP": (1, False, command_seedmap), - "SEED_RANDOMNESS": (1, False, setter(None, "SEED_RANDOMNESS", - 0, 4294967295)), + "SEED_RANDOMNESS": (1, False, command_seedrandomness), "TURN": (1, False, setter(None, "TURN", 0, 65535)), "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)), "MAP_LENGTH": (1, False, command_maplength), @@ -1036,11 +1314,10 @@ commands_db = { } -"""World state database. With sane default values.""" +"""World state database. With sane default values. (Randomness is in rand.)""" world_db = { "TURN": 0, "SEED_MAP": 0, - "SEED_RANDOMNESS": 0, "PLAYER_TYPE": 0, "MAP_LENGTH": 64, "WORLD_ACTIVE": 0, @@ -1049,6 +1326,9 @@ world_db = { "Things": {} } +"""Mapping of direction names to internal direction chars.""" +directions_db = {"east": "d", "south-east": "c", "south-west": "x", + "west": "s", "north-west": "w", "north-east": "e"} """File IO database.""" io_db = { @@ -1066,6 +1346,8 @@ io_db = { try: + libpr = prep_library() + rand = RandomnessIO() opts = parse_command_line_arguments() setup_server_io() if None != opts.replay: